Changeset 18

Timestamp:

02/18/07 23:36:15

Author:

fumanchu

Message:

Moved Database.isrelatedtype to TypeAdapter?.related. Also moved Database.python_type to TypeAdapter?.python_type, which now uses TypeAdapter?._reverse_types (a dict). Also removed Typeless mode for SQLite; it's just too dangerous.

Files:

• trunk/geniusql/__init__.py (modified) (1 diff)
• trunk/geniusql/adapters.py (modified) (2 diffs)
• trunk/geniusql/objects.py (modified) (2 diffs)
• trunk/geniusql/providers/ado.py (modified) (8 diffs)
• trunk/geniusql/providers/firebird.py (modified) (4 diffs)
• trunk/geniusql/providers/mysql.py (modified) (4 diffs)
• trunk/geniusql/providers/postgres.py (modified) (5 diffs)
• trunk/geniusql/providers/sqlite.py (modified) (4 diffs)
• trunk/geniusql/test/test_sqlite.py (modified) (2 diffs)

trunk/geniusql/__init__.py

@@ -71 +71 @@
-        that's not How Python Works. Quack.
-        '''
+        type.__init__(name, bases, dct)
-        
-        newdoc = [cls.__doc__ or ""]

trunk/geniusql/adapters.py

@@ -342 +342 @@
-    """Determine the best database type for a given column + Python type.
-    
-Dejavu
+Geniusql
-    appropriate column data type for each UnitProperty based on the
-    type (and hints) of that property. This class recommends such
@@ -368 +368 @@
-    # TEXT is not an SQL standard, but it's common.
-    numeric_text_type = "TEXT"
+    
+    _reverse_types = {
+        "DATE": datetime.date,
+        "DATETIME": datetime.datetime,
+        "TIMESTAMP": datetime.datetime,
+        "TIME": datetime.time,
+        
+        "INT": int,
+        "INTEGER": int,
+        "SMALLINT": int,
+        
+        "BOOL": bool,
+        "BOOLEAN": bool,
+        
+        "BIGINT": long,
+        "LONG": long,
+        
+        "DOUBLE": float,
+        "DOUBLE PRECISION": float,
+        "FLOAT": float,
+        "REAL": float,
+        "SINGLE": float,
+        
+        "CHAR": str,
+        "BLOB": str,
+        "TEXT": str,
+        "VARCHAR": str,
+        }
+    
+    if decimal:
+        _reverse_types["DECIMAL"] = decimal.Decimal
+        _reverse_types["NUMERIC"] = decimal.Decimal
+    elif fixedpoint:
+        _reverse_types["DECIMAL"] = fixedpoint.FixedPoint
+        _reverse_types["NUMERIC"] = fixedpoint.FixedPoint
+    
+    def __init__(self):
+        # Make a copy of the class-level 'dict
+        self._reverse_types = self._reverse_types.copy()
+    
+    def python_type(self, dbtype):
+        """Return a Python type which can store values of the given dbtype."""
+        # Strip any size argument (e.g. "VARCHAR(255)").
+        key = dbtype.upper().split("(", 1)[0]
+        try:
+            return self._reverse_types[key]
+        except KeyError:
+            raise TypeError("Database type %r could not be converted "
+                            "to a Python type." % dbtype)
+    
+    def related(self, pytype1, pytype2):
+        """If values of both types are expressed with the same SQL, return True."""
+        if issubclass(pytype1, pytype2) or issubclass(pytype2, pytype1):
+            return True
+        if issubclass(pytype1, basestring) and issubclass(pytype2, basestring):
+            return True
+        if ((issubclass(pytype1, int) or issubclass(pytype1, long)) and
+            (issubclass(pytype2, int) or issubclass(pytype2, long))):
+            return True
+        if fixedpoint:
+            if decimal:
+                if ((issubclass(pytype1, fixedpoint.FixedPoint)
+                     or issubclass(pytype1, decimal.Decimal)) and
+                    (issubclass(pytype2, fixedpoint.FixedPoint)
+                     or issubclass(pytype2, decimal.Decimal))):
+                    return True
+            else:
+                if (issubclass(pytype1, fixedpoint.FixedPoint) and
+                    issubclass(pytype2, fixedpoint.FixedPoint)):
+                    return True
+        else:
+            if decimal:
+                if (issubclass(pytype1, decimal.Decimal) and
+                    issubclass(pytype2, decimal.Decimal)):
+                    return True
+        return False
-    
-    def coerce(self, col, pytype):

trunk/geniusql/objects.py

@@ -606 +606 @@
-        if dbtype is None:
-            col.dbtype = self.db.typeadapter.coerce(col, pytype)
-
-isrelatedtype
+typeadapter.
+typeadapter.related
-        
-        return col
@@ -773 +773 @@
-    def log(self, msg):
-        pass
-    
-    def python_type(self, dbtype):
-        """Return a Python type which can store values of the given dbtype."""
-        raise TypeError("Database type %r could not be converted "
-                        "to a Python type." % dbtype)
-    
-    def isrelatedtype(self, pytype1, pytype2):
-        """If values of both types are expressed with the same SQL, return True."""
-        if issubclass(pytype1, pytype2) or issubclass(pytype2, pytype1):
-            return True
-        if issubclass(pytype1, basestring) and issubclass(pytype2, basestring):
-            return True
-        if ((issubclass(pytype1, int) or issubclass(pytype1, long)) and
-            (issubclass(pytype2, int) or issubclass(pytype2, long))):
-            return True
-        if typerefs.fixedpoint:
-            if typerefs.decimal:
-                if ((issubclass(pytype1, typerefs.fixedpoint.FixedPoint)
-                     or issubclass(pytype1, typerefs.decimal.Decimal)) and
-                    (issubclass(pytype2, typerefs.fixedpoint.FixedPoint)
-                     or issubclass(pytype2, typerefs.decimal.Decimal))):
-                    return True
-            else:
-                if (issubclass(pytype1, typerefs.fixedpoint.FixedPoint) and
-                    issubclass(pytype2, typerefs.fixedpoint.FixedPoint)):
-                    return True
-        else:
-            if typerefs.decimal:
-                if (issubclass(pytype1, typerefs.decimal.Decimal) and
-                    issubclass(pytype2, typerefs.decimal.Decimal)):
-                    return True
-        return False
-    
-    #                               Naming                               #

trunk/geniusql/providers/ado.py

@@ -511 +511 @@
-        
-        cols = []
+        pytype = self.db.typeadapter.python_type
-        for row in data:
-            # I tried passing criteria to OpenSchema, but passing None is
@@ -520 +521 @@
-            default = row[8]
-            if default is not None:
-self.db.python_
+py
-                if issubclass(deftype, (int, long)):
-                    # We may have stuck extraneous quotes in the default
@@ -529 +530 @@
-            
-            name = str(row[3])
-self.db.python_
+py
-                                default, hints={}, key=(name in pknames),
-                                name=name, qname=self.db.quote(name))
@@ -613 +614 @@
-
-
+class ADOTypeAdapter(adapters.TypeAdapter):
+    
+    _reverse_types = adapters.TypeAdapter._reverse_types.copy()
+    _reverse_types.update({
+        "DBDATE": datetime.date,
+        "DBTIME": datetime.time,
+        "DBTIMESTAMP": datetime.datetime,
+        
+        "UNSIGNEDTINYINT": int,
+        "UNSIGNEDSMALLINT": int,
+        "UNSIGNEDINT": int,
+        "BIT": bool,
+        
+        "UNSIGNEDBIGINT": long,
+        
+        "BSTR": str,
+        "VARIANT": str,
+        "BINARY": str,
+        "LONGVARCHAR": str,
+        "VARBINARY": str,
+        "LONGVARBINARY": str,
+        
+        "WCHAR": unicode,
+        "VARWCHAR": unicode,
+        "LONGVARWCHAR": unicode,
+        })
+    
+    if typerefs.decimal:
+        _reverse_types["CURRENCY"] = typerefs.decimal.Decimal
+    elif typerefs.fixedpoint:
+        _reverse_types["CURRENCY"] = typerefs.fixedpoint.FixedPoint
+
+
-class ADODatabase(geniusql.Database):
-    
-    decompiler = ADOSQLDecompiler
-    adapterfromdb = AdapterFromADO()
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-    
-    #                               Naming                                #
@@ -806 +802 @@
-
-
-adapters.
+ADO
-    
-    # Hm. Docs say 38, but I can't seem to get more than 12 working.
@@ -999 +995 @@
-
-
-adapters.
+ADO
-    # http://msdn2.microsoft.com/en-us/library/ms714540.aspx
-    # http://office.microsoft.com/en-us/access/HP010322481033.aspx
@@ -1006 +1002 @@
-    numeric_max_precision = 12
-    numeric_max_bytes = 6
+    
+    _reverse_types = ADOTypeAdapter._reverse_types.copy()
+    _reverse_types.update({
+        "LONG": int,
+        "MEMO": str,
+        })
-    
-    def coerce_bool(self, col): return "BIT"
@@ -1229 +1231 @@
-        del conn
-        return "ADO Version: %s" % v
-    
-    def python_type(self, dbtype):
-        if dbtype == "LONG":
-            return int
-        return ADODatabase.python_type(self, dbtype)
-
-

trunk/geniusql/providers/firebird.py

@@ -113 +113 @@
-    
-    numeric_text_type = "BLOB"
+    
+    _reverse_types = adapters.TypeAdapter._reverse_types.copy()
+    _reverse_types.update({
+        'LONG': int,
+        'SHORT': int,
+        'INT64': long,
+        'VARYING': str,
+        'NCHAR': unicode,
+        'NATIONAL': unicode,
+        })
-    
-    def coerce_str(self, col):
@@ -435 +445 @@
-            "T.RDB$FIELD_NAME='RDB$FIELD_TYPE';" % tablename, conn=conn)
-        cols = []
+        pytype = self.db.typeadapter.python_type
-        for name, dbtype, fieldlen, default, prec, scale in data:
-            hints = {}
@@ -463 +474 @@
-            
-            # Column(pytype, dbtype, default=None, hints=None, key=False, name, qname)
-self.db.python_
+py
-                                  hints, key, name, self.db.quote(name))
-            cols.append(col)
@@ -563 +574 @@
-    sql_name_max_length = 31
-    encoding = 'utf8'
-    
-    def python_type(self, dbtype):
-        """Return a Python type which can store values of the given dbtype."""
-        dbtype = dbtype.upper()
-        
-        if dbtype in ('INTEGER', 'SMALLINT', 'LONG', 'SHORT'):
-            return int
-        elif dbtype in ('BIGINT', 'INT64'):
-            return long
-        elif dbtype in ('FLOAT', 'DOUBLE', 'DOUBLE PRECISION', 'REAL'):
-            return float
-        elif dbtype.startswith('NUMERIC') or dbtype.startswith('DECIMAL'):
-            if typerefs.decimal:
-                return typerefs.decimal.Decimal
-            elif typerefs.fixedpoint:
-                return typerefs.fixedpoint.FixedPoint
-        elif dbtype == 'DATE':
-            return datetime.date
-        elif dbtype == 'TIMESTAMP':
-            return datetime.datetime
-        elif dbtype == 'TIME':
-            return datetime.time
-        for t in ('CHAR', 'VARCHAR', 'BLOB', 'TEXT', 'VARYING'):
-            if dbtype.startswith(t):
-                return str
-        for t in ('NCHAR', 'NATIONAL'):
-            if dbtype.startswith(t):
-                return unicode
-        
-        raise TypeError("Database type %r could not be converted "
-                        "to a Python type." % dbtype)
-    
-    #                               Naming                               #

trunk/geniusql/providers/mysql.py

@@ -88 +88 @@
-    numeric_max_precision = 16
-    numeric_max_bytes = 8
+    
+    _reverse_types = adapters.TypeAdapter._reverse_types.copy()
+    _reverse_types.update({
+        'TINYINT': int,
+        'MEDIUMINT': int,
+        
+        'BINARY': str,
+        'VARBINARY': str,
+        'TINYBLOB': str,
+        'TINYTEXT': str,
+        'MEDIUMBLOB': str,
+        'MEDIUMTEXT': str,
+        'LONGBLOB': str,
+        'LONGTEXT': str,
+        })
-    
-    def float_type(self, precision):
@@ -126 +141 @@
-            return "MEDIUMINT"
-        return "INTEGER"
+    
+    def related(self, pytype1, pytype2):
+        if pytype1 is float and pytype2 is float:
+            # MySQL provides no reliable method to compare floats in SQL.
+            # Setting this to False will set col.imperfect_type to True,
+            # which will tell the SQL decompiler to mark float comparisons
+            # as imperfect.
+            return False
+        return adapters.TypeAdapter.related(self, pytype1, pytype2)
-
-
@@ -325 +349 @@
-            
-            key = (row[3] == "PRI")
-
+typeadapter.
-            
-            col = geniusql.Column(pytype, dbtype, None, hints, key,
@@ -419 +443 @@
-        return "MySQL Version: %s" % self._version
-    
-    def python_type(self, dbtype):
-        """Return a Python type which can store values of the given dbtype."""
-        dbtype = dbtype.upper()
-        parenpos = dbtype.find("(")
-        if parenpos > -1:
-            dbtype = dbtype[:parenpos]
-        
-        if dbtype in ('TINYINT', 'SMALLINT', 'MEDIUMINT', 'INT', 'INTEGER'):
-            return int
-        elif dbtype == 'BIGINT':
-            return long
-        elif dbtype in ('BOOL', 'BOOLEAN'):
-            return bool
-        elif dbtype in ('FLOAT', 'DOUBLE', 'DOUBLE PRECISION', 'REAL'):
-            return float
-        elif dbtype in ('DECIMAL', 'NUMERIC'):
-            if typerefs.decimal:
-                return typerefs.decimal.Decimal
-            elif typerefs.fixedpoint:
-                return typerefs.fixedpoint.Fixedpoint
-        elif dbtype == 'DATE':
-            return datetime.date
-        elif dbtype in ('DATETIME', 'TIMESTAMP'):
-            return datetime.datetime
-        elif dbtype == 'TIME':
-            return datetime.time
-        elif dbtype in ('CHAR', 'VARCHAR', 'BINARY', 'VARBINARY',
-                        'TINYBLOB', 'TINYTEXT', 'BLOB', 'TEXT',
-                        'MEDIUMBLOB', 'MEDIUMTEXT', 'LONGBLOB', 'LONGTEXT'):
-            return str
-        
-        raise TypeError("Database type %r could not be converted "
-                        "to a Python type." % dbtype)
-    
-    def isrelatedtype(self, pytype1, pytype2):
-        if pytype1 is float and pytype2 is float:
-            # MySQL provides no reliable method to compare floats in SQL.
-            # Setting this to False will set col.imperfect_type to True,
-            # which will tell the SQL decompiler to mark float comparisons
-            # as imperfect.
-            return False
-        return geniusql.Database.isrelatedtype(self, pytype1, pytype2)
-    
-    def quote(self, name):
-        """Return name, quoted for use in an SQL statement."""

trunk/geniusql/providers/postgres.py

@@ -178 +178 @@
-        data, _ = self.db.fetch(sql, conn=conn)
-        cols = []
+        pytype = self.db.typeadapter.python_type
-        for row in data:
-            name = row[0]
@@ -192 +193 @@
-            else:
-                dbtype = None
-self.db.python_
+py
-                                None, {}, row[2] in indices,
-                                row[0], self.db.quote(row[0]))
@@ -219 +220 @@
-                    # our guessed type. Be sure to strip any ::typename
-                    default = default.split("::", 1)[0]
-self.db.python_
+py
-            else:
-                c.default = None
@@ -315 +316 @@
-
-
+class PgTypeAdapter(adapters.TypeAdapter):
+    
+    _reverse_types = adapters.TypeAdapter._reverse_types.copy()
+    _reverse_types.update({
+        "TIMESTAMPTZ": datetime.datetime,
+        "TIMETZ": datetime.time,
+        "INT2": int,
+        "INT4": int,
+        "INT8": long,
+        "FLOAT4": float,
+        "FLOAT8": float,
+        "MONEY": float,
+        "BYTEA": str,
+        "BPCHAR": str,
+        })
+
-class PgDatabase(geniusql.Database):
-    
@@ -324 +341 @@
-    adaptertosql = AdapterToPgSQL()
-    adapterfromdb = AdapterFromPg()
+    typeadapter = PgTypeAdapter()
-    
-    decompiler = PgDecompiler
-    schemaclass = PgSchema
-    
-    def __init__(self, **kwargs):
-        geniusql.Database.__init__(self, **kwargs)
-    
-    def python_type(self, dbtype):
-        """Return a Python type which can store values of the given dbtype."""
-        dbtype = dbtype.upper()
-        if dbtype in ('INT2', 'INT4', 'INTEGER', 'SMALLINT'):
-            return int
-        elif dbtype in ('BOOL', 'BOOLEAN'):
-            return bool
-        elif dbtype in ('INT8', 'BIGINT'):
-            return long
-        elif dbtype in ('FLOAT4', 'FLOAT8', 'MONEY', 'DOUBLE PRECISION', 'REAL'):
-            return float
-        elif dbtype.startswith('NUMERIC'):
-            if typerefs.decimal:
-                return typerefs.decimal.Decimal
-            elif typerefs.fixedpoint:
-                return typerefs.fixedpoint.FixedPoint
-        elif dbtype == 'DATE':
-            return datetime.date
-        elif dbtype in ('TIMESTAMP', 'TIMESTAMPTZ'):
-            return datetime.datetime
-        elif dbtype in ('TIME', 'TIMETZ'):
-            return datetime.time
-        elif dbtype in ('BYTEA'):
-            return str
-        for t in ('CHAR', 'VARCHAR', 'BPCHAR', 'TEXT'):
-            if dbtype.startswith(t):
-                return str
-        
-        raise TypeError("Database type %r could not be converted "
-                        "to a Python type." % dbtype)
-    
-    def quote(self, name):

trunk/geniusql/providers/sqlite.py

@@ -57 +57 @@
-            return '1'
-        return '0'
-
-
-class AdapterToSQLiteTypeless(AdapterToSQLite):
-    
-    def cast_any_to_object(self, colref):
-        return colref
-
-
@@ -238 +232 @@
-    numeric_max_bytes = 0
-    
+    _reverse_types = adapters.TypeAdapter._reverse_types.copy()
+    _reverse_types.update({
+        "NONE": unicode,
+        })
+    
+    def python_type(self, dbtype):
+        """Return a Python type which can store values of the given dbtype."""
+        # Strip any size argument (e.g. "VARCHAR(255)").
+        key = dbtype.upper().split("(", 1)[0]
+        try:
+            return self._reverse_types[key]
+        except KeyError:
+            return str
+    
-    def coerce_decimal_Decimal(self, col):
-        return "TEXT"
@@ -265 +273 @@
-        """Return a datatype which can handle the given number of bytes."""
-        return "INTEGER"
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-
-
@@ -763 +772 @@
-        kwargs['mode'] = int(kwargs.pop('mode', '0755'), 8)
-        geniusql.Database.__init__(self, **kwargs)
-    
-    def isrelatedtype(self, pytype1, pytype2):
-        if (self.adaptertosql.perfect_dates and
-            issubclass(pytype1, (datetime.date, datetime.time, datetime.datetime)) and
-            issubclass(pytype2, self.python_type(self.typeadapter.coerce(None, pytype1)))):
-            return True
-        return geniusql.Database.isrelatedtype(self, pytype1, pytype2)
-    
-    def python_type(self, dbtype):
-        """Return a Python type which can store values of the given dbtype."""
-        if isinstance(self.typeadapter, TypeAdapterSQLiteTypeless):
-            return str
-        
-        if dbtype == "REAL":
-            return float
-        elif dbtype == "NUMERIC":
-            if typerefs.decimal:
-                return typerefs.decimal.Decimal
-            elif typerefs.fixedpoint:
-                return typerefs.fixedpoint.FixedPoint
-        elif dbtype.startswith("INTEGER"):
-            return int
-        elif dbtype == "NONE":
-            return unicode
-        
-        return str
-    
-    def quote(self, name):

trunk/geniusql/test/test_sqlite.py

@@ -33 +33 @@
-        print "Testing SQLite with 'Perfect Dates'"
-        opts['adaptertosql.perfect_dates'] = True
+        opts['typeadapter.perfect_dates'] = True
-        reload(zoo_fixture)
-        zoo_fixture.run(DB_class, dbpath, opts)
-        opts['adaptertosql.perfect_dates'] = False
+        opts['typeadapter.perfect_dates'] = False
-        
-        print
@@ -41 +43 @@
-        reload(zoo_fixture)
-        zoo_fixture.run(DB_class, ':memory:', opts)
-        
-        print
-        print "Testing SQLite 'typeless'..."
-        from geniusql.providers import sqlite
-        opts['typeadapter'] = sqlite.TypeAdapterSQLiteTypeless()
-        reload(zoo_fixture)
-        zoo_fixture.run(DB_class, dbpath, opts)
-
-if __name__ == "__main__":