Ah ha, so SQL expression operations are all translated directly to
their appropriate SQL clauses. This makes sense I guess. Too bad this
means I have to implement the same function twice, one in Python and
another in SQL. Would be nice if there was some magic to morph custom
properties to have some capabilities to operate on the Python side,
but I guess that would be much slower.
Right now I solved this problem with this new comparator:
class AgeComparator(PropComparator):
def __clause_element__(self):
return (func.datediff(func.curdate(),
self.mapper.c.date_of_birth) / 365)
def operate(self, op, *args, **kwargs):
return op(self.__clause_element__(), *args, **kwargs)
Thanks a lot!
On Sep 27, 1:14 pm, Michael Bayer <mike...@zzzcomputing.com> wrote:
> On Sep 27, 2009, at 12:49 PM, Yuen Ho Wong wrote:
>
>
>
>
>
>
>
> > So I have this following code:
>
> > class User(Base):
> > ....
>
> > class AgeComparator(PropComparator):
>
> > def __lt__(self, other):
> > pass
>
> > def __gt__(self, other):
> > pass
>
> > def __eq__(self, other):
> > pass
>
> > def __ne__(self, other):
> > return not (self == other)
>
> > def __le__(self, other):
> > return self < other or self == other
>
> > def __ge__(self, other):
> > return self > other or self == other
>
> > @comparable_using(AgeComparator)
> > @property
> > def age(self):
> > today = date.today()
> > age = today - (self.date_of_birth or (today + 1))
> > return age.days / 365
>
> > All I want to do is this:
>
> > user = User(date_of_birth=date.today())
> > session.add(user)
> > new_borns = session.query(User).filter(User.age == 0).all()
>
> > The doc for comparable_property() suggests that this is possible, but
> > I'm lost finding my way to call the descriptor bound on this instance.
>
> The age(self): function is only called when you actually have an
> instance, such as:
>
> user = sess.query(User).get(10)
> print "age is: " , user.age
>
> The point of @comparable_using associates the behavior of
> AgeComparator to the "age" attribute on the User class, no instance:
>
> User.age == 0
>
> User.age == 0 is going to invoke the __eq__() method on the
> AgeComparator you created. There is no instance within the query()
> call here. __eq__() needs to return a clause expression of your
> choosing, which must be expressed in terms of SQL functions, since
> you're rendering a SQL statement. That's a little tricky here since
> there's a lot of date arithmetic there, but using hypothetical
> functions it would look something like:
>
> def __eq__(self, other):
> return func.count_days(func.date_diff(func.now() -
> mapped_table.c.date_of_birth)) / 365
>
> The comparable_using example should probably include a short
> PropComparator to give more context. A sample comparator is at:
>
> http://www.sqlalchemy.org/docs/05/mappers.html#custom-comparators
>
>
>
>
>
> > The problem I have is that the ComparableProperty only gave itself and
> > the mapper to the comparator, but the user instance is nowhere to be
> > found inside either ComparableProperty, PropComparator or mapper. I'd
> > appreciate some help here if this is at all possible. The documents on
> > this is a little too sparse IMO.
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"sqlalchemy" group.
To post to this group, send email to sqlalchemy@googlegroups.com
To unsubscribe from this group, send email to
sqlalchemy+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/sqlalchemy?hl=en
-~----------~----~----~----~------~----~------~--~---
