def __init__(self, session=None):
self._buffer = []
if session is None:
session = make_session(create_engine(http_uri))
self.session = session
self.dialect_cls = session.bind.dialect.__class__
def _test_server_version_any(self, uri):
engine_session = make_session(
create_engine(system_http_uri,
connect_args=dict(server_version='123.45.67.89')))
# Connection and version get initialized on first query:
engine_session.scalar('select 1')
ver = engine_session.get_bind().dialect.server_version_info
self.assertEqual(ver, (123, 45, 67, 89))
def test_disable_engine_reflection(self):
engine = self.session.connection().engine
url = str(engine.url)
prefix = 'clickhouse+{}://'.format(engine.driver)
if not url.startswith(prefix):
url = prefix + url.split('://')[1]
session = make_session(create_engine(url + '?engine_reflection=no'))
metadata = self.metadata(session=session)
columns = [Column('x', types.Int32)] + [engines.Log()]
table = Table('test_reflect', metadata, *columns)
with self.create_table(table):
metadata.clear() # reflect from clean state
self.assertFalse(metadata.tables)
table = Table('test_reflect', metadata, autoload=True)
self.assertIsNone(getattr(table, 'engine', None))
def __init__(self, credentials):
self.host = credentials['host']
self.db = credentials['db']
self.ch = sa.create_engine(
f"clickhouse://*****:*****@{credentials['host']}:8123/{credentials['db']}"
)
self.client = Client(host=credentials['host'],
password=credentials['password'])
self.client.execute('CREATE DATABASE IF NOT EXISTS amdattds;')
self.pandahouse_host = f"http://{credentials['host']}:8123"
self.conn = {
'host': self.pandahouse_host,
'database': self.db,
'password': credentials['password']
}
self.session = make_session(self.ch)
metadata = MetaData(bind=self.ch)
metadata.reflect(bind=self.ch)
self.connection = self.ch.connect()
import re
from sqlalchemy import create_engine
from clickhouse_sqlalchemy import make_session
from tests.config import http_uri, native_uri, system_native_uri
http_engine = create_engine(http_uri)
http_session = make_session(http_engine)
http_stream_session = make_session(create_engine(http_uri + '?stream=1'))
native_engine = create_engine(native_uri)
native_session = make_session(native_engine)
system_native_session = make_session(create_engine(system_native_uri))
class MockedEngine(object):
prev_do_execute = None
prev_do_executemany = None
prev_get_server_version_info = None
prev_get_default_schema_name = None
def __init__(self, session=None):
self._buffer = []
if session is None:
session = make_session(create_engine(http_uri))
self.session = session
self.dialect_cls = session.bind.dialect.__class__
def get_session(connection='base'):
connection = ClickhouseStore.connection_str(connection)
engine = create_engine(connection)
session = make_session(engine)
return session
from sqlalchemy import create_engine, Column, Table, MetaData, literal
from clickhouse_sqlalchemy import types, engines
from clickhouse_sqlalchemy import make_session
from clickhouse_sqlalchemy.declarative import get_declarative_base
uri = 'clickhouse://*****:*****@web1:8123/csv_parser_db'
engine = create_engine(uri)
session = make_session(engine)
metadata = MetaData(bind=engine)
Base = get_declarative_base(metadata=metadata)
class Test(Base):
id = Column(types.Int32, primary_key=True)
a = Column(types.String)
b = Column(types.String)
c = Column(types.String)
d = Column(types.String)
__table_args__ = (
engines.Memory(),
)
test_table = Test.__table__
data = [{'id': i, 'a': str(i), 'b': str(i + 3), 'c': str(i + 3), 'd': str(i + 3)} for i in xrange(10)]
import re
from sqlalchemy import create_engine
from clickhouse_sqlalchemy import make_session
from tests.config import uri, native_uri, system_native_uri
session = make_session(create_engine(uri))
native_session = make_session(create_engine(native_uri))
system_native_session = make_session(create_engine(system_native_uri))
class MockedEngine(object):
def __init__(self, engine_session=None):
self.buffer = buffer = []
engine_session = engine_session or session
self.dialect_cls = engine_session.bind.dialect
self.prev_do_execute = self.dialect_cls.do_execute
self.prev_do_executemany = self.dialect_cls.do_executemany
def do_executemany(cursor, statement, parameters, context=None):
buffer.append(statement)
def do_execute(cursor, statement, parameters, context=None):
buffer.append(statement)
self.dialect_cls.do_execute = do_execute