| #!/bin/env python |
| # -*- coding: utf-8 -*- |
| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| |
| ############################################################################ |
| # |
| # @file test_sys_boolean.py |
| # @date 2020-07-08 15:24:04 |
| # @brief This file is a test file for boolean data type |
| # |
| ############################################################################# |
| |
| """ |
| 测试boolean类型 |
| """ |
| |
| import os |
| from data import schema as DATA |
| from lib import palo_config |
| from lib import palo_client |
| from lib import util |
| from lib import common |
| |
| config = palo_config.config |
| fe_http_port = config.fe_http_port |
| broker_info = palo_config.broker_info |
| file_dir = os.path.abspath(os.path.dirname(__file__)) |
| |
| |
| def setup_module(): |
| """ |
| setUp |
| """ |
| pass |
| |
| |
| def test_bool_create_table_wrong_1(): |
| """ |
| { |
| "title": "test_bool_create_table_wrong_1", |
| "describe": "验证boolean类型不支持max, min, sum三种聚合方式", |
| "tag": "fuzz,p1" |
| } |
| """ |
| database_name, table_name, rollup_table_name = util.gen_name_list() |
| client = common.create_workspace(database_name) |
| agg_type = ['MAX', 'MIN', 'SUM'] |
| for type in agg_type: |
| flag = True |
| try: |
| column_list = [('k1', 'BOOLEAN'), ('k2', 'INT'), ('v1', 'BOOLEAN', type)] |
| distribution = palo_client.DistributionInfo('Hash(k2)', 1) |
| client.create_table(table_name, column_list, distribution_info=distribution) |
| flag = False |
| except Exception as e: |
| print(str(e)) |
| pass |
| assert flag, 'expect create table faile' |
| client.clean(database_name) |
| |
| |
| def test_bool_create_table_wrong_2(): |
| """ |
| { |
| "title": "test_bool_create_table_wrong_2", |
| "describe": "验证boolean类型不支持作为分区列", |
| "tag": "fuzz,p1" |
| } |
| """ |
| database_name, table_name, rollup_table_name = util.gen_name_list() |
| client = common.create_workspace(database_name) |
| partition_name_list = ['p1', 'p2', 'p3'] |
| partition_column = ['k1', 'k2'] |
| partition_value_list = [('0', 'True'), ('10', 'True'), ('100', 'False')] |
| partition_info = palo_client.PartitionInfo(partition_column, partition_name_list, partition_value_list) |
| distribution_info = palo_client.DistributionInfo('HASH(k2)', 10) |
| flag = True |
| try: |
| client.create_table(table_name, DATA.boolean_column_list, partition_info, |
| distribution_info) |
| flag = False |
| except Exception as e: |
| print(str(e)) |
| assert flag |
| client.clean(database_name) |
| |
| |
| def test_bool_create_table_wrong_3(): |
| """ |
| { |
| "title": "test_bool_create_table_wrong_3", |
| "describe": "验证不支持创建boolean类型的bloom filter", |
| "tag": "fuzz,p1" |
| } |
| """ |
| """bug: bool类型作为bloom filter""" |
| database_name, table_name, rollup_table_name = util.gen_name_list() |
| client = common.create_workspace(database_name) |
| distribution_info = palo_client.DistributionInfo('HASH(k2)', 10) |
| flag = True |
| try: |
| client.create_table(table_name, DATA.boolean_column_list, distribution_info=distribution_info, |
| bloom_filter_column_list=['k1', 'k2']) |
| flag = False |
| except Exception as e: |
| print(str(e)) |
| assert flag |
| client.clean(database_name) |
| |
| |
| def test_bool_bucket_key(): |
| """ |
| { |
| "title": "test_bool_create_table_wrong_1", |
| "describe": "验证支持bool类型的hash分桶，导入，验证结果正确", |
| "tag": "system,p1" |
| } |
| """ |
| database_name, table_name, rollup_table_name = util.gen_name_list() |
| client = common.create_workspace(database_name) |
| ret = client.create_table(table_name, DATA.boolean_column_list, distribution_info=DATA.hash_distribution_info, |
| keys_desc=DATA.boolean_aggregate_key, set_null=True) |
| assert ret |
| bool_hdfs = palo_config.gen_remote_file_path('sys/load/test_bool.data') |
| column_name_list = ['k1', 'k2', 'v1', 'v2'] |
| load_data_info = palo_client.LoadDataInfo(bool_hdfs, table_name, column_name_list=column_name_list) |
| ret = client.batch_load(util.get_label(), load_data_info, max_filter_ratio=0.01, broker=broker_info, is_wait=True) |
| assert ret |
| assert client.verify('%s/data/LOAD/expe_agg_bool_null_ns.data' % file_dir, table_name) |
| client.clean(database_name) |
| |
| |
| def test_bool_broker_load(): |
| """ |
| { |
| "title": "test_bool_broker_load", |
| "describe": "验证broker导入bool类型，结果正确", |
| "tag": "system,p1" |
| } |
| """ |
| database_name, table_name, rollup_table_name = util.gen_name_list() |
| client = common.create_workspace(database_name) |
| # 建表 |
| agg_tb = table_name + '_agg' |
| duplicate_tb = table_name + "_dup" |
| unique_tb = table_name + "_uniq" |
| ret = client.create_table(agg_tb, DATA.boolean_column_list, distribution_info=DATA.boolean_distribution_info, |
| keys_desc=DATA.boolean_aggregate_key, set_null=True) |
| assert ret |
| ret = client.create_table(duplicate_tb, DATA.boolean_column_no_agg_list, |
| distribution_info=DATA.boolean_distribution_info, keys_desc=DATA.boolean_duplicate_key, |
| set_null=True) |
| assert ret |
| ret = client.create_table(unique_tb, DATA.boolean_column_no_agg_list, |
| distribution_info=DATA.boolean_distribution_info, keys_desc=DATA.boolean_unique_key, |
| set_null=True) |
| assert ret |
| # 导入 |
| bool_hdfs = palo_config.gen_remote_file_path('sys/load/test_bool.data') |
| column_name_list = ['k1', 'k2', 'v1', 'v2'] |
| load_data_info = palo_client.LoadDataInfo(bool_hdfs, agg_tb, column_name_list=column_name_list) |
| ret = client.batch_load(util.get_label(), load_data_info, max_filter_ratio=0.01, broker=broker_info, is_wait=True) |
| assert ret |
| load_data_info = palo_client.LoadDataInfo(bool_hdfs, duplicate_tb, column_name_list=column_name_list) |
| ret = client.batch_load(util.get_label(), load_data_info, max_filter_ratio=0.01, broker=broker_info, is_wait=True) |
| assert ret |
| load_data_info = palo_client.LoadDataInfo(bool_hdfs, unique_tb, column_name_list=column_name_list) |
| ret = client.batch_load(util.get_label(), load_data_info, max_filter_ratio=0.01, broker=broker_info, is_wait=True) |
| assert ret |
| # 查询&验证结果 |
| assert client.verify('%s/data/LOAD/expe_agg_bool_null_ns.data' % file_dir, agg_tb) |
| assert client.verify('%s/data/LOAD/expe_dup_bool_null_ns.data' % file_dir, duplicate_tb) |
| assert client.verify('%s/data/LOAD/expe_uniq_bool_null_ns.data' % file_dir, unique_tb) |
| client.clean(database_name) |
| |
| |
| def test_bool_stream_load(): |
| """ |
| { |
| "title": "test_bool_stream_load", |
| "describe": "验证stream导入bool类型，结果正确", |
| "tag": "system,p1" |
| } |
| """ |
| database_name, table_name, rollup_table_name = util.gen_name_list() |
| client = common.create_workspace(database_name) |
| # 建表 |
| agg_tb = table_name + '_agg' |
| duplicate_tb = table_name + "_dup" |
| unique_tb = table_name + "_uniq" |
| ret = client.create_table(agg_tb, DATA.boolean_column_list, distribution_info=DATA.boolean_distribution_info, |
| keys_desc=DATA.boolean_aggregate_key, set_null=True) |
| assert ret |
| ret = client.create_table(duplicate_tb, DATA.boolean_column_no_agg_list, |
| distribution_info=DATA.boolean_distribution_info, keys_desc=DATA.boolean_duplicate_key, |
| set_null=True) |
| assert ret |
| ret = client.create_table(unique_tb, DATA.boolean_column_no_agg_list, |
| distribution_info=DATA.boolean_distribution_info, keys_desc=DATA.boolean_unique_key, |
| set_null=True) |
| assert ret |
| # 导入 |
| local_file = '%s/data/LOAD/test_bool.data' % file_dir |
| print(file_dir) |
| ret = client.stream_load(agg_tb, local_file, max_filter_ratio=0.1) |
| assert ret |
| column_name_list = ['k1', 'k2', 'v1', 'v2'] |
| ret = client.stream_load(duplicate_tb, local_file, max_filter_ratio=0.1, column_name_list=column_name_list) |
| assert ret |
| ret = client.stream_load(unique_tb, local_file, max_filter_ratio=0.1, column_name_list=column_name_list) |
| assert ret |
| # 查询 & 验证 |
| assert client.verify('%s/data/LOAD/expe_agg_bool_null_ns.data' % file_dir, agg_tb) |
| assert client.verify('%s/data/LOAD/expe_dup_bool_null_ns.data' % file_dir, duplicate_tb) |
| assert client.verify('%s/data/LOAD/expe_uniq_bool_null_ns.data' % file_dir, unique_tb) |
| client.clean(database_name) |
| |
| |
| def test_bool_insert(): |
| """ |
| { |
| "title": "test_bool_insert", |
| "describe": "验证insert导入bool类型，结果正确", |
| "tag": "system,p1" |
| } |
| """ |
| database_name, table_name, rollup_table_name = util.gen_name_list() |
| client = common.create_workspace(database_name) |
| # 建表 |
| agg_tb = table_name + '_agg' |
| duplicate_tb = table_name + "_dup" |
| unique_tb = table_name + "_uniq" |
| sql = "SET enable_insert_strict = false;" |
| client.execute(sql) |
| ret = client.create_table(agg_tb, DATA.boolean_column_list, distribution_info=DATA.boolean_distribution_info, |
| keys_desc=DATA.boolean_aggregate_key, set_null=True) |
| assert ret |
| ret = client.create_table(duplicate_tb, DATA.boolean_column_no_agg_list, |
| distribution_info=DATA.boolean_distribution_info, keys_desc=DATA.boolean_duplicate_key, |
| set_null=True) |
| assert ret |
| ret = client.create_table(unique_tb, DATA.boolean_column_no_agg_list, |
| distribution_info=DATA.boolean_distribution_info, keys_desc=DATA.boolean_unique_key, |
| set_null=True) |
| assert ret |
| # 导入 |
| sql_list = list() |
| sql_list.append("insert into %s(k1, k2, v1, v2) values (1, 1, 1, 1), (0, 0, 0, 0)") |
| sql_list.append("insert into %s(k1, k2, v1, v2) values ('true', 2, 'true', 'true'), ('false', 3, 'false', 'false')") |
| sql_list.append("insert into %s(k1, k2, v1, v2) values (true, 4, true, true), (false, 5, false, false)") |
| sql_list.append("insert into %s(k1, k2, v1, v2) values ('0', 6, '0', '0'), ('1', 7, '1', '8')") |
| sql_list.append("insert into %s(k1, k2, v1, v2) values ('hello', 8, 'a', 'b'), (null, 9, null, null)") |
| sql_list.append("insert into %s(k1, k2, v1, v2) values ('TRue', 2, 'TRUe', 'FALSE'), ('False', 3, 'TRUE', 'FALSe')") |
| for insert_sql in sql_list: |
| sql = insert_sql % agg_tb |
| ret = client.execute(sql) |
| assert ret == (), 'expect insert ok' |
| sql_list = list() |
| sql_list.append("insert into %s(k1, k2, v1) values (1, 1, 1), (0, 0, 0)") |
| sql_list.append("insert into %s(k1, k2, v1) values ('true', 2, 'true'), ('false', 3, 'false')") |
| sql_list.append("insert into %s(k1, k2, v1) values (true, 4, true), (false, 5, false)") |
| sql_list.append("insert into %s(k1, k2, v1) values ('0', 6, '0'), ('1', 7, '1')") |
| sql_list.append("insert into %s(k1, k2, v1) values ('hello', 8, 'a'), (null, 9, null)") |
| sql_list.append("insert into %s(k1, k2, v1) values ('TRue', 2, 'TRUe'), ('False', 3, 'TRUE')") |
| for insert_sql in sql_list: |
| for tb in [duplicate_tb, unique_tb]: |
| sql = insert_sql % tb |
| ret = client.execute(sql) |
| assert ret == (), 'expect insert ok' |
| # 验证 |
| assert client.verify('%s/data/LOAD/expe_bool_agg_insert_null_ns.data' % file_dir, agg_tb) |
| assert client.verify('%s/data/LOAD/expe_bool_dup_insert_null_ns.data' % file_dir, duplicate_tb) |
| assert client.verify('%s/data/LOAD/expe_bool_agg_insert_null_ns.data' % file_dir, unique_tb) |
| client.clean(database_name) |
| |
| |
| def test_bool_load_strict_null(): |
| """ |
| { |
| "title": "test_bool_load_strict_null", |
| "describe": "验证broker导入bool类型，设置strict为true，列为Null，验证导入结果正确", |
| "tag": "fuzz,p1" |
| } |
| """ |
| database_name, table_name, rollup_table_name = util.gen_name_list() |
| client = common.create_workspace(database_name) |
| # 建表 |
| agg_tb = table_name + '_agg' |
| duplicate_tb = table_name + "_dup" |
| unique_tb = table_name + "_uniq" |
| ret = client.create_table(agg_tb, DATA.boolean_column_list, distribution_info=DATA.boolean_distribution_info, |
| keys_desc=DATA.boolean_aggregate_key, set_null=True) |
| assert ret |
| ret = client.create_table(duplicate_tb, DATA.boolean_column_no_agg_list, |
| distribution_info=DATA.boolean_distribution_info, keys_desc=DATA.boolean_duplicate_key, |
| set_null=True) |
| assert ret |
| ret = client.create_table(unique_tb, DATA.boolean_column_no_agg_list, |
| distribution_info=DATA.boolean_distribution_info, keys_desc=DATA.boolean_unique_key, |
| set_null=True) |
| assert ret |
| # 导入 |
| bool_hdfs = palo_config.gen_remote_file_path('sys/load/test_bool.data') |
| column_name_list = ['k1', 'k2', 'v1', 'v2'] |
| load_data_info = palo_client.LoadDataInfo(bool_hdfs, agg_tb, column_name_list=column_name_list) |
| ret = client.batch_load(util.get_label(), load_data_info, max_filter_ratio=0.01, |
| broker=broker_info, is_wait=True, strict_mode=True) |
| assert ret |
| load_data_info = palo_client.LoadDataInfo(bool_hdfs, duplicate_tb, column_name_list=column_name_list) |
| ret = client.batch_load(util.get_label(), load_data_info, max_filter_ratio=0.01, |
| broker=broker_info, is_wait=True, strict_mode=True) |
| assert ret |
| load_data_info = palo_client.LoadDataInfo(bool_hdfs, unique_tb, column_name_list=column_name_list) |
| ret = client.batch_load(util.get_label(), load_data_info, max_filter_ratio=0.01, |
| broker=broker_info, is_wait=True, strict_mode=True) |
| assert ret |
| # 查询&验证结果 |
| assert client.verify('%s/data/LOAD/expe_agg_bool_null_s.data' % file_dir, agg_tb) |
| assert client.verify('%s/data/LOAD/expe_dup_bool_null_s.data' % file_dir, duplicate_tb) |
| assert client.verify('%s/data/LOAD/expe_uniq_bool_null_s.data' % file_dir, unique_tb) |
| client.clean(database_name) |
| |
| |
| def test_bool_load_strict_not_null(): |
| """ |
| { |
| "title": "test_bool_load_strict_not_null", |
| "describe": "验证broker导入bool类型，设置strict为true，列为Null，验证导入结果正确", |
| "tag": "fuzz,p1" |
| } |
| """ |
| database_name, table_name, rollup_table_name = util.gen_name_list() |
| client = common.create_workspace(database_name) |
| # 建表 |
| agg_tb = table_name + '_agg' |
| duplicate_tb = table_name + "_dup" |
| unique_tb = table_name + "_uniq" |
| ret = client.create_table(agg_tb, DATA.boolean_column_list, distribution_info=DATA.boolean_distribution_info, |
| keys_desc=DATA.boolean_aggregate_key, set_null=False) |
| assert ret |
| ret = client.create_table(duplicate_tb, DATA.boolean_column_no_agg_list, |
| distribution_info=DATA.boolean_distribution_info, keys_desc=DATA.boolean_duplicate_key, |
| set_null=False) |
| assert ret |
| ret = client.create_table(unique_tb, DATA.boolean_column_no_agg_list, |
| distribution_info=DATA.boolean_distribution_info, keys_desc=DATA.boolean_unique_key, |
| set_null=False) |
| assert ret |
| # 导入 |
| bool_hdfs = palo_config.gen_remote_file_path('sys/load/test_bool.data') |
| column_name_list = ['k1', 'k2', 'v1', 'v2'] |
| load_data_info = palo_client.LoadDataInfo(bool_hdfs, agg_tb, column_name_list=column_name_list) |
| ret = client.batch_load(util.get_label(), load_data_info, max_filter_ratio=0.5, |
| broker=broker_info, is_wait=True, strict_mode=True) |
| assert ret |
| load_data_info = palo_client.LoadDataInfo(bool_hdfs, duplicate_tb, column_name_list=column_name_list) |
| ret = client.batch_load(util.get_label(), load_data_info, max_filter_ratio=0.5, |
| broker=broker_info, is_wait=True, strict_mode=True) |
| assert ret |
| load_data_info = palo_client.LoadDataInfo(bool_hdfs, unique_tb, column_name_list=column_name_list) |
| ret = client.batch_load(util.get_label(), load_data_info, max_filter_ratio=0.5, |
| broker=broker_info, is_wait=True, strict_mode=True) |
| assert ret |
| # 查询&验证结果 |
| assert client.verify('%s/data/LOAD/expe_agg_bool_not_null_s.data' % file_dir, agg_tb) |
| assert client.verify('%s/data/LOAD/expe_dup_bool_not_null_s.data' % file_dir, duplicate_tb) |
| assert client.verify('%s/data/LOAD/expe_uniq_bool_not_null_s.data' % file_dir, unique_tb) |
| client.clean(database_name) |
| |
| |
| def test_add_bool_key_column(): |
| """ |
| { |
| "title": "test_add_bool_key_column", |
| "describe": "验证增加boolean类型的key列成功", |
| "tag": "system,p1" |
| } |
| """ |
| """bug: 增加bool类型的key列""" |
| database_name, table_name, rollup_table_name = util.gen_name_list() |
| client = common.create_workspace(database_name) |
| ret = client.create_table(table_name, DATA.boolean_column_list, distribution_info=DATA.hash_distribution_info, |
| keys_desc=DATA.boolean_aggregate_key, set_null=True) |
| assert ret |
| bool_hdfs = palo_config.gen_remote_file_path('sys/load/test_bool.data') |
| column_name_list = ['k1', 'k2', 'v1', 'v2'] |
| load_data_info = palo_client.LoadDataInfo(bool_hdfs, table_name, column_name_list=column_name_list) |
| ret = client.batch_load(util.get_label(), load_data_info, max_filter_ratio=0.01, broker=broker_info, is_wait=True) |
| assert ret |
| assert client.verify('%s/data/LOAD/expe_agg_bool_null_ns.data' % file_dir, table_name) |
| sql = 'select k1, k2, 1, v1, v2 from %s order by 1, 2' % table_name |
| ret1 = client.execute(sql) |
| add_column = ['k3 boolean default "1"'] |
| ret = client.schema_change(table_name, add_column_list=add_column, is_wait=True) |
| assert ret |
| sql = "select * from %s order by k1, k2" % table_name |
| ret2 = client.execute(sql) |
| util.check(ret1, ret2) |
| client.clean(database_name) |
| |
| |
| def test_add_bool_value_column(): |
| """ |
| { |
| "title": "test_add_bool_value_column", |
| "describe": "验证增加boolean类型的value列成功", |
| "tag": "system,p1" |
| } |
| """ |
| """增加bool类型的value列""" |
| database_name, table_name, rollup_table_name = util.gen_name_list() |
| client = common.create_workspace(database_name) |
| ret = client.create_table(table_name, DATA.boolean_column_list, distribution_info=DATA.hash_distribution_info, |
| keys_desc=DATA.boolean_aggregate_key, set_null=True) |
| assert ret |
| bool_hdfs = palo_config.gen_remote_file_path('sys/load/test_bool.data') |
| column_name_list = ['k1', 'k2', 'v1', 'v2'] |
| load_data_info = palo_client.LoadDataInfo(bool_hdfs, table_name, column_name_list=column_name_list) |
| ret = client.batch_load(util.get_label(), load_data_info, max_filter_ratio=0.01, broker=broker_info, is_wait=True) |
| assert ret |
| assert client.verify('%s/data/LOAD/expe_agg_bool_null_ns.data' % file_dir, table_name) |
| sql = 'select k1, k2, v1, v2, null from %s order by 1, 2' % table_name |
| ret1 = client.execute(sql) |
| add_column = ['v3 boolean replace_if_not_null'] |
| ret = client.schema_change(table_name, add_column_list=add_column, is_wait=True) |
| assert ret |
| sql = "select * from %s order by k1, k2" % table_name |
| ret2 = client.execute(sql) |
| util.check(ret1, ret2) |
| client.clean(database_name) |
| |
| |
| def test_drop_bool_column(): |
| """ |
| { |
| "title": "test_drop_bool_column", |
| "describe": "验证删除boolean类型的value列成功，key列失败因为有replace列", |
| "tag": "system,p1" |
| } |
| """ |
| database_name, table_name, rollup_table_name = util.gen_name_list() |
| client = common.create_workspace(database_name) |
| ret = client.create_table(table_name, DATA.boolean_column_list, distribution_info=DATA.hash_distribution_info, |
| keys_desc=DATA.boolean_aggregate_key, set_null=True) |
| assert ret |
| bool_hdfs = palo_config.gen_remote_file_path('sys/load/test_bool.data') |
| column_name_list = ['k1', 'k2', 'v1', 'v2'] |
| load_data_info = palo_client.LoadDataInfo(bool_hdfs, table_name, column_name_list=column_name_list) |
| ret = client.batch_load(util.get_label(), load_data_info, max_filter_ratio=0.01, broker=broker_info, is_wait=True) |
| assert ret |
| assert client.verify('%s/data/LOAD/expe_agg_bool_null_ns.data' % file_dir, table_name) |
| sql = 'select k1, k2, v1 from %s order by 1, 2' % table_name |
| ret1 = client.execute(sql) |
| # 删除bool key列失败，因为有replace聚合 |
| flag = True |
| try: |
| drop_column = ['k1'] |
| client.schema_change(table_name, drop_column_list=drop_column, is_wait=False) |
| flag = False |
| except Exception as e: |
| print(str(e)) |
| assert flag |
| |
| drop_column = ['v2'] |
| ret = client.schema_change(table_name, drop_column_list=drop_column, is_wait=True) |
| assert ret |
| sql = "select * from %s order by k1, k2" % table_name |
| ret2 = client.execute(sql) |
| util.check(ret1, ret2) |
| client.clean(database_name) |
| |
| |
| def test_alter_to_bool(): |
| """ |
| { |
| "title": "test_alter_to_bool", |
| "describe": "验证不支持其他列（tinyint/int/char/varchar/date/float）转为boolean类型列", |
| "tag": "fuzz,p1" |
| } |
| """ |
| database_name, table_name, rollup_table_name = util.gen_name_list() |
| client = common.create_workspace(database_name) |
| ret = client.create_table(table_name, DATA.baseall_column_list, distribution_info=DATA.hash_distribution_info, |
| set_null=True) |
| assert ret |
| flag = True |
| try: |
| modify_column = ['k1 boolean' ] |
| ret = client.schema_change(table_name, modify_column_list=modify_column, is_wait=True) |
| flag = False |
| except Exception as e: |
| print(str(e)) |
| assert flag, 'expcet alter modify failed, can not convert tinyint to boolean' |
| flag = True |
| try: |
| modify_column = ['k4 boolean' ] |
| ret = client.schema_change(table_name, modify_column_list=modify_column, is_wait=True) |
| flag = False |
| except Exception as e: |
| print(str(e)) |
| assert flag, 'expcet alter modify failed, can not convert bigint to boolean' |
| flag = True |
| try: |
| modify_column = ['k6 boolean' ] |
| ret = client.schema_change(table_name, modify_column_list=modify_column, is_wait=True) |
| flag = False |
| except Exception as e: |
| print(str(e)) |
| assert flag, 'expcet alter modify failed, can not convert char to boolean' |
| flag = True |
| try: |
| modify_column = ['k7 boolean' ] |
| ret = client.schema_change(table_name, modify_column_list=modify_column, is_wait=True) |
| flag = False |
| except Exception as e: |
| print(str(e)) |
| assert flag, 'expcet alter modify failed, can not convert varchar to boolean' |
| flag = True |
| try: |
| modify_column = ['k10 boolean' ] |
| ret = client.schema_change(table_name, modify_column_list=modify_column, is_wait=True) |
| flag = False |
| except Exception as e: |
| print(str(e)) |
| assert flag, 'expcet alter modify failed, can not convert date to boolean' |
| flag = True |
| try: |
| modify_column = ['k9 boolean' ] |
| ret = client.schema_change(table_name, modify_column_list=modify_column, is_wait=True) |
| flag = False |
| except Exception as e: |
| print(str(e)) |
| assert flag, 'expcet alter modify failed, can not convert float to boolean' |
| client.clean(database_name) |
| |
| |
| def test_alter_bool_to_other_type(): |
| """ |
| { |
| "title": "test_alter_bool_to_other_type", |
| "describe": "验证不支持boolean类型列转为其他列（tinyint/int/char/varchar/date/float）", |
| "tag": "fuzz,p1" |
| } |
| """ |
| database_name, table_name, rollup_table_name = util.gen_name_list() |
| client = common.create_workspace(database_name) |
| ret = client.create_table(table_name, DATA.boolean_column_list, distribution_info=DATA.hash_distribution_info, |
| keys_desc=DATA.boolean_aggregate_key, set_null=True) |
| assert ret |
| bool_hdfs = palo_config.gen_remote_file_path('sys/load/test_bool.data') |
| column_name_list = ['k1', 'k2', 'v1', 'v2'] |
| load_data_info = palo_client.LoadDataInfo(bool_hdfs, table_name, column_name_list=column_name_list) |
| ret = client.batch_load(util.get_label(), load_data_info, max_filter_ratio=0.01, broker=broker_info, is_wait=True) |
| assert ret |
| assert client.verify('%s/data/LOAD/expe_agg_bool_null_ns.data' % file_dir, table_name) |
| flag = True |
| try: |
| modify_column = ['v1 varchar(2) replace', 'v2 varchar(1) replace_if_not_null'] |
| ret = client.schema_change(table_name, modify_column_list=modify_column, is_wait=True) |
| flag = False |
| except Exception as e: |
| print(str(e)) |
| assert flag, 'expcet alter modify failed, can not convert boolean to varchar' |
| try: |
| modify_column = ['v1 char(2) replace', 'v2 char(1) replace_if_not_null'] |
| ret = client.schema_change(table_name, modify_column_list=modify_column, is_wait=True) |
| flag = False |
| except Exception as e: |
| print(str(e)) |
| assert flag, 'expcet alter modify failed, can not convert boolean to char' |
| try: |
| modify_column = ['v1 tinyint replace', 'v2 tinyint replace_if_not_null'] |
| ret = client.schema_change(table_name, modify_column_list=modify_column, is_wait=True) |
| flag = False |
| except Exception as e: |
| print(str(e)) |
| assert flag, 'expcet alter modify failed, can not convert boolean to tinyint' |
| try: |
| modify_column = ['v1 float replace', 'v2 float replace_if_not_null'] |
| ret = client.schema_change(table_name, modify_column_list=modify_column, is_wait=True) |
| flag = False |
| except Exception as e: |
| print(str(e)) |
| assert flag, 'expcet alter modify failed, can not convert boolean to float' |
| try: |
| modify_column = ['v1 date replace', 'v2 date replace_if_not_null'] |
| ret = client.schema_change(table_name, modify_column_list=modify_column, is_wait=True) |
| flag = False |
| except Exception as e: |
| print(str(e)) |
| assert flag, 'expcet alter modify failed, can not convert boolean to date' |
| client.clean(database_name) |
| |
| |
| def test_rollup_bool(): |
| """ |
| { |
| "title": "test_rollup_bool", |
| "describe": "验证试用boolean类型创建rollup", |
| "tag": "system,p1" |
| } |
| """ |
| database_name, table_name, rollup_table_name = util.gen_name_list() |
| client = common.create_workspace(database_name) |
| ret = client.create_table(table_name, DATA.boolean_column_list, distribution_info=DATA.hash_distribution_info, |
| keys_desc=DATA.boolean_aggregate_key, set_null=True) |
| assert ret |
| bool_hdfs = palo_config.gen_remote_file_path('sys/load/test_bool.data') |
| column_name_list = ['k1', 'k2', 'v1', 'v2'] |
| load_data_info = palo_client.LoadDataInfo(bool_hdfs, table_name, column_name_list=column_name_list) |
| ret = client.batch_load(util.get_label(), load_data_info, max_filter_ratio=0.01, broker=broker_info, is_wait=True) |
| assert ret |
| assert client.verify('%s/data/LOAD/expe_agg_bool_null_ns.data' % file_dir, table_name) |
| int_tb_name = 'int_' + table_name |
| int_4_column_list = [('k1', 'BOOLEAN'), |
| ('k2', 'INT'), |
| ('k3', 'BOOLEAN', 'REPLACE'), |
| ('k4', 'INT', 'SUM')] |
| ret = client.create_table(int_tb_name, int_4_column_list, distribution_info=DATA.hash_distribution_info, |
| keys_desc=DATA.boolean_aggregate_key, set_null=True) |
| assert ret |
| insert_sql = 'insert into %s select * from %s' % (int_tb_name, table_name) |
| ret = client.execute(insert_sql) |
| assert ret == () |
| assert client.verify('%s/data/LOAD/expe_agg_bool_null_ns.data' % file_dir, int_tb_name) |
| sql = 'select k1, sum(k4) from %s group by k1 order by k1' % int_tb_name |
| ret1 = client.execute(sql) |
| rollup_column = ['k1', 'k4'] |
| ret = client.create_rollup_table(int_tb_name, rollup_table_name, rollup_column, is_wait=True) |
| assert ret |
| assert client.get_index(int_tb_name, rollup_table_name) |
| ret2 = client.execute(sql) |
| util.check(ret1, ret2) |
| client.clean(database_name) |
| |
| |
| def test_material_view_bool(): |
| """ |
| { |
| "title": "test_material_view_bool", |
| "describe": "验证支持试用boolean类型创建物化视图", |
| "tag": "system,p1" |
| } |
| """ |
| database_name, table_name, rollup_table_name = util.gen_name_list() |
| client = common.create_workspace(database_name) |
| ret = client.create_table(table_name, DATA.boolean_column_no_agg_list, |
| distribution_info=DATA.hash_distribution_info, |
| keys_desc=DATA.boolean_duplicate_key, set_null=True) |
| assert ret |
| bool_hdfs = palo_config.gen_remote_file_path('sys/load/test_bool.data') |
| column_name_list = ['k1', 'k2', 'v1', 'v2'] |
| load_data_info = palo_client.LoadDataInfo(bool_hdfs, table_name, column_name_list=column_name_list) |
| ret = client.batch_load(util.get_label(), load_data_info, max_filter_ratio=0.01, broker=broker_info, is_wait=True) |
| assert ret |
| assert client.verify('%s/data/LOAD/expe_dup_bool_null_ns.data' % file_dir, table_name) |
| int_tb_name = 'int_' + table_name |
| int_4_column_list = [('k1', 'BOOLEAN'), |
| ('k2', 'INT'), |
| ('k3', 'INT')] |
| ret = client.create_table(int_tb_name, int_4_column_list, distribution_info=DATA.hash_distribution_info, |
| keys_desc=DATA.boolean_duplicate_key, set_null=True) |
| assert ret |
| insert_sql = 'insert into %s select * from %s' % (int_tb_name, table_name) |
| ret = client.execute(insert_sql) |
| assert ret == () |
| assert client.verify('%s/data/LOAD/expe_dup_bool_null_ns.data' % file_dir, int_tb_name) |
| sql = 'select k1, sum(k3) from %s group by k1 order by k1' % int_tb_name |
| ret1 = client.execute(sql) |
| ret = client.create_materialized_view(int_tb_name, rollup_table_name, sql, is_wait=True) |
| assert ret |
| assert client.get_index(int_tb_name, rollup_table_name) |
| ret2 = client.execute(sql) |
| util.check(ret1, ret2) |
| client.clean(database_name) |
| |
| |
| if __name__ == '__main__': |
| setup_module() |
| test_bool_create_table_wrong_3() |
| test_add_bool_key_column() |
| test_add_bool_value_column() |
| |
| |
| |
