标签: sqlalchemy

我正在使用 sqlalchemy-migrate 来更改 Postgre SQL 数据库中表中一列的类型。我正在使用的升级脚本是：

# -*- cofing: utf-8 -*-

from sqlalchemy import MetaData, Table, Column, String, Integer
from migrate import changeset


metadata = MetaData()


def upgrade(migrate_engine):
    # ALTER TABLE courses ALTER COLUMN number SET DATA TYPE character varying;
    metadata.bind = migrate_engine
    courses = Table('courses', metadata, Column("number", Integer), extend_existing=True)
    courses.c.number.alter(type=String)


def downgrade(migrate_engine):
    # ALTER TABLE courses ALTER COLUMN number SET DATA TYPE integer;
    metadata.bind = migrate_engine
    courses = Table('courses', metadata, Column("number", String), extend_existing=True)
    courses.c.number.alter(type=Integer, cast='numeric')

升级部分似乎工作，但降级总是失败并出现以下错误：

sqlalchemy.exc.ProgrammingError: (ProgrammingError) column …

我有一个 CustomType ，如何在创建自定义类型时检查 Column 是否设置为 nullabe=True ？

 import sqlalchemy.types as types

 class MyType(types.TypeDecorator):
     impl = types.Unicode

     def process_bind_param(self, value, dialect):
         return "PREFIX:" + value

     def process_result_value(self, value, dialect): 
         return value[7:]

这是一个定义的模型，将使用它：

class User(BaseModel):
     __tablename__ = 'user'

     mytype = Column(MyType(), nullable=True)

SQLAlchemy的支持Postgres的范围的类型，如所描述的在这里。它使用postgresql+psycopg2方言进行 Postgres 通信。这些测试用例给出了 SQLALchemy 中范围类型的使用示例。

如何过滤或排序 SQLAlchemy 中此类范围字段的一个组件（较低或较高）？

使用第一个链接中的示例

from psycopg2.extras import DateTimeRange
from sqlalchemy.dialects.postgresql import TSRANGE

class RoomBooking(Base):

  __tablename__ = 'room_booking'

  room = Column(Integer(), primary_key=True)
  during = Column(TSRANGE())

booking = RoomBooking(
  room=101,
  during=DateTimeRange(datetime(2013, 3, 23), None)
)

例如，我想过滤在给定日期时间开始的期间的预订，或者在日期时间开始之前对预订进行排序。

因此，我希望大致生成此 SQL：

SELECT room, during
FROM room_booking
WHERE lower(during) = foo
ORDER BY upper(during)

我试过像这样的结构

RoomBooking.query.filter(RoomBooking.during.lower == foo).order_by(RoomBooking.during.upper)

但要认识到这可能不起作用，因为 lower 是 python 对象上的一个属性，与基础表列无关。

一个可能的解决方案可能是找到一种使用upper()/lower()SQLAlchemy 范围函数的方法。

假设您想在 sqlalchemy 中迭代 ORM 类的 ORM 属性。因此，您需要一个 ORM 属性列表。你是怎么得到那个名单的？

如果 ORM 类没有重命名属性，因此 ORM 属性与数据库列匹配，那么您可以使用以下解决方案：https : //stackoverflow.com/a/24748320/1023033 （顺便说一句，还有一个内置的源代码文件 /lib/sqlalchemy/orm/base.py 中的（私有）函数 _orm_columns() 似乎提供了此功能）

但是如果 python ORM 类的名称与数据库列的名称不同（例如在这 3 个 ORM 属性中）：

>>> class User(Base):
...     __tablename__ = 'users'
...
...     id = Column('pkey', Integer, primary_key=True)
...     name = Column('user_name', String)
...     fullname = Column('human_name', String)

那么那个方法就行不通了。那么，如何获得 ORM 属性的 Python 版本呢？

当我将 SQLAlchemy 与 Oracle 结合使用时，我还必须为主键添加序列，但迁移不会自行创建序列。如何获得要创建的序列？

我曾多次尝试调整代码以使 SQLAlchemy 为主键创建 oracle 序列，但到目前为止，我还无法获得由 SQLAlchemy 创建的 Oracle 序列。到目前为止，我有一个非常简单的用户/角色设置，并且存在表，但不存在序列。它运行时没有显示任何错误。

Model 类如下所示：

class Role(SurrogatePK, Model):
    """A role for a user."""

    __tablename__ = 'roles'
    id = db.Column(db.Integer, db.Sequence(__tablename__ + '_id_seq'), primary_key=True)
    name = Column(db.String(80), unique=True, nullable=False)
    user_id = reference_col('users', nullable=True)
    user = relationship('User', backref='roles')

    def __init__(self, name, **kwargs):
        """Create instance."""
        db.Model.__init__(self, name=name, **kwargs)

我正在使用 Flask 和 SQLAlchemy，并且在我运行之后；

$ python manage.py db init
Creating directory <lots removed here>...done

$ $ python manage.py db migrate
INFO  [alembic.runtime.migration] Context impl …

使用属性和混合变压器对遍历以下树有一点帮助；

class Category(db.Model):
    __tablename__ = 'category'
    id = db.Column(db.Integer, primary_key=True)
    parent = db.Column(db.Integer, db.ForeignKey('category.id'), nullable=True)
    name = db.Column(db.String(400), index=True, unique=True)

    children = db.relationship("Category", cascade='all, delete-orphan', backref=db.backref("child", remote_side=[id]))
    parents = db.relationship("Category", cascade='all', backref=db.backref("back", remote_side=[id]))
    entries = db.relationship("Feeds", backref='entry', lazy='dynamic')


class Feeds(db.Model):
    __tablename__ = 'feeds'
    id = db.Column(db.Integer, primary_key=True)
    category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
    name = (db.String(400), index=True, unique=True)

    @property
     def parents(self):
         allparents=[]
         p = self.children
         while p:
             allparents.append(p)
             p = p.children
         return allparents

我有一个简单的对象

catlist = db.session.query(Category).filter_by(id=1).all()

1. 如何遍历所有树以获得具有可变树深度的子级，即祖先 -> 父级 -> 子级 …

我有这个代码:

def advertiser_table(engine):
    return Table('advertiser', metadata, autoload=True, autoload_with=engine)

后来我试试这个:

advertisers = advertiser_table(engine)
...
session.bulk_insert_mappings(
        advertisers.name,
        missing_advetisers.to_dict('records'),
    )

missing_adverisers熊猫在哪里DataFrame(但对于这个问题并不重要).

这给我的错误是:

sqlalchemy.orm.exc.UnmappedClassError: Class ''advertiser'' is not mapped

从阅读文档中我可以争先恐后地提出这个问题,但不仅仅是那个......这是什么Mapper以及为什么它对这个库的功能如此不利？为什么"类"没有映射？显然,我该怎样做才能将它"映射"到这个图书馆想要映射的内容？

我需要更新MSSQL数据库中的表。表的尺寸不允许将表加载到内存中，修改数据框并重新写回。

我还一次只需要更新一列，所以我不能使用本主题中提出的解决方案（即该解决方案提出了对感兴趣的行的删除操作，这对我来说是不可能的，因为我一次只能更新一列）

所以我需要执行类似更新的查询

Update mytable
set mycolumn = dfcolumn
from df
where mytable.key=df.key

其中mytable是dbtable，df是熊猫数据框。

可以使用SQLALCHEMY执行这种功能吗？

我有两个表(location和country)试图查询; 在我的烧瓶应用中由下面的模型表示

from sqlalchemy import Column, DateTime, ForeignKey, Integer, \
                       Numeric, SmallInteger, String, Table
from sqlalchemy.orm import relationship
from sqlalchemy.schema import FetchedValue
from flask_sqlalchemy import SQLAlchemy


db = SQLAlchemy()


class Country(db.Model):
    __tablename__ = 'country'

    country_id = db.Column(db.Integer, primary_key=True)
    country_name = db.Column(db.String(30), nullable=False)
    full_country_name = db.Column(db.String(90), nullable=False)
    country_code = db.Column(db.String(4), nullable=False)

    def __str__(self):
        return '%s' % self.country_name

    def __repr__(self):
        return '<Country %r>' % self.country_name


class Location(db.Model):
    __tablename__ = 'location'

    location_id = db.Column(db.Integer, primary_key=True)
    location_name = db.Column(db.String(75), nullable=False) …

我正在尝试用棉花糖反序列化深层结构。例如：

hour = {
    'day': {
        'name': 'monday'
    }
}
loaded_hour, error = HoursSerializationSchema().load(hour) # this works

new_practitioner_at_location = {
    'hours': [
        hour
    ]
}
loaded, error = PractitionerToServiceLocationSerializationSchema().load(new_practitioner_at_location) # this fails

当我尝试反序列化时，new_practitioner_at_location我得到以下信息（发生在序列化程序使用“ day”键时）：

AttributeError: 'dict' object has no attribute '_sa_instance_state'

请注意，当相同的数据结构（小时）未嵌套在时，相同的模式可以反序列化该数据结构new_practitioner_at_location。

显示问题的自包含脚本：

from sqlalchemy import Column, Integer, ForeignKey, String
from sqlalchemy.orm import relationship, backref
from sqlalchemy.ext.declarative import declarative_base
import os
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_marshmallow import Marshmallow
from flask_migrate import …