1015 lines
46 KiB
Python
1015 lines
46 KiB
Python
#!/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_create_dynamic_partition_parameter.py
|
|
# @date 2021/06/02 10:28:20
|
|
# @brief This file is a test file for doris dynamic partition parameters.
|
|
#
|
|
#############################################################################
|
|
|
|
"""
|
|
测试动态分区功能参数
|
|
"""
|
|
|
|
import time
|
|
import datetime
|
|
import sys
|
|
from dateutil.relativedelta import relativedelta
|
|
sys.path.append("../")
|
|
from lib import palo_config
|
|
from lib import palo_client
|
|
from lib import palo_job
|
|
from lib import util
|
|
|
|
client = None
|
|
config = palo_config.config
|
|
LOG = palo_client.LOG
|
|
L = palo_client.L
|
|
|
|
|
|
def setup_module():
|
|
"""
|
|
setUp
|
|
"""
|
|
global client
|
|
client = palo_client.get_client(config.fe_host, config.fe_query_port, user=config.fe_user,
|
|
password=config.fe_password, http_port=config.fe_http_port)
|
|
|
|
|
|
def create(table_name, datetype, info, column=None, keys_desc=None, partition_info=None):
|
|
"""
|
|
建表
|
|
info:动态分区建表参数
|
|
"""
|
|
if partition_info is None:
|
|
partition_info = palo_client.PartitionInfo('k1', [], [])
|
|
distribution_info = palo_client.DistributionInfo('HASH(k1)', 3)
|
|
dynamic_info = palo_client.DynamicPartitionInfo(info)
|
|
dynamic = dynamic_info.to_string()
|
|
if column is None:
|
|
column = [('k1', datetype), ('k2', 'varchar(20)'), ('k3', 'int', 'sum')]
|
|
client.create_table(table_name, column, partition_info, distribution_info, keys_desc=keys_desc,
|
|
dynamic_partition_info=dynamic)
|
|
assert client.show_tables(table_name), 'fail to create table'
|
|
|
|
|
|
def get_partition_name_list(start, end, prefix):
|
|
"""
|
|
分区名
|
|
"""
|
|
partition_name_list = []
|
|
for i in range(-start, -end - 1, -1):
|
|
p_name = (datetime.datetime.now() - datetime.timedelta(days=i))
|
|
partition_name_list.append(str(prefix + p_name.strftime("%Y%m%d")))
|
|
return partition_name_list
|
|
|
|
|
|
def get_partition_value_list(start, end):
|
|
"""
|
|
分区范围
|
|
"""
|
|
partition_value_list = []
|
|
for i in range(-start, -end - 1, -1):
|
|
p_value = (datetime.datetime.now() - datetime.timedelta(days=i))
|
|
p_value2 = (datetime.datetime.now() - datetime.timedelta(days=(i - 1)))
|
|
p_value = p_value.strftime("%Y-%m-%d")
|
|
p_value2 = p_value2.strftime("%Y-%m-%d")
|
|
tmp = '[types: [DATEV2]; keys: [%s]; ..types: [DATEV2]; keys: [%s]; )' % (p_value, p_value2)
|
|
partition_value_list.append(tmp)
|
|
return partition_value_list
|
|
|
|
|
|
def check_partition_list(table_name, partition_name_list):
|
|
"""
|
|
验证分区是否创建成功
|
|
"""
|
|
ret = client.get_partition_list(table_name)
|
|
partitions_list = util.get_attr(ret, palo_job.PartitionInfo.PartitionName)
|
|
expect_plist_sorted = sorted(partition_name_list)
|
|
|
|
actural_plist_sorted = sorted(partitions_list)
|
|
assert expect_plist_sorted == actural_plist_sorted, \
|
|
'expect: %s, actural: %s' % (expect_plist_sorted, actural_plist_sorted)
|
|
|
|
|
|
def check_partition_range(table_name, partition_value_list):
|
|
"""
|
|
验证分区范围是否正确
|
|
"""
|
|
ret = client.get_partition_list(table_name)
|
|
LOG.info(L('', PARTITION_RANGE=util.get_attr(ret, palo_job.PartitionInfo.Range), EXPECT=partition_value_list))
|
|
assert util.get_attr(ret, palo_job.PartitionInfo.Range) == partition_value_list
|
|
|
|
|
|
def test_dynamic_partition_enable():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_enable",
|
|
"describe": "验证dynamic_partition.enable参数功能enable=true开启动态分区功能",
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
create(table_name, 'date', dynamic_partition_info)
|
|
partition_name_list = get_partition_name_list(-3, 3, 'p')
|
|
partition_value_list = get_partition_value_list(-3, 3)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.drop_table(table_name, database_name)
|
|
dynamic_partition_info = {'enable': 'false', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
create(table_name, 'date', dynamic_partition_info)
|
|
check_partition_list(table_name, [])
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_hour():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_hour",
|
|
"describe": "time_unit=HOUR建表，仅支持datetime格式",
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
now_time = datetime.datetime.now()
|
|
partition_name_list = []
|
|
for i in range(30, -31, -1):
|
|
p_name = (now_time - datetime.timedelta(hours=i))
|
|
partition_name_list.append(str("p" + p_name.strftime("%Y%m%d%H")))
|
|
partition_value_list = []
|
|
for i in range(30, -31, -1):
|
|
p_value = (now_time - datetime.timedelta(hours=i))
|
|
p_value2 = (now_time - datetime.timedelta(hours=(i - 1)))
|
|
p_value = p_value.strftime("%Y-%m-%d %H:00:00")
|
|
p_value2 = p_value2.strftime("%Y-%m-%d %H:00:00")
|
|
partition = '[types: [DATETIMEV2]; keys: [%s]; ..types: [DATETIMEV2]; keys: [%s]; )' % (p_value, p_value2)
|
|
partition_value_list.append(partition)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'HOUR', 'start': -30, 'end': 30, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
create(table_name, 'datetime', dynamic_partition_info)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_day_date():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_day_date",
|
|
"describe": "time_unit=DAY建表，datetype=date",
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
partition_name_list = get_partition_name_list(-3, 3, 'p')
|
|
partition_value_list = get_partition_value_list(-3, 3)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
create(table_name, 'date', dynamic_partition_info)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_day_int():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_day_int",
|
|
"describe": "time_unit=DAY建表，datetype=int",
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
partition_name_list = get_partition_name_list(-3, 3, 'p')
|
|
partition_value_list = []
|
|
for i in range(3, -4, -1):
|
|
p_value = (datetime.datetime.now() - datetime.timedelta(days=i))
|
|
p_value2 = (datetime.datetime.now() - datetime.timedelta(days=(i - 1)))
|
|
p_value = p_value.strftime("%Y%m%d")
|
|
p_value2 = p_value2.strftime("%Y%m%d")
|
|
partition = '[types: [INT]; keys: [%s]; ..types: [INT]; keys: [%s]; )' % (p_value, p_value2)
|
|
partition_value_list.append(partition)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
create(table_name, 'int', dynamic_partition_info)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_day_datetime():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_day_datetime",
|
|
"describe": "time_unit=DAY建表,datetype=datetime",
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
partition_name_list = get_partition_name_list(-3, 3, 'p')
|
|
partition_value_list = []
|
|
for i in range(3, -4, -1):
|
|
p_value = (datetime.datetime.now() - datetime.timedelta(days=i))
|
|
p_value2 = (datetime.datetime.now() - datetime.timedelta(days=(i - 1)))
|
|
p_value = p_value.strftime("%Y-%m-%d 00:00:00")
|
|
p_value2 = p_value2.strftime("%Y-%m-%d 00:00:00")
|
|
partition = '[types: [DATETIMEV2]; keys: [%s]; ..types: [DATETIMEV2]; keys: [%s]; )' % (p_value, p_value2)
|
|
partition_value_list.append(partition)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
create(table_name, 'datetime', dynamic_partition_info)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_week_date():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_week_date",
|
|
"describe": "time_unit=WEEK建表，datetype=date"
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
partition_name_list = []
|
|
today = datetime.datetime.now().weekday()
|
|
start_day = datetime.datetime.now() - datetime.timedelta(days=today)
|
|
# todo: 2022-2023 week name not same
|
|
for i in range(30, -31, -1):
|
|
p_name = start_day - datetime.timedelta(days=7 * i)
|
|
week = str("0" + str(int(p_name.strftime("%U")) + 1))
|
|
partition_name_list.append(str("p" + p_name.strftime("%Y_") + week[-2:]))
|
|
partition_value_list = []
|
|
for i in range(30, -31, -1):
|
|
p_value = start_day - datetime.timedelta(days=7 * i)
|
|
p_value2 = start_day - datetime.timedelta(days=(7 * (i - 1)))
|
|
p_value = p_value.strftime("%Y-%m-%d")
|
|
p_value2 = p_value2.strftime("%Y-%m-%d")
|
|
partition = '[types: [DATEV2]; keys: [%s]; ..types: [DATEV2]; keys: [%s]; )' % (p_value, p_value2)
|
|
partition_value_list.append(partition)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'WEEK', 'start': -30, 'end': 30, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
create(table_name, 'date', dynamic_partition_info)
|
|
# check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_week_datetime():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_week_datetime",
|
|
"describe": "time_unit=WEEK建表, datetype=datetime"
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
partition_name_list = []
|
|
today = datetime.datetime.now().weekday()
|
|
start_day = datetime.datetime.now() - datetime.timedelta(days=today)
|
|
for i in range(30, -31, -1):
|
|
p_name = start_day - datetime.timedelta(days=7 * i)
|
|
week = str("0" + str(int(p_name.strftime("%U")) + 1))
|
|
partition_name_list.append(str("p" + p_name.strftime("%Y_") + week[-2:]))
|
|
partition_value_list = []
|
|
for i in range(30, -31, -1):
|
|
p_value = start_day - datetime.timedelta(days=7 * i)
|
|
p_value2 = start_day - datetime.timedelta(days=(7 * (i - 1)))
|
|
p_value = p_value.strftime("%Y-%m-%d 00:00:00")
|
|
p_value2 = p_value2.strftime("%Y-%m-%d 00:00:00")
|
|
partition = '[types: [DATETIMEV2]; keys: [%s]; ..types: [DATETIMEV2]; keys: [%s]; )' % (p_value, p_value2)
|
|
partition_value_list.append(partition)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'WEEK', 'start': -30, 'end': 30, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
create(table_name, 'datetime', dynamic_partition_info)
|
|
# check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.drop_table(table_name, database_name)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_week_int():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_week_int",
|
|
"describe": "time_unit=WEEK建表, datetype=int"
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
partition_name_list = []
|
|
today = datetime.datetime.now().weekday()
|
|
start_day = datetime.datetime.now() - datetime.timedelta(days=today)
|
|
for i in range(30, -31, -1):
|
|
p_name = start_day - datetime.timedelta(days=7 * i)
|
|
week = str("0" + str(int(p_name.strftime("%U")) + 1))
|
|
partition_name_list.append(str("p" + p_name.strftime("%Y_") + week[-2:]))
|
|
partition_value_list = []
|
|
for i in range(30, -31, -1):
|
|
p_value = start_day - datetime.timedelta(days=7 * i)
|
|
p_value2 = start_day - datetime.timedelta(days=(7 * (i - 1)))
|
|
p_value = p_value.strftime("%Y%m%d")
|
|
p_value2 = p_value2.strftime("%Y%m%d")
|
|
partition = '[types: [INT]; keys: [%s]; ..types: [INT]; keys: [%s]; )' % (p_value, p_value2)
|
|
partition_value_list.append(partition)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'WEEK', 'start': -30, 'end': 30, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
create(table_name, 'int', dynamic_partition_info)
|
|
# check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_month_date():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_month_date",
|
|
"describe": "time_unit=MONTH建表，datetype=date",
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
partition_name_list = []
|
|
for i in range(10, -11, -1):
|
|
p_name = datetime.datetime.now() - relativedelta(months=i)
|
|
partition_name_list.append(str("p" + p_name.strftime("%Y%m")))
|
|
partition_value_list = []
|
|
start_day = datetime.datetime.now()
|
|
for i in range(10, -11, -1):
|
|
p_value = start_day - relativedelta(months=i)
|
|
p_value2 = start_day - relativedelta(months=(i - 1))
|
|
p_value = p_value.strftime("%Y-%m") + "-01"
|
|
p_value2 = p_value2.strftime("%Y-%m") + "-01"
|
|
partition = '[types: [DATEV2]; keys: [%s]; ..types: [DATEV2]; keys: [%s]; )' % (p_value, p_value2)
|
|
partition_value_list.append(partition)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'MONTH', 'start': -10, 'end': 10, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
create(table_name, 'date', dynamic_partition_info)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_month_datetime():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_month_datetime",
|
|
"describe": "time_unit=MONTH建表，datetype=datetime",
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
partition_name_list = []
|
|
for i in range(10, -11, -1):
|
|
p_name = datetime.datetime.now() - relativedelta(months=i)
|
|
partition_name_list.append(str("p" + p_name.strftime("%Y%m")))
|
|
partition_value_list = []
|
|
start_day = datetime.datetime.now()
|
|
for i in range(10, -11, -1):
|
|
p_value = start_day - relativedelta(months=i)
|
|
p_value2 = start_day - relativedelta(months=(i - 1))
|
|
p_value = p_value.strftime("%Y-%m") + "-01 00:00:00"
|
|
p_value2 = p_value2.strftime("%Y-%m") + "-01 00:00:00"
|
|
partition = '[types: [DATETIMEV2]; keys: [%s]; ..types: [DATETIMEV2]; keys: [%s]; )' % (p_value, p_value2)
|
|
partition_value_list.append(partition)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'MONTH', 'start': -10, 'end': 10, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
create(table_name, 'datetime', dynamic_partition_info)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_month_int():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_month_int",
|
|
"describe": "time_unit=MONTH建表，datetype=int",
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
partition_name_list = []
|
|
for i in range(10, -11, -1):
|
|
p_name = datetime.datetime.now() - relativedelta(months=i)
|
|
partition_name_list.append(str("p" + p_name.strftime("%Y%m")))
|
|
partition_value_list = []
|
|
start_day = datetime.datetime.now()
|
|
for i in range(10, -11, -1):
|
|
p_value = start_day - relativedelta(months=i)
|
|
p_value2 = start_day - relativedelta(months=(i - 1))
|
|
p_value = p_value.strftime("%Y%m") + "01"
|
|
p_value2 = p_value2.strftime("%Y%m") + "01"
|
|
partition = '[types: [INT]; keys: [%s]; ..types: [INT]; keys: [%s]; )' % (p_value, p_value2)
|
|
partition_value_list.append(partition)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'MONTH', 'start': -10, 'end': 10, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
create(table_name, 'int', dynamic_partition_info)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_time_zone():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_time_zone",
|
|
"describe": "验证dynamic_partition.time_zone参数功能",
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
partition_name_list = []
|
|
for i in range(11, 4, -1):
|
|
p_name = (datetime.datetime.now() - datetime.timedelta(hours=i))
|
|
partition_name_list.append(str("p" + p_name.strftime("%Y%m%d%H")))
|
|
partition_value_list = []
|
|
for i in range(11, 4, -1):
|
|
p_value = (datetime.datetime.now() - datetime.timedelta(hours=i))
|
|
p_value2 = (datetime.datetime.now() - datetime.timedelta(hours=(i - 1)))
|
|
p_value = p_value.strftime("%Y-%m-%d %H:00:00")
|
|
p_value2 = p_value2.strftime("%Y-%m-%d %H:00:00")
|
|
partition = '[types: [DATETIMEV2]; keys: [%s]; ..types: [DATETIMEV2]; keys: [%s]; )' % (p_value, p_value2)
|
|
partition_value_list.append(partition)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'HOUR', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true', 'time_zone': 'Etc/GMT'}
|
|
create(table_name, 'datetime', dynamic_partition_info)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_start():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_start",
|
|
"describe": "验证dynamic_partition.start参数功能",
|
|
"tag": "p1,function,fuzz"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
start_list = [-5, -3, -10, -1, -100]
|
|
for start in start_list:
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': start, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
create(table_name, 'date', dynamic_partition_info)
|
|
partition_name_list = get_partition_name_list(start, 3, 'p')
|
|
partition_value_list = get_partition_value_list(start, 3)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.drop_table(table_name, database_name)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': 0, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
util.assert_return(False, 'Dynamic partition start must less than 0', create, table_name, 'date', \
|
|
dynamic_partition_info)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_end():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_end",
|
|
"describe": "验证dynamic_partition.end参数功能",
|
|
"tag": "p1,function,fuzz"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
end_list = [3, 5, 10, 100, 1]
|
|
for end in end_list:
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': end, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
create(table_name, 'date', dynamic_partition_info)
|
|
partition_name_list = get_partition_name_list(-3, end, 'p')
|
|
partition_value_list = get_partition_value_list(-3, end)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.drop_table(table_name, database_name)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 0, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
util.assert_return(False, 'Dynamic partition end must greater than 0', create, table_name, 'date', \
|
|
dynamic_partition_info)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_prefix():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_prefix",
|
|
"describe": "验证dynamic_partition.prefix参数功能",
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
prefix_list = ['snfkjds', 'a', 'vhklskhsfdkksdv', 'fds', 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa']
|
|
for prefix in prefix_list:
|
|
partition_name_list = get_partition_name_list(-3, 3, prefix)
|
|
partition_value_list = get_partition_value_list(-3, 3)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': prefix,
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
create(table_name, 'date', dynamic_partition_info)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.drop_table(table_name, database_name)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_buckets():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_buckets",
|
|
"describe": "验证dynamic_partition.buckets参数功能",
|
|
"tag": "p1,function,fuzz"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
buckets_list = [1, 2, 5, 10, 100]
|
|
for buckets in buckets_list:
|
|
partition_name_list = get_partition_name_list(-3, 3, 'p')
|
|
partition_value_list = get_partition_value_list(-3, 3)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': buckets, 'create_history_partition': 'true'}
|
|
create(table_name, 'date', dynamic_partition_info)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
ret = client.get_partition_list(table_name)
|
|
assert util.get_attr(ret, palo_job.PartitionInfo.Buckets) == [str(buckets) for i in range(7)]
|
|
client.drop_table(table_name, database_name)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': -10, 'create_history_partition': 'true'}
|
|
util.assert_return(False, 'Dynamic partition buckets must greater than 0', create, table_name, 'date', \
|
|
dynamic_partition_info)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_replication_num():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_replication_num",
|
|
"describe": "验证dynamic_partition.replication_num参数功能",
|
|
"tag": "p1,function,fuzz"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
replication_num_list = [1, 2, 3]
|
|
for replication_num in replication_num_list:
|
|
partition_name_list = get_partition_name_list(-3, 3, 'p')
|
|
partition_value_list = get_partition_value_list(-3, 3)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true', 'replication_num': replication_num}
|
|
create(table_name, 'date', dynamic_partition_info)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
ret = client.get_partition_list(table_name)
|
|
assert util.get_attr(ret, palo_job.PartitionInfo.ReplicationNum) == [str(replication_num) for i in range(7)]
|
|
client.drop_table(table_name, database_name)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true', 'replication_num': -3}
|
|
util.assert_return(False, 'Dynamic partition replication num must greater than 0', create, table_name, 'date', \
|
|
dynamic_partition_info)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_start_day_of_week():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_start_day_of_week",
|
|
"describe": "验证dynamic_partition.start_day_of_week参数功能",
|
|
"tag": "p1,function,fuzz"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
start_day_of_week_list = [1, 2, 3, 4, 5, 6, 7]
|
|
for start_day_of_week in start_day_of_week_list:
|
|
today = datetime.datetime.now().weekday()
|
|
start_day = datetime.datetime.now() - datetime.timedelta(days=(today - start_day_of_week + 1))
|
|
partition_name_list = []
|
|
for i in range(3, -4, -1):
|
|
p_name = start_day - datetime.timedelta(days=7 * i)
|
|
week = str("0" + str(p_name.strftime("%U")))
|
|
partition_name_list.append(str("p" + p_name.strftime("%Y_") + week[-2:]))
|
|
partition_value_list = []
|
|
for i in range(3, -4, -1):
|
|
p_value = start_day - datetime.timedelta(days=7 * i)
|
|
p_value2 = start_day - datetime.timedelta(days=(7 * (i - 1)))
|
|
p_value = p_value.strftime("%Y-%m-%d")
|
|
p_value2 = p_value2.strftime("%Y-%m-%d")
|
|
partition = '[types: [DATEV2]; keys: [%s]; ..types: [DATEV2]; keys: [%s]; )' % (p_value, p_value2)
|
|
partition_value_list.append(partition)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'WEEK', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true', 'start_day_of_week': start_day_of_week}
|
|
create(table_name, 'date', dynamic_partition_info)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.drop_table(table_name, database_name)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'WEEK', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true', 'start_day_of_week': 8}
|
|
util.assert_return(False, 'between 1 and 7', create, table_name, 'date', dynamic_partition_info)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_start_day_of_month():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_start_day_of_month",
|
|
"describe": "验证dynamic_partition.start_day_of_month参数功能",
|
|
"tag": "p1,function,fuzz"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
start_day_of_month_list = [1, 2, 5, 10, 28]
|
|
for start_day_of_month in start_day_of_month_list:
|
|
partition_name_list = []
|
|
today = datetime.datetime.now().strftime("%d")
|
|
if int(today) - start_day_of_month >= 0:
|
|
month_count = 0
|
|
else:
|
|
month_count = 1
|
|
for i in range(3 + month_count, -4 + month_count, -1):
|
|
p_name = datetime.datetime.now() - relativedelta(months=i)
|
|
partition_name_list.append(str("p" + p_name.strftime("%Y%m")))
|
|
partition_value_list = []
|
|
start_day = datetime.datetime.now()
|
|
for i in range(3 + month_count, -4 + month_count, -1):
|
|
p_value = start_day - relativedelta(months=i)
|
|
p_value2 = start_day - relativedelta(months=(i - 1))
|
|
if start_day_of_month >= 10:
|
|
p_value = p_value.strftime("%Y-%m") + "-" + str(start_day_of_month)
|
|
p_value2 = p_value2.strftime("%Y-%m") + "-" + str(start_day_of_month)
|
|
else:
|
|
p_value = p_value.strftime("%Y-%m") + "-0" + str(start_day_of_month)
|
|
p_value2 = p_value2.strftime("%Y-%m") + "-0" + str(start_day_of_month)
|
|
partition = '[types: [DATEV2]; keys: [%s]; ..types: [DATEV2]; keys: [%s]; )' % (p_value, p_value2)
|
|
partition_value_list.append(partition)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'MONTH', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true', 'start_day_of_month': start_day_of_month}
|
|
create(table_name, 'date', dynamic_partition_info)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.drop_table(table_name, database_name)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'MONTH', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true', 'start_day_of_month': 29}
|
|
util.assert_return(False, 'between 1 and 28', create, table_name, 'date', dynamic_partition_info)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_create_history_partition():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_create_history_partition",
|
|
"describe": "验证dynamic_partition.create_history_partition参数功能",
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'false'}
|
|
create(table_name, 'date', dynamic_partition_info)
|
|
partition_name_list = get_partition_name_list(0, 3, 'p')
|
|
partition_value_list = get_partition_value_list(0, 3)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_hot_partition_num():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_hot_partition_num",
|
|
"describe": "验证dynamic_partition.hot_partition_num参数功能",
|
|
"tag": "p1,function,fuzz"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
partition_name_list = get_partition_name_list(-3, 3, 'p')
|
|
partition_value_list = get_partition_value_list(-3, 3)
|
|
hot_partition_num_list = [None, 0, 1, 2, 3, 4]
|
|
for hot_partition_num in hot_partition_num_list:
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true', 'hot_partition_num': hot_partition_num}
|
|
create(table_name, 'date', dynamic_partition_info)
|
|
if hot_partition_num is None or hot_partition_num == 0:
|
|
storage_medium = ['HDD' for i in range(7)]
|
|
else:
|
|
storage_medium = ['HDD' for i in range(4 - hot_partition_num)] + \
|
|
['SSD' for i in range(hot_partition_num + 3)]
|
|
ret = client.get_partition_list(table_name)
|
|
assert util.get_attr(ret, palo_job.PartitionInfo.StorageMedium) == storage_medium
|
|
client.drop_table(table_name, database_name)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true', 'hot_partition_num': -1}
|
|
util.assert_return(False, 'larger than 0', create, table_name, 'date', dynamic_partition_info)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_dynamic_partition_history_partition_num():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_dynamic_partition_history_partition_num",
|
|
"describe": "验证dynamic_partition.history_partition_num参数功能",
|
|
"tag": "p1,function,fuzz"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
history_partition_num_list = [5, 3, -1, 1, 0, None]
|
|
for num in history_partition_num_list:
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true', 'history_partition_num': num}
|
|
create(table_name, 'date', dynamic_partition_info)
|
|
if num is None or num == -1:
|
|
start = -3
|
|
else:
|
|
start = -min(3, num)
|
|
partition_name_list = get_partition_name_list(start, 3, 'p')
|
|
partition_value_list = get_partition_value_list(start, 3)
|
|
check_partition_list(table_name, partition_name_list)
|
|
check_partition_range(table_name, partition_value_list)
|
|
client.drop_table(table_name, database_name)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true', 'history_partition_num': -2}
|
|
util.assert_return(False, 'Dynamic history partition num must greater than 0', create, table_name, 'date', \
|
|
dynamic_partition_info)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_composite_partition():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_composite_partition",
|
|
"describe": "验证复合分区创建动态分区表，建表失败",
|
|
"tag": "p1,function,fuzz"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
column = [('k1', 'date'), ('k2', 'date'), ('k3', 'int')]
|
|
partition_info = palo_client.PartitionInfo(['k1', 'k2'], [], [])
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
util.assert_return(False, 'only support single-column range partition', create, table_name, 'date',
|
|
dynamic_partition_info, column, partition_info=partition_info)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_list_partition():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_list_partition",
|
|
"describe": "验证list分区创建动态分区表，建表失败",
|
|
"tag": "p1,function,fuzz"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
partition_info = palo_client.PartitionInfo(['k1'], [], [], partition_type='LIST')
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
util.assert_return(False, 'Only support dynamic partition properties on range partition table',
|
|
create, table_name, 'date', dynamic_partition_info, partition_info=partition_info)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_range_partition():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_range_partition",
|
|
"describe": "验证range分区创建动态分区表，建表成功",
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
partition_info = palo_client.PartitionInfo(['k1'], [], [], partition_type='RANGE')
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
util.assert_return(True, None, create, table_name, 'date', dynamic_partition_info, partition_info=partition_info)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_type():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_type",
|
|
"describe": "分区数据格式不为date/datetime/int时创建动态分区表失败",
|
|
"tag": "p1,function,fuzz"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
typelist = ['float', 'double', 'char', 'varchar', 'hll', 'bitmap']
|
|
for type in typelist:
|
|
column = [('k1', type), ('k2', 'date'), ('k3', 'int')]
|
|
util.assert_return(False, 'errCode', create, table_name, 'date', dynamic_partition_info, column=column)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_aggregation_aggregate():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_aggregation_aggregate",
|
|
"describe": "AGGREGATE聚合方式创建动态分区表",
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
column = [('k1', 'date'), ('k2', 'int', 'sum'), ('k3', 'int', 'max')]
|
|
keys_desc = 'AGGREGATE KEY(k1)'
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
util.assert_return(True, None, create, table_name, 'date', dynamic_partition_info, column, keys_desc=keys_desc)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_aggregation_unique():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_aggregation_unique",
|
|
"describe": "UNIQUE聚合方式创建动态分区表",
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
column = [('k1', 'date'), ('k2', 'int'), ('k3', 'int')]
|
|
keys_desc = 'UNIQUE KEY(k1)'
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
util.assert_return(True, None, create, table_name, 'date', dynamic_partition_info, column, keys_desc=keys_desc)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_aggregation_duplicate():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_aggregation_duplicate",
|
|
"describe": "DUPLICATE聚合方式创建动态分区表",
|
|
"tag": "p1,function"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
column = [('k1', 'date'), ('k2', 'int'), ('k3', 'int')]
|
|
keys_desc = 'DUPLICATE KEY(k1)'
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'start': -3, 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
util.assert_return(True, None, create, table_name, 'date', dynamic_partition_info, column, keys_desc=keys_desc)
|
|
client.clean(database_name)
|
|
|
|
|
|
def test_create_history_partition_with_no_start():
|
|
"""
|
|
{
|
|
"title": "test_sys_dynamic_partition_parameter.test_create_history_partition_with_no_start",
|
|
"describe": "不设置start创建历史分区,issues #5995",
|
|
"tag": "p1,fuzz"
|
|
}
|
|
"""
|
|
database_name, table_name, index_name = util.gen_num_format_name_list()
|
|
LOG.info(L('', database_name=database_name, table_name=table_name, index_name=index_name))
|
|
client.clean(database_name)
|
|
client.create_database(database_name)
|
|
client.use(database_name)
|
|
dynamic_partition_info = {'enable': 'true', 'time_unit': 'DAY', 'end': 3, 'prefix': 'p',
|
|
'buckets': 10, 'create_history_partition': 'true'}
|
|
util.assert_return(False, 'Provide start or history_partition_num property when creating history partition', \
|
|
create, table_name, 'date', dynamic_partition_info)
|
|
client.clean(database_name)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
setup_module()
|
|
test_dynamic_partition_enable()
|