Merge lp:~thisfred/u1db/and-the-wild-rocky-mountains-to-roam into lp:u1db

[Eric Casteleijn]

Made range queries work with wildcards in exactly the same way that regular queries do.

Made range queries work with wildcards in exactly the same way that regular queries do.

[lp:~thisfred/u1db/and-the-wild-rocky-mountains-to-roam]

327. By Eric Casteleijn on 2012-06-06

more out of memory checks. clearer variable names.

328. By Eric Casteleijn on 2012-06-11

added constants for glob cases

329. By Eric Casteleijn on 2012-06-12

merged trunk, resolved conflicts

330. By Eric Casteleijn on 2012-06-12

more conflicts resolved

Unmerged revisions

=== modified file 'include/u1db/u1db.h'
--- include/u1db/u1db.h	2012-05-29 14:32:27 +0000
+++ include/u1db/u1db.h	2012-06-06 17:13:17 +0000
@@ -127,7 +127,6 @@
  */
 int u1db_put_doc(u1database *db, u1db_document *doc);
 
-
 /**
  * Mark conflicts as having been resolved.
  * @param doc (IN/OUT) The new content. doc->doc_rev will be updated with the
@@ -255,10 +254,22 @@
  *
  * @param index_name    An identifier for this index.
  * @param n_expressions The number of index expressions.
+ * @param exp0... The values to match in the index, all of these should be char*
+ */
+int u1db_create_index(u1database *db, const char *index_name, int n_expressions,
+                      ...);
+
+
+/**
+ * Create an index that you can query for matching documents.
+ *
+ * @param index_name    An identifier for this index.
+ * @param n_expressions The number of index expressions.
  * @param expressions   An array of expressions.
  */
-int u1db_create_index(u1database *db, const char *index_name,
-                      int n_expressions, const char **expressions);
+int u1db_create_indexl(u1database *db, const char *index_name,
+                       int n_expressions, const char **expressions);
+
 
 /**
  * Delete a defined index.
@@ -292,6 +303,7 @@
  */
 int u1db_query_init(u1database *db, const char *index_name, u1query **query);
 
+
 /**
  * Free the memory pointed to by query and all associated buffers.
  *
@@ -299,6 +311,20 @@
  */
 void u1db_free_query(u1query **query);
 
+
+/**
+ * Get documents which match a given index.
+ *
+ * @param query A u1query object, as created by u1db_query_init.
+ * @param context Will be returned via the document callback
+ * @param n_values The number of parameters being passed, must be >= 1
+ * @param values The values to match in the index.
+ */
+int u1db_get_from_indexl(u1database *db, u1query *query, void *context,
+                         u1db_doc_callback cb, int n_values,
+                         const char **values);
+
+
 /**
  * Get documents which match a given index.
  *
@@ -307,10 +333,24 @@
  * @param n_values The number of parameters being passed, must be >= 1
  * @param val0... The values to match in the index, all of these should be char*
  */
-int u1db_get_from_index(u1database *db, u1query *query,
-                        void *context, u1db_doc_callback cb,
-                        int n_values, ...);
-
+int u1db_get_from_index(u1database *db, u1query *query, void *context,
+                        u1db_doc_callback cb, int n_values, ...);
+
+
+
+/**
+ * Get documents with key values in the specified range
+ *
+ * @param query A u1query object, as created by u1db_query_init.
+ * @param context Will be returned via the document callback
+ * @param n_values The number of values.
+ * @param start_values An array of values. If NULL, assume an open ended query.
+ * @param end_values An array of values. If NULL, assume an open ended query.
+ */
+int u1db_get_range_from_index(u1database *db, u1query *query,
+                              void *context, u1db_doc_callback cb,
+                              int n_values, const char **start_values,
+                              const char **end_values);
 /**
  * Get keys under which documents are indexed.
  *
@@ -319,6 +359,8 @@
  */
 int u1db_get_index_keys(u1database *db, char *index_name, void *context,
                         u1db_key_callback cb);
+
+
 /**
  * Get documents matching a single column index.
  */

=== modified file 'include/u1db/u1db_internal.h'
--- include/u1db/u1db_internal.h	2012-05-18 10:52:37 +0000
+++ include/u1db/u1db_internal.h	2012-06-06 17:13:17 +0000
@@ -331,19 +331,37 @@
 /**
  * Format a given query.
  *
- * @param n_fields  The number of fields being passed in, (the number of args
- * 		    in argp)
- * @param argp	    Arguments being passed. It is assumed that all arguments
- * 		    will be of type "char*".
+ * @param n_fields The number of fields being passed in. (The number of values
+ *     in values)
+ * @param values Array of values being passed.
  * @param buf (OUT) The character array. This will be dynamically allocated,
- * 		    and callers must free() it.
+ *     and callers must free() it.
  * @param wildcard (IN/OUT) Any array indicating a wildcard type for this
- * 			 argument. A 0 indicates this is an exact match, a 1
- * 			 indicates this is a pure wildcard (eg, "*") and a 2
- * 			 indicates this is a glob (eg "f*").
- * 			 This must point to an array at least n_fields wide.
- */
-int u1db__format_query(int n_fields, va_list argp, char **buf, int *wildcard);
+ *     argument. A 0 indicates this is an exact match, a 1
+ *     indicates this is a pure wildcard (eg, "*") and a 2
+ *     indicates this is a glob (eg "f*").
+ *     This must point to an array at least n_fields wide.
+ */
+int u1db__format_query(int n_fields, const char **values, char **buf,
+                       int *wildcard);
+
+
+/**
+ * Format a given range query.
+ *
+ * @param n_fields The number of fields being passed in. (The number of values
+ *     in start_values and end_values)
+ * @param start_values Array of values used to define the lower bound of the
+ *     query.
+ * @param end_values Array of values used to define the upper bound of the
+ *     query.
+ * @param buf (OUT) The character array. This will be dynamically allocated,
+ *     and callers must free() it.
+ */
+int u1db__format_range_query(int n_fields, const char **start_values,
+                             const char **end_values, char **buf,
+                             int *start_wildcard, int *end_wildcard);
+
 
 /**
  * Given this document content, update the indexed fields in the db.

=== modified file 'src/u1db.c'
--- src/u1db.c	2012-05-29 15:49:21 +0000
+++ src/u1db.c	2012-06-06 17:13:17 +0000
@@ -1694,12 +1694,13 @@
     return U1DB_OK;
 }
 
+
 int
-u1db_create_index(u1database *db, const char *index_name, int n_expressions,
-                  const char **expressions)
+u1db_create_indexl(u1database *db, const char *index_name, int n_expressions,
+                   const char **expressions)
 {
     int status = U1DB_OK, i = 0;
-    sqlite3_stmt *statement;
+    sqlite3_stmt *statement = NULL;
     const char **unique_expressions;
     int n_unique;
 
@@ -1717,14 +1718,20 @@
     }
     status = u1db__find_unique_expressions(db, n_expressions, expressions,
             &n_unique, &unique_expressions);
-    if (status != U1DB_OK) { goto finish; }
+    if (status != U1DB_OK) {
+        goto finish;
+    }
     status = sqlite3_prepare_v2(db->sql_handle,
         "SELECT field FROM index_definitions"
         " WHERE name = ? ORDER BY offset DESC",
         -1, &statement, NULL);
-    if (status != SQLITE_OK) { goto finish; }
+    if (status != SQLITE_OK) {
+        goto finish;
+    }
     status = sqlite3_bind_text(statement, 1, index_name, -1, SQLITE_TRANSIENT);
-    if (status != SQLITE_OK) { goto finish; }
+    if (status != SQLITE_OK) {
+        goto finish;
+    }
     status = sqlite3_step(statement);
     i=0;
     while (status == SQLITE_ROW) {
@@ -1736,7 +1743,9 @@
         status = sqlite3_step(statement);
         i++;
     }
-    if (status != SQLITE_DONE) { goto finish; }
+    if (status != SQLITE_DONE) {
+        goto finish;
+    }
     if (i>0) {
         status = SQLITE_OK;
         goto finish;
@@ -1749,13 +1758,19 @@
         goto finish;
     }
     status = sqlite3_bind_text(statement, 1, index_name, -1, SQLITE_TRANSIENT);
-    if (status != SQLITE_OK) { goto finish; }
+    if (status != SQLITE_OK) {
+        goto finish;
+    }
     for (i = 0; i < n_expressions; ++i) {
         status = sqlite3_bind_int(statement, 2, i);
-        if (status != SQLITE_OK) { goto finish; }
+        if (status != SQLITE_OK) {
+            goto finish;
+        }
         status = sqlite3_bind_text(statement, 3, expressions[i], -1,
                                    SQLITE_TRANSIENT);
-        if (status != SQLITE_OK) { goto finish; }
+        if (status != SQLITE_OK) {
+            goto finish;
+        }
         status = sqlite3_step(statement);
         if (status != SQLITE_DONE) {
             if (status == SQLITE_CONSTRAINT) {
@@ -1765,7 +1780,9 @@
             goto finish;
         }
         status = sqlite3_reset(statement);
-        if (status != SQLITE_OK) { goto finish; }
+        if (status != SQLITE_OK) {
+            goto finish;
+        }
     }
     status = u1db__index_all_docs(db, n_unique, unique_expressions);
 finish:
@@ -1783,6 +1800,33 @@
 
 
 int
+u1db_create_index(u1database *db, const char *index_name, int n_expressions,
+                  ...)
+{
+    int i, status = U1DB_OK;
+    va_list argp;
+    const char **expressions = NULL;
+
+    expressions = (const char **)calloc(n_expressions, sizeof(char*));
+    if (expressions == NULL) {
+        status = U1DB_NOMEM;
+        goto finish;
+    }
+    va_start(argp, n_expressions);
+    for (i = 0; i < n_expressions; ++i) {
+        expressions[i] = va_arg(argp, char *);
+    }
+    status = u1db_create_indexl(db, index_name, n_expressions, expressions);
+finish:
+    if (expressions != NULL)
+        free(expressions);
+    va_end(argp);
+    return status;
+}
+
+
+
+int
 u1db_delete_index(u1database *db, const char *index_name)
 {
     int status = U1DB_OK;

=== modified file 'src/u1db_query.c'
--- src/u1db_query.c	2012-05-30 19:42:52 +0000
+++ src/u1db_query.c	2012-06-06 17:13:17 +0000
@@ -535,17 +535,14 @@
 
 
 int
-u1db_get_from_index(u1database *db, u1query *query,
-                    void *context, u1db_doc_callback cb,
-                    int n_values, ...)
+u1db_get_from_indexl(u1database *db, u1query *query, void *context,
+                     u1db_doc_callback cb, int n_values, const char **values)
 {
     int status = U1DB_OK;
     sqlite3_stmt *statement = NULL;
     char *doc_id = NULL;
     char *query_str = NULL;
     int i, bind_arg;
-    va_list argp;
-    const char *valN = NULL;
     int wildcard[20] = {0};
 
     if (db == NULL || query == NULL || cb == NULL || n_values < 0)
@@ -558,29 +555,26 @@
     if (n_values > 20) {
         return U1DB_NOT_IMPLEMENTED;
     }
-    va_start(argp, n_values);
-    status = u1db__format_query(query->num_fields, argp, &query_str, wildcard);
-    va_end(argp);
+    status = u1db__format_query(
+        query->num_fields, values, &query_str, wildcard);
     if (status != U1DB_OK) { goto finish; }
     status = sqlite3_prepare_v2(db->sql_handle, query_str, -1,
                                 &statement, NULL);
     if (status != SQLITE_OK) { goto finish; }
     // Bind all of the 'field_name' parameters. sqlite_bind starts at 1
     bind_arg = 1;
-    va_start(argp, n_values);
     for (i = 0; i < query->num_fields; ++i) {
         status = sqlite3_bind_text(statement, bind_arg, query->fields[i], -1,
                                    SQLITE_TRANSIENT);
         bind_arg++;
         if (status != SQLITE_OK) { goto finish; }
-        valN = va_arg(argp, char *);
         if (wildcard[i] == 0) {
             // Not a wildcard, so add the argument
-            status = sqlite3_bind_text(statement, bind_arg, valN, -1,
+            status = sqlite3_bind_text(statement, bind_arg, values[i], -1,
                                        SQLITE_TRANSIENT);
             bind_arg++;
         } else if (wildcard[i] == 2) {
-            status = sqlite3_bind_text(statement, bind_arg, valN, -1,
+            status = sqlite3_bind_text(statement, bind_arg, values[i], -1,
                                        SQLITE_TRANSIENT);
             bind_arg++;
         }
@@ -600,11 +594,134 @@
         status = U1DB_OK;
     }
 finish:
+    sqlite3_finalize(statement);
+    if (query_str != NULL) {
+        free(query_str);
+    }
+    return status;
+}
+
+
+int
+u1db_get_from_index(u1database *db, u1query *query, void *context,
+                    u1db_doc_callback cb, int n_values, ...)
+{
+    int i, status = U1DB_OK;
+    va_list argp;
+    const char **values = NULL;
+
+    values = (const char **)calloc(n_values, sizeof(char*));
+    if (values == NULL) {
+        status = U1DB_NOMEM;
+        goto finish;
+    }
+    va_start(argp, n_values);
+    for (i = 0; i < n_values; ++i) {
+        values[i] = va_arg(argp, char *);
+    }
+    status = u1db_get_from_indexl(db, query, context, cb, n_values, values);
+finish:
+    if (values != NULL)
+        free(values);
     va_end(argp);
+    return status;
+}
+
+
+int
+u1db_get_range_from_index(u1database *db, u1query *query,
+                          void *context, u1db_doc_callback cb,
+                          int n_values, const char **start_values,
+                          const char **end_values)
+{
+    int i, bind_arg, status = U1DB_OK;
+    char *query_str = NULL;
+    sqlite3_stmt *statement = NULL;
+    char *doc_id = NULL;
+    char *value_copy = NULL;
+    int start_wildcard[20] = {0};
+    int end_wildcard[20] = {0};
+
+    if (db == NULL || query == NULL || cb == NULL || n_values < 0) {
+        return U1DB_INVALID_PARAMETER;
+    }
+    if (n_values != query->num_fields) {
+        return U1DB_INVALID_VALUE_FOR_INDEX;
+    }
+    status = u1db__format_range_query(
+        query->num_fields, start_values, end_values, &query_str,
+        start_wildcard, end_wildcard);
+
+    if (status != U1DB_OK) { goto finish; }
+    status = sqlite3_prepare_v2(db->sql_handle, query_str, -1,
+                                &statement, NULL);
+    if (status != SQLITE_OK) { goto finish; }
+    // Bind all of the 'field_name' parameters. sqlite_bind starts at 1
+    bind_arg = 1;
+
+    for (i = 0; i < query->num_fields; ++i) {
+        status = sqlite3_bind_text(
+            statement, bind_arg, query->fields[i], -1, SQLITE_TRANSIENT);
+        if (status != SQLITE_OK) { goto finish; }
+        bind_arg++;
+        if (start_values != NULL) {
+            if (start_wildcard[i] == 0) {
+                status = sqlite3_bind_text(
+                    statement, bind_arg, start_values[i], -1,
+                    SQLITE_TRANSIENT);
+                bind_arg++;
+            } else if (start_wildcard[i] == 2) {
+                if (value_copy != NULL)
+                    free(value_copy);
+                value_copy = strdup(start_values[i]);
+                value_copy[strlen(value_copy) - 1] = '\0';
+                status = sqlite3_bind_text(
+                    statement, bind_arg, value_copy, -1, SQLITE_TRANSIENT);
+                bind_arg++;
+            }
+            if (status != SQLITE_OK) { goto finish; }
+        }
+        if (end_values != NULL) {
+            if (end_wildcard[i] == 0) {
+                status = sqlite3_bind_text(
+                    statement, bind_arg, end_values[i], -1,
+                    SQLITE_TRANSIENT);
+                bind_arg++;
+            } else if (end_wildcard[i] == 2) {
+                if (value_copy != NULL)
+                    free(value_copy);
+                value_copy = strdup(end_values[i]);
+                value_copy[strlen(value_copy) - 1] = '\0';
+                status = sqlite3_bind_text(
+                    statement, bind_arg, value_copy, -1, SQLITE_TRANSIENT);
+                bind_arg++;
+                status = sqlite3_bind_text(
+                    statement, bind_arg, end_values[i], -1, SQLITE_TRANSIENT);
+                bind_arg++;
+            }
+            if (status != SQLITE_OK) { goto finish; }
+        }
+    }
+    status = sqlite3_step(statement);
+    while (status == SQLITE_ROW) {
+        doc_id = (char*)sqlite3_column_text(statement, 0);
+        // We use u1db_get_docs so we can pass check_for_conflicts=0, which is
+        // currently expected by the test suite.
+        status = u1db_get_docs(
+            db, 1, (const char**)&doc_id, 0, 0, context, cb);
+        if (status != U1DB_OK) { goto finish; }
+        status = sqlite3_step(statement);
+    }
+    if (status == SQLITE_DONE) {
+        status = U1DB_OK;
+    }
+finish:
     sqlite3_finalize(statement);
     if (query_str != NULL) {
         free(query_str);
     }
+    if (value_copy != NULL)
+        free(value_copy);
     return status;
 }
 
@@ -681,7 +798,8 @@
 
 
 int
-u1db__format_query(int n_fields, va_list argp, char **buf, int *wildcard)
+u1db__format_query(int n_fields, const char **values, char **buf,
+                   int *wildcard)
 {
     int status = U1DB_OK;
     int buf_size, i;
@@ -712,7 +830,7 @@
                 " AND d%d.field_name = ?",
                 i, i);
         }
-        val = va_arg(argp, char *);
+        val = values[i];
         if (val == NULL) {
             status = U1DB_INVALID_VALUE_FOR_INDEX;
             goto finish;
@@ -756,6 +874,120 @@
     return status;
 }
 
+int
+u1db__format_range_query(int n_fields, const char **start_values,
+                         const char **end_values, char **buf,
+                         int *start_wildcard, int *end_wildcard)
+{
+    int status = U1DB_OK;
+    int buf_size, i;
+    char *cur = NULL;
+    const char *val = NULL;
+    int have_start_wildcard = 0;
+    int have_end_wildcard = 0;
+
+    if (n_fields < 1) {
+        return U1DB_INVALID_PARAMETER;
+    }
+    // 81 for 1 doc, 166 for 2, 251 for 3
+    buf_size = (1 + n_fields) * 100;
+    // The first field is treated specially
+    cur = (char*)calloc(buf_size, 1);
+    if (cur == NULL) {
+        return U1DB_NOMEM;
+    }
+    *buf = cur;
+    add_to_buf(&cur, &buf_size, "SELECT d0.doc_id FROM document_fields d0");
+    for (i = 1; i < n_fields; ++i) {
+        add_to_buf(&cur, &buf_size, ", document_fields d%d", i);
+    }
+    add_to_buf(&cur, &buf_size, " WHERE d0.field_name = ?");
+    for (i = 0; i < n_fields; ++i) {
+        if (i != 0) {
+            add_to_buf(&cur, &buf_size,
+                " AND d0.doc_id = d%d.doc_id"
+                " AND d%d.field_name = ?",
+                i, i);
+        }
+        if (start_values != NULL) {
+            val = start_values[i];
+            if (val == NULL) {
+                status = U1DB_INVALID_VALUE_FOR_INDEX;
+                goto finish;
+            }
+            if (val[0] == '*') {
+                start_wildcard[i] = 1;
+                have_start_wildcard= 1;
+                add_to_buf(&cur, &buf_size, " and d%d.value not null", i);
+            } else if (val[0] != '\0' && val[strlen(val)-1] == '*') {
+                // glob
+                start_wildcard[i] = 2;
+                if (have_start_wildcard) {
+                    //globs not allowed after another wildcard
+                    status = U1DB_INVALID_GLOBBING;
+                    goto finish;
+                }
+                have_start_wildcard = 1;
+                add_to_buf(&cur, &buf_size, " and d%d.value >= ?", i);
+            } else {
+                start_wildcard[i] = 0;
+                if (have_start_wildcard) {
+                    // can't have a non-wildcard after a wildcard
+                    status = U1DB_INVALID_GLOBBING;
+                    goto finish;
+                }
+                add_to_buf(&cur, &buf_size, " and d%d.value >= ?", i);
+            }
+        }
+        if (end_values != NULL) {
+            val = end_values[i];
+            if (val == NULL) {
+                status = U1DB_INVALID_VALUE_FOR_INDEX;
+                goto finish;
+            }
+            if (val[0] == '*') {
+                end_wildcard[i] = 1;
+                have_end_wildcard = 1;
+                add_to_buf(&cur, &buf_size, " AND d%d.value NOT NULL", i);
+            } else if (val[0] != '\0' && val[strlen(val)-1] == '*') {
+                // glob
+                end_wildcard[i] = 2;
+                if (have_end_wildcard) {
+                    //globs not allowed after another wildcard
+                    status = U1DB_INVALID_GLOBBING;
+                    goto finish;
+                }
+                have_end_wildcard = 1;
+                add_to_buf(
+                    &cur, &buf_size,
+                    " AND (d%d.value < ? OR d%d.value GLOB ?)", i, i);
+            } else {
+                end_wildcard[i] = 0;
+                if (have_end_wildcard) {
+                    // Can't have a non-wildcard after a wildcard
+                    status = U1DB_INVALID_GLOBBING;
+                    goto finish;
+                }
+                add_to_buf(&cur, &buf_size, " AND d%d.value <= ?", i);
+            }
+        }
+
+    }
+    add_to_buf(&cur, &buf_size, " ORDER BY ");
+    for (i = 0; i < n_fields; ++i) {
+        if (i != 0) {
+            add_to_buf(&cur, &buf_size, ", ");
+        }
+        add_to_buf(&cur, &buf_size, "d%d.value", i);
+    }
+finish:
+    if (status != U1DB_OK && *buf != NULL) {
+        free(*buf);
+        *buf = NULL;
+    }
+    return status;
+}
+
 struct sqlcb_to_field_cb {
     void *user_context;
     int (*user_cb)(void *, const char*, transformation *tr);
@@ -787,7 +1019,6 @@
         }
     }
     else {
-        // TODO: unicode fieldnames ?
         size = (end - field_copy);
         word = (char *)calloc(size + 1, 1);
         strncpy(word, field_copy, size);
@@ -969,7 +1200,7 @@
 }
 
 static int
-evaluate_index_and_insert_into_db(void *context, const char *expression, 
+evaluate_index_and_insert_into_db(void *context, const char *expression,
                                   transformation *tr)
 {
     struct evaluate_index_context *ctx;

=== modified file 'u1db/__init__.py'
--- u1db/__init__.py	2012-05-31 18:51:20 +0000
+++ u1db/__init__.py	2012-06-06 17:13:17 +0000
@@ -180,22 +180,45 @@
     def get_from_index(self, index_name, *key_values):
         """Return documents that match the keys supplied.
 
-        You must supply exactly the same number of values as has been defined
+        You must supply exactly the same number of values as have been defined
         in the index. It is possible to do a prefix match by using '*' to
         indicate a wildcard match. You can only supply '*' to trailing entries,
-        (eg [('val', '*', '*')] is allowed, but [('*', 'val', 'val')] is not.)
+        (eg 'val', '*', '*' is allowed, but '*', 'val', 'val' is not.)
         It is also possible to append a '*' to the last supplied value (eg
-        [('val*', '*', '*')] or [('val', 'val*', '*')], but not [('val*',
-        'val', '*')])
+        'val*', '*', '*' or 'val', 'val*', '*', but not 'val*', 'val', '*')
 
         :return: List of [Document]
         :param index_name: The index to query
-        :param key_values: tuples of values to match. eg, if you have
+        :param key_values: values to match. eg, if you have
             an index with 3 fields then you would have:
-            (x-val1, x-val2, x-val3), (y-val1, y-val2, y-val3), ...
+            get_from_index(index_name, val1, val2, val3)
         """
         raise NotImplementedError(self.get_from_index)
 
+    def get_range_from_index(self, index_name, start_value, end_value):
+        """Return documents that fall within the specified range.
+
+        Both ends of the range are inclusive. For both start_value and
+        end_value, one must supply exactly the same number of values as have
+        been defined in the index, or pass None. In case of a single column
+        index, a string is accepted as an alternative for a tuple with a single
+        value. It is possible to do a prefix match by using '*' to indicate
+        a wildcard match. You can only supply '*' to trailing entries, (eg
+        'val', '*', '*' is allowed, but '*', 'val', 'val' is not.) It is also
+        possible to append a '*' to the last supplied value (eg 'val*', '*',
+        '*' or 'val', 'val*', '*', but not 'val*', 'val', '*')
+
+        :return: List of [Document]
+        :param index_name: The index to query
+        :param start_values: tuples of values that define the lower bound of
+            the range. eg, if you have an index with 3 fields then you would
+            have: (val1, val2, val3)
+        :param end_values: tuples of values that define the upper bound of the
+            range. eg, if you have an index with 3 fields then you would have:
+            (val1, val2, val3)
+        """
+        raise NotImplementedError(self.get_range_from_index)
+
     def get_index_keys(self, index_name):
         """Return all keys under which documents are indexed in this index.
 

=== modified file 'u1db/backends/inmemory.py'
--- u1db/backends/inmemory.py	2012-05-31 18:51:20 +0000
+++ u1db/backends/inmemory.py	2012-06-06 17:13:17 +0000
@@ -27,6 +27,11 @@
 from u1db.backends import CommonBackend, CommonSyncTarget
 
 
+def get_prefix(value):
+    key_prefix = '\x01'.join(value)
+    return key_prefix.rstrip('*')
+
+
 class InMemoryDatabase(CommonBackend):
     """A database that only stores the data internally."""
 
@@ -222,6 +227,24 @@
             result.append(self._factory(doc_id, doc_rev, doc))
         return result
 
+    def get_range_from_index(self, index_name, start_value=None,
+                             end_value=None):
+        """Return all documents with key values in the specified range."""
+        try:
+            index = self._indexes[index_name]
+        except KeyError:
+            raise errors.IndexDoesNotExist
+        if isinstance(start_value, basestring):
+            start_value = (start_value,)
+        if isinstance(end_value, basestring):
+            end_value = (end_value,)
+        doc_ids = index.lookup_range(start_value, end_value)
+        result = []
+        for doc_id in doc_ids:
+            doc_rev, doc = self._docs[doc_id]
+            result.append(self._factory(doc_id, doc_rev, doc))
+        return result
+
     def get_index_keys(self, index_name):
         try:
             index = self._indexes[index_name]
@@ -345,6 +368,32 @@
         else:
             return self._lookup_prefix(values[:last])
 
+    def lookup_range(self, start_values, end_values):
+        """Find docs within the range."""
+        # TODO: Wildly inefficient, which is unlikely to be a problem for the
+        # inmemory implementation.
+        if start_values:
+            self._find_non_wildcards(start_values)
+            start_values = get_prefix(start_values)
+        if end_values:
+            if self._find_non_wildcards(end_values) == -1:
+                exact = True
+            else:
+                exact = False
+            end_values = get_prefix(end_values)
+        found = []
+        for key, doc_ids in sorted(self._values.iteritems()):
+            if start_values and start_values > key:
+                continue
+            if end_values and end_values < key:
+                if exact:
+                    break
+                else:
+                    if not key.startswith(end_values):
+                        break
+            found.extend(doc_ids)
+        return found
+
     def keys(self):
         """Find the indexed keys."""
         return self._values.keys()
@@ -353,8 +402,7 @@
         """Find docs that match the prefix string in values."""
         # TODO: We need a different data structure to make prefix style fast,
         #       some sort of sorted list would work, but a plain dict doesn't.
-        key_prefix = '\x01'.join(value)
-        key_prefix = key_prefix.rstrip('*')
+        key_prefix = get_prefix(value)
         all_doc_ids = []
         for key, doc_ids in sorted(self._values.iteritems()):
             if key.startswith(key_prefix):

=== modified file 'u1db/backends/sqlite_backend.py'
--- u1db/backends/sqlite_backend.py	2012-05-31 18:51:20 +0000
+++ u1db/backends/sqlite_backend.py	2012-06-06 17:13:17 +0000
@@ -568,14 +568,19 @@
 
     @staticmethod
     def _transform_glob(value, escape_char='.'):
-        """Transform the given glob value into a valid LIKE statement.
-        """
+        """Transform the given glob value into a valid LIKE statement."""
         to_escape = [escape_char, '%', '_']
         for esc in to_escape:
             value = value.replace(esc, escape_char + esc)
         assert value[-1] == '*'
         return value[:-1] + '%'
 
+    @staticmethod
+    def _strip_glob(value):
+        """Remove the trailing * from a value."""
+        assert value[-1] == '*'
+        return value[:-1]
+
     def get_from_index(self, index_name, *key_values):
         definition = self._get_index_definition(index_name)
         # First, build the definition. We join the document_fields table
@@ -638,6 +643,97 @@
         res = c.fetchall()
         return [self._factory(r[0], r[1], r[2]) for r in res]
 
+    def get_range_from_index(self, index_name, start_value=None,
+                             end_value=None):
+        """Return all documents with key values in the specified range."""
+        definition = self._get_index_definition(index_name)
+        tables = ["document_fields d%d" % i for i in range(len(definition))]
+        novalue_where = [
+            "d.doc_id = d%d.doc_id AND d%d.field_name = ?" % (i, i) for i in
+            range(len(definition))]
+        wildcard_where = [
+            novalue_where[i] + (" AND d%d.value NOT NULL" % (i,)) for i in
+            range(len(definition))]
+        like_where = [
+            novalue_where[i] + (
+                " AND (d%d.value < ? OR d%d.value LIKE ? ESCAPE '.')" %
+                (i, i))
+            for i in range(len(definition))]
+        range_where_lower = [
+            novalue_where[i] + (" AND d%d.value >= ?" % (i,)) for i in
+            range(len(definition))]
+        range_where_upper = [
+            novalue_where[i] + (" AND d%d.value <= ?" % (i,)) for i in
+            range(len(definition))]
+        args = []
+        where = []
+        if start_value:
+            if isinstance(start_value, basestring):
+                start_value = (start_value,)
+            if len(start_value) != len(definition):
+                raise errors.InvalidValueForIndex()
+            is_wildcard = False
+            for idx, (field, value) in enumerate(zip(definition, start_value)):
+                args.append(field)
+                if value.endswith('*'):
+                    if value == '*':
+                        where.append(wildcard_where[idx])
+                    else:
+                        # This is a glob match
+                        if is_wildcard:
+                            # We can't have a partial wildcard following
+                            # another wildcard
+                            raise errors.InvalidGlobbing
+                        where.append(range_where_lower[idx])
+                        args.append(self._strip_glob(value))
+                    is_wildcard = True
+                else:
+                    if is_wildcard:
+                        raise errors.InvalidGlobbing
+                    where.append(range_where_lower[idx])
+                    args.append(value)
+        if end_value:
+            if isinstance(end_value, basestring):
+                end_value = (end_value,)
+            if len(end_value) != len(definition):
+                raise errors.InvalidValueForIndex()
+            is_wildcard = False
+            for idx, (field, value) in enumerate(zip(definition, end_value)):
+                args.append(field)
+                if value.endswith('*'):
+                    if value == '*':
+                        where.append(wildcard_where[idx])
+                    else:
+                        # This is a glob match
+                        if is_wildcard:
+                            # We can't have a partial wildcard following
+                            # another wildcard
+                            raise errors.InvalidGlobbing
+                        where.append(like_where[idx])
+                        args.append(self._strip_glob(value))
+                        args.append(self._transform_glob(value))
+                    is_wildcard = True
+                else:
+                    if is_wildcard:
+                        raise errors.InvalidGlobbing
+                    where.append(range_where_upper[idx])
+                    args.append(value)
+        statement = (
+            "SELECT d.doc_id, d.doc_rev, d.content FROM document d, %s "
+            "WHERE %s ORDER BY %s;" % (
+                ', '.join(tables),
+                ' AND '.join(where),
+                ', '.join(
+                    ['d%d.value' % i for i in range(len(definition))])))
+        c = self._db_handle.cursor()
+        try:
+            c.execute(statement, tuple(args))
+        except dbapi2.OperationalError, e:
+            raise dbapi2.OperationalError(str(e) +
+                '\nstatement: %s\nargs: %s\n' % (statement, args))
+        res = c.fetchall()
+        return [self._factory(r[0], r[1], r[2]) for r in res]
+
     def get_index_keys(self, index):
         c = self._db_handle.cursor()
         try:

=== modified file 'u1db/tests/c_backend_wrapper.pyx'
--- u1db/tests/c_backend_wrapper.pyx	2012-05-31 18:51:20 +0000
+++ u1db/tests/c_backend_wrapper.pyx	2012-06-06 17:13:17 +0000
@@ -92,21 +92,28 @@
                                   u1db_trans_info_callback cb)
     int u1db_get_doc_conflicts(u1database *db, char *doc_id, void *context,
                                u1db_doc_callback cb)
-
-    int u1db_create_index(u1database *db, char *index_name,
-                          int n_expressions, const_char_ptr *expressions)
+    int u1db_create_indexl(u1database *db, char *index_name, int n_expressions,
+                           const_char_ptr *expressions)
+    int u1db_create_index(u1database *db, char *index_name, int n_expressions,
+                          ...)
+    int u1db_get_from_indexl(u1database *db, u1query *query, void *context,
+                             u1db_doc_callback cb, int n_values, 
+                             const_char_ptr *values)
+    int u1db_get_from_index(u1database *db, u1query *query, void *context,
+                             u1db_doc_callback cb, int n_values, char *val0,
+                             ...)
+    int u1db_get_range_from_index(u1database *db, u1query *query,
+                                  void *context, u1db_doc_callback cb,
+                                  int n_values, const_char_ptr *start_values,
+                                  const_char_ptr *end_values)
     int u1db_delete_index(u1database *db, char *index_name)
-
     int u1db_list_indexes(u1database *db, void *context,
                   int (*cb)(void *context, const_char_ptr index_name,
                             int n_expressions, const_char_ptr *expressions))
-    int u1db_get_from_index(u1database *db, u1query *query, void *context,
-                            u1db_doc_callback cb, int n_values, char *val0, ...)
     int u1db_get_index_keys(u1database *db, char *index_name, void *context,
                             u1db_key_callback cb)
     int u1db_simple_lookup1(u1database *db, char *index_name, char *val1,
                             void *context, u1db_doc_callback cb)
-
     int u1db_query_init(u1database *db, char *index_name, u1query **query)
     void u1db_free_query(u1query **query)
 
@@ -212,7 +219,8 @@
                             u1db_record **conflict_records)
     int u1db__sync_exchange_seen_ids(u1db_sync_exchange *se, int *n_ids,
                                      const_char_ptr **doc_ids)
-    int u1db__format_query(int n_fields, va_list argp, char **buf, int *wildcard)
+    int u1db__format_query(int n_fields, const_char_ptr *values, char **buf,
+                           int *wildcard)
     int u1db__get_sync_target(u1database *db, u1db_sync_target **sync_target)
     int u1db__free_sync_target(u1db_sync_target **sync_target)
     int u1db__sync_db_to_target(u1database *db, u1db_sync_target *target,
@@ -316,16 +324,6 @@
     return 0
 
 
-cdef int _format_query_dotted(char **buf, int *wildcard, int n_fields, ...):
-    cdef va_list argp
-    cdef int status
-
-    va_start_int(argp, n_fields)
-    status = u1db__format_query(n_fields, argp, buf, wildcard)
-    va_end(argp)
-    return status
-
-
 cdef int return_doc_cb_wrapper(void *context, u1db_document *doc,
         int gen) with gil:
     cdef CDocument pydoc
@@ -374,22 +372,16 @@
     cdef int status
     cdef char *buf
     cdef int wildcard[10]
+    cdef const_char_ptr *values
+    cdef int n_values
 
-    if len(fields) == 0:
-        status = _format_query_dotted(&buf, wildcard, 0)
-    elif len(fields) == 1:
-        status = _format_query_dotted(&buf, wildcard, 1, <char*>fields[0])
-    elif len(fields) == 2:
-        status = _format_query_dotted(&buf, wildcard, 2, <char*>fields[0],
-                <char*>fields[1])
-    elif len(fields) == 3:
-        status = _format_query_dotted(&buf, wildcard, 3, <char*>fields[0],
-                <char*>fields[1], <char*>fields[2])
-    elif len(fields) == 4:
-        status = _format_query_dotted(&buf, wildcard, 4, <char*>fields[0],
-                <char*>fields[1], <char*>fields[2], <char *>fields[3])
-    else:
-        status = U1DB_NOT_IMPLEMENTED
+    # keep a reference to new_objs so that the pointers in expressions
+    # remain valid.
+    new_objs = _list_to_str_array(fields, &values, &n_values)
+    try:
+        status = u1db__format_query(n_values, values, &buf, wildcard)
+    finally:
+        free(<void*>values)
     handle_status("format_query", status)
     if buf == NULL:
         res = None
@@ -1036,7 +1028,7 @@
         if status != U1DB_OK:
             raise RuntimeError("Failed to _sync_exchange: %d" % (status,))
 
-    def create_index(self, index_name, *index_expressions):
+    def create_indexl(self, index_name, index_expressions):
         cdef const_char_ptr *expressions
         cdef int n_expressions
 
@@ -1045,11 +1037,41 @@
         new_objs = _list_to_str_array(
             index_expressions, &expressions, &n_expressions)
         try:
-            handle_status("create_index",
-                u1db_create_index(
-                    self._db, index_name, n_expressions, expressions))
+            status = u1db_create_indexl(
+                self._db, index_name, n_expressions, expressions)
         finally:
             free(<void*>expressions)
+        handle_status("create_index", status)
+
+    def create_index(self, index_name, *index_expressions):
+        extra = []
+        if len(index_expressions) == 0:
+            status = u1db_create_index(self._db, index_name, 0, NULL)
+        elif len(index_expressions) == 1:
+            status = u1db_create_index(
+                self._db, index_name, 1,
+                _ensure_str(index_expressions[0], extra))
+        elif len(index_expressions) == 2:
+            status = u1db_create_index(
+                self._db, index_name, 2,
+                _ensure_str(index_expressions[0], extra),
+                _ensure_str(index_expressions[1], extra))
+        elif len(index_expressions) == 3:
+            status = u1db_create_index(
+                self._db, index_name, 3,
+                _ensure_str(index_expressions[0], extra),
+                _ensure_str(index_expressions[1], extra),
+                _ensure_str(index_expressions[2], extra))
+        elif len(index_expressions) == 4:
+            status = u1db_create_index(
+                self._db, index_name, 4,
+                _ensure_str(index_expressions[0], extra),
+                _ensure_str(index_expressions[1], extra),
+                _ensure_str(index_expressions[2], extra),
+                _ensure_str(index_expressions[3], extra))
+        else:
+            status = U1DB_NOT_IMPLEMENTED
+        handle_status("create_index", status)
 
     def list_indexes(self):
         a_list = []
@@ -1062,9 +1084,29 @@
         handle_status("delete_index",
             u1db_delete_index(self._db, index_name))
 
+    def get_from_indexl(self, index_name, key_values):
+        cdef const_char_ptr *values
+        cdef int n_values
+        cdef CQuery query
+
+        query = self._query_init(index_name)
+        res = []
+        # keep a reference to new_objs so that the pointers in expressions
+        # remain valid.
+        new_objs = _list_to_str_array(key_values, &values, &n_values)
+        try:
+            handle_status(
+                "get_from_index", u1db_get_from_indexl(
+                    self._db, query._query, <void*>res, _append_doc_to_list,
+                    n_values, values))
+        finally:
+            free(<void*>values)
+        return res
+
     def get_from_index(self, index_name, *key_values):
         cdef CQuery query
         cdef int status
+
         extra = []
         query = self._query_init(index_name)
         res = []
@@ -1099,6 +1141,42 @@
         handle_status("get_from_index", status)
         return res
 
+    def get_range_from_index(self, index_name, start_value=None,
+                             end_value=None):
+        cdef CQuery query
+        cdef const_char_ptr *start_values
+        cdef int n_values
+        cdef const_char_ptr *end_values
+
+        if start_value is not None:
+            if isinstance(start_value, basestring):
+                start_value = (start_value,)
+            new_objs_1 = _list_to_str_array(
+                start_value, &start_values, &n_values)
+        else:
+            n_values = 0
+            start_values = NULL
+        if end_value is not None:
+            if isinstance(end_value, basestring):
+                end_value = (end_value,)
+            new_objs_2 = _list_to_str_array(
+                end_value, &end_values, &n_values)
+        else:
+            end_values = NULL
+        query = self._query_init(index_name)
+        res = []
+        try:
+            handle_status("get_range_from_index",
+                u1db_get_range_from_index(
+                    self._db, query._query, <void*>res, _append_doc_to_list,
+                    n_values, start_values, end_values))
+        finally:
+            if start_values != NULL:
+                free(<void*>start_values)
+            if end_values != NULL:
+                free(<void*>end_values)
+        return res
+
     def get_index_keys(self, index_name):
         cdef int status
         result = []

=== modified file 'u1db/tests/test_backends.py'
--- u1db/tests/test_backends.py	2012-05-31 18:51:20 +0000
+++ u1db/tests/test_backends.py	2012-06-06 17:13:17 +0000
@@ -814,6 +814,166 @@
             [doc4, doc3, doc2, doc1],
             self.db.get_from_index('test-idx', 'v*', '*'))
 
+    def test_get_range_from_index_start_end(self):
+        doc1 = self.db.create_doc('{"key": "value3"}')
+        doc2 = self.db.create_doc('{"key": "value2"}')
+        self.db.create_doc('{"key": "value4"}')
+        self.db.create_doc('{"key": "value1"}')
+        self.db.create_index('test-idx', 'key')
+        self.assertEqual(
+            [doc2, doc1],
+            self.db.get_range_from_index('test-idx', 'value2', 'value3'))
+
+    def test_get_range_from_index_start(self):
+        doc1 = self.db.create_doc('{"key": "value3"}')
+        doc2 = self.db.create_doc('{"key": "value2"}')
+        doc3 = self.db.create_doc('{"key": "value4"}')
+        self.db.create_doc('{"key": "value1"}')
+        self.db.create_index('test-idx', 'key')
+        self.assertEqual(
+            [doc2, doc1, doc3],
+            self.db.get_range_from_index('test-idx', 'value2'))
+
+    def test_get_range_from_index_end(self):
+        self.db.create_doc('{"key": "value3"}')
+        doc2 = self.db.create_doc('{"key": "value2"}')
+        self.db.create_doc('{"key": "value4"}')
+        doc4 = self.db.create_doc('{"key": "value1"}')
+        self.db.create_index('test-idx', 'key')
+        self.assertEqual(
+            [doc4, doc2],
+            self.db.get_range_from_index('test-idx', None, 'value2'))
+
+    def test_get_wildcard_range_from_index_start(self):
+        doc1 = self.db.create_doc('{"key": "value4"}')
+        doc2 = self.db.create_doc('{"key": "value23"}')
+        doc3 = self.db.create_doc('{"key": "value2"}')
+        doc4 = self.db.create_doc('{"key": "value22"}')
+        self.db.create_doc('{"key": "value1"}')
+        self.db.create_index('test-idx', 'key')
+        self.assertEqual(
+            [doc3, doc4, doc2, doc1],
+            self.db.get_range_from_index('test-idx', 'value2*'))
+
+    def test_get_wildcard_range_from_index_end(self):
+        self.db.create_doc('{"key": "value4"}')
+        doc2 = self.db.create_doc('{"key": "value23"}')
+        doc3 = self.db.create_doc('{"key": "value2"}')
+        doc4 = self.db.create_doc('{"key": "value22"}')
+        doc5 = self.db.create_doc('{"key": "value1"}')
+        self.db.create_index('test-idx', 'key')
+        self.assertEqual(
+            [doc5, doc3, doc4, doc2],
+            self.db.get_range_from_index('test-idx', None, 'value2*'))
+
+    def test_get_wildcard_range_from_index_start_end(self):
+        self.db.create_doc('{"key": "a"}')
+        doc2 = self.db.create_doc('{"key": "boo3"}')
+        doc3 = self.db.create_doc('{"key": "catalyst"}')
+        doc4 = self.db.create_doc('{"key": "whaever"}')
+        doc5 = self.db.create_doc('{"key": "zerg"}')
+        self.db.create_index('test-idx', 'key')
+        self.assertEqual(
+            [doc3, doc4],
+            self.db.get_range_from_index('test-idx', 'cat*', 'zap*'))
+
+    def test_get_range_from_index_multi_column_start_end(self):
+        self.db.create_doc('{"key": "value3", "key2": "value4"}')
+        doc2 = self.db.create_doc('{"key": "value2", "key2": "value3"}')
+        doc3 = self.db.create_doc('{"key": "value2", "key2": "value2"}')
+        self.db.create_doc('{"key": "value1", "key2": "value1"}')
+        self.db.create_index('test-idx', 'key', 'key2')
+        self.assertEqual(
+            [doc3, doc2],
+            self.db.get_range_from_index(
+                'test-idx', ('value2', 'value2'), ('value2', 'value3')))
+
+    def test_get_range_from_index_multi_column_start(self):
+        doc1 = self.db.create_doc('{"key": "value3", "key2": "value4"}')
+        doc2 = self.db.create_doc('{"key": "value2", "key2": "value3"}')
+        self.db.create_doc('{"key": "value2", "key2": "value2"}')
+        self.db.create_doc('{"key": "value1", "key2": "value1"}')
+        self.db.create_index('test-idx', 'key', 'key2')
+        self.assertEqual(
+            [doc2, doc1],
+            self.db.get_range_from_index('test-idx', ('value2', 'value3')))
+
+    def test_get_range_from_index_multi_column_end(self):
+        self.db.create_doc('{"key": "value3", "key2": "value4"}')
+        doc2 = self.db.create_doc('{"key": "value2", "key2": "value3"}')
+        doc3 = self.db.create_doc('{"key": "value2", "key2": "value2"}')
+        doc4 = self.db.create_doc('{"key": "value1", "key2": "value1"}')
+        self.db.create_index('test-idx', 'key', 'key2')
+        self.assertEqual(
+            [doc4, doc3, doc2],
+            self.db.get_range_from_index(
+                'test-idx', None, ('value2', 'value3')))
+
+    def test_get_wildcard_range_from_index_multi_column_start(self):
+        doc1 = self.db.create_doc('{"key": "value3", "key2": "value4"}')
+        doc2 = self.db.create_doc('{"key": "value2", "key2": "value23"}')
+        doc3 = self.db.create_doc('{"key": "value2", "key2": "value2"}')
+        self.db.create_doc('{"key": "value1", "key2": "value1"}')
+        self.db.create_index('test-idx', 'key', 'key2')
+        self.assertEqual(
+            [doc3, doc2, doc1],
+            self.db.get_range_from_index('test-idx', ('value2', 'value2*')))
+
+    def test_get_wildcard_range_from_index_multi_column_end(self):
+        self.db.create_doc('{"key": "value3", "key2": "value4"}')
+        doc2 = self.db.create_doc('{"key": "value2", "key2": "value23"}')
+        doc3 = self.db.create_doc('{"key": "value2", "key2": "value2"}')
+        doc4 = self.db.create_doc('{"key": "value1", "key2": "value1"}')
+        self.db.create_index('test-idx', 'key', 'key2')
+        self.assertEqual(
+            [doc4, doc3, doc2],
+            self.db.get_range_from_index(
+                'test-idx', None, ('value2', 'value2*')))
+
+    def test_get_glob_range_from_index_multi_column_start(self):
+        doc1 = self.db.create_doc('{"key": "value3", "key2": "value4"}')
+        doc2 = self.db.create_doc('{"key": "value2", "key2": "value23"}')
+        self.db.create_doc('{"key": "value1", "key2": "value2"}')
+        self.db.create_doc('{"key": "value1", "key2": "value1"}')
+        self.db.create_index('test-idx', 'key', 'key2')
+        self.assertEqual(
+            [doc2, doc1],
+            self.db.get_range_from_index('test-idx', ('value2', '*')))
+
+    def test_get_glob_range_from_index_multi_column_end(self):
+        self.db.create_doc('{"key": "value3", "key2": "value4"}')
+        doc2 = self.db.create_doc('{"key": "value2", "key2": "value23"}')
+        doc3 = self.db.create_doc('{"key": "value1", "key2": "value2"}')
+        doc4 = self.db.create_doc('{"key": "value1", "key2": "value1"}')
+        self.db.create_index('test-idx', 'key', 'key2')
+        self.assertEqual(
+            [doc4, doc3, doc2],
+            self.db.get_range_from_index('test-idx', None, ('value2', '*')))
+
+    def test_get_range_from_index_illegal_wildcard_order(self):
+        self.db.create_index('test-idx', 'k1', 'k2')
+        self.assertRaises(
+            errors.InvalidGlobbing,
+            self.db.get_range_from_index, 'test-idx', ('*', 'v2'))
+
+    def test_get_range_from_index_illegal_glob_after_wildcard(self):
+        self.db.create_index('test-idx', 'k1', 'k2')
+        self.assertRaises(
+            errors.InvalidGlobbing,
+            self.db.get_range_from_index, 'test-idx', ('*', 'v*'))
+
+    def test_get_range_from_index_illegal_wildcard_order_end(self):
+        self.db.create_index('test-idx', 'k1', 'k2')
+        self.assertRaises(
+            errors.InvalidGlobbing,
+            self.db.get_range_from_index, 'test-idx', None, ('*', 'v2'))
+
+    def test_get_range_from_index_illegal_glob_after_wildcard_end(self):
+        self.db.create_index('test-idx', 'k1', 'k2')
+        self.assertRaises(
+            errors.InvalidGlobbing,
+            self.db.get_range_from_index, 'test-idx', None, ('*', 'v*'))
+
     def test_get_from_index_fails_if_no_index(self):
         self.assertRaises(
             errors.IndexDoesNotExist, self.db.get_from_index, 'foo')

=== modified file 'u1db/tests/test_c_backend.py'
--- u1db/tests/test_c_backend.py	2012-05-31 18:51:20 +0000
+++ u1db/tests/test_c_backend.py	2012-06-06 17:13:17 +0000
@@ -93,6 +93,15 @@
                          " VALUES ('doc-id', 'doc-rev', '{}')")
         self.assertRaises(Exception, self.db.get_doc_conflicts, 'doc-id')
 
+    def test_create_indexl(self):
+        # We manually poke data into the DB, so that we test just the "get_doc"
+        # code, rather than also testing the index management code.
+        self.db = c_backend_wrapper.CDatabase(':memory:')
+        doc = self.db.create_doc(tests.simple_doc)
+        self.db.create_indexl("key-idx", ["key"])
+        docs = self.db.get_from_index('key-idx', 'value')
+        self.assertEqual([doc], docs)
+
     def test_get_from_index(self):
         # We manually poke data into the DB, so that we test just the "get_doc"
         # code, rather than also testing the index management code.
@@ -102,6 +111,15 @@
         docs = self.db.get_from_index('key-idx', 'value')
         self.assertEqual([doc], docs)
 
+    def test_get_from_indexl(self):
+        # We manually poke data into the DB, so that we test just the "get_doc"
+        # code, rather than also testing the index management code.
+        self.db = c_backend_wrapper.CDatabase(':memory:')
+        doc = self.db.create_doc(tests.simple_doc)
+        self.db.create_index("key-idx", "key")
+        docs = self.db.get_from_indexl('key-idx', ['value'])
+        self.assertEqual([doc], docs)
+
     def test_get_from_index_2(self):
         self.db = c_backend_wrapper.CDatabase(':memory:')
         doc = self.db.create_doc(tests.nested_doc)