[evolution-data-server/sqlite-refactor: 4/13] Adding new EBookBackendSqlite (refactor in progress)
- From: Tristan Van Berkom <tvb src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [evolution-data-server/sqlite-refactor: 4/13] Adding new EBookBackendSqlite (refactor in progress)
- Date: Mon, 25 Nov 2013 10:20:31 +0000 (UTC)
commit 5e13ecb08c5affa05dae74e0ee41b33ab09e37e7
Author: Tristan Van Berkom <tristanvb openismus com>
Date: Tue Nov 19 21:56:38 2013 +0900
Adding new EBookBackendSqlite (refactor in progress)
addressbook/libedata-book/Makefile.am | 2 +
addressbook/libedata-book/e-book-backend-sqlite.c | 7052 +++++++++++++++++++++
addressbook/libedata-book/e-book-backend-sqlite.h | 311 +
addressbook/libedata-book/libedata-book.h | 1 +
4 files changed, 7366 insertions(+), 0 deletions(-)
---
diff --git a/addressbook/libedata-book/Makefile.am b/addressbook/libedata-book/Makefile.am
index 6b39d2d..38096d7 100644
--- a/addressbook/libedata-book/Makefile.am
+++ b/addressbook/libedata-book/Makefile.am
@@ -28,6 +28,7 @@ libedata_book_1_2_la_SOURCES = \
e-book-backend-cache.c \
e-book-backend-db-cache.c \
e-book-backend-sqlitedb.c \
+ e-book-backend-sqlite.c \
e-book-backend.c \
e-data-book.c \
e-data-book-cursor.c \
@@ -70,6 +71,7 @@ libedata_bookinclude_HEADERS = \
e-data-book-direct.h \
e-book-backend-cache.h \
e-book-backend-sqlitedb.h \
+ e-book-backend-sqlite.h \
e-book-backend-db-cache.h \
$(NULL)
diff --git a/addressbook/libedata-book/e-book-backend-sqlite.c
b/addressbook/libedata-book/e-book-backend-sqlite.c
new file mode 100644
index 0000000..32ea79b
--- /dev/null
+++ b/addressbook/libedata-book/e-book-backend-sqlite.c
@@ -0,0 +1,7052 @@
+/*-*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/* e-book-backend-sqlite.c
+ *
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * Authors:
+ * Tristan Van Berkom <tristanvb openismus com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser 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.
+ */
+
+#include "e-book-backend-sqlite.h"
+
+#include <locale.h>
+#include <string.h>
+#include <errno.h>
+
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+
+#include <sqlite3.h>
+#include <libebackend/libebackend.h>
+
+#include "e-book-backend-sexp.h"
+
+
+/* Some forward declarations */
+typedef struct _SummaryField SummaryField;
+
+static sqlite3_stmt *book_backend_sqlite_prepare_insert (EBookBackendSqlite *ebsql,
+ gboolean replace_existing,
+ GError **error);
+static sqlite3_stmt *book_backend_sqlite_prepare_multi_insert (EBookBackendSqlite *ebsql,
+ SummaryField *field,
+ GError **error);
+static sqlite3_stmt *book_backend_sqlite_prepare_multi_delete (EBookBackendSqlite *ebsql,
+ SummaryField *field,
+ GError **error);
+static gboolean book_backend_sqlite_insert_contact (EBookBackendSqlite *ebsql,
+ EContact *contact,
+ gboolean replace_existing,
+ GError **error);
+static gboolean book_backend_sqlite_set_locale_internal (EBookBackendSqlite *ebsql,
+ const gchar *locale,
+ GError **error);
+
+#define d(x)
+
+#if d(1)+0
+# define LOCK_MUTEX(mutex) \
+ G_STMT_START { \
+ g_printerr ("%s: DB Locking\n", G_STRFUNC); \
+ g_mutex_lock (mutex); \
+ g_printerr ("%s: DB Locked\n", G_STRFUNC); \
+ } G_STMT_END
+
+# define UNLOCK_MUTEX(mutex) \
+ G_STMT_START { \
+ g_printerr ("%s: DB Unlocking\n", G_STRFUNC); \
+ g_mutex_unlock (mutex); \
+ g_printerr ("%s: DB Unlocked\n", G_STRFUNC); \
+ } G_STMT_END
+#else
+# define LOCK_MUTEX(mutex) g_mutex_lock (mutex)
+# define UNLOCK_MUTEX(mutex) g_mutex_unlock (mutex)
+#endif
+
+#define FOLDER_VERSION 8
+#define INSERT_MULTI_STMT_BYTES 128
+#define COLUMN_DEFINITION_BYTES 32
+#define GENERATED_QUERY_BYTES 2048
+
+#define EBSQL_ESCAPE_SEQUENCE "ESCAPE '^'"
+
+/* Names for custom functions */
+#define EBSQL_FUNC_EQPHONE_EXACT "eqphone_exact"
+#define EBSQL_FUNC_EQPHONE_NATIONAL "eqphone_national"
+#define EBSQL_FUNC_EQPHONE_SHORT "eqphone_short"
+
+/* Suffixes for column names used to store specialized data */
+#define EBSQL_SUFFIX_REVERSE "reverse"
+#define EBSQL_SUFFIX_SORT_KEY "localized"
+#define EBSQL_SUFFIX_PHONE "phone"
+#define EBSQL_SUFFIX_COUNTRY "country"
+
+/* Track EBookIndexType's in a bit mask */
+#define INDEX_FLAG(type) (1 << E_BOOK_INDEX_##type)
+
+
+struct _SummaryField {
+ EContactField field_id; /* The EContact field */
+ GType type; /* The GType (only support string or gboolean) */
+ const gchar *dbname; /* The key for this field in the sqlite3 table */
+ gint index; /* Types of searches this field should support (see EBookIndexType)
*/
+ gchar *aux_table; /* Name of auxiliary table for this field, for multivalued fields
only */
+ gchar *aux_table_symbolic; /* Symolic name of auxiliary table used in queries */
+};
+
+struct _EBookBackendSqlitePrivate {
+
+ /* Parameters and settings */
+ gchar *path; /* Full file name of the file we're operating on (used for hash
table entries) */
+ gboolean store_vcard; /* Whether vcards should be stored */
+ gchar *locale; /* The current locale */
+ gchar *region_code; /* Region code (for phone number parsing) */
+ gchar *folderid; /* The summary table name (configurable, for support of legacy
+ * databases created by EBookBackendSqliteDB) */
+
+ /* Summary configuration */
+ SummaryField *summary_fields;
+ gint n_summary_fields;
+
+ GMutex lock; /* Main API lock */
+ GMutex updates_lock; /* Lock used for calls to e_book_backend_sqlite_lock_updates () */
+ guint32 in_transaction; /* Nested transaction counter */
+ gboolean writer_lock; /* Whether a writer lock was acquired for this transaction */
+
+ ECollator *collator; /* The ECollator to create sort keys for any sortable fields */
+
+ /* SQLite resources */
+ sqlite3 *db;
+ sqlite3_stmt *insert_stmt; /* Insert statement for main summary table */
+ sqlite3_stmt *replace_stmt; /* Replace statement for main summary table */
+ GHashTable *multi_deletes; /* Delete statement for each auxiliary table */
+ GHashTable *multi_inserts; /* Insert statement for each auxiliary table */
+
+ /* This error can be set from an SQLite collation function
+ * which has no way to effect the error returned by sqlite3_exec
+ */
+ GError *extra_error;
+};
+
+G_DEFINE_TYPE (EBookBackendSqlite, e_book_backend_sqlite, G_TYPE_OBJECT)
+G_DEFINE_QUARK (e-book-backend-sqlite-error-quark,
+ e_book_backend_sqlite_error)
+
+/* The ColumnInfo struct is used to constant data
+ * and dynamically allocated data, the 'type' and
+ * 'extra' members are however always constant.
+ */
+typedef struct {
+ gchar *name;
+ const gchar *type;
+ const gchar *extra;
+ gchar *index;
+} ColumnInfo;
+
+static ColumnInfo main_table_columns[] = {
+ { (gchar *) "folder_id", "TEXT", "PRIMARY KEY", NULL },
+ { (gchar *) "version", "INTEGER", NULL, NULL },
+ { (gchar *) "multivalues", "TEXT", NULL, NULL },
+ { (gchar *) "lc_collate", "TEXT", NULL, NULL },
+ { (gchar *) "countrycode", "VARCHAR(2)", NULL, NULL },
+};
+
+/* Default summary configuration */
+static EContactField default_summary_fields[] = {
+ E_CONTACT_UID,
+ E_CONTACT_REV,
+ E_CONTACT_FILE_AS,
+ E_CONTACT_NICKNAME,
+ E_CONTACT_FULL_NAME,
+ E_CONTACT_GIVEN_NAME,
+ E_CONTACT_FAMILY_NAME,
+ E_CONTACT_EMAIL,
+ E_CONTACT_IS_LIST,
+ E_CONTACT_LIST_SHOW_ADDRESSES,
+ E_CONTACT_WANTS_HTML
+};
+
+/* Create indexes on full_name and email fields as autocompletion
+ * queries would mainly rely on this.
+ *
+ * Add sort keys for name fields as those are likely targets for
+ * cursor usage.
+ */
+static EContactField default_indexed_fields[] = {
+ E_CONTACT_FULL_NAME,
+ E_CONTACT_EMAIL,
+ E_CONTACT_FILE_AS,
+ E_CONTACT_FAMILY_NAME,
+ E_CONTACT_GIVEN_NAME
+};
+
+static EBookIndexType default_index_types[] = {
+ E_BOOK_INDEX_PREFIX,
+ E_BOOK_INDEX_PREFIX,
+ E_BOOK_INDEX_SORT_KEY,
+ E_BOOK_INDEX_SORT_KEY,
+ E_BOOK_INDEX_SORT_KEY
+};
+
+/******************************************************
+ * Sharing EBookBackendSqlite instances *
+ ******************************************************/
+static GHashTable *db_connections = NULL;
+static GMutex dbcon_lock;
+
+static EBookBackendSqlite *
+book_backend_sqlite_ref_from_hash (const gchar *path)
+{
+ EBookBackendSqlite *ebsql = NULL;
+
+ if (db_connections != NULL) {
+ ebsql = g_hash_table_lookup (db_connections, path);
+ }
+
+ if (ebsql)
+ return g_object_ref (ebsql);
+
+ return NULL;
+}
+
+static void
+book_backend_sqlite_register_to_hash (EBookBackendSqlite *ebsql,
+ const gchar *path)
+{
+ if (db_connections == NULL)
+ db_connections = g_hash_table_new_full (
+ (GHashFunc) g_str_hash,
+ (GEqualFunc) g_str_equal,
+ (GDestroyNotify) g_free,
+ (GDestroyNotify) NULL);
+ g_hash_table_insert (db_connections, g_strdup (path), ebsql);
+}
+
+static void
+book_backend_sqlite_unregister_from_hash (EBookBackendSqlite *ebsql)
+{
+ EBookBackendSqlitePrivate *priv = ebsql->priv;
+
+ g_mutex_lock (&dbcon_lock);
+ if (db_connections != NULL) {
+ if (priv->path != NULL) {
+ g_hash_table_remove (db_connections, priv->path);
+
+ if (g_hash_table_size (db_connections) == 0) {
+ g_hash_table_destroy (db_connections);
+ db_connections = NULL;
+ }
+
+ }
+ }
+ g_mutex_unlock (&dbcon_lock);
+}
+
+/************************************************************
+ * SQLite helper functions *
+ ************************************************************
+ *
+ * Lock must be held at all times when executing statements
+ *
+ */
+typedef gint (* EbSqlSqliteCollate) (gpointer ref,
+ gint len1,
+ const void *str1,
+ gint len2,
+ const void *str2);
+typedef void (* EbSqlCustomFunction) (sqlite3_context *context,
+ gint argc,
+ sqlite3_value **argv);
+typedef gint (* EbSqlSqliteCallback) (gpointer ref,
+ gint n_cols,
+ gchar **cols,
+ gchar **names);
+
+/* For debugging statements with BOOKSQL_DEBUG environment variable */
+static gint
+print_debug_cb (gpointer ref,
+ gint n_cols,
+ gchar **cols,
+ gchar **name)
+{
+ gint i;
+
+ g_printerr (" DEBUG BEGIN:\n");
+
+ for (i = 0; i < n_cols; i++)
+ g_printerr (" NAME: '%s' VALUE: %s\n", name[i], cols[i]);
+
+ g_printerr (" DEBUG END\n");
+
+ return 0;
+}
+
+/* Collect a GList of column names in the main summary table */
+static gint
+get_columns_cb (gpointer ref,
+ gint col,
+ gchar **cols,
+ gchar **name)
+{
+ GSList **columns = (GSList **) ref;
+ gint i;
+
+ for (i = 0; i < col; i++) {
+ if (strcmp (name[i], "name") == 0) {
+
+ /* Keep comparing for the legacy 'bdata' column */
+ if (strcmp (cols[i], "vcard") != 0 &&
+ strcmp (cols[i], "bdata") != 0) {
+ gchar *column = g_strdup (cols[i]);
+
+ *columns = g_slist_prepend (*columns, column);
+ }
+ break;
+ }
+ }
+ return 0;
+}
+
+/* Collect the first string result */
+static gint
+get_string_cb (gpointer ref,
+ gint col,
+ gchar **cols,
+ gchar **name)
+{
+ gchar **ret = ref;
+
+ *ret = g_strdup (cols [0]);
+
+ return 0;
+}
+
+/* Collect the first integer result */
+static gint
+get_int_cb (gpointer ref,
+ gint col,
+ gchar **cols,
+ gchar **name)
+{
+ gint *ret = ref;
+
+ *ret = cols [0] ? g_ascii_strtoll (cols[0], NULL, 10) : 0;
+
+ return 0;
+}
+
+/* Collect the result of a SELECT count(*) statement */
+static gint
+get_count_cb (gpointer ref,
+ gint n_cols,
+ gchar **cols,
+ gchar **name)
+{
+ gint64 count = 0;
+ gint *ret = ref;
+ gint i;
+
+ for (i = 0; i < n_cols; i++) {
+ if (name[i] && strncmp (name[i], "count", 5) == 0) {
+ count = g_ascii_strtoll (cols[i], NULL, 10);
+
+ break;
+ }
+ }
+
+ *ret = count;
+
+ return 0;
+}
+
+/* Report if there was at least one result */
+static gint
+get_exists_cb (gpointer ref,
+ gint col,
+ gchar **cols,
+ gchar **name)
+{
+ gboolean *exists = ref;
+
+ *exists = TRUE;
+
+ return 0;
+}
+
+static EbSqlSearchData *
+search_data_from_results (gchar **cols)
+{
+ EbSqlSearchData *data = g_slice_new0 (EbSqlSearchData);
+
+ if (cols[0]) {
+ data->uid = g_strdup (cols[0]);
+
+ if (cols[1])
+ data->vcard = g_strdup (cols[1]);
+ }
+
+ return data;
+}
+
+static gint
+collect_full_results_cb (gpointer ref,
+ gint col,
+ gchar **cols,
+ gchar **name)
+{
+ EbSqlSearchData *data;
+ GSList **vcard_data = ref;
+
+ data = search_data_from_results (cols);
+
+ *vcard_data = g_slist_prepend (*vcard_data, data);
+
+ return 0;
+}
+
+static gint
+collect_uid_results_cb (gpointer ref,
+ gint col,
+ gchar **cols,
+ gchar **name)
+{
+ GSList **uids = ref;
+
+ if (cols[0])
+ *uids = g_slist_prepend (*uids, g_strdup (cols [0]));
+
+ return 0;
+}
+
+static gint
+collect_lean_results_cb (gpointer ref,
+ gint ncol,
+ gchar **cols,
+ gchar **name)
+{
+ GSList **vcard_data = ref;
+ EbSqlSearchData *search_data = g_slice_new0 (EbSqlSearchData);
+ EContact *contact = e_contact_new ();
+ gchar *vcard;
+ gint i;
+
+ /* parse through cols, this will be useful if the api starts supporting field restrictions */
+ for (i = 0; i < ncol; i++) {
+ if (!name[i] || !cols[i])
+ continue;
+
+ /* Only UID & REV can be used to create contacts from the summary columns */
+ if (!g_ascii_strcasecmp (name[i], "uid")) {
+ e_contact_set (contact, E_CONTACT_UID, cols[i]);
+ search_data->uid = g_strdup (cols[i]);
+ } else if (!g_ascii_strcasecmp (name[i], "Rev")) {
+ e_contact_set (contact, E_CONTACT_REV, cols[i]);
+ }
+ }
+
+ vcard = e_vcard_to_string (E_VCARD (contact), EVC_FORMAT_VCARD_30);
+ search_data->vcard = vcard;
+ *vcard_data = g_slist_prepend (*vcard_data, search_data);
+
+ g_object_unref (contact);
+ return 0;
+}
+
+static gint
+collect_uids_and_rev_cb (gpointer user_data,
+ gint col,
+ gchar **cols,
+ gchar **name)
+{
+ GHashTable *uids_and_rev = user_data;
+
+ if (col == 2 && cols[0])
+ g_hash_table_insert (uids_and_rev, g_strdup (cols[0]), g_strdup (cols[1] ? cols[1] : ""));
+
+ return 0;
+}
+
+static void
+ebsql_string_append_vprintf (GString *string,
+ const gchar *fmt,
+ va_list args)
+{
+ gchar *stmt;
+
+ /* Unfortunately, sqlite3_vsnprintf() doesnt tell us
+ * how many bytes it would have needed if it doesnt fit
+ * into the target buffer, so we can't avoid this
+ * really disgusting memory dup.
+ */
+ stmt = sqlite3_vmprintf (fmt, args);
+ g_string_append (string, stmt);
+ sqlite3_free (stmt);
+}
+
+static void
+ebsql_string_append_printf (GString *string,
+ const gchar *fmt,
+ ...)
+{
+ va_list args;
+
+ va_start (args, fmt);
+ ebsql_string_append_vprintf (string, fmt, args);
+ va_end (args);
+}
+
+/* Appends an identifier suitable to identify the
+ * column to test in the context of a query.
+ *
+ * The suffix is for special indexed columns (such as
+ * reverse values, sort keys, phone numbers, etc).
+ */
+static void
+ebsql_string_append_column (GString *string,
+ SummaryField *field,
+ const gchar *suffix)
+{
+ if (field->aux_table) {
+ g_string_append (string, field->aux_table_symbolic);
+ g_string_append (string, ".value");
+ } else {
+ g_string_append (string, "summary.");
+ g_string_append (string, field->dbname);
+ }
+
+ if (suffix) {
+ g_string_append_c (string, '_');
+ g_string_append (string, suffix);
+ }
+}
+
+static gboolean
+book_backend_sqlite_exec_real (EBookBackendSqlite *ebsql,
+ const gchar *stmt,
+ EbSqlSqliteCallback callback,
+ gpointer data,
+ GError **error)
+{
+ gchar *errmsg = NULL;
+ gint ret = -1;
+
+ ret = sqlite3_exec (ebsql->priv->db, stmt, callback, data, &errmsg);
+
+ /* Handle possible extra error */
+ if (ebsql->priv->extra_error) {
+ g_propagate_error (error, ebsql->priv->extra_error);
+ ebsql->priv->extra_error = NULL;
+ return FALSE;
+ }
+
+ while (ret == SQLITE_BUSY || ret == SQLITE_LOCKED || ret == -1) {
+ if (errmsg) {
+ sqlite3_free (errmsg);
+ errmsg = NULL;
+ }
+ g_thread_yield ();
+ ret = sqlite3_exec (ebsql->priv->db, stmt, callback, data, &errmsg);
+
+ /* Handle possible extra error */
+ if (ebsql->priv->extra_error) {
+ g_propagate_error (error, ebsql->priv->extra_error);
+ ebsql->priv->extra_error = NULL;
+ return FALSE;
+ }
+ }
+
+ if (ret != SQLITE_OK) {
+ d (g_printerr ("Error in SQL EXEC statement: %s [%s].\n", stmt, errmsg));
+ g_set_error_literal (error,
+ E_BOOK_SQL_ERROR,
+ ret == SQLITE_CONSTRAINT ?
+ E_BOOK_SQL_ERROR_CONSTRAINT :
+ E_BOOK_SQL_ERROR_OTHER,
+ errmsg);
+ sqlite3_free (errmsg);
+ return FALSE;
+ }
+
+ if (errmsg)
+ sqlite3_free (errmsg);
+
+ return TRUE;
+}
+
+static gint G_GNUC_CONST
+book_backend_sqlite_debug_level (void)
+{
+ static gint booksql_debug = -1;
+
+ if (booksql_debug == -1) {
+ const gchar *const tmp = g_getenv ("BOOKSQL_DEBUG");
+
+ if (tmp)
+ booksql_debug = g_ascii_strtoll (tmp, NULL, 10);
+ else
+ booksql_debug = 0;
+ }
+
+ return booksql_debug;
+}
+
+static void
+book_backend_sqlite_debug (EBookBackendSqlite *ebsql,
+ const gchar *stmt,
+ EbSqlSqliteCallback callback,
+ gpointer data,
+ GError **error)
+{
+ GError *local_error = NULL;
+
+ g_printerr ("DEBUG STATEMENT: %s\n", stmt);
+
+ if (book_backend_sqlite_debug_level () > 1) {
+ gchar *debug = g_strconcat ("EXPLAIN QUERY PLAN ", stmt, NULL);
+ book_backend_sqlite_exec_real (ebsql, debug, print_debug_cb, NULL, &local_error);
+ g_free (debug);
+ }
+
+ if (local_error) {
+ g_printerr ("DEBUG STATEMENT END: Error: %s\n", local_error->message);
+ } else if (book_backend_sqlite_debug_level () > 1) {
+ g_printerr ("DEBUG STATEMENT END: Success\n");
+ }
+
+ g_clear_error (&local_error);
+}
+
+static gboolean
+book_backend_sqlite_exec (EBookBackendSqlite *ebsql,
+ const gchar *stmt,
+ EbSqlSqliteCallback callback,
+ gpointer data,
+ GError **error)
+{
+ if (book_backend_sqlite_debug_level () > 0)
+ book_backend_sqlite_debug (ebsql, stmt, callback, data, error);
+
+ return book_backend_sqlite_exec_real (ebsql, stmt, callback, data, error);
+}
+
+static gboolean
+book_backend_sqlite_exec_vprintf (EBookBackendSqlite *ebsql,
+ const gchar *fmt,
+ EbSqlSqliteCallback callback,
+ gpointer data,
+ GError **error,
+ va_list args)
+{
+ gboolean success;
+ gchar *stmt;
+
+ stmt = sqlite3_vmprintf (fmt, args);
+ success = book_backend_sqlite_exec (ebsql, stmt, callback, data, error);
+ sqlite3_free (stmt);
+
+ return success;
+}
+
+static gboolean
+book_backend_sqlite_exec_printf (EBookBackendSqlite *ebsql,
+ const gchar *fmt,
+ EbSqlSqliteCallback callback,
+ gpointer data,
+ GError **error,
+ ...)
+{
+ gboolean success;
+ va_list args;
+
+ va_start (args, error);
+ success = book_backend_sqlite_exec_vprintf (ebsql, fmt, callback, data, error, args);
+ va_end (args);
+
+ return success;
+}
+
+static gboolean
+book_backend_sqlite_start_transaction (EBookBackendSqlite *ebsql,
+ gboolean writer_lock,
+ GError **error)
+{
+ gboolean success = TRUE;
+
+ g_return_val_if_fail (ebsql != NULL, FALSE);
+ g_return_val_if_fail (ebsql->priv != NULL, FALSE);
+ g_return_val_if_fail (ebsql->priv->db != NULL, FALSE);
+
+ ebsql->priv->in_transaction++;
+ g_return_val_if_fail (ebsql->priv->in_transaction > 0, FALSE);
+
+ if (ebsql->priv->in_transaction == 1) {
+
+ /* It's important to make the distinction between a
+ * transaction which will read or one which will write.
+ *
+ * While it's not well documented, when receiving the SQLITE_BUSY
+ * error status, one can only safely retry at the beginning of
+ * the transaction.
+ *
+ * If a transaction is 'upgraded' to require a writer lock
+ * half way through the transaction and SQLITE_BUSY is returned,
+ * the whole transaction would need to be retried from the beginning.
+ */
+ ebsql->priv->writer_lock = writer_lock;
+
+ success = book_backend_sqlite_exec (
+ ebsql, writer_lock ? "BEGIN IMMEDIATE" : "BEGIN",
+ NULL, NULL, error);
+ } else {
+
+ /* Warn about cases where where a read transaction might be upgraded */
+ if (writer_lock && !ebsql->priv->writer_lock)
+ g_warning ("A nested transaction wants to write, "
+ "but the outermost transaction was started "
+ "without a writer lock.");
+ }
+
+ return success;
+}
+
+static gboolean
+book_backend_sqlite_commit_transaction (EBookBackendSqlite *ebsql,
+ GError **error)
+{
+ gboolean success = TRUE;
+
+ g_return_val_if_fail (ebsql != NULL, FALSE);
+ g_return_val_if_fail (ebsql->priv != NULL, FALSE);
+ g_return_val_if_fail (ebsql->priv->db != NULL, FALSE);
+
+ g_return_val_if_fail (ebsql->priv->in_transaction > 0, FALSE);
+
+ ebsql->priv->in_transaction--;
+
+ if (ebsql->priv->in_transaction == 0) {
+ success = book_backend_sqlite_exec (
+ ebsql, "COMMIT", NULL, NULL, error);
+ }
+
+ return success;
+}
+
+static gboolean
+book_backend_sqlite_rollback_transaction (EBookBackendSqlite *ebsql,
+ GError **error)
+{
+ gboolean success = TRUE;
+
+ g_return_val_if_fail (ebsql != NULL, FALSE);
+ g_return_val_if_fail (ebsql->priv != NULL, FALSE);
+ g_return_val_if_fail (ebsql->priv->db != NULL, FALSE);
+
+ g_return_val_if_fail (ebsql->priv->in_transaction > 0, FALSE);
+
+ ebsql->priv->in_transaction--;
+
+ if (ebsql->priv->in_transaction == 0) {
+ success = book_backend_sqlite_exec (
+ ebsql, "ROLLBACK", NULL, NULL, error);
+
+ }
+ return success;
+}
+
+static sqlite3_stmt *
+book_backend_sqlite_prepare_statement (EBookBackendSqlite *ebsql,
+ const gchar *stmt_str,
+ GError **error)
+{
+ sqlite3_stmt *stmt;
+ const gchar *stmt_tail = NULL;
+ gint ret;
+
+ ret = sqlite3_prepare_v2 (ebsql->priv->db, stmt_str, strlen (stmt_str), &stmt, &stmt_tail);
+
+ if (ret != SQLITE_OK) {
+ const gchar *errmsg = sqlite3_errmsg (ebsql->priv->db);
+ g_set_error_literal (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_OTHER,
+ errmsg);
+ } else if (stmt == NULL) {
+ g_set_error_literal (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_OTHER,
+ "Unknown error preparing SQL statement");
+ }
+
+ if (stmt_tail && stmt_tail[0])
+ g_warning ("Part of this statement was not parsed: %s", stmt_tail);
+
+ return stmt;
+}
+
+/* Convenience for running statements. After successfully
+ * binding all parameters, just return with this.
+ */
+static gboolean
+book_backend_sqlite_complete_statement (EBookBackendSqlite *ebsql,
+ sqlite3_stmt *stmt,
+ gint ret,
+ GError **error)
+{
+ if (ret == SQLITE_OK) {
+ ret = sqlite3_step (stmt);
+
+ if (ret == SQLITE_DONE)
+ ret = SQLITE_OK;
+ }
+
+ if (ret != SQLITE_OK) {
+ const gchar *errmsg = sqlite3_errmsg (ebsql->priv->db);
+ g_set_error_literal (error,
+ E_BOOK_SQL_ERROR,
+ ret == SQLITE_CONSTRAINT ?
+ E_BOOK_SQL_ERROR_CONSTRAINT : E_BOOK_SQL_ERROR_OTHER,
+ errmsg);
+ }
+
+ /* Reset / Clear at the end, regardless of error state */
+ sqlite3_reset (stmt);
+ sqlite3_clear_bindings (stmt);
+
+ return (ret == SQLITE_OK);
+}
+
+/******************************************************
+ * Summary Fields *
+ ******************************************************/
+static ColumnInfo *
+column_info_new (SummaryField *field,
+ const gchar *folderid,
+ const gchar *column_suffix,
+ const gchar *column_type,
+ const gchar *column_extra,
+ const gchar *idx_prefix)
+{
+ ColumnInfo *info;
+
+ info = g_slice_new0 (ColumnInfo);
+ info->type = column_type;
+ info->extra = column_extra;
+
+ if (!info->type) {
+
+ if (field->type == G_TYPE_STRING)
+ info->type = "TEXT";
+ else if (field->type == G_TYPE_BOOLEAN)
+ info->type = "INTEGER";
+ else
+ g_warn_if_reached ();
+ }
+
+ if (field->type == E_TYPE_CONTACT_ATTR_LIST) {
+
+ /* Attribute lists are on their own table and columns
+ * prefixed with 'value_'
+ */
+ if (column_suffix)
+ info->name = g_strconcat ("value_",
+ column_suffix,
+ NULL);
+ else
+ info->name = g_strdup ("value");
+ } else {
+
+ /* Regular fields are named by their 'dbname'
+ */
+ if (column_suffix)
+ info->name = g_strconcat (field->dbname,
+ "_",
+ column_suffix,
+ NULL);
+ else
+ info->name = g_strdup (field->dbname);
+ }
+
+ if (idx_prefix)
+ info->index =
+ g_strconcat (idx_prefix,
+ "_", field->dbname,
+ "_", folderid,
+ NULL);
+
+ return info;
+}
+
+static void
+column_info_free (ColumnInfo *info)
+{
+ if (info) {
+ g_free (info->name);
+ g_free (info->index);
+ g_slice_free (ColumnInfo, info);
+ }
+}
+
+static gint
+summary_field_array_index (GArray *array,
+ EContactField field)
+{
+ gint i;
+
+ for (i = 0; i < array->len; i++) {
+ SummaryField *iter = &g_array_index (array, SummaryField, i);
+ if (field == iter->field_id)
+ return i;
+ }
+
+ return -1;
+}
+
+static SummaryField *
+summary_field_append (GArray *array,
+ const gchar *folderid,
+ EContactField field_id,
+ GError **error)
+{
+ const gchar *dbname = NULL;
+ GType type = G_TYPE_INVALID;
+ gint idx;
+ SummaryField new_field = { 0, };
+
+ if (field_id < 1 || field_id >= E_CONTACT_FIELD_LAST) {
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_OTHER,
+ _("Invalid contact field '%d' specified in summary"),
+ field_id);
+ return NULL;
+ }
+
+ /* Avoid including the same field twice in the summary */
+ idx = summary_field_array_index (array, field_id);
+ if (idx >= 0)
+ return &g_array_index (array, SummaryField, idx);
+
+ /* Resolve some exceptions, we store these
+ * specific contact fields with different names
+ * than those found in the EContactField table
+ */
+ switch (field_id) {
+ case E_CONTACT_UID:
+ dbname = "uid";
+ break;
+ case E_CONTACT_IS_LIST:
+ dbname = "is_list";
+ break;
+ default:
+ dbname = e_contact_field_name (field_id);
+ break;
+ }
+
+ type = e_contact_field_type (field_id);
+
+ if (type != G_TYPE_STRING &&
+ type != G_TYPE_BOOLEAN &&
+ type != E_TYPE_CONTACT_ATTR_LIST) {
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_OTHER,
+ _("Contact field '%s' of type '%s' specified in summary, "
+ "but only boolean, string and string list field types are supported"),
+ e_contact_pretty_name (field_id), g_type_name (type));
+ return NULL;
+ }
+
+ if (type == E_TYPE_CONTACT_ATTR_LIST) {
+ new_field.aux_table = g_strconcat (folderid, "_", dbname, "_list", NULL);
+ new_field.aux_table_symbolic = g_strconcat (dbname, "_list", NULL);
+ }
+
+ new_field.field_id = field_id;
+ new_field.dbname = dbname;
+ new_field.type = type;
+ new_field.index = 0;
+ g_array_append_val (array, new_field);
+
+ return &g_array_index (array, SummaryField, array->len - 1);
+}
+
+static gboolean
+summary_field_remove (GArray *array,
+ EContactField field)
+{
+ gint idx;
+
+ idx = summary_field_array_index (array, field);
+ if (idx < 0)
+ return FALSE;
+
+ g_array_remove_index_fast (array, idx);
+ return TRUE;
+}
+
+static void
+summary_fields_add_indexes (GArray *array,
+ EContactField *indexes,
+ EBookIndexType *index_types,
+ gint n_indexes)
+{
+ gint i, j;
+
+ for (i = 0; i < array->len; i++) {
+ SummaryField *sfield = &g_array_index (array, SummaryField, i);
+
+ for (j = 0; j < n_indexes; j++) {
+ if (sfield->field_id == indexes[j])
+ sfield->index |= (1 << index_types[j]);
+
+ }
+ }
+}
+
+static SummaryField *
+summary_field_get (EBookBackendSqlite *ebsql,
+ EContactField field_id)
+{
+ gint i;
+
+ for (i = 0; i < ebsql->priv->n_summary_fields; i++) {
+ if (ebsql->priv->summary_fields[i].field_id == field_id)
+ return &(ebsql->priv->summary_fields[i]);
+ }
+
+ return NULL;
+}
+
+static GSList *
+summary_field_list_main_columns (SummaryField *field,
+ const gchar *folderid)
+{
+ GSList *columns = NULL;
+ ColumnInfo *info;
+
+ /* Only strings and booleans are supported in the main
+ * summary, string lists are supported in the auxiliary tables
+ */
+ if (field->type != G_TYPE_STRING &&
+ field->type != G_TYPE_BOOLEAN)
+ return NULL;
+
+ /* Normal / default column */
+ info = column_info_new (field, folderid, NULL, NULL,
+ (field->field_id == E_CONTACT_UID) ? "PRIMARY KEY" : NULL,
+ (field->index & INDEX_FLAG (PREFIX)) != 0 ? "INDEX" : NULL);
+ columns = g_slist_prepend (columns, info);
+
+ /* Localized column, for storing sort keys */
+ if (field->type == G_TYPE_STRING && (field->index & INDEX_FLAG (SORT_KEY))) {
+ info = column_info_new (field, folderid, EBSQL_SUFFIX_SORT_KEY, "TEXT", NULL, "SINDEX");
+ columns = g_slist_prepend (columns, info);
+ }
+
+ /* Suffix match column */
+ if (field->type == G_TYPE_STRING && (field->index & INDEX_FLAG (SUFFIX)) != 0) {
+ info = column_info_new (field, folderid, EBSQL_SUFFIX_REVERSE, "TEXT", NULL, "RINDEX");
+ columns = g_slist_prepend (columns, info);
+ }
+
+ /* Phone match column */
+ if (field->type == G_TYPE_STRING && (field->index & INDEX_FLAG (PHONE)) != 0) {
+
+ /* One indexed column for storing the national number */
+ info = column_info_new (field, folderid, EBSQL_SUFFIX_PHONE, "TEXT", NULL, "PINDEX");
+ columns = g_slist_prepend (columns, info);
+
+ /* One integer column for storing the country code */
+ info = column_info_new (field, folderid, EBSQL_SUFFIX_COUNTRY, "INTEGER", "DEFAULT 0",
NULL);
+ columns = g_slist_prepend (columns, info);
+ }
+
+ return g_slist_reverse (columns);
+}
+
+static GSList *
+summary_field_list_aux_columns (SummaryField *field,
+ const gchar *folderid)
+{
+ GSList *columns = NULL;
+ ColumnInfo *info;
+
+ if (field->type != E_TYPE_CONTACT_ATTR_LIST)
+ return NULL;
+
+ /* The UID column of any auxiliary table is implied and references
+ * the UID in the main summary table
+ */
+
+ /* Normalized value column, for prefix and other regular searches */
+ info = column_info_new (field, folderid, NULL, "TEXT", NULL,
+ (field->index & INDEX_FLAG (PREFIX)) != 0 ? "INDEX" : NULL);
+ columns = g_slist_prepend (columns, info);
+
+ /* Suffix match column */
+ if ((field->index & INDEX_FLAG (SUFFIX)) != 0) {
+
+ info = column_info_new (field, folderid, EBSQL_SUFFIX_REVERSE, "TEXT", NULL, "RINDEX");
+ columns = g_slist_prepend (columns, info);
+ }
+
+ /* Phone match column */
+ if ((field->index & INDEX_FLAG (PHONE)) != 0) {
+
+ /* One indexed column for storing the national number */
+ info = column_info_new (field, folderid, EBSQL_SUFFIX_PHONE, "TEXT", NULL, "PINDEX");
+ columns = g_slist_prepend (columns, info);
+
+ /* One integer column for storing the country code */
+ info = column_info_new (field, folderid, EBSQL_SUFFIX_COUNTRY, "INTEGER", "DEFAULT 0",
NULL);
+ columns = g_slist_prepend (columns, info);
+ }
+
+ return g_slist_reverse (columns);
+}
+
+static void
+summary_fields_array_free (SummaryField *fields,
+ gint n_fields)
+{
+ gint i;
+
+ for (i = 0; i < n_fields; i++) {
+ g_free (fields[i].aux_table);
+ g_free (fields[i].aux_table_symbolic);
+ }
+
+ g_free (fields);
+}
+
+/******************************************************
+ * Functions installed into the SQLite *
+ ******************************************************/
+
+/* Implementation for REGEXP keyword */
+static void
+ebsql_regexp (sqlite3_context *context,
+ gint argc,
+ sqlite3_value **argv)
+{
+ GRegex *regex;
+ const gchar *expression;
+ const gchar *text;
+
+ /* Reuse the same GRegex for all REGEXP queries with the same expression */
+ regex = sqlite3_get_auxdata (context, 0);
+ if (!regex) {
+ GError *error = NULL;
+
+ expression = (const gchar *) sqlite3_value_text (argv[0]);
+
+ regex = g_regex_new (expression, 0, 0, &error);
+
+ if (!regex) {
+ sqlite3_result_error (context,
+ error ? error->message :
+ _("Error parsing regular expression"),
+ -1);
+ g_clear_error (&error);
+ return;
+ }
+
+ /* SQLite will take care of freeing the GRegex when we're done with the query */
+ sqlite3_set_auxdata (context, 0, regex, (GDestroyNotify)g_regex_unref);
+ }
+
+ /* Now perform the comparison */
+ text = (const gchar *) sqlite3_value_text (argv[1]);
+ if (text != NULL) {
+ gboolean match;
+
+ match = g_regex_match (regex, text, 0, NULL);
+ sqlite3_result_int (context, match ? 1 : 0);
+ }
+}
+
+static void
+ebsql_eqphone (sqlite3_context *context,
+ gint argc,
+ sqlite3_value **argv,
+ EPhoneNumberMatch requested_match)
+{
+ EBookBackendSqlite *ebsql = sqlite3_user_data (context);
+ EPhoneNumber *input_phone = NULL, *row_phone = NULL;
+ EPhoneNumberMatch match = E_PHONE_NUMBER_MATCH_NONE;
+ const gchar *text;
+
+ /* Reuse the same phone number for all queries with the same phone number argument */
+ input_phone = sqlite3_get_auxdata (context, 0);
+ if (!input_phone) {
+
+ /* The first argument will be reused for many rows */
+ text = (const gchar *) sqlite3_value_text (argv[0]);
+ if (text) {
+
+ /* Ignore errors, they are fine for phone numbers */
+ input_phone = e_phone_number_from_string (text, ebsql->priv->region_code, NULL);
+
+ /* SQLite will take care of freeing the EPhoneNumber when we're done with the
expression */
+ if (input_phone)
+ sqlite3_set_auxdata (context, 0,
+ input_phone,
+ (GDestroyNotify)e_phone_number_free);
+ }
+ }
+
+ /* This shouldn't happen, as we catch invalid phone number queries in preflight
+ */
+ if (!input_phone) {
+ sqlite3_result_int (context, 0);
+ return;
+ }
+
+ /* Parse the phone number for this row */
+ text = (const gchar *) sqlite3_value_text (argv[1]);
+ if (text != NULL) {
+ row_phone = e_phone_number_from_string (text, ebsql->priv->region_code, NULL);
+
+ /* And perform the comparison */
+ if (row_phone) {
+ match = e_phone_number_compare (input_phone, row_phone);
+
+ e_phone_number_free (row_phone);
+ }
+ }
+
+ /* Now report the result */
+ if (match != E_PHONE_NUMBER_MATCH_NONE &&
+ match <= requested_match)
+ sqlite3_result_int (context, 1);
+ else
+ sqlite3_result_int (context, 0);
+}
+
+/* Exact phone number match function: EBSQL_FUNC_EQPHONE_EXACT */
+static void
+ebsql_eqphone_exact (sqlite3_context *context,
+ gint argc,
+ sqlite3_value **argv)
+{
+ ebsql_eqphone (context, argc, argv, E_PHONE_NUMBER_MATCH_EXACT);
+}
+
+/* National phone number match function: EBSQL_FUNC_EQPHONE_NATIONAL */
+static void
+ebsql_eqphone_national (sqlite3_context *context,
+ gint argc,
+ sqlite3_value **argv)
+{
+ ebsql_eqphone (context, argc, argv, E_PHONE_NUMBER_MATCH_NATIONAL);
+}
+
+/* Short phone number match function: EBSQL_FUNC_EQPHONE_SHORT */
+static void
+ebsql_eqphone_short (sqlite3_context *context,
+ gint argc,
+ sqlite3_value **argv)
+{
+ ebsql_eqphone (context, argc, argv, E_PHONE_NUMBER_MATCH_SHORT);
+}
+
+/**********************************************************
+ * Database Initialization *
+ **********************************************************/
+static inline gint
+main_table_index_by_name (const gchar *name)
+{
+ gint i;
+
+ for (i = 0; i < G_N_ELEMENTS (main_table_columns); i++) {
+ if (g_strcmp0 (name, main_table_columns[i].name) == 0)
+ return i;
+ }
+
+ return -1;
+}
+
+static gint
+check_main_table_columns (gpointer data,
+ gint n_cols,
+ gchar **cols,
+ gchar **name)
+{
+ guint *columns_mask = (guint *)data;
+ gint i;
+
+ for (i = 0; i < n_cols; i++) {
+
+ if (g_strcmp0 (name[i], "name") == 0) {
+ gint idx = main_table_index_by_name (cols[i]);
+
+ if (idx >= 0)
+ *columns_mask |= (1 << idx);
+
+ break;
+ }
+ }
+
+ return 0;
+}
+
+static gboolean
+book_backend_sqlite_init_sqlite (EBookBackendSqlite *ebsql,
+ const gchar *filename,
+ GError **error)
+{
+ gint ret;
+
+ e_sqlite3_vfs_init ();
+
+ ret = sqlite3_open (filename, &ebsql->priv->db);
+
+ /* Install support for the REGEXP keyword */
+ if (ret == SQLITE_OK)
+ ret = sqlite3_create_function (
+ ebsql->priv->db, "regexp", 2, SQLITE_UTF8, ebsql,
+ ebsql_regexp, NULL, NULL);
+
+ /* Fallback for E_BOOK_QUERY_EQUALS_PHONE_NUMBER */
+ if (ret == SQLITE_OK)
+ ret = sqlite3_create_function (
+ ebsql->priv->db, EBSQL_FUNC_EQPHONE_EXACT, 2, SQLITE_UTF8,
+ ebsql, ebsql_eqphone_exact, NULL, NULL);
+
+ /* Fallback for E_BOOK_QUERY_EQUALS_NATIONAL_PHONE_NUMBER */
+ if (ret == SQLITE_OK)
+ ret = sqlite3_create_function (
+ ebsql->priv->db, EBSQL_FUNC_EQPHONE_NATIONAL, 2, SQLITE_UTF8,
+ ebsql, ebsql_eqphone_national, NULL, NULL);
+
+ /* Fallback for E_BOOK_QUERY_EQUALS_SHORT_PHONE_NUMBER */
+ if (ret == SQLITE_OK)
+ ret = sqlite3_create_function (
+ ebsql->priv->db, EBSQL_FUNC_EQPHONE_SHORT, 2, SQLITE_UTF8,
+ ebsql, ebsql_eqphone_short, NULL, NULL);
+
+ if (ret != SQLITE_OK) {
+ if (!ebsql->priv->db) {
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_OTHER,
+ _("Insufficient memory"));
+ } else {
+ const gchar *errmsg;
+ errmsg = sqlite3_errmsg (ebsql->priv->db);
+ d (g_printerr ("Can't open database %s: %s\n", filename, errmsg));
+ g_set_error_literal (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_OTHER,
+ errmsg);
+ sqlite3_close (ebsql->priv->db);
+ }
+ return FALSE;
+ }
+
+ book_backend_sqlite_exec (ebsql, "ATTACH DATABASE ':memory:' AS mem",
+ NULL, NULL, NULL);
+ book_backend_sqlite_exec (ebsql, "PRAGMA foreign_keys = ON",
+ NULL, NULL, NULL);
+
+ /* For optimized prefix searches, we rely on
+ * case insensitivity in LIKE statements
+ */
+ book_backend_sqlite_exec (ebsql, "PRAGMA case_sensitive_like = ON",
+ NULL, NULL, NULL);
+
+ return TRUE;
+}
+
+static inline void
+format_column_declaration (GString *string,
+ ColumnInfo *info)
+{
+ g_string_append (string, info->name);
+ g_string_append_c (string, ' ');
+
+ g_string_append (string, info->type);
+
+ if (info->extra) {
+ g_string_append_c (string, ' ');
+ g_string_append (string, info->extra);
+ }
+}
+
+static inline gboolean
+ensure_column_index (EBookBackendSqlite *ebsql,
+ const gchar *table,
+ ColumnInfo *info,
+ GError **error)
+{
+ if (!info->index)
+ return TRUE;
+
+ return book_backend_sqlite_exec_printf (
+ ebsql, "CREATE INDEX IF NOT EXISTS %Q ON %Q (%s)",
+ NULL, NULL, error,
+ info->index, table, info->name);
+}
+
+/* Called with the lock held and inside a transaction */
+static gboolean
+book_backend_sqlite_init_folders (EBookBackendSqlite *ebsql,
+ gint *previous_schema,
+ GError **error)
+{
+ GString *string;
+ gint version = 0, i;
+ guint existing_columns_mask = 0;
+ gboolean success;
+
+ string = g_string_sized_new (COLUMN_DEFINITION_BYTES * G_N_ELEMENTS (main_table_columns));
+ g_string_append (string, "CREATE TABLE IF NOT EXISTS folders (");
+ for (i = 0; i < G_N_ELEMENTS (main_table_columns); i++) {
+
+ if (i > 0)
+ g_string_append (string, ", ");
+
+ format_column_declaration (string, &(main_table_columns[i]));
+ }
+ g_string_append_c (string, ')');
+
+ /* Create main folders table */
+ success = book_backend_sqlite_exec (ebsql,
+ string->str,
+ NULL, NULL, error);
+ g_string_free (string, TRUE);
+
+ /* Fetch the version, it should be the same for all folders (hence the LIMIT). */
+ if (success)
+ success = book_backend_sqlite_exec (
+ ebsql, "SELECT version FROM folders LIMIT 1",
+ get_int_cb, &version, error);
+
+ /* Check which columns in the main table already exist */
+ if (success)
+ success = book_backend_sqlite_exec (
+ ebsql, "PRAGMA table_info (folders)",
+ check_main_table_columns, &existing_columns_mask, error);
+
+ /* Add columns which may be missing */
+ for (i = 0; success && i < G_N_ELEMENTS (main_table_columns); i++) {
+ ColumnInfo *info = &(main_table_columns[i]);
+
+ if ((existing_columns_mask & (1 << i)) != 0)
+ continue;
+
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "ALTER TABLE folders ADD COLUMN %s %s %s",
+ NULL, NULL, error, info->name, info->type,
+ info->extra ? info->extra : "");
+ }
+
+ /* Special case upgrade for schema versions 3 & 4.
+ *
+ * Drops the reverse_multivalues column.
+ */
+ if (success && version >= 3 && version < 5) {
+
+ success = book_backend_sqlite_exec (
+ ebsql,
+ "UPDATE folders SET "
+ "multivalues = REPLACE(RTRIM(REPLACE("
+ "multivalues || ':', ':', "
+ "CASE reverse_multivalues "
+ "WHEN 0 THEN ';prefix ' "
+ "ELSE ';prefix;suffix ' "
+ "END)), ' ', ':'), "
+ "reverse_multivalues = NULL",
+ NULL, NULL, error);
+ }
+
+ /* Finish the eventual upgrade by storing the current schema version.
+ */
+ if (success && version >= 1 && version < FOLDER_VERSION) {
+
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "UPDATE folders SET version = %d",
+ NULL, NULL, error, FOLDER_VERSION);
+ }
+
+ if (success)
+ *previous_schema = version;
+ else
+ *previous_schema = 0;
+
+ return success;
+}
+
+/* Called with the lock held and inside a transaction */
+static gboolean
+book_backend_sqlite_init_keys (EBookBackendSqlite *ebsql,
+ GError **error)
+{
+ gboolean success;
+
+ /* Create a child table to store key/value pairs for a folder. */
+ success = book_backend_sqlite_exec (
+ ebsql,
+ "CREATE TABLE IF NOT EXISTS keys ("
+ " key TEXT PRIMARY KEY,"
+ " value TEXT,"
+ " folder_id TEXT REFERENCES folders)",
+ NULL, NULL, error);
+
+ /* Add an index on the keys */
+ if (success)
+ success = book_backend_sqlite_exec (
+ ebsql,
+ "CREATE INDEX IF NOT EXISTS keysindex ON keys (folder_id)",
+ NULL, NULL, error);
+
+ return success;
+}
+
+static gchar *
+format_multivalues (EBookBackendSqlite *ebsql)
+{
+ gint i;
+ GString *string;
+ gboolean first = TRUE;
+
+ string = g_string_new (NULL);
+
+ for (i = 0; i < ebsql->priv->n_summary_fields; i++) {
+ if (ebsql->priv->summary_fields[i].type == E_TYPE_CONTACT_ATTR_LIST) {
+ if (first)
+ first = FALSE;
+ else
+ g_string_append_c (string, ':');
+
+ g_string_append (string, ebsql->priv->summary_fields[i].dbname);
+
+ /* E_BOOK_INDEX_SORT_KEY is not supported in the multivalue fields */
+ if ((ebsql->priv->summary_fields[i].index & INDEX_FLAG (PREFIX)) != 0)
+ g_string_append (string, ";prefix");
+ if ((ebsql->priv->summary_fields[i].index & INDEX_FLAG (SUFFIX)) != 0)
+ g_string_append (string, ";suffix");
+ if ((ebsql->priv->summary_fields[i].index & INDEX_FLAG (PHONE)) != 0)
+ g_string_append (string, ";phone");
+ }
+ }
+
+ return g_string_free (string, FALSE);
+}
+
+/* Called with the lock held and inside a transaction */
+static gboolean
+book_backend_sqlite_add_folder (EBookBackendSqlite *ebsql,
+ gboolean *already_exists,
+ GError **error)
+{
+ gboolean success;
+ gchar *multivalues;
+ gint count = 0;
+
+ /* Check if this folder is already declared in the main folders table */
+ success = book_backend_sqlite_exec_printf (
+ ebsql,
+ "SELECT count(*) FROM sqlite_master WHERE type='table' AND name=%Q;",
+ get_count_cb, &count, error, ebsql->priv->folderid);
+
+ if (success && count == 0) {
+ const gchar *lc_collate;
+
+ multivalues = format_multivalues (ebsql);
+ lc_collate = setlocale (LC_COLLATE, NULL);
+
+ success = book_backend_sqlite_exec_printf (
+ ebsql,
+ "INSERT OR IGNORE INTO folders"
+ " ( folder_id, version, multivalues, lc_collate ) "
+ "VALUES ( %Q, %d, %Q, %Q ) ",
+ NULL, NULL, error,
+ ebsql->priv->folderid, FOLDER_VERSION, multivalues, lc_collate);
+
+ g_free (multivalues);
+ }
+
+ if (success && already_exists)
+ *already_exists = (count > 0);
+
+ return success;
+}
+
+/* Called with the lock held and inside a transaction */
+static gboolean
+book_backend_sqlite_introspect_summary (EBookBackendSqlite *ebsql,
+ gint previous_schema,
+ GSList **introspected_columns,
+ GError **error)
+{
+ gboolean success;
+ GSList *summary_columns = NULL, *l;
+ GArray *summary_fields = NULL;
+ gchar *multivalues = NULL;
+ gint i, j;
+
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "PRAGMA table_info (%Q);",
+ get_columns_cb, &summary_columns, error, ebsql->priv->folderid);
+
+ if (!success)
+ goto introspect_summary_finish;
+
+ summary_columns = g_slist_reverse (summary_columns);
+ summary_fields = g_array_new (FALSE, FALSE, sizeof (SummaryField));
+
+ /* Introspect the normal summary fields */
+ for (l = summary_columns; l; l = l->next) {
+ EContactField field_id;
+ const gchar *col = l->data;
+ gchar *p;
+ gint computed = 0;
+ gchar *freeme = NULL;
+
+ /* Note that we don't have any way to introspect
+ * E_BOOK_INDEX_PREFIX, this is not important because if
+ * the prefix index is specified, it will be created
+ * the first time the SQLite tables are created, so
+ * it's not important to ensure prefix indexes after
+ * introspecting the summary.
+ */
+
+ /* Check if we're parsing a reverse field */
+ if ((p = strstr (col, "_" EBSQL_SUFFIX_REVERSE)) != NULL) {
+ computed = INDEX_FLAG (SUFFIX);
+ freeme = g_strndup (col, p - col);
+ col = freeme;
+ } else if ((p = strstr (col, "_" EBSQL_SUFFIX_PHONE)) != NULL) {
+ computed = INDEX_FLAG (PHONE);
+ freeme = g_strndup (col, p - col);
+ col = freeme;
+ } else if ((p = strstr (col, "_" EBSQL_SUFFIX_COUNTRY)) != NULL) {
+ computed = INDEX_FLAG (PHONE);
+ freeme = g_strndup (col, p - col);
+ col = freeme;
+ } else if ((p = strstr (col, "_" EBSQL_SUFFIX_SORT_KEY)) != NULL) {
+ computed = INDEX_FLAG (SORT_KEY);
+ freeme = g_strndup (col, p - col);
+ col = freeme;
+ }
+
+ /* First check exception fields */
+ if (g_ascii_strcasecmp (col, "uid") == 0)
+ field_id = E_CONTACT_UID;
+ else if (g_ascii_strcasecmp (col, "is_list") == 0)
+ field_id = E_CONTACT_IS_LIST;
+ else
+ field_id = e_contact_field_id (col);
+
+ /* Check for parse error */
+ if (field_id == 0) {
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_OTHER,
+ _("Error introspecting unknown summary field '%s'"),
+ col);
+ success = FALSE;
+ g_free (freeme);
+ break;
+ }
+
+ /* Computed columns are always declared after the normal columns,
+ * if a reverse field is encountered we need to set the suffix
+ * index on the coresponding summary field
+ */
+ if (computed) {
+ gint field_idx;
+ SummaryField *iter;
+
+ field_idx = summary_field_array_index (summary_fields, field_id);
+ if (field_idx >= 0) {
+ iter = &g_array_index (summary_fields, SummaryField, field_idx);
+ iter->index |= computed;
+ }
+
+ } else {
+ summary_field_append (summary_fields, ebsql->priv->folderid,
+ field_id, NULL);
+ }
+
+ g_free (freeme);
+ }
+
+ if (!success)
+ goto introspect_summary_finish;
+
+ /* Introspect the multivalied summary fields */
+ success = book_backend_sqlite_exec_printf (
+ ebsql,
+ "SELECT multivalues FROM folders WHERE folder_id = %Q",
+ get_string_cb, &multivalues, error, ebsql->priv->folderid);
+
+ if (!success)
+ goto introspect_summary_finish;
+
+
+ if (multivalues) {
+ gchar **fields = g_strsplit (multivalues, ":", 0);
+
+ for (i = 0; fields[i] != NULL; i++) {
+ EContactField field_id;
+ SummaryField *iter;
+ gchar **params;
+
+ params = g_strsplit (fields[i], ";", 0);
+ field_id = e_contact_field_id (params[0]);
+ iter = summary_field_append (summary_fields,
+ ebsql->priv->folderid,
+ field_id, NULL);
+
+ if (iter) {
+ for (j = 1; params[j]; ++j) {
+ /* Sort keys not supported for multivalued fields */
+ if (strcmp (params[j], "prefix") == 0) {
+ iter->index |= INDEX_FLAG (PREFIX);
+ } else if (strcmp (params[j], "suffix") == 0) {
+ iter->index |= INDEX_FLAG (SUFFIX);
+ } else if (strcmp (params[j], "phone") == 0) {
+ iter->index |= INDEX_FLAG (PHONE);
+ }
+ }
+ }
+
+ g_strfreev (params);
+ }
+
+ g_strfreev (fields);
+ }
+
+ /* HARD CODE UP AHEAD
+ *
+ * Now we're finished introspecting, if the summary is from a previous version,
+ * we need to add any summary fields which we're added to the default summary
+ * since the schema version which was introduced here
+ */
+ if (previous_schema >= 1) {
+ SummaryField *summary_field;
+
+ if (previous_schema < 8) {
+
+ /* We used to keep 4 email fields in the summary, before we supported
+ * the multivaliued E_CONTACT_EMAIL... convert the old summary to use
+ * the multivaliued field instead.
+ */
+ if (summary_field_array_index (summary_fields, E_CONTACT_EMAIL_1) >= 0 &&
+ summary_field_array_index (summary_fields, E_CONTACT_EMAIL_2) >= 0 &&
+ summary_field_array_index (summary_fields, E_CONTACT_EMAIL_3) >= 0 &&
+ summary_field_array_index (summary_fields, E_CONTACT_EMAIL_4) >= 0) {
+
+ summary_field_remove (summary_fields, E_CONTACT_EMAIL_1);
+ summary_field_remove (summary_fields, E_CONTACT_EMAIL_2);
+ summary_field_remove (summary_fields, E_CONTACT_EMAIL_3);
+ summary_field_remove (summary_fields, E_CONTACT_EMAIL_4);
+
+ summary_field = summary_field_append (summary_fields,
+ ebsql->priv->folderid,
+ E_CONTACT_EMAIL, NULL);
+ summary_field->index |= INDEX_FLAG (PREFIX);
+ }
+
+ /* Regardless of whether it was a default summary or not, add the sort
+ * keys to anything less than Schema 8 (as long as those fields are at least
+ * in the summary)
+ */
+ if ((i = summary_field_array_index (summary_fields, E_CONTACT_FILE_AS)) >= 0) {
+ summary_field = &g_array_index (summary_fields, SummaryField, i);
+ summary_field->index |= INDEX_FLAG (SORT_KEY);
+ }
+
+ if ((i = summary_field_array_index (summary_fields, E_CONTACT_GIVEN_NAME)) >= 0) {
+ summary_field = &g_array_index (summary_fields, SummaryField, i);
+ summary_field->index |= INDEX_FLAG (SORT_KEY);
+ }
+
+ if ((i = summary_field_array_index (summary_fields, E_CONTACT_FAMILY_NAME)) >= 0) {
+ summary_field = &g_array_index (summary_fields, SummaryField, i);
+ summary_field->index |= INDEX_FLAG (SORT_KEY);
+ }
+ }
+ }
+
+ introspect_summary_finish:
+
+ /* Apply the introspected summary fields */
+ if (success) {
+ summary_fields_array_free (ebsql->priv->summary_fields,
+ ebsql->priv->n_summary_fields);
+
+ ebsql->priv->n_summary_fields = summary_fields->len;
+ ebsql->priv->summary_fields = (SummaryField *) g_array_free (summary_fields, FALSE);
+
+ *introspected_columns = summary_columns;
+ } else if (summary_fields) {
+ gint n_fields;
+ SummaryField *fields;
+
+ /* Properly free the array */
+ n_fields = summary_fields->len;
+ fields = (SummaryField *)g_array_free (summary_fields, FALSE);
+ summary_fields_array_free (fields, n_fields);
+
+ g_slist_free_full (summary_columns, (GDestroyNotify) g_free);
+ }
+
+ g_free (multivalues);
+
+ return success;
+}
+
+/* Called with the lock held and inside a transaction */
+static gboolean
+book_backend_sqlite_init_contacts (EBookBackendSqlite *ebsql,
+ GSList *introspected_columns,
+ GError **error)
+{
+ gint i;
+ gboolean success = TRUE;
+ GString *string;
+ GSList *summary_columns = NULL, *l;
+
+ /* Get a list of all columns and indexes which should be present
+ * in the main summary table */
+ for (i = 0; i < ebsql->priv->n_summary_fields; i++) {
+ SummaryField *field = &(ebsql->priv->summary_fields[i]);
+
+ l = summary_field_list_main_columns (field, ebsql->priv->folderid);
+ summary_columns = g_slist_concat (summary_columns, l);
+ }
+
+ /* Create the main contacts table for this folder
+ */
+ string = g_string_sized_new (32 * g_slist_length (summary_columns));
+ g_string_append (string, "CREATE TABLE IF NOT EXISTS %Q (");
+
+ for (l = summary_columns; l; l = l->next) {
+ ColumnInfo *info = l->data;
+
+ if (l != summary_columns)
+ g_string_append (string, ", ");
+
+ format_column_declaration (string, info);
+ }
+ g_string_append (string, ", vcard TEXT)");
+
+ success = book_backend_sqlite_exec_printf (
+ ebsql, string->str,
+ NULL, NULL, error, ebsql->priv->folderid);
+
+ g_string_free (string, TRUE);
+
+ /* If we introspected something, let's first adjust the contacts table
+ * so that it includes the right columns */
+ if (introspected_columns) {
+
+ /* Add any missing columns which are in the summary fields but
+ * not found in the contacts table
+ */
+ for (l = summary_columns; success && l; l = l->next) {
+ ColumnInfo *info = l->data;
+
+ if (g_slist_find_custom (introspected_columns,
+ info->name, (GCompareFunc)g_ascii_strcasecmp))
+ continue;
+
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "ALTER TABLE %Q ADD COLUMN %s %s %s",
+ NULL, NULL, error, ebsql->priv->folderid,
+ info->name, info->type,
+ info->extra ? info->extra : "");
+ }
+ }
+
+ /* Add indexes to columns in the main contacts table
+ */
+ for (l = summary_columns; success && l; l = l->next) {
+ ColumnInfo *info = l->data;
+
+ success = ensure_column_index (ebsql, ebsql->priv->folderid, info, error);
+ }
+
+ g_slist_free_full (summary_columns, (GDestroyNotify)column_info_free);
+
+ return success;
+}
+
+/* Called with the lock held and inside a transaction */
+static gboolean
+book_backend_sqlite_init_aux_tables (EBookBackendSqlite *ebsql,
+ gint previous_schema,
+ GError **error)
+{
+ GString *string;
+ gboolean success = TRUE;
+ GSList *aux_columns = NULL, *l;
+ gchar *tmp;
+ gint i;
+
+ /* Drop the general 'folder_id_lists' table which was used prior to
+ * version 8 of the schema
+ */
+ if (previous_schema >= 1 && previous_schema < 8) {
+ tmp = g_strconcat (ebsql->priv->folderid, "_lists", NULL);
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "DROP TABLE IF EXISTS %Q",
+ NULL, NULL, error, tmp);
+ g_free (tmp);
+ }
+
+ for (i = 0; success && i < ebsql->priv->n_summary_fields; i++) {
+ SummaryField *field = &(ebsql->priv->summary_fields[i]);
+
+ if (field->type != E_TYPE_CONTACT_ATTR_LIST)
+ continue;
+
+ aux_columns = summary_field_list_aux_columns (field, ebsql->priv->folderid);
+
+ /* Create the auxiliary table for this multi valued field */
+ string = g_string_sized_new (COLUMN_DEFINITION_BYTES * 3 +
+ COLUMN_DEFINITION_BYTES * g_slist_length (aux_columns));
+
+ g_string_append (string, "CREATE TABLE IF NOT EXISTS %Q (uid TEXT NOT NULL REFERENCES %Q
(uid)");
+ for (l = aux_columns; l; l = l->next) {
+ ColumnInfo *info = l->data;
+
+ g_string_append (string, ", ");
+ format_column_declaration (string, info);
+ }
+ g_string_append_c (string, ')');
+
+ success = book_backend_sqlite_exec_printf (
+ ebsql, string->str, NULL, NULL, error,
+ field->aux_table, ebsql->priv->folderid);
+ g_string_free (string, TRUE);
+
+ /* Add indexes to columns in this auxiliary table
+ */
+ for (l = aux_columns; success && l; l = l->next) {
+ ColumnInfo *info = l->data;
+
+ success = ensure_column_index (ebsql, field->aux_table, info, error);
+ }
+
+ g_slist_free_full (aux_columns, (GDestroyNotify)column_info_free);
+ }
+
+ return success;
+}
+
+/* Called with the lock held and inside a transaction */
+static gboolean
+book_backend_sqlite_init_statements (EBookBackendSqlite *ebsql,
+ GError **error)
+{
+ sqlite3_stmt *stmt;
+ gint i;
+
+ ebsql->priv->insert_stmt = book_backend_sqlite_prepare_insert (ebsql, FALSE, error);
+ if (!ebsql->priv->insert_stmt)
+ goto preparation_failed;
+
+ ebsql->priv->replace_stmt = book_backend_sqlite_prepare_insert (ebsql, TRUE, error);
+ if (!ebsql->priv->replace_stmt)
+ goto preparation_failed;
+
+ ebsql->priv->multi_deletes =
+ g_hash_table_new_full (g_direct_hash, g_direct_equal,
+ NULL,
+ (GDestroyNotify)sqlite3_finalize);
+ ebsql->priv->multi_inserts =
+ g_hash_table_new_full (g_direct_hash, g_direct_equal,
+ NULL,
+ (GDestroyNotify)sqlite3_finalize);
+
+ for (i = 0; i < ebsql->priv->n_summary_fields; i++) {
+ SummaryField *field = &(ebsql->priv->summary_fields[i]);
+
+ if (field->type != E_TYPE_CONTACT_ATTR_LIST)
+ continue;
+
+ stmt = book_backend_sqlite_prepare_multi_insert (ebsql, field, error);
+ if (!stmt)
+ goto preparation_failed;
+
+ g_hash_table_insert (ebsql->priv->multi_inserts,
+ GUINT_TO_POINTER (field->field_id),
+ stmt);
+
+ stmt = book_backend_sqlite_prepare_multi_delete (ebsql, field, error);
+ if (!stmt)
+ goto preparation_failed;
+
+ g_hash_table_insert (ebsql->priv->multi_deletes,
+ GUINT_TO_POINTER (field->field_id),
+ stmt);
+ }
+
+ return TRUE;
+
+ preparation_failed:
+
+ return FALSE;
+}
+
+/* Called with the lock held and inside a transaction */
+static gboolean
+book_backend_sqlite_upgrade (EBookBackendSqlite *ebsql,
+ const gchar *region,
+ const gchar *lc_collate,
+ GError **error)
+{
+ gboolean success = FALSE;
+ GSList *vcard_data = NULL;
+ GSList *l;
+
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "SELECT uid, vcard FROM %Q",
+ collect_full_results_cb, &vcard_data, error, ebsql->priv->folderid);
+
+ for (l = vcard_data; success && l; l = l->next) {
+ EbSqlSearchData *const s_data = l->data;
+ EContact *contact = NULL;
+
+ /* It can be we're opening a light summary which was created without
+ * storing the vcards, such as was used in EDS versions 3.2 to 3.6.
+ *
+ * In this case we just want to skip the contacts we can't load
+ * and leave them as is in the SQLite, they will be added from
+ * the old BDB in the case of a migration anyway.
+ */
+ if (s_data->vcard)
+ contact = e_contact_new_from_vcard_with_uid (s_data->vcard, s_data->uid);
+
+ if (contact == NULL)
+ continue;
+
+ success = book_backend_sqlite_insert_contact (ebsql, contact, TRUE, error);
+
+ g_object_unref (contact);
+ }
+
+ g_slist_free_full (vcard_data, (GDestroyNotify)e_book_backend_sqlite_search_data_free);
+
+ if (success)
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "UPDATE folders SET countrycode = %Q WHERE folder_id = %Q",
+ NULL, NULL, error, region, ebsql->priv->folderid);
+
+ if (success)
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "UPDATE folders SET lc_collate = %Q WHERE folder_id = %Q",
+ NULL, NULL, error, lc_collate, ebsql->priv->folderid);
+
+ return success;
+}
+
+/* Called with the lock held and inside a transaction */
+static gboolean
+book_backend_sqlite_init_locale (EBookBackendSqlite *ebsql,
+ gint previous_schema,
+ gboolean already_exists,
+ GError **error)
+{
+ gchar *stored_lc_collate = NULL;
+ const gchar *lc_collate = NULL;
+ gboolean success = TRUE;
+ gboolean relocalized = FALSE;
+
+ /* Get the locale setting for this addressbook */
+ if (already_exists) {
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "SELECT lc_collate FROM folders WHERE folder_id = %Q",
+ get_string_cb, &stored_lc_collate, error, ebsql->priv->folderid);
+
+ lc_collate = stored_lc_collate;
+ }
+
+ if (!lc_collate)
+ /* When creating a new addressbook, or upgrading from a version
+ * where we did not have any locale setting; default to system locale
+ */
+ lc_collate = setlocale (LC_COLLATE, NULL);
+
+ /* Before touching any data, make sure we have a valid ECollator */
+ if (success)
+ success = book_backend_sqlite_set_locale_internal (ebsql, lc_collate, error);
+
+ /* Schema 8 is when we moved from EBookBackendSqliteDB */
+ if (success && previous_schema >= 1 && previous_schema < 8) {
+ gint is_populated = 0;
+
+ /* We need to hold on to the value of any previously set 'is_populated' flag */
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "SELECT is_populated FROM folders WHERE folder_id = %Q",
+ get_int_cb, &is_populated, error, ebsql->priv->folderid);
+
+ if (success) {
+ /* We can't use e_book_backend_sqlite_set_key_value_int() at this
+ * point as that would hold the access locks
+ */
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "INSERT or REPLACE INTO keys (key, value, folder_id) values (%Q, %Q,
%Q)",
+ NULL, NULL, error,
+ E_BOOK_SQL_IS_POPULATED_KEY,
+ is_populated ? "1" : "0",
+ ebsql->priv->folderid);
+ }
+ }
+
+ /* Need to relocalize the whole thing if the schema has been upgraded to version 7 */
+ if (success && previous_schema >= 1 && previous_schema < 7) {
+ success = book_backend_sqlite_upgrade (ebsql, ebsql->priv->region_code, lc_collate, error);
+ relocalized = TRUE;
+ }
+
+ /* We may need to relocalize for a country code change */
+ if (success && relocalized == FALSE && e_phone_number_is_supported ()) {
+ gchar *stored_region = NULL;
+
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "SELECT countrycode FROM folders WHERE folder_id = %Q",
+ get_string_cb, &stored_region, error, ebsql->priv->folderid);
+
+ if (success && g_strcmp0 (ebsql->priv->region_code, stored_region) != 0) {
+ success = book_backend_sqlite_upgrade (ebsql, ebsql->priv->region_code, lc_collate,
error);
+ relocalized = TRUE;
+ }
+
+ g_free (stored_region);
+ }
+
+ g_free (stored_lc_collate);
+
+ return success;
+}
+
+static EBookBackendSqlite *
+e_book_backend_sqlite_new_internal (const gchar *path,
+ const gchar *folderid,
+ gboolean store_vcard,
+ SummaryField *fields,
+ gint n_fields,
+ GError **error)
+{
+ EBookBackendSqlite *ebsql;
+ gchar *dirname = NULL;
+ gint previous_schema = 0;
+ gboolean already_exists = FALSE;
+ gboolean success;
+ GSList *introspected_columns = NULL;
+
+ g_return_val_if_fail (path != NULL, NULL);
+
+ if (folderid == NULL)
+ folderid = "folder_id";
+
+ g_mutex_lock (&dbcon_lock);
+
+ ebsql = book_backend_sqlite_ref_from_hash (path);
+ if (ebsql)
+ goto exit;
+
+ ebsql = g_object_new (E_TYPE_BOOK_BACKEND_SQLITE, NULL);
+ ebsql->priv->path = g_strdup (path);
+ ebsql->priv->folderid = g_strdup (folderid);
+ ebsql->priv->summary_fields = fields;
+ ebsql->priv->n_summary_fields = n_fields;
+ ebsql->priv->store_vcard = store_vcard;
+
+ /* Ensure existance of the directories leading up to 'path' */
+ dirname = g_path_get_dirname (path);
+ if (g_mkdir_with_parents (dirname, 0777) < 0) {
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_OTHER,
+ "Can not make parent directory: %s",
+ g_strerror (errno));
+ g_clear_object (&ebsql);
+ goto exit;
+ }
+
+ /* The additional instance lock is unneccesarry because of the global
+ * lock held here, but let's keep it locked because we hold it while
+ * executing any SQLite code throughout this code
+ */
+ LOCK_MUTEX (&ebsql->priv->lock);
+
+ /* Initialize the SQLite (set some parameters and add some custom hooks) */
+ if (!book_backend_sqlite_init_sqlite (ebsql, path, error)) {
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+ g_clear_object (&ebsql);
+ goto exit;
+ }
+
+ /* Lets do it all atomically inside a single transaction */
+ if (!book_backend_sqlite_start_transaction (ebsql, TRUE, error)) {
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+ g_clear_object (&ebsql);
+ goto exit;
+ }
+
+ /* Initialize main folders table, also retrieve the current
+ * schema version if the table already exists
+ */
+ success = book_backend_sqlite_init_folders (ebsql, &previous_schema, error);
+
+ /* Initialize the key/value table */
+ if (success)
+ success = book_backend_sqlite_init_keys (ebsql, error);
+
+ /* Determine if the addressbook already existed, and fill out
+ * some information in the main folder table
+ */
+ if (success)
+ success = book_backend_sqlite_add_folder (ebsql, &already_exists, error);
+
+ if (success && already_exists) {
+
+ /* If the addressbook did exist, then check how it's configured.
+ *
+ * Let the existing summary information override the current
+ * one asked for by our callers.
+ *
+ * Some summary fields are also adjusted for schema upgrades
+ */
+ success = book_backend_sqlite_introspect_summary (ebsql,
+ previous_schema,
+ &introspected_columns,
+ error);
+ }
+
+ /* Add the contacts table, ensure the right columns are defined
+ * to handle our summary configuration
+ */
+ if (success)
+ success = book_backend_sqlite_init_contacts (ebsql,
+ introspected_columns,
+ error);
+
+ /* Add any auxiliary tables which we might need to support our
+ * summary configuration.
+ *
+ * Any fields which represent a 'list-of-strings' require an
+ * auxiliary table to store them in.
+ */
+ if (success)
+ success = book_backend_sqlite_init_aux_tables (ebsql, previous_schema, error);
+
+ /* At this point we have resolved our schema, let's build our
+ * precompiled statements, we might use them to re-insert contacts
+ * in the next step
+ */
+ if (success)
+ success = book_backend_sqlite_init_statements (ebsql, error);
+
+ /* Load / resolve the current locale setting
+ *
+ * Also perform the overall upgrade in this step
+ * in the case that an upgrade happened, or a locale
+ * change is detected... all rows need to be renormalized
+ * for this.
+ */
+ if (success)
+ success = book_backend_sqlite_init_locale (ebsql,
+ previous_schema,
+ already_exists,
+ error);
+
+
+ if (success)
+ success = book_backend_sqlite_commit_transaction (ebsql, error);
+ else {
+ /* The GError is already set. */
+ book_backend_sqlite_rollback_transaction (ebsql, NULL);
+ }
+
+ /* Release the instance lock and register to the global hash */
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ /* If we failed somewhere, give up on creating the 'ebsql',
+ * otherwise add it to the hash table
+ */
+ if (!success)
+ g_clear_object (&ebsql);
+ else
+ book_backend_sqlite_register_to_hash (ebsql, path);
+
+ exit:
+ /* Cleanup and exit */
+ g_mutex_unlock (&dbcon_lock);
+ g_slist_free_full (introspected_columns, (GDestroyNotify) g_free);
+ g_free (dirname);
+
+ return ebsql;
+}
+
+/**********************************************************
+ * Inserting Contacts *
+ **********************************************************/
+static gchar *
+convert_phone (const gchar *normal,
+ const gchar *region_code,
+ gboolean for_vcard,
+ gint *out_country_code)
+{
+ EPhoneNumber *number = NULL;
+ gchar *return_phone_number = NULL;
+ gchar *national_number = NULL;
+ gint country_code = 0;
+
+ /* Don't warn about erronous phone number strings, it's a perfectly normal
+ * use case for users to enter notes instead of phone numbers in the phone
+ * number contact fields, such as "Ask Jenny for Lisa's phone number"
+ */
+ if (normal && e_phone_number_is_supported ())
+ number = e_phone_number_from_string (normal, region_code, NULL);
+
+ if (number) {
+ EPhoneNumberCountrySource source;
+
+ national_number = e_phone_number_get_national_number (number);
+ country_code = e_phone_number_get_country_code (number, &source);
+ e_phone_number_free (number);
+
+ if (source == E_PHONE_NUMBER_COUNTRY_FROM_DEFAULT)
+ country_code = 0;
+ }
+
+ if (national_number) {
+
+ if (for_vcard) {
+
+ if (country_code)
+ return_phone_number =
+ g_strdup_printf ("+%d|%s",
+ country_code,
+ national_number);
+ else
+ return_phone_number =
+ g_strconcat ("|",
+ national_number,
+ NULL);
+
+ g_free (national_number);
+
+ } else {
+
+ return_phone_number = national_number;
+ }
+ }
+
+ if (out_country_code)
+ *out_country_code = country_code;
+
+ return return_phone_number;
+}
+
+static sqlite3_stmt *
+book_backend_sqlite_prepare_multi_delete (EBookBackendSqlite *ebsql,
+ SummaryField *field,
+ GError **error)
+{
+ sqlite3_stmt *stmt = NULL;
+ gchar *stmt_str;
+
+ stmt_str = sqlite3_mprintf ("DELETE FROM %Q WHERE uid = :uid", field->aux_table);
+ stmt = book_backend_sqlite_prepare_statement (ebsql, stmt_str, error);
+ sqlite3_free (stmt_str);
+
+ return stmt;
+}
+
+static gboolean
+book_backend_sqlite_run_multi_delete (EBookBackendSqlite *ebsql,
+ SummaryField *field,
+ const gchar *uid,
+ GError **error)
+{
+ sqlite3_stmt *stmt;
+ gint ret;
+
+ stmt = g_hash_table_lookup (ebsql->priv->multi_deletes, GUINT_TO_POINTER (field->field_id));
+
+ /* This can return an error if a previous call to sqlite3_step() had errors,
+ * so let's just ignore any error in this case
+ */
+ sqlite3_reset (stmt);
+
+ /* Clear all previously set values */
+ ret = sqlite3_clear_bindings (stmt);
+
+ /* Set the UID host parameter statically */
+ if (ret == SQLITE_OK)
+ ret = sqlite3_bind_text (stmt, 1, uid, -1, SQLITE_STATIC);
+
+ /* Run the statement */
+ return book_backend_sqlite_complete_statement (ebsql, stmt, ret, error);
+}
+
+static sqlite3_stmt *
+book_backend_sqlite_prepare_multi_insert (EBookBackendSqlite *ebsql,
+ SummaryField *field,
+ GError **error)
+{
+ sqlite3_stmt *stmt = NULL;
+ GString *string;
+
+ string = g_string_sized_new (INSERT_MULTI_STMT_BYTES);
+ ebsql_string_append_printf (string, "INSERT INTO %Q (uid, value", field->aux_table);
+
+ if ((field->index & INDEX_FLAG (SUFFIX)) != 0)
+ g_string_append (string, ", value_" EBSQL_SUFFIX_REVERSE);
+
+ if ((field->index & INDEX_FLAG (PHONE)) != 0) {
+ g_string_append (string, ", value_" EBSQL_SUFFIX_PHONE);
+ g_string_append (string, ", value_" EBSQL_SUFFIX_COUNTRY);
+ }
+
+ g_string_append (string, ") VALUES (:uid, :value");
+
+ if ((field->index & INDEX_FLAG (SUFFIX)) != 0)
+ g_string_append (string, ", :value_" EBSQL_SUFFIX_REVERSE);
+
+ if ((field->index & INDEX_FLAG (PHONE)) != 0) {
+ g_string_append (string, ", :value_" EBSQL_SUFFIX_PHONE);
+ g_string_append (string, ", :value_" EBSQL_SUFFIX_COUNTRY);
+ }
+
+ g_string_append_c (string, ')');
+
+ stmt = book_backend_sqlite_prepare_statement (ebsql, string->str, error);
+ g_string_free (string, TRUE);
+
+ return stmt;
+}
+
+static gboolean
+book_backend_sqlite_run_multi_insert_one (EBookBackendSqlite *ebsql,
+ sqlite3_stmt *stmt,
+ SummaryField *field,
+ const gchar *uid,
+ const gchar *value,
+ GError **error)
+{
+ gchar *normal = e_util_utf8_normalize (value);
+ gchar *str;
+ gint ret, param_idx = 1;
+
+ /* :uid */
+ ret = sqlite3_bind_text (stmt, param_idx++, uid, -1, SQLITE_STATIC);
+
+ if (ret == SQLITE_OK) /* :value */
+ ret = sqlite3_bind_text (stmt, param_idx++, normal, -1, g_free);
+
+ if (ret == SQLITE_OK && (field->index & INDEX_FLAG (SUFFIX)) != 0) {
+ if (normal)
+ str = g_utf8_strreverse (normal, -1);
+ else
+ str = NULL;
+
+ /* :value_reverse */
+ ret = sqlite3_bind_text (stmt, param_idx++, str, -1, g_free);
+ }
+
+ if (ret == SQLITE_OK && (field->index & INDEX_FLAG (PHONE)) != 0) {
+ gint country_code;
+
+ str = convert_phone (normal, ebsql->priv->region_code,
+ FALSE, &country_code);
+
+ /* :value_phone */
+ ret = sqlite3_bind_text (stmt, param_idx++, str, -1, g_free);
+
+ /* :value_country */
+ if (ret == SQLITE_OK)
+ sqlite3_bind_int (stmt, param_idx++, country_code);
+
+ }
+
+ /* Run the statement */
+ return book_backend_sqlite_complete_statement (ebsql, stmt, ret, error);
+}
+
+static gboolean
+book_backend_sqlite_run_multi_insert (EBookBackendSqlite *ebsql,
+ SummaryField *field,
+ const gchar *uid,
+ EContact *contact,
+ GError **error)
+{
+ sqlite3_stmt *stmt;
+ GList *values, *l;
+ gboolean success = TRUE;
+
+ stmt = g_hash_table_lookup (ebsql->priv->multi_inserts, GUINT_TO_POINTER (field->field_id));
+ values = e_contact_get (contact, field->field_id);
+
+ for (l = values; success && l != NULL; l = l->next) {
+ gchar *value = (gchar *) l->data;
+
+ success = book_backend_sqlite_run_multi_insert_one (
+ ebsql, stmt, field, uid, value, error);
+ }
+
+ /* Free the list of allocated strings */
+ e_contact_attr_list_free (values);
+
+ return success;
+}
+
+static sqlite3_stmt *
+book_backend_sqlite_prepare_insert (EBookBackendSqlite *ebsql,
+ gboolean replace_existing,
+ GError **error)
+{
+ sqlite3_stmt *stmt;
+ GString *string;
+ gint i;
+
+ string = g_string_new ("");
+ if (replace_existing)
+ ebsql_string_append_printf (string, "INSERT or REPLACE INTO %Q (",
+ ebsql->priv->folderid);
+ else
+ ebsql_string_append_printf (string, "INSERT or FAIL INTO %Q (",
+ ebsql->priv->folderid);
+
+ /*
+ * First specify the column names for the insert, since it's possible we
+ * upgraded the DB and cannot be sure the order of the columns are ordered
+ * just how we like them to be.
+ */
+ for (i = 0; i < ebsql->priv->n_summary_fields; i++) {
+ SummaryField *field = &(ebsql->priv->summary_fields[i]);
+
+ /* Multi values go into a separate table/statement */
+ if (field->type != E_TYPE_CONTACT_ATTR_LIST) {
+
+ /* Only add a ", " before every field except the first,
+ * this will not break because the first 2 fields (UID & REV)
+ * are string fields.
+ */
+ if (i > 0)
+ g_string_append (string, ", ");
+
+ g_string_append (string, field->dbname);
+ }
+
+ if (field->type == G_TYPE_STRING) {
+
+ if ((field->index & INDEX_FLAG (SORT_KEY)) != 0) {
+ g_string_append (string, ", ");
+ g_string_append (string, field->dbname);
+ g_string_append (string, "_" EBSQL_SUFFIX_SORT_KEY);
+ }
+
+ if ((field->index & INDEX_FLAG (SUFFIX)) != 0) {
+ g_string_append (string, ", ");
+ g_string_append (string, field->dbname);
+ g_string_append (string, "_" EBSQL_SUFFIX_REVERSE);
+ }
+
+ if ((field->index & INDEX_FLAG (PHONE)) != 0) {
+
+ g_string_append (string, ", ");
+ g_string_append (string, field->dbname);
+ g_string_append (string, "_" EBSQL_SUFFIX_PHONE);
+
+ g_string_append (string, ", ");
+ g_string_append (string, field->dbname);
+ g_string_append (string, "_" EBSQL_SUFFIX_COUNTRY);
+ }
+ }
+ }
+ g_string_append (string, ", vcard)");
+
+ /*
+ * Now specify values for all of the column names we specified.
+ */
+ g_string_append (string, " VALUES (");
+ for (i = 0; i < ebsql->priv->n_summary_fields; i++) {
+ SummaryField *field = &(ebsql->priv->summary_fields[i]);
+
+ if (field->type != E_TYPE_CONTACT_ATTR_LIST) {
+ /* Only add a ", " before every field except the first,
+ * this will not break because the first 2 fields (UID & REV)
+ * are string fields.
+ */
+ if (i > 0)
+ g_string_append (string, ", ");
+ }
+
+ if (field->type == G_TYPE_STRING || field->type == G_TYPE_BOOLEAN) {
+
+ g_string_append_c (string, ':');
+ g_string_append (string, field->dbname);
+
+ if ((field->index & INDEX_FLAG (SORT_KEY)) != 0)
+ g_string_append_printf (string, ", :%s_" EBSQL_SUFFIX_SORT_KEY,
field->dbname);
+
+ if ((field->index & INDEX_FLAG (SUFFIX)) != 0)
+ g_string_append_printf (string, ", :%s_" EBSQL_SUFFIX_REVERSE, field->dbname);
+
+ if ((field->index & INDEX_FLAG (PHONE)) != 0) {
+ g_string_append_printf (string, ", :%s_" EBSQL_SUFFIX_PHONE, field->dbname);
+ g_string_append_printf (string, ", :%s_" EBSQL_SUFFIX_COUNTRY, field->dbname);
+ }
+
+ } else if (field->type != E_TYPE_CONTACT_ATTR_LIST)
+ g_warn_if_reached ();
+ }
+
+ g_string_append (string, ", :vcard)");
+
+ stmt = book_backend_sqlite_prepare_statement (ebsql, string->str, error);
+ g_string_free (string, TRUE);
+
+ return stmt;
+}
+
+static gboolean
+book_backend_sqlite_run_insert (EBookBackendSqlite *ebsql,
+ gboolean replace_existing,
+ EContact *contact,
+ GError **error)
+{
+ EBookBackendSqlitePrivate *priv;
+ sqlite3_stmt *stmt;
+ gint i, param_idx;
+ gint ret;
+
+ priv = ebsql->priv;
+
+ if (replace_existing)
+ stmt = ebsql->priv->replace_stmt;
+ else
+ stmt = ebsql->priv->insert_stmt;
+
+ /* This can return an error if a previous call to sqlite3_step() had errors,
+ * so let's just ignore any error in this case
+ */
+ sqlite3_reset (stmt);
+
+ /* Clear all previously set values */
+ ret = sqlite3_clear_bindings (stmt);
+
+ for (i = 0, param_idx = 1; ret == SQLITE_OK && i < ebsql->priv->n_summary_fields; i++) {
+ SummaryField *field = &(ebsql->priv->summary_fields[i]);
+
+ if (field->type == G_TYPE_STRING) {
+ gchar *val;
+ gchar *normal;
+ gchar *str;
+
+ val = e_contact_get (contact, field->field_id);
+
+ /* Special exception, never normalize/localize the UID or REV string */
+ if (field->field_id != E_CONTACT_UID &&
+ field->field_id != E_CONTACT_REV) {
+ normal = e_util_utf8_normalize (val);
+ } else
+ normal = g_strdup (val);
+
+ /* Takes ownership of 'normal' */
+ ret = sqlite3_bind_text (stmt, param_idx++, normal, -1, g_free);
+
+ if (ret == SQLITE_OK &&
+ (field->index & INDEX_FLAG (SORT_KEY)) != 0) {
+ if (val)
+ str = e_collator_generate_key (ebsql->priv->collator, val, NULL);
+ else
+ str = g_strdup ("");
+
+ ret = sqlite3_bind_text (stmt, param_idx++, str, -1, g_free);
+ }
+
+ if (ret == SQLITE_OK &&
+ (field->index & INDEX_FLAG (SUFFIX)) != 0) {
+ if (normal)
+ str = g_utf8_strreverse (normal, -1);
+ else
+ str = NULL;
+
+ ret = sqlite3_bind_text (stmt, param_idx++, str, -1, g_free);
+ }
+
+ if (ret == SQLITE_OK &&
+ (field->index & INDEX_FLAG (PHONE)) != 0) {
+ gint country_code;
+
+ str = convert_phone (normal, ebsql->priv->region_code,
+ FALSE, &country_code);
+
+ ret = sqlite3_bind_text (stmt, param_idx++, str, -1, g_free);
+ if (ret == SQLITE_OK)
+ sqlite3_bind_int (stmt, param_idx++, country_code);
+ }
+
+ g_free (val);
+ } else if (field->type == G_TYPE_BOOLEAN) {
+ gboolean val;
+
+ val = e_contact_get (contact, field->field_id) ? TRUE : FALSE;
+
+ ret = sqlite3_bind_int (stmt, param_idx++, val ? 1 : 0);
+ } else if (field->type != E_TYPE_CONTACT_ATTR_LIST)
+ g_warn_if_reached ();
+ }
+
+ if (ret == SQLITE_OK) {
+ gchar *vcard = NULL;
+
+ if (priv->store_vcard)
+ vcard = e_vcard_to_string (E_VCARD (contact), EVC_FORMAT_VCARD_30);
+
+ ret = sqlite3_bind_text (stmt, param_idx++, vcard, -1, g_free);
+ }
+
+ /* Run the statement */
+ return book_backend_sqlite_complete_statement (ebsql, stmt, ret, error);
+}
+
+static void
+update_e164_attribute_params (EVCard *vcard,
+ const gchar *default_region)
+{
+ GList *attr_list;
+
+ for (attr_list = e_vcard_get_attributes (vcard); attr_list; attr_list = attr_list->next) {
+ EVCardAttribute *const attr = attr_list->data;
+ EVCardAttributeParam *param = NULL;
+ gchar *e164 = NULL, *cc, *nn;
+ GList *param_list, *values;
+
+ /* We only attach E164 parameters to TEL attributes. */
+ if (strcmp (e_vcard_attribute_get_name (attr), EVC_TEL) != 0)
+ continue;
+
+ /* Compute E164 number. */
+ values = e_vcard_attribute_get_values (attr);
+
+ e164 = values && values->data ?
+ convert_phone (values->data, default_region, TRUE, NULL) : NULL;
+
+ if (e164 == NULL) {
+ e_vcard_attribute_remove_param (attr, EVC_X_E164);
+ continue;
+ }
+
+ /* Find already exisiting parameter, so that we can reuse it. */
+ for (param_list = e_vcard_attribute_get_params (attr); param_list; param_list =
param_list->next) {
+ if (strcmp (e_vcard_attribute_param_get_name (param_list->data), EVC_X_E164) == 0) {
+ param = param_list->data;
+ break;
+ }
+ }
+
+ /* Create a new parameter instance if needed. Otherwise clean
+ * the existing parameter's values: This is much cheaper than
+ * checking for modifications. */
+ if (param == NULL) {
+ param = e_vcard_attribute_param_new (EVC_X_E164);
+ e_vcard_attribute_add_param (attr, param);
+ } else {
+ e_vcard_attribute_param_remove_values (param);
+ }
+
+ /* Split the phone number into country calling code and
+ * national number code. */
+ nn = strchr (e164, '|');
+
+ if (nn == NULL) {
+ g_warn_if_reached ();
+ continue;
+ }
+
+ *nn++ = '\0';
+ cc = e164;
+
+ /* Assign the parameter values. It seems odd that we revert
+ * the order of NN and CC, but at least EVCard's parser doesn't
+ * permit an empty first param value. Which of course could be
+ * fixed - in order to create a nice potential IOP problem with
+ ** other vCard parsers. */
+ e_vcard_attribute_param_add_values (param, nn, cc, NULL);
+
+ g_free (e164);
+ }
+}
+
+static gboolean
+book_backend_sqlite_insert_contact (EBookBackendSqlite *ebsql,
+ EContact *contact,
+ gboolean replace_existing,
+ GError **error)
+{
+ EBookBackendSqlitePrivate *priv;
+ gboolean success;
+
+ priv = ebsql->priv;
+
+ /* Update E.164 parameters in vcard if needed */
+ if (priv->store_vcard)
+ update_e164_attribute_params (E_VCARD (contact),
+ priv->region_code);
+
+ success = book_backend_sqlite_run_insert (ebsql,
+ replace_existing,
+ contact,
+ error);
+
+ /* Update attribute list table */
+ if (success) {
+ gchar *uid = e_contact_get (contact, E_CONTACT_UID);
+ gint i;
+
+ for (i = 0; success && i < priv->n_summary_fields; i++) {
+ SummaryField *field = &(ebsql->priv->summary_fields[i]);
+
+ if (field->type != E_TYPE_CONTACT_ATTR_LIST)
+ continue;
+
+ success = book_backend_sqlite_run_multi_delete (
+ ebsql, field, uid, error);
+
+ if (success)
+ success = book_backend_sqlite_run_multi_insert (
+ ebsql, field, uid, contact, error);
+ }
+
+ g_free (uid);
+ }
+
+ return success;
+}
+
+/***************************************************************
+ * Structures and utilities for preflight and query generation *
+ ***************************************************************/
+
+/* Internal extension of the EBookQueryTest enumeration
+ *
+ */
+enum {
+ /* 'exists' is a supported query on a field, but not part of EBookQueryTest */
+ BOOK_QUERY_EXISTS = E_BOOK_QUERY_LAST,
+
+ /* From here the compound types start */
+ BOOK_QUERY_SUB_AND,
+ BOOK_QUERY_SUB_OR,
+ BOOK_QUERY_SUB_NOT,
+ BOOK_QUERY_SUB_END,
+
+ BOOK_QUERY_SUB_FIRST = BOOK_QUERY_SUB_AND,
+};
+
+#define IS_QUERY_PHONE(query) \
+ ((query) == E_BOOK_QUERY_EQUALS_PHONE_NUMBER || \
+ (query) == E_BOOK_QUERY_EQUALS_NATIONAL_PHONE_NUMBER || \
+ (query) == E_BOOK_QUERY_EQUALS_SHORT_PHONE_NUMBER)
+
+
+typedef struct {
+ guint query; /* EBookQueryTest (extended) */
+} QueryElement;
+
+typedef struct {
+ guint query; /* EBookQueryTest (extended) */
+} QueryDelimiter;
+
+typedef struct {
+ guint query; /* EBookQueryTest (extended) */
+
+ EContactField field_id; /* The EContactField to compare */
+ SummaryField *field; /* The summary field for 'field' */
+ gchar *value; /* The value to compare with */
+
+ /* For preflighting without collecting strings */
+ guint has_value : 1;
+ guint has_extra : 1;
+} QueryFieldTest;
+
+typedef struct {
+ guint query; /* EBookQueryTest (extended) */
+
+ /* Common fields from QueryFieldTest */
+ EContactField field_id; /* The EContactField to compare */
+ SummaryField *field; /* The summary field for 'field' */
+ gchar *value; /* The value to compare with */
+ guint has_value : 1;
+ guint has_extra : 1;
+
+ /* Extension */
+ gchar *region; /* Region code from the query input */
+ gchar *national; /* Parsed national number */
+ gint country; /* Parsed country code */
+} QueryPhoneTest;
+
+/* This enumeration is ordered by severity, higher values
+ * of PreflightStatus take precedence in error reporting.
+ */
+typedef enum {
+ PREFLIGHT_OK = 0,
+ PREFLIGHT_NOT_SUMMARIZED,
+ PREFLIGHT_INVALID,
+ PREFLIGHT_UNSUPPORTED,
+} PreflightStatus;
+
+typedef enum {
+ PREFLIGHT_FLAG_STR_COLLECT = (1 << 0),
+ PREFLIGHT_FLAG_AUX_COLLECT = (1 << 1)
+} PreflightFlags;
+
+typedef struct {
+ EContactField field_id; /* multi string field id */
+ GPtrArray *constraints; /* segmented query, if applicable */
+} PreflightAuxData;
+
+/* Stack initializer for the PreflightContext struct below */
+#define PREFLIGHT_CONTEXT_INIT { 0, 0, NULL, FALSE, NULL }
+
+typedef struct {
+ PreflightFlags flags;
+
+ PreflightStatus status; /* result status */
+ GPtrArray *constraints; /* main query */
+ gboolean list_all; /* TRUE if all results should be returned */
+
+ GSList *aux_fields; /* List of PreflightAuxData */
+} PreflightContext;
+
+static QueryElement *
+query_delimiter_new (guint query)
+{
+ QueryDelimiter *delim;
+
+ g_return_val_if_fail (query >= BOOK_QUERY_SUB_FIRST, NULL);
+
+ delim = g_slice_new (QueryDelimiter);
+ delim->query = query;
+
+ return (QueryElement *)delim;
+}
+
+static QueryFieldTest *
+query_field_test_new (guint query,
+ EContactField field)
+{
+ QueryFieldTest *test;
+
+ g_return_val_if_fail (query < BOOK_QUERY_SUB_FIRST, NULL);
+ g_return_val_if_fail (IS_QUERY_PHONE (query) == FALSE, NULL);
+
+ test = g_slice_new (QueryFieldTest);
+ test->query = query;
+ test->field_id = field;
+
+ /* Instead of g_slice_new0, NULL them out manually */
+ test->field = NULL;
+ test->value = NULL;
+ test->has_value = FALSE;
+ test->has_extra = FALSE;
+
+ return test;
+}
+
+static QueryPhoneTest *
+query_phone_test_new (guint query,
+ EContactField field)
+{
+ QueryPhoneTest *test;
+
+ g_return_val_if_fail (IS_QUERY_PHONE (query), NULL);
+
+ test = g_slice_new (QueryPhoneTest);
+ test->query = query;
+ test->field_id = field;
+
+ /* Instead of g_slice_new0, NULL them out manually */
+ test->field = NULL;
+ test->value = NULL;
+ test->has_value = FALSE;
+ test->has_extra = FALSE;
+
+ /* Extra QueryPhoneTest fields */
+ test->region = NULL;
+ test->national = NULL;
+ test->country = 0;
+
+ return test;
+}
+
+static void
+query_element_free (QueryElement *element)
+{
+ if (element) {
+
+ if (element->query >= BOOK_QUERY_SUB_FIRST) {
+ QueryDelimiter *delim = (QueryDelimiter *)element;
+
+ g_slice_free (QueryDelimiter, delim);
+ } else if (IS_QUERY_PHONE (element->query)) {
+ QueryPhoneTest *test = (QueryPhoneTest *)element;
+
+ g_free (test->value);
+ g_free (test->region);
+ g_free (test->national);
+ g_slice_free (QueryPhoneTest, test);
+ } else {
+ QueryFieldTest *test = (QueryFieldTest *)element;
+
+ g_free (test->value);
+ g_slice_free (QueryFieldTest, test);
+ }
+ }
+}
+
+/* We use ptr arrays for the QueryElement vectors */
+static inline void
+constraints_insert (GPtrArray *array,
+ gint idx,
+ gpointer data)
+{
+ gint last_idx;
+
+ g_return_if_fail ((idx >= -1) && (idx < (gint)array->len + 1));
+
+ g_ptr_array_add (array, data);
+
+ last_idx = array->len - 1;
+ if (idx < 0 || idx == last_idx)
+ /* Nothing to do, explicitly added to the end anyway */
+ return;
+
+ data = array->pdata[last_idx];
+ memmove (&(array->pdata[idx + 1]),
+ &(array->pdata[idx]),
+ (last_idx - idx) * sizeof (gpointer));
+ array->pdata[idx] = data;
+}
+
+static inline QueryElement *
+constraints_take (GPtrArray *array,
+ gint idx)
+{
+ QueryElement *element;
+
+ g_return_val_if_fail (idx >= 0 && idx < (gint)array->len, NULL);
+
+ element = array->pdata[idx];
+ array->pdata[idx] = NULL;
+ g_ptr_array_remove_index (array, idx);
+
+ return element;
+}
+
+static inline void
+constraints_insert_delimiter (GPtrArray *array,
+ gint idx,
+ guint query)
+{
+ QueryElement *delim;
+
+ delim = query_delimiter_new (query);
+ constraints_insert (array, idx, delim);
+}
+
+static inline void
+constraints_insert_field_test (GPtrArray *array,
+ gint idx,
+ SummaryField *field,
+ guint query,
+ const gchar *value)
+{
+ QueryFieldTest *test;
+
+ test = query_field_test_new (query, field->field_id);
+ test->field = field;
+ test->value = g_strdup (value);
+ test->has_value = (value && value[0]);
+
+ constraints_insert (array, idx, test);
+}
+
+static PreflightAuxData *
+preflight_aux_data_new (EContactField field_id)
+{
+ PreflightAuxData *aux_data = g_slice_new (PreflightAuxData);
+
+ aux_data->field_id = field_id;
+ aux_data->constraints = NULL;
+
+ return aux_data;
+}
+
+static void
+preflight_aux_data_free (PreflightAuxData *aux_data)
+{
+ if (aux_data) {
+ if (aux_data->constraints)
+ g_ptr_array_free (aux_data->constraints, TRUE);
+
+ g_slice_free (PreflightAuxData, aux_data);
+ }
+}
+
+static gint
+preflight_aux_data_find (PreflightAuxData *aux_data,
+ gpointer data)
+{
+ EContactField field_id = GPOINTER_TO_UINT (data);
+
+ /* Unsigned comparison, just to be safe,
+ * let's not return something like:
+ * 'aux_data->field_id - field_id'
+ */
+ if (aux_data->field_id > field_id)
+ return 1;
+ else if (aux_data->field_id < field_id)
+ return -1;
+
+ return 0;
+}
+
+static PreflightAuxData *
+preflight_context_search_aux (PreflightContext *context,
+ EContactField field_id)
+{
+ PreflightAuxData *aux_data = NULL;
+ GSList *link;
+
+ link = g_slist_find_custom (context->aux_fields,
+ GUINT_TO_POINTER (field_id),
+ (GCompareFunc)preflight_aux_data_find);
+ if (link)
+ aux_data = link->data;
+
+ return aux_data;
+}
+
+static void
+preflight_context_clear (PreflightContext *context)
+{
+ if (context) {
+
+ /* Free any allocated data, but leave the context->status in place */
+ if (context->constraints)
+ g_ptr_array_free (context->constraints, TRUE);
+
+ g_slist_free_full (context->aux_fields,
+ (GDestroyNotify)preflight_aux_data_free);
+ }
+}
+
+/* A small API to track the current sub-query context.
+ *
+ * I.e. sub contexts can be OR, AND, or NOT, in which
+ * field tests or other sub contexts are nested.
+ */
+typedef GQueue SubQueryContext;
+
+typedef struct {
+ guint sub_type; /* The type of this sub context */
+ guint count; /* The number of field tests so far in this context */
+} SubQueryData;
+
+#define sub_query_context_new g_queue_new
+#define sub_query_context_free(ctx) g_queue_free (ctx)
+
+static inline void
+sub_query_context_push (SubQueryContext *ctx,
+ guint sub_type)
+{
+ SubQueryData *data;
+
+ data = g_slice_new (SubQueryData);
+ data->sub_type = sub_type;
+ data->count = 0;
+
+ g_queue_push_tail (ctx, data);
+}
+
+static inline void
+sub_query_context_pop (SubQueryContext *ctx)
+{
+ SubQueryData *data;
+
+ data = g_queue_pop_tail (ctx);
+ g_slice_free (SubQueryData, data);
+}
+
+static inline guint
+sub_query_context_peek_type (SubQueryContext *ctx)
+{
+ SubQueryData *data;
+
+ data = g_queue_peek_tail (ctx);
+
+ return data->sub_type;
+}
+
+/* Returns the context field test count before incrementing */
+static inline guint
+sub_query_context_increment (SubQueryContext *ctx)
+{
+ SubQueryData *data;
+
+ data = g_queue_peek_tail (ctx);
+
+ if (data) {
+ data->count++;
+
+ return (data->count - 1);
+ }
+
+ /* If we're not in a sub context, just return 0 */
+ return 0;
+}
+
+/**********************************************************
+ * Querying preflighting *
+ **********************************************************
+ *
+ * The preflight checks are performed before a query might
+ * take place in order to evaluate whether the given query
+ * can be performed with the current summary configuration.
+ *
+ * After preflighting, all relevant data has been extracted
+ * from the search expression and the search expression need
+ * not be parsed again.
+ */
+typedef gboolean (* PreflightSubCallback) (QueryElement *element,
+ gpointer user_data);
+
+static void
+query_preflight_foreach_sub (QueryElement **elements,
+ gint n_elements,
+ gint offset,
+ gboolean include_delim,
+ PreflightSubCallback callback,
+ gpointer user_data)
+{
+ gint sub_counter = 1, i;
+
+ g_return_if_fail (offset >= 0 && offset < n_elements);
+ g_return_if_fail (elements[offset]->query >= BOOK_QUERY_SUB_FIRST);
+ g_return_if_fail (callback != NULL);
+
+ if (include_delim && !callback (elements[offset], user_data))
+ return;
+
+ for (i = (offset + 1); sub_counter > 0 && i < n_elements; i++) {
+
+ if (elements[i]->query >= BOOK_QUERY_SUB_FIRST) {
+
+ if (elements[i]->query == BOOK_QUERY_SUB_END)
+ sub_counter--;
+ else
+ sub_counter++;
+
+ if (include_delim &&
+ !callback (elements[i], user_data))
+ break;
+ } else {
+
+ if (!callback (elements[i], user_data))
+ break;
+ }
+ }
+}
+
+/* Table used in ESExp parsing below */
+static const struct {
+ const gchar *name; /* Name of the symbol to match for this parse phase */
+ gboolean subset; /* TRUE for the subset ESExpIFunc, otherwise the field check ESExpFunc */
+ guint test; /* Extended EBookQueryTest value */
+} check_symbols[] = {
+ { "and", TRUE, BOOK_QUERY_SUB_AND },
+ { "or", TRUE, BOOK_QUERY_SUB_OR },
+ { "not", TRUE, BOOK_QUERY_SUB_NOT },
+
+ { "contains", FALSE, E_BOOK_QUERY_CONTAINS },
+ { "is", FALSE, E_BOOK_QUERY_IS },
+ { "beginswith", FALSE, E_BOOK_QUERY_BEGINS_WITH },
+ { "endswith", FALSE, E_BOOK_QUERY_ENDS_WITH },
+ { "eqphone", FALSE, E_BOOK_QUERY_EQUALS_PHONE_NUMBER },
+ { "eqphone_national", FALSE, E_BOOK_QUERY_EQUALS_NATIONAL_PHONE_NUMBER },
+ { "eqphone_short", FALSE, E_BOOK_QUERY_EQUALS_SHORT_PHONE_NUMBER },
+ { "regex_normal", FALSE, E_BOOK_QUERY_REGEX_NORMAL },
+ { "regex_raw", FALSE, E_BOOK_QUERY_REGEX_RAW },
+ { "exists", FALSE, BOOK_QUERY_EXISTS },
+};
+
+
+/* Cheat our way into passing mode data to these funcs */
+typedef struct {
+ guint query_type : 16;
+ guint flags : 16;
+} CheckFuncData;
+
+static ESExpResult *
+func_check_subset (ESExp *f,
+ gint argc,
+ struct _ESExpTerm **argv,
+ gpointer data)
+{
+ ESExpResult *result, *sub_result;
+ GPtrArray *result_array;
+ QueryElement *element, **sub_elements;
+ gint i, j, len;
+ guint uint_data;
+ CheckFuncData check_data;
+
+ uint_data = GPOINTER_TO_UINT (data);
+ memcpy (&check_data, &uint_data, sizeof (guint));
+
+ /* The compound query delimiter is the first element in this return array */
+ result_array = g_ptr_array_new_with_free_func ((GDestroyNotify)query_element_free);
+ element = query_delimiter_new (check_data.query_type);
+ g_ptr_array_add (result_array, element);
+
+ for (i = 0; i < argc; i++) {
+ sub_result = e_sexp_term_eval (f, argv[i]);
+
+ if (sub_result->type == ESEXP_RES_ARRAY_PTR) {
+ /* Steal the elements directly from the sub result */
+ sub_elements = (QueryElement **)sub_result->value.ptrarray->pdata;
+ len = sub_result->value.ptrarray->len;
+
+ for (j = 0; j < len; j++) {
+ element = sub_elements[j];
+ sub_elements[j] = NULL;
+
+ g_ptr_array_add (result_array, element);
+ }
+ }
+ e_sexp_result_free (f, sub_result);
+ }
+
+ /* The last element in this return array is the sub end delimiter */
+ element = query_delimiter_new (BOOK_QUERY_SUB_END);
+ g_ptr_array_add (result_array, element);
+
+ result = e_sexp_result_new (f, ESEXP_RES_ARRAY_PTR);
+ result->value.ptrarray = result_array;
+
+ return result;
+}
+
+static ESExpResult *
+func_check (struct _ESExp *f,
+ gint argc,
+ struct _ESExpResult **argv,
+ gpointer data)
+{
+ ESExpResult *result;
+ GPtrArray *result_array;
+ QueryElement *element = NULL;
+ EContactField field = 0;
+ const gchar *query_name = NULL;
+ const gchar *query_value = NULL;
+ const gchar *query_extra = NULL;
+ guint uint_data;
+ CheckFuncData check_data;
+
+ uint_data = GPOINTER_TO_UINT (data);
+ memcpy (&check_data, &uint_data, sizeof (guint));
+
+ if (argc == 2 &&
+ argv[0]->type == ESEXP_RES_STRING &&
+ argv[1]->type == ESEXP_RES_STRING) {
+
+ query_name = argv[0]->value.string;
+ query_value = argv[1]->value.string;
+
+ /* We use E_CONTACT_FIELD_LAST to hold the special case of "x-evolution-any-field" */
+ if (g_strcmp0 (query_name, "x-evolution-any-field") == 0)
+ field = E_CONTACT_FIELD_LAST;
+ else
+ field = e_contact_field_id (query_name);
+
+ } else if (argc == 3 &&
+ argv[0]->type == ESEXP_RES_STRING &&
+ argv[1]->type == ESEXP_RES_STRING &&
+ argv[2]->type == ESEXP_RES_STRING) {
+ query_name = argv[0]->value.string;
+ query_value = argv[1]->value.string;
+ query_extra = argv[2]->value.string;
+
+ field = e_contact_field_id (query_name);
+ }
+
+ if (IS_QUERY_PHONE (check_data.query_type)) {
+ QueryPhoneTest *test;
+
+ /* Collect data from this field test */
+ test = query_phone_test_new (check_data.query_type, field);
+ test->has_value = (query_value && query_value[0]);
+ test->has_extra = (query_extra && query_extra[0]);
+
+ /* For phone numbers, we need to collect the strings regardless,
+ * just to pass the preflight check and validate the query
+ */
+ test->value = g_strdup (query_value);
+ test->region = g_strdup (query_extra);
+
+ element = (QueryElement *)test;
+ } else {
+ QueryFieldTest *test;
+
+ /* Collect data from this field test */
+ test = query_field_test_new (check_data.query_type, field);
+ test->has_value = (query_value && query_value[0]);
+ test->has_extra = (query_extra && query_extra[0]);
+
+ /* We avoid collecting strings unless we're going to use them */
+ if ((check_data.flags & PREFLIGHT_FLAG_STR_COLLECT) != 0) {
+ test->value = g_strdup (query_value);
+ }
+
+ element = (QueryElement *)test;
+ }
+
+ /* Return an array with only one element, for lack of a pointer type ESExpResult */
+ result_array = g_ptr_array_new_with_free_func ((GDestroyNotify)query_element_free);
+ g_ptr_array_add (result_array, element);
+
+ result = e_sexp_result_new (f, ESEXP_RES_ARRAY_PTR);
+ result->value.ptrarray = result_array;
+
+ return result;
+}
+
+/* Initial stage of preflighting, parse the search
+ * expression and generate our array of QueryElements
+ */
+static void
+query_preflight_initialize (PreflightContext *context,
+ const gchar *sexp,
+ PreflightFlags flags)
+{
+ ESExp *sexp_parser;
+ ESExpResult *result;
+ gint esexp_error, i;
+
+ context->flags = flags;
+
+ if (sexp == NULL || *sexp == '\0') {
+ context->list_all = TRUE;
+ return;
+ }
+
+ sexp_parser = e_sexp_new ();
+
+ for (i = 0; i < G_N_ELEMENTS (check_symbols); i++) {
+ CheckFuncData check_data;
+ guint uint_data;
+
+ check_data.query_type = check_symbols[i].test;
+ check_data.flags = context->flags;
+ memcpy (&uint_data, &check_data, sizeof (guint));
+
+ if (check_symbols[i].subset) {
+ e_sexp_add_ifunction (
+ sexp_parser, 0, check_symbols[i].name,
+ func_check_subset,
+ GUINT_TO_POINTER (uint_data));
+ } else {
+ e_sexp_add_function (
+ sexp_parser, 0, check_symbols[i].name,
+ func_check,
+ GUINT_TO_POINTER (uint_data));
+ }
+ }
+
+ e_sexp_input_text (sexp_parser, sexp, strlen (sexp));
+ esexp_error = e_sexp_parse (sexp_parser);
+
+ if (esexp_error == -1) {
+ context->status = PREFLIGHT_INVALID;
+ } else {
+
+ result = e_sexp_eval (sexp_parser);
+ if (result) {
+
+ if (result->type == ESEXP_RES_ARRAY_PTR) {
+
+ /* Just steal the array away from the ESexpResult */
+ context->constraints = result->value.ptrarray;
+ result->value.ptrarray = NULL;
+
+ } else {
+ context->status = PREFLIGHT_INVALID;
+ }
+ }
+
+ e_sexp_result_free (sexp_parser, result);
+ }
+
+ e_sexp_unref (sexp_parser);
+}
+
+typedef struct {
+ EBookBackendSqlite *ebsql;
+ gboolean has_attr_list;
+} AttrListCheckData;
+
+static gboolean
+check_has_attr_list_cb (QueryElement *element,
+ gpointer user_data)
+{
+ QueryFieldTest *test = (QueryFieldTest *)element;
+ AttrListCheckData *data = (AttrListCheckData *)user_data;
+
+ /* We havent resolved all the fields at this stage yet */
+ if (!test->field)
+ test->field = summary_field_get (data->ebsql, test->field_id);
+
+ if (test->field && test->field->type == E_TYPE_CONTACT_ATTR_LIST)
+ data->has_attr_list = TRUE;
+
+ /* Keep looping until we find one */
+ return (data->has_attr_list == FALSE);
+}
+
+/* This pass resolves values on the QueryElements useful
+ * for actually performing the query, furthermore it resolves
+ * whether the query can be performed on the SQLite tables or not.
+ */
+static void
+query_preflight_check (PreflightContext *context,
+ EBookBackendSqlite *ebsql)
+{
+ gint i, n_elements;
+ QueryElement **elements;
+
+ context->status = PREFLIGHT_OK;
+
+ elements = (QueryElement **)context->constraints->pdata;
+ n_elements = context->constraints->len;
+
+ for (i = 0; i < n_elements; i++) {
+ QueryFieldTest *test;
+ guint field_test;
+
+ /* We don't care about the subquery delimiters at this point */
+ if (elements[i]->query >= BOOK_QUERY_SUB_FIRST) {
+
+ /* It's too complicated to properly perform
+ * the unary NOT operator on a constraint which
+ * accesses attribute lists.
+ *
+ * Hint, if the contact has a "%.com" email address
+ * and a "%.org" email address, what do we return
+ * for (not (endswith "email" ".com") ?
+ *
+ * Currently we rely on DISTINCT to sort out
+ * muliple results from the attribute list tables,
+ * this breaks down with NOT.
+ */
+ if (elements[i]->query == BOOK_QUERY_SUB_NOT) {
+ AttrListCheckData data = { ebsql, FALSE };
+
+ query_preflight_foreach_sub (elements,
+ n_elements,
+ i, FALSE,
+ check_has_attr_list_cb,
+ &data);
+
+ if (data.has_attr_list)
+ context->status = MAX (context->status,
+ PREFLIGHT_NOT_SUMMARIZED);
+ }
+
+ continue;
+ }
+
+ test = (QueryFieldTest *) elements[i];
+ field_test = (EBookQueryTest)test->query;
+
+ if (!test->field)
+ test->field = summary_field_get (ebsql, test->field_id);
+
+ /* Even if the field is not in the summary, we need to
+ * retport unsupported errors if phone number queries are
+ * issued while libphonenumber is unavailable
+ */
+ if (!test->field) {
+
+ /* Special case for e_book_query_any_field_contains().
+ *
+ * We interpret 'x-evolution-any-field' as E_CONTACT_FIELD_LAST
+ */
+ if (test->field_id == E_CONTACT_FIELD_LAST) {
+
+ /* If we search for a NULL or zero length string, it
+ * means 'get all contacts', that is considered a summary
+ * query but is handled differently (i.e. we just drop the
+ * field tests and run a regular query).
+ *
+ * This is only true if the 'any field contains' query is
+ * the only test in the constraints, however.
+ */
+ if (!test->has_value && n_elements == 1) {
+
+ context->list_all = TRUE;
+
+ } else {
+
+ /* Searching for a value with 'x-evolution-any-field' is
+ * not a summary query.
+ */
+ context->status = MAX (context->status, PREFLIGHT_NOT_SUMMARIZED);
+ }
+
+ } else {
+
+ /* Couldnt resolve the field, it's not a summary query */
+ context->status = MAX (context->status, PREFLIGHT_NOT_SUMMARIZED);
+ }
+ }
+
+ switch (field_test) {
+ case BOOK_QUERY_EXISTS:
+ case E_BOOK_QUERY_IS:
+ case E_BOOK_QUERY_CONTAINS:
+ case E_BOOK_QUERY_BEGINS_WITH:
+ case E_BOOK_QUERY_ENDS_WITH:
+ case E_BOOK_QUERY_REGEX_NORMAL:
+
+ /* All of these queries can only apply to string fields,
+ * or fields which hold multiple strings
+ */
+ if (test->field) {
+
+ if (test->field->type != G_TYPE_STRING &&
+ test->field->type != E_TYPE_CONTACT_ATTR_LIST)
+ context->status = MAX (context->status, PREFLIGHT_INVALID);
+ }
+
+ break;
+
+ case E_BOOK_QUERY_REGEX_RAW:
+ /* Raw regex queries only supported in the fallback */
+ context->status = MAX (context->status, PREFLIGHT_NOT_SUMMARIZED);
+ break;
+
+ case E_BOOK_QUERY_EQUALS_PHONE_NUMBER:
+ case E_BOOK_QUERY_EQUALS_NATIONAL_PHONE_NUMBER:
+ case E_BOOK_QUERY_EQUALS_SHORT_PHONE_NUMBER:
+
+ /* Phone number queries are supported so long as they are in the summary,
+ * libphonenumber is available, and the phone number string is a valid one
+ */
+ if (!e_phone_number_is_supported ()) {
+
+ context->status = MAX (context->status, PREFLIGHT_UNSUPPORTED);
+
+ } else {
+ QueryPhoneTest *phone_test = (QueryPhoneTest *)test;
+ EPhoneNumberCountrySource source;
+ EPhoneNumber *number;
+ const gchar *region_code;
+
+ if (phone_test->region)
+ region_code = phone_test->region;
+ else
+ region_code = ebsql->priv->region_code;
+
+ number = e_phone_number_from_string (phone_test->value,
+ region_code, NULL);
+
+ if (number == NULL) {
+
+ context->status = MAX (context->status, PREFLIGHT_INVALID);
+
+ } else {
+ /* Collect values we'll need later while generating field
+ * tests, no need to parse the phone number more than once
+ */
+ if ((context->flags & PREFLIGHT_FLAG_STR_COLLECT) != 0) {
+
+ phone_test->national = e_phone_number_get_national_number
(number);
+ phone_test->country = e_phone_number_get_country_code
(number, &source);
+
+ if (source == E_PHONE_NUMBER_COUNTRY_FROM_DEFAULT)
+ phone_test->country = 0;
+ }
+
+ e_phone_number_free (number);
+ }
+ }
+ break;
+ }
+
+ if ((context->flags & PREFLIGHT_FLAG_AUX_COLLECT) != 0 &&
+ test->field &&
+ test->field->type == E_TYPE_CONTACT_ATTR_LIST) {
+
+ PreflightAuxData *aux_data;
+
+ aux_data = preflight_context_search_aux (context, test->field_id);
+ if (!aux_data) {
+ aux_data = preflight_aux_data_new (test->field_id);
+ context->aux_fields =
+ g_slist_prepend (context->aux_fields, aux_data);
+ }
+ }
+ }
+
+ /* If we cannot satisfy this query with the summary, there is no point
+ * to return the allocated list */
+ if (context->status > PREFLIGHT_OK) {
+ g_slist_free_full (context->aux_fields,
+ (GDestroyNotify)preflight_aux_data_free);
+ context->aux_fields = NULL;
+ }
+}
+
+/* Handle special case of E_CONTACT_FULL_NAME
+ *
+ * For any query which accesses the full name field,
+ * we need to also OR it with any of the related name
+ * fields, IF those are found in the summary as well.
+ */
+static void
+query_preflight_substitute_full_name (PreflightContext *context,
+ EBookBackendSqlite *ebsql)
+{
+ gint i, j;
+
+ for (i = 0; i < context->constraints->len; i++) {
+ SummaryField *family_name, *given_name, *nickname;
+ QueryElement *element;
+ QueryFieldTest *test;
+
+ element = g_ptr_array_index (context->constraints, i);
+
+ if (element->query >= BOOK_QUERY_SUB_FIRST)
+ continue;
+
+ test = (QueryFieldTest *) element;
+ if (test->field_id != E_CONTACT_FULL_NAME)
+ continue;
+
+ family_name = summary_field_get (ebsql, E_CONTACT_FAMILY_NAME);
+ given_name = summary_field_get (ebsql, E_CONTACT_GIVEN_NAME);
+ nickname = summary_field_get (ebsql, E_CONTACT_NICKNAME);
+
+ /* If any of these are in the summary, then we'll construct
+ * a grouped OR statment for this E_CONTACT_FULL_NAME test */
+ if (family_name || given_name || nickname) {
+ /* Add the OR directly before the E_CONTACT_FULL_NAME test */
+ constraints_insert_delimiter (context->constraints, i, BOOK_QUERY_SUB_OR);
+
+
+ j = i + 2;
+
+ if (family_name)
+ constraints_insert_field_test (context->constraints, j++,
+ family_name, test->query,
+ test->value);
+
+ if (given_name)
+ constraints_insert_field_test (context->constraints, j++,
+ given_name, test->query,
+ test->value);
+
+ if (nickname)
+ constraints_insert_field_test (context->constraints, j++,
+ nickname, test->query,
+ test->value);
+
+ constraints_insert_delimiter (context->constraints, j, BOOK_QUERY_SUB_END);
+
+ i = j;
+ }
+ }
+}
+
+/* Migrates the chunk of the constraints at 'offset' into one of the
+ * PreflightAuxData indicated by aux_field.
+ *
+ * Returns the number of QueryElements which have been removed from
+ * the main constraints
+ */
+static gint
+query_preflight_migrate_offset (PreflightContext *context,
+ EContactField aux_field,
+ gint offset)
+{
+ PreflightAuxData *aux_data;
+ QueryElement **elements;
+ gint n_elements;
+ gint sub_counter = 0;
+ gint dest_offset = 0;
+ gboolean end_needed = FALSE;
+ gint n_migrated = 0;
+
+ aux_data = preflight_context_search_aux (context, aux_field);
+ g_return_val_if_fail (aux_data != NULL, 0);
+
+ if (!aux_data->constraints) {
+
+ /* We created a new batch for 'aux_field',
+ * we'll be adding this batch directly to the beginning
+ */
+ aux_data->constraints = g_ptr_array_new_with_free_func ((GDestroyNotify)query_element_free);
+
+ } else {
+ elements = (QueryElement **)aux_data->constraints->pdata;
+ n_elements = aux_data->constraints->len;
+
+ /* If we're migrating a second or third constraint, we must ensure that
+ * it's encapsulated with an AND
+ */
+ if (elements[0]->query != BOOK_QUERY_SUB_AND) {
+ constraints_insert_delimiter (aux_data->constraints, 0, BOOK_QUERY_SUB_AND);
+
+ /* We're going to add to the end */
+ dest_offset = n_elements - 1;
+
+ end_needed = TRUE;
+ } else {
+ /* We're going to add to the end (before the existing AND statement's end) */
+ dest_offset = n_elements - 2;
+ }
+ }
+
+ elements = (QueryElement **)context->constraints->pdata;
+ n_elements = context->constraints->len;
+
+ do {
+ QueryElement *element;
+
+ /* Migrate one element */
+ element = constraints_take (context->constraints, offset);
+ constraints_insert (aux_data->constraints, dest_offset++, element);
+
+ n_migrated++;
+
+ /* If we migrated a group... migrate the whole group */
+ if (element->query == BOOK_QUERY_SUB_END)
+ sub_counter--;
+ else if (element->query >= BOOK_QUERY_SUB_FIRST)
+ sub_counter++;
+
+ } while (context->constraints->len > offset && sub_counter > 0);
+
+ if (end_needed)
+ constraints_insert_delimiter (aux_data->constraints, -1, BOOK_QUERY_SUB_END);
+
+ /* Return the number of elements removed from the main constraints */
+ return n_migrated;
+}
+
+/* Will set the EContactField to 0 if it's completely isolated
+ * to the summary table, E_CONTACT_FIELD_LAST if it's not isolated,
+ * or another attribute list type EContactField if it's isolated
+ * to that field.
+ *
+ * Expects the initial value to be 'E_CONTACT_FIELD_LAST + 1'
+ */
+static gboolean
+check_isolated_cb (QueryElement *element,
+ gpointer user_data)
+{
+ EContactField *field_id = (EContactField *)user_data;
+ QueryFieldTest *test = (QueryFieldTest *)element;
+
+ if (*field_id > E_CONTACT_FIELD_LAST) {
+
+ /* First field encountered, let's see what it is... */
+ if (test->field->type == E_TYPE_CONTACT_ATTR_LIST)
+ *field_id = test->field_id;
+ else
+ *field_id = 0;
+
+ return TRUE;
+
+ } else if (*field_id == 0) {
+
+ if (test->field->type == E_TYPE_CONTACT_ATTR_LIST) {
+
+ /* Oops, summary and auxiliary encountered */
+ *field_id = E_CONTACT_FIELD_LAST;
+ return FALSE;
+ }
+
+ } else if (test->field_id != *field_id) {
+ /* Auxiliary and something else encountered */
+ *field_id = E_CONTACT_FIELD_LAST;
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static void
+query_preflight_optimize_and (PreflightContext *context,
+ QueryElement **elements,
+ gint n_elements)
+{
+ GSList *list, *l;
+
+ /* First, find the indexes to the various toplevel elements */
+ query_preflight_foreach_sub (elements,
+ n_elements,
+ 0, FALSE,
+ check_isolated_cb,
+ &field_id);
+
+}
+
+static void
+query_preflight_optimize_toplevel (PreflightContext *context,
+ QueryElement **elements,
+ gint n_elements)
+{
+ EContactField field_id;
+
+ if (elements[0]->query >= BOOK_QUERY_SUB_FIRST) {
+
+ switch (elements[0]->query) {
+ case BOOK_QUERY_SUB_AND:
+
+ /* AND components at the toplevel can be migrated, so long
+ * as each component is isolated
+ */
+ query_preflight_optimize_and (context, elements, n_elements);
+ break;
+
+ case BOOK_QUERY_SUB_OR:
+
+ /* OR at the toplevel can be migrated if limited to one table */
+ field_id = E_CONTACT_FIELD_LAST + 1;
+ query_preflight_foreach_sub (elements,
+ n_elements,
+ 0, FALSE,
+ check_isolated_cb,
+ &field_id);
+
+ if (field_id != 0 &&
+ field_id != E_CONTACT_FIELD_LAST) {
+
+ /* Isolated to an auxiliary table, let's migrate it */
+ query_preflight_migrate_offset (context, field_id, 0);
+
+ } else {
+ /* Isolated to the summary table, nothing to optimize */
+ }
+ break;
+
+ case BOOK_QUERY_SUB_NOT:
+
+ /* We dont support NOT operations on attribute lists as
+ * summarized queries, so there can not be any optimization
+ * made here.
+ */
+ break;
+
+ case BOOK_QUERY_SUB_END:
+ default:
+ g_warn_if_reached ();
+ break;
+ }
+
+ } else {
+
+ QueryFieldTest *test = (QueryFieldTest *)elements[0];
+
+ /* Toplevel field test should stand alone at the first position */
+
+ /* Special case of 'x-evolution-any-field' will have no SummaryField
+ * resolved in test->field
+ */
+ if (test->field && test->field->type == E_TYPE_CONTACT_ATTR_LIST)
+ query_preflight_migrate_offset (context, test->field_id, 0);
+ }
+}
+
+/* In this phase, we attempt to pull out field tests from
+ * the main constraints array which touch auxiliary tables
+ * and place them instead into their PreflightAuxData
+ * constraint arrays respectively.
+ *
+ * This will result in queries being generated using nested
+ * select statements before joining, allowing us to leverage
+ * the indexes we created in those.
+ *
+ * A query such as this:
+ *
+ * SELECT DISTINCT summary.uid, summary.vcard FROM 'table' AS summary
+ * LEFT OUTER JOIN 'email_list_table' AS email_list ON summary.uid = email_list.uid
+ * WHERE summary.full_name = 'joe'
+ * AND email_list.value = 'joe email com'
+ *
+ * Becomes:
+ *
+ * SELECT DISTINCT summary.uid, summary.vcard FROM
+ * (
+ * SELECT DISTINCT email_list.uid FROM 'email_list_table' AS email_list
+ * WHERE email_list.value = 'joe email com'
+ * ) AS email_list_results
+ * LEFT OUTER JOIN 'table' AS summary ON summary.uid = email_list_results.uid
+ * WHERE summary.full_name = 'joe'
+ *
+ * A better algorithm should be written, but let's start with these assumptions:
+ *
+ * o Any shallow query with only one auxiliary table constraint can have
+ * the auxiliary constraint migrated into the nested select
+ *
+ * o Any AND query which contains one or more summary constraint
+ * and one or more auxiliary table constraints, can have the auxiliary
+ * table constraints migrated into the nested select.
+ *
+ * o Any OR query which accesses the same table (summary or a specific
+ * auxiliary table) can be considered a logical group, and thus
+ * can be migrated as a group.
+ *
+ * o For the purpose of this optimization, any query contained in a NOT unary
+ * statement can also have it's parenting NOT statement (child included)
+ * migrated based on the same rules above.
+ *
+ */
+static void
+query_preflight_optimize (PreflightContext *context,
+ EBookBackendSqlite *ebsql)
+{
+ QueryElement **elements;
+ gint n_elements;
+
+ if (context->constraints &&
+ context->constraints->len > 0) {
+
+ elements = (QueryElement **)context->constraints->pdata;
+ n_elements = context->constraints->len;
+
+ query_preflight_optimize_toplevel (context, elements, n_elements);
+ }
+
+ if (context->constraints &&
+ context->constraints->len == 0) {
+ g_ptr_array_free (context->constraints, TRUE);
+ context->constraints = NULL;
+ }
+}
+
+static gboolean
+query_preflight_for_summary_check (EBookBackendSqlite *ebsql,
+ const gchar *sexp)
+{
+ PreflightContext context = PREFLIGHT_CONTEXT_INIT;
+
+ query_preflight_initialize (&context, sexp, 0);
+
+ if (context.status == PREFLIGHT_OK)
+ query_preflight_check (&context, ebsql);
+
+ preflight_context_clear (&context);
+
+ return (context.status == PREFLIGHT_OK);
+}
+
+static void
+query_preflight_for_sql_query (PreflightContext *context,
+ EBookBackendSqlite *ebsql,
+ const gchar *sexp)
+{
+ query_preflight_initialize (context, sexp,
+ PREFLIGHT_FLAG_STR_COLLECT |
+ PREFLIGHT_FLAG_AUX_COLLECT);
+
+ if (context->list_all == FALSE &&
+ context->status == PREFLIGHT_OK) {
+
+ query_preflight_check (context, ebsql);
+
+ /* No need to change the constraints if we're not
+ * going to generate statements with it
+ */
+ if (context->status == PREFLIGHT_OK) {
+
+ /* Handle E_CONTACT_FULL_NAME substitutions */
+ query_preflight_substitute_full_name (context, ebsql);
+
+ /* Optimize queries which touch auxiliary columns */
+ query_preflight_optimize (context, ebsql);
+ }
+ }
+
+ if (context->status != PREFLIGHT_OK)
+ context->list_all = FALSE;
+}
+
+/**********************************************************
+ * Field Test Generators *
+ **********************************************************
+ *
+ * This section contains the field test generators for
+ * various EBookQueryTest types. When implementing new
+ * query types, a new GenerateFieldTest needs to be created
+ * and added to the table below.
+ */
+
+typedef void (* GenerateFieldTest) (EBookBackendSqlite *ebsql,
+ GString *string,
+ QueryFieldTest *test);
+
+/* This function escapes characters which need escaping
+ * for LIKE statements as well as the single quotes.
+ *
+ * The return value is not suitable to be formatted
+ * with %Q or %q
+ */
+static gchar *
+ebsql_normalize_for_like (const gchar *value,
+ gboolean reverse_string,
+ gboolean *escape_needed)
+{
+ GString *str;
+ size_t len;
+ gchar c;
+ gboolean escape_modifier_needed = FALSE;
+ gchar *normal = NULL;
+ gchar *reverse = NULL;
+ const gchar *ptr;
+ const gchar *str_to_escape;
+
+ normal = e_util_utf8_normalize (value);
+
+ if (reverse_string) {
+ reverse = g_utf8_strreverse (normal, -1);
+ str_to_escape = reverse;
+ } else
+ str_to_escape = normal;
+
+ /* Just assume each character must be escaped. The result of this function
+ * is discarded shortly after calling this function. Therefore it's
+ * acceptable to possibly allocate twice the memory needed.
+ */
+ len = strlen (str_to_escape);
+ str = g_string_sized_new (2 * len + 4 + strlen (EBSQL_ESCAPE_SEQUENCE) - 1);
+
+ ptr = str_to_escape;
+ while ((c = *ptr++)) {
+ if (c == '\'') {
+ g_string_append_c (str, '\'');
+ } else if (c == '%' || c == '_' || c == '^') {
+ g_string_append_c (str, '^');
+ escape_modifier_needed = TRUE;
+ }
+
+ g_string_append_c (str, c);
+ }
+
+ if (escape_needed)
+ *escape_needed = escape_modifier_needed;
+
+ g_free (normal);
+ g_free (reverse);
+
+ return g_string_free (str, FALSE);
+}
+
+static void
+field_test_query_is (EBookBackendSqlite *ebsql,
+ GString *string,
+ QueryFieldTest *test)
+{
+ SummaryField *field = test->field;
+ gchar *normal;
+
+ normal = e_util_utf8_normalize (test->value);
+
+ ebsql_string_append_column (string, field, NULL);
+ ebsql_string_append_printf (string, " = %Q", normal);
+
+ g_free (normal);
+}
+
+static void
+field_test_query_contains (EBookBackendSqlite *ebsql,
+ GString *string,
+ QueryFieldTest *test)
+{
+ SummaryField *field = test->field;
+ gboolean need_escape;
+ gchar *escaped;
+
+ escaped = ebsql_normalize_for_like (test->value, FALSE, &need_escape);
+
+ g_string_append_c (string, '(');
+
+ ebsql_string_append_column (string, field, NULL);
+ g_string_append (string, " IS NOT NULL AND ");
+ ebsql_string_append_column (string, field, NULL);
+ g_string_append (string, " LIKE '%");
+ g_string_append (string, escaped);
+ g_string_append (string, "%'");
+
+ if (need_escape)
+ g_string_append (string, EBSQL_ESCAPE_SEQUENCE);
+
+ g_string_append_c (string, ')');
+
+ g_free (escaped);
+}
+
+static void
+field_test_query_begins_with (EBookBackendSqlite *ebsql,
+ GString *string,
+ QueryFieldTest *test)
+{
+ SummaryField *field = test->field;
+ gboolean need_escape;
+ gchar *escaped;
+
+ escaped = ebsql_normalize_for_like (test->value, FALSE, &need_escape);
+
+ g_string_append_c (string, '(');
+ ebsql_string_append_column (string, field, NULL);
+ g_string_append (string, " IS NOT NULL AND ");
+
+ ebsql_string_append_column (string, field, NULL);
+ g_string_append (string, " LIKE \'");
+ g_string_append (string, escaped);
+ g_string_append (string, "%\'");
+
+ if (need_escape)
+ g_string_append (string, EBSQL_ESCAPE_SEQUENCE);
+ g_string_append_c (string, ')');
+
+ g_free (escaped);
+}
+
+static void
+field_test_query_ends_with (EBookBackendSqlite *ebsql,
+ GString *string,
+ QueryFieldTest *test)
+{
+ SummaryField *field = test->field;
+ gboolean need_escape;
+ gchar *escaped;
+
+ if ((field->index & INDEX_FLAG (SUFFIX)) != 0) {
+
+ escaped = ebsql_normalize_for_like (test->value,
+ TRUE, &need_escape);
+
+ g_string_append_c (string, '(');
+ ebsql_string_append_column (string, field, EBSQL_SUFFIX_REVERSE);
+ g_string_append (string, " IS NOT NULL AND ");
+
+ ebsql_string_append_column (string, field, EBSQL_SUFFIX_REVERSE);
+ g_string_append (string, " LIKE \'");
+ g_string_append (string, escaped);
+ g_string_append (string, "%\'");
+
+ } else {
+
+ escaped = ebsql_normalize_for_like (test->value,
+ FALSE, &need_escape);
+ g_string_append_c (string, '(');
+
+ ebsql_string_append_column (string, field, NULL);
+ g_string_append (string, " IS NOT NULL AND ");
+
+ ebsql_string_append_column (string, field, NULL);
+ g_string_append (string, " LIKE \'%");
+ g_string_append (string, escaped);
+ g_string_append (string, "\'");
+ }
+
+ if (need_escape)
+ g_string_append (string, EBSQL_ESCAPE_SEQUENCE);
+
+ g_string_append_c (string, ')');
+ g_free (escaped);
+}
+
+static void
+field_test_query_eqphone (EBookBackendSqlite *ebsql,
+ GString *string,
+ QueryFieldTest *test)
+{
+ SummaryField *field = test->field;
+ QueryPhoneTest *phone_test = (QueryPhoneTest *)test;
+
+ if ((field->index & INDEX_FLAG (PHONE)) != 0) {
+
+ g_string_append_c (string, '(');
+ ebsql_string_append_column (string, field, EBSQL_SUFFIX_PHONE);
+ ebsql_string_append_printf (string, " = %Q AND ", phone_test->national);
+
+ /* For exact matches, a country code qualifier is required by both
+ * query input and row input
+ */
+ ebsql_string_append_column (string, field, EBSQL_SUFFIX_COUNTRY);
+ g_string_append (string, " != 0 AND ");
+
+ ebsql_string_append_column (string, field, EBSQL_SUFFIX_COUNTRY);
+ ebsql_string_append_printf (string, " = %d", phone_test->country);
+ g_string_append_c (string, ')');
+
+ } else {
+
+ /* No indexed columns available, perform the fallback */
+ g_string_append (string, EBSQL_FUNC_EQPHONE_EXACT " (");
+ ebsql_string_append_column (string, field, NULL);
+ ebsql_string_append_printf (string, ", %Q)", test->value);
+ }
+}
+
+static void
+field_test_query_eqphone_national (EBookBackendSqlite *ebsql,
+ GString *string,
+ QueryFieldTest *test)
+{
+
+ SummaryField *field = test->field;
+ QueryPhoneTest *phone_test = (QueryPhoneTest *)test;
+
+ if ((field->index & INDEX_FLAG (PHONE)) != 0) {
+
+ /* Only a compound expression if there is a country code */
+ if (phone_test->country)
+ g_string_append_c (string, '(');
+
+ /* Generate: phone = %Q */
+ ebsql_string_append_column (string, field, EBSQL_SUFFIX_PHONE);
+ ebsql_string_append_printf (string, " = %Q", phone_test->national);
+
+ /* When doing a national search, no need to check country
+ * code unless the query number also has a country code
+ */
+ if (phone_test->country) {
+ /* Generate: (phone = %Q AND (country = 0 OR country = %d)) */
+ g_string_append (string, "AND (");
+ ebsql_string_append_column (string, field, EBSQL_SUFFIX_COUNTRY);
+ g_string_append (string, " = 0 OR ");
+ ebsql_string_append_column (string, field, EBSQL_SUFFIX_COUNTRY);
+ ebsql_string_append_printf (string, " = %d))", phone_test->country);
+
+ }
+
+ } else {
+
+ /* No indexed columns available, perform the fallback */
+ g_string_append (string, EBSQL_FUNC_EQPHONE_NATIONAL " (");
+ ebsql_string_append_column (string, field, NULL);
+ ebsql_string_append_printf (string, ", %Q)", test->value);
+ }
+}
+
+static void
+field_test_query_eqphone_short (EBookBackendSqlite *ebsql,
+ GString *string,
+ QueryFieldTest *test)
+{
+ SummaryField *field = test->field;
+
+ /* No quick way to do the short match */
+ g_string_append (string, EBSQL_FUNC_EQPHONE_SHORT " (");
+ ebsql_string_append_column (string, field, NULL);
+ ebsql_string_append_printf (string, ", %Q)", test->value);
+}
+
+static void
+field_test_query_regex_normal (EBookBackendSqlite *ebsql,
+ GString *string,
+ QueryFieldTest *test)
+{
+ SummaryField *field = test->field;
+ gchar *normal;
+
+ normal = e_util_utf8_normalize (test->value);
+
+ if (field->aux_table)
+ ebsql_string_append_printf (string, "%s.value REGEXP %Q",
+ field->aux_table_symbolic,
+ normal);
+ else
+ ebsql_string_append_printf (string, "summary.%s REGEXP %Q",
+ field->dbname,
+ normal);
+
+ g_free (normal);
+}
+
+static void
+field_test_query_exists (EBookBackendSqlite *ebsql,
+ GString *string,
+ QueryFieldTest *test)
+{
+ SummaryField *field = test->field;
+
+ ebsql_string_append_column (string, field, NULL);
+ ebsql_string_append_printf (string, " IS NOT NULL");
+}
+
+/* Lookup table for field test generators per EBookQueryTest,
+ *
+ * WARNING: This must stay in line with the EBookQueryTest definition.
+ */
+static const GenerateFieldTest field_test_func_table[] = {
+ field_test_query_is, /* E_BOOK_QUERY_IS */
+ field_test_query_contains, /* E_BOOK_QUERY_CONTAINS */
+ field_test_query_begins_with, /* E_BOOK_QUERY_BEGINS_WITH */
+ field_test_query_ends_with, /* E_BOOK_QUERY_ENDS_WITH */
+ field_test_query_eqphone, /* E_BOOK_QUERY_EQUALS_PHONE_NUMBER */
+ field_test_query_eqphone_national, /* E_BOOK_QUERY_EQUALS_NATIONAL_PHONE_NUMBER */
+ field_test_query_eqphone_short, /* E_BOOK_QUERY_EQUALS_SHORT_PHONE_NUMBER */
+ field_test_query_regex_normal, /* E_BOOK_QUERY_REGEX_NORMAL */
+ NULL /* Unsupported */, /* E_BOOK_QUERY_REGEX_RAW */
+ field_test_query_exists, /* BOOK_QUERY_EXISTS */
+};
+
+/**********************************************************
+ * Querying Contacts *
+ **********************************************************/
+
+/* The various search types indicate what should be fetched
+ */
+typedef enum {
+ SEARCH_UID_AND_VCARD, /* Get a list of EbSqlSearchData */
+ SEARCH_UID_AND_REV, /* Get a list of EbSqlSearchData, with shallow vcards only containing UID & REV
*/
+ SEARCH_UID, /* Get a list of UID strings */
+ SEARCH_COUNT, /* Get the number of matching rows */
+} SearchType;
+
+static void
+book_backend_sqlite_generate_constraints (EBookBackendSqlite *ebsql,
+ GString *string,
+ GPtrArray *constraints)
+{
+ SubQueryContext *ctx;
+ QueryDelimiter *delim;
+ QueryFieldTest *test;
+ QueryElement **elements;
+ gint n_elements, i;
+
+ elements = (QueryElement **)constraints->pdata;
+ n_elements = constraints->len;
+
+ ctx = sub_query_context_new();
+
+ for (i = 0; i < n_elements; i++) {
+ GenerateFieldTest generate_test_func = NULL;
+
+ /* Seperate field tests with the appropriate grouping */
+ if (elements[i]->query != BOOK_QUERY_SUB_END &&
+ sub_query_context_increment (ctx) > 0) {
+ guint delim_type = sub_query_context_peek_type (ctx);
+
+ switch (delim_type) {
+ case BOOK_QUERY_SUB_AND:
+
+ g_string_append (string, " AND ");
+ break;
+
+ case BOOK_QUERY_SUB_OR:
+
+ g_string_append (string, " OR ");
+ break;
+
+ case BOOK_QUERY_SUB_NOT:
+
+ /* Nothing to do between children of NOT,
+ * there should only ever be one child of NOT anyway
+ */
+ break;
+
+ case BOOK_QUERY_SUB_END:
+ default:
+ g_warn_if_reached ();
+ }
+ }
+
+ if (elements[i]->query >= BOOK_QUERY_SUB_FIRST) {
+ delim = (QueryDelimiter *)elements[i];
+
+ switch (delim->query) {
+
+ case BOOK_QUERY_SUB_NOT:
+
+ /* NOT is a unary operator and as such
+ * comes before the opening parenthesis
+ */
+ g_string_append (string, "NOT ");
+
+ /* Fall through */
+
+ case BOOK_QUERY_SUB_AND:
+ case BOOK_QUERY_SUB_OR:
+
+ /* Open a grouped statement and push the context */
+ sub_query_context_push (ctx, delim->query);
+ g_string_append_c (string, '(');
+ break;
+
+ case BOOK_QUERY_SUB_END:
+ /* Close a grouped statement and pop the context */
+ g_string_append_c (string, ')');
+ sub_query_context_pop (ctx);
+ break;
+ default:
+ g_warn_if_reached ();
+ }
+
+ continue;
+ }
+
+ /* Find the appropriate field test generator */
+ test = (QueryFieldTest *)elements[i];
+ if (test->query < G_N_ELEMENTS (field_test_func_table))
+ generate_test_func = field_test_func_table[test->query];
+
+ /* These should never happen, if it does it should be
+ * fixed in the preflight checks
+ */
+ g_warn_if_fail (generate_test_func != NULL);
+ g_warn_if_fail (test->field != NULL);
+
+ /* Generate the field test */
+ generate_test_func (ebsql, string, test);
+ }
+
+ sub_query_context_free (ctx);
+}
+
+/* Generates the SELECT portion of the query, this will possibly add some
+ * of the constraints into nested selects. Constraints that could not be
+ * nested will have their symbolic table names in context.
+ *
+ * This also handles getting the correct callback and asking for the
+ * right data depending on the 'search_type'
+ */
+static EbSqlSqliteCallback
+book_backend_sqlite_generate_select (EBookBackendSqlite *ebsql,
+ GString *string,
+ SearchType search_type,
+ PreflightContext *context,
+ GError **error)
+{
+ GSList *l;
+ EbSqlSqliteCallback callback = NULL;
+ gchar *first_field = NULL;
+
+ g_string_append (string, "SELECT ");
+ if (context->aux_fields)
+ g_string_append (string, "DISTINCT ");
+
+ switch (search_type) {
+ case SEARCH_UID_AND_VCARD:
+ if (!ebsql->priv->store_vcard) {
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_OTHER,
+ _("Full vcards are not stored in cache, "
+ "vcards cannot be returned"));
+ return FALSE;
+ }
+
+ callback = collect_full_results_cb;
+ g_string_append (string, "summary.uid, summary.vcard ");
+ break;
+ case SEARCH_UID_AND_REV:
+ callback = collect_lean_results_cb;
+ g_string_append (string, "summary.uid, summary.Rev ");
+ break;
+ case SEARCH_UID:
+ callback = collect_uid_results_cb;
+ g_string_append (string, "summary.uid ");
+ break;
+ case SEARCH_COUNT:
+ callback = get_count_cb;
+ if (context->aux_fields)
+ g_string_append (string, "count (DISTINCT summary.uid) ");
+ else
+ g_string_append (string, "count (*) ");
+ break;
+ }
+
+ g_string_append (string, "FROM ");
+
+ for (l = context->aux_fields; l; l = l->next) {
+ PreflightAuxData *aux_data = (PreflightAuxData *)l->data;
+ SummaryField *field = summary_field_get (ebsql, aux_data->field_id);
+
+ /* For every other query, start with the JOIN */
+ if (first_field)
+ g_string_append (string, "LEFT OUTER JOIN ");
+
+ if (aux_data->constraints) {
+ /* A query with the nested selects:
+ *
+ * SELECT DISTINCT summary.uid, summary.vcard FROM
+ * (
+ * SELECT DISTINCT email_list.uid FROM 'folder_id_email_list' AS email_list
+ * WHERE email_list.value = 'janet jackson com'
+ * ) AS email_list_results
+ * LEFT OUTER JOIN
+ * (
+ * SELECT DISTINCT phone_list.uid FROM 'folder_id_phone_list' AS phone_list
+ * WHERE phone_list.value_reverse = '1234567'
+ * ) AS phone_list_results ON phone_list_results.uid = email_list_results.uid
+ * LEFT OUTER JOIN 'folder_id' AS summary ON summary.uid = email_list_results.uid
+ * WHERE summary.full_name = 'janet jackson'
+ */
+ ebsql_string_append_printf (string,
+ "( SELECT DISTINCT %s.uid FROM %Q AS %s WHERE ",
+ field->aux_table_symbolic,
+ field->aux_table,
+ field->aux_table_symbolic);
+ book_backend_sqlite_generate_constraints (ebsql, string, aux_data->constraints);
+ ebsql_string_append_printf (string, " ) AS %s_results ",
+ field->aux_table_symbolic);
+
+ if (first_field)
+ ebsql_string_append_printf (string, "ON %s_results.uid = %s ",
+ field->aux_table_symbolic, first_field);
+
+ if (!first_field)
+ first_field = g_strconcat (field->aux_table_symbolic, "_results.uid", NULL);
+
+ } else {
+ /* Join the table in the normal way and leave the constraints for later */
+ ebsql_string_append_printf (string, "%Q AS %s ",
+ field->aux_table,
+ field->aux_table_symbolic);
+
+ if (first_field)
+ ebsql_string_append_printf (string, "ON %s.uid = %s ",
+ field->aux_table_symbolic,
+ first_field);
+
+ if (!first_field)
+ first_field = g_strconcat (field->aux_table_symbolic, ".uid", NULL);
+ }
+ }
+
+ if (first_field)
+ g_string_append (string, "LEFT OUTER JOIN ");
+
+ ebsql_string_append_printf (string, "%Q AS summary ", ebsql->priv->folderid);
+ if (first_field)
+ ebsql_string_append_printf (string, "ON summary.uid = %s ", first_field);
+
+ g_free (first_field);
+
+ return callback;
+}
+
+static gboolean
+book_backend_sqlite_search_summary (EBookBackendSqlite *ebsql,
+ PreflightContext *context,
+ SearchType search_type,
+ GSList **return_data,
+ GError **error)
+{
+ GString *string;
+ EbSqlSqliteCallback callback = NULL;
+ gboolean success = FALSE;
+
+
+ /* We might calculate a reasonable estimation of bytes
+ * during the preflight checks */
+ string = g_string_sized_new (GENERATED_QUERY_BYTES);
+
+ /* Generate the leading SELECT statement */
+ callback = book_backend_sqlite_generate_select (ebsql,
+ string,
+ search_type,
+ context,
+ error);
+
+ if (callback &&
+ context->list_all == FALSE &&
+ context->constraints != NULL) {
+ /*
+ * Now generate the search expression on the main contacts table
+ */
+ g_string_append (string, "WHERE ");
+ book_backend_sqlite_generate_constraints (ebsql,
+ string,
+ context->constraints);
+ }
+
+ if (callback)
+ success = book_backend_sqlite_exec (ebsql, string->str,
+ callback, return_data,
+ error);
+
+ g_string_free (string, TRUE);
+
+ return success;
+}
+
+static gboolean
+book_backend_sqlite_search_fallback (EBookBackendSqlite *ebsql,
+ PreflightContext *context,
+ const gchar *sexp,
+ SearchType search_type,
+ GSList **return_data,
+ GError **error)
+{
+ GSList *all = NULL, *ret_list = NULL, *l;
+ EBookBackendSExp *bsexp = NULL;
+ GString *string;
+
+ /* Collect all results */
+ string = g_string_new ("");
+ if (!book_backend_sqlite_generate_select (ebsql, string,
+ SEARCH_UID_AND_VCARD,
+ context, error)) {
+ g_string_free (string, TRUE);
+ return FALSE;
+ }
+ if (!book_backend_sqlite_exec (ebsql, string->str,
+ collect_full_results_cb,
+ &all, error)) {
+ g_string_free (string, TRUE);
+ return FALSE;
+ }
+ g_string_free (string, TRUE);
+
+ /* Now filter them manually */
+ bsexp = e_book_backend_sexp_new (sexp);
+
+ for (l = all; l != NULL; l = g_slist_next (l)) {
+ EbSqlSearchData *search_data = (EbSqlSearchData *) l->data;
+
+ if (e_book_backend_sexp_match_vcard (bsexp, search_data->vcard)) {
+
+ switch (search_type) {
+ case SEARCH_UID_AND_VCARD:
+ case SEARCH_UID_AND_REV:
+ ret_list = g_slist_prepend (ret_list, search_data);
+ break;
+ case SEARCH_UID:
+ ret_list = g_slist_prepend (ret_list, g_strdup (search_data->uid));
+ e_book_backend_sqlite_search_data_free (search_data);
+ break;
+ case SEARCH_COUNT:
+ /* SEARCH_COUNT is specific to the cursor API below */
+ g_warn_if_reached ();
+ break;
+ }
+
+ } else {
+ e_book_backend_sqlite_search_data_free (search_data);
+ }
+ }
+
+ g_object_unref (bsexp);
+ g_slist_free (all);
+
+ /* Output the list and return successfully */
+ *return_data = ret_list;
+
+ return TRUE;
+}
+
+/* book_backend_sqlite_search_query:
+ * @ebsql: An EBookBackendSqlite
+ * @sexp: The search expression, or NULL for all contacts
+ * @search_type: Indicates what kind of data should be returned
+ * @return_data: A list of data fetched from the DB, as specified by 'search_type'
+ * @error: Location to store any error which may have occurred
+ *
+ * This is the main common entry point for querying contacts.
+ *
+ * If the query cannot be satisfied with the summary, then
+ * a fallback will automatically be used.
+ *
+ *
+ */
+static gboolean
+book_backend_sqlite_search_query (EBookBackendSqlite *ebsql,
+ const gchar *sexp,
+ SearchType search_type,
+ GSList **return_data,
+ GError **error)
+{
+ PreflightContext context = PREFLIGHT_CONTEXT_INIT;
+
+ gboolean success = FALSE;
+
+ /* Now start with the query preflighting */
+ query_preflight_for_sql_query (&context, ebsql, sexp);
+
+ /* Depending on the preflighting status, search the summary,
+ * fallback on a full search, or report an error.
+ */
+ switch (context.status) {
+ case PREFLIGHT_OK:
+ /* Query expression can be satisfied with our summary,
+ * let's perform the real query now.
+ */
+ success = book_backend_sqlite_search_summary (ebsql,
+ &context,
+ search_type,
+ return_data,
+ error);
+ break;
+
+ case PREFLIGHT_NOT_SUMMARIZED:
+ /* Query expression accesses fields outside the summary,
+ * let's perform our slower fallback routine
+ */
+ success = book_backend_sqlite_search_fallback (ebsql,
+ &context,
+ sexp,
+ search_type,
+ return_data,
+ error);
+ break;
+
+ case PREFLIGHT_INVALID:
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_INVALID_QUERY,
+ _("Invalid query: %s"), sexp);
+ break;
+
+ case PREFLIGHT_UNSUPPORTED:
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_NOT_SUPPORTED,
+ _("Query contained unsupported elements"));
+ break;
+ }
+
+ preflight_context_clear (&context);
+
+ return success;
+}
+
+/**********************************************************
+ * GObjectClass *
+ **********************************************************/
+static void
+e_book_backend_sqlite_dispose (GObject *object)
+{
+ EBookBackendSqlite *ebsql = E_BOOK_BACKEND_SQLITE (object);
+
+ book_backend_sqlite_unregister_from_hash (ebsql);
+
+ /* Chain up to parent's dispose() method. */
+ G_OBJECT_CLASS (e_book_backend_sqlite_parent_class)->dispose (object);
+}
+
+static void
+e_book_backend_sqlite_finalize (GObject *object)
+{
+ EBookBackendSqlite *ebsql = E_BOOK_BACKEND_SQLITE (object);
+ EBookBackendSqlitePrivate *priv = ebsql->priv;
+
+ sqlite3_close (priv->db);
+
+ summary_fields_array_free (priv->summary_fields,
+ priv->n_summary_fields);
+
+ g_free (priv->folderid);
+ g_free (priv->path);
+ g_free (priv->locale);
+ g_free (priv->region_code);
+
+ if (priv->collator)
+ e_collator_unref (priv->collator);
+
+ g_mutex_clear (&priv->lock);
+ g_mutex_clear (&priv->updates_lock);
+
+ sqlite3_finalize (priv->insert_stmt);
+ sqlite3_finalize (priv->replace_stmt);
+
+ if (priv->multi_deletes)
+ g_hash_table_destroy (priv->multi_deletes);
+
+ if (priv->multi_inserts)
+ g_hash_table_destroy (priv->multi_inserts);
+
+ /* Chain up to parent's finalize() method. */
+ G_OBJECT_CLASS (e_book_backend_sqlite_parent_class)->finalize (object);
+}
+
+static void
+e_book_backend_sqlite_class_init (EBookBackendSqliteClass *class)
+{
+ GObjectClass *object_class;
+
+ g_type_class_add_private (class, sizeof (EBookBackendSqlitePrivate));
+
+ object_class = G_OBJECT_CLASS (class);
+ object_class->dispose = e_book_backend_sqlite_dispose;
+ object_class->finalize = e_book_backend_sqlite_finalize;
+}
+
+static void
+e_book_backend_sqlite_init (EBookBackendSqlite *ebsql)
+{
+ ebsql->priv =
+ G_TYPE_INSTANCE_GET_PRIVATE (ebsql,
+ E_TYPE_BOOK_BACKEND_SQLITE,
+ EBookBackendSqlitePrivate);
+
+ ebsql->priv->store_vcard = TRUE;
+
+ ebsql->priv->in_transaction = 0;
+ g_mutex_init (&ebsql->priv->lock);
+ g_mutex_init (&ebsql->priv->updates_lock);
+}
+
+static EBookBackendSqlite *
+e_book_backend_sqlite_new_with_folderid (const gchar *path,
+ const gchar *folderid,
+ gboolean store_vcard,
+ GError **error)
+{
+ EBookBackendSqlite *ebsql;
+ GArray *summary_fields;
+ gint i;
+
+ /* Create the default summary structs */
+ summary_fields = g_array_new (FALSE, FALSE, sizeof (SummaryField));
+ for (i = 0; i < G_N_ELEMENTS (default_summary_fields); i++)
+ summary_field_append (summary_fields, folderid, default_summary_fields[i], NULL);
+
+ /* Add the default index flags */
+ summary_fields_add_indexes (
+ summary_fields,
+ default_indexed_fields,
+ default_index_types,
+ G_N_ELEMENTS (default_indexed_fields));
+
+ ebsql = e_book_backend_sqlite_new_internal (
+ path, folderid,
+ store_vcard,
+ (SummaryField *) summary_fields->data,
+ summary_fields->len,
+ error);
+
+ g_array_free (summary_fields, FALSE);
+
+ return ebsql;
+}
+
+/**
+ * e_book_backend_sqlite_new
+ * @path: location where the db would be created
+ * @store_vcard: True if the vcard should be stored inside db, if FALSE only the summary fields would be
stored inside db.
+ * @error:
+ *
+ * If the path for multiple addressbooks are same, the contacts from all addressbooks
+ * would be stored in same db in different tables.
+ *
+ * Returns:
+ *
+ * Since: 3.2
+ **/
+EBookBackendSqlite *
+e_book_backend_sqlite_new (const gchar *path,
+ gboolean store_vcard,
+ GError **error)
+{
+ return e_book_backend_sqlite_new_with_folderid (path, NULL, store_vcard, error);
+}
+
+/**
+ * e_book_backend_sqlite_new_full:
+ * @path: location where the db would be created
+ * @folderid: folder id of the address-book
+ * @store_vcard: True if the vcard should be stored inside db, if FALSE only the summary fields would be
stored inside db.
+ * @setup: an #ESourceBackendSummarySetup describing how the summary should be setup
+ * @error: A location to store any error that may have occurred
+ *
+ * Like e_book_backend_sqlite_new(), but allows configuration of which contact fields
+ * will be stored for quick reference in the summary. The configuration indicated by
+ * @setup will only be taken into account when initially creating the underlying table,
+ * further configurations will be ignored.
+ *
+ * The fields %E_CONTACT_UID and %E_CONTACT_REV are not optional,
+ * they will be stored in the summary regardless of this function's parameters
+ *
+ * <note><para>Only #EContactFields with the type #G_TYPE_STRING, #G_TYPE_BOOLEAN or
+ * #E_TYPE_CONTACT_ATTR_LIST are currently supported.</para></note>
+ *
+ * Returns: (transfer full): The newly created #EBookBackendSqlite
+ *
+ * Since: 3.8
+ **/
+EBookBackendSqlite *
+e_book_backend_sqlite_new_full (const gchar *path,
+ const gchar *folderid,
+ gboolean store_vcard,
+ ESourceBackendSummarySetup *setup,
+ GError **error)
+{
+ EBookBackendSqlite *ebsql = NULL;
+ EContactField *fields;
+ EContactField *indexed_fields;
+ EBookIndexType *index_types = NULL;
+ gboolean had_error = FALSE;
+ GArray *summary_fields;
+ gint n_fields = 0, n_indexed_fields = 0, i;
+
+ fields = e_source_backend_summary_setup_get_summary_fields (setup, &n_fields);
+ indexed_fields = e_source_backend_summary_setup_get_indexed_fields (setup, &index_types,
&n_indexed_fields);
+
+ /* No specified summary fields indicates the default summary configuration should be used */
+ if (n_fields <= 0) {
+ ebsql = e_book_backend_sqlite_new_with_folderid (path, folderid, store_vcard, error);
+ g_free (fields);
+ g_free (index_types);
+ g_free (indexed_fields);
+
+ return ebsql;
+ }
+
+ summary_fields = g_array_new (FALSE, FALSE, sizeof (SummaryField));
+
+ /* Ensure the non-optional fields first */
+ summary_field_append (summary_fields, folderid, E_CONTACT_UID, error);
+ summary_field_append (summary_fields, folderid, E_CONTACT_REV, error);
+
+ for (i = 0; i < n_fields; i++) {
+ if (!summary_field_append (summary_fields, folderid, fields[i], error)) {
+ had_error = TRUE;
+ break;
+ }
+ }
+
+ if (had_error) {
+ gint n_sfields;
+ SummaryField *sfields;
+
+ /* Properly free the array */
+ n_sfields = summary_fields->len;
+ sfields = (SummaryField *)g_array_free (summary_fields, FALSE);
+ summary_fields_array_free (sfields, n_sfields);
+
+ g_free (fields);
+ g_free (index_types);
+ g_free (indexed_fields);
+ return NULL;
+ }
+
+ /* Add the 'indexed' flag to the SummaryField structs */
+ summary_fields_add_indexes (
+ summary_fields, indexed_fields, index_types, n_indexed_fields);
+
+ ebsql = e_book_backend_sqlite_new_internal (
+ path, folderid,
+ store_vcard,
+ (SummaryField *) summary_fields->data,
+ summary_fields->len,
+ error);
+
+ g_free (fields);
+ g_free (index_types);
+ g_free (indexed_fields);
+ g_array_free (summary_fields, FALSE);
+
+ return ebsql;
+}
+
+gboolean
+e_book_backend_sqlite_lock_updates (EBookBackendSqlite *ebsql,
+ gboolean writer_lock,
+ GError **error)
+{
+ gboolean success;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+
+ LOCK_MUTEX (&ebsql->priv->updates_lock);
+
+ LOCK_MUTEX (&ebsql->priv->lock);
+ success = book_backend_sqlite_start_transaction (ebsql, writer_lock, error);
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ return success;
+}
+
+gboolean
+e_book_backend_sqlite_unlock_updates (EBookBackendSqlite *ebsql,
+ gboolean do_commit,
+ GError **error)
+{
+ gboolean success;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+
+ LOCK_MUTEX (&ebsql->priv->lock);
+ success = do_commit ?
+ book_backend_sqlite_commit_transaction (ebsql, error) :
+ book_backend_sqlite_rollback_transaction (ebsql, error);
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ UNLOCK_MUTEX (&ebsql->priv->updates_lock);
+
+ return success;
+}
+
+/**
+ * e_book_backend_sqlite_ref_collator:
+ * @ebsql: An #EBookBackendSqlite
+ *
+ * References the currently active #ECollator for @ebsql,
+ * use e_collator_unref() when finished using the returned collator.
+ *
+ * Note that the active collator will change with the active locale setting.
+ *
+ * Returns: (transfer full): A reference to the active collator.
+ */
+ECollator *
+e_book_backend_sqlite_ref_collator (EBookBackendSqlite *ebsql)
+{
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), NULL);
+
+ return e_collator_ref (ebsql->priv->collator);
+}
+
+/**
+ * e_book_backend_sqlite_add_contact
+ * @ebsql: An #EBookBackendSqlite
+ * @contact: EContact to be added
+ * @replace_existing: Whether this contact should replace another contact with the same UID.
+ * @error: A location to store any error that may have occurred.
+ *
+ * This is a convenience wrapper for e_book_backend_sqlite_add_contacts,
+ * which is the preferred means to add or modify multiple contacts when possible.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 3.8
+ **/
+gboolean
+e_book_backend_sqlite_add_contact (EBookBackendSqlite *ebsql,
+ EContact *contact,
+ gboolean replace_existing,
+ GError **error)
+{
+ GSList l;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+ g_return_val_if_fail (E_IS_CONTACT (contact), FALSE);
+
+ l.data = contact;
+ l.next = NULL;
+
+ return e_book_backend_sqlite_add_contacts (
+ ebsql, &l,
+ replace_existing, error);
+}
+
+/**
+ * e_book_backend_sqlite_add_contacts
+ * @ebsql: An #EBookBackendSqlite
+ * @contacts: list of EContacts
+ * @replace_existing: Whether this contact should replace another contact with the same UID.
+ * @error: A location to store any error that may have occurred.
+ *
+ * Adds or replaces contacts in @ebsql. If @replace_existing is specified then existing
+ * contacts with the same UID will be replaced, otherwise adding an existing contact
+ * will return an error.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 3.8
+ **/
+gboolean
+e_book_backend_sqlite_add_contacts (EBookBackendSqlite *ebsql,
+ GSList *contacts,
+ gboolean replace_existing,
+ GError **error)
+{
+ GSList *l;
+ gboolean success = TRUE;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+ g_return_val_if_fail (contacts != NULL, FALSE);
+
+ LOCK_MUTEX (&ebsql->priv->lock);
+
+ if (!book_backend_sqlite_start_transaction (ebsql, TRUE, error)) {
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+ return FALSE;
+ }
+
+ for (l = contacts; success && l != NULL; l = g_slist_next (l)) {
+ EContact *contact = (EContact *) l->data;
+
+ success = book_backend_sqlite_insert_contact (
+ ebsql, contact, replace_existing, error);
+ }
+
+ if (success)
+ success = book_backend_sqlite_commit_transaction (ebsql, error);
+ else
+ /* The GError is already set. */
+ book_backend_sqlite_rollback_transaction (ebsql, NULL);
+
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ return success;
+}
+
+/**
+ * e_book_backend_sqlite_remove_contact:
+ *
+ * FIXME: Document me.
+ *
+ * Since: 3.2
+ **/
+gboolean
+e_book_backend_sqlite_remove_contact (EBookBackendSqlite *ebsql,
+ const gchar *uid,
+ GError **error)
+{
+ GSList l;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+ g_return_val_if_fail (uid != NULL, FALSE);
+
+ l.data = (gchar *) uid; /* Won't modify it, I promise :) */
+ l.next = NULL;
+
+ return e_book_backend_sqlite_remove_contacts (
+ ebsql, &l, error);
+}
+
+static gchar *
+generate_delete_stmt (const gchar *table,
+ GSList *uids)
+{
+ GString *str = g_string_new (NULL);
+ GSList *l;
+
+ ebsql_string_append_printf (str, "DELETE FROM %Q WHERE uid IN (", table);
+
+ for (l = uids; l; l = l->next) {
+ const gchar *uid = (const gchar *) l->data;
+
+ /* First uid with no comma */
+ if (l != uids)
+ g_string_append_printf (str, ", ");
+
+ ebsql_string_append_printf (str, "%Q", uid);
+ }
+
+ g_string_append_c (str, ')');
+
+ return g_string_free (str, FALSE);
+}
+
+/**
+ * e_book_backend_sqlite_remove_contacts:
+ *
+ * FIXME: Document me.
+ *
+ * Since: 3.2
+ **/
+gboolean
+e_book_backend_sqlite_remove_contacts (EBookBackendSqlite *ebsql,
+ GSList *uids,
+ GError **error)
+{
+ gboolean success = TRUE;
+ gint i;
+ gchar *stmt;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+ g_return_val_if_fail (uids != NULL, FALSE);
+
+ LOCK_MUTEX (&ebsql->priv->lock);
+
+ if (!book_backend_sqlite_start_transaction (ebsql, TRUE, error)) {
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+ return FALSE;
+ }
+
+ /* Delete data from the auxiliary tables first */
+ for (i = 0; success && i < ebsql->priv->n_summary_fields; i++) {
+ SummaryField *field = &(ebsql->priv->summary_fields[i]);
+
+ if (field->type != E_TYPE_CONTACT_ATTR_LIST)
+ continue;
+
+ stmt = generate_delete_stmt (field->aux_table, uids);
+ success = book_backend_sqlite_exec (ebsql, stmt, NULL, NULL, error);
+ g_free (stmt);
+ }
+
+ /* Now delete the entry from the main contacts */
+ if (success) {
+ stmt = generate_delete_stmt (ebsql->priv->folderid, uids);
+ success = book_backend_sqlite_exec (ebsql, stmt, NULL, NULL, error);
+ g_free (stmt);
+ }
+
+ if (success)
+ success = book_backend_sqlite_commit_transaction (ebsql, error);
+ else
+ /* The GError is already set. */
+ book_backend_sqlite_rollback_transaction (ebsql, NULL);
+
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ return success;
+}
+
+/**
+ * e_book_backend_sqlite_has_contact:
+ *
+ * FIXME: Document me.
+ *
+ * Since: 3.2
+ **/
+gboolean
+e_book_backend_sqlite_has_contact (EBookBackendSqlite *ebsql,
+ const gchar *uid,
+ gboolean *exists,
+ GError **error)
+{
+ gboolean local_exists = FALSE;
+ gboolean success;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+ g_return_val_if_fail (uid != NULL, FALSE);
+ g_return_val_if_fail (exists != NULL, FALSE);
+
+ LOCK_MUTEX (&ebsql->priv->lock);
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "SELECT uid FROM %Q WHERE uid = %Q",
+ get_exists_cb, &local_exists, error, ebsql->priv->folderid, uid);
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ *exists = local_exists;
+
+ return success;
+}
+
+/**
+ * e_book_backend_sqlite_get_contact:
+ *
+ * FIXME: Document me.
+ *
+ * Since: 3.2
+ **/
+gboolean
+e_book_backend_sqlite_get_contact (EBookBackendSqlite *ebsql,
+ const gchar *uid,
+ gboolean meta_contact,
+ EContact **contact,
+ GError **error)
+{
+ gboolean success = FALSE;
+ gchar *vcard = NULL;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+ g_return_val_if_fail (uid != NULL, FALSE);
+ g_return_val_if_fail (contact != NULL && *contact == NULL, FALSE);
+
+ success = e_book_backend_sqlite_get_vcard_string (ebsql,
+ uid,
+ meta_contact,
+ &vcard,
+ error);
+
+ if (success && vcard) {
+ *contact = e_contact_new_from_vcard_with_uid (vcard, uid);
+ g_free (vcard);
+ }
+
+ return success;
+}
+
+/**
+ * e_book_backend_sqlite_get_vcard_string:
+ * @ebsql: An #EBookBackendSqlite
+ * @uid: The uid to fetch a vcard for
+ * @fields_of_interest: The required fields for this vcard, or %NULL to require all fields.
+ * @with_all_required_fields: (allow none) (out): Whether all the required fields are present in the
returned vcard.
+ * @error: A location to store any error that may have occurred.
+ *
+ * Searches @ebsql in the context of @folderid for @uid.
+ *
+ * If @ebsql is configured to store the whole vcards, the whole vcard will be returned.
+ * Otherwise the summary cache will be searched and the virtual vcard will be built
+ * from the summary cache.
+ *
+ * In either case, @with_all_required_fields if specified, will be updated to reflect whether
+ * the returned vcard string satisfies the passed 'fields_of_interest' parameter.
+ *
+ * Returns: (transfer full): The vcard string for @uid or %NULL if @uid was not found.
+ *
+ * Since: 3.2
+ */
+gboolean
+e_book_backend_sqlite_get_vcard_string (EBookBackendSqlite *ebsql,
+ const gchar *uid,
+ gboolean meta_contact,
+ gchar **ret_vcard,
+ GError **error)
+{
+ gboolean success = FALSE;
+ gchar *vcard_str = NULL;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+ g_return_val_if_fail (uid != NULL, FALSE);
+ g_return_val_if_fail (ret_vcard != NULL && *ret_vcard == NULL, FALSE);
+
+ LOCK_MUTEX (&ebsql->priv->lock);
+
+ /* Try constructing contacts from only UID/REV first if that's requested */
+ if (meta_contact) {
+ GSList *vcards = NULL;
+
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "SELECT summary.uid, summary.Rev FROM %Q AS summary WHERE uid = %Q",
+ collect_lean_results_cb, &vcards, error,
+ ebsql->priv->folderid, uid);
+
+ if (vcards) {
+ EbSqlSearchData *search_data = (EbSqlSearchData *) vcards->data;
+
+ vcard_str = search_data->vcard;
+ search_data->vcard = NULL;
+
+ g_slist_free_full (vcards, (GDestroyNotify)e_book_backend_sqlite_search_data_free);
+ vcards = NULL;
+ }
+
+ } else if (ebsql->priv->store_vcard) {
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "SELECT vcard FROM %Q WHERE uid = %Q",
+ get_string_cb, &vcard_str, error, ebsql->priv->folderid, uid);
+ } else {
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_OTHER,
+ _("Full vcards are not stored in cache, "
+ "vcards cannot be returned"));
+ }
+
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ *ret_vcard = vcard_str;
+
+ if (success && !vcard_str) {
+ /* Odd, but true */
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_CONTACT_NOT_FOUND,
+ _("Contact '%s' not found"), uid);
+ success = FALSE;
+ }
+
+ return success;
+}
+
+/**
+ * e_book_backend_sqlite_check_summary_query:
+ * @ebsql: an #EBookBackendSqlite
+ * @sexp: the search expression to check
+ *
+ * Checks whether @sexp contains only checks for the summary fields
+ * configured in @ebsql, and thus can be executed without falling
+ * back to a full search.
+ *
+ * Since: 3.8
+ **/
+gboolean
+e_book_backend_sqlite_check_summary_query (EBookBackendSqlite *ebsql,
+ const gchar *sexp)
+{
+ gboolean is_summary;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+
+ LOCK_MUTEX (&ebsql->priv->lock);
+ is_summary = query_preflight_for_summary_check (ebsql, sexp);
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ return is_summary;
+}
+
+/**
+ * e_book_backend_sqlite_search
+ * @ebsql:
+ * @sexp: search expression; use NULL or an empty string to get all stored
+ * contacts.
+ * @fields_of_interest: a #GHashTable containing the names of fields to return,
+ * or NULL for all. At the moment if this is non-null, the vcard will be
+ * populated with summary fields, else it would return the whole vcard if
+ * its stored in the db. [not implemented fully]
+ * @searched: (allow none) (out): Whether @ebsql was capable of searching
+ * for the provided query @sexp.
+ * @with_all_required_fields: (allow none) (out): Whether all the required
+ * fields are present in the returned vcards.
+ * @error:
+ *
+ * Searching with summary fields is always supported. Search expressions
+ * containing any other field is supported only if backend chooses to store
+ * the vcard inside the db.
+ *
+ * Summary fields - uid, rev, nickname, given_name, family_name, file_as
+ * email_1, email_2, email_3, email_4, is_list, list_show_addresses, wants_html
+ *
+ * If @ebsql was incapable of returning vcards with results that satisfy
+ * @fields_of_interest, then @with_all_required_fields will be updated to
+ * @FALSE and only uid fields will be present in the returned vcards. This
+ * can be useful when a summary query succeeds and the returned list can be
+ * used to iterate and fetch for full required data from another persistance.
+ *
+ * Returns: List of EbSqlSearchData.
+ *
+ * Since: 3.2
+ **/
+gboolean
+e_book_backend_sqlite_search (EBookBackendSqlite *ebsql,
+ const gchar *sexp,
+ gboolean meta_contacts,
+ GSList **ret_list,
+ GError **error)
+{
+ gboolean success;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+ g_return_val_if_fail (ret_list != NULL && *ret_list == NULL, FALSE);
+
+ LOCK_MUTEX (&ebsql->priv->lock);
+ success = book_backend_sqlite_search_query (ebsql, sexp,
+ meta_contacts ?
+ SEARCH_UID_AND_REV : SEARCH_UID_AND_VCARD,
+ ret_list,
+ error);
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ return success;
+}
+
+/**
+ * e_book_backend_sqlite_search_uids:
+ *
+ * FIXME: Document me.
+ *
+ * Since: 3.2
+ **/
+gboolean
+e_book_backend_sqlite_search_uids (EBookBackendSqlite *ebsql,
+ const gchar *sexp,
+ GSList **ret_list,
+ GError **error)
+{
+ gboolean success;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+ g_return_val_if_fail (ret_list != NULL && *ret_list == NULL, FALSE);
+
+ LOCK_MUTEX (&ebsql->priv->lock);
+ success = book_backend_sqlite_search_query (ebsql, sexp,
+ SEARCH_UID,
+ ret_list,
+ error);
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ return success;
+}
+
+/**
+ * e_book_backend_sqlite_get_uids_and_rev:
+ *
+ * Gets hash table of all uids (key) and rev (value) pairs stored
+ * for each contact in the cache. The hash table should be freed
+ * with g_hash_table_destroy(), if not needed anymore. Each key
+ * and value is a newly allocated string.
+ *
+ * Since: 3.4
+ **/
+GHashTable *
+e_book_backend_sqlite_get_uids_and_rev (EBookBackendSqlite *ebsql,
+ GError **error)
+{
+ GHashTable *uids_and_rev;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), NULL);
+
+ uids_and_rev = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
+
+ LOCK_MUTEX (&ebsql->priv->lock);
+ book_backend_sqlite_exec_printf (
+ ebsql, "SELECT uid, rev FROM %Q",
+ collect_uids_and_rev_cb, uids_and_rev, error, ebsql->priv->folderid);
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ return uids_and_rev;
+}
+
+/**
+ * e_book_backend_sqlite_get_key_value:
+ *
+ * FIXME: Document me.
+ *
+ * Since: 3.2
+ **/
+gboolean
+e_book_backend_sqlite_get_key_value (EBookBackendSqlite *ebsql,
+ const gchar *key,
+ gchar **value,
+ GError **error)
+{
+ gboolean success;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+ g_return_val_if_fail (key != NULL, FALSE);
+ g_return_val_if_fail (value != NULL && *value == NULL, FALSE);
+
+ LOCK_MUTEX (&ebsql->priv->lock);
+
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "SELECT value FROM keys WHERE folder_id = %Q AND key = %Q",
+ get_string_cb, value, error, ebsql->priv->folderid, key);
+
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ return success;
+}
+
+/**
+ * e_book_backend_sqlite_set_key_value:
+ *
+ * FIXME: Document me.
+ *
+ * Since: 3.2
+ **/
+gboolean
+e_book_backend_sqlite_set_key_value (EBookBackendSqlite *ebsql,
+ const gchar *key,
+ const gchar *value,
+ GError **error)
+{
+ gboolean success;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+ g_return_val_if_fail (key != NULL, FALSE);
+ g_return_val_if_fail (value != NULL, FALSE);
+
+ LOCK_MUTEX (&ebsql->priv->lock);
+
+ if (!book_backend_sqlite_start_transaction (ebsql, TRUE, error)) {
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+ return FALSE;
+ }
+
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "INSERT or REPLACE INTO keys (key, value, folder_id) values (%Q, %Q, %Q)",
+ NULL, NULL, error, key, value, ebsql->priv->folderid);
+
+ if (success)
+ success = book_backend_sqlite_commit_transaction (ebsql, error);
+ else
+ /* The GError is already set. */
+ book_backend_sqlite_rollback_transaction (ebsql, NULL);
+
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ return success;
+}
+
+/**
+ * e_book_backend_sqlite_get_key_value_int:
+ *
+ * FIXME: Document me.
+ *
+ * Since: 3.2
+ **/
+gboolean
+e_book_backend_sqlite_get_key_value_int (EBookBackendSqlite *ebsql,
+ const gchar *key,
+ gint *value,
+ GError **error)
+{
+ gboolean success;
+ gchar *str_value = NULL;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+ g_return_val_if_fail (key != NULL, FALSE);
+ g_return_val_if_fail (value != NULL, FALSE);
+
+ success = e_book_backend_sqlite_get_key_value (ebsql, key, &str_value, error);
+
+ if (success) {
+
+ if (str_value)
+ *value = g_ascii_strtoll (str_value, NULL, 10);
+ else
+ *value = 0;
+
+ g_free (str_value);
+ }
+
+ return success;
+}
+
+/**
+ * e_book_backend_sqlite_set_key_value_int:
+ *
+ * FIXME: Document me.
+ *
+ * Since: 3.2
+ **/
+gboolean
+e_book_backend_sqlite_set_key_value_int (EBookBackendSqlite *ebsql,
+ const gchar *key,
+ gint value,
+ GError **error)
+{
+ gboolean success;
+ gchar *str_value = NULL;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+ g_return_val_if_fail (key != NULL, FALSE);
+
+ str_value = g_strdup_printf ("%d", value);
+ success = e_book_backend_sqlite_set_key_value (ebsql,
+ key,
+ str_value,
+ error);
+ g_free (str_value);
+
+ return success;
+}
+
+/**
+ * e_book_backend_sqlite_search_data_free:
+ *
+ * FIXME: Document me.
+ *
+ * Since: 3.2
+ **/
+void
+e_book_backend_sqlite_search_data_free (EbSqlSearchData *s_data)
+{
+ if (s_data) {
+ g_free (s_data->uid);
+ g_free (s_data->vcard);
+ g_slice_free (EbSqlSearchData, s_data);
+ }
+}
+
+static gboolean
+book_backend_sqlite_set_locale_internal (EBookBackendSqlite *ebsql,
+ const gchar *locale,
+ GError **error)
+{
+ EBookBackendSqlitePrivate *priv = ebsql->priv;
+ ECollator *collator;
+ gchar *region_code = NULL;
+
+ if (g_strcmp0 (priv->locale, locale) != 0) {
+
+ if (e_phone_number_is_supported ()) {
+ region_code = e_phone_number_get_default_region (error);
+ if (!region_code)
+ return FALSE;
+ }
+
+ collator = e_collator_new (locale, error);
+ if (!collator) {
+ g_free (region_code);
+ return FALSE;
+ }
+
+ /* Assign region code XXX should be tied to the locale and parsed by ICU */
+ g_free (priv->region_code);
+ priv->region_code = region_code;
+
+ /* Assign locale */
+ g_free (priv->locale);
+ priv->locale = g_strdup (locale);
+
+ /* Assign collator */
+ if (ebsql->priv->collator)
+ e_collator_unref (ebsql->priv->collator);
+ ebsql->priv->collator = collator;
+ }
+
+ return TRUE;
+}
+
+/**
+ * e_book_backend_sqlite_set_locale:
+ * @ebsql: An #EBookBackendSqlite
+ * @lc_collate: The new locale for the addressbook
+ * @error: A location to store any error that may have occurred
+ *
+ * Relocalizes any locale specific data in the specified
+ * new @lc_collate locale.
+ *
+ * The @lc_collate locale setting is stored and remembered on
+ * subsequent accesses of the addressbook, changing the locale
+ * will store the new locale and will modify sort keys and any
+ * locale specific data in the addressbook.
+ *
+ * Returns: Whether the new locale was successfully set.
+ *
+ * Since: 3.12
+ */
+gboolean
+e_book_backend_sqlite_set_locale (EBookBackendSqlite *ebsql,
+ const gchar *lc_collate,
+ GError **error)
+{
+ gboolean success;
+ gchar *stored_lc_collate;
+ gchar *current_region = NULL;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+
+ LOCK_MUTEX (&ebsql->priv->lock);
+
+ if (e_phone_number_is_supported ()) {
+ current_region = e_phone_number_get_default_region (error);
+
+ if (current_region == NULL) {
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+ return FALSE;
+ }
+ }
+
+ if (!book_backend_sqlite_set_locale_internal (ebsql, lc_collate, error)) {
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+ g_free (current_region);
+ return FALSE;
+ }
+
+ if (!book_backend_sqlite_start_transaction (ebsql, TRUE, error)) {
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+ g_free (current_region);
+ return FALSE;
+ }
+
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "SELECT lc_collate FROM folders WHERE folder_id = %Q",
+ get_string_cb, &stored_lc_collate, error, ebsql->priv->folderid);
+
+ if (success && g_strcmp0 (stored_lc_collate, lc_collate) != 0)
+ success = book_backend_sqlite_upgrade (ebsql, ebsql->priv->region_code, lc_collate, error);
+
+ /* If for some reason we failed, then reset the collator to use the old locale */
+ if (!success)
+ book_backend_sqlite_set_locale_internal (ebsql, stored_lc_collate, NULL);
+
+ g_free (stored_lc_collate);
+ g_free (current_region);
+
+ if (!success)
+ goto rollback;
+
+ success = book_backend_sqlite_commit_transaction (ebsql, error);
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ return success;
+
+ rollback:
+ /* The GError is already set. */
+ book_backend_sqlite_rollback_transaction (ebsql, NULL);
+
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ return FALSE;
+}
+
+/**
+ * e_book_backend_sqlite_get_locale:
+ * @ebsql: An #EBookBackendSqlite
+ * @locale_out: (out) (transfer full): The location to return the current locale
+ * @error: A location to store any error that may have occurred
+ *
+ * Fetches the current locale setting for the address-book.
+ *
+ * Upon success, @lc_collate_out will hold the returned locale setting,
+ * otherwise %FALSE will be returned and @error will be updated accordingly.
+ *
+ * Returns: Whether the locale was successfully fetched.
+ *
+ * Since: 3.12
+ */
+gboolean
+e_book_backend_sqlite_get_locale (EBookBackendSqlite *ebsql,
+ gchar **locale_out,
+ GError **error)
+{
+ gboolean success;
+ GError *local_error = NULL;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+ g_return_val_if_fail (locale_out != NULL && *locale_out == NULL, FALSE);
+
+ LOCK_MUTEX (&ebsql->priv->lock);
+
+ success = book_backend_sqlite_exec_printf (
+ ebsql, "SELECT lc_collate FROM folders WHERE folder_id = %Q",
+ get_string_cb, locale_out, error, ebsql->priv->folderid);
+
+ if (!book_backend_sqlite_set_locale_internal (ebsql, *locale_out, &local_error)) {
+ g_warning ("Error loading new locale: %s", local_error->message);
+ g_clear_error (&local_error);
+ }
+
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ return success;
+}
+
+/******************************************************************
+ * EbSqlCursor apis *
+ ******************************************************************/
+typedef struct _CursorState CursorState;
+
+struct _CursorState {
+ gchar **values; /* The current cursor position, results will be returned after this
position */
+ gchar *last_uid; /* The current cursor contact UID position, used as a tie breaker */
+ EbSqlCursorOrigin position; /* The position is updated with the cursor state and is used to
distinguish
+ * between the beginning and the ending of the cursor's contact list.
+ * While the cursor is in a non-null state, the position will be
+ * EBSQL_CURSOR_ORIGIN_CURRENT.
+ */
+};
+
+struct _EbSqlCursor {
+ EBookBackendSExp *sexp; /* An EBookBackendSExp based on the query, used by
e_book_backend_sqlite_cursor_compare() */
+ gchar *select_vcards; /* The first fragment when querying results */
+ gchar *select_count; /* The first fragment when querying contact counts */
+ gchar *query; /* The SQL query expression derived from the passed search expression */
+ gchar *order; /* The normal order SQL query fragment to append at the end, containing
ORDER BY etc */
+ gchar *reverse_order; /* The reverse order SQL query fragment to append at the end,
containing ORDER BY etc */
+
+ EContactField *sort_fields; /* The fields to sort in a query in the order or sort priority */
+ EBookCursorSortType *sort_types; /* The sort method to use for each field */
+ gint n_sort_fields; /* The amound of sort fields */
+
+ CursorState state;
+};
+
+static CursorState *cursor_state_copy (EbSqlCursor *cursor,
+ CursorState *state);
+static void cursor_state_free (EbSqlCursor *cursor,
+ CursorState *state);
+static void cursor_state_clear (EbSqlCursor *cursor,
+ CursorState *state,
+ EbSqlCursorOrigin position);
+static void cursor_state_set_from_contact (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ CursorState *state,
+ EContact *contact);
+static void cursor_state_set_from_vcard (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ CursorState *state,
+ const gchar *vcard);
+
+static CursorState *
+cursor_state_copy (EbSqlCursor *cursor,
+ CursorState *state)
+{
+ CursorState *copy;
+ gint i;
+
+ copy = g_slice_new0 (CursorState);
+ copy->values = g_new0 (gchar *, cursor->n_sort_fields);
+
+ for (i = 0; i < cursor->n_sort_fields; i++)
+ copy->values[i] = g_strdup (state->values[i]);
+
+ copy->last_uid = g_strdup (state->last_uid);
+ copy->position = state->position;
+
+ return copy;
+}
+
+static void
+cursor_state_free (EbSqlCursor *cursor,
+ CursorState *state)
+{
+ if (state) {
+ cursor_state_clear (cursor, state, EBSQL_CURSOR_ORIGIN_BEGIN);
+ g_free (state->values);
+ g_slice_free (CursorState, state);
+ }
+}
+
+static void
+cursor_state_clear (EbSqlCursor *cursor,
+ CursorState *state,
+ EbSqlCursorOrigin position)
+{
+ gint i;
+
+ for (i = 0; i < cursor->n_sort_fields; i++) {
+ g_free (state->values[i]);
+ state->values[i] = NULL;
+ }
+
+ g_free (state->last_uid);
+ state->last_uid = NULL;
+ state->position = position;
+}
+
+static void
+cursor_state_set_from_contact (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ CursorState *state,
+ EContact *contact)
+{
+ gint i;
+
+ cursor_state_clear (cursor, state, EBSQL_CURSOR_ORIGIN_BEGIN);
+
+ for (i = 0; i < cursor->n_sort_fields; i++) {
+ const gchar *string = e_contact_get_const (contact, cursor->sort_fields[i]);
+
+ if (string)
+ state->values[i] =
+ e_collator_generate_key (ebsql->priv->collator,
+ string, NULL);
+ else
+ state->values[i] = g_strdup ("");
+ }
+
+ state->last_uid = e_contact_get (contact, E_CONTACT_UID);
+ state->position = EBSQL_CURSOR_ORIGIN_CURRENT;
+}
+
+static void
+cursor_state_set_from_vcard (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ CursorState *state,
+ const gchar *vcard)
+{
+ EContact *contact;
+
+ contact = e_contact_new_from_vcard (vcard);
+ cursor_state_set_from_contact (ebsql, cursor, state, contact);
+ g_object_unref (contact);
+}
+
+static gboolean
+ebsql_cursor_setup_query (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ const gchar *sexp,
+ GError **error)
+{
+ PreflightContext context = PREFLIGHT_CONTEXT_INIT;
+ GString *string;
+
+ /* Preflighting and error checking */
+ if (sexp) {
+
+ query_preflight_for_sql_query (&context, ebsql, sexp);
+
+ if (context.status == PREFLIGHT_INVALID) {
+
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_INVALID_QUERY,
+ _("Invalid query for EbSqlCursor"));
+
+ preflight_context_clear (&context);
+ return FALSE;
+
+ } else if (context.status > PREFLIGHT_OK) {
+
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_INVALID_QUERY,
+ _("Only summary queries are supported by EbSqlCursor"));
+
+ preflight_context_clear (&context);
+ return FALSE;
+ }
+ }
+
+ /* Now we caught the errors, let's generate our queries and get out of here ... */
+ g_free (cursor->select_vcards);
+ g_free (cursor->select_count);
+ g_free (cursor->query);
+ g_clear_object (&(cursor->sexp));
+
+ /* Generate the leading SELECT portions that we need */
+ string = g_string_new ("");
+ book_backend_sqlite_generate_select (ebsql, string, SEARCH_UID_AND_VCARD, &context, NULL);
+ cursor->select_vcards = g_string_free (string, FALSE);
+
+ string = g_string_new ("");
+ book_backend_sqlite_generate_select (ebsql, string, SEARCH_COUNT, &context, NULL);
+ cursor->select_count = g_string_free (string, FALSE);
+
+ if (sexp == NULL || context.list_all) {
+ cursor->query = NULL;
+ cursor->sexp = NULL;
+ } else {
+ /* Generate the constraints for our queries
+ *
+ * It can be that they are optimized into the select segment
+ */
+ if (context.constraints) {
+ string = g_string_new (NULL);
+ book_backend_sqlite_generate_constraints (ebsql,
+ string,
+ context.constraints);
+ cursor->query = g_string_free (string, FALSE);
+ } else {
+ cursor->query = NULL;
+ }
+
+ cursor->sexp = e_book_backend_sexp_new (sexp);
+ }
+
+ preflight_context_clear (&context);
+
+ return TRUE;
+}
+
+static gchar *
+ebsql_cursor_order_by_fragment (EBookBackendSqlite *ebsql,
+ const EContactField *sort_fields,
+ const EBookCursorSortType *sort_types,
+ guint n_sort_fields,
+ gboolean reverse)
+{
+ GString *string;
+ gint i;
+
+ string = g_string_new ("ORDER BY ");
+
+ for (i = 0; i < n_sort_fields; i++) {
+ SummaryField *field = summary_field_get (ebsql, sort_fields[i]);
+
+ if (i > 0)
+ g_string_append (string, ", ");
+
+ g_string_append (string, "summary.");
+ g_string_append (string, field->dbname);
+ g_string_append (string, "_" EBSQL_SUFFIX_SORT_KEY " ");
+
+ if (reverse)
+ g_string_append (string, (sort_types[i] == E_BOOK_CURSOR_SORT_ASCENDING ? "DESC" :
"ASC"));
+ else
+ g_string_append (string, (sort_types[i] == E_BOOK_CURSOR_SORT_ASCENDING ? "ASC" :
"DESC"));
+ }
+
+ /* Also order the UID, since it's our tie breaker */
+ if (n_sort_fields > 0)
+ g_string_append (string, ", ");
+
+ g_string_append (string, "summary.uid ");
+ g_string_append (string, reverse ? "DESC" : "ASC");
+
+ return g_string_free (string, FALSE);
+}
+
+static EbSqlCursor *
+ebsql_cursor_new (EBookBackendSqlite *ebsql,
+ const gchar *sexp,
+ const EContactField *sort_fields,
+ const EBookCursorSortType *sort_types,
+ guint n_sort_fields)
+{
+ EbSqlCursor *cursor = g_slice_new0 (EbSqlCursor);
+
+ cursor->order = ebsql_cursor_order_by_fragment (ebsql,
+ sort_fields,
+ sort_types,
+ n_sort_fields,
+ FALSE);
+ cursor->reverse_order = ebsql_cursor_order_by_fragment (ebsql,
+ sort_fields,
+ sort_types,
+ n_sort_fields,
+ TRUE);
+
+ /* Sort parameters */
+ cursor->n_sort_fields = n_sort_fields;
+ cursor->sort_fields = g_memdup (sort_fields, sizeof (EContactField) * n_sort_fields);
+ cursor->sort_types = g_memdup (sort_types, sizeof (EBookCursorSortType) * n_sort_fields);
+
+ /* Cursor state */
+ cursor->state.values = g_new0 (gchar *, n_sort_fields);
+ cursor->state.last_uid = NULL;
+ cursor->state.position = EBSQL_CURSOR_ORIGIN_BEGIN;
+
+ return cursor;
+}
+
+static void
+ebsql_cursor_free (EbSqlCursor *cursor)
+{
+ if (cursor) {
+ cursor_state_clear (cursor, &(cursor->state), EBSQL_CURSOR_ORIGIN_BEGIN);
+ g_free (cursor->state.values);
+
+ g_clear_object (&(cursor->sexp));
+ g_free (cursor->select_vcards);
+ g_free (cursor->select_count);
+ g_free (cursor->query);
+ g_free (cursor->order);
+ g_free (cursor->reverse_order);
+ g_free (cursor->sort_fields);
+ g_free (cursor->sort_types);
+
+ g_slice_free (EbSqlCursor, cursor);
+ }
+}
+
+#define GREATER_OR_LESS(cursor, idx, reverse) \
+ (reverse ? \
+ (((EbSqlCursor *)cursor)->sort_types[idx] == E_BOOK_CURSOR_SORT_ASCENDING ? '<' : '>') : \
+ (((EbSqlCursor *)cursor)->sort_types[idx] == E_BOOK_CURSOR_SORT_ASCENDING ? '>' : '<'))
+
+static inline void
+ebsql_cursor_format_equality (GString *string,
+ SummaryField *field,
+ const gchar *value,
+ gchar equality)
+{
+ g_string_append (string, "summary.");
+ g_string_append (string, field->dbname);
+ g_string_append (string, "_" EBSQL_SUFFIX_SORT_KEY " ");
+
+ g_string_append_c (string, equality);
+ ebsql_string_append_printf (string, " %Q", value);
+}
+
+static gchar *
+ebsql_cursor_constraints (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ CursorState *state,
+ gboolean reverse,
+ gboolean include_current_uid)
+{
+ GString *string;
+ SummaryField *field;
+ gint i, j;
+
+ /* Example for:
+ * ORDER BY family_name ASC, given_name DESC
+ *
+ * Where current cursor values are:
+ * family_name = Jackson
+ * given_name = Micheal
+ *
+ * With reverse = FALSE
+ *
+ * (summary.family_name > 'Jackson') OR
+ * (summary.family_name = 'Jackson' AND summary.given_name < 'Micheal') OR
+ * (summary.family_name = 'Jackson' AND summary.given_name = 'Micheal' AND summary.uid >
'last-uid')
+ *
+ * With reverse = TRUE (needed for moving the cursor backwards through results)
+ *
+ * (summary.family_name < 'Jackson') OR
+ * (summary.family_name = 'Jackson' AND summary.given_name > 'Micheal') OR
+ * (summary.family_name = 'Jackson' AND summary.given_name = 'Micheal' AND summary.uid <
'last-uid')
+ *
+ */
+ string = g_string_new (NULL);
+
+ for (i = 0; i <= cursor->n_sort_fields; i++) {
+
+ /* Break once we hit a NULL value */
+ if ((i < cursor->n_sort_fields && state->values[i] == NULL) ||
+ (i == cursor->n_sort_fields && state->last_uid == NULL))
+ break;
+
+ /* Between each qualifier, add an 'OR' */
+ if (i > 0)
+ g_string_append (string, " OR ");
+
+ /* Begin qualifier */
+ g_string_append_c (string, '(');
+
+ /* Create the '=' statements leading up to the current tie breaker */
+ for (j = 0; j < i; j++) {
+ field = summary_field_get (ebsql, cursor->sort_fields[j]);
+
+ ebsql_cursor_format_equality (string, field, state->values[j], '=');
+ g_string_append (string, " AND ");
+ }
+
+ if (i == cursor->n_sort_fields) {
+
+ /* The 'include_current_uid' clause is used for calculating
+ * the current position of the cursor, inclusive of the
+ * current position.
+ */
+ if (include_current_uid)
+ g_string_append_c (string, '(');
+
+ /* Append the UID tie breaker */
+ ebsql_string_append_printf (string,
+ "summary.uid %c %Q",
+ reverse ? '<' : '>',
+ state->last_uid);
+
+ if (include_current_uid)
+ ebsql_string_append_printf (string,
+ " OR summary.uid = %Q)",
+ state->last_uid);
+
+ } else {
+
+ /* SPECIAL CASE: If we have a parially set cursor state, then we must
+ * report next results that are inclusive of the final qualifier.
+ *
+ * This allows one to set the cursor with the family name set to 'J'
+ * and include the results for contact's Mr & Miss 'J'.
+ */
+ gboolean include_exact_match =
+ (reverse == FALSE &&
+ ((i + 1 < cursor->n_sort_fields && state->values[i + 1] == NULL) ||
+ (i + 1 == cursor->n_sort_fields && state->last_uid == NULL)));
+
+ if (include_exact_match)
+ g_string_append_c (string, '(');
+
+ /* Append the final qualifier for this field */
+ field = summary_field_get (ebsql, cursor->sort_fields[i]);
+ ebsql_cursor_format_equality (string, field, state->values[i],
+ GREATER_OR_LESS (cursor, i, reverse));
+
+ if (include_exact_match) {
+ g_string_append (string, " OR ");
+ ebsql_cursor_format_equality (string, field, state->values[i], '=');
+ g_string_append_c (string, ')');
+ }
+ }
+
+ /* End qualifier */
+ g_string_append_c (string, ')');
+ }
+
+ return g_string_free (string, FALSE);
+}
+
+static gboolean
+cursor_count_total_locked (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ gint *total,
+ GError **error)
+{
+ GString *query;
+ gboolean success;
+
+ query = g_string_new (cursor->select_count);
+
+ /* Add the filter constraints (if any) */
+ if (cursor->query) {
+ g_string_append (query, " WHERE ");
+
+ g_string_append_c (query, '(');
+ g_string_append (query, cursor->query);
+ g_string_append_c (query, ')');
+ }
+
+ /* Execute the query */
+ success = book_backend_sqlite_exec (ebsql, query->str,
+ get_count_cb, total, error);
+
+ g_string_free (query, TRUE);
+
+ return success;
+}
+
+static gboolean
+cursor_count_position_locked (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ gint *position,
+ GError **error)
+{
+ GString *query;
+ gboolean success;
+
+ query = g_string_new (cursor->select_count);
+
+ /* Add the filter constraints (if any) */
+ if (cursor->query) {
+ g_string_append (query, " WHERE ");
+
+ g_string_append_c (query, '(');
+ g_string_append (query, cursor->query);
+ g_string_append_c (query, ')');
+ }
+
+ /* Add the cursor constraints (if any) */
+ if (cursor->state.values[0] != NULL) {
+ gchar *constraints = NULL;
+
+ if (!cursor->query)
+ g_string_append (query, " WHERE ");
+ else
+ g_string_append (query, " AND ");
+
+ /* Here we do a reverse query, we're looking for all the
+ * results leading up to the current cursor value, including
+ * the cursor value
+ */
+ constraints = ebsql_cursor_constraints (ebsql, cursor,
+ &(cursor->state),
+ TRUE, TRUE);
+
+ g_string_append_c (query, '(');
+ g_string_append (query, constraints);
+ g_string_append_c (query, ')');
+
+ g_free (constraints);
+ }
+
+ /* Execute the query */
+ success = book_backend_sqlite_exec (ebsql, query->str,
+ get_count_cb, position, error);
+
+ g_string_free (query, TRUE);
+
+ return success;
+}
+
+/**
+ * e_book_backend_sqlite_cursor_new:
+ * @ebsql: An #EBookBackendSqlite
+ * @folderid: folder id of the address-book
+ * @sexp: search expression; use NULL or an empty string to get all stored contacts.
+ * @sort_fields: (array length=n_sort_fields): An array of #EContactFields as sort keys in order of priority
+ * @sort_types: (array length=n_sort_fields): An array of #EBookCursorSortTypes, one for each field in
@sort_fields
+ * @n_sort_fields: The number of fields to sort results by.
+ * @error: A return location to store any error that might be reported.
+ *
+ * Creates a new #EbSqlCursor.
+ *
+ * The cursor should be freed with e_book_backend_sqlite_cursor_free().
+ *
+ * Returns: (transfer full): A newly created #EbSqlCursor
+ *
+ * Since: 3.12
+ */
+EbSqlCursor *
+e_book_backend_sqlite_cursor_new (EBookBackendSqlite *ebsql,
+ const gchar *sexp,
+ const EContactField *sort_fields,
+ const EBookCursorSortType *sort_types,
+ guint n_sort_fields,
+ GError **error)
+{
+ EbSqlCursor *cursor;
+ gint i;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), NULL);
+
+ /* We don't like '\0' sexps, prefer NULL */
+ if (sexp && !sexp[0])
+ sexp = NULL;
+
+ LOCK_MUTEX (&ebsql->priv->lock);
+
+ /* Need one sort key ... */
+ if (n_sort_fields == 0) {
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_INVALID_QUERY,
+ _("At least one sort field must be specified to use an EbSqlCursor"));
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+ return NULL;
+ }
+
+ /* We only support summarized sort keys which are not multi value fields */
+ for (i = 0; i < n_sort_fields; i++) {
+ SummaryField *field;
+
+ field = summary_field_get (ebsql, sort_fields[i]);
+
+ if (field == NULL) {
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_INVALID_QUERY,
+ _("Cannot sort by a field that is not in the summary"));
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+ return NULL;
+ }
+
+ if ((field->index & INDEX_FLAG (SORT_KEY)) == 0) {
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_INVALID_QUERY,
+ _("Cannot sort by a field which is not configured with
E_BOOK_INDEX_SORT_KEY"));
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+ return NULL;
+ }
+
+ if (field->type == E_TYPE_CONTACT_ATTR_LIST) {
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_INVALID_QUERY,
+ _("Cannot sort by a field which may have multiple values"));
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+ return NULL;
+ }
+ }
+
+ /* Now we need to create the cursor instance before setting up the query
+ * (not really true, but more convenient that way).
+ */
+ cursor = ebsql_cursor_new (ebsql, sexp, sort_fields, sort_types, n_sort_fields);
+
+ /* Setup the cursor's query expression which might fail */
+ if (!ebsql_cursor_setup_query (ebsql, cursor, sexp, error)) {
+ ebsql_cursor_free (cursor);
+ cursor = NULL;
+ }
+
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ return cursor;
+}
+
+/**
+ * e_book_backend_sqlite_cursor_free:
+ * @ebsql: An #EBookBackendSqlite
+ * @cursor: The #EbSqlCursor to free
+ *
+ * Frees @cursor.
+ *
+ * Since: 3.12
+ */
+void
+e_book_backend_sqlite_cursor_free (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor)
+{
+ g_return_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql));
+
+ ebsql_cursor_free (cursor);
+}
+
+typedef struct {
+ GSList *results;
+ gchar *alloc_vcard;
+ const gchar *last_vcard;
+
+ gboolean collect_results;
+ gint n_results;
+} CursorCollectData;
+
+static gint
+collect_results_for_cursor_cb (gpointer ref,
+ gint col,
+ gchar **cols,
+ gchar **name)
+{
+ CursorCollectData *data = ref;
+
+ if (data->collect_results) {
+ EbSqlSearchData *search_data;
+
+ search_data = search_data_from_results (cols);
+
+ data->results = g_slist_prepend (data->results, search_data);
+
+ data->last_vcard = search_data->vcard;
+ } else {
+ g_free (data->alloc_vcard);
+ data->alloc_vcard = g_strdup (cols[1]);
+
+ data->last_vcard = data->alloc_vcard;
+ }
+
+ data->n_results++;
+
+ return 0;
+}
+
+/**
+ * e_book_backend_sqlite_cursor_step:
+ * @ebsql: An #EBookBackendSqlite
+ * @cursor: The #EbSqlCursor to use
+ * @flags: The #EbSqlCursorStepFlags for this step
+ * @origin: The #EbSqlCursorOrigin from whence to step
+ * @count: A positive or negative amount of contacts to try and fetch
+ * @results: (out) (allow-none) (element-type EbSqlSearchData) (transfer full):
+ * A return location to store the results, or %NULL if %EBSQL_CURSOR_STEP_FETCH is not specified in %flags.
+ * @error: A return location to store any error that might be reported.
+ *
+ * Steps @cursor through it's sorted query by a maximum of @count contacts
+ * starting from @origin.
+ *
+ * If @count is negative, then the cursor will move through the list in reverse.
+ *
+ * If @cursor reaches the beginning or end of the query results, then the
+ * returned list might not contain the amount of desired contacts, or might
+ * return no results if the cursor currently points to the last contact.
+ * Reaching the end of the list is not considered an error condition. Attempts
+ * to step beyond the end of the list after having reached the end of the list
+ * will however trigger an %E_BOOK_SQL_ERROR_END_OF_LIST error.
+ *
+ * If %EBSQL_CURSOR_STEP_FETCH is specified in %flags, a pointer to
+ * a %NULL #GSList pointer should be provided for the @results parameter.
+ *
+ * The result list will be stored to @results and should be freed with g_slist_free()
+ * and all elements freed with e_book_backend_sqlite_search_data_free().
+ *
+ * Returns: The number of contacts traversed if successful, otherwise -1 is
+ * returned and @error is set.
+ *
+ * Since: 3.12
+ */
+gint
+e_book_backend_sqlite_cursor_step (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ EbSqlCursorStepFlags flags,
+ EbSqlCursorOrigin origin,
+ gint count,
+ GSList **results,
+ GError **error)
+{
+ CursorCollectData data = { NULL, NULL, NULL, FALSE, 0 };
+ CursorState *state;
+ GString *query;
+ gboolean success;
+ EbSqlCursorOrigin try_position;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), -1);
+ g_return_val_if_fail (cursor != NULL, -1);
+ g_return_val_if_fail ((flags & EBSQL_CURSOR_STEP_FETCH) == 0 ||
+ (results != NULL && *results == NULL), -1);
+
+
+ /* Check if this step should result in an end of list error first */
+ try_position = cursor->state.position;
+ if (origin != EBSQL_CURSOR_ORIGIN_CURRENT)
+ try_position = origin;
+
+ /* Report errors for requests to run off the end of the list */
+ if (try_position == EBSQL_CURSOR_ORIGIN_BEGIN && count < 0) {
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_END_OF_LIST,
+ _("Tried to step a cursor in reverse, "
+ "but cursor is already at the beginning of the contact list"));
+
+ return -1;
+ } else if (try_position == EBSQL_CURSOR_ORIGIN_END && count > 0) {
+ g_set_error (error,
+ E_BOOK_SQL_ERROR,
+ E_BOOK_SQL_ERROR_END_OF_LIST,
+ _("Tried to step a cursor forwards, "
+ "but cursor is already at the end of the contact list"));
+
+ return -1;
+ }
+
+ /* Nothing to do, silently return */
+ if (count == 0 && try_position == EBSQL_CURSOR_ORIGIN_CURRENT)
+ return 0;
+
+ /* If we're not going to modify the position, just use
+ * a copy of the current cursor state.
+ */
+ if ((flags & EBSQL_CURSOR_STEP_MOVE) != 0)
+ state = &(cursor->state);
+ else
+ state = cursor_state_copy (cursor, &(cursor->state));
+
+ /* Every query starts with the STATE_CURRENT position, first
+ * fix up the cursor state according to 'origin'
+ */
+ switch (origin) {
+ case EBSQL_CURSOR_ORIGIN_CURRENT:
+ /* Do nothing, normal operation */
+ break;
+
+ case EBSQL_CURSOR_ORIGIN_BEGIN:
+ case EBSQL_CURSOR_ORIGIN_END:
+
+ /* Prepare the state before executing the query */
+ cursor_state_clear (cursor, state, origin);
+ break;
+ }
+
+ /* If count is 0 then there is no need to run any
+ * query, however it can be useful if you just want
+ * to move the cursor to the beginning or ending of
+ * the list.
+ */
+ if (count == 0) {
+
+ /* Free the state copy if need be */
+ if ((flags & EBSQL_CURSOR_STEP_MOVE) == 0)
+ cursor_state_free (cursor, state);
+
+ return 0;
+ }
+
+ query = g_string_new (cursor->select_vcards);
+
+ /* Add the filter constraints (if any) */
+ if (cursor->query) {
+ g_string_append (query, " WHERE ");
+
+ g_string_append_c (query, '(');
+ g_string_append (query, cursor->query);
+ g_string_append_c (query, ')');
+ }
+
+ /* Add the cursor constraints (if any) */
+ if (state->values[0] != NULL) {
+ gchar *constraints = NULL;
+
+ if (!cursor->query)
+ g_string_append (query, " WHERE ");
+ else
+ g_string_append (query, " AND ");
+
+ constraints = ebsql_cursor_constraints (ebsql,
+ cursor,
+ state,
+ count < 0,
+ FALSE);
+
+ g_string_append_c (query, '(');
+ g_string_append (query, constraints);
+ g_string_append_c (query, ')');
+
+ g_free (constraints);
+ }
+
+ /* Add the sort order */
+ g_string_append_c (query, ' ');
+ if (count > 0)
+ g_string_append (query, cursor->order);
+ else
+ g_string_append (query, cursor->reverse_order);
+
+ /* Add the limit */
+ g_string_append_printf (query, " LIMIT %d", ABS (count));
+
+ /* Specify whether we really want results or not */
+ data.collect_results = (flags & EBSQL_CURSOR_STEP_FETCH) != 0;
+
+ /* Execute the query */
+ LOCK_MUTEX (&ebsql->priv->lock);
+ success = book_backend_sqlite_exec (ebsql, query->str,
+ collect_results_for_cursor_cb, &data,
+ error);
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ g_string_free (query, TRUE);
+
+ /* If there was no error, update the internal cursor state */
+ if (success) {
+
+ if (data.n_results < ABS (count)) {
+
+ /* We've reached the end, clear the current state */
+ if (count < 0)
+ cursor_state_clear (cursor, state, EBSQL_CURSOR_ORIGIN_BEGIN);
+ else
+ cursor_state_clear (cursor, state, EBSQL_CURSOR_ORIGIN_END);
+
+ } else if (data.last_vcard) {
+
+ /* Set the cursor state to the last result */
+ cursor_state_set_from_vcard (ebsql, cursor, state, data.last_vcard);
+ } else
+ /* Should never get here */
+ g_warn_if_reached ();
+
+ /* Assign the results to return (if any) */
+ if (results) {
+ /* Correct the order of results at the last minute */
+ *results = g_slist_reverse (data.results);
+ data.results = NULL;
+ }
+ }
+
+ /* Cleanup what was allocated by collect_results_for_cursor_cb() */
+ if (data.results)
+ g_slist_free_full (data.results,
+ (GDestroyNotify)e_book_backend_sqlite_search_data_free);
+ g_free (data.alloc_vcard);
+
+ /* Free the copy state if we were working with a copy */
+ if ((flags & EBSQL_CURSOR_STEP_MOVE) == 0)
+ cursor_state_free (cursor, state);
+
+ if (success)
+ return data.n_results;
+
+ return -1;
+}
+
+/**
+ * e_book_backend_sqlite_cursor_set_target_alphabetic_index:
+ * @ebsql: An #EBookBackendSqlite
+ * @cursor: The #EbSqlCursor to modify
+ * @idx: The alphabetic index
+ *
+ * Sets the @cursor position to an
+ * <link linkend="cursor-alphabet">Alphabetic Index</link>
+ * into the alphabet active in @ebsql's locale.
+ *
+ * After setting the target to an alphabetic index, for example the
+ * index for letter 'E', then further calls to e_book_backend_sqlite_cursor_step()
+ * will return results starting with the letter 'E' (or results starting
+ * with the last result in 'D', if moving in a negative direction).
+ *
+ * The passed index must be a valid index in the active locale, knowledge
+ * on the currently active alphabet index must be obtained using #ECollator
+ * APIs.
+ *
+ * Use e_book_backend_sqlite_ref_collator() to obtain the active collator for @ebsql.
+ *
+ * Since: 3.12
+ */
+void
+e_book_backend_sqlite_cursor_set_target_alphabetic_index (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ gint idx)
+{
+ gint n_labels = 0;
+
+ g_return_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql));
+ g_return_if_fail (cursor != NULL);
+ g_return_if_fail (idx >= 0);
+
+ e_collator_get_index_labels (ebsql->priv->collator, &n_labels,
+ NULL, NULL, NULL);
+ g_return_if_fail (idx < n_labels);
+
+ cursor_state_clear (cursor, &(cursor->state), EBSQL_CURSOR_ORIGIN_CURRENT);
+ if (cursor->n_sort_fields > 0) {
+ cursor->state.values[0] =
+ e_collator_generate_key_for_index (ebsql->priv->collator, idx);
+ }
+}
+
+/**
+ * e_book_backend_sqlite_cursor_set_sexp:
+ * @ebsql: An #EBookBackendSqlite
+ * @cursor: The #EbSqlCursor
+ * @sexp: The new query expression for @cursor
+ * @error: A return location to store any error that might be reported.
+ *
+ * Modifies the current query expression for @cursor. This will not
+ * modify @cursor's state, but will change the outcome of any further
+ * calls to e_book_backend_sqlite_cursor_calculate() or
+ * e_book_backend_sqlite_cursor_step().
+ *
+ * Returns: %TRUE if the expression was valid and accepted by @ebsql
+ *
+ * Since: 3.12
+ */
+gboolean
+e_book_backend_sqlite_cursor_set_sexp (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ const gchar *sexp,
+ GError **error)
+{
+ gboolean success;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+ g_return_val_if_fail (cursor != NULL, FALSE);
+
+ /* We don't like '\0' sexps, prefer NULL */
+ if (sexp && !sexp[0])
+ sexp = NULL;
+
+ LOCK_MUTEX (&ebsql->priv->lock);
+ success = ebsql_cursor_setup_query (ebsql, cursor, sexp, error);
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ return success;
+}
+
+/**
+ * e_book_backend_sqlite_cursor_calculate:
+ * @ebsql: An #EBookBackendSqlite
+ * @cursor: The #EbSqlCursor
+ * @total: (out) (allow-none): A return location to store the total result set for this cursor
+ * @position: (out) (allow-none): A return location to store the total results before the cursor value
+ * @error: (allow-none): A return location to store any error that might be reported.
+ *
+ * Calculates the @total amount of results for the @cursor's query expression,
+ * as well as the current @position of @cursor in the results. @position is
+ * represented as the amount of results which lead up to the current value
+ * of @cursor, if @cursor currently points to an exact contact, the position
+ * also includes the cursor contact.
+ *
+ * Returns: Whether @total and @position were successfully calculated.
+ *
+ * Since: 3.12
+ */
+gboolean
+e_book_backend_sqlite_cursor_calculate (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ gint *total,
+ gint *position,
+ GError **error)
+{
+ gboolean success = TRUE;
+ gint local_total = 0;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), FALSE);
+ g_return_val_if_fail (cursor != NULL, FALSE);
+
+ /* If we're in a clear cursor state, then the position is 0 */
+ if (position && cursor->state.values[0] == NULL) {
+
+ if (cursor->state.position == EBSQL_CURSOR_ORIGIN_BEGIN) {
+ /* Mark the local pointer NULL, no need to calculate this anymore */
+ *position = 0;
+ position = NULL;
+ } else if (cursor->state.position == EBSQL_CURSOR_ORIGIN_END) {
+
+ /* Make sure that we look up the total so we can
+ * set the position to 'total + 1'
+ */
+ if (!total)
+ total = &local_total;
+ }
+ }
+
+ /* Early return if there is nothing to do */
+ if (!total && !position)
+ return TRUE;
+
+ LOCK_MUTEX (&ebsql->priv->lock);
+
+ /* Start a read transaction, it's important our two queries are atomic */
+ if (!book_backend_sqlite_start_transaction (ebsql, FALSE, error)) {
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+ return FALSE;
+ }
+
+ if (total)
+ success = cursor_count_total_locked (ebsql, cursor, total, error);
+
+ if (success && position)
+ success = cursor_count_position_locked (ebsql, cursor, position, error);
+
+ if (success)
+ success = book_backend_sqlite_commit_transaction (ebsql, error);
+ else
+ /* The GError is already set. */
+ book_backend_sqlite_rollback_transaction (ebsql, NULL);
+
+
+ UNLOCK_MUTEX (&ebsql->priv->lock);
+
+ /* In the case we're at the end, we just set the position
+ * to be the total + 1
+ */
+ if (success && position && total &&
+ cursor->state.position == EBSQL_CURSOR_ORIGIN_END)
+ *position = *total + 1;
+
+ return success;
+}
+
+/**
+ * e_book_backend_sqlite_cursor_compare_contact:
+ * @ebsql: An #EBookBackendSqlite
+ * @cursor: The #EbSqlCursor
+ * @contact: The #EContact to compare
+ * @matches_sexp: (out) (allow-none): Whether the contact matches the cursor's search expression
+ *
+ * Compares @contact with @cursor and returns whether @contact is less than, equal to, or greater
+ * than @cursor.
+ *
+ * Returns: A value that is less than, equal to, or greater than zero if @contact is found,
+ * respectively, to be less than, to match, or be greater than the current value of @cursor.
+ *
+ * Since: 3.12
+ */
+gint
+e_book_backend_sqlite_cursor_compare_contact (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ EContact *contact,
+ gboolean *matches_sexp)
+{
+ EBookBackendSqlitePrivate *priv;
+ gint i;
+ gint comparison = 0;
+
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_SQLITE (ebsql), -1);
+ g_return_val_if_fail (E_IS_CONTACT (contact), -1);
+ g_return_val_if_fail (cursor != NULL, -1);
+
+ priv = ebsql->priv;
+
+ if (matches_sexp) {
+ if (cursor->sexp == NULL)
+ *matches_sexp = TRUE;
+ else
+ *matches_sexp =
+ e_book_backend_sexp_match_contact (cursor->sexp, contact);
+ }
+
+ for (i = 0; i < cursor->n_sort_fields && comparison == 0; i++) {
+
+ /* Empty state sorts below any contact value, which means the contact sorts above cursor */
+ if (cursor->state.values[i] == NULL) {
+ comparison = 1;
+ } else {
+ const gchar *field_value;
+
+ field_value = (const gchar *)
+ e_contact_get_const (contact, cursor->sort_fields[i]);
+
+ /* Empty contact state sorts below any cursor value */
+ if (field_value == NULL)
+ comparison = -1;
+ else {
+ gchar *collation_key;
+
+ /* Check if contact sorts below, equal to, or above the cursor */
+ collation_key = e_collator_generate_key (priv->collator, field_value, NULL);
+ comparison = strcmp (collation_key, cursor->state.values[i]);
+ g_free (collation_key);
+ }
+ }
+ }
+
+ /* UID tie-breaker */
+ if (comparison == 0) {
+ const gchar *uid;
+
+ uid = (const gchar *)e_contact_get_const (contact, E_CONTACT_UID);
+
+ if (cursor->state.last_uid == NULL)
+ comparison = 1;
+ else if (uid == NULL)
+ comparison = -1;
+ else
+ comparison = strcmp (uid, cursor->state.last_uid);
+ }
+
+ return comparison;
+}
diff --git a/addressbook/libedata-book/e-book-backend-sqlite.h
b/addressbook/libedata-book/e-book-backend-sqlite.h
new file mode 100644
index 0000000..74897b5
--- /dev/null
+++ b/addressbook/libedata-book/e-book-backend-sqlite.h
@@ -0,0 +1,311 @@
+/*-*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/* e-book-backend-sqlitedb.h
+ *
+ * Copyright (C) 2013 Intel Corporation
+ *
+ * Authors:
+ * Tristan Van Berkom <tristanvb openismus com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser 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.
+ */
+
+#if !defined (__LIBEDATA_BOOK_H_INSIDE__) && !defined (LIBEDATA_BOOK_COMPILATION)
+#error "Only <libedata-book/libedata-book.h> should be included directly."
+#endif
+
+#ifndef E_BOOK_BACKEND_SQLITE_H
+#define E_BOOK_BACKEND_SQLITE_H
+
+#include <libebook-contacts/libebook-contacts.h>
+
+/* Standard GObject macros */
+#define E_TYPE_BOOK_BACKEND_SQLITE \
+ (e_book_backend_sqlite_get_type ())
+#define E_BOOK_BACKEND_SQLITE(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST \
+ ((obj), E_TYPE_BOOK_BACKEND_SQLITE, EBookBackendSqlite))
+#define E_BOOK_BACKEND_SQLITE_CLASS(cls) \
+ (G_TYPE_CHECK_CLASS_CAST \
+ ((cls), E_TYPE_BOOK_BACKEND_SQLITE, EBookBackendSqliteClass))
+#define E_IS_BOOK_BACKEND_SQLITE(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE \
+ ((obj), E_TYPE_BOOK_BACKEND_SQLITE))
+#define E_IS_BOOK_BACKEND_SQLITE_CLASS(cls) \
+ (G_TYPE_CHECK_CLASS_TYPE \
+ ((cls), E_TYPE_BOOK_BACKEND_SQLITE))
+#define E_BOOK_BACKEND_SQLITE_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS \
+ ((obj), E_TYPE_BOOK_BACKEND_SQLITE, EBookBackendSqliteClass))
+
+/**
+ * E_BOOK_SQL_ERROR:
+ *
+ * Error domain for #EBookBackendSqlite operations.
+ *
+ * Since: 3.12
+ **/
+#define E_BOOK_SQL_ERROR (e_book_backend_sqlite_error_quark ())
+
+/**
+ * E_BOOK_SQL_IS_POPULATED_KEY:
+ *
+ * This key can be used with e_book_backend_sqlite_get_key_value().
+ *
+ * In the case of a migration from an older SQLite, any value which
+ * was previously stored with e_book_backend_sqlitedb_set_is_populated()
+ * can be retrieved with this key.
+ *
+ * Since: 3.12
+ **/
+#define E_BOOK_SQL_IS_POPULATED_KEY "eds-reserved-namespace-is-populated"
+
+G_BEGIN_DECLS
+
+typedef struct _EBookBackendSqlite EBookBackendSqlite;
+typedef struct _EBookBackendSqliteClass EBookBackendSqliteClass;
+typedef struct _EBookBackendSqlitePrivate EBookBackendSqlitePrivate;
+
+/**
+ * EBookSqlError:
+ * @E_BOOK_SQL_ERROR_CONSTRAINT: The error occurred due to an explicit constraint
+ * @E_BOOK_SQL_ERROR_CONTACT_NOT_FOUND: A contact was not found by UID (this is different
+ * from a query that returns no results, which is not an error).
+ * @E_BOOK_SQL_ERROR_OTHER: Another error occurred
+ * @E_BOOK_SQL_ERROR_NOT_SUPPORTED: A query was not supported
+ * @E_BOOK_SQL_ERROR_INVALID_QUERY: A query was invalid. This can happen if the sexp could not be parsed
+ * or if a phone number query contained non-phonenumber input.
+ * @E_BOOK_SQL_ERROR_END_OF_LIST: An attempt was made to fetch results past the end of a contact list
+ *
+ * Defines the types of possible errors reported by the #EBookBackendSqlite
+ */
+typedef enum {
+ E_BOOK_SQL_ERROR_CONSTRAINT,
+ E_BOOK_SQL_ERROR_CONTACT_NOT_FOUND,
+ E_BOOK_SQL_ERROR_OTHER,
+ E_BOOK_SQL_ERROR_NOT_SUPPORTED,
+ E_BOOK_SQL_ERROR_INVALID_QUERY,
+ E_BOOK_SQL_ERROR_END_OF_LIST
+} EBookSqlError;
+
+/**
+ * EBookBackendSqlite:
+ *
+ * Contains only private data that should be read and manipulated using the
+ * functions below.
+ *
+ * Since: 3.2
+ **/
+struct _EBookBackendSqlite {
+ GObject parent;
+ EBookBackendSqlitePrivate *priv;
+};
+
+struct _EBookBackendSqliteClass {
+ GObjectClass parent_class;
+};
+
+/**
+ * EbSqlSearchData:
+ *
+ * FIXME: Document me.
+ *
+ * Since: 3.2
+ **/
+typedef struct {
+ gchar *vcard;
+ gchar *uid;
+} EbSqlSearchData;
+
+/**
+ * EbSqlCuror:
+ *
+ * An opaque cursor pointer
+ *
+ * Since: 3.12
+ */
+typedef struct _EbSqlCursor EbSqlCursor;
+
+/**
+ * EbSqlCursorOrigin:
+ * @EBSQL_CURSOR_ORIGIN_CURRENT: The current cursor position
+ * @EBSQL_CURSOR_ORIGIN_BEGIN: The beginning of the cursor results.
+ * @EBSQL_CURSOR_ORIGIN_END: The ending of the cursor results.
+ *
+ * Specifies the start position to in the list of traversed contacts
+ * in calls to e_book_backend_sqlite_cursor_step().
+ *
+ * When an #EbSqlCuror is created, the current position implied by %EBSQL_CURSOR_ORIGIN_CURRENT
+ * is the same as %EBSQL_CURSOR_ORIGIN_BEGIN.
+ *
+ * Since: 3.12
+ */
+typedef enum {
+ EBSQL_CURSOR_ORIGIN_CURRENT = 0,
+ EBSQL_CURSOR_ORIGIN_BEGIN,
+ EBSQL_CURSOR_ORIGIN_END
+} EbSqlCursorOrigin;
+
+/**
+ * EbSqlCursorStepFlags:
+ * @EBSQL_CURSOR_STEP_MOVE: The cursor position should be modified while stepping
+ * @EBSQL_CURSOR_STEP_FETCH: Traversed contacts should be listed and returned while stepping.
+ *
+ * Defines the behaviour of e_book_backend_sqlite_cursor_step().
+ *
+ * Since: 3.12
+ */
+typedef enum {
+ EBSQL_CURSOR_STEP_MOVE = (1 << 0),
+ EBSQL_CURSOR_STEP_FETCH = (1 << 1)
+} EbSqlCursorStepFlags;
+
+GType e_book_backend_sqlite_get_type (void) G_GNUC_CONST;
+GQuark e_book_backend_sqlite_error_quark (void);
+void e_book_backend_sqlite_search_data_free
+ (EbSqlSearchData *s_data);
+
+EBookBackendSqlite *
+ e_book_backend_sqlite_new (const gchar *path,
+ gboolean store_vcard,
+ GError **error);
+EBookBackendSqlite *
+ e_book_backend_sqlite_new_full (const gchar *path,
+ const gchar *folderid,
+ gboolean store_vcard,
+ ESourceBackendSummarySetup *setup,
+ GError **error);
+
+gboolean e_book_backend_sqlite_lock_updates (EBookBackendSqlite *ebsql,
+ gboolean writer_lock,
+ GError **error);
+gboolean e_book_backend_sqlite_unlock_updates(EBookBackendSqlite *ebsql,
+ gboolean do_commit,
+ GError **error);
+gboolean e_book_backend_sqlite_set_locale (EBookBackendSqlite *ebsql,
+ const gchar *lc_collate,
+ GError **error);
+gboolean e_book_backend_sqlite_get_locale (EBookBackendSqlite *ebsql,
+ gchar **locale_out,
+ GError **error);
+GHashTable* e_book_backend_sqlite_get_uids_and_rev
+ (EBookBackendSqlite *ebsql,
+ GError **error);
+
+ECollator *e_book_backend_sqlite_ref_collator (EBookBackendSqlite *ebsql);
+
+gboolean e_book_backend_sqlite_check_summary_query
+ (EBookBackendSqlite *ebsql,
+ const gchar *query);
+
+/* Adding / Removing / Searching contacts */
+gboolean e_book_backend_sqlite_add_contact (EBookBackendSqlite *ebsql,
+ EContact *contact,
+ gboolean replace_existing,
+ GError **error);
+gboolean e_book_backend_sqlite_add_contacts (EBookBackendSqlite *ebsql,
+ GSList *contacts,
+ gboolean replace_existing,
+ GError **error);
+gboolean e_book_backend_sqlite_remove_contact(EBookBackendSqlite *ebsql,
+ const gchar *uid,
+ GError **error);
+gboolean e_book_backend_sqlite_remove_contacts
+ (EBookBackendSqlite *ebsql,
+ GSList *uids,
+ GError **error);
+gboolean e_book_backend_sqlite_has_contact (EBookBackendSqlite *ebsql,
+ const gchar *uid,
+ gboolean *exists,
+ GError **error);
+gboolean e_book_backend_sqlite_get_contact (EBookBackendSqlite *ebsql,
+ const gchar *uid,
+ gboolean meta_contact,
+ EContact **ret_contact,
+ GError **error);
+gboolean e_book_backend_sqlite_get_vcard_string
+ (EBookBackendSqlite *ebsql,
+ const gchar *uid,
+ gboolean meta_contact,
+ gchar **ret_vcard,
+ GError **error);
+gboolean e_book_backend_sqlite_search (EBookBackendSqlite *ebsql,
+ const gchar *sexp,
+ gboolean meta_contacts,
+ GSList **ret_list,
+ GError **error);
+gboolean e_book_backend_sqlite_search_uids (EBookBackendSqlite *ebsql,
+ const gchar *sexp,
+ GSList **ret_list,
+ GError **error);
+
+/* Key / Value convenience API */
+gboolean e_book_backend_sqlite_get_key_value (EBookBackendSqlite *ebsql,
+ const gchar *key,
+ gchar **value,
+ GError **error);
+gboolean e_book_backend_sqlite_set_key_value (EBookBackendSqlite *ebsql,
+ const gchar *key,
+ const gchar *value,
+ GError **error);
+gboolean e_book_backend_sqlite_get_key_value_int
+ (EBookBackendSqlite *ebsql,
+ const gchar *key,
+ gint *value,
+ GError **error);
+gboolean e_book_backend_sqlite_set_key_value_int
+ (EBookBackendSqlite *ebsql,
+ const gchar *key,
+ gint value,
+ GError **error);
+
+/* Cursor API */
+EbSqlCursor *e_book_backend_sqlite_cursor_new (EBookBackendSqlite *ebsql,
+ const gchar *sexp,
+ const EContactField *sort_fields,
+ const EBookCursorSortType *sort_types,
+ guint n_sort_fields,
+ GError **error);
+void e_book_backend_sqlite_cursor_free (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor);
+gint e_book_backend_sqlite_cursor_step (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ EbSqlCursorStepFlags flags,
+ EbSqlCursorOrigin origin,
+ gint count,
+ GSList **results,
+ GError **error);
+void e_book_backend_sqlite_cursor_set_target_alphabetic_index
+ (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ gint idx);
+gboolean e_book_backend_sqlite_cursor_set_sexp
+ (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ const gchar *sexp,
+ GError **error);
+gboolean e_book_backend_sqlite_cursor_calculate
+ (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ gint *total,
+ gint *position,
+ GError **error);
+gint e_book_backend_sqlite_cursor_compare_contact
+ (EBookBackendSqlite *ebsql,
+ EbSqlCursor *cursor,
+ EContact *contact,
+ gboolean *matches_sexp);
+
+G_END_DECLS
+
+#endif /* E_BOOK_BACKEND_SQLITE_H */
diff --git a/addressbook/libedata-book/libedata-book.h b/addressbook/libedata-book/libedata-book.h
index d6f4251..d91acea 100644
--- a/addressbook/libedata-book/libedata-book.h
+++ b/addressbook/libedata-book/libedata-book.h
@@ -29,6 +29,7 @@
#include <libedata-book/e-book-backend-factory.h>
#include <libedata-book/e-book-backend-sexp.h>
#include <libedata-book/e-book-backend-sqlitedb.h>
+#include <libedata-book/e-book-backend-sqlite.h>
#include <libedata-book/e-book-backend-summary.h>
#include <libedata-book/e-book-backend.h>
#include <libedata-book/e-data-book-cursor.h>
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
