Changeset 72

Timestamp:

02/27/07 15:31:10 (6 years ago)

Author:

ged

Message:

- fixed foreign key names on MySQL (and possibly other) databases by

making sure the generated name is unique for the whole database, and not
only for the table on which it applies.

- added example to front page
- added an explicit link to the cheese shop on the download page

Location:

elixir/trunk

Files:

• CHANGES (modified) (1 diff)
• docs/download.rst (modified) (1 diff)
• docs/index.rst (modified) (1 diff)
• elixir/relationships.py (modified) (4 diffs)

elixir/trunk/CHANGES

@@ -6 +6 @@
   list that is neither threadsafe, nor safe when doing nested class 
   definition.  Also added a test to validate that this works.
+- fixed foreign key names on MySQL (and possibly other) databases by 
+  making sure the generated name is unique for the whole database, and not
+  only for the table on which it applies.
 - implemented singletable non-polymorphic inheritance
 - added support to pass non-keyword arguments to tables. You just pass

elixir/trunk/docs/download.rst

@@ -17 +17 @@
         out how to use it (it's pretty easy, like the name promises).
 
+
+Releases
+--------
+
+Each release is also available for standard download on the `Cheese Shop
+<http://cheeseshop.python.org/pypi/Elixir/>`_
+
 Development Version
 -------------------

elixir/trunk/docs/index.rst

@@ -16 +16 @@
 focuses on providing a simpler syntax for defining model objects when you do
 not need the full expressiveness of SQLAlchemy's manual mapper definitions.
+
+-------
+Example
+-------
+
+Here is a very short model definition example, so that you can see what the
+syntax look like. For some explanation and more complete examples, please have
+a look at the `tutorial <tutorial.html>`_ or at the 
+`examples page <examples.html>`_.
+
+::
+
+    class Person(Entity):
+        has_field('name', Unicode(255))
+
+        has_many('addresses', of_kind='Address')
+
+
+    class Address(Entity):
+        has_field('email', String(128))
+
+        belongs_to('person', of_kind='Person')
+
 
 -------

elixir/trunk/elixir/relationships.py

@@ -416 +416 @@
                 self.primaryjoin_clauses.append(field.column == pk_col)
             
-            # TODO: better constraint-naming?
+            # In some databases (at lease MySQL) the constraint name needs to 
+            # be unique for the whole database, instead of per table.
+            fk_name = "%s_%s_fk" % (self.entity.table.name, self.name)
             source_desc.add_constraint(ForeignKeyConstraint(
                                             fk_colnames, fk_refcols,
-                                            name=self.name +'_fk',
+                                            name=fk_name,
                                             **self.constraint_kwargs))
     
@@ -514 +516 @@
                         % (self.entity.__name__, self.name)
                     )
+
+            # We use the name of the relation for the first entity 
+            # (instead of the name of its primary key), so that we can 
+            # have two many-to-many relations between the same objects 
+            # without having a table name collision. 
+            source_part = "%s_%s" % (e1_desc.tablename, self.name)
+
+            # And we use the name of the primary key for the second entity
+            # when there is no inverse, so that a many-to-many relation 
+            # can be defined without an inverse.
+            if self.inverse:
+                e2_name = self.inverse.name
+            else:
+                e2_name = '_'.join([key.column.name for key in
+                                    e2_desc.primary_keys])
+            target_part = "%s_%s" % (e2_desc.tablename, e2_name)
+            
+            if self.user_tablename:
+                tablename = self.user_tablename
+            else:
+                # we need to keep the table name consistent (independant of 
+                # whether this relation or its inverse is setup first)
+                if self.inverse and e1_desc.tablename < e2_desc.tablename:
+                    tablename = "%s__%s" % (target_part, source_part)
+                else:
+                    tablename = "%s__%s" % (source_part, target_part)
+
+            # In some databases (at lease MySQL) the constraint names need 
+            # to be unique for the whole database, instead of per table.
+            source_fk_name = "%s_fk" % source_part
+            if self.inverse:
+                target_fk_name = "%s_fk" % target_part
+            else:
+                target_fk_name = "%s_inverse_fk" % source_part
+
             columns = list()
             constraints = list()
@@ -520 +557 @@
             self.secondaryjoin_clauses = list()
 
-            for num, desc, join_name in (('1', e1_desc, 'primary'), 
-                                         ('2', e2_desc, 'secondary')):
+            for num, desc, join_name, fk_name in (
+                    ('1', e1_desc, 'primary', source_fk_name), 
+                    ('2', e2_desc, 'secondary', target_fk_name)):
                 fk_colnames = list()
                 fk_refcols = list()
@@ -550 +588 @@
                     join_list.append(col == pk_col)
                 
-                # TODO: better constraint-naming?
                 constraints.append(
                     ForeignKeyConstraint(fk_colnames, fk_refcols,
-                                         name=desc.tablename + '_fk'))
-
-            if self.user_tablename:
-                tablename = self.user_tablename
-            else:
-                # We use the name of the relation for the first entity 
-                # (instead of the name of its primary key), so that we can 
-                # have two many-to-many relations between the same objects 
-                # without having a table name collision. 
-                source_part = "%s_%s" % (e1_desc.tablename, self.name)
-
-                # And we use the name of the primary key for the second entity
-                # when there is no inverse, so that a many-to-many relation 
-                # can be defined without an inverse.
-                if self.inverse:
-                    e2_name = self.inverse.name
-                else:
-                    e2_name = '_'.join([key.column.name for key in
-                                        e2_desc.primary_keys])
-                target_part = "%s_%s" % (e2_desc.tablename, e2_name)
-
-                # we need to keep the table name consistent (independant of 
-                # whether this relation or its inverse is setup first)
-                if self.inverse and e1_desc.tablename < e2_desc.tablename:
-                    tablename = "%s__%s" % (target_part, source_part)
-                else:
-                    tablename = "%s__%s" % (source_part, target_part)
+                                         name=fk_name))
+
 
             args = columns + constraints