Changeset 65

Timestamp:

04/09/07 18:06:49

Author:

fumanchu

Message:

Moved adapters.AdapterSet? to dbtypes.DatabaseTypeSet?.

Files:

• trunk/geniusql/adapters.py (modified) (2 diffs)
• trunk/geniusql/dbtypes.py (modified) (5 diffs)
• trunk/geniusql/decompile.py (modified) (6 diffs)
• trunk/geniusql/objects.py (modified) (5 diffs)
• trunk/geniusql/providers/ado.py (modified) (2 diffs)
• trunk/geniusql/providers/msaccess.py (modified) (4 diffs)
• trunk/geniusql/providers/postgres.py (modified) (6 diffs)
• trunk/geniusql/providers/sqlserver.py (modified) (4 diffs)
• trunk/geniusql/select.py (modified) (2 diffs)
• trunk/geniusql/test/test_msaccess.py (modified) (1 diff)
• trunk/geniusql/test/zoo_fixture.py (modified) (1 diff)

trunk/geniusql/adapters.py

@@ -36 +36 @@
-    import pickle
-
-
-
-
-
+
+
-
-import sys
@@ -57 +55 @@
-del L, sys
-
-import warnings
-
-from geniusql import errors, typerefs
-
-
-# ----------------------------- Adapter Sets ----------------------------- #
-
-
-def getCoerceName(pytype):
-    """Return the name of the coercion method for a given Python type."""
-    mod = pytype.__module__
-    if mod == "__builtin__":
-        xform = "%s" % pytype.__name__
-    else:
-        xform = "%s_%s" % (mod, pytype.__name__)
-    xform = xform.replace(".", "_")
-    return xform
-
-
-class AdapterSet(object):
-    """Determine the best database type for a given column + Python type.
-    
-    When Geniusql is asked to create database tables, it must choose an
-    appropriate column data type for each UnitProperty based on the
-    type (and hints) of that property. This class recommends such
-    database types by returning a new instance of DatabaseType.
-    """
-    
-    known_types = None
-    
-    # You should REALLY check into your DB's encoding and override this.
-    encoding = 'utf8'
-    
-    def __copy__(self):
-        newset = self.__class__()
-        newset.update(self)
-        newset.known_types = self.known_types.copy()
-        return newset
-    copy = __copy__
-    
-    def canonicalize(self, dbtypename):
-        """Return the canonical DatabaseType for the given synonym.
-        
-        In order to avoid large amounts of code (in each provider module!)
-        that merely looks up synonyms, database types MUST be
-        canonicalized for all Column and SQLExpression objects.
-        """
-        for typeset in self.known_types.itervalues():
-            for dbtype in typeset:
-                if (dbtypename == dbtype.__name__
-                    or dbtypename in dbtype.synonyms):
-                    return dbtype
-        raise KeyError("No canonical name found for %r." % dbtypename)
-    
-    def default(self, pytype, dbtype=None):
-        """Return a default adapter instance for the given pytype, dbtype."""
-        if dbtype is None:
-            dbtype = self.database_type(pytype)
-        
-        ptypes = [pytype, None]
-        for base in pytype.__bases__:
-            ptypes.append(base)
-        
-        for p in ptypes:
-            if p in dbtype.default_adapters:
-                return dbtype.default_adapters[p]
-        
-        raise TypeError("%s has no default adapter for %s. Looked for: %s" %
-                        (dbtype, pytype, "\n".join([repr(x) for x in ptypes])))
-    
-    
-    # ------------------------- Database types ------------------------- #
-    
-    def database_type(self, pytype, hints=None):
-        """Return a DatabaseType instance for the given Python type.
-        
-        hints: if provided, this should be a dict of property attributes
-            which can be used to distinguish between similar database types.
-            Canonical keys include 'bytes', 'precision', and 'scale'.
-        """
-        xform = "dbtype_for_" + getCoerceName(pytype)
-        try:
-            xform = getattr(self, xform)
-        except AttributeError:
-            raise TypeError("%r is not handled by %s. Tried %r" %
-                            (pytype, self.__class__, xform))
-        if hints is None:
-            hints = {}
-        return xform(hints)
-    
-    def dbtype_for_float(self, hints):
-        """Return a DatabaseType for floats of the given binary precision."""
-        # Note that 'precision' is binary digits, not decimal.
-        precision = int(hints.get('precision', maxfloat_digits))
-        if precision == 0:
-            # Use the maximum precision.
-            precision = max([0] + [dbtype.max_precision
-                                   for dbtype in self.known_types['float']])
-        for dbtype in self.known_types['float']:
-            if precision <= dbtype.max_precision:
-                return dbtype(precision=precision)
-        return self.decimal_type(precision=precision)
-    
-    def dbtype_for_str(self, hints):
-        # The bytes hint shall not reflect the usual 4-byte base for varchar.
-        bytes = int(hints.get('bytes', 255))
-        if bytes == 0:
-            # Use the maximum bytes.
-            bytes = max([0] + [dbtype.max_bytes
-                               for dbtype in self.known_types['varchar']])
-        for dbtype in self.known_types['varchar']:
-            if bytes <= dbtype.max_bytes:
-                return dbtype(bytes=bytes)
-        raise ValueError("%r is greater than the maximum bytes %r."
-                         % (bytes, dbtype.max_bytes))
-    
-    def dbtype_for_dict(self, hints):
-        return self.dbtype_for_str(hints)
-    def dbtype_for_list(self, hints):
-        return self.dbtype_for_str(hints)
-    def dbtype_for_tuple(self, hints):
-        return self.dbtype_for_str(hints)
-    def dbtype_for_unicode(self, hints):
-        return self.dbtype_for_str(hints)
-    
-    def dbtype_for_geniusql_logic_Expression(self, hints):
-        return self.dbtype_for_str(hints)
-    
-    def dbtype_for_bool(self, hints):
-        return self.known_types['bool'][0]()
-    
-    def dbtype_for_datetime_datetime(self, hints):
-        return self.known_types['datetime'][0]()
-    
-    def dbtype_for_datetime_date(self, hints):
-        return self.known_types['date'][0]()
-    
-    def dbtype_for_datetime_time(self, hints):
-        return self.known_types['time'][0]()
-    
-    def dbtype_for_datetime_timedelta(self, hints):
-        try:
-            # If your DB has an INTERVAL datatype, you should provide a
-            # native INTERVAL type. You'll also have to update the date
-            # arithmetic inside the decompiler and add a timedelta adapter.
-            return self.known_types['timedelta'][0]()
-        except (KeyError, IndexError):
-            # Fallback for DB's which do not have an INTERVAL data type.
-            # Use decimal instead of float to avoid rounding errors.
-            # Using precision of 12 should allow +/- 31688 years.
-            return self.decimal_type(12, 0)
-    
-    def numeric_max_precision(self):
-        return max([0] + [t.max_precision for t in self.known_types['numeric']])
-    
-    def decimal_type(self, precision, scale):
-        if scale > precision:
-            scale = precision
-        
-        for dbtype in self.known_types['numeric']:
-            if precision <= dbtype.max_precision:
-                return dbtype(precision=precision, scale=scale)
-        
-        # Use a VARCHAR type (add 1 char for the decimal point and 1 for sign).
-        bytes = precision + 1
-        if scale:
-            bytes += 1
-        dbtype = self.dbtype_for_str({'bytes': bytes})
-        
-        errors.warn("The given precision (%s) is greater than the "
-                    "maximum numeric precision (%s). Using %s instead."
-                    % (precision, self.numeric_max_precision(), dbtype))
-        return dbtype
-    
-    if typerefs.decimal:
-        if hasattr(typerefs.decimal, "Decimal"):
-            def dbtype_for_decimal_Decimal(self, hints):
-                precision = int(hints.get('precision', 0))
-                if precision == 0:
-                    precision = self.numeric_max_precision()
-                # Assume most people use decimal for money; default scale = 2.
-                scale = int(hints.get('scale', 2))
-                return self.decimal_type(precision, scale)
-        else:
-            def dbtype_for_decimal(self, hints):
-                precision = int(hints.get('precision', 0))
-                if precision == 0:
-                    precision = self.numeric_max_precision()
-                # Assume most people use decimal for money; default scale = 2.
-                scale = int(hints.get('scale', 2))
-                return self.decimal_type(precision, scale)
-    
-    if typerefs.fixedpoint:
-        def dbtype_for_fixedpoint_FixedPoint(self, hints):
-            # Note that fixedpoint has no theoretical precision limit.
-            precision = int(hints.get('precision', 0))
-            if precision == 0:
-                precision = self.numeric_max_precision()
-            # Assume most people use fixedpoint for money; default scale = 2.
-            scale = int(hints.get('scale', 2))
-            return self.decimal_type(precision, scale)
-    
-    def dbtype_for_long(self, hints):
-        if 'bytes' in hints:
-            bytes = int(hints['bytes'])
-        else:
-            bytes = self.numeric_max_precision() / 2
-        
-        for dbtype in self.known_types['int']:
-            if bytes <= dbtype.max_bytes:
-                return dbtype(bytes=bytes)
-        return self.decimal_type(precision=bytes * 2, scale=0)
-    
-    def dbtype_for_int(self, hints):
-        bytes = int(hints.get('bytes', maxint_bytes))
-        for dbtype in self.known_types['int']:
-            if bytes <= dbtype.max_bytes:
-                return dbtype(bytes=bytes)
-        return self.decimal_type(precision=bytes * 2, scale=0)
-
-

trunk/geniusql/dbtypes.py

@@ -4 +4 @@
-import datetime
-
-
+errors, 
-
-
@@ -28 +28 @@
-    synonyms = []
-    
-    # Given the wide variety of type systems in commercial databases,
-    # it seemed best to just overlay them all with a nominative system.
-    implicit_conversions = []
-    
-    def __init__(self, **kwargs):
-        for k, v in kwargs.iteritems():
@@ -49 +45 @@
-        """Return the type for use in CREATE or ALTER statements."""
-        return self.__class__.__name__
+    
+    def default_adapter(self, pytype):
+        """Return a default adapter instance for the given pytype, dbtype."""
+        ptypes = [pytype, None]
+        for base in pytype.__bases__:
+            ptypes.append(base)
+        
+        for p in ptypes:
+            if p in self.default_adapters:
+                return self.default_adapters[p]
+        
+        raise TypeError("%s has no default adapter for %s. Looked for: %s" %
+                        (self, pytype, "\n".join([repr(x) for x in ptypes])))
-
-
@@ -120 +129 @@
-    _initargs = DatabaseType._initargs + ("precision", "max_precision")
-    
- (= 53 for PostgreSQL 8).
-Python floats are implemented using C doubles; actual precision depends
-on platform 
-PostgreSQL
+. Python floats are
+implemented using C doubles; actual precision depends on platform
+
+Many commercial DB's
-    max_precision = 53
-    
@@ -411 +420 @@
-    default_adapters = {bool: adapters.bool_to_SQL99BOOLEAN()}
-
+
+
+# ----------------------------- Type Sets ----------------------------- #
+
+
+def getCoerceName(pytype):
+    """Return the name of the coercion method for a given Python type."""
+    mod = pytype.__module__
+    if mod == "__builtin__":
+        xform = "%s" % pytype.__name__
+    else:
+        xform = "%s_%s" % (mod, pytype.__name__)
+    xform = xform.replace(".", "_")
+    return xform
+
+
+class DatabaseTypeSet(object):
+    """Determine the best database type for a given column + Python type.
+    
+    When Geniusql is asked to create database tables, it must choose an
+    appropriate column data type for each UnitProperty based on the
+    type (and hints) of that property. This class recommends such
+    database types by returning a new instance of DatabaseType.
+    """
+    
+    known_types = None
+    
+    # You should REALLY check into your DB's encoding and override this.
+    encoding = 'utf8'
+    
+    def __copy__(self):
+        newset = self.__class__()
+        newset.update(self)
+        newset.known_types = self.known_types.copy()
+        return newset
+    copy = __copy__
+    
+    def canonicalize(self, dbtypename):
+        """Return the canonical DatabaseType for the given synonym.
+        
+        In order to avoid large amounts of code (in each provider module!)
+        that merely looks up synonyms, database types MUST be
+        canonicalized for all Column and SQLExpression objects.
+        """
+        for typeset in self.known_types.itervalues():
+            for dbtype in typeset:
+                if (dbtypename == dbtype.__name__
+                    or dbtypename in dbtype.synonyms):
+                    return dbtype
+        raise KeyError("No canonical name found for %r." % dbtypename)
+    
+    def database_type(self, pytype, hints=None):
+        """Return a DatabaseType instance for the given Python type.
+        
+        hints: if provided, this should be a dict of property attributes
+            which can be used to distinguish between similar database types.
+            Canonical keys include 'bytes', 'precision', and 'scale'.
+        """
+        xform = "dbtype_for_" + getCoerceName(pytype)
+        try:
+            xform = getattr(self, xform)
+        except AttributeError:
+            raise TypeError("%r is not handled by %s. Tried %r" %
+                            (pytype, self.__class__, xform))
+        if hints is None:
+            hints = {}
+        return xform(hints)
+    
+    def dbtype_for_float(self, hints):
+        """Return a DatabaseType for floats of the given binary precision."""
+        # Note that 'precision' is binary digits, not decimal.
+        precision = int(hints.get('precision', adapters.maxfloat_digits))
+        if precision == 0:
+            # Use the maximum precision.
+            precision = max([0] + [dbtype.max_precision
+                                   for dbtype in self.known_types['float']])
+        for dbtype in self.known_types['float']:
+            if precision <= dbtype.max_precision:
+                return dbtype(precision=precision)
+        return self.decimal_type(precision=precision)
+    
+    def dbtype_for_str(self, hints):
+        # The bytes hint shall not reflect the usual 4-byte base for varchar.
+        bytes = int(hints.get('bytes', 255))
+        if bytes == 0:
+            # Use the maximum bytes.
+            bytes = max([0] + [dbtype.max_bytes
+                               for dbtype in self.known_types['varchar']])
+        for dbtype in self.known_types['varchar']:
+            if bytes <= dbtype.max_bytes:
+                return dbtype(bytes=bytes)
+        raise ValueError("%r is greater than the maximum bytes %r."
+                         % (bytes, dbtype.max_bytes))
+    
+    def dbtype_for_dict(self, hints):
+        return self.dbtype_for_str(hints)
+    def dbtype_for_list(self, hints):
+        return self.dbtype_for_str(hints)
+    def dbtype_for_tuple(self, hints):
+        return self.dbtype_for_str(hints)
+    def dbtype_for_unicode(self, hints):
+        return self.dbtype_for_str(hints)
+    
+    def dbtype_for_geniusql_logic_Expression(self, hints):
+        return self.dbtype_for_str(hints)
+    
+    def dbtype_for_bool(self, hints):
+        return self.known_types['bool'][0]()
+    
+    def dbtype_for_datetime_datetime(self, hints):
+        return self.known_types['datetime'][0]()
+    
+    def dbtype_for_datetime_date(self, hints):
+        return self.known_types['date'][0]()
+    
+    def dbtype_for_datetime_time(self, hints):
+        return self.known_types['time'][0]()
+    
+    def dbtype_for_datetime_timedelta(self, hints):
+        try:
+            # If your DB has an INTERVAL datatype, you should provide a
+            # native INTERVAL type. You'll also have to update the date
+            # arithmetic inside the decompiler and add a timedelta adapter.
+            return self.known_types['timedelta'][0]()
+        except (KeyError, IndexError):
+            # Fallback for DB's which do not have an INTERVAL data type.
+            # Use decimal instead of float to avoid rounding errors.
+            # Using precision of 12 should allow +/- 31688 years.
+            return self.decimal_type(12, 0)
+    
+    def numeric_max_precision(self):
+        return max([0] + [t.max_precision for t in self.known_types['numeric']])
+    
+    def decimal_type(self, precision, scale):
+        if scale > precision:
+            scale = precision
+        
+        for dbtype in self.known_types['numeric']:
+            if precision <= dbtype.max_precision:
+                return dbtype(precision=precision, scale=scale)
+        
+        # Use a VARCHAR type (add 1 char for the decimal point and 1 for sign).
+        bytes = precision + 1
+        if scale:
+            bytes += 1
+        dbtype = self.dbtype_for_str({'bytes': bytes})
+        
+        errors.warn("The given precision (%s) is greater than the "
+                    "maximum numeric precision (%s). Using %s instead."
+                    % (precision, self.numeric_max_precision(), dbtype))
+        return dbtype
+    
+    if typerefs.decimal:
+        if hasattr(typerefs.decimal, "Decimal"):
+            def dbtype_for_decimal_Decimal(self, hints):
+                precision = int(hints.get('precision', 0))
+                if precision == 0:
+                    precision = self.numeric_max_precision()
+                # Assume most people use decimal for money; default scale = 2.
+                scale = int(hints.get('scale', 2))
+                return self.decimal_type(precision, scale)
+        else:
+            def dbtype_for_decimal(self, hints):
+                precision = int(hints.get('precision', 0))
+                if precision == 0:
+                    precision = self.numeric_max_precision()
+                # Assume most people use decimal for money; default scale = 2.
+                scale = int(hints.get('scale', 2))
+                return self.decimal_type(precision, scale)
+    
+    if typerefs.fixedpoint:
+        def dbtype_for_fixedpoint_FixedPoint(self, hints):
+            # Note that fixedpoint has no theoretical precision limit.
+            precision = int(hints.get('precision', 0))
+            if precision == 0:
+                precision = self.numeric_max_precision()
+            # Assume most people use fixedpoint for money; default scale = 2.
+            scale = int(hints.get('scale', 2))
+            return self.decimal_type(precision, scale)
+    
+    def dbtype_for_long(self, hints):
+        if 'bytes' in hints:
+            bytes = int(hints['bytes'])
+        else:
+            bytes = self.numeric_max_precision() / 2
+        
+        for dbtype in self.known_types['int']:
+            if bytes <= dbtype.max_bytes:
+                return dbtype(bytes=bytes)
+        return self.decimal_type(precision=bytes * 2, scale=0)
+    
+    def dbtype_for_int(self, hints):
+        bytes = int(hints.get('bytes', adapters.maxint_bytes))
+        for dbtype in self.known_types['int']:
+            if bytes <= dbtype.max_bytes:
+                return dbtype(bytes=bytes)
+        return self.decimal_type(precision=bytes * 2, scale=0)
+

trunk/geniusql/decompile.py

@@ -109 +109 @@
-    bool_false = "FALSE"
-    
-adapter
+type
-        self.tables = tables
-        self.expr = expr
-adapterset = adapter
+typeset = type
-        
-        self.groups = []
@@ -120 +120 @@
-        self.false_expr = self.const(False, self.bool_false)
-        
-adapter
-self.adapterset.default(bool, booldbtype
+type
+booldbtype.default_adapter(bool
-        self.T = self.const(True, booladapter.push(True, booldbtype))
-        self.F = self.const(False, booladapter.push(False, booldbtype))
@@ -136 +136 @@
-        name = "expr%s" % self.exprcount
-        
-adapter
+type
-        e = SQLExpression(sql, name, dbtype, pytype)
-self.adapterset.default(pytype, db
+dbtype.default_adapter(py
-        
-        return e
@@ -429 +429 @@
-            atoms = []
-            for x in op2.value:
-self.adapterset.default(type(x), op1.dbtype
+op1.dbtype.default_adapter(type(x)
-                atoms.append(adapter.push(x, op1.dbtype))
-            if atoms:
@@ -448 +448 @@
-            atoms = []
-            for x in op2.value:
-self.adapterset.default(type(x), op1.dbtype
+op1.dbtype.default_adapter(type(x)
-                atoms.append(adapter.push(x.lower(), op1.dbtype))
-            return self.get_expr("LOWER(%s) IN (%s)" %
@@ -531 +531 @@
-        if newpytype != op1.pytype:
-            op1.pytype = newpytype
-adapter
-self.adapterset.default(newpytype, op1.db
+type
+op1.dbtype.default_adapter(newpy
-        if not op1.name.startswith("expr_"):
-            op1.name = "expr_%s" % op1.name

trunk/geniusql/objects.py

@@ -19 +19 @@
-import geniusql
-from geniusql import errors, typerefs
-adapter
+dbtype
-from geniusql import conns
-from geniusql import decompile
@@ -331 +331 @@
-        tpair = [(self.qname, self)]
-        decom = self.schema.db.decompiler(tpair, logic.filter(**inputs),
-adapter
+type
-##        decom.verbose = True
-        code = decom.code()
@@ -626 +626 @@
-        col.autoincrement = autoincrement
-        
-adapter
+type
-        if col.dbtype is None:
-            col.dbtype = typer.database_type(pytype, hints or {})
-typer.default(pytype, col.db
+col.dbtype.default_adapter(py
-        
-        return col
@@ -754 +754 @@
-    __metaclass__ = geniusql._AttributeDocstrings
-    
-adapterset = adapters.Adapter
+typeset = dbtypes.DatabaseType
-    decompiler = decompile.SQLDecompiler
-    joinwrapper = select.TableWrapper
@@ -842 +842 @@
-            conn = self.connections.get()
-        if isinstance(query, unicode):
-adapter
+type
-        self.log(query)
-        return conn.query(query)

trunk/geniusql/providers/ado.py

@@ -256 +256 @@
-            atoms = []
-            for x in op2.value:
-self.adapterset.default(type(x), op1.dbtype
+op1.dbtype.default_adapter(type(x)
-                atoms.append(adapter.push(x, op1.dbtype))
-            if atoms:
@@ -461 +461 @@
-            conn = self.connections.get()
-##        if isinstance(query, unicode):
-adapter
+type
-        
-        self.log(query)

trunk/geniusql/providers/msaccess.py

@@ -324 +324 @@
-
-
-AdapterSet(adapters.Adapter
+TypeSet(dbtypes.DatabaseType
-    
-    known_types = {'float': [REAL, FLOAT],
@@ -484 +484 @@
-        
-        cols = []
-adapter
+type
-        for row in data:
-            # I tried passing criteria to OpenSchema, but passing None is
@@ -532 +532 @@
-                    dbtype.bytes = (2 ** 31) - 1
-            
-typer.default(pytype, db
+dbtype.default_adapter(py
-            cols.append(c)
-        
@@ -645 +645 @@
-    
-    decompiler = MSAccessDecompiler
-adapterset = MSAccessAdapter
+typeset = MSAccessType
-    connectionmanager = MSAccessConnectionManager
-    schemaclass = MSAccessSchema

trunk/geniusql/providers/postgres.py

@@ -353 +353 @@
-
-
-AdapterSet(adapters.Adapter
+TypeSet(dbtypes.DatabaseType
-    
-    known_types = {'float': [FLOAT4, FLOAT8],
@@ -385 +385 @@
-            atoms = []
-            for x in op2.value:
-self.adapterset.default(type(x), op1.dbtype
+op1.dbtype.default_adapter(type(x)
-                atoms.append(adapter.push(x.lower(), op1.dbtype))
-            return self.get_expr("LOWER(%s) IN (%s)" %
@@ -515 +515 @@
-        data, _ = self.db.fetch(sql, conn=conn)
-        cols = []
-adapterset = self.db.adapter
+typeset = self.db.type
-        for row in data:
-            name = row[0]
@@ -526 +526 @@
-            dbtype, _ = self.db.fetch("SELECT typname, typlen FROM pg_type "
-                                      "WHERE oid = %s" % row[1], conn=conn)
-adapter
+type
-            dbtype = dbtypetype()
-            
@@ -532 +532 @@
-                                None, key=row[2] in indices,
-                                name=row[0], qname=self.db.quote(row[0]))
-adapterset.default(c.pytype, db
+dbtype.default_adapter(c.py
-            
-            if dbtypetype in (FLOAT4, FLOAT8):
@@ -660 +660 @@
-    decompiler = PgDecompiler
-    schemaclass = PgSchema
-adapterset = PgAdapter
+typeset = PgType
-    
-    def quote(self, name):

trunk/geniusql/providers/sqlserver.py

@@ -240 +240 @@
-
-
-AdapterSet(adapters.Adapter
+TypeSet(dbtypes.DatabaseType
-    
-    known_types = {'float': [REAL, FLOAT],
@@ -403 +403 @@
-        
-        cols = []
-adapter
+type
-        for row in data:
-            # I tried passing criteria to OpenSchema, but passing None is
@@ -444 +444 @@
-                    dbtype.bytes = b = int(row[13])
-            
-typer.default(pytype, db
+dbtype.default_adapter(py
-            cols.append(c)
-        return cols
@@ -487 +487 @@
-    
-    decompiler = SQLServerDecompiler
-adapterset = SQLServerAdapter
+typeset = SQLServerType
-    connectionmanager = SQLServerConnectionManager
-    schemaclass = SQLServerSchema

trunk/geniusql/select.py

@@ -247 +247 @@
-        """Return an SQL WHERE clause, and an 'imperfect' flag."""
-        tpairs = [(t.alias or t.qname, t.table) for t in self.tables]
-adapter
+type
-        code = decom.code()
-        return code, decom.imperfect
@@ -343 +343 @@
-        tpairs = [(t.alias or t.qname, t.table) for t in self.tables]
-        decom = self.db.decompiler
-adapter
+type
-##        decom.verbose = True
-        

trunk/geniusql/test/test_msaccess.py

@@ -26 +26 @@
-##            def test_currency_dbtypes(obj):
-##                db = zoo_fixture.db
-adapter
+type
-##                schema = zoo_fixture.schema
-##                

trunk/geniusql/test/zoo_fixture.py

@@ -1103 +1103 @@
-            if db:
-                import math
-adapter
+type
-                if maxprec == 0:
-                    # SQLite, for example, must always use TEXT.