Comment faire pour imprimer toutes les colonnes de SQLAlchemy ORM

À l'aide de SQLAlchemy, je suis en train d'imprimer tous les attributs de chacun des modèles que j'ai d'une manière similaire à:

SELECT * from table;

Cependant, je voudrais faire quelque chose avec chacun des modèles de l'instance de l'information que je reçois. Jusqu'à présent, le meilleur que j'ai été en mesure de venir avec est:

for m in session.query(model).all():
    print [getattr(m, x.__str__().split('.')[1]) for x in model.__table__.columns]
    # additional code

Et cela va me donner ce que je cherche, mais c'est un assez rond-point de la façon de l'obtenir. J'ai été un peu en espérant pour un attribut, le long des lignes de:

m.attributes 
# or 
m.columns.values

Je sens que je suis en manque de quelque chose et il y a une bien meilleure manière de faire ceci. Je fais cela parce que je vais être de tout imprimer .Les fichiers CSV, et je ne veux pas avoir à spécifier les colonnes/attributs qui m'intéresse, je veux tout (il y a un grand nombre de colonnes dans un grand nombre de modèles à imprimer).

OriginalL'auteur mrmagooey | 2011-05-18

python sqlalchemy

5

Prendre un coup d'oeil à SQLAchemy de les métadonnées de réflexion fonctionnalité.

L'inspecteur d'objet semble être ce dont j'ai besoin, merci.
À l'aide de flacon de sqlalchemy ORM j'ai été en mesure d'obtenir les noms de colonne via le suivant: data_table.__table__.les colonnes

OriginalL'auteur Alexander Kiselev
12

C'est un vieux post, mais j'ai rencontré un problème avec la base de données des noms de colonnes ne correspond pas à la cartographié les noms des attributs de l'instance. Nous avons fini par aller avec ceci:
```
from sqlalchemy import inspect
inst = inspect(model)
attr_names = [c_attr.key for c_attr in inst.mapper.column_attrs]
```
Espère que ça aide quelqu'un avec le même problème!

Très utile. Merci!!!!
Merci!!!! Cela fonctionne parfaitement!

OriginalL'auteur Starktron

Bâtiment sur Rodney L réponse:

model = MYMODEL
columns = [m.key for m in model.__table__.columns]

OriginalL'auteur KurtB

7

Sans doute le plus court de solution (voir le récent la documentation):
```
from sqlalchemy.inspection import inspect
table = inspect(model)
for column in table.c
    print column.name
```
solution sympa, cela a réglé mon problème

OriginalL'auteur Kostiantyn Ivashchenko
5

Je crois que c'est le moyen le plus facile:
```
print [cname for cname in m.__dict__.keys()]
```
EDIT: La réponse au-dessus de moi à l'aide de sqlalchemy.l'inspection.inspecter() semble être une meilleure solution.

dict ne peut pas toujours aider. J'utilise les touches = auto._sa_instance_state.attrs.les éléments()
pas aider..si nous avons plusieurs fonction définie selon le modèle, cette obtiendrez de ces fonction

OriginalL'auteur Fahad Yousuf

Mettre cela ensemble et trouvé utile:

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
engine = create_engine('mysql+pymysql://testuser:password@localhost:3306/testdb')
DeclarativeBase = declarative_base()
metadata = DeclarativeBase.metadata
metadata.bind = engine


# configure Session class with desired options
Session = sessionmaker()

# associate it with our custom Session class
Session.configure(bind=engine)

# work with the session
session = Session()

Et puis:

d = {k: metadata.tables[k].columns.keys() for k in metadata.tables.keys()}

Exemple de sortie print(d):

{'orderdetails': ['orderNumber', 'productCode', 'quantityOrdered', 'priceEach', 'orderLineNumber'], 
'offices': ['addressLine1', 'addressLine2', 'city', 'country', 'officeCode', 'phone', 'postalCode', 'state', 'territory'],
'orders': ['comments', 'customerNumber', 'orderDate', 'orderNumber', 'requiredDate', 'shippedDate', 'status'],
'products': ['MSRP', 'buyPrice', 'productCode', 'productDescription', 'productLine', 'productName', 'productScale', 'productVendor', 'quantityInStock'],
'employees': ['employeeNumber', 'lastName', 'firstName', 'extension', 'email', 'officeCode', 'reportsTo', 'jobTitle'], 
'customers': ['addressLine1', 'addressLine2', 'city', 'contactFirstName', 'contactLastName', 'country', 'creditLimit', 'customerName', 'customerNumber', 'phone', 'postalCode', 'salesRepEmployeeNumber', 'state'],
'productlines': ['htmlDescription', 'image', 'productLine', 'textDescription'],
'payments': ['amount', 'checkNumber', 'customerNumber', 'paymentDate']}

OU puis:

from sqlalchemy.sql import text
cmd = "SELECT * FROM information_schema.columns WHERE table_schema = :db ORDER BY table_name,ordinal_position"
result = session.execute(
            text(cmd),
            {"db": "classicmodels"}
        )
result.fetchall()

OriginalL'auteur jmunsch

2

Je suis à l'aide de SQL Alchimie v 1.0.14 sur Python 3.5.2

En supposant que vous pouvez vous connecter à un moteur avec create_engine(), j'ai été en mesure d'afficher toutes les colonnes à l'aide du code suivant. Remplacer "ma chaîne de connexion" et "mon nom de table" avec les valeurs appropriées.
```
from sqlalchemy import create_engine, MetaData, Table, select

engine = create_engine('my connection string')

conn = engine.connect()
metadata = MetaData(conn)
t = Table("my table name", metadata, autoload=True)
columns = [m.key for m in t.columns]
columns
```
la dernière ligne affiche uniquement les noms de colonnes de la déclaration précédente.

OriginalL'auteur FistOfFury

Vous pouvez être intéressé par ce que j'ai trouvé pour ce faire.

from sqlalchemy.orm import class_mapper
import collections
# structure returned by get_metadata function.
MetaDataTuple = collections.namedtuple("MetaDataTuple", 
"coltype, colname, default, m2m, nullable, uselist, collection")
def get_metadata_iterator(class_):
for prop in class_mapper(class_).iterate_properties:
name = prop.key
if name.startswith("_") or name == "id" or name.endswith("_id"):
continue
md = _get_column_metadata(prop)
if md is None:
continue
yield md
def get_column_metadata(class_, colname):
prop = class_mapper(class_).get_property(colname)
md = _get_column_metadata(prop)
if md is None:
raise ValueError("Not a column name: %r." % (colname,))
return md
def _get_column_metadata(prop):
name = prop.key
m2m = False
default = None
nullable = None
uselist = False
collection = None
proptype = type(prop)
if proptype is ColumnProperty:
coltype = type(prop.columns[0].type).__name__
try:
default = prop.columns[0].default
except AttributeError:
default = None
else:
if default is not None:
default = default.arg(None)
nullable = prop.columns[0].nullable
elif proptype is RelationshipProperty:
coltype = RelationshipProperty.__name__
m2m = prop.secondary is not None
nullable = prop.local_side[0].nullable
uselist = prop.uselist
if prop.collection_class is not None:
collection = type(prop.collection_class()).__name__
else:
collection = "list"
else:
return None
return MetaDataTuple(coltype, str(name), default, m2m, nullable, uselist, collection)

OriginalL'auteur Keith

print repr(model.__table__)

Ou tout simplement les colonnes:

print str(list(model.__table__.columns))

OriginalL'auteur Curtis Yallop

0

Je l'utiliser parce que c'est légèrement plus courte:
```
for m in session.query(*model.__table__.columns).all():
print m
```
OriginalL'auteur rvl

Vous devez vous connecter pour publier un commentaire.