mirror of
https://github.com/taosdata/TDengine
synced 2026-05-24 10:09:01 +00:00
c52c68aa4f
The following commits could not be applied individually due to context differences between the monorepo and the public repo's build files. They have been applied as a cumulative diff to ensure the final state matches the monorepo exactly: - chore: sync CI files with 3.0 branch to eliminate merge conflicts (rd-public/tsdb!271) - revert(refactor): dynamically link taosd taosudf taosmqtt against libtaosnative.so to reduce binary size (revert #183) (rd-public/tsdb!282) - fix(docs): autofix formatting issues across all doc files (rd-public/tsdb!296) - feat: support -DBUILD_SANITIZER=true on windows for debug build (rd-public/tsdb!291) - feat(build): build cache, mirror, and sccache optimizations (rd-public/tsdb!326) - docs: update image for three replica (rd-public/tsdb!324) - enh: shared storage on windows (rd-public/tsdb!333) - fix(cmake): convert ext_libs3 from git clone to URL tarball download (rd-public/tsdb!360) - feat: dual-source deps and comprehensive docs/packaging (cherry-pick to main) (rd-public/tsdb!352) - fix(cmake): guard DOWNLOAD_EXTRACT_TIMESTAMP for CMake < 3.24 and fix duplicate Cargo.lock entry (rd-public/tsdb!369) - fix: test case execution failure in pytest.sh (rd-public/tsdb!338) - enh: built-in compilation support for Python UDF plugins use abi3 (rd-public/tsdb!325)
976 lines
No EOL
40 KiB
C++
976 lines
No EOL
40 KiB
C++
/*
|
|
* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
|
|
*
|
|
* This program is free software: you can use, redistribute, and/or modify
|
|
* it under the terms of the GNU Affero General Public License, version 3
|
|
* or later ("AGPL"), as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <gtest/gtest.h>
|
|
#include <osSleep.h>
|
|
#include <time.h>
|
|
#include <iostream>
|
|
#include "clientSession.h"
|
|
#include "taoserror.h"
|
|
#include "tglobal.h"
|
|
#include "thash.h"
|
|
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wwrite-strings"
|
|
#pragma GCC diagnostic ignored "-Wunused-function"
|
|
#pragma GCC diagnostic ignored "-Wunused-variable"
|
|
#pragma GCC diagnostic ignored "-Wsign-compare"
|
|
|
|
#include "clientInt.h"
|
|
#include "executor.h"
|
|
#include "taos.h"
|
|
|
|
int main(int argc, char** argv) {
|
|
testing::InitGoogleTest(&argc, argv);
|
|
|
|
return RUN_ALL_TESTS();
|
|
}
|
|
|
|
TAOS* getConnWithGlobalOption(const char* tz) {
|
|
int code = taos_options(TSDB_OPTION_TIMEZONE, tz);
|
|
ASSERT(code == 0);
|
|
TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
|
|
ASSERT(pConn != nullptr);
|
|
return pConn;
|
|
}
|
|
|
|
TAOS* getConnWithOption(const char* tz) {
|
|
TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
|
|
ASSERT(pConn != nullptr);
|
|
if (tz != NULL) {
|
|
int code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_TIMEZONE, tz);
|
|
ASSERT(code == 0);
|
|
}
|
|
return pConn;
|
|
}
|
|
|
|
void execQuery(TAOS* pConn, const char* sql) {
|
|
TAOS_RES* pRes = taos_query(pConn, sql);
|
|
int code = taos_errno(pRes);
|
|
while (code == TSDB_CODE_MND_DB_IN_CREATING || code == TSDB_CODE_MND_DB_IN_DROPPING) {
|
|
taosMsleep(2000);
|
|
TAOS_RES* pRes = taos_query(pConn, sql);
|
|
code = taos_errno(pRes);
|
|
}
|
|
ASSERT(code == TSDB_CODE_SUCCESS);
|
|
taos_free_result(pRes);
|
|
}
|
|
|
|
void execQueryFail(TAOS* pConn, const char* sql) {
|
|
printf("execQueryFail: %s\n", sql);
|
|
TAOS_RES* pRes = taos_query(pConn, sql);
|
|
#ifndef WINDOWS
|
|
ASSERT(taos_errno(pRes) != TSDB_CODE_SUCCESS);
|
|
#endif
|
|
taos_free_result(pRes);
|
|
}
|
|
|
|
void checkRows(TAOS* pConn, const char* sql, int32_t expectedRows) {
|
|
printf("checkRows sql:%s,rows:%d\n", sql, expectedRows);
|
|
TAOS_RES* pRes = taos_query(pConn, sql);
|
|
ASSERT(taos_errno(pRes) == TSDB_CODE_SUCCESS);
|
|
TAOS_ROW pRow = NULL;
|
|
int rows = 0;
|
|
while ((pRow = taos_fetch_row(pRes)) != NULL) {
|
|
rows++;
|
|
}
|
|
ASSERT(rows == expectedRows);
|
|
taos_free_result(pRes);
|
|
}
|
|
|
|
void check_timezone(TAOS* pConn, const char* sql, const char* tz) {
|
|
TAOS_RES* pRes = taos_query(pConn, sql);
|
|
ASSERT(taos_errno(pRes) == 0);
|
|
TAOS_ROW row = NULL;
|
|
while ((row = taos_fetch_row(pRes)) != NULL) {
|
|
if (strcmp((const char*)row[0], "timezone") == 0) {
|
|
ASSERT(strstr((const char*)row[1], tz) != NULL);
|
|
}
|
|
}
|
|
taos_free_result(pRes);
|
|
}
|
|
|
|
void check_sql_result_partial(TAOS* pConn, const char* sql, const char* result) {
|
|
TAOS_RES* pRes = taos_query(pConn, sql);
|
|
ASSERT(taos_errno(pRes) == 0);
|
|
TAOS_ROW row = NULL;
|
|
while ((row = taos_fetch_row(pRes)) != NULL) {
|
|
ASSERT(strstr((const char*)row[0], result) != NULL);
|
|
}
|
|
taos_free_result(pRes);
|
|
}
|
|
|
|
int64_t get_sql_result(TAOS* pConn, const char* sql) {
|
|
int64_t ts = 0;
|
|
TAOS_RES* pRes = taos_query(pConn, sql);
|
|
ASSERT(taos_errno(pRes) == 0);
|
|
TAOS_ROW row = NULL;
|
|
while ((row = taos_fetch_row(pRes)) != NULL) {
|
|
ts = *(int64_t*)row[0];
|
|
}
|
|
taos_free_result(pRes);
|
|
return ts;
|
|
}
|
|
|
|
void check_sql_result(TAOS* pConn, const char* sql, const char* result) {
|
|
printf("check_sql_result sql:%s,result:%s\n", sql, result);
|
|
TAOS_RES* pRes = taos_query(pConn, sql);
|
|
ASSERT(taos_errno(pRes) == 0);
|
|
TAOS_ROW row = NULL;
|
|
while ((row = taos_fetch_row(pRes)) != NULL) {
|
|
#ifndef WINDOWS
|
|
ASSERT(memcmp((const char*)row[0], result, strlen(result)) == 0);
|
|
#endif
|
|
}
|
|
taos_free_result(pRes);
|
|
}
|
|
|
|
void check_sql_result_integer(TAOS* pConn, const char* sql, int64_t result) {
|
|
printf("check_sql_result_integer sql:%s,result:%ld\n", sql, result);
|
|
TAOS_RES* pRes = taos_query(pConn, sql);
|
|
ASSERT(taos_errno(pRes) == 0);
|
|
TAOS_ROW row = NULL;
|
|
while ((row = taos_fetch_row(pRes)) != NULL) {
|
|
#ifndef WINDOWS
|
|
ASSERT(*(int64_t*)row[0] == result);
|
|
#endif
|
|
}
|
|
taos_free_result(pRes);
|
|
}
|
|
|
|
void check_set_timezone(TAOS* optionFunc(const char* tz)) {
|
|
{
|
|
TAOS* pConn = optionFunc("UTC-8"); // Asia/Shanghai timezone
|
|
check_timezone(pConn, "show local variables", "UTC-8");
|
|
|
|
execQuery(pConn, "drop database if exists db1");
|
|
execQuery(pConn, "create database db1");
|
|
execQuery(pConn, "create table db1.t1 (ts timestamp, v int)");
|
|
|
|
execQuery(pConn, "insert into db1.t1 values('2023-09-16 17:00:00', 1)");
|
|
checkRows(pConn, "select * from db1.t1 where ts == '2023-09-16 17:00:00'", 1);
|
|
|
|
taos_close(pConn);
|
|
}
|
|
|
|
{
|
|
TAOS* pConn = optionFunc("UTC+8");
|
|
check_timezone(pConn, "show local variables", "UTC+8");
|
|
checkRows(pConn, "select * from db1.t1 where ts == '2023-09-16 01:00:00'", 1);
|
|
execQuery(pConn, "insert into db1.t1 values('2023-09-16 17:00:01', 1)");
|
|
|
|
taos_close(pConn);
|
|
}
|
|
|
|
{
|
|
TAOS* pConn = optionFunc("UTC+0");
|
|
check_timezone(pConn, "show local variables", "UTC+0");
|
|
checkRows(pConn, "select * from db1.t1 where ts == '2023-09-16 09:00:00'", 1);
|
|
checkRows(pConn, "select * from db1.t1 where ts == '2023-09-17 01:00:01'", 1);
|
|
|
|
taos_close(pConn);
|
|
}
|
|
}
|
|
|
|
#define CHECK_TAOS_OPTION_POINTER(taos, option, isnull) \
|
|
{ \
|
|
STscObj* pObj = acquireTscObj(*(int64_t*)taos); \
|
|
ASSERT(pObj != nullptr); \
|
|
if (isnull) { \
|
|
ASSERT(pObj->optionInfo.option == nullptr); \
|
|
} else { \
|
|
ASSERT(pObj->optionInfo.option != nullptr); \
|
|
} \
|
|
}
|
|
|
|
#define CHECK_TAOS_OPTION_APP(taos, option, val) \
|
|
{ \
|
|
STscObj* pObj = acquireTscObj(*(int64_t*)taos); \
|
|
ASSERT(pObj != nullptr); \
|
|
ASSERT(strcmp(pObj->optionInfo.option, val) == 0); \
|
|
}
|
|
|
|
#define CHECK_TAOS_OPTION_IP_ERROR(taos, option, val) \
|
|
{ \
|
|
STscObj* pObj = acquireTscObj(*(int64_t*)taos); \
|
|
ASSERT(pObj != nullptr); \
|
|
ASSERT(pObj->optionInfo.option == val); \
|
|
}
|
|
|
|
#define CHECK_TAOS_OPTION_IP(taos, option, val) \
|
|
{ \
|
|
STscObj* pObj = acquireTscObj(*(int64_t*)taos); \
|
|
ASSERT(pObj != nullptr); \
|
|
char ip[TD_IP_LEN] = {0}; \
|
|
taosInetNtoa(ip, pObj->optionInfo.option); \
|
|
ASSERT(strcmp(ip, val) == 0); \
|
|
}
|
|
|
|
static int32_t checkUserIp(TAOS* taos, const char* ip) {
|
|
TAOS_RES* pRes = taos_query(taos, "select user_ip from performance_schema.perf_connections");
|
|
|
|
ASSERT(taos_errno(pRes) == 0);
|
|
|
|
TAOS_ROW row = NULL;
|
|
bool found = false;
|
|
while ((row = taos_fetch_row(pRes)) != NULL) {
|
|
if (strcmp((const char*)row[0], ip) == 0) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (found == false) {
|
|
ASSERT(0);
|
|
}
|
|
|
|
taos_free_result(pRes);
|
|
|
|
ASSERT(1);
|
|
return 0;
|
|
}
|
|
|
|
TEST(connectionCase, setConnectionOption_Test) {
|
|
int32_t code = taos_options_connection(NULL, TSDB_OPTION_CONNECTION_CHARSET, NULL);
|
|
ASSERT(code != 0);
|
|
TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
|
|
ASSERT_NE(pConn, nullptr);
|
|
|
|
code = taos_options_connection(pConn, TSDB_MAX_OPTIONS_CONNECTION, NULL);
|
|
ASSERT(code != 0);
|
|
|
|
// test charset
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_CHARSET, "");
|
|
ASSERT(code != 0);
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_CHARSET, NULL);
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_POINTER(pConn, charsetCxt, true);
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_CHARSET, "Asia/Shanghai");
|
|
ASSERT(code != 0);
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_CHARSET, "gbk");
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_POINTER(pConn, charsetCxt, false);
|
|
|
|
#ifndef WINDOWS
|
|
// test timezone
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_TIMEZONE, "");
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_POINTER(pConn, timezone, false);
|
|
check_sql_result(pConn, "select timezone()", "UTC (UTC, +0000)");
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_TIMEZONE, NULL);
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_POINTER(pConn, timezone, true);
|
|
check_sql_result(pConn, "select timezone()", "Asia/Shanghai (CST, +0800)");
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_TIMEZONE, "UTC");
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_POINTER(pConn, timezone, false);
|
|
check_sql_result(pConn, "select timezone()", "UTC (UTC, +0000)");
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_TIMEZONE, "Asia/Kolkata");
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_POINTER(pConn, timezone, false);
|
|
check_sql_result(pConn, "select timezone()", "Asia/Kolkata (IST, +0530)");
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_TIMEZONE, "adbc");
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_POINTER(pConn, timezone, false);
|
|
check_sql_result(pConn, "select timezone()", "adbc (UTC, +0000)");
|
|
#endif
|
|
|
|
// test user APP
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_USER_APP, "");
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_APP(pConn, userApp, "");
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_USER_APP, NULL);
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_APP(pConn, userApp, "");
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_USER_APP, "aaaaaaaaaaaaaaaaaaaaaabbbbbbb");
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_APP(pConn, userApp, "aaaaaaaaaaaaaaaaaaaaaab");
|
|
|
|
// test connector info
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_CONNECTOR_INFO, "");
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_APP(pConn, cInfo, "");
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_CONNECTOR_INFO, NULL);
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_APP(pConn, cInfo, "");
|
|
|
|
const char* str255 =
|
|
"TDengine_ConnectOptionsTest_255_Character_String_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz_"
|
|
"This_is_a_test_string_for_connection_options_testing_in_TDengine_database_system_with_exactly_255_characters_"
|
|
"including_alphanumeric_and_special";
|
|
const char* str258 =
|
|
"TDengine_ConnectOptionsTest_255_Character_String_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz_"
|
|
"This_is_a_test_string_for_connection_options_testing_in_TDengine_database_system_with_exactly_255_characters_"
|
|
"including_alphanumeric_and_specialaaa";
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_CONNECTOR_INFO, str258);
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_APP(pConn, cInfo, str255);
|
|
|
|
// test user IP
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_USER_IP, "");
|
|
// ASSERT(code != 0); // add dual later
|
|
CHECK_TAOS_OPTION_IP_ERROR(pConn, userIp, INADDR_NONE);
|
|
|
|
checkUserIp(pConn, "");
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_USER_IP, NULL);
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_IP_ERROR(pConn, userIp, INADDR_NONE);
|
|
|
|
checkUserIp(pConn, "");
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_USER_IP, "aaaaaaaaaaaaaaaaaaaaaabbbbbbb");
|
|
// ASSERT(code != 0); // add dual later
|
|
CHECK_TAOS_OPTION_IP_ERROR(pConn, userIp, INADDR_NONE);
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_USER_IP, "1292.168.0.2");
|
|
// ASSERT(code != 0); // add dual alter
|
|
CHECK_TAOS_OPTION_IP_ERROR(pConn, userIp, INADDR_NONE);
|
|
taosSsleep(6);
|
|
checkUserIp(pConn, "");
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_USER_IP, "192.168.0.2");
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_IP(pConn, userIp, "192.168.0.2");
|
|
|
|
taosSsleep(6);
|
|
|
|
checkUserIp(pConn, "192.168.0.2");
|
|
taosMsleep(2 * HEARTBEAT_INTERVAL);
|
|
|
|
// test user APP and user IP
|
|
check_sql_result_integer(
|
|
pConn, "select count(*) from performance_schema.perf_connections where user_app = 'aaaaaaaaaaaaaaaaaaaaaab'", 1);
|
|
check_sql_result_integer(pConn,
|
|
"select count(*) from performance_schema.perf_connections where user_ip = '192.168.0.2'", 1);
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_USER_IP, "192.168.1.2");
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_IP(pConn, userIp, "192.168.1.2");
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_USER_IP, NULL);
|
|
CHECK_TAOS_OPTION_IP_ERROR(pConn, userIp, INADDR_NONE);
|
|
taosSsleep(6);
|
|
checkUserIp(pConn, "");
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_USER_IP, "192.168.1.2");
|
|
CHECK_TAOS_OPTION_IP(pConn, userIp, "192.168.1.2");
|
|
taosSsleep(6);
|
|
checkUserIp(pConn, "192.168.1.2");
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_USER_APP, "user");
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_APP(pConn, userApp, "user");
|
|
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_CONNECTOR_INFO, "java-connector:3.23.3");
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_APP(pConn, cInfo, "java-connector:3.23.3");
|
|
|
|
taosMsleep(2 * HEARTBEAT_INTERVAL);
|
|
|
|
check_sql_result_integer(pConn, "select count(*) from performance_schema.perf_connections where user_app = 'user'",
|
|
1);
|
|
check_sql_result_integer(
|
|
pConn, "select count(*) from performance_schema.perf_connections where connector_info = 'java-connector:3.23.3'",
|
|
1);
|
|
check_sql_result_integer(pConn,
|
|
"select count(*) from performance_schema.perf_connections where user_ip = '192.168.1.2'", 1);
|
|
|
|
// test clear
|
|
code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_CLEAR, "192.168.0.2");
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_POINTER(pConn, charsetCxt, true);
|
|
|
|
#ifndef WINDOWS
|
|
CHECK_TAOS_OPTION_POINTER(pConn, timezone, true);
|
|
check_sql_result(pConn, "select timezone()", "Asia/Shanghai (CST, +0800)");
|
|
#endif
|
|
|
|
CHECK_TAOS_OPTION_APP(pConn, userApp, "");
|
|
CHECK_TAOS_OPTION_IP_ERROR(pConn, userIp, INADDR_NONE);
|
|
|
|
taos_close(pConn);
|
|
}
|
|
|
|
TEST(charsetCase, charset_Test) {
|
|
// 1. build connection with different charset
|
|
TAOS* pConnGbk = taos_connect("localhost", "root", "taosdata", NULL, 0);
|
|
ASSERT(pConnGbk != nullptr);
|
|
|
|
TAOS* pConnUTF8 = taos_connect("localhost", "root", "taosdata", NULL, 0);
|
|
ASSERT(pConnUTF8 != nullptr);
|
|
|
|
TAOS* pConnDefault = taos_connect("localhost", "root", "taosdata", NULL, 0);
|
|
ASSERT(pConnDefault != nullptr);
|
|
|
|
int32_t code = taos_options_connection(pConnGbk, TSDB_OPTION_CONNECTION_CHARSET, "gbk");
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_POINTER(pConnGbk, charsetCxt, false);
|
|
|
|
code = taos_options_connection(pConnUTF8, TSDB_OPTION_CONNECTION_CHARSET, "UTF-8");
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_POINTER(pConnUTF8, charsetCxt, false);
|
|
|
|
// 2. build test string
|
|
char sqlTag[256] = {0};
|
|
char sqlCol[256] = {0};
|
|
|
|
// 芬 gbk encode is 0xB7D2, UTF-8 encode is 0xE88AAC
|
|
// 中国 gbk encode is 0xD6D0B9FA, UTF-8 encode is 0xE4B8ADE59BBD
|
|
char fenUtf8[32] = {0};
|
|
char fenGbk[32] = {0};
|
|
char zhongGbk[32] = {0};
|
|
char zhongguoUtf8[32] = {0};
|
|
char guoUtf8[32] = {0};
|
|
char zhongguoGbk[32] = {0};
|
|
snprintf(fenUtf8, sizeof(fenUtf8), "%c%c%c", 0xE8, 0x8A, 0xAC);
|
|
snprintf(fenGbk, sizeof(fenGbk), "%c%c", 0xB7, 0xD2);
|
|
snprintf(zhongguoUtf8, sizeof(zhongguoUtf8), "%c%c%c%c%c%c", 0xE4, 0xB8, 0xAD, 0xE5, 0x9B, 0xBD);
|
|
snprintf(guoUtf8, sizeof(guoUtf8), "%c%c%c", 0xE5, 0x9B, 0xBD);
|
|
snprintf(zhongguoGbk, sizeof(zhongguoGbk), "%c%c%c%c", 0xD6, 0xD0, 0xB9, 0xFA);
|
|
snprintf(zhongGbk, sizeof(zhongGbk), "%c%c", 0xD6, 0xD0);
|
|
|
|
// 3. create stable
|
|
execQuery(pConnGbk, "drop database if exists db1");
|
|
execQuery(pConnGbk, "create database db1");
|
|
execQuery(pConnGbk,
|
|
"create table db1.stb (ts timestamp, c1 nchar(32), c2 int) tags(t1 timestamp, t2 nchar(32), t3 int)");
|
|
|
|
// 4. test tag with different charset
|
|
snprintf(sqlTag, sizeof(sqlTag), "create table db1.ctb1 using db1.stb tags('2023-09-16 17:00:00+05:00', '%s', 1)",
|
|
fenUtf8);
|
|
execQueryFail(pConnGbk, sqlTag);
|
|
|
|
snprintf(sqlTag, sizeof(sqlTag), "create table db1.ctb1 using db1.stb tags('2023-09-16 17:00:00+05:00', '%s', 1)",
|
|
fenGbk);
|
|
execQuery(pConnGbk, sqlTag);
|
|
|
|
// 5. test column with different charset
|
|
snprintf(sqlCol, sizeof(sqlCol), "insert into db1.ctb1 values(1732178775133, '%s', 1)", zhongguoUtf8);
|
|
execQueryFail(pConnGbk, sqlCol);
|
|
|
|
snprintf(sqlCol, sizeof(sqlCol), "insert into db1.ctb1 values(1732178775133, '%s', 1)", zhongguoGbk);
|
|
execQuery(pConnGbk, sqlCol);
|
|
|
|
// 6. check result with different charset
|
|
check_sql_result(pConnGbk, "select t2 from db1.ctb1", fenGbk);
|
|
check_sql_result(pConnUTF8, "select t2 from db1.ctb1", fenUtf8);
|
|
|
|
check_sql_result(pConnGbk, "select c1 from db1.ctb1", zhongguoGbk);
|
|
check_sql_result(pConnUTF8, "select c1 from db1.ctb1", zhongguoUtf8);
|
|
|
|
// 7. test function with different charset
|
|
// 7.1 concat
|
|
char zhongguofenGbk[32] = {0};
|
|
snprintf(zhongguofenGbk, sizeof(zhongguofenGbk), "%s%s", zhongguoGbk, fenGbk);
|
|
char sql[256] = {0};
|
|
snprintf(sql, sizeof(sql), "select concat(c1, '%s') from db1.ctb1", fenGbk);
|
|
execQueryFail(pConnGbk, sql);
|
|
snprintf(sql, sizeof(sql), "select concat(c1, '%s') from db1.ctb1", fenUtf8);
|
|
check_sql_result(pConnGbk, sql, zhongguofenGbk);
|
|
|
|
// 7.2 trim
|
|
snprintf(sql, sizeof(sql), "select trim(LEADING c1 from '%s') from db1.ctb1", zhongguofenGbk);
|
|
check_sql_result(pConnGbk, sql, zhongguofenGbk);
|
|
char zhongguofenUtf8[32] = {0};
|
|
snprintf(zhongguofenUtf8, sizeof(zhongguofenUtf8), "%s%s", zhongguoUtf8, fenUtf8);
|
|
snprintf(sql, sizeof(sql), "select trim(LEADING c1 from '%s') from db1.ctb1", zhongguofenUtf8);
|
|
check_sql_result(pConnGbk, sql, fenUtf8);
|
|
|
|
check_sql_result(pConnGbk, "select char(c1) from db1.ctb1", "");
|
|
|
|
check_sql_result_integer(pConnGbk, "select ascii(c1) from db1.ctb1", 0xE4);
|
|
check_sql_result_integer(pConnUTF8, "select ascii(c1) from db1.ctb1", 0xE4);
|
|
check_sql_result_integer(pConnGbk, "select LENGTH(c1) from db1.ctb1", 8);
|
|
check_sql_result_integer(pConnUTF8, "select LENGTH(c1) from db1.ctb1", 8);
|
|
check_sql_result_integer(pConnGbk, "select CHAR_LENGTH(c1) from db1.ctb1", 2);
|
|
check_sql_result_integer(pConnUTF8, "select CHAR_LENGTH(c1) from db1.ctb1", 2);
|
|
|
|
execQuery(pConnGbk, "select LOWER(c1) from db1.ctb1");
|
|
execQuery(pConnGbk, "select UPPER(c1) from db1.ctb1");
|
|
|
|
snprintf(sql, sizeof(sql), "select position(c1 in '%s') from db1.ctb1", zhongguofenGbk);
|
|
check_sql_result_integer(pConnGbk, sql, 0);
|
|
|
|
snprintf(sql, sizeof(sql), "select position('%s' in c1) from db1.ctb1", guoUtf8);
|
|
check_sql_result_integer(pConnUTF8, sql, 2);
|
|
|
|
snprintf(sql, sizeof(sql), "select replace(c1, '%s', 'a') from db1.ctb1", zhongguoGbk);
|
|
execQueryFail(pConnGbk, sql);
|
|
|
|
snprintf(sql, sizeof(sql), "select replace(c1, '%s', 'a') from db1.ctb1", zhongguoUtf8);
|
|
check_sql_result(pConnUTF8, sql, "a");
|
|
|
|
snprintf(sql, sizeof(sql), "%s%s", zhongguoGbk, zhongguoGbk);
|
|
check_sql_result(pConnGbk, "select repeat(c1, 2) from db1.ctb1", sql);
|
|
|
|
check_sql_result(pConnGbk, "select cast(c1 as binary(32)) from db1.ctb1", zhongguoUtf8);
|
|
|
|
check_sql_result(pConnUTF8, "select substr(c1,2,1) from db1.ctb1", guoUtf8);
|
|
|
|
snprintf(sql, sizeof(sql), "select SUBSTRING_INDEX(c1,'%s',1) from db1.ctb1", guoUtf8);
|
|
check_sql_result(pConnGbk, sql, zhongGbk);
|
|
|
|
// 8. test default charset
|
|
snprintf(sqlCol, sizeof(sqlCol), "insert into db1.ctb1 values(1732178775134, '%s', 1)", zhongguoUtf8);
|
|
execQuery(pConnDefault, sqlCol);
|
|
check_sql_result(pConnDefault, "select c1 from db1.ctb1 where ts = 1732178775134", zhongguoUtf8);
|
|
|
|
// 9. test json tag with different charset
|
|
execQuery(pConnUTF8, "create table db1.jsta (ts timestamp, c1 nchar(32), c2 int) tags(t1 json)");
|
|
snprintf(sqlCol, sizeof(sqlCol), "create table db1.jsta1 using db1.jsta tags('{\"k\":\"%s\"}')", fenUtf8);
|
|
execQuery(pConnUTF8, sqlCol);
|
|
snprintf(sqlCol, sizeof(sqlCol), "insert into db1.jsta1 values(1732178775133, '%s', 1)", zhongguoUtf8);
|
|
execQuery(pConnUTF8, sqlCol);
|
|
|
|
char resJsonTag[32] = {0};
|
|
snprintf(resJsonTag, sizeof(resJsonTag), "{\"k\":\"%s\"}", fenGbk);
|
|
check_sql_result(pConnGbk, "select t1 from db1.jsta1", resJsonTag);
|
|
|
|
// 10. reset charset to default(utf-8
|
|
code = taos_options_connection(pConnGbk, TSDB_OPTION_CONNECTION_CHARSET, NULL);
|
|
ASSERT(code == 0);
|
|
CHECK_TAOS_OPTION_POINTER(pConnGbk, charsetCxt, true);
|
|
check_sql_result(pConnGbk, "select t2 from db1.ctb1 where ts = 1732178775134", fenUtf8);
|
|
check_sql_result(pConnGbk, "select c1 from db1.ctb1 where ts = 1732178775134", zhongguoUtf8);
|
|
|
|
taos_close(pConnGbk);
|
|
taos_close(pConnUTF8);
|
|
taos_close(pConnDefault);
|
|
}
|
|
|
|
TEST(charsetCase, alter_charset_Test) {
|
|
TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
|
|
ASSERT(pConn != nullptr);
|
|
|
|
execQueryFail(pConn, "alter dnode 1 'charset gbk'");
|
|
execQueryFail(pConn, "local 'charset gbk'");
|
|
|
|
taos_close(pConn);
|
|
}
|
|
|
|
#ifndef WINDOWS
|
|
TEST(timezoneCase, set_timezone_Test) {
|
|
check_set_timezone(getConnWithGlobalOption);
|
|
check_set_timezone(getConnWithOption);
|
|
}
|
|
|
|
TEST(timezoneCase, alter_timezone_Test) {
|
|
TAOS* pConn = getConnWithGlobalOption("UTC-8");
|
|
check_timezone(pConn, "show local variables", "UTC-8");
|
|
|
|
execQuery(pConn, "alter local 'timezone Asia/Kolkata'");
|
|
check_timezone(pConn, "show local variables", "Asia/Kolkata");
|
|
|
|
execQuery(pConn, "alter local 'timezone Asia/Shanghai'");
|
|
check_timezone(pConn, "show local variables", "Asia/Shanghai");
|
|
|
|
execQueryFail(pConn, "alter dnode 1 'timezone Asia/Kolkata'");
|
|
|
|
taos_close(pConn);
|
|
}
|
|
|
|
char* tz_test[] = {
|
|
"2023-09-16 17:00:00+", "2023-09-16 17:00:00+a", "2023-09-16 17:00:00+8", "2023-09-16 17:00:00+832",
|
|
"2023-09-16 17:00:00+8323", "2023-09-16 17:00:00+:", "2023-09-16 17:00:00+8:", "2023-09-16 17:00:00++:",
|
|
"2023-09-16 17:00:00+d:", "2023-09-16 17:00:00+09:", "2023-09-16 17:00:00+8f:", "2023-09-16 17:00:00+080:",
|
|
"2023-09-16 17:00:00+:30", "2023-09-16 17:00:00+:3", "2023-09-16 17:00:00+:093", "2023-09-16 17:00:00+:-30",
|
|
"2023-09-16 17:00:00++:-30", "2023-09-16 17:00:00+8:8", "2023-09-16 17:00:00+8:2a", "2023-09-16 17:00:00+8:08",
|
|
"2023-09-16 17:00:00+8:038", "2023-09-16 17:00:00+08:8", "2023-09-16 17:00:00+09:3a", "2023-09-16 17:00:00+09:abc",
|
|
"2023-09-16 17:00:00+09:001",
|
|
};
|
|
|
|
void do_insert_failed() {
|
|
TAOS* pConn = getConnWithGlobalOption("UTC-8");
|
|
|
|
for (unsigned int i = 0; i < sizeof(tz_test) / sizeof(tz_test[0]); ++i) {
|
|
char sql[1024] = {0};
|
|
(void)snprintf(sql, sizeof(sql), "insert into db1.ctb1 values('%s', '%s', 1)", tz_test[i], tz_test[i]);
|
|
|
|
execQueryFail(pConn, sql);
|
|
}
|
|
taos_close(pConn);
|
|
}
|
|
|
|
struct insert_params {
|
|
const char* tz;
|
|
const char* tbname;
|
|
const char* t1;
|
|
const char* t2;
|
|
};
|
|
|
|
struct insert_params params1[] = {
|
|
{"UTC", "ntb", "2023-09-16 17:00:00", "2023-09-16 17:00:00+08:00"},
|
|
{"UTC", "ctb1", "2023-09-16 17:00:00", "2023-09-16 17:00:00+08:00"},
|
|
};
|
|
|
|
struct insert_params params2[] = {
|
|
{"UTC+9", "ntb", "2023-09-16 08:00:00", "2023-09-16 08:00:00-01:00"},
|
|
{"UTC+9", "ctb1", "2023-09-16 08:00:00", "2023-09-16 11:00:00+02:00"},
|
|
};
|
|
|
|
void do_insert(struct insert_params params) {
|
|
TAOS* pConn = getConnWithOption(params.tz);
|
|
char sql[1024] = {0};
|
|
(void)snprintf(sql, sizeof(sql), "insert into db1.%s values('%s', '%s', 1)", params.tbname, params.t1, params.t2);
|
|
execQuery(pConn, sql);
|
|
taos_close(pConn);
|
|
}
|
|
|
|
void do_select(struct insert_params params) {
|
|
TAOS* pConn = getConnWithOption(params.tz);
|
|
char sql[1024] = {0};
|
|
(void)snprintf(sql, sizeof(sql), "select * from db1.%s where ts == '%s' and c1 == '%s'", params.tbname, params.t1,
|
|
params.t2);
|
|
checkRows(pConn, sql, 1);
|
|
taos_close(pConn);
|
|
}
|
|
|
|
// test insert string and integer to timestamp both normal table and child table(and tag)
|
|
TEST(timezoneCase, insert_with_timezone_Test) {
|
|
/*
|
|
* 1. prepare data, create db and tables
|
|
*/
|
|
TAOS* pConn1 = getConnWithOption("UTC+2");
|
|
execQuery(pConn1, "drop database if exists db1");
|
|
execQuery(pConn1, "create database db1");
|
|
execQuery(pConn1, "create table db1.ntb (ts timestamp, c1 timestamp, c2 int)");
|
|
execQuery(pConn1,
|
|
"create table db1.stb (ts timestamp, c1 timestamp, c2 int) tags(t1 timestamp, t2 timestamp, t3 int)");
|
|
execQuery(pConn1,
|
|
"create table db1.ctb1 using db1.stb tags(\"2023-09-16 17:00:00+05:00\", \"2023-09-16 17:00:00\", 1)");
|
|
execQuery(pConn1, "create table db1.ctb2 using db1.stb tags(1732178775000, 1732178775000, 1)");
|
|
execQuery(pConn1, "insert into db1.ntb values(1732178775133, 1732178775133, 1)");
|
|
execQuery(pConn1, "insert into db1.ctb1 values(1732178775133, 1732178775133, 1)"); // 2024-11-21 10:46:15.133+02:00
|
|
execQuery(pConn1, "insert into db1.ctb2 values(1732178775133, 1732178775133, 1)");
|
|
|
|
/*
|
|
* 2. test tag and timestamp with integer format
|
|
*/
|
|
TAOS* pConn2 = getConnWithOption("UTC-2");
|
|
checkRows(pConn2, "select * from db1.stb where t1 == '2023-09-16 17:00:00+05:00' and t2 == '2023-09-16 21:00:00'", 1);
|
|
checkRows(pConn2,
|
|
"select * from db1.stb where t1 == '2024-11-21 16:46:15+08:00' and t2 == '2024-11-21 09:46:15+01:00'", 1);
|
|
checkRows(pConn2,
|
|
"select * from db1.ntb where ts == '2024-11-21 09:46:15.133+01:00' and c1 == '2024-11-21 10:46:15.133'", 1);
|
|
checkRows(pConn2,
|
|
"select * from db1.ctb1 where ts == '2024-11-21 09:46:15.133+01:00' and c1 == '2024-11-21 10:46:15.133'",
|
|
1);
|
|
|
|
check_sql_result(pConn2, "select TO_ISO8601(ts) from db1.ctb1",
|
|
"2024-11-21T10:46:15.133+0200"); // 2024-01-01 23:00:00+0200
|
|
|
|
/*
|
|
* 3. test timestamp with string format
|
|
*/
|
|
for (unsigned int i = 0; i < sizeof(params1) / sizeof(params1[0]); ++i) {
|
|
do_insert(params1[i]);
|
|
do_select(params1[i]);
|
|
do_select(params2[i]);
|
|
}
|
|
|
|
do_insert_failed();
|
|
/*
|
|
* 4. test NULL timezone, use default timezone UTC-8
|
|
*/
|
|
TAOS* pConn3 = getConnWithOption(NULL);
|
|
checkRows(pConn3, "select * from db1.stb where t1 == '2023-09-16 20:00:00' and t2 == '2023-09-17 03:00:00'", 2);
|
|
checkRows(pConn3, "select * from db1.stb where t1 == 1732178775000 and t2 == 1732178775000", 1);
|
|
checkRows(pConn3, "select * from db1.ntb where ts == '2024-11-21 16:46:15.133' and c1 == '2024-11-21 16:46:15.133'",
|
|
1);
|
|
checkRows(pConn3, "select * from db1.ctb1 where ts == '2023-09-17 01:00:00' and c1 == '2023-09-16 17:00:00'", 1);
|
|
|
|
/*
|
|
* 5. test multi connection with different timezone
|
|
*/
|
|
checkRows(pConn2,
|
|
"select * from db1.ctb1 where ts == '2024-11-21 09:46:15.133+01:00' and c1 == '2024-11-21 10:46:15.133'",
|
|
1);
|
|
checkRows(pConn1,
|
|
"select * from db1.ctb1 where ts == '2024-11-21 09:46:15.133+01:00' and c1 == '2024-11-21 06:46:15.133'",
|
|
1);
|
|
|
|
taos_close(pConn1);
|
|
taos_close(pConn2);
|
|
taos_close(pConn3);
|
|
}
|
|
|
|
TEST(timezoneCase, func_timezone_Test) {
|
|
TAOS* pConn = getConnWithGlobalOption("UTC+8");
|
|
check_sql_result(pConn, "select timezone()", "UTC+8 (UTC, -0800)");
|
|
taos_close(pConn);
|
|
|
|
pConn = getConnWithOption("UTC-2");
|
|
|
|
execQuery(pConn, "drop database if exists db1");
|
|
execQuery(pConn, "create database db1");
|
|
execQuery(pConn, "create table db1.ntb (ts timestamp, c1 binary(32), c2 int)");
|
|
execQuery(pConn, "insert into db1.ntb values(1704142800000, '2024-01-01 23:00:00', 1)"); // 2024-01-01 23:00:00+0200
|
|
|
|
// test timezone
|
|
check_sql_result(pConn, "select timezone()", "UTC-2 (UTC, +0200)");
|
|
|
|
// test timetruncate
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE('2024-01-01 23:00:00', 1d, 0))",
|
|
"2024-01-01T02:00:00.000+0200");
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE('2024-01-01 01:00:00', 1d, 0))",
|
|
"2023-12-31T02:00:00.000+0200");
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE('2024-01-01 01:00:00+0300', 1d, 0))",
|
|
"2023-12-31T02:00:00.000+0200");
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE('2024-01-01 01:00:00-0300', 1d, 0))",
|
|
"2024-01-01T02:00:00.000+0200");
|
|
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE('2024-01-04 23:00:00', 1w, 0))",
|
|
"2024-01-04T02:00:00.000+0200");
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE('2024-01-04 01:00:00', 1w, 0))",
|
|
"2023-12-28T02:00:00.000+0200");
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE('2024-01-04 01:00:00+0300', 1w, 0))",
|
|
"2023-12-28T02:00:00.000+0200");
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE('2024-01-04 01:00:00-0300', 1w, 0))",
|
|
"2024-01-04T02:00:00.000+0200");
|
|
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE('2024-01-01 23:00:00', 1d, 1))",
|
|
"2024-01-01T00:00:00.000+0200");
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE('2024-01-01 01:00:00', 1d, 1))",
|
|
"2024-01-01T00:00:00.000+0200");
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE('2024-01-01 01:00:00+0500', 1d, 1))",
|
|
"2023-12-31T00:00:00.000+0200");
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE('2024-01-01 01:00:00-0300', 1d, 1))",
|
|
"2024-01-01T00:00:00.000+0200");
|
|
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE('2024-01-04 23:00:00', 1w, 1))",
|
|
"2024-01-04T00:00:00.000+0200");
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE('2024-01-04 01:00:00', 1w, 1))",
|
|
"2024-01-04T00:00:00.000+0200");
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE('2024-01-04 01:00:00+0500', 1w, 1))",
|
|
"2023-12-28T00:00:00.000+0200");
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE('2024-01-04 01:00:00-0300', 1w, 1))",
|
|
"2024-01-04T00:00:00.000+0200");
|
|
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE(1704142800000, 1d, 0))",
|
|
"2024-01-01T02:00:00.000+0200"); // 2024-01-01 23:00:00+0200
|
|
check_sql_result(pConn, "select TO_ISO8601(TIMETRUNCATE(ts, 1w, 1)) from db1.ntb",
|
|
"2023-12-28T00:00:00.000+0200"); // 2024-01-01 23:00:00+0200
|
|
|
|
// TODAY
|
|
check_sql_result_partial(pConn, "select TO_ISO8601(today())", "T00:00:00.000+0200");
|
|
|
|
// NOW
|
|
check_sql_result_partial(pConn, "select TO_ISO8601(now())", "+0200");
|
|
|
|
// WEEKDAY
|
|
check_sql_result_integer(pConn, "select WEEKDAY('2024-01-01')", 0);
|
|
check_sql_result_integer(pConn, "select WEEKDAY('2024-01-01 03:00:00')", 0);
|
|
check_sql_result_integer(pConn, "select WEEKDAY('2024-01-01 23:00:00+0200')", 0);
|
|
check_sql_result_integer(pConn, "select WEEKDAY('2024-01-01 23:00:00-1100')", 1);
|
|
check_sql_result_integer(pConn, "select WEEKDAY(1704142800000)", 0);
|
|
check_sql_result_integer(pConn, "select WEEKDAY(ts) from db1.ntb", 1);
|
|
|
|
// DAYOFWEEK
|
|
check_sql_result_integer(pConn, "select DAYOFWEEK('2024-01-01')", 2);
|
|
check_sql_result_integer(pConn, "select DAYOFWEEK('2024-01-01 03:00:00')", 2);
|
|
check_sql_result_integer(pConn, "select DAYOFWEEK('2024-01-01 23:00:00+0200')", 2);
|
|
check_sql_result_integer(pConn, "select DAYOFWEEK('2024-01-01 23:00:00-1100')", 3);
|
|
check_sql_result_integer(pConn, "select DAYOFWEEK(1704142800000)", 2);
|
|
check_sql_result_integer(pConn, "select DAYOFWEEK(ts) from db1.ntb", 3);
|
|
|
|
// WEEK
|
|
check_sql_result_integer(pConn, "select WEEK('2024-01-07')", 1);
|
|
check_sql_result_integer(pConn, "select WEEK('2024-01-07 02:00:00')", 1);
|
|
check_sql_result_integer(pConn, "select WEEK('2024-01-07 02:00:00+0200')", 1);
|
|
check_sql_result_integer(pConn, "select WEEK('2024-01-07 02:00:00+1100')", 0);
|
|
check_sql_result_integer(pConn, "select WEEK(1704142800000)", 0); // 2024-01-01 23:00:00+0200
|
|
check_sql_result_integer(pConn, "select WEEK(ts) from db1.ntb", 0); // 2024-01-01 23:00:00+0200
|
|
|
|
check_sql_result_integer(pConn, "select WEEK('2024-01-07', 3)", 1);
|
|
check_sql_result_integer(pConn, "select WEEK('2024-01-07 02:00:00', 3)", 1);
|
|
check_sql_result_integer(pConn, "select WEEK('2024-01-07 02:00:00+0200', 3)", 1);
|
|
check_sql_result_integer(pConn, "select WEEK('2024-01-01 02:00:00+1100', 3)", 52);
|
|
check_sql_result_integer(pConn, "select WEEK(1704142800000, 3)", 1); // 2024-01-01 23:00:00+0200
|
|
check_sql_result_integer(pConn, "select WEEK(ts, 3) from db1.ntb", 1); // 2024-01-01 23:00:00+0200
|
|
|
|
// WEEKOFYEAR
|
|
check_sql_result_integer(pConn, "select WEEKOFYEAR('2024-01-07')", 1);
|
|
check_sql_result_integer(pConn, "select WEEKOFYEAR('2024-01-07 02:00:00')", 1);
|
|
check_sql_result_integer(pConn, "select WEEKOFYEAR('2024-01-07 02:00:00+0200')", 1);
|
|
check_sql_result_integer(pConn, "select WEEKOFYEAR('2024-01-01 02:00:00+1100')", 52);
|
|
check_sql_result_integer(pConn, "select WEEKOFYEAR(1704142800000)", 1); // 2024-01-01 23:00:00+0200
|
|
check_sql_result_integer(pConn, "select WEEKOFYEAR(ts) from db1.ntb", 1); // 2024-01-01 23:00:00+0200
|
|
|
|
// TO_ISO8601
|
|
check_sql_result(pConn, "select TO_ISO8601(ts) from db1.ntb", "2024-01-01T23:00:00.000+0200");
|
|
check_sql_result(pConn, "select TO_ISO8601(ts,'-08') from db1.ntb", "2024-01-01T13:00:00.000-08");
|
|
check_sql_result(pConn, "select TO_ISO8601(1)", "1970-01-01T02:00:00.001+0200");
|
|
check_sql_result(pConn, "select TO_ISO8601(1,'+0800')", "1970-01-01T08:00:00.001+0800");
|
|
|
|
// TO_UNIXTIMESTAMP
|
|
check_sql_result_integer(pConn, "select TO_UNIXTIMESTAMP(c1) from db1.ntb",
|
|
1704121200000); // use timezone in server UTC-8
|
|
check_sql_result_integer(pConn, "select TO_UNIXTIMESTAMP('2024-01-01T23:00:00.000+0200')", 1704142800000);
|
|
check_sql_result_integer(pConn, "select TO_UNIXTIMESTAMP('2024-01-01T13:00:00.000-08')", 1704142800000);
|
|
check_sql_result_integer(pConn, "select TO_UNIXTIMESTAMP('2024-01-01T23:00:00.001')", 1704142800001);
|
|
|
|
// TO_TIMESTAMP
|
|
check_sql_result_integer(pConn, "select TO_TIMESTAMP(c1,'yyyy-mm-dd hh24:mi:ss') from db1.ntb",
|
|
1704121200000); // use timezone in server UTC-8
|
|
check_sql_result_integer(pConn, "select TO_TIMESTAMP('2024-01-01 23:00:00+02:00', 'yyyy-mm-dd hh24:mi:ss tzh')",
|
|
1704142800000);
|
|
check_sql_result_integer(pConn, "select TO_TIMESTAMP('2024-01-01T13:00:00-08', 'yyyy-mm-ddThh24:mi:ss tzh')",
|
|
1704142800000);
|
|
check_sql_result_integer(pConn, "select TO_TIMESTAMP('2024/01/01 23:00:00', 'yyyy/mm/dd hh24:mi:ss')", 1704142800000);
|
|
|
|
// TO_CHAR
|
|
check_sql_result(pConn, "select TO_CHAR(ts,'yyyy-mm-dd hh24:mi:ss') from db1.ntb",
|
|
"2024-01-02 05:00:00"); // use timezone in server UTC-8
|
|
check_sql_result(pConn, "select TO_CHAR(cast(1704142800000 as timestamp), 'yyyy-mm-dd hh24:mi:ss tzh')",
|
|
"2024-01-01 23:00:00 +02");
|
|
check_sql_result(pConn, "select TO_CHAR(cast(1704142800000 as timestamp), 'yyyy-mm-dd hh24:mi:ss')",
|
|
"2024-01-01 23:00:00");
|
|
|
|
// TIMEDIFF
|
|
check_sql_result_integer(pConn, "select TIMEDIFF(c1, '2024-01-01T23:00:00.001+02') from db1.ntb",
|
|
-21600001); // use timezone in server UTC-8
|
|
check_sql_result_integer(pConn, "select TIMEDIFF(c1, '2024-01-01T23:00:00.001') from db1.ntb",
|
|
-1); // use timezone in server UTC-8
|
|
check_sql_result_integer(pConn, "select TIMEDIFF('2024-01-01T23:00:00.001', '2024-01-01T13:00:00.000-08')", 1);
|
|
|
|
// CAST
|
|
check_sql_result_integer(pConn, "select CAST(c1 as timestamp) from db1.ntb", 1704121200000);
|
|
check_sql_result_integer(pConn, "select CAST('2024-01-01T23:00:00.000+02' as timestamp)", 1704142800000);
|
|
check_sql_result_integer(pConn, "select CAST('2024-01-01T23:00:00.000' as timestamp)", 1704142800000);
|
|
|
|
taos_close(pConn);
|
|
|
|
// hash join
|
|
pConn = getConnWithOption("UTC+1");
|
|
|
|
execQuery(pConn, "drop database if exists db1");
|
|
execQuery(pConn, "create database db1");
|
|
execQuery(pConn, "create table db1.ntb (ts timestamp, c1 binary(32), c2 int)");
|
|
execQuery(pConn, "create table db1.ntb1 (ts timestamp, c1 binary(32), c2 int)");
|
|
execQuery(pConn, "insert into db1.ntb values(1703987400000, '2023-12-31 00:50:00', 1)"); // 2023-12-31 00:50:00-0100
|
|
execQuery(pConn,
|
|
"insert into db1.ntb1 values(1704070200000, '2023-12-31 23:50:00', 11)"); // 2023-12-31 23:50:00-0100
|
|
checkRows(pConn, "select a.ts,b.ts from db1.ntb a join db1.ntb1 b on timetruncate(a.ts, 1d) = timetruncate(b.ts, 1d)",
|
|
1);
|
|
|
|
// operator +1n +1y
|
|
check_sql_result(pConn, "select TO_ISO8601(CAST('2023-01-31T00:00:00.000-01' as timestamp) + 1n)",
|
|
"2023-02-28T00:00:00.000-0100");
|
|
check_sql_result(pConn, "select TO_ISO8601(CAST('2024-01-31T00:00:00.000-01' as timestamp) + 1n)",
|
|
"2024-02-29T00:00:00.000-0100");
|
|
check_sql_result(pConn, "select TO_ISO8601(CAST('2024-02-29T00:00:00.000-01' as timestamp) + 1y)",
|
|
"2025-02-28T00:00:00.000-0100");
|
|
check_sql_result(pConn, "select TO_ISO8601(CAST('2024-01-31T00:00:00.000-01' as timestamp) + 1y)",
|
|
"2025-01-31T00:00:00.000-0100");
|
|
|
|
check_sql_result(pConn, "select TO_ISO8601(CAST('2024-01-01T00:00:00.000+01' as timestamp) + 1n)",
|
|
"2024-01-31T22:00:00.000-0100");
|
|
check_sql_result(pConn, "select TO_ISO8601(CAST('2024-01-01T00:00:00.000+01' as timestamp) + 1y)",
|
|
"2024-12-31T22:00:00.000-0100");
|
|
|
|
// case when
|
|
check_sql_result_integer(
|
|
pConn, "select case CAST('2024-01-01T00:00:00.000+01' as timestamp) when 1704063600000 then 1 end", 1);
|
|
check_sql_result_integer(pConn,
|
|
"select case CAST('2024-01-01T00:00:00.000' as timestamp) when 1704070800000 then 1 end", 1);
|
|
|
|
taos_close(pConn);
|
|
}
|
|
|
|
time_t time_winter = 1731323281; // 2024-11-11 19:08:01+0800
|
|
time_t time_summer = 1731323281 - 120 * 24 * 60 * 60;
|
|
|
|
struct test_times {
|
|
const char* name;
|
|
time_t t;
|
|
const char* timezone;
|
|
} test_tz[] = {{"", time_winter, " (UTC, +0000)"},
|
|
{"America/New_York", time_winter, "America/New_York (EST, -0500)"}, // 2024-11-11 19:08:01+0800
|
|
{"America/New_York", time_summer, "America/New_York (EDT, -0400)"},
|
|
{"Asia/Kolkata", time_winter, "Asia/Kolkata (IST, +0530)"},
|
|
{"Asia/Shanghai", time_winter, "Asia/Shanghai (CST, +0800)"},
|
|
{"Europe/London", time_winter, "Europe/London (GMT, +0000)"},
|
|
{"Europe/London", time_summer, "Europe/London (BST, +0100)"}};
|
|
|
|
void timezone_str_test(const char* tz, time_t t, const char* tzStr) {
|
|
int code = setenv("TZ", tz, 1);
|
|
ASSERT(-1 != code);
|
|
tzset();
|
|
|
|
char str1[TD_TIMEZONE_LEN] = {0};
|
|
ASSERT(taosFormatTimezoneStr(t, tz, NULL, str1) == 0);
|
|
ASSERT_STREQ(str1, tzStr);
|
|
}
|
|
|
|
void timezone_rz_str_test(const char* tz, time_t t, const char* tzStr) {
|
|
timezone_t sp = tzalloc(tz);
|
|
ASSERT(sp);
|
|
|
|
char str1[TD_TIMEZONE_LEN] = {0};
|
|
ASSERT(taosFormatTimezoneStr(t, tz, sp, str1) == 0);
|
|
ASSERT_STREQ(str1, tzStr);
|
|
tzfree(sp);
|
|
}
|
|
TEST(sessionTest, session1) {
|
|
int32_t code = sessMgtInit();
|
|
ASSERT(code == 0);
|
|
int32_t expect = 1000;
|
|
|
|
char* users[] = {"test1", "test2", "test3", "test4", "test5"};
|
|
|
|
for (int32_t i = 0; i < sizeof(users) / sizeof(users[0]); i++) {
|
|
code = sessMgtUpdataLimit(users[i], SESSION_PER_USER, expect);
|
|
ASSERT(code == 0);
|
|
code = sessMgtUpdataLimit(users[i], SESSION_CONN_TIME, expect);
|
|
ASSERT(code == 0);
|
|
code = sessMgtUpdataLimit(users[i], SESSION_CONN_IDLE_TIME, expect);
|
|
ASSERT(code == 0);
|
|
code = sessMgtUpdataLimit(users[i], SESSION_MAX_CONCURRENCY, expect);
|
|
ASSERT(code == 0);
|
|
code = sessMgtUpdataLimit(users[i], SESSION_MAX_CALL_VNODE_NUM, expect);
|
|
ASSERT(code == 0);
|
|
code = sessMgtUpdataLimit(users[i], SESSION_MAX_TYPE, 10);
|
|
ASSERT(code != 0);
|
|
}
|
|
|
|
SSessParam para = {}; para.type = SESSION_PER_USER; para.value = 1;
|
|
for (int32_t i = 0; i <= 1000; i++) {
|
|
for (int32_t i = 0; i < sizeof(users) / sizeof(users[0]); i++) {
|
|
code = sessMgtUpdateUserMetric(users[i], ¶);
|
|
ASSERT(code == 0);
|
|
}
|
|
}
|
|
|
|
for (int32_t i = 0; i < sizeof(users) / sizeof(users[0]); i++) {
|
|
code = sessMgtUpdateUserMetric(users[i], ¶);
|
|
ASSERT(code != 0);
|
|
}
|
|
|
|
sessMgtDestroy();
|
|
}
|
|
|
|
#endif
|
|
|
|
#pragma GCC diagnostic pop |