r19831: Big ldb_dn optimization and interfaces enhancement patch
[kamenim/samba.git] / source4 / lib / ldb / ldb_sqlite3 / ldb_sqlite3.c
index 1d23478941c837a58b0cc6383c9a3595cf377ce0..7671b0d954f69bfb8d09e2c5408ddb25cb6a8612 100644 (file)
@@ -2,7 +2,7 @@
    ldb database library
    
    Copyright (C) Derrell Lipman  2005
-   Copyright (C) Simo Sorce 2005
+   Copyright (C) Simo Sorce 2005-2006
    
    ** NOTE! The following LGPL license applies to the ldb
    ** library. This does NOT imply that all of Samba is released
  *  Author: Derrell Lipman (based on Andrew Tridgell's LDAP backend)
  */
 
-#include <stdarg.h>
 #include "includes.h"
-#include "ldb/include/ldb.h"
-#include "ldb/include/ldb_errors.h"
-#include "ldb/include/ldb_private.h"
-#include "ldb/ldb_sqlite3/ldb_sqlite3.h"
+#include "ldb/include/includes.h"
+
+#include <sqlite3.h>
+
+struct lsqlite3_private {
+       int trans_count;
+       char **options;
+        sqlite3 *sqlite;
+};
+
+struct lsql_context {
+       struct ldb_module *module;
+
+       /* search stuff */
+       long long current_eid;
+       const char * const * attrs;
+       struct ldb_reply *ares;
+
+       /* async stuff */
+       void *context;
+       int (*callback)(struct ldb_context *, void *, struct ldb_reply *);
+};
+
+static struct ldb_handle *init_handle(struct lsqlite3_private *lsqlite3,
+                                       struct ldb_module *module,
+                                       struct ldb_request *req)
+{
+       struct lsql_context *ac;
+       struct ldb_handle *h;
+
+       h = talloc_zero(lsqlite3, struct ldb_handle);
+       if (h == NULL) {
+               ldb_set_errstring(module->ldb, "Out of Memory");
+               return NULL;
+       }
+
+       h->module = module;
+
+       ac = talloc(h, struct lsql_context);
+       if (ac == NULL) {
+               ldb_set_errstring(module->ldb, "Out of Memory");
+               talloc_free(h);
+               return NULL;
+       }
+
+       h->private_data = (void *)ac;
+
+       h->state = LDB_ASYNC_INIT;
+       h->status = LDB_SUCCESS;
+
+       ac->module = module;
+       ac->context = req->context;
+       ac->callback = req->callback;
+
+       return h;
+}
 
 /*
  * Macros used throughout
@@ -80,7 +131,7 @@ static char *lsqlite3_tprintf(TALLOC_CTX *mem_ctx, const char *fmt, ...)
        return ret;
 }
 
-static unsigned char        base160tab[161] = {
+static char base160tab[161] = {
         48 ,49 ,50 ,51 ,52 ,53 ,54 ,55 ,56 ,57 , /* 0-9 */
         58 ,59 ,65 ,66 ,67 ,68 ,69 ,70 ,71 ,72 , /* : ; A-H */
         73 ,74 ,75 ,76 ,77 ,78 ,79 ,80 ,81 ,82 , /* I-R */
@@ -169,10 +220,9 @@ base160next_sql(sqlite3_context * hContext,
 {
         int                         i;
         int                         len;
-        unsigned char *             pTab;
-        unsigned char *             pBase160 =
-                strdup(sqlite3_value_text(argv[0]));
-        unsigned char *             pStart = pBase160;
+        char *             pTab;
+        char *             pBase160 = strdup((const char *)sqlite3_value_text(argv[0]));
+        char *             pStart = pBase160;
 
         /*
          * We need a minimum of four digits, and we will always get a multiple
@@ -291,7 +341,7 @@ static char *parsetree_to_sql(struct ldb_module *module,
                 * For simple searches, we want to retrieve the list of EIDs that
                 * match the criteria.
                */
-               attr = ldb_casefold(mem_ctx, t->u.equality.attr);
+               attr = ldb_attr_casefold(mem_ctx, t->u.equality.attr);
                if (attr == NULL) return NULL;
                h = ldb_attrib_handler(module->ldb, attr);
 
@@ -319,9 +369,9 @@ static char *parsetree_to_sql(struct ldb_module *module,
 
                } else if (strcasecmp(t->u.equality.attr, "dn") == 0) {
                        /* DN query is a special ldb case */
-                       char *cdn = ldb_dn_linearize_casefold(module->ldb,
-                                                             ldb_dn_explode(module->ldb,
-                                                             value.data));
+                       char *cdn = ldb_dn_casefold(mem_ctx,
+                                                       ldb_dn_new(mem_ctx, module->ldb,
+                                                             (const char *)value.data));
 
                        return lsqlite3_tprintf(mem_ctx,
                                                "SELECT eid FROM ldb_entry "
@@ -355,11 +405,11 @@ static char *parsetree_to_sql(struct ldb_module *module,
                        wild_card_string[strlen(wild_card_string) - 1] = '\0';
                }
 
-               attr = ldb_casefold(mem_ctx, t->u.substring.attr);
+               attr = ldb_attr_casefold(mem_ctx, t->u.substring.attr);
                if (attr == NULL) return NULL;
                h = ldb_attrib_handler(module->ldb, attr);
 
-               subval.data = wild_card_string;
+               subval.data = (void *)wild_card_string;
                subval.length = strlen(wild_card_string) + 1;
 
                /* Get a canonicalised copy of the data */
@@ -376,7 +426,7 @@ static char *parsetree_to_sql(struct ldb_module *module,
                                        value.data);
 
        case LDB_OP_GREATER:
-               attr = ldb_casefold(mem_ctx, t->u.equality.attr);
+               attr = ldb_attr_casefold(mem_ctx, t->u.equality.attr);
                if (attr == NULL) return NULL;
                h = ldb_attrib_handler(module->ldb, attr);
 
@@ -395,7 +445,7 @@ static char *parsetree_to_sql(struct ldb_module *module,
                                        attr);
 
        case LDB_OP_LESS:
-               attr = ldb_casefold(mem_ctx, t->u.equality.attr);
+               attr = ldb_attr_casefold(mem_ctx, t->u.equality.attr);
                if (attr == NULL) return NULL;
                h = ldb_attrib_handler(module->ldb, attr);
 
@@ -418,7 +468,7 @@ static char *parsetree_to_sql(struct ldb_module *module,
                        return talloc_strdup(mem_ctx, "SELECT eid FROM ldb_entry");
                }
 
-               attr = ldb_casefold(mem_ctx, t->u.present.attr);
+               attr = ldb_attr_casefold(mem_ctx, t->u.present.attr);
                if (attr == NULL) return NULL;
 
                return lsqlite3_tprintf(mem_ctx,
@@ -427,7 +477,7 @@ static char *parsetree_to_sql(struct ldb_module *module,
                                        attr);
 
        case LDB_OP_APPROX:
-               attr = ldb_casefold(mem_ctx, t->u.equality.attr);
+               attr = ldb_attr_casefold(mem_ctx, t->u.equality.attr);
                if (attr == NULL) return NULL;
                h = ldb_attrib_handler(module->ldb, attr);
 
@@ -566,10 +616,10 @@ static void lsqlite3_compare(sqlite3_context *ctx, int argc,
                                        sqlite3_value **argv)
 {
        struct ldb_context *ldb = (struct ldb_context *)sqlite3_user_data(ctx);
-       const unsigned char *val = sqlite3_value_text(argv[0]);
-       const unsigned char *func = sqlite3_value_text(argv[1]);
-       const unsigned char *cmp = sqlite3_value_text(argv[2]);
-       const unsigned char *attr = sqlite3_value_text(argv[3]);
+       const char *val = (const char *)sqlite3_value_text(argv[0]);
+       const char *func = (const char *)sqlite3_value_text(argv[1]);
+       const char *cmp = (const char *)sqlite3_value_text(argv[2]);
+       const char *attr = (const char *)sqlite3_value_text(argv[3]);
        const struct ldb_attrib_handler *h;
        struct ldb_val valX;
        struct ldb_val valY;
@@ -579,9 +629,9 @@ static void lsqlite3_compare(sqlite3_context *ctx, int argc,
        /* greater */
        case '>': /* >= */
                h = ldb_attrib_handler(ldb, attr);
-               valX.data = cmp;
+               valX.data = (void *)cmp;
                valX.length = strlen(cmp);
-               valY.data = val;
+               valY.data = (void *)val;
                valY.length = strlen(val);
                ret = h->comparison_fn(ldb, ldb, &valY, &valX);
                if (ret >= 0)
@@ -593,9 +643,9 @@ static void lsqlite3_compare(sqlite3_context *ctx, int argc,
        /* lesser */
        case '<': /* <= */
                h = ldb_attrib_handler(ldb, attr);
-               valX.data = cmp;
+               valX.data = (void *)cmp;
                valX.length = strlen(cmp);
-               valY.data = val;
+               valY.data = (void *)val;
                valY.length = strlen(val);
                ret = h->comparison_fn(ldb, ldb, &valY, &valX);
                if (ret <= 0)
@@ -656,87 +706,72 @@ static int lsqlite3_eid_callback(void *result, int col_num, char **cols, char **
        return SQLITE_OK;
 }
 
-struct lsqlite3_msgs {
-       int count;
-       struct ldb_message **msgs;
-       long long current_eid;
-       const char * const * attrs;
-       TALLOC_CTX *mem_ctx;
-};
-
 /*
  * add a single set of ldap message values to a ldb_message
  */
-
 static int lsqlite3_search_callback(void *result, int col_num, char **cols, char **names)
 {
-       struct lsqlite3_msgs *msgs = (struct lsqlite3_msgs *)result;
+       struct ldb_handle *handle = talloc_get_type(result, struct ldb_handle);
+       struct lsql_context *ac = talloc_get_type(handle->private_data, struct lsql_context);
        struct ldb_message *msg;
        long long eid;
        int i;
 
        /* eid, dn, attr_name, attr_value */
-       if (col_num != 4) return SQLITE_ABORT;
+       if (col_num != 4)
+               return SQLITE_ABORT;
 
        eid = atoll(cols[0]);
 
-       if (eid != msgs->current_eid) {
-               msgs->msgs = talloc_realloc(msgs->mem_ctx,
-                                           msgs->msgs,
-                                           struct ldb_message *,
-                                           msgs->count + 2);
-               if (msgs->msgs == NULL) return SQLITE_ABORT;
+       if (eid != ac->current_eid) { /* here begin a new entry */
 
-               msgs->msgs[msgs->count] = talloc(msgs->msgs, struct ldb_message);
-               if (msgs->msgs[msgs->count] == NULL) return SQLITE_ABORT;
+               /* call the async callback for the last entry
+                * except the first time */
+               if (ac->current_eid != 0) {
+                       ac->ares->message = ldb_msg_canonicalize(ac->module->ldb, ac->ares->message);
+                       if (ac->ares->message == NULL)
+                               return SQLITE_ABORT;
+                       
+                       handle->status = ac->callback(ac->module->ldb, ac->context, ac->ares);
+                       if (handle->status != LDB_SUCCESS)
+                               return SQLITE_ABORT;
+               }
 
-               msgs->msgs[msgs->count]->dn = NULL;
-               msgs->msgs[msgs->count]->num_elements = 0;
-               msgs->msgs[msgs->count]->elements = NULL;
-               msgs->msgs[msgs->count]->private_data = NULL;
+               /* start over */
+               ac->ares = talloc_zero(ac, struct ldb_reply);
+               if (!ac->ares)
+                       return SQLITE_ABORT;
 
-               msgs->count++;
-               msgs->current_eid = eid;
+               ac->ares->message = ldb_msg_new(ac->ares);
+               if (!ac->ares->message)
+                       return SQLITE_ABORT;
+
+               ac->ares->type = LDB_REPLY_ENTRY;
+               ac->current_eid = eid;
        }
 
-       msg = msgs->msgs[msgs->count -1];
+       msg = ac->ares->message;
 
        if (msg->dn == NULL) {
-               msg->dn = ldb_dn_explode(msg, cols[1]);
-               if (msg->dn == NULL) return SQLITE_ABORT;
+               msg->dn = ldb_dn_new(msg, ac->module->ldb, cols[1]);
+               if (msg->dn == NULL)
+                       return SQLITE_ABORT;
        }
 
-       if (msgs->attrs) {
+       if (ac->attrs) {
                int found = 0;
-               for (i = 0; msgs->attrs[i]; i++) {
-                       if (strcasecmp(cols[2], msgs->attrs[i]) == 0) {
+               for (i = 0; ac->attrs[i]; i++) {
+                       if (strcasecmp(cols[2], ac->attrs[i]) == 0) {
                                found = 1;
                                break;
                        }
                }
-               if (!found) return 0;
+               if (!found) return SQLITE_OK;
        }
 
-       msg->elements = talloc_realloc(msg,
-                                      msg->elements,
-                                      struct ldb_message_element,
-                                      msg->num_elements + 1);
-       if (msg->elements == NULL) return SQLITE_ABORT;
-
-       msg->elements[msg->num_elements].flags = 0;
-       msg->elements[msg->num_elements].name = talloc_strdup(msg->elements, cols[2]);
-       if (msg->elements[msg->num_elements].name == NULL) return SQLITE_ABORT;
-
-       msg->elements[msg->num_elements].num_values = 1;
-       msg->elements[msg->num_elements].values = talloc_array(msg->elements,
-                                                               struct ldb_val, 1);
-       if (msg->elements[msg->num_elements].values == NULL) return SQLITE_ABORT;
-
-       msg->elements[msg->num_elements].values[0].length = strlen(cols[3]);
-       msg->elements[msg->num_elements].values[0].data = talloc_strdup(msg->elements, cols[3]);
-       if (msg->elements[msg->num_elements].values[0].data == NULL) return SQLITE_ABORT;
-
-       msg->num_elements++;
+       if (ldb_msg_add_string(msg, cols[2], cols[3]) != 0) {
+               return SQLITE_ABORT;
+       }
 
        return SQLITE_OK;
 }
@@ -775,7 +810,7 @@ static long long lsqlite3_get_eid_ndn(sqlite3 *sqlite, void *mem_ctx, const char
        return eid;
 }
 
-static long long lsqlite3_get_eid(struct ldb_module *module, const struct ldb_dn *dn)
+static long long lsqlite3_get_eid(struct ldb_module *module, struct ldb_dn *dn)
 {
        TALLOC_CTX *local_ctx;
        struct lsqlite3_private *lsqlite3 = module->private_data;
@@ -793,7 +828,7 @@ static long long lsqlite3_get_eid(struct ldb_module *module, const struct ldb_dn
                return -1;
        }
 
-       cdn = ldb_dn_linearize(local_ctx, ldb_dn_casefold(module->ldb, dn));
+       cdn = ldb_dn_linearize(local_ctx, ldb_dn_casefold(module->ldb, local_ctx, dn));
        if (!cdn) goto done;
 
        eid = lsqlite3_get_eid_ndn(lsqlite3->sqlite, local_ctx, cdn);
@@ -808,47 +843,43 @@ done:
  */
 
 /* search for matching records, by tree */
-static int lsqlite3_search_bytree(struct ldb_module * module, const struct ldb_dn* basedn,
-                                 enum ldb_scope scope, struct ldb_parse_tree * tree,
-                                 const char * const * attrs, struct ldb_result ** res)
+int lsql_search(struct ldb_module *module, struct ldb_request *req)
 {
-       TALLOC_CTX *local_ctx;
-       struct lsqlite3_private *lsqlite3 = module->private_data;
-       struct lsqlite3_msgs msgs;
+       struct lsqlite3_private *lsqlite3 = talloc_get_type(module->private_data, struct lsqlite3_private);
+       struct lsql_context *lsql_ac;
        char *norm_basedn;
        char *sqlfilter;
        char *errmsg;
-       char *query;
-        int ret, i;
+       char *query = NULL;
+        int ret;
 
-       /* create a local ctx */
-       local_ctx = talloc_named(lsqlite3, 0, "lsqlite3_search_bytree local context");
-       if (local_ctx == NULL) {
-               return -1;
+       req->handle = init_handle(lsqlite3, module, req);
+       if (req->handle == NULL) {
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       if (basedn) {
-               norm_basedn = ldb_dn_linearize(local_ctx, ldb_dn_casefold(module->ldb, basedn));
+       lsql_ac = talloc_get_type(req->handle->private_data, struct lsql_context);
+
+       if ((req->op.search.base == NULL || req->op.search.base->comp_num == 0) &&
+           (req->op.search.scope == LDB_SCOPE_BASE || req->op.search.scope == LDB_SCOPE_ONELEVEL))
+               return LDB_ERR_OPERATIONS_ERROR;
+
+       if (req->op.search.base) {
+               norm_basedn = ldb_dn_linearize(lsql_ac, ldb_dn_casefold(module->ldb, lsql_ac, req->op.search.base));
                if (norm_basedn == NULL) {
                        ret = LDB_ERR_INVALID_DN_SYNTAX;
                        goto failed;
                }
-       } else norm_basedn = talloc_strdup(local_ctx, "");
-
-       if (*norm_basedn == '\0' &&
-               (scope == LDB_SCOPE_BASE || scope == LDB_SCOPE_ONELEVEL)) {
-                       ret = LDB_ERR_UNWILLING_TO_PERFORM;
-                       goto failed;
-               }
+       } else norm_basedn = talloc_strdup(lsql_ac, "");
 
         /* Convert filter into a series of SQL conditions (constraints) */
-       sqlfilter = parsetree_to_sql(module, local_ctx, tree);
+       sqlfilter = parsetree_to_sql(module, lsql_ac, req->op.search.tree);
         
-        switch(scope) {
+        switch(req->op.search.scope) {
         case LDB_SCOPE_DEFAULT:
         case LDB_SCOPE_SUBTREE:
                if (*norm_basedn != '\0') {
-                       query = lsqlite3_tprintf(local_ctx,
+                       query = lsqlite3_tprintf(lsql_ac,
                                "SELECT entry.eid,\n"
                                "       entry.dn,\n"
                                "       av.attr_name,\n"
@@ -872,7 +903,7 @@ static int lsqlite3_search_bytree(struct ldb_module * module, const struct ldb_d
                                norm_basedn,
                                sqlfilter);
                } else {
-                       query = lsqlite3_tprintf(local_ctx,
+                       query = lsqlite3_tprintf(lsql_ac,
                                "SELECT entry.eid,\n"
                                "       entry.dn,\n"
                                "       av.attr_name,\n"
@@ -896,7 +927,7 @@ static int lsqlite3_search_bytree(struct ldb_module * module, const struct ldb_d
                break;
                 
         case LDB_SCOPE_BASE:
-                query = lsqlite3_tprintf(local_ctx,
+                query = lsqlite3_tprintf(lsql_ac,
                         "SELECT entry.eid,\n"
                         "       entry.dn,\n"
                         "       av.attr_name,\n"
@@ -920,7 +951,7 @@ static int lsqlite3_search_bytree(struct ldb_module * module, const struct ldb_d
                 break;
                 
         case LDB_SCOPE_ONELEVEL:
-                query = lsqlite3_tprintf(local_ctx,
+                query = lsqlite3_tprintf(lsql_ac,
                         "SELECT entry.eid,\n"
                         "       entry.dn,\n"
                         "       av.attr_name,\n"
@@ -946,7 +977,6 @@ static int lsqlite3_search_bytree(struct ldb_module * module, const struct ldb_d
         }
 
         if (query == NULL) {
-                ret = LDB_ERR_OTHER;
                 goto failed;
         }
 
@@ -954,96 +984,94 @@ static int lsqlite3_search_bytree(struct ldb_module * module, const struct ldb_d
        printf ("%s\n", query);
        / * */
 
-       msgs.msgs = NULL;
-       msgs.count = 0;
-       msgs.current_eid = 0;
-       msgs.mem_ctx = local_ctx;
-       msgs.attrs = attrs;
+       lsql_ac->current_eid = 0;
+       lsql_ac->attrs = req->op.search.attrs;
+       lsql_ac->ares = NULL;
 
-       ret = sqlite3_exec(lsqlite3->sqlite, query, lsqlite3_search_callback, &msgs, &errmsg);
+       req->handle->state = LDB_ASYNC_PENDING;
+
+       ret = sqlite3_exec(lsqlite3->sqlite, query, lsqlite3_search_callback, req->handle, &errmsg);
        if (ret != SQLITE_OK) {
                if (errmsg) {
-                       ldb_set_errstring(module, talloc_strdup(module, errmsg));
+                       ldb_set_errstring(module->ldb, errmsg);
                        free(errmsg);
                }
-               ret = LDB_ERR_OTHER;
                goto failed;
        }
 
-       for (i = 0; i < msgs.count; i++) {
-               msgs.msgs[i] = ldb_msg_canonicalize(module->ldb, msgs.msgs[i]);
-               if (msgs.msgs[i] ==  NULL) {
+       /* complete the last message if any */
+       if (lsql_ac->ares) {
+               lsql_ac->ares->message = ldb_msg_canonicalize(module->ldb, lsql_ac->ares->message);
+               if (lsql_ac->ares->message == NULL)
+                       goto failed;
+                       
+               req->handle->status = lsql_ac->callback(module->ldb, lsql_ac->context, lsql_ac->ares);
+               if (req->handle->status != LDB_SUCCESS)
                        goto failed;
-               }
-       }
-
-       *res = talloc(module, struct ldb_result);
-       if (! *res) {
-               goto failed;
        }
 
-       (*res)->msgs = talloc_steal(*res, msgs.msgs);
-       (*res)->count = msgs.count;
+       req->handle->state = LDB_ASYNC_DONE;
 
-       talloc_free(local_ctx);
        return LDB_SUCCESS;
 
-/* If error, return error code; otherwise return number of results */
 failed:
-        talloc_free(local_ctx);
-       return LDB_ERR_OTHER;
+       return LDB_ERR_OPERATIONS_ERROR;
 }
 
-
 /* add a record */
-static int lsqlite3_add(struct ldb_module *module, const struct ldb_message *msg)
+static int lsql_add(struct ldb_module *module, struct ldb_request *req)
 {
-       TALLOC_CTX *local_ctx;
-       struct lsqlite3_private *lsqlite3 = module->private_data;
+       struct lsqlite3_private *lsqlite3 = talloc_get_type(module->private_data, struct lsqlite3_private);
+       struct lsql_context *lsql_ac;
+       struct ldb_message *msg = req->op.add.message;
         long long eid;
        char *dn, *ndn;
        char *errmsg;
        char *query;
-       int ret;
        int i;
-        
-       /* create a local ctx */
-       local_ctx = talloc_named(lsqlite3, 0, "lsqlite3_add local context");
-       if (local_ctx == NULL) {
-               return LDB_ERR_OTHER;
+       int ret = LDB_SUCCESS;
+
+       req->handle = init_handle(lsqlite3, module, req);
+       if (req->handle == NULL) {
+               return LDB_ERR_OPERATIONS_ERROR;
        }
+       lsql_ac = talloc_get_type(req->handle->private_data, struct lsql_context);
+       req->handle->state = LDB_ASYNC_DONE;
+       req->handle->status = LDB_SUCCESS;
 
         /* See if this is an ltdb special */
        if (ldb_dn_is_special(msg->dn)) {
                struct ldb_dn *c;
 
-               c = ldb_dn_explode(local_ctx, "@SUBCLASSES");
+               c = ldb_dn_new(lsql_ac, module->ldb, "@SUBCLASSES");
                if (ldb_dn_compare(module->ldb, msg->dn, c) == 0) {
 #warning "insert subclasses into object class tree"
                        ret = LDB_ERR_UNWILLING_TO_PERFORM;
-                       goto failed;
+                       goto done;
                }
 
 /*
-               c = ldb_dn_explode(local_ctx, "@INDEXLIST");
+               c = ldb_dn_new(local_ctx, module->ldb, "@INDEXLIST");
                if (ldb_dn_compare(module->ldb, msg->dn, c) == 0) {
 #warning "should we handle indexes somehow ?"
-                       goto failed;
+                       ret = LDB_ERR_UNWILLING_TO_PERFORM;
+                       goto done;
                }
 */
-                /* Others are implicitly ignored */
-                return LDB_SUCCESS;
+                /* Others return an error */
+               ret = LDB_ERR_UNWILLING_TO_PERFORM;
+               goto done;
        }
 
        /* create linearized and normalized dns */
-       dn = ldb_dn_linearize(local_ctx, msg->dn);
-       ndn = ldb_dn_linearize(local_ctx, ldb_dn_casefold(module->ldb, msg->dn));
+       dn = ldb_dn_linearize(lsql_ac, msg->dn);
+       ndn = ldb_dn_linearize(lsql_ac, ldb_dn_casefold(module->ldb, lsql_ac, msg->dn));
        if (dn == NULL || ndn == NULL) {
                ret = LDB_ERR_OTHER;
-               goto failed;
+               goto done;
        }
 
-       query = lsqlite3_tprintf(local_ctx,
+       query = lsqlite3_tprintf(lsql_ac,
                                   /* Add new entry */
                                   "INSERT OR ABORT INTO ldb_entry "
                                   "('dn', 'norm_dn') "
@@ -1051,23 +1079,23 @@ static int lsqlite3_add(struct ldb_module *module, const struct ldb_message *msg
                                dn, ndn);
        if (query == NULL) {
                ret = LDB_ERR_OTHER;
-               goto failed;
+               goto done;
        }
 
        ret = sqlite3_exec(lsqlite3->sqlite, query, NULL, NULL, &errmsg);
        if (ret != SQLITE_OK) {
                if (errmsg) {
-                       ldb_set_errstring(module, talloc_strdup(module, errmsg));
+                       ldb_set_errstring(module->ldb, errmsg);
                        free(errmsg);
                }
                ret = LDB_ERR_OTHER;
-               goto failed;
+               goto done;
        }
 
-       eid = lsqlite3_get_eid_ndn(lsqlite3->sqlite, local_ctx, ndn);
+       eid = lsqlite3_get_eid_ndn(lsqlite3->sqlite, lsql_ac, ndn);
        if (eid == -1) {
                ret = LDB_ERR_OTHER;
-               goto failed;
+               goto done;
        }
 
        for (i = 0; i < msg->num_elements; i++) {
@@ -1077,10 +1105,10 @@ static int lsqlite3_add(struct ldb_module *module, const struct ldb_message *msg
                int j;
 
                /* Get a case-folded copy of the attribute name */
-               attr = ldb_casefold(local_ctx, el->name);
+               attr = ldb_attr_casefold(lsql_ac, el->name);
                if (attr == NULL) {
                        ret = LDB_ERR_OTHER;
-                       goto failed;
+                       goto done;
                }
 
                h = ldb_attrib_handler(module->ldb, el->name);
@@ -1091,13 +1119,13 @@ static int lsqlite3_add(struct ldb_module *module, const struct ldb_message *msg
                        char *insert;
 
                        /* Get a canonicalised copy of the data */
-                       h->canonicalise_fn(module->ldb, local_ctx, &(el->values[j]), &value);
+                       h->canonicalise_fn(module->ldb, lsql_ac, &(el->values[j]), &value);
                        if (value.data == NULL) {
                                ret = LDB_ERR_OTHER;
-                               goto failed;
+                               goto done;
                        }
 
-                       insert = lsqlite3_tprintf(local_ctx,
+                       insert = lsqlite3_tprintf(lsql_ac,
                                        "INSERT OR ROLLBACK INTO ldb_attribute_values "
                                        "('eid', 'attr_name', 'norm_attr_name',"
                                        " 'attr_value', 'norm_attr_value') "
@@ -1106,65 +1134,69 @@ static int lsqlite3_add(struct ldb_module *module, const struct ldb_message *msg
                                        el->values[j].data, value.data);
                        if (insert == NULL) {
                                ret = LDB_ERR_OTHER;
-                               goto failed;
+                               goto done;
                        }
 
                        ret = sqlite3_exec(lsqlite3->sqlite, insert, NULL, NULL, &errmsg);
                        if (ret != SQLITE_OK) {
                                if (errmsg) {
-                                       ldb_set_errstring(module, talloc_strdup(module, errmsg));
+                                       ldb_set_errstring(module->ldb, errmsg);
                                        free(errmsg);
                                }
                                ret = LDB_ERR_OTHER;
-                               goto failed;
+                               goto done;
                        }
                }
        }
 
-       talloc_free(local_ctx);
-        return LDB_SUCCESS;
-
-failed:
-       talloc_free(local_ctx);
+       if (lsql_ac->callback) {
+               req->handle->status = lsql_ac->callback(module->ldb, lsql_ac->context, NULL);
+       }
+       
+done:
+       req->handle->state = LDB_ASYNC_DONE;
        return ret;
 }
 
-
 /* modify a record */
-static int lsqlite3_modify(struct ldb_module *module, const struct ldb_message *msg)
+static int lsql_modify(struct ldb_module *module, struct ldb_request *req)
 {
-       TALLOC_CTX *local_ctx;
-       struct lsqlite3_private *lsqlite3 = module->private_data;
+       struct lsqlite3_private *lsqlite3 = talloc_get_type(module->private_data, struct lsqlite3_private);
+       struct lsql_context *lsql_ac;
+       struct ldb_message *msg = req->op.mod.message;
         long long eid;
        char *errmsg;
-       int ret;
        int i;
-        
-       /* create a local ctx */
-       local_ctx = talloc_named(lsqlite3, 0, "lsqlite3_modify local context");
-       if (local_ctx == NULL) {
-               return LDB_ERR_OTHER;
+       int ret = LDB_SUCCESS;
+
+       req->handle = init_handle(lsqlite3, module, req);
+       if (req->handle == NULL) {
+               return LDB_ERR_OPERATIONS_ERROR;
        }
+       lsql_ac = talloc_get_type(req->handle->private_data, struct lsql_context);
+       req->handle->state = LDB_ASYNC_DONE;
+       req->handle->status = LDB_SUCCESS;
 
         /* See if this is an ltdb special */
        if (ldb_dn_is_special(msg->dn)) {
                struct ldb_dn *c;
 
-               c = ldb_dn_explode(local_ctx, "@SUBCLASSES");
+               c = ldb_dn_new(lsql_ac, module->ldb, "@SUBCLASSES");
                if (ldb_dn_compare(module->ldb, msg->dn, c) == 0) {
 #warning "modify subclasses into object class tree"
                        ret = LDB_ERR_UNWILLING_TO_PERFORM;
-                       goto failed;
+                       goto done;
                }
 
-                /* Others are implicitly ignored */
-                return LDB_SUCCESS;
+                /* Others return an error */
+               ret = LDB_ERR_UNWILLING_TO_PERFORM;
+                goto done;
        }
 
        eid = lsqlite3_get_eid(module, msg->dn);
        if (eid == -1) {
                ret = LDB_ERR_OTHER;
-               goto failed;
+               goto done;
        }
 
        for (i = 0; i < msg->num_elements; i++) {
@@ -1176,10 +1208,10 @@ static int lsqlite3_modify(struct ldb_module *module, const struct ldb_message *
                int j;
 
                /* Get a case-folded copy of the attribute name */
-               attr = ldb_casefold(local_ctx, el->name);
+               attr = ldb_attr_casefold(lsql_ac, el->name);
                if (attr == NULL) {
                        ret = LDB_ERR_OTHER;
-                       goto failed;
+                       goto done;
                }
 
                h = ldb_attrib_handler(module->ldb, el->name);
@@ -1189,24 +1221,24 @@ static int lsqlite3_modify(struct ldb_module *module, const struct ldb_message *
                case LDB_FLAG_MOD_REPLACE:
                        
                        /* remove all attributes before adding the replacements */
-                       mod = lsqlite3_tprintf(local_ctx,
+                       mod = lsqlite3_tprintf(lsql_ac,
                                                "DELETE FROM ldb_attribute_values "
                                                "WHERE eid = '%lld' "
                                                "AND norm_attr_name = '%q';",
                                                eid, attr);
                        if (mod == NULL) {
                                ret = LDB_ERR_OTHER;
-                               goto failed;
+                               goto done;
                        }
 
                        ret = sqlite3_exec(lsqlite3->sqlite, mod, NULL, NULL, &errmsg);
                        if (ret != SQLITE_OK) {
                                if (errmsg) {
-                                       ldb_set_errstring(module, talloc_strdup(module, errmsg));
+                                       ldb_set_errstring(module->ldb, errmsg);
                                        free(errmsg);
                                }
                                ret = LDB_ERR_OTHER;
-                               goto failed;
+                               goto done;
                         }
 
                        /* MISSING break is INTENTIONAL */
@@ -1218,13 +1250,13 @@ static int lsqlite3_modify(struct ldb_module *module, const struct ldb_message *
                                struct ldb_val value;
 
                                /* Get a canonicalised copy of the data */
-                               h->canonicalise_fn(module->ldb, local_ctx, &(el->values[j]), &value);
+                               h->canonicalise_fn(module->ldb, lsql_ac, &(el->values[j]), &value);
                                if (value.data == NULL) {
                                        ret = LDB_ERR_OTHER;
-                                       goto failed;
+                                       goto done;
                                }
 
-                               mod = lsqlite3_tprintf(local_ctx,
+                               mod = lsqlite3_tprintf(lsql_ac,
                                        "INSERT OR ROLLBACK INTO ldb_attribute_values "
                                        "('eid', 'attr_name', 'norm_attr_name',"
                                        " 'attr_value', 'norm_attr_value') "
@@ -1234,17 +1266,17 @@ static int lsqlite3_modify(struct ldb_module *module, const struct ldb_message *
 
                                if (mod == NULL) {
                                        ret = LDB_ERR_OTHER;
-                                       goto failed;
+                                       goto done;
                                }
 
                                ret = sqlite3_exec(lsqlite3->sqlite, mod, NULL, NULL, &errmsg);
                                if (ret != SQLITE_OK) {
                                        if (errmsg) {
-                                               ldb_set_errstring(module, talloc_strdup(module, errmsg));
+                                               ldb_set_errstring(module->ldb, errmsg);
                                                free(errmsg);
                                        }
                                        ret = LDB_ERR_OTHER;
-                                       goto failed;
+                                       goto done;
                                }
                        }
 
@@ -1253,24 +1285,24 @@ static int lsqlite3_modify(struct ldb_module *module, const struct ldb_message *
                case LDB_FLAG_MOD_DELETE:
 #warning "We should throw an error if the attribute we are trying to delete does not exist!"
                        if (el->num_values == 0) {
-                               mod = lsqlite3_tprintf(local_ctx,
+                               mod = lsqlite3_tprintf(lsql_ac,
                                                        "DELETE FROM ldb_attribute_values "
                                                        "WHERE eid = '%lld' "
                                                        "AND norm_attr_name = '%q';",
                                                        eid, attr);
                                if (mod == NULL) {
                                        ret = LDB_ERR_OTHER;
-                                       goto failed;
+                                       goto done;
                                }
 
                                ret = sqlite3_exec(lsqlite3->sqlite, mod, NULL, NULL, &errmsg);
                                if (ret != SQLITE_OK) {
                                        if (errmsg) {
-                                               ldb_set_errstring(module, talloc_strdup(module, errmsg));
+                                               ldb_set_errstring(module->ldb, errmsg);
                                                free(errmsg);
                                        }
                                        ret = LDB_ERR_OTHER;
-                                       goto failed;
+                                       goto done;
                                }
                        }
 
@@ -1279,13 +1311,13 @@ static int lsqlite3_modify(struct ldb_module *module, const struct ldb_message *
                                struct ldb_val value;
 
                                /* Get a canonicalised copy of the data */
-                               h->canonicalise_fn(module->ldb, local_ctx, &(el->values[j]), &value);
+                               h->canonicalise_fn(module->ldb, lsql_ac, &(el->values[j]), &value);
                                if (value.data == NULL) {
                                        ret = LDB_ERR_OTHER;
-                                       goto failed;
+                                       goto done;
                                }
 
-                               mod = lsqlite3_tprintf(local_ctx,
+                               mod = lsqlite3_tprintf(lsql_ac,
                                        "DELETE FROM ldb_attribute_values "
                                        "WHERE eid = '%lld' "
                                        "AND norm_attr_name = '%q' "
@@ -1294,17 +1326,17 @@ static int lsqlite3_modify(struct ldb_module *module, const struct ldb_message *
 
                                if (mod == NULL) {
                                        ret = LDB_ERR_OTHER;
-                                       goto failed;
+                                       goto done;
                                }
 
                                ret = sqlite3_exec(lsqlite3->sqlite, mod, NULL, NULL, &errmsg);
                                if (ret != SQLITE_OK) {
                                        if (errmsg) {
-                                               ldb_set_errstring(module, talloc_strdup(module, errmsg));
+                                               ldb_set_errstring(module->ldb, errmsg);
                                                free(errmsg);
                                        }
                                        ret = LDB_ERR_OTHER;
-                                       goto failed;
+                                       goto done;
                                }
                        }
 
@@ -1312,42 +1344,40 @@ static int lsqlite3_modify(struct ldb_module *module, const struct ldb_message *
                }
        }
 
-       talloc_free(local_ctx);
-        return LDB_SUCCESS;
-
-failed:
-       talloc_free(local_ctx);
+       if (lsql_ac->callback) {
+               req->handle->status = lsql_ac->callback(module->ldb, lsql_ac->context, NULL);
+       }
+       
+done:
+       req->handle->state = LDB_ASYNC_DONE;
        return ret;
 }
 
 /* delete a record */
-static int lsqlite3_delete(struct ldb_module *module, const struct ldb_dn *dn)
+static int lsql_delete(struct ldb_module *module, struct ldb_request *req)
 {
-       TALLOC_CTX *local_ctx;
-       struct lsqlite3_private *lsqlite3 = module->private_data;
+       struct lsqlite3_private *lsqlite3 = talloc_get_type(module->private_data, struct lsqlite3_private);
+       struct lsql_context *lsql_ac;
         long long eid;
        char *errmsg;
        char *query;
-       int ret;
+       int ret = LDB_SUCCESS;
 
-       /* ignore ltdb specials */
-       if (ldb_dn_is_special(dn)) {
-               return LDB_SUCCESS;
-       }
 
-       /* create a local ctx */
-       local_ctx = talloc_named(lsqlite3, 0, "lsqlite3_delete local context");
-       if (local_ctx == NULL) {
-               return LDB_ERR_OTHER;
+       req->handle = init_handle(lsqlite3, module, req);
+       if (req->handle == NULL) {
+               return LDB_ERR_OPERATIONS_ERROR;
        }
+       lsql_ac = talloc_get_type(req->handle->private_data, struct lsql_context);
+       req->handle->state = LDB_ASYNC_DONE;
+       req->handle->status = LDB_SUCCESS;
 
-       eid = lsqlite3_get_eid(module, dn);
+       eid = lsqlite3_get_eid(module, req->op.del.dn);
        if (eid == -1) {
-               ret = LDB_ERR_OTHER;
-               goto failed;
+               goto done;
        }
 
-       query = lsqlite3_tprintf(local_ctx,
+       query = lsqlite3_tprintf(lsql_ac,
                                   /* Delete entry */
                                   "DELETE FROM ldb_entry WHERE eid = %lld; "
                                   /* Delete attributes */
@@ -1355,88 +1385,84 @@ static int lsqlite3_delete(struct ldb_module *module, const struct ldb_dn *dn)
                                eid, eid);
        if (query == NULL) {
                ret = LDB_ERR_OTHER;
-               goto failed;
+               goto done;
        }
 
        ret = sqlite3_exec(lsqlite3->sqlite, query, NULL, NULL, &errmsg);
        if (ret != SQLITE_OK) {
                if (errmsg) {
-                       ldb_set_errstring(module, talloc_strdup(module, errmsg));
+                       ldb_set_errstring(module->ldb, errmsg);
                        free(errmsg);
                }
-               ret = LDB_ERR_OTHER;
-               goto failed;
+               req->handle->status = LDB_ERR_OPERATIONS_ERROR;
+               goto done;
        }
 
-       talloc_free(local_ctx);
-        return LDB_SUCCESS;
-
-failed:
-       talloc_free(local_ctx);
+       if (lsql_ac->callback) {
+               ret = lsql_ac->callback(module->ldb, lsql_ac->context, NULL);
+       }
+       
+done:
+       req->handle->state = LDB_ASYNC_DONE;
        return ret;
 }
 
 /* rename a record */
-static int lsqlite3_rename(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
+static int lsql_rename(struct ldb_module *module, struct ldb_request *req)
 {
-       TALLOC_CTX *local_ctx;
-       struct lsqlite3_private *lsqlite3 = module->private_data;
+       struct lsqlite3_private *lsqlite3 = talloc_get_type(module->private_data, struct lsqlite3_private);
+       struct lsql_context *lsql_ac;
        char *new_dn, *new_cdn, *old_cdn;
        char *errmsg;
        char *query;
-       int ret;
-
-       /* ignore ltdb specials */
-       if (ldb_dn_is_special(olddn) || ldb_dn_is_special(newdn)) {
-               return LDB_SUCCESS;
-       }
+       int ret = LDB_SUCCESS;
 
-       /* create a local ctx */
-       local_ctx = talloc_named(lsqlite3, 0, "lsqlite3_rename local context");
-       if (local_ctx == NULL) {
-               return LDB_ERR_OTHER;
+       req->handle = init_handle(lsqlite3, module, req);
+       if (req->handle == NULL) {
+               return LDB_ERR_OPERATIONS_ERROR;
        }
+       lsql_ac = talloc_get_type(req->handle->private_data, struct lsql_context);
+       req->handle->state = LDB_ASYNC_DONE;
+       req->handle->status = LDB_SUCCESS;
 
        /* create linearized and normalized dns */
-       old_cdn = ldb_dn_linearize(local_ctx, ldb_dn_casefold(module->ldb, olddn));
-       new_cdn = ldb_dn_linearize(local_ctx, ldb_dn_casefold(module->ldb, newdn));
-       new_dn = ldb_dn_linearize(local_ctx, newdn);
+       old_cdn = ldb_dn_linearize(lsql_ac, ldb_dn_casefold(module->ldb, lsql_ac, req->op.rename.olddn));
+       new_cdn = ldb_dn_linearize(lsql_ac, ldb_dn_casefold(module->ldb, lsql_ac, req->op.rename.newdn));
+       new_dn = ldb_dn_linearize(lsql_ac, req->op.rename.newdn);
        if (old_cdn == NULL || new_cdn == NULL || new_dn == NULL) {
-               ret = LDB_ERR_OTHER;
-               goto failed;
+               goto done;
        }
 
        /* build the SQL query */
-       query = lsqlite3_tprintf(local_ctx,
+       query = lsqlite3_tprintf(lsql_ac,
                                 "UPDATE ldb_entry SET dn = '%q', norm_dn = '%q' "
                                 "WHERE norm_dn = '%q';",
                                 new_dn, new_cdn, old_cdn);
        if (query == NULL) {
-               ret = LDB_ERR_OTHER;
-               goto failed;
+               goto done;
        }
 
        /* execute */
        ret = sqlite3_exec(lsqlite3->sqlite, query, NULL, NULL, &errmsg);
        if (ret != SQLITE_OK) {
                if (errmsg) {
-                       ldb_set_errstring(module, talloc_strdup(module, errmsg));
+                       ldb_set_errstring(module->ldb, errmsg);
                        free(errmsg);
                }
-               ret = LDB_ERR_OTHER;
-               goto failed;
+               ret = LDB_ERR_OPERATIONS_ERROR;
+               goto done;
        }
 
-       /* clean up and exit */
-       talloc_free(local_ctx);
-        return LDB_SUCCESS;
+       if (lsql_ac->callback) {
+               ret = lsql_ac->callback(module->ldb, lsql_ac->context, NULL);
+       }
 
-failed:
-       talloc_free(local_ctx);
+done:
+       req->handle->state = LDB_ASYNC_DONE;
        return ret;
 }
 
-static int lsqlite3_start_trans(struct ldb_module * module)
+static int lsql_start_trans(struct ldb_module * module)
 {
        int ret;
        char *errmsg;
@@ -1458,7 +1484,7 @@ static int lsqlite3_start_trans(struct ldb_module * module)
        return 0;
 }
 
-static int lsqlite3_end_trans(struct ldb_module *module)
+static int lsql_end_trans(struct ldb_module *module)
 {
        int ret;
        char *errmsg;
@@ -1482,7 +1508,7 @@ static int lsqlite3_end_trans(struct ldb_module *module)
         return 0;
 }
 
-static int lsqlite3_del_trans(struct ldb_module *module)
+static int lsql_del_trans(struct ldb_module *module)
 {
        struct lsqlite3_private *lsqlite3 = module->private_data;
 
@@ -1497,6 +1523,41 @@ static int lsqlite3_del_trans(struct ldb_module *module)
        return -1;
 }
 
+static int destructor(struct lsqlite3_private *lsqlite3)
+{        
+       if (lsqlite3->sqlite) {
+               sqlite3_close(lsqlite3->sqlite);
+       }
+       return 0;
+}
+
+static int lsql_request(struct ldb_module *module, struct ldb_request *req)
+{
+       return LDB_ERR_OPERATIONS_ERROR;
+}
+
+static int lsql_wait(struct ldb_handle *handle, enum ldb_wait_type type)
+{
+       return handle->status;
+}
+
+/*
+ * Table of operations for the sqlite3 backend
+ */
+static const struct ldb_module_ops lsqlite3_ops = {
+       .name              = "sqlite",
+       .search            = lsql_search,
+       .add               = lsql_add,
+        .modify            = lsql_modify,
+        .del               = lsql_delete,
+        .rename            = lsql_rename,
+       .request           = lsql_request,
+       .start_transaction = lsql_start_trans,
+       .end_transaction   = lsql_end_trans,
+       .del_transaction   = lsql_del_trans,
+       .wait              = lsql_wait,
+};
+
 /*
  * Static functions
  */
@@ -1606,12 +1667,12 @@ static int initialize(struct lsqlite3_private *lsqlite3,
                 "    ('TOP', '0001');");
         
         /* Skip protocol indicator of url  */
-        if (strncmp(url, "sqlite://", 9) != 0) {
+        if (strncmp(url, "sqlite3://", 10) != 0) {
                 return SQLITE_MISUSE;
         }
         
         /* Update pointer to just after the protocol indicator */
-        url += 9;
+        url += 10;
         
         /* Try to open the (possibly empty/non-existent) database */
         if ((ret = sqlite3_open(url, &lsqlite3->sqlite)) != SQLITE_OK) {
@@ -1769,69 +1830,14 @@ failed:
        return -1;
 }
 
-static int
-destructor(void *p)
-{
-       struct lsqlite3_private *lsqlite3 = p;
-        
-       if (lsqlite3->sqlite) {
-               sqlite3_close(lsqlite3->sqlite);
-       }
-       return 0;
-}
-
-
-static int lsqlite3_request(struct ldb_module *module, struct ldb_request *req)
-{
-       switch (req->operation) {
-
-       case LDB_REQ_SEARCH:
-               return lsqlite3_search_bytree(module,
-                                         req->op.search.base,
-                                         req->op.search.scope, 
-                                         req->op.search.tree, 
-                                         req->op.search.attrs, 
-                                         req->op.search.res);
-
-       case LDB_REQ_ADD:
-               return lsqlite3_add(module, req->op.add.message);
-
-       case LDB_REQ_MODIFY:
-               return lsqlite3_modify(module, req->op.mod.message);
-
-       case LDB_REQ_DELETE:
-               return lsqlite3_delete(module, req->op.del.dn);
-
-       case LDB_REQ_RENAME:
-               return lsqlite3_rename(module,
-                                       req->op.rename.olddn,
-                                       req->op.rename.newdn);
-
-       default:
-               return LDB_ERR_OPERATIONS_ERROR;
-
-       }
-}
-
-
-/*
- * Table of operations for the sqlite3 backend
- */
-static const struct ldb_module_ops lsqlite3_ops = {
-       .name              = "sqlite",
-       .request           = lsqlite3_request,
-       .start_transaction = lsqlite3_start_trans,
-       .end_transaction   = lsqlite3_end_trans,
-       .del_transaction   = lsqlite3_del_trans
-};
-
 /*
  * connect to the database
  */
-int lsqlite3_connect(struct ldb_context *ldb,
-                    const char *url, 
-                    unsigned int flags, 
-                    const char *options[])
+static int lsqlite3_connect(struct ldb_context *ldb,
+                           const char *url, 
+                           unsigned int flags, 
+                           const char *options[],
+                           struct ldb_module **module)
 {
        int                         i;
         int                         ret;
@@ -1853,15 +1859,19 @@ int lsqlite3_connect(struct ldb_context *ldb,
         
        talloc_set_destructor(lsqlite3, destructor);
         
-       ldb->modules = talloc(ldb, struct ldb_module);
-       if (!ldb->modules) {
+
+
+       *module = talloc(ldb, struct ldb_module);
+       if (!module) {
+               ldb_oom(ldb);
                goto failed;
        }
-       ldb->modules->ldb = ldb;
-       ldb->modules->prev = ldb->modules->next = NULL;
-       ldb->modules->private_data = lsqlite3;
-       ldb->modules->ops = &lsqlite3_ops;
-        
+       talloc_set_name_const(*module, "ldb_sqlite3 backend");
+       (*module)->ldb = ldb;
+       (*module)->prev = (*module)->next = NULL;
+       (*module)->private_data = lsqlite3;
+       (*module)->ops = &lsqlite3_ops;
+
        if (options) {
                /*
                  * take a copy of the options array, so we don't have to rely
@@ -1895,3 +1905,7 @@ failed:
        return -1;
 }
 
+int ldb_sqlite3_init(void)
+{
+       return ldb_register_backend("sqlite3", lsqlite3_connect);
+}