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