def _get_property_from_mapper(self, resource, attr, args): """ Matches calls like (resource, attr_name). Fetches the property from the mapper and does a recursive call passing it as ``attr`` so other rules can match the property by type. """ prop = get_mapper(resource).get_property(attr) return self.get(resource, prop, args)
def test_relation(self): user = get_mapper(model.Address).get_property('user') field = self.factory(model.Address, user) self.failUnless(isinstance(field, fields.Relation), ` field `) self.failUnless(field.required, ` field `) foreign_keys = get_foreign_keys(user) foreign_keys = [c.name for c in foreign_keys] self.failUnlessEqual(foreign_keys, ['user_id'])
def test_foreign_key(self): user_id = get_mapper(model.Address).get_property('user_id').columns[0] field = self.factory(model.Address, user_id) self.failUnless(isinstance(field, fields.ForeignKey), ` field `) self.failUnless(field.required, ` field `) field = field.type self.failUnless(isinstance(field, fields.Integer), ` field `) self.failUnless(field.required, ` field `)
def test_primary_key(self): id = get_mapper(model.Address).get_property('id').columns[0] field = self.factory(model.Address, id) self.failUnless(isinstance(field, fields.PrimaryKey), ` field `) self.failUnless(field.auto, ` field `) self.failUnless(not field.required, ` field `) field = field.type self.failUnless(isinstance(field, fields.Integer), ` field `) self.failUnless(field.required, ` field `)
def _reflect_models(self): # Use the scoped_session sqlsoup creates. This is suboptimal, we # need a way to bring the objects sqlsoup creates into our # session (which we can control: set to transactional, etc...) # If we don't use soup's session SA barfs with a # 'object is already attached to session blah' metadata = MetaData(self.engine) metadata.reflect() # workaround: sqlalchemy does unicode names reflecting and SqlSoup # doesn't like it for name, table in metadata.tables.iteritems(): table.name = str(name) metadata.tables[table.name] = metadata.tables.pop(name) if self.reflect == 'all': table_names = metadata.tables.keys() else: table_names = self.reflect db = sqlsoup.SqlSoup(metadata, self.session_factory) entities = dict() for table_name in table_names: try: entities[table_name] = db.entity(table_name) except sqlsoup.PKNotFoundError: log.warn("reflection: skipping table " + table_name + "...") mappers = dict((e, get_mapper(e)) for e in entities.itervalues()) # autogenerate relations for table_name, entity in entities.iteritems(): self._fix_soup_entity(entity) for prop in mappers[entity].iterate_properties: if isinstance(prop, ColumnProperty): for col in prop.columns: # See if the column is a foreign key try: fk = get_foreign_keys(col)[0] except IndexError: # It isn't... continue # It is, lookup parent mapper relation_kwds = dict() for parent, m in mappers.iteritems(): if fk.references(m.local_table): if col.primary_key: relation_kwds[ "cascade"] = 'all, delete-orphan' break # Relate it assert getattr(db, table_name) is entity # parent.relate( self.names_for_resource(entity)[1], entity, backref=self.names_for_resource(parent)[0], **relation_kwds) return entities.values()
def test_sequence(self): id = get_mapper(model.User).get_property('id') field = self.factory(model.User, id) self.failUnless(isinstance(field, fields.PrimaryKey), ` field `) self.failUnless(not field.required, ` field `) self.failUnless(field.auto, ` field `) self.failUnless(not field.has_default, ` field `) field = field.type self.failUnless(isinstance(field, fields.Integer), ` field `) self.failUnless(field.required, ` field `)
def get_id(self, obj): m = get_mapper(obj) if not m: raise TypeError("WTF are you sending to me! %r" % (obj, )) def _replace_slash(s): if isinstance(s, basestring): return s.replace('/', self.slash_replacement) return s pk = map(_replace_slash, m.primary_key_from_instance(obj)) return self.composite_id_separator.join(map(unicode, pk))
def _fields_for_mapped_class(self, resource, attr, args): """ Matches calls like (resource,None) which means that we're operating on a resource, not on it's properties/attributes. Begin a recursive descent passing (resource, attr_name) for each attribute. """ #XXX: It should be documented somewhere that FieldFactories # should pass the attr. names as a string sometime during # the recursive descent so rules that match (resource, attr_name) # can kick in # -> This applies also to other factories like viewfactories properties = get_mapper(resource).iterate_properties args['fields'] = filter( lambda f: f is not None and not f.name.startswith('_'), [self(resource, prop.key) for prop in properties]) return fields.FieldList
def get_column(self, resource, column_name, query): resource_pure=resource columns=column_name.split(".") stack= () for i in xrange(len(columns)-1): parent_pure=resource_pure parent=resource attr=columns[i] stack=stack + ((parent, attr),) prop = get_mapper(parent_pure).get_property(attr) if isinstance(prop, RelationshipProperty): resource_pure = get_other(prop) if stack in self.joins: resource = self.joins[stack] else: resource = aliased(resource_pure) self.joins[stack] = resource else: resource_pure = resource = getattr(parent, attr) col=columns[-1] is_date = hasattr(resource, 'property')\ and isinstance(resource.property, ColumnProperty)\ and not isinstance(resource.property, RelationshipProperty)\ and hasattr(resource.property, 'columns')\ and ( isinstance(resource.property.columns[0].type, types.Date) or isinstance(resource.property.columns[0].type, types.DateTime)) if not is_date: return getattr(resource, col) else: return date_part(col, resource)
def test_mapper_renamed_key(self): prop = get_mapper(model.CountryModified).get_property('label') field = self.factory(model.CountryModified, prop) self.failUnless(field.name == 'label', ` field `)
def setUp(self): self.factory = SAFieldFactory() #XXX: The following line, for some reason, prevents the first test # from failing if coverage is on, go figure get_mapper(model.User)
def test_unicode_field(self): prop = get_mapper(model.User).get_property('name') field = self.factory(model.User, prop) self.failUnless(isinstance(field, fields.Unicode), ` field `)
def test_related_list(self): prop = get_mapper(model.User).get_property('addresses') field = self.factory(model.User, prop) self.failUnless(isinstance(field, fields.List), ` field `) self.failUnless(not field.required, ` field `)
def test_explicit_from_info(self): prop = get_mapper(model.PowerUser).get_property('description') field = self.factory(model.PowerUser, prop) self.failUnless(isinstance(field, fields.HTMLText), ` field `)
def test_length(self): prop = get_mapper(model.User).get_property('name') field = self.factory(model.User, prop) self.failUnlessEqual(field.length, 15)
def test_non_auto_pk(self): code = get_mapper(model.Country).get_property('code') field = self.factory(model.Country, code) self.failUnless(isinstance(field, fields.PrimaryKey), ` field `) self.failUnless(field.required, ` field `) self.failUnless(not field.auto, ` field `)