postgres.c

/*
 * This file is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2,
 * as published by the Free Software Foundation.
 *
 * In addition to the permissions in the GNU General Public License,
 * the authors give you unlimited permission to link the compiled
 * version of this file into combinations with other programs,
 * and to distribute those combinations without any restriction
 * coming from the use of this file.  (The General Public License
 * restrictions do apply in other respects; for example, they cover
 * modification of the file, and distribution when not linked into
 * a combined executable.)
 *
 * This file is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; see the file COPYING.  If not, write to
 * the Free Software Foundation, 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */
 
#include <assert.h>
#include <string.h>
#include <git2.h>
#include <git2/odb_backend.h>
#include <postgresql/libpq-fe.h>

#define GIT2_TABLE_NAME "git2_odb"
#define GIT2_SCHEMA_NAME "git2"

typedef struct {
	git_odb_backend parent;
	PGconn *db;
} postgres_backend;

int postgres_backend__read_header(size_t *len_p, git_otype *type_p, git_odb_backend *_backend, const git_oid *oid)
{
	postgres_backend *backend;
	int error;
	PGresult *result;

	assert(len_p && type_p && _backend && oid);

	backend = (postgres_backend *)_backend;
	error = GIT_ERROR;
	
	result = PQexecParams(backend->db, "SELECT type, size FROM " GIT2_SCHEMA_NAME "." GIT2_TABLE_NAME " WHERE oid = $1;", 1, NULL, (const char**)(&(oid->id)), NULL, NULL, 0);
	if(PQresultStatus(result) != PGRES_TUPLES_OK){
		return GIT_ERROR;
	}
	
	if(PQntuples(result) < 1){
		error = GIT_ENOTFOUND;
	}
	else{
		assert(PQntuples(result) == 1);
		
		*type_p = (git_otype)strtol(PQgetvalue(result, 0, 0), NULL, 10);
		*len_p = (git_otype)strtol(PQgetvalue(result, 0, 1), NULL, 10);
		error = GIT_SUCCESS;
	}

	PQclear(result);
	return error;
}

int postgres_backend__read(void **data_p, size_t *len_p, git_otype *type_p, git_odb_backend *_backend, const git_oid *oid)
{
	postgres_backend *backend;
	int error;
	PGresult *result;

	assert(data_p && len_p && type_p && _backend && oid);

	backend = (postgres_backend *)_backend;
	error = GIT_ERROR;

	result = PQexecParams(backend->db, "SELECT type, size, data FROM " GIT2_SCHEMA_NAME "." GIT2_TABLE_NAME " WHERE oid = $1;", 1, NULL, (const char**)(&(oid->id)), NULL, NULL, 0);
	if(PQresultStatus(result) != PGRES_TUPLES_OK){
		return GIT_ERROR;
	}
	
	if(PQntuples(result) < 1){
		error = GIT_ENOTFOUND;
	}
	else{
		assert(PQntuples(result) == 1);
		
		*type_p = (git_otype)strtol(PQgetvalue(result, 0, 0), NULL, 10);
		*len_p = (git_otype)strtol(PQgetvalue(result, 0, 1), NULL, 10);
		*data_p = malloc(*len_p);

		if (*data_p == NULL) {
			error = GIT_ENOMEM;
		} else {
			memcpy(*data_p, PQgetvalue(result, 0, 2), *len_p);
			error = GIT_SUCCESS;
		}
		
		error = GIT_SUCCESS;
	}

	PQclear(result);
	return error;
}

int postgres_backend__read_prefix(git_oid *out_oid, void **data_p, size_t *len_p, git_otype *type_p, git_odb_backend *_backend,
					const git_oid *short_oid, unsigned int len) {
	if (len >= GIT_OID_HEXSZ) {
		/* Just match the full identifier */
		int error = postgres_backend__read(data_p, len_p, type_p, _backend, short_oid);
		if (error == GIT_SUCCESS)
			git_oid_cpy(out_oid, short_oid);

		return error;
	} else if (len < GIT_OID_HEXSZ) {
		return GIT_ENOTIMPLEMENTED;
	}
}

int postgres_backend__exists(git_odb_backend *_backend, const git_oid *oid)
{
	postgres_backend *backend;
	int found;
	PGresult *result;

	assert(_backend && oid);

	backend = (postgres_backend *)_backend;
	found = 0;
	
	result = PQexecParams(backend->db, "SELECT type, size, data FROM " GIT2_SCHEMA_NAME "." GIT2_TABLE_NAME " WHERE oid = $1;", 1, NULL, (const char**)(&(oid->id)), NULL, NULL, 0);
	if(PQresultStatus(result) != PGRES_TUPLES_OK){
		return GIT_ERROR;
	}

	if(PQntuples(result) > 0){
		found = 1;
	}

	PQclear(result);
	return found;
}

int postgres_backend__write(git_oid *id, git_odb_backend *_backend, const void *data, size_t len, git_otype type)
{
	int error;
	postgres_backend *backend;
	PGresult *result;
	
	//this is a rather ugly construct to avoid having to know about postgres' internal integer representation
	char type_str[128];
	char size_str[128];
	
	const char *values[4] = {(char*)id->id, type_str, size_str, (char*)data};
	const int lengths[4] = {0, 0, 0, len};
	const int formats[4] = {0, 0, 0, 1};
	
	assert(id && _backend && data);

	backend = (postgres_backend *)_backend;

	if ((error = git_odb_hash(id, data, len, type)) < 0)
		return error;

	snprintf(type_str, sizeof(type_str), "%d", type);
	snprintf(size_str, sizeof(size_str), "%d", len);
	
	result = PQexecParams(backend->db, "INSERT INTO " GIT2_SCHEMA_NAME "." GIT2_TABLE_NAME " VALUES ($1, $2, $3, $4);", 4, NULL, values, lengths, formats, 0);

	error = PQresultStatus(result);
	PQclear(result);
	
	return (error == PGRES_COMMAND_OK || error == PGRES_TUPLES_OK) ? GIT_SUCCESS : GIT_ERROR;
}

void postgres_backend__free(git_odb_backend *_backend)
{
	postgres_backend *backend;
	assert(_backend);
	backend = (postgres_backend *)_backend;

	PQfinish(backend->db);

	free(backend);
}

static int create_table(PGconn *db)
{
	PGresult *result;
	
	//This should use CREATE SCHEMA IF NOT EXISTS, but that was added in Postgres 9.3
	static const char *schema_create = 
		"CREATE SCHEMA " GIT2_SCHEMA_NAME;
	
	//FIXME: using bytea for BLOBs might have some implications on the
	//need to escape/unescape data before writes / after reads.
	//However, it might well be that this is already handled by sending
	//the parameter as binary. This should be tested in postgres_backend__write
	static const char *sql_creat =
		"CREATE TABLE " GIT2_SCHEMA_NAME "." GIT2_TABLE_NAME " ("
		"oid TEXT PRIMARY KEY NOT NULL,"
		"type INTEGER NOT NULL,"
		"size INTEGER NOT NULL,"
		"data bytea);";

	result = PQexec(db, schema_create);
	if(PQresultStatus(result) != PGRES_COMMAND_OK && PQresultStatus(result) != PGRES_TUPLES_OK){
		return GIT_ERROR;
	}
	
	result = PQexec(db, sql_creat);
	if(PQresultStatus(result) != PGRES_COMMAND_OK && PQresultStatus(result) != PGRES_TUPLES_OK){
		return GIT_ERROR;
	}

	return GIT_SUCCESS;
}

static int init_db(PGconn *db)
{
	PGresult *result;
	static const char *sql_check = "SELECT EXISTS ( SELECT 1 FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace "
							" WHERE n.nspname = '"GIT2_SCHEMA_NAME"' AND c.relname = '"GIT2_TABLE_NAME"' AND c.relkind = 'r');";
	
	result = PQexec(db, sql_check);
	if(PQresultStatus(result) != PGRES_TUPLES_OK || PQntuples(result) < 1){
		PQclear(result);
		return create_table(db);
	}
	
	return GIT_SUCCESS;
}

int pq_connect(PGconn **db, const char *host, unsigned port, const char *dbname, const char *user, const char *password){
	char port_str[10];
	
	snprintf(port_str, sizeof(port_str), "%d", port);

	//This allows the application to use the .pgpass mechanism by supplying a NULL password
	char const *keywords[] = {"host", "port", "dbname", "user",  (password) ? "password":NULL,  NULL};
	const char *values[] = {host, port_str, dbname, user, password, NULL};

	*db = PQconnectdbParams(keywords, (char const**)values, 0);

	if(!(*db)){
		return 1;
	}

	if(PQstatus(*db) != CONNECTION_OK){
		PQfinish(*db);
		return 1;
	}

	return 0;
}

int git_odb_backend_postgres(git_odb_backend **backend_out, const char *pg_host,
        const char *pg_user, const char *pg_passwd, const char *pg_db, unsigned int pg_port)
{
	postgres_backend *backend;
	int error;

	backend = calloc(1, sizeof(postgres_backend));
	if (backend == NULL)
		return GIT_ENOMEM;

	if(pq_connect(&(backend->db), pg_host, pg_port, pg_db, pg_user, pg_passwd)){
		goto cleanup;
	}

	// check for and possibly create the database
	error = init_db(backend->db);
	if (error < 0)
		goto cleanup;

	backend->parent.read = &postgres_backend__read;
	backend->parent.read_header = &postgres_backend__read_header;
	backend->parent.write = &postgres_backend__write;
	backend->parent.exists = &postgres_backend__exists;
	backend->parent.free = &postgres_backend__free;

	*backend_out = (git_odb_backend *)backend;
	return GIT_SUCCESS;

	cleanup:
		postgres_backend__free((git_odb_backend *)backend);
		return GIT_ERROR;
}