Changeset 3254

Timestamp:

05/26/07 08:06:33 (1 year ago)

Author:

mscott

Message:

Merging branch for #55:

• Add test to expose cascade delete corner case where duplicate UNASSIGNED values end up in an index before everything gets a chance to be deleted.
• Add test to make sure key restriction relaxation and re-enforcement work as intended.
• Add relax_all_indices method to schevo.extent.Extent.
• Call relax_all_indices on an extent during cascade delete if a key collision is detected while setting fields to UNASSIGNED.
• Add docs to SchevoPublicApi regarding relax_index and enforce_index.

Files:

• trunk/Schevo/doc/SchevoPublicApi.txt (modified) (1 diff)
• trunk/Schevo/schevo/database2.py (modified) (3 diffs)
• trunk/Schevo/schevo/extent.py (modified) (1 diff)
• trunk/Schevo/schevo/transaction.py (modified) (2 diffs)
• trunk/Schevo/tests/test_on_delete.py (modified) (1 diff)
• trunk/Schevo/tests/test_relax_index.py (added)

trunk/Schevo/doc/SchevoPublicApi.txt

@@ -72 +72 @@
-Extent instances
-================
+
+
+Relaxing and enforcing key restrictions
+---------------------------------------
+
+Schevo has the unique ability to temporarily relax key restrictions
+while still ensuring that the database remains in a consistent state.
+
+Key restrictions may only be relaxed within the execution of a
+transaction.
+
+Given an extent `db.Foo` that has a key specification of `_key(field1,
+field2)`, relax that key restriction by calling `relax_index`::
+
+    db.Foo.relax_index('field1', 'field2')
+
+Key restrictions that are relaxed within a transaction are relaxed for
+the entire execution of the transaction, or until the key is enforced
+within that transaction, or until that transaction ends, whichever
+comes first.
+
+When a key restriction is relaxed by a transaction, it remains relaxed
+for all sub-transactions, regardless of any request by those
+sub-transactions to enforce the key restriction.
+
+To re-enforce the key restriction before the end of a transaction's
+execution, call `enforce_index`::
+
+    db.Foo.enforce_index('field1', 'field2')
+
+See the ``tests/test_relax_index.py`` test case for code examples.
-
-

trunk/Schevo/schevo/database2.py

@@ -136 +136 @@
-            assert log(2, 'Result was', repr(retval))
-            # Enforce any indices relaxed by the transaction.
-tx._relaxed
+frozenset(tx._relaxed)
-                assert log(2, 'Enforcing index', extent_name, index_spec)
-(extent_name, 
+_field_ids(extent_name, *
-            # If the transaction must be executed with strict
-            # validation, perform that validation now.
@@ -495 +495 @@
-
-    def _enforce_index(self, extent_name, *index_spec):
+        """Call _enforce_index after converting index_spec from field
+        names to field IDs."""
+        extent_map = self._extent_map(extent_name)
+        index_spec = _field_ids(extent_map, index_spec)
+        return self._enforce_index_field_ids(extent_name, *index_spec)
+  
+    def _enforce_index_field_ids(self, extent_name, *index_spec):
-        """Validate and begin enforcing constraints on the specified
-        index if it was relaxed within the currently-executing
@@ -502 +509 @@
-            # No-op if called outside a transaction.
-            return
-ID-ify the index_spec
+Find the index to re-enforce
-        extent_map = self._extent_map(extent_name)
-        index_spec = _field_ids(extent_map, index_spec)
-        # Find the index to re-enforce.
-        indices = extent_map['indices']
-        if index_spec not in indices:

trunk/Schevo/schevo/extent.py

@@ -168 +168 @@
-        self._relax(self.name, *index_spec)
-
+    def relax_all_indices(self):
+        """Relax all indices using `relax_index`."""
+        for index_spec in self.key_spec:
+            self.relax_index(*index_spec)
+
-
-class ExtentExtenders(NamespaceExtension):

trunk/Schevo/schevo/transaction.py

@@ -11 +11 @@
-from schevo.constant import (CASCADE, DEFAULT, REMOVE, RESTRICT,
-                             UNASSIGN, UNASSIGNED)
-
-
-
+
+
+
+
+
+
+
+
+
-from schevo import field
-from schevo.field import not_fget
@@ -465 +471 @@
-            field_dump_map.update(new_dump_map)
-            field_related_entity_map.update(new_related_entity_map)
-
+
+
-            oid = referrer._oid
-
-
+
+
+
+
+
+
+
+
+
+
-            referrers.add((extent_name, oid, referrer))
-        # Delete entities in a deterministic (sorted) fashion.

trunk/Schevo/tests/test_on_delete.py

@@ -541 +541 @@
-
-
+class BaseOnDeleteKeyRelax(CreatesSchema):
+
+    body = """
+
+    class Foo(E.Entity):
+
+        bar = f.entity('Bar', on_delete=CASCADE)
+        baz = f.entity('Baz', on_delete=CASCADE)
+
+        _key(baz)
+
+        _sample_unittest = [
+            ((1,), ((1,), 1)),
+            ((1,), ((1,), 2)),
+            ((2,), ((2,), 1)),
+            ((2,), ((2,), 2)),
+            ]
+        
+
+    class Bar(E.Entity):
+
+        number = f.integer()
+
+        _key(number)
+
+        _sample_unittest = [
+            (1,),
+            (2,),
+            ]
+
+
+    class Baz(E.Entity):
+
+        bar = f.entity('Bar', on_delete=CASCADE)
+        number = f.integer()
+
+        _key(bar, number)
+
+        _sample_unittest = [
+            ((1,), 1),
+            ((1,), 2),
+            ((2,), 1),
+            ((2,), 2),
+            ]
+
+    """
+
+    def test_delete_bar(self):
+        assert len(db.Foo) == 4
+        assert len(db.Bar) == 2
+        assert len(db.Baz) == 4
+        bar1 = db.Bar.findone(number=1)
+        ex(bar1.t.delete())
+        assert len(db.Foo) == 2
+        assert len(db.Bar) == 1
+        assert len(db.Baz) == 2
+
+
+class TestOnDeleteKeyRelax1(BaseOnDeleteKeyRelax):
+
+    format = 1
+
+
+class TestOnDeleteKeyRelax2(BaseOnDeleteKeyRelax):
+
+    format = 2
+
+
-class TestOnDeleteEntityListRemove(CreatesSchema):
-