770 lines
30 KiB
Python
770 lines
30 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_sys_time_zone.py
|
|
*
|
|
**************************************************************************/
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import time
|
|
import datetime
|
|
import pytest
|
|
|
|
from data import partition as DATA
|
|
sys.path.append("../")
|
|
from lib import palo_config
|
|
from lib import palo_client
|
|
import pymysql
|
|
from lib import util
|
|
from lib import palo_job
|
|
from lib import common
|
|
|
|
config = palo_config.config
|
|
broker_name = config.broker_name
|
|
broker_property = config.broker_property
|
|
broker_info = palo_config.broker_info
|
|
repo_location = config.repo_location
|
|
|
|
LOG = palo_client.LOG
|
|
L = palo_client.L
|
|
repo_name = "backup_restore_repo_zone"
|
|
|
|
|
|
def setup_module():
|
|
"""
|
|
setUp
|
|
"""
|
|
global Palo_client
|
|
global mysql_cursor
|
|
Palo_client = palo_client.PaloClient(config.fe_host, config.fe_query_port,
|
|
config.palo_db, config.fe_user, config.fe_password)
|
|
Palo_client.init()
|
|
master = Palo_client.get_master_host()
|
|
Palo_client = common.get_client(master)
|
|
|
|
connect = pymysql.connect(host=config.mysql_host, port=config.mysql_port,\
|
|
user=config.mysql_user, passwd=config.mysql_password)
|
|
mysql_cursor = connect.cursor()
|
|
try:
|
|
ret = Palo_client.create_repository(repo_name, broker_name, repo_location=repo_location,
|
|
repo_properties=broker_property)
|
|
assert ret, "palo create_repository failed"
|
|
except Exception as e:
|
|
print(str(e))
|
|
sql = "set time_zone = '+08:00'"
|
|
check2(sql)
|
|
|
|
|
|
def mysql_execute(sql, db=None):
|
|
"""
|
|
连接mysql执行语句
|
|
"""
|
|
try:
|
|
if db is None:
|
|
db = os.environ["MYSQL_DB"]
|
|
mysql_cursor.execute("use %s" % db)
|
|
mysql_cursor.execute(sql)
|
|
LOG.info(L('mysql execute sql', db=db, sql=sql))
|
|
return mysql_cursor.fetchall()
|
|
except Exception as error:
|
|
LOG.error(L('error', error=error))
|
|
assert False, "execute error. %s" % str(error)
|
|
|
|
|
|
def get_timestamp(res):
|
|
"""将字符串转为时间戳, '18:01:10' -> 数字时间戳，这样好比较大小，不存在两个时间差1s，分钟对应的数值差1"""
|
|
res1 = str(res[0][0])
|
|
timeArray = time.strptime(res1, "%H:%M:%S")
|
|
timestamp = time.mktime(timeArray)
|
|
LOG.info(L('get_timestamp, input, output', res=res, timestamp=timestamp))
|
|
return timestamp
|
|
|
|
|
|
def check2(psql, msql=None):
|
|
"""palo & mysql execute sql
|
|
:sql: execute sql
|
|
:msql: mysql 执行的sql
|
|
"""
|
|
if not msql:
|
|
msql = psql
|
|
LOG.info(L('palo sql', palo_sql=psql))
|
|
res1= Palo_client.execute(psql)
|
|
LOG.info(L('mysql sql', mysql_sql=msql))
|
|
res2 = mysql_execute(msql)
|
|
if "CURTIME" in psql:
|
|
##可能会差1s左右，故转为时间戳个数
|
|
timestamp_res1 = get_timestamp(res1)
|
|
timestamp_res2 = get_timestamp(res2)
|
|
LOG.info(L('CURTIME sql : palo res; mysql res', \
|
|
timestamp_res1=timestamp_res1, timestamp_res2=timestamp_res2))
|
|
assert abs(timestamp_res1 - timestamp_res2) <= 1, "palo %s, mysql %s, \
|
|
excepted res1 - res2 <= 1" % (timestamp_res1, timestamp_res2)
|
|
else:
|
|
util.check(res1, res2)
|
|
|
|
|
|
def show_be_broker_time():
|
|
"""show be,broker time,把be、broker里和时间相关的变量,非空则放到list里，逐条比较是否相等
|
|
show be：LastStartTime：上次启动的时间，不会一直变,格式2019-09-04 20:54:55
|
|
show broker：LastStartTime：上次启动的时间，不会一直变，格式2019-09-04 20:54:55
|
|
"""
|
|
be_list = Palo_client.get_alive_backend_list()
|
|
be_info = be_list[0]
|
|
list = []
|
|
LOG.info(L('be info is', be_info=be_info))
|
|
be_start_time = palo_job.BackendProcInfo(be_info).get_backend_start_time()
|
|
LOG.info(L('palo be start time', start_time=be_start_time))
|
|
list.append(be_start_time)
|
|
broker = Palo_client.get_broker_start_update_time()
|
|
if broker:
|
|
LOG.info(L('broker start_time', start_time=broker))
|
|
list += [broker]
|
|
return list
|
|
|
|
|
|
def unity_datetime_format(time, snapshot_flag=False):
|
|
"""统一datetime的格式"，snapshot_flag是否是snapshot，格式不一样"""
|
|
LOG.info(L('unity datetime format', time=time, snapshot=snapshot_flag))
|
|
try:
|
|
if snapshot_flag:
|
|
unity_time = datetime.datetime.strptime('%s' % time, '%Y-%m-%d-%H-%M-%S')
|
|
else:
|
|
unity_time = datetime.datetime.strptime('%s' % time, '%Y-%m-%d %H:%M:%S')
|
|
except ValueError as e:
|
|
if snapshot_flag:
|
|
unity_time = datetime.datetime.strptime('%s' % time, '%Y-%m-%d-%H-%M-%S.%f')
|
|
else:
|
|
unity_time = datetime.datetime.strptime('%s' % time, '%Y-%m-%d %H:%M:%S.%f')
|
|
return unity_time
|
|
|
|
|
|
def recombinate_time(origin_time, offset_hour, offset_minutes):
|
|
"""在origin_time时间上叠加上offset_time时间
|
|
-01:10 和+06:10 距离+08:00的分钟计算方式不一样
|
|
"""
|
|
seconds = 0
|
|
if offset_hour < 0:
|
|
##+09:10
|
|
seconds = (offset_hour * 60 - offset_minutes) * 60
|
|
elif offset_hour >= 8:
|
|
##-01:10
|
|
seconds = (offset_hour * 60 + offset_minutes) * 60
|
|
else:
|
|
##+06:10
|
|
seconds = (offset_hour * 60 - offset_minutes) * 60
|
|
offset_time = datetime.timedelta(days=0, seconds=seconds, microseconds=0)
|
|
assert isinstance(offset_time, datetime.timedelta)
|
|
offert_time = (origin_time - offset_time).isoformat()
|
|
try:
|
|
offert_time = datetime.datetime.strptime(offert_time, '%Y-%m-%dT%H:%M:%S')
|
|
except ValueError as e:
|
|
offert_time = datetime.datetime.strptime(offert_time, '%Y-%m-%dT%H:%M:%S.%f')
|
|
return offert_time
|
|
|
|
|
|
def wait_for_integer_min():
|
|
"""Waiting time to judge in the same minute"""
|
|
sql = "select SECOND(now())"
|
|
ret = Palo_client.execute(sql)
|
|
if int(ret[0][0]) > 50:
|
|
time.sleep(20)
|
|
|
|
|
|
def check2_gap_time_zone(palo_res, mysql_res, zone, snapshot_flag=False):
|
|
"""比较两个tiemdate时间的差;如：2019-09-19 04:05:59 格式
|
|
参数：palo_res, mysql_res，要对比的两个时间；zone 新设置的时区值"""
|
|
res = get_day_and_second(zone)
|
|
hour = 8 - int(res[0])
|
|
second = int(res[1])
|
|
for palo_data, mysql_data in zip(palo_res, mysql_res):
|
|
if palo_data == 'N/A' or palo_data == '':
|
|
###没broker时，返回的是N/A
|
|
assert palo_data == mysql_data, "err: excepted %s == %s" % (palo_data, mysql_data)
|
|
continue
|
|
unity_palo = unity_datetime_format(palo_data, snapshot_flag)
|
|
unity_mysql = unity_datetime_format(mysql_data, snapshot_flag)
|
|
|
|
##小于+08:00，如+01:10，-03:10. 偏移量是正数
|
|
palo_date = recombinate_time(unity_palo, hour, second)
|
|
assert palo_date == unity_mysql, "res %s, excepted %s" % (palo_date, unity_mysql)
|
|
|
|
|
|
def get_day_and_second(date_delta):
|
|
"""从datetime里获取小时和分钟 eg:-08:10,取出 8和10"""
|
|
if date_delta:
|
|
res_list = date_delta.split(':')
|
|
day = res_list[0]
|
|
second = res_list[1]
|
|
return day, second
|
|
return False
|
|
|
|
|
|
def backup(repo_name, database_name, table_name, snapshot_label):
|
|
"""创建仓库，备份"""
|
|
ret = Palo_client.backup(snapshot_label=snapshot_label, backup_list=[table_name],
|
|
repo_name=repo_name, database_name=database_name,
|
|
is_wait=True)
|
|
LOG.info(L("backup res", snapshot_label=snapshot_label, repo_name=repo_name, \
|
|
table_name=table_name, res=ret))
|
|
assert ret
|
|
|
|
|
|
def restore(repo_name, database_name, table_name, snapshot_label):
|
|
"""恢复到新表里"""
|
|
##restore
|
|
new_table_name = table_name + "_new"
|
|
restore_list = list()
|
|
restore_list.append('%s AS %s' % (table_name, new_table_name))
|
|
ret = Palo_client.restore(snapshot_name=snapshot_label, repo_name=repo_name,
|
|
restore_list=restore_list, database_name=database_name,
|
|
is_wait=True)
|
|
LOG.info(L("restore res", snapshot_label=snapshot_label, repo_name=repo_name, \
|
|
table_name=table_name, res=ret))
|
|
assert ret
|
|
# check
|
|
line1 = 'select * from %s order by k1' % table_name
|
|
line2 = 'select * from %s order by k1' % new_table_name
|
|
LOG.info(L('palo sql 1', palo_sql=line1))
|
|
ret1 = Palo_client.execute(line1)
|
|
LOG.info(L('palo sql 2', palo_sql=line2))
|
|
ret2 = Palo_client.execute(line2)
|
|
util.check(ret1, ret2)
|
|
|
|
|
|
def get_backup_time(backup_db):
|
|
"""获取备份相关时间信息"""
|
|
##backup
|
|
snapshot_name = ''
|
|
res_backup = ''
|
|
time_list = []
|
|
|
|
res_backup = Palo_client.show_backup(backup_db)
|
|
LOG.info(L('show backup res', res_backup=res_backup))
|
|
assert res_backup
|
|
|
|
backup_info = res_backup[-1]
|
|
time_list = [palo_job.BackupJob(backup_info).get_create_time(), \
|
|
palo_job.BackupJob(backup_info).get_snap_finish_time(),\
|
|
palo_job.BackupJob(backup_info).get_upload_finish_time(), \
|
|
palo_job.BackupJob(backup_info).get_finished_time()]
|
|
snapshot_name = palo_job.BackupJob(backup_info).get_snapshotName()
|
|
return time_list, snapshot_name
|
|
|
|
|
|
def get_restore_time(restore_db):
|
|
"""获取备份恢复相关时间信息"""
|
|
##restore
|
|
snapshot_name = ''
|
|
res_backup = ''
|
|
time_list = []
|
|
|
|
res = Palo_client.show_restore(restore_db)
|
|
LOG.info(L('show RESTORE res', res_restore=res))
|
|
assert res
|
|
time_list += [palo_job.RestoreJob(res[-1]).get_create_time(),\
|
|
palo_job.RestoreJob(res[-1]).get_meta_prepare_time(),
|
|
palo_job.RestoreJob(res[-1]).get_snapshot_finished_time(),
|
|
palo_job.RestoreJob(res[-1]).get_down_load_finished(),
|
|
palo_job.RestoreJob(res[-1]).get_finished()]
|
|
return time_list, snapshot_name
|
|
|
|
|
|
def get_repo_time():
|
|
"""获取备repo相关时间信息"""
|
|
##repo
|
|
time_list = []
|
|
res = Palo_client.show_repository()
|
|
assert res
|
|
LOG.info(L('show REPOSITORIES res', res=res[0]))
|
|
time_list = [palo_job.RepoInfo(res[0]).get_create_time()]
|
|
return time_list, palo_job.RepoInfo(res[0]).get_repo_name()
|
|
|
|
|
|
def get_snapshot_time(repo, snapshot_name=None):
|
|
"""获取备snapshot相关时间信息"""
|
|
snap_res = Palo_client.show_snapshot(repo, snapshot_name)
|
|
LOG.info(L('show snapshot repo, snapshot_name, res',\
|
|
repo=repo, snapshot_name=snapshot_name, res=snap_res))
|
|
assert snap_res
|
|
time_list = [palo_job.SnapshotInfo(snap_res[0]).get_timestamp()]
|
|
LOG.info(L('get snapshot time', time_list=time_list))
|
|
return time_list
|
|
|
|
|
|
def create_table(database_name, table_name):
|
|
"""建表"""
|
|
Palo_client.clean(database_name)
|
|
Palo_client.create_database(database_name)
|
|
Palo_client.use(database_name)
|
|
sql = "drop table if exists %s" % table_name
|
|
LOG.info(L('palo sql', palo_sql=sql))
|
|
res = Palo_client.execute(sql)
|
|
# 建表
|
|
partition_name_list = ['partition_a', 'partition_b', 'partition_c', 'partition_d']
|
|
partition_value_list = ['100', '500', '1000', 'MAXVALUE']
|
|
|
|
partition_info = palo_client.PartitionInfo('k3',
|
|
partition_name_list, partition_value_list)
|
|
distribution_type_d = 'HASH(k1, k2, k5)'
|
|
distribution_info_d = palo_client.DistributionInfo(distribution_type_d, 31)
|
|
Palo_client.create_table(table_name, DATA.schema_1, partition_info, distribution_info_d)
|
|
assert Palo_client.show_tables(table_name)
|
|
for partition_name in partition_name_list:
|
|
assert Palo_client.get_partition(table_name, partition_name)
|
|
|
|
|
|
def test_set_sys_time_zone():
|
|
"""
|
|
{
|
|
"title": "test_sys_time_zone.test_set_sys_time_zone",
|
|
"describe": "设置系统变量system_time_zone。系统不允许，会报错",
|
|
"tag": "function,p1,fuzz"
|
|
}
|
|
"""
|
|
"""
|
|
设置系统变量system_time_zone。系统不允许，会报错
|
|
"""
|
|
zone = '+08:00'
|
|
excepted = "%s variable '%s' is read-only. Use SET %s to assign the value"
|
|
try:
|
|
sql = "set system_time_zone = '%s'" % zone
|
|
res = Palo_client.execute(sql)
|
|
assert 0 == 1, "palo sql %s shoud not ok" % sql
|
|
except Exception as err:
|
|
LOG.info(L('test_set_sys_time_zone err', error=err))
|
|
assert excepted in str(err), "diff: res %s, excepted %s" % (err, excepted)
|
|
try:
|
|
sql = "set global system_time_zone = '%s'" % zone
|
|
Palo_client.execute(sql)
|
|
assert 0 == 1, "palo sql %s shoud not ok" % sql
|
|
except Exception as err:
|
|
LOG.info(L('test_set_sys_time_zone err', error=err))
|
|
assert excepted in str(err), "diff: res %s, excepted %s" % (err, excepted)
|
|
|
|
|
|
def test_set_time_zone():
|
|
"""
|
|
{
|
|
"title": "test_sys_time_zone.test_set_time_zone",
|
|
"describe": "设置time_zone变量。测试点：多种方式；与system_time_zone不匹配等",
|
|
"tag": "function,p1,fuzz"
|
|
}
|
|
"""
|
|
"""
|
|
设置time_zone变量。
|
|
测试点：多种方式；与system_time_zone不匹配等
|
|
"""
|
|
zone_ok = ['America/Los_Angeles', 'Asia/Shanghai', '-00:00', '+00:00', '-08:00', '+09:00',\
|
|
'-08:10', '+08:10', '+12:00', '-12:00']
|
|
zone_err = ['met', 'CMT', 'CTT', 'CAT','UTC','utc', 'CST', 'cst', '-12:01',\
|
|
'+12:01', '-08:90', '+08:90', '09:00', 'SYSTEM']
|
|
for zone in zone_ok:
|
|
Palo_client.set_time_zone(zone)
|
|
res_var = Palo_client.show_variables("time_zone")
|
|
assert res_var[1][1] == zone, "res %s, excepted %s" % (res_var[1][1], zone)
|
|
|
|
excepted = "Unknown or incorrect time zone"
|
|
for zone in zone_err:
|
|
try:
|
|
Palo_client.set_time_zone(zone)
|
|
LOG.error(L('err res', zone=zone))
|
|
except Exception as err:
|
|
assert excepted in str(err), "res %s, excepted %s" % (str(err), excepted)
|
|
try:
|
|
Palo_client.set_time_zone(zone)
|
|
LOG.error(L('err res', zone=zone))
|
|
except Exception as err:
|
|
assert excepted in str(err), "res %s, excepted %s" % (str(err), excepted)
|
|
|
|
|
|
def test_set_time_zone_show_proc():
|
|
"""
|
|
{
|
|
"title": "test_sys_time_zone.test_set_time_zone_show_proc",
|
|
"describe": "验证时区设置对show proc相关的时间显示",
|
|
"tag": "function,p1"
|
|
}
|
|
"""
|
|
"""
|
|
验证时区设置对show proc相关的时间显示
|
|
"""
|
|
zone_list = ['-01:10', '+03:30', '+09:01']
|
|
for zone in zone_list:
|
|
Palo_client.set_time_zone('+08:00')
|
|
res_var = Palo_client.show_variables("time_zone")
|
|
assert res_var[1][1] == "+08:00", "res %s, excepted +08:00" % res_var[1][1]
|
|
time.sleep(5)
|
|
res_before = show_be_broker_time()
|
|
Palo_client.set_time_zone(zone)
|
|
res_var = Palo_client.show_variables("time_zone")
|
|
assert res_var[1][1] == zone, "res %s, excepted %s" % (res_var[1][1], zone)
|
|
#varify_time_zone_correct(zone, Palo_client, False, zone)
|
|
time.sleep(5)
|
|
res_after = show_be_broker_time()
|
|
assert res_after
|
|
LOG.info(L('zone, before res, after res',\
|
|
zone=zone, res_before=res_before, res_after=res_after))
|
|
check2_gap_time_zone(res_before, res_after, zone)
|
|
|
|
|
|
def test_set_time_zone_show_backup():
|
|
"""
|
|
{
|
|
"title": "test_sys_time_zone.test_set_time_zone_show_backup",
|
|
"describe": "创建db，导入数据，备份,setUp里会设置时区为+08:00，有这些数据后，先获取时间信息，然后设置新时区，再次获取时间",
|
|
"tag": "function,p1"
|
|
}
|
|
"""
|
|
"""show backup_restore
|
|
创建db，导入数据，备份
|
|
setUp里会设置时区为+08:00，有这些数据后，先获取时间信息，然后设置新时区，再次获取时间
|
|
"""
|
|
Palo_client.set_time_zone('+08:00')
|
|
res_var = Palo_client.show_variables("time_zone")
|
|
assert res_var[1][1] == "+08:00", "res %s, excepted +08:00" % res_var[1][1]
|
|
|
|
database_name, table_name, index_name = util.gen_name_list()
|
|
create_table(database_name, table_name)
|
|
# 导入
|
|
data_desc_list = palo_client.LoadDataInfo(DATA.file_path_1, table_name)
|
|
assert Palo_client.batch_load(util.get_label(), data_desc_list, broker=broker_info)
|
|
##进行备份恢复
|
|
snapshot_label = util.get_snapshot_label('backup')
|
|
backup(repo_name, database_name, table_name, snapshot_label)
|
|
######第一次获取时间
|
|
res_before, snapshot = get_backup_time(database_name)
|
|
assert res_before
|
|
########set time zone
|
|
zone = "+01:00"
|
|
Palo_client.set_time_zone(zone)
|
|
res_var = Palo_client.show_variables("time_zone")
|
|
LOG.info(L('zone, res', zone=zone, res=res_var))
|
|
assert res_var[1][1] == zone, "res %s, excepted %s" % (res_var[1][1], zone)
|
|
time.sleep(5)
|
|
#######再次获取时间
|
|
res_after, snapshot = get_backup_time(database_name)
|
|
assert res_after
|
|
LOG.info(L('zone, before res, after res',\
|
|
zone=zone, res_before=res_before, res_after=res_after))
|
|
check2_gap_time_zone(res_before, res_after, zone)
|
|
Palo_client.clean(database_name)
|
|
|
|
|
|
def test_set_time_zone_show_backup_restore():
|
|
"""
|
|
{
|
|
"title": "test_sys_time_zone.test_set_time_zone_show_backup_restore",
|
|
"describe": "创建db，导入数据，备份，后恢复, setUp里会设置时区为+08:00，有这些数据后，先获取时间信息，然后设置新时区，再次获取时间",
|
|
"tag": "function,p1"
|
|
}
|
|
"""
|
|
"""show backup_restore
|
|
创建db，导入数据，备份，后恢复
|
|
setUp里会设置时区为+08:00，有这些数据后，先获取时间信息，然后设置新时区，再次获取时间
|
|
"""
|
|
Palo_client.set_time_zone("+08:00")
|
|
database_name, table_name, index_name = util.gen_name_list()
|
|
create_table(database_name, table_name)
|
|
# 导入
|
|
data_desc_list = palo_client.LoadDataInfo(DATA.file_path_1, table_name)
|
|
assert Palo_client.batch_load(util.get_label(), data_desc_list, broker=broker_info, is_wait=True)
|
|
##进行备份恢复
|
|
snapshot_label = util.get_snapshot_label('backup_restore')
|
|
backup(repo_name, database_name, table_name, snapshot_label)
|
|
restore(repo_name, database_name, table_name, snapshot_label)
|
|
######第一次获取时间
|
|
res_before, snapshot = get_restore_time(database_name)
|
|
#有内容才继续
|
|
assert res_before
|
|
zone = "+01:00"
|
|
Palo_client.set_time_zone(zone)
|
|
res_var = Palo_client.show_variables("time_zone")
|
|
LOG.info(L('zone, res', zone=zone, res=res_var))
|
|
assert res_var[1][1] == zone, "res %s, excepted %s" % (res_var[1][1], zone)
|
|
time.sleep(5)
|
|
#######再次获取时间
|
|
res_after, snapshot = get_restore_time(database_name)
|
|
assert res_after
|
|
###因为标准是+08:00，现在设置+01:00，时间相差7小时,0分钟
|
|
LOG.info(L('zone, before res, after res, excepted',\
|
|
zone=zone, res_before=res_before, res_after=res_after))
|
|
check2_gap_time_zone(res_before, res_after, zone)
|
|
Palo_client.clean(database_name)
|
|
|
|
|
|
def test_set_time_zone_show_repo():
|
|
"""
|
|
{
|
|
"title": "test_sys_time_zone.test_set_time_zone_show_repo",
|
|
"describe": "setUp里会设置时区为+08:00，先获取时间信息，然后设置新时区，再次获取时间",
|
|
"tag": "function,p1"
|
|
}
|
|
"""
|
|
"""show repo
|
|
setUp里会设置时区为+08:00，先获取时间信息，然后设置新时区，再次获取时间
|
|
"""
|
|
##set time zone
|
|
zone = "+08:00"
|
|
Palo_client.set_time_zone(zone)
|
|
res_var = Palo_client.show_variables("time_zone")
|
|
assert res_var[1][1] == zone, "res %s, excepted %s" % (res_var[1][1], zone)
|
|
res_before = get_repo_time()
|
|
assert res_before
|
|
##set time zone
|
|
zone = "+01:00"
|
|
Palo_client.set_time_zone(zone)
|
|
res_var = Palo_client.show_variables("time_zone")
|
|
assert res_var[1][1] == zone, "res %s, excepted %s" % (res_var[1][1], zone)
|
|
time.sleep(5)
|
|
res_after = get_repo_time()
|
|
assert res_after
|
|
LOG.info(L('zone, before res, after res',\
|
|
zone=zone, res_before=res_before, res_after=res_after))
|
|
check2_gap_time_zone(res_before[0], res_after[0], zone)
|
|
|
|
|
|
def test_set_time_zone_show_snapshot():
|
|
"""
|
|
{
|
|
"title": "test_sys_time_zone.test_set_time_zone_show_snapshot",
|
|
"describe": "setUp里会设置时区为+08:00，先获取时间信息，然后设置新时区，再次获取时间",
|
|
"tag": "function,p1,fuzz"
|
|
}
|
|
"""
|
|
"""show snapshot
|
|
setUp里会设置时区为+08:00，先获取时间信息，然后设置新时区，再次获取时间
|
|
"""
|
|
###snapshot, 与时间无关
|
|
res_repo = get_repo_time()
|
|
assert res_repo
|
|
repo = res_repo[1]
|
|
snapshot_name = None
|
|
LOG.info(L('repo,snapshot_name', repo=repo, snapshot_name=snapshot_name))
|
|
if repo:
|
|
zone = "+08:00"
|
|
Palo_client.set_time_zone(zone)
|
|
res_var = Palo_client.show_variables("time_zone")
|
|
assert res_var[1][1] == zone, "res %s, excepted %s" % (res_var[1][1], zone)
|
|
res_before = get_snapshot_time(repo, snapshot_name)
|
|
assert res_before
|
|
##set time zone
|
|
zone = "+01:00"
|
|
Palo_client.set_time_zone(zone)
|
|
res_var = Palo_client.show_variables("time_zone")
|
|
assert res_var[1][1] == zone, "res %s, excepted %s" % (res_var[1][1], zone)
|
|
time.sleep(5)
|
|
res_after = get_snapshot_time(repo, snapshot_name)
|
|
assert res_after
|
|
LOG.info(L('zone, before res, after res',\
|
|
zone=zone, res_before=res_before, res_after=res_after))
|
|
try:
|
|
check2_gap_time_zone(res_before, res_after, zone, True)
|
|
LOG.error(L('snapshot time zone varify err', res_before=res_before, res_after=res_after))
|
|
except Exception as err:
|
|
assert 'excepted' in str(err), "excepted excepted, err: %s" % str(err)
|
|
else:
|
|
raise pytest.skip('get zone failed')
|
|
|
|
|
|
def test_set_time_zone_alter_table():
|
|
"""
|
|
{
|
|
"title": "test_sys_time_zone.test_set_time_zone_alter_table",
|
|
"describe": "setUp里会设置时区为+08:00，先获取时间信息，然后设置新时区，再次获取时间",
|
|
"tag": "function,p1"
|
|
}
|
|
"""
|
|
"""
|
|
设置time_zone变量,验证对导schema change的影响。
|
|
setUp里会设置时区为+08:00，先获取时间信息，然后设置新时区，再次获取时间
|
|
"""
|
|
database_name, table_name, index_name = util.gen_name_list()
|
|
#建表
|
|
create_table(database_name, table_name)
|
|
zone = "+08:00"
|
|
Palo_client.set_time_zone(zone)
|
|
res_var = Palo_client.show_variables("time_zone")
|
|
assert res_var[1][1] == zone, "res %s, excepted %s" % (res_var[1][1], zone)
|
|
##alter table
|
|
column_list = [('k11', 'INT KEY', None, '5')]
|
|
ret = Palo_client.schema_change_add_column(table_name, column_list,\
|
|
after_column_name='k1', is_wait_job=True)
|
|
assert ret
|
|
res_before = []
|
|
res_after = []
|
|
schema_change_job_list = Palo_client.get_table_schema_change_job_list(table_name, database_name)
|
|
LOG.info(L('palo db, table, res', db=database_name, table=table_name, res=schema_change_job_list))
|
|
res_before.append(schema_change_job_list[-1][palo_job.SchemaChangeJob.CreateTime])
|
|
res_before.append(schema_change_job_list[-1][palo_job.SchemaChangeJob.FinishTime])
|
|
##set time zone
|
|
zone = "+01:00"
|
|
Palo_client.set_time_zone(zone)
|
|
res_var = Palo_client.show_variables("time_zone")
|
|
assert res_var[1][1] == zone, "res %s, excepted %s" % (res_var[1][1], zone)
|
|
schema_change_job_list = Palo_client.get_table_schema_change_job_list(table_name, database_name)
|
|
LOG.info(L('palo db, table, res', db=database_name, table=table_name, res=schema_change_job_list))
|
|
res_after.append(schema_change_job_list[-1][palo_job.SchemaChangeJob.CreateTime])
|
|
res_after.append(schema_change_job_list[-1][palo_job.SchemaChangeJob.FinishTime])
|
|
###check
|
|
LOG.info(L('zone, before res, after res',\
|
|
zone=zone, res_before=res_before, res_after=res_after))
|
|
check2_gap_time_zone(res_before, res_after, zone)
|
|
Palo_client.clean(database_name)
|
|
|
|
|
|
def test_set_time_zone_delete_job():
|
|
"""
|
|
{
|
|
"title": "test_sys_time_zone.test_set_time_zone_delete_job",
|
|
"describe": "设置time_zone变量,验证对删除任务的影响。setUp里会设置时区为+08:00，先获取时间信息，然后设置新时区，再次获取时间",
|
|
"tag": "function,p1"
|
|
}
|
|
"""
|
|
"""
|
|
设置time_zone变量,验证对删除任务的影响。
|
|
setUp里会设置时区为+08:00，先获取时间信息，然后设置新时区，再次获取时间
|
|
"""
|
|
database_name, table_name, index_name = util.gen_name_list()
|
|
create_table(database_name, table_name)
|
|
##delete table
|
|
zone = "CST"
|
|
Palo_client.set_time_zone(zone)
|
|
res_var = Palo_client.show_variables("time_zone")
|
|
assert res_var[1][1] == zone, "res %s, excepted %s" % (res_var[1][1], zone)
|
|
ret = Palo_client.delete(table_name, [('k1', '=', '3')], 'partition_a')
|
|
assert ret
|
|
res = Palo_client.show_delete(database_name)
|
|
LOG.info(L('palo delete result', palo_result=res))
|
|
delete_time_before = palo_job.DeleteJob(res[-1]).get_create_time()
|
|
##set time zone
|
|
zone = "+01:00"
|
|
Palo_client.set_time_zone(zone)
|
|
res_var = Palo_client.show_variables("time_zone")
|
|
assert res_var[1][1] == zone, "res %s, excepted %s" % (res_var[1][1], zone)
|
|
res_2 = Palo_client.show_delete(database_name)
|
|
assert res_2
|
|
delete_time_after = palo_job.DeleteJob(res_2[-1]).get_create_time()
|
|
LOG.info(L('zone, before res, after res',\
|
|
zone=zone, res_before=[delete_time_before], res_after=[delete_time_after]))
|
|
print(delete_time_before)
|
|
print(delete_time_after)
|
|
check2_gap_time_zone([delete_time_before], [delete_time_after], zone)
|
|
Palo_client.clean(database_name)
|
|
|
|
|
|
def test_set_time_zone_select_time_function():
|
|
"""
|
|
{
|
|
"title": "test_sys_time_zone.test_set_time_zone_select_time_function",
|
|
"describe": "设置time_zone变量,验证对时间相关函数的影响。测试点：5个函数,now(),curtime(),UNIX_TIMESTAMP() FROM_UNIXTIME(), CONVERT_TZ()",
|
|
"tag": "function,p1"
|
|
}
|
|
"""
|
|
"""
|
|
设置time_zone变量,验证对时间相关函数的影响。
|
|
测试点：5个函数,now(),curtime(),UNIX_TIMESTAMP() FROM_UNIXTIME(), CONVERT_TZ()
|
|
"""
|
|
zone_list = ["+06:00", "+09:10", "-01:10", "+08:00"]
|
|
for zone in zone_list:
|
|
sql = "set time_zone = '%s'" % zone
|
|
check2(sql)
|
|
res_var = Palo_client.show_variables("time_zone")
|
|
assert res_var[1][1] == zone, "res %s, excepted %s" % (res_var[1][1], zone)
|
|
#UNIX_TIMESTAMP
|
|
sql = "select UNIX_TIMESTAMP('1970-01-01 08:00:00'), UNIX_TIMESTAMP('1970-01-01 18:10:10')"
|
|
check2(sql)
|
|
##curtime
|
|
sql = "SELECT CURTIME()"
|
|
check2(sql)
|
|
##FROM_UNIXTIME
|
|
sql = "select FROM_UNIXTIME(123.4, '%Y-%m-%d %H:%i:%s'), FROM_UNIXTIME(-123,\
|
|
'%Y-%m-%d %H:%i:%s'), FROM_UNIXTIME(+123, '%Y-%m-%d %H:%i:%s')"
|
|
check2(sql)
|
|
#CONVERT_TZ
|
|
sql = "SELECT CONVERT_TZ('2004-01-01 12:00:00','+01:00','+10:00')"
|
|
check2(sql)
|
|
##now
|
|
wait_for_integer_min()
|
|
sql = "select date(now()), HOUR(now()), MINUTE(now()), DAY(now()),\
|
|
MONTH(now()), QUARTER(now()), YEAR(now())"
|
|
check2(sql)
|
|
|
|
|
|
def test_set_time_zone_insert_load_select():
|
|
"""
|
|
{
|
|
"title": "test_sys_time_zone.test_set_time_zone_insert_load_select",
|
|
"describe": "设置time_zone变量,验证对导入和查询时间相关函数的影响。测试点：导入数据里含now,curtime()和不受影响的函数utc_timestamp，验证查询结果",
|
|
"tag": "function,p1"
|
|
}
|
|
"""
|
|
"""
|
|
设置time_zone变量,验证对导入和查询时间相关函数的影响。
|
|
测试点：导入数据里含now,curtime()和不受影响的函数utc_timestamp，验证查询结果
|
|
"""
|
|
database_name, table_name, index_name = util.gen_name_list()
|
|
Palo_client.clean(database_name)
|
|
Palo_client.create_database(database_name)
|
|
Palo_client.use(database_name)
|
|
zone = "CST"
|
|
Palo_client.set_time_zone(zone)
|
|
res_var = Palo_client.show_variables("time_zone")
|
|
assert res_var[1][1] == zone, "res %s, excepted %s" % (res_var[1][1], zone)
|
|
sql = "drop table if exists %s" % table_name
|
|
LOG.info(L('palo&mysql sql', sql=sql))
|
|
res = Palo_client.execute(sql)
|
|
mysql_cursor.execute(sql)
|
|
sql = 'create table %s(k1 tinyint, k2 smallint NULL, k3 tinyint NULL, k4 tinyint NULL,\
|
|
k5 date NULL, k6 datetime NULL, k8 date NULL, k9 datetime NULL, \
|
|
k7 varchar(20) NULL, k10 double sum, k11 float sum) engine=olap \
|
|
distributed by hash(k1) buckets 5 properties("storage_type"="column")' % table_name
|
|
msql = 'create table %s(k1 tinyint, k2 smallint, k3 tinyint NULL, k4 tinyint NULL,\
|
|
k5 date, k6 datetime, k8 date, k9 datetime, k7 varchar(20),\
|
|
k10 double, k11 float)' % table_name
|
|
check2(sql, msql)
|
|
wait_for_integer_min()
|
|
insert_sql = "insert into %s values (1, HOUR(now()), MINUTE(now()),\
|
|
UNIX_TIMESTAMP('1970-01-01 08:00:00'), date(now()),\
|
|
'2019-09-09 09:00:00', date(now())," % table_name
|
|
insert_sql += "FROM_UNIXTIME(+123, '%Y-%m-%d %H:%i:%s'), '7', 10.10, 11.11)"
|
|
check2(insert_sql)
|
|
select_sql = "select * from %s" % table_name
|
|
check2(select_sql)
|
|
Palo_client.clean(database_name)
|
|
|
|
|
|
def teardown_module():
|
|
"""清理环境"""
|
|
sql = "set time_zone = '+08:00'"
|
|
check2(sql)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
print("test")
|
|
setup_module()
|
|
test_set_time_zone_select_time_function()
|
|
test_set_time_zone_insert_load_select()
|
|
|
|
|