Comment construire une application flask autour d'une base de données déjà existante?

La clé pour connecter la réponse de Holger à un contexte flask est que db.Model est un objet declarative_base comme Base. Il m'a fallu du temps pour remarquer cette phrase importante dans la documentation de flask-sqlalchemy

Voici les étapes que j'ai utilisées pour mon application:

1. Initiez un objet db de la manière habituelle flask-alchemy: db = SQLAlchemy(app). Notez que vous devrez définir app.config['SQLALCHEMY_DATABASE_URI'] = 'connection_string' avant cela.

2. Lier la base déclarative à un moteur: db.Model.metadata.reflect(db.engine)

3. Alors vous peut utiliser les tables existantes facilement (par exemple. J'ai une table appelée bâtiments):

   class Buildings(db.Model):
       __table__ = db.Model.metadata.tables['BUILDING']
   
       def __repr__(self):
           return self.DISTRICT
   

Maintenant, votre classe Buildings suivra le schéma existant. Vous pouvez essayer dir(Buildings) dans un shell Python et voir toutes les colonnes déjà listées.

J'ai récemment vécu la même chose, avec le défi supplémentaire de relier les modèles à travers deux bases de données.

J'ai utilisé Flask-SQLAlchemy et tout ce que j'avais à faire était de définir mes modèles de la même manière que mes tables de base de données, et j'étais parti rire. Ce que j'ai trouvé difficile, c'était de déterminer exactement à quoi devrait ressembler la structure de mon projet.

Mon projet était une API Restful, et c'est ce que j'ai fini avec:

conf/
    __init__.py
    local.py
    dev.py
    stage.py
    live.py
deploy/
    #nginx, uwsgi config, etc
middleware/
    authentication.py
app_name/
    blueprints/
        __init__.py
        model_name.py #routes for model_name
        ...
    models/
        __init.py
        model_name.py
    __init__.py
    database.py
tests/
    unit/
        test_etc.py
        ...
run.py

Fichiers de remarque:

Conf/xxx.py

C'est ainsi que nous disons à Flask-SQLAlchemy à quoi se connecter, plus vous pouvez mettre n'importe quel autre élément de configuration ici (comme l'emplacement du journal, la configuration du débogage, etc.).

SQLALCHEMY_DATABASE_URI = 'mysql://username:password@host:port/db_name'

App_name/___init___.py

C'est là que je crée mon application et initialise la base de données. Cet objet db sera importé et utilisé dans toute l'application (c'est-à-dire dans les modèles, les tests, etc.). J'ai également défini mon enregistreur, initialise mes API et blueprints et attache mon middleware ici (non illustré).

from app_name.database import db
from flask import Flask

def create_app(*args, **kwargs):
    env = kwargs['env']
    app = Flask(__name__)
    app.config.from_object('conf.%s' % env)
    db.init_app(app)
    return app

App_name/database.py

from flask.ext.sqlalchemy import SQLAlchemy
db = SQLAlchemy()

App_name/models/model_name.py

from services.database import db


class Bar(db.Model):

    __tablename__ = 'your_MySQL_table_name'

    id = db.Column('YourMySQLColumnName', db.Integer, primary_key=True)
    name = db.Column('WhateverName', db.String(100))
    foo = db.Column(db.ForeignKey('another_MySQLTableName.id'))

class Foo(db.Model):

    __tablename__ = 'another_MySQLTableName'

    id = db.Column('FooId', db.Integer, primary_key=True)
    ...

Run.py

#! /usr/bin/env python

from app_name import create_app

app = create_app(env='local')

if __name__ == '__main__':
    app.run()

J'utilise run.py pour exécuter l'application en local, mais j'utilise nginx + uWSGI pour exécuter l'application dans la dev/stage/milieux de vie.

Je suppose que vous aurez un répertoire views/ en plus de cela.

Je pense que le moyen le plus simple d'utiliser une base de données existante avec sqlalchemy est d'utiliser la classe AutomapBase. Un exemple de code de docs est le suivant:

from sqlalchemy.ext.automap import automap_base
from sqlalchemy.orm import Session
from sqlalchemy import create_engine

Base = automap_base()

# engine, suppose it has two tables 'user' and 'address' set up
engine = create_engine("sqlite:///mydatabase.db")

# reflect the tables
Base.prepare(engine, reflect=True)

# mapped classes are now created with names by default
# matching that of the table name.
User = Base.classes.user
Address = Base.classes.address

session = Session(engine)

# rudimentary relationships are produced
session.add(Address(email_address="foo@bar.com", user=User(name="foo")))
session.commit()

# collection-based relationships are by default named
# "<classname>_collection"
print (u1.address_collection)

Reportez-vous à SqlAlchemy-Automap pour plus de détails et des utilisations plus compliquées

J'essaie d'utiliser générée automatiquement, mais rien ne fonctionne ou je ne pouvais pas l'exécuter. Lorsque je cherche à générer du code en utilisant sqlacodegen, je trouve https://github.com/ksindi/flask-sqlacodegen , vous pouvez générer le code juste

flask-sqlacodegen  mysql://username:password@host:port/db_name --schema yourschema --tables table1,table2 --flask

J'ai essayé et ça marche parfaitement

C'est une autre façon de configurer le chemin du moteur décrit dans la réponse de Holger. Pratique s'il y a des caractères spéciaux dans votre nom d'utilisateur ou mot de passe.

from sqlalchemy.engine.url import URL
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base

engine_URL = URL('mssql+pymssql',
                 username='DOMAIN\\USERNAME', 
                 password="""p@ssword'!""", 
                 host='host.com', 
                 database='database_name')

engine = create_engine(engine_URL)
Base = declarative_base()
Base.metadata.reflect(engine)

Cette solution a fonctionné pour moi

"""Example for reflecting database tables to ORM objects

This script creates classes for each table reflected
from the database.

Note: The class names are imported to the global namespace using
the same name as the tables. This is useful for quick utility scripts.
A better solution for production code would be to return a dict
of reflected ORM objects.
"""

from sqlalchemy import create_engine, MetaData
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base


def reflect_all_tables_to_declarative(uri):
"""Reflects all tables to declaratives

Given a valid engine URI and declarative_base base class
reflects all tables and imports them to the global namespace.

Returns a session object bound to the engine created.
"""

# create an unbound base our objects will inherit from
Base = declarative_base()

engine = create_engine(uri)
metadata = MetaData(bind=engine)
Base.metadata = metadata

g = globals()

metadata.reflect()

for tablename, tableobj in metadata.tables.items():
    g[tablename] = type(str(tablename), (Base,), {'__table__' : tableobj })
    print("Reflecting {0}".format(tablename))

Session = sessionmaker(bind=engine)
return Session()


# set to database credentials/host
CONNECTION_URI = "postgres://..."

session = reflect_all_tables_to_declarative(CONNECTION_URI)

# do something with the session and the orm objects
results = session.query(some_table_name).all()

Alambic (l'outil derrière flacon-sqlalchemy) peut être configuré pour ignorer les tables. La configuration n'est pas trop difficile à configurer. voir: https://gist.github.com/utek/6163250