Merge lp:~thisfred/u1db/improve_get_from_index into lp:u1db

[Eric Casteleijn]

changed get_from_index signature to take any number of arguments for the column values

changed get_from_index signature to take any number of arguments for the column values

Note that this does not touch the C implementation, which already uses varargs, which in fact we may want to change. The bug tracking that issue is lp:1006954

[John Lenton (chipaca)]

review: Approve

=== modified file 'u1db/__init__.py'
--- u1db/__init__.py	2012-05-31 16:31:31 +0000
+++ u1db/__init__.py	2012-05-31 18:55:27 +0000
@@ -177,7 +177,7 @@
         """
         raise NotImplementedError(self.list_indexes)
 
-    def get_from_index(self, index_name, key_values):
+    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
@@ -190,9 +190,9 @@
 
         :return: List of [Document]
         :param index_name: The index to query
-        :param key_values: A list of tuple of values to match. eg, if you have
-            an index with 3 field,s then you would have:
-            [(x-val1, x-val2, x-val3), (y-val1, y-val2, y-val3), ...])
+        :param key_values: tuples of 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), ...
         """
         raise NotImplementedError(self.get_from_index)
 

=== modified file 'u1db/backends/inmemory.py'
--- u1db/backends/inmemory.py	2012-05-31 16:31:31 +0000
+++ u1db/backends/inmemory.py	2012-05-31 18:55:27 +0000
@@ -210,7 +210,7 @@
             definitions.append((idx._name, idx._definition))
         return definitions
 
-    def get_from_index(self, index_name, key_values):
+    def get_from_index(self, index_name, *key_values):
         try:
             index = self._indexes[index_name]
         except KeyError:
@@ -337,16 +337,13 @@
             return -1
         return last
 
-    def lookup(self, key_values):
+    def lookup(self, values):
         """Find docs that match the values."""
-        result = []
-        for values in key_values:
-            last = self._find_non_wildcards(values)
-            if last == -1:
-                result.extend(self._lookup_exact(values))
-            else:
-                result.extend(self._lookup_prefix(values[:last]))
-        return result
+        last = self._find_non_wildcards(values)
+        if last == -1:
+            return self._lookup_exact(values)
+        else:
+            return self._lookup_prefix(values[:last])
 
     def keys(self):
         """Find the indexed keys."""

=== modified file 'u1db/backends/sqlite_backend.py'
--- u1db/backends/sqlite_backend.py	2012-05-31 16:31:31 +0000
+++ u1db/backends/sqlite_backend.py	2012-05-31 18:55:27 +0000
@@ -576,7 +576,7 @@
         assert value[-1] == '*'
         return value[:-1] + '%'
 
-    def get_from_index(self, index_name, key_values):
+    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
         # against itself, as many times as the 'width' of our definition.
@@ -596,50 +596,47 @@
                       + (" AND d%d.value LIKE ? ESCAPE '.'" % (i,))
                       for i in range(len(definition))]
         c = self._db_handle.cursor()
-        result = []
         is_wildcard = False
-        for key_value in key_values:
-            # Merge the lists together, so that:
-            # [field1, field2, field3], [val1, val2, val3]
-            # Becomes:
-            # (field1, val1, field2, val2, field3, val3)
-            args = []
-            where = []
-            if len(key_value) != len(definition):
-                raise errors.InvalidValueForIndex()
-            for idx, (field, value) in enumerate(zip(definition, key_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._transform_glob(value))
-                    is_wildcard = True
+        # Merge the lists together, so that:
+        # [field1, field2, field3], [val1, val2, val3]
+        # Becomes:
+        # (field1, val1, field2, val2, field3, val3)
+        args = []
+        where = []
+        if len(key_values) != len(definition):
+            raise errors.InvalidValueForIndex()
+        for idx, (field, value) in enumerate(zip(definition, key_values)):
+            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(exact_where[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))])))
-            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()
-            result.extend([self._factory(r[0], r[1], r[2]) for r in res])
-        return result
+                    where.append(like_where[idx])
+                    args.append(self._transform_glob(value))
+                is_wildcard = True
+            else:
+                if is_wildcard:
+                    raise errors.InvalidGlobbing
+                where.append(exact_where[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))])))
+        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()

=== modified file 'u1db/commandline/client.py'
--- u1db/commandline/client.py	2012-05-30 21:45:09 +0000
+++ u1db/commandline/client.py	2012-05-31 18:55:27 +0000
@@ -432,7 +432,7 @@
     def run(self, database, index, values):
         try:
             db = self._open(database, create=False)
-            docs = db.get_from_index(index, [values])
+            docs = db.get_from_index(index, *values)
         except errors.DatabaseDoesNotExist:
             self.stderr.write("Database does not exist.\n")
         except errors.IndexDoesNotExist:

=== modified file 'u1db/tests/c_backend_wrapper.pyx'
--- u1db/tests/c_backend_wrapper.pyx	2012-05-30 21:45:09 +0000
+++ u1db/tests/c_backend_wrapper.pyx	2012-05-31 18:55:27 +0000
@@ -1062,42 +1062,41 @@
         handle_status("delete_index",
             u1db_delete_index(self._db, index_name))
 
-    def get_from_index(self, index_name, key_values):
+    def get_from_index(self, index_name, *key_values):
         cdef CQuery query
         cdef int status
         extra = []
         query = self._query_init(index_name)
         res = []
         status = U1DB_OK
-        for entry in key_values:
-            if len(entry) == 0:
-                status = u1db_get_from_index(self._db, query._query,
-                    <void*>res, _append_doc_to_list, 0, NULL)
-            elif len(entry) == 1:
-                status = u1db_get_from_index(self._db, query._query,
-                    <void*>res, _append_doc_to_list, 1,
-                    _ensure_str(entry[0], extra))
-            elif len(entry) == 2:
-                status = u1db_get_from_index(self._db, query._query,
-                    <void*>res, _append_doc_to_list, 2,
-                    _ensure_str(entry[0], extra),
-                    _ensure_str(entry[1], extra))
-            elif len(entry) == 3:
-                status = u1db_get_from_index(self._db, query._query,
-                    <void*>res, _append_doc_to_list, 3,
-                    _ensure_str(entry[0], extra),
-                    _ensure_str(entry[1], extra),
-                    _ensure_str(entry[2], extra))
-            elif len(entry) == 4:
-                status = u1db_get_from_index(self._db, query._query,
-                    <void*>res, _append_doc_to_list, 4,
-                    _ensure_str(entry[0], extra),
-                    _ensure_str(entry[1], extra),
-                    _ensure_str(entry[2], extra),
-                    _ensure_str(entry[3], extra))
-            else:
-                status = U1DB_NOT_IMPLEMENTED
-            handle_status("get_from_index", status)
+        if len(key_values) == 0:
+            status = u1db_get_from_index(self._db, query._query,
+                <void*>res, _append_doc_to_list, 0, NULL)
+        elif len(key_values) == 1:
+            status = u1db_get_from_index(self._db, query._query,
+                <void*>res, _append_doc_to_list, 1,
+                _ensure_str(key_values[0], extra))
+        elif len(key_values) == 2:
+            status = u1db_get_from_index(self._db, query._query,
+                <void*>res, _append_doc_to_list, 2,
+                _ensure_str(key_values[0], extra),
+                _ensure_str(key_values[1], extra))
+        elif len(key_values) == 3:
+            status = u1db_get_from_index(self._db, query._query,
+                <void*>res, _append_doc_to_list, 3,
+                _ensure_str(key_values[0], extra),
+                _ensure_str(key_values[1], extra),
+                _ensure_str(key_values[2], extra))
+        elif len(key_values) == 4:
+            status = u1db_get_from_index(self._db, query._query,
+                <void*>res, _append_doc_to_list, 4,
+                _ensure_str(key_values[0], extra),
+                _ensure_str(key_values[1], extra),
+                _ensure_str(key_values[2], extra),
+                _ensure_str(key_values[3], extra))
+        else:
+            status = U1DB_NOT_IMPLEMENTED
+        handle_status("get_from_index", status)
         return res
 
     def get_index_keys(self, index_name):

=== modified file 'u1db/tests/test_backends.py'
--- u1db/tests/test_backends.py	2012-05-31 16:39:27 +0000
+++ u1db/tests/test_backends.py	2012-05-31 18:55:27 +0000
@@ -727,8 +727,7 @@
     def test_create_index_on_non_ascii_field_name(self):
         doc = self.db.create_doc(simplejson.dumps({u'\xe5': 'value'}))
         self.db.create_index('test-idx', u'\xe5')
-        self.assertEqual([doc],
-                         self.db.get_from_index('test-idx', [('value',)]))
+        self.assertEqual([doc], self.db.get_from_index('test-idx', 'value'))
 
     def test_list_indexes_with_non_ascii_field_names(self):
         self.db.create_index('test-idx', u'\xe5')
@@ -738,20 +737,18 @@
     def test_create_index_evaluates_it(self):
         doc = self.db.create_doc(simple_doc)
         self.db.create_index('test-idx', 'key')
-        self.assertEqual([doc],
-                         self.db.get_from_index('test-idx', [('value',)]))
+        self.assertEqual([doc], self.db.get_from_index('test-idx', 'value'))
 
     def test_wildcard_matches_unicode_value(self):
         doc = self.db.create_doc(simplejson.dumps({"key": u"valu\xe5"}))
         self.db.create_index('test-idx', 'key')
-        self.assertEqual(
-            [doc], self.db.get_from_index('test-idx', [('*',)]))
+        self.assertEqual([doc], self.db.get_from_index('test-idx', '*'))
 
     def test_retrieve_unicode_value_from_index(self):
         doc = self.db.create_doc(simplejson.dumps({"key": u"valu\xe5"}))
         self.db.create_index('test-idx', 'key')
         self.assertEqual(
-            [doc], self.db.get_from_index('test-idx', [(u"valu\xe5",)]))
+            [doc], self.db.get_from_index('test-idx', u"valu\xe5"))
 
     def test_create_index_fails_if_name_taken(self):
         self.db.create_index('test-idx', 'key')
@@ -769,8 +766,7 @@
         doc2 = self.db.create_doc(simple_doc)
         self.db.delete_doc(doc2)
         self.db.create_index('test-idx', 'key')
-        self.assertEqual([doc],
-                         self.db.get_from_index('test-idx', [('value',)]))
+        self.assertEqual([doc], self.db.get_from_index('test-idx', 'value'))
 
     def test_delete_index(self):
         self.db.create_index('test-idx', 'key')
@@ -781,40 +777,32 @@
     def test_create_adds_to_index(self):
         self.db.create_index('test-idx', 'key')
         doc = self.db.create_doc(simple_doc)
-        self.assertEqual([doc],
-            self.db.get_from_index('test-idx', [('value',)]))
+        self.assertEqual([doc], self.db.get_from_index('test-idx', 'value'))
 
     def test_get_from_index_unmatched(self):
         self.db.create_doc(simple_doc)
         self.db.create_index('test-idx', 'key')
-        self.assertEqual(
-            [], self.db.get_from_index('test-idx', [('novalue',)]))
+        self.assertEqual([], self.db.get_from_index('test-idx', 'novalue'))
 
     def test_create_index_multiple_exact_matches(self):
         doc = self.db.create_doc(simple_doc)
         doc2 = self.db.create_doc(simple_doc)
         self.db.create_index('test-idx', 'key')
-        self.assertEqual(sorted([doc, doc2]),
-            sorted(self.db.get_from_index('test-idx', [('value',)])))
+        self.assertEqual(
+            sorted([doc, doc2]),
+            sorted(self.db.get_from_index('test-idx', 'value')))
 
     def test_get_from_index(self):
         doc = self.db.create_doc(simple_doc)
         self.db.create_index('test-idx', 'key')
-        self.assertEqual([doc],
-                         self.db.get_from_index('test-idx', [('value',)]))
-
-    def test_get_from_index_some_matches(self):
-        doc = self.db.create_doc(simple_doc)
-        self.db.create_index('test-idx', 'key')
-        self.assertEqual([doc],
-            self.db.get_from_index('test-idx', [('value',), ('novalue',)]))
+        self.assertEqual([doc], self.db.get_from_index('test-idx', 'value'))
 
     def test_get_from_index_multi(self):
         content = '{"key": "value", "key2": "value2"}'
         doc = self.db.create_doc(content)
         self.db.create_index('test-idx', 'key', 'key2')
-        self.assertEqual([doc],
-            self.db.get_from_index('test-idx', [('value', 'value2')]))
+        self.assertEqual(
+            [doc], self.db.get_from_index('test-idx', 'value', 'value2'))
 
     def test_get_from_index_multi_ordered(self):
         doc1 = self.db.create_doc('{"key": "value3", "key2": "value4"}')
@@ -822,13 +810,13 @@
         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, doc1],
-            self.db.get_from_index('test-idx', [('v*', '*')]))
+        self.assertEqual(
+            [doc4, doc3, doc2, doc1],
+            self.db.get_from_index('test-idx', 'v*', '*'))
 
     def test_get_from_index_fails_if_no_index(self):
-        self.assertRaises(errors.IndexDoesNotExist,
-                          self.db.get_from_index,
-                          'foo', [])
+        self.assertRaises(
+            errors.IndexDoesNotExist, self.db.get_from_index, 'foo')
 
     def test_get_index_keys_fails_if_no_index(self):
         self.assertRaises(errors.IndexDoesNotExist,
@@ -845,39 +833,41 @@
         new_content = '{"key": "altval"}'
         doc.set_json(new_content)
         self.db.put_doc(doc)
-        self.assertEqual([],
-            self.db.get_from_index('test-idx', [('value',)]))
-        self.assertEqual([doc],
-            self.db.get_from_index('test-idx', [('altval',)]))
+        self.assertEqual([], self.db.get_from_index('test-idx', 'value'))
+        self.assertEqual([doc], self.db.get_from_index('test-idx', 'altval'))
 
     def test_delete_updates_index(self):
         doc = self.db.create_doc(simple_doc)
         doc2 = self.db.create_doc(simple_doc)
         self.db.create_index('test-idx', 'key')
-        self.assertEqual(sorted([doc, doc2]),
-            sorted(self.db.get_from_index('test-idx', [('value',)])))
+        self.assertEqual(
+            sorted([doc, doc2]),
+            sorted(self.db.get_from_index('test-idx', 'value')))
         self.db.delete_doc(doc)
-        self.assertEqual([doc2],
-            self.db.get_from_index('test-idx', [('value',)]))
+        self.assertEqual([doc2], self.db.get_from_index('test-idx', 'value'))
 
     def test_get_from_index_illegal_number_of_entries(self):
         self.db.create_index('test-idx', 'k1', 'k2')
-        self.assertRaises(errors.InvalidValueForIndex,
-            self.db.get_from_index, 'test-idx', [()])
-        self.assertRaises(errors.InvalidValueForIndex,
-            self.db.get_from_index, 'test-idx', [('v1',)])
-        self.assertRaises(errors.InvalidValueForIndex,
-            self.db.get_from_index, 'test-idx', [('v1', 'v2', 'v3')])
+        self.assertRaises(
+            errors.InvalidValueForIndex, self.db.get_from_index, 'test-idx')
+        self.assertRaises(
+            errors.InvalidValueForIndex,
+            self.db.get_from_index, 'test-idx', 'v1')
+        self.assertRaises(
+            errors.InvalidValueForIndex,
+            self.db.get_from_index, 'test-idx', 'v1', 'v2', 'v3')
 
     def test_get_from_index_illegal_wildcard_order(self):
         self.db.create_index('test-idx', 'k1', 'k2')
-        self.assertRaises(errors.InvalidGlobbing,
-            self.db.get_from_index, 'test-idx', [('*', 'v2')])
+        self.assertRaises(
+            errors.InvalidGlobbing,
+            self.db.get_from_index, 'test-idx', '*', 'v2')
 
     def test_get_from_index_illegal_glob_after_wildcard(self):
         self.db.create_index('test-idx', 'k1', 'k2')
-        self.assertRaises(errors.InvalidGlobbing,
-            self.db.get_from_index, 'test-idx', [('*', 'v*')])
+        self.assertRaises(
+            errors.InvalidGlobbing,
+            self.db.get_from_index, 'test-idx', '*', 'v*')
 
     def test_get_all_from_index(self):
         self.db.create_index('test-idx', 'key')
@@ -888,8 +878,9 @@
         diff_value_doc = '{"key": "diff value"}'
         doc4 = self.db.create_doc(diff_value_doc)
         # This is essentially a 'prefix' match, but we match every entry.
-        self.assertEqual(sorted([doc1, doc2, doc4]),
-            sorted(self.db.get_from_index('test-idx', [('*',)])))
+        self.assertEqual(
+            sorted([doc1, doc2, doc4]),
+            sorted(self.db.get_from_index('test-idx', '*')))
 
     def test_get_all_from_index_ordered(self):
         self.db.create_index('test-idx', 'key')
@@ -898,36 +889,33 @@
         doc3 = self.db.create_doc('{"key": "value a"}')
         doc4 = self.db.create_doc('{"key": "value m"}')
         # This is essentially a 'prefix' match, but we match every entry.
-        self.assertEqual([doc3, doc2, doc4, doc1],
-            self.db.get_from_index('test-idx', [('*',)]))
+        self.assertEqual(
+            [doc3, doc2, doc4, doc1], self.db.get_from_index('test-idx', '*'))
 
     def test_put_updates_when_adding_key(self):
         doc = self.db.create_doc("{}")
         self.db.create_index('test-idx', 'key')
-        self.assertEqual([],
-            self.db.get_from_index('test-idx', [('*',)]))
+        self.assertEqual([], self.db.get_from_index('test-idx', '*'))
         doc.set_json(simple_doc)
         self.db.put_doc(doc)
-        self.assertEqual([doc],
-            self.db.get_from_index('test-idx', [('*',)]))
+        self.assertEqual([doc], self.db.get_from_index('test-idx', '*'))
 
     def test_get_from_index_empty_string(self):
         self.db.create_index('test-idx', 'key')
         doc1 = self.db.create_doc(simple_doc)
         content2 = '{"key": ""}'
         doc2 = self.db.create_doc(content2)
-        self.assertEqual([doc2],
-                         self.db.get_from_index('test-idx', [('',)]))
+        self.assertEqual([doc2], self.db.get_from_index('test-idx', ''))
         # Empty string matches the wildcard.
-        self.assertEqual(sorted([doc1, doc2]),
-            sorted(self.db.get_from_index('test-idx', [('*',)])))
+        self.assertEqual(
+            sorted([doc1, doc2]),
+            sorted(self.db.get_from_index('test-idx', '*')))
 
     def test_get_from_index_not_null(self):
         self.db.create_index('test-idx', 'key')
         doc1 = self.db.create_doc(simple_doc)
         self.db.create_doc('{"key": null}')
-        self.assertEqual([doc1],
-            self.db.get_from_index('test-idx', [('*',)]))
+        self.assertEqual([doc1], self.db.get_from_index('test-idx', '*'))
 
     def test_get_partial_from_index(self):
         content1 = '{"k1": "v1", "k2": "v2"}'
@@ -940,8 +928,9 @@
         doc3 = self.db.create_doc(content3)
         self.db.create_doc(content4)
         self.db.create_index('test-idx', 'k1', 'k2')
-        self.assertEqual(sorted([doc1, doc2, doc3]),
-            sorted(self.db.get_from_index('test-idx', [("v1", "*")])))
+        self.assertEqual(
+            sorted([doc1, doc2, doc3]),
+            sorted(self.db.get_from_index('test-idx', "v1", "*")))
 
     def test_get_glob_match(self):
         # Note: the exact glob syntax is probably subject to change
@@ -955,61 +944,63 @@
         doc2 = self.db.create_doc(content2)
         doc3 = self.db.create_doc(content3)
         self.db.create_doc(content4)
-        self.assertEqual(sorted([doc1, doc2, doc3]),
-            sorted(self.db.get_from_index('test-idx', [("v1", "v*")])))
+        self.assertEqual(
+            sorted([doc1, doc2, doc3]),
+            sorted(self.db.get_from_index('test-idx', "v1", "v*")))
 
     def test_nested_index(self):
         doc = self.db.create_doc(nested_doc)
         self.db.create_index('test-idx', 'sub.doc')
-        self.assertEqual([doc],
-            self.db.get_from_index('test-idx', [('underneath',)]))
+        self.assertEqual(
+            [doc], self.db.get_from_index('test-idx', 'underneath'))
         doc2 = self.db.create_doc(nested_doc)
         self.assertEqual(
             sorted([doc, doc2]),
-            sorted(self.db.get_from_index('test-idx', [('underneath',)])))
+            sorted(self.db.get_from_index('test-idx', 'underneath')))
 
     def test_nested_nonexistent(self):
         self.db.create_doc(nested_doc)
         # sub exists, but sub.foo does not:
         self.db.create_index('test-idx', 'sub.foo')
-        self.assertEqual([], self.db.get_from_index('test-idx', [('*',)]))
+        self.assertEqual([], self.db.get_from_index('test-idx', '*'))
 
     def test_nested_nonexistent2(self):
         self.db.create_doc(nested_doc)
         # sub exists, but sub.foo does not:
         self.db.create_index('test-idx', 'sub.foo.bar.baz.qux.fnord')
-        self.assertEqual([], self.db.get_from_index('test-idx', [('*',)]))
+        self.assertEqual([], self.db.get_from_index('test-idx', '*'))
 
     def test_index_list1(self):
         self.db.create_index("index", "name")
         content = '{"name": ["foo", "bar"]}'
         doc = self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("bar", )])
+        rows = self.db.get_from_index("index", "bar")
         self.assertEqual([doc], rows)
 
     def test_index_list2(self):
         self.db.create_index("index", "name")
         content = '{"name": ["foo", "bar"]}'
         doc = self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("foo", )])
+        rows = self.db.get_from_index("index", "foo")
         self.assertEqual([doc], rows)
 
     def test_get_from_index_case_sensitive(self):
         self.db.create_index('test-idx', 'key')
         doc1 = self.db.create_doc(simple_doc)
-        self.assertEqual([], self.db.get_from_index('test-idx', [('V*',)]))
-        self.assertEqual([doc1],
-                         self.db.get_from_index('test-idx', [('v*',)]))
+        self.assertEqual([], self.db.get_from_index('test-idx', 'V*'))
+        self.assertEqual([doc1], self.db.get_from_index('test-idx', 'v*'))
 
     def test_get_from_index_illegal_glob_before_value(self):
         self.db.create_index('test-idx', 'k1', 'k2')
-        self.assertRaises(errors.InvalidGlobbing,
-            self.db.get_from_index, 'test-idx', [('v*', 'v2')])
+        self.assertRaises(
+            errors.InvalidGlobbing,
+            self.db.get_from_index, 'test-idx', 'v*', 'v2')
 
     def test_get_from_index_illegal_glob_after_glob(self):
         self.db.create_index('test-idx', 'k1', 'k2')
-        self.assertRaises(errors.InvalidGlobbing,
-            self.db.get_from_index, 'test-idx', [('v*', 'v*')])
+        self.assertRaises(
+            errors.InvalidGlobbing,
+            self.db.get_from_index, 'test-idx', 'v*', 'v*')
 
     def test_get_from_index_with_sql_wildcards(self):
         self.db.create_index('test-idx', 'key')
@@ -1021,31 +1012,29 @@
         doc3 = self.db.create_doc(content3)
         # The '%' in the search should be treated literally, not as a sql
         # globbing character.
-        self.assertEqual([doc1],
-            self.db.get_from_index('test-idx', [('va%*',)]))
+        self.assertEqual([doc1], self.db.get_from_index('test-idx', 'va%*'))
         # Same for '_'
-        self.assertEqual([doc3],
-            self.db.get_from_index('test-idx', [('va_*',)]))
+        self.assertEqual([doc3], self.db.get_from_index('test-idx', 'va_*'))
 
     def test_get_from_index_with_lower(self):
         self.db.create_index("index", "lower(name)")
         content = '{"name": "Foo"}'
         doc = self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("foo", )])
+        rows = self.db.get_from_index("index", "foo")
         self.assertEqual([doc], rows)
 
     def test_get_from_index_with_lower_matches_same_case(self):
         self.db.create_index("index", "lower(name)")
         content = '{"name": "foo"}'
         doc = self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("foo", )])
+        rows = self.db.get_from_index("index", "foo")
         self.assertEqual([doc], rows)
 
     def test_index_lower_doesnt_match_different_case(self):
         self.db.create_index("index", "lower(name)")
         content = '{"name": "Foo"}'
         self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("Foo", )])
+        rows = self.db.get_from_index("index", "Foo")
         self.assertEqual([], rows)
 
     def test_index_lower_doesnt_match_other_index(self):
@@ -1053,63 +1042,63 @@
         self.db.create_index("other_index", "name")
         content = '{"name": "Foo"}'
         self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("Foo", )])
+        rows = self.db.get_from_index("index", "Foo")
         self.assertEqual(0, len(rows))
 
     def test_index_split_words_match_first(self):
         self.db.create_index("index", "split_words(name)")
         content = '{"name": "foo bar"}'
         doc = self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("foo", )])
+        rows = self.db.get_from_index("index", "foo")
         self.assertEqual([doc], rows)
 
     def test_index_split_words_match_second(self):
         self.db.create_index("index", "split_words(name)")
         content = '{"name": "foo bar"}'
         doc = self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("bar", )])
+        rows = self.db.get_from_index("index", "bar")
         self.assertEqual([doc], rows)
 
     def test_index_split_words_match_both(self):
         self.db.create_index("index", "split_words(name)")
         content = '{"name": "foo foo"}'
         doc = self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("foo", )])
+        rows = self.db.get_from_index("index", "foo")
         self.assertEqual([doc], rows)
 
     def test_index_split_words_double_space(self):
         self.db.create_index("index", "split_words(name)")
         content = '{"name": "foo  bar"}'
         doc = self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("bar", )])
+        rows = self.db.get_from_index("index", "bar")
         self.assertEqual([doc], rows)
 
     def test_index_split_words_leading_space(self):
         self.db.create_index("index", "split_words(name)")
         content = '{"name": " foo bar"}'
         doc = self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("foo", )])
+        rows = self.db.get_from_index("index", "foo")
         self.assertEqual([doc], rows)
 
     def test_index_split_words_trailing_space(self):
         self.db.create_index("index", "split_words(name)")
         content = '{"name": "foo bar "}'
         doc = self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("bar", )])
+        rows = self.db.get_from_index("index", "bar")
         self.assertEqual([doc], rows)
 
     def test_get_from_index_with_number(self):
         self.db.create_index("index", "number(foo, 5)")
         content = '{"foo": 12}'
         doc = self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("00012", )])
+        rows = self.db.get_from_index("index", "00012")
         self.assertEqual([doc], rows)
 
     def test_get_from_index_with_number_bigger_than_padding(self):
         self.db.create_index("index", "number(foo, 5)")
         content = '{"foo": 123456}'
         doc = self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("123456", )])
+        rows = self.db.get_from_index("index", "123456")
         self.assertEqual([doc], rows)
 
     def test_number_mapping_ignores_non_numbers(self):
@@ -1118,28 +1107,28 @@
         doc1 = self.db.create_doc(content)
         content = '{"foo": "this is not a maigret painting"}'
         self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("*", )])
+        rows = self.db.get_from_index("index", "*")
         self.assertEqual([doc1], rows)
 
     def test_get_from_index_with_bool(self):
         self.db.create_index("index", "bool(foo)")
         content = '{"foo": true}'
         doc = self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("1", )])
+        rows = self.db.get_from_index("index", "1")
         self.assertEqual([doc], rows)
 
     def test_get_from_index_with_bool_false(self):
         self.db.create_index("index", "bool(foo)")
         content = '{"foo": false}'
         doc = self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("0", )])
+        rows = self.db.get_from_index("index", "0")
         self.assertEqual([doc], rows)
 
     def test_get_from_index_with_non_bool(self):
         self.db.create_index("index", "bool(foo)")
         content = '{"foo": 42}'
         self.db.create_doc(content)
-        rows = self.db.get_from_index("index", [("*", )])
+        rows = self.db.get_from_index("index", "*")
         self.assertEqual([], rows)
 
     def test_get_index_keys_from_index(self):
@@ -1197,7 +1186,7 @@
         self.db.create_index('test-idx', 'key')
         self.assertTrue(
             isinstance(
-                self.db.get_from_index('test-idx', [('value',)])[0],
+                self.db.get_from_index('test-idx', 'value')[0],
                 TestAlternativeDocument))
 
     def test_sync_exchange_updates_indexes(self):
@@ -1216,9 +1205,9 @@
             docs_by_gen, 'other-replica', last_known_generation=0,
             return_doc_cb=ignore)
         self.assertGetDoc(self.db, doc.doc_id, other_rev, new_content, False)
-        self.assertEqual([doc_other],
-                         self.db.get_from_index('test-idx', [('altval',)]))
-        self.assertEqual([], self.db.get_from_index('test-idx', [('value',)]))
+        self.assertEqual(
+            [doc_other], self.db.get_from_index('test-idx', 'altval'))
+        self.assertEqual([], self.db.get_from_index('test-idx', 'value'))
 
 
 # Use a custom loader to apply the scenarios at load time.

=== modified file 'u1db/tests/test_c_backend.py'
--- u1db/tests/test_c_backend.py	2012-05-31 16:10:38 +0000
+++ u1db/tests/test_c_backend.py	2012-05-31 18:55:27 +0000
@@ -99,14 +99,14 @@
         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_index('key-idx', [('value',)])
+        docs = self.db.get_from_index('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)
         self.db.create_index("multi-idx", "key", "sub.doc")
-        docs = self.db.get_from_index('multi-idx', [('value', 'underneath')])
+        docs = self.db.get_from_index('multi-idx', 'value', 'underneath')
         self.assertEqual([doc], docs)
 
     def test_get_index_keys(self):

=== modified file 'u1db/tests/test_inmemory.py'
--- u1db/tests/test_inmemory.py	2012-05-23 10:57:02 +0000
+++ u1db/tests/test_inmemory.py	2012-05-31 18:55:27 +0000
@@ -104,13 +104,13 @@
     def test_lookup(self):
         idx = inmemory.InMemoryIndex('idx-name', ['key'])
         idx.add_json('doc-id', simple_doc)
-        self.assertEqual(['doc-id'], idx.lookup([('value',)]))
+        self.assertEqual(['doc-id'], idx.lookup(['value']))
 
     def test_lookup_multi(self):
         idx = inmemory.InMemoryIndex('idx-name', ['key'])
         idx.add_json('doc-id', simple_doc)
         idx.add_json('doc2-id', simple_doc)
-        self.assertEqual(['doc-id', 'doc2-id'], idx.lookup([('value',)]))
+        self.assertEqual(['doc-id', 'doc2-id'], idx.lookup(['value']))
 
     def test__find_non_wildcards(self):
         idx = inmemory.InMemoryIndex('idx-name', ['k1', 'k2', 'k3'])

=== modified file 'u1db/tests/test_sync.py'
--- u1db/tests/test_sync.py	2012-05-30 21:45:09 +0000
+++ u1db/tests/test_sync.py	2012-05-31 18:55:27 +0000
@@ -461,8 +461,7 @@
             {'receive': {'docs': [], 'last_known_gen': 0},
              'return': {'docs': [(doc.doc_id, doc.rev)],
                         'last_gen': 1}})
-        self.assertEqual([doc],
-                         self.db1.get_from_index('test-idx', [('value',)]))
+        self.assertEqual([doc], self.db1.get_from_index('test-idx', 'value'))
 
     def test_sync_pulling_doesnt_update_other_if_changed(self):
         doc = self.db2.create_doc(simple_doc)
@@ -551,9 +550,8 @@
         self.assertTransactionLog([doc_id, doc_id], self.db1)
         self.assertGetDoc(self.db1, doc_id, doc2_rev, new_doc, True)
         self.assertGetDoc(self.db2, doc_id, doc2_rev, new_doc, False)
-        self.assertEqual([doc2],
-                         self.db1.get_from_index('test-idx', [('altval',)]))
-        self.assertEqual([], self.db1.get_from_index('test-idx', [('value',)]))
+        self.assertEqual([doc2], self.db1.get_from_index('test-idx', 'altval'))
+        self.assertEqual([], self.db1.get_from_index('test-idx', 'value'))
 
     def test_sync_sees_remote_delete_conflicted(self):
         doc1 = self.db1.create_doc(simple_doc)
@@ -577,7 +575,7 @@
         self.assertGetDocIncludeDeleted(self.db1, doc_id, doc2.rev, None, True)
         self.assertGetDocIncludeDeleted(
             self.db2, doc_id, doc2.rev, None, False)
-        self.assertEqual([], self.db1.get_from_index('test-idx', [('value',)]))
+        self.assertEqual([], self.db1.get_from_index('test-idx', 'value'))
 
     def test_sync_local_race_conflicted(self):
         doc = self.db1.create_doc(simple_doc)
@@ -602,11 +600,9 @@
         self.sync(self.db1, self.db2, trace_hook=after_whatschanged)
         self.assertEqual([True], triggered)
         self.assertGetDoc(self.db1, doc_id, doc2_rev2, content2, True)
-        self.assertEqual([doc],
-                         self.db1.get_from_index('test-idx', [('altval',)]))
-        self.assertEqual([], self.db1.get_from_index('test-idx', [('value',)]))
-        self.assertEqual([], self.db1.get_from_index('test-idx',
-                                                     [('localval',)]))
+        self.assertEqual([doc], self.db1.get_from_index('test-idx', 'altval'))
+        self.assertEqual([], self.db1.get_from_index('test-idx', 'value'))
+        self.assertEqual([], self.db1.get_from_index('test-idx', 'localval'))
 
     def test_sync_propagates_deletes(self):
         doc1 = self.db1.create_doc(simple_doc)
@@ -628,8 +624,8 @@
             self.db1, doc_id, deleted_rev, None, False)
         self.assertGetDocIncludeDeleted(
             self.db2, doc_id, deleted_rev, None, False)
-        self.assertEqual([], self.db1.get_from_index('test-idx', [('value',)]))
-        self.assertEqual([], self.db2.get_from_index('test-idx', [('value',)]))
+        self.assertEqual([], self.db1.get_from_index('test-idx', 'value'))
+        self.assertEqual([], self.db2.get_from_index('test-idx', 'value'))
         self.sync(self.db2, self.db3)
         self.assertLastExchangeLog(self.db3,
             {'receive': {'docs': [(doc_id, deleted_rev)],

=== modified file 'u1todo/u1todo.py'
--- u1todo/u1todo.py	2012-05-30 21:45:09 +0000
+++ u1todo/u1todo.py	2012-05-31 18:55:27 +0000
@@ -86,15 +86,15 @@
             # No tags specified, so return all tasks.
             return self.get_all_tasks()
         # Get all tasks for the first tag.
-        results = dict((doc.doc_id, doc) for doc in
-            self.db.get_from_index(TAGS_INDEX, [(tags[0],)]))
+        results = dict(
+            (doc.doc_id, doc) for doc in
+            self.db.get_from_index(TAGS_INDEX, tags[0]))
         # Now loop over the rest of the tags (if any) and remove from the
         # results any document that does not have that particular tag.
         for tag in tags[1:]:
             # Get the ids of all documents with this tag.
             ids = [
-                doc.doc_id for doc in
-                self.db.get_from_index(TAGS_INDEX, [(tag,)])]
+                doc.doc_id for doc in self.db.get_from_index(TAGS_INDEX, tag)]
             for key in results.keys():
                 if key not in ids:
                     # Remove the document from result, because it does not have
@@ -157,8 +157,7 @@
         # Since the DONE_INDEX indexes anything that has a value in the field
         # "done", and all tasks do (either True or False), it's a good way to
         # get all tasks out of the database.
-        return [
-            Task(doc) for doc in self.db.get_from_index(DONE_INDEX, ["*"])]
+        return [Task(doc) for doc in self.db.get_from_index(DONE_INDEX, "*")]
 
 
 class Task(object):