método de iteração nas colunas definidas do modelo sqlalchemy?

Tenho tentado descobrir como iterar a lista de colunas definidas em um modelo SQLAlchemy. Eu quero escrever alguns métodos de serialização e cópia para alguns modelos. Não posso simplesmente iterar sobre o, obj.__dict__pois ele contém muitos itens específicos de SA.

Alguém sabe uma maneira de obter os nomes ide a descpartir do seguinte?

class JobStatus(Base):
    __tablename__ = 'jobstatus'

    id = Column(Integer, primary_key=True)
    desc = Column(Unicode(20))

Neste pequeno caso, eu poderia facilmente criar um:

def logme(self):
    return {'id': self.id, 'desc': self.desc}

mas eu prefiro algo que gere automaticamente o dict(para objetos maiores).

Você pode usar a seguinte função:

def __unicode__(self):
    return "[%s(%s)]" % (self.__class__.__name__, ', '.join('%s=%s' % (k, self.__dict__[k]) for k in sorted(self.__dict__) if '_sa_' != k[:4]))

Isso excluirá atributos mágicos SA , mas não excluirá as relações. Então, basicamente, ele pode carregar as dependências, pais, filhos, etc., o que definitivamente não é desejável.

Mas na verdade é muito mais fácil porque se você herdar de Base, você terá um __table__atributo, para que possa fazer:

for c in JobStatus.__table__.columns:
    print c

for c in JobStatus.__table__.foreign_keys:
    print c

Consulte Como descobrir propriedades da tabela do objeto mapeado SQLAlchemy - pergunta semelhante.

Edição de Mike: consulte funções como Mapper.c e Mapper.mapped_table . Se estiver usando 0.8 e superior, consulte também Mapper.attrs e funções relacionadas.

Exemplo para Mapper.attrs :

from sqlalchemy import inspect
mapper = inspect(JobStatus)
for column in mapper.attrs:
    print column.key

Você pode obter a lista de propriedades definidas do mapeador. Para o seu caso, você está interessado apenas em objetos ColumnProperty.

from sqlalchemy.orm import class_mapper
import sqlalchemy

def attribute_names(cls):
    return [prop.key for prop in class_mapper(cls).iterate_properties
        if isinstance(prop, sqlalchemy.orm.ColumnProperty)]

Sei que essa é uma questão antiga, mas acabo de me deparar com a mesma exigência e gostaria de oferecer uma solução alternativa para futuros leitores.

Como Josh observa, nomes completos de campos SQL serão retornados por JobStatus.__table__.columns, portanto, em vez do id do nome do campo original , você obterá jobstatus.id . Não é tão útil quanto poderia ser.

A solução para obter uma lista de nomes de campo conforme foram originalmente definidos é examinar o _dataatributo no objeto de coluna, que contém os dados completos. Se olharmos JobStatus.__table__.columns._data, é assim:

{'desc': Column('desc', Unicode(length=20), table=<jobstatus>),
 'id': Column('id', Integer(), table=<jobstatus>, primary_key=True, nullable=False)}

A partir daqui, você pode simplesmente ligar, o JobStatus.__table__.columns._data.keys()que lhe dá uma lista bonita e limpa:

['id', 'desc']

self.__table__.columnsirá "apenas" dar-lhe as colunas definidas naquela classe particular, ou seja, sem as herdadas. se precisar de tudo, use self.__mapper__.columns. no seu exemplo eu provavelmente usaria algo assim:

class JobStatus(Base):

    ...

    def __iter__(self):
        values = vars(self)
        for attr in self.__mapper__.columns.keys():
            if attr in values:
                yield attr, values[attr]

    def logme(self):
        return dict(self)

Supondo que você esteja usando o mapeamento declarativo do SQLAlchemy, você pode usar o __mapper__atributo para chegar ao mapeador de classe. Para obter todos os atributos mapeados (incluindo relacionamentos):

obj.__mapper__.attrs.keys()

Se quiser nomes de coluna estritamente, use obj.__mapper__.column_attrs.keys(). Consulte a documentação para outras visualizações.

https://docs.sqlalchemy.org/en/latest/orm/mapping_api.html#sqlalchemy.orm.mapper.Mapper.attrs

Para obter um as_dictmétodo em todas as minhas aulas, usei uma Mixinclasse que usa as técnicas descritas por Ants Aasma .

class BaseMixin(object):                                                                                                                                                                             
    def as_dict(self):                                                                                                                                                                               
        result = {}                                                                                                                                                                                  
        for prop in class_mapper(self.__class__).iterate_properties:                                                                                                                                 
            if isinstance(prop, ColumnProperty):                                                                                                                                                     
                result[prop.key] = getattr(self, prop.key)                                                                                                                                           
        return result

E então use-o assim em suas aulas

class MyClass(BaseMixin, Base):
    pass

Dessa forma, você pode invocar o seguinte em uma instância de MyClass.

> myclass = MyClass()
> myclass.as_dict()

Espero que isto ajude.

Eu brinquei com isso um pouco mais adiante, na verdade eu precisava renderizar minhas instâncias dictcomo a forma de um objeto HAL com seus links para objetos relacionados. Então, adicionei essa pequena mágica aqui, que irá rastrear todas as propriedades da classe igual à anterior, com a diferença de que eu irei rastrear mais profundamente nas Relaionshippropriedades e gerar linkspara elas automaticamente.

Observe que isso só funcionará para relacionamentos com uma única chave primária

from sqlalchemy.orm import class_mapper, ColumnProperty
from functools import reduce


def deepgetattr(obj, attr):
    """Recurses through an attribute chain to get the ultimate value."""
    return reduce(getattr, attr.split('.'), obj)


class BaseMixin(object):
    def as_dict(self):
        IgnoreInstrumented = (
            InstrumentedList, InstrumentedDict, InstrumentedSet
        )
        result = {}
        for prop in class_mapper(self.__class__).iterate_properties:
            if isinstance(getattr(self, prop.key), IgnoreInstrumented):
                # All reverse relations are assigned to each related instances
                # we don't need to link these, so we skip
                continue
            if isinstance(prop, ColumnProperty):
                # Add simple property to the dictionary with its value
                result[prop.key] = getattr(self, prop.key)
            if isinstance(prop, RelationshipProperty):
                # Construct links relaions
                if 'links' not in result:
                    result['links'] = {}

                # Get value using nested class keys
                value = (
                    deepgetattr(
                        self, prop.key + "." + prop.mapper.primary_key[0].key
                    )
                )
                result['links'][prop.key] = {}
                result['links'][prop.key]['href'] = (
                    "/{}/{}".format(prop.key, value)
                )
        return result

self.__dict__

retorna um dict em que as chaves são nomes de atributos e valores os valores do objeto.

/! \ há um atributo suplementar: '_sa_instance_state' mas você pode lidar com isso :)

Eu sei que esta é uma pergunta antiga, mas e quanto a:

class JobStatus(Base):

    ...

    def columns(self):
        return [col for col in dir(self) if isinstance(col, db.Column)]

Então, para obter os nomes das colunas: jobStatus.columns()

Isso iria voltar ['id', 'desc']

Em seguida, você pode fazer um loop e fazer coisas com as colunas e valores:

for col in jobStatus.colums():
    doStuff(getattr(jobStatus, col))