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()
def test_register_base(self):
registry.register("mockdialect", __name__, "MockDialect")
e = create_engine("mockdialect://")
assert isinstance(e.dialect, MockDialect)
