Python session.create_engine方法代碼示例

# 需要導入模塊: from oslo_db.sqlalchemy import session [as 別名]
# 或者: from oslo_db.sqlalchemy.session import create_engine [as 別名]
def run_migrations_online():
    set_mysql_engine()
    engine = session.create_engine(neutron_config.database.connection)

    connection = engine.connect()
    context.configure(
        connection=connection,
        target_metadata=target_metadata,
        version_table=alembic_migrations.VPNAAS_VERSION_TABLE
    )
    try:
        with context.begin_transaction():
            context.run_migrations()
    finally:
        connection.close()
        engine.dispose() 

# 需要導入模塊: from oslo_db.sqlalchemy import session [as 別名]
# 或者: from oslo_db.sqlalchemy.session import create_engine [as 別名]
def run_migrations_online():
    set_mysql_engine()
    engine = session.create_engine(neutron_config.database.connection)

    connection = engine.connect()
    context.configure(
        connection=connection,
        target_metadata=target_metadata,
        version_table=DR_VERSION_TABLE
    )
    try:
        with context.begin_transaction():
            context.run_migrations()
    finally:
        connection.close()
        engine.dispose() 

# 需要導入模塊: from oslo_db.sqlalchemy import session [as 別名]
# 或者: from oslo_db.sqlalchemy.session import create_engine [as 別名]
def run_migrations_online():
    set_mysql_engine()
    engine = session.create_engine(neutron_config.database.connection)

    connection = engine.connect()
    context.configure(
        connection=connection,
        target_metadata=target_metadata,
        include_object=include_object,
        version_table=L2GW_VERSION_TABLE
    )

    try:
        with context.begin_transaction():
            context.run_migrations()
    finally:
        connection.close()
        engine.dispose() 

# 需要導入模塊: from oslo_db.sqlalchemy import session [as 別名]
# 或者: from oslo_db.sqlalchemy.session import create_engine [as 別名]
def run_migrations_online():
    set_mysql_engine()
    engine = session.create_engine(neutron_config.database.connection)

    connection = engine.connect()
    context.configure(
        connection=connection,
        target_metadata=target_metadata,
        include_object=include_object,
        version_table=ODL_VERSION_TABLE
    )

    try:
        with context.begin_transaction():
            context.run_migrations()
    finally:
        connection.close()
        engine.dispose() 

# 需要導入模塊: from oslo_db.sqlalchemy import session [as 別名]
# 或者: from oslo_db.sqlalchemy.session import create_engine [as 別名]
def run_migrations_online():
    set_mysql_engine()
    engine = session.create_engine(neutron_config.database.connection)

    connection = engine.connect()
    context.configure(
        connection=connection,
        target_metadata=target_metadata,
        include_object=include_object,
        version_table=MIDONET_VERSION_TABLE
    )
    try:
        with context.begin_transaction():
            context.run_migrations()
    finally:
        connection.close()
        engine.dispose() 

# 需要導入模塊: from oslo_db.sqlalchemy import session [as 別名]
# 或者: from oslo_db.sqlalchemy.session import create_engine [as 別名]
def run_migrations_online():
    set_mysql_engine()
    engine = session.create_engine(neutron_config.database.connection)

    connection = engine.connect()
    context.configure(
        connection=connection,
        target_metadata=target_metadata,
        version_table=BGPVPN_VERSION_TABLE
    )
    try:
        with context.begin_transaction():
            context.run_migrations()
    finally:
        connection.close()
        engine.dispose() 

# 需要導入模塊: from oslo_db.sqlalchemy import session [as 別名]
# 或者: from oslo_db.sqlalchemy.session import create_engine [as 別名]
def run_migrations_online():
    set_mysql_engine()
    engine = session.create_engine(neutron_config.database.connection)

    connection = engine.connect()
    context.configure(
        connection=connection,
        target_metadata=target_metadata,
        include_object=include_object,
        version_table=DF_VERSION_TABLE
    )

    try:
        with context.begin_transaction():
            context.run_migrations()
    finally:
        connection.close()
        engine.dispose() 

# 需要導入模塊: from oslo_db.sqlalchemy import session [as 別名]
# 或者: from oslo_db.sqlalchemy.session import create_engine [as 別名]
def run_migrations_online():
    """Run migrations in 'online' mode.

    In this scenario we need to create an Engine
    and associate a connection with the context.

    """
    engine = session.create_engine(
        get_sqlalchemy_url())
    connection = engine.connect()
    context.configure(
        connection=connection,
        target_metadata=target_metadata
    )

    try:
        with context.begin_transaction():
            context.run_migrations()
    finally:
        connection.close() 

# 需要導入模塊: from oslo_db.sqlalchemy import session [as 別名]
# 或者: from oslo_db.sqlalchemy.session import create_engine [as 別名]
def test_combine_params(self):
        with self._fixture() as ce:
            engines.create_engine(
                "mysql+pymysql://foo:bar@bat/"
                "?charset=utf8&param_file=tripleo.cnf",
                connection_parameters="plugin=sqlalchemy_collectd&"
                                      "collectd_host=127.0.0.1&"
                                      "bind_host=192.168.1.5")

        self.assertEqual(
            ce.mock_calls[0][1][0].query,
            {
                'bind_host': '192.168.1.5',
                'charset': 'utf8',
                'collectd_host': '127.0.0.1',
                'param_file': 'tripleo.cnf',
                'plugin': 'sqlalchemy_collectd'
            }
        ) 

# 需要導入模塊: from oslo_db.sqlalchemy import session [as 別名]
# 或者: from oslo_db.sqlalchemy.session import create_engine [as 別名]
def test_combine_multi_params(self):
        with self._fixture() as ce:
            engines.create_engine(
                "mysql+pymysql://foo:bar@bat/"
                "?charset=utf8&param_file=tripleo.cnf&plugin=connmon",
                connection_parameters="plugin=sqlalchemy_collectd&"
                                      "collectd_host=127.0.0.1&"
                                      "bind_host=192.168.1.5")

        self.assertEqual(
            ce.mock_calls[0][1][0].query,
            {
                'bind_host': '192.168.1.5',
                'charset': 'utf8',
                'collectd_host': '127.0.0.1',
                'param_file': 'tripleo.cnf',
                'plugin': ['connmon', 'sqlalchemy_collectd']
            }
        ) 

# 需要導入模塊: from oslo_db.sqlalchemy import session [as 別名]
# 或者: from oslo_db.sqlalchemy.session import create_engine [as 別名]
def _create_engine(connection, **engine_args):
    LOG.debug('Sql connection: please check "sql_connection" property in '
              'barbican configuration file; Args: %s', engine_args)

    engine = session.create_engine(connection, **engine_args)

    # TODO(jfwood): if 'mysql' in connection_dict.drivername:
    # TODO(jfwood): sqlalchemy.event.listen(_ENGINE, 'checkout',
    # TODO(jfwood):                         ping_listener)

    # Wrap the engine's connect method with a retry decorator.
    engine.connect = wrap_db_error(engine.connect)

    return engine 

# 需要導入模塊: from oslo_db.sqlalchemy import session [as 別名]
# 或者: from oslo_db.sqlalchemy.session import create_engine [as 別名]
def _setUp(self):
        self._engine = session.create_engine('sqlite:///:memory:')
        self.Session = sa.orm.sessionmaker(bind=self._engine)
        self.external_id = 'EXTERNAL_ID'
        models.BASE.metadata.create_all(self._engine)
        self._load_sample_data() 

# 需要導入模塊: from oslo_db.sqlalchemy import session [as 別名]
# 或者: from oslo_db.sqlalchemy.session import create_engine [as 別名]
def setUp(self):
        super(DBManageTestCase, self).setUp()
        self.sbehaviors = secret_behaviors.SecretBehaviors(self.client)
        self.cbehaviors = container_behaviors.ContainerBehaviors(self.client)

        db_url = BCONF.sql_connection

        time.sleep(5)
        # Setup session for tests to query DB
        engine = session.create_engine(db_url)
        self.conn = engine.connect() 

# 需要導入模塊: from oslo_db.sqlalchemy import session [as 別名]
# 或者: from oslo_db.sqlalchemy.session import create_engine [as 別名]
def __init__(self, db_connection, library_path, login, slot_id):
        self.dry_run = False
        self.db_engine = session.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() 

# 需要導入模塊: from oslo_db.sqlalchemy import session [as 別名]
# 或者: from oslo_db.sqlalchemy.session import create_engine [as 別名]
def _fixture(self):
        from sqlalchemy import create_engine

        def _mock_create_engine(*arg, **kw):
            return create_engine("sqlite://")

        return mock.patch(
            "oslo_db.sqlalchemy.engines.sqlalchemy.create_engine",
            side_effect=_mock_create_engine)