def test_discover_catalog_with_not_existing_table(self):
"""Validate if discovering catalog raises as exception when table not exist"""
# Create config to discover a not existing table
with self.assertRaises(snowflake.connector.errors.ProgrammingError):
test_utils.discover_catalog(
self.snowflake_conn, {
'tables':
f'{SCHEMA_NAME}.empty_table_2,{SCHEMA_NAME}.not_existing_table'
})
def setUp(self):
self.conn = test_utils.get_test_connection()
with connect_with_backoff(self.conn) as open_conn:
with open_conn.cursor() as cursor:
cursor.execute('CREATE TABLE a (`b c` int)')
cursor.execute('INSERT INTO a (`b c`) VALUES (1)')
self.catalog = test_utils.discover_catalog(self.conn, {})
self.catalog.streams[0].stream = 'some_stream_name'
self.catalog.streams[0].metadata = [{
'breadcrumb': (),
'metadata': {
'selected': True,
'table-key-properties': [],
'database-name': 'tap_mysql_test'
}
}, {
'breadcrumb': ('properties', 'b c'),
'metadata': {
'selected': True
}
}]
test_utils.set_replication_method_and_key(self.catalog.streams[0],
'FULL_TABLE', None)
def setUp(self):
self.conn = test_utils.get_test_connection()
with connect_with_backoff(self.conn) as open_conn:
with open_conn.cursor() as cursor:
cursor.execute('CREATE TABLE incremental (val int, updated datetime)')
cursor.execute('INSERT INTO incremental (val, updated) VALUES (1, \'2017-06-01\')')
cursor.execute('INSERT INTO incremental (val, updated) VALUES (2, \'2017-06-20\')')
cursor.execute('INSERT INTO incremental (val, updated) VALUES (3, \'2017-09-22\')')
cursor.execute('CREATE TABLE integer_incremental (val int, updated int)')
cursor.execute('INSERT INTO integer_incremental (val, updated) VALUES (1, 1)')
cursor.execute('INSERT INTO integer_incremental (val, updated) VALUES (2, 2)')
cursor.execute('INSERT INTO integer_incremental (val, updated) VALUES (3, 3)')
self.catalog = test_utils.discover_catalog(self.conn, {})
for stream in self.catalog.streams:
stream.metadata = [
{'breadcrumb': (),
'metadata': {
'selected': True,
'table-key-properties': [],
'database-name': 'tap_mysql_test'
}},
{'breadcrumb': ('properties', 'val'), 'metadata': {'selected': True}}
]
stream.stream = stream.table
test_utils.set_replication_method_and_key(stream, 'INCREMENTAL', 'updated')
def runTest(self):
conn = test_utils.get_test_connection()
with connect_with_backoff(conn) as open_conn:
with open_conn.cursor() as cur:
cur.execute('''
CREATE TABLE tab (
id INTEGER PRIMARY KEY,
a INTEGER,
b INTEGER)
''')
catalog = test_utils.discover_catalog(conn, {})
catalog.streams[0].stream = 'tab'
catalog.streams[0].metadata = [
{'breadcrumb': (), 'metadata': {'selected': True, 'database-name': 'tap_mysql_test'}},
{'breadcrumb': ('properties', 'a'), 'metadata': {'selected': True}}
]
test_utils.set_replication_method_and_key(catalog.streams[0], 'FULL_TABLE', None)
global SINGER_MESSAGES
SINGER_MESSAGES.clear()
tap_mysql.do_sync(conn, {}, catalog, {})
schema_message = list(filter(lambda m: isinstance(m, singer.SchemaMessage), SINGER_MESSAGES))[0]
self.assertTrue(isinstance(schema_message, singer.SchemaMessage))
# tap-mysql selects new fields by default. If a field doesn't appear in the schema, then it should be
# selected
expectedKeys = ['id', 'a', 'b']
self.assertEqual(schema_message.schema['properties'].keys(), set(expectedKeys))
def init_tables(conn):
with connect_with_backoff(conn) as open_conn:
with open_conn.cursor() as cur:
cur.execute("""
CREATE TABLE table_1 (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
foo BIGINT,
bar VARCHAR(10)
)""")
cur.execute("""
CREATE TABLE table_2 (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
foo BIGINT,
bar VARCHAR(10)
)""")
for record in TABLE_1_DATA:
insert_record(conn, "table_1", record)
for record in TABLE_2_DATA:
insert_record(conn, "table_2", record)
catalog = test_utils.discover_catalog(conn, {})
return catalog
def setUp(self):
self.conn = test_utils.get_test_connection()
with connect_with_backoff(self.conn) as open_conn:
with open_conn.cursor() as cursor:
cursor.execute("CREATE TABLE full_table (val int)")
cursor.execute("INSERT INTO full_table (val) VALUES (1)")
self.catalog = test_utils.discover_catalog(self.conn, {})
for stream in self.catalog.streams:
stream.key_properties = []
stream.metadata = [
{
"breadcrumb": (),
"metadata": {
"selected": True,
"database-name": "tap_mysql_test"
},
},
{
"breadcrumb": ("properties", "val"),
"metadata": {
"selected": True
}
},
]
stream.stream = stream.table
test_utils.set_replication_method_and_key(stream, "FULL_TABLE",
None)
def setUp(self):
self.conn = test_utils.get_test_connection()
with connect_with_backoff(self.conn) as open_conn:
with open_conn.cursor() as cursor:
cursor.execute('CREATE TABLE full_table (val int)')
cursor.execute('INSERT INTO full_table (val) VALUES (1)')
self.catalog = test_utils.discover_catalog(self.conn, {})
for stream in self.catalog.streams:
stream.key_properties = []
stream.metadata = [{
'breadcrumb': (),
'metadata': {
'selected': True,
'database-name': 'tap_mysql_test'
}
}, {
'breadcrumb': ('properties', 'val'),
'metadata': {
'selected': True
}
}]
stream.stream = stream.table
test_utils.set_replication_method_and_key(stream, 'FULL_TABLE',
None)
def setUpClass(cls):
conn = test_utils.get_test_connection()
with connect_with_backoff(conn) as open_conn:
with open_conn.cursor() as cur:
cur.execute('''
CREATE TABLE test_type_mapping (
c_pk INTEGER PRIMARY KEY,
c_decimal DECIMAL,
c_decimal_2_unsigned DECIMAL(5, 2) UNSIGNED,
c_decimal_2 DECIMAL(11, 2),
c_tinyint TINYINT,
c_tinyint_1 TINYINT(1),
c_tinyint_1_unsigned TINYINT(1) UNSIGNED,
c_smallint SMALLINT,
c_mediumint MEDIUMINT,
c_int INT,
c_bigint BIGINT,
c_bigint_unsigned BIGINT(20) UNSIGNED,
c_float FLOAT,
c_double DOUBLE,
c_bit BIT(4),
c_date DATE,
c_time TIME,
c_year YEAR
)''')
catalog = test_utils.discover_catalog(conn, {})
cls.schema = catalog.streams[0].schema
cls.metadata = catalog.streams[0].metadata
def setUp(self):
self.conn = test_utils.get_test_connection()
with connect_with_backoff(self.conn) as open_conn:
with open_conn.cursor() as cursor:
cursor.execute("CREATE TABLE a (`b c` int)")
cursor.execute("INSERT INTO a (`b c`) VALUES (1)")
self.catalog = test_utils.discover_catalog(self.conn, {})
self.catalog.streams[0].stream = "some_stream_name"
self.catalog.streams[0].metadata = [
{
"breadcrumb": (),
"metadata": {
"selected": True,
"table-key-properties": [],
"database-name": "tap_mysql_test",
},
},
{
"breadcrumb": ("properties", "b c"),
"metadata": {
"selected": True
}
},
]
test_utils.set_replication_method_and_key(self.catalog.streams[0],
"FULL_TABLE", None)
def test_discover_catalog_with_strategy_defined(self):
"""Validate if discovering catalog adds the sync strategy and incrementing col if provided"""
config = {
'tables': f'{DB_NAME}.{SCHEMA_NAME}.empty_table_1',
'metadata': {
f'{DB_NAME}.{SCHEMA_NAME}.empty_table_1': {
'table-key-properties': ['keys'],
'replication-key': 'column1',
'replication-method': 'INCREMENTAL',
'selected': True
}
}
}
catalog = test_utils.discover_catalog(self.snowflake_conn, config)
stream = catalog.streams[0]
stream_metadata = stream.to_dict().get('metadata')[0].get('metadata')
self.assertEqual(
stream_metadata, {
'table-key-properties': ['keys'],
'replication-key': 'column1',
'replication-method': 'INCREMENTAL',
'selected-by-default': False,
'database-name': f'{DB_NAME}',
'schema-name': f'{SCHEMA_NAME}',
'row-count': 0,
'is-view': False,
'selected': True
})
def test_do_not_discover_key_properties_for_view(self):
catalog = test_utils.discover_catalog(self.conn, {})
primary_keys = {}
for c in catalog.streams:
primary_keys[c.table] = singer.metadata.to_map(c.metadata).get(
(), {}).get('table-key-properties')
self.assertEqual(primary_keys, {'a_table': ['id'], 'a_view': None})
def test_do_not_discover_key_properties_for_view(self):
catalog = test_utils.discover_catalog(self.conn, {})
primary_keys = {}
for c in catalog.streams:
primary_keys[c.table] = (singer.metadata.to_map(c.metadata).get(
(), {}).get("table-key-properties"))
self.assertEqual(primary_keys, {"a_table": ["id"], "a_view": None})
def test_discovery_sets_is_view(self):
catalog = test_utils.discover_catalog(self.conn, {})
is_view = {}
for stream in catalog.streams:
md_map = singer.metadata.to_map(stream.metadata)
is_view[stream.table] = md_map.get((), {}).get('is-view')
self.assertEqual(is_view, {'a_table': False, 'a_view': True})
def setUp(self):
self.maxDiff = None
self.state = {}
self.conn = test_utils.get_test_connection()
log_file, log_pos = binlog.fetch_current_log_file_and_pos(self.conn)
with connect_with_backoff(self.conn) as open_conn:
with open_conn.cursor() as cursor:
cursor.execute('CREATE TABLE binlog_1 (id int, updated datetime)')
cursor.execute('CREATE TABLE binlog_2 (id int, updated datetime)')
cursor.execute('INSERT INTO binlog_1 (id, updated) VALUES (1, \'2017-06-01\')')
cursor.execute('INSERT INTO binlog_1 (id, updated) VALUES (2, \'2017-06-20\')')
cursor.execute('INSERT INTO binlog_1 (id, updated) VALUES (3, \'2017-09-22\')')
cursor.execute('INSERT INTO binlog_2 (id, updated) VALUES (1, \'2017-10-22\')')
cursor.execute('INSERT INTO binlog_2 (id, updated) VALUES (2, \'2017-11-10\')')
cursor.execute('INSERT INTO binlog_2 (id, updated) VALUES (3, \'2017-12-10\')')
cursor.execute('UPDATE binlog_1 set updated=\'2018-06-18\' WHERE id = 3')
cursor.execute('UPDATE binlog_2 set updated=\'2018-06-18\' WHERE id = 2')
cursor.execute('DELETE FROM binlog_1 WHERE id = 2')
cursor.execute('DELETE FROM binlog_2 WHERE id = 1')
open_conn.commit()
self.catalog = test_utils.discover_catalog(self.conn, {})
for stream in self.catalog.streams:
stream.stream = stream.table
stream.metadata = [
{'breadcrumb': (),
'metadata': {
'selected': True,
'database-name': 'tap_mysql_test',
'table-key-propertes': ['id']
}},
{'breadcrumb': ('properties', 'id'), 'metadata': {'selected': True}},
{'breadcrumb': ('properties', 'updated'), 'metadata': {'selected': True}}
]
test_utils.set_replication_method_and_key(stream, 'LOG_BASED', None)
self.state = singer.write_bookmark(self.state,
stream.tap_stream_id,
'log_file',
log_file)
self.state = singer.write_bookmark(self.state,
stream.tap_stream_id,
'log_pos',
log_pos)
self.state = singer.write_bookmark(self.state,
stream.tap_stream_id,
'version',
singer.utils.now())
def test_generate_sql_full_sync(self):
"""Validate the where clause is filtering properly"""
catalog = test_utils.discover_catalog(
self.snowflake_conn, {'tables': f'{SCHEMA_NAME}.empty_table_1'},
select_all=True)
catalog_entry = catalog.streams[0]
columns = list(catalog_entry.schema.properties.keys())
select_sql = common.generate_sql_query(catalog_entry, columns)
assert select_sql == f'SELECT "C_PK","C_INT" FROM "{DB_NAME}"."{SCHEMA_NAME}"."EMPTY_TABLE_1"'
def test_discover_catalog_with_view(self):
"""Validate if discovering catalog with filter_tables option working as expected"""
# Create config to discover only one view
catalog = test_utils.discover_catalog(
self.snowflake_conn, {'tables': f'{SCHEMA_NAME}.empty_view_1'})
# Only one view should be discovered
tap_stream_ids = [s.tap_stream_id for s in catalog.streams]
self.assertCountEqual(tap_stream_ids,
[f'{DB_NAME}-TAP_SNOWFLAKE_TEST-EMPTY_VIEW_1'])
def test_discover_catalog_with_single_table(self):
"""Validate if discovering catalog with filter_tables option working as expected"""
# Create config to discover only one table
catalog = test_utils.discover_catalog(
self.snowflake_conn, {'tables': f'{SCHEMA_NAME}.empty_table_2'})
# Only one table should be discovered
tap_stream_ids = [s.tap_stream_id for s in catalog.streams]
self.assertCountEqual(
tap_stream_ids,
['ANALYTICS_DB_TEST-TAP_SNOWFLAKE_TEST-EMPTY_TABLE_2'])
def runTest(self):
catalog = test_utils.discover_catalog(self.conn, {})
primary_keys = {}
for c in catalog.streams:
primary_keys[c.table] = singer.metadata.to_map(c.metadata).get(
(), {}).get('table-key-properties')
self.assertEqual(primary_keys, {
'good_pk_tab': ['good_pk'],
'bad_pk_tab': []
})
def runTest(self):
catalog = test_utils.discover_catalog(self.conn, {})
primary_keys = {}
for c in catalog.streams:
primary_keys[c.table] = (singer.metadata.to_map(c.metadata).get(
(), {}).get("table-key-properties"))
self.assertEqual(primary_keys, {
"good_pk_tab": ["good_pk"],
"bad_pk_tab": []
})
def setUp(self):
self.conn = test_utils.get_test_connection()
with connect_with_backoff(self.conn) as open_conn:
with open_conn.cursor() as cursor:
cursor.execute(
"CREATE TABLE incremental (val int, updated datetime)")
cursor.execute(
"INSERT INTO incremental (val, updated) VALUES (1, '2017-06-01')"
)
cursor.execute(
"INSERT INTO incremental (val, updated) VALUES (2, '2017-06-20')"
)
cursor.execute(
"INSERT INTO incremental (val, updated) VALUES (3, '2017-09-22')"
)
cursor.execute(
"CREATE TABLE integer_incremental (val int, updated int)")
cursor.execute(
"INSERT INTO integer_incremental (val, updated) VALUES (1, 1)"
)
cursor.execute(
"INSERT INTO integer_incremental (val, updated) VALUES (2, 2)"
)
cursor.execute(
"INSERT INTO integer_incremental (val, updated) VALUES (3, 3)"
)
self.catalog = test_utils.discover_catalog(self.conn, {})
for stream in self.catalog.streams:
stream.metadata = [
{
"breadcrumb": (),
"metadata": {
"selected": True,
"table-key-properties": [],
"database-name": "tap_mysql_test",
},
},
{
"breadcrumb": ("properties", "val"),
"metadata": {
"selected": True
}
},
]
stream.stream = stream.table
test_utils.set_replication_method_and_key(stream, "INCREMENTAL",
"updated")
def test_generate_sql_incremental_sync_without_bookmark(self):
"""Validate the where clause is filtering properly, when incremental and no bookmark yet"""
catalog = test_utils.discover_catalog(self.snowflake_conn, {
'tables': f'{DB_NAME}.{SCHEMA_NAME}.EMPTY_TABLE_1',
'metadata': {
f'{DB_NAME}.{SCHEMA_NAME}.EMPTY_TABLE_1': {
'replication-method': 'INCREMENTAL',
'replication-key': 'REP_KEY'
}
}
},
select_all=True)
catalog_entry = catalog.streams[0]
columns = list(catalog_entry.schema.properties.keys())
select_sql = common.generate_sql_query(catalog_entry, columns)
assert select_sql == f'SELECT "C_PK","C_INT" FROM "{DB_NAME}"."{SCHEMA_NAME}"."EMPTY_TABLE_1" ORDER BY "REP_KEY" ASC'
def test_generate_sql_missing_lookback_config(self):
"""Validate the where clause is filtering properly, when full table and look back window"""
with pytest.raises(Exception):
catalog = test_utils.discover_catalog(self.snowflake_conn, {
'tables': f'{DB_NAME}.{SCHEMA_NAME}.EMPTY_TABLE_1',
'metadata': {
f'{DB_NAME}.{SCHEMA_NAME}.EMPTY_TABLE_1': {
'replication-method': 'FULL_TABLE',
'rolling_lookback': {'MISSING_REQUIRED_CONFIG'}
}
}
},
select_all=True)
catalog_entry = catalog.streams[0]
columns = list(catalog_entry.schema.properties.keys())
common.generate_sql_query(catalog_entry, columns)
def setUp(self):
self.conn = test_utils.get_test_connection()
with connect_with_backoff(self.conn) as open_conn:
with open_conn.cursor() as cursor:
cursor.execute(
# BINARY is presently supported
'CREATE TABLE good_pk_tab (good_pk BINARY(10), age INT, PRIMARY KEY (good_pk))')
cursor.execute("INSERT INTO good_pk_tab (good_pk, age) VALUES "
"(BINARY('a'), 20), "
"(BINARY('b'), 30), "
"(BINARY('c'), 30), "
"(BINARY('d'), 40)")
self.catalog = test_utils.discover_catalog(self.conn, {})
def test_discover_catalog_without_strategy_defined(self):
"""Validate if discovering catalog excludes sync strategy if not configured"""
catalog = test_utils.discover_catalog(
self.snowflake_conn, {'tables': f'{SCHEMA_NAME}.empty_table_1'})
# table should be discovered
stream = catalog.streams[0]
stream_metadata = stream.to_dict().get('metadata')[0].get('metadata')
self.assertEqual(
stream_metadata, {
'selected-by-default': False,
'database-name': f'{DB_NAME}',
'schema-name': f'{SCHEMA_NAME}',
'row-count': 0,
'is-view': False,
})
def test_discover_catalog_with_multiple_table(self):
"""Validate if discovering catalog with filter_tables option working as expected"""
# Create config to discover three tables
catalog = test_utils.discover_catalog(
self.snowflake_conn, {
'tables':
f'{SCHEMA_NAME}.empty_table_1,{SCHEMA_NAME}.empty_table_2,{SCHEMA_NAME}.test_type_mapping'
})
# Three tables should be discovered
tap_stream_ids = [s.tap_stream_id for s in catalog.streams]
self.assertCountEqual(tap_stream_ids, [
f'{DB_NAME}-TAP_SNOWFLAKE_TEST-EMPTY_TABLE_1',
f'{DB_NAME}-TAP_SNOWFLAKE_TEST-EMPTY_TABLE_2',
f'{DB_NAME}-TAP_SNOWFLAKE_TEST-TEST_TYPE_MAPPING'
])
def runTest(self):
conn = test_utils.get_test_connection()
with connect_with_backoff(conn) as open_conn:
with open_conn.cursor() as cur:
cur.execute("""
CREATE TABLE tab (
id INTEGER PRIMARY KEY,
a INTEGER,
b INTEGER)
""")
catalog = test_utils.discover_catalog(conn, {})
catalog.streams[0].stream = "tab"
catalog.streams[0].metadata = [
{
"breadcrumb": (),
"metadata": {
"selected": True,
"database-name": "tap_mysql_test"
}
},
{
"breadcrumb": ("properties", "a"),
"metadata": {
"selected": True
}
},
]
test_utils.set_replication_method_and_key(catalog.streams[0],
"FULL_TABLE", None)
global SINGER_MESSAGES
SINGER_MESSAGES.clear()
tap_mysql.do_sync(conn, {}, catalog, {})
schema_message = list(
filter(lambda m: isinstance(m, singer.SchemaMessage),
SINGER_MESSAGES))[0]
self.assertTrue(isinstance(schema_message, singer.SchemaMessage))
# tap-mysql selects new fields by default. If a field doesn't appear in the schema, then it should be
# selected
expectedKeys = ["id", "a", "b"]
self.assertEqual(schema_message.schema["properties"].keys(),
set(expectedKeys))
def test_discover_catalog_select_all(self):
"""Validate if discovering catalog select-all works"""
catalog = test_utils.discover_catalog(
self.snowflake_conn, {'tables': f'{SCHEMA_NAME}.empty_table_1'},
select_all=True)
# table should be discovered
stream = catalog.streams[0]
stream_metadata = stream.to_dict().get('metadata')[0].get('metadata')
self.assertEqual(
stream_metadata, {
'replication-method': 'FULL_TABLE',
'selected-by-default': True,
'database-name': f'{DB_NAME}',
'schema-name': f'{SCHEMA_NAME}',
'row-count': 0,
'is-view': False,
'selected': True
})
def test_generate_sql_full_sync_lookback(self):
"""Validate the where clause is filtering properly, when full table and look back window"""
catalog = test_utils.discover_catalog(self.snowflake_conn, {
'tables': f'{DB_NAME}.{SCHEMA_NAME}.EMPTY_TABLE_1',
'metadata': {
f'{DB_NAME}.{SCHEMA_NAME}.EMPTY_TABLE_1': {
'replication-method': 'FULL_TABLE',
'rolling_lookback': {
'time_unit': 'day',
'time_amount': '7',
'time_column': 'c_datetime'
}
}
}
},
select_all=True)
catalog_entry = catalog.streams[0]
columns = list(catalog_entry.schema.properties.keys())
select_sql = common.generate_sql_query(catalog_entry, columns)
assert select_sql == f'SELECT "C_PK","C_INT" FROM "{DB_NAME}"."{SCHEMA_NAME}"."EMPTY_TABLE_1" WHERE "c_datetime" >= DATEADD(day, -7, SYSTIMESTAMP())'
def setUp(self):
self.conn = test_utils.get_test_connection()
self.state = {}
log_file, log_pos = binlog.fetch_current_log_file_and_pos(self.conn)
with connect_with_backoff(self.conn) as open_conn:
with open_conn.cursor() as cursor:
cursor.execute(
'CREATE TABLE datetime_types (id int, datetime_col datetime, timestamp_col timestamp, time_col time, date_col date)'
)
cursor.execute(
'INSERT INTO datetime_types (id, datetime_col, timestamp_col, time_col, date_col) VALUES (1, \'0000-00-00\', \'0000-00-00 00:00:00\', \'00:00:00\', \'0000-00-00\' )'
)
cursor.execute(
'INSERT INTO datetime_types (id, datetime_col, timestamp_col, time_col, date_col) VALUES (2, NULL, NULL, NULL, NULL)'
)
open_conn.commit()
self.catalog = test_utils.discover_catalog(self.conn, {})
for stream in self.catalog.streams:
stream.stream = stream.table
stream.metadata = [{
'breadcrumb': (),
'metadata': {
'selected': True,
'database-name': 'tap_mysql_test',
'table-key-propertes': ['id']
}
}, {
'breadcrumb': ('properties', 'id'),
'metadata': {
'selected': True
}
}, {
'breadcrumb': ('properties', 'datetime_col'),
'metadata': {
'selected': True
}
}, {
'breadcrumb': ('properties', 'timestamp_col'),
'metadata': {
'selected': True
}
}, {
'breadcrumb': ('properties', 'time_col'),
'metadata': {
'selected': True
}
}, {
'breadcrumb': ('properties', 'date_col'),
'metadata': {
'selected': True
}
}]
test_utils.set_replication_method_and_key(stream, 'LOG_BASED',
None)
self.state = singer.write_bookmark(self.state,
stream.tap_stream_id,
'log_file', log_file)
self.state = singer.write_bookmark(self.state,
stream.tap_stream_id, 'log_pos',
log_pos)
self.state = singer.write_bookmark(self.state,
stream.tap_stream_id, 'version',
singer.utils.now())
def setUpClass(cls):
cls.snowflake_conn = test_utils.get_test_connection()
with cls.snowflake_conn.open_connection() as open_conn:
with open_conn.cursor() as cur:
cur.execute('''
CREATE TABLE {}.test_type_mapping (
c_pk INTEGER PRIMARY KEY,
c_decimal DECIMAL,
c_decimal_2 DECIMAL(11, 2),
c_smallint SMALLINT,
c_int INT,
c_bigint BIGINT,
c_float FLOAT,
c_double DOUBLE,
c_date DATE,
c_datetime DATETIME,
c_time TIME,
c_binary BINARY,
c_varbinary VARBINARY(16),
c_object OBJECT,
c_array ARRAY
)'''.format(SCHEMA_NAME))
cur.execute(f'''
INSERT INTO {SCHEMA_NAME}.test_type_mapping
SELECT 1
,12345
,123456789.12
,123
,12345
,1234567890
,123.123
,123.123
,'2019-08-01'
,'2019-08-01 17:23:59'
,'17:23:59'
,HEX_ENCODE('binary')
,HEX_ENCODE('varbinary')
,parse_json($${{'test_key':['test_val']}}$$)
,array_construct(1, object_construct('foo', 'bar'), array_construct(3,3,3))
''')
cur.execute('''
CREATE TABLE {}.empty_table_1 (
c_pk INTEGER PRIMARY KEY,
c_int INT
)'''.format(SCHEMA_NAME))
cur.execute('''
CREATE TABLE {}.empty_table_2 (
c_pk INTEGER PRIMARY KEY,
c_int INT
)'''.format(SCHEMA_NAME))
cur.execute('''
CREATE VIEW {}.empty_view_1 AS
SELECT c_pk, c_int FROM {}.empty_table_1
'''.format(SCHEMA_NAME, SCHEMA_NAME))
# Discover catalog object including only TEST_TYPE_MAPPING table to run detailed tests later
cls.dt_catalog = test_utils.discover_catalog(
cls.snowflake_conn, {'tables': f'{SCHEMA_NAME}.test_type_mapping'})
cls.dt_stream = cls.dt_catalog.streams[0]
cls.dt_schema = cls.dt_catalog.streams[0].schema
cls.dt_metadata = cls.dt_catalog.streams[0].metadata
