/*
- * Bacula Catalog Database routines specific to PostgreSQL
- * These are PostgreSQL specific routines
- *
- * Dan Langille, December 2003
- * based upon work done by Kern Sibbald, March 2000
- *
- * Version $Id$
- */
+ Bacula® - The Network Backup Solution
-/*
- Copyright (C) 2003-2005 Kern Sibbald
+ Copyright (C) 2003-2007 Free Software Foundation Europe e.V.
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public License as
- published by the Free Software Foundation; either version 2 of
- the License, or (at your option) any later version.
+ The main author of Bacula is Kern Sibbald, with contributions from
+ many others, a complete list can be found in the file AUTHORS.
+ This program is Free Software; you can redistribute it and/or
+ modify it under the terms of version two of the GNU General Public
+ License as published by the Free Software Foundation and included
+ in the file LICENSE.
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
+ This program 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; if not, write to the Free
- Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
- MA 02111-1307, USA.
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301, USA.
+ Bacula® is a registered trademark of John Walker.
+ The licensor of Bacula is the Free Software Foundation Europe
+ (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
+ Switzerland, email:ftf@fsfeurope.org.
+*/
+/*
+ * Bacula Catalog Database routines specific to PostgreSQL
+ * These are PostgreSQL specific routines
+ *
+ * Dan Langille, December 2003
+ * based upon work done by Kern Sibbald, March 2000
+ *
+ * Version $Id$
*/
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+/*
+ * Retrieve database type
+ */
+const char *
+db_get_type(void)
+{
+ return "PostgreSQL";
+
+}
+
/*
* Initialize database data structure. In principal this should
* never have errors, or it is really fatal.
if (!mult_db_connections) {
/* Look to see if DB already open */
for (mdb=NULL; (mdb=(B_DB *)qnext(&db_list, &mdb->bq)); ) {
- if (strcmp(mdb->db_name, db_name) == 0) {
+ if (bstrcmp(mdb->db_name, db_name) &&
+ bstrcmp(mdb->db_address, db_address) &&
+ mdb->db_port == db_port) {
Dmsg2(100, "DB REopen %d %s\n", mdb->ref_count, db_name);
mdb->ref_count++;
V(mutex);
mdb->fname = get_pool_memory(PM_FNAME);
mdb->path = get_pool_memory(PM_FNAME);
mdb->esc_name = get_pool_memory(PM_FNAME);
+ mdb->esc_path = get_pool_memory(PM_FNAME);
mdb->allow_transactions = mult_db_connections;
qinsert(&db_list, &mdb->bq); /* put db in list */
V(mutex);
int errstat;
char buf[10], *port;
+#ifdef xxx
+ if (!PQisthreadsafe()) {
+ Jmsg(jcr, M_ABORT, 0, _("PostgreSQL configuration problem. "
+ "PostgreSQL library is not thread safe. Connot continue.\n"));
+ }
+#endif
P(mutex);
if (mdb->connected) {
V(mutex);
mdb->connected = false;
if ((errstat=rwl_init(&mdb->lock)) != 0) {
+ berrno be;
Mmsg1(&mdb->errmsg, _("Unable to initialize DB lock. ERR=%s\n"),
- strerror(errstat));
+ be.bstrerror(errstat));
V(mutex);
return 0;
}
return 0;
}
+ mdb->connected = true;
+
if (!check_tables_version(jcr, mdb)) {
V(mutex);
return 0;
}
- mdb->connected = true;
+ sql_query(mdb, "SET datestyle TO 'ISO, YMD'");
+
V(mutex);
return 1;
}
}
db_end_transaction(jcr, mdb);
P(mutex);
+ sql_free_result(mdb);
mdb->ref_count--;
if (mdb->ref_count == 0) {
qdchain(&mdb->bq);
free_pool_memory(mdb->fname);
free_pool_memory(mdb->path);
free_pool_memory(mdb->esc_name);
+ free_pool_memory(mdb->esc_path);
if (mdb->db_name) {
free(mdb->db_name);
}
if (mdb->db_socket) {
free(mdb->db_socket);
}
- my_postgresql_free_result(mdb);
free(mdb);
}
V(mutex);
}
+void db_thread_cleanup()
+{ }
+
/*
* Return the next unique index (auto-increment) for
* the given table. Return NULL on error.
Dmsg0(500, "my_postgresql_fetch_row start\n");
- if (mdb->row_number == -1 || mdb->row == NULL) {
+ if (!mdb->row || mdb->row_size < mdb->num_fields) {
Dmsg1(500, "we have need space of %d bytes\n", sizeof(char *) * mdb->num_fields);
- if (mdb->row != NULL) {
+ if (mdb->row) {
Dmsg0(500, "my_postgresql_fetch_row freeing space\n");
free(mdb->row);
- mdb->row = NULL;
}
-
mdb->row = (POSTGRESQL_ROW) malloc(sizeof(char *) * mdb->num_fields);
+ mdb->row_size = mdb->num_fields;
// now reset the row_number now that we have the space allocated
mdb->row_number = 0;
int i;
Dmsg0(500, "my_postgresql_fetch_field starts\n");
- if (mdb->fields == NULL) {
+
+ if (!mdb->fields || mdb->fields_size < mdb->num_fields) {
+ if (mdb->fields) {
+ free(mdb->fields);
+ }
Dmsg1(500, "allocating space for %d fields\n", mdb->num_fields);
mdb->fields = (POSTGRESQL_FIELD *)malloc(sizeof(POSTGRESQL_FIELD) * mdb->num_fields);
+ mdb->fields_size = mdb->num_fields;
for (i = 0; i < mdb->num_fields; i++) {
Dmsg1(500, "filling field %d\n", i);
/*
* Note, if this routine returns 1 (failure), Bacula expects
* that no result has been stored.
+ * This is where QUERY_DB comes with Postgresql.
+ *
+ * Returns: 0 on success
+ * 1 on failure
+ *
*/
-int my_postgresql_query(B_DB *mdb, const char *query) {
+int my_postgresql_query(B_DB *mdb, const char *query)
+{
Dmsg0(500, "my_postgresql_query started\n");
// We are starting a new query. reset everything.
mdb->num_rows = -1;
mdb->row_number = -1;
mdb->field_number = -1;
- if (mdb->result != NULL) {
+ if (mdb->result) {
PQclear(mdb->result); /* hmm, someone forgot to free?? */
+ mdb->result = NULL;
}
Dmsg1(500, "my_postgresql_query starts with '%s'\n", query);
- mdb->result = PQexec(mdb->db, query);
+
+ for (int i=0; i < 10; i++) {
+ mdb->result = PQexec(mdb->db, query);
+ if (mdb->result) {
+ break;
+ }
+ bmicrosleep(5, 0);
+ }
+ if (!mdb->result) {
+ Dmsg1(50, "Query failed: %s\n", query);
+ goto bail_out;
+ }
+
mdb->status = PQresultStatus(mdb->result);
if (mdb->status == PGRES_TUPLES_OK || mdb->status == PGRES_COMMAND_OK) {
Dmsg1(500, "we have a result\n", query);
// how many fields in the set?
- mdb->num_fields = (int) PQnfields(mdb->result);
+ mdb->num_fields = (int)PQnfields(mdb->result);
Dmsg1(500, "we have %d fields\n", mdb->num_fields);
- mdb->num_rows = PQntuples(mdb->result);
+ mdb->num_rows = PQntuples(mdb->result);
Dmsg1(500, "we have %d rows\n", mdb->num_rows);
- mdb->status = 0;
+ mdb->status = 0; /* succeed */
} else {
- Dmsg1(500, "we failed\n", query);
- mdb->status = 1;
+ Dmsg1(50, "Result status failed: %s\n", query);
+ goto bail_out;
}
Dmsg0(500, "my_postgresql_query finishing\n");
+ return mdb->status;
+bail_out:
+ Dmsg1(500, "we failed\n", query);
+ PQclear(mdb->result);
+ mdb->result = NULL;
+ mdb->status = 1; /* failed */
return mdb->status;
}
-void my_postgresql_free_result (B_DB *mdb)
+void my_postgresql_free_result(B_DB *mdb)
{
+
+ db_lock(mdb);
if (mdb->result) {
PQclear(mdb->result);
mdb->result = NULL;
free(mdb->fields);
mdb->fields = NULL;
}
+ db_unlock(mdb);
}
int my_postgresql_currval(B_DB *mdb, char *table_name)
bstrncat(sequence, "_seq", sizeof(sequence));
bsnprintf(query, sizeof(query), "SELECT currval('%s')", sequence);
-// Mmsg(query, "SELECT currval('%s')", sequence);
Dmsg1(500, "my_postgresql_currval invoked with '%s'\n", query);
- result = PQexec(mdb->db, query);
+ for (int i=0; i < 10; i++) {
+ result = PQexec(mdb->db, query);
+ if (result) {
+ break;
+ }
+ bmicrosleep(5, 0);
+ }
+ if (!result) {
+ Dmsg1(50, "Query failed: %s\n", query);
+ goto bail_out;
+ }
Dmsg0(500, "exec done");
id = atoi(PQgetvalue(result, 0, 0));
Dmsg2(500, "got value '%s' which became %d\n", PQgetvalue(result, 0, 0), id);
} else {
+ Dmsg1(50, "Result status failed: %s\n", query);
Mmsg1(&mdb->errmsg, _("error fetching currval: %s\n"), PQerrorMessage(mdb->db));
}
+bail_out:
PQclear(result);
return id;
}
+int my_postgresql_batch_start(JCR *jcr, B_DB *mdb)
+{
+ char *query = "COPY batch FROM STDIN";
+
+ Dmsg0(500, "my_postgresql_batch_start started\n");
+
+ if (my_postgresql_query(mdb,
+ " CREATE TEMPORARY TABLE batch "
+ " (fileindex int, "
+ " jobid int, "
+ " path varchar, "
+ " name varchar, "
+ " lstat varchar, "
+ " md5 varchar)") == 1)
+ {
+ Dmsg0(500, "my_postgresql_batch_start failed\n");
+ return 1;
+ }
+
+ // We are starting a new query. reset everything.
+ mdb->num_rows = -1;
+ mdb->row_number = -1;
+ mdb->field_number = -1;
+
+ my_postgresql_free_result(mdb);
+
+ for (int i=0; i < 10; i++) {
+ mdb->result = PQexec(mdb->db, query);
+ if (mdb->result) {
+ break;
+ }
+ bmicrosleep(5, 0);
+ }
+ if (!mdb->result) {
+ Dmsg1(50, "Query failed: %s\n", query);
+ goto bail_out;
+ }
+
+ mdb->status = PQresultStatus(mdb->result);
+ if (mdb->status == PGRES_COPY_IN) {
+ // how many fields in the set?
+ mdb->num_fields = (int) PQnfields(mdb->result);
+ mdb->num_rows = 0;
+ mdb->status = 1;
+ } else {
+ Dmsg1(50, "Result status failed: %s\n", query);
+ goto bail_out;
+ }
+
+ Dmsg0(500, "my_postgresql_batch_start finishing\n");
+
+ return mdb->status;
+
+bail_out:
+ mdb->status = 0;
+ PQclear(mdb->result);
+ mdb->result = NULL;
+ return mdb->status;
+}
+
+/* set error to something to abort operation */
+int my_postgresql_batch_end(JCR *jcr, B_DB *mdb, const char *error)
+{
+ int res;
+ int count=30;
+ Dmsg0(500, "my_postgresql_batch_end started\n");
+
+ if (!mdb) { /* no files ? */
+ return 0;
+ }
+
+ do {
+ res = PQputCopyEnd(mdb->db, error);
+ } while (res == 0 && --count > 0);
+
+ if (res == 1) {
+ Dmsg0(500, "ok\n");
+ mdb->status = 1;
+ }
+
+ if (res <= 0) {
+ Dmsg0(500, "we failed\n");
+ mdb->status = 0;
+ Mmsg1(&mdb->errmsg, _("error ending batch mode: %s\n"), PQerrorMessage(mdb->db));
+ }
+
+ Dmsg0(500, "my_postgresql_batch_end finishing\n");
+
+ return mdb->status;
+}
+
+int my_postgresql_batch_insert(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
+{
+ int res;
+ int count=30;
+ size_t len;
+ char *digest;
+ char ed1[50];
+
+ mdb->esc_name = check_pool_memory_size(mdb->esc_name, mdb->fnl*2+1);
+ my_postgresql_copy_escape(mdb->esc_name, mdb->fname, mdb->fnl);
+
+ mdb->esc_path = check_pool_memory_size(mdb->esc_path, mdb->pnl*2+1);
+ my_postgresql_copy_escape(mdb->esc_path, mdb->path, mdb->pnl);
+
+ if (ar->Digest == NULL || ar->Digest[0] == 0) {
+ digest = "0";
+ } else {
+ digest = ar->Digest;
+ }
+
+ len = Mmsg(mdb->cmd, "%u\t%s\t%s\t%s\t%s\t%s\n",
+ ar->FileIndex, edit_int64(ar->JobId, ed1), mdb->esc_path,
+ mdb->esc_name, ar->attr, digest);
+
+ do {
+ res = PQputCopyData(mdb->db,
+ mdb->cmd,
+ len);
+ } while (res == 0 && --count > 0);
+
+ if (res == 1) {
+ Dmsg0(500, "ok\n");
+ mdb->changes++;
+ mdb->status = 1;
+ }
+
+ if (res <= 0) {
+ Dmsg0(500, "we failed\n");
+ mdb->status = 0;
+ Mmsg1(&mdb->errmsg, _("error ending batch mode: %s\n"), PQerrorMessage(mdb->db));
+ }
+
+ Dmsg0(500, "my_postgresql_batch_insert finishing\n");
+
+ return mdb->status;
+}
+
+/*
+ * Escape strings so that PostgreSQL is happy on COPY
+ *
+ * NOTE! len is the length of the old string. Your new
+ * string must be long enough (max 2*old+1) to hold
+ * the escaped output.
+ */
+char *my_postgresql_copy_escape(char *dest, char *src, size_t len)
+{
+ /* we have to escape \t, \n, \r, \ */
+ char c = '\0' ;
+
+ while (len > 0 && *src) {
+ switch (*src) {
+ case '\n':
+ c = 'n';
+ break;
+ case '\\':
+ c = '\\';
+ break;
+ case '\t':
+ c = 't';
+ break;
+ case '\r':
+ c = 'r';
+ break;
+ default:
+ c = '\0' ;
+ }
+
+ if (c) {
+ *dest = '\\';
+ dest++;
+ *dest = c;
+ } else {
+ *dest = *src;
+ }
+
+ len--;
+ src++;
+ dest++;
+ }
+
+ *dest = '\0';
+ return dest;
+}
+
+char *my_pg_batch_lock_path_query = "BEGIN; LOCK TABLE Path IN SHARE ROW EXCLUSIVE MODE";
+
+
+char *my_pg_batch_lock_filename_query = "BEGIN; LOCK TABLE Filename IN SHARE ROW EXCLUSIVE MODE";
+
+char *my_pg_batch_unlock_tables_query = "COMMIT";
+
+char *my_pg_batch_fill_path_query = "INSERT INTO Path (Path) "
+ " SELECT a.Path FROM "
+ " (SELECT DISTINCT Path FROM batch) AS a "
+ " WHERE NOT EXISTS (SELECT Path FROM Path WHERE Path = a.Path) ";
+
+char *my_pg_batch_fill_filename_query = "INSERT INTO Filename (Name) "
+ " SELECT a.Name FROM "
+ " (SELECT DISTINCT Name FROM batch) as a "
+ " WHERE NOT EXISTS "
+ " (SELECT Name FROM Filename WHERE Name = a.Name)";
#endif /* HAVE_POSTGRESQL */