guillotina_alchemy.py

guillotina_alchemy.py

import sqlalchemy as sa
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base(cls=FolderDB)

@implementer(IOpiniones)
class Opinion(Base):
    __tablename__ = 'opiniones'

    id_opinion = sa.Column(
        sa.Integer, primary_key=True,
        server_default=sa.text("nextval('opiniones_id_opinion_seq'::regclass)")
    )
    id_producto = sa.Column(
        sa.ForeignKey(u'productos.id_producto'), nullable=False
    )
    nota = sa.Column(sa.SmallInteger, nullable=False)
    titulo = sa.Column(sa.String(125), nullable=False)
    id_usuario = sa.Column(sa.Integer, nullable=False)
    fecha = sa.Column(
        sa.DateTime, nullable=False, server_default=sa.text("now()")
    )
    idioma = sa.Column(sa.String(2), nullable=False)
    opinion = sa.Column(sa.Text, nullable=False)
    nombre_usuario = sa.Column(sa.String(254))

    def precio(self, xxx):
        return 4 + 4

# Aixo es el mateix que utilitzar el core(builder), una capa es el mapper, i l'altra el declarative, 
que es el mapper (imperatiu) de forma declarativa... De fet, 

Opiniones.__table__ es el mateix que Opiniones = Table(xxx, Columns....)

# A partir d'aqui pots fer:

opinion  = await db.fetch_one(Opiniones.__table__.where(Opiniones.id == 1))
# pero aixo torna un diccionari.

# El paquet, https://github.com/vinissimus/asyncom
# Permet fer coses com:
await db.query(Opiniones).count()
una  = db.query(Opiniones).get(id=100)
db.query(Opiniones).filter(sa.or_(Opinion.idioma == 'ca', Opinion.estado = 'pub')).limit(10)
# el limit encara no l'he probat al paquet... (segurament s'ha de parxejar per tornar-lo async
# i faci el fetch.
data = await ISerializer(ins)()

# i es pot anar mes enlla, pq en realitat, les relacions que podem fer amb arbre
# sempre son: 1 -- n

class Opiniones():
    def items(self, db):
      cls = self.__class__
      return db.query(self.__class__).filter(cls.id_vino == self.id_vino)
 
# que ens pot dur a:
await for item in ins.items.all()
# el awaitable es el .all de la classe query de paquet asyncom, la resta son chains.
# La gracia d'aixo es q et retorna instancies 

# Suposo que el FolderDB (Una mena de metaclasse), es podria fer que implementes el ILocation
# i suposo que amb això ja tindriem una capa interessant d'integració de sqlalchemy amb guillotina.
# entenc que guillotina crea una transacció de postgres lligada a la request, i per tant
# totes les operacions que fessis, hi estarien vinculades.

ins.idioma = 'ca'
db.save(ins)

# falta el tema del _p_register (o de com gestionar la cache d'objectes que tens 
# pendents de fer flush... pero vaja, en aquest cas, aixo faria el 
UPDATE opiniones set idioma='ca' where id_opinion = 'xxx';
# I en tot cas, si la request falla, 
# la transacció es desfà. La mateixa transacció activa que tens 
# Així mateix es com funciona el zope.sqlalchemy (la integració que fa servir pyramid)
# pero ells utilitzen la sessio de sqlalchemy, q es molt mes complexa, pq es precupa
# de fer els sqls de forma ordenada, pq postgres no falli..