r7562: work in progress

(This used to be commit d8a9ce78533639f510b60b48c8f305bd07f3f717)

1 files changed, 699 insertions, 323 deletions

diff --git a/source4/lib/ldb/ldb_sqlite3/ldb_sqlite3.c b/source4/lib/ldb/ldb_sqlite3/ldb_sqlite3.c
index 4089f0bdb5..dbbb775928 100644
--- a/source4/lib/ldb/ldb_sqlite3/ldb_sqlite3.c
+++ b/source4/lib/ldb/ldb_sqlite3/ldb_sqlite3.c
@@ -48,27 +48,30 @@
 # define TRUE   (! FALSE)
 #endif
 
+#define FILTER_ATTR_TABLE       "temp_filter_attrs"
+#define RESULT_ATTR_TABLE       "temp_result_attrs"
+
 #define QUERY_NOROWS(lsqlite3, bRollbackOnError, sql...)        \
-    do {                                                        \
-            if (query_norows(lsqlite3, sql) != 0) {             \
-                if (bRollbackOnError) {                         \
-                        query_norows(lsqlite3,                  \
-                                       "ROLLBACK;");            \
+        do {                                                    \
+                if (query_norows(lsqlite3, sql) != 0) {         \
+                        if (bRollbackOnError) {                 \
+                                query_norows(lsqlite3,          \
+                                             "ROLLBACK;");      \
+                        }                                       \
+                        return -1;                              \
                 }                                               \
-                return -1;                                      \
-        }                                                       \
-    } while (0)
+        } while (0)
 
 #define QUERY_INT(lsqlite3, result_var, bRollbackOnError, sql...)       \
-    do {                                                                \
-            if (query_int(lsqlite3, &result_var, sql) != 0) {           \
-                    if (bRollbackOnError) {                             \
-                            query_norows(lsqlite3,                      \
-                                                  "ROLLBACK;");         \
-                    }                                                   \
-                    return -1;                                          \
-            }                                                           \
-    } while (0)
+        do {                                                            \
+                if (query_int(lsqlite3, &result_var, sql) != 0) {       \
+                        if (bRollbackOnError) {                         \
+                                query_norows(lsqlite3,                  \
+                                             "ROLLBACK;");              \
+                        }                                               \
+                        return -1;                                      \
+                }                                                       \
+        } while (0)
 
 
 /*
@@ -84,12 +87,20 @@ lsqlite3_delete(struct ldb_module *module,
                 const char *dn);
 
 static int
+lsqlite3_search_bytree(struct ldb_module * module,
+                       const char * pBaseDN,
+                       enum ldb_scope scope,
+                       struct ldb_parse_tree * pTree,
+                       const char * const * attrs,
+                       struct ldb_message *** pppRes);
+
+static int
 lsqlite3_search(struct ldb_module * module,
                 const char * pBaseDN,
                 enum ldb_scope scope,
                 const char * pExpression,
                 const char * const attrs[],
-                struct ldb_message *** res);
+                struct ldb_message *** pppRes);
 
 static int
 lsqlite3_add(struct ldb_module *module,
@@ -131,15 +142,28 @@ query_int(const struct lsqlite3_private * lsqlite3,
 static int case_fold_attr_required(void * hUserData,
                                    char *attr);
 
+static int
+add_msg_attr(void * hTalloc,
+             long long eid,
+             const char * pDN,
+             const char * pAttrName,
+             const char * pAttrValue,
+             long long prevEID,
+             int * pAllocated,
+             struct ldb_message *** pppRes);
+
 static char *
 parsetree_to_sql(struct ldb_module *module,
-                          char * hTalloc,
+                 char * hTalloc,
                  const struct ldb_parse_tree *t);
 
+static int
+parsetree_to_attrlist(struct lsqlite3_private * lsqlite3,
+                      const struct ldb_parse_tree * t);
+
 static char *
-parsetree_to_tablelist(struct ldb_module *module,
-                       char * hTalloc,
-                       const struct ldb_parse_tree *t);
+build_attr_table_list(void * hTalloc,
+                      struct lsqlite3_private * lsqlite3);
 
 static int
 msg_to_sql(struct ldb_module * module,
@@ -193,54 +217,51 @@ lsqlite3_connect(const char *url,
         int                         ret;
 	struct ldb_context *        ldb = NULL;
 	struct lsqlite3_private *   lsqlite3 = NULL;
-
+        
 	ldb = talloc(NULL, struct ldb_context);
 	if (!ldb) {
-		errno = ENOMEM;
 		goto failed;
 	}
-
+        
 	lsqlite3 = talloc(ldb, struct lsqlite3_private);
 	if (!lsqlite3) {
-		errno = ENOMEM;
 		goto failed;
 	}
-
+        
 	lsqlite3->sqlite = NULL;
 	lsqlite3->options = NULL;
         lsqlite3->lock_count = 0;
-
+        
 	ret = initialize(lsqlite3, url);
 	if (ret != SQLITE_OK) {
 		goto failed;
 	}
-
+        
 	talloc_set_destructor(lsqlite3, destructor);
-
+        
 	ldb->modules = talloc(ldb, struct ldb_module);
 	if (!ldb->modules) {
-		errno = ENOMEM;
 		goto failed;
 	}
 	ldb->modules->ldb = ldb;
 	ldb->modules->prev = ldb->modules->next = NULL;
 	ldb->modules->private_data = lsqlite3;
 	ldb->modules->ops = &lsqlite3_ops;
-
+        
 	if (options) {
 		/*
                  * take a copy of the options array, so we don't have to rely
                  * on the caller keeping it around (it might be dynamic)
                  */
 		for (i=0;options[i];i++) ;
-
+                
 		lsqlite3->options = talloc_array(lsqlite3, char *, i+1);
 		if (!lsqlite3->options) {
 			goto failed;
 		}
-		
+                
 		for (i=0;options[i];i++) {
-
+                        
 			lsqlite3->options[i+1] = NULL;
 			lsqlite3->options[i] =
                                 talloc_strdup(lsqlite3->options, options[i]);
@@ -249,9 +270,9 @@ lsqlite3_connect(const char *url,
 			}
 		}
 	}
-
+        
 	return ldb;
-
+        
 failed:
         if (lsqlite3->sqlite != NULL) {
                 (void) sqlite3_close(lsqlite3->sqlite);
@@ -275,7 +296,7 @@ lsqlite3_rename(struct ldb_module * module,
 	if (olddn[0] == '@' ||newdn[0] == '@') {
 		return 0;
 	}
-
+        
 #warning "lsqlite3_rename() is not yet supported"
         return -1;
 }
@@ -289,42 +310,44 @@ lsqlite3_delete(struct ldb_module *module,
 	if (dn[0] == '@') {
 		return 0;
 	}
-	
+        
 #warning "lsqlite3_delete() is not yet supported"
         return -1;
 }
 
-/* search for matching records */
+/* search for matching records, by tree */
 static int
-lsqlite3_search(struct ldb_module * module,
-                const char * pBaseDN,
-                enum ldb_scope scope,
-                const char * pExpression,
-                const char * const attrs[],
-                struct ldb_message *** res)
+lsqlite3_search_bytree(struct ldb_module * module,
+                       const char * pBaseDN,
+                       enum ldb_scope scope,
+                       struct ldb_parse_tree * pTree,
+                       const char * const * attrs,
+                       struct ldb_message *** pppRes)
 {
+        int                         i;
         int                         ret;
+        int                         allocated;
         int                         bLoop;
         long long                   eid = 0;
         long long                   prevEID;
         char *                      pSql = NULL;
 	char *                      pSqlConstraints;
         char *                      pTableList;
-        char *                      hTalloc;
+        char *                      hTalloc = NULL;
         const char *                pDN;
         const char *                pAttrName;
         const char *                pAttrValue;
+        const char * const *        pRequestedAttrs;
         sqlite3_stmt *              pStmt;
-	struct ldb_parse_tree *     pTree;
 	struct lsqlite3_private *   lsqlite3 = module->private_data;
-	
+        
 	if (pBaseDN == NULL) {
 		pBaseDN = "";
 	}
-
+        
         /* Begin a transaction */
         QUERY_NOROWS(lsqlite3, FALSE, "BEGIN IMMEDIATE;");
-
+        
         /*
          * Obtain the eid of the base DN
          */
@@ -335,24 +358,60 @@ lsqlite3_search(struct ldb_module * module,
                   "  FROM ldb_attr_dn "
                   "  WHERE attr_value = %Q;",
                   pBaseDN);
-
-        /* Parse the filter expression into a tree we can work with */
-	if ((pTree = ldb_parse_tree(module->ldb, pExpression)) == NULL) {
-		return -1;
-	}
-	
+        
         /* Allocate a temporary talloc context */
-	hTalloc = talloc_new(module->ldb);
-
-        /* Move the parse tree to our temporary context */
-	talloc_steal(hTalloc, pTree);
-	
-        /* Convert filter into a series of SQL statements (constraints) */
+	if ((hTalloc = talloc_new(module->ldb)) == NULL) {
+                ret = -1;
+                talloc_free(pTree);
+                goto cleanup;
+        }
+        
+        /* Convert filter into a series of SQL conditions (constraints) */
 	pSqlConstraints = parsetree_to_sql(module, hTalloc, pTree);
-	
-        /* Get the list of attribute names to use as our extra table list */
-        pTableList = parsetree_to_tablelist(module, hTalloc, pTree);
-
+        
+        /* Ensure we're starting with an empty result attribute table */
+        QUERY_NOROWS(lsqlite3,
+                     FALSE,
+                     "DELETE FROM " RESULT_ATTR_TABLE " "
+                     "  WHERE 1;");/* avoid a schema change with WHERE 1 */
+        
+        /* Insert the list of requested attributes into this table */
+        for (pRequestedAttrs = (const char * const *) attrs;
+             pRequestedAttrs != NULL;
+             pRequestedAttrs++) {
+                
+                QUERY_NOROWS(lsqlite3,
+                             FALSE,
+                             "INSERT OR IGNORE INTO " RESULT_ATTR_TABLE " "
+                             "    (attr_name) "
+                             "  VALUES "
+                             "    (%Q);",
+                             *pRequestedAttrs);
+        }
+        
+        /* Ensure we're starting with an empty filter attribute table */
+        QUERY_NOROWS(lsqlite3,
+                     FALSE,
+                     "DELETE FROM " FILTER_ATTR_TABLE " "
+                     "  WHERE 1;");/* avoid a schema change with WHERE 1 */
+        
+        /*
+         * Create a table of unique attribute names for our extra table list
+         */
+        if (parsetree_to_attrlist(lsqlite3, pTree) != 0) {
+                ret = -1;
+                goto cleanup;
+        }
+        
+        /*
+         * Build the attribute table list from the list of unique names.
+         */
+        
+        if ((pTableList = build_attr_table_list(hTalloc, lsqlite3)) == NULL) {
+                ret = -1;
+                goto cleanup;
+        }
+        
         switch(scope) {
         case LDB_SCOPE_DEFAULT:
         case LDB_SCOPE_SUBTREE:
@@ -373,12 +432,15 @@ lsqlite3_search(struct ldb_module * module,
                         "         AND ldap_entry.eid IN\n%s\n"
                         "    ) "
                         "    AND av.eid = entry.eid "
+                        "    AND av.attr_name IN "
+                        "          (SELECT attr_name "
+                        "             FROM " RESULT_ATTR_TABLE ") "
                         "  ORDER BY av.eid, av.attr_name;",
                         pTableList,
                         eid,
                         pSqlConstraints);
                 break;
-
+                
         case LDB_SCOPE_BASE:
                 pSql = sqlite3_mprintf(
                         "SELECT entry.eid,\n"
@@ -394,12 +456,15 @@ lsqlite3_search(struct ldb_module * module,
                         "         AND ldb_entry.eid IN\n%s\n"
                         "    ) "
                         "    AND av.eid = entry.eid "
+                        "    AND av.attr_name IN "
+                        "          (SELECT attr_name "
+                        "             FROM " RESULT_ATTR_TABLE ") "
                         "  ORDER BY av.eid, av.attr_name;",
                         pTableList,
                         eid,
                         pSqlConstraints);
                 break;
-
+                
         case LDB_SCOPE_ONELEVEL:
                 pSql = sqlite3_mprintf(
                         "SELECT entry.eid,\n"
@@ -417,70 +482,96 @@ lsqlite3_search(struct ldb_module * module,
                         "         AND ldb_entry.eid IN\n%s\n"
                         "    ) "
                         "    AND av.eid = entry.eid "
+                        "    AND av.attr_name IN "
+                        "          (SELECT attr_name "
+                        "             FROM " RESULT_ATTR_TABLE ") "
                         "  ORDER BY av.eid, av.attr_name;",
                         pTableList,
                         eid,
                         pSqlConstraints);
                 break;
         }
-
-        /* Initially, we have no old eid */
-        prevEID = -1;
-
+        
         /*
          * Prepare and execute the SQL statement.  Loop allows retrying on
          * certain errors, e.g. SQLITE_SCHEMA occurs if the schema changes,
          * requiring retrying the operation.
          */
         for (bLoop = TRUE; bLoop; ) {
-
+                /* There are no allocate message structures yet */
+                allocated = 0;
+                
+                for (i = 0; i < allocated; i++) {
+                        (*pppRes)[i] = NULL;
+                }
+                
                 /* Compile the SQL statement into sqlite virtual machine */
                 if ((ret = sqlite3_prepare(lsqlite3->sqlite,
                                            pSql,
                                            -1,
                                            &pStmt,
                                            NULL)) == SQLITE_SCHEMA) {
+                        talloc_free(*pppRes);
                         continue;
                 } else if (ret != SQLITE_OK) {
                         ret = -1;
                         break;
                 }
                 
+                /* Initially, we have no previous eid */
+                prevEID = -1;
+                
                 /* Loop through the returned rows */
-                do {
+                for (ret = SQLITE_ROW; ret == SQLITE_ROW; ) {
+                        
                         /* Get the next row */
                         if ((ret = sqlite3_step(pStmt)) == SQLITE_ROW) {
-
+                                
                                 /* Get the values from this row */
                                 eid = sqlite3_column_int64(pStmt, 0);
                                 pDN = sqlite3_column_text(pStmt, 1);
                                 pAttrName = sqlite3_column_text(pStmt, 2);
                                 pAttrValue = sqlite3_column_text(pStmt, 3);
                                 
-                                /* Add this row data to the return results */
-#warning "finish returning the result set of the search here"
+                                /* Add this result to the result set */
+                                if ((ret = add_msg_attr(hTalloc,
+                                                        eid,
+                                                        pDN,
+                                                        pAttrName,
+                                                        pAttrValue,
+                                                        prevEID,
+                                                        &allocated,
+                                                        pppRes)) != 0) {
+                                        
+                                        (void) sqlite3_finalize(pStmt);
+                                        ret = -1;
+                                        break;
+                                }
                         }
-                } while (ret == SQLITE_ROW);
-
+#warning "finish returning the result set of the search here"
+                }
+                
                 if (ret == SQLITE_SCHEMA) {
                         (void) sqlite3_finalize(pStmt);
+                        talloc_free(*pppRes);
                         continue;
                 } else if (ret != SQLITE_DONE) {
                         (void) sqlite3_finalize(pStmt);
                         ret = -1;
                         break;
                 }
-
+                
                 /* Free the virtual machine */
                 if ((ret = sqlite3_finalize(pStmt)) == SQLITE_SCHEMA) {
                         (void) sqlite3_finalize(pStmt);
+                        talloc_free(*pppRes);
                         continue;
                 } else if (ret != SQLITE_OK) {
                         (void) sqlite3_finalize(pStmt);
                         ret = -1;
                         break;
                 }
-
+                
                 /*
                  * Normal condition is only one time through loop.  Loop is
                  * rerun in error conditions, via "continue", above.
@@ -488,15 +579,66 @@ lsqlite3_search(struct ldb_module * module,
                 ret = 0;
                 bLoop = FALSE;
         }
-
-
+        
         /* End the transaction */
         QUERY_NOROWS(lsqlite3, FALSE, "END TRANSACTION;");
-
+        
         /* We're alll done with this query */
         sqlite3_free(pSql);
+        
+        /* Were there any results? */
+        if (ret != 0 || allocated == 0) {
+                /* Nope.  We can free the results. */
+                talloc_free(pppRes);
+        }
+        
+cleanup:
+        /* Clean up our temporary tables */
+        QUERY_NOROWS(lsqlite3,
+                     FALSE,
+                     "DELETE FROM " RESULT_ATTR_TABLE " "
+                     "  WHERE 1;");/* avoid a schema change with WHERE 1 */
+        
+        QUERY_NOROWS(lsqlite3,
+                     FALSE,
+                     "DELETE FROM " FILTER_ATTR_TABLE " "
+                     "  WHERE 1;");/* avoid a schema change with WHERE 1 */
+        
+        
+        if (hTalloc != NULL) {
+                talloc_free(hTalloc);
+        }
+        
+        /* If error, return error code; otherwise return number of results */
+	return ret == 0 ? allocated : ret;
+}
 
-	return ret;
+/* search for matching records, by expression */
+static int
+lsqlite3_search(struct ldb_module * module,
+                const char * pBaseDN,
+                enum ldb_scope scope,
+                const char * pExpression,
+                const char * const * attrs,
+                struct ldb_message *** pppRes)
+{
+        int                     ret;
+        struct ldb_parse_tree * pTree;
+        
+        /* Parse the filter expression into a tree we can work with */
+	if ((pTree = ldb_parse_tree(module->ldb, pExpression)) == NULL) {
+                return -1;
+	}
+        
+        /* Now use the bytree function for the remainder of processing */
+        ret = lsqlite3_search_bytree(module, pBaseDN, scope,
+                                     pTree, attrs, pppRes);
+        
+        /* Free the parse tree */
+	talloc_free(pTree);
+        
+        /* All done. */
+        return ret;
 }
 
 
@@ -507,15 +649,15 @@ lsqlite3_add(struct ldb_module *module,
 {
         long long                   eid;
 	struct lsqlite3_private *   lsqlite3 = module->private_data;
-
+        
 	/* ignore ltdb specials */
 	if (msg->dn[0] == '@') {
 		return 0;
 	}
-
+        
         /* Begin a transaction */
         QUERY_NOROWS(lsqlite3, FALSE, "BEGIN EXCLUSIVE;");
-
+        
         /*
          * Build any portions of the directory tree that don't exist.  If the
          * final component already exists, it's an error.
@@ -524,13 +666,13 @@ lsqlite3_add(struct ldb_module *module,
                 QUERY_NOROWS(lsqlite3, FALSE, "ROLLBACK;");
                 return -1;
         }
-
+        
         /* Add attributes to this new entry */
 	if (msg_to_sql(module, msg, eid, FALSE) != 0) {
                 QUERY_NOROWS(lsqlite3, FALSE, "ROLLBACK;");
                 return -1;
         }
-
+        
         /* Everything worked.  Commit it! */
         QUERY_NOROWS(lsqlite3, TRUE, "COMMIT;");
         return 0;
@@ -543,15 +685,15 @@ lsqlite3_modify(struct ldb_module *module,
                 const struct ldb_message *msg)
 {
 	struct lsqlite3_private *   lsqlite3 = module->private_data;
-
+        
 	/* ignore ltdb specials */
 	if (msg->dn[0] == '@') {
 		return 0;
 	}
-
+        
         /* Begin a transaction */
         QUERY_NOROWS(lsqlite3, FALSE, "BEGIN EXCLUSIVE;");
-
+        
         /* Everything worked.  Commit it! */
         QUERY_NOROWS(lsqlite3, TRUE, "COMMIT;");
         return 0 ;
@@ -565,9 +707,9 @@ lsqlite3_lock(struct ldb_module *module,
 	if (lockname == NULL) {
 		return -1;
 	}
-
+        
 	/* TODO implement a local locking mechanism here */
-
+        
 	return 0;
 }
 
@@ -579,9 +721,9 @@ lsqlite3_unlock(struct ldb_module *module,
 	if (lockname == NULL) {
 		return -1;
 	}
-
+        
 	/* TODO implement a local locking mechanism here */
-
+        
         return 0;
 }
 
@@ -590,7 +732,7 @@ static const char *
 lsqlite3_errstring(struct ldb_module *module)
 {
 	struct lsqlite3_private *   lsqlite3 = module->private_data;
-
+        
 	return sqlite3_errmsg(lsqlite3->sqlite);
 }
 
@@ -611,22 +753,22 @@ initialize(struct lsqlite3_private *lsqlite3,
         sqlite3_stmt *  stmt;
         const char *    schema =       
                 "-- ------------------------------------------------------"
-
+                
                 "PRAGMA auto_vacuum=1;"
-
+                
                 "-- ------------------------------------------------------"
-
+                
                 "BEGIN EXCLUSIVE;"
-
+                
                 "-- ------------------------------------------------------"
-
+                
                 "CREATE TABLE ldb_info AS"
                 "  SELECT 'LDB' AS database_type,"
                 "         '1.0' AS version;"
-
+                
                 "-- ------------------------------------------------------"
                 "-- Schema"
-
+                
                 "/*"
                 " * The entry table holds the information about an entry. "
                 " * This table is used to obtain the EID of the entry and to "
@@ -638,21 +780,21 @@ initialize(struct lsqlite3_private *lsqlite3,
                 "("
                 "  -- Unique identifier of this LDB entry"
                 "  eid                   INTEGER PRIMARY KEY,"
-
+                
                 "  -- Unique identifier of the parent LDB entry"
                 "  peid                  INTEGER REFERENCES ldb_entry,"
-
+                
                 "  -- Distinguished name of this entry"
                 "  dn                    TEXT,"
-
+                
                 "  -- Time when the entry was created"
                 "  create_timestamp      INTEGER,"
-
+                
                 "  -- Time when the entry was last modified"
                 "  modify_timestamp      INTEGER"
                 ");"
-
-
+                
+                
                 "/*"
                 " * The purpose of the descendant table is to support the"
                 " * subtree search feature.  For each LDB entry with a unique"
@@ -671,24 +813,24 @@ initialize(struct lsqlite3_private *lsqlite3,
                 "("
                 "  -- The unique identifier of the ancestor LDB entry"
                 "  aeid                  INTEGER REFERENCES ldb_entry,"
-
+                
                 "  -- The unique identifier of the descendant LDB entry"
                 "  deid                  INTEGER REFERENCES ldb_entry"
                 ");"
-
-
+                
+                
                 "CREATE TABLE ldb_object_classes"
                 "("
                 "  -- Object classes are inserted into this table to track"
                 "  -- their class hierarchy.  'top' is the top-level class"
                 "  -- of which all other classes are subclasses."
                 "  class_name            TEXT PRIMARY KEY,"
-
+                
                 "  -- tree_key tracks the position of the class in"
                 "  -- the hierarchy"
                 "  tree_key              TEXT UNIQUE"
                 ");"
-
+                
                 "/*"
                 " * We keep a full listing of attribute/value pairs here"
                 " */"
@@ -698,7 +840,7 @@ initialize(struct lsqlite3_private *lsqlite3,
                 "  attr_name             TEXT, -- see ldb_attr_ATTRIBUTE_NAME"
                 "  attr_value            TEXT"
                 ");"
-
+                
                 "/*"
                 " * There is one attribute table per searchable attribute."
                 " */"
@@ -707,20 +849,20 @@ initialize(struct lsqlite3_private *lsqlite3,
                 "("
                 "  -- The unique identifier of the LDB entry"
                 "  eid                   INTEGER REFERENCES ldb_entry,"
-
+                
                 "  -- Normalized attribute value"
                 "  attr_value            TEXT"
                 ");"
                 "*/"
-
-
+                
+                
                 "-- ------------------------------------------------------"
                 "-- Indexes"
-
-
+                
+                
                 "-- ------------------------------------------------------"
                 "-- Triggers"
-
+                
                 "CREATE TRIGGER ldb_entry_insert_tr"
                 "  AFTER INSERT"
                 "  ON ldb_entry"
@@ -731,7 +873,7 @@ initialize(struct lsqlite3_private *lsqlite3,
                 "            modify_timestamp = strftime('%s', 'now')"
                 "        WHERE eid = new.eid;"
                 "    END;"
-
+                
                 "CREATE TRIGGER ldb_entry_update_tr"
                 "  AFTER UPDATE"
                 "  ON ldb_entry"
@@ -741,19 +883,19 @@ initialize(struct lsqlite3_private *lsqlite3,
                 "        SET modify_timestamp = strftime('%s', 'now')"
                 "        WHERE eid = old.eid;"
                 "    END;"
-
+                
                 "-- ------------------------------------------------------"
                 "-- Table initialization"
-
+                
                 "/* We need an implicit 'top' level object class */"
                 "INSERT INTO ldb_attributes (attr_name,"
                 "                            parent_tree_key)"
                 "  SELECT 'top', '';"
-
+                
                 "-- ------------------------------------------------------"
-
+                
                 "COMMIT;"
-
+                
                 "-- ------------------------------------------------------"
                 ;
         
@@ -761,18 +903,18 @@ initialize(struct lsqlite3_private *lsqlite3,
         if (strncmp(url, "sqlite://", 9) != 0) {
                 return SQLITE_MISUSE;
         }
-
+        
         /* Update pointer to just after the protocol indicator */
         url += 9;
-                
+        
         /* Try to open the (possibly empty/non-existent) database */
         if ((ret = sqlite3_open(url, &lsqlite3->sqlite)) != SQLITE_OK) {
                 return ret;
         }
-
+        
         /* Begin a transaction */
         QUERY_NOROWS(lsqlite3, FALSE, "BEGIN EXCLUSIVE;");
-
+        
         /* Determine if this is a new database.  No tables means it is. */
         QUERY_INT(lsqlite3,
                   queryInt,
@@ -780,13 +922,13 @@ initialize(struct lsqlite3_private *lsqlite3,
                   "SELECT COUNT(*) "
                   "  FROM sqlite_master "
                   "  WHERE type = 'table';");
-
+        
         if (queryInt == 0) {
                 /*
                  * Create the database schema
                  */
                 for (pTail = discard_const_p(char, schema); pTail != NULL; ) {
-
+                        
                         if ((ret = sqlite3_prepare(
                                      lsqlite3->sqlite,
                                      pTail,
@@ -795,7 +937,7 @@ initialize(struct lsqlite3_private *lsqlite3,
                                      &pTail)) != SQLITE_OK ||
                             (ret = sqlite3_step(stmt)) != SQLITE_DONE ||
                             (ret = sqlite3_finalize(stmt)) != SQLITE_OK) {
-
+                                
                                 QUERY_NOROWS(lsqlite3, FALSE, "ROLLBACK;");
                                 (void) sqlite3_close(lsqlite3->sqlite);
                                 return ret;
@@ -825,17 +967,39 @@ initialize(struct lsqlite3_private *lsqlite3,
                               "       AND version = '1.0'"
                               "  );") != 0 ||
                     queryInt != 1) {
-                
+                        
                         /* It's not one that we created.  See ya! */
                         QUERY_NOROWS(lsqlite3, FALSE, "ROLLBACK;");
                         (void) sqlite3_close(lsqlite3->sqlite);
                         return SQLITE_MISUSE;
                 }
         }
-
+        
+        /*
+         * Create a temporary table to hold attributes requested in the result
+         * set of a search.
+         */
+        QUERY_NOROWS(lsqlite3,
+                     FALSE,
+                     "CREATE TEMPORARY TABLE " RESULT_ATTR_TABLE " "
+                     " ("
+                     "  attr_name TEXT PRIMARY KEY "
+                     " );");
+        
+        /*
+         * Create a temporary table to hold the attributes used by filters
+         * during a search.
+         */
+        QUERY_NOROWS(lsqlite3,
+                     FALSE,
+                     "CREATE TEMPORARY TABLE " FILTER_ATTR_TABLE " "
+                     " ("
+                     "  attr_name TEXT PRIMARY KEY "
+                     " );");
+        
         /* Commit the transaction */
         QUERY_NOROWS(lsqlite3, FALSE, "COMMIT;");
-
+        
         return SQLITE_OK;
 }
 
@@ -843,7 +1007,7 @@ static int
 destructor(void *p)
 {
 	struct lsqlite3_private *   lsqlite3 = p;
-
+        
         (void) sqlite3_close(lsqlite3->sqlite);
 	return 0;
 }
@@ -871,19 +1035,19 @@ query_norows(const struct lsqlite3_private *lsqlite3,
         
         /* Begin access to variable argument list */
         va_start(args, pSql);
-
+        
         /* Format the query */
         if ((p = sqlite3_vmprintf(pSql, args)) == NULL) {
                 return -1;
         }
-
+        
         /*
          * Prepare and execute the SQL statement.  Loop allows retrying on
          * certain errors, e.g. SQLITE_SCHEMA occurs if the schema changes,
          * requiring retrying the operation.
          */
         for (bLoop = TRUE; bLoop; ) {
-
+                
                 /* Compile the SQL statement into sqlite virtual machine */
                 if ((ret = sqlite3_prepare(lsqlite3->sqlite,
                                            pTail,
@@ -905,7 +1069,7 @@ query_norows(const struct lsqlite3_private *lsqlite3,
                         ret = -1;
                         break;
                 }
-
+                
                 /* Free the virtual machine */
                 if ((ret = sqlite3_finalize(pStmt)) == SQLITE_SCHEMA) {
                         (void) sqlite3_finalize(pStmt);
@@ -915,7 +1079,7 @@ query_norows(const struct lsqlite3_private *lsqlite3,
                         ret = -1;
                         break;
                 }
-
+                
                 /*
                  * Normal condition is only one time through loop.  Loop is
                  * rerun in error conditions, via "continue", above.
@@ -923,13 +1087,13 @@ query_norows(const struct lsqlite3_private *lsqlite3,
                 ret = 0;
                 bLoop = FALSE;
         }
-
+        
         /* All done with variable argument list */
         va_end(args);
-
+        
         /* Free the memory we allocated for our query string */
         sqlite3_free(p);
-
+        
         return ret;
 }
 
@@ -958,19 +1122,19 @@ query_int(const struct lsqlite3_private * lsqlite3,
         
         /* Begin access to variable argument list */
         va_start(args, pSql);
-
+        
         /* Format the query */
         if ((p = sqlite3_vmprintf(pSql, args)) == NULL) {
                 return -1;
         }
-
+        
         /*
          * Prepare and execute the SQL statement.  Loop allows retrying on
          * certain errors, e.g. SQLITE_SCHEMA occurs if the schema changes,
          * requiring retrying the operation.
          */
         for (bLoop = TRUE; bLoop; ) {
-
+                
                 /* Compile the SQL statement into sqlite virtual machine */
                 if ((ret = sqlite3_prepare(lsqlite3->sqlite,
                                            pTail,
@@ -992,10 +1156,10 @@ query_int(const struct lsqlite3_private * lsqlite3,
                         ret = -1;
                         break;
                 }
-
+                
                 /* Get the value to be returned */
                 *pRet = sqlite3_column_int64(pStmt, 0);
-
+                
                 /* Free the virtual machine */
                 if ((ret = sqlite3_finalize(pStmt)) == SQLITE_SCHEMA) {
                         (void) sqlite3_finalize(pStmt);
@@ -1005,7 +1169,7 @@ query_int(const struct lsqlite3_private * lsqlite3,
                         ret = -1;
                         break;
                 }
-
+                
                 /*
                  * Normal condition is only one time through loop.  Loop is
                  * rerun in error conditions, via "continue", above.
@@ -1013,13 +1177,13 @@ query_int(const struct lsqlite3_private * lsqlite3,
                 ret = 0;
                 bLoop = FALSE;
         }
-
+        
         /* All done with variable argument list */
         va_end(args);
-
+        
         /* Free the memory we allocated for our query string */
         sqlite3_free(p);
-
+        
         return ret;
 }
 
@@ -1043,162 +1207,210 @@ case_fold_attr_required(void * hUserData,
  * add a single set of ldap message values to a ldb_message
  */
 
-#warning "add_msg_attr() not yet implemented or used"
-#if 0
 static int
-add_msg_attr(struct ldb_context *ldb,
-                      struct ldb_message *msg, 
-                      const char *attr,
-                      struct berval **bval)
+add_msg_attr(void * hTalloc,
+             long long eid,
+             const char * pDN,
+             const char * pAttrName,
+             const char * pAttrValue,
+             long long prevEID,
+             int * pAllocated,
+             struct ldb_message *** pppRes)
 {
-        int                          i;
-	int                          count;
+        void *                       x;
+        struct ldb_message *         msg;
 	struct ldb_message_element * el;
-
-	count = ldap_count_values_len(bval);
-
-	if (count <= 0) {
-		return -1;
-	}
-
-	el = talloc_realloc(msg, msg->elements, struct ldb_message_element, 
-			      msg->num_elements + 1);
-	if (!el) {
-		errno = ENOMEM;
-		return -1;
-	}
-
-	msg->elements = el;
-
-	el = &msg->elements[msg->num_elements];
-
-	el->name = talloc_strdup(msg->elements, attr);
-	if (!el->name) {
-		errno = ENOMEM;
-		return -1;
-	}
-	el->flags = 0;
-
-	el->num_values = 0;
-	el->values = talloc_array(msg->elements, struct ldb_val, count);
-	if (!el->values) {
-		errno = ENOMEM;
-		return -1;
-	}
-
-	for (i=0;i<count;i++) {
-		el->values[i].data = talloc_memdup(el->values, bval[i]->bv_val, bval[i]->bv_len);
-		if (!el->values[i].data) {
-			return -1;
-		}
-		el->values[i].length = bval[i]->bv_len;
-		el->num_values++;
-	}
-
-	msg->num_elements++;
-
+        
+        /* Is this a different EID than the previous one? */
+        if (eid != prevEID) {
+                /* Yup.  Add another result to the result array */
+                if ((x = talloc_realloc(hTalloc,
+                                        *pAllocated == 0 ? NULL : pppRes,
+                                        struct ldb_message *,
+                                        *pAllocated + 1)) == NULL) {
+                        
+                        return -1;
+                }
+                
+                /* Save the new result list */
+                *pppRes = x;
+                
+                /* We've allocated one more result */
+                *pAllocated++;
+                
+                /* Ensure that the message is initialized */
+                msg = x;
+                msg->dn = NULL;
+                msg->num_elements = 0;
+                msg->elements = NULL;
+                msg->private_data = NULL;
+        } else {
+                /* Same EID.  Point to the previous most-recent message */
+                msg = *pppRes[*pAllocated - 1];
+        }
+        
+        /*
+         * Point to the most recent previous element.  (If there are none,
+         * this will point to non-allocated memory, but the pointer will never
+         * be dereferenced.)
+         */
+        el = &msg->elements[msg->num_elements - 1];
+        
+        /* See if the most recent previous element has the same attr_name */
+        if (msg->num_elements == 0 || strcmp(el->name, pAttrName) != 0) {
+                
+                /* It's a new attr_name.  Allocate another message element */
+                if ((el = talloc_realloc(msg,
+                                         msg->elements,
+                                         struct ldb_message_element, 
+                                         msg->num_elements + 1)) == NULL) {
+                        return -1;
+                }
+                
+                /* Save the new element */
+                msg->elements = el;
+                
+                /* There's now one additional element */
+                msg->num_elements++;
+                
+                /* Save the attribute name */
+                if ((el->name =
+                     talloc_strdup(msg->elements, pAttrName)) == NULL) {
+                        
+                        return -1;
+                }
+                
+                /* No flags */
+                el->flags = 0;
+                
+                /* Initialize number of attribute values for this type */
+                el->num_values = 0;
+                el->values = NULL;
+        }
+        
+        /* Increase the value array size by 1 */
+        if ((el->values =
+             talloc_realloc(el,
+                            el->num_values == 0 ? NULL : el->values,
+                            struct ldb_val,
+                            el->num_values)) == NULL) {
+                return -1;
+        }
+        
+        /* Save the new attribute value length */
+        el->values[el->num_values].length = strlen(pAttrValue) + 1;
+        
+        /* Copy the new attribute value */
+        if (talloc_memdup(el->values[el->num_values].data,
+                          pAttrValue,
+                          el->values[el->num_values].length) == NULL) {
+                return -1;
+        }
+        
+        /* We now have one additional value of this type */
+        el->num_values++;
+        
 	return 0;
 }
-#endif
 
 static char *
 parsetree_to_sql(struct ldb_module *module,
-                          char * hTalloc,
-                          const struct ldb_parse_tree *t)
+                 char * hTalloc,
+                 const struct ldb_parse_tree *t)
 {
 	int                     i;
 	char *                  child;
         char *                  p;
 	char *                  ret = NULL;
         char *                  pAttrName;
-	
-
+        
+        
 	switch(t->operation) {
-		case LDB_OP_SIMPLE:
-			break;
-
-		case LDB_OP_EXTENDED:
-#warning  "derrell, you'll need to work out how to handle bitops"
-			return NULL;
-
-		case LDB_OP_AND:
-			ret = parsetree_to_sql(module,
-                                               hTalloc,
-                                               t->u.list.elements[0]);
-
-			for (i = 1; i < t->u.list.num_elements; i++) {
-				child =
-                                        parsetree_to_sql(
-                                                module,
-                                                hTalloc,
-                                                t->u.list.elements[i]);
-				ret = talloc_asprintf_append(ret,
-                                                             "INTERSECT\n"
-                                                             "%s\n",
-                                                             child);
-				talloc_free(child);
-			}
-
-                        child = ret;
-                        ret = talloc_asprintf("(\n"
-                                              "%s\n"
-                                              ")\n",
-                                              child);
-                        talloc_free(child);
-			return ret;
-
-		case LDB_OP_OR:
-			child =
+        case LDB_OP_SIMPLE:
+                break;
+                
+        case LDB_OP_EXTENDED:
+#warning  "work out how to handle bitops"
+                return NULL;
+
+        case LDB_OP_AND:
+                ret = parsetree_to_sql(module,
+                                       hTalloc,
+                                       t->u.list.elements[0]);
+                
+                for (i = 1; i < t->u.list.num_elements; i++) {
+                        child =
                                 parsetree_to_sql(
                                         module,
                                         hTalloc,
-                                        t->u.list.elements[0]);
-
-			for (i = 1; i < t->u.list.num_elements; i++) {
-				child =
-                                        parsetree_to_sql(
-                                                module,
-                                                hTalloc,
-                                                t->u.list.elements[i]);
-				ret = talloc_asprintf_append(ret,
-                                                             "UNION\n"
-                                                             "%s\n",
-                                                             child);
-				talloc_free(child);
-			}
-                        child = ret;
-                        ret = talloc_asprintf("(\n"
-                                              "%s\n"
-                                              ")\n",
-                                              child);
+                                        t->u.list.elements[i]);
+                        ret = talloc_asprintf_append(ret,
+                                                     "INTERSECT\n"
+                                                     "%s\n",
+                                                     child);
                         talloc_free(child);
-			return ret;
-
-		case LDB_OP_NOT:
-			child =
+                }
+                
+                child = ret;
+                ret = talloc_asprintf("(\n"
+                                      "%s\n"
+                                      ")\n",
+                                      child);
+                talloc_free(child);
+                return ret;
+                
+        case LDB_OP_OR:
+                child =
+                        parsetree_to_sql(
+                                module,
+                                hTalloc,
+                                t->u.list.elements[0]);
+                
+                for (i = 1; i < t->u.list.num_elements; i++) {
+                        child =
                                 parsetree_to_sql(
                                         module,
                                         hTalloc,
-                                        t->u.not.child);
-			ret = talloc_asprintf(hTalloc,
-                                              "(\n"
-                                              "  SELECT eid\n"
-                                              "    FROM ldb_entry\n"
-                                              "    WHERE eid NOT IN %s\n"
-                                              ")\n",
-                                              child);
-			talloc_free(child);
-			return ret;
-
-		default:
-                        /* should never occur */
-			abort();
+                                        t->u.list.elements[i]);
+                        ret = talloc_asprintf_append(ret,
+                                                     "UNION\n"
+                                                     "%s\n",
+                                                     child);
+                        talloc_free(child);
+                }
+                child = ret;
+                ret = talloc_asprintf("(\n"
+                                      "%s\n"
+                                      ")\n",
+                                      child);
+                talloc_free(child);
+                return ret;
+                
+        case LDB_OP_NOT:
+                child =
+                        parsetree_to_sql(
+                                module,
+                                hTalloc,
+                                t->u.not.child);
+                ret = talloc_asprintf(hTalloc,
+                                      "(\n"
+                                      "  SELECT eid\n"
+                                      "    FROM ldb_entry\n"
+                                      "    WHERE eid NOT IN %s\n"
+                                      ")\n",
+                                      child);
+                talloc_free(child);
+                return ret;
+                
+        default:
+                /* should never occur */
+                abort();
 	};
-	
+        
         /* Get a case-folded copy of the attribute name */
         pAttrName = ldb_casefold((struct ldb_context *) module,
                                  t->u.simple.attr);
-
+        
         /*
          * For simple searches, we want to retrieve the list of EIDs that
          * match the criteria.  We accomplish this by searching the
@@ -1219,10 +1431,10 @@ parsetree_to_sql(struct ldb_module *module,
                                          pAttrName)) == NULL) {
                         return NULL;
                 }
-
+                
                 ret = talloc_strdup(hTalloc, p);
                 sqlite3_free(p);
-
+                
 	} else if (strcasecmp(t->u.simple.attr, "objectclass") == 0) {
 		/*
                  * For object classes, we want to search for all objectclasses
@@ -1243,10 +1455,10 @@ parsetree_to_sql(struct ldb_module *module,
                              t->u.simple.value.data)) == NULL) {
                         return NULL;
                 }
-
+                
                 ret = talloc_strdup(hTalloc, p);
                 sqlite3_free(p);
-
+                
 	} else {
                 /* A normal query. */
                 if ((p = sqlite3_mprintf("(\n"
@@ -1258,7 +1470,7 @@ parsetree_to_sql(struct ldb_module *module,
                                          t->u.simple.value.data)) == NULL) {
                         return NULL;
                 }
-
+                
                 ret = talloc_strdup(hTalloc, p);
                 sqlite3_free(p);
 	}
@@ -1266,13 +1478,177 @@ parsetree_to_sql(struct ldb_module *module,
 }
 
 
+static int
+parsetree_to_attrlist(struct lsqlite3_private * lsqlite3,
+                      const struct ldb_parse_tree * t)
+{
+	int                         i;
+        
+	switch(t->operation) {
+        case LDB_OP_SIMPLE:
+                break;
+                
+        case LDB_OP_EXTENDED:
+#warning  "work out how to handle bitops"
+                return -1;
+
+        case LDB_OP_AND:
+                if (parsetree_to_attrlist(
+                            lsqlite3,
+                            t->u.list.elements[0]) != 0) {
+                        return -1;
+                }
+                
+                for (i = 1; i < t->u.list.num_elements; i++) {
+                        if (parsetree_to_attrlist(
+                                    lsqlite3,
+                                    t->u.list.elements[i]) != 0) {
+                                return -1;
+                        }
+                }
+                
+                return 0;
+                
+        case LDB_OP_OR:
+                if (parsetree_to_attrlist(
+                            lsqlite3,
+                            t->u.list.elements[0]) != 0) {
+                        return -1;
+                }
+                
+                for (i = 1; i < t->u.list.num_elements; i++) {
+                        if (parsetree_to_attrlist(
+                                    lsqlite3,
+                                    t->u.list.elements[i]) != 0) {
+                                return -1;
+                        }
+                }
+                
+                return 0;
+                
+        case LDB_OP_NOT:
+                if (parsetree_to_attrlist(lsqlite3,
+                                          t->u.not.child) != 0) {
+                        return -1;
+                }
+                
+                return 0;
+                
+        default:
+                /* should never occur */
+                abort();
+	};
+        
+        QUERY_NOROWS(lsqlite3,
+                     FALSE,
+                     "INSERT OR IGNORE INTO " FILTER_ATTR_TABLE " "
+                     "    (attr_name) "
+                     "  VALUES "
+                     "    (%Q);",
+                     t->u.simple.attr);
+	return 0;
+}
+
+
+/*
+ * Use the already-generated FILTER_ATTR_TABLE to create a list of attribute
+ * table names that will be used in search queries.
+ */
 static char *
-parsetree_to_tablelist(struct ldb_module *module,
-                                char * hTalloc,
-                                const struct ldb_parse_tree *t)
+build_attr_table_list(void * hTalloc,
+                      struct lsqlite3_private * lsqlite3)
 {
-#warning "obtain talloc'ed array of attribute names for table list"
-        return NULL;
+        int             ret;
+        int             bLoop;
+        char *          p;
+        char *          pTableList;
+        sqlite3_stmt *  pStmt;
+        
+        /*
+         * Prepare and execute the SQL statement.  Loop allows retrying on
+         * certain errors, e.g. SQLITE_SCHEMA occurs if the schema changes,
+         * requiring retrying the operation.
+         */
+        for (bLoop = TRUE; bLoop; ) {
+                /* Initialize a string to which we'll append each table name */
+                if ((pTableList = talloc_strdup(hTalloc, "")) == NULL) {
+                        return NULL;
+                }
+                
+                /* Compile the SQL statement into sqlite virtual machine */
+                if ((ret = sqlite3_prepare(lsqlite3->sqlite,
+                                           "SELECT attr_name "
+                                           "  FROM " FILTER_ATTR_TABLE ";",
+                                           -1,
+                                           &pStmt,
+                                           NULL)) == SQLITE_SCHEMA) {
+                        continue;
+                } else if (ret != SQLITE_OK) {
+                        ret = -1;
+                        break;
+                }
+                
+                /* Loop through the returned rows */
+                for (ret = SQLITE_ROW; ret == SQLITE_ROW; ) {
+                        
+                        /* Get the next row */
+                        if ((ret = sqlite3_step(pStmt)) == SQLITE_ROW) {
+                                
+                                /*
+                                 * Get value from this row and append to table
+                                 * list
+                                 */
+                                p = discard_const_p(char,
+                                                    sqlite3_column_text(pStmt,
+                                                                        0));
+                                
+                                /* Append it to the table list */
+                                if ((p = talloc_asprintf(
+                                             hTalloc,
+                                             "%s%s",
+                                             *pTableList == '\0' ? "" : ",",
+                                             sqlite3_column_text(pStmt,
+                                                                 0))) == NULL) {
+                                        
+                                        talloc_free(pTableList);
+                                        return NULL;
+                                }
+                                
+                                /* We have a new table list */
+                                talloc_free(pTableList);
+                                pTableList = p;
+                        }
+                }
+                
+                if (ret == SQLITE_SCHEMA) {
+                        talloc_free(pTableList);
+                        continue;
+                }
+                
+                /* Free the virtual machine */
+                if ((ret = sqlite3_finalize(pStmt)) == SQLITE_SCHEMA) {
+                        (void) sqlite3_finalize(pStmt);
+                        continue;
+                } else if (ret != SQLITE_OK) {
+                        (void) sqlite3_finalize(pStmt);
+                        ret = -1;
+                        break;
+                }
+                
+                /*
+                 * Normal condition is only one time through loop.  Loop is
+                 * rerun in error conditions, via "continue", above.
+                 */
+                ret = 0;
+                bLoop = FALSE;
+        }
+
+        if (ret != 0) {
+                talloc_free(pTableList);
+                pTableList = NULL;
+        }
+
+        return pTableList;
 }
 
 
@@ -1291,30 +1667,30 @@ msg_to_sql(struct ldb_module * module,
 	unsigned int                i;
         unsigned int                j;
 	struct lsqlite3_private *   lsqlite3 = module->private_data;
-
+        
 	for (i = 0; i < msg->num_elements; i++) {
 		const struct ldb_message_element *el = &msg->elements[i];
-
+                
                 if (! use_flags) {
                         flags = LDB_FLAG_MOD_ADD;
                 } else {
                         flags = el->flags & LDB_FLAG_MOD_MASK;
                 }
-
+                
                 /* Get a case-folded copy of the attribute name */
                 pAttrName = ldb_casefold((struct ldb_context *) module,
                                          el->name);
-
+                
                 if (flags == LDB_FLAG_MOD_ADD) {
                         /* Create the attribute table if it doesn't exist */
                         if (new_attr(module, pAttrName) != 0) {
                                 return -1;
                         }
                 }
-
+                
                 /* For each value of the specified attribute name... */
 		for (j = 0; j < el->num_values; j++) {
-
+                        
                         /* ... bind the attribute value, if necessary */
                         switch (flags) {
                         case LDB_FLAG_MOD_ADD:
@@ -1335,9 +1711,9 @@ msg_to_sql(struct ldb_module * module,
                                              "  WHERE eid = %lld;",
                                              el->name, el->values[j].data,
                                              eid);
-                                      
+                                
                                 break;
-
+                                
                         case LDB_FLAG_MOD_REPLACE:
                                 QUERY_NOROWS(lsqlite3,
                                              FALSE,
@@ -1357,7 +1733,7 @@ msg_to_sql(struct ldb_module * module,
                                              el->name, el->values[j].data,
                                              eid);
                                 break;
-
+                                
                         case LDB_FLAG_MOD_DELETE:
                                 /* No additional parameters to this query */
                                 QUERY_NOROWS(lsqlite3,
@@ -1381,7 +1757,7 @@ msg_to_sql(struct ldb_module * module,
                         }
 		}
 	}
-
+        
 	return 0;
 }
 
@@ -1401,7 +1777,7 @@ new_dn(struct ldb_module * module,
         struct ldb_dn_component *   pComponent;
 	struct ldb_context *        ldb = module->ldb;
 	struct lsqlite3_private *   lsqlite3 = module->private_data;
-
+        
         /* Explode and normalize the DN */
         if ((pExplodedDN =
              ldb_explode_dn(ldb,
@@ -1410,12 +1786,12 @@ new_dn(struct ldb_module * module,
                             case_fold_attr_required)) == NULL) {
                 return -1;
         }
-
+        
         /* Allocate a string to hold the partial DN of each component */
         if ((pPartialDN = talloc_strdup(ldb, "")) == NULL) {
                 return -1;
         }
-
+        
         /* For each component of the DN (starting with the last one)... */
         eid = 0;
         for (nComponent = pExplodedDN->comp_num - 1, bFirst = TRUE;
@@ -1424,7 +1800,7 @@ new_dn(struct ldb_module * module,
                 
                 /* Point to the component */
                 pComponent = pExplodedDN->components[nComponent];
-
+                
                 /* Add this component on to the partial DN to date */
                 if ((p = talloc_asprintf(ldb,
                                          "%s%s%s",
@@ -1433,13 +1809,13 @@ new_dn(struct ldb_module * module,
                                          pPartialDN)) == NULL) {
                         return -1;
                 }
-
+                
                 /* No need for the old partial DN any more */
                 talloc_free(pPartialDN);
-
+                
                 /* Save the new partial DN */
                 pPartialDN = p;
-
+                
                 /*
                  * Ensure that an entry is in the ldb_entry table for this
                  * component.  Any component other than the last one
@@ -1467,30 +1843,30 @@ new_dn(struct ldb_module * module,
                                      nComponent == 0 ? "" : "OR IGNORE",
                                      eid, pPartialDN);
                 }
-
+                
                 /* Get the EID of the just inserted row (the next parent) */
                 eid = sqlite3_last_insert_rowid(lsqlite3->sqlite);
         }
-
+        
         /* Give 'em what they came for! */
         *pEID = eid;
-
+        
         return 0;
 }
 
 
 static int
 new_attr(struct ldb_module * module,
-                  char * pAttrName)
+         char * pAttrName)
 {
         long long                   bExists;
 	struct lsqlite3_private *   lsqlite3 = module->private_data;
-
+        
         /*
          * NOTE:
          *   pAttrName is assumed to already be case-folded here!
          */
-
+        
         /* See if the table already exists */
         QUERY_INT(lsqlite3,
                   bExists,
@@ -1500,7 +1876,7 @@ new_attr(struct ldb_module * module,
                   "  WHERE type = 'table' "
                   "    AND tbl_name = %Q;",
                   pAttrName);
-
+        
         /* Did it exist? */
         if (! bExists) {
                 /* Nope.  Create the table */
@@ -1513,7 +1889,7 @@ new_attr(struct ldb_module * module,
                              ");",
                              pAttrName);
         }
-
+        
         return 0;
 }