def create_engine(dbpath='sqlite:///:memory:', echo=False): """ Dont use directly, write a wrapper over this in your store.py file """ engine = sqlalchemy_create_engine(dbpath, echo=echo) Base.metadata.create_all(engine) return engine
def create_engine(cls, *args, **kwds): engine = patch_engine(sqlalchemy_create_engine(*args, **kwds)) event.listen(engine, 'before_cursor_execute', sql_commenter, retval=True) return engine
def create_engine(db): db_path = '%s:%s@%s:%s/%s' % (db['user'], db['pass'], db['host'], db['port'], db['schema']) db_secured_path = '%s:%s@%s:%s/%s' % (db['user'], '*****', db['host'], db['port'], db['schema']) engine = sqlalchemy_create_engine(f'mysql+mysqlconnector://{db_path}') print(f'Connected to MySQL at {db_secured_path}\n') return engine
def create_single_session(cls, url, scopefunc=None): engine = sqlalchemy_create_engine(url, pool_size=10, max_overflow=70, pool_recycle=1200) patched_engine = patch_engine(engine) return scoped_session(sessionmaker(expire_on_commit=False, bind=patched_engine), scopefunc=scopefunc)
def __create_engine(type_, pool_size=1, debug=False, **db_info): """ Create a sqlalchemy engine .. seealso:: supports all keywords arguments of constructor :class:`sqlalchemy.engine.url.URL` :param str type_: the type of engine (postgres, mysql) :param int pool_size: pool size of the engine (at least as much as the number of threads in :class:`gmaltcli.worker.WorkerPool`) :param bool debug: Enable echo parameters of sqlalchemy engine :return: a sqlalchemy engine :rtype: :class:`sqlalchemy.engine.base.Engine` """ uri = sql_url.URL(type_, **db_info) return sqlalchemy_create_engine(uri, pool_size=pool_size, echo=debug)
def __init__(self, *args, **kwargs): if not hasattr(self, 'engine'): self.engine = None if not args and not kwargs: return if self.engine: raise RuntimeError('The engine is already configured.') # pylint: disable=no-member self.engine = sqlalchemy_create_engine(*args, **kwargs) SQLAlchemy.Session.configure(bind=self.engine) SQLAlchemy.Model.metadata.bind = self.engine self.manager = ConnectionManager(self.engine) # to be removed later self.create_all()
def create_engine(self, conn_string: Optional[str] = None, persist: bool = True ) -> Optional[Engine]: """ Args: conn_string => database connection string persist => whether to persist the database engine to self.engine Returns: New database connection (SQLAlchemy Engine) using either provided conn_string or self.conn_string. NOTE: If both conn_string and self.conn_string are None then will return None. Preconditions: N/A """ if conn_string is not None: self.conn_string = conn_string if self.conn_string is not None: engine = sqlalchemy_create_engine(self.conn_string) if persist: self.engine = engine return engine return None
#import statements from sqlalchemy import create_engine as sqlalchemy_create_engine from sqlalchemy.orm import scoped_session as sqlalchemy_orm_scoped_session from sqlalchemy.orm import sessionmaker as sqlalchemy_orm_sessionmaker import flask, flask_session, string, os, argon2 #create the database connection databaseEngine = sqlalchemy_create_engine(os.getenv('DATABASE_URL')) databaseDatabase = sqlalchemy_orm_scoped_session( sqlalchemy_orm_sessionmaker(bind=databaseEngine)) #the application variable for flask app = flask.Flask(__name__) #the path to the static directory app._static_folder = 'static' #set up the session app.config['SESSION_PERMANENT'] = True app.config['SESSION_TYPE'] = 'filesystem' flask_session.Session(app) #the home page/search page for books @app.route('/', methods=['GET', 'POST']) def route_rootIndex(): #get a list of random books books = databaseDatabase.execute( 'SELECT * FROM books ORDER BY RANDOM() LIMIT 20' ) #make these books into clickable links
def create_engine(self, db, *args, **kwargs): url = kwargs.pop('url') engine = sqlalchemy_create_engine(url, **kwargs) logger.info('db: %s inited.', db) return engine
from sqlalchemy import create_engine as sqlalchemy_create_engine from sqlalchemy.orm import sessionmaker from screencloud import config engine = sqlalchemy_create_engine( config['SQL_DB_URI'], client_encoding='utf8' ) session_factory = sessionmaker(autocommit=False, autoflush=False, bind=engine)
def create_engine(cls, *args, **kwds): engine = patch_engine(sqlalchemy_create_engine(*args, **kwds)) return engine