Changeset 350

Timestamp:

07/02/08 15:17:29 (5 years ago)

Author:

ged

Message:

• added add_mapper_property and add_table_column helper method in EntityBuilders
  
• added full_tablename property on EntityDescriptor (includes schema name if
  any)
  

Location:

elixir/trunk/elixir

Files:

• entity.py (modified) (2 diffs)
• ext/associable.py (modified) (11 diffs)
• fields.py (modified) (2 diffs)
• properties.py (modified) (2 diffs)
• relationships.py (modified) (5 diffs)

elixir/trunk/elixir/entity.py

@@ -157 +157 @@
                     # key columns
                     parent_desc = self.parent._descriptor
-                    schema = parent_desc.table_options.get('schema', None)
-                    tablename = parent_desc.tablename
-                    if schema is not None:
-                        tablename = "%s.%s" % (schema, tablename)
+                    tablename = parent_desc.table_fullname
                     for pk_col in parent_desc.primary_keys:
                         colname = options.MULTIINHERITANCECOL_NAMEFORMAT % \
@@ -534 +531 @@
         else:
             return None
+
+    def table_fullname(self):
+        '''
+        Complete name of the table for the related entity.
+        Includes the schema name if there is one specified.
+        '''
+        schema = self.table_options.get('schema', None)
+        if schema is not None:
+            return "%s.%s" % (schema, self.tablename)
+        else:
+            return self.tablename
+    table_fullname = property(table_fullname)
 
     def columns(self):

elixir/trunk/elixir/ext/associable.py

@@ -9 +9 @@
 ------------------------------
 
-A frequent pattern in database schemas is the has_and_belongs_to_many, or a 
+A frequent pattern in database schemas is the has_and_belongs_to_many, or a
 many-to-many table. Quite often multiple tables will refer to a single one
 creating quite a few many-to-many intermediate tables.
 
 Polymorphic associations lower the amount of many-to-many tables by setting up
-a table that allows relations to any other table in the database, and relates 
-it to the associable table. In some implementations, this layout does not 
-enforce referential integrity with database foreign key constraints, this 
-implementation uses an additional many-to-many table with foreign key 
+a table that allows relations to any other table in the database, and relates
+it to the associable table. In some implementations, this layout does not
+enforce referential integrity with database foreign key constraints, this
+implementation uses an additional many-to-many table with foreign key
 constraints to avoid this problem.
 
@@ -38 +38 @@
 
 .. sourcecode:: python
-    
+
     class Tag(Entity):
         name = Field(Unicode)
-    
+
     acts_as_taggable = associable(Tag)
-    
+
     class Entry(Entity):
         title = Field(Unicode)
         acts_as_taggable('tags')
-    
+
     class Article(Entity):
         title = Field(Unicode)
@@ -56 +56 @@
 
 .. sourcecode:: python
-    
+
     class Address(Entity):
         street = Field(String(130))
         city = Field(String(100))
-    
+
     is_addressable = associable(Address, 'addresses')
-    
+
     class Person(Entity):
         name = Field(Unicode)
         orders = OneToMany('Order')
         is_addressable()
-    
+
     class Order(Entity):
         order_num = Field(primary_key=True)
@@ -73 +73 @@
         person = ManyToOne('Person')
         is_addressable('address', uselist=False)
-    
+
     home = Address(street='123 Elm St.', city='Spooksville')
     user = Person(name='Jane Doe')
     user.addresses.append(home)
-    
+
     neworder = Order(item_count=4)
     neworder.address = home
     user.orders.append(neworder)
-    
+
     # Queries using the added helpers
     Person.select_by_addresses(city='Cupertino')
@@ -131 +131 @@
 
     class GenericAssoc(object):
-    
+
         def __init__(self, tablename):
             self.type = tablename
-   
+
     #TODO: inherit from entity builder
     class Associable(object):
         """An associable Elixir Statement object"""
-        
+
         def __init__(self, entity, name=None, uselist=True, lazy=True):
             self.entity = entity
             self.lazy = lazy
             self.uselist = uselist
-            
+
             if name is None:
                 self.name = plural_name
@@ -150 +150 @@
 
         def after_table(self):
-            col = sa.Column('%s_assoc_id' % interface_name, sa.Integer, 
+            col = sa.Column('%s_assoc_id' % interface_name, sa.Integer,
                             sa.ForeignKey('%s.id' % able_name))
             self.entity._descriptor.add_column(col)
@@ -162 +162 @@
                 tablename =  "%s_to_%s" % (able_name, interface_name)
                 association_to_table = sa.Table(tablename, metadata,
-                    sa.Column('assoc_id', sa.Integer, 
-                              sa.ForeignKey(association_table.c.id, 
-                                            ondelete="CASCADE"), 
+                    sa.Column('assoc_id', sa.Integer,
+                              sa.ForeignKey(association_table.c.id,
+                                            ondelete="CASCADE"),
                               primary_key=True),
                     #FIXME: this assumes a single id col
-                    sa.Column('%s_id' % interface_name, sa.Integer, 
-                              sa.ForeignKey(assoc_entity.table.c.id, 
-                                            ondelete="RESTRICT"), 
+                    sa.Column('%s_id' % interface_name, sa.Integer,
+                              sa.ForeignKey(assoc_entity.table.c.id,
+                                            ondelete="RESTRICT"),
                               primary_key=True),
                 )
@@ -186 +186 @@
                                        order_by=assoc_entity.mapper.order_by)
                 })
-        
+
             entity = self.entity
             entity.mapper.add_property(
-                attr_name, 
+                attr_name,
                 sa.orm.relation(GenericAssoc, lazy=self.lazy,
                                 backref='_backref_%s' % entity.table.name)
@@ -197 +197 @@
                 def get(self):
                     if getattr(self, attr_name) is None:
-                        setattr(self, attr_name, 
+                        setattr(self, attr_name,
                                 GenericAssoc(entity.table.name))
                     return getattr(self, attr_name).targets
@@ -211 +211 @@
                 def set(self, value):
                     if getattr(self, attr_name) is None:
-                        setattr(self, attr_name, 
+                        setattr(self, attr_name,
                                 GenericAssoc(entity.table.name))
                     getattr(self, attr_name).targets = [value]
                 setattr(entity, self.name, property(get, set))
 
-            # self.name is both set via mapper synonym and the python 
+            # self.name is both set via mapper synonym and the python
             # property, but that's how synonym properties work.
-            # adding synonym property after "real" property otherwise it 
+            # adding synonym property after "real" property otherwise it
             # breaks when using SQLAlchemy > 0.4.1
             entity.mapper.add_property(self.name, sa.orm.synonym(attr_name))
@@ -227 +227 @@
                                 .filter_by(**kwargs).all()
             setattr(entity, 'select_by_%s' % self.name, classmethod(select_by))
-            
+
             def select(cls, *args, **kwargs):
                 return cls.query.join([attr_name, 'targets']) \

elixir/trunk/elixir/fields.py

@@ -187 +187 @@
         self.column = Column(self.colname, self.type,
                              *self.args, **self.kwargs)
-        self.entity._descriptor.add_column(self.column)
+        self.add_table_column(self.column)
 
     def create_properties(self):
@@ -196 +196 @@
             self.property = deferred(self.column, group=group)
         elif self.name != self.colname:
-            # if the property name is different from the column name, we need to
-            # add an explicit property (otherwise nothing is needed as it's done
-            # automatically by SA)
+            # if the property name is different from the column name, we need 
+            # to add an explicit property (otherwise nothing is needed as it's
+            # done automatically by SA)
             self.property = self.column
 
         if self.property:
-            self.entity._descriptor.add_property(self.name, self.property)
+            self.add_mapper_property(self.name, self.property)
 
         if self.synonym:
-            self.entity._descriptor.add_property(self.synonym,
-                                                 synonym(self.name))
+            self.add_mapper_property(self.synonym, synonym(self.name))
 
 

elixir/trunk/elixir/properties.py

@@ -77 +77 @@
         pass
 
+    # helper methods
+    def add_mapper_property(self, name, prop):
+        self.entity._descriptor.add_property(name, prop)
+
+    def add_table_column(self, column):
+        self.entity._descriptor.add_column(column)
+
 
 class CounterMeta(type):
@@ -146 +153 @@
             prop_value = self.prop
         prop_value = self.evaluate_property(prop_value)
-        self.entity._descriptor.add_property(self.name, prop_value)
+        self.add_mapper_property(self.name, prop_value)
 
     def evaluate_property(self, prop):

elixir/trunk/elixir/relationships.py

@@ -414 +414 @@
         kwargs.update(self.get_prop_kwargs())
         self.property = relation(self.target, **kwargs)
-        self.entity._descriptor.add_property(self.name, self.property)
+        self.add_mapper_property(self.name, self.property)
 
     def target(self):
@@ -571 +571 @@
                 # Build the list of column "paths" the foreign key will
                 # point to
-                target_path = "%s.%s" % (target_desc.tablename, pk_col.key)
-                schema = target_desc.table_options.get('schema', None)
-                if schema is not None:
-                    target_path = "%s.%s" % (schema, target_path)
-                fk_refcols.append(target_path)
+                fk_refcols.append("%s.%s" % \
+                                  (target_desc.table_fullname, pk_col.key))
 
                 # Build up the primary join. This is needed when you have
@@ -757 +754 @@
 
             joins = (self.primaryjoin_clauses, self.secondaryjoin_clauses)
-            for num, desc, fk_name, m2m in (
+            for num, desc, fk_name, rel in (
                     (0, e1_desc, source_fk_name, self),
                     (1, e2_desc, target_fk_name, self.inverse)):
@@ -784 +781 @@
                     # Build the list of column "paths" the foreign key will
                     # point to
-                    target_path = "%s.%s" % (desc.tablename, pk_col.key)
-                    schema = desc.table_options.get('schema', None)
-                    if schema is not None:
-                        target_path = "%s.%s" % (schema, target_path)
+                    target_path = "%s.%s" % (desc.table_fullname, pk_col.key)
                     fk_refcols.append(target_path)
 
@@ -794 +788 @@
                         joins[num].append(col == pk_col)
 
-                onupdate = m2m and m2m.onupdate
-                ondelete = m2m and m2m.ondelete
+                onupdate = rel and rel.onupdate
+                ondelete = rel and rel.ondelete
 
                 constraints.append(