def _boolean_fixture(self, table_args=(), table_kwargs={}): m = MetaData() t = Table('tname', m, Column('id', Integer, primary_key=True), Column('flag', Boolean)) return ApplyBatchImpl(t, table_args, table_kwargs)
def sqla_metadata(self): # pylint: disable=no-member metadata = MetaData(bind=self.get_sqla_engine()) return metadata.reflect()
def _get_meta_data(engine): """search db objects like views or tables""" meta_data = MetaData(engine) meta_data.reflect(views=True) return meta_data
"drop_db", # util "test_db_connection", "get_contest_list", "is_contest_id", "ask_for_contest", "get_submissions", "get_submission_results", "get_datasets_to_judge", "enumerate_files" ] # Instantiate or import these objects. version = 39 engine = create_engine(config.database, echo=config.database_debug, pool_timeout=60, pool_recycle=120) metadata = MetaData(engine) from .session import Session, ScopedSession, SessionGen, \ custom_psycopg2_connection from .types import CastingArray, Codename, Filename, FilenameSchema, \ FilenameSchemaArray, Digest from .base import Base from .fsobject import FSObject, LargeObject from .contest import Contest, Announcement, Presentation from .user import User, Team, Participation, Message, Question from .admin import Admin from .task import Task, Statement, Attachment, Dataset, Manager, Testcase, \ TaskName, TaskTitle from .submission import Submission, File, Token, SubmissionResult, \ Executable, Evaluation
Table, Numeric) from sqlalchemy.dialects.postgresql import ARRAY from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import relationship import sqlahelper as sah from geoalchemy2 import types as geotypes # import WAM_APP_FRED.app_settings # from geoalchemy2.types import Geometry # from WAM_APP_FRED.cli.openFRED import mapped_classes, db_session # ##########################################SQLAlchemy setup######################################## SCHEMA_1 = 'climate' SCHEMA_2 = 'supply' engine = sah.get_engine('oep_engine') metadata_1 = MetaData(schema=SCHEMA_1, bind=engine) metadata_2 = MetaData(schema=SCHEMA_2, bind=engine) # ##########################################TABLE DEFINITION######################################## # included function from github: https://github.com/open-fred/cli/blob/master/openFRED.py # copied function to avoid dependencies def mapped_classes(metadata): """ Returns classes mapped to the openFRED database via SQLAlchemy. The classes are dynamically created and stored in a dictionary keyed by class names. The dictionary also contains the special entry `__Base__`, which an SQLAlchemy `declarative_base` instance used as the base class from which all mapped classes inherit. """
def test_nolength_string(self): metadata = MetaData() foo = Table('foo', metadata, Column('one', String)) foo.create(config.db) foo.drop(config.db)
# define metadata for table from sqlalchemy import MetaData from sqlalchemy import Table, Column from sqlalchemy import Integer, String metadata = MetaData( ) # metadata is collection of tables and can be traversed like XML DOM user_table = Table("user", metadata, Column("id", Integer, primary_key=True), Column("name", String)) # init engine over database from sqlalchemy import create_engine engine = create_engine("sqlite://", echo=True) # create table from metadata metadata.create_all(engine) # now load metadata for the table from database metadata2 = MetaData() user_table_reflected = Table("user", metadata2, autoload=True, autoload_with=engine) print("-- TABLE SCHEMA LOADED FROM DB ---------------------") print(repr(user_table_reflected))
def _fk_fixture(self, table_args=(), table_kwargs={}): m = MetaData() t = Table('tname', m, Column('id', Integer, primary_key=True), Column('email', String()), Column('user_id', Integer, ForeignKey('user.id'))) return ApplyBatchImpl(t, table_args, table_kwargs)
pool_timeout=1200, pool_reset_on_return='commit') return eng engine = get_engine() Base = declarative_base() Session = sessionmaker(bind=engine) db_session = Session() session_factory = sessionmaker(bind=engine) ScopedSession = scoped_session(session_factory) db_scoped_session = ScopedSession() metadata = MetaData(get_engine()) db_lock = threading.RLock() __all__ = [ 'engine', 'Base', 'db_session', 'metadata', 'db_lock', 'db_scoped_session', 'ScopedSession' ] # ss = ScopedSession() # ss2 = ScopedSession() # if ss is ss2: # print(1) # ScopedSession.remove() # # if ss is ss2: # print(1)
def _ix_fixture(self, table_args=(), table_kwargs={}): m = MetaData() t = Table('tname', m, Column('id', Integer, primary_key=True), Column('x', String()), Column('y', Integer), Index('ix1', 'y')) return ApplyBatchImpl(t, table_args, table_kwargs)
def _sql_ck_fixture(self, table_args=(), table_kwargs={}): m = MetaData() t = Table('tname', m, Column('id', Integer, primary_key=True), Column('email', String())) t.append_constraint(CheckConstraint(t.c.email.like('%@%'))) return ApplyBatchImpl(t, table_args, table_kwargs)
def _uq_fixture(self, table_args=(), table_kwargs={}): m = MetaData() t = Table('tname', m, Column('id', Integer, primary_key=True), Column('x', String()), Column('y', Integer), UniqueConstraint('y', name='uq1')) return ApplyBatchImpl(t, table_args, table_kwargs)
def _enum_fixture(self, table_args=(), table_kwargs={}): m = MetaData() t = Table('tname', m, Column('id', Integer, primary_key=True), Column('thing', Enum('a', 'b', 'c'))) return ApplyBatchImpl(t, table_args, table_kwargs)
def _boolean_no_ck_fixture(self, table_args=(), table_kwargs={}): m = MetaData() t = Table('tname', m, Column('id', Integer, primary_key=True), Column('flag', Boolean(create_constraint=False))) return ApplyBatchImpl(t, table_args, table_kwargs)
def test_basic(self, metadata, connection): s_table = Table( "sometable", metadata, Column("id_a", Unicode(255), primary_key=True), Column("id_b", Unicode(255), primary_key=True, unique=True), Column("group", Unicode(255), primary_key=True), Column("col", Unicode(255)), UniqueConstraint("col", "group"), ) # "group" is a keyword, so lower case normalind = Index("tableind", s_table.c.id_b, s_table.c.group) Index( "compress1", s_table.c.id_a, s_table.c.id_b, oracle_compress=True ) Index( "compress2", s_table.c.id_a, s_table.c.id_b, s_table.c.col, oracle_compress=1, ) metadata.create_all(connection) mirror = MetaData() mirror.reflect(connection) metadata.drop_all(connection) mirror.create_all(connection) inspect = MetaData() inspect.reflect(connection) def obj_definition(obj): return ( obj.__class__, tuple([c.name for c in obj.columns]), getattr(obj, "unique", None), ) # find what the primary k constraint name should be primaryconsname = connection.scalar( text( """SELECT constraint_name FROM all_constraints WHERE table_name = :table_name AND owner = :owner AND constraint_type = 'P' """ ), dict( table_name=s_table.name.upper(), owner=testing.db.dialect.default_schema_name.upper(), ), ) reflectedtable = inspect.tables[s_table.name] # make a dictionary of the reflected objects: reflected = dict( [ (obj_definition(i), i) for i in reflectedtable.indexes | reflectedtable.constraints ] ) # assert we got primary key constraint and its name, Error # if not in dict assert ( reflected[ (PrimaryKeyConstraint, ("id_a", "id_b", "group"), None) ].name.upper() == primaryconsname.upper() ) # Error if not in dict eq_(reflected[(Index, ("id_b", "group"), False)].name, normalind.name) assert (Index, ("id_b",), True) in reflected assert (Index, ("col", "group"), True) in reflected idx = reflected[(Index, ("id_a", "id_b"), False)] assert idx.dialect_options["oracle"]["compress"] == 2 idx = reflected[(Index, ("id_a", "id_b", "col"), False)] assert idx.dialect_options["oracle"]["compress"] == 1 eq_(len(reflectedtable.constraints), 1) eq_(len(reflectedtable.indexes), 5)
def create_tables(engine=user_engine): meta = MetaData() meta.create_all(bind=engine, tables=tables) print('- 创建表成功: ') for table in tables: print('- %s' % table)
def upgrade(migrate_engine): meta = MetaData() meta.bind = migrate_engine table = define_hosts_table(meta) table.create()
def drop_tables(engine=user_engine): meta = MetaData() meta.drop_all(bind=engine, tables=tables) print('- 删除表成功:') print(tables)
from sqlalchemy import (create_engine, MetaData, Column, Table, Integer, String, DateTime) from datetime import datetime engine = create_engine('sqlite:///teste.db', echo=True) metadata = MetaData(bind=engine) user_table = Table( 'usuarios', metadata, Column('id', Integer, primary_key=True), Column('nome', String(40), index=True), Column('idade', Integer, nullable=False), Column('senha', String), Column('Criado_em', DateTime, default=datetime.now), Column('atualizado_em', DateTime, default=datetime.now, onupdate=datetime.now)) metadata.create_all(engine)
def upgrade(): connection = op.get_bind() meta = MetaData() meta.reflect(bind=connection) commit_table = meta.tables["commit"] distribution_table = meta.tables["distribution"] machine_table = meta.tables["machine"] run_table = meta.tables["run"] summary_table = meta.tables["summary"] runs = connection.execute(run_table.select()) commits = connection.execute(commit_table.select()) distributions = connection.execute(distribution_table.select()) machines = connection.execute(machine_table.select()) runs_by_id = {r["id"]: r for r in runs} commits_by_id = {c["id"]: c for c in commits} machines_by_id = {m["id"]: m for m in machines} logging.info("1fed559406c5: Get benchmarks") summaries = connection.execute( summary_table.select() .join(run_table, run_table.c.id == summary_table.c.run_id) .filter(run_table.c.name.like("commit: %")) ) i = 1 logging.info("1fed559406c5: Truncate distribution table") connection.execute(distribution_table.delete()) assert list(connection.execute(distribution_table.select())) == [] for summary in summaries: run = runs_by_id.get(summary["run_id"]) if not run: continue commit = commits_by_id.get(run["commit_id"]) if not commit: continue if commit.timestamp is None: continue m = machines_by_id[run["machine_id"]] machine_hash = f"{m.name}-{m.gpu_count}-{m.cpu_core_count}-{m.cpu_thread_count}-{m.memory_bytes}" distributions = list( connection.execute( get_distribution( summary_table, run_table, machine_table, commit_table, commit, summary, machine_hash, 100, ) ) ) if not distributions: continue distribution = distributions[0] values = dict(distribution) machine_hash = values.pop("hash") values["id"] = uuid.uuid4().hex values["machine_hash"] = machine_hash values["limit"] = 100 connection.execute( insert(distribution_table) .values(values) .on_conflict_do_update( index_elements=["case_id", "context_id", "commit_id", "machine_hash"], set_=values, ) ) logging.info(f"1fed559406c5: Processed {i} summary") i += 1 logging.info("1fed559406c5: Done with migration")
CheckConstraint, Integer, String, DateTime, Boolean, Date, Text, SmallInteger, DDL, sql, ) from sqlalchemy.dialects.postgresql import ARRAY, UUID, INET, JSONB metadata = MetaData( naming_convention={ 'fk': '%(table_name)s_fk_%(column_0_name)s', 'ix': '%(table_name)s_idx_%(column_0_name)s', 'pk': '%(table_name)s_pkey', }) import mbdata.config # noqa: E402 mbdata.config.configure(metadata=metadata, schema='musicbrainz') sqlalchemy.event.listen( metadata, 'before_create', DDL('CREATE SCHEMA IF NOT EXISTS musicbrainz'), ) account = Table( 'account', metadata,
def get_sqlalchemy_metadata(self): sa_engine = self.get_engine() meta = MetaData() meta.reflect(bind=sa_engine) return meta
app = Flask(__name__) ################################################# # Database Setup ################################################# DATABASE_URL = os.environ['DATABASE_URL'] app.config["SQLALCHEMY_DATABASE_URI"] = DATABASE_URL app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # for local "postgres://*****:*****@@127.0.0.1/inc5000" db = SQLAlchemy(app) metadata = MetaData(bind=db.engine) # inc2018_data = Table('inc2018_data', metadata, autoload_with=db.engine) inc2018_data = Table('inc2018_data', metadata, autoload_with=db.engine) #session = Session(db.engine) # reflect an existing database into a new model Base = automap_base() # reflect the tables Base.prepare(db.engine, reflect=True) session = Session(db.engine) Base.classes.keys() # Save references to each table
def create_new_spine_database(db_url, upgrade=True, for_spine_model=False): """Create a new Spine database at the given url.""" try: engine = create_engine(db_url) except DatabaseError as e: raise SpineDBAPIError("Could not connect to '{}': {}".format( db_url, e.orig.args)) # Drop existing tables. This is a Spine db now... meta = MetaData(engine) meta.reflect() meta.drop_all(engine) # Create new tables meta = MetaData(naming_convention=naming_convention) Table( "commit", meta, Column("id", Integer, primary_key=True), Column("comment", String(255), nullable=False), Column("date", DateTime, nullable=False), Column("user", String(45)), ) object_class_category = Table( "object_class_category", meta, Column("id", Integer, primary_key=True), Column("name", String(255), nullable=False, unique=True), Column("description", String(255), server_default=null()), Column("commit_id", Integer, ForeignKey("commit.id")), ) object_class = Table( "object_class", meta, Column("id", Integer, primary_key=True), Column("name", String(255), nullable=False, unique=True), Column("description", String(255), server_default=null()), Column("category_id", Integer, ForeignKey("object_class_category.id"), server_default=null()), Column("display_order", Integer, server_default="99"), Column("display_icon", BigInteger, server_default=null()), Column("hidden", Integer, server_default="0"), Column("commit_id", Integer, ForeignKey("commit.id")), ) Table( "object_category", meta, Column("id", Integer, primary_key=True), Column("object_class_id", Integer, ForeignKey("object_class.id")), Column("name", String(255), nullable=False, unique=True), Column("description", String(255), server_default=null()), Column("commit_id", Integer, ForeignKey("commit.id")), ) Table( "object", meta, Column("id", Integer, primary_key=True), Column( "class_id", Integer, ForeignKey("object_class.id", onupdate="CASCADE", ondelete="CASCADE")), Column("name", String(255), nullable=False, unique=True), Column("description", String(255), server_default=null()), Column("category_id", Integer, ForeignKey("object_category.id")), Column("commit_id", Integer, ForeignKey("commit.id")), ) Table( "relationship_class", meta, Column("id", Integer, primary_key=True), Column("dimension", Integer, primary_key=True), Column("object_class_id", Integer, ForeignKey("object_class.id")), Column("name", String(255), nullable=False), Column("hidden", Integer, server_default="0"), Column("commit_id", Integer, ForeignKey("commit.id")), UniqueConstraint("dimension", "name"), ) Table( "relationship", meta, Column("id", Integer, primary_key=True), Column("dimension", Integer, primary_key=True), Column("object_id", Integer, ForeignKey("object.id")), Column("class_id", Integer, nullable=False), Column("name", String(255), nullable=False), Column("commit_id", Integer, ForeignKey("commit.id")), UniqueConstraint("dimension", "name"), ForeignKeyConstraint( ("class_id", "dimension"), ("relationship_class.id", "relationship_class.dimension"), onupdate="CASCADE", ondelete="CASCADE", ), ) Table( "parameter", meta, Column("id", Integer, primary_key=True), Column("name", String(155), nullable=False, unique=True), Column("description", String(155), server_default=null()), Column("data_type", String(155), server_default="NUMERIC"), Column("relationship_class_id", Integer, default=null()), Column( "object_class_id", Integer, ForeignKey("object_class.id", onupdate="CASCADE", ondelete="CASCADE"), server_default=null(), ), Column("can_have_time_series", Integer, server_default="0"), Column("can_have_time_pattern", Integer, server_default="1"), Column("can_be_stochastic", Integer, server_default="0"), Column("default_value", String(155), server_default="0"), Column("is_mandatory", Integer, server_default="0"), Column("precision", Integer, server_default="2"), Column("unit", String(155), server_default=null()), Column("minimum_value", Float, server_default=null()), Column("maximum_value", Float, server_default=null()), Column("commit_id", Integer, ForeignKey("commit.id")), CheckConstraint( "`relationship_class_id` IS NOT NULL OR `object_class_id` IS NOT NULL" ), ) Table( "parameter_value", meta, Column("id", Integer, primary_key=True), Column( "parameter_id", Integer, ForeignKey("parameter.id", onupdate="CASCADE", ondelete="CASCADE")), Column("relationship_id", Integer, server_default=null()), Column("dummy_relationship_dimension", Integer, server_default="0"), Column("object_id", Integer, ForeignKey("object.id", onupdate="CASCADE", ondelete="CASCADE"), server_default=null()), Column("index", Integer, server_default="1"), Column("value", String(155), server_default=null()), Column("json", String(255), server_default=null()), Column("expression", String(155), server_default=null()), Column("time_pattern", String(155), server_default=null()), Column("time_series_id", String(155), server_default=null()), Column("stochastic_model_id", String(155), server_default=null()), Column("commit_id", Integer, ForeignKey("commit.id")), CheckConstraint( "`relationship_id` IS NOT NULL OR `object_id` IS NOT NULL"), UniqueConstraint("parameter_id", "object_id"), UniqueConstraint("parameter_id", "relationship_id"), ForeignKeyConstraint( ("relationship_id", "dummy_relationship_dimension"), ("relationship.id", "relationship.dimension"), onupdate="CASCADE", ondelete="CASCADE", ), ) try: meta.create_all(engine) except DatabaseError as e: raise SpineDBAPIError("Unable to create Spine database: {}".format( e.orig.args)) if not upgrade: return engine is_head(db_url, upgrade=True) if not for_spine_model: return engine # Add specific data structure for Spine Model meta = MetaData(engine, reflect=True) object_class = meta.tables["object_class"] object_ = meta.tables["object"] relationship_class = meta.tables["relationship_class"] parameter_definition = meta.tables["parameter_definition"] parameter_tag = meta.tables["parameter_tag"] parameter_definition_tag = meta.tables["parameter_definition_tag"] obj_cls = lambda *x: dict( zip(("id", "name", "description", "display_order", "display_icon"), x)) obj = lambda *x: dict(zip(("class_id", "name", "description"), x)) rel_cls = lambda *x: dict( zip(("id", "dimension", "object_class_id", "name"), x)) obj_par_def = lambda *x: dict( zip(("id", "name", "object_class_id", "default_value"), x)) rel_par_def = lambda *x: dict( zip(("id", "name", "relationship_class_id", "default_value"), x)) par_tag = lambda *x: dict(zip(("id", "tag", "description"), x)) par_def_tag = lambda *x: dict( zip(("parameter_definition_id", "parameter_tag_id"), x)) try: engine.execute( object_class.insert(), [ obj_cls(1, "direction", "A flow direction", 1, 281105626296654, 0), obj_cls( 2, "unit", "An entity where an energy conversion process takes place", 2, 281470681805429, 0), obj_cls(3, "connection", "An entity where an energy transfer takes place", 3, 280378317271233, 0), obj_cls(4, "storage", "A storage", 4, 280376899531934, 0), obj_cls(5, "commodity", "A commodity", 5, 281473533932880, 0), obj_cls(6, "node", "An entity where an energy balance takes place", 6, 280740554077951, 0), obj_cls(7, "temporal_block", "A temporal block", 7, 280376891207703, 0), ], ) engine.execute( object_.insert(), [ obj(1, "from_node", "From a node, into something else"), obj(1, "to_node", "Into a node, from something else"), ], ) engine.execute( relationship_class.insert(), [ rel_cls(1, 0, 2, "unit__node__direction__temporal_block"), rel_cls(1, 1, 6, "unit__node__direction__temporal_block"), rel_cls(1, 2, 1, "unit__node__direction__temporal_block"), rel_cls(1, 3, 7, "unit__node__direction__temporal_block"), rel_cls(2, 0, 3, "connection__node__direction__temporal_block"), rel_cls(2, 1, 6, "connection__node__direction__temporal_block"), rel_cls(2, 2, 1, "connection__node__direction__temporal_block"), rel_cls(2, 3, 7, "connection__node__direction__temporal_block"), rel_cls(3, 0, 6, "node__commodity"), rel_cls(3, 1, 5, "node__commodity"), rel_cls(4, 0, 2, "unit_group__unit"), rel_cls(4, 1, 2, "unit_group__unit"), rel_cls(5, 0, 5, "commodity_group__commodity"), rel_cls(5, 1, 5, "commodity_group__commodity"), rel_cls(6, 0, 6, "node_group__node"), rel_cls(6, 1, 6, "node_group__node"), rel_cls(7, 0, 2, "unit_group__commodity_group"), rel_cls(7, 1, 5, "unit_group__commodity_group"), rel_cls(8, 0, 5, "commodity_group__node_group"), rel_cls(8, 1, 6, "commodity_group__node_group"), rel_cls(9, 0, 2, "unit__commodity"), rel_cls(9, 1, 5, "unit__commodity"), rel_cls(10, 0, 2, "unit__commodity__direction"), rel_cls(10, 1, 5, "unit__commodity__direction"), rel_cls(10, 2, 1, "unit__commodity__direction"), rel_cls(11, 0, 2, "unit__commodity__commodity"), rel_cls(11, 1, 5, "unit__commodity__commodity"), rel_cls(11, 2, 5, "unit__commodity__commodity"), rel_cls(12, 0, 3, "connection__node__direction"), rel_cls(12, 1, 6, "connection__node__direction"), rel_cls(12, 2, 1, "connection__node__direction"), rel_cls(13, 0, 3, "connection__node__node"), rel_cls(13, 1, 6, "connection__node__node"), rel_cls(13, 2, 6, "connection__node__node"), rel_cls(14, 0, 6, "node__temporal_block"), rel_cls(14, 1, 7, "node__temporal_block"), rel_cls(15, 0, 4, "storage__unit"), rel_cls(15, 1, 2, "storage__unit"), rel_cls(16, 0, 4, "storage__connection"), rel_cls(16, 1, 3, "storage__connection"), rel_cls(17, 0, 4, "storage__commodity"), rel_cls(17, 1, 5, "storage__commodity"), ], ) engine.execute( parameter_definition.insert(), [ obj_par_def(1, "fom_cost", 2, "null"), obj_par_def(2, "start_up_cost", 2, "null"), obj_par_def(3, "shut_down_cost", 2, "null"), obj_par_def(4, "number_of_units", 2, 1), obj_par_def(5, "avail_factor", 2, 1), obj_par_def(6, "min_down_time", 2, 0), obj_par_def(7, "min_up_time", 2, 0), obj_par_def(8, "start_datetime", 7, "null"), obj_par_def(9, "end_datetime", 7, "null"), obj_par_def(10, "time_slice_duration", 7, "null"), obj_par_def(11, "demand", 6, 0), obj_par_def(12, "online_variable_type", 2, '"integer_online_variable"'), obj_par_def(13, "fix_units_on", 2, "null"), obj_par_def(14, "stor_state_cap", 4, 0), obj_par_def(15, "frac_state_loss", 4, 0), ], ) engine.execute( parameter_definition.insert(), [ rel_par_def(1001, "unit_conv_cap_to_flow", 9, 1), rel_par_def(1002, "unit_capacity", 10, "null"), rel_par_def(1003, "operating_cost", 10, "null"), rel_par_def(1004, "vom_cost", 10, "null"), rel_par_def(1005, "tax_net_flow", 8, "null"), rel_par_def(1006, "tax_out_flow", 8, "null"), rel_par_def(1007, "tax_in_flow", 8, "null"), rel_par_def(1008, "fix_ratio_out_in", 11, "null"), rel_par_def(1009, "fix_ratio_out_in", 12, "null"), rel_par_def(1010, "max_ratio_out_in", 11, "null"), rel_par_def(1011, "max_ratio_out_in", 12, "null"), rel_par_def(1012, "min_ratio_out_in", 11, "null"), rel_par_def(1013, "min_ratio_out_in", 12, "null"), rel_par_def(1014, "minimum_operating_point", 9, "null"), rel_par_def(1017, "stor_unit_discharg_eff", 15, 1), rel_par_def(1018, "stor_unit_charg_eff", 15, 1), rel_par_def(1019, "stor_conn_discharg_eff", 16, 1), rel_par_def(1020, "stor_conn_charg_eff", 16, 1), rel_par_def(1021, "max_cum_in_flow_bound", 7, "null"), rel_par_def(1022, "fix_flow", 10, "null"), rel_par_def(1023, "fix_trans", 12, "null"), ], ) engine.execute( parameter_tag.insert(), [ par_tag(1, "duration", "duration in time"), par_tag(2, "date_time", "a specific point in time"), par_tag(3, "time_series", "time series data"), par_tag(4, "time_pattern", "time patterned data"), ], ) engine.execute( parameter_definition_tag.insert(), [ par_def_tag(11, 3), par_def_tag(10, 1), par_def_tag(8, 2), par_def_tag(9, 2) ], ) except DatabaseError as e: raise SpineDBAPIError( "Unable to add specific data structure for Spine Model: {}".format( e.orig.args)) return engine
from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm.exc import NoResultFound from sqlalchemy.orm.session import Session from crate_anon.anonymise.config_singleton import config from crate_anon.anonymise.constants import ( MAX_TRID, TABLE_KWARGS, TridType, ) if TYPE_CHECKING: from crate_anon.anonymise.scrub import PersonalizedScrubber log = logging.getLogger(__name__) admin_meta = MetaData() AdminBase = declarative_base(metadata=admin_meta) class PatientInfoConstants(object): SECRET_MAP_TABLENAME = 'secret_map' PID_FIELDNAME = "pid" MPID_FIELDNAME = "mpid" RID_FIELDNAME = "rid" MRID_FIELDNAME = "mrid" TRID_FIELDNAME = "trid" class PatientInfo(AdminBase): """ Represent patient information in the secret admin database.
from sqlalchemy.dialects.postgresql import UUID from sqlalchemy.sql import func convention = { 'all_column_names': lambda constraint, table: '_'.join([ column.name for column in constraint.columns.values() ]), 'ix': 'ix__%(table_name)s__%(all_column_names)s', 'uq': 'uq__%(table_name)s__%(all_column_names)s', 'ck': 'ck__%(table_name)s__%(constraint_name)s', 'fk': 'fk__%(table_name)s__%(all_column_names)s__%(referred_table_name)s', 'pk': 'pk__%(table_name)s' } metadata = MetaData(naming_convention=convention) names_table = Table( 'names', metadata, Column('id', Integer, autoincrement=True, primary_key=True, unique=True), Column('name', String, nullable=False), Column( 'local_uuid', UUID(as_uuid=True), primary_key=True, nullable=False, unique=True ), Column('date', DateTime(timezone=True), server_default=func.now()), ) parse_company_table = Table( 'parsed_company',
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. from typing import Any from sqlalchemy import MetaData from sqlalchemy.ext.declarative import declarative_base from airflow.configuration import conf SQL_ALCHEMY_SCHEMA = conf.get("core", "SQL_ALCHEMY_SCHEMA") metadata = (None if not SQL_ALCHEMY_SCHEMA or SQL_ALCHEMY_SCHEMA.isspace() else MetaData(schema=SQL_ALCHEMY_SCHEMA)) Base = declarative_base(metadata=metadata) # type: Any ID_LEN = 250 # used for typing class Operator: pass def get_id_collation_args(): collation = conf.get('core', 'sql_engine_collation_for_ids', fallback=None) if collation: return {'collation': collation} else:
def test_reflect_all(self, connection): m = MetaData() m.reflect(connection) eq_(set(t.name for t in m.tables.values()), set(["admin_docindex"]))
from sqlalchemy.exc import NoSuchTableError # Need our custom types, but don't import anything else from model from galaxy.model.custom_types import TrimmedString log = logging.getLogger( __name__ ) log.setLevel(logging.DEBUG) handler = logging.StreamHandler( sys.stdout ) format = "%(name)s %(levelname)s %(asctime)s %(message)s" formatter = logging.Formatter( format ) handler.setFormatter( formatter ) log.addHandler( handler ) now = datetime.datetime.utcnow metadata = MetaData() SkipToolTest_table = Table( "skip_tool_test", metadata, Column( "id", Integer, primary_key=True ), Column( "create_time", DateTime, default=now ), Column( "update_time", DateTime, default=now, onupdate=now ), Column( "repository_metadata_id", Integer, ForeignKey( "repository_metadata.id" ), index=True ), Column( "initial_changeset_revision", TrimmedString( 255 ), index=True ), Column( "comment" , TEXT ) ) def upgrade( migrate_engine ): print __doc__ metadata.bind = migrate_engine metadata.reflect() # Initialize.
def _selfref_fk_fixture(self, table_args=(), table_kwargs={}): m = MetaData() t = Table('tname', m, Column('id', Integer, primary_key=True), Column('parent_id', Integer, ForeignKey('tname.id')), Column('data', String)) return ApplyBatchImpl(t, table_args, table_kwargs)