Re: [Sqlalchemy-tickets] [sqlalchemy] #2824: Add ability to query column sets as one entity

[sqlalchemy <mi...@zz...>]

#2824: Add ability to query column sets as one entity
-----------------------------------+------------------------------------
      Reporter:  vmagamedov        |      Owner:  zzzeek
          Type:  enhancement       |     Status:  new
      Priority:  medium            |  Milestone:  0.9.xx
     Component:  orm               |   Severity:  no triage selected yet
    Resolution:                    |   Keywords:
Progress State:  not decided upon  |
-----------------------------------+------------------------------------
Changes (by zzzeek):

 * status_field:  awaiting triage => not decided upon
 * milestone:   => 0.9.xx


Comment:

 this seems like just a simple filter on top of column-based results.  I'd
 think you could just hit Session.query_cls, and __iter__(), and be done
 with it, proof of concept:

 {{{
 #!python
 from sqlalchemy.orm import Query

 class Thing(Query):
     _special = False

     @classmethod
     def factory(cls, entities, session=None):
         if isinstance(entities[0], EntityThing):
             ent = entities[0]
             query = Thing(ent._expand(), session)
             query._special = ent
             return query
         else:
             return Query(entities, session)

     def __iter__(self):
         if self._special:
             return self._special._iter(Query.__iter__(self))
         else:
             return Query.__iter__(self)

 class EntityThing(object):
     def __init__(self, expr):
         self.expr = expr

     def _expand(self):
         return [
             e.label(key)
             for key, e in self.expr.items()
         ]

     def _iter(self, rows):
         for row in rows:
             yield self._process(row)

     def _process(self, row):
         return dict((key, col) for key, col in zip(self.expr, row))

 from sqlalchemy import *
 from sqlalchemy.orm import *
 from sqlalchemy.ext.declarative import declarative_base

 Base = declarative_base()

 class A(Base):
     __tablename__ = 'a'

     id = Column(Integer, primary_key=True)
     data = Column(String)

 e = create_engine("sqlite://", echo=True)
 Base.metadata.create_all(e)

 sess = Session(e, query_cls=Thing.factory)
 sess.add(A(data='a1'), A(data='a2'))

 et = EntityThing({"id": A.id, "data": A.data})
 print sess.query(et).all()
 }}}

 the only feature I can see here is maybe a more idiomatic way of filtering
 the output of a Query, we've just had people overriding `__iter__()` but
 we'd want to revisit several existing examples/recipes that feature this
 usage.

--
Ticket URL: <http://www.sqlalchemy.org/trac/ticket/2824#comment:1>
sqlalchemy <http://www.sqlalchemy.org/>
The Database Toolkit for Python