在SQLAlchemy中映射大量类似的表

Question

我有很多(~2000)个时间序列数据的位置.每个时间序列都有数百万行.我想将它们存储在Postgres数据库中.我目前的方法是为每个位置时间序列设置一个表,以及一个存储有关每个位置(坐标,高程等)的信息的元表.我正在使用Python/SQLAlchemy来创建和填充表.我想在元表和每个时间序列表之间建立关系来执行查询,例如"选择在日期A和日期B之间具有数据的所有位置"和"选择日期A的所有数据并导出带坐标的csv".创建具有相同结构的许多表(仅名称不同)并与元表建立关系的最佳方法是什么？或者我应该使用不同的数据库设计？

目前我正在使用这种方法来生成许多类似的映射:

from sqlalchemy import create_engine, MetaData
from sqlalchemy.types import Float, String, DateTime, Integer
from sqlalchemy import Column, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, relationship, backref

Base = declarative_base()


def make_timeseries(name):
    class TimeSeries(Base):

        __tablename__ = name
        table_name = Column(String(50), ForeignKey('locations.table_name'))
        datetime = Column(DateTime, primary_key=True)
        value = Column(Float)

        location = relationship('Location', backref=backref('timeseries',
                                lazy='dynamic'))

        def __init__(self, table_name, datetime, value):
            self.table_name = table_name
            self.datetime = datetime
            self.value = value

        def __repr__(self):
            return "{}: {}".format(self.datetime, self.value)

    return TimeSeries


class Location(Base):

    __tablename__ = 'locations'
    id = Column(Integer, primary_key=True)
    table_name = Column(String(50), unique=True)
    lon = Column(Float)
    lat = Column(Float)

if __name__ == '__main__':
    connection_string = 'postgresql://user:pw@localhost/location_test'
    engine = create_engine(connection_string)
    metadata = MetaData(bind=engine)
    Session = sessionmaker(bind=engine)
    session = Session()

    TS1 = make_timeseries('ts1')
    # TS2 = make_timeseries('ts2')   # this breaks because of the foreign key
    Base.metadata.create_all(engine)
    session.add(TS1("ts1", "2001-01-01", 999))
    session.add(TS1("ts1", "2001-01-02", -555))

    qs = session.query(Location).first()
    print qs.timeseries.all()

这种方法存在一些问题,最值得注意的是,如果我创建多个TimeSeries外键不起作用.以前我已经使用了一些工作,但这似乎是一个大黑客,我觉得必须有一个更好的方法来做到这一点.我应该如何组织和访问我的数据？

Answer 1

Alternative-1: Table Partitioning

Partitioning一旦我读到完全相同的表结构,我立即浮现在脑海中.我不是DBA,并且没有太多使用它的生产经验(甚至更多关于PostgreSQL),但请阅读PostgreSQL - Partitioning文档.表分区旨在解决您所遇到的问题,但超过1K的表/分区听起来很有挑战性; 因此,请在论坛/ SO上进行更多关于此主题的可扩展性相关问题的研究.

鉴于您最常用的搜索标准,datetime组件非常重要,因此必须有坚实的索引策略.如果您决定使用partitioningroot,那么明显的分区策略将基于日期范围.与最新数据相比,这可能允许您将不同块中的旧数据分区,特别是假设旧数据(几乎从未)更新,因此物理布局将是密集且高效的; 而你可以采用另一种策略来获取更多"近期"数据.

Alternative-2: trick SQLAlchemy

这基本上使您的示例代码通过欺骗SA来假设所有这些TimeSeries都是children一个实体使用Concrete Table Inheritance.下面的代码是自包含的,并创建50个表,其中包含最少的数据.但是如果你已经拥有一个数据库,它应该允许你很快地检查性能,这样你就可以做出决定,即使它是一个非常接近的可能性.

from datetime import date, datetime

from sqlalchemy import create_engine, Column, String, Integer, DateTime, Float, ForeignKey, func
from sqlalchemy.orm import sessionmaker, relationship, configure_mappers, joinedload
from sqlalchemy.ext.declarative import declarative_base, declared_attr
from sqlalchemy.ext.declarative import AbstractConcreteBase, ConcreteBase


engine = create_engine('sqlite:///:memory:', echo=True)
Session = sessionmaker(bind=engine)
session = Session()
Base = declarative_base(engine)


# MODEL
class Location(Base):
    __tablename__ = 'locations'
    id = Column(Integer, primary_key=True)
    table_name = Column(String(50), unique=True)
    lon = Column(Float)
    lat = Column(Float)


class TSBase(AbstractConcreteBase, Base):
    @declared_attr
    def table_name(cls):
        return Column(String(50), ForeignKey('locations.table_name'))


def make_timeseries(name):
    class TimeSeries(TSBase):
        __tablename__ = name
        __mapper_args__ = { 'polymorphic_identity': name, 'concrete':True}

        datetime = Column(DateTime, primary_key=True)
        value = Column(Float)

        def __init__(self, datetime, value, table_name=name ):
            self.table_name = table_name
            self.datetime = datetime
            self.value = value

    return TimeSeries


def _test_model():
    _NUM = 50
    # 0. generate classes for all tables
    TS_list = [make_timeseries('ts{}'.format(1+i)) for i in range(_NUM)]
    TS1, TS2, TS3 = TS_list[:3] # just to have some named ones
    Base.metadata.create_all()
    print('-'*80)

    # 1. configure mappers
    configure_mappers()

    # 2. define relationship
    Location.timeseries = relationship(TSBase, lazy="dynamic")
    print('-'*80)

    # 3. add some test data
    session.add_all([Location(table_name='ts{}'.format(1+i), lat=5+i, lon=1+i*2)
        for i in range(_NUM)])
    session.commit()
    print('-'*80)

    session.add(TS1(datetime(2001,1,1,3), 999))
    session.add(TS1(datetime(2001,1,2,2), 1))
    session.add(TS2(datetime(2001,1,2,8), 33))
    session.add(TS2(datetime(2002,1,2,18,50), -555))
    session.add(TS3(datetime(2005,1,3,3,33), 8))
    session.commit()


    # Query-1: get all timeseries of one Location
    #qs = session.query(Location).first()
    qs = session.query(Location).filter(Location.table_name == "ts1").first()
    print(qs)
    print(qs.timeseries.all())
    assert 2 == len(qs.timeseries.all())
    print('-'*80)


    # Query-2: select all location with data between date-A and date-B
    dateA, dateB = date(2001,1,1), date(2003,12,31)
    qs = (session.query(Location)
            .join(TSBase, Location.timeseries)
            .filter(TSBase.datetime >= dateA)
            .filter(TSBase.datetime <= dateB)
            ).all()
    print(qs)
    assert 2 == len(qs)
    print('-'*80)


    # Query-3: select all data (including coordinates) for date A
    dateA = date(2001,1,1)
    qs = (session.query(Location.lat, Location.lon, TSBase.datetime, TSBase.value)
            .join(TSBase, Location.timeseries)
            .filter(func.date(TSBase.datetime) == dateA)
            ).all()
    print(qs)
    # @note: qs is list of tuples; easy export to CSV
    assert 1 == len(qs)
    print('-'*80)


if __name__ == '__main__':
    _test_model()

Alternative-3: a-la BigData

如果您确实遇到使用数据库的性能问题,我可能会尝试:

• 仍然像现在一样将数据保存在单独的表/数据库/模式中
• 使用数据库引擎提供的"本机"解决方案批量导入数据
• MapReduce类似于使用的分析.
  • 在这里,我将继续使用python和sqlalchemy,并实现自己的分布式查询和聚合(或找到现有的东西).显然,这只有在您不需要直接在数据库上生成这些结果时才有效.

编辑1: Alternative-4: TimeSeries databases

我没有使用大规模的经验,但绝对值得考虑的选择.

如果您以后可以分享您的调查结果和整个决策过程,那将是非常棒的.

Answer 2

我会避免你上面提到的数据库设计。我对您正在使用的数据了解不够，但听起来您应该有两个表。一张表用于存储位置，一个子表用于存储位置_数据。位置表将存储您上面提到的数据，例如坐标和海拔。location_data 表将存储位置表中的 location_id 以及要跟踪的时间序列数据。

这将消除每次添加另一个位置时更改数据库结构和代码更改的情况，并且允许您正在查看的查询类型。