小编Ilj*_*ilä的帖子

我如何在SQLAlchemy中编写以下SQL查询,涉及按位和？

select * from table where flags & 1 = 1;

table表名在哪里,并且是该表flags中的列名.

我在从PostTag包含Post和Tag列的表中删除记录时遇到问题.这是我的关系表:

tags = db.Table('PostTag',
    db.Column('Tag', db.Integer, db.ForeignKey('Tag.Id')),
    db.Column('Post', db.Integer, db.ForeignKey('Post.Id'))
)

和

tags = db.relationship(Tag, secondary=tags, backref=db.backref('Post', lazy='dynamic'))

当我这样做:

from models.Post import Post

posts = Post.query.join(Post.tags).filter(Post.Id == id).all()
if(posts):
   return posts
return False

然后

for posttag in post[0].tags:
    db.session.delete(posttag)
    db.session.flush()

删除多对多关系的行,但也删除Tag表中的记录.

我只需要从PostTag表中删除某些条件的记录(Post=1例如)

我搜索了互联网,但我没有找到任何结论.我不需要在多对多关系上级联.

这是sql日志:

 297 Query  DELETE FROM `PostTag` WHERE `PostTag`.`Tag` = 14 AND `PostTag`.`Post` = 3
 297 Query  DELETE FROM `PostTag` WHERE `PostTag`.`Tag` = 14 AND `PostTag`.`Post` …

我正在尝试使用SSL连接与SQLAlchemy连接到Amazon Aurora,将IAM角色指定为数据库用户帐户并将身份验证令牌指定为密码,如[AWS docs]中所述(http://docs.aws.amazon) .com/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.html#UsingWithRDS.IAMDBAuth.Connecting)

这些是我遵循的步骤.

wget https://s3.amazonaws.com/rds-downloads/rds-combined-ca-bundle.pem

export LIBMYSQL_ENABLE_CLEARTEXT_PLUGIN=1

aws rds generate-db-auth-token --hostname 'datadbcluster-1.cluster-xxxxxxxxxxxx.us-west-2.rds.amazonaws.com' --port 3306 --username dt_analyst --region us-west-2 > /home/ubuntu/dt_analyst.pem

mysql -h datadbinstance2nd. xxxxxxxxxxxx.us-west-2.rds.amazonaws.com--ssl-ca /home/ubuntu/rds-combined-ca-bundle.pem -u dt_analyst --ssl-verify-server-cert --enable-cleartext-plugin -p'<token>'

我确认我可以使用mysql客户端通过SSL连接.

但我想使用sqlalchemy而不是mysql客户端进行连接.以下代码是根据Internet上的十几条建议编译的,但只会产生以下错误.

'sqlalchemy.exc.OperationalError:(_ mysql_exceptions.OperationalError)(1045,"用户拒绝访问...")'

我的代码如下.

import boto3

client = boto3.client('rds', region_name='us-west-2')

dialect='mysql'
user = ‘dt_analyst’
host = 'datadbcluster-1.cluster-xxxxxxxxxxxx.us-west-2.rds.amazonaws.com'
port = 3306
data = ‘datadb’
region='us-west-2'

token = client.generate_db_auth_token(host,port,user,region)
host1 = 'datadbinstance2nd. xxxxxxxxxxxx.us-west-2.rds.amazonaws.com'
conn_str = '%s://%s:%s@%s:%d/%s'%(dialect,user,token,host1,port,data)
conn_str += '?ssl_key=%s'%token
conn_str += '&ssl_cert=’/home/ubuntu/rds-combined-ca-bundle.pem'

ssl_args = {
    'ssl': { …

SQLAlchemy 文档解释了如何创建分区表。但它没有解释如何创建分区。

所以如果我有这个：

#Skipping create_engine and metadata
Base = declarative_base()

class Measure(Base):
    __tablename__ = 'measures'
    __table_args__ = {
        postgresql_partition_by: 'RANGE (log_date)'
    }
    city_id = Column(Integer, not_null=True)
    log_date = Columne(Date, not_null=True)
    peaktemp = Column(Integer)
    unitsales = Column(Integer)

class Measure2020(Base):
    """How am I suppposed to declare this ? """

我知道我会做的大部分事情SELECT * FROM measures WHERE logdate between XX and YY。但这似乎很有趣。

我有一个表用户和一个表朋友将用户映射到其他用户,因为每个用户可以有很多朋友.这种关系显然是对称的:如果用户A是用户B的朋友,那么用户B也是用户A的朋友,我只存储一次这种关系.除了两个用户ID之外,Friends表还有其他字段,因此我必须使用关联对象.

我试图在Users类中声明这种关系(扩展声明基础),但我似乎无法弄清楚如何做到这一点.我希望能够通过房产朋友访问给定用户的所有朋友,所以说朋友= bob.friends.

这个问题的最佳方法是什么？我试着在这里发布许多不同的设置,但是由于各种原因它们都没有工作.

编辑:我的最新尝试看起来像这样:

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)

    # Relationships
    friends1 = relationship('Friends', primaryjoin=lambda: id==Friends.friend1ID)
    friends2 = relationship('Friends', primaryjoin=lambda: id==Friends.friend2ID)


class Friends(Base):
    __tablename__ = 'friends'
    id = Column(Integer, primary_key=True)
    friend1ID = Column(Integer, ForeignKey('users.id') )
    friend2ID = Column(Integer, ForeignKey('users.id') )
    status = Column(Integer)

    # Relationships
    vriend1 = relationship('Student', primaryjoin=student2ID==Student.id)
    vriend2 = relationship('Student', primaryjoin=student1ID==Student.id)

但是会导致以下错误:

InvalidRequestError: Table 'users' is already defined for this MetaData instance.  Specify 'extend_existing=True' to redefine options and columns on an existing Table …

我的ORM中定义了两个表:

Base = declarative_base()

class GeneralLedger(Base):
  __tablename__ = 'generalledgers'
  id = Column(Integer, primary_key=True)
  invoiceId = Column(Integer)
  ..

class ConsolidatedLedger(Base):
  __tablename__ = 'consolidatedledgers'
  id = Column(Integer, primary_key = True)
  invoiceId = Column(Integer)

..

我没有在两个表之间设置任何关系.我按以下方式加入:

records = DBSession.query(GeneralLedger).join(ConsolidatedLedger, GeneralLedger.invoiceId == ConsolidatedLedger.invoiceId).all()

我也尝试过:

records = DBSession.query(GeneralLedger).filter(GeneralLedger.invoiceId == ConsolidatedLedger.invoiceId).all()

在这两种情况下,当我在视图中显示结果时,只显示GeneralLedger表中的条目.如何从同一结果集中的两个表中获取结果？我试过这个:

records = DBSession.query(GeneralLedger, ConsolidatedLedger).join(ConsolidatedLedger, GeneralLedger.invoiceId == ConsolidatedLedger.invoiceId).all()

但是,出于某种原因,当我在模板(Jinja2)中迭代结果时,列的值对于每一行都是空的.此外,当计数:

total = DBSession.query(GeneralLedger).join(ConsolidatedLedger, GeneralLedger.invoiceId == ConsolidatedLedger.invoiceId).count()

总行数是两个表中匹配记录的总和.我正在使用webhelpers.paginate来处理分页:

query = DBSession.query(GeneralLedger).join(ConsolidatedLedger, GeneralLedger.invoiceId == ConsolidatedLedger.invoiceId)
records = paginate.Page(query, current_page, url=page_url)

并且发送到模板的结果集就好像除了ConslidatedLedger表上的结果之外的所有结果都被删除了.例如,我的页面总数设置为20条记录.如果该页面上存在来自ConslidatedLedger的记录,则页面将被截断,仅显示来自GeneralLedger的记录,但分页不会中断.

有什么想法吗？谢谢!

嗨,我想使用joinload对我的查询进行过滤.但我似乎无法使其发挥作用.以下是我的示例查询

result = (
        session.query(Work).
        options(
            joinedload(Work.company_users).
            joinedload(CompanyUser.user)
        ).
        filter(Work.id == 1).
        filter(User.first_name == 'The name').  <<--- I can't get this to work.
        all()
    )

当运行它时,它返回的行超出了我的预期.真正的结果应该只返回8rows.但是在执行此查询时,它会返回234行,这比我预期的要多

当我尝试访问该页面时发生此错误。创建表时没有出现错误，但似乎仍然存在问题。

模型是这样的：

class User(UserMixin, db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(64), index=True, unique=True)
    sell_items = db.relationship('Item', backref='user')

class Item(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    item_name = db.Column(db.String(64), index=True)
    item_image = db.Column(db.String(200), index=True)
    price = db.Column(db.Float(10), index=True)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
    user = db.relationship('User', backref='sell_items')

整个错误信息是这样的

Triggering mapper: 'Mapper|User|user'. Original exception was: Error creating backref 'user' on relationship 'User.sell_items': property of that name exists on mapper 'Mapper|Item|item'

我怎样才能解决这个问题？我想做的是参考username谁卖这个项目，但我不能。模型之间的关系存在问题。

我有一个类Node,其自我引用映射'children'(backref'parent')表示SQLAlchemy中的树,我想选择整个树.如果我做

session.query(Node).all()

然后每次访问node.children都会触发一个select.如果我加入了加载

session.query(Node).options(joinedload_all('children')).all()

然后发出的sql有一个不必要的表连接,因为我想要整个树(所有节点).有没有办法在SA中执行此操作,还是应该在SA外部自己构建树？

我需要一些帮助来用 SQLAlchemy 语言表达我的代码，如下所示：

SELECT
    s.agent_id,
    s.property_id,
    p.address_zip,
    (
        SELECT v.valuation
        FROM property_valuations v WHERE v.zip_code = p.address_zip
        ORDER BY ABS(DATEDIFF(v.as_of, s.date_sold))
        LIMIT 1
    ) AS back_valuation,
FROM sales s
JOIN properties p ON s.property_id = p.id

内部子查询旨在从表中获取属性值，propert_valuations其中列 ( zip_code INT, valuation DECIMAL, as_if DATE) 最接近表中的销售日期sales。我知道如何重写它，但我完全停留在order_by表达式上 - 我无法准备子查询以稍后传递排序成员。

目前我有以下疑问：

subquery = (
    session.query(PropertyValuation)
    .filter(PropertyValuation.zip_code == Property.address_zip)
    .order_by(func.abs(func.datediff(PropertyValuation.as_of, Sale.date_sold)))
    .limit(1)
)

query = session.query(Sale).join(Sale.property_)

如何将这些查询组合在一起？