From c081a23fc842ffae3eb50156f7877633c06558e0 Mon Sep 17 00:00:00 2001 From: zhangxuan_hw Date: Fri, 1 Nov 2024 18:08:24 +0800 Subject: [PATCH 1/8] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E7=9B=AE=E5=BD=95?= =?UTF-8?q?=E5=92=8C=E6=96=87=E4=BB=B6=E5=90=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 替换TSE tianchi 修改tse 修改TSE tianchi mulu ctc_mysql_conn_info命名冲突 修改测试用例目录名 rename Tse --- mysql-test/enableCases.list | 74 +- mysql-test/mysql-source-code-meta.patch | 42 +- .../{tianchi => ctc}/r/ctc_atomic_ddl.result | 0 .../r/ctc_auto_increment.result | 0 .../{tianchi => ctc}/r/ctc_bit_analyze.result | 0 .../{tianchi => ctc}/r/ctc_charset.result | 0 .../r/ctc_charset_binary.result | 0 .../r/ctc_charset_collate.result | 0 .../r/ctc_compressed_proxy_conn.result | 0 .../r/ctc_cond_pushdown.result | 0 .../r/ctc_cond_pushdown_explain.result | 0 .../r/ctc_create_table.result} | 0 .../r/ctc_crud_for_drop_column.result | 0 .../{tianchi => ctc}/r/ctc_datatype.result | 0 .../r/ctc_datatype_adapt.result | 0 .../r/ctc_datatype_blob.result | 0 .../r/ctc_datetime_analyze.result | 0 .../{tianchi => ctc}/r/ctc_dc_reuse.result | 0 .../suite/{tianchi => ctc}/r/ctc_dcl.result | 0 .../suite/{tianchi => ctc}/r/ctc_ddl.result | 20 +- .../r/ctc_ddl_alter_table.result | 0 .../{tianchi => ctc}/r/ctc_ddl_analyze.result | 0 .../r/ctc_ddl_auto_inc.result | 0 .../{tianchi => ctc}/r/ctc_ddl_cascade.result | 0 .../r/ctc_ddl_character_set.result | 0 .../r/ctc_ddl_create_table.result} | 3706 ++++++++--------- .../r/ctc_ddl_create_table_check.result | 0 .../r/ctc_ddl_default_index.result | 0 .../{tianchi => ctc}/r/ctc_ddl_engine.result | 36 +- .../r/ctc_ddl_foreign_key.result | 0 .../r/ctc_ddl_foreign_key_set_enum.result | 0 .../r/ctc_ddl_func_index.result | 0 .../r/ctc_ddl_func_proc.result | 0 .../r/ctc_ddl_generated_columns.result | 0 .../{tianchi => ctc}/r/ctc_ddl_index.result | 0 .../r/ctc_ddl_max_reclength.result | 0 .../r/ctc_ddl_multi_db.result | 0 .../r/ctc_ddl_partition.result | 0 .../r/ctc_ddl_temporary_table.result | 0 .../{tianchi => ctc}/r/ctc_ddl_trigger.result | 28 +- .../r/ctc_ddl_unsupport_command.result | 0 .../{tianchi => ctc}/r/ctc_ddl_view.result | 0 .../r/ctc_decimal_analyze.result | 0 .../{tianchi => ctc}/r/ctc_delete_time.result | 0 .../r/ctc_dml_decimal_table.result | 0 .../{tianchi => ctc}/r/ctc_dml_ignore.result | 0 .../r/ctc_dml_two_table.result | 0 .../r/ctc_enum_analyze.result | 0 .../r/ctc_handler_operation.result | 0 .../r/ctc_index_functions_base.result | 0 .../{tianchi => ctc}/r/ctc_insert_time.result | 0 .../{tianchi => ctc}/r/ctc_json_value.result | 0 .../suite/{tianchi => ctc}/r/ctc_lcov.result | 0 .../r/ctc_link_and_migr_row.result | 0 .../r/ctc_lock_instance.result | 0 ...urrency_with_nowait_and_skip_locked.result | 0 .../r/ctc_partition_update.result | 0 .../{tianchi => ctc}/r/ctc_read_only.result | 0 .../r/ctc_select_early_return.result | 0 .../{tianchi => ctc}/r/ctc_set_analyze.result | 0 .../r/ctc_string_analyze.result | 0 .../{tianchi => ctc}/r/ctc_update_time.result | 0 .../{tianchi => ctc}/r/ctc_varchar.result | 0 .../r/recreate_test_db.result | 0 .../{tianchi => ctc}/t/ctc_atomic_ddl.test | 0 .../t/ctc_auto_increment.test | 0 .../{tianchi => ctc}/t/ctc_bit_analyze.test | 0 .../suite/{tianchi => ctc}/t/ctc_charset.test | 0 .../t/ctc_charset_binary.test | 0 .../t/ctc_charset_collate.test | 0 .../t/ctc_compressed_proxy_conn.test | 0 .../{tianchi => ctc}/t/ctc_cond_pushdown.test | 0 .../t/ctc_cond_pushdown_explain.test | 0 .../t/ctc_crud_for_drop_column.test | 0 .../{tianchi => ctc}/t/ctc_datatype.test | 6 +- .../t/ctc_datatype_adapt.test | 4 +- .../{tianchi => ctc}/t/ctc_datatype_blob.test | 2 +- .../t/ctc_datetime_analyze.test | 0 .../{tianchi => ctc}/t/ctc_dc_reuse.test | 0 .../suite/{tianchi => ctc}/t/ctc_dcl.test | 0 .../suite/{tianchi => ctc}/t/ctc_ddl.test | 22 +- .../t/ctc_ddl_alter_table.test | 2 +- .../{tianchi => ctc}/t/ctc_ddl_analyze.test | 0 .../{tianchi => ctc}/t/ctc_ddl_auto_inc.test | 2 +- .../{tianchi => ctc}/t/ctc_ddl_cascade.test | 0 .../t/ctc_ddl_character_set.test | 0 .../t/ctc_ddl_create_table.test | 0 .../t/ctc_ddl_create_table_check.test | 0 .../t/ctc_ddl_default_index.test | 0 .../{tianchi => ctc}/t/ctc_ddl_engine.test | 28 +- .../t/ctc_ddl_fault_process.test | 26 +- .../t/ctc_ddl_foreign_key.test | 0 .../t/ctc_ddl_foreign_key_set_enum.test | 0 .../t/ctc_ddl_func_index.test | 0 .../{tianchi => ctc}/t/ctc_ddl_func_proc.test | 0 .../t/ctc_ddl_generated_columns.test | 0 .../{tianchi => ctc}/t/ctc_ddl_index.test | 0 .../{tianchi => ctc}/t/ctc_ddl_limit.test | 0 .../t/ctc_ddl_max_reclength.test | 0 .../{tianchi => ctc}/t/ctc_ddl_multi_db.test | 0 .../{tianchi => ctc}/t/ctc_ddl_partition.test | 0 .../t/ctc_ddl_tablespace.test | 2 +- .../t/ctc_ddl_temporary_table.test | 4 +- .../t/ctc_ddl_too_many_databases.test | 0 .../{tianchi => ctc}/t/ctc_ddl_trigger.test | 16 +- .../t/ctc_ddl_unsupport_command.test | 2 +- .../{tianchi => ctc}/t/ctc_ddl_view.test | 0 .../t/ctc_decimal_analyze.test | 0 .../{tianchi => ctc}/t/ctc_delete_time.test | 0 .../t/ctc_dml_decimal_table.test | 0 .../{tianchi => ctc}/t/ctc_dml_ignore.test | 0 .../{tianchi => ctc}/t/ctc_dml_two_table.test | 2 +- .../{tianchi => ctc}/t/ctc_enum_analyze.test | 0 .../t/ctc_handler_operation.test | 0 .../t/ctc_index_functions_base.test | 0 .../{tianchi => ctc}/t/ctc_insert_time.test | 0 .../{tianchi => ctc}/t/ctc_json_value.test | 0 .../suite/{tianchi => ctc}/t/ctc_lcov.test | 2 +- .../t/ctc_link_and_migr_row.test | 0 .../{tianchi => ctc}/t/ctc_lock_instance.test | 0 ...ncurrency_with_nowait_and_skip_locked.test | 0 .../t/ctc_partition_update.test | 0 .../{tianchi => ctc}/t/ctc_read_only.test | 0 .../t/ctc_select_early_return.test | 0 .../{tianchi => ctc}/t/ctc_set_analyze.test | 0 .../t/ctc_string_analyze.test | 2 +- .../{tianchi => ctc}/t/ctc_update_time.test | 0 .../suite/{tianchi => ctc}/t/ctc_varchar.test | 0 .../{tianchi => ctc}/t/recreate_test_db.test | 0 storage/{tianchi => ctc}/CMakeLists.txt | 36 +- .../{tianchi/tse_cbo.cc => ctc/ctc_cbo.cc} | 102 +- storage/{tianchi/tse_cbo.h => ctc/ctc_cbo.h} | 34 +- .../ctc_ddl_rewriter_plugin.cc} | 472 +-- .../tse_ddl_util.cc => ctc/ctc_ddl_util.cc} | 216 +- .../tse_ddl_util.h => ctc/ctc_ddl_util.h} | 48 +- .../tse_error.cc => ctc/ctc_error.cc} | 12 +- .../{tianchi/tse_error.h => ctc/ctc_error.h} | 14 +- storage/{tianchi/tse_log.h => ctc/ctc_log.h} | 58 +- storage/{tianchi => ctc}/ctc_meta_data.cc | 364 +- storage/{tianchi => ctc}/ctc_meta_data.h | 14 +- .../ctc_mysql_proxy.cc} | 284 +- .../ctc_proxy_util.cc} | 68 +- .../tse_proxy_util.h => ctc/ctc_proxy_util.h} | 20 +- storage/{tianchi/tse_srv.h => ctc/ctc_srv.h} | 566 +-- .../ctc_srv_mq_module.cc} | 184 +- .../ctc_srv_mq_module.h} | 14 +- .../ctc_srv_mq_stub.cc} | 504 +-- .../tse_stats.cc => ctc/ctc_stats.cc} | 152 +- .../{tianchi/tse_stats.h => ctc/ctc_stats.h} | 10 +- .../{tianchi/tse_util.cc => ctc/ctc_util.cc} | 324 +- .../{tianchi/tse_util.h => ctc/ctc_util.h} | 62 +- .../datatype_cnvrt_4_index_search.cc | 38 +- .../datatype_cnvrt_4_index_search.h | 6 +- storage/{tianchi => ctc}/datatype_cnvrtr.cc | 212 +- storage/{tianchi => ctc}/datatype_cnvrtr.h | 24 +- storage/{tianchi => ctc}/decimal_convert.cc | 6 +- storage/{tianchi => ctc}/decimal_convert.h | 0 storage/{tianchi/ha_tse.cc => ctc/ha_ctc.cc} | 1710 ++++---- storage/{tianchi/ha_tse.h => ctc/ha_ctc.h} | 118 +- .../ha_tse_ddl.cc => ctc/ha_ctc_ddl.cc} | 1226 +++--- .../ha_tse_ddl.h => ctc/ha_ctc_ddl.h} | 158 +- .../ha_tsepart.cc => ctc/ha_ctcpart.cc} | 360 +- .../ha_tsepart.h => ctc/ha_ctcpart.h} | 32 +- .../{tianchi => ctc}/message_queue/dsw_list.h | 0 .../message_queue/dsw_message.h | 0 .../{tianchi => ctc}/message_queue/dsw_shm.h | 0 .../message_queue/dsw_typedef.h | 0 storage/{tianchi => ctc}/mysql_daac_plugin.cc | 26 +- .../{tianchi => ctc}/protobuf/tc_db.pb-c.c | 1982 ++++----- .../{tianchi => ctc}/protobuf/tc_db.pb-c.h | 1056 ++--- storage/{tianchi => ctc}/protobuf/tc_db.proto | 106 +- storage/{tianchi => ctc}/srv_mq_msg.h | 130 +- 172 files changed, 7388 insertions(+), 7388 deletions(-) rename mysql-test/suite/{tianchi => ctc}/r/ctc_atomic_ddl.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_auto_increment.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_bit_analyze.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_charset.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_charset_binary.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_charset_collate.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_compressed_proxy_conn.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_cond_pushdown.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_cond_pushdown_explain.result (100%) rename mysql-test/suite/{tianchi/r/ctc_ddl_create_table.result => ctc/r/ctc_create_table.result} (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_crud_for_drop_column.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_datatype.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_datatype_adapt.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_datatype_blob.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_datetime_analyze.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_dc_reuse.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_dcl.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl.result (91%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_alter_table.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_analyze.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_auto_inc.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_cascade.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_character_set.result (100%) rename mysql-test/suite/{tianchi/r/ctc_create_table.result => ctc/r/ctc_ddl_create_table.result} (97%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_create_table_check.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_default_index.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_engine.result (82%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_foreign_key.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_foreign_key_set_enum.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_func_index.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_func_proc.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_generated_columns.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_index.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_max_reclength.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_multi_db.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_partition.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_temporary_table.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_trigger.result (87%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_unsupport_command.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_ddl_view.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_decimal_analyze.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_delete_time.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_dml_decimal_table.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_dml_ignore.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_dml_two_table.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_enum_analyze.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_handler_operation.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_index_functions_base.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_insert_time.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_json_value.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_lcov.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_link_and_migr_row.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_lock_instance.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_locking_read_concurrency_with_nowait_and_skip_locked.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_partition_update.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_read_only.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_select_early_return.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_set_analyze.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_string_analyze.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_update_time.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/ctc_varchar.result (100%) rename mysql-test/suite/{tianchi => ctc}/r/recreate_test_db.result (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_atomic_ddl.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_auto_increment.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_bit_analyze.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_charset.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_charset_binary.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_charset_collate.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_compressed_proxy_conn.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_cond_pushdown.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_cond_pushdown_explain.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_crud_for_drop_column.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_datatype.test (98%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_datatype_adapt.test (97%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_datatype_blob.test (99%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_datetime_analyze.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_dc_reuse.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_dcl.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl.test (87%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_alter_table.test (99%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_analyze.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_auto_inc.test (99%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_cascade.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_character_set.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_create_table.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_create_table_check.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_default_index.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_engine.test (67%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_fault_process.test (90%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_foreign_key.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_foreign_key_set_enum.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_func_index.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_func_proc.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_generated_columns.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_index.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_limit.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_max_reclength.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_multi_db.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_partition.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_tablespace.test (98%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_temporary_table.test (97%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_too_many_databases.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_trigger.test (80%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_unsupport_command.test (99%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_ddl_view.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_decimal_analyze.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_delete_time.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_dml_decimal_table.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_dml_ignore.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_dml_two_table.test (94%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_enum_analyze.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_handler_operation.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_index_functions_base.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_insert_time.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_json_value.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_lcov.test (97%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_link_and_migr_row.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_lock_instance.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_locking_read_concurrency_with_nowait_and_skip_locked.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_partition_update.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_read_only.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_select_early_return.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_set_analyze.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_string_analyze.test (98%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_update_time.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/ctc_varchar.test (100%) rename mysql-test/suite/{tianchi => ctc}/t/recreate_test_db.test (100%) rename storage/{tianchi => ctc}/CMakeLists.txt (69%) rename storage/{tianchi/tse_cbo.cc => ctc/ctc_cbo.cc} (89%) rename storage/{tianchi/tse_cbo.h => ctc/ctc_cbo.h} (73%) rename storage/{tianchi/tse_ddl_rewriter_plugin.cc => ctc/ctc_ddl_rewriter_plugin.cc} (75%) rename storage/{tianchi/tse_ddl_util.cc => ctc/ctc_ddl_util.cc} (68%) rename storage/{tianchi/tse_ddl_util.h => ctc/ctc_ddl_util.h} (46%) rename storage/{tianchi/tse_error.cc => ctc/ctc_error.cc} (96%) rename storage/{tianchi/tse_error.h => ctc/ctc_error.h} (96%) rename storage/{tianchi/tse_log.h => ctc/ctc_log.h} (75%) rename storage/{tianchi => ctc}/ctc_meta_data.cc (71%) rename storage/{tianchi => ctc}/ctc_meta_data.h (66%) rename storage/{tianchi/tse_mysql_proxy.cc => ctc/ctc_mysql_proxy.cc} (69%) rename storage/{tianchi/tse_proxy_util.cc => ctc/ctc_proxy_util.cc} (79%) rename storage/{tianchi/tse_proxy_util.h => ctc/ctc_proxy_util.h} (80%) rename storage/{tianchi/tse_srv.h => ctc/ctc_srv.h} (47%) rename storage/{tianchi/tse_srv_mq_module.cc => ctc/ctc_srv_mq_module.cc} (72%) rename storage/{tianchi/tse_srv_mq_module.h => ctc/ctc_srv_mq_module.h} (79%) rename storage/{tianchi/tse_srv_mq_stub.cc => ctc/ctc_srv_mq_stub.cc} (73%) rename storage/{tianchi/tse_stats.cc => ctc/ctc_stats.cc} (65%) rename storage/{tianchi/tse_stats.h => ctc/ctc_stats.h} (87%) rename storage/{tianchi/tse_util.cc => ctc/ctc_util.cc} (71%) rename storage/{tianchi/tse_util.h => ctc/ctc_util.h} (51%) rename storage/{tianchi => ctc}/datatype_cnvrt_4_index_search.cc (87%) rename storage/{tianchi => ctc}/datatype_cnvrt_4_index_search.h (87%) rename storage/{tianchi => ctc}/datatype_cnvrtr.cc (92%) rename storage/{tianchi => ctc}/datatype_cnvrtr.h (92%) rename storage/{tianchi => ctc}/decimal_convert.cc (99%) rename storage/{tianchi => ctc}/decimal_convert.h (100%) rename storage/{tianchi/ha_tse.cc => ctc/ha_ctc.cc} (77%) rename storage/{tianchi/ha_tse.h => ctc/ha_ctc.h} (92%) rename storage/{tianchi/ha_tse_ddl.cc => ctc/ha_ctc_ddl.cc} (68%) rename storage/{tianchi/ha_tse_ddl.h => ctc/ha_ctc_ddl.h} (62%) rename storage/{tianchi/ha_tsepart.cc => ctc/ha_ctcpart.cc} (75%) rename storage/{tianchi/ha_tsepart.h => ctc/ha_ctcpart.h} (96%) rename storage/{tianchi => ctc}/message_queue/dsw_list.h (100%) rename storage/{tianchi => ctc}/message_queue/dsw_message.h (100%) rename storage/{tianchi => ctc}/message_queue/dsw_shm.h (100%) rename storage/{tianchi => ctc}/message_queue/dsw_typedef.h (100%) rename storage/{tianchi => ctc}/mysql_daac_plugin.cc (86%) rename storage/{tianchi => ctc}/protobuf/tc_db.pb-c.c (57%) rename storage/{tianchi => ctc}/protobuf/tc_db.pb-c.h (42%) rename storage/{tianchi => ctc}/protobuf/tc_db.proto (68%) rename storage/{tianchi => ctc}/srv_mq_msg.h (80%) diff --git a/mysql-test/enableCases.list b/mysql-test/enableCases.list index 6e3d6e6..ff25a32 100644 --- a/mysql-test/enableCases.list +++ b/mysql-test/enableCases.list @@ -12,8 +12,8 @@ slow_query_log_func # ------ BEGIN TEST CASES OF DML ------ ctc_compressed_proxy_conn ctc_dml_ignore -tianchi.ctc_dml_two_table -tianchi.ctc_link_and_migr_row +ctc.ctc_dml_two_table +ctc.ctc_link_and_migr_row #test_services ctc_datetime_analyze ctc_set_analyze @@ -27,50 +27,50 @@ binlog_transaction_write_set_savepoint_basic binlog_transaction_write_set_savepoint_clear_identifiers binlog_transaction_write_set_savepoint_insert_overwrite_identifier # current rc isolation level lock mode is not same as innodb, already record -#tianchi.ctc_dc_reuse +#ctc.ctc_dc_reuse # ------ END TEST CASES OF TRANSACTION ------ # ------ BEGIN TEST CASES OF INDEX ------ -tianchi.ctc_index_functions_base +ctc.ctc_index_functions_base innodb.multi_value_basic #update_delete_number # ------ END TEST CASES OF INDEX ------ # ------ BEGIN TEST CASES OF DATATYPE ------ -tianchi.ctc_datatype -tianchi.ctc_datatype_blob -tianchi.ctc_datatype_adapt +ctc.ctc_datatype +ctc.ctc_datatype_blob +ctc.ctc_datatype_adapt lob_double_purge json_small_partial_update_04 -# tianchi.ctc_json_value.test +# ctc.ctc_json_value.test # ------ END TEST CASES OF DATATYPE ------ # ------ BEGIN TEST CASES OF PARTITION ------ -tianchi.ctc_partition_update +ctc.ctc_partition_update # ------ END TEST CASES OF PARTITION ------ # ------ BEGIN TEST CASES OF DDL ------ -tianchi.ctc_ddl_func_index -tianchi.ctc_ddl_trigger -tianchi.ctc_ddl_view -tianchi.ctc_ddl_index -tianchi.ctc_ddl_partition -tianchi.ctc_ddl_max_reclength -tianchi.ctc_ddl_func_proc -tianchi.ctc_ddl_foreign_key -tianchi.ctc_ddl_foreign_key_set_enum -tianchi.ctc_ddl_multi_db -tianchi.ctc_ddl_temporary_table -# tianchi.ctc_ddl_engine -tianchi.ctc_ddl_func_index -tianchi.ctc_ddl_create_table_check -tianchi.ctc_ddl_generated_columns -tianchi.ctc_ddl_character_set -tianchi.ctc_dcl -# tianchi.ctc_lcov #增加覆盖率的测试用例 +ctc.ctc_ddl_func_index +ctc.ctc_ddl_trigger +ctc.ctc_ddl_view +ctc.ctc_ddl_index +ctc.ctc_ddl_partition +ctc.ctc_ddl_max_reclength +ctc.ctc_ddl_func_proc +ctc.ctc_ddl_foreign_key +ctc.ctc_ddl_foreign_key_set_enum +ctc.ctc_ddl_multi_db +ctc.ctc_ddl_temporary_table +# ctc.ctc_ddl_engine +ctc.ctc_ddl_func_index +ctc.ctc_ddl_create_table_check +ctc.ctc_ddl_generated_columns +ctc.ctc_ddl_character_set +ctc.ctc_dcl +# ctc.ctc_lcov #增加覆盖率的测试用例 # ------ END TEST CASES OF DDL ------ # ------ BEGIN TEST CASES OF CHARSET ------ @@ -83,19 +83,19 @@ ctc_ddl_default_index.test delete_decimal # update_decimal -tianchi.ctc_crud_for_drop_column.test +ctc.ctc_crud_for_drop_column.test ctc_select_early_return.test # ------ TEST CASES for cond pushdown ------ ctc_cond_pushdown.test ctc_cond_pushdown_explain.test -tianchi.ctc_varchar +ctc.ctc_varchar # ------ TEST CASES for handler operation ------ ctc_handler_operation.test -tianchi.ctc_ddl_unsupport_command +ctc.ctc_ddl_unsupport_command -tianchi.ctc_read_only +ctc.ctc_read_only subselect.test # ------ TEST CASES FROM suite/engines/funcs ------ @@ -105,10 +105,10 @@ ctc_delete_time # ------ END TEST CASES ------ ctc_dml_decimal_table.test -tianchi.ctc_ddl -tianchi.ctc_ddl_cascade -tianchi.ctc_ddl_create_table -tianchi.ctc_ddl_alter_table -tianchi.ctc_ddl_analyze -tianchi.ctc_ddl_auto_inc +ctc.ctc_ddl +ctc.ctc_ddl_cascade +ctc.ctc_ddl_create_table +ctc.ctc_ddl_alter_table +ctc.ctc_ddl_analyze +ctc.ctc_ddl_auto_inc ctc_atomic_ddl.test \ No newline at end of file diff --git a/mysql-test/mysql-source-code-meta.patch b/mysql-test/mysql-source-code-meta.patch index 075c7b6..2b5f319 100644 --- a/mysql-test/mysql-source-code-meta.patch +++ b/mysql-test/mysql-source-code-meta.patch @@ -452,7 +452,7 @@ index 80638063..c649fa53 100644 m_registry_committed.get(id_key, &element); if (element) { -+ if (m_thd->query().str && std::string(m_thd->query().str) == "tse_mdl_thd_notify") { ++ if (m_thd->query().str && std::string(m_thd->query().str) == "ctc_mdl_thd_notify") { + } else { + MDL_checker::add_to_invalidate(m_thd, element->object()); + } @@ -531,7 +531,7 @@ index 80638063..c649fa53 100644 +} + +void Dictionary_client::add_modified_objects_before_commit() { -+ if (m_thd->query().str && std::string(m_thd->query().str) == "tse_mdl_thd_notify") { ++ if (m_thd->query().str && std::string(m_thd->query().str) == "ctc_mdl_thd_notify") { + return; + } + add_modified_objects(); @@ -779,14 +779,14 @@ index 1e3ce91c..48125691 100644 static bool get_shared_tablespace_names( THD *thd, std::set *shared_spaces) { - assert(innodb_hton != nullptr && innodb_hton->get_tablespace_type); -+ assert(tse_hton != nullptr && tse_hton->get_tablespace_type); ++ assert(ctc_hton != nullptr && ctc_hton->get_tablespace_type); auto process_spaces = [&](std::unique_ptr &space) { - if (my_strcasecmp(system_charset_info, space->engine().c_str(), "InnoDB")) + if (my_strcasecmp(system_charset_info, space->engine().c_str(), "CTC")) return false; Tablespace_type space_type; - if (innodb_hton->get_tablespace_type(*space, &space_type)) { -+ if (tse_hton->get_tablespace_type(*space, &space_type)) { ++ if (ctc_hton->get_tablespace_type(*space, &space_type)) { LogErr(ERROR_LEVEL, ER_UNKNOWN_TABLESPACE_TYPE, space->name().c_str()); return true; } @@ -892,7 +892,7 @@ index 217a0c19..fe900ebd 100644 innodb_hton = hton; break; + case DB_TYPE_CTC: -+ tse_hton = hton; ++ ctc_hton = hton; + break; default: break; @@ -1400,7 +1400,7 @@ index 50b76e2f..080fdf93 100644 handlerton *temptable_hton; handlerton *myisam_hton; handlerton *innodb_hton; -+handlerton *tse_hton; ++handlerton *ctc_hton; char *opt_disabled_storage_engines; uint opt_server_id_bits = 0; @@ -1438,7 +1438,7 @@ index 0d7d41c4..b3f86eb6 100644 extern handlerton *heap_hton; extern handlerton *temptable_hton; extern handlerton *innodb_hton; -+extern handlerton *tse_hton; ++extern handlerton *ctc_hton; extern uint opt_server_id_bits; extern ulong opt_server_id_mask; extern const char *load_default_groups[]; @@ -1460,8 +1460,8 @@ index 902fe2b2..2fad578e 100644 do { + if (thread_id_counter == 0) { + handlerton *hton = ha_resolve_by_legacy_type(current_thd, DB_TYPE_CTC); -+ my_thread_id tse_inst_id = hton->get_inst_id ? (my_thread_id)hton->get_inst_id() : 0; -+ thread_id_counter = tse_inst_id << 16; ++ my_thread_id ctc_inst_id = hton->get_inst_id ? (my_thread_id)hton->get_inst_id() : 0; ++ thread_id_counter = ctc_inst_id << 16; + } new_id = thread_id_counter++; } while (!thread_ids.insert_unique(new_id).second); @@ -1750,7 +1750,7 @@ index 70d9c1ff..b98e6ecb 100644 - tmp_table.s->db_low_byte_first = (create_info->db_type == myisam_hton || - create_info->db_type == heap_hton); + tmp_table.s->db_low_byte_first = -+ (create_info->db_type == myisam_hton || create_info->db_type == heap_hton || create_info->db_type == tse_hton); ++ (create_info->db_type == myisam_hton || create_info->db_type == heap_hton || create_info->db_type == ctc_hton); tmp_table.set_not_started(); if (!thd->variables.explicit_defaults_for_timestamp) @@ -1949,7 +1949,7 @@ index 5963cf6e..3218795f 100644 // Disable ICP for Innodb intrinsic temp table because of performance - if (tbl->s->db_type() == innodb_hton && tbl->s->tmp_table != NO_TMP_TABLE && -+ if ((tbl->s->db_type() == innodb_hton || tbl->s->db_type() == tse_hton) && tbl->s->tmp_table != NO_TMP_TABLE && ++ if ((tbl->s->db_type() == innodb_hton || tbl->s->db_type() == ctc_hton) && tbl->s->tmp_table != NO_TMP_TABLE && tbl->s->tmp_table != TRANSACTIONAL_TMP_TABLE) return; @@ -2139,9 +2139,9 @@ index 2063261b..1c71f772 100644 plugin_unlock(nullptr, db_plugin); + + // Cache CTC engine's -+ db_plugin = ha_lock_engine(nullptr, tse_hton); ++ db_plugin = ha_lock_engine(nullptr, ctc_hton); + handler = get_new_handler((TABLE_SHARE *)nullptr, false, thd->mem_root, -+ tse_hton); ++ ctc_hton); + CTC_MAX_KEY_LENGTH = handler->max_key_length(); + CTC_MAX_KEY_PART_LENGTH = handler->max_key_parts(); + CTC_MAX_KEY_PARTS = handler->max_key_parts(); @@ -2186,7 +2186,7 @@ index 2063261b..1c71f772 100644 force_disk_table, mem_engine)) { - hton = innodb_hton; + //hton = innodb_hton; -+ hton = tse_hton; ++ hton = ctc_hton; } else { switch (mem_engine) { case TMP_TABLE_TEMPTABLE: @@ -2197,7 +2197,7 @@ index 2063261b..1c71f772 100644 - table->s->db_type() == innodb_hton); + table->s->db_type() == innodb_hton || + table->s->db_type() == myisam_hton || -+ table->s->db_type() == tse_hton); ++ table->s->db_type() == ctc_hton); int error; if ((error = table->file->ha_open(table, table->s->table_name.str, O_RDWR, @@ -2206,7 +2206,7 @@ index 2063261b..1c71f772 100644 table->s->db_type() == temptable_hton) { table->file = get_new_handler( - table->s, false, share->alloc_for_tmp_file_handler, innodb_hton); -+ table->s, false, share->alloc_for_tmp_file_handler, tse_hton); ++ table->s, false, share->alloc_for_tmp_file_handler, ctc_hton); error = table->file->create(share->table_name.str, table, &create_info, nullptr); } @@ -2214,7 +2214,7 @@ index 2063261b..1c71f772 100644 trace_tmp.add_alnum("record_format", "fixed"); } else if (table->s->db_type() == temptable_hton) { trace_tmp.add_alnum("location", "TempTable"); -+ } else if (table->s->db_type() == tse_hton) { ++ } else if (table->s->db_type() == ctc_hton) { + trace_tmp.add_alnum("location", "CTC"); } else { assert(s->db_type() == heap_hton); @@ -2223,7 +2223,7 @@ index 2063261b..1c71f772 100644 if (create_tmp_table_with_fallback(thd, table)) return true; // Make empty record so random data is not written to disk empty_record(table); -+ } else if (share->db_type() == tse_hton) { ++ } else if (share->db_type() == ctc_hton) { + if (create_tmp_table_with_fallback(thd, table)) return true; + // Make empty record so random data is not written to disk + empty_record(table); @@ -2238,7 +2238,7 @@ index 2063261b..1c71f772 100644 - share.db_plugin = ha_lock_engine(thd, innodb_hton); + //share.db_plugin = ha_lock_engine(thd, innodb_hton); -+ share.db_plugin = ha_lock_engine(thd, tse_hton); ++ share.db_plugin = ha_lock_engine(thd, ctc_hton); TABLE_LIST *const wtable_list = wtable->pos_in_table_list; Derived_refs_iterator ref_it(wtable_list); @@ -2247,7 +2247,7 @@ index 2063261b..1c71f772 100644 */ bool reposition_innodb_cursor(TABLE *table, ha_rows row_num) { - assert(table->s->db_type() == innodb_hton); -+ assert(table->s->db_type() == tse_hton); ++ assert(table->s->db_type() == ctc_hton); + my_error(ER_FEATURE_UNSUPPORTED, MYF(0), "reposition_innodb_cursor", "by CTC"); + return true; if (table->file->ha_rnd_init(false)) return true; /* purecov: inspected */ @@ -2312,7 +2312,7 @@ index cb0f1409..a6da7249 100644 return true; - assert(t->s->db_type() == innodb_hton); -+ assert(t->s->db_type() == tse_hton); ++ assert(t->s->db_type() == ctc_hton); if (t->file->ha_rnd_init(true)) return true; /* purecov: inspected */ if (!w->m_frame_buffer_positions.empty()) { diff --git a/mysql-test/suite/tianchi/r/ctc_atomic_ddl.result b/mysql-test/suite/ctc/r/ctc_atomic_ddl.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_atomic_ddl.result rename to mysql-test/suite/ctc/r/ctc_atomic_ddl.result diff --git a/mysql-test/suite/tianchi/r/ctc_auto_increment.result b/mysql-test/suite/ctc/r/ctc_auto_increment.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_auto_increment.result rename to mysql-test/suite/ctc/r/ctc_auto_increment.result diff --git a/mysql-test/suite/tianchi/r/ctc_bit_analyze.result b/mysql-test/suite/ctc/r/ctc_bit_analyze.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_bit_analyze.result rename to mysql-test/suite/ctc/r/ctc_bit_analyze.result diff --git a/mysql-test/suite/tianchi/r/ctc_charset.result b/mysql-test/suite/ctc/r/ctc_charset.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_charset.result rename to mysql-test/suite/ctc/r/ctc_charset.result diff --git a/mysql-test/suite/tianchi/r/ctc_charset_binary.result b/mysql-test/suite/ctc/r/ctc_charset_binary.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_charset_binary.result rename to mysql-test/suite/ctc/r/ctc_charset_binary.result diff --git a/mysql-test/suite/tianchi/r/ctc_charset_collate.result b/mysql-test/suite/ctc/r/ctc_charset_collate.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_charset_collate.result rename to mysql-test/suite/ctc/r/ctc_charset_collate.result diff --git a/mysql-test/suite/tianchi/r/ctc_compressed_proxy_conn.result b/mysql-test/suite/ctc/r/ctc_compressed_proxy_conn.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_compressed_proxy_conn.result rename to mysql-test/suite/ctc/r/ctc_compressed_proxy_conn.result diff --git a/mysql-test/suite/tianchi/r/ctc_cond_pushdown.result b/mysql-test/suite/ctc/r/ctc_cond_pushdown.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_cond_pushdown.result rename to mysql-test/suite/ctc/r/ctc_cond_pushdown.result diff --git a/mysql-test/suite/tianchi/r/ctc_cond_pushdown_explain.result b/mysql-test/suite/ctc/r/ctc_cond_pushdown_explain.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_cond_pushdown_explain.result rename to mysql-test/suite/ctc/r/ctc_cond_pushdown_explain.result diff --git a/mysql-test/suite/tianchi/r/ctc_ddl_create_table.result b/mysql-test/suite/ctc/r/ctc_create_table.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_ddl_create_table.result rename to mysql-test/suite/ctc/r/ctc_create_table.result diff --git a/mysql-test/suite/tianchi/r/ctc_crud_for_drop_column.result b/mysql-test/suite/ctc/r/ctc_crud_for_drop_column.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_crud_for_drop_column.result rename to mysql-test/suite/ctc/r/ctc_crud_for_drop_column.result diff --git a/mysql-test/suite/tianchi/r/ctc_datatype.result b/mysql-test/suite/ctc/r/ctc_datatype.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_datatype.result rename to mysql-test/suite/ctc/r/ctc_datatype.result diff --git a/mysql-test/suite/tianchi/r/ctc_datatype_adapt.result b/mysql-test/suite/ctc/r/ctc_datatype_adapt.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_datatype_adapt.result rename to mysql-test/suite/ctc/r/ctc_datatype_adapt.result diff --git a/mysql-test/suite/tianchi/r/ctc_datatype_blob.result b/mysql-test/suite/ctc/r/ctc_datatype_blob.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_datatype_blob.result rename to mysql-test/suite/ctc/r/ctc_datatype_blob.result diff --git a/mysql-test/suite/tianchi/r/ctc_datetime_analyze.result b/mysql-test/suite/ctc/r/ctc_datetime_analyze.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_datetime_analyze.result rename to mysql-test/suite/ctc/r/ctc_datetime_analyze.result diff --git a/mysql-test/suite/tianchi/r/ctc_dc_reuse.result b/mysql-test/suite/ctc/r/ctc_dc_reuse.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_dc_reuse.result rename to mysql-test/suite/ctc/r/ctc_dc_reuse.result diff --git a/mysql-test/suite/tianchi/r/ctc_dcl.result b/mysql-test/suite/ctc/r/ctc_dcl.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_dcl.result rename to mysql-test/suite/ctc/r/ctc_dcl.result diff --git a/mysql-test/suite/tianchi/r/ctc_ddl.result b/mysql-test/suite/ctc/r/ctc_ddl.result similarity index 91% rename from mysql-test/suite/tianchi/r/ctc_ddl.result rename to mysql-test/suite/ctc/r/ctc_ddl.result index a277457..7c7506f 100644 --- a/mysql-test/suite/tianchi/r/ctc_ddl.result +++ b/mysql-test/suite/ctc/r/ctc_ddl.result @@ -182,25 +182,25 @@ create table ``(i int); ERROR 42000: Incorrect table name '' create table ` `(i int); ERROR 42000: Incorrect table name ' ' -set debug = '+d, tse_lock_table_fail'; -set debug = '+d, tse_lock_table_fail_DDL_LOCKED'; +set debug = '+d, ctc_lock_table_fail'; +set debug = '+d, ctc_lock_table_fail_DDL_LOCKED'; create table test1(i int); ERROR HY000: Instance has been locked, disallow this operation -set debug = '-d, tse_lock_table_fail_DDL_LOCKED'; -set debug = '+d, tse_lock_table_fail_VERSION_NOT_MATCH'; +set debug = '-d, ctc_lock_table_fail_DDL_LOCKED'; +set debug = '+d, ctc_lock_table_fail_VERSION_NOT_MATCH'; create table test1(i int); ERROR HY000: Version not match. Please make sure cluster on the same version. -set debug = '-d, tse_lock_table_fail_VERSION_NOT_MATCH'; -set debug = '+d, tse_lock_table_fail_DISALLOW_OPERATION'; +set debug = '-d, ctc_lock_table_fail_VERSION_NOT_MATCH'; +set debug = '+d, ctc_lock_table_fail_DISALLOW_OPERATION'; create table test1(i int); ERROR HY000: The table or database is being used. Please try again later. -set debug = '-d, tse_lock_table_fail_DISALLOW_OPERATION'; -set debug = '-d, tse_lock_table_fail'; +set debug = '-d, ctc_lock_table_fail_DISALLOW_OPERATION'; +set debug = '-d, ctc_lock_table_fail'; create table test1(i int); set debug = '+d, non_metadata_normalization'; -set debug = '+d, tse_ddl_rewrite_broadcast_fail'; +set debug = '+d, ctc_ddl_rewrite_broadcast_fail'; lock table test1 write; ERROR HY000: Version not match. Please make sure cluster on the same version. -set debug = '-d, tse_ddl_rewrite_broadcast_fail'; +set debug = '-d, ctc_ddl_rewrite_broadcast_fail'; set debug = '-d, non_metadata_normalization'; drop table test1; diff --git a/mysql-test/suite/tianchi/r/ctc_ddl_alter_table.result b/mysql-test/suite/ctc/r/ctc_ddl_alter_table.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_ddl_alter_table.result rename to mysql-test/suite/ctc/r/ctc_ddl_alter_table.result diff --git a/mysql-test/suite/tianchi/r/ctc_ddl_analyze.result b/mysql-test/suite/ctc/r/ctc_ddl_analyze.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_ddl_analyze.result rename to mysql-test/suite/ctc/r/ctc_ddl_analyze.result diff --git a/mysql-test/suite/tianchi/r/ctc_ddl_auto_inc.result b/mysql-test/suite/ctc/r/ctc_ddl_auto_inc.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_ddl_auto_inc.result rename to mysql-test/suite/ctc/r/ctc_ddl_auto_inc.result diff --git a/mysql-test/suite/tianchi/r/ctc_ddl_cascade.result b/mysql-test/suite/ctc/r/ctc_ddl_cascade.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_ddl_cascade.result rename to mysql-test/suite/ctc/r/ctc_ddl_cascade.result diff --git a/mysql-test/suite/tianchi/r/ctc_ddl_character_set.result b/mysql-test/suite/ctc/r/ctc_ddl_character_set.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_ddl_character_set.result rename to mysql-test/suite/ctc/r/ctc_ddl_character_set.result diff --git a/mysql-test/suite/tianchi/r/ctc_create_table.result b/mysql-test/suite/ctc/r/ctc_ddl_create_table.result similarity index 97% rename from mysql-test/suite/tianchi/r/ctc_create_table.result rename to mysql-test/suite/ctc/r/ctc_ddl_create_table.result index 7ea8d3f..f88dd01 100644 --- a/mysql-test/suite/tianchi/r/ctc_create_table.result +++ b/mysql-test/suite/ctc/r/ctc_ddl_create_table.result @@ -1,1853 +1,1853 @@ -drop table if exists DEMO; -drop table if exists t1; -create table DEMO (ID integer not null, NAME varchar(10), AGE integer, GRADE real) DEFAULT CHARSET=utf8; -Warnings: -Warning 3719 'utf8' is currently an alias for the character set UTF8MB3, but will be an alias for UTF8MB4 in a future release. Please consider using UTF8MB4 in order to be unambiguous. -desc DEMO; -Field Type Null Key Default Extra -ID int NO NULL -NAME varchar(10) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL, - `NAME` varchar(10) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb3 -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -insert into DEMO values (1, 'LIOR', 35, 6.9); -insert into DEMO values (4, 'MIKE', 55, 99.92); -insert into DEMO values (8, 'ROMAN', 40, 94.1); -insert into DEMO values (16, 'DAN', 60, 1234567890); -insert into DEMO values (32, 'ZVI', 35, 777.666); -insert into DEMO values (1, 'Eitan', NULL, 4.9); -insert into DEMO values (888888, 'zhangdi', NULL, 10000.8); -insert into DEMO values (1131, 'Hisses', 1, NULL); -insert into DEMO values (null, 'ff', 36, 8.9); -ERROR 23000: Column 'ID' cannot be null -insert into DEMO values (12, 'abcdefghija', 36, 8.9); -ERROR 22001: Data too long for column 'NAME' at row 1 -insert into DEMO values (12, 'abcdefghij', 36, 8.9); -insert into DEMO values (12, 'abcdefghi中', 36, 8.9); -insert into DEMO values (12, 'abcdefghi中国', 36, 8.9); -ERROR 22001: Data too long for column 'NAME' at row 1 -SELECT * FROM DEMO; -ID NAME AGE GRADE -1 LIOR 35 6.9 -4 MIKE 55 99.92 -8 ROMAN 40 94.1 -16 DAN 60 1234567890 -32 ZVI 35 777.666 -1 Eitan NULL 4.9 -888888 zhangdi NULL 10000.8 -1131 Hisses 1 NULL -12 abcdefghij 36 8.9 -12 abcdefghi中 36 8.9 -desc DEMO; -Field Type Null Key Default Extra -ID int NO NULL -NAME varchar(10) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL, - `NAME` varchar(10) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb3 -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -drop table DEMO; -create table DEMO (ID integer PRIMARY KEY, NAME varchar(19), AGE integer, GRADE real); -desc DEMO; -Field Type Null Key Default Extra -ID int NO PRI NULL -NAME varchar(19) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL, - `NAME` varchar(19) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL, - PRIMARY KEY (`ID`) -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -DEMO 0 PRIMARY 1 ID A NULL NULL NULL BTREE YES NULL -insert into DEMO values (1, 'LIOR', 35, 6.9); -insert into DEMO values (1, 'MIKE', 55, 99.92); -ERROR 23000: Duplicate entry '1' for key 'DEMO.PRIMARY' -insert into DEMO (NAME,AGE,GRADE) values ('MIKE', 55, 99.92); -ERROR HY000: Field 'ID' doesn't have a default value -insert into DEMO values (2, 'LIOR', 35, 6.9); -alter table DEMO drop primary key; -insert into DEMO values (1, 'MIKE', 55, 99.92); -SELECT * FROM DEMO; -ID NAME AGE GRADE -1 LIOR 35 6.9 -2 LIOR 35 6.9 -1 MIKE 55 99.92 -desc DEMO; -Field Type Null Key Default Extra -ID int NO NULL -NAME varchar(19) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL, - `NAME` varchar(19) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -drop table DEMO; -create table DEMO (ID integer, NAME varchar(19), AGE integer, GRADE real, PRIMARY KEY (ID, NAME)); -desc DEMO; -Field Type Null Key Default Extra -ID int NO PRI NULL -NAME varchar(19) NO PRI NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL, - `NAME` varchar(19) NOT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL, - PRIMARY KEY (`ID`,`NAME`) -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -DEMO 0 PRIMARY 1 ID A NULL NULL NULL BTREE YES NULL -DEMO 0 PRIMARY 2 NAME A NULL NULL NULL BTREE YES NULL -insert into DEMO values (888888, 'zhangdi', 35, 10000.8); -insert into DEMO values (888888, 'zhangdi', 35, 10000.8); -ERROR 23000: Duplicate entry '888888-zhangdi' for key 'DEMO.PRIMARY' -insert into DEMO values (888889, 'zhangdi', 11, 99.8); -insert into DEMO values (888888, 'zhangdi1', 35, 10000.8); -insert into DEMO values (122, 'LIOR', 22, 77.8); -insert into DEMO values (31434, 'ALEX', 43, 100.8); -alter table DEMO drop primary key; -insert into DEMO values (888888, 'zhangdi', 35, 10000.8); -SELECT * FROM DEMO; -ID NAME AGE GRADE -888888 zhangdi 35 10000.8 -888889 zhangdi 11 99.8 -888888 zhangdi1 35 10000.8 -122 LIOR 22 77.8 -31434 ALEX 43 100.8 -888888 zhangdi 35 10000.8 -desc DEMO; -Field Type Null Key Default Extra -ID int NO NULL -NAME varchar(19) NO NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL, - `NAME` varchar(19) NOT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -drop table DEMO; -create table DEMO (ID integer, NAME varchar(19), AGE integer, GRADE real, CONSTRAINT pk_demo PRIMARY KEY (ID, NAME)); -desc DEMO; -Field Type Null Key Default Extra -ID int NO PRI NULL -NAME varchar(19) NO PRI NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL, - `NAME` varchar(19) NOT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL, - PRIMARY KEY (`ID`,`NAME`) -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -DEMO 0 PRIMARY 1 ID A NULL NULL NULL BTREE YES NULL -DEMO 0 PRIMARY 2 NAME A NULL NULL NULL BTREE YES NULL -insert into DEMO values (888888, 'zhangdi', 35, 10000.8); -insert into DEMO values (888888, 'zhangdi', 35, 10000.8); -ERROR 23000: Duplicate entry '888888-zhangdi' for key 'DEMO.PRIMARY' -insert into DEMO values (888889, 'zhangdi', 11, 99.8); -insert into DEMO values (888888, 'zhangdi1', 35, 10000.8); -insert into DEMO values (122, 'LIOR', 22, 77.8); -insert into DEMO values (31434, 'ALEX', 43, 100.8); -alter table DEMO drop primary key; -insert into DEMO values (888888, 'zhangdi', 35, 10000.8); -SELECT * FROM DEMO; -ID NAME AGE GRADE -888888 zhangdi 35 10000.8 -888889 zhangdi 11 99.8 -888888 zhangdi1 35 10000.8 -122 LIOR 22 77.8 -31434 ALEX 43 100.8 -888888 zhangdi 35 10000.8 -desc DEMO; -Field Type Null Key Default Extra -ID int NO NULL -NAME varchar(19) NO NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL, - `NAME` varchar(19) NOT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -drop table DEMO; -create table DEMO (ID integer, NAME varchar(19), AGE integer, GRADE real, CONSTRAINT pk_demo PRIMARY KEY (ID, NAME)); -desc DEMO; -Field Type Null Key Default Extra -ID int NO PRI NULL -NAME varchar(19) NO PRI NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL, - `NAME` varchar(19) NOT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL, - PRIMARY KEY (`ID`,`NAME`) -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -DEMO 0 PRIMARY 1 ID A NULL NULL NULL BTREE YES NULL -DEMO 0 PRIMARY 2 NAME A NULL NULL NULL BTREE YES NULL -insert into DEMO values (888888, 'zhangdi', 35, 10000.8); -insert into DEMO values (888888, 'zhangdi', 35, 10000.8); -ERROR 23000: Duplicate entry '888888-zhangdi' for key 'DEMO.PRIMARY' -insert into DEMO values (888889, 'zhangdi', 11, 99.8); -insert into DEMO values (888888, 'zhangdi1', 35, 10000.8); -insert into DEMO values (122, 'LIOR', 22, 77.8); -insert into DEMO values (31434, 'ALEX', 43, 100.8); -alter table DEMO drop constraint pk_demo; -ERROR HY000: Constraint 'pk_demo' does not exist. -alter table DEMO drop primary key; -insert into DEMO values (888888, 'zhangdi', 35, 10000.8); -SELECT * FROM DEMO; -ID NAME AGE GRADE -888888 zhangdi 35 10000.8 -888889 zhangdi 11 99.8 -888888 zhangdi1 35 10000.8 -122 LIOR 22 77.8 -31434 ALEX 43 100.8 -888888 zhangdi 35 10000.8 -desc DEMO; -Field Type Null Key Default Extra -ID int NO NULL -NAME varchar(19) NO NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL, - `NAME` varchar(19) NOT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -drop table DEMO; -create table DEMO (ID integer UNIQUE KEY, NAME varchar(19), AGE integer, GRADE real); -desc DEMO; -Field Type Null Key Default Extra -ID int YES UNI NULL -NAME varchar(19) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int DEFAULT NULL, - `NAME` varchar(19) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL, - UNIQUE KEY `ID` (`ID`) -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -DEMO 0 ID 1 ID A NULL NULL NULL YES BTREE YES NULL -insert into DEMO values (1, 'LIOR', 35, 6.9); -insert into DEMO values (1, 'MIKE', 55, 99.92); -ERROR 23000: Duplicate entry '1' for key 'DEMO.ID' -insert into DEMO values (null,'DAN', 45, 33.33); -insert into DEMO values (null,'DAN', 45, 33.33); -insert into DEMO values (null,'DAN', 45, 33.33); -insert into DEMO values (2, 'MIKE', 55, 99.92); -ALTER TABLE DEMO DROP INDEX ID; -ALTER TABLE DEMO DROP INDEX ID; -ERROR 42000: Can't DROP 'ID'; check that column/key exists -insert into DEMO values (1, 'MIKE', 55, 99.92); -SELECT * FROM DEMO; -ID NAME AGE GRADE -1 LIOR 35 6.9 -NULL DAN 45 33.33 -NULL DAN 45 33.33 -NULL DAN 45 33.33 -2 MIKE 55 99.92 -1 MIKE 55 99.92 -desc DEMO; -Field Type Null Key Default Extra -ID int YES NULL -NAME varchar(19) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int DEFAULT NULL, - `NAME` varchar(19) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -drop table DEMO; -create table DEMO (ID integer UNIQUE, NAME varchar(19), AGE integer, GRADE real); -desc DEMO; -Field Type Null Key Default Extra -ID int YES UNI NULL -NAME varchar(19) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int DEFAULT NULL, - `NAME` varchar(19) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL, - UNIQUE KEY `ID` (`ID`) -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -DEMO 0 ID 1 ID A NULL NULL NULL YES BTREE YES NULL -insert into DEMO values (1, 'LIOR', 35, 6.9); -insert into DEMO values (1, 'MIKE', 55, 99.92); -ERROR 23000: Duplicate entry '1' for key 'DEMO.ID' -insert into DEMO values (null,'DAN', 45, 33.33); -insert into DEMO values (null,'DAN', 45, 33.33); -insert into DEMO values (null,'DAN', 45, 33.33); -insert into DEMO values (2, 'MIKE', 55, 99.92); -ALTER TABLE DEMO DROP INDEX ID; -ALTER TABLE DEMO DROP INDEX ID; -ERROR 42000: Can't DROP 'ID'; check that column/key exists -insert into DEMO values (1, 'MIKE', 55, 99.92); -SELECT * FROM DEMO; -ID NAME AGE GRADE -1 LIOR 35 6.9 -NULL DAN 45 33.33 -NULL DAN 45 33.33 -NULL DAN 45 33.33 -2 MIKE 55 99.92 -1 MIKE 55 99.92 -desc DEMO; -Field Type Null Key Default Extra -ID int YES NULL -NAME varchar(19) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int DEFAULT NULL, - `NAME` varchar(19) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -drop table DEMO; -create table DEMO (ID integer, NAME varchar(10), AGE integer, GRADE real, CONSTRAINT uk_demo UNIQUE KEY (ID)); -desc DEMO; -Field Type Null Key Default Extra -ID int YES UNI NULL -NAME varchar(10) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int DEFAULT NULL, - `NAME` varchar(10) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL, - UNIQUE KEY `uk_demo` (`ID`) -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -DEMO 0 uk_demo 1 ID A NULL NULL NULL YES BTREE YES NULL -insert into DEMO values (1, 'LIOR', 35, 6.9); -insert into DEMO values (1, 'LIOR', 35, 6.9); -ERROR 23000: Duplicate entry '1' for key 'DEMO.uk_demo' -insert into DEMO values (1, 'MIKE', 55, 99.92); -ERROR 23000: Duplicate entry '1' for key 'DEMO.uk_demo' -insert into DEMO values (2, 'MIKE', 55, 99.92); -insert into DEMO values (3, 'LIOR', 35, 6.9); -insert into DEMO values (null, 'LIOR', 35, 6.9); -insert into DEMO values (null, 'LIOR', 35, 6.9); -insert into DEMO values (null, 'LIOR', 35, 6.9); -insert into DEMO values (null, 'LIOR', 35, 6.9); -ALTER TABLE DEMO DROP INDEX ID; -ERROR 42000: Can't DROP 'ID'; check that column/key exists -ALTER TABLE DEMO DROP INDEX uk_demo; -insert into DEMO values (1, 'MIKE', 55, 99.92); -desc DEMO; -Field Type Null Key Default Extra -ID int YES NULL -NAME varchar(10) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int DEFAULT NULL, - `NAME` varchar(10) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -drop table DEMO; -create table DEMO (ID integer, NAME varchar(10), AGE integer, GRADE real, CONSTRAINT uk_demo UNIQUE KEY (ID)); -desc DEMO; -Field Type Null Key Default Extra -ID int YES UNI NULL -NAME varchar(10) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int DEFAULT NULL, - `NAME` varchar(10) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL, - UNIQUE KEY `uk_demo` (`ID`) -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -DEMO 0 uk_demo 1 ID A NULL NULL NULL YES BTREE YES NULL -insert into DEMO values (1, 'LIOR', 35, 6.9); -insert into DEMO values (1, 'LIOR', 35, 6.9); -ERROR 23000: Duplicate entry '1' for key 'DEMO.uk_demo' -insert into DEMO values (1, 'MIKE', 55, 99.92); -ERROR 23000: Duplicate entry '1' for key 'DEMO.uk_demo' -insert into DEMO values (2, 'MIKE', 55, 99.92); -insert into DEMO values (3, 'LIOR', 35, 6.9); -insert into DEMO values (null, 'LIOR', 35, 6.9); -insert into DEMO values (null, 'LIOR', 35, 6.9); -insert into DEMO values (null, 'LIOR', 35, 6.9); -insert into DEMO values (null, 'LIOR', 35, 6.9); -ALTER TABLE DEMO DROP INDEX ID; -ERROR 42000: Can't DROP 'ID'; check that column/key exists -alter table DEMO drop constraint uk_demo; -insert into DEMO values (1, 'MIKE', 55, 99.92); -desc DEMO; -Field Type Null Key Default Extra -ID int YES NULL -NAME varchar(10) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int DEFAULT NULL, - `NAME` varchar(10) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -drop table DEMO; -create table DEMO (ID integer, NAME varchar(10), AGE integer, GRADE real, CONSTRAINT ID UNIQUE KEY (ID)); -desc DEMO; -Field Type Null Key Default Extra -ID int YES UNI NULL -NAME varchar(10) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int DEFAULT NULL, - `NAME` varchar(10) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL, - UNIQUE KEY `ID` (`ID`) -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -DEMO 0 ID 1 ID A NULL NULL NULL YES BTREE YES NULL -insert into DEMO values (1, 'LIOR', 35, 6.9); -insert into DEMO values (1, 'LIOR', 35, 6.9); -ERROR 23000: Duplicate entry '1' for key 'DEMO.ID' -insert into DEMO values (1, 'MIKE', 55, 99.92); -ERROR 23000: Duplicate entry '1' for key 'DEMO.ID' -insert into DEMO values (2, 'MIKE', 55, 99.92); -insert into DEMO values (3, 'LIOR', 35, 6.9); -insert into DEMO values (null, 'LIOR', 35, 6.9); -insert into DEMO values (null, 'LIOR', 35, 6.9); -insert into DEMO values (null, 'LIOR', 35, 6.9); -insert into DEMO values (null, 'LIOR', 35, 6.9); -ALTER TABLE DEMO DROP INDEX ID; -insert into DEMO values (1, 'MIKE', 55, 99.92); -desc DEMO; -Field Type Null Key Default Extra -ID int YES NULL -NAME varchar(10) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int DEFAULT NULL, - `NAME` varchar(10) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -drop table DEMO; -create table DEMO (ID integer, NAME varchar(10), AGE integer, GRADE real, CONSTRAINT uk_demo UNIQUE KEY (ID, NAME)); -desc DEMO; -Field Type Null Key Default Extra -ID int YES MUL NULL -NAME varchar(10) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int DEFAULT NULL, - `NAME` varchar(10) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL, - UNIQUE KEY `uk_demo` (`ID`,`NAME`) -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -DEMO 0 uk_demo 1 ID A NULL NULL NULL YES BTREE YES NULL -DEMO 0 uk_demo 2 NAME A NULL NULL NULL YES BTREE YES NULL -insert into DEMO values (1, 'LIOR', 35, 6.9); -insert into DEMO values (1, 'LIOR', 35, 6.9); -ERROR 23000: Duplicate entry '1-LIOR' for key 'DEMO.uk_demo' -insert into DEMO values (1, 'MIKE', 55, 99.92); -insert into DEMO values (null, 'LIOR', 35, 6.9); -insert into DEMO values (null, 'LIOR', 35, 6.9); -ALTER TABLE DEMO DROP INDEX ID; -ERROR 42000: Can't DROP 'ID'; check that column/key exists -ALTER TABLE DEMO DROP INDEX NAME; -ERROR 42000: Can't DROP 'NAME'; check that column/key exists -alter table DEMO drop constraint uk_demo; -insert into DEMO values (1, 'MIKE', 55, 99.92); -desc DEMO; -Field Type Null Key Default Extra -ID int YES NULL -NAME varchar(10) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int DEFAULT NULL, - `NAME` varchar(10) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -drop table DEMO; -create table DEMO (ID integer PRIMARY KEY auto_increment ,AGE integer, GRADE real); -desc DEMO; -Field Type Null Key Default Extra -ID int NO PRI NULL auto_increment -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL AUTO_INCREMENT, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL, - PRIMARY KEY (`ID`) -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -DEMO 0 PRIMARY 1 ID A NULL NULL NULL BTREE YES NULL -insert into DEMO (AGE, GRADE) values (20, 5.5); -insert into DEMO (AGE, GRADE) values (30,6.5); -insert into DEMO (AGE, GRADE) values (40,7.5); -insert into DEMO values (null,40,7.5); -insert into DEMO values (null,40,7.5); -insert into DEMO values (4,40,7.5); -ERROR 23000: Duplicate entry '4' for key 'DEMO.PRIMARY' -SELECT * FROM DEMO; -ID AGE GRADE -1 20 5.5 -2 30 6.5 -3 40 7.5 -4 40 7.5 -5 40 7.5 -desc DEMO; -Field Type Null Key Default Extra -ID int NO PRI NULL auto_increment -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL AUTO_INCREMENT, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL, - PRIMARY KEY (`ID`) -) ENGINE=CTC AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -DEMO 0 PRIMARY 1 ID A NULL NULL NULL BTREE YES NULL -drop table DEMO; -create table DEMO (ID integer UNIQUE auto_increment,AGE integer, GRADE real); -desc DEMO; -Field Type Null Key Default Extra -ID int NO PRI NULL auto_increment -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL AUTO_INCREMENT, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL, - UNIQUE KEY `ID` (`ID`) -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -DEMO 0 ID 1 ID A NULL NULL NULL BTREE YES NULL -insert into DEMO (AGE, GRADE) values (20, 5.5); -insert into DEMO (AGE, GRADE) values (30,6.5); -insert into DEMO (AGE, GRADE) values (40,7.5); -insert into DEMO values (null,40,7.5); -insert into DEMO values (null,40,7.5); -insert into DEMO values (4,40,7.5); -ERROR 23000: Duplicate entry '4' for key 'DEMO.ID' -SELECT * FROM DEMO; -ID AGE GRADE -1 20 5.5 -2 30 6.5 -3 40 7.5 -4 40 7.5 -5 40 7.5 -desc DEMO; -Field Type Null Key Default Extra -ID int NO PRI NULL auto_increment -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL AUTO_INCREMENT, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL, - UNIQUE KEY `ID` (`ID`) -) ENGINE=CTC AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -DEMO 0 ID 1 ID A NULL NULL NULL BTREE YES NULL -drop table DEMO; -create table DEMO (ID integer DEFAULT NULL, NAME varchar(19), AGE integer DEFAULT 100, GRADE real); -desc DEMO; -Field Type Null Key Default Extra -ID int YES NULL -NAME varchar(19) YES NULL -AGE int YES 100 -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int DEFAULT NULL, - `NAME` varchar(19) DEFAULT NULL, - `AGE` int DEFAULT '100', - `GRADE` double DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -INSERT INTO DEMO(NAME,GRADE) VALUES('test1',10); -INSERT INTO DEMO(NAME,GRADE) VALUES('test2',20); -INSERT INTO DEMO(NAME,GRADE) VALUES('test3',30); -INSERT INTO DEMO(NAME,GRADE) VALUES('test4',40); -INSERT INTO DEMO VALUES(10,'test4',40,200); -INSERT INTO DEMO VALUES(101,'test4',40,201); -SELECT * FROM DEMO; -ID NAME AGE GRADE -NULL test1 100 10 -NULL test2 100 20 -NULL test3 100 30 -NULL test4 100 40 -10 test4 40 200 -101 test4 40 201 -desc DEMO; -Field Type Null Key Default Extra -ID int YES NULL -NAME varchar(19) YES NULL -AGE int YES 100 -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int DEFAULT NULL, - `NAME` varchar(19) DEFAULT NULL, - `AGE` int DEFAULT '100', - `GRADE` double DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -drop table DEMO; -DROP TABLE IF EXISTS DEMO; -Warnings: -Note 1051 Unknown table 'test.DEMO' -CREATE TABLE DEMO(c1 CHAR(10) NULL DEFAULT 'x'); -insert into DEMO values(null); -insert into DEMO values(''); -insert into DEMO values('x'); -insert into DEMO values('acbdfd'); -insert into DEMO values('abdcdedcddfdfdfdfdffddfd'); -ERROR 22001: Data too long for column 'c1' at row 1 -SELECT * FROM DEMO; -c1 -NULL - -x -acbdfd -desc DEMO; -Field Type Null Key Default Extra -c1 char(10) YES x -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `c1` char(10) DEFAULT 'x' -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -SHOW TABLES; -Tables_in_test -DEMO -SHOW CREATE TABLE DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `c1` char(10) DEFAULT 'x' -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -DROP TABLE DEMO; -SHOW TABLES; -Tables_in_test -DROP TABLE IF EXISTS DEMO; -Warnings: -Note 1051 Unknown table 'test.DEMO' -CREATE TABLE DEMO(ID integer, c1 CHAR(10) NULL DEFAULT 'x'); -insert into DEMO values(1,null); -insert into DEMO values(2,''); -insert into DEMO values(3,'x'); -insert into DEMO values(4, 'acbdfd'); -insert into DEMO values(5,'abdcdedcddfdfdfdfdffddfd'); -ERROR 22001: Data too long for column 'c1' at row 1 -insert into DEMO(ID) values(6); -SELECT * FROM DEMO; -ID c1 -1 NULL -2 -3 x -4 acbdfd -6 x -desc DEMO; -Field Type Null Key Default Extra -ID int YES NULL -c1 char(10) YES x -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int DEFAULT NULL, - `c1` char(10) DEFAULT 'x' -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -SHOW TABLES; -Tables_in_test -DEMO -SHOW CREATE TABLE DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int DEFAULT NULL, - `c1` char(10) DEFAULT 'x' -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -DROP TABLE DEMO; -SHOW TABLES; -Tables_in_test -DROP TABLE IF EXISTS DEMO; -Warnings: -Note 1051 Unknown table 'test.DEMO' -CREATE TABLE DEMO(c1 CHAR(10) NULL DEFAULT 'x', c2 int); -insert into DEMO (c2) values(2); -insert into DEMO values('12',3); -insert into DEMO values('',4); -insert into DEMO values(null,5); -SELECT * FROM DEMO; -c1 c2 -x 2 -12 3 - 4 -NULL 5 -desc DEMO; -Field Type Null Key Default Extra -c1 char(10) YES x -c2 int YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `c1` char(10) DEFAULT 'x', - `c2` int DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -SHOW TABLES; -Tables_in_test -DEMO -SHOW CREATE TABLE DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `c1` char(10) DEFAULT 'x', - `c2` int DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -DROP TABLE DEMO; -SHOW TABLES; -Tables_in_test -create table DEMO (a decimal(3,1)); -insert into DEMO values (1.3); -insert into DEMO values (99.99); -ERROR 22003: Out of range value for column 'a' at row 1 -insert into DEMO values (99.9); -insert into DEMO values (-99.9); -insert into DEMO values (-99.99); -ERROR 22003: Out of range value for column 'a' at row 1 -insert into DEMO values (-99.95); -ERROR 22003: Out of range value for column 'a' at row 1 -insert into DEMO values (-99.949); -Warnings: -Note 1265 Data truncated for column 'a' at row 1 -insert into DEMO values (-99.94); -Warnings: -Note 1265 Data truncated for column 'a' at row 1 -SELECT * FROM DEMO; -a -1.3 -99.9 --99.9 --99.9 --99.9 -desc DEMO; -Field Type Null Key Default Extra -a decimal(3,1) YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `a` decimal(3,1) DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -drop table DEMO; -create table DEMO (ID integer comment 'user_id', NAME varchar(19) comment 'name', AGE integer DEFAULT 100 comment 'student_age', GRADE real comment 'student_grade'); -insert into DEMO values (1, 'LIOR', 35, 6.9); -insert into DEMO values (4, 'MIKE', 55, 99.92); -SELECT * FROM DEMO; -ID NAME AGE GRADE -1 LIOR 35 6.9 -4 MIKE 55 99.92 -desc DEMO; -Field Type Null Key Default Extra -ID int YES NULL -NAME varchar(19) YES NULL -AGE int YES 100 -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int DEFAULT NULL COMMENT 'user_id', - `NAME` varchar(19) DEFAULT NULL COMMENT 'name', - `AGE` int DEFAULT '100' COMMENT 'student_age', - `GRADE` double DEFAULT NULL COMMENT 'student_grade' -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -drop table DEMO; -create table DEMO (NAME varchar(5) COLLATE utf8_unicode_ci); -Warnings: -Warning 3778 'utf8_unicode_ci' is a collation of the deprecated character set UTF8MB3. Please consider using UTF8MB4 with an appropriate collation instead. -show full columns from DEMO; -Field Type Collation Null Key Default Extra Privileges Comment -NAME varchar(5) utf8_unicode_ci YES NULL select,insert,update,references -insert into DEMO values ('LIOR'); -SELECT * FROM DEMO; -NAME -LIOR -desc DEMO; -Field Type Null Key Default Extra -NAME varchar(5) YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `NAME` varchar(5) CHARACTER SET utf8 COLLATE utf8_unicode_ci DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -drop table DEMO; -create table DEMO (id int NOT NULL AUTO_INCREMENT, name varchar(20) DEFAULT NULL, create_time timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, last_modify_time timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, PRIMARY KEY (id)); -insert into DEMO (name) VALUES ('aa'),('bb'),('cc'); -UPDATE DEMO SET name = 'ab' WHERE id = 1; -desc DEMO; -Field Type Null Key Default Extra -id int NO PRI NULL auto_increment -name varchar(20) YES NULL -create_time timestamp NO CURRENT_TIMESTAMP DEFAULT_GENERATED -last_modify_time timestamp NO CURRENT_TIMESTAMP DEFAULT_GENERATED on update CURRENT_TIMESTAMP -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `id` int NOT NULL AUTO_INCREMENT, - `name` varchar(20) DEFAULT NULL, - `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, - `last_modify_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, - PRIMARY KEY (`id`) -) ENGINE=CTC AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -DEMO 0 PRIMARY 1 id A NULL NULL NULL BTREE YES NULL -drop table DEMO; -create table DEMO (ID integer not null, NAME varchar(19), AGE integer, GRADE real); -DESC DEMO; -Field Type Null Key Default Extra -ID int NO NULL -NAME varchar(19) YES NULL -AGE int YES NULL -GRADE double YES NULL -insert into DEMO values (1, 'LIOR', 35, 6.9); -insert into DEMO values (4, 'MIKE', 55, 99.92); -insert into DEMO values (8, 'ROMAN', 40, 94.1); -insert into DEMO values (16, 'DAN', 60, 1234567890); -insert into DEMO values (32, 'ZVI', 35, 777.666); -insert into DEMO values (1, 'Eitan', NULL, 4.9); -insert into DEMO values (888888, 'zhangdi', NULL, 10000.8); -insert into DEMO values (1131, 'Hisses', 1, NULL); -insert into DEMO values (null, 'ff', 36, 8.9); -ERROR 23000: Column 'ID' cannot be null -SELECT * FROM DEMO; -ID NAME AGE GRADE -1 LIOR 35 6.9 -4 MIKE 55 99.92 -8 ROMAN 40 94.1 -16 DAN 60 1234567890 -32 ZVI 35 777.666 -1 Eitan NULL 4.9 -888888 zhangdi NULL 10000.8 -1131 Hisses 1 NULL -desc DEMO; -Field Type Null Key Default Extra -ID int NO NULL -NAME varchar(19) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL, - `NAME` varchar(19) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -truncate DEMO; -SELECT * FROM DEMO; -ID NAME AGE GRADE -desc DEMO; -Field Type Null Key Default Extra -ID int NO NULL -NAME varchar(19) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL, - `NAME` varchar(19) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL -) ENGINE=CTC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -drop table DEMO; -create table DEMO (ID integer PRIMARY KEY auto_increment , NAME varchar(19), AGE integer, GRADE real); -DESC DEMO; -Field Type Null Key Default Extra -ID int NO PRI NULL auto_increment -NAME varchar(19) YES NULL -AGE int YES NULL -GRADE double YES NULL -insert into DEMO values (1, 'LIOR', 35, 6.9); -insert into DEMO values (4, 'MIKE', 55, 99.92); -insert into DEMO values (8, 'ROMAN', 40, 94.1); -insert into DEMO values (16, 'DAN', 60, 1234567890); -insert into DEMO values (32, 'ZVI', 35, 777.666); -insert into DEMO values (1, 'Eitan', NULL, 4.9); -ERROR 23000: Duplicate entry '1' for key 'DEMO.PRIMARY' -insert into DEMO values (888888, 'zhangdi', NULL, 10000.8); -insert into DEMO values (1131, 'Hisses', 1, NULL); -insert into DEMO values (null, 'ff', 36, 8.9); -SELECT * FROM DEMO; -ID NAME AGE GRADE -1 LIOR 35 6.9 -4 MIKE 55 99.92 -8 ROMAN 40 94.1 -16 DAN 60 1234567890 -32 ZVI 35 777.666 -888888 zhangdi NULL 10000.8 -1131 Hisses 1 NULL -888889 ff 36 8.9 -desc DEMO; -Field Type Null Key Default Extra -ID int NO PRI NULL auto_increment -NAME varchar(19) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL AUTO_INCREMENT, - `NAME` varchar(19) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL, - PRIMARY KEY (`ID`) -) ENGINE=CTC AUTO_INCREMENT=888890 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -DEMO 0 PRIMARY 1 ID A NULL NULL NULL BTREE YES NULL -truncate DEMO; -SELECT * FROM DEMO; -ID NAME AGE GRADE -insert into DEMO values (null, 'ff', 36, 8.9); -insert into DEMO values (null, 'ff', 36, 8.9); -insert into DEMO values (null, 'ff', 36, 8.9); -insert into DEMO values (null, 'ff', 36, 8.9); -insert into DEMO values (null, 'ff', 36, 8.9); -desc DEMO; -Field Type Null Key Default Extra -ID int NO PRI NULL auto_increment -NAME varchar(19) YES NULL -AGE int YES NULL -GRADE double YES NULL -show create table DEMO; -Table Create Table -DEMO CREATE TABLE `DEMO` ( - `ID` int NOT NULL AUTO_INCREMENT, - `NAME` varchar(19) DEFAULT NULL, - `AGE` int DEFAULT NULL, - `GRADE` double DEFAULT NULL, - PRIMARY KEY (`ID`) -) ENGINE=CTC AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci -show index from DEMO; -Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Visible Expression -DEMO 0 PRIMARY 1 ID A NULL NULL NULL BTREE YES NULL -drop table DEMO; -create table DEMO (ID integer, NAME varchar(19), AGE integer, GRADE real, SEX char(1), check (5 0 THEN INSERT INTO DEMO_TRIGGER_LOG VALUES('delete', old.NAME); @@ -25,12 +25,12 @@ END IF; END| SHOW TRIGGERS; Trigger Event Table Statement Timing Created sql_mode Definer character_set_client collation_connection Database Collation -TRIGGER_TSE1 INSERT DEMO BEGIN +TRIGGER_CTC1 INSERT DEMO BEGIN IF NEW.AGE <= 0 THEN INSERT INTO DEMO_TRIGGER_LOG VALUES('insert', NEW.NAME); END IF; END AFTER # ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION root@localhost utf8mb4 utf8mb4_0900_ai_ci utf8mb4_0900_ai_ci -TRIGGER_TSE2 UPDATE DEMO BEGIN +TRIGGER_CTC2 UPDATE DEMO BEGIN IF NEW.AGE < 0 THEN SET NEW.AGE = 0; ELSEIF new.AGE > 100 THEN @@ -38,7 +38,7 @@ SET new.AGE = 100; END IF; INSERT INTO DEMO_TRIGGER_LOG VALUES('update', NEW.NAME); END BEFORE # ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION root@localhost utf8mb4 utf8mb4_0900_ai_ci utf8mb4_0900_ai_ci -TRIGGER_TSE3 DELETE DEMO BEGIN +TRIGGER_CTC3 DELETE DEMO BEGIN IF old.AGE > 0 THEN INSERT INTO DEMO_TRIGGER_LOG VALUES('delete', old.NAME); END IF; @@ -87,12 +87,12 @@ update ROMAN delete DAN SHOW TRIGGERS; Trigger Event Table Statement Timing Created sql_mode Definer character_set_client collation_connection Database Collation -TRIGGER_TSE1 INSERT DEMO BEGIN +TRIGGER_CTC1 INSERT DEMO BEGIN IF NEW.AGE <= 0 THEN INSERT INTO DEMO_TRIGGER_LOG VALUES('insert', NEW.NAME); END IF; END AFTER # ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION root@localhost utf8mb4 utf8mb4_0900_ai_ci utf8mb4_0900_ai_ci -TRIGGER_TSE2 UPDATE DEMO BEGIN +TRIGGER_CTC2 UPDATE DEMO BEGIN IF NEW.AGE < 0 THEN SET NEW.AGE = 0; ELSEIF new.AGE > 100 THEN @@ -100,19 +100,19 @@ SET new.AGE = 100; END IF; INSERT INTO DEMO_TRIGGER_LOG VALUES('update', NEW.NAME); END BEFORE # ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION root@localhost utf8mb4 utf8mb4_0900_ai_ci utf8mb4_0900_ai_ci -TRIGGER_TSE3 DELETE DEMO BEGIN +TRIGGER_CTC3 DELETE DEMO BEGIN IF old.AGE > 0 THEN INSERT INTO DEMO_TRIGGER_LOG VALUES('delete', old.NAME); END IF; END AFTER # ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION root@localhost utf8mb4 utf8mb4_0900_ai_ci utf8mb4_0900_ai_ci -DROP TRIGGER TRIGGER_TSE; +DROP TRIGGER TRIGGER_CTC; ERROR HY000: Trigger does not exist -DROP TRIGGER IF EXISTS TRIGGER_TSE; +DROP TRIGGER IF EXISTS TRIGGER_CTC; Warnings: Note 1360 Trigger does not exist -DROP TRIGGER IF EXISTS TRIGGER_TSE1; -DROP TRIGGER IF EXISTS TRIGGER_TSE2; -DROP TRIGGER IF EXISTS TRIGGER_TSE3; +DROP TRIGGER IF EXISTS TRIGGER_CTC1; +DROP TRIGGER IF EXISTS TRIGGER_CTC2; +DROP TRIGGER IF EXISTS TRIGGER_CTC3; SHOW TRIGGERS; Trigger Event Table Statement Timing Created sql_mode Definer character_set_client collation_connection Database Collation drop table DEMO; diff --git a/mysql-test/suite/tianchi/r/ctc_ddl_unsupport_command.result b/mysql-test/suite/ctc/r/ctc_ddl_unsupport_command.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_ddl_unsupport_command.result rename to mysql-test/suite/ctc/r/ctc_ddl_unsupport_command.result diff --git a/mysql-test/suite/tianchi/r/ctc_ddl_view.result b/mysql-test/suite/ctc/r/ctc_ddl_view.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_ddl_view.result rename to mysql-test/suite/ctc/r/ctc_ddl_view.result diff --git a/mysql-test/suite/tianchi/r/ctc_decimal_analyze.result b/mysql-test/suite/ctc/r/ctc_decimal_analyze.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_decimal_analyze.result rename to mysql-test/suite/ctc/r/ctc_decimal_analyze.result diff --git a/mysql-test/suite/tianchi/r/ctc_delete_time.result b/mysql-test/suite/ctc/r/ctc_delete_time.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_delete_time.result rename to mysql-test/suite/ctc/r/ctc_delete_time.result diff --git a/mysql-test/suite/tianchi/r/ctc_dml_decimal_table.result b/mysql-test/suite/ctc/r/ctc_dml_decimal_table.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_dml_decimal_table.result rename to mysql-test/suite/ctc/r/ctc_dml_decimal_table.result diff --git a/mysql-test/suite/tianchi/r/ctc_dml_ignore.result b/mysql-test/suite/ctc/r/ctc_dml_ignore.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_dml_ignore.result rename to mysql-test/suite/ctc/r/ctc_dml_ignore.result diff --git a/mysql-test/suite/tianchi/r/ctc_dml_two_table.result b/mysql-test/suite/ctc/r/ctc_dml_two_table.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_dml_two_table.result rename to mysql-test/suite/ctc/r/ctc_dml_two_table.result diff --git a/mysql-test/suite/tianchi/r/ctc_enum_analyze.result b/mysql-test/suite/ctc/r/ctc_enum_analyze.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_enum_analyze.result rename to mysql-test/suite/ctc/r/ctc_enum_analyze.result diff --git a/mysql-test/suite/tianchi/r/ctc_handler_operation.result b/mysql-test/suite/ctc/r/ctc_handler_operation.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_handler_operation.result rename to mysql-test/suite/ctc/r/ctc_handler_operation.result diff --git a/mysql-test/suite/tianchi/r/ctc_index_functions_base.result b/mysql-test/suite/ctc/r/ctc_index_functions_base.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_index_functions_base.result rename to mysql-test/suite/ctc/r/ctc_index_functions_base.result diff --git a/mysql-test/suite/tianchi/r/ctc_insert_time.result b/mysql-test/suite/ctc/r/ctc_insert_time.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_insert_time.result rename to mysql-test/suite/ctc/r/ctc_insert_time.result diff --git a/mysql-test/suite/tianchi/r/ctc_json_value.result b/mysql-test/suite/ctc/r/ctc_json_value.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_json_value.result rename to mysql-test/suite/ctc/r/ctc_json_value.result diff --git a/mysql-test/suite/tianchi/r/ctc_lcov.result b/mysql-test/suite/ctc/r/ctc_lcov.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_lcov.result rename to mysql-test/suite/ctc/r/ctc_lcov.result diff --git a/mysql-test/suite/tianchi/r/ctc_link_and_migr_row.result b/mysql-test/suite/ctc/r/ctc_link_and_migr_row.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_link_and_migr_row.result rename to mysql-test/suite/ctc/r/ctc_link_and_migr_row.result diff --git a/mysql-test/suite/tianchi/r/ctc_lock_instance.result b/mysql-test/suite/ctc/r/ctc_lock_instance.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_lock_instance.result rename to mysql-test/suite/ctc/r/ctc_lock_instance.result diff --git a/mysql-test/suite/tianchi/r/ctc_locking_read_concurrency_with_nowait_and_skip_locked.result b/mysql-test/suite/ctc/r/ctc_locking_read_concurrency_with_nowait_and_skip_locked.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_locking_read_concurrency_with_nowait_and_skip_locked.result rename to mysql-test/suite/ctc/r/ctc_locking_read_concurrency_with_nowait_and_skip_locked.result diff --git a/mysql-test/suite/tianchi/r/ctc_partition_update.result b/mysql-test/suite/ctc/r/ctc_partition_update.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_partition_update.result rename to mysql-test/suite/ctc/r/ctc_partition_update.result diff --git a/mysql-test/suite/tianchi/r/ctc_read_only.result b/mysql-test/suite/ctc/r/ctc_read_only.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_read_only.result rename to mysql-test/suite/ctc/r/ctc_read_only.result diff --git a/mysql-test/suite/tianchi/r/ctc_select_early_return.result b/mysql-test/suite/ctc/r/ctc_select_early_return.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_select_early_return.result rename to mysql-test/suite/ctc/r/ctc_select_early_return.result diff --git a/mysql-test/suite/tianchi/r/ctc_set_analyze.result b/mysql-test/suite/ctc/r/ctc_set_analyze.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_set_analyze.result rename to mysql-test/suite/ctc/r/ctc_set_analyze.result diff --git a/mysql-test/suite/tianchi/r/ctc_string_analyze.result b/mysql-test/suite/ctc/r/ctc_string_analyze.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_string_analyze.result rename to mysql-test/suite/ctc/r/ctc_string_analyze.result diff --git a/mysql-test/suite/tianchi/r/ctc_update_time.result b/mysql-test/suite/ctc/r/ctc_update_time.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_update_time.result rename to mysql-test/suite/ctc/r/ctc_update_time.result diff --git a/mysql-test/suite/tianchi/r/ctc_varchar.result b/mysql-test/suite/ctc/r/ctc_varchar.result similarity index 100% rename from mysql-test/suite/tianchi/r/ctc_varchar.result rename to mysql-test/suite/ctc/r/ctc_varchar.result diff --git a/mysql-test/suite/tianchi/r/recreate_test_db.result b/mysql-test/suite/ctc/r/recreate_test_db.result similarity index 100% rename from mysql-test/suite/tianchi/r/recreate_test_db.result rename to mysql-test/suite/ctc/r/recreate_test_db.result diff --git a/mysql-test/suite/tianchi/t/ctc_atomic_ddl.test b/mysql-test/suite/ctc/t/ctc_atomic_ddl.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_atomic_ddl.test rename to mysql-test/suite/ctc/t/ctc_atomic_ddl.test diff --git a/mysql-test/suite/tianchi/t/ctc_auto_increment.test b/mysql-test/suite/ctc/t/ctc_auto_increment.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_auto_increment.test rename to mysql-test/suite/ctc/t/ctc_auto_increment.test diff --git a/mysql-test/suite/tianchi/t/ctc_bit_analyze.test b/mysql-test/suite/ctc/t/ctc_bit_analyze.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_bit_analyze.test rename to mysql-test/suite/ctc/t/ctc_bit_analyze.test diff --git a/mysql-test/suite/tianchi/t/ctc_charset.test b/mysql-test/suite/ctc/t/ctc_charset.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_charset.test rename to mysql-test/suite/ctc/t/ctc_charset.test diff --git a/mysql-test/suite/tianchi/t/ctc_charset_binary.test b/mysql-test/suite/ctc/t/ctc_charset_binary.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_charset_binary.test rename to mysql-test/suite/ctc/t/ctc_charset_binary.test diff --git a/mysql-test/suite/tianchi/t/ctc_charset_collate.test b/mysql-test/suite/ctc/t/ctc_charset_collate.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_charset_collate.test rename to mysql-test/suite/ctc/t/ctc_charset_collate.test diff --git a/mysql-test/suite/tianchi/t/ctc_compressed_proxy_conn.test b/mysql-test/suite/ctc/t/ctc_compressed_proxy_conn.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_compressed_proxy_conn.test rename to mysql-test/suite/ctc/t/ctc_compressed_proxy_conn.test diff --git a/mysql-test/suite/tianchi/t/ctc_cond_pushdown.test b/mysql-test/suite/ctc/t/ctc_cond_pushdown.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_cond_pushdown.test rename to mysql-test/suite/ctc/t/ctc_cond_pushdown.test diff --git a/mysql-test/suite/tianchi/t/ctc_cond_pushdown_explain.test b/mysql-test/suite/ctc/t/ctc_cond_pushdown_explain.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_cond_pushdown_explain.test rename to mysql-test/suite/ctc/t/ctc_cond_pushdown_explain.test diff --git a/mysql-test/suite/tianchi/t/ctc_crud_for_drop_column.test b/mysql-test/suite/ctc/t/ctc_crud_for_drop_column.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_crud_for_drop_column.test rename to mysql-test/suite/ctc/t/ctc_crud_for_drop_column.test diff --git a/mysql-test/suite/tianchi/t/ctc_datatype.test b/mysql-test/suite/ctc/t/ctc_datatype.test similarity index 98% rename from mysql-test/suite/tianchi/t/ctc_datatype.test rename to mysql-test/suite/ctc/t/ctc_datatype.test index 2b30aad..f9db9d5 100644 --- a/mysql-test/suite/tianchi/t/ctc_datatype.test +++ b/mysql-test/suite/ctc/t/ctc_datatype.test @@ -1,5 +1,5 @@ # -# Simple test for the TSE storage engine +# Simple test for the CTC storage engine # with most datatypes and null / not null # @@ -137,8 +137,8 @@ select length(IDB) from t1; drop table t1; --disable_query_log -#call mtr.add_suppression("tse_ddl_fill_column_by_field"); -#call mtr.add_suppression("TSE_RETURN_IF_ERROR return"); +#call mtr.add_suppression("ctc_ddl_fill_column_by_field"); +#call mtr.add_suppression("CTC_RETURN_IF_ERROR return"); --enable_query_log create table t1 (IDA varchar(2001)) ENGINE=CTC DEFAULT CHARSET=utf8mb4; diff --git a/mysql-test/suite/tianchi/t/ctc_datatype_adapt.test b/mysql-test/suite/ctc/t/ctc_datatype_adapt.test similarity index 97% rename from mysql-test/suite/tianchi/t/ctc_datatype_adapt.test rename to mysql-test/suite/ctc/t/ctc_datatype_adapt.test index c7da00e..41a3cc7 100644 --- a/mysql-test/suite/tianchi/t/ctc_datatype_adapt.test +++ b/mysql-test/suite/ctc/t/ctc_datatype_adapt.test @@ -1,5 +1,5 @@ # -# Simple test for the TSE storage engine +# Simple test for the CTC storage engine # with the data type which not supported by CantianDB # such as YEAR, TIME ,etc. # @@ -21,7 +21,7 @@ drop table t1; -- echo # test with TIME data type # -# Note:for TIME data type, TSE just support data +# Note:for TIME data type, CTC just support data # range 00:00:00.000000 to 23:59:59.000000, # not -838:59:59.000000~838:59:59.000000 # diff --git a/mysql-test/suite/tianchi/t/ctc_datatype_blob.test b/mysql-test/suite/ctc/t/ctc_datatype_blob.test similarity index 99% rename from mysql-test/suite/tianchi/t/ctc_datatype_blob.test rename to mysql-test/suite/ctc/t/ctc_datatype_blob.test index c1301f1..5232e15 100644 --- a/mysql-test/suite/tianchi/t/ctc_datatype_blob.test +++ b/mysql-test/suite/ctc/t/ctc_datatype_blob.test @@ -1,5 +1,5 @@ # -# Simple test for the TSE storage engine +# Simple test for the CTC storage engine # with blob data and null / not null # diff --git a/mysql-test/suite/tianchi/t/ctc_datetime_analyze.test b/mysql-test/suite/ctc/t/ctc_datetime_analyze.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_datetime_analyze.test rename to mysql-test/suite/ctc/t/ctc_datetime_analyze.test diff --git a/mysql-test/suite/tianchi/t/ctc_dc_reuse.test b/mysql-test/suite/ctc/t/ctc_dc_reuse.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_dc_reuse.test rename to mysql-test/suite/ctc/t/ctc_dc_reuse.test diff --git a/mysql-test/suite/tianchi/t/ctc_dcl.test b/mysql-test/suite/ctc/t/ctc_dcl.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_dcl.test rename to mysql-test/suite/ctc/t/ctc_dcl.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl.test b/mysql-test/suite/ctc/t/ctc_ddl.test similarity index 87% rename from mysql-test/suite/tianchi/t/ctc_ddl.test rename to mysql-test/suite/ctc/t/ctc_ddl.test index e944c8a..eb82649 100644 --- a/mysql-test/suite/tianchi/t/ctc_ddl.test +++ b/mysql-test/suite/ctc/t/ctc_ddl.test @@ -83,7 +83,7 @@ ALTER TABLE DEMO RENAME TO DEMO1; SELECT * FROM DEMO1; #Renaming a general tablespace -#TSE不支持CREATE TABLESPACE，也就无法rename TABLESPACE，也就无法rename tablespace +#CTC不支持CREATE TABLESPACE，也就无法rename TABLESPACE，也就无法rename tablespace #CREATE TABLESPACE TEST_SPACE; #ERROR 1478 (HY000): Table storage engine 'CTC' does not support the create option 'CREATE TABLESPACE' @@ -119,25 +119,25 @@ create table `@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#$` create table ``(i int); --error ER_WRONG_TABLE_NAME create table ` `(i int); -set debug = '+d, tse_lock_table_fail'; -set debug = '+d, tse_lock_table_fail_DDL_LOCKED'; +set debug = '+d, ctc_lock_table_fail'; +set debug = '+d, ctc_lock_table_fail_DDL_LOCKED'; --error ER_DISALLOWED_OPERATION create table test1(i int); -set debug = '-d, tse_lock_table_fail_DDL_LOCKED'; -set debug = '+d, tse_lock_table_fail_VERSION_NOT_MATCH'; +set debug = '-d, ctc_lock_table_fail_DDL_LOCKED'; +set debug = '+d, ctc_lock_table_fail_VERSION_NOT_MATCH'; --error ER_DISALLOWED_OPERATION create table test1(i int); -set debug = '-d, tse_lock_table_fail_VERSION_NOT_MATCH'; -set debug = '+d, tse_lock_table_fail_DISALLOW_OPERATION'; +set debug = '-d, ctc_lock_table_fail_VERSION_NOT_MATCH'; +set debug = '+d, ctc_lock_table_fail_DISALLOW_OPERATION'; --error ER_DISALLOWED_OPERATION create table test1(i int); -set debug = '-d, tse_lock_table_fail_DISALLOW_OPERATION'; -set debug = '-d, tse_lock_table_fail'; +set debug = '-d, ctc_lock_table_fail_DISALLOW_OPERATION'; +set debug = '-d, ctc_lock_table_fail'; create table test1(i int); set debug = '+d, non_metadata_normalization'; -set debug = '+d, tse_ddl_rewrite_broadcast_fail'; +set debug = '+d, ctc_ddl_rewrite_broadcast_fail'; --error ER_DISALLOWED_OPERATION lock table test1 write; -set debug = '-d, tse_ddl_rewrite_broadcast_fail'; +set debug = '-d, ctc_ddl_rewrite_broadcast_fail'; set debug = '-d, non_metadata_normalization'; drop table test1; \ No newline at end of file diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_alter_table.test b/mysql-test/suite/ctc/t/ctc_ddl_alter_table.test similarity index 99% rename from mysql-test/suite/tianchi/t/ctc_ddl_alter_table.test rename to mysql-test/suite/ctc/t/ctc_ddl_alter_table.test index b5433bd..1326548 100644 --- a/mysql-test/suite/tianchi/t/ctc_ddl_alter_table.test +++ b/mysql-test/suite/ctc/t/ctc_ddl_alter_table.test @@ -568,7 +568,7 @@ ALTER TABLE `test`.`supplier11` ADD CONSTRAINT `chk_1000` CHECK((`supplier_id` > DROP TABLE `test`.`supplier11`; DROP TABLE `test`.`supplier`; -# 验证TSE PK在使用add column方式进行创建时，存在约束名称对接不一致问题 +# 验证CTC PK在使用add column方式进行创建时，存在约束名称对接不一致问题 create table DEMO_KEY (ID integer, AGE integer, GRADE real); # 原先使用 被索引列的列名+tableid作为 PK约束名 现改为PRIMARY+tableid alter table DEMO_KEY add column col1 integer primary key; diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_analyze.test b/mysql-test/suite/ctc/t/ctc_ddl_analyze.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_analyze.test rename to mysql-test/suite/ctc/t/ctc_ddl_analyze.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_auto_inc.test b/mysql-test/suite/ctc/t/ctc_ddl_auto_inc.test similarity index 99% rename from mysql-test/suite/tianchi/t/ctc_ddl_auto_inc.test rename to mysql-test/suite/ctc/t/ctc_ddl_auto_inc.test index 7f7ff5c..24d71f6 100644 --- a/mysql-test/suite/tianchi/t/ctc_ddl_auto_inc.test +++ b/mysql-test/suite/ctc/t/ctc_ddl_auto_inc.test @@ -359,7 +359,7 @@ drop table DEMO; #无符号BIGINT主键自增测试(范围为0-18446744073709551615) -##tse的uint64_t对接参天的int64_t(范围为-9223372036854775808-9223372036854775807) +##ctc的uint64_t对接参天的int64_t(范围为-9223372036854775808-9223372036854775807) create table DEMO (ID BIGINT unsigned PRIMARY KEY auto_increment ,ID1 BIGINT); insert DEMO values (9223372036854775806, 100); insert DEMO values (null, 100); diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_cascade.test b/mysql-test/suite/ctc/t/ctc_ddl_cascade.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_cascade.test rename to mysql-test/suite/ctc/t/ctc_ddl_cascade.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_character_set.test b/mysql-test/suite/ctc/t/ctc_ddl_character_set.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_character_set.test rename to mysql-test/suite/ctc/t/ctc_ddl_character_set.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_create_table.test b/mysql-test/suite/ctc/t/ctc_ddl_create_table.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_create_table.test rename to mysql-test/suite/ctc/t/ctc_ddl_create_table.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_create_table_check.test b/mysql-test/suite/ctc/t/ctc_ddl_create_table_check.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_create_table_check.test rename to mysql-test/suite/ctc/t/ctc_ddl_create_table_check.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_default_index.test b/mysql-test/suite/ctc/t/ctc_ddl_default_index.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_default_index.test rename to mysql-test/suite/ctc/t/ctc_ddl_default_index.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_engine.test b/mysql-test/suite/ctc/t/ctc_ddl_engine.test similarity index 67% rename from mysql-test/suite/tianchi/t/ctc_ddl_engine.test rename to mysql-test/suite/ctc/t/ctc_ddl_engine.test index 6cc4718..d37353b 100644 --- a/mysql-test/suite/tianchi/t/ctc_ddl_engine.test +++ b/mysql-test/suite/ctc/t/ctc_ddl_engine.test @@ -1,7 +1,7 @@ #切换引擎相关的测试用例 -#不支持设置TSE以外的任何引擎存储引擎 +#不支持设置CTC以外的任何引擎存储引擎 set default_storage_engine=CTC; --error ER_DISALLOWED_OPERATION set default_storage_engine=InnoDB; @@ -15,11 +15,11 @@ set default_storage_engine=CTC; set default_storage_engine=CTC; create database demo_db_tmp; use demo_db_tmp; -create table TSE_DEMO (ID integer not null, NAME varchar(19), AGE integer, GRADE real); -INSERT INTO TSE_DEMO values(30,'DEMO',21,23); -insert into TSE_DEMO values (1, 'DEMO', 35, 6.9); -select * from TSE_DEMO; -show create table TSE_DEMO; +create table CTC_DEMO (ID integer not null, NAME varchar(19), AGE integer, GRADE real); +INSERT INTO CTC_DEMO values(30,'DEMO',21,23); +insert into CTC_DEMO values (1, 'DEMO', 35, 6.9); +select * from CTC_DEMO; +show create table CTC_DEMO; --error 1286 create table InnoDB_DEMO (ID integer not null, NAME varchar(19), AGE integer, GRADE real) engine = InnoDB1; --error ER_DISALLOWED_OPERATION @@ -27,15 +27,15 @@ create table InnoDB_DEMO (ID integer not null, NAME varchar(19), AGE integer, GR --error ER_DISALLOWED_OPERATION create table MyISAM_DEMO (ID integer not null, NAME varchar(19), AGE integer, GRADE real) engine = MyISAM; create table InnoDB_DEMO (ID integer not null, NAME varchar(19), AGE integer, GRADE real) engine = CTC; -show create table TSE_DEMO; +show create table CTC_DEMO; --error ER_DISALLOWED_OPERATION -alter table TSE_DEMO engine=InnoDB; -show create table TSE_DEMO; +alter table CTC_DEMO engine=InnoDB; +show create table CTC_DEMO; --error ER_DISALLOWED_OPERATION -alter table TSE_DEMO engine=MyISAM; -show create table TSE_DEMO; -alter table TSE_DEMO engine=CTC; -show create table TSE_DEMO; -select * from TSE_DEMO; +alter table CTC_DEMO engine=MyISAM; +show create table CTC_DEMO; +alter table CTC_DEMO engine=CTC; +show create table CTC_DEMO; +select * from CTC_DEMO; drop database demo_db_tmp; diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_fault_process.test b/mysql-test/suite/ctc/t/ctc_ddl_fault_process.test similarity index 90% rename from mysql-test/suite/tianchi/t/ctc_ddl_fault_process.test rename to mysql-test/suite/ctc/t/ctc_ddl_fault_process.test index 5b18285..a99f43f 100644 --- a/mysql-test/suite/tianchi/t/ctc_ddl_fault_process.test +++ b/mysql-test/suite/ctc/t/ctc_ddl_fault_process.test @@ -8,11 +8,11 @@ use DEMO_DB; #创建表 模拟参天成功，mysql失败的场景，使用仅仅mysql执行sql语句的方式来修正错误(ctc_disable_ddl) -set debug = '+d, tse_create_table_cantian_error';#此句用于模拟参天成功，但是给mysql返回失败的场景 +set debug = '+d, ctc_create_table_cantian_error';#此句用于模拟参天成功，但是给mysql返回失败的场景 --error 3655 #此时参天创建成功，mysql创建失败，参天有表结构，mysql没有表结构(ERROR 3655 (HY000): ddl statement operation is disallowed on create table DEMO (ID integer not null, NAME varchar(19), AGE integer, GRADE real)) create table DEMO (ID integer not null, NAME varchar(19), AGE integer, GRADE real); show tables; -set debug = '-d, tse_create_table_cantian_error';#清除故障调试点 +set debug = '-d, ctc_create_table_cantian_error';#清除故障调试点 --error ER_DISALLOWED_OPERATION #此时因为参天表已经存在，再创建表，会报表已经存在(ERROR ER_DISALLOWED_OPERATION (HY000): DEMO_DB_DB.DEMO already exists(cantian error_code:1301)) create table DEMO (ID integer not null, NAME varchar(19), AGE integer, GRADE real); show tables; @@ -43,10 +43,10 @@ ALTER TABLE DEMO ADD COLUMN col1 integer; insert into DEMO values (1, 'LIOR', 35, 6.9,1987); # 执行 select 语句 select * from DEMO; -set debug = '+d, tse_drop_table_cantian_error'; +set debug = '+d, ctc_drop_table_cantian_error'; --error 3655 #此时参天删表成功，mysql删表失败，参天无表结构，mysql有表结构 ERROR 3655 (HY000): ddl statement operation is disallowed on drop table DEMO drop table DEMO; -set debug = '-d, tse_drop_table_cantian_error'; +set debug = '-d, ctc_drop_table_cantian_error'; --error ER_DISALLOWED_OPERATION #此时参天表不存在，mysql有表，删表失败 ERROR ER_DISALLOWED_OPERATION (HY000): The table or view DEMO_DB_DB.DEMO does not exist.(cantian error_code:843) drop table DEMO; #sql只在mysql执行，不同步参天节点 @@ -68,7 +68,7 @@ ALTER TABLE DEMO ADD COLUMN col1 integer; insert into DEMO values (1, 'LIOR', 35, 6.9,1987); # 执行 select 语句 select * from DEMO; -set debug = '+d, tse_rename_table_cantian_error'; +set debug = '+d, ctc_rename_table_cantian_error'; --error 3655 #此时参天rename成功，mysqlrename失败， ERROR 3655 (HY000): ddl statement operation is disallowed on ALTER TABLE DEMO RENAME TO DEMO1 ALTER TABLE DEMO RENAME TO DEMO1; show tables; @@ -76,7 +76,7 @@ show tables; select * from DEMO; --error 1146 #此时参天表已经不存在了，select会出错，ERROR 1146 (42S02): Table 'DEMO_DB.demo1' doesn't exist select * from DEMO1; -set debug = '-d, tse_rename_table_cantian_error'; +set debug = '-d, ctc_rename_table_cantian_error'; --error 1146 #此时参天表已经不存在了，rename会出错，ERROR 1146 (42S02): Table 'DEMO_DB.demo1' doesn't exist ALTER TABLE DEMO RENAME TO DEMO1; #sql只在mysql执行，不同步参天节点 此时能够rename表成功 @@ -98,7 +98,7 @@ ALTER TABLE DEMO ADD COLUMN col1 integer; insert into DEMO values (1, 'LIOR', 35, 6.9,1987); # 执行 select 语句 select * from DEMO; -set debug = '+d, tse_rename_table_cantian_error'; +set debug = '+d, ctc_rename_table_cantian_error'; --error 3655 #此时参天rename成功，mysqlrename失败， ERROR 3655 (HY000): ddl statement operation is disallowed on ALTER TABLE DEMO RENAME TO DEMO1 RENAME TABLE DEMO TO DEMO1; show tables; @@ -106,7 +106,7 @@ show tables; select * from DEMO; --error 1146 #此时参天表已经不存在了，select会出错，ERROR 1146 (42S02): Table 'DEMO_DB.demo1' doesn't exist select * from DEMO1; -set debug = '-d, tse_rename_table_cantian_error'; +set debug = '-d, ctc_rename_table_cantian_error'; --error ER_DISALLOWED_OPERATION #此时参天表已经不存在了，rename会出错，ERROR ER_DISALLOWED_OPERATION (HY000): The table or view DEMO_DB_DB.demo does not exist.(cantian error_code:843) RENAME TABLE DEMO TO DEMO1; #sql只在mysql执行，不同步参天节点 此时能够rename表成功 @@ -127,12 +127,12 @@ create table DEMO (ID integer not null, NAME varchar(19), AGE integer, GRADE rea show tables; INSERT INTO DEMO values(30,'insert',21,23); select * from DEMO; -set debug = '+d, tse_alter_table_cantian_error';#此句用于模拟参天成功，但是给mysql返回失败的场景 +set debug = '+d, ctc_alter_table_cantian_error';#此句用于模拟参天成功，但是给mysql返回失败的场景 --error 3655 #ERROR 3655 (HY000): ddl statement operation is disallowed on ALTER TABLE DEMO ADD COLUMN col1 integer ALTER TABLE DEMO ADD COLUMN col1 integer; select * from DEMO; desc DEMO; -set debug = '-d, tse_alter_table_cantian_error';#清除故障调试点 +set debug = '-d, ctc_alter_table_cantian_error';#清除故障调试点 ALTER TABLE DEMO ADD COLUMN col1 integer; desc DEMO; #sql只在mysql执行，不同步参天节点 @@ -149,17 +149,17 @@ drop table DEMO; -#修改表[删除列] 模拟参天成功，mysql失败的场景，使用仅仅mysql执行sql语句的方式来修正错误(tse_disable_ddl) +#修改表[删除列] 模拟参天成功，mysql失败的场景，使用仅仅mysql执行sql语句的方式来修正错误(ctc_disable_ddl) create table DEMO (ID integer not null, NAME varchar(19), AGE integer, GRADE real); show tables; INSERT INTO DEMO values(30,'insert',21,23); select * from DEMO; -set debug = '+d, tse_alter_table_cantian_error';#此句用于模拟参天成功，但是给mysql返回失败的场景 +set debug = '+d, ctc_alter_table_cantian_error';#此句用于模拟参天成功，但是给mysql返回失败的场景 --error 3655 #ERROR 3655 (HY000): ddl statement operation is disallowed on ALTER TABLE DEMO ADD COLUMN col1 integer ALTER TABLE DEMO drop COLUMN GRADE; select * from DEMO; desc DEMO; -set debug = '-d, tse_alter_table_cantian_error';#清除故障调试点 +set debug = '-d, ctc_alter_table_cantian_error';#清除故障调试点 ALTER TABLE DEMO drop COLUMN GRADE; desc DEMO; #mysql和参天的元数据列数不匹配，因此插入失败 diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_foreign_key.test b/mysql-test/suite/ctc/t/ctc_ddl_foreign_key.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_foreign_key.test rename to mysql-test/suite/ctc/t/ctc_ddl_foreign_key.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_foreign_key_set_enum.test b/mysql-test/suite/ctc/t/ctc_ddl_foreign_key_set_enum.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_foreign_key_set_enum.test rename to mysql-test/suite/ctc/t/ctc_ddl_foreign_key_set_enum.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_func_index.test b/mysql-test/suite/ctc/t/ctc_ddl_func_index.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_func_index.test rename to mysql-test/suite/ctc/t/ctc_ddl_func_index.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_func_proc.test b/mysql-test/suite/ctc/t/ctc_ddl_func_proc.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_func_proc.test rename to mysql-test/suite/ctc/t/ctc_ddl_func_proc.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_generated_columns.test b/mysql-test/suite/ctc/t/ctc_ddl_generated_columns.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_generated_columns.test rename to mysql-test/suite/ctc/t/ctc_ddl_generated_columns.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_index.test b/mysql-test/suite/ctc/t/ctc_ddl_index.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_index.test rename to mysql-test/suite/ctc/t/ctc_ddl_index.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_limit.test b/mysql-test/suite/ctc/t/ctc_ddl_limit.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_limit.test rename to mysql-test/suite/ctc/t/ctc_ddl_limit.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_max_reclength.test b/mysql-test/suite/ctc/t/ctc_ddl_max_reclength.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_max_reclength.test rename to mysql-test/suite/ctc/t/ctc_ddl_max_reclength.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_multi_db.test b/mysql-test/suite/ctc/t/ctc_ddl_multi_db.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_multi_db.test rename to mysql-test/suite/ctc/t/ctc_ddl_multi_db.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_partition.test b/mysql-test/suite/ctc/t/ctc_ddl_partition.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_partition.test rename to mysql-test/suite/ctc/t/ctc_ddl_partition.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_tablespace.test b/mysql-test/suite/ctc/t/ctc_ddl_tablespace.test similarity index 98% rename from mysql-test/suite/tianchi/t/ctc_ddl_tablespace.test rename to mysql-test/suite/ctc/t/ctc_ddl_tablespace.test index 290a0df..caa0b92 100644 --- a/mysql-test/suite/tianchi/t/ctc_ddl_tablespace.test +++ b/mysql-test/suite/ctc/t/ctc_ddl_tablespace.test @@ -105,7 +105,7 @@ drop tablespace ts01; create tablespace ts04 add datafile 'ts_04' autoextend_size=1M; -#测试alter tablespace add drop datafile(innodb不支持这两种操作，tse对标innodb需要进行禁止) +#测试alter tablespace add drop datafile(innodb不支持这两种操作，ctc对标innodb需要进行禁止) create tablespace ts01 add datafile 'ts_01.ibd' autoextend_size=1M; --error ER_CHECK_NOT_IMPLEMENTED alter tablespace ts01 add datafile 'ts_02.ibd' autoextend_size=4M; diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_temporary_table.test b/mysql-test/suite/ctc/t/ctc_ddl_temporary_table.test similarity index 97% rename from mysql-test/suite/tianchi/t/ctc_ddl_temporary_table.test rename to mysql-test/suite/ctc/t/ctc_ddl_temporary_table.test index dfafe69..643b05d 100644 --- a/mysql-test/suite/tianchi/t/ctc_ddl_temporary_table.test +++ b/mysql-test/suite/ctc/t/ctc_ddl_temporary_table.test @@ -2,7 +2,7 @@ drop table if exists DEMO; --enable_warnings -#临时表 临时表中表名和数据库的表名相同，不使用TSE,使用的是INNODB +#临时表 临时表中表名和数据库的表名相同，不使用CTC,使用的是INNODB set default_storage_engine=CTC; # 创建并切换数据库 create database demo_db_tmp; @@ -41,7 +41,7 @@ drop database demo_db_tmp; -#临时表 临时表中表名和数据库的表名不相同，不使用TSE 使用的是INNODB +#临时表 临时表中表名和数据库的表名不相同，不使用CTC 使用的是INNODB set default_storage_engine=CTC; # 创建并切换数据库 create database demo_db_tmp; diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_too_many_databases.test b/mysql-test/suite/ctc/t/ctc_ddl_too_many_databases.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_too_many_databases.test rename to mysql-test/suite/ctc/t/ctc_ddl_too_many_databases.test diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_trigger.test b/mysql-test/suite/ctc/t/ctc_ddl_trigger.test similarity index 80% rename from mysql-test/suite/tianchi/t/ctc_ddl_trigger.test rename to mysql-test/suite/ctc/t/ctc_ddl_trigger.test index 8a0cfd4..21d98ef 100644 --- a/mysql-test/suite/tianchi/t/ctc_ddl_trigger.test +++ b/mysql-test/suite/ctc/t/ctc_ddl_trigger.test @@ -8,14 +8,14 @@ create table DEMO (ID integer not null, NAME varchar(20), AGE integer, GRADE rea create table DEMO_TRIGGER_LOG (ACTION varchar(20), NAME varchar(20)); DELIMITER |; -create TRIGGER TRIGGER_TSE1 AFTER INSERT ON DEMO FOR EACH ROW +create TRIGGER TRIGGER_CTC1 AFTER INSERT ON DEMO FOR EACH ROW BEGIN IF NEW.AGE <= 0 THEN INSERT INTO DEMO_TRIGGER_LOG VALUES('insert', NEW.NAME); END IF; END| -create TRIGGER TRIGGER_TSE2 BEFORE UPDATE ON DEMO FOR EACH ROW +create TRIGGER TRIGGER_CTC2 BEFORE UPDATE ON DEMO FOR EACH ROW BEGIN IF NEW.AGE < 0 THEN SET NEW.AGE = 0; @@ -25,7 +25,7 @@ BEGIN INSERT INTO DEMO_TRIGGER_LOG VALUES('update', NEW.NAME); END| -create TRIGGER TRIGGER_TSE3 AFTER DELETE ON DEMO FOR EACH ROW +create TRIGGER TRIGGER_CTC3 AFTER DELETE ON DEMO FOR EACH ROW BEGIN IF old.AGE > 0 THEN INSERT INTO DEMO_TRIGGER_LOG VALUES('delete', old.NAME); @@ -59,12 +59,12 @@ select * from DEMO_TRIGGER_LOG; --replace_column 6 # SHOW TRIGGERS; --error 1360 -DROP TRIGGER TRIGGER_TSE; +DROP TRIGGER TRIGGER_CTC; -DROP TRIGGER IF EXISTS TRIGGER_TSE; -DROP TRIGGER IF EXISTS TRIGGER_TSE1; -DROP TRIGGER IF EXISTS TRIGGER_TSE2; -DROP TRIGGER IF EXISTS TRIGGER_TSE3; +DROP TRIGGER IF EXISTS TRIGGER_CTC; +DROP TRIGGER IF EXISTS TRIGGER_CTC1; +DROP TRIGGER IF EXISTS TRIGGER_CTC2; +DROP TRIGGER IF EXISTS TRIGGER_CTC3; --replace_column 6 # SHOW TRIGGERS; diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_unsupport_command.test b/mysql-test/suite/ctc/t/ctc_ddl_unsupport_command.test similarity index 99% rename from mysql-test/suite/tianchi/t/ctc_ddl_unsupport_command.test rename to mysql-test/suite/ctc/t/ctc_ddl_unsupport_command.test index 7ffd2aa..e6b4d1b 100644 --- a/mysql-test/suite/tianchi/t/ctc_ddl_unsupport_command.test +++ b/mysql-test/suite/ctc/t/ctc_ddl_unsupport_command.test @@ -42,7 +42,7 @@ ALTER INSTANCE RELOAD KEYRING; ALTER INSTANCE ROTATE BINLOG MASTER KEY; -#测试alter tablespace add drop datafile(innodb不支持这两种操作，tse对标innodb需要进行禁止) +#测试alter tablespace add drop datafile(innodb不支持这两种操作，ctc对标innodb需要进行禁止) create tablespace ts01 add datafile 'ts_01.ibd' autoextend_size=1M; --error ER_CHECK_NOT_IMPLEMENTED alter tablespace ts01 add datafile 'ts_02.ibd' autoextend_size=4M; diff --git a/mysql-test/suite/tianchi/t/ctc_ddl_view.test b/mysql-test/suite/ctc/t/ctc_ddl_view.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_ddl_view.test rename to mysql-test/suite/ctc/t/ctc_ddl_view.test diff --git a/mysql-test/suite/tianchi/t/ctc_decimal_analyze.test b/mysql-test/suite/ctc/t/ctc_decimal_analyze.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_decimal_analyze.test rename to mysql-test/suite/ctc/t/ctc_decimal_analyze.test diff --git a/mysql-test/suite/tianchi/t/ctc_delete_time.test b/mysql-test/suite/ctc/t/ctc_delete_time.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_delete_time.test rename to mysql-test/suite/ctc/t/ctc_delete_time.test diff --git a/mysql-test/suite/tianchi/t/ctc_dml_decimal_table.test b/mysql-test/suite/ctc/t/ctc_dml_decimal_table.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_dml_decimal_table.test rename to mysql-test/suite/ctc/t/ctc_dml_decimal_table.test diff --git a/mysql-test/suite/tianchi/t/ctc_dml_ignore.test b/mysql-test/suite/ctc/t/ctc_dml_ignore.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_dml_ignore.test rename to mysql-test/suite/ctc/t/ctc_dml_ignore.test diff --git a/mysql-test/suite/tianchi/t/ctc_dml_two_table.test b/mysql-test/suite/ctc/t/ctc_dml_two_table.test similarity index 94% rename from mysql-test/suite/tianchi/t/ctc_dml_two_table.test rename to mysql-test/suite/ctc/t/ctc_dml_two_table.test index c37717b..8dbf1c5 100644 --- a/mysql-test/suite/tianchi/t/ctc_dml_two_table.test +++ b/mysql-test/suite/ctc/t/ctc_dml_two_table.test @@ -3,7 +3,7 @@ -- disable_abort_on_error -- disable_query_log -# 设置默认存储引擎 (自动生成.result的时候，需要使用InnoDB，执行DML测试的时候，要使用TSE引擎，我们的策略是比较InnoDB和TSE引擎执行结果的差异来校验TSE引擎是否存在BUG) +# 设置默认存储引擎 (自动生成.result的时候，需要使用InnoDB，执行DML测试的时候，要使用CTC引擎，我们的策略是比较InnoDB和CTC引擎执行结果的差异来校验CTC引擎是否存在BUG) #注意，测试用例要保证不破坏执行环境，所以测试用例产生的数据(包括表，数据库等等)，测试用例执行完毕后，原则上是要把产生的数据删除的，避免影响别的测试用例 drop table IF EXISTS PERSONS; diff --git a/mysql-test/suite/tianchi/t/ctc_enum_analyze.test b/mysql-test/suite/ctc/t/ctc_enum_analyze.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_enum_analyze.test rename to mysql-test/suite/ctc/t/ctc_enum_analyze.test diff --git a/mysql-test/suite/tianchi/t/ctc_handler_operation.test b/mysql-test/suite/ctc/t/ctc_handler_operation.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_handler_operation.test rename to mysql-test/suite/ctc/t/ctc_handler_operation.test diff --git a/mysql-test/suite/tianchi/t/ctc_index_functions_base.test b/mysql-test/suite/ctc/t/ctc_index_functions_base.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_index_functions_base.test rename to mysql-test/suite/ctc/t/ctc_index_functions_base.test diff --git a/mysql-test/suite/tianchi/t/ctc_insert_time.test b/mysql-test/suite/ctc/t/ctc_insert_time.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_insert_time.test rename to mysql-test/suite/ctc/t/ctc_insert_time.test diff --git a/mysql-test/suite/tianchi/t/ctc_json_value.test b/mysql-test/suite/ctc/t/ctc_json_value.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_json_value.test rename to mysql-test/suite/ctc/t/ctc_json_value.test diff --git a/mysql-test/suite/tianchi/t/ctc_lcov.test b/mysql-test/suite/ctc/t/ctc_lcov.test similarity index 97% rename from mysql-test/suite/tianchi/t/ctc_lcov.test rename to mysql-test/suite/ctc/t/ctc_lcov.test index a260b24..86c887b 100644 --- a/mysql-test/suite/tianchi/t/ctc_lcov.test +++ b/mysql-test/suite/ctc/t/ctc_lcov.test @@ -10,7 +10,7 @@ drop tablespace ts01_new; # 测试datafile命名限制 --error ER_WRONG_FILE_NAME create tablespace ts04 add datafile 'ts_04' autoextend_size=1M; -#测试alter tablespace add drop datafile(innodb不支持这两种操作，tse对标innodb需要进行禁止) +#测试alter tablespace add drop datafile(innodb不支持这两种操作，ctc对标innodb需要进行禁止) create tablespace ts01 add datafile 'ts_01.ibd' autoextend_size=1M; --error ER_CHECK_NOT_IMPLEMENTED alter tablespace ts01 add datafile 'ts_02.ibd' autoextend_size=4M; diff --git a/mysql-test/suite/tianchi/t/ctc_link_and_migr_row.test b/mysql-test/suite/ctc/t/ctc_link_and_migr_row.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_link_and_migr_row.test rename to mysql-test/suite/ctc/t/ctc_link_and_migr_row.test diff --git a/mysql-test/suite/tianchi/t/ctc_lock_instance.test b/mysql-test/suite/ctc/t/ctc_lock_instance.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_lock_instance.test rename to mysql-test/suite/ctc/t/ctc_lock_instance.test diff --git a/mysql-test/suite/tianchi/t/ctc_locking_read_concurrency_with_nowait_and_skip_locked.test b/mysql-test/suite/ctc/t/ctc_locking_read_concurrency_with_nowait_and_skip_locked.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_locking_read_concurrency_with_nowait_and_skip_locked.test rename to mysql-test/suite/ctc/t/ctc_locking_read_concurrency_with_nowait_and_skip_locked.test diff --git a/mysql-test/suite/tianchi/t/ctc_partition_update.test b/mysql-test/suite/ctc/t/ctc_partition_update.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_partition_update.test rename to mysql-test/suite/ctc/t/ctc_partition_update.test diff --git a/mysql-test/suite/tianchi/t/ctc_read_only.test b/mysql-test/suite/ctc/t/ctc_read_only.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_read_only.test rename to mysql-test/suite/ctc/t/ctc_read_only.test diff --git a/mysql-test/suite/tianchi/t/ctc_select_early_return.test b/mysql-test/suite/ctc/t/ctc_select_early_return.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_select_early_return.test rename to mysql-test/suite/ctc/t/ctc_select_early_return.test diff --git a/mysql-test/suite/tianchi/t/ctc_set_analyze.test b/mysql-test/suite/ctc/t/ctc_set_analyze.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_set_analyze.test rename to mysql-test/suite/ctc/t/ctc_set_analyze.test diff --git a/mysql-test/suite/tianchi/t/ctc_string_analyze.test b/mysql-test/suite/ctc/t/ctc_string_analyze.test similarity index 98% rename from mysql-test/suite/tianchi/t/ctc_string_analyze.test rename to mysql-test/suite/ctc/t/ctc_string_analyze.test index 7a6901c..01588b7 100644 --- a/mysql-test/suite/tianchi/t/ctc_string_analyze.test +++ b/mysql-test/suite/ctc/t/ctc_string_analyze.test @@ -1,5 +1,5 @@ # -# Simple test for the TSE storage engine +# Simple test for the CTC storage engine # such as VARCHAR, CHAR ,etc. # diff --git a/mysql-test/suite/tianchi/t/ctc_update_time.test b/mysql-test/suite/ctc/t/ctc_update_time.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_update_time.test rename to mysql-test/suite/ctc/t/ctc_update_time.test diff --git a/mysql-test/suite/tianchi/t/ctc_varchar.test b/mysql-test/suite/ctc/t/ctc_varchar.test similarity index 100% rename from mysql-test/suite/tianchi/t/ctc_varchar.test rename to mysql-test/suite/ctc/t/ctc_varchar.test diff --git a/mysql-test/suite/tianchi/t/recreate_test_db.test b/mysql-test/suite/ctc/t/recreate_test_db.test similarity index 100% rename from mysql-test/suite/tianchi/t/recreate_test_db.test rename to mysql-test/suite/ctc/t/recreate_test_db.test diff --git a/storage/tianchi/CMakeLists.txt b/storage/ctc/CMakeLists.txt similarity index 69% rename from storage/tianchi/CMakeLists.txt rename to storage/ctc/CMakeLists.txt index d7d180f..98bf679 100644 --- a/storage/tianchi/CMakeLists.txt +++ b/storage/ctc/CMakeLists.txt @@ -12,17 +12,17 @@ # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA -SET(TSE_PLUGIN_DYNAMIC "ha_ctc") -SET(TSE_SOURCES tse_log.h ha_tse.cc ha_tse.h ha_tsepart.h ha_tsepart.cc ha_tse_ddl.cc ha_tse_ddl.h tse_ddl_util.cc tse_ddl_util.h datatype_cnvrtr.cc datatype_cnvrtr.h tse_error.cc tse_error.h - decimal_convert.cc decimal_convert.h tse_cbo.cc tse_cbo.h datatype_cnvrt_4_index_search.cc datatype_cnvrt_4_index_search.h tse_ddl_rewriter_plugin.cc - ctc_meta_data.cc ctc_meta_data.h tse_stats.h tse_stats.cc tse_srv.h tse_util.h tse_util.cc protobuf/tc_db.pb-c.c protobuf/tc_db.pb-c.h) +SET(CTC_PLUGIN_DYNAMIC "ha_ctc") +SET(CTC_SOURCES ctc_log.h ha_ctc.cc ha_ctc.h ha_ctcpart.h ha_ctcpart.cc ha_ctc_ddl.cc ha_ctc_ddl.h ctc_ddl_util.cc ctc_ddl_util.h datatype_cnvrtr.cc datatype_cnvrtr.h ctc_error.cc ctc_error.h + decimal_convert.cc decimal_convert.h ctc_cbo.cc ctc_cbo.h datatype_cnvrt_4_index_search.cc datatype_cnvrt_4_index_search.h ctc_ddl_rewriter_plugin.cc + ctc_meta_data.cc ctc_meta_data.h ctc_stats.h ctc_stats.cc ctc_srv.h ctc_util.h ctc_util.cc protobuf/tc_db.pb-c.c protobuf/tc_db.pb-c.h) option(WITH_DAAC OFF) IF (WITH_DAAC) add_definitions(-DWITH_DAAC) message(STATUS "ADD WITH DAAC") - list(APPEND TSE_SOURCES mysql_daac_plugin.cc) + list(APPEND CTC_SOURCES mysql_daac_plugin.cc) ELSE () - list(APPEND TSE_SOURCES tse_srv_mq_stub.cc tse_srv_mq_module.cc tse_srv_mq_module.h srv_mq_msg.h message_queue/dsw_shm.h + list(APPEND CTC_SOURCES ctc_srv_mq_stub.cc ctc_srv_mq_module.cc ctc_srv_mq_module.h srv_mq_msg.h message_queue/dsw_shm.h message_queue/dsw_list.h message_queue/dsw_message.h message_queue/dsw_typedef.h) ENDIF () ADD_DEFINITIONS(-DMYSQL_SERVER) @@ -46,40 +46,40 @@ LINK_DIRECTORIES(${DAAC_LIB_PATH}) LINK_DIRECTORIES(${MYSQL_CLIENT_STATIC_LIB_PATH}) INCLUDE_DIRECTORIES(SYSTEM ${BOOST_PATCHES_DIR} ${BOOST_INCLUDE_DIR}) -SET(TSE_PROXY_SOURCES tse_proxy_util.cc tse_proxy_util.h tse_mysql_proxy.cc) -SET(TSE_PROXY_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,-Bsymbolic") -add_library(ctc_proxy SHARED ${TSE_PROXY_SOURCES}) +SET(CTC_PROXY_SOURCES ctc_proxy_util.cc ctc_proxy_util.h ctc_mysql_proxy.cc) +SET(CTC_PROXY_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,-Bsymbolic") +add_library(ctc_proxy SHARED ${CTC_PROXY_SOURCES}) target_link_libraries(ctc_proxy libmysqlclient.a) # ctc_proxy link libmysqlclient.a function symbol rather than mysqld`s -set_target_properties(ctc_proxy PROPERTIES COMPILE_FLAGS ${TSE_PROXY_CXX_FLAGS} LINK_FLAGS " -Wl,-Bsymbolic" +set_target_properties(ctc_proxy PROPERTIES COMPILE_FLAGS ${CTC_PROXY_CXX_FLAGS} LINK_FLAGS " -Wl,-Bsymbolic" LIBRARY_OUTPUT_DIRECTORY ${DAAC_LIB_PATH}) IF (WITH_DAAC) - IF (WITH_TSE_STORAGE_ENGINE AND NOT WITHOUT_TSE_STORAGE_ENGINE) + IF (WITH_CTC_STORAGE_ENGINE AND NOT WITHOUT_CTC_STORAGE_ENGINE) MYSQL_ADD_PLUGIN(ctc - ${TSE_SOURCES} + ${CTC_SOURCES} STORAGE_ENGINE MANDATORY LINK_LIBRARIES libzecommon.so libzeclient.so libzeprotocol.so libprotobuf-c.a pcre2-8 ctc_proxy daac ) - ELSEIF (NOT WITHOUT_TSE_STORAGE_ENGINE) + ELSEIF (NOT WITHOUT_CTC_STORAGE_ENGINE) MYSQL_ADD_PLUGIN(ctc - ${TSE_SOURCES} + ${CTC_SOURCES} STORAGE_ENGINE MODULE_ONLY LINK_LIBRARIES libzecommon.so libzeclient.so libzeprotocol.so libprotobuf-c.a pcre2-8 ctc_proxy daac ) ENDIF () ELSE () - IF (WITH_TSE_STORAGE_ENGINE AND NOT WITHOUT_TSE_STORAGE_ENGINE) + IF (WITH_CTC_STORAGE_ENGINE AND NOT WITHOUT_CTC_STORAGE_ENGINE) MYSQL_ADD_PLUGIN(ctc - ${TSE_SOURCES} + ${CTC_SOURCES} STORAGE_ENGINE DEFAULT LINK_LIBRARIES message_queue libprotobuf-c.a libsecurec.so ctc_proxy ) - ELSEIF (NOT WITHOUT_TSE_STORAGE_ENGINE) + ELSEIF (NOT WITHOUT_CTC_STORAGE_ENGINE) MYSQL_ADD_PLUGIN(ctc - ${TSE_SOURCES} + ${CTC_SOURCES} STORAGE_ENGINE MODULE_ONLY LINK_LIBRARIES message_queue libprotobuf-c.a libsecurec.so ctc_proxy diff --git a/storage/tianchi/tse_cbo.cc b/storage/ctc/ctc_cbo.cc similarity index 89% rename from storage/tianchi/tse_cbo.cc rename to storage/ctc/ctc_cbo.cc index 4d64a29..2687648 100644 --- a/storage/tianchi/tse_cbo.cc +++ b/storage/ctc/ctc_cbo.cc @@ -14,13 +14,13 @@ along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Bon, MA 02110-1301 USA */ -#include "tse_cbo.h" -#include "ha_tse.h" -#include "tse_log.h" +#include "ctc_cbo.h" +#include "ha_ctc.h" +#include "ctc_log.h" #include "sql/field.h" -#include "tse_srv_mq_module.h" +#include "ctc_srv_mq_module.h" #include "datatype_cnvrtr.h" -#include "tse_util.h" +#include "ctc_util.h" static void convert_enum_key_to_variant(const uchar *enum_key, cache_variant_t *variant, capacity_usage cap_usage_of_enum_key) { @@ -59,7 +59,7 @@ static void convert_set_key_to_variant(const uchar *set_key, cache_variant_t *va } } -void r_key2variant(tse_key *rKey, KEY_PART_INFO *cur_index_part, cache_variant_t *ret_val, cache_variant_t * value, uint32_t key_offset) +void r_key2variant(ctc_key *rKey, KEY_PART_INFO *cur_index_part, cache_variant_t *ret_val, cache_variant_t * value, uint32_t key_offset) { if (rKey->cmp_type == CMP_TYPE_NULL) { *ret_val = *value; @@ -94,7 +94,7 @@ void r_key2variant(tse_key *rKey, KEY_PART_INFO *cur_index_part, cache_variant_t key_offset += field->real_type() == MYSQL_TYPE_VARCHAR ? OFFSET_VARCHAR_TYPE : 0; const uchar *key = rKey->key + key_offset + offset; - uchar tmp_ptr[TSE_BYTE_8] = {0}; + uchar tmp_ptr[CTC_BYTE_8] = {0}; const field_cnvrt_aux_t *mysql_info = get_auxiliary_for_field_convert(field, field->type()); switch (field->real_type()) { case MYSQL_TYPE_SET: @@ -133,11 +133,11 @@ void r_key2variant(tse_key *rKey, KEY_PART_INFO *cur_index_part, cache_variant_t ret_val->v_date = *(date_t *)const_cast(key); break; case MYSQL_TYPE_DATETIME2: - cnvrt_datetime_decimal(const_cast(key), cur_index_part->field->decimals(), tmp_ptr, DATETIME_MAX_DECIMALS, TSE_BYTE_8); + cnvrt_datetime_decimal(const_cast(key), cur_index_part->field->decimals(), tmp_ptr, DATETIME_MAX_DECIMALS, CTC_BYTE_8); ret_val->v_date = *(date_t *)tmp_ptr; break; case MYSQL_TYPE_TIME2: - cnvrt_time_decimal(const_cast(key), cur_index_part->field->decimals(), tmp_ptr, DATETIME_MAX_DECIMALS, TSE_BYTE_8); + cnvrt_time_decimal(const_cast(key), cur_index_part->field->decimals(), tmp_ptr, DATETIME_MAX_DECIMALS, CTC_BYTE_8); ret_val->v_date = *(date_t *)tmp_ptr; break; case MYSQL_TYPE_DECIMAL: @@ -177,13 +177,13 @@ double datetime_compare(const uchar *datetime1, const uchar *datetime2) } template -static inline en_tse_compare_type two_nums_compare(T a, T b) { +static inline en_ctc_compare_type two_nums_compare(T a, T b) { if (a > b) { return GREAT; } if (a < b) { return LESS; } return EQUAL; } -static en_tse_compare_type compare(cache_variant_t *right, cache_variant_t *left, Field *field, +static en_ctc_compare_type compare(cache_variant_t *right, cache_variant_t *left, Field *field, const CHARSET_INFO *cs) { double compare_value = 0; @@ -260,13 +260,13 @@ double eval_density_result(double density) return density; } -static double calc_frequency_hist_equal_density(tse_cbo_stats_column_t *col_stat, cache_variant_t *val, +static double calc_frequency_hist_equal_density(ctc_cbo_stats_column_t *col_stat, cache_variant_t *val, Field *field, const CHARSET_INFO *cs) { - en_tse_compare_type cmp_result; + en_ctc_compare_type cmp_result; int64 result = 0; double density = col_stat->density; - tse_cbo_column_hist_t *hist_infos = col_stat->column_hist; + ctc_cbo_column_hist_t *hist_infos = col_stat->column_hist; for (uint32 i = 0; i < col_stat->hist_count; i++) { cmp_result = compare(&hist_infos[i].ep_value, val, field, cs); @@ -288,12 +288,12 @@ static double calc_frequency_hist_equal_density(tse_cbo_stats_column_t *col_stat return density; } -static double calc_balance_hist_equal_density(tse_cbo_stats_column_t *col_stat, cache_variant_t *val, +static double calc_balance_hist_equal_density(ctc_cbo_stats_column_t *col_stat, cache_variant_t *val, Field *field, const CHARSET_INFO *cs) { uint32 popular_count = 0; - en_tse_compare_type cmp_result; - tse_cbo_column_hist_t *hist_infos = col_stat->column_hist; + en_ctc_compare_type cmp_result; + ctc_cbo_column_hist_t *hist_infos = col_stat->column_hist; for (uint32 i = 0; i < col_stat->hist_count; i++) { cmp_result = compare(&hist_infos[i].ep_value, val, field, cs); @@ -310,9 +310,9 @@ static double calc_balance_hist_equal_density(tse_cbo_stats_column_t *col_stat, return col_stat->density; } -static double calc_equal_null_density(tse_cbo_stats_table_t *cbo_stats, uint32 col_id) +static double calc_equal_null_density(ctc_cbo_stats_table_t *cbo_stats, uint32 col_id) { - tse_cbo_stats_column_t *col_stat = &cbo_stats->columns[col_id]; + ctc_cbo_stats_column_t *col_stat = &cbo_stats->columns[col_id]; double density = DEFAULT_RANGE_DENSITY; if (cbo_stats->estimate_rows > 0) { density = (double)col_stat->num_null / cbo_stats->estimate_rows; @@ -320,18 +320,18 @@ static double calc_equal_null_density(tse_cbo_stats_table_t *cbo_stats, uint32 c return density ; } -double calc_hist_equal_density(tse_cbo_stats_table_t *cbo_stats, cache_variant_t *val, +double calc_hist_equal_density(ctc_cbo_stats_table_t *cbo_stats, cache_variant_t *val, uint32 col_id, Field *field, const CHARSET_INFO *cs) { - tse_cbo_stats_column_t *col_stat = &cbo_stats->columns[col_id]; + ctc_cbo_stats_column_t *col_stat = &cbo_stats->columns[col_id]; double density = col_stat->density; uint32 hist_count = col_stat->hist_count; if (hist_count == 0) { - tse_log_note("hist_count: 0, column id: %u", col_id); + ctc_log_note("hist_count: 0, column id: %u", col_id); return density; } if (hist_count > STATS_HISTGRAM_MAX_SIZE) { - tse_log_error("Error hist_count: %u, column id: %u", hist_count, col_id); + ctc_log_error("Error hist_count: %u, column id: %u", hist_count, col_id); assert(0); return col_stat->density; } @@ -346,18 +346,18 @@ double calc_hist_equal_density(tse_cbo_stats_table_t *cbo_stats, cache_variant_t return density; } -static double calc_hist_between_frequency(tse_cbo_stats_table_t *cbo_stats, field_stats_val stats_val, +static double calc_hist_between_frequency(ctc_cbo_stats_table_t *cbo_stats, field_stats_val stats_val, Field *field, uint32 col_id, const CHARSET_INFO *cs) { - tse_cbo_stats_column_t *col_stat = &cbo_stats->columns[col_id]; + ctc_cbo_stats_column_t *col_stat = &cbo_stats->columns[col_id]; double density = col_stat->density; uint32 hist_count = col_stat->hist_count; - tse_cbo_column_hist_t *hist_infos = col_stat->column_hist; + ctc_cbo_column_hist_t *hist_infos = col_stat->column_hist; uint32 end_pos = hist_count - 1; int64 total_nums = hist_infos[end_pos].ep_number; int64 low_nums = 0; int64 high_nums = total_nums; - en_tse_compare_type cmp_result; + en_ctc_compare_type cmp_result; // HISTOGRAM_FREQUNCEY for (uint32 i = 0; i < hist_count; i++) { @@ -392,11 +392,11 @@ static double calc_hist_between_frequency(tse_cbo_stats_table_t *cbo_stats, fie } -static double percent_in_bucket(tse_cbo_stats_column_t *col_stat, uint32 high, +static double percent_in_bucket(ctc_cbo_stats_column_t *col_stat, uint32 high, cache_variant_t *key, Field *field) { double percent = 0.0D; - tse_cbo_column_hist_t *hist_infos = col_stat->column_hist; + ctc_cbo_column_hist_t *hist_infos = col_stat->column_hist; cache_variant_t *ep_high = high >= col_stat->hist_count ? &col_stat->high_value : &hist_infos[high].ep_value; cache_variant_t *ep_low = high < 1 ? &col_stat->low_value : &hist_infos[high - 1].ep_value; double denominator; @@ -477,13 +477,13 @@ static double percent_in_bucket(tse_cbo_stats_column_t *col_stat, uint32 high, return percent; } -static int calc_hist_range_boundary(field_stats_val stats_val, Field *field, tse_cbo_stats_column_t *col_stat, +static int calc_hist_range_boundary(field_stats_val stats_val, Field *field, ctc_cbo_stats_column_t *col_stat, double *percent, const CHARSET_INFO *cs) { - en_tse_compare_type cmp_result; + en_ctc_compare_type cmp_result; uint32 i, lo_pos, hi_pos; uint32 hist_count = col_stat->hist_count; - tse_cbo_column_hist_t *hist_infos = col_stat->column_hist; + ctc_cbo_column_hist_t *hist_infos = col_stat->column_hist; lo_pos = hi_pos = hist_count - 1; @@ -525,10 +525,10 @@ static int calc_hist_range_boundary(field_stats_val stats_val, Field *field, tse return hi_pos - lo_pos; } -static double calc_hist_between_balance(tse_cbo_stats_table_t *cbo_stats, field_stats_val stats_val, +static double calc_hist_between_balance(ctc_cbo_stats_table_t *cbo_stats, field_stats_val stats_val, Field *field, uint32 col_id, const CHARSET_INFO *cs) { - tse_cbo_stats_column_t *col_stat = &cbo_stats->columns[col_id]; + ctc_cbo_stats_column_t *col_stat = &cbo_stats->columns[col_id]; double density = col_stat->density; double percent = 0; @@ -542,17 +542,17 @@ static double calc_hist_between_balance(tse_cbo_stats_table_t *cbo_stats, field_ return density; } -static double calc_hist_between_density(tse_cbo_stats_table_t *cbo_stats, +static double calc_hist_between_density(ctc_cbo_stats_table_t *cbo_stats, uint32 col_id, Field *field, field_stats_val stats_val, const CHARSET_INFO *cs) { double density; - tse_cbo_stats_column_t *col_stat = &cbo_stats->columns[col_id]; + ctc_cbo_stats_column_t *col_stat = &cbo_stats->columns[col_id]; if (col_stat->hist_count == 0) { - tse_log_note("hist_count: 0, column id: %u", col_id); + ctc_log_note("hist_count: 0, column id: %u", col_id); return col_stat->density; } if (col_stat->hist_count > STATS_HISTGRAM_MAX_SIZE) { - tse_log_error("Error hist_count: %u, column id: %u", col_stat->hist_count, col_id); + ctc_log_error("Error hist_count: %u, column id: %u", col_stat->hist_count, col_id); assert(0); return col_stat->density; } @@ -566,12 +566,12 @@ static double calc_hist_between_density(tse_cbo_stats_table_t *cbo_stats, return density; } -double calc_density_by_cond(tse_cbo_stats_table_t *cbo_stats, KEY_PART_INFO cur_index_part, tse_range_key *key, +double calc_density_by_cond(ctc_cbo_stats_table_t *cbo_stats, KEY_PART_INFO cur_index_part, ctc_range_key *key, uint32_t key_offset, uint32_t col_id, const CHARSET_INFO *cs) { double density = DEFAULT_RANGE_DENSITY; - tse_key *min_key = key->min_key; - tse_key *max_key = key->max_key; + ctc_key *min_key = key->min_key; + ctc_key *max_key = key->max_key; cache_variant_t *low_val; cache_variant_t *high_val; @@ -594,7 +594,7 @@ double calc_density_by_cond(tse_cbo_stats_table_t *cbo_stats, KEY_PART_INFO cur_ compare(&min_key_val, high_val, cur_index_part.field, cs) == GREAT) { return 0; } - en_tse_compare_type comapare_value = compare(&max_key_val, &min_key_val, cur_index_part.field, cs); + en_ctc_compare_type comapare_value = compare(&max_key_val, &min_key_val, cur_index_part.field, cs); if (comapare_value == EQUAL && min_key->cmp_type == CMP_TYPE_CLOSE_INTERNAL && max_key->cmp_type == CMP_TYPE_CLOSE_INTERNAL) { return calc_hist_equal_density(cbo_stats, &max_key_val, col_id, cur_index_part.field, cs); @@ -621,8 +621,8 @@ void calc_accumulate_gcol_num(uint num_fields, Field** field, uint32_t *acc_gcol } } -double calc_density_one_table(uint16_t idx_id, tse_range_key *key, - tse_cbo_stats_table_t *cbo_stats, const TABLE &table) +double calc_density_one_table(uint16_t idx_id, ctc_range_key *key, + ctc_cbo_stats_table_t *cbo_stats, const TABLE &table) { if (cbo_stats->estimate_rows == 0) { // no stats or empty table return 0; @@ -630,7 +630,7 @@ double calc_density_one_table(uint16_t idx_id, tse_range_key *key, double density = 1.0; uint32_t my_col_id; uint32_t ct_col_id; - uint32_t acc_gcol_num[TSE_MAX_COLUMNS] = {0}; + uint32_t acc_gcol_num[CTC_MAX_COLUMNS] = {0}; calc_accumulate_gcol_num(table.s->fields, table.s->field, acc_gcol_num); uint32_t key_offset = 0;//列在索引中的偏移量 uint64_t col_map = max(key->min_key->col_map, key->max_key->col_map); @@ -666,7 +666,7 @@ double calc_density_one_table(uint16_t idx_id, tse_range_key *key, } /* - * This is a safe-guard logic since we don't handle tse call error in this method, + * This is a safe-guard logic since we don't handle ctc call error in this method, * we need this to make sure that our optimizer continue to work even when we * miscalculated the density, and it's still prefer index read */ @@ -676,14 +676,14 @@ double calc_density_one_table(uint16_t idx_id, tse_range_key *key, return density; } -void tse_index_stats_update(TABLE *table, tianchi_cbo_stats_t *cbo_stats) +void ctc_index_stats_update(TABLE *table, ctc_cbo_stats_t *cbo_stats) { rec_per_key_t rec_per_key = 0.0f; KEY sk; uint32_t *n_diff = cbo_stats->ndv_keys; uint32_t records; uint32_t table_part_num = cbo_stats->part_cnt == 0 ? 1 : cbo_stats->part_cnt; - uint32_t acc_gcol_num[TSE_MAX_COLUMNS] = {0}; + uint32_t acc_gcol_num[CTC_MAX_COLUMNS] = {0}; calc_accumulate_gcol_num(table->s->fields, table->s->field, acc_gcol_num); if (cbo_stats->records == 0) { return; @@ -697,8 +697,8 @@ void tse_index_stats_update(TABLE *table, tianchi_cbo_stats_t *cbo_stats) uint32 fld_idx = sk.key_part[j].field->field_index(); fld_idx = fld_idx - acc_gcol_num[fld_idx]; for (uint32 k = 0; k < table_part_num; k++) { - records = cbo_stats->tse_cbo_stats_table[k].estimate_rows; - uint32 has_null = cbo_stats->tse_cbo_stats_table[k].columns[fld_idx].num_null ? 1 : 0; + records = cbo_stats->ctc_cbo_stats_table[k].estimate_rows; + uint32 has_null = cbo_stats->ctc_cbo_stats_table[k].columns[fld_idx].num_null ? 1 : 0; uint32 n_diff_part = *(n_diff + i * MAX_KEY_COLUMNS + j); do { if (!n_diff_part) { @@ -712,7 +712,7 @@ void tse_index_stats_update(TABLE *table, tianchi_cbo_stats_t *cbo_stats) // if all n_diff(s) values 0, take records itself as rec_per_key if (all_n_diff_is_zero) { for (uint32 k = 0; k < table_part_num; k++) { - rec_per_key += static_cast(cbo_stats->tse_cbo_stats_table[k].estimate_rows); + rec_per_key += static_cast(cbo_stats->ctc_cbo_stats_table[k].estimate_rows); } } diff --git a/storage/tianchi/tse_cbo.h b/storage/ctc/ctc_cbo.h similarity index 73% rename from storage/tianchi/tse_cbo.h rename to storage/ctc/ctc_cbo.h index b10d691..4006690 100644 --- a/storage/tianchi/tse_cbo.h +++ b/storage/ctc/ctc_cbo.h @@ -15,50 +15,50 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#ifndef __TSE_CBO_H__ -#define __TSE_CBO_H__ +#ifndef __CTC_CBO_H__ +#define __CTC_CBO_H__ -#include "tse_srv.h" +#include "ctc_srv.h" #include "sql/table.h" #include "sql/dd/types/table.h" #include "srv_mq_msg.h" #define REAL_EPSINON 0.00001 -typedef enum en_tse_compare_type { +typedef enum en_ctc_compare_type { GREAT = 0, EQUAL, LESS, UNCOMPARABLE } compare_type; -typedef enum en_tse_query_type { +typedef enum en_ctc_query_type { QUERY_TYPE_NULL = 0, QUERY_TYPE_NOT_NULL, QUERY_TYPE_EQUAL } query_type; -typedef enum en_tse_cmp_type { +typedef enum en_ctc_cmp_type { CMP_TYPE_NULL = 0, CMP_TYPE_OPEN_INTERNAL, CMP_TYPE_CLOSE_INTERNAL -} tse_cmp_type_t; +} ctc_cmp_type_t; typedef struct { const uchar *key; uint len; - tse_cmp_type_t cmp_type; + ctc_cmp_type_t cmp_type; uint64_t col_map; -} tse_key; +} ctc_key; typedef struct { - tse_key *min_key; - tse_key *max_key; -} tse_range_key; + ctc_key *min_key; + ctc_key *max_key; +} ctc_range_key; typedef struct { - tse_cmp_type_t min_type; - tse_cmp_type_t max_type; + ctc_cmp_type_t min_type; + ctc_cmp_type_t max_type; cache_variant_t *max_key_val; cache_variant_t *min_key_val; } field_stats_val; @@ -70,8 +70,8 @@ typedef struct { uint32_t subpart_num; } part_info_t; -double calc_density_one_table(uint16_t idx_id, tse_range_key *key, - tse_cbo_stats_table_t *cbo_stats, const TABLE &table); +double calc_density_one_table(uint16_t idx_id, ctc_range_key *key, + ctc_cbo_stats_table_t *cbo_stats, const TABLE &table); void calc_accumulate_gcol_num(uint num_fields, Field** field, uint32_t *acc_gcol_num); -void tse_index_stats_update(TABLE *table, tianchi_cbo_stats_t *cbo_stats); +void ctc_index_stats_update(TABLE *table, ctc_cbo_stats_t *cbo_stats); #endif diff --git a/storage/tianchi/tse_ddl_rewriter_plugin.cc b/storage/ctc/ctc_ddl_rewriter_plugin.cc similarity index 75% rename from storage/tianchi/tse_ddl_rewriter_plugin.cc rename to storage/ctc/ctc_ddl_rewriter_plugin.cc index 6968284..64c5b3f 100644 --- a/storage/tianchi/tse_ddl_rewriter_plugin.cc +++ b/storage/ctc/ctc_ddl_rewriter_plugin.cc @@ -32,13 +32,13 @@ #include "sql/sql_class.h" #include "sql/sql_lex.h" #include "sql/sql_error.h" -#include "tse_log.h" -#include "tse_srv.h" -#include "tse_util.h" -#include "tse_proxy_util.h" -#include "tse_error.h" -#include "ha_tse.h" -#include "ha_tse_ddl.h" +#include "ctc_log.h" +#include "ctc_srv.h" +#include "ctc_util.h" +#include "ctc_proxy_util.h" +#include "ctc_error.h" +#include "ha_ctc.h" +#include "ha_ctc_ddl.h" #include "sql/sql_initialize.h" // opt_initialize_insecure #include "sql/sql_list.h" #include "sql/set_var.h" @@ -62,7 +62,7 @@ using namespace std; -static SYS_VAR *tse_rewriter_system_variables[] = { +static SYS_VAR *ctc_rewriter_system_variables[] = { nullptr }; @@ -98,7 +98,7 @@ int check_default_engine(set_var *setvar, bool &need_forward MY_ATTRIBUTE((unuse return -1; } - if (strcasecmp(setvar->value->item_name.ptr(), tse_hton_name) != 0) { + if (strcasecmp(setvar->value->item_name.ptr(), ctc_hton_name) != 0) { my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), "Once the CTC is loaded, it must be set as the default engine. To modify the setting, uninstall the CTC first."); return -1; @@ -112,7 +112,7 @@ int check_session_pool_volume(set_var *setvar, bool &need_forward MY_ATTRIBUTE(( } uint max_sessions; - if (tse_get_max_sessions_per_node(&max_sessions)) { + if (ctc_get_max_sessions_per_node(&max_sessions)) { my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), "Get max connections in Cantian failed"); return -1; } @@ -210,7 +210,7 @@ int unsupport_tx_isolation_level(set_var *setvar, bool &need_forward MY_ATTRIBUT return -1; } -int tse_check_opt_forward(set_var *setvar MY_ATTRIBUTE((unused)), bool &need_forward, +int ctc_check_opt_forward(set_var *setvar MY_ATTRIBUTE((unused)), bool &need_forward, string user_val_str MY_ATTRIBUTE((unused))) { need_forward = false; push_warning_printf(current_thd, Sql_condition::SL_WARNING, ER_DISALLOWED_OPERATION, @@ -222,20 +222,20 @@ static std::unordered_map set_variable_rules_map {"default_storage_engine", check_default_engine}, {"max_connections", check_session_pool_volume}, {"transaction_isolation", unsupport_tx_isolation_level}, - {"read_only", tse_check_opt_forward}, - {"super_read_only", tse_check_opt_forward}, - {"offline_mode", tse_check_opt_forward}, - {"gtid_next", tse_check_opt_forward} + {"read_only", ctc_check_opt_forward}, + {"super_read_only", ctc_check_opt_forward}, + {"offline_mode", ctc_check_opt_forward}, + {"gtid_next", ctc_check_opt_forward} }; -static int tse_get_user_var_string(MYSQL_THD thd, Item_func_get_user_var *itemFunc, string &user_val_str) { +static int ctc_get_user_var_string(MYSQL_THD thd, Item_func_get_user_var *itemFunc, string &user_val_str) { mysql_mutex_lock(&thd->LOCK_thd_data); String str; user_var_entry *var_entry; var_entry = find_or_nullptr(thd->user_vars, itemFunc->name.ptr()); if (var_entry == nullptr) { - tse_log_system("user var:%s have no value. no need to broadcast.", itemFunc->name.ptr()); + ctc_log_system("user var:%s have no value. no need to broadcast.", itemFunc->name.ptr()); my_printf_error(ER_DISALLOWED_OPERATION, "[CTC]:Please make sure %s has value in it.", MYF(0), itemFunc->name.ptr()); mysql_mutex_unlock(&thd->LOCK_thd_data); return -1; @@ -270,7 +270,7 @@ static int allow_sqlcmd(MYSQL_THD thd, string session_var_name) { return 0; } -static int tse_check_dcl(string &, MYSQL_THD thd, bool &need_forward) { +static int ctc_check_dcl(string &, MYSQL_THD thd, bool &need_forward) { if (check_readonly(thd, false) || (thd->lex->query_tables != nullptr && check_schema_readonly(thd, thd->lex->query_tables->table_name))) { @@ -284,23 +284,23 @@ static int tse_check_dcl(string &, MYSQL_THD thd, bool &need_forward) { } // reference for 'validate_password_require_current' function -int tse_verify_password4existed_user(MYSQL_THD thd, const LEX_USER *existed_user, bool &res) { +int ctc_verify_password4existed_user(MYSQL_THD thd, const LEX_USER *existed_user, bool &res) { ACL_USER *acl_user = nullptr; plugin_ref plugin = nullptr; int is_error = 0; Acl_cache_lock_guard acl_cache_lock(thd, Acl_cache_lock_mode::WRITE_MODE); if (!acl_cache_lock.lock()) { - tse_log_error("tse_verify_password failed, lock acl cache failed"); + ctc_log_error("ctc_verify_password failed, lock acl cache failed"); return -1; } acl_user = find_acl_user(existed_user->host.str, existed_user->user.str, true); if (!acl_user) { - tse_log_error("tse_verify_password failed, find acl user failed"); + ctc_log_error("ctc_verify_password failed, find acl user failed"); return -1; } plugin = my_plugin_lock_by_name(nullptr, acl_user->plugin, MYSQL_AUTHENTICATION_PLUGIN); if (!plugin) { - tse_log_error("tse_verify_password failed, lock plugin %s failed", acl_user->plugin.str ? acl_user->plugin.str : ""); + ctc_log_error("ctc_verify_password failed, lock plugin %s failed", acl_user->plugin.str ? acl_user->plugin.str : ""); return -1; } st_mysql_auth *auth = (st_mysql_auth *)plugin_decl(plugin)->info; @@ -318,18 +318,18 @@ int tse_verify_password4existed_user(MYSQL_THD thd, const LEX_USER *existed_user return 0; } -void tse_remove_replace_clause4sql(string &sql_str) { +void ctc_remove_replace_clause4sql(string &sql_str) { // match: replace "xxx" | replace 'xxx' regex replace_pattern(" \\s*replace \\s*(\".*\"|'.*')", std::regex_constants::icase); sql_str = regex_replace(sql_str, replace_pattern, " "); } /* - to adapt TSE broadcast: + to adapt CTC broadcast: 1. alter user current_user() -> alter user 'user'@'host' 2. alter user current user && replace 'old password', we need check the old password to remove the 'replace clause' */ -static int tse_rewrite_alter_user4update_passwd(MYSQL_THD thd, string &sql_str) { +static int ctc_rewrite_alter_user4update_passwd(MYSQL_THD thd, string &sql_str) { List_iterator user_list(thd->lex->users_list); LEX_USER *tmp_user; LEX_USER *user; @@ -352,7 +352,7 @@ static int tse_rewrite_alter_user4update_passwd(MYSQL_THD thd, string &sql_str) if (user->uses_replace_clause) { if (is_self) { bool is_password_matched = false; - if (tse_verify_password4existed_user(thd, user, is_password_matched)) { + if (ctc_verify_password4existed_user(thd, user, is_password_matched)) { return -1; } if (!is_password_matched) { @@ -365,11 +365,11 @@ static int tse_rewrite_alter_user4update_passwd(MYSQL_THD thd, string &sql_str) } } if (!existed_other_user_with_replace) { - tse_remove_replace_clause4sql(rw_query_sql); + ctc_remove_replace_clause4sql(rw_query_sql); } regex current_user_pattern(" \\s*current_user[(][)] ", regex_constants::icase); string current_user_name(sctx->user().str); - current_user_name = tse_deserilize_username_with_single_quotation(current_user_name); + current_user_name = ctc_deserilize_username_with_single_quotation(current_user_name); string user2host(""); user2host = " '" + current_user_name + "'@'" + string(sctx->priv_host().str) + "'"; rw_query_sql = regex_replace(rw_query_sql, current_user_pattern, user2host.c_str()); @@ -377,15 +377,15 @@ static int tse_rewrite_alter_user4update_passwd(MYSQL_THD thd, string &sql_str) return 0; } -static int tse_check_alter_user(string &sql_str, MYSQL_THD thd, bool &need_forward) { - if (tse_check_dcl(sql_str, thd, need_forward) != 0) { +static int ctc_check_alter_user(string &sql_str, MYSQL_THD thd, bool &need_forward) { + if (ctc_check_dcl(sql_str, thd, need_forward) != 0) { return -1; } - return tse_rewrite_alter_user4update_passwd(thd, sql_str); + return ctc_rewrite_alter_user4update_passwd(thd, sql_str); } -static int tse_rewrite_setpasswd(MYSQL_THD thd, string &sql_str) { +static int ctc_rewrite_setpasswd(MYSQL_THD thd, string &sql_str) { // match: set password = | set password to | set password for current_user()，but 'to' and '=' dont match for replacing regex add_or_rewrite_for_pattern("^set \\s*password\\s*((?=to|=)|for \\s*current_user[(][)])", regex_constants::icase); string rw_query_sql = sql_str; @@ -399,7 +399,7 @@ static int tse_rewrite_setpasswd(MYSQL_THD thd, string &sql_str) { set_var_password *set_passwd = static_cast(var); const LEX_USER *user_for_setpasswd = set_passwd->get_user(); string username(user_for_setpasswd->user.str); - username = tse_deserilize_username_with_single_quotation(username); + username = ctc_deserilize_username_with_single_quotation(username); user2host = "SET PASSWORD FOR '" + username + "'@'" + string(user_for_setpasswd->host.str) + "' "; rw_query_sql = regex_replace(rw_query_sql, add_or_rewrite_for_pattern, user2host.c_str()); @@ -408,11 +408,11 @@ static int tse_rewrite_setpasswd(MYSQL_THD thd, string &sql_str) { !strcmp(thd->m_main_security_ctx.priv_user().str, user_for_setpasswd->user.str)) { // check replacing old password is correct or not bool is_password_matched = false; - if (tse_verify_password4existed_user(thd, user_for_setpasswd, is_password_matched)) { + if (ctc_verify_password4existed_user(thd, user_for_setpasswd, is_password_matched)) { return -1; } if (is_password_matched) { - tse_remove_replace_clause4sql(rw_query_sql); + ctc_remove_replace_clause4sql(rw_query_sql); } else { my_error(ER_INCORRECT_CURRENT_PASSWORD, MYF(0)); return -1; @@ -423,21 +423,21 @@ static int tse_rewrite_setpasswd(MYSQL_THD thd, string &sql_str) { return 0; } -static int tse_check_set_password(SENSI_INFO string &sql_str, MYSQL_THD thd, bool &need_forward) { - if (tse_check_dcl(sql_str, thd, need_forward) != 0) { +static int ctc_check_set_password(SENSI_INFO string &sql_str, MYSQL_THD thd, bool &need_forward) { + if (ctc_check_dcl(sql_str, thd, need_forward) != 0) { return -1; } - return tse_rewrite_setpasswd(thd, sql_str); + return ctc_rewrite_setpasswd(thd, sql_str); } -static int tse_check_flush(string &, MYSQL_THD thd, bool &need_forward) { +static int ctc_check_flush(string &, MYSQL_THD thd, bool &need_forward) { need_forward = thd->lex->type & (REFRESH_FOR_EXPORT | REFRESH_READ_LOCK | REFRESH_GRANT); return 0; } static unordered_set set_variable_not_broadcast{"ctc_ddl_local_enabled", "ctc_ddl_enabled"}; -static bool tse_check_ddl_local_enable(string sql_str, bool &need_forwar) { +static bool ctc_check_ddl_local_enable(string sql_str, bool &need_forwar) { transform(sql_str.begin(), sql_str.end(), sql_str.begin(), ::tolower); for (auto it : set_variable_not_broadcast) { @@ -450,35 +450,35 @@ static bool tse_check_ddl_local_enable(string sql_str, bool &need_forwar) { return false; } -static uint32_t tse_set_var_option(bool is_null_value, bool is_set_default_value, +static uint32_t ctc_set_var_option(bool is_null_value, bool is_set_default_value, set_var *setvar) { uint32_t options = 0; if (is_null_value) { - options |= TSE_SET_VARIABLE_TO_NULL; + options |= CTC_SET_VARIABLE_TO_NULL; } if (is_set_default_value) { - options |= TSE_SET_VARIABLE_TO_DEFAULT; + options |= CTC_SET_VARIABLE_TO_DEFAULT; } if (setvar->type == OPT_PERSIST_ONLY) { - options |= TSE_SET_VARIABLE_PERSIST_ONLY; + options |= CTC_SET_VARIABLE_PERSIST_ONLY; } if (setvar->type == OPT_PERSIST) { - options |= TSE_SET_VARIABLE_PERSIST; + options |= CTC_SET_VARIABLE_PERSIST; } return options; } -static int tse_set_var_meta(MYSQL_THD thd, uint32_t options, const char* base_name, +static int ctc_set_var_meta(MYSQL_THD thd, uint32_t options, const char* base_name, string var_name, string var_value, bool var_real_type) { - tianchi_handler_t tch; + ctc_handler_t tch; tch.inst_id = ctc_instance_id; - handlerton* hton = get_tse_hton(); + handlerton* hton = get_ctc_hton(); - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); - tse_ddl_broadcast_request broadcast_req {{0}, {0}, {0}, {0}, 0, 0, 0, 0, {0}}; - broadcast_req.options |= TSE_NOT_NEED_CANTIAN_EXECUTE; - broadcast_req.options |= (thd->lex->contains_plaintext_password ? TSE_CURRENT_SQL_CONTAIN_PLAINTEXT_PASSWORD : 0); + ctc_ddl_broadcast_request broadcast_req {{0}, {0}, {0}, {0}, 0, 0, 0, 0, {0}}; + broadcast_req.options |= CTC_NOT_NEED_CANTIAN_EXECUTE; + broadcast_req.options |= (thd->lex->contains_plaintext_password ? CTC_CURRENT_SQL_CONTAIN_PLAINTEXT_PASSWORD : 0); string sql = string(thd->query().str).substr(0, thd->query().length); if (var_real_type) { // actual value of the variable type int @@ -491,12 +491,12 @@ static int tse_set_var_meta(MYSQL_THD thd, uint32_t options, const char* base_na strncpy(broadcast_req.db_name, base_name, SMALL_RECORD_SIZE - 1); } broadcast_req.options |= options; - int ret = tse_execute_mysql_ddl_sql(&tch, &broadcast_req, true); + int ret = ctc_execute_mysql_ddl_sql(&tch, &broadcast_req, true); update_sess_ctx_by_tch(tch, hton, thd); return ret; } -static int tse_get_variables_value_string(MYSQL_THD thd, string &sql_str, set_var* setvar, string& val_str, +static int ctc_get_variables_value_string(MYSQL_THD thd, string &sql_str, set_var* setvar, string& val_str, bool& is_null_value, bool &need_forward) { Item_func_get_user_var *itemFunc = dynamic_cast(setvar->value); Item_func_get_system_var *itemFuncSys = dynamic_cast(setvar->value); @@ -509,8 +509,8 @@ static int tse_get_variables_value_string(MYSQL_THD thd, string &sql_str, set_va if (itemFunc) { // 从临时变量取值 - tse_log_system("[TSE_DDL_REWRITE]:get user var value. %s", sql_str.c_str()); - int ret = tse_get_user_var_string(thd, itemFunc, val_str); + ctc_log_system("[CTC_DDL_REWRITE]:get user var value. %s", sql_str.c_str()); + int ret = ctc_get_user_var_string(thd, itemFunc, val_str); if (ret != 0) { need_forward = false; return -1; @@ -519,7 +519,7 @@ static int tse_get_variables_value_string(MYSQL_THD thd, string &sql_str, set_va // 从系统变量取值 String* new_str; String str; - tse_log_system("[TSE_DDL_REWRITE]:get system var value. %s", sql_str.c_str()); + ctc_log_system("[CTC_DDL_REWRITE]:get system var value. %s", sql_str.c_str()); #ifdef FEATURE_X_FOR_MYSQL_26 if (itemFuncSys->bind(thd)) { need_forward = false; @@ -551,7 +551,7 @@ static int tse_get_variables_value_string(MYSQL_THD thd, string &sql_str, set_va return 0; } -static int tse_check_set_opt_rule(set_var *setvar, string& name_str, string& user_val_str, bool& need_forward) { +static int ctc_check_set_opt_rule(set_var *setvar, string& name_str, string& user_val_str, bool& need_forward) { int ret = 0; transform(name_str.begin(), name_str.end(), name_str.begin(), ::tolower); auto it = set_variable_rules_map.find(name_str); @@ -566,8 +566,8 @@ static int tse_check_set_opt_rule(set_var *setvar, string& name_str, string& use } /* 参考set_var.cc: sql_set_variables */ -static int tse_check_set_opt(string &sql_str, MYSQL_THD thd, bool &need_forward) { - if (tse_check_ddl_local_enable(sql_str, need_forward)) { +static int ctc_check_set_opt(string &sql_str, MYSQL_THD thd, bool &need_forward) { + if (ctc_check_ddl_local_enable(sql_str, need_forward)) { return 0; } @@ -612,9 +612,9 @@ static int tse_check_set_opt(string &sql_str, MYSQL_THD thd, bool &need_forward) is_set_default_value = true; val_str = ""; } else { - ret = tse_get_variables_value_string(thd, sql_str, setvar, val_str, is_null_value, need_forward); + ret = ctc_get_variables_value_string(thd, sql_str, setvar, val_str, is_null_value, need_forward); } - ret |= tse_check_set_opt_rule(setvar, name_str, val_str, need_forward); + ret |= ctc_check_set_opt_rule(setvar, name_str, val_str, need_forward); } } else { // There's no need to broadcast non-set_var SET_OPTION cmds. @@ -632,11 +632,11 @@ static int tse_check_set_opt(string &sql_str, MYSQL_THD thd, bool &need_forward) if (setvar->value && setvar->value->result_type() == INT_RESULT) { var_real_type = true; } - uint32_t options = tse_set_var_option(is_null_value, is_set_default_value, setvar); + uint32_t options = ctc_set_var_option(is_null_value, is_set_default_value, setvar); #ifdef FEATURE_X_FOR_MYSQL_26 - ret = tse_set_var_meta(thd, options, setvar->base.str, name_str, val_str, var_real_type); + ret = ctc_set_var_meta(thd, options, setvar->base.str, name_str, val_str, var_real_type); #elif defined(FEATURE_X_FOR_MYSQL_32) - ret = tse_set_var_meta(thd, options, setvar->m_var_tracker.get_var_name() + ret = ctc_set_var_meta(thd, options, setvar->m_var_tracker.get_var_name() name_str, val_str, var_real_type); #endif } else { @@ -645,7 +645,7 @@ static int tse_check_set_opt(string &sql_str, MYSQL_THD thd, bool &need_forward) } } - tse_log_debug("set option %s, need_forward: %d", sql_str.c_str(), need_forward); + ctc_log_debug("set option %s, need_forward: %d", sql_str.c_str(), need_forward); } if (IS_METADATA_NORMALIZATION() && !contain_subselect) { need_forward = false; @@ -662,22 +662,22 @@ static int is_system_db(const char *ddl_db) { return 0; } -static int tse_check_ddl_engine(string &, MYSQL_THD thd, bool &need_forward) { +static int ctc_check_ddl_engine(string &, MYSQL_THD thd, bool &need_forward) { need_forward = false; // broadcast by storage engine - LEX_CSTRING tse_name; - tse_name.str = tse_hton_name; - tse_name.length = strlen(tse_hton_name); - handlerton *tse_handlerton = nullptr; - // 获取TSE引擎handlerton指针，如果thd->lex->create_info->db_type和TSE引擎指针不相等，那么必然不是TSE引擎 - plugin_ref plugin = ha_resolve_by_name(thd, &tse_name, false); + LEX_CSTRING ctc_name; + ctc_name.str = ctc_hton_name; + ctc_name.length = strlen(ctc_hton_name); + handlerton *ctc_handlerton = nullptr; + // 获取CTC引擎handlerton指针，如果thd->lex->create_info->db_type和CTC引擎指针不相等，那么必然不是CTC引擎 + plugin_ref plugin = ha_resolve_by_name(thd, &ctc_name, false); if (plugin) { - tse_handlerton = plugin_data(plugin); + ctc_handlerton = plugin_data(plugin); } // 检查ddl语句是否显示指定非CTC if (thd->lex->create_info != nullptr && thd->lex->create_info->db_type != nullptr && - thd->lex->create_info->db_type != tse_handlerton && + thd->lex->create_info->db_type != ctc_handlerton && !(thd->lex->create_info->options & HA_LEX_CREATE_TMP_TABLE)) { my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), "Once the CTC is loaded, it must be used as the default engine. To specify other engine for table, uninstall the CTC first."); @@ -702,7 +702,7 @@ static int tse_check_ddl_engine(string &, MYSQL_THD thd, bool &need_forward) { const Sql_cmd_tablespace *sct = dynamic_cast(thd->lex->m_sql_cmd); if (sct != nullptr && sct->get_options().engine_name.str != nullptr && - strcmp(sct->get_options().engine_name.str, tse_name.str) != 0) { + strcmp(sct->get_options().engine_name.str, ctc_name.str) != 0) { my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), "Once the CTC is loaded, it must be used as the default engine. To specify other engine for table, uninstall the CTC first."); return -1; @@ -722,17 +722,17 @@ static int tse_check_ddl_engine(string &, MYSQL_THD thd, bool &need_forward) { return 0; } -static int tse_check_ddl(string &, MYSQL_THD, bool &need_forward) { +static int ctc_check_ddl(string &, MYSQL_THD, bool &need_forward) { need_forward = false; // broadcast by storage engine return 0; } -static int tse_check_unspport_ddl(string &, MYSQL_THD, bool &) { +static int ctc_check_unspport_ddl(string &, MYSQL_THD, bool &) { my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), "Cantian doesn't support current operation"); return -1; } -static int tse_read_only_ddl(string &, MYSQL_THD thd, bool &need_forward) { +static int ctc_read_only_ddl(string &, MYSQL_THD thd, bool &need_forward) { if (check_readonly(thd, true) || (thd->lex->query_tables != nullptr && check_schema_readonly(thd, thd->lex->query_tables->table_name))) { @@ -741,13 +741,13 @@ static int tse_read_only_ddl(string &, MYSQL_THD thd, bool &need_forward) { return 0; } -static int tse_lock_tables_ddl(string &, MYSQL_THD thd, bool &) { +static int ctc_lock_tables_ddl(string &, MYSQL_THD thd, bool &) { int ret = 0; vector ticket_list; - int pre_lock_ret = tse_lock_table_pre(thd, ticket_list, MDL_SHARED_NO_READ_WRITE); + int pre_lock_ret = ctc_lock_table_pre(thd, ticket_list, MDL_SHARED_NO_READ_WRITE); if (pre_lock_ret != 0) { - tse_lock_table_post(thd, ticket_list); - my_printf_error(ER_LOCK_WAIT_TIMEOUT, "[TSE_DDL_REWRITE]: LOCK TABLE FAILED", MYF(0)); + ctc_lock_table_post(thd, ticket_list); + my_printf_error(ER_LOCK_WAIT_TIMEOUT, "[CTC_DDL_REWRITE]: LOCK TABLE FAILED", MYF(0)); return ER_LOCK_WAIT_TIMEOUT; } #ifdef FEATURE_X_FOR_MYSQL_32 @@ -757,11 +757,11 @@ static int tse_lock_tables_ddl(string &, MYSQL_THD thd, bool &) { TABLE_LIST *tables = thd->lex->query_tables; for (TABLE_LIST *table = tables; table != NULL; table = table->next_global) { #endif - tianchi_handler_t tch; + ctc_handler_t tch; tch.inst_id = ctc_instance_id; - handlerton* hton = get_tse_hton(); + handlerton* hton = get_ctc_hton(); - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); int32_t mdl_type = 0; auto desc_type = table->lock_descriptor().type; if (desc_type >= TL_READ_DEFAULT && desc_type <= TL_READ_NO_INSERT) { @@ -771,18 +771,18 @@ static int tse_lock_tables_ddl(string &, MYSQL_THD thd, bool &) { } else { continue; } - tse_lock_table_info lock_info = {{0}, {0}, {0}, {0}, SQLCOM_LOCK_TABLES, mdl_type}; + ctc_lock_table_info lock_info = {{0}, {0}, {0}, {0}, SQLCOM_LOCK_TABLES, mdl_type}; FILL_USER_INFO_WITH_THD(lock_info, thd); strncpy(lock_info.db_name, table->db, SMALL_RECORD_SIZE - 1); strncpy(lock_info.table_name, table->table_name, SMALL_RECORD_SIZE - 1); int err_code = 0; - ret = tse_lock_table(&tch, lock_info.db_name, &lock_info, &err_code); + ret = ctc_lock_table(&tch, lock_info.db_name, &lock_info, &err_code); if (ret != 0) { break; } } - tse_lock_table_post(thd, ticket_list); + ctc_lock_table_post(thd, ticket_list); if (ret != 0) { #ifdef FEATURE_X_FOR_MYSQL_32 @@ -790,38 +790,38 @@ static int tse_lock_tables_ddl(string &, MYSQL_THD thd, bool &) { #elif defined(FEATURE_X_FOR_MYSQL_26) for (TABLE_LIST *table = tables; table != NULL; table = table->next_global) { #endif - tianchi_handler_t tch; + ctc_handler_t tch; tch.inst_id = ctc_instance_id; - handlerton* hton = get_tse_hton(); + handlerton* hton = get_ctc_hton(); - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); - tse_lock_table_info lock_info = {{0}, {0}, {0}, {0}, SQLCOM_LOCK_TABLES, (int32_t)TL_UNLOCK}; + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); + ctc_lock_table_info lock_info = {{0}, {0}, {0}, {0}, SQLCOM_LOCK_TABLES, (int32_t)TL_UNLOCK}; FILL_USER_INFO_WITH_THD(lock_info, thd); strncpy(lock_info.db_name, table->db, SMALL_RECORD_SIZE - 1); strncpy(lock_info.table_name, table->table_name, SMALL_RECORD_SIZE - 1); - ret = tse_unlock_table(&tch, ctc_instance_id, &lock_info); + ret = ctc_unlock_table(&tch, ctc_instance_id, &lock_info); if (ret != 0) { - tse_log_error("[TSE_DDL_REWRITE]:unlock table failed, table:%s.%s", lock_info.db_name, lock_info.table_name); + ctc_log_error("[CTC_DDL_REWRITE]:unlock table failed, table:%s.%s", lock_info.db_name, lock_info.table_name); } } } return ret; } -static int tse_unlock_tables_ddl(string &, MYSQL_THD thd, bool &) { +static int ctc_unlock_tables_ddl(string &, MYSQL_THD thd, bool &) { int ret = 0; - tianchi_handler_t tch; + ctc_handler_t tch; tch.inst_id = ctc_instance_id; - handlerton* hton = get_tse_hton(); + handlerton* hton = get_ctc_hton(); - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); - tse_lock_table_info lock_info = {{0}, {0}, {0}, {0}, SQLCOM_UNLOCK_TABLES, 0}; + ctc_lock_table_info lock_info = {{0}, {0}, {0}, {0}, SQLCOM_UNLOCK_TABLES, 0}; FILL_USER_INFO_WITH_THD(lock_info, thd); - ret = tse_unlock_table(&tch, ctc_instance_id, &lock_info); + ret = ctc_unlock_table(&tch, ctc_instance_id, &lock_info); return ret; } @@ -834,47 +834,47 @@ typedef struct ddl_broadcast_cmd_s static unordered_map ddl_cmds = { - // DCL，broadcast on !tse_dcl_disabled - {SQLCOM_GRANT, {true, tse_check_dcl}}, - {SQLCOM_REVOKE, {false, tse_check_dcl}}, - {SQLCOM_CREATE_USER, {false, tse_check_dcl}}, - {SQLCOM_DROP_USER, {false, tse_check_dcl}}, - {SQLCOM_RENAME_USER, {false, tse_check_dcl}}, - {SQLCOM_REVOKE_ALL, {false, tse_check_dcl}}, - {SQLCOM_ALTER_USER, {false, tse_check_alter_user}}, - {SQLCOM_ALTER_USER_DEFAULT_ROLE, {false, tse_check_dcl}}, - {SQLCOM_CREATE_ROLE, {false, tse_check_dcl}}, - {SQLCOM_DROP_ROLE, {false, tse_check_dcl}}, - {SQLCOM_SET_ROLE, {false, tse_check_dcl}}, - {SQLCOM_GRANT_ROLE, {false, tse_check_dcl}}, - {SQLCOM_REVOKE_ROLE, {false, tse_check_dcl}}, - {SQLCOM_SET_PASSWORD, {false, tse_check_set_password}}, + // DCL，broadcast on !ctc_dcl_disabled + {SQLCOM_GRANT, {true, ctc_check_dcl}}, + {SQLCOM_REVOKE, {false, ctc_check_dcl}}, + {SQLCOM_CREATE_USER, {false, ctc_check_dcl}}, + {SQLCOM_DROP_USER, {false, ctc_check_dcl}}, + {SQLCOM_RENAME_USER, {false, ctc_check_dcl}}, + {SQLCOM_REVOKE_ALL, {false, ctc_check_dcl}}, + {SQLCOM_ALTER_USER, {false, ctc_check_alter_user}}, + {SQLCOM_ALTER_USER_DEFAULT_ROLE, {false, ctc_check_dcl}}, + {SQLCOM_CREATE_ROLE, {false, ctc_check_dcl}}, + {SQLCOM_DROP_ROLE, {false, ctc_check_dcl}}, + {SQLCOM_SET_ROLE, {false, ctc_check_dcl}}, + {SQLCOM_GRANT_ROLE, {false, ctc_check_dcl}}, + {SQLCOM_REVOKE_ROLE, {false, ctc_check_dcl}}, + {SQLCOM_SET_PASSWORD, {false, ctc_check_set_password}}, // prepare statement - {SQLCOM_PREPARE, {false, tse_check_ddl}}, - {SQLCOM_EXECUTE, {false, tse_check_ddl}}, + {SQLCOM_PREPARE, {false, ctc_check_ddl}}, + {SQLCOM_EXECUTE, {false, ctc_check_ddl}}, // 存储过程，broadcast - {SQLCOM_CREATE_PROCEDURE, {true, tse_read_only_ddl}}, - {SQLCOM_DROP_PROCEDURE, {true, tse_read_only_ddl}}, - {SQLCOM_ALTER_PROCEDURE, {true, tse_read_only_ddl}}, - {SQLCOM_ALTER_FUNCTION, {true, tse_read_only_ddl}}, - {SQLCOM_CREATE_SPFUNCTION, {true, tse_read_only_ddl}}, - {SQLCOM_DROP_FUNCTION, {true, tse_read_only_ddl}}, + {SQLCOM_CREATE_PROCEDURE, {true, ctc_read_only_ddl}}, + {SQLCOM_DROP_PROCEDURE, {true, ctc_read_only_ddl}}, + {SQLCOM_ALTER_PROCEDURE, {true, ctc_read_only_ddl}}, + {SQLCOM_ALTER_FUNCTION, {true, ctc_read_only_ddl}}, + {SQLCOM_CREATE_SPFUNCTION, {true, ctc_read_only_ddl}}, + {SQLCOM_DROP_FUNCTION, {true, ctc_read_only_ddl}}, // 触发器 & 视图，broadcast - {SQLCOM_CREATE_VIEW, {true, tse_read_only_ddl}}, - {SQLCOM_DROP_VIEW, {true, tse_read_only_ddl}}, - {SQLCOM_CREATE_TRIGGER, {true, tse_read_only_ddl}}, - {SQLCOM_DROP_TRIGGER, {true, tse_read_only_ddl}}, + {SQLCOM_CREATE_VIEW, {true, ctc_read_only_ddl}}, + {SQLCOM_DROP_VIEW, {true, ctc_read_only_ddl}}, + {SQLCOM_CREATE_TRIGGER, {true, ctc_read_only_ddl}}, + {SQLCOM_DROP_TRIGGER, {true, ctc_read_only_ddl}}, // set Variable, check var map // SET_OPTION query with subselect item needs specific db - {SQLCOM_SET_OPTION, {true, tse_check_set_opt}}, + {SQLCOM_SET_OPTION, {true, ctc_check_set_opt}}, // Locking, broadcast - {SQLCOM_LOCK_TABLES, {true, tse_lock_tables_ddl}}, - {SQLCOM_UNLOCK_TABLES, {true, tse_unlock_tables_ddl}}, + {SQLCOM_LOCK_TABLES, {true, ctc_lock_tables_ddl}}, + {SQLCOM_UNLOCK_TABLES, {true, ctc_unlock_tables_ddl}}, {SQLCOM_LOCK_INSTANCE, {false, NULL}}, {SQLCOM_UNLOCK_INSTANCE, {false, NULL}}, @@ -882,69 +882,69 @@ static unordered_map {SQLCOM_ANALYZE, {true, NULL}}, // Flush, only broadcast for REFRESH_READ_LOCK - {SQLCOM_FLUSH, {false, tse_check_flush}}, + {SQLCOM_FLUSH, {false, ctc_check_flush}}, // table & tablespace operations, do not broadcast in rewriter - {SQLCOM_CREATE_TABLE, {false, tse_check_ddl_engine}}, - {SQLCOM_ALTER_TABLE, {false, tse_check_ddl_engine}}, - {SQLCOM_CREATE_INDEX, {false, tse_check_ddl}}, - {SQLCOM_DROP_INDEX, {false, tse_check_ddl}}, - {SQLCOM_REPAIR, {false, tse_check_ddl}}, - {SQLCOM_OPTIMIZE, {false, tse_check_ddl}}, - {SQLCOM_CHECK, {false, tse_check_ddl}}, - {SQLCOM_RENAME_TABLE, {false, tse_check_ddl}}, - {SQLCOM_ALTER_TABLESPACE, {false, tse_check_ddl_engine}}, + {SQLCOM_CREATE_TABLE, {false, ctc_check_ddl_engine}}, + {SQLCOM_ALTER_TABLE, {false, ctc_check_ddl_engine}}, + {SQLCOM_CREATE_INDEX, {false, ctc_check_ddl}}, + {SQLCOM_DROP_INDEX, {false, ctc_check_ddl}}, + {SQLCOM_REPAIR, {false, ctc_check_ddl}}, + {SQLCOM_OPTIMIZE, {false, ctc_check_ddl}}, + {SQLCOM_CHECK, {false, ctc_check_ddl}}, + {SQLCOM_RENAME_TABLE, {false, ctc_check_ddl}}, + {SQLCOM_ALTER_TABLESPACE, {false, ctc_check_ddl_engine}}, // drop table operations, do not broadcast in rewriter - {SQLCOM_DROP_TABLE, {false, tse_check_ddl_engine}}, + {SQLCOM_DROP_TABLE, {false, ctc_check_ddl_engine}}, // database operations, do not broadcast in rewriter - {SQLCOM_CHANGE_DB, {false, tse_check_ddl}}, - {SQLCOM_CREATE_DB, {false, tse_check_ddl}}, - {SQLCOM_DROP_DB, {false, tse_check_ddl_engine}}, + {SQLCOM_CHANGE_DB, {false, ctc_check_ddl}}, + {SQLCOM_CREATE_DB, {false, ctc_check_ddl}}, + {SQLCOM_DROP_DB, {false, ctc_check_ddl_engine}}, // alter database broadcast for recording logical logs {SQLCOM_ALTER_DB, {false, NULL}}, // 不支持创建,修改，删除EVENT - {SQLCOM_CREATE_EVENT, {false, tse_check_unspport_ddl}}, - {SQLCOM_ALTER_EVENT, {false, tse_check_unspport_ddl}}, - {SQLCOM_DROP_EVENT, {false, tse_check_unspport_ddl}}, + {SQLCOM_CREATE_EVENT, {false, ctc_check_unspport_ddl}}, + {SQLCOM_ALTER_EVENT, {false, ctc_check_unspport_ddl}}, + {SQLCOM_DROP_EVENT, {false, ctc_check_unspport_ddl}}, // Replication operations - unsupported - {SQLCOM_CREATE_SERVER, {false, tse_check_unspport_ddl}}, - {SQLCOM_DROP_SERVER, {false, tse_check_unspport_ddl}}, - {SQLCOM_ALTER_SERVER, {false, tse_check_unspport_ddl}}, + {SQLCOM_CREATE_SERVER, {false, ctc_check_unspport_ddl}}, + {SQLCOM_DROP_SERVER, {false, ctc_check_unspport_ddl}}, + {SQLCOM_ALTER_SERVER, {false, ctc_check_unspport_ddl}}, // 不支持alter instance - {SQLCOM_ALTER_INSTANCE, {false, tse_check_unspport_ddl}}, + {SQLCOM_ALTER_INSTANCE, {false, ctc_check_unspport_ddl}}, // 不支持import table - {SQLCOM_IMPORT, {false, tse_check_unspport_ddl}}, + {SQLCOM_IMPORT, {false, ctc_check_unspport_ddl}}, // 不支持创建，删除SRS - {SQLCOM_CREATE_SRS, {false, tse_check_unspport_ddl}}, - {SQLCOM_DROP_SRS, {false, tse_check_unspport_ddl}}, + {SQLCOM_CREATE_SRS, {false, ctc_check_unspport_ddl}}, + {SQLCOM_DROP_SRS, {false, ctc_check_unspport_ddl}}, // 不支持创建，修改，删除，设置资源组 - {SQLCOM_CREATE_RESOURCE_GROUP, {false, tse_check_unspport_ddl}}, - {SQLCOM_ALTER_RESOURCE_GROUP, {false, tse_check_unspport_ddl}}, - {SQLCOM_DROP_RESOURCE_GROUP, {false, tse_check_unspport_ddl}}, - {SQLCOM_SET_RESOURCE_GROUP, {false, tse_check_unspport_ddl}}, + {SQLCOM_CREATE_RESOURCE_GROUP, {false, ctc_check_unspport_ddl}}, + {SQLCOM_ALTER_RESOURCE_GROUP, {false, ctc_check_unspport_ddl}}, + {SQLCOM_DROP_RESOURCE_GROUP, {false, ctc_check_unspport_ddl}}, + {SQLCOM_SET_RESOURCE_GROUP, {false, ctc_check_unspport_ddl}}, // XA operations - unsupported - {SQLCOM_XA_START, {false, tse_check_unspport_ddl}}, - {SQLCOM_XA_END, {false, tse_check_unspport_ddl}}, - {SQLCOM_XA_PREPARE, {false, tse_check_unspport_ddl}}, - {SQLCOM_XA_COMMIT, {false, tse_check_unspport_ddl}}, - {SQLCOM_XA_ROLLBACK, {false, tse_check_unspport_ddl}}, - {SQLCOM_XA_RECOVER, {false, tse_check_unspport_ddl}}, + {SQLCOM_XA_START, {false, ctc_check_unspport_ddl}}, + {SQLCOM_XA_END, {false, ctc_check_unspport_ddl}}, + {SQLCOM_XA_PREPARE, {false, ctc_check_unspport_ddl}}, + {SQLCOM_XA_COMMIT, {false, ctc_check_unspport_ddl}}, + {SQLCOM_XA_ROLLBACK, {false, ctc_check_unspport_ddl}}, + {SQLCOM_XA_RECOVER, {false, ctc_check_unspport_ddl}}, // handler operations - supported - {SQLCOM_HA_OPEN, {false, tse_check_ddl}}, - {SQLCOM_HA_CLOSE, {false, tse_check_ddl}}, - {SQLCOM_HA_READ, {false, tse_check_ddl}}, + {SQLCOM_HA_OPEN, {false, ctc_check_ddl}}, + {SQLCOM_HA_CLOSE, {false, ctc_check_ddl}}, + {SQLCOM_HA_READ, {false, ctc_check_ddl}}, }; @@ -971,40 +971,40 @@ bool is_dcl_sql_cmd(enum_sql_command sql_cmd) { } #ifdef HAVE_PSI_INTERFACE -static PSI_memory_key key_memory_tse_ddl_rewriter; +static PSI_memory_key key_memory_ctc_ddl_rewriter; static PSI_memory_info all_rewrite_memory[] = { - {&key_memory_tse_ddl_rewriter, "ctc_ddl_rewriter", 0, 0, PSI_DOCUMENT_ME}}; + {&key_memory_ctc_ddl_rewriter, "ctc_ddl_rewriter", 0, 0, PSI_DOCUMENT_ME}}; static int plugin_init(MYSQL_PLUGIN) { const char *category = "rewriter"; int count = static_cast(array_elements(all_rewrite_memory)); mysql_memory_register(category, all_rewrite_memory, count); - tse_log_system("plugin_init called"); + ctc_log_system("plugin_init called"); return 0; /* success */ } #else #define plugin_init nullptr -#define key_memory_tse_ddl_rewriter PSI_NOT_INSTRUMENTED +#define key_memory_ctc_ddl_rewriter PSI_NOT_INSTRUMENTED #endif /* HAVE_PSI_INTERFACE */ -static void tse_ddl_rewrite_handle_error(MYSQL_THD thd, int ret, tse_ddl_broadcast_request &broadcast_req, uint8_t sql_cmd) { - if (ret == TSE_DDL_VERSION_NOT_MATCH) { +static void ctc_ddl_rewrite_handle_error(MYSQL_THD thd, int ret, ctc_ddl_broadcast_request &broadcast_req, uint8_t sql_cmd) { + if (ret == CTC_DDL_VERSION_NOT_MATCH) { broadcast_req.err_code = ER_DISALLOWED_OPERATION; my_printf_error(ER_DISALLOWED_OPERATION, "Version not match. Please make sure cluster on the same version.", MYF(0)); - tse_log_system("[TSE_DDL_REWRITE]: Version not match, sql=%s", sql_without_plaintext_password(&broadcast_req).c_str()); + ctc_log_system("[CTC_DDL_REWRITE]: Version not match, sql=%s", sql_without_plaintext_password(&broadcast_req).c_str()); return; } my_printf_error(broadcast_req.err_code, "Got error(err_code:%d, err_msg:%s) on remote mysql.", MYF(0), broadcast_req.err_code, broadcast_req.err_msg); - tse_log_error("[TSE_DDL_REWRITE]:Got error on remote mysql, query:%s, user_name:%s, err_code:%d, err_msg:%s", + ctc_log_error("[CTC_DDL_REWRITE]:Got error on remote mysql, query:%s, user_name:%s, err_code:%d, err_msg:%s", sql_without_plaintext_password(&broadcast_req).c_str(), broadcast_req.user_name, broadcast_req.err_code, broadcast_req.err_msg); // unlock when lock instance failed if (sql_cmd == SQLCOM_LOCK_INSTANCE) { - tse_check_unlock_instance(thd); + ctc_check_unlock_instance(thd); } return; @@ -1012,13 +1012,13 @@ static void tse_ddl_rewrite_handle_error(MYSQL_THD thd, int ret, tse_ddl_broadca int ddl_broadcast_and_wait(MYSQL_THD thd, string &query_str, uint8_t sql_cmd, ddl_broadcast_cmd &broadcast_cmd) { - tianchi_handler_t tch; + ctc_handler_t tch; memset(&tch, 0, sizeof(tch)); tch.inst_id = ctc_instance_id; - handlerton *hton = get_tse_hton(); + handlerton *hton = get_ctc_hton(); update_member_tch(tch, hton, thd); - tse_ddl_broadcast_request broadcast_req {{0}, {0}, {0}, {0}, 0, 0, 0, 0, {0}}; + ctc_ddl_broadcast_request broadcast_req {{0}, {0}, {0}, {0}, 0, 0, 0, 0, {0}}; if (thd->db().str != NULL && strlen(thd->db().str) > 0 && broadcast_cmd.need_select_db) { @@ -1027,42 +1027,42 @@ int ddl_broadcast_and_wait(MYSQL_THD thd, string &query_str, if (sql_cmd == SQLCOM_SET_OPTION) { // Use it to mark SET_OPTION query with subselect item - broadcast_req.options |= TSE_SET_VARIABLE_WITH_SUBSELECT; + broadcast_req.options |= CTC_SET_VARIABLE_WITH_SUBSELECT; } - broadcast_req.options |= TSE_NOT_NEED_CANTIAN_EXECUTE; - broadcast_req.options |= (thd->lex->contains_plaintext_password ? TSE_CURRENT_SQL_CONTAIN_PLAINTEXT_PASSWORD : 0); + broadcast_req.options |= CTC_NOT_NEED_CANTIAN_EXECUTE; + broadcast_req.options |= (thd->lex->contains_plaintext_password ? CTC_CURRENT_SQL_CONTAIN_PLAINTEXT_PASSWORD : 0); FILL_BROADCAST_BASE_REQ(broadcast_req, query_str.c_str(), thd->m_main_security_ctx.priv_user().str, thd->m_main_security_ctx.priv_host().str, ctc_instance_id, sql_cmd); vector ticket_list; if (sql_cmd == SQLCOM_LOCK_TABLES) { - int pre_lock_ret = tse_lock_table_pre(thd, ticket_list, MDL_SHARED_NO_READ_WRITE); + int pre_lock_ret = ctc_lock_table_pre(thd, ticket_list, MDL_SHARED_NO_READ_WRITE); if (pre_lock_ret != 0) { - tse_lock_table_post(thd, ticket_list); - my_printf_error(ER_LOCK_WAIT_TIMEOUT, "[TSE_DDL_REWRITE]: LOCK TABLE FAILED", MYF(0)); + ctc_lock_table_post(thd, ticket_list); + my_printf_error(ER_LOCK_WAIT_TIMEOUT, "[CTC_DDL_REWRITE]: LOCK TABLE FAILED", MYF(0)); return ER_LOCK_WAIT_TIMEOUT; } } // 全局创建连接成功后执行sql语句 - int ret = tse_broadcast_rewrite_sql(&tch, &broadcast_req, true); + int ret = ctc_broadcast_rewrite_sql(&tch, &broadcast_req, true); if (sql_cmd == SQLCOM_LOCK_TABLES) { - tse_lock_table_post(thd, ticket_list); + ctc_lock_table_post(thd, ticket_list); } - DBUG_EXECUTE_IF("tse_ddl_rewrite_broadcast_fail", { ret = TSE_DDL_VERSION_NOT_MATCH;broadcast_req.err_code = ER_DISALLOWED_OPERATION; }); + DBUG_EXECUTE_IF("ctc_ddl_rewrite_broadcast_fail", { ret = CTC_DDL_VERSION_NOT_MATCH;broadcast_req.err_code = ER_DISALLOWED_OPERATION; }); if (ret != 0 && broadcast_req.err_code != 0) { - tse_ddl_rewrite_handle_error(thd, ret, broadcast_req, sql_cmd); + ctc_ddl_rewrite_handle_error(thd, ret, broadcast_req, sql_cmd); return broadcast_req.err_code; } - tse_log_system("[TSE_DDL_REWRITE]:ret:%d, query:%s, user_name:%s, err_code:%d, broadcast_inst_id:%u, " - "conn_id:%u, tse_inst_id:%u", ret, sql_without_plaintext_password(&broadcast_req).c_str(), broadcast_req.user_name, + ctc_log_system("[CTC_DDL_REWRITE]:ret:%d, query:%s, user_name:%s, err_code:%d, broadcast_inst_id:%u, " + "conn_id:%u, ctc_inst_id:%u", ret, sql_without_plaintext_password(&broadcast_req).c_str(), broadcast_req.user_name, broadcast_req.err_code, broadcast_req.mysql_inst_id, tch.thd_id, tch.inst_id); update_sess_ctx_by_tch(tch, hton, thd); - return convert_tse_error_code_to_mysql((ct_errno_t)ret); + return convert_ctc_error_code_to_mysql((ct_errno_t)ret); } bool plugin_ddl_passthru(MYSQL_THD thd, @@ -1080,7 +1080,7 @@ bool plugin_ddl_passthru(MYSQL_THD thd, #else const char *engine_str = (*thd->variables.table_plugin)->name.str; #endif - if (strcasecmp(engine_str, tse_hton_name) != 0) { + if (strcasecmp(engine_str, ctc_hton_name) != 0) { return true; } @@ -1102,32 +1102,32 @@ bool check_agent_connection(MYSQL_THD thd) { MYSQL *agent_conn = NULL; // 连接mysql server失败，不允许执行ddl操作 - if (tse_init_agent_client(agent_conn) != 0) { + if (ctc_init_agent_client(agent_conn) != 0) { my_printf_error(ER_DISALLOWED_OPERATION, "Failed to establish connection for DDL remote execution!", MYF(0)); - tse_close_mysql_conn(&agent_conn); + ctc_close_mysql_conn(&agent_conn); return true; } - tse_close_mysql_conn(&agent_conn); + ctc_close_mysql_conn(&agent_conn); return false; } int ctc_record_sql(MYSQL_THD thd, bool need_select_db) { - tianchi_handler_t tch; + ctc_handler_t tch; tch.inst_id = ctc_instance_id; - handlerton* hton = get_tse_hton(); + handlerton* hton = get_ctc_hton(); - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); - tse_ddl_broadcast_request broadcast_req {{0}, {0}, {0}, {0}, 0, 0, 0, 0, {0}}; + ctc_ddl_broadcast_request broadcast_req {{0}, {0}, {0}, {0}, 0, 0, 0, 0, {0}}; if (thd->db().str != NULL && strlen(thd->db().str) > 0 && need_select_db) { strncpy(broadcast_req.db_name, thd->db().str, SMALL_RECORD_SIZE - 1); } - broadcast_req.options |= TSE_NOT_NEED_CANTIAN_EXECUTE; - broadcast_req.options |= (thd->lex->contains_plaintext_password ? TSE_CURRENT_SQL_CONTAIN_PLAINTEXT_PASSWORD : 0); + broadcast_req.options |= CTC_NOT_NEED_CANTIAN_EXECUTE; + broadcast_req.options |= (thd->lex->contains_plaintext_password ? CTC_CURRENT_SQL_CONTAIN_PLAINTEXT_PASSWORD : 0); string sql = string(thd->query().str).substr(0, thd->query().length); FILL_BROADCAST_BASE_REQ(broadcast_req, sql.c_str(), thd->m_main_security_ctx.priv_user().str, @@ -1136,7 +1136,7 @@ int ctc_record_sql(MYSQL_THD thd, bool need_select_db) { int ret = ctc_record_sql_for_cantian(&tch, &broadcast_req, false); update_sess_ctx_by_tch(tch, hton, thd); - tse_log_system("[TSE_REWRITE_META]:ret:%d, query:%s", ret, sql_without_plaintext_password(&broadcast_req).c_str()); + ctc_log_system("[CTC_REWRITE_META]:ret:%d, query:%s", ret, sql_without_plaintext_password(&broadcast_req).c_str()); return ret; } @@ -1149,13 +1149,13 @@ bool plugin_ddl_block(MYSQL_THD thd, if (broadcast_cmd.pre_func != NULL) { int ret = broadcast_cmd.pre_func(query_str, thd, need_forward); if (ret != 0) { - tse_log_system("pre_func execute failed,ret:%d,cmd:%d, sql:%s", + ctc_log_system("pre_func execute failed,ret:%d,cmd:%d, sql:%s", ret, it->first, query_str.c_str()); return true; } } - if (tse_check_ddl_sql_length(query_str)) { + if (ctc_check_ddl_sql_length(query_str)) { return true; } @@ -1165,17 +1165,17 @@ bool plugin_ddl_block(MYSQL_THD thd, if (IS_METADATA_NORMALIZATION() && !is_dcl_sql_cmd(thd->lex->sql_command)) { if (ctc_record_sql(thd, broadcast_cmd.need_select_db)) { - tse_log_error("[CTC_META_SQL]:record sql str failed. sql:%s", query_str.c_str()); + ctc_log_error("[CTC_META_SQL]:record sql str failed. sql:%s", query_str.c_str()); return true; } } if (!IS_METADATA_NORMALIZATION()) { if (engine_skip_ddl(thd)) { - tse_log_warning("[CTC_NOMETA_SQL]:record sql str only generate metadata. sql:%s", query_str.c_str()); + ctc_log_warning("[CTC_NOMETA_SQL]:record sql str only generate metadata. sql:%s", query_str.c_str()); return false; } - // disallow ddl query if ctc_concurrent_ddl=OFF and tse_enable_ddl not set + // disallow ddl query if ctc_concurrent_ddl=OFF and ctc_enable_ddl not set if (!ddl_enabled_normal(thd)) { my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), "DDL not allowed in this mode, Please check the value of @@ctc_concurrent_ddl."); return true; @@ -1188,7 +1188,7 @@ bool plugin_ddl_block(MYSQL_THD thd, } // due to MDL_key::BACKUP_LOCK`s MDL_INTENTION_EXCLUSIVE comflicts with MDL_key::BACKUP_LOCK`s MDL_SHARED (user execute STMT `lock instance for backup`) -static bool tse_is_instance_locked_by_backup(MYSQL_THD thd) { +static bool ctc_is_instance_locked_by_backup(MYSQL_THD thd) { MDL_request mdl_request; MDL_key key(MDL_key::BACKUP_LOCK, "", ""); // check this conn whether has backup S lock @@ -1206,7 +1206,7 @@ static bool tse_is_instance_locked_by_backup(MYSQL_THD thd) { } } -static bool tse_is_have_global_read_lock(MYSQL_THD thd) { +static bool ctc_is_have_global_read_lock(MYSQL_THD thd) { // check if current connetion hold global read lock, let it go if (thd->global_read_lock.is_acquired()) { return false; @@ -1220,11 +1220,11 @@ static bool tse_is_have_global_read_lock(MYSQL_THD thd) { return false; } -static inline bool tse_is_broadcast_by_storage_engine(ddl_broadcast_cmd broadcast_cmd) { - return broadcast_cmd.pre_func == tse_check_ddl || broadcast_cmd.pre_func == tse_check_ddl_engine; +static inline bool ctc_is_broadcast_by_storage_engine(ddl_broadcast_cmd broadcast_cmd) { + return broadcast_cmd.pre_func == ctc_check_ddl || broadcast_cmd.pre_func == ctc_check_ddl_engine; } -static bool tse_is_set_session_var(MYSQL_THD thd, string &query_str) { +static bool ctc_is_set_session_var(MYSQL_THD thd, string &query_str) { if (thd->lex->sql_command != SQLCOM_SET_OPTION) { return false; } @@ -1236,14 +1236,14 @@ static bool tse_is_set_session_var(MYSQL_THD thd, string &query_str) { // identify SET statement other than GLOBAL scop set_var *setvar = dynamic_cast(var); if (setvar && setvar->type != OPT_GLOBAL) { - tse_log_system("[TSE_DDL_REWRITE]:let non global scop sql pass. sql_str:%s", query_str.c_str()); + ctc_log_system("[CTC_DDL_REWRITE]:let non global scop sql pass. sql_str:%s", query_str.c_str()); return true; } // identify "set names utf8" sql str set_var_collation_client *set_var_collation = dynamic_cast(var); if (set_var_collation) { - tse_log_system("[TSE_DDL_REWRITE]:let set names xxx pass. sql_str:%s", query_str.c_str()); + ctc_log_system("[CTC_DDL_REWRITE]:let set names xxx pass. sql_str:%s", query_str.c_str()); return true; } } @@ -1251,8 +1251,8 @@ static bool tse_is_set_session_var(MYSQL_THD thd, string &query_str) { return false; } -static int tse_check_metadata_switch() { - metadata_switchs metadata_switch = (metadata_switchs)tse_get_metadata_switch(); +static int ctc_check_metadata_switch() { + metadata_switchs metadata_switch = (metadata_switchs)ctc_get_metadata_switch(); switch (metadata_switch) { case metadata_switchs::MATCH_META: { return 0; @@ -1260,21 +1260,21 @@ static int tse_check_metadata_switch() { case metadata_switchs::MATCH_NO_META: return 1; case metadata_switchs::CLUSTER_NOT_READY: - tse_log_error("[CTC_META]: Cantian cluster not ready"); + ctc_log_error("[CTC_META]: Cantian cluster not ready"); my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), "CANTIAN cluster not read."); return -1; case metadata_switchs::NOT_MATCH: - tse_log_error("[CTC_META]: The metadata switch of CTC and CANTIAN not match"); + ctc_log_error("[CTC_META]: The metadata switch of CTC and CANTIAN not match"); my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), "metadata switch not match."); return -1; default: - tse_log_error("[CTC_META]: ctc_get_metadata_switch fail"); + ctc_log_error("[CTC_META]: ctc_get_metadata_switch fail"); my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), "CTC get metadata switch status fail."); return -1; } } -static int tse_ddl_rewrite(MYSQL_THD thd, mysql_event_class_t event_class, +static int ctc_ddl_rewrite(MYSQL_THD thd, mysql_event_class_t event_class, const void *event) { if (is_meta_version_initialize()) { return 0; @@ -1302,7 +1302,7 @@ static int tse_ddl_rewrite(MYSQL_THD thd, mysql_event_class_t event_class, return -1; } - int check_metadata_switch_result = tse_check_metadata_switch(); + int check_metadata_switch_result = ctc_check_metadata_switch(); // for non-metadata-normalization's gate test DBUG_EXECUTE_IF("non_metadata_normalization", { check_metadata_switch_result = 1; }); // broadcast SET_OPTION query with subselect item @@ -1311,28 +1311,28 @@ static int tse_ddl_rewrite(MYSQL_THD thd, mysql_event_class_t event_class, } if (sql_cmd == SQLCOM_LOCK_INSTANCE) { - if (tse_check_lock_instance(thd, need_forward)) { + if (ctc_check_lock_instance(thd, need_forward)) { return -1; } } else if (sql_cmd == SQLCOM_UNLOCK_INSTANCE) { - tse_check_unlock_instance(thd); - } else if (!IS_METADATA_NORMALIZATION() && (need_forward || tse_is_broadcast_by_storage_engine(it->second))) { + ctc_check_unlock_instance(thd); + } else if (!IS_METADATA_NORMALIZATION() && (need_forward || ctc_is_broadcast_by_storage_engine(it->second))) { // block ddl when instance has exclusive backup lock (LOCK INSTANCE FOR BACKUP), ref sql_backup_lock.cc - if (tse_is_instance_locked_by_backup(thd)) { + if (ctc_is_instance_locked_by_backup(thd)) { // don't block SET session variable after "lock instance for backup" - if (tse_is_set_session_var(thd, query_str)) { + if (ctc_is_set_session_var(thd, query_str)) { return 0; } my_printf_error(ER_DISALLOWED_OPERATION, "Instance has been locked, disallow this operation", MYF(0)); - tse_log_system("[TSE_DDL_REWRITE]: Instance has been locked, disallow sql=%s", query_str.c_str()); + ctc_log_system("[CTC_DDL_REWRITE]: Instance has been locked, disallow sql=%s", query_str.c_str()); return -1; } - if (tse_is_have_global_read_lock(thd)) { + if (ctc_is_have_global_read_lock(thd)) { my_error(ER_CANT_UPDATE_WITH_READLOCK, MYF(0)); - tse_log_error("[TSE_DDL_REWRITE]: Instance have global read lock, disallow sql=%s", query_str.c_str()); + ctc_log_error("[CTC_DDL_REWRITE]: Instance have global read lock, disallow sql=%s", query_str.c_str()); return -1; } } @@ -1342,10 +1342,10 @@ static int tse_ddl_rewrite(MYSQL_THD thd, mysql_event_class_t event_class, } /* Audit plugin descriptor. */ -static struct st_mysql_audit tse_ddl_rewriter_descriptor = { +static struct st_mysql_audit ctc_ddl_rewriter_descriptor = { MYSQL_AUDIT_INTERFACE_VERSION, /* interface version */ nullptr, /* release_thd() */ - tse_ddl_rewrite, /* event_notify() */ + ctc_ddl_rewrite, /* event_notify() */ { 0, 0, @@ -1360,14 +1360,14 @@ static struct st_mysql_audit tse_ddl_rewriter_descriptor = { #else #define STRUCT_FLD(name, value) value #endif -struct st_mysql_plugin g_tse_ddl_rewriter_plugin = { +struct st_mysql_plugin g_ctc_ddl_rewriter_plugin = { /* the plugin type (a MYSQL_XXX_PLUGIN value) */ /* int */ STRUCT_FLD(type, MYSQL_AUDIT_PLUGIN), /* pointer to type-specific plugin descriptor */ /* void* */ - STRUCT_FLD(info, &tse_ddl_rewriter_descriptor), + STRUCT_FLD(info, &ctc_ddl_rewriter_descriptor), /* plugin name */ /* const char* */ @@ -1405,7 +1405,7 @@ struct st_mysql_plugin g_tse_ddl_rewriter_plugin = { STRUCT_FLD(status_vars, nullptr), /* SYS_VAR** */ - STRUCT_FLD(system_vars, tse_rewriter_system_variables), + STRUCT_FLD(system_vars, ctc_rewriter_system_variables), /* reserved for dependency checking */ /* void* */ diff --git a/storage/tianchi/tse_ddl_util.cc b/storage/ctc/ctc_ddl_util.cc similarity index 68% rename from storage/tianchi/tse_ddl_util.cc rename to storage/ctc/ctc_ddl_util.cc index f256be4..ef5589b 100644 --- a/storage/tianchi/tse_ddl_util.cc +++ b/storage/ctc/ctc_ddl_util.cc @@ -11,8 +11,8 @@ GNU General Public License for more details. */ -#include "tse_ddl_util.h" -#include "tse_log.h" +#include "ctc_ddl_util.h" +#include "ctc_log.h" #include "sql/sql_class.h" #include "sql/create_field.h" #include "sql/sql_lex.h" @@ -22,11 +22,11 @@ using namespace std; const char *ibd_suffix = ".ibd"; -void *tse_ddl_alloc_mem(char **mem_start, char *mem_end, +void *ctc_ddl_alloc_mem(char **mem_start, char *mem_end, size_t malloc_size) { assert(mem_start != NULL && *mem_start != NULL && mem_end != NULL); if (*mem_start + malloc_size >= mem_end) { - tse_log_error("alloc ddl mem failed,size:%u", (uint32_t)malloc_size); + ctc_log_error("alloc ddl mem failed,size:%u", (uint32_t)malloc_size); return NULL; } void *ptr = *mem_start; @@ -34,11 +34,11 @@ void *tse_ddl_alloc_mem(char **mem_start, char *mem_end, return ptr; } -int check_tse_identifier_name(const char *in_name) { +int check_ctc_identifier_name(const char *in_name) { if (in_name == nullptr) { return 0; } - if (strlen(in_name) > TSE_IDENTIFIER_MAX_LEN) { + if (strlen(in_name) > CTC_IDENTIFIER_MAX_LEN) { my_error(ER_TOO_LONG_IDENT, MYF(0), in_name); return -1; } @@ -88,7 +88,7 @@ bool check_data_file_name(const char *data_file_name) { return false; } -Field *tse_get_field_by_name(TABLE *form, const char *name) { +Field *ctc_get_field_by_name(TABLE *form, const char *name) { for (uint32_t i = 0; i < form->s->fields; i++) { if (strcasecmp(form->field[i]->field_name, name) == 0) { return form->field[i]; @@ -97,7 +97,7 @@ Field *tse_get_field_by_name(TABLE *form, const char *name) { return nullptr; } -const Create_field *tse_get_create_field_by_column_name(THD *thd, const char* field_name) { +const Create_field *ctc_get_create_field_by_column_name(THD *thd, const char* field_name) { // 处理普通建表 Alter_info *alter_info = thd->lex->alter_info; const Create_field *field = NULL; @@ -165,67 +165,67 @@ const Create_field *tse_get_create_field_by_column_name(THD *thd, const char* fi return nullptr; } -tse_alter_table_drop_type tse_ddl_get_drop_type_from_mysql_type( +ctc_alter_table_drop_type ctc_ddl_get_drop_type_from_mysql_type( Alter_drop::drop_type drop_type) { switch (drop_type) { case Alter_drop::drop_type::KEY: - return TSE_ALTER_TABLE_DROP_KEY; + return CTC_ALTER_TABLE_DROP_KEY; case Alter_drop::drop_type::COLUMN: - return TSE_ALTER_TABLE_DROP_COLUMN; + return CTC_ALTER_TABLE_DROP_COLUMN; case Alter_drop::drop_type::FOREIGN_KEY: - return TSE_ALTER_TABLE_DROP_FOREIGN_KEY; + return CTC_ALTER_TABLE_DROP_FOREIGN_KEY; case Alter_drop::drop_type::CHECK_CONSTRAINT: - return TSE_ALTER_TABLE_DROP_CHECK_CONSTRAINT; + return CTC_ALTER_TABLE_DROP_CHECK_CONSTRAINT; case Alter_drop::drop_type::ANY_CONSTRAINT: - return TSE_ALTER_TABLE_DROP_ANY_CONSTRAINT; + return CTC_ALTER_TABLE_DROP_ANY_CONSTRAINT; default: - return TSE_ALTER_TABLE_DROP_UNKNOW; + return CTC_ALTER_TABLE_DROP_UNKNOW; } } -tse_alter_column_type tse_ddl_get_alter_column_type_from_mysql_type( +ctc_alter_column_type ctc_ddl_get_alter_column_type_from_mysql_type( Alter_column::Type alter_column_type) { switch (alter_column_type) {// SET_DEFAULT, DROP_DEFAULT, RENAME_COLUMN case Alter_column::Type::SET_DEFAULT: - return TSE_ALTER_COLUMN_SET_DEFAULT; + return CTC_ALTER_COLUMN_SET_DEFAULT; case Alter_column::Type::DROP_DEFAULT: - return TSE_ALTER_COLUMN_DROP_DEFAULT; + return CTC_ALTER_COLUMN_DROP_DEFAULT; case Alter_column::Type::RENAME_COLUMN: - return TSE_ALTER_COLUMN_RENAME_COLUMN; + return CTC_ALTER_COLUMN_RENAME_COLUMN; case Alter_column::Type::SET_COLUMN_VISIBLE: - return TSE_ALTER_COLUMN_SET_COLUMN_VISIBLE; + return CTC_ALTER_COLUMN_SET_COLUMN_VISIBLE; case Alter_column::Type::SET_COLUMN_INVISIBLE: - return TSE_ALTER_COLUMN_SET_COLUMN_INVISIBLE; + return CTC_ALTER_COLUMN_SET_COLUMN_INVISIBLE; default: - return TSE_ALTER_COLUMN_UNKNOW; + return CTC_ALTER_COLUMN_UNKNOW; } } -bool get_tse_key_type(const KEY *key_info, int32_t *ret_type) { - *ret_type = TSE_KEYTYPE_UNKNOW; +bool get_ctc_key_type(const KEY *key_info, int32_t *ret_type) { + *ret_type = CTC_KEYTYPE_UNKNOW; if (key_info->flags & HA_SPATIAL) { - *ret_type = TSE_KEYTYPE_SPATIAL; + *ret_type = CTC_KEYTYPE_SPATIAL; } else if (key_info->flags & HA_NOSAME) { if (!my_strcasecmp(system_charset_info, key_info->name, primary_key_name)) { - *ret_type = TSE_KEYTYPE_PRIMARY; + *ret_type = CTC_KEYTYPE_PRIMARY; } else { - *ret_type = TSE_KEYTYPE_UNIQUE; + *ret_type = CTC_KEYTYPE_UNIQUE; } } else if (key_info->flags & HA_FULLTEXT) { - *ret_type = TSE_KEYTYPE_FULLTEXT; + *ret_type = CTC_KEYTYPE_FULLTEXT; } else if (key_info->flags & HA_GENERATED_KEY) { - *ret_type = TSE_KEYTYPE_FOREIGN; + *ret_type = CTC_KEYTYPE_FOREIGN; } else { - *ret_type = TSE_KEYTYPE_MULTIPLE; + *ret_type = CTC_KEYTYPE_MULTIPLE; } switch (*ret_type) { - case TSE_KEYTYPE_SPATIAL: - *ret_type = TSE_KEYTYPE_UNKNOW; - TSE_ENGINE_ERROR("unsupport index type:TSE_KEYTYPE_SPATIAL"); + case CTC_KEYTYPE_SPATIAL: + *ret_type = CTC_KEYTYPE_UNKNOW; + CTC_ENGINE_ERROR("unsupport index type:CTC_KEYTYPE_SPATIAL"); return false; - case TSE_KEYTYPE_FULLTEXT: - *ret_type = TSE_KEYTYPE_UNKNOW; - TSE_ENGINE_ERROR("unsupport index type:TSE_KEYTYPE_FULLTEXT"); + case CTC_KEYTYPE_FULLTEXT: + *ret_type = CTC_KEYTYPE_UNKNOW; + CTC_ENGINE_ERROR("unsupport index type:CTC_KEYTYPE_FULLTEXT"); return false; default: break; @@ -233,41 +233,41 @@ bool get_tse_key_type(const KEY *key_info, int32_t *ret_type) { return true; } -bool get_tse_key_algorithm(ha_key_alg algorithm, int32_t *ret_algorithm) { - *ret_algorithm = (int32_t)TSE_HA_KEY_ALG_BTREE; +bool get_ctc_key_algorithm(ha_key_alg algorithm, int32_t *ret_algorithm) { + *ret_algorithm = (int32_t)CTC_HA_KEY_ALG_BTREE; switch (algorithm) { case HA_KEY_ALG_RTREE: - tse_log_error("unsupport index hash_type:HA_KEY_ALG_RTREE"); + ctc_log_error("unsupport index hash_type:HA_KEY_ALG_RTREE"); return true; case HA_KEY_ALG_SE_SPECIFIC: - TSE_ENGINE_ERROR("unsupport index hash_type:HA_KEY_ALG_SE_SPECIFIC"); + CTC_ENGINE_ERROR("unsupport index hash_type:HA_KEY_ALG_SE_SPECIFIC"); return false; case HA_KEY_ALG_FULLTEXT: - TSE_ENGINE_ERROR("unsupport index hash_type:HA_KEY_ALG_FULLTEXT"); + CTC_ENGINE_ERROR("unsupport index hash_type:HA_KEY_ALG_FULLTEXT"); return false; - case TSE_HA_KEY_ALG_HASH: - // tse_log_error("unsupport index hash_type:TSE_HA_KEY_ALG_HASH"); + case CTC_HA_KEY_ALG_HASH: + // ctc_log_error("unsupport index hash_type:CTC_HA_KEY_ALG_HASH"); return true; default: break; } // mysql字符序和daac的参数对接 - static map - g_tse_key_algorithm_map = { - {HA_KEY_ALG_SE_SPECIFIC, TSE_HA_KEY_ALG_SE_SPECIFIC}, - {HA_KEY_ALG_BTREE, TSE_HA_KEY_ALG_BTREE}, - {HA_KEY_ALG_RTREE, TSE_HA_KEY_ALG_RTREE}, - {HA_KEY_ALG_HASH, TSE_HA_KEY_ALG_HASH}, - {HA_KEY_ALG_FULLTEXT, TSE_HA_KEY_ALG_FULLTEXT}}; - auto it = g_tse_key_algorithm_map.find(algorithm); - if (it != g_tse_key_algorithm_map.end()) { + static map + g_ctc_key_algorithm_map = { + {HA_KEY_ALG_SE_SPECIFIC, CTC_HA_KEY_ALG_SE_SPECIFIC}, + {HA_KEY_ALG_BTREE, CTC_HA_KEY_ALG_BTREE}, + {HA_KEY_ALG_RTREE, CTC_HA_KEY_ALG_RTREE}, + {HA_KEY_ALG_HASH, CTC_HA_KEY_ALG_HASH}, + {HA_KEY_ALG_FULLTEXT, CTC_HA_KEY_ALG_FULLTEXT}}; + auto it = g_ctc_key_algorithm_map.find(algorithm); + if (it != g_ctc_key_algorithm_map.end()) { *ret_algorithm = (int32_t)it->second; return true; } return false; } -bool tse_ddl_get_data_type_from_mysql_type(Field *field, +bool ctc_ddl_get_data_type_from_mysql_type(Field *field, const enum_field_types &mysql_type, int32_t *ret_type) { if (field != nullptr) { const field_cnvrt_aux_t *mysql_info = get_auxiliary_for_field_convert(field, mysql_type); @@ -277,32 +277,32 @@ bool tse_ddl_get_data_type_from_mysql_type(Field *field, } } - tse_log_error("unsupport mysql datatype:%d", (int32_t)mysql_type); - *ret_type = TSE_DDL_TYPE_UNKNOW; + ctc_log_error("unsupport mysql datatype:%d", (int32_t)mysql_type); + *ret_type = CTC_DDL_TYPE_UNKNOW; return false; } // SET类型最多只能包含64个成员, 1～8成员的集合占1个字节 ,9～16成员的集合占2个字节 // 17～24成员的集合占3个字节, 25～32成员的集合占4个字节, 33～64成员的集合占8个字节 -bool set_column_datatype(size_t set_num, TcDb__TseDDLColumnDef *column) { +bool set_column_datatype(size_t set_num, TcDb__CtcDDLColumnDef *column) { if (set_num < 9) { - column->datatype->datatype = TSE_DDL_TYPE_TINY; + column->datatype->datatype = CTC_DDL_TYPE_TINY; return true; } else if (set_num > 8 && set_num < 17) { - column->datatype->datatype = TSE_DDL_TYPE_SHORT; + column->datatype->datatype = CTC_DDL_TYPE_SHORT; return true; } else if (set_num > 16 && set_num < 33) { - column->datatype->datatype = TSE_DDL_TYPE_INT24; + column->datatype->datatype = CTC_DDL_TYPE_INT24; return true; } else if (set_num > 32 && set_num < 65) { - column->datatype->datatype = TSE_DDL_TYPE_LONGLONG; + column->datatype->datatype = CTC_DDL_TYPE_LONGLONG; return true; } return false; } -bool tse_is_with_default_value(Field *field, const dd::Column *col_obj) { +bool ctc_is_with_default_value(Field *field, const dd::Column *col_obj) { bool has_default_value = false; if (col_obj != nullptr) { const bool has_default = ((!field->is_flag_set(NO_DEFAULT_VALUE_FLAG) && @@ -318,44 +318,44 @@ bool tse_is_with_default_value(Field *field, const dd::Column *col_obj) { return false; } -tse_ddl_fk_rule tse_ddl_get_foreign_key_rule(fk_option rule) { +ctc_ddl_fk_rule ctc_ddl_get_foreign_key_rule(fk_option rule) { switch (rule) { case FK_OPTION_UNDEF: case FK_OPTION_NO_ACTION: case FK_OPTION_RESTRICT: case FK_OPTION_DEFAULT: - return TSE_DDL_FK_RULE_RESTRICT; + return CTC_DDL_FK_RULE_RESTRICT; case FK_OPTION_CASCADE: - return TSE_DDL_FK_RULE_CASCADE; + return CTC_DDL_FK_RULE_CASCADE; case FK_OPTION_SET_NULL: - return TSE_DDL_FK_RULE_SET_NULL; + return CTC_DDL_FK_RULE_SET_NULL; default: break; } - tse_log_error("unknown foreign key option %d", (int)rule); + ctc_log_error("unknown foreign key option %d", (int)rule); assert(0); - return TSE_DDL_FK_RULE_UNKNOW; + return CTC_DDL_FK_RULE_UNKNOW; } -tse_ddl_fk_rule tse_ddl_get_foreign_key_rule(dd::Foreign_key::enum_rule rule) { +ctc_ddl_fk_rule ctc_ddl_get_foreign_key_rule(dd::Foreign_key::enum_rule rule) { switch (rule) { case dd::Foreign_key::enum_rule::RULE_NO_ACTION: case dd::Foreign_key::enum_rule::RULE_RESTRICT: case dd::Foreign_key::enum_rule::RULE_SET_DEFAULT: - return TSE_DDL_FK_RULE_RESTRICT; + return CTC_DDL_FK_RULE_RESTRICT; case dd::Foreign_key::enum_rule::RULE_CASCADE: - return TSE_DDL_FK_RULE_CASCADE; + return CTC_DDL_FK_RULE_CASCADE; case dd::Foreign_key::enum_rule::RULE_SET_NULL: - return TSE_DDL_FK_RULE_SET_NULL; + return CTC_DDL_FK_RULE_SET_NULL; default: break; } - tse_log_error("unknown foreign key option %d", (int)rule); + ctc_log_error("unknown foreign key option %d", (int)rule); assert(0); - return TSE_DDL_FK_RULE_UNKNOW; + return CTC_DDL_FK_RULE_UNKNOW; } -const dd::Index *tse_ddl_get_index_by_name(const dd::Table *tab_obj, +const dd::Index *ctc_ddl_get_index_by_name(const dd::Table *tab_obj, const char *index_name) { for (const dd::Index *index : tab_obj->indexes()) { if (strcmp(index->name().data(), index_name) == 0) { @@ -365,7 +365,7 @@ const dd::Index *tse_ddl_get_index_by_name(const dd::Table *tab_obj, return nullptr; } -const dd::Column *tse_ddl_get_column_by_name(const dd::Table *table_def, +const dd::Column *ctc_ddl_get_column_by_name(const dd::Table *table_def, const char *col_name) { for (auto iter : table_def->columns()) { if (my_strcasecmp(system_charset_info, iter->name().data(), col_name) == 0) { @@ -375,23 +375,23 @@ const dd::Column *tse_ddl_get_column_by_name(const dd::Table *table_def, return nullptr; } -bool tse_ddl_get_create_key_type(dd::Index::enum_index_type type, int32_t *ret_type) { - *ret_type = TSE_KEYTYPE_UNKNOW; +bool ctc_ddl_get_create_key_type(dd::Index::enum_index_type type, int32_t *ret_type) { + *ret_type = CTC_KEYTYPE_UNKNOW; switch (type) { case dd::Index::enum_index_type::IT_PRIMARY: - *ret_type = TSE_KEYTYPE_PRIMARY; + *ret_type = CTC_KEYTYPE_PRIMARY; return true; case dd::Index::enum_index_type::IT_UNIQUE: - *ret_type = TSE_KEYTYPE_UNIQUE; + *ret_type = CTC_KEYTYPE_UNIQUE; return true; case dd::Index::enum_index_type::IT_MULTIPLE: - *ret_type = TSE_KEYTYPE_MULTIPLE; + *ret_type = CTC_KEYTYPE_MULTIPLE; return true; case dd::Index::enum_index_type::IT_FULLTEXT: - TSE_ENGINE_ERROR("unsupport index type:IT_FULLTEXT"); + CTC_ENGINE_ERROR("unsupport index type:IT_FULLTEXT"); return false; case dd::Index::enum_index_type::IT_SPATIAL: - TSE_ENGINE_ERROR("unsupport index type:IT_SPATIAL"); + CTC_ENGINE_ERROR("unsupport index type:IT_SPATIAL"); return false; default: break; @@ -399,35 +399,35 @@ bool tse_ddl_get_create_key_type(dd::Index::enum_index_type type, int32_t *ret_t return true; } -bool tse_ddl_get_create_key_algorithm(dd::Index::enum_index_algorithm algorithm, +bool ctc_ddl_get_create_key_algorithm(dd::Index::enum_index_algorithm algorithm, int32_t *ret_algorithm) { - *ret_algorithm = (int32_t)TSE_HA_KEY_ALG_BTREE; + *ret_algorithm = (int32_t)CTC_HA_KEY_ALG_BTREE; switch (algorithm) { case dd::Index::enum_index_algorithm::IA_RTREE: - // tse_log_error("unsupport index hash_type:IA_RTREE,use TSE_HA_KEY_ALG_BTREE"); + // ctc_log_error("unsupport index hash_type:IA_RTREE,use CTC_HA_KEY_ALG_BTREE"); return true; case dd::Index::enum_index_algorithm::IA_SE_SPECIFIC: - TSE_ENGINE_ERROR("unsupport index hash_type:IA_SE_SPECIFIC"); + CTC_ENGINE_ERROR("unsupport index hash_type:IA_SE_SPECIFIC"); return false; case dd::Index::enum_index_algorithm::IA_FULLTEXT: - TSE_ENGINE_ERROR("unsupport index hash_type:IA_FULLTEXT"); + CTC_ENGINE_ERROR("unsupport index hash_type:IA_FULLTEXT"); return false; case dd::Index::enum_index_algorithm::IA_HASH: - // tse_log_error("unsupport index hash_type:IA_HASH USE TSE_HA_KEY_ALG_BTREE"); + // ctc_log_error("unsupport index hash_type:IA_HASH USE CTC_HA_KEY_ALG_BTREE"); return true; default: break; } - static map - g_tse_create_key_algorithm_map = { - {dd::Index::enum_index_algorithm::IA_SE_SPECIFIC, TSE_HA_KEY_ALG_SE_SPECIFIC}, - {dd::Index::enum_index_algorithm::IA_BTREE, TSE_HA_KEY_ALG_BTREE}, - {dd::Index::enum_index_algorithm::IA_RTREE, TSE_HA_KEY_ALG_RTREE}, - {dd::Index::enum_index_algorithm::IA_HASH, TSE_HA_KEY_ALG_HASH}, - {dd::Index::enum_index_algorithm::IA_FULLTEXT, TSE_HA_KEY_ALG_FULLTEXT}}; - auto it = g_tse_create_key_algorithm_map.find(algorithm); - if (it != g_tse_create_key_algorithm_map.end()) { + static map + g_ctc_create_key_algorithm_map = { + {dd::Index::enum_index_algorithm::IA_SE_SPECIFIC, CTC_HA_KEY_ALG_SE_SPECIFIC}, + {dd::Index::enum_index_algorithm::IA_BTREE, CTC_HA_KEY_ALG_BTREE}, + {dd::Index::enum_index_algorithm::IA_RTREE, CTC_HA_KEY_ALG_RTREE}, + {dd::Index::enum_index_algorithm::IA_HASH, CTC_HA_KEY_ALG_HASH}, + {dd::Index::enum_index_algorithm::IA_FULLTEXT, CTC_HA_KEY_ALG_FULLTEXT}}; + auto it = g_ctc_create_key_algorithm_map.find(algorithm); + if (it != g_ctc_create_key_algorithm_map.end()) { *ret_algorithm = (int32_t)it->second; return true; } @@ -453,16 +453,16 @@ uint16 get_prefix_index_len(const Field *field, const uint16 key_length) { return prefix_len; } -int convert_tse_part_type(dd::Table::enum_partition_type mysql_part_type, uint32_t *tse_part_type) { - *tse_part_type = TSE_PART_TYPE_INVALID; +int convert_ctc_part_type(dd::Table::enum_partition_type mysql_part_type, uint32_t *ctc_part_type) { + *ctc_part_type = CTC_PART_TYPE_INVALID; switch (mysql_part_type) { case dd::Table::PT_RANGE: case dd::Table::PT_RANGE_COLUMNS: - *tse_part_type = TSE_PART_TYPE_RANGE; + *ctc_part_type = CTC_PART_TYPE_RANGE; break; case dd::Table::PT_LIST: case dd::Table::PT_LIST_COLUMNS: - *tse_part_type = TSE_PART_TYPE_LIST; + *ctc_part_type = CTC_PART_TYPE_LIST; break; case dd::Table::PT_HASH: case dd::Table::PT_LINEAR_HASH: @@ -470,22 +470,22 @@ int convert_tse_part_type(dd::Table::enum_partition_type mysql_part_type, uint32 case dd::Table::PT_KEY_55: case dd::Table::PT_LINEAR_KEY_51: case dd::Table::PT_LINEAR_KEY_55: - *tse_part_type = TSE_PART_TYPE_HASH; + *ctc_part_type = CTC_PART_TYPE_HASH; break; default : my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), "Partition tables support only hash partitions, range partitions, list partitions, and columns partitions."); - tse_log_system("unsupported partition type : %d.", mysql_part_type); + ctc_log_system("unsupported partition type : %d.", mysql_part_type); return 1; } return 0; } -int convert_tse_subpart_type(dd::Table::enum_subpartition_type mysql_subpart_type, uint32_t *tse_part_type) { - *tse_part_type = TSE_PART_TYPE_INVALID; +int convert_ctc_subpart_type(dd::Table::enum_subpartition_type mysql_subpart_type, uint32_t *ctc_part_type) { + *ctc_part_type = CTC_PART_TYPE_INVALID; switch (mysql_subpart_type) { case dd::Table::ST_NONE: - *tse_part_type = TSE_PART_TYPE_INVALID; + *ctc_part_type = CTC_PART_TYPE_INVALID; break; case dd::Table::ST_HASH: case dd::Table::ST_LINEAR_HASH: @@ -493,12 +493,12 @@ int convert_tse_subpart_type(dd::Table::enum_subpartition_type mysql_subpart_typ case dd::Table::ST_KEY_55: case dd::Table::ST_LINEAR_KEY_51: case dd::Table::ST_LINEAR_KEY_55: - *tse_part_type = TSE_PART_TYPE_HASH; + *ctc_part_type = CTC_PART_TYPE_HASH; break; default : my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), "SubPartition tables support only hash partitions"); - tse_log_system("unsupported partition type : %d.", mysql_subpart_type); + ctc_log_system("unsupported partition type : %d.", mysql_subpart_type); return 1; } return 0; diff --git a/storage/tianchi/tse_ddl_util.h b/storage/ctc/ctc_ddl_util.h similarity index 46% rename from storage/tianchi/tse_ddl_util.h rename to storage/ctc/ctc_ddl_util.h index 0565539..2976cad 100644 --- a/storage/tianchi/tse_ddl_util.h +++ b/storage/ctc/ctc_ddl_util.h @@ -11,38 +11,38 @@ GNU General Public License for more details. */ -#ifndef __TSE_DDL_UTIL_H__ -#define __TSE_DDL_UTIL_H__ +#ifndef __CTC_DDL_UTIL_H__ +#define __CTC_DDL_UTIL_H__ #include "sql/table.h" #include "sql/sql_alter.h" -#include "tse_srv.h" +#include "ctc_srv.h" #include "protobuf/tc_db.pb-c.h" -#include "ha_tse_ddl.h" +#include "ha_ctc_ddl.h" -void *tse_ddl_alloc_mem(char **mem_start, char *mem_end, size_t malloc_size); -int check_tse_identifier_name(const char *in_name); +void *ctc_ddl_alloc_mem(char **mem_start, char *mem_end, size_t malloc_size); +int check_ctc_identifier_name(const char *in_name); bool check_file_name_has_suffix(const char *file_name, const char *suffix); bool check_file_name_prefix(const char *file_name); bool check_data_file_name(const char *data_file_name); -Field *tse_get_field_by_name(TABLE *form, const char *name); -const Create_field *tse_get_create_field_by_column_name(THD *thd, const char* field_name); -tse_alter_table_drop_type tse_ddl_get_drop_type_from_mysql_type(Alter_drop::drop_type drop_type); -tse_alter_column_type tse_ddl_get_alter_column_type_from_mysql_type( +Field *ctc_get_field_by_name(TABLE *form, const char *name); +const Create_field *ctc_get_create_field_by_column_name(THD *thd, const char* field_name); +ctc_alter_table_drop_type ctc_ddl_get_drop_type_from_mysql_type(Alter_drop::drop_type drop_type); +ctc_alter_column_type ctc_ddl_get_alter_column_type_from_mysql_type( Alter_column::Type alter_column_type); -bool get_tse_key_type(const KEY *key_info, int32_t *ret_type); -bool get_tse_key_algorithm(ha_key_alg algorithm, int32_t *ret_algorithm); -bool tse_ddl_get_data_type_from_mysql_type(Field *field, +bool get_ctc_key_type(const KEY *key_info, int32_t *ret_type); +bool get_ctc_key_algorithm(ha_key_alg algorithm, int32_t *ret_algorithm); +bool ctc_ddl_get_data_type_from_mysql_type(Field *field, const enum_field_types &mysql_type, int32_t *ret_type); -bool set_column_datatype(size_t set_num, TcDb__TseDDLColumnDef *column); -bool tse_is_with_default_value(Field *field, const dd::Column *col_obj); -tse_ddl_fk_rule tse_ddl_get_foreign_key_rule(fk_option rule); -tse_ddl_fk_rule tse_ddl_get_foreign_key_rule(dd::Foreign_key::enum_rule rule); -const dd::Index *tse_ddl_get_index_by_name(const dd::Table *tab_obj, const char *index_name); -const dd::Column *tse_ddl_get_column_by_name(const dd::Table *table_def, const char *col_name); -bool tse_ddl_get_create_key_type(dd::Index::enum_index_type type, int32_t *ret_type); -bool tse_ddl_get_create_key_algorithm(dd::Index::enum_index_algorithm algorithm, int32_t *ret_algorithm); +bool set_column_datatype(size_t set_num, TcDb__CtcDDLColumnDef *column); +bool ctc_is_with_default_value(Field *field, const dd::Column *col_obj); +ctc_ddl_fk_rule ctc_ddl_get_foreign_key_rule(fk_option rule); +ctc_ddl_fk_rule ctc_ddl_get_foreign_key_rule(dd::Foreign_key::enum_rule rule); +const dd::Index *ctc_ddl_get_index_by_name(const dd::Table *tab_obj, const char *index_name); +const dd::Column *ctc_ddl_get_column_by_name(const dd::Table *table_def, const char *col_name); +bool ctc_ddl_get_create_key_type(dd::Index::enum_index_type type, int32_t *ret_type); +bool ctc_ddl_get_create_key_algorithm(dd::Index::enum_index_algorithm algorithm, int32_t *ret_algorithm); uint16 get_prefix_index_len(const Field *field, const uint16 key_length); -int convert_tse_part_type(dd::Table::enum_partition_type mysql_part_type, uint32_t *tse_part_type); -int convert_tse_subpart_type(dd::Table::enum_subpartition_type mysql_subpart_type, uint32_t *tse_part_type); -#endif // __TSE_DDL_UTIL_H__ \ No newline at end of file +int convert_ctc_part_type(dd::Table::enum_partition_type mysql_part_type, uint32_t *ctc_part_type); +int convert_ctc_subpart_type(dd::Table::enum_subpartition_type mysql_subpart_type, uint32_t *ctc_part_type); +#endif // __CTC_DDL_UTIL_H__ \ No newline at end of file diff --git a/storage/tianchi/tse_error.cc b/storage/ctc/ctc_error.cc similarity index 96% rename from storage/tianchi/tse_error.cc rename to storage/ctc/ctc_error.cc index 1fd16e4..b8e67b3 100644 --- a/storage/tianchi/tse_error.cc +++ b/storage/ctc/ctc_error.cc @@ -15,9 +15,9 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ #include -#include "tse_error.h" +#include "ctc_error.h" #include "my_base.h" -#include "tse_log.h" +#include "ctc_log.h" static std::unordered_map err_code_lookup_map = { {ERR_OAMAP_DUP_KEY_ERROR, HA_ERR_GENERIC}, @@ -150,7 +150,7 @@ int convert_cantian_err_to_mysql(ct_errno_t error) { return err_code; } -void tse_alter_table_handle_fault(ct_errno_t error) { +void ctc_alter_table_handle_fault(ct_errno_t error) { switch (error) { case ERR_CONSTRAINT_VIOLATED_NO_FOUND: my_printf_error(ER_NO_REFERENCED_ROW_2, @@ -163,7 +163,7 @@ void tse_alter_table_handle_fault(ct_errno_t error) { } -int convert_tse_error_code_to_mysql_impl(ct_errno_t error, const char* funcName, const int line) { +int convert_ctc_error_code_to_mysql_impl(ct_errno_t error, const char* funcName, const int line) { if (error == CT_SUCCESS) { return 0; } @@ -187,8 +187,8 @@ int convert_tse_error_code_to_mysql_impl(ct_errno_t error, const char* funcName, if (iter != err_code_lookup_map.end()) { ret = iter->second; } else { - tse_log_system("func %s(line%d) returned with unknown err, cantian ret %d", funcName, line, (int)error); + ctc_log_system("func %s(line%d) returned with unknown err, cantian ret %d", funcName, line, (int)error); } - tse_log_note("func %s(line%d) returned with errCode %d, cantian ret %d", funcName, line, ret, (int)error); + ctc_log_note("func %s(line%d) returned with errCode %d, cantian ret %d", funcName, line, ret, (int)error); return ret; } diff --git a/storage/tianchi/tse_error.h b/storage/ctc/ctc_error.h similarity index 96% rename from storage/tianchi/tse_error.h rename to storage/ctc/ctc_error.h index 3f9ec7b..c1e913a 100644 --- a/storage/tianchi/tse_error.h +++ b/storage/ctc/ctc_error.h @@ -14,8 +14,8 @@ along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#ifndef __TSE_ERROR_H__ -#define __TSE_ERROR_H__ +#ifndef __CTC_ERROR_H__ +#define __CTC_ERROR_H__ typedef enum en_errno { @@ -199,7 +199,7 @@ typedef enum en_errno { ERR_GSS_FILE_IS_OPEN = 2042, - // SHM and TSE + // SHM and CTC ERR_SEM_FAULT = 4000, ERR_BATCH_DATA_HANDLE_FAILED = 4001, ERR_SHM_SEND_MSG_FAILED = 4002, @@ -210,11 +210,11 @@ typedef enum en_errno { ERR_FK_NO_INDEX_PAREN_4MYSQL = 4006, ERR_CHILD_DUPLICATE_KEY = 4007, ERR_WRITE_OPT_IN_READONLY = 4008, - TSE_DDL_VERSION_NOT_MATCH = 9999, + CTC_DDL_VERSION_NOT_MATCH = 9999, } ct_errno_t; -#define convert_tse_error_code_to_mysql(error) convert_tse_error_code_to_mysql_impl(error, __func__, __LINE__) -int convert_tse_error_code_to_mysql_impl(ct_errno_t error, const char* funcName, const int line); +#define convert_ctc_error_code_to_mysql(error) convert_ctc_error_code_to_mysql_impl(error, __func__, __LINE__) +int convert_ctc_error_code_to_mysql_impl(ct_errno_t error, const char* funcName, const int line); -void tse_alter_table_handle_fault(ct_errno_t error); +void ctc_alter_table_handle_fault(ct_errno_t error); #endif \ No newline at end of file diff --git a/storage/tianchi/tse_log.h b/storage/ctc/ctc_log.h similarity index 75% rename from storage/tianchi/tse_log.h rename to storage/ctc/ctc_log.h index 6b96dc6..144f809 100644 --- a/storage/tianchi/tse_log.h +++ b/storage/ctc/ctc_log.h @@ -24,10 +24,10 @@ #include "my_dbug.h" #include "mysqld_error.h" -#ifndef __TSE_LOG_H__ -#define __TSE_LOG_H__ +#ifndef __CTC_LOG_H__ +#define __CTC_LOG_H__ -#define TSE_LOG_SIZE 1024 +#define CTC_LOG_SIZE 1024 #define UNUSED_PARAM(_p) (void(_p)) // supress warning declared but not used #define __FILENAME__ (strrchr("/" __FILE__, '/') + 1) @@ -56,8 +56,8 @@ static void replace_all(char *filter_str, const char *regex) { std::regex pattern(regex); std::string s(filter_str); s = std::regex_replace(s, pattern, "*****"); - if (s.length() >= TSE_LOG_SIZE) { - s = s.substr(0, TSE_LOG_SIZE - 1); + if (s.length() >= CTC_LOG_SIZE) { + s = s.substr(0, CTC_LOG_SIZE - 1); } strcpy(filter_str, s.c_str()); filter_str[s.length()] = '\0'; @@ -80,23 +80,23 @@ static void do_security_filter(char *filter_str) { */ -inline void tse_log_print(enum loglevel loglevel, const char *fmt, ...) MY_ATTRIBUTE((format(printf, 2, 3))); +inline void ctc_log_print(enum loglevel loglevel, const char *fmt, ...) MY_ATTRIBUTE((format(printf, 2, 3))); -void tse_log_print(enum loglevel loglevel, const char *fmt, ...) { +void ctc_log_print(enum loglevel loglevel, const char *fmt, ...) { if (log_error_verbosity < loglevel) return; assert(fmt); va_list args; - char msg_buf[TSE_LOG_SIZE]; + char msg_buf[CTC_LOG_SIZE]; va_start(args, fmt); int res = vsnprintf(msg_buf, sizeof(msg_buf), fmt, args); va_end(args); assert(res); - if (res >= TSE_LOG_SIZE) { - msg_buf[TSE_LOG_SIZE - 2] = '.'; - msg_buf[TSE_LOG_SIZE - 3] = '.'; - msg_buf[TSE_LOG_SIZE - 4] = '.'; + if (res >= CTC_LOG_SIZE) { + msg_buf[CTC_LOG_SIZE - 2] = '.'; + msg_buf[CTC_LOG_SIZE - 3] = '.'; + msg_buf[CTC_LOG_SIZE - 4] = '.'; } if (!opt_general_log_raw) { //配置文件中的log-raw @@ -107,53 +107,53 @@ void tse_log_print(enum loglevel loglevel, const char *fmt, ...) { } /* System Level log */ -#define tse_log_system(fmt, args...) tse_log_print(SYSTEM_LEVEL, "[%s:%s(%d)]" fmt, __FILENAME__, __FUNCTION__, __LINE__, ##args) +#define ctc_log_system(fmt, args...) ctc_log_print(SYSTEM_LEVEL, "[%s:%s(%d)]" fmt, __FILENAME__, __FUNCTION__, __LINE__, ##args) /* Error Level log */ -#define tse_log_error(fmt, args...) tse_log_print(ERROR_LEVEL, "[%s:%s(%d)]" fmt, __FILENAME__, __FUNCTION__, __LINE__, ##args) +#define ctc_log_error(fmt, args...) ctc_log_print(ERROR_LEVEL, "[%s:%s(%d)]" fmt, __FILENAME__, __FUNCTION__, __LINE__, ##args) /* Warning Level log */ -#define tse_log_warning(fmt, args...) tse_log_print(WARNING_LEVEL, "[%s:%s(%d)]" fmt, __FILENAME__, __FUNCTION__, __LINE__, ##args) +#define ctc_log_warning(fmt, args...) ctc_log_print(WARNING_LEVEL, "[%s:%s(%d)]" fmt, __FILENAME__, __FUNCTION__, __LINE__, ##args) /* note Level log */ -#define tse_log_note(fmt, args...) tse_log_print(INFORMATION_LEVEL, "[%s:%s(%d)]" fmt, __FILENAME__, __FUNCTION__, __LINE__, ##args) -#define tse_log_verbose tse_log_note -#define tse_log_info tse_log_note -#define tse_log_trivia tse_log_note +#define ctc_log_note(fmt, args...) ctc_log_print(INFORMATION_LEVEL, "[%s:%s(%d)]" fmt, __FILENAME__, __FUNCTION__, __LINE__, ##args) +#define ctc_log_verbose ctc_log_note +#define ctc_log_info ctc_log_note +#define ctc_log_trivia ctc_log_note /* debug only Level log */ -#define tse_log_debug(fmt, args...) DBUG_PRINT("tse", (fmt, ##args)) -#define tse_log_debug_only tse_log_debug +#define ctc_log_debug(fmt, args...) DBUG_PRINT("ctc", (fmt, ##args)) +#define ctc_log_debug_only ctc_log_debug -#define TSE_ENGINE_ERROR(message) \ +#define CTC_ENGINE_ERROR(message) \ do { \ - tse_log_error(message); \ + ctc_log_error(message); \ my_error(ER_IB_MSG_1381, MYF(0), message); \ } while (0) -#define TSE_RETURN_IF_ERROR(_expVal, retVal) \ +#define CTC_RETURN_IF_ERROR(_expVal, retVal) \ do { \ bool _status_ = (_expVal); \ if (!_status_) { \ - tse_log_system("TSE_RETURN_IF_ERROR return"); \ + ctc_log_system("CTC_RETURN_IF_ERROR return"); \ return retVal; \ } \ } while (0) -#define TSE_RETURN_IF_NOT_ZERO(retVal) \ +#define CTC_RETURN_IF_NOT_ZERO(retVal) \ do { \ int ret = retVal; \ if (ret != 0) { \ - tse_log_system("TSE_RETURN_IF_NOT_ZERO return"); \ + ctc_log_system("CTC_RETURN_IF_NOT_ZERO return"); \ return ret; \ } \ } while (0) -#define TSE_RET_ERR_IF_NULL(var) \ +#define CTC_RET_ERR_IF_NULL(var) \ do { \ if (var == NULL) { \ return CT_ERROR; \ } \ } while (0) -#endif // __TSE_LOG_H__ +#endif // __CTC_LOG_H__ diff --git a/storage/tianchi/ctc_meta_data.cc b/storage/ctc/ctc_meta_data.cc similarity index 71% rename from storage/tianchi/ctc_meta_data.cc rename to storage/ctc/ctc_meta_data.cc index 90a047d..5f72ba3 100644 --- a/storage/tianchi/ctc_meta_data.cc +++ b/storage/ctc/ctc_meta_data.cc @@ -24,10 +24,10 @@ #include #include "mysql.h" #include "sql/mysqld.h" // mysql_port, my_localhost -#include "tse_log.h" -#include "tse_srv.h" -#include "tse_util.h" -#include "tse_proxy_util.h" +#include "ctc_log.h" +#include "ctc_srv.h" +#include "ctc_util.h" +#include "ctc_proxy_util.h" #include "sql/sql_table.h" #include "my_dir.h" #include "sql/sql_handler.h" @@ -45,7 +45,7 @@ #include "sql/auth/auth_common.h" #include "sql/sys_vars_shared.h" // intern_find_sys_var #include "sql/sql_lex.h" // lex_start/lex_end -#include "sql/handler.h" // ha_tse_commit +#include "sql/handler.h" // ha_ctc_commit #include "sql/auth/auth_acls.h" #include "sql/sp_cache.h" // sp_cache_invalidate #include "sql/sp_head.h" // Stored_program_creation_ctx @@ -60,20 +60,20 @@ using namespace std; extern uint32_t ctc_instance_id; -static map g_tse_mdl_thd_map; -static mutex m_tse_mdl_thd_mutex; -static map *> g_tse_mdl_ticket_maps; -static map *> g_tse_invalidate_routine_maps; -static map *> g_tse_invalidate_schema_maps; -static mutex m_tse_mdl_ticket_mutex; -static mutex m_tse_invalidate_dd_cache_mutex; +static map g_ctc_mdl_thd_map; +static mutex m_ctc_mdl_thd_mutex; +static map *> g_ctc_mdl_ticket_maps; +static map *> g_ctc_invalidate_routine_maps; +static map *> g_ctc_invalidate_schema_maps; +static mutex m_ctc_mdl_ticket_mutex; +static mutex m_ctc_invalidate_dd_cache_mutex; bool no_create_dir = true; class Release_all_ctc_explicit_locks : public MDL_release_locks_visitor { public: bool release(MDL_ticket *ticket) override { const MDL_key *mdl_key = ticket->get_key(); - tse_log_system("[TSE_MDL_THD]: Release ticket info, db_name:%s, name:%s, namespace:%d, ticket_type:%d", + ctc_log_system("[CTC_MDL_THD]: Release ticket info, db_name:%s, name:%s, namespace:%d, ticket_type:%d", mdl_key->db_name(), mdl_key->name(), mdl_key->mdl_namespace(), ticket->get_type()); return ticket->get_type() == MDL_EXCLUSIVE || ((ticket->get_type() == MDL_SHARED_READ_ONLY || ticket->get_type() == MDL_SHARED_NO_READ_WRITE) && @@ -97,73 +97,73 @@ static void release_ctc_thd_and_explicit_locks(THD *thd) { static void release_routine_and_schema(THD *thd, bool *error); static void release_ctc_thd_tickets(THD *thd) { - lock_guard lock(m_tse_mdl_ticket_mutex); - auto ticket_map_iter = g_tse_mdl_ticket_maps.find(thd); - if (ticket_map_iter == g_tse_mdl_ticket_maps.end()) { + lock_guard lock(m_ctc_mdl_ticket_mutex); + auto ticket_map_iter = g_ctc_mdl_ticket_maps.find(thd); + if (ticket_map_iter == g_ctc_mdl_ticket_maps.end()) { return; } - map *tse_mdl_ticket_map = ticket_map_iter->second; - if (tse_mdl_ticket_map == nullptr) { - g_tse_mdl_ticket_maps.erase(thd); + map *ctc_mdl_ticket_map = ticket_map_iter->second; + if (ctc_mdl_ticket_map == nullptr) { + g_ctc_mdl_ticket_maps.erase(thd); return; } - tse_mdl_ticket_map->clear(); - delete tse_mdl_ticket_map; - g_tse_mdl_ticket_maps.erase(thd); + ctc_mdl_ticket_map->clear(); + delete ctc_mdl_ticket_map; + g_ctc_mdl_ticket_maps.erase(thd); } -static void release_tse_mdl_thd_by_key(uint64_t mdl_thd_key) { +static void release_ctc_mdl_thd_by_key(uint64_t mdl_thd_key) { /* 存在并发场景 map操作加锁 */ - lock_guard lock(m_tse_mdl_thd_mutex); - auto iter = g_tse_mdl_thd_map.find(mdl_thd_key); - if (iter == g_tse_mdl_thd_map.end()) { + lock_guard lock(m_ctc_mdl_thd_mutex); + auto iter = g_ctc_mdl_thd_map.find(mdl_thd_key); + if (iter == g_ctc_mdl_thd_map.end()) { return; } - THD *thd = g_tse_mdl_thd_map[mdl_thd_key]; + THD *thd = g_ctc_mdl_thd_map[mdl_thd_key]; assert(thd); bool error = 0; release_routine_and_schema(thd, &error); release_ctc_thd_tickets(thd); release_ctc_thd_and_explicit_locks(thd); - tse_log_system("[TSE_MDL_THD]: Close mdl thd by key=%lu", mdl_thd_key); + ctc_log_system("[CTC_MDL_THD]: Close mdl thd by key=%lu", mdl_thd_key); - g_tse_mdl_thd_map.erase(mdl_thd_key); + g_ctc_mdl_thd_map.erase(mdl_thd_key); } -static void release_tse_mdl_thd_by_cantian_id(uint16_t cantian_inst_id) { - lock_guard lock(m_tse_mdl_thd_mutex); - for (auto iter = g_tse_mdl_thd_map.begin(); iter != g_tse_mdl_thd_map.end(); ) { - if (tse_get_cantian_id_from_conn_key(iter->first) == cantian_inst_id) { +static void release_ctc_mdl_thd_by_cantian_id(uint16_t cantian_inst_id) { + lock_guard lock(m_ctc_mdl_thd_mutex); + for (auto iter = g_ctc_mdl_thd_map.begin(); iter != g_ctc_mdl_thd_map.end(); ) { + if (ctc_get_cantian_id_from_conn_key(iter->first) == cantian_inst_id) { THD *thd = iter->second; assert(thd); bool error = 0; release_routine_and_schema(thd, &error); release_ctc_thd_tickets(thd); release_ctc_thd_and_explicit_locks(thd); - tse_log_system("[TSE_MDL_THD]: Close mdl thd by cantian_id:%u", cantian_inst_id); - iter = g_tse_mdl_thd_map.erase(iter); + ctc_log_system("[CTC_MDL_THD]: Close mdl thd by cantian_id:%u", cantian_inst_id); + iter = g_ctc_mdl_thd_map.erase(iter); } else { ++iter; } } } -static void release_tse_mdl_thd_by_inst_id(uint32_t mysql_inst_id) { - lock_guard lock(m_tse_mdl_thd_mutex); - for (auto iter = g_tse_mdl_thd_map.begin(); iter != g_tse_mdl_thd_map.end(); ) { - if (tse_get_inst_id_from_conn_key(iter->first) == mysql_inst_id) { +static void release_ctc_mdl_thd_by_inst_id(uint32_t mysql_inst_id) { + lock_guard lock(m_ctc_mdl_thd_mutex); + for (auto iter = g_ctc_mdl_thd_map.begin(); iter != g_ctc_mdl_thd_map.end(); ) { + if (ctc_get_inst_id_from_conn_key(iter->first) == mysql_inst_id) { THD *thd = iter->second; assert(thd); bool error = 0; release_routine_and_schema(thd, &error); release_ctc_thd_tickets(thd); release_ctc_thd_and_explicit_locks(thd); - tse_log_system("[TSE_MDL_THD]: Close mdl thd by inst_id:%u", mysql_inst_id); - iter = g_tse_mdl_thd_map.erase(iter); + ctc_log_system("[CTC_MDL_THD]: Close mdl thd by inst_id:%u", mysql_inst_id); + iter = g_ctc_mdl_thd_map.erase(iter); } else { ++iter; } @@ -171,9 +171,9 @@ static void release_tse_mdl_thd_by_inst_id(uint32_t mysql_inst_id) { } static void ctc_init_thd(THD **thd, uint64_t thd_key) { - lock_guard lock(m_tse_mdl_thd_mutex); - if (g_tse_mdl_thd_map.find(thd_key) != g_tse_mdl_thd_map.end()) { - (*thd) = g_tse_mdl_thd_map[thd_key]; + lock_guard lock(m_ctc_mdl_thd_mutex); + if (g_ctc_mdl_thd_map.find(thd_key) != g_ctc_mdl_thd_map.end()) { + (*thd) = g_ctc_mdl_thd_map[thd_key]; my_thread_init(); (*thd)->thread_stack = (char *)thd; (*thd)->store_globals(); @@ -183,37 +183,37 @@ static void ctc_init_thd(THD **thd, uint64_t thd_key) { new_thd->set_new_thread_id(); new_thd->thread_stack = (char *)thd; new_thd->store_globals(); - new_thd->set_query("tse_mdl_thd_notify", 18); - g_tse_mdl_thd_map[thd_key] = new_thd; + new_thd->set_query("ctc_mdl_thd_notify", 18); + g_ctc_mdl_thd_map[thd_key] = new_thd; (*thd) = new_thd; } } #ifdef METADATA_NORMALIZED -static void tse_insert_schema(THD *thd, invalidate_obj_entry_t *obj) { - lock_guard lock(m_tse_invalidate_dd_cache_mutex); - auto it = g_tse_invalidate_schema_maps.find(thd); +static void ctc_insert_schema(THD *thd, invalidate_obj_entry_t *obj) { + lock_guard lock(m_ctc_invalidate_dd_cache_mutex); + auto it = g_ctc_invalidate_schema_maps.find(thd); vector *invalidate_schema_list = nullptr; - if (it == g_tse_invalidate_schema_maps.end()) { + if (it == g_ctc_invalidate_schema_maps.end()) { invalidate_schema_list = new vector; assert(invalidate_schema_list); - g_tse_invalidate_schema_maps[thd] = invalidate_schema_list; + g_ctc_invalidate_schema_maps[thd] = invalidate_schema_list; } - g_tse_invalidate_schema_maps[thd]->emplace_back(obj); + g_ctc_invalidate_schema_maps[thd]->emplace_back(obj); } #endif #ifdef METADATA_NORMALIZED -static void tse_insert_routine(THD *thd, invalidate_obj_entry_t *obj) { - lock_guard lock(m_tse_invalidate_dd_cache_mutex); - auto it = g_tse_invalidate_routine_maps.find(thd); +static void ctc_insert_routine(THD *thd, invalidate_obj_entry_t *obj) { + lock_guard lock(m_ctc_invalidate_dd_cache_mutex); + auto it = g_ctc_invalidate_routine_maps.find(thd); vector *invalidate_routine_list = nullptr; - if (it == g_tse_invalidate_routine_maps.end()) { + if (it == g_ctc_invalidate_routine_maps.end()) { invalidate_routine_list = new vector; assert(invalidate_routine_list); - g_tse_invalidate_routine_maps[thd] = invalidate_routine_list; + g_ctc_invalidate_routine_maps[thd] = invalidate_routine_list; } - g_tse_invalidate_routine_maps[thd]->emplace_back(obj); + g_ctc_invalidate_routine_maps[thd]->emplace_back(obj); } #endif @@ -223,7 +223,7 @@ typename std::enable_if::type MDL_ticket *schema_ticket = nullptr; MDL_ticket *routine_ticket = nullptr; - tse_log_system("[INVALIDATE_ROUTINE]: enter invalidate_routine. schema_name:%s, routine_name:%s", schema_name, routine_name); + ctc_log_system("[INVALIDATE_ROUTINE]: enter invalidate_routine. schema_name:%s, routine_name:%s", schema_name, routine_name); if(!thd->mdl_context.owns_equal_or_stronger_lock( MDL_key::SCHEMA, schema_name, "", MDL_INTENTION_EXCLUSIVE)) { MDL_request mdl_request; @@ -251,7 +251,7 @@ typename std::enable_if::type MDL_REQUEST_INIT_BY_KEY(&mdl_request, &mdl_key, MDL_EXCLUSIVE, MDL_EXPLICIT); if (thd->mdl_context.acquire_lock(&mdl_request, CTC_MDL_TIMEOUT)) { assert(thd->killed || thd->is_error()); - tse_log_error("[INVALIDATE_ROUTINE]: Failed to acquire routine/procedure mdl of schema_name:%s and routine_name:%s", schema_name, routine_name); + ctc_log_error("[INVALIDATE_ROUTINE]: Failed to acquire routine/procedure mdl of schema_name:%s and routine_name:%s", schema_name, routine_name); return true; } routine_ticket = mdl_request.ticket; @@ -284,7 +284,7 @@ typename std::enable_if::type if (routine_ticket) thd->mdl_context.release_lock(routine_ticket); if (schema_ticket) thd->mdl_context.release_lock(schema_ticket); - tse_log_system("[INVALIDATE_ROUTINE]: leave invalidate_routine. schema_name:%s, routine_name:%s", schema_name, routine_name); + ctc_log_system("[INVALIDATE_ROUTINE]: leave invalidate_routine. schema_name:%s, routine_name:%s", schema_name, routine_name); return false; } @@ -301,7 +301,7 @@ typename std::enable_if::type MDL_ticket *schema_ticket = nullptr; MDL_ticket *table_ticket = nullptr; - tse_log_system("[INVALIDATE_TABLE]: enter invalidate_table, schema:%s, table:%s", schema_name, table_name); + ctc_log_system("[INVALIDATE_TABLE]: enter invalidate_table, schema:%s, table:%s", schema_name, table_name); if(!thd->mdl_context.owns_equal_or_stronger_lock( MDL_key::SCHEMA, schema_name, "", MDL_INTENTION_EXCLUSIVE)) { MDL_request mdl_request; @@ -309,12 +309,12 @@ typename std::enable_if::type MDL_INTENTION_EXCLUSIVE, MDL_EXPLICIT); if (thd->mdl_context.acquire_lock(&mdl_request, CTC_MDL_TIMEOUT)) { assert(thd->killed || thd->is_error()); - tse_log_error("[INVALIDATE_TABLE]: Failed to acquire schema mdl lock of schema:%s and table:%s ", schema_name, table_name); + ctc_log_error("[INVALIDATE_TABLE]: Failed to acquire schema mdl lock of schema:%s and table:%s ", schema_name, table_name); return true; } schema_ticket = mdl_request.ticket; } - tse_log_system("[INVALIDATE_TABLE]: enter invalidate_table table, schema:%s, table:%s", schema_name, table_name); + ctc_log_system("[INVALIDATE_TABLE]: enter invalidate_table table, schema:%s, table:%s", schema_name, table_name); if(!thd->mdl_context.owns_equal_or_stronger_lock( MDL_key::TABLE, schema_name, table_name, MDL_EXCLUSIVE)) { MDL_request mdl_request; @@ -322,7 +322,7 @@ typename std::enable_if::type MDL_EXCLUSIVE, MDL_EXPLICIT); if (thd->mdl_context.acquire_lock(&mdl_request, CTC_MDL_TIMEOUT)) { assert(thd->killed || thd->is_error()); - tse_log_error("[INVALIDATE_TABLE]: Failed to acquire table mdl lock of schema:%s and table:%s ", schema_name, table_name); + ctc_log_error("[INVALIDATE_TABLE]: Failed to acquire table mdl lock of schema:%s and table:%s ", schema_name, table_name); return true; } table_ticket = mdl_request.ticket; @@ -337,7 +337,7 @@ typename std::enable_if::type if (schema_ticket) thd->mdl_context.release_lock(schema_ticket); if (table_ticket) thd->mdl_context.release_lock(table_ticket); - tse_log_system("[INVALIDATE_TABLE]: leave invalidate_table, schema:%s, table:%s", schema_name, table_name); + ctc_log_system("[INVALIDATE_TABLE]: leave invalidate_table, schema:%s, table:%s", schema_name, table_name); return false; } @@ -353,14 +353,14 @@ typename std::enable_if::type invalidate_schema(T *thd, const char *schema_name) { MDL_ticket *schema_ticket = nullptr; - tse_log_system("[INVALIDATE_SCHEMA]:enter invalidate_schema, schema:%s", schema_name); + ctc_log_system("[INVALIDATE_SCHEMA]:enter invalidate_schema, schema:%s", schema_name); MDL_request mdl_request; MDL_REQUEST_INIT(&mdl_request, MDL_key::SCHEMA, schema_name, "", MDL_EXCLUSIVE, MDL_EXPLICIT); if (thd->mdl_context.acquire_lock(&mdl_request, CTC_MDL_TIMEOUT)) { assert(thd->killed || thd->is_error()); - tse_log_error("[INVALIDATE_SCHEMA]: Failed to acquire schema(%s) mdl lock .", schema_name); + ctc_log_error("[INVALIDATE_SCHEMA]: Failed to acquire schema(%s) mdl lock .", schema_name); return true; } schema_ticket = mdl_request.ticket; @@ -376,7 +376,7 @@ typename std::enable_if::type if (schema_ticket) thd->mdl_context.release_lock(schema_ticket); - tse_log_system("leave invalidate_schema, schema:%s", schema_name); + ctc_log_system("leave invalidate_schema, schema:%s", schema_name); return false; } @@ -391,14 +391,14 @@ typename std::enable_if::type invalidate_tablespace(T *thd, const char *tablespace_name) { MDL_ticket *tablespace_ticket = nullptr; - tse_log_system("[INVALIDATE_TABLESPACE]: enter invalidate_tablespace, tablespace_name:%s", tablespace_name); + ctc_log_system("[INVALIDATE_TABLESPACE]: enter invalidate_tablespace, tablespace_name:%s", tablespace_name); MDL_request mdl_request; MDL_REQUEST_INIT(&mdl_request, MDL_key::TABLESPACE, tablespace_name, "", MDL_EXCLUSIVE, MDL_EXPLICIT); if (thd->mdl_context.acquire_lock(&mdl_request, CTC_MDL_TIMEOUT)) { assert(thd->killed || thd->is_error()); - tse_log_error("[INVALIDATE_TABLESPACE]: Failed to acquire tablespace mdl lock of tablespace_name:%s", tablespace_name); + ctc_log_error("[INVALIDATE_TABLESPACE]: Failed to acquire tablespace mdl lock of tablespace_name:%s", tablespace_name); return true; } tablespace_ticket = mdl_request.ticket; @@ -415,7 +415,7 @@ typename std::enable_if::type if (tablespace_ticket) thd->mdl_context.release_lock(tablespace_ticket); - tse_log_system("[INVALIDATE_TABLESPACE]:leave invalidate_tablespace, tablespace_name:%s", tablespace_name); + ctc_log_system("[INVALIDATE_TABLESPACE]:leave invalidate_tablespace, tablespace_name:%s", tablespace_name); return false; } @@ -427,22 +427,22 @@ typename std::enable_if::type template static typename std::enable_if::type - tse_invalidate_mysql_dd_cache_impl(tianchi_handler_t *tch, tse_invalidate_broadcast_request *broadcast_req, int *err_code) { + ctc_invalidate_mysql_dd_cache_impl(ctc_handler_t *tch, ctc_invalidate_broadcast_request *broadcast_req, int *err_code) { UNUSED_PARAM(err_code); // 相同节点不用执行 if(broadcast_req->mysql_inst_id == ctc_instance_id) { - tse_log_note("tse_invalidate_mysql_dd_cache curnode not need execute,mysql_inst_id:%u", broadcast_req->mysql_inst_id); + ctc_log_note("ctc_invalidate_mysql_dd_cache curnode not need execute,mysql_inst_id:%u", broadcast_req->mysql_inst_id); return 0; } bool error = false; T *thd = nullptr; - uint64_t thd_key = tse_get_conn_key(tch->inst_id, tch->thd_id, true); + uint64_t thd_key = ctc_get_conn_key(tch->inst_id, tch->thd_id, true); ctc_init_thd(&thd, thd_key); if (broadcast_req->is_dcl == true) { error = reload_acl_caches(thd, false); - tse_log_system("[TSE_INVALID_DD]: remote invalidate acl cache, mysql_inst_id=%u", broadcast_req->mysql_inst_id); + ctc_log_system("[CTC_INVALID_DD]: remote invalidate acl cache, mysql_inst_id=%u", broadcast_req->mysql_inst_id); } else { invalidate_obj_entry_t *obj = NULL; uint32_t offset = 1; @@ -453,7 +453,7 @@ static typename std::enable_if::type obj = (invalidate_obj_entry_t *)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(invalidate_obj_entry_t), MYF(MY_WME)); assert(obj); memcpy(obj, buff + offset, sizeof(invalidate_obj_entry_t)); - printf("\n[tse_invalidate_mysql_dd_cache_impl] type: %u, first: %s, second: %s\n", obj->type, obj->first, obj->second); fflush(stdout); + printf("\n[ctc_invalidate_mysql_dd_cache_impl] type: %u, first: %s, second: %s\n", obj->type, obj->first, obj->second); fflush(stdout); switch (obj->type) { case T::OBJ_ABSTRACT_TABLE: error = invalidate_table(thd, obj->first, obj->second); @@ -461,10 +461,10 @@ static typename std::enable_if::type break; case T::OBJ_RT_PROCEDURE: case T::OBJ_RT_FUNCTION: - tse_insert_routine(thd, obj); + ctc_insert_routine(thd, obj); break; case T::OBJ_SCHEMA: - tse_insert_schema(thd, obj); + ctc_insert_schema(thd, obj); break; case T::OBJ_TABLESPACE: error = invalidate_tablespace(thd, obj->first); @@ -490,7 +490,7 @@ static typename std::enable_if::type thd->restore_globals(); my_thread_end(); - tse_log_system("[TSE_INVALID_DD]: remote invalidate dd cache success, mysql_inst_id=%u", broadcast_req->mysql_inst_id); + ctc_log_system("[CTC_INVALID_DD]: remote invalidate dd cache success, mysql_inst_id=%u", broadcast_req->mysql_inst_id); return error; } @@ -502,10 +502,10 @@ static void release_routine_and_schema(THD *thd MY_ATTRIBUTE((unused)), bool *er #ifdef METADATA_NORMALIZED static void release_routine_and_schema(THD *thd, bool *error) { - lock_guard lock(m_tse_invalidate_dd_cache_mutex); - auto it_routine = g_tse_invalidate_routine_maps.find(thd); - auto it_schema = g_tse_invalidate_schema_maps.find(thd); - if (it_routine != g_tse_invalidate_routine_maps.end()) { + lock_guard lock(m_ctc_invalidate_dd_cache_mutex); + auto it_routine = g_ctc_invalidate_routine_maps.find(thd); + auto it_schema = g_ctc_invalidate_schema_maps.find(thd); + if (it_routine != g_ctc_invalidate_routine_maps.end()) { vector *invalidate_routine_list = it_routine->second; if (invalidate_routine_list != nullptr) { for (auto invalidate_it : *invalidate_routine_list) { @@ -520,10 +520,10 @@ static void release_routine_and_schema(THD *thd, bool *error) { delete invalidate_routine_list; invalidate_routine_list = nullptr; } - g_tse_invalidate_routine_maps.erase(thd); + g_ctc_invalidate_routine_maps.erase(thd); } - if (it_schema != g_tse_invalidate_schema_maps.end()) { + if (it_schema != g_ctc_invalidate_schema_maps.end()) { vector *invalidate_schema_list = it_schema->second; if (invalidate_schema_list != nullptr) { for (auto invalidate_it : *invalidate_schema_list) { @@ -538,30 +538,30 @@ static void release_routine_and_schema(THD *thd, bool *error) { delete invalidate_schema_list; invalidate_schema_list = nullptr; } - g_tse_invalidate_schema_maps.erase(thd); + g_ctc_invalidate_schema_maps.erase(thd); } } #endif template static typename std::enable_if::type - tse_invalidate_mysql_dd_cache_impl(tianchi_handler_t *tch MY_ATTRIBUTE((unused)), - tse_invalidate_broadcast_request *broadcast_req MY_ATTRIBUTE((unused)), + ctc_invalidate_mysql_dd_cache_impl(ctc_handler_t *tch MY_ATTRIBUTE((unused)), + ctc_invalidate_broadcast_request *broadcast_req MY_ATTRIBUTE((unused)), int *err_code MY_ATTRIBUTE((unused))) { return 0; } -int tse_invalidate_mysql_dd_cache(tianchi_handler_t *tch, tse_invalidate_broadcast_request *broadcast_req, int *err_code) { - return (int)tse_invalidate_mysql_dd_cache_impl(tch, broadcast_req, err_code); +int ctc_invalidate_mysql_dd_cache(ctc_handler_t *tch, ctc_invalidate_broadcast_request *broadcast_req, int *err_code) { + return (int)ctc_invalidate_mysql_dd_cache_impl(tch, broadcast_req, err_code); } -static void tse_init_mdl_request(tse_lock_table_info *lock_info, MDL_request *mdl_request) { +static void ctc_init_mdl_request(ctc_lock_table_info *lock_info, MDL_request *mdl_request) { MDL_key mdl_key; dd::String_type schema_name = dd::String_type(lock_info->db_name); dd::String_type name = dd::String_type(lock_info->table_name); - MDL_key::enum_mdl_namespace tse_mdl_namespace = (MDL_key::enum_mdl_namespace)lock_info->mdl_namespace; + MDL_key::enum_mdl_namespace ctc_mdl_namespace = (MDL_key::enum_mdl_namespace)lock_info->mdl_namespace; - switch (tse_mdl_namespace) { + switch (ctc_mdl_namespace) { case MDL_key::FUNCTION: dd::Function::create_mdl_key(schema_name, name, &mdl_key); MDL_REQUEST_INIT_BY_KEY(mdl_request, &mdl_key, MDL_EXCLUSIVE, MDL_EXPLICIT); @@ -583,25 +583,25 @@ static void tse_init_mdl_request(tse_lock_table_info *lock_info, MDL_request *md MDL_REQUEST_INIT_BY_KEY(mdl_request, &mdl_key, MDL_EXCLUSIVE, MDL_EXPLICIT); break; default: - MDL_REQUEST_INIT(mdl_request, tse_mdl_namespace, lock_info->db_name, lock_info->table_name, + MDL_REQUEST_INIT(mdl_request, ctc_mdl_namespace, lock_info->db_name, lock_info->table_name, MDL_EXCLUSIVE, MDL_EXPLICIT); break; } return; } -static void tse_init_mdl_request(tse_lock_table_info *lock_info, MDL_request *mdl_request, MDL_key::enum_mdl_namespace tse_mdl_namespace) { +static void ctc_init_mdl_request(ctc_lock_table_info *lock_info, MDL_request *mdl_request, MDL_key::enum_mdl_namespace ctc_mdl_namespace) { MDL_key mdl_key; dd::String_type schema_name = dd::String_type(lock_info->db_name); dd::String_type name = dd::String_type(lock_info->table_name); - MDL_REQUEST_INIT(mdl_request, tse_mdl_namespace, lock_info->db_name, lock_info->table_name, + MDL_REQUEST_INIT(mdl_request, ctc_mdl_namespace, lock_info->db_name, lock_info->table_name, (enum_mdl_type)lock_info->mdl_namespace, MDL_EXPLICIT); return; } -int tse_mdl_lock_thd(tianchi_handler_t *tch, tse_lock_table_info *lock_info, int *err_code) { +int ctc_mdl_lock_thd(ctc_handler_t *tch, ctc_lock_table_info *lock_info, int *err_code) { bool is_same_node = (tch->inst_id == ctc_instance_id); - uint64_t mdl_thd_key = tse_get_conn_key(tch->inst_id, tch->thd_id, true); + uint64_t mdl_thd_key = ctc_get_conn_key(tch->inst_id, tch->thd_id, true); if (is_same_node) { return false; @@ -610,29 +610,29 @@ int tse_mdl_lock_thd(tianchi_handler_t *tch, tse_lock_table_info *lock_info, int THD *thd = nullptr; ctc_init_thd(&thd, mdl_thd_key); - MDL_request tse_mdl_request; - tse_init_mdl_request(lock_info, &tse_mdl_request); + MDL_request ctc_mdl_request; + ctc_init_mdl_request(lock_info, &ctc_mdl_request); - if (thd->mdl_context.acquire_lock(&tse_mdl_request, 10)) { + if (thd->mdl_context.acquire_lock(&ctc_mdl_request, 10)) { *err_code = ER_LOCK_WAIT_TIMEOUT; - tse_log_error("[TSE_MDL_LOCK]:Failed to get mdl lock of namespace:%d , db_name:%s and table_name:%s", + ctc_log_error("[CTC_MDL_LOCK]:Failed to get mdl lock of namespace:%d , db_name:%s and table_name:%s", lock_info->mdl_namespace, lock_info->db_name, lock_info->table_name); return true; } - lock_guard lock(m_tse_mdl_ticket_mutex); - auto iter = g_tse_mdl_ticket_maps.find(thd); - map *tse_mdl_ticket_map = nullptr; - if (iter == g_tse_mdl_ticket_maps.end()) { - tse_mdl_ticket_map = new map; - g_tse_mdl_ticket_maps[thd] = tse_mdl_ticket_map; + lock_guard lock(m_ctc_mdl_ticket_mutex); + auto iter = g_ctc_mdl_ticket_maps.find(thd); + map *ctc_mdl_ticket_map = nullptr; + if (iter == g_ctc_mdl_ticket_maps.end()) { + ctc_mdl_ticket_map = new map; + g_ctc_mdl_ticket_maps[thd] = ctc_mdl_ticket_map; } else { - tse_mdl_ticket_map = g_tse_mdl_ticket_maps[thd]; + ctc_mdl_ticket_map = g_ctc_mdl_ticket_maps[thd]; } string mdl_ticket_key; - mdl_ticket_key.assign(((const char*)(tse_mdl_request.key.ptr())), tse_mdl_request.key.length()); + mdl_ticket_key.assign(((const char*)(ctc_mdl_request.key.ptr())), ctc_mdl_request.key.length()); assert(mdl_ticket_key.length() > 0); - tse_mdl_ticket_map->insert(map::value_type(mdl_ticket_key, tse_mdl_request.ticket)); + ctc_mdl_ticket_map->insert(map::value_type(mdl_ticket_key, ctc_mdl_request.ticket)); thd->restore_globals(); my_thread_end(); @@ -640,45 +640,45 @@ int tse_mdl_lock_thd(tianchi_handler_t *tch, tse_lock_table_info *lock_info, int return false; } -void ctc_mdl_unlock_thd_by_ticket(THD* thd, MDL_request *tse_release_request) { - lock_guard lock(m_tse_mdl_ticket_mutex); - auto ticket_map_iter = g_tse_mdl_ticket_maps.find(thd); - if (ticket_map_iter == g_tse_mdl_ticket_maps.end()) { +void ctc_mdl_unlock_thd_by_ticket(THD* thd, MDL_request *ctc_release_request) { + lock_guard lock(m_ctc_mdl_ticket_mutex); + auto ticket_map_iter = g_ctc_mdl_ticket_maps.find(thd); + if (ticket_map_iter == g_ctc_mdl_ticket_maps.end()) { return; } - map *tse_mdl_ticket_map = ticket_map_iter->second; - if (tse_mdl_ticket_map == nullptr) { - g_tse_mdl_ticket_maps.erase(thd); + map *ctc_mdl_ticket_map = ticket_map_iter->second; + if (ctc_mdl_ticket_map == nullptr) { + g_ctc_mdl_ticket_maps.erase(thd); return; } string mdl_ticket_key; - mdl_ticket_key.assign(((const char*)(tse_release_request->key.ptr())), tse_release_request->key.length()); - auto ticket_iter = tse_mdl_ticket_map->find(mdl_ticket_key); - if (ticket_iter == tse_mdl_ticket_map->end()) { + mdl_ticket_key.assign(((const char*)(ctc_release_request->key.ptr())), ctc_release_request->key.length()); + auto ticket_iter = ctc_mdl_ticket_map->find(mdl_ticket_key); + if (ticket_iter == ctc_mdl_ticket_map->end()) { return; } MDL_ticket *ticket = ticket_iter->second; thd->mdl_context.release_all_locks_for_name(ticket); - tse_mdl_ticket_map->erase(mdl_ticket_key); - if (tse_mdl_ticket_map->empty()) { - delete tse_mdl_ticket_map; - g_tse_mdl_ticket_maps.erase(thd); + ctc_mdl_ticket_map->erase(mdl_ticket_key); + if (ctc_mdl_ticket_map->empty()) { + delete ctc_mdl_ticket_map; + g_ctc_mdl_ticket_maps.erase(thd); } } -void tse_mdl_unlock_tables_thd(tianchi_handler_t *tch) { +void ctc_mdl_unlock_tables_thd(ctc_handler_t *tch) { bool is_same_node = (tch->inst_id == ctc_instance_id); - uint64_t mdl_thd_key = tse_get_conn_key(tch->inst_id, tch->thd_id, true); + uint64_t mdl_thd_key = ctc_get_conn_key(tch->inst_id, tch->thd_id, true); if (is_same_node) { return; } - auto iter = g_tse_mdl_thd_map.find(mdl_thd_key); - if (iter == g_tse_mdl_thd_map.end()) { + auto iter = g_ctc_mdl_thd_map.find(mdl_thd_key); + if (iter == g_ctc_mdl_thd_map.end()) { return; } THD* thd = iter->second; @@ -687,31 +687,31 @@ void tse_mdl_unlock_tables_thd(tianchi_handler_t *tch) { my_thread_init(); thd->store_globals(); - lock_guard lock(m_tse_mdl_ticket_mutex); - auto ticket_map_iter = g_tse_mdl_ticket_maps.find(thd); - if (ticket_map_iter == g_tse_mdl_ticket_maps.end()) { + lock_guard lock(m_ctc_mdl_ticket_mutex); + auto ticket_map_iter = g_ctc_mdl_ticket_maps.find(thd); + if (ticket_map_iter == g_ctc_mdl_ticket_maps.end()) { return; } - map *tse_mdl_ticket_map = ticket_map_iter->second; - if (tse_mdl_ticket_map == nullptr) { - g_tse_mdl_ticket_maps.erase(thd); + map *ctc_mdl_ticket_map = ticket_map_iter->second; + if (ctc_mdl_ticket_map == nullptr) { + g_ctc_mdl_ticket_maps.erase(thd); return; } - for (auto iter = tse_mdl_ticket_map->begin(); iter != tse_mdl_ticket_map->end();) { + for (auto iter = ctc_mdl_ticket_map->begin(); iter != ctc_mdl_ticket_map->end();) { MDL_ticket *ticket = iter->second; if (ticket->get_type() == MDL_SHARED_READ_ONLY || ticket->get_type() == MDL_SHARED_NO_READ_WRITE) { thd->mdl_context.release_lock(ticket); - tse_mdl_ticket_map->erase(iter++); + ctc_mdl_ticket_map->erase(iter++); } else { iter++; } } - if (tse_mdl_ticket_map->empty()) { - delete tse_mdl_ticket_map; - g_tse_mdl_ticket_maps.erase(thd); + if (ctc_mdl_ticket_map->empty()) { + delete ctc_mdl_ticket_map; + g_ctc_mdl_ticket_maps.erase(thd); } thd->restore_globals(); @@ -720,16 +720,16 @@ void tse_mdl_unlock_tables_thd(tianchi_handler_t *tch) { return; } -void tse_mdl_unlock_thd(tianchi_handler_t *tch, tse_lock_table_info *lock_info) { +void ctc_mdl_unlock_thd(ctc_handler_t *tch, ctc_lock_table_info *lock_info) { bool is_same_node = (tch->inst_id == ctc_instance_id); - uint64_t mdl_thd_key = tse_get_conn_key(tch->inst_id, tch->thd_id, true); + uint64_t mdl_thd_key = ctc_get_conn_key(tch->inst_id, tch->thd_id, true); if (is_same_node) { return; } - auto iter = g_tse_mdl_thd_map.find(mdl_thd_key); - if (iter == g_tse_mdl_thd_map.end()) { + auto iter = g_ctc_mdl_thd_map.find(mdl_thd_key); + if (iter == g_ctc_mdl_thd_map.end()) { return; } THD* thd = iter->second; @@ -737,33 +737,33 @@ void tse_mdl_unlock_thd(tianchi_handler_t *tch, tse_lock_table_info *lock_info) my_thread_init(); thd->store_globals(); - MDL_request tse_release_request; - tse_init_mdl_request(lock_info, &tse_release_request); - ctc_mdl_unlock_thd_by_ticket(thd, &tse_release_request); + MDL_request ctc_release_request; + ctc_init_mdl_request(lock_info, &ctc_release_request); + ctc_mdl_unlock_thd_by_ticket(thd, &ctc_release_request); thd->restore_globals(); my_thread_end(); return; } -int close_tse_mdl_thd(uint32_t thd_id, uint32_t mysql_inst_id) { +int close_ctc_mdl_thd(uint32_t thd_id, uint32_t mysql_inst_id) { if (thd_id == 0) { if ((uint16_t)mysql_inst_id == (uint16_t)CANTIAN_DOWN_MASK) { /* 清理整个参天节点相关的THD */ - tse_log_system("[TSE_MDL_THD]:Close All MDL THD on bad node by cantian_instance_id:%u", + ctc_log_system("[CTC_MDL_THD]:Close All MDL THD on bad node by cantian_instance_id:%u", (uint16_t)(mysql_inst_id >> 16)); - release_tse_mdl_thd_by_cantian_id((uint16_t)(mysql_inst_id >> 16)); + release_ctc_mdl_thd_by_cantian_id((uint16_t)(mysql_inst_id >> 16)); } else { /* 清理整个mysqld节点相关的THD */ - tse_log_system("[TSE_MDL_THD]:Close All MDL THD by ctc_instance_id:%u", mysql_inst_id); - release_tse_mdl_thd_by_inst_id(mysql_inst_id); + ctc_log_system("[CTC_MDL_THD]:Close All MDL THD by ctc_instance_id:%u", mysql_inst_id); + release_ctc_mdl_thd_by_inst_id(mysql_inst_id); } } else { /* 通过把mysql_inst_id左移32位 与 thd_id拼接在一起 用来唯一标识一个THD */ - uint64_t mdl_thd_key = tse_get_conn_key(mysql_inst_id, thd_id, true); - tse_log_note("[TSE_MDL_THD]: Close THD by conn_id=%u, ctc_instance_id=%u, proxy_conn_map_key=%lu", + uint64_t mdl_thd_key = ctc_get_conn_key(mysql_inst_id, thd_id, true); + ctc_log_note("[CTC_MDL_THD]: Close THD by conn_id=%u, ctc_instance_id=%u, proxy_conn_map_key=%lu", thd_id, mysql_inst_id, mdl_thd_key); - release_tse_mdl_thd_by_key(mdl_thd_key); + release_ctc_mdl_thd_by_key(mdl_thd_key); } return 0; } @@ -827,10 +827,10 @@ static void ctc_get_set_var_item(THD* new_thd, sys_var* sysvar, Item** res MY_AT #ifdef FEATURE_X_FOR_MYSQL_26 static void ctc_set_var_type(uint32_t option, set_var *var) { - if ((option & TSE_SET_VARIABLE_PERSIST) > 0) { + if ((option & CTC_SET_VARIABLE_PERSIST) > 0) { var->type = OPT_PERSIST; } - if ((option & TSE_SET_VARIABLE_PERSIST_ONLY) > 0) { + if ((option & CTC_SET_VARIABLE_PERSIST_ONLY) > 0) { var->type = OPT_PERSIST_ONLY; } } @@ -844,7 +844,7 @@ static void ctc_init_thd_priv(THD** thd, Sctx_ptr *ctx) { new_thd->store_globals(); lex_start(new_thd); new_thd->security_context()->skip_grants(); - new_thd->set_query("tse_mdl_thd_notify", 18); + new_thd->set_query("ctc_mdl_thd_notify", 18); const std::vector priv_list = { "ENCRYPTION_KEY_ADMIN", "ROLE_ADMIN", "SYSTEM_VARIABLES_ADMIN", @@ -864,7 +864,7 @@ static void ctc_init_thd_priv(THD** thd, Sctx_ptr *ctx) { (*thd) = new_thd; } -int ctc_set_sys_var(tse_ddl_broadcast_request *broadcast_req) { +int ctc_set_sys_var(ctc_ddl_broadcast_request *broadcast_req) { Sctx_ptr ctx; THD *new_thd = nullptr; ctc_init_thd_priv(&new_thd, &ctx); @@ -878,14 +878,14 @@ int ctc_set_sys_var(tse_ddl_broadcast_request *broadcast_req) { string var_value = broadcast_req->sql_str; List tmp_var_list; - bool is_default_value = ((broadcast_req->options) & (TSE_SET_VARIABLE_TO_DEFAULT)) > 0; - bool is_null_value = ((broadcast_req->options) & (TSE_SET_VARIABLE_TO_NULL)) > 0; + bool is_default_value = ((broadcast_req->options) & (CTC_SET_VARIABLE_TO_DEFAULT)) > 0; + bool is_null_value = ((broadcast_req->options) & (CTC_SET_VARIABLE_TO_NULL)) > 0; bool var_is_int = ((broadcast_req->user_ip[0] & 1) != 0); enum_var_type type = OPT_GLOBAL; - if ((broadcast_req->options & TSE_SET_VARIABLE_PERSIST) > 0) { + if ((broadcast_req->options & CTC_SET_VARIABLE_PERSIST) > 0) { type = OPT_PERSIST; } - if ((broadcast_req->options & TSE_SET_VARIABLE_PERSIST_ONLY) > 0) { + if ((broadcast_req->options & CTC_SET_VARIABLE_PERSIST_ONLY) > 0) { type = OPT_PERSIST_ONLY; } LEX_CSTRING base_name = {nullptr, 0}; @@ -896,7 +896,7 @@ int ctc_set_sys_var(tse_ddl_broadcast_request *broadcast_req) { sysvar = intern_find_sys_var(var_name.c_str(), var_name.length()); int ret = -1; if (sysvar == nullptr) { - tse_log_error("[ctc_set_sys_var]:sysvar is nullptr and var_name : %s", var_name.c_str()); + ctc_log_error("[ctc_set_sys_var]:sysvar is nullptr and var_name : %s", var_name.c_str()); return ret; } ctc_get_set_var_item(new_thd, sysvar, &res, var_value, is_null_value, var_is_int); @@ -918,7 +918,7 @@ int ctc_set_sys_var(tse_ddl_broadcast_request *broadcast_req) { tmp_var_list.push_back(var); ret = sql_set_variables(new_thd, &tmp_var_list, false); if (ret != 0) { - tse_log_error("[ctc_set_sys_var]:set global opt faili;var_name : %s, var_value: %s", + ctc_log_error("[ctc_set_sys_var]:set global opt faili;var_name : %s, var_value: %s", var_name.c_str(), var_value.c_str()); return ret; } @@ -937,12 +937,12 @@ int ctc_set_sys_var(tse_ddl_broadcast_request *broadcast_req) { return ret; } -int tse_ddl_execute_lock_tables_by_req(tianchi_handler_t *tch, tse_lock_table_info *lock_info, int *err_code) { +int ctc_ddl_execute_lock_tables_by_req(ctc_handler_t *tch, ctc_lock_table_info *lock_info, int *err_code) { // unlock tables before locking tables - tse_mdl_unlock_tables_thd(tch); + ctc_mdl_unlock_tables_thd(tch); bool is_same_node = (tch->inst_id == ctc_instance_id); - uint64_t mdl_thd_key = tse_get_conn_key(tch->inst_id, tch->thd_id, true); + uint64_t mdl_thd_key = ctc_get_conn_key(tch->inst_id, tch->thd_id, true); if (is_same_node) { return false; @@ -951,29 +951,29 @@ int tse_ddl_execute_lock_tables_by_req(tianchi_handler_t *tch, tse_lock_table_in THD *thd = nullptr; ctc_init_thd(&thd, mdl_thd_key); - MDL_request tse_mdl_request; - tse_init_mdl_request(lock_info, &tse_mdl_request, MDL_key::TABLE); + MDL_request ctc_mdl_request; + ctc_init_mdl_request(lock_info, &ctc_mdl_request, MDL_key::TABLE); - if (thd->mdl_context.acquire_lock(&tse_mdl_request, 10)) { + if (thd->mdl_context.acquire_lock(&ctc_mdl_request, 10)) { *err_code = ER_LOCK_WAIT_TIMEOUT; - tse_log_error("[TSE_MDL_LOCK]:Get mdl lock fail. namespace:%d, db_name:%s, table_name:%s", + ctc_log_error("[CTC_MDL_LOCK]:Get mdl lock fail. namespace:%d, db_name:%s, table_name:%s", lock_info->mdl_namespace, lock_info->db_name, lock_info->table_name); return true; } - lock_guard lock(m_tse_mdl_ticket_mutex); - auto iter = g_tse_mdl_ticket_maps.find(thd); - map *tse_mdl_ticket_map = nullptr; - if (iter == g_tse_mdl_ticket_maps.end()) { - tse_mdl_ticket_map = new map; - g_tse_mdl_ticket_maps[thd] = tse_mdl_ticket_map; + lock_guard lock(m_ctc_mdl_ticket_mutex); + auto iter = g_ctc_mdl_ticket_maps.find(thd); + map *ctc_mdl_ticket_map = nullptr; + if (iter == g_ctc_mdl_ticket_maps.end()) { + ctc_mdl_ticket_map = new map; + g_ctc_mdl_ticket_maps[thd] = ctc_mdl_ticket_map; } else { - tse_mdl_ticket_map = g_tse_mdl_ticket_maps[thd]; + ctc_mdl_ticket_map = g_ctc_mdl_ticket_maps[thd]; } string mdl_ticket_key; - mdl_ticket_key.assign(((const char*)(tse_mdl_request.key.ptr())), tse_mdl_request.key.length()); + mdl_ticket_key.assign(((const char*)(ctc_mdl_request.key.ptr())), ctc_mdl_request.key.length()); assert(mdl_ticket_key.length() > 0); - tse_mdl_ticket_map->insert(map::value_type(mdl_ticket_key, tse_mdl_request.ticket)); + ctc_mdl_ticket_map->insert(map::value_type(mdl_ticket_key, ctc_mdl_request.ticket)); thd->restore_globals(); my_thread_end(); diff --git a/storage/tianchi/ctc_meta_data.h b/storage/ctc/ctc_meta_data.h similarity index 66% rename from storage/tianchi/ctc_meta_data.h rename to storage/ctc/ctc_meta_data.h index 2da8adf..92fd986 100644 --- a/storage/tianchi/ctc_meta_data.h +++ b/storage/ctc/ctc_meta_data.h @@ -19,18 +19,18 @@ #define __CTC_META_DATA_H__ #include -#include "tse_srv.h" +#include "ctc_srv.h" #pragma GCC visibility push(default) #define CTC_MDL_TIMEOUT (31536000) -int close_tse_mdl_thd(uint32_t thd_id, uint32_t mysql_inst_id); -int tse_mdl_lock_thd(tianchi_handler_t *tch, tse_lock_table_info *lock_info, int *err_code); -void tse_mdl_unlock_thd(tianchi_handler_t *tch, tse_lock_table_info *lock_info); -int ctc_set_sys_var(tse_ddl_broadcast_request *broadcast_req); -int tse_ddl_execute_lock_tables_by_req(tianchi_handler_t *tch, tse_lock_table_info *lock_info, int *err_code); -void tse_mdl_unlock_tables_thd(tianchi_handler_t *tch); +int close_ctc_mdl_thd(uint32_t thd_id, uint32_t mysql_inst_id); +int ctc_mdl_lock_thd(ctc_handler_t *tch, ctc_lock_table_info *lock_info, int *err_code); +void ctc_mdl_unlock_thd(ctc_handler_t *tch, ctc_lock_table_info *lock_info); +int ctc_set_sys_var(ctc_ddl_broadcast_request *broadcast_req); +int ctc_ddl_execute_lock_tables_by_req(ctc_handler_t *tch, ctc_lock_table_info *lock_info, int *err_code); +void ctc_mdl_unlock_tables_thd(ctc_handler_t *tch); #pragma GCC visibility pop diff --git a/storage/tianchi/tse_mysql_proxy.cc b/storage/ctc/ctc_mysql_proxy.cc similarity index 69% rename from storage/tianchi/tse_mysql_proxy.cc rename to storage/ctc/ctc_mysql_proxy.cc index 4695d5d..8141c5f 100644 --- a/storage/tianchi/tse_mysql_proxy.cc +++ b/storage/ctc/ctc_mysql_proxy.cc @@ -25,12 +25,12 @@ #include "my_md5_size.h" #include "mysql.h" #include "sql/mysqld.h" // mysql_port, my_localhost -#include "tse_log.h" -#include "tse_srv.h" -#include "tse_util.h" -#include "ha_tse.h" +#include "ctc_log.h" +#include "ctc_srv.h" +#include "ctc_util.h" +#include "ha_ctc.h" #include "ctc_meta_data.h" -#include "tse_proxy_util.h" +#include "ctc_proxy_util.h" #include "sql/sql_table.h" #include "my_dir.h" #include "sql/sql_handler.h" @@ -48,22 +48,22 @@ #include "sql/auth/auth_common.h" #include "sql/sys_vars_shared.h" // intern_find_sys_var #include "sql/sql_lex.h" // lex_start/lex_end -#include "sql/handler.h" // ha_tse_commit +#include "sql/handler.h" // ha_ctc_commit using namespace std; -struct ctc_mysql_conn { +struct ctc_mysql_conn_info { MYSQL* conn; set> table_lock_info; // 连接上已存在的表锁 (db, table) bool has_explicit_table_lock; // 连接上是否存在显式的表锁 uint32_t name_locks; // 连接上持有的命名锁数量 }; -static map g_mysql_conn_map; -static mutex m_tse_mysql_proxy_mutex; +static map g_mysql_conn_map; +static mutex m_ctc_mysql_proxy_mutex; -static ctc_mysql_conn* init_ctc_mysql_conn(MYSQL* curr_conn) { - ctc_mysql_conn *ctc_conn_info = new ctc_mysql_conn(); +static ctc_mysql_conn_info* init_ctc_mysql_conn(MYSQL* curr_conn) { + ctc_mysql_conn_info *ctc_conn_info = new ctc_mysql_conn_info(); ctc_conn_info->conn = curr_conn; ctc_conn_info->table_lock_info = set>(); ctc_conn_info->has_explicit_table_lock = false; @@ -72,7 +72,7 @@ static ctc_mysql_conn* init_ctc_mysql_conn(MYSQL* curr_conn) { } static void set_explicit_table_lock(uint64_t conn_map_key, uint8_t sql_command) { - lock_guard lock(m_tse_mysql_proxy_mutex); + lock_guard lock(m_ctc_mysql_proxy_mutex); if (sql_command == SQLCOM_LOCK_TABLES) { g_mysql_conn_map[conn_map_key]->has_explicit_table_lock = true; } else if (sql_command == SQLCOM_UNLOCK_TABLES) { @@ -81,48 +81,48 @@ static void set_explicit_table_lock(uint64_t conn_map_key, uint8_t sql_command) return; } -int tse_select_db(MYSQL *curr_conn, const char *db) { +int ctc_select_db(MYSQL *curr_conn, const char *db) { if (CM_IS_EMPTY_STR(db)) { return 0; } int ret = mysql_ping(curr_conn); if (ret != 0) { - tse_log_error("tse_select_db: mysql server has gone. db:%s error_code:%d, reconnecting.", db, ret); + ctc_log_error("ctc_select_db: mysql server has gone. db:%s error_code:%d, reconnecting.", db, ret); } ret = mysql_select_db(curr_conn, db); if (ret != 0) { - tse_log_error("select db:%s failed,ret:%d, error_code:%d,desc:%s", db, ret, + ctc_log_error("select db:%s failed,ret:%d, error_code:%d,desc:%s", db, ret, mysql_errno(curr_conn), mysql_error(curr_conn)); return mysql_errno(curr_conn); } return 0; } -static void tse_drop_proxy_user(MYSQL *agent_conn, const string &proxy_user_name) +static void ctc_drop_proxy_user(MYSQL *agent_conn, const string &proxy_user_name) { string drop_user_sql = "drop user if exists '" + proxy_user_name + "';"; - if (tse_mysql_query(agent_conn, drop_user_sql.c_str())) { - tse_log_error("tse_drop_proxy_user failed, drop user=%s, sql=%s, err_code=%d, err_msg=%s", + if (ctc_mysql_query(agent_conn, drop_user_sql.c_str())) { + ctc_log_error("ctc_drop_proxy_user failed, drop user=%s, sql=%s, err_code=%d, err_msg=%s", proxy_user_name.c_str(), drop_user_sql.c_str(), mysql_errno(agent_conn), mysql_error(agent_conn)); assert(0); } } -static int tse_create_proxy_user(MYSQL *agent_conn, const char*user_name, const char*user_ip, +static int ctc_create_proxy_user(MYSQL *agent_conn, const char*user_name, const char*user_ip, string &proxy_user_name, string &proxy_user_password) { string create_user_sql = "CREATE USER '" + proxy_user_name + \ "' IDENTIFIED WITH 'mysql_native_password' BY RANDOM PASSWORD;"; - int ret = tse_mysql_query(agent_conn, create_user_sql.c_str()); // ret: success: 0, fail: 1 + int ret = ctc_mysql_query(agent_conn, create_user_sql.c_str()); // ret: success: 0, fail: 1 int err_code = mysql_errno(agent_conn); char err_msg[ERROR_MESSAGE_LEN] = {0}; strncpy(err_msg, mysql_error(agent_conn), ERROR_MESSAGE_LEN - 1); if (ret != 0 || err_code != 0) { - tse_log_error("tse_create_proxy_user failed to create user %s, " + ctc_log_error("ctc_create_proxy_user failed to create user %s, " "sql=%s, ret=%d, err_code=%d, err_msg=%s", proxy_user_name.c_str(), create_user_sql.c_str(), ret, err_code, err_msg); return err_code; @@ -130,15 +130,15 @@ static int tse_create_proxy_user(MYSQL *agent_conn, const char*user_name, const MYSQL_RES *result = mysql_store_result(agent_conn); if (result == nullptr) { - tse_log_error("tse_create_proxy_user store result failed, user name:%s", user_name); - tse_drop_proxy_user(agent_conn, proxy_user_name); + ctc_log_error("ctc_create_proxy_user store result failed, user name:%s", user_name); + ctc_drop_proxy_user(agent_conn, proxy_user_name); return -1; } MYSQL_ROW row = mysql_fetch_row(result); if (row == nullptr) { - tse_log_error("tse_create_proxy_user mysql_fetch_row failed, user name:%s", user_name); - tse_drop_proxy_user(agent_conn, proxy_user_name); + ctc_log_error("ctc_create_proxy_user mysql_fetch_row failed, user name:%s", user_name); + ctc_drop_proxy_user(agent_conn, proxy_user_name); return -1; } @@ -146,29 +146,29 @@ static int tse_create_proxy_user(MYSQL *agent_conn, const char*user_name, const mysql_free_result(result); string username(user_name); - username = tse_escape_single_quotation_str(username); + username = ctc_escape_single_quotation_str(username); string grant_user_sql = "grant proxy on '" + username + "'@'" + string(user_ip) + "' to '" + proxy_user_name + "';"; - ret = tse_mysql_query(agent_conn, grant_user_sql.c_str()); + ret = ctc_mysql_query(agent_conn, grant_user_sql.c_str()); err_code = mysql_errno(agent_conn); strncpy(err_msg, mysql_error(agent_conn), ERROR_MESSAGE_LEN - 1); if (ret != 0 || err_code != 0) { - tse_log_error("tse_create_proxy_user failed to grant %s to %s, " + ctc_log_error("ctc_create_proxy_user failed to grant %s to %s, " "sql=%s, ret=%d, err_code=%d, err_msg=%s", user_name, proxy_user_name.c_str(), grant_user_sql.c_str(), ret, err_code, err_msg); - tse_drop_proxy_user(agent_conn, proxy_user_name); + ctc_drop_proxy_user(agent_conn, proxy_user_name); return err_code; } return 0; } -static int tse_init_proxy_client(MYSQL *&curr_conn, uint64_t conn_map_key, +static int ctc_init_proxy_client(MYSQL *&curr_conn, uint64_t conn_map_key, const char *user_name, const char *user_ip) { MYSQL *agent_conn = NULL; - int ret = tse_init_agent_client(agent_conn); + int ret = ctc_init_agent_client(agent_conn); if (ret != 0) { return ret; } @@ -176,10 +176,10 @@ static int tse_init_proxy_client(MYSQL *&curr_conn, uint64_t conn_map_key, SENSI_INFO string proxy_user_password; string proxy_user_name = "proxy_" + std::to_string(conn_map_key); - ret = tse_create_proxy_user(agent_conn, user_name, user_ip, proxy_user_name, proxy_user_password); + ret = ctc_create_proxy_user(agent_conn, user_name, user_ip, proxy_user_name, proxy_user_password); if (ret != 0) { - tse_log_error("tse_init_proxy_client tse_create_proxy_user failed, ret=%d", ret); - tse_close_mysql_conn(&agent_conn); + ctc_log_error("ctc_init_proxy_client ctc_create_proxy_user failed, ret=%d", ret); + ctc_close_mysql_conn(&agent_conn); return ret; } @@ -187,28 +187,28 @@ static int tse_init_proxy_client(MYSQL *&curr_conn, uint64_t conn_map_key, if (strcmp(user_ip, "%") != 0) { con_host = user_ip; } - ret = tse_mysql_conn(curr_conn, con_host, proxy_user_name.c_str(), proxy_user_password.c_str()); + ret = ctc_mysql_conn(curr_conn, con_host, proxy_user_name.c_str(), proxy_user_password.c_str()); proxy_user_password.clear(); if (ret) { - tse_log_error("tse_init_proxy_client tse_mysql_conn failed, user=%s, err_code=%d, err_msg=%s.", + ctc_log_error("ctc_init_proxy_client ctc_mysql_conn failed, user=%s, err_code=%d, err_msg=%s.", proxy_user_name.c_str(), mysql_errno(curr_conn), mysql_error(curr_conn)); - tse_close_mysql_conn(&curr_conn); + ctc_close_mysql_conn(&curr_conn); } - tse_drop_proxy_user(agent_conn, proxy_user_name); - tse_close_mysql_conn(&agent_conn); + ctc_drop_proxy_user(agent_conn, proxy_user_name); + ctc_close_mysql_conn(&agent_conn); return ret; } static void get_ctc_mysql_conn(uint64_t conn_map_key, MYSQL *&curr_conn) { - lock_guard lock(m_tse_mysql_proxy_mutex); + lock_guard lock(m_ctc_mysql_proxy_mutex); auto iter = g_mysql_conn_map.find(conn_map_key); if (iter != g_mysql_conn_map.end()) { curr_conn = iter->second->conn; } } -int tse_init_mysql_client(uint64_t conn_map_key, const char *db, MYSQL *&curr_conn, +int ctc_init_mysql_client(uint64_t conn_map_key, const char *db, MYSQL *&curr_conn, const char *user_name, const char *user_ip, bool use_proxy) { if (opt_noacl && strcmp(user_name, "skip-grants user") == 0) { @@ -219,52 +219,52 @@ int tse_init_mysql_client(uint64_t conn_map_key, const char *db, MYSQL *&curr_co int ret = 0; if (curr_conn != NULL) { - ret = tse_select_db(curr_conn, db); + ret = ctc_select_db(curr_conn, db); if (ret == 0) { return 0; } - tse_log_error("tse_init_mysql_client select db failed, err_code=%d, err_msg=%s.", + ctc_log_error("ctc_init_mysql_client select db failed, err_code=%d, err_msg=%s.", mysql_errno(curr_conn), mysql_error(curr_conn)); - lock_guard lock(m_tse_mysql_proxy_mutex); + lock_guard lock(m_ctc_mysql_proxy_mutex); delete g_mysql_conn_map[conn_map_key]; g_mysql_conn_map.erase(conn_map_key); - tse_close_mysql_conn(&curr_conn); + ctc_close_mysql_conn(&curr_conn); } assert(curr_conn == nullptr); while(!mysqld_server_started) { - tse_log_system("[TSE_INIT]:tse_init_mysql_client wait mysql server start!!!!"); + ctc_log_system("[CTC_INIT]:ctc_init_mysql_client wait mysql server start!!!!"); sleep(1); } if (use_proxy) { - ret = tse_init_proxy_client(curr_conn, conn_map_key, user_name, user_ip); + ret = ctc_init_proxy_client(curr_conn, conn_map_key, user_name, user_ip); } else { - ret = tse_init_agent_client(curr_conn); + ret = ctc_init_agent_client(curr_conn); } if (ret) { - tse_log_error("init mysql client failed ret=%d", ret); + ctc_log_error("init mysql client failed ret=%d", ret); return ret; } - ret = tse_mysql_query(curr_conn, "set lock_wait_timeout = 1;"); + ret = ctc_mysql_query(curr_conn, "set lock_wait_timeout = 1;"); if (ret != 0 || mysql_errno(curr_conn) != 0) { - tse_log_error("set lock_wait_timeout = 1 failed. err_code:%u, err_msg:%s", + ctc_log_error("set lock_wait_timeout = 1 failed. err_code:%u, err_msg:%s", mysql_errno(curr_conn), mysql_error(curr_conn)); } - ret = tse_select_db(curr_conn, db); + ret = ctc_select_db(curr_conn, db); if (ret != 0) { - tse_log_error("tse_init_mysql_client select db failed, err_code=%d, err_msg=%s.", + ctc_log_error("ctc_init_mysql_client select db failed, err_code=%d, err_msg=%s.", mysql_errno(curr_conn), mysql_error(curr_conn)); - tse_close_mysql_conn(&curr_conn); + ctc_close_mysql_conn(&curr_conn); return ret; } { - lock_guard lock(m_tse_mysql_proxy_mutex); + lock_guard lock(m_ctc_mysql_proxy_mutex); g_mysql_conn_map[conn_map_key] = init_ctc_mysql_conn(curr_conn); } return 0; @@ -272,19 +272,19 @@ int tse_init_mysql_client(uint64_t conn_map_key, const char *db, MYSQL *&curr_co static void close_mysql_conn_by_key(uint64_t conn_map_key) { /* 存在并发场景 map操作加锁 */ - lock_guard lock(m_tse_mysql_proxy_mutex); + lock_guard lock(m_ctc_mysql_proxy_mutex); auto iter = g_mysql_conn_map.find(conn_map_key); if (iter == g_mysql_conn_map.end()) { - tse_log_system("[TSE_CLOSE_CONN]: Connection has already been closed or not exists (key=%lu)", conn_map_key); + ctc_log_system("[CTC_CLOSE_CONN]: Connection has already been closed or not exists (key=%lu)", conn_map_key); return; } MYSQL *mysql_conn = iter->second->conn; - tse_close_mysql_conn(&mysql_conn); + ctc_close_mysql_conn(&mysql_conn); uint32_t name_locks = sub_g_name_locks(iter->second->name_locks); - tse_log_system("[TSE_CLOSE_CONN]: Close connect by key=%lu, current global name locks=%u", conn_map_key, name_locks); + ctc_log_system("[CTC_CLOSE_CONN]: Close connect by key=%lu, current global name locks=%u", conn_map_key, name_locks); delete g_mysql_conn_map[conn_map_key]; g_mysql_conn_map.erase(conn_map_key); @@ -292,26 +292,26 @@ static void close_mysql_conn_by_key(uint64_t conn_map_key) { static MYSQL* get_mysql_conn_by_key(uint64_t conn_map_key) { /* 存在并发场景 map操作加锁 */ - lock_guard lock(m_tse_mysql_proxy_mutex); + lock_guard lock(m_ctc_mysql_proxy_mutex); auto iter = g_mysql_conn_map.find(conn_map_key); if (iter == g_mysql_conn_map.end()) { - tse_log_system("get mysql Connection has already been closed or not exists (key=%lu)", conn_map_key); + ctc_log_system("get mysql Connection has already been closed or not exists (key=%lu)", conn_map_key); return NULL; } return iter->second->conn; } static void close_mysql_conn_by_inst_id(uint32_t inst_id, bool by_mysql_inst) { - lock_guard lock(m_tse_mysql_proxy_mutex); + lock_guard lock(m_ctc_mysql_proxy_mutex); for (auto iter = g_mysql_conn_map.begin(); iter != g_mysql_conn_map.end(); ) { - uint32_t find_id = by_mysql_inst ? tse_get_inst_id_from_conn_key(iter->first) : - tse_get_cantian_id_from_conn_key(iter->first); + uint32_t find_id = by_mysql_inst ? ctc_get_inst_id_from_conn_key(iter->first) : + ctc_get_cantian_id_from_conn_key(iter->first); if (find_id == inst_id) { MYSQL *mysql_conn = iter->second->conn; - tse_close_mysql_conn(&mysql_conn); + ctc_close_mysql_conn(&mysql_conn); uint32_t name_locks = sub_g_name_locks(iter->second->name_locks); - tse_log_system("[TSE_CLOSE_CONN]: Close connects by mysql_id/cantian_id = %d, instance_id=%u, key=%lu," + ctc_log_system("[CTC_CLOSE_CONN]: Close connects by mysql_id/cantian_id = %d, instance_id=%u, key=%lu," "current global name locks=%u", by_mysql_inst, inst_id, iter->first, name_locks); delete g_mysql_conn_map[iter->first]; @@ -327,33 +327,33 @@ static inline bool is_backup_lock_op(uint8_t sql_command) { sql_command == SQLCOM_UNLOCK_INSTANCE; } -static inline bool tse_use_proxy(uint8_t sql_command) { - bool is_slave = tse_get_cluster_role() == (int32_t)dis_cluster_role::STANDBY; - tse_log_system("[Disaster Recovery] is_slave: %d, sql_command=%d, use_proxy:%d", is_slave, sql_command, (!is_slave && !is_backup_lock_op(sql_command))); +static inline bool ctc_use_proxy(uint8_t sql_command) { + bool is_slave = ctc_get_cluster_role() == (int32_t)dis_cluster_role::STANDBY; + ctc_log_system("[Disaster Recovery] is_slave: %d, sql_command=%d, use_proxy:%d", is_slave, sql_command, (!is_slave && !is_backup_lock_op(sql_command))); return !is_slave && !is_backup_lock_op(sql_command); } extern uint32_t ctc_instance_id; -__attribute__((visibility("default"))) int tse_execute_rewrite_open_conn(uint32_t thd_id, tse_ddl_broadcast_request *broadcast_req) { +__attribute__((visibility("default"))) int ctc_execute_rewrite_open_conn(uint32_t thd_id, ctc_ddl_broadcast_request *broadcast_req) { // 相同节点不用执行 if (broadcast_req->mysql_inst_id == ctc_instance_id) { return 0; } - bool use_proxy = tse_use_proxy(broadcast_req->sql_command); - uint64_t conn_map_key = tse_get_conn_key(broadcast_req->mysql_inst_id, thd_id, use_proxy); + bool use_proxy = ctc_use_proxy(broadcast_req->sql_command); + uint64_t conn_map_key = ctc_get_conn_key(broadcast_req->mysql_inst_id, thd_id, use_proxy); MYSQL *curr_conn = NULL; - int ret = tse_init_mysql_client(conn_map_key, broadcast_req->db_name, curr_conn, + int ret = ctc_init_mysql_client(conn_map_key, broadcast_req->db_name, curr_conn, broadcast_req->user_name, broadcast_req->user_ip, use_proxy); if (ret != 0) { broadcast_req->err_code = ret; - tse_log_error("[TSE_REWRITE_CONN]:init_mysql_client failed, ret:%d, conn_map_key:%lu, sql:%s", ret, conn_map_key, + ctc_log_error("[CTC_REWRITE_CONN]:init_mysql_client failed, ret:%d, conn_map_key:%lu, sql:%s", ret, conn_map_key, sql_without_plaintext_password(broadcast_req).c_str()); return ret; } - tse_log_system("[TSE_REWRITE_CONN]: remote open conn for sql=%s, user_name:%s, success, mysql_inst_id=%u," + ctc_log_system("[CTC_REWRITE_CONN]: remote open conn for sql=%s, user_name:%s, success, mysql_inst_id=%u," "conn_map_key:%lu", sql_without_plaintext_password(broadcast_req).c_str(), broadcast_req->user_name, broadcast_req->mysql_inst_id, conn_map_key); @@ -361,10 +361,10 @@ __attribute__((visibility("default"))) int tse_execute_rewrite_open_conn(uint32_ return 0; } -__attribute__((visibility("default"))) int tse_ddl_execute_update(uint32_t thd_id, tse_ddl_broadcast_request *broadcast_req, bool *allow_fail) { +__attribute__((visibility("default"))) int ctc_ddl_execute_update(uint32_t thd_id, ctc_ddl_broadcast_request *broadcast_req, bool *allow_fail) { // 相同节点不用执行 if(broadcast_req->mysql_inst_id == ctc_instance_id) { - tse_log_note("tse_ddl_execute_update curnode not need execute,mysql_inst_id:%u", broadcast_req->mysql_inst_id); + ctc_log_note("ctc_ddl_execute_update curnode not need execute,mysql_inst_id:%u", broadcast_req->mysql_inst_id); return 0; } @@ -372,19 +372,19 @@ __attribute__((visibility("default"))) int tse_ddl_execute_update(uint32_t thd_i if (is_meta_normalization && broadcast_req->sql_command != SQLCOM_SET_OPTION) { return 0; } else if (is_meta_normalization && broadcast_req->sql_command == SQLCOM_SET_OPTION - && (broadcast_req->options & TSE_SET_VARIABLE_WITH_SUBSELECT) == 0){ + && (broadcast_req->options & CTC_SET_VARIABLE_WITH_SUBSELECT) == 0){ return ctc_set_sys_var(broadcast_req); } - bool use_proxy = tse_use_proxy(broadcast_req->sql_command); - uint64_t conn_map_key = tse_get_conn_key(broadcast_req->mysql_inst_id, thd_id, use_proxy); + bool use_proxy = ctc_use_proxy(broadcast_req->sql_command); + uint64_t conn_map_key = ctc_get_conn_key(broadcast_req->mysql_inst_id, thd_id, use_proxy); MYSQL *curr_conn = NULL; - int ret = tse_init_mysql_client(conn_map_key, broadcast_req->db_name, curr_conn, + int ret = ctc_init_mysql_client(conn_map_key, broadcast_req->db_name, curr_conn, broadcast_req->user_name, broadcast_req->user_ip, use_proxy); if (ret != 0) { broadcast_req->err_code = ret; - tse_log_error("[TSE_DDL]:init_mysql_client failed, ret:%d, conn_id:%u, sql_str:%s", ret, thd_id, + ctc_log_error("[CTC_DDL]:init_mysql_client failed, ret:%d, conn_id:%u, sql_str:%s", ret, thd_id, sql_without_plaintext_password(broadcast_req).c_str()); return ret; @@ -392,42 +392,42 @@ __attribute__((visibility("default"))) int tse_ddl_execute_update(uint32_t thd_i // 设置随机密码seed if (broadcast_req->sql_command == SQLCOM_CREATE_USER || broadcast_req->sql_command == SQLCOM_ALTER_USER || broadcast_req->sql_command == SQLCOM_SET_PASSWORD) { - ret = tse_mysql_query(curr_conn, ("set @random_password_seed = " + std::to_string(thd_id) + ";").c_str()); + ret = ctc_mysql_query(curr_conn, ("set @random_password_seed = " + std::to_string(thd_id) + ";").c_str()); if (ret != 0) { - tse_log_error("tse_init_proxy_client set @random_password_seed failed, error_code:%d", mysql_errno(curr_conn)); + ctc_log_error("ctc_init_proxy_client set @random_password_seed failed, error_code:%d", mysql_errno(curr_conn)); return ret; } } - if (broadcast_req->options & TSE_OPEN_NO_CHECK_FK_FOR_CURRENT_SQL) { - if (tse_mysql_query(curr_conn, "SET SESSION foreign_key_checks = 0;")) { - tse_log_error("tse_init_proxy_client SET SESSION foreign_key_checks = 0; failed, error_code:%d,error:%s", mysql_errno(curr_conn), mysql_error(curr_conn)); + if (broadcast_req->options & CTC_OPEN_NO_CHECK_FK_FOR_CURRENT_SQL) { + if (ctc_mysql_query(curr_conn, "SET SESSION foreign_key_checks = 0;")) { + ctc_log_error("ctc_init_proxy_client SET SESSION foreign_key_checks = 0; failed, error_code:%d,error:%s", mysql_errno(curr_conn), mysql_error(curr_conn)); broadcast_req->err_code = mysql_errno(curr_conn); - tse_close_mysql_conn(&curr_conn); + ctc_close_mysql_conn(&curr_conn); return broadcast_req->err_code; } } - ret = tse_mysql_query(curr_conn, broadcast_req->sql_str); // ret: success: 0, fail: 1 + ret = ctc_mysql_query(curr_conn, broadcast_req->sql_str); // ret: success: 0, fail: 1 int error_code = mysql_errno(curr_conn); if (ret != 0 || error_code != 0) { broadcast_req->err_code = error_code; strncpy(broadcast_req->err_msg, mysql_error(curr_conn), ERROR_MESSAGE_LEN - 1); - tse_log_error("[TSE_DDL]:mysql query exectue failed. err_code:%d, err_msg:%s, sql_str:%s, user_name:%s," + ctc_log_error("[CTC_DDL]:mysql query exectue failed. err_code:%d, err_msg:%s, sql_str:%s, user_name:%s," " conn_id:%u, allow_fail:%d",error_code, broadcast_req->err_msg, sql_without_plaintext_password(broadcast_req).c_str(), broadcast_req->user_name, thd_id, *allow_fail); return broadcast_req->err_code; } - if (broadcast_req->options & TSE_OPEN_NO_CHECK_FK_FOR_CURRENT_SQL) { - if (tse_mysql_query(curr_conn, "SET SESSION foreign_key_checks = 1;")) { - tse_log_error("tse_init_proxy_client SET SESSION foreign_key_checks = 1; failed, error_code:%d,error:%s", mysql_errno(curr_conn), mysql_error(curr_conn)); + if (broadcast_req->options & CTC_OPEN_NO_CHECK_FK_FOR_CURRENT_SQL) { + if (ctc_mysql_query(curr_conn, "SET SESSION foreign_key_checks = 1;")) { + ctc_log_error("ctc_init_proxy_client SET SESSION foreign_key_checks = 1; failed, error_code:%d,error:%s", mysql_errno(curr_conn), mysql_error(curr_conn)); broadcast_req->err_code = mysql_errno(curr_conn); - tse_close_mysql_conn(&curr_conn); + ctc_close_mysql_conn(&curr_conn); return broadcast_req->err_code; } } - tse_log_system("[TSE_DDL]: remote execute sql=%s, user_name:%s, success, mysql_inst_id=%u, conn_map_key:%lu", + ctc_log_system("[CTC_DDL]: remote execute sql=%s, user_name:%s, success, mysql_inst_id=%u, conn_map_key:%lu", sql_without_plaintext_password(broadcast_req).c_str(), broadcast_req->user_name, broadcast_req->mysql_inst_id, conn_map_key); set_explicit_table_lock(conn_map_key, broadcast_req->sql_command); @@ -438,7 +438,7 @@ __attribute__((visibility("default"))) int tse_ddl_execute_update(uint32_t thd_i return 0; } -static int tse_ddl_get_lock(MYSQL *curr_conn, const uint64_t &conn_map_key, const char *lock_name, int *err_code) { +static int ctc_ddl_get_lock(MYSQL *curr_conn, const uint64_t &conn_map_key, const char *lock_name, int *err_code) { uchar digest[MD5_HASH_SIZE]; compute_md5_hash(pointer_cast(digest), lock_name, strlen(lock_name)); @@ -448,10 +448,10 @@ static int tse_ddl_get_lock(MYSQL *curr_conn, const uint64_t &conn_map_key, cons output[(MD5_HASH_SIZE * 2)] = '\0'; string lock_function_str = string("SELECT GET_LOCK('") + output + string("', 0);"); - int ret = tse_mysql_query(curr_conn, lock_function_str.c_str()); + int ret = ctc_mysql_query(curr_conn, lock_function_str.c_str()); *err_code = mysql_errno(curr_conn); if (ret != 0 || *err_code != 0) { - tse_log_error("[TSE_LOCK_TABLE]:execute GET_LOCK() failed, " + ctc_log_error("[CTC_LOCK_TABLE]:execute GET_LOCK() failed, " "return_err: %d, err_code:%d, err_msg:%s, lock_function_str:%s", ret, *err_code, mysql_error(curr_conn), lock_function_str.c_str()); return *err_code; @@ -459,7 +459,7 @@ static int tse_ddl_get_lock(MYSQL *curr_conn, const uint64_t &conn_map_key, cons MYSQL_RES *query_res = mysql_store_result(curr_conn); if (query_res == nullptr) { - tse_log_error("[TSE_LOCK_TABLE]:execute GET_LOCK() failed to store result, lock_name:%s, err_msg:%s", + ctc_log_error("[CTC_LOCK_TABLE]:execute GET_LOCK() failed to store result, lock_name:%s, err_msg:%s", lock_name, mysql_error(curr_conn)); return 1; } @@ -474,26 +474,26 @@ static int tse_ddl_get_lock(MYSQL *curr_conn, const uint64_t &conn_map_key, cons mysql_free_result(query_res); { - lock_guard lock(m_tse_mysql_proxy_mutex); + lock_guard lock(m_ctc_mysql_proxy_mutex); auto iter = g_mysql_conn_map.find(conn_map_key); if (iter != g_mysql_conn_map.end()) { iter->second->name_locks++; uint32_t name_locks = add_g_name_locks(1); - tse_log_note("[TSE_LOCK_TABLE]: conn key=%lu, its name locks=%u, current global name locks=%u", + ctc_log_note("[CTC_LOCK_TABLE]: conn key=%lu, its name locks=%u, current global name locks=%u", conn_map_key, iter->second->name_locks, name_locks); } } return 0; } -int32_t tse_check_table_exist(MYSQL *curr_conn_proxy, const char *db_name, const char *table_name, int *err_code) { +int32_t ctc_check_table_exist(MYSQL *curr_conn_proxy, const char *db_name, const char *table_name, int *err_code) { string sql_str = "SELECT EXISTS (SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA LIKE '" + string(db_name) + "' AND TABLE_NAME = '" + string(table_name) + "');"; MYSQL_RES *query_res = nullptr; - if (tse_mysql_query(curr_conn_proxy, sql_str.c_str()) || !(query_res = mysql_store_result(curr_conn_proxy))) { + if (ctc_mysql_query(curr_conn_proxy, sql_str.c_str()) || !(query_res = mysql_store_result(curr_conn_proxy))) { *err_code = mysql_errno(curr_conn_proxy); - tse_log_error("[TSE_LOCK_TABLE]:err_msg:%s, db:%s, table:%s", mysql_error(curr_conn_proxy), db_name, table_name); + ctc_log_error("[CTC_LOCK_TABLE]:err_msg:%s, db:%s, table:%s", mysql_error(curr_conn_proxy), db_name, table_name); return -1; } @@ -504,77 +504,77 @@ int32_t tse_check_table_exist(MYSQL *curr_conn_proxy, const char *db_name, const return res; } -__attribute__((visibility("default"))) int tse_ddl_execute_lock_tables(tianchi_handler_t *tch, char *db_name, tse_lock_table_info *lock_info, int *err_code) { +__attribute__((visibility("default"))) int ctc_ddl_execute_lock_tables(ctc_handler_t *tch, char *db_name, ctc_lock_table_info *lock_info, int *err_code) { if (IS_METADATA_NORMALIZATION()) { if (lock_info->sql_type == SQLCOM_LOCK_TABLES) { - if (tse_ddl_execute_lock_tables_by_req(tch, lock_info, err_code)) { + if (ctc_ddl_execute_lock_tables_by_req(tch, lock_info, err_code)) { return *err_code; } - } else if (tse_mdl_lock_thd(tch, lock_info, err_code)) { + } else if (ctc_mdl_lock_thd(tch, lock_info, err_code)) { return *err_code; } return 0; } bool is_same_node = (tch->inst_id == ctc_instance_id); - uint64_t conn_map_key = tse_get_conn_key(tch->inst_id, tch->thd_id, !is_same_node); + uint64_t conn_map_key = ctc_get_conn_key(tch->inst_id, tch->thd_id, !is_same_node); MYSQL *curr_conn = NULL; - int ret = tse_init_mysql_client(conn_map_key, db_name, curr_conn, lock_info->user_name, lock_info->user_ip, !is_same_node); + int ret = ctc_init_mysql_client(conn_map_key, db_name, curr_conn, lock_info->user_name, lock_info->user_ip, !is_same_node); if (ret != 0) { *err_code = ret; - tse_log_error("[TSE_LOCK_TABLE]:tse_init_mysql_client failed, ret:%d, conn_id:%u, ctc_instance_id:%u", + ctc_log_error("[CTC_LOCK_TABLE]:ctc_init_mysql_client failed, ret:%d, conn_id:%u, ctc_instance_id:%u", ret, tch->thd_id, tch->inst_id); return ret; } /* Operations on the Database, only need to lock the database. */ if (strlen(lock_info->table_name) == 0) { - return tse_ddl_get_lock(curr_conn, conn_map_key, lock_info->db_name, err_code); + return ctc_ddl_get_lock(curr_conn, conn_map_key, lock_info->db_name, err_code); } string lock_name_str; lock_name_str.append(lock_info->db_name); lock_name_str.append("."); lock_name_str.append(lock_info->table_name); - ret = tse_ddl_get_lock(curr_conn, conn_map_key, lock_name_str.c_str(), err_code); + ret = ctc_ddl_get_lock(curr_conn, conn_map_key, lock_name_str.c_str(), err_code); if (ret != 0) { return ret; } /* Do not run lock_table on the same node. */ if(is_same_node) { - tse_log_note("[TSE_LOCK_TABLE]:curnode not need execute, mysql_inst_id:%u", tch->inst_id); + ctc_log_note("[CTC_LOCK_TABLE]:curnode not need execute, mysql_inst_id:%u", tch->inst_id); return 0; } if (lock_info->sql_type == SQLCOM_CREATE_TABLE || lock_info->sql_type == SQLCOM_DROP_VIEW || lock_info->sql_type == SQLCOM_CREATE_VIEW) { - tse_log_note("[TSE_LOCK_TABLE]:Skip lock_table. sql_cmd:%d", lock_info->sql_type); + ctc_log_note("[CTC_LOCK_TABLE]:Skip lock_table. sql_cmd:%d", lock_info->sql_type); return 0; } if (g_mysql_conn_map[conn_map_key]->has_explicit_table_lock) { - tse_log_system("[TSE_LOCK_TABLE]: curnode doesn't need execute, conn_map_key=%lu, mysql_thd_id=%u, mysql_inst_id=%u", + ctc_log_system("[CTC_LOCK_TABLE]: curnode doesn't need execute, conn_map_key=%lu, mysql_thd_id=%u, mysql_inst_id=%u", conn_map_key, tch->thd_id, tch->inst_id); return ret; } - int32_t row_res = tse_check_table_exist(curr_conn, lock_info->db_name, lock_info->table_name, err_code); + int32_t row_res = ctc_check_table_exist(curr_conn, lock_info->db_name, lock_info->table_name, err_code); if (row_res > 0) { - lock_guard lock(m_tse_mysql_proxy_mutex); + lock_guard lock(m_ctc_mysql_proxy_mutex); g_mysql_conn_map[conn_map_key]->table_lock_info.insert(make_pair(lock_info->db_name, lock_info->table_name)); } string lock_str = "lock tables "; { - lock_guard lock(m_tse_mysql_proxy_mutex); + lock_guard lock(m_ctc_mysql_proxy_mutex); for (auto iter : g_mysql_conn_map[conn_map_key]->table_lock_info) { - row_res = tse_check_table_exist(curr_conn, iter.first.c_str(), iter.second.c_str(), err_code); + row_res = ctc_check_table_exist(curr_conn, iter.first.c_str(), iter.second.c_str(), err_code); if (row_res <= 0) { - tse_log_warning("[TSE_LOCK_TABLE]:Table not exist. row_res:%d, db:%s, table:%s", row_res, iter.first.c_str(), iter.second.c_str()); + ctc_log_warning("[CTC_LOCK_TABLE]:Table not exist. row_res:%d, db:%s, table:%s", row_res, iter.first.c_str(), iter.second.c_str()); return 0; } @@ -587,10 +587,10 @@ __attribute__((visibility("default"))) int tse_ddl_execute_lock_tables(tianchi_h lock_str += ";"; if (g_mysql_conn_map[conn_map_key]->table_lock_info.size() > 0) { - ret = tse_mysql_query(curr_conn, lock_str.c_str()); + ret = ctc_mysql_query(curr_conn, lock_str.c_str()); if (ret != 0 || mysql_errno(curr_conn) != 0) { *err_code = mysql_errno(curr_conn); - tse_log_error("[TSE_LOCK_TABLE]:return_err:%d, err_code:%d, err_msg:%s, lock_sql_str:%s, conn_id:%u, ctc_instance_id:%u", + ctc_log_error("[CTC_LOCK_TABLE]:return_err:%d, err_code:%d, err_msg:%s, lock_sql_str:%s, conn_id:%u, ctc_instance_id:%u", ret, *err_code, mysql_error(curr_conn), lock_str.c_str(), tch->thd_id, tch->inst_id); } } @@ -598,29 +598,29 @@ __attribute__((visibility("default"))) int tse_ddl_execute_lock_tables(tianchi_h return ret; } -__attribute__((visibility("default"))) int tse_ddl_execute_unlock_tables(tianchi_handler_t *tch, uint32_t mysql_inst_id, tse_lock_table_info *lock_info) +__attribute__((visibility("default"))) int ctc_ddl_execute_unlock_tables(ctc_handler_t *tch, uint32_t mysql_inst_id, ctc_lock_table_info *lock_info) { if (IS_METADATA_NORMALIZATION()) { UNUSED_PARAM(mysql_inst_id); if (lock_info->sql_type == SQLCOM_UNLOCK_TABLES) { - tse_mdl_unlock_tables_thd(tch); + ctc_mdl_unlock_tables_thd(tch); } - tse_mdl_unlock_thd(tch, lock_info); + ctc_mdl_unlock_thd(tch, lock_info); return 0; } bool is_same_node = (tch->inst_id == ctc_instance_id); - uint64_t conn_map_key = tse_get_conn_key(tch->inst_id, tch->thd_id, !is_same_node); + uint64_t conn_map_key = ctc_get_conn_key(tch->inst_id, tch->thd_id, !is_same_node); MYSQL *curr_conn = get_mysql_conn_by_key(conn_map_key); if (curr_conn == NULL) { - tse_log_system("[TSE_UNLOCK_TABLE]: curr_conn is NULL, conn_map_key=%lu, conn_id=%u, ctc_instance_id=%u", + ctc_log_system("[CTC_UNLOCK_TABLE]: curr_conn is NULL, conn_map_key=%lu, conn_id=%u, ctc_instance_id=%u", conn_map_key, tch->thd_id, tch->inst_id); return 0; } /* Releases all named locks held by the current session */ - if (tse_mysql_query(curr_conn, "SELECT RELEASE_ALL_LOCKS();")) { - tse_log_error("[TSE_UNLOCK_TABLE]: RELEASE_ALL_LOCKS failed, close conn, conn_id=%u, err_code=%d, err_msg=%s", + if (ctc_mysql_query(curr_conn, "SELECT RELEASE_ALL_LOCKS();")) { + ctc_log_error("[CTC_UNLOCK_TABLE]: RELEASE_ALL_LOCKS failed, close conn, conn_id=%u, err_code=%d, err_msg=%s", tch->thd_id, mysql_errno(curr_conn), mysql_error(curr_conn)); close_mysql_conn_by_key(conn_map_key); return 0; @@ -630,14 +630,14 @@ __attribute__((visibility("default"))) int tse_ddl_execute_unlock_tables(tianchi { // 清空加锁信息 - lock_guard lock(m_tse_mysql_proxy_mutex); + lock_guard lock(m_ctc_mysql_proxy_mutex); auto iter = g_mysql_conn_map.find(conn_map_key); if (iter != g_mysql_conn_map.end()) { iter->second->table_lock_info.clear(); if (iter->second->name_locks > 0) { iter->second->name_locks--; uint32_t name_locks = sub_g_name_locks(1); - tse_log_note("[TSE_LOCK_TABLE]: conn key=%lu, its name locks=%u, current global name locks=%u", + ctc_log_note("[CTC_LOCK_TABLE]: conn key=%lu, its name locks=%u, current global name locks=%u", conn_map_key, iter->second->name_locks, name_locks); } } @@ -646,17 +646,17 @@ __attribute__((visibility("default"))) int tse_ddl_execute_unlock_tables(tianchi /* Do not run unlock_table on the same node. */ if(is_same_node) { close_mysql_conn_by_key(conn_map_key); - tse_log_note("[TSE_UNLOCK_TABLE]: curnode doesn't need execute, conn_map_key=%lu, mysql_inst_id=%u", conn_map_key, tch->inst_id); + ctc_log_note("[CTC_UNLOCK_TABLE]: curnode doesn't need execute, conn_map_key=%lu, mysql_inst_id=%u", conn_map_key, tch->inst_id); return 0; } if (g_mysql_conn_map[conn_map_key]->has_explicit_table_lock) { - tse_log_system("[TSE_UNLOCK_TABLE]: curnode doesn't need execute, conn_map_key=%lu, mysql_thd_id=%u, mysql_inst_id=%u", conn_map_key, tch->thd_id, tch->inst_id); + ctc_log_system("[CTC_UNLOCK_TABLE]: curnode doesn't need execute, conn_map_key=%lu, mysql_thd_id=%u, mysql_inst_id=%u", conn_map_key, tch->thd_id, tch->inst_id); return 0; } - if (tse_mysql_query(curr_conn, "UNLOCK TABLES;")) { - tse_log_error("[TSE_UNLOCK_TABLE]: UNLOCK TABLES failed, close conn, conn_id=%u, err_code=%d, err_msg=%s", + if (ctc_mysql_query(curr_conn, "UNLOCK TABLES;")) { + ctc_log_error("[CTC_UNLOCK_TABLE]: UNLOCK TABLES failed, close conn, conn_id=%u, err_code=%d, err_msg=%s", tch->thd_id, mysql_errno(curr_conn), mysql_error(curr_conn)); close_mysql_conn_by_key(conn_map_key); return 0; @@ -672,30 +672,30 @@ __attribute__((visibility("default"))) int tse_ddl_execute_unlock_tables(tianchi */ __attribute__((visibility("default"))) int close_mysql_connection(uint32_t thd_id, uint32_t mysql_inst_id) { if (IS_METADATA_NORMALIZATION()) { - close_tse_mdl_thd(thd_id, mysql_inst_id); + close_ctc_mdl_thd(thd_id, mysql_inst_id); return 0; } if (thd_id == 0) { if ((uint16_t)mysql_inst_id == (uint16_t)CANTIAN_DOWN_MASK) { /* 清理整个参天节点相关的连接 */ - tse_log_system("[TSE_CLOSE_SESSION]:Close All connects on bad node by cantian_instance_id:%u", + ctc_log_system("[CTC_CLOSE_SESSION]:Close All connects on bad node by cantian_instance_id:%u", (mysql_inst_id >> 16)); close_mysql_conn_by_inst_id((mysql_inst_id >> 16), false); } else { /* 清理整个mysqld节点相关的连接 */ - tse_log_system("[TSE_CLOSE_SESSION]:Close All connects by ctc_instance_id:%u", mysql_inst_id); + ctc_log_system("[CTC_CLOSE_SESSION]:Close All connects by ctc_instance_id:%u", mysql_inst_id); close_mysql_conn_by_inst_id(mysql_inst_id, true); } } else { /* 通过把mysql_inst_id左移32位 与 thd_id拼接在一起 用来唯一标识一个连接 */ - uint64_t proxy_conn_map_key = tse_get_conn_key(mysql_inst_id, thd_id, true); - tse_log_note("[TSE_CLOSE_SESSION]: Close connect by conn_id=%u, ctc_instance_id=%u, proxy_conn_map_key=%lu", + uint64_t proxy_conn_map_key = ctc_get_conn_key(mysql_inst_id, thd_id, true); + ctc_log_note("[CTC_CLOSE_SESSION]: Close connect by conn_id=%u, ctc_instance_id=%u, proxy_conn_map_key=%lu", thd_id, mysql_inst_id, proxy_conn_map_key); close_mysql_conn_by_key(proxy_conn_map_key); - uint64_t agent_conn_map_key = tse_get_conn_key(mysql_inst_id, thd_id, false); - tse_log_note("[TSE_CLOSE_SESSION]: Close connect by conn_id=%u, ctc_instance_id=%u, agent_conn_map_key=%lu", + uint64_t agent_conn_map_key = ctc_get_conn_key(mysql_inst_id, thd_id, false); + ctc_log_note("[CTC_CLOSE_SESSION]: Close connect by conn_id=%u, ctc_instance_id=%u, agent_conn_map_key=%lu", thd_id, mysql_inst_id, agent_conn_map_key); close_mysql_conn_by_key(agent_conn_map_key); } diff --git a/storage/tianchi/tse_proxy_util.cc b/storage/ctc/ctc_proxy_util.cc similarity index 79% rename from storage/tianchi/tse_proxy_util.cc rename to storage/ctc/ctc_proxy_util.cc index 2ab93bf..06fe128 100644 --- a/storage/tianchi/tse_proxy_util.cc +++ b/storage/ctc/ctc_proxy_util.cc @@ -15,18 +15,18 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#include "tse_proxy_util.h" +#include "ctc_proxy_util.h" #include -#include "tse_log.h" +#include "ctc_log.h" #include "sql/sql_connect.h" #include "sql/conn_handler/connection_handler_manager.h" // Connection_handler_manager #include "compression.h" -#include "ha_tse.h" +#include "ha_ctc.h" #include "sql/mysqld.h" #include "ctc_meta_data.h" -#define TSE_CONN_MAX_RETRY_TIMES 10 -#define TSE_PASSWORD_BUFFER_SIZE (uint32)512 +#define CTC_CONN_MAX_RETRY_TIMES 10 +#define CTC_PASSWORD_BUFFER_SIZE (uint32)512 #ifndef SENSI_INFO #define SENSI_INFO @@ -62,13 +62,13 @@ static bool is_dangerous_pwd(const char *password) { return danger_pwd_flag; } -static int tse_get_agent_info(char *password, uint password_size) { +static int ctc_get_agent_info(char *password, uint password_size) { char *user_password = getenv("MYSQL_AGENT_PASSWORD"); if (user_password == NULL) { return -1; } if (is_dangerous_pwd(user_password)) { - tse_log_error("checking pwd failed"); + ctc_log_error("checking pwd failed"); return -1; } @@ -77,12 +77,12 @@ static int tse_get_agent_info(char *password, uint password_size) { FILE *fp = popen(cmd.c_str(), "r"); if (fp == NULL) { - tse_log_error("encrypting cmd failed"); + ctc_log_error("encrypting cmd failed"); return -1; } if (fgets(password, password_size, fp) == NULL) { - tse_log_error("get password failed"); + ctc_log_error("get password failed"); pclose (fp); return -1; } @@ -102,28 +102,28 @@ static int tse_get_agent_info(char *password, uint password_size) { return 0; } -static void tse_inc_conn_count(int &dec_conn_count) +static void ctc_inc_conn_count(int &dec_conn_count) { Connection_handler_manager *conn_manager = Connection_handler_manager::get_instance(); conn_manager->check_and_incr_conn_count(true); Connection_handler_manager::reset_max_used_connections(); dec_conn_count--; - tse_log_warning("[TSE_CONN_INC]:connection_count:%u, max_used_connections:%lu, max_connections:%lu, dec_conn_count:%d", + ctc_log_warning("[CTC_CONN_INC]:connection_count:%u, max_used_connections:%lu, max_connections:%lu, dec_conn_count:%d", Connection_handler_manager::connection_count, Connection_handler_manager::max_used_connections, max_connections, dec_conn_count); } -static void tse_dec_conn_count(int &dec_conn_count) +static void ctc_dec_conn_count(int &dec_conn_count) { Connection_handler_manager::dec_connection_count(); dec_conn_count++; - tse_log_warning("[TSE_CONN_DEC]:connection_count:%u, max_used_connections:%lu, max_connections:%lu, dec_conn_count:%d", + ctc_log_warning("[CTC_CONN_DEC]:connection_count:%u, max_used_connections:%lu, max_connections:%lu, dec_conn_count:%d", Connection_handler_manager::connection_count, Connection_handler_manager::max_used_connections, max_connections, dec_conn_count); } -int tse_mysql_conn(MYSQL *&con, const char *host, const char *user, const char *passwd) { +int ctc_mysql_conn(MYSQL *&con, const char *host, const char *user, const char *passwd) { con = mysql_init(NULL); if (con == nullptr) { - tse_log_error("tse_mysql_conn mysql_init failed, error_code:%d,error:%s", mysql_errno(con), mysql_error(con)); + ctc_log_error("ctc_mysql_conn mysql_init failed, error_code:%d,error:%s", mysql_errno(con), mysql_error(con)); my_thread_end(); if (!mysql_errno(con)) { return CR_OUT_OF_MEMORY; @@ -150,12 +150,12 @@ int tse_mysql_conn(MYSQL *&con, const char *host, const char *user, const char * (void)mysql_options(con, MYSQL_OPT_READ_TIMEOUT, &opt_timeout); (void)mysql_options(con, MYSQL_OPT_WRITE_TIMEOUT, &opt_timeout); - int retry_time = TSE_CONN_MAX_RETRY_TIMES; + int retry_time = CTC_CONN_MAX_RETRY_TIMES; int dec_conn_count = 0; while (!mysql_real_connect(con, host, user, passwd, NULL, mysqld_port, mysqld_unix_port, CLIENT_MULTI_STATEMENTS | CLIENT_MULTI_RESULTS | CLIENT_REMEMBER_OPTIONS | CLIENT_INTERACTIVE) && retry_time > 0) { int err = mysql_errno(con); if (err == ER_CON_COUNT_ERROR) { - tse_dec_conn_count(dec_conn_count); + ctc_dec_conn_count(dec_conn_count); } // 3922 errcode, server has open compress conn, client need to open. if (err == ER_WRONG_COMPRESSION_ALGORITHM_CLIENT) { @@ -167,43 +167,43 @@ int tse_mysql_conn(MYSQL *&con, const char *host, const char *user, const char * retry_time--; continue; } - tse_log_error("tse_mysql_conn create internal connection failed, retry_time=%d, user=%s, err_code=%d, err_msg=%s.", + ctc_log_error("ctc_mysql_conn create internal connection failed, retry_time=%d, user=%s, err_code=%d, err_msg=%s.", retry_time, user, err, mysql_error(con)); retry_time--; } while (dec_conn_count != 0) { - tse_inc_conn_count(dec_conn_count); + ctc_inc_conn_count(dec_conn_count); } my_thread_end(); return con == nullptr; } -int tse_init_agent_client(MYSQL *&curr_conn) { - SENSI_INFO char agent_password[TSE_PASSWORD_BUFFER_SIZE] = {0}; +int ctc_init_agent_client(MYSQL *&curr_conn) { + SENSI_INFO char agent_password[CTC_PASSWORD_BUFFER_SIZE] = {0}; string agent_user = "root"; - if (!tse_get_agent_info(agent_password, TSE_PASSWORD_BUFFER_SIZE)) { + if (!ctc_get_agent_info(agent_password, CTC_PASSWORD_BUFFER_SIZE)) { agent_user = "RDS_agent"; } const char *password = (agent_user == "root") ? NULL : agent_password; - int ret = tse_mysql_conn(curr_conn, my_localhost, agent_user.c_str(), password); - memset(agent_password, 0, TSE_PASSWORD_BUFFER_SIZE); + int ret = ctc_mysql_conn(curr_conn, my_localhost, agent_user.c_str(), password); + memset(agent_password, 0, CTC_PASSWORD_BUFFER_SIZE); if (ret) { - tse_log_error("tse_init_agent_client tse_mysql_conn failed, err_code=%d, err_msg=%s.", + ctc_log_error("ctc_init_agent_client ctc_mysql_conn failed, err_code=%d, err_msg=%s.", mysql_errno(curr_conn), mysql_error(curr_conn)); - tse_close_mysql_conn(&curr_conn); + ctc_close_mysql_conn(&curr_conn); return ret; } return 0; } -int tse_mysql_query(MYSQL *mysql, const char *query) { +int ctc_mysql_query(MYSQL *mysql, const char *query) { reset_mqh(nullptr, nullptr, 0); int ret = mysql_ping(mysql); if (ret != 0) { - tse_log_error("tse_mysql_query: mysql server has gone. error_code:%d, reconnecting.", ret); + ctc_log_error("ctc_mysql_query: mysql server has gone. error_code:%d, reconnecting.", ret); } /* @@ -214,8 +214,8 @@ int tse_mysql_query(MYSQL *mysql, const char *query) { CR_UNKNOWN_ERROR: 2000 */ - if (tse_get_cluster_role() == (int32_t)dis_cluster_role::STANDBY) { - tse_reset_mysql_read_only(); + if (ctc_get_cluster_role() == (int32_t)dis_cluster_role::STANDBY) { + ctc_reset_mysql_read_only(); } do { @@ -223,17 +223,17 @@ int tse_mysql_query(MYSQL *mysql, const char *query) { } while (!mysql_next_result(mysql)); ret = mysql_query(mysql, query); - if (tse_get_cluster_role() == (int32_t)dis_cluster_role::STANDBY) { - tse_set_mysql_read_only(); + if (ctc_get_cluster_role() == (int32_t)dis_cluster_role::STANDBY) { + ctc_set_mysql_read_only(); } if (ret != 0) { - tse_log_error("[TSE_MYSQL_QUERY]:ret:%d, err_code=%d, err_msg=%s, query_str:%s.", ret, mysql_errno(mysql), mysql_error(mysql), query); + ctc_log_error("[CTC_MYSQL_QUERY]:ret:%d, err_code=%d, err_msg=%s, query_str:%s.", ret, mysql_errno(mysql), mysql_error(mysql), query); } return ret; // success: 0, fail: other } -void tse_close_mysql_conn(MYSQL **curr_conn) { +void ctc_close_mysql_conn(MYSQL **curr_conn) { mysql_close(*curr_conn); *curr_conn = NULL; } \ No newline at end of file diff --git a/storage/tianchi/tse_proxy_util.h b/storage/ctc/ctc_proxy_util.h similarity index 80% rename from storage/tianchi/tse_proxy_util.h rename to storage/ctc/ctc_proxy_util.h index e8a04d2..b9a7367 100644 --- a/storage/tianchi/tse_proxy_util.h +++ b/storage/ctc/ctc_proxy_util.h @@ -15,8 +15,8 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#ifndef __TSE_PROXY_UTIL_H__ -#define __TSE_PROXY_UTIL_H__ +#ifndef __CTC_PROXY_UTIL_H__ +#define __CTC_PROXY_UTIL_H__ #include @@ -27,7 +27,7 @@ using namespace std; #define AGENT_CONN_KEY_MASK (0x8000000000000000ULL) // this api can called by both CTC storage level(ha_ctc.so) and ctc_proxy.so, mysql_close C API used mysqlclient -void tse_close_mysql_conn(MYSQL **curr_conn); +void ctc_close_mysql_conn(MYSQL **curr_conn); /* conn_key format: @@ -43,7 +43,7 @@ void tse_close_mysql_conn(MYSQL **curr_conn); because cantiand_id ranges from [0, 1] use the first bit of conn_key to represent if this conn is proxy or agent (0: proxy, 1: agent) */ -inline uint64_t tse_get_conn_key(uint32_t inst_id, uint32_t thd_id, bool use_proxy) { +inline uint64_t ctc_get_conn_key(uint32_t inst_id, uint32_t thd_id, bool use_proxy) { uint64_t conn_key = (((uint64_t)(inst_id)) << 32) + thd_id; if (!use_proxy) { conn_key |= AGENT_CONN_KEY_MASK; @@ -51,22 +51,22 @@ inline uint64_t tse_get_conn_key(uint32_t inst_id, uint32_t thd_id, bool use_pro return conn_key; } -inline uint32_t tse_get_inst_id_from_conn_key(uint64_t conn_key) { +inline uint32_t ctc_get_inst_id_from_conn_key(uint64_t conn_key) { return (conn_key & (AGENT_CONN_KEY_MASK - 1)) >> 32; } -inline uint16_t tse_get_cantian_id_from_conn_key(uint64_t conn_key) { +inline uint16_t ctc_get_cantian_id_from_conn_key(uint64_t conn_key) { return (conn_key & (AGENT_CONN_KEY_MASK - 1)) >> 48; } -int tse_init_agent_client(MYSQL *&curr_conn); -int tse_mysql_conn(MYSQL *&con, const char *host, const char *user, const char *passwd); +int ctc_init_agent_client(MYSQL *&curr_conn); +int ctc_mysql_conn(MYSQL *&con, const char *host, const char *user, const char *passwd); uint32_t get_g_name_locks(void); uint32_t add_g_name_locks(uint32_t num); uint32_t sub_g_name_locks(uint32_t num); -int tse_mysql_query(MYSQL *mysql, const char *query); +int ctc_mysql_query(MYSQL *mysql, const char *query); #pragma GCC visibility pop -#endif // __TSE_PROXY_UTIL_H__ +#endif // __CTC_PROXY_UTIL_H__ diff --git a/storage/tianchi/tse_srv.h b/storage/ctc/ctc_srv.h similarity index 47% rename from storage/tianchi/tse_srv.h rename to storage/ctc/ctc_srv.h index 8b7e95e..69ab7bb 100644 --- a/storage/tianchi/tse_srv.h +++ b/storage/ctc/ctc_srv.h @@ -15,8 +15,8 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#ifndef __TSE_SRV_H__ -#define __TSE_SRV_H__ +#ifndef __CTC_SRV_H__ +#define __CTC_SRV_H__ #include #include @@ -43,30 +43,30 @@ extern "C" { #define MAX_LOCK_TABLE_NAME (MAX_DDL_SQL_LEN - LOCK_TABLE_SQL_FMT_LEN) #define MAX_KEY_COLUMNS (uint32_t)16 // cantian限制复合索引最大支持字段不超过16 #define FUNC_TEXT_MAX_LEN 128 -#define TSE_IDENTIFIER_MAX_LEN 64 +#define CTC_IDENTIFIER_MAX_LEN 64 #define CANTIAN_DOWN_MASK 0xFFFF // 参天节点故障 #define MAX_DDL_ERROR_MSG_LEN 1024 #define PART_CURSOR_NUM 8192 #define MAX_SUBPART_NUM 4096 // 参天限制每个一级分区下子分区不超过4096 -#define TSE_BUF_LEN (64 * 1024) -#define BIG_RECORD_SIZE TSE_BUF_LEN // 采用最大长度 -#define MAX_RECORD_SIZE (1 * TSE_BUF_LEN) -#define TSE_MAX_KEY_NAME_LENGTH 64 -#define TSE_SQL_START_INTERNAL_SAVEPOINT "TSE4CANTIAN_SYS_SV" -#define IS_TSE_PART(part_id) ((part_id) < (PART_CURSOR_NUM)) +#define CTC_BUF_LEN (64 * 1024) +#define BIG_RECORD_SIZE CTC_BUF_LEN // 采用最大长度 +#define MAX_RECORD_SIZE (1 * CTC_BUF_LEN) +#define CTC_MAX_KEY_NAME_LENGTH 64 +#define CTC_SQL_START_INTERNAL_SAVEPOINT "CTC4CANTIAN_SYS_SV" +#define IS_CTC_PART(part_id) ((part_id) < (PART_CURSOR_NUM)) #define MAX_BULK_INSERT_PART_ROWS 128 #define SESSION_CURSOR_NUM (8192 * 2) #define MAX_MESSAGE_SIZE 4194304 // 共享内存最大可申请空间大小 // for broadcast_req.options -#define TSE_SET_VARIABLE_PERSIST (0x1 << 8) -#define TSE_SET_VARIABLE_PERSIST_ONLY (0x1 << 7) -#define TSE_OPEN_NO_CHECK_FK_FOR_CURRENT_SQL (0x1 << 6) -#define TSE_CURRENT_SQL_CONTAIN_PLAINTEXT_PASSWORD (0x1 << 5) -#define TSE_NOT_NEED_CANTIAN_EXECUTE (0x1 << 4) -#define TSE_SET_VARIABLE_TO_DEFAULT (0x1 << 3) -#define TSE_SET_VARIABLE_TO_NULL (0x1 << 2) -#define TSE_SET_VARIABLE_WITH_SUBSELECT (0x1 << 0) +#define CTC_SET_VARIABLE_PERSIST (0x1 << 8) +#define CTC_SET_VARIABLE_PERSIST_ONLY (0x1 << 7) +#define CTC_OPEN_NO_CHECK_FK_FOR_CURRENT_SQL (0x1 << 6) +#define CTC_CURRENT_SQL_CONTAIN_PLAINTEXT_PASSWORD (0x1 << 5) +#define CTC_NOT_NEED_CANTIAN_EXECUTE (0x1 << 4) +#define CTC_SET_VARIABLE_TO_DEFAULT (0x1 << 3) +#define CTC_SET_VARIABLE_TO_NULL (0x1 << 2) +#define CTC_SET_VARIABLE_WITH_SUBSELECT (0x1 << 0) #define CTC_AUTOINC_OLD_STYLE_LOCKING 0 #define CTC_AUTOINC_NEW_STYLE_LOCKING 1 @@ -75,7 +75,7 @@ extern "C" { typedef int64_t date_t; typedef struct { - uint32_t inst_id; // instance id, thd_id alone is not sufficient to uniquely identify a tse session + uint32_t inst_id; // instance id, thd_id alone is not sufficient to uniquely identify a ctc session uint32_t thd_id; uint32_t part_id; uint32_t subpart_id; @@ -93,7 +93,7 @@ typedef struct { bool is_broadcast; bool read_only_in_ct; // TRUE if read only in cantian: sys tables/views void* msg_buf; -} tianchi_handler_t; +} ctc_handler_t; typedef struct { char db_name[SMALL_RECORD_SIZE]; @@ -102,7 +102,7 @@ typedef struct { char user_ip[SMALL_RECORD_SIZE]; int32_t sql_type; int32_t mdl_namespace; -} tse_lock_table_info; +} ctc_lock_table_info; typedef struct cache_st_variant { union { @@ -120,22 +120,22 @@ typedef struct cache_st_variant { typedef enum { FREQUENCY_HIST = 0, HEIGHT_BALANCED_HIST = 1, -} tse_cbo_hist_type_t; +} ctc_cbo_hist_type_t; typedef struct { cache_variant_t ep_value; int ep_number; -} tse_cbo_column_hist_t; +} ctc_cbo_column_hist_t; typedef struct { uint32_t num_null; double density; - tse_cbo_hist_type_t hist_type; + ctc_cbo_hist_type_t hist_type; uint32_t hist_count; - tse_cbo_column_hist_t column_hist[STATS_HISTGRAM_MAX_SIZE]; // Column histogram statistics (array) + ctc_cbo_column_hist_t column_hist[STATS_HISTGRAM_MAX_SIZE]; // Column histogram statistics (array) cache_variant_t low_value; cache_variant_t high_value; -} tse_cbo_stats_column_t; +} ctc_cbo_stats_column_t; /** * cache info that can expand this struct @@ -143,8 +143,8 @@ typedef struct { */ typedef struct { uint32_t estimate_rows; - tse_cbo_stats_column_t *columns; -} tse_cbo_stats_table_t; + ctc_cbo_stats_column_t *columns; +} ctc_cbo_stats_table_t; /* * statistics information that mysql optimizer need @@ -159,8 +159,8 @@ typedef struct { uint32_t *ndv_keys; uint32_t num_str_cols; bool *col_type; - tse_cbo_stats_table_t *tse_cbo_stats_table; -} tianchi_cbo_stats_t; + ctc_cbo_stats_table_t *ctc_cbo_stats_table; +} ctc_cbo_stats_t; #pragma pack() typedef struct { @@ -177,7 +177,7 @@ typedef struct { char user_ip[SMALL_RECORD_SIZE]; int32_t error_code; uint32_t msg_len; - tianchi_handler_t tch; + ctc_handler_t tch; uint32_t mysql_inst_id; bool is_alter_copy; uint32_t table_flags; @@ -188,7 +188,7 @@ typedef struct { uint32_t autocommit; uint32_t lock_wait_timeout; bool use_exclusive_lock; -} tianchi_trx_context_t; +} ctc_trx_context_t; typedef struct { char db_name[SMALL_RECORD_SIZE]; @@ -200,7 +200,7 @@ typedef struct { uint8_t sql_command; uint32_t options; char err_msg[ERROR_MESSAGE_LEN]; -} tse_ddl_broadcast_request; +} ctc_ddl_broadcast_request; typedef struct { uint8_t type; @@ -214,7 +214,7 @@ typedef struct { uint32_t mysql_inst_id; bool is_dcl; int err_code; -} tse_invalidate_broadcast_request; +} ctc_invalidate_broadcast_request; typedef struct { bool is_key_null; // 该列数据是否为null @@ -253,7 +253,7 @@ typedef union { uint32_t unused_ops : 15; }; uint32_t is_option_set; -} tse_column_option_set_bit; +} ctc_column_option_set_bit; typedef enum { EXP_CURSOR_ACTION_SELECT = 0, @@ -268,203 +268,203 @@ typedef struct { expected_cursor_action_t action; uint16_t find_flag; uint16_t active_index; - char index_name[TSE_MAX_KEY_NAME_LENGTH + 1]; // 索引名 + char index_name[CTC_MAX_KEY_NAME_LENGTH + 1]; // 索引名 uint16_t key_num; // 查询条件覆盖多少列 key_info_t key_info[MAX_KEY_COLUMNS]; // 索引查询条件数组 bool index_skip_scan; } index_key_info_t; -enum TSE_FUNC_TYPE { - TSE_FUNC_TYPE_OPEN_TABLE = 0, - TSE_FUNC_TYPE_CLOSE_TABLE, - TSE_FUNC_TYPE_CLOSE_SESSION, - TSE_FUNC_TYPE_WRITE_ROW, - TSE_FUNC_TYPE_UPDATE_JOB, - TSE_FUNC_TYPE_UPDATE_ROW, - TSE_FUNC_TYPE_DELETE_ROW, - TSE_FUNC_TYPE_RND_INIT, - TSE_FUNC_TYPE_RND_END, - TSE_FUNC_TYPE_RND_NEXT, - TSE_FUNC_TYPE_RND_PREFETCH, - TSE_FUNC_TYPE_SCAN_RECORDS, - TSE_FUNC_TYPE_TRX_COMMIT, - TSE_FUNC_TYPE_TRX_ROLLBACK, - TSE_FUNC_TYPE_TRX_BEGIN, - TSE_FUNC_TYPE_LOCK_TABLE, - TSE_FUNC_TYPE_UNLOCK_TABLE, - TSE_FUNC_TYPE_INDEX_END, - TSE_FUNC_TYPE_SRV_SET_SAVEPOINT, - TSE_FUNC_TYPE_SRV_ROLLBACK_SAVEPOINT, - TSE_FUNC_TYPE_SRV_RELEASE_SAVEPOINT, - TSE_FUNC_TYPE_GENERAL_FETCH, - TSE_FUNC_TYPE_GENERAL_PREFETCH, - TSE_FUNC_TYPE_FREE_CURSORS, - TSE_FUNC_TYPE_GET_INDEX_NAME, - TSE_FUNC_TYPE_INDEX_READ, - TSE_FUNC_TYPE_RND_POS, - TSE_FUNC_TYPE_POSITION, - TSE_FUNC_TYPE_DELETE_ALL_ROWS, - TSE_FUNC_TYPE_GET_CBO_STATS, - TSE_FUNC_TYPE_WRITE_LOB, - TSE_FUNC_TYPE_READ_LOB, - TSE_FUNC_TYPE_CREATE_TABLE, - TSE_FUNC_TYPE_TRUNCATE_TABLE, - TSE_FUNC_TYPE_TRUNCATE_PARTITION, - TSE_FUNC_TYPE_RENAME_TABLE, - TSE_FUNC_TYPE_ALTER_TABLE, - TSE_FUNC_TYPE_GET_SERIAL_VALUE, - TSE_FUNC_TYPE_DROP_TABLE, - TSE_FUNC_TYPE_EXCUTE_MYSQL_DDL_SQL, - TSE_FUNC_TYPE_BROADCAST_REWRITE_SQL, - TSE_FUNC_TYPE_CREATE_TABLESPACE, - TSE_FUNC_TYPE_ALTER_TABLESPACE, - TSE_FUNC_TYPE_DROP_TABLESPACE, - TSE_FUNC_TYPE_BULK_INSERT, - TSE_FUNC_TYPE_ANALYZE, - TSE_FUNC_TYPE_GET_MAX_SESSIONS, - TSE_FUNC_LOCK_INSTANCE, - TSE_FUNC_UNLOCK_INSTANCE, - TSE_FUNC_CHECK_TABLE_EXIST, - TSE_FUNC_SEARCH_METADATA_SWITCH, +enum CTC_FUNC_TYPE { + CTC_FUNC_TYPE_OPEN_TABLE = 0, + CTC_FUNC_TYPE_CLOSE_TABLE, + CTC_FUNC_TYPE_CLOSE_SESSION, + CTC_FUNC_TYPE_WRITE_ROW, + CTC_FUNC_TYPE_UPDATE_JOB, + CTC_FUNC_TYPE_UPDATE_ROW, + CTC_FUNC_TYPE_DELETE_ROW, + CTC_FUNC_TYPE_RND_INIT, + CTC_FUNC_TYPE_RND_END, + CTC_FUNC_TYPE_RND_NEXT, + CTC_FUNC_TYPE_RND_PREFETCH, + CTC_FUNC_TYPE_SCAN_RECORDS, + CTC_FUNC_TYPE_TRX_COMMIT, + CTC_FUNC_TYPE_TRX_ROLLBACK, + CTC_FUNC_TYPE_TRX_BEGIN, + CTC_FUNC_TYPE_LOCK_TABLE, + CTC_FUNC_TYPE_UNLOCK_TABLE, + CTC_FUNC_TYPE_INDEX_END, + CTC_FUNC_TYPE_SRV_SET_SAVEPOINT, + CTC_FUNC_TYPE_SRV_ROLLBACK_SAVEPOINT, + CTC_FUNC_TYPE_SRV_RELEASE_SAVEPOINT, + CTC_FUNC_TYPE_GENERAL_FETCH, + CTC_FUNC_TYPE_GENERAL_PREFETCH, + CTC_FUNC_TYPE_FREE_CURSORS, + CTC_FUNC_TYPE_GET_INDEX_NAME, + CTC_FUNC_TYPE_INDEX_READ, + CTC_FUNC_TYPE_RND_POS, + CTC_FUNC_TYPE_POSITION, + CTC_FUNC_TYPE_DELETE_ALL_ROWS, + CTC_FUNC_TYPE_GET_CBO_STATS, + CTC_FUNC_TYPE_WRITE_LOB, + CTC_FUNC_TYPE_READ_LOB, + CTC_FUNC_TYPE_CREATE_TABLE, + CTC_FUNC_TYPE_TRUNCATE_TABLE, + CTC_FUNC_TYPE_TRUNCATE_PARTITION, + CTC_FUNC_TYPE_RENAME_TABLE, + CTC_FUNC_TYPE_ALTER_TABLE, + CTC_FUNC_TYPE_GET_SERIAL_VALUE, + CTC_FUNC_TYPE_DROP_TABLE, + CTC_FUNC_TYPE_EXCUTE_MYSQL_DDL_SQL, + CTC_FUNC_TYPE_BROADCAST_REWRITE_SQL, + CTC_FUNC_TYPE_CREATE_TABLESPACE, + CTC_FUNC_TYPE_ALTER_TABLESPACE, + CTC_FUNC_TYPE_DROP_TABLESPACE, + CTC_FUNC_TYPE_BULK_INSERT, + CTC_FUNC_TYPE_ANALYZE, + CTC_FUNC_TYPE_GET_MAX_SESSIONS, + CTC_FUNC_LOCK_INSTANCE, + CTC_FUNC_UNLOCK_INSTANCE, + CTC_FUNC_CHECK_TABLE_EXIST, + CTC_FUNC_SEARCH_METADATA_SWITCH, CTC_FUNC_QUERY_SHM_USAGE, - TSE_FUNC_QUERY_CLUSTER_ROLE, - TSE_FUNC_SET_CLUSTER_ROLE_BY_CANTIAN, - TSE_FUNC_PRE_CREATE_DB, - TSE_FUNC_TYPE_DROP_TABLESPACE_AND_USER, - TSE_FUNC_DROP_DB_PRE_CHECK, - TSE_FUNC_KILL_CONNECTION, - TSE_FUNC_TYPE_INVALIDATE_OBJECT, - TSE_FUNC_TYPE_RECORD_SQL, + CTC_FUNC_QUERY_CLUSTER_ROLE, + CTC_FUNC_SET_CLUSTER_ROLE_BY_CANTIAN, + CTC_FUNC_PRE_CREATE_DB, + CTC_FUNC_TYPE_DROP_TABLESPACE_AND_USER, + CTC_FUNC_DROP_DB_PRE_CHECK, + CTC_FUNC_KILL_CONNECTION, + CTC_FUNC_TYPE_INVALIDATE_OBJECT, + CTC_FUNC_TYPE_RECORD_SQL, /* for instance registration, should be the last but before duplex */ - TSE_FUNC_TYPE_REGISTER_INSTANCE, + CTC_FUNC_TYPE_REGISTER_INSTANCE, CTC_FUNC_QUERY_SHM_FILE_NUM, - TSE_FUNC_TYPE_WAIT_CONNETOR_STARTUPED, + CTC_FUNC_TYPE_WAIT_CONNETOR_STARTUPED, /* for duplex channel */ - TSE_FUNC_TYPE_MYSQL_EXECUTE_UPDATE, - TSE_FUNC_TYPE_CLOSE_MYSQL_CONNECTION, - TSE_FUNC_TYPE_LOCK_TABLES, - TSE_FUNC_TYPE_UNLOCK_TABLES, - TSE_FUNC_TYPE_EXECUTE_REWRITE_OPEN_CONN, - TSE_FUNC_TYPE_INVALIDATE_OBJECTS, - TSE_FUNC_TYPE_INVALIDATE_ALL_OBJECTS, - TSE_FUNC_TYPE_UPDATE_DDCACHE, - TSE_FUNC_TYPE_NUMBER, + CTC_FUNC_TYPE_MYSQL_EXECUTE_UPDATE, + CTC_FUNC_TYPE_CLOSE_MYSQL_CONNECTION, + CTC_FUNC_TYPE_LOCK_TABLES, + CTC_FUNC_TYPE_UNLOCK_TABLES, + CTC_FUNC_TYPE_EXECUTE_REWRITE_OPEN_CONN, + CTC_FUNC_TYPE_INVALIDATE_OBJECTS, + CTC_FUNC_TYPE_INVALIDATE_ALL_OBJECTS, + CTC_FUNC_TYPE_UPDATE_DDCACHE, + CTC_FUNC_TYPE_NUMBER, }; typedef enum en_select_mode { SELECT_ORDINARY, /* default behaviour */ SELECT_SKIP_LOCKED, /* skip the row if row is locked */ SELECT_NOWAIT /* return immediately if row is locked */ -} tse_select_mode_t; +} ctc_select_mode_t; typedef enum { - TSE_DDL_TYPE_UNKNOW = -1, - TSE_DDL_TYPE_DECIMAL, - TSE_DDL_TYPE_TINY, - TSE_DDL_TYPE_SHORT, - TSE_DDL_TYPE_LONG, - TSE_DDL_TYPE_FLOAT, - TSE_DDL_TYPE_DOUBLE, - TSE_DDL_TYPE_NULL, - TSE_DDL_TYPE_TIMESTAMP, - TSE_DDL_TYPE_LONGLONG, - TSE_DDL_TYPE_INT24, - TSE_DDL_TYPE_DATE, - TSE_DDL_TYPE_TIME, - TSE_DDL_TYPE_DATETIME, - TSE_DDL_TYPE_YEAR, - TSE_DDL_TYPE_NEWDATE, /**< Internal to TSE_DDL. Not used in protocol */ - TSE_DDL_TYPE_VARCHAR, - TSE_DDL_TYPE_BIT, - TSE_DDL_TYPE_TIMESTAMP2, - TSE_DDL_TYPE_DATETIME2, /**< Internal to TSE_DDL. Not used in protocol */ - TSE_DDL_TYPE_TIME2, /**< Internal to TSE_DDL. Not used in protocol */ - TSE_DDL_TYPE_TYPED_ARRAY, /**< Used for replication only */ - TSE_DDL_TYPE_JSON = 245, - TSE_DDL_TYPE_NEWDECIMAL = 246, - TSE_DDL_TYPE_CLOB = 247, - TSE_DDL_TYPE_TINY_BLOB = 249, - TSE_DDL_TYPE_MEDIUM_BLOB = 250, - TSE_DDL_TYPE_LONG_BLOB = 251, - TSE_DDL_TYPE_BLOB = 252, - TSE_DDL_TYPE_VAR_STRING = 253, - TSE_DDL_TYPE_STRING = 254, -} enum_tse_ddl_field_types; + CTC_DDL_TYPE_UNKNOW = -1, + CTC_DDL_TYPE_DECIMAL, + CTC_DDL_TYPE_TINY, + CTC_DDL_TYPE_SHORT, + CTC_DDL_TYPE_LONG, + CTC_DDL_TYPE_FLOAT, + CTC_DDL_TYPE_DOUBLE, + CTC_DDL_TYPE_NULL, + CTC_DDL_TYPE_TIMESTAMP, + CTC_DDL_TYPE_LONGLONG, + CTC_DDL_TYPE_INT24, + CTC_DDL_TYPE_DATE, + CTC_DDL_TYPE_TIME, + CTC_DDL_TYPE_DATETIME, + CTC_DDL_TYPE_YEAR, + CTC_DDL_TYPE_NEWDATE, /**< Internal to CTC_DDL. Not used in protocol */ + CTC_DDL_TYPE_VARCHAR, + CTC_DDL_TYPE_BIT, + CTC_DDL_TYPE_TIMESTAMP2, + CTC_DDL_TYPE_DATETIME2, /**< Internal to CTC_DDL. Not used in protocol */ + CTC_DDL_TYPE_TIME2, /**< Internal to CTC_DDL. Not used in protocol */ + CTC_DDL_TYPE_TYPED_ARRAY, /**< Used for replication only */ + CTC_DDL_TYPE_JSON = 245, + CTC_DDL_TYPE_NEWDECIMAL = 246, + CTC_DDL_TYPE_CLOB = 247, + CTC_DDL_TYPE_TINY_BLOB = 249, + CTC_DDL_TYPE_MEDIUM_BLOB = 250, + CTC_DDL_TYPE_LONG_BLOB = 251, + CTC_DDL_TYPE_BLOB = 252, + CTC_DDL_TYPE_VAR_STRING = 253, + CTC_DDL_TYPE_STRING = 254, +} enum_ctc_ddl_field_types; typedef enum { - TSE_ALTER_TABLE_DROP_UNKNOW = -1, - TSE_ALTER_TABLE_DROP_KEY, - TSE_ALTER_TABLE_DROP_COLUMN, - TSE_ALTER_TABLE_DROP_FOREIGN_KEY, - TSE_ALTER_TABLE_DROP_CHECK_CONSTRAINT, - TSE_ALTER_TABLE_DROP_ANY_CONSTRAINT -} tse_alter_table_drop_type; + CTC_ALTER_TABLE_DROP_UNKNOW = -1, + CTC_ALTER_TABLE_DROP_KEY, + CTC_ALTER_TABLE_DROP_COLUMN, + CTC_ALTER_TABLE_DROP_FOREIGN_KEY, + CTC_ALTER_TABLE_DROP_CHECK_CONSTRAINT, + CTC_ALTER_TABLE_DROP_ANY_CONSTRAINT +} ctc_alter_table_drop_type; typedef enum { - TSE_ALTER_COLUMN_UNKNOW = -1, - TSE_ALTER_COLUMN_SET_DEFAULT, - TSE_ALTER_COLUMN_DROP_DEFAULT, - TSE_ALTER_COLUMN_RENAME_COLUMN, - TSE_ALTER_COLUMN_SET_COLUMN_VISIBLE, - TSE_ALTER_COLUMN_SET_COLUMN_INVISIBLE -} tse_alter_column_type; + CTC_ALTER_COLUMN_UNKNOW = -1, + CTC_ALTER_COLUMN_SET_DEFAULT, + CTC_ALTER_COLUMN_DROP_DEFAULT, + CTC_ALTER_COLUMN_RENAME_COLUMN, + CTC_ALTER_COLUMN_SET_COLUMN_VISIBLE, + CTC_ALTER_COLUMN_SET_COLUMN_INVISIBLE +} ctc_alter_column_type; typedef enum { - TSE_ALTER_COLUMN_ALTER_MODE_NONE = -1, - TSE_ALTER_COLUMN_ALTER_ADD_COLUMN = 1, // 添加列 - TSE_ALTER_COLUMN_ALTER_MODIFY_COLUMN = 2, // 修改列 -} tse_alter_column_alter_mode; + CTC_ALTER_COLUMN_ALTER_MODE_NONE = -1, + CTC_ALTER_COLUMN_ALTER_ADD_COLUMN = 1, // 添加列 + CTC_ALTER_COLUMN_ALTER_MODIFY_COLUMN = 2, // 修改列 +} ctc_alter_column_alter_mode; typedef enum { - TSE_KEYTYPE_UNKNOW = -1, - TSE_KEYTYPE_PRIMARY, - TSE_KEYTYPE_UNIQUE, - TSE_KEYTYPE_MULTIPLE, - TSE_KEYTYPE_FULLTEXT, - TSE_KEYTYPE_SPATIAL, - TSE_KEYTYPE_FOREIGN -} tse_key_type; + CTC_KEYTYPE_UNKNOW = -1, + CTC_KEYTYPE_PRIMARY, + CTC_KEYTYPE_UNIQUE, + CTC_KEYTYPE_MULTIPLE, + CTC_KEYTYPE_FULLTEXT, + CTC_KEYTYPE_SPATIAL, + CTC_KEYTYPE_FOREIGN +} ctc_key_type; typedef enum { - TSE_PART_TYPE_INVALID = 0, - TSE_PART_TYPE_RANGE = 1, - TSE_PART_TYPE_LIST = 2, - TSE_PART_TYPE_HASH = 3, -} tse_part_type; - -typedef enum en_tse_lock_table_mode { - TSE_LOCK_MODE_SHARE = 0, /* SHARE */ - TSE_LOCK_MODE_EXCLUSIVE /* EXCLUSIVE */ -} tse_lock_table_mode_t; - -typedef struct tse_db_infos { + CTC_PART_TYPE_INVALID = 0, + CTC_PART_TYPE_RANGE = 1, + CTC_PART_TYPE_LIST = 2, + CTC_PART_TYPE_HASH = 3, +} ctc_part_type; + +typedef enum en_ctc_lock_table_mode { + CTC_LOCK_MODE_SHARE = 0, /* SHARE */ + CTC_LOCK_MODE_EXCLUSIVE /* EXCLUSIVE */ +} ctc_lock_table_mode_t; + +typedef struct ctc_db_infos { char *name; uint32_t datafile_size; bool datafile_autoextend; uint32_t datafile_extend_size; -} tse_db_infos_t; - -typedef enum en_tse_func_type_t { - TSE_UNKNOWN_FUNC, - TSE_EQ_FUNC, - TSE_EQUAL_FUNC, - TSE_NE_FUNC, - TSE_LT_FUNC, - TSE_LE_FUNC, - TSE_GE_FUNC, - TSE_GT_FUNC, - TSE_LIKE_FUNC, - TSE_ISNULL_FUNC, - TSE_ISNOTNULL_FUNC, - TSE_NOT_FUNC, - TSE_COND_AND_FUNC, - TSE_COND_OR_FUNC, - TSE_XOR_FUNC -} tse_func_type_t; - -typedef struct en_tse_cond_field_t { +} ctc_db_infos_t; + +typedef enum en_ctc_func_type_t { + CTC_UNKNOWN_FUNC, + CTC_EQ_FUNC, + CTC_EQUAL_FUNC, + CTC_NE_FUNC, + CTC_LT_FUNC, + CTC_LE_FUNC, + CTC_GE_FUNC, + CTC_GT_FUNC, + CTC_LIKE_FUNC, + CTC_ISNULL_FUNC, + CTC_ISNOTNULL_FUNC, + CTC_NOT_FUNC, + CTC_COND_AND_FUNC, + CTC_COND_OR_FUNC, + CTC_XOR_FUNC +} ctc_func_type_t; + +typedef struct en_ctc_cond_field_t { uint16_t field_no; - enum_tse_ddl_field_types field_type; + enum_ctc_ddl_field_types field_type; uint16_t field_size; void *field_value; bool null_value; @@ -472,21 +472,21 @@ typedef struct en_tse_cond_field_t { bool col_updated; bool index_only_invalid_col; // col in cond but not in index while select with index_only bool no_backslash; -} tse_cond_field; - -struct en_tse_cond_list_t; -typedef struct en_tse_cond_t { - tse_func_type_t func_type; - tse_cond_field field_info; - struct en_tse_cond_list_t *cond_list; - struct en_tse_cond_t *next; -} tse_conds; - -typedef struct en_tse_cond_list_t { - tse_conds *first; - tse_conds *last; +} ctc_cond_field; + +struct en_ctc_cond_list_t; +typedef struct en_ctc_cond_t { + ctc_func_type_t func_type; + ctc_cond_field field_info; + struct en_ctc_cond_list_t *cond_list; + struct en_ctc_cond_t *next; +} ctc_conds; + +typedef struct en_ctc_cond_list_t { + ctc_conds *first; + ctc_conds *last; uint16_t elements; -} tse_cond_list; +} ctc_cond_list; typedef struct { uint64_t ignore : 1; @@ -514,116 +514,116 @@ typedef struct { /* General Control Interface */ int srv_wait_instance_startuped(void); -int tse_alloc_inst_id(uint32_t *inst_id); -int tse_release_inst_id(uint32_t inst_id); +int ctc_alloc_inst_id(uint32_t *inst_id); +int ctc_release_inst_id(uint32_t inst_id); -int tse_open_table(tianchi_handler_t *tch, const char *table_name, const char *user_name); -int tse_close_table(tianchi_handler_t *tch); +int ctc_open_table(ctc_handler_t *tch, const char *table_name, const char *user_name); +int ctc_close_table(ctc_handler_t *tch); -int tse_close_session(tianchi_handler_t *tch); -void tse_kill_session(tianchi_handler_t *tch); +int ctc_close_session(ctc_handler_t *tch); +void ctc_kill_session(ctc_handler_t *tch); -uint8_t *tse_alloc_buf(tianchi_handler_t *tch, uint32_t buf_size); -void tse_free_buf(tianchi_handler_t *tch, uint8_t *buf); +uint8_t *ctc_alloc_buf(ctc_handler_t *tch, uint32_t buf_size); +void ctc_free_buf(ctc_handler_t *tch, uint8_t *buf); /* Data Manipulation Language(DML) Related Interface */ -int tse_write_row(tianchi_handler_t *tch, const record_info_t *record_info, +int ctc_write_row(ctc_handler_t *tch, const record_info_t *record_info, uint16_t serial_column_offset, uint64_t *last_insert_id, dml_flag_t flag); -int tse_update_job(update_job_info info); +int ctc_update_job(update_job_info info); /* corresponds to cantian. */ -int tse_bulk_write(tianchi_handler_t *tch, const record_info_t *record_info, uint64_t rec_num, +int ctc_bulk_write(ctc_handler_t *tch, const record_info_t *record_info, uint64_t rec_num, uint32_t *err_pos, dml_flag_t flag, ctc_part_t *part_ids); -int tse_update_row(tianchi_handler_t *tch, uint16_t new_record_len, const uint8_t *new_record, +int ctc_update_row(ctc_handler_t *tch, uint16_t new_record_len, const uint8_t *new_record, const uint16_t *upd_cols, uint16_t col_num, dml_flag_t flag); -int tse_delete_row(tianchi_handler_t *tch, uint16_t record_len, dml_flag_t flag); -int tse_rnd_init(tianchi_handler_t *tch, expected_cursor_action_t action, - tse_select_mode_t mode, tse_conds *cond); -int tse_rnd_end(tianchi_handler_t *tch); -int tse_rnd_next(tianchi_handler_t *tch, record_info_t *record_info); -int tse_rnd_prefetch(tianchi_handler_t *tch, uint8_t *records, uint16_t *record_lens, +int ctc_delete_row(ctc_handler_t *tch, uint16_t record_len, dml_flag_t flag); +int ctc_rnd_init(ctc_handler_t *tch, expected_cursor_action_t action, + ctc_select_mode_t mode, ctc_conds *cond); +int ctc_rnd_end(ctc_handler_t *tch); +int ctc_rnd_next(ctc_handler_t *tch, record_info_t *record_info); +int ctc_rnd_prefetch(ctc_handler_t *tch, uint8_t *records, uint16_t *record_lens, uint32_t *recNum, uint64_t *rowids, int32_t max_row_size); -int tse_position(tianchi_handler_t *tch, uint8_t *position, uint16_t pos_length); -int tse_rnd_pos(tianchi_handler_t *tch, uint16_t pos_length, uint8_t *position, record_info_t *record_info); -int tse_delete_all_rows(tianchi_handler_t *tch, dml_flag_t flag); -int tse_scan_records(tianchi_handler_t *tch, uint64_t *num_rows, char *index_name); +int ctc_position(ctc_handler_t *tch, uint8_t *position, uint16_t pos_length); +int ctc_rnd_pos(ctc_handler_t *tch, uint16_t pos_length, uint8_t *position, record_info_t *record_info); +int ctc_delete_all_rows(ctc_handler_t *tch, dml_flag_t flag); +int ctc_scan_records(ctc_handler_t *tch, uint64_t *num_rows, char *index_name); /* Index Related Interface */ -int tse_index_end(tianchi_handler_t *tch); -int tse_index_read(tianchi_handler_t *tch, record_info_t *record_info, index_key_info_t *index_info, - tse_select_mode_t mode, tse_conds *cond, const bool is_replace); -int tse_general_fetch(tianchi_handler_t *tch, record_info_t *record_info); -int tse_general_prefetch(tianchi_handler_t *tch, uint8_t *records, uint16_t *record_lens, +int ctc_index_end(ctc_handler_t *tch); +int ctc_index_read(ctc_handler_t *tch, record_info_t *record_info, index_key_info_t *index_info, + ctc_select_mode_t mode, ctc_conds *cond, const bool is_replace); +int ctc_general_fetch(ctc_handler_t *tch, record_info_t *record_info); +int ctc_general_prefetch(ctc_handler_t *tch, uint8_t *records, uint16_t *record_lens, uint32_t *recNum, uint64_t *rowids, int32_t max_row_size); -int tse_free_session_cursors(tianchi_handler_t *tch, uint64_t *cursors, int32_t csize); +int ctc_free_session_cursors(ctc_handler_t *tch, uint64_t *cursors, int32_t csize); /* Transaction Related Interface */ -int tse_trx_begin(tianchi_handler_t *tch, tianchi_trx_context_t trx_context, bool is_mysql_local); -int tse_trx_commit(tianchi_handler_t *tch, uint64_t *cursors, int32_t csize, bool *is_ddl_commit); -int tse_trx_rollback(tianchi_handler_t *tch, uint64_t *cursors, int32_t csize); +int ctc_trx_begin(ctc_handler_t *tch, ctc_trx_context_t trx_context, bool is_mysql_local); +int ctc_trx_commit(ctc_handler_t *tch, uint64_t *cursors, int32_t csize, bool *is_ddl_commit); +int ctc_trx_rollback(ctc_handler_t *tch, uint64_t *cursors, int32_t csize); -int tse_srv_set_savepoint(tianchi_handler_t *tch, const char *name); -int tse_srv_rollback_savepoint(tianchi_handler_t *tch, uint64_t *cursors, int32_t csize, const char *name); -int tse_srv_release_savepoint(tianchi_handler_t *tch, const char *name); +int ctc_srv_set_savepoint(ctc_handler_t *tch, const char *name); +int ctc_srv_rollback_savepoint(ctc_handler_t *tch, uint64_t *cursors, int32_t csize, const char *name); +int ctc_srv_release_savepoint(ctc_handler_t *tch, const char *name); /* Optimizer Related Interface */ -int tse_analyze_table(tianchi_handler_t *tch, const char *db_name, const char *table_name, double sampling_ratio); -int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, tse_cbo_stats_table_t *tse_cbo_stats_table, uint32_t first_partid, uint32_t num_part_fetch); -int tse_get_index_name(tianchi_handler_t *tch, char *index_name); +int ctc_analyze_table(ctc_handler_t *tch, const char *db_name, const char *table_name, double sampling_ratio); +int ctc_get_cbo_stats(ctc_handler_t *tch, ctc_cbo_stats_t *stats, ctc_cbo_stats_table_t *ctc_cbo_stats_table, uint32_t first_partid, uint32_t num_part_fetch); +int ctc_get_index_name(ctc_handler_t *tch, char *index_name); /* Datatype Related Interface */ -int tse_knl_write_lob(tianchi_handler_t *tch, char *locator, uint32_t locator_size, +int ctc_knl_write_lob(ctc_handler_t *tch, char *locator, uint32_t locator_size, int column_id, void *data, uint32_t data_len, bool force_outline); -int tse_knl_read_lob(tianchi_handler_t *tch, char* loc, uint32_t offset, +int ctc_knl_read_lob(ctc_handler_t *tch, char* loc, uint32_t offset, void *buf, uint32_t size, uint32_t *read_size); /* Data Definition Language(DDL) Related Interface */ -int tse_lock_table(tianchi_handler_t *tch, const char *db_name, tse_lock_table_info *lock_info, int *error_code); -int tse_unlock_table(tianchi_handler_t *tch, uint32_t mysql_inst_id, tse_lock_table_info *lock_info); +int ctc_lock_table(ctc_handler_t *tch, const char *db_name, ctc_lock_table_info *lock_info, int *error_code); +int ctc_unlock_table(ctc_handler_t *tch, uint32_t mysql_inst_id, ctc_lock_table_info *lock_info); -int tse_lock_instance(bool *is_mysqld_starting, tse_lock_table_mode_t lock_type, tianchi_handler_t *tch); -int tse_unlock_instance(bool *is_mysqld_starting, tianchi_handler_t *tch); +int ctc_lock_instance(bool *is_mysqld_starting, ctc_lock_table_mode_t lock_type, ctc_handler_t *tch); +int ctc_unlock_instance(bool *is_mysqld_starting, ctc_handler_t *tch); -int tse_drop_tablespace_and_user(tianchi_handler_t *tch, const char *db_name, +int ctc_drop_tablespace_and_user(ctc_handler_t *tch, const char *db_name, const char *sql_str, const char *user_name, const char *user_ip, int *error_code, char *error_message); -int tse_drop_db_pre_check(tianchi_handler_t *tch, const char *db_name, int *error_code, char *error_message); -int tse_pre_create_db(tianchi_handler_t *tch, const char *sql_str, tse_db_infos_t *db_infos, +int ctc_drop_db_pre_check(ctc_handler_t *tch, const char *db_name, int *error_code, char *error_message); +int ctc_pre_create_db(ctc_handler_t *tch, const char *sql_str, ctc_db_infos_t *db_infos, int *error_code, char *error_message); -int tse_create_tablespace(void *space_def, ddl_ctrl_t *ddl_ctrl); -int tse_alter_tablespace(void *space_alter_def, ddl_ctrl_t *ddl_ctrl); -int tse_drop_tablespace(void *space_drop_def, ddl_ctrl_t *ddl_ctrl); +int ctc_create_tablespace(void *space_def, ddl_ctrl_t *ddl_ctrl); +int ctc_alter_tablespace(void *space_alter_def, ddl_ctrl_t *ddl_ctrl); +int ctc_drop_tablespace(void *space_drop_def, ddl_ctrl_t *ddl_ctrl); -int tse_create_table(void *table_def, ddl_ctrl_t *ddl_ctrl); -int tse_alter_table(void *alter_def, ddl_ctrl_t *ddl_ctrl); -int tse_truncate_table(void *table_def, ddl_ctrl_t *ddl_ctrl); -int tse_truncate_partition(void *table_def, ddl_ctrl_t *ddl_ctrl); -int tse_rename_table(void *alter_def, ddl_ctrl_t *ddl_ctrl); -int tse_drop_table(void *drop_def, ddl_ctrl_t *ddl_ctrl); +int ctc_create_table(void *table_def, ddl_ctrl_t *ddl_ctrl); +int ctc_alter_table(void *alter_def, ddl_ctrl_t *ddl_ctrl); +int ctc_truncate_table(void *table_def, ddl_ctrl_t *ddl_ctrl); +int ctc_truncate_partition(void *table_def, ddl_ctrl_t *ddl_ctrl); +int ctc_rename_table(void *alter_def, ddl_ctrl_t *ddl_ctrl); +int ctc_drop_table(void *drop_def, ddl_ctrl_t *ddl_ctrl); -int tse_get_max_sessions_per_node(uint32_t *max_sessions); -int tse_get_serial_value(tianchi_handler_t *tch, uint64_t *value, dml_flag_t flag); +int ctc_get_max_sessions_per_node(uint32_t *max_sessions); +int ctc_get_serial_value(ctc_handler_t *tch, uint64_t *value, dml_flag_t flag); int close_mysql_connection(uint32_t thd_id, uint32_t mysql_inst_id); -int tse_ddl_execute_lock_tables(tianchi_handler_t *tch, char *db_name, tse_lock_table_info *lock_info, int *err_code); -int tse_ddl_execute_unlock_tables(tianchi_handler_t *tch, uint32_t mysql_inst_id, tse_lock_table_info *lock_info); -EXTER_ATTACK int tse_ddl_execute_update(uint32_t thd_id, tse_ddl_broadcast_request *broadcast_req, bool *allow_fail); -EXTER_ATTACK int tse_execute_mysql_ddl_sql(tianchi_handler_t *tch, tse_ddl_broadcast_request *broadcast_req, bool allow_fail); -int tse_execute_rewrite_open_conn(uint32_t thd_id, tse_ddl_broadcast_request *broadcast_req); -int tse_broadcast_rewrite_sql(tianchi_handler_t *tch, tse_ddl_broadcast_request *broadcast_req, bool allow_fail); +int ctc_ddl_execute_lock_tables(ctc_handler_t *tch, char *db_name, ctc_lock_table_info *lock_info, int *err_code); +int ctc_ddl_execute_unlock_tables(ctc_handler_t *tch, uint32_t mysql_inst_id, ctc_lock_table_info *lock_info); +EXTER_ATTACK int ctc_ddl_execute_update(uint32_t thd_id, ctc_ddl_broadcast_request *broadcast_req, bool *allow_fail); +EXTER_ATTACK int ctc_execute_mysql_ddl_sql(ctc_handler_t *tch, ctc_ddl_broadcast_request *broadcast_req, bool allow_fail); +int ctc_execute_rewrite_open_conn(uint32_t thd_id, ctc_ddl_broadcast_request *broadcast_req); +int ctc_broadcast_rewrite_sql(ctc_handler_t *tch, ctc_ddl_broadcast_request *broadcast_req, bool allow_fail); /* Metadata Related Interface */ -int tse_check_db_table_exists(const char *db, const char *name, bool *is_exists); -int tse_search_metadata_status(bool *cantian_metadata_switch, bool *cantian_cluster_ready); +int ctc_check_db_table_exists(const char *db, const char *name, bool *is_exists); +int ctc_search_metadata_status(bool *cantian_metadata_switch, bool *cantian_cluster_ready); -int tse_invalidate_mysql_dd_cache(tianchi_handler_t *tch, tse_invalidate_broadcast_request *broadcast_req, int *err_code); -int tse_broadcast_mysql_dd_invalidate(tianchi_handler_t *tch, tse_invalidate_broadcast_request *broadcast_req); +int ctc_invalidate_mysql_dd_cache(ctc_handler_t *tch, ctc_invalidate_broadcast_request *broadcast_req, int *err_code); +int ctc_broadcast_mysql_dd_invalidate(ctc_handler_t *tch, ctc_invalidate_broadcast_request *broadcast_req); /* Disaster Recovery Related Interface*/ -int tse_set_cluster_role_by_cantian(bool is_slave); +int ctc_set_cluster_role_by_cantian(bool is_slave); -int ctc_record_sql_for_cantian(tianchi_handler_t *tch, tse_ddl_broadcast_request *broadcast_req, bool allow_fail); -int tse_query_cluster_role(bool *is_slave, bool *cantian_cluster_ready); +int ctc_record_sql_for_cantian(ctc_handler_t *tch, ctc_ddl_broadcast_request *broadcast_req, bool allow_fail); +int ctc_query_cluster_role(bool *is_slave, bool *cantian_cluster_ready); int ctc_query_shm_file_num(uint32_t *shm_file_num); int ctc_query_shm_usage(uint32_t *shm_usage); diff --git a/storage/tianchi/tse_srv_mq_module.cc b/storage/ctc/ctc_srv_mq_module.cc similarity index 72% rename from storage/tianchi/tse_srv_mq_module.cc rename to storage/ctc/ctc_srv_mq_module.cc index b04edf8..930c530 100644 --- a/storage/tianchi/tse_srv_mq_module.cc +++ b/storage/ctc/ctc_srv_mq_module.cc @@ -16,17 +16,17 @@ */ #include "srv_mq_msg.h" -#include "tse_srv_mq_module.h" +#include "ctc_srv_mq_module.h" #include #include #include #include #include "assert.h" -#include "tse_error.h" -#include "tse_log.h" +#include "ctc_error.h" +#include "ctc_log.h" #include "message_queue/dsw_shm.h" -#include "tse_stats.h" -#include "ha_tse.h" +#include "ctc_stats.h" +#include "ha_ctc.h" #define MQ_THD_NUM 1 #define MAX_DDL_THD_NUM 1024 @@ -35,7 +35,7 @@ using namespace std; #define CTC_IGNORE_ERROR_WHEN_MYSQL_SHUTDOWN(req, tag) \ do { \ if ((req)->result != 0 && get_server_state() == SERVER_SHUTTING_DOWN) { \ - tse_log_error("%s failed,server will shutdown:result:%d", (tag), \ + ctc_log_error("%s failed,server will shutdown:result:%d", (tag), \ (req)->result); \ (req)->result = 0; \ } \ @@ -53,73 +53,73 @@ int g_shm_client_id(-1); static void* mq_msg_handler(void *arg) { pthread_detach(pthread_self()); dsw_message_block_t *message_block = (dsw_message_block_t *)arg; - tse_log_note("recv msg ! cmd:%d", message_block->head.cmd_type); + ctc_log_note("recv msg ! cmd:%d", message_block->head.cmd_type); switch (message_block->head.cmd_type) { - case TSE_FUNC_TYPE_EXECUTE_REWRITE_OPEN_CONN: { + case CTC_FUNC_TYPE_EXECUTE_REWRITE_OPEN_CONN: { execute_ddl_mysql_sql_request *req = (execute_ddl_mysql_sql_request *)message_block->seg_buf[0]; - req->result = tse_execute_rewrite_open_conn(req->thd_id, &req->broadcast_req); - tse_log_note("execute_rewrite_open_conn : sql_txt:%s,result:%d", req->broadcast_req.sql_str, req->result); - CTC_IGNORE_ERROR_WHEN_MYSQL_SHUTDOWN(req, "tse_ddl_execute_update"); + req->result = ctc_execute_rewrite_open_conn(req->thd_id, &req->broadcast_req); + ctc_log_note("execute_rewrite_open_conn : sql_txt:%s,result:%d", req->broadcast_req.sql_str, req->result); + CTC_IGNORE_ERROR_WHEN_MYSQL_SHUTDOWN(req, "ctc_ddl_execute_update"); break; } - case TSE_FUNC_TYPE_MYSQL_EXECUTE_UPDATE: { + case CTC_FUNC_TYPE_MYSQL_EXECUTE_UPDATE: { execute_ddl_mysql_sql_request *req = (execute_ddl_mysql_sql_request *)message_block->seg_buf[0]; - req->result = tse_ddl_execute_update(req->thd_id, &req->broadcast_req, &req->allow_fail); - tse_log_system("[Disaster Recovery] execute_ddl_mysql_sql : db:%s, sql_txt:%s,result:%d", req->broadcast_req.db_name, + req->result = ctc_ddl_execute_update(req->thd_id, &req->broadcast_req, &req->allow_fail); + ctc_log_system("[Disaster Recovery] execute_ddl_mysql_sql : db:%s, sql_txt:%s,result:%d", req->broadcast_req.db_name, req->broadcast_req.sql_str, req->result); - tse_log_note("execute_ddl_mysql_sql : db:%s, sql_txt:%s,result:%d", req->broadcast_req.db_name, + ctc_log_note("execute_ddl_mysql_sql : db:%s, sql_txt:%s,result:%d", req->broadcast_req.db_name, req->broadcast_req.sql_str, req->result); - CTC_IGNORE_ERROR_WHEN_MYSQL_SHUTDOWN(req, "tse_ddl_execute_update"); + CTC_IGNORE_ERROR_WHEN_MYSQL_SHUTDOWN(req, "ctc_ddl_execute_update"); break; } - case TSE_FUNC_TYPE_CLOSE_MYSQL_CONNECTION: { + case CTC_FUNC_TYPE_CLOSE_MYSQL_CONNECTION: { struct close_mysql_connection_request *req = (struct close_mysql_connection_request *)message_block->seg_buf[0]; req->result = close_mysql_connection(req->thd_id, req->inst_id); - tse_log_note("close_connection : thd_id : %d, inst_id : %d, ret : %d.", req->thd_id, req->inst_id, req->result); + ctc_log_note("close_connection : thd_id : %d, inst_id : %d, ret : %d.", req->thd_id, req->inst_id, req->result); CTC_IGNORE_ERROR_WHEN_MYSQL_SHUTDOWN(req, "close_mysql_connection"); break; } - case TSE_FUNC_TYPE_LOCK_TABLES: { - struct tse_lock_tables_request *req = (struct tse_lock_tables_request *)message_block->seg_buf[0]; - req->result = tse_ddl_execute_lock_tables(&(req->tch), req->db_name, &(req->lock_info), &(req->err_code)); - tse_log_note("lock tables : thd_id : %d, inst_id : %d, ret : %d.", req->tch.thd_id, req->tch.inst_id, + case CTC_FUNC_TYPE_LOCK_TABLES: { + struct ctc_lock_tables_request *req = (struct ctc_lock_tables_request *)message_block->seg_buf[0]; + req->result = ctc_ddl_execute_lock_tables(&(req->tch), req->db_name, &(req->lock_info), &(req->err_code)); + ctc_log_note("lock tables : thd_id : %d, inst_id : %d, ret : %d.", req->tch.thd_id, req->tch.inst_id, req->result); - CTC_IGNORE_ERROR_WHEN_MYSQL_SHUTDOWN(req, "tse_ddl_execute_lock_tables"); + CTC_IGNORE_ERROR_WHEN_MYSQL_SHUTDOWN(req, "ctc_ddl_execute_lock_tables"); break; } - case TSE_FUNC_TYPE_UNLOCK_TABLES: { - struct tse_unlock_tables_request *req = (struct tse_unlock_tables_request *)message_block->seg_buf[0]; - req->result = tse_ddl_execute_unlock_tables(&(req->tch), req->mysql_inst_id, &(req->lock_info)); - tse_log_note("unlock tables : thd_id : %d, inst_id : %d, ret : %d.", req->tch.thd_id, req->tch.inst_id, + case CTC_FUNC_TYPE_UNLOCK_TABLES: { + struct ctc_unlock_tables_request *req = (struct ctc_unlock_tables_request *)message_block->seg_buf[0]; + req->result = ctc_ddl_execute_unlock_tables(&(req->tch), req->mysql_inst_id, &(req->lock_info)); + ctc_log_note("unlock tables : thd_id : %d, inst_id : %d, ret : %d.", req->tch.thd_id, req->tch.inst_id, req->result); - CTC_IGNORE_ERROR_WHEN_MYSQL_SHUTDOWN(req, "tse_ddl_execute_unlock_tables"); + CTC_IGNORE_ERROR_WHEN_MYSQL_SHUTDOWN(req, "ctc_ddl_execute_unlock_tables"); break; } - case TSE_FUNC_TYPE_INVALIDATE_OBJECTS: { + case CTC_FUNC_TYPE_INVALIDATE_OBJECTS: { struct invalidate_mysql_dd_request *req = (struct invalidate_mysql_dd_request *)message_block->seg_buf[0]; - req->result = tse_invalidate_mysql_dd_cache(&(req->tch), &req->broadcast_req, &(req->err_code)); - tse_log_note("invalidate dd cache: thd_id : %d, inst_id : %d, ret : %d.", req->tch.thd_id, req->tch.inst_id, + req->result = ctc_invalidate_mysql_dd_cache(&(req->tch), &req->broadcast_req, &(req->err_code)); + ctc_log_note("invalidate dd cache: thd_id : %d, inst_id : %d, ret : %d.", req->tch.thd_id, req->tch.inst_id, req->result); - CTC_IGNORE_ERROR_WHEN_MYSQL_SHUTDOWN(req, "tse_invalidate_mysql_dd_cache"); + CTC_IGNORE_ERROR_WHEN_MYSQL_SHUTDOWN(req, "ctc_invalidate_mysql_dd_cache"); break; } - case TSE_FUNC_SET_CLUSTER_ROLE_BY_CANTIAN: { + case CTC_FUNC_SET_CLUSTER_ROLE_BY_CANTIAN: { struct set_cluster_role_by_cantian_request *req = (struct set_cluster_role_by_cantian_request *)message_block->seg_buf[0]; - req->result = tse_set_cluster_role_by_cantian(req->is_slave); - tse_log_note("[Disaster Recovery] Set cluster role by cantian, is_slave:%d", req->is_slave); - CTC_IGNORE_ERROR_WHEN_MYSQL_SHUTDOWN(req, "tse_set_cluster_role_by_cantian"); + req->result = ctc_set_cluster_role_by_cantian(req->is_slave); + ctc_log_note("[Disaster Recovery] Set cluster role by cantian, is_slave:%d", req->is_slave); + CTC_IGNORE_ERROR_WHEN_MYSQL_SHUTDOWN(req, "ctc_set_cluster_role_by_cantian"); break; } default: { - tse_log_error("cmd type invalid, cmd_type:%d.", message_block->head.cmd_type); + ctc_log_error("cmd type invalid, cmd_type:%d.", message_block->head.cmd_type); break; } } int result = sem_post(&message_block->head.sem); if (result != CT_SUCCESS) { - tse_log_error("sem post failed, result:%d.", result); + ctc_log_error("sem post failed, result:%d.", result); } g_ddl_thd_num--; pthread_exit(0); @@ -132,12 +132,12 @@ int mq_recv_msg(struct shm_seg_s *shm_seg, dsw_message_block_t *message_block) int result; pthread_t thd; if (g_ddl_thd_num > MAX_DDL_THD_NUM) { - tse_log_error("ddl thd has reach max limit: %d", MAX_DDL_THD_NUM); + ctc_log_error("ddl thd has reach max limit: %d", MAX_DDL_THD_NUM); assert(0); } result = pthread_create(&thd, NULL, mq_msg_handler, (void*)message_block); if (result != 0) { - tse_log_error("pthread_create failed, result:%d.", result); + ctc_log_error("pthread_create failed, result:%d.", result); } g_ddl_thd_num++; return result; @@ -146,13 +146,13 @@ int mq_recv_msg(struct shm_seg_s *shm_seg, dsw_message_block_t *message_block) void shm_log_err(char *log_text, int length) { UNUSED_PARAM(length); - tse_log_error("%s", log_text); + ctc_log_error("%s", log_text); } void shm_log_info(char *log_text, int length) { UNUSED_PARAM(length); - tse_log_system("%s", log_text); + ctc_log_system("%s", log_text); } int mq_srv_start(int proc_id) @@ -165,7 +165,7 @@ int mq_srv_start(int proc_id) bool init_shm_segment(int shm_num, int *inst_id) { if (g_shm_segs[shm_num] != nullptr) { - tse_log_system("The segment g_shm_segs[%d] has already been initialized.", shm_num); + ctc_log_system("The segment g_shm_segs[%d] has already been initialized.", shm_num); return true; } shm_key_t shm_key{}; @@ -178,17 +178,17 @@ bool init_shm_segment(int shm_num, int *inst_id) if (shm_num == 0) { if (shm_client_connect(&shm_key, inst_id) < 0) { - tse_log_error("shm client connect failed, shm_name(%s)", shm_key.shm_name); + ctc_log_error("shm client connect failed, shm_name(%s)", shm_key.shm_name); return false; } - ha_tse_set_inst_id((uint32_t) *inst_id); + ha_ctc_set_inst_id((uint32_t) *inst_id); g_shm_client_id = CTC_GET_CLIENT_ID(*inst_id); } g_shm_segs[shm_num] = shm_init(&shm_key, false); if (g_shm_segs[shm_num] == nullptr) { - tse_log_error("shm init failed, shm_seg is null shm_num:%d.", shm_num); + ctc_log_error("shm init failed, shm_seg is null shm_num:%d.", shm_num); return false; } @@ -203,28 +203,28 @@ int init_ctc_mq_moudle() int inst_id = -1; if (shm_tpool_init(MQ_THD_NUM) != 0) { - tse_log_error("shm tpool init failed"); + ctc_log_error("shm tpool init failed"); return -1; } if (!init_shm_segment(0, &inst_id)) { - tse_log_error("shm init failed, shm_seg is null"); + ctc_log_error("shm init failed, shm_seg is null"); return -1; } if (ctc_get_shm_file_num(&g_shm_file_num) != 0) { - tse_log_error("shm init g_shm_file_num failed"); + ctc_log_error("shm init g_shm_file_num failed"); return -1; } for (uint32_t i = 1; i < g_shm_file_num + 1; ++i) { if (!init_shm_segment(i, &inst_id)) { - tse_log_error("shm init failed, init_shm_segment[%u] init failed.", i); + ctc_log_error("shm init failed, init_shm_segment[%u] init failed.", i); return -1; } } return 0; } -int deinit_tse_mq_moudle() +int deinit_ctc_mq_moudle() { for (uint32_t i = 0; i < g_shm_file_num + 1; ++i) { if (g_shm_segs[i] == nullptr) { @@ -243,14 +243,14 @@ int deinit_tse_mq_moudle() return 0; } -int (*tse_init)() = init_ctc_mq_moudle; -int (*tse_deinit)() = deinit_tse_mq_moudle; +int (*ctc_init)() = init_ctc_mq_moudle; +int (*ctc_deinit)() = deinit_ctc_mq_moudle; static int g_group_num = 0; cpu_set_t g_masks[SHM_MAX_SEG_NUM]; static int g_cpu_info[SHM_SEG_MAX_NUM][SMALL_RECORD_SIZE]; -void *get_one_shm_inst(tianchi_handler_t *tch) +void *get_one_shm_inst(ctc_handler_t *tch) { uint32_t hashSeed = tch == nullptr ? 0 : tch->thd_id; if (g_group_num != 0 && tch != nullptr && tch->bind_core != 1) { @@ -279,7 +279,7 @@ void batch_free_shm_buf(void *seg, dsw_message_block_t* msg) if (msg->seg_buf[i]) { shm_free(nullptr, msg->seg_buf[i]); } else { - tse_log_error("seg buf is null, i:%u, seg_num:%u.", i, msg->head.seg_num); + ctc_log_error("seg buf is null, i:%u, seg_num:%u.", i, msg->head.seg_num); } } } @@ -312,26 +312,26 @@ static void set_cpu_mask() } } -static void tse_log_reg_error_by_code(int error_code) +static void ctc_log_reg_error_by_code(int error_code) { switch(error_code) { case ERR_CONNECTION_FAILED: #ifdef WITH_DAAC - tse_log_error("connection failed"); + ctc_log_error("connection failed"); #else - tse_log_error("shm connection failed"); + ctc_log_error("shm connection failed"); #endif break; case REG_MISMATCH_CTC_VERSION: - tse_log_error("CTC client version mismatch server!"); + ctc_log_error("CTC client version mismatch server!"); break; default: - tse_log_error("recv unknown register instance error code %d", error_code); + ctc_log_error("recv unknown register instance error code %d", error_code); break; } } -EXTER_ATTACK int tse_mq_deal_func(void *shm_inst, TSE_FUNC_TYPE func_type, +EXTER_ATTACK int ctc_mq_deal_func(void *shm_inst, CTC_FUNC_TYPE func_type, void *request, void* msg_buf, uint32_t server_id, uint32_t wait_sec) { uint64_t start_time = 0; @@ -350,7 +350,7 @@ EXTER_ATTACK int tse_mq_deal_func(void *shm_inst, TSE_FUNC_TYPE func_type, } if (msg == nullptr) { - tse_log_error("alloc shm failed, len:%lu.", sizeof(dsw_message_block_t)); + ctc_log_error("alloc shm failed, len:%lu.", sizeof(dsw_message_block_t)); return ERR_ALLOC_MEMORY; } int ret = CT_SUCCESS; @@ -362,7 +362,7 @@ EXTER_ATTACK int tse_mq_deal_func(void *shm_inst, TSE_FUNC_TYPE func_type, if (is_alloc) { shm_free(nullptr, msg); } - tse_log_error("sem init failed, ret:%d, func_type:%d.", ret, func_type); + ctc_log_error("sem init failed, ret:%d, func_type:%d.", ret, func_type); return ERR_SEM_FAULT; } @@ -379,12 +379,12 @@ EXTER_ATTACK int tse_mq_deal_func(void *shm_inst, TSE_FUNC_TYPE func_type, ret = shm_send_msg(seg, server_id, msg); if (ret != CT_SUCCESS) { result = ERR_SHM_SEND_MSG_FAILED; - tse_log_error("send msg failed, ret:%d, func_type:%d.", ret, func_type); + ctc_log_error("send msg failed, ret:%d, func_type:%d.", ret, func_type); break; } // register funcs won't relinquish the processor - if (func_type < TSE_FUNC_TYPE_REGISTER_INSTANCE) { + if (func_type < CTC_FUNC_TYPE_REGISTER_INSTANCE) { sched_yield(); } @@ -399,7 +399,7 @@ EXTER_ATTACK int tse_mq_deal_func(void *shm_inst, TSE_FUNC_TYPE func_type, if (ret != CT_SUCCESS) { result = ERR_SEM_FAULT; - tse_log_error("send msg sem wait failed, ret:%d, func_type:%d.", ret, func_type); + ctc_log_error("send msg sem wait failed, ret:%d, func_type:%d.", ret, func_type); break; } } while (0); @@ -407,7 +407,7 @@ EXTER_ATTACK int tse_mq_deal_func(void *shm_inst, TSE_FUNC_TYPE func_type, if (is_alloc) { ret = sem_destroy(&msg->head.sem); if (ret != CT_SUCCESS) { - tse_log_error("sem destory failed, ret:%d, func_type:%d.", ret, func_type); + ctc_log_error("sem destory failed, ret:%d, func_type:%d.", ret, func_type); } shm_free(nullptr, msg); } @@ -420,20 +420,20 @@ EXTER_ATTACK int tse_mq_deal_func(void *shm_inst, TSE_FUNC_TYPE func_type, return result; } -int tse_mq_register_func(void) +int ctc_mq_register_func(void) { mq_srv_start(g_shm_client_id); shm_seg_s *shm_inst = (shm_seg_s *)get_one_shm_inst(nullptr); register_instance_request *req = (register_instance_request *)alloc_share_mem(shm_inst, sizeof(register_instance_request)); if (req == NULL) { - tse_log_error("[TSE_INIT]: alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(register_instance_request)); + ctc_log_error("[CTC_INIT]: alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(register_instance_request)); return ERR_ALLOC_MEMORY; } req->ctc_version = (uint32_t)CTC_CLIENT_VERSION_NUMBER; int result = ERR_CONNECTION_FAILED; - if (tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_REGISTER_INSTANCE, req, nullptr, SERVER_REGISTER_PROC_ID) == CT_SUCCESS) { + if (ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_REGISTER_INSTANCE, req, nullptr, SERVER_REGISTER_PROC_ID) == CT_SUCCESS) { result = req->result; } @@ -441,29 +441,29 @@ int tse_mq_register_func(void) set_cpu_info(req); set_cpu_mask(); } else { - tse_log_reg_error_by_code(result); + ctc_log_reg_error_by_code(result); } shm_free(nullptr, req); return result; } -int tse_mq_get_batch_data(dsw_message_block_t *message_block, uint8_t *buf_data, uint32_t buf_len) +int ctc_mq_get_batch_data(dsw_message_block_t *message_block, uint8_t *buf_data, uint32_t buf_len) { uint32_t use_buf_len = 0; for (uint16_t i = 0; i < message_block->head.seg_num; ++i) { - if (message_block->head.seg_desc[i].length > TSE_MQ_MESSAGE_SLICE_LEN) { - tse_log_error("seg_data length error, seg_len:%u.", message_block->head.seg_desc[i].length); + if (message_block->head.seg_desc[i].length > CTC_MQ_MESSAGE_SLICE_LEN) { + ctc_log_error("seg_data length error, seg_len:%u.", message_block->head.seg_desc[i].length); return ERR_GENERIC_INTERNAL_ERROR; } if (use_buf_len + message_block->head.seg_desc[i].length > buf_len) { - tse_log_error("buf len error, buf_len:%u, use_buf_len:%u.", buf_len, use_buf_len); + ctc_log_error("buf len error, buf_len:%u, use_buf_len:%u.", buf_len, use_buf_len); return ERR_GENERIC_INTERNAL_ERROR; } if (message_block->seg_buf[i] == nullptr) { - tse_log_error("buf_data error, seg_buf[%u] is null.", i); + ctc_log_error("buf_data error, seg_buf[%u] is null.", i); return ERR_GENERIC_INTERNAL_ERROR; } @@ -473,7 +473,7 @@ int tse_mq_get_batch_data(dsw_message_block_t *message_block, uint8_t *buf_data, return CT_SUCCESS; } -static int tse_mq_fill_batch_data(shm_seg_s *seg, dsw_message_block_t* msg, uint8_t* data_buf, +static int ctc_mq_fill_batch_data(shm_seg_s *seg, dsw_message_block_t* msg, uint8_t* data_buf, uint32_t data_len, uint32_t buf_size) { assert(data_len <= buf_size); @@ -485,8 +485,8 @@ static int tse_mq_fill_batch_data(shm_seg_s *seg, dsw_message_block_t* msg, uint uint32_t copy_len; while (tmp_len > 0) { i = msg->head.seg_num; - if (tmp_len > TSE_MQ_MESSAGE_SLICE_LEN) { - msg->head.seg_desc[i].length = TSE_MQ_MESSAGE_SLICE_LEN; + if (tmp_len > CTC_MQ_MESSAGE_SLICE_LEN) { + msg->head.seg_desc[i].length = CTC_MQ_MESSAGE_SLICE_LEN; } else { msg->head.seg_desc[i].length = tmp_len; } @@ -495,13 +495,13 @@ static int tse_mq_fill_batch_data(shm_seg_s *seg, dsw_message_block_t* msg, uint msg->head.seg_desc[i].type = 0; msg->seg_buf[i] = shm_alloc(seg, msg->head.seg_desc[i].length); if (msg->seg_buf[i] == nullptr) { - tse_log_error("Alloc seg_buf failed, seg_num:%u, buf_len:%u.", i, msg->head.seg_desc[i].length); + ctc_log_error("Alloc seg_buf failed, seg_num:%u, buf_len:%u.", i, msg->head.seg_desc[i].length); batch_free_shm_buf(seg, msg); return ERR_ALLOC_MEMORY; } if (data_len > 0) { - copy_len = data_len > TSE_MQ_MESSAGE_SLICE_LEN ? TSE_MQ_MESSAGE_SLICE_LEN : data_len; + copy_len = data_len > CTC_MQ_MESSAGE_SLICE_LEN ? CTC_MQ_MESSAGE_SLICE_LEN : data_len; data_len -= copy_len; memcpy(msg->seg_buf[i], buf_tmp, copy_len); @@ -512,18 +512,18 @@ static int tse_mq_fill_batch_data(shm_seg_s *seg, dsw_message_block_t* msg, uint return CT_SUCCESS; } -EXTER_ATTACK int tse_mq_batch_send_message(void *shm_inst, TSE_FUNC_TYPE func_type, uint8_t* data_buf, +EXTER_ATTACK int ctc_mq_batch_send_message(void *shm_inst, CTC_FUNC_TYPE func_type, uint8_t* data_buf, uint32_t send_data_len, uint32_t buf_size) { - if (buf_size > TSE_MQ_MESSAGE_SLICE_LEN * DSW_MESSAGE_SEGMENT_NUM_MAX) { - tse_log_error("batch send message failed, data_len:%u.", buf_size); + if (buf_size > CTC_MQ_MESSAGE_SLICE_LEN * DSW_MESSAGE_SEGMENT_NUM_MAX) { + ctc_log_error("batch send message failed, data_len:%u.", buf_size); return ERR_GENERIC_INTERNAL_ERROR; } shm_seg_s *seg = (shm_seg_s *)shm_inst; dsw_message_block_t* msg = (dsw_message_block_t*)shm_alloc(seg, sizeof(dsw_message_block_t)); if (msg == nullptr) { - tse_log_error("alloc shm failed, len:%lu.", sizeof(dsw_message_block_t)); + ctc_log_error("alloc shm failed, len:%lu.", sizeof(dsw_message_block_t)); return ERR_ALLOC_MEMORY; } @@ -532,12 +532,12 @@ EXTER_ATTACK int tse_mq_batch_send_message(void *shm_inst, TSE_FUNC_TYPE func_ty if (ret != 0) { shm_free(nullptr, msg); result = ERR_SEM_FAULT; - tse_log_error("sem init failed, ret(%d).", ret); + ctc_log_error("sem init failed, ret(%d).", ret); return result; } do { - ret = tse_mq_fill_batch_data(seg, msg, data_buf, send_data_len, buf_size); + ret = ctc_mq_fill_batch_data(seg, msg, data_buf, send_data_len, buf_size); if (ret != CT_SUCCESS) { result = ERR_BATCH_DATA_HANDLE_FAILED; break; @@ -549,7 +549,7 @@ EXTER_ATTACK int tse_mq_batch_send_message(void *shm_inst, TSE_FUNC_TYPE func_ty ret = shm_send_msg(seg, SERVER_PROC_ID, msg); if (ret != CT_SUCCESS) { result = ERR_SHM_SEND_MSG_FAILED; - tse_log_error("batch send msg failed, ret:%d, func_type:%d.", ret, func_type); + ctc_log_error("batch send msg failed, ret:%d, func_type:%d.", ret, func_type); break; } @@ -557,21 +557,21 @@ EXTER_ATTACK int tse_mq_batch_send_message(void *shm_inst, TSE_FUNC_TYPE func_ty ret = sem_wait(&msg->head.sem); if (ret != CT_SUCCESS) { result = ERR_SEM_FAULT; - tse_log_error("batch send msg sem wait failed, ret:%d, func_type:%d.", ret, func_type); + ctc_log_error("batch send msg sem wait failed, ret:%d, func_type:%d.", ret, func_type); break; } - ret = tse_mq_get_batch_data(msg, data_buf, buf_size); + ret = ctc_mq_get_batch_data(msg, data_buf, buf_size); if (ret != 0) { result = ERR_BATCH_DATA_HANDLE_FAILED; - tse_log_error("get batch data error, data_buf:%p, data_len:%u.", data_buf, buf_size); + ctc_log_error("get batch data error, data_buf:%p, data_len:%u.", data_buf, buf_size); break; } } while (0); ret = sem_destroy(&msg->head.sem); if (ret != CT_SUCCESS) { - tse_log_error("sem destory failed, ret:%d, func_type:%d.", ret, func_type); + ctc_log_error("sem destory failed, ret:%d, func_type:%d.", ret, func_type); } batch_free_shm_buf(seg, msg); shm_free(nullptr, msg); diff --git a/storage/tianchi/tse_srv_mq_module.h b/storage/ctc/ctc_srv_mq_module.h similarity index 79% rename from storage/tianchi/tse_srv_mq_module.h rename to storage/ctc/ctc_srv_mq_module.h index f542c8f..e644e3b 100644 --- a/storage/tianchi/tse_srv_mq_module.h +++ b/storage/ctc/ctc_srv_mq_module.h @@ -15,10 +15,10 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#ifndef __TSE_SRV_MQ_MODULE__ -#define __TSE_SRV_MQ_MODULE__ +#ifndef __CTC_SRV_MQ_MODULE__ +#define __CTC_SRV_MQ_MODULE__ -#include "tse_srv.h" +#include "ctc_srv.h" #include "message_queue/dsw_shm.h" #include "message_queue/dsw_message.h" @@ -26,12 +26,12 @@ extern "C" { #endif /* __cpluscplus */ -void *get_one_shm_inst(tianchi_handler_t *tch); -int tse_mq_register_func(void); -int tse_mq_batch_send_message(void *shm_inst, TSE_FUNC_TYPE func_type, uint8_t* data_buf, +void *get_one_shm_inst(ctc_handler_t *tch); +int ctc_mq_register_func(void); +int ctc_mq_batch_send_message(void *shm_inst, CTC_FUNC_TYPE func_type, uint8_t* data_buf, uint32_t send_data_len, uint32_t buf_size); -int tse_mq_deal_func(void* shm_inst, enum TSE_FUNC_TYPE func_type, void* request,void* msg_buf, +int ctc_mq_deal_func(void* shm_inst, enum CTC_FUNC_TYPE func_type, void* request,void* msg_buf, uint32_t server_id = SERVER_PROC_ID, uint32_t wait_sec = 0); #ifdef __cplusplus diff --git a/storage/tianchi/tse_srv_mq_stub.cc b/storage/ctc/ctc_srv_mq_stub.cc similarity index 73% rename from storage/tianchi/tse_srv_mq_stub.cc rename to storage/ctc/ctc_srv_mq_stub.cc index 2ffbbc8..670c826 100644 --- a/storage/tianchi/tse_srv_mq_stub.cc +++ b/storage/ctc/ctc_srv_mq_stub.cc @@ -16,36 +16,36 @@ */ #include "srv_mq_msg.h" -#include "tse_srv_mq_module.h" +#include "ctc_srv_mq_module.h" #include "message_queue/dsw_shm.h" -#include "tse_error.h" -#include "tse_log.h" -#include "tse_srv.h" -#include "tse_util.h" -#include "ha_tse.h" +#include "ctc_error.h" +#include "ctc_log.h" +#include "ctc_srv.h" +#include "ctc_util.h" +#include "ha_ctc.h" #include "protobuf/tc_db.pb-c.h" #include #define OUTLINE_LOB_LOCATOR_SIZE 44 // 行外LOB数据结构体长度 -// 双进程模式在 tse_init 中已经提前获取 inst_id -int tse_alloc_inst_id(uint32_t *inst_id) { - *inst_id = ha_tse_get_inst_id(); - return tse_mq_register_func(); +// 双进程模式在 ctc_init 中已经提前获取 inst_id +int ctc_alloc_inst_id(uint32_t *inst_id) { + *inst_id = ha_ctc_get_inst_id(); + return ctc_mq_register_func(); } // 双进程模式在 clean_up_for_bad_mysql_proc 中释放 inst_id -int tse_release_inst_id(uint32_t ) { +int ctc_release_inst_id(uint32_t ) { return CT_SUCCESS; } -int tse_open_table(tianchi_handler_t *tch, const char *table_name, const char *user_name) { +int ctc_open_table(ctc_handler_t *tch, const char *table_name, const char *user_name) { void *shm_inst = get_one_shm_inst(tch); uint64_t len = sizeof(open_table_request); open_table_request *req = (open_table_request*)alloc_share_mem(shm_inst, len); DBUG_EXECUTE_IF("open_table_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } @@ -55,7 +55,7 @@ int tse_open_table(tianchi_handler_t *tch, const char *table_name, const char *u req->tch = *tch; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_OPEN_TABLE, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_OPEN_TABLE, req, tch->msg_buf); *tch = req->tch; // 此处不管参天处理成功与否，都需要拷贝一次，避免session泄漏 if (ret == CT_SUCCESS) { result = req->result; @@ -64,18 +64,18 @@ int tse_open_table(tianchi_handler_t *tch, const char *table_name, const char *u return result; } -int tse_close_session(tianchi_handler_t *tch) { - tse_log_note("close session"); +int ctc_close_session(ctc_handler_t *tch) { + ctc_log_note("close session"); void *shm_inst = get_one_shm_inst(tch); close_session_request *req = (close_session_request*)alloc_share_mem(shm_inst, sizeof(close_session_request)); if (req == NULL) { - tse_log_error("[TSE_CLOSE_SESSION]:alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(close_session_request)); + ctc_log_error("[CTC_CLOSE_SESSION]:alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(close_session_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_CLOSE_SESSION, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_CLOSE_SESSION, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { result = req->result; @@ -84,35 +84,35 @@ int tse_close_session(tianchi_handler_t *tch) { return result; } -void tse_kill_session(tianchi_handler_t *tch) { - tse_log_note("kill session"); +void ctc_kill_session(ctc_handler_t *tch) { + ctc_log_note("kill session"); void *shm_inst = get_one_shm_inst(tch); close_session_request *req = (close_session_request*)alloc_share_mem(shm_inst, sizeof(close_session_request)); if (req == NULL) { - tse_log_error("[TSE_KILL_SESSION]:alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(close_session_request)); + ctc_log_error("[CTC_KILL_SESSION]:alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(close_session_request)); return; } req->tch = *tch; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_KILL_CONNECTION, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_KILL_CONNECTION, req, tch->msg_buf); if (ret != CT_SUCCESS) { - tse_log_error("[TSE_KILL_SESSION]:Connection failed when sending kill stmt message to Cantian"); + ctc_log_error("[CTC_KILL_SESSION]:Connection failed when sending kill stmt message to Cantian"); } free_share_mem(shm_inst, req); } -int tse_close_table(tianchi_handler_t *tch) { +int ctc_close_table(ctc_handler_t *tch) { void *shm_inst = get_one_shm_inst(tch); close_table_request *req = (close_table_request*)alloc_share_mem(shm_inst, sizeof(close_table_request)); DBUG_EXECUTE_IF("close_table_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(close_table_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(close_table_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_CLOSE_TABLE, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_CLOSE_TABLE, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { result = req->result; @@ -121,12 +121,12 @@ int tse_close_table(tianchi_handler_t *tch) { return result; } -int tse_write_row(tianchi_handler_t *tch, const record_info_t *record_info, +int ctc_write_row(ctc_handler_t *tch, const record_info_t *record_info, uint16_t serial_column_offset, uint64_t *last_insert_id, dml_flag_t flag) { void *shm_inst = get_one_shm_inst(tch); write_row_request *req = (write_row_request*)alloc_share_mem(shm_inst, sizeof(write_row_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(write_row_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(write_row_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; @@ -136,7 +136,7 @@ int tse_write_row(tianchi_handler_t *tch, const record_info_t *record_info, req->flag = flag; int result = ERR_CONNECTION_FAILED; int ret = CT_SUCCESS; - ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_WRITE_ROW, req, tch->msg_buf); + ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_WRITE_ROW, req, tch->msg_buf); tch->sql_stat_start = req->tch.sql_stat_start; *tch = req->tch; if (ret == CT_SUCCESS) { @@ -147,13 +147,13 @@ int tse_write_row(tianchi_handler_t *tch, const record_info_t *record_info, return result; } -int tse_bulk_write(tianchi_handler_t *tch, const record_info_t *record_info, uint64_t rec_num, +int ctc_bulk_write(ctc_handler_t *tch, const record_info_t *record_info, uint64_t rec_num, uint32_t *err_pos, dml_flag_t flag, ctc_part_t *part_ids) { void *shm_inst = get_one_shm_inst(tch); assert(record_info->record_len * rec_num <= MAX_RECORD_SIZE); bulk_write_request *req = (bulk_write_request*)alloc_share_mem(shm_inst, sizeof(bulk_write_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(bulk_write_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(bulk_write_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; @@ -166,7 +166,7 @@ int tse_bulk_write(tianchi_handler_t *tch, const record_info_t *record_info, uin } int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_BULK_INSERT, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_BULK_INSERT, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { result = req->result; @@ -178,14 +178,14 @@ int tse_bulk_write(tianchi_handler_t *tch, const record_info_t *record_info, uin return result; } -int tse_update_row(tianchi_handler_t *tch, uint16_t new_record_len, const uint8_t *new_record, +int ctc_update_row(ctc_handler_t *tch, uint16_t new_record_len, const uint8_t *new_record, const uint16_t *upd_cols, uint16_t col_num, dml_flag_t flag) { assert(new_record_len < BIG_RECORD_SIZE); - assert(col_num <= TSE_MAX_COLUMNS); + assert(col_num <= CTC_MAX_COLUMNS); void *shm_inst = get_one_shm_inst(tch); update_row_request *req = (update_row_request*)alloc_share_mem(shm_inst, sizeof(update_row_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(update_row_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(update_row_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; @@ -195,7 +195,7 @@ int tse_update_row(tianchi_handler_t *tch, uint16_t new_record_len, const uint8_ req->flag = flag; memcpy(req->upd_cols, upd_cols, sizeof(uint16_t) * col_num); int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_UPDATE_ROW, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_UPDATE_ROW, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { result = req->result; @@ -204,19 +204,19 @@ int tse_update_row(tianchi_handler_t *tch, uint16_t new_record_len, const uint8_ return result; } -int tse_delete_row(tianchi_handler_t *tch, uint16_t record_len, dml_flag_t flag) { +int ctc_delete_row(ctc_handler_t *tch, uint16_t record_len, dml_flag_t flag) { assert(record_len < BIG_RECORD_SIZE); void *shm_inst = get_one_shm_inst(tch); delete_row_request *req = (delete_row_request*)alloc_share_mem(shm_inst, sizeof(delete_row_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(delete_row_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(delete_row_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; req->record_len = record_len; req->flag = flag; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_DELETE_ROW, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_DELETE_ROW, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { result = req->result; @@ -225,12 +225,12 @@ int tse_delete_row(tianchi_handler_t *tch, uint16_t record_len, dml_flag_t flag) return result; } -int tse_scan_records(tianchi_handler_t *tch, uint64_t *num_rows, char *index_name) { +int ctc_scan_records(ctc_handler_t *tch, uint64_t *num_rows, char *index_name) { void *shm_inst = get_one_shm_inst(tch); uint64_t len = sizeof(scan_records_request); scan_records_request *req = (scan_records_request*)alloc_share_mem(shm_inst, len); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } memset(req, 0, len); @@ -240,7 +240,7 @@ int tse_scan_records(tianchi_handler_t *tch, uint64_t *num_rows, char *index_nam } req->tch = *tch; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_SCAN_RECORDS, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_SCAN_RECORDS, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { if (req->result == CT_SUCCESS) { @@ -252,17 +252,17 @@ int tse_scan_records(tianchi_handler_t *tch, uint64_t *num_rows, char *index_nam return result; } -int tse_rnd_next(tianchi_handler_t *tch, record_info_t *record_info) { +int ctc_rnd_next(ctc_handler_t *tch, record_info_t *record_info) { void *shm_inst = get_one_shm_inst(tch); rnd_next_request *req = (rnd_next_request*)alloc_share_mem(shm_inst, sizeof(rnd_next_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(rnd_next_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(rnd_next_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; req->record = record_info->record; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_RND_NEXT, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_RND_NEXT, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { if(req->result == CT_SUCCESS) { @@ -275,20 +275,20 @@ int tse_rnd_next(tianchi_handler_t *tch, record_info_t *record_info) { return result; } -int tse_rnd_prefetch(tianchi_handler_t *tch, uint8_t *records, uint16_t *record_lens, +int ctc_rnd_prefetch(ctc_handler_t *tch, uint8_t *records, uint16_t *record_lens, uint32_t *recNum, uint64_t *rowids, int32_t max_row_size) { void *shm_inst = get_one_shm_inst(tch); rnd_prefetch_request *req = (rnd_prefetch_request*)alloc_share_mem(shm_inst, sizeof(rnd_prefetch_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(rnd_prefetch_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(rnd_prefetch_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; req->max_row_size = max_row_size; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_RND_PREFETCH, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_RND_PREFETCH, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { if (req->result == CT_SUCCESS) { @@ -309,11 +309,11 @@ int tse_rnd_prefetch(tianchi_handler_t *tch, uint8_t *records, uint16_t *record_ return result; } -int tse_rnd_init(tianchi_handler_t *tch, expected_cursor_action_t action, tse_select_mode_t mode, tse_conds *cond) { +int ctc_rnd_init(ctc_handler_t *tch, expected_cursor_action_t action, ctc_select_mode_t mode, ctc_conds *cond) { void *shm_inst = get_one_shm_inst(tch); rnd_init_request *req = (rnd_init_request*)alloc_share_mem(shm_inst, sizeof(rnd_init_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(rnd_init_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(rnd_init_request)); return ERR_ALLOC_MEMORY; } @@ -322,7 +322,7 @@ int tse_rnd_init(tianchi_handler_t *tch, expected_cursor_action_t action, tse_se req->mode = mode; req->cond = cond; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_RND_INIT, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_RND_INIT, req, tch->msg_buf); *tch = req->tch; tch->sql_stat_start = req->tch.sql_stat_start; if (ret == CT_SUCCESS) { @@ -332,17 +332,17 @@ int tse_rnd_init(tianchi_handler_t *tch, expected_cursor_action_t action, tse_se return result; } -int tse_rnd_end(tianchi_handler_t *tch) { +int ctc_rnd_end(ctc_handler_t *tch) { void *shm_inst = get_one_shm_inst(tch); rnd_end_request *req = (rnd_end_request*)alloc_share_mem(shm_inst, sizeof(rnd_end_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(rnd_end_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(rnd_end_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_RND_END, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_RND_END, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { result = req->result; @@ -351,12 +351,12 @@ int tse_rnd_end(tianchi_handler_t *tch) { return result; } -int tse_position(tianchi_handler_t *tch, uint8_t *position, uint16_t pos_length) { +int ctc_position(ctc_handler_t *tch, uint8_t *position, uint16_t pos_length) { assert(pos_length < SMALL_RECORD_SIZE); void *shm_inst = get_one_shm_inst(tch); position_request *req = (position_request*)alloc_share_mem(shm_inst, sizeof(position_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(position_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(position_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; @@ -364,7 +364,7 @@ int tse_position(tianchi_handler_t *tch, uint8_t *position, uint16_t pos_length) memcpy(req->position, position, pos_length); int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_POSITION, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_POSITION, req, tch->msg_buf); if (ret == CT_SUCCESS) { memcpy(position, req->position, pos_length); } @@ -373,12 +373,12 @@ int tse_position(tianchi_handler_t *tch, uint8_t *position, uint16_t pos_length) return result; } -int tse_rnd_pos(tianchi_handler_t *tch, uint16_t pos_length, uint8_t *position, record_info_t *record_info) { +int ctc_rnd_pos(ctc_handler_t *tch, uint16_t pos_length, uint8_t *position, record_info_t *record_info) { assert(pos_length < SMALL_RECORD_SIZE); void *shm_inst = get_one_shm_inst(tch); rnd_pos_request *req = (rnd_pos_request*)alloc_share_mem(shm_inst, sizeof(rnd_pos_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(rnd_pos_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(rnd_pos_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; @@ -388,7 +388,7 @@ int tse_rnd_pos(tianchi_handler_t *tch, uint16_t pos_length, uint8_t *position, memcpy(req->position, position, pos_length); int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_RND_POS, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_RND_POS, req, tch->msg_buf); if (ret == CT_SUCCESS) { if(req->result == CT_SUCCESS) { record_info->record_len = req->record_len; @@ -400,17 +400,17 @@ int tse_rnd_pos(tianchi_handler_t *tch, uint16_t pos_length, uint8_t *position, return result; } -int tse_delete_all_rows(tianchi_handler_t *tch, dml_flag_t flag) { +int ctc_delete_all_rows(ctc_handler_t *tch, dml_flag_t flag) { void *shm_inst = get_one_shm_inst(tch); delete_all_rows_request *req = (delete_all_rows_request*)alloc_share_mem(shm_inst, sizeof(delete_all_rows_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(delete_all_rows_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(delete_all_rows_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; req->flag = flag; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_DELETE_ALL_ROWS, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_DELETE_ALL_ROWS, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { result = req->result; @@ -419,17 +419,17 @@ int tse_delete_all_rows(tianchi_handler_t *tch, dml_flag_t flag) { return result; } -int tse_index_end(tianchi_handler_t *tch) { +int ctc_index_end(ctc_handler_t *tch) { void *shm_inst = get_one_shm_inst(tch); index_end_request *req = (index_end_request*)alloc_share_mem(shm_inst, sizeof(index_end_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(index_end_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(index_end_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_INDEX_END, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_INDEX_END, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { result = req->result; @@ -485,8 +485,8 @@ static void copy_index_info_to_req(const index_key_info_t *index_info, index_rea return; } -int tse_index_read(tianchi_handler_t *tch, record_info_t *record_info, index_key_info_t *index_info, - tse_select_mode_t mode, tse_conds *cond, const bool is_replace) { +int ctc_index_read(ctc_handler_t *tch, record_info_t *record_info, index_key_info_t *index_info, + ctc_select_mode_t mode, ctc_conds *cond, const bool is_replace) { if (index_info == NULL) { return ERR_GENERIC_INTERNAL_ERROR; } @@ -494,7 +494,7 @@ int tse_index_read(tianchi_handler_t *tch, record_info_t *record_info, index_key void *shm_inst = get_one_shm_inst(tch); index_read_request *req = (index_read_request*)alloc_share_mem(shm_inst, sizeof(index_read_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(index_read_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(index_read_request)); return ERR_ALLOC_MEMORY; } @@ -509,7 +509,7 @@ int tse_index_read(tianchi_handler_t *tch, record_info_t *record_info, index_key req->result = 0; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_INDEX_READ, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_INDEX_READ, req, tch->msg_buf); *tch = req->tch; tch->sql_stat_start = req->tch.sql_stat_start; if (ret == CT_SUCCESS) { @@ -526,11 +526,11 @@ int tse_index_read(tianchi_handler_t *tch, record_info_t *record_info, index_key return result; } -int tse_trx_begin(tianchi_handler_t *tch, tianchi_trx_context_t trx_context, bool is_mysql_local) { +int ctc_trx_begin(ctc_handler_t *tch, ctc_trx_context_t trx_context, bool is_mysql_local) { void *shm_inst = get_one_shm_inst(tch); trx_begin_request *req = (trx_begin_request*)alloc_share_mem(shm_inst, sizeof(trx_begin_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(trx_begin_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(trx_begin_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; @@ -538,7 +538,7 @@ int tse_trx_begin(tianchi_handler_t *tch, tianchi_trx_context_t trx_context, boo req->is_mysql_local = is_mysql_local; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_TRX_BEGIN, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_TRX_BEGIN, req, tch->msg_buf); *tch = req->tch; // 此处不管参天处理成功与否，都需要拷贝一次，避免session泄漏 if (ret == CT_SUCCESS) { result = req->result; @@ -547,11 +547,11 @@ int tse_trx_begin(tianchi_handler_t *tch, tianchi_trx_context_t trx_context, boo return result; } -int tse_trx_commit(tianchi_handler_t *tch, uint64_t *cursors, int32_t csize, bool *is_ddl_commit) { +int ctc_trx_commit(ctc_handler_t *tch, uint64_t *cursors, int32_t csize, bool *is_ddl_commit) { void *shm_inst = get_one_shm_inst(tch); trx_commit_request *req = (trx_commit_request*)alloc_share_mem(shm_inst, sizeof(trx_commit_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(trx_commit_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(trx_commit_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; @@ -559,7 +559,7 @@ int tse_trx_commit(tianchi_handler_t *tch, uint64_t *cursors, int32_t csize, boo req->cursors = cursors; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_TRX_COMMIT, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_TRX_COMMIT, req, tch->msg_buf); *is_ddl_commit = req->is_ddl_commit; if (ret == CT_SUCCESS) { result = req->result; @@ -568,11 +568,11 @@ int tse_trx_commit(tianchi_handler_t *tch, uint64_t *cursors, int32_t csize, boo return result; } -int tse_trx_rollback(tianchi_handler_t *tch, uint64_t *cursors, int32_t csize) { +int ctc_trx_rollback(ctc_handler_t *tch, uint64_t *cursors, int32_t csize) { void *shm_inst = get_one_shm_inst(tch); trx_rollback_request *req = (trx_rollback_request*)alloc_share_mem(shm_inst, sizeof(trx_rollback_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(trx_rollback_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(trx_rollback_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; @@ -580,7 +580,7 @@ int tse_trx_rollback(tianchi_handler_t *tch, uint64_t *cursors, int32_t csize) { req->cursors = cursors; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_TRX_ROLLBACK, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_TRX_ROLLBACK, req, tch->msg_buf); if (ret == CT_SUCCESS) { result = req->result; } @@ -588,19 +588,19 @@ int tse_trx_rollback(tianchi_handler_t *tch, uint64_t *cursors, int32_t csize) { return result; } -int tse_srv_set_savepoint(tianchi_handler_t *tch, const char *name) { +int ctc_srv_set_savepoint(ctc_handler_t *tch, const char *name) { void *shm_inst = get_one_shm_inst(tch); uint64_t len = sizeof(srv_set_savepoint_request); srv_set_savepoint_request *req = (srv_set_savepoint_request*)alloc_share_mem(shm_inst, len); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } memset(req, 0, len); strncpy(req->name, name, SMALL_RECORD_SIZE - 1); req->tch = *tch; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_SRV_SET_SAVEPOINT, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_SRV_SET_SAVEPOINT, req, tch->msg_buf); if (ret == CT_SUCCESS) { result = req->result; } @@ -608,11 +608,11 @@ int tse_srv_set_savepoint(tianchi_handler_t *tch, const char *name) { return result; } -int tse_srv_rollback_savepoint(tianchi_handler_t *tch, uint64_t *cursors, int32_t csize, const char *name) { +int ctc_srv_rollback_savepoint(ctc_handler_t *tch, uint64_t *cursors, int32_t csize, const char *name) { void *shm_inst = get_one_shm_inst(tch); srv_rollback_savepoint_request *req = (srv_rollback_savepoint_request*)alloc_share_mem(shm_inst, sizeof(srv_rollback_savepoint_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(srv_rollback_savepoint_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(srv_rollback_savepoint_request)); return ERR_ALLOC_MEMORY; } memset(req->name, 0, SMALL_RECORD_SIZE); @@ -622,7 +622,7 @@ int tse_srv_rollback_savepoint(tianchi_handler_t *tch, uint64_t *cursors, int32_ req->cursors = cursors; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_SRV_ROLLBACK_SAVEPOINT, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_SRV_ROLLBACK_SAVEPOINT, req, tch->msg_buf); if (ret == CT_SUCCESS) { result = req->result; } @@ -630,19 +630,19 @@ int tse_srv_rollback_savepoint(tianchi_handler_t *tch, uint64_t *cursors, int32_ return result; } -int tse_srv_release_savepoint(tianchi_handler_t *tch, const char *name) { +int ctc_srv_release_savepoint(ctc_handler_t *tch, const char *name) { void *shm_inst = get_one_shm_inst(tch); uint64_t len = sizeof(srv_release_savepoint_request); srv_release_savepoint_request *req = (srv_release_savepoint_request*)alloc_share_mem(shm_inst, len); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } memset(req, 0, len); strncpy(req->name, name, SMALL_RECORD_SIZE - 1); req->tch = *tch; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_SRV_RELEASE_SAVEPOINT, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_SRV_RELEASE_SAVEPOINT, req, tch->msg_buf); if (ret == CT_SUCCESS) { result = req->result; } @@ -650,17 +650,17 @@ int tse_srv_release_savepoint(tianchi_handler_t *tch, const char *name) { return result; } -int tse_general_fetch(tianchi_handler_t *tch, record_info_t *record_info) { +int ctc_general_fetch(ctc_handler_t *tch, record_info_t *record_info) { void *shm_inst = get_one_shm_inst(tch); general_fetch_request *req = (general_fetch_request*)alloc_share_mem(shm_inst, sizeof(general_fetch_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(general_fetch_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(general_fetch_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; req->record = record_info->record; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_GENERAL_FETCH, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_GENERAL_FETCH, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { if (req->result == CT_SUCCESS) { @@ -673,11 +673,11 @@ int tse_general_fetch(tianchi_handler_t *tch, record_info_t *record_info) { return result; } -int tse_free_session_cursors(tianchi_handler_t *tch, uint64_t *cursors, int32_t csize) { +int ctc_free_session_cursors(ctc_handler_t *tch, uint64_t *cursors, int32_t csize) { void *shm_inst = get_one_shm_inst(tch); free_session_cursors_request *req = (free_session_cursors_request*)alloc_share_mem(shm_inst, sizeof(free_session_cursors_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(free_session_cursors_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(free_session_cursors_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; @@ -685,7 +685,7 @@ int tse_free_session_cursors(tianchi_handler_t *tch, uint64_t *cursors, int32_t req->cursors = cursors; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_FREE_CURSORS, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_FREE_CURSORS, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { result = req->result; @@ -694,28 +694,28 @@ int tse_free_session_cursors(tianchi_handler_t *tch, uint64_t *cursors, int32_t return result; } -int tse_get_max_sessions_per_node(uint32_t *max_sessions) { +int ctc_get_max_sessions_per_node(uint32_t *max_sessions) { void *shm_inst = get_one_shm_inst(NULL); get_max_session_request *req = (get_max_session_request*)alloc_share_mem(shm_inst, sizeof(get_max_session_request)); - DBUG_EXECUTE_IF("tse_get_max_sessions_shm_oom", { req = NULL; }); + DBUG_EXECUTE_IF("ctc_get_max_sessions_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(get_max_session_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(get_max_session_request)); return ERR_ALLOC_MEMORY; } - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_GET_MAX_SESSIONS, req, nullptr); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_GET_MAX_SESSIONS, req, nullptr); if (ret == CT_SUCCESS) { *max_sessions = req->max_sessions; } return ret; } -int tse_analyze_table(tianchi_handler_t *tch, const char *db_name, const char *table_name, double sampling_ratio) { +int ctc_analyze_table(ctc_handler_t *tch, const char *db_name, const char *table_name, double sampling_ratio) { void *shm_inst = get_one_shm_inst(tch); uint64_t len = sizeof(analyze_table_request); analyze_table_request *req = (analyze_table_request*)alloc_share_mem(shm_inst, len); - DBUG_EXECUTE_IF("tse_analyze_table_shm_oom", { req = NULL; }); + DBUG_EXECUTE_IF("ctc_analyze_table_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } memset(req, 0, len); @@ -725,7 +725,7 @@ int tse_analyze_table(tianchi_handler_t *tch, const char *db_name, const char *t strncpy(req->user_name, db_name, SMALL_RECORD_SIZE - 1); int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_ANALYZE, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_ANALYZE, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { result = req->result; @@ -734,8 +734,8 @@ int tse_analyze_table(tianchi_handler_t *tch, const char *db_name, const char *t return result; } -void ctc_cbo_stats_columns_copy(tse_cbo_stats_column_t *dst_columns, tse_cbo_stats_column_t *src_columns, - tianchi_cbo_stats_t *stats, uint num_columns) { +void ctc_cbo_stats_columns_copy(ctc_cbo_stats_column_t *dst_columns, ctc_cbo_stats_column_t *src_columns, + ctc_cbo_stats_t *stats, uint num_columns) { for (uint j = 0; j < num_columns; j++) { dst_columns[j].num_null = src_columns[j].num_null; dst_columns[j].density = src_columns[j].density; @@ -766,39 +766,39 @@ void ctc_cbo_stats_columns_copy(tse_cbo_stats_column_t *dst_columns, tse_cbo_sta } } -void ctc_cbo_stats_copy_from_shm(tianchi_handler_t *tch, tse_cbo_stats_table_t *tse_cbo_stats_table, - get_cbo_stats_request *req, tianchi_cbo_stats_t *stats) { +void ctc_cbo_stats_copy_from_shm(ctc_handler_t *tch, ctc_cbo_stats_table_t *ctc_cbo_stats_table, + get_cbo_stats_request *req, ctc_cbo_stats_t *stats) { bool is_part_table = stats->part_cnt ? true : false; stats->is_updated = req->stats->is_updated; stats->records = req->stats->records; memcpy(stats->ndv_keys, req->stats->ndv_keys, stats->key_len); - uint num_columns = req->stats->msg_len / sizeof(tse_cbo_stats_column_t); + uint num_columns = req->stats->msg_len / sizeof(ctc_cbo_stats_column_t); if (!is_part_table) { *tch = req->tch; - tse_cbo_stats_table->estimate_rows = req->tse_cbo_stats_table->estimate_rows; - ctc_cbo_stats_columns_copy(tse_cbo_stats_table->columns, - req->tse_cbo_stats_table->columns, stats, num_columns); + ctc_cbo_stats_table->estimate_rows = req->ctc_cbo_stats_table->estimate_rows; + ctc_cbo_stats_columns_copy(ctc_cbo_stats_table->columns, + req->ctc_cbo_stats_table->columns, stats, num_columns); } else { for (uint i = 0; i < req->num_part_fetch; i++) { - tse_cbo_stats_table[i].estimate_rows = req->tse_cbo_stats_table[i].estimate_rows; - ctc_cbo_stats_columns_copy(tse_cbo_stats_table[i].columns, - req->tse_cbo_stats_table[i].columns, stats, num_columns); + ctc_cbo_stats_table[i].estimate_rows = req->ctc_cbo_stats_table[i].estimate_rows; + ctc_cbo_stats_columns_copy(ctc_cbo_stats_table[i].columns, + req->ctc_cbo_stats_table[i].columns, stats, num_columns); } } } -int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, tse_cbo_stats_table_t *tse_cbo_stats_table, uint32_t first_partid, uint32_t num_part_fetch) { +int ctc_get_cbo_stats(ctc_handler_t *tch, ctc_cbo_stats_t *stats, ctc_cbo_stats_table_t *ctc_cbo_stats_table, uint32_t first_partid, uint32_t num_part_fetch) { void *shm_inst_4_req = get_one_shm_inst(tch); get_cbo_stats_request *req = (get_cbo_stats_request*)alloc_share_mem(shm_inst_4_req, sizeof(get_cbo_stats_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst_4_req, sizeof(get_cbo_stats_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst_4_req, sizeof(get_cbo_stats_request)); return ERR_ALLOC_MEMORY; } void *shm_inst_4_stats = get_one_shm_inst(tch); - req->stats = (tianchi_cbo_stats_t *)alloc_share_mem(shm_inst_4_stats, sizeof(tianchi_cbo_stats_t)); + req->stats = (ctc_cbo_stats_t *)alloc_share_mem(shm_inst_4_stats, sizeof(ctc_cbo_stats_t)); if (req->stats == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst_4_stats, sizeof(tianchi_cbo_stats_t)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst_4_stats, sizeof(ctc_cbo_stats_t)); free_share_mem(shm_inst_4_req, req); return ERR_ALLOC_MEMORY; } @@ -813,73 +813,73 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, tse_cb void *shm_inst_4_table = get_one_shm_inst(tch); void *shm_inst_4_str_stats = get_one_shm_inst(tch); char *shm_mem_4_str_stats_begin; - tse_cbo_stats_column_t* part_columns = nullptr; + ctc_cbo_stats_column_t* part_columns = nullptr; req->stats->ndv_keys = (uint32_t*)alloc_share_mem(shm_inst_4_keys, stats->key_len); if (req->stats->ndv_keys == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_keys, stats->key_len); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_keys, stats->key_len); free_share_mem(shm_inst_4_stats, req->stats); free_share_mem(shm_inst_4_req, req); return ERR_ALLOC_MEMORY; } if (!is_part_table) { - req->tse_cbo_stats_table = - (tse_cbo_stats_table_t*)alloc_share_mem(shm_inst_4_table, sizeof(tse_cbo_stats_table_t)); - if (req->tse_cbo_stats_table == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst_4_table, sizeof(tse_cbo_stats_table_t)); + req->ctc_cbo_stats_table = + (ctc_cbo_stats_table_t*)alloc_share_mem(shm_inst_4_table, sizeof(ctc_cbo_stats_table_t)); + if (req->ctc_cbo_stats_table == NULL) { + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst_4_table, sizeof(ctc_cbo_stats_table_t)); free_share_mem(shm_inst_4_keys, req->stats->ndv_keys); free_share_mem(shm_inst_4_stats, req->stats); free_share_mem(shm_inst_4_req, req); return ERR_ALLOC_MEMORY; } - req->tse_cbo_stats_table->columns = (tse_cbo_stats_column_t*)alloc_share_mem(shm_inst_4_columns, req->stats->msg_len); - if (req->tse_cbo_stats_table->columns == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_columns, req->stats->msg_len); - free_share_mem(shm_inst_4_table, req->tse_cbo_stats_table); + req->ctc_cbo_stats_table->columns = (ctc_cbo_stats_column_t*)alloc_share_mem(shm_inst_4_columns, req->stats->msg_len); + if (req->ctc_cbo_stats_table->columns == NULL) { + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_columns, req->stats->msg_len); + free_share_mem(shm_inst_4_table, req->ctc_cbo_stats_table); free_share_mem(shm_inst_4_keys, req->stats->ndv_keys); free_share_mem(shm_inst_4_stats, req->stats); free_share_mem(shm_inst_4_req, req); return ERR_ALLOC_MEMORY; } - memset(req->tse_cbo_stats_table->columns, 0, req->stats->msg_len); + memset(req->ctc_cbo_stats_table->columns, 0, req->stats->msg_len); shm_mem_4_str_stats_begin = (char*)alloc_share_mem(shm_inst_4_str_stats, stats->num_str_cols * (STATS_HISTGRAM_MAX_SIZE + 2) * CBO_STRING_MAX_LEN); if (shm_mem_4_str_stats_begin == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_str_stats, + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_str_stats, stats->num_str_cols * (STATS_HISTGRAM_MAX_SIZE + 2) * CBO_STRING_MAX_LEN); - free_share_mem(shm_inst_4_columns, req->tse_cbo_stats_table->columns); - free_share_mem(shm_inst_4_table, req->tse_cbo_stats_table); + free_share_mem(shm_inst_4_columns, req->ctc_cbo_stats_table->columns); + free_share_mem(shm_inst_4_table, req->ctc_cbo_stats_table); free_share_mem(shm_inst_4_keys, req->stats->ndv_keys); free_share_mem(shm_inst_4_stats, req->stats); free_share_mem(shm_inst_4_req, req); return ERR_ALLOC_MEMORY; } char *shm_mem_4_str_stats = shm_mem_4_str_stats_begin; - for (uint i = 0; i < req->stats->msg_len / sizeof(tse_cbo_stats_column_t); i++) { + for (uint i = 0; i < req->stats->msg_len / sizeof(ctc_cbo_stats_column_t); i++) { if (stats->col_type[i] == true) { - req->tse_cbo_stats_table->columns[i].high_value.v_str = shm_mem_4_str_stats; - req->tse_cbo_stats_table->columns[i].low_value.v_str = shm_mem_4_str_stats + CBO_STRING_MAX_LEN; + req->ctc_cbo_stats_table->columns[i].high_value.v_str = shm_mem_4_str_stats; + req->ctc_cbo_stats_table->columns[i].low_value.v_str = shm_mem_4_str_stats + CBO_STRING_MAX_LEN; shm_mem_4_str_stats = shm_mem_4_str_stats + CBO_STRING_MAX_LEN * 2; for (uint j = 0; j < STATS_HISTGRAM_MAX_SIZE; j++) { - req->tse_cbo_stats_table->columns[i].column_hist[j].ep_value.v_str = shm_mem_4_str_stats; + req->ctc_cbo_stats_table->columns[i].column_hist[j].ep_value.v_str = shm_mem_4_str_stats; shm_mem_4_str_stats = shm_mem_4_str_stats + CBO_STRING_MAX_LEN; } } } } else { - req->tse_cbo_stats_table = - (tse_cbo_stats_table_t*)alloc_share_mem(shm_inst_4_table, num_part_fetch * sizeof(tse_cbo_stats_table_t)); - if (req->tse_cbo_stats_table == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst_4_table, num_part_fetch * sizeof(tse_cbo_stats_table_t)); + req->ctc_cbo_stats_table = + (ctc_cbo_stats_table_t*)alloc_share_mem(shm_inst_4_table, num_part_fetch * sizeof(ctc_cbo_stats_table_t)); + if (req->ctc_cbo_stats_table == NULL) { + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst_4_table, num_part_fetch * sizeof(ctc_cbo_stats_table_t)); free_share_mem(shm_inst_4_keys, req->stats->ndv_keys); free_share_mem(shm_inst_4_stats, req->stats); free_share_mem(shm_inst_4_req, req); return ERR_ALLOC_MEMORY; } - part_columns = (tse_cbo_stats_column_t*)alloc_share_mem(shm_inst_4_columns, stats->msg_len * num_part_fetch); + part_columns = (ctc_cbo_stats_column_t*)alloc_share_mem(shm_inst_4_columns, stats->msg_len * num_part_fetch); if (part_columns == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_columns, stats->msg_len * num_part_fetch); - free_share_mem(shm_inst_4_table, req->tse_cbo_stats_table); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_columns, stats->msg_len * num_part_fetch); + free_share_mem(shm_inst_4_table, req->ctc_cbo_stats_table); free_share_mem(shm_inst_4_keys, req->stats->ndv_keys); free_share_mem(shm_inst_4_stats, req->stats); free_share_mem(shm_inst_4_req, req); @@ -887,15 +887,15 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, tse_cb } memset(part_columns, 0, stats->msg_len * num_part_fetch); for (uint i = 0; i < num_part_fetch; i++) { - req->tse_cbo_stats_table[i].columns = part_columns + i * (stats->msg_len / sizeof(tse_cbo_stats_column_t)); + req->ctc_cbo_stats_table[i].columns = part_columns + i * (stats->msg_len / sizeof(ctc_cbo_stats_column_t)); } shm_mem_4_str_stats_begin = (char *)alloc_share_mem(shm_inst_4_str_stats, stats->num_str_cols * num_part_fetch * ((STATS_HISTGRAM_MAX_SIZE + 2) * CBO_STRING_MAX_LEN)); if (shm_mem_4_str_stats_begin == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_str_stats, + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%u)", shm_inst_4_str_stats, stats->num_str_cols * num_part_fetch * ((STATS_HISTGRAM_MAX_SIZE + 2) * CBO_STRING_MAX_LEN)); - free_share_mem(shm_inst_4_table, req->tse_cbo_stats_table); + free_share_mem(shm_inst_4_table, req->ctc_cbo_stats_table); free_share_mem(shm_inst_4_columns, part_columns); free_share_mem(shm_inst_4_keys, req->stats->ndv_keys); free_share_mem(shm_inst_4_stats, req->stats); @@ -904,13 +904,13 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, tse_cb } char *shm_mem_4_str_stats = shm_mem_4_str_stats_begin; for (uint i = 0; i < num_part_fetch; i++) { - for (uint j = 0; j < req->stats->msg_len / sizeof(tse_cbo_stats_column_t); j++) { + for (uint j = 0; j < req->stats->msg_len / sizeof(ctc_cbo_stats_column_t); j++) { if (stats->col_type[j] == true) { - req->tse_cbo_stats_table[i].columns[j].high_value.v_str = shm_mem_4_str_stats; - req->tse_cbo_stats_table[i].columns[j].low_value.v_str = shm_mem_4_str_stats + CBO_STRING_MAX_LEN; + req->ctc_cbo_stats_table[i].columns[j].high_value.v_str = shm_mem_4_str_stats; + req->ctc_cbo_stats_table[i].columns[j].low_value.v_str = shm_mem_4_str_stats + CBO_STRING_MAX_LEN; shm_mem_4_str_stats = shm_mem_4_str_stats + CBO_STRING_MAX_LEN * 2; for (uint k = 0; k < STATS_HISTGRAM_MAX_SIZE; k++) { - req->tse_cbo_stats_table[i].columns[j].column_hist[k].ep_value.v_str = shm_mem_4_str_stats; + req->ctc_cbo_stats_table[i].columns[j].column_hist[k].ep_value.v_str = shm_mem_4_str_stats; shm_mem_4_str_stats = shm_mem_4_str_stats + CBO_STRING_MAX_LEN; } } @@ -920,53 +920,53 @@ int tse_get_cbo_stats(tianchi_handler_t *tch, tianchi_cbo_stats_t *stats, tse_cb req->tch = *tch; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst_4_req, TSE_FUNC_TYPE_GET_CBO_STATS, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst_4_req, CTC_FUNC_TYPE_GET_CBO_STATS, req, tch->msg_buf); if (ret == CT_SUCCESS) { if (req->result == CT_SUCCESS) { - ctc_cbo_stats_copy_from_shm(tch, tse_cbo_stats_table, req, stats); + ctc_cbo_stats_copy_from_shm(tch, ctc_cbo_stats_table, req, stats); } result = req->result; } free_share_mem(shm_inst_4_str_stats, shm_mem_4_str_stats_begin); if (!is_part_table) { - free_share_mem(shm_inst_4_columns, req->tse_cbo_stats_table->columns); + free_share_mem(shm_inst_4_columns, req->ctc_cbo_stats_table->columns); } else { free_share_mem(shm_inst_4_columns, part_columns); } free_share_mem(shm_inst_4_keys, req->stats->ndv_keys); - free_share_mem(shm_inst_4_table, req->tse_cbo_stats_table); + free_share_mem(shm_inst_4_table, req->ctc_cbo_stats_table); free_share_mem(shm_inst_4_stats, req->stats); free_share_mem(shm_inst_4_req, req); return result; } -int tse_get_index_name(tianchi_handler_t *tch, char *index_name) { +int ctc_get_index_name(ctc_handler_t *tch, char *index_name) { void *shm_inst = get_one_shm_inst(tch); uint64_t len = sizeof(get_index_slot_request); get_index_slot_request *req = (get_index_slot_request*)alloc_share_mem(shm_inst, len); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } memset(req, 0, len); req->tch = *tch; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_GET_INDEX_NAME, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_GET_INDEX_NAME, req, tch->msg_buf); if (ret == CT_SUCCESS) { strncpy(index_name, req->index_name, strlen(req->index_name) + 1); result = req->result; } else { result = ret; - tse_log_error("tse_get_index_name failed: %d", ret); + ctc_log_error("ctc_get_index_name failed: %d", ret); } free_share_mem(shm_inst, req); return result; } -uint8_t* tse_alloc_buf(tianchi_handler_t *tch, uint32_t buf_size) { +uint8_t* ctc_alloc_buf(ctc_handler_t *tch, uint32_t buf_size) { if (buf_size == 0) { return nullptr; } @@ -974,7 +974,7 @@ uint8_t* tse_alloc_buf(tianchi_handler_t *tch, uint32_t buf_size) { return (uint8_t*)alloc_share_mem(shm_inst, buf_size); } -void tse_free_buf(tianchi_handler_t *tch, uint8_t *buf) { +void ctc_free_buf(ctc_handler_t *tch, uint8_t *buf) { if (buf == nullptr) { return; } @@ -982,19 +982,19 @@ void tse_free_buf(tianchi_handler_t *tch, uint8_t *buf) { free_share_mem(shm_inst, buf); } -int tse_general_prefetch(tianchi_handler_t *tch, uint8_t *records, uint16_t *record_lens, +int ctc_general_prefetch(ctc_handler_t *tch, uint8_t *records, uint16_t *record_lens, uint32_t *recNum, uint64_t *rowids, int32_t max_row_size) { void *shm_inst = get_one_shm_inst(tch); general_prefetch_request *req = (general_prefetch_request*)alloc_share_mem(shm_inst, sizeof(general_prefetch_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(general_prefetch_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(general_prefetch_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; req->max_row_size = max_row_size; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_GENERAL_PREFETCH, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_GENERAL_PREFETCH, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { @@ -1011,14 +1011,14 @@ int tse_general_prefetch(tianchi_handler_t *tch, uint8_t *records, uint16_t *rec result = req->result; } else { result = ret; - tse_log_error("cantiand deal the message failed: %d", ret); + ctc_log_error("cantiand deal the message failed: %d", ret); } free_share_mem(shm_inst, req); return result; } -int tse_drop_tablespace_and_user(tianchi_handler_t *tch, +int ctc_drop_tablespace_and_user(ctc_handler_t *tch, const char *db_name, const char *sql_str, const char *user_name, @@ -1031,7 +1031,7 @@ int tse_drop_tablespace_and_user(tianchi_handler_t *tch, drop_tablespace_and_user_request *req = (drop_tablespace_and_user_request*)alloc_share_mem(shm_inst, len); DBUG_EXECUTE_IF("drop_tablespace_and_user_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } memset(req, 0, len); @@ -1040,7 +1040,7 @@ int tse_drop_tablespace_and_user(tianchi_handler_t *tch, strncpy(req->user_name, user_name, SMALL_RECORD_SIZE - 1); strncpy(req->user_ip, user_ip, SMALL_RECORD_SIZE - 1); req->tch = *tch; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_DROP_TABLESPACE_AND_USER, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_DROP_TABLESPACE_AND_USER, req, tch->msg_buf); *tch = req->tch; if(req->error_message != NULL && strlen(req->error_message) > 0) { *error_code = req->error_code; @@ -1054,19 +1054,19 @@ int tse_drop_tablespace_and_user(tianchi_handler_t *tch, return result; } -int tse_drop_db_pre_check(tianchi_handler_t *tch, const char *db_name, int *error_code, char *error_message) { +int ctc_drop_db_pre_check(ctc_handler_t *tch, const char *db_name, int *error_code, char *error_message) { void *shm_inst = get_one_shm_inst(tch); uint64_t len = sizeof(drop_db_pre_check_request); drop_db_pre_check_request *req = (drop_db_pre_check_request*)alloc_share_mem(shm_inst, len); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } memset(req, 0, len); req->tch = *tch; strncpy(req->db_name, db_name, SMALL_RECORD_SIZE - 1); int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_DROP_DB_PRE_CHECK, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_DROP_DB_PRE_CHECK, req, tch->msg_buf); *tch = req->tch; *error_code = req->error_code; strncpy(error_message, req->error_message, ERROR_MESSAGE_LEN); @@ -1077,14 +1077,14 @@ int tse_drop_db_pre_check(tianchi_handler_t *tch, const char *db_name, int *erro return result; } -int tse_lock_table(tianchi_handler_t *tch, const char *db_name, tse_lock_table_info *lock_info, +int ctc_lock_table(ctc_handler_t *tch, const char *db_name, ctc_lock_table_info *lock_info, int *error_code) { void *shm_inst = get_one_shm_inst(tch); uint64_t len = sizeof(lock_table_request); lock_table_request *req = (lock_table_request*)alloc_share_mem(shm_inst, len); DBUG_EXECUTE_IF("lock_table_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } @@ -1096,7 +1096,7 @@ int tse_lock_table(tianchi_handler_t *tch, const char *db_name, tse_lock_table_i req->lock_info = *lock_info; req->mysql_inst_id = tch->inst_id; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_LOCK_TABLE, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_LOCK_TABLE, req, tch->msg_buf); *tch = req->tch; *error_code = req->error_code; if (ret == CT_SUCCESS) { @@ -1106,7 +1106,7 @@ int tse_lock_table(tianchi_handler_t *tch, const char *db_name, tse_lock_table_i return result; } -int tse_pre_create_db(tianchi_handler_t *tch, const char *sql_str, tse_db_infos_t *db_infos, +int ctc_pre_create_db(ctc_handler_t *tch, const char *sql_str, ctc_db_infos_t *db_infos, int *error_code, char *error_message) { void *shm_inst = get_one_shm_inst(tch); @@ -1114,7 +1114,7 @@ int tse_pre_create_db(tianchi_handler_t *tch, const char *sql_str, tse_db_infos_ pre_create_db_request *req = (pre_create_db_request*)alloc_share_mem(shm_inst, len); DBUG_EXECUTE_IF("create_tablespace_and_user_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } memset(req, 0, len); @@ -1125,7 +1125,7 @@ int tse_pre_create_db(tianchi_handler_t *tch, const char *sql_str, tse_db_infos_ req->ctc_db_datafile_autoextend = db_infos->datafile_autoextend; req->ctc_db_datafile_extend_size = db_infos->datafile_extend_size; req->tch = *tch; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_PRE_CREATE_DB, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_PRE_CREATE_DB, req, tch->msg_buf); *tch = req->tch; if(req->error_message != NULL && strlen(req->error_message) > 0) { *error_code = req->error_code; @@ -1139,19 +1139,19 @@ int tse_pre_create_db(tianchi_handler_t *tch, const char *sql_str, tse_db_infos_ return result; } -int tse_unlock_table(tianchi_handler_t *tch, uint32_t mysql_insert_id, tse_lock_table_info *lock_info) { +int ctc_unlock_table(ctc_handler_t *tch, uint32_t mysql_insert_id, ctc_lock_table_info *lock_info) { void *shm_inst = get_one_shm_inst(tch); - tse_unlock_tables_request *req = (tse_unlock_tables_request*)alloc_share_mem(shm_inst, sizeof(tse_unlock_tables_request)); + ctc_unlock_tables_request *req = (ctc_unlock_tables_request*)alloc_share_mem(shm_inst, sizeof(ctc_unlock_tables_request)); DBUG_EXECUTE_IF("unlock_table_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(tse_unlock_tables_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(ctc_unlock_tables_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; req->mysql_inst_id = mysql_insert_id; req->lock_info = *lock_info; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_UNLOCK_TABLE, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_UNLOCK_TABLE, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { result = req->result; @@ -1160,7 +1160,7 @@ int tse_unlock_table(tianchi_handler_t *tch, uint32_t mysql_insert_id, tse_lock_ return result; } -int tse_knl_write_lob(tianchi_handler_t *tch, char* locator, uint32_t locator_size, int column_id, +int ctc_knl_write_lob(ctc_handler_t *tch, char* locator, uint32_t locator_size, int column_id, void* data, uint32_t data_len, bool force_outline) { void *shm_inst = get_one_shm_inst(tch); @@ -1178,10 +1178,10 @@ int tse_knl_write_lob(tianchi_handler_t *tch, char* locator, uint32_t locator_si req->force_outline = force_outline; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_batch_send_message(shm_inst, TSE_FUNC_TYPE_WRITE_LOB, reqBuf, reqSize, reqSize); + int ret = ctc_mq_batch_send_message(shm_inst, CTC_FUNC_TYPE_WRITE_LOB, reqBuf, reqSize, reqSize); *tch = req->tch; if (ret != CT_SUCCESS) { - tse_log_error("tse_mq_batch_send_message failed in write lob: %d", ret); + ctc_log_error("ctc_mq_batch_send_message failed in write lob: %d", ret); } else { if (req->result == CT_SUCCESS) { memcpy(locator, req->locator, locator_size); @@ -1192,7 +1192,7 @@ int tse_knl_write_lob(tianchi_handler_t *tch, char* locator, uint32_t locator_si return result; } -int tse_knl_read_lob(tianchi_handler_t *tch, char* locator, uint32_t offset, void *buf, uint32_t size, uint32_t *read_size) +int ctc_knl_read_lob(ctc_handler_t *tch, char* locator, uint32_t offset, void *buf, uint32_t size, uint32_t *read_size) { void *shm_inst = get_one_shm_inst(tch); int reqSize = sizeof(knl_read_lob_request) + size; @@ -1207,9 +1207,9 @@ int tse_knl_read_lob(tianchi_handler_t *tch, char* locator, uint32_t offset, voi req->size = size; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_batch_send_message(shm_inst, TSE_FUNC_TYPE_READ_LOB, reqBuf, reqSize, reqSize); + int ret = ctc_mq_batch_send_message(shm_inst, CTC_FUNC_TYPE_READ_LOB, reqBuf, reqSize, reqSize); if (ret != CT_SUCCESS) { - tse_log_error("tse_mq_batch_send_message failed in read lob: %d", ret); + ctc_log_error("ctc_mq_batch_send_message failed in read lob: %d", ret); } else { if(req->result == CT_SUCCESS) { *read_size = (uint32_t)(req->read_size); @@ -1227,18 +1227,18 @@ int srv_wait_instance_startuped(void) void *shm_inst = get_one_shm_inst(NULL); void *req_mem = alloc_share_mem(shm_inst, 0); if (req_mem == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%d)", shm_inst, 0); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%d)", shm_inst, 0); return ERR_ALLOC_MEMORY; } - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_WAIT_CONNETOR_STARTUPED, req_mem, nullptr, SERVER_REGISTER_PROC_ID, 5); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_WAIT_CONNETOR_STARTUPED, req_mem, nullptr, SERVER_REGISTER_PROC_ID, 5); free_share_mem(shm_inst, req_mem); return ret; } -int tse_create_table(void *table_def, ddl_ctrl_t *ddl_ctrl) { +int ctc_create_table(void *table_def, ddl_ctrl_t *ddl_ctrl) { void *shm_inst = get_one_shm_inst(&ddl_ctrl->tch); int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_batch_send_message(shm_inst, TSE_FUNC_TYPE_CREATE_TABLE, (uint8_t*)table_def, ddl_ctrl->msg_len, + int ret = ctc_mq_batch_send_message(shm_inst, CTC_FUNC_TYPE_CREATE_TABLE, (uint8_t*)table_def, ddl_ctrl->msg_len, ddl_ctrl->msg_len); memcpy(ddl_ctrl, table_def, sizeof(ddl_ctrl_t)); if (ret == CT_SUCCESS) { @@ -1247,19 +1247,19 @@ int tse_create_table(void *table_def, ddl_ctrl_t *ddl_ctrl) { return result; } -int tse_truncate_table(void *table_def, ddl_ctrl_t *ddl_ctrl) { +int ctc_truncate_table(void *table_def, ddl_ctrl_t *ddl_ctrl) { assert(ddl_ctrl->msg_len + sizeof(ddl_ctrl_t) < REQUEST_SIZE); void *shm_inst = get_one_shm_inst(NULL); void *req_mem = alloc_share_mem(shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); DBUG_EXECUTE_IF("truncate_table_shm_oom", { req_mem = NULL; }); if (req_mem == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); return ERR_ALLOC_MEMORY; } memcpy((char *)req_mem, ddl_ctrl, sizeof(ddl_ctrl_t)); memcpy((char *)req_mem + sizeof(ddl_ctrl_t), table_def, ddl_ctrl->msg_len); int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_TRUNCATE_TABLE, req_mem, nullptr); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_TRUNCATE_TABLE, req_mem, nullptr); memcpy(ddl_ctrl, req_mem, sizeof(ddl_ctrl_t)); if (ret == CT_SUCCESS) { result = ddl_ctrl->error_code; @@ -1268,10 +1268,10 @@ int tse_truncate_table(void *table_def, ddl_ctrl_t *ddl_ctrl) { return result; } -int tse_truncate_partition(void *table_def, ddl_ctrl_t *ddl_ctrl) { +int ctc_truncate_partition(void *table_def, ddl_ctrl_t *ddl_ctrl) { void *shm_inst = get_one_shm_inst(&ddl_ctrl->tch); int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_batch_send_message(shm_inst, TSE_FUNC_TYPE_TRUNCATE_PARTITION, (uint8_t*)table_def, ddl_ctrl->msg_len, + int ret = ctc_mq_batch_send_message(shm_inst, CTC_FUNC_TYPE_TRUNCATE_PARTITION, (uint8_t*)table_def, ddl_ctrl->msg_len, ddl_ctrl->msg_len); memcpy(ddl_ctrl, table_def, sizeof(ddl_ctrl_t)); if (ret == CT_SUCCESS) { @@ -1280,10 +1280,10 @@ int tse_truncate_partition(void *table_def, ddl_ctrl_t *ddl_ctrl) { return result; } -int tse_alter_table(void *alter_def, ddl_ctrl_t *ddl_ctrl) { +int ctc_alter_table(void *alter_def, ddl_ctrl_t *ddl_ctrl) { void *shm_inst = get_one_shm_inst(&ddl_ctrl->tch); int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_batch_send_message(shm_inst, TSE_FUNC_TYPE_ALTER_TABLE, (uint8_t*)alter_def, ddl_ctrl->msg_len, + int ret = ctc_mq_batch_send_message(shm_inst, CTC_FUNC_TYPE_ALTER_TABLE, (uint8_t*)alter_def, ddl_ctrl->msg_len, ddl_ctrl->msg_len); memcpy(ddl_ctrl, alter_def, sizeof(ddl_ctrl_t)); if (ret == CT_SUCCESS) { @@ -1292,19 +1292,19 @@ int tse_alter_table(void *alter_def, ddl_ctrl_t *ddl_ctrl) { return result; } -int tse_rename_table(void *alter_def, ddl_ctrl_t *ddl_ctrl) { +int ctc_rename_table(void *alter_def, ddl_ctrl_t *ddl_ctrl) { assert(ddl_ctrl->msg_len + sizeof(ddl_ctrl_t) < REQUEST_SIZE); void *shm_inst = get_one_shm_inst(NULL); void *req_mem = alloc_share_mem(shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); DBUG_EXECUTE_IF("rename_table_shm_oom", { req_mem = NULL; }); if (req_mem == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); return ERR_ALLOC_MEMORY; } memcpy((char *)req_mem, ddl_ctrl, sizeof(ddl_ctrl_t)); memcpy((char *)req_mem + sizeof(ddl_ctrl_t), alter_def, ddl_ctrl->msg_len); int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_RENAME_TABLE, req_mem, nullptr); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_RENAME_TABLE, req_mem, nullptr); memcpy(ddl_ctrl, req_mem, sizeof(ddl_ctrl_t)); if (ret == CT_SUCCESS) { result = ddl_ctrl->error_code; @@ -1313,17 +1313,17 @@ int tse_rename_table(void *alter_def, ddl_ctrl_t *ddl_ctrl) { return result; } -int tse_update_job(update_job_info info) +int ctc_update_job(update_job_info info) { void *shm_inst = get_one_shm_inst(NULL); update_job_request *req = (update_job_request*)alloc_share_mem(shm_inst, sizeof(update_job_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(update_job_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(update_job_request)); return ERR_ALLOC_MEMORY; } int result = ERR_CONNECTION_FAILED; req->info = info; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_UPDATE_JOB, req, nullptr); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_UPDATE_JOB, req, nullptr); if (ret == CT_SUCCESS) { result = req->result; } @@ -1331,19 +1331,19 @@ int tse_update_job(update_job_info info) return result; } -int tse_execute_mysql_ddl_sql(tianchi_handler_t *tch, tse_ddl_broadcast_request *broadcast_req, bool allow_fail) { +int ctc_execute_mysql_ddl_sql(ctc_handler_t *tch, ctc_ddl_broadcast_request *broadcast_req, bool allow_fail) { void *shm_inst = get_one_shm_inst(tch); execute_mysql_ddl_sql_request *req = (execute_mysql_ddl_sql_request*)alloc_share_mem(shm_inst, sizeof(execute_mysql_ddl_sql_request)); DBUG_EXECUTE_IF("xcute_general_ddl_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(execute_mysql_ddl_sql_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(execute_mysql_ddl_sql_request)); return ERR_ALLOC_MEMORY; } - memcpy(&req->broadcast_req, broadcast_req, sizeof(tse_ddl_broadcast_request)); + memcpy(&req->broadcast_req, broadcast_req, sizeof(ctc_ddl_broadcast_request)); req->tch = *tch; req->allow_fail = allow_fail; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_EXCUTE_MYSQL_DDL_SQL, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_EXCUTE_MYSQL_DDL_SQL, req, tch->msg_buf); *tch = req->tch; broadcast_req->err_code = req->broadcast_req.err_code; if (ret == CT_SUCCESS) { @@ -1353,18 +1353,18 @@ int tse_execute_mysql_ddl_sql(tianchi_handler_t *tch, tse_ddl_broadcast_request return result; } -int tse_broadcast_mysql_dd_invalidate(tianchi_handler_t *tch, tse_invalidate_broadcast_request *broadcast_req) { +int ctc_broadcast_mysql_dd_invalidate(ctc_handler_t *tch, ctc_invalidate_broadcast_request *broadcast_req) { void *shm_inst = get_one_shm_inst(tch); invalidate_mysql_dd_request *req = (invalidate_mysql_dd_request *)alloc_share_mem(shm_inst, sizeof(invalidate_mysql_dd_request)); DBUG_EXECUTE_IF("xcute_general_ddl_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(invalidate_mysql_dd_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(invalidate_mysql_dd_request)); return ERR_ALLOC_MEMORY; } - memcpy(&req->broadcast_req, broadcast_req, sizeof(tse_invalidate_broadcast_request)); + memcpy(&req->broadcast_req, broadcast_req, sizeof(ctc_invalidate_broadcast_request)); req->tch = *tch; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_INVALIDATE_OBJECT, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_INVALIDATE_OBJECT, req, tch->msg_buf); *tch = req->tch; broadcast_req->err_code = req->broadcast_req.err_code; if (ret == CT_SUCCESS) { @@ -1374,19 +1374,19 @@ int tse_broadcast_mysql_dd_invalidate(tianchi_handler_t *tch, tse_invalidate_bro return result; } -int tse_broadcast_rewrite_sql(tianchi_handler_t *tch, tse_ddl_broadcast_request *broadcast_req, bool allow_fail) { +int ctc_broadcast_rewrite_sql(ctc_handler_t *tch, ctc_ddl_broadcast_request *broadcast_req, bool allow_fail) { void *shm_inst = get_one_shm_inst(tch); execute_mysql_ddl_sql_request *req = (execute_mysql_ddl_sql_request*)alloc_share_mem(shm_inst, sizeof(execute_mysql_ddl_sql_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(execute_mysql_ddl_sql_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(execute_mysql_ddl_sql_request)); return ERR_ALLOC_MEMORY; } - memcpy(&req->broadcast_req, broadcast_req, sizeof(tse_ddl_broadcast_request)); + memcpy(&req->broadcast_req, broadcast_req, sizeof(ctc_ddl_broadcast_request)); req->tch = *tch; req->allow_fail = allow_fail; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_BROADCAST_REWRITE_SQL, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_BROADCAST_REWRITE_SQL, req, tch->msg_buf); *tch = req->tch; broadcast_req->err_code = req->broadcast_req.err_code; strncpy(broadcast_req->err_msg, req->broadcast_req.err_msg, ERROR_MESSAGE_LEN); @@ -1397,12 +1397,12 @@ int tse_broadcast_rewrite_sql(tianchi_handler_t *tch, tse_ddl_broadcast_request return result; } -int tse_get_serial_value(tianchi_handler_t *tch, uint64_t *value, dml_flag_t flag) { +int ctc_get_serial_value(ctc_handler_t *tch, uint64_t *value, dml_flag_t flag) { void *shm_inst = get_one_shm_inst(tch); get_serial_val_request *req = (get_serial_val_request*)alloc_share_mem(shm_inst, sizeof(get_serial_val_request)); DBUG_EXECUTE_IF("get_serial_val_ddl_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(get_serial_val_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(get_serial_val_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; @@ -1410,7 +1410,7 @@ int tse_get_serial_value(tianchi_handler_t *tch, uint64_t *value, dml_flag_t fla req->flag.auto_inc_offset = flag.auto_inc_offset; req->flag.auto_increase = flag.auto_increase; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_GET_SERIAL_VALUE, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_GET_SERIAL_VALUE, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { *value = req->value; @@ -1421,19 +1421,19 @@ int tse_get_serial_value(tianchi_handler_t *tch, uint64_t *value, dml_flag_t fla return result; } -int tse_drop_table(void *drop_def, ddl_ctrl_t *ddl_ctrl) { +int ctc_drop_table(void *drop_def, ddl_ctrl_t *ddl_ctrl) { assert(ddl_ctrl->msg_len + sizeof(ddl_ctrl_t) < REQUEST_SIZE); void *shm_inst = get_one_shm_inst(NULL); void *req_mem = alloc_share_mem(shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); DBUG_EXECUTE_IF("drop_table_shm_oom", { req_mem = NULL; }); if (req_mem == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); return ERR_ALLOC_MEMORY; } memcpy((char *)req_mem, ddl_ctrl, sizeof(ddl_ctrl_t)); memcpy((char *)req_mem + sizeof(ddl_ctrl_t), drop_def, ddl_ctrl->msg_len); int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_DROP_TABLE, req_mem, nullptr); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_DROP_TABLE, req_mem, nullptr); memcpy(ddl_ctrl, req_mem, sizeof(ddl_ctrl_t)); if (ret == CT_SUCCESS) { result = ddl_ctrl->error_code; @@ -1442,19 +1442,19 @@ int tse_drop_table(void *drop_def, ddl_ctrl_t *ddl_ctrl) { return result; } -int tse_create_tablespace(void *space_def, ddl_ctrl_t *ddl_ctrl) { +int ctc_create_tablespace(void *space_def, ddl_ctrl_t *ddl_ctrl) { assert(ddl_ctrl->msg_len + sizeof(ddl_ctrl_t) < REQUEST_SIZE); void *shm_inst = get_one_shm_inst(NULL); void *req_mem = alloc_share_mem(shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); DBUG_EXECUTE_IF("create_tablespace_shm_oom", { req_mem = NULL; }); if (req_mem == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); return ERR_ALLOC_MEMORY; } memcpy((char *)req_mem, ddl_ctrl, sizeof(ddl_ctrl_t)); memcpy((char *)req_mem + sizeof(ddl_ctrl_t), space_def, ddl_ctrl->msg_len); int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_CREATE_TABLESPACE, req_mem, nullptr); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_CREATE_TABLESPACE, req_mem, nullptr); memcpy(ddl_ctrl, req_mem, sizeof(ddl_ctrl_t)); if (ret == CT_SUCCESS) { result = ddl_ctrl->error_code; @@ -1463,19 +1463,19 @@ int tse_create_tablespace(void *space_def, ddl_ctrl_t *ddl_ctrl) { return result; } -int tse_alter_tablespace(void *space_alter_def, ddl_ctrl_t *ddl_ctrl) { +int ctc_alter_tablespace(void *space_alter_def, ddl_ctrl_t *ddl_ctrl) { assert(ddl_ctrl->msg_len + sizeof(ddl_ctrl_t) < REQUEST_SIZE); void *shm_inst = get_one_shm_inst(NULL); void *req_mem = alloc_share_mem(shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); DBUG_EXECUTE_IF("alter_tablespace_shm_oom", { req_mem = NULL; }); if (req_mem == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); return ERR_ALLOC_MEMORY; } memcpy((char *)req_mem, ddl_ctrl, sizeof(ddl_ctrl_t)); memcpy((char *)req_mem + sizeof(ddl_ctrl_t), space_alter_def, ddl_ctrl->msg_len); int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_ALTER_TABLESPACE, req_mem, nullptr); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_ALTER_TABLESPACE, req_mem, nullptr); memcpy(ddl_ctrl, req_mem, sizeof(ddl_ctrl_t)); if (ret == CT_SUCCESS) { result = ddl_ctrl->error_code; @@ -1484,19 +1484,19 @@ int tse_alter_tablespace(void *space_alter_def, ddl_ctrl_t *ddl_ctrl) { return result; } -int tse_drop_tablespace(void *space_drop_def, ddl_ctrl_t *ddl_ctrl) { +int ctc_drop_tablespace(void *space_drop_def, ddl_ctrl_t *ddl_ctrl) { assert(ddl_ctrl->msg_len + sizeof(ddl_ctrl_t) < REQUEST_SIZE); void *shm_inst = get_one_shm_inst(NULL); void *req_mem = alloc_share_mem(shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); DBUG_EXECUTE_IF("drop_tablespace_shm_oom", { req_mem = NULL; }); if (req_mem == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, ddl_ctrl->msg_len + sizeof(ddl_ctrl_t)); return ERR_ALLOC_MEMORY; } memcpy((char *)req_mem, ddl_ctrl, sizeof(ddl_ctrl_t)); memcpy((char *)req_mem + sizeof(ddl_ctrl_t), space_drop_def, ddl_ctrl->msg_len); int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_DROP_TABLESPACE, req_mem, nullptr); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_DROP_TABLESPACE, req_mem, nullptr); memcpy(ddl_ctrl, req_mem, sizeof(ddl_ctrl_t)); if (ret == CT_SUCCESS) { result = ddl_ctrl->error_code; @@ -1505,12 +1505,12 @@ int tse_drop_tablespace(void *space_drop_def, ddl_ctrl_t *ddl_ctrl) { return result; } -int tse_lock_instance(bool *is_mysqld_starting, tse_lock_table_mode_t lock_type, tianchi_handler_t *tch) { +int ctc_lock_instance(bool *is_mysqld_starting, ctc_lock_table_mode_t lock_type, ctc_handler_t *tch) { void *shm_inst = get_one_shm_inst(tch); lock_instance_request *req = (lock_instance_request*)alloc_share_mem(shm_inst, sizeof(lock_instance_request)); DBUG_EXECUTE_IF("lock_instance_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(lock_instance_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(lock_instance_request)); return ERR_ALLOC_MEMORY; } @@ -1518,7 +1518,7 @@ int tse_lock_instance(bool *is_mysqld_starting, tse_lock_table_mode_t lock_type, req->lock_type = lock_type; req->is_mysqld_starting = *is_mysqld_starting; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_LOCK_INSTANCE, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_LOCK_INSTANCE, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { result = req->result; @@ -1527,19 +1527,19 @@ int tse_lock_instance(bool *is_mysqld_starting, tse_lock_table_mode_t lock_type, return result; } -int tse_unlock_instance(bool *is_mysqld_starting, tianchi_handler_t *tch) { +int ctc_unlock_instance(bool *is_mysqld_starting, ctc_handler_t *tch) { void *shm_inst = get_one_shm_inst(tch); unlock_instance_request *req = (unlock_instance_request*)alloc_share_mem(shm_inst, sizeof(unlock_instance_request)); DBUG_EXECUTE_IF("unlock_instance_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(unlock_instance_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(unlock_instance_request)); return ERR_ALLOC_MEMORY; } req->tch = *tch; req->is_mysqld_starting = *is_mysqld_starting; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_UNLOCK_INSTANCE, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_UNLOCK_INSTANCE, req, tch->msg_buf); *tch = req->tch; if (ret == CT_SUCCESS) { result = req->result; @@ -1548,17 +1548,17 @@ int tse_unlock_instance(bool *is_mysqld_starting, tianchi_handler_t *tch) { return result; } -int tse_search_metadata_status(bool *cantian_metadata_switch, bool *cantian_cluster_ready) { +int ctc_search_metadata_status(bool *cantian_metadata_switch, bool *cantian_cluster_ready) { void *shm_inst = get_one_shm_inst(NULL); search_metadata_status_request *req = (search_metadata_status_request*)alloc_share_mem(shm_inst, sizeof(search_metadata_status_request)); DBUG_EXECUTE_IF("check_init_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(search_metadata_status_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(search_metadata_status_request)); return ERR_ALLOC_MEMORY; } int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_SEARCH_METADATA_SWITCH, req, nullptr); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_SEARCH_METADATA_SWITCH, req, nullptr); if (ret == CT_SUCCESS) { result = req->result; *cantian_metadata_switch = req->metadata_switch; @@ -1569,20 +1569,20 @@ int tse_search_metadata_status(bool *cantian_metadata_switch, bool *cantian_clus return result; } -int tse_check_db_table_exists(const char *db, const char *name, bool *is_exists) { +int ctc_check_db_table_exists(const char *db, const char *name, bool *is_exists) { void *shm_inst = get_one_shm_inst(NULL); uint64_t len = sizeof(check_table_exists_request); check_table_exists_request *req = (check_table_exists_request*)alloc_share_mem(shm_inst, len); DBUG_EXECUTE_IF("check_init_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, len); return ERR_ALLOC_MEMORY; } memset(req, 0, len); int result = ERR_CONNECTION_FAILED; strncpy(req->db, db, SMALL_RECORD_SIZE - 1); strncpy(req->name, name, SMALL_RECORD_SIZE - 1); - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_CHECK_TABLE_EXIST, req, nullptr); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_CHECK_TABLE_EXIST, req, nullptr); if (ret == CT_SUCCESS) { result = req->result; *is_exists = (bool)req->is_exists; @@ -1592,19 +1592,19 @@ int tse_check_db_table_exists(const char *db, const char *name, bool *is_exists) return result; } -int ctc_record_sql_for_cantian(tianchi_handler_t *tch, tse_ddl_broadcast_request *broadcast_req, bool allow_fail) { +int ctc_record_sql_for_cantian(ctc_handler_t *tch, ctc_ddl_broadcast_request *broadcast_req, bool allow_fail) { void *shm_inst = get_one_shm_inst(tch); execute_mysql_ddl_sql_request *req = (execute_mysql_ddl_sql_request*)alloc_share_mem(shm_inst, sizeof(execute_mysql_ddl_sql_request)); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(execute_mysql_ddl_sql_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(execute_mysql_ddl_sql_request)); return ERR_ALLOC_MEMORY; } - memcpy(&req->broadcast_req, broadcast_req, sizeof(tse_ddl_broadcast_request)); + memcpy(&req->broadcast_req, broadcast_req, sizeof(ctc_ddl_broadcast_request)); req->tch = *tch; req->allow_fail = allow_fail; int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_TYPE_RECORD_SQL, req, tch->msg_buf); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_RECORD_SQL, req, tch->msg_buf); *tch = req->tch; broadcast_req->err_code = req->broadcast_req.err_code; strncpy(broadcast_req->err_msg, req->broadcast_req.err_msg, ERROR_MESSAGE_LEN); @@ -1615,17 +1615,17 @@ int ctc_record_sql_for_cantian(tianchi_handler_t *tch, tse_ddl_broadcast_request return result; } -int tse_query_cluster_role(bool *is_slave, bool *cantian_cluster_ready) { +int ctc_query_cluster_role(bool *is_slave, bool *cantian_cluster_ready) { void *shm_inst = get_one_shm_inst(NULL); query_cluster_role_request *req = (query_cluster_role_request*) alloc_share_mem(shm_inst, sizeof(query_cluster_role_request)); DBUG_EXECUTE_IF("check_init_shm_oom", { req = NULL; }); if (req == NULL) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(query_cluster_role_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(query_cluster_role_request)); return ERR_ALLOC_MEMORY; } int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, TSE_FUNC_QUERY_CLUSTER_ROLE, req, nullptr); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_QUERY_CLUSTER_ROLE, req, nullptr); if (ret == CT_SUCCESS) { result = req->result; *is_slave = req->is_slave; @@ -1642,11 +1642,11 @@ int ctc_query_shm_file_num(uint32_t *shm_file_num) query_shm_file_num_request *req = (query_shm_file_num_request*) alloc_share_mem(shm_inst, sizeof(query_shm_file_num_request)); if (req == nullptr) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(query_shm_file_num_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(query_shm_file_num_request)); return ERR_ALLOC_MEMORY; } int result = ERR_CONNECTION_FAILED; - int ret = tse_mq_deal_func(shm_inst, CTC_FUNC_QUERY_SHM_FILE_NUM, req, nullptr, SERVER_REGISTER_PROC_ID); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_QUERY_SHM_FILE_NUM, req, nullptr, SERVER_REGISTER_PROC_ID); if (ret == CT_SUCCESS) { result = req->result; *shm_file_num = req->shm_file_num; @@ -1661,12 +1661,12 @@ int ctc_query_shm_usage(uint32_t *shm_usage) void *shm_inst = get_one_shm_inst(NULL); query_shm_usage_request *req = (query_shm_usage_request *)alloc_share_mem(shm_inst, sizeof(query_shm_usage_request)); if (req == nullptr) { - tse_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(query_shm_usage_request)); + ctc_log_error("alloc shm mem error, shm_inst(%p), size(%lu)", shm_inst, sizeof(query_shm_usage_request)); return ERR_ALLOC_MEMORY; } int result = ERR_CONNECTION_FAILED; req->shm_usage = shm_usage; - int ret = tse_mq_deal_func(shm_inst, CTC_FUNC_QUERY_SHM_USAGE, req, nullptr); + int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_QUERY_SHM_USAGE, req, nullptr); if (ret == CT_SUCCESS) { result = req->result; } diff --git a/storage/tianchi/tse_stats.cc b/storage/ctc/ctc_stats.cc similarity index 65% rename from storage/tianchi/tse_stats.cc rename to storage/ctc/ctc_stats.cc index 9fb1c7a..60cc649 100644 --- a/storage/tianchi/tse_stats.cc +++ b/storage/ctc/ctc_stats.cc @@ -14,82 +14,82 @@ along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#include "tse_stats.h" -#include "tse_log.h" +#include "ctc_stats.h" +#include "ctc_log.h" #include const char *ctc_interface_strs[] = { - "TSE_FUNC_TYPE_OPEN_TABLE", - "TSE_FUNC_TYPE_CLOSE_TABLE", - "TSE_FUNC_TYPE_CLOSE_SESSION", - "TSE_FUNC_TYPE_WRITE_ROW", - "TSE_FUNC_TYPE_UPDATE_JOB", - "TSE_FUNC_TYPE_UPDATE_ROW", - "TSE_FUNC_TYPE_DELETE_ROW", - "TSE_FUNC_TYPE_RND_INIT", - "TSE_FUNC_TYPE_RND_END", - "TSE_FUNC_TYPE_RND_NEXT", - "TSE_FUNC_TYPE_RND_PREFETCH", - "TSE_FUNC_TYPE_SCAN_RECORDS", - "TSE_FUNC_TYPE_TRX_COMMIT", - "TSE_FUNC_TYPE_TRX_ROLLBACK", - "TSE_FUNC_TYPE_TRX_BEGIN", - "TSE_FUNC_TYPE_LOCK_TABLE", - "TSE_FUNC_TYPE_UNLOCK_TABLE", - "TSE_FUNC_TYPE_INDEX_END", - "TSE_FUNC_TYPE_SRV_SET_SAVEPOINT", - "TSE_FUNC_TYPE_SRV_ROLLBACK_SAVEPOINT", - "TSE_FUNC_TYPE_SRV_RELEASE_SAVEPOINT", - "TSE_FUNC_TYPE_GENERAL_FETCH", - "TSE_FUNC_TYPE_GENERAL_PREFETCH", - "TSE_FUNC_TYPE_FREE_CURSORS", - "TSE_FUNC_TYPE_GET_INDEX_NAME", - "TSE_FUNC_TYPE_INDEX_READ", - "TSE_FUNC_TYPE_RND_POS", - "TSE_FUNC_TYPE_POSITION", - "TSE_FUNC_TYPE_DELETE_ALL_ROWS", - "TSE_FUNC_TYPE_GET_CBO_STATS", - "TSE_FUNC_TYPE_WRITE_LOB", - "TSE_FUNC_TYPE_READ_LOB", - "TSE_FUNC_TYPE_CREATE_TABLE", - "TSE_FUNC_TYPE_TRUNCATE_TABLE", - "TSE_FUNC_TYPE_TRUNCATE_PARTITION", - "TSE_FUNC_TYPE_RENAME_TABLE", - "TSE_FUNC_TYPE_ALTER_TABLE", - "TSE_FUNC_TYPE_GET_SERIAL_VALUE", - "TSE_FUNC_TYPE_DROP_TABLE", - "TSE_FUNC_TYPE_EXCUTE_MYSQL_DDL_SQL", - "TSE_FUNC_TYPE_BROADCAST_REWRITE_SQL", - "TSE_FUNC_TYPE_CREATE_TABLESPACE", - "TSE_FUNC_TYPE_ALTER_TABLESPACE", - "TSE_FUNC_TYPE_DROP_TABLESPACE", - "TSE_FUNC_TYPE_BULK_INSERT", - "TSE_FUNC_TYPE_ANALYZE", - "TSE_FUNC_TYPE_GET_MAX_SESSIONS", - "TSE_FUNC_LOCK_INSTANCE", - "TSE_FUNC_UNLOCK_INSTANCE", - "TSE_FUNC_CHECK_TABLE_EXIST", - "TSE_FUNC_SEARCH_METADATA_SWITCH", + "CTC_FUNC_TYPE_OPEN_TABLE", + "CTC_FUNC_TYPE_CLOSE_TABLE", + "CTC_FUNC_TYPE_CLOSE_SESSION", + "CTC_FUNC_TYPE_WRITE_ROW", + "CTC_FUNC_TYPE_UPDATE_JOB", + "CTC_FUNC_TYPE_UPDATE_ROW", + "CTC_FUNC_TYPE_DELETE_ROW", + "CTC_FUNC_TYPE_RND_INIT", + "CTC_FUNC_TYPE_RND_END", + "CTC_FUNC_TYPE_RND_NEXT", + "CTC_FUNC_TYPE_RND_PREFETCH", + "CTC_FUNC_TYPE_SCAN_RECORDS", + "CTC_FUNC_TYPE_TRX_COMMIT", + "CTC_FUNC_TYPE_TRX_ROLLBACK", + "CTC_FUNC_TYPE_TRX_BEGIN", + "CTC_FUNC_TYPE_LOCK_TABLE", + "CTC_FUNC_TYPE_UNLOCK_TABLE", + "CTC_FUNC_TYPE_INDEX_END", + "CTC_FUNC_TYPE_SRV_SET_SAVEPOINT", + "CTC_FUNC_TYPE_SRV_ROLLBACK_SAVEPOINT", + "CTC_FUNC_TYPE_SRV_RELEASE_SAVEPOINT", + "CTC_FUNC_TYPE_GENERAL_FETCH", + "CTC_FUNC_TYPE_GENERAL_PREFETCH", + "CTC_FUNC_TYPE_FREE_CURSORS", + "CTC_FUNC_TYPE_GET_INDEX_NAME", + "CTC_FUNC_TYPE_INDEX_READ", + "CTC_FUNC_TYPE_RND_POS", + "CTC_FUNC_TYPE_POSITION", + "CTC_FUNC_TYPE_DELETE_ALL_ROWS", + "CTC_FUNC_TYPE_GET_CBO_STATS", + "CTC_FUNC_TYPE_WRITE_LOB", + "CTC_FUNC_TYPE_READ_LOB", + "CTC_FUNC_TYPE_CREATE_TABLE", + "CTC_FUNC_TYPE_TRUNCATE_TABLE", + "CTC_FUNC_TYPE_TRUNCATE_PARTITION", + "CTC_FUNC_TYPE_RENAME_TABLE", + "CTC_FUNC_TYPE_ALTER_TABLE", + "CTC_FUNC_TYPE_GET_SERIAL_VALUE", + "CTC_FUNC_TYPE_DROP_TABLE", + "CTC_FUNC_TYPE_EXCUTE_MYSQL_DDL_SQL", + "CTC_FUNC_TYPE_BROADCAST_REWRITE_SQL", + "CTC_FUNC_TYPE_CREATE_TABLESPACE", + "CTC_FUNC_TYPE_ALTER_TABLESPACE", + "CTC_FUNC_TYPE_DROP_TABLESPACE", + "CTC_FUNC_TYPE_BULK_INSERT", + "CTC_FUNC_TYPE_ANALYZE", + "CTC_FUNC_TYPE_GET_MAX_SESSIONS", + "CTC_FUNC_LOCK_INSTANCE", + "CTC_FUNC_UNLOCK_INSTANCE", + "CTC_FUNC_CHECK_TABLE_EXIST", + "CTC_FUNC_SEARCH_METADATA_SWITCH", "CTC_FUNC_QUERY_SHM_USAGE", - "TSE_FUNC_QUERY_CLUSTER_ROLE", - "TSE_FUNC_SET_CLUSTER_ROLE_BY_CANTIAN", - "TSE_FUNC_PRE_CREATE_DB", - "TSE_FUNC_TYPE_DROP_TABLESPACE_AND_USER", - "TSE_FUNC_DROP_DB_PRE_CHECK", - "TSE_FUNC_KILL_CONNECTION", - "TSE_FUNC_TYPE_INVALIDATE_OBJECT", - "TSE_FUNC_TYPE_RECORD_SQL", - "TSE_FUNC_TYPE_REGISTER_INSTANCE", - "TSE_FUNC_QUERY_SHM_FILE_NUM", - "TSE_FUNC_TYPE_WAIT_CONNETOR_STARTUPED", - "TSE_FUNC_TYPE_MYSQL_EXECUTE_UPDATE", - "TSE_FUNC_TYPE_CLOSE_MYSQL_CONNECTION", - "TSE_FUNC_TYPE_LOCK_TABLES", - "TSE_FUNC_TYPE_UNLOCK_TABLES", - "TSE_FUNC_TYPE_EXECUTE_REWRITE_OPEN_CONN", - "TSE_FUNC_TYPE_INVALIDATE_OBJECTS", - "TSE_FUNC_TYPE_INVALIDATE_ALL_OBJECTS", - "TSE_FUNC_TYPE_UPDATE_DDCACHE", + "CTC_FUNC_QUERY_CLUSTER_ROLE", + "CTC_FUNC_SET_CLUSTER_ROLE_BY_CANTIAN", + "CTC_FUNC_PRE_CREATE_DB", + "CTC_FUNC_TYPE_DROP_TABLESPACE_AND_USER", + "CTC_FUNC_DROP_DB_PRE_CHECK", + "CTC_FUNC_KILL_CONNECTION", + "CTC_FUNC_TYPE_INVALIDATE_OBJECT", + "CTC_FUNC_TYPE_RECORD_SQL", + "CTC_FUNC_TYPE_REGISTER_INSTANCE", + "CTC_FUNC_QUERY_SHM_FILE_NUM", + "CTC_FUNC_TYPE_WAIT_CONNETOR_STARTUPED", + "CTC_FUNC_TYPE_MYSQL_EXECUTE_UPDATE", + "CTC_FUNC_TYPE_CLOSE_MYSQL_CONNECTION", + "CTC_FUNC_TYPE_LOCK_TABLES", + "CTC_FUNC_TYPE_UNLOCK_TABLES", + "CTC_FUNC_TYPE_EXECUTE_REWRITE_OPEN_CONN", + "CTC_FUNC_TYPE_INVALIDATE_OBJECTS", + "CTC_FUNC_TYPE_INVALIDATE_ALL_OBJECTS", + "CTC_FUNC_TYPE_UPDATE_DDCACHE", }; @@ -141,7 +141,7 @@ bool ctc_stats::get_statistics_enabled() { void ctc_stats::set_statistics_enabled(const bool val) { if (val && !m_statistics_enabled) { - for (int i = 0; i < TSE_FUNC_TYPE_NUMBER; i++) { + for (int i = 0; i < CTC_FUNC_TYPE_NUMBER; i++) { m_calls[i] = 0; m_use_time[i] = 0; } @@ -150,20 +150,20 @@ void ctc_stats::set_statistics_enabled(const bool val) { m_statistics_enabled = val; } -void ctc_stats::gather_stats(const enum TSE_FUNC_TYPE& type, const uint64_t use_time) { +void ctc_stats::gather_stats(const enum CTC_FUNC_TYPE& type, const uint64_t use_time) { m_calls[type]++; m_use_time[type] += use_time; } void ctc_stats::print_cost_times(std::string &ctc_srv_monitor_str) { - if ((sizeof(ctc_interface_strs) / sizeof(ctc_interface_strs[0])) != TSE_FUNC_TYPE_NUMBER) { + if ((sizeof(ctc_interface_strs) / sizeof(ctc_interface_strs[0])) != CTC_FUNC_TYPE_NUMBER) { ctc_srv_monitor_str += "[CTC_STATS]: ctc_interface_strs number must be same as total ctc interfaces.\n"; return; } ctc_srv_monitor_str += "\n======================================CTC_STATS=====================================\n"; ctc_srv_monitor_str += "Interface: Call counter Used Time Average Time\n"; - for (int i = 0; i < TSE_FUNC_TYPE_NUMBER; i++) { + for (int i = 0; i < CTC_FUNC_TYPE_NUMBER; i++) { uint64_t calls = m_calls[i]; uint64_t use_time = m_use_time[i]; if (calls == 0) { diff --git a/storage/tianchi/tse_stats.h b/storage/ctc/ctc_stats.h similarity index 87% rename from storage/tianchi/tse_stats.h rename to storage/ctc/ctc_stats.h index 9b0eba7..3e2d168 100644 --- a/storage/tianchi/tse_stats.h +++ b/storage/ctc/ctc_stats.h @@ -23,8 +23,8 @@ #include "../../sql/sql_class.h" #include "../../sql/sql_profile.h" #include "my_config.h" -#include "tse_srv.h" -#include "ha_tse.h" +#include "ctc_srv.h" +#include "ha_ctc.h" class ctc_stats { private: @@ -38,15 +38,15 @@ class ctc_stats { static ctc_stats& get_instance(void) noexcept; bool get_statistics_enabled(void); void set_statistics_enabled(const bool val); - void gather_stats(const enum TSE_FUNC_TYPE& type, const uint64_t use_time); + void gather_stats(const enum CTC_FUNC_TYPE& type, const uint64_t use_time); void print_stats(THD *thd, stat_print_fn *stat_print); void print_cost_times(std::string &ctc_srv_monitor_str); void print_shm_usage(std::string &ctc_srv_monitor_str); private: bool m_statistics_enabled = false; - std::atomic_uint64_t m_calls[TSE_FUNC_TYPE_NUMBER]; - std::atomic_uint64_t m_use_time[TSE_FUNC_TYPE_NUMBER]; + std::atomic_uint64_t m_calls[CTC_FUNC_TYPE_NUMBER]; + std::atomic_uint64_t m_use_time[CTC_FUNC_TYPE_NUMBER]; }; #endif diff --git a/storage/tianchi/tse_util.cc b/storage/ctc/ctc_util.cc similarity index 71% rename from storage/tianchi/tse_util.cc rename to storage/ctc/ctc_util.cc index 8cad69f..6cde6e5 100644 --- a/storage/tianchi/tse_util.cc +++ b/storage/ctc/ctc_util.cc @@ -15,10 +15,10 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#include "tse_srv.h" -#include "tse_util.h" -#include "tse_log.h" -#include "tse_proxy_util.h" +#include "ctc_srv.h" +#include "ctc_util.h" +#include "ctc_log.h" +#include "ctc_proxy_util.h" #include "sql/sql_class.h" #include "sql/sql_lex.h" @@ -27,11 +27,11 @@ #include "my_sys.h" #include "sql/mysqld.h" #include "sql/strfunc.h" -#include "ha_tse.h" -#include "tse_error.h" +#include "ha_ctc.h" +#include "ctc_error.h" #include "decimal_convert.h" #include "sql_string.h" -#include "ha_tse_ddl.h" +#include "ha_ctc_ddl.h" using namespace std; extern bool ctc_enable_x_lock_instance; @@ -49,7 +49,7 @@ string cnvrt_name_for_sql(string name) { return res; } -void tse_print_cantian_err_msg(const ddl_ctrl_t *ddl_ctrl, ct_errno_t ret) +void ctc_print_cantian_err_msg(const ddl_ctrl_t *ddl_ctrl, ct_errno_t ret) { switch (ret) { case ERR_DUPLICATE_ENTRY: @@ -64,7 +64,7 @@ void tse_print_cantian_err_msg(const ddl_ctrl_t *ddl_ctrl, ct_errno_t ret) } } -static uint32_t tse_convert_identifier_to_sysname(char *to, const char *from, size_t to_len) { +static uint32_t ctc_convert_identifier_to_sysname(char *to, const char *from, size_t to_len) { uint32_t errors_ignored; CHARSET_INFO *cs_from = &my_charset_filename; CHARSET_INFO *cs_to = system_charset_info; @@ -73,7 +73,7 @@ static uint32_t tse_convert_identifier_to_sysname(char *to, const char *from, si strconvert(cs_from, from, cs_to, to, to_len, &errors_ignored))); } -void tse_split_normalized_name(const char *file_name, char db[], size_t db_buf_len, +void ctc_split_normalized_name(const char *file_name, char db[], size_t db_buf_len, char name[], size_t name_buf_len, bool *is_tmp_table) { size_t dir_length, prefix_length; string path(file_name); @@ -102,20 +102,20 @@ void tse_split_normalized_name(const char *file_name, char db[], size_t db_buf_l /* Get database */ path.replace(path.begin() + dir_length - 1, path.begin() + dir_length, 1, 0); // Remove end '/' prefix_length = dirname_length(buf); - (void)tse_convert_identifier_to_sysname(db, buf + prefix_length, db_buf_len - 1); + (void)ctc_convert_identifier_to_sysname(db, buf + prefix_length, db_buf_len - 1); db[db_buf_len - 1] = '\0'; } } -void tse_copy_name(char to_name[], const char from_name[], size_t to_buf_len) { +void ctc_copy_name(char to_name[], const char from_name[], size_t to_buf_len) { if (to_name != from_name) { (void)strncpy(to_name, from_name, to_buf_len - 1); to_name[to_buf_len - 1] = '\0'; } } -bool tse_check_ddl_sql_length(const string &query_str) { +bool ctc_check_ddl_sql_length(const string &query_str) { if (query_str.length() > MAX_DDL_SQL_LEN_CONTEXT) { string err_msg = "`" + query_str.substr(0, 100) + "...` Is Large Than " + to_string(MAX_DDL_SQL_LEN_CONTEXT); @@ -125,14 +125,14 @@ bool tse_check_ddl_sql_length(const string &query_str) { return false; } -string sql_without_plaintext_password(tse_ddl_broadcast_request* broadcast_req) { - if (broadcast_req->options & TSE_CURRENT_SQL_CONTAIN_PLAINTEXT_PASSWORD) { +string sql_without_plaintext_password(ctc_ddl_broadcast_request* broadcast_req) { + if (broadcast_req->options & CTC_CURRENT_SQL_CONTAIN_PLAINTEXT_PASSWORD) { return "(contains plaintext password), sql_command = " + to_string(broadcast_req->sql_command); } return (string)broadcast_req->sql_str; } -int16_t tse_get_column_by_field(Field **field, const char *col_name) { +int16_t ctc_get_column_by_field(Field **field, const char *col_name) { int16_t col_id; for (col_id = 0; *field != nullptr; field++, col_id++) { if (my_strcasecmp(system_charset_info, (*field)->field_name, col_name) == 0) { @@ -142,7 +142,7 @@ int16_t tse_get_column_by_field(Field **field, const char *col_name) { return INVALID_MAX_COLUMN; } -int tse_set_cond_field_size(const field_cnvrt_aux_t *mysql_info, tse_conds *cond) { +int ctc_set_cond_field_size(const field_cnvrt_aux_t *mysql_info, ctc_conds *cond) { switch (mysql_info->cantian_map_type) { case CANTIAN_COL_BITS_4: cond->field_info.field_size = 4; @@ -157,37 +157,37 @@ int tse_set_cond_field_size(const field_cnvrt_aux_t *mysql_info, tse_conds *cond break; } default: - tse_log_error("tse_set_cond_field_size: unknow col bits: %d", mysql_info->cantian_map_type); + ctc_log_error("ctc_set_cond_field_size: unknow col bits: %d", mysql_info->cantian_map_type); return CT_ERROR; } return CT_SUCCESS; } -int tse_fill_cond_field_data_num(tianchi_handler_t m_tch, Item *items, Field *mysql_field, - const field_cnvrt_aux_t *mysql_info, tse_conds *cond) { +int ctc_fill_cond_field_data_num(ctc_handler_t m_tch, Item *items, Field *mysql_field, + const field_cnvrt_aux_t *mysql_info, ctc_conds *cond) { int ret = CT_SUCCESS; void *data = nullptr; bool is_alloc_data = CT_FALSE; Item_func_comparison *item_func_comparison = dynamic_cast(items); - TSE_RET_ERR_IF_NULL(item_func_comparison); + CTC_RET_ERR_IF_NULL(item_func_comparison); switch (mysql_info->ddl_field_type) { - case TSE_DDL_TYPE_LONG: - case TSE_DDL_TYPE_LONGLONG: { + case CTC_DDL_TYPE_LONG: + case CTC_DDL_TYPE_LONGLONG: { Item_func *item_func = dynamic_cast(items); - TSE_RET_ERR_IF_NULL(item_func); + CTC_RET_ERR_IF_NULL(item_func); longlong val; if ((item_func->arguments()[1])->type() == Item::CACHE_ITEM) { Item_cache_int *item_cache_int = dynamic_cast(item_func_comparison->arguments()[1]); - TSE_RET_ERR_IF_NULL(item_cache_int); + CTC_RET_ERR_IF_NULL(item_cache_int); val = item_cache_int->val_int(); } else { Item_int *item_int = dynamic_cast(item_func_comparison->arguments()[1]); - TSE_RET_ERR_IF_NULL(item_int); + CTC_RET_ERR_IF_NULL(item_int); val = item_int->val_int(); } data = (uchar *)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(longlong), MYF(MY_WME)); if (data == nullptr) { - tse_log_error("[tse_fill_cond_field_data_num]alloc mem failed, size(%ld)", sizeof(longlong)); + ctc_log_error("[ctc_fill_cond_field_data_num]alloc mem failed, size(%ld)", sizeof(longlong)); my_error(ER_OUT_OF_RESOURCES, MYF(0), "COND FIELD DATA"); return CT_ERROR; } @@ -195,26 +195,26 @@ int tse_fill_cond_field_data_num(tianchi_handler_t m_tch, Item *items, Field *my memcpy(data, &val, sizeof(longlong)); break; } - case TSE_DDL_TYPE_DOUBLE: { + case CTC_DDL_TYPE_DOUBLE: { Item_float *item_float = dynamic_cast(item_func_comparison->arguments()[1]); - TSE_RET_ERR_IF_NULL(item_float); + CTC_RET_ERR_IF_NULL(item_float); data = &item_float->value; break; } - case TSE_DDL_TYPE_NEWDECIMAL: { + case CTC_DDL_TYPE_NEWDECIMAL: { const int scale = mysql_field->decimals(); Field_new_decimal *field_new_decimal = dynamic_cast(mysql_field); - TSE_RET_ERR_IF_NULL(field_new_decimal); + CTC_RET_ERR_IF_NULL(field_new_decimal); const int prec = field_new_decimal->precision; int binary_size = my_decimal_get_binary_size(prec, scale); uchar *buff = new uchar[binary_size]; Item_decimal *item_decimal = dynamic_cast(item_func_comparison->arguments()[1]); - TSE_RET_ERR_IF_NULL(item_decimal); + CTC_RET_ERR_IF_NULL(item_decimal); my_decimal *d = item_decimal->val_decimal(nullptr); my_decimal2binary(E_DEC_FATAL_ERROR, d, buff, prec, scale); data = (uchar *)my_malloc(PSI_NOT_INSTRUMENTED, binary_size, MYF(MY_WME)); if (data == nullptr) { - tse_log_error("[tse_fill_cond_field_data_num]alloc mem failed, size(%d)", binary_size); + ctc_log_error("[ctc_fill_cond_field_data_num]alloc mem failed, size(%d)", binary_size); my_error(ER_OUT_OF_RESOURCES, MYF(0), "COND FIELD DATA"); return CT_ERROR; } @@ -224,16 +224,16 @@ int tse_fill_cond_field_data_num(tianchi_handler_t m_tch, Item *items, Field *my break; } default: - tse_log_error("[tse_copy_cond_field_data]unsupport sql_data_type %d", mysql_info->sql_data_type); + ctc_log_error("[ctc_copy_cond_field_data]unsupport sql_data_type %d", mysql_info->sql_data_type); assert(0); return CT_ERROR; } uchar cantian_ptr[DECIMAL_MAX_STR_LENGTH + 1]; ret = convert_numeric_to_cantian(mysql_info, (const uchar *)data, cantian_ptr, mysql_field, (uint32_t *)(&cond->field_info.field_size)); - cond->field_info.field_value = tse_alloc_buf(&m_tch, cond->field_info.field_size); + cond->field_info.field_value = ctc_alloc_buf(&m_tch, cond->field_info.field_size); if (cond->field_info.field_size > 0 && cond->field_info.field_value == nullptr) { - tse_log_error("tse_fill_cond_field: alloc field_data error, size(%u).", cond->field_info.field_size); + ctc_log_error("ctc_fill_cond_field: alloc field_data error, size(%u).", cond->field_info.field_size); return CT_ERROR; } @@ -245,14 +245,14 @@ int tse_fill_cond_field_data_num(tianchi_handler_t m_tch, Item *items, Field *my return ret; } -void refill_cond_type_date(MYSQL_TIME ltime, tse_conds *cond) { +void refill_cond_type_date(MYSQL_TIME ltime, ctc_conds *cond) { if (!ltime.hour || !ltime.minute || !ltime.second || !ltime.second_part) { switch (cond->func_type) { - case TSE_LT_FUNC: - cond->func_type = TSE_LE_FUNC; + case CTC_LT_FUNC: + cond->func_type = CTC_LE_FUNC; break; - case TSE_NE_FUNC: - cond->func_type = TSE_ISNOTNULL_FUNC; + case CTC_NE_FUNC: + cond->func_type = CTC_ISNOTNULL_FUNC; break; default: break; @@ -260,13 +260,13 @@ void refill_cond_type_date(MYSQL_TIME ltime, tse_conds *cond) { } } -int tse_fill_cond_field_data_date(tianchi_handler_t m_tch, const field_cnvrt_aux_t *mysql_info, - MYSQL_TIME ltime, date_detail_t *date_detail, tse_conds *cond) { +int ctc_fill_cond_field_data_date(ctc_handler_t m_tch, const field_cnvrt_aux_t *mysql_info, + MYSQL_TIME ltime, date_detail_t *date_detail, ctc_conds *cond) { int ret = CT_SUCCESS; - cond->field_info.field_value = tse_alloc_buf(&m_tch, cond->field_info.field_size); + cond->field_info.field_value = ctc_alloc_buf(&m_tch, cond->field_info.field_size); if (cond->field_info.field_size > 0 && cond->field_info.field_value == nullptr) { - tse_log_error("tse_fill_cond_field: alloc field_data error, size(%u).", cond->field_info.field_size); + ctc_log_error("ctc_fill_cond_field: alloc field_data error, size(%u).", cond->field_info.field_size); return CT_ERROR; } @@ -300,7 +300,7 @@ int tse_fill_cond_field_data_date(tianchi_handler_t m_tch, const field_cnvrt_aux datetime_with_no_zero_in_date_to_timeval(<ime, *thd->time_zone(), &tm, &warnings); #elif defined(FEATURE_X_FOR_MYSQL_26) struct timeval tm = {0, 0}; - tse_datetime_with_no_zero_in_date_to_timeval(<ime, *thd->time_zone(), &tm, &warnings); + ctc_datetime_with_no_zero_in_date_to_timeval(<ime, *thd->time_zone(), &tm, &warnings); #endif assert((warnings == EOK) || (warnings == MYSQL_TIME_WARN_TRUNCATED)); my_tz_UTC->gmt_sec_to_TIME(<ime, tm); @@ -333,55 +333,55 @@ void update_value_by_charset(char *data, uint16 *size, uint16 bytes) { *size = cur; } -int tse_get_column_cs(const CHARSET_INFO *cs) { - auto it = mysql_collate_num_to_tse_type.find(cs->number); - if (it != mysql_collate_num_to_tse_type.end()) { +int ctc_get_column_cs(const CHARSET_INFO *cs) { + auto it = mysql_collate_num_to_ctc_type.find(cs->number); + if (it != mysql_collate_num_to_ctc_type.end()) { return (int32_t)it->second; } return cs->number; } -int tse_fill_cond_field_data_string(tianchi_handler_t m_tch, Item_func *item_func, - tse_conds *cond, bool no_backslash) { +int ctc_fill_cond_field_data_string(ctc_handler_t m_tch, Item_func *item_func, + ctc_conds *cond, bool no_backslash) { if ((item_func->arguments()[1])->type() == Item::NULL_ITEM) { cond->field_info.null_value = true; return CT_SUCCESS; } Item_field *item_field = dynamic_cast((item_func)->arguments()[0]); - TSE_RET_ERR_IF_NULL(item_field); + CTC_RET_ERR_IF_NULL(item_field); uint cslen = item_field->collation.collation->mbminlen; - cond->field_info.collate_id = tse_get_column_cs(item_field->collation.collation); + cond->field_info.collate_id = ctc_get_column_cs(item_field->collation.collation); if (no_backslash) { cond->field_info.no_backslash = true; } Item_string *item_string = dynamic_cast(item_func->arguments()[1]); - TSE_RET_ERR_IF_NULL(item_string); + CTC_RET_ERR_IF_NULL(item_string); String *item_str = item_string->val_str(nullptr); cond->field_info.field_size = item_str->length(); void *data = item_str->ptr(); - cond->field_info.field_value = tse_alloc_buf(&m_tch, cond->field_info.field_size); + cond->field_info.field_value = ctc_alloc_buf(&m_tch, cond->field_info.field_size); if (cond->field_info.field_size > 0 && cond->field_info.field_value == nullptr) { - tse_log_error("tse_fill_cond_field: alloc field_data error, size(%u).", cond->field_info.field_size); + ctc_log_error("ctc_fill_cond_field: alloc field_data error, size(%u).", cond->field_info.field_size); return CT_ERROR; } memset(cond->field_info.field_value, 0, cond->field_info.field_size); memcpy(cond->field_info.field_value, data, cond->field_info.field_size); - if(cond->func_type == TSE_LIKE_FUNC) { + if(cond->func_type == CTC_LIKE_FUNC) { update_value_by_charset((char *)cond->field_info.field_value, &cond->field_info.field_size, cslen - 1); } return CT_SUCCESS; } -int tse_fill_cond_field_data(tianchi_handler_t m_tch, Item *items, Field *mysql_field, - const field_cnvrt_aux_t *mysql_info, tse_conds *cond) { +int ctc_fill_cond_field_data(ctc_handler_t m_tch, Item *items, Field *mysql_field, + const field_cnvrt_aux_t *mysql_info, ctc_conds *cond) { int ret = CT_SUCCESS; Item_func *item_func = dynamic_cast(items); - TSE_RET_ERR_IF_NULL(item_func); + CTC_RET_ERR_IF_NULL(item_func); Item_func_comparison *item_func_comparison = dynamic_cast(items); - TSE_RET_ERR_IF_NULL(item_func_comparison); + CTC_RET_ERR_IF_NULL(item_func_comparison); if ((item_func->arguments()[1])->type() == Item::CACHE_ITEM) { Item_cache *item_cache = dynamic_cast(item_func_comparison->arguments()[1]); - TSE_RET_ERR_IF_NULL(item_cache); + CTC_RET_ERR_IF_NULL(item_cache); cond->field_info.null_value = !item_cache->has_value(); } else { cond->field_info.null_value = item_func_comparison->arguments()[1]->null_value; @@ -392,17 +392,17 @@ int tse_fill_cond_field_data(tianchi_handler_t m_tch, Item *items, Field *mysql_ switch (mysql_info->sql_data_type) { case NUMERIC_DATA: - ret = tse_fill_cond_field_data_num(m_tch, items, mysql_field, mysql_info, cond); + ret = ctc_fill_cond_field_data_num(m_tch, items, mysql_field, mysql_info, cond); break; case DATETIME_DATA:{ MYSQL_TIME ltime; date_detail_t date_detail; memset(&date_detail, 0, sizeof(date_detail_t)); Item_func_comparison *item_func_comparison = dynamic_cast(items); - TSE_RET_ERR_IF_NULL(item_func_comparison); + CTC_RET_ERR_IF_NULL(item_func_comparison); if (mysql_info->mysql_field_type == MYSQL_TYPE_YEAR) { Item_int *item_int = dynamic_cast(item_func_comparison->arguments()[1]); - TSE_RET_ERR_IF_NULL(item_int); + CTC_RET_ERR_IF_NULL(item_int); ltime.year = item_int->value; ltime.month = 1; ltime.day = 1; @@ -413,34 +413,34 @@ int tse_fill_cond_field_data(tianchi_handler_t m_tch, Item *items, Field *mysql_ ltime.neg = false; } else { Item_func *item_date_func = dynamic_cast(item_func->arguments()[1]); - TSE_RET_ERR_IF_NULL(item_date_func); + CTC_RET_ERR_IF_NULL(item_date_func); Item_date_literal *item_date_literal = (Item_date_literal *)(item_date_func); - TSE_RET_ERR_IF_NULL(item_date_literal); + CTC_RET_ERR_IF_NULL(item_date_literal); if (item_date_literal->get_date(<ime, TIME_FUZZY_DATE)) { return CT_ERROR; } } - ret = tse_fill_cond_field_data_date(m_tch, mysql_info, ltime, &date_detail, cond); + ret = ctc_fill_cond_field_data_date(m_tch, mysql_info, ltime, &date_detail, cond); break; } case STRING_DATA:{ - ret = tse_fill_cond_field_data_string(m_tch, item_func, cond, false); + ret = ctc_fill_cond_field_data_string(m_tch, item_func, cond, false); break; } case LOB_DATA: case UNKNOW_DATA: default: - tse_log_error("[mysql2cantian]unsupport sql_data_type %d", mysql_info->sql_data_type); + ctc_log_error("[mysql2cantian]unsupport sql_data_type %d", mysql_info->sql_data_type); return CT_ERROR; } return ret; } -int tse_fill_cond_field(tianchi_handler_t m_tch, Item *items, Field **field, tse_conds *cond, bool no_backslash) { +int ctc_fill_cond_field(ctc_handler_t m_tch, Item *items, Field **field, ctc_conds *cond, bool no_backslash) { Item_func *item_func = dynamic_cast(items); - TSE_RET_ERR_IF_NULL(item_func); + CTC_RET_ERR_IF_NULL(item_func); const char *field_name = item_func->arguments()[0]->item_name.ptr(); - cond->field_info.field_no = tse_get_column_by_field(field, field_name); + cond->field_info.field_no = ctc_get_column_by_field(field, field_name); if (cond->field_info.field_no == INVALID_MAX_COLUMN) { return CT_ERROR; } @@ -458,34 +458,34 @@ int tse_fill_cond_field(tianchi_handler_t m_tch, Item *items, Field **field, tse } } cond->field_info.field_no -= gcol_cnt; - if (cond->func_type == TSE_ISNULL_FUNC || cond->func_type == TSE_ISNOTNULL_FUNC) { + if (cond->func_type == CTC_ISNULL_FUNC || cond->func_type == CTC_ISNOTNULL_FUNC) { return CT_SUCCESS; - } else if(cond->func_type == TSE_LIKE_FUNC) { - return tse_fill_cond_field_data_string(m_tch, item_func, cond, no_backslash); + } else if(cond->func_type == CTC_LIKE_FUNC) { + return ctc_fill_cond_field_data_string(m_tch, item_func, cond, no_backslash); } - if (tse_set_cond_field_size(mysql_info, cond) != CT_SUCCESS) { + if (ctc_set_cond_field_size(mysql_info, cond) != CT_SUCCESS) { return CT_ERROR; } - return tse_fill_cond_field_data(m_tch, items, mysql_field, mysql_info, cond); + return ctc_fill_cond_field_data(m_tch, items, mysql_field, mysql_info, cond); } -int tse_push_cond_list(tianchi_handler_t m_tch, Item *items, Field **field, - tse_cond_list *list, bool no_backslash) { +int ctc_push_cond_list(ctc_handler_t m_tch, Item *items, Field **field, + ctc_cond_list *list, bool no_backslash) { Item_cond *item_cond = dynamic_cast(items); - TSE_RET_ERR_IF_NULL(item_cond); + CTC_RET_ERR_IF_NULL(item_cond); List *argument_list = item_cond->argument_list(); uint16_t size = argument_list->size(); list_node *node = argument_list->first_node(); for (uint16_t i = 0; i < size; i++) { - tse_conds *cond = (tse_conds *)tse_alloc_buf(&m_tch, sizeof(tse_conds)); + ctc_conds *cond = (ctc_conds *)ctc_alloc_buf(&m_tch, sizeof(ctc_conds)); if (cond == nullptr) { - tse_log_error("tse_push_cond_list: alloc tse_conds error, size(%lu).", sizeof(tse_conds)); + ctc_log_error("ctc_push_cond_list: alloc ctc_conds error, size(%lu).", sizeof(ctc_conds)); return CT_ERROR; } - memset(cond, 0, sizeof(tse_conds)); + memset(cond, 0, sizeof(ctc_conds)); if (dfs_fill_conds(m_tch, (Item *)(node->info), field, cond, no_backslash) != CT_SUCCESS) { return CT_ERROR; } @@ -502,20 +502,20 @@ int tse_push_cond_list(tianchi_handler_t m_tch, Item *items, Field **field, return CT_SUCCESS; } -int tse_push_cond_args(tianchi_handler_t m_tch, Item *items, Field **field, - tse_cond_list *list, bool no_backslash) { +int ctc_push_cond_args(ctc_handler_t m_tch, Item *items, Field **field, + ctc_cond_list *list, bool no_backslash) { Item_func *item_func = dynamic_cast(items); - TSE_RET_ERR_IF_NULL(item_func); + CTC_RET_ERR_IF_NULL(item_func); Item **args = item_func->arguments(); uint16_t size = item_func->argument_count(); for (uint16_t i = 0; i < size; i++) { - tse_conds *cond = (tse_conds *)tse_alloc_buf(&m_tch, sizeof(tse_conds)); + ctc_conds *cond = (ctc_conds *)ctc_alloc_buf(&m_tch, sizeof(ctc_conds)); if (cond == nullptr) { - tse_log_error("tse_push_cond_args: alloc tse_conds error, size(%lu).", sizeof(tse_conds)); + ctc_log_error("ctc_push_cond_args: alloc ctc_conds error, size(%lu).", sizeof(ctc_conds)); return CT_ERROR; } - memset(cond, 0, sizeof(tse_conds)); + memset(cond, 0, sizeof(ctc_conds)); dfs_fill_conds(m_tch, args[i], field, cond, no_backslash); if (list->elements == 0) { list->first = cond; @@ -529,85 +529,85 @@ int tse_push_cond_args(tianchi_handler_t m_tch, Item *items, Field **field, return CT_SUCCESS; } -tse_func_type_t item_func_to_tse_func(Item_func::Functype fc) { +ctc_func_type_t item_func_to_ctc_func(Item_func::Functype fc) { switch (fc) { case (Item_func::Functype::EQUAL_FUNC): - return TSE_EQUAL_FUNC; + return CTC_EQUAL_FUNC; case (Item_func::Functype::EQ_FUNC): - return TSE_EQ_FUNC; + return CTC_EQ_FUNC; case (Item_func::Functype::NE_FUNC): - return TSE_NE_FUNC; + return CTC_NE_FUNC; case (Item_func::Functype::LT_FUNC): - return TSE_LT_FUNC; + return CTC_LT_FUNC; case (Item_func::Functype::LE_FUNC): - return TSE_LE_FUNC; + return CTC_LE_FUNC; case (Item_func::Functype::GT_FUNC): - return TSE_GT_FUNC; + return CTC_GT_FUNC; case (Item_func::Functype::GE_FUNC): - return TSE_GE_FUNC; + return CTC_GE_FUNC; case (Item_func::Functype::ISNULL_FUNC): - return TSE_ISNULL_FUNC; + return CTC_ISNULL_FUNC; case (Item_func::Functype::ISNOTNULL_FUNC): - return TSE_ISNOTNULL_FUNC; + return CTC_ISNOTNULL_FUNC; case (Item_func::Functype::LIKE_FUNC): - return TSE_LIKE_FUNC; + return CTC_LIKE_FUNC; case (Item_func::Functype::NOT_FUNC): - return TSE_NOT_FUNC; + return CTC_NOT_FUNC; case (Item_func::Functype::COND_AND_FUNC): - return TSE_COND_AND_FUNC; + return CTC_COND_AND_FUNC; case (Item_func::Functype::COND_OR_FUNC): - return TSE_COND_OR_FUNC; + return CTC_COND_OR_FUNC; case (Item_func::Functype::XOR_FUNC): - return TSE_XOR_FUNC; + return CTC_XOR_FUNC; default: - return TSE_UNKNOWN_FUNC; + return CTC_UNKNOWN_FUNC; } } -int dfs_fill_conds(tianchi_handler_t m_tch, Item *items, Field **field, tse_conds *conds, bool no_backslash) { +int dfs_fill_conds(ctc_handler_t m_tch, Item *items, Field **field, ctc_conds *conds, bool no_backslash) { Item_func *item_func = dynamic_cast(items); - TSE_RET_ERR_IF_NULL(item_func); + CTC_RET_ERR_IF_NULL(item_func); Item_func::Functype fc = item_func->functype(); - conds->func_type = item_func_to_tse_func(fc); + conds->func_type = item_func_to_ctc_func(fc); int ret = CT_SUCCESS; - tse_cond_list *list; + ctc_cond_list *list; switch (conds->func_type) { - case TSE_COND_AND_FUNC: - case TSE_COND_OR_FUNC: - list = (tse_cond_list *)tse_alloc_buf(&m_tch, sizeof(tse_cond_list)); + case CTC_COND_AND_FUNC: + case CTC_COND_OR_FUNC: + list = (ctc_cond_list *)ctc_alloc_buf(&m_tch, sizeof(ctc_cond_list)); if (list == nullptr) { - tse_log_error("tse_fill_conds: alloc tse_cond_list error, size(%lu).", sizeof(tse_cond_list)); + ctc_log_error("ctc_fill_conds: alloc ctc_cond_list error, size(%lu).", sizeof(ctc_cond_list)); return CT_ERROR; } - memset(list, 0, sizeof(tse_cond_list)); - ret = tse_push_cond_list(m_tch, items, field, list, no_backslash); + memset(list, 0, sizeof(ctc_cond_list)); + ret = ctc_push_cond_list(m_tch, items, field, list, no_backslash); conds->cond_list = list; break; - case TSE_NOT_FUNC: - case TSE_XOR_FUNC: - list = (tse_cond_list *)tse_alloc_buf(&m_tch, sizeof(tse_cond_list)); + case CTC_NOT_FUNC: + case CTC_XOR_FUNC: + list = (ctc_cond_list *)ctc_alloc_buf(&m_tch, sizeof(ctc_cond_list)); if (list == nullptr) { - tse_log_error("tse_fill_conds: alloc tse_cond_list error, size(%lu).", sizeof(tse_cond_list)); + ctc_log_error("ctc_fill_conds: alloc ctc_cond_list error, size(%lu).", sizeof(ctc_cond_list)); return CT_ERROR; } - memset(list, 0, sizeof(tse_cond_list)); - ret = tse_push_cond_args(m_tch, items, field, list, no_backslash); + memset(list, 0, sizeof(ctc_cond_list)); + ret = ctc_push_cond_args(m_tch, items, field, list, no_backslash); conds->cond_list = list; break; - case TSE_EQ_FUNC: - case TSE_EQUAL_FUNC: - case TSE_NE_FUNC: - case TSE_LT_FUNC: - case TSE_LE_FUNC: - case TSE_GE_FUNC: - case TSE_GT_FUNC: - case TSE_ISNULL_FUNC: - case TSE_ISNOTNULL_FUNC: - case TSE_LIKE_FUNC: - ret = tse_fill_cond_field(m_tch, item_func, field, conds, no_backslash); + case CTC_EQ_FUNC: + case CTC_EQUAL_FUNC: + case CTC_NE_FUNC: + case CTC_LT_FUNC: + case CTC_LE_FUNC: + case CTC_GE_FUNC: + case CTC_GT_FUNC: + case CTC_ISNULL_FUNC: + case CTC_ISNOTNULL_FUNC: + case CTC_LIKE_FUNC: + ret = ctc_fill_cond_field(m_tch, item_func, field, conds, no_backslash); break; - case TSE_UNKNOWN_FUNC: + case CTC_UNKNOWN_FUNC: default: return CT_ERROR; } @@ -632,7 +632,7 @@ void cm_assert(bool condition) 3.普通字符 追加即可 */ -string tse_deserilize_get_text(string &name) { +string ctc_deserilize_get_text(string &name) { THD *thd = current_thd; string res(""); int len = name.size(); @@ -686,7 +686,7 @@ string tse_deserilize_get_text(string &name) { return res; } -string tse_escape_single_quotation_str(string &src) { +string ctc_escape_single_quotation_str(string &src) { string res = ""; for (size_t i = 0; i < src.length(); i++) { switch (src[i]) { @@ -699,9 +699,9 @@ string tse_escape_single_quotation_str(string &src) { return res; } -string tse_deserilize_username_with_single_quotation(string &src) { - string deserilize = tse_deserilize_get_text(src); - return tse_escape_single_quotation_str(deserilize); +string ctc_deserilize_username_with_single_quotation(string &src) { + string deserilize = ctc_deserilize_get_text(src); + return ctc_escape_single_quotation_str(deserilize); } /** @@ -710,68 +710,68 @@ string tse_deserilize_username_with_single_quotation(string &src) { - true: there is ddl in progress - false: no ddl is in progress */ -static bool tse_is_ddl_processing() { +static bool ctc_is_ddl_processing() { uint32_t name_locks = get_g_name_locks(); if (name_locks > 0) { - tse_log_system("[TSE_LOCK_INSTANCE]: contains %u global name locks, there is DDL in progress.", name_locks); + ctc_log_system("[CTC_LOCK_INSTANCE]: contains %u global name locks, there is DDL in progress.", name_locks); return true; } return false; } -int tse_check_lock_instance(MYSQL_THD thd, bool &need_forward) { +int ctc_check_lock_instance(MYSQL_THD thd, bool &need_forward) { if (thd->mdl_context.has_locks(MDL_key::BACKUP_LOCK)) { need_forward = false; return 0; } - if (tse_is_ddl_processing()) { + if (ctc_is_ddl_processing()) { my_printf_error(ER_DISALLOWED_OPERATION, "Please try lock instance for backup later, DDL is in processing.", MYF(0)); return -1; } if (acquire_exclusive_backup_lock(thd, 0, false)) { my_printf_error(ER_DISALLOWED_OPERATION, "Please try lock instance for backup later, DDL is in processing.", MYF(0)); - tse_log_error("[TSE_LOCK_INSTANCE]: Not allowed to lock instance, DDL is in processing"); + ctc_log_error("[CTC_LOCK_INSTANCE]: Not allowed to lock instance, DDL is in processing"); return -1; } - tse_lock_table_mode_t lock_mode; + ctc_lock_table_mode_t lock_mode; bool is_mysqld_starting = is_starting(); if (ctc_enable_x_lock_instance || is_mysqld_starting) { - lock_mode = TSE_LOCK_MODE_EXCLUSIVE; + lock_mode = CTC_LOCK_MODE_EXCLUSIVE; } else { - lock_mode = TSE_LOCK_MODE_SHARE; + lock_mode = CTC_LOCK_MODE_SHARE; } - tianchi_handler_t tch; - handlerton *tse_hton = get_tse_hton(); - if (get_tch_in_handler_data(tse_hton, thd, tch)) { - tse_log_error("[TSE_LOCK_INSTANCE]: failed to get tch"); + ctc_handler_t tch; + handlerton *ctc_hton = get_ctc_hton(); + if (get_tch_in_handler_data(ctc_hton, thd, tch)) { + ctc_log_error("[CTC_LOCK_INSTANCE]: failed to get tch"); release_backup_lock(thd); return -1; } - int ret = tse_lock_instance(&is_mysqld_starting, lock_mode, &tch); - update_sess_ctx_by_tch(tch, tse_hton, thd); + int ret = ctc_lock_instance(&is_mysqld_starting, lock_mode, &tch); + update_sess_ctx_by_tch(tch, ctc_hton, thd); assert(ret == 0); - tse_log_system("[TSE_LOCK_INSTANCE]: SUCCESS. tse_inst:%u, conn_id:%u, lock_mode:%s", - tch.inst_id, tch.thd_id, lock_mode == TSE_LOCK_MODE_EXCLUSIVE ? "X_LATCH" : "S_LATCH"); + ctc_log_system("[CTC_LOCK_INSTANCE]: SUCCESS. ctc_inst:%u, conn_id:%u, lock_mode:%s", + tch.inst_id, tch.thd_id, lock_mode == CTC_LOCK_MODE_EXCLUSIVE ? "X_LATCH" : "S_LATCH"); return ret; } -int tse_check_unlock_instance(MYSQL_THD thd) { +int ctc_check_unlock_instance(MYSQL_THD thd) { if (!thd->mdl_context.has_locks(MDL_key::BACKUP_LOCK)) { return 0; } - tianchi_handler_t tch; - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(get_tse_hton(), thd, tch)); + ctc_handler_t tch; + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(get_ctc_hton(), thd, tch)); bool is_mysqld_starting = is_starting(); - tse_unlock_instance(&is_mysqld_starting, &tch); - tse_log_system("[TSE_UNLOCK_INSTANCE]: SUCCESS. tse_inst:%u, conn_id:%u", tch.inst_id, tch.thd_id); + ctc_unlock_instance(&is_mysqld_starting, &tch); + ctc_log_system("[CTC_UNLOCK_INSTANCE]: SUCCESS. ctc_inst:%u, conn_id:%u", tch.inst_id, tch.thd_id); return 0; } @@ -786,7 +786,7 @@ static inline bool is_temporary_table_being_opened(const TABLE_LIST *table) is_temporary_table(table)); } -int tse_lock_table_pre(MYSQL_THD thd, vector& ticket_list, enum_mdl_type mdl_type) { +int ctc_lock_table_pre(MYSQL_THD thd, vector& ticket_list, enum_mdl_type mdl_type) { #ifdef FEATURE_X_FOR_MYSQL_32 Table_ref *tables_start = thd->lex->query_tables; Table_ref *tables_end = thd->lex->first_not_own_table(); @@ -812,7 +812,7 @@ int tse_lock_table_pre(MYSQL_THD thd, vector& ticket_list, enum_mdl return 0; } -void tse_lock_table_post(MYSQL_THD thd, vector& ticket_list) { +void ctc_lock_table_post(MYSQL_THD thd, vector& ticket_list) { for (auto it = ticket_list.begin(); it != ticket_list.end(); ++it) { thd->mdl_context.release_lock(*it); } diff --git a/storage/tianchi/tse_util.h b/storage/ctc/ctc_util.h similarity index 51% rename from storage/tianchi/tse_util.h rename to storage/ctc/ctc_util.h index 0343c7e..7885910 100644 --- a/storage/tianchi/tse_util.h +++ b/storage/ctc/ctc_util.h @@ -15,8 +15,8 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#ifndef __TSE_UTIL_H__ -#define __TSE_UTIL_H__ +#ifndef __CTC_UTIL_H__ +#define __CTC_UTIL_H__ #include #include @@ -34,52 +34,52 @@ static unordered_set mysql_system_db{"information_schema", "mysql", "per #define CM_IS_EMPTY_STR(str) (((str) == NULL) || ((str)[0] == 0)) -#define TSE_GET_THD_DB_NAME(thd) (thd->db().str == NULL) ? nullptr : const_cast(thd->db().str) +#define CTC_GET_THD_DB_NAME(thd) (thd->db().str == NULL) ? nullptr : const_cast(thd->db().str) #define CBO_STRING_MAX_LEN 16 #define OFFSET_VARCHAR_TYPE 2 -void tse_split_normalized_name(const char *file_name, char db[], size_t db_buf_len, +void ctc_split_normalized_name(const char *file_name, char db[], size_t db_buf_len, char name[], size_t name_buf_len, bool *is_tmp_table); -void tse_copy_name(char to_name[], const char from_name[], size_t to_buf_len); -bool tse_check_ddl_sql_length(const string &query_str); +void ctc_copy_name(char to_name[], const char from_name[], size_t to_buf_len); +bool ctc_check_ddl_sql_length(const string &query_str); string format_remote_errmsg(const char *err_msg); // utils for cond pushdown -int dfs_fill_conds(tianchi_handler_t m_tch, Item *items, Field **field, tse_conds *conds, bool no_backslash); -int tse_push_cond_list(tianchi_handler_t m_tch, Item *items, Field **field, tse_cond_list *list, bool no_backslash); -int tse_push_cond_args(tianchi_handler_t m_tch, Item *items, Field **field, tse_cond_list *list, bool no_backslash); -int tse_fill_cond_field(Item *items, Field **field, tse_conds *cond, bool no_backslash); -int tse_set_cond_field_size(const field_cnvrt_aux_t *mysql_info, tse_conds *cond); -int tse_fill_cond_field_data(tianchi_handler_t m_tch, Item *items, Field *mysql_field, - const field_cnvrt_aux_t *mysql_info, tse_conds *cond); -int tse_fill_cond_field_data_num(tianchi_handler_t m_tch, Item *items, Field *mysql_field, - const field_cnvrt_aux_t *mysql_info, tse_conds *cond); -int tse_fill_cond_field_data_date(tianchi_handler_t m_tch, const field_cnvrt_aux_t *mysql_info, - MYSQL_TIME ltime, date_detail_t *date_detail, tse_conds *cond); -int tse_fill_cond_field_data_string(tianchi_handler_t m_tch, Item_func *item_func, tse_conds *cond, bool no_backslash); +int dfs_fill_conds(ctc_handler_t m_tch, Item *items, Field **field, ctc_conds *conds, bool no_backslash); +int ctc_push_cond_list(ctc_handler_t m_tch, Item *items, Field **field, ctc_cond_list *list, bool no_backslash); +int ctc_push_cond_args(ctc_handler_t m_tch, Item *items, Field **field, ctc_cond_list *list, bool no_backslash); +int ctc_fill_cond_field(Item *items, Field **field, ctc_conds *cond, bool no_backslash); +int ctc_set_cond_field_size(const field_cnvrt_aux_t *mysql_info, ctc_conds *cond); +int ctc_fill_cond_field_data(ctc_handler_t m_tch, Item *items, Field *mysql_field, + const field_cnvrt_aux_t *mysql_info, ctc_conds *cond); +int ctc_fill_cond_field_data_num(ctc_handler_t m_tch, Item *items, Field *mysql_field, + const field_cnvrt_aux_t *mysql_info, ctc_conds *cond); +int ctc_fill_cond_field_data_date(ctc_handler_t m_tch, const field_cnvrt_aux_t *mysql_info, + MYSQL_TIME ltime, date_detail_t *date_detail, ctc_conds *cond); +int ctc_fill_cond_field_data_string(ctc_handler_t m_tch, Item_func *item_func, ctc_conds *cond, bool no_backslash); void update_value_by_charset(char *data, uint16 *size, uint16 bytes); -tse_func_type_t item_func_to_tse_func(Item_func::Functype fc); -int16_t tse_get_column_by_field(Field **field, const char *col_name); -int tse_get_column_cs(const CHARSET_INFO *cs); +ctc_func_type_t item_func_to_ctc_func(Item_func::Functype fc); +int16_t ctc_get_column_by_field(Field **field, const char *col_name); +int ctc_get_column_cs(const CHARSET_INFO *cs); void cm_assert(bool condition); -string tse_deserilize_username_with_single_quotation(string &src); -void tse_print_cantian_err_msg(const ddl_ctrl_t *ddl_ctrl, ct_errno_t ret); -int tse_check_lock_instance(MYSQL_THD thd, bool &need_forward); -int tse_check_unlock_instance(MYSQL_THD thd); +string ctc_deserilize_username_with_single_quotation(string &src); +void ctc_print_cantian_err_msg(const ddl_ctrl_t *ddl_ctrl, ct_errno_t ret); +int ctc_check_lock_instance(MYSQL_THD thd, bool &need_forward); +int ctc_check_unlock_instance(MYSQL_THD thd); int ctc_record_sql(MYSQL_THD thd, bool need_select_db); -int tse_lock_table_pre(MYSQL_THD thd, vector& ticket_list, enum_mdl_type mdl_type); -void tse_lock_table_post(MYSQL_THD thd, vector& ticket_list); +int ctc_lock_table_pre(MYSQL_THD thd, vector& ticket_list, enum_mdl_type mdl_type); +void ctc_lock_table_post(MYSQL_THD thd, vector& ticket_list); #pragma GCC visibility push(default) -/* exposing API for tse_proxy */ -string sql_without_plaintext_password(tse_ddl_broadcast_request* broadcast_req); -string tse_escape_single_quotation_str(string &src); +/* exposing API for ctc_proxy */ +string sql_without_plaintext_password(ctc_ddl_broadcast_request* broadcast_req); +string ctc_escape_single_quotation_str(string &src); string cnvrt_name_for_sql(string name); #pragma GCC visibility pop -#endif // __TSE_UTIL_H__ +#endif // __CTC_UTIL_H__ diff --git a/storage/tianchi/datatype_cnvrt_4_index_search.cc b/storage/ctc/datatype_cnvrt_4_index_search.cc similarity index 87% rename from storage/tianchi/datatype_cnvrt_4_index_search.cc rename to storage/ctc/datatype_cnvrt_4_index_search.cc index 6f104f2..a3bbda0 100644 --- a/storage/tianchi/datatype_cnvrt_4_index_search.cc +++ b/storage/ctc/datatype_cnvrt_4_index_search.cc @@ -16,13 +16,13 @@ */ #include "sql/field.h" #include "typelib.h" -#include "tse_log.h" -#include "tse_error.h" +#include "ctc_log.h" +#include "ctc_error.h" #include "datatype_cnvrt_4_index_search.h" constexpr uint8 OFFSET_VARCHAR_TYPE = 2; -static void tse_convert_mysql_key_to_cantian(KEY_PART_INFO &key_part, const uint8_t *key, uint16_t key_len, uint32_t *data_field_len, +static void ctc_convert_mysql_key_to_cantian(KEY_PART_INFO &key_part, const uint8_t *key, uint16_t key_len, uint32_t *data_field_len, uint8_t **use_key, uint32_t *use_key_len, bool *is_key_null) { if (key_len == 0) { return; @@ -34,7 +34,7 @@ static void tse_convert_mysql_key_to_cantian(KEY_PART_INFO &key_part, const uint offset = 1; } bool check_blob = false; - // convert tse index datatype + // convert ctc index datatype uint32_t data_len = field->key_length(); if (field->type() == MYSQL_TYPE_VARCHAR) { *data_field_len = offset + data_len + OFFSET_VARCHAR_TYPE; @@ -72,7 +72,7 @@ static void tse_convert_mysql_key_to_cantian(KEY_PART_INFO &key_part, const uint return; } -static void tse_index_make_up_key_length(int *key, uint8_t **origin_key, uint32_t *origin_key_len, uint32_t length) { +static void ctc_index_make_up_key_length(int *key, uint8_t **origin_key, uint32_t *origin_key_len, uint32_t length) { int tmp_key = 0; uint8_t *tmp_key_ptr = (uint8_t *)&tmp_key; memcpy(tmp_key_ptr, *origin_key, *origin_key_len); @@ -93,7 +93,7 @@ static void tse_index_make_up_key_length(int *key, uint8_t **origin_key, uint32_ return; } -int tse_fill_index_key_info(TABLE *table, const uchar *key, uint key_len, const key_range *end_range, +int ctc_fill_index_key_info(TABLE *table, const uchar *key, uint key_len, const key_range *end_range, index_key_info_t *index_key_info, bool index_skip_scan) { const uchar *my_key = nullptr; const uchar *end_key = key + key_len; @@ -104,20 +104,20 @@ int tse_fill_index_key_info(TABLE *table, const uchar *key, uint key_len, const index_key_info->key_num = 0; do { if (index_key_info->key_num >= table->key_info[index_key_info->active_index].actual_key_parts) { - tse_log_error("tse_fill_index_key_info: colunm id(%d) is bigger than table key parts(%d).", + ctc_log_error("ctc_fill_index_key_info: colunm id(%d) is bigger than table key parts(%d).", index_key_info->key_num, table->key_info[index_key_info->active_index].actual_key_parts); return ERR_GENERIC_INTERNAL_ERROR; } KEY_PART_INFO key_part = table->key_info[index_key_info->active_index].key_part[index_key_info->key_num]; uint32_t data_field_len = 0; - tse_convert_mysql_key_to_cantian(key_part, key, key_len, &data_field_len, + ctc_convert_mysql_key_to_cantian(key_part, key, key_len, &data_field_len, &index_key_info->key_info[index_key_info->key_num].left_key, &index_key_info->key_info[index_key_info->key_num].left_key_len, &index_key_info->key_info[index_key_info->key_num].is_key_null); if (!index_skip_scan && end_range != nullptr && my_key < end_range->key + end_range->length) { - tse_convert_mysql_key_to_cantian(key_part, my_key, end_range->length, &data_field_len, + ctc_convert_mysql_key_to_cantian(key_part, my_key, end_range->length, &data_field_len, &index_key_info->key_info[index_key_info->key_num].right_key, &index_key_info->key_info[index_key_info->key_num].right_key_len, &index_key_info->key_info[index_key_info->key_num].is_key_null); @@ -138,21 +138,21 @@ int tse_fill_index_key_info(TABLE *table, const uchar *key, uint key_len, const return CT_SUCCESS; } -int tse_convert_key_from_mysql_to_cantian(Field *field, uint8_t **mysql_ptr, dec4_t *cantian_ptr, uint32_t *len) +int ctc_convert_key_from_mysql_to_cantian(Field *field, uint8_t **mysql_ptr, dec4_t *cantian_ptr, uint32_t *len) { int ret = CT_SUCCESS; const field_cnvrt_aux_t *mysql_info = get_auxiliary_for_field_convert(field, field->type()); // 针对tiny和short类型，对应到daac是int类型，所以key length需要按照daac大小的存储 if (mysql_info->mysql_field_type == MYSQL_TYPE_TINY || mysql_info->mysql_field_type == MYSQL_TYPE_SHORT || mysql_info->mysql_field_type == MYSQL_TYPE_INT24) { - tse_index_make_up_key_length(reinterpret_cast(cantian_ptr), mysql_ptr, len, sizeof(int)); + ctc_index_make_up_key_length(reinterpret_cast(cantian_ptr), mysql_ptr, len, sizeof(int)); return ret; } if (field->type() == MYSQL_TYPE_BIT) { *(int64_t *)cantian_ptr = bit_cnvt_mysql_cantian(*mysql_ptr, field); - *len = TSE_BYTE_8; + *len = CTC_BYTE_8; *mysql_ptr = reinterpret_cast(cantian_ptr); return ret; } @@ -170,7 +170,7 @@ int tse_convert_key_from_mysql_to_cantian(Field *field, uint8_t **mysql_ptr, dec if (mysql_info->sql_data_type == DATETIME_DATA) { ret = convert_datetime_to_cantian(mysql_info, reinterpret_cast(cantian_ptr), *mysql_ptr, field); if (ret != CT_SUCCESS) { - tse_log_error("tse convert index datatime to cantian failed."); + ctc_log_error("ctc convert index datatime to cantian failed."); return ret; } @@ -182,7 +182,7 @@ int tse_convert_key_from_mysql_to_cantian(Field *field, uint8_t **mysql_ptr, dec if (field->type() == MYSQL_TYPE_DECIMAL || field->type() == MYSQL_TYPE_NEWDECIMAL) { ret = decimal_mysql_to_cantian(*mysql_ptr, reinterpret_cast(cantian_ptr), field, len); if (ret != CT_SUCCESS) { - tse_log_error("tse convert index decimal to cantian failed."); + ctc_log_error("ctc convert index decimal to cantian failed."); return ret; } @@ -192,23 +192,23 @@ int tse_convert_key_from_mysql_to_cantian(Field *field, uint8_t **mysql_ptr, dec return ret; } -int tse_convert_index_datatype(TABLE *table, index_key_info_t *index_key_info, bool has_right_key, dec4_t *data) { +int ctc_convert_index_datatype(TABLE *table, index_key_info_t *index_key_info, bool has_right_key, dec4_t *data) { int ret; for (int i = 0; i < index_key_info->key_num; ++i) { Field *field = table->key_info[index_key_info->active_index].key_part[i].field; if (index_key_info->key_info[i].left_key_len != 0) { - ret = tse_convert_key_from_mysql_to_cantian(field, &index_key_info->key_info[i].left_key, data++, &index_key_info->key_info[i].left_key_len); + ret = ctc_convert_key_from_mysql_to_cantian(field, &index_key_info->key_info[i].left_key, data++, &index_key_info->key_info[i].left_key_len); if (ret != CT_SUCCESS) { - tse_log_error("tse_convert_key_from_mysql_to_cantian: convert mysql index search left key failed, ret(%d).", ret); + ctc_log_error("ctc_convert_key_from_mysql_to_cantian: convert mysql index search left key failed, ret(%d).", ret); return ret; } } if (has_right_key && index_key_info->key_info[i].right_key_len != 0) { - ret = tse_convert_key_from_mysql_to_cantian(field, &index_key_info->key_info[i].right_key, data++, &index_key_info->key_info[i].right_key_len); + ret = ctc_convert_key_from_mysql_to_cantian(field, &index_key_info->key_info[i].right_key, data++, &index_key_info->key_info[i].right_key_len); if (ret != CT_SUCCESS) { - tse_log_error("tse_convert_key_from_mysql_to_cantian: convert mysql index search right key failed, ret(%d).", ret); + ctc_log_error("ctc_convert_key_from_mysql_to_cantian: convert mysql index search right key failed, ret(%d).", ret); return ret; } } diff --git a/storage/tianchi/datatype_cnvrt_4_index_search.h b/storage/ctc/datatype_cnvrt_4_index_search.h similarity index 87% rename from storage/tianchi/datatype_cnvrt_4_index_search.h rename to storage/ctc/datatype_cnvrt_4_index_search.h index aed10e2..a83cccc 100644 --- a/storage/tianchi/datatype_cnvrt_4_index_search.h +++ b/storage/ctc/datatype_cnvrt_4_index_search.h @@ -15,11 +15,11 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ #include "sql/dd/types/table.h" -#include "tse_srv.h" +#include "ctc_srv.h" #include "datatype_cnvrtr.h" #include "decimal_convert.h" -int tse_fill_index_key_info(TABLE *table, const uchar *key, uint key_len, const key_range *end_range, +int ctc_fill_index_key_info(TABLE *table, const uchar *key, uint key_len, const key_range *end_range, index_key_info_t *index_key_info, bool index_skip_scan); -int tse_convert_index_datatype(TABLE *table, index_key_info_t *index_key_info, bool has_right_key, dec4_t *data); +int ctc_convert_index_datatype(TABLE *table, index_key_info_t *index_key_info, bool has_right_key, dec4_t *data); diff --git a/storage/tianchi/datatype_cnvrtr.cc b/storage/ctc/datatype_cnvrtr.cc similarity index 92% rename from storage/tianchi/datatype_cnvrtr.cc rename to storage/ctc/datatype_cnvrtr.cc index 9e20ec3..7ad5c9e 100644 --- a/storage/tianchi/datatype_cnvrtr.cc +++ b/storage/ctc/datatype_cnvrtr.cc @@ -23,10 +23,10 @@ #include "sql/tztime.h" // my_tz_find, my_tz_OFFSET0 #include "m_string.h" #include "myisampack.h" // mi_int2store -#include "tse_error.h" -#include "tse_log.h" +#include "ctc_error.h" +#include "ctc_log.h" #include "decimal_convert.h" -#include "tse_srv.h" +#include "ctc_srv.h" #ifdef FEATURE_X_FOR_MYSQL_26 #include "sql/json_dom.h" #elif defined(FEATURE_X_FOR_MYSQL_32) @@ -69,37 +69,37 @@ uint16 g_cantian_month_days[2][12] = { Tips:if add new val in enum_field_types, should update this array! */ static field_cnvrt_aux_t g_field_cnvrt_aux_array[] = { - {MYSQL_TYPE_DECIMAL, CANTIAN_COL_BITS_NULL, UNKNOW_DATA, TSE_DDL_TYPE_DECIMAL }, - {MYSQL_TYPE_TINY, CANTIAN_COL_BITS_4, NUMERIC_DATA, TSE_DDL_TYPE_LONG }, - {MYSQL_TYPE_SHORT, CANTIAN_COL_BITS_4, NUMERIC_DATA, TSE_DDL_TYPE_LONG }, - {MYSQL_TYPE_LONG, CANTIAN_COL_BITS_4, NUMERIC_DATA, TSE_DDL_TYPE_LONG }, - {MYSQL_TYPE_FLOAT, CANTIAN_COL_BITS_8, NUMERIC_DATA, TSE_DDL_TYPE_DOUBLE }, - {MYSQL_TYPE_DOUBLE, CANTIAN_COL_BITS_8, NUMERIC_DATA, TSE_DDL_TYPE_DOUBLE }, - {MYSQL_TYPE_NULL, CANTIAN_COL_BITS_NULL, UNKNOW_DATA, TSE_DDL_TYPE_NULL }, - {MYSQL_TYPE_TIMESTAMP, CANTIAN_COL_BITS_8, DATETIME_DATA, TSE_DDL_TYPE_TIMESTAMP }, - {MYSQL_TYPE_LONGLONG, CANTIAN_COL_BITS_8, NUMERIC_DATA, TSE_DDL_TYPE_LONGLONG }, - {MYSQL_TYPE_INT24, CANTIAN_COL_BITS_4, NUMERIC_DATA, TSE_DDL_TYPE_LONG }, - {MYSQL_TYPE_DATE, CANTIAN_COL_BITS_8, DATETIME_DATA, TSE_DDL_TYPE_DATE }, - {MYSQL_TYPE_TIME, CANTIAN_COL_BITS_8, DATETIME_DATA, TSE_DDL_TYPE_TIME }, - {MYSQL_TYPE_DATETIME, CANTIAN_COL_BITS_8, DATETIME_DATA, TSE_DDL_TYPE_DATETIME }, - {MYSQL_TYPE_YEAR, CANTIAN_COL_BITS_8, DATETIME_DATA, TSE_DDL_TYPE_YEAR }, - {MYSQL_TYPE_NEWDATE, CANTIAN_COL_BITS_NULL, UNKNOW_DATA, TSE_DDL_TYPE_NEWDATE }, - {MYSQL_TYPE_VARCHAR, CANTIAN_COL_BITS_VAR, STRING_DATA, TSE_DDL_TYPE_VARCHAR }, - {MYSQL_TYPE_BIT, CANTIAN_COL_BITS_8, NUMERIC_DATA, TSE_DDL_TYPE_LONGLONG }, - {MYSQL_TYPE_TIMESTAMP2, CANTIAN_COL_BITS_NULL, UNKNOW_DATA, TSE_DDL_TYPE_TIMESTAMP2 }, - {MYSQL_TYPE_DATETIME2, CANTIAN_COL_BITS_NULL, UNKNOW_DATA, TSE_DDL_TYPE_DATETIME2 }, - {MYSQL_TYPE_TIME2, CANTIAN_COL_BITS_NULL, UNKNOW_DATA, TSE_DDL_TYPE_TIME2 }, - {MYSQL_TYPE_TYPED_ARRAY, CANTIAN_COL_BITS_NULL, UNKNOW_DATA, TSE_DDL_TYPE_TYPED_ARRAY}, + {MYSQL_TYPE_DECIMAL, CANTIAN_COL_BITS_NULL, UNKNOW_DATA, CTC_DDL_TYPE_DECIMAL }, + {MYSQL_TYPE_TINY, CANTIAN_COL_BITS_4, NUMERIC_DATA, CTC_DDL_TYPE_LONG }, + {MYSQL_TYPE_SHORT, CANTIAN_COL_BITS_4, NUMERIC_DATA, CTC_DDL_TYPE_LONG }, + {MYSQL_TYPE_LONG, CANTIAN_COL_BITS_4, NUMERIC_DATA, CTC_DDL_TYPE_LONG }, + {MYSQL_TYPE_FLOAT, CANTIAN_COL_BITS_8, NUMERIC_DATA, CTC_DDL_TYPE_DOUBLE }, + {MYSQL_TYPE_DOUBLE, CANTIAN_COL_BITS_8, NUMERIC_DATA, CTC_DDL_TYPE_DOUBLE }, + {MYSQL_TYPE_NULL, CANTIAN_COL_BITS_NULL, UNKNOW_DATA, CTC_DDL_TYPE_NULL }, + {MYSQL_TYPE_TIMESTAMP, CANTIAN_COL_BITS_8, DATETIME_DATA, CTC_DDL_TYPE_TIMESTAMP }, + {MYSQL_TYPE_LONGLONG, CANTIAN_COL_BITS_8, NUMERIC_DATA, CTC_DDL_TYPE_LONGLONG }, + {MYSQL_TYPE_INT24, CANTIAN_COL_BITS_4, NUMERIC_DATA, CTC_DDL_TYPE_LONG }, + {MYSQL_TYPE_DATE, CANTIAN_COL_BITS_8, DATETIME_DATA, CTC_DDL_TYPE_DATE }, + {MYSQL_TYPE_TIME, CANTIAN_COL_BITS_8, DATETIME_DATA, CTC_DDL_TYPE_TIME }, + {MYSQL_TYPE_DATETIME, CANTIAN_COL_BITS_8, DATETIME_DATA, CTC_DDL_TYPE_DATETIME }, + {MYSQL_TYPE_YEAR, CANTIAN_COL_BITS_8, DATETIME_DATA, CTC_DDL_TYPE_YEAR }, + {MYSQL_TYPE_NEWDATE, CANTIAN_COL_BITS_NULL, UNKNOW_DATA, CTC_DDL_TYPE_NEWDATE }, + {MYSQL_TYPE_VARCHAR, CANTIAN_COL_BITS_VAR, STRING_DATA, CTC_DDL_TYPE_VARCHAR }, + {MYSQL_TYPE_BIT, CANTIAN_COL_BITS_8, NUMERIC_DATA, CTC_DDL_TYPE_LONGLONG }, + {MYSQL_TYPE_TIMESTAMP2, CANTIAN_COL_BITS_NULL, UNKNOW_DATA, CTC_DDL_TYPE_TIMESTAMP2 }, + {MYSQL_TYPE_DATETIME2, CANTIAN_COL_BITS_NULL, UNKNOW_DATA, CTC_DDL_TYPE_DATETIME2 }, + {MYSQL_TYPE_TIME2, CANTIAN_COL_BITS_NULL, UNKNOW_DATA, CTC_DDL_TYPE_TIME2 }, + {MYSQL_TYPE_TYPED_ARRAY, CANTIAN_COL_BITS_NULL, UNKNOW_DATA, CTC_DDL_TYPE_TYPED_ARRAY}, // > MYSQL_TYPE_INVALID - {MYSQL_TYPE_JSON, CANTIAN_COL_BITS_VAR, LOB_DATA, TSE_DDL_TYPE_JSON }, - {MYSQL_TYPE_NEWDECIMAL, CANTIAN_COL_BITS_VAR, NUMERIC_DATA, TSE_DDL_TYPE_NEWDECIMAL }, - {MYSQL_TYPE_TINY_BLOB, CANTIAN_COL_BITS_VAR, LOB_DATA, TSE_DDL_TYPE_TINY_BLOB }, - {MYSQL_TYPE_MEDIUM_BLOB, CANTIAN_COL_BITS_VAR, LOB_DATA, TSE_DDL_TYPE_MEDIUM_BLOB}, - {MYSQL_TYPE_LONG_BLOB, CANTIAN_COL_BITS_VAR, LOB_DATA, TSE_DDL_TYPE_LONG_BLOB }, - {MYSQL_TYPE_BLOB, CANTIAN_COL_BITS_VAR, LOB_DATA, TSE_DDL_TYPE_BLOB }, + {MYSQL_TYPE_JSON, CANTIAN_COL_BITS_VAR, LOB_DATA, CTC_DDL_TYPE_JSON }, + {MYSQL_TYPE_NEWDECIMAL, CANTIAN_COL_BITS_VAR, NUMERIC_DATA, CTC_DDL_TYPE_NEWDECIMAL }, + {MYSQL_TYPE_TINY_BLOB, CANTIAN_COL_BITS_VAR, LOB_DATA, CTC_DDL_TYPE_TINY_BLOB }, + {MYSQL_TYPE_MEDIUM_BLOB, CANTIAN_COL_BITS_VAR, LOB_DATA, CTC_DDL_TYPE_MEDIUM_BLOB}, + {MYSQL_TYPE_LONG_BLOB, CANTIAN_COL_BITS_VAR, LOB_DATA, CTC_DDL_TYPE_LONG_BLOB }, + {MYSQL_TYPE_BLOB, CANTIAN_COL_BITS_VAR, LOB_DATA, CTC_DDL_TYPE_BLOB }, // The following two types not used for datatype convert, Unconfirmed scenarios in which this feature will be used. - {MYSQL_TYPE_VAR_STRING, CANTIAN_COL_BITS_NULL, UNKNOW_DATA, TSE_DDL_TYPE_VAR_STRING }, - {MYSQL_TYPE_STRING, CANTIAN_COL_BITS_VAR, STRING_DATA, TSE_DDL_TYPE_STRING } + {MYSQL_TYPE_VAR_STRING, CANTIAN_COL_BITS_NULL, UNKNOW_DATA, CTC_DDL_TYPE_VAR_STRING }, + {MYSQL_TYPE_STRING, CANTIAN_COL_BITS_VAR, STRING_DATA, CTC_DDL_TYPE_STRING } }; /** get idx in g_field_cnvrt_aux_array. @@ -157,9 +157,9 @@ const field_cnvrt_aux_t* get_auxiliary_for_field_convert(Field *field, enum_fiel if (field->is_flag_set(BLOB_FLAG)) { if (field->charset() == &my_charset_bin && field->is_flag_set(BINARY_FLAG)) { - ret->ddl_field_type = TSE_DDL_TYPE_BLOB; + ret->ddl_field_type = CTC_DDL_TYPE_BLOB; } else { - ret->ddl_field_type = TSE_DDL_TYPE_CLOB; + ret->ddl_field_type = CTC_DDL_TYPE_CLOB; } } @@ -369,24 +369,24 @@ int decimal_mysql_to_cantian(const uint8_t *mysql_ptr, uchar *cantian_ptr, Field int ret = 0; const int scale = mysql_field->decimals(); Field_new_decimal *f = dynamic_cast(mysql_field); - TSE_RET_ERR_IF_NULL(f); + CTC_RET_ERR_IF_NULL(f); const int prec = f->precision; my_decimal d; ret = binary2my_decimal(E_DEC_FATAL_ERROR, mysql_ptr, &d, prec, scale); if (ret != E_DEC_OK) { - tse_log_error("[mysql2cantians]Decimal data type convert binary to my_decimal failed!"); + ctc_log_error("[mysql2cantians]Decimal data type convert binary to my_decimal failed!"); return ret; } char buff[DECIMAL_MAX_STR_LENGTH + 1]; int len = sizeof(buff); ret = decimal2string(&d, buff, &len); if (ret != E_DEC_OK) { - tse_log_error("[mysql2cantian]Decimal data type convert my_decimal to string failed!"); + ctc_log_error("[mysql2cantian]Decimal data type convert my_decimal to string failed!"); return ret; } dec8_t d8; if (ct_cm_str_to_dec8(buff, &d8) != CT_SUCCESS_STATUS) { - tse_log_error("[mysql2cantian]Decimal data type convert str to dec8 failed!"); + ctc_log_error("[mysql2cantian]Decimal data type convert str to dec8 failed!"); assert(0); } cm_dec_8_to_4((dec4_t *)cantian_ptr, &d8); @@ -401,7 +401,7 @@ void decimal_cantian_to_mysql(uint8_t *mysql_ptr, uchar *cantian_ptr, Field *mys ct_cm_dec_4_to_8(&dec, d4, (uint32)cm_dec4_stor_sz(d4)); char str[DEC_MAX_NUM_SAVING_PREC]; if (ct_cm_dec8_to_str(&dec, DEC_MAX_NUM_SAVING_PREC, str) != CT_SUCCESS_STATUS) { - tse_log_error("[cantian2mysql]Decimal data type convert dec8 to str failed!"); + ctc_log_error("[cantian2mysql]Decimal data type convert dec8 to str failed!"); assert(0); } @@ -409,20 +409,20 @@ void decimal_cantian_to_mysql(uint8_t *mysql_ptr, uchar *cantian_ptr, Field *mys const char *decimal_data = str; const char *end = strend(decimal_data); if (string2decimal(decimal_data, &decimal_value, &end) != E_DEC_OK) { - tse_log_error("[cantian2mysql]Decimal data type convert str to my_decimal failed!"); + ctc_log_error("[cantian2mysql]Decimal data type convert str to my_decimal failed!"); assert(0); } Field_new_decimal *f = dynamic_cast(mysql_field); if (f == nullptr) { - tse_log_error("[cantian2mysql]Decimal data type convert my_decimal to binary failed!"); + ctc_log_error("[cantian2mysql]Decimal data type convert my_decimal to binary failed!"); assert(0); } const int prec = f->precision; const int scale = mysql_field->decimals(); if (my_decimal2binary(E_DEC_FATAL_ERROR, &decimal_value, mysql_ptr, prec, scale) != E_DEC_OK) { - tse_log_error("[cantian2mysql]Decimal data type convert my_decimal to binary failed!"); + ctc_log_error("[cantian2mysql]Decimal data type convert my_decimal to binary failed!"); assert(0); } } @@ -432,17 +432,17 @@ int decimal_mysql_to_double(const uint8_t *mysql_ptr, uchar *double_ptr, Field * int ret = 0; const int scale = mysql_field->decimals(); Field_new_decimal *f = dynamic_cast(mysql_field); - TSE_RET_ERR_IF_NULL(f); + CTC_RET_ERR_IF_NULL(f); const int prec = f->precision; my_decimal d; ret = binary2my_decimal(E_DEC_FATAL_ERROR, mysql_ptr, &d, prec, scale); if (ret != E_DEC_OK) { - tse_log_error("[decimal2double]: Decimal data type convert binary to my_decimal failed!"); + ctc_log_error("[decimal2double]: Decimal data type convert binary to my_decimal failed!"); return ret; } ret = decimal2double(&d, (double *)double_ptr); if (ret != E_DEC_OK) { - tse_log_error("[decimal2double]: Decimal data type convert my_decimal to double failed!"); + ctc_log_error("[decimal2double]: Decimal data type convert my_decimal to double failed!"); } return ret; } @@ -477,25 +477,25 @@ static inline uint32_t get_blob_buffer_size(uint32_t remain_size) @brief blob data is stored in mysql Field_blob struct, which is in one piece of continuous memory we can get the ptr and length from Field_blob get_blob_data and get_length interface, - then invoke the Cantian tse_knl_write_lob interface, write blob data to tse storage engine + then invoke the Cantian ctc_knl_write_lob interface, write blob data to ctc storage engine piece by piece. It's important to note that one piece of blob data preferably greater than 4000, - because the tse storage engine is store blob data inline when blob data length less than 4000, + because the ctc storage engine is store blob data inline when blob data length less than 4000, otherwise the blob data store outline. */ int convert_blob_to_cantian(uchar *cantian_ptr, uint32 &cantian_offset, uchar *blob_str, uint32 remain_size, - tianchi_handler_t &tch, uint column_id, uint32_t &field_len) { + ctc_handler_t &tch, uint column_id, uint32_t &field_len) { uint32_t buffer_size = get_blob_buffer_size(remain_size); - assert(buffer_size >= TSE_LOB_LOCATOR_BUF_SIZE); + assert(buffer_size >= CTC_LOB_LOCATOR_BUF_SIZE); lob_text_t piece_lob; uint32_t offset = 0; lob_locator_t *lob_locator = nullptr; uint32 locator_size = OFFSET_OF(lob_locator_t, data) + remain_size; - locator_size = locator_size > TSE_LOB_LOCATOR_BUF_SIZE ? TSE_LOB_LOCATOR_BUF_SIZE : locator_size; + locator_size = locator_size > CTC_LOB_LOCATOR_BUF_SIZE ? CTC_LOB_LOCATOR_BUF_SIZE : locator_size; lob_locator = (lob_locator_t *)my_malloc(PSI_NOT_INSTRUMENTED, locator_size, MYF(MY_WME)); if (lob_locator == nullptr) { - tse_log_error("[mysql2cantian]Apply for lob locator:%u Failed", locator_size); + ctc_log_error("[mysql2cantian]Apply for lob locator:%u Failed", locator_size); my_error(ER_OUT_OF_RESOURCES, MYF(0), "LOB LOCATOR"); field_len = 0; return HA_ERR_SE_OUT_OF_MEMORY; @@ -503,7 +503,7 @@ int convert_blob_to_cantian(uchar *cantian_ptr, uint32 &cantian_offset, memset(lob_locator, 0xFF, locator_size); lob_locator->head.size = 0; // for inline - if (remain_size <= TSE_LOB_MAX_INLINE_SIZE) { + if (remain_size <= CTC_LOB_MAX_INLINE_SIZE) { lob_locator->head.type = 0; lob_locator->head.is_outline = false; lob_locator->head.size = remain_size; @@ -515,14 +515,14 @@ int convert_blob_to_cantian(uchar *cantian_ptr, uint32 &cantian_offset, while (remain_size > 0) { piece_lob.str = (char *) blob_str + offset; piece_lob.len = remain_size > buffer_size ? buffer_size : remain_size; - int ret = tse_knl_write_lob(&tch, (char *)lob_locator, locator_size, column_id, + int ret = ctc_knl_write_lob(&tch, (char *)lob_locator, locator_size, column_id, (void *)piece_lob.str, (uint32_t)piece_lob.len, force_outline); if (ret != CT_SUCCESS) { - tse_log_error("[mysql2cantian]tse_knl_write_lob Failed:%d", ret); + ctc_log_error("[mysql2cantian]ctc_knl_write_lob Failed:%d", ret); my_free(lob_locator); lob_locator = nullptr; field_len = 0; - return convert_tse_error_code_to_mysql((ct_errno_t)ret); + return convert_ctc_error_code_to_mysql((ct_errno_t)ret); } if (!force_outline) { force_outline = true; @@ -550,7 +550,7 @@ void convert_json_to_mysql(Field *mysql_field) Field_json *json = dynamic_cast(mysql_field); Json_wrapper wr; if (json == nullptr || (bitmap_is_set(json->table->read_set, mysql_field->field_index()) && json->val_json(&wr))) { - tse_log_error("[convert_json_to_mysql] get json value failed"); + ctc_log_error("[convert_json_to_mysql] get json value failed"); assert(0); } } @@ -558,19 +558,19 @@ void convert_json_to_mysql(Field *mysql_field) } /** @brief - The blob data stored in the TSE storage engine can be in-line or out-line scenarios. - However, you can query the blob data by calling the tse_knl_read_lob interface in + The blob data stored in the CTC storage engine can be in-line or out-line scenarios. + However, you can query the blob data by calling the ctc_knl_read_lob interface in sharding mode. Then you need to assemble the fragmented data into a whole memory block and insert it into the MySQL by delivery the address of lob buf. */ -void convert_blob_to_mysql(uchar *cantian_ptr, Field *mysql_field, tianchi_handler_t &tch, uint8_t *mysql_ptr) +void convert_blob_to_mysql(uchar *cantian_ptr, Field *mysql_field, ctc_handler_t &tch, uint8_t *mysql_ptr) { bitmap_set_bit(mysql_field->table->read_set, mysql_field->field_index()); lob_locator_t *locator = (lob_locator_t *)(uint8*)cantian_ptr; uint32_t blob_len = locator->head.size; char *blob_buf = (char *)my_malloc(PSI_NOT_INSTRUMENTED, blob_len * sizeof(char), MYF(MY_WME)); if (blob_len == 0) { - tse_log_note("[cantian2mysql]data type %d for 0 length", mysql_field->type()); + ctc_log_note("[cantian2mysql]data type %d for 0 length", mysql_field->type()); // Insert in Mysql when the data is empty memcpy(mysql_ptr, &blob_buf, sizeof(char *)); convert_json_to_mysql(mysql_field); @@ -578,7 +578,7 @@ void convert_blob_to_mysql(uchar *cantian_ptr, Field *mysql_field, tianchi_handl } if (blob_buf == nullptr) { - tse_log_error("[cantian2mysql]Apply for blob buf:%u Failed", blob_len); + ctc_log_error("[cantian2mysql]Apply for blob buf:%u Failed", blob_len); my_error(ER_OUT_OF_RESOURCES, MYF(0), "BLOB DATA"); return; } @@ -600,14 +600,14 @@ void convert_blob_to_mysql(uchar *cantian_ptr, Field *mysql_field, tianchi_handl // read blob data piece by piece while (remain_size > 0) { piece_len = remain_size > buffer_size ? buffer_size : remain_size; - int ret = tse_knl_read_lob(&tch, (char *)locator, offset, blob_buf + offset, piece_len, &read_size); + int ret = ctc_knl_read_lob(&tch, (char *)locator, offset, blob_buf + offset, piece_len, &read_size); if (ret != CT_SUCCESS) { - tse_log_error("[cantian2mysql]tse_knl_read_lob Failed : %d", ret); + ctc_log_error("[cantian2mysql]ctc_knl_read_lob Failed : %d", ret); read_flag = false; break; } if (read_size <= 0) { - tse_log_note("[cantian2mysql]tse_knl_read_lob read lob length is %d,stop read!", read_size); + ctc_log_note("[cantian2mysql]ctc_knl_read_lob read lob length is %d,stop read!", read_size); read_flag = false; break; } @@ -677,7 +677,7 @@ longlong bit_cnvt_mysql_cantian(const uchar *ptr, Field *mysql_field) ulonglong bits = 0; Field_bit *field = dynamic_cast(mysql_field); if (field == nullptr) { - tse_log_error("bit_cnvt_mysql_cantian failed!"); + ctc_log_error("bit_cnvt_mysql_cantian failed!"); assert(0); } uint bytes_in_rec = field->bytes_in_rec; @@ -712,7 +712,7 @@ void bit_cnvt_cantian_mysql(const uchar *cantian_ptr, uchar *mysql_ptr, Field *m ulonglong bits = 0; Field_bit *field = dynamic_cast(mysql_field); if (field == nullptr) { - tse_log_error("bit_cnvt_cantian_mysql failed!"); + ctc_log_error("bit_cnvt_cantian_mysql failed!"); assert(0); return; } @@ -788,7 +788,7 @@ int convert_numeric_to_cantian(const field_cnvrt_aux_t *mysql_info, const uchar res = decimal_mysql_to_cantian(mysql_ptr, cantian_ptr, mysql_field, length); break; default: - tse_log_error("[mysql2cantian]unsupport numeric datatype %d", mysql_info->mysql_field_type); + ctc_log_error("[mysql2cantian]unsupport numeric datatype %d", mysql_info->mysql_field_type); assert(0); break; } @@ -822,7 +822,7 @@ static void decode_mysql_year_type(MYSQL_TIME& ltime, const uchar *mysql_ptr) @brief Decode time value from TIME type which in Mysql format, and fill in other fields. @note In Mysql Format,The value of the TIME type ranges from -838:59:59.000000 to 838:59:59.000000. - For the value of hour in the CantianDB must range from 0 to 23, the tse just support + For the value of hour in the CantianDB must range from 0 to 23, the ctc just support TIME type range from 00:00:00.000000 to 23:59:59.000000. @param[out] ltime The variable to convert to. @param mysql_ptr The value to convert from, mysql time data ptr. @@ -900,7 +900,7 @@ static void decode_mysql_timestamp_type(MYSQL_TIME& ltime, const uchar *mysql_pt @brief Decode all date and time Type which in Mysql format, and output to MYSQL_TIME class. @note In Mysql Format,The value of the TIME type ranges from -838:59:59.000000 to 838:59:59.000000. - For the value of hour in the CantianDB must range from 0 to 23, the tse just support + For the value of hour in the CantianDB must range from 0 to 23, the ctc just support TIME type range from 00:00:00.000000 to 23:59:59.000000. @param[out] ltime The variable to convert to. @param mysql_info mysql field type info. @@ -927,7 +927,7 @@ void decode_mysql_datetime(MYSQL_TIME& ltime, const field_cnvrt_aux_t* mysql_inf decode_mysql_timestamp_type(ltime, mysql_ptr, mysql_field); break; default: - tse_log_error("[mysql2cantian datetime]unsupport datatype %d", mysql_info->mysql_field_type); + ctc_log_error("[mysql2cantian datetime]unsupport datatype %d", mysql_info->mysql_field_type); assert(false); } } @@ -1006,7 +1006,7 @@ void cnvrt_time_decimal(const uchar *src_ptr, int src_dec, uchar *des_ptr, int d { // convert decimal for MYSQL_TYPE_TIME MYSQL_TIME ltime; - uchar tmp_ptr[TSE_BYTE_8] = {0}; + uchar tmp_ptr[CTC_BYTE_8] = {0}; longlong packed = my_time_packed_from_binary(src_ptr, src_dec); TIME_from_longlong_time_packed(<ime, packed); // fill in other fields @@ -1023,7 +1023,7 @@ void cnvrt_datetime_decimal(const uchar *src_ptr, int src_dec, uchar *des_ptr, i { // convert decimal for MYSQL_TYPE_DATETIME MYSQL_TIME ltime; - uchar tmp_ptr[TSE_BYTE_8] = {0}; + uchar tmp_ptr[CTC_BYTE_8] = {0}; longlong packed = my_datetime_packed_from_binary(src_ptr, src_dec); TIME_from_longlong_datetime_packed(<ime, packed); longlong ll = TIME_to_longlong_datetime_packed(ltime); @@ -1041,15 +1041,15 @@ int convert_datetime_to_cantian(const field_cnvrt_aux_t* mysql_info, uchar *cant { switch (mysql_info->mysql_field_type) { case MYSQL_TYPE_TIME: - cnvrt_time_decimal(mysql_ptr, mysql_field->decimals(), cantian_ptr, DATETIME_MAX_DECIMALS, TSE_BYTE_8); + cnvrt_time_decimal(mysql_ptr, mysql_field->decimals(), cantian_ptr, DATETIME_MAX_DECIMALS, CTC_BYTE_8); break; case MYSQL_TYPE_DATETIME: - cnvrt_datetime_decimal(mysql_ptr, mysql_field->decimals(), cantian_ptr, DATETIME_MAX_DECIMALS, TSE_BYTE_8); + cnvrt_datetime_decimal(mysql_ptr, mysql_field->decimals(), cantian_ptr, DATETIME_MAX_DECIMALS, CTC_BYTE_8); break; case MYSQL_TYPE_DATE: - memset(cantian_ptr, 0, TSE_BYTE_8); + memset(cantian_ptr, 0, CTC_BYTE_8); memcpy(cantian_ptr, mysql_ptr, mysql_field->pack_length()); break; @@ -1108,7 +1108,7 @@ static void convert_numeric_to_mysql(const field_cnvrt_aux_t *mysql_info, uchar decimal_cantian_to_mysql(mysql_ptr, cantian_ptr, mysql_field); break; default: - tse_log_error("[cantian2mysql]unsupport numeric datatype %d", mysql_info->mysql_field_type); + ctc_log_error("[cantian2mysql]unsupport numeric datatype %d", mysql_info->mysql_field_type); assert(0); break; } @@ -1140,7 +1140,7 @@ static void convert_numeric_to_mysql(const field_cnvrt_aux_t *mysql_info, uchar @return False on success, true on error. */ -bool tse_datetime_with_no_zero_in_date_to_timeval(const MYSQL_TIME *ltime, +bool ctc_datetime_with_no_zero_in_date_to_timeval(const MYSQL_TIME *ltime, const Time_zone &tz, struct timeval *tm, int *warnings) @@ -1188,7 +1188,7 @@ bool tse_datetime_with_no_zero_in_date_to_timeval(const MYSQL_TIME *ltime, @param [out] ptr The pointer to store the value to. @param dec Precision. */ -static void tse_my_timestamp_to_binary(const struct timeval *tm, uchar *ptr, uint dec) +static void ctc_my_timestamp_to_binary(const struct timeval *tm, uchar *ptr, uint dec) { assert(dec <= DATETIME_MAX_DECIMALS); /* Stored value must have been previously properly rounded or truncated */ @@ -1219,7 +1219,7 @@ static void tse_my_timestamp_to_binary(const struct timeval *tm, uchar *ptr, uin @brief convert datetime data from cantian to mysql */ -static void convert_datetime_to_mysql(tianchi_handler_t &tch, const field_cnvrt_aux_t* mysql_info, +static void convert_datetime_to_mysql(ctc_handler_t &tch, const field_cnvrt_aux_t* mysql_info, uint8_t *mysql_ptr, uchar *cantian_ptr, Field *mysql_field) { if (mysql_info->mysql_field_type == MYSQL_TYPE_DATE) { @@ -1284,14 +1284,14 @@ static void convert_datetime_to_mysql(tianchi_handler_t &tch, const field_cnvrt_ int warnings = 0; int dec = mysql_field->decimals(); - tse_datetime_with_no_zero_in_date_to_timeval(<ime, *my_tz_OFFSET0, &tm, &warnings); + ctc_datetime_with_no_zero_in_date_to_timeval(<ime, *my_tz_OFFSET0, &tm, &warnings); // Assume that since the value was properly stored, there're no warnings assert(!warnings); - tse_my_timestamp_to_binary(&tm, mysql_ptr, dec); + ctc_my_timestamp_to_binary(&tm, mysql_ptr, dec); break; } default: - tse_log_error("[cantian2mysql datetime]unsupport datatype %d", mysql_info->mysql_field_type); + ctc_log_error("[cantian2mysql datetime]unsupport datatype %d", mysql_info->mysql_field_type); assert(0); break; } @@ -1319,7 +1319,7 @@ static uint32_t calculate_variable_len(const field_cnvrt_aux_t* mysql_info, Fiel } else if (data_offset == 2) { field_len = read_from_2_little_endian(mysql_ptr); } else { - tse_log_error("[mysql2cantian]get varchar data length error: %u", data_offset); + ctc_log_error("[mysql2cantian]get varchar data length error: %u", data_offset); } break; case MYSQL_TYPE_JSON: @@ -1345,7 +1345,7 @@ static uint32_t calculate_variable_len(const field_cnvrt_aux_t* mysql_info, Fiel int scale = mysql_field->decimals(); Field_new_decimal *f = dynamic_cast(mysql_field); if (f == nullptr) { - tse_log_error("[mysql2cantian calculate length]unknow data type: %d", mysql_info->mysql_field_type); + ctc_log_error("[mysql2cantian calculate length]unknow data type: %d", mysql_info->mysql_field_type); data_offset = 0; break; } @@ -1357,7 +1357,7 @@ static uint32_t calculate_variable_len(const field_cnvrt_aux_t* mysql_info, Fiel break; } default: - tse_log_error("[mysql2cantian calculate length]unknow data type: %d", mysql_info->mysql_field_type); + ctc_log_error("[mysql2cantian calculate length]unknow data type: %d", mysql_info->mysql_field_type); data_offset = 0; break; } @@ -1391,7 +1391,7 @@ static uint8_t padding_variable_byte(const field_cnvrt_aux_t* mysql_info, break; } default: - tse_log_debug("[cantian2mysql]mysql field type: %d do not need data head", mysql_info->mysql_field_type); + ctc_log_debug("[cantian2mysql]mysql field type: %d do not need data head", mysql_info->mysql_field_type); break; } return mysql_offset; @@ -1431,7 +1431,7 @@ static void get_map_and_field_len(uint32_t &field_len, const field_cnvrt_aux_t* } break; default: - tse_log_error("[mysql2cantian]unknow col bits: %d", mysql_info->cantian_map_type); + ctc_log_error("[mysql2cantian]unknow col bits: %d", mysql_info->cantian_map_type); assert(0); break; } @@ -1440,7 +1440,7 @@ static void get_map_and_field_len(uint32_t &field_len, const field_cnvrt_aux_t* static int convert_data_from_mysql_to_cantian(const field_cnvrt_aux_t* mysql_info, Field *field, record_buf_info_t *record_buf, uint16_t *serial_column_offset, field_offset_and_len_t *field_offset_info, - uint32_t &field_len, tianchi_handler_t &tch, uint column_id) + uint32_t &field_len, ctc_handler_t &tch, uint column_id) { int res = 0; switch (mysql_info->sql_data_type) { @@ -1490,14 +1490,14 @@ static int convert_data_from_mysql_to_cantian(const field_cnvrt_aux_t* mysql_inf } break; case UNKNOW_DATA: default: - tse_log_error("[mysql2cantian]unsupport sql_data_type %d", mysql_info->sql_data_type); + ctc_log_error("[mysql2cantian]unsupport sql_data_type %d", mysql_info->sql_data_type); assert(0); break; } return res; } -int mysql_record_to_cantian_record(const TABLE &table, record_buf_info_t *record_buf, tianchi_handler_t &tch, +int mysql_record_to_cantian_record(const TABLE &table, record_buf_info_t *record_buf, ctc_handler_t &tch, uint16_t *serial_column_offset, std::vector *fields) { *serial_column_offset = 0; @@ -1592,7 +1592,7 @@ int mysql_record_to_cantian_record(const TABLE &table, record_buf_info_t *record } void copy_column_data_to_mysql(field_info_t *field_info, const field_cnvrt_aux_t* mysql_info, - tianchi_handler_t &tch, bool is_index_only) + ctc_handler_t &tch, bool is_index_only) { if (!bitmap_is_set(field_info->field->table->read_set, field_info->field->field_index()) && tch.sql_command == SQLCOM_SELECT) { @@ -1640,7 +1640,7 @@ void copy_column_data_to_mysql(field_info_t *field_info, const field_cnvrt_aux_t uint32_t blob_len = field_info->field_len; char *blob_buf = (char *)my_malloc(PSI_NOT_INSTRUMENTED, blob_len * sizeof(char), MYF(MY_WME)); if (blob_buf == nullptr) { - tse_log_error("[cantian2mysql]Apply for blob buf:%u Failed", blob_len); + ctc_log_error("[cantian2mysql]Apply for blob buf:%u Failed", blob_len); return; } memcpy(blob_buf, field_info->cantian_cur_field, blob_len); @@ -1654,13 +1654,13 @@ void copy_column_data_to_mysql(field_info_t *field_info, const field_cnvrt_aux_t case UNKNOW_DATA: /* fall through */ default: - tse_log_error("[cantian2mysql]unsupport datatype %d", mysql_info->sql_data_type); + ctc_log_error("[cantian2mysql]unsupport datatype %d", mysql_info->sql_data_type); assert(0); break; } } -static inline bool ctc_field_type_is_lob(bool is_index_only, const field_cnvrt_aux_t* cnvrt_aux, Field *field, tianchi_handler_t &tch) +static inline bool ctc_field_type_is_lob(bool is_index_only, const field_cnvrt_aux_t* cnvrt_aux, Field *field, ctc_handler_t &tch) { return !is_index_only && (cnvrt_aux->mysql_field_type == MYSQL_TYPE_BLOB || cnvrt_aux->mysql_field_type == MYSQL_TYPE_JSON || @@ -1669,7 +1669,7 @@ static inline bool ctc_field_type_is_lob(bool is_index_only, const field_cnvrt_a } static bool ctc_update_offset_single(uint col_id, Field *field, uint8 cantian_col_type, const field_cnvrt_aux_t* cnvrt_aux, record_info_t *record_info, - record_buf_info_t *record_buf, field_offset_and_len_t *size, bool is_index_only, tianchi_handler_t &tch) + record_buf_info_t *record_buf, field_offset_and_len_t *size, bool is_index_only, ctc_handler_t &tch) { switch (cantian_col_type) { case CANTIAN_COL_BITS_NULL: @@ -1697,7 +1697,7 @@ static bool ctc_update_offset_single(uint col_id, Field *field, uint8 cantian_co break; } default: - tse_log_error("[cantian2mysql]unknow col bits: %u", cantian_col_type); + ctc_log_error("[cantian2mysql]unknow col bits: %u", cantian_col_type); assert(0); break; } @@ -1705,7 +1705,7 @@ static bool ctc_update_offset_single(uint col_id, Field *field, uint8 cantian_co } static bool ctc_parse_cantian_column_and_update_offset(Field *field, uint8 cantian_col_type, const field_cnvrt_aux_t* cnvrt_aux, - record_buf_info_t *record_buf, field_offset_and_len_t *size, bool is_index_only, tianchi_handler_t &tch) + record_buf_info_t *record_buf, field_offset_and_len_t *size, bool is_index_only, ctc_handler_t &tch) { switch (cantian_col_type) { case CANTIAN_COL_BITS_NULL: @@ -1752,7 +1752,7 @@ static bool ctc_parse_cantian_column_and_update_offset(Field *field, uint8 canti break; } default: - tse_log_error("[cantian2mysql]unknow col bits: %u", cantian_col_type); + ctc_log_error("[cantian2mysql]unknow col bits: %u", cantian_col_type); assert(0); break; } @@ -1760,7 +1760,7 @@ static bool ctc_parse_cantian_column_and_update_offset(Field *field, uint8 canti } void convert_cantian_field_to_mysql_field(uint col_id, Field *field, field_offset_and_col_type *filed_offset, record_info_t *record_info, - record_buf_info_t *record_buf, tianchi_handler_t &tch, bool is_index_only) + record_buf_info_t *record_buf, ctc_handler_t &tch, bool is_index_only) { // Get auxiliary info for field convertion const field_cnvrt_aux_t* cnvrt_aux_info = get_auxiliary_for_field_convert(field, field->type()); @@ -1792,23 +1792,23 @@ void convert_cantian_field_to_mysql_field(uint col_id, Field *field, field_offse } void cantian_record_to_mysql_record(const TABLE &table, index_info_t *index, record_buf_info_t *record_buf, - tianchi_handler_t &tch, record_info_t *record_info) + ctc_handler_t &tch, record_info_t *record_info) { row_head_t *row_head = (row_head_t *)record_buf->cantian_record_buf; bool is_index_only = false; - tse_log_debug("size %u, column cnt %u, is_changed:%hu, is_deleted:%hu, " + ctc_log_debug("size %u, column cnt %u, is_changed:%hu, is_deleted:%hu, " "is_link:%hu, is_migr:%hu, self_chg:%hu, is_csf:%hu", row_head->size, row_head->column_count, row_head->is_changed, row_head->is_deleted, row_head->is_link, row_head->is_migr, row_head->self_chg, row_head->is_csf); if (row_head->is_csf) { - tse_log_error("csf format is not supported yet"); + ctc_log_error("csf format is not supported yet"); assert(0); } if (IS_SPRS_ROW(row_head)) { - tse_log_error("sparse row not supported yet"); + ctc_log_error("sparse row not supported yet"); assert(0); } @@ -1853,7 +1853,7 @@ void cantian_record_to_mysql_record(const TABLE &table, index_info_t *index, rec // @note that this cnvrt func can only be used for record fetched directly // from index structures(i.e. circumstances like index-only) void cantian_index_record_to_mysql_record(const TABLE &table, index_info_t *index, record_buf_info_t *record_buf, - tianchi_handler_t &tch, record_info_t *record_info) + ctc_handler_t &tch, record_info_t *record_info) { auto index_info = table.key_info[index->active_index]; uint n_fields = index_info.actual_key_parts; @@ -1934,7 +1934,7 @@ int get_cantian_record_length(const TABLE *table) case MYSQL_TYPE_NEWDECIMAL: { int scale = mysql_field->decimals(); Field_new_decimal *f = dynamic_cast(mysql_field); - TSE_RET_ERR_IF_NULL(f); + CTC_RET_ERR_IF_NULL(f); int prec = f->precision; int ncells = ALIGN_UP(prec - scale, 4) + ALIGN_UP(scale, 4); field_len = ROUND_UP((1 + ncells) * sizeof(uint16_t) + sizeof(uint16_t), 4); @@ -1948,7 +1948,7 @@ int get_cantian_record_length(const TABLE *table) field_len = ROUND_UP(sizeof(lob_locator_t) + sizeof(uint16_t), 4); break; default: - tse_log_error("unsupported column type %d", mysql_field->type()); + ctc_log_error("unsupported column type %d", mysql_field->type()); return -1; } total_record_length += field_len; diff --git a/storage/tianchi/datatype_cnvrtr.h b/storage/ctc/datatype_cnvrtr.h similarity index 92% rename from storage/tianchi/datatype_cnvrtr.h rename to storage/ctc/datatype_cnvrtr.h index 21516aa..95b6a9c 100644 --- a/storage/tianchi/datatype_cnvrtr.h +++ b/storage/ctc/datatype_cnvrtr.h @@ -15,7 +15,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#include "ha_tse.h" +#include "ha_ctc.h" #include "my_inttypes.h" #include #include "sql/my_decimal.h" @@ -45,13 +45,13 @@ typedef int16 timezone_info_t; */ typedef int64 date_t; -#define TSE_BYTE_8 8 +#define CTC_BYTE_8 8 #define CANTIAN_COL_BITS_NULL (uint8)0x00 // NULL in Cantian Storage #define CANTIAN_COL_BITS_4 (uint8)0x01 // 4 Bytes in Cantian Storage #define CANTIAN_COL_BITS_8 (uint8)0x02 // 8 Bytes in Cantian Storage #define CANTIAN_COL_BITS_VAR (uint8)0x03 // Variable Bytes in Cantian Storage -#define TSE_LOB_LOCATOR_BUF_SIZE (uint32)4012 -#define TSE_LOB_MAX_INLINE_SIZE (TSE_LOB_LOCATOR_BUF_SIZE - offsetof(lob_locator_t, data)) +#define CTC_LOB_LOCATOR_BUF_SIZE (uint32)4012 +#define CTC_LOB_MAX_INLINE_SIZE (CTC_LOB_LOCATOR_BUF_SIZE - offsetof(lob_locator_t, data)) #define ALIGN_UP(x, align) ((x) / (align) + ((x) % (align) ? 1 : 0)) #define ROUND_UP(x, align) ((x) / (align) + ((x) % (align) ? 1 : 0)) * (align) #define MICROSECS_PER_MILLISEC 1000U @@ -61,8 +61,8 @@ typedef int64 date_t; #define LOB_DATA_SIZE_8M (1024 * 1024 * 8) /* LOB_DATA_BUFFER_SIZE must bigger than 4000,Otherwise, incorrect data may be written to the row. */ #define LOB_DATA_BUFFER_SIZE_8K (1024 * 8) -#define TSE_DDL_MAX_VARCHAR_COLUMN_SIZE 8000 -#define VARCHAR_AS_BLOB(len) ((len) > TSE_DDL_MAX_VARCHAR_COLUMN_SIZE) +#define CTC_DDL_MAX_VARCHAR_COLUMN_SIZE 8000 +#define VARCHAR_AS_BLOB(len) ((len) > CTC_DDL_MAX_VARCHAR_COLUMN_SIZE) #define CM_ALL_ZERO_DATETIME ((date_t)-63113904000000000LL) /* == cm_encode_date(00-00-00 00:00:00.000000) */ longlong bit_cnvt_mysql_cantian(const uchar *ptr, Field *mysql_field); @@ -171,7 +171,7 @@ typedef struct st_mysql_to_cantian_field_convert { enum_field_types mysql_field_type; uint8_t cantian_map_type; enum_sql_data_types sql_data_type; - enum_tse_ddl_field_types ddl_field_type; + enum_ctc_ddl_field_types ddl_field_type; } field_cnvrt_aux_t; typedef struct { @@ -213,16 +213,16 @@ static std::unordered_map g_blob_field_buffer_size_map = }; typedef void (*cnvrt_to_mysql_fn)(const TABLE &table, index_info_t *index, record_buf_info_t *record_buf, - tianchi_handler_t &tch, record_info_t *record_info); + ctc_handler_t &tch, record_info_t *record_info); void cantian_record_to_mysql_record(const TABLE &table, index_info_t *index, record_buf_info_t *record_buf, - tianchi_handler_t &tch, record_info_t *record_info); + ctc_handler_t &tch, record_info_t *record_info); int mysql_record_to_cantian_record(const TABLE &table, record_buf_info_t *record_buf, - tianchi_handler_t &tch, uint16_t *serial_column_offset, + ctc_handler_t &tch, uint16_t *serial_column_offset, std::vector *fields=nullptr); void cal_gcol_cnts_for_update(Field **field, uint column_id, uint32_t *virtual_gcol_cnt); void cantian_index_record_to_mysql_record(const TABLE &table, index_info_t *index, record_buf_info_t *record_buf, - tianchi_handler_t &tch, record_info_t *record_info); + ctc_handler_t &tch, record_info_t *record_info); int isolation_level_to_cantian( enum_tx_isolation isolation_level); @@ -243,7 +243,7 @@ int convert_numeric_to_cantian(const field_cnvrt_aux_t *mysql_info, const uchar void cm_encode_date(const date_detail_t *detail, date_t *date); int assign_mysql_date_detail(enum_field_types mysql_field_type, MYSQL_TIME ltime, date_detail_t *date_detail); -bool tse_datetime_with_no_zero_in_date_to_timeval(const MYSQL_TIME *ltime, const Time_zone &tz, +bool ctc_datetime_with_no_zero_in_date_to_timeval(const MYSQL_TIME *ltime, const Time_zone &tz, struct timeval *tm, int *warnings); bool check_zero_date(const date_detail_t& datetime); bool check_zero_time_ltime(const MYSQL_TIME ltime); diff --git a/storage/tianchi/decimal_convert.cc b/storage/ctc/decimal_convert.cc similarity index 99% rename from storage/tianchi/decimal_convert.cc rename to storage/ctc/decimal_convert.cc index 7da8a6c..4c818ef 100644 --- a/storage/tianchi/decimal_convert.cc +++ b/storage/ctc/decimal_convert.cc @@ -17,7 +17,7 @@ #include "decimal_convert.h" #include #include "stdlib.h" -#include "tse_log.h" +#include "ctc_log.h" // half of g_1ten_powers, used for rounding a decimal const uint32 ct_5ten_powers[10] = { 0u, // 0 @@ -62,12 +62,12 @@ status_t ct_cm_text_to_dec8(const text_t *dec_text, dec8_t *dec) { np.excl_flag = NF_NONE; err_no = ct_cm_split_num_text(dec_text, &np); if (err_no != NERR_SUCCESS) { - tse_log_error("Decimal data type convert text to dec8 failed!"); + ctc_log_error("Decimal data type convert text to dec8 failed!"); return CT_ERROR; } err_no = ct_cm_numpart_to_dec8(&np, dec); if (err_no != NERR_SUCCESS) { - tse_log_error("Decimal data type convert numpart to dec8 failed!"); + ctc_log_error("Decimal data type convert numpart to dec8 failed!"); return CT_ERROR; } return CT_SUCCESS_STATUS; diff --git a/storage/tianchi/decimal_convert.h b/storage/ctc/decimal_convert.h similarity index 100% rename from storage/tianchi/decimal_convert.h rename to storage/ctc/decimal_convert.h diff --git a/storage/tianchi/ha_tse.cc b/storage/ctc/ha_ctc.cc similarity index 77% rename from storage/tianchi/ha_tse.cc rename to storage/ctc/ha_ctc.cc index a2ae613..1e14959 100644 --- a/storage/tianchi/ha_tse.cc +++ b/storage/ctc/ha_ctc.cc @@ -15,55 +15,55 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -// @file storage/tianchi/ha_tse.cc -// description: TIANCHI handler implementation for MySQL storage engine API. -// this module should use tse_srv rather than knl_intf +// @file storage/ctc/ha_ctc.cc +// description: CTC handler implementation for MySQL storage engine API. +// this module should use ctc_srv rather than knl_intf /** - @file ha_tse.cc + @file ha_ctc.cc @details - The tse storage engine is set up to use table locks. It - implements an tse "SHARE" that is inserted into a hash by table + The ctc storage engine is set up to use table locks. It + implements an ctc "SHARE" that is inserted into a hash by table name. You can use this to store information of state that any - tse handler object will be able to see when it is using that + ctc handler object will be able to see when it is using that table. - Please read the object definition in ha_tse.h before reading the rest + Please read the object definition in ha_ctc.h before reading the rest of this file. @note - When you create an TSE table, the MySQL Server creates a table .frm + When you create an CTC table, the MySQL Server creates a table .frm (format) file in the database directory, using the table name as the file name as is customary with MySQL. No other files are created. To get an idea - of what occurs, here is an tse select that would do a scan of an entire + of what occurs, here is an ctc select that would do a scan of an entire table: @code - ha_tse::store_lock - ha_tse::external_lock - ha_tse::info - ha_tse::rnd_init - ha_tse::extra - ha_tse::rnd_next - ha_tse::rnd_next - ha_tse::rnd_next - ha_tse::rnd_next - ha_tse::rnd_next - ha_tse::rnd_next - ha_tse::rnd_next - ha_tse::rnd_next - ha_tse::rnd_next - ha_tse::extra - ha_tse::external_lock - ha_tse::extra + ha_ctc::store_lock + ha_ctc::external_lock + ha_ctc::info + ha_ctc::rnd_init + ha_ctc::extra + ha_ctc::rnd_next + ha_ctc::rnd_next + ha_ctc::rnd_next + ha_ctc::rnd_next + ha_ctc::rnd_next + ha_ctc::rnd_next + ha_ctc::rnd_next + ha_ctc::rnd_next + ha_ctc::rnd_next + ha_ctc::extra + ha_ctc::external_lock + ha_ctc::extra ENUM HA_EXTRA_RESET Reset database to after open @endcode - Here you see that the tse storage engine has 9 rows called before + Here you see that the ctc storage engine has 9 rows called before rnd_next signals that it has reached the end of its data. Also note that the table in question was already opened; had it not been open, a call to - ha_tse::open() would also have been necessary. Calls to - ha_tse::extra() are hints as to what will be occurring to the request. + ha_ctc::open() would also have been necessary. Calls to + ha_ctc::extra() are hints as to what will be occurring to the request. A Longer Dse can be found called the "Skeleton Engine" which can be found on TangentOrg. It has both an engine and a full build environment @@ -73,9 +73,9 @@ -Brian */ -#include "ha_tse.h" -#include "ha_tse_ddl.h" -#include "ha_tsepart.h" +#include "ha_ctc.h" +#include "ha_ctc_ddl.h" +#include "ha_ctcpart.h" #include #include @@ -107,11 +107,11 @@ #include "sql/dd/properties.h" #include "sql/dd/types/partition.h" -#include "tse_stats.h" -#include "tse_error.h" -#include "tse_log.h" -#include "tse_srv_mq_module.h" -#include "tse_util.h" +#include "ctc_stats.h" +#include "ctc_error.h" +#include "ctc_log.h" +#include "ctc_srv_mq_module.h" +#include "ctc_util.h" #include "protobuf/tc_db.pb-c.h" #include "typelib.h" #include "datatype_cnvrt_4_index_search.h" @@ -151,26 +151,26 @@ static void ctc_statistics_enabled_update(THD *, SYS_VAR *, void *var_ptr, const /* 创库的表空间datafile自动扩展, 默认开 */ bool ctc_db_datafile_autoextend = true; static MYSQL_SYSVAR_BOOL(db_datafile_autoextend, ctc_db_datafile_autoextend, PLUGIN_VAR_NOCMDARG, - "Indicates whether to automatically extend the tablespace data files of the TSE database.", nullptr, nullptr, true); + "Indicates whether to automatically extend the tablespace data files of the CTC database.", nullptr, nullptr, true); /* 创库的表空间datafile大小, 单位M, 默认32M, 最小1M, 最大8T */ uint32_t ctc_db_datafile_size = 32; static MYSQL_SYSVAR_UINT(db_datafile_size, ctc_db_datafile_size, PLUGIN_VAR_RQCMDARG, - "Size of the tablespace data file of the TSE database, in MB.", nullptr, nullptr, 32, 1, 8192 * 1024, 0); + "Size of the tablespace data file of the CTC database, in MB.", nullptr, nullptr, 32, 1, 8192 * 1024, 0); /* 创库的表空间datafile自动扩展大小, 单位M, 默认128M, 最小1M, 最大8T */ uint32_t ctc_db_datafile_extend_size = 128; static MYSQL_SYSVAR_UINT(db_datafile_extend_size, ctc_db_datafile_extend_size, PLUGIN_VAR_RQCMDARG, - "Size of the TSE database tablespace data file automatically extended, in MB.", nullptr, nullptr, 128, 1, 8192 * 1024, 0); + "Size of the CTC database tablespace data file automatically extended, in MB.", nullptr, nullptr, 128, 1, 8192 * 1024, 0); bool ctc_concurrent_ddl = true; static MYSQL_SYSVAR_BOOL(concurrent_ddl, ctc_concurrent_ddl, PLUGIN_VAR_RQCMDARG, "Indicates whether to ban concurrent DDL.", nullptr, nullptr, true); -static mutex m_tse_metadata_normalization_mutex; +static mutex m_ctc_metadata_normalization_mutex; int32_t ctc_metadata_normalization = (int32_t)metadata_switchs::DEFAULT; static MYSQL_SYSVAR_INT(metadata_normalization, ctc_metadata_normalization, PLUGIN_VAR_READONLY, "Option for Mysql-Cantian metadata normalization.", nullptr, nullptr, -1, -1, 3, 0); -static mutex m_tse_cluster_role_mutex; +static mutex m_ctc_cluster_role_mutex; int32_t ctc_cluster_role = (int32_t)dis_cluster_role::DEFAULT; static MYSQL_SYSVAR_INT(cluster_role, ctc_cluster_role, PLUGIN_VAR_READONLY, "flag for Disaster Recovery Cluster Role.", nullptr, nullptr, -1, -1, 2, 0); @@ -182,7 +182,7 @@ static MYSQL_SYSVAR_INT(max_cursors_no_autocommit, ctc_max_cursors_no_autocommit "Size of max cursors for no autocommit in commit/rollback.", nullptr, nullptr, 128, 0, 8192, 0); static MYSQL_THDVAR_UINT(lock_wait_timeout, PLUGIN_VAR_RQCMDARG, - "Timeout in seconds an TSE transaction may wait " + "Timeout in seconds an CTC transaction may wait " "for a lock before being rolled back. Unit is " "millisecond and values 0 means disable the timeout.", nullptr, nullptr, 50000, 0, 1024 * 1024 * 1024, 0); @@ -201,9 +201,9 @@ static void ctc_gather_change_stats_update(THD *, SYS_VAR *, void *var_ptr, cons update_job_info info = { "GATHER_CHANGE_STATS", 19, "SYS", 3, 0 }; bool val = *static_cast(var_ptr) = *static_cast(save); info.switch_on = val; - ret = (ct_errno_t)tse_update_job(info); + ret = (ct_errno_t)ctc_update_job(info); if (ret != CT_SUCCESS) { - tse_log_error("Error update cantian job info: %d", ret); + ctc_log_error("Error update cantian job info: %d", ret); } } @@ -242,7 +242,7 @@ static MYSQL_SYSVAR_BOOL(select_prefetch, ctc_select_prefetch, PLUGIN_VAR_RQCMDA // All global and session system variables must be published to mysqld before // use. This is done by constructing a NULL-terminated array of the variables // and linking to it in the plugin public interface. -static SYS_VAR *tse_system_variables[] = { +static SYS_VAR *ctc_system_variables[] = { MYSQL_SYSVAR(lock_wait_timeout), MYSQL_SYSVAR(instance_id), MYSQL_SYSVAR(sampling_ratio), @@ -316,21 +316,21 @@ static const Alter_inplace_info::HA_ALTER_FLAGS COLUMN_TYPE_OPERATIONS = constexpr int max_prefetch_num = MAX_PREFETCH_REC_NUM; // ref MAX_RECORD_BUFFER_SIZE, used for private record buffer assigned for each handler -constexpr int MAX_RECORD_BUFFER_SIZE_TSE = (1 * TSE_BUF_LEN); +constexpr int MAX_RECORD_BUFFER_SIZE_CTC = (1 * CTC_BUF_LEN); constexpr uint64 INVALID_VALUE64 = 0xFFFFFFFFFFFFFFFFULL; bool is_log_table = false; #define ARRAY_SIZE_TWO 2 -static int tse_rollback_savepoint(handlerton *hton, THD *thd, void *savepoint); -handlerton *tse_hton; +static int ctc_rollback_savepoint(handlerton *hton, THD *thd, void *savepoint); +handlerton *ctc_hton; -int ha_tse_get_inst_id() { return ctc_instance_id; } +int ha_ctc_get_inst_id() { return ctc_instance_id; } -void ha_tse_set_inst_id(uint32_t inst_id) { ctc_instance_id = inst_id; } +void ha_ctc_set_inst_id(uint32_t inst_id) { ctc_instance_id = inst_id; } -handlerton *get_tse_hton() { return tse_hton; } +handlerton *get_ctc_hton() { return ctc_hton; } /* * Check whether it is CREATE TABLE ... SELECT @@ -344,13 +344,13 @@ bool user_var_set(MYSQL_THD thd, string target_str) { user_var_entry *var_entry; var_entry = find_or_nullptr(thd->user_vars, target_str); if (var_entry != nullptr && var_entry->ptr() != nullptr) { - tse_log_debug("thd (%d) has user variable %s", thd->thread_id(), target_str.data()); + ctc_log_debug("thd (%d) has user variable %s", thd->thread_id(), target_str.data()); return true; } return false; } -dml_flag_t tse_get_dml_flag(THD *thd, bool is_replace, bool auto_inc_used, +dml_flag_t ctc_get_dml_flag(THD *thd, bool is_replace, bool auto_inc_used, bool has_explicit_autoinc, bool dup_update) { dml_flag_t flag; flag.ignore = thd->lex->is_ignore(); @@ -383,7 +383,7 @@ bool is_work_flow() { } bool is_ctc_mdl_thd(THD* thd) { - if (thd->query().str && string(thd->query().str) == "tse_mdl_thd_notify") { + if (thd->query().str && string(thd->query().str) == "ctc_mdl_thd_notify") { return true; } return false; @@ -430,10 +430,10 @@ bool engine_ddl_passthru(MYSQL_THD thd) { return is_initialize() || !mysqld_server_started || is_mysql_local; } -bool ha_tse::is_replay_ddl(MYSQL_THD thd) { +bool ha_ctc::is_replay_ddl(MYSQL_THD thd) { char db_name[SMALL_RECORD_SIZE] = { 0 }; - tse_split_normalized_name(table->s->normalized_path.str, db_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); - tse_copy_name(db_name, db_name, SMALL_RECORD_SIZE); + ctc_split_normalized_name(table->s->normalized_path.str, db_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); + ctc_copy_name(db_name, db_name, SMALL_RECORD_SIZE); if (mysql_system_db.find(db_name) != mysql_system_db.end()) { return false; } @@ -445,47 +445,47 @@ bool ha_tse::is_replay_ddl(MYSQL_THD thd) { return false; } -static int tse_reg_instance() { +static int ctc_reg_instance() { uint32_t inst_id = MYSQL_PROC_START; uint32_t count = 0; ct_errno_t ret = CT_SUCCESS; - while (count++ < TSE_START_TIMEOUT) { - ret = (ct_errno_t)tse_alloc_inst_id(&inst_id); + while (count++ < CTC_START_TIMEOUT) { + ret = (ct_errno_t)ctc_alloc_inst_id(&inst_id); if (ret == CT_SUCCESS) { - ha_tse_set_inst_id(inst_id); - tse_log_system("[TSE_INIT]:tse reg instance success, inst_id:%u", - ha_tse_get_inst_id()); + ha_ctc_set_inst_id(inst_id); + ctc_log_system("[CTC_INIT]:ctc reg instance success, inst_id:%u", + ha_ctc_get_inst_id()); break; } - tse_log_system("[TSE_INIT]:tse reg instance failed and sleep %u/%u", count, - TSE_START_TIMEOUT); + ctc_log_system("[CTC_INIT]:ctc reg instance failed and sleep %u/%u", count, + CTC_START_TIMEOUT); sleep(1); } - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } -static void tse_unreg_instance() { +static void ctc_unreg_instance() { // 元数据归一流程初始化阶段下发参天, 主干不下发 if (opt_initialize_insecure && !CHECK_HAS_MEMBER(handlerton, get_inst_id)) { return; } uint32_t inst_id; - inst_id = ha_tse_get_inst_id(); - ct_errno_t ret = (ct_errno_t)tse_release_inst_id(inst_id); + inst_id = ha_ctc_get_inst_id(); + ct_errno_t ret = (ct_errno_t)ctc_release_inst_id(inst_id); if (ret != CT_SUCCESS) { - tse_log_error("tse release instance id:%u failed, ret:%d", - ha_tse_get_inst_id(), ret); + ctc_log_error("ctc release instance id:%u failed, ret:%d", + ha_ctc_get_inst_id(), ret); } else { - tse_log_system("tse release instance id:%u success", ha_tse_get_inst_id()); + ctc_log_system("ctc release instance id:%u success", ha_ctc_get_inst_id()); } } /* * Check if the ALTER TABLE operations need table copy * reference: is_inplace_alter_impossible() -* Alter_info::ALTER_TABLE_ALGORITHM_COPY tag set at ha_tse::create or spcified by ALGORITHMY = COPY +* Alter_info::ALTER_TABLE_ALGORITHM_COPY tag set at ha_ctc::create or spcified by ALGORITHMY = COPY */ bool is_alter_table_copy(MYSQL_THD thd, const char *name) { if (!thd->lex->alter_info) { @@ -792,7 +792,7 @@ void cond_push_boolean_term(Item *term, Item *&pushed_cond, Item *&remainder_con } } -void ha_tse::prep_cond_push(const Item *cond) { +void ha_ctc::prep_cond_push(const Item *cond) { Item *item = const_cast(cond); Item *pushed_cond = nullptr; Item *remainder = nullptr; @@ -802,7 +802,7 @@ void ha_tse::prep_cond_push(const Item *cond) { } // 返回值检测设置 -void ha_tse::check_error_code_to_mysql(THD *thd, ct_errno_t *ret) { +void ha_ctc::check_error_code_to_mysql(THD *thd, ct_errno_t *ret) { bool no_foreign_key_check = thd->variables.option_bits & OPTION_NO_FOREIGN_KEY_CHECKS; //判断ret是否返回死锁，死锁则回滚 if (*ret == ERR_DEAD_LOCK) { @@ -815,12 +815,12 @@ void ha_tse::check_error_code_to_mysql(THD *thd, ct_errno_t *ret) { static set g_ctc_ignore_foreign_key_check_ret_value = { ERR_CONSTRAINT_VIOLATED_NO_FOUND, ERR_ROW_IS_REFERENCED}; if (g_ctc_ignore_foreign_key_check_ret_value.count(*ret) > 0) { - tse_log_system("ctc_ignore_foreign_key_check catching."); + ctc_log_system("ctc_ignore_foreign_key_check catching."); *ret = CT_SUCCESS; } } -bool ha_tse::check_unsupported_operation(THD *thd, HA_CREATE_INFO *create_info) { +bool ha_ctc::check_unsupported_operation(THD *thd, HA_CREATE_INFO *create_info) { // 不支持的操作 if (thd->lex->alter_info && (thd->lex->alter_info->flags & Alter_info::ALTER_EXCHANGE_PARTITION)) { @@ -914,7 +914,7 @@ static void dd_set_autoinc(dd::Properties &se_private_data, uint64 autoinc) { se_private_data.set(dd_table_key_strings[DD_TABLE_AUTOINC], autoinc); } -bool ha_tse::get_se_private_data(dd::Table *dd_table, bool reset) { +bool ha_ctc::get_se_private_data(dd::Table *dd_table, bool reset) { static uint n_tables = 1024; static uint n_indexes = 0; static uint n_pages = 4; @@ -958,9 +958,9 @@ bool ha_tse::get_se_private_data(dd::Table *dd_table, bool reset) { return false; } -static handler *tse_create_handler(handlerton *hton, TABLE_SHARE *table, bool partitioned, MEM_ROOT *mem_root) { +static handler *ctc_create_handler(handlerton *hton, TABLE_SHARE *table, bool partitioned, MEM_ROOT *mem_root) { if (partitioned) { - ha_tsepart *file = new (mem_root) ha_tsepart(hton, table); + ha_ctcpart *file = new (mem_root) ha_ctcpart(hton, table); if (file && (file->initialize() || file->init_partitioning(mem_root))) { delete file; return nullptr; @@ -969,7 +969,7 @@ static handler *tse_create_handler(handlerton *hton, TABLE_SHARE *table, bool pa return file; } - ha_tse *file = new (mem_root) ha_tse(hton, table); + ha_ctc *file = new (mem_root) ha_ctc(hton, table); if (file && file->initialize()) { delete file; return nullptr; @@ -978,7 +978,7 @@ static handler *tse_create_handler(handlerton *hton, TABLE_SHARE *table, bool pa return file; } -static bool tse_check_if_log_table(const char* db_name, const char* table_name) { +static bool ctc_check_if_log_table(const char* db_name, const char* table_name) { LEX_CSTRING cstr_db_name = {db_name, strlen(db_name)}; LEX_CSTRING cstr_table_name = {table_name, strlen(table_name)}; if (cstr_db_name.length == MYSQL_SCHEMA_NAME.length && !my_strcasecmp(system_charset_info, cstr_db_name.str, MYSQL_SCHEMA_NAME.str)) { @@ -1003,7 +1003,7 @@ static bool tse_check_if_log_table(const char* db_name, const char* table_name) @retval true Given db.table_name is supported system table. @retval false Given db.table_name is not a supported system table. */ -static bool tse_is_supported_system_table(const char *db MY_ATTRIBUTE((unused)), +static bool ctc_is_supported_system_table(const char *db MY_ATTRIBUTE((unused)), const char *table_name MY_ATTRIBUTE((unused)), bool is_sql_layer_system_table MY_ATTRIBUTE((unused))) { @@ -1021,11 +1021,11 @@ static bool tse_is_supported_system_table(const char *db MY_ATTRIBUTE((unused)), @return precise type, including the charset-collation code. */ -uint tse_dtype_form_prtype(uint old_prtype, uint charset_coll) { +uint ctc_dtype_form_prtype(uint old_prtype, uint charset_coll) { return (old_prtype + (charset_coll << 16)); } -uint get_tse_type_from_mysql_dd_type(uint *unsigned_flag, uint *binary_type, uint *charset_no, +uint get_ctc_type_from_mysql_dd_type(uint *unsigned_flag, uint *binary_type, uint *charset_no, dd::enum_column_types dd_type, const CHARSET_INFO *field_charset, bool is_unsigned) { @@ -1141,7 +1141,7 @@ uint get_tse_type_from_mysql_dd_type(uint *unsigned_flag, uint *binary_type, uin return (0); } -void tse_dict_mem_fill_column_struct(dict_col *column, uint mtype, uint prtype, uint col_len) { +void ctc_dict_mem_fill_column_struct(dict_col *column, uint mtype, uint prtype, uint col_len) { column->mtype = (unsigned int)mtype; column->prtype = (unsigned int)prtype; column->len = (unsigned int)col_len; @@ -1154,30 +1154,30 @@ compatibility check from column description in Ha_fk_column_type form. @param[out] col dict_col filled by this function @param[in] fk_col_type foreign key type information */ -static void tse_fill_fake_column_struct( +static void ctc_fill_fake_column_struct( dict_col *col, const Ha_fk_column_type *fk_col_type) { uint unsigned_type; uint binary_type; uint charset_no; - uint mtype = get_tse_type_from_mysql_dd_type(&unsigned_type, &binary_type, &charset_no, fk_col_type->type, + uint mtype = get_ctc_type_from_mysql_dd_type(&unsigned_type, &binary_type, &charset_no, fk_col_type->type, fk_col_type->field_charset, fk_col_type->is_unsigned); - uint fake_prtype = tse_dtype_form_prtype(unsigned_type | binary_type, charset_no); + uint fake_prtype = ctc_dtype_form_prtype(unsigned_type | binary_type, charset_no); /* Fake prtype only contains info which is relevant for foreign key - type compatibility check, especially the info used in tse_cmp_cols_are_equal. */ + type compatibility check, especially the info used in ctc_cmp_cols_are_equal. */ uint col_len = calc_pack_length(fk_col_type->type, fk_col_type->char_length, fk_col_type->elements_count, true, fk_col_type->numeric_scale, fk_col_type->is_unsigned); memset(col, 0, sizeof(dict_col)); - tse_dict_mem_fill_column_struct(col, mtype, fake_prtype, col_len); + ctc_dict_mem_fill_column_struct(col, mtype, fake_prtype, col_len); } /** Checks if a data main type is a string type. Also a BLOB is considered a string type. @return true if string type */ -bool tse_dtype_is_string_type(uint mtype) { +bool ctc_dtype_is_string_type(uint mtype) { if (mtype <= DATA_BLOB || mtype == DATA_MYSQL || mtype == DATA_VARMYSQL) { return (true); } @@ -1192,7 +1192,7 @@ bool tse_dtype_is_string_type(uint mtype) { @param prtype precise type @return true if binary string type */ -bool tse_dtype_is_binary_string_type(uint mtype, uint prtype) { +bool ctc_dtype_is_binary_string_type(uint mtype, uint prtype) { if ((mtype == DATA_FIXBINARY) || (mtype == DATA_BINARY) || (mtype == DATA_BLOB && (prtype & DATA_BINARY_TYPE))) { return (true); @@ -1209,9 +1209,9 @@ bool tse_dtype_is_binary_string_type(uint mtype, uint prtype) { @param prtype precise type @return true if non-binary string type */ -bool tse_dtype_is_non_binary_string_type(uint mtype, uint prtype) { - if (tse_dtype_is_string_type(mtype) == true && - tse_dtype_is_binary_string_type(mtype, prtype) == false) { +bool ctc_dtype_is_non_binary_string_type(uint mtype, uint prtype) { + if (ctc_dtype_is_string_type(mtype) == true && + ctc_dtype_is_binary_string_type(mtype, prtype) == false) { return (true); } @@ -1220,27 +1220,27 @@ bool tse_dtype_is_non_binary_string_type(uint mtype, uint prtype) { /** Gets the MySQL charset-collation code for MySQL string types. @return MySQL charset-collation code */ -static inline uint tse_dtype_get_charset_coll(uint prtype) { +static inline uint ctc_dtype_get_charset_coll(uint prtype) { return ((prtype >> 16) & CHAR_COLL_MASK); } -bool tse_cmp_cols_are_equal(const dict_col *col1, const dict_col *col2, +bool ctc_cmp_cols_are_equal(const dict_col *col1, const dict_col *col2, bool check_charsets) { - if (tse_dtype_is_non_binary_string_type(col1->mtype, col1->prtype) && - tse_dtype_is_non_binary_string_type(col2->mtype, col2->prtype)) { + if (ctc_dtype_is_non_binary_string_type(col1->mtype, col1->prtype) && + ctc_dtype_is_non_binary_string_type(col2->mtype, col2->prtype)) { /* Both are non-binary string types: they can be compared if and only if the charset-collation is the same */ if (check_charsets) { - return (tse_dtype_get_charset_coll(col1->prtype) == - tse_dtype_get_charset_coll(col2->prtype)); + return (ctc_dtype_get_charset_coll(col1->prtype) == + ctc_dtype_get_charset_coll(col2->prtype)); } else { return (true); } } - if (tse_dtype_is_binary_string_type(col1->mtype, col1->prtype) && - tse_dtype_is_binary_string_type(col2->mtype, col2->prtype)) { + if (ctc_dtype_is_binary_string_type(col1->mtype, col1->prtype) && + ctc_dtype_is_binary_string_type(col2->mtype, col2->prtype)) { /* Both are binary string types: they can be compared */ return (true); } @@ -1265,14 +1265,14 @@ bool tse_cmp_cols_are_equal(const dict_col *col1, const dict_col *col2, match. Which is true in most cases. @return True if types are compatible, False if not. */ -static bool tse_check_fk_column_compat(const Ha_fk_column_type *child_column_type, +static bool ctc_check_fk_column_compat(const Ha_fk_column_type *child_column_type, const Ha_fk_column_type *parent_column_type, bool check_charsets) { dict_col dict_child_col, dict_parent_col; - tse_fill_fake_column_struct(&dict_child_col, child_column_type); - tse_fill_fake_column_struct(&dict_parent_col, parent_column_type); + ctc_fill_fake_column_struct(&dict_child_col, child_column_type); + ctc_fill_fake_column_struct(&dict_parent_col, parent_column_type); - return (tse_cmp_cols_are_equal(&dict_child_col, &dict_parent_col, check_charsets)); + return (ctc_cmp_cols_are_equal(&dict_child_col, &dict_parent_col, check_charsets)); } /* @@ -1286,14 +1286,14 @@ thd_sess_ctx_s *get_or_init_sess_ctx(handlerton *hton, THD *thd) { sess_ctx = (thd_sess_ctx_s *)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(thd_sess_ctx_s), MYF(MY_WME)); if (sess_ctx == nullptr) { - tse_log_error("my_malloc error for sess_ctx"); + ctc_log_error("my_malloc error for sess_ctx"); return nullptr; } memset(sess_ctx, 0xFF, sizeof(thd_sess_ctx_s)); - sess_ctx->is_tse_trx_begin = 0; + sess_ctx->is_ctc_trx_begin = 0; sess_ctx->sql_stat_start = 0; - sess_ctx->cursors_map = new unordered_map; + sess_ctx->cursors_map = new unordered_map; sess_ctx->invalid_cursors = nullptr; assert(sess_ctx->cursors_map->size() == 0); sess_ctx->msg_buf = nullptr; @@ -1303,11 +1303,11 @@ thd_sess_ctx_s *get_or_init_sess_ctx(handlerton *hton, THD *thd) { } /* - Called by handlerton functions to get a new tianchi handler. - This tianchi handler will be only use for one time and initialized with session context. + Called by handlerton functions to get a new ctc handler. + This ctc handler will be only use for one time and initialized with session context. Handlerton functions need it since they don't have m_tch member. */ -int get_tch_in_handler_data(handlerton *hton, THD *thd, tianchi_handler_t &tch, bool alloc_msg_buf MY_ATTRIBUTE((unused))) { +int get_tch_in_handler_data(handlerton *hton, THD *thd, ctc_handler_t &tch, bool alloc_msg_buf MY_ATTRIBUTE((unused))) { memset(&tch, 0, sizeof(tch)); thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(hton, thd); if (sess_ctx == nullptr) { @@ -1318,7 +1318,7 @@ int get_tch_in_handler_data(handlerton *hton, THD *thd, tianchi_handler_t &tch, sess_ctx->sess_addr = INVALID_VALUE64; sess_ctx->thd_id = thd->thread_id(); sess_ctx->bind_core = 0; - sess_ctx->is_tse_trx_begin = 0; + sess_ctx->is_ctc_trx_begin = 0; sess_ctx->sql_stat_start = 0; } @@ -1353,7 +1353,7 @@ static void ctc_copy_cursors_to_free(thd_sess_ctx_s *sess_ctx, uint64_t *cursors idx = invalid_csize; } if (left == 0) { - unordered_map::iterator it; + unordered_map::iterator it; for (it = sess_ctx->cursors_map->begin(); it != sess_ctx->cursors_map->end(); it++) { cursors[idx++] = it->second; } @@ -1361,14 +1361,14 @@ static void ctc_copy_cursors_to_free(thd_sess_ctx_s *sess_ctx, uint64_t *cursors } } -void update_sess_ctx_cursor_by_tch(tianchi_handler_t &tch, handlerton *hton, THD *thd) { +void update_sess_ctx_cursor_by_tch(ctc_handler_t &tch, handlerton *hton, THD *thd) { if (tch.cursor_addr == INVALID_VALUE64) { return; } thd_sess_ctx_s *sess_ctx = (thd_sess_ctx_s *)thd_get_ha_data(thd, hton); assert(sess_ctx != nullptr); - unordered_map::iterator it; + unordered_map::iterator it; it = sess_ctx->cursors_map->find(&tch); if (it != sess_ctx->cursors_map->end()) { uint64_t current_cursor = it->second; @@ -1388,16 +1388,16 @@ void update_sess_ctx_cursor_by_tch(tianchi_handler_t &tch, handlerton *hton, THD int32_t total_csize = sess_ctx->cursors_map->size() + sess_ctx->invalid_cursors->size(); if (total_csize >= SESSION_CURSOR_NUM) { uint32_t free_csize = sess_ctx->invalid_cursors->size(); - uint64_t *cursors = (uint64_t *)tse_alloc_buf(&tch, sizeof(uint64_t) * free_csize); + uint64_t *cursors = (uint64_t *)ctc_alloc_buf(&tch, sizeof(uint64_t) * free_csize); if ((total_csize != 0) && (cursors == nullptr)) { - tse_log_error("tse_alloc_buf for cursors in update_sess_ctx_cursor_by_tch failed"); + ctc_log_error("ctc_alloc_buf for cursors in update_sess_ctx_cursor_by_tch failed"); } assert((total_csize == 0) ^ (cursors != nullptr)); ctc_copy_cursors_to_free(sess_ctx, cursors, 1); assert(sess_ctx->invalid_cursors->empty()); - tse_log_system("[FREE CURSORS] free %d cursors in advance.", free_csize); - tse_free_session_cursors(&tch, cursors, free_csize); - tse_free_buf(&tch, (uint8_t *)cursors); + ctc_log_system("[FREE CURSORS] free %d cursors in advance.", free_csize); + ctc_free_session_cursors(&tch, cursors, free_csize); + ctc_free_buf(&tch, (uint8_t *)cursors); } } @@ -1405,10 +1405,10 @@ void update_sess_ctx_cursor_by_tch(tianchi_handler_t &tch, handlerton *hton, THD Since session address and sql_stat_start may be changed in tch after processing in cantian, call this method if session address or sql_stat_start may be updated in tch. */ -void update_sess_ctx_by_tch(tianchi_handler_t &tch, handlerton *hton, THD *thd) { +void update_sess_ctx_by_tch(ctc_handler_t &tch, handlerton *hton, THD *thd) { thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(hton, thd); if (sess_ctx == nullptr) { - tse_log_error("update_sess_ctx_by_tch failed, thd_sess_ctx_s my_malloc error!"); + ctc_log_error("update_sess_ctx_by_tch failed, thd_sess_ctx_s my_malloc error!"); return; } @@ -1420,10 +1420,10 @@ void update_sess_ctx_by_tch(tianchi_handler_t &tch, handlerton *hton, THD *thd) /* 1. Make sure that session address is invalid everytime thd's been updated. - 2. Call this method if the following tse interface may be the + 2. Call this method if the following ctc interface may be the first call of a dml sql (may use sql_stat_start). */ -void update_member_tch(tianchi_handler_t &tch, handlerton *hton, THD *thd, bool alloc_msg_buf MY_ATTRIBUTE((unused))) { +void update_member_tch(ctc_handler_t &tch, handlerton *hton, THD *thd, bool alloc_msg_buf MY_ATTRIBUTE((unused))) { thd_sess_ctx_s *sess_ctx = (thd_sess_ctx_s *)thd_get_ha_data(thd, hton); if (sess_ctx == nullptr || sess_ctx->thd_id != thd->thread_id()) { tch.thd_id = thd->thread_id(); @@ -1485,13 +1485,13 @@ void release_sess_ctx(thd_sess_ctx_s *sess_ctx, handlerton *hton, THD *thd) { thd_set_ha_data(thd, hton, nullptr); } -/** Creates an TSE transaction struct for the thd if it does not yet have - one. Starts a new TSE transaction if a transaction is not yet started. And +/** Creates an CTC transaction struct for the thd if it does not yet have + one. Starts a new CTC transaction if a transaction is not yet started. And assigns a new snapshot for a consistent read if the transaction does not yet have one. @return 0 */ -static int tse_start_trx_and_assign_scn( - handlerton *hton, /*!< in: TSE handlerton */ +static int ctc_start_trx_and_assign_scn( + handlerton *hton, /*!< in: CTC handlerton */ THD *thd) /*!< in: MySQL thread handle of the user for whom the transaction should be committed */ { @@ -1514,12 +1514,12 @@ static int tse_start_trx_and_assign_scn( return 0; } - tianchi_handler_t tch; - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); - thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(tse_hton, thd); + ctc_handler_t tch; + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); + thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(ctc_hton, thd); // get_tch_in_handler_data若成功返回，则sess_ctx肯定不为空 assert(sess_ctx != nullptr); - assert(sess_ctx->is_tse_trx_begin == 0); + assert(sess_ctx->is_ctc_trx_begin == 0); if (sess_ctx == nullptr) { return HA_ERR_OUT_OF_MEM; } @@ -1527,22 +1527,22 @@ static int tse_start_trx_and_assign_scn( uint32_t autocommit = !thd->in_multi_stmt_transaction_mode(); int isolation_level = isolation_level_to_cantian(mysql_isolation); uint32_t lock_wait_timeout = THDVAR(thd, lock_wait_timeout); - tianchi_trx_context_t trx_context = {isolation_level, autocommit, lock_wait_timeout, false}; + ctc_trx_context_t trx_context = {isolation_level, autocommit, lock_wait_timeout, false}; bool is_mysql_local = user_var_set(thd, "ctc_ddl_local_enabled"); - ct_errno_t ret = (ct_errno_t)tse_trx_begin(&tch, trx_context, is_mysql_local); + ct_errno_t ret = (ct_errno_t)ctc_trx_begin(&tch, trx_context, is_mysql_local); if (ret != CT_SUCCESS) { - tse_log_error("start trx failed with error code: %d", ret); - return convert_tse_error_code_to_mysql(ret); + ctc_log_error("start trx failed with error code: %d", ret); + return convert_ctc_error_code_to_mysql(ret); } update_sess_ctx_by_tch(tch, hton, thd); - sess_ctx->is_tse_trx_begin = 1; + sess_ctx->is_ctc_trx_begin = 1; trans_register_ha(thd, !autocommit, hton, nullptr); return 0; } -void broadcast_and_reload_buffer(tianchi_handler_t *tch, tse_invalidate_broadcast_request *req) { +void broadcast_and_reload_buffer(ctc_handler_t *tch, ctc_invalidate_broadcast_request *req) { if (req->buff_len + sizeof(invalidate_obj_entry_t) > DD_BROADCAST_RECORD_LENGTH) { - (void)tse_broadcast_mysql_dd_invalidate(tch, req); + (void)ctc_broadcast_mysql_dd_invalidate(tch, req); memset(req->buff, 0, DD_BROADCAST_RECORD_LENGTH); req->buff_len = 1; } @@ -1550,9 +1550,9 @@ void broadcast_and_reload_buffer(tianchi_handler_t *tch, tse_invalidate_broadcas template static typename std::enable_if::type - invalidate_remote_dd(T *thd, tianchi_handler_t *tch) + invalidate_remote_dd(T *thd, ctc_handler_t *tch) { - tse_invalidate_broadcast_request req; + ctc_invalidate_broadcast_request req; req.mysql_inst_id = ctc_instance_id; req.buff_len = 1; req.is_dcl = false; @@ -1594,26 +1594,26 @@ static typename std::enable_if::typ } } req.buff[0] = '1'; - (void)tse_broadcast_mysql_dd_invalidate(tch, &req); + (void)ctc_broadcast_mysql_dd_invalidate(tch, &req); } template static typename std::enable_if::type - invalidate_remote_dd(T *thd MY_ATTRIBUTE((unused)), tianchi_handler_t *tch MY_ATTRIBUTE((unused))) { + invalidate_remote_dd(T *thd MY_ATTRIBUTE((unused)), ctc_handler_t *tch MY_ATTRIBUTE((unused))) { // do nothing } -bool invalidate_remote_dcl_cache(tianchi_handler_t *tch) +bool invalidate_remote_dcl_cache(ctc_handler_t *tch) { - tse_invalidate_broadcast_request req; + ctc_invalidate_broadcast_request req; req.mysql_inst_id = ctc_instance_id; req.buff_len = 0; req.is_dcl = true; - bool result = tse_broadcast_mysql_dd_invalidate(tch, &req); + bool result = ctc_broadcast_mysql_dd_invalidate(tch, &req); return result; } -static void tse_register_trx(handlerton *hton, THD *thd) { +static void ctc_register_trx(handlerton *hton, THD *thd) { trans_register_ha(thd, false, hton, nullptr); if (thd_test_options(thd, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) { trans_register_ha(thd, true, hton, nullptr); @@ -1623,7 +1623,7 @@ static void tse_register_trx(handlerton *hton, THD *thd) { // 利用SFINAE特性，控制是否调用thd->is_empty() template static typename std::enable_if::type - commit_preprocess(T* thd, tianchi_handler_t *tch) { + commit_preprocess(T* thd, ctc_handler_t *tch) { if (is_work_flow() && !thd->is_empty() && !thd->is_attachable_transaction_active()) { (void)invalidate_remote_dd(thd, tch); thd->clear(); @@ -1632,26 +1632,26 @@ static typename std::enable_if::type template static typename std::enable_if::type - commit_preprocess(T* thd MY_ATTRIBUTE((unused)), tianchi_handler_t *tch MY_ATTRIBUTE((unused))) { + commit_preprocess(T* thd MY_ATTRIBUTE((unused)), ctc_handler_t *tch MY_ATTRIBUTE((unused))) { // no action here } template static typename std::enable_if::type -attachable_trx_update_pre_addr(T *tse_hton, THD *thd, tianchi_handler_t *tch, bool set_to_pre_addr) { +attachable_trx_update_pre_addr(T *ctc_hton, THD *thd, ctc_handler_t *tch, bool set_to_pre_addr) { if (thd->is_attachable_transaction_active() && (thd->tx_isolation == ISO_READ_UNCOMMITTED) - && (tse_hton->pre_sess_addr != 0) && thd->query_plan.get_command() == SQLCOM_RENAME_TABLE) { - tch->pre_sess_addr = set_to_pre_addr ? tse_hton->pre_sess_addr : 0; + && (ctc_hton->pre_sess_addr != 0) && thd->query_plan.get_command() == SQLCOM_RENAME_TABLE) { + tch->pre_sess_addr = set_to_pre_addr ? ctc_hton->pre_sess_addr : 0; } } template static typename std::enable_if::type -attachable_trx_update_pre_addr(T *tse_hton MY_ATTRIBUTE((unused)), THD *thd MY_ATTRIBUTE((unused)), - tianchi_handler_t *tch MY_ATTRIBUTE((unused)), bool set_to_pre_addr MY_ATTRIBUTE((unused))) { +attachable_trx_update_pre_addr(T *ctc_hton MY_ATTRIBUTE((unused)), THD *thd MY_ATTRIBUTE((unused)), + ctc_handler_t *tch MY_ATTRIBUTE((unused)), bool set_to_pre_addr MY_ATTRIBUTE((unused))) { } -static void tse_free_cursors_no_autocommit(THD *thd, tianchi_handler_t *tch, thd_sess_ctx_s *sess_ctx) { +static void ctc_free_cursors_no_autocommit(THD *thd, ctc_handler_t *tch, thd_sess_ctx_s *sess_ctx) { if (!thd->in_multi_stmt_transaction_mode()) { return; } @@ -1665,19 +1665,19 @@ static void tse_free_cursors_no_autocommit(THD *thd, tianchi_handler_t *tch, thd return; } - uint64_t *cursors = (uint64_t *)tse_alloc_buf(tch, sizeof(uint64_t) * total_csize); + uint64_t *cursors = (uint64_t *)ctc_alloc_buf(tch, sizeof(uint64_t) * total_csize); if ((total_csize != 0) && (cursors == nullptr)) { - tse_log_error("tse_alloc_buf for cursors in tse_free_cursors_no_autocommit failed"); + ctc_log_error("ctc_alloc_buf for cursors in ctc_free_cursors_no_autocommit failed"); } assert((total_csize == 0) ^ (cursors != nullptr)); ctc_copy_cursors_to_free(sess_ctx, cursors, 0); - tse_free_session_cursors(tch, cursors, total_csize); - tse_free_buf(tch, (uint8_t *)cursors); + ctc_free_session_cursors(tch, cursors, total_csize); + ctc_free_buf(tch, (uint8_t *)cursors); } /** - Commits a transaction in an tse database or marks an SQL statement ended. - @param: hton in, tse handlerton + Commits a transaction in an ctc database or marks an SQL statement ended. + @param: hton in, ctc handlerton @param: thd in, MySQL thread handle of the user for whom the transaction should be committed @param: commit_trx in, true - commit transaction false - the current SQL @@ -1685,60 +1685,60 @@ static void tse_free_cursors_no_autocommit(THD *thd, tianchi_handler_t *tch, thd @return 0 or deadlock error if the transaction was aborted by another higher priority transaction. */ -static int tse_commit(handlerton *hton, THD *thd, bool commit_trx) { +static int ctc_commit(handlerton *hton, THD *thd, bool commit_trx) { DBUG_TRACE; if (engine_ddl_passthru(thd) && (is_alter_table_copy(thd) || is_create_table_check(thd) || is_lock_table(thd))) { return 0; } - tianchi_handler_t tch; + ctc_handler_t tch; bool is_ddl_commit = false; bool will_commit = commit_trx || (!thd->in_multi_stmt_transaction_mode()); - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch, will_commit)); + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch, will_commit)); ct_errno_t ret = CT_SUCCESS; thd_sess_ctx_s *sess_ctx = (thd_sess_ctx_s *)thd_get_ha_data(thd, hton); assert(sess_ctx != nullptr); if (will_commit) { commit_preprocess(thd, &tch); - attachable_trx_update_pre_addr(tse_hton, thd, &tch, true); + attachable_trx_update_pre_addr(ctc_hton, thd, &tch, true); int32_t total_csize = sess_ctx->cursors_map->size(); if (sess_ctx->invalid_cursors != nullptr) { total_csize += sess_ctx->invalid_cursors->size(); } - uint64_t *cursors = (uint64_t *)tse_alloc_buf(&tch, sizeof(uint64_t) * total_csize); + uint64_t *cursors = (uint64_t *)ctc_alloc_buf(&tch, sizeof(uint64_t) * total_csize); if ((total_csize != 0) && (cursors == nullptr)) { - tse_log_error("tse_alloc_buf for cursors in tse_commit failed"); + ctc_log_error("ctc_alloc_buf for cursors in ctc_commit failed"); } assert((total_csize == 0) ^ (cursors != nullptr)); ctc_copy_cursors_to_free(sess_ctx, cursors, 0); - ret = (ct_errno_t)tse_trx_commit(&tch, cursors, total_csize, &is_ddl_commit); - tse_free_buf(&tch, (uint8_t *)cursors); + ret = (ct_errno_t)ctc_trx_commit(&tch, cursors, total_csize, &is_ddl_commit); + ctc_free_buf(&tch, (uint8_t *)cursors); if (ret != CT_SUCCESS) { - tse_log_error("commit atomic ddl failed with error code: %d", ret); - return convert_tse_error_code_to_mysql(ret); + ctc_log_error("commit atomic ddl failed with error code: %d", ret); + return convert_ctc_error_code_to_mysql(ret); } if (is_ddl_commit && !engine_skip_ddl(thd)) { - tse_ddl_broadcast_request broadcast_req {{0}, {0}, {0}, {0}, 0, 0, 0, 0, {0}}; + ctc_ddl_broadcast_request broadcast_req {{0}, {0}, {0}, {0}, 0, 0, 0, 0, {0}}; string sql = string(thd->query().str).substr(0, thd->query().length); FILL_BROADCAST_BASE_REQ(broadcast_req, sql.c_str(), thd->m_main_security_ctx.priv_user().str, thd->m_main_security_ctx.priv_host().str, ctc_instance_id, thd->lex->sql_command); if (thd->db().str != NULL && thd->db().length > 0) { strncpy(broadcast_req.db_name, thd->db().str, SMALL_RECORD_SIZE - 1); } - broadcast_req.options &= (~TSE_NOT_NEED_CANTIAN_EXECUTE); - ret = (ct_errno_t)tse_execute_mysql_ddl_sql(&tch, &broadcast_req, false); + broadcast_req.options &= (~CTC_NOT_NEED_CANTIAN_EXECUTE); + ret = (ct_errno_t)ctc_execute_mysql_ddl_sql(&tch, &broadcast_req, false); DBUG_EXECUTE_IF("core_after_ddl_cantian_commit_broadcast", { assert(0); }); - tse_log_system("[TSE_BROARDCAST_ATOMIC_DDL]:ret:%d, query:%s, user_name:%s, err_code:%d, broadcast_inst_id:%u, " - "conn_id:%u, tse_inst_id:%u", ret, broadcast_req.sql_str, broadcast_req.user_name, + ctc_log_system("[CTC_BROARDCAST_ATOMIC_DDL]:ret:%d, query:%s, user_name:%s, err_code:%d, broadcast_inst_id:%u, " + "conn_id:%u, ctc_inst_id:%u", ret, broadcast_req.sql_str, broadcast_req.user_name, broadcast_req.err_code, broadcast_req.mysql_inst_id, tch.thd_id, tch.inst_id); assert (ret == CT_SUCCESS); } - sess_ctx->is_tse_trx_begin = 0; + sess_ctx->is_ctc_trx_begin = 0; } else { - tse_free_cursors_no_autocommit(thd, &tch, sess_ctx); + ctc_free_cursors_no_autocommit(thd, &tch, sess_ctx); } if (!commit_trx) { @@ -1749,8 +1749,8 @@ static int tse_commit(handlerton *hton, THD *thd, bool commit_trx) { } /** - Rollback a transaction in an tse database or marks an SQL statement ended. - @param: hton in, tse handlerton + Rollback a transaction in an ctc database or marks an SQL statement ended. + @param: hton in, ctc handlerton @param: thd in, handle to the MySQL thread of the user whose transaction should be rolled back be committed @param: commit_trx in, TRUE - rollback entire transaction FALSE - rollback the @@ -1759,17 +1759,17 @@ static int tse_commit(handlerton *hton, THD *thd, bool commit_trx) { higher priority transaction. @note: */ -static int tse_rollback(handlerton *hton, THD *thd, bool rollback_trx) { +static int ctc_rollback(handlerton *hton, THD *thd, bool rollback_trx) { DBUG_TRACE; if (thd->lex->sql_command == SQLCOM_DROP_TABLE) { - tse_log_error("[CTC_TRX]:rollback when drop table, rollback_trx=%d", rollback_trx); + ctc_log_error("[CTC_TRX]:rollback when drop table, rollback_trx=%d", rollback_trx); } bool will_rollback = rollback_trx || !thd->in_multi_stmt_transaction_mode(); ct_errno_t ret = CT_SUCCESS; - tianchi_handler_t tch; - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); + ctc_handler_t tch; + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); thd_sess_ctx_s *sess_ctx = (thd_sess_ctx_s *)thd_get_ha_data(thd, hton); assert(sess_ctx != nullptr); @@ -1778,36 +1778,36 @@ static int tse_rollback(handlerton *hton, THD *thd, bool rollback_trx) { if (sess_ctx->invalid_cursors != nullptr) { total_csize += sess_ctx->invalid_cursors->size(); } - uint64_t *cursors = (uint64_t *)tse_alloc_buf(&tch, sizeof(uint64_t) * total_csize); + uint64_t *cursors = (uint64_t *)ctc_alloc_buf(&tch, sizeof(uint64_t) * total_csize); if ((total_csize != 0) && (cursors == nullptr)) { - tse_log_error("tse_alloc_buf for cursors in tse_rollback failed"); + ctc_log_error("ctc_alloc_buf for cursors in ctc_rollback failed"); } assert((total_csize == 0) ^ (cursors != nullptr)); ctc_copy_cursors_to_free(sess_ctx, cursors, 0); - ret = (ct_errno_t)tse_trx_rollback(&tch, cursors, total_csize); + ret = (ct_errno_t)ctc_trx_rollback(&tch, cursors, total_csize); if (ret != CT_SUCCESS) { - tse_free_buf(&tch, (uint8_t *)cursors); - tse_log_error("rollback trx failed with error code: %d", ret); - return convert_tse_error_code_to_mysql(ret); + ctc_free_buf(&tch, (uint8_t *)cursors); + ctc_log_error("rollback trx failed with error code: %d", ret); + return convert_ctc_error_code_to_mysql(ret); } - tse_free_buf(&tch, (uint8_t *)cursors); - sess_ctx->is_tse_trx_begin = 0; + ctc_free_buf(&tch, (uint8_t *)cursors); + sess_ctx->is_ctc_trx_begin = 0; } else if (sess_ctx->sql_stat_start == 0) { int32_t total_csize = sess_ctx->cursors_map->size(); if (sess_ctx->invalid_cursors != nullptr) { total_csize += sess_ctx->invalid_cursors->size(); } - uint64_t *cursors = (uint64_t *)tse_alloc_buf(&tch, sizeof(uint64_t) * total_csize); + uint64_t *cursors = (uint64_t *)ctc_alloc_buf(&tch, sizeof(uint64_t) * total_csize); if ((total_csize != 0) && (cursors == nullptr)) { - tse_log_error("tse_alloc_buf for cursors in tse_rollback failed"); + ctc_log_error("ctc_alloc_buf for cursors in ctc_rollback failed"); } assert((total_csize == 0) ^ (cursors != nullptr)); ctc_copy_cursors_to_free(sess_ctx, cursors, 0); - (void)tse_srv_rollback_savepoint(&tch, cursors, total_csize, TSE_SQL_START_INTERNAL_SAVEPOINT); - tse_free_buf(&tch, (uint8_t *)cursors); + (void)ctc_srv_rollback_savepoint(&tch, cursors, total_csize, CTC_SQL_START_INTERNAL_SAVEPOINT); + ctc_free_buf(&tch, (uint8_t *)cursors); } else { - tse_free_cursors_no_autocommit(thd, &tch, sess_ctx); + ctc_free_cursors_no_autocommit(thd, &tch, sess_ctx); } if (!rollback_trx) { @@ -1818,9 +1818,9 @@ static int tse_rollback(handlerton *hton, THD *thd, bool rollback_trx) { return 0; } -static int tse_close_connect(handlerton *hton, THD *thd) { - tianchi_handler_t tch; - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); +static int ctc_close_connect(handlerton *hton, THD *thd) { + ctc_handler_t tch; + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); thd_sess_ctx_s *sess_ctx = (thd_sess_ctx_s *)thd_get_ha_data(thd, hton); if (thd->is_attachable_transaction_active() || is_initialize() || is_ctc_mdl_thd(thd)) { @@ -1829,26 +1829,26 @@ static int tse_close_connect(handlerton *hton, THD *thd) { tch.is_broadcast = true; } - tianchi_handler_t local_tch; + ctc_handler_t local_tch; memset(&local_tch, 0, sizeof(local_tch)); local_tch.inst_id = tch.inst_id; local_tch.sess_addr = tch.sess_addr; local_tch.thd_id = tch.thd_id; local_tch.is_broadcast = tch.is_broadcast; - int ret = tse_close_session(&local_tch); + int ret = ctc_close_session(&local_tch); release_sess_ctx(sess_ctx, hton, thd); - return convert_tse_error_code_to_mysql((ct_errno_t)ret); + return convert_ctc_error_code_to_mysql((ct_errno_t)ret); } -static void tse_kill_connection(handlerton *hton, THD *thd) { - tianchi_handler_t tch; +static void ctc_kill_connection(handlerton *hton, THD *thd) { + ctc_handler_t tch; int ret = get_tch_in_handler_data(hton, thd, tch); if (ret != CT_SUCCESS) { return; } if (tch.sess_addr == INVALID_VALUE64) { - tse_log_system("[TSE_KILL_SESSION]:trying to kill a thd without session assigned, conn_id=%u, instid=%u", + ctc_log_system("[CTC_KILL_SESSION]:trying to kill a thd without session assigned, conn_id=%u, instid=%u", tch.thd_id, tch.inst_id); return; } @@ -1857,39 +1857,39 @@ static void tse_kill_connection(handlerton *hton, THD *thd) { return; } - tianchi_handler_t local_tch; + ctc_handler_t local_tch; memset(&local_tch, 0, sizeof(local_tch)); local_tch.inst_id = tch.inst_id; local_tch.sess_addr = tch.sess_addr; local_tch.thd_id = tch.thd_id; - tse_kill_session(&local_tch); - tse_log_system("[TSE_KILL_SESSION]:conn_id:%u, ctc_instance_id:%u", tch.thd_id, tch.inst_id); + ctc_kill_session(&local_tch); + ctc_log_system("[CTC_KILL_SESSION]:conn_id:%u, ctc_instance_id:%u", tch.thd_id, tch.inst_id); } -static int tse_pre_create_db4cantian(THD *thd, tianchi_handler_t *tch) { +static int ctc_pre_create_db4cantian(THD *thd, ctc_handler_t *tch) { if (engine_skip_ddl(thd)) { return CT_SUCCESS; } char user_name[SMALL_RECORD_SIZE] = { 0 }; - tse_copy_name(user_name, thd->lex->name.str, SMALL_RECORD_SIZE); + ctc_copy_name(user_name, thd->lex->name.str, SMALL_RECORD_SIZE); int error_code = 0; char error_message[ERROR_MESSAGE_LEN] = {0}; - tse_log_system("[TSE_INIT]:tse_pre_create_db4cantian begin"); + ctc_log_system("[CTC_INIT]:ctc_pre_create_db4cantian begin"); DBUG_EXECUTE_IF("core_before_create_tablespace_and_db", { assert(0); }); // 有锁的问题 string sql = string(thd->query().str).substr(0, thd->query().length); - tse_db_infos_t db_infos; + ctc_db_infos_t db_infos; db_infos.name = user_name; db_infos.datafile_size = ctc_db_datafile_size; db_infos.datafile_autoextend = ctc_db_datafile_autoextend; db_infos.datafile_extend_size = ctc_db_datafile_extend_size; - int ret = tse_pre_create_db(tch, sql.c_str(), &db_infos, &error_code, error_message); + int ret = ctc_pre_create_db(tch, sql.c_str(), &db_infos, &error_code, error_message); DBUG_EXECUTE_IF("core_after_create_tablespace_and_db", { assert(0); }); // 元数据不一致的问题 - tse_log_system("[TSE_PRE_CREATE_DB]:ret:%d, database:%s, error_code:%d, error_message:%s, conn_id:%u, ctc_instance_id:%u", + ctc_log_system("[CTC_PRE_CREATE_DB]:ret:%d, database:%s, error_code:%d, error_message:%s, conn_id:%u, ctc_instance_id:%u", ret, thd->lex->name.str, error_code, error_message, tch->thd_id, tch->inst_id); if (ret != CT_SUCCESS) { @@ -1906,31 +1906,31 @@ static int tse_pre_create_db4cantian(THD *thd, tianchi_handler_t *tch) { my_error(ER_CANT_CREATE_DB, MYF(0), thd->lex->name.str, error_code, error_message); } } - tse_log_system("[TSE_INIT]:tse_pre_create_db4cantian end, ret=%d", ret); + ctc_log_system("[CTC_INIT]:ctc_pre_create_db4cantian end, ret=%d", ret); return ret; } -static void tse_lock_table_handle_error(int err_code, tse_lock_table_info *lock_info, tianchi_handler_t &tch, THD *thd) { - DBUG_EXECUTE_IF("tse_lock_table_fail_DDL_LOCKED", { err_code = ERR_USER_DDL_LOCKED; }); - DBUG_EXECUTE_IF("tse_lock_table_fail_VERSION_NOT_MATCH", { err_code = TSE_DDL_VERSION_NOT_MATCH; }); - DBUG_EXECUTE_IF("tse_lock_table_fail_DISALLOW_OPERATION", { err_code = ER_DISALLOWED_OPERATION; }); +static void ctc_lock_table_handle_error(int err_code, ctc_lock_table_info *lock_info, ctc_handler_t &tch, THD *thd) { + DBUG_EXECUTE_IF("ctc_lock_table_fail_DDL_LOCKED", { err_code = ERR_USER_DDL_LOCKED; }); + DBUG_EXECUTE_IF("ctc_lock_table_fail_VERSION_NOT_MATCH", { err_code = CTC_DDL_VERSION_NOT_MATCH; }); + DBUG_EXECUTE_IF("ctc_lock_table_fail_DISALLOW_OPERATION", { err_code = ER_DISALLOWED_OPERATION; }); switch (err_code) { case ERR_USER_DDL_LOCKED: my_printf_error(ER_DISALLOWED_OPERATION, "Instance has been locked, disallow this operation", MYF(0)); - tse_log_system("[TSE_MDL_LOCK]: Instance has been locked, disallow this operation," + ctc_log_system("[CTC_MDL_LOCK]: Instance has been locked, disallow this operation," "lock_info=(%s, %s), sql=%s, conn_id=%u, ctc_instance_id=%u", lock_info->db_name, lock_info->table_name, thd->query().str, tch.thd_id, tch.inst_id); break; - case TSE_DDL_VERSION_NOT_MATCH: + case CTC_DDL_VERSION_NOT_MATCH: my_printf_error(ER_DISALLOWED_OPERATION, "Version not match. Please make sure cluster on the same version.", MYF(0)); - tse_log_system("[TSE_MDL_LOCK]: Version not match,lock_info=(%s, %s), sql=%s", lock_info->db_name, lock_info->table_name, thd->query().str); + ctc_log_system("[CTC_MDL_LOCK]: Version not match,lock_info=(%s, %s), sql=%s", lock_info->db_name, lock_info->table_name, thd->query().str); break; default: my_printf_error(err_code, "The table or database is being used. Please try again later.", MYF(0)); - tse_log_error("[TSE_MDL_LOCK]: Lock failed, err=%d, lock_info=(%s, %s), sql=%s, conn_id=%u, ctc_instance_id=%u", + ctc_log_error("[CTC_MDL_LOCK]: Lock failed, err=%d, lock_info=(%s, %s), sql=%s, conn_id=%u, ctc_instance_id=%u", err_code, lock_info->db_name, lock_info->table_name, thd->query().str, tch.thd_id, tch.inst_id); break; } @@ -1938,8 +1938,8 @@ static void tse_lock_table_handle_error(int err_code, tse_lock_table_info *lock_ return; } -static int tse_notify_pre_event(THD *thd, handlerton *tse_hton, tianchi_handler_t &tch, tse_lock_table_info *lock_info) { - thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(tse_hton, thd); +static int ctc_notify_pre_event(THD *thd, handlerton *ctc_hton, ctc_handler_t &tch, ctc_lock_table_info *lock_info) { + thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(ctc_hton, thd); assert(sess_ctx != nullptr); if (sess_ctx == nullptr) { return HA_ERR_OUT_OF_MEM; @@ -1947,30 +1947,30 @@ static int tse_notify_pre_event(THD *thd, handlerton *tse_hton, tianchi_handler_ int ret = 0; int err_code = 0; - const char *cur_db_name = TSE_GET_THD_DB_NAME(thd); + const char *cur_db_name = CTC_GET_THD_DB_NAME(thd); enum_sql_command sql_command = thd->lex->sql_command; if (sql_command == SQLCOM_CREATE_DB || sql_command == SQLCOM_DROP_DB || sql_command == SQLCOM_ALTER_DB) { cur_db_name = nullptr; } if (is_work_flow()) { - ret = tse_lock_table(&tch, cur_db_name, lock_info, &err_code); + ret = ctc_lock_table(&tch, cur_db_name, lock_info, &err_code); - DBUG_EXECUTE_IF("tse_lock_table_fail", { ret = -1; }); + DBUG_EXECUTE_IF("ctc_lock_table_fail", { ret = -1; }); if (ret != 0) { - tse_lock_table_handle_error(err_code, lock_info, tch, thd); + ctc_lock_table_handle_error(err_code, lock_info, tch, thd); return ret; } } switch (sql_command) { case SQLCOM_CREATE_DB:{ - ret = tse_pre_create_db4cantian(thd, &tch); + ret = ctc_pre_create_db4cantian(thd, &tch); break; } case SQLCOM_DROP_DB:{ char err_msg[ERROR_MESSAGE_LEN] = {0}; - ret = tse_drop_db_pre_check(&tch, lock_info->db_name, &err_code, err_msg); + ret = ctc_drop_db_pre_check(&tch, lock_info->db_name, &err_code, err_msg); if (ret != 0) { my_printf_error(ER_DISALLOWED_OPERATION, "Can't drop database '%s' (errno: %d - %s)", MYF(0), lock_info->db_name, err_code, err_msg); @@ -1983,37 +1983,37 @@ static int tse_notify_pre_event(THD *thd, handlerton *tse_hton, tianchi_handler_ return ret; } -static int tse_notify_post_event(THD *thd, handlerton *tse_hton, tianchi_handler_t &tch, tse_lock_table_info *lock_info) { - thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(tse_hton, thd); +static int ctc_notify_post_event(THD *thd, handlerton *ctc_hton, ctc_handler_t &tch, ctc_lock_table_info *lock_info) { + thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(ctc_hton, thd); assert(sess_ctx != nullptr); if (sess_ctx == nullptr) { return HA_ERR_OUT_OF_MEM; } - DBUG_EXECUTE_IF("core_before_tse_unlock_table", { assert(0); }); // 解锁前core + DBUG_EXECUTE_IF("core_before_ctc_unlock_table", { assert(0); }); // 解锁前core int ret = 0; if (is_work_flow()) { if ((MDL_key::enum_mdl_namespace)lock_info->mdl_namespace == MDL_key::ACL_CACHE) { invalidate_remote_dcl_cache(&tch); - tse_log_system("[CTC_ACL_CACHE]:invalidate dcl cache."); + ctc_log_system("[CTC_ACL_CACHE]:invalidate dcl cache."); if (thd->is_error()) { - tse_log_system("TSE_POST_EVENT]: no need to record sql str since thd has an error."); + ctc_log_system("CTC_POST_EVENT]: no need to record sql str since thd has an error."); return ret; } if (is_dcl_sql_cmd(thd->lex->sql_command) && ctc_record_sql(thd, true)) { - tse_log_error("[TSE_POST_EVENT]:record dcl sql str failed. sql:%s", thd->query().str); + ctc_log_error("[CTC_POST_EVENT]:record dcl sql str failed. sql:%s", thd->query().str); } return ret; } - tse_log_system("[UNLOCK_TABLE]: tse_unlock_table lock_info=(%s, %s), sql=%s", lock_info->db_name, lock_info->table_name, thd->query().str); - ret = tse_unlock_table(&tch, ctc_instance_id, lock_info); + ctc_log_system("[UNLOCK_TABLE]: ctc_unlock_table lock_info=(%s, %s), sql=%s", lock_info->db_name, lock_info->table_name, thd->query().str); + ret = ctc_unlock_table(&tch, ctc_instance_id, lock_info); if (ret != 0) { - tse_log_error("[TSE_MDL_LOCK]: unlock failed, ret: %d, sql: %s, conn_id: %u, ctc_instance_id: %u", + ctc_log_error("[CTC_MDL_LOCK]: unlock failed, ret: %d, sql: %s, conn_id: %u, ctc_instance_id: %u", ret, thd->query().str, tch.thd_id, tch.inst_id); } } @@ -2031,7 +2031,7 @@ static int tse_notify_post_event(THD *thd, handlerton *tse_hton, tianchi_handler @return False if notification was successful and it is OK to acquire lock, True if one of SEs asks to abort lock acquisition. */ -static bool tse_notify_exclusive_mdl(THD *thd, const MDL_key *mdl_key, +static bool ctc_notify_exclusive_mdl(THD *thd, const MDL_key *mdl_key, ha_notification_type notification_type, bool *victimized MY_ATTRIBUTE((unused))) { if (is_ctc_mdl_thd(thd) || (notification_type == HA_NOTIFY_PRE_EVENT && @@ -2055,7 +2055,7 @@ static bool tse_notify_exclusive_mdl(THD *thd, const MDL_key *mdl_key, if (!IS_METADATA_NORMALIZATION()) { if (engine_skip_ddl(thd)) { - tse_log_warning("[CTC_NOMETA_SQL]:record sql str only generate metadata. sql:%s", thd->query().str); + ctc_log_warning("[CTC_NOMETA_SQL]:record sql str only generate metadata. sql:%s", thd->query().str); return false; } @@ -2074,44 +2074,44 @@ static bool tse_notify_exclusive_mdl(THD *thd, const MDL_key *mdl_key, } int ret = 0; - tianchi_handler_t tch; - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(tse_hton, thd, tch)); + ctc_handler_t tch; + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(ctc_hton, thd, tch)); - tse_lock_table_info lock_info = {{0}, {0}, {0}, {0}, thd->lex->sql_command, (int32_t)mdl_key->mdl_namespace()}; + ctc_lock_table_info lock_info = {{0}, {0}, {0}, {0}, thd->lex->sql_command, (int32_t)mdl_key->mdl_namespace()}; FILL_USER_INFO_WITH_THD(lock_info, thd); strncpy(lock_info.db_name, mdl_key->db_name(), SMALL_RECORD_SIZE - 1); strncpy(lock_info.table_name, mdl_key->name(), SMALL_RECORD_SIZE - 1); if (notification_type == HA_NOTIFY_PRE_EVENT) { - ret = tse_notify_pre_event(thd, tse_hton, tch, &lock_info); + ret = ctc_notify_pre_event(thd, ctc_hton, tch, &lock_info); } else { - ret = tse_notify_post_event(thd, tse_hton, tch, &lock_info); + ret = ctc_notify_post_event(thd, ctc_hton, tch, &lock_info); } - update_sess_ctx_by_tch(tch, tse_hton, thd); + update_sess_ctx_by_tch(tch, ctc_hton, thd); if (ret != 0) { - tse_unlock_table(&tch, ctc_instance_id, &lock_info); + ctc_unlock_table(&tch, ctc_instance_id, &lock_info); return true; } return false; } -static bool tse_notify_alter_table(THD *thd, const MDL_key *mdl_key, +static bool ctc_notify_alter_table(THD *thd, const MDL_key *mdl_key, ha_notification_type notification_type) { vector ticket_list; if (IS_METADATA_NORMALIZATION() && notification_type == HA_NOTIFY_PRE_EVENT) { - int pre_lock_ret = tse_lock_table_pre(thd, ticket_list, MDL_SHARED_UPGRADABLE); + int pre_lock_ret = ctc_lock_table_pre(thd, ticket_list, MDL_SHARED_UPGRADABLE); if (pre_lock_ret != 0) { - tse_lock_table_post(thd, ticket_list); - my_printf_error(ER_LOCK_WAIT_TIMEOUT, "[tse_notify_alter_table]: LOCK TABLE FAILED", MYF(0)); + ctc_lock_table_post(thd, ticket_list); + my_printf_error(ER_LOCK_WAIT_TIMEOUT, "[ctc_notify_alter_table]: LOCK TABLE FAILED", MYF(0)); return true; } } - bool ret = tse_notify_exclusive_mdl(thd, mdl_key, notification_type, nullptr); + bool ret = ctc_notify_exclusive_mdl(thd, mdl_key, notification_type, nullptr); if (IS_METADATA_NORMALIZATION() && notification_type == HA_NOTIFY_PRE_EVENT) { - tse_lock_table_post(thd, ticket_list); + ctc_lock_table_post(thd, ticket_list); } return ret; @@ -2122,78 +2122,78 @@ static const int BASE36 = 36; // 0~9 and a~z, total 36 encoded character /** Sets a transaction savepoint. - @param: hton in, tse handlerton + @param: hton in, ctc handlerton @param: thd in, handle to the MySQL thread @param: savepoint in, savepoint data @return: 0 if succeeds */ -static int tse_set_savepoint(handlerton *hton, THD *thd, void *savepoint) { +static int ctc_set_savepoint(handlerton *hton, THD *thd, void *savepoint) { DBUG_TRACE; char name[MAX_SAVEPOINT_NAME_LEN]; longlong2str((unsigned long long)savepoint, name, BASE36); - tianchi_handler_t tch; - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); - if (!strcmp(name, TSE_SQL_START_INTERNAL_SAVEPOINT)) { + ctc_handler_t tch; + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); + if (!strcmp(name, CTC_SQL_START_INTERNAL_SAVEPOINT)) { my_error(ER_DISALLOWED_OPERATION, MYF(0), "this savepoint has been used by sys db!"); return ER_DISALLOWED_OPERATION; } - ct_errno_t ret = (ct_errno_t)tse_srv_set_savepoint(&tch, name); + ct_errno_t ret = (ct_errno_t)ctc_srv_set_savepoint(&tch, name); if (ret != CT_SUCCESS) { - tse_log_error("set trx savepoint failed with error code: %d", ret); + ctc_log_error("set trx savepoint failed with error code: %d", ret); } - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } /** Rollback to a transaction savepoint. - @param: hton in, tse handlerton + @param: hton in, ctc handlerton @param: thd in, handle to the MySQL thread @param: savepoint in, savepoint data @return: 0 if succeeds */ -static int tse_rollback_savepoint(handlerton *hton, THD *thd, void *savepoint) { +static int ctc_rollback_savepoint(handlerton *hton, THD *thd, void *savepoint) { DBUG_TRACE; char name[MAX_SAVEPOINT_NAME_LEN]; longlong2str((unsigned long long)savepoint, name, BASE36); - tianchi_handler_t tch; - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); + ctc_handler_t tch; + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); thd_sess_ctx_s *sess_ctx = (thd_sess_ctx_s *)thd_get_ha_data(thd, hton); assert(sess_ctx != nullptr); int32_t total_csize = sess_ctx->cursors_map->size(); if (sess_ctx->invalid_cursors != nullptr) { total_csize += sess_ctx->invalid_cursors->size(); } - uint64_t *cursors = (uint64_t *)tse_alloc_buf(&tch, sizeof(uint64_t) * total_csize); + uint64_t *cursors = (uint64_t *)ctc_alloc_buf(&tch, sizeof(uint64_t) * total_csize); if ((total_csize != 0) && (cursors == nullptr)) { - tse_log_error("tse_alloc_buf for cursors in tse_rollback_savepoint failed"); + ctc_log_error("ctc_alloc_buf for cursors in ctc_rollback_savepoint failed"); } assert((total_csize == 0) ^ (cursors != nullptr)); ctc_copy_cursors_to_free(sess_ctx, cursors, 0); - ct_errno_t ret = (ct_errno_t)tse_srv_rollback_savepoint(&tch, cursors, total_csize, name); - tse_free_buf(&tch, (uint8_t *)cursors); + ct_errno_t ret = (ct_errno_t)ctc_srv_rollback_savepoint(&tch, cursors, total_csize, name); + ctc_free_buf(&tch, (uint8_t *)cursors); if (ret != CT_SUCCESS) { - tse_log_error("rollback to trx savepoint failed with error code: %d", ret); + ctc_log_error("rollback to trx savepoint failed with error code: %d", ret); } - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } /** Release a transaction savepoint. - @param: hton in, tse handlerton + @param: hton in, ctc handlerton @param: thd in, handle to the MySQL thread @param: savepoint in, savepoint data @return: 0 if succeeds */ -static int tse_release_savepoint(handlerton *hton, THD *thd, void *savepoint) { +static int ctc_release_savepoint(handlerton *hton, THD *thd, void *savepoint) { DBUG_TRACE; /** - * SQLCOM_SAVEPOINT命令如果发现之前已保存有重名的savepoint，mysql会触发调用tse_release_savepoint， - * 该种场景下就不需要再调用tse_srv_release_savepoint了，knl_set_savepoint接口内部会去掉重名的savepoint； + * SQLCOM_SAVEPOINT命令如果发现之前已保存有重名的savepoint，mysql会触发调用ctc_release_savepoint， + * 该种场景下就不需要再调用ctc_srv_release_savepoint了，knl_set_savepoint接口内部会去掉重名的savepoint； * - * tse_srv_release_savepoint底层调到knl_release_savepoint，会把当前savepoint及其之后的全都release掉， + * ctc_srv_release_savepoint底层调到knl_release_savepoint，会把当前savepoint及其之后的全都release掉， * 与innodb行为不一致，在某些场景下会引发缺陷 */ if (thd->query_plan.get_command() == SQLCOM_SAVEPOINT) { @@ -2202,13 +2202,13 @@ static int tse_release_savepoint(handlerton *hton, THD *thd, void *savepoint) { char name[MAX_SAVEPOINT_NAME_LEN]; longlong2str((unsigned long long)savepoint, name, BASE36); - tianchi_handler_t tch; - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); - ct_errno_t ret = (ct_errno_t)tse_srv_release_savepoint(&tch, name); + ctc_handler_t tch; + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); + ct_errno_t ret = (ct_errno_t)ctc_srv_release_savepoint(&tch, name); if (ret != CT_SUCCESS) { - tse_log_error("release trx savepoint failed with error code: %d", ret); + ctc_log_error("release trx savepoint failed with error code: %d", ret); } - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } /** @@ -2217,7 +2217,7 @@ static int tse_release_savepoint(handlerton *hton, THD *thd, void *savepoint) { times @return: 0 if succeeds */ -int ha_tse::prefetch_and_fill_record_buffer(uchar *buf, tse_prefetch_fn prefetch) { +int ha_ctc::prefetch_and_fill_record_buffer(uchar *buf, ctc_prefetch_fn prefetch) { // update max col id needed by executor set_max_col_index_4_reading(); uint32_t fetched_num; @@ -2228,7 +2228,7 @@ int ha_tse::prefetch_and_fill_record_buffer(uchar *buf, tse_prefetch_fn prefetch m_prefetch_buf = (uchar *)my_malloc(PSI_NOT_INSTRUMENTED, MAX_RECORD_SIZE, MYF(MY_WME)); } if (m_prefetch_buf == nullptr) { - tse_log_error("alloc mem failed, m_prefetch_buf size(%u)", MAX_RECORD_SIZE); + ctc_log_error("alloc mem failed, m_prefetch_buf size(%u)", MAX_RECORD_SIZE); return HA_ERR_OUT_OF_MEM; } @@ -2236,7 +2236,7 @@ int ha_tse::prefetch_and_fill_record_buffer(uchar *buf, tse_prefetch_fn prefetch &fetched_num, m_rowids, m_cantian_rec_len); check_error_code_to_mysql(ha_thd(), &ret); if (ret != CT_SUCCESS) { - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } if (fetched_num == 0) { return HA_ERR_END_OF_FILE; @@ -2265,7 +2265,7 @@ int ha_tse::prefetch_and_fill_record_buffer(uchar *buf, tse_prefetch_fn prefetch return 0; } -void ha_tse::fill_record_to_rec_buffer() { +void ha_ctc::fill_record_to_rec_buffer() { m_rec_buf->clear(); for (uint32_t i = 0; i < m_rec_buf->max_records() && cur_fill_buf_index < actual_fetched_nums; i++) { uint8_t *tmpRecBuf = m_rec_buf->add_record(); @@ -2282,7 +2282,7 @@ void ha_tse::fill_record_to_rec_buffer() { m_rec_buf->set_out_of_range(is_out_of_range); } -void ha_tse::reset_rec_buf(bool is_prefetch) { +void ha_ctc::reset_rec_buf(bool is_prefetch) { cur_pos_in_buf = INVALID_MAX_UINT32; if (is_prefetch) { cur_pos_in_buf = 0; @@ -2293,7 +2293,7 @@ void ha_tse::reset_rec_buf(bool is_prefetch) { m_rec_buf->reset(); } -void ha_tse::set_max_col_index_4_reading() { +void ha_ctc::set_max_col_index_4_reading() { max_col_index = table->read_set->n_bits - 1; // max_col_index equals to num_of_cols - 1 in table if it's not a read-only // scan @@ -2325,7 +2325,7 @@ void ha_tse::set_max_col_index_4_reading() { } -bool ha_tse::pre_check_for_cascade(bool is_update) { +bool ha_ctc::pre_check_for_cascade(bool is_update) { TABLE_SHARE_FOREIGN_KEY_PARENT_INFO *fk = table->s->foreign_key_parent; for (uint i = 0; i < table->s->foreign_key_parents; i++) { @@ -2344,19 +2344,19 @@ bool ha_tse::pre_check_for_cascade(bool is_update) { return true; } -ha_tse::ha_tse(handlerton *hton, TABLE_SHARE *table_arg) +ha_ctc::ha_ctc(handlerton *hton, TABLE_SHARE *table_arg) : handler(hton, table_arg), m_rec_buf(nullptr), m_share(nullptr) { ref_length = ROW_ID_LENGTH; } -ha_tse::~ha_tse() { - if (m_tse_buf != nullptr) { - tse_free_buf(&m_tch, m_tse_buf); - m_tse_buf = nullptr; +ha_ctc::~ha_ctc() { + if (m_ctc_buf != nullptr) { + ctc_free_buf(&m_tch, m_ctc_buf); + m_ctc_buf = nullptr; } if (m_read_buf != nullptr && !is_single_run_mode()) { - tse_free_buf(&m_tch, m_read_buf); + ctc_free_buf(&m_tch, m_read_buf); m_read_buf = nullptr; } @@ -2381,14 +2381,14 @@ ha_tse::~ha_tse() { free_blob_addrs(); } -int ha_tse::initialize() { +int ha_ctc::initialize() { THD *thd = ha_thd(); int ret = get_tch_in_handler_data(ht, thd, m_tch); if (ret != 0) { - tse_log_error("alloc session context mem error."); + ctc_log_error("alloc session context mem error."); return ret; } - m_tch.inst_id = ha_tse_get_inst_id(); + m_tch.inst_id = ha_ctc_get_inst_id(); m_tch.cursor_addr = INVALID_VALUE64; m_tch.cursor_ref = 0; m_tch.cursor_valid = false; @@ -2396,7 +2396,7 @@ int ha_tse::initialize() { return CT_SUCCESS; } -bool tse_is_temporary(const dd::Table *table_def) { +bool ctc_is_temporary(const dd::Table *table_def) { return table_def ? table_def->is_temporary() : true; } @@ -2427,14 +2427,14 @@ bool tse_is_temporary(const dd::Table *table_def) { @retval 0 Success. */ -EXTER_ATTACK int ha_tse::open(const char *name, int, uint test_if_locked, const dd::Table *table_def) { +EXTER_ATTACK int ha_ctc::open(const char *name, int, uint test_if_locked, const dd::Table *table_def) { DBUG_TRACE; assert(table_share == table->s); THD *thd = ha_thd(); if (!(test_if_locked & (HA_OPEN_TMP_TABLE | HA_OPEN_INTERNAL_TABLE))) { if (table_share->m_part_info == nullptr) { - if (!(m_share = get_share())) { + if (!(m_share = get_share())) { return HA_ERR_OUT_OF_MEM; } } @@ -2443,9 +2443,9 @@ EXTER_ATTACK int ha_tse::open(const char *name, int, uint test_if_locked, const unlock_shared_ha_data(); if (ret != CT_SUCCESS) { if (table_share->m_part_info == nullptr) { - free_share(); + free_share(); } - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } } @@ -2459,10 +2459,10 @@ EXTER_ATTACK int ha_tse::open(const char *name, int, uint test_if_locked, const char user_name[SMALL_RECORD_SIZE] = {0}; char table_name[SMALL_RECORD_SIZE] = {0}; - bool is_tmp_table = tse_is_temporary(table_def); - tse_split_normalized_name(name, user_name, SMALL_RECORD_SIZE, table_name, SMALL_RECORD_SIZE, &is_tmp_table); + bool is_tmp_table = ctc_is_temporary(table_def); + ctc_split_normalized_name(name, user_name, SMALL_RECORD_SIZE, table_name, SMALL_RECORD_SIZE, &is_tmp_table); if (!is_tmp_table) { - tse_copy_name(table_name, table->s->table_name.str, SMALL_RECORD_SIZE); + ctc_copy_name(table_name, table->s->table_name.str, SMALL_RECORD_SIZE); } m_cantian_rec_len = get_cantian_record_length(table); @@ -2470,20 +2470,20 @@ EXTER_ATTACK int ha_tse::open(const char *name, int, uint test_if_locked, const m_max_batch_num = MAX_RECORD_SIZE / m_cantian_rec_len; m_max_batch_num = m_max_batch_num > UINT_MAX ? UINT_MAX : m_max_batch_num; // restricted by uint32 - update_member_tch(m_tch, tse_hton, thd); + update_member_tch(m_tch, ctc_hton, thd); key_used_on_scan = table_share->primary_key; // table_def can be null while index_merge using union, we can not get table_name by table_def - ct_errno_t ret = (ct_errno_t)tse_open_table(&m_tch, table_name, user_name); - update_sess_ctx_by_tch(m_tch, tse_hton, thd); + ct_errno_t ret = (ct_errno_t)ctc_open_table(&m_tch, table_name, user_name); + update_sess_ctx_by_tch(m_tch, ctc_hton, thd); check_error_code_to_mysql(ha_thd(), &ret); if (ret != CT_SUCCESS && !(test_if_locked & (HA_OPEN_TMP_TABLE | HA_OPEN_INTERNAL_TABLE)) && table_share->m_part_info == nullptr) { - free_share(); + free_share(); } - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } /** @@ -2501,7 +2501,7 @@ EXTER_ATTACK int ha_tse::open(const char *name, int, uint test_if_locked, const sql_base.cc, sql_select.cc and table.cc */ -int ha_tse::close(void) { +int ha_ctc::close(void) { DBUG_TRACE; THD *thd = ha_thd(); @@ -2510,7 +2510,7 @@ int ha_tse::close(void) { } if (m_share && table_share->m_part_info == nullptr) { - free_share(); + free_share(); } if (is_replay_ddl(thd)) { @@ -2522,19 +2522,19 @@ int ha_tse::close(void) { return 0; } - update_member_tch(m_tch, tse_hton, thd); + update_member_tch(m_tch, ctc_hton, thd); if (m_tch.ctx_addr == INVALID_VALUE64) { - tse_log_warning("[TSE_CLOSE_TABLE]:Close a table that is not open."); + ctc_log_warning("[CTC_CLOSE_TABLE]:Close a table that is not open."); return 0; } - ct_errno_t ret = (ct_errno_t)tse_close_table(&m_tch); + ct_errno_t ret = (ct_errno_t)ctc_close_table(&m_tch); check_error_code_to_mysql(ha_thd(), &ret); m_tch.ctx_addr = INVALID_VALUE64; - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } -int ha_tse::handle_auto_increment(bool &has_explicit_autoinc) { +int ha_ctc::handle_auto_increment(bool &has_explicit_autoinc) { THD *thd = ha_thd(); const Discrete_interval *insert_id_info; insert_id_for_cur_row = 0; @@ -2587,8 +2587,8 @@ int ha_tse::handle_auto_increment(bool &has_explicit_autoinc) { } @endcode - See ha_tina.cc for an tse of extracting all of the data as strings. - ha_berekly.cc has an tse of how to store it intact by "packing" it + See ha_tina.cc for an ctc of extracting all of the data as strings. + ha_berekly.cc has an ctc of how to store it intact by "packing" it for ha_berkeley's own native storage type. See the note for update_row() on auto_increments. This case also applies to @@ -2602,10 +2602,10 @@ int ha_tse::handle_auto_increment(bool &has_explicit_autoinc) { sql_insert.cc, sql_select.cc, sql_table.cc, sql_udf.cc and sql_update.cc */ #ifdef METADATA_NORMALIZED -EXTER_ATTACK int ha_tse::write_row(uchar *buf, bool write_through) { +EXTER_ATTACK int ha_ctc::write_row(uchar *buf, bool write_through) { #endif #ifndef METADATA_NORMALIZED -EXTER_ATTACK int ha_tse::write_row(uchar *buf) { +EXTER_ATTACK int ha_ctc::write_row(uchar *buf) { #endif DBUG_TRACE; THD *thd = ha_thd(); @@ -2614,7 +2614,7 @@ EXTER_ATTACK int ha_tse::write_row(uchar *buf) { return CT_SUCCESS; } - int cantian_record_buf_size = TSE_BUF_LEN; + int cantian_record_buf_size = CTC_BUF_LEN; uint16_t serial_column_offset = 0; int error_result = CT_SUCCESS; bool auto_inc_used = false; @@ -2631,7 +2631,7 @@ EXTER_ATTACK int ha_tse::write_row(uchar *buf) { } if (!m_rec_buf_4_writing) { - dml_flag_t flag = tse_get_dml_flag(thd, false, auto_inc_used, has_explicit_autoinc, false); + dml_flag_t flag = ctc_get_dml_flag(thd, false, auto_inc_used, has_explicit_autoinc, false); #ifdef METADATA_NORMALIZED flag.write_through = write_through; #endif @@ -2658,9 +2658,9 @@ EXTER_ATTACK int ha_tse::write_row(uchar *buf) { memset(cur_write_pos, 0, sizeof(row_head_t)); record_buf_info_t record_buf = {cur_write_pos, buf, &cantian_record_buf_size}; - update_member_tch(m_tch, tse_hton, thd, false); + update_member_tch(m_tch, ctc_hton, thd, false); error_result = mysql_record_to_cantian_record(*table, &record_buf, m_tch, &serial_column_offset); - update_sess_ctx_by_tch(m_tch, tse_hton, thd); // update for tse_knl_write_lob in mysql_record_to_cantian_record + update_sess_ctx_by_tch(m_tch, ctc_hton, thd); // update for ctc_knl_write_lob in mysql_record_to_cantian_record if (error_result != 0) { m_rec_buf_4_writing->reset(); @@ -2672,31 +2672,31 @@ EXTER_ATTACK int ha_tse::write_row(uchar *buf) { } -int ha_tse::convert_mysql_record_and_write_to_cantian(uchar *buf, int *cantian_record_buf_size, +int ha_ctc::convert_mysql_record_and_write_to_cantian(uchar *buf, int *cantian_record_buf_size, uint16_t *serial_column_offset, dml_flag_t flag) { int error_result; ct_errno_t ret; uint64_t cur_last_insert_id = 0; - if (m_tse_buf == nullptr) { - m_tse_buf = tse_alloc_buf(&m_tch, BIG_RECORD_SIZE); - if (m_tse_buf == nullptr) { - return convert_tse_error_code_to_mysql(ERR_ALLOC_MEMORY); + if (m_ctc_buf == nullptr) { + m_ctc_buf = ctc_alloc_buf(&m_tch, BIG_RECORD_SIZE); + if (m_ctc_buf == nullptr) { + return convert_ctc_error_code_to_mysql(ERR_ALLOC_MEMORY); } } - memset(m_tse_buf, 0, sizeof(row_head_t)); - record_buf_info_t record_buf = {m_tse_buf, buf, cantian_record_buf_size}; + memset(m_ctc_buf, 0, sizeof(row_head_t)); + record_buf_info_t record_buf = {m_ctc_buf, buf, cantian_record_buf_size}; - update_member_tch(m_tch, tse_hton, ha_thd()); + update_member_tch(m_tch, ctc_hton, ha_thd()); error_result = mysql_record_to_cantian_record(*table, &record_buf, m_tch, serial_column_offset); - update_sess_ctx_by_tch(m_tch, tse_hton, ha_thd()); // update for tse_knl_write_lob in mysql_record_to_cantian_record + update_sess_ctx_by_tch(m_tch, ctc_hton, ha_thd()); // update for ctc_knl_write_lob in mysql_record_to_cantian_record if (error_result != 0) { return error_result; } - update_member_tch(m_tch, tse_hton, ha_thd()); - record_info_t record_info = {m_tse_buf, (uint16_t)*cantian_record_buf_size, nullptr, nullptr}; - ret = (ct_errno_t)tse_write_row(&m_tch, &record_info, *serial_column_offset, &cur_last_insert_id, flag); - update_sess_ctx_by_tch(m_tch, tse_hton, ha_thd()); + update_member_tch(m_tch, ctc_hton, ha_thd()); + record_info_t record_info = {m_ctc_buf, (uint16_t)*cantian_record_buf_size, nullptr, nullptr}; + ret = (ct_errno_t)ctc_write_row(&m_tch, &record_info, *serial_column_offset, &cur_last_insert_id, flag); + update_sess_ctx_by_tch(m_tch, ctc_hton, ha_thd()); check_error_code_to_mysql(ha_thd(), &ret); if (table->next_number_field && buf == table->record[0] && !flag.has_explicit_autoinc) { @@ -2704,22 +2704,22 @@ int ha_tse::convert_mysql_record_and_write_to_cantian(uchar *buf, int *cantian_r insert_id_for_cur_row = cur_last_insert_id; } - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } -int ha_tse::bulk_insert_low(dml_flag_t flag, uint *dup_offset) { +int ha_ctc::bulk_insert_low(dml_flag_t flag, uint *dup_offset) { record_info_t record_info = {m_rec_buf_data, (uint16_t)m_cantian_rec_len, nullptr, nullptr}; - return tse_bulk_write(&m_tch, &record_info, m_rec_buf_4_writing->records(), dup_offset, flag, nullptr); + return ctc_bulk_write(&m_tch, &record_info, m_rec_buf_4_writing->records(), dup_offset, flag, nullptr); } -int ha_tse::bulk_insert() { +int ha_ctc::bulk_insert() { ct_errno_t ret; uint dup_offset = 0; THD *thd = ha_thd(); - dml_flag_t flag = tse_get_dml_flag(thd, false, false, false, false); - update_member_tch(m_tch, tse_hton, thd); + dml_flag_t flag = ctc_get_dml_flag(thd, false, false, false, false); + update_member_tch(m_tch, ctc_hton, thd); ret = (ct_errno_t)bulk_insert_low(flag, &dup_offset); - update_sess_ctx_by_tch(m_tch, tse_hton, thd); + update_sess_ctx_by_tch(m_tch, ctc_hton, thd); check_error_code_to_mysql(thd, &ret); if (ret != CT_SUCCESS) { @@ -2729,12 +2729,12 @@ int ha_tse::bulk_insert() { index_info_t index = {UINT_MAX, UINT_MAX}; cantian_record_to_mysql_record(*table, &index, &record_buf, m_tch, nullptr); } - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } return CT_SUCCESS; } -void ha_tse::start_bulk_insert(ha_rows rows) { +void ha_ctc::start_bulk_insert(ha_rows rows) { assert(m_rec_buf_4_writing == nullptr); THD *thd = ha_thd(); @@ -2743,7 +2743,7 @@ void ha_tse::start_bulk_insert(ha_rows rows) { } if (m_rec_buf_data == nullptr) { - m_rec_buf_data = (uchar *)my_malloc(PSI_NOT_INSTRUMENTED, MAX_RECORD_BUFFER_SIZE_TSE, MYF(MY_WME)); + m_rec_buf_data = (uchar *)my_malloc(PSI_NOT_INSTRUMENTED, MAX_RECORD_BUFFER_SIZE_CTC, MYF(MY_WME)); } if (rows == 1 || m_is_insert_dup || m_is_replace || m_ignore_dup || table->s->blob_fields > 0 || @@ -2754,7 +2754,7 @@ void ha_tse::start_bulk_insert(ha_rows rows) { m_rec_buf_4_writing = new Record_buffer{m_max_batch_num, (size_t)m_cantian_rec_len, m_rec_buf_data}; } -int ha_tse::end_bulk_insert() { +int ha_ctc::end_bulk_insert() { if (engine_ddl_passthru(ha_thd()) && is_create_table_check(ha_thd())) { return 0; } @@ -2791,7 +2791,7 @@ static bool check_if_update_primary_key(TABLE *table) { return false; } -int tse_cmp_key_values(TABLE *table, const uchar *old_data, const uchar *new_data, uint key_nr) { +int ctc_cmp_key_values(TABLE *table, const uchar *old_data, const uchar *new_data, uint key_nr) { if (key_nr == MAX_KEY) { return 0; } @@ -2823,7 +2823,7 @@ int tse_cmp_key_values(TABLE *table, const uchar *old_data, const uchar *new_dat @details Currently new_data will not have an updated auto_increament record. You can - do this for tse by doing: + do this for ctc by doing: @code @@ -2837,7 +2837,7 @@ int tse_cmp_key_values(TABLE *table, const uchar *old_data, const uchar *new_dat @see sql_select.cc, sql_acl.cc, sql_update.cc and sql_insert.cc */ -EXTER_ATTACK int ha_tse::update_row(const uchar *old_data, uchar *new_data) { +EXTER_ATTACK int ha_ctc::update_row(const uchar *old_data, uchar *new_data) { DBUG_TRACE; THD *thd = ha_thd(); @@ -2845,12 +2845,12 @@ EXTER_ATTACK int ha_tse::update_row(const uchar *old_data, uchar *new_data) { thd->lex->sql_command == SQLCOM_REPLACE_SELECT) ? true : m_is_replace; if (thd->lex->sql_command == SQLCOM_REPLACE || thd->lex->sql_command == SQLCOM_REPLACE_SELECT) { uint key_nr = table->file->errkey; - if (key_nr < MAX_KEY && tse_cmp_key_values(table, old_data, new_data, key_nr) != 0) { + if (key_nr < MAX_KEY && ctc_cmp_key_values(table, old_data, new_data, key_nr) != 0) { return HA_ERR_KEY_NOT_FOUND; } } - int cantian_new_record_buf_size = TSE_BUF_LEN; + int cantian_new_record_buf_size = CTC_BUF_LEN; uint16_t serial_column_offset = 0; ha_statistic_increment(&System_status_var::ha_update_count); @@ -2867,15 +2867,15 @@ EXTER_ATTACK int ha_tse::update_row(const uchar *old_data, uchar *new_data) { return HA_ERR_RECORD_IS_THE_SAME; } - if (m_tse_buf == nullptr) { - m_tse_buf = tse_alloc_buf(&m_tch, BIG_RECORD_SIZE); - if (m_tse_buf == nullptr) { - return convert_tse_error_code_to_mysql(ERR_ALLOC_MEMORY); + if (m_ctc_buf == nullptr) { + m_ctc_buf = ctc_alloc_buf(&m_tch, BIG_RECORD_SIZE); + if (m_ctc_buf == nullptr) { + return convert_ctc_error_code_to_mysql(ERR_ALLOC_MEMORY); } } - memset(m_tse_buf, 0, sizeof(row_head_t)); + memset(m_ctc_buf, 0, sizeof(row_head_t)); - record_buf_info_t record_buf = {m_tse_buf, new_data, &cantian_new_record_buf_size}; + record_buf_info_t record_buf = {m_ctc_buf, new_data, &cantian_new_record_buf_size}; ct_errno_t ret = (ct_errno_t)mysql_record_to_cantian_record(*table, &record_buf, m_tch, &serial_column_offset, &upd_fields); if (ret != CT_SUCCESS) { @@ -2887,14 +2887,14 @@ EXTER_ATTACK int ha_tse::update_row(const uchar *old_data, uchar *new_data) { } // (m_ignore_dup && m_is_replace) -> special case for load data ... replace into bool dup_update = m_is_insert_dup || (m_ignore_dup && m_is_replace); - dml_flag_t flag = tse_get_dml_flag(thd, m_is_replace, false, false, dup_update); + dml_flag_t flag = ctc_get_dml_flag(thd, m_is_replace, false, false, dup_update); if (!flag.no_foreign_key_check) { flag.no_cascade_check = flag.dd_update ? true : pre_check_for_cascade(true); } - ret = (ct_errno_t)tse_update_row(&m_tch, cantian_new_record_buf_size, m_tse_buf, + ret = (ct_errno_t)ctc_update_row(&m_tch, cantian_new_record_buf_size, m_ctc_buf, &upd_fields[0], upd_fields.size(), flag); check_error_code_to_mysql(thd, &ret); - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } /** @@ -2917,7 +2917,7 @@ EXTER_ATTACK int ha_tse::update_row(const uchar *old_data, uchar *new_data) { sql_acl.cc, sql_udf.cc, sql_delete.cc, sql_insert.cc and sql_select.cc */ -int ha_tse::delete_row(const uchar *buf) { +int ha_ctc::delete_row(const uchar *buf) { DBUG_TRACE; UNUSED_PARAM(buf); ha_statistic_increment(&System_status_var::ha_delete_count); @@ -2925,22 +2925,22 @@ int ha_tse::delete_row(const uchar *buf) { m_is_replace = (thd->lex->sql_command == SQLCOM_REPLACE || thd->lex->sql_command == SQLCOM_REPLACE_SELECT) ? true : m_is_replace; // m_is_insert_dup for on duplicate key update in partiton table when new row is in different partition - dml_flag_t flag = tse_get_dml_flag(thd, m_is_replace || m_is_insert_dup, false, false, false); + dml_flag_t flag = ctc_get_dml_flag(thd, m_is_replace || m_is_insert_dup, false, false, false); if (!flag.no_foreign_key_check) { flag.no_cascade_check = flag.dd_update ? true : pre_check_for_cascade(false); } - ct_errno_t ret = (ct_errno_t)tse_delete_row(&m_tch, table->s->reclength, flag); + ct_errno_t ret = (ct_errno_t)ctc_delete_row(&m_tch, table->s->reclength, flag); check_error_code_to_mysql(thd, &ret); - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } -bool ha_tse::is_record_buffer_wanted(ha_rows *const max_rows) const { +bool ha_ctc::is_record_buffer_wanted(ha_rows *const max_rows) const { *max_rows = 0; return false; } // @ref set_record_buffer -int ha_tse::set_prefetch_buffer() { +int ha_ctc::set_prefetch_buffer() { if (m_rec_buf) { delete m_rec_buf; m_rec_buf = nullptr; @@ -2954,22 +2954,22 @@ int ha_tse::set_prefetch_buffer() { // max rows that internal buf can support ha_rows max_rows = max_prefetch_num; // max rows that record buffer can support - max_rows = (max_rows > MAX_RECORD_BUFFER_SIZE_TSE / mysql_rec_length) ? - MAX_RECORD_BUFFER_SIZE_TSE / mysql_rec_length : max_rows; + max_rows = (max_rows > MAX_RECORD_BUFFER_SIZE_CTC / mysql_rec_length) ? + MAX_RECORD_BUFFER_SIZE_CTC / mysql_rec_length : max_rows; // max rows that limited by array in shared mem intf max_rows = (max_rows > max_prefetch_num - 1) ? max_prefetch_num - 1 : max_rows; // alloc m_rec_buf_data if (m_rec_buf_data == nullptr) { - m_rec_buf_data = (uchar *)my_malloc(PSI_NOT_INSTRUMENTED, MAX_RECORD_BUFFER_SIZE_TSE, MYF(MY_WME)); + m_rec_buf_data = (uchar *)my_malloc(PSI_NOT_INSTRUMENTED, MAX_RECORD_BUFFER_SIZE_CTC, MYF(MY_WME)); } if (m_rec_buf_data == nullptr) { - tse_log_error("alloc mem failed, m_rec_buf_data size(%u)", MAX_RECORD_BUFFER_SIZE_TSE); + ctc_log_error("alloc mem failed, m_rec_buf_data size(%u)", MAX_RECORD_BUFFER_SIZE_CTC); return ERR_ALLOC_MEMORY; } m_rec_buf = new Record_buffer{max_rows, mysql_rec_length, m_rec_buf_data}; - tse_log_note("prefetch record %llu", max_rows); + ctc_log_note("prefetch record %llu", max_rows); return CT_SUCCESS; } @@ -3003,7 +3003,7 @@ int ha_tse::set_prefetch_buffer() { */ // @ref row_prebuilt_t::can_prefetch_records() -bool ha_tse::can_prefetch_records() const { +bool ha_ctc::can_prefetch_records() const { // do not prefetch if set ctc_select_prefetch = false if (!ctc_select_prefetch) { return false; @@ -3042,7 +3042,7 @@ bool ha_tse::can_prefetch_records() const { @see sql_insert.cc, reference ha_federated::convert_row_to_internal_format in ha_federated.cc. */ -void ha_tse::update_blob_addrs(uchar *record) { +void ha_ctc::update_blob_addrs(uchar *record) { ptrdiff_t old_ptr = (ptrdiff_t)(record - table->record[0]); for (uint i = 0; i < table->s->blob_fields; i++) { uint field_no = table->s->blob_field[i]; @@ -3067,46 +3067,46 @@ void ha_tse::update_blob_addrs(uchar *record) { } } -void ha_tse::free_blob_addrs() { +void ha_ctc::free_blob_addrs() { for (auto addr : m_blob_addrs) { my_free(addr); } m_blob_addrs.clear(); } -void free_m_cond(tianchi_handler_t m_tch, tse_conds **conds) { - tse_conds *cond = *conds; +void free_m_cond(ctc_handler_t m_tch, ctc_conds **conds) { + ctc_conds *cond = *conds; if (cond == nullptr) { return; } if (cond->cond_list == nullptr) { if (cond->field_info.field_value != nullptr) { - tse_free_buf(&m_tch, (uint8_t *)(cond->field_info.field_value)); + ctc_free_buf(&m_tch, (uint8_t *)(cond->field_info.field_value)); cond->field_info.field_value = nullptr; } - tse_free_buf(&m_tch, (uint8_t *)cond); + ctc_free_buf(&m_tch, (uint8_t *)cond); *conds = nullptr; return; } - tse_conds *node = cond->cond_list->first; + ctc_conds *node = cond->cond_list->first; int size = cond->cond_list->elements; for (int i = 0; i < size; i++) { - tse_conds *tmp = node->next; + ctc_conds *tmp = node->next; free_m_cond(m_tch, &node); if (tmp == nullptr) { cond->cond_list->last = nullptr; - tse_free_buf(&m_tch, (uint8_t *)(cond->cond_list)); + ctc_free_buf(&m_tch, (uint8_t *)(cond->cond_list)); cond->cond_list = nullptr; - tse_free_buf(&m_tch, (uint8_t *)cond); + ctc_free_buf(&m_tch, (uint8_t *)cond); *conds = nullptr; } node = tmp; } } -int tse_fill_conds(tianchi_handler_t m_tch, const Item *pushed_cond, Field **field, - tse_conds *m_cond, bool no_backslash) { - memset(m_cond, 0, sizeof(tse_conds)); +int ctc_fill_conds(ctc_handler_t m_tch, const Item *pushed_cond, Field **field, + ctc_conds *m_cond, bool no_backslash) { + memset(m_cond, 0, sizeof(ctc_conds)); Item *items = const_cast(pushed_cond); return dfs_fill_conds(m_tch, items, field, m_cond, no_backslash); } @@ -3114,7 +3114,7 @@ int tse_fill_conds(tianchi_handler_t m_tch, const Item *pushed_cond, Field **fie /** @brief rnd_init() is called when the system wants the storage engine to do a table - scan. See the tse in the introduction at the top of this file to see when + scan. See the ctc in the introduction at the top of this file to see when rnd_init() is called. @details @@ -3126,7 +3126,7 @@ int tse_fill_conds(tianchi_handler_t m_tch, const Item *pushed_cond, Field **fie sql_update.cc */ -int ha_tse::rnd_init(bool) { +int ha_ctc::rnd_init(bool) { DBUG_TRACE; m_index_sorted = false; THD *thd = ha_thd(); @@ -3148,27 +3148,27 @@ int ha_tse::rnd_init(bool) { action = EXP_CURSOR_ACTION_UPDATE; } } - update_member_tch(m_tch, tse_hton, ha_thd()); + update_member_tch(m_tch, ctc_hton, ha_thd()); m_tch.cursor_valid = false; - ret = (ct_errno_t)tse_rnd_init(&m_tch, action, get_select_mode(), m_cond); - update_sess_ctx_by_tch(m_tch, tse_hton, ha_thd()); + ret = (ct_errno_t)ctc_rnd_init(&m_tch, action, get_select_mode(), m_cond); + update_sess_ctx_by_tch(m_tch, ctc_hton, ha_thd()); if (!(table_share->tmp_table != NO_TMP_TABLE && table_share->tmp_table != TRANSACTIONAL_TMP_TABLE) || !is_log_table) { - update_sess_ctx_cursor_by_tch(m_tch, tse_hton, thd); + update_sess_ctx_cursor_by_tch(m_tch, ctc_hton, thd); } check_error_code_to_mysql(ha_thd(), &ret); cnvrt_to_mysql_record = cantian_record_to_mysql_record; reset_rec_buf(); - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } /** @brief alloc m_read_buf for select. */ -int ha_tse::tse_alloc_tse_buf_4_read() { +int ha_ctc::ctc_alloc_ctc_buf_4_read() { // no need alloc/copy/free record in single run mode if (is_single_run_mode()) { m_read_buf = nullptr; @@ -3179,9 +3179,9 @@ int ha_tse::tse_alloc_tse_buf_4_read() { return CT_SUCCESS; } - m_read_buf = tse_alloc_buf(&m_tch, BIG_RECORD_SIZE); + m_read_buf = ctc_alloc_buf(&m_tch, BIG_RECORD_SIZE); if (m_read_buf == nullptr) { - return convert_tse_error_code_to_mysql(ERR_ALLOC_MEMORY); + return convert_ctc_error_code_to_mysql(ERR_ALLOC_MEMORY); } return CT_SUCCESS; } @@ -3201,7 +3201,7 @@ int ha_tse::tse_alloc_tse_buf_4_read() { filesort.cc, records.cc, sql_handler.cc, sql_select.cc, sql_table.cc and sql_update.cc */ -int ha_tse::rnd_next(uchar *buf) { +int ha_ctc::rnd_next(uchar *buf) { DBUG_TRACE; if (unlikely(!m_rec_buf || m_rec_buf->records() == 0)) { @@ -3217,9 +3217,9 @@ int ha_tse::rnd_next(uchar *buf) { if (!m_rec_buf || m_rec_buf->max_records() == 0) { int ret = CT_SUCCESS; ct_errno_t ct_ret = CT_SUCCESS; - TSE_RETURN_IF_NOT_ZERO(tse_alloc_tse_buf_4_read()); + CTC_RETURN_IF_NOT_ZERO(ctc_alloc_ctc_buf_4_read()); record_info_t record_info = {m_read_buf, 0, nullptr, nullptr}; - ct_ret = (ct_errno_t)tse_rnd_next(&m_tch, &record_info); + ct_ret = (ct_errno_t)ctc_rnd_next(&m_tch, &record_info); ret = process_cantian_record(buf, &record_info, ct_ret, HA_ERR_END_OF_FILE); return ret; } @@ -3246,7 +3246,7 @@ int ha_tse::rnd_next(uchar *buf) { } } - int mysql_ret = prefetch_and_fill_record_buffer(buf, tse_rnd_prefetch); + int mysql_ret = prefetch_and_fill_record_buffer(buf, ctc_rnd_prefetch); if (mysql_ret != 0) { set_my_errno(mysql_ret); return mysql_ret; @@ -3275,9 +3275,9 @@ int ha_tse::rnd_next(uchar *buf) { @see filesort.cc, sql_select.cc, sql_delete.cc and sql_update.cc */ -void ha_tse::position(const uchar *) { +void ha_ctc::position(const uchar *) { if (cur_pos_in_buf == INVALID_MAX_UINT32) { - tse_position(&m_tch, ref, ref_length); + ctc_position(&m_tch, ref, ref_length); return; } assert(cur_pos_in_buf < max_prefetch_num); @@ -3298,18 +3298,18 @@ void ha_tse::position(const uchar *) { @see filesort.cc, records.cc, sql_insert.cc, sql_select.cc and sql_update.cc */ -EXTER_ATTACK int ha_tse::rnd_pos(uchar *buf, uchar *pos) { +EXTER_ATTACK int ha_ctc::rnd_pos(uchar *buf, uchar *pos) { DBUG_TRACE; ha_statistic_increment(&System_status_var::ha_read_rnd_count); int ret = CT_SUCCESS; ct_errno_t ct_ret = CT_SUCCESS; - TSE_RETURN_IF_NOT_ZERO(tse_alloc_tse_buf_4_read()); + CTC_RETURN_IF_NOT_ZERO(ctc_alloc_ctc_buf_4_read()); record_info_t record_info = {m_read_buf, 0, nullptr, nullptr}; uint key_len = ref_length; - if (IS_TSE_PART(m_tch.part_id)) { + if (IS_CTC_PART(m_tch.part_id)) { key_len -= PARTITION_BYTES_IN_POS; } - ct_ret = (ct_errno_t)tse_rnd_pos(&m_tch, key_len, pos, &record_info); + ct_ret = (ct_errno_t)ctc_rnd_pos(&m_tch, key_len, pos, &record_info); ret = process_cantian_record(buf, &record_info, ct_ret, HA_ERR_KEY_NOT_FOUND); return ret; } @@ -3353,13 +3353,13 @@ EXTER_ATTACK int ha_tse::rnd_pos(uchar *buf, uchar *pos) { sql_show.cc, sql_table.cc, sql_union.cc and sql_update.cc */ -void ha_tse::info_low() { +void ha_ctc::info_low() { if (m_share && m_share->cbo_stats != nullptr) { - stats.records = m_share->cbo_stats->tse_cbo_stats_table->estimate_rows; + stats.records = m_share->cbo_stats->ctc_cbo_stats_table->estimate_rows; } } -int ha_tse::info(uint flag) { +int ha_ctc::info(uint flag) { DBUG_TRACE; THD *thd = ha_thd(); if (engine_ddl_passthru(thd) && (is_alter_table_copy(thd) || is_create_table_check(thd))) { @@ -3378,13 +3378,13 @@ int ha_tse::info(uint flag) { thd->lex->sql_command == SQLCOM_ANALYZE) { ret = (ct_errno_t)analyze(thd, nullptr); if (ret != CT_SUCCESS) { - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } } ret = (ct_errno_t)get_cbo_stats_4share(); if (ret != CT_SUCCESS) { - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } } @@ -3395,8 +3395,8 @@ int ha_tse::info(uint flag) { } if (flag & HA_STATUS_ERRKEY) { - char index_name[TSE_MAX_KEY_NAME_LENGTH + 1] = { 0 }; - ret = (ct_errno_t)tse_get_index_name(&m_tch, index_name); + char index_name[CTC_MAX_KEY_NAME_LENGTH + 1] = { 0 }; + ret = (ct_errno_t)ctc_get_index_name(&m_tch, index_name); if (ret == CT_SUCCESS) { for (uint i = 0; i < table->s->keys; i++) { @@ -3411,10 +3411,10 @@ int ha_tse::info(uint flag) { } } - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } -int ha_tse::analyze(THD *thd, HA_CHECK_OPT *) { +int ha_ctc::analyze(THD *thd, HA_CHECK_OPT *) { if (engine_ddl_passthru(thd)) { if (m_share) { @@ -3428,42 +3428,42 @@ int ha_tse::analyze(THD *thd, HA_CHECK_OPT *) { } char user_name_str[SMALL_RECORD_SIZE] = { 0 }; - tse_copy_name(user_name_str, thd->lex->query_tables->get_db_name(), SMALL_RECORD_SIZE); + ctc_copy_name(user_name_str, thd->lex->query_tables->get_db_name(), SMALL_RECORD_SIZE); - ct_errno_t ret = (ct_errno_t)tse_analyze_table( + ct_errno_t ret = (ct_errno_t)ctc_analyze_table( &m_tch, user_name_str, thd->lex->query_tables->table_name, THDVAR(thd, sampling_ratio)); check_error_code_to_mysql(thd, &ret); if (ret == CT_SUCCESS && m_share && table_share->m_part_info == nullptr) { m_share->need_fetch_cbo = true; } - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } -int ha_tse::optimize(THD *thd, HA_CHECK_OPT *) +int ha_ctc::optimize(THD *thd, HA_CHECK_OPT *) { if (engine_ddl_passthru(thd)) { return 0; } - tse_ddl_stack_mem stack_mem(0); - update_member_tch(m_tch, tse_hton, thd); + ctc_ddl_stack_mem stack_mem(0); + update_member_tch(m_tch, ctc_hton, thd); ddl_ctrl_t ddl_ctrl = {{0}, {0}, {0}, 0, 0, m_tch, ctc_instance_id, false, 0}; FILL_USER_INFO_WITH_THD(ddl_ctrl, thd); ct_errno_t ret = (ct_errno_t)fill_rebuild_index_req(table, thd, &ddl_ctrl, &stack_mem); if (ret != 0) { - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } - void *tse_ddl_req_msg_mem = stack_mem.get_buf(); - if (tse_ddl_req_msg_mem == nullptr) { + void *ctc_ddl_req_msg_mem = stack_mem.get_buf(); + if (ctc_ddl_req_msg_mem == nullptr) { return HA_ERR_OUT_OF_MEM; } - tse_register_trx(tse_hton, thd); - ret = (ct_errno_t)tse_alter_table(tse_ddl_req_msg_mem, &ddl_ctrl); - tse_ddl_hook_cantian_error("tse_optimize_table_cantian_error", thd, &ddl_ctrl, &ret); + ctc_register_trx(ctc_hton, thd); + ret = (ct_errno_t)ctc_alter_table(ctc_ddl_req_msg_mem, &ddl_ctrl); + ctc_ddl_hook_cantian_error("ctc_optimize_table_cantian_error", thd, &ddl_ctrl, &ret); m_tch = ddl_ctrl.tch; - update_sess_ctx_by_tch(m_tch, tse_hton, thd); + update_sess_ctx_by_tch(m_tch, ctc_hton, thd); - return tse_ddl_handle_fault("tse_optimize table", thd, &ddl_ctrl, ret); + return ctc_ddl_handle_fault("ctc_optimize table", thd, &ddl_ctrl, ret); } /** @@ -3475,7 +3475,7 @@ int ha_tse::optimize(THD *thd, HA_CHECK_OPT *) @see ha_innodb.cc */ -int ha_tse::extra(enum ha_extra_function operation) { +int ha_ctc::extra(enum ha_extra_function operation) { DBUG_TRACE; switch (operation) { @@ -3506,7 +3506,7 @@ int ha_tse::extra(enum ha_extra_function operation) { return 0; } -int ha_tse::reset() { +int ha_ctc::reset() { m_is_replace = false; m_is_insert_dup = false; m_is_covering_index = false; @@ -3522,7 +3522,7 @@ int ha_tse::reset() { return 0; } -int ha_tse::rnd_end() { +int ha_ctc::rnd_end() { DBUG_TRACE; THD *thd = ha_thd(); if (engine_ddl_passthru(thd) && (is_alter_table_copy(thd) || is_create_table_check(thd) || @@ -3533,9 +3533,9 @@ int ha_tse::rnd_end() { int ret = CT_SUCCESS; if ((table_share->tmp_table != NO_TMP_TABLE && table_share->tmp_table != TRANSACTIONAL_TMP_TABLE) || is_log_table) { - ct_errno_t tse_ret = (ct_errno_t)tse_rnd_end(&m_tch); - check_error_code_to_mysql(ha_thd(), &tse_ret); - ret = convert_tse_error_code_to_mysql(tse_ret); + ct_errno_t ctc_ret = (ct_errno_t)ctc_rnd_end(&m_tch); + check_error_code_to_mysql(ha_thd(), &ctc_ret); + ret = convert_ctc_error_code_to_mysql(ctc_ret); } m_tch.cursor_valid = false; @@ -3543,13 +3543,13 @@ int ha_tse::rnd_end() { return ret; } -int ha_tse::index_init(uint index, bool sorted) { +int ha_ctc::index_init(uint index, bool sorted) { DBUG_TRACE; ct_errno_t ret = (ct_errno_t)set_prefetch_buffer(); if (ret != CT_SUCCESS) { return ret; } - update_member_tch(m_tch, tse_hton, ha_thd(), false); + update_member_tch(m_tch, ctc_hton, ha_thd(), false); m_index_sorted = sorted; active_index = index; reset_rec_buf(); @@ -3562,14 +3562,14 @@ int ha_tse::index_init(uint index, bool sorted) { return CT_SUCCESS; } -int ha_tse::index_end() { +int ha_ctc::index_end() { DBUG_TRACE; active_index = MAX_KEY; int ret = CT_SUCCESS; if (table_share->tmp_table != NO_TMP_TABLE && table_share->tmp_table != TRANSACTIONAL_TMP_TABLE) { - ret = (ct_errno_t)tse_index_end(&m_tch); + ret = (ct_errno_t)ctc_index_end(&m_tch); assert(ret == CT_SUCCESS); } @@ -3580,11 +3580,11 @@ int ha_tse::index_end() { return ret; } -int ha_tse::process_cantian_record(uchar *buf, record_info_t *record_info, ct_errno_t ct_ret, int rc_ret) { +int ha_ctc::process_cantian_record(uchar *buf, record_info_t *record_info, ct_errno_t ct_ret, int rc_ret) { int ret = CT_SUCCESS; check_error_code_to_mysql(ha_thd(), &ct_ret); if (ct_ret != CT_SUCCESS) { - ret = convert_tse_error_code_to_mysql(ct_ret); + ret = convert_ctc_error_code_to_mysql(ct_ret); return ret; } @@ -3602,7 +3602,7 @@ int ha_tse::process_cantian_record(uchar *buf, record_info_t *record_info, ct_er return ret; } -EXTER_ATTACK int ha_tse::index_read(uchar *buf, const uchar *key, uint key_len, ha_rkey_function find_flag) { +EXTER_ATTACK int ha_ctc::index_read(uchar *buf, const uchar *key, uint key_len, ha_rkey_function find_flag) { DBUG_TRACE; ha_statistic_increment(&System_status_var::ha_read_key_count); @@ -3645,33 +3645,33 @@ EXTER_ATTACK int ha_tse::index_read(uchar *buf, const uchar *key, uint key_len, index_key_info.index_skip_scan = true; } #endif - int ret = tse_fill_index_key_info(table, key, key_len, end_range, &index_key_info, index_key_info.index_skip_scan); + int ret = ctc_fill_index_key_info(table, key, key_len, end_range, &index_key_info, index_key_info.index_skip_scan); if (ret != CT_SUCCESS) { - tse_log_error("ha_tse::index_read: fill index key info failed, ret(%d).", ret); + ctc_log_error("ha_ctc::index_read: fill index key info failed, ret(%d).", ret); return ret; } bool has_right_key = !index_key_info.index_skip_scan && end_range != nullptr && end_range->length != 0; dec4_t d4[MAX_KEY_COLUMNS * 2]; - ret = tse_convert_index_datatype(table, &index_key_info, has_right_key, d4); + ret = ctc_convert_index_datatype(table, &index_key_info, has_right_key, d4); if (ret != CT_SUCCESS) { - tse_log_error("ha_tse::index_read: convert data type for index search failed, ret(%d).", ret); + ctc_log_error("ha_ctc::index_read: convert data type for index search failed, ret(%d).", ret); return ret; } - TSE_RETURN_IF_NOT_ZERO(tse_alloc_tse_buf_4_read()); - update_member_tch(m_tch, tse_hton, ha_thd()); + CTC_RETURN_IF_NOT_ZERO(ctc_alloc_ctc_buf_4_read()); + update_member_tch(m_tch, ctc_hton, ha_thd()); record_info_t record_info = {m_read_buf, 0, nullptr, nullptr}; - attachable_trx_update_pre_addr(tse_hton, ha_thd(), &m_tch, true); - ct_errno_t ct_ret = (ct_errno_t)tse_index_read(&m_tch, &record_info, &index_key_info, + attachable_trx_update_pre_addr(ctc_hton, ha_thd(), &m_tch, true); + ct_errno_t ct_ret = (ct_errno_t)ctc_index_read(&m_tch, &record_info, &index_key_info, get_select_mode(), m_cond, m_is_replace || m_is_insert_dup); - update_sess_ctx_by_tch(m_tch, tse_hton, ha_thd()); - attachable_trx_update_pre_addr(tse_hton, ha_thd(), &m_tch, false); + update_sess_ctx_by_tch(m_tch, ctc_hton, ha_thd()); + attachable_trx_update_pre_addr(ctc_hton, ha_thd(), &m_tch, false); if (index_key_info.need_init) { if (!(table_share->tmp_table != NO_TMP_TABLE && table_share->tmp_table != TRANSACTIONAL_TMP_TABLE)) { - update_sess_ctx_cursor_by_tch(m_tch, tse_hton, ha_thd()); + update_sess_ctx_cursor_by_tch(m_tch, ctc_hton, ha_thd()); } index_key_info.need_init = false; } @@ -3680,22 +3680,22 @@ EXTER_ATTACK int ha_tse::index_read(uchar *buf, const uchar *key, uint key_len, return ret; } -EXTER_ATTACK int ha_tse::index_read_last(uchar *buf, const uchar *key_ptr, uint key_len) { +EXTER_ATTACK int ha_ctc::index_read_last(uchar *buf, const uchar *key_ptr, uint key_len) { return index_read(buf, key_ptr, key_len, HA_READ_PREFIX_LAST); } -int ha_tse::index_fetch(uchar *buf) { +int ha_ctc::index_fetch(uchar *buf) { DBUG_TRACE; int mysql_ret = 0; if (!m_rec_buf || m_rec_buf->max_records() == 0) { int ret = CT_SUCCESS; ct_errno_t ct_ret = CT_SUCCESS; - TSE_RETURN_IF_NOT_ZERO(tse_alloc_tse_buf_4_read()); + CTC_RETURN_IF_NOT_ZERO(ctc_alloc_ctc_buf_4_read()); record_info_t record_info = {m_read_buf, 0, nullptr, nullptr}; - attachable_trx_update_pre_addr(tse_hton, ha_thd(), &m_tch, true); - ct_ret = (ct_errno_t)tse_general_fetch(&m_tch, &record_info); - attachable_trx_update_pre_addr(tse_hton, ha_thd(), &m_tch, false); + attachable_trx_update_pre_addr(ctc_hton, ha_thd(), &m_tch, true); + ct_ret = (ct_errno_t)ctc_general_fetch(&m_tch, &record_info); + attachable_trx_update_pre_addr(ctc_hton, ha_thd(), &m_tch, false); ret = process_cantian_record(buf, &record_info, ct_ret, HA_ERR_END_OF_FILE); return ret; } @@ -3722,9 +3722,9 @@ int ha_tse::index_fetch(uchar *buf) { } } - attachable_trx_update_pre_addr(tse_hton, ha_thd(), &m_tch, true); - mysql_ret = prefetch_and_fill_record_buffer(buf, tse_general_prefetch); - attachable_trx_update_pre_addr(tse_hton, ha_thd(), &m_tch, false); + attachable_trx_update_pre_addr(ctc_hton, ha_thd(), &m_tch, true); + mysql_ret = prefetch_and_fill_record_buffer(buf, ctc_general_prefetch); + attachable_trx_update_pre_addr(ctc_hton, ha_thd(), &m_tch, false); if (mysql_ret != 0) { set_my_errno(mysql_ret); @@ -3733,7 +3733,7 @@ int ha_tse::index_fetch(uchar *buf) { return CT_SUCCESS; } -int ha_tse::index_next_same(uchar *buf, const uchar *, uint) { +int ha_ctc::index_next_same(uchar *buf, const uchar *, uint) { DBUG_TRACE; ha_statistic_increment(&System_status_var::ha_read_next_count); return index_fetch(buf); @@ -3743,7 +3743,7 @@ int ha_tse::index_next_same(uchar *buf, const uchar *, uint) { @brief Used to read forward through the index. */ -int ha_tse::index_next(uchar *buf) { +int ha_ctc::index_next(uchar *buf) { DBUG_TRACE; ha_statistic_increment(&System_status_var::ha_read_next_count); return index_fetch(buf); @@ -3753,7 +3753,7 @@ int ha_tse::index_next(uchar *buf) { @brief Used to read backwards through the index. */ -int ha_tse::index_prev(uchar *buf) { +int ha_ctc::index_prev(uchar *buf) { DBUG_TRACE; ha_statistic_increment(&System_status_var::ha_read_prev_count); return index_fetch(buf); @@ -3769,7 +3769,7 @@ int ha_tse::index_prev(uchar *buf) { @see opt_range.cc, opt_sum.cc, sql_handler.cc and sql_select.cc */ -int ha_tse::index_first(uchar *buf) { +int ha_ctc::index_first(uchar *buf) { DBUG_TRACE; ha_statistic_increment(&System_status_var::ha_read_first_count); int error = index_read(buf, nullptr, 0, HA_READ_AFTER_KEY); @@ -3790,7 +3790,7 @@ int ha_tse::index_first(uchar *buf) { @see opt_range.cc, opt_sum.cc, sql_handler.cc and sql_select.cc */ -int ha_tse::index_last(uchar *buf) { +int ha_ctc::index_last(uchar *buf) { DBUG_TRACE; ha_statistic_increment(&System_status_var::ha_read_last_count); int error = index_read(buf, nullptr, 0, HA_READ_BEFORE_KEY); @@ -3821,21 +3821,21 @@ int ha_tse::index_last(uchar *buf) { JOIN::reinit() in sql_select.cc and st_select_lex_unit::exec() in sql_union.cc. */ -int ha_tse::delete_all_rows() { +int ha_ctc::delete_all_rows() { DBUG_TRACE; THD *thd = ha_thd(); - update_member_tch(m_tch, tse_hton, thd); - dml_flag_t flag = tse_get_dml_flag(thd, false, false, false, false); + update_member_tch(m_tch, ctc_hton, thd); + dml_flag_t flag = ctc_get_dml_flag(thd, false, false, false, false); if (!flag.no_foreign_key_check) { flag.no_cascade_check = pre_check_for_cascade(false); } - ct_errno_t ret = (ct_errno_t)tse_delete_all_rows(&m_tch, flag); - update_sess_ctx_by_tch(m_tch, tse_hton, thd); + ct_errno_t ret = (ct_errno_t)ctc_delete_all_rows(&m_tch, flag); + update_sess_ctx_by_tch(m_tch, ctc_hton, thd); check_error_code_to_mysql(thd, &ret); if (thd->lex->is_ignore() && ret == ERR_ROW_IS_REFERENCED) { return 0; } - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } /** @@ -3845,8 +3845,8 @@ int ha_tse::delete_all_rows() { @details To get the the maximum number of indexes per table of DAAC */ -uint ha_tse::max_supported_keys() const { - return TSE_MAX_KEY_NUM; +uint ha_ctc::max_supported_keys() const { + return CTC_MAX_KEY_NUM; } /** @@ -3856,8 +3856,8 @@ uint ha_tse::max_supported_keys() const { @details To get the max possible key length of DAAC */ -uint ha_tse::max_supported_key_length() const { - return TSE_MAX_KEY_LENGTH; +uint ha_ctc::max_supported_key_length() const { + return CTC_MAX_KEY_LENGTH; } /** @@ -3867,8 +3867,8 @@ uint ha_tse::max_supported_key_length() const { @details To get the maximum columns of a composite index */ -uint ha_tse::max_supported_key_parts() const { - return TSE_MAX_KEY_PARTS; +uint ha_ctc::max_supported_key_parts() const { + return CTC_MAX_KEY_PARTS; } /** @@ -3878,12 +3878,12 @@ uint ha_tse::max_supported_key_parts() const { @details To get the maximum supported indexed columns length */ -uint ha_tse::max_supported_key_part_length( +uint ha_ctc::max_supported_key_part_length( HA_CREATE_INFO *create_info MY_ATTRIBUTE((unused))) const { - return TSE_MAX_KEY_PART_LENGTH; + return CTC_MAX_KEY_PART_LENGTH; } -enum_alter_inplace_result ha_tse::check_if_supported_inplace_alter( +enum_alter_inplace_result ha_ctc::check_if_supported_inplace_alter( TABLE *altered_table, Alter_inplace_info *ha_alter_info) { DBUG_TRACE; THD *thd = ha_thd(); @@ -3936,14 +3936,14 @@ enum_alter_inplace_result ha_tse::check_if_supported_inplace_alter( // if this table have any added columns uint32_t add_column_size = new_table_fields - old_table_fields + (drop_list_size - index_drop_count); - tse_log_system("[SUPPORT_INPLACE]:old_table_fields:%u new_table_fields:%u drop_list_size:%u create_list_size:%u add_column_size:%u, index_drop_count:%u", + ctc_log_system("[SUPPORT_INPLACE]:old_table_fields:%u new_table_fields:%u drop_list_size:%u create_list_size:%u add_column_size:%u, index_drop_count:%u", old_table_fields, new_table_fields, drop_list_size, create_list_size, add_column_size, index_drop_count); for (int i = add_column_size; i > 0; i--) { int32_t add_column_idx = create_list_size - i; if (add_column_idx < 0) { assert(0); - tse_log_error("[SUPPORT_INPLACE]: add_column_idx smaller than 0."); + ctc_log_error("[SUPPORT_INPLACE]: add_column_idx smaller than 0."); break; } @@ -3971,33 +3971,33 @@ enum_alter_inplace_result ha_tse::check_if_supported_inplace_alter( /** @brief - Construct tse range key based on mysql range key + Construct ctc range key based on mysql range key */ -void ha_tse::set_tse_range_key(tse_key *tse_key, key_range *mysql_range_key, bool is_min_key) { +void ha_ctc::set_ctc_range_key(ctc_key *ctc_key, key_range *mysql_range_key, bool is_min_key) { if (!mysql_range_key) { - tse_key->key = nullptr; - tse_key->cmp_type = CMP_TYPE_NULL; - tse_key->len = 0; - tse_key->col_map = 0; + ctc_key->key = nullptr; + ctc_key->cmp_type = CMP_TYPE_NULL; + ctc_key->len = 0; + ctc_key->col_map = 0; return; } - tse_key->col_map = mysql_range_key->keypart_map; - tse_key->key = mysql_range_key->key; - tse_key->len = mysql_range_key->length; + ctc_key->col_map = mysql_range_key->keypart_map; + ctc_key->key = mysql_range_key->key; + ctc_key->len = mysql_range_key->length; switch(mysql_range_key->flag) { case HA_READ_KEY_EXACT: - tse_key->cmp_type = CMP_TYPE_CLOSE_INTERNAL; + ctc_key->cmp_type = CMP_TYPE_CLOSE_INTERNAL; break; case HA_READ_BEFORE_KEY: - tse_key->cmp_type = CMP_TYPE_OPEN_INTERNAL; + ctc_key->cmp_type = CMP_TYPE_OPEN_INTERNAL; break; case HA_READ_AFTER_KEY: - tse_key->cmp_type = is_min_key ? CMP_TYPE_OPEN_INTERNAL : CMP_TYPE_CLOSE_INTERNAL; + ctc_key->cmp_type = is_min_key ? CMP_TYPE_OPEN_INTERNAL : CMP_TYPE_CLOSE_INTERNAL; break; default: - tse_key->cmp_type = CMP_TYPE_NULL; + ctc_key->cmp_type = CMP_TYPE_NULL; } } @@ -4014,35 +4014,35 @@ void ha_tse::set_tse_range_key(tse_key *tse_key, key_range *mysql_range_key, boo @see check_quick_keys() in opt_range.cc */ -ha_rows ha_tse::records_in_range(uint inx, key_range *min_key, +ha_rows ha_ctc::records_in_range(uint inx, key_range *min_key, key_range *max_key) { DBUG_TRACE; - tse_key tse_min_key; - tse_key tse_max_key; - set_tse_range_key(&tse_min_key, min_key, true); - set_tse_range_key(&tse_max_key, max_key, false); - if (tse_max_key.len < tse_min_key.len) { - tse_max_key.cmp_type = CMP_TYPE_NULL; - } else if (tse_max_key.len > tse_min_key.len) { - tse_min_key.cmp_type = CMP_TYPE_NULL; + ctc_key ctc_min_key; + ctc_key ctc_max_key; + set_ctc_range_key(&ctc_min_key, min_key, true); + set_ctc_range_key(&ctc_max_key, max_key, false); + if (ctc_max_key.len < ctc_min_key.len) { + ctc_max_key.cmp_type = CMP_TYPE_NULL; + } else if (ctc_max_key.len > ctc_min_key.len) { + ctc_min_key.cmp_type = CMP_TYPE_NULL; } - tse_range_key key = {&tse_min_key, &tse_max_key}; + ctc_range_key key = {&ctc_min_key, &ctc_max_key}; uint64_t n_rows = 0; double density; if (m_share) { if (!m_share->cbo_stats->is_updated) { - tse_log_debug("table %s has not been analyzed", table->alias); + ctc_log_debug("table %s has not been analyzed", table->alias); return 1; } - density = calc_density_one_table(inx, &key, m_share->cbo_stats->tse_cbo_stats_table, *table); + density = calc_density_one_table(inx, &key, m_share->cbo_stats->ctc_cbo_stats_table, *table); /* - * This is a safe-guard logic since we don't handle tse call error in this method, + * This is a safe-guard logic since we don't handle ctc call error in this method, * we need this to make sure that our optimizer continue to work even when we * miscalculated the density, and it's still prefer index read */ - n_rows += m_share->cbo_stats->tse_cbo_stats_table->estimate_rows * density; + n_rows += m_share->cbo_stats->ctc_cbo_stats_table->estimate_rows * density; } /* @@ -4055,34 +4055,34 @@ ha_rows ha_tse::records_in_range(uint inx, key_range *min_key, return n_rows; } -int ha_tse::records(ha_rows *num_rows) /*!< out: number of rows */ +int ha_ctc::records(ha_rows *num_rows) /*!< out: number of rows */ { DBUG_TRACE; uint64_t n_rows = 0; ct_errno_t ret = CT_SUCCESS; THD *thd = ha_thd(); - update_member_tch(m_tch, tse_hton, thd); + update_member_tch(m_tch, ctc_hton, thd); char *index_name = nullptr; if (active_index != MAX_KEY) { index_name = const_cast (table->key_info[active_index].name); } /* Count the records */ - ret = (ct_errno_t)tse_scan_records(&m_tch, &n_rows, index_name); - update_sess_ctx_by_tch(m_tch, tse_hton, thd); + ret = (ct_errno_t)ctc_scan_records(&m_tch, &n_rows, index_name); + update_sess_ctx_by_tch(m_tch, ctc_hton, thd); assert(ret == CT_SUCCESS); if (ret != CT_SUCCESS) { - tse_log_error("scan records failed with error code: %d", ret); - return convert_tse_error_code_to_mysql(ret); + ctc_log_error("scan records failed with error code: %d", ret); + return convert_ctc_error_code_to_mysql(ret); } *num_rows = n_rows; return 0; } -int ha_tse::records_from_index(ha_rows *num_rows, uint inx) +int ha_ctc::records_from_index(ha_rows *num_rows, uint inx) { active_index = inx; int ret = records(num_rows); @@ -4090,27 +4090,27 @@ int ha_tse::records_from_index(ha_rows *num_rows, uint inx) return ret; } -int32_t tse_get_cluster_role() { +int32_t ctc_get_cluster_role() { if (ctc_cluster_role != (int32_t)dis_cluster_role::DEFAULT) { return ctc_cluster_role; } - lock_guard lock(m_tse_cluster_role_mutex); + lock_guard lock(m_ctc_cluster_role_mutex); bool is_slave = false; bool cantian_cluster_ready = false; - int ret = tse_query_cluster_role(&is_slave, &cantian_cluster_ready); + int ret = ctc_query_cluster_role(&is_slave, &cantian_cluster_ready); if (ret != CT_SUCCESS || !cantian_cluster_ready) { ctc_cluster_role = (int32_t)dis_cluster_role::CLUSTER_NOT_READY; - tse_log_error("[Disaster Rocovery] tse_query_cluster_role failed with error code: %d, is_slave:%d, cantian_cluster_ready: %d", ret, is_slave, cantian_cluster_ready); + ctc_log_error("[Disaster Rocovery] ctc_query_cluster_role failed with error code: %d, is_slave:%d, cantian_cluster_ready: %d", ret, is_slave, cantian_cluster_ready); return ctc_cluster_role; } - tse_log_system("[Disaster Recovery] is_slave:%d, cantian_cluster_ready:%d", is_slave, cantian_cluster_ready); + ctc_log_system("[Disaster Recovery] is_slave:%d, cantian_cluster_ready:%d", is_slave, cantian_cluster_ready); // ctc_cluster_role: The character the node was before change // is_slave: The character the node is now // Only reset 'read_only's to false when the node turns from slave to master if (is_slave) { - tse_set_mysql_read_only(); + ctc_set_mysql_read_only(); } else if (ctc_cluster_role == (int32_t)dis_cluster_role::STANDBY) { - tse_reset_mysql_read_only(); + ctc_reset_mysql_read_only(); } ctc_cluster_role = is_slave ? (int32_t)dis_cluster_role::STANDBY : (int32_t)dis_cluster_role::PRIMARY; @@ -4126,11 +4126,11 @@ int32_t ctc_get_shm_file_num(uint32_t *shm_file_num) { extern uint32_t g_shm_file_num; int32_t ctc_get_shm_usage(uint32_t *ctc_shm_usage) { uint32_t size = (g_shm_file_num + 1) * MEM_CLASS_NUM * sizeof(uint32_t); - uint32_t *shm_usage = (uint32_t *)tse_alloc_buf(NULL, size); + uint32_t *shm_usage = (uint32_t *)ctc_alloc_buf(NULL, size); memset(shm_usage, 0, size); int ret = ctc_query_shm_usage(shm_usage); memcpy(ctc_shm_usage, shm_usage, size); - tse_free_buf(nullptr, (uint8_t *)shm_usage); + ctc_free_buf(nullptr, (uint8_t *)shm_usage); return ret; } @@ -4147,7 +4147,7 @@ int32_t ctc_get_shm_usage(uint32_t *ctc_shm_usage) { lock (if we don't want to use MySQL table locks at all), or add locks for many tables (like we do when we are using a MERGE handler). - Berkeley DB, for tse, changes all WRITE locks to TL_WRITE_ALLOW_WRITE + Berkeley DB, for ctc, changes all WRITE locks to TL_WRITE_ALLOW_WRITE (which signals that we are doing WRITES, but are still allowing other readers and writers). @@ -4171,7 +4171,7 @@ int32_t ctc_get_shm_usage(uint32_t *ctc_shm_usage) { @see get_lock_data() in lock.cc */ -THR_LOCK_DATA **ha_tse::store_lock(THD *, THR_LOCK_DATA **to, +THR_LOCK_DATA **ha_ctc::store_lock(THD *, THR_LOCK_DATA **to, enum thr_lock_type lock_type) { /* This method should not be called for internal temporary tables @@ -4184,7 +4184,7 @@ THR_LOCK_DATA **ha_tse::store_lock(THD *, THR_LOCK_DATA **to, DBUG_TRACE; // SELECT FOR SHARE / SELECT FOR UPDATE use exclusive lock - if ((lock_type == TL_READ_WITH_SHARED_LOCKS && tse_get_cluster_role() == (int32_t)dis_cluster_role::PRIMARY) || + if ((lock_type == TL_READ_WITH_SHARED_LOCKS && ctc_get_cluster_role() == (int32_t)dis_cluster_role::PRIMARY) || (lock_type >= TL_WRITE_ALLOW_WRITE && lock_type <= TL_WRITE_ONLY)) { m_select_lock = lock_mode::EXCLUSIVE_LOCK; } else { @@ -4210,7 +4210,7 @@ THR_LOCK_DATA **ha_tse::store_lock(THD *, THR_LOCK_DATA **to, the section "locking functions for mysql" in lock.cc; copy_data_between_tables() in sql_table.cc. */ -int ha_tse::external_lock(THD *thd, int lock_type) { +int ha_ctc::external_lock(THD *thd, int lock_type) { /* cantian dose not need mysql lock type, need long testing on this. May need map mysql lock type to cantian lock type in the future after figure @@ -4219,10 +4219,10 @@ int ha_tse::external_lock(THD *thd, int lock_type) { DBUG_TRACE; if (IS_METADATA_NORMALIZATION() && - tse_check_if_log_table(table_share->db.str, table_share->table_name.str)) { + ctc_check_if_log_table(table_share->db.str, table_share->table_name.str)) { is_log_table = true; if (!thd->in_sub_stmt) { - thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(tse_hton, thd); + thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(ctc_hton, thd); sess_ctx->sql_stat_start = 1; m_tch.sql_stat_start = 1; } @@ -4249,24 +4249,24 @@ int ha_tse::external_lock(THD *thd, int lock_type) { When thread has table lock explicitly, MySQL will execute an external lock for every new table it uses instead of external lock. 1. Without explicit table lock, MySQL execute external_lock, - we make external_lock to call start_stmt for tse_trx_begin. + we make external_lock to call start_stmt for ctc_trx_begin. 2. With explicit table lock, MySQL execute start_stmt directly. We will use this function to indicate CTC that a new SQL statement has started. @details - Called from ha_tse::external_lock(). + Called from ha_ctc::external_lock(). Called from sql_base.cc by check_lock_and_start_stmt(). @see sql_base.cc by check_lock_and_start_stmt(). */ -int ha_tse::start_stmt(THD *thd, thr_lock_type) { +int ha_ctc::start_stmt(THD *thd, thr_lock_type) { DBUG_TRACE; trans_register_ha(thd, false, ht, nullptr); // register trans to STMT - update_member_tch(m_tch, tse_hton, thd, false); - thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(tse_hton, thd); + update_member_tch(m_tch, ctc_hton, thd, false); + thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(ctc_hton, thd); if (sess_ctx == nullptr) { return HA_ERR_OUT_OF_MEM; } @@ -4282,7 +4282,7 @@ int ha_tse::start_stmt(THD *thd, thr_lock_type) { } // if session level transaction we only start one time - if (sess_ctx->is_tse_trx_begin) { + if (sess_ctx->is_ctc_trx_begin) { assert(m_tch.sess_addr != INVALID_VALUE64); assert(m_tch.thd_id == thd->thread_id()); return 0; @@ -4292,21 +4292,21 @@ int ha_tse::start_stmt(THD *thd, thr_lock_type) { uint32_t autocommit = !thd->in_multi_stmt_transaction_mode(); int isolation_level = isolation_level_to_cantian(thd_get_trx_isolation(thd)); - tianchi_trx_context_t trx_context = {isolation_level, autocommit, lock_wait_timeout, m_select_lock == lock_mode::EXCLUSIVE_LOCK}; + ctc_trx_context_t trx_context = {isolation_level, autocommit, lock_wait_timeout, m_select_lock == lock_mode::EXCLUSIVE_LOCK}; bool is_mysql_local = user_var_set(thd, "ctc_ddl_local_enabled"); - ct_errno_t ret = (ct_errno_t)tse_trx_begin(&m_tch, trx_context, is_mysql_local); + ct_errno_t ret = (ct_errno_t)ctc_trx_begin(&m_tch, trx_context, is_mysql_local); check_error_code_to_mysql(ha_thd(), &ret); - update_sess_ctx_by_tch(m_tch, tse_hton, thd); + update_sess_ctx_by_tch(m_tch, ctc_hton, thd); if (ret != CT_SUCCESS) { - tse_log_error("start trx failed with error code: %d", ret); - return convert_tse_error_code_to_mysql(ret); + ctc_log_error("start trx failed with error code: %d", ret); + return convert_ctc_error_code_to_mysql(ret); } - sess_ctx->is_tse_trx_begin = 1; + sess_ctx->is_ctc_trx_begin = 1; if (!autocommit) { trans_register_ha(thd, true, ht, nullptr); } @@ -4314,14 +4314,14 @@ int ha_tse::start_stmt(THD *thd, thr_lock_type) { } /** Return partitioning flags. */ -static uint tse_partition_flags() { +static uint ctc_partition_flags() { return (HA_CANNOT_PARTITION_FK | HA_TRUNCATE_PARTITION_PRECLOSE); } -struct st_mysql_storage_engine tse_storage_engine = { +struct st_mysql_storage_engine ctc_storage_engine = { MYSQL_HANDLERTON_INTERFACE_VERSION}; -static bool tse_get_tablespace_statistics( +static bool ctc_get_tablespace_statistics( const char *tablespace_name, const char *file_name, const dd::Properties &ts_se_private_data, ha_tablespace_statistics *stats) { UNUSED_PARAM(tablespace_name); @@ -4331,7 +4331,7 @@ static bool tse_get_tablespace_statistics( return true; } -EXTER_ATTACK bool tse_drop_database_with_err(handlerton *hton, char *path) { +EXTER_ATTACK bool ctc_drop_database_with_err(handlerton *hton, char *path) { THD *thd = current_thd; assert(thd != nullptr); @@ -4339,41 +4339,41 @@ EXTER_ATTACK bool tse_drop_database_with_err(handlerton *hton, char *path) { return false; } - tianchi_handler_t tch; + ctc_handler_t tch; int res = get_tch_in_handler_data(hton, thd, tch); if (res != CT_SUCCESS) { return true; } char db_name[SMALL_RECORD_SIZE] = { 0 }; - tse_split_normalized_name(path, db_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); + ctc_split_normalized_name(path, db_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); int error_code = 0; char error_message[ERROR_MESSAGE_LEN] = {0}; - /* tse_drop_tablespace_and_user接口内部新建session并自己释放 */ + /* ctc_drop_tablespace_and_user接口内部新建session并自己释放 */ string sql = string(thd->query().str).substr(0, thd->query().length); - int ret = tse_drop_tablespace_and_user( + int ret = ctc_drop_tablespace_and_user( &tch, db_name, sql.c_str(), thd->m_main_security_ctx.priv_user().str, thd->m_main_security_ctx.priv_host().str, &error_code, error_message); update_sess_ctx_by_tch(tch, hton, thd); - tse_log_system("[TSE_DROP_DB]: ret:%d, database(%s), error_code:%d, error_message:%s", + ctc_log_system("[CTC_DROP_DB]: ret:%d, database(%s), error_code:%d, error_message:%s", ret, db_name, error_code, error_message); if (ret != CT_SUCCESS) { - tse_log_error("drop database failed with error code: %d", convert_tse_error_code_to_mysql((ct_errno_t)ret)); + ctc_log_error("drop database failed with error code: %d", convert_ctc_error_code_to_mysql((ct_errno_t)ret)); cm_assert(0); } return false; } -EXTER_ATTACK void tse_drop_database(handlerton *hton, char *path) { - (void)tse_drop_database_with_err(hton, path); +EXTER_ATTACK void ctc_drop_database(handlerton *hton, char *path) { + (void)ctc_drop_database_with_err(hton, path); } -static int tse_check_tx_isolation() { +static int ctc_check_tx_isolation() { // 检查GLOBAL变量 enum_tx_isolation tx_isol = (enum_tx_isolation)global_system_variables.transaction_isolation; if (tx_isol == ISO_SERIALIZABLE || tx_isol == ISO_READ_UNCOMMITTED) { - tse_log_error("TSE init failed. GLOBAL transaction isolation can not " + ctc_log_error("CTC init failed. GLOBAL transaction isolation can not " "be SERIALIZABLE and READ-UNCOMMITTED. Please check system variable or my.cnf file."); return HA_ERR_INITIALIZATION; } @@ -4381,33 +4381,33 @@ static int tse_check_tx_isolation() { // 检查SESSION 变量 THD *thd = current_thd; if (thd && (thd->tx_isolation == ISO_SERIALIZABLE || thd->tx_isolation == ISO_READ_UNCOMMITTED)) { - tse_log_error("TSE init failed. SESSION transaction isolation can not " + ctc_log_error("CTC init failed. SESSION transaction isolation can not " "be SERIALIZABLE and READ-UNCOMMITTED. Please check system variable or my.cnf file."); return HA_ERR_INITIALIZATION; } return 0; } -static int tse_create_db(THD *thd, handlerton *hton) { +static int ctc_create_db(THD *thd, handlerton *hton) { if (engine_skip_ddl(thd)) { return CT_SUCCESS; } - tianchi_handler_t tch; - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); + ctc_handler_t tch; + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); - tse_ddl_broadcast_request broadcast_req {{0}, {0}, {0}, {0}, 0, 0, 0, 0, {0}}; + ctc_ddl_broadcast_request broadcast_req {{0}, {0}, {0}, {0}, 0, 0, 0, 0, {0}}; DBUG_EXECUTE_IF("core_before_create_tablespace_and_db", { assert(0); }); // 有锁的问题 string sql = string(thd->query().str).substr(0, thd->query().length); FILL_BROADCAST_BASE_REQ(broadcast_req, sql.c_str(), thd->m_main_security_ctx.priv_user().str, thd->m_main_security_ctx.priv_host().str, ctc_instance_id, tch.sql_command); - broadcast_req.options &= (~TSE_NOT_NEED_CANTIAN_EXECUTE); - int ret = tse_execute_mysql_ddl_sql(&tch, &broadcast_req, false); + broadcast_req.options &= (~CTC_NOT_NEED_CANTIAN_EXECUTE); + int ret = ctc_execute_mysql_ddl_sql(&tch, &broadcast_req, false); DBUG_EXECUTE_IF("core_after_create_tablespace_and_db", { assert(0); }); // 元数据不一致的问题 - tse_log_system("[TSE_BROARDCAST_CREATE_DB]:ret:%d, query:%s, user_name:%s, err_code:%d, broadcast_inst_id:%u, " - "conn_id:%u, tse_inst_id:%u", ret, broadcast_req.sql_str, broadcast_req.user_name, + ctc_log_system("[CTC_BROARDCAST_CREATE_DB]:ret:%d, query:%s, user_name:%s, err_code:%d, broadcast_inst_id:%u, " + "conn_id:%u, ctc_inst_id:%u", ret, broadcast_req.sql_str, broadcast_req.user_name, broadcast_req.err_code, broadcast_req.mysql_inst_id, tch.thd_id, tch.inst_id); update_sess_ctx_by_tch(tch, hton, thd); assert(ret == CT_SUCCESS); @@ -4415,7 +4415,7 @@ static int tse_create_db(THD *thd, handlerton *hton) { return ret; } -bool tse_binlog_log_query_with_err(handlerton *hton, THD *thd, +bool ctc_binlog_log_query_with_err(handlerton *hton, THD *thd, enum_binlog_command binlog_command, const char *query, uint query_length, const char *db, const char *table_name) { @@ -4427,16 +4427,16 @@ bool tse_binlog_log_query_with_err(handlerton *hton, THD *thd, return false; } if (binlog_command == LOGCOM_CREATE_DB) { - return tse_create_db(thd, hton); + return ctc_create_db(thd, hton); } return false; } -void tse_binlog_log_query(handlerton *hton, THD *thd, +void ctc_binlog_log_query(handlerton *hton, THD *thd, enum_binlog_command binlog_command, const char *query, uint query_length, const char *db, const char *table_name) { - (void)tse_binlog_log_query_with_err(hton, thd, binlog_command, query, query_length, db, table_name); + (void)ctc_binlog_log_query_with_err(hton, thd, binlog_command, query, query_length, db, table_name); } /** Return 0 on success and non-zero on failure. @@ -4452,30 +4452,30 @@ static bool ctc_show_status(handlerton *, THD *thd, stat_print_fn *stat_print, e return false; } -void tse_set_mysql_read_only() { - tse_log_system("[Disaster Recovecy] starting or initializing"); +void ctc_set_mysql_read_only() { + ctc_log_system("[Disaster Recovecy] starting or initializing"); super_read_only = true; read_only = true; opt_readonly = true; - tse_log_system("[Disaster Recovery] set super_read_only = true."); + ctc_log_system("[Disaster Recovery] set super_read_only = true."); } -void tse_reset_mysql_read_only() { - tse_log_system("[Disaster Recovecy] starting or initializing"); +void ctc_reset_mysql_read_only() { + ctc_log_system("[Disaster Recovecy] starting or initializing"); super_read_only = false; read_only = false; opt_readonly = false; - tse_log_system("[Disaster Recovery] set super_read_only = false."); + ctc_log_system("[Disaster Recovery] set super_read_only = false."); } -int tse_set_cluster_role_by_cantian(bool is_slave) { - lock_guard lock(m_tse_cluster_role_mutex); +int ctc_set_cluster_role_by_cantian(bool is_slave) { + lock_guard lock(m_ctc_cluster_role_mutex); if (is_slave) { ctc_cluster_role = (int32_t)dis_cluster_role::STANDBY; - tse_set_mysql_read_only(); + ctc_set_mysql_read_only(); } else { ctc_cluster_role = (int32_t)dis_cluster_role::PRIMARY; - tse_reset_mysql_read_only(); + ctc_reset_mysql_read_only(); } return 0; } @@ -4489,42 +4489,42 @@ bool is_single_run_mode() #endif } -void tse_set_metadata_switch() { // MySQL为元数据归一版本 - lock_guard lock(m_tse_metadata_normalization_mutex); +void ctc_set_metadata_switch() { // MySQL为元数据归一版本 + lock_guard lock(m_ctc_metadata_normalization_mutex); if (ctc_metadata_normalization != (int32_t)metadata_switchs::DEFAULT) { return; } bool cantian_metadata_switch = false; bool cantian_cluster_ready = false; - int ret = tse_search_metadata_status(&cantian_metadata_switch, &cantian_cluster_ready); + int ret = ctc_search_metadata_status(&cantian_metadata_switch, &cantian_cluster_ready); if (ret != CT_SUCCESS || !cantian_cluster_ready) { ctc_metadata_normalization = (int32_t)metadata_switchs::CLUSTER_NOT_READY; - tse_log_error("[tse_set_metadata_switch] tse_search_metadata_status failed with error code: %d, cantian_cluster_ready: %d", ret, cantian_cluster_ready); + ctc_log_error("[ctc_set_metadata_switch] ctc_search_metadata_status failed with error code: %d, cantian_cluster_ready: %d", ret, cantian_cluster_ready); return; } - tse_log_system("[tse_set_metadata_switch] mysql_metadata_switch: 1, cantian_metadata_switch: %d, cantian_cluster_ready: %d", cantian_metadata_switch, cantian_cluster_ready); + ctc_log_system("[ctc_set_metadata_switch] mysql_metadata_switch: 1, cantian_metadata_switch: %d, cantian_cluster_ready: %d", cantian_metadata_switch, cantian_cluster_ready); ctc_metadata_normalization = cantian_metadata_switch ? (int32_t)metadata_switchs::MATCH_META : (int32_t)metadata_switchs::NOT_MATCH; } -int32_t tse_get_metadata_switch() { +int32_t ctc_get_metadata_switch() { if (ctc_metadata_normalization != (int32_t)metadata_switchs::DEFAULT) { return ctc_metadata_normalization; } - lock_guard lock(m_tse_metadata_normalization_mutex); + lock_guard lock(m_ctc_metadata_normalization_mutex); if (ctc_metadata_normalization != (int32_t)metadata_switchs::DEFAULT) { return ctc_metadata_normalization; } bool mysql_metadata_switch = CHECK_HAS_MEMBER(handlerton, get_metadata_switch); bool cantian_metadata_switch = false; bool cantian_cluster_ready = false; - int ret = tse_search_metadata_status(&cantian_metadata_switch, &cantian_cluster_ready); + int ret = ctc_search_metadata_status(&cantian_metadata_switch, &cantian_cluster_ready); if (ret != CT_SUCCESS || !cantian_cluster_ready) { ctc_metadata_normalization = (int32_t)metadata_switchs::CLUSTER_NOT_READY; - tse_log_error("[tse_get_metadata_switch] tse_search_metadata_status failed with error code: %d, cantian_metadata_switch: %d, cantian_cluster_ready: %d", ret, cantian_metadata_switch, cantian_cluster_ready); + ctc_log_error("[ctc_get_metadata_switch] ctc_search_metadata_status failed with error code: %d, cantian_metadata_switch: %d, cantian_cluster_ready: %d", ret, cantian_metadata_switch, cantian_cluster_ready); return ctc_metadata_normalization; } - tse_log_system("[tse_get_metadata_switch] cantian_metadata_switch: %d, cantian_cluster_ready: %d", cantian_metadata_switch, cantian_cluster_ready); + ctc_log_system("[ctc_get_metadata_switch] cantian_metadata_switch: %d, cantian_cluster_ready: %d", cantian_metadata_switch, cantian_cluster_ready); ctc_metadata_normalization = (mysql_metadata_switch == cantian_metadata_switch) ? (mysql_metadata_switch ? (int32_t)metadata_switchs::MATCH_META : (int32_t)metadata_switchs::MATCH_NO_META) : (int32_t)metadata_switchs::NOT_MATCH; return ctc_metadata_normalization; @@ -4534,28 +4534,28 @@ int32_t tse_get_metadata_switch() { /** Check metadata init status in CTC. */ -static int tse_get_metadata_status() { +static int ctc_get_metadata_status() { DBUG_TRACE; bool is_exists; int ret = 0; - ct_errno_t begin = (ct_errno_t)tse_check_db_table_exists("mysql", "", &is_exists); + ct_errno_t begin = (ct_errno_t)ctc_check_db_table_exists("mysql", "", &is_exists); if (begin != CT_SUCCESS) { - tse_log_error("check metadata init start failed with error code: %d", begin); - return convert_tse_error_code_to_mysql(begin); + ctc_log_error("check metadata init start failed with error code: %d", begin); + return convert_ctc_error_code_to_mysql(begin); } ret = is_exists ? 1 : 0; - ct_errno_t end = (ct_errno_t)tse_check_db_table_exists("sys", "sys_config", &is_exists); + ct_errno_t end = (ct_errno_t)ctc_check_db_table_exists("sys", "sys_config", &is_exists); if (end != CT_SUCCESS) { - tse_log_error("check metadata init end failed with error code: %d", end); - return convert_tse_error_code_to_mysql(end); + ctc_log_error("check metadata init end failed with error code: %d", end); + return convert_ctc_error_code_to_mysql(end); } ret = is_exists ? 2 : ret; return ret; } -static int tse_init_tablespace(List *tablespaces) +static int ctc_init_tablespace(List *tablespaces) { DBUG_TRACE; const size_t len = 30 + sizeof("id=;flags=;server_version=;space_version=;state=normal"); @@ -4570,12 +4570,12 @@ static int tse_init_tablespace(List *tablespaces) return 0; } -static bool tse_ddse_dict_init( +static bool ctc_ddse_dict_init( dict_init_mode_t dict_init_mode, uint version, List *tables, List *tablespaces) { DBUG_TRACE; - tse_log_system("[CTC_INIT]: begin tse_ddse_dict_init."); + ctc_log_system("[CTC_INIT]: begin ctc_ddse_dict_init."); assert(tables && tables->is_empty()); assert(tablespaces && tablespaces->is_empty()); @@ -4588,7 +4588,7 @@ static bool tse_ddse_dict_init( return true; } - if (tse_init_tablespace(tablespaces)) { + if (ctc_init_tablespace(tablespaces)) { return true; } @@ -4692,7 +4692,7 @@ static bool tse_ddse_dict_init( tables->push_back(innodb_index_stats); tables->push_back(innodb_ddl_log); - tse_log_system("[CTC_INIT]:end init dict!"); + ctc_log_system("[CTC_INIT]:end init dict!"); return false; } @@ -4705,116 +4705,116 @@ static bool is_dd_table_id(uint16_t id) { return (s_dd_table_ids.find(id) != s_dd_table_ids.end()); } -static void tse_dict_register_dd_table_id(dd::Object_id dd_table_id) { +static void ctc_dict_register_dd_table_id(dd::Object_id dd_table_id) { DBUG_TRACE; s_dd_table_ids.insert(dd_table_id); return; } -static bool tse_dict_recover(dict_recovery_mode_t, uint){ +static bool ctc_dict_recover(dict_recovery_mode_t, uint){ DBUG_TRACE; return false; } -static bool tse_dict_get_server_version(uint *version) { +static bool ctc_dict_get_server_version(uint *version) { DBUG_TRACE; *version = MYSQL_VERSION_ID; return false; } -static bool tse_dict_set_server_version() { +static bool ctc_dict_set_server_version() { DBUG_TRACE; return false; } -static void tse_dict_cache_reset(const char *, const char *) { +static void ctc_dict_cache_reset(const char *, const char *) { DBUG_TRACE; return; } -static void tse_dict_cache_reset_tables_and_tablespaces() { +static void ctc_dict_cache_reset_tables_and_tablespaces() { DBUG_TRACE; return; } -static int tse_op_before_load_meta(THD *thd) { +static int ctc_op_before_load_meta(THD *thd) { bool need_forward = true; - return tse_check_lock_instance(thd, need_forward); + return ctc_check_lock_instance(thd, need_forward); } -static int tse_op_after_load_meta(THD *thd) { - return tse_check_unlock_instance(thd); +static int ctc_op_after_load_meta(THD *thd) { + return ctc_check_unlock_instance(thd); } -static bool tse_dict_readonly() { +static bool ctc_dict_readonly() { return false; } template -static typename std::enable_if::type set_hton_members(T *tse_hton) { - tse_hton->get_inst_id = ha_tse_get_inst_id; - tse_hton->get_metadata_switch = tse_get_metadata_switch; - tse_hton->set_metadata_switch = tse_set_metadata_switch; - tse_hton->get_metadata_status = tse_get_metadata_status; - tse_hton->op_before_load_meta = tse_op_before_load_meta; - tse_hton->op_after_load_meta = tse_op_after_load_meta; - tse_hton->drop_database = tse_drop_database_with_err; - tse_hton->binlog_log_query = tse_binlog_log_query_with_err; - tse_hton->get_cluster_role = tse_get_cluster_role; +static typename std::enable_if::type set_hton_members(T *ctc_hton) { + ctc_hton->get_inst_id = ha_ctc_get_inst_id; + ctc_hton->get_metadata_switch = ctc_get_metadata_switch; + ctc_hton->set_metadata_switch = ctc_set_metadata_switch; + ctc_hton->get_metadata_status = ctc_get_metadata_status; + ctc_hton->op_before_load_meta = ctc_op_before_load_meta; + ctc_hton->op_after_load_meta = ctc_op_after_load_meta; + ctc_hton->drop_database = ctc_drop_database_with_err; + ctc_hton->binlog_log_query = ctc_binlog_log_query_with_err; + ctc_hton->get_cluster_role = ctc_get_cluster_role; } template -static typename std::enable_if::type set_hton_members(T *tse_hton) { - tse_hton->drop_database = tse_drop_database; - tse_hton->binlog_log_query = tse_binlog_log_query; +static typename std::enable_if::type set_hton_members(T *ctc_hton) { + ctc_hton->drop_database = ctc_drop_database; + ctc_hton->binlog_log_query = ctc_binlog_log_query; } -extern int (*tse_init)(); -extern int (*tse_deinit)(); +extern int (*ctc_init)(); +extern int (*ctc_deinit)(); -static int tse_init_func(void *p) { +static int ctc_init_func(void *p) { DBUG_TRACE; - tse_hton = (handlerton *)p; - tse_hton->state = SHOW_OPTION_YES; - tse_hton->db_type = (legacy_db_type)30; - tse_hton->create = tse_create_handler; - tse_hton->is_supported_system_table = tse_is_supported_system_table; - tse_hton->check_fk_column_compat = tse_check_fk_column_compat; - tse_hton->commit = tse_commit; - tse_hton->rollback = tse_rollback; - tse_hton->savepoint_set = tse_set_savepoint; - tse_hton->savepoint_rollback = tse_rollback_savepoint; - tse_hton->savepoint_release = tse_release_savepoint; - tse_hton->close_connection = tse_close_connect; - tse_hton->kill_connection = tse_kill_connection; - tse_hton->notify_exclusive_mdl = tse_notify_exclusive_mdl; - tse_hton->notify_alter_table = tse_notify_alter_table; - tse_hton->start_consistent_snapshot = tse_start_trx_and_assign_scn; - tse_hton->partition_flags = tse_partition_flags; - tse_hton->flags = HTON_SUPPORTS_FOREIGN_KEYS | HTON_CAN_RECREATE | HTON_SUPPORTS_ATOMIC_DDL; + ctc_hton = (handlerton *)p; + ctc_hton->state = SHOW_OPTION_YES; + ctc_hton->db_type = (legacy_db_type)30; + ctc_hton->create = ctc_create_handler; + ctc_hton->is_supported_system_table = ctc_is_supported_system_table; + ctc_hton->check_fk_column_compat = ctc_check_fk_column_compat; + ctc_hton->commit = ctc_commit; + ctc_hton->rollback = ctc_rollback; + ctc_hton->savepoint_set = ctc_set_savepoint; + ctc_hton->savepoint_rollback = ctc_rollback_savepoint; + ctc_hton->savepoint_release = ctc_release_savepoint; + ctc_hton->close_connection = ctc_close_connect; + ctc_hton->kill_connection = ctc_kill_connection; + ctc_hton->notify_exclusive_mdl = ctc_notify_exclusive_mdl; + ctc_hton->notify_alter_table = ctc_notify_alter_table; + ctc_hton->start_consistent_snapshot = ctc_start_trx_and_assign_scn; + ctc_hton->partition_flags = ctc_partition_flags; + ctc_hton->flags = HTON_SUPPORTS_FOREIGN_KEYS | HTON_CAN_RECREATE | HTON_SUPPORTS_ATOMIC_DDL; // TODO: HTON_SUPPORTS_TABLE_ENCRYPTION 表空间 tablespace加密功能暂时不做支持，后面会考虑添加。 - tse_hton->foreign_keys_flags = HTON_FKS_WITH_PREFIX_PARENT_KEYS | + ctc_hton->foreign_keys_flags = HTON_FKS_WITH_PREFIX_PARENT_KEYS | HTON_FKS_NEED_DIFFERENT_PARENT_AND_SUPPORTING_KEYS | HTON_FKS_WITH_EXTENDED_PARENT_KEYS; - tse_hton->alter_tablespace = tsebase_alter_tablespace; - tse_hton->file_extensions = nullptr; - tse_hton->get_tablespace_statistics = tse_get_tablespace_statistics; - tse_hton->show_status = ctc_show_status; - tse_hton->ddse_dict_init = tse_ddse_dict_init; - tse_hton->dict_register_dd_table_id = tse_dict_register_dd_table_id; - tse_hton->dict_recover = tse_dict_recover; - tse_hton->dict_get_server_version = tse_dict_get_server_version; - tse_hton->dict_set_server_version = tse_dict_set_server_version; - tse_hton->dict_cache_reset = tse_dict_cache_reset; - tse_hton->dict_cache_reset_tables_and_tablespaces = tse_dict_cache_reset_tables_and_tablespaces; - tse_hton->is_dict_readonly = tse_dict_readonly; + ctc_hton->alter_tablespace = ctcbase_alter_tablespace; + ctc_hton->file_extensions = nullptr; + ctc_hton->get_tablespace_statistics = ctc_get_tablespace_statistics; + ctc_hton->show_status = ctc_show_status; + ctc_hton->ddse_dict_init = ctc_ddse_dict_init; + ctc_hton->dict_register_dd_table_id = ctc_dict_register_dd_table_id; + ctc_hton->dict_recover = ctc_dict_recover; + ctc_hton->dict_get_server_version = ctc_dict_get_server_version; + ctc_hton->dict_set_server_version = ctc_dict_set_server_version; + ctc_hton->dict_cache_reset = ctc_dict_cache_reset; + ctc_hton->dict_cache_reset_tables_and_tablespaces = ctc_dict_cache_reset_tables_and_tablespaces; + ctc_hton->is_dict_readonly = ctc_dict_readonly; #ifdef FEATURE_X_FOR_MYSQL_32 - tse_hton->push_to_engine = tse_push_to_engine; + ctc_hton->push_to_engine = ctc_push_to_engine; #endif - set_hton_members(tse_hton); - int ret = tse_init(); + set_hton_members(ctc_hton); + int ret = ctc_init(); if (ret != 0) { - tse_log_error("[CTC_INIT]: ctc storage engine plugin init failed:%d", ret); + ctc_log_error("[CTC_INIT]: ctc storage engine plugin init failed:%d", ret); return HA_ERR_INITIALIZATION; } @@ -4822,67 +4822,67 @@ static int tse_init_func(void *p) { // 主干非initialize_insecure模式，需要注册共享内存接收线程并等待参天启动完成 ret = srv_wait_instance_startuped(); if (ret != 0) { - tse_log_error("wait cantian instance startuped failed:%d", ret); + ctc_log_error("wait cantian instance startuped failed:%d", ret); return HA_ERR_INITIALIZATION; } - ret = tse_reg_instance(); + ret = ctc_reg_instance(); if (ret != 0) { - tse_log_error("[CTC_INIT]:ctc_reg_instance failed:%d", ret); + ctc_log_error("[CTC_INIT]:ctc_reg_instance failed:%d", ret); return HA_ERR_INITIALIZATION; } - ret = tse_check_tx_isolation(); + ret = ctc_check_tx_isolation(); if (ret != 0) { - tse_log_error("[CTC_INIT]:ctc_check_tx_isolation failed:%d", ret); + ctc_log_error("[CTC_INIT]:ctc_check_tx_isolation failed:%d", ret); return HA_ERR_INITIALIZATION; } - tse_get_cluster_role(); - tse_log_system("[CTC_INIT]:SUCCESS!"); + ctc_get_cluster_role(); + ctc_log_system("[CTC_INIT]:SUCCESS!"); return 0; } -static int tse_deinit_func(void *p) { +static int ctc_deinit_func(void *p) { // handler.cc:726 此处传的p固定为null, 不是handlerton，不能依赖这部分逻辑 UNUSED_PARAM(p); - tse_log_system( - "tse_deinit_func tse_ddl_req_msg_mem_use_heap_cnt:%u, " - "tse_ddl_req_msg_mem_max_size:%u.", - (uint32_t)tse_ddl_stack_mem::tse_ddl_req_msg_mem_use_heap_cnt, - (uint32_t)tse_ddl_stack_mem::tse_ddl_req_msg_mem_max_size); - tse_unreg_instance(); - return tse_deinit(); + ctc_log_system( + "ctc_deinit_func ctc_ddl_req_msg_mem_use_heap_cnt:%u, " + "ctc_ddl_req_msg_mem_max_size:%u.", + (uint32_t)ctc_ddl_stack_mem::ctc_ddl_req_msg_mem_use_heap_cnt, + (uint32_t)ctc_ddl_stack_mem::ctc_ddl_req_msg_mem_max_size); + ctc_unreg_instance(); + return ctc_deinit(); } -static SHOW_VAR tse_status[] = { +static SHOW_VAR ctc_status[] = { {nullptr, nullptr, SHOW_UNDEF, SHOW_SCOPE_UNDEF}}; -extern struct st_mysql_plugin g_tse_ddl_rewriter_plugin; +extern struct st_mysql_plugin g_ctc_ddl_rewriter_plugin; -const char *tse_hton_name = "CTC"; +const char *ctc_hton_name = "CTC"; #pragma GCC visibility push(default) -mysql_declare_plugin(ctc) g_tse_ddl_rewriter_plugin,{ +mysql_declare_plugin(ctc) g_ctc_ddl_rewriter_plugin,{ MYSQL_STORAGE_ENGINE_PLUGIN, - &tse_storage_engine, - tse_hton_name, + &ctc_storage_engine, + ctc_hton_name, PLUGIN_AUTHOR_ORACLE, "CTC storage engine", PLUGIN_LICENSE_GPL, - tse_init_func, + ctc_init_func, nullptr, - tse_deinit_func, + ctc_deinit_func, CTC_CLIENT_VERSION_NUMBER, - tse_status, - tse_system_variables, + ctc_status, + ctc_system_variables, nullptr, PLUGIN_OPT_ALLOW_EARLY, } mysql_declare_plugin_end; #pragma GCC visibility pop -void ha_tse::update_create_info(HA_CREATE_INFO *create_info) { +void ha_ctc::update_create_info(HA_CREATE_INFO *create_info) { if ((create_info->used_fields & HA_CREATE_USED_AUTO) || !table->found_next_number_field) { return; } @@ -4895,11 +4895,11 @@ void ha_tse::update_create_info(HA_CREATE_INFO *create_info) { int ret = 0; if (m_tch.ctx_addr == INVALID_VALUE64) { char user_name[SMALL_RECORD_SIZE] = { 0 }; - tse_split_normalized_name(table->s->normalized_path.str, user_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); - tse_copy_name(user_name, user_name, SMALL_RECORD_SIZE); - update_member_tch(m_tch, tse_hton, thd); - ret = tse_open_table(&m_tch, table->s->table_name.str, user_name); - update_sess_ctx_by_tch(m_tch, tse_hton, thd); + ctc_split_normalized_name(table->s->normalized_path.str, user_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); + ctc_copy_name(user_name, user_name, SMALL_RECORD_SIZE); + update_member_tch(m_tch, ctc_hton, thd); + ret = ctc_open_table(&m_tch, table->s->table_name.str, user_name); + update_sess_ctx_by_tch(m_tch, ctc_hton, thd); if (ret != 0) { create_info->auto_increment_value = (ulonglong)0; } @@ -4908,13 +4908,13 @@ void ha_tse::update_create_info(HA_CREATE_INFO *create_info) { uint64_t inc_value = 0; uint16_t auto_inc_step = thd->variables.auto_increment_increment; uint16_t auto_inc_offset = thd->variables.auto_increment_offset; - update_member_tch(m_tch, tse_hton, thd); + update_member_tch(m_tch, ctc_hton, thd); dml_flag_t flag; flag.auto_inc_offset = auto_inc_offset; flag.auto_inc_step = auto_inc_step; flag.auto_increase = false; - ret = tse_get_serial_value(&m_tch, &inc_value, flag); - update_sess_ctx_by_tch(m_tch, tse_hton, thd); + ret = ctc_get_serial_value(&m_tch, &inc_value, flag); + update_sess_ctx_by_tch(m_tch, ctc_hton, thd); if (ret != 0) { create_info->auto_increment_value = (ulonglong)0; } else { @@ -4943,7 +4943,7 @@ void ha_tse::update_create_info(HA_CREATE_INFO *create_info) { @see delete_table and ha_create_table() in handler.cc */ -EXTER_ATTACK int ha_tse::delete_table(const char *full_path_name, const dd::Table *table_def) { +EXTER_ATTACK int ha_ctc::delete_table(const char *full_path_name, const dd::Table *table_def) { THD *thd = ha_thd(); ct_errno_t ret = CT_SUCCESS; @@ -4962,37 +4962,37 @@ EXTER_ATTACK int ha_tse::delete_table(const char *full_path_name, const dd::Tabl } if (table_def != nullptr && table_def->is_persistent()) { - tse_register_trx(ht, thd); + ctc_register_trx(ht, thd); } - update_member_tch(m_tch, tse_hton, thd); + update_member_tch(m_tch, ctc_hton, thd); ddl_ctrl_t ddl_ctrl = {{0}, {0}, {0}, 0, 0, m_tch, ctc_instance_id, false, 0}; FILL_USER_INFO_WITH_THD(ddl_ctrl, thd); - tse_ddl_stack_mem stack_mem(0); + ctc_ddl_stack_mem stack_mem(0); int mysql_ret = fill_delete_table_req(full_path_name, table_def, thd, &ddl_ctrl, &stack_mem); if (mysql_ret != CT_SUCCESS) { return mysql_ret; } - void *tse_ddl_req_msg_mem = stack_mem.get_buf(); - if (tse_ddl_req_msg_mem == nullptr) { + void *ctc_ddl_req_msg_mem = stack_mem.get_buf(); + if (ctc_ddl_req_msg_mem == nullptr) { return HA_ERR_OUT_OF_MEM; } - tse_log_note("tse_drop_table enter"); - ret = (ct_errno_t)tse_drop_table(tse_ddl_req_msg_mem, &ddl_ctrl); - tse_log_note("tse_drop_table finish"); - tse_ddl_hook_cantian_error("tse_drop_table_cantian_error", thd, &ddl_ctrl, &ret); + ctc_log_note("ctc_drop_table enter"); + ret = (ct_errno_t)ctc_drop_table(ctc_ddl_req_msg_mem, &ddl_ctrl); + ctc_log_note("ctc_drop_table finish"); + ctc_ddl_hook_cantian_error("ctc_drop_table_cantian_error", thd, &ddl_ctrl, &ret); m_tch = ddl_ctrl.tch; - update_sess_ctx_by_tch(m_tch, tse_hton, thd); - return tse_ddl_handle_fault("tse_drop_table", thd, &ddl_ctrl, ret, full_path_name, HA_ERR_WRONG_TABLE_NAME); + update_sess_ctx_by_tch(m_tch, ctc_hton, thd); + return ctc_ddl_handle_fault("ctc_drop_table", thd, &ddl_ctrl, ret, full_path_name, HA_ERR_WRONG_TABLE_NAME); } static map> - g_tse_ddl_ignore_cantian_errors = { - {"tse_create_table_cantian_error", {ERR_DUPLICATE_TABLE}}, // 创建表，自动忽略参天表已经存在的错误 - {"tse_drop_table_cantian_error", {ERR_TABLE_OR_VIEW_NOT_EXIST}}, // 删除表，自动忽略参天表不存在的错误 - {"tse_rename_table_cantian_error", {ERR_TABLE_OR_VIEW_NOT_EXIST}}, // rename表，自动忽略参天表不存在的错误 - {"tse_alter_table_cantian_error", {ERR_OBJECT_EXISTS,ERR_COLUMN_NOT_EXIST}}}; + g_ctc_ddl_ignore_cantian_errors = { + {"ctc_create_table_cantian_error", {ERR_DUPLICATE_TABLE}}, // 创建表，自动忽略参天表已经存在的错误 + {"ctc_drop_table_cantian_error", {ERR_TABLE_OR_VIEW_NOT_EXIST}}, // 删除表，自动忽略参天表不存在的错误 + {"ctc_rename_table_cantian_error", {ERR_TABLE_OR_VIEW_NOT_EXIST}}, // rename表，自动忽略参天表不存在的错误 + {"ctc_alter_table_cantian_error", {ERR_OBJECT_EXISTS,ERR_COLUMN_NOT_EXIST}}}; -void tse_ddl_hook_cantian_error(const char *tag, THD *thd, ddl_ctrl_t *ddl_ctrl, +void ctc_ddl_hook_cantian_error(const char *tag, THD *thd, ddl_ctrl_t *ddl_ctrl, ct_errno_t *ret) { bool ignore_error = false; @@ -5005,9 +5005,9 @@ void tse_ddl_hook_cantian_error(const char *tag, THD *thd, ddl_ctrl_t *ddl_ctrl, return; } - auto st = g_tse_ddl_ignore_cantian_errors.find(tag); - if (*ret != 0 && st != g_tse_ddl_ignore_cantian_errors.end() && st->second.count(*ret) > 0) { - tse_log_system( + auto st = g_ctc_ddl_ignore_cantian_errors.find(tag); + if (*ret != 0 && st != g_ctc_ddl_ignore_cantian_errors.end() && st->second.count(*ret) > 0) { + ctc_log_system( "tag:%s cantian ret:%d ignore by ignore_cantian_error_code, " "sql:%s, table_name:%s, error_message:%s", tag, *ret, thd->query().str, thd->lex->query_tables->table_name, @@ -5015,19 +5015,19 @@ void tse_ddl_hook_cantian_error(const char *tag, THD *thd, ddl_ctrl_t *ddl_ctrl, *ret = (ct_errno_t)0; } } -int tse_ddl_handle_fault(const char *tag, const THD *thd, +int ctc_ddl_handle_fault(const char *tag, const THD *thd, const ddl_ctrl_t *ddl_ctrl, ct_errno_t ret, const char *param, int fix_ret) { if (ret != CT_SUCCESS) { - tse_log_system("[TSE_DDL_RES]:tag ret:%d, msg_len:%u, sql:%s, param:%s, error_message:%s", + ctc_log_system("[CTC_DDL_RES]:tag ret:%d, msg_len:%u, sql:%s, param:%s, error_message:%s", ret, (uint32_t)(ddl_ctrl->msg_len), thd->query().str, param == nullptr ? "" : param, ddl_ctrl->error_msg); RETURN_IF_OOM(ret); - int32_t error = convert_tse_error_code_to_mysql(ret); + int32_t error = convert_ctc_error_code_to_mysql(ret); if (error != HA_ERR_GENERIC) { return error; } else if (strlen(ddl_ctrl->error_msg) > 0) { - tse_print_cantian_err_msg(ddl_ctrl, ret); + ctc_print_cantian_err_msg(ddl_ctrl, ret); } else { my_error(ER_DISALLOWED_OPERATION, MYF(0), UN_SUPPORT_DDL, thd->query().str); } @@ -5036,7 +5036,7 @@ int tse_ddl_handle_fault(const char *tag, const THD *thd, } return error; } else { - tse_log_system("[TSE_DDL_RES]:%s success, ret: %d, sql:%s", tag, ret, thd->query().str); + ctc_log_system("[CTC_DDL_RES]:%s success, ret: %d, sql:%s", tag, ret, thd->query().str); return ret; } } @@ -5078,23 +5078,23 @@ int tse_ddl_handle_fault(const char *tag, const THD *thd, @retval 0 Success. @retval non-0 Error. */ -EXTER_ATTACK int ha_tse::create(const char *name, TABLE *form, HA_CREATE_INFO *create_info, +EXTER_ATTACK int ha_ctc::create(const char *name, TABLE *form, HA_CREATE_INFO *create_info, dd::Table *table_def) { THD *thd = ha_thd(); ct_errno_t ret = CT_SUCCESS; if (check_unsupported_operation(thd, create_info)) { - tse_log_system("Unsupported operation. sql = %s", thd->query().str); + ctc_log_system("Unsupported operation. sql = %s", thd->query().str); return HA_ERR_WRONG_COMMAND; } /* copy algorithm is used when ha_create is called by mysql_alter_table */ - bool is_tmp_table = create_info->options & HA_LEX_CREATE_TMP_TABLE || tse_is_temporary(table_def); + bool is_tmp_table = create_info->options & HA_LEX_CREATE_TMP_TABLE || ctc_is_temporary(table_def); if (thd->lex->sql_command != SQLCOM_CREATE_TABLE && thd->lex->sql_command != SQLCOM_CREATE_VIEW && thd->lex->alter_info) { if (is_tmp_table) { - tse_log_system("Unsupported operation. sql = %s", thd->query().str); + ctc_log_system("Unsupported operation. sql = %s", thd->query().str); return HA_ERR_NOT_ALLOWED_COMMAND; } // do not move this under engine_ddl_passthru(thd) function @@ -5107,26 +5107,26 @@ EXTER_ATTACK int ha_tse::create(const char *name, TABLE *form, HA_CREATE_INFO *c char db_name[SMALL_RECORD_SIZE] = {0}; char table_name[SMALL_RECORD_SIZE] = {0}; - tse_split_normalized_name(name, db_name, SMALL_RECORD_SIZE, table_name, SMALL_RECORD_SIZE, &is_tmp_table); + ctc_split_normalized_name(name, db_name, SMALL_RECORD_SIZE, table_name, SMALL_RECORD_SIZE, &is_tmp_table); if (!is_tmp_table) { - TSE_RETURN_IF_NOT_ZERO(check_tse_identifier_name(table_def->name().c_str())); - tse_copy_name(table_name, const_cast(table_def->name().c_str()), SMALL_RECORD_SIZE); + CTC_RETURN_IF_NOT_ZERO(check_ctc_identifier_name(table_def->name().c_str())); + ctc_copy_name(table_name, const_cast(table_def->name().c_str()), SMALL_RECORD_SIZE); } if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE)) { - tse_register_trx(ht, thd); + ctc_register_trx(ht, thd); } if (thd->lex->sql_command == SQLCOM_TRUNCATE) { - return ha_tse_truncate_table(&m_tch, thd, db_name, table_name, is_tmp_table); + return ha_ctc_truncate_table(&m_tch, thd, db_name, table_name, is_tmp_table); } if (get_cantian_record_length(form) > CT_MAX_RECORD_LENGTH) { return HA_ERR_TOO_BIG_ROW; } - tse_ddl_stack_mem stack_mem(0); - update_member_tch(m_tch, tse_hton, thd); + ctc_ddl_stack_mem stack_mem(0); + update_member_tch(m_tch, ctc_hton, thd); ddl_ctrl_t ddl_ctrl = {{0}, {0}, {0}, 0, 0, m_tch, ctc_instance_id, false, 0}; FILL_USER_INFO_WITH_THD(ddl_ctrl, thd); @@ -5136,9 +5136,9 @@ EXTER_ATTACK int ha_tse::create(const char *name, TABLE *form, HA_CREATE_INFO *c uint32_t table_flags = 0; if (is_tmp_table) { - table_flags |= TSE_TMP_TABLE; + table_flags |= CTC_TMP_TABLE; if (create_info->options & HA_LEX_CREATE_INTERNAL_TMP_TABLE) { - table_flags |= TSE_INTERNAL_TMP_TABLE; + table_flags |= CTC_INTERNAL_TMP_TABLE; } ddl_ctrl.table_flags = table_flags; } @@ -5147,12 +5147,12 @@ EXTER_ATTACK int ha_tse::create(const char *name, TABLE *form, HA_CREATE_INFO *c return ret; } - void *tse_ddl_req_msg_mem = stack_mem.get_buf(); - if (tse_ddl_req_msg_mem == nullptr) { + void *ctc_ddl_req_msg_mem = stack_mem.get_buf(); + if (ctc_ddl_req_msg_mem == nullptr) { return HA_ERR_OUT_OF_MEM; } - ret = (ct_errno_t)tse_create_table(tse_ddl_req_msg_mem, &ddl_ctrl); + ret = (ct_errno_t)ctc_create_table(ctc_ddl_req_msg_mem, &ddl_ctrl); if (ret == ERR_FUNCTION_NOT_EXIST) { char *err_msg; char *field_name = strtok_r(ddl_ctrl.error_msg, ",", &err_msg); @@ -5164,10 +5164,10 @@ EXTER_ATTACK int ha_tse::create(const char *name, TABLE *form, HA_CREATE_INFO *c return CT_ERROR; } } - tse_ddl_hook_cantian_error("tse_create_table_cantian_error", thd, &ddl_ctrl, &ret); + ctc_ddl_hook_cantian_error("ctc_create_table_cantian_error", thd, &ddl_ctrl, &ret); m_tch = ddl_ctrl.tch; - update_sess_ctx_by_tch(m_tch, tse_hton, thd); - return tse_ddl_handle_fault("tse_create_table", thd, &ddl_ctrl, ret); + update_sess_ctx_by_tch(m_tch, ctc_hton, thd); + return ctc_ddl_handle_fault("ctc_create_table", thd, &ddl_ctrl, ret); } /** Implementation of inplace_alter_table() @@ -5186,13 +5186,13 @@ EXTER_ATTACK int ha_tse::create(const char *name, TABLE *form, HA_CREATE_INFO *c @retval true Failure @retval false Success */ -bool ha_tse::inplace_alter_table(TABLE *altered_table, +bool ha_ctc::inplace_alter_table(TABLE *altered_table, Alter_inplace_info *ha_alter_info, const dd::Table *old_table_def, dd::Table *new_table_def) { if (old_table_def == nullptr || new_table_def == nullptr) { - tse_log_error( + ctc_log_error( "inplace_alter_table old_table_def:%p, or new_table_def:%p is NULL", old_table_def, new_table_def); return true; @@ -5203,7 +5203,7 @@ bool ha_tse::inplace_alter_table(TABLE *altered_table, ct_errno_t ret = CT_SUCCESS; if (check_unsupported_operation(thd, nullptr)) { - tse_log_system("Unsupported operation. sql = %s", thd->query().str); + ctc_log_system("Unsupported operation. sql = %s", thd->query().str); return true; } @@ -5217,8 +5217,8 @@ bool ha_tse::inplace_alter_table(TABLE *altered_table, return false; } - tse_ddl_stack_mem stack_mem(0); - update_member_tch(m_tch, tse_hton, thd); + ctc_ddl_stack_mem stack_mem(0); + update_member_tch(m_tch, ctc_hton, thd); ddl_ctrl_t ddl_ctrl = {{0}, {0}, {0}, 0, 0, m_tch, ctc_instance_id, false, 0}; FILL_USER_INFO_WITH_THD(ddl_ctrl, thd); if (alter_info->flags & Alter_info::ALTER_RECREATE) { @@ -5232,19 +5232,19 @@ bool ha_tse::inplace_alter_table(TABLE *altered_table, return true; } - void *tse_ddl_req_msg_mem = stack_mem.get_buf(); - if (tse_ddl_req_msg_mem == nullptr) { + void *ctc_ddl_req_msg_mem = stack_mem.get_buf(); + if (ctc_ddl_req_msg_mem == nullptr) { return true; } - tse_register_trx(ht, thd); - ret = (ct_errno_t)tse_alter_table(tse_ddl_req_msg_mem, &ddl_ctrl); - tse_ddl_hook_cantian_error("tse_alter_table_cantian_error", thd, &ddl_ctrl, &ret); + ctc_register_trx(ht, thd); + ret = (ct_errno_t)ctc_alter_table(ctc_ddl_req_msg_mem, &ddl_ctrl); + ctc_ddl_hook_cantian_error("ctc_alter_table_cantian_error", thd, &ddl_ctrl, &ret); m_tch = ddl_ctrl.tch; - update_sess_ctx_by_tch(m_tch, tse_hton, thd); - tse_ddl_handle_fault("tse_alter_table", thd, &ddl_ctrl, ret); + update_sess_ctx_by_tch(m_tch, ctc_hton, thd); + ctc_ddl_handle_fault("ctc_alter_table", thd, &ddl_ctrl, ret); // 这个地方alter table需要特殊处理返回值 if (ret != CT_SUCCESS) { - tse_alter_table_handle_fault(ret); + ctc_alter_table_handle_fault(ret); return true; } @@ -5266,7 +5266,7 @@ bool ha_tse::inplace_alter_table(TABLE *altered_table, @see mysql_rename_table() in sql_table.cc */ -EXTER_ATTACK int ha_tse::rename_table(const char *from, const char *to, +EXTER_ATTACK int ha_ctc::rename_table(const char *from, const char *to, const dd::Table *from_table_def, dd::Table *to_table_def) { THD *thd = ha_thd(); @@ -5281,8 +5281,8 @@ EXTER_ATTACK int ha_tse::rename_table(const char *from, const char *to, return HA_ERR_UNSUPPORTED; } - tse_ddl_stack_mem stack_mem(0); - update_member_tch(m_tch, tse_hton, thd); + ctc_ddl_stack_mem stack_mem(0); + update_member_tch(m_tch, ctc_hton, thd); ddl_ctrl_t ddl_ctrl = {{0}, {0}, {0}, 0, 0, m_tch, ctc_instance_id, false, 0}; FILL_USER_INFO_WITH_THD(ddl_ctrl, thd); if (is_alter_table_copy(thd)) { @@ -5294,24 +5294,24 @@ EXTER_ATTACK int ha_tse::rename_table(const char *from, const char *to, return ret; } - void *tse_ddl_req_msg_mem = stack_mem.get_buf(); - if(tse_ddl_req_msg_mem == nullptr) { + void *ctc_ddl_req_msg_mem = stack_mem.get_buf(); + if(ctc_ddl_req_msg_mem == nullptr) { return HA_ERR_OUT_OF_MEM; } - tse_register_trx(ht, thd); - ret = (ct_errno_t)tse_rename_table(tse_ddl_req_msg_mem, &ddl_ctrl); - tse_ddl_hook_cantian_error("tse_rename_table_cantian_error", thd, &ddl_ctrl, &ret); + ctc_register_trx(ht, thd); + ret = (ct_errno_t)ctc_rename_table(ctc_ddl_req_msg_mem, &ddl_ctrl); + ctc_ddl_hook_cantian_error("ctc_rename_table_cantian_error", thd, &ddl_ctrl, &ret); m_tch = ddl_ctrl.tch; - update_sess_ctx_by_tch(m_tch, tse_hton, thd); - return tse_ddl_handle_fault("tse_rename_table", thd, &ddl_ctrl, ret, to); + update_sess_ctx_by_tch(m_tch, ctc_hton, thd); + return ctc_ddl_handle_fault("ctc_rename_table", thd, &ddl_ctrl, ret, to); } -int ha_tse::check(THD *, HA_CHECK_OPT *) +int ha_ctc::check(THD *, HA_CHECK_OPT *) { return HA_ADMIN_OK; } -bool ha_tse::get_error_message(int error, String *buf) +bool ha_ctc::get_error_message(int error, String *buf) { if (error == HA_ERR_ROW_IS_REFERENCED) { buf->append(STRING_WITH_LEN("Record is referenced by child tables(")); @@ -5339,13 +5339,13 @@ bool ha_tse::get_error_message(int error, String *buf) return false; } -tse_select_mode_t ha_tse::get_select_mode() +ctc_select_mode_t ha_ctc::get_select_mode() { /* Set select mode for SKIP LOCKED / NOWAIT */ if (table->pos_in_table_list == nullptr) { return SELECT_ORDINARY; } - tse_select_mode_t mode; + ctc_select_mode_t mode; switch (table->pos_in_table_list->lock_descriptor().action) { case THR_SKIP: mode = SELECT_SKIP_LOCKED; @@ -5360,13 +5360,13 @@ tse_select_mode_t ha_tse::get_select_mode() return mode; } -int alloc_str_mysql_mem(tianchi_cbo_stats_t *cbo_stats, uint32_t part_num, TABLE *table) +int alloc_str_mysql_mem(ctc_cbo_stats_t *cbo_stats, uint32_t part_num, TABLE *table) { - uint32_t acc_gcol_num[TSE_MAX_COLUMNS] = {0}; + uint32_t acc_gcol_num[CTC_MAX_COLUMNS] = {0}; calc_accumulate_gcol_num(table->s->fields, table->s->field, acc_gcol_num); cbo_stats->col_type =(bool *)my_malloc(PSI_NOT_INSTRUMENTED, table->s->fields * sizeof(bool), MYF(MY_WME)); if (cbo_stats->col_type == nullptr) { - tse_log_error("alloc shm mem failed, cbo_stats->col_type(%lu)", table->s->fields * sizeof(bool)); + ctc_log_error("alloc shm mem failed, cbo_stats->col_type(%lu)", table->s->fields * sizeof(bool)); return ERR_ALLOC_MEMORY; } memset(cbo_stats->col_type, 0, table->s->fields * sizeof(bool)); @@ -5386,7 +5386,7 @@ int alloc_str_mysql_mem(tianchi_cbo_stats_t *cbo_stats, uint32_t part_num, TABLE uint32_t str_stats_mem_size = part_num * cbo_stats->num_str_cols * (STATS_HISTGRAM_MAX_SIZE + 2) * CBO_STRING_MAX_LEN; char *str_stats_mem = (char *)my_malloc(PSI_NOT_INSTRUMENTED, str_stats_mem_size, MYF(MY_WME)); if (str_stats_mem == nullptr) { - tse_log_error("alloc shm mem failed, str_stats_mem size(%u)", str_stats_mem_size); + ctc_log_error("alloc shm mem failed, str_stats_mem size(%u)", str_stats_mem_size); return ERR_ALLOC_MEMORY; } memset(str_stats_mem, 0, str_stats_mem_size); @@ -5399,11 +5399,11 @@ int alloc_str_mysql_mem(tianchi_cbo_stats_t *cbo_stats, uint32_t part_num, TABLE uint32_t ct_col_id = j - acc_gcol_num[j]; if (field->real_type() == MYSQL_TYPE_VARCHAR || field->real_type() == MYSQL_TYPE_VAR_STRING || field->real_type() == MYSQL_TYPE_STRING) { - cbo_stats->tse_cbo_stats_table[i].columns[ct_col_id].high_value.v_str = str_stats_mem; - cbo_stats->tse_cbo_stats_table[i].columns[ct_col_id].low_value.v_str = str_stats_mem + CBO_STRING_MAX_LEN; + cbo_stats->ctc_cbo_stats_table[i].columns[ct_col_id].high_value.v_str = str_stats_mem; + cbo_stats->ctc_cbo_stats_table[i].columns[ct_col_id].low_value.v_str = str_stats_mem + CBO_STRING_MAX_LEN; str_stats_mem = str_stats_mem + CBO_STRING_MAX_LEN * 2; for (uint k = 0; k < STATS_HISTGRAM_MAX_SIZE; k++) { - cbo_stats->tse_cbo_stats_table[i].columns[ct_col_id].column_hist[k].ep_value.v_str = str_stats_mem; + cbo_stats->ctc_cbo_stats_table[i].columns[ct_col_id].column_hist[k].ep_value.v_str = str_stats_mem; str_stats_mem = str_stats_mem + CBO_STRING_MAX_LEN; } } @@ -5412,51 +5412,51 @@ int alloc_str_mysql_mem(tianchi_cbo_stats_t *cbo_stats, uint32_t part_num, TABLE return CT_SUCCESS; } -int ha_tse::initialize_cbo_stats() +int ha_ctc::initialize_cbo_stats() { if (!m_share || m_share->cbo_stats != nullptr) { return CT_SUCCESS; } - m_share->cbo_stats = (tianchi_cbo_stats_t*)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(tianchi_cbo_stats_t), MYF(MY_WME)); + m_share->cbo_stats = (ctc_cbo_stats_t*)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(ctc_cbo_stats_t), MYF(MY_WME)); if (m_share->cbo_stats == nullptr) { - tse_log_error("alloc mem failed, m_share->cbo_stats size(%lu)", sizeof(tianchi_cbo_stats_t)); + ctc_log_error("alloc mem failed, m_share->cbo_stats size(%lu)", sizeof(ctc_cbo_stats_t)); return ERR_ALLOC_MEMORY; } *m_share->cbo_stats = {0, 0, 0, 0, 0, nullptr, 0, nullptr, nullptr}; - m_share->cbo_stats->tse_cbo_stats_table = - (tse_cbo_stats_table_t*)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(tse_cbo_stats_table_t), MYF(MY_WME)); - if (m_share->cbo_stats->tse_cbo_stats_table == nullptr) { - tse_log_error("alloc mem failed, m_share->cbo_stats->tse_cbo_stats_table(%lu)", sizeof(tse_cbo_stats_table_t)); + m_share->cbo_stats->ctc_cbo_stats_table = + (ctc_cbo_stats_table_t*)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(ctc_cbo_stats_table_t), MYF(MY_WME)); + if (m_share->cbo_stats->ctc_cbo_stats_table == nullptr) { + ctc_log_error("alloc mem failed, m_share->cbo_stats->ctc_cbo_stats_table(%lu)", sizeof(ctc_cbo_stats_table_t)); return ERR_ALLOC_MEMORY; } - m_share->cbo_stats->tse_cbo_stats_table->columns = - (tse_cbo_stats_column_t*)my_malloc(PSI_NOT_INSTRUMENTED, table->s->fields * sizeof(tse_cbo_stats_column_t), MYF(MY_WME)); - if (m_share->cbo_stats->tse_cbo_stats_table->columns == nullptr) { - tse_log_error("alloc mem failed, m_share->cbo_stats->tse_cbo_stats_table->columns size(%lu)", table->s->fields * sizeof(tse_cbo_stats_column_t)); + m_share->cbo_stats->ctc_cbo_stats_table->columns = + (ctc_cbo_stats_column_t*)my_malloc(PSI_NOT_INSTRUMENTED, table->s->fields * sizeof(ctc_cbo_stats_column_t), MYF(MY_WME)); + if (m_share->cbo_stats->ctc_cbo_stats_table->columns == nullptr) { + ctc_log_error("alloc mem failed, m_share->cbo_stats->ctc_cbo_stats_table->columns size(%lu)", table->s->fields * sizeof(ctc_cbo_stats_column_t)); return ERR_ALLOC_MEMORY; } for (uint col_id = 0; col_id < table->s->fields; col_id++) { - m_share->cbo_stats->tse_cbo_stats_table->columns[col_id].hist_count = 0; + m_share->cbo_stats->ctc_cbo_stats_table->columns[col_id].hist_count = 0; } ct_errno_t ret = (ct_errno_t)alloc_str_mysql_mem(m_share->cbo_stats, 1, table); if (ret != CT_SUCCESS) { - tse_log_error("m_share:tse alloc str mysql mem failed, ret:%d", ret); + ctc_log_error("m_share:ctc alloc str mysql mem failed, ret:%d", ret); } m_share->cbo_stats->ndv_keys = (uint32_t*)my_malloc(PSI_NOT_INSTRUMENTED, table->s->keys * sizeof(uint32_t) * MAX_KEY_COLUMNS, MYF(MY_WME)); if (m_share->cbo_stats->ndv_keys == nullptr) { - tse_log_error("alloc mem failed, m_share->cbo_stats->ndv_keys size(%lu)", table->s->keys * sizeof(uint32_t) * MAX_KEY_COLUMNS); + ctc_log_error("alloc mem failed, m_share->cbo_stats->ndv_keys size(%lu)", table->s->keys * sizeof(uint32_t) * MAX_KEY_COLUMNS); return ERR_ALLOC_MEMORY; } - m_share->cbo_stats->msg_len = table->s->fields * sizeof(tse_cbo_stats_column_t); + m_share->cbo_stats->msg_len = table->s->fields * sizeof(ctc_cbo_stats_column_t); m_share->cbo_stats->key_len = table->s->keys * sizeof(uint32_t) * MAX_KEY_COLUMNS; return CT_SUCCESS; } -int ha_tse::get_cbo_stats_4share() +int ha_ctc::get_cbo_stats_4share() { THD *thd = ha_thd(); int ret = CT_SUCCESS; @@ -5464,21 +5464,21 @@ int ha_tse::get_cbo_stats_4share() if (m_share && (m_share->need_fetch_cbo || now - m_share->get_cbo_time > ctc_update_analyze_time)) { if (m_tch.ctx_addr == INVALID_VALUE64) { char user_name[SMALL_RECORD_SIZE] = { 0 }; - tse_split_normalized_name(table->s->normalized_path.str, user_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); - tse_copy_name(user_name, user_name, SMALL_RECORD_SIZE); - update_member_tch(m_tch, tse_hton, thd); - ret = tse_open_table(&m_tch, table->s->table_name.str, user_name); - update_sess_ctx_by_tch(m_tch, tse_hton, thd); + ctc_split_normalized_name(table->s->normalized_path.str, user_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); + ctc_copy_name(user_name, user_name, SMALL_RECORD_SIZE); + update_member_tch(m_tch, ctc_hton, thd); + ret = ctc_open_table(&m_tch, table->s->table_name.str, user_name); + update_sess_ctx_by_tch(m_tch, ctc_hton, thd); if (ret != CT_SUCCESS) { return ret; } } - update_member_tch(m_tch, tse_hton, thd); - ret = tse_get_cbo_stats(&m_tch, m_share->cbo_stats, m_share->cbo_stats->tse_cbo_stats_table, 0, 0); - update_sess_ctx_by_tch(m_tch, tse_hton, thd); + update_member_tch(m_tch, ctc_hton, thd); + ret = ctc_get_cbo_stats(&m_tch, m_share->cbo_stats, m_share->cbo_stats->ctc_cbo_stats_table, 0, 0); + update_sess_ctx_by_tch(m_tch, ctc_hton, thd); if (ret == CT_SUCCESS && m_share->cbo_stats->is_updated) { m_share->need_fetch_cbo = false; - tse_index_stats_update(table, m_share->cbo_stats); + ctc_index_stats_update(table, m_share->cbo_stats); } m_share->get_cbo_time = now; } @@ -5486,9 +5486,9 @@ int ha_tse::get_cbo_stats_4share() return ret; } -void free_columns_cbo_stats(tse_cbo_stats_column_t *tse_cbo_stats_columns, bool *is_str_first_addr, TABLE *table) +void free_columns_cbo_stats(ctc_cbo_stats_column_t *ctc_cbo_stats_columns, bool *is_str_first_addr, TABLE *table) { - uint32_t acc_gcol_num[TSE_MAX_COLUMNS] = {0}; + uint32_t acc_gcol_num[CTC_MAX_COLUMNS] = {0}; calc_accumulate_gcol_num(table->s->fields, table->s->field, acc_gcol_num); for (uint j = 0; j < table->s->fields; j++) { Field *field = table->field[j]; @@ -5499,21 +5499,21 @@ void free_columns_cbo_stats(tse_cbo_stats_column_t *tse_cbo_stats_columns, bool if (field->real_type() == MYSQL_TYPE_VARCHAR || field->real_type() == MYSQL_TYPE_VAR_STRING || field->real_type() == MYSQL_TYPE_STRING) { if (*is_str_first_addr) { - my_free(tse_cbo_stats_columns[ct_col_id].high_value.v_str); + my_free(ctc_cbo_stats_columns[ct_col_id].high_value.v_str); *is_str_first_addr = false; } - tse_cbo_stats_columns[ct_col_id].high_value.v_str = nullptr; - tse_cbo_stats_columns[ct_col_id].low_value.v_str = nullptr; + ctc_cbo_stats_columns[ct_col_id].high_value.v_str = nullptr; + ctc_cbo_stats_columns[ct_col_id].low_value.v_str = nullptr; for (uint k = 0; k < STATS_HISTGRAM_MAX_SIZE; k++) { - tse_cbo_stats_columns[ct_col_id].column_hist[k].ep_value.v_str = nullptr; + ctc_cbo_stats_columns[ct_col_id].column_hist[k].ep_value.v_str = nullptr; } } } - my_free(tse_cbo_stats_columns); - tse_cbo_stats_columns = nullptr; + my_free(ctc_cbo_stats_columns); + ctc_cbo_stats_columns = nullptr; } -void ha_tse::free_cbo_stats() +void ha_ctc::free_cbo_stats() { if (!m_share || m_share->cbo_stats == nullptr) { return; @@ -5525,10 +5525,10 @@ void ha_tse::free_cbo_stats() m_share->cbo_stats->col_type = nullptr; bool is_str_first_addr = true; - free_columns_cbo_stats(m_share->cbo_stats->tse_cbo_stats_table->columns, &is_str_first_addr, table); + free_columns_cbo_stats(m_share->cbo_stats->ctc_cbo_stats_table->columns, &is_str_first_addr, table); - my_free(m_share->cbo_stats->tse_cbo_stats_table); - m_share->cbo_stats->tse_cbo_stats_table = nullptr; + my_free(m_share->cbo_stats->ctc_cbo_stats_table); + m_share->cbo_stats->ctc_cbo_stats_table = nullptr; my_free((uchar *)(m_share->cbo_stats)); m_share->cbo_stats = nullptr; @@ -5545,9 +5545,9 @@ void ha_tse::free_cbo_stats() is returned if entire condition was supported. */ #ifdef FEATURE_X_FOR_MYSQL_32 -const Item *ha_tse::cond_push(const Item *cond) { +const Item *ha_ctc::cond_push(const Item *cond) { #elif defined(FEATURE_X_FOR_MYSQL_26) -const Item *ha_tse::cond_push(const Item *cond, bool other_tbls_ok MY_ATTRIBUTE((unused))) { +const Item *ha_ctc::cond_push(const Item *cond, bool other_tbls_ok MY_ATTRIBUTE((unused))) { #endif assert(m_cond == nullptr); assert(pushed_cond == nullptr); @@ -5567,9 +5567,9 @@ const Item *ha_tse::cond_push(const Item *cond, bool other_tbls_ok MY_ATTRIBUTE( return remainder; } - m_cond = (tse_conds *)tse_alloc_buf(&m_tch, sizeof(tse_conds)); + m_cond = (ctc_conds *)ctc_alloc_buf(&m_tch, sizeof(ctc_conds)); if (m_cond == nullptr) { - tse_log_error("alloc mem failed, m_cond size(%lu), pushdown cond is null.", sizeof(tse_conds)); + ctc_log_error("alloc mem failed, m_cond size(%lu), pushdown cond is null.", sizeof(ctc_conds)); return remainder; } @@ -5578,7 +5578,7 @@ const Item *ha_tse::cond_push(const Item *cond, bool other_tbls_ok MY_ATTRIBUTE( no_backslash = true; } Field **field = table->field; - if (tse_fill_conds(m_tch, m_pushed_conds, field, m_cond, no_backslash) != CT_SUCCESS) { + if (ctc_fill_conds(m_tch, m_pushed_conds, field, m_cond, no_backslash) != CT_SUCCESS) { free_m_cond(m_tch, &m_cond); m_pushed_conds = nullptr; m_remainder_conds = nullptr; @@ -5617,7 +5617,7 @@ const Item *ha_tse::cond_push(const Item *cond, bool other_tbls_ok MY_ATTRIBUTE( * @return Possible error code, '0' if no errors. */ #ifdef FEATURE_X_FOR_MYSQL_26 -int ha_tse::engine_push(AQP::Table_access *table_aqp) +int ha_ctc::engine_push(AQP::Table_access *table_aqp) { DBUG_TRACE; const Item *cond = table_aqp->get_condition(); @@ -5646,9 +5646,9 @@ int ha_tse::engine_push(AQP::Table_access *table_aqp) return 0; } - m_cond = (tse_conds *)tse_alloc_buf(&m_tch, sizeof(tse_conds)); + m_cond = (ctc_conds *)ctc_alloc_buf(&m_tch, sizeof(ctc_conds)); if (m_cond == nullptr) { - tse_log_error("alloc mem failed, m_cond size(%lu), pushdown cond is null.", sizeof(tse_conds)); + ctc_log_error("alloc mem failed, m_cond size(%lu), pushdown cond is null.", sizeof(ctc_conds)); return 0; } @@ -5657,7 +5657,7 @@ int ha_tse::engine_push(AQP::Table_access *table_aqp) no_backslash = true; } Field **field = table_aqp->get_table()->field; - if (tse_fill_conds(m_tch, m_pushed_conds, field, m_cond, no_backslash) != CT_SUCCESS) { + if (ctc_fill_conds(m_tch, m_pushed_conds, field, m_cond, no_backslash) != CT_SUCCESS) { free_m_cond(m_tch, &m_cond); m_pushed_conds = nullptr; m_remainder_conds = nullptr; @@ -5782,7 +5782,7 @@ TABLE *ctc_get_basic_table(const AccessPath *path) { * * @return Possible ret code, '0' if no errors. */ -static int tse_push_to_engine(THD *thd, AccessPath *root_path, JOIN *) { +static int ctc_push_to_engine(THD *thd, AccessPath *root_path, JOIN *) { DBUG_TRACE; if (!thd->optimizer_switch_flag(OPTIMIZER_SWITCH_ENGINE_CONDITION_PUSHDOWN)) { @@ -5803,22 +5803,22 @@ static int tse_push_to_engine(THD *thd, AccessPath *root_path, JOIN *) { return 0; } - ha_tse *const tse_handler = dynamic_cast(table->file); - if (tse_handler == nullptr) { - tse_log_warning("[tse_push_to_engine] tse_handler is nullptr."); + ha_ctc *const ctc_handler = dynamic_cast(table->file); + if (ctc_handler == nullptr) { + ctc_log_warning("[ctc_push_to_engine] ctc_handler is nullptr."); return 0; } - tse_handler->prep_cond_push(cond); - if (tse_handler->m_pushed_conds == nullptr) { + ctc_handler->prep_cond_push(cond); + if (ctc_handler->m_pushed_conds == nullptr) { return 0; } - tianchi_handler_t *tch = tse_handler->get_m_tch(); - tse_handler->m_cond = (tse_conds *)tse_alloc_buf(tch, sizeof(tse_conds)); - if (tse_handler->m_cond == nullptr) { - tse_log_warning("[tse_push_to_engine] alloc mem failed, m_cond size(%lu), pushdown cond is null.", - sizeof(tse_conds)); + ctc_handler_t *tch = ctc_handler->get_m_tch(); + ctc_handler->m_cond = (ctc_conds *)ctc_alloc_buf(tch, sizeof(ctc_conds)); + if (ctc_handler->m_cond == nullptr) { + ctc_log_warning("[ctc_push_to_engine] alloc mem failed, m_cond size(%lu), pushdown cond is null.", + sizeof(ctc_conds)); return 0; } @@ -5827,21 +5827,21 @@ static int tse_push_to_engine(THD *thd, AccessPath *root_path, JOIN *) { no_backslash = true; } Field **field = table->field; - if (tse_fill_conds(*tch, tse_handler->m_pushed_conds, field, tse_handler->m_cond, no_backslash) != CT_SUCCESS) { - free_m_cond(*tch, &tse_handler->m_cond); - tse_handler->m_pushed_conds = nullptr; - tse_handler->m_remainder_conds = nullptr; - tse_log_warning("[tse_push_to_engine] tse_fill_conds failed."); + if (ctc_fill_conds(*tch, ctc_handler->m_pushed_conds, field, ctc_handler->m_cond, no_backslash) != CT_SUCCESS) { + free_m_cond(*tch, &ctc_handler->m_cond); + ctc_handler->m_pushed_conds = nullptr; + ctc_handler->m_remainder_conds = nullptr; + ctc_log_warning("[ctc_push_to_engine] ctc_fill_conds failed."); return 0; } - tse_handler->pushed_cond = tse_handler->m_pushed_conds; - tse_handler->m_remainder_conds = const_cast(cond); + ctc_handler->pushed_cond = ctc_handler->m_pushed_conds; + ctc_handler->m_remainder_conds = const_cast(cond); return 0; } -const handlerton *ha_tse::hton_supporting_engine_pushdown() { - return tse_hton; +const handlerton *ha_ctc::hton_supporting_engine_pushdown() { + return ctc_hton; } #endif diff --git a/storage/tianchi/ha_tse.h b/storage/ctc/ha_ctc.h similarity index 92% rename from storage/tianchi/ha_tse.h rename to storage/ctc/ha_ctc.h index ee244c8..43244b3 100644 --- a/storage/tianchi/ha_tse.h +++ b/storage/ctc/ha_ctc.h @@ -15,10 +15,10 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -/* class for the the tse handler */ +/* class for the the ctc handler */ -#ifndef __HA_TSE_H__ -#define __HA_TSE_H__ +#ifndef __HA_CTC_H__ +#define __HA_CTC_H__ #include #include @@ -29,10 +29,10 @@ #include "sql/item.h" #include "sql/record_buffer.h" #include "my_sqlcommand.h" -#include "tse_srv.h" +#include "ctc_srv.h" #include "datatype_cnvrtr.h" -#include "tse_error.h" -#include "tse_cbo.h" +#include "ctc_error.h" +#include "ctc_cbo.h" #include "sql/dd/types/schema.h" #include "sql/dd/types/object_table_definition.h" #include "sql/dd/string_type.h" @@ -60,17 +60,17 @@ using namespace std; #define CT_NULL_VALUE_LEN (uint16)0xFFFF #define INVALID_MAX_UINT32 (uint32_t)0xFFFFFFFF -#define TSE_BUF_LEN (64 * 1024) +#define CTC_BUF_LEN (64 * 1024) #define MAX_BATCH_FETCH_NUM 100 #define DEFAULT_RANGE_DENSITY 0.5 #define PREFER_RANGE_DENSITY 0.8 #define CT_MAX_RECORD_LENGTH 64000 /* update if restraints changed in Cantian */ -#define TSE_MAX_KEY_PART_LENGTH 4095 // CT_MAX_KEY_SIZE -#define TSE_MAX_KEY_PARTS 16 // CT_MAX_INDEX_COLUMNS -#define TSE_MAX_KEY_LENGTH 4095 // CT_MAX_KEY_SIZE -#define TSE_MAX_KEY_NUM 32 // CT_MAX_TABLE_INDEXES +#define CTC_MAX_KEY_PART_LENGTH 4095 // CT_MAX_KEY_SIZE +#define CTC_MAX_KEY_PARTS 16 // CT_MAX_INDEX_COLUMNS +#define CTC_MAX_KEY_LENGTH 4095 // CT_MAX_KEY_SIZE +#define CTC_MAX_KEY_NUM 32 // CT_MAX_TABLE_INDEXES /* The 'MAIN TYPE' of a column */ #define DATA_MISSING 0 /* missing column */ @@ -128,9 +128,9 @@ again. */ this only holds for tables created with >= MySQL-4.0.14 */ #define TMP_DIR "tmp" -#define TSE_TMP_TABLE 1 -#define TSE_INTERNAL_TMP_TABLE 2 -#define TSE_TABLE_CONTAINS_VIRCOL 4 +#define CTC_TMP_TABLE 1 +#define CTC_INTERNAL_TMP_TABLE 2 +#define CTC_TABLE_CONTAINS_VIRCOL 4 #define CTC_ANALYZE_TIME_SEC 100 #define MEM_CLASS_NUM 27 @@ -145,9 +145,9 @@ again. */ return HA_ERR_SE_OUT_OF_MEMORY; \ } -#define IS_METADATA_NORMALIZATION() (tse_get_metadata_switch() == (int32_t)metadata_switchs::MATCH_META) -#define IS_PRIMARY_ROLE() (tse_get_cluster_role() == (int32_t)dis_cluster_role::PRIMARY) -#define IS_STANDBY_ROLE() (tse_get_cluster_role() == (int32_t)dis_cluster_role::STANDBY) +#define IS_METADATA_NORMALIZATION() (ctc_get_metadata_switch() == (int32_t)metadata_switchs::MATCH_META) +#define IS_PRIMARY_ROLE() (ctc_get_cluster_role() == (int32_t)dis_cluster_role::PRIMARY) +#define IS_STANDBY_ROLE() (ctc_get_cluster_role() == (int32_t)dis_cluster_role::STANDBY) bool is_single_run_mode(); #ifdef LIBMYSQL_VERSION_ID @@ -162,8 +162,8 @@ bool is_single_run_mode(); static const dd::String_type index_file_name_val_key("index_file_name"); static const uint ROW_ID_LENGTH = sizeof(uint64_t); -static const uint TSE_START_TIMEOUT = 120; // seconds -extern const char *tse_hton_name; +static const uint CTC_START_TIMEOUT = 120; // seconds +extern const char *ctc_hton_name; extern bool no_create_dir; enum class lock_mode { NO_LOCK = 0, @@ -191,7 +191,7 @@ enum class mysql_run_mode { DOUBLE }; -typedef int (*tse_prefetch_fn)(tianchi_handler_t *tch, uint8_t *records, uint16_t *record_lens, +typedef int (*ctc_prefetch_fn)(ctc_handler_t *tch, uint8_t *records, uint16_t *record_lens, uint32_t *recNum, uint64_t *rowids, int32 max_row_size); #define FILL_USER_INFO_WITH_THD(ctrl, _thd) \ @@ -251,11 +251,11 @@ CHECK_HAS_MEMBER_FUNC_IMPL(invalidates) #define CHECK_HAS_MEMBER(type, member) check_has_##member::value /** @brief - Tse_share is a class that will be shared among all open handlers. + Ctc_share is a class that will be shared among all open handlers. */ -class Tse_share : public Handler_share { +class Ctc_share : public Handler_share { public: - tianchi_cbo_stats_t *cbo_stats = nullptr; + ctc_cbo_stats_t *cbo_stats = nullptr; int used_count = 0; bool need_fetch_cbo = false; time_t get_cbo_time = 0; @@ -265,10 +265,10 @@ class Tse_share : public Handler_share { Class definition for the storage engine */ -class ha_tse : public handler { +class ha_ctc : public handler { public: - ha_tse(handlerton *hton, TABLE_SHARE *table); - ~ha_tse(); + ha_ctc(handlerton *hton, TABLE_SHARE *table); + ~ha_ctc(); int initialize(); @@ -609,7 +609,7 @@ public: */ int rnd_pos(uchar *buf, uchar *pos) override; ///< required - int prefetch_and_fill_record_buffer(uchar *buf, tse_prefetch_fn); + int prefetch_and_fill_record_buffer(uchar *buf, ctc_prefetch_fn); void fill_record_to_rec_buffer(); void reset_rec_buf(bool is_prefetch = false); /** @@ -697,7 +697,7 @@ public: int records(ha_rows *num_rows) override; int records_from_index(ha_rows *num_rows, uint inx) override; - void set_tse_range_key(tse_key *tse_key, key_range *mysql_range_key, bool is_min_key); + void set_ctc_range_key(ctc_key *ctc_key, key_range *mysql_range_key, bool is_min_key); /** @brief @@ -832,7 +832,7 @@ public: void start_bulk_insert(ha_rows rows) override; int end_bulk_insert() override; - /** Check if Tse supports a particular alter table in-place + /** Check if Ctc supports a particular alter table in-place @param altered_table TABLE object for new version of table. @param ha_alter_info Structure describing changes to be done by ALTER TABLE and holding data used during in-place alter. @@ -869,7 +869,7 @@ public: virtual int get_cbo_stats_4share(); /** Pointer to Cond pushdown */ - tse_conds *m_cond = nullptr; + ctc_conds *m_cond = nullptr; Item *m_pushed_conds = nullptr; Item *m_remainder_conds = nullptr; @@ -887,7 +887,7 @@ public: bool is_replay_ddl(MYSQL_THD thd); - tianchi_handler_t *get_m_tch() { return &m_tch; } + ctc_handler_t *get_m_tch() { return &m_tch; } protected: /* fooling percona-server's gap lock detection on rr which blocks some SQL */ @@ -895,11 +895,11 @@ public: protected: - /* tianchi handler that can be used to determine who sends the request */ - tianchi_handler_t m_tch; + /* ctc handler that can be used to determine who sends the request */ + ctc_handler_t m_tch; /* cantian record buffer */ - uchar *m_tse_buf = nullptr; + uchar *m_ctc_buf = nullptr; uchar *m_read_buf = nullptr; /* select lock mode */ @@ -945,13 +945,13 @@ public: vector m_blob_addrs; - /** Pointer to Tse_share on the TABLE_SHARE. */ - Tse_share *m_share; + /** Pointer to Ctc_share on the TABLE_SHARE. */ + Ctc_share *m_share; - tse_select_mode_t get_select_mode(); + ctc_select_mode_t get_select_mode(); private: - int tse_alloc_tse_buf_4_read(); + int ctc_alloc_ctc_buf_4_read(); int process_cantian_record(uchar *buf, record_info_t *record_info, ct_errno_t ct_ret, int rc_ret); int bulk_insert(); virtual int bulk_insert_low(dml_flag_t flag, uint *dup_offset); @@ -972,27 +972,27 @@ typedef struct { uint64 sess_addr; uint thd_id; uint16 bind_core; - uint is_tse_trx_begin; + uint is_ctc_trx_begin; uint8_t sql_stat_start; /* TRUE when we start processing of an SQL statement */ - std::unordered_map *cursors_map; + std::unordered_map *cursors_map; std::vector *invalid_cursors; void* msg_buf; } thd_sess_ctx_s; #pragma pack() -int ha_tse_get_inst_id(); -void ha_tse_set_inst_id(uint32_t inst_id); +int ha_ctc_get_inst_id(); +void ha_ctc_set_inst_id(uint32_t inst_id); bool is_ddl_sql_cmd(enum_sql_command sql_cmd); bool is_dcl_sql_cmd(enum_sql_command sql_cmd); thd_sess_ctx_s *get_or_init_sess_ctx(handlerton *hton, THD *thd); -handlerton *get_tse_hton(); -void update_sess_ctx_by_tch(tianchi_handler_t &tch, handlerton *hton, THD *thd); -void update_member_tch(tianchi_handler_t &tch, handlerton *hton, THD *thd, bool alloc_msg_buf = true); -int get_tch_in_handler_data(handlerton *hton, THD *thd, tianchi_handler_t &tch, bool alloc_msg_buf = true); -void tse_ddl_hook_cantian_error(const char *tag, THD *thd, ddl_ctrl_t *ddl_ctrl, +handlerton *get_ctc_hton(); +void update_sess_ctx_by_tch(ctc_handler_t &tch, handlerton *hton, THD *thd); +void update_member_tch(ctc_handler_t &tch, handlerton *hton, THD *thd, bool alloc_msg_buf = true); +int get_tch_in_handler_data(handlerton *hton, THD *thd, ctc_handler_t &tch, bool alloc_msg_buf = true); +void ctc_ddl_hook_cantian_error(const char *tag, THD *thd, ddl_ctrl_t *ddl_ctrl, ct_errno_t *ret); -int tse_ddl_handle_fault(const char *tag, const THD *thd, +int ctc_ddl_handle_fault(const char *tag, const THD *thd, const ddl_ctrl_t *ddl_ctrl, ct_errno_t ret, const char *param = nullptr, int fix_ret = 0); bool ddl_enabled_normal(MYSQL_THD thd); bool engine_skip_ddl(MYSQL_THD thd); @@ -1000,23 +1000,23 @@ bool engine_ddl_passthru(MYSQL_THD thd); bool is_alter_table_copy(MYSQL_THD thd, const char *name = nullptr); bool is_alter_table_scan(bool m_error_if_not_empty); -int tse_fill_conds(tianchi_handler_t m_tch, const Item *pushed_cond, Field **field, - tse_conds *m_cond, bool no_backslash); -void free_m_cond(tianchi_handler_t m_tch, tse_conds **conds); -void tse_set_metadata_switch(); -int32_t tse_get_metadata_switch(); +int ctc_fill_conds(ctc_handler_t m_tch, const Item *pushed_cond, Field **field, + ctc_conds *m_cond, bool no_backslash); +void free_m_cond(ctc_handler_t m_tch, ctc_conds **conds); +void ctc_set_metadata_switch(); +int32_t ctc_get_metadata_switch(); bool is_meta_version_initialize(); bool user_var_set(MYSQL_THD thd, string target_str); bool is_initialize(); bool is_starting(); -bool tse_is_temporary(const dd::Table *table_def); -int32_t tse_get_cluster_role(); -void tse_set_mysql_read_only(); -void tse_reset_mysql_read_only(); +bool ctc_is_temporary(const dd::Table *table_def); +int32_t ctc_get_cluster_role(); +void ctc_set_mysql_read_only(); +void ctc_reset_mysql_read_only(); -int alloc_str_mysql_mem(tianchi_cbo_stats_t *cbo_stats, uint32_t part_num, TABLE *table); -void free_columns_cbo_stats(tse_cbo_stats_column_t *tse_cbo_stats_columns, bool *is_str_first_addr, TABLE *table); +int alloc_str_mysql_mem(ctc_cbo_stats_t *cbo_stats, uint32_t part_num, TABLE *table); +void free_columns_cbo_stats(ctc_cbo_stats_column_t *ctc_cbo_stats_columns, bool *is_str_first_addr, TABLE *table); int32_t ctc_get_shm_file_num(uint32_t *shm_file_num); int32_t ctc_get_shm_usage(uint32_t *ctc_shm_usage); diff --git a/storage/tianchi/ha_tse_ddl.cc b/storage/ctc/ha_ctc_ddl.cc similarity index 68% rename from storage/tianchi/ha_tse_ddl.cc rename to storage/ctc/ha_ctc_ddl.cc index 3171d0c..bc0f4be 100644 --- a/storage/tianchi/ha_tse_ddl.cc +++ b/storage/ctc/ha_ctc_ddl.cc @@ -14,9 +14,9 @@ along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#include "storage/tianchi/ha_tse.h" -#include "storage/tianchi/ha_tse_ddl.h" -#include "storage/tianchi/ha_tsepart.h" +#include "storage/ctc/ha_ctc.h" +#include "storage/ctc/ha_ctc_ddl.h" +#include "storage/ctc/ha_ctcpart.h" #include #include @@ -54,57 +54,57 @@ #include "srv_mq_msg.h" #include "decimal_convert.h" #include "datatype_cnvrtr.h" -#include "tse_error.h" -#include "tse_log.h" -#include "tse_util.h" -#include "tse_ddl_util.h" +#include "ctc_error.h" +#include "ctc_log.h" +#include "ctc_util.h" +#include "ctc_ddl_util.h" #include #include using namespace std; -#define TSE_MAX_COLUMN_LEN 65 +#define CTC_MAX_COLUMN_LEN 65 #define CT_UNSPECIFIED_NUM_PREC 0 #define CT_UNSPECIFIED_NUM_SCALE (-100) -const uint32_t TSE_DDL_PROTOBUF_MEM_SIZE = 1024 * 1024 * 10; // 10M -mutex m_tse_ddl_protobuf_mem_mutex; -char tse_ddl_req_mem[TSE_DDL_PROTOBUF_MEM_SIZE]; +const uint32_t CTC_DDL_PROTOBUF_MEM_SIZE = 1024 * 1024 * 10; // 10M +mutex m_ctc_ddl_protobuf_mem_mutex; +char ctc_ddl_req_mem[CTC_DDL_PROTOBUF_MEM_SIZE]; extern uint32_t ctc_instance_id; -extern handlerton *tse_hton; +extern handlerton *ctc_hton; -size_t tse_ddl_stack_mem::tse_ddl_req_msg_mem_max_size = 0; -size_t tse_ddl_stack_mem::tse_ddl_req_msg_mem_use_heap_cnt = 0; +size_t ctc_ddl_stack_mem::ctc_ddl_req_msg_mem_max_size = 0; +size_t ctc_ddl_stack_mem::ctc_ddl_req_msg_mem_use_heap_cnt = 0; int fill_delete_table_req(const char *full_path_name, const dd::Table *table_def, - THD *thd, ddl_ctrl_t *ddl_ctrl, tse_ddl_stack_mem *stack_mem) { - TcDb__TseDDLDropTableDef req; + THD *thd, ddl_ctrl_t *ddl_ctrl, ctc_ddl_stack_mem *stack_mem) { + TcDb__CtcDDLDropTableDef req; - tc_db__tse_ddldrop_table_def__init(&req); + tc_db__ctc_ddldrop_table_def__init(&req); // 填充req信息 char db_name[SMALL_RECORD_SIZE] = {0}; char user_name[SMALL_RECORD_SIZE] = {0}; char table_name[SMALL_RECORD_SIZE] = {0}; - bool is_tmp_table = tse_is_temporary(table_def); - tse_split_normalized_name(full_path_name, db_name, SMALL_RECORD_SIZE, table_name, SMALL_RECORD_SIZE, &is_tmp_table); + bool is_tmp_table = ctc_is_temporary(table_def); + ctc_split_normalized_name(full_path_name, db_name, SMALL_RECORD_SIZE, table_name, SMALL_RECORD_SIZE, &is_tmp_table); if (is_tmp_table) { - ddl_ctrl->table_flags |= TSE_TMP_TABLE; + ddl_ctrl->table_flags |= CTC_TMP_TABLE; req.name = table_name; } else { req.name = const_cast(table_def->name().c_str()); } - tse_copy_name(user_name, db_name, SMALL_RECORD_SIZE); + ctc_copy_name(user_name, db_name, SMALL_RECORD_SIZE); req.user = user_name; - req.db_name = TSE_GET_THD_DB_NAME(thd); + req.db_name = CTC_GET_THD_DB_NAME(thd); // 拷贝算法语句在delete_table接口广播 string drop_sql; if (is_alter_table_copy(thd)) { - req.options |= TSE_DROP_FOR_MYSQL_COPY; + req.options |= CTC_DROP_FOR_MYSQL_COPY; ddl_ctrl->is_alter_copy = true; } @@ -116,20 +116,20 @@ int fill_delete_table_req(const char *full_path_name, const dd::Table *table_def } if (thd->variables.option_bits & OPTION_NO_FOREIGN_KEY_CHECKS) { - req.options |= TSE_DROP_NO_CHECK_FK; + req.options |= CTC_DROP_NO_CHECK_FK; } else if (table_def && !table_def->foreign_key_parents().empty()) { // broadcasted mysql need set to ignore FKs and cantian also ignore FKs - req.options |= (TSE_DROP_NO_CHECK_FK_FOR_CANTIAN_AND_BROADCAST | TSE_DROP_NO_CHECK_FK); + req.options |= (CTC_DROP_NO_CHECK_FK_FOR_CANTIAN_AND_BROADCAST | CTC_DROP_NO_CHECK_FK); } - size_t msg_len = tc_db__tse_ddldrop_table_def__get_packed_size(&req); + size_t msg_len = tc_db__ctc_ddldrop_table_def__get_packed_size(&req); stack_mem->set_mem_size(msg_len + sizeof(ddl_ctrl_t)); - void *tse_ddl_req_msg_mem = stack_mem->get_buf(); - if (tse_ddl_req_msg_mem == nullptr) { + void *ctc_ddl_req_msg_mem = stack_mem->get_buf(); + if (ctc_ddl_req_msg_mem == nullptr) { return HA_ERR_OUT_OF_MEM; } - if (tc_db__tse_ddldrop_table_def__pack(&req, (uint8_t *)tse_ddl_req_msg_mem) != msg_len) { + if (tc_db__ctc_ddldrop_table_def__pack(&req, (uint8_t *)ctc_ddl_req_msg_mem) != msg_len) { assert(false); } @@ -137,33 +137,33 @@ int fill_delete_table_req(const char *full_path_name, const dd::Table *table_def return 0; } -static int tse_init_create_tablespace_def(TcDb__TseDDLSpaceDef *req, char **mem_start, +static int ctc_init_create_tablespace_def(TcDb__CtcDDLSpaceDef *req, char **mem_start, char *mem_end) { - tc_db__tse_ddlspace_def__init(req); + tc_db__ctc_ddlspace_def__init(req); req->n_datafiles_list = 1; - req->datafiles_list = (TcDb__TseDDLDataFileDef **)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLDataFileDef*)); // mysql最多只有一个datafile，此处按1计算 + req->datafiles_list = (TcDb__CtcDDLDataFileDef **)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLDataFileDef*)); // mysql最多只有一个datafile，此处按1计算 if (req->datafiles_list == NULL) { return HA_ERR_OUT_OF_MEM; } - req->datafiles_list[0] = (TcDb__TseDDLDataFileDef *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLDataFileDef)); + req->datafiles_list[0] = (TcDb__CtcDDLDataFileDef *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLDataFileDef)); if (req->datafiles_list[0] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddldata_file_def__init(req->datafiles_list[0]); - TcDb__TseDDLDataFileDef *datafile = req->datafiles_list[0]; - datafile->autoextend = (TcDb__TseDDLAutoExtendDef *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLAutoExtendDef)); + tc_db__ctc_ddldata_file_def__init(req->datafiles_list[0]); + TcDb__CtcDDLDataFileDef *datafile = req->datafiles_list[0]; + datafile->autoextend = (TcDb__CtcDDLAutoExtendDef *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLAutoExtendDef)); if (datafile->autoextend == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlauto_extend_def__init(datafile->autoextend); + tc_db__ctc_ddlauto_extend_def__init(datafile->autoextend); return 0; } -static void tse_ddl_fill_datafile_by_alter_info(TcDb__TseDDLDataFileDef *datafile, st_alter_tablespace *alter_info) { +static void ctc_ddl_fill_datafile_by_alter_info(TcDb__CtcDDLDataFileDef *datafile, st_alter_tablespace *alter_info) { datafile->name = const_cast(alter_info->data_file_name); datafile->size = 1024 * 1024; // 8 * 1024 * 1024 datafile->autoextend->enabled = true; @@ -176,7 +176,7 @@ static void tse_ddl_fill_datafile_by_alter_info(TcDb__TseDDLDataFileDef *datafil // TODO:其他参数目前不确定如何填写 包含autoextend } -static int tse_create_tablespace_handler(handlerton *hton, THD *thd, +static int ctc_create_tablespace_handler(handlerton *hton, THD *thd, st_alter_tablespace *alter_info, dd::Tablespace *dd_space MY_ATTRIBUTE((unused))) { if (engine_ddl_passthru(thd)) { @@ -184,58 +184,58 @@ static int tse_create_tablespace_handler(handlerton *hton, THD *thd, } ct_errno_t ret; size_t msg_len = 0; - tse_ddl_stack_mem stack_mem(0); - void *tse_ddl_req_msg_mem = nullptr; + ctc_ddl_stack_mem stack_mem(0); + void *ctc_ddl_req_msg_mem = nullptr; { - TcDb__TseDDLSpaceDef req; - char *req_mem_start = tse_ddl_req_mem; - char *req_mem_end = req_mem_start + TSE_DDL_PROTOBUF_MEM_SIZE; - lock_guard lock(m_tse_ddl_protobuf_mem_mutex); - ret = (ct_errno_t)tse_init_create_tablespace_def(&req, &req_mem_start, req_mem_end); + TcDb__CtcDDLSpaceDef req; + char *req_mem_start = ctc_ddl_req_mem; + char *req_mem_end = req_mem_start + CTC_DDL_PROTOBUF_MEM_SIZE; + lock_guard lock(m_ctc_ddl_protobuf_mem_mutex); + ret = (ct_errno_t)ctc_init_create_tablespace_def(&req, &req_mem_start, req_mem_end); assert(req_mem_start <= req_mem_end); if (ret != 0) { return ret; } // fill parameter for create tablespace - TSE_RETURN_IF_NOT_ZERO(check_tse_identifier_name(alter_info->tablespace_name)); + CTC_RETURN_IF_NOT_ZERO(check_ctc_identifier_name(alter_info->tablespace_name)); req.name = const_cast(alter_info->tablespace_name); - req.db_name = TSE_GET_THD_DB_NAME(thd); + req.db_name = CTC_GET_THD_DB_NAME(thd); string sql = string(thd->query().str).substr(0, thd->query().length); req.sql_str = const_cast(sql.c_str()); // fill datafile parameter - TcDb__TseDDLDataFileDef *datafile = req.datafiles_list[0]; + TcDb__CtcDDLDataFileDef *datafile = req.datafiles_list[0]; if(check_data_file_name(alter_info->data_file_name)) { return HA_ERR_WRONG_FILE_NAME; } - tse_ddl_fill_datafile_by_alter_info(datafile, alter_info); + ctc_ddl_fill_datafile_by_alter_info(datafile, alter_info); - msg_len = tc_db__tse_ddlspace_def__get_packed_size(&req); + msg_len = tc_db__ctc_ddlspace_def__get_packed_size(&req); stack_mem.set_mem_size(msg_len + sizeof(ddl_ctrl_t)); - tse_ddl_req_msg_mem = stack_mem.get_buf(); - if(tse_ddl_req_msg_mem == nullptr) { + ctc_ddl_req_msg_mem = stack_mem.get_buf(); + if(ctc_ddl_req_msg_mem == nullptr) { return HA_ERR_OUT_OF_MEM; } - if (tc_db__tse_ddlspace_def__pack(&req, (uint8_t *)tse_ddl_req_msg_mem) != msg_len) { + if (tc_db__ctc_ddlspace_def__pack(&req, (uint8_t *)ctc_ddl_req_msg_mem) != msg_len) { assert(false); } } - tianchi_handler_t tch; - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); + ctc_handler_t tch; + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); ddl_ctrl_t ddl_ctrl = {{0}, {0}, {0}, 0, 0, tch, ctc_instance_id, false, 0}; FILL_USER_INFO_WITH_THD(ddl_ctrl, thd); ddl_ctrl.msg_len = msg_len; - ret = (ct_errno_t)tse_create_tablespace(tse_ddl_req_msg_mem, &ddl_ctrl); - memcpy(&tch, &ddl_ctrl.tch, sizeof(tianchi_handler_t)); - tse_ddl_hook_cantian_error("tse_create_tablespace_cantian_error", thd, &ddl_ctrl, &ret); + ret = (ct_errno_t)ctc_create_tablespace(ctc_ddl_req_msg_mem, &ddl_ctrl); + memcpy(&tch, &ddl_ctrl.tch, sizeof(ctc_handler_t)); + ctc_ddl_hook_cantian_error("ctc_create_tablespace_cantian_error", thd, &ddl_ctrl, &ret); update_sess_ctx_by_tch(tch, hton, thd); - return tse_ddl_handle_fault("tse_create_tablespace", thd, &ddl_ctrl, ret, alter_info->tablespace_name); + return ctc_ddl_handle_fault("ctc_create_tablespace", thd, &ddl_ctrl, ret, alter_info->tablespace_name); } -static int tse_alter_tablespace_handler(handlerton *hton, THD *thd, +static int ctc_alter_tablespace_handler(handlerton *hton, THD *thd, st_alter_tablespace *alter_info, const dd::Tablespace *old_dd_space, dd::Tablespace *new_dd_space) { @@ -254,10 +254,10 @@ static int tse_alter_tablespace_handler(handlerton *hton, THD *thd, const char *from = old_dd_space->name().c_str(); const char *to = new_dd_space->name().c_str(); size_t msg_len = 0; - tse_ddl_stack_mem stack_mem(0); - void *tse_ddl_req_msg_mem = nullptr; + ctc_ddl_stack_mem stack_mem(0); + void *ctc_ddl_req_msg_mem = nullptr; { - lock_guard lock(m_tse_ddl_protobuf_mem_mutex); + lock_guard lock(m_ctc_ddl_protobuf_mem_mutex); // TODO 检测from表名 不能和系统表一致（即不能修改系统表） if (alter_info->ts_alter_tablespace_type == ALTER_TABLESPACE_RENAME && my_strcasecmp(system_charset_info, from, to) == 0) { @@ -265,52 +265,52 @@ static int tse_alter_tablespace_handler(handlerton *hton, THD *thd, "tablespace name is same for rename", MYF(0)); return HA_WRONG_CREATE_OPTION; } - auto tse_alter_action = - g_tse_alter_tablespace_map.find(alter_info->ts_alter_tablespace_type); - if (tse_alter_action == g_tse_alter_tablespace_map.end()) { + auto ctc_alter_action = + g_ctc_alter_tablespace_map.find(alter_info->ts_alter_tablespace_type); + if (ctc_alter_action == g_ctc_alter_tablespace_map.end()) { return ER_ILLEGAL_HA; } - TcDb__TseDDLAlterSpaceDef req; - tc_db__tse_ddlalter_space_def__init(&req); + TcDb__CtcDDLAlterSpaceDef req; + tc_db__ctc_ddlalter_space_def__init(&req); - req.action = tse_alter_action->second; + req.action = ctc_alter_action->second; - TSE_RETURN_IF_NOT_ZERO(check_tse_identifier_name(from)); + CTC_RETURN_IF_NOT_ZERO(check_ctc_identifier_name(from)); req.name = const_cast(from); - TSE_RETURN_IF_NOT_ZERO(check_tse_identifier_name(to)); + CTC_RETURN_IF_NOT_ZERO(check_ctc_identifier_name(to)); req.new_name = const_cast(to); - req.db_name = TSE_GET_THD_DB_NAME(thd); + req.db_name = CTC_GET_THD_DB_NAME(thd); string sql = string(thd->query().str).substr(0, thd->query().length); req.sql_str = const_cast(sql.c_str()); if (alter_info->autoextend_size != 0 && alter_info->autoextend_size.has_value()) { req.auto_extend_size = (uint64_t)alter_info->autoextend_size.value(); } - msg_len = tc_db__tse_ddlalter_space_def__get_packed_size(&req); + msg_len = tc_db__ctc_ddlalter_space_def__get_packed_size(&req); stack_mem.set_mem_size(msg_len + sizeof(ddl_ctrl_t)); - tse_ddl_req_msg_mem = stack_mem.get_buf(); - if(tse_ddl_req_msg_mem == nullptr) { + ctc_ddl_req_msg_mem = stack_mem.get_buf(); + if(ctc_ddl_req_msg_mem == nullptr) { return HA_ERR_OUT_OF_MEM; } - if (tc_db__tse_ddlalter_space_def__pack(&req, (uint8_t *)tse_ddl_req_msg_mem) != msg_len) { + if (tc_db__ctc_ddlalter_space_def__pack(&req, (uint8_t *)ctc_ddl_req_msg_mem) != msg_len) { assert(false); } } - tianchi_handler_t tch; - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); + ctc_handler_t tch; + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); ddl_ctrl_t ddl_ctrl = {{0}, {0}, {0}, 0, 0, tch, ctc_instance_id, false, 0}; FILL_USER_INFO_WITH_THD(ddl_ctrl, thd); ddl_ctrl.msg_len = msg_len; - ret = (ct_errno_t)tse_alter_tablespace(tse_ddl_req_msg_mem, &ddl_ctrl); - memcpy(&tch, &ddl_ctrl.tch, sizeof(tianchi_handler_t)); - tse_ddl_hook_cantian_error("tse_alter_tablespace_cantian_error", thd, &ddl_ctrl, &ret); + ret = (ct_errno_t)ctc_alter_tablespace(ctc_ddl_req_msg_mem, &ddl_ctrl); + memcpy(&tch, &ddl_ctrl.tch, sizeof(ctc_handler_t)); + ctc_ddl_hook_cantian_error("ctc_alter_tablespace_cantian_error", thd, &ddl_ctrl, &ret); update_sess_ctx_by_tch(tch, hton, thd); - return tse_ddl_handle_fault("tse_alter_tablespace", thd, &ddl_ctrl, ret); + return ctc_ddl_handle_fault("ctc_alter_tablespace", thd, &ddl_ctrl, ret); } -static int tse_drop_tablespace_handler(handlerton *hton, THD *thd, +static int ctc_drop_tablespace_handler(handlerton *hton, THD *thd, st_alter_tablespace *alter_info, const dd::Tablespace *dd_space MY_ATTRIBUTE((unused))) { if (engine_ddl_passthru(thd)) { @@ -318,53 +318,53 @@ static int tse_drop_tablespace_handler(handlerton *hton, THD *thd, } ct_errno_t ret; size_t msg_len = 0; - tse_ddl_stack_mem stack_mem(0); - void *tse_ddl_req_msg_mem = nullptr; + ctc_ddl_stack_mem stack_mem(0); + void *ctc_ddl_req_msg_mem = nullptr; { - lock_guard lock(m_tse_ddl_protobuf_mem_mutex); - TcDb__TseDDLDropSpaceDef req; - tc_db__tse_ddldrop_space_def__init(&req); - TSE_RETURN_IF_NOT_ZERO(check_tse_identifier_name(alter_info->tablespace_name)); + lock_guard lock(m_ctc_ddl_protobuf_mem_mutex); + TcDb__CtcDDLDropSpaceDef req; + tc_db__ctc_ddldrop_space_def__init(&req); + CTC_RETURN_IF_NOT_ZERO(check_ctc_identifier_name(alter_info->tablespace_name)); req.obj_name = const_cast(alter_info->tablespace_name); - req.db_name = TSE_GET_THD_DB_NAME(thd); + req.db_name = CTC_GET_THD_DB_NAME(thd); string sql = string(thd->query().str).substr(0, thd->query().length); req.sql_str = const_cast(sql.c_str()); - msg_len = tc_db__tse_ddldrop_space_def__get_packed_size(&req); + msg_len = tc_db__ctc_ddldrop_space_def__get_packed_size(&req); stack_mem.set_mem_size(msg_len + sizeof(ddl_ctrl_t)); - tse_ddl_req_msg_mem = stack_mem.get_buf(); - if(tse_ddl_req_msg_mem == nullptr) { + ctc_ddl_req_msg_mem = stack_mem.get_buf(); + if(ctc_ddl_req_msg_mem == nullptr) { return HA_ERR_OUT_OF_MEM; } - if (tc_db__tse_ddldrop_space_def__pack(&req, (uint8_t *)tse_ddl_req_msg_mem) != msg_len) { + if (tc_db__ctc_ddldrop_space_def__pack(&req, (uint8_t *)ctc_ddl_req_msg_mem) != msg_len) { assert(false); } } - tianchi_handler_t tch; - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); + ctc_handler_t tch; + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(hton, thd, tch)); ddl_ctrl_t ddl_ctrl = {{0}, {0}, {0}, 0, 0, tch, ctc_instance_id, false, 0}; FILL_USER_INFO_WITH_THD(ddl_ctrl, thd); ddl_ctrl.msg_len = msg_len; - ret = (ct_errno_t)tse_drop_tablespace(tse_ddl_req_msg_mem, &ddl_ctrl); - memcpy(&tch, &ddl_ctrl.tch, sizeof(tianchi_handler_t)); - tse_ddl_hook_cantian_error("tse_drop_tablespace_cantian_error", thd, &ddl_ctrl, &ret); + ret = (ct_errno_t)ctc_drop_tablespace(ctc_ddl_req_msg_mem, &ddl_ctrl); + memcpy(&tch, &ddl_ctrl.tch, sizeof(ctc_handler_t)); + ctc_ddl_hook_cantian_error("ctc_drop_tablespace_cantian_error", thd, &ddl_ctrl, &ret); update_sess_ctx_by_tch(tch, hton, thd); - return tse_ddl_handle_fault("tse_drop_tablespace", thd, &ddl_ctrl, ret, alter_info->tablespace_name); + return ctc_ddl_handle_fault("ctc_drop_tablespace", thd, &ddl_ctrl, ret, alter_info->tablespace_name); } /** alter tablespace. - @param: hton in, tse handlerton + @param: hton in, ctc handlerton @param: thd in, handle to the MySQL thread @param: savepoint in, savepoint data @return: 0 if succeeds */ -int tsebase_alter_tablespace(handlerton *hton, THD *thd, +int ctcbase_alter_tablespace(handlerton *hton, THD *thd, st_alter_tablespace *alter_info, const dd::Tablespace *old_ts_def, dd::Tablespace *new_ts_def) { @@ -373,11 +373,11 @@ int tsebase_alter_tablespace(handlerton *hton, THD *thd, // TODO：只读模式和强制恢复模式不能修改表空间 switch (alter_info->ts_cmd_type) { case CREATE_TABLESPACE: - return tse_create_tablespace_handler(hton, thd, alter_info, new_ts_def); + return ctc_create_tablespace_handler(hton, thd, alter_info, new_ts_def); case ALTER_TABLESPACE: - return tse_alter_tablespace_handler(hton, thd, alter_info, old_ts_def, new_ts_def); + return ctc_alter_tablespace_handler(hton, thd, alter_info, old_ts_def, new_ts_def); case DROP_TABLESPACE: - return tse_drop_tablespace_handler(hton, thd, alter_info, old_ts_def); + return ctc_drop_tablespace_handler(hton, thd, alter_info, old_ts_def); case CREATE_UNDO_TABLESPACE: case ALTER_UNDO_TABLESPACE: case DROP_UNDO_TABLESPACE: @@ -401,7 +401,7 @@ int tsebase_alter_tablespace(handlerton *hton, THD *thd, return HA_ADMIN_NOT_IMPLEMENTED; } -static bool tse_fill_column_precision_and_scale(TcDb__TseDDLColumnDef *column, Field *field) { +static bool ctc_fill_column_precision_and_scale(TcDb__CtcDDLColumnDef *column, Field *field) { switch (field->real_type()) { case MYSQL_TYPE_FLOAT: case MYSQL_TYPE_DOUBLE: { @@ -448,7 +448,7 @@ static bool tse_fill_column_precision_and_scale(TcDb__TseDDLColumnDef *column, F return true; } -static void tse_set_unsigned_column(Field *field, uint32 *is_unsigned) { +static void ctc_set_unsigned_column(Field *field, uint32 *is_unsigned) { if ((is_numeric_type(field->type()) && field->is_unsigned()) || field->real_type() == MYSQL_TYPE_ENUM || field->real_type() == MYSQL_TYPE_BIT) { *is_unsigned = 1; @@ -457,8 +457,8 @@ static void tse_set_unsigned_column(Field *field, uint32 *is_unsigned) { } } -static bool tse_ddl_fill_column_by_field_fill_type(TcDb__TseDDLColumnDef *column, Field *field) { - if (!tse_ddl_get_data_type_from_mysql_type(field, field->type(), &column->datatype->datatype)) { +static bool ctc_ddl_fill_column_by_field_fill_type(TcDb__CtcDDLColumnDef *column, Field *field) { + if (!ctc_ddl_get_data_type_from_mysql_type(field, field->type(), &column->datatype->datatype)) { char info[300]; // max column name length(64) * max_mb_size(4) + redundancy sprintf(info, "column name: %s", field->field_name); my_error(ER_FEATURE_UNSUPPORTED, MYF(0), "*DataType Conversion*", info); @@ -471,20 +471,20 @@ static bool tse_ddl_fill_column_by_field_fill_type(TcDb__TseDDLColumnDef *column if (field->type() == MYSQL_TYPE_VARCHAR) { uint32_t varchar_length = field->row_pack_length(); if (VARCHAR_AS_BLOB(varchar_length)) { - column->datatype->datatype = TSE_DDL_TYPE_CLOB; + column->datatype->datatype = CTC_DDL_TYPE_CLOB; } column->datatype->size = varchar_length; } - tse_set_unsigned_column(field, &column->is_unsigned); + ctc_set_unsigned_column(field, &column->is_unsigned); - if (!tse_fill_column_precision_and_scale(column, field)) { - tse_log_error("fill column precision and scale failed"); + if (!ctc_fill_column_precision_and_scale(column, field)) { + ctc_log_error("fill column precision and scale failed"); return false; } return true; } -static int tse_prepare_enum_field_impl(THD *thd, Create_field *sql_field, String *def) { +static int ctc_prepare_enum_field_impl(THD *thd, Create_field *sql_field, String *def) { DBUG_TRACE; assert(sql_field->sql_type == MYSQL_TYPE_ENUM); if (!sql_field->charset) { @@ -494,7 +494,7 @@ static int tse_prepare_enum_field_impl(THD *thd, Create_field *sql_field, String if (def == nullptr) { if ((sql_field->flags & NOT_NULL_FLAG) != 0) { my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name); - return TSE_ENUM_DEFAULT_NULL; + return CTC_ENUM_DEFAULT_NULL; } } else { def->length(sql_field->charset->cset->lengthsp(sql_field->charset, def->ptr(), def->length())); @@ -505,16 +505,16 @@ static int tse_prepare_enum_field_impl(THD *thd, Create_field *sql_field, String uint enum_index = find_type2(interval, def->ptr(), def->length(), sql_field->charset); if (enum_index == 0) { my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name); - return TSE_ENUM_DEFAULT_INVALID; + return CTC_ENUM_DEFAULT_INVALID; } return enum_index; } my_error(ER_INVALID_DEFAULT, MYF(0), "constant default is null"); - return TSE_ENUM_DEFAULT_INVALID; + return CTC_ENUM_DEFAULT_INVALID; } -static bool tse_prepare_set_field_impl(THD *thd, Create_field *sql_field, ulonglong *set_bitmap, - String *def, TcDb__TseDDLColumnDef *column) { +static bool ctc_prepare_set_field_impl(THD *thd, Create_field *sql_field, ulonglong *set_bitmap, + String *def, TcDb__CtcDDLColumnDef *column) { DBUG_TRACE; assert(sql_field->sql_type == MYSQL_TYPE_SET); @@ -538,7 +538,7 @@ static bool tse_prepare_set_field_impl(THD *thd, Create_field *sql_field, ulongl assert(comma_length > 0); if (!set_column_datatype(interval->count, column)) { - tse_log_error("set column datatype failed, set num is %lu", interval->count); + ctc_log_error("set column datatype failed, set num is %lu", interval->count); return false; } @@ -577,20 +577,20 @@ static bool tse_prepare_set_field_impl(THD *thd, Create_field *sql_field, ulongl return true; } -static bool tse_process_string_default_value(TcDb__TseDDLColumnDef *column, string &expr_str, +static bool ctc_process_string_default_value(TcDb__CtcDDLColumnDef *column, string &expr_str, char **mem_start, char *mem_end, bool is_blob_type) { if (!is_blob_type) { boost::algorithm::replace_all(expr_str, "'", "''"); - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, expr_str.length() + 1); + column->default_text = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, expr_str.length() + 1); if (column->default_text == nullptr) { - tse_log_error("alloc mem for bit default text failed, mem_start is null"); + ctc_log_error("alloc mem for bit default text failed, mem_start is null"); return false; } strncpy(column->default_text, expr_str.c_str(), expr_str.length() + 1); } else { - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, expr_str.length() * 2 + 1); + column->default_text = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, expr_str.length() * 2 + 1); if (column->default_text == nullptr) { - tse_log_error("alloc mem for bit default text failed, mem_start is null"); + ctc_log_error("alloc mem for bit default text failed, mem_start is null"); return false; } int pos = 0; @@ -603,8 +603,8 @@ static bool tse_process_string_default_value(TcDb__TseDDLColumnDef *column, stri return true; } -static bool tse_get_bit_default_value( - THD *thd, TcDb__TseDDLColumnDef *column, Field *field, const Create_field *fld, const dd::Column *col_obj, +static bool ctc_get_bit_default_value( + THD *thd, TcDb__CtcDDLColumnDef *column, Field *field, const Create_field *fld, const dd::Column *col_obj, char **mem_start, char *mem_end, bool is_expr_value) { column->is_unsigned = 1; longlong num = 0; @@ -613,7 +613,7 @@ static bool tse_get_bit_default_value( uint32_t bit_value_len = (uint32_t)(col_obj->default_value().length()); Field_bit *bitfield = dynamic_cast(field); Field_bit *new_field = bitfield->clone(thd->mem_root); - uchar bit_ptr[TSE_MAX_BIT_LEN]; + uchar bit_ptr[CTC_MAX_BIT_LEN]; for (uint32_t i = 0; i < bit_value_len; i++) { bit_ptr[i] = bit_value_buf[i]; } @@ -639,16 +639,16 @@ static bool tse_get_bit_default_value( &err); if (err) { string expr_str(res->c_ptr()); - return tse_process_string_default_value(column, expr_str, mem_start, mem_end, false); + return ctc_process_string_default_value(column, expr_str, mem_start, mem_end, false); } } } } uint32_t num_len = to_string(num).length(); - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, num_len + 1); + column->default_text = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, num_len + 1); if (column->default_text == nullptr) { - tse_log_error("alloc mem for bit default text failed, mem_start is null"); + ctc_log_error("alloc mem for bit default text failed, mem_start is null"); return false; } sprintf(column->default_text, "%llu", num); @@ -657,9 +657,9 @@ static bool tse_get_bit_default_value( return true; } -static bool tse_get_datetime_default_value( - TcDb__TseDDLColumnDef *column, Field *field, const Create_field *fld, const dd::Column *col_obj, - char **mem_start, char *mem_end, tse_column_option_set_bit *option_set, bool is_expr_value) { +static bool ctc_get_datetime_default_value( + TcDb__CtcDDLColumnDef *column, Field *field, const Create_field *fld, const dd::Column *col_obj, + char **mem_start, char *mem_end, ctc_column_option_set_bit *option_set, bool is_expr_value) { if (field->has_insert_default_datetime_value_expression()) { // current_timestamp (or with ON UPDATE CURRENT_TIMESTAMP) option_set->is_default_func = 1; @@ -705,9 +705,9 @@ static bool tse_get_datetime_default_value( if (check_zero_date(date_detail)) { char *tmp_zero_date = const_cast("0000-00-00 00:00:00"); int len = strlen(tmp_zero_date); - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, len + 1); + column->default_text = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, len + 1); if (column->default_text == nullptr) { - tse_log_error("alloc mem for datetime default text failed."); + ctc_log_error("alloc mem for datetime default text failed."); return false; } strncpy(column->default_text, tmp_zero_date, len + 1); @@ -717,9 +717,9 @@ static bool tse_get_datetime_default_value( switch (field->real_type()) { case MYSQL_TYPE_TIME2: { int len = expr_str.length(); - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(char) * (len + 1)); + column->default_text = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, sizeof(char) * (len + 1)); if (column->default_text == nullptr) { - tse_log_error("alloc mem for datetime default text failed."); + ctc_log_error("alloc mem for datetime default text failed."); return false; } sprintf(column->default_text, "%s", expr_str.c_str()); @@ -729,9 +729,9 @@ static bool tse_get_datetime_default_value( if (!is_expr_value) { char tmp_timestamp[MAX_DATE_STRING_REP_LENGTH]; int len = my_datetime_to_str(ltime, tmp_timestamp, field->decimals()); - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, len + 1); + column->default_text = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, len + 1); if (column->default_text == nullptr) { - tse_log_error("alloc mem for datetime default text failed."); + ctc_log_error("alloc mem for datetime default text failed."); return false; } strncpy(column->default_text, tmp_timestamp, len + 1); @@ -740,9 +740,9 @@ static bool tse_get_datetime_default_value( } default: { int len = expr_str.length(); - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, len + 1); + column->default_text = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, len + 1); if (column->default_text == nullptr) { - tse_log_error("alloc mem for datetime default text failed."); + ctc_log_error("alloc mem for datetime default text failed."); return false; } strncpy(column->default_text, expr_str.c_str(), len + 1); @@ -752,7 +752,7 @@ static bool tse_get_datetime_default_value( return true; } -static int tse_prepare_enum_field(THD *thd, Field *field, const Create_field *fld, +static int ctc_prepare_enum_field(THD *thd, Field *field, const Create_field *fld, const CHARSET_INFO *field_cs) { int is_enum = 0; String default_str; @@ -782,36 +782,36 @@ static int tse_prepare_enum_field(THD *thd, Field *field, const Create_field *fl sql_field->charset = def->charset(); } } - is_enum = tse_prepare_enum_field_impl(thd, sql_field, def); + is_enum = ctc_prepare_enum_field_impl(thd, sql_field, def); return is_enum; } -static bool tse_get_enum_default_value( - THD *thd, TcDb__TseDDLColumnDef *column, const dd::Column *col_obj, Field *field, const Create_field *fld, +static bool ctc_get_enum_default_value( + THD *thd, TcDb__CtcDDLColumnDef *column, const dd::Column *col_obj, Field *field, const Create_field *fld, char **mem_start, char *mem_end, const CHARSET_INFO *field_cs) { int is_enum; column->is_unsigned = 1; - column->datatype->datatype = column->datatype->size == 1 ? TSE_DDL_TYPE_TINY : TSE_DDL_TYPE_SHORT; + column->datatype->datatype = column->datatype->size == 1 ? CTC_DDL_TYPE_TINY : CTC_DDL_TYPE_SHORT; - is_enum = tse_prepare_enum_field(thd, field, fld, field_cs); + is_enum = ctc_prepare_enum_field(thd, field, fld, field_cs); - if (is_enum == TSE_ENUM_DEFAULT_INVALID) { + if (is_enum == CTC_ENUM_DEFAULT_INVALID) { return false; } column->default_text = nullptr; - if (is_enum != TSE_ENUM_DEFAULT_NULL) { - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, 10); + if (is_enum != CTC_ENUM_DEFAULT_NULL) { + column->default_text = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, 10); if (column->default_text == nullptr) { - tse_log_error("alloc mem for enum default text failed, mem_start is null"); + ctc_log_error("alloc mem for enum default text failed, mem_start is null"); return false; } sprintf(column->default_text, "%d", is_enum); } else { char *default_value = const_cast(col_obj->default_value_utf8().data()); int len = strlen(default_value); - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, len + 1); + column->default_text = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, len + 1); if (column->default_text == nullptr) { - tse_log_error("alloc mem for enum default text failed, mem_start is null"); + ctc_log_error("alloc mem for enum default text failed, mem_start is null"); return false; } strncpy(column->default_text, default_value, len + 1); @@ -819,8 +819,8 @@ static bool tse_get_enum_default_value( return true; } -static bool tse_prepare_set_field(THD *thd, Field *field, const Create_field *fld, const CHARSET_INFO *field_cs, - ulonglong *set_bitmap, TcDb__TseDDLColumnDef *column) { +static bool ctc_prepare_set_field(THD *thd, Field *field, const Create_field *fld, const CHARSET_INFO *field_cs, + ulonglong *set_bitmap, TcDb__CtcDDLColumnDef *column) { bool is_get_set_bitmap = 0; String default_str; String *def; @@ -847,12 +847,12 @@ static bool tse_prepare_set_field(THD *thd, Field *field, const Create_field *fl } } - is_get_set_bitmap = tse_prepare_set_field_impl(thd, sql_field, set_bitmap, def, column); + is_get_set_bitmap = ctc_prepare_set_field_impl(thd, sql_field, set_bitmap, def, column); return is_get_set_bitmap; } -static bool tse_get_set_default_value( - THD *thd, TcDb__TseDDLColumnDef *column, Field *field, const Create_field *fld, char **mem_start, +static bool ctc_get_set_default_value( + THD *thd, TcDb__CtcDDLColumnDef *column, Field *field, const Create_field *fld, char **mem_start, char *mem_end, const CHARSET_INFO *field_cs) { ulonglong set_bitmap; bool is_get_set_bitmap = false; @@ -860,14 +860,14 @@ static bool tse_get_set_default_value( column->is_unsigned = 1; } // fld == nullptr 为create，此时field_charset 为空值需处理置位 - is_get_set_bitmap = tse_prepare_set_field(thd, field, fld, field_cs, &set_bitmap, column); + is_get_set_bitmap = ctc_prepare_set_field(thd, field, fld, field_cs, &set_bitmap, column); if (!is_get_set_bitmap) { return false; } else { - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, 64); + column->default_text = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, 64); if (column->default_text == nullptr) { - tse_log_error("alloc mem for set default text failed, mem_start is null"); + ctc_log_error("alloc mem for set default text failed, mem_start is null"); return false; } sprintf(column->default_text, "%lld", set_bitmap); @@ -876,9 +876,9 @@ static bool tse_get_set_default_value( return true; } -static bool tse_verify_string_default_length(TcDb__TseDDLColumnDef *column, String* default_str, Field *field, +static bool ctc_verify_string_default_length(TcDb__CtcDDLColumnDef *column, String* default_str, Field *field, const Create_field *fld) { - if (column->datatype->datatype == TSE_DDL_TYPE_CLOB) { + if (column->datatype->datatype == CTC_DDL_TYPE_CLOB) { return true; } const CHARSET_INFO* col_charset = fld ? fld->charset : field->charset(); @@ -891,8 +891,8 @@ static bool tse_verify_string_default_length(TcDb__TseDDLColumnDef *column, Stri return true; } -static bool tse_get_string_default_value( - TcDb__TseDDLColumnDef *column, Field *field, const dd::Column *col_obj, const Create_field *fld, +static bool ctc_get_string_default_value( + TcDb__CtcDDLColumnDef *column, Field *field, const dd::Column *col_obj, const Create_field *fld, char **mem_start, char *mem_end, bool is_blob_type) { char *field_default_string = nullptr; if (fld == nullptr) { @@ -907,7 +907,7 @@ static bool tse_get_string_default_value( String* tmp_string_ptr; assert(field->m_default_val_expr); tmp_string_ptr = field->m_default_val_expr->expr_item->val_str(&tmp_string); - if (!is_blob_type && !tse_verify_string_default_length(column, tmp_string_ptr, field, fld)) { + if (!is_blob_type && !ctc_verify_string_default_length(column, tmp_string_ptr, field, fld)) { return false; } field_default_string = tmp_string_ptr->c_ptr(); @@ -921,17 +921,17 @@ static bool tse_get_string_default_value( } else { tmp_string_ptr = fld->m_default_val_expr->expr_item->val_str(&tmp_string); } - if (!tse_verify_string_default_length(column, tmp_string_ptr, field, fld)) { + if (!ctc_verify_string_default_length(column, tmp_string_ptr, field, fld)) { return false; } field_default_string = tmp_string_ptr->c_ptr(); } string expr_str(field_default_string); - return tse_process_string_default_value(column, expr_str, mem_start, mem_end, is_blob_type); + return ctc_process_string_default_value(column, expr_str, mem_start, mem_end, is_blob_type); } -static bool tse_get_numeric_default_value( - TcDb__TseDDLColumnDef *column, Field *field, const dd::Column *col_obj, const Create_field *fld, +static bool ctc_get_numeric_default_value( + TcDb__CtcDDLColumnDef *column, Field *field, const dd::Column *col_obj, const Create_field *fld, char **mem_start, char *mem_end, bool is_expr_value) { char *field_default_string = nullptr; @@ -942,9 +942,9 @@ static bool tse_get_numeric_default_value( if (expr_item->type() == Item::VARBIN_ITEM) { longlong num = expr_item->val_int(); uint32_t num_len = to_string(num).length(); - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, num_len + 1); + column->default_text = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, num_len + 1); if (column->default_text == nullptr) { - tse_log_error("alloc mem for set default text failed, mem_start is null"); + ctc_log_error("alloc mem for set default text failed, mem_start is null"); return false; } sprintf(column->default_text, "%llu", num); @@ -952,9 +952,9 @@ static bool tse_get_numeric_default_value( } else { field_default_string = expr_item->val_str(&tmp_string)->c_ptr(); int default_text_len = strlen(field_default_string); - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, default_text_len + 1); + column->default_text = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, default_text_len + 1); if (column->default_text == nullptr) { - tse_log_error("alloc mem for set default text failed, mem_start is null"); + ctc_log_error("alloc mem for set default text failed, mem_start is null"); return false; } strncpy(column->default_text, field_default_string, default_text_len + 1); @@ -962,9 +962,9 @@ static bool tse_get_numeric_default_value( } else { char *default_value = const_cast(col_obj->default_value_utf8().data()); int len = strlen(default_value); - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, len + 1); + column->default_text = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, len + 1); if (column->default_text == nullptr) { - tse_log_error("alloc mem for numeric default text failed, mem_start is null"); + ctc_log_error("alloc mem for numeric default text failed, mem_start is null"); return false; } strncpy(column->default_text, default_value, len + 1); @@ -972,8 +972,8 @@ static bool tse_get_numeric_default_value( return true; } -static bool tse_check_expression_default_value(TcDb__TseDDLColumnDef *column, Field *field, const Create_field *fld, - tse_column_option_set_bit *option_set, bool* is_expr_value) { +static bool ctc_check_expression_default_value(TcDb__CtcDDLColumnDef *column, Field *field, const Create_field *fld, + ctc_column_option_set_bit *option_set, bool* is_expr_value) { if ((field != nullptr && !field->m_default_val_expr) || (fld != nullptr && !fld->m_default_val_expr)) { //排除普通表达式 @@ -1006,21 +1006,21 @@ static bool tse_check_expression_default_value(TcDb__TseDDLColumnDef *column, Fi } -static bool tse_ddl_fill_column_default_value( - THD *thd, TcDb__TseDDLColumnDef *column, Field *field, const Create_field *fld, const dd::Column *col_obj, - tse_column_option_set_bit *option_set, char **mem_start, char *mem_end, const CHARSET_INFO *field_cs) { +static bool ctc_ddl_fill_column_default_value( + THD *thd, TcDb__CtcDDLColumnDef *column, Field *field, const Create_field *fld, const dd::Column *col_obj, + ctc_column_option_set_bit *option_set, char **mem_start, char *mem_end, const CHARSET_INFO *field_cs) { option_set->is_default = true; option_set->is_default_null = false; // function except DEFAULT CURRENT_TIMESTAMP and ON UPDATE CURRENT_TIMESTAMP - // CURRENT_TIMESTAMP and ON UPDATE CURRENT_TIMESTAMP is described in tse_get_datetime_default_value + // CURRENT_TIMESTAMP and ON UPDATE CURRENT_TIMESTAMP is described in ctc_get_datetime_default_value option_set->is_default_func = field->has_insert_default_general_value_expression() && !field->has_insert_default_datetime_value_expression() && !field->has_update_default_datetime_value_expression(); option_set->is_curr_timestamp = 0; bool is_expr_value = false; if (option_set->is_default_func) { - TSE_RETURN_IF_ERROR(tse_check_expression_default_value(column, field, fld, option_set, &is_expr_value), false); + CTC_RETURN_IF_ERROR(ctc_check_expression_default_value(column, field, fld, option_set, &is_expr_value), false); if (!is_expr_value) { return true; } @@ -1029,17 +1029,17 @@ static bool tse_ddl_fill_column_default_value( bool is_blob_type = false; switch (field->real_type()) { case MYSQL_TYPE_BIT: - TSE_RETURN_IF_ERROR(tse_get_bit_default_value(thd, column, field, fld, col_obj, mem_start, mem_end, is_expr_value), false); + CTC_RETURN_IF_ERROR(ctc_get_bit_default_value(thd, column, field, fld, col_obj, mem_start, mem_end, is_expr_value), false); break; case MYSQL_TYPE_BLOB: - is_blob_type = (column->datatype->datatype != TSE_DDL_TYPE_CLOB); + is_blob_type = (column->datatype->datatype != CTC_DDL_TYPE_CLOB); case MYSQL_TYPE_JSON: if (!is_expr_value) { char *default_value = const_cast(col_obj->default_value_utf8().data()); int len = strlen(default_value); - column->default_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, len + 1); + column->default_text = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, len + 1); if (column->default_text == nullptr) { - tse_log_error("alloc mem for json default text failed, mem_start is null"); + ctc_log_error("alloc mem for json default text failed, mem_start is null"); return false; } strncpy(column->default_text, default_value, len + 1); @@ -1047,30 +1047,30 @@ static bool tse_ddl_fill_column_default_value( } case MYSQL_TYPE_STRING: case MYSQL_TYPE_VARCHAR: - TSE_RETURN_IF_ERROR(tse_get_string_default_value(column, field, col_obj, fld, mem_start, mem_end, is_blob_type), false); + CTC_RETURN_IF_ERROR(ctc_get_string_default_value(column, field, col_obj, fld, mem_start, mem_end, is_blob_type), false); break; case MYSQL_TYPE_ENUM: - TSE_RETURN_IF_ERROR(tse_get_enum_default_value(thd, column, col_obj, field, fld, mem_start, mem_end, field_cs), false); + CTC_RETURN_IF_ERROR(ctc_get_enum_default_value(thd, column, col_obj, field, fld, mem_start, mem_end, field_cs), false); break; case MYSQL_TYPE_SET: - TSE_RETURN_IF_ERROR(tse_get_set_default_value(thd, column, field, fld, mem_start, mem_end, field_cs), false); + CTC_RETURN_IF_ERROR(ctc_get_set_default_value(thd, column, field, fld, mem_start, mem_end, field_cs), false); break; case MYSQL_TYPE_YEAR: case MYSQL_TYPE_NEWDATE: case MYSQL_TYPE_DATETIME2: case MYSQL_TYPE_TIMESTAMP2: case MYSQL_TYPE_TIME2: - TSE_RETURN_IF_ERROR(tse_get_datetime_default_value(column, field, fld, col_obj, mem_start, mem_end, option_set, is_expr_value), false); + CTC_RETURN_IF_ERROR(ctc_get_datetime_default_value(column, field, fld, col_obj, mem_start, mem_end, option_set, is_expr_value), false); break; default: - TSE_RETURN_IF_ERROR(tse_get_numeric_default_value(column, field, col_obj, fld, mem_start, mem_end, is_expr_value), false); + CTC_RETURN_IF_ERROR(ctc_get_numeric_default_value(column, field, col_obj, fld, mem_start, mem_end, is_expr_value), false); break; } return true; } -static void tse_fill_column_option_set(TcDb__TseDDLColumnDef *column, Field *field, - TABLE *form, tse_column_option_set_bit *option_set) { +static void ctc_fill_column_option_set(TcDb__CtcDDLColumnDef *column, Field *field, + TABLE *form, ctc_column_option_set_bit *option_set) { column->is_option_set = 0; option_set->is_option_set= 0; option_set->primary = false; @@ -1102,15 +1102,15 @@ static void tse_fill_column_option_set(TcDb__TseDDLColumnDef *column, Field *fie } const field_cnvrt_aux_t *mysql_info = get_auxiliary_for_field_convert(field, field->real_type()); if (mysql_info->sql_data_type == STRING_DATA || mysql_info->sql_data_type == LOB_DATA) { - column->collate = tse_get_column_cs(field->charset()); + column->collate = ctc_get_column_cs(field->charset()); option_set->is_collate = 1; } } -static bool tse_ddl_fill_column_by_field( - THD *thd, TcDb__TseDDLColumnDef *column, Field *field, +static bool ctc_ddl_fill_column_by_field( + THD *thd, TcDb__CtcDDLColumnDef *column, Field *field, const dd::Table *table_def, TABLE *form, const Create_field *fld, - tse_alter_column_alter_mode alter_mode, char **mem_start, char *mem_end, const CHARSET_INFO *field_cs) { + ctc_alter_column_alter_mode alter_mode, char **mem_start, char *mem_end, const CHARSET_INFO *field_cs) { const dd::Column *col_obj = NULL; col_obj = table_def ? table_def->get_column(field->field_name) : nullptr; // create view中创临时表，table_def为空 /* @@ -1130,13 +1130,13 @@ static bool tse_ddl_fill_column_by_field( column->name = const_cast(field->field_name); } - TSE_RETURN_IF_ERROR(tse_ddl_fill_column_by_field_fill_type(column, field), false); + CTC_RETURN_IF_ERROR(ctc_ddl_fill_column_by_field_fill_type(column, field), false); - tse_column_option_set_bit option_set; - tse_fill_column_option_set(column, field, form, &option_set); + ctc_column_option_set_bit option_set; + ctc_fill_column_option_set(column, field, form, &option_set); - if (tse_is_with_default_value(field, col_obj)) { - TSE_RETURN_IF_ERROR(tse_ddl_fill_column_default_value(thd, column, field, fld, col_obj, + if (ctc_is_with_default_value(field, col_obj)) { + CTC_RETURN_IF_ERROR(ctc_ddl_fill_column_default_value(thd, column, field, fld, col_obj, &option_set, mem_start, mem_end, field_cs), false); } else { option_set.is_default = 0; @@ -1146,27 +1146,27 @@ static bool tse_ddl_fill_column_by_field( } // 这句代码要放在所有设置option_set的后面 column->is_option_set = option_set.is_option_set; - column->alter_mode = alter_mode; // tse_alter_column_alter_mode + column->alter_mode = alter_mode; // ctc_alter_column_alter_mode return true; } -static int tse_ddl_alter_table_fill_foreign_key_info(TcDb__TseDDLForeignKeyDef *fk_def, const Foreign_key_spec *fk, +static int ctc_ddl_alter_table_fill_foreign_key_info(TcDb__CtcDDLForeignKeyDef *fk_def, const Foreign_key_spec *fk, char **mem_start, char *mem_end) { - TSE_RETURN_IF_NOT_ZERO(check_tse_identifier_name(fk->name.str)); + CTC_RETURN_IF_NOT_ZERO(check_ctc_identifier_name(fk->name.str)); fk_def->name = const_cast(fk->name.str); - fk_def->delete_opt = tse_ddl_get_foreign_key_rule(fk->delete_opt); - fk_def->update_opt = tse_ddl_get_foreign_key_rule(fk->update_opt); + fk_def->delete_opt = ctc_ddl_get_foreign_key_rule(fk->delete_opt); + fk_def->update_opt = ctc_ddl_get_foreign_key_rule(fk->update_opt); size_t buf_len = fk->ref_db.length + 1; - fk_def->referenced_table_schema_name = (char *)tse_ddl_alloc_mem(mem_start, mem_end, buf_len); + fk_def->referenced_table_schema_name = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, buf_len); if (fk_def->referenced_table_schema_name == nullptr) { return HA_ERR_OUT_OF_MEM; } - tse_copy_name(fk_def->referenced_table_schema_name, fk->ref_db.str, buf_len); + ctc_copy_name(fk_def->referenced_table_schema_name, fk->ref_db.str, buf_len); fk_def->referenced_table_name = const_cast(fk->ref_table.str); for (uint j = 0; j < fk_def->n_elements; j++) { - TcDb__TseDDLForeignKeyElementDef *fk_ele = fk_def->elements[j]; + TcDb__CtcDDLForeignKeyElementDef *fk_ele = fk_def->elements[j]; fk_ele->src_column_name = const_cast(fk->columns[j]->get_field_name()); fk_ele->ref_column_name = @@ -1175,30 +1175,30 @@ static int tse_ddl_alter_table_fill_foreign_key_info(TcDb__TseDDLForeignKeyDef * return CT_SUCCESS; } -static int tse_ddl_create_table_fill_foreign_key_info(TcDb__TseDDLCreateTableDef *req, +static int ctc_ddl_create_table_fill_foreign_key_info(TcDb__CtcDDLCreateTableDef *req, const dd::Table *table_def, char **mem_start, char *mem_end) { if (req->n_fk_list == 0) { return CT_SUCCESS; } for (uint i = 0; i < req->n_fk_list; i++) { - TcDb__TseDDLForeignKeyDef *fk_def = req->fk_list[i]; + TcDb__CtcDDLForeignKeyDef *fk_def = req->fk_list[i]; assert(table_def != nullptr); const dd::Foreign_key *fk = table_def->foreign_keys().at(i); - TSE_RETURN_IF_NOT_ZERO(check_tse_identifier_name(fk->name().data())); + CTC_RETURN_IF_NOT_ZERO(check_ctc_identifier_name(fk->name().data())); fk_def->name = const_cast(fk->name().data()); - fk_def->delete_opt = tse_ddl_get_foreign_key_rule(fk->delete_rule()); - fk_def->update_opt = tse_ddl_get_foreign_key_rule(fk->update_rule()); + fk_def->delete_opt = ctc_ddl_get_foreign_key_rule(fk->delete_rule()); + fk_def->update_opt = ctc_ddl_get_foreign_key_rule(fk->update_rule()); size_t buf_len = fk->referenced_table_schema_name().length() + 1; - fk_def->referenced_table_schema_name = (char *)tse_ddl_alloc_mem(mem_start, mem_end, buf_len); + fk_def->referenced_table_schema_name = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, buf_len); if (fk_def->referenced_table_schema_name == nullptr) { return HA_ERR_OUT_OF_MEM; } - tse_copy_name(fk_def->referenced_table_schema_name, fk->referenced_table_schema_name().data(), buf_len); + ctc_copy_name(fk_def->referenced_table_schema_name, fk->referenced_table_schema_name().data(), buf_len); fk_def->referenced_table_name = const_cast(fk->referenced_table_name().data()); for (uint j = 0; j < fk_def->n_elements; j++) { - TcDb__TseDDLForeignKeyElementDef *fk_ele = fk_def->elements[j]; + TcDb__CtcDDLForeignKeyElementDef *fk_ele = fk_def->elements[j]; const dd::Foreign_key_element *fk_col_obj = fk->elements().at(j); fk_ele->src_column_name = const_cast(fk_col_obj->column().name().data()); @@ -1209,7 +1209,7 @@ static int tse_ddl_create_table_fill_foreign_key_info(TcDb__TseDDLCreateTableDef return CT_SUCCESS; } -static void tse_fill_prefix_func_key_part(TcDb__TseDDLTableKeyPart *req_key_part, +static void ctc_fill_prefix_func_key_part(TcDb__CtcDDLTableKeyPart *req_key_part, const Field *field, uint16 prefix_len) { req_key_part->is_func = true; if (field->real_type() == MYSQL_TYPE_BLOB && field->charset() == &my_charset_bin && @@ -1225,19 +1225,19 @@ static void tse_fill_prefix_func_key_part(TcDb__TseDDLTableKeyPart *req_key_part return; } -static uint32_t tse_fill_func_key_part(TABLE *form, THD *thd, TcDb__TseDDLTableKeyPart *req_key_part, Value_generator *gcol_info) +static uint32_t ctc_fill_func_key_part(TABLE *form, THD *thd, TcDb__CtcDDLTableKeyPart *req_key_part, Value_generator *gcol_info) { Item_func *func_expr_item = dynamic_cast(gcol_info->expr_item); if (func_expr_item == nullptr) { my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), - "[TSE_CREATE_TABLE]: CTC do not support this functional index."); + "[CTC_CREATE_TABLE]: CTC do not support this functional index."); return CT_ERROR; } uint32_t arg_count = func_expr_item->arg_count; if (arg_count == 0) { my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), - "[TSE_CREATE_TABLE]: There is no functional index."); + "[CTC_CREATE_TABLE]: There is no functional index."); return CT_ERROR; } @@ -1247,7 +1247,7 @@ static uint32_t tse_fill_func_key_part(TABLE *form, THD *thd, TcDb__TseDDLTableK uint32_t col_item_count = 0; Field *field = nullptr; for (uint32_t i = 0; i < arg_count; i++) { - field = tse_get_field_by_name(form, const_cast(args[i]->item_name.ptr())); + field = ctc_get_field_by_name(form, const_cast(args[i]->item_name.ptr())); if (field && field->is_gcol()) { my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), "Cantian does not support index on generated column."); @@ -1284,7 +1284,7 @@ static uint32_t tse_fill_func_key_part(TABLE *form, THD *thd, TcDb__TseDDLTableK return CT_SUCCESS; } -static bool tse_ddl_create_table_fill_add_key(TcDb__TseDDLCreateTableDef *req, THD *thd, +static bool ctc_ddl_create_table_fill_add_key(TcDb__CtcDDLCreateTableDef *req, THD *thd, const dd::Table *table_def, TABLE *form, char *user) { if (req->n_key_list == 0) { return true; @@ -1292,7 +1292,7 @@ static bool tse_ddl_create_table_fill_add_key(TcDb__TseDDLCreateTableDef *req, T if (table_def == nullptr) { for (uint i = 0; i < req->n_key_list; i++) { - TcDb__TseDDLTableKey *req_key_def = req->key_list[i]; + TcDb__CtcDDLTableKey *req_key_def = req->key_list[i]; const KEY *key = form->key_info + i; if (key->key_length == 0) { my_error(ER_WRONG_KEY_COLUMN, MYF(0), key->key_part->field->field_name); @@ -1300,16 +1300,16 @@ static bool tse_ddl_create_table_fill_add_key(TcDb__TseDDLCreateTableDef *req, T } req_key_def->user = user; req_key_def->table = req->name; - TSE_RETURN_IF_NOT_ZERO(check_tse_identifier_name(key->name)); + CTC_RETURN_IF_NOT_ZERO(check_ctc_identifier_name(key->name)); req_key_def->name = const_cast(key->name); req_key_def->space = NULL; - TSE_RETURN_IF_ERROR(get_tse_key_type(key, &req_key_def->key_type), false); - TSE_RETURN_IF_ERROR(get_tse_key_algorithm(key->algorithm, &req_key_def->algorithm), false); - if (req_key_def->key_type == TSE_KEYTYPE_PRIMARY || req_key_def->key_type == TSE_KEYTYPE_UNIQUE) { + CTC_RETURN_IF_ERROR(get_ctc_key_type(key, &req_key_def->key_type), false); + CTC_RETURN_IF_ERROR(get_ctc_key_algorithm(key->algorithm, &req_key_def->algorithm), false); + if (req_key_def->key_type == CTC_KEYTYPE_PRIMARY || req_key_def->key_type == CTC_KEYTYPE_UNIQUE) { req_key_def->is_constraint = true; } for (uint j = 0; j < req_key_def->n_columns; j++) { - TcDb__TseDDLTableKeyPart *req_key_part = req_key_def->columns[j]; + TcDb__CtcDDLTableKeyPart *req_key_part = req_key_def->columns[j]; KEY_PART_INFO *key_part = key->key_part + j; if (key_part->key_part_flag & HA_REVERSE_SORT) { req_key_def->is_dsc = true; @@ -1320,7 +1320,7 @@ static bool tse_ddl_create_table_fill_add_key(TcDb__TseDDLCreateTableDef *req, T assert(fld != nullptr); if (fld->is_field_for_functional_index()) { req_key_def->is_func = true; - TSE_RETURN_IF_ERROR(tse_fill_func_key_part(form, thd, req_key_part, fld->gcol_info) == CT_SUCCESS, false); + CTC_RETURN_IF_ERROR(ctc_fill_func_key_part(form, thd, req_key_part, fld->gcol_info) == CT_SUCCESS, false); } else { if (fld->is_virtual_gcol()) { my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), @@ -1330,7 +1330,7 @@ static bool tse_ddl_create_table_fill_add_key(TcDb__TseDDLCreateTableDef *req, T uint prefix_len = get_prefix_index_len(fld, key_part->length); if (prefix_len) { - tse_fill_prefix_func_key_part(req_key_part, fld, prefix_len); + ctc_fill_prefix_func_key_part(req_key_part, fld, prefix_len); is_prefix_key = true; } else { req_key_part->is_func = false; @@ -1339,10 +1339,10 @@ static bool tse_ddl_create_table_fill_add_key(TcDb__TseDDLCreateTableDef *req, T req_key_part->name = const_cast(key_part->field->field_name); } req_key_part->length = key_part->length; - tse_ddl_get_data_type_from_mysql_type(fld, fld->type(), &req_key_part->datatype); - tse_set_unsigned_column(fld, &req_key_part->is_unsigned); + ctc_ddl_get_data_type_from_mysql_type(fld, fld->type(), &req_key_part->datatype); + ctc_set_unsigned_column(fld, &req_key_part->is_unsigned); if (is_prefix_key && fld->is_flag_set(BLOB_FLAG)) { - req_key_part->datatype = TSE_DDL_TYPE_VARCHAR; + req_key_part->datatype = CTC_DDL_TYPE_VARCHAR; } } } @@ -1350,31 +1350,31 @@ static bool tse_ddl_create_table_fill_add_key(TcDb__TseDDLCreateTableDef *req, T } for (uint i = 0; i < req->n_key_list; i++) { - TcDb__TseDDLTableKey *req_key_def = req->key_list[i]; + TcDb__CtcDDLTableKey *req_key_def = req->key_list[i]; assert(table_def != nullptr); const dd::Index *idx = table_def->indexes().at(i); req_key_def->user = user; req_key_def->table = req->name; - TSE_RETURN_IF_NOT_ZERO(check_tse_identifier_name(idx->name().data())); + CTC_RETURN_IF_NOT_ZERO(check_ctc_identifier_name(idx->name().data())); req_key_def->name = const_cast(idx->name().data()); req_key_def->space = NULL; - TSE_RETURN_IF_ERROR(tse_ddl_get_create_key_type(idx->type(), &req_key_def->key_type), false); - TSE_RETURN_IF_ERROR(tse_ddl_get_create_key_algorithm(idx->algorithm(), &req_key_def->algorithm), false); + CTC_RETURN_IF_ERROR(ctc_ddl_get_create_key_type(idx->type(), &req_key_def->key_type), false); + CTC_RETURN_IF_ERROR(ctc_ddl_get_create_key_algorithm(idx->algorithm(), &req_key_def->algorithm), false); for (uint j = 0; j < req_key_def->n_columns; j++) { - TcDb__TseDDLTableKeyPart *req_key_part = req_key_def->columns[j]; + TcDb__CtcDDLTableKeyPart *req_key_part = req_key_def->columns[j]; const dd::Index_element *key_part = idx->elements().at(j); if (key_part->order() == dd::Index_element::ORDER_DESC) { req_key_def->is_dsc = true; } bool is_prefix_key = false; assert(key_part != NULL); - Field *fld = tse_get_field_by_name(form, key_part->column().name().data()); + Field *fld = ctc_get_field_by_name(form, key_part->column().name().data()); assert(fld != nullptr); if (fld->is_field_for_functional_index()) { req_key_def->is_func = true; - TSE_RETURN_IF_ERROR(tse_fill_func_key_part(form, thd, req_key_part, fld->gcol_info) == CT_SUCCESS, false); + CTC_RETURN_IF_ERROR(ctc_fill_func_key_part(form, thd, req_key_part, fld->gcol_info) == CT_SUCCESS, false); } else { if (fld->is_virtual_gcol()) { my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), @@ -1384,7 +1384,7 @@ static bool tse_ddl_create_table_fill_add_key(TcDb__TseDDLCreateTableDef *req, T uint prefix_len = get_prefix_index_len(fld, key_part->length()); if (prefix_len) { - tse_fill_prefix_func_key_part(req_key_part, fld, prefix_len); + ctc_fill_prefix_func_key_part(req_key_part, fld, prefix_len); is_prefix_key = true; } else { req_key_part->is_func = false; @@ -1393,37 +1393,37 @@ static bool tse_ddl_create_table_fill_add_key(TcDb__TseDDLCreateTableDef *req, T req_key_part->name = const_cast(key_part->column().name().data()); } req_key_part->length = key_part->length(); - tse_ddl_get_data_type_from_mysql_type(fld, fld->type(), &req_key_part->datatype); - tse_set_unsigned_column(fld, &req_key_part->is_unsigned); + ctc_ddl_get_data_type_from_mysql_type(fld, fld->type(), &req_key_part->datatype); + ctc_set_unsigned_column(fld, &req_key_part->is_unsigned); if (is_prefix_key && fld->is_flag_set(BLOB_FLAG)) { - req_key_part->datatype = TSE_DDL_TYPE_VARCHAR; + req_key_part->datatype = CTC_DDL_TYPE_VARCHAR; } } } return true; } -static int tse_ddl_fill_partition_table_info(const dd::Partition *pt, char **mem_start, char *mem_end, - TcDb__TseDDLPartitionDef *part_def, uint32_t part_id) +static int ctc_ddl_fill_partition_table_info(const dd::Partition *pt, char **mem_start, char *mem_end, + TcDb__CtcDDLPartitionDef *part_def, uint32_t part_id) { - TcDb__TseDDLPartitionTableDef *part_table = part_def->part_table_list[part_id]; + TcDb__CtcDDLPartitionTableDef *part_table = part_def->part_table_list[part_id]; part_table->name = const_cast(pt->name().data()); part_table->n_subpart_table_list = pt->subpartitions().size(); if (part_table->n_subpart_table_list > 0) { part_table->subpart_table_list = - (TcDb__TseDDLPartitionTableDef **)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(TcDb__TseDDLPartitionTableDef *) * pt->subpartitions().size()); + (TcDb__CtcDDLPartitionTableDef **)ctc_ddl_alloc_mem(mem_start, mem_end, sizeof(TcDb__CtcDDLPartitionTableDef *) * pt->subpartitions().size()); if (part_table->subpart_table_list == NULL) { return HA_ERR_OUT_OF_MEM; } - TcDb__TseDDLPartitionTableDef **subpart_table_list = part_table->subpart_table_list; + TcDb__CtcDDLPartitionTableDef **subpart_table_list = part_table->subpart_table_list; uint32_t i = 0; for (const dd::Partition *sub_part_obj : pt->subpartitions()) { - subpart_table_list[i] = (TcDb__TseDDLPartitionTableDef *)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(TcDb__TseDDLPartitionTableDef)); + subpart_table_list[i] = (TcDb__CtcDDLPartitionTableDef *)ctc_ddl_alloc_mem(mem_start, mem_end, sizeof(TcDb__CtcDDLPartitionTableDef)); if (subpart_table_list[i] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlpartition_table_def__init(subpart_table_list[i]); - TcDb__TseDDLPartitionTableDef *sub_part_table = part_table->subpart_table_list[i]; + tc_db__ctc_ddlpartition_table_def__init(subpart_table_list[i]); + TcDb__CtcDDLPartitionTableDef *sub_part_table = part_table->subpart_table_list[i]; sub_part_table->name = const_cast(sub_part_obj->name().data()); i++; } @@ -1431,20 +1431,20 @@ static int tse_ddl_fill_partition_table_info(const dd::Partition *pt, char **mem return 0; } -static int tse_ddl_prepare_create_partition_info(TcDb__TseDDLCreateTableDef *req, const dd::Table *table_def, +static int ctc_ddl_prepare_create_partition_info(TcDb__CtcDDLCreateTableDef *req, const dd::Table *table_def, char **mem_start, char *mem_end) { - req->partition_def = (TcDb__TseDDLPartitionDef *)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(TcDb__TseDDLPartitionDef)); + req->partition_def = (TcDb__CtcDDLPartitionDef *)ctc_ddl_alloc_mem(mem_start, mem_end, sizeof(TcDb__CtcDDLPartitionDef)); if (req->partition_def == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlpartition_def__init(req->partition_def); - int ret = convert_tse_part_type(table_def->partition_type(), &req->partition_def->part_type); + tc_db__ctc_ddlpartition_def__init(req->partition_def); + int ret = convert_ctc_part_type(table_def->partition_type(), &req->partition_def->part_type); if (ret != 0) { return ret; } - ret = convert_tse_subpart_type(table_def->subpartition_type(), &req->partition_def->subpart_type); + ret = convert_ctc_subpart_type(table_def->subpartition_type(), &req->partition_def->subpart_type); if (ret != 0) { return ret; } @@ -1452,118 +1452,118 @@ static int tse_ddl_prepare_create_partition_info(TcDb__TseDDLCreateTableDef *req req->partition_def->n_part_table_list = table_def->partitions().size(); req->partition_def->part_table_list = - (TcDb__TseDDLPartitionTableDef **)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(TcDb__TseDDLPartitionTableDef *) * req->partition_def->n_part_table_list); + (TcDb__CtcDDLPartitionTableDef **)ctc_ddl_alloc_mem(mem_start, mem_end, sizeof(TcDb__CtcDDLPartitionTableDef *) * req->partition_def->n_part_table_list); if (req->partition_def->part_table_list == NULL) { return HA_ERR_OUT_OF_MEM; } - TcDb__TseDDLPartitionTableDef **part_table_list = req->partition_def->part_table_list; + TcDb__CtcDDLPartitionTableDef **part_table_list = req->partition_def->part_table_list; uint32_t i = 0; for (const dd::Partition *pt : table_def->partitions()) { - part_table_list[i] = (TcDb__TseDDLPartitionTableDef *)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(TcDb__TseDDLPartitionTableDef)); + part_table_list[i] = (TcDb__CtcDDLPartitionTableDef *)ctc_ddl_alloc_mem(mem_start, mem_end, sizeof(TcDb__CtcDDLPartitionTableDef)); if (part_table_list[i] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlpartition_table_def__init(part_table_list[i]); - TSE_RETURN_IF_NOT_ZERO(tse_ddl_fill_partition_table_info(pt, mem_start, mem_end, req->partition_def, i)); + tc_db__ctc_ddlpartition_table_def__init(part_table_list[i]); + CTC_RETURN_IF_NOT_ZERO(ctc_ddl_fill_partition_table_info(pt, mem_start, mem_end, req->partition_def, i)); i++; } return 0; } -static int tse_ddl_init_column_def(TcDb__TseDDLCreateTableDef *req, char **mem_start, char *mem_end) { - req->columns = (TcDb__TseDDLColumnDef **)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLColumnDef*) * req->n_columns); +static int ctc_ddl_init_column_def(TcDb__CtcDDLCreateTableDef *req, char **mem_start, char *mem_end) { + req->columns = (TcDb__CtcDDLColumnDef **)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLColumnDef*) * req->n_columns); if (req->columns == NULL) { return HA_ERR_OUT_OF_MEM; } for (uint i = 0; i < req->n_columns; i++) { - req->columns[i] = (TcDb__TseDDLColumnDef *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLColumnDef)); + req->columns[i] = (TcDb__CtcDDLColumnDef *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLColumnDef)); if (req->columns[i] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlcolumn_def__init(req->columns[i]); - TcDb__TseDDLColumnDef *column = req->columns[i]; - column->datatype = (TcDb__TseDDLColumnDataTypeDef *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLColumnDataTypeDef)); + tc_db__ctc_ddlcolumn_def__init(req->columns[i]); + TcDb__CtcDDLColumnDef *column = req->columns[i]; + column->datatype = (TcDb__CtcDDLColumnDataTypeDef *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLColumnDataTypeDef)); if (column->datatype == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlcolumn_data_type_def__init(column->datatype); + tc_db__ctc_ddlcolumn_data_type_def__init(column->datatype); } return 0; } -static int tse_ddl_init_foreign_key_def(TcDb__TseDDLCreateTableDef *req, const dd::Table *table_def, +static int ctc_ddl_init_foreign_key_def(TcDb__CtcDDLCreateTableDef *req, const dd::Table *table_def, char **mem_start, char *mem_end) { - req->fk_list = (TcDb__TseDDLForeignKeyDef **)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLForeignKeyDef*) * req->n_fk_list); + req->fk_list = (TcDb__CtcDDLForeignKeyDef **)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLForeignKeyDef*) * req->n_fk_list); if (req->fk_list == NULL) { return HA_ERR_OUT_OF_MEM; } for (uint i = 0; i < req->n_fk_list; i++) { - req->fk_list[i] = (TcDb__TseDDLForeignKeyDef *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLForeignKeyDef)); + req->fk_list[i] = (TcDb__CtcDDLForeignKeyDef *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLForeignKeyDef)); if (req->fk_list[i] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlforeign_key_def__init(req->fk_list[i]); - TcDb__TseDDLForeignKeyDef *fk_def = req->fk_list[i]; + tc_db__ctc_ddlforeign_key_def__init(req->fk_list[i]); + TcDb__CtcDDLForeignKeyDef *fk_def = req->fk_list[i]; const dd::Foreign_key *fk = table_def->foreign_keys().at(i); fk_def->n_elements = fk->elements().size(); - fk_def->elements = (TcDb__TseDDLForeignKeyElementDef **)tse_ddl_alloc_mem( + fk_def->elements = (TcDb__CtcDDLForeignKeyElementDef **)ctc_ddl_alloc_mem( mem_start, mem_end, - sizeof(TcDb__TseDDLForeignKeyElementDef*) * fk_def->n_elements); + sizeof(TcDb__CtcDDLForeignKeyElementDef*) * fk_def->n_elements); if (fk_def->elements == NULL) { return HA_ERR_OUT_OF_MEM; } for (uint j = 0; j < fk_def->n_elements; j++) { - fk_def->elements[j] = (TcDb__TseDDLForeignKeyElementDef *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLForeignKeyElementDef)); + fk_def->elements[j] = (TcDb__CtcDDLForeignKeyElementDef *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLForeignKeyElementDef)); if (fk_def->elements[j] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlforeign_key_element_def__init(fk_def->elements[j]); + tc_db__ctc_ddlforeign_key_element_def__init(fk_def->elements[j]); } } return 0; } -static int tse_ddl_init_index_def(TcDb__TseDDLCreateTableDef *req, const dd::Table *table_def, +static int ctc_ddl_init_index_def(TcDb__CtcDDLCreateTableDef *req, const dd::Table *table_def, char **mem_start, char *mem_end) { - req->key_list = (TcDb__TseDDLTableKey **)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLTableKey*) * req->n_key_list); + req->key_list = (TcDb__CtcDDLTableKey **)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLTableKey*) * req->n_key_list); if (req->key_list == NULL) { return HA_ERR_OUT_OF_MEM; } for (uint i = 0; i < req->n_key_list; i++) { - req->key_list[i] = (TcDb__TseDDLTableKey *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLTableKey)); + req->key_list[i] = (TcDb__CtcDDLTableKey *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLTableKey)); if (req->key_list[i] == NULL) { return HA_ERR_OUT_OF_MEM; } - TcDb__TseDDLTableKey *req_key = req->key_list[i]; - tc_db__tse_ddltable_key__init(req_key); + TcDb__CtcDDLTableKey *req_key = req->key_list[i]; + tc_db__ctc_ddltable_key__init(req_key); const dd::Index *idx = table_def->indexes().at(i); assert(idx != NULL); req_key->n_columns = idx->elements().size(); - req_key->columns = (TcDb__TseDDLTableKeyPart **)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLTableKeyPart*) * req_key->n_columns); + req_key->columns = (TcDb__CtcDDLTableKeyPart **)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLTableKeyPart*) * req_key->n_columns); if (req_key->columns == NULL) { return HA_ERR_OUT_OF_MEM; } for (uint j = 0; j < req_key->n_columns; j++) { - req_key->columns[j] = (TcDb__TseDDLTableKeyPart *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLTableKeyPart)); + req_key->columns[j] = (TcDb__CtcDDLTableKeyPart *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLTableKeyPart)); if (req_key->columns[j] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddltable_key_part__init(req_key->columns[j]); - req_key->columns[j]->func_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, FUNC_TEXT_MAX_LEN); + tc_db__ctc_ddltable_key_part__init(req_key->columns[j]); + req_key->columns[j]->func_text = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, FUNC_TEXT_MAX_LEN); assert(req_key->columns[j]->func_text != NULL); memset(req_key->columns[j]->func_text, 0, FUNC_TEXT_MAX_LEN); } @@ -1571,14 +1571,14 @@ static int tse_ddl_init_index_def(TcDb__TseDDLCreateTableDef *req, const dd::Tab return 0; } -static int tse_ddl_init_index_form(TcDb__TseDDLCreateTableDef *req, TABLE *form, +static int ctc_ddl_init_index_form(TcDb__CtcDDLCreateTableDef *req, TABLE *form, char **mem_start, char *mem_end) { req->n_key_list = form->s->keys; if (req->n_key_list > 0) { - req->key_list = (TcDb__TseDDLTableKey **)tse_ddl_alloc_mem( + req->key_list = (TcDb__CtcDDLTableKey **)ctc_ddl_alloc_mem( mem_start, mem_end, - sizeof(TcDb__TseDDLTableKey*) * req->n_key_list); + sizeof(TcDb__CtcDDLTableKey*) * req->n_key_list); if (req->key_list == NULL) { return HA_ERR_OUT_OF_MEM; } @@ -1588,28 +1588,28 @@ static int tse_ddl_init_index_form(TcDb__TseDDLCreateTableDef *req, TABLE *form, my_error(ER_WRONG_KEY_COLUMN, MYF(0), key->key_part->field->field_name); return ER_WRONG_KEY_COLUMN; } - req->key_list[i] = (TcDb__TseDDLTableKey *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLTableKey)); + req->key_list[i] = (TcDb__CtcDDLTableKey *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLTableKey)); if (req->key_list[i] == NULL) { return HA_ERR_OUT_OF_MEM; } - TcDb__TseDDLTableKey *req_key = req->key_list[i]; - tc_db__tse_ddltable_key__init(req_key); + TcDb__CtcDDLTableKey *req_key = req->key_list[i]; + tc_db__ctc_ddltable_key__init(req_key); req_key->n_columns = key->user_defined_key_parts; - req_key->columns = (TcDb__TseDDLTableKeyPart **)tse_ddl_alloc_mem( + req_key->columns = (TcDb__CtcDDLTableKeyPart **)ctc_ddl_alloc_mem( mem_start, mem_end, - sizeof(TcDb__TseDDLTableKeyPart*) * req_key->n_columns); + sizeof(TcDb__CtcDDLTableKeyPart*) * req_key->n_columns); if (req_key->columns == NULL) { return HA_ERR_OUT_OF_MEM; } for (uint j = 0; j < req_key->n_columns; j++) { - req_key->columns[j] = (TcDb__TseDDLTableKeyPart *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLTableKeyPart)); + req_key->columns[j] = (TcDb__CtcDDLTableKeyPart *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLTableKeyPart)); if (req_key->columns[j] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddltable_key_part__init(req_key->columns[j]); - req_key->columns[j]->func_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, FUNC_TEXT_MAX_LEN); + tc_db__ctc_ddltable_key_part__init(req_key->columns[j]); + req_key->columns[j]->func_text = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, FUNC_TEXT_MAX_LEN); assert(req_key->columns[j]->func_text != NULL); memset(req_key->columns[j]->func_text, 0, FUNC_TEXT_MAX_LEN); } @@ -1618,35 +1618,35 @@ static int tse_ddl_init_index_form(TcDb__TseDDLCreateTableDef *req, TABLE *form, return 0; } -static int tse_ddl_init_create_table_def(TcDb__TseDDLCreateTableDef *req, +static int ctc_ddl_init_create_table_def(TcDb__CtcDDLCreateTableDef *req, TABLE *form, THD *thd, const dd::Table *table_def, char **mem_start, char *mem_end) { uint fields = form->s->fields; - tc_db__tse_ddlcreate_table_def__init(req); - DBUG_EXECUTE_IF("tse_create_table_max_column", { fields = REC_MAX_N_USER_FIELDS + 1; }); + tc_db__ctc_ddlcreate_table_def__init(req); + DBUG_EXECUTE_IF("ctc_create_table_max_column", { fields = REC_MAX_N_USER_FIELDS + 1; }); if (fields > REC_MAX_N_USER_FIELDS) { - tse_log_system("Max filed %d > %d, sql:%s", fields, REC_MAX_N_USER_FIELDS, + ctc_log_system("Max filed %d > %d, sql:%s", fields, REC_MAX_N_USER_FIELDS, thd->query().str); return HA_ERR_TOO_MANY_FIELDS; } req->n_columns = fields; if (req->n_columns > 0) { - TSE_RETURN_IF_NOT_ZERO(tse_ddl_init_column_def(req, mem_start, mem_end)); + CTC_RETURN_IF_NOT_ZERO(ctc_ddl_init_column_def(req, mem_start, mem_end)); } if (table_def == nullptr) { - return tse_ddl_init_index_form(req, form, mem_start, mem_end); + return ctc_ddl_init_index_form(req, form, mem_start, mem_end); } req->n_key_list = table_def->indexes().size(); if (req->n_key_list > 0) { - TSE_RETURN_IF_NOT_ZERO(tse_ddl_init_index_def(req, table_def, mem_start, mem_end)); + CTC_RETURN_IF_NOT_ZERO(ctc_ddl_init_index_def(req, table_def, mem_start, mem_end)); } req->n_fk_list = table_def->foreign_keys().size(); if (req->n_fk_list > 0) { - TSE_RETURN_IF_NOT_ZERO(tse_ddl_init_foreign_key_def(req, table_def, mem_start, mem_end)); + CTC_RETURN_IF_NOT_ZERO(ctc_ddl_init_foreign_key_def(req, table_def, mem_start, mem_end)); } if (table_def->partitions().size() > 0) { @@ -1656,30 +1656,30 @@ static int tse_ddl_init_create_table_def(TcDb__TseDDLCreateTableDef *req, "The number of subpartitions of one parent partition exceeds the maximum %d.", MYF(0), MAX_SUBPART_NUM); return -1; } - int ret = tse_ddl_prepare_create_partition_info(req, table_def, mem_start, mem_end); + int ret = ctc_ddl_prepare_create_partition_info(req, table_def, mem_start, mem_end); if (ret != 0) { - tse_log_system("tse_ddl_prepare_create_partition_info failed , ret = %d.", ret); + ctc_log_system("ctc_ddl_prepare_create_partition_info failed , ret = %d.", ret); return ret; } } return 0; } -int ha_tse_truncate_table(tianchi_handler_t *tch, THD *thd, const char *db_name, const char *table_name, bool is_tmp_table) { +int ha_ctc_truncate_table(ctc_handler_t *tch, THD *thd, const char *db_name, const char *table_name, bool is_tmp_table) { assert(thd->lex->sql_command == SQLCOM_TRUNCATE); ct_errno_t ret = CT_SUCCESS; size_t msg_len = 0; - tse_ddl_stack_mem stack_mem(0); - void *tse_ddl_req_msg_mem = nullptr; + ctc_ddl_stack_mem stack_mem(0); + void *ctc_ddl_req_msg_mem = nullptr; { - TcDb__TseDDLTruncateTableDef req; - tc_db__tse_ddltruncate_table_def__init(&req); + TcDb__CtcDDLTruncateTableDef req; + tc_db__ctc_ddltruncate_table_def__init(&req); char user_name[SMALL_RECORD_SIZE] = { 0 }; - tse_copy_name(user_name, db_name, SMALL_RECORD_SIZE); + ctc_copy_name(user_name, db_name, SMALL_RECORD_SIZE); req.schema = const_cast(user_name); req.name = const_cast(table_name); - req.db_name = TSE_GET_THD_DB_NAME(thd); + req.db_name = CTC_GET_THD_DB_NAME(thd); string sql; if (is_tmp_table) { // truncate临时表不需要广播 req.sql_str = nullptr; @@ -1690,48 +1690,48 @@ int ha_tse_truncate_table(tianchi_handler_t *tch, THD *thd, const char *db_name, if (thd->variables.option_bits & OPTION_NO_FOREIGN_KEY_CHECKS) { req.no_check_fk = 1; } - msg_len = tc_db__tse_ddltruncate_table_def__get_packed_size(&req); + msg_len = tc_db__ctc_ddltruncate_table_def__get_packed_size(&req); stack_mem.set_mem_size(msg_len + sizeof(ddl_ctrl_t)); - tse_ddl_req_msg_mem = stack_mem.get_buf(); - if (tse_ddl_req_msg_mem == nullptr) { + ctc_ddl_req_msg_mem = stack_mem.get_buf(); + if (ctc_ddl_req_msg_mem == nullptr) { return HA_ERR_OUT_OF_MEM; } - if (tc_db__tse_ddltruncate_table_def__pack(&req, (uint8_t *)tse_ddl_req_msg_mem) != msg_len) { + if (tc_db__ctc_ddltruncate_table_def__pack(&req, (uint8_t *)ctc_ddl_req_msg_mem) != msg_len) { assert(false); } } - update_member_tch(*tch, tse_hton, thd); + update_member_tch(*tch, ctc_hton, thd); ddl_ctrl_t ddl_ctrl = {{0}, {0}, {0}, 0, 0, *tch, ctc_instance_id, false, 0}; FILL_USER_INFO_WITH_THD(ddl_ctrl, thd); ddl_ctrl.msg_len = msg_len; - ret = (ct_errno_t)tse_truncate_table(tse_ddl_req_msg_mem, &ddl_ctrl); - tse_ddl_hook_cantian_error("tse_truncate_table_cantian_error", thd, &ddl_ctrl, &ret); + ret = (ct_errno_t)ctc_truncate_table(ctc_ddl_req_msg_mem, &ddl_ctrl); + ctc_ddl_hook_cantian_error("ctc_truncate_table_cantian_error", thd, &ddl_ctrl, &ret); *tch = ddl_ctrl.tch; - update_sess_ctx_by_tch(*tch, tse_hton, thd); - return tse_ddl_handle_fault("tse_truncate_table", thd, &ddl_ctrl, ret); + update_sess_ctx_by_tch(*tch, ctc_hton, thd); + return ctc_ddl_handle_fault("ctc_truncate_table", thd, &ddl_ctrl, ret); } static int fill_create_table_req_base_info(HA_CREATE_INFO *create_info, char *db_name, char *table_name, THD *thd, - TcDb__TseDDLCreateTableDef *req, bool is_alter_copy, char **mem_start, char *mem_end) { - req->schema = (char *)tse_ddl_alloc_mem(mem_start, mem_end, SMALL_RECORD_SIZE); + TcDb__CtcDDLCreateTableDef *req, bool is_alter_copy, char **mem_start, char *mem_end) { + req->schema = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, SMALL_RECORD_SIZE); if (req->schema == nullptr) { return HA_ERR_OUT_OF_MEM; } - req->alter_db_name = (char *)tse_ddl_alloc_mem(mem_start, mem_end, SMALL_RECORD_SIZE); + req->alter_db_name = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, SMALL_RECORD_SIZE); if (req->alter_db_name == nullptr) { return HA_ERR_OUT_OF_MEM; } - tse_copy_name(req->schema, db_name, SMALL_RECORD_SIZE); + ctc_copy_name(req->schema, db_name, SMALL_RECORD_SIZE); if (thd->lex->query_tables != nullptr) { - tse_copy_name(req->alter_db_name, thd->lex->query_tables->get_db_name(), SMALL_RECORD_SIZE); + ctc_copy_name(req->alter_db_name, thd->lex->query_tables->get_db_name(), SMALL_RECORD_SIZE); } else { - tse_copy_name(req->alter_db_name, db_name, SMALL_RECORD_SIZE); + ctc_copy_name(req->alter_db_name, db_name, SMALL_RECORD_SIZE); } req->name = table_name; - TSE_RETURN_IF_NOT_ZERO(check_tse_identifier_name(create_info->tablespace)); + CTC_RETURN_IF_NOT_ZERO(check_ctc_identifier_name(create_info->tablespace)); if (create_info->tablespace && strcmp(req->schema, create_info->tablespace) != 0) { req->space = const_cast(create_info->tablespace); } @@ -1744,26 +1744,26 @@ static int fill_create_table_req_base_info(HA_CREATE_INFO *create_info, char *db req->auto_increment_value = create_info->auto_increment_value; if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS) { - req->options |= TSE_CREATE_IF_NOT_EXISTS; + req->options |= CTC_CREATE_IF_NOT_EXISTS; } if (thd->variables.option_bits & OPTION_NO_FOREIGN_KEY_CHECKS) { - req->options |= TSE_CREATE_TYPE_NO_CHECK_CONS; + req->options |= CTC_CREATE_TYPE_NO_CHECK_CONS; } - req->db_name = TSE_GET_THD_DB_NAME(thd); + req->db_name = CTC_GET_THD_DB_NAME(thd); req->is_create_as_select = !thd->lex->query_block->field_list_is_empty(); return 0; } static int fill_create_table_req_columns_info(HA_CREATE_INFO *create_info, dd::Table *table_def, TABLE *form, - THD *thd, ddl_ctrl_t *ddl_ctrl, TcDb__TseDDLCreateTableDef *req, char **mem_start, char *mem_end) { - uint32_t tse_col_idx = 0; + THD *thd, ddl_ctrl_t *ddl_ctrl, TcDb__CtcDDLCreateTableDef *req, char **mem_start, char *mem_end) { + uint32_t ctc_col_idx = 0; uint32_t mysql_col_idx = 0; - while (tse_col_idx < req->n_columns) { + while (ctc_col_idx < req->n_columns) { Field *field = form->field[mysql_col_idx]; if (field->is_gcol()) { - ddl_ctrl->table_flags |= TSE_TABLE_CONTAINS_VIRCOL; + ddl_ctrl->table_flags |= CTC_TABLE_CONTAINS_VIRCOL; if (field->is_virtual_gcol()) { mysql_col_idx++; req->n_columns--; @@ -1773,13 +1773,13 @@ static int fill_create_table_req_columns_info(HA_CREATE_INFO *create_info, dd::T return HA_ERR_WRONG_COMMAND; } - TcDb__TseDDLColumnDef *column = req->columns[tse_col_idx]; - const Create_field *fld_charset = tse_get_create_field_by_column_name(thd, field->field_name); + TcDb__CtcDDLColumnDef *column = req->columns[ctc_col_idx]; + const Create_field *fld_charset = ctc_get_create_field_by_column_name(thd, field->field_name); const CHARSET_INFO *field_cs = fld_charset != nullptr ? get_sql_field_charset(fld_charset, create_info) : nullptr; - TSE_RETURN_IF_ERROR( - tse_ddl_fill_column_by_field(thd, column, field, table_def, form, NULL, TSE_ALTER_COLUMN_ALTER_ADD_COLUMN, + CTC_RETURN_IF_ERROR( + ctc_ddl_fill_column_by_field(thd, column, field, table_def, form, NULL, CTC_ALTER_COLUMN_ALTER_ADD_COLUMN, mem_start, mem_end, field_cs), HA_ERR_WRONG_COMMAND); - tse_col_idx++; + ctc_col_idx++; mysql_col_idx++; } @@ -1793,12 +1793,12 @@ static int fill_create_table_req_columns_info(HA_CREATE_INFO *create_info, dd::T } int fill_create_table_req(HA_CREATE_INFO *create_info, dd::Table *table_def, char *db_name, char *table_name, - TABLE *form, THD *thd, ddl_ctrl_t *ddl_ctrl, tse_ddl_stack_mem *stack_mem) { - lock_guard lock(m_tse_ddl_protobuf_mem_mutex); - char *req_mem_start = tse_ddl_req_mem; - char *req_mem_end = req_mem_start + TSE_DDL_PROTOBUF_MEM_SIZE; - TcDb__TseDDLCreateTableDef req; - int ret = tse_ddl_init_create_table_def(&req, form, thd, table_def, &req_mem_start, req_mem_end); + TABLE *form, THD *thd, ddl_ctrl_t *ddl_ctrl, ctc_ddl_stack_mem *stack_mem) { + lock_guard lock(m_ctc_ddl_protobuf_mem_mutex); + char *req_mem_start = ctc_ddl_req_mem; + char *req_mem_end = req_mem_start + CTC_DDL_PROTOBUF_MEM_SIZE; + TcDb__CtcDDLCreateTableDef req; + int ret = ctc_ddl_init_create_table_def(&req, form, thd, table_def, &req_mem_start, req_mem_end); assert(req_mem_start <= req_mem_end); if (ret != 0) { return ret; @@ -1824,31 +1824,31 @@ int fill_create_table_req(HA_CREATE_INFO *create_info, dd::Table *table_def, cha return ret; } - TSE_RETURN_IF_NOT_ZERO(tse_ddl_create_table_fill_foreign_key_info(&req, table_def, &req_mem_start, req_mem_end)); - TSE_RETURN_IF_ERROR(tse_ddl_create_table_fill_add_key(&req, thd, table_def, form, req.schema), HA_ERR_WRONG_COMMAND); + CTC_RETURN_IF_NOT_ZERO(ctc_ddl_create_table_fill_foreign_key_info(&req, table_def, &req_mem_start, req_mem_end)); + CTC_RETURN_IF_ERROR(ctc_ddl_create_table_fill_add_key(&req, thd, table_def, form, req.schema), HA_ERR_WRONG_COMMAND); - size_t msg_len = tc_db__tse_ddlcreate_table_def__get_packed_size(&req); + size_t msg_len = tc_db__ctc_ddlcreate_table_def__get_packed_size(&req); stack_mem->set_mem_size(msg_len + sizeof(ddl_ctrl_t)); - void *tse_ddl_req_msg_mem = stack_mem->get_buf(); - if (tse_ddl_req_msg_mem == nullptr) { + void *ctc_ddl_req_msg_mem = stack_mem->get_buf(); + if (ctc_ddl_req_msg_mem == nullptr) { return HA_ERR_OUT_OF_MEM; } - if (tc_db__tse_ddlcreate_table_def__pack(&req, (uint8_t *)tse_ddl_req_msg_mem + sizeof(ddl_ctrl_t)) != msg_len) { + if (tc_db__ctc_ddlcreate_table_def__pack(&req, (uint8_t *)ctc_ddl_req_msg_mem + sizeof(ddl_ctrl_t)) != msg_len) { assert(false); } ddl_ctrl->msg_len = msg_len + sizeof(ddl_ctrl_t); - memcpy(tse_ddl_req_msg_mem, ddl_ctrl, sizeof(ddl_ctrl_t)); + memcpy(ctc_ddl_req_msg_mem, ddl_ctrl, sizeof(ddl_ctrl_t)); return 0; } -static int tse_ddl_fill_add_part_table_info(TcDb__TseDDLPartitionTableDef *add_part, partition_element &part, +static int ctc_ddl_fill_add_part_table_info(TcDb__CtcDDLPartitionTableDef *add_part, partition_element &part, char **mem_start, char *mem_end) { int name_len = strlen(part.partition_name); - add_part->name = (char *)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(char) * (name_len + 1)); + add_part->name = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, sizeof(char) * (name_len + 1)); if (add_part->name == nullptr) { return HA_ERR_OUT_OF_MEM; } @@ -1856,20 +1856,20 @@ static int tse_ddl_fill_add_part_table_info(TcDb__TseDDLPartitionTableDef *add_p add_part->n_subpart_table_list = part.subpartitions.size(); if (part.subpartitions.size() > 0) { add_part->subpart_table_list = - (TcDb__TseDDLPartitionTableDef **)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(TcDb__TseDDLPartitionTableDef *) * part.subpartitions.size()); + (TcDb__CtcDDLPartitionTableDef **)ctc_ddl_alloc_mem(mem_start, mem_end, sizeof(TcDb__CtcDDLPartitionTableDef *) * part.subpartitions.size()); if (add_part->subpart_table_list == NULL) { return HA_ERR_OUT_OF_MEM; } - TcDb__TseDDLPartitionTableDef **subpart_table_list = add_part->subpart_table_list; + TcDb__CtcDDLPartitionTableDef **subpart_table_list = add_part->subpart_table_list; uint32_t i = 0; for (partition_element sub_part_obj : part.subpartitions) { - subpart_table_list[i] = (TcDb__TseDDLPartitionTableDef *)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(TcDb__TseDDLPartitionTableDef)); + subpart_table_list[i] = (TcDb__CtcDDLPartitionTableDef *)ctc_ddl_alloc_mem(mem_start, mem_end, sizeof(TcDb__CtcDDLPartitionTableDef)); if (subpart_table_list[i] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlpartition_table_def__init(subpart_table_list[i]); + tc_db__ctc_ddlpartition_table_def__init(subpart_table_list[i]); int name_len = strlen(sub_part_obj.partition_name); - subpart_table_list[i]->name = (char *)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(char) * (name_len + 1)); + subpart_table_list[i]->name = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, sizeof(char) * (name_len + 1)); if (subpart_table_list[i]->name == NULL) { return HA_ERR_OUT_OF_MEM; } @@ -1880,26 +1880,26 @@ static int tse_ddl_fill_add_part_table_info(TcDb__TseDDLPartitionTableDef *add_p return 0; } -static int tse_prepare_alter_partition_init_part_list(TcDb__TseDDLAlterTableDef *req, Alter_inplace_info *alter_info, +static int ctc_prepare_alter_partition_init_part_list(TcDb__CtcDDLAlterTableDef *req, Alter_inplace_info *alter_info, char **mem_start, char *mem_end) { List part_list = alter_info->modified_part_info->partitions; if (part_list.size() > PART_CURSOR_NUM) { my_error(ER_TOO_MANY_PARTITIONS_ERROR, MYF(0)); return -1; } - req->drop_partition_names = (char **)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(char *) * part_list.size()); + req->drop_partition_names = (char **)ctc_ddl_alloc_mem(mem_start, mem_end, sizeof(char *) * part_list.size()); if (req->drop_partition_names == NULL) { return HA_ERR_OUT_OF_MEM; } - req->add_part_list = (TcDb__TseDDLPartitionTableDef **)tse_ddl_alloc_mem(mem_start, mem_end, - sizeof(TcDb__TseDDLPartitionTableDef *) * part_list.size()); + req->add_part_list = (TcDb__CtcDDLPartitionTableDef **)ctc_ddl_alloc_mem(mem_start, mem_end, + sizeof(TcDb__CtcDDLPartitionTableDef *) * part_list.size()); if (req->add_part_list == NULL) { return HA_ERR_OUT_OF_MEM; } return 0; } -static int tse_ddl_prepare_alter_partition_info(TcDb__TseDDLAlterTableDef *req, +static int ctc_ddl_prepare_alter_partition_info(TcDb__CtcDDLAlterTableDef *req, Alter_inplace_info *alter_info, char **mem_start, char *mem_end) { req->n_drop_partition_names = 0; @@ -1908,12 +1908,12 @@ static int tse_ddl_prepare_alter_partition_info(TcDb__TseDDLAlterTableDef *req, if (alter_info->modified_part_info->partitions.size() <= 0) { return 0; } - TSE_RETURN_IF_NOT_ZERO(tse_prepare_alter_partition_init_part_list(req, alter_info, mem_start, mem_end)); + CTC_RETURN_IF_NOT_ZERO(ctc_prepare_alter_partition_init_part_list(req, alter_info, mem_start, mem_end)); for (auto part : alter_info->modified_part_info->partitions) { switch (part.part_state) { case PART_TO_BE_DROPPED: { int name_len = strlen(part.partition_name); - req->drop_partition_names[req->n_drop_partition_names] = (char *)tse_ddl_alloc_mem(mem_start, mem_end, + req->drop_partition_names[req->n_drop_partition_names] = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, sizeof(char) * (name_len + 1)); if (req->drop_partition_names[req->n_drop_partition_names] == NULL) { return HA_ERR_OUT_OF_MEM; @@ -1923,14 +1923,14 @@ static int tse_ddl_prepare_alter_partition_info(TcDb__TseDDLAlterTableDef *req, break; } case PART_TO_BE_ADDED: { - req->add_part_list[req->n_add_part_list] = (TcDb__TseDDLPartitionTableDef *)tse_ddl_alloc_mem(mem_start, mem_end, - sizeof(TcDb__TseDDLPartitionTableDef)); + req->add_part_list[req->n_add_part_list] = (TcDb__CtcDDLPartitionTableDef *)ctc_ddl_alloc_mem(mem_start, mem_end, + sizeof(TcDb__CtcDDLPartitionTableDef)); if (req->add_part_list[req->n_add_part_list] == NULL) { return HA_ERR_OUT_OF_MEM; } - TcDb__TseDDLPartitionTableDef *add_part = req->add_part_list[req->n_add_part_list]; - tc_db__tse_ddlpartition_table_def__init(add_part); - TSE_RETURN_IF_NOT_ZERO(tse_ddl_fill_add_part_table_info(add_part, part, mem_start, mem_end)); + TcDb__CtcDDLPartitionTableDef *add_part = req->add_part_list[req->n_add_part_list]; + tc_db__ctc_ddlpartition_table_def__init(add_part); + CTC_RETURN_IF_NOT_ZERO(ctc_ddl_fill_add_part_table_info(add_part, part, mem_start, mem_end)); req->n_add_part_list++; break; } @@ -1949,96 +1949,96 @@ static int tse_ddl_prepare_alter_partition_info(TcDb__TseDDLAlterTableDef *req, return 0; } -static int init_drop_list_4alter_table(TcDb__TseDDLAlterTableDef *req, char **mem_start, char *mem_end) { - req->drop_list = (TcDb__TseDDLAlterTableDrop **)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLAlterTableDrop*) * req->n_drop_list); +static int init_drop_list_4alter_table(TcDb__CtcDDLAlterTableDef *req, char **mem_start, char *mem_end) { + req->drop_list = (TcDb__CtcDDLAlterTableDrop **)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLAlterTableDrop*) * req->n_drop_list); if (req->drop_list == NULL) { return HA_ERR_OUT_OF_MEM; } for (uint i = 0; i < req->n_drop_list; i++) { - req->drop_list[i] = (TcDb__TseDDLAlterTableDrop *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLAlterTableDrop)); + req->drop_list[i] = (TcDb__CtcDDLAlterTableDrop *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLAlterTableDrop)); if (req->drop_list[i] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlalter_table_drop__init(req->drop_list[i]); + tc_db__ctc_ddlalter_table_drop__init(req->drop_list[i]); } return 0; } -static int init_alter_list_4alter_table(TcDb__TseDDLAlterTableDef *req, char **mem_start, char *mem_end) { - req->alter_list = (TcDb__TseDDLAlterTableAlterColumn **)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLAlterTableAlterColumn*) * req->n_alter_list); +static int init_alter_list_4alter_table(TcDb__CtcDDLAlterTableDef *req, char **mem_start, char *mem_end) { + req->alter_list = (TcDb__CtcDDLAlterTableAlterColumn **)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLAlterTableAlterColumn*) * req->n_alter_list); if (req->alter_list == NULL) { return HA_ERR_OUT_OF_MEM; } for (uint i = 0; i < req->n_alter_list; i++) { - req->alter_list[i] = (TcDb__TseDDLAlterTableAlterColumn *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLAlterTableAlterColumn)); + req->alter_list[i] = (TcDb__CtcDDLAlterTableAlterColumn *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLAlterTableAlterColumn)); if (req->alter_list[i] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlalter_table_alter_column__init(req->alter_list[i]); + tc_db__ctc_ddlalter_table_alter_column__init(req->alter_list[i]); } return 0; } -static int init_create_list_4alter_table(TcDb__TseDDLAlterTableDef *req, char **mem_start, char *mem_end) { - req->create_list = (TcDb__TseDDLColumnDef **)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLColumnDef*) * req->n_create_list); +static int init_create_list_4alter_table(TcDb__CtcDDLAlterTableDef *req, char **mem_start, char *mem_end) { + req->create_list = (TcDb__CtcDDLColumnDef **)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLColumnDef*) * req->n_create_list); if (req->create_list == NULL) { return HA_ERR_OUT_OF_MEM; } for (uint i = 0; i < req->n_create_list; i++) { - req->create_list[i] = (TcDb__TseDDLColumnDef *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLColumnDef)); + req->create_list[i] = (TcDb__CtcDDLColumnDef *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLColumnDef)); if (req->create_list[i] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlcolumn_def__init(req->create_list[i]); - TcDb__TseDDLColumnDef *column = req->create_list[i]; - column->datatype = (TcDb__TseDDLColumnDataTypeDef *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLColumnDataTypeDef)); + tc_db__ctc_ddlcolumn_def__init(req->create_list[i]); + TcDb__CtcDDLColumnDef *column = req->create_list[i]; + column->datatype = (TcDb__CtcDDLColumnDataTypeDef *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLColumnDataTypeDef)); if (column->datatype == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlcolumn_data_type_def__init(column->datatype); + tc_db__ctc_ddlcolumn_data_type_def__init(column->datatype); } return 0; } -static int init_add_key_list_4alter_table(TcDb__TseDDLAlterTableDef *req, Alter_inplace_info *ha_alter_info, +static int init_add_key_list_4alter_table(TcDb__CtcDDLAlterTableDef *req, Alter_inplace_info *ha_alter_info, char **mem_start, char *mem_end) { - req->add_key_list = (TcDb__TseDDLTableKey **)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLTableKey*) * req->n_add_key_list); + req->add_key_list = (TcDb__CtcDDLTableKey **)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLTableKey*) * req->n_add_key_list); if (req->add_key_list == NULL) { return HA_ERR_OUT_OF_MEM; } for (uint i = 0; i < req->n_add_key_list; i++) { - req->add_key_list[i] = (TcDb__TseDDLTableKey *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLTableKey)); + req->add_key_list[i] = (TcDb__CtcDDLTableKey *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLTableKey)); if (req->add_key_list[i] == NULL) { return HA_ERR_OUT_OF_MEM; } - TcDb__TseDDLTableKey *req_key = req->add_key_list[i]; - tc_db__tse_ddltable_key__init(req_key); + TcDb__CtcDDLTableKey *req_key = req->add_key_list[i]; + tc_db__ctc_ddltable_key__init(req_key); const KEY *key = &ha_alter_info->key_info_buffer[ha_alter_info->index_add_buffer[i]]; assert(key != NULL); req_key->n_columns = key->user_defined_key_parts; - req_key->columns = (TcDb__TseDDLTableKeyPart **)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLTableKeyPart*) * req_key->n_columns); + req_key->columns = (TcDb__CtcDDLTableKeyPart **)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLTableKeyPart*) * req_key->n_columns); if (req_key->columns == NULL) { return HA_ERR_OUT_OF_MEM; } for (uint j = 0; j < req_key->n_columns; j++) { - req_key->columns[j] = (TcDb__TseDDLTableKeyPart *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLTableKeyPart)); + req_key->columns[j] = (TcDb__CtcDDLTableKeyPart *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLTableKeyPart)); if (req_key->columns[j] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddltable_key_part__init(req_key->columns[j]); - req_key->columns[j]->func_text = (char *)tse_ddl_alloc_mem(mem_start, mem_end, FUNC_TEXT_MAX_LEN); + tc_db__ctc_ddltable_key_part__init(req_key->columns[j]); + req_key->columns[j]->func_text = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, FUNC_TEXT_MAX_LEN); if (req_key->columns[j]->func_text == nullptr) { return HA_ERR_OUT_OF_MEM; } @@ -2048,27 +2048,27 @@ static int init_add_key_list_4alter_table(TcDb__TseDDLAlterTableDef *req, Alter_ return 0; } -static int init_drop_key_list_4alter_table(TcDb__TseDDLAlterTableDef *req, char **mem_start, char *mem_end) { - req->drop_key_list = (TcDb__TseDDLAlterTableDropKey **)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLAlterTableDropKey*) * req->n_drop_key_list); +static int init_drop_key_list_4alter_table(TcDb__CtcDDLAlterTableDef *req, char **mem_start, char *mem_end) { + req->drop_key_list = (TcDb__CtcDDLAlterTableDropKey **)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLAlterTableDropKey*) * req->n_drop_key_list); if (req->drop_key_list == NULL) { return HA_ERR_OUT_OF_MEM; } for (uint i = 0; i < req->n_drop_key_list; i++) { - req->drop_key_list[i] = (TcDb__TseDDLAlterTableDropKey *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLAlterTableDropKey)); + req->drop_key_list[i] = (TcDb__CtcDDLAlterTableDropKey *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLAlterTableDropKey)); if (req->drop_key_list[i] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlalter_table_drop_key__init(req->drop_key_list[i]); + tc_db__ctc_ddlalter_table_drop_key__init(req->drop_key_list[i]); } return 0; } -static int init_foreign_key_list_4alter_table(TcDb__TseDDLAlterTableDef *req, Alter_inplace_info *ha_alter_info, +static int init_foreign_key_list_4alter_table(TcDb__CtcDDLAlterTableDef *req, Alter_inplace_info *ha_alter_info, char **mem_start, char *mem_end) { - req->add_foreign_key_list = (TcDb__TseDDLForeignKeyDef **)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLForeignKeyDef*) * ha_alter_info->alter_info->key_list.size()); + req->add_foreign_key_list = (TcDb__CtcDDLForeignKeyDef **)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLForeignKeyDef*) * ha_alter_info->alter_info->key_list.size()); if (req->add_foreign_key_list == NULL) { return HA_ERR_OUT_OF_MEM; } @@ -2077,58 +2077,58 @@ static int init_foreign_key_list_4alter_table(TcDb__TseDDLAlterTableDef *req, Al if (key->type != KEYTYPE_FOREIGN) { continue; } - req->add_foreign_key_list[req->n_add_foreign_key_list] = (TcDb__TseDDLForeignKeyDef *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLForeignKeyDef)); + req->add_foreign_key_list[req->n_add_foreign_key_list] = (TcDb__CtcDDLForeignKeyDef *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLForeignKeyDef)); if (req->add_foreign_key_list[req->n_add_foreign_key_list] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlforeign_key_def__init(req->add_foreign_key_list[req->n_add_foreign_key_list]); - TcDb__TseDDLForeignKeyDef *fk_def = req->add_foreign_key_list[req->n_add_foreign_key_list]; + tc_db__ctc_ddlforeign_key_def__init(req->add_foreign_key_list[req->n_add_foreign_key_list]); + TcDb__CtcDDLForeignKeyDef *fk_def = req->add_foreign_key_list[req->n_add_foreign_key_list]; const Foreign_key_spec *fk = down_cast(key); fk_def->n_elements = fk->columns.size(); - fk_def->elements = (TcDb__TseDDLForeignKeyElementDef **)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLForeignKeyElementDef*) * fk_def->n_elements); + fk_def->elements = (TcDb__CtcDDLForeignKeyElementDef **)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLForeignKeyElementDef*) * fk_def->n_elements); if (fk_def->elements == NULL) { return HA_ERR_OUT_OF_MEM; } for (uint j = 0; j < fk_def->n_elements; j++) { - fk_def->elements[j] = (TcDb__TseDDLForeignKeyElementDef *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLForeignKeyElementDef)); + fk_def->elements[j] = (TcDb__CtcDDLForeignKeyElementDef *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLForeignKeyElementDef)); if (fk_def->elements[j] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlforeign_key_element_def__init(fk_def->elements[j]); + tc_db__ctc_ddlforeign_key_element_def__init(fk_def->elements[j]); } - TSE_RETURN_IF_NOT_ZERO(tse_ddl_alter_table_fill_foreign_key_info(fk_def, fk, mem_start, mem_end)); + CTC_RETURN_IF_NOT_ZERO(ctc_ddl_alter_table_fill_foreign_key_info(fk_def, fk, mem_start, mem_end)); req->n_add_foreign_key_list++; } return 0; } -static int init_alter_index_list_4alter_table(TcDb__TseDDLAlterTableDef *req, char **mem_start, char *mem_end) { - req->alter_index_list = (TcDb__TseDDLAlterIndexDef **)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLAlterIndexDef) * req->n_alter_index_list); +static int init_alter_index_list_4alter_table(TcDb__CtcDDLAlterTableDef *req, char **mem_start, char *mem_end) { + req->alter_index_list = (TcDb__CtcDDLAlterIndexDef **)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLAlterIndexDef) * req->n_alter_index_list); if (req->alter_index_list == NULL) { return HA_ERR_OUT_OF_MEM; } for (uint i = 0; i < req->n_alter_index_list; i++) { - req->alter_index_list[i] = (TcDb__TseDDLAlterIndexDef *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLAlterIndexDef)); + req->alter_index_list[i] = (TcDb__CtcDDLAlterIndexDef *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLAlterIndexDef)); if (req->alter_index_list[i] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlalter_index_def__init(req->alter_index_list[i]); + tc_db__ctc_ddlalter_index_def__init(req->alter_index_list[i]); } return 0; } -static int init_tse_ddl_alter_table_def(TcDb__TseDDLAlterTableDef *req, Alter_inplace_info *ha_alter_info, +static int init_ctc_ddl_alter_table_def(TcDb__CtcDDLAlterTableDef *req, Alter_inplace_info *ha_alter_info, THD *thd, TABLE *altered_table, char **mem_start, char *mem_end, size_t *rename_cols) { - tc_db__tse_ddlalter_table_def__init(req); + tc_db__ctc_ddlalter_table_def__init(req); uint32_t create_fields = (uint32_t)ha_alter_info->alter_info->create_list.size(); - DBUG_EXECUTE_IF("tse_alter_table_max_column", { create_fields = REC_MAX_N_USER_FIELDS + 1; }); + DBUG_EXECUTE_IF("ctc_alter_table_max_column", { create_fields = REC_MAX_N_USER_FIELDS + 1; }); if (create_fields > REC_MAX_N_USER_FIELDS) { - tse_log_system("Max filed %d > %u, sql:%s", (uint32_t)create_fields, + ctc_log_system("Max filed %d > %u, sql:%s", (uint32_t)create_fields, REC_MAX_N_USER_FIELDS, thd->query().str); my_error(ER_TOO_MANY_FIELDS, MYF(0)); return HA_ERR_TOO_MANY_FIELDS; @@ -2148,28 +2148,28 @@ static int init_tse_ddl_alter_table_def(TcDb__TseDDLAlterTableDef *req, Alter_in // 分区表 if (ha_alter_info->modified_part_info != NULL) { - TSE_RETURN_IF_NOT_ZERO(tse_ddl_prepare_alter_partition_info(req, ha_alter_info, mem_start, mem_end)); + CTC_RETURN_IF_NOT_ZERO(ctc_ddl_prepare_alter_partition_info(req, ha_alter_info, mem_start, mem_end)); } if (req->n_drop_list > 0) { - TSE_RETURN_IF_NOT_ZERO(init_drop_list_4alter_table(req, mem_start, mem_end)); + CTC_RETURN_IF_NOT_ZERO(init_drop_list_4alter_table(req, mem_start, mem_end)); } if (req->n_alter_list > 0) { - TSE_RETURN_IF_NOT_ZERO(init_alter_list_4alter_table(req, mem_start, mem_end)); + CTC_RETURN_IF_NOT_ZERO(init_alter_list_4alter_table(req, mem_start, mem_end)); } if (req->n_create_list > 0) { - TSE_RETURN_IF_NOT_ZERO(init_create_list_4alter_table(req, mem_start, mem_end)); + CTC_RETURN_IF_NOT_ZERO(init_create_list_4alter_table(req, mem_start, mem_end)); } - req->table_def = (TcDb__TseDDLAlterTablePorp *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLAlterTablePorp)); + req->table_def = (TcDb__CtcDDLAlterTablePorp *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLAlterTablePorp)); if (req->table_def == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlalter_table_porp__init(req->table_def); + tc_db__ctc_ddlalter_table_porp__init(req->table_def); // 添加索引 if ((ha_alter_info->handler_flags & Alter_inplace_info::ADD_STORED_BASE_COLUMN) && @@ -2177,17 +2177,17 @@ static int init_tse_ddl_alter_table_def(TcDb__TseDDLAlterTableDef *req, Alter_in req->n_add_key_list = 0; } if (req->n_add_key_list > 0) { - TSE_RETURN_IF_NOT_ZERO(init_add_key_list_4alter_table(req, ha_alter_info, mem_start, mem_end)); + CTC_RETURN_IF_NOT_ZERO(init_add_key_list_4alter_table(req, ha_alter_info, mem_start, mem_end)); } // 删除索引 if (req->n_drop_key_list > 0) { - TSE_RETURN_IF_NOT_ZERO(init_drop_key_list_4alter_table(req, mem_start, mem_end)); + CTC_RETURN_IF_NOT_ZERO(init_drop_key_list_4alter_table(req, mem_start, mem_end)); } // 增加外键 if (ha_alter_info->handler_flags & Alter_inplace_info::ADD_FOREIGN_KEY) { - TSE_RETURN_IF_NOT_ZERO(init_foreign_key_list_4alter_table(req, ha_alter_info, mem_start, mem_end)); + CTC_RETURN_IF_NOT_ZERO(init_foreign_key_list_4alter_table(req, ha_alter_info, mem_start, mem_end)); } // 自增 @@ -2199,7 +2199,7 @@ static int init_tse_ddl_alter_table_def(TcDb__TseDDLAlterTableDef *req, Alter_in // alter index if (req->n_alter_index_list > 0) { - TSE_RETURN_IF_NOT_ZERO(init_alter_index_list_4alter_table(req, mem_start, mem_end)); + CTC_RETURN_IF_NOT_ZERO(init_alter_index_list_4alter_table(req, mem_start, mem_end)); } return 0; } @@ -2224,19 +2224,19 @@ static const Create_field *get_field_by_index(Alter_info *alter_info, return field; } -static uint32_t tse_fill_key_part(THD *thd, - TcDb__TseDDLTableKeyPart *req_key_part, - TcDb__TseDDLTableKey *req_key_def, +static uint32_t ctc_fill_key_part(THD *thd, + TcDb__CtcDDLTableKeyPart *req_key_part, + TcDb__CtcDDLTableKey *req_key_def, const Create_field *create_field, TABLE *form, const KEY_PART_INFO *key_part) { - Field *field = tse_get_field_by_name(form, create_field->field_name); + Field *field = ctc_get_field_by_name(form, create_field->field_name); assert(field != nullptr); bool is_prefix_key = false; if (field->is_field_for_functional_index()) { req_key_def->is_func = true; - TSE_RETURN_IF_ERROR(tse_fill_func_key_part(form, thd, req_key_part, create_field->gcol_info) == CT_SUCCESS, CT_ERROR); + CTC_RETURN_IF_ERROR(ctc_fill_func_key_part(form, thd, req_key_part, create_field->gcol_info) == CT_SUCCESS, CT_ERROR); } else { if (field->is_virtual_gcol()) { my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), @@ -2246,7 +2246,7 @@ static uint32_t tse_fill_key_part(THD *thd, uint prefix_len = get_prefix_index_len(create_field->field, key_part->length); if (prefix_len) { - tse_fill_prefix_func_key_part(req_key_part, create_field->field, prefix_len); + ctc_fill_prefix_func_key_part(req_key_part, create_field->field, prefix_len); is_prefix_key = true; } else { req_key_part->is_func = false; @@ -2255,40 +2255,40 @@ static uint32_t tse_fill_key_part(THD *thd, req_key_part->name = const_cast(create_field->field_name); } - tse_ddl_get_data_type_from_mysql_type(field, create_field->sql_type, &req_key_part->datatype); - tse_set_unsigned_column(field, &req_key_part->is_unsigned); + ctc_ddl_get_data_type_from_mysql_type(field, create_field->sql_type, &req_key_part->datatype); + ctc_set_unsigned_column(field, &req_key_part->is_unsigned); if (is_prefix_key && field->is_flag_set(BLOB_FLAG)) { - req_key_part->datatype = TSE_DDL_TYPE_VARCHAR; + req_key_part->datatype = CTC_DDL_TYPE_VARCHAR; } req_key_part->length = (uint32_t)create_field->key_length(); return CT_SUCCESS; } -bool tse_ddl_fill_add_key(THD *thd, TABLE *form, TcDb__TseDDLAlterTableDef *req, +bool ctc_ddl_fill_add_key(THD *thd, TABLE *form, TcDb__CtcDDLAlterTableDef *req, Alter_inplace_info *ha_alter_info, char *user) { for (uint i = 0; i < req->n_add_key_list; i++) { - TcDb__TseDDLTableKey *req_key_def = req->add_key_list[i]; + TcDb__CtcDDLTableKey *req_key_def = req->add_key_list[i]; const KEY *key = &ha_alter_info->key_info_buffer[ha_alter_info->index_add_buffer[i]]; assert(key != nullptr); req_key_def->user = user; req_key_def->table = const_cast(thd->lex->query_tables->table_name); - TSE_RETURN_IF_NOT_ZERO(check_tse_identifier_name(key->name)); + CTC_RETURN_IF_NOT_ZERO(check_ctc_identifier_name(key->name)); req_key_def->name = const_cast(key->name); req_key_def->space = NULL; - TSE_RETURN_IF_ERROR(get_tse_key_type(key, &req_key_def->key_type), false); - if (req_key_def->key_type == TSE_KEYTYPE_PRIMARY || req_key_def->key_type == TSE_KEYTYPE_UNIQUE) { + CTC_RETURN_IF_ERROR(get_ctc_key_type(key, &req_key_def->key_type), false); + if (req_key_def->key_type == CTC_KEYTYPE_PRIMARY || req_key_def->key_type == CTC_KEYTYPE_UNIQUE) { req_key_def->is_constraint = true; } - TSE_RETURN_IF_ERROR(get_tse_key_algorithm(key->algorithm, &req_key_def->algorithm), false); + CTC_RETURN_IF_ERROR(get_ctc_key_algorithm(key->algorithm, &req_key_def->algorithm), false); for (uint j = 0; j < req_key_def->n_columns; j++) { - TcDb__TseDDLTableKeyPart *req_key_part = req_key_def->columns[j]; + TcDb__CtcDDLTableKeyPart *req_key_part = req_key_def->columns[j]; const KEY_PART_INFO *key_part = key->key_part + j; const Create_field *create_field = get_field_by_index(ha_alter_info->alter_info, key_part->fieldnr); assert(create_field != NULL); - TSE_RETURN_IF_ERROR( - (tse_fill_key_part(thd, req_key_part, req_key_def, create_field, form, + CTC_RETURN_IF_ERROR( + (ctc_fill_key_part(thd, req_key_part, req_key_def, create_field, form, key_part) == CT_SUCCESS), false); } @@ -2296,68 +2296,68 @@ bool tse_ddl_fill_add_key(THD *thd, TABLE *form, TcDb__TseDDLAlterTableDef *req, return true; } -static int tse_ddl_fill_drop_key(Alter_inplace_info *ha_alter_info, const dd::Table *old_table_def, - TcDb__TseDDLAlterTableDef *req) +static int ctc_ddl_fill_drop_key(Alter_inplace_info *ha_alter_info, const dd::Table *old_table_def, + TcDb__CtcDDLAlterTableDef *req) { - for (uint tse_drop_key_idx = 0; tse_drop_key_idx < req->n_drop_key_list; tse_drop_key_idx++) { - TcDb__TseDDLAlterTableDropKey *req_drop = req->drop_key_list[tse_drop_key_idx]; - const KEY *key = ha_alter_info->index_drop_buffer[tse_drop_key_idx]; + for (uint ctc_drop_key_idx = 0; ctc_drop_key_idx < req->n_drop_key_list; ctc_drop_key_idx++) { + TcDb__CtcDDLAlterTableDropKey *req_drop = req->drop_key_list[ctc_drop_key_idx]; + const KEY *key = ha_alter_info->index_drop_buffer[ctc_drop_key_idx]; req_drop->name = const_cast(key->name); - req_drop->drop_type = TSE_ALTER_TABLE_DROP_KEY; + req_drop->drop_type = CTC_ALTER_TABLE_DROP_KEY; - const dd::Index *idx = tse_ddl_get_index_by_name(old_table_def, req_drop->name); + const dd::Index *idx = ctc_ddl_get_index_by_name(old_table_def, req_drop->name); assert(idx != nullptr); - TSE_RETURN_IF_ERROR(tse_ddl_get_create_key_type(idx->type(), &req_drop->key_type), CT_ERROR); + CTC_RETURN_IF_ERROR(ctc_ddl_get_create_key_type(idx->type(), &req_drop->key_type), CT_ERROR); } return CT_SUCCESS; } -static int fill_tse_alter_drop_list(Alter_inplace_info *ha_alter_info, const dd::Table *old_table_def, - TcDb__TseDDLAlterTableDef *req) +static int fill_ctc_alter_drop_list(Alter_inplace_info *ha_alter_info, const dd::Table *old_table_def, + TcDb__CtcDDLAlterTableDef *req) { - uint32_t tse_drop_idx = 0; + uint32_t ctc_drop_idx = 0; uint32_t mysql_drop_idx = 0; - while (tse_drop_idx < req->n_drop_list) { - TcDb__TseDDLAlterTableDrop *req_drop = req->drop_list[tse_drop_idx]; + while (ctc_drop_idx < req->n_drop_list) { + TcDb__CtcDDLAlterTableDrop *req_drop = req->drop_list[ctc_drop_idx]; const Alter_drop *drop = ha_alter_info->alter_info->drop_list.at((size_t)mysql_drop_idx); req_drop->name = const_cast(drop->name); - req_drop->drop_type = tse_ddl_get_drop_type_from_mysql_type(drop->type); - if (req_drop->drop_type == TSE_ALTER_TABLE_DROP_COLUMN) { - const dd::Column *col = tse_ddl_get_column_by_name(old_table_def, drop->name); + req_drop->drop_type = ctc_ddl_get_drop_type_from_mysql_type(drop->type); + if (req_drop->drop_type == CTC_ALTER_TABLE_DROP_COLUMN) { + const dd::Column *col = ctc_ddl_get_column_by_name(old_table_def, drop->name); assert(col != nullptr); if (col->is_virtual()) { req->n_drop_list--; mysql_drop_idx++; continue; } - } else if (req_drop->drop_type == TSE_ALTER_TABLE_DROP_FOREIGN_KEY) { - req_drop->key_type = TSE_KEYTYPE_FOREIGN; - } else if (req_drop->drop_type == TSE_ALTER_TABLE_DROP_KEY) { + } else if (req_drop->drop_type == CTC_ALTER_TABLE_DROP_FOREIGN_KEY) { + req_drop->key_type = CTC_KEYTYPE_FOREIGN; + } else if (req_drop->drop_type == CTC_ALTER_TABLE_DROP_KEY) { // drop 索引通过index_drop_count实现 req->n_drop_list--; mysql_drop_idx++; continue; } - tse_drop_idx++; + ctc_drop_idx++; mysql_drop_idx++; } return CT_SUCCESS; } -static int fill_tse_alter_create_list(THD *thd, TABLE *altered_table, Alter_inplace_info *ha_alter_info, - dd::Table *new_table_def, TcDb__TseDDLAlterTableDef *req, ddl_ctrl_t *ddl_ctrl, char **mem_start, char *mem_end) +static int fill_ctc_alter_create_list(THD *thd, TABLE *altered_table, Alter_inplace_info *ha_alter_info, + dd::Table *new_table_def, TcDb__CtcDDLAlterTableDef *req, ddl_ctrl_t *ddl_ctrl, char **mem_start, char *mem_end) { - uint32_t tse_col_idx = 0; + uint32_t ctc_col_idx = 0; uint32_t mysql_col_idx = 0; - while (tse_col_idx < req->n_create_list) { - TcDb__TseDDLColumnDef *req_create_column = req->create_list[tse_col_idx]; + while (ctc_col_idx < req->n_create_list) { + TcDb__CtcDDLColumnDef *req_create_column = req->create_list[ctc_col_idx]; const Create_field *fld = ha_alter_info->alter_info->create_list[mysql_col_idx]; /* Generate Columns Not Processed */ if (fld->is_gcol()) { - ddl_ctrl->table_flags |= TSE_TABLE_CONTAINS_VIRCOL; + ddl_ctrl->table_flags |= CTC_TABLE_CONTAINS_VIRCOL; if (fld->is_virtual_gcol()) { req->n_create_list--; mysql_col_idx++; @@ -2369,18 +2369,18 @@ static int fill_tse_alter_create_list(THD *thd, TABLE *altered_table, Alter_inpl } } - tse_alter_column_alter_mode alter_mode = TSE_ALTER_COLUMN_ALTER_MODE_NONE; + ctc_alter_column_alter_mode alter_mode = CTC_ALTER_COLUMN_ALTER_MODE_NONE; if (fld->field == NULL) { - alter_mode = TSE_ALTER_COLUMN_ALTER_ADD_COLUMN; + alter_mode = CTC_ALTER_COLUMN_ALTER_ADD_COLUMN; } if (fld->change != NULL) { - alter_mode = TSE_ALTER_COLUMN_ALTER_MODIFY_COLUMN; + alter_mode = CTC_ALTER_COLUMN_ALTER_MODIFY_COLUMN; } const CHARSET_INFO *field_cs = get_sql_field_charset(fld, ha_alter_info->create_info); - TSE_RETURN_IF_ERROR(tse_ddl_fill_column_by_field(thd, req_create_column, altered_table->s->field[mysql_col_idx], + CTC_RETURN_IF_ERROR(ctc_ddl_fill_column_by_field(thd, req_create_column, altered_table->s->field[mysql_col_idx], ((const dd::Table *)new_table_def), altered_table, fld, alter_mode, mem_start, mem_end, field_cs), CT_ERROR); - tse_col_idx++; + ctc_col_idx++; mysql_col_idx++; } @@ -2393,7 +2393,7 @@ static int fill_tse_alter_create_list(THD *thd, TABLE *altered_table, Alter_inpl return CT_SUCCESS; } -static void fill_sys_cur_timestamp(THD *thd, TcDb__TseDDLAlterTableDef *req) { +static void fill_sys_cur_timestamp(THD *thd, TcDb__CtcDDLAlterTableDef *req) { date_detail_t date_detail; MYSQL_TIME ltime; #ifdef FEATURE_X_FOR_MYSQL_32 @@ -2415,8 +2415,8 @@ static void fill_sys_cur_timestamp(THD *thd, TcDb__TseDDLAlterTableDef *req) { } static void fill_alter_list_4alter_table(dd::Table *new_table_def, Alter_inplace_info *ha_alter_info, - TcDb__TseDDLAlterTableDef *req, size_t rename_cols, uint32_t thd_id, char **req_mem_start, char *req_mem_end) { - TcDb__TseDDLAlterTableAlterColumn *req_alter = NULL; + TcDb__CtcDDLAlterTableDef *req, size_t rename_cols, uint32_t thd_id, char **req_mem_start, char *req_mem_end) { + TcDb__CtcDDLAlterTableAlterColumn *req_alter = NULL; uint32_t copy_rm_num = 0; for (uint32_t i = 0; i < req->n_alter_list - rename_cols; i++) { req_alter = req->alter_list[i]; @@ -2429,10 +2429,10 @@ static void fill_alter_list_4alter_table(dd::Table *new_table_def, Alter_inplace alter_column->change_type() == Alter_column::Type::RENAME_COLUMN) { req_alter->name = const_cast(alter_column->name); req_alter->new_name = const_cast(alter_column->m_new_name); - req_alter->type = tse_ddl_get_alter_column_type_from_mysql_type(alter_column->change_type()); + req_alter->type = ctc_ddl_get_alter_column_type_from_mysql_type(alter_column->change_type()); if (alter_column->change_type() == Alter_column::Type::RENAME_COLUMN) { uint32_t copy_rm_index = req->n_alter_list - rename_cols + copy_rm_num; - req_alter->new_name = (char *)tse_ddl_alloc_mem(req_mem_start, req_mem_end, TSE_MAX_COLUMN_LEN); + req_alter->new_name = (char *)ctc_ddl_alloc_mem(req_mem_start, req_mem_end, CTC_MAX_COLUMN_LEN); sprintf(req_alter->new_name, "TMPCOLUMN4CANTIAN_%d_%d", copy_rm_index, thd_id); // for rename swap columns: // column a to b, b to c, c to x... or a to b, b to a @@ -2450,30 +2450,30 @@ static void fill_alter_list_4alter_table(dd::Table *new_table_def, Alter_inplace } int fill_alter_table_req(TABLE *altered_table, Alter_inplace_info *ha_alter_info, const dd::Table *old_table_def, - dd::Table *new_table_def, THD *thd, ddl_ctrl_t *ddl_ctrl, tse_ddl_stack_mem *stack_mem) { - lock_guard lock(m_tse_ddl_protobuf_mem_mutex); - TcDb__TseDDLAlterTableDef req; + dd::Table *new_table_def, THD *thd, ddl_ctrl_t *ddl_ctrl, ctc_ddl_stack_mem *stack_mem) { + lock_guard lock(m_ctc_ddl_protobuf_mem_mutex); + TcDb__CtcDDLAlterTableDef req; - char *req_mem_start = tse_ddl_req_mem; - char *req_mem_end = req_mem_start + TSE_DDL_PROTOBUF_MEM_SIZE; + char *req_mem_start = ctc_ddl_req_mem; + char *req_mem_end = req_mem_start + CTC_DDL_PROTOBUF_MEM_SIZE; size_t rename_cols = 0; - TSE_RETURN_IF_NOT_ZERO(init_tse_ddl_alter_table_def(&req, ha_alter_info, thd, + CTC_RETURN_IF_NOT_ZERO(init_ctc_ddl_alter_table_def(&req, ha_alter_info, thd, altered_table, &req_mem_start, req_mem_end, &rename_cols)); assert(req_mem_start <= req_mem_end); char user_name_str[SMALL_RECORD_SIZE]; if (thd->lex->query_tables != nullptr) { - tse_copy_name(user_name_str, thd->lex->query_tables->get_db_name(), SMALL_RECORD_SIZE); + ctc_copy_name(user_name_str, thd->lex->query_tables->get_db_name(), SMALL_RECORD_SIZE); } else { - tse_copy_name(user_name_str, altered_table->s->db.str, SMALL_RECORD_SIZE); + ctc_copy_name(user_name_str, altered_table->s->db.str, SMALL_RECORD_SIZE); } req.user = user_name_str; req.name = const_cast(thd->lex->query_tables->table_name); fill_sys_cur_timestamp(thd, &req); - TSE_RETURN_IF_ERROR((fill_tse_alter_drop_list(ha_alter_info, old_table_def, &req) == CT_SUCCESS), CT_ERROR); + CTC_RETURN_IF_ERROR((fill_ctc_alter_drop_list(ha_alter_info, old_table_def, &req) == CT_SUCCESS), CT_ERROR); if (thd->variables.option_bits & OPTION_NO_FOREIGN_KEY_CHECKS) { - req.options |= TSE_CREATE_TYPE_NO_CHECK_CONS; + req.options |= CTC_CREATE_TYPE_NO_CHECK_CONS; } // 删除索引相关逻辑填充 if (ha_alter_info->index_drop_count) { @@ -2482,7 +2482,7 @@ int fill_alter_table_req(TABLE *altered_table, Alter_inplace_info *ha_alter_info Alter_inplace_info::DROP_UNIQUE_INDEX | Alter_inplace_info::DROP_PK_INDEX)); - TSE_RETURN_IF_ERROR((tse_ddl_fill_drop_key(ha_alter_info, old_table_def, &req) == CT_SUCCESS), CT_ERROR); + CTC_RETURN_IF_ERROR((ctc_ddl_fill_drop_key(ha_alter_info, old_table_def, &req) == CT_SUCCESS), CT_ERROR); } if (req.n_alter_list > 0) { @@ -2490,48 +2490,48 @@ int fill_alter_table_req(TABLE *altered_table, Alter_inplace_info *ha_alter_info rename_cols, ddl_ctrl->tch.thd_id, &req_mem_start, req_mem_end); } - TSE_RETURN_IF_ERROR((fill_tse_alter_create_list(thd, altered_table, ha_alter_info, + CTC_RETURN_IF_ERROR((fill_ctc_alter_create_list(thd, altered_table, ha_alter_info, new_table_def, &req, ddl_ctrl, &req_mem_start, req_mem_end) == CT_SUCCESS), CT_ERROR); // 创建索引相关逻辑填充 - TSE_RETURN_IF_ERROR(tse_ddl_fill_add_key(thd, altered_table, &req, ha_alter_info, req.user), true); + CTC_RETURN_IF_ERROR(ctc_ddl_fill_add_key(thd, altered_table, &req, ha_alter_info, req.user), true); assert(req_mem_start <= req_mem_end); // rename索引 for (uint32_t i = 0; i < req.n_alter_index_list; ++i) { - TcDb__TseDDLAlterIndexDef *req_alter_index_def = req.alter_index_list[i]; + TcDb__CtcDDLAlterIndexDef *req_alter_index_def = req.alter_index_list[i]; req_alter_index_def->user = user_name_str; req_alter_index_def->table = const_cast(thd->lex->query_tables->table_name); req_alter_index_def->name = const_cast(ha_alter_info->index_rename_buffer[i].old_key->name); req_alter_index_def->new_name = const_cast(ha_alter_info->index_rename_buffer[i].new_key->name); - TSE_RETURN_IF_ERROR(get_tse_key_type(ha_alter_info->index_rename_buffer[i].old_key, &req_alter_index_def->key_type), true); + CTC_RETURN_IF_ERROR(get_ctc_key_type(ha_alter_info->index_rename_buffer[i].old_key, &req_alter_index_def->key_type), true); } - req.db_name = TSE_GET_THD_DB_NAME(thd); + req.db_name = CTC_GET_THD_DB_NAME(thd); string sql = string(thd->query().str).substr(0, thd->query().length); req.sql_str = const_cast(sql.c_str()); - size_t msg_len = tc_db__tse_ddlalter_table_def__get_packed_size(&req); + size_t msg_len = tc_db__ctc_ddlalter_table_def__get_packed_size(&req); stack_mem->set_mem_size(msg_len + sizeof(ddl_ctrl_t)); - void *tse_ddl_req_msg_mem = stack_mem->get_buf(); - if(tse_ddl_req_msg_mem == nullptr) { + void *ctc_ddl_req_msg_mem = stack_mem->get_buf(); + if(ctc_ddl_req_msg_mem == nullptr) { return HA_ERR_OUT_OF_MEM; } - if (tc_db__tse_ddlalter_table_def__pack(&req, (uint8_t *)tse_ddl_req_msg_mem + sizeof(ddl_ctrl_t)) != msg_len) { + if (tc_db__ctc_ddlalter_table_def__pack(&req, (uint8_t *)ctc_ddl_req_msg_mem + sizeof(ddl_ctrl_t)) != msg_len) { assert(false); } ddl_ctrl->msg_len = msg_len + sizeof(ddl_ctrl_t); - memcpy(tse_ddl_req_msg_mem, ddl_ctrl, sizeof(ddl_ctrl_t)); + memcpy(ctc_ddl_req_msg_mem, ddl_ctrl, sizeof(ddl_ctrl_t)); return 0; } -static void tse_fill_rename_constraints(TcDb__TseDDLRenameTableDef *req, const char *old_cons_name, +static void ctc_fill_rename_constraints(TcDb__CtcDDLRenameTableDef *req, const char *old_cons_name, const char *new_cons_name, char **mem_start, char *mem_end) { - req->old_constraints_name[req->n_old_constraints_name] = (char *)tse_ddl_alloc_mem(mem_start, mem_end, + req->old_constraints_name[req->n_old_constraints_name] = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, sizeof(char) * (strlen(old_cons_name) + 1)); - req->new_constraints_name[req->n_new_constraints_name] = (char *)tse_ddl_alloc_mem(mem_start, mem_end, + req->new_constraints_name[req->n_new_constraints_name] = (char *)ctc_ddl_alloc_mem(mem_start, mem_end, sizeof(char) * (strlen(new_cons_name) + 1)); assert(req->old_constraints_name[req->n_old_constraints_name] != NULL); assert(req->new_constraints_name[req->n_new_constraints_name] != NULL); @@ -2539,10 +2539,10 @@ static void tse_fill_rename_constraints(TcDb__TseDDLRenameTableDef *req, const c strcpy(req->new_constraints_name[req->n_new_constraints_name], new_cons_name); } -static int init_tse_ddl_rename_constraints_def(THD *thd, TcDb__TseDDLRenameTableDef *req, +static int init_ctc_ddl_rename_constraints_def(THD *thd, TcDb__CtcDDLRenameTableDef *req, const dd::Table *from_table_def, dd::Table *to_table_def, char **mem_start, char *mem_end) { size_t constraint_size = from_table_def->foreign_keys().size(); - handlerton *tse_handlerton = get_tse_hton(); + handlerton *ctc_handlerton = get_ctc_hton(); size_t generated_cons = 0; // The number of default constraints bool is_alter_copy = is_alter_table_copy(thd); @@ -2558,26 +2558,26 @@ static int init_tse_ddl_rename_constraints_def(THD *thd, TcDb__TseDDLRenameTable (from_table_def->tablespace_id() != to_table_def->tablespace_id()) || // copy rename cross db (strcmp(from_tbl_name, to_table_def->name().c_str()) != 0)); // alter copy(如指定) for (const dd::Foreign_key *fk : from_table_def->foreign_keys()) { - bool is_generated_name = dd::is_generated_foreign_key_name(from_tbl_name, tbl_name_length, tse_handlerton, *fk); + bool is_generated_name = dd::is_generated_foreign_key_name(from_tbl_name, tbl_name_length, ctc_handlerton, *fk); if (is_generated_name && is_rename_table) { generated_cons++; } } - req->new_constraints_name = (char **)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(char *) * generated_cons); - req->old_constraints_name = (char **)tse_ddl_alloc_mem(mem_start, mem_end, sizeof(char *) * generated_cons); + req->new_constraints_name = (char **)ctc_ddl_alloc_mem(mem_start, mem_end, sizeof(char *) * generated_cons); + req->old_constraints_name = (char **)ctc_ddl_alloc_mem(mem_start, mem_end, sizeof(char *) * generated_cons); if (req->new_constraints_name == NULL || req->old_constraints_name == NULL) { return HA_ERR_OUT_OF_MEM; } for (const dd::Foreign_key *fk : from_table_def->foreign_keys()) { - bool is_generated_name = dd::is_generated_foreign_key_name(from_tbl_name, tbl_name_length, tse_handlerton, *fk); + bool is_generated_name = dd::is_generated_foreign_key_name(from_tbl_name, tbl_name_length, ctc_handlerton, *fk); if (is_generated_name && is_rename_table) { - char new_fk_name[TSE_MAX_CONS_NAME_LEN + 1]; + char new_fk_name[CTC_MAX_CONS_NAME_LEN + 1]; // Construct new name by copying suffix from the old one. strxnmov(new_fk_name, sizeof(new_fk_name) - 1, to_table_def->name().c_str(), fk->name().c_str() + tbl_name_length, NullS); - tse_fill_rename_constraints(req, fk->name().c_str(), new_fk_name, mem_start, mem_end); + ctc_fill_rename_constraints(req, fk->name().c_str(), new_fk_name, mem_start, mem_end); req->n_old_constraints_name++; req->n_new_constraints_name++; } @@ -2587,22 +2587,22 @@ static int init_tse_ddl_rename_constraints_def(THD *thd, TcDb__TseDDLRenameTable } int fill_rename_table_req(const char *from, const char *to, const dd::Table *from_table_def, - dd::Table *to_table_def, THD *thd, ddl_ctrl_t *ddl_ctrl, tse_ddl_stack_mem *stack_mem) { + dd::Table *to_table_def, THD *thd, ddl_ctrl_t *ddl_ctrl, ctc_ddl_stack_mem *stack_mem) { char old_db[SMALL_RECORD_SIZE] = { 0 }; char new_db[SMALL_RECORD_SIZE] = { 0 }; char user_name[SMALL_RECORD_SIZE] = { 0 }; char new_user_name[SMALL_RECORD_SIZE] = { 0 }; - tse_split_normalized_name(from, old_db, SMALL_RECORD_SIZE, nullptr, 0, nullptr); - tse_split_normalized_name(to, new_db, SMALL_RECORD_SIZE, nullptr, 0, nullptr); - tse_copy_name(user_name, old_db, SMALL_RECORD_SIZE); - tse_copy_name(new_user_name, new_db, SMALL_RECORD_SIZE); + ctc_split_normalized_name(from, old_db, SMALL_RECORD_SIZE, nullptr, 0, nullptr); + ctc_split_normalized_name(to, new_db, SMALL_RECORD_SIZE, nullptr, 0, nullptr); + ctc_copy_name(user_name, old_db, SMALL_RECORD_SIZE); + ctc_copy_name(new_user_name, new_db, SMALL_RECORD_SIZE); - char *req_mem_start = tse_ddl_req_mem; - char *req_mem_end = req_mem_start + TSE_DDL_PROTOBUF_MEM_SIZE; - TcDb__TseDDLRenameTableDef req; - tc_db__tse_ddlrename_table_def__init(&req); + char *req_mem_start = ctc_ddl_req_mem; + char *req_mem_end = req_mem_start + CTC_DDL_PROTOBUF_MEM_SIZE; + TcDb__CtcDDLRenameTableDef req; + tc_db__ctc_ddlrename_table_def__init(&req); - int ret = init_tse_ddl_rename_constraints_def(thd, &req, from_table_def, to_table_def, &req_mem_start, req_mem_end); + int ret = init_ctc_ddl_rename_constraints_def(thd, &req, from_table_def, to_table_def, &req_mem_start, req_mem_end); if (ret != 0) { return ret; } @@ -2613,19 +2613,19 @@ int fill_rename_table_req(const char *from, const char *to, const dd::Table *fro req.old_table_name = const_cast(from_table_def->name().c_str()); req.new_db_name = new_db; req.new_table_name = const_cast(to_table_def->name().c_str()); - req.current_db_name = const_cast(TSE_GET_THD_DB_NAME(thd)); + req.current_db_name = const_cast(CTC_GET_THD_DB_NAME(thd)); string sql = string(thd->query().str).substr(0, thd->query().length); req.sql_str = const_cast(sql.c_str()); - size_t msg_len = tc_db__tse_ddlrename_table_def__get_packed_size(&req); + size_t msg_len = tc_db__ctc_ddlrename_table_def__get_packed_size(&req); stack_mem->set_mem_size(msg_len + sizeof(ddl_ctrl_t)); - void *tse_ddl_req_msg_mem = stack_mem->get_buf(); - if(tse_ddl_req_msg_mem == nullptr) { + void *ctc_ddl_req_msg_mem = stack_mem->get_buf(); + if(ctc_ddl_req_msg_mem == nullptr) { return HA_ERR_OUT_OF_MEM; } - if (tc_db__tse_ddlrename_table_def__pack(&req, (uint8_t *)tse_ddl_req_msg_mem) != msg_len) { + if (tc_db__ctc_ddlrename_table_def__pack(&req, (uint8_t *)ctc_ddl_req_msg_mem) != msg_len) { assert(false); } @@ -2633,18 +2633,18 @@ int fill_rename_table_req(const char *from, const char *to, const dd::Table *fro return 0; } -static int fill_partition_info_4truncate(TcDb__TseDDLTruncateTablePartitionDef *req, dd::Table *dd_table, +static int fill_partition_info_4truncate(TcDb__CtcDDLTruncateTablePartitionDef *req, dd::Table *dd_table, partition_info *part_info, char **mem_start, char *mem_end) { uint32_t part_num = 0; if (part_info->is_sub_partitioned()) { req->n_subpartition_id = 0; - req->subpartition_id = (uint32_t *)tse_ddl_alloc_mem( + req->subpartition_id = (uint32_t *)ctc_ddl_alloc_mem( mem_start, mem_end, dd_table->leaf_partitions()->size() * sizeof(uint32_t)); if (req->subpartition_id == nullptr) { return HA_ERR_OUT_OF_MEM; } req->n_subpartition_name = 0; - req->subpartition_name = (char **)tse_ddl_alloc_mem( + req->subpartition_name = (char **)ctc_ddl_alloc_mem( mem_start, mem_end, dd_table->leaf_partitions()->size() * sizeof(char *)); if (req->subpartition_name == nullptr) { return HA_ERR_OUT_OF_MEM; @@ -2680,89 +2680,89 @@ static int fill_partition_info_4truncate(TcDb__TseDDLTruncateTablePartitionDef * } int fill_truncate_partition_req(const char *full_name, partition_info *part_info, - dd::Table *dd_table, THD *thd, ddl_ctrl_t *ddl_ctrl, tse_ddl_stack_mem *stack_mem) { - lock_guard lock(m_tse_ddl_protobuf_mem_mutex); - char *req_mem_start = tse_ddl_req_mem; - char *req_mem_end = req_mem_start + TSE_DDL_PROTOBUF_MEM_SIZE; + dd::Table *dd_table, THD *thd, ddl_ctrl_t *ddl_ctrl, ctc_ddl_stack_mem *stack_mem) { + lock_guard lock(m_ctc_ddl_protobuf_mem_mutex); + char *req_mem_start = ctc_ddl_req_mem; + char *req_mem_end = req_mem_start + CTC_DDL_PROTOBUF_MEM_SIZE; char db_name[SMALL_RECORD_SIZE] = { 0 }; char user_name[SMALL_RECORD_SIZE] = { 0 }; const char *table_name_str = dd_table->name().c_str(); - tse_split_normalized_name(full_name, db_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); - tse_copy_name(user_name, db_name, SMALL_RECORD_SIZE); - TcDb__TseDDLTruncateTablePartitionDef req; - tc_db__tse_ddltruncate_table_partition_def__init(&req); + ctc_split_normalized_name(full_name, db_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); + ctc_copy_name(user_name, db_name, SMALL_RECORD_SIZE); + TcDb__CtcDDLTruncateTablePartitionDef req; + tc_db__ctc_ddltruncate_table_partition_def__init(&req); req.user = user_name; - req.db_name = TSE_GET_THD_DB_NAME(thd); + req.db_name = CTC_GET_THD_DB_NAME(thd); req.table_name = const_cast(table_name_str); string sql = string(thd->query().str).substr(0, thd->query().length); req.sql_str = const_cast(sql.c_str()); req.n_partition_id = 0; - req.partition_id = (uint32_t *)tse_ddl_alloc_mem( + req.partition_id = (uint32_t *)ctc_ddl_alloc_mem( &req_mem_start, req_mem_end, dd_table->leaf_partitions()->size() * sizeof(uint32_t)); if (req.partition_id == nullptr) { return HA_ERR_OUT_OF_MEM; } req.n_partition_name = 0; - req.partition_name = (char **)tse_ddl_alloc_mem( + req.partition_name = (char **)ctc_ddl_alloc_mem( &req_mem_start, req_mem_end, dd_table->leaf_partitions()->size() * sizeof(char *)); if (req.partition_name == nullptr) { return HA_ERR_OUT_OF_MEM; } - TSE_RETURN_IF_NOT_ZERO(fill_partition_info_4truncate(&req, dd_table, + CTC_RETURN_IF_NOT_ZERO(fill_partition_info_4truncate(&req, dd_table, part_info, &req_mem_start, req_mem_end)); - size_t msg_len = tc_db__tse_ddltruncate_table_partition_def__get_packed_size(&req); + size_t msg_len = tc_db__ctc_ddltruncate_table_partition_def__get_packed_size(&req); stack_mem->set_mem_size(msg_len + sizeof(ddl_ctrl_t)); - void *tse_ddl_req_msg_mem = stack_mem->get_buf(); - if(tse_ddl_req_msg_mem == nullptr) { + void *ctc_ddl_req_msg_mem = stack_mem->get_buf(); + if(ctc_ddl_req_msg_mem == nullptr) { return HA_ERR_OUT_OF_MEM; } - if (tc_db__tse_ddltruncate_table_partition_def__pack(&req, (uint8_t *)tse_ddl_req_msg_mem + sizeof(ddl_ctrl_t)) + if (tc_db__ctc_ddltruncate_table_partition_def__pack(&req, (uint8_t *)ctc_ddl_req_msg_mem + sizeof(ddl_ctrl_t)) != msg_len) { assert(false); } ddl_ctrl->msg_len = msg_len + sizeof(ddl_ctrl_t); - memcpy(tse_ddl_req_msg_mem, ddl_ctrl, sizeof(ddl_ctrl_t)); + memcpy(ctc_ddl_req_msg_mem, ddl_ctrl, sizeof(ddl_ctrl_t)); return 0; } -int init_tse_optimize_table_def(TcDb__TseDDLAlterTableDef *req, TABLE *table, char **mem_start, char *mem_end) { - tc_db__tse_ddlalter_table_def__init(req); +int init_ctc_optimize_table_def(TcDb__CtcDDLAlterTableDef *req, TABLE *table, char **mem_start, char *mem_end) { + tc_db__ctc_ddlalter_table_def__init(req); req->n_alter_index_list = table->s->keys; if (req->n_alter_index_list > 0) { - req->alter_index_list = (TcDb__TseDDLAlterIndexDef **)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLAlterIndexDef) * req->n_alter_index_list); + req->alter_index_list = (TcDb__CtcDDLAlterIndexDef **)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLAlterIndexDef) * req->n_alter_index_list); if (req->alter_index_list == NULL) { return HA_ERR_OUT_OF_MEM; } for (uint i = 0; i < req->n_alter_index_list; i++) { - req->alter_index_list[i] = (TcDb__TseDDLAlterIndexDef *)tse_ddl_alloc_mem( - mem_start, mem_end, sizeof(TcDb__TseDDLAlterIndexDef)); + req->alter_index_list[i] = (TcDb__CtcDDLAlterIndexDef *)ctc_ddl_alloc_mem( + mem_start, mem_end, sizeof(TcDb__CtcDDLAlterIndexDef)); if (req->alter_index_list[i] == NULL) { return HA_ERR_OUT_OF_MEM; } - tc_db__tse_ddlalter_index_def__init(req->alter_index_list[i]); + tc_db__ctc_ddlalter_index_def__init(req->alter_index_list[i]); } } return 0; } -int fill_rebuild_index_req(TABLE *table, THD *thd, ddl_ctrl_t *ddl_ctrl, tse_ddl_stack_mem *stack_mem) { +int fill_rebuild_index_req(TABLE *table, THD *thd, ddl_ctrl_t *ddl_ctrl, ctc_ddl_stack_mem *stack_mem) { int ret; - lock_guard lock(m_tse_ddl_protobuf_mem_mutex); - TcDb__TseDDLAlterTableDef req; - char *req_mem_start = tse_ddl_req_mem; - char *req_mem_end = req_mem_start + TSE_DDL_PROTOBUF_MEM_SIZE; + lock_guard lock(m_ctc_ddl_protobuf_mem_mutex); + TcDb__CtcDDLAlterTableDef req; + char *req_mem_start = ctc_ddl_req_mem; + char *req_mem_end = req_mem_start + CTC_DDL_PROTOBUF_MEM_SIZE; char db_name[SMALL_RECORD_SIZE] = { 0 }; char table_name[SMALL_RECORD_SIZE] = { 0 }; - tse_copy_name(db_name, thd->lex->query_tables->get_db_name(), SMALL_RECORD_SIZE); - tse_copy_name(table_name, thd->lex->query_tables->table_name, SMALL_RECORD_SIZE); + ctc_copy_name(db_name, thd->lex->query_tables->get_db_name(), SMALL_RECORD_SIZE); + ctc_copy_name(table_name, thd->lex->query_tables->table_name, SMALL_RECORD_SIZE); - ret = init_tse_optimize_table_def(&req, table, &req_mem_start, req_mem_end); + ret = init_ctc_optimize_table_def(&req, table, &req_mem_start, req_mem_end); if (ret != 0) { return ret; } @@ -2770,26 +2770,26 @@ int fill_rebuild_index_req(TABLE *table, THD *thd, ddl_ctrl_t *ddl_ctrl, tse_ddl req.name = table_name; fill_sys_cur_timestamp(thd, &req); for (uint32_t i = 0; i < req.n_alter_index_list; ++i) { - TcDb__TseDDLAlterIndexDef *req_alter_index_def = req.alter_index_list[i]; + TcDb__CtcDDLAlterIndexDef *req_alter_index_def = req.alter_index_list[i]; req_alter_index_def->user = db_name; req_alter_index_def->table = table_name; req_alter_index_def->name = const_cast (table->key_info[i].name); } - req.db_name = TSE_GET_THD_DB_NAME(thd); + req.db_name = CTC_GET_THD_DB_NAME(thd); string sql = string(thd->query().str).substr(0, thd->query().length); req.sql_str = const_cast(sql.c_str()); - size_t msg_len = tc_db__tse_ddlalter_table_def__get_packed_size(&req); + size_t msg_len = tc_db__ctc_ddlalter_table_def__get_packed_size(&req); stack_mem->set_mem_size(msg_len + sizeof(ddl_ctrl_t)); - void *tse_ddl_req_msg_mem = stack_mem->get_buf(); - if(tse_ddl_req_msg_mem == nullptr) { + void *ctc_ddl_req_msg_mem = stack_mem->get_buf(); + if(ctc_ddl_req_msg_mem == nullptr) { return HA_ERR_OUT_OF_MEM; } - if (tc_db__tse_ddlalter_table_def__pack(&req, (uint8_t *)tse_ddl_req_msg_mem + sizeof(ddl_ctrl_t)) != msg_len) { + if (tc_db__ctc_ddlalter_table_def__pack(&req, (uint8_t *)ctc_ddl_req_msg_mem + sizeof(ddl_ctrl_t)) != msg_len) { assert(false); } ddl_ctrl->msg_len = msg_len + sizeof(ddl_ctrl_t); - memcpy(tse_ddl_req_msg_mem, ddl_ctrl, sizeof(ddl_ctrl_t)); + memcpy(ctc_ddl_req_msg_mem, ddl_ctrl, sizeof(ddl_ctrl_t)); return 0; } \ No newline at end of file diff --git a/storage/tianchi/ha_tse_ddl.h b/storage/ctc/ha_ctc_ddl.h similarity index 62% rename from storage/tianchi/ha_tse_ddl.h rename to storage/ctc/ha_ctc_ddl.h index 04f6680..4c7fd43 100644 --- a/storage/tianchi/ha_tse_ddl.h +++ b/storage/ctc/ha_ctc_ddl.h @@ -14,25 +14,25 @@ along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#ifndef __HA_TSE_DDL_H__ -#define __HA_TSE_DDL_H__ -#include "tse_srv.h" +#ifndef __HA_CTC_DDL_H__ +#define __HA_CTC_DDL_H__ +#include "ctc_srv.h" #include #include #include -#include "storage/tianchi/ha_tsepart.h" +#include "storage/ctc/ha_ctcpart.h" #define UN_SUPPORT_DDL "ddl statement" /** Max table name length as defined in CT_MAX_NAME_LEN */ -#define TSE_MAX_TABLE_NAME_LEN 64 -#define TSE_MAX_CONS_NAME_LEN TSE_MAX_TABLE_NAME_LEN -#define TSE_MAX_DATABASE_NAME_LEN TSE_MAX_TABLE_NAME_LEN -#define TSE_MAX_BIT_LEN 64 -#define TSE_ENUM_DEFAULT_NULL -1 -#define TSE_ENUM_DEFAULT_INVALID -2 -#define TSE_MAX_FULL_NAME_LEN (TSE_MAX_TABLE_NAME_LEN + TSE_MAX_DATABASE_NAME_LEN + 14) -#define TSE_TYPE_TIME_SIZE 3 -#define TSE_TYPE_DATATIME_SIZE 5 -#define TSE_TYPE_TIMPSTAMP_SIZE 4 +#define CTC_MAX_TABLE_NAME_LEN 64 +#define CTC_MAX_CONS_NAME_LEN CTC_MAX_TABLE_NAME_LEN +#define CTC_MAX_DATABASE_NAME_LEN CTC_MAX_TABLE_NAME_LEN +#define CTC_MAX_BIT_LEN 64 +#define CTC_ENUM_DEFAULT_NULL -1 +#define CTC_ENUM_DEFAULT_INVALID -2 +#define CTC_MAX_FULL_NAME_LEN (CTC_MAX_TABLE_NAME_LEN + CTC_MAX_DATABASE_NAME_LEN + 14) +#define CTC_TYPE_TIME_SIZE 3 +#define CTC_TYPE_DATATIME_SIZE 5 +#define CTC_TYPE_TIMPSTAMP_SIZE 4 #define DATA_N_SYS_COLS 3 /* number of system columns defined above */ @@ -51,43 +51,43 @@ is that mlog_parse_index() cannot recognize the system columns by just having n_fields, n_uniq and the lengths of the columns. */ #define REC_MAX_N_USER_FIELDS (REC_MAX_N_FIELDS - DATA_N_SYS_COLS * 2) -#define TSE_DDL_PROTOBUF_MSG_STACK_SIZE (4 * 1024) // < 4kb用栈内存，大于4kb用堆内存 -#define TSE_DDL_PROTOBUF_MSG_SIZE (1024 * 1024 * 10) // 10M +#define CTC_DDL_PROTOBUF_MSG_STACK_SIZE (4 * 1024) // < 4kb用栈内存，大于4kb用堆内存 +#define CTC_DDL_PROTOBUF_MSG_SIZE (1024 * 1024 * 10) // 10M typedef enum { - TSE_CREATE_IF_NOT_EXISTS = 0x00000001, - TSE_CREATE_OR_REPLACE = 0x00000002, - TSE_CREATE_TYPE_NO_CHECK_CONS = 0x00000008, // for create child table but ref parent table not create -} tse_create_option_t; + CTC_CREATE_IF_NOT_EXISTS = 0x00000001, + CTC_CREATE_OR_REPLACE = 0x00000002, + CTC_CREATE_TYPE_NO_CHECK_CONS = 0x00000008, // for create child table but ref parent table not create +} ctc_create_option_t; typedef enum { - TSE_DROP_IF_EXISTS = 0x00000001, - TSE_DROP_KEEP_FILES = 0x00000002, // for tablespace - TSE_DROP_CASCADE_CONS = 0x00000004, // for tablespace - TSE_DROP_NO_CHECK_FK = 0x00000010, // for support drop without checking foreign key - TSE_DROP_FOR_MYSQL_COPY = 0x00000020, // for support alter parent table using mysql copy - TSE_DROP_NO_CHECK_FK_FOR_CANTIAN_AND_BROADCAST = 0x01000000, // just for broadcast to set NO_CHECK_FK, not for cantian -} tse_drop_option_t; + CTC_DROP_IF_EXISTS = 0x00000001, + CTC_DROP_KEEP_FILES = 0x00000002, // for tablespace + CTC_DROP_CASCADE_CONS = 0x00000004, // for tablespace + CTC_DROP_NO_CHECK_FK = 0x00000010, // for support drop without checking foreign key + CTC_DROP_FOR_MYSQL_COPY = 0x00000020, // for support alter parent table using mysql copy + CTC_DROP_NO_CHECK_FK_FOR_CANTIAN_AND_BROADCAST = 0x01000000, // just for broadcast to set NO_CHECK_FK, not for cantian +} ctc_drop_option_t; typedef enum { - TSE_ALTSPACE_ADD_DATAFILE = 0, - TSE_ALTSPACE_DROP_DATAFILE = 1, - TSE_ALTSPACE_RENAME_DATAFILE = 2, - TSE_ALTSPACE_RENAME_SPACE = 3, - TSE_ALTSPACE_SET_AUTOEXTEND = 4, - TSE_ALTSPACE_SET_AUTOPURGE = 5, - TSE_ALTSPACE_SET_RETENTION = 6, - TSE_ALTSPACE_OFFLINE_DATAFILE = 7, - TSE_ALTSPACE_SHRINK_SPACE = 8, - TSE_ALTSPACE_SET_AUTOOFFLINE = 9 -} tse_altspace_action_t; + CTC_ALTSPACE_ADD_DATAFILE = 0, + CTC_ALTSPACE_DROP_DATAFILE = 1, + CTC_ALTSPACE_RENAME_DATAFILE = 2, + CTC_ALTSPACE_RENAME_SPACE = 3, + CTC_ALTSPACE_SET_AUTOEXTEND = 4, + CTC_ALTSPACE_SET_AUTOPURGE = 5, + CTC_ALTSPACE_SET_RETENTION = 6, + CTC_ALTSPACE_OFFLINE_DATAFILE = 7, + CTC_ALTSPACE_SHRINK_SPACE = 8, + CTC_ALTSPACE_SET_AUTOOFFLINE = 9 +} ctc_altspace_action_t; typedef enum { - TSE_DDL_FK_RULE_UNKNOW = -1, - TSE_DDL_FK_RULE_RESTRICT, - TSE_DDL_FK_RULE_CASCADE, - TSE_DDL_FK_RULE_SET_NULL -} tse_ddl_fk_rule; + CTC_DDL_FK_RULE_UNKNOW = -1, + CTC_DDL_FK_RULE_RESTRICT, + CTC_DDL_FK_RULE_CASCADE, + CTC_DDL_FK_RULE_SET_NULL +} ctc_ddl_fk_rule; typedef enum { /** @@ -98,13 +98,13 @@ typedef enum { @note Assigned as default value for key algorithm by parser, replaced by SEs default algorithm for keys in mysql_prepare_create_table(). */ - TSE_HA_KEY_ALG_UNKNOW = -1, - TSE_HA_KEY_ALG_SE_SPECIFIC = 0, - TSE_HA_KEY_ALG_BTREE = 1, /* B-tree. */ - TSE_HA_KEY_ALG_RTREE = 2, /* R-tree, for spatial searches */ - TSE_HA_KEY_ALG_HASH = 3, /* HASH keys (HEAP, NDB). */ - TSE_HA_KEY_ALG_FULLTEXT = 4 /* FULLTEXT. */ -} tse_ha_key_alg; + CTC_HA_KEY_ALG_UNKNOW = -1, + CTC_HA_KEY_ALG_SE_SPECIFIC = 0, + CTC_HA_KEY_ALG_BTREE = 1, /* B-tree. */ + CTC_HA_KEY_ALG_RTREE = 2, /* R-tree, for spatial searches */ + CTC_HA_KEY_ALG_HASH = 3, /* HASH keys (HEAP, NDB). */ + CTC_HA_KEY_ALG_FULLTEXT = 4 /* FULLTEXT. */ +} ctc_ha_key_alg; typedef enum { COLLATE_DEFAULT = -1, @@ -136,10 +136,10 @@ typedef enum { COLLATE_DEC8_SWEDISH_CI = 87, COLLATE_SWEDISH_CI = 255, COLLATE_LATIN2_GENERAL_CI = 309 -} enum_tse_ddl_collate_type; +} enum_ctc_ddl_collate_type; // mysql字符序和daac的参数对接 -static map mysql_collate_num_to_tse_type = { +static map mysql_collate_num_to_ctc_type = { {3, COLLATE_DEC8_SWEDISH_CI}, {4, COLLATE_CP850_GENERAL_CI}, {5, COLLATE_LATIN1_GERMAN1_CI}, @@ -170,31 +170,31 @@ static map mysql_collate_num_to_tse_type = { {76, COLLATE_UTF8_TOLOWER_CI}, }; -static map g_tse_alter_tablespace_map = { - {ALTER_TABLESPACE_ADD_FILE, TSE_ALTSPACE_ADD_DATAFILE}, - {ALTER_TABLESPACE_DROP_FILE, TSE_ALTSPACE_DROP_DATAFILE}, - {ALTER_TABLESPACE_RENAME, TSE_ALTSPACE_RENAME_SPACE}, - {ALTER_TABLESPACE_OPTIONS, TSE_ALTSPACE_SET_AUTOEXTEND}, // option 只有auto extend适配 +static map g_ctc_alter_tablespace_map = { + {ALTER_TABLESPACE_ADD_FILE, CTC_ALTSPACE_ADD_DATAFILE}, + {ALTER_TABLESPACE_DROP_FILE, CTC_ALTSPACE_DROP_DATAFILE}, + {ALTER_TABLESPACE_RENAME, CTC_ALTSPACE_RENAME_SPACE}, + {ALTER_TABLESPACE_OPTIONS, CTC_ALTSPACE_SET_AUTOEXTEND}, // option 只有auto extend适配 }; -class tse_ddl_stack_mem { +class ctc_ddl_stack_mem { public: - tse_ddl_stack_mem(size_t mem_size):buf_obj(nullptr) { + ctc_ddl_stack_mem(size_t mem_size):buf_obj(nullptr) { set_mem_size(mem_size); } void set_mem_size(size_t mem_size) { free_buf(); - assert(mem_size < TSE_DDL_PROTOBUF_MSG_SIZE); - if (mem_size <= TSE_DDL_PROTOBUF_MSG_STACK_SIZE) { + assert(mem_size < CTC_DDL_PROTOBUF_MSG_SIZE); + if (mem_size <= CTC_DDL_PROTOBUF_MSG_STACK_SIZE) { buf_obj = stack_obj; } else { buf_obj = my_malloc(PSI_NOT_INSTRUMENTED, mem_size, MYF(MY_WME)); - tse_ddl_req_msg_mem_use_heap_cnt++; + ctc_ddl_req_msg_mem_use_heap_cnt++; } - tse_ddl_req_msg_mem_max_size = - std::max(tse_ddl_req_msg_mem_max_size, mem_size); + ctc_ddl_req_msg_mem_max_size = + std::max(ctc_ddl_req_msg_mem_max_size, mem_size); } - ~tse_ddl_stack_mem() { free_buf(); } + ~ctc_ddl_stack_mem() { free_buf(); } void *get_buf() { return buf_obj; } private: void free_buf() { @@ -204,31 +204,31 @@ private: } } public: - static size_t tse_ddl_req_msg_mem_max_size; // 统计ddl的req_msg_mem用的最多内存尺寸 - static size_t tse_ddl_req_msg_mem_use_heap_cnt; // 统计ddl的req_msg_mem用的堆内存的次数 + static size_t ctc_ddl_req_msg_mem_max_size; // 统计ddl的req_msg_mem用的最多内存尺寸 + static size_t ctc_ddl_req_msg_mem_use_heap_cnt; // 统计ddl的req_msg_mem用的堆内存的次数 private: - char stack_obj[TSE_DDL_PROTOBUF_MSG_STACK_SIZE]; + char stack_obj[CTC_DDL_PROTOBUF_MSG_STACK_SIZE]; void *buf_obj; }; int fill_delete_table_req(const char *full_path_name, const dd::Table *table_def, - THD *thd, ddl_ctrl_t *ddl_ctrl, tse_ddl_stack_mem *stack_mem); -int tsebase_alter_tablespace(handlerton *hton, THD *thd, + THD *thd, ddl_ctrl_t *ddl_ctrl, ctc_ddl_stack_mem *stack_mem); +int ctcbase_alter_tablespace(handlerton *hton, THD *thd, st_alter_tablespace *alter_info, const dd::Tablespace *old_ts_def, dd::Tablespace *new_ts_def); -int ha_tse_truncate_table(tianchi_handler_t *tch, THD *thd, const char *db_name, +int ha_ctc_truncate_table(ctc_handler_t *tch, THD *thd, const char *db_name, const char *table_name, bool is_tmp_table); -int check_tse_identifier_name(const char *in_name); +int check_ctc_identifier_name(const char *in_name); int fill_create_table_req(HA_CREATE_INFO *create_info, dd::Table *table_def, char *db_name, char *table_name, - TABLE *form, THD *thd, ddl_ctrl_t *ddl_ctrl, tse_ddl_stack_mem *stack_mem); + TABLE *form, THD *thd, ddl_ctrl_t *ddl_ctrl, ctc_ddl_stack_mem *stack_mem); int fill_alter_table_req(TABLE *altered_table, Alter_inplace_info *ha_alter_info, const dd::Table *old_table_def, - dd::Table *new_table_def, THD *thd, ddl_ctrl_t *ddl_ctrl, tse_ddl_stack_mem *stack_mem); + dd::Table *new_table_def, THD *thd, ddl_ctrl_t *ddl_ctrl, ctc_ddl_stack_mem *stack_mem); int fill_rename_table_req(const char *from, const char *to, const dd::Table *from_table_def, - dd::Table *to_table_def, THD *thd, ddl_ctrl_t *ddl_ctrl, tse_ddl_stack_mem *stack_mem); + dd::Table *to_table_def, THD *thd, ddl_ctrl_t *ddl_ctrl, ctc_ddl_stack_mem *stack_mem); int fill_truncate_partition_req(const char *full_name, partition_info *part_info, - dd::Table *dd_table, THD *thd, ddl_ctrl_t *ddl_ctrl, tse_ddl_stack_mem *stack_mem); -int fill_rebuild_index_req(TABLE *table, THD *thd, ddl_ctrl_t *ddl_ctrl, tse_ddl_stack_mem *stack_mem); -bool get_tse_key_type(const KEY *key_info, int32_t *ret_type); -bool get_tse_key_algorithm(ha_key_alg algorithm, int32_t *ret_algorithm); + dd::Table *dd_table, THD *thd, ddl_ctrl_t *ddl_ctrl, ctc_ddl_stack_mem *stack_mem); +int fill_rebuild_index_req(TABLE *table, THD *thd, ddl_ctrl_t *ddl_ctrl, ctc_ddl_stack_mem *stack_mem); +bool get_ctc_key_type(const KEY *key_info, int32_t *ret_type); +bool get_ctc_key_algorithm(ha_key_alg algorithm, int32_t *ret_algorithm); #endif diff --git a/storage/tianchi/ha_tsepart.cc b/storage/ctc/ha_ctcpart.cc similarity index 75% rename from storage/tianchi/ha_tsepart.cc rename to storage/ctc/ha_ctcpart.cc index 0d7187d..3b9aa3a 100644 --- a/storage/tianchi/ha_tsepart.cc +++ b/storage/ctc/ha_ctcpart.cc @@ -15,12 +15,12 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -// @file storage/tianchi/ha_tsepart.cc -// description: TIANCHI handler implementation for MySQL storage engine API. -// this module should use tse_part_srv rather than knl_intf +// @file storage/ctc/ha_ctcpart.cc +// description: CTC handler implementation for MySQL storage engine API. +// this module should use ctc_part_srv rather than knl_intf -#include "ha_tsepart.h" -#include "ha_tse_ddl.h" +#include "ha_ctcpart.h" +#include "ha_ctc_ddl.h" #include #include #include @@ -46,12 +46,12 @@ #include "sql/sql_lex.h" #include "sql/sql_plugin.h" #include "sql/partition_info.h" -#include "tse_error.h" -#include "tse_log.h" +#include "ctc_error.h" +#include "ctc_log.h" #include "srv_mq_msg.h" #include #include "typelib.h" -#include "tse_cbo.h" +#include "ctc_cbo.h" #include "sql/sql_alter.h" #include "sql/dd/properties.h" #include "sql/dd/types/partition.h" @@ -59,7 +59,7 @@ #define INVALID_PART_ID (uint32)0xFFFFFFFF; -extern handlerton *get_tse_hton(); +extern handlerton *get_ctc_hton(); extern uint32_t ctc_update_analyze_time; constexpr uint64 INVALID_VALUE64 = 0xFFFFFFFFFFFFFFFFULL; @@ -81,12 +81,12 @@ static bool get_used_partitions(partition_info *part_info, if (*used_parts > 0) { *part_ids = (uint32_t *)my_malloc(PSI_NOT_INSTRUMENTED, (*used_parts) * sizeof(uint32_t), MYF(MY_WME)); if (*part_ids == NULL) { - tse_log_system("Failed to allocate memory for part_ids."); + ctc_log_system("Failed to allocate memory for part_ids."); return false; } *subpart_ids = (uint32_t *)my_malloc(PSI_NOT_INSTRUMENTED, (*used_parts) * sizeof(uint32_t), MYF(MY_WME)); if (*subpart_ids == NULL) { - tse_log_system("Failed to allocate memory for subpart_ids. Freeing previously allocated memory..."); + ctc_log_system("Failed to allocate memory for subpart_ids. Freeing previously allocated memory..."); my_free(*part_ids); return false; } @@ -110,20 +110,20 @@ static bool get_used_partitions(partition_info *part_info, } } }else{ - tse_log_system("invalid used_parts :%u", *used_parts); + ctc_log_system("invalid used_parts :%u", *used_parts); } return true; } -ha_tsepart::ha_tsepart(handlerton *hton, TABLE_SHARE *table_arg) - : ha_tse(hton, table_arg), Partition_helper(this), +ha_ctcpart::ha_ctcpart(handlerton *hton, TABLE_SHARE *table_arg) + : ha_ctc(hton, table_arg), Partition_helper(this), m_bulk_insert_parts(nullptr), m_part_share(nullptr) { pruned_by_engine = false; ref_length = ROW_ID_LENGTH + PARTITION_BYTES_IN_POS; } /** - Open an TSE table. + Open an CTC table. @param[in] name table name @param[in] mode access mode @param[in] test_if_locked test if the file to be opened is locked @@ -131,9 +131,9 @@ ha_tsepart::ha_tsepart(handlerton *hton, TABLE_SHARE *table_arg) @retval 1 if error @retval 0 if success */ -int ha_tsepart::open(const char *name, int mode, uint test_if_locked, +int ha_ctcpart::open(const char *name, int mode, uint test_if_locked, const dd::Table *table_def) { - if (!(m_part_share = get_share())) return HA_ERR_OUT_OF_MEM; + if (!(m_part_share = get_share())) return HA_ERR_OUT_OF_MEM; if (m_part_info == NULL) { m_part_info = table->part_info; @@ -142,24 +142,24 @@ int ha_tsepart::open(const char *name, int mode, uint test_if_locked, lock_shared_ha_data(); if (m_part_share->populate_partition_name_hash(m_part_info)) { unlock_shared_ha_data(); - free_share(); + free_share(); return HA_ERR_INTERNAL_ERROR; } if (m_part_share->auto_inc_mutex == nullptr && table->found_next_number_field != nullptr) { if (m_part_share->init_auto_inc_mutex(table_share)) { unlock_shared_ha_data(); - free_share(); + free_share(); return HA_ERR_INTERNAL_ERROR; } } unlock_shared_ha_data(); - int ret = ha_tse::open(name, mode, test_if_locked, table_def); + int ret = ha_ctc::open(name, mode, test_if_locked, table_def); m_max_batch_num = m_max_batch_num > MAX_BULK_INSERT_PART_ROWS ? MAX_BULK_INSERT_PART_ROWS : m_max_batch_num; if (ret != CT_SUCCESS) { - free_share(); + free_share(); return ret; } if (open_partitioning(m_part_share)) { @@ -169,18 +169,18 @@ int ha_tsepart::open(const char *name, int mode, uint test_if_locked, return ret; } -int ha_tsepart::close() { +int ha_ctcpart::close() { assert(m_part_share); close_partitioning(); - free_share(); + free_share(); if (m_bulk_insert_parts != nullptr) { my_free(m_bulk_insert_parts); m_bulk_insert_parts = nullptr; } - return ha_tse::close(); + return ha_ctc::close(); } -void ha_tsepart::set_partition(uint part_id) { +void ha_ctcpart::set_partition(uint part_id) { if (m_is_sub_partitioned) { m_tch.part_id = get_ct_part_no(m_part_info->num_subparts, part_id); m_tch.subpart_id = get_ct_sub_no(m_part_info->num_subparts, part_id); @@ -190,24 +190,24 @@ void ha_tsepart::set_partition(uint part_id) { } } -void ha_tsepart::reset_partition(uint part_id) { +void ha_ctcpart::reset_partition(uint part_id) { m_tch.part_id = INVALID_PART_ID; m_tch.subpart_id = INVALID_PART_ID; m_last_part = part_id; } -void ha_tsepart::get_auto_increment(ulonglong, ulonglong, ulonglong, +void ha_ctcpart::get_auto_increment(ulonglong, ulonglong, ulonglong, ulonglong *first_value, ulonglong*) { uint64 inc_value; - update_member_tch(m_tch, get_tse_hton(), ha_thd()); + update_member_tch(m_tch, get_ctc_hton(), ha_thd()); THD* thd = ha_thd(); dml_flag_t flag; flag.auto_inc_offset = thd->variables.auto_increment_increment; flag.auto_inc_step = thd->variables.auto_increment_offset; flag.auto_increase = true; - int ret = tse_get_serial_value(&m_tch, &inc_value, flag); - update_sess_ctx_by_tch(m_tch, get_tse_hton(), ha_thd()); + int ret = ctc_get_serial_value(&m_tch, &inc_value, flag); + update_sess_ctx_by_tch(m_tch, get_ctc_hton(), ha_thd()); if (ret != 0) { *first_value = (~(ulonglong)0); return; @@ -215,13 +215,13 @@ void ha_tsepart::get_auto_increment(ulonglong, ulonglong, ulonglong, *first_value = inc_value; } -void ha_tsepart::print_error(int error, myf errflag) { +void ha_ctcpart::print_error(int error, myf errflag) { if (print_partition_error(error)) { handler::print_error(error, errflag); } } -void ha_tsepart::part_autoinc_has_expl_non_null_value_update_row(uchar *new_data) { +void ha_ctcpart::part_autoinc_has_expl_non_null_value_update_row(uchar *new_data) { if (table->found_next_number_field && new_data == table->record[0] && !table->s->next_number_keypart && bitmap_is_set(table->write_set, @@ -232,13 +232,13 @@ void ha_tsepart::part_autoinc_has_expl_non_null_value_update_row(uchar *new_data /** Write a row in specific partition. - Stores a row in an TSE database, to the table specified in this + Stores a row in an CTC database, to the table specified in this handle. @param[in] part_id Partition to write to. @param[in] record A row in MySQL format. @return error code. */ -int ha_tsepart::write_row_in_part(uint part_id, uchar *record) { +int ha_ctcpart::write_row_in_part(uint part_id, uchar *record) { bool saved_autoinc_has_expl_non_null = table->autoinc_field_has_explicit_non_null_value; Field *saved_next_number_field = table->next_number_field; THD *thd = ha_thd(); @@ -257,7 +257,7 @@ int ha_tsepart::write_row_in_part(uint part_id, uchar *record) { } set_partition(part_id); - int ret = ha_tse::write_row(record); + int ret = ha_ctc::write_row(record); if (ret == 0 && m_rec_buf_4_writing != nullptr) { assert(m_bulk_insert_parts != nullptr); @@ -273,9 +273,9 @@ int ha_tsepart::write_row_in_part(uint part_id, uchar *record) { return ret; } -void ha_tsepart::start_bulk_insert(ha_rows rows) { +void ha_ctcpart::start_bulk_insert(ha_rows rows) { assert(m_rec_buf_4_writing == nullptr); - ha_tse::start_bulk_insert(rows); + ha_ctc::start_bulk_insert(rows); if (m_rec_buf_4_writing != nullptr) { if (m_bulk_insert_parts == nullptr) { // m_max_batch_num is fixed after open table, if table structrue is changed, it should be closed and reopened @@ -285,9 +285,9 @@ void ha_tsepart::start_bulk_insert(ha_rows rows) { } } -int ha_tsepart::bulk_insert_low(dml_flag_t flag, uint *dup_offset) { +int ha_ctcpart::bulk_insert_low(dml_flag_t flag, uint *dup_offset) { record_info_t record_info = {m_rec_buf_data, (uint16_t)m_cantian_rec_len, nullptr, nullptr}; - return (ct_errno_t)tse_bulk_write(&m_tch, &record_info, m_rec_buf_4_writing->records(), + return (ct_errno_t)ctc_bulk_write(&m_tch, &record_info, m_rec_buf_4_writing->records(), dup_offset, flag, m_bulk_insert_parts); } @@ -299,13 +299,13 @@ int ha_tsepart::bulk_insert_low(dml_flag_t flag, uint *dup_offset) { @param[in] new_row New row in MySQL format. @return error number or 0. */ -int ha_tsepart::update_row_in_part(uint part_id, const uchar *old_row, uchar *new_row) { +int ha_ctcpart::update_row_in_part(uint part_id, const uchar *old_row, uchar *new_row) { if (m_index_sorted) { cursor_set_bit(cursor_set, part_id); m_tch.cursor_addr = cursors[part_id]; } int ret; - ret = ha_tse::update_row(old_row, new_row); + ret = ha_ctc::update_row(old_row, new_row); reset_partition(part_id); return ret; } @@ -315,7 +315,7 @@ int ha_tsepart::update_row_in_part(uint part_id, const uchar *old_row, uchar *ne @param[in] new_part_id New partition to write to. @return 0 for success else error code. */ -int ha_tsepart::write_row_in_new_part(uint new_part_id) { +int ha_ctcpart::write_row_in_new_part(uint new_part_id) { UNUSED_PARAM(new_part_id); return 0; } @@ -326,13 +326,13 @@ int ha_tsepart::write_row_in_new_part(uint new_part_id) { @param[in] record Row to delete in MySQL format. @return error number or 0. */ -int ha_tsepart::delete_row_in_part(uint part_id, const uchar *record) { +int ha_ctcpart::delete_row_in_part(uint part_id, const uchar *record) { if (m_index_sorted) { cursor_set_bit(cursor_set, part_id); m_tch.cursor_addr = cursors[part_id]; } int ret; - ret = ha_tse::delete_row(record); + ret = ha_ctc::delete_row(record); reset_partition(part_id); return ret; } @@ -343,9 +343,9 @@ int ha_tsepart::delete_row_in_part(uint part_id, const uchar *record) { @param[in] scan True for scan else random access. @return error number or 0. */ -int ha_tsepart::rnd_init_in_part(uint part_id, bool scan) { +int ha_ctcpart::rnd_init_in_part(uint part_id, bool scan) { set_partition(part_id); - int ret = ha_tse::rnd_init(scan); + int ret = ha_ctc::rnd_init(scan); reset_partition(part_id); return ret; } @@ -356,9 +356,9 @@ int ha_tsepart::rnd_init_in_part(uint part_id, bool scan) { @param[out] buf Next row. @return error number or 0. */ -int ha_tsepart::rnd_next_in_part(uint part_id, uchar *buf) { +int ha_ctcpart::rnd_next_in_part(uint part_id, uchar *buf) { set_partition(part_id); - int ret = ha_tse::rnd_next(buf); + int ret = ha_ctc::rnd_next(buf); reset_partition(part_id); return ret; } @@ -369,13 +369,13 @@ int ha_tsepart::rnd_next_in_part(uint part_id, uchar *buf) { @param[in] scan True for scan else random access. @return error number or 0. */ -int ha_tsepart::rnd_end_in_part(uint part_id, bool scan) { +int ha_ctcpart::rnd_end_in_part(uint part_id, bool scan) { UNUSED_PARAM(scan); if (m_tch.cursor_addr == INVALID_VALUE64) { return 0; } set_partition(part_id); - int ret = ha_tse::rnd_end(); + int ret = ha_ctc::rnd_end(); reset_partition(part_id); return ret; } @@ -385,21 +385,21 @@ int ha_tsepart::rnd_end_in_part(uint part_id, bool scan) { @param[out] ref_arg Reference (PK if exists else row_id). @param[in] record Record to position. */ -void ha_tsepart::position_in_last_part(uchar *ref_arg, const uchar *record) { +void ha_ctcpart::position_in_last_part(uchar *ref_arg, const uchar *record) { UNUSED_PARAM(record); m_tch.thd_id = ha_thd()->thread_id(); uint part_id = m_last_part; set_partition(part_id); int ret = 0; if (cur_pos_in_buf == INVALID_MAX_UINT32) { - ret = tse_position(&m_tch, ref_arg, ref_length - PARTITION_BYTES_IN_POS); + ret = ctc_position(&m_tch, ref_arg, ref_length - PARTITION_BYTES_IN_POS); } else { assert(cur_pos_in_buf < max_prefetch_num); memcpy(ref_arg, &m_rowids[cur_pos_in_buf], ref_length - PARTITION_BYTES_IN_POS); } if (ret != 0) { - tse_log_error("find position failed."); + ctc_log_error("find position failed."); assert(0); } reset_partition(part_id); @@ -412,13 +412,13 @@ void ha_tsepart::position_in_last_part(uchar *ref_arg, const uchar *record) { @param[in] pos Position, given as primary key value or DB_ROW_ID @return 0, HA_ERR_KEY_NOT_FOUND or error code. */ -int ha_tsepart::rnd_pos(uchar *buf, uchar *pos) { +int ha_ctcpart::rnd_pos(uchar *buf, uchar *pos) { DBUG_TRACE; ha_statistic_increment(&System_status_var::ha_read_rnd_count); m_tch.thd_id = ha_thd()->thread_id(); uint part_id = uint2korr(pos); set_partition(part_id); - int ret = ha_tse::rnd_pos(buf, pos + PARTITION_BYTES_IN_POS); + int ret = ha_ctc::rnd_pos(buf, pos + PARTITION_BYTES_IN_POS); reset_partition(part_id); return ret; } @@ -429,7 +429,7 @@ int ha_tsepart::rnd_pos(uchar *buf, uchar *pos) { @param[in] sorted True if result MUST be sorted according to index. @return 0 or error number. */ -int ha_tsepart::index_init(uint index, bool sorted) { +int ha_ctcpart::index_init(uint index, bool sorted) { int ret; ret = ph_index_init_setup(index, sorted); if (ret != 0) { @@ -448,7 +448,7 @@ int ha_tsepart::index_init(uint index, bool sorted) { uint part_id = m_part_info->get_first_used_partition(); set_partition(part_id); - ret = ha_tse::index_init(index, sorted); + ret = ha_ctc::index_init(index, sorted); reset_partition(part_id); pruned_by_engine = false; @@ -464,14 +464,14 @@ int ha_tsepart::index_init(uint index, bool sorted) { End index cursor. @return 0 or error code. */ -int ha_tsepart::index_end() { +int ha_ctcpart::index_end() { pruned_by_engine = false; if (m_ordered) { destroy_record_priority_queue(); for (uint i = m_part_info->get_first_used_partition(); i < MY_BIT_NONE; i = m_part_info->get_next_used_partition(i)) { if (cursor_is_set(cursor_set, i)){ m_tch.cursor_addr = cursors[i]; - ha_tse::index_end(); + ha_ctc::index_end(); cursor_clear_bit(cursor_set, i); } } @@ -480,7 +480,7 @@ int ha_tsepart::index_end() { return 0; } - ha_tse::index_end(); + ha_ctc::index_end(); m_tch.part_id = INVALID_PART_ID; m_tch.subpart_id = INVALID_PART_ID; m_tch.cursor_ref = 0; @@ -488,9 +488,9 @@ int ha_tsepart::index_end() { return 0; } -int ha_tsepart::index_read(uchar *buf, const uchar *key, uint key_len, +int ha_ctcpart::index_read(uchar *buf, const uchar *key, uint key_len, ha_rkey_function find_flag) { - return ha_tse::index_read(buf, key, key_len, find_flag); + return ha_ctc::index_read(buf, key, key_len, find_flag); } /** @@ -499,12 +499,12 @@ int ha_tsepart::index_read(uchar *buf, const uchar *key, uint key_len, @param[out] record First record in index in the partition. @return error number or 0. */ -int ha_tsepart::index_first_in_part(uint part_id, uchar *record) { +int ha_ctcpart::index_first_in_part(uint part_id, uchar *record) { if (part_id != m_last_part) { - ha_tse::reset_rec_buf(); + ha_ctc::reset_rec_buf(); } set_partition(part_id); - int ret = ha_tse::index_first(record); + int ret = ha_ctc::index_first(record); reset_partition(part_id); if (m_index_sorted) { cursor_set_bit(cursor_set, part_id); @@ -519,12 +519,12 @@ int ha_tsepart::index_first_in_part(uint part_id, uchar *record) { @param[out] record Last record in index in the partition. @return error number or 0. */ -int ha_tsepart::index_last_in_part(uint part_id, uchar *record) { +int ha_ctcpart::index_last_in_part(uint part_id, uchar *record) { if (part_id != m_last_part) { - ha_tse::reset_rec_buf(); + ha_ctc::reset_rec_buf(); } set_partition(part_id); - int ret = ha_tse::index_last(record); + int ret = ha_ctc::index_last(record); reset_partition(part_id); if (m_index_sorted) { cursor_set_bit(cursor_set, part_id); @@ -539,13 +539,13 @@ int ha_tsepart::index_last_in_part(uint part_id, uchar *record) { @param[out] record Last record in index in the partition. @return error number or 0. */ -int ha_tsepart::index_prev_in_part(uint part_id, uchar *record) { +int ha_ctcpart::index_prev_in_part(uint part_id, uchar *record) { if (m_index_sorted) { cursor_set_bit(cursor_set, part_id); m_tch.cursor_addr = cursors[part_id]; } set_partition(part_id); - int ret = ha_tse::index_prev(record); + int ret = ha_ctc::index_prev(record); reset_partition(part_id); return ret; } @@ -556,13 +556,13 @@ int ha_tsepart::index_prev_in_part(uint part_id, uchar *record) { @param[out] record Last record in index in the partition. @return error number or 0. */ -int ha_tsepart::index_next_in_part(uint part_id, uchar *record) { +int ha_ctcpart::index_next_in_part(uint part_id, uchar *record) { if (m_index_sorted) { cursor_set_bit(cursor_set, part_id); m_tch.cursor_addr = cursors[part_id]; } set_partition(part_id); - int ret = ha_tse::index_next(record); + int ret = ha_ctc::index_next(record); reset_partition(part_id); return ret; } @@ -577,13 +577,13 @@ int ha_tsepart::index_next_in_part(uint part_id, uchar *record) { @param[in] length Length of key. @return error number or 0. */ -int ha_tsepart::index_next_same_in_part(uint part_id, uchar *record, const uchar *key, uint length) { +int ha_ctcpart::index_next_same_in_part(uint part_id, uchar *record, const uchar *key, uint length) { if (m_index_sorted) { cursor_set_bit(cursor_set, part_id); m_tch.cursor_addr = cursors[part_id]; } set_partition(part_id); - int ret = ha_tse::index_next_same(record, key, length); + int ret = ha_ctc::index_next_same(record, key, length); reset_partition(part_id); return ret; } @@ -599,13 +599,13 @@ int ha_tsepart::index_next_same_in_part(uint part_id, uchar *record, const uchar @param[in] find_flag Key condition/direction to use. @return error number or 0. */ -int ha_tsepart::index_read_map_in_part(uint part_id, uchar *record, const uchar *key, +int ha_ctcpart::index_read_map_in_part(uint part_id, uchar *record, const uchar *key, key_part_map keypart_map, enum ha_rkey_function find_flag) { if (part_id != m_last_part) { - ha_tse::reset_rec_buf(); + ha_ctc::reset_rec_buf(); } set_partition(part_id); - int ret = ha_tse::index_read_map(record, key, keypart_map, find_flag); + int ret = ha_ctc::index_read_map(record, key, keypart_map, find_flag); reset_partition(part_id); if (m_index_sorted) { cursor_set_bit(cursor_set, part_id); @@ -622,13 +622,13 @@ int ha_tsepart::index_read_map_in_part(uint part_id, uchar *record, const uchar @param[in] keypart_map Which part of the key to use. @return error number or 0. */ -int ha_tsepart::index_read_last_map_in_part(uint part_id, uchar *record, const uchar *key, +int ha_ctcpart::index_read_last_map_in_part(uint part_id, uchar *record, const uchar *key, key_part_map keypart_map) { if (part_id != m_last_part) { - ha_tse::reset_rec_buf(); + ha_ctc::reset_rec_buf(); } set_partition(part_id); - int ret = ha_tse::index_read_last_map(record, key, keypart_map); + int ret = ha_ctc::index_read_last_map(record, key, keypart_map); reset_partition(part_id); if (m_index_sorted) { cursor_set_bit(cursor_set, part_id); @@ -649,16 +649,16 @@ int ha_tsepart::index_read_last_map_in_part(uint part_id, uchar *record, const u @param[in] find_flag Key condition/direction to use. @return error number or 0. */ -int ha_tsepart::index_read_idx_map_in_part(uint part_id, uchar *record, uint index, +int ha_ctcpart::index_read_idx_map_in_part(uint part_id, uchar *record, uint index, const uchar *key, key_part_map keypart_map, enum ha_rkey_function find_flag) { set_partition(part_id); - int ret = ha_tse::index_read_idx_map(record, index, key, keypart_map, find_flag); + int ret = ha_ctc::index_read_idx_map(record, index, key, keypart_map, find_flag); reset_partition(part_id); return ret; } -bool ha_tsepart::need_prune_partitions_by_engine(const key_range *start_key, const key_range *end_key) { +bool ha_ctcpart::need_prune_partitions_by_engine(const key_range *start_key, const key_range *end_key) { if (start_key == nullptr || end_key == nullptr) { return false; } @@ -682,7 +682,7 @@ bool ha_tsepart::need_prune_partitions_by_engine(const key_range *start_key, con return true; } -bool ha_tsepart::equal_range_on_part_field(const key_range *start_key, const key_range *end_key) { +bool ha_ctcpart::equal_range_on_part_field(const key_range *start_key, const key_range *end_key) { vector part_field_ids; for (uint i = 0; i num_columns; i++) { part_field_ids.push_back(m_part_info->part_field_array[i]->field_index()); @@ -722,7 +722,7 @@ bool ha_tsepart::equal_range_on_part_field(const key_range *start_key, const key @param[in] sorted Return rows in sorted order. @return error number or 0. */ -int ha_tsepart::read_range_first_in_part(uint part_id, uchar *record, +int ha_ctcpart::read_range_first_in_part(uint part_id, uchar *record, const key_range *start_key, const key_range *end_key, bool sorted) { UNUSED_PARAM(sorted); @@ -752,7 +752,7 @@ int ha_tsepart::read_range_first_in_part(uint part_id, uchar *record, int ret; if (part_id != m_last_part) { - ha_tse::reset_rec_buf(); + ha_ctc::reset_rec_buf(); } set_partition(part_id); @@ -760,7 +760,7 @@ int ha_tsepart::read_range_first_in_part(uint part_id, uchar *record, ret = index_read(read_record, m_start_key.key, m_start_key.length, m_start_key.flag); } else { - ret = ha_tse::index_first(read_record); + ret = ha_ctc::index_first(read_record); } if (ret == HA_ERR_KEY_NOT_FOUND) { ret = HA_ERR_END_OF_FILE; @@ -791,7 +791,7 @@ int ha_tsepart::read_range_first_in_part(uint part_id, uchar *record, if NULL use table->record[0] as return buffer. @return error number or 0. */ -int ha_tsepart::read_range_next_in_part(uint part_id, uchar *record) { +int ha_ctcpart::read_range_next_in_part(uint part_id, uchar *record) { uchar *read_record = record; if (read_record == nullptr) { read_record = table->record[0]; @@ -801,7 +801,7 @@ int ha_tsepart::read_range_next_in_part(uint part_id, uchar *record) { m_tch.cursor_addr = cursors[part_id]; } set_partition(part_id); - int ret = ha_tse::index_next(read_record); + int ret = ha_ctc::index_next(read_record); reset_partition(part_id); return ret; } @@ -812,46 +812,46 @@ int ha_tsepart::read_range_next_in_part(uint part_id, uchar *record) { @param[in] part_id Id of partition for which row type to be retrieved @return Partition row type. */ -enum row_type ha_tsepart::get_partition_row_type(const dd::Table *partition_table, uint part_id) { +enum row_type ha_ctcpart::get_partition_row_type(const dd::Table *partition_table, uint part_id) { UNUSED_PARAM(partition_table); UNUSED_PARAM(part_id); return ROW_TYPE_NOT_USED; } -void ha_tsepart::info_low() { +void ha_ctcpart::info_low() { stats.records = 0; if (m_part_share->cbo_stats != nullptr) { uint part_num = m_is_sub_partitioned ? table->part_info->num_parts * table->part_info->num_subparts : table->part_info->num_parts; for (uint part_id = m_part_info->get_first_used_partition(); part_id < part_num; part_id = m_part_info->get_next_used_partition(part_id)) { - stats.records += m_part_share->cbo_stats->tse_cbo_stats_table[part_id].estimate_rows; + stats.records += m_part_share->cbo_stats->ctc_cbo_stats_table[part_id].estimate_rows; } } } -int ha_tsepart::info(uint flag) { - return ha_tse::info(flag); +int ha_ctcpart::info(uint flag) { + return ha_ctc::info(flag); } -ha_rows ha_tsepart::records_in_range(uint inx, key_range *min_key, key_range *max_key) { +ha_rows ha_ctcpart::records_in_range(uint inx, key_range *min_key, key_range *max_key) { double density; if (m_part_share && !m_part_share->cbo_stats->is_updated) { - tse_log_debug("table %s has not been analyzed", table->alias); + ctc_log_debug("table %s has not been analyzed", table->alias); return 1; } - tse_key tse_min_key; - tse_key tse_max_key; - set_tse_range_key(&tse_min_key, min_key, true); - set_tse_range_key(&tse_max_key, max_key, false); - tse_range_key key = {&tse_min_key, &tse_max_key}; - if (tse_max_key.len < tse_min_key.len) { - tse_max_key.cmp_type = CMP_TYPE_NULL; - } else if (tse_max_key.len > tse_min_key.len) { - tse_min_key.cmp_type = CMP_TYPE_NULL; + ctc_key ctc_min_key; + ctc_key ctc_max_key; + set_ctc_range_key(&ctc_min_key, min_key, true); + set_ctc_range_key(&ctc_max_key, max_key, false); + ctc_range_key key = {&ctc_min_key, &ctc_max_key}; + if (ctc_max_key.len < ctc_min_key.len) { + ctc_max_key.cmp_type = CMP_TYPE_NULL; + } else if (ctc_max_key.len > ctc_min_key.len) { + ctc_min_key.cmp_type = CMP_TYPE_NULL; } uint64_t n_rows_num = 0; @@ -861,15 +861,15 @@ ha_rows ha_tsepart::records_in_range(uint inx, key_range *min_key, key_range *ma for (uint part_id = m_part_info->get_first_used_partition(); part_id < part_num; part_id = m_part_info->get_next_used_partition(part_id)) { - set_tse_range_key(&tse_min_key, min_key, true); - set_tse_range_key(&tse_max_key, max_key, false); - if (tse_max_key.len < tse_min_key.len) { - tse_max_key.cmp_type = CMP_TYPE_NULL; - } else if (tse_max_key.len > tse_min_key.len) { - tse_min_key.cmp_type = CMP_TYPE_NULL; + set_ctc_range_key(&ctc_min_key, min_key, true); + set_ctc_range_key(&ctc_max_key, max_key, false); + if (ctc_max_key.len < ctc_min_key.len) { + ctc_max_key.cmp_type = CMP_TYPE_NULL; + } else if (ctc_max_key.len > ctc_min_key.len) { + ctc_min_key.cmp_type = CMP_TYPE_NULL; } - density = calc_density_one_table(inx, &key, &m_part_share->cbo_stats->tse_cbo_stats_table[part_id], *table); - n_rows_num += m_part_share->cbo_stats->tse_cbo_stats_table[part_id].estimate_rows * density; + density = calc_density_one_table(inx, &key, &m_part_share->cbo_stats->ctc_cbo_stats_table[part_id], *table); + n_rows_num += m_part_share->cbo_stats->ctc_cbo_stats_table[part_id].estimate_rows * density; } /* @@ -882,7 +882,7 @@ for (uint part_id = m_part_info->get_first_used_partition(); part_id < part_num; return (ha_rows)n_rows_num; } -int ha_tsepart::records(ha_rows *num_rows) /*!< out: number of rows */ +int ha_ctcpart::records(ha_rows *num_rows) /*!< out: number of rows */ { *num_rows = 0; int ret; @@ -890,7 +890,7 @@ int ha_tsepart::records(ha_rows *num_rows) /*!< out: number of rows */ part_id = m_part_info->get_next_used_partition(part_id)) { set_partition(part_id); ha_rows n_rows{}; - ret = ha_tse::records(&n_rows); + ret = ha_ctc::records(&n_rows); reset_partition(part_id); if (ret != 0) { *num_rows = HA_POS_ERROR; @@ -903,13 +903,13 @@ int ha_tsepart::records(ha_rows *num_rows) /*!< out: number of rows */ extern uint32_t ctc_instance_id; /* alter table truncate partition */ -int ha_tsepart::truncate_partition_low(dd::Table *dd_table) { +int ha_ctcpart::truncate_partition_low(dd::Table *dd_table) { THD *thd = ha_thd(); if (engine_ddl_passthru(thd)) { return 0; } - tse_ddl_stack_mem stack_mem(0); + ctc_ddl_stack_mem stack_mem(0); update_member_tch(m_tch, ht, thd); ddl_ctrl_t ddl_ctrl = {{0}, {0}, {0}, 0, 0, m_tch, ctc_instance_id, false, 0}; FILL_USER_INFO_WITH_THD(ddl_ctrl, thd); @@ -917,20 +917,20 @@ int ha_tsepart::truncate_partition_low(dd::Table *dd_table) { table->s->normalized_path.str, m_part_info, dd_table, thd, &ddl_ctrl, &stack_mem); if (ret != 0) { - return convert_tse_error_code_to_mysql(ret); + return convert_ctc_error_code_to_mysql(ret); } - void *tse_ddl_req_msg_mem = stack_mem.get_buf(); - if (tse_ddl_req_msg_mem == nullptr) { + void *ctc_ddl_req_msg_mem = stack_mem.get_buf(); + if (ctc_ddl_req_msg_mem == nullptr) { return HA_ERR_OUT_OF_MEM; } - ret = (ct_errno_t)tse_truncate_partition(tse_ddl_req_msg_mem, &ddl_ctrl); - tse_ddl_hook_cantian_error("tse_truncate_partition_cantian_error", thd, &ddl_ctrl, &ret); + ret = (ct_errno_t)ctc_truncate_partition(ctc_ddl_req_msg_mem, &ddl_ctrl); + ctc_ddl_hook_cantian_error("ctc_truncate_partition_cantian_error", thd, &ddl_ctrl, &ret); m_tch = ddl_ctrl.tch; update_sess_ctx_by_tch(m_tch, ht, thd); - return tse_ddl_handle_fault("tse_truncate_partition", thd, &ddl_ctrl, ret); + return ctc_ddl_handle_fault("ctc_truncate_partition", thd, &ddl_ctrl, ret); } -int ha_tsepart::analyze(THD *thd, HA_CHECK_OPT *opt) { +int ha_ctcpart::analyze(THD *thd, HA_CHECK_OPT *opt) { if (engine_ddl_passthru(thd)) { m_part_share->need_fetch_cbo = true; return 0; @@ -940,7 +940,7 @@ int ha_tsepart::analyze(THD *thd, HA_CHECK_OPT *opt) { (alter_info->flags & Alter_info::ALTER_ALL_PARTITION)) { m_tch.part_id = INVALID_PART_ID; m_part_share->need_fetch_cbo = true; - return ha_tse::analyze(thd, opt); + return ha_ctc::analyze(thd, opt); } int ret; uint32_t used_parts; @@ -950,11 +950,11 @@ int ha_tsepart::analyze(THD *thd, HA_CHECK_OPT *opt) { if (!m_part_info->set_read_partitions(&alter_info->partition_names)) { memory_allocated = get_used_partitions(m_part_info, &part_ids, &subpart_ids, &used_parts); if(!memory_allocated){ - tse_log_error("Failed to allocate memory !"); + ctc_log_error("Failed to allocate memory !"); return HA_ERR_OUT_OF_MEM; } } else { - tse_log_error("no partition alter !"); + ctc_log_error("no partition alter !"); return HA_ERR_GENERIC; } if (m_part_info->num_parts == used_parts) { @@ -962,7 +962,7 @@ int ha_tsepart::analyze(THD *thd, HA_CHECK_OPT *opt) { my_free(part_ids); my_free(subpart_ids); m_part_share->need_fetch_cbo = true; - return ha_tse::analyze(thd, opt); + return ha_ctc::analyze(thd, opt); } for (uint i = 0; i < used_parts; i++) { uint32_t part_id = part_ids[i]; @@ -970,9 +970,9 @@ int ha_tsepart::analyze(THD *thd, HA_CHECK_OPT *opt) { m_tch.part_id = part_id; m_tch.subpart_id = subpart_id; m_part_share->need_fetch_cbo = true; - ret = ha_tse::analyze(thd, opt); + ret = ha_ctc::analyze(thd, opt); if (ret != 0) { - tse_log_error("analyze partition error!"); + ctc_log_error("analyze partition error!"); my_free(subpart_ids); my_free(part_ids); return ret; @@ -983,76 +983,76 @@ int ha_tsepart::analyze(THD *thd, HA_CHECK_OPT *opt) { return ret; } -int ha_tsepart::optimize(THD *thd, HA_CHECK_OPT *opt) { +int ha_ctcpart::optimize(THD *thd, HA_CHECK_OPT *opt) { int ret; m_tch.part_id = INVALID_PART_ID; - ret = ha_tse::analyze(thd, opt); + ret = ha_ctc::analyze(thd, opt); if (ret != 0) { - tse_log_error("analyze partition error!"); + ctc_log_error("analyze partition error!"); return ret; } m_part_share->need_fetch_cbo = true; - ret = ha_tse::optimize(thd, opt); + ret = ha_ctc::optimize(thd, opt); if (ret != 0) { - tse_log_error("optimize partition error!"); + ctc_log_error("optimize partition error!"); return ret; } return (HA_ADMIN_TRY_ALTER); } -int ha_tsepart::initialize_cbo_stats() { +int ha_ctcpart::initialize_cbo_stats() { if (m_part_share->cbo_stats != nullptr) { return CT_SUCCESS; } uint32_t part_num = m_is_sub_partitioned ? table->part_info->num_parts * table->part_info->num_subparts : table->part_info->num_parts; - m_part_share->cbo_stats = (tianchi_cbo_stats_t*)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(tianchi_cbo_stats_t), MYF(MY_WME)); + m_part_share->cbo_stats = (ctc_cbo_stats_t*)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(ctc_cbo_stats_t), MYF(MY_WME)); if (m_part_share->cbo_stats == nullptr) { - tse_log_error("alloc mem failed, m_part_share->cbo_stats size(%lu)", sizeof(tianchi_cbo_stats_t)); + ctc_log_error("alloc mem failed, m_part_share->cbo_stats size(%lu)", sizeof(ctc_cbo_stats_t)); return ERR_ALLOC_MEMORY; } *m_part_share->cbo_stats = {0, 0, 0, 0, 0, nullptr, 0, nullptr, nullptr}; m_part_share->cbo_stats->part_cnt = part_num; - m_part_share->cbo_stats->tse_cbo_stats_table = - (tse_cbo_stats_table_t*)my_malloc(PSI_NOT_INSTRUMENTED, part_num * sizeof(tse_cbo_stats_table_t), MYF(MY_WME)); - if (m_part_share->cbo_stats->tse_cbo_stats_table == nullptr) { - tse_log_error("alloc mem failed, m_part_share->cbo_stats->tse_cbo_stats_table size(%lu)", part_num * sizeof(tse_cbo_stats_table_t)); + m_part_share->cbo_stats->ctc_cbo_stats_table = + (ctc_cbo_stats_table_t*)my_malloc(PSI_NOT_INSTRUMENTED, part_num * sizeof(ctc_cbo_stats_table_t), MYF(MY_WME)); + if (m_part_share->cbo_stats->ctc_cbo_stats_table == nullptr) { + ctc_log_error("alloc mem failed, m_part_share->cbo_stats->ctc_cbo_stats_table size(%lu)", part_num * sizeof(ctc_cbo_stats_table_t)); return ERR_ALLOC_MEMORY; } m_part_share->cbo_stats->ndv_keys = (uint32_t*)my_malloc(PSI_NOT_INSTRUMENTED, table->s->keys * sizeof(uint32_t) * MAX_KEY_COLUMNS, MYF(MY_WME)); if (m_part_share->cbo_stats->ndv_keys == nullptr) { - tse_log_error("alloc mem failed, m_part_share->cbo_stats->ndv_keys size(%lu)", table->s->keys * sizeof(uint32_t) * MAX_KEY_COLUMNS); + ctc_log_error("alloc mem failed, m_part_share->cbo_stats->ndv_keys size(%lu)", table->s->keys * sizeof(uint32_t) * MAX_KEY_COLUMNS); return ERR_ALLOC_MEMORY; } for (uint i = 0; i < part_num; i++) { - m_part_share->cbo_stats->tse_cbo_stats_table[i].estimate_rows = 0; - m_part_share->cbo_stats->tse_cbo_stats_table[i].columns = - (tse_cbo_stats_column_t*)my_malloc(PSI_NOT_INSTRUMENTED, table->s->fields * sizeof(tse_cbo_stats_column_t), MYF(MY_WME)); - if (m_part_share->cbo_stats->tse_cbo_stats_table[i].columns == nullptr) { - tse_log_error("alloc mem failed, m_part_share->cbo_stats->tse_cbo_stats_table size(%lu)", table->s->fields * sizeof(tse_cbo_stats_column_t)); + m_part_share->cbo_stats->ctc_cbo_stats_table[i].estimate_rows = 0; + m_part_share->cbo_stats->ctc_cbo_stats_table[i].columns = + (ctc_cbo_stats_column_t*)my_malloc(PSI_NOT_INSTRUMENTED, table->s->fields * sizeof(ctc_cbo_stats_column_t), MYF(MY_WME)); + if (m_part_share->cbo_stats->ctc_cbo_stats_table[i].columns == nullptr) { + ctc_log_error("alloc mem failed, m_part_share->cbo_stats->ctc_cbo_stats_table size(%lu)", table->s->fields * sizeof(ctc_cbo_stats_column_t)); return ERR_ALLOC_MEMORY; } for (uint col_id = 0; col_id < table->s->fields; col_id++) { - m_part_share->cbo_stats->tse_cbo_stats_table[i].columns[col_id].hist_count = 0; + m_part_share->cbo_stats->ctc_cbo_stats_table[i].columns[col_id].hist_count = 0; } } ct_errno_t ret = (ct_errno_t)alloc_str_mysql_mem(m_part_share->cbo_stats, part_num, table); if (ret != CT_SUCCESS) { - tse_log_error("m_part_share:tse alloc str mysql mem failed, ret:%d", ret); + ctc_log_error("m_part_share:ctc alloc str mysql mem failed, ret:%d", ret); } - m_part_share->cbo_stats->msg_len = table->s->fields * sizeof(tse_cbo_stats_column_t); + m_part_share->cbo_stats->msg_len = table->s->fields * sizeof(ctc_cbo_stats_column_t); m_part_share->cbo_stats->key_len = table->s->keys * sizeof(uint32_t) * MAX_KEY_COLUMNS; return CT_SUCCESS; } -int ha_tsepart::get_cbo_stats_4share() +int ha_ctcpart::get_cbo_stats_4share() { THD *thd = ha_thd(); int ret = CT_SUCCESS; @@ -1060,11 +1060,11 @@ int ha_tsepart::get_cbo_stats_4share() if (m_part_share->need_fetch_cbo || now - m_part_share->get_cbo_time > ctc_update_analyze_time) { if (m_tch.ctx_addr == INVALID_VALUE64) { char user_name[SMALL_RECORD_SIZE] = { 0 }; - tse_split_normalized_name(table->s->normalized_path.str, user_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); - tse_copy_name(user_name, user_name, SMALL_RECORD_SIZE); - update_member_tch(m_tch, get_tse_hton(), thd); - ret = tse_open_table(&m_tch, table->s->table_name.str, user_name); - update_sess_ctx_by_tch(m_tch, get_tse_hton(), thd); + ctc_split_normalized_name(table->s->normalized_path.str, user_name, SMALL_RECORD_SIZE, nullptr, 0, nullptr); + ctc_copy_name(user_name, user_name, SMALL_RECORD_SIZE); + update_member_tch(m_tch, get_ctc_hton(), thd); + ret = ctc_open_table(&m_tch, table->s->table_name.str, user_name); + update_sess_ctx_by_tch(m_tch, get_ctc_hton(), thd); if (ret != CT_SUCCESS) { return ret; } @@ -1078,9 +1078,9 @@ int ha_tsepart::get_cbo_stats_4share() uint32_t first_partid = 0; for (uint32_t i = 0; i < fetch_times; i++) { - update_member_tch(m_tch, get_tse_hton(), thd); - ret = tse_get_cbo_stats(&m_tch, m_part_share->cbo_stats, &m_part_share->cbo_stats->tse_cbo_stats_table[first_partid], first_partid, num_part_fetch); - update_sess_ctx_by_tch(m_tch, get_tse_hton(), thd); + update_member_tch(m_tch, get_ctc_hton(), thd); + ret = ctc_get_cbo_stats(&m_tch, m_part_share->cbo_stats, &m_part_share->cbo_stats->ctc_cbo_stats_table[first_partid], first_partid, num_part_fetch); + update_sess_ctx_by_tch(m_tch, get_ctc_hton(), thd); if (ret != CT_SUCCESS) { return ret; } @@ -1089,14 +1089,14 @@ int ha_tsepart::get_cbo_stats_4share() num_part_fetch = part_cnt - first_partid; if (num_part_fetch > 0) { - update_member_tch(m_tch, get_tse_hton(), thd); - ret = tse_get_cbo_stats(&m_tch, m_part_share->cbo_stats, &m_part_share->cbo_stats->tse_cbo_stats_table[first_partid], first_partid, num_part_fetch); - update_sess_ctx_by_tch(m_tch, get_tse_hton(), thd); + update_member_tch(m_tch, get_ctc_hton(), thd); + ret = ctc_get_cbo_stats(&m_tch, m_part_share->cbo_stats, &m_part_share->cbo_stats->ctc_cbo_stats_table[first_partid], first_partid, num_part_fetch); + update_sess_ctx_by_tch(m_tch, get_ctc_hton(), thd); } if (ret == CT_SUCCESS && m_part_share->cbo_stats->is_updated) { m_part_share->need_fetch_cbo = false; - tse_index_stats_update(table, m_part_share->cbo_stats); + ctc_index_stats_update(table, m_part_share->cbo_stats); } m_part_share->get_cbo_time = now; } @@ -1104,7 +1104,7 @@ int ha_tsepart::get_cbo_stats_4share() return ret; } -void ha_tsepart::free_cbo_stats() { +void ha_ctcpart::free_cbo_stats() { if (m_part_share->cbo_stats == nullptr) { return; } @@ -1113,58 +1113,58 @@ void ha_tsepart::free_cbo_stats() { bool is_str_first_addr = true; for (uint i = 0; i < part_num; i++) { - free_columns_cbo_stats(m_part_share->cbo_stats->tse_cbo_stats_table[i].columns, &is_str_first_addr, table); + free_columns_cbo_stats(m_part_share->cbo_stats->ctc_cbo_stats_table[i].columns, &is_str_first_addr, table); } my_free((m_part_share->cbo_stats->ndv_keys)); m_part_share->cbo_stats->ndv_keys = nullptr; my_free((m_part_share->cbo_stats->col_type)); m_part_share->cbo_stats->col_type = nullptr; - my_free(m_part_share->cbo_stats->tse_cbo_stats_table); - m_part_share->cbo_stats->tse_cbo_stats_table = nullptr; + my_free(m_part_share->cbo_stats->ctc_cbo_stats_table); + m_part_share->cbo_stats->ctc_cbo_stats_table = nullptr; my_free(m_part_share->cbo_stats); m_part_share->cbo_stats = nullptr; } -int ha_tsepart::check(THD *, HA_CHECK_OPT *) +int ha_ctcpart::check(THD *, HA_CHECK_OPT *) { return HA_ADMIN_OK; } -int ha_tsepart::repair(THD *thd, HA_CHECK_OPT *) +int ha_ctcpart::repair(THD *thd, HA_CHECK_OPT *) { if (engine_ddl_passthru(thd)) { return HA_ADMIN_OK; } - tianchi_handler_t tch; - TSE_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(get_tse_hton(), thd, tch)); - tse_ddl_broadcast_request broadcast_req {{0}, {0}, {0}, {0}, 0, 0, 0, 0, {0}}; + ctc_handler_t tch; + CTC_RETURN_IF_NOT_ZERO(get_tch_in_handler_data(get_ctc_hton(), thd, tch)); + ctc_ddl_broadcast_request broadcast_req {{0}, {0}, {0}, {0}, 0, 0, 0, 0, {0}}; string sql = string(thd->query().str).substr(0, thd->query().length); FILL_BROADCAST_BASE_REQ(broadcast_req, sql.c_str(), thd->m_main_security_ctx.priv_user().str, thd->m_main_security_ctx.priv_host().str, ctc_instance_id, thd->lex->sql_command); if (thd->db().str != NULL && thd->db().length > 0) { strncpy(broadcast_req.db_name, thd->db().str, SMALL_RECORD_SIZE - 1); } - broadcast_req.options |= TSE_NOT_NEED_CANTIAN_EXECUTE; + broadcast_req.options |= CTC_NOT_NEED_CANTIAN_EXECUTE; ct_errno_t ret = CT_SUCCESS; if (IS_METADATA_NORMALIZATION()) { ret = (ct_errno_t)ctc_record_sql_for_cantian(&tch, &broadcast_req, false); assert (ret == CT_SUCCESS); } else { - ret = (ct_errno_t)tse_execute_mysql_ddl_sql(&tch, &broadcast_req, false); + ret = (ct_errno_t)ctc_execute_mysql_ddl_sql(&tch, &broadcast_req, false); assert (ret == CT_SUCCESS); } return (int)ret; } -uint32 ha_tsepart::calculate_key_hash_value(Field **field_array) +uint32 ha_ctcpart::calculate_key_hash_value(Field **field_array) { return (Partition_helper::ph_calculate_key_hash_value(field_array)); } -bool ha_tsepart::check_unsupported_indexdir(dd::Table *table_def) { +bool ha_ctcpart::check_unsupported_indexdir(dd::Table *table_def) { for (const auto dd_part : *table_def->leaf_partitions()) { dd::String_type index_file_name; if (dd_part == nullptr){ @@ -1182,13 +1182,13 @@ bool ha_tsepart::check_unsupported_indexdir(dd::Table *table_def) { return false; } -EXTER_ATTACK int ha_tsepart::create(const char *name, TABLE *form, HA_CREATE_INFO *create_info, +EXTER_ATTACK int ha_ctcpart::create(const char *name, TABLE *form, HA_CREATE_INFO *create_info, dd::Table *table_def) { THD *thd = ha_thd(); if (table_def != nullptr && check_unsupported_indexdir(table_def)) { - tse_log_system("Unsupported operation. sql = %s", thd->query().str); + ctc_log_system("Unsupported operation. sql = %s", thd->query().str); return HA_ERR_WRONG_COMMAND; } - return ha_tse::create(name, form, create_info, table_def); + return ha_ctc::create(name, form, create_info, table_def); } diff --git a/storage/tianchi/ha_tsepart.h b/storage/ctc/ha_ctcpart.h similarity index 96% rename from storage/tianchi/ha_tsepart.h rename to storage/ctc/ha_ctcpart.h index 8c7b372..79caa88 100644 --- a/storage/tianchi/ha_tsepart.h +++ b/storage/ctc/ha_ctcpart.h @@ -15,21 +15,21 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -/* class for the the tse part table handler */ +/* class for the the ctc part table handler */ -#ifndef __HA_TSEPART_H__ -#define __HA_TSEPART_H__ +#ifndef __HA_CTCPART_H__ +#define __HA_CTCPART_H__ -#include "ha_tse.h" -#include "tse_srv.h" -#include "tse_util.h" +#include "ha_ctc.h" +#include "ctc_srv.h" +#include "ctc_util.h" #include "sql/partitioning/partition_handler.h" #include "sql/dd/string_type.h" -class Tsepart_share : public Partition_share { +class Ctcpart_share : public Partition_share { public: //std::vector table_records; - tianchi_cbo_stats_t *cbo_stats = nullptr; + ctc_cbo_stats_t *cbo_stats = nullptr; int used_count = 0; bool need_fetch_cbo = false; time_t get_cbo_time = 0; @@ -39,11 +39,11 @@ class Tsepart_share : public Partition_share { /** @brief Class definition for the storage engine */ -class ha_tsepart : public ha_tse, +class ha_ctcpart : public ha_ctc, public Partition_helper, public Partition_handler { public: - ha_tsepart(handlerton *hton, TABLE_SHARE *table_arg); + ha_ctcpart(handlerton *hton, TABLE_SHARE *table_arg); handler *get_handler() override { return (static_cast(this)); } @@ -68,7 +68,7 @@ class ha_tsepart : public ha_tse, bool check_unsupported_indexdir(dd::Table *table_def); /** Write a row in specific partition. - Stores a row in an TSE database, to the table specified in this + Stores a row in an CTC database, to the table specified in this handle. @param[in] part_id Partition to write to. @param[in] record A row in MySQL format. @@ -213,7 +213,7 @@ class ha_tsepart : public ha_tse, const uchar *key, key_part_map keypart_map, enum ha_rkey_function find_flag) override; - /** Open an TSE table. + /** Open an CTC table. @param[in] name table name @param[in] mode access mode @param[in] test_if_locked test if the file to be opened is locked @@ -331,7 +331,7 @@ class ha_tsepart : public ha_tse, } ulonglong table_flags() const override { - return (ha_tse::table_flags() | HA_CAN_REPAIR); + return (ha_ctc::table_flags() | HA_CAN_REPAIR); } THD *get_thd() const override { return ha_thd(); } @@ -421,8 +421,8 @@ class ha_tsepart : public ha_tse, // store partitions for bulk insert ctc_part_t *m_bulk_insert_parts; - /** Pointer to Tsepart_share on the TABLE_SHARE. */ - Tsepart_share *m_part_share; + /** Pointer to Ctcpart_share on the TABLE_SHARE. */ + Ctcpart_share *m_part_share; bool autoinc_has_expl_non_null_value = false; bool autoinc_has_expl_non_null_value_update_row = false; @@ -442,4 +442,4 @@ static inline void cursor_clear_bit(int *cursor_set, uint bit) { (cursor_set)[bit / 8] &= ~(1 << (bit & 7)); } -#endif /* ha_tsepart_h */ +#endif /* ha_ctcpart_h */ diff --git a/storage/tianchi/message_queue/dsw_list.h b/storage/ctc/message_queue/dsw_list.h similarity index 100% rename from storage/tianchi/message_queue/dsw_list.h rename to storage/ctc/message_queue/dsw_list.h diff --git a/storage/tianchi/message_queue/dsw_message.h b/storage/ctc/message_queue/dsw_message.h similarity index 100% rename from storage/tianchi/message_queue/dsw_message.h rename to storage/ctc/message_queue/dsw_message.h diff --git a/storage/tianchi/message_queue/dsw_shm.h b/storage/ctc/message_queue/dsw_shm.h similarity index 100% rename from storage/tianchi/message_queue/dsw_shm.h rename to storage/ctc/message_queue/dsw_shm.h diff --git a/storage/tianchi/message_queue/dsw_typedef.h b/storage/ctc/message_queue/dsw_typedef.h similarity index 100% rename from storage/tianchi/message_queue/dsw_typedef.h rename to storage/ctc/message_queue/dsw_typedef.h diff --git a/storage/tianchi/mysql_daac_plugin.cc b/storage/ctc/mysql_daac_plugin.cc similarity index 86% rename from storage/tianchi/mysql_daac_plugin.cc rename to storage/ctc/mysql_daac_plugin.cc index 1b20f4c..8b3fc11 100644 --- a/storage/tianchi/mysql_daac_plugin.cc +++ b/storage/ctc/mysql_daac_plugin.cc @@ -37,8 +37,8 @@ #include "mysql/psi/mysql_memory.h" #include "sql/sql_plugin.h" // st_plugin_int #include "sql/sql_initialize.h" // opt_initialize_insecure -#include "tse_log.h" -#include "ha_tse.h" +#include "ctc_log.h" +#include "ha_ctc.h" #include "decimal_convert.h" struct mysql_daac_context { @@ -71,7 +71,7 @@ static std::string get_cantiand_home_dir() { if (tmp_home_dir != NULL && strlen(tmp_home_dir) > 0) { home_dir = tmp_home_dir; } - tse_log_system("get cantiand home_dir:%s", home_dir.c_str()); + ctc_log_system("get cantiand home_dir:%s", home_dir.c_str()); return home_dir; } @@ -79,7 +79,7 @@ static void *mysql_daac_startup_thread(void *p) { DBUG_TRACE; struct mysql_daac_context *con = (struct mysql_daac_context *)p; if(con->daac_startup_thread.thread == 0) { - tse_log_error("please create the nomont thread first!"); + ctc_log_error("please create the nomont thread first!"); return nullptr; } @@ -95,7 +95,7 @@ static void *mysql_daac_startup_thread(void *p) { home_dir.c_str()}; ret = cantiand_lib_main(3, const_cast(argv)); } - tse_log_system("init daac mode:%s,home_dir:%s, ret:%d", mode.c_str(), + ctc_log_system("init daac mode:%s,home_dir:%s, ret:%d", mode.c_str(), home_dir.c_str(), ret); return nullptr; } @@ -108,20 +108,20 @@ int daemon_daac_plugin_init() { // but single process needs to start up cantian thread in both meat and nometa when initializing if (!is_single_run_mode()) { if (opt_initialize_insecure) { - tse_log_warning("initialize-insecure mode no need start the daac startup thread."); + ctc_log_warning("initialize-insecure mode no need start the daac startup thread."); return 0; } const char *se_name = "ctc_ddl_rewriter"; const LEX_CSTRING name = {se_name, strlen(se_name)}; if (!plugin_is_ready(name, MYSQL_AUDIT_PLUGIN)) { - tse_log_error("tse_ddl_rewriter plugin install failed."); + ctc_log_error("ctc_ddl_rewriter plugin install failed."); return -1; } } if (daac_context != NULL) { - tse_log_error("daemon_daac_plugin_init daac_context:%p not NULL", daac_context); + ctc_log_error("daemon_daac_plugin_init daac_context:%p not NULL", daac_context); return 0; } @@ -129,7 +129,7 @@ int daemon_daac_plugin_init() { PSI_NOT_INSTRUMENTED, sizeof(struct mysql_daac_context), MYF(0)); if (daac_context == nullptr) { - tse_log_error("alloc mem failed, daac_context size(%lu)", sizeof(struct mysql_daac_context)); + ctc_log_error("alloc mem failed, daac_context size(%lu)", sizeof(struct mysql_daac_context)); return -1; } my_thread_attr_t startup_attr; /* Thread attributes */ @@ -138,7 +138,7 @@ int daemon_daac_plugin_init() { /* now create the startup thread */ if (my_thread_create(&daac_context->daac_startup_thread, &startup_attr, mysql_daac_startup_thread, (void *)daac_context) != 0) { - tse_log_error("Could not create daac startup thread!"); + ctc_log_error("Could not create daac startup thread!"); return -1; } return 0; @@ -149,7 +149,7 @@ int daemon_daac_plugin_deinit() { void *dummy_retval; if (daac_context == nullptr || daac_context->daac_startup_thread.thread == 0) { - tse_log_system("startup thread not started"); + ctc_log_system("startup thread not started"); return 0; } @@ -160,5 +160,5 @@ int daemon_daac_plugin_deinit() { return 0; } -int (*tse_init)() = daemon_daac_plugin_init; -int (*tse_deinit)() = daemon_daac_plugin_deinit; +int (*ctc_init)() = daemon_daac_plugin_init; +int (*ctc_deinit)() = daemon_daac_plugin_deinit; diff --git a/storage/tianchi/protobuf/tc_db.pb-c.c b/storage/ctc/protobuf/tc_db.pb-c.c similarity index 57% rename from storage/tianchi/protobuf/tc_db.pb-c.c rename to storage/ctc/protobuf/tc_db.pb-c.c index 5faadfa..2857a04 100644 --- a/storage/tianchi/protobuf/tc_db.pb-c.c +++ b/storage/ctc/protobuf/tc_db.pb-c.c @@ -7,1132 +7,1132 @@ #endif #include "tc_db.pb-c.h" -void tc_db__tse_ddlcolumn_data_type_def__init - (TcDb__TseDDLColumnDataTypeDef *message) +void tc_db__ctc_ddlcolumn_data_type_def__init + (TcDb__CtcDDLColumnDataTypeDef *message) { - static const TcDb__TseDDLColumnDataTypeDef init_value = TC_DB__TSE_DDLCOLUMN_DATA_TYPE_DEF__INIT; + static const TcDb__CtcDDLColumnDataTypeDef init_value = TC_DB__CTC_DDLCOLUMN_DATA_TYPE_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddlcolumn_data_type_def__get_packed_size - (const TcDb__TseDDLColumnDataTypeDef *message) +size_t tc_db__ctc_ddlcolumn_data_type_def__get_packed_size + (const TcDb__CtcDDLColumnDataTypeDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddlcolumn_data_type_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlcolumn_data_type_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddlcolumn_data_type_def__pack - (const TcDb__TseDDLColumnDataTypeDef *message, +size_t tc_db__ctc_ddlcolumn_data_type_def__pack + (const TcDb__CtcDDLColumnDataTypeDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddlcolumn_data_type_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlcolumn_data_type_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddlcolumn_data_type_def__pack_to_buffer - (const TcDb__TseDDLColumnDataTypeDef *message, +size_t tc_db__ctc_ddlcolumn_data_type_def__pack_to_buffer + (const TcDb__CtcDDLColumnDataTypeDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddlcolumn_data_type_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlcolumn_data_type_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLColumnDataTypeDef * - tc_db__tse_ddlcolumn_data_type_def__unpack +TcDb__CtcDDLColumnDataTypeDef * + tc_db__ctc_ddlcolumn_data_type_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLColumnDataTypeDef *) - protobuf_c_message_unpack (&tc_db__tse_ddlcolumn_data_type_def__descriptor, + return (TcDb__CtcDDLColumnDataTypeDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddlcolumn_data_type_def__descriptor, allocator, len, data); } -void tc_db__tse_ddlcolumn_data_type_def__free_unpacked - (TcDb__TseDDLColumnDataTypeDef *message, +void tc_db__ctc_ddlcolumn_data_type_def__free_unpacked + (TcDb__CtcDDLColumnDataTypeDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddlcolumn_data_type_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlcolumn_data_type_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddlcolumn_def__init - (TcDb__TseDDLColumnDef *message) +void tc_db__ctc_ddlcolumn_def__init + (TcDb__CtcDDLColumnDef *message) { - static const TcDb__TseDDLColumnDef init_value = TC_DB__TSE_DDLCOLUMN_DEF__INIT; + static const TcDb__CtcDDLColumnDef init_value = TC_DB__CTC_DDLCOLUMN_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddlcolumn_def__get_packed_size - (const TcDb__TseDDLColumnDef *message) +size_t tc_db__ctc_ddlcolumn_def__get_packed_size + (const TcDb__CtcDDLColumnDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddlcolumn_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlcolumn_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddlcolumn_def__pack - (const TcDb__TseDDLColumnDef *message, +size_t tc_db__ctc_ddlcolumn_def__pack + (const TcDb__CtcDDLColumnDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddlcolumn_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlcolumn_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddlcolumn_def__pack_to_buffer - (const TcDb__TseDDLColumnDef *message, +size_t tc_db__ctc_ddlcolumn_def__pack_to_buffer + (const TcDb__CtcDDLColumnDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddlcolumn_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlcolumn_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLColumnDef * - tc_db__tse_ddlcolumn_def__unpack +TcDb__CtcDDLColumnDef * + tc_db__ctc_ddlcolumn_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLColumnDef *) - protobuf_c_message_unpack (&tc_db__tse_ddlcolumn_def__descriptor, + return (TcDb__CtcDDLColumnDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddlcolumn_def__descriptor, allocator, len, data); } -void tc_db__tse_ddlcolumn_def__free_unpacked - (TcDb__TseDDLColumnDef *message, +void tc_db__ctc_ddlcolumn_def__free_unpacked + (TcDb__CtcDDLColumnDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddlcolumn_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlcolumn_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddlforeign_key_element_def__init - (TcDb__TseDDLForeignKeyElementDef *message) +void tc_db__ctc_ddlforeign_key_element_def__init + (TcDb__CtcDDLForeignKeyElementDef *message) { - static const TcDb__TseDDLForeignKeyElementDef init_value = TC_DB__TSE_DDLFOREIGN_KEY_ELEMENT_DEF__INIT; + static const TcDb__CtcDDLForeignKeyElementDef init_value = TC_DB__CTC_DDLFOREIGN_KEY_ELEMENT_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddlforeign_key_element_def__get_packed_size - (const TcDb__TseDDLForeignKeyElementDef *message) +size_t tc_db__ctc_ddlforeign_key_element_def__get_packed_size + (const TcDb__CtcDDLForeignKeyElementDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddlforeign_key_element_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlforeign_key_element_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddlforeign_key_element_def__pack - (const TcDb__TseDDLForeignKeyElementDef *message, +size_t tc_db__ctc_ddlforeign_key_element_def__pack + (const TcDb__CtcDDLForeignKeyElementDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddlforeign_key_element_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlforeign_key_element_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddlforeign_key_element_def__pack_to_buffer - (const TcDb__TseDDLForeignKeyElementDef *message, +size_t tc_db__ctc_ddlforeign_key_element_def__pack_to_buffer + (const TcDb__CtcDDLForeignKeyElementDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddlforeign_key_element_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlforeign_key_element_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLForeignKeyElementDef * - tc_db__tse_ddlforeign_key_element_def__unpack +TcDb__CtcDDLForeignKeyElementDef * + tc_db__ctc_ddlforeign_key_element_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLForeignKeyElementDef *) - protobuf_c_message_unpack (&tc_db__tse_ddlforeign_key_element_def__descriptor, + return (TcDb__CtcDDLForeignKeyElementDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddlforeign_key_element_def__descriptor, allocator, len, data); } -void tc_db__tse_ddlforeign_key_element_def__free_unpacked - (TcDb__TseDDLForeignKeyElementDef *message, +void tc_db__ctc_ddlforeign_key_element_def__free_unpacked + (TcDb__CtcDDLForeignKeyElementDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddlforeign_key_element_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlforeign_key_element_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddlforeign_key_def__init - (TcDb__TseDDLForeignKeyDef *message) +void tc_db__ctc_ddlforeign_key_def__init + (TcDb__CtcDDLForeignKeyDef *message) { - static const TcDb__TseDDLForeignKeyDef init_value = TC_DB__TSE_DDLFOREIGN_KEY_DEF__INIT; + static const TcDb__CtcDDLForeignKeyDef init_value = TC_DB__CTC_DDLFOREIGN_KEY_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddlforeign_key_def__get_packed_size - (const TcDb__TseDDLForeignKeyDef *message) +size_t tc_db__ctc_ddlforeign_key_def__get_packed_size + (const TcDb__CtcDDLForeignKeyDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddlforeign_key_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlforeign_key_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddlforeign_key_def__pack - (const TcDb__TseDDLForeignKeyDef *message, +size_t tc_db__ctc_ddlforeign_key_def__pack + (const TcDb__CtcDDLForeignKeyDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddlforeign_key_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlforeign_key_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddlforeign_key_def__pack_to_buffer - (const TcDb__TseDDLForeignKeyDef *message, +size_t tc_db__ctc_ddlforeign_key_def__pack_to_buffer + (const TcDb__CtcDDLForeignKeyDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddlforeign_key_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlforeign_key_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLForeignKeyDef * - tc_db__tse_ddlforeign_key_def__unpack +TcDb__CtcDDLForeignKeyDef * + tc_db__ctc_ddlforeign_key_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLForeignKeyDef *) - protobuf_c_message_unpack (&tc_db__tse_ddlforeign_key_def__descriptor, + return (TcDb__CtcDDLForeignKeyDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddlforeign_key_def__descriptor, allocator, len, data); } -void tc_db__tse_ddlforeign_key_def__free_unpacked - (TcDb__TseDDLForeignKeyDef *message, +void tc_db__ctc_ddlforeign_key_def__free_unpacked + (TcDb__CtcDDLForeignKeyDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddlforeign_key_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlforeign_key_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddltable_key_part__init - (TcDb__TseDDLTableKeyPart *message) +void tc_db__ctc_ddltable_key_part__init + (TcDb__CtcDDLTableKeyPart *message) { - static const TcDb__TseDDLTableKeyPart init_value = TC_DB__TSE_DDLTABLE_KEY_PART__INIT; + static const TcDb__CtcDDLTableKeyPart init_value = TC_DB__CTC_DDLTABLE_KEY_PART__INIT; *message = init_value; } -size_t tc_db__tse_ddltable_key_part__get_packed_size - (const TcDb__TseDDLTableKeyPart *message) +size_t tc_db__ctc_ddltable_key_part__get_packed_size + (const TcDb__CtcDDLTableKeyPart *message) { - assert(message->base.descriptor == &tc_db__tse_ddltable_key_part__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddltable_key_part__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddltable_key_part__pack - (const TcDb__TseDDLTableKeyPart *message, +size_t tc_db__ctc_ddltable_key_part__pack + (const TcDb__CtcDDLTableKeyPart *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddltable_key_part__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddltable_key_part__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddltable_key_part__pack_to_buffer - (const TcDb__TseDDLTableKeyPart *message, +size_t tc_db__ctc_ddltable_key_part__pack_to_buffer + (const TcDb__CtcDDLTableKeyPart *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddltable_key_part__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddltable_key_part__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLTableKeyPart * - tc_db__tse_ddltable_key_part__unpack +TcDb__CtcDDLTableKeyPart * + tc_db__ctc_ddltable_key_part__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLTableKeyPart *) - protobuf_c_message_unpack (&tc_db__tse_ddltable_key_part__descriptor, + return (TcDb__CtcDDLTableKeyPart *) + protobuf_c_message_unpack (&tc_db__ctc_ddltable_key_part__descriptor, allocator, len, data); } -void tc_db__tse_ddltable_key_part__free_unpacked - (TcDb__TseDDLTableKeyPart *message, +void tc_db__ctc_ddltable_key_part__free_unpacked + (TcDb__CtcDDLTableKeyPart *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddltable_key_part__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddltable_key_part__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddltable_key__init - (TcDb__TseDDLTableKey *message) +void tc_db__ctc_ddltable_key__init + (TcDb__CtcDDLTableKey *message) { - static const TcDb__TseDDLTableKey init_value = TC_DB__TSE_DDLTABLE_KEY__INIT; + static const TcDb__CtcDDLTableKey init_value = TC_DB__CTC_DDLTABLE_KEY__INIT; *message = init_value; } -size_t tc_db__tse_ddltable_key__get_packed_size - (const TcDb__TseDDLTableKey *message) +size_t tc_db__ctc_ddltable_key__get_packed_size + (const TcDb__CtcDDLTableKey *message) { - assert(message->base.descriptor == &tc_db__tse_ddltable_key__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddltable_key__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddltable_key__pack - (const TcDb__TseDDLTableKey *message, +size_t tc_db__ctc_ddltable_key__pack + (const TcDb__CtcDDLTableKey *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddltable_key__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddltable_key__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddltable_key__pack_to_buffer - (const TcDb__TseDDLTableKey *message, +size_t tc_db__ctc_ddltable_key__pack_to_buffer + (const TcDb__CtcDDLTableKey *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddltable_key__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddltable_key__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLTableKey * - tc_db__tse_ddltable_key__unpack +TcDb__CtcDDLTableKey * + tc_db__ctc_ddltable_key__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLTableKey *) - protobuf_c_message_unpack (&tc_db__tse_ddltable_key__descriptor, + return (TcDb__CtcDDLTableKey *) + protobuf_c_message_unpack (&tc_db__ctc_ddltable_key__descriptor, allocator, len, data); } -void tc_db__tse_ddltable_key__free_unpacked - (TcDb__TseDDLTableKey *message, +void tc_db__ctc_ddltable_key__free_unpacked + (TcDb__CtcDDLTableKey *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddltable_key__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddltable_key__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_msg_comm_def__init - (TcDb__TseMsgCommDef *message) +void tc_db__ctc_msg_comm_def__init + (TcDb__CtcMsgCommDef *message) { - static const TcDb__TseMsgCommDef init_value = TC_DB__TSE_MSG_COMM_DEF__INIT; + static const TcDb__CtcMsgCommDef init_value = TC_DB__CTC_MSG_COMM_DEF__INIT; *message = init_value; } -size_t tc_db__tse_msg_comm_def__get_packed_size - (const TcDb__TseMsgCommDef *message) +size_t tc_db__ctc_msg_comm_def__get_packed_size + (const TcDb__CtcMsgCommDef *message) { - assert(message->base.descriptor == &tc_db__tse_msg_comm_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_msg_comm_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_msg_comm_def__pack - (const TcDb__TseMsgCommDef *message, +size_t tc_db__ctc_msg_comm_def__pack + (const TcDb__CtcMsgCommDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_msg_comm_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_msg_comm_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_msg_comm_def__pack_to_buffer - (const TcDb__TseMsgCommDef *message, +size_t tc_db__ctc_msg_comm_def__pack_to_buffer + (const TcDb__CtcMsgCommDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_msg_comm_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_msg_comm_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseMsgCommDef * - tc_db__tse_msg_comm_def__unpack +TcDb__CtcMsgCommDef * + tc_db__ctc_msg_comm_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseMsgCommDef *) - protobuf_c_message_unpack (&tc_db__tse_msg_comm_def__descriptor, + return (TcDb__CtcMsgCommDef *) + protobuf_c_message_unpack (&tc_db__ctc_msg_comm_def__descriptor, allocator, len, data); } -void tc_db__tse_msg_comm_def__free_unpacked - (TcDb__TseMsgCommDef *message, +void tc_db__ctc_msg_comm_def__free_unpacked + (TcDb__CtcMsgCommDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_msg_comm_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_msg_comm_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddlpartition_table_def__init - (TcDb__TseDDLPartitionTableDef *message) +void tc_db__ctc_ddlpartition_table_def__init + (TcDb__CtcDDLPartitionTableDef *message) { - static const TcDb__TseDDLPartitionTableDef init_value = TC_DB__TSE_DDLPARTITION_TABLE_DEF__INIT; + static const TcDb__CtcDDLPartitionTableDef init_value = TC_DB__CTC_DDLPARTITION_TABLE_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddlpartition_table_def__get_packed_size - (const TcDb__TseDDLPartitionTableDef *message) +size_t tc_db__ctc_ddlpartition_table_def__get_packed_size + (const TcDb__CtcDDLPartitionTableDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddlpartition_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlpartition_table_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddlpartition_table_def__pack - (const TcDb__TseDDLPartitionTableDef *message, +size_t tc_db__ctc_ddlpartition_table_def__pack + (const TcDb__CtcDDLPartitionTableDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddlpartition_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlpartition_table_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddlpartition_table_def__pack_to_buffer - (const TcDb__TseDDLPartitionTableDef *message, +size_t tc_db__ctc_ddlpartition_table_def__pack_to_buffer + (const TcDb__CtcDDLPartitionTableDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddlpartition_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlpartition_table_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLPartitionTableDef * - tc_db__tse_ddlpartition_table_def__unpack +TcDb__CtcDDLPartitionTableDef * + tc_db__ctc_ddlpartition_table_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLPartitionTableDef *) - protobuf_c_message_unpack (&tc_db__tse_ddlpartition_table_def__descriptor, + return (TcDb__CtcDDLPartitionTableDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddlpartition_table_def__descriptor, allocator, len, data); } -void tc_db__tse_ddlpartition_table_def__free_unpacked - (TcDb__TseDDLPartitionTableDef *message, +void tc_db__ctc_ddlpartition_table_def__free_unpacked + (TcDb__CtcDDLPartitionTableDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddlpartition_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlpartition_table_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddlpartition_def__init - (TcDb__TseDDLPartitionDef *message) +void tc_db__ctc_ddlpartition_def__init + (TcDb__CtcDDLPartitionDef *message) { - static const TcDb__TseDDLPartitionDef init_value = TC_DB__TSE_DDLPARTITION_DEF__INIT; + static const TcDb__CtcDDLPartitionDef init_value = TC_DB__CTC_DDLPARTITION_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddlpartition_def__get_packed_size - (const TcDb__TseDDLPartitionDef *message) +size_t tc_db__ctc_ddlpartition_def__get_packed_size + (const TcDb__CtcDDLPartitionDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddlpartition_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlpartition_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddlpartition_def__pack - (const TcDb__TseDDLPartitionDef *message, +size_t tc_db__ctc_ddlpartition_def__pack + (const TcDb__CtcDDLPartitionDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddlpartition_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlpartition_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddlpartition_def__pack_to_buffer - (const TcDb__TseDDLPartitionDef *message, +size_t tc_db__ctc_ddlpartition_def__pack_to_buffer + (const TcDb__CtcDDLPartitionDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddlpartition_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlpartition_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLPartitionDef * - tc_db__tse_ddlpartition_def__unpack +TcDb__CtcDDLPartitionDef * + tc_db__ctc_ddlpartition_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLPartitionDef *) - protobuf_c_message_unpack (&tc_db__tse_ddlpartition_def__descriptor, + return (TcDb__CtcDDLPartitionDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddlpartition_def__descriptor, allocator, len, data); } -void tc_db__tse_ddlpartition_def__free_unpacked - (TcDb__TseDDLPartitionDef *message, +void tc_db__ctc_ddlpartition_def__free_unpacked + (TcDb__CtcDDLPartitionDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddlpartition_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlpartition_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddlcreate_table_def__init - (TcDb__TseDDLCreateTableDef *message) +void tc_db__ctc_ddlcreate_table_def__init + (TcDb__CtcDDLCreateTableDef *message) { - static const TcDb__TseDDLCreateTableDef init_value = TC_DB__TSE_DDLCREATE_TABLE_DEF__INIT; + static const TcDb__CtcDDLCreateTableDef init_value = TC_DB__CTC_DDLCREATE_TABLE_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddlcreate_table_def__get_packed_size - (const TcDb__TseDDLCreateTableDef *message) +size_t tc_db__ctc_ddlcreate_table_def__get_packed_size + (const TcDb__CtcDDLCreateTableDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddlcreate_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlcreate_table_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddlcreate_table_def__pack - (const TcDb__TseDDLCreateTableDef *message, +size_t tc_db__ctc_ddlcreate_table_def__pack + (const TcDb__CtcDDLCreateTableDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddlcreate_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlcreate_table_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddlcreate_table_def__pack_to_buffer - (const TcDb__TseDDLCreateTableDef *message, +size_t tc_db__ctc_ddlcreate_table_def__pack_to_buffer + (const TcDb__CtcDDLCreateTableDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddlcreate_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlcreate_table_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLCreateTableDef * - tc_db__tse_ddlcreate_table_def__unpack +TcDb__CtcDDLCreateTableDef * + tc_db__ctc_ddlcreate_table_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLCreateTableDef *) - protobuf_c_message_unpack (&tc_db__tse_ddlcreate_table_def__descriptor, + return (TcDb__CtcDDLCreateTableDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddlcreate_table_def__descriptor, allocator, len, data); } -void tc_db__tse_ddlcreate_table_def__free_unpacked - (TcDb__TseDDLCreateTableDef *message, +void tc_db__ctc_ddlcreate_table_def__free_unpacked + (TcDb__CtcDDLCreateTableDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddlcreate_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlcreate_table_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddlalter_table_porp__init - (TcDb__TseDDLAlterTablePorp *message) +void tc_db__ctc_ddlalter_table_porp__init + (TcDb__CtcDDLAlterTablePorp *message) { - static const TcDb__TseDDLAlterTablePorp init_value = TC_DB__TSE_DDLALTER_TABLE_PORP__INIT; + static const TcDb__CtcDDLAlterTablePorp init_value = TC_DB__CTC_DDLALTER_TABLE_PORP__INIT; *message = init_value; } -size_t tc_db__tse_ddlalter_table_porp__get_packed_size - (const TcDb__TseDDLAlterTablePorp *message) +size_t tc_db__ctc_ddlalter_table_porp__get_packed_size + (const TcDb__CtcDDLAlterTablePorp *message) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_porp__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_porp__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddlalter_table_porp__pack - (const TcDb__TseDDLAlterTablePorp *message, +size_t tc_db__ctc_ddlalter_table_porp__pack + (const TcDb__CtcDDLAlterTablePorp *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_porp__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_porp__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddlalter_table_porp__pack_to_buffer - (const TcDb__TseDDLAlterTablePorp *message, +size_t tc_db__ctc_ddlalter_table_porp__pack_to_buffer + (const TcDb__CtcDDLAlterTablePorp *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_porp__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_porp__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLAlterTablePorp * - tc_db__tse_ddlalter_table_porp__unpack +TcDb__CtcDDLAlterTablePorp * + tc_db__ctc_ddlalter_table_porp__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLAlterTablePorp *) - protobuf_c_message_unpack (&tc_db__tse_ddlalter_table_porp__descriptor, + return (TcDb__CtcDDLAlterTablePorp *) + protobuf_c_message_unpack (&tc_db__ctc_ddlalter_table_porp__descriptor, allocator, len, data); } -void tc_db__tse_ddlalter_table_porp__free_unpacked - (TcDb__TseDDLAlterTablePorp *message, +void tc_db__ctc_ddlalter_table_porp__free_unpacked + (TcDb__CtcDDLAlterTablePorp *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_porp__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_porp__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddlalter_table_drop__init - (TcDb__TseDDLAlterTableDrop *message) +void tc_db__ctc_ddlalter_table_drop__init + (TcDb__CtcDDLAlterTableDrop *message) { - static const TcDb__TseDDLAlterTableDrop init_value = TC_DB__TSE_DDLALTER_TABLE_DROP__INIT; + static const TcDb__CtcDDLAlterTableDrop init_value = TC_DB__CTC_DDLALTER_TABLE_DROP__INIT; *message = init_value; } -size_t tc_db__tse_ddlalter_table_drop__get_packed_size - (const TcDb__TseDDLAlterTableDrop *message) +size_t tc_db__ctc_ddlalter_table_drop__get_packed_size + (const TcDb__CtcDDLAlterTableDrop *message) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_drop__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_drop__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddlalter_table_drop__pack - (const TcDb__TseDDLAlterTableDrop *message, +size_t tc_db__ctc_ddlalter_table_drop__pack + (const TcDb__CtcDDLAlterTableDrop *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_drop__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_drop__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddlalter_table_drop__pack_to_buffer - (const TcDb__TseDDLAlterTableDrop *message, +size_t tc_db__ctc_ddlalter_table_drop__pack_to_buffer + (const TcDb__CtcDDLAlterTableDrop *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_drop__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_drop__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLAlterTableDrop * - tc_db__tse_ddlalter_table_drop__unpack +TcDb__CtcDDLAlterTableDrop * + tc_db__ctc_ddlalter_table_drop__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLAlterTableDrop *) - protobuf_c_message_unpack (&tc_db__tse_ddlalter_table_drop__descriptor, + return (TcDb__CtcDDLAlterTableDrop *) + protobuf_c_message_unpack (&tc_db__ctc_ddlalter_table_drop__descriptor, allocator, len, data); } -void tc_db__tse_ddlalter_table_drop__free_unpacked - (TcDb__TseDDLAlterTableDrop *message, +void tc_db__ctc_ddlalter_table_drop__free_unpacked + (TcDb__CtcDDLAlterTableDrop *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_drop__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_drop__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddlalter_table_drop_key__init - (TcDb__TseDDLAlterTableDropKey *message) +void tc_db__ctc_ddlalter_table_drop_key__init + (TcDb__CtcDDLAlterTableDropKey *message) { - static const TcDb__TseDDLAlterTableDropKey init_value = TC_DB__TSE_DDLALTER_TABLE_DROP_KEY__INIT; + static const TcDb__CtcDDLAlterTableDropKey init_value = TC_DB__CTC_DDLALTER_TABLE_DROP_KEY__INIT; *message = init_value; } -size_t tc_db__tse_ddlalter_table_drop_key__get_packed_size - (const TcDb__TseDDLAlterTableDropKey *message) +size_t tc_db__ctc_ddlalter_table_drop_key__get_packed_size + (const TcDb__CtcDDLAlterTableDropKey *message) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_drop_key__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_drop_key__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddlalter_table_drop_key__pack - (const TcDb__TseDDLAlterTableDropKey *message, +size_t tc_db__ctc_ddlalter_table_drop_key__pack + (const TcDb__CtcDDLAlterTableDropKey *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_drop_key__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_drop_key__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddlalter_table_drop_key__pack_to_buffer - (const TcDb__TseDDLAlterTableDropKey *message, +size_t tc_db__ctc_ddlalter_table_drop_key__pack_to_buffer + (const TcDb__CtcDDLAlterTableDropKey *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_drop_key__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_drop_key__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLAlterTableDropKey * - tc_db__tse_ddlalter_table_drop_key__unpack +TcDb__CtcDDLAlterTableDropKey * + tc_db__ctc_ddlalter_table_drop_key__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLAlterTableDropKey *) - protobuf_c_message_unpack (&tc_db__tse_ddlalter_table_drop_key__descriptor, + return (TcDb__CtcDDLAlterTableDropKey *) + protobuf_c_message_unpack (&tc_db__ctc_ddlalter_table_drop_key__descriptor, allocator, len, data); } -void tc_db__tse_ddlalter_table_drop_key__free_unpacked - (TcDb__TseDDLAlterTableDropKey *message, +void tc_db__ctc_ddlalter_table_drop_key__free_unpacked + (TcDb__CtcDDLAlterTableDropKey *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_drop_key__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_drop_key__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddlalter_table_alter_column__init - (TcDb__TseDDLAlterTableAlterColumn *message) +void tc_db__ctc_ddlalter_table_alter_column__init + (TcDb__CtcDDLAlterTableAlterColumn *message) { - static const TcDb__TseDDLAlterTableAlterColumn init_value = TC_DB__TSE_DDLALTER_TABLE_ALTER_COLUMN__INIT; + static const TcDb__CtcDDLAlterTableAlterColumn init_value = TC_DB__CTC_DDLALTER_TABLE_ALTER_COLUMN__INIT; *message = init_value; } -size_t tc_db__tse_ddlalter_table_alter_column__get_packed_size - (const TcDb__TseDDLAlterTableAlterColumn *message) +size_t tc_db__ctc_ddlalter_table_alter_column__get_packed_size + (const TcDb__CtcDDLAlterTableAlterColumn *message) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_alter_column__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_alter_column__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddlalter_table_alter_column__pack - (const TcDb__TseDDLAlterTableAlterColumn *message, +size_t tc_db__ctc_ddlalter_table_alter_column__pack + (const TcDb__CtcDDLAlterTableAlterColumn *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_alter_column__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_alter_column__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddlalter_table_alter_column__pack_to_buffer - (const TcDb__TseDDLAlterTableAlterColumn *message, +size_t tc_db__ctc_ddlalter_table_alter_column__pack_to_buffer + (const TcDb__CtcDDLAlterTableAlterColumn *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_alter_column__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_alter_column__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLAlterTableAlterColumn * - tc_db__tse_ddlalter_table_alter_column__unpack +TcDb__CtcDDLAlterTableAlterColumn * + tc_db__ctc_ddlalter_table_alter_column__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLAlterTableAlterColumn *) - protobuf_c_message_unpack (&tc_db__tse_ddlalter_table_alter_column__descriptor, + return (TcDb__CtcDDLAlterTableAlterColumn *) + protobuf_c_message_unpack (&tc_db__ctc_ddlalter_table_alter_column__descriptor, allocator, len, data); } -void tc_db__tse_ddlalter_table_alter_column__free_unpacked - (TcDb__TseDDLAlterTableAlterColumn *message, +void tc_db__ctc_ddlalter_table_alter_column__free_unpacked + (TcDb__CtcDDLAlterTableAlterColumn *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_alter_column__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_alter_column__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddlalter_table_def__init - (TcDb__TseDDLAlterTableDef *message) +void tc_db__ctc_ddlalter_table_def__init + (TcDb__CtcDDLAlterTableDef *message) { - static const TcDb__TseDDLAlterTableDef init_value = TC_DB__TSE_DDLALTER_TABLE_DEF__INIT; + static const TcDb__CtcDDLAlterTableDef init_value = TC_DB__CTC_DDLALTER_TABLE_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddlalter_table_def__get_packed_size - (const TcDb__TseDDLAlterTableDef *message) +size_t tc_db__ctc_ddlalter_table_def__get_packed_size + (const TcDb__CtcDDLAlterTableDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddlalter_table_def__pack - (const TcDb__TseDDLAlterTableDef *message, +size_t tc_db__ctc_ddlalter_table_def__pack + (const TcDb__CtcDDLAlterTableDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddlalter_table_def__pack_to_buffer - (const TcDb__TseDDLAlterTableDef *message, +size_t tc_db__ctc_ddlalter_table_def__pack_to_buffer + (const TcDb__CtcDDLAlterTableDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLAlterTableDef * - tc_db__tse_ddlalter_table_def__unpack +TcDb__CtcDDLAlterTableDef * + tc_db__ctc_ddlalter_table_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLAlterTableDef *) - protobuf_c_message_unpack (&tc_db__tse_ddlalter_table_def__descriptor, + return (TcDb__CtcDDLAlterTableDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddlalter_table_def__descriptor, allocator, len, data); } -void tc_db__tse_ddlalter_table_def__free_unpacked - (TcDb__TseDDLAlterTableDef *message, +void tc_db__ctc_ddlalter_table_def__free_unpacked + (TcDb__CtcDDLAlterTableDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddlalter_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_table_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddltruncate_table_def__init - (TcDb__TseDDLTruncateTableDef *message) +void tc_db__ctc_ddltruncate_table_def__init + (TcDb__CtcDDLTruncateTableDef *message) { - static const TcDb__TseDDLTruncateTableDef init_value = TC_DB__TSE_DDLTRUNCATE_TABLE_DEF__INIT; + static const TcDb__CtcDDLTruncateTableDef init_value = TC_DB__CTC_DDLTRUNCATE_TABLE_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddltruncate_table_def__get_packed_size - (const TcDb__TseDDLTruncateTableDef *message) +size_t tc_db__ctc_ddltruncate_table_def__get_packed_size + (const TcDb__CtcDDLTruncateTableDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddltruncate_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddltruncate_table_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddltruncate_table_def__pack - (const TcDb__TseDDLTruncateTableDef *message, +size_t tc_db__ctc_ddltruncate_table_def__pack + (const TcDb__CtcDDLTruncateTableDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddltruncate_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddltruncate_table_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddltruncate_table_def__pack_to_buffer - (const TcDb__TseDDLTruncateTableDef *message, +size_t tc_db__ctc_ddltruncate_table_def__pack_to_buffer + (const TcDb__CtcDDLTruncateTableDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddltruncate_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddltruncate_table_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLTruncateTableDef * - tc_db__tse_ddltruncate_table_def__unpack +TcDb__CtcDDLTruncateTableDef * + tc_db__ctc_ddltruncate_table_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLTruncateTableDef *) - protobuf_c_message_unpack (&tc_db__tse_ddltruncate_table_def__descriptor, + return (TcDb__CtcDDLTruncateTableDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddltruncate_table_def__descriptor, allocator, len, data); } -void tc_db__tse_ddltruncate_table_def__free_unpacked - (TcDb__TseDDLTruncateTableDef *message, +void tc_db__ctc_ddltruncate_table_def__free_unpacked + (TcDb__CtcDDLTruncateTableDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddltruncate_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddltruncate_table_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddltruncate_table_partition_def__init - (TcDb__TseDDLTruncateTablePartitionDef *message) +void tc_db__ctc_ddltruncate_table_partition_def__init + (TcDb__CtcDDLTruncateTablePartitionDef *message) { - static const TcDb__TseDDLTruncateTablePartitionDef init_value = TC_DB__TSE_DDLTRUNCATE_TABLE_PARTITION_DEF__INIT; + static const TcDb__CtcDDLTruncateTablePartitionDef init_value = TC_DB__CTC_DDLTRUNCATE_TABLE_PARTITION_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddltruncate_table_partition_def__get_packed_size - (const TcDb__TseDDLTruncateTablePartitionDef *message) +size_t tc_db__ctc_ddltruncate_table_partition_def__get_packed_size + (const TcDb__CtcDDLTruncateTablePartitionDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddltruncate_table_partition_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddltruncate_table_partition_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddltruncate_table_partition_def__pack - (const TcDb__TseDDLTruncateTablePartitionDef *message, +size_t tc_db__ctc_ddltruncate_table_partition_def__pack + (const TcDb__CtcDDLTruncateTablePartitionDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddltruncate_table_partition_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddltruncate_table_partition_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddltruncate_table_partition_def__pack_to_buffer - (const TcDb__TseDDLTruncateTablePartitionDef *message, +size_t tc_db__ctc_ddltruncate_table_partition_def__pack_to_buffer + (const TcDb__CtcDDLTruncateTablePartitionDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddltruncate_table_partition_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddltruncate_table_partition_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLTruncateTablePartitionDef * - tc_db__tse_ddltruncate_table_partition_def__unpack +TcDb__CtcDDLTruncateTablePartitionDef * + tc_db__ctc_ddltruncate_table_partition_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLTruncateTablePartitionDef *) - protobuf_c_message_unpack (&tc_db__tse_ddltruncate_table_partition_def__descriptor, + return (TcDb__CtcDDLTruncateTablePartitionDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddltruncate_table_partition_def__descriptor, allocator, len, data); } -void tc_db__tse_ddltruncate_table_partition_def__free_unpacked - (TcDb__TseDDLTruncateTablePartitionDef *message, +void tc_db__ctc_ddltruncate_table_partition_def__free_unpacked + (TcDb__CtcDDLTruncateTablePartitionDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddltruncate_table_partition_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddltruncate_table_partition_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddlrename_table_def__init - (TcDb__TseDDLRenameTableDef *message) +void tc_db__ctc_ddlrename_table_def__init + (TcDb__CtcDDLRenameTableDef *message) { - static const TcDb__TseDDLRenameTableDef init_value = TC_DB__TSE_DDLRENAME_TABLE_DEF__INIT; + static const TcDb__CtcDDLRenameTableDef init_value = TC_DB__CTC_DDLRENAME_TABLE_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddlrename_table_def__get_packed_size - (const TcDb__TseDDLRenameTableDef *message) +size_t tc_db__ctc_ddlrename_table_def__get_packed_size + (const TcDb__CtcDDLRenameTableDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddlrename_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlrename_table_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddlrename_table_def__pack - (const TcDb__TseDDLRenameTableDef *message, +size_t tc_db__ctc_ddlrename_table_def__pack + (const TcDb__CtcDDLRenameTableDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddlrename_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlrename_table_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddlrename_table_def__pack_to_buffer - (const TcDb__TseDDLRenameTableDef *message, +size_t tc_db__ctc_ddlrename_table_def__pack_to_buffer + (const TcDb__CtcDDLRenameTableDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddlrename_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlrename_table_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLRenameTableDef * - tc_db__tse_ddlrename_table_def__unpack +TcDb__CtcDDLRenameTableDef * + tc_db__ctc_ddlrename_table_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLRenameTableDef *) - protobuf_c_message_unpack (&tc_db__tse_ddlrename_table_def__descriptor, + return (TcDb__CtcDDLRenameTableDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddlrename_table_def__descriptor, allocator, len, data); } -void tc_db__tse_ddlrename_table_def__free_unpacked - (TcDb__TseDDLRenameTableDef *message, +void tc_db__ctc_ddlrename_table_def__free_unpacked + (TcDb__CtcDDLRenameTableDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddlrename_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlrename_table_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddldrop_table_def__init - (TcDb__TseDDLDropTableDef *message) +void tc_db__ctc_ddldrop_table_def__init + (TcDb__CtcDDLDropTableDef *message) { - static const TcDb__TseDDLDropTableDef init_value = TC_DB__TSE_DDLDROP_TABLE_DEF__INIT; + static const TcDb__CtcDDLDropTableDef init_value = TC_DB__CTC_DDLDROP_TABLE_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddldrop_table_def__get_packed_size - (const TcDb__TseDDLDropTableDef *message) +size_t tc_db__ctc_ddldrop_table_def__get_packed_size + (const TcDb__CtcDDLDropTableDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddldrop_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddldrop_table_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddldrop_table_def__pack - (const TcDb__TseDDLDropTableDef *message, +size_t tc_db__ctc_ddldrop_table_def__pack + (const TcDb__CtcDDLDropTableDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddldrop_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddldrop_table_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddldrop_table_def__pack_to_buffer - (const TcDb__TseDDLDropTableDef *message, +size_t tc_db__ctc_ddldrop_table_def__pack_to_buffer + (const TcDb__CtcDDLDropTableDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddldrop_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddldrop_table_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLDropTableDef * - tc_db__tse_ddldrop_table_def__unpack +TcDb__CtcDDLDropTableDef * + tc_db__ctc_ddldrop_table_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLDropTableDef *) - protobuf_c_message_unpack (&tc_db__tse_ddldrop_table_def__descriptor, + return (TcDb__CtcDDLDropTableDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddldrop_table_def__descriptor, allocator, len, data); } -void tc_db__tse_ddldrop_table_def__free_unpacked - (TcDb__TseDDLDropTableDef *message, +void tc_db__ctc_ddldrop_table_def__free_unpacked + (TcDb__CtcDDLDropTableDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddldrop_table_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddldrop_table_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddlalter_index_def__init - (TcDb__TseDDLAlterIndexDef *message) +void tc_db__ctc_ddlalter_index_def__init + (TcDb__CtcDDLAlterIndexDef *message) { - static const TcDb__TseDDLAlterIndexDef init_value = TC_DB__TSE_DDLALTER_INDEX_DEF__INIT; + static const TcDb__CtcDDLAlterIndexDef init_value = TC_DB__CTC_DDLALTER_INDEX_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddlalter_index_def__get_packed_size - (const TcDb__TseDDLAlterIndexDef *message) +size_t tc_db__ctc_ddlalter_index_def__get_packed_size + (const TcDb__CtcDDLAlterIndexDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_index_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_index_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddlalter_index_def__pack - (const TcDb__TseDDLAlterIndexDef *message, +size_t tc_db__ctc_ddlalter_index_def__pack + (const TcDb__CtcDDLAlterIndexDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_index_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_index_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddlalter_index_def__pack_to_buffer - (const TcDb__TseDDLAlterIndexDef *message, +size_t tc_db__ctc_ddlalter_index_def__pack_to_buffer + (const TcDb__CtcDDLAlterIndexDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_index_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_index_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLAlterIndexDef * - tc_db__tse_ddlalter_index_def__unpack +TcDb__CtcDDLAlterIndexDef * + tc_db__ctc_ddlalter_index_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLAlterIndexDef *) - protobuf_c_message_unpack (&tc_db__tse_ddlalter_index_def__descriptor, + return (TcDb__CtcDDLAlterIndexDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddlalter_index_def__descriptor, allocator, len, data); } -void tc_db__tse_ddlalter_index_def__free_unpacked - (TcDb__TseDDLAlterIndexDef *message, +void tc_db__ctc_ddlalter_index_def__free_unpacked + (TcDb__CtcDDLAlterIndexDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddlalter_index_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_index_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddlauto_extend_def__init - (TcDb__TseDDLAutoExtendDef *message) +void tc_db__ctc_ddlauto_extend_def__init + (TcDb__CtcDDLAutoExtendDef *message) { - static const TcDb__TseDDLAutoExtendDef init_value = TC_DB__TSE_DDLAUTO_EXTEND_DEF__INIT; + static const TcDb__CtcDDLAutoExtendDef init_value = TC_DB__CTC_DDLAUTO_EXTEND_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddlauto_extend_def__get_packed_size - (const TcDb__TseDDLAutoExtendDef *message) +size_t tc_db__ctc_ddlauto_extend_def__get_packed_size + (const TcDb__CtcDDLAutoExtendDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddlauto_extend_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlauto_extend_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddlauto_extend_def__pack - (const TcDb__TseDDLAutoExtendDef *message, +size_t tc_db__ctc_ddlauto_extend_def__pack + (const TcDb__CtcDDLAutoExtendDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddlauto_extend_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlauto_extend_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddlauto_extend_def__pack_to_buffer - (const TcDb__TseDDLAutoExtendDef *message, +size_t tc_db__ctc_ddlauto_extend_def__pack_to_buffer + (const TcDb__CtcDDLAutoExtendDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddlauto_extend_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlauto_extend_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLAutoExtendDef * - tc_db__tse_ddlauto_extend_def__unpack +TcDb__CtcDDLAutoExtendDef * + tc_db__ctc_ddlauto_extend_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLAutoExtendDef *) - protobuf_c_message_unpack (&tc_db__tse_ddlauto_extend_def__descriptor, + return (TcDb__CtcDDLAutoExtendDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddlauto_extend_def__descriptor, allocator, len, data); } -void tc_db__tse_ddlauto_extend_def__free_unpacked - (TcDb__TseDDLAutoExtendDef *message, +void tc_db__ctc_ddlauto_extend_def__free_unpacked + (TcDb__CtcDDLAutoExtendDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddlauto_extend_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlauto_extend_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddldata_file_def__init - (TcDb__TseDDLDataFileDef *message) +void tc_db__ctc_ddldata_file_def__init + (TcDb__CtcDDLDataFileDef *message) { - static const TcDb__TseDDLDataFileDef init_value = TC_DB__TSE_DDLDATA_FILE_DEF__INIT; + static const TcDb__CtcDDLDataFileDef init_value = TC_DB__CTC_DDLDATA_FILE_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddldata_file_def__get_packed_size - (const TcDb__TseDDLDataFileDef *message) +size_t tc_db__ctc_ddldata_file_def__get_packed_size + (const TcDb__CtcDDLDataFileDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddldata_file_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddldata_file_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddldata_file_def__pack - (const TcDb__TseDDLDataFileDef *message, +size_t tc_db__ctc_ddldata_file_def__pack + (const TcDb__CtcDDLDataFileDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddldata_file_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddldata_file_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddldata_file_def__pack_to_buffer - (const TcDb__TseDDLDataFileDef *message, +size_t tc_db__ctc_ddldata_file_def__pack_to_buffer + (const TcDb__CtcDDLDataFileDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddldata_file_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddldata_file_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLDataFileDef * - tc_db__tse_ddldata_file_def__unpack +TcDb__CtcDDLDataFileDef * + tc_db__ctc_ddldata_file_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLDataFileDef *) - protobuf_c_message_unpack (&tc_db__tse_ddldata_file_def__descriptor, + return (TcDb__CtcDDLDataFileDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddldata_file_def__descriptor, allocator, len, data); } -void tc_db__tse_ddldata_file_def__free_unpacked - (TcDb__TseDDLDataFileDef *message, +void tc_db__ctc_ddldata_file_def__free_unpacked + (TcDb__CtcDDLDataFileDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddldata_file_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddldata_file_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddlspace_def__init - (TcDb__TseDDLSpaceDef *message) +void tc_db__ctc_ddlspace_def__init + (TcDb__CtcDDLSpaceDef *message) { - static const TcDb__TseDDLSpaceDef init_value = TC_DB__TSE_DDLSPACE_DEF__INIT; + static const TcDb__CtcDDLSpaceDef init_value = TC_DB__CTC_DDLSPACE_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddlspace_def__get_packed_size - (const TcDb__TseDDLSpaceDef *message) +size_t tc_db__ctc_ddlspace_def__get_packed_size + (const TcDb__CtcDDLSpaceDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddlspace_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlspace_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddlspace_def__pack - (const TcDb__TseDDLSpaceDef *message, +size_t tc_db__ctc_ddlspace_def__pack + (const TcDb__CtcDDLSpaceDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddlspace_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlspace_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddlspace_def__pack_to_buffer - (const TcDb__TseDDLSpaceDef *message, +size_t tc_db__ctc_ddlspace_def__pack_to_buffer + (const TcDb__CtcDDLSpaceDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddlspace_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlspace_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLSpaceDef * - tc_db__tse_ddlspace_def__unpack +TcDb__CtcDDLSpaceDef * + tc_db__ctc_ddlspace_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLSpaceDef *) - protobuf_c_message_unpack (&tc_db__tse_ddlspace_def__descriptor, + return (TcDb__CtcDDLSpaceDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddlspace_def__descriptor, allocator, len, data); } -void tc_db__tse_ddlspace_def__free_unpacked - (TcDb__TseDDLSpaceDef *message, +void tc_db__ctc_ddlspace_def__free_unpacked + (TcDb__CtcDDLSpaceDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddlspace_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlspace_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddldrop_space_def__init - (TcDb__TseDDLDropSpaceDef *message) +void tc_db__ctc_ddldrop_space_def__init + (TcDb__CtcDDLDropSpaceDef *message) { - static const TcDb__TseDDLDropSpaceDef init_value = TC_DB__TSE_DDLDROP_SPACE_DEF__INIT; + static const TcDb__CtcDDLDropSpaceDef init_value = TC_DB__CTC_DDLDROP_SPACE_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddldrop_space_def__get_packed_size - (const TcDb__TseDDLDropSpaceDef *message) +size_t tc_db__ctc_ddldrop_space_def__get_packed_size + (const TcDb__CtcDDLDropSpaceDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddldrop_space_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddldrop_space_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddldrop_space_def__pack - (const TcDb__TseDDLDropSpaceDef *message, +size_t tc_db__ctc_ddldrop_space_def__pack + (const TcDb__CtcDDLDropSpaceDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddldrop_space_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddldrop_space_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddldrop_space_def__pack_to_buffer - (const TcDb__TseDDLDropSpaceDef *message, +size_t tc_db__ctc_ddldrop_space_def__pack_to_buffer + (const TcDb__CtcDDLDropSpaceDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddldrop_space_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddldrop_space_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLDropSpaceDef * - tc_db__tse_ddldrop_space_def__unpack +TcDb__CtcDDLDropSpaceDef * + tc_db__ctc_ddldrop_space_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLDropSpaceDef *) - protobuf_c_message_unpack (&tc_db__tse_ddldrop_space_def__descriptor, + return (TcDb__CtcDDLDropSpaceDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddldrop_space_def__descriptor, allocator, len, data); } -void tc_db__tse_ddldrop_space_def__free_unpacked - (TcDb__TseDDLDropSpaceDef *message, +void tc_db__ctc_ddldrop_space_def__free_unpacked + (TcDb__CtcDDLDropSpaceDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddldrop_space_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddldrop_space_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -void tc_db__tse_ddlalter_space_def__init - (TcDb__TseDDLAlterSpaceDef *message) +void tc_db__ctc_ddlalter_space_def__init + (TcDb__CtcDDLAlterSpaceDef *message) { - static const TcDb__TseDDLAlterSpaceDef init_value = TC_DB__TSE_DDLALTER_SPACE_DEF__INIT; + static const TcDb__CtcDDLAlterSpaceDef init_value = TC_DB__CTC_DDLALTER_SPACE_DEF__INIT; *message = init_value; } -size_t tc_db__tse_ddlalter_space_def__get_packed_size - (const TcDb__TseDDLAlterSpaceDef *message) +size_t tc_db__ctc_ddlalter_space_def__get_packed_size + (const TcDb__CtcDDLAlterSpaceDef *message) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_space_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_space_def__descriptor); return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); } -size_t tc_db__tse_ddlalter_space_def__pack - (const TcDb__TseDDLAlterSpaceDef *message, +size_t tc_db__ctc_ddlalter_space_def__pack + (const TcDb__CtcDDLAlterSpaceDef *message, uint8_t *out) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_space_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_space_def__descriptor); return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); } -size_t tc_db__tse_ddlalter_space_def__pack_to_buffer - (const TcDb__TseDDLAlterSpaceDef *message, +size_t tc_db__ctc_ddlalter_space_def__pack_to_buffer + (const TcDb__CtcDDLAlterSpaceDef *message, ProtobufCBuffer *buffer) { - assert(message->base.descriptor == &tc_db__tse_ddlalter_space_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_space_def__descriptor); return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); } -TcDb__TseDDLAlterSpaceDef * - tc_db__tse_ddlalter_space_def__unpack +TcDb__CtcDDLAlterSpaceDef * + tc_db__ctc_ddlalter_space_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data) { - return (TcDb__TseDDLAlterSpaceDef *) - protobuf_c_message_unpack (&tc_db__tse_ddlalter_space_def__descriptor, + return (TcDb__CtcDDLAlterSpaceDef *) + protobuf_c_message_unpack (&tc_db__ctc_ddlalter_space_def__descriptor, allocator, len, data); } -void tc_db__tse_ddlalter_space_def__free_unpacked - (TcDb__TseDDLAlterSpaceDef *message, +void tc_db__ctc_ddlalter_space_def__free_unpacked + (TcDb__CtcDDLAlterSpaceDef *message, ProtobufCAllocator *allocator) { if(!message) return; - assert(message->base.descriptor == &tc_db__tse_ddlalter_space_def__descriptor); + assert(message->base.descriptor == &tc_db__ctc_ddlalter_space_def__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } -static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_data_type_def__field_descriptors[5] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddlcolumn_data_type_def__field_descriptors[5] = { { "datatype", @@ -1140,7 +1140,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_data_type_def__field_ PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDataTypeDef, datatype), + offsetof(TcDb__CtcDDLColumnDataTypeDef, datatype), NULL, NULL, 0, /* flags */ @@ -1152,7 +1152,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_data_type_def__field_ PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDataTypeDef, size), + offsetof(TcDb__CtcDDLColumnDataTypeDef, size), NULL, NULL, 0, /* flags */ @@ -1164,7 +1164,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_data_type_def__field_ PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDataTypeDef, precision), + offsetof(TcDb__CtcDDLColumnDataTypeDef, precision), NULL, NULL, 0, /* flags */ @@ -1176,7 +1176,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_data_type_def__field_ PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDataTypeDef, scale), + offsetof(TcDb__CtcDDLColumnDataTypeDef, scale), NULL, NULL, 0, /* flags */ @@ -1188,41 +1188,41 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_data_type_def__field_ PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDataTypeDef, mysql_ori_datatype), + offsetof(TcDb__CtcDDLColumnDataTypeDef, mysql_ori_datatype), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddlcolumn_data_type_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddlcolumn_data_type_def__field_indices_by_name[] = { 0, /* field[0] = datatype */ 4, /* field[4] = mysql_ori_datatype */ 2, /* field[2] = precision */ 3, /* field[3] = scale */ 1, /* field[1] = size */ }; -static const ProtobufCIntRange tc_db__tse_ddlcolumn_data_type_def__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddlcolumn_data_type_def__number_ranges[1 + 1] = { { 1, 0 }, { 0, 5 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddlcolumn_data_type_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddlcolumn_data_type_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLColumnDataTypeDef", - "TseDDLColumnDataTypeDef", - "TcDb__TseDDLColumnDataTypeDef", + "tc_db.CtcDDLColumnDataTypeDef", + "CtcDDLColumnDataTypeDef", + "TcDb__CtcDDLColumnDataTypeDef", "tc_db", - sizeof(TcDb__TseDDLColumnDataTypeDef), + sizeof(TcDb__CtcDDLColumnDataTypeDef), 5, - tc_db__tse_ddlcolumn_data_type_def__field_descriptors, - tc_db__tse_ddlcolumn_data_type_def__field_indices_by_name, - 1, tc_db__tse_ddlcolumn_data_type_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddlcolumn_data_type_def__init, + tc_db__ctc_ddlcolumn_data_type_def__field_descriptors, + tc_db__ctc_ddlcolumn_data_type_def__field_indices_by_name, + 1, tc_db__ctc_ddlcolumn_data_type_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddlcolumn_data_type_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_def__field_descriptors[14] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddlcolumn_def__field_descriptors[14] = { { "name", @@ -1230,7 +1230,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_def__field_descriptor PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDef, name), + offsetof(TcDb__CtcDDLColumnDef, name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1242,8 +1242,8 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_def__field_descriptor PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDef, datatype), - &tc_db__tse_ddlcolumn_data_type_def__descriptor, + offsetof(TcDb__CtcDDLColumnDef, datatype), + &tc_db__ctc_ddlcolumn_data_type_def__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1254,7 +1254,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_def__field_descriptor PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDef, is_option_set), + offsetof(TcDb__CtcDDLColumnDef, is_option_set), NULL, NULL, 0, /* flags */ @@ -1266,7 +1266,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_def__field_descriptor PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDef, col_id), + offsetof(TcDb__CtcDDLColumnDef, col_id), NULL, NULL, 0, /* flags */ @@ -1278,7 +1278,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_def__field_descriptor PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDef, cons_name), + offsetof(TcDb__CtcDDLColumnDef, cons_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1290,7 +1290,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_def__field_descriptor PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDef, ref_user), + offsetof(TcDb__CtcDDLColumnDef, ref_user), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1302,7 +1302,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_def__field_descriptor PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDef, ref_table), + offsetof(TcDb__CtcDDLColumnDef, ref_table), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1314,7 +1314,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_def__field_descriptor PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDef, default_text), + offsetof(TcDb__CtcDDLColumnDef, default_text), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1326,7 +1326,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_def__field_descriptor PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDef, comment), + offsetof(TcDb__CtcDDLColumnDef, comment), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1338,7 +1338,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_def__field_descriptor PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDef, alter_mode), + offsetof(TcDb__CtcDDLColumnDef, alter_mode), NULL, NULL, 0, /* flags */ @@ -1350,7 +1350,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_def__field_descriptor PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT64, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDef, collate), + offsetof(TcDb__CtcDDLColumnDef, collate), NULL, NULL, 0, /* flags */ @@ -1362,7 +1362,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_def__field_descriptor PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDef, new_name), + offsetof(TcDb__CtcDDLColumnDef, new_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1374,7 +1374,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_def__field_descriptor PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDef, is_unsigned), + offsetof(TcDb__CtcDDLColumnDef, is_unsigned), NULL, NULL, 0, /* flags */ @@ -1386,14 +1386,14 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcolumn_def__field_descriptor PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLColumnDef, default_func_name), + offsetof(TcDb__CtcDDLColumnDef, default_func_name), NULL, &protobuf_c_empty_string, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddlcolumn_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddlcolumn_def__field_indices_by_name[] = { 9, /* field[9] = alter_mode */ 3, /* field[3] = col_id */ 10, /* field[10] = collate */ @@ -1409,29 +1409,29 @@ static const unsigned tc_db__tse_ddlcolumn_def__field_indices_by_name[] = { 6, /* field[6] = ref_table */ 5, /* field[5] = ref_user */ }; -static const ProtobufCIntRange tc_db__tse_ddlcolumn_def__number_ranges[3 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddlcolumn_def__number_ranges[3 + 1] = { { 1, 0 }, { 4, 2 }, { 10, 5 }, { 0, 14 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddlcolumn_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddlcolumn_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLColumnDef", - "TseDDLColumnDef", - "TcDb__TseDDLColumnDef", + "tc_db.CtcDDLColumnDef", + "CtcDDLColumnDef", + "TcDb__CtcDDLColumnDef", "tc_db", - sizeof(TcDb__TseDDLColumnDef), + sizeof(TcDb__CtcDDLColumnDef), 14, - tc_db__tse_ddlcolumn_def__field_descriptors, - tc_db__tse_ddlcolumn_def__field_indices_by_name, - 3, tc_db__tse_ddlcolumn_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddlcolumn_def__init, + tc_db__ctc_ddlcolumn_def__field_descriptors, + tc_db__ctc_ddlcolumn_def__field_indices_by_name, + 3, tc_db__ctc_ddlcolumn_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddlcolumn_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddlforeign_key_element_def__field_descriptors[2] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddlforeign_key_element_def__field_descriptors[2] = { { "src_column_name", @@ -1439,7 +1439,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlforeign_key_element_def__fie PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLForeignKeyElementDef, src_column_name), + offsetof(TcDb__CtcDDLForeignKeyElementDef, src_column_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1451,38 +1451,38 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlforeign_key_element_def__fie PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLForeignKeyElementDef, ref_column_name), + offsetof(TcDb__CtcDDLForeignKeyElementDef, ref_column_name), NULL, &protobuf_c_empty_string, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddlforeign_key_element_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddlforeign_key_element_def__field_indices_by_name[] = { 1, /* field[1] = ref_column_name */ 0, /* field[0] = src_column_name */ }; -static const ProtobufCIntRange tc_db__tse_ddlforeign_key_element_def__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddlforeign_key_element_def__number_ranges[1 + 1] = { { 1, 0 }, { 0, 2 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddlforeign_key_element_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddlforeign_key_element_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLForeignKeyElementDef", - "TseDDLForeignKeyElementDef", - "TcDb__TseDDLForeignKeyElementDef", + "tc_db.CtcDDLForeignKeyElementDef", + "CtcDDLForeignKeyElementDef", + "TcDb__CtcDDLForeignKeyElementDef", "tc_db", - sizeof(TcDb__TseDDLForeignKeyElementDef), + sizeof(TcDb__CtcDDLForeignKeyElementDef), 2, - tc_db__tse_ddlforeign_key_element_def__field_descriptors, - tc_db__tse_ddlforeign_key_element_def__field_indices_by_name, - 1, tc_db__tse_ddlforeign_key_element_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddlforeign_key_element_def__init, + tc_db__ctc_ddlforeign_key_element_def__field_descriptors, + tc_db__ctc_ddlforeign_key_element_def__field_indices_by_name, + 1, tc_db__ctc_ddlforeign_key_element_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddlforeign_key_element_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddlforeign_key_def__field_descriptors[8] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddlforeign_key_def__field_descriptors[8] = { { "name", @@ -1490,7 +1490,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlforeign_key_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLForeignKeyDef, name), + offsetof(TcDb__CtcDDLForeignKeyDef, name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1502,7 +1502,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlforeign_key_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLForeignKeyDef, unique_index_name), + offsetof(TcDb__CtcDDLForeignKeyDef, unique_index_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1514,7 +1514,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlforeign_key_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLForeignKeyDef, match_opt), + offsetof(TcDb__CtcDDLForeignKeyDef, match_opt), NULL, NULL, 0, /* flags */ @@ -1526,7 +1526,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlforeign_key_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLForeignKeyDef, update_opt), + offsetof(TcDb__CtcDDLForeignKeyDef, update_opt), NULL, NULL, 0, /* flags */ @@ -1538,7 +1538,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlforeign_key_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLForeignKeyDef, delete_opt), + offsetof(TcDb__CtcDDLForeignKeyDef, delete_opt), NULL, NULL, 0, /* flags */ @@ -1550,7 +1550,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlforeign_key_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLForeignKeyDef, referenced_table_schema_name), + offsetof(TcDb__CtcDDLForeignKeyDef, referenced_table_schema_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1562,7 +1562,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlforeign_key_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLForeignKeyDef, referenced_table_name), + offsetof(TcDb__CtcDDLForeignKeyDef, referenced_table_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1573,15 +1573,15 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlforeign_key_def__field_descr 8, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_MESSAGE, - offsetof(TcDb__TseDDLForeignKeyDef, n_elements), - offsetof(TcDb__TseDDLForeignKeyDef, elements), - &tc_db__tse_ddlforeign_key_element_def__descriptor, + offsetof(TcDb__CtcDDLForeignKeyDef, n_elements), + offsetof(TcDb__CtcDDLForeignKeyDef, elements), + &tc_db__ctc_ddlforeign_key_element_def__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddlforeign_key_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddlforeign_key_def__field_indices_by_name[] = { 4, /* field[4] = delete_opt */ 7, /* field[7] = elements */ 2, /* field[2] = match_opt */ @@ -1591,27 +1591,27 @@ static const unsigned tc_db__tse_ddlforeign_key_def__field_indices_by_name[] = { 1, /* field[1] = unique_index_name */ 3, /* field[3] = update_opt */ }; -static const ProtobufCIntRange tc_db__tse_ddlforeign_key_def__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddlforeign_key_def__number_ranges[1 + 1] = { { 1, 0 }, { 0, 8 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddlforeign_key_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddlforeign_key_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLForeignKeyDef", - "TseDDLForeignKeyDef", - "TcDb__TseDDLForeignKeyDef", + "tc_db.CtcDDLForeignKeyDef", + "CtcDDLForeignKeyDef", + "TcDb__CtcDDLForeignKeyDef", "tc_db", - sizeof(TcDb__TseDDLForeignKeyDef), + sizeof(TcDb__CtcDDLForeignKeyDef), 8, - tc_db__tse_ddlforeign_key_def__field_descriptors, - tc_db__tse_ddlforeign_key_def__field_indices_by_name, - 1, tc_db__tse_ddlforeign_key_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddlforeign_key_def__init, + tc_db__ctc_ddlforeign_key_def__field_descriptors, + tc_db__ctc_ddlforeign_key_def__field_indices_by_name, + 1, tc_db__ctc_ddlforeign_key_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddlforeign_key_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key_part__field_descriptors[7] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddltable_key_part__field_descriptors[7] = { { "name", @@ -1619,7 +1619,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key_part__field_descri PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTableKeyPart, name), + offsetof(TcDb__CtcDDLTableKeyPart, name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1631,7 +1631,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key_part__field_descri PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTableKeyPart, length), + offsetof(TcDb__CtcDDLTableKeyPart, length), NULL, NULL, 0, /* flags */ @@ -1643,7 +1643,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key_part__field_descri PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTableKeyPart, datatype), + offsetof(TcDb__CtcDDLTableKeyPart, datatype), NULL, NULL, 0, /* flags */ @@ -1655,7 +1655,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key_part__field_descri PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_BOOL, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTableKeyPart, is_func), + offsetof(TcDb__CtcDDLTableKeyPart, is_func), NULL, NULL, 0, /* flags */ @@ -1667,7 +1667,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key_part__field_descri PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTableKeyPart, func_text), + offsetof(TcDb__CtcDDLTableKeyPart, func_text), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1679,7 +1679,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key_part__field_descri PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTableKeyPart, func_name), + offsetof(TcDb__CtcDDLTableKeyPart, func_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1691,14 +1691,14 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key_part__field_descri PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTableKeyPart, is_unsigned), + offsetof(TcDb__CtcDDLTableKeyPart, is_unsigned), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddltable_key_part__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddltable_key_part__field_indices_by_name[] = { 2, /* field[2] = datatype */ 5, /* field[5] = func_name */ 4, /* field[4] = func_text */ @@ -1707,27 +1707,27 @@ static const unsigned tc_db__tse_ddltable_key_part__field_indices_by_name[] = { 1, /* field[1] = length */ 0, /* field[0] = name */ }; -static const ProtobufCIntRange tc_db__tse_ddltable_key_part__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddltable_key_part__number_ranges[1 + 1] = { { 1, 0 }, { 0, 7 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddltable_key_part__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddltable_key_part__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLTableKeyPart", - "TseDDLTableKeyPart", - "TcDb__TseDDLTableKeyPart", + "tc_db.CtcDDLTableKeyPart", + "CtcDDLTableKeyPart", + "TcDb__CtcDDLTableKeyPart", "tc_db", - sizeof(TcDb__TseDDLTableKeyPart), + sizeof(TcDb__CtcDDLTableKeyPart), 7, - tc_db__tse_ddltable_key_part__field_descriptors, - tc_db__tse_ddltable_key_part__field_indices_by_name, - 1, tc_db__tse_ddltable_key_part__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddltable_key_part__init, + tc_db__ctc_ddltable_key_part__field_descriptors, + tc_db__ctc_ddltable_key_part__field_indices_by_name, + 1, tc_db__ctc_ddltable_key_part__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddltable_key_part__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key__field_descriptors[10] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddltable_key__field_descriptors[10] = { { "user", @@ -1735,7 +1735,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTableKey, user), + offsetof(TcDb__CtcDDLTableKey, user), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1747,7 +1747,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTableKey, table), + offsetof(TcDb__CtcDDLTableKey, table), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1759,7 +1759,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTableKey, name), + offsetof(TcDb__CtcDDLTableKey, name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1771,7 +1771,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTableKey, space), + offsetof(TcDb__CtcDDLTableKey, space), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1783,7 +1783,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTableKey, key_type), + offsetof(TcDb__CtcDDLTableKey, key_type), NULL, NULL, 0, /* flags */ @@ -1795,7 +1795,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTableKey, algorithm), + offsetof(TcDb__CtcDDLTableKey, algorithm), NULL, NULL, 0, /* flags */ @@ -1807,7 +1807,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_BOOL, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTableKey, is_func), + offsetof(TcDb__CtcDDLTableKey, is_func), NULL, NULL, 0, /* flags */ @@ -1818,9 +1818,9 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key__field_descriptors 8, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_MESSAGE, - offsetof(TcDb__TseDDLTableKey, n_columns), - offsetof(TcDb__TseDDLTableKey, columns), - &tc_db__tse_ddltable_key_part__descriptor, + offsetof(TcDb__CtcDDLTableKey, n_columns), + offsetof(TcDb__CtcDDLTableKey, columns), + &tc_db__ctc_ddltable_key_part__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -1831,7 +1831,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_BOOL, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTableKey, is_constraint), + offsetof(TcDb__CtcDDLTableKey, is_constraint), NULL, NULL, 0, /* flags */ @@ -1843,14 +1843,14 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltable_key__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_BOOL, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTableKey, is_dsc), + offsetof(TcDb__CtcDDLTableKey, is_dsc), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddltable_key__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddltable_key__field_indices_by_name[] = { 5, /* field[5] = algorithm */ 7, /* field[7] = columns */ 8, /* field[8] = is_constraint */ @@ -1862,27 +1862,27 @@ static const unsigned tc_db__tse_ddltable_key__field_indices_by_name[] = { 1, /* field[1] = table */ 0, /* field[0] = user */ }; -static const ProtobufCIntRange tc_db__tse_ddltable_key__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddltable_key__number_ranges[1 + 1] = { { 1, 0 }, { 0, 10 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddltable_key__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddltable_key__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLTableKey", - "TseDDLTableKey", - "TcDb__TseDDLTableKey", + "tc_db.CtcDDLTableKey", + "CtcDDLTableKey", + "TcDb__CtcDDLTableKey", "tc_db", - sizeof(TcDb__TseDDLTableKey), + sizeof(TcDb__CtcDDLTableKey), 10, - tc_db__tse_ddltable_key__field_descriptors, - tc_db__tse_ddltable_key__field_indices_by_name, - 1, tc_db__tse_ddltable_key__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddltable_key__init, + tc_db__ctc_ddltable_key__field_descriptors, + tc_db__ctc_ddltable_key__field_indices_by_name, + 1, tc_db__ctc_ddltable_key__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddltable_key__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_msg_comm_def__field_descriptors[4] = +static const ProtobufCFieldDescriptor tc_db__ctc_msg_comm_def__field_descriptors[4] = { { "inst_id", @@ -1890,7 +1890,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_msg_comm_def__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseMsgCommDef, inst_id), + offsetof(TcDb__CtcMsgCommDef, inst_id), NULL, NULL, 0, /* flags */ @@ -1902,7 +1902,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_msg_comm_def__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseMsgCommDef, thd_id), + offsetof(TcDb__CtcMsgCommDef, thd_id), NULL, NULL, 0, /* flags */ @@ -1914,7 +1914,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_msg_comm_def__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseMsgCommDef, handler_id), + offsetof(TcDb__CtcMsgCommDef, handler_id), NULL, NULL, 0, /* flags */ @@ -1926,40 +1926,40 @@ static const ProtobufCFieldDescriptor tc_db__tse_msg_comm_def__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT64, 0, /* quantifier_offset */ - offsetof(TcDb__TseMsgCommDef, sess_addr), + offsetof(TcDb__CtcMsgCommDef, sess_addr), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_msg_comm_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_msg_comm_def__field_indices_by_name[] = { 2, /* field[2] = handler_id */ 0, /* field[0] = inst_id */ 3, /* field[3] = sess_addr */ 1, /* field[1] = thd_id */ }; -static const ProtobufCIntRange tc_db__tse_msg_comm_def__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_msg_comm_def__number_ranges[1 + 1] = { { 1, 0 }, { 0, 4 } }; -const ProtobufCMessageDescriptor tc_db__tse_msg_comm_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_msg_comm_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseMsgCommDef", - "TseMsgCommDef", - "TcDb__TseMsgCommDef", + "tc_db.CtcMsgCommDef", + "CtcMsgCommDef", + "TcDb__CtcMsgCommDef", "tc_db", - sizeof(TcDb__TseMsgCommDef), + sizeof(TcDb__CtcMsgCommDef), 4, - tc_db__tse_msg_comm_def__field_descriptors, - tc_db__tse_msg_comm_def__field_indices_by_name, - 1, tc_db__tse_msg_comm_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_msg_comm_def__init, + tc_db__ctc_msg_comm_def__field_descriptors, + tc_db__ctc_msg_comm_def__field_indices_by_name, + 1, tc_db__ctc_msg_comm_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_msg_comm_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddlpartition_table_def__field_descriptors[2] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddlpartition_table_def__field_descriptors[2] = { { "name", @@ -1967,7 +1967,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlpartition_table_def__field_d PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLPartitionTableDef, name), + offsetof(TcDb__CtcDDLPartitionTableDef, name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -1978,39 +1978,39 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlpartition_table_def__field_d 2, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_MESSAGE, - offsetof(TcDb__TseDDLPartitionTableDef, n_subpart_table_list), - offsetof(TcDb__TseDDLPartitionTableDef, subpart_table_list), - &tc_db__tse_ddlpartition_table_def__descriptor, + offsetof(TcDb__CtcDDLPartitionTableDef, n_subpart_table_list), + offsetof(TcDb__CtcDDLPartitionTableDef, subpart_table_list), + &tc_db__ctc_ddlpartition_table_def__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddlpartition_table_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddlpartition_table_def__field_indices_by_name[] = { 0, /* field[0] = name */ 1, /* field[1] = subpart_table_list */ }; -static const ProtobufCIntRange tc_db__tse_ddlpartition_table_def__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddlpartition_table_def__number_ranges[1 + 1] = { { 1, 0 }, { 0, 2 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddlpartition_table_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddlpartition_table_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLPartitionTableDef", - "TseDDLPartitionTableDef", - "TcDb__TseDDLPartitionTableDef", + "tc_db.CtcDDLPartitionTableDef", + "CtcDDLPartitionTableDef", + "TcDb__CtcDDLPartitionTableDef", "tc_db", - sizeof(TcDb__TseDDLPartitionTableDef), + sizeof(TcDb__CtcDDLPartitionTableDef), 2, - tc_db__tse_ddlpartition_table_def__field_descriptors, - tc_db__tse_ddlpartition_table_def__field_indices_by_name, - 1, tc_db__tse_ddlpartition_table_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddlpartition_table_def__init, + tc_db__ctc_ddlpartition_table_def__field_descriptors, + tc_db__ctc_ddlpartition_table_def__field_indices_by_name, + 1, tc_db__ctc_ddlpartition_table_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddlpartition_table_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddlpartition_def__field_descriptors[3] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddlpartition_def__field_descriptors[3] = { { "part_type", @@ -2018,7 +2018,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlpartition_def__field_descrip PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLPartitionDef, part_type), + offsetof(TcDb__CtcDDLPartitionDef, part_type), NULL, NULL, 0, /* flags */ @@ -2030,7 +2030,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlpartition_def__field_descrip PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLPartitionDef, subpart_type), + offsetof(TcDb__CtcDDLPartitionDef, subpart_type), NULL, NULL, 0, /* flags */ @@ -2041,40 +2041,40 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlpartition_def__field_descrip 3, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_MESSAGE, - offsetof(TcDb__TseDDLPartitionDef, n_part_table_list), - offsetof(TcDb__TseDDLPartitionDef, part_table_list), - &tc_db__tse_ddlpartition_table_def__descriptor, + offsetof(TcDb__CtcDDLPartitionDef, n_part_table_list), + offsetof(TcDb__CtcDDLPartitionDef, part_table_list), + &tc_db__ctc_ddlpartition_table_def__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddlpartition_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddlpartition_def__field_indices_by_name[] = { 2, /* field[2] = part_table_list */ 0, /* field[0] = part_type */ 1, /* field[1] = subpart_type */ }; -static const ProtobufCIntRange tc_db__tse_ddlpartition_def__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddlpartition_def__number_ranges[1 + 1] = { { 1, 0 }, { 0, 3 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddlpartition_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddlpartition_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLPartitionDef", - "TseDDLPartitionDef", - "TcDb__TseDDLPartitionDef", + "tc_db.CtcDDLPartitionDef", + "CtcDDLPartitionDef", + "TcDb__CtcDDLPartitionDef", "tc_db", - sizeof(TcDb__TseDDLPartitionDef), + sizeof(TcDb__CtcDDLPartitionDef), 3, - tc_db__tse_ddlpartition_def__field_descriptors, - tc_db__tse_ddlpartition_def__field_indices_by_name, - 1, tc_db__tse_ddlpartition_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddlpartition_def__init, + tc_db__ctc_ddlpartition_def__field_descriptors, + tc_db__ctc_ddlpartition_def__field_indices_by_name, + 1, tc_db__ctc_ddlpartition_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddlpartition_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddlcreate_table_def__field_descriptors[14] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddlcreate_table_def__field_descriptors[14] = { { "schema", @@ -2082,7 +2082,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcreate_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLCreateTableDef, schema), + offsetof(TcDb__CtcDDLCreateTableDef, schema), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2094,7 +2094,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcreate_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLCreateTableDef, name), + offsetof(TcDb__CtcDDLCreateTableDef, name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2106,7 +2106,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcreate_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLCreateTableDef, space), + offsetof(TcDb__CtcDDLCreateTableDef, space), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2117,9 +2117,9 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcreate_table_def__field_desc 4, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_MESSAGE, - offsetof(TcDb__TseDDLCreateTableDef, n_columns), - offsetof(TcDb__TseDDLCreateTableDef, columns), - &tc_db__tse_ddlcolumn_def__descriptor, + offsetof(TcDb__CtcDDLCreateTableDef, n_columns), + offsetof(TcDb__CtcDDLCreateTableDef, columns), + &tc_db__ctc_ddlcolumn_def__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -2129,9 +2129,9 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcreate_table_def__field_desc 5, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_MESSAGE, - offsetof(TcDb__TseDDLCreateTableDef, n_fk_list), - offsetof(TcDb__TseDDLCreateTableDef, fk_list), - &tc_db__tse_ddlforeign_key_def__descriptor, + offsetof(TcDb__CtcDDLCreateTableDef, n_fk_list), + offsetof(TcDb__CtcDDLCreateTableDef, fk_list), + &tc_db__ctc_ddlforeign_key_def__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -2141,9 +2141,9 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcreate_table_def__field_desc 6, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_MESSAGE, - offsetof(TcDb__TseDDLCreateTableDef, n_key_list), - offsetof(TcDb__TseDDLCreateTableDef, key_list), - &tc_db__tse_ddltable_key__descriptor, + offsetof(TcDb__CtcDDLCreateTableDef, n_key_list), + offsetof(TcDb__CtcDDLCreateTableDef, key_list), + &tc_db__ctc_ddltable_key__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -2154,7 +2154,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcreate_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT64, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLCreateTableDef, auto_increment_value), + offsetof(TcDb__CtcDDLCreateTableDef, auto_increment_value), NULL, NULL, 0, /* flags */ @@ -2166,7 +2166,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcreate_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLCreateTableDef, options), + offsetof(TcDb__CtcDDLCreateTableDef, options), NULL, NULL, 0, /* flags */ @@ -2178,7 +2178,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcreate_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLCreateTableDef, db_name), + offsetof(TcDb__CtcDDLCreateTableDef, db_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2190,7 +2190,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcreate_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLCreateTableDef, sql_str), + offsetof(TcDb__CtcDDLCreateTableDef, sql_str), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2202,7 +2202,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcreate_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLCreateTableDef, alter_table_name), + offsetof(TcDb__CtcDDLCreateTableDef, alter_table_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2214,7 +2214,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcreate_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLCreateTableDef, alter_db_name), + offsetof(TcDb__CtcDDLCreateTableDef, alter_db_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2226,7 +2226,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcreate_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_BOOL, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLCreateTableDef, is_create_as_select), + offsetof(TcDb__CtcDDLCreateTableDef, is_create_as_select), NULL, NULL, 0, /* flags */ @@ -2238,14 +2238,14 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlcreate_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLCreateTableDef, partition_def), - &tc_db__tse_ddlpartition_def__descriptor, + offsetof(TcDb__CtcDDLCreateTableDef, partition_def), + &tc_db__ctc_ddlpartition_def__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddlcreate_table_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddlcreate_table_def__field_indices_by_name[] = { 11, /* field[11] = alter_db_name */ 10, /* field[10] = alter_table_name */ 6, /* field[6] = auto_increment_value */ @@ -2261,27 +2261,27 @@ static const unsigned tc_db__tse_ddlcreate_table_def__field_indices_by_name[] = 2, /* field[2] = space */ 9, /* field[9] = sql_str */ }; -static const ProtobufCIntRange tc_db__tse_ddlcreate_table_def__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddlcreate_table_def__number_ranges[1 + 1] = { { 1, 0 }, { 0, 14 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddlcreate_table_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddlcreate_table_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLCreateTableDef", - "TseDDLCreateTableDef", - "TcDb__TseDDLCreateTableDef", + "tc_db.CtcDDLCreateTableDef", + "CtcDDLCreateTableDef", + "TcDb__CtcDDLCreateTableDef", "tc_db", - sizeof(TcDb__TseDDLCreateTableDef), + sizeof(TcDb__CtcDDLCreateTableDef), 14, - tc_db__tse_ddlcreate_table_def__field_descriptors, - tc_db__tse_ddlcreate_table_def__field_indices_by_name, - 1, tc_db__tse_ddlcreate_table_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddlcreate_table_def__init, + tc_db__ctc_ddlcreate_table_def__field_descriptors, + tc_db__ctc_ddlcreate_table_def__field_indices_by_name, + 1, tc_db__ctc_ddlcreate_table_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddlcreate_table_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_porp__field_descriptors[6] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddlalter_table_porp__field_descriptors[6] = { { "new_name", @@ -2289,7 +2289,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_porp__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTablePorp, new_name), + offsetof(TcDb__CtcDDLAlterTablePorp, new_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2301,7 +2301,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_porp__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTablePorp, pctfree), + offsetof(TcDb__CtcDDLAlterTablePorp, pctfree), NULL, NULL, 0, /* flags */ @@ -2313,7 +2313,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_porp__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTablePorp, appendonly), + offsetof(TcDb__CtcDDLAlterTablePorp, appendonly), NULL, NULL, 0, /* flags */ @@ -2325,7 +2325,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_porp__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTablePorp, enable_row_move), + offsetof(TcDb__CtcDDLAlterTablePorp, enable_row_move), NULL, NULL, 0, /* flags */ @@ -2337,7 +2337,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_porp__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTablePorp, shrink_opt), + offsetof(TcDb__CtcDDLAlterTablePorp, shrink_opt), NULL, NULL, 0, /* flags */ @@ -2349,14 +2349,14 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_porp__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_INT64, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTablePorp, serial_start), + offsetof(TcDb__CtcDDLAlterTablePorp, serial_start), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddlalter_table_porp__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddlalter_table_porp__field_indices_by_name[] = { 2, /* field[2] = appendonly */ 3, /* field[3] = enable_row_move */ 0, /* field[0] = new_name */ @@ -2364,27 +2364,27 @@ static const unsigned tc_db__tse_ddlalter_table_porp__field_indices_by_name[] = 5, /* field[5] = serial_start */ 4, /* field[4] = shrink_opt */ }; -static const ProtobufCIntRange tc_db__tse_ddlalter_table_porp__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddlalter_table_porp__number_ranges[1 + 1] = { { 1, 0 }, { 0, 6 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddlalter_table_porp__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddlalter_table_porp__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLAlterTablePorp", - "TseDDLAlterTablePorp", - "TcDb__TseDDLAlterTablePorp", + "tc_db.CtcDDLAlterTablePorp", + "CtcDDLAlterTablePorp", + "TcDb__CtcDDLAlterTablePorp", "tc_db", - sizeof(TcDb__TseDDLAlterTablePorp), + sizeof(TcDb__CtcDDLAlterTablePorp), 6, - tc_db__tse_ddlalter_table_porp__field_descriptors, - tc_db__tse_ddlalter_table_porp__field_indices_by_name, - 1, tc_db__tse_ddlalter_table_porp__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddlalter_table_porp__init, + tc_db__ctc_ddlalter_table_porp__field_descriptors, + tc_db__ctc_ddlalter_table_porp__field_indices_by_name, + 1, tc_db__ctc_ddlalter_table_porp__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddlalter_table_porp__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_drop__field_descriptors[3] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddlalter_table_drop__field_descriptors[3] = { { "name", @@ -2392,7 +2392,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_drop__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableDrop, name), + offsetof(TcDb__CtcDDLAlterTableDrop, name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2404,7 +2404,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_drop__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableDrop, drop_type), + offsetof(TcDb__CtcDDLAlterTableDrop, drop_type), NULL, NULL, 0, /* flags */ @@ -2416,39 +2416,39 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_drop__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableDrop, key_type), + offsetof(TcDb__CtcDDLAlterTableDrop, key_type), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddlalter_table_drop__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddlalter_table_drop__field_indices_by_name[] = { 1, /* field[1] = drop_type */ 2, /* field[2] = key_type */ 0, /* field[0] = name */ }; -static const ProtobufCIntRange tc_db__tse_ddlalter_table_drop__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddlalter_table_drop__number_ranges[1 + 1] = { { 1, 0 }, { 0, 3 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddlalter_table_drop__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddlalter_table_drop__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLAlterTableDrop", - "TseDDLAlterTableDrop", - "TcDb__TseDDLAlterTableDrop", + "tc_db.CtcDDLAlterTableDrop", + "CtcDDLAlterTableDrop", + "TcDb__CtcDDLAlterTableDrop", "tc_db", - sizeof(TcDb__TseDDLAlterTableDrop), + sizeof(TcDb__CtcDDLAlterTableDrop), 3, - tc_db__tse_ddlalter_table_drop__field_descriptors, - tc_db__tse_ddlalter_table_drop__field_indices_by_name, - 1, tc_db__tse_ddlalter_table_drop__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddlalter_table_drop__init, + tc_db__ctc_ddlalter_table_drop__field_descriptors, + tc_db__ctc_ddlalter_table_drop__field_indices_by_name, + 1, tc_db__ctc_ddlalter_table_drop__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddlalter_table_drop__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_drop_key__field_descriptors[3] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddlalter_table_drop_key__field_descriptors[3] = { { "name", @@ -2456,7 +2456,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_drop_key__field_ PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableDropKey, name), + offsetof(TcDb__CtcDDLAlterTableDropKey, name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2468,7 +2468,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_drop_key__field_ PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableDropKey, drop_type), + offsetof(TcDb__CtcDDLAlterTableDropKey, drop_type), NULL, NULL, 0, /* flags */ @@ -2480,39 +2480,39 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_drop_key__field_ PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableDropKey, key_type), + offsetof(TcDb__CtcDDLAlterTableDropKey, key_type), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddlalter_table_drop_key__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddlalter_table_drop_key__field_indices_by_name[] = { 1, /* field[1] = drop_type */ 2, /* field[2] = key_type */ 0, /* field[0] = name */ }; -static const ProtobufCIntRange tc_db__tse_ddlalter_table_drop_key__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddlalter_table_drop_key__number_ranges[1 + 1] = { { 1, 0 }, { 0, 3 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddlalter_table_drop_key__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddlalter_table_drop_key__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLAlterTableDropKey", - "TseDDLAlterTableDropKey", - "TcDb__TseDDLAlterTableDropKey", + "tc_db.CtcDDLAlterTableDropKey", + "CtcDDLAlterTableDropKey", + "TcDb__CtcDDLAlterTableDropKey", "tc_db", - sizeof(TcDb__TseDDLAlterTableDropKey), + sizeof(TcDb__CtcDDLAlterTableDropKey), 3, - tc_db__tse_ddlalter_table_drop_key__field_descriptors, - tc_db__tse_ddlalter_table_drop_key__field_indices_by_name, - 1, tc_db__tse_ddlalter_table_drop_key__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddlalter_table_drop_key__init, + tc_db__ctc_ddlalter_table_drop_key__field_descriptors, + tc_db__ctc_ddlalter_table_drop_key__field_indices_by_name, + 1, tc_db__ctc_ddlalter_table_drop_key__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddlalter_table_drop_key__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_alter_column__field_descriptors[7] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddlalter_table_alter_column__field_descriptors[7] = { { "name", @@ -2520,7 +2520,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_alter_column__fi PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableAlterColumn, name), + offsetof(TcDb__CtcDDLAlterTableAlterColumn, name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2532,7 +2532,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_alter_column__fi PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableAlterColumn, new_name), + offsetof(TcDb__CtcDDLAlterTableAlterColumn, new_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2544,7 +2544,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_alter_column__fi PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableAlterColumn, type), + offsetof(TcDb__CtcDDLAlterTableAlterColumn, type), NULL, NULL, 0, /* flags */ @@ -2556,7 +2556,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_alter_column__fi PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_BOOL, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableAlterColumn, has_no_default), + offsetof(TcDb__CtcDDLAlterTableAlterColumn, has_no_default), NULL, NULL, 0, /* flags */ @@ -2568,7 +2568,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_alter_column__fi PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_BOOL, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableAlterColumn, has_default), + offsetof(TcDb__CtcDDLAlterTableAlterColumn, has_default), NULL, NULL, 0, /* flags */ @@ -2580,7 +2580,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_alter_column__fi PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_BOOL, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableAlterColumn, is_default_null), + offsetof(TcDb__CtcDDLAlterTableAlterColumn, is_default_null), NULL, NULL, 0, /* flags */ @@ -2592,14 +2592,14 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_alter_column__fi PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableAlterColumn, default_text), + offsetof(TcDb__CtcDDLAlterTableAlterColumn, default_text), NULL, &protobuf_c_empty_string, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddlalter_table_alter_column__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddlalter_table_alter_column__field_indices_by_name[] = { 6, /* field[6] = default_text */ 4, /* field[4] = has_default */ 3, /* field[3] = has_no_default */ @@ -2608,27 +2608,27 @@ static const unsigned tc_db__tse_ddlalter_table_alter_column__field_indices_by_n 1, /* field[1] = new_name */ 2, /* field[2] = type */ }; -static const ProtobufCIntRange tc_db__tse_ddlalter_table_alter_column__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddlalter_table_alter_column__number_ranges[1 + 1] = { { 1, 0 }, { 0, 7 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddlalter_table_alter_column__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddlalter_table_alter_column__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLAlterTableAlterColumn", - "TseDDLAlterTableAlterColumn", - "TcDb__TseDDLAlterTableAlterColumn", + "tc_db.CtcDDLAlterTableAlterColumn", + "CtcDDLAlterTableAlterColumn", + "TcDb__CtcDDLAlterTableAlterColumn", "tc_db", - sizeof(TcDb__TseDDLAlterTableAlterColumn), + sizeof(TcDb__CtcDDLAlterTableAlterColumn), 7, - tc_db__tse_ddlalter_table_alter_column__field_descriptors, - tc_db__tse_ddlalter_table_alter_column__field_indices_by_name, - 1, tc_db__tse_ddlalter_table_alter_column__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddlalter_table_alter_column__init, + tc_db__ctc_ddlalter_table_alter_column__field_descriptors, + tc_db__ctc_ddlalter_table_alter_column__field_indices_by_name, + 1, tc_db__ctc_ddlalter_table_alter_column__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddlalter_table_alter_column__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descriptors[20] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddlalter_table_def__field_descriptors[20] = { { "action", @@ -2636,7 +2636,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableDef, action), + offsetof(TcDb__CtcDDLAlterTableDef, action), NULL, NULL, 0, /* flags */ @@ -2648,7 +2648,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableDef, options), + offsetof(TcDb__CtcDDLAlterTableDef, options), NULL, NULL, 0, /* flags */ @@ -2660,7 +2660,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableDef, user), + offsetof(TcDb__CtcDDLAlterTableDef, user), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2672,7 +2672,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableDef, name), + offsetof(TcDb__CtcDDLAlterTableDef, name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2683,9 +2683,9 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr 5, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_MESSAGE, - offsetof(TcDb__TseDDLAlterTableDef, n_drop_list), - offsetof(TcDb__TseDDLAlterTableDef, drop_list), - &tc_db__tse_ddlalter_table_drop__descriptor, + offsetof(TcDb__CtcDDLAlterTableDef, n_drop_list), + offsetof(TcDb__CtcDDLAlterTableDef, drop_list), + &tc_db__ctc_ddlalter_table_drop__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -2695,9 +2695,9 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr 6, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_MESSAGE, - offsetof(TcDb__TseDDLAlterTableDef, n_alter_list), - offsetof(TcDb__TseDDLAlterTableDef, alter_list), - &tc_db__tse_ddlalter_table_alter_column__descriptor, + offsetof(TcDb__CtcDDLAlterTableDef, n_alter_list), + offsetof(TcDb__CtcDDLAlterTableDef, alter_list), + &tc_db__ctc_ddlalter_table_alter_column__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -2707,9 +2707,9 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr 7, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_MESSAGE, - offsetof(TcDb__TseDDLAlterTableDef, n_create_list), - offsetof(TcDb__TseDDLAlterTableDef, create_list), - &tc_db__tse_ddlcolumn_def__descriptor, + offsetof(TcDb__CtcDDLAlterTableDef, n_create_list), + offsetof(TcDb__CtcDDLAlterTableDef, create_list), + &tc_db__ctc_ddlcolumn_def__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -2720,8 +2720,8 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableDef, table_def), - &tc_db__tse_ddlalter_table_porp__descriptor, + offsetof(TcDb__CtcDDLAlterTableDef, table_def), + &tc_db__ctc_ddlalter_table_porp__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -2731,9 +2731,9 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr 9, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_MESSAGE, - offsetof(TcDb__TseDDLAlterTableDef, n_add_key_list), - offsetof(TcDb__TseDDLAlterTableDef, add_key_list), - &tc_db__tse_ddltable_key__descriptor, + offsetof(TcDb__CtcDDLAlterTableDef, n_add_key_list), + offsetof(TcDb__CtcDDLAlterTableDef, add_key_list), + &tc_db__ctc_ddltable_key__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -2743,9 +2743,9 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr 10, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_MESSAGE, - offsetof(TcDb__TseDDLAlterTableDef, n_drop_key_list), - offsetof(TcDb__TseDDLAlterTableDef, drop_key_list), - &tc_db__tse_ddlalter_table_drop_key__descriptor, + offsetof(TcDb__CtcDDLAlterTableDef, n_drop_key_list), + offsetof(TcDb__CtcDDLAlterTableDef, drop_key_list), + &tc_db__ctc_ddlalter_table_drop_key__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -2755,9 +2755,9 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr 11, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_MESSAGE, - offsetof(TcDb__TseDDLAlterTableDef, n_add_foreign_key_list), - offsetof(TcDb__TseDDLAlterTableDef, add_foreign_key_list), - &tc_db__tse_ddlforeign_key_def__descriptor, + offsetof(TcDb__CtcDDLAlterTableDef, n_add_foreign_key_list), + offsetof(TcDb__CtcDDLAlterTableDef, add_foreign_key_list), + &tc_db__ctc_ddlforeign_key_def__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -2768,7 +2768,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT64, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableDef, new_auto_increment_value), + offsetof(TcDb__CtcDDLAlterTableDef, new_auto_increment_value), NULL, NULL, 0, /* flags */ @@ -2780,7 +2780,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableDef, db_name), + offsetof(TcDb__CtcDDLAlterTableDef, db_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2792,7 +2792,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableDef, sql_str), + offsetof(TcDb__CtcDDLAlterTableDef, sql_str), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2803,9 +2803,9 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr 15, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_MESSAGE, - offsetof(TcDb__TseDDLAlterTableDef, n_alter_index_list), - offsetof(TcDb__TseDDLAlterTableDef, alter_index_list), - &tc_db__tse_ddlalter_index_def__descriptor, + offsetof(TcDb__CtcDDLAlterTableDef, n_alter_index_list), + offsetof(TcDb__CtcDDLAlterTableDef, alter_index_list), + &tc_db__ctc_ddlalter_index_def__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -2815,8 +2815,8 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr 16, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_STRING, - offsetof(TcDb__TseDDLAlterTableDef, n_drop_partition_names), - offsetof(TcDb__TseDDLAlterTableDef, drop_partition_names), + offsetof(TcDb__CtcDDLAlterTableDef, n_drop_partition_names), + offsetof(TcDb__CtcDDLAlterTableDef, drop_partition_names), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2827,9 +2827,9 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr 17, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_MESSAGE, - offsetof(TcDb__TseDDLAlterTableDef, n_add_part_list), - offsetof(TcDb__TseDDLAlterTableDef, add_part_list), - &tc_db__tse_ddlpartition_table_def__descriptor, + offsetof(TcDb__CtcDDLAlterTableDef, n_add_part_list), + offsetof(TcDb__CtcDDLAlterTableDef, add_part_list), + &tc_db__ctc_ddlpartition_table_def__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -2840,7 +2840,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableDef, hash_coalesce_count), + offsetof(TcDb__CtcDDLAlterTableDef, hash_coalesce_count), NULL, NULL, 0, /* flags */ @@ -2852,7 +2852,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_INT64, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableDef, systimestamp), + offsetof(TcDb__CtcDDLAlterTableDef, systimestamp), NULL, NULL, 0, /* flags */ @@ -2864,14 +2864,14 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_table_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterTableDef, tz_offset_utc), + offsetof(TcDb__CtcDDLAlterTableDef, tz_offset_utc), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddlalter_table_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddlalter_table_def__field_indices_by_name[] = { 0, /* field[0] = action */ 10, /* field[10] = add_foreign_key_list */ 8, /* field[8] = add_key_list */ @@ -2893,27 +2893,27 @@ static const unsigned tc_db__tse_ddlalter_table_def__field_indices_by_name[] = { 19, /* field[19] = tz_offset_UTC */ 2, /* field[2] = user */ }; -static const ProtobufCIntRange tc_db__tse_ddlalter_table_def__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddlalter_table_def__number_ranges[1 + 1] = { { 1, 0 }, { 0, 20 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddlalter_table_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddlalter_table_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLAlterTableDef", - "TseDDLAlterTableDef", - "TcDb__TseDDLAlterTableDef", + "tc_db.CtcDDLAlterTableDef", + "CtcDDLAlterTableDef", + "TcDb__CtcDDLAlterTableDef", "tc_db", - sizeof(TcDb__TseDDLAlterTableDef), + sizeof(TcDb__CtcDDLAlterTableDef), 20, - tc_db__tse_ddlalter_table_def__field_descriptors, - tc_db__tse_ddlalter_table_def__field_indices_by_name, - 1, tc_db__tse_ddlalter_table_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddlalter_table_def__init, + tc_db__ctc_ddlalter_table_def__field_descriptors, + tc_db__ctc_ddlalter_table_def__field_indices_by_name, + 1, tc_db__ctc_ddlalter_table_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddlalter_table_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddltruncate_table_def__field_descriptors[5] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddltruncate_table_def__field_descriptors[5] = { { "schema", @@ -2921,7 +2921,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltruncate_table_def__field_de PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTruncateTableDef, schema), + offsetof(TcDb__CtcDDLTruncateTableDef, schema), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2933,7 +2933,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltruncate_table_def__field_de PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTruncateTableDef, name), + offsetof(TcDb__CtcDDLTruncateTableDef, name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2945,7 +2945,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltruncate_table_def__field_de PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTruncateTableDef, db_name), + offsetof(TcDb__CtcDDLTruncateTableDef, db_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2957,7 +2957,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltruncate_table_def__field_de PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTruncateTableDef, sql_str), + offsetof(TcDb__CtcDDLTruncateTableDef, sql_str), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -2969,42 +2969,42 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltruncate_table_def__field_de PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTruncateTableDef, no_check_fk), + offsetof(TcDb__CtcDDLTruncateTableDef, no_check_fk), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddltruncate_table_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddltruncate_table_def__field_indices_by_name[] = { 2, /* field[2] = db_name */ 1, /* field[1] = name */ 4, /* field[4] = no_check_fk */ 0, /* field[0] = schema */ 3, /* field[3] = sql_str */ }; -static const ProtobufCIntRange tc_db__tse_ddltruncate_table_def__number_ranges[2 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddltruncate_table_def__number_ranges[2 + 1] = { { 1, 0 }, { 4, 2 }, { 0, 5 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddltruncate_table_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddltruncate_table_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLTruncateTableDef", - "TseDDLTruncateTableDef", - "TcDb__TseDDLTruncateTableDef", + "tc_db.CtcDDLTruncateTableDef", + "CtcDDLTruncateTableDef", + "TcDb__CtcDDLTruncateTableDef", "tc_db", - sizeof(TcDb__TseDDLTruncateTableDef), + sizeof(TcDb__CtcDDLTruncateTableDef), 5, - tc_db__tse_ddltruncate_table_def__field_descriptors, - tc_db__tse_ddltruncate_table_def__field_indices_by_name, - 2, tc_db__tse_ddltruncate_table_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddltruncate_table_def__init, + tc_db__ctc_ddltruncate_table_def__field_descriptors, + tc_db__ctc_ddltruncate_table_def__field_indices_by_name, + 2, tc_db__ctc_ddltruncate_table_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddltruncate_table_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddltruncate_table_partition_def__field_descriptors[9] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddltruncate_table_partition_def__field_descriptors[9] = { { "user", @@ -3012,7 +3012,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltruncate_table_partition_def PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTruncateTablePartitionDef, user), + offsetof(TcDb__CtcDDLTruncateTablePartitionDef, user), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3024,7 +3024,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltruncate_table_partition_def PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTruncateTablePartitionDef, db_name), + offsetof(TcDb__CtcDDLTruncateTablePartitionDef, db_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3036,7 +3036,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltruncate_table_partition_def PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTruncateTablePartitionDef, table_name), + offsetof(TcDb__CtcDDLTruncateTablePartitionDef, table_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3047,8 +3047,8 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltruncate_table_partition_def 4, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_STRING, - offsetof(TcDb__TseDDLTruncateTablePartitionDef, n_partition_name), - offsetof(TcDb__TseDDLTruncateTablePartitionDef, partition_name), + offsetof(TcDb__CtcDDLTruncateTablePartitionDef, n_partition_name), + offsetof(TcDb__CtcDDLTruncateTablePartitionDef, partition_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3059,8 +3059,8 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltruncate_table_partition_def 5, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_UINT32, - offsetof(TcDb__TseDDLTruncateTablePartitionDef, n_partition_id), - offsetof(TcDb__TseDDLTruncateTablePartitionDef, partition_id), + offsetof(TcDb__CtcDDLTruncateTablePartitionDef, n_partition_id), + offsetof(TcDb__CtcDDLTruncateTablePartitionDef, partition_id), NULL, NULL, 0 | PROTOBUF_C_FIELD_FLAG_PACKED, /* flags */ @@ -3072,7 +3072,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltruncate_table_partition_def PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTruncateTablePartitionDef, sql_str), + offsetof(TcDb__CtcDDLTruncateTablePartitionDef, sql_str), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3084,7 +3084,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltruncate_table_partition_def PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_BOOL, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLTruncateTablePartitionDef, is_subpart), + offsetof(TcDb__CtcDDLTruncateTablePartitionDef, is_subpart), NULL, NULL, 0, /* flags */ @@ -3095,8 +3095,8 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltruncate_table_partition_def 8, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_STRING, - offsetof(TcDb__TseDDLTruncateTablePartitionDef, n_subpartition_name), - offsetof(TcDb__TseDDLTruncateTablePartitionDef, subpartition_name), + offsetof(TcDb__CtcDDLTruncateTablePartitionDef, n_subpartition_name), + offsetof(TcDb__CtcDDLTruncateTablePartitionDef, subpartition_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3107,15 +3107,15 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddltruncate_table_partition_def 9, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_UINT32, - offsetof(TcDb__TseDDLTruncateTablePartitionDef, n_subpartition_id), - offsetof(TcDb__TseDDLTruncateTablePartitionDef, subpartition_id), + offsetof(TcDb__CtcDDLTruncateTablePartitionDef, n_subpartition_id), + offsetof(TcDb__CtcDDLTruncateTablePartitionDef, subpartition_id), NULL, NULL, 0 | PROTOBUF_C_FIELD_FLAG_PACKED, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddltruncate_table_partition_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddltruncate_table_partition_def__field_indices_by_name[] = { 1, /* field[1] = db_name */ 6, /* field[6] = is_subpart */ 4, /* field[4] = partition_id */ @@ -3126,27 +3126,27 @@ static const unsigned tc_db__tse_ddltruncate_table_partition_def__field_indices_ 2, /* field[2] = table_name */ 0, /* field[0] = user */ }; -static const ProtobufCIntRange tc_db__tse_ddltruncate_table_partition_def__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddltruncate_table_partition_def__number_ranges[1 + 1] = { { 1, 0 }, { 0, 9 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddltruncate_table_partition_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddltruncate_table_partition_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLTruncateTablePartitionDef", - "TseDDLTruncateTablePartitionDef", - "TcDb__TseDDLTruncateTablePartitionDef", + "tc_db.CtcDDLTruncateTablePartitionDef", + "CtcDDLTruncateTablePartitionDef", + "TcDb__CtcDDLTruncateTablePartitionDef", "tc_db", - sizeof(TcDb__TseDDLTruncateTablePartitionDef), + sizeof(TcDb__CtcDDLTruncateTablePartitionDef), 9, - tc_db__tse_ddltruncate_table_partition_def__field_descriptors, - tc_db__tse_ddltruncate_table_partition_def__field_indices_by_name, - 1, tc_db__tse_ddltruncate_table_partition_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddltruncate_table_partition_def__init, + tc_db__ctc_ddltruncate_table_partition_def__field_descriptors, + tc_db__ctc_ddltruncate_table_partition_def__field_indices_by_name, + 1, tc_db__ctc_ddltruncate_table_partition_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddltruncate_table_partition_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddlrename_table_def__field_descriptors[12] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddlrename_table_def__field_descriptors[12] = { { "action", @@ -3154,7 +3154,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlrename_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLRenameTableDef, action), + offsetof(TcDb__CtcDDLRenameTableDef, action), NULL, NULL, 0, /* flags */ @@ -3166,7 +3166,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlrename_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLRenameTableDef, options), + offsetof(TcDb__CtcDDLRenameTableDef, options), NULL, NULL, 0, /* flags */ @@ -3178,7 +3178,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlrename_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLRenameTableDef, user), + offsetof(TcDb__CtcDDLRenameTableDef, user), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3190,7 +3190,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlrename_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLRenameTableDef, new_user), + offsetof(TcDb__CtcDDLRenameTableDef, new_user), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3202,7 +3202,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlrename_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLRenameTableDef, new_table_name), + offsetof(TcDb__CtcDDLRenameTableDef, new_table_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3214,7 +3214,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlrename_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLRenameTableDef, new_db_name), + offsetof(TcDb__CtcDDLRenameTableDef, new_db_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3226,7 +3226,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlrename_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLRenameTableDef, old_table_name), + offsetof(TcDb__CtcDDLRenameTableDef, old_table_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3238,7 +3238,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlrename_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLRenameTableDef, old_db_name), + offsetof(TcDb__CtcDDLRenameTableDef, old_db_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3250,7 +3250,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlrename_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLRenameTableDef, current_db_name), + offsetof(TcDb__CtcDDLRenameTableDef, current_db_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3262,7 +3262,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlrename_table_def__field_desc PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLRenameTableDef, sql_str), + offsetof(TcDb__CtcDDLRenameTableDef, sql_str), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3273,8 +3273,8 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlrename_table_def__field_desc 11, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_STRING, - offsetof(TcDb__TseDDLRenameTableDef, n_old_constraints_name), - offsetof(TcDb__TseDDLRenameTableDef, old_constraints_name), + offsetof(TcDb__CtcDDLRenameTableDef, n_old_constraints_name), + offsetof(TcDb__CtcDDLRenameTableDef, old_constraints_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3285,15 +3285,15 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlrename_table_def__field_desc 12, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_STRING, - offsetof(TcDb__TseDDLRenameTableDef, n_new_constraints_name), - offsetof(TcDb__TseDDLRenameTableDef, new_constraints_name), + offsetof(TcDb__CtcDDLRenameTableDef, n_new_constraints_name), + offsetof(TcDb__CtcDDLRenameTableDef, new_constraints_name), NULL, &protobuf_c_empty_string, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddlrename_table_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddlrename_table_def__field_indices_by_name[] = { 0, /* field[0] = action */ 8, /* field[8] = current_db_name */ 11, /* field[11] = new_constraints_name */ @@ -3307,27 +3307,27 @@ static const unsigned tc_db__tse_ddlrename_table_def__field_indices_by_name[] = 9, /* field[9] = sql_str */ 2, /* field[2] = user */ }; -static const ProtobufCIntRange tc_db__tse_ddlrename_table_def__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddlrename_table_def__number_ranges[1 + 1] = { { 1, 0 }, { 0, 12 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddlrename_table_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddlrename_table_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLRenameTableDef", - "TseDDLRenameTableDef", - "TcDb__TseDDLRenameTableDef", + "tc_db.CtcDDLRenameTableDef", + "CtcDDLRenameTableDef", + "TcDb__CtcDDLRenameTableDef", "tc_db", - sizeof(TcDb__TseDDLRenameTableDef), + sizeof(TcDb__CtcDDLRenameTableDef), 12, - tc_db__tse_ddlrename_table_def__field_descriptors, - tc_db__tse_ddlrename_table_def__field_indices_by_name, - 1, tc_db__tse_ddlrename_table_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddlrename_table_def__init, + tc_db__ctc_ddlrename_table_def__field_descriptors, + tc_db__ctc_ddlrename_table_def__field_indices_by_name, + 1, tc_db__ctc_ddlrename_table_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddlrename_table_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddldrop_table_def__field_descriptors[6] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddldrop_table_def__field_descriptors[6] = { { "options", @@ -3335,7 +3335,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddldrop_table_def__field_descri PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLDropTableDef, options), + offsetof(TcDb__CtcDDLDropTableDef, options), NULL, NULL, 0, /* flags */ @@ -3347,7 +3347,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddldrop_table_def__field_descri PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLDropTableDef, user), + offsetof(TcDb__CtcDDLDropTableDef, user), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3359,7 +3359,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddldrop_table_def__field_descri PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLDropTableDef, name), + offsetof(TcDb__CtcDDLDropTableDef, name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3371,7 +3371,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddldrop_table_def__field_descri PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLDropTableDef, dbname_und), + offsetof(TcDb__CtcDDLDropTableDef, dbname_und), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3383,7 +3383,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddldrop_table_def__field_descri PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLDropTableDef, db_name), + offsetof(TcDb__CtcDDLDropTableDef, db_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3395,14 +3395,14 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddldrop_table_def__field_descri PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLDropTableDef, sql_str), + offsetof(TcDb__CtcDDLDropTableDef, sql_str), NULL, &protobuf_c_empty_string, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddldrop_table_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddldrop_table_def__field_indices_by_name[] = { 4, /* field[4] = db_name */ 3, /* field[3] = dbname_und */ 2, /* field[2] = name */ @@ -3410,27 +3410,27 @@ static const unsigned tc_db__tse_ddldrop_table_def__field_indices_by_name[] = { 5, /* field[5] = sql_str */ 1, /* field[1] = user */ }; -static const ProtobufCIntRange tc_db__tse_ddldrop_table_def__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddldrop_table_def__number_ranges[1 + 1] = { { 1, 0 }, { 0, 6 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddldrop_table_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddldrop_table_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLDropTableDef", - "TseDDLDropTableDef", - "TcDb__TseDDLDropTableDef", + "tc_db.CtcDDLDropTableDef", + "CtcDDLDropTableDef", + "TcDb__CtcDDLDropTableDef", "tc_db", - sizeof(TcDb__TseDDLDropTableDef), + sizeof(TcDb__CtcDDLDropTableDef), 6, - tc_db__tse_ddldrop_table_def__field_descriptors, - tc_db__tse_ddldrop_table_def__field_indices_by_name, - 1, tc_db__tse_ddldrop_table_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddldrop_table_def__init, + tc_db__ctc_ddldrop_table_def__field_descriptors, + tc_db__ctc_ddldrop_table_def__field_indices_by_name, + 1, tc_db__ctc_ddldrop_table_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddldrop_table_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_index_def__field_descriptors[6] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddlalter_index_def__field_descriptors[6] = { { "user", @@ -3438,7 +3438,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_index_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterIndexDef, user), + offsetof(TcDb__CtcDDLAlterIndexDef, user), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3450,7 +3450,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_index_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterIndexDef, name), + offsetof(TcDb__CtcDDLAlterIndexDef, name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3462,7 +3462,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_index_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterIndexDef, type), + offsetof(TcDb__CtcDDLAlterIndexDef, type), NULL, NULL, 0, /* flags */ @@ -3474,7 +3474,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_index_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterIndexDef, table), + offsetof(TcDb__CtcDDLAlterIndexDef, table), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3486,7 +3486,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_index_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterIndexDef, new_name), + offsetof(TcDb__CtcDDLAlterIndexDef, new_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3498,14 +3498,14 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_index_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterIndexDef, key_type), + offsetof(TcDb__CtcDDLAlterIndexDef, key_type), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddlalter_index_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddlalter_index_def__field_indices_by_name[] = { 5, /* field[5] = key_type */ 1, /* field[1] = name */ 4, /* field[4] = new_name */ @@ -3513,27 +3513,27 @@ static const unsigned tc_db__tse_ddlalter_index_def__field_indices_by_name[] = { 2, /* field[2] = type */ 0, /* field[0] = user */ }; -static const ProtobufCIntRange tc_db__tse_ddlalter_index_def__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddlalter_index_def__number_ranges[1 + 1] = { { 1, 0 }, { 0, 6 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddlalter_index_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddlalter_index_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLAlterIndexDef", - "TseDDLAlterIndexDef", - "TcDb__TseDDLAlterIndexDef", + "tc_db.CtcDDLAlterIndexDef", + "CtcDDLAlterIndexDef", + "TcDb__CtcDDLAlterIndexDef", "tc_db", - sizeof(TcDb__TseDDLAlterIndexDef), + sizeof(TcDb__CtcDDLAlterIndexDef), 6, - tc_db__tse_ddlalter_index_def__field_descriptors, - tc_db__tse_ddlalter_index_def__field_indices_by_name, - 1, tc_db__tse_ddlalter_index_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddlalter_index_def__init, + tc_db__ctc_ddlalter_index_def__field_descriptors, + tc_db__ctc_ddlalter_index_def__field_indices_by_name, + 1, tc_db__ctc_ddlalter_index_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddlalter_index_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddlauto_extend_def__field_descriptors[3] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddlauto_extend_def__field_descriptors[3] = { { "enabled", @@ -3541,7 +3541,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlauto_extend_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_BOOL, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAutoExtendDef, enabled), + offsetof(TcDb__CtcDDLAutoExtendDef, enabled), NULL, NULL, 0, /* flags */ @@ -3553,7 +3553,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlauto_extend_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT64, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAutoExtendDef, nextsize), + offsetof(TcDb__CtcDDLAutoExtendDef, nextsize), NULL, NULL, 0, /* flags */ @@ -3565,39 +3565,39 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlauto_extend_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_INT64, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAutoExtendDef, maxsize), + offsetof(TcDb__CtcDDLAutoExtendDef, maxsize), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddlauto_extend_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddlauto_extend_def__field_indices_by_name[] = { 0, /* field[0] = enabled */ 2, /* field[2] = maxsize */ 1, /* field[1] = nextsize */ }; -static const ProtobufCIntRange tc_db__tse_ddlauto_extend_def__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddlauto_extend_def__number_ranges[1 + 1] = { { 1, 0 }, { 0, 3 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddlauto_extend_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddlauto_extend_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLAutoExtendDef", - "TseDDLAutoExtendDef", - "TcDb__TseDDLAutoExtendDef", + "tc_db.CtcDDLAutoExtendDef", + "CtcDDLAutoExtendDef", + "TcDb__CtcDDLAutoExtendDef", "tc_db", - sizeof(TcDb__TseDDLAutoExtendDef), + sizeof(TcDb__CtcDDLAutoExtendDef), 3, - tc_db__tse_ddlauto_extend_def__field_descriptors, - tc_db__tse_ddlauto_extend_def__field_indices_by_name, - 1, tc_db__tse_ddlauto_extend_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddlauto_extend_def__init, + tc_db__ctc_ddlauto_extend_def__field_descriptors, + tc_db__ctc_ddlauto_extend_def__field_indices_by_name, + 1, tc_db__ctc_ddlauto_extend_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddlauto_extend_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddldata_file_def__field_descriptors[5] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddldata_file_def__field_descriptors[5] = { { "name", @@ -3605,7 +3605,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddldata_file_def__field_descrip PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLDataFileDef, name), + offsetof(TcDb__CtcDDLDataFileDef, name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3617,7 +3617,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddldata_file_def__field_descrip PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_INT64, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLDataFileDef, size), + offsetof(TcDb__CtcDDLDataFileDef, size), NULL, NULL, 0, /* flags */ @@ -3629,7 +3629,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddldata_file_def__field_descrip PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_INT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLDataFileDef, block_size), + offsetof(TcDb__CtcDDLDataFileDef, block_size), NULL, NULL, 0, /* flags */ @@ -3641,8 +3641,8 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddldata_file_def__field_descrip PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_MESSAGE, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLDataFileDef, autoextend), - &tc_db__tse_ddlauto_extend_def__descriptor, + offsetof(TcDb__CtcDDLDataFileDef, autoextend), + &tc_db__ctc_ddlauto_extend_def__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -3653,41 +3653,41 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddldata_file_def__field_descrip PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLDataFileDef, node_id), + offsetof(TcDb__CtcDDLDataFileDef, node_id), NULL, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddldata_file_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddldata_file_def__field_indices_by_name[] = { 3, /* field[3] = autoextend */ 2, /* field[2] = block_size */ 0, /* field[0] = name */ 4, /* field[4] = node_id */ 1, /* field[1] = size */ }; -static const ProtobufCIntRange tc_db__tse_ddldata_file_def__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddldata_file_def__number_ranges[1 + 1] = { { 1, 0 }, { 0, 5 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddldata_file_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddldata_file_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLDataFileDef", - "TseDDLDataFileDef", - "TcDb__TseDDLDataFileDef", + "tc_db.CtcDDLDataFileDef", + "CtcDDLDataFileDef", + "TcDb__CtcDDLDataFileDef", "tc_db", - sizeof(TcDb__TseDDLDataFileDef), + sizeof(TcDb__CtcDDLDataFileDef), 5, - tc_db__tse_ddldata_file_def__field_descriptors, - tc_db__tse_ddldata_file_def__field_indices_by_name, - 1, tc_db__tse_ddldata_file_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddldata_file_def__init, + tc_db__ctc_ddldata_file_def__field_descriptors, + tc_db__ctc_ddldata_file_def__field_indices_by_name, + 1, tc_db__ctc_ddldata_file_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddldata_file_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddlspace_def__field_descriptors[9] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddlspace_def__field_descriptors[9] = { { "name", @@ -3695,7 +3695,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlspace_def__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLSpaceDef, name), + offsetof(TcDb__CtcDDLSpaceDef, name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3707,7 +3707,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlspace_def__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLSpaceDef, type), + offsetof(TcDb__CtcDDLSpaceDef, type), NULL, NULL, 0, /* flags */ @@ -3719,7 +3719,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlspace_def__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_BOOL, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLSpaceDef, in_memory), + offsetof(TcDb__CtcDDLSpaceDef, in_memory), NULL, NULL, 0, /* flags */ @@ -3731,7 +3731,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlspace_def__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_BOOL, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLSpaceDef, autooffline), + offsetof(TcDb__CtcDDLSpaceDef, autooffline), NULL, NULL, 0, /* flags */ @@ -3743,7 +3743,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlspace_def__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLSpaceDef, extent_size), + offsetof(TcDb__CtcDDLSpaceDef, extent_size), NULL, NULL, 0, /* flags */ @@ -3754,9 +3754,9 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlspace_def__field_descriptors 6, PROTOBUF_C_LABEL_REPEATED, PROTOBUF_C_TYPE_MESSAGE, - offsetof(TcDb__TseDDLSpaceDef, n_datafiles_list), - offsetof(TcDb__TseDDLSpaceDef, datafiles_list), - &tc_db__tse_ddldata_file_def__descriptor, + offsetof(TcDb__CtcDDLSpaceDef, n_datafiles_list), + offsetof(TcDb__CtcDDLSpaceDef, datafiles_list), + &tc_db__ctc_ddldata_file_def__descriptor, NULL, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ @@ -3767,7 +3767,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlspace_def__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLSpaceDef, flags), + offsetof(TcDb__CtcDDLSpaceDef, flags), NULL, NULL, 0, /* flags */ @@ -3779,7 +3779,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlspace_def__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLSpaceDef, db_name), + offsetof(TcDb__CtcDDLSpaceDef, db_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3791,14 +3791,14 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlspace_def__field_descriptors PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLSpaceDef, sql_str), + offsetof(TcDb__CtcDDLSpaceDef, sql_str), NULL, &protobuf_c_empty_string, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddlspace_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddlspace_def__field_indices_by_name[] = { 3, /* field[3] = autooffline */ 5, /* field[5] = datafiles_list */ 7, /* field[7] = db_name */ @@ -3809,27 +3809,27 @@ static const unsigned tc_db__tse_ddlspace_def__field_indices_by_name[] = { 8, /* field[8] = sql_str */ 1, /* field[1] = type */ }; -static const ProtobufCIntRange tc_db__tse_ddlspace_def__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddlspace_def__number_ranges[1 + 1] = { { 1, 0 }, { 0, 9 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddlspace_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddlspace_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLSpaceDef", - "TseDDLSpaceDef", - "TcDb__TseDDLSpaceDef", + "tc_db.CtcDDLSpaceDef", + "CtcDDLSpaceDef", + "TcDb__CtcDDLSpaceDef", "tc_db", - sizeof(TcDb__TseDDLSpaceDef), + sizeof(TcDb__CtcDDLSpaceDef), 9, - tc_db__tse_ddlspace_def__field_descriptors, - tc_db__tse_ddlspace_def__field_indices_by_name, - 1, tc_db__tse_ddlspace_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddlspace_def__init, + tc_db__ctc_ddlspace_def__field_descriptors, + tc_db__ctc_ddlspace_def__field_indices_by_name, + 1, tc_db__ctc_ddlspace_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddlspace_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddldrop_space_def__field_descriptors[4] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddldrop_space_def__field_descriptors[4] = { { "obj_name", @@ -3837,7 +3837,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddldrop_space_def__field_descri PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLDropSpaceDef, obj_name), + offsetof(TcDb__CtcDDLDropSpaceDef, obj_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3849,7 +3849,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddldrop_space_def__field_descri PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLDropSpaceDef, option), + offsetof(TcDb__CtcDDLDropSpaceDef, option), NULL, NULL, 0, /* flags */ @@ -3861,7 +3861,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddldrop_space_def__field_descri PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLDropSpaceDef, db_name), + offsetof(TcDb__CtcDDLDropSpaceDef, db_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3873,40 +3873,40 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddldrop_space_def__field_descri PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLDropSpaceDef, sql_str), + offsetof(TcDb__CtcDDLDropSpaceDef, sql_str), NULL, &protobuf_c_empty_string, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddldrop_space_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddldrop_space_def__field_indices_by_name[] = { 2, /* field[2] = db_name */ 0, /* field[0] = obj_name */ 1, /* field[1] = option */ 3, /* field[3] = sql_str */ }; -static const ProtobufCIntRange tc_db__tse_ddldrop_space_def__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddldrop_space_def__number_ranges[1 + 1] = { { 1, 0 }, { 0, 4 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddldrop_space_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddldrop_space_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLDropSpaceDef", - "TseDDLDropSpaceDef", - "TcDb__TseDDLDropSpaceDef", + "tc_db.CtcDDLDropSpaceDef", + "CtcDDLDropSpaceDef", + "TcDb__CtcDDLDropSpaceDef", "tc_db", - sizeof(TcDb__TseDDLDropSpaceDef), + sizeof(TcDb__CtcDDLDropSpaceDef), 4, - tc_db__tse_ddldrop_space_def__field_descriptors, - tc_db__tse_ddldrop_space_def__field_indices_by_name, - 1, tc_db__tse_ddldrop_space_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddldrop_space_def__init, + tc_db__ctc_ddldrop_space_def__field_descriptors, + tc_db__ctc_ddldrop_space_def__field_indices_by_name, + 1, tc_db__ctc_ddldrop_space_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddldrop_space_def__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_space_def__field_descriptors[6] = +static const ProtobufCFieldDescriptor tc_db__ctc_ddlalter_space_def__field_descriptors[6] = { { "action", @@ -3914,7 +3914,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_space_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT32, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterSpaceDef, action), + offsetof(TcDb__CtcDDLAlterSpaceDef, action), NULL, NULL, 0, /* flags */ @@ -3926,7 +3926,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_space_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterSpaceDef, name), + offsetof(TcDb__CtcDDLAlterSpaceDef, name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3938,7 +3938,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_space_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterSpaceDef, new_name), + offsetof(TcDb__CtcDDLAlterSpaceDef, new_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3950,7 +3950,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_space_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_UINT64, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterSpaceDef, auto_extend_size), + offsetof(TcDb__CtcDDLAlterSpaceDef, auto_extend_size), NULL, NULL, 0, /* flags */ @@ -3962,7 +3962,7 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_space_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterSpaceDef, db_name), + offsetof(TcDb__CtcDDLAlterSpaceDef, db_name), NULL, &protobuf_c_empty_string, 0, /* flags */ @@ -3974,14 +3974,14 @@ static const ProtobufCFieldDescriptor tc_db__tse_ddlalter_space_def__field_descr PROTOBUF_C_LABEL_NONE, PROTOBUF_C_TYPE_STRING, 0, /* quantifier_offset */ - offsetof(TcDb__TseDDLAlterSpaceDef, sql_str), + offsetof(TcDb__CtcDDLAlterSpaceDef, sql_str), NULL, &protobuf_c_empty_string, 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, }; -static const unsigned tc_db__tse_ddlalter_space_def__field_indices_by_name[] = { +static const unsigned tc_db__ctc_ddlalter_space_def__field_indices_by_name[] = { 0, /* field[0] = action */ 3, /* field[3] = auto_extend_size */ 4, /* field[4] = db_name */ @@ -3989,23 +3989,23 @@ static const unsigned tc_db__tse_ddlalter_space_def__field_indices_by_name[] = { 2, /* field[2] = new_name */ 5, /* field[5] = sql_str */ }; -static const ProtobufCIntRange tc_db__tse_ddlalter_space_def__number_ranges[1 + 1] = +static const ProtobufCIntRange tc_db__ctc_ddlalter_space_def__number_ranges[1 + 1] = { { 1, 0 }, { 0, 6 } }; -const ProtobufCMessageDescriptor tc_db__tse_ddlalter_space_def__descriptor = +const ProtobufCMessageDescriptor tc_db__ctc_ddlalter_space_def__descriptor = { PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, - "tc_db.TseDDLAlterSpaceDef", - "TseDDLAlterSpaceDef", - "TcDb__TseDDLAlterSpaceDef", + "tc_db.CtcDDLAlterSpaceDef", + "CtcDDLAlterSpaceDef", + "TcDb__CtcDDLAlterSpaceDef", "tc_db", - sizeof(TcDb__TseDDLAlterSpaceDef), + sizeof(TcDb__CtcDDLAlterSpaceDef), 6, - tc_db__tse_ddlalter_space_def__field_descriptors, - tc_db__tse_ddlalter_space_def__field_indices_by_name, - 1, tc_db__tse_ddlalter_space_def__number_ranges, - (ProtobufCMessageInit) tc_db__tse_ddlalter_space_def__init, + tc_db__ctc_ddlalter_space_def__field_descriptors, + tc_db__ctc_ddlalter_space_def__field_indices_by_name, + 1, tc_db__ctc_ddlalter_space_def__number_ranges, + (ProtobufCMessageInit) tc_db__ctc_ddlalter_space_def__init, NULL,NULL,NULL /* reserved[123] */ }; diff --git a/storage/tianchi/protobuf/tc_db.pb-c.h b/storage/ctc/protobuf/tc_db.pb-c.h similarity index 42% rename from storage/tianchi/protobuf/tc_db.pb-c.h rename to storage/ctc/protobuf/tc_db.pb-c.h index 5d8e123..9a445a0 100644 --- a/storage/tianchi/protobuf/tc_db.pb-c.h +++ b/storage/ctc/protobuf/tc_db.pb-c.h @@ -15,31 +15,31 @@ PROTOBUF_C__BEGIN_DECLS #endif -typedef struct TcDb__TseDDLColumnDataTypeDef TcDb__TseDDLColumnDataTypeDef; -typedef struct TcDb__TseDDLColumnDef TcDb__TseDDLColumnDef; -typedef struct TcDb__TseDDLForeignKeyElementDef TcDb__TseDDLForeignKeyElementDef; -typedef struct TcDb__TseDDLForeignKeyDef TcDb__TseDDLForeignKeyDef; -typedef struct TcDb__TseDDLTableKeyPart TcDb__TseDDLTableKeyPart; -typedef struct TcDb__TseDDLTableKey TcDb__TseDDLTableKey; -typedef struct TcDb__TseMsgCommDef TcDb__TseMsgCommDef; -typedef struct TcDb__TseDDLPartitionTableDef TcDb__TseDDLPartitionTableDef; -typedef struct TcDb__TseDDLPartitionDef TcDb__TseDDLPartitionDef; -typedef struct TcDb__TseDDLCreateTableDef TcDb__TseDDLCreateTableDef; -typedef struct TcDb__TseDDLAlterTablePorp TcDb__TseDDLAlterTablePorp; -typedef struct TcDb__TseDDLAlterTableDrop TcDb__TseDDLAlterTableDrop; -typedef struct TcDb__TseDDLAlterTableDropKey TcDb__TseDDLAlterTableDropKey; -typedef struct TcDb__TseDDLAlterTableAlterColumn TcDb__TseDDLAlterTableAlterColumn; -typedef struct TcDb__TseDDLAlterTableDef TcDb__TseDDLAlterTableDef; -typedef struct TcDb__TseDDLTruncateTableDef TcDb__TseDDLTruncateTableDef; -typedef struct TcDb__TseDDLTruncateTablePartitionDef TcDb__TseDDLTruncateTablePartitionDef; -typedef struct TcDb__TseDDLRenameTableDef TcDb__TseDDLRenameTableDef; -typedef struct TcDb__TseDDLDropTableDef TcDb__TseDDLDropTableDef; -typedef struct TcDb__TseDDLAlterIndexDef TcDb__TseDDLAlterIndexDef; -typedef struct TcDb__TseDDLAutoExtendDef TcDb__TseDDLAutoExtendDef; -typedef struct TcDb__TseDDLDataFileDef TcDb__TseDDLDataFileDef; -typedef struct TcDb__TseDDLSpaceDef TcDb__TseDDLSpaceDef; -typedef struct TcDb__TseDDLDropSpaceDef TcDb__TseDDLDropSpaceDef; -typedef struct TcDb__TseDDLAlterSpaceDef TcDb__TseDDLAlterSpaceDef; +typedef struct TcDb__CtcDDLColumnDataTypeDef TcDb__CtcDDLColumnDataTypeDef; +typedef struct TcDb__CtcDDLColumnDef TcDb__CtcDDLColumnDef; +typedef struct TcDb__CtcDDLForeignKeyElementDef TcDb__CtcDDLForeignKeyElementDef; +typedef struct TcDb__CtcDDLForeignKeyDef TcDb__CtcDDLForeignKeyDef; +typedef struct TcDb__CtcDDLTableKeyPart TcDb__CtcDDLTableKeyPart; +typedef struct TcDb__CtcDDLTableKey TcDb__CtcDDLTableKey; +typedef struct TcDb__CtcMsgCommDef TcDb__CtcMsgCommDef; +typedef struct TcDb__CtcDDLPartitionTableDef TcDb__CtcDDLPartitionTableDef; +typedef struct TcDb__CtcDDLPartitionDef TcDb__CtcDDLPartitionDef; +typedef struct TcDb__CtcDDLCreateTableDef TcDb__CtcDDLCreateTableDef; +typedef struct TcDb__CtcDDLAlterTablePorp TcDb__CtcDDLAlterTablePorp; +typedef struct TcDb__CtcDDLAlterTableDrop TcDb__CtcDDLAlterTableDrop; +typedef struct TcDb__CtcDDLAlterTableDropKey TcDb__CtcDDLAlterTableDropKey; +typedef struct TcDb__CtcDDLAlterTableAlterColumn TcDb__CtcDDLAlterTableAlterColumn; +typedef struct TcDb__CtcDDLAlterTableDef TcDb__CtcDDLAlterTableDef; +typedef struct TcDb__CtcDDLTruncateTableDef TcDb__CtcDDLTruncateTableDef; +typedef struct TcDb__CtcDDLTruncateTablePartitionDef TcDb__CtcDDLTruncateTablePartitionDef; +typedef struct TcDb__CtcDDLRenameTableDef TcDb__CtcDDLRenameTableDef; +typedef struct TcDb__CtcDDLDropTableDef TcDb__CtcDDLDropTableDef; +typedef struct TcDb__CtcDDLAlterIndexDef TcDb__CtcDDLAlterIndexDef; +typedef struct TcDb__CtcDDLAutoExtendDef TcDb__CtcDDLAutoExtendDef; +typedef struct TcDb__CtcDDLDataFileDef TcDb__CtcDDLDataFileDef; +typedef struct TcDb__CtcDDLSpaceDef TcDb__CtcDDLSpaceDef; +typedef struct TcDb__CtcDDLDropSpaceDef TcDb__CtcDDLDropSpaceDef; +typedef struct TcDb__CtcDDLAlterSpaceDef TcDb__CtcDDLAlterSpaceDef; /* --- enums --- */ @@ -47,7 +47,7 @@ typedef struct TcDb__TseDDLAlterSpaceDef TcDb__TseDDLAlterSpaceDef; /* --- messages --- */ -struct TcDb__TseDDLColumnDataTypeDef +struct TcDb__CtcDDLColumnDataTypeDef { ProtobufCMessage base; /* @@ -63,16 +63,16 @@ struct TcDb__TseDDLColumnDataTypeDef int32_t scale; int32_t mysql_ori_datatype; }; -#define TC_DB__TSE_DDLCOLUMN_DATA_TYPE_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddlcolumn_data_type_def__descriptor) \ +#define TC_DB__CTC_DDLCOLUMN_DATA_TYPE_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddlcolumn_data_type_def__descriptor) \ , 0, 0, 0, 0, 0 } -struct TcDb__TseDDLColumnDef +struct TcDb__CtcDDLColumnDef { ProtobufCMessage base; char *name; - TcDb__TseDDLColumnDataTypeDef *datatype; + TcDb__CtcDDLColumnDataTypeDef *datatype; uint32_t is_option_set; uint32_t col_id; char *cons_name; @@ -81,7 +81,7 @@ struct TcDb__TseDDLColumnDef char *default_text; char *comment; /* - * tse_alter_column_alter_mode + * ctc_alter_column_alter_mode */ uint32_t alter_mode; uint64_t collate; @@ -89,23 +89,23 @@ struct TcDb__TseDDLColumnDef uint32_t is_unsigned; char *default_func_name; }; -#define TC_DB__TSE_DDLCOLUMN_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddlcolumn_def__descriptor) \ +#define TC_DB__CTC_DDLCOLUMN_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddlcolumn_def__descriptor) \ , (char *)protobuf_c_empty_string, NULL, 0, 0, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0, 0, (char *)protobuf_c_empty_string, 0, (char *)protobuf_c_empty_string } -struct TcDb__TseDDLForeignKeyElementDef +struct TcDb__CtcDDLForeignKeyElementDef { ProtobufCMessage base; char *src_column_name; char *ref_column_name; }; -#define TC_DB__TSE_DDLFOREIGN_KEY_ELEMENT_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddlforeign_key_element_def__descriptor) \ +#define TC_DB__CTC_DDLFOREIGN_KEY_ELEMENT_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddlforeign_key_element_def__descriptor) \ , (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string } -struct TcDb__TseDDLForeignKeyDef +struct TcDb__CtcDDLForeignKeyDef { ProtobufCMessage base; /* @@ -119,14 +119,14 @@ struct TcDb__TseDDLForeignKeyDef char *referenced_table_schema_name; char *referenced_table_name; size_t n_elements; - TcDb__TseDDLForeignKeyElementDef **elements; + TcDb__CtcDDLForeignKeyElementDef **elements; }; -#define TC_DB__TSE_DDLFOREIGN_KEY_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddlforeign_key_def__descriptor) \ +#define TC_DB__CTC_DDLFOREIGN_KEY_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddlforeign_key_def__descriptor) \ , (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0, 0, 0, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0,NULL } -struct TcDb__TseDDLTableKeyPart +struct TcDb__CtcDDLTableKeyPart { ProtobufCMessage base; /* @@ -143,12 +143,12 @@ struct TcDb__TseDDLTableKeyPart char *func_name; uint32_t is_unsigned; }; -#define TC_DB__TSE_DDLTABLE_KEY_PART__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddltable_key_part__descriptor) \ +#define TC_DB__CTC_DDLTABLE_KEY_PART__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddltable_key_part__descriptor) \ , (char *)protobuf_c_empty_string, 0, 0, 0, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0 } -struct TcDb__TseDDLTableKey +struct TcDb__CtcDDLTableKey { ProtobufCMessage base; /* @@ -159,25 +159,25 @@ struct TcDb__TseDDLTableKey char *name; char *space; /* - * tse_key_type + * ctc_key_type */ int32_t key_type; /* - * tse_ha_key_alg + * ctc_ha_key_alg */ int32_t algorithm; protobuf_c_boolean is_func; size_t n_columns; - TcDb__TseDDLTableKeyPart **columns; + TcDb__CtcDDLTableKeyPart **columns; protobuf_c_boolean is_constraint; protobuf_c_boolean is_dsc; }; -#define TC_DB__TSE_DDLTABLE_KEY__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddltable_key__descriptor) \ +#define TC_DB__CTC_DDLTABLE_KEY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddltable_key__descriptor) \ , (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0, 0, 0, 0,NULL, 0, 0 } -struct TcDb__TseMsgCommDef +struct TcDb__CtcMsgCommDef { ProtobufCMessage base; uint32_t inst_id; @@ -185,48 +185,48 @@ struct TcDb__TseMsgCommDef uint32_t handler_id; uint64_t sess_addr; }; -#define TC_DB__TSE_MSG_COMM_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_msg_comm_def__descriptor) \ +#define TC_DB__CTC_MSG_COMM_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_msg_comm_def__descriptor) \ , 0, 0, 0, 0 } -struct TcDb__TseDDLPartitionTableDef +struct TcDb__CtcDDLPartitionTableDef { ProtobufCMessage base; char *name; size_t n_subpart_table_list; - TcDb__TseDDLPartitionTableDef **subpart_table_list; + TcDb__CtcDDLPartitionTableDef **subpart_table_list; }; -#define TC_DB__TSE_DDLPARTITION_TABLE_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddlpartition_table_def__descriptor) \ +#define TC_DB__CTC_DDLPARTITION_TABLE_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddlpartition_table_def__descriptor) \ , (char *)protobuf_c_empty_string, 0,NULL } -struct TcDb__TseDDLPartitionDef +struct TcDb__CtcDDLPartitionDef { ProtobufCMessage base; uint32_t part_type; uint32_t subpart_type; size_t n_part_table_list; - TcDb__TseDDLPartitionTableDef **part_table_list; + TcDb__CtcDDLPartitionTableDef **part_table_list; }; -#define TC_DB__TSE_DDLPARTITION_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddlpartition_def__descriptor) \ +#define TC_DB__CTC_DDLPARTITION_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddlpartition_def__descriptor) \ , 0, 0, 0,NULL } -struct TcDb__TseDDLCreateTableDef +struct TcDb__CtcDDLCreateTableDef { ProtobufCMessage base; char *schema; char *name; char *space; size_t n_columns; - TcDb__TseDDLColumnDef **columns; + TcDb__CtcDDLColumnDef **columns; size_t n_fk_list; - TcDb__TseDDLForeignKeyDef **fk_list; + TcDb__CtcDDLForeignKeyDef **fk_list; size_t n_key_list; - TcDb__TseDDLTableKey **key_list; + TcDb__CtcDDLTableKey **key_list; /* *init auto incremnet value */ @@ -240,14 +240,14 @@ struct TcDb__TseDDLCreateTableDef char *alter_table_name; char *alter_db_name; protobuf_c_boolean is_create_as_select; - TcDb__TseDDLPartitionDef *partition_def; + TcDb__CtcDDLPartitionDef *partition_def; }; -#define TC_DB__TSE_DDLCREATE_TABLE_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddlcreate_table_def__descriptor) \ +#define TC_DB__CTC_DDLCREATE_TABLE_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddlcreate_table_def__descriptor) \ , (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0,NULL, 0,NULL, 0,NULL, 0, 0, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0, NULL } -struct TcDb__TseDDLAlterTablePorp +struct TcDb__CtcDDLAlterTablePorp { ProtobufCMessage base; /* @@ -260,48 +260,48 @@ struct TcDb__TseDDLAlterTablePorp uint32_t shrink_opt; int64_t serial_start; }; -#define TC_DB__TSE_DDLALTER_TABLE_PORP__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddlalter_table_porp__descriptor) \ +#define TC_DB__CTC_DDLALTER_TABLE_PORP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddlalter_table_porp__descriptor) \ , (char *)protobuf_c_empty_string, 0, 0, 0, 0, 0 } -struct TcDb__TseDDLAlterTableDrop +struct TcDb__CtcDDLAlterTableDrop { ProtobufCMessage base; char *name; /* - * tse_alter_table_drop_type + * ctc_alter_table_drop_type */ int32_t drop_type; /* - * tse_key_type + * ctc_key_type */ int32_t key_type; }; -#define TC_DB__TSE_DDLALTER_TABLE_DROP__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddlalter_table_drop__descriptor) \ +#define TC_DB__CTC_DDLALTER_TABLE_DROP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddlalter_table_drop__descriptor) \ , (char *)protobuf_c_empty_string, 0, 0 } -struct TcDb__TseDDLAlterTableDropKey +struct TcDb__CtcDDLAlterTableDropKey { ProtobufCMessage base; char *name; /* - * tse_alter_table_drop_type + * ctc_alter_table_drop_type */ int32_t drop_type; /* - * tse_key_type + * ctc_key_type */ int32_t key_type; }; -#define TC_DB__TSE_DDLALTER_TABLE_DROP_KEY__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddlalter_table_drop_key__descriptor) \ +#define TC_DB__CTC_DDLALTER_TABLE_DROP_KEY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddlalter_table_drop_key__descriptor) \ , (char *)protobuf_c_empty_string, 0, 0 } -struct TcDb__TseDDLAlterTableAlterColumn +struct TcDb__CtcDDLAlterTableAlterColumn { ProtobufCMessage base; char *name; @@ -318,12 +318,12 @@ struct TcDb__TseDDLAlterTableAlterColumn */ char *default_text; }; -#define TC_DB__TSE_DDLALTER_TABLE_ALTER_COLUMN__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddlalter_table_alter_column__descriptor) \ +#define TC_DB__CTC_DDLALTER_TABLE_ALTER_COLUMN__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddlalter_table_alter_column__descriptor) \ , (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0, 0, 0, 0, (char *)protobuf_c_empty_string } -struct TcDb__TseDDLAlterTableDef +struct TcDb__CtcDDLAlterTableDef { ProtobufCMessage base; /* @@ -338,43 +338,43 @@ struct TcDb__TseDDLAlterTableDef *Columns, keys and constraints to be dropped. */ size_t n_drop_list; - TcDb__TseDDLAlterTableDrop **drop_list; + TcDb__CtcDDLAlterTableDrop **drop_list; /* * Columns for ALTER_COLUMN_CHANGE_DEFAULT. */ size_t n_alter_list; - TcDb__TseDDLAlterTableAlterColumn **alter_list; + TcDb__CtcDDLAlterTableAlterColumn **alter_list; /* * List of columns, used by both CREATE and ALTER TABLE. */ size_t n_create_list; - TcDb__TseDDLColumnDef **create_list; - TcDb__TseDDLAlterTablePorp *table_def; + TcDb__CtcDDLColumnDef **create_list; + TcDb__CtcDDLAlterTablePorp *table_def; size_t n_add_key_list; - TcDb__TseDDLTableKey **add_key_list; + TcDb__CtcDDLTableKey **add_key_list; size_t n_drop_key_list; - TcDb__TseDDLAlterTableDropKey **drop_key_list; + TcDb__CtcDDLAlterTableDropKey **drop_key_list; size_t n_add_foreign_key_list; - TcDb__TseDDLForeignKeyDef **add_foreign_key_list; + TcDb__CtcDDLForeignKeyDef **add_foreign_key_list; uint64_t new_auto_increment_value; char *db_name; char *sql_str; size_t n_alter_index_list; - TcDb__TseDDLAlterIndexDef **alter_index_list; + TcDb__CtcDDLAlterIndexDef **alter_index_list; size_t n_drop_partition_names; char **drop_partition_names; size_t n_add_part_list; - TcDb__TseDDLPartitionTableDef **add_part_list; + TcDb__CtcDDLPartitionTableDef **add_part_list; uint32_t hash_coalesce_count; int64_t systimestamp; int32_t tz_offset_utc; }; -#define TC_DB__TSE_DDLALTER_TABLE_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddlalter_table_def__descriptor) \ +#define TC_DB__CTC_DDLALTER_TABLE_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddlalter_table_def__descriptor) \ , 0, 0, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0,NULL, 0,NULL, 0,NULL, NULL, 0,NULL, 0,NULL, 0,NULL, 0, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0,NULL, 0,NULL, 0,NULL, 0, 0, 0 } -struct TcDb__TseDDLTruncateTableDef +struct TcDb__CtcDDLTruncateTableDef { ProtobufCMessage base; char *schema; @@ -383,12 +383,12 @@ struct TcDb__TseDDLTruncateTableDef char *sql_str; uint32_t no_check_fk; }; -#define TC_DB__TSE_DDLTRUNCATE_TABLE_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddltruncate_table_def__descriptor) \ +#define TC_DB__CTC_DDLTRUNCATE_TABLE_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddltruncate_table_def__descriptor) \ , (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0 } -struct TcDb__TseDDLTruncateTablePartitionDef +struct TcDb__CtcDDLTruncateTablePartitionDef { ProtobufCMessage base; char *user; @@ -405,12 +405,12 @@ struct TcDb__TseDDLTruncateTablePartitionDef size_t n_subpartition_id; uint32_t *subpartition_id; }; -#define TC_DB__TSE_DDLTRUNCATE_TABLE_PARTITION_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddltruncate_table_partition_def__descriptor) \ +#define TC_DB__CTC_DDLTRUNCATE_TABLE_PARTITION_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddltruncate_table_partition_def__descriptor) \ , (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0,NULL, 0,NULL, (char *)protobuf_c_empty_string, 0, 0,NULL, 0,NULL } -struct TcDb__TseDDLRenameTableDef +struct TcDb__CtcDDLRenameTableDef { ProtobufCMessage base; /* @@ -431,12 +431,12 @@ struct TcDb__TseDDLRenameTableDef size_t n_new_constraints_name; char **new_constraints_name; }; -#define TC_DB__TSE_DDLRENAME_TABLE_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddlrename_table_def__descriptor) \ +#define TC_DB__CTC_DDLRENAME_TABLE_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddlrename_table_def__descriptor) \ , 0, 0, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0,NULL, 0,NULL } -struct TcDb__TseDDLDropTableDef +struct TcDb__CtcDDLDropTableDef { ProtobufCMessage base; uint32_t options; @@ -446,12 +446,12 @@ struct TcDb__TseDDLDropTableDef char *db_name; char *sql_str; }; -#define TC_DB__TSE_DDLDROP_TABLE_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddldrop_table_def__descriptor) \ +#define TC_DB__CTC_DDLDROP_TABLE_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddldrop_table_def__descriptor) \ , 0, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string } -struct TcDb__TseDDLAlterIndexDef +struct TcDb__CtcDDLAlterIndexDef { ProtobufCMessage base; char *user; @@ -463,28 +463,28 @@ struct TcDb__TseDDLAlterIndexDef char *table; char *new_name; /* - * tse_key_type + * ctc_key_type */ int32_t key_type; }; -#define TC_DB__TSE_DDLALTER_INDEX_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddlalter_index_def__descriptor) \ +#define TC_DB__CTC_DDLALTER_INDEX_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddlalter_index_def__descriptor) \ , (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0 } -struct TcDb__TseDDLAutoExtendDef +struct TcDb__CtcDDLAutoExtendDef { ProtobufCMessage base; protobuf_c_boolean enabled; uint64_t nextsize; int64_t maxsize; }; -#define TC_DB__TSE_DDLAUTO_EXTEND_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddlauto_extend_def__descriptor) \ +#define TC_DB__CTC_DDLAUTO_EXTEND_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddlauto_extend_def__descriptor) \ , 0, 0, 0 } -struct TcDb__TseDDLDataFileDef +struct TcDb__CtcDDLDataFileDef { ProtobufCMessage base; char *name; @@ -496,15 +496,15 @@ struct TcDb__TseDDLDataFileDef /* * the data of the autoextend property of the device */ - TcDb__TseDDLAutoExtendDef *autoextend; + TcDb__CtcDDLAutoExtendDef *autoextend; uint32_t node_id; }; -#define TC_DB__TSE_DDLDATA_FILE_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddldata_file_def__descriptor) \ +#define TC_DB__CTC_DDLDATA_FILE_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddldata_file_def__descriptor) \ , (char *)protobuf_c_empty_string, 0, 0, NULL, 0 } -struct TcDb__TseDDLSpaceDef +struct TcDb__CtcDDLSpaceDef { ProtobufCMessage base; /* @@ -519,17 +519,17 @@ struct TcDb__TseDDLSpaceDef protobuf_c_boolean autooffline; uint32_t extent_size; size_t n_datafiles_list; - TcDb__TseDDLDataFileDef **datafiles_list; + TcDb__CtcDDLDataFileDef **datafiles_list; uint32_t flags; char *db_name; char *sql_str; }; -#define TC_DB__TSE_DDLSPACE_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddlspace_def__descriptor) \ +#define TC_DB__CTC_DDLSPACE_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddlspace_def__descriptor) \ , (char *)protobuf_c_empty_string, 0, 0, 0, 0, 0,NULL, 0, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string } -struct TcDb__TseDDLDropSpaceDef +struct TcDb__CtcDDLDropSpaceDef { ProtobufCMessage base; char *obj_name; @@ -537,12 +537,12 @@ struct TcDb__TseDDLDropSpaceDef char *db_name; char *sql_str; }; -#define TC_DB__TSE_DDLDROP_SPACE_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddldrop_space_def__descriptor) \ +#define TC_DB__CTC_DDLDROP_SPACE_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddldrop_space_def__descriptor) \ , (char *)protobuf_c_empty_string, 0, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string } -struct TcDb__TseDDLAlterSpaceDef +struct TcDb__CtcDDLAlterSpaceDef { ProtobufCMessage base; uint32_t action; @@ -558,562 +558,562 @@ struct TcDb__TseDDLAlterSpaceDef char *db_name; char *sql_str; }; -#define TC_DB__TSE_DDLALTER_SPACE_DEF__INIT \ - { PROTOBUF_C_MESSAGE_INIT (&tc_db__tse_ddlalter_space_def__descriptor) \ +#define TC_DB__CTC_DDLALTER_SPACE_DEF__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&tc_db__ctc_ddlalter_space_def__descriptor) \ , 0, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string } -/* TcDb__TseDDLColumnDataTypeDef methods */ -void tc_db__tse_ddlcolumn_data_type_def__init - (TcDb__TseDDLColumnDataTypeDef *message); -size_t tc_db__tse_ddlcolumn_data_type_def__get_packed_size - (const TcDb__TseDDLColumnDataTypeDef *message); -size_t tc_db__tse_ddlcolumn_data_type_def__pack - (const TcDb__TseDDLColumnDataTypeDef *message, +/* TcDb__CtcDDLColumnDataTypeDef methods */ +void tc_db__ctc_ddlcolumn_data_type_def__init + (TcDb__CtcDDLColumnDataTypeDef *message); +size_t tc_db__ctc_ddlcolumn_data_type_def__get_packed_size + (const TcDb__CtcDDLColumnDataTypeDef *message); +size_t tc_db__ctc_ddlcolumn_data_type_def__pack + (const TcDb__CtcDDLColumnDataTypeDef *message, uint8_t *out); -size_t tc_db__tse_ddlcolumn_data_type_def__pack_to_buffer - (const TcDb__TseDDLColumnDataTypeDef *message, +size_t tc_db__ctc_ddlcolumn_data_type_def__pack_to_buffer + (const TcDb__CtcDDLColumnDataTypeDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLColumnDataTypeDef * - tc_db__tse_ddlcolumn_data_type_def__unpack +TcDb__CtcDDLColumnDataTypeDef * + tc_db__ctc_ddlcolumn_data_type_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddlcolumn_data_type_def__free_unpacked - (TcDb__TseDDLColumnDataTypeDef *message, +void tc_db__ctc_ddlcolumn_data_type_def__free_unpacked + (TcDb__CtcDDLColumnDataTypeDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLColumnDef methods */ -void tc_db__tse_ddlcolumn_def__init - (TcDb__TseDDLColumnDef *message); -size_t tc_db__tse_ddlcolumn_def__get_packed_size - (const TcDb__TseDDLColumnDef *message); -size_t tc_db__tse_ddlcolumn_def__pack - (const TcDb__TseDDLColumnDef *message, +/* TcDb__CtcDDLColumnDef methods */ +void tc_db__ctc_ddlcolumn_def__init + (TcDb__CtcDDLColumnDef *message); +size_t tc_db__ctc_ddlcolumn_def__get_packed_size + (const TcDb__CtcDDLColumnDef *message); +size_t tc_db__ctc_ddlcolumn_def__pack + (const TcDb__CtcDDLColumnDef *message, uint8_t *out); -size_t tc_db__tse_ddlcolumn_def__pack_to_buffer - (const TcDb__TseDDLColumnDef *message, +size_t tc_db__ctc_ddlcolumn_def__pack_to_buffer + (const TcDb__CtcDDLColumnDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLColumnDef * - tc_db__tse_ddlcolumn_def__unpack +TcDb__CtcDDLColumnDef * + tc_db__ctc_ddlcolumn_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddlcolumn_def__free_unpacked - (TcDb__TseDDLColumnDef *message, +void tc_db__ctc_ddlcolumn_def__free_unpacked + (TcDb__CtcDDLColumnDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLForeignKeyElementDef methods */ -void tc_db__tse_ddlforeign_key_element_def__init - (TcDb__TseDDLForeignKeyElementDef *message); -size_t tc_db__tse_ddlforeign_key_element_def__get_packed_size - (const TcDb__TseDDLForeignKeyElementDef *message); -size_t tc_db__tse_ddlforeign_key_element_def__pack - (const TcDb__TseDDLForeignKeyElementDef *message, +/* TcDb__CtcDDLForeignKeyElementDef methods */ +void tc_db__ctc_ddlforeign_key_element_def__init + (TcDb__CtcDDLForeignKeyElementDef *message); +size_t tc_db__ctc_ddlforeign_key_element_def__get_packed_size + (const TcDb__CtcDDLForeignKeyElementDef *message); +size_t tc_db__ctc_ddlforeign_key_element_def__pack + (const TcDb__CtcDDLForeignKeyElementDef *message, uint8_t *out); -size_t tc_db__tse_ddlforeign_key_element_def__pack_to_buffer - (const TcDb__TseDDLForeignKeyElementDef *message, +size_t tc_db__ctc_ddlforeign_key_element_def__pack_to_buffer + (const TcDb__CtcDDLForeignKeyElementDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLForeignKeyElementDef * - tc_db__tse_ddlforeign_key_element_def__unpack +TcDb__CtcDDLForeignKeyElementDef * + tc_db__ctc_ddlforeign_key_element_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddlforeign_key_element_def__free_unpacked - (TcDb__TseDDLForeignKeyElementDef *message, +void tc_db__ctc_ddlforeign_key_element_def__free_unpacked + (TcDb__CtcDDLForeignKeyElementDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLForeignKeyDef methods */ -void tc_db__tse_ddlforeign_key_def__init - (TcDb__TseDDLForeignKeyDef *message); -size_t tc_db__tse_ddlforeign_key_def__get_packed_size - (const TcDb__TseDDLForeignKeyDef *message); -size_t tc_db__tse_ddlforeign_key_def__pack - (const TcDb__TseDDLForeignKeyDef *message, +/* TcDb__CtcDDLForeignKeyDef methods */ +void tc_db__ctc_ddlforeign_key_def__init + (TcDb__CtcDDLForeignKeyDef *message); +size_t tc_db__ctc_ddlforeign_key_def__get_packed_size + (const TcDb__CtcDDLForeignKeyDef *message); +size_t tc_db__ctc_ddlforeign_key_def__pack + (const TcDb__CtcDDLForeignKeyDef *message, uint8_t *out); -size_t tc_db__tse_ddlforeign_key_def__pack_to_buffer - (const TcDb__TseDDLForeignKeyDef *message, +size_t tc_db__ctc_ddlforeign_key_def__pack_to_buffer + (const TcDb__CtcDDLForeignKeyDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLForeignKeyDef * - tc_db__tse_ddlforeign_key_def__unpack +TcDb__CtcDDLForeignKeyDef * + tc_db__ctc_ddlforeign_key_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddlforeign_key_def__free_unpacked - (TcDb__TseDDLForeignKeyDef *message, +void tc_db__ctc_ddlforeign_key_def__free_unpacked + (TcDb__CtcDDLForeignKeyDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLTableKeyPart methods */ -void tc_db__tse_ddltable_key_part__init - (TcDb__TseDDLTableKeyPart *message); -size_t tc_db__tse_ddltable_key_part__get_packed_size - (const TcDb__TseDDLTableKeyPart *message); -size_t tc_db__tse_ddltable_key_part__pack - (const TcDb__TseDDLTableKeyPart *message, +/* TcDb__CtcDDLTableKeyPart methods */ +void tc_db__ctc_ddltable_key_part__init + (TcDb__CtcDDLTableKeyPart *message); +size_t tc_db__ctc_ddltable_key_part__get_packed_size + (const TcDb__CtcDDLTableKeyPart *message); +size_t tc_db__ctc_ddltable_key_part__pack + (const TcDb__CtcDDLTableKeyPart *message, uint8_t *out); -size_t tc_db__tse_ddltable_key_part__pack_to_buffer - (const TcDb__TseDDLTableKeyPart *message, +size_t tc_db__ctc_ddltable_key_part__pack_to_buffer + (const TcDb__CtcDDLTableKeyPart *message, ProtobufCBuffer *buffer); -TcDb__TseDDLTableKeyPart * - tc_db__tse_ddltable_key_part__unpack +TcDb__CtcDDLTableKeyPart * + tc_db__ctc_ddltable_key_part__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddltable_key_part__free_unpacked - (TcDb__TseDDLTableKeyPart *message, +void tc_db__ctc_ddltable_key_part__free_unpacked + (TcDb__CtcDDLTableKeyPart *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLTableKey methods */ -void tc_db__tse_ddltable_key__init - (TcDb__TseDDLTableKey *message); -size_t tc_db__tse_ddltable_key__get_packed_size - (const TcDb__TseDDLTableKey *message); -size_t tc_db__tse_ddltable_key__pack - (const TcDb__TseDDLTableKey *message, +/* TcDb__CtcDDLTableKey methods */ +void tc_db__ctc_ddltable_key__init + (TcDb__CtcDDLTableKey *message); +size_t tc_db__ctc_ddltable_key__get_packed_size + (const TcDb__CtcDDLTableKey *message); +size_t tc_db__ctc_ddltable_key__pack + (const TcDb__CtcDDLTableKey *message, uint8_t *out); -size_t tc_db__tse_ddltable_key__pack_to_buffer - (const TcDb__TseDDLTableKey *message, +size_t tc_db__ctc_ddltable_key__pack_to_buffer + (const TcDb__CtcDDLTableKey *message, ProtobufCBuffer *buffer); -TcDb__TseDDLTableKey * - tc_db__tse_ddltable_key__unpack +TcDb__CtcDDLTableKey * + tc_db__ctc_ddltable_key__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddltable_key__free_unpacked - (TcDb__TseDDLTableKey *message, +void tc_db__ctc_ddltable_key__free_unpacked + (TcDb__CtcDDLTableKey *message, ProtobufCAllocator *allocator); -/* TcDb__TseMsgCommDef methods */ -void tc_db__tse_msg_comm_def__init - (TcDb__TseMsgCommDef *message); -size_t tc_db__tse_msg_comm_def__get_packed_size - (const TcDb__TseMsgCommDef *message); -size_t tc_db__tse_msg_comm_def__pack - (const TcDb__TseMsgCommDef *message, +/* TcDb__CtcMsgCommDef methods */ +void tc_db__ctc_msg_comm_def__init + (TcDb__CtcMsgCommDef *message); +size_t tc_db__ctc_msg_comm_def__get_packed_size + (const TcDb__CtcMsgCommDef *message); +size_t tc_db__ctc_msg_comm_def__pack + (const TcDb__CtcMsgCommDef *message, uint8_t *out); -size_t tc_db__tse_msg_comm_def__pack_to_buffer - (const TcDb__TseMsgCommDef *message, +size_t tc_db__ctc_msg_comm_def__pack_to_buffer + (const TcDb__CtcMsgCommDef *message, ProtobufCBuffer *buffer); -TcDb__TseMsgCommDef * - tc_db__tse_msg_comm_def__unpack +TcDb__CtcMsgCommDef * + tc_db__ctc_msg_comm_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_msg_comm_def__free_unpacked - (TcDb__TseMsgCommDef *message, +void tc_db__ctc_msg_comm_def__free_unpacked + (TcDb__CtcMsgCommDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLPartitionTableDef methods */ -void tc_db__tse_ddlpartition_table_def__init - (TcDb__TseDDLPartitionTableDef *message); -size_t tc_db__tse_ddlpartition_table_def__get_packed_size - (const TcDb__TseDDLPartitionTableDef *message); -size_t tc_db__tse_ddlpartition_table_def__pack - (const TcDb__TseDDLPartitionTableDef *message, +/* TcDb__CtcDDLPartitionTableDef methods */ +void tc_db__ctc_ddlpartition_table_def__init + (TcDb__CtcDDLPartitionTableDef *message); +size_t tc_db__ctc_ddlpartition_table_def__get_packed_size + (const TcDb__CtcDDLPartitionTableDef *message); +size_t tc_db__ctc_ddlpartition_table_def__pack + (const TcDb__CtcDDLPartitionTableDef *message, uint8_t *out); -size_t tc_db__tse_ddlpartition_table_def__pack_to_buffer - (const TcDb__TseDDLPartitionTableDef *message, +size_t tc_db__ctc_ddlpartition_table_def__pack_to_buffer + (const TcDb__CtcDDLPartitionTableDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLPartitionTableDef * - tc_db__tse_ddlpartition_table_def__unpack +TcDb__CtcDDLPartitionTableDef * + tc_db__ctc_ddlpartition_table_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddlpartition_table_def__free_unpacked - (TcDb__TseDDLPartitionTableDef *message, +void tc_db__ctc_ddlpartition_table_def__free_unpacked + (TcDb__CtcDDLPartitionTableDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLPartitionDef methods */ -void tc_db__tse_ddlpartition_def__init - (TcDb__TseDDLPartitionDef *message); -size_t tc_db__tse_ddlpartition_def__get_packed_size - (const TcDb__TseDDLPartitionDef *message); -size_t tc_db__tse_ddlpartition_def__pack - (const TcDb__TseDDLPartitionDef *message, +/* TcDb__CtcDDLPartitionDef methods */ +void tc_db__ctc_ddlpartition_def__init + (TcDb__CtcDDLPartitionDef *message); +size_t tc_db__ctc_ddlpartition_def__get_packed_size + (const TcDb__CtcDDLPartitionDef *message); +size_t tc_db__ctc_ddlpartition_def__pack + (const TcDb__CtcDDLPartitionDef *message, uint8_t *out); -size_t tc_db__tse_ddlpartition_def__pack_to_buffer - (const TcDb__TseDDLPartitionDef *message, +size_t tc_db__ctc_ddlpartition_def__pack_to_buffer + (const TcDb__CtcDDLPartitionDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLPartitionDef * - tc_db__tse_ddlpartition_def__unpack +TcDb__CtcDDLPartitionDef * + tc_db__ctc_ddlpartition_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddlpartition_def__free_unpacked - (TcDb__TseDDLPartitionDef *message, +void tc_db__ctc_ddlpartition_def__free_unpacked + (TcDb__CtcDDLPartitionDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLCreateTableDef methods */ -void tc_db__tse_ddlcreate_table_def__init - (TcDb__TseDDLCreateTableDef *message); -size_t tc_db__tse_ddlcreate_table_def__get_packed_size - (const TcDb__TseDDLCreateTableDef *message); -size_t tc_db__tse_ddlcreate_table_def__pack - (const TcDb__TseDDLCreateTableDef *message, +/* TcDb__CtcDDLCreateTableDef methods */ +void tc_db__ctc_ddlcreate_table_def__init + (TcDb__CtcDDLCreateTableDef *message); +size_t tc_db__ctc_ddlcreate_table_def__get_packed_size + (const TcDb__CtcDDLCreateTableDef *message); +size_t tc_db__ctc_ddlcreate_table_def__pack + (const TcDb__CtcDDLCreateTableDef *message, uint8_t *out); -size_t tc_db__tse_ddlcreate_table_def__pack_to_buffer - (const TcDb__TseDDLCreateTableDef *message, +size_t tc_db__ctc_ddlcreate_table_def__pack_to_buffer + (const TcDb__CtcDDLCreateTableDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLCreateTableDef * - tc_db__tse_ddlcreate_table_def__unpack +TcDb__CtcDDLCreateTableDef * + tc_db__ctc_ddlcreate_table_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddlcreate_table_def__free_unpacked - (TcDb__TseDDLCreateTableDef *message, +void tc_db__ctc_ddlcreate_table_def__free_unpacked + (TcDb__CtcDDLCreateTableDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLAlterTablePorp methods */ -void tc_db__tse_ddlalter_table_porp__init - (TcDb__TseDDLAlterTablePorp *message); -size_t tc_db__tse_ddlalter_table_porp__get_packed_size - (const TcDb__TseDDLAlterTablePorp *message); -size_t tc_db__tse_ddlalter_table_porp__pack - (const TcDb__TseDDLAlterTablePorp *message, +/* TcDb__CtcDDLAlterTablePorp methods */ +void tc_db__ctc_ddlalter_table_porp__init + (TcDb__CtcDDLAlterTablePorp *message); +size_t tc_db__ctc_ddlalter_table_porp__get_packed_size + (const TcDb__CtcDDLAlterTablePorp *message); +size_t tc_db__ctc_ddlalter_table_porp__pack + (const TcDb__CtcDDLAlterTablePorp *message, uint8_t *out); -size_t tc_db__tse_ddlalter_table_porp__pack_to_buffer - (const TcDb__TseDDLAlterTablePorp *message, +size_t tc_db__ctc_ddlalter_table_porp__pack_to_buffer + (const TcDb__CtcDDLAlterTablePorp *message, ProtobufCBuffer *buffer); -TcDb__TseDDLAlterTablePorp * - tc_db__tse_ddlalter_table_porp__unpack +TcDb__CtcDDLAlterTablePorp * + tc_db__ctc_ddlalter_table_porp__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddlalter_table_porp__free_unpacked - (TcDb__TseDDLAlterTablePorp *message, +void tc_db__ctc_ddlalter_table_porp__free_unpacked + (TcDb__CtcDDLAlterTablePorp *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLAlterTableDrop methods */ -void tc_db__tse_ddlalter_table_drop__init - (TcDb__TseDDLAlterTableDrop *message); -size_t tc_db__tse_ddlalter_table_drop__get_packed_size - (const TcDb__TseDDLAlterTableDrop *message); -size_t tc_db__tse_ddlalter_table_drop__pack - (const TcDb__TseDDLAlterTableDrop *message, +/* TcDb__CtcDDLAlterTableDrop methods */ +void tc_db__ctc_ddlalter_table_drop__init + (TcDb__CtcDDLAlterTableDrop *message); +size_t tc_db__ctc_ddlalter_table_drop__get_packed_size + (const TcDb__CtcDDLAlterTableDrop *message); +size_t tc_db__ctc_ddlalter_table_drop__pack + (const TcDb__CtcDDLAlterTableDrop *message, uint8_t *out); -size_t tc_db__tse_ddlalter_table_drop__pack_to_buffer - (const TcDb__TseDDLAlterTableDrop *message, +size_t tc_db__ctc_ddlalter_table_drop__pack_to_buffer + (const TcDb__CtcDDLAlterTableDrop *message, ProtobufCBuffer *buffer); -TcDb__TseDDLAlterTableDrop * - tc_db__tse_ddlalter_table_drop__unpack +TcDb__CtcDDLAlterTableDrop * + tc_db__ctc_ddlalter_table_drop__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddlalter_table_drop__free_unpacked - (TcDb__TseDDLAlterTableDrop *message, +void tc_db__ctc_ddlalter_table_drop__free_unpacked + (TcDb__CtcDDLAlterTableDrop *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLAlterTableDropKey methods */ -void tc_db__tse_ddlalter_table_drop_key__init - (TcDb__TseDDLAlterTableDropKey *message); -size_t tc_db__tse_ddlalter_table_drop_key__get_packed_size - (const TcDb__TseDDLAlterTableDropKey *message); -size_t tc_db__tse_ddlalter_table_drop_key__pack - (const TcDb__TseDDLAlterTableDropKey *message, +/* TcDb__CtcDDLAlterTableDropKey methods */ +void tc_db__ctc_ddlalter_table_drop_key__init + (TcDb__CtcDDLAlterTableDropKey *message); +size_t tc_db__ctc_ddlalter_table_drop_key__get_packed_size + (const TcDb__CtcDDLAlterTableDropKey *message); +size_t tc_db__ctc_ddlalter_table_drop_key__pack + (const TcDb__CtcDDLAlterTableDropKey *message, uint8_t *out); -size_t tc_db__tse_ddlalter_table_drop_key__pack_to_buffer - (const TcDb__TseDDLAlterTableDropKey *message, +size_t tc_db__ctc_ddlalter_table_drop_key__pack_to_buffer + (const TcDb__CtcDDLAlterTableDropKey *message, ProtobufCBuffer *buffer); -TcDb__TseDDLAlterTableDropKey * - tc_db__tse_ddlalter_table_drop_key__unpack +TcDb__CtcDDLAlterTableDropKey * + tc_db__ctc_ddlalter_table_drop_key__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddlalter_table_drop_key__free_unpacked - (TcDb__TseDDLAlterTableDropKey *message, +void tc_db__ctc_ddlalter_table_drop_key__free_unpacked + (TcDb__CtcDDLAlterTableDropKey *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLAlterTableAlterColumn methods */ -void tc_db__tse_ddlalter_table_alter_column__init - (TcDb__TseDDLAlterTableAlterColumn *message); -size_t tc_db__tse_ddlalter_table_alter_column__get_packed_size - (const TcDb__TseDDLAlterTableAlterColumn *message); -size_t tc_db__tse_ddlalter_table_alter_column__pack - (const TcDb__TseDDLAlterTableAlterColumn *message, +/* TcDb__CtcDDLAlterTableAlterColumn methods */ +void tc_db__ctc_ddlalter_table_alter_column__init + (TcDb__CtcDDLAlterTableAlterColumn *message); +size_t tc_db__ctc_ddlalter_table_alter_column__get_packed_size + (const TcDb__CtcDDLAlterTableAlterColumn *message); +size_t tc_db__ctc_ddlalter_table_alter_column__pack + (const TcDb__CtcDDLAlterTableAlterColumn *message, uint8_t *out); -size_t tc_db__tse_ddlalter_table_alter_column__pack_to_buffer - (const TcDb__TseDDLAlterTableAlterColumn *message, +size_t tc_db__ctc_ddlalter_table_alter_column__pack_to_buffer + (const TcDb__CtcDDLAlterTableAlterColumn *message, ProtobufCBuffer *buffer); -TcDb__TseDDLAlterTableAlterColumn * - tc_db__tse_ddlalter_table_alter_column__unpack +TcDb__CtcDDLAlterTableAlterColumn * + tc_db__ctc_ddlalter_table_alter_column__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddlalter_table_alter_column__free_unpacked - (TcDb__TseDDLAlterTableAlterColumn *message, +void tc_db__ctc_ddlalter_table_alter_column__free_unpacked + (TcDb__CtcDDLAlterTableAlterColumn *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLAlterTableDef methods */ -void tc_db__tse_ddlalter_table_def__init - (TcDb__TseDDLAlterTableDef *message); -size_t tc_db__tse_ddlalter_table_def__get_packed_size - (const TcDb__TseDDLAlterTableDef *message); -size_t tc_db__tse_ddlalter_table_def__pack - (const TcDb__TseDDLAlterTableDef *message, +/* TcDb__CtcDDLAlterTableDef methods */ +void tc_db__ctc_ddlalter_table_def__init + (TcDb__CtcDDLAlterTableDef *message); +size_t tc_db__ctc_ddlalter_table_def__get_packed_size + (const TcDb__CtcDDLAlterTableDef *message); +size_t tc_db__ctc_ddlalter_table_def__pack + (const TcDb__CtcDDLAlterTableDef *message, uint8_t *out); -size_t tc_db__tse_ddlalter_table_def__pack_to_buffer - (const TcDb__TseDDLAlterTableDef *message, +size_t tc_db__ctc_ddlalter_table_def__pack_to_buffer + (const TcDb__CtcDDLAlterTableDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLAlterTableDef * - tc_db__tse_ddlalter_table_def__unpack +TcDb__CtcDDLAlterTableDef * + tc_db__ctc_ddlalter_table_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddlalter_table_def__free_unpacked - (TcDb__TseDDLAlterTableDef *message, +void tc_db__ctc_ddlalter_table_def__free_unpacked + (TcDb__CtcDDLAlterTableDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLTruncateTableDef methods */ -void tc_db__tse_ddltruncate_table_def__init - (TcDb__TseDDLTruncateTableDef *message); -size_t tc_db__tse_ddltruncate_table_def__get_packed_size - (const TcDb__TseDDLTruncateTableDef *message); -size_t tc_db__tse_ddltruncate_table_def__pack - (const TcDb__TseDDLTruncateTableDef *message, +/* TcDb__CtcDDLTruncateTableDef methods */ +void tc_db__ctc_ddltruncate_table_def__init + (TcDb__CtcDDLTruncateTableDef *message); +size_t tc_db__ctc_ddltruncate_table_def__get_packed_size + (const TcDb__CtcDDLTruncateTableDef *message); +size_t tc_db__ctc_ddltruncate_table_def__pack + (const TcDb__CtcDDLTruncateTableDef *message, uint8_t *out); -size_t tc_db__tse_ddltruncate_table_def__pack_to_buffer - (const TcDb__TseDDLTruncateTableDef *message, +size_t tc_db__ctc_ddltruncate_table_def__pack_to_buffer + (const TcDb__CtcDDLTruncateTableDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLTruncateTableDef * - tc_db__tse_ddltruncate_table_def__unpack +TcDb__CtcDDLTruncateTableDef * + tc_db__ctc_ddltruncate_table_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddltruncate_table_def__free_unpacked - (TcDb__TseDDLTruncateTableDef *message, +void tc_db__ctc_ddltruncate_table_def__free_unpacked + (TcDb__CtcDDLTruncateTableDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLTruncateTablePartitionDef methods */ -void tc_db__tse_ddltruncate_table_partition_def__init - (TcDb__TseDDLTruncateTablePartitionDef *message); -size_t tc_db__tse_ddltruncate_table_partition_def__get_packed_size - (const TcDb__TseDDLTruncateTablePartitionDef *message); -size_t tc_db__tse_ddltruncate_table_partition_def__pack - (const TcDb__TseDDLTruncateTablePartitionDef *message, +/* TcDb__CtcDDLTruncateTablePartitionDef methods */ +void tc_db__ctc_ddltruncate_table_partition_def__init + (TcDb__CtcDDLTruncateTablePartitionDef *message); +size_t tc_db__ctc_ddltruncate_table_partition_def__get_packed_size + (const TcDb__CtcDDLTruncateTablePartitionDef *message); +size_t tc_db__ctc_ddltruncate_table_partition_def__pack + (const TcDb__CtcDDLTruncateTablePartitionDef *message, uint8_t *out); -size_t tc_db__tse_ddltruncate_table_partition_def__pack_to_buffer - (const TcDb__TseDDLTruncateTablePartitionDef *message, +size_t tc_db__ctc_ddltruncate_table_partition_def__pack_to_buffer + (const TcDb__CtcDDLTruncateTablePartitionDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLTruncateTablePartitionDef * - tc_db__tse_ddltruncate_table_partition_def__unpack +TcDb__CtcDDLTruncateTablePartitionDef * + tc_db__ctc_ddltruncate_table_partition_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddltruncate_table_partition_def__free_unpacked - (TcDb__TseDDLTruncateTablePartitionDef *message, +void tc_db__ctc_ddltruncate_table_partition_def__free_unpacked + (TcDb__CtcDDLTruncateTablePartitionDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLRenameTableDef methods */ -void tc_db__tse_ddlrename_table_def__init - (TcDb__TseDDLRenameTableDef *message); -size_t tc_db__tse_ddlrename_table_def__get_packed_size - (const TcDb__TseDDLRenameTableDef *message); -size_t tc_db__tse_ddlrename_table_def__pack - (const TcDb__TseDDLRenameTableDef *message, +/* TcDb__CtcDDLRenameTableDef methods */ +void tc_db__ctc_ddlrename_table_def__init + (TcDb__CtcDDLRenameTableDef *message); +size_t tc_db__ctc_ddlrename_table_def__get_packed_size + (const TcDb__CtcDDLRenameTableDef *message); +size_t tc_db__ctc_ddlrename_table_def__pack + (const TcDb__CtcDDLRenameTableDef *message, uint8_t *out); -size_t tc_db__tse_ddlrename_table_def__pack_to_buffer - (const TcDb__TseDDLRenameTableDef *message, +size_t tc_db__ctc_ddlrename_table_def__pack_to_buffer + (const TcDb__CtcDDLRenameTableDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLRenameTableDef * - tc_db__tse_ddlrename_table_def__unpack +TcDb__CtcDDLRenameTableDef * + tc_db__ctc_ddlrename_table_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddlrename_table_def__free_unpacked - (TcDb__TseDDLRenameTableDef *message, +void tc_db__ctc_ddlrename_table_def__free_unpacked + (TcDb__CtcDDLRenameTableDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLDropTableDef methods */ -void tc_db__tse_ddldrop_table_def__init - (TcDb__TseDDLDropTableDef *message); -size_t tc_db__tse_ddldrop_table_def__get_packed_size - (const TcDb__TseDDLDropTableDef *message); -size_t tc_db__tse_ddldrop_table_def__pack - (const TcDb__TseDDLDropTableDef *message, +/* TcDb__CtcDDLDropTableDef methods */ +void tc_db__ctc_ddldrop_table_def__init + (TcDb__CtcDDLDropTableDef *message); +size_t tc_db__ctc_ddldrop_table_def__get_packed_size + (const TcDb__CtcDDLDropTableDef *message); +size_t tc_db__ctc_ddldrop_table_def__pack + (const TcDb__CtcDDLDropTableDef *message, uint8_t *out); -size_t tc_db__tse_ddldrop_table_def__pack_to_buffer - (const TcDb__TseDDLDropTableDef *message, +size_t tc_db__ctc_ddldrop_table_def__pack_to_buffer + (const TcDb__CtcDDLDropTableDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLDropTableDef * - tc_db__tse_ddldrop_table_def__unpack +TcDb__CtcDDLDropTableDef * + tc_db__ctc_ddldrop_table_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddldrop_table_def__free_unpacked - (TcDb__TseDDLDropTableDef *message, +void tc_db__ctc_ddldrop_table_def__free_unpacked + (TcDb__CtcDDLDropTableDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLAlterIndexDef methods */ -void tc_db__tse_ddlalter_index_def__init - (TcDb__TseDDLAlterIndexDef *message); -size_t tc_db__tse_ddlalter_index_def__get_packed_size - (const TcDb__TseDDLAlterIndexDef *message); -size_t tc_db__tse_ddlalter_index_def__pack - (const TcDb__TseDDLAlterIndexDef *message, +/* TcDb__CtcDDLAlterIndexDef methods */ +void tc_db__ctc_ddlalter_index_def__init + (TcDb__CtcDDLAlterIndexDef *message); +size_t tc_db__ctc_ddlalter_index_def__get_packed_size + (const TcDb__CtcDDLAlterIndexDef *message); +size_t tc_db__ctc_ddlalter_index_def__pack + (const TcDb__CtcDDLAlterIndexDef *message, uint8_t *out); -size_t tc_db__tse_ddlalter_index_def__pack_to_buffer - (const TcDb__TseDDLAlterIndexDef *message, +size_t tc_db__ctc_ddlalter_index_def__pack_to_buffer + (const TcDb__CtcDDLAlterIndexDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLAlterIndexDef * - tc_db__tse_ddlalter_index_def__unpack +TcDb__CtcDDLAlterIndexDef * + tc_db__ctc_ddlalter_index_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddlalter_index_def__free_unpacked - (TcDb__TseDDLAlterIndexDef *message, +void tc_db__ctc_ddlalter_index_def__free_unpacked + (TcDb__CtcDDLAlterIndexDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLAutoExtendDef methods */ -void tc_db__tse_ddlauto_extend_def__init - (TcDb__TseDDLAutoExtendDef *message); -size_t tc_db__tse_ddlauto_extend_def__get_packed_size - (const TcDb__TseDDLAutoExtendDef *message); -size_t tc_db__tse_ddlauto_extend_def__pack - (const TcDb__TseDDLAutoExtendDef *message, +/* TcDb__CtcDDLAutoExtendDef methods */ +void tc_db__ctc_ddlauto_extend_def__init + (TcDb__CtcDDLAutoExtendDef *message); +size_t tc_db__ctc_ddlauto_extend_def__get_packed_size + (const TcDb__CtcDDLAutoExtendDef *message); +size_t tc_db__ctc_ddlauto_extend_def__pack + (const TcDb__CtcDDLAutoExtendDef *message, uint8_t *out); -size_t tc_db__tse_ddlauto_extend_def__pack_to_buffer - (const TcDb__TseDDLAutoExtendDef *message, +size_t tc_db__ctc_ddlauto_extend_def__pack_to_buffer + (const TcDb__CtcDDLAutoExtendDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLAutoExtendDef * - tc_db__tse_ddlauto_extend_def__unpack +TcDb__CtcDDLAutoExtendDef * + tc_db__ctc_ddlauto_extend_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddlauto_extend_def__free_unpacked - (TcDb__TseDDLAutoExtendDef *message, +void tc_db__ctc_ddlauto_extend_def__free_unpacked + (TcDb__CtcDDLAutoExtendDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLDataFileDef methods */ -void tc_db__tse_ddldata_file_def__init - (TcDb__TseDDLDataFileDef *message); -size_t tc_db__tse_ddldata_file_def__get_packed_size - (const TcDb__TseDDLDataFileDef *message); -size_t tc_db__tse_ddldata_file_def__pack - (const TcDb__TseDDLDataFileDef *message, +/* TcDb__CtcDDLDataFileDef methods */ +void tc_db__ctc_ddldata_file_def__init + (TcDb__CtcDDLDataFileDef *message); +size_t tc_db__ctc_ddldata_file_def__get_packed_size + (const TcDb__CtcDDLDataFileDef *message); +size_t tc_db__ctc_ddldata_file_def__pack + (const TcDb__CtcDDLDataFileDef *message, uint8_t *out); -size_t tc_db__tse_ddldata_file_def__pack_to_buffer - (const TcDb__TseDDLDataFileDef *message, +size_t tc_db__ctc_ddldata_file_def__pack_to_buffer + (const TcDb__CtcDDLDataFileDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLDataFileDef * - tc_db__tse_ddldata_file_def__unpack +TcDb__CtcDDLDataFileDef * + tc_db__ctc_ddldata_file_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddldata_file_def__free_unpacked - (TcDb__TseDDLDataFileDef *message, +void tc_db__ctc_ddldata_file_def__free_unpacked + (TcDb__CtcDDLDataFileDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLSpaceDef methods */ -void tc_db__tse_ddlspace_def__init - (TcDb__TseDDLSpaceDef *message); -size_t tc_db__tse_ddlspace_def__get_packed_size - (const TcDb__TseDDLSpaceDef *message); -size_t tc_db__tse_ddlspace_def__pack - (const TcDb__TseDDLSpaceDef *message, +/* TcDb__CtcDDLSpaceDef methods */ +void tc_db__ctc_ddlspace_def__init + (TcDb__CtcDDLSpaceDef *message); +size_t tc_db__ctc_ddlspace_def__get_packed_size + (const TcDb__CtcDDLSpaceDef *message); +size_t tc_db__ctc_ddlspace_def__pack + (const TcDb__CtcDDLSpaceDef *message, uint8_t *out); -size_t tc_db__tse_ddlspace_def__pack_to_buffer - (const TcDb__TseDDLSpaceDef *message, +size_t tc_db__ctc_ddlspace_def__pack_to_buffer + (const TcDb__CtcDDLSpaceDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLSpaceDef * - tc_db__tse_ddlspace_def__unpack +TcDb__CtcDDLSpaceDef * + tc_db__ctc_ddlspace_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddlspace_def__free_unpacked - (TcDb__TseDDLSpaceDef *message, +void tc_db__ctc_ddlspace_def__free_unpacked + (TcDb__CtcDDLSpaceDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLDropSpaceDef methods */ -void tc_db__tse_ddldrop_space_def__init - (TcDb__TseDDLDropSpaceDef *message); -size_t tc_db__tse_ddldrop_space_def__get_packed_size - (const TcDb__TseDDLDropSpaceDef *message); -size_t tc_db__tse_ddldrop_space_def__pack - (const TcDb__TseDDLDropSpaceDef *message, +/* TcDb__CtcDDLDropSpaceDef methods */ +void tc_db__ctc_ddldrop_space_def__init + (TcDb__CtcDDLDropSpaceDef *message); +size_t tc_db__ctc_ddldrop_space_def__get_packed_size + (const TcDb__CtcDDLDropSpaceDef *message); +size_t tc_db__ctc_ddldrop_space_def__pack + (const TcDb__CtcDDLDropSpaceDef *message, uint8_t *out); -size_t tc_db__tse_ddldrop_space_def__pack_to_buffer - (const TcDb__TseDDLDropSpaceDef *message, +size_t tc_db__ctc_ddldrop_space_def__pack_to_buffer + (const TcDb__CtcDDLDropSpaceDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLDropSpaceDef * - tc_db__tse_ddldrop_space_def__unpack +TcDb__CtcDDLDropSpaceDef * + tc_db__ctc_ddldrop_space_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddldrop_space_def__free_unpacked - (TcDb__TseDDLDropSpaceDef *message, +void tc_db__ctc_ddldrop_space_def__free_unpacked + (TcDb__CtcDDLDropSpaceDef *message, ProtobufCAllocator *allocator); -/* TcDb__TseDDLAlterSpaceDef methods */ -void tc_db__tse_ddlalter_space_def__init - (TcDb__TseDDLAlterSpaceDef *message); -size_t tc_db__tse_ddlalter_space_def__get_packed_size - (const TcDb__TseDDLAlterSpaceDef *message); -size_t tc_db__tse_ddlalter_space_def__pack - (const TcDb__TseDDLAlterSpaceDef *message, +/* TcDb__CtcDDLAlterSpaceDef methods */ +void tc_db__ctc_ddlalter_space_def__init + (TcDb__CtcDDLAlterSpaceDef *message); +size_t tc_db__ctc_ddlalter_space_def__get_packed_size + (const TcDb__CtcDDLAlterSpaceDef *message); +size_t tc_db__ctc_ddlalter_space_def__pack + (const TcDb__CtcDDLAlterSpaceDef *message, uint8_t *out); -size_t tc_db__tse_ddlalter_space_def__pack_to_buffer - (const TcDb__TseDDLAlterSpaceDef *message, +size_t tc_db__ctc_ddlalter_space_def__pack_to_buffer + (const TcDb__CtcDDLAlterSpaceDef *message, ProtobufCBuffer *buffer); -TcDb__TseDDLAlterSpaceDef * - tc_db__tse_ddlalter_space_def__unpack +TcDb__CtcDDLAlterSpaceDef * + tc_db__ctc_ddlalter_space_def__unpack (ProtobufCAllocator *allocator, size_t len, const uint8_t *data); -void tc_db__tse_ddlalter_space_def__free_unpacked - (TcDb__TseDDLAlterSpaceDef *message, +void tc_db__ctc_ddlalter_space_def__free_unpacked + (TcDb__CtcDDLAlterSpaceDef *message, ProtobufCAllocator *allocator); /* --- per-message closures --- */ -typedef void (*TcDb__TseDDLColumnDataTypeDef_Closure) - (const TcDb__TseDDLColumnDataTypeDef *message, +typedef void (*TcDb__CtcDDLColumnDataTypeDef_Closure) + (const TcDb__CtcDDLColumnDataTypeDef *message, void *closure_data); -typedef void (*TcDb__TseDDLColumnDef_Closure) - (const TcDb__TseDDLColumnDef *message, +typedef void (*TcDb__CtcDDLColumnDef_Closure) + (const TcDb__CtcDDLColumnDef *message, void *closure_data); -typedef void (*TcDb__TseDDLForeignKeyElementDef_Closure) - (const TcDb__TseDDLForeignKeyElementDef *message, +typedef void (*TcDb__CtcDDLForeignKeyElementDef_Closure) + (const TcDb__CtcDDLForeignKeyElementDef *message, void *closure_data); -typedef void (*TcDb__TseDDLForeignKeyDef_Closure) - (const TcDb__TseDDLForeignKeyDef *message, +typedef void (*TcDb__CtcDDLForeignKeyDef_Closure) + (const TcDb__CtcDDLForeignKeyDef *message, void *closure_data); -typedef void (*TcDb__TseDDLTableKeyPart_Closure) - (const TcDb__TseDDLTableKeyPart *message, +typedef void (*TcDb__CtcDDLTableKeyPart_Closure) + (const TcDb__CtcDDLTableKeyPart *message, void *closure_data); -typedef void (*TcDb__TseDDLTableKey_Closure) - (const TcDb__TseDDLTableKey *message, +typedef void (*TcDb__CtcDDLTableKey_Closure) + (const TcDb__CtcDDLTableKey *message, void *closure_data); -typedef void (*TcDb__TseMsgCommDef_Closure) - (const TcDb__TseMsgCommDef *message, +typedef void (*TcDb__CtcMsgCommDef_Closure) + (const TcDb__CtcMsgCommDef *message, void *closure_data); -typedef void (*TcDb__TseDDLPartitionTableDef_Closure) - (const TcDb__TseDDLPartitionTableDef *message, +typedef void (*TcDb__CtcDDLPartitionTableDef_Closure) + (const TcDb__CtcDDLPartitionTableDef *message, void *closure_data); -typedef void (*TcDb__TseDDLPartitionDef_Closure) - (const TcDb__TseDDLPartitionDef *message, +typedef void (*TcDb__CtcDDLPartitionDef_Closure) + (const TcDb__CtcDDLPartitionDef *message, void *closure_data); -typedef void (*TcDb__TseDDLCreateTableDef_Closure) - (const TcDb__TseDDLCreateTableDef *message, +typedef void (*TcDb__CtcDDLCreateTableDef_Closure) + (const TcDb__CtcDDLCreateTableDef *message, void *closure_data); -typedef void (*TcDb__TseDDLAlterTablePorp_Closure) - (const TcDb__TseDDLAlterTablePorp *message, +typedef void (*TcDb__CtcDDLAlterTablePorp_Closure) + (const TcDb__CtcDDLAlterTablePorp *message, void *closure_data); -typedef void (*TcDb__TseDDLAlterTableDrop_Closure) - (const TcDb__TseDDLAlterTableDrop *message, +typedef void (*TcDb__CtcDDLAlterTableDrop_Closure) + (const TcDb__CtcDDLAlterTableDrop *message, void *closure_data); -typedef void (*TcDb__TseDDLAlterTableDropKey_Closure) - (const TcDb__TseDDLAlterTableDropKey *message, +typedef void (*TcDb__CtcDDLAlterTableDropKey_Closure) + (const TcDb__CtcDDLAlterTableDropKey *message, void *closure_data); -typedef void (*TcDb__TseDDLAlterTableAlterColumn_Closure) - (const TcDb__TseDDLAlterTableAlterColumn *message, +typedef void (*TcDb__CtcDDLAlterTableAlterColumn_Closure) + (const TcDb__CtcDDLAlterTableAlterColumn *message, void *closure_data); -typedef void (*TcDb__TseDDLAlterTableDef_Closure) - (const TcDb__TseDDLAlterTableDef *message, +typedef void (*TcDb__CtcDDLAlterTableDef_Closure) + (const TcDb__CtcDDLAlterTableDef *message, void *closure_data); -typedef void (*TcDb__TseDDLTruncateTableDef_Closure) - (const TcDb__TseDDLTruncateTableDef *message, +typedef void (*TcDb__CtcDDLTruncateTableDef_Closure) + (const TcDb__CtcDDLTruncateTableDef *message, void *closure_data); -typedef void (*TcDb__TseDDLTruncateTablePartitionDef_Closure) - (const TcDb__TseDDLTruncateTablePartitionDef *message, +typedef void (*TcDb__CtcDDLTruncateTablePartitionDef_Closure) + (const TcDb__CtcDDLTruncateTablePartitionDef *message, void *closure_data); -typedef void (*TcDb__TseDDLRenameTableDef_Closure) - (const TcDb__TseDDLRenameTableDef *message, +typedef void (*TcDb__CtcDDLRenameTableDef_Closure) + (const TcDb__CtcDDLRenameTableDef *message, void *closure_data); -typedef void (*TcDb__TseDDLDropTableDef_Closure) - (const TcDb__TseDDLDropTableDef *message, +typedef void (*TcDb__CtcDDLDropTableDef_Closure) + (const TcDb__CtcDDLDropTableDef *message, void *closure_data); -typedef void (*TcDb__TseDDLAlterIndexDef_Closure) - (const TcDb__TseDDLAlterIndexDef *message, +typedef void (*TcDb__CtcDDLAlterIndexDef_Closure) + (const TcDb__CtcDDLAlterIndexDef *message, void *closure_data); -typedef void (*TcDb__TseDDLAutoExtendDef_Closure) - (const TcDb__TseDDLAutoExtendDef *message, +typedef void (*TcDb__CtcDDLAutoExtendDef_Closure) + (const TcDb__CtcDDLAutoExtendDef *message, void *closure_data); -typedef void (*TcDb__TseDDLDataFileDef_Closure) - (const TcDb__TseDDLDataFileDef *message, +typedef void (*TcDb__CtcDDLDataFileDef_Closure) + (const TcDb__CtcDDLDataFileDef *message, void *closure_data); -typedef void (*TcDb__TseDDLSpaceDef_Closure) - (const TcDb__TseDDLSpaceDef *message, +typedef void (*TcDb__CtcDDLSpaceDef_Closure) + (const TcDb__CtcDDLSpaceDef *message, void *closure_data); -typedef void (*TcDb__TseDDLDropSpaceDef_Closure) - (const TcDb__TseDDLDropSpaceDef *message, +typedef void (*TcDb__CtcDDLDropSpaceDef_Closure) + (const TcDb__CtcDDLDropSpaceDef *message, void *closure_data); -typedef void (*TcDb__TseDDLAlterSpaceDef_Closure) - (const TcDb__TseDDLAlterSpaceDef *message, +typedef void (*TcDb__CtcDDLAlterSpaceDef_Closure) + (const TcDb__CtcDDLAlterSpaceDef *message, void *closure_data); /* --- services --- */ @@ -1121,31 +1121,31 @@ typedef void (*TcDb__TseDDLAlterSpaceDef_Closure) /* --- descriptors --- */ -extern const ProtobufCMessageDescriptor tc_db__tse_ddlcolumn_data_type_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddlcolumn_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddlforeign_key_element_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddlforeign_key_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddltable_key_part__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddltable_key__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_msg_comm_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddlpartition_table_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddlpartition_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddlcreate_table_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddlalter_table_porp__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddlalter_table_drop__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddlalter_table_drop_key__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddlalter_table_alter_column__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddlalter_table_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddltruncate_table_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddltruncate_table_partition_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddlrename_table_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddldrop_table_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddlalter_index_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddlauto_extend_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddldata_file_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddlspace_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddldrop_space_def__descriptor; -extern const ProtobufCMessageDescriptor tc_db__tse_ddlalter_space_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddlcolumn_data_type_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddlcolumn_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddlforeign_key_element_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddlforeign_key_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddltable_key_part__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddltable_key__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_msg_comm_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddlpartition_table_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddlpartition_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddlcreate_table_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddlalter_table_porp__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddlalter_table_drop__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddlalter_table_drop_key__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddlalter_table_alter_column__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddlalter_table_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddltruncate_table_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddltruncate_table_partition_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddlrename_table_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddldrop_table_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddlalter_index_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddlauto_extend_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddldata_file_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddlspace_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddldrop_space_def__descriptor; +extern const ProtobufCMessageDescriptor tc_db__ctc_ddlalter_space_def__descriptor; PROTOBUF_C__END_DECLS diff --git a/storage/tianchi/protobuf/tc_db.proto b/storage/ctc/protobuf/tc_db.proto similarity index 68% rename from storage/tianchi/protobuf/tc_db.proto rename to storage/ctc/protobuf/tc_db.proto index ad96108..62e6da8 100644 --- a/storage/tianchi/protobuf/tc_db.proto +++ b/storage/ctc/protobuf/tc_db.proto @@ -2,7 +2,7 @@ syntax = "proto3"; package tc_db; -message TseDDLColumnDataTypeDef { +message CtcDDLColumnDataTypeDef { /* * These definitions is same as the `typmode_t`; thus they should * be replaced by typmode_t for unifying the definition of columns @@ -13,9 +13,9 @@ message TseDDLColumnDataTypeDef { int32 scale = 4; int32 mysql_ori_datatype = 5; } -message TseDDLColumnDef { +message CtcDDLColumnDef { string name = 1; - TseDDLColumnDataTypeDef datatype = 2; + CtcDDLColumnDataTypeDef datatype = 2; uint32 is_option_set = 4; uint32 col_id = 5; string cons_name = 6; @@ -23,17 +23,17 @@ message TseDDLColumnDef { string ref_table = 11; string default_text = 12; string comment = 13; - uint32 alter_mode = 14; // tse_alter_column_alter_mode + uint32 alter_mode = 14; // ctc_alter_column_alter_mode uint64 collate = 15; string new_name = 16; uint32 is_unsigned = 17; string default_func_name = 18; } -message TseDDLForeignKeyElementDef { +message CtcDDLForeignKeyElementDef { string src_column_name = 1; string ref_column_name = 2; } -message TseDDLForeignKeyDef { +message CtcDDLForeignKeyDef { // fill_dd_foreign_keys_from_create_fields string name = 1; string unique_index_name = 2; @@ -42,9 +42,9 @@ message TseDDLForeignKeyDef { uint32 delete_opt = 5; string referenced_table_schema_name = 6; string referenced_table_name = 7; - repeated TseDDLForeignKeyElementDef elements = 8; + repeated CtcDDLForeignKeyElementDef elements = 8; } -message TseDDLTableKeyPart { +message CtcDDLTableKeyPart { // KEY_PART_INFO string name = 1; /* Length of key part in bytes, excluding NULL flag and length bytes */ @@ -55,44 +55,44 @@ message TseDDLTableKeyPart { string func_name = 6; uint32 is_unsigned = 7; } -message TseDDLTableKey { +message CtcDDLTableKey { // Key string user = 1; string table = 2; string name = 3; string space = 4; - int32 key_type = 5; // tse_key_type - int32 algorithm = 6; // tse_ha_key_alg + int32 key_type = 5; // ctc_key_type + int32 algorithm = 6; // ctc_ha_key_alg bool is_func = 7; - repeated TseDDLTableKeyPart columns = 8; + repeated CtcDDLTableKeyPart columns = 8; bool is_constraint = 9; bool is_dsc = 10; } -message TseMsgCommDef { +message CtcMsgCommDef { uint32 inst_id = 1; uint32 thd_id = 2; uint32 handler_id = 3; uint64 sess_addr = 4; } -message TseDDLPartitionTableDef { +message CtcDDLPartitionTableDef { string name = 1; - repeated TseDDLPartitionTableDef subpart_table_list = 2; + repeated CtcDDLPartitionTableDef subpart_table_list = 2; } -message TseDDLPartitionDef { +message CtcDDLPartitionDef { uint32 part_type = 1; uint32 subpart_type = 2; - repeated TseDDLPartitionTableDef part_table_list = 3; + repeated CtcDDLPartitionTableDef part_table_list = 3; } -message TseDDLCreateTableDef { +message CtcDDLCreateTableDef { string schema = 1; string name = 2; string space = 3; - repeated TseDDLColumnDef columns = 4; - repeated TseDDLForeignKeyDef fk_list = 5; - repeated TseDDLTableKey key_list = 6; + repeated CtcDDLColumnDef columns = 4; + repeated CtcDDLForeignKeyDef fk_list = 5; + repeated CtcDDLTableKey key_list = 6; uint64 auto_increment_value = 7; //init auto incremnet value uint32 options = 8; // if not exists string db_name = 9; @@ -100,10 +100,10 @@ message TseDDLCreateTableDef { string alter_table_name = 11; string alter_db_name = 12; bool is_create_as_select = 13; - TseDDLPartitionDef partition_def = 14; + CtcDDLPartitionDef partition_def = 14; } -message TseDDLAlterTablePorp { +message CtcDDLAlterTablePorp { // knl_alt_table_prop_t string new_name = 1; uint32 pctfree = 2; @@ -113,19 +113,19 @@ message TseDDLAlterTablePorp { int64 serial_start = 6; } -message TseDDLAlterTableDrop { +message CtcDDLAlterTableDrop { string name = 1; - int32 drop_type = 2; // tse_alter_table_drop_type - int32 key_type = 3; // tse_key_type + int32 drop_type = 2; // ctc_alter_table_drop_type + int32 key_type = 3; // ctc_key_type } -message TseDDLAlterTableDropKey { +message CtcDDLAlterTableDropKey { string name = 1; - int32 drop_type = 2; // tse_alter_table_drop_type - int32 key_type = 3; // tse_key_type + int32 drop_type = 2; // ctc_alter_table_drop_type + int32 key_type = 3; // ctc_key_type } -message TseDDLAlterTableAlterColumn { +message CtcDDLAlterTableAlterColumn { string name = 1; string new_name = 2; uint32 type = 3; // SET_DEFAULT, DROP_DEFAULT, RENAME_COLUMN @@ -136,7 +136,7 @@ message TseDDLAlterTableAlterColumn { // string default_data = 8; } -message TseDDLAlterTableDef { +message CtcDDLAlterTableDef { uint32 action = 1; // altable_action_t uint32 options = 2; string user = 3; @@ -144,27 +144,27 @@ message TseDDLAlterTableDef { /** Columns, keys and constraints to be dropped. */ - repeated TseDDLAlterTableDrop drop_list = 5; + repeated CtcDDLAlterTableDrop drop_list = 5; // Columns for ALTER_COLUMN_CHANGE_DEFAULT. - repeated TseDDLAlterTableAlterColumn alter_list = 6; + repeated CtcDDLAlterTableAlterColumn alter_list = 6; // List of columns, used by both CREATE and ALTER TABLE. - repeated TseDDLColumnDef create_list = 7; - TseDDLAlterTablePorp table_def = 8; - repeated TseDDLTableKey add_key_list = 9; - repeated TseDDLAlterTableDropKey drop_key_list = 10; - repeated TseDDLForeignKeyDef add_foreign_key_list = 11; + repeated CtcDDLColumnDef create_list = 7; + CtcDDLAlterTablePorp table_def = 8; + repeated CtcDDLTableKey add_key_list = 9; + repeated CtcDDLAlterTableDropKey drop_key_list = 10; + repeated CtcDDLForeignKeyDef add_foreign_key_list = 11; uint64 new_auto_increment_value = 12; string db_name = 13; string sql_str = 14; - repeated TseDDLAlterIndexDef alter_index_list = 15; + repeated CtcDDLAlterIndexDef alter_index_list = 15; repeated string drop_partition_names = 16; - repeated TseDDLPartitionTableDef add_part_list = 17; + repeated CtcDDLPartitionTableDef add_part_list = 17; uint32 hash_coalesce_count = 18; int64 systimestamp = 19; int32 tz_offset_UTC = 20; } -message TseDDLTruncateTableDef { +message CtcDDLTruncateTableDef { string schema = 1; string name = 2; string db_name = 4; @@ -172,7 +172,7 @@ message TseDDLTruncateTableDef { uint32 no_check_fk = 6; } -message TseDDLTruncateTablePartitionDef { +message CtcDDLTruncateTablePartitionDef { string user = 1; string db_name = 2; string table_name = 3; @@ -184,7 +184,7 @@ message TseDDLTruncateTablePartitionDef { repeated uint32 subpartition_id = 9; } -message TseDDLRenameTableDef { +message CtcDDLRenameTableDef { uint32 action = 1; // altable_action_t uint32 options = 2; string user = 3; @@ -199,7 +199,7 @@ message TseDDLRenameTableDef { repeated string new_constraints_name = 12; } -message TseDDLDropTableDef { +message CtcDDLDropTableDef { uint32 options = 1; string user = 2; string name = 3; @@ -208,49 +208,49 @@ message TseDDLDropTableDef { string sql_str = 6; } -message TseDDLAlterIndexDef { +message CtcDDLAlterIndexDef { string user = 1; string name = 2; uint32 type = 3; // def type string table = 4; string new_name = 5; - int32 key_type = 6; // tse_key_type + int32 key_type = 6; // ctc_key_type } -message TseDDLAutoExtendDef { +message CtcDDLAutoExtendDef { bool enabled = 1; uint64 nextsize = 2; int64 maxsize = 3; } -message TseDDLDataFileDef { +message CtcDDLDataFileDef { string name = 1; int64 size = 2; //device size int32 block_size = 3; - TseDDLAutoExtendDef autoextend = 4; // the data of the autoextend property of the device + CtcDDLAutoExtendDef autoextend = 4; // the data of the autoextend property of the device uint32 node_id = 5; } -message TseDDLSpaceDef { +message CtcDDLSpaceDef { string name = 1; // name of the space uint32 type = 2; // type of the space bool in_memory = 3; bool autooffline = 4; uint32 extent_size = 5; - repeated TseDDLDataFileDef datafiles_list = 6; + repeated CtcDDLDataFileDef datafiles_list = 6; uint32 flags = 7; string db_name = 8; string sql_str = 9; } -message TseDDLDropSpaceDef { +message CtcDDLDropSpaceDef { string obj_name = 1; uint32 option = 2; string db_name = 3; string sql_str = 4; } -message TseDDLAlterSpaceDef { +message CtcDDLAlterSpaceDef { uint32 action = 1; string name = 2; // name of the space string new_name = 3; // name of the new space diff --git a/storage/tianchi/srv_mq_msg.h b/storage/ctc/srv_mq_msg.h similarity index 80% rename from storage/tianchi/srv_mq_msg.h rename to storage/ctc/srv_mq_msg.h index 8f0f304..1338647 100644 --- a/storage/tianchi/srv_mq_msg.h +++ b/storage/ctc/srv_mq_msg.h @@ -18,18 +18,18 @@ #ifndef SRV_MQ_MSG__ #define SRV_MQ_MSG__ -#include "tse_srv.h" +#include "ctc_srv.h" #ifdef __cplusplus extern "C" { #endif /* __cpluscplus */ #define SHM_SEG_MAX_NUM 64 -#define TSE_MAX_COLUMNS 4096 // CT_MAX_COLUMNS +#define CTC_MAX_COLUMNS 4096 // CT_MAX_COLUMNS #define INDEX_KEY_SIZE 4096 // 索引查询条件的大小mysql限制为3072，取4096 #define MAX_PREFETCH_REC_NUM 100 #define REQUEST_SIZE (MAX_RECORD_SIZE + (2 * MAX_PREFETCH_REC_NUM) + 24) // 根据rnd_prefetch_request计算, 取8字节对齐 -#define TSE_MQ_MESSAGE_SLICE_LEN 102400 +#define CTC_MQ_MESSAGE_SLICE_LEN 102400 #define MAX_LOB_LOCATOR_SIZE 4000 // 存储引擎存储blob对象结构体最大长度 @@ -44,19 +44,19 @@ struct register_instance_request { }; struct close_session_request { - tianchi_handler_t tch; + ctc_handler_t tch; int result; }; struct open_table_request { char table_name[SMALL_RECORD_SIZE]; char user_name[SMALL_RECORD_SIZE]; - tianchi_handler_t tch; + ctc_handler_t tch; int result; }; struct close_table_request { - tianchi_handler_t tch; + ctc_handler_t tch; int result; }; @@ -64,7 +64,7 @@ struct write_row_request { uint16_t record_len; uint8_t *record; int result; - tianchi_handler_t tch; + ctc_handler_t tch; uint16_t serial_column_offset; uint64_t last_insert_id; dml_flag_t flag; @@ -77,7 +77,7 @@ struct update_job_request { struct bulk_write_request { int result; - tianchi_handler_t tch; + ctc_handler_t tch; uint16_t record_len; uint64_t record_num; uint32_t err_pos; @@ -87,51 +87,51 @@ struct bulk_write_request { }; struct update_row_request { - tianchi_handler_t tch; + ctc_handler_t tch; uint16_t new_record_len; uint8_t *new_record; - uint16_t upd_cols[TSE_MAX_COLUMNS]; + uint16_t upd_cols[CTC_MAX_COLUMNS]; uint16_t col_num; int result; dml_flag_t flag; }; struct delete_row_request { - tianchi_handler_t tch; + ctc_handler_t tch; uint16_t record_len; int result; dml_flag_t flag; }; struct rnd_init_request { - tianchi_handler_t tch; + ctc_handler_t tch; int result; expected_cursor_action_t action; - tse_select_mode_t mode; - tse_conds *cond; + ctc_select_mode_t mode; + ctc_conds *cond; }; struct rnd_end_request { - tianchi_handler_t tch; + ctc_handler_t tch; int result; }; struct scan_records_request { - tianchi_handler_t tch; + ctc_handler_t tch; uint64_t num_rows; - char index_name[TSE_MAX_KEY_NAME_LENGTH]; // 索引名 + char index_name[CTC_MAX_KEY_NAME_LENGTH]; // 索引名 int result; }; struct rnd_next_request { - tianchi_handler_t tch; + ctc_handler_t tch; uint16_t record_len; uint8_t *record; int result; }; struct rnd_prefetch_request { - tianchi_handler_t tch; + ctc_handler_t tch; int result; int max_row_size; uint8_t records[MAX_RECORD_SIZE]; @@ -141,14 +141,14 @@ struct rnd_prefetch_request { }; struct trx_begin_request { - tianchi_handler_t tch; + ctc_handler_t tch; int result; - tianchi_trx_context_t trx_context; + ctc_trx_context_t trx_context; bool is_mysql_local; }; struct trx_commit_request { - tianchi_handler_t tch; + ctc_handler_t tch; int result; bool is_ddl_commit; int32_t csize; @@ -156,7 +156,7 @@ struct trx_commit_request { }; struct trx_rollback_request { - tianchi_handler_t tch; + ctc_handler_t tch; int result; int32_t csize; uint64_t *cursors; @@ -164,8 +164,8 @@ struct trx_rollback_request { struct lock_table_request { char db_name[SMALL_RECORD_SIZE]; - tse_lock_table_info lock_info; - tianchi_handler_t tch; + ctc_lock_table_info lock_info; + ctc_handler_t tch; int result; uint32_t mysql_inst_id; int error_code; @@ -174,7 +174,7 @@ struct lock_table_request { struct pre_create_db_request { - tianchi_handler_t tch; + ctc_handler_t tch; char sql_str[MAX_DDL_SQL_LEN]; char db_name[SMALL_RECORD_SIZE]; uint32_t ctc_db_datafile_size; @@ -186,7 +186,7 @@ struct pre_create_db_request { }; struct drop_tablespace_and_user_request { - tianchi_handler_t tch; + ctc_handler_t tch; char db_name[SMALL_RECORD_SIZE]; char sql_str[MAX_DDL_SQL_LEN]; char user_name[SMALL_RECORD_SIZE]; @@ -197,7 +197,7 @@ struct drop_tablespace_and_user_request { }; struct drop_db_pre_check_request { - tianchi_handler_t tch; + ctc_handler_t tch; char db_name[SMALL_RECORD_SIZE]; int result; int error_code; @@ -206,13 +206,13 @@ struct drop_db_pre_check_request { struct srv_set_savepoint_request { char name[SMALL_RECORD_SIZE]; - tianchi_handler_t tch; + ctc_handler_t tch; int result; }; struct srv_rollback_savepoint_request { char name[SMALL_RECORD_SIZE]; - tianchi_handler_t tch; + ctc_handler_t tch; int result; int32_t csize; uint64_t *cursors; @@ -220,7 +220,7 @@ struct srv_rollback_savepoint_request { struct srv_release_savepoint_request { char name[SMALL_RECORD_SIZE]; - tianchi_handler_t tch; + ctc_handler_t tch; int result; }; @@ -235,7 +235,7 @@ struct index_read_request { uint8_t *record; uint16_t record_len; uint16_t find_flag; - char index_name[TSE_MAX_KEY_NAME_LENGTH + 1]; + char index_name[CTC_MAX_KEY_NAME_LENGTH + 1]; uint16_t key_num; int action; int result; @@ -244,27 +244,27 @@ struct index_read_request { uint8_t right_key_record[INDEX_KEY_SIZE]; struct index_key_info left_key_info; struct index_key_info right_key_info; - tianchi_handler_t tch; - tse_select_mode_t mode; - tse_conds *cond; + ctc_handler_t tch; + ctc_select_mode_t mode; + ctc_conds *cond; bool is_replace; bool index_skip_scan; }; struct index_end_request { - tianchi_handler_t tch; + ctc_handler_t tch; int result; }; struct general_fetch_request { - tianchi_handler_t tch; + ctc_handler_t tch; uint16_t record_len; uint8_t *record; int result; }; struct general_prefetch_request { - tianchi_handler_t tch; + ctc_handler_t tch; int result; int max_row_size; uint8_t records[MAX_RECORD_SIZE]; @@ -274,20 +274,20 @@ struct general_prefetch_request { }; struct free_session_cursors_request { - tianchi_handler_t tch; + ctc_handler_t tch; int result; int32_t csize; uint64_t *cursors; }; struct get_index_slot_request { - tianchi_handler_t tch; + ctc_handler_t tch; int result; - char index_name[TSE_MAX_KEY_NAME_LENGTH + 1]; + char index_name[CTC_MAX_KEY_NAME_LENGTH + 1]; }; struct rnd_pos_request { - tianchi_handler_t tch; + ctc_handler_t tch; uint16_t record_len; uint8_t *record; uint16_t pos_length; @@ -296,20 +296,20 @@ struct rnd_pos_request { }; struct position_request { - tianchi_handler_t tch; + ctc_handler_t tch; uint16_t pos_length; uint8_t position[SMALL_RECORD_SIZE]; int result; }; struct delete_all_rows_request { - tianchi_handler_t tch; + ctc_handler_t tch; int result; dml_flag_t flag; }; struct knl_write_lob_request { - tianchi_handler_t tch; + ctc_handler_t tch; char locator[MAX_LOB_LOCATOR_SIZE]; int column_id; uint32_t data_len; @@ -319,7 +319,7 @@ struct knl_write_lob_request { }; struct knl_read_lob_request { - tianchi_handler_t tch; + ctc_handler_t tch; char locator[MAX_LOB_LOCATOR_SIZE]; uint32_t offset; uint32_t size; @@ -333,7 +333,7 @@ struct get_max_session_request { }; struct analyze_table_request { - tianchi_handler_t tch; + ctc_handler_t tch; char table_name[SMALL_RECORD_SIZE]; char user_name[SMALL_RECORD_SIZE]; double ratio; @@ -342,15 +342,15 @@ struct analyze_table_request { struct get_cbo_stats_request { int result; - tianchi_handler_t tch; - tianchi_cbo_stats_t *stats; - tse_cbo_stats_table_t *tse_cbo_stats_table; + ctc_handler_t tch; + ctc_cbo_stats_t *stats; + ctc_cbo_stats_table_t *ctc_cbo_stats_table; uint16_t first_partid; uint16_t num_part_fetch; }; struct get_serial_val_request { - tianchi_handler_t tch; + ctc_handler_t tch; uint64_t value; int result; dml_flag_t flag; @@ -362,19 +362,19 @@ struct close_mysql_connection_request { int result; }; -struct tse_lock_tables_request { - tianchi_handler_t tch; +struct ctc_lock_tables_request { + ctc_handler_t tch; char db_name[SMALL_RECORD_SIZE]; - tse_lock_table_info lock_info; + ctc_lock_table_info lock_info; int err_code; int result; }; -struct tse_unlock_tables_request { - tianchi_handler_t tch; +struct ctc_unlock_tables_request { + ctc_handler_t tch; int result; uint32_t mysql_inst_id; - tse_lock_table_info lock_info; + ctc_lock_table_info lock_info; }; struct check_table_exists_request { @@ -413,35 +413,35 @@ struct set_cluster_role_by_cantian_request { }; struct execute_ddl_mysql_sql_request { - tse_ddl_broadcast_request broadcast_req; + ctc_ddl_broadcast_request broadcast_req; uint32_t thd_id; int result; bool allow_fail; }; struct execute_mysql_ddl_sql_request { - tse_ddl_broadcast_request broadcast_req; - tianchi_handler_t tch; + ctc_ddl_broadcast_request broadcast_req; + ctc_handler_t tch; int result; bool allow_fail; }; struct lock_instance_request { bool is_mysqld_starting; - tse_lock_table_mode_t lock_type; - tianchi_handler_t tch; + ctc_lock_table_mode_t lock_type; + ctc_handler_t tch; int result; }; struct unlock_instance_request { bool is_mysqld_starting; - tianchi_handler_t tch; + ctc_handler_t tch; int result; }; struct invalidate_mysql_dd_request { - tse_invalidate_broadcast_request broadcast_req; - tianchi_handler_t tch; + ctc_invalidate_broadcast_request broadcast_req; + ctc_handler_t tch; int err_code; int result; }; -- Gitee From 30311385909a7e2de34f66e76c9a492bbc8fb653 Mon Sep 17 00:00:00 2001 From: zhangxuan_hw Date: Tue, 5 Nov 2024 16:08:34 +0800 Subject: [PATCH 2/8] Replace 'daac' with 'cantian' in repository test --- .gitignore | 4 +- mysql-test/README.md | 2 +- mysql-test/mysql-test-run-ST.pl | 6 +-- mysql-test/suite/ctc/t/ctc_ddl.test | 4 +- .../suite/ctc/t/ctc_ddl_alter_table.test | 4 +- .../suite/ctc/t/ctc_link_and_migr_row.test | 2 +- storage/ctc/CMakeLists.txt | 22 ++++---- storage/ctc/ctc_ddl_util.cc | 2 +- storage/ctc/ctc_error.cc | 6 +-- storage/ctc/ctc_srv.h | 2 +- storage/ctc/ctc_srv_mq_module.cc | 2 +- storage/ctc/ctc_stats.cc | 6 +-- storage/ctc/datatype_cnvrt_4_index_search.cc | 2 +- storage/ctc/datatype_cnvrtr.h | 2 +- storage/ctc/ha_ctc.cc | 18 +++---- storage/ctc/ha_ctc_ddl.h | 2 +- ...daac_plugin.cc => mysql_cantian_plugin.cc} | 50 +++++++++---------- 17 files changed, 68 insertions(+), 68 deletions(-) rename storage/ctc/{mysql_daac_plugin.cc => mysql_cantian_plugin.cc} (73%) diff --git a/.gitignore b/.gitignore index 7ad2cbd..004134a 100644 --- a/.gitignore +++ b/.gitignore @@ -25,8 +25,8 @@ source_downloads /bld_debug /bld_release /mysql-source -# daac -/daac_lib +# cantian +/cantian_lib /mysql_bin # test diff --git a/mysql-test/README.md b/mysql-test/README.md index 3b372d3..00d8e1e 100644 --- a/mysql-test/README.md +++ b/mysql-test/README.md @@ -72,7 +72,7 @@ chmod 777 ./mysql-test-run-meta-single.pl su - cantiandba cd /usr/local/mysql/mysql-test export RUN_MODE=cantiand_with_mysql -export LD_LIBRARY_PATH=/usr/local/mysql/lib:/home/regress/cantian-connector-mysql/mysql-source/daac_lib:/usr/local/mysql/lib:/home/regress/cantian-connector-mysql/mysql-source/daac_lib:/usr/local/mysql/lib/private:/home/cantiandba/install/lib:/home/cantiandba/install/add-ons::/home/regress/cantian-connector-mysql/bld_debug/library_output_directory +export LD_LIBRARY_PATH=/usr/local/mysql/lib:/home/regress/cantian-connector-mysql/mysql-source/cantian_lib:/usr/local/mysql/lib:/home/regress/cantian-connector-mysql/mysql-source/cantian_lib:/usr/local/mysql/lib/private:/home/cantiandba/install/lib:/home/cantiandba/install/add-ons::/home/regress/cantian-connector-mysql/bld_debug/library_output_directory export CANTIAND_MODE=open export CANTIAND_HOME_DIR=/home/cantiandba/data ``` diff --git a/mysql-test/mysql-test-run-ST.pl b/mysql-test/mysql-test-run-ST.pl index 9c330a7..143fd3e 100644 --- a/mysql-test/mysql-test-run-ST.pl +++ b/mysql-test/mysql-test-run-ST.pl @@ -6139,7 +6139,7 @@ sub mysqld_arguments ($$$) { return $args; } -sub daac_start { +sub cantian_start { my $ret = run_sh_script("start_cantiand_ST.sh start"); return $ret; } @@ -6258,8 +6258,8 @@ sub mysqld_start ($$$$) { # Remember data dir for gmon.out files if using gprof $gprof_dirs{ $mysqld->value('datadir') } = 1 if $opt_gprof; -# if (daac_start()) { -# mtr_error("Failed to start daac."); +# if (cantian_start()) { +# mtr_error("Failed to start cantian."); # } if (defined $exe) { $mysqld->{'proc'} = diff --git a/mysql-test/suite/ctc/t/ctc_ddl.test b/mysql-test/suite/ctc/t/ctc_ddl.test index eb82649..28239c2 100644 --- a/mysql-test/suite/ctc/t/ctc_ddl.test +++ b/mysql-test/suite/ctc/t/ctc_ddl.test @@ -28,9 +28,9 @@ ALTER TABLE DEMO ADD PRIMARY KEY (ID); #创建用户 #CREATE USER zd1 IDENTIFIED BY "Zd1-123456"; -#GRANT ALL PRIVILEGES ON *.* TO zd1; #daac里面需要把 ON *.*删除掉，DAAC不支持此语法 +#GRANT ALL PRIVILEGES ON *.* TO zd1; #cantian里面需要把 ON *.*删除掉，CANTIAN不支持此语法 #CREATE USER zd2 IDENTIFIED BY "Zd1-123456"; -#GRANT SELECT,INSERT,UPDATE, DELETE ON demo_db.DEMO TO zd2; #这里只支持db.table语法，daac不支持db,发到daac侧需要把db删掉 +#GRANT SELECT,INSERT,UPDATE, DELETE ON demo_db.DEMO TO zd2; #这里只支持db.table语法，cantian不支持db,发到cantian侧需要把db删掉 #Adding a foreign key constraint create table DEMO_A (ID integer not null, NAME varchar(19) not null, SCORE float, CONSTRAINT id_fk FOREIGN KEY (ID) REFERENCES DEMO(ID)); diff --git a/mysql-test/suite/ctc/t/ctc_ddl_alter_table.test b/mysql-test/suite/ctc/t/ctc_ddl_alter_table.test index 1326548..f3dd619 100644 --- a/mysql-test/suite/ctc/t/ctc_ddl_alter_table.test +++ b/mysql-test/suite/ctc/t/ctc_ddl_alter_table.test @@ -448,7 +448,7 @@ INSERT INTO DEMO (col1,col2) values(4,4); --error 1062 UPDATE DEMO set col1 = 2 where ID = 1; SELECT * FROM DEMO; -#没有修改成功，但是也没执行报错， TODODDL 后面需要来审视 innodb能够修改成功，daac没有修改成功 +#没有修改成功，但是也没执行报错， TODODDL 后面需要来审视 innodb能够修改成功，cantian没有修改成功 UPDATE DEMO set col1 = 100 where ID = 1; SELECT * FROM DEMO; desc DEMO; @@ -493,7 +493,7 @@ desc DEMO; show create table DEMO; show index from DEMO; --error 1048 -#这个地方modify了以后感觉丢失了自增属性，但是唯一属性daac还在 +#这个地方modify了以后感觉丢失了自增属性，但是唯一属性cantian还在 INSERT INTO DEMO values(null, 'insert6',1,1.2); #1048 (23000): Column 'ID' cannot be null --error 1062 INSERT INTO DEMO values(7, 'insert6',1,1.2);#ERROR 1062 (23000): Duplicate entry '7' for key 'DEMO.PRIMARY' diff --git a/mysql-test/suite/ctc/t/ctc_link_and_migr_row.test b/mysql-test/suite/ctc/t/ctc_link_and_migr_row.test index 5d379b3..aeab6b9 100644 --- a/mysql-test/suite/ctc/t/ctc_link_and_migr_row.test +++ b/mysql-test/suite/ctc/t/ctc_link_and_migr_row.test @@ -1,4 +1,4 @@ -#### test case come from daac codebase gs_row_chain.sql, only part of it pick up to here +#### test case come from cantian codebase gs_row_chain.sql, only part of it pick up to here #### remember if table column is too long or column size to big, to pick new case from gs_row_chain.sql #### 链接行： #### 1、当行数据大于PCRH_MAX_ROW_SIZE:8050(pcrh表)或者HEAP_MAX_ROW_SIZE:8040(堆表)，插入时会产生链接行 diff --git a/storage/ctc/CMakeLists.txt b/storage/ctc/CMakeLists.txt index 98bf679..b4e60e1 100644 --- a/storage/ctc/CMakeLists.txt +++ b/storage/ctc/CMakeLists.txt @@ -16,11 +16,11 @@ SET(CTC_PLUGIN_DYNAMIC "ha_ctc") SET(CTC_SOURCES ctc_log.h ha_ctc.cc ha_ctc.h ha_ctcpart.h ha_ctcpart.cc ha_ctc_ddl.cc ha_ctc_ddl.h ctc_ddl_util.cc ctc_ddl_util.h datatype_cnvrtr.cc datatype_cnvrtr.h ctc_error.cc ctc_error.h decimal_convert.cc decimal_convert.h ctc_cbo.cc ctc_cbo.h datatype_cnvrt_4_index_search.cc datatype_cnvrt_4_index_search.h ctc_ddl_rewriter_plugin.cc ctc_meta_data.cc ctc_meta_data.h ctc_stats.h ctc_stats.cc ctc_srv.h ctc_util.h ctc_util.cc protobuf/tc_db.pb-c.c protobuf/tc_db.pb-c.h) -option(WITH_DAAC OFF) -IF (WITH_DAAC) - add_definitions(-DWITH_DAAC) - message(STATUS "ADD WITH DAAC") - list(APPEND CTC_SOURCES mysql_daac_plugin.cc) +option(WITH_CANTIAN OFF) +IF (WITH_CANTIAN) + add_definitions(-DWITH_CANTIAN) + message(STATUS "ADD WITH CANTIAN") + list(APPEND CTC_SOURCES mysql_cantian_plugin.cc) ELSE () list(APPEND CTC_SOURCES ctc_srv_mq_stub.cc ctc_srv_mq_module.cc ctc_srv_mq_module.h srv_mq_msg.h message_queue/dsw_shm.h message_queue/dsw_list.h message_queue/dsw_message.h message_queue/dsw_typedef.h) @@ -40,9 +40,9 @@ SET(CMAKE_SKIP_RPATH TRUE) STRING_APPEND(CMAKE_CXX_FLAGS " -Wl,-z,now") STRING_APPEND(CMAKE_CXX_FLAGS " -Wl,-z,nodelete") -SET(DAAC_LIB_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../daac_lib) +SET(CANTIAN_LIB_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../cantian_lib) SET(MYSQL_CLIENT_STATIC_LIB_PATH ${CMAKE_BINARY_DIR}/archive_output_directory/) -LINK_DIRECTORIES(${DAAC_LIB_PATH}) +LINK_DIRECTORIES(${CANTIAN_LIB_PATH}) LINK_DIRECTORIES(${MYSQL_CLIENT_STATIC_LIB_PATH}) INCLUDE_DIRECTORIES(SYSTEM ${BOOST_PATCHES_DIR} ${BOOST_INCLUDE_DIR}) @@ -52,21 +52,21 @@ add_library(ctc_proxy SHARED ${CTC_PROXY_SOURCES}) target_link_libraries(ctc_proxy libmysqlclient.a) # ctc_proxy link libmysqlclient.a function symbol rather than mysqld`s set_target_properties(ctc_proxy PROPERTIES COMPILE_FLAGS ${CTC_PROXY_CXX_FLAGS} LINK_FLAGS " -Wl,-Bsymbolic" - LIBRARY_OUTPUT_DIRECTORY ${DAAC_LIB_PATH}) -IF (WITH_DAAC) + LIBRARY_OUTPUT_DIRECTORY ${CANTIAN_LIB_PATH}) +IF (WITH_CANTIAN) IF (WITH_CTC_STORAGE_ENGINE AND NOT WITHOUT_CTC_STORAGE_ENGINE) MYSQL_ADD_PLUGIN(ctc ${CTC_SOURCES} STORAGE_ENGINE MANDATORY - LINK_LIBRARIES libzecommon.so libzeclient.so libzeprotocol.so libprotobuf-c.a pcre2-8 ctc_proxy daac + LINK_LIBRARIES libzecommon.so libzeclient.so libzeprotocol.so libprotobuf-c.a pcre2-8 ctc_proxy cantian ) ELSEIF (NOT WITHOUT_CTC_STORAGE_ENGINE) MYSQL_ADD_PLUGIN(ctc ${CTC_SOURCES} STORAGE_ENGINE MODULE_ONLY - LINK_LIBRARIES libzecommon.so libzeclient.so libzeprotocol.so libprotobuf-c.a pcre2-8 ctc_proxy daac + LINK_LIBRARIES libzecommon.so libzeclient.so libzeprotocol.so libprotobuf-c.a pcre2-8 ctc_proxy cantian ) ENDIF () ELSE () diff --git a/storage/ctc/ctc_ddl_util.cc b/storage/ctc/ctc_ddl_util.cc index ef5589b..ef26c46 100644 --- a/storage/ctc/ctc_ddl_util.cc +++ b/storage/ctc/ctc_ddl_util.cc @@ -251,7 +251,7 @@ bool get_ctc_key_algorithm(ha_key_alg algorithm, int32_t *ret_algorithm) { default: break; } - // mysql字符序和daac的参数对接 + // mysql字符序和cantian的参数对接 static map g_ctc_key_algorithm_map = { {HA_KEY_ALG_SE_SPECIFIC, CTC_HA_KEY_ALG_SE_SPECIFIC}, diff --git a/storage/ctc/ctc_error.cc b/storage/ctc/ctc_error.cc index b8e67b3..29ba361 100644 --- a/storage/ctc/ctc_error.cc +++ b/storage/ctc/ctc_error.cc @@ -30,11 +30,11 @@ static std::unordered_map err_code_lookup_map = { tell it also to MySQL so that MySQL knows to empty the cached binlog for this transaction */ {ERR_DEAD_LOCK, HA_ERR_LOCK_DEADLOCK}, - /* The DAAC serialization isolation level is stricter than the MySQL + /* The CANTIAN serialization isolation level is stricter than the MySQL repeatable read isolation level. If two transactions conflict: - - The daac is locked, including lock timeout and transaction area conflict. + - The cantian is locked, including lock timeout and transaction area conflict. - MySQL will be locked, including lock timeout and success. - Therefore, the daac transaction conflict error code is temporarily + Therefore, the cantian transaction conflict error code is temporarily classified as lock timeout. */ {ERR_SERIALIZE_ACCESS, HA_ERR_RECORD_CHANGED}, /* Starting from 5.0.13, we let MySQL just roll back the diff --git a/storage/ctc/ctc_srv.h b/storage/ctc/ctc_srv.h index 69ab7bb..7a4de58 100644 --- a/storage/ctc/ctc_srv.h +++ b/storage/ctc/ctc_srv.h @@ -245,7 +245,7 @@ typedef union { uint32_t is_collate : 1; // sql_parse_collate 字符串排序用的 跟字符集有关系 https://www.cnblogs.com/jpfss/p/11548826.html uint32_t has_null : 1; // not null sql_parse_column_not_null uint32_t has_quote : 1; // if column name wrapped with double quotation 如果列名用双引号括起来 - uint32_t is_dummy : 1; // if it is a dummy column for index 目前在daac代码中暂未使用 + uint32_t is_dummy : 1; // if it is a dummy column for index 目前在cantian代码中暂未使用 uint32_t is_default_null : 1; // empty string treat as null or '' uint32_t isKey : 1; // key关键字 uint32_t is_default_func : 1; // if default value is generated by mysql functions diff --git a/storage/ctc/ctc_srv_mq_module.cc b/storage/ctc/ctc_srv_mq_module.cc index 930c530..80a0706 100644 --- a/storage/ctc/ctc_srv_mq_module.cc +++ b/storage/ctc/ctc_srv_mq_module.cc @@ -316,7 +316,7 @@ static void ctc_log_reg_error_by_code(int error_code) { switch(error_code) { case ERR_CONNECTION_FAILED: -#ifdef WITH_DAAC +#ifdef WITH_CANTIAN ctc_log_error("connection failed"); #else ctc_log_error("shm connection failed"); diff --git a/storage/ctc/ctc_stats.cc b/storage/ctc/ctc_stats.cc index 60cc649..a03a218 100644 --- a/storage/ctc/ctc_stats.cc +++ b/storage/ctc/ctc_stats.cc @@ -93,7 +93,7 @@ const char *ctc_interface_strs[] = { }; -#ifndef WITH_DAAC +#ifndef WITH_CANTIAN typedef struct tag_mem_class_cfg_s { uint32_t size; // align to 8 bytes uint32_t num; @@ -178,7 +178,7 @@ void ctc_stats::print_cost_times(std::string &ctc_srv_monitor_str) { ctc_srv_monitor_str += "\n======================================CTC_STATS=====================================\n"; } -#ifndef WITH_DAAC +#ifndef WITH_CANTIAN extern uint32_t g_shm_file_num; void ctc_stats::print_shm_usage(std::string &ctc_srv_monitor_str) { uint32_t *ctc_shm_usage = (uint32_t *)my_malloc(PSI_NOT_INSTRUMENTED, (g_shm_file_num + 1) * MEM_CLASS_NUM * sizeof(uint32_t), MYF(MY_WME)); @@ -216,7 +216,7 @@ void ctc_stats::print_stats(THD *thd, stat_print_fn *stat_print) { if (get_statistics_enabled()) { print_cost_times(ctc_srv_monitor_str); } -#ifndef WITH_DAAC +#ifndef WITH_CANTIAN print_shm_usage(ctc_srv_monitor_str); #endif diff --git a/storage/ctc/datatype_cnvrt_4_index_search.cc b/storage/ctc/datatype_cnvrt_4_index_search.cc index a3bbda0..97b0565 100644 --- a/storage/ctc/datatype_cnvrt_4_index_search.cc +++ b/storage/ctc/datatype_cnvrt_4_index_search.cc @@ -142,7 +142,7 @@ int ctc_convert_key_from_mysql_to_cantian(Field *field, uint8_t **mysql_ptr, dec { int ret = CT_SUCCESS; const field_cnvrt_aux_t *mysql_info = get_auxiliary_for_field_convert(field, field->type()); - // 针对tiny和short类型，对应到daac是int类型，所以key length需要按照daac大小的存储 + // 针对tiny和short类型，对应到cantian是int类型，所以key length需要按照cantian大小的存储 if (mysql_info->mysql_field_type == MYSQL_TYPE_TINY || mysql_info->mysql_field_type == MYSQL_TYPE_SHORT || mysql_info->mysql_field_type == MYSQL_TYPE_INT24) { ctc_index_make_up_key_length(reinterpret_cast(cantian_ptr), mysql_ptr, len, sizeof(int)); diff --git a/storage/ctc/datatype_cnvrtr.h b/storage/ctc/datatype_cnvrtr.h index 95b6a9c..2499520 100644 --- a/storage/ctc/datatype_cnvrtr.h +++ b/storage/ctc/datatype_cnvrtr.h @@ -164,7 +164,7 @@ typedef struct st_lob_text { typedef enum en_isolation_level { ISOLATION_READ_COMMITTED = 1, // read committed isolation level(default) ISOLATION_SERIALIZABLE = 3, // serializable isolation level - // value 2 is internal isolation level of daac, ignore for now + // value 2 is internal isolation level of cantian, ignore for now } isolation_level_t; typedef struct st_mysql_to_cantian_field_convert { diff --git a/storage/ctc/ha_ctc.cc b/storage/ctc/ha_ctc.cc index 1e14959..6032249 100644 --- a/storage/ctc/ha_ctc.cc +++ b/storage/ctc/ha_ctc.cc @@ -193,7 +193,7 @@ static MYSQL_THDVAR_DOUBLE(sampling_ratio, PLUGIN_VAR_RQCMDARG, __attribute__((visibility("default"))) uint32_t ctc_instance_id = 0; static MYSQL_SYSVAR_UINT(instance_id, ctc_instance_id, PLUGIN_VAR_READONLY, - "mysql instance id which is used for daac", nullptr, + "mysql instance id which is used for cantian", nullptr, nullptr, 0, 0, UINT32_MAX, 0); static void ctc_gather_change_stats_update(THD *, SYS_VAR *, void *var_ptr, const void *save) { @@ -1331,7 +1331,7 @@ int get_tch_in_handler_data(handlerton *hton, THD *thd, ctc_handler_t &tch, bool tch.query_id = thd->query_id; tch.sql_stat_start = sess_ctx->sql_stat_start; tch.pre_sess_addr = 0; -#ifndef WITH_DAAC +#ifndef WITH_CANTIAN tch.msg_buf = sess_ctx->msg_buf; if (sess_ctx->msg_buf == nullptr && alloc_msg_buf) { @@ -1448,7 +1448,7 @@ void update_member_tch(ctc_handler_t &tch, handlerton *hton, THD *thd, bool allo tch.query_id = thd->query_id; tch.sql_stat_start = sess_ctx->sql_stat_start; tch.pre_sess_addr = 0; -#ifndef WITH_DAAC +#ifndef WITH_CANTIAN tch.msg_buf = sess_ctx->msg_buf; if (sess_ctx->msg_buf == nullptr && alloc_msg_buf) { @@ -1474,7 +1474,7 @@ void release_sess_ctx(thd_sess_ctx_s *sess_ctx, handlerton *hton, THD *thd) { delete sess_ctx->invalid_cursors; sess_ctx->invalid_cursors = nullptr; } -#ifndef WITH_DAAC +#ifndef WITH_CANTIAN if (sess_ctx->msg_buf != nullptr) { sem_destroy(&(((dsw_message_block_t*)(sess_ctx->msg_buf))->head.sem)); shm_free(nullptr, sess_ctx->msg_buf); @@ -3843,7 +3843,7 @@ int ha_ctc::delete_all_rows() { max_supported_keys() is called when create indexes; @details - To get the the maximum number of indexes per table of DAAC + To get the the maximum number of indexes per table of CANTIAN */ uint ha_ctc::max_supported_keys() const { return CTC_MAX_KEY_NUM; @@ -3854,7 +3854,7 @@ uint ha_ctc::max_supported_keys() const { max_supported_key_length() is called when create indexes; @details - To get the max possible key length of DAAC + To get the max possible key length of CANTIAN */ uint ha_ctc::max_supported_key_length() const { return CTC_MAX_KEY_LENGTH; @@ -4177,8 +4177,8 @@ THR_LOCK_DATA **ha_ctc::store_lock(THD *, THR_LOCK_DATA **to, This method should not be called for internal temporary tables as they don't have properly initialized THR_LOCK and THR_LOCK_DATA structures. - daac engine dose not need mysql lock type, need long testing on this. - May need map mysql lock type to daac lock type in the future after figure + cantian engine dose not need mysql lock type, need long testing on this. + May need map mysql lock type to cantian lock type in the future after figure out they lock meaning. */ DBUG_TRACE; @@ -4482,7 +4482,7 @@ int ctc_set_cluster_role_by_cantian(bool is_slave) { bool is_single_run_mode() { -#ifndef WITH_DAAC +#ifndef WITH_CANTIAN return false; #else return true; diff --git a/storage/ctc/ha_ctc_ddl.h b/storage/ctc/ha_ctc_ddl.h index 4c7fd43..9bce090 100644 --- a/storage/ctc/ha_ctc_ddl.h +++ b/storage/ctc/ha_ctc_ddl.h @@ -138,7 +138,7 @@ typedef enum { COLLATE_LATIN2_GENERAL_CI = 309 } enum_ctc_ddl_collate_type; -// mysql字符序和daac的参数对接 +// mysql字符序和cantian的参数对接 static map mysql_collate_num_to_ctc_type = { {3, COLLATE_DEC8_SWEDISH_CI}, {4, COLLATE_CP850_GENERAL_CI}, diff --git a/storage/ctc/mysql_daac_plugin.cc b/storage/ctc/mysql_cantian_plugin.cc similarity index 73% rename from storage/ctc/mysql_daac_plugin.cc rename to storage/ctc/mysql_cantian_plugin.cc index 8b3fc11..757469f 100644 --- a/storage/ctc/mysql_daac_plugin.cc +++ b/storage/ctc/mysql_cantian_plugin.cc @@ -41,8 +41,8 @@ #include "ha_ctc.h" #include "decimal_convert.h" -struct mysql_daac_context { - my_thread_handle daac_startup_thread; +struct mysql_cantian_context { + my_thread_handle cantian_startup_thread; }; extern "C" { @@ -75,10 +75,10 @@ static std::string get_cantiand_home_dir() { return home_dir; } -static void *mysql_daac_startup_thread(void *p) { +static void *mysql_cantian_startup_thread(void *p) { DBUG_TRACE; - struct mysql_daac_context *con = (struct mysql_daac_context *)p; - if(con->daac_startup_thread.thread == 0) { + struct mysql_cantian_context *con = (struct mysql_cantian_context *)p; + if(con->cantian_startup_thread.thread == 0) { ctc_log_error("please create the nomont thread first!"); return nullptr; } @@ -95,20 +95,20 @@ static void *mysql_daac_startup_thread(void *p) { home_dir.c_str()}; ret = cantiand_lib_main(3, const_cast(argv)); } - ctc_log_system("init daac mode:%s,home_dir:%s, ret:%d", mode.c_str(), + ctc_log_system("init cantian mode:%s,home_dir:%s, ret:%d", mode.c_str(), home_dir.c_str(), ret); return nullptr; } -struct mysql_daac_context *daac_context = NULL; -int daemon_daac_plugin_init() { +struct mysql_cantian_context *cantian_context = NULL; +int daemon_cantian_plugin_init() { DBUG_TRACE; // mysql with nometa does not need to start cantian startup thread in multiple process when initializing // but single process needs to start up cantian thread in both meat and nometa when initializing if (!is_single_run_mode()) { if (opt_initialize_insecure) { - ctc_log_warning("initialize-insecure mode no need start the daac startup thread."); + ctc_log_warning("initialize-insecure mode no need start the cantian startup thread."); return 0; } @@ -120,45 +120,45 @@ int daemon_daac_plugin_init() { } } - if (daac_context != NULL) { - ctc_log_error("daemon_daac_plugin_init daac_context:%p not NULL", daac_context); + if (cantian_context != NULL) { + ctc_log_error("daemon_cantian_plugin_init cantian_context:%p not NULL", cantian_context); return 0; } - daac_context = (struct mysql_daac_context *)my_malloc( + cantian_context = (struct mysql_cantian_context *)my_malloc( PSI_NOT_INSTRUMENTED, - sizeof(struct mysql_daac_context), MYF(0)); - if (daac_context == nullptr) { - ctc_log_error("alloc mem failed, daac_context size(%lu)", sizeof(struct mysql_daac_context)); + sizeof(struct mysql_cantian_context), MYF(0)); + if (cantian_context == nullptr) { + ctc_log_error("alloc mem failed, cantian_context size(%lu)", sizeof(struct mysql_cantian_context)); return -1; } my_thread_attr_t startup_attr; /* Thread attributes */ my_thread_attr_init(&startup_attr); my_thread_attr_setdetachstate(&startup_attr, MY_THREAD_CREATE_JOINABLE); /* now create the startup thread */ - if (my_thread_create(&daac_context->daac_startup_thread, &startup_attr, mysql_daac_startup_thread, - (void *)daac_context) != 0) { - ctc_log_error("Could not create daac startup thread!"); + if (my_thread_create(&cantian_context->cantian_startup_thread, &startup_attr, mysql_cantian_startup_thread, + (void *)cantian_context) != 0) { + ctc_log_error("Could not create cantian startup thread!"); return -1; } return 0; } -int daemon_daac_plugin_deinit() { +int daemon_cantian_plugin_deinit() { DBUG_TRACE; void *dummy_retval; - if (daac_context == nullptr || daac_context->daac_startup_thread.thread == 0) { + if (cantian_context == nullptr || cantian_context->cantian_startup_thread.thread == 0) { ctc_log_system("startup thread not started"); return 0; } ct_singlep_shutdown(); - my_thread_join(&daac_context->daac_startup_thread, &dummy_retval); - my_free(daac_context); - daac_context = NULL; + my_thread_join(&cantian_context->cantian_startup_thread, &dummy_retval); + my_free(cantian_context); + cantian_context = NULL; return 0; } -int (*ctc_init)() = daemon_daac_plugin_init; -int (*ctc_deinit)() = daemon_daac_plugin_deinit; +int (*ctc_init)() = daemon_cantian_plugin_init; +int (*ctc_deinit)() = daemon_cantian_plugin_deinit; -- Gitee From 3d59895d2a4fd42987260b481eb2d6af3f54b694 Mon Sep 17 00:00:00 2001 From: qiuyang19960521 Date: Thu, 7 Nov 2024 19:38:40 +0800 Subject: [PATCH 3/8] fix(compile): eversql compile fail --- storage/ctc/ctc_ddl_rewriter_plugin.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/storage/ctc/ctc_ddl_rewriter_plugin.cc b/storage/ctc/ctc_ddl_rewriter_plugin.cc index 64c5b3f..81c2195 100644 --- a/storage/ctc/ctc_ddl_rewriter_plugin.cc +++ b/storage/ctc/ctc_ddl_rewriter_plugin.cc @@ -636,7 +636,7 @@ static int ctc_check_set_opt(string &sql_str, MYSQL_THD thd, bool &need_forward) #ifdef FEATURE_X_FOR_MYSQL_26 ret = ctc_set_var_meta(thd, options, setvar->base.str, name_str, val_str, var_real_type); #elif defined(FEATURE_X_FOR_MYSQL_32) - ret = ctc_set_var_meta(thd, options, setvar->m_var_tracker.get_var_name() + ret = ctc_set_var_meta(thd, options, setvar->m_var_tracker.get_var_name(), name_str, val_str, var_real_type); #endif } else { -- Gitee From de71fb7274c8bfdfa5aab6be463de57fd1c328ec Mon Sep 17 00:00:00 2001 From: qiuyang19960521 Date: Tue, 5 Nov 2024 16:40:23 +0800 Subject: [PATCH 4/8] fix(DDL): set global opt error code postback --- storage/ctc/ctc_ddl_rewriter_plugin.cc | 5 +++++ storage/ctc/ctc_meta_data.cc | 15 +++++++++------ storage/ctc/ctc_srv_mq_stub.cc | 5 +++-- 3 files changed, 17 insertions(+), 8 deletions(-) diff --git a/storage/ctc/ctc_ddl_rewriter_plugin.cc b/storage/ctc/ctc_ddl_rewriter_plugin.cc index 81c2195..45aa8d3 100644 --- a/storage/ctc/ctc_ddl_rewriter_plugin.cc +++ b/storage/ctc/ctc_ddl_rewriter_plugin.cc @@ -492,6 +492,11 @@ static int ctc_set_var_meta(MYSQL_THD thd, uint32_t options, const char* base_na } broadcast_req.options |= options; int ret = ctc_execute_mysql_ddl_sql(&tch, &broadcast_req, true); + if (ret != 0 && broadcast_req.err_code != 0) { + string err_msg = broadcast_req.err_msg; + my_printf_error(broadcast_req.err_code, "%s", MYF(0), err_msg.c_str()); + return ret; + } update_sess_ctx_by_tch(tch, hton, thd); return ret; } diff --git a/storage/ctc/ctc_meta_data.cc b/storage/ctc/ctc_meta_data.cc index 5f72ba3..5909e3a 100644 --- a/storage/ctc/ctc_meta_data.cc +++ b/storage/ctc/ctc_meta_data.cc @@ -894,10 +894,11 @@ int ctc_set_sys_var(ctc_ddl_broadcast_request *broadcast_req) { } sysvar = intern_find_sys_var(var_name.c_str(), var_name.length()); - int ret = -1; if (sysvar == nullptr) { + my_error(ER_UNKNOWN_SYSTEM_VARIABLE, MYF(0), var_name.c_str()); + strncpy(broadcast_req->err_msg, new_thd->get_stmt_da()->message_text(), ERROR_MESSAGE_LEN - 1); ctc_log_error("[ctc_set_sys_var]:sysvar is nullptr and var_name : %s", var_name.c_str()); - return ret; + return ER_UNKNOWN_SYSTEM_VARIABLE; } ctc_get_set_var_item(new_thd, sysvar, &res, var_value, is_null_value, var_is_int); @@ -916,11 +917,13 @@ int ctc_set_sys_var(ctc_ddl_broadcast_request *broadcast_req) { var = new (new_thd->mem_root) set_var(type, var_tracker, res); #endif tmp_var_list.push_back(var); - ret = sql_set_variables(new_thd, &tmp_var_list, false); + int ret = sql_set_variables(new_thd, &tmp_var_list, false); if (ret != 0) { - ctc_log_error("[ctc_set_sys_var]:set global opt faili;var_name : %s, var_value: %s", - var_name.c_str(), var_value.c_str()); - return ret; + uint err_code = new_thd->get_stmt_da()->mysql_errno(); + strncpy(broadcast_req->err_msg, new_thd->get_stmt_da()->message_text(), ERROR_MESSAGE_LEN - 1); + ctc_log_error("[ctc_set_sys_var]:set global opt fail; err_code: %u, var_name: %s, var_value: %s", + err_code, var_name.c_str(), var_value.c_str()); + return err_code; } tmp_var_list.clear(); diff --git a/storage/ctc/ctc_srv_mq_stub.cc b/storage/ctc/ctc_srv_mq_stub.cc index 670c826..4d56307 100644 --- a/storage/ctc/ctc_srv_mq_stub.cc +++ b/storage/ctc/ctc_srv_mq_stub.cc @@ -1346,6 +1346,7 @@ int ctc_execute_mysql_ddl_sql(ctc_handler_t *tch, ctc_ddl_broadcast_request *bro int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_EXCUTE_MYSQL_DDL_SQL, req, tch->msg_buf); *tch = req->tch; broadcast_req->err_code = req->broadcast_req.err_code; + strncpy(broadcast_req->err_msg, req->broadcast_req.err_msg, ERROR_MESSAGE_LEN - 1); if (ret == CT_SUCCESS) { result = req->result; } @@ -1389,7 +1390,7 @@ int ctc_broadcast_rewrite_sql(ctc_handler_t *tch, ctc_ddl_broadcast_request *bro int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_BROADCAST_REWRITE_SQL, req, tch->msg_buf); *tch = req->tch; broadcast_req->err_code = req->broadcast_req.err_code; - strncpy(broadcast_req->err_msg, req->broadcast_req.err_msg, ERROR_MESSAGE_LEN); + strncpy(broadcast_req->err_msg, req->broadcast_req.err_msg, ERROR_MESSAGE_LEN - 1); if (ret == CT_SUCCESS) { result = req->result; } @@ -1607,7 +1608,7 @@ int ctc_record_sql_for_cantian(ctc_handler_t *tch, ctc_ddl_broadcast_request *br int ret = ctc_mq_deal_func(shm_inst, CTC_FUNC_TYPE_RECORD_SQL, req, tch->msg_buf); *tch = req->tch; broadcast_req->err_code = req->broadcast_req.err_code; - strncpy(broadcast_req->err_msg, req->broadcast_req.err_msg, ERROR_MESSAGE_LEN); + strncpy(broadcast_req->err_msg, req->broadcast_req.err_msg, ERROR_MESSAGE_LEN - 1); if (ret == CT_SUCCESS) { result = req->result; } -- Gitee From 4fdc2f4816830576e978536b39e2a8ff46c7c23d Mon Sep 17 00:00:00 2001 From: lijieac Date: Thu, 7 Nov 2024 20:18:25 +0800 Subject: [PATCH 5/8] perf(decimal): support direct conversion between Cantian's decimal and MySQL's decimal types Signed-off-by: lijieac --- storage/ctc/datatype_cnvrtr.cc | 204 ++++++++++++++++++++++++++++----- 1 file changed, 174 insertions(+), 30 deletions(-) diff --git a/storage/ctc/datatype_cnvrtr.cc b/storage/ctc/datatype_cnvrtr.cc index 7ad5c9e..fde35e4 100644 --- a/storage/ctc/datatype_cnvrtr.cc +++ b/storage/ctc/datatype_cnvrtr.cc @@ -357,6 +357,175 @@ static inline uint32_t read_from_2_little_endian(const uint8_t *buf) return ((uint32_t)(buf[0]) | ((uint32_t)(buf[1]) << 8)); } +static inline void record_digital(uint8 *digits, int32 val, int start, int step) +{ + int end = start + step - 1; + while (val != 0 && end >= start) { + digits[end] = val % 10; + val /= 10; + end--; + } +} + +// [start, end] left-closed, right-closed +int32 restore_digital(uint8 *digits, int start, int end, int step) +{ + int32 val = 0; + int newEnd = start + step - 1; + while (start <= end) { + val = val * 10 + digits[start]; + start++; + } + while (start <= newEnd) { + val = val * 10; + start++; + } + return val; +} + +void remove_leading_zero(uint8 *digits, int &start, int &point, int &end) +{ + while (end > point && digits[end] == 0) { + end--; + } + start = 0; + while (start < point && digits[start] == 0) { + start++; + } +} + +#define DIG_PER_MYDEC 9 +#define DIG_PER_DEC4 4 +void convert_mydec_to_digital(my_decimal *myd, uint8 *digits, int &start, int &point, int &end) +{ + // integer part + int i = 0; + int my_point_loc = (myd->intg + DIG_PER_MYDEC - 1) / DIG_PER_MYDEC; + while (i < my_point_loc) { + record_digital(digits, (int32)myd->buf[i], i * DIG_PER_MYDEC, DIG_PER_MYDEC); + i++; + } + + if (myd->frac != 0) { + int my_frac_loc = (myd->frac + DIG_PER_MYDEC - 1) / DIG_PER_MYDEC + my_point_loc; + while (i < my_frac_loc) { + record_digital(digits, (int32)myd->buf[i], i * DIG_PER_MYDEC, DIG_PER_MYDEC); + i++; + } + } + point = my_point_loc * DIG_PER_MYDEC; // the first fraction index + end = point + myd->frac - 1; // the last fraction index + remove_leading_zero(digits, start, point, end); +} + +void convert_digital_to_dec4(dec4_t *d4, uint8 *digits, bool sign, int start, int point, int end) +{ + int expn = point - start; + int cell0_num = 0; // number of digits in cells[0] + d4->sign = sign ? 1 : 0; + if (expn > 0) { + cell0_num = expn % DIG_PER_DEC4; + if (cell0_num == 0 && expn >= DIG_PER_DEC4) { + expn -= DIG_PER_DEC4; + } + } else { + cell0_num = DIG_PER_DEC4 + (expn % DIG_PER_DEC4); + expn -= cell0_num; + } + d4->expn = expn / DIG_PER_DEC4; + // record digital to cell of dec4 + int cell_idx = 0, digidx = start; + // cells[0] + if (cell0_num != 0) { + d4->cells[cell_idx] = 0; + while (digidx < start + cell0_num) { + d4->cells[cell_idx] = d4->cells[cell_idx] * 10 + digits[digidx]; + digidx++; + } + cell_idx++; + } + // remaining numbers + while (digidx <= end) { + d4->cells[cell_idx] = 0; + if (digidx + DIG_PER_DEC4 <= end) { + d4->cells[cell_idx] = restore_digital(digits, digidx, digidx + DIG_PER_DEC4 - 1, DIG_PER_DEC4); + } else { + d4->cells[cell_idx] = restore_digital(digits, digidx, end, DIG_PER_DEC4); + } + digidx += DIG_PER_DEC4; + cell_idx++; + } + d4->ncells = cell_idx; +} + +void convert_dec4_to_digital(dec4_t *dec4, uint8 *digits, int &start, int &point, int &end) +{ + if (dec4->cells == 0) { + start = point = end = 0; + return; + } + // only fraction + int i = 0, j = 0; + if (dec4->expn >= 0) { + point = (dec4->expn + 1) * DIG_PER_DEC4; // the first fraction index + } else if (dec4->expn < 0) { + point = 0; + i = -(dec4->expn + 1); + } + start = i * DIG_PER_DEC4; + while (j < dec4->ncells) { + record_digital(digits, (int32)dec4->cells[j], i * DIG_PER_DEC4, DIG_PER_DEC4); + i++; + j++; + } + end = i * DIG_PER_DEC4 - 1; // the last fraction index + remove_leading_zero(digits, start, point, end); +} + +void convert_digital_to_mydec(my_decimal *mydec, uint8 *digits, bool sign, int start, int point, int end) +{ + mydec->sign(sign); + mydec->intg = point - start; + mydec->frac = end - point + 1; + int buf_idx = 0, digidx = start, buf0_num = mydec->intg % DIG_PER_MYDEC; + // buf[0] + if (buf0_num != 0) { + mydec->buf[0] = 0; + while (digidx < start + buf0_num) { + mydec->buf[0] = mydec->buf[0] * 10 + digits[digidx]; + digidx++; + } + buf_idx = 1; + } + // remaining numbers + while (digidx <= end) { + mydec->buf[buf_idx] = 0; + if (digidx + DIG_PER_MYDEC <= end) { + mydec->buf[buf_idx] = restore_digital(digits, digidx, digidx + DIG_PER_MYDEC - 1, DIG_PER_MYDEC); + } else { + mydec->buf[buf_idx] = restore_digital(digits, digidx, end, DIG_PER_MYDEC); + } + digidx += DIG_PER_MYDEC; + buf_idx++; + } +} + +void convert_mydec_to_dec4(my_decimal *from, dec4_t *to) +{ + uint8 digits[DECIMAL_MAX_STR_LENGTH] = {0}; + int start = 0, point = 0, end = 0; + convert_mydec_to_digital(from, digits, start, point, end); + convert_digital_to_dec4(to, digits, from->sign(), start, point, end); +} + +void convert_dec4_to_mydec(dec4_t *from, my_decimal *to) +{ + uint8 digits[DECIMAL_MAX_STR_LENGTH] = {0}; + int start = 0, point = 0, end = 0; + convert_dec4_to_digital(from, digits, start, point, end); + convert_digital_to_mydec(to, digits, from->sign != 0, start, point, end); +} + /** @brief decimal is stored by my_decimal struct in mysql , and stored by dec4_t in cantian; @@ -377,42 +546,17 @@ int decimal_mysql_to_cantian(const uint8_t *mysql_ptr, uchar *cantian_ptr, Field ctc_log_error("[mysql2cantians]Decimal data type convert binary to my_decimal failed!"); return ret; } - char buff[DECIMAL_MAX_STR_LENGTH + 1]; - int len = sizeof(buff); - ret = decimal2string(&d, buff, &len); - if (ret != E_DEC_OK) { - ctc_log_error("[mysql2cantian]Decimal data type convert my_decimal to string failed!"); - return ret; - } - dec8_t d8; - if (ct_cm_str_to_dec8(buff, &d8) != CT_SUCCESS_STATUS) { - ctc_log_error("[mysql2cantian]Decimal data type convert str to dec8 failed!"); - assert(0); - } - cm_dec_8_to_4((dec4_t *)cantian_ptr, &d8); + dec4_t *d4 = (dec4_t *)cantian_ptr; + convert_mydec_to_dec4(&d, d4); *length = (uint32)cm_dec4_stor_sz((dec4_t *)cantian_ptr); return ret; } void decimal_cantian_to_mysql(uint8_t *mysql_ptr, uchar *cantian_ptr, Field *mysql_field) { - dec8_t dec; + my_decimal mydec; dec4_t *d4 = (dec4_t *)cantian_ptr; - ct_cm_dec_4_to_8(&dec, d4, (uint32)cm_dec4_stor_sz(d4)); - char str[DEC_MAX_NUM_SAVING_PREC]; - if (ct_cm_dec8_to_str(&dec, DEC_MAX_NUM_SAVING_PREC, str) != CT_SUCCESS_STATUS) { - ctc_log_error("[cantian2mysql]Decimal data type convert dec8 to str failed!"); - assert(0); - } - - my_decimal decimal_value; - const char *decimal_data = str; - const char *end = strend(decimal_data); - if (string2decimal(decimal_data, &decimal_value, &end) != E_DEC_OK) { - ctc_log_error("[cantian2mysql]Decimal data type convert str to my_decimal failed!"); - assert(0); - } - + convert_dec4_to_mydec(d4, &mydec); Field_new_decimal *f = dynamic_cast(mysql_field); if (f == nullptr) { ctc_log_error("[cantian2mysql]Decimal data type convert my_decimal to binary failed!"); @@ -421,7 +565,7 @@ void decimal_cantian_to_mysql(uint8_t *mysql_ptr, uchar *cantian_ptr, Field *mys const int prec = f->precision; const int scale = mysql_field->decimals(); - if (my_decimal2binary(E_DEC_FATAL_ERROR, &decimal_value, mysql_ptr, prec, scale) != E_DEC_OK) { + if (my_decimal2binary(E_DEC_FATAL_ERROR, &mydec, mysql_ptr, prec, scale) != E_DEC_OK) { ctc_log_error("[cantian2mysql]Decimal data type convert my_decimal to binary failed!"); assert(0); } -- Gitee From 8e51f1a9b28a74b3d574311dd6840d4010d751fe Mon Sep 17 00:00:00 2001 From: yuanyazhi Date: Thu, 14 Nov 2024 10:18:42 +0800 Subject: [PATCH 6/8] broadcast_global_var --- storage/ctc/ctc_ddl_rewriter_plugin.cc | 14 +------------- 1 file changed, 1 insertion(+), 13 deletions(-) diff --git a/storage/ctc/ctc_ddl_rewriter_plugin.cc b/storage/ctc/ctc_ddl_rewriter_plugin.cc index 45aa8d3..5da5639 100644 --- a/storage/ctc/ctc_ddl_rewriter_plugin.cc +++ b/storage/ctc/ctc_ddl_rewriter_plugin.cc @@ -210,22 +210,10 @@ int unsupport_tx_isolation_level(set_var *setvar, bool &need_forward MY_ATTRIBUT return -1; } -int ctc_check_opt_forward(set_var *setvar MY_ATTRIBUTE((unused)), bool &need_forward, - string user_val_str MY_ATTRIBUTE((unused))) { - need_forward = false; - push_warning_printf(current_thd, Sql_condition::SL_WARNING, ER_DISALLOWED_OPERATION, - "CTC: This parameter will not be broadcast to other nodes."); - return 0; -} - static std::unordered_map set_variable_rules_map = { {"default_storage_engine", check_default_engine}, {"max_connections", check_session_pool_volume}, - {"transaction_isolation", unsupport_tx_isolation_level}, - {"read_only", ctc_check_opt_forward}, - {"super_read_only", ctc_check_opt_forward}, - {"offline_mode", ctc_check_opt_forward}, - {"gtid_next", ctc_check_opt_forward} + {"transaction_isolation", unsupport_tx_isolation_level} }; static int ctc_get_user_var_string(MYSQL_THD thd, Item_func_get_user_var *itemFunc, string &user_val_str) { -- Gitee From 92fea48cd534fb6009fddc6c9319b73de08443fa Mon Sep 17 00:00:00 2001 From: liuzifeng Date: Thu, 7 Nov 2024 10:36:58 +0800 Subject: [PATCH 7/8] fix set var --- storage/ctc/ctc_ddl_rewriter_plugin.cc | 127 +++++++++++++++++-------- storage/ctc/ha_ctc.cc | 46 +++++---- storage/ctc/ha_ctc.h | 7 ++ storage/ctc/ha_ctc_ddl.h | 6 ++ 4 files changed, 126 insertions(+), 60 deletions(-) diff --git a/storage/ctc/ctc_ddl_rewriter_plugin.cc b/storage/ctc/ctc_ddl_rewriter_plugin.cc index 64c5b3f..b1bb6a2 100644 --- a/storage/ctc/ctc_ddl_rewriter_plugin.cc +++ b/storage/ctc/ctc_ddl_rewriter_plugin.cc @@ -436,20 +436,6 @@ static int ctc_check_flush(string &, MYSQL_THD thd, bool &need_forward) { return 0; } -static unordered_set set_variable_not_broadcast{"ctc_ddl_local_enabled", "ctc_ddl_enabled"}; -static bool ctc_check_ddl_local_enable(string sql_str, bool &need_forwar) { - transform(sql_str.begin(), sql_str.end(), sql_str.begin(), ::tolower); - - for (auto it : set_variable_not_broadcast) { - if (sql_str.find(it) != sql_str.npos) { - need_forwar = false; - return true; - } - } - - return false; -} - static uint32_t ctc_set_var_option(bool is_null_value, bool is_set_default_value, set_var *setvar) { uint32_t options = 0; @@ -565,29 +551,74 @@ static int ctc_check_set_opt_rule(set_var *setvar, string& name_str, string& use return ret; } -/* 参考set_var.cc: sql_set_variables */ -static int ctc_check_set_opt(string &sql_str, MYSQL_THD thd, bool &need_forward) { - if (ctc_check_ddl_local_enable(sql_str, need_forward)) { +static int ctc_set_user_var_flag(MYSQL_THD thd, string name, string value) { + handlerton* hton = get_ctc_hton(); + thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(hton, thd); + if (sess_ctx == nullptr) { + return HA_ERR_OUT_OF_MEM; + } + bool is_flag_set = (value == "1") || (value == "true"); + bool is_flag_unset = (value == "0") || (value == "false") || (value == "NULL"); + auto it = user_var_flag_map.find(name); + if (it != user_var_flag_map.end()) { + if (is_flag_set) { + sess_ctx->set_flag |= it->second; + } else if (is_flag_unset) { + sess_ctx->set_flag &= ~it->second; + } else { + my_printf_error(ER_UNKNOWN_COM_ERROR, "Invalid variable value for '%s': '%s'", MYF(0), + name.c_str(), value.c_str()); + return -1; + } + } + return 0; +} + +static int check_non_system_var(set_var_base *var, bool& need_forward, MYSQL_THD thd) { + need_forward = false; + if (typeid(*var) != typeid(set_var_user)) { return 0; } - List_iterator_fast var_it(thd->lex->var_list); + set_var_user *setvar_user = dynamic_cast(var); + String set_str; + string var_name; + string var_value; + // 参考set_var.cc: set_var_user::print + // set_str由print函数追加"@"和":="生成 + setvar_user->print(thd, &set_str); + if (set_str.ptr() == nullptr || set_str.length() == 0) { + my_printf_error(ER_NOT_ALLOWED_COMMAND, "%s", MYF(0), "The used command is not allowed"); + return -1; + } + string str(set_str.ptr(), set_str.length()); + size_t pos = str.find("@"); + if (pos != str.npos) { + size_t end_pos = str.find(":=", pos); + if (end_pos != str.npos) { + size_t name_start = pos + 1; + size_t name_len = end_pos - name_start; + var_name = str.substr(name_start, name_len); + } + } + size_t value_pos = str.find(":="); + if (value_pos != str.npos) { + size_t value_start = value_pos + 2; + size_t value_len = str.length() - value_start; + var_value = str.substr(value_start, value_len); + } - set_var_base *var = nullptr; + return ctc_set_user_var_flag(thd, var_name, var_value); +} + +static int check_system_var(set_var_base *var, string &sql_str, MYSQL_THD thd, + bool& need_forward, bool& contain_subselect) { + set_var *setvar = dynamic_cast(var); + bool is_set_default_value = false; + bool is_null_value = false; int ret = 0; string name_str; string val_str; - - // broadcast SET_OPTION query with subselect item - bool contain_subselect = false; - if (thd->lex->query_tables) { - contain_subselect = true; - } - var_it.rewind(); - while ((var = var_it++)) { - set_var *setvar = dynamic_cast(var); - bool is_set_default_value = false; - bool is_null_value = false; #ifdef FEATURE_X_FOR_MYSQL_32 if (setvar) { std::function f = [&thd, &need_forward, setvar] @@ -616,19 +647,16 @@ static int ctc_check_set_opt(string &sql_str, MYSQL_THD thd, bool &need_forward) } ret |= ctc_check_set_opt_rule(setvar, name_str, val_str, need_forward); } - } else { - // There's no need to broadcast non-set_var SET_OPTION cmds. - need_forward = false; } - if (need_forward && allow_sqlcmd(thd, "ctc_setopt_disabled") != 0) { - my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), "Set global variable query is not allowed (ctc_setopt_disabled = true)"); + my_printf_error(ER_DISALLOWED_OPERATION, "%s", MYF(0), + "Set global variable query is not allowed (ctc_setopt_disabled = true)"); return -1; } - if(IS_METADATA_NORMALIZATION() && !contain_subselect && need_forward && setvar) { + if (IS_METADATA_NORMALIZATION() && !contain_subselect && need_forward && setvar) { if (setvar->check(thd) == 0) { - bool var_real_type = false; + bool var_real_type = false; if (setvar->value && setvar->value->result_type() == INT_RESULT) { var_real_type = true; } @@ -636,15 +664,36 @@ static int ctc_check_set_opt(string &sql_str, MYSQL_THD thd, bool &need_forward) #ifdef FEATURE_X_FOR_MYSQL_26 ret = ctc_set_var_meta(thd, options, setvar->base.str, name_str, val_str, var_real_type); #elif defined(FEATURE_X_FOR_MYSQL_32) - ret = ctc_set_var_meta(thd, options, setvar->m_var_tracker.get_var_name() + ret = ctc_set_var_meta(thd, options, setvar->m_var_tracker.get_var_name(), name_str, val_str, var_real_type); #endif } else { thd->clear_error(); - need_forward = false; // 值校验失败, ctc不进行广播并返回成功, 后续报错由MySQL完成 + need_forward = false; // 值校验失败, ctc不进行广播并返回成功, 后续报错由MySQL完成 } } + return ret; +} +/* 参考set_var.cc: sql_set_variables */ +static int ctc_check_set_opt(string &sql_str, MYSQL_THD thd, bool &need_forward) { + List_iterator_fast var_it(thd->lex->var_list); + + set_var_base *var = nullptr; + int ret = 0; + + // broadcast SET_OPTION query with subselect item + bool contain_subselect = false; + if (thd->lex->query_tables) { + contain_subselect = true; + } + var_it.rewind(); + while ((var = var_it++)) { + if (typeid(*var) != typeid(set_var)) { + ret = check_non_system_var(var, need_forward, thd); + } else { + ret = check_system_var(var, sql_str, thd, need_forward, contain_subselect); + } ctc_log_debug("set option %s, need_forward: %d", sql_str.c_str(), need_forward); } if (IS_METADATA_NORMALIZATION() && !contain_subselect) { diff --git a/storage/ctc/ha_ctc.cc b/storage/ctc/ha_ctc.cc index 6032249..c4dfb3d 100644 --- a/storage/ctc/ha_ctc.cc +++ b/storage/ctc/ha_ctc.cc @@ -340,16 +340,6 @@ static inline bool is_create_table_check(MYSQL_THD thd) { return (thd->lex->sql_command == SQLCOM_CREATE_TABLE && thd->lex->is_exec_started()); } -bool user_var_set(MYSQL_THD thd, string target_str) { - user_var_entry *var_entry; - var_entry = find_or_nullptr(thd->user_vars, target_str); - if (var_entry != nullptr && var_entry->ptr() != nullptr) { - ctc_log_debug("thd (%d) has user variable %s", thd->thread_id(), target_str.data()); - return true; - } - return false; -} - dml_flag_t ctc_get_dml_flag(THD *thd, bool is_replace, bool auto_inc_used, bool has_explicit_autoinc, bool dup_update) { dml_flag_t flag; @@ -412,13 +402,22 @@ bool is_alter_table_scan(bool m_error_if_not_empty) { } bool ddl_enabled_normal(MYSQL_THD thd) { - return !user_var_set(thd, "ctc_ddl_local_enabled") && - (ctc_concurrent_ddl == true || user_var_set(thd, "ctc_ddl_enabled")); + handlerton* hton = get_ctc_hton(); + thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(hton, thd); + assert(sess_ctx != nullptr); + // 1.CTC_DDL_LOCAL_ENABLED被设置：不能从rewrite插件下发任何SQL语句 + // 2.CTC_DDL_LOCAL_ENABLED没被设置，ctc_concurrent_ddl=true，允许运行到判断是否广播的逻辑中 + // 3.CTC_DDL_LOCAL_ENABLED没被设置，ctc_concurrent_ddl=false，若CTC_DDL_ENABLED被设置，允许运行到判断是否广播的逻辑中 + return !(sess_ctx->set_flag & CTC_DDL_LOCAL_ENABLED) && + (ctc_concurrent_ddl == true || (sess_ctx->set_flag & CTC_DDL_ENABLED)); } bool engine_skip_ddl(MYSQL_THD thd) { + handlerton* hton = get_ctc_hton(); + thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(hton, thd); + assert(sess_ctx != nullptr); // 接口流程不需要走到参天: 用于参天SYS库操作 - return user_var_set(thd, "ctc_ddl_local_enabled") && ctc_concurrent_ddl == true; + return (sess_ctx->set_flag & CTC_DDL_LOCAL_ENABLED) && ctc_concurrent_ddl == true; } bool engine_ddl_passthru(MYSQL_THD thd) { @@ -426,7 +425,10 @@ bool engine_ddl_passthru(MYSQL_THD thd) { if (is_initialize() || is_meta_version_upgrading_force()) { return false; } - bool is_mysql_local = user_var_set(thd, "ctc_ddl_local_enabled"); + handlerton* hton = get_ctc_hton(); + thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(hton, thd); + assert(sess_ctx != nullptr); + bool is_mysql_local = (sess_ctx->set_flag & CTC_DDL_LOCAL_ENABLED); return is_initialize() || !mysqld_server_started || is_mysql_local; } @@ -437,12 +439,13 @@ bool ha_ctc::is_replay_ddl(MYSQL_THD thd) { if (mysql_system_db.find(db_name) != mysql_system_db.end()) { return false; } + + handlerton* hton = get_ctc_hton(); + thd_sess_ctx_s *sess_ctx = get_or_init_sess_ctx(hton, thd); + assert(sess_ctx != nullptr); - if (user_var_set(thd, "ctc_ddl_local_enabled") && user_var_set(thd, "ctc_replay_ddl")) { - return true; - } - - return false; + uint ctc_var_flag = (CTC_DDL_LOCAL_ENABLED | CTC_REPLAY_DDL); + return (sess_ctx->set_flag & ctc_var_flag) == ctc_var_flag; } static int ctc_reg_instance() { @@ -1297,6 +1300,7 @@ thd_sess_ctx_s *get_or_init_sess_ctx(handlerton *hton, THD *thd) { sess_ctx->invalid_cursors = nullptr; assert(sess_ctx->cursors_map->size() == 0); sess_ctx->msg_buf = nullptr; + sess_ctx->set_flag = 0; thd_set_ha_data(thd, hton, sess_ctx); } return sess_ctx; @@ -1528,7 +1532,7 @@ static int ctc_start_trx_and_assign_scn( int isolation_level = isolation_level_to_cantian(mysql_isolation); uint32_t lock_wait_timeout = THDVAR(thd, lock_wait_timeout); ctc_trx_context_t trx_context = {isolation_level, autocommit, lock_wait_timeout, false}; - bool is_mysql_local = user_var_set(thd, "ctc_ddl_local_enabled"); + bool is_mysql_local = (sess_ctx->set_flag & CTC_DDL_LOCAL_ENABLED); ct_errno_t ret = (ct_errno_t)ctc_trx_begin(&tch, trx_context, is_mysql_local); if (ret != CT_SUCCESS) { ctc_log_error("start trx failed with error code: %d", ret); @@ -4294,7 +4298,7 @@ int ha_ctc::start_stmt(THD *thd, thr_lock_type) { ctc_trx_context_t trx_context = {isolation_level, autocommit, lock_wait_timeout, m_select_lock == lock_mode::EXCLUSIVE_LOCK}; - bool is_mysql_local = user_var_set(thd, "ctc_ddl_local_enabled"); + bool is_mysql_local = (sess_ctx->set_flag & CTC_DDL_LOCAL_ENABLED); ct_errno_t ret = (ct_errno_t)ctc_trx_begin(&m_tch, trx_context, is_mysql_local); check_error_code_to_mysql(ha_thd(), &ret); diff --git a/storage/ctc/ha_ctc.h b/storage/ctc/ha_ctc.h index 43244b3..35f889d 100644 --- a/storage/ctc/ha_ctc.h +++ b/storage/ctc/ha_ctc.h @@ -191,6 +191,12 @@ enum class mysql_run_mode { DOUBLE }; +enum set_opt_flag { + CTC_DDL_LOCAL_ENABLED = 1 << 0, + CTC_DDL_ENABLED = 1 << 1, + CTC_REPLAY_DDL = 1 << 2 +}; + typedef int (*ctc_prefetch_fn)(ctc_handler_t *tch, uint8_t *records, uint16_t *record_lens, uint32_t *recNum, uint64_t *rowids, int32 max_row_size); @@ -977,6 +983,7 @@ typedef struct { std::unordered_map *cursors_map; std::vector *invalid_cursors; void* msg_buf; + uint set_flag; } thd_sess_ctx_s; #pragma pack() diff --git a/storage/ctc/ha_ctc_ddl.h b/storage/ctc/ha_ctc_ddl.h index 9bce090..910279f 100644 --- a/storage/ctc/ha_ctc_ddl.h +++ b/storage/ctc/ha_ctc_ddl.h @@ -177,6 +177,12 @@ static map g_ctc_alter_tab {ALTER_TABLESPACE_OPTIONS, CTC_ALTSPACE_SET_AUTOEXTEND}, // option 只有auto extend适配 }; +static const std::unordered_map user_var_flag_map = { + {"ctc_ddl_local_enabled", CTC_DDL_LOCAL_ENABLED}, + {"ctc_ddl_enabled", CTC_DDL_ENABLED}, + {"ctc_replay_ddl", CTC_REPLAY_DDL} +}; + class ctc_ddl_stack_mem { public: ctc_ddl_stack_mem(size_t mem_size):buf_obj(nullptr) { -- Gitee From f6c774c22cdb66cfba9ad070473623af57c38e7b Mon Sep 17 00:00:00 2001 From: zhangxuan_hw Date: Mon, 18 Nov 2024 18:00:15 +0800 Subject: [PATCH 8/8] =?UTF-8?q?=E6=B5=8B=E8=AF=95=E9=97=A8=E7=A6=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- storage/ctc/ha_ctc.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/storage/ctc/ha_ctc.cc b/storage/ctc/ha_ctc.cc index c4dfb3d..2ad574d 100644 --- a/storage/ctc/ha_ctc.cc +++ b/storage/ctc/ha_ctc.cc @@ -5488,6 +5488,7 @@ int ha_ctc::get_cbo_stats_4share() } return ret; + } void free_columns_cbo_stats(ctc_cbo_stats_column_t *ctc_cbo_stats_columns, bool *is_str_first_addr, TABLE *table) -- Gitee