Changeset 229

Timestamp:

07/18/06 20:28:17

Author:

fumanchu

Message:

Bah. The DB Introspection test wasn't running. Here are fixes for MySQL, PostreSQL. More fixes coming.

Files:

• trunk/storage/db.py (modified) (3 diffs)
• trunk/storage/dbmodel.py (modified) (2 diffs)
• trunk/storage/storemysql.py (modified) (9 diffs)
• trunk/storage/storepypgsql.py (modified) (13 diffs)
• trunk/test/zoo_fixture.py (modified) (5 diffs)

trunk/storage/db.py

@@ -731 +731 @@
-        del self.db[cls.__name__].columns.indices[name]
-    
-, conn=None
+
-        """Map new Table objects to all registered classes."""
-        # Use the superclass call to avoid DROP TABLE.
-        dict.clear(self.db)
-conn
+
-        for cls in self.arena._registered_classes:
-            # Try to find a matching Table object from _get_tables.
-
+db.
-            if t:
-                t = t[0]
@@ -744 +744 @@
-                for ckey in cls.properties:
-                    # Try to find a matching Column object from _get_columns.
-
+db.
-                    if c:
-                        c = c[0]
@@ -752 +752 @@
-                dbindices = self.db._get_indices(t.name)
-                for ikey in cls.indices():
-
+db.
-                    # Try to find a matching Column object from _get_columns.
-                    i = [x for x in dbindices if x.name == iname]

trunk/storage/dbmodel.py

@@ -839 +839 @@
-        
-        t.db.execute("ALTER TABLE %s ADD COLUMN %s %s%s;" %
-      
+
-        dict.__setitem__(self, key, column)
-    
@@ -854 +854 @@
-        t = self.table
-        t.db.execute("ALTER TABLE %s RENAME COLUMN %s TO %s;" %
-      
+
-    
-    def rename(self, oldkey, newkey):

trunk/storage/storemysql.py

@@ -95 +95 @@
-    def float_type(self, precision):
-        """Return a datatype which can handle the given precision."""
-
-
-
-
+
+
+
+
+
+
-    
-    def coerce_str(self, cls, key):
@@ -109 +111 @@
-                return "VARBINARY(%s)" % bytes
-            elif bytes < 2 ** 16:
-
+
+
+
+
-            elif bytes < 2 ** 24:
-                return "MEDIUMBLOB"
@@ -176 +181 @@
-    indexsetclass = MySQLIndexSet
-    
+    def __init__(self, name, **kwargs):
+        db.Database.__init__(self, name, **kwargs)
+        
+        self.decompiler = MySQLDecompiler
+        
+        # Get the version string from MySQL, to see if we need
+        # a different decompiler.
+        conn = self._template_conn()
+        rowdata, cols = self.fetch("SELECT version();", conn)
+        conn.close()
+        v = rowdata[0][0]
+        self._version = storage.Version(v)
+        if self._version > storage.Version("4.1.1"):
+            self.decompiler = MySQLDecompiler411
+    
+    def version(self):
+        return "MySQL Version: %s" % self._version
+    
-    def __setitem__(self, key, table):
-        q = self.quote
@@ -184 +207 @@
-            qname = col.qname
-            dbtype = col.dbtype
-
+
+
+
+
+
+
+
+
-            # See create_storage for the other half of this hack.
-            if colname in table.mysql_identifiers:
@@ -233 +263 @@
-        # cols are: Field, Type, Null, Key, Default, Extra.
-        # See http://dev.mysql.com/doc/refman/4.1/en/describe.html
-        q = self.quote
-        data, _ = self.fetch("SHOW COLUMNS FROM %s.%s" %
-q
+self.quote
-        cols = []
-        for row in data:
-row[4]
-
-
+None
+
+.upper()
-            parenpos = dbtype.find("(")
-            if parenpos > -1:
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            c.dbtype = dbtype
-            
-            cols.append(c)
-        return cols
+    
+    def _get_indices(self, tablename, conn=None):
+        indices = []
+        try:
+            # cols are: Table, Non_unique, Key_name, Seq_in_index, Column_name,
+            # Collation, Cardinality, Sub_part, Packed, Null, Index_type, Comment
+            data, _ = self.fetch("SHOW INDEX FROM %s.%s"
+                                 % (self.qname, self.quote(tablename)),
+                                 conn=conn)
+        except _mysql.ProgrammingError, x:
+            if x.args[0] != 1146:
+                raise
+        else:
+            for row in data:
+                i = db.Index(row[2], self.quote(row[2]),
+                             row[0], row[4], None, not row[1])
+                indices.append(i)
+        return indices
-    
-    def python_type(self, dbtype):
-        """Return a Python type which can store values of the given dbtype."""
-        dbtype = dbtype.upper()
-
-
-
-
+
+
+
+
+
+
-            return int
-        elif dbtype == 'BIGINT':
@@ -262 +335 @@
-        elif dbtype in ('FLOAT', 'DOUBLE', 'DOUBLE PRECISION', 'REAL'):
-            return float
-.startswith('DECIMAL') or dbtype.startswith(
+ in ('DECIMAL', 
-            if db.decimal:
-                return db.decimal.Decimal
@@ -273 +346 @@
-        elif dbtype == 'TIME':
-            return datetime.time
-
-
-
-
-
+
+
+
+
-        
-        raise TypeError("Database type %s could not be converted "
-                        "to a Python type." % repr(dbtype))
-    
-    def _get_indices(self, tablename, conn=None):
-        indices = []
-        try:
-            # cols are: Table, Non_unique, Key_name, Seq_in_index, Column_name,
-            # Collation, Cardinality, Sub_part, Packed, Null, Index_type, Comment
-            q = self.sm.quote
-            data, _ = self.fetch("SHOW INDEX FROM %s.%s"
-                                 % (self.qname, q(tablename)), conn=conn)
-        except _mysql.ProgrammingError, x:
-            if x.args[0] != 1146:
-                raise
-        else:
-            for row in data:
-                i = db.Index(row[2], self.quote(row[2]),
-                             row[0], row[4], None, not row[1])
-                indices.append(i)
-        return indices
-    
-    def quote(self, name):
@@ -363 +417 @@
-                         if k in connargs])
-        allOptions['connargs'] = connargs
-        
-        allOptions['name'] = connargs['db']
-        
-        db.StorageManagerDB.__init__(self, name, arena, allOptions)
-
-
-
-
-
-
-
-
-
-
-
+
-    
-    def destroy(self, unit):
@@ -383 +425 @@
-        t = self.db[unit.__class__.__name__].qname
-        self.db.execute('DELETE FROM %s WHERE %s;' % (t, self.id_clause(unit)))
-    
-    def version(self):
-        return "MySQL Version: %s" % self._version
-    
-    def _seq_UnitSequencerInteger(self, unit):

trunk/storage/storepypgsql.py

@@ -12 +12 @@
-    like_escapes = [("%", r"\\%"), ("_", r"\\_")]
-
-
-class FieldTypeAdapterPgSQL(db.FieldTypeAdapter):
-    
-    def coerce_int(self, cls, key):
-        prop = getattr(cls, key)
-        if isinstance(cls.sequencer, dejavu.UnitSequencerInteger):
-            if key in cls.identifiers:
-                seqname = self.sm.db.quote("%s_%s_seq" % (cls.__name__, key))
-                return "INTEGER DEFAULT nextval('%s') NOT NULL" % seqname
-        bytes = int(prop.hints.get('bytes', db.maxint_bytes))
-        return self.int_type(bytes)
-
-
@@ -68 +57 @@
-        self.table = table
-        self.indices = PgIndexSet(self.table)
+    
+    def __setitem__(self, key, column):
+        t = self.table
+        if key in self:
+            del self[key]
+        
+        default = column.default or ""
+        if default:
+            if not(isinstance(default, str)
+                   and default.startswith("nextval(")):
+                default = t.db.adaptertosql.coerce(default)
+            default = " DEFAULT %s" % default
+        
+        t.db.execute("ALTER TABLE %s ADD COLUMN %s %s%s;" %
+                     (t.qname, column.qname, column.dbtype, default))
+        dict.__setitem__(self, key, column)
-
-
@@ -89 +94 @@
-                             % tablename, conn=conn)
-        table_OID = data[0][0]
+        
-        sql = ("SELECT attname, atttypid, attnum, attlen, atttypmod "
-               "FROM pg_attribute WHERE attrelid = %s" % table_OID)
@@ -110 +116 @@
-            
-            if dbtype in ('float4', 'float8', 'money', 'numeric'):
-4
+3
-            
-            # Default value
@@ -118 +124 @@
-            if default:
-                default = default[0][0]
-                # Sequences
-                if default.startswith("nextval("):
-
+
+
-                else:
-                    # adsrc is always a string, so we must cast
@@ -139 +145 @@
-            cols.append(c)
-        return cols
-        
-        raise TypeError("Database type %s could not be converted "
-                        "to a Python type." % repr(dbtype))
-    
-    def _get_indices(self, tablename, conn=None):
@@ -171 +174 @@
-    def python_type(self, dbtype):
-        """Return a Python type which can store values of the given dbtype."""
-        if "nextval(" in dbtype:
-            return int
-        
-        dbtype = dbtype.upper()
-        if dbtype in ('INT2', 'INT4', 'INTEGER'):
@@ -181 +181 @@
-        elif dbtype == 'INT8':
-            return long
-
+, 'REAL'
-            return float
-        elif dbtype.startswith('NUMERIC'):
@@ -197 +197 @@
-            if dbtype.startswith(t):
-                return str
+        
+        raise TypeError("Database type %s could not be converted "
+                        "to a Python type." % repr(dbtype))
+    
+    def __setitem__(self, key, table):
+        if key in self:
+            del self[key]
+        
+        fields = []
+        for col in table.columns.itervalues():
+            default = col.default or ""
+            if default:
+                if not(isinstance(default, str)
+                       and default.startswith("nextval(")):
+                    default = self.adaptertosql.coerce(default)
+                default = " DEFAULT %s" % default
+            f = '%s %s%s' % (col.qname, col.dbtype, default)
+            fields.append(f)
+        
+        self.execute('CREATE TABLE %s (%s);' %
+                     (table.qname, ", ".join(fields)))
+        
+        for index in table.columns.indices.itervalues():
+            self.execute('CREATE INDEX %s ON %s (%s);' %
+                         (index.qname, table.qname,
+                          self.quote(index.colname)))
+        
+        dict.__setitem__(self, key, table)
-    
-    def quote(self, name):
@@ -266 +294 @@
-    
-    databaseclass = PgDatabase
-    typeAdapter = FieldTypeAdapterPgSQL()
-    
-    def __init__(self, name, arena, allOptions={}):
@@ -286 +313 @@
-        for key in cls.properties:
-            col = t.columns[key]
-'nextval' in col.dbtype
+isinstance(col.default, str) and col.default.startswith('nextval')
-                # Skip this field, since we're using a sequencer
-                continue
@@ -313 +340 @@
-        fields = []
-        for key in cls.properties:
-            dbtype = self.typeAdapter.coerce(cls, key)
-            
-            col = self.db.make_column(cls.__name__, key, dbtype)
-            
-            prop = cls.property(key)
-            col.default = prop.default
-            col.hints = prop.hints.copy()
-            
-            # Here's where we differ from the superclass:
-            # we have to manually CREATE SEQUENCE,
-            # and use class attributes to do so.
-            if 'nextval' in dbtype:
-                seqname = self.db.quote("%s_%s_seq" % (t.name, col.name))
-                self.db.execute("CREATE SEQUENCE %s START %s;"
-                                % (seqname, cls.sequencer.initial))
-            
-            # Use the superclass call to avoid ALTER TABLE.
-col
+self.make_column(cls, key)
-            
-            if key in indices:
@@ -339 +350 @@
-        # Attach to self.db, which should call CREATE TABLE.
-        self.db[cls.__name__] = t
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

trunk/test/zoo_fixture.py

@@ -59 +59 @@
-    PreviousZoos = UnitProperty(list, hints={'bytes': 1000})
-    LastEscape = EscapeProperty(datetime.datetime)
-bytes
-bytes
+precision
+precision
-    MotherID = UnitProperty(int)
-
@@ -786 +786 @@
-    def test_DB_Introspection(self):
-        s = arena.stores.values()[0]
-tables
+db
-            return
-        
-tables
+db
-        cols = zootable.columns
-        self.assertEqual(len(cols), 6)
-        idcol = cols['ID']
-        # Since SQLite is typeless, it always returns 'str'
-
-
+
-        
-        # Test the automatic construction of Unit classes.
@@ -801 +800 @@
-            for cls in (Zoo, Animal):
-                print cls.__name__,
-tables
+db
-                uc = s.autoclass(t, cls.__name__)
-                self.assert_(not issubclass(uc, cls))
@@ -814 +813 @@
-                    for k, v in orig.hints.iteritems():
-                        if isinstance(v, (int, long)):
-
+
+
-                        else:
-                            self.assertEqual(copy.hints[k], v)
@@ -961 +961 @@
-    engines.register_classes(arena)
-    
-tables
+db
-        arena.stores['testSM'].sync()
-