标签: flask-sqlalchemy

我使用本教程作为指导.http://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-iv-database

我想要有可以产生多个产品的类别.类似于他有多个帖子的用户.

当我打开python解释器并尝试创建一个类别

>>>from app import db, models
>>>u = models.Category(name="Test")

我收到这个错误

/sqlalchemy/orm/properties.py", line 1387, in _generate_backref
self, mapper))
sqlalchemy.exc.ArgumentError: Error creating backref 'category' on relationship 'Category.products': property of that name exists on mapper 'Mapper|Product|product'

所以backref存在问题.在教程中(我已经用他的代码尝试过),他能够使用类似语法的用户.

我甚至尝试使用他的所有文件并创建并迁移了一个新的数据库,我得到了同样的错误.

这是我的models.py文件:

from app import db

WR_IP_NO = 0
WR_IP_YES = 1

class Category(db.Model):
    id = db.Column(db.Integer, primary_key = True)
    name = db.Column(db.String(64), unique = True)
    products = db.relationship('Product', backref = 'category', lazy = 'dynamic')

    def __repr__(self):
        return '<Category %r>' % (self.name)

class …

我的User模特是

class User(UserMixin, db.Model):
    __tablename__ = 'users'
    # noinspection PyShadowingBuiltins
    uuid = Column('uuid', GUID(), default=uuid.uuid4, primary_key=True,
                  unique=True)
    email = Column('email', String, nullable=False, unique=True)
    _password = Column('password', String, nullable=False)
    created_on = Column('created_on', sa.types.DateTime(timezone=True),
                        default=datetime.utcnow())
    last_login = Column('last_login', sa.types.DateTime(timezone=True),
                        onupdate=datetime.utcnow())

其中GUID是sqlalchemy docs中描述的自定义类型(完全相同)

现在我跑的时候

alembic revision --autogenerate -m "Added initial table"

我得到了我upgrade()的

def upgrade():
    ### commands auto generated by Alembic - please adjust! ###
    op.create_table('users',
    sa.Column('uuid', sa.GUID(), nullable=False),
    sa.Column('email', sa.String(), nullable=False),
    sa.Column('password', sa.String(), nullable=False),
    sa.Column('created_on', …

我正在使用Flask作为我的python wsgi服务器,而sqlalchemy使用我的所有数据库访问.

我想我想在我的应用程序中使用Flask-Sqlalchemy扩展,但我不想使用声明性基类(db.Model),相反,我想使用sqlalchemy.ext.declarative中的基类.

这是否会破坏使用扩展程序的全部目的？

我的用例:

我想扩展程序可以帮助我更好地管理会话/引擎,但我想分别处理所有模型.

我实际上不介意使用扩展,但我想编写严格的模型.我正在从一个非烧瓶应用程序移植代码,我会在我去的时候将更改推回到该项目.例如,如果flask-sqlalchemy允许我欺骗表元数据,那么当代码被推回时会导致问题.我的代码中还有一些代码可以进行大量的类型检查(多态身份),我还记得在使用扩展时不建议读取表格上的类型检查.

什么是设计烧瓶sqlalchemy中三对多对多的正确方法？

假设我有用户,团队和角色.用户被分配到团队.分配给团队后,还会在该团队中为用户分配角色.

from myapp import db

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(128), unique=True)

    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return "<User(%s)>" % self.name

class Team(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(128), unique=True)

    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return "<Team(%s)>" % self.name

class Role(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(128), unique=True)

    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return "<Role(%s)>" % self.name

为此设计代理表的几种方法都失败了.我认为我误解了文档,因此不想让你迷惑我到目前为止所采取的所有失败的方法.

我想留下一个问题:在flask-sqlalchemy中设计一个三向多对多关系的正确方法是什么.

association_table = Table("association_table",
                          Base.metadata,
                          Column("show_id", Integer(), ForeignKey("show_times.id"), primary_key=True),
                          Column("theater_id", Integer(), ForeignKey("theaters.id")))

association_table2 = Table("association_table2",
                           Base.metadata,
                           Column("show_id", Integer(), ForeignKey("show_times.id"), primary_key=True),
                           Column("movie_id", Integer(), ForeignKey("movies.id")))



class Movie(Base):
    __tablename__ = "movies"
    id = Column(Integer, primary_key=True)
    title = Column(String(), unique=True)
    plot = Column(String())
    duration = Column(String())
    rating = Column(String())
    trailer = Column(String())
    imdb = Column(String())
    poster = Column(String())
    summary = Column(String())

class Theater(Base):
    __tablename__ = "theaters"
    id = Column(Integer, primary_key=True)
    zip_code = Column(String())
    city = Column(String())
    state = Column(String())
    address = Column(String())
    phone_number = Column(String()) …

我正在开发一个Flask项目,我正在使用Flask-SQLAlchemy.
我需要使用多个现有的数据库.
我创建了"app"对象和SQLAlchemy对象:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy


app = Flask(__name__)
db = SQLAlchemy(app)

在配置中,我设置了默认连接和其他绑定:

SQLALCHEMY_DATABASE_URI = 'postgresql://pg_user:pg_pwd@pg_server/pg_db'
SQLALCHEMY_BINDS = {
    'oracle_bind': 'oracle://oracle_user:oracle_pwd@oracle_server/oracle_schema',
    'mssql_bind': 'mssql+pyodbc://msssql_user:mssql_pwd@mssql_server/mssql_schema?driver=FreeTDS'
}

然后我使用声明性系统创建了表模型,并在需要时设置 __bind_key__参数以指示表所在的数据库.
例如:

class MyTable(db.Model):
    __bind_key__ = 'mssql_bind'
    __tablename__ = 'my_table'

    id = db.Column(db.Integer, nullable=False, primary_key=True)
    val = db.Column(db.String(50), nullable=False)

通过这种方式,一切正常,当我进行查询时,它是在正确的数据库上进行的.

阅读SQLAlchemy文档和Flask-SQLALchemy文档我理解这些事情(我写下来检查我理解正确):

• 您可以通过会话处理事务.
• 在SQLAlchemy中,您可以将会话与特定引擎绑定.
• Flask-SQLAlchemy在请求开始时自动创建会话(scoped_session),并在请求结束时销毁它
  

所以我可以这样做:

record = MyTable(1, 'some text')
db.session.add(record)
db.session.commit()

我无法理解当我们在Flask-SqlAlchemy中使用多个关于会话的数据库时会发生什么.

我验证了系统能够通过__bind_key__参数在正确的数据库中正确绑定表,因此,我可以通过在不同的数据库中插入数据db.session,并在提交时保存所有内容.

但是,我不能理解Flask-SQLAlchemy是否创建多个会话(每个引擎一个会话)或者以不同的方式管理事物.
在这两种情况下,如何引用特定数据库的会话/事务？
如果我使用db.session.commit()系统对所有涉及的数据库进行提交,但是如果我只想为单个数据库提交,我该怎么办？
我会做的事情如下:

db.session('mssql_bind').commit()

但我无法弄清楚如何做到这一点.

我还看到了一个Flask-SQLAlchemy实现,它可以简化这些情况的管理:

问题:https …

我正在使用flask migrateflask-sqlalchemy进行数据库创建和迁移.

一切都工作正常,直到我更改我的数据库用户密码包含'@'然后它停止工作所以,我更新了我的代码基于 写密码包含特殊字符时的连接字符串

它适用于应用但不适用于烧瓶迁移,它在迁移时显示错误

即 python manage.py db migrate

ValueError: invalid interpolation syntax in u'mysql://user:p%40ssword@localhost/testdb' at position 15

密码在这里被p@ssword转义urlquote(见上面的问题链接).

完整错误堆栈:

Traceback (most recent call last):
  File "manage.py", line 20, in <module>
    manager.run()
  File "/usr/local/lib/python2.7/dist-packages/flask_script/__init__.py", line 412, in run
    result = self.handle(sys.argv[0], sys.argv[1:])
  File "/usr/local/lib/python2.7/dist-packages/flask_script/__init__.py", line 383, in handle
    res = handle(*args, **config)
  File "/usr/local/lib/python2.7/dist-packages/flask_script/commands.py", line 216, in __call__
    return self.run(*args, **kwargs)
  File "/usr/local/lib/python2.7/dist-packages/flask_migrate/__init__.py", line 177, in migrate
    version_path=version_path, rev_id=rev_id)
  File "/usr/local/lib/python2.7/dist-packages/alembic/command.py", line 117, …

我有一个Flask项目,通过Flask-SQLAlchemy与MySQL数据库交互.

我的问题是,如何根据值或其他值从数据库中选择一行.

我在SQL中想要的结果看起来像这样

SELECT id FROM users WHERE email=email OR name=name;

如何在Flask-SQLAlchemy中实现这一目标？

我的SQLAlchemy应用程序(在MariaDB之上运行)包括两个模型MyModelA,MyModelB后者是前者的子记录:

class MyModelA(db.Model):
    a_id   = db.Column(db.Integer, nullable=False, primary_key=True)
    my_field1 = db.Column(db.String(1024), nullable=True)

class MyModelB(db.Model):
    b_id   = db.Column(db.Integer, nullable=False, primary_key=True)
    a_id = db.Column(db.Integer, db.ForeignKey(MyModelA.a_id), nullable=False)
    my_field2 = db.Column(db.String(1024), nullable=True)

这些的实例MyModelA和MyModelB我创建:

>>> my_a = MyModelA(my_field1="A1")
>>> my_a.aid
1
>>> MyModelB(a_id=my_a.aid, my_field2="B1")

我有以下代码删除MyModelAwhere 的实例a_id==1:

db.session.commit()
try:
    my_a = MyModelA.query.get(a_id=1)
    assert my_a is not None
    print "#1) Number of MyModelAs: %s\n" % MyModelA.query.count()
    db.session.delete(my_a)
    db.session.commit()
except IntegrityError:
    print "#2) Cannot delete instance …

SQLAlchemy的官方教程提供了使用会话系统的示例，例如：

>>> from sqlalchemy.orm import sessionmaker
>>> Session = sessionmaker(bind=engine)

许多非官方的教程也利用了会话，但是有些根本不使用会话，而是选择了一种称为这种方法的东西：

e = create_engine('sqlite:///company.db')
conn = e.connect()
query = conn.execute("SELECT first_name FROM employee")

当这个简单得多的系统似乎做同样的事情时，为什么根本需要会话？据我所知，官方文档并未阐明为什么这样做是必要的。

SQLAlchemy官方文档中有一个特别相关的部分：

Web应用程序是最简单的情况，因为这样的应用程序已经围绕一个一致的范围进行了构建-这是请求，它表示来自浏览器的传入请求，处理该请求以制定响应，最后交付回复给客户。因此，将Web应用程序与Session集成是将Session的范围与请求的范围链接起来的直接任务。可以在请求开始时建立会话，也可以使用惰性初始化模式来建立会话，该模式会在需要时立即建立会话。然后，请求继续进行，并使用适当的系统，其中应用程序逻辑可以按照与访问实际请求对象的方式相关的方式访问当前会话。随着请求的结束，会话也被拆除，通常通过使用Web框架提供的事件挂钩来实现。Session所使用的事务也可以在此时提交，或者应用程序可以选择显式的提交模式，仅针对那些有保证的请求进行提交，但始终始终无条件地终止Session。

...和...

一些Web框架包括一些基础结构，以帮助完成使Session的寿命与Web请求的寿命保持一致的任务。这包括与Flask Web框架结合使用的产品，例如Flask-SQLAlchemy和通常与Pyramid框架一起使用的Zope-SQLAlchemy。SQLAlchemy建议使用这些产品。

不幸的是，我仍然无法确定我是否需要使用会话，或者最后一段是否暗示着某些实现（例如Flask-SQLAlchemy）已经在自动管理会话。

我需要使用会议吗？不使用会话是否存在重大风险？因为使用Flask-SQLAlchemy，我已经在使用会话了吗？