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
