Changeset 458 for elixir/trunk/elixir

Timestamp:

09/17/09 13:54:19 (3 years ago)

Author:

ged

Message:

- Changed the pattern used by default to generate column names for (all)

ManyToMany relationships so that the meaning of bidirectional
self-referential relationships does not depend on the order of declaration
of each side (closes #69). See upgrade notes for details.

- Made M2MCOL_NAMEFORMAT accept a callable, so that more complex naming

generation can be used if so desired.

Location:

elixir/trunk/elixir

Files:

• options.py (modified) (2 diffs)
• relationships.py (modified) (5 diffs)

elixir/trunk/elixir/options.py

@@ -184 +184 @@
 # format constants
 FKCOL_NAMEFORMAT = "%(relname)s_%(key)s"
-M2MCOL_NAMEFORMAT = "%(tablename)s_%(key)s"
+OLD_M2MCOL_NAMEFORMAT = "%(tablename)s_%(key)s%(numifself)s"
+NEW_M2MCOL_NAMEFORMAT = "%(relname)s_%(key)s"
+M2MCOL_NAMEFORMAT = NEW_M2MCOL_NAMEFORMAT
 CONSTRAINT_NAMEFORMAT = "%(tablename)s_%(colnames)s_fk"
 MULTIINHERITANCECOL_NAMEFORMAT = "%(entity)s_%(key)s"
@@ -197 +199 @@
 
 # debugging/migration help
-CHECK_TABLENAME_CHANGES = False
+MIGRATION_TO_07_AID = False
 
 #

elixir/trunk/elixir/relationships.py

@@ -417 +417 @@
 __doc_all__ = []
 
+
 class Relationship(Property):
     '''
@@ -862 +863 @@
                 "all ManyToMany tables", DeprecationWarning, stacklevel=3)
         self.column_format = column_format or options.M2MCOL_NAMEFORMAT
+        if not callable(self.column_format):
+            # we need to store the format in a variable so that the
+            # closure of the lambda is correct
+            format = self.column_format
+            self.column_format = lambda data: format % data
+        if options.MIGRATION_TO_07_AID:
+            self.column_format = \
+                migration_aid_column_formatter(self.column_format)
 
         self.filter = filter
@@ -938 +947 @@
             # whether this relation or its inverse is setup first).
             if self.inverse and source_part < target_part:
-                #TODO: if self-relf, only include source_part
+                #XXX: use a different scheme for selfref (to not include the
+                #     table name twice)?
                 tablename = "%s__%s" % (target_part, source_part)
-                if options.CHECK_TABLENAME_CHANGES and \
+                if options.MIGRATION_TO_07_AID and \
                    e1_desc.tablename >= e2_desc.tablename:
                     oldname = "%s__%s" % (source_part, target_part)
-
-                    raise Exception(
+                    warnings.warn(
                         "The generated table name for the '%s' relationship "
                         "on the '%s' entity changed from '%s' (the name "
@@ -996 +1005 @@
                     assert len(colnames) == len(desc.primary_keys)
                 else:
+                    data = {# relationship info
+                            'relname': rel and rel.name or 'inverse',
+                            'selfref': e1_desc is e2_desc,
+                            'num': num,
+                            'numifself': e1_desc is e2_desc and str(num + 1)
+                                                            or '',
+                            # target info
+                            'target': desc.entity,
+                            'entity': desc.entity.__name__.lower(),
+                            'tablename': desc.tablename
+                           }
+                    colnames = []
                     for pk_col in desc.primary_keys:
-                        colname = self.column_format % \
-                                  {'tablename': desc.tablename,
-                                   'key': pk_col.key,
-                                   'entity': desc.entity.__name__.lower()}
-                        # In case we have a many-to-many self-reference, we
-                        # need to tweak the names of the columns so that we
-                        # don't end up with twice the same column name.
-                        if self.entity is self.target:
-                            colname += str(num + 1)
-                        colnames.append(colname)
+                        data.update(key=pk_col.key)
+                        colnames.append(self.column_format(data))
 
                 for pk_col, colname in zip(desc.primary_keys, colnames):
@@ -1087 +1100 @@
 
 
+def alternate_m2m_column_formatter(data):
+    if data['selfref']:
+        return options.NEW_M2MCOL_NAMEFORMAT % data
+    else:
+        return options.OLD_M2MCOL_NAMEFORMAT % data
+
+
+def migration_aid_m2m_column_formatter(formatter):
+    def debug_formatter(data):
+        new_name = formatter(data)
+        old_name = options.OLD_M2MCOL_NAMEFORMAT % data
+        if new_name != old_name:
+            complete_data = data.copy()
+            #TODO: use explicit num and selfref variables
+            complete_data.update(old_name=old_name,
+                                 new_name=new_name,
+                                 dir=data['num'] is 0 and 'local' or 'remote')
+            # Specifying a stacklevel is useless in this case as the name
+            # generation is triggered by setup_all(), not by the declaration
+            # of the offending relationship.
+            warnings.warn("The generated column name for the '%(relname)s' "
+                          "relationship on the '%(entity)s' entity changed "
+                          "from '%(old_name)s' to '%(new_name)s'. "
+                          % complete_data)
+        return new_name
+    return debug_formatter
+
+
 def _get_join_clauses(local_table, local_cols1, local_cols2, target_table):
     primary_join, secondary_join = [], []