def test_create_sql_table_column_types_are_case_insensitive(self, handler): create_definitions = ['lows int(11)', 'CAPS INT(11)', 'MiXeD INt(11)'] expected_columns = [ SQLColumn('lows', data_types.MySQLInt(11)), SQLColumn('CAPS', data_types.MySQLInt(11)), SQLColumn('MiXeD', data_types.MySQLInt(11)), ] self.assert_sql_table_equal_with_create_defs(handler, create_definitions, expected_columns)
def test_convert_with_col_int(self, converter): self._convert_and_assert_with_one_column( converter, SQLColumn('col_int', mysql_data_types.MySQLInt(11)), { 'name': 'col_int', 'type': ['null', 'int'], 'default': None })
def test_convert_with_table_namespace_and_aliases(self, converter): doc = 'I am doc' aliases = ['foo'] metadata = { MetaDataKey.NAMESPACE: self.namespace, MetaDataKey.ALIASES: aliases } col_name = 'col' sql_table = SQLTable( self.table_name, [SQLColumn(col_name, mysql_data_types.MySQLInt(11))], doc=doc, **metadata) expected_schema = { 'type': 'record', 'name': self.table_name, 'namespace': self.namespace, 'fields': [{ 'name': col_name, 'type': ['null', 'int'], 'default': None }], 'doc': doc, 'aliases': aliases } actual_schema = converter.convert(sql_table) assert expected_schema == actual_schema
def expected_sql_table_date_and_time(self): col_id = SQLColumn('id', data_types.MySQLInt(11), primary_key_order=1, is_nullable=False) col_dttm = SQLColumn('dttm', data_types.MySQLDateTime(), default_value='1000-01-01 00:00:00', is_nullable=False) col_tstmp = SQLColumn('tstmp', data_types.MySQLTimestamp(), default_value='1970-01-01 00:00:01', is_nullable=False) col_tm = SQLColumn('tm', data_types.MySQLTime(), default_value='11:12:00', is_nullable=False) col_yr = SQLColumn('yr', data_types.MySQLYear(), default_value='2000', is_nullable=False) col_dt = SQLColumn('dt', data_types.MySQLDate(), default_value='1000-01-01', is_nullable=False) return SQLTable('date_and_time', [col_id, col_dttm, col_tstmp, col_tm, col_yr, col_dt])
def test_convert_with_non_nullable_without_default_column(self, converter): self._convert_and_assert_with_one_column( converter, SQLColumn('col', mysql_data_types.MySQLInt(11), is_nullable=False), { 'name': 'col', 'type': 'int' })
def test_create_sql_table_from_sql_stmts_with_multi_sqls(self, handler): sql_table = handler.create_sql_table_from_sql_stmts( [self.alter_table_sql, self.create_table_sql]) expected_column = SQLColumn('id', data_types.MySQLInt(11), is_nullable=False) expected_table = SQLTable(self.table_name, [expected_column]) assert expected_table == sql_table
def test_convert_with_unsigned_int_column(self, converter): self._convert_and_assert_with_one_column( converter, SQLColumn('col', mysql_data_types.MySQLInt(11, unsigned=True)), { 'name': 'col', 'type': ['null', 'long'], 'default': None, 'unsigned': True })
def test_convert_with_column_default_value(self, converter): self._convert_and_assert_with_one_column( converter, SQLColumn('col', mysql_data_types.MySQLInt(11), default_value=10), { 'name': 'col', 'type': ['int', 'null'], 'default': 10 })
def expected_sql_table_foo(self): col_id = SQLColumn('id', data_types.MySQLInt(11), primary_key_order=1, is_nullable=False) col_name = SQLColumn('name', data_types.MySQLVarChar(255)) col_amount = SQLColumn('amount', data_types.MySQLDecimal(10, 2, unsigned=True), default_value=0.0) col_age = SQLColumn('age', data_types.MySQLInt(None)) col_bar = SQLColumn( 'bar', data_types.MySQLEnum(values=['a1', 'a2', 'a3'], char_set="latin1")) col_bar_one = SQLColumn( 'bar_one', data_types.MySQLSet(values=['a1', 'a2', 'a3'], char_set="latin1")) return SQLTable( 'foo', [col_id, col_name, col_amount, col_age, col_bar, col_bar_one])
def test_create_sql_table_from_sql_stmts_with_primary_keys(self, handler): create_definitions = [ 'id int(11) not null', 'pid int(11) not null', 'tag char(3)', 'primary key(id, pid)' ] expected_columns = [ SQLColumn('id', data_types.MySQLInt(11), is_nullable=False, primary_key_order=1), SQLColumn('pid', data_types.MySQLInt(11), is_nullable=False, primary_key_order=2), SQLColumn('tag', data_types.MySQLChar(3)) ] self.assert_sql_table_equal_with_create_defs(handler, create_definitions, expected_columns)
def test_convert_with_primary_key_column(self, converter): self._convert_and_assert_with_one_column( converter, SQLColumn('col', mysql_data_types.MySQLInt(11), primary_key_order=1), { 'name': 'col', 'type': ['null', 'int'], 'default': None, AvroMetaDataKeys.PRIMARY_KEY: True })
def test_convert_with_table_metadata(self, converter): pkey_col1 = SQLColumn('pkey_col_one', mysql_data_types.MySQLInt(11), primary_key_order=1) pkey_col2 = SQLColumn('pkey_col_two', mysql_data_types.MySQLInt(11), primary_key_order=2) col = SQLColumn('col', mysql_data_types.MySQLInt(11)) sql_table = SQLTable(self.table_name, [pkey_col2, pkey_col1, col]) expected_schema = { 'type': 'record', 'name': self.table_name, 'namespace': '', 'fields': [ { 'name': pkey_col2.name, 'type': ['null', 'int'], 'default': None, AvroMetaDataKeys.PRIMARY_KEY: 2 }, { 'name': pkey_col1.name, 'type': ['null', 'int'], 'default': None, AvroMetaDataKeys.PRIMARY_KEY: 1 }, { 'name': col.name, 'type': ['null', 'int'], 'default': None }, ], AvroMetaDataKeys.PRIMARY_KEY: [pkey_col1.name, pkey_col2.name] } actual_schema = converter.convert(sql_table) assert expected_schema == actual_schema
def test_create_sql_table_stmt_with_quoted_primary_keys( self, handler, primary_key_identifier): create_definitions = [ 'id int(11) not null', '`name` varchar(8)', 'primary key({})'.format(primary_key_identifier) ] expected_columns = [ SQLColumn('id', data_types.MySQLInt(11), is_nullable=False, primary_key_order=1), SQLColumn('name', data_types.MySQLVarChar(8)) ] self.assert_sql_table_equal_with_create_defs(handler, create_definitions, expected_columns)
def test_create_temp_table(self, handler): sql = 'create temporary table `foo` (bar int(11));' actual = handler.create_sql_table_from_sql_stmts([sql]) expected = SQLTable('foo', [SQLColumn('bar', data_types.MySQLInt(11))]) assert actual == expected
class TestMySQLHandler(object): @pytest.fixture def handler(self): return mysql_handler.MySQLHandler() @property def table_name(self): return 'foo' @property def create_table_sql(self): return 'CREATE TABLE `{0}` (`id` int(11) not null);'.format( self.table_name) @property def alter_table_sql(self): return 'ALTER TABLE `{0}` add `color` varchar(16);'.format( self.table_name) @property def create_table_foo_sql(self): return ('CREATE TABLE `foo` (' '`id` int(11) auto_increment not null, ' 'name varchar(255),' 'amount decimal(10, 2) default 0.0 unsigned,' 'age int default NULL,' "bar enum (\"a1\", \"a2\", 'a3') CHARACTER SET latin1," "bar_one set (\"a1\", 'a2', 'a3') CHARACTER SET latin1," 'primary key (id) ' ');') @property def expected_sql_table_foo(self): col_id = SQLColumn('id', data_types.MySQLInt(11), primary_key_order=1, is_nullable=False) col_name = SQLColumn('name', data_types.MySQLVarChar(255)) col_amount = SQLColumn('amount', data_types.MySQLDecimal(10, 2, unsigned=True), default_value=0.0) col_age = SQLColumn('age', data_types.MySQLInt(None)) col_bar = SQLColumn( 'bar', data_types.MySQLEnum(values=['a1', 'a2', 'a3'], char_set="latin1")) col_bar_one = SQLColumn( 'bar_one', data_types.MySQLSet(values=['a1', 'a2', 'a3'], char_set="latin1")) return SQLTable( 'foo', [col_id, col_name, col_amount, col_age, col_bar, col_bar_one]) @property def create_table_date_and_time_sql(self): return ('CREATE TABLE `date_and_time` (' '`id` int(11) auto_increment not null, ' 'dttm datetime default \'1000-01-01 00:00:00\' not null, ' 'tstmp timestamp default \'1970-01-01 00:00:01\' not null, ' 'tm time default \'11:12:00\' not null, ' 'yr year default \'2000\' not null, ' 'dt date default \'1000-01-01\' not null, ' 'primary key (id) ' ');') @property def expected_sql_table_date_and_time(self): col_id = SQLColumn('id', data_types.MySQLInt(11), primary_key_order=1, is_nullable=False) col_dttm = SQLColumn('dttm', data_types.MySQLDateTime(), default_value='1000-01-01 00:00:00', is_nullable=False) col_tstmp = SQLColumn('tstmp', data_types.MySQLTimestamp(), default_value='1970-01-01 00:00:01', is_nullable=False) col_tm = SQLColumn('tm', data_types.MySQLTime(), default_value='11:12:00', is_nullable=False) col_yr = SQLColumn('yr', data_types.MySQLYear(), default_value='2000', is_nullable=False) col_dt = SQLColumn('dt', data_types.MySQLDate(), default_value='1000-01-01', is_nullable=False) return SQLTable('date_and_time', [col_id, col_dttm, col_tstmp, col_tm, col_yr, col_dt]) def test_create_sql_table_from_sql_stmts(self, handler): sql_table = handler.create_sql_table_from_sql_stmts( [self.create_table_foo_sql]) assert self.expected_sql_table_foo == sql_table def test_create_sql_table_from_sql_stmts_date_types(self, handler): sql_table = handler.create_sql_table_from_sql_stmts( [self.create_table_date_and_time_sql]) assert self.expected_sql_table_date_and_time == sql_table def assert_sql_table_equal_with_create_defs(self, handler, create_definitions, expected_columns): sql = self._build_create_table_sql(create_definitions) actual_table = handler.create_sql_table_from_sql_stmts([sql]) expected_table = SQLTable(self.table_name, expected_columns) assert_equal_sql_table(expected_table, actual_table) def _build_create_table_sql(self, create_definitions): return 'CREATE TABLE `{table}` ({definitions});'.format( table=self.table_name, definitions=','.join(create_definitions)) @pytest.mark.parametrize(("create_definition", "expected_column"), [ ('`bar` bit(4) not null', SQLColumn('bar', data_types.MySQLBit(4), is_nullable=False)), ('bar bit null', SQLColumn('bar', data_types.MySQLBit(None))), ('bar bit default 0b0101', SQLColumn('bar', data_types.MySQLBit(None), default_value=5)), ('bar bit default b\'101\'', SQLColumn('bar', data_types.MySQLBit(None), default_value=5)), ]) def test_create_sql_table_from_sql_stmts_with_bit_type( self, handler, create_definition, expected_column): self.assert_sql_table_equal_with_create_defs(handler, [create_definition], [expected_column]) @pytest.mark.parametrize(("create_definition", "expected_column"), [ ('`bar` int(4) not null unsigned', SQLColumn( 'bar', data_types.MySQLInt(4, unsigned=True), is_nullable=False)), ('`bar` int(4) default 10', SQLColumn('bar', data_types.MySQLInt(4), default_value=10)), ('bar tinyint null', SQLColumn('bar', data_types.MySQLTinyInt(None))), ('bar smallint null', SQLColumn('bar', data_types.MySQLSmallInt(None))), ('bar bigint null', SQLColumn('bar', data_types.MySQLBigInt(None))), ('bar integer null', SQLColumn('bar', data_types.MySQLInteger(None))), ]) def test_create_sql_table_from_sql_stmts_with_integer_type( self, handler, create_definition, expected_column): self.assert_sql_table_equal_with_create_defs(handler, [create_definition], [expected_column]) @pytest.mark.parametrize(("create_definition", "expected_column"), [ ('`bar` bool not null', SQLColumn('bar', data_types.MySQLBool(), is_nullable=False)), ('bar bool null', SQLColumn('bar', data_types.MySQLBool())), ('bar bool default TRUE', SQLColumn('bar', data_types.MySQLBool(), default_value=True)), ('bar bool default true', SQLColumn('bar', data_types.MySQLBool(), default_value=True)), ('bar bool default 1', SQLColumn('bar', data_types.MySQLBool(), default_value=True)), ('bar bool default FALSE', SQLColumn('bar', data_types.MySQLBool(), default_value=False)), ('bar bool default false', SQLColumn('bar', data_types.MySQLBool(), default_value=False)), ('bar bool default 0', SQLColumn('bar', data_types.MySQLBool(), default_value=False)), ('bar boolean null', SQLColumn('bar', data_types.MySQLBoolean())), ]) def test_create_sql_table_from_sql_stmts_with_boolean_type( self, handler, create_definition, expected_column): self.assert_sql_table_equal_with_create_defs(handler, [create_definition], [expected_column]) @pytest.mark.parametrize(("create_definition", "expected_column"), [ ('bar decimal(10, 2) default 0.0 unsigned', SQLColumn('bar', data_types.MySQLDecimal(10, 2, unsigned=True), default_value=0.0)), ('bar double NULL', SQLColumn('bar', data_types.MySQLDouble( None, None))), ('bar numeric(10) null', SQLColumn('bar', data_types.MySQLNumeric(10, None))), ]) def test_create_sql_table_from_sql_stmts_with_real_num_type( self, handler, create_definition, expected_column): self.assert_sql_table_equal_with_create_defs(handler, [create_definition], [expected_column]) @pytest.mark.parametrize( ("create_definition", "expected_column"), [ ('bar char(3) not null', SQLColumn('bar', data_types.MySQLChar(3), is_nullable=False)), ('bar char not null', SQLColumn('bar', data_types.MySQLChar(3), is_nullable=False)), ('bar varchar(255) null', SQLColumn('bar', data_types.MySQLVarChar(255))), ('bar text CHARACTER SET latin1 COLLATE latin1_german1_ci', SQLColumn( 'bar', data_types.MySQLText(char_set='latin1', collate='latin1_german1_ci'))), ('bar char(42) default \'Luke\'', SQLColumn('bar', data_types.MySQLChar(42), default_value='Luke')), ('bar varchar(42) default \'use\'', SQLColumn('bar', data_types.MySQLVarChar(42), default_value='use')), ('bar tinytext default \'force!\'', SQLColumn( 'bar', data_types.MySQLTinyText(), default_value='force!')), # Note that MySQL BLOB and TEXT cannot have default value so we are # intentionally excluding them from such tests. For more information # See http://dev.mysql.com/doc/refman/5.5/en/data-type-defaults.html # or the discussion on r/119051/ ]) def test_create_sql_table_from_sql_stmts_with_string_type( self, handler, create_definition, expected_column): self.assert_sql_table_equal_with_create_defs(handler, [create_definition], [expected_column]) @pytest.mark.parametrize(("create_definition", "expected_column"), [ ('bar date default \'1000-01-01\' not null', SQLColumn('bar', data_types.MySQLDate(), default_value='1000-01-01', is_nullable=False)), ('bar date null', SQLColumn('bar', data_types.MySQLDate())), ]) def test_create_sql_table_from_sql_stmts_with_date_type( self, handler, create_definition, expected_column): self.assert_sql_table_equal_with_create_defs(handler, [create_definition], [expected_column]) @pytest.mark.parametrize(("create_definition", "expected_column"), [ ('bar year default \'2000\' not null', SQLColumn('bar', data_types.MySQLYear(), default_value='2000', is_nullable=False)), ('bar year null', SQLColumn('bar', data_types.MySQLYear())), ]) def test_create_sql_table_from_sql_stmts_with_year_type( self, handler, create_definition, expected_column): self.assert_sql_table_equal_with_create_defs(handler, [create_definition], [expected_column]) @pytest.mark.parametrize(("create_definition", "expected_column"), [ ('bar time default \'11:12:00\' not null', SQLColumn('bar', data_types.MySQLTime(), default_value='11:12:00', is_nullable=False)), ('bar time(2) default \'11:12:00\' not null', SQLColumn('bar', data_types.MySQLTime(2), default_value='11:12:00', is_nullable=False)), ('bar time null', SQLColumn('bar', data_types.MySQLTime())), ]) def test_create_sql_table_from_sql_stmts_with_time_type( self, handler, create_definition, expected_column): self.assert_sql_table_equal_with_create_defs(handler, [create_definition], [expected_column]) @pytest.mark.parametrize(("create_definition", "expected_column"), [ ('bar timestamp default \'1970-01-01 00:00:01\' not null', SQLColumn('bar', data_types.MySQLTimestamp(), default_value='1970-01-01 00:00:01', is_nullable=False)), ('bar timestamp(2) default \'1970-01-01 00:00:01\' not null', SQLColumn('bar', data_types.MySQLTimestamp(2), default_value='1970-01-01 00:00:01', is_nullable=False)), ('bar timestamp null', SQLColumn('bar', data_types.MySQLTimestamp())), ]) def test_create_sql_table_from_sql_stmts_with_timestamp_type( self, handler, create_definition, expected_column): self.assert_sql_table_equal_with_create_defs(handler, [create_definition], [expected_column]) @pytest.mark.parametrize(("create_definition", "expected_column"), [ ('bar datetime default \'1000-01-01 00:00:00\' not null', SQLColumn('bar', data_types.MySQLDateTime(), default_value='1000-01-01 00:00:00', is_nullable=False)), ('bar datetime(2) default \'1000-01-01 00:00:00\' not null', SQLColumn('bar', data_types.MySQLDateTime(2), default_value='1000-01-01 00:00:00', is_nullable=False)), ('bar datetime null', SQLColumn('bar', data_types.MySQLDateTime())), ]) def test_create_sql_table_from_sql_stmts_with_datetime_type( self, handler, create_definition, expected_column): self.assert_sql_table_equal_with_create_defs(handler, [create_definition], [expected_column]) @pytest.mark.parametrize( ("create_definition", "expected_column"), [ ('bar binary(64)', SQLColumn('bar', data_types.MySQLBinary(64))), ('bar binary', SQLColumn('bar', data_types.MySQLBinary())), ('bar varbinary(64)', SQLColumn('bar', data_types.MySQLVarBinary(64))), ('bar blob null', SQLColumn('bar', data_types.MySQLBlob())), ('bar tinyblob', SQLColumn('bar', data_types.MySQLTinyBlob())), ('bar mediumblob', SQLColumn('bar', data_types.MySQLMediumBlob())), ('bar longblob', SQLColumn('bar', data_types.MySQLLongBlob())), ('bar binary(16) default \'The powerglove\'', SQLColumn('bar', data_types.MySQLBinary(16), default_value='The powerglove')), # Note that MySQL BLOB and TEXT cannot have default value so we are # intentionally excluding them from such tests. For more information # See http://dev.mysql.com/doc/refman/5.5/en/data-type-defaults.html # or the discussion on r/119051/ ]) def test_create_sql_table_from_sql_stmts_with_binary_type( self, handler, create_definition, expected_column): self.assert_sql_table_equal_with_create_defs(handler, [create_definition], [expected_column]) @pytest.mark.parametrize(("create_definition", "expected_column"), [ ("bar enum ('a1', \"a2\", 'a3') CHARACTER SET latin1", SQLColumn( 'bar', data_types.MySQLEnum(values=['a1', 'a2', 'a3'], char_set="latin1"))), ("bar enum ('a1', 'a2', 'a3') " "CHARACTER SET latin1 COLLATE latin1_german1_ci not null", SQLColumn('bar', data_types.MySQLEnum(values=['a1', 'a2', 'a3'], char_set="latin1", collate="latin1_german1_ci"), is_nullable=False)), ("bar enum (\"a1\", 'a2', 'a3') default a1", SQLColumn('bar', data_types.MySQLEnum(['a1', 'a2', 'a3']), default_value='a1')), ]) def test_create_sql_table_from_sql_stmts_with_enum_type( self, handler, create_definition, expected_column): self.assert_sql_table_equal_with_create_defs(handler, [create_definition], [expected_column]) @pytest.mark.parametrize(("create_definition", "expected_column"), [ ("bar set (\"a1\", 'a2', 'a3') CHARACTER SET latin1", SQLColumn( 'bar', data_types.MySQLSet(values=['a1', 'a2', 'a3'], char_set="latin1"))), ("bar set ('a1', 'a2', \"a3\") " " CHARACTER SET latin1 COLLATE latin1_german1_ci not null", SQLColumn('bar', data_types.MySQLSet(values=['a1', 'a2', 'a3'], char_set="latin1", collate="latin1_german1_ci"), is_nullable=False)), ("bar set ('a1', \"a2\", 'a3') default a2", SQLColumn('bar', data_types.MySQLSet(['a1', 'a2', 'a3']), default_value='a2')), ]) def test_create_sql_table_from_sql_stmts_with_set_type( self, handler, create_definition, expected_column): self.assert_sql_table_equal_with_create_defs(handler, [create_definition], [expected_column]) def test_create_sql_table_from_sql_stmts_with_primary_keys(self, handler): create_definitions = [ 'id int(11) not null', 'pid int(11) not null', 'tag char(3)', 'primary key(id, pid)' ] expected_columns = [ SQLColumn('id', data_types.MySQLInt(11), is_nullable=False, primary_key_order=1), SQLColumn('pid', data_types.MySQLInt(11), is_nullable=False, primary_key_order=2), SQLColumn('tag', data_types.MySQLChar(3)) ] self.assert_sql_table_equal_with_create_defs(handler, create_definitions, expected_columns) @pytest.mark.parametrize('primary_key_identifier', ['`id`', '"id"']) def test_create_sql_table_stmt_with_quoted_primary_keys( self, handler, primary_key_identifier): create_definitions = [ 'id int(11) not null', '`name` varchar(8)', 'primary key({})'.format(primary_key_identifier) ] expected_columns = [ SQLColumn('id', data_types.MySQLInt(11), is_nullable=False, primary_key_order=1), SQLColumn('name', data_types.MySQLVarChar(8)) ] self.assert_sql_table_equal_with_create_defs(handler, create_definitions, expected_columns) def test_create_sql_table_column_types_are_case_insensitive(self, handler): create_definitions = ['lows int(11)', 'CAPS INT(11)', 'MiXeD INt(11)'] expected_columns = [ SQLColumn('lows', data_types.MySQLInt(11)), SQLColumn('CAPS', data_types.MySQLInt(11)), SQLColumn('MiXeD', data_types.MySQLInt(11)), ] self.assert_sql_table_equal_with_create_defs(handler, create_definitions, expected_columns) def test_create_sql_table_from_sql_stmts_with_multi_sqls(self, handler): sql_table = handler.create_sql_table_from_sql_stmts( [self.alter_table_sql, self.create_table_sql]) expected_column = SQLColumn('id', data_types.MySQLInt(11), is_nullable=False) expected_table = SQLTable(self.table_name, [expected_column]) assert expected_table == sql_table def test_create_sql_table_from_sql_stmts_with_non_create_table_sql( self, handler): with pytest.raises(ValueError) as e: handler.create_sql_table_from_sql_stmts( [self.create_table_sql, self.alter_table_sql]) assert str(e.value).startswith( 'parsed_stmt should be a create-table statement') def test_create_sql_table_from_sql_stmts_with_bad_sql(self, handler): sql = 'CREATE TABLE `foo_tbl` `id` int(11) auto_increment;' with pytest.raises(sql_handler_base.SQLHandlerException) as e: handler.create_sql_table_from_sql_stmts([sql]) assert str(e.value).startswith('No column exists in the table.') def test_create_sql_table_from_sql_stmts_with_bad_col_type(self, handler): sql = 'CREATE TABLE `foo_tbl` (id basscannon(11));' with pytest.raises(sql_handler_base.SQLHandlerException) as e: handler.create_sql_table_from_sql_stmts([sql]) assert 'Unknown MySQL column type basscannon.' == str(e.value) def test_create_sql_table_from_sql_stmts_with_no_stmts(self, handler): with pytest.raises(sql_handler_base.SQLHandlerException) as e: handler.create_sql_table_from_sql_stmts([]) assert 'Unable to process MySQL statements [].' == str(e.value) def test_identifiers_with_quotes(self, handler): sql = 'CREATE TABLE `Fo``o` (`ba"r` int, `"ba""z"` int);' actual = handler.create_sql_table_from_sql_stmts([sql]) assert actual.name == 'Fo`o' assert actual.columns[0].name == 'ba"r' assert actual.columns[1].name == '"ba""z"' def test_create_temp_table(self, handler): sql = 'create temporary table `foo` (bar int(11));' actual = handler.create_sql_table_from_sql_stmts([sql]) expected = SQLTable('foo', [SQLColumn('bar', data_types.MySQLInt(11))]) assert actual == expected