Changeset 83

Timestamp:

03/05/07 21:32:53 (6 years ago)

Author:

ged

Message:

- Added support for the "version_id_col" option on entities. This option adds

a column to the table which will be used to prevent concurrent modifications
on any row of the entity's table (i.e. it will raise an error if it happens).

- Using invalid options on entities will now raise an exception

Location:

elixir/trunk

Files:

• CHANGES (modified) (2 diffs)
• elixir/entity.py (modified) (4 diffs)
• elixir/options.py (modified) (5 diffs)
• tests/test_options.py (modified) (2 diffs)

elixir/trunk/CHANGES

@@ -1 @@
-0.2.1
+0.3.0
 - Added support for autoloading/reflecting databases with
   has_and_belongs_to_many relationships. The tablename argument is now
   optional, but still recommended, otherwise you'll have to use the same exact
   name for your intermediary table than the one generated.
+- Added support for the "version_id_col" option on entities. This option adds 
+  a column to the table which will be used to prevent concurrent modifications
+  on any row of the entity's table (i.e. it will raise an error if it happens).
 - Made the colname argument optional for belongs_to relationships in
   autoloaded entities. It is only required to specify it if you have several
@@ -19 +22 @@
 - Actually make the code python 2.3 compatible (Robin's patch was based on
   0.1.0 while I had introduced more decorators in the trunk in the mean time).
+- Using invalid options on entities will now raise an exception
 - Some cleanup/useless code removal
 

elixir/trunk/elixir/entity.py

@@ -25 +25 @@
 DEFAULT_AUTO_PRIMARYKEY_NAME = "id"
 DEFAULT_AUTO_PRIMARYKEY_TYPE = Integer
-
+DEFAULT_VERSION_ID_COL = "row_version"
 
 class EntityDescriptor(object):
@@ -70 +70 @@
 
         for option in ('inheritance', 
-                       'autoload', 'shortnames', 'auto_primarykey'):
+                       'autoload', 'shortnames', 'auto_primarykey',
+                       'version_id_col'):
             setattr(self, option, options_defaults[option])
 
@@ -141 +142 @@
             kwargs['order_by'] = self.translate_order_by(self.order_by)
         
+        if self.version_id_col:
+            kwargs['version_id_col'] = self.fields[self.version_id_col].column
+
         if self.parent:
             if self.inheritance == 'single':
@@ -192 +196 @@
 #                for field in self.fields.itervalues():
 #                    self.add_field(field)
+
+        if self.version_id_col:
+            if not isinstance(self.version_id_col, basestring):
+                self.version_id_col = DEFAULT_VERSION_ID_COL
+            self.add_field(Field(Integer, colname=self.version_id_col))
 
         if not self.autoload:

elixir/trunk/elixir/options.py

@@ -40 +40 @@
 +---------------------+-------------------------------------------------------+
 | ``autoload``        | Automatically load column definitions from the        |
-|                     | existing database table.  For now, it does **not**    |
-|                     | work for ``has_and_belongs_to_many`` relationships.   |
+|                     | existing database table.                              |
 |                     | Using autoloaded tables implies setting               |
 |                     | ``delay_setup`` to ``True`` before defining your      |
@@ -62 +61 @@
 |                     | corresponding entity.  If this option is False,       |
 |                     | it will disallow auto-creation of a primary key.      |
++---------------------+-------------------------------------------------------+
+| ``version_id_col``  | If this option is True, it will create a version      |
+|                     | column automatically using the default name. If given |
+|                     | as string, it will create the column using that name. |
+|                     | This can be used to prevent concurrent modifications  |
+|                     | to the entity's table rows (i.e. it will raise an     |
+|                     | exception if it happens).                             |
 +---------------------+-------------------------------------------------------+
 | ``order_by``        | How to order select results. Either a string or a     |
@@ -112 +118 @@
     shortnames=False,
     auto_primarykey=True,
+    version_id_col=False,
     mapper_options=dict(),
     table_options=dict(),
@@ -124 +131 @@
         'shortnames',
         'auto_primarykey',
+        'version_id_col',
         'order_by',
     )
@@ -133 +141 @@
             if kwarg in UsingOptions.valid_options:
                 setattr(desc, kwarg, kwargs[kwarg])
+            else:
+                raise Exception("'%s' is not a valid option for Elixir "
+                                "entities." % kwarg)
 
 

elixir/trunk/tests/test_options.py

@@ -3 +3 @@
 """
 
-from sqlalchemy import create_engine, UniqueConstraint 
-from sqlalchemy.exceptions import SQLError
+from sqlalchemy import create_engine, create_session, UniqueConstraint 
+from sqlalchemy.exceptions import SQLError, ConcurrentModificationError 
 from elixir     import *
 
-#TODO: complete this test. 
-
-# The order_by option is already tested in test_order_by.py
-
-class Record(Entity):
-    with_fields(
-        title = Field(Unicode(30)),
-        artist = Field(Unicode(30)),
-        year = Field(Integer)
-    )
-    
-    using_options(tablename="records")
 
 class TestOptions(object):
@@ -24 +12 @@
         engine = create_engine('sqlite:///')
         metadata.connect(engine)
-        create_all()
-    
+
+    # this test is a rip-off SQLAlchemy's activemapper's update test
+    def test_version_id_col(self):
+        class Person(Entity):
+            has_field('name', Unicode(30))
+
+            using_options(version_id_col=True)
+
+        Person.table.create()
+
+        p1 = Person(name='Daniel')
+        objectstore.flush()
+        objectstore.clear()
+        
+        person = Person.select()[0]
+        person.name = 'Gaetan'
+        objectstore.flush()
+        objectstore.clear()
+        assert person.row_version == 2
+
+        person = Person.select()[0]
+        person.name = 'Jonathan'
+        objectstore.flush()
+        objectstore.clear()
+        assert person.row_version == 3
+
+        # check that a concurrent modification raises exception
+        p1 = Person.select()[0]
+        s1 = objectstore.session
+        s2 = create_session()
+        objectstore.context.current = s2
+        p2 = Person.select()[0]
+        p1.name = "Daniel"
+        p2.name = "Gaetan"
+        objectstore.flush()
+        try:
+            objectstore.context.current = s1
+            objectstore.flush()
+            assert False
+        except ConcurrentModificationError:
+            pass
+
     def teardown(self):
         cleanup_all()
-    
+
+
 class TestTableOptions(object):
     def setup(self):