标签: flask-sqlalchemy

我遇到了与模型本身配置多对多关系的问题.当我使用普通关系配置(即不使用Association对象)时,我可以配置自多对多关系.

在这种情况下,我必须在多对多表中记录一些额外的信息,所以我试图使用Association对象(PageLink)实现关系.

这是模型.

class PageLink(Base):
    '''
    Association table.
    '''
    __tablename__ = 'page_links'

    id = Column(Integer,primary_key=True)
    page_from = Column(Integer,ForeignKey('page.id'),primary_key=True)
    page_to = Column(Integer,ForeignKey('page.id'),primary_key=True)
    extra_col1 = Column(String(256),nullable=False)

class Page(Base):
    '''
    main table
    '''

    __tablename__ = 'page'

    id = Column(Integer,primary_key=True)
    name = Column(String(56),nullable=False)

    linked = relationship('PageLinks',backref='parent_page',
                          primaryjoin=id==PageLink.page_from,
                          secondaryjoin=id==PageLink.page_to)

这种方法不起作用.我试过删除'secondaryjoin'关键字,但它不起作用.

非常感谢有关此事的任何帮助或建议.

谢谢你的阅读.

我的主要目标是使实施修订历史记录和日记更加容易。

我发现自己想知道是否有可能使用Flask-SQLAlchemy（或直接使用SQL）为mysql获取一个自动递增的非唯一整数。 我发现了这个堆栈溢出帖子，该帖子与我想做什么很接近，但问题集中在主键上。例如，如果我的表有这些列，

revision_id = db.Column(db.Integer, nullable=False)
post_id = db.Column(db.Integer, nullable=False)

__table_args__ = (
    PrimaryKeyConstraint('post_id', 'revision_id'),
)

是否可以创建一个修订版本ID为1且post_id为max（post_id）+ 1的新帖子，而不会出现两个用户尝试同时创建一个帖子并创建相同的post_id的问题？

该系统的优势在于，它使发布历史记录（和差异记录）非常简单。每当有人想要修改帖子时，我都将使用与原始帖子相同的post_id并增加version_id（现在我将其键入，但存在相同的问题）。

更新：

西尔万·勒鲁（Sylvain Leroux）使我走上了正确的道路，以解决我的问题。我需要将两个表都设置为sqlalchemy中的主键。如果sqlalchemy中有一个以上的主键，则不会假定它们是唯一的。这是我目前的定义，

revision_id = db.Column(db.Integer, primary_key=True, nullable=False, autoincrement=False, default=1)
post_id = db.Column(db.Integer, primary_key=True, nullable=False, autoincrement=True)
__table_args__ = (
    PrimaryKeyConstraint('post_id', 'revision_id'),
)

哪个产生这个SQL

CREATE TABLE `post` (
    revision_id INTEGER NOT NULL, 
    post_id INTEGER NOT NULL AUTO_INCREMENT, 
    PRIMARY KEY (post_id, revision_id), 
)

这让我可以插入有无post_id的内容。

所有人都归功于Sylvain Leroux，因为我只是将他的答案翻译成了SQLAlchemy。

我有一个烧瓶应用程序分布在带有蓝图的模块上.每个模块/蓝图都有自己的models.py文件,其中定义了模型.

随着我的桌面应用程序,直接使用SQLAlchemy的API,我将继承object定义Base了一些列的类(如:id,date_created...),然后将作为我的声明的基础(例如:Base = declarative_base(cls=Base)).

• 我如何子类化flask-SQLALchemy,db.Model以便我可以将它用作默认列的Base,我希望所有表都有？

我试图使用flask-sqlalchemy(烧瓶版本0.10,flask-sqlalch版本1.0,python 3.3.3)来反映我的数据库中的表并遇到错误.当我使用代码时:

from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+mysqlconnector://**appropriate connection string here **'
db = SQLAlchemy(app)

db.reflect(app = app)

得到以下错误:

file "testmodel.py", line 9, in (module)
db.reflect(app = app)
File "~pathToSqlAlch\flask_sqlalchemy\__init__.py", line 872, in reflect
self.execute_for_all_tables(app, bind, 'reflect')
File "~pathToSqlAlch\flask_sqlalchemy\__init__.py", line 848, in _execute_for_all_tables
op(bind=self.get_engine(app,bind), tables=tables)
reflect() got an unexpected keyword argument 'tables'

任何想法可能导致这个或我可能做错了什么？

在我的Python（Flask）代码中，我需要从SQLAlchemy查询中获取按给定变量排序的第一个元素和最后一个元素。

我首先编写了以下代码：

first_valuation = Valuation.query.filter_by(..).order_by(sqlalchemy.desc(Valuation.date)).first()
# Do some things
last_valuation = Valuation.query.filter_by(..).order_by(sqlalchemy.asc(Valuation.date)).first()
# Do other things

由于这些查询对于PostgreSQL数据库可能很繁重，并且在我复制代码时，我认为只使用一个请求会更好，但是我不知道SQLAlchemy足以做到这一点...（当查询有效时）触发，例如？）

解决此问题的最佳方法是什么？

我正在使用pyCharm，并且一直在尝试安装sqlalchemy软件包以帮助我连接到我的mysql数据库。我跑了

pip install flask-sqlalchemy 

下载一堆文件后，它成功完成了，但是当我这样做时，该库仍然不可用：

from flask.ext.sqlalchemy import SQLAlchemy

我对python和所有这些东西还很陌生，我不知道该怎么做。安装flask很容易，因为pyCharm帮了我大忙，有什么办法可以做类似的事情吗？

编辑：通过打开pyCharm的首选项，然后转到Project Interpreter，它显示了所有已安装的模块，从而设法做到了这一点。然后只需单击底部的+按钮，然后搜索所需的模块即可。PyCharm从那时起为我做了一切。

我有一个基于miguel flask教程的Web应用程序

所以我使用sqlalchemy-migrate作为数据库,现在我应该在迁移中使用Alembic如何进行配置？有什么办法我可以从sqlalchemy-migrate更改为Flask-Migrate吗？(因为我的应用程序已经完成并且再次执行它是如此多的工作)Thanx

db_migrate.py:

#!flask/bin/python
import imp
from migrate.versioning import api
from app import db
from config import SQLALCHEMY_DATABASE_URI
from config import SQLALCHEMY_MIGRATE_REPO
migration = SQLALCHEMY_MIGRATE_REPO + '/versions/%03d_migration.py' % (api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) + 1)
tmp_module = imp.new_module('old_model')
old_model = api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
exec old_model in tmp_module.__dict__
script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, tmp_module.meta, db.metadata)
open(migration, "wt").write(script)
api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
print 'New migration saved as ' + migration
print 'Current database version: ' + str(api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO))

我怎样才能Planes与Bookings指定的两个日期之间.Bookings如果它们在2个日期之间,我需要将其过滤到仅包括在内.我试过这个,但得到错误:'Plane.bookings' does not support object population - eager loading cannot be applied.

为什么会出现此错误以及如何解决？

planes = (db.session.query(Plane)
             .join(Booking)
             .filter(Booking.start_date >= date)
             .options(contains_eager(Plane.bookings)))

型号:

class Booking(db.Model):
        id = db.Column(db.Integer, primary_key=True)
        start_date = db.Column(db.DateTime)
        end_date = db.Column(db.DateTime)

        person_id = db.Column(db.Integer, db.ForeignKey('person.id'))
        person = db.relationship('Person', foreign_keys=[person_id], backref=db.backref('bookings', lazy='dynamic'))

        instructor_id = db.Column(db.Integer, db.ForeignKey('person.id'))
        instructor = db.relationship('Person', foreign_keys=[instructor_id], backref=db.backref('instructor_bookings', lazy='dynamic'))

        plane_id = db.Column(db.Integer, db.ForeignKey('plane.id'))
        plane = db.relationship('Plane', backref=db.backref('bookings', lazy='dynamic'))

        def __init__(self, start_date, end_date, plane_id, instructor_id, person_id):
            self.start_date = start_date …

我的SQL技能非常缺乏,所以我无法弄清楚如何形成我需要的查询.

我有两个具有一对多关系的db模型,定义如下:

class Parent(db.Model):
  __tablename__ = 'parent'

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

  children = db.relationship('Child', 
                             backref = 'parent', 
                             lazy = 'joined')

class Child(db.Model):
  __tablename__ = 'child'

  id = db.Column(db.Integer, primary_key = True)
  parent_id = db.Column(db.Integer, db.ForeignKey('parent.id'))

  value = db.Column(db.String(140))

我希望能够形成一个查询,返回满足三个条件的所有父母:

1:有一个或多个孩子,其值包含'value1'

2:有一个或多个孩子,其值包含'value2'

3:没有孩子,其值包含'value3'或'value4'

对于此示例数据:

Parents:
id |
1  |
2  |
3  |
4  |

Children:
id | parent_id | value
1  | 1         | 'value1'
2  | 1         | 'value2'
3  | 1         | 'value3'
4  | 1 …

我想在flask-SQLAlchemy中执行以下子查询,但不知道如何:

SELECT * 
FROM (
     SELECT * 
     FROM  `articles` 
     WHERE publisher_id = "bild"
     ORDER BY date_time DESC 
     LIMIT 10
) AS t
ORDER BY RAND( ) 
LIMIT 2

我知道我可以将查询构建为:

subq = Article.query.filter(Article.publisher_id =='bild').order_by(Article.date_time.desc()).limit(10).subquery()
qry = subq.select().order_by(func.rand()).limit(2)

但是我不知道如何以与我执行相同的方式执行它,例如

articles = Article.query.filter(Article.publisher_id =='bild').all()

即获取所有Article对象.我能做的就是打电话

db.session.execute(qry).fetchall()

但这只给了我一个包含实际行值的列表,而不是我可以在其上调用另一个函数的对象(如article.to_json()).

有任何想法吗？qry是一个sqlalchemy.sql.selectable.Select对象,db.session.execute(qry)一个sqlalchemy.engine.result.ResultProxy同时Article.query,关于这一点我可以打电话all(),是一个flask_sqlalchemy.BaseQuery.谢谢!!