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