#4986

Committed 15 Mar 2026 08:32AM UTC coverage: 37.305% (-31.3%) from 68.601%

Build # #4986

Build Type

push

travis-ci

Committed by

tomchon

Commit Message

test: keep docs and unit test

Run Details

125478 of 336361 relevant lines covered (37.3%)

1134847.06 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.88

/source/client/wrapper/src/wrapperDriver.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 "wrapper.h"
#include "wrapperHint.h"

#ifdef WINDOWS
#define DRIVER_NATIVE_NAME    "taosnative.dll"
#define DRIVER_WSBSOCKET_NAME "taosws.dll"
#elif defined(DARWIN)
#define DRIVER_NATIVE_NAME    "libtaosnative.dylib"
#define DRIVER_WSBSOCKET_NAME "libtaosws.dylib"
#else
#define DRIVER_NATIVE_NAME    "libtaosnative.so"
#define DRIVER_WSBSOCKET_NAME "libtaosws.so"
#endif

#define LOAD_FUNC(fptr, fname)                \
  funcName = fname;                           \
  fptr = taosLoadDllFunc(tsDriver, funcName); \
  if (fptr == NULL) goto _OVER;

#ifdef WEBSOCKET
EDriverType tsDriverType = DRIVER_NATIVE;  // todo simon
#else
EDriverType tsDriverType = DRIVER_NATIVE;
#endif

void *tsDriver = NULL;

static int32_t taosGetDevelopPath(char *driverPath, const char *driverName) {
  char    appPath[PATH_MAX] = {0};
  int32_t ret = taosAppPath(appPath, PATH_MAX);
  if (ret == 0) {
    snprintf(driverPath, PATH_MAX, "%s%s..%slib%s%s", appPath, TD_DIRSEP, TD_DIRSEP, TD_DIRSEP, driverName);
    ret = taosRealPath(driverPath, NULL, PATH_MAX);
  }

  return ret;
}

void taosDriverEnvInit() {
  const char *driver = getenv("TDENGINE_DRIVER");
  if (driver) {
    if (strcasecmp(driver, STR_NATIVE) == 0) {
      tsDriverType = DRIVER_NATIVE;
    } else if (strcasecmp(driver, STR_WEBSOCKET) == 0) {
      tsDriverType = DRIVER_WEBSOCKET;
    }
  }
}

int32_t taosDriverInit(EDriverType driverType) {
  int32_t     code = -1;
  char        driverPath[PATH_MAX + 32] = {0};
  const char *driverName = NULL;
  const char *funcName = NULL;

  if (driverType == DRIVER_NATIVE) {
    driverName = DRIVER_NATIVE_NAME;
  } else {
    driverName = DRIVER_WSBSOCKET_NAME;
  }

  // load from develop build path
  if (tsDriver == NULL && taosGetDevelopPath(driverPath, driverName) == 0) {
    tsDriver = taosLoadDll(driverPath);
  }  

  // load from system path
  if (tsDriver == NULL) {
    tsDriver = taosLoadDll(driverName);
  }

// load from install path on mac
#if defined(DARWIN)
  if (tsDriver == NULL) {
    snprintf(driverPath, PATH_MAX, "/usr/local/lib/%s", driverName);
    tsDriver = taosLoadDll(driverPath);
  }
#endif

  if (tsDriver == NULL) {
    printf("failed to load %s since %s [0x%X]\r\n", driverName, terrstr(), terrno);
    showWrapperHint(terrno);
    return code;
  }

  LOAD_FUNC(fp_taos_set_config, "taos_set_config");

  LOAD_FUNC(fp_taos_init, "taos_init");
  LOAD_FUNC(fp_taos_cleanup, "taos_cleanup");
  LOAD_FUNC(fp_taos_options, "taos_options");
  LOAD_FUNC(fp_taos_set_option, "taos_set_option");
  LOAD_FUNC(fp_taos_options_connection, "taos_options_connection");
  LOAD_FUNC(fp_taos_connect, "taos_connect");
  LOAD_FUNC(fp_taos_connect_totp, "taos_connect_totp");
  LOAD_FUNC(fp_taos_connect_token, "taos_connect_token");
  LOAD_FUNC(fp_taos_connect_test, "taos_connect_test");
  LOAD_FUNC(fp_taos_connect_auth, "taos_connect_auth");
  LOAD_FUNC(fp_taos_connect_with, "taos_connect_with");
  LOAD_FUNC(fp_taos_connect_with_dsn, "taos_connect_with_dsn");
  LOAD_FUNC(fp_taos_close, "taos_close");

  LOAD_FUNC(fp_taos_data_type, "taos_data_type");

  LOAD_FUNC(fp_taos_stmt_init, "taos_stmt_init");
  LOAD_FUNC(fp_taos_stmt_init_with_reqid, "taos_stmt_init_with_reqid");
  LOAD_FUNC(fp_taos_stmt_init_with_options, "taos_stmt_init_with_options");
  LOAD_FUNC(fp_taos_stmt_prepare, "taos_stmt_prepare");
  LOAD_FUNC(fp_taos_stmt_set_tbname_tags, "taos_stmt_set_tbname_tags");
  LOAD_FUNC(fp_taos_stmt_set_tbname, "taos_stmt_set_tbname");
  LOAD_FUNC(fp_taos_stmt_set_tags, "taos_stmt_set_tags");
  LOAD_FUNC(fp_taos_stmt_set_sub_tbname, "taos_stmt_set_sub_tbname");
  LOAD_FUNC(fp_taos_stmt_get_tag_fields, "taos_stmt_get_tag_fields");
  LOAD_FUNC(fp_taos_stmt_get_col_fields, "taos_stmt_get_col_fields");
  LOAD_FUNC(fp_taos_stmt_reclaim_fields, "taos_stmt_reclaim_fields");

  LOAD_FUNC(fp_taos_stmt_is_insert, "taos_stmt_is_insert");
  LOAD_FUNC(fp_taos_stmt_num_params, "taos_stmt_num_params");
  LOAD_FUNC(fp_taos_stmt_get_param, "taos_stmt_get_param");
  LOAD_FUNC(fp_taos_stmt_bind_param, "taos_stmt_bind_param");
  LOAD_FUNC(fp_taos_stmt_bind_param_batch, "taos_stmt_bind_param_batch");
  LOAD_FUNC(fp_taos_stmt_bind_single_param_batch, "taos_stmt_bind_single_param_batch");
  LOAD_FUNC(fp_taos_stmt_add_batch, "taos_stmt_add_batch");
  LOAD_FUNC(fp_taos_stmt_execute, "taos_stmt_execute");
  LOAD_FUNC(fp_taos_stmt_use_result, "taos_stmt_use_result");
  LOAD_FUNC(fp_taos_stmt_close, "taos_stmt_close");
  LOAD_FUNC(fp_taos_stmt_errstr, "taos_stmt_errstr");
  LOAD_FUNC(fp_taos_stmt_affected_rows, "taos_stmt_affected_rows");
  LOAD_FUNC(fp_taos_stmt_affected_rows_once, "taos_stmt_affected_rows_once");

  LOAD_FUNC(fp_taos_stmt2_init, "taos_stmt2_init");
  LOAD_FUNC(fp_taos_stmt2_prepare, "taos_stmt2_prepare");
  LOAD_FUNC(fp_taos_stmt2_bind_param, "taos_stmt2_bind_param");
  LOAD_FUNC(fp_taos_stmt2_bind_param_a, "taos_stmt2_bind_param_a");
  LOAD_FUNC(fp_taos_stmt2_exec, "taos_stmt2_exec");
  LOAD_FUNC(fp_taos_stmt2_close, "taos_stmt2_close");
  LOAD_FUNC(fp_taos_stmt2_is_insert, "taos_stmt2_is_insert");
  LOAD_FUNC(fp_taos_stmt2_get_fields, "taos_stmt2_get_fields");
  LOAD_FUNC(fp_taos_stmt2_free_fields, "taos_stmt2_free_fields");
  LOAD_FUNC(fp_taos_stmt2_result, "taos_stmt2_result");
  LOAD_FUNC(fp_taos_stmt2_error, "taos_stmt2_error");

  LOAD_FUNC(fp_taos_query, "taos_query");
  LOAD_FUNC(fp_taos_query_with_reqid, "taos_query_with_reqid");

  LOAD_FUNC(fp_taos_fetch_row, "taos_fetch_row");
  LOAD_FUNC(fp_taos_result_precision, "taos_result_precision");
  LOAD_FUNC(fp_taos_free_result, "taos_free_result");
  LOAD_FUNC(fp_taos_kill_query, "taos_kill_query");
  LOAD_FUNC(fp_taos_field_count, "taos_field_count");
  LOAD_FUNC(fp_taos_num_fields, "taos_num_fields");
  LOAD_FUNC(fp_taos_affected_rows, "taos_affected_rows");
  LOAD_FUNC(fp_taos_affected_rows64, "taos_affected_rows64");

  LOAD_FUNC(fp_taos_fetch_fields, "taos_fetch_fields");
  LOAD_FUNC(fp_taos_fetch_fields_e, "taos_fetch_fields_e");
  LOAD_FUNC(fp_taos_select_db, "taos_select_db");
  LOAD_FUNC(fp_taos_print_row, "taos_print_row");
  LOAD_FUNC(fp_taos_print_row_with_size, "taos_print_row_with_size");
  LOAD_FUNC(fp_taos_stop_query, "taos_stop_query");
  LOAD_FUNC(fp_taos_is_null, "taos_is_null");
  LOAD_FUNC(fp_taos_is_null_by_column, "taos_is_null_by_column");
  LOAD_FUNC(fp_taos_is_update_query, "taos_is_update_query");
  LOAD_FUNC(fp_taos_fetch_block, "taos_fetch_block");
  LOAD_FUNC(fp_taos_fetch_block_s, "taos_fetch_block_s");
  LOAD_FUNC(fp_taos_fetch_raw_block, "taos_fetch_raw_block");
  LOAD_FUNC(fp_taos_get_column_data_offset, "taos_get_column_data_offset");
  LOAD_FUNC(fp_taos_validate_sql, "taos_validate_sql");
  LOAD_FUNC(fp_taos_reset_current_db, "taos_reset_current_db");

  LOAD_FUNC(fp_taos_fetch_lengths, "taos_fetch_lengths");
  LOAD_FUNC(fp_taos_result_block, "taos_result_block");

  LOAD_FUNC(fp_taos_get_server_info, "taos_get_server_info");
  LOAD_FUNC(fp_taos_get_client_info, "taos_get_client_info");
  LOAD_FUNC(fp_taos_get_current_db, "taos_get_current_db");
  LOAD_FUNC(fp_taos_get_connection_info, "taos_get_connection_info");

  LOAD_FUNC(fp_taos_errstr, "taos_errstr");
  LOAD_FUNC(fp_taos_errno, "taos_errno");

  LOAD_FUNC(fp_taos_query_a, "taos_query_a");
  LOAD_FUNC(fp_taos_query_a_with_reqid, "taos_query_a_with_reqid");
  LOAD_FUNC(fp_taos_fetch_rows_a, "taos_fetch_rows_a");
  LOAD_FUNC(fp_taos_fetch_raw_block_a, "taos_fetch_raw_block_a");
  LOAD_FUNC(fp_taos_get_raw_block, "taos_get_raw_block");

  LOAD_FUNC(fp_taos_get_db_route_info, "taos_get_db_route_info");
  LOAD_FUNC(fp_taos_get_table_vgId, "taos_get_table_vgId");
  LOAD_FUNC(fp_taos_get_tables_vgId, "taos_get_tables_vgId");

  LOAD_FUNC(fp_taos_load_table_info, "taos_load_table_info");

  LOAD_FUNC(fp_taos_set_hb_quit, "taos_set_hb_quit");

  LOAD_FUNC(fp_taos_set_notify_cb, "taos_set_notify_cb");

  LOAD_FUNC(fp_taos_fetch_whitelist_a, "taos_fetch_whitelist_a");

  LOAD_FUNC(fp_taos_fetch_whitelist_dual_stack_a, "taos_fetch_whitelist_dual_stack_a");
  LOAD_FUNC(fp_taos_fetch_ip_whitelist_a, "taos_fetch_ip_whitelist_a");
  LOAD_FUNC(fp_taos_fetch_datetime_whitelist_a, "taos_fetch_datetime_whitelist_a");

  LOAD_FUNC(fp_taos_set_conn_mode, "taos_set_conn_mode");

  LOAD_FUNC(fp_taos_schemaless_insert, "taos_schemaless_insert");
  LOAD_FUNC(fp_taos_schemaless_insert_with_reqid, "taos_schemaless_insert_with_reqid");
  LOAD_FUNC(fp_taos_schemaless_insert_raw, "taos_schemaless_insert_raw");
  LOAD_FUNC(fp_taos_schemaless_insert_raw_with_reqid, "taos_schemaless_insert_raw_with_reqid");
  LOAD_FUNC(fp_taos_schemaless_insert_ttl, "taos_schemaless_insert_ttl");
  LOAD_FUNC(fp_taos_schemaless_insert_ttl_with_reqid, "taos_schemaless_insert_ttl_with_reqid");
  LOAD_FUNC(fp_taos_schemaless_insert_raw_ttl, "taos_schemaless_insert_raw_ttl");
  LOAD_FUNC(fp_taos_schemaless_insert_raw_ttl_with_reqid, "taos_schemaless_insert_raw_ttl_with_reqid");
  LOAD_FUNC(fp_taos_schemaless_insert_raw_ttl_with_reqid_tbname_key,
            "taos_schemaless_insert_raw_ttl_with_reqid_tbname_key");
  LOAD_FUNC(fp_taos_schemaless_insert_ttl_with_reqid_tbname_key, "taos_schemaless_insert_ttl_with_reqid_tbname_key");

  LOAD_FUNC(fp_tmq_conf_new, "tmq_conf_new");
  LOAD_FUNC(fp_tmq_conf_set, "tmq_conf_set");
  LOAD_FUNC(fp_tmq_conf_destroy, "tmq_conf_destroy");
  LOAD_FUNC(fp_tmq_conf_set_auto_commit_cb, "tmq_conf_set_auto_commit_cb");

  LOAD_FUNC(fp_tmq_list_new, "tmq_list_new");
  LOAD_FUNC(fp_tmq_list_append, "tmq_list_append");
  LOAD_FUNC(fp_tmq_list_destroy, "tmq_list_destroy");
  LOAD_FUNC(fp_tmq_list_get_size, "tmq_list_get_size");
  LOAD_FUNC(fp_tmq_list_to_c_array, "tmq_list_to_c_array");

  LOAD_FUNC(fp_tmq_consumer_new, "tmq_consumer_new");
  LOAD_FUNC(fp_tmq_subscribe, "tmq_subscribe");
  LOAD_FUNC(fp_tmq_unsubscribe, "tmq_unsubscribe");
  LOAD_FUNC(fp_tmq_subscription, "tmq_subscription");
  LOAD_FUNC(fp_tmq_consumer_poll, "tmq_consumer_poll");
  LOAD_FUNC(fp_tmq_consumer_close, "tmq_consumer_close");
  LOAD_FUNC(fp_tmq_commit_sync, "tmq_commit_sync");
  LOAD_FUNC(fp_tmq_commit_async, "tmq_commit_async");
  LOAD_FUNC(fp_tmq_commit_offset_sync, "tmq_commit_offset_sync");
  LOAD_FUNC(fp_tmq_commit_offset_async, "tmq_commit_offset_async");
  LOAD_FUNC(fp_tmq_get_topic_assignment, "tmq_get_topic_assignment");
  LOAD_FUNC(fp_tmq_free_assignment, "tmq_free_assignment");
  LOAD_FUNC(fp_tmq_offset_seek, "tmq_offset_seek");
  LOAD_FUNC(fp_tmq_position, "tmq_position");
  LOAD_FUNC(fp_tmq_committed, "tmq_committed");

  LOAD_FUNC(fp_tmq_get_connect, "tmq_get_connect");
  LOAD_FUNC(fp_tmq_get_table_name, "tmq_get_table_name");
  LOAD_FUNC(fp_tmq_get_res_type, "tmq_get_res_type");
  LOAD_FUNC(fp_tmq_get_topic_name, "tmq_get_topic_name");
  LOAD_FUNC(fp_tmq_get_db_name, "tmq_get_db_name");
  LOAD_FUNC(fp_tmq_get_vgroup_id, "tmq_get_vgroup_id");
  LOAD_FUNC(fp_tmq_get_vgroup_offset, "tmq_get_vgroup_offset");
  LOAD_FUNC(fp_tmq_err2str, "tmq_err2str");

  LOAD_FUNC(fp_tmq_get_raw, "tmq_get_raw");
  LOAD_FUNC(fp_tmq_write_raw, "tmq_write_raw");
  LOAD_FUNC(fp_taos_write_raw_block, "taos_write_raw_block");
  LOAD_FUNC(fp_taos_write_raw_block_with_reqid, "taos_write_raw_block_with_reqid");
  LOAD_FUNC(fp_taos_write_raw_block_with_fields, "taos_write_raw_block_with_fields");
  LOAD_FUNC(fp_taos_write_raw_block_with_fields_with_reqid, "taos_write_raw_block_with_fields_with_reqid");
  LOAD_FUNC(fp_tmq_free_raw, "tmq_free_raw");

  LOAD_FUNC(fp_tmq_get_json_meta, "tmq_get_json_meta");
  LOAD_FUNC(fp_tmq_free_json_meta, "tmq_free_json_meta");

  LOAD_FUNC(fp_taos_check_server_status, "taos_check_server_status");
  LOAD_FUNC(fp_taos_write_crashinfo, "taos_write_crashinfo");
  LOAD_FUNC(fp_getBuildInfo, "getBuildInfo");

  LOAD_FUNC(fp_taos_connect_is_alive, "taos_connect_is_alive");

  code = 0;

_OVER:
  if (code != 0) {
    printf("failed to load function %s from %s since %s [0x%X]\r\n", funcName, driverPath, terrstr(), terrno);
    showWrapperHint(terrno);
    taosDriverCleanup();
  }

  return code;
}

void taosDriverCleanup() {
  if (tsDriver != NULL) {
    taosCloseDll(tsDriver);
    tsDriver = NULL;
  }
}

1	/*
2	* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3	*
4	* This program is free software: you can use, redistribute, and/or modify
5	* it under the terms of the GNU Affero General Public License, version 3
6	* or later ("AGPL"), as published by the Free Software Foundation.
7	*
8	* This program is distributed in the hope that it will be useful, but WITHOUT
9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10	* FITNESS FOR A PARTICULAR PURPOSE.
11	*
12	* You should have received a copy of the GNU Affero General Public License
13	* along with this program. If not, see <http://www.gnu.org/licenses/>.
14	*/
15
16	#include "wrapper.h"
17	#include "wrapperHint.h"
18
19	#ifdef WINDOWS
20	#define DRIVER_NATIVE_NAME "taosnative.dll"
21	#define DRIVER_WSBSOCKET_NAME "taosws.dll"
22	#elif defined(DARWIN)
23	#define DRIVER_NATIVE_NAME "libtaosnative.dylib"
24	#define DRIVER_WSBSOCKET_NAME "libtaosws.dylib"
25	#else
26	#define DRIVER_NATIVE_NAME "libtaosnative.so"
27	#define DRIVER_WSBSOCKET_NAME "libtaosws.so"
28	#endif
29
30	#define LOAD_FUNC(fptr, fname) \
31	funcName = fname; \
32	fptr = taosLoadDllFunc(tsDriver, funcName); \
33	if (fptr == NULL) goto _OVER;
34
35	#ifdef WEBSOCKET
36	EDriverType tsDriverType = DRIVER_NATIVE; // todo simon
37	#else
38	EDriverType tsDriverType = DRIVER_NATIVE;
39	#endif
40
41	void *tsDriver = NULL;
42
43	static int32_t taosGetDevelopPath(char driverPath, const char driverName) {	26✔
44	char appPath[PATH_MAX] = {0};	26✔
45	int32_t ret = taosAppPath(appPath, PATH_MAX);	26✔
46	if (ret == 0) {	26✔
47	snprintf(driverPath, PATH_MAX, "%s%s..%slib%s%s", appPath, TD_DIRSEP, TD_DIRSEP, TD_DIRSEP, driverName);	26✔
48	ret = taosRealPath(driverPath, NULL, PATH_MAX);	26✔
49	}
50
51	return ret;	26✔
52	}
53
54	void taosDriverEnvInit() {	26✔
55	const char *driver = getenv("TDENGINE_DRIVER");	26✔
56	if (driver) {	26✔
57	if (strcasecmp(driver, STR_NATIVE) == 0) {	×
58	tsDriverType = DRIVER_NATIVE;	×
59	} else if (strcasecmp(driver, STR_WEBSOCKET) == 0) {	×
60	tsDriverType = DRIVER_WEBSOCKET;	×
61	}
62	}
63	}	26✔
64
65	int32_t taosDriverInit(EDriverType driverType) {	26✔
66	int32_t code = -1;	26✔
67	char driverPath[PATH_MAX + 32] = {0};	26✔
68	const char *driverName = NULL;	26✔
69	const char *funcName = NULL;	26✔
70
71	if (driverType == DRIVER_NATIVE) {	26✔
72	driverName = DRIVER_NATIVE_NAME;	26✔
73	} else {
74	driverName = DRIVER_WSBSOCKET_NAME;	×
75	}
76
77	// load from develop build path
78	if (tsDriver == NULL && taosGetDevelopPath(driverPath, driverName) == 0) {	26✔
79	tsDriver = taosLoadDll(driverPath);	8✔
80	}
81
82	// load from system path
83	if (tsDriver == NULL) {	26✔
84	tsDriver = taosLoadDll(driverName);	18✔
85	}
86
87	// load from install path on mac
88	#if defined(DARWIN)
89	if (tsDriver == NULL) {
90	snprintf(driverPath, PATH_MAX, "/usr/local/lib/%s", driverName);
91	tsDriver = taosLoadDll(driverPath);
92	}
93	#endif
94
95	if (tsDriver == NULL) {	26✔
96	printf("failed to load %s since %s [0x%X]\r\n", driverName, terrstr(), terrno);	×
97	showWrapperHint(terrno);	×
98	return code;	×
99	}
100
101	LOAD_FUNC(fp_taos_set_config, "taos_set_config");	26✔
102
103	LOAD_FUNC(fp_taos_init, "taos_init");	26✔
104	LOAD_FUNC(fp_taos_cleanup, "taos_cleanup");	26✔
105	LOAD_FUNC(fp_taos_options, "taos_options");	26✔
106	LOAD_FUNC(fp_taos_set_option, "taos_set_option");	26✔
107	LOAD_FUNC(fp_taos_options_connection, "taos_options_connection");	26✔
108	LOAD_FUNC(fp_taos_connect, "taos_connect");	26✔
109	LOAD_FUNC(fp_taos_connect_totp, "taos_connect_totp");	26✔
110	LOAD_FUNC(fp_taos_connect_token, "taos_connect_token");	26✔
111	LOAD_FUNC(fp_taos_connect_test, "taos_connect_test");	26✔
112	LOAD_FUNC(fp_taos_connect_auth, "taos_connect_auth");	26✔
113	LOAD_FUNC(fp_taos_connect_with, "taos_connect_with");	26✔
114	LOAD_FUNC(fp_taos_connect_with_dsn, "taos_connect_with_dsn");	26✔
115	LOAD_FUNC(fp_taos_close, "taos_close");	26✔
116
117	LOAD_FUNC(fp_taos_data_type, "taos_data_type");	26✔
118
119	LOAD_FUNC(fp_taos_stmt_init, "taos_stmt_init");	26✔
120	LOAD_FUNC(fp_taos_stmt_init_with_reqid, "taos_stmt_init_with_reqid");	26✔
121	LOAD_FUNC(fp_taos_stmt_init_with_options, "taos_stmt_init_with_options");	26✔
122	LOAD_FUNC(fp_taos_stmt_prepare, "taos_stmt_prepare");	26✔
123	LOAD_FUNC(fp_taos_stmt_set_tbname_tags, "taos_stmt_set_tbname_tags");	26✔
124	LOAD_FUNC(fp_taos_stmt_set_tbname, "taos_stmt_set_tbname");	26✔
125	LOAD_FUNC(fp_taos_stmt_set_tags, "taos_stmt_set_tags");	26✔
126	LOAD_FUNC(fp_taos_stmt_set_sub_tbname, "taos_stmt_set_sub_tbname");	26✔
127	LOAD_FUNC(fp_taos_stmt_get_tag_fields, "taos_stmt_get_tag_fields");	26✔
128	LOAD_FUNC(fp_taos_stmt_get_col_fields, "taos_stmt_get_col_fields");	26✔
129	LOAD_FUNC(fp_taos_stmt_reclaim_fields, "taos_stmt_reclaim_fields");	26✔
130
131	LOAD_FUNC(fp_taos_stmt_is_insert, "taos_stmt_is_insert");	26✔
132	LOAD_FUNC(fp_taos_stmt_num_params, "taos_stmt_num_params");	26✔
133	LOAD_FUNC(fp_taos_stmt_get_param, "taos_stmt_get_param");	26✔
134	LOAD_FUNC(fp_taos_stmt_bind_param, "taos_stmt_bind_param");	26✔
135	LOAD_FUNC(fp_taos_stmt_bind_param_batch, "taos_stmt_bind_param_batch");	26✔
136	LOAD_FUNC(fp_taos_stmt_bind_single_param_batch, "taos_stmt_bind_single_param_batch");	26✔
137	LOAD_FUNC(fp_taos_stmt_add_batch, "taos_stmt_add_batch");	26✔
138	LOAD_FUNC(fp_taos_stmt_execute, "taos_stmt_execute");	26✔
139	LOAD_FUNC(fp_taos_stmt_use_result, "taos_stmt_use_result");	26✔
140	LOAD_FUNC(fp_taos_stmt_close, "taos_stmt_close");	26✔
141	LOAD_FUNC(fp_taos_stmt_errstr, "taos_stmt_errstr");	26✔
142	LOAD_FUNC(fp_taos_stmt_affected_rows, "taos_stmt_affected_rows");	26✔
143	LOAD_FUNC(fp_taos_stmt_affected_rows_once, "taos_stmt_affected_rows_once");	26✔
144
145	LOAD_FUNC(fp_taos_stmt2_init, "taos_stmt2_init");	26✔
146	LOAD_FUNC(fp_taos_stmt2_prepare, "taos_stmt2_prepare");	26✔
147	LOAD_FUNC(fp_taos_stmt2_bind_param, "taos_stmt2_bind_param");	26✔
148	LOAD_FUNC(fp_taos_stmt2_bind_param_a, "taos_stmt2_bind_param_a");	26✔
149	LOAD_FUNC(fp_taos_stmt2_exec, "taos_stmt2_exec");	26✔
150	LOAD_FUNC(fp_taos_stmt2_close, "taos_stmt2_close");	26✔
151	LOAD_FUNC(fp_taos_stmt2_is_insert, "taos_stmt2_is_insert");	26✔
152	LOAD_FUNC(fp_taos_stmt2_get_fields, "taos_stmt2_get_fields");	26✔
153	LOAD_FUNC(fp_taos_stmt2_free_fields, "taos_stmt2_free_fields");	26✔
154	LOAD_FUNC(fp_taos_stmt2_result, "taos_stmt2_result");	26✔
155	LOAD_FUNC(fp_taos_stmt2_error, "taos_stmt2_error");	26✔
156
157	LOAD_FUNC(fp_taos_query, "taos_query");	26✔
158	LOAD_FUNC(fp_taos_query_with_reqid, "taos_query_with_reqid");	26✔
159
160	LOAD_FUNC(fp_taos_fetch_row, "taos_fetch_row");	26✔
161	LOAD_FUNC(fp_taos_result_precision, "taos_result_precision");	26✔
162	LOAD_FUNC(fp_taos_free_result, "taos_free_result");	26✔
163	LOAD_FUNC(fp_taos_kill_query, "taos_kill_query");	26✔
164	LOAD_FUNC(fp_taos_field_count, "taos_field_count");	26✔
165	LOAD_FUNC(fp_taos_num_fields, "taos_num_fields");	26✔
166	LOAD_FUNC(fp_taos_affected_rows, "taos_affected_rows");	26✔
167	LOAD_FUNC(fp_taos_affected_rows64, "taos_affected_rows64");	26✔
168
169	LOAD_FUNC(fp_taos_fetch_fields, "taos_fetch_fields");	26✔
170	LOAD_FUNC(fp_taos_fetch_fields_e, "taos_fetch_fields_e");	26✔
171	LOAD_FUNC(fp_taos_select_db, "taos_select_db");	26✔
172	LOAD_FUNC(fp_taos_print_row, "taos_print_row");	26✔
173	LOAD_FUNC(fp_taos_print_row_with_size, "taos_print_row_with_size");	26✔
174	LOAD_FUNC(fp_taos_stop_query, "taos_stop_query");	26✔
175	LOAD_FUNC(fp_taos_is_null, "taos_is_null");	26✔
176	LOAD_FUNC(fp_taos_is_null_by_column, "taos_is_null_by_column");	26✔
177	LOAD_FUNC(fp_taos_is_update_query, "taos_is_update_query");	26✔
178	LOAD_FUNC(fp_taos_fetch_block, "taos_fetch_block");	26✔
179	LOAD_FUNC(fp_taos_fetch_block_s, "taos_fetch_block_s");	26✔
180	LOAD_FUNC(fp_taos_fetch_raw_block, "taos_fetch_raw_block");	26✔
181	LOAD_FUNC(fp_taos_get_column_data_offset, "taos_get_column_data_offset");	26✔
182	LOAD_FUNC(fp_taos_validate_sql, "taos_validate_sql");	26✔
183	LOAD_FUNC(fp_taos_reset_current_db, "taos_reset_current_db");	26✔
184
185	LOAD_FUNC(fp_taos_fetch_lengths, "taos_fetch_lengths");	26✔
186	LOAD_FUNC(fp_taos_result_block, "taos_result_block");	26✔
187
188	LOAD_FUNC(fp_taos_get_server_info, "taos_get_server_info");	26✔
189	LOAD_FUNC(fp_taos_get_client_info, "taos_get_client_info");	26✔
190	LOAD_FUNC(fp_taos_get_current_db, "taos_get_current_db");	26✔
191	LOAD_FUNC(fp_taos_get_connection_info, "taos_get_connection_info");	26✔
192
193	LOAD_FUNC(fp_taos_errstr, "taos_errstr");	26✔
194	LOAD_FUNC(fp_taos_errno, "taos_errno");	26✔
195
196	LOAD_FUNC(fp_taos_query_a, "taos_query_a");	26✔
197	LOAD_FUNC(fp_taos_query_a_with_reqid, "taos_query_a_with_reqid");	26✔
198	LOAD_FUNC(fp_taos_fetch_rows_a, "taos_fetch_rows_a");	26✔
199	LOAD_FUNC(fp_taos_fetch_raw_block_a, "taos_fetch_raw_block_a");	26✔
200	LOAD_FUNC(fp_taos_get_raw_block, "taos_get_raw_block");	26✔
201
202	LOAD_FUNC(fp_taos_get_db_route_info, "taos_get_db_route_info");	26✔
203	LOAD_FUNC(fp_taos_get_table_vgId, "taos_get_table_vgId");	26✔
204	LOAD_FUNC(fp_taos_get_tables_vgId, "taos_get_tables_vgId");	26✔
205
206	LOAD_FUNC(fp_taos_load_table_info, "taos_load_table_info");	26✔
207
208	LOAD_FUNC(fp_taos_set_hb_quit, "taos_set_hb_quit");	26✔
209
210	LOAD_FUNC(fp_taos_set_notify_cb, "taos_set_notify_cb");	26✔
211
212	LOAD_FUNC(fp_taos_fetch_whitelist_a, "taos_fetch_whitelist_a");	26✔
213
214	LOAD_FUNC(fp_taos_fetch_whitelist_dual_stack_a, "taos_fetch_whitelist_dual_stack_a");	26✔
215	LOAD_FUNC(fp_taos_fetch_ip_whitelist_a, "taos_fetch_ip_whitelist_a");	26✔
216	LOAD_FUNC(fp_taos_fetch_datetime_whitelist_a, "taos_fetch_datetime_whitelist_a");	26✔
217
218	LOAD_FUNC(fp_taos_set_conn_mode, "taos_set_conn_mode");	26✔
219
220	LOAD_FUNC(fp_taos_schemaless_insert, "taos_schemaless_insert");	26✔
221	LOAD_FUNC(fp_taos_schemaless_insert_with_reqid, "taos_schemaless_insert_with_reqid");	26✔
222	LOAD_FUNC(fp_taos_schemaless_insert_raw, "taos_schemaless_insert_raw");	26✔
223	LOAD_FUNC(fp_taos_schemaless_insert_raw_with_reqid, "taos_schemaless_insert_raw_with_reqid");	26✔
224	LOAD_FUNC(fp_taos_schemaless_insert_ttl, "taos_schemaless_insert_ttl");	26✔
225	LOAD_FUNC(fp_taos_schemaless_insert_ttl_with_reqid, "taos_schemaless_insert_ttl_with_reqid");	26✔
226	LOAD_FUNC(fp_taos_schemaless_insert_raw_ttl, "taos_schemaless_insert_raw_ttl");	26✔
227	LOAD_FUNC(fp_taos_schemaless_insert_raw_ttl_with_reqid, "taos_schemaless_insert_raw_ttl_with_reqid");	26✔
228	LOAD_FUNC(fp_taos_schemaless_insert_raw_ttl_with_reqid_tbname_key,	26✔
229	"taos_schemaless_insert_raw_ttl_with_reqid_tbname_key");
230	LOAD_FUNC(fp_taos_schemaless_insert_ttl_with_reqid_tbname_key, "taos_schemaless_insert_ttl_with_reqid_tbname_key");	26✔
231
232	LOAD_FUNC(fp_tmq_conf_new, "tmq_conf_new");	26✔
233	LOAD_FUNC(fp_tmq_conf_set, "tmq_conf_set");	26✔
234	LOAD_FUNC(fp_tmq_conf_destroy, "tmq_conf_destroy");	26✔
235	LOAD_FUNC(fp_tmq_conf_set_auto_commit_cb, "tmq_conf_set_auto_commit_cb");	26✔
236
237	LOAD_FUNC(fp_tmq_list_new, "tmq_list_new");	26✔
238	LOAD_FUNC(fp_tmq_list_append, "tmq_list_append");	26✔
239	LOAD_FUNC(fp_tmq_list_destroy, "tmq_list_destroy");	26✔
240	LOAD_FUNC(fp_tmq_list_get_size, "tmq_list_get_size");	26✔
241	LOAD_FUNC(fp_tmq_list_to_c_array, "tmq_list_to_c_array");	26✔
242
243	LOAD_FUNC(fp_tmq_consumer_new, "tmq_consumer_new");	26✔
244	LOAD_FUNC(fp_tmq_subscribe, "tmq_subscribe");	26✔
245	LOAD_FUNC(fp_tmq_unsubscribe, "tmq_unsubscribe");	26✔
246	LOAD_FUNC(fp_tmq_subscription, "tmq_subscription");	26✔
247	LOAD_FUNC(fp_tmq_consumer_poll, "tmq_consumer_poll");	26✔
248	LOAD_FUNC(fp_tmq_consumer_close, "tmq_consumer_close");	26✔
249	LOAD_FUNC(fp_tmq_commit_sync, "tmq_commit_sync");	26✔
250	LOAD_FUNC(fp_tmq_commit_async, "tmq_commit_async");	26✔
251	LOAD_FUNC(fp_tmq_commit_offset_sync, "tmq_commit_offset_sync");	26✔
252	LOAD_FUNC(fp_tmq_commit_offset_async, "tmq_commit_offset_async");	26✔
253	LOAD_FUNC(fp_tmq_get_topic_assignment, "tmq_get_topic_assignment");	26✔
254	LOAD_FUNC(fp_tmq_free_assignment, "tmq_free_assignment");	26✔
255	LOAD_FUNC(fp_tmq_offset_seek, "tmq_offset_seek");	26✔
256	LOAD_FUNC(fp_tmq_position, "tmq_position");	26✔
257	LOAD_FUNC(fp_tmq_committed, "tmq_committed");	26✔
258
259	LOAD_FUNC(fp_tmq_get_connect, "tmq_get_connect");	26✔
260	LOAD_FUNC(fp_tmq_get_table_name, "tmq_get_table_name");	26✔
261	LOAD_FUNC(fp_tmq_get_res_type, "tmq_get_res_type");	26✔
262	LOAD_FUNC(fp_tmq_get_topic_name, "tmq_get_topic_name");	26✔
263	LOAD_FUNC(fp_tmq_get_db_name, "tmq_get_db_name");	26✔
264	LOAD_FUNC(fp_tmq_get_vgroup_id, "tmq_get_vgroup_id");	26✔
265	LOAD_FUNC(fp_tmq_get_vgroup_offset, "tmq_get_vgroup_offset");	26✔
266	LOAD_FUNC(fp_tmq_err2str, "tmq_err2str");	26✔
267
268	LOAD_FUNC(fp_tmq_get_raw, "tmq_get_raw");	26✔
269	LOAD_FUNC(fp_tmq_write_raw, "tmq_write_raw");	26✔
270	LOAD_FUNC(fp_taos_write_raw_block, "taos_write_raw_block");	26✔
271	LOAD_FUNC(fp_taos_write_raw_block_with_reqid, "taos_write_raw_block_with_reqid");	26✔
272	LOAD_FUNC(fp_taos_write_raw_block_with_fields, "taos_write_raw_block_with_fields");	26✔
273	LOAD_FUNC(fp_taos_write_raw_block_with_fields_with_reqid, "taos_write_raw_block_with_fields_with_reqid");	26✔
274	LOAD_FUNC(fp_tmq_free_raw, "tmq_free_raw");	26✔
275
276	LOAD_FUNC(fp_tmq_get_json_meta, "tmq_get_json_meta");	26✔
277	LOAD_FUNC(fp_tmq_free_json_meta, "tmq_free_json_meta");	26✔
278
279	LOAD_FUNC(fp_taos_check_server_status, "taos_check_server_status");	26✔
280	LOAD_FUNC(fp_taos_write_crashinfo, "taos_write_crashinfo");	26✔
281	LOAD_FUNC(fp_getBuildInfo, "getBuildInfo");	26✔
282
283	LOAD_FUNC(fp_taos_connect_is_alive, "taos_connect_is_alive");	26✔
284
285	code = 0;	26✔
286
287	_OVER:	26✔
288	if (code != 0) {	26✔
289	printf("failed to load function %s from %s since %s [0x%X]\r\n", funcName, driverPath, terrstr(), terrno);	×
290	showWrapperHint(terrno);	×
291	taosDriverCleanup();	×
292	}
293
294	return code;	26✔
295	}
296
297	void taosDriverCleanup() {	×
298	if (tsDriver != NULL) {	×
299	taosCloseDll(tsDriver);	×
300	tsDriver = NULL;	×
301	}
302	}	×

taosdata / TDengine / #4986

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous