def main(keep_saved, config_location): if not config_location: config_location = os.path.dirname(os.path.abspath(__file__)) + "\\config.ini" try: open(config_location) except IOError: print "Problem opening config.ini at " + config_location engine = create_engine(make_connection(config_location), echo=False) Session = sessionmaker(bind=engine) session = Session() Base = declarative_base() class FeverItems(Base): __tablename__ = 'fever_items' id = Column(INTEGER, primary_key=True) description = Column(LONGTEXT) is_saved = Column(TINYINT) records = session.query(FeverItems.description).filter_by(is_saved=1) contents = [] for record in records: contents.append(record) if not keep_saved: session.query(FeverItems).filter_by(is_saved=1).update({"is_saved": 0}) session.commit() return contents if __name__ == "__main__": main(bool(sys.argv[1]), str(sys.argv[2]))
def make_declarative_base(self, model=object, metaclass=DeclarativeMeta, metadata=None): """Creates the declarative base that all models will inherit from. :param model: base model class (or a tuple of base classes) to pass to :func:`~sqlalchemy.ext.declarative.declarative_base`. Or a class returned from ``declarative_base``, in which case a new base class is not created. :param metadata: :class:`~sqlalchemy.MetaData` instance to use, or none to use SQLAlchemy's default. :param metaclass: """ if not isinstance(model, DeclarativeMeta): model = declarative_base(bind=self.engine, cls=model, name='DbModel', metadata=metadata, metaclass=metaclass, class_registry=self._class_registry) # if user passed in a declarative base and a metaclass for some reason, # make sure the base uses the metaclass if metadata is not None and model.metadata is not metadata: model.metadata = metadata if not getattr(model, 'query_class', None): model.query_class = self.Query model.query = _QueryProperty(self) return model
def __init__(self, binds): # Setup mdoels and engines if not binds: binds = {} elif isinstance(binds, str): binds = {'default': binds} if 'default' not in binds: raise ImproperlyConfigured('default datastore not specified') self._engines = {} self._declarative_register = {} self._bases = {} self._base_declarative = declarative_base(name='OdmBase', metaclass=DeclarativeMeta) self.binds = {} self.is_green = False for name, bind in tuple(binds.items()): key = None if name == 'default' else name engine = create_engine(bind) dialect = engine.dialect # Dialect requires Green Pool if getattr(dialect, 'is_green', False): self.is_green = True self._engines[key] = engine
def __init__(self) -> None: super().__init__() self.engine: Engine = get_engine(get_database_uri()) self.Model: DeclarativeMeta = declarative_base(bind=self.engine) for module in sa, sa.orm: for key in module.__all__: if not hasattr(self, key): setattr(self, key, getattr(module, key))
def prepare_schema_connection(model_cls, config_cls): model_cls.SCHEMA = config_cls.SCHEMA class Base(object): __table_args__ = {'schema': config_cls.SCHEMA, 'extend_existing':True} model_cls.Base = declarative_base(cls=Base) model_cls.metadata = model_cls.Base.metadata engine = create_engine("%s://%s:%s@%s/%s" % (config_cls.DBTYPE, config_cls.DBUSER, config_cls.DBPASS, config_cls.DBHOST, config_cls.DBNAME), convert_unicode=True, pool_recycle=3600) model_cls.Base.metadata.bind = engine session_maker = sessionmaker(bind=engine) return session_maker
class Basic: base = declarative_base() __url = 'postgresql://{}:{}@{}:{}/{}' __url = __url.format(dbUserName, dbPassword, dbHost, dbPort, dbName) con = create_engine(__url, client_encoding='utf8') meta = sqlalchemy.MetaData(bind=con, reflect=True) __Session = sessionmaker(con) session = __Session()
def prepare_schema_connection(dbtype, dbhost, dbname, schema, dbuser, dbpass): class Base(object): __table_args__ = {'schema': schema, 'extend_existing': True} Base = declarative_base(cls=Base) Base.schema = schema metadata = Base.metadata engine_key = "%s://%s:%s@%s/%s" % (dbtype, dbuser, dbpass, dbhost, dbname) engine = create_engine(engine_key, pool_recycle=3600) Base.metadata.bind = engine session_maker = sessionmaker(bind=engine) return session_maker
def prepare_schema_connection(model_cls, dbtype, dbhost, dbname, schema, dbuser, dbpass): class Base(object): __table_args__ = {'schema': schema, 'extend_existing':True} model_cls.Base = declarative_base(cls=Base) model_cls.Base.schema = schema model_cls.metadata = model_cls.Base.metadata engine_key = "%s://%s:%s@%s/%s" % (dbtype, dbuser, dbpass, dbhost, dbname) engine = create_engine(engine_key, pool_recycle=3600) model_cls.Base.metadata.bind = engine session_maker = sessionmaker(bind=engine) return session_maker
class AVTables(declarative_base(metaclass=DeclarativeABCMeta)): __abstract__ = True @abc.abstractmethod def serialize(self, recurse=False) -> Mapping[str, SerializedData]: # noqa: E501 pylint: disable=no-self-use """Serialize the data so that it can be turned into a JSON format""" return {} @classmethod def serialize_date(cls, date: Optional[datetime.date]): if isinstance(date, datetime.date): return date.isoformat() return None
def init_declarative_base(override_base=None): global Base if Base: return if override_base: Base = override_base else: convention = { "ix": 'ix_%(column_0_label)s', "uq": "uq_%(table_name)s_%(column_0_name)s", "ck": "ck_%(table_name)s_%(constraint_name)s", "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s", "pk": "pk_%(table_name)s" } metadata = MetaData(naming_convention=convention) Base = declarative_base(metadata=metadata)
def load_dataset_with_columns() -> Generator[SqlaTable, None, None]: with app.app_context(): engine = create_engine(app.config["SQLALCHEMY_DATABASE_URI"], echo=True) meta = MetaData() session = db.session students = Table( "students", meta, Column("id", Integer, primary_key=True), Column("name", String(255)), Column("lastname", String(255)), Column("ds", Date), ) meta.create_all(engine) students.insert().values(name="George", ds="2021-01-01") dataset = SqlaTable( database_id=db.session.query(Database).first().id, table_name="students" ) column = TableColumn(table_id=dataset.id, column_name="name") dataset.columns = [column] session.add(dataset) session.commit() yield dataset # cleanup students_table = meta.tables.get("students") if students_table is not None: base = declarative_base() # needed for sqlite session.commit() base.metadata.drop_all(engine, [students_table], checkfirst=True) session.delete(dataset) session.delete(column) session.commit()
def get_base_meta_class(module): return declarative_base().__class__
import re from sqlalchemy.ext.declarative.api import declared_attr, has_inherited_table, declarative_base class _Base_(object): """ This class allows us to base the tablename off the class name. We also check for has_inherited_table, so as not to redeclare. We make the table name to lower case and underscored. We don't implement the primary key in base as some classes will use a foreign key to a parent table as their primary key. see: http://docs.sqlalchemy.org/en/rel_0_7/orm/extensions/declarative.html#augmenting-the-base """ @declared_attr def __tablename__(self): if has_inherited_table(self): return None name = self.__name__ return ( name[0].lower() + re.sub(r'([A-Z])', lambda m: "_" + m.group(0).lower(), name[1:])) __table_args__ = {'mysql_engine': 'InnoDB'} Base = declarative_base(cls=_Base_)
from sqlalchemy.ext.declarative.api import declarative_base from puyol.orm.query import PuyolQuery __author__ = 'USER' AlchemyBase = declarative_base() class Base(object): @classmethod def get(cls, *criteria, **kwargs): from puyol.connector import session return PuyolQuery(session.query(cls), cls, *criteria, **kwargs)
URLS = { 'SQL': os.environ['SUBDB'], } #print message or not parser = argparse.ArgumentParser() parser.add_argument('-v', '--verbose', action='store_true') parser.add_argument('-a', '--alerts', action='store_true') args = parser.parse_args() if args.verbose: logging.basicConfig(format="%(levelname)s: %(message)s", level=logging.DEBUG) else: logging.basicConfig(format="%(levelname)s: %(message)s", level=logging.WARNING) try: engine = sqlalchemy.create_engine(URLS['SQL']) Session = sessionmaker(bind=engine) Base = declarative_base(bind=engine) DBSession = sessionmaker(bind=engine) Base.metadata.create_all(engine) except Exception: logging.error('Database is not reachable with provided path : %s', URLS['SQL']) logging.error( 'Please check database instance is running and database name exists') exit(0)
import sqlalchemy as sa from wsgiref.simple_server import make_server from pyramid.config import Configurator from sqlalchemy import engine_from_config from zope.sqlalchemy import ZopeTransactionExtension from sqlalchemy.orm import scoped_session, sessionmaker from sqlalchemy.ext.declarative.api import declarative_base from seth import db from seth.db.base import Model from seth.classy.rest import generics Base = declarative_base(cls=Model) # Basic model definition class SuperModel(Base): string_column = sa.Column(sa.String(512)) def __repr__(self): return u"SuperModel {0}".format(self.id) class SampleResource(generics.GenericApiView): def get(self): print SuperModel.query.count() SuperModel.query.all()
def init_declarative_base(override_base=None): global Base if override_base: Base=override_base else: Base = declarative_base()
class BaseCFG(object): """ Class that contains custom configuration for a :func:`sqlalchemy.ext.declarative.declarative_base` to be used with the ORM. It automatically figures out a tablename (thus no need to set ``__tablename__``). """ @declared_attr def __tablename__(cls): # @NoSelf return cls.__name__.lower() def __str__(self): return unicode(self).encode("utf-8") Base = declarative_base(cls=BaseCFG) """Base class for all ORM classes. Uses :class:`BaseCFG` configuration.""" class RootFactory(object): """Skeleton for simple ACL permission protection.""" def __init__(self, request): self.request = request def __acl__(self): from .settings import CTF_BEFORE, CTF_STARTED, CTF_ARCHIVE, CTF_ENDED permission_map = { CTF_BEFORE: [ ('group:team', ['teams', 'logged_in']), (Everyone, ['teams', 'login', 'register']),
import datetime import os import threading from sqlalchemy.ext.declarative.api import declarative_base from sqlalchemy.orm.session import object_session import sqlalchemy as SA import time class tBase(object): session = property(lambda self: object_session(self)) created_date = SA.Column(SA.DateTime, default=datetime.datetime.utcnow) modified_date = SA.Column(SA.DateTime, default=datetime.datetime.utcnow, onupdate=SA.text('current_timestamp')) Base = declarative_base(cls=tBase) def id_generate(): return IdGenerator.generate() class IdGenerator(object): _inc = 0 _inc_lock = threading.Lock() @staticmethod def generate(): # 32 bits time id = (int(time.time()) & 0xffffffff) << 32 # 8 bits pid
from sqlalchemy.ext.declarative.api import declarative_base from sqlalchemy.orm import sessionmaker from sqlalchemy.sql.schema import Column from sqlalchemy.sql.sqltypes import Integer, CHAR DB_CONNECT_STRING = 'mysql://*****:*****@127.0.0.1:3306/test?charset=utf8&use_unicode=1' params = {'pool_recycle': 60, 'echo_pool': True, 'pool_size': 500, 'echo': True} engine = create_engine(DB_CONNECT_STRING, *(), **params) # engine = create_engine(DB_CONNECT_STRING) DB_Session = sessionmaker(bind=engine) session = DB_Session() # declarative_base() 创建了一个 BaseModel 类,这个类的子类可以自动与一个表关联。 BaseModel = declarative_base() class User(BaseModel): __tablename__ = 'user' id = Column('id', Integer, primary_key=True) name = Column('name', CHAR(30)) # or Column(String(30)) def init_db(): # BaseModel.metadata.create_all(engine) 会找到 BaseModel 的所有子类,并在数据库中建立这些表; BaseModel.metadata.create_all(engine) def drop_db(): BaseModel.metadata.drop_all(engine) init_db()
import os from sqlalchemy import create_engine from sqlalchemy.ext.declarative.api import declarative_base from sqlalchemy.orm import scoped_session, sessionmaker from eventsourcing.infrastructure.datastore import Datastore, DatastoreConnectionError, DatastoreSettings ActiveRecord = declarative_base() DEFAULT_SQLALCHEMY_DB_URI = 'sqlite:///:memory:' class SQLAlchemySettings(DatastoreSettings): DB_URI = os.getenv('DB_URI', DEFAULT_SQLALCHEMY_DB_URI) def __init__(self, uri=DEFAULT_SQLALCHEMY_DB_URI): self.uri = uri or self.DB_URI class SQLAlchemyDatastore(Datastore): def __init__(self, base=ActiveRecord, tables=None, connection_strategy='plain', # connect_args=None, poolclass=None, **kwargs): super(SQLAlchemyDatastore, self).__init__(**kwargs) self._session = None self._engine = None self._base = base self._tables = tables self._connection_strategy = connection_strategy
""" Created on Nov 29, 2013 @author: be07336 """ from sqlalchemy.ext.declarative.api import declarative_base from sqlalchemy.orm import relationship from sqlalchemy.schema import Column, ForeignKey from sqlalchemy.types import Integer, String, NUMERIC from model.connection import ConnectionManager Base = declarative_base(bind=ConnectionManager.get_instance().get_engine()) class Candidate(Base): """ Candidate class """ __tablename__ = 'CANDIDATE' id = Column(Integer, primary_key=True) name = Column(String) email = Column(String) year = Column(String) destination = Column(String) company = Column(String) evaluations = relationship( "Evaluation", primaryjoin="Candidate.id == Evaluation.candidate")
from sqlalchemy.ext.declarative.api import declarative_base from sqlalchemy.orm.scoping import scoped_session from sqlalchemy.orm.session import sessionmaker from sqlalchemy.sql.schema import Column from sqlalchemy.sql.sqltypes import Integer, String, DateTime, Text import datetime DBSession = scoped_session(sessionmaker()) Base = declarative_base() class JobModel(Base): __tablename__ = 'jobs' id = Column(Integer, primary_key=True) city = Column(String(100), nullable=False) companyLogo = Column(String(150)) companySize = Column(String(30)) companyName = Column(String(30), nullable=False) industryField = Column(String(30)) financeStage = Column(String(30)) website = Column(String(50)) salary = Column(String(30), nullable=False) jobNature = Column(String(50)) createTime = Column(DateTime, default=datetime.datetime.now, nullable=False) positionName = Column(String(30), nullable=False) positionType = Column(String(30))
from sqlalchemy import * from sqlalchemy.orm import relationship, backref from sqlalchemy.schema import Column, Sequence, PrimaryKeyConstraint, ForeignKey from sqlalchemy.types import Integer, String from sqlalchemy import create_engine from sqlalchemy.ext.declarative.api import declarative_base from sqlalchemy.orm.session import sessionmaker engine = create_engine("sqlite:///development.sqlite3", echo=False) Base = declarative_base(engine) documents_tags = Table( "documents_tags", Base.metadata, Column("document_id", Integer, ForeignKey("documents.id")), Column("tag_id", Integer, ForeignKey("tags.id")), ) authors_documents = Table( "authors_documents", Base.metadata, Column("author_id", Integer, ForeignKey("authors.id")), Column("document_id", Integer, ForeignKey("documents.id")), ) class Document(Base): __tablename__ = "documents" id = Column(Integer, Sequence("document_id_seq"), primary_key=True)
from sqlalchemy.engine import create_engine from sqlalchemy.ext.declarative.api import declarative_base from sqlalchemy.schema import Column, Sequence from sqlalchemy.types import Integer, String, DateTime #definicao do banco de dados DATABASE="sqlite:///blog.db" engine = create_engine(DATABASE, echo=True) BASE = declarative_base(engine) class Post(BASE): """ modelo de post """ __tablename__ = 'posts' id = Column(Integer, Sequence('post_id_seq'), primary_key=True) title = Column(String(250)) content = Column(String()) date=Column(DateTime()) def __init__(self, title, content, date): self.title = title self.content = content self.date = date def __repr__(self): return "<User('%s','%s', '%s')>" % (self.id, self.title, self.date) #essa linha roda na primeira vez que o modulo eh carregado e apenas uma vez BASE.metadata.create_all(engine)
def rebind(self, database_uri: str): self.engine = get_engine(database_uri) self.Model = declarative_base(bind=self.engine, metadata=self.metadata)
# create_table_orm.py from sqlalchemy import Column, String, INTEGER, DateTime from sqlalchemy.ext.declarative.api import declarative_base from sqlalchemy.orm import sessionmaker BASE = declarative_base() # 定义学生对象 class Company(BASE): # 表的名字:STUDENT __tablename__ = 'tab_company' # id id = Column(INTEGER,primary_key=True) # 表号 name = Column(String(20)) #创建时间 createTime=Column(DateTime) #创建人 createUser=Column(String(50)) # 创建表的参数 __table_args__ = { "mysql_charset": "utf8" } def __str__(self): # 格式输出查询出的数据 return '%s,%s,%s,%s' % (self.id, self.name,self.createTime,self.createUser)
from sqlalchemy.ext.declarative.api import declarative_base vxlan_id = -1 vm_id = 0 BASEOBJ = declarative_base() class base(BASEOBJ): """Base class for Nova and Glance Models""" __abstract__ = True __table_args__ = {'mysql_engine': 'InnoDB'} __table_initialized__ = False class test(base): """ Base class for resource type object """ __abstract__ = True _resource_name_ = None _alias_name_ = None __protected_attributes__ = set([ "created_at", "updated_at", "deleted_at", "deleted"]) class g_var(object): def __init__(self): global vxlan_id pass @classmethod def print_cls(cls): print cls.__class__
class ModelBase: Base = declarative_base()
from sqlalchemy import Column, types import datetime from mittn.issue import Issue from sqlalchemy.ext.declarative.api import declarative_base import json import socket HOSTNAME = socket.gethostbyname(socket.gethostname()) Base = declarative_base(cls=Issue) class ScannerIssue(Base): __tablename__ = 'headlessscanner_issues' # We use LargeBinary in message because it can be very big # XXX fields that are used in all tools come from issue.py severity = Column(types.Text) issuetype = Column(types.Text) issuename = Column(types.Text) issuedetail = Column(types.Text) confidence = Column(types.Text) host = Column(types.Text) port = Column(types.Text) protocol = Column(types.Text) messages = Column(types.LargeBinary) def unique_fields(self): """ These fields are used when checking for false
import logging db_ip = "112.74.48.66" db_port = "3306" #用户 db_user = "******" #密码 db_password = "******" #数据库名 db_name = "bs_user" #目标路径 target_location = 'mysql+pymysql://'+db_user+':'+db_password+'@'+db_ip+':3306/'+db_name #相应的数据库表名 tb_accountFund = "accountfunds" DynamicBase = declarative_base(class_registry=dict()) engine = sqlalchemy.create_engine(target_location) def insert_funds(property_list): pass def delete_content(table_name,user_field,user_id): conn = engine.connect() try: delete_str = "DELETE FROM "+ table_name +" WHERE "+ user_field + " = " + user_id conn.connect() conn.execute(delete_str) except Exception as e: logging.exception('erorr msg')
#if no env variable has been defined, a default one is set if not(os.environ.has_key("SUBDB")): os.environ['SUBDB'] = 'mysql://*****:*****@127.0.0.1:3306/sub_ai' URLS = { 'SQL':os.environ['SUBDB'], } #print message or not parser = argparse.ArgumentParser() parser.add_argument('-v','--verbose',action='store_true') parser.add_argument('-a','--alerts',action='store_true') args = parser.parse_args() if args.verbose: logging.basicConfig(format="%(levelname)s: %(message)s", level=logging.DEBUG) else: logging.basicConfig(format="%(levelname)s: %(message)s", level=logging.WARNING) try: engine = sqlalchemy.create_engine(URLS['SQL']) Session = sessionmaker(bind=engine) Base = declarative_base(bind=engine) DBSession = sessionmaker(bind = engine) Base.metadata.create_all(engine) except Exception: logging.error('Database is not reachable with provided path : %s',URLS['SQL']) logging.error('Please check database instance is running and database name exists') exit(0)
@declared_attr def __tablename__(self): if has_inherited_table(self): return None name = self.__name__ return ( name[0].lower() + re.sub(r'([A-Z])', lambda m:"_" + m.group(0).lower(), name[1:]) ) __table_args__ = {'mysql_engine': 'InnoDB'} Base = declarative_base(cls=_Base_) def connect(url): engine = create_engine(url) Session = sessionmaker(autocommit=False, autoflush=False, bind=engine) return Session def create_all(engine): Base.metadata.create_all(engine) def drop_all(session):
String, Time, UniqueConstraint, ) from sqlalchemy.dialects.postgresql import TSVECTOR from sqlalchemy.exc import IntegrityError, SQLAlchemyError from sqlalchemy.ext.declarative.api import declarative_base, DeclarativeMeta from sqlalchemy.orm import relationship, Session from sqlalchemy.sql.schema import CheckConstraint from app.config import PSQL_ENVIRONMENT from app.dependencies import logger from app.internal.privacy import PrivacyKinds import app.routers.salary.config as SalaryConfig Base: DeclarativeMeta = declarative_base() class User(Base): __tablename__ = "users" id = Column(Integer, primary_key=True, index=True) username = Column(String, unique=True, nullable=False) email = Column(String, unique=True, nullable=False) password = Column(String, nullable=False) full_name = Column(String) description = Column(String, default="Happy new user!") avatar = Column(String, default="profile.png") telegram_id = Column(String, unique=True) is_active = Column(Boolean, default=False) disabled = Column(Boolean, default=False, nullable=False)
from wsgiref.simple_server import make_server import sqlalchemy as sa from sqlalchemy import engine_from_config from sqlalchemy.orm import scoped_session, sessionmaker from sqlalchemy.ext.declarative.api import declarative_base from zope.sqlalchemy import ZopeTransactionExtension from marshmallow import Schema, fields from seth import db from seth import filtering from seth.classy.rest import generics from seth.db.base import TimeStampedModel Base = declarative_base(cls=TimeStampedModel) # Basic model definition class SuperModel(Base): string_column = sa.Column(sa.String(512)) # Define model filter class SuperModelFilters(filtering.FilterFactory): model = SuperModel string_column = filtering.CharFilter() # Basic schema definition - TimeStampedModel predefines four fields: # id, is_deleted, created_at, updated_at
import re import sys from tempfile import NamedTemporaryFile from sqlalchemy.engine import create_engine from sqlalchemy.ext.declarative.api import declarative_base from sqlalchemy.orm.session import sessionmaker from sqlalchemy.schema import MetaData, Column from sqlalchemy.types import Integer, Float, String # connstr = 'sqlite://' ## four slashes for absolute paths - three for relative connstr = 'sqlite:///{0}'.format('/tmp/profile.sqlite') engine = create_engine(connstr) metadata = MetaData(bind=engine) Base = declarative_base(metadata=metadata) Session = sessionmaker(bind=engine) class Results(Base): __tablename__ = 'results' rid = Column(Integer, primary_key=True) ncalls = Column(Integer) tottime = Column(Float) filename = Column(String) percall_tottime = Column(Float) cumtime = Column(Float) percall_cumtime = Column(Float) class ExecutionInfo(Base):
from sqlalchemy.ext.declarative import api from sqlalchemy.ext.declarative import declared_attr from datetime import datetime from sqlalchemy import Column, Integer, Boolean, Float, ARRAY, DateTime, BigInteger class BaseModel(object): @declared_attr def __tablename__(cls): return cls.__name__.lower() id = Column(BigInteger, primary_key=True) created_at = Column( DateTime, default=datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")) updated_at = Column( DateTime, default=datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"), onupdate=datetime.utcnow().strftime('"%Y-%m-%d %H:%M:%S"')) Base = api.declarative_base(cls=BaseModel)
from sqlalchemy.ext.declarative.api import declarative_base from sqlalchemy.orm import relationship from sqlalchemy.sql.schema import ForeignKey, Column from sqlalchemy.sql.sqltypes import Integer, String __author__ = 'chiesa' BASE = declarative_base() class Managers(BASE): __tablename__ = 'managers' id = Column(Integer, primary_key=True) name = Column(String) class Employees(BASE): __tablename__ = 'employees' id = Column(Integer, primary_key=True) name = Column(String) surname = Column(String) manager_id = Column(Integer, ForeignKey('managers.id')) manager = relationship(Managers, backref='employees')
class Context(object): ''' Singelton context of a running instance providing general information / configuration ''' configuration = None base = declarative_base() version = "$EOSS_PROJECT_ID$" orm_initialized = None def __init__(self, url=None): ''' Singelton context of a running instance providing general information / configuration ''' self.version = 'v1' if url == None: self.url = read_OS_var("EOSS_CATALOG_DB", mandatory=False) else: self.url = url if self.orm_initialized is None: assert self.url != None, 'Please specify DB connection with EOSS_CATALOG_DB' self.init_orm() def __str__(self): return "<EOSS context version:%s>" % (self.version) def init_orm(self): """ Initualize ORM component and create tables if necessary. :param url: sqlalchemy compatible DB url string :return: None - set sqlalchemy session as class attribute """ prog = os.path.basename(sys.argv[0]) or 'eoss-api' username = pwd.getpwuid(os.getuid()).pw_name hostname = socket.gethostname().split(".")[0] self.engine = create_engine( self.url, # pool_size=10, # max_overflow=5, # pool_recycle=600, connect_args={ 'application_name': "%s:%s@%s" % (prog, username, hostname) }, poolclass=NullPool) self.getBase().metadata.create_all(self.engine) # metadata = schema.MetaData() self.session_factory = sessionmaker(bind=self.engine, autocommit=False, autoflush=False, expire_on_commit=True) self.session = scoped_session(self.session_factory) self.base.metadata.create_all(self.engine) self.orm_initialized = True def getSession(self): ''' Return sqlalchemy session (http://docs.sqlalchemy.org/en/latest/orm/session_api.html) :return: ''' return self.session() def closeSession(self): self.session.remove() def get_engine(self): """ Get DB engine from sqlalchemy for direct manipulation (http://docs.sqlalchemy.org/en/latest/core/connections.html?highlight=engine#module-sqlalchemy.engine) :return: sqlalchemy db engine """ return self.engine def getBase(self): """ Return sqlalchemy base necessary for table registrations (http://docs.sqlalchemy.org/en/latest/orm/extensions/declarative/api.html) :return: """ return self.base def __new__(cls, *attr, **kwargs): """ Handle Context object as singelton""" if not hasattr(cls, '_inst'): cls._inst = super(Context, cls).__new__(cls, *attr, **kwargs) return cls._inst
import os from sqlalchemy.orm.session import sessionmaker from sqlalchemy.orm.scoping import scoped_session from sqlalchemy.ext.declarative.api import declarative_base import sqlalchemy BASE = os.path.dirname(__file__) Engine = sqlalchemy.create_engine('sqlite:///%s'%(os.path.join(BASE, "data.db")), echo=True) Entity = declarative_base(bind=Engine) session_factory = sessionmaker(bind=Engine) session = scoped_session(session_factory=session_factory)
from sqlalchemy.ext.declarative.api import declarative_base from sqlalchemy.orm.session import sessionmaker from sqlalchemy.types import Integer, Float, String from tempfile import NamedTemporaryFile, mkdtemp import sys import re import os import shutil #connstr = 'sqlite://' ## four slashes for absolute paths - three for relative connstr = 'sqlite:///{0}'.format('/tmp/profile.sqlite') engine = create_engine(connstr) metadata = MetaData(bind=engine) Base = declarative_base(metadata=metadata) Session = sessionmaker(bind=engine) class Results(Base): __tablename__ = 'results' rid = Column(Integer,primary_key=True) ncalls = Column(Integer) tottime = Column(Float) filename = Column(String) percall_tottime = Column(Float) cumtime = Column(Float) percall_cumtime = Column(Float) class ExecutionInfo(Base):
#!/usr/bin/python # -*- coding: utf-8 -*- #coding=utf-8 """ Create On 2015年11月11日 @deprecated: 构造持久化类基类:Base @author: Linked """ from sqlalchemy.ext.declarative.api import declarative_base Base = declarative_base() #持久化的Base类
def legacy_database_fixer(database_path, database, database_name, database_exists): database_directory = os.path.dirname(database_path) old_database_path = database_path old_filename = os.path.basename(old_database_path) new_filename = f"Pre_Alembic_{old_filename}" pre_alembic_path = os.path.join(database_directory, new_filename) pre_alembic_database_exists = False if os.path.exists(pre_alembic_path): database_path = pre_alembic_path pre_alembic_database_exists = True datas = [] if database_exists: Session, engine = db_helper.create_database_session(database_path) database_session = Session() result = engine.dialect.has_table(engine, 'alembic_version') if not result: if not pre_alembic_database_exists: os.rename(old_database_path, pre_alembic_path) pre_alembic_database_exists = True if pre_alembic_database_exists: Session, engine = db_helper.create_database_session(pre_alembic_path) database_session = Session() api_table = database.api_table() media_table = database.media_table() Base = declarative_base() # DON'T FORGET TO REMOVE # database_name = "posts" # DON'T FORGET TO REMOVE legacy_api_table = api_table.legacy(Base, database_name) legacy_media_table = media_table.legacy(Base) result = database_session.query(legacy_api_table) post_db = result.all() for post in post_db: post_id = post.id created_at = post.created_at new_item = {} new_item["post_id"] = post_id new_item["text"] = post.text new_item["price"] = post.price new_item["paid"] = post.paid new_item["postedAt"] = created_at new_item["medias"] = [] result2 = database_session.query(legacy_media_table) media_db = result2.filter_by(post_id=post_id).all() for media in media_db: new_item2 = {} new_item2["media_id"] = media.id new_item2["post_id"] = media.post_id new_item2["links"] = [media.link] new_item2["directory"] = media.directory new_item2["filename"] = media.filename new_item2["size"] = media.size new_item2["media_type"] = media.media_type new_item2["downloaded"] = media.downloaded new_item2["created_at"] = created_at new_item["medias"].append(new_item2) datas.append(new_item) print database_session.close() x = export_sqlite(old_database_path, datas, database_name, legacy_fixer=True) print
""" Created on Nov 29, 2013 @author: be07336 """ from sqlalchemy.ext.declarative.api import declarative_base from sqlalchemy.orm import relationship from sqlalchemy.schema import Column, ForeignKey from sqlalchemy.types import Integer, String, NUMERIC from model.connection import ConnectionManager Base = declarative_base(bind=ConnectionManager.get_instance().get_engine()) class Candidate(Base): """ Candidate class """ __tablename__ = 'CANDIDATE' id = Column(Integer, primary_key=True) name = Column(String) email = Column(String) year = Column(String) destination = Column(String) company = Column(String) evaluations = relationship("Evaluation", primaryjoin="Candidate.id == Evaluation.candidate") others = relationship("Document", primaryjoin="and_(Candidate.id == Document.candidate,"
if redis_config["pass"]: redis_url = "redis://:" + redis_config["pass"] + "@" + redis_config[ "host"] + ":" + redis_config["port"] rds_instance = redis.Redis(host=redis_config["host"], port=redis_config["port"], password=redis_config["pass"]) else: redis_url = "redis://" + redis_config["host"] + ":" + redis_config["port"] rds_instance = redis.Redis(host=redis_config["host"], port=redis_config["port"]) mongo_url = "mongodb://{username}:{password}@{host}:{port}".format( username=get_config("MONGODB_USERNAME", ""), password=get_config("MONGODB_PASSWORD", ""), host=get_config("MONGODB_HOST", "mongodb"), port=get_config("MONGODB_PORT", "27017")) engine = create_engine(mysql_url) metadata = MetaData() Base = declarative_base() # Base.prepare(engine, reflect=True) db_session = scoped_session( sessionmaker(autocommit=False, autoflush=False, bind=engine)) Base.query = db_session.query_property()
def init_declarative_base(override_base=None): global Base if override_base: Base = override_base else: Base = declarative_base()