def test_engine_from_config_custom(self): from sqlalchemy import util tokens = __name__.split(".") class MyDialect(MockDialect): engine_config_types = { "foobar": int, "bathoho": util.bool_or_str("force"), } def __init__(self, foobar=None, bathoho=None, **kw): self.foobar = foobar self.bathoho = bathoho global dialect dialect = MyDialect registry.register( "mockdialect.barb", ".".join(tokens[0:-1]), tokens[-1] ) config = { "sqlalchemy.url": "mockdialect+barb://", "sqlalchemy.foobar": "5", "sqlalchemy.bathoho": "false", } e = engine_from_config(config, _initialize=False) eq_(e.dialect.foobar, 5) eq_(e.dialect.bathoho, False)
def test_register_dotted(self): from sqlalchemy.dialects import registry registry.register("mockdialect.foob", __name__, "MockDialect") e = create_engine("mockdialect+foob://") assert isinstance(e.dialect, MockDialect)
def setup(cls, driver, user, pwd, host, db, echo=False, params=None, dialects=None, **kwargs): """ Setup function that will configure all the required resources for communicating with the database :param driver: Database driver that will be used when the server need to store persistant data :param user: Database user :param pwd: Database password :param host: Database host :param db: Database schema :param echo: Boolean for printing sql request default: false :return: N/A """ from sqlalchemy import create_engine from sqlalchemy.orm import scoped_session, sessionmaker from sqlalchemy.ext.declarative import declarative_base if dialects is not None: from sqlalchemy.dialects import registry for name, values in dialects.items(): registry.register(name, values['module'], values['class']) database_uri = "{}://{}:{}@{}/{}".format(driver, user, pwd, host, db) \ + ('?{}'.format(cls._params(params)) if params is not None else '') cls.engine = create_engine(database_uri, echo=echo) cls._sessionmaker = sessionmaker(bind=cls.engine) cls.session = scoped_session(cls._sessionmaker) cls.Model = declarative_base(cls.session) cls.Model.query = cls.session.query_property() cls._sqlalchemy = SQLAlchemy(engine=cls.engine, query=cls.session.query_property(), session=cls.session, model=cls.Model) cls.session.close()
def test_on_connect_url(self): """test #6586""" tokens = __name__.split(".") canary = mock.Mock() class MyDialect(MockDialect): def on_connect_url(self, url): canary.on_connect_url(url) global dialect dialect = MyDialect registry.register( "mockdialect.ocu", ".".join(tokens[0:-1]), tokens[-1] ) create_engine("mockdialect+ocu://foo:bar@host/test") eq_( canary.mock_calls, [ mock.call.on_connect_url( url.URL.create( drivername="mockdialect+ocu", username="******", password="******", host="host", database="test", ) ) ], )
def connection_str(connection='base'): registry.register('clickhouse', 'clickhouse_sqlalchemy.drivers.base', 'dialect') conf = get_conf('database', 'CLICKHOUSE').get(connection) connection = 'clickhouse://{user}:{password}@{host}:{port}/{db}'.format( **conf) return connection
def test_wrapper_hooks(self): def get_dialect_cls(url): url.drivername = "sqlite" return url.get_dialect() global WrapperFactory WrapperFactory = Mock() WrapperFactory.get_dialect_cls.side_effect = get_dialect_cls registry.register("wrapperdialect", __name__, "WrapperFactory") from sqlalchemy.dialects import sqlite e = create_engine("wrapperdialect://") eq_(e.dialect.name, "sqlite") assert isinstance(e.dialect, sqlite.dialect) eq_( WrapperFactory.mock_calls, [ call.get_dialect_cls(url.make_url("sqlite://")), call.engine_created(e), ], )
def test_wrapper_hooks(self): def get_dialect_cls(url): url = url.set(drivername="sqlite") return url.get_dialect() global WrapperFactory WrapperFactory = Mock() WrapperFactory.get_dialect_cls.side_effect = get_dialect_cls registry.register("wrapperdialect", __name__, "WrapperFactory") from sqlalchemy.dialects import sqlite e = create_engine("wrapperdialect://") eq_(e.dialect.name, "sqlite") assert isinstance(e.dialect, sqlite.dialect) eq_( WrapperFactory.mock_calls, [ call.get_dialect_cls(url.make_url("wrapperdialect://")), call.engine_created(e), ], )
def test_engine_from_config_custom(self): from sqlalchemy import util tokens = __name__.split(".") class MyDialect(MockDialect): engine_config_types = { "foobar": int, "bathoho": util.bool_or_str('force') } def __init__(self, foobar=None, bathoho=None, **kw): self.foobar = foobar self.bathoho = bathoho global dialect dialect = MyDialect registry.register("mockdialect.barb", ".".join(tokens[0:-1]), tokens[-1]) config = { "sqlalchemy.url": "mockdialect+barb://", "sqlalchemy.foobar": "5", "sqlalchemy.bathoho": "false" } e = engine_from_config(config, _initialize=False) eq_(e.dialect.foobar, 5) eq_(e.dialect.bathoho, False)
def test_register_per_dbapi(self): from sqlalchemy.dialects import registry registry.register("mysql.my_mock_dialect", __name__, "MockDialect") e = create_engine("mysql+my_mock_dialect://") assert isinstance(e.dialect, MockDialect)
def test_register_legacy(self): tokens = __name__.split(".") global dialect dialect = MockDialect registry.register("mockdialect.foob", ".".join(tokens[0:-1]), tokens[-1]) e = create_engine("mockdialect+foob://") assert isinstance(e.dialect, MockDialect)
def test_register_legacy(self): from sqlalchemy.dialects import registry tokens = __name__.split(".") global dialect dialect = MockDialect registry.register("mockdialect.foob", ".".join(tokens[0:-1]), tokens[-1]) e = create_engine("mockdialect+foob://") assert isinstance(e.dialect, MockDialect)
def get_dialect(dialect_name: str) -> DefaultDialect: if dialect_name.lower() in ['postgresql', 'pg']: dialect_obj = postgresql.dialect() elif dialect_name.lower() in ['clickhouse', 'ch']: registry.register("clickhouse", "sqlalchemy_clickhouse.base", "dialect") dialect_obj = clickhouse.dialect() else: msg = 'Unknown dialect %s. Cannot find it to compile query.' % dialect_name raise QueryCompilerException(msg) return dialect_obj
def test_is_async_to_create_engine(self, is_async): def get_dialect_cls(url): url = url.set(drivername="sqlite") return url.get_dialect() global MockDialectGetDialect MockDialectGetDialect = Mock() MockDialectGetDialect.get_dialect_cls.side_effect = get_dialect_cls MockDialectGetDialect.get_async_dialect_cls.side_effect = ( get_dialect_cls) registry.register("mockdialect", __name__, "MockDialectGetDialect") from sqlalchemy.dialects import sqlite kw = {} if is_async is not None: kw["_is_async"] = is_async e = create_engine("mockdialect://", **kw) eq_(e.dialect.name, "sqlite") assert isinstance(e.dialect, sqlite.dialect) if is_async: eq_( MockDialectGetDialect.mock_calls, [ call.get_async_dialect_cls(url.make_url("mockdialect://")), call.engine_created(e), ], ) else: eq_( MockDialectGetDialect.mock_calls, [ call.get_dialect_cls(url.make_url("mockdialect://")), call.engine_created(e), ], ) MockDialectGetDialect.reset_mock() u = url.make_url("mockdialect://") u.get_dialect(**kw) if is_async: eq_( MockDialectGetDialect.mock_calls, [call.get_async_dialect_cls(u)], ) else: eq_( MockDialectGetDialect.mock_calls, [call.get_dialect_cls(u)], )
def create_sqlite_fixture(*ordered_actions, **kwargs): """Create a SQLite fixture. """ scope = kwargs.pop("scope", "function") tables = kwargs.pop("tables", None) session = kwargs.pop("session", None) decimal_warnings = kwargs.pop("decimal_warnings", False) if len(kwargs): raise KeyError("Unsupported Arguments: {}".format(kwargs)) registry.register("sqlite.pmrsqlite", __name__, "PMRSQLiteDialect") @pytest.fixture(scope=scope) def _(): # XXX: Ideally we eventually make use of the shared memory cache to enable connecting by # credentials with sqlite. # database_name = "file:{}?mode=memory&cache=shared".format(next(_database_names)) database_name = "" raw_engine = create_engine( "sqlite+pmrsqlite:///{}".format(database_name)) # This *must* happen before the connection occurs (implicitly in `EngineManager`). event.listen(raw_engine, "connect", enable_foreign_key_checks) engine_manager = EngineManager(raw_engine, ordered_actions, tables=tables) for engine in engine_manager.manage(session=session): with filter_sqlalchemy_warnings( decimal_warnings_enabled=(not decimal_warnings)): assign_fixture_credentials( raw_engine, drivername="sqlite+pmrsqlite", host="", port=None, database=database_name, username="", password="", ) yield engine event.remove(raw_engine, "connect", enable_foreign_key_checks) return _
def register_engine(cls, name, driver, user, pwd, host, db, params=None, dialects=None, echo=False): from sqlalchemy import create_engine from sqlalchemy.orm import scoped_session, sessionmaker from sqlalchemy.ext.declarative import declarative_base if dialects is not None: from sqlalchemy.dialects import registry for registry_name, values in dialects.items(): registry.register(registry_name, values['module'], values['class']) database_uri = "{}://{}:{}@{}/{}".format(driver, user, pwd, host, db) \ + (';{}'.format(cls._params(params)) if params is not None else '') cls.engines[name] = create_engine(database_uri, echo=echo) cls._sessionmakers[name] = sessionmaker(bind=cls.engines[name]) cls.sessions[name] = scoped_session(cls._sessionmakers[name]) cls.models[name] = declarative_base(cls.sessions[name]) cls.models[name].query = cls.sessions[name].query_property() cls._sqlalchemy_array[name] = SQLAlchemy(engine=cls.engines[name], query=cls.sessions[name].query_property(), session=cls.sessions[name], model=cls.models[name]) cls.sessions[name].close()
def test_no_warning_for_dual_dbapi_clsmethod(self): """The dbapi() class method is renamed to import_dbapi(), so that the .dbapi attribute can be exclusively an instance attribute. Dialect classes will likely have both a dbapi() classmethod as well as an import_dbapi() class method to maintain cross-compatibility. Make sure these updated classes don't get a warning and that the new method is used. """ from sqlalchemy.dialects.sqlite import pysqlite from sqlalchemy.dialects import registry canary = mock.Mock() class MyDialect(pysqlite.SQLiteDialect_pysqlite): @classmethod def dbapi(cls): canary.dbapi() return __import__("sqlite3") @classmethod def import_dbapi(cls): canary.import_dbapi() return __import__("sqlite3") tokens = __name__.split(".") global dialect dialect = MyDialect registry.register("mockdialect2.sqlite", ".".join(tokens[0:-1]), tokens[-1]) # no warning e = create_engine("mockdialect2+sqlite://") eq_(canary.mock_calls, [mock.call.import_dbapi()]) sqlite3 = __import__("sqlite3") is_(e.dialect.dbapi, sqlite3)
def test_dbapi_clsmethod_renamed(self): """The dbapi() class method is renamed to import_dbapi(), so that the .dbapi attribute can be exclusively an instance attribute. """ from sqlalchemy.dialects.sqlite import pysqlite from sqlalchemy.dialects import registry canary = mock.Mock() class MyDialect(pysqlite.SQLiteDialect_pysqlite): @classmethod def dbapi(cls): canary() return __import__("sqlite3") tokens = __name__.split(".") global dialect dialect = MyDialect registry.register("mockdialect1.sqlite", ".".join(tokens[0:-1]), tokens[-1]) with expect_deprecated( r"The dbapi\(\) classmethod on dialect classes has " r"been renamed to import_dbapi\(\). Implement an " r"import_dbapi\(\) classmethod directly on class " r".*MyDialect.* to remove this warning; the old " r".dbapi\(\) classmethod may be maintained for backwards " r"compatibility."): e = create_engine("mockdialect1+sqlite://") eq_(canary.mock_calls, [mock.call()]) sqlite3 = __import__("sqlite3") is_(e.dialect.dbapi, sqlite3)
class AscendEngineSpec(ImpalaEngineSpec): """Engine spec for Ascend.io (Hive2+TLS) using Cloudera's Impala""" engine = "ascend" registry.register("ascend", "impala.sqlalchemy", "ImpalaDialect") engine_name = "Ascend" _time_grain_expressions = { None: "{col}", "PT1S": "DATE_TRUNC('second', {col})", "PT1M": "DATE_TRUNC('minute', {col})", "PT1H": "DATE_TRUNC('hour', {col})", "P1D": "DATE_TRUNC('day', {col})", "P1W": "DATE_TRUNC('week', {col})", "P1M": "DATE_TRUNC('month', {col})", "P0.25Y": "DATE_TRUNC('quarter', {col})", "P1Y": "DATE_TRUNC('year', {col})", }
def register(): registry.register("rdsdataapi", "sqlalchemy_rdsdataapi", "RdsDataApiDialect")
"""PyTest configuration for SQLAlchemy-Dataflex.""" # coding=utf-8 # noinspection PyPackageRequirements import pytest from sqlalchemy.dialects import registry registry.register("dataflex.pyodbc", "sqlalchemy_dataflex.pyodbc", "DataflexDialect_pyodbc") pytest.register_assert_rewrite("sqlalchemy.testing.assertions") from sqlalchemy.testing.plugin.pytestplugin import *
from sqlalchemy.dialects import registry registry.register("drill", "sqlalchemy_drill.pyodbc", "DrillDialect_pyodbc") registry.register("drill.pyodbc", "sqlalchemy_drill.pyodbc", "DrillDialect_pyodbc") from sqlalchemy.testing.plugin.pytestplugin import *
from sqlalchemy.dialects import registry registry.register("ibmi", "sqlalchemy_ibmi.backend", "AS400Dialect_pyodbc")
__version__ = '0.4' from sqlalchemy.dialects import registry registry.register("redshift", "redshift_sqlalchemy.dialect", "RedshiftDialect") registry.register("redshift+psycopg2", "redshift_sqlalchemy.dialect", "RedshiftDialect")
"__call__":dialect_init_wrap(tp_factory)(dialect) })(dialect) bundled_drivers = { "drizzle":"mysqldb".split(), "firebird":"kinterbasdb fdb".split(), "mssql":"pyodbc adodbapi pymssql zxjdbc mxodbc".split(), "mysql":"mysqldb oursql pyodbc zxjdbc mysqlconnector pymysql gaerdbms cymysql".split(), "oracle":"cx_oracle zxjdbc".split(), "postgresql":"psycopg2 pg8000 pypostgresql zxjdbc".split(), "sqlite":"pysqlite".split(), "sybase":"pysybase pyodbc".split() } for db, drivers in bundled_drivers.items(): try: globals()[dialect_name(db)] = dialect_maker(db, None) registry.register("gevent_%s" % db, "sqlalchemy_gevent", dialect_name(db)) for driver in drivers: globals()[dialect_name(db,driver)] = dialect_maker(db, driver) registry.register("gevent_%s.%s" % (db,driver), "sqlalchemy_gevent", dialect_name(db,driver)) except ImportError: # drizzle was removed in sqlalchemy v1.0 pass def patch_all(): for db, drivers in bundled_drivers.items(): registry.register(db, "sqlalchemy_gevent", dialect_name(db)) for driver in drivers: registry.register("%s.%s" % (db,driver), "sqlalchemy_gevent", dialect_name(db,driver))
# See the License for the specific language governing permissions and # limitations under the License. # some inspiration from Dropbox's PyHive from __future__ import absolute_import import re from sqlalchemy.dialects import registry from sqlalchemy.engine.default import DefaultDialect from sqlalchemy.sql.compiler import IdentifierPreparer, GenericTypeCompiler from sqlalchemy.types import (BOOLEAN, SMALLINT, BIGINT, TIMESTAMP, FLOAT, DECIMAL, Integer, Float, String) registry.register('impala', 'impala.sqlalchemy', 'ImpalaDialect') class TINYINT(Integer): __visit_name__ = 'TINYINT' class INT(Integer): __visit_name__ = 'INT' class DOUBLE(Float): __visit_name__ = 'DOUBLE' class STRING(String):
from sqlalchemy.dialects import registry registry.register("postgresql.oedialect", "oedialect.dialect", "OEDialect") from sqlalchemy.testing.plugin.pytestplugin import *
from sqlalchemy.dialects import registry __version__ = "0.8" # https://bitbucket.org/zzzeek/sqlalchemy/issues/3536/engine-entrypoint-plugins registry.register("sphinx", "sqlalchemy_sphinx.mysqldb", "Dialect") registry.register("sphinx.cymsql", "sqlalchemy_sphinx.cymysql", "Dialect") registry.register("sphinx.mysqldb", "sqlalchemy_sphinx.mysqldb", "Dialect")
__version__ = '0.1' from sqlalchemy.dialects import registry registry.register("h2", "sqlalchemy_h2.dialect.zxjdbc", "dialect") registry.register("h2.zxjdbc", "sqlalchemy_h2.dialect.zxjdbc", "dialect")
# distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from __future__ import absolute_import import re from sqlalchemy.dialects import registry from sqlalchemy.dialects.postgresql.base import PGDialect from sqlalchemy.engine.default import DefaultDialect from sqlalchemy.types import (BOOLEAN, SMALLINT, BIGINT, TIMESTAMP, FLOAT, DECIMAL, Integer, Float, String) registry.register('impala', 'impala.sqlalchemy', 'ImpalaDialect') class TINYINT(Integer): __visit_name__ = 'TINYINT' class INT(Integer): __visit_name__ = 'INT' class DOUBLE(Float): __visit_name__ = 'DOUBLE' class STRING(String):
from sqlalchemy.dialects import registry registry.register("exa.pyodbc", "sqlalchemy_exasol.pyodbc", "EXADialect_pyodbc") registry.register("exa.turbodbc", "sqlalchemy_exasol.turbodbc", "EXADialect_turbodbc") from sqlalchemy.testing.plugin.pytestplugin import *
__version__ = '0.1.8' from sqlalchemy.dialects import registry #registry.register("netezza", "sqlalchemy_netezza.pyodbc", "NetezzaDialect") #registry.register("netezza.pyodbc", "sqlalchemy_netezza.pyodbc", "NetezzaDialect") registry.register("netezza", "netezza_dialect", "NetezzaODBC") registry.register("netezza.pyodbc", "netezza_dialect", "NetezzaODBC")
from sqlalchemy.dialects import registry registry.register("pandas", "calchipan.base", "PandasDialect") registry.register("pandas.calchipan", "calchipan.base", "PandasDialect") from sqlalchemy.testing import runner def setup_py_test(): runner.setup_py_test() if __name__ == '__main__': runner.main()
awvspy.awvsresult ~~~~~~~~~~~~~~~~~~ This module contains the awvs scan result. """ import sys import logging import hashlib import datetime from sqlalchemy.dialects import registry from sqlalchemy import create_engine from awvspy.awvsmodels import WVSScans from awvspy.dbapi import make_session_scope,get_session registry.register("access", "sqlalchemy_access.pyodbc", "AccessDialect_pyodbc") registry.register("access.pyodbc", "sqlalchemy_access.pyodbc", "AccessDialect_pyodbc") if sys.platform == 'win32': import pyodbc class AWVSResult(object): def __init__(self): pass engine = create_engine("access+pyodbc://vulnscanresults") session = get_session(engine=engine) with make_session_scope(session) as session: wvs_scans = session.query(WVSScans).all()
from sqlalchemy import * from sqlalchemy.dialects import registry from sqlalchemy_teradata.dialect import TeradataDialect from sqlalchemy.testing import fixtures from sqlalchemy.testing.plugin.pytestplugin import * from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import relation, sessionmaker registry.register("tdalchemy", "sqlalchemy_teradata.dialect", "TeradataDialect") class DialectSQLAlchUsageTest(fixtures.TestBase): """ This usage test is meant to serve as documentation and follows the tutorial here: http://docs.sqlalchemy.org/en/latest/core/tutorial.html but with the dialect being developed """ # Note: this test uses pytest which captures stdout by default, pass -s to disable def setup(self): self.dialect = TeradataDialect() # add credentials here passw = "" user = "" self.engine = create_engine('teradata://'+user+':'+passw+'@<host>:<port>') self.conn = self.engine.connect() # build a table with columns self.metadata = MetaData() self.users = Table('my_users', self.metadata,
__version__ = '0.8' from sqlalchemy.dialects import registry registry.register("drill", "sqlalchemy_drill.sadrill", "DrillDialect_sadrill") registry.register("drill.sadrill", "sqlalchemy_drill.sadrill", "DrillDialect_sadrill")
def register_fdw_support(url): class PGDialectFdw(url.get_dialect()): """A sqldialect based on psyopg2 for managing foreign tables """ ddl_compiler = PGDDLCompilerFdw construct_arguments = [ (Table, { "server": None, "options": None }) ] @reflection.cache def get_primary_keys(self, connection, table_name, schema=None, **kw): if schema is not None: current_schema = schema else: current_schema = self.default_schema_name PK_SQL = """ SELECT cu.column_name FROM information_schema.table_constraints tc INNER JOIN information_schema.key_column_usage cu on cu.constraint_name = tc.constraint_name and cu.table_name = tc.table_name and cu.table_schema = tc.table_schema WHERE cu.table_name = :table_name and constraint_type = 'PRIMARY KEY' and cu.table_schema = :schema; """ t = sql.text(PK_SQL, typemap={'attname': sqltypes.Unicode}) c = connection.execute(t, table_name=table_name, schema=current_schema) primary_keys = [r[0] for r in c.fetchall()] return primary_keys @reflection.cache def get_table_names(self, connection, schema=None, **kw): if schema is not None: current_schema = schema else: current_schema = self.default_schema_name result = connection.execute( sql.text( "SELECT relname FROM pg_class c " "WHERE relkind in ('r', 'f') " "AND '%s' = (select nspname from pg_namespace n " "where n.oid = c.relnamespace) " % current_schema, typemap={'relname': sqltypes.Unicode} ) ) return [row[0] for row in result] @reflection.cache def get_table_oid(self, connection, table_name, schema=None, **kw): """Fetch the oid for schema.table_name. Several reflection methods require the table oid. The idea for using this method is that it can be fetched one time and cached for subsequent calls. """ table_oid = None if schema is not None: schema_where_clause = "n.nspname = :schema" else: schema_where_clause = "pg_catalog.pg_table_is_visible(c.oid)" query = """ SELECT c.oid FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE (%s) AND c.relname = :table_name AND c.relkind in ('r', 'v', 'f') """ % schema_where_clause # Since we're binding to unicode, table_name and schema_name must be # unicode. table_name = str(table_name) bindparams = [sql.bindparam('table_name', type_=sqltypes.Unicode)] if schema is not None: schema = str(schema) bindparams.append(sql.bindparam('schema', type_=sqltypes.Unicode)) s = sql.text( query, bindparams=bindparams, typemap={'oid': sqltypes.Integer}) c = connection.execute(s, table_name=table_name, schema=schema) table_oid = c.scalar() if table_oid is None: raise exc.NoSuchTableError(table_name) return table_oid @reflection.cache def get_foreign_table_options(self, connection, pgfdw_table): oid = self.get_table_oid(connection, pgfdw_table.name, pgfdw_table.schema) query = """ SELECT ftoptions, srvname FROM pg_foreign_table t inner join pg_foreign_server s ON t.ftserver = s.oid WHERE t.ftrelid = :oid """ s = sql.text( query, bindparams=[sql.bindparam('oid', type_=sqltypes.Integer)], typemap={ 'ftoptions': ARRAY(sqltypes.Unicode), 'srvname': sqltypes.Unicode } ) c = connection.execute(s, oid=oid) options, srv_name = c.fetchone() pgfdw_table.pgfdw_server = srv_name pgfdw_table.pgfdw_options = dict([ option.split('=', 1) for option in options ]) if options is not None else {} m = sys.modules[PGDialectFdw.__module__] setattr(m, PGDialectFdw.__name__, PGDialectFdw) setattr(m, 'dialect', PGDialectFdw) registry.register( url.drivername, PGDialectFdw.__module__, PGDialectFdw.__name__, ) return PGDialectFdw
from sqlalchemy.dialects.postgresql.psycopg2 import PGDialect_psycopg2 from sqlalchemy.dialects import registry from .pool import GreenletPool class PGDGreen(PGDialect_psycopg2): '''PostgreSql dialect using psycopg2 and greenlet to obtain an implicit asynchronous database connection. ''' poolclass = GreenletPool is_green = True @classmethod def dbapi(cls): from odm.dialects.postgresql import green return green def create_connect_args(self, url): args, opts = super().create_connect_args(url) opts.pop('pool_size', None) opts.pop('pool_timeout', None) return [[], opts] registry.register("postgresql.green", "odm.dialects.postgresql", "PGDGreen")
#!/usr/bin/env python from sqlalchemy.dialects import registry from sqlalchemy.testing import runner registry.register("monetdb", "sqlalchemy_monetdb.dialect", "MonetDialect") def setup_py_test(): runner.setup_py_test() if __name__ == '__main__': runner.main()
from six import string_types, iteritems import sqlalchemy from sqlalchemy import BigInteger from sqlalchemy import Text from sqlalchemy.types import TypeDecorator, TEXT, UserDefinedType from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.ext.mutable import Mutable from sqlalchemy.dialects import postgresql, mysql, sqlite from sqlalchemy import func Base = declarative_base() from sqlalchemy.dialects import registry registry.register('spatialite', 'ambry.orm.dialects.spatialite', 'SpatialiteDialect') registry.register('postgis', 'ambry.orm.dialects.postgis', 'PostgisDialect') # http://stackoverflow.com/a/23175518/1144479 # SQLAlchemy does not map BigInt to Int by default on the sqlite dialect. # It should, but it doesnt. BigIntegerType = BigInteger() BigIntegerType = BigIntegerType.with_variant(postgresql.BIGINT(), 'postgresql') BigIntegerType = BigIntegerType.with_variant(mysql.BIGINT(), 'mysql') BigIntegerType = BigIntegerType.with_variant(sqlite.INTEGER(), 'sqlite') class Geometry(UserDefinedType): """Geometry type, to ensure that WKT text is properly inserted into the database with the GeomFromText() function.
from sqlalchemy.dialects import registry registry.register( "postgresql", "sqlalchemy_postgresql_pg8000.pg8000", "PGDialect_pg8000") registry.register("postgresql.pg8000", "sqlalchemy_postgresql_pg8000.pg8000", "PGDialect_pg8000") from sqlalchemy.testing import runner # use this in setup.py 'test_suite': # test_suite="run_tests.setup_py_test" def setup_py_test(): runner.setup_py_test() if __name__ == '__main__': runner.main()
# -*- coding: utf-8 -*- import os import random import string from sqlalchemy.dialects import registry registry.register("awsathena.rest", "pyathena.sqlalchemy_athena", "AthenaDialect") BASE_PATH = os.path.dirname(os.path.abspath(__file__)) S3_PREFIX = "test_pyathena" WORK_GROUP = "test-pyathena" SCHEMA = "test_pyathena_" + "".join( [random.choice(string.ascii_lowercase + string.digits) for _ in range(10)]) class Env(object): def __init__(self): self.region_name = os.getenv("AWS_DEFAULT_REGION", None) assert ( self.region_name ), "Required environment variable `AWS_DEFAULT_REGION` not found." self.s3_staging_dir = os.getenv("AWS_ATHENA_S3_STAGING_DIR", None) assert ( self.s3_staging_dir ), "Required environment variable `AWS_ATHENA_S3_STAGING_DIR` not found." ENV = Env()
from sqlalchemy.dialects import registry registry.register('aster', 'sqlalchemy_aster.jdbc', 'AsterDialect_jdbc') registry.register('aster.jdbc', 'sqlalchemy_aster.jdbc', 'AsterDialect_jdbc') from sqlalchemy.testing.plugin.pytestplugin import *
from sqlalchemy.dialects import registry registry.register("ocientdb", "sqlalchemy_ocientdb.pyodbc", "OcientDbDialect_pyodbc") registry.register("ocientdb.pyodbc", "sqlalchemy_ocientdb.pyodbc", "OcientDbDialect_pyodbc") from sqlalchemy.testing import runner runner.main()
__author__ = 'kbroughton' from sqlalchemy.dialects import registry registry.register("vertica", "torpedo_vertica.pyodbc", "Vertica_pyodbc") registry.register("vertica.pyodbc", "torpedo_vertica.pyodbc", "Vertica_pyodbc") from torpedo.testing import runner # use this in setup.py 'test_suite': # test_suite="run_tests.setup_py_test" def setup_py_test(): runner.setup_py_test() if __name__ == '__main__': runner.main()
from alembic.migration import MigrationContext from alembic.testing import eq_ from alembic.testing import eq_ignore_whitespace from alembic.testing.fixtures import TestBase class CustomDialect(default.DefaultDialect): name = "custom_dialect" try: from sqlalchemy.dialects import registry except ImportError: pass else: registry.register("custom_dialect", __name__, "CustomDialect") class CustomDialectImpl(impl.DefaultImpl): __dialect__ = "custom_dialect" transactional_ddl = False def render_type(self, type_, autogen_context): if type_.__module__ == __name__: autogen_context.imports.add("from %s import custom_dialect_types" % (__name__, )) is_external = True else: is_external = False if is_external and hasattr(self,
def test_register_base(self): registry.register("mockdialect", __name__, "MockDialect") e = create_engine("mockdialect://") assert isinstance(e.dialect, MockDialect)
# from .inserter import ValueInserter # import os # import logging from ambry.util import get_logger # , memoize # from ..database.inserter import SegmentedInserter, SegmentInserterFactory from contextlib import contextmanager import atexit import weakref # import pdb global_logger = get_logger(__name__) # global_logger.setLevel(logging.DEBUG) from sqlalchemy.dialects import registry registry.register( "spatialite", "ambry.database.dialects.spatialite", "SpatialiteDialect") registry.register( "postgis", "ambry.database.dialects.postgis", "PostgisDialect") connections = dict() def close_connections_at_exit(): """Close any connections that have not already been closed.""" for id_, (conn_ref, dsn, where) in connections.items(): conn = conn_ref()
from __future__ import absolute_import from __future__ import unicode_literals from distutils.version import StrictVersion import sqlalchemy if StrictVersion(sqlalchemy.__version__) >= StrictVersion('0.9.4'): from sqlalchemy.dialects import registry registry.register("hive", "pyhive.sqlalchemy_hive", "HiveDialect") registry.register("presto", "pyhive.sqlalchemy_presto", "PrestoDialect") from sqlalchemy.testing.plugin.pytestplugin import *
def test_register_base(self): from sqlalchemy.dialects import registry registry.register("mockdialect", __name__, "MockDialect") e = create_engine("mockdialect://") assert isinstance(e.dialect, MockDialect)
from sqlalchemy.dialects import registry registry.register("akiban", "sqlalchemy_akiban.dialect.psycopg2", "AkibanPsycopg2Dialect") registry.register("akiban.psycopg2", "sqlalchemy_akiban.dialect.psycopg2", "AkibanPsycopg2Dialect") from sqlalchemy.testing import runner runner.main()
#!/usr/bin/env python from sqlalchemy.dialects import registry from sqlalchemy.testing import runner registry.register("monetdb", "sqlalchemy_monetdb.base", "MDBDialect") def setup_py_test(): runner.setup_py_test() if __name__ == '__main__': runner.main()
from sqlalchemy.dialects import registry registry.register("db2", "ibm_db_sa.ibm_db", "DB2Dialect_ibm_db") registry.register("db2.ibm_db", "ibm_db_sa.ibm_db", "DB2Dialect_ibm_db") registry.register("db2.pyodbc", "ibm_db_sa.pyodbc", "DB2Dialect_pyodbc") registry.register("db2.zxjdbc", "ibm_db_sa.zxjdbc", "DB2Dialect_zxjdbc") registry.register("db2.pyodbc400", "ibm_db_sa.pyodbc", "AS400Dialect_pyodbc") registry.register("db2.zxjdbc400", "ibm_db_sa.zxjdbc", "AS400Dialect_zxjdbc") from sqlalchemy.testing import runner runner.main()
def test_register_dotted(self): registry.register("mockdialect.foob", __name__, "MockDialect") e = create_engine("mockdialect+foob://") assert isinstance(e.dialect, MockDialect)
def patch_all(): for db, drivers in bundled_drivers.items(): registry.register(db, "sqlalchemy_gevent", dialect_name(db)) for driver in drivers: registry.register("%s.%s" % (db,driver), "sqlalchemy_gevent", dialect_name(db,driver))
def test_register_per_dbapi(self): registry.register("mysql.my_mock_dialect", __name__, "MockDialect") e = create_engine("mysql+my_mock_dialect://") assert isinstance(e.dialect, MockDialect)
from pkg_resources import get_distribution __version__ = get_distribution('sqlalchemy-redshift').version from sqlalchemy.dialects import registry registry.register("redshift", "redshift_sqlalchemy.dialect", "RedshiftDialect") registry.register( "redshift+psycopg2", "redshift_sqlalchemy.dialect", "RedshiftDialect" )
from movr.transactions import start_ride_txn, end_ride_txn, add_user_txn, add_vehicle_txn, get_users_txn, get_user_txn, get_vehicles_txn, get_rides_txn, remove_user_txn, remove_vehicle_txn from cockroachdb.sqlalchemy import run_transaction from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker from sqlalchemy.dialects import registry registry.register("cockroachdb", "cockroachdb.sqlalchemy.dialect", "CockroachDBDialect") class MovR: """ Wraps the database connection. The class methods wrap database transactions. """ def __init__(self, conn_string): """ Establish a connection to the database, creating an Engine instance. Arguments: conn_string {String} -- CockroachDB connection string. """ self.engine = create_engine(conn_string, convert_unicode=True) def start_ride(self, city, rider_id, rider_city, vehicle_id): """ Wraps a `run_transaction` call that starts a ride. Arguments: city {String} -- The ride's city. rider_id {UUID} -- The user's unique ID. rider_city {String} -- The user's city. vehicle_id {UUID} -- The vehicle's unique ID.
__version__ = '0.01' from sqlalchemy.dialects import registry registry.register('aster', 'sqlalchemy_aster.jdbc', 'AsterDialect_jdbc') registry.register('aster.jdbc', 'sqlalchemy_aster.jdbc', 'AsterDialect_jdbc')
from sqlalchemy.dialects import registry registry.register("cubrid", "sqlalchemy_cubrid.cubriddb", "CubridDialect_cubriddb") registry.register("cubrid.cubriddb", "sqlalchemy_cubrid.cubriddb", "CubridDialect_cubriddb") from sqlalchemy.testing import runner runner.main()