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)