Changeset 428 for elixir/trunk/elixir

Timestamp:

12/08/08 17:10:58 (3 years ago)

Author:

ged

Message:

implemented ManyToOne relationships to plain SA-mapped classes. OneToMany and ManyToMany relationships don't work yet

Location:

elixir/trunk/elixir

Files:

• entity.py (modified) (9 diffs)
• relationships.py (modified) (13 diffs)

elixir/trunk/elixir/entity.py

@@ -9 +9 @@
 import inspect
 import types
+import warnings
 
 from copy import copy
 
 import sqlalchemy
-from sqlalchemy     import Table, Column, Integer, desc, ForeignKey, and_, \
-                           ForeignKeyConstraint
+from sqlalchemy import Table, Column, Integer, desc, ForeignKey, and_, \
+                       ForeignKeyConstraint
 from sqlalchemy.orm import MapperExtension, mapper, object_session, \
                            EXT_CONTINUE, polymorphic_union, ScopedSession, \
                            ColumnProperty
+from sqlalchemy.sql import ColumnCollection
 
 import elixir
@@ -67 +69 @@
 
         # columns and constraints waiting for a table to exist
-        self._columns = []
+        self._columns = ColumnCollection()
         self.constraints = []
 
@@ -270 +272 @@
                 self.add_column(Column(self.version_id_col, Integer))
 
-            args = self.columns + self.constraints + self.table_args
+            args = list(self.columns) + self.constraints + self.table_args
         self.entity.table = Table(self.tablename, self.metadata,
                                   *args, **kwargs)
@@ -473 +475 @@
             check_duplicate = not self.allowcoloverride
 
-        if check_duplicate and self.get_column(col.key, False) is not None:
-            raise Exception("Column '%s' already exist in '%s' ! " %
-                            (col.key, self.entity.__name__))
-        self._columns.append(col)
+        if col.key in self._columns:
+            if check_duplicate:
+                raise Exception("Column '%s' already exist in '%s' ! " %
+                                (col.key, self.entity.__name__))
+            else:
+                del self._columns[col.key]
+        self._columns.add(col)
 
         if col.primary_key:
@@ -510 +515 @@
 #FIXME: something like this is needed to propagate the relationships from
 # parent entities to their children in a concrete inheritance scenario. But
-# this doesn't work because of the backref matching code.
+# this doesn't work because of the backref matching code. In most case
+# (test_concrete.py) it doesn't even happen at all.
 #        if self.children and self.inheritance == 'concrete':
 #            for child in self.children:
@@ -531 +537 @@
         #TODO: this needs to work whether the table is already setup or not
         #TODO: support SA table/autoloaded entity
-        for col in self.columns:
-            if col.key == key:
-                return col
-        if check_missing:
-            raise Exception("No column named '%s' found in the table of the "
-                            "'%s' entity!" % (key, self.entity.__name__))
-        return None
+        try:
+            return self.columns[key]
+        except KeyError:
+            if check_missing:
+                raise Exception("No column named '%s' found in the table of "
+                                "the '%s' entity!"
+                                % (key, self.entity.__name__))
 
     def get_inverse_relation(self, rel, check_reverse=True):
@@ -617 +623 @@
     primary_keys = property(primary_keys)
 
+    def table(self):
+        if self.entity.table:
+            return self.entity.table
+        else:
+            return FakeTable(self)
+    table = property(table)
+
     def primary_key_properties(self):
         """
@@ -637 +650 @@
         return self._pk_props
     primary_key_properties = property(primary_key_properties)
+
+class FakePK(object):
+    def __init__(self, descriptor):
+        self.descriptor = descriptor
+
+    def columns(self):
+        return self.descriptor.primary_keys
+    columns = property(columns)
+
+class FakeTable(object):
+    def __init__(self, descriptor):
+        self.descriptor = descriptor
+        self.primary_key = FakePK(descriptor)
+
+    def columns(self):
+        return self.descriptor.columns
+    columns = property(columns)
+
+    def fullname(self):
+        '''
+        Complete name of the table for the related entity.
+        Includes the schema name if there is one specified.
+        '''
+        schema = self.descriptor.table_options.get('schema', None)
+        if schema is not None:
+            return "%s.%s" % (schema, self.descriptor.tablename)
+        else:
+            return self.descriptor.tablename
+    fullname = property(fullname)
+
 
 class TriggerProxy(object):
@@ -900 +943 @@
         desc._pk_col_done = False
         desc.has_pk = False
-        desc._columns = []
+        desc._columns = ColumnCollection()
         desc.constraints = []
         desc.properties = {}

elixir/trunk/elixir/relationships.py

@@ -399 +399 @@
 
 from sqlalchemy import ForeignKeyConstraint, Column, Table, and_
-from sqlalchemy.orm import relation, backref
+from sqlalchemy.orm import relation, backref, class_mapper
 from sqlalchemy.ext.associationproxy import association_proxy
 
@@ -484 +484 @@
     def target(self):
         if not self._target:
-            if isinstance(self.of_kind, EntityMeta):
-                self._target = self.of_kind
-            else:
+            if isinstance(self.of_kind, basestring):
                 collection = self.entity._descriptor.collection
                 self._target = collection.resolve(self.of_kind, self.entity)
+            else:
+                self._target = self.of_kind
         return self._target
     target = property(target)
@@ -510 +510 @@
             else:
                 check_reverse = not self.kwargs.get('viewonly', False)
-                inverse = self.target._descriptor.get_inverse_relation(self,
-                            check_reverse=check_reverse)
-
+                if isinstance(self.target, EntityMeta):
+                    inverse = self.target._descriptor.get_inverse_relation(
+                        self, check_reverse=check_reverse)
+                else:
+                    inverse = None
             self._inverse = inverse
             if inverse and not self.kwargs.get('viewonly', False):
@@ -599 +601 @@
         return isinstance(other, (OneToMany, OneToOne))
 
+    def target_table(self):
+        if isinstance(self.target, EntityMeta):
+            return self.target._descriptor.table
+        else:
+            return class_mapper(self.target).local_table
+    target_table = property(target_table)
+
     def create_keys(self, pk):
         '''
@@ -615 +624 @@
         # for that, I need:
         # - the list of primary key columns of the target table (type and name)
+        # - a way to get to a column from its name
         # - the name of the target table
-        target_desc = self.target._descriptor
-        #make sure the target has all its pk set up
-        target_desc.create_pk_cols()
+        #XXX: use a fake table object on pure Elixir case and always introspect
+        #the table as if it was pure SA???
+        if isinstance(self.target, EntityMeta):
+            # make sure the target has all its pk set up
+            self.target._descriptor.create_pk_cols()
+
+        target_table = self.target_table
 
         if source_desc.autoload:
@@ -629 +643 @@
                         _get_join_clauses(self.entity.table,
                                           self.colname, None,
-                                          self.target.table)[0]
+                                          target_table)[0]
                     if not self.primaryjoin_clauses:
                         colnames = ', '.join(self.colname)
@@ -645 +659 @@
 
             if self.target_column is None:
-                target_columns = target_desc.primary_keys
+                target_columns = target_table.primary_key.columns
             else:
-                target_columns = [target_desc.get_column(col)
+                target_columns = [target_table.columns[col]
                                   for col in self.target_column]
 
@@ -653 +667 @@
                 raise Exception("No primary key found in target table ('%s') "
                                 "for the '%s' relationship of the '%s' entity."
-                                % (self.target.tablename, self.name,
+                                % (target_table.name, self.name,
                                    self.entity.__name__))
             if self.colname and \
@@ -687 +701 @@
                     if col.key == self.name:
                         raise ValueError(
-                                 "ManyToOne named '%s' in '%s' conficts " \
-                                 " with the column of the same name. " \
-                                 "You should probably define the foreign key "\
-                                 "field manually and use the 'field' "\
-                                 "argument on the ManyToOne relationship" \
+                                 "ManyToOne named '%s' in '%s' conficts "
+                                 " with the column of the same name. "
+                                 "You should probably define the foreign key "
+                                 "field manually and use the 'field' "
+                                 "argument on the ManyToOne relationship"
                                  % (self.name, self.entity.__name__))
 
@@ -704 +718 @@
                 # point to
                 fk_refcols.append("%s.%s" % \
-                                  (target_desc.table_fullname, target_col.key))
+                                  (target_table.fullname, target_col.key))
 
                 # Build up the primary join. This is needed when you have
-                # several belongs_to relationships between two objects
+                # several ManyToOne relationships between two objects
                 self.primaryjoin_clauses.append(col == target_col)
 
@@ -725 +739 @@
         kwargs = {'uselist': False}
 
-        if self.entity.table is self.target.table:
+        if self.entity.table is self.target_table:
             # this is needed because otherwise SA has no way to know what is
             # the direction of the relationship since both columns present in
@@ -733 +747 @@
             # doesn't help in this case.
             kwargs['remote_side'] = \
-                [col for col in self.target.table.primary_key.columns]
+                [col for col in self.target_table.primary_key.columns]
 
         if self.primaryjoin_clauses:
@@ -882 +896 @@
                 return
 
+        #needs: table_options['schema'], autoload, tablename, primary_keys,
+        #entity.__name__, table_fullname
         e1_desc = self.entity._descriptor
         e2_desc = self.target._descriptor