Changeset 420

Timestamp:

03/11/07 02:33:51

Author:

fumanchu

Message:

New 'repair' mode for map_all, map, sync. New 'automap' arg for arena.storage. Return of MappingError?.

Files:

• trunk/arenas.py (modified) (6 diffs)
• trunk/errors.py (modified) (1 diff)
• trunk/schemas.py (modified) (1 diff)
• trunk/storage/__init__.py (modified) (4 diffs)
• trunk/storage/db.py (modified) (7 diffs)

trunk/arenas.py

@@ -102 +102 @@
-            del self.stores[name]
-    
-
+, conflict_mode='error'
-        """Map all registered classes to internal storage structures.
-        
@@ -112 +112 @@
-        This method is idempotent, but that doesn't mean cheap. Try not
-        to call it very often (once at app startup is usually enough).
+        
+        conflict_mode: This argument determines what happens when there are
+        discrepancies between the Dejavu model and the actual database.
+            
+            If 'error' (the default), MappingError is raised for the
+            first issue and the sync process is aborted.
+            
+            If 'warn', then a warning is raised (instead of an error)
+            for each issue, and the sync process is not aborted. This
+            allows you to see all errors at once, without having to stop
+            and fix each one and then execute the process again.
+            
+            If 'repair', then each issue will be resolved by changing
+            the database to match the model.
-        """
-        storemap = {}
@@ -128 +142 @@
-        storemap.sort()
-        for order, store, classes in storemap:
-
+, conflict_mode
-    
-    def shutdown(self):
@@ -174 +188 @@
-        raise KeyError("No registered class found for '%s'." % classname)
-    
-
+, automap=True
-        """Return the StorageManager which handles Units of the given class.
-        
-
-
+
+
+
+
-        """
-        store = self._registered_classes.get(cls)
@@ -186 +202 @@
-        store = self._find_storage(cls)
-        self._registered_classes[cls] = store
-
+
+
-        return store
-    
@@ -213 +230 @@
-    def create_storage(self, cls):
-        """Create storage space for cls."""
-
-
-
-
-
+
-        store.create_storage(cls)
-    
-    def has_storage(self, cls):
-        """If storage space for cls exists, return True (False otherwise)."""
-
-
-
-
-
-
+
-        return store.has_storage(cls)
-    

trunk/errors.py

@@ -20 +20 @@
-    """Warning about functionality which is not supported by all SM's."""
-    pass
+
+class MappingError(DejavuError):
+    """Exception raised when a Unit class cannot be mapped to storage.
+    
+    This exception should be raised when a consumer attempts to build
+    a map between a Unit class and existing internal storage structures.
+    Other exceptions may be raised when trying to find such a map after
+    it has already (supposedly) been created. That is, the questions
+    "do we have a map?" and "can we create a map?" are distinct.
+    The latter should raise this exception whenever possible.
+    The behavior of the former is not specified.
+    """
+    pass

trunk/schemas.py

@@ -140 +140 @@
-        easily if you run assert_storage before the upgrade methods.
-        """
-
-
-
-
-
-
-
-
+
-    
-    def assert_version(self):

trunk/storage/__init__.py

@@ -1 +1 @@
-"""Storage Managers for Dejavu."""
-
-import re
-import datetime
-import thread
-try:
-    import cPickle as pickle
-except ImportError:
-    import pickle
-
-
+
+
+
+
+
-
-
@@ -60 +61 @@
-    #                               Schemas                               #
-    
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-    def create_database(self):
@@ -160 +185 @@
-    #                               Schemas                               #
-    
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        """
-warn
+conflict_mode
-    
-    def create_database(self):
@@ -487 +522 @@
-managers = {
-    "cache": CachingProxy,
+    "caching": CachingProxy,
-    "burned": BurnedProxy,
-    "proxy": ProxyStorage,

trunk/storage/db.py

@@ -37 +37 @@
-import dejavu
-from dejavu import logic, storage, logflags, xray
-
+, MappingError
-
-
@@ -68 +68 @@
-        self.db = self.databaseclass(**allOptions)
-        self.schema = self.db.schema(name)
+        
+        if 'Prefix' in allOptions:
+            self.schema.prefix = allOptions['Prefix']
-        
-        def logger(msg):
@@ -418 +421 @@
-    auto_discover = True
-    
-warn=False
-Table objects (if not found)
+conflict_mode='error'
+internal storage
-        
-        If self.auto_discover is True (the default), then Table/Column/Index
@@ -430 +433 @@
-        and changes to the database are not expected outside the model.
-        
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-        """
-        if self.auto_discover:
-warn
+conflict_mode
-        else:
-            for cls in classes:
-
-
+
-                    # If our consumer-side key is already present, skip this cls.
-                    # This allows arena.storage() to auto-sync class by class
@@ -448 +460 @@
-                
-                # Use the superclass call to avoid DROP/CREATE TABLE
-name
-
-warn=False
+.__name__
+
+conflict_mode='error'
-        """Map classes to existing Table objects (found via discovery).
-        
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-        """
+        
+        def notify(msg):
+            if conflict_mode == 'warn':
+                warnings.warn(msg)
+            else:
+                raise MappingError(msg)
+        
-        for cls in classes:
-            clsname = cls.__name__
@@ -471 +498 @@
-            tablename = self.schema.table_name(clsname)
-            try:
-
+ using the DB name
-                table = self.schema[tablename]
+                self.schema.alias(table.name, clsname)
-            except KeyError:
-                # Can we create a map? Discover the DB table and try again.
-                try:
-                    table = self.schema.discover(tablename)
+                    self.schema.alias(table.name, clsname)
-                except geniusql.errors.MappingError:
-                    msg = "%s: no such table %r." % (clsname, tablename)
-
-
+
+
+
+
+
-                        continue
-                    else:
-                        raise geniusql.errors.MappingError(msg)
-            
-            self.schema.alias(table.name, clsname)
-            
-            # Match Column objects with class properties.
@@ -491 +519 @@
-            indices = cls.indices()
-            related = self.db.typeadapter.related
-c
-c
+p
+p
-                try:
-                    col = dbcols[colname]
+                    table.alias(colname, pkey)
-                except KeyError, x:
-
-
-
+
+
+
+
+
+
+
+
-                        continue
+                
+                # Check that the column.key matches our identifiers list;
+                # this is crucial for the proper operation of OLTP methods
+                # in geniusql.Table, which uses column.key to decide
+                # the unique identifiers for a given row of data.
+                if pkey in cls.identifiers and not col.key:
+                    msg = ("%s: %r is an identifier, but the "
+                           "column is not marked as a primary key."
+                           % (clsname, pkey))
+                    if conflict_mode == 'repair':
+                        col.key = True
+                        table.add_primary()
-                    else:
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                
-                # Set imperfect_type
-c
+p
-                if newtype != col.pytype:
-                    col.imperfect_type = not related(newtype, col.pytype)
-                    col.pytype = newtype
-                
-                table.alias(col.name, ckey)
-                
-                # Try to find matching Index objects. Because index names are
-                # so platform-specific, we match attributes rather than names.
-c
-rite
+p
+
-                        if idx.colname == colname:
-c
+p
-                            table.indices.alias(ikey, a)
-                            break
-                    else:
-
-
-
-
+
+
+
-                        else:
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            
-            # Set Table.references