Changeset 233

Timestamp:

07/20/06 23:55:22

Author:

fumanchu

Message:

Moved db.FieldTypeAdapter? to dbmodel.TypeAdapter?, so it no longer depends on any Unit logic.

Files:

• trunk/storage/db.py (modified) (6 diffs)
• trunk/storage/dbmodel.py (modified) (5 diffs)
• trunk/storage/storeado.py (modified) (10 diffs)
• trunk/storage/storemysql.py (modified) (9 diffs)
• trunk/storage/storepypgsql.py (modified) (2 diffs)
• trunk/storage/storesqlite.py (modified) (8 diffs)
• trunk/test/test_storemsaccess.py (modified) (3 diffs)
• trunk/test/zoo_fixture.py (modified) (2 diffs)

trunk/storage/db.py

@@ -45 +45 @@
-    fixedpoint = None
-
-import sys
-for maxint_bytes in xrange(9):
-    if sys.maxint <= 2 ** ((maxint_bytes * 8) - 1):
-        break
-
-
-import threading
-import warnings
@@ -58 +52 @@
-from dejavu import logic, storage, LOGSQL, xray
-from dbmodel import *
-
-
-class FieldTypeAdapter(object):
-    """For a UnitProperty, return a database type.
-    
-    This base class is designed to work out-of-the-box with PostgreSQL 8.
-    """
-    
-    # Max binary precision for floating-point columns (= 53 for PostgreSQL 8).
-    float_max_precision = 53
-    
-    # Max decimal precision for NUMERIC columns (= 1000 for PostgreSQL 8).
-    numeric_max_precision = 1000
-    
-    # "The actual storage requirement is two bytes for each group of four
-    # decimal digits, plus eight bytes overhead." Note we omit the overhead.
-    numeric_max_bytes = 500
-    
-    def coerce(self, cls, key):
-        """Return a column object for the given UnitProperty (cls and key)."""
-        prop = cls.property(key)
-        
-        # Obtain the DB type
-        valuetype = prop.type
-        mod = valuetype.__module__
-        if mod == "__builtin__":
-            xform = "coerce_%s" % valuetype.__name__
-        else:
-            xform = "coerce_%s_%s" % (mod, valuetype.__name__)
-        xform = xform.replace(".", "_")
-        try:
-            xform = getattr(self, xform)
-        except AttributeError:
-            raise TypeError("'%s' is not handled by %s." %
-                            (valuetype, self.__class__))
-        dbtype = xform(cls, key)
-        
-        return dbtype
-    
-    def float_type(self, precision):
-        """Return a datatype which can handle floats of the given binary precision."""
-        if precision <= 24:
-            return "REAL"
-        else:
-            # Python floats are implemented using C doubles;
-            # actual precision depends on platform.
-            # PostgreSQL DOUBLE is 53 binary-digit precision.
-            return "DOUBLE PRECISION"
-    
-    def coerce_float(self, cls, key):
-        prop = getattr(cls, key)
-        # Note that 'precision' is binary digits, not decimal
-        precision = int(prop.hints.get('precision', 0))
-        if precision == 0:
-            precision = self.float_max_precision
-        elif precision > self.float_max_precision:
-            warnings.warn("Float precision %s > maximum %s for %s.%s, "
-                          "using %s. Values may be stored incorrectly."
-                          % (precision, self.float_max_precision,
-                             cls.__name__, key, self.__class__.__name__),
-                          dejavu.StorageWarning)
-            precision = self.float_max_precision
-        return self.float_type(precision)
-    
-    def coerce_str(self, cls, key):
-        # The bytes hint shall not reflect the usual 4-byte base for varchar.
-        prop = getattr(cls, key)
-        bytes = int(prop.hints.get('bytes', 0))
-        if bytes:
-            return "VARCHAR(%s)" % bytes
-        else:
-            # TEXT is not an SQL standard, but it's common.
-            return "TEXT"
-    
-    def coerce_dict(self, cls, key):
-        return self.coerce_str(cls, key)
-    def coerce_list(self, cls, key):
-        return self.coerce_str(cls, key)
-    def coerce_tuple(self, cls, key):
-        return self.coerce_str(cls, key)
-    def coerce_unicode(self, cls, key):
-        return self.coerce_str(cls, key)
-    
-    def coerce_bool(self, cls, key): return "BOOLEAN"
-    
-    def coerce_datetime_datetime(self, cls, key): return "TIMESTAMP"
-    def coerce_datetime_date(self, cls, key): return "DATE"
-    def coerce_datetime_time(self, cls, key): return "TIME"
-    
-    # I was seriously disinterested in writing a parser for interval.
-    def coerce_datetime_timedelta(self, cls, key):
-        return self.coerce_float(cls, key)
-    
-    def coerce_decimal_Decimal(self, cls, key):
-        prop = getattr(cls, key)
-        precision = int(prop.hints.get('precision', decimal.getcontext().prec))
-        if precision == 0:
-            precision = self.numeric_max_precision
-        elif precision > self.numeric_max_precision:
-            warnings.warn("Decimal precision %s > maximum %s for %s.%s, "
-                          "using %s. Values may be stored incorrectly."
-                          % (precision, self.numeric_max_precision,
-                             cls.__name__, key, self.__class__.__name__),
-                          dejavu.StorageWarning)
-            precision = self.numeric_max_precision
-        
-        # Assume most people use decimal for money; default scale = 2.
-        scale = int(prop.hints.get('scale', 2))
-        if scale > precision:
-            scale = precision
-        return "NUMERIC(%s, %s)" % (precision, scale)
-    
-    def coerce_decimal(self, cls, key):
-        # If decimal ever becomes a builtin. Python 2.5?
-        return self.coerce_decimal_Decimal(cls, key)
-    
-    def coerce_fixedpoint_FixedPoint(self, cls, key):
-        prop = getattr(cls, key)
-        # Note that fixedpoint has no theoretical precision limit.
-        precision = int(prop.hints.get('precision', 0))
-        if precision == 0:
-            precision = self.numeric_max_precision
-        elif precision > self.numeric_max_precision:
-            warnings.warn("Fixedpoint precision %s > maximum %s for %s.%s, "
-                          "using %s. Values may be stored incorrectly."
-                          % (precision, self.numeric_max_precision,
-                             cls.__name__, key, self.__class__.__name__),
-                          dejavu.StorageWarning)
-            precision = self.numeric_max_precision
-        
-        # Assume most people use fixedpoint for money; default scale = 2.
-        scale = int(prop.hints.get('scale', 2))
-        if scale > precision:
-            scale = precision
-        return "NUMERIC(%s, %s)" % (precision, scale)
-    
-    def int_type(self, bytes):
-        """Return a datatype which can handle the given number of bytes."""
-        if bytes == 1:
-            return "BOOLEAN"
-        elif bytes == 2:
-            return "SMALLINT"
-        elif bytes <= 4:
-            return "INTEGER"
-        elif bytes <= 8:
-            # BIGINT is usually 8 bytes
-            return "BIGINT"
-        else:
-            # Anything larger than 8 bytes, use decimal/numeric.
-            # For PostgreSQL, "The actual storage requirement is two bytes
-            # for each group of four decimal digits, plus eight bytes
-            # overhead." Note we omit the overhead in our calculation.
-            return "NUMERIC(%s, 0)" % (bytes * 2)
-    
-    def coerce_long(self, cls, key):
-        prop = getattr(cls, key)
-        bytes = int(prop.hints.get('bytes', self.numeric_max_precision))
-        if bytes == 0:
-            bytes = self.numeric_max_bytes
-        elif bytes > self.numeric_max_bytes:
-            warnings.warn("Long bytes %s > maximum %s for %s.%s, "
-                          "using %s. Values may be stored incorrectly."
-                          % (bytes, self.numeric_max_bytes,
-                             cls.__name__, key, self.__class__.__name__),
-                          dejavu.StorageWarning)
-            bytes = self.numeric_max_bytes
-        
-        return self.int_type(bytes)
-    
-    def coerce_int(self, cls, key):
-        prop = getattr(cls, key)
-        bytes = int(prop.hints.get('bytes', maxint_bytes))
-        if bytes == 0:
-            bytes = maxint_bytes
-        elif bytes > maxint_bytes:
-            warnings.warn("Integer bytes %s > maximum %s for %s.%s, "
-                          "using %s. Values may be stored incorrectly."
-                          % (bytes, maxint_bytes,
-                             cls.__name__, key, self.__class__.__name__),
-                          dejavu.StorageWarning)
-            bytes = maxint_bytes
-        
-        return self.int_type(bytes)
-
-
@@ -301 +112 @@
-    
-    use_asterisk_to_get_all = False
-    
-    typeAdapter = FieldTypeAdapter()
-    databaseclass = Database
-    
@@ -316 +125 @@
-            return item
-        
-        adapter = get_option('Type Adapter')
-        if adapter:
-            self.typeAdapter = adapter
-        
-        adapter = get_option('Database Class')
-        if adapter:
@@ -328 +133 @@
-        self.db = self.databaseclass(name, **allOptions)
-        self.db.log = self.arena.log
+        
+        adapter = get_option('Type Adapter')
+        if adapter:
+            self.db.typeadapter = adapter
-    
-    def version(self):
@@ -692 +501 @@
-    
-    def _make_column(self, cls, key):
-        dbtype = self.typeAdapter.coerce(cls, key)
-        col = self.db.make_column(cls.__name__, key, dbtype)
-        prop = getattr(cls, key)
+        col = self.db.make_column(cls.__name__, key)
-        col.default = prop.default
-        col.hints = prop.hints.copy()
+        col.dbtype = self.db.db_type(col, prop.type)
+        
+        if key in cls.identifiers:
+            if isinstance(cls.sequencer, dejavu.UnitSequencerInteger):
+                col.autoincrement = True
+                col.default = cls.sequencer.initial
-        return col
-    

trunk/storage/dbmodel.py

@@ -30 +30 @@
-    import pickle
-import Queue
+
+import sys
+for maxint_bytes in xrange(9):
+    if sys.maxint <= 2 ** ((maxint_bytes * 8) - 1):
+        break
+
-import time
-from types import FunctionType
@@ -274 +280 @@
-        else:
-            return unicode(value, self.encoding)
+
+
+class TypeAdapter(object):
+    """Determine the best database type for a given column + Python type.
+    
+    This base class is designed to work out-of-the-box with PostgreSQL 8.
+    """
+    
+    # Max binary precision for floating-point columns (= 53 for PostgreSQL 8).
+    float_max_precision = 53
+    
+    # Max decimal precision for NUMERIC columns (= 1000 for PostgreSQL 8).
+    numeric_max_precision = 1000
+    
+    # "The actual storage requirement is two bytes for each group of four
+    # decimal digits, plus eight bytes overhead." Note we omit the overhead.
+    numeric_max_bytes = 500
+    
+    def coerce(self, col, pytype):
+        """Return a database type for the given column object and Python type."""
+        mod = pytype.__module__
+        if mod == "__builtin__":
+            xform = "coerce_%s" % pytype.__name__
+        else:
+            xform = "coerce_%s_%s" % (mod, pytype.__name__)
+        xform = xform.replace(".", "_")
+        try:
+            xform = getattr(self, xform)
+        except AttributeError:
+            raise TypeError("'%s' is not handled by %s." %
+                            (pytype, self.__class__))
+        return xform(col)
+    
+    def float_type(self, precision):
+        """Return a datatype which can handle floats of the given binary precision."""
+        if precision <= 24:
+            return "REAL"
+        else:
+            # Python floats are implemented using C doubles;
+            # actual precision depends on platform.
+            # PostgreSQL DOUBLE is 53 binary-digit precision.
+            return "DOUBLE PRECISION"
+    
+    def coerce_float(self, col):
+        # Note that 'precision' is binary digits, not decimal
+        precision = int(col.hints.get('precision', 0))
+        if precision == 0:
+            precision = self.float_max_precision
+        elif precision > self.float_max_precision:
+            warnings.warn("Float precision %s > maximum %s for %s, "
+                          "using %s. Values may be stored incorrectly."
+                          % (precision, self.float_max_precision,
+                             col.name, self.__class__.__name__),
+                          dejavu.StorageWarning)
+            precision = self.float_max_precision
+        return self.float_type(precision)
+    
+    def coerce_str(self, col):
+        # The bytes hint shall not reflect the usual 4-byte base for varchar.
+        bytes = int(col.hints.get('bytes', 0))
+        if bytes:
+            return "VARCHAR(%s)" % bytes
+        else:
+            # TEXT is not an SQL standard, but it's common.
+            return "TEXT"
+    
+    def coerce_dict(self, col):
+        return self.coerce_str(col)
+    def coerce_list(self, col):
+        return self.coerce_str(col)
+    def coerce_tuple(self, col):
+        return self.coerce_str(col)
+    def coerce_unicode(self, col):
+        return self.coerce_str(col)
+    
+    def coerce_bool(self, col): return "BOOLEAN"
+    
+    def coerce_datetime_datetime(self, col): return "TIMESTAMP"
+    def coerce_datetime_date(self, col): return "DATE"
+    def coerce_datetime_time(self, col): return "TIME"
+    
+    # I was seriously disinterested in writing a parser for interval.
+    def coerce_datetime_timedelta(self, col):
+        return self.coerce_float(col)
+    
+    def decimal_type(self, colname, precision, scale):
+        if precision == 0:
+            precision = self.numeric_max_precision
+        elif precision > self.numeric_max_precision:
+            warnings.warn("Decimal precision %s > maximum %s for %s, "
+                          "using %s. Values may be stored incorrectly."
+                          % (precision, self.numeric_max_precision,
+                             colname, self.__class__.__name__),
+                          dejavu.StorageWarning)
+            precision = self.numeric_max_precision
+        
+        if scale > precision:
+            scale = precision
+        return "NUMERIC(%s, %s)" % (precision, scale)
+    
+    def coerce_decimal_Decimal(self, col):
+        precision = int(col.hints.get('precision', decimal.getcontext().prec))
+        # Assume most people use decimal for money; default scale = 2.
+        scale = int(col.hints.get('scale', 2))
+        return self.decimal_type(col.name, precision, scale)
+    
+    def coerce_decimal(self, col):
+        # If decimal ever becomes a builtin. Python 2.5?
+        return self.coerce_decimal_Decimal(col)
+    
+    def coerce_fixedpoint_FixedPoint(self, col):
+        # Note that fixedpoint has no theoretical precision limit.
+        precision = int(col.hints.get('precision', 0))
+        # Assume most people use fixedpoint for money; default scale = 2.
+        scale = int(col.hints.get('scale', 2))
+        return self.decimal_type(col.name, precision, scale)
+    
+    def int_type(self, bytes):
+        """Return a datatype which can handle the given number of bytes."""
+        if bytes == 1:
+            return "BOOLEAN"
+        elif bytes == 2:
+            return "SMALLINT"
+        elif bytes <= 4:
+            return "INTEGER"
+        elif bytes <= 8:
+            # BIGINT is usually 8 bytes
+            return "BIGINT"
+        else:
+            # Anything larger than 8 bytes, use decimal/numeric.
+            # For PostgreSQL, "The actual storage requirement is two bytes
+            # for each group of four decimal digits, plus eight bytes
+            # overhead." Note we omit the overhead in our calculation.
+            return "NUMERIC(%s, 0)" % (bytes * 2)
+    
+    def coerce_long(self, col):
+        bytes = int(col.hints.get('bytes', self.numeric_max_precision))
+        if bytes == 0:
+            bytes = self.numeric_max_bytes
+        elif bytes > self.numeric_max_bytes:
+            warnings.warn("Long bytes %s > maximum %s for %s, "
+                          "using %s. Values may be stored incorrectly."
+                          % (bytes, self.numeric_max_bytes,
+                             col.name, self.__class__.__name__),
+                          dejavu.StorageWarning)
+            bytes = self.numeric_max_bytes
+        
+        return self.int_type(bytes)
+    
+    def coerce_int(self, col):
+        bytes = int(col.hints.get('bytes', maxint_bytes))
+        if bytes == 0:
+            bytes = maxint_bytes
+        elif bytes > maxint_bytes:
+            warnings.warn("Integer bytes %s > maximum %s for %s, "
+                          "using %s. Values may be stored incorrectly."
+                          % (bytes, maxint_bytes,
+                             col.name, self.__class__.__name__),
+                          dejavu.StorageWarning)
+            bytes = maxint_bytes
+        
+        return self.int_type(bytes)
-
-
@@ -915 +1083 @@
-    adaptertosql = AdapterToSQL()
-    adapterfromdb = AdapterFromDB()
+    typeadapter = TypeAdapter()
-    
-    columnsetclass = ColumnSet
@@ -943 +1112 @@
-        raise TypeError("Database type %s could not be converted "
-                        "to a Python type." % repr(dbtype))
+    
+    def db_type(self, col, pytype):
+        """Return a database type which can store values of the given pytype."""
+        return self.typeadapter.coerce(col, pytype)
-    
-    def __setitem__(self, key, table):
@@ -1023 +1196 @@
-        return self.sql_name(columnkey)
-    
-
+
+
-        name = self.column_name(tablekey, columnkey)
-dbtyp
+Non
-    
-    def table_name(self, key):

trunk/storage/storeado.py

@@ -589 +589 @@
-        adoconn = win32com.client.Dispatch(r'ADODB.Connection')
-        return "ADO Version: %s" % adoconn.Version
-    
-    def _make_column(self, cls, key):
-        dbtype = self.typeAdapter.coerce(cls, key)
-        col = self.db.make_column(cls.__name__, key, dbtype)
-        prop = getattr(cls, key)
-        col.default = prop.default
-        col.hints = prop.hints.copy()
-        if key in cls.identifiers:
-            if isinstance(cls.sequencer, dejavu.UnitSequencerInteger):
-                col.autoincrement = True
-                col.default = cls.sequencer.initial
-        return col
-
-
@@ -630 +618 @@
-
-
-FieldTypeAdapter_SQLServer(db.Field
+TypeAdapter_SQLServer(db.
-    
-    # Hm. Docs say 38, but I can't seem to get more than 12 working.
-    numeric_max_precision = 12
-    
-ls, key
+ol
-        return "BIT"
-    
-ls, key
+ol
-        return "DATETIME"
-    
-ls, key
+ol
-        return "DATETIME"
-    
-ls, key
+ol
-        return "DATETIME"
-    
-ls, key
+ol
-        # The bytes hint does not reflect the usual 4-byte base for varchar.
-
-
+
-        if bytes == 0:
-            # Okay, what the @#$%& is wrong with Redmond??!?! We can't even
@@ -701 +688 @@
-    columnsetclass = SQLServerColumnSet
-    adaptertosql = AdapterToADOSQL_SQLServer()
+    typeadapter = TypeAdapter_SQLServer()
-    
-    def create_database(self):
@@ -751 +739 @@
-class StorageManagerADO_SQLServer(StorageManagerADO):
-    
-    typeAdapter = FieldTypeAdapter_SQLServer()
-    databaseclass = SQLServerDatabase
-    
@@ -809 +796 @@
-
-
-FieldTypeAdapter_MSAccess(db.Field
+TypeAdapter_MSAccess(db.
-    
-    # Hm. Docs say 28/38, but I can't seem to get more than 12 working.
-    numeric_max_precision = 12
-    
-ls, key
-
-ls, key
-ls, key
-ls, key
+ol
+
+ol
+ol
+ol
-    
-    def int_type(self, bytes):
@@ -831 +818 @@
-            return "DECIMAL"
-    
-ls, key
+ol
-        # The bytes hint shall not reflect the usual 4-byte base for varchar.
-
-
+
-        if bytes and bytes <= 255:
-            # 255 chars is the upper limit for TEXT / VARCHAR in MS Access.
@@ -842 +828 @@
-            # in Access UI). But then, 1 GB is the limit for the whole DB.
-            # Note that OpenSchema will return a DATA_TYPE of "WCHAR".
-            for assoc in cls._associations.itervalues():
-                if assoc.nearKey == key:
-                    warnings.warn("Memo fields cannot be used as join keys. "
-                                  "You should set %s.%s(hints={'bytes': 255})"
-                                  % (cls.__name__, key),
-                                  dejavu.StorageWarning)
-            return "MEMO"
-
@@ -896 +876 @@
-    decompiler = ADOSQLDecompiler_MSAccess
-    adaptertosql = AdapterToADOSQL_MSAccess()
+    typeadapter = TypeAdapter_MSAccess()
+    
-    columnsetclass = MSAccessColumnSet
-    
@@ -989 +971 @@
-    
-    use_asterisk_to_get_all = True
-    
-    typeAdapter = FieldTypeAdapter_MSAccess()
-    databaseclass = MSAccessDatabase
-    
@@ -1024 +1004 @@
-        data, col_defs = self.db.fetch("SELECT @@IDENTITY;")
-        setattr(unit, cls.identifiers[0], data[0][0])
-
+
+
+
+
+
+
+
+
+
+
-
-

trunk/storage/storemysql.py

@@ -86 +86 @@
-
-
-
-
+
-    
-    float_max_precision = 53
@@ -102 +101 @@
-        return "FLOAT(%s)" % precision
-    
-
-
-
+
+
-        if bytes:
-            # MySQL VARBINARY/BLOBs will do case-sensitive comparisons.
@@ -111 +109 @@
-                return "VARBINARY(%s)" % bytes
-            elif bytes < 2 ** 16:
-
-
-
-
+
-            elif bytes < 2 ** 24:
-                return "MEDIUMBLOB"
-        return "LONGBLOB"
-    
-ls, key
+ol
-        # We could use BOOLEAN, but it wasn't introduced until 4.1.0.
-        return "BOOL"
-    
-ls, key
+ol
-        return "DATETIME"
-    
-
-
-
+
+
-        if bytes == 1:
-            return "BOOLEAN"
@@ -140 +134 @@
-
-
+class TypeAdapterMySQL41(TypeAdapterMySQL):
+    
+    def coerce_str(self, col):
+        dbtype = TypeAdapterMySQL.coerce_str(self, col)
+        if dbtype == "BLOB":
+            dbtype = "BLOB(%s)" % col.hints['bytes']
+        return dbtype
+
-
-class MySQLIndexSet(db.IndexSet):
@@ -190 +192 @@
-    adaptertosql = AdapterToMySQL()
-    adapterfromdb = AdapterFromMySQL()
+    typeadapter = TypeAdapterMySQL()
-    
-    columnsetclass = MySQLColumnSet
@@ -206 +209 @@
-        v = rowdata[0][0]
-        self._version = storage.Version(v)
+        
+        # decompiler
-        if self._version > storage.Version("4.1.1"):
-            self.decompiler = MySQLDecompiler411
+        
+        # type adapter
+        if self._version >= storage.Version("4.1"):
+            self.typeadapter = TypeAdapterMySQL41()
-    
-    def version(self):
@@ -422 +431 @@
-    """StoreManager to save and retrieve Units via _mysql."""
-    
-    typeAdapter = FieldTypeAdapterMySQL()
-    databaseclass = MySQLDatabase
-    
@@ -436 +444 @@
-        allOptions['name'] = connargs['db']
-        db.StorageManagerDB.__init__(self, name, arena, allOptions)
-        self.typeAdapter.db = self.db
-    
-    def destroy(self, unit):
@@ -492 +499 @@
-        # Attach to self.db, which should call CREATE TABLE.
-        self.db[cls.__name__] = t
-    
-    def _make_column(self, cls, key):
-        dbtype = self.typeAdapter.coerce(cls, key)
-        col = self.db.make_column(cls.__name__, key, dbtype)
-        prop = getattr(cls, key)
-        col.default = prop.default
-        col.hints = prop.hints.copy()
-        
-        if key in cls.identifiers:
-            if isinstance(cls.sequencer, dejavu.UnitSequencerInteger):
-                col.autoincrement = True
-                col.default = cls.sequencer.initial
-        return col

trunk/storage/storepypgsql.py

@@ -318 +318 @@
-                allOptions['name'] = v
-        db.StorageManagerDB.__init__(self, name, arena, allOptions)
-        # Stick a reference to self into the typeAdapter. See coerce_int.
-        self.typeAdapter.sm = self
-    
-    def _seq_UnitSequencerInteger(self, unit):
@@ -347 +345 @@
-        data, col_defs = self.db.fetch("SELECT last_value FROM %s;" % seqname)
-        setattr(unit, idcol, data[0][0])
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+

trunk/storage/storesqlite.py

@@ -141 +141 @@
-
-
-FieldTypeAdapterSQLite(db.Field
-UnitProperty
+TypeAdapterSQLite(db.
+column and Python type
-    
-    From http://www.sqlite.org/datatype3.html:
@@ -164 +164 @@
-    numeric_max_bytes = 7
-    
-    def coerce(self, cls, key):
-        """coerce(cls, key) -> SQL typename for valuetype."""
-        if self.db.typeless:
-            # SQLite can be 'typeless' (but we lose the type introspection)
-            # This will be returned inside _get_columns as NUMERIC.
-            return ""
-        
-        return db.FieldTypeAdapter.coerce(self, cls, key)
-    
-    def float_type(self, precision):
-        """Return a datatype which can handle floats of the given binary precision."""
-        return "REAL"
-    
-ls, key
+ol
-        # The bytes hint shall not reflect the usual 4-byte base for varchar.
-        return "TEXT"
-    
-ls, key
-
-ls, key
-ls, key
-ls, key
+ol
+
+ol
+ol
+ol
-    
-    # I was seriously disinterested in writing a parser for interval.
-ls, key
-ls, key
-
-ls, key
+ol
+ol
+
+ol
-        return "NUMERIC"
-    
-ls, key
+ol
-        return "NUMERIC"
-    
@@ -201 +192 @@
-        return "INTEGER"
-
+
+class TypeAdapterSQLiteTypeless(db.TypeAdapter):
+    
+    def coerce(self, col, pytype):
+        # SQLite can be 'typeless' (but we lose the type introspection)
+        # This will be returned inside _get_columns as NUMERIC.
+        return ""
-
-
@@ -348 +346 @@
-    adaptertosql = AdapterToSQLite()
-    adapterfromdb = AdapterFromSQLite()
+    typeadapter = TypeAdapterSQLite()
-    
-    columnsetclass = SQLiteColumnSet
-    
-    typeless = False
-    
-    def _get_tables(self, conn=None):
@@ -392 +389 @@
-    def python_type(self, dbtype):
-        """Return a Python type which can store values of the given dbtype."""
-self.typeless
+isinstance(self.typeadapter, TypeAdapterSQLiteTypeless)
-            return str
-        
@@ -520 +517 @@
-    """StoreManager to save and retrieve Units via _sqlite."""
-    
-    typeAdapter = FieldTypeAdapterSQLite()
-    databaseclass = SQLiteDatabase
-    
@@ -531 +527 @@
-        allOptions['mode'] = int(allOptions.pop('Mode', '0755'), 8)
-        db.StorageManagerDB.__init__(self, name, arena, allOptions)
-        self.typeAdapter.db = self.db
-    
-    def version(self):
@@ -641 +636 @@
-    def _make_column(self, cls, key):
-        col = db.StorageManagerDB._make_column(self, cls, key)
-
-
-
-
+
+
+
-        return col
-

trunk/test/test_storemsaccess.py

@@ -19 +19 @@
-    else:
-        
-Field
+
-            """Stores Decimal and FixedPoint objects as CURRENCY."""
-            
-ls, key
+ol
-                return "CURRENCY"
-
-ls, key
+ol
-                return "CURRENCY"
-            
@@ -42 +42 @@
-            def test_currency(obj):
-                sm = zoo_fixture.arena.stores['testSM']
-typeA
+db.typea
-                
-                for c, p in [('Exhibit', 'Acreage'), ('Zoo', 'Admission')]:
@@ -65 +65 @@
-            
-            # plugin the adapter for testing CURRENCY columns
-StorageManagerADO_MSAccess.typeA
+MSAccessDatabase.typea
-            
-            reload(zoo_fixture)

trunk/test/zoo_fixture.py

@@ -209 +209 @@
-        self.assertEqual(leopard.PreviousZoos, None)
-        box.memorize(leopard)
+        self.assertEqual(leopard.ID, 1)
+        
-        leopard.add(WAP)
-        leopard.LastEscape = datetime.datetime(2004, 12, 21, 8, 15, 0)
@@ -859 +861 @@
-        import math
-        sm = arena.stores['testSM']
-typeAdapter
-typeA
-typeA
+db
+db.typea
+db.typea
-        else:
-            num_prec_log2 = 9