标签: flask-sqlalchemy

我在思考如何处理 Flask 请求中过期的 sqlalchemy 对象时遇到了麻烦。假设我执行以下操作：

from models import Foo, Bar

@app.route("/page")
def page():
  foos = Foo.query.all()

  for foo in foos:
    b = Bar(foo.data)
    db.session.add(b)

  db.session.commit()

  return render_template('page.html', foos=foos)

然后在page.html：

{% for foo in foos %}
  {{ foo. name }}
{% endfor %}

然后 SQLAlchemy 将对模板循环中的每个 foo 执行选择查询，因为session.commit()将foos集合标记为已过期。如果我知道无法foos实际更改，那么防止len(foos)执行查询的正确方法是什么？同样，如果foos 已更改，使用单个查询而不是多个查询刷新数据的正确方法是什么？

您好，我有一些外键问题。

我有这样的事情：

class Foo(db.Model):
    """The foo object."""
    __tablename__ = 'foos_foo'
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.Text, unique=True)
    content = db.Column(db.Text)
    bar = db.relationship('Bar', backref='bars_bar')
    bar_id = db.Column(db.Integer, db.ForeignKey('bars_bar.id'))


class Bar(db.Model):
    """The bar object."""
    __tablename__ = 'bars_bar'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.Text, unique=True)
    description = db.Column(db.Text)
    status = db.Column(db.SmallInteger, default=NEW)

我使用这种配置风格：https : //github.com/mitsuhiko/flask/wiki/Large-app-how-to

所以我有这样的事情：

from app.foos.views import mod as foosModule
from app.bars.views import mod as barsModule

app.register_blueprint(foosModule)
app.register_blueprint(barsModule)

If I call like in the config style from …

尝试将代码更新为 https://github.com/thrisp/flask-security从python 2.7到3.3时出现错误

给出以下最基本的实例

test.py：

from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.security import Security, UserMixin, RoleMixin, \
     SQLAlchemyUserDatastore

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'

db = SQLAlchemy(app)
db.drop_all()

roles_users = db.Table('roles_users',
        db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
        db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))

class Role(db.Model, RoleMixin):
        id = db.Column(db.Integer(), primary_key=True)
        name = db.Column(db.String(80), unique=True)
        description = db.Column(db.String(255))

class User(db.Model, UserMixin):
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(255), unique=True)
    password = db.Column(db.String(255))
    last_login_at = db.Column(db.DateTime())
    current_login_at = db.Column(db.DateTime())
    last_login_ip = db.Column(db.String(100))
    current_login_ip = …

我正在使用flask-sqlalchemy,我的问题是在子句中的位置:

select * from table_1 where id in (1,2,3,5)
OR
select * from table_1 where field_1_id in (select id from table_2 where .... )

和get_or_create一样,peewee orm

Object.get_or_create(.......)

我怎么能用flask-sqlalchemy生成这个句子？

我有这个 Meter 对象模型

class Meter(db.Model):
    """
    Model for repair meter.

    """
    __tablename__ = 'meters'

    id = db.Column(db.Integer, primary_key=True, nullable=False)
    meter_no = db.Column(db.String(50), unique=True, nullable=False)
    client = db.Column(db.String(50), unique=True, nullable=False)
    problems = db.Column(db.PickleType)
    functional = db.Column(db.Boolean(), default=False, server_default="false")
    location = db.Column(db.Integer, db.ForeignKey('locations.id'))
    date_in = db.Column(db.Date, default=dt.date.today())
    date_out = db.Column(db.Date)

问题 PickleType 列存储一个 Python 列表，其中包含问题对象的 id

然后我有这个函数尝试查询仪表数据库表并仅获取列表存储中具有特定问题 id (prob_id) 的 Meter 对象作为 PickleType。

def problemrate(prob_id, month):
    """
    Return meters with the problem id for a particular month.

    args:
        prob_id (int): problem id …

我想从多个表中获取数据，所以我用 sqlalchemy 做到了这一点：

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


a = db.aliased(Employee, name='Employee')
b = db.aliased(Person, name='Person')
c = db.aliased(PositionFulfillment, name='PositionFulfillment')
d = db.aliased(Position, name='Position')
e = db.aliased(PositionType, name='PositionType')
f = db.aliased(Party, name='Party')

data = db.session.query(a, b, e, f) \
    .join(b, a.entity_id == b.entity_id) \
    .join(c, a.entity_id == c.party_id) \
    .join(d, c.position_id == d.id) \
    .join(e, d.position_type_id == e.id) \
    .join(f, d.party_id == f.id) \
    .all()

但是当我尝试使用这样的分页时：

page = request.args.get('page', 1, type=int)
count = request.args.get('count', 10, type=int)

a = …

我有一个 REST API 端点，我需要在其中解析以下格式的传入嵌套 JSON：

        site: {
            id: '37251',
            site_name: 'TestSite',
            address: {
                'address': '1234 Blaisdell Ave',
                'city': 'Minneapolis',
                'state': 'MN',
                'zip': '55456',
                'neighborhood': 'Kingfield',
                'county': 'Hennepin',
            },
            geolocation: {
                latitude :  '41.6544',
                longitude :  '73.3322',
                accuracy: '45'
            }
        }

进入以下 SQLAlchemy 类：

地点：

class Site(db.Model):
    __tablename__ = 'site'
    id = Column(Integer, primary_key=True, autoincrement=True)
    site_name  = Column(String(80))# does site have a formal name
    address_id = Column(Integer, ForeignKey('address.id'))
    address = relationship("Address", backref=backref("site", uselist=False))
    geoposition_id = Column(Integer, ForeignKey('geoposition.id'))
    geoposition = relationship("Geoposition", backref=backref("site", …

我正在使用 Flask-SQLAlchemy，但在 SQL 语法中的 IN 子句中遇到了一些问题。我希望我的 IN 子句“读取”的数据是一个包含一些数据的列表，例如

args = [1, 2, 3]

这是我的代码的样子。

connection = db.session.connection()
raw_sql = text("""
        SELECT
          *
        FROM 
         table
        WHERE data IN :list
        """)
query = connection.engine.execute(raw_sql, {'list' : args})

我试过给 args 参数插入元组和列表，但没有任何效果。我要么得到：

• Python 'tuple' 不能转换为 MySQL 类型 args = tuple([1, 2, 3])
• Python 'list' 无法转换为 MySQL 类型，使用时 args = [1, 2, 3]

您如何使用 SQLAlchemy 从列表中读取并使用 RAW SQL 和参数作为输入？

我有一些像这样的表:

class Genre(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(128), index=True)
    artist_id = db.Column(db.Integer, db.ForeignKey('artist.id'))

class Song(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(128), index=True)
    artist = db.relationship('Artist', uselist=False)
    artist_id = db.Column(db.Integer, db.ForeignKey('artist.id'))

class Artist(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(128), index=True)
    genres = db.relationship('Genre')
    songs = db.relationship('Song')

所以基本上,歌曲有一个艺术家.每位艺术家都可以拥有多种类型.

我试图通过任何艺术家获得所有歌曲,其中的类型列表包含一个特定名称的类型.我做了一些研究,我发现了一些非常接近的东西:

Song.query.filter(Artist.genres.any(Genre.name.in_([genre_name_im_looking_for])))

这将是一种工作,但并非适用于所有情况.例如,上述声明还将返回所有拥有流派'独立摇滚'的艺术家的歌曲.如何指定我不希望类型名称位于值列表中,而是指定为特定值？

Song.query.filter(Artist.genres.any(Genre.name='rock'))

也不可能,因为它是一个关键字表达式.

有任何想法吗？

我试图按照以下教程中的说明操作:

教程

我从以下repo下载了代码:

回购

但是当我在本地运行并尝试向数据库添加内容时,我收到以下错误:

builtins.KeyError
KeyError: 'SQLALCHEMY_TRACK_MODIFICATIONS'

当我尝试读取回溯时,我意识到即使我在配置文件中添加了一个变量SQLALCHEMY_TRACK_MODIFICATIONS,一些python库文件也无法识别它存在.

看起来有一个类似问题的另一个答案,但这更像是一个快速修复,而不是为什么会发生这种情况.

我想知道为什么会发生这种情况以及如何解决它.最好不要改变整个结构.

非常感谢提前.