def get_session(self): if not self.sessionmaker: engine = self.get_db_engine() self.sessionmaker = scoped_session(sessionmaker(bind=engine)) session = self.sessionmaker() session.rollback() return session
def __init__(self,keep_session=False): #cache self.dash_engines = [] #check db if len(settings.SQL_BACKENDS)==0: raise Exception('Settings SQL_BACKENDS need one db at least!') #初始化数据库连接 #初始化session marker for backend in settings.SQL_BACKENDS: engine = create_engine( backend['db_url'], pool_size=backend['db_pool_size'], echo=settings.SQL_DEBUG, encoding=backend['db_charset'], pool_recycle=backend['db_pool_recycle'] ) self.dash_engines.append(engine) #初始化shardstat idx=0 s=scoped_session(sessionmaker(bind=self.dash_engines[0]))() for db_setting in settings.SQL_BACKENDS: ss=ShardStat(shard_name=db_setting['db_name'], shard_id=idx) s.add(ss) idx+=1 try: s.commit() except: s.rollback() s.close()
def setUp(self): """Creates the Flask application and the APIManager.""" # create the Flask application app = Flask(__name__) app.config['DEBUG'] = True app.config['TESTING'] = True app.config['SECRET_KEY'] = "testing..." del app.logger.handlers[0] # sqlalchemy flask self.base = declarative_base() self.engine = create_engine('sqlite://') self.session = scoped_session(sessionmaker(autocommit=False, autoflush=False, bind=self.engine)) self.app = app self._ctx = self.app.test_request_context() self._ctx.push() self.client = self.app.test_client() # Add an error handler that returns straight LeverException # recommendations @self.app.errorhandler(LeverException) def handler(exc): tb = exc.extra.pop('tb', None) self.app.logger.debug("Lever Exception Thrown!\n" "Extra: {0}\nEnd User: {1}" .format(exc.extra, exc.end_user), exc_info=True) if tb: self.app.logger.debug("Traceback from lever exception:" "\n{0}".format(tb.replace('\\n', '\n'))) return jsonify(**exc.end_user), exc.code return app
def session(self, dbname): # set up a session for each db; this uses scoped_session (based on the # thread ID) to ensure only one session per thread if dbname not in self._sessions: Session = orm.sessionmaker(bind=self.engine(dbname)) self._sessions[dbname] = scoping.scoped_session(Session) return self._sessions[dbname]
def _create_sessions(self): ''' Creates database sessions ''' gi_tax_engine = create_engine(self.gi_taxonomy_url, echo=False, convert_unicode=True, encoding='utf-8', pool_recycle=3600) gi_tax_session = scoped_session(sessionmaker( bind=gi_tax_engine, autocommit=False, autoflush=False)) self.gi_tax_session = gi_tax_session
def session(app): sess = None try: sess = scoped_session(sessionmaker(autocommit=False, autoflush=False, bind=app.engine)) yield sess finally: if sess: sess.close()
def __init__(self, db_connection, library_path, login, slot_id): self.dry_run = False self.db_engine = sqlalchemy.create_engine(db_connection) self._session_creator = scoping.scoped_session(orm.sessionmaker(bind=self.db_engine, autocommit=True)) self.crypto_plugin = p11_crypto.P11CryptoPlugin(CONF) self.plugin_name = utils.generate_fullname_for(self.crypto_plugin) self.pkcs11 = self.crypto_plugin.pkcs11 self.session = self.pkcs11.get_session()
def start(self): db_dir_path = self.resource_manager.get_fs_resource_path("store") self.db_string = "sqlite:///%s/app.db" % db_dir_path self.engine = create_engine(self.db_string) self.session = scoped_session(sessionmaker(bind=self.engine, autocommit=False, autoflush=True)) Base.metadata.create_all(self.engine)
def _create_sessions(self): ''' Creates database sessions ''' unity_engine = create_engine (self.unity_db_url, echo=False, convert_unicode=True, encoding='utf-8', pool_recycle=3600) unity_session = scoped_session(sessionmaker( bind=unity_engine, autocommit=False, autoflush=False)) self.unity_session = unity_session ncbitax_engine = create_engine (self.ncbitax_db_url, echo=False, convert_unicode=True, encoding='utf-8', pool_recycle=3600) ncbitax_session = scoped_session(sessionmaker( bind=ncbitax_engine, autocommit=False, autoflush=False)) self.ncbitax_session = ncbitax_session
def __init__(self, connection=None): self.connection = connection or cfg.db.connection self.engine = sqlalchemy.create_engine(self.connection) self.DBSession = scoping.scoped_session( orm.sessionmaker( bind=self.engine, autocommit=True ) )
def init_session(database_filename): engine = create_engine('sqlite:///{0}'.format(database_filename), echo=False) DBSession = scoped_session( sessionmaker( autoflush=True, autocommit=False, bind=engine ) ) return DBSession
def dispatch(self): """Add the database session to the request's scope.""" try: self.db_session = scoped_session(sessionmaker(bind=self.engine)) ret = super(BaseHandler, self).dispatch() self.db_session.commit() return ret except: self.db_session.rollback() raise
def SelectAll(self,pModel): try: Session = scoped_session(sessionmaker(bind=connect.ConnectorMySql())) ses = Session() lst = ses.query(pModel).all() return lst except Exception as e: raise Exception('Type Error In SelectAll :'+ str(e))
def init(self): '''Initialize(reset) mocked in-memory copy. ''' self.url = 'sqlite://' self.mock_engine = sqlalchemy.create_engine(self.url) self.MBase = declarative_base() self.MBase.metadata = self.TBase.metadata self.MBase.metadata.bind = self.mock_engine self.MBase.metadata.create_all() self._Session = scoped_session(sessionmaker(bind=self.mock_engine))
def __init__(self): self.nv_log_handler = nv_logger(self.__class__.__name__).get_logger() self.db_engine = create_engine(NVDB_SQLALCHEMY_DB, connect_args={'check_same_thread': False}, poolclass=StaticPool, echo=False) session_maker = sessionmaker(bind=self.db_engine) self.Session = scoped_session(session_maker) self.db_session = None db_base.metadata.create_all(self.db_engine) self.nv_midbox_db_entry = None self.nv_webserver = None self.nv_log_handler.debug("Tables created in nvdb")
def InsertWithOutGetID(self,pmodel): try: Session = scoped_session(sessionmaker(bind=connect.ConnectorMySql())) Base.query = Session.query_property() ses = Session() ses.add(pmodel) ses.commit() ses.close() return except Exception as e: raise Exception('Type Error In Insert :'+ str(e))
def _init_db(self): print '>>>', 'init_db' db_config_file = os.path.abspath('config/database.py') # execfile(db_config_file) db_info = {'username':'******', 'password':'******', 'host':'127.0.0.1', 'db':'storm'} engine = create_engine('mysql://%s:%s@%s/%s?charset=utf8' % (db_info['username'], db_info['password'], db_info['host'], db_info['db']), echo=False) # Session = sessionmaker(bind=engine) self.db = scoped_session(sessionmaker(bind=engine))
def __init__(self): """ dialect+driver://username:password@host:port/database """ self.conf = SysUtil().get_sys_conf() db_username = self.conf["db_username"] db_password = self.conf["db_password"] db_url = self.conf["db_url"] db_name = self.conf["db_name"] self.engine = create_engine("sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool) self._scoped_session = scoped_session(sessionmaker(bind=self.engine, expire_on_commit=True)) self.session = None
def open_db_connection(dsn): """ Sets up and configures the SQLAlchemy session using the provided L{dsn}. :param dsn: The DSN to connect too :type dsn: str """ assert isinstance(dsn, str) assert dsn engine = create_engine(dsn, echo=False, pool_recycle=3600) global Session Session = scoped_session(sessionmaker(bind=engine, autocommit=True))
def initialize(settings, **kwargs): create_db = kwargs.get('create_db', settings['app.create_db']) engine = engine_from_config( settings, prefix='sa.', echo=settings['app.echo'] ) maker = scoped_session(sessionmaker( extension=ZopeTransactionExtension() )) maker.configure(bind=engine) db.register_maker(maker) Base.metadata.bind = engine if create_db: logger.info(u"Flag 'app.create_db' is ON. Creating tables ...") Base.metadata.create_all(engine)
def get_repo_storage_id(repo_id): if repo_storage_id.has_key(repo_id): return repo_storage_id[repo_id] else: from .db import Base from sqlalchemy.orm.scoping import scoped_session RepoStorageId = Base.classes.RepoStorageId storage_id = None session = scoped_session(objstore_factory.session) q = session.query(RepoStorageId).filter(RepoStorageId.repo_id==repo_id) r = q.first() storage_id = r.storage_id if r else None repo_storage_id[repo_id] = storage_id session.remove() return storage_id
def loader(url): u"""농식품종합정보시스템 식품 정보(식단명 및 재료)를 DB에 저장합니다. :param URL: 저장할 데이터베이스 URL (ex. mysql://scott@tiger:example.com/dbname) """ engine = create_engine(url) Session = scoped_session(sessionmaker(engine)) sess = Session() Base.metadata.bind = engine Base.metadata.create_all() for food in koreafood.get_food_list(): mfood = koreafood.food_to_model(sess, food) sess.merge(mfood) sess.commit()
def __init__(self, conf): self.dry_run = False self.db_engine = sqlalchemy.create_engine(conf.sql_connection) self._session_creator = scoping.scoped_session( orm.sessionmaker( bind=self.db_engine, autocommit=True ) ) self.crypto_plugin = p11_crypto.P11CryptoPlugin(conf) self.pkcs11 = self.crypto_plugin.pkcs11 self.plugin_name = utils.generate_fullname_for(self.crypto_plugin) self.hsm_session = self.pkcs11.get_session() self.new_mkek_label = self.crypto_plugin.mkek_label self.new_hmac_label = self.crypto_plugin.hmac_label self.new_mkek = self.crypto_plugin._get_master_key(self.new_mkek_label) self.new_mkhk = self.crypto_plugin._get_master_key(self.new_hmac_label)
def loader(url): """ 농식품종합정보시스템 식품 정보(식단명 및 재료) 정보를 DB에 저장합니다. URL 저장할 데이터베이스 URL (ex. mysql://scott@tiger:example.com/dbname) """ engine = create_engine(url) Session = scoped_session(sessionmaker(engine)) sess = Session() food_model.Base.metadata.bind = engine food_model.Base.metadata.create_all() for food in koreafood.get_food_list(): mfood = food_to_model(sess, food) add_food(sess, mfood) for aliment in mfood.aliments: add_aliment(sess, aliment) add_food_aliment(sess, mfood, aliment)
def get_session(dbpath=None, scoped=False): """ Create an sql alchemy session for IO db operations :param dbpath: the path to the database, e.g. sqlite:///path_to_my_dbase.sqlite if None or missing, it defaults to the 'dburi' field in config.yaml :param scoped: boolean (False by default) if the session must be scoped session """ if dbpath is None: dbpath = get_default_dbpath() # init the session: engine = create_engine(dbpath) Base.metadata.create_all(engine) # @UndefinedVariable if not scoped: # create a configured "Session" class session = sessionmaker(bind=engine) # create a Session return session() # return session else: session_factory = sessionmaker(bind=engine) return scoped_session(session_factory)
def get_session (database_alias = 'default'): Session = _session_classes.get(database_alias, None) if Session is None: db_settings = settings.DATABASES[database_alias] port = db_settings['PORT'] engine = create_engine(URL( ENGINE[db_settings['ENGINE'].split('.')[-1]], username = db_settings['USER'], password = db_settings['PASSWORD'], host = db_settings['HOST'], port = None if port == '' else port, database = db_settings['NAME'] ), echo = settings.DEBUG) session_factory = sessionmaker(bind = engine) Session = scoped_session(session_factory) _session_classes[database_alias] = Session return Session
def test_order_clause_list(self): # This emulates customized comparators which return clause lists # for .asc and .desc operations. old_asc = Person.name.asc expected_expr = OrderClauseList(Person.id.asc(), Person.name.asc(), Person.age.asc()) self.assert_equal(str(expected_expr), 'person.id ASC, person.name ASC, person.age ASC') try: Person.name.asc = lambda : OrderClauseList(Person.id.asc(), old_asc()) expr = self._run_visitor('two-asc-asc') self.assert_equal(str(expr), str(expected_expr)) finally: Person.name.asc = old_asc # Make sure the correct ORDER BY clause is generated. sm = scoped_session(sessionmaker()) sess = sm() q = sess.query(Person).order_by(expr) # pylint: disable=E1101 q_str = str(q.statement) self.assert_not_equal(q_str.find("ORDER BY %s" % expr), -1)
def process_message(self, peer, mailfrom, rcpttos, data): try: # print(data) time_received = time.time() ttl_ts = time_received + self._message_ttl self._session.add(Message(source=str(peer), sender=str(mailfrom), recipients=str(rcpttos), body=str(data), time_received=time_received, ttl_ts=ttl_ts)) process_message_hook(peer, mailfrom, rcpttos, data) if self._message_ttl_enabled: self._session.query(Message).filter(Message.ttl_ts <= time.time()).delete() self._session.commit() self._message_retry_count = 0 with open('message_parsed_file', 'w') as f: f.write(str(time_received)) except: self._session.rollback() self._message_retry_count += 1 if self._message_retry_count > 4: self._logger.send_error(traceback.format_exc()) self._session = scoped_session(sessionmaker(bind=create_engine(self._conn_str))) if self._message_retry_count > 5: raise self.process_message(peer, mailfrom, rcpttos, data)
def start(self, path): now = datetime.now() self.logger.info("**********%s**********" % now.strftime("%Y-%m-%d %H-%M-%S")) wb = load_workbook(path) # 加载excel文件 config = yaml.load(wb["配置文件"].cell(row=1, column=1).value) # config = json.load(open("配置文件.json", encoding="utf-8")) # 接口地址 self.url = config.get("网址", None) if not self.url: self.logger.error("配置文件 中网址为空,程序退出。") return self.sleepnum = config.get("休眠时间", 2) self.ispatch = config.get("补数据", None) == "是" self.timeslot = config.get("时间段", []) self.prefixname = config.get("自定义扩展表名", "") # 加载区域代码 self.area_code = [ str(cell.value) for cell in wb["区域代码"]["A"] if str(cell.value) != "None" ] # self.area_code = json.load( # open("区域代码.json", encoding="utf-8")).get("区域代码", None) # print(len(self.area_code), self.area_code) self.logger.debug("area len: {0}, areas: {1}".format( len(self.area_code), self.area_code)) if not self.area_code: self.logger.error("区域代码加载失败,请检查") return # 加载指标代码 self.kpi_code = [ str(cell.value) for cell in wb["指标代码"]["A"] if str(cell.value) != "None" ] # self.kpi_code = json.load( # open("指标代码.json", encoding="utf-8")).get("指标代码", None) # print(len(self.kpi_code), self.kpi_code) self.logger.debug("kpi len: {0}, kpis: {1}".format( len(self.kpi_code), self.kpi_code)) if not self.kpi_code: self.logger.error("指标代码加载失败,请检查") return # 数据库地址 databaseurl = config.get("数据库连接地址", None) if not databaseurl: # print("没有找到数据库连接地址") self.logger.error("没有找到数据库连接地址") return # 采集天数 self.days = config.get("天数", 10) if self.ispatch and isinstance(self.timeslot, list) and len( self.timeslot) == 2: start = datetime.strptime(self.timeslot[0], "%Y-%m-%d") end = datetime.strptime(self.timeslot[1], "%Y-%m-%d") if start.year != end.year: # print("起始时间段必须在同一年") self.logger.error("起始时间段必须在同一年") return # 保证最小的日期在前面 if start > end: start, end = end, start else: # 当前日期的前self.days天 start = now + timedelta(days=-self.days) end = now + timedelta(days=-1) self.comparenum = config.get("比对差量", 100) self.threadnum = config.get("线程数", 4) self.executor = ThreadPoolExecutor(max_workers=self.threadnum) self.logger.info("线程数量: %s" % str(self.threadnum)) _dates = self._getDates(start, end) # 日期段 try: engine = create_engine( databaseurl, pool_size=self.threadnum, poolclass=QueuePool, ) Base.metadata.create_all(engine) # 创建表 self.session = scoped_session( sessionmaker(bind=engine, autocommit=False, autoflush=True)) except Exception as e: traceback.print_exc() # 初始化失败 self.logger.error(str(e)) return # 预发送人 preSheet = wb["预发送"] if not preSheet: self.logger.warn("无法找到预发送人表") self.preSend = [] else: self.preSend = [ str(cell.value) for cell in preSheet["A"] if str(cell.value) != "None" ] # list(preSheet.columns)[0]] self.logger.debug("预发送人: {0}".format(self.preSend)) self._startTasks(path, _dates)
#!/usr/bin/python3 """ lists all State objects from the database hbtn_0e_6_usa using sqlalchemy """ import sys import os from sqlalchemy import * import MySQLdb from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker from sqlalchemy.orm.scoping import scoped_session from sqlalchemy import MetaData, Table from model_state import Base, State if __name__ == '__main__': engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format( sys.argv[1], sys.argv[2], sys.argv[3])) Session = scoped_session(sessionmaker(bind=engine)) session = Session() state = session.query(State.id, State.name).first() metadata = MetaData() Base.metadata.create_all(engine) try: print("{}: {}".format(state[0], state[1])) except: print("Nothing") session.close()
def db_session(self): session = scoped_session(sessionmaker(bind=self.engine))() yield session session.close()
def reload(self): '''This is the 'reload' method''' Base.metadata.create_all(self.__engine) self.__session = scoped_session(sessionmaker(bind=self.__engine))
def init_session(self) -> None: engine = create_engine("sqlite:///{sqlite_filepath}".format(sqlite_filepath=self.db_path), echo=True) self.session = scoped_session(sessionmaker()) self.session.configure(bind=engine) Base.metadata.create_all(engine)
def __init__(self, connection): """""" self.engine = sqlalchemy.create_engine(connection) self.db = scoping.scoped_session(orm.sessionmaker(bind=self.engine))
def __init__(self, connection=None): self.connection = connection self.engine = sa.create_engine(self.connection) self.DBSession = scoping.scoped_session( orm.sessionmaker(bind=self.engine, autocommit=False))
from sqlalchemy.engine import create_engine from sqlalchemy.orm.scoping import scoped_session from sqlalchemy.orm.session import sessionmaker, Session engine = create_engine("sqlite:///:memory:") session_factory = scoped_session(sessionmaker(bind=engine)) class SqlalchemyContext(object): def __init__(self): self._db = session_factory() @property def db(self) -> Session: return self._db # return self.session_factory() def cleanup(self, exception=None): if exception: self.db.rollback() return self.db.commit()
from sqlalchemy import create_engine from sqlalchemy.orm import Session username = os.environ['cleardb_username'] pw = os.environ['cleardb_pw'] host = os.environ['cleardb_host'] database = os.environ['cleardb_db'] databaseurl = os.environ['CLEARDB_DATABASE_URL'] SQLALCHEMY_DATABASE_URI = 'mysql://' + username + ":" + pw + host + database # engine = create_engine('mysql+mysqlconnector://'+username+':'+ pw +'@localhost/movies', pool_recycle=3600) engine = create_engine(databaseurl, pool_recycle=360, pool_pre_ping=True) with engine.connect() as connection: con = connection.execute SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) app.session = scoped_session(SessionLocal, scopefunc=_app_ctx_stack.__ident_func__) def request_db(): #queries for 2 random actor names in the database and saves them as session result_list = [ p for (p, ) in app.session.query(distinct(Movies.actor_name)).order_by( func.rand()).limit(2) ] session['result_list'] = result_list app.session.close() @app.route('/', methods=['POST', 'GET']) def index(): request_db()
def prepare_storage(connect_str): engine = create_engine(connect_str, pool_recycle=7200) return scoped_session(sessionmaker(bind=engine))
from contextlib import contextmanager from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker from sqlalchemy.orm.scoping import scoped_session from app.core.config import settings engine = create_engine(settings.SQLALCHEMY_DATABASE_URI, pool_pre_ping=True) Session = sessionmaker(autocommit=False, autoflush=False, bind=engine) SessionLocal = scoped_session(Session) @contextmanager def session_scope(): """Provide a transactional scope around a series of operations.""" # session = __Session() session = SessionLocal try: yield session session.commit() except: session.rollback() raise finally: session.close()
def create_session(self): return scoped_session( sessionmaker(bind=self._engine, autocommit=True, autoflush=False))
class Meta: abstract = True sqlalchemy_session = scoped_session(get_session) sqlalchemy_session_persistence = 'commit'
user_id = Column(Integer, ForeignKey(User.id)) text = Column(Text(collation="utf8_unicode_ci")) withdraw = Column(Boolean, default=False) data = Column(DateTime, server_default=func.now()) def __repr__(self): return '<Transaction %r, %r>' % (self.price, self.text) class Notice(Base): __tablename__ = 'notice' id = Column(Integer, primary_key=True) user_id = Column(Integer, ForeignKey(User.id)) text = Column(Text(collation="utf8_unicode_ci")) hypertext = Column(Unicode(255, collation='utf8_unicode_ci'), default='') read = Column(Boolean, default=False) data = Column(DateTime, server_default=func.now()) ban = Column(Boolean, default=False) engine = create_engine( 'mysql://%s:%s@%s/%s?charset=utf8' % (school.config['DATABASE_USER'], school.config['DATABASE_PASSWORD'], school.config['DATABASE_IP'], school.config['DATABASE_NAME']), encoding='utf8', echo=False) Base.metadata.create_all(engine) Session = scoped_session(sessionmaker()) Session.configure(bind=engine)
# __db_engine = create_engine(config.SQLALCHEMY_DB, listeners=[ForeignKeysListener()], echo=config.SQLALCHEMY_ECHO) BaseModel.metadata.bind = __db_engine def db_init(): BaseModel.metadata.create_all(__db_engine) def db_reset(delete=False): if delete and os.path.exists(config.SQLITE_FILE): os.remove(config.SQLITE_FILE) for table in reversed(BaseModel.metadata.sorted_tables): db.execute(table.delete()) db.commit() db_init() DBSession = scoped_session(sessionmaker(bind=__db_engine)) db = DBSession() db_init()
def __init__(self, connection_url: str, connect_args: dict = None): self.url = connection_url self.engine = create_engine(connection_url, connect_args) self._session_factory = sessionmaker(bind=self.engine) # Session is the actual constructor object self.Session = scoped_session(self._session_factory)
SQLALCHEMY_RECORD_QUERIES = True ''' SQL DB ''' # SQLALCHEMY_DATABASE_URI = 'mysql://*****:*****@localhost/reporting' SQLALCHEMY_DATABASE_URI = 'mysql://' + os.environ.get('MYSQL_USER') + ':' + os.environ.get( 'MYSQL_PASS') + '@' + os.environ.get('MYSQL_HOST') + '/' + os.environ.get('MYSQL_DBNAME') log = logging.getLogger() engine = create_engine(SQLALCHEMY_DATABASE_URI, poolclass=NullPool) db_session = scoped_session(sessionmaker(autocommit=False, autoflush=False, bind=engine)) Base = declarative_base() Base.query = db_session.query_property() ''' Data Processor Constants ''' BUCKET_NAME = os.environ.get('BUCKET_NAME') ARCHIVE_BUCKET_NAME = os.environ.get('ARCHIVE_BUCKET_NAME') QUOTA_VIEW = os.environ.get('QUOTA_VIEW') USAGE_VIEW = os.environ.get('USAGE_VIEW') SCHEDULER_HOUR = os.environ.get('SCHEDULER_HOUR') SCHEDULER_MIN = os.environ.get('SCHEDULER_MIN')
from sqlalchemy.orm.scoping import scoped_session from sqlalchemy.orm.session import sessionmaker from sqlalchemy.types import Enum from exchange import Exchange, get_exchange_api from utils import get_conf conf = get_conf() if conf.get('dry_run', False): db_handle = 'sqlite:///tradesv2.dry_run.sqlite' else: db_handle = 'sqlite:///tradesv2.sqlite' engine = create_engine(db_handle, echo=False) session = scoped_session( sessionmaker(bind=engine, autoflush=True, autocommit=True)) Session = session() Base = declarative_base() class Trade(Base): __tablename__ = 'trades' query = session.query_property() id = Column(Integer, primary_key=True) exchange = Column(Enum(Exchange), nullable=False) pair = Column(String, nullable=False) is_open = Column(Boolean, nullable=False, default=True) open_rate = Column(Float, nullable=False) close_rate = Column(Float) close_profit = Column(Float)
def __init__(self, connection_string): self.engine = create_engine(connection_string) self._session_factory = sessionmaker(bind=self.engine) # Session is the actual constructor object self.Session = scoped_session(self._session_factory)
sel_signup_date = lambda e: e.cssselect('td span')[6].text sel_pv = lambda e: e.cssselect('td span')[7].text sel_network_pv = lambda e: e.cssselect('td span')[8].text TREE_URL = 'https://www.atomy.kr/v2/Home/MyAtomy/GroupTree2' DATA_TEMPLATE = "Slevel={}&VcustNo={}&VbuCustName=0&VgjisaCode=1&VgmemberAuth=0&VglevelCnt=0&Vglevel=1&VglevelMax=1&VgregDate=1&VgcustDate=0&VgstopDate=0&VgtotSale=1&VgcumSale=0&VgcurSale=1&VgbuName=1&SDate=2021-02-23&EDate=2021-02-23&glevel=1&glevelMax=1&gbu_name=1&gjisaCode=1&greg_date=1>ot_sale=1&gcur_sale=1" DB_HOST = os.environ.get('DB_HOST') or 'localhost' DB_USER = os.environ.get('DB_USER') or 'omc' DB_PASS = os.environ.get('DB_PASSWORD') or 'omc' DB_DB = os.environ.get('DB_DB') or 'order_master_common' engine = create_engine( f"mysql+mysqldb://{DB_USER}:{DB_PASS}@{DB_HOST}/{DB_DB}?auth_plugin=mysql_native_password&charset=utf8", pool_size=30, max_overflow=0) session_factory = sessionmaker(bind=engine) Session = scoped_session(session_factory) logging.basicConfig( level=logging.INFO, force=True, format="%(asctime)s\t%(levelname)s\t%(threadName)s\t%(name)s\t%(message)s") logger = logging.getLogger('build_network') def build_network(username='******', password='******', root_id='S5832131', update=False, incremental=False, cont=False, active=True,
# -*- coding: utf-8 -*- # Conexión a bases de datos # Lección 2 # SQLAlchemy: Conexión y sesión from Leccion_1 import Base from sqlalchemy.engine import create_engine from sqlalchemy.orm.scoping import scoped_session from sqlalchemy.orm.session import sessionmaker engine = create_engine('sqlite:///books.sqlite') session = scoped_session(sessionmaker(bind=engine)) Base.metadata.bind = engine
class Meta: model = models.Rate sqlalchemy_session = scoped_session(get_session, scopefunc=get_session)
import pickle except ImportError: import cPickle as pickle __all_ = ["dynamic_table", "OrmBase", "Model", "MyModel"] create_engine = partial( sa.create_engine, # convert_unicode=True, pool_recycle=3600, echo=False, connect_args={"check_same_thread": False}, poolclass=StaticPool, ) SESSION = scoped_session(sessionmaker(autocommit=False, autoflush=False)) @contextmanager def db_write(*args, **kwargs): """ Provide a transactional scope around a series of operations. """ session = SESSION() try: yield session session.commit() except Exception as e: traceback.print_exc()
url = 'mysql+pymysql://root:[email protected]:3306/python01?charset=utf8' engine = create_engine( url, max_overflow=0, # 超过连接池大小外最多创建的连接 pool_size=10, # 连接池大小 pool_timeout=30 # 池中没有线程最多等待的时间,否则报错 ) # 创建表结构,已存在表则无需执行 # base.metadata.create_all(engine) # 2. 创建与数据库的会话, class, 不是实例 print("== 实现方式(一) ==") # 使用thread local storage技术, 使 session 线程隔离 SessionFactory = sessionmaker(bind=engine) # 生成session实例, 单例模式, 与线程绑定 session = scoped_session(SessionFactory) # over ''' # print("== 实现方式(二) ==") Session = sessionmaker(bind=engine) # 生成session实例, 每次生成一个新的 session = Session() # over ''' # 3. add stu = Student() Student.set(stu, sid=9, sname='新增9', createTime='2021-08-22 17:25:03') # 把要创建的数据对象添加到这个session里 session.add(stu) # 提交,使前面修改的数据生效
#!/usr/bin/env python # encoding: utf-8 from os.path import expanduser import ConfigParser import sqlalchemy from sqlalchemy import Column, Integer, String, DateTime, Float from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import create_engine from sqlalchemy.orm.session import sessionmaker from sqlalchemy.orm.scoping import scoped_session from sqlalchemy import desc from sqlalchemy import or_ from sqlalchemy.sql import func config_file = expanduser("~") + '/.opensourcefeeds.cfg' Config = ConfigParser.ConfigParser() Config.read(config_file) engine = create_engine('mysql://%s:%s@%s/%s?charset=utf8&use_unicode=0' % (Config.get('DATABASE', 'username'), Config.get('DATABASE', 'password'), Config.get('DATABASE', 'host'), Config.get('DATABASE', 'database'))) session = scoped_session(sessionmaker(autocommit=False, autoflush=False, bind=engine)) Base = declarative_base() Base.query = session.query_property()
def reload(self): Base.metadata.create_all(self.__engine) self.__session = scoped_session(sessionmaker(bind=self.__engine))