def modify_url(cls, url: URL, database: Optional[str],
schema: Optional[str]) -> None:
"""
Modify the url to point to a new schema.
:param url: SqlAlchemy URL instance
:param database: database to point the new URL to
:param schema: schema to point the new URL to
"""
database_current = url.database
schema_current = None
if not cls.supports_schemas or database is None:
return
if "/" in database_current:
database_current, schema_current = database_current.split("/")
if database is None:
database = database_current
if schema is None:
schema = schema_current
if schema is None:
url.database = database
else:
url.database = database + "/" + schema
def __init__(self):
# Set up datastore connection.
from sqlalchemy.engine.url import URL
logger.info(_endpoints.tracker_store.kwargs)
dialect = _endpoints.tracker_store.kwargs["dialect"] #"postgresql"
username = _endpoints.tracker_store.kwargs["username"] #"postgres"
password = None
login_db = _endpoints.tracker_store.kwargs["login_db"] #"postgres"
host = _endpoints.tracker_store.url
port = None
db = _endpoints.tracker_store.kwargs["db"] #"rasa"
query = None
#login_db: Alternative database name to which initially connect, and create
# the database specified by `db` (PostgreSQL only).
engine_url = URL(dialect, username, password, host, port, login_db,
query)
# if `login_db` has been provided, use currentpassword channel with
# that database to create working database `db`
try:
self.engine = create_engine(engine_url)
# Create Database
self._create_database(self.engine, db)
engine_url.database = db
self.engine = create_engine(engine_url)
Base.metadata.create_all(self.engine)
except (sqlalchemy.exc.OperationalError,
sqlalchemy.exc.ProgrammingError,
psycopg2.OperationalError) as e:
# Several Rasa services started in parallel may attempt to
# create tables at the same time. That is okay so long as
# the first services finishes the table creation.
logger.error(f"Could not create tables: {e}")
self.sessionmaker = sessionmaker(bind=self.engine)
def modify_url(cls, url: URL, schema: Optional[str] = None) -> None:
"""
Modify the url to point to a new schema.
:param url: SqlAlchemy URL instance
:param schema: schema to connect to
"""
database = url.database
if not cls.supports_schemas or database is None:
return
if "/" in database:
database = database.split("/")[0]
if schema is None:
url.database = database
else:
url.database = database + "/" + schema
def get_db_session(config: configparser.ConfigParser) -> Session:
"""
Open a database session.
:param config: Database username, password, etc.
:return: Returns a live database session.
"""
url = URL(
config['sqlalchemy']['drivername'],
config['sqlalchemy']['username'],
config['sqlalchemy']['password'],
config['sqlalchemy']['host'],
config['sqlalchemy']['port'],
# config['sqlalchemy']['database'],
)
engine = create_engine(url)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
engine.execute(
f"CREATE DATABASE IF NOT EXISTS {config['sqlalchemy']['database']};"
)
engine.dispose()
url.database = config['sqlalchemy']['database']
engine = create_engine(url)
session_maker = sessionmaker(bind=engine)
session = session_maker()
return session
def test_adjust_database_uri_when_selected_schema_is_none(self):
url = URL(drivername="trino", database="hive")
TrinoEngineSpec.adjust_database_uri(url, selected_schema=None)
self.assertEqual(url.database, "hive")
url.database = "hive/default"
TrinoEngineSpec.adjust_database_uri(url, selected_schema=None)
self.assertEqual(url.database, "hive/default")
def adjust_database_uri(cls,
uri: URL,
selected_schema: Optional[str] = None) -> None:
database = uri.database
if selected_schema and database:
selected_schema = parse.quote(selected_schema, safe="")
database = database.split("/")[0] + "/" + selected_schema
uri.database = database
def model_login(conn_params):
link = URL(conn_params['database_driver'], username = conn_params['username'],
password= conn_params['password'], host = conn_params['host'])
if conn_params['connection_database']:
link.database = conn_params['connection_database']
elif not conn_params['connection_database'] and conn_params['database_driver'] == 'postgresql':
link.database = 'postgres'
engine = create_engine(link)
conn = ''
dict_ret = {}
try:
conn = engine.connect()
except OperationalError as e:
dict_ret = {'login': False, 'msg': str(e)}
else:
# todo 'msg'
dict_ret = {'login': True, 'msg': ''}
conn.close()
return dict_ret
def _make_url(self, log_errors=True):
"""Returns a sqlalchemy url from the current url attribute or None if not valid."""
if not self._url:
if log_errors:
self._logger.msg_error.emit(
f"No URL specified for <b>{self.name}</b>. Please specify one and try again"
)
return None
try:
url_copy = dict(self._url)
dialect = url_copy.pop("dialect")
if not dialect:
if log_errors:
self._logger.msg_error.emit(
f"Unable to generate URL from <b>{self.name}</b> selections: invalid dialect {dialect}. "
"<br>Please select a new dialect and try again.")
return None
if dialect == 'sqlite':
url = URL('sqlite', **url_copy) # pylint: disable=unexpected-keyword-arg
else:
db_api = spinedb_api.SUPPORTED_DIALECTS[dialect]
drivername = f"{dialect}+{db_api}"
url = URL(drivername, **url_copy) # pylint: disable=unexpected-keyword-arg
except Exception as e: # pylint: disable=broad-except
# This is in case one of the keys has invalid format
if log_errors:
self._logger.msg_error.emit(
f"Unable to generate URL from <b>{self.name}</b> selections: {e} "
"<br>Please make new selections and try again.")
return None
if not url.database:
if log_errors:
self._logger.msg_error.emit(
f"Unable to generate URL from <b>{self.name}</b> selections: database missing. "
"<br>Please select a database and try again.")
return None
# Small hack to make sqlite file paths relative to this DS directory
# TODO: Check if this is still needed
if dialect == "sqlite" and not os.path.isabs(url.database):
url.database = os.path.join(self.data_dir, url.database)
self._properties_ui.lineEdit_database.setText(url.database)
# Final check
try:
engine = create_engine(url)
with engine.connect():
pass
except Exception as e: # pylint: disable=broad-except
if log_errors:
self._logger.msg_error.emit(
f"Unable to generate URL from <b>{self.name}</b> selections: {e} "
"<br>Please make new selections and try again.")
return None
return url
def adjust_database_uri(cls,
uri: URL,
selected_schema: Optional[str] = None) -> None:
if selected_schema:
uri.database = parse.quote(selected_schema, safe="")
from sqlalchemy import create_engine
from sqlalchemy.engine.url import URL
from sqlalchemy.orm import sessionmaker, Session, scoped_session
from .config import database_config
__engine_url = URL(database_config['driver'])
__engine_url.username = database_config['user']
__engine_url.password = database_config['password']
__engine_url.host = database_config['host']
__engine_url.database = database_config['name']
engine_url = str(__engine_url)
__engine = create_engine(str(__engine_url) + '?charset=utf8')
class __Database:
__session = None
def __init__(self, session_maker):
"""
:type session_maker: sessionmaker
"""
self.__session__maker = session_maker
def get_session(self):
"""
def __getitem__(self, name):
if 'DATABASES' not in settings:
raise exceptions.ImproperlyConfigured(
'DATABASES not configured in project settings.')
if name not in settings['DATABASES']:
raise exceptions.ImproperlyConfigured(
'%r not present in DATABASES configuration.' % name)
config = settings['DATABASES'][name]
if isinstance(config, six.string_types):
url = make_url(config)
options = {}
else:
config = dict(map(lambda i: (i[0].lower(), i[1]), config.items()))
options = config.get('options', {})
url = URL(config['engine'],
username=config.get('username', config.get('user')),
password=config.get('password', config.get('pass')),
host=config.get('hostname', config.get('host')),
port=config.get('port'),
database=config.get('name', config.get('database')))
# If alchemist is invoked by a test runner we should switch to using
# testing databases.
if settings['TESTING']:
if url.drivername.startswith('sqlite'):
# Switch to using an in-memory database for sqlite.
url.database = ':memory:'
else:
# Switch to using a named testing database for other dialects.
ident = threading.current_thread().ident
url.database = 'test_%s_%s' % (url.database, ident)
# Apply MySQL hacks to make MySQL play nice.
pool_size = None
pool_recycle = None
if url.drivername.startswith('mysql'):
pool_size = 10
pool_recycle = 7200
# Get "global" options for the database engine.
pool_size = settings.get('DATABASE_POOL_SIZE', pool_size)
if pool_size:
options.setdefault('pool_size', pool_size)
pool_recycle = settings.get('DATABASE_POOL_RECYCLE', pool_recycle)
if pool_recycle:
options.setdefault('pool_recycle', pool_recycle)
pool_timeout = settings.get('DATABASE_POOL_TIMEOUT')
if pool_timeout:
options.setdefault('pool_timeout', pool_timeout)
# Forward configuration to sqlalchemy and create the engine.
engine = sa.create_engine(url, **options)
if settings["DEBUG"]:
# Create a no-op listener if we're in debug mode.
from sqlalchemy.event import listen
listen(engine, "after_cursor_execute", lambda *a, **kw: None)
# Return the created engine.
return engine
def __getitem__(self, name):
if 'DATABASES' not in settings:
raise exceptions.ImproperlyConfigured(
'DATABASES not configured in project settings.')
if name not in settings['DATABASES']:
raise exceptions.ImproperlyConfigured(
'%r not present in DATABASES configuration.' % name)
config = settings['DATABASES'][name]
if isinstance(config, six.string_types):
url = make_url(config)
options = {}
else:
config = dict(map(lambda i: (i[0].lower(), i[1]), config.items()))
options = config.get('options', {})
url = URL(
config['engine'],
username=config.get('username', config.get('user')),
password=config.get('password', config.get('pass')),
host=config.get('hostname', config.get('host')),
port=config.get('port'),
database=config.get('name', config.get('database')))
# If alchemist is invoked by a test runner we should switch to using
# testing databases.
if settings['TESTING']:
if url.drivername.startswith('sqlite'):
# Switch to using an in-memory database for sqlite.
url.database = ':memory:'
else:
# Switch to using a named testing database for other dialects.
ident = threading.current_thread().ident
url.database = 'test_%s_%s' % (url.database, ident)
# Apply MySQL hacks to make MySQL play nice.
pool_size = None
pool_recycle = None
if url.drivername.startswith('mysql'):
pool_size = 10
pool_recycle = 7200
# Get "global" options for the database engine.
pool_size = settings.get('DATABASE_POOL_SIZE', pool_size)
if pool_size:
options.setdefault('pool_size', pool_size)
pool_recycle = settings.get('DATABASE_POOL_RECYCLE', pool_recycle)
if pool_recycle:
options.setdefault('pool_recycle', pool_recycle)
pool_timeout = settings.get('DATABASE_POOL_TIMEOUT')
if pool_timeout:
options.setdefault('pool_timeout', pool_timeout)
# Forward configuration to sqlalchemy and create the engine.
engine = sa.create_engine(url, **options)
if settings["DEBUG"]:
# Create a no-op listener if we're in debug mode.
from sqlalchemy.event import listen
listen(engine, "after_cursor_execute", lambda *a, **kw: None)
# Return the created engine.
return engine
