Changeset 127

Timestamp:

12/21/05 02:48:04

Author:

fumanchu

Message:

Initial implementation of #16 (schema changes). See modeling.html ("Managing Schema Changes") for summary. Oh, and Unit has a new remove_property method.

Files:

• trunk/__init__.py (modified) (1 diff)
• trunk/arenas.py (modified) (2 diffs)
• trunk/doc/index.html (modified) (1 diff)
• trunk/doc/modeling.html (modified) (1 diff)
• trunk/schemas.py (added)
• trunk/storage/__init__.py (modified) (5 diffs)
• trunk/storage/db.py (modified) (3 diffs)
• trunk/storage/storeado.py (modified) (5 diffs)
• trunk/storage/storemysql.py (modified) (3 diffs)
• trunk/storage/storepypgsql.py (modified) (2 diffs)
• trunk/storage/storeshelve.py (modified) (2 diffs)
• trunk/storage/storesqlite.py (modified) (4 diffs)
• trunk/test/test_dejavu.py (modified) (1 diff)
• trunk/test/test_storeburned.py (modified) (2 diffs)
• trunk/test/test_storecaching.py (modified) (2 diffs)
• trunk/test/test_storemsaccess.py (modified) (1 diff)
• trunk/test/test_storemysql.py (modified) (1 diff)
• trunk/test/test_storeproxy.py (modified) (2 diffs)
• trunk/test/test_storepypgsql.py (modified) (1 diff)
• trunk/test/test_storeshelve.py (modified) (1 diff)
• trunk/test/test_storesqlite.py (modified) (1 diff)
• trunk/test/test_storesqlserver.py (modified) (1 diff)
• trunk/test/zoo_fixture.py (modified) (3 diffs)
• trunk/units.py (modified) (3 diffs)

trunk/__init__.py

@@ -42 +42 @@
-from dejavu.containers import *
-from dejavu.errors import *
+from dejavu.schemas import *
-from dejavu.units import *
-from dejavu import logic

trunk/arenas.py

@@ -149 +149 @@
-        self.storage(cls).create_storage(cls)
-    
+    def has_storage(self, cls):
+        return self.storage(cls).has_storage(cls)
+    
+    def drop_storage(self, cls):
+        self.storage(cls).drop_storage(cls)
+    
+    def add_property(self, cls, name):
+        self.storage(cls).add_property(cls, name)
+    
+    def drop_property(self, cls, name):
+        self.storage(cls).drop_property(cls, name)
+    
+    def rename_property(self, cls, oldname, newname):
+        self.storage(cls).rename_property(cls, oldname, newname)
+    
-    def migrate_class(self, cls, new_store):
-        """migrate_class(cls, new_store). Copy all units of cls to new_store."""
@@ -249 +264 @@
-        classes = [c for c in self.arena._registered_classes.iterkeys()
-                   if issubclass(c, cls)]
+        if not classes:
+            # Even the requested class is not registered.
+            raise errors.UnrecallableError("The '%s' class is not registered."
+                                           % cls.__name__)
-        
-        for cls in classes:

trunk/doc/index.html

@@ -56 +56 @@
-        <li>Loading Stores</li>
-        <li>Registering Unit Classes</li>
+        <li>Managing Schema Changes</li>
-        </ul>
-    </li>

trunk/doc/modeling.html

@@ -688 +688 @@
-the chain of associations between two Unit classes.</p>
-
+<h4>Managing Schema Changes</h4>
+<p>The <tt>Schema</tt> class helps you manage changes to your
+Dejavu model throughout its lifetime. For example, let's say that we deploy
+our Archaeology application at various libraries around the world. After
+a year, one of the developers wishes to implement a new reporting feature;
+however, it would be easiest to build if the Unit Property names could
+be exposed to the users. Unfortunately, our "ArchID" property on the
+Biography class isn't very informative. It would be better if we could
+rename that to "ArchaeologistID":</p>
+
+<pre>class ArchBioSchema(dejavu.Schema):
+    
+    guid = 'da39a3ee5e6b4b0d3255bfef95601890afd80709'
+    latest = 2
+    
+    def upgrade_to_2(self):
+        self.arena.rename_property(Biography, "ArchID", "ArchaeologistID")
+
+abs = ArchBioSchema(arena)
+abs.upgrade()
+</pre>
+
+<p>Assuming we've already made the change to our model, the above example
+renames the property in the persistence layer (the database). There are
+also <tt class='def'>add_property(name)</tt> and
+<tt class='def'>drop_property(name)</tt> methods. There may be more methods
+in future versions of Dejavu; this feature is pretty new.</p>
+
+<p>The example also declares this change to be "version 2" of our schema.
+If you examine the base Schema class, you will see that it already has an
+<tt>upgrade_to_0</tt> method and an <tt>upgrade_to_1</tt> method. The
+"zeroth" upgrade makes no schema changes; it merely marks all deployed
+databases with "version 0". The upgrade to version 1 will automatically
+create all of your existing tables for you. Once you've made your first
+change to the initial schema, you can write your own <tt>upgrade_to_2</tt>
+method as we did above.</p>
+
+<p>If you call <tt class='def'>upgrade(version)</tt> with a version argument,
+then your deployment will be upgraded to that version. If no argument is
+given, the installation will be upgraded to <tt>Schema.latest</tt>. You
+can even skip steps (i.e. remove broken steps) if it comes to that.</p>
+
+<h5>The DeployedVersion Unit</h5>
+
+<p>The <tt>Schema</tt> class uses a magic table in the database to keep
+track of each deployment's schema version. The Unit class is called
+"DeployedVersion", and it has ID and Version attributes.</p>
+
+<p>The ID attribute will be set to whatever your <tt>Schema.guid</tt>
+is. It's a simple way to isolate multiple installed Dejavu applications.
+A given application should use the same guid throughout its lifetime.
+I used <tt>sha.new().hexdigest()</tt> to generate the example. Feel free
+to use sha.new, a guid generator, a descriptive name, or whatever you
+like.</p>
+
+<p>If you introduce schemas after you've deployed, you should probably
+skip upgrade #1 by manually setting <tt>DeployedVersion.Version</tt>
+to 1 (or whatever is accurate) at each of your installations.</p>
+
+
-<hr />
-

trunk/storage/__init__.py

@@ -40 +40 @@
-        raise NotImplementedError
-    
-    def create_storage(self, unitClass):
-        pass
-    
-    def reserve(self, unit):
-        """Reserve storage space for the Unit."""
@@ -55 +52 @@
-    
-    def distinct(self, cls, attrs, expr=None):
-distinct(cls, attrs, expr=None) -> 
+
-        raise NotImplementedError
-    
-    def multirecall(self, classes, expr):
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
@@ -90 +113 @@
-            self.nextstore.destroy(unit)
-    
-    def create_storage(self, unitClass):
-        if self.nextstore:
-            self.nextstore.create_storage(unitClass)
-    
-    def reserve(self, unit):
-        """Reserve storage space for the Unit."""
@@ -113 +132 @@
-        if self.nextstore:
-            return self.nextstore.multirecall(classes, expr)
+    
+    #                               Schemas                               #
+    
+    def create_database(self):
+        if self.nextstore:
+            self.nextstore.create_database()
+    
+    def drop_database(self):
+        if self.nextstore:
+            self.nextstore.drop_database()
+    
+    def create_storage(self, cls):
+        if self.nextstore:
+            self.nextstore.create_storage(cls)
+    
+    def has_storage(self, cls):
+        if self.nextstore:
+            return self.nextstore.has_storage(cls)
+        return False
+    
+    def drop_storage(self, cls):
+        if self.nextstore:
+            self.nextstore.drop_storage(cls)
+    
+    def add_property(self, cls, name):
+        if self.nextstore:
+            self.nextstore.add_property(cls, name)
+    
+    def drop_property(self, cls, name):
+        if self.nextstore:
+            self.nextstore.drop_property(cls, name)
+    
+    def rename_property(self, cls, oldname, newname):
+        if self.nextstore:
+            self.nextstore.rename_property(cls, oldname, newname)
-
-
@@ -335 +389 @@
-            # .cancel does nothing if the thread is already finished.
-            self.timer.cancel()
+    
+    def add_property(self, cls, name):
+        self.sweep(cls)
+        if self.nextstore:
+            self.nextstore.add_property(cls, name)
+    
+    def drop_property(self, cls, name):
+        self.sweep(cls)
+        if self.nextstore:
+            self.nextstore.drop_property(cls, name)
+    
+    def rename_property(self, cls, oldname, newname):
+        self.sweep(cls)
+        if self.nextstore:
+            self.nextstore.rename_property(cls, oldname, newname)
-
-

trunk/storage/db.py

@@ -867 +867 @@
-            getattr(conn, self.close_connection_method)()
-    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-        tablename = self.table_name(clsname)
-        if fields:
@@ -1058 +1036 @@
-                                     (self.column_name(clsname, key), val))
-            
-
-
-
-
+
+
+
+
+
-            unit.cleanse()
-    
@@ -1296 +1275 @@
-            if acceptable:
-                yield unitset
+    
+    #                               Schemas                               #
+    
+    def create_database(self):
+        self.execute("CREATE DATABASE %s;" % self.sql_name(self.dbname))
+    
+    def drop_database(self):
+        self.execute("DROP DATABASE %s;" % self.sql_name(self.dbname))
+    
+    def create_storage(self, cls):
+        """Create storage for the given class."""
+        clsname = cls.__name__
+        tablename = self.table_name(clsname)
+        typename = self.typeAdapter.coerce
+        
+        fields = []
+        for key in cls.properties():
+            fields.append(u'%s %s' % (self.column_name(clsname, key),
+                                      typename(cls, key)))
+        self.execute(u'CREATE TABLE %s (%s);' % (tablename, ", ".join(fields)))
+        
+        for index in cls.indices():
+            i = self.table_name("i" + clsname + index)
+            self.execute(u'CREATE INDEX %s ON %s (%s);' %
+                         (i, tablename, self.column_name(clsname, index)))
+    
+    def has_storage(self, cls):
+        try:
+            # Must use fetch here instead of execute, because e.g. MySQL
+            # must call store_result if the query has a result set
+            # (or it will crash on a subsequent execute).
+            self.fetch("SELECT * FROM %s WHERE 1=0;" % self.table_name(cls.__name__))
+        except:
+            return False
+        return True
+    
+    def drop_storage(self, cls):
+        self.execute(u'DROP TABLE %s;' % self.table_name(cls.__name__))
+    
+    def add_property(self, cls, name):
+        clsname = cls.__name__
+        self.execute("ALTER TABLE %s ADD COLUMN %s %s;" %
+                     (self.table_name(clsname),
+                      self.column_name(clsname, name),
+                      self.typeAdapter.coerce(cls, name),
+                      ))
+    
+    def drop_property(self, cls, name):
+        clsname = cls.__name__
+        self.execute("ALTER TABLE %s DROP COLUMN %s;" %
+                     (self.table_name(clsname),
+                      self.column_name(clsname, name)))
+    
+    def rename_property(self, cls, oldname, newname):
+        clsname = cls.__name__
+        oldname = self.column_name(clsname, oldname)
+        newname = self.column_name(clsname, newname)
+        if oldname != newname:
+            self.execute("ALTER TABLE %s RENAME COLUMN %s TO %s;" %
+                         (self.table_name(clsname), oldname, newname))
-
-

trunk/storage/storeado.py

@@ -44 +44 @@
-adLockOptimistic = 3
-adLockBatchOptimistic = 4
+
+adSchemaColumns = 3
+adSchemaTables = 20
-
-adUseClient = 3
@@ -357 +360 @@
-            x.args += (query, )
-            conn = None
- x
-
-
+
+
+, schema=False
-        """fetch(query, conn=None) -> rowdata, columns."""
-        if conn is None:
-            conn = self.connection()
-        self.arena.log(query, dejavu.LOGSQL)
-        
-        res = win32com.client.Dispatch(r'ADODB.Recordset')
-        # Uncomment the following to get .Recordcount
-        # res.CursorLocation = adUseClient
-        try:
-
-
-
-
+
+
-            else:
-
+
+
+
+
+
+
+
+
-        except pywintypes.com_error, x:
-            try:
@@ -382 +386 @@
-            x.args += (query, )
-            conn = None
- x
+
-        
-        columns = [(x.Name, x.Type) for x in res.Fields]
@@ -397 +401 @@
-        
-        return data, columns
-    
+
-    def version(self):
-        adoconn = win32com.client.Dispatch(r'ADODB.Connection')
-        return "ADO Version: %s" % adoconn.Version
+    
+    def get_tables(self, conn=None):
+        return self.fetch(adSchemaTables, conn=conn, schema=True)
+    
+    def has_storage(self, cls):
+        names = [x[2] for x in self.get_tables()[0]]
+        return self.table_name(cls.__name__, quoted=False) in names
+    
+    def get_columns(self, conn=None):
+        return self.fetch(adSchemaColumns, conn=conn, schema=True)
+    
+    def rename_property(self, cls, oldname, newname):
+        clsname = cls.__name__
+        tblname = self.table_name(clsname, quoted=False)
+        oldname = self.column_name(clsname, oldname, quoted=False)
+        newname = self.column_name(clsname, newname, quoted=False)
+         
+        conn = self.connection()
+        try:
+            cat = win32com.client.Dispatch(r'ADOX.Catalog')
+            cat.ActiveConnection = conn
+            cat.Tables(tblname).Columns(oldname).Name = newname
+        except pywintypes.com_error, x:
+            conn = None
+            cat = None
+            raise
-
-
@@ -492 +522 @@
-        adoconn.Execute("DROP DATABASE %s;" % self.sql_name(self.dbname))
-        adoconn.Close()
+    
+    def add_property(self, cls, name):
+        clsname = cls.__name__
+        # SQL Server doesn't use the "COLUMN" keyword with "ADD"
+        self.execute("ALTER TABLE %s ADD %s %s;" %
+                     (self.table_name(clsname),
+                      self.column_name(clsname, name),
+                      self.typeAdapter.coerce(cls, name),
+                      ))
+    
+    def rename_property(self, cls, oldname, newname):
+        clsname = cls.__name__
+        oldname = self.column_name(clsname, oldname, quoted=False)
+        newname = self.column_name(clsname, newname, quoted=False)
+        if oldname != newname:
+            self.execute("EXEC sp_rename '%s.%s', '%s', 'COLUMN'" %
+                         (self.table_name(clsname), oldname, newname))
-
-

trunk/storage/storemysql.py

@@ -98 +98 @@
-            # They also won't truncate trailing spaces like VARCHAR does.
-            if bytes <= 255:
- CHARACTER SET utf8
+
-            elif bytes < 2 ** 16:
-                return "BLOB"
@@ -173 +173 @@
-        return _mysql.connect(**tmplconn)
-    
-    def create_database(self):
-        # _mysql has create_db and drop_db commands, but they're deprecated.
-        sql = 'CREATE DATABASE %s;' % self.sql_name(self.dbname)
-        conn = self._template_conn()
-        self.execute(sql, conn)
-        conn.close()
-    
-    def drop_database(self):
-        sql = 'DROP DATABASE %s;' % self.sql_name(self.dbname)
-        conn = self._template_conn()
-        self.execute(sql, conn)
-        conn.close()
-    
-    def version(self):
-        conn = self._template_conn()
-        rowdata, cols = self.fetch("SELECT version();", conn)
-        conn.close()
-        return "MySQL Version: %s" % rowdata[0][0]
-    
-    def create_storage(self, unitClass):
-        clsname = unitClass.__name__
-        tablename = self.table_name(clsname)
-        
-        coerce = self.typeAdapter.coerce
-        fields = []
-        for key in unitClass.properties():
-            fields.append(u'%s %s' % (self.column_name(clsname, key),
-                                      coerce(unitClass, key)))
-        self.execute(u'CREATE TABLE %s (%s);' % (tablename, ", ".join(fields)))
-        
-        for index in unitClass.indices():
-            i = self.table_name("i" + clsname + index)
-            
-            dbtype = coerce(unitClass, index)
-            if dbtype.endswith('BLOB') or dbtype == 'TEXT':
-                # MySQL won't allow indexes on a BLOB field
-                # without a specific length.
-                self.execute(u'CREATE INDEX %s ON %s (%s(%s));' %
-                             (i, tablename,
-                              self.column_name(clsname, index), 255))
-            else:
-                self.execute(u'CREATE INDEX %s ON %s (%s);' %
-                             (i, tablename,
-                              self.column_name(clsname, index)))
-    
-    def fetch(self, query, conn=None):
-        """fetch(query, conn=None) -> rowdata, columns.
@@ -238 +193 @@
-                     (self.table_name(unit.__class__.__name__),
-                      self.id_clause(unit)))
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

trunk/storage/storepypgsql.py

@@ -84 +84 @@
-        return libpq.PQconnectdb(tmplconn)
-    
-    def create_database(self):
-        c = self._template_conn()
-        self.execute('CREATE DATABASE %s' % self.sql_name(self.dbname), c)
-        c.finish()
-    
-    def drop_database(self):
-        c = self._template_conn()
-        self.execute("DROP DATABASE %s;" % self.sql_name(self.dbname), c)
-        c.finish()
-    
-    def version(self):
-        c = self._template_conn()
@@ -114 +104 @@
-        
-        return data, columns
+    
+    def create_database(self):
+        c = self._template_conn()
+        self.execute('CREATE DATABASE %s' % self.sql_name(self.dbname), c)
+        c.finish()
+    
+    def drop_database(self):
+        c = self._template_conn()
+        self.execute("DROP DATABASE %s;" % self.sql_name(self.dbname), c)
+        c.finish()
+    
+    def has_storage(self, cls):
+        # For some odd reason, libpq errors if you try to filter by tablename.
+        sql = u"SELECT tablename FROM pg_tables"
+        data, cols = self.fetch(sql)
+        return [self.table_name(cls.__name__, quoted=False)] in data
-

trunk/storage/storeshelve.py

@@ -111 +111 @@
-            lock.release()
-    
-    def create_database(self):
-        if not os.path.exists(self.shelvepath):
-            os.makedirs(self.shelvepath)
-    
-    def drop_database(self):
-        while self.shelves:
-            clsname, shelf = self.shelves.popitem()
-            shelf.close()
-            tbl = os.path.join(self.shelvepath, clsname)
-            os.remove(tbl)
-    
-    def version(self):
-        import sys
-        return "Shelve version: %s" % sys.version
-    
-    def create_storage(self, unitClass):
-        pass
-    
-    def view(self, cls, fields, expr=None):
@@ -252 +238 @@
-                yield unitrow
-
+    #                               Schemas                               #
+    
+    def create_database(self):
+        if not os.path.exists(self.shelvepath):
+            os.makedirs(self.shelvepath)
+    
+    def drop_database(self):
+        while self.shelves:
+            clsname, shelf = self.shelves.popitem()
+            shelf.close()
+            tbl = os.path.join(self.shelvepath, clsname)
+            os.remove(tbl)
+    
+    def create_storage(self, cls):
+        pass
+    
+    def has_storage(self, cls):
+        return cls.__name__ in self.shelves
+    
+    def drop_storage(self, cls):
+        clsname = cls.__name__
+        shelf = self.shelves.pop(clsname)
+        shelf.close()
+        tbl = os.path.join(self.shelvepath, clsname)
+        os.remove(tbl)
+    
+    def add_property(self, cls, name):
+        data, lock = self.shelf(cls)
+        try:
+            for id, props in data.items():
+                props[name] = None
+                data[id] = props
+        finally:
+            lock.release()
+    
+    def drop_property(self, cls, name):
+        data, lock = self.shelf(cls)
+        try:
+            for id, props in data.items():
+                del props[name]
+                data[id] = props
+        finally:
+            lock.release()
+    
+    def rename_property(self, cls, oldname, newname):
+        data, lock = self.shelf(cls)
+        try:
+            for id, props in data.items():
+                props[newname] = props[oldname]
+                del props[oldname]
+                data[id] = props
+        finally:
+            lock.release()

trunk/storage/storesqlite.py

@@ -16 +16 @@
-    import warnings
-    warnings.warn(_escape_warning, dejavu.StorageWarning)
+
+_add_column_support = (_version >= storage.Version([3, 2, 0]))
+_rename_table_support = (_version >= storage.Version([3, 1, 0]))
-
-
@@ -163 +166 @@
-        # SQLite should create the DB if missing.
-        return _sqlite.connect(self.database, self.mode)
-    
-    create_database = _get_conn
-    
-    def drop_database(self):
-        self.shutdown()
-        # This should accept relative or absolute paths
-        os.remove(self.database)
-    
-    def version(self):
@@ -192 +188 @@
-                     (self.table_name(unit.__class__.__name__),
-                      self.id_clause(unit)))
-    
-    def create_storage(self, unitClass):
-        clsname = unitClass.__name__
-        tablename = self.table_name(clsname)
-        
-        # SQLite is typeless.
-        fields = [self.column_name(clsname, key)
-                  for key in unitClass.properties()]
-        
-        self.execute(u'CREATE TABLE %s (%s);' % (tablename, ", ".join(fields)))
-        for index in unitClass.indices():
-            i = self.table_name("i" + clsname + index)
-            self.execute(u'CREATE INDEX %s ON %s (%s);' %
-                         (i, tablename, self.column_name(clsname, index)))
-    
-    def join(self, unitjoin):
@@ -287 +269 @@
-                     (u', '.join(colnames), joins, w))
-        return statement, imp, columns
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

trunk/test/test_dejavu.py

@@ -9 +9 @@
-
-arena.add_store("default", "dejavu.storage.CachingProxy")
+arena.register(Animal)
+arena.register(Lecture)
+arena.register(Vet)
+arena.register(Visit)
+arena.register(Zoo)
-
-

trunk/test/test_storeburned.py

@@ -1 +1 @@
-import os
-import zoo_fixture
-
-zoo_fixture.init()
-shelvedb = "dejavu.storage.storeshelve.StorageManagerShelve"
-proxiedopts = {u'Path': os.path.join(os.getcwd(), os.path.dirname(__file__))}
-zoo_fixture.arena.add_store('shelvedb', shelvedb, proxiedopts)
-
-opts = {'Next Store': 'shelvedb',
-        'Lifetime': '10 minutes',
@@ -14 +10 @@
-
-def run():
+    import zoo_fixture
+    # Isolate schema changes from one test to the next.
+    reload(zoo_fixture)
+    zoo_fixture.init()
+    zoo_fixture.arena.add_store('shelvedb', shelvedb, proxiedopts)
-    zoo_fixture.run(SM_class, opts)
-

trunk/test/test_storecaching.py

@@ -1 +1 @@
-import os
-import zoo_fixture
-
-zoo_fixture.init()
-shelvedb = "dejavu.storage.storeshelve.StorageManagerShelve"
-proxiedopts = {u'Path': os.path.join(os.getcwd(), os.path.dirname(__file__))}
-zoo_fixture.arena.add_store('shelvedb', shelvedb, proxiedopts)
-
-opts = {'Next Store': 'shelvedb',
-        'Lifetime': '10 minutes',
@@ -14 +10 @@
-
-def run():
+    import zoo_fixture
+    # Isolate schema changes from one test to the next.
+    reload(zoo_fixture)
+    
+    zoo_fixture.init()
+    zoo_fixture.arena.add_store('shelvedb', shelvedb, proxiedopts)
-    zoo_fixture.run(SM_class, opts)
-

trunk/test/test_storemsaccess.py

@@ -17 +17 @@
-    def run():
-        import zoo_fixture
+        # Isolate schema changes from one test to the next.
+        reload(zoo_fixture)
-        zoo_fixture.init()
-        zoo_fixture.run(SM_class, opts)

trunk/test/test_storemysql.py

@@ -19 +19 @@
-    def run():
-        import zoo_fixture
+        # Isolate schema changes from one test to the next.
+        reload(zoo_fixture)
-        zoo_fixture.init()
-        zoo_fixture.run(SM_class, opts)

trunk/test/test_storeproxy.py

@@ -1 +1 @@
-import os
-import zoo_fixture
-
-zoo_fixture.init()
-shelvedb = "dejavu.storage.storeshelve.StorageManagerShelve"
-proxiedopts = {u'Path': os.path.join(os.getcwd(), os.path.dirname(__file__))}
-zoo_fixture.arena.add_store('shelvedb', shelvedb, proxiedopts)
-
-opts = {'Next Store': 'shelvedb',
-        'Lifetime': '10 minutes',
@@ -14 +10 @@
-
-def run():
+    import zoo_fixture
+    # Isolate schema changes from one test to the next.
+    reload(zoo_fixture)
+    zoo_fixture.init()
+    zoo_fixture.arena.add_store('shelvedb', shelvedb, proxiedopts)
-    zoo_fixture.run(SM_class, opts)
-

trunk/test/test_storepypgsql.py

@@ -23 +23 @@
-    def run():
-        import zoo_fixture
+        # Isolate schema changes from one test to the next.
+        reload(zoo_fixture)
-        zoo_fixture.init()
-        zoo_fixture.run(SM_class, opts)

trunk/test/test_storeshelve.py

@@ -13 +13 @@
-def run():
-    import zoo_fixture
+    # Isolate schema changes from one test to the next.
+    reload(zoo_fixture)
-    zoo_fixture.init()
-    zoo_fixture.run(SM_class, opts)

trunk/test/test_storesqlite.py

@@ -13 +13 @@
-    def run():
-        import zoo_fixture
+        # Isolate schema changes from one test to the next.
+        reload(zoo_fixture)
-        zoo_fixture.init()
-        zoo_fixture.run(SM_class, opts)

trunk/test/test_storesqlserver.py

@@ -16 +16 @@
-    def run():
-        import zoo_fixture
+        # Isolate schema changes from one test to the next.
+        reload(zoo_fixture)
-        zoo_fixture.init()
-        zoo_fixture.run(SM_class, opts)

trunk/test/zoo_fixture.py

@@ -700 +700 @@
-##        lion.LastEscape = datetime.datetime(2005, 12, 25, 8, 14)
-##        box.commit_since("rollback point name")
+    
+    def testzzzz_Schema_Upgrade(self):
+        # Must run last.
+        zs = ZooSchema(arena)
+        
+        # In this first upgrade, we simulate the case where the code was
+        # upgraded, and the database schema upgrade performed afterward.
+        # The Schema.latest property is set, and upgrade() is called with
+        # no argument (which should upgrade us to "latest").
+        Animal.set_property("ExhibitID")
+        zs.latest = 2
+        zs.upgrade()
+        
+        # In this example, we simulate the developer who wants to put
+        # model changes inline with database changes (see upgrade_to_3).
+        # We do not set latest, but instead supply an arg to upgrade().
+        zs.upgrade(3)
+        
+        # Test that Animals have a new "Family" property, and an ExhibitID.
+        box = arena.new_sandbox()
+        emp = box.unit(Animal, Family='Emperor Penguin')
+        self.assertEqual(emp.ExhibitID, 'The Penguin Encounter')
-
-
@@ -720 +742 @@
-    arena.logflags = dejavu.LOGSQL
-
+
+class ZooSchema(dejavu.Schema):
+    
+    latest = 1
+    
+    def upgrade_to_2(self):
+        self.arena.add_property(Animal, "ExhibitID")
+        box = self.arena.new_sandbox()
+        for exhibit in box.recall(Exhibit):
+            for animalID in exhibit.Animals:
+                a = box.unit(Animal, ID=animalID)
+                if a:
+                    # Exhibits are identified by ZooID and Name
+                    a.ZooID = exhibit.ZooID
+                    a.ExhibitID = exhibit.Name
+        box.flush_all()
+    
+    def upgrade_to_3(self):
+        Animal.remove_property("Species")
+        Animal.set_property("Family")
+        
+        # Note that we drop this column in a separate step from step 2.
+        # If we had mixed model properties and SM properties in step 2,
+        # we could have done this all in one step. But this is a better
+        # demonstration of the possibilities. ;)
+        Exhibit.remove_property("Animals")
+        self.arena.drop_property(Exhibit, "Animals")
+        
+        self.arena.rename_property(Animal, "Species", "Family")
+
+
-def setup(SM_class, opts):
-    """setup(SM_class, opts). Set up storage for Zoo classes."""
@@ -731 +784 @@
-    engines.register_classes(arena)
-    
-
-
-
-
+
-
-

trunk/units.py

@@ -519 +519 @@
-        except TypeError, x:
-            x.args += (self.__class__.__name__, self._properties.keys())
- x
+
-    
-    def dirty(self):
@@ -539 +539 @@
-            cls.set_property(key, typ, False, descriptor)
-    set_properties = classmethod(set_properties)
+    
+    def remove_property(cls, key):
+        delattr(cls, key)
+        del cls._properties[key]
+    remove_property = classmethod(remove_property)
-    
-    def indices(cls):
@@ -549 +554 @@
-            except AttributeError, x:
-                x.args += (cls, key)
- x
+
-        return tuple(product)
-    indices = classmethod(indices)