Re: [sqlalchemy] Find whether a synonym "points" to a foreign key or a relationship (Looking for your blessing)
Thank you...
> Of course using all those descriptors for every attribute is a pretty
> java-esque
Yeah... but you know... It's not easy getting rid of the past... And
I'm pretty O.C.D, so I lve getters/setters... I'm opened to new
experiences, though :-) Any hint, suggestion... whatever! you may have
will be very appreciated...
As usual, thank you so much!
2011/2/27 Michael Bayer :
>
> On Feb 27, 2011, at 6:45 PM, Hector Blanco wrote:
>
>> A few days ago I asked what appears in the body of the message, a few
>> lines below. To summarize:
>>
>> Let's say I have a class "User" (yeah, to define "users" in my
>> application) and each user can belong to one "UserGroup" (another
>> class of my application). The User class would be something like:
>>
>>
>> class User(declarativeBase):
>> """Represents a user"""
>> __tablename__ = "users"
>>
>> _id = Column("id", Integer, primary_key=True)
>> _firstName = Column("first_name", String(50))
>> _lastName = Column("last_name", String(50))
>> _userName = Column("user_name", String(50), unique=True,
>> nullable=False)
>> _password = Column("password", String(64), nullable=False)
>> _userGroupId = Column("user_group_id", Integer,
>> ForeignKey("user_groups.id"))
>>
>> _userGroup = relationship("UserGroup", uselist=False)
>>
>>
>> id = synonym('_id', descriptor=property(getId, setId))
>> firstName = synonym('_firstName', descriptor=property(getFirstName,
>> setFirstName))
>> lastName = synonym('_lastName', descriptor=property(getLastName,
>> setLastName))
>> userName = synonym('_userName', descriptor=property(getUserName,
>> setUserName))
>> password = synonym('_password', descriptor=property(getPassword,
>> setPassword))
>> userGroupId = synonym('_userGroupId',
>> descriptor=property(getUserGroupId,
>> setUserGroupId))
>> userGroup = synonym('_userGroup', descriptor=property(getUserGroup,
>> setUserGroup))
>>
>> I wanted to find a way to find which synonyms "pointed" to foreign
>> keys and which ones pointed to relationships. Basically, having a
>> couple of methods like the following:
>> def getRelationships(cls):
>> that when invoked with getRelationships(User.User) would return a list
>> with ["userGroup"] (withouth the "_" in front)
>> and another:
>> def getForeignKeys(cls):
>> that would return ["userGroupId"]
>>
>> So far I've done this:
>>
>> def getRelationships(cls):
>> retval = list()
>> mapper = sqlalchemy.orm.class_mapper(cls)
>> actualNameToSynonym = dict()
>> relationships = set()
>>
>> for prop in mapper.iterate_properties:
>> if isinstance(prop, sqlalchemy.orm.properties.SynonymProperty):
>> actualNameToSynonym[prop.name] = prop.key
>> # dictionary <_userName, userName, userGroup,
>> _userGroup>
>>
>> elif isinstance(prop,
>> sqlalchemy.orm.properties.RelationshipProperty):
>> relationships.add(prop.key)
>> #set with _userGroup, and rest of relationships
>>
>> for relationship in relationships:
>> retval.append(actualNameToSynonym[relationship])
>>
>> return retval
>>
>> def getForeignKeys(cls):
>> retval = list()
>> mapper = sqlalchemy.orm.class_mapper(cls)
>> actualNameToSynonym = dict()
>> columnsWithForeignKeys = set()
>>
>> for prop in mapper.iterate_properties:
>> if isinstance(prop, sqlalchemy.orm.properties.SynonymProperty):
>> actualNameToSynonym[prop.name] = prop.key
>> # dictionary <_userName, userName, userGroup,
>> _userGroup>
>>
>> elif isinstance(prop,
>> sqlalchemy.orm.properties.ColumnProperty):
>> for column in prop.columns:
>> if len(column.foreign_keys) > 0:
>> columnsWithForeignKeys.add(prop.key)
>>
>> for columnWithForeignKeys in columnsWithForeignKeys:
>> retval.append(actualNameToSynonym[columnWithForeignKeys])
>> return retval
>>
>> Both are very similar: First they create a dictionary mapping the
>> synonym's key with the "real" name (<_userGroup, userGroup>) and store
>> the "relationships" or the columns that have a "foreign key" in a set
>> (for the method that tries to get relationships, that set would be
>> set("_userGroup") and for the one that tries to get foreign keys,
>> set("_userGroupId")) . In a second "for" loop they match that
>> "underscored" name with the name of the synonym to return a list with
>> the names of the synonyms, and not the actual columns (basically, to
>> transform "_userGroupId" to "userGroupId")
>>
>> They seem to work, at least with my not-complicated-at-all classes,
>> but I'd li
Re: [sqlalchemy] Find whether a synonym "points" to a foreign key or a relationship (Looking for your blessing)
On Feb 27, 2011, at 6:45 PM, Hector Blanco wrote:
> A few days ago I asked what appears in the body of the message, a few
> lines below. To summarize:
>
> Let's say I have a class "User" (yeah, to define "users" in my
> application) and each user can belong to one "UserGroup" (another
> class of my application). The User class would be something like:
>
>
> class User(declarativeBase):
> """Represents a user"""
> __tablename__ = "users"
>
> _id = Column("id", Integer, primary_key=True)
> _firstName = Column("first_name", String(50))
> _lastName = Column("last_name", String(50))
> _userName = Column("user_name", String(50), unique=True, nullable=False)
> _password = Column("password", String(64), nullable=False)
> _userGroupId = Column("user_group_id", Integer,
> ForeignKey("user_groups.id"))
>
> _userGroup = relationship("UserGroup", uselist=False)
>
>
> id = synonym('_id', descriptor=property(getId, setId))
> firstName = synonym('_firstName', descriptor=property(getFirstName,
> setFirstName))
> lastName = synonym('_lastName', descriptor=property(getLastName,
> setLastName))
> userName = synonym('_userName', descriptor=property(getUserName,
> setUserName))
> password = synonym('_password', descriptor=property(getPassword,
> setPassword))
> userGroupId = synonym('_userGroupId',
> descriptor=property(getUserGroupId,
> setUserGroupId))
> userGroup = synonym('_userGroup', descriptor=property(getUserGroup,
> setUserGroup))
>
> I wanted to find a way to find which synonyms "pointed" to foreign
> keys and which ones pointed to relationships. Basically, having a
> couple of methods like the following:
> def getRelationships(cls):
> that when invoked with getRelationships(User.User) would return a list
> with ["userGroup"] (withouth the "_" in front)
> and another:
> def getForeignKeys(cls):
> that would return ["userGroupId"]
>
> So far I've done this:
>
> def getRelationships(cls):
> retval = list()
> mapper = sqlalchemy.orm.class_mapper(cls)
> actualNameToSynonym = dict()
> relationships = set()
>
> for prop in mapper.iterate_properties:
> if isinstance(prop, sqlalchemy.orm.properties.SynonymProperty):
> actualNameToSynonym[prop.name] = prop.key
> # dictionary <_userName, userName, userGroup,
> _userGroup>
>
> elif isinstance(prop,
> sqlalchemy.orm.properties.RelationshipProperty):
> relationships.add(prop.key)
> #set with _userGroup, and rest of relationships
>
> for relationship in relationships:
> retval.append(actualNameToSynonym[relationship])
>
> return retval
>
> def getForeignKeys(cls):
> retval = list()
> mapper = sqlalchemy.orm.class_mapper(cls)
> actualNameToSynonym = dict()
> columnsWithForeignKeys = set()
>
> for prop in mapper.iterate_properties:
> if isinstance(prop, sqlalchemy.orm.properties.SynonymProperty):
> actualNameToSynonym[prop.name] = prop.key
> # dictionary <_userName, userName, userGroup,
> _userGroup>
>
> elif isinstance(prop, sqlalchemy.orm.properties.ColumnProperty):
> for column in prop.columns:
> if len(column.foreign_keys) > 0:
> columnsWithForeignKeys.add(prop.key)
>
> for columnWithForeignKeys in columnsWithForeignKeys:
> retval.append(actualNameToSynonym[columnWithForeignKeys])
> return retval
>
> Both are very similar: First they create a dictionary mapping the
> synonym's key with the "real" name (<_userGroup, userGroup>) and store
> the "relationships" or the columns that have a "foreign key" in a set
> (for the method that tries to get relationships, that set would be
> set("_userGroup") and for the one that tries to get foreign keys,
> set("_userGroupId")) . In a second "for" loop they match that
> "underscored" name with the name of the synonym to return a list with
> the names of the synonyms, and not the actual columns (basically, to
> transform "_userGroupId" to "userGroupId")
>
> They seem to work, at least with my not-complicated-at-all classes,
> but I'd like to know what do you guys think of my approach. Is it
> good? Can it break something? Is there a better way?
No thats a pretty OK way , there's an argument called "resolve_synonyms" to
get_property() in 0.6 but that's gone away in 0.7 anyway. There aren't too
many choices for types of *Property. Perhaps if you wanted to handle
CompositeProperty, though you wouldn't need to do so in 0.7 since composite
doesn't "replace" the column props in 0.7.
Of course using all those descri
Re: [sqlalchemy] Find whether a synonym "points" to a foreign key or a relationship (Looking for your blessing)
A few days ago I asked what appears in the body of the message, a few
lines below. To summarize:
Let's say I have a class "User" (yeah, to define "users" in my
application) and each user can belong to one "UserGroup" (another
class of my application). The User class would be something like:
class User(declarativeBase):
"""Represents a user"""
__tablename__ = "users"
_id = Column("id", Integer, primary_key=True)
_firstName = Column("first_name", String(50))
_lastName = Column("last_name", String(50))
_userName = Column("user_name", String(50), unique=True, nullable=False)
_password = Column("password", String(64), nullable=False)
_userGroupId = Column("user_group_id", Integer,
ForeignKey("user_groups.id"))
_userGroup = relationship("UserGroup", uselist=False)
id = synonym('_id', descriptor=property(getId, setId))
firstName = synonym('_firstName', descriptor=property(getFirstName,
setFirstName))
lastName = synonym('_lastName', descriptor=property(getLastName,
setLastName))
userName = synonym('_userName', descriptor=property(getUserName,
setUserName))
password = synonym('_password', descriptor=property(getPassword,
setPassword))
userGroupId = synonym('_userGroupId',
descriptor=property(getUserGroupId,
setUserGroupId))
userGroup = synonym('_userGroup', descriptor=property(getUserGroup,
setUserGroup))
I wanted to find a way to find which synonyms "pointed" to foreign
keys and which ones pointed to relationships. Basically, having a
couple of methods like the following:
def getRelationships(cls):
that when invoked with getRelationships(User.User) would return a list
with ["userGroup"] (withouth the "_" in front)
and another:
def getForeignKeys(cls):
that would return ["userGroupId"]
So far I've done this:
def getRelationships(cls):
retval = list()
mapper = sqlalchemy.orm.class_mapper(cls)
actualNameToSynonym = dict()
relationships = set()
for prop in mapper.iterate_properties:
if isinstance(prop, sqlalchemy.orm.properties.SynonymProperty):
actualNameToSynonym[prop.name] = prop.key
# dictionary <_userName, userName, userGroup,
_userGroup>
elif isinstance(prop,
sqlalchemy.orm.properties.RelationshipProperty):
relationships.add(prop.key)
#set with _userGroup, and rest of relationships
for relationship in relationships:
retval.append(actualNameToSynonym[relationship])
return retval
def getForeignKeys(cls):
retval = list()
mapper = sqlalchemy.orm.class_mapper(cls)
actualNameToSynonym = dict()
columnsWithForeignKeys = set()
for prop in mapper.iterate_properties:
if isinstance(prop, sqlalchemy.orm.properties.SynonymProperty):
actualNameToSynonym[prop.name] = prop.key
# dictionary <_userName, userName, userGroup,
_userGroup>
elif isinstance(prop, sqlalchemy.orm.properties.ColumnProperty):
for column in prop.columns:
if len(column.foreign_keys) > 0:
columnsWithForeignKeys.add(prop.key)
for columnWithForeignKeys in columnsWithForeignKeys:
retval.append(actualNameToSynonym[columnWithForeignKeys])
return retval
Both are very similar: First they create a dictionary mapping the
synonym's key with the "real" name (<_userGroup, userGroup>) and store
the "relationships" or the columns that have a "foreign key" in a set
(for the method that tries to get relationships, that set would be
set("_userGroup") and for the one that tries to get foreign keys,
set("_userGroupId")) . In a second "for" loop they match that
"underscored" name with the name of the synonym to return a list with
the names of the synonyms, and not the actual columns (basically, to
transform "_userGroupId" to "userGroupId")
They seem to work, at least with my not-complicated-at-all classes,
but I'd like to know what do you guys think of my approach. Is it
good? Can it break something? Is there a better way?
Thank you!
2011/2/18 Hector Blanco :
> I'll give it a try!!
>
> Thank you!
>
> 2011/2/18 Michael Bayer :
>>
>> On Feb 17, 2011, at 6:37 PM, Hector Blanco wrote:
>>
>>> Hello everyone!
>>>
>>> Let's say I have a class defined like this:
>>>
>>> class User(declarativeBase):
>>> """Represents a user"""
>>> __tablename__ = "users"
>>>
>>> _id = Column("id", Integer, primary_key=True)
>>> _phone = Column("phone", String(16))
>>> _userName = Column("user_name", String(50), unique=True,
>>> nullable=False)
>>>
