Changeset 44

Timestamp:

12/31/04 03:43:46

Author:

fumanchu

Message:

1. Changed all storage tests to use common zoo_fixture.py.
2. Added SQLite Storage Manager.
3. Fixed icontains, icontainedby.
4. Added storage.Version class for comparing version strings.
5. Moved decompiler code into common db.SQLDecompiler.
6. SQLDecompiler.code() sets imperfect, but doesn't return it anymore.
7. Fixed bug in storeado expanded columns (no repr of None).
8. All db SM's now have a _get_conn method in prep for a common db.StorageManagerDB class.
9. All db SM's now have create_database and drop_database.
10. Added separate decom for mysql 4.1.1. Autodetects version.
11. Bugfix: SM.shutdown() methods weren't closing current thread's connection (if threaded).
12. Started cleaning up storeodbc.
13. Bugfix in storeshelve if Unit.ID was non-string.
14. Changed Zoo.Animal.Options to .PreviousZoos? (a list).

Files:

• trunk/__init__.py (modified) (1 diff)
• trunk/containers.py (modified) (2 diffs)
• trunk/storage/__init__.py (modified) (2 diffs)
• trunk/storage/db.py (modified) (4 diffs)
• trunk/storage/storeado.py (modified) (12 diffs)
• trunk/storage/storemysql.py (modified) (8 diffs)
• trunk/storage/storeodbc.py (modified) (5 diffs)
• trunk/storage/storepypgsql.py (modified) (7 diffs)
• trunk/storage/storeshelve.py (modified) (4 diffs)
• trunk/storage/storesqlite.py (added)
• trunk/storage/test_storeado.py (modified) (1 diff)
• trunk/storage/test_storemysql.py (modified) (1 diff)
• trunk/storage/test_storeodbc.py (modified) (1 diff)
• trunk/storage/test_storepypgsql.py (modified) (1 diff)
• trunk/storage/test_storeshelve.py (modified) (1 diff)
• trunk/storage/test_storesqlite.py (added)
• trunk/storage/zoo_fixture.py (added)
• trunk/zoo.py (modified) (1 diff)

trunk/__init__.py

@@ -908 +908 @@
-def icontains(a, b):
-    """Case-insensitive test b in a. Note the operand order."""
-
-
-
+
-
-def icontainedby(a, b):
-    """Case-insensitive test a in b. Note the operand order."""
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-
-def istartswith(a, b):

trunk/containers.py

@@ -369 +369 @@
-    
-    def add(self, **facets):
+        """add(**facets) -> add a row to the Prism."""
-        for name, row in self.facets.iteritems():
-            row.append(facets.get(name))
-    
-    def row_number(self, **facet):
+        """row_number(**facet) -> row number, given one facet's key+value."""
-        k, v = facet.popitem()
-        f = self.facets[k]
@@ -381 +383 @@
-    
-    def row(self, **facet):
+        """row(**facet) -> all facets of a row given one facet's key+value."""
-        number = self.row_number(**facet)
-        return dict([(k, v[number]) for k, v in self.facets.iteritems()])

trunk/storage/__init__.py

@@ -1 +1 @@
-"""Storage Managers for Dejavu."""
-
+import re
-import datetime
-import threading
@@ -310 +311 @@
-        return xform(value)
-
+
+class Version(object):
+    
+    def __init__(self, atoms):
+        if isinstance(atoms, basestring):
+            self.atoms = re.split(r'\W', atoms)
+        else:
+            self.atoms = [str(x) for x in atoms]
+    
+    def __cmp__(self, other):
+        index = 0
+        while index < len(self.atoms) and index < len(other.atoms):
+            mine, theirs = self.atoms[index], other.atoms[index]
+            if mine.isdigit() and theirs.isdigit():
+                mine, theirs = int(mine), int(theirs)
+            if mine < theirs:
+                return -1
+            if mine > theirs:
+                return 1
+            index += 1
+        if index < len(other.atoms):
+            return -1
+        if index < len(self.atoms):
+            return 1
+        return 0
+

trunk/storage/db.py

@@ -15 +15 @@
-"""
-
+from types import FunctionType
+from dejavu import codewalk
+
-try:
-    import cPickle as pickle
@@ -98 +101 @@
-        # precision, but... meh. That's why they're called "hints".
-        return u"NUMERIC"
+    coerce_decimal_Decimal = coerce_decimal
-    
-    def coerce_fixedpoint_FixedPoint(self, cls, key):
@@ -292 +296 @@
-
-
+# -------------------------- SQL DECOMPILATION -------------------------- #
+
-class ConstWrapper(str):
-a decompiler
+SQLDecompiler's
-    
-    When we hit LOAD_CONST while decompiling, we occasionally need to keep
@@ -314 +320 @@
-
-
+# Stack sentinels
+table_arg = object()
+kw_arg = object()
+# cannot_represent exists so that a portion of an Expression can be
+# labeled imperfect. For example, the function dejavu.iscurrentweek
+# rarely has an SQL equivalent. All Units (which match the rest of 
+# the Expression) will be recalled; they can then be compared in
+# expr.evaluate(unit).
+cannot_represent = object()
+
+
+class SQLDecompiler(codewalk.LambdaDecompiler):
+    """SQLDecompiler(tablename, expr, adapter=AdapterToSQL).
+    
+    Produce SQL from a supplied Expression object, with a lambda of the form:
+        lambda x, **kw: ...
+    
+    Attributes of x (or whatever the name of the first argument is) will be
+    mapped to table columns. Keyword arguments should be bound using
+    Expression.bind_args before calling this decompiler.
+    """
+    
+    # Some constants are function or class objects,
+    # which should not be coerced.
+    no_coerce = (FunctionType,
+                 type,
+                 type(len),       # <type 'builtin_function_or_method'>
+                 )
+    
+    sql_cmp_op = ('<', '<=', '=', '!=', '>', '>=', 'in', 'not in')
+    
+    def __init__(self, tablename, expr, adapter=AdapterToSQL):
+        self.tablename = tablename
+        self.expr = expr
+        self.adapter = adapter()
+        obj = expr.func
+        codewalk.LambdaDecompiler.__init__(self, obj)
+    
+    def code(self):
+        self.imperfect = False
+        self.walk()
+        # After walk(), self.stack should be reduced to a single string,
+        # which is the SQL representation of our Expression.
+        result = self.stack[0]
+        if result is cannot_represent:
+            # The entire expression could not be evaluated.
+            result = self.adapter.coerce(True)
+        return result
+    
+    def visit_target(self, terms):
+        """A target is an AND or OR test."""
+        comp = self.stack.pop()
+        while terms:
+            term, operation = terms.pop()
+            if term is not cannot_represent:
+                if comp is cannot_represent:
+                    comp = term
+                else:
+                    comp = "(%s) %s (%s)" % (term, operation.upper(), comp)
+        self.stack.append(comp)
+    
+    def visit_LOAD_DEREF(self, lo, hi):
+        raise ValueError("Illegal reference found in %s." % self.expr)
+    
+    def visit_LOAD_GLOBAL(self, lo, hi):
+        raise ValueError("Illegal global found in %s." % self.expr)
+    
+    def visit_LOAD_FAST(self, lo, hi):
+        if lo + (hi << 8) < self.co_argcount:
+            self.stack.append(table_arg)
+        else:
+            self.stack.append(kw_arg)
+    
+    def visit_LOAD_ATTR(self, lo, hi):
+        name = self.co_names[lo + (hi << 8)]
+        tos = self.stack.pop()
+        if tos is table_arg:
+            # Call another function to make subclassing easier.
+            self.stack.append(self.column_name(name))
+        else:
+            # tos.name will reference an attribute of the tos object.
+            # Stick the tos and name in a tuple for later processing.
+            self.stack.append((tos, name))
+    
+    def visit_LOAD_CONST(self, lo, hi):
+        val = self.co_consts[lo + (hi << 8)]
+        if not isinstance(val, self.no_coerce):
+            val = ConstWrapper(val, self.adapter.coerce(val))
+        self.stack.append(val)
+    
+    def visit_BUILD_TUPLE(self, lo, hi):
+        terms = ", ".join([self.stack.pop() for i in range(lo + hi << 8)])
+        self.stack.append("(" + terms + ")")
+    
+    visit_BUILD_LIST = visit_BUILD_TUPLE
+    
+    def visit_CALL_FUNCTION(self, lo, hi):
+        kwargs = {}
+        for i in range(hi):
+            val = self.stack.pop()
+            key = self.stack.pop()
+            kwargs[key] = val
+        kwargs = [k + "=" + v for k, v in kwargs.iteritems()]
+        
+        args = []
+        for i in range(lo):
+            arg = self.stack.pop()
+            args.append(arg)
+        args.reverse()
+        
+        if kwargs:
+            args += kwargs
+        
+        func = self.stack.pop()
+        
+        # Handle function objects.
+        if isinstance(func, tuple):
+            tos, name = func
+            dispatch = getattr(self, "attr_" + name, None)
+            if dispatch:
+                self.stack.append(dispatch(tos, *args))
+                return
+        else:
+            funcname = func.__module__ + "_" + func.__name__
+            funcname = funcname.replace(".", "_")
+            if funcname.startswith("_"):
+                funcname = "func" + funcname
+            dispatch = getattr(self, funcname, None)
+            if dispatch:
+                self.stack.append(dispatch(*args))
+                return
+        
+        if self.stack:
+            self.stack[-1] = cannot_represent
+        else:
+            self.stack = [cannot_represent]
+        self.imperfect = True
+    
+    def visit_COMPARE_OP(self, lo, hi):
+        op2, op1 = self.stack.pop(), self.stack.pop()
+        if op1 is cannot_represent or op2 is cannot_represent:
+            self.stack.append(cannot_represent)
+        else:
+            op = lo + (hi << 8)
+            if op in (6, 7):     # in, not in
+                value = self.containedby(op1, op2)
+                if op == 7:
+                    value = "NOT " + value
+                self.stack.append(value)
+            elif op1 == 'NULL':
+                if op == 2:
+                    self.stack.append(op2 + " IS NULL")
+                elif op == 3:
+                    self.stack.append(op2 + " IS NOT NULL")
+                else:
+                    raise ValueError("Non-equality Null comparisons not allowed.")
+            elif op2 == 'NULL':
+                if op == 2:
+                    self.stack.append(op1 + " IS NULL")
+                elif op == 3:
+                    self.stack.append(op1 + " IS NOT NULL")
+                else:
+                    raise ValueError("Non-equality Null comparisons not allowed.")
+            else:
+                # Comparison operators for strings are case-sensitive in PG et al.
+                self.stack.append(op1 + " " + self.sql_cmp_op[op] + " " + op2)
+    
+    def binary_op(self, op):
+        op2, op1 = self.stack.pop(), self.stack.pop()
+        self.stack.append(op1 + " " + op + " " + op2)
+    
+    def visit_BINARY_SUBSCR(self):
+        # The only BINARY_SUBSCR used in Expressions should be kwargs[key].
+        name = self.stack.pop()
+        tos = self.stack.pop()
+        if tos is not kw_arg:
+            raise ValueError("Subscript %s of %s object not allowed."
+                             % (name, tos))
+        # name, since formed in LOAD_CONST, may have extraneous quotes.
+        name = name.strip("'\"")
+        value = self.expr.kwargs[name]
+        value = self.adapter.coerce(value)
+        self.stack.append(value)
+    
+    def visit_UNARY_NOT(self):
+        op = self.stack.pop()
+        if op is cannot_represent:
+            self.stack.append(cannot_represent)
+        else:
+            self.stack.append("NOT (" + op + ")")
+    
+    
+    def column_name(self, name):
+        # This is valid SQL for PostgreSQL only and should be overridden.
+        return '"%s"."%s"' % (self.tablename, name)
+    
+    # --------------------------- Dispatchees --------------------------- #
+    
+    def attr_startswith(self, tos, arg):
+        return tos + " LIKE '" + arg.strip("'\"") + "%'"
+    
+    def attr_endswith(self, tos, arg):
+        return tos + " LIKE '%" + arg.strip("'\"") + "'"
+    
+    def containedby(self, op1, op2):
+        if isinstance(op1, ConstWrapper):
+            # Looking for text in a field. Use Like (reverse terms).
+            return op2 + " LIKE '%" + op1.strip("'\"") + "%'"
+        else:
+            # Looking for field in (a, b, c)
+            atoms = [self.adapter.coerce(x) for x in op2.basevalue]
+            return op1 + " IN (" + ", ".join(atoms) + ")"
+    
+    def dejavu_icontainedby(self, op1, op2):
+        if isinstance(op1, ConstWrapper):
+            # Looking for text in a field. Use Like (reverse terms).
+            return "LOWER(" + op2 + ") LIKE '%" + op1.strip("'\"").lower() + "%'"
+        else:
+            # Looking for field in (a, b, c).
+            # Force all args to lowercase for case-insensitive comparison.
+            atoms = [self.adapter.coerce(x).lower() for x in op2.basevalue]
+            return "LOWER(%s) IN (%s)" % (op1, ", ".join(atoms))
+    
+    def dejavu_icontains(self, x, y):
+        return self.dejavu_icontainedby(y, x)
+    
+    def dejavu_istartswith(self, x, y):
+        y = y.strip("'\"")
+        return "LOWER(" + x + ") LIKE '" + y + "%'"
+    
+    def dejavu_iendswith(self, x, y):
+        y = y.strip("'\"")
+        return "LOWER(" + x + ") LIKE '%" + y + "'"
+    
+    def dejavu_ieq(self, x, y):
+        return "LOWER(" + x + ") = LOWER(" + y + ")"
+    
+    def dejavu_now(self):
+        return "NOW()"
+    
+    def dejavu_today(self):
+        return "CURRENT_DATE"
+    
+    def dejavu_year(self, x):
+        return "YEAR(" + x + ")"
+    
+    def func__builtin___len(self, x):
+        return "LENGTH(" + x + ")"
+

trunk/storage/storeado.py

@@ -20 +20 @@
-
-import dejavu
-codewalk, 
+
-from dejavu.storage import db
-import recur
@@ -191 +191 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-    
-    def visit_COMPARE_OP(self, lo, hi):
@@ -346 +197 @@
-        op = lo + (hi << 8)
-        if op in (6, 7):     # in, not in
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-            if op == 7:
-not
+NOT
-            self.stack.append(value)
-            self.imperfect = True
@@ -385 +231 @@
-            self.stack.append(op1 + " " + self.sql_cmp_op[op] + " " + op2)
-    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
@@ -451 +333 @@
-                            col = self.colIndices['ID']
-                            ID = self.data[col][row]
-
-
-
-
+
+
+
-                        except pywintypes.com_error, x:
-
+1) 
-                            # was reserved but no table yet made for these
-
-
-
+
+
+
+
+
-                        else:
-                            if rs.BOF and rs.EOF:
-                                values = []
-                            else:
-
+
+
-                            rs.Close()
-
-
+    
+    
-                        # Set the attribute directly to avoid __set__ overhead.
-                        unit._properties[key] = values
@@ -561 +445 @@
-        self.connstring = allOptions[u'Connect']
-        self.CreateIfMissing = allOptions.get(u'Create If Missing', '')
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-        
-        self.prefix = allOptions.get(u'Prefix', u"djv")
@@ -598 +476 @@
-            self._connection.Close()
-    
+    def _get_conn(self):
+        conn = win32com.client.Dispatch(r'ADODB.Connection')
+        try:
+            conn.Open(self.connstring)
+        except pywintypes.com_error, x:
+            if x.args[2][5] == -2147467259 and self.CreateIfMissing:
+                self.create_database()
+                conn.Open(self.connstring)
+            else:
+                raise
+        return conn
+    
-    def connection(self):
-        if self.threaded:
-            t = threading.currentThread()
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-            return self._connection
-    
@@ -704 +587 @@
-    
-    def where(self, cls, expr):
-
+
+
-    
-    def execute(self, aQuery, conn=None):
@@ -796 +680 @@
-            pass
-        
-        # Ugly, ugly hack to get NTEXT or MEMO as appropriate. The point
-        # is, we want a large text field so we can pickle each item.
-        ftype = self.createAdapter.coerce_list(unitcls, key)
-        self.execute(u"CREATE TABLE %s (EXPVAL %s);" % (table, ftype), conn)
-        
-        ins = u"INSERT INTO " + table + " (EXPVAL) VALUES ('%s');"
-        val = getattr(unit, key)
-
+
+
+
+
+
+
+
+
+
+
+
-            for v in val:
-                # Create a row for the unit.
@@ -906 +794 @@
-        # This method hasn't been tested yet for SQL server.
-        adoconn = win32com.client.Dispatch(r'ADODB.Connection')
-
+
+
+
+
+
+
+
-        adoconn.Execute("CREATE DATABASE %s" % self.DBName)
-
@@ -919 +813 @@
-class ADOSQLDecompiler_MSAccess(ADOSQLDecompiler):
-    sql_cmp_op = ('<', '<=', '=', '<>', '>', '>=', 'in', 'not in')
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-
-
@@ -952 +845 @@
-    
-    def create_database(self):
+        # By not providing an Engine Type, it defaults to 5 = Access 2000.
-        cat = win32com.client.Dispatch(r'ADOX.Catalog')
-        cat.Create(self.connstring)
+    
+    def drop_database(self):
+        atoms = dict([pair.upper().split("=", 1)
+                      for pair in self.connstring.split(";")
+                      if pair])
+        dbname = atoms.get("DATA SOURCE") or atoms.get("DATA SOURCE NAME")
+        import os
+        # This should accept relative or absolute paths
+        os.remove(dbname)
-
-

trunk/storage/storemysql.py

@@ -15 +15 @@
-import threading
-import datetime
-try:
-    import cPickle as pickle
-except ImportError:
-    import pickle
-from types import FunctionType
-
-try:
-    import fixedpoint
-except ImportError:
-    pass
-
-import dejavu
-codewalk, 
+
-from dejavu.storage import db
-import recur
-
-
@@ -36 +25 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
@@ -303 +119 @@
-        return u"LONGBLOB"
-    
-
+
+
-
-
@@ -309 +126 @@
-    """StoreManager to save and retrieve Units via _mysql ."""
-    
-    decompiler = MySQLDecompiler
-    createAdapter = FieldTypeAdapterMySQL()
-    threaded = False
@@ -325 +141 @@
-        
-        self.CreateIfMissing = allOptions.get(u'Create If Missing', '')
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-        
-        self.prefix = allOptions.get(u'Prefix', u"djv")
-        self.reserve_lock = threading.Lock()
+        
+        self.decompiler = MySQLDecompiler
+        # Try to get the version string from MySQL, to see if we need
+        # a different decompiler.
+        try:
+            res = self.execute("SELECT VERSION();")
+            if res.num_rows():
+                version = storage.Version(res.fetch_row(1, 0)[0][0])
+                if version > storage.Version("4.1.1"):
+                    self.decompiler = MySQLDecompiler411
+        except:
+            pass
-    
-    def identifier(self, *atoms):
@@ -354 +172 @@
-    
-    def shutdown(self):
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-    def connection(self):
-        if self.threaded:
-            t = threading.currentThread()
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-            return self._connection
-    
@@ -377 +207 @@
-        tmplconn['db'] = ''
-        conn = _mysql.connect(**tmplconn)
-
+;
-                     self.identifier(self.connargs['db']), conn)
-        conn.close()
+    
+    def drop_database(self):
+        self.execute("DROP DATABASE %s;" %
+                     self.identifier(self.connargs['db']))
-    
-    def select(self, unitClass, expr, distinct_fields=None):
@@ -398 +232 @@
-    
-    def where(self, cls, expr):
-
+
+
+
-    
-    def execute(self, query, conn=None):

trunk/storage/storeodbc.py

@@ -3 +3 @@
-"""
-
-
+
+
+
+
-import datetime
-
-
+
+
+
+
+
-
-import dejavu
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-    """Transform Expression values according to their type for ODBC SQL."""
-    
-    def to_str(self, value):
-        return str(value)
-    
-    def coerce_NoneType(self, value):
-        return "Null"
-    
-    def coerce_bool(self, value):
-        if value:
-            return 'True'
-        return 'False'
-    
-    def coerce_datetime_datetime(self, value):
@@ -107 +34 @@
-    def coerce_datetime_time(self, value):
-        return u"{t '%s'}" % value.strftime('%H:%M:%S')
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
@@ -258 +55 @@
-    """Iterator for populating Units from storage."""
-    
-
-
-
-
-
-
+
-        self.store  = store
-        self.unitClass = unitClass
-        self.expr = expr
-        self.server = server
-        self.colIndices = {}
-        self.fieldTypes = []
-        
-        self.sql, self.imperfect = store.select(unitClass, expr)
-    
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    def load_data(self):
-        anRS = self.store.recordset(self.sql)
@@ -305 +111 @@
-                    unit = self.unitClass(server.namespace)
-                    self.populate_unit(unit, row)
-                    cache.store(unit)
-                else:
-                    unit = unit[0]
-                # If our SQL is imperfect, it's OK to ask our server
-                # to accept() our new Unit, but don't yield it to the
-                # caller unless it passes evaluate().
-                if (not self.imperfect) or self.expr.evaluate(unit):
-                    yield unit
-
-
-class CollectionIteratorODBC(StoreIteratorODBC):
-    """Iterator for populating Unit Collections from storage."""
-    
-    storageManager = None
-    
-    def load_collection(self, unit):
-        # Grab the data dictionary (list of Unit ID's)
-        rsource = (u"SELECT ID FROM %s__%s" % 
-                  (self.storageManager.prefix, safe_name(unit.ID)))
-        dataRS = self.storageManager.recordset(rsource)
-        while 1:
-            data = dataRS.fetchone()
-            if data is None:
-                break
-            fieldNames = [x[0] for x in dataRS.description]
-            datadict = dict(zip(fieldNames, data))
-            unit[unicode(datadict(u'id'))] = None
-        dataRS.close()
-    
-    def units(self):
-        self.load_data()
-        if len(self.data) > 0:
-            server = self.server
-            cache = server.cache(self.unitClass)
-            for row in self.data:
-                # Notice odbc field names are lower case.
-                ID = unicode(row[self.colIndices[u'id']])
-                # Search the cache to see if we've already attached this unit.
-                # Use has_key() instead of 'is' or '==' because the Unit may
-                # have changed its _properties since the last load.
-                unit = cache['ID'].get(ID, None)
-                if unit is None:
-                    unit = self.unitClass(server.namespace)
-                    self.populate_unit(unit, row)
-                    self.load_collection(unit)
-                    cache.store(unit)
-                else:
@@ -485 +246 @@
-                       bool: lambda x, y: u"BIT",
-                       }
+
+
+class StorageManagerPgSQL(storage.StorageManager):
+    """StoreManager to save and retrieve Units via pyPgSQL 1.35."""
+    
+    decompiler = PgSQLDecompiler
+    createAdapter = db.FieldTypeAdapter()
+    
+    def __init__(self, name, arena, allOptions={}):
+        storage.StorageManager.__init__(self, name, arena, allOptions)
+        
+        # connstring = (host=h port=p dbname=d user=u password=p options=o tty=t)
+        self.connstring = allOptions[u'Connect']
+        atoms = self.connstring.split(" ")
+        for atom in atoms:
+            k, v = atom.split("=", 1)
+            setattr(self, k, v)
+        self.CreateIfMissing = allOptions.get(u'Create If Missing', '')
+        self.threaded = bool(allOptions.get(u'Threaded', '1'))
+        self._connection = None
+        
+        self.prefix = allOptions.get(u'Prefix', u"djv")
+        self.reserve_lock = threading.Lock()
+    
+    def identifier(self, *atoms):
+        ident = '"' + ''.join(map(str, atoms)).replace('"', '""') + '"'
+        if len(ident) > 63:
+            warnings.warn("Identifier is longer than 63 characters. Most "
+                          "installations of Postgres are limited to 63. "
+                          "See NAMEDATALEN.")
+        return ident
+    
+    def shutdown(self):
+        if self.threaded:
+            t = threading.currentThread()
+            conn = getattr(t, "dejavu_storage_connection", None)
+            if conn is not None:
+                conn.finish()
+        else:
+            if self._connection is not None:
+                self._connection.finish()
+    
+    def _get_conn(self):
+        try:
+            conn = libpq.PQconnectdb(self.connstring)
+        except Exception, x:
+            if self.CreateIfMissing:
+                self.create_database()
+                conn = libpq.PQconnectdb(self.connstring)
+            else:
+                raise
+        return conn
+    
+    def connection(self):
+        if self.threaded:
+            t = threading.currentThread()
+            if not hasattr(t, 'dejavu_storage_connection'):
+                t.dejavu_storage_connection = self._get_conn()
+            return t.dejavu_storage_connection
+        else:
+            if self._connection is None:
+                self._connection = self._get_conn()
+            return self._connection
+    
+    def _template_conn(self):
+        atoms = self.connstring.split(" ")
+        tmplconn = ""
+        for atom in atoms:
+            k, v = atom.split("=", 1)
+            if k == 'dbname': v = 'template1'
+            tmplconn += "%s=%s " % (k, v)
+        return libpq.PQconnectdb(tmplconn)
+    
+    def create_database(self):
+        self.execute('CREATE DATABASE %s' % self.identifier(self.dbname),
+                     self._template_conn())
+    
+    def drop_database(self):
+        self.execute("DROP DATABASE %s;" % self.identifier(self.dbname),
+                     self._template_conn())
+    
+    def select(self, unitClass, expr, distinct_fields=None):
+        tablename = self.identifier(self.prefix, unitClass.__name__)
+        if distinct_fields:
+            distinct_fields = [self.identifier(x) for x in distinct_fields]
+            sql = (u'SELECT DISTINCT %s FROM %s' %
+                   (u', '.join(distinct_fields), tablename))
+        else:
+            sql = u'SELECT * FROM %s' % tablename
+        w, i = self.where(unitClass, expr)
+        if len(w) > 0:
+            w = u" WHERE " + w
+        else:
+            w = u""
+        sql += w
+        return sql, i
+    
+    def where(self, cls, expr):
+        decom = self.decompiler(self.prefix + cls.__name__, expr)
+        return decom.code(), decom.imperfect
+    
+    def execute(self, query, conn=None):
+        if conn is None:
+            conn = self.connection()
+        try:
+            return conn.query(query)
+        except Exception, x:
+            x.args += (query,)
+            raise x
+    
+    def recall(self, cls, expr=None, pairs=None):
+        if expr is None:
+            expr = logic.Expression(lambda x: True)
+        return StoreIteratorPgSQL(self, cls, expr).units()
+    
+    def reserve(self, unit):
+        """reserve(unit). -> Reserve a persistent slot for unit.
+        
+        Notice in particular that we do not use the auto-number or
+        sequence generation capabilities within some databases, etc.
+        The ID should be supplied by UnitSequencers via reserve().
+        """
+        clsname = unit.__class__.__name__
+        tblname = self.identifier(self.prefix, clsname)
+        id = self.identifier("ID")
+        self.reserve_lock.acquire()
+        try:
+            if unit.ID is None:
+                data = []
+                res = self.execute(u'SELECT %s FROM %s;' % (id, tblname))
+                if res.resultType != libpq.EMPTY_QUERY:
+                    data = [res.getvalue(row, 0) for row in xrange(res.ntuples)]
+                unit.ID = unit.sequencer.next(data)
+            
+            self.execute('INSERT INTO %s (%s) VALUES (%s)' %
+                         (tblname, id, AdapterToPgSQL.coerce(unit.ID)))
+        finally:
+            self.reserve_lock.release()
+    
+    def save(self, unit, forceSave=False):
+        """save(unit, forceSave=False) -> Update storage from unit's data."""
+        if unit.dirty() or forceSave:
+            cls = unit.__class__
+            clsname = cls.__name__
+            tablename = self.identifier(self.prefix, clsname)
+            
+            parms = []
+            for key in cls.properties():
+                if key != "ID":
+                    val = AdapterToPgSQL.coerce(getattr(unit, key))
+                    parms.append('%s = %s' % (self.identifier(key), val))
+            sql = ('UPDATE %s SET %s WHERE %s = %s' %
+                   (tablename, u", ".join(parms),
+                    self.identifier("ID"),
+                    AdapterToPgSQL.coerce(unit.ID, cls.property_type("ID"))))
+            self.execute(sql)
+            unit.cleanse()
+    
+    def destroy(self, unit):
+        """Delete the unit."""
+        # Use a DELETE command instead of a cursor for better performance.
+        deleteStatement = (u'DELETE * FROM %s WHERE %s = %s' %
+                           (self.identifier(self.prefix, unit.__class__.__name__),
+                            self.identifier("ID"),
+                            AdapterToPgSQL.coerce(unit.ID)))
+        self.execute(deleteStatement)
-    
-    def create_storage(self, unitClass):
+        tblname = self.identifier(self.prefix, unitClass.__name__)
+        
+        coerce = self.createAdapter.coerce
-        fields = []
-
-
-
-
-
-
-
-
+
+
+
-        try:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

trunk/storage/storepypgsql.py

@@ -5 +5 @@
-import threading
-import datetime
-try:
-    import cPickle as pickle
-except ImportError:
-    import pickle
-from types import FunctionType
-
-try:
-    import fixedpoint
-except ImportError:
-    pass
-
-import dejavu
-codewalk, 
+
-from dejavu.storage import db
-import recur
-
-
-AdapterToPgSQL = db.AdapterToSQL()
-AdapterFromPg = db.AdapterFromDB
-
-
-def containedby(op1, op2, notin=False):
-    if isinstance(op1, db.ConstWrapper):
-        # Looking for text in a field. Use Like (reverse terms).
-        value = op2 + " LIKE '%" + op1[1:-1] + "%'"
-    else:
-        # Looking for field in (a, b, c)
-        atoms = [AdapterToPgSQL.coerce(x) for x in op2.basevalue]
-        value = op1 + " IN (" + ", ".join(atoms) + ")"
-    if notin:
-        value = "NOT " + value
-    return value
-
-def icontainedby(op1, op2, notin=False):
-    if isinstance(op1, db.ConstWrapper):
-        # Looking for text in a field. Use Like (reverse terms).
-        value = op2 + " ILIKE '%" + op1[1:-1] + "%'"
-    else:
-        # Looking for field in (a, b, c)
-        atoms = [AdapterToPgSQL.coerce(x).lower() for x in op2.basevalue]
-        value = "LOWER(" + op1 + ") IN (" + ", ".join(atoms) + ")"
-    if notin:
-        value = "NOT " + value
-    return value
-
-
-# Stack sentinels
-cannot_represent = object()
-table_arg = object()
-kw_arg = object()
-
-class PgSQLDecompiler(codewalk.LambdaDecompiler):
-    """PgSQLDecompiler(store, unitClass, expr, adapter=AdapterToPgSQL).
-    
-    Produce SQL from a supplied Expression object, with a lambda of the form:
-        lambda x, **kw: ...
-    
-    Attributes of x (or whatever the name of the first argument is) will be
-    mapped to table columns. Keyword arguments should be bound to the
-    Expression before calling this decompiler.
-    """
-    
-    sql_cmp_op = ('<', '<=', '=', '!=', '>', '>=', 'in', 'not in')
-    functions = {dejavu.icontains: lambda x, y: x + " ILIKE '%" + y[1:-1] + "%'",
-                 dejavu.icontainedby: icontainedby,
-                 dejavu.istartswith: lambda x, y: x + " ILIKE '" + y[1:-1] + "%'",
-                 dejavu.iendswith: lambda x, y: x + " ILIKE '%" + y[1:-1] + "'",
-                 # This is a test of ILIKE with no wildcards,
-                 # to see if it behaves like ieq.
-                 dejavu.ieq: lambda x, y: x + " ILIKE " + y,
-                 dejavu.now: lambda: "now()",
-                 dejavu.today: lambda: "CURRENT_DATE",
-                 dejavu.year: lambda x: "date_part('year', " + x + ")",
-                 len: lambda x: "length(" + x + ")",
-                 }
-    
-    def __init__(self, store, unitClass, expr, adapter=AdapterToPgSQL):
-        self.tablename = store.prefix + unitClass.__name__
-        self.expr = expr
-        self.adapter = adapter
-        obj = expr.func
-        codewalk.LambdaDecompiler.__init__(self, obj)
-    
-    def code(self):
-        self.imperfect = False
-        self.walk()
-        result = self.stack[0]
-        if result is cannot_represent:
-            result = 'TRUE'
-        return result, self.imperfect
-    
-    def visit_target(self, terms):
-        """A target is an AND or OR test."""
-        comp = self.stack.pop()
-        while terms:
-            term, operation = terms.pop()
-            # All this checking of cannot_represent is done so that a
-            # function can be labeled imperfect. For example, the function
-            # dejavu.iscurrentweek has no PG SQL equivalent. All Units
-            # (which match the rest of the Expression) will be recalled.
-            # They can then be compared in expr.evaluate(unit).
-            if term is not cannot_represent:
-                if comp is cannot_represent:
-                    comp = term
-                else:
-                    comp = "(%s) %s (%s)" % (term, operation.upper(), comp)
-        self.stack.append(comp)
-    
-    def visit_LOAD_DEREF(self, lo, hi):
-        raise ValueError("Illegal reference found in %s." % self.expr)
-    
-    def visit_LOAD_GLOBAL(self, lo, hi):
-        raise ValueError("Illegal global found in %s." % self.expr)
-    
-    def visit_LOAD_FAST(self, lo, hi):
-        if lo + (hi << 8) < self.co_argcount:
-            self.stack.append(table_arg)
-        else:
-            self.stack.append(kw_arg)
-    
-    def visit_LOAD_ATTR(self, lo, hi):
-        name = self.co_names[lo + (hi << 8)]
-        tos = self.stack.pop()
-        if tos is table_arg:
-            self.stack.append('"%s"."%s"' % (self.tablename, name))
-        else:
-            self.stack.append((tos, name))
-    
-    def visit_LOAD_CONST(self, lo, hi):
-        val = self.co_consts[lo + (hi << 8)]
-        # Some constants are function or class objects,
-        # which should not be coerced.
-        no_coerce = (FunctionType, type,
-                     type(len),       # <type 'builtin_function_or_method'>
-                     )
-        if not isinstance(val, no_coerce):
-            val = db.ConstWrapper(val, self.adapter.coerce(val))
-        self.stack.append(val)
-    
-    def visit_BUILD_TUPLE(self, lo, hi):
-        terms = ", ".join([self.stack.pop() for i in range(lo + hi << 8)])
-        self.stack.append("(" + terms + ")")
-    
-    visit_BUILD_LIST = visit_BUILD_TUPLE
-    
-    def visit_CALL_FUNCTION(self, lo, hi):
-        kwargs = {}
-        for i in range(hi):
-            val = self.stack.pop()
-            key = self.stack.pop()
-            kwargs[key] = val
-        kwargs = [k + "=" + v for k, v in kwargs.iteritems()]
-        
-        args = []
-        for i in range(lo):
-            arg = self.stack.pop()
-            args.append(arg)
-        args.reverse()
-        
-        if kwargs:
-            args += kwargs
-        
-        func = self.stack.pop()
-        
-        # Handle function objects.
-        if func in self.functions:
-            self.stack.append(self.functions[func](*args))
-        else:
-            if isinstance(func, tuple):
-                tos, func = func
-                if func == "startswith":
-                    self.stack.append(tos + " LIKE '" + args[0][1:-1] + "%'")
-                    return
-                elif func == "endswith":
-                    self.stack.append(tos + " LIKE '%" + args[0][1:-1] + "'")
-                    return
-                return
-            
-            if self.stack:
-                self.stack[-1] = cannot_represent
-            else:
-                self.stack = [cannot_represent]
-            self.imperfect = True
-    
-    def visit_COMPARE_OP(self, lo, hi):
-        op2, op1 = self.stack.pop(), self.stack.pop()
-        op = lo + (hi << 8)
-        if op in (6, 7):     # in, not in
-            self.stack.append(containedby(op1, op2, op == 7))
-            self.imperfect = True
-        elif op1 == 'NULL':
-            if op == 2:
-                self.stack.append(op2 + " IS NULL")
-            elif op == 3:
-                self.stack.append(op2 + " IS NOT NULL")
-            else:
-                raise ValueError("Non-equality Null comparisons not allowed.")
-        elif op2 == 'NULL':
-            if op == 2:
-                self.stack.append(op1 + " IS NULL")
-            elif op == 3:
-                self.stack.append(op1 + " IS NOT NULL")
-            else:
-                raise ValueError("Non-equality Null comparisons not allowed.")
-        else:
-            # Comparison operators for strings are case-sensitive in PG.
-            self.stack.append(op1 + " " + self.sql_cmp_op[op] + " " + op2)
-    
-    def binary_op(self, op):
-        op2, op1 = self.stack.pop(), self.stack.pop()
-        self.stack.append(op1 + " " + op + " " + op2)
-    
-    def visit_BINARY_SUBSCR(self):
-        # The only BINARY_SUBSCR used in Expressions should be kwargs[key].
-        name = self.stack.pop()
-        tos = self.stack.pop()
-        if tos is not kw_arg:
-            raise ValueError(tos, name)
-        # name, since formed in LOAD_CONST, has extraneous single-quotes.
-        name = name[1:-1]
-        value = self.expr.kwargs[name]
-        value = self.adapter.coerce(value)
-        self.stack.append(value)
-    
-    def visit_UNARY_NOT(self):
-        op = self.stack.pop()
-        if op is cannot_represent:
-            # Usually as a result of has(farClassName).
-            self.stack.append(cannot_represent)
-        else:
-            self.stack.append("NOT (" + op + ")")
-
-
@@ -274 +51 @@
-
-
+class PgSQLDecompiler(db.SQLDecompiler):
+    
+    def dejavu_icontainedby(self, op1, op2):
+        if isinstance(op1, db.ConstWrapper):
+            # Looking for text in a field. Use ILike (reverse terms).
+            return op2 + " ILIKE '%" + op1.strip("'\"") + "%'"
+        else:
+            # Looking for field in (a, b, c).
+            # Force all args to lowercase for case-insensitive comparison.
+            atoms = [self.adapter.coerce(x).lower() for x in op2.basevalue]
+            return "LOWER(%s) IN (%s)" % (op1, ", ".join(atoms))
+    
+    def dejavu_istartswith(self, x, y):
+        return x + " ILIKE '" + y.strip("'\"") + "%'"
+    
+    def dejavu_iendswith(self, x, y):
+        return x + " ILIKE '%" + y.strip("'\"") + "'"
+    
+    def dejavu_ieq(self, x, y):
+        # ILIKE with no wildcards should behave like ieq.
+        return x + " ILIKE " + y
+    
+    def dejavu_year(self, x):
+        return "date_part('year', " + x + ")"
+
+
+
-class StorageManagerPgSQL(storage.StorageManager):
-    """StoreManager to save and retrieve Units via pyPgSQL 1.35."""
@@ -279 +83 @@
-    decompiler = PgSQLDecompiler
-    createAdapter = db.FieldTypeAdapter()
-    threaded = False
-    
-    def __init__(self, name, arena, allOptions={}):
@@ -291 +94 @@
-            setattr(self, k, v)
-        self.CreateIfMissing = allOptions.get(u'Create If Missing', '')
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-        
-        self.prefix = allOptions.get(u'Prefix', u"djv")
@@ -316 +109 @@
-    
-    def shutdown(self):
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-    def connection(self):
-        if self.threaded:
-            t = threading.currentThread()
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-            return self._connection
-    
-create_database
+_template_conn
-        atoms = self.connstring.split(" ")
-        tmplconn = ""
@@ -342 +147 @@
-            if k == 'dbname': v = 'template1'
-            tmplconn += "%s=%s " % (k, v)
-
-
+
+
+
+
+
+
+
+
+
-    
-    def select(self, unitClass, expr, distinct_fields=None):
@@ -362 +174 @@
-    
-    def where(self, cls, expr):
-
+
+
-    
-    def execute(self, query, conn=None):

trunk/storage/storeshelve.py

@@ -1 @@
-.path
+
-import shelve
-import threading
@@ -10 +10 @@
-    """StoreManager to save and retrieve Units via stdlib shelve."""
-    
-    shelvepath = None
-    
-    # A dictionary whose keys are classnames and whose
-    # values are objects returned by shelve.open().
-    shelves = {}
-    
-    def __init__(self, name, arena, allOptions={}):
-        storage.StorageManager.__init__(self, name, arena, allOptions)
-        self.shelvepath = allOptions['Path']
+        
+        # A dictionary whose keys are classnames and whose
+        # values are objects returned by shelve.open().
-        self.shelves = {}
+        
-        self.locks = {}
-    
@@ -60 +58 @@
-        try:
-            if unit.ID is None:
-
+
+
-            data[str(unit.ID)] = unit._properties
-        finally:
@@ -84 +83 @@
-            lock.release()
-    
+    def create_database(self):
+        pass
+    
+    def drop_database(self):
+        for clsname, shelf in self.shelves.iteritems():
+            shelf.close()
+            tbl = os.path.join(self.shelvepath, clsname)
+            os.remove(tbl)
+    
-    def create_storage(self, unitClass):
-        pass

trunk/storage/test_storeado.py

@@ -1 @@
-
-
-
-
-
-
+
+
-
+if __name__ == '__main__':
+    # Microsoft Access
+    opts = {u'Connect': "PROVIDER=MICROSOFT.JET.OLEDB.4.0;DATA SOURCE=zoo.mdb;",
+            u'Expanded Columns': "Animal.PreviousZoos",
+            u'Create If Missing': True,
+            }
-
-conn = "PROVIDER=MICROSOFT.JET.OLEDB.4.0;DATA SOURCE=zoo.mdb;"
-smOptions = {u'Connect': conn,
-             u'Expanded Columns': "Animal.Options",
-             u'Create If Missing': True,
-             }
-testSM = storeado.StorageManagerADO_MSAccess("test", zoo.arena, smOptions)
-zoo.arena.add_store('testSM', testSM)
-
-for cls in (zoo.Animal, zoo.Zoo, zoo.Exhibit):
-    try:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+

trunk/storage/test_storemysql.py

@@ -1 @@
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-    dbname = raw_input("Database name [dejavu_test]:") or "dejavu_test"
-    pword = raw_input("Password for the root user:")
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-    
-
-
+
+
+
+
-        try:
-
-
-
-
-
-
-
-
-
-
+
+
+
+

trunk/storage/test_storeodbc.py

@@ -1 @@
-
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
-    
-
-
-
-
-
-
-
+
+
+
+
-    
-
+
+
+
+
+
-        try:
-execute("DROP TABLE djvThings"
-dbi.prog
+drop_database(
+Name
-            pass
-        testSM.create_storage(Things)
-    
-    def test_recordset(self):
-        rs = testSM.recordset("SELECT * FROM [djvAnimals]")
-        data = rs.fetchall()
-        # Assert num columns == 4
-        self.assertEqual(len(data), 4)
-        # Assert num rows == 3
-        self.assertEqual(len(data[0]), 3)
-    
-    def test_max_id(self):
-        self.assertEqual(testSM.max_id(Animals), 4)
-        self.test_create_storage()
-        self.assertEqual(testSM.max_id(Things), 0)
-    
-    def test_unit_roundtrip(self):
-        """Assert that a Unit can be loaded and saved."""
-        e = logic.Expression(lambda x: x.Name == 'Cat')
-        it = testSM.loader(testServer, Animals, e)
-        self.assertEqual(it.sql, "SELECT * FROM [djvAnimals] WHERE [Name] = 'Cat'")
-        u = [x for x in it.units()]
-        self.assertEqual(len(u), 1)
-        cat = u[0]
-        self.assertEqual(cat.Name, 'Cat')
-        legs = cat.Legs + 1
-        if legs > 10:
-            legs = 4
-        cat.Legs = legs
-        testSM.save(cat, True)
-        
-        # Now, do the whole thing again to see if our save worked.
-        testServer.forget(cat, False)
-        it = testSM.loader(testServer, Animals, e)
-        u = [x for x in it.units()]
-        self.assertEqual(len(u), 1)
-        cat = u[0]
-        self.assertEqual(cat.Name, 'Cat')
-        self.assertEqual(cat.Legs, legs)
-
-
-class ExpressionTests(unittest.TestCase):
-    
-    def test_Adapter(self):
-        adapter = storeodbc.AdapterToODBCSQL()
-        pairs = [(3, '3'),
-                 (3.1, '3.1'),
-                 (fixedpoint.FixedPoint(5.2, 3), '5.200'),
-                 (u'down the Stra\u00DFe', u"'down the Stra\u00DFe'"),
-                 ('a salted peanut', "'a salted peanut'"),
-                 (datetime.datetime(2001, 11, 15, 14, 15, 16),
-                  "{ts '2001-11-15 14:15:16'}"),
-                 (datetime.date(2001, 11, 15), "{d '2001-11-15'}"),
-                 (datetime.time(6, 30), "{t '06:30:00'}"),
-                 (True, 'True'),
-                 (None, 'Null'),
-                 ]
-        for initial, final in pairs:
-            self.assertEqual(adapter.coerce(initial), final)
-    
-    def test_Decompiler(self):
-        def trial(lam, sql, imperfect):
-            e = logic.Expression(lam)
-            decom = storeodbc.ODBCSQLDecompiler(e)
-            self.assertEqual(decom.code(), (sql, imperfect))
-        trial(lambda x: x.Date == 3, "[Date] = 3", False)
-        trial(lambda x, **kw: (x.a == 3) and ((x.b > 1) or (x.b < -10)),
-              u'([a] = 3) and (([b] > 1) or ([b] < -10))', False)
-        trial(lambda x, **kw: (x.Group == 3) and not (x.Name.startswith("_"))
-              and not (x.Name.endswith('test')),
-              u"([Group] = 3) and ((not ([Name] Like '_%')) "
-              u"and (not ([Name] Like '%test')))", True)
-        trial(lambda x: (x.Group == '3') and (x.Date > datetime.date(2004, 2, 14)),
-              u"([Group] = '3') and ([Date] > {d '2004-02-14'})", True)
-        
-        # In operator
-        trial(lambda x: 'tool' in x.Name or 'tool' in x.Content,
-              u"([Name] Like '%tool%') or ([Content] Like '%tool%')", True)
-        trial(lambda x: x.Name in ('Johann', 'Gambolputty', 'de von Ausfern'),
-              u"[Name] in ('Johann', 'Gambolputty', 'de von Ausfern')", True)
-        # Try In with cell references
-        pet, pet2 = Animals(), Animals()
-        pet.Name, pet2.Name = 'Pony', 'Iguana'
-        trial(lambda x: x.Name in (pet.Name, pet2.Name),
-              u"[Name] in ('Pony', 'Iguana')", True)
-        
-        # logic functions
-        trial(lambda x: dejavu.ieq(x.Name, 'Johann'), u"[Name] = 'Johann'", False)
-        trial(lambda x: dejavu.icontains(x.Name, 'tool'), u"[Name] Like '%tool%'", False)
-        trial(lambda x: dejavu.icontainedby(x.Name, ('Johann', 'Gambolputty', 'de von Ausfern')),
-              u"[Name] in ('Johann', 'Gambolputty', 'de von Ausfern')", False)
-
-
-if __name__ == "__main__":
-    unittest.main()
-

trunk/storage/test_storepypgsql.py

@@ -1 @@
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-    dbname = raw_input("Database name [dejavu_test]:") or "dejavu_test"
-    pword = raw_input("Password for the postgres user:")
-
-
-
-
-
-
+
+
+
+
-    
-
-
+
+
+
+
+
-        try:
-
-
-
-
-
-
-
-
-
+
+
+
-

trunk/storage/test_storeshelve.py

@@ -1 @@
-
-
+
-
-
+
+
+
+
-
-
-
-
+
+
-
-
-
+
+
-    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+

trunk/zoo.py

@@ -21 +21 @@
-    ZooID = UnitProperty(int, index=True)
-    Legs = UnitProperty(int)
-Options = UnitProperty(dic
+PreviousZoos = UnitProperty(lis
-    LastEscape = EscapeProperty(datetime.datetime)
-