def test_reflect(self):
"""
checking, that after call metadata.reflect()
we have clickohouse-specific table, which have overridden join methods
"""
unbound_metadata = MetaData(bind=native_session.bind)
table = CHTable('test_reflect', unbound_metadata,
Column('x', types.Int32), engines.Log())
table.drop(native_session.bind, if_exists=True)
table.create(native_session.bind)
std_metadata = self.metadata()
self.assertFalse(std_metadata.tables)
std_metadata.reflect(only=[table.name])
table = std_metadata.tables.get(table.name)
assert table is not None
self.assertTrue(isinstance(table, CHTable))
query = table.select().join(text('another_table'),
table.c.x == 'xxx',
type='INNER',
strictness='ALL',
distribution='GLOBAL')
self.assertEqual(
self.compile(query), "SELECT x FROM test_reflect "
"GLOBAL ALL INNER JOIN another_table "
"ON x = %(x_1)s")
def test_get_table_names(self):
table = Table('test_reflect', self.metadata(),
Column('x', types.Int32), engines.Log())
table.create(self.session.bind)
insp = inspect(self.session.bind)
self.assertListEqual(insp.get_table_names(), ['test_reflect'])
def test_exists_describe_escaping(self):
metadata = self.metadata()
table = Table('.test', self.metadata(), Column('x', types.Int32),
engines.Log())
inspect(self.session.connection()).has_table(table.name)
with self.create_table(table):
metadata.clear() # reflect from clean state
self.assertFalse(metadata.tables)
Table('.test', metadata, autoload=True)
def test_insert(self):
table = Table('t', self.metadata(),
Column('x', types.String, primary_key=True),
engines.Log())
with self.create_table(table):
query = table.insert().values(x=literal_column("'test'"))
self.session.execute(query)
rv = self.session.execute(select(table.c.x)).scalar()
self.assertEqual(rv, 'test')
def test_reflect(self):
# checking, that after call metadata.reflect()
# we have a clickhouse-specific table, which has overridden join
# methods
session = self.session
metadata = self.metadata()
# ### Maybe: ###
# # session = native_session # database=test
# session = self.__class__.session
# same as in `self.metadata()` # database=default
# unbound_metadata = MetaData(bind=session.bind)
table = CHTable(
'test_reflect',
metadata,
Column('x', types.Int32),
engines.Log()
)
table.drop(session.bind, if_exists=True)
table.create(session.bind)
# Sub-test: ensure the `metadata.reflect` makes a CHTable
metadata.clear() # reflect from clean state
self.assertFalse(metadata.tables)
metadata.reflect(only=[table.name])
table2 = metadata.tables.get(table.name)
self.assertIsNotNone(table2)
self.assertListEqual([c.name for c in table2.columns], ['x'])
self.assertTrue(isinstance(table2, CHTable))
# Sub-test: ensure `CHTable(..., autoload=True)` works too
metadata.clear()
table3 = CHTable('test_reflect', metadata, autoload=True)
self.assertListEqual([c.name for c in table3.columns], ['x'])
# Sub-test: check that they all reflected the same.
for table_x in [table, table2, table3]:
query = table_x.select().select_from(table_x.join(
text('another_table'),
table.c.x == 'xxx',
type='INNER',
strictness='ALL',
distribution='GLOBAL'
))
self.assertEqual(
self.compile(query),
"SELECT test_reflect.x FROM test_reflect "
"GLOBAL ALL INNER JOIN another_table "
"ON test_reflect.x = %(x_1)s"
)
def test_reflect_generic_table(self):
# checking, that generic table columns are reflected properly
metadata = self.metadata()
table = Table('test_reflect', metadata, Column('x', types.Int32),
engines.Log())
self.session.execute('DROP TABLE IF EXISTS test_reflect')
table.create(self.session.bind)
# Sub-test: ensure the `metadata.reflect` makes a CHTable
metadata.clear() # reflect from clean state
self.assertFalse(metadata.tables)
table = Table('test_reflect', metadata, autoload=True)
self.assertListEqual([c.name for c in table.columns], ['x'])
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 test_log(self):
engine = engines.Log()
with self._test_table(engine) as (table, engine):
self.assertIsInstance(engine, engines.Log)
