#!/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()