Skip to content

T
TDengine

taosdata / TDengine
大约 2 年 前同步成功

通知 1193
Star 22018
Fork 4786
T
TDengine
“ca8b7a2760be58670ad9388fddc99a1f4bb0d88a”上不存在“projects/stevenjoezhang”
提交 f1f5c0c4 编写于 作者: F freemine
浏览文件
操作

1. add SQLDriverConnect to let ODBC-aware software to communicate with 

   such as pyodbc
2. SQLDescribeCol
3. more DATA-TYPE-convertions in SQLGetData
上级 888e81ac
显示空白变更内容
内联 并排
Showing with 1843 addition and 419 deletion
src/CMakeLists.txt
浏览文件 @ f1f5c0c4
...@@ -21,5 +21,5 @@ ADD_SUBDIRECTORY(wal) ...@@ -21,5 +21,5 @@ ADD_SUBDIRECTORY(wal)
ADD_SUBDIRECTORY(cq) ADD_SUBDIRECTORY(cq)
ADD_SUBDIRECTORY(dnode) ADD_SUBDIRECTORY(dnode)
ADD_SUBDIRECTORY(connector/odbc) ADD_SUBDIRECTORY(connector/odbc)
ADD_SUBDIRECTORY(connector/jdbc) # ADD_SUBDIRECTORY(connector/jdbc)
src/connector/odbc/src/todbc.c
浏览文件 @ f1f5c0c4
...@@ -25,6 +25,7 @@ ...@@ -25,6 +25,7 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <time.h>
#define D(fmt, ...) \ #define D(fmt, ...) \
...@@ -87,6 +88,16 @@ do { \ ...@@ -87,6 +88,16 @@ do { \
obj->err.sql_state[0] = '\0'; \ obj->err.sql_state[0] = '\0'; \
} while (0) } while (0)
#define SET_UNSUPPORT_ERROR(obj, sqlstate, err_fmt, ...) \
do { \
SET_ERROR(obj, sqlstate, TSDB_CODE_COM_OPS_NOT_SUPPORT, err_fmt, ##__VA_ARGS__); \
} while (0) \
#define SET_HANDLE_INVALID(obj, sqlstate, err_fmt, ...) \
do { \
SET_ERROR(obj, sqlstate, TSDB_CODE_QRY_INVALID_QHANDLE, err_fmt, ##__VA_ARGS__); \
} while (0);
#define SDUP(s,n) (s ? (s[n] ? (const char*)strndup((const char*)s,n) : (const char*)s) : strdup("")) #define SDUP(s,n) (s ? (s[n] ? (const char*)strndup((const char*)s,n) : (const char*)s) : strdup(""))
#define SFRE(x,s,n) \ #define SFRE(x,s,n) \
do { \ do { \
...@@ -108,6 +119,25 @@ do { \ ...@@ -108,6 +119,25 @@ do { \
r_091c = SQL_SUCCESS; \ r_091c = SQL_SUCCESS; \
} while (0) } while (0)
#define PROFILING 0
#define PROFILE(statement) \
do { \
if (!PROFILING) { \
statement; \
break; \
} \
struct timeval tv0, tv1; \
gettimeofday(&tv0, NULL); \
statement; \
gettimeofday(&tv1, NULL); \
double delta = difftime(tv1.tv_sec, tv0.tv_sec); \
delta *= 1000000; \
delta += (tv1.tv_usec-tv0.tv_usec); \
delta /= 1000000; \
D("%s: elapsed: [%.6f]s", #statement, delta); \
} while (0)
typedef struct env_s env_t; typedef struct env_s env_t;
typedef struct conn_s conn_t; typedef struct conn_s conn_t;
typedef struct sql_s sql_t; typedef struct sql_s sql_t;
...@@ -116,8 +146,13 @@ typedef struct param_bind_s param_bind_t; ...@@ -116,8 +146,13 @@ typedef struct param_bind_s param_bind_t;
struct param_bind_s { struct param_bind_s {
SQLUSMALLINT ParameterNumber; SQLUSMALLINT ParameterNumber;
SQLSMALLINT ValueType;
SQLSMALLINT ParameterType;
SQLULEN LengthPrecision;
SQLSMALLINT ParameterScale;
SQLPOINTER ParameterValue; SQLPOINTER ParameterValue;
SQLLEN *StrLen_or_Ind; SQLLEN *StrLen_or_Ind;
unsigned int valid; unsigned int valid;
}; };
...@@ -158,13 +193,23 @@ struct sql_s { ...@@ -158,13 +193,23 @@ struct sql_s {
taos_error_t err; taos_error_t err;
}; };
typedef struct c_target_s c_target_t;
struct c_target_s {
SQLUSMALLINT col;
SQLSMALLINT ct; // c type: SQL_C_XXX
char *ptr;
SQLLEN len;
SQLLEN *soi;
};
static pthread_once_t init_once = PTHREAD_ONCE_INIT; static pthread_once_t init_once = PTHREAD_ONCE_INIT;
static void init_routine(void); static void init_routine(void);
static int do_field_display_size(TAOS_FIELD *field); static int do_field_display_size(TAOS_FIELD *field);
static void do_convert(SQLPOINTER TargetValue, SQLLEN BufferLength, SQLLEN *StrLen_or_Ind, TAOS_FIELD *field, void *row); static void do_convert(SQLPOINTER TargetValue, SQLLEN BufferLength, SQLLEN *StrLen_or_Ind, TAOS_FIELD *field, void *row);
SQLRETURN SQL_API SQLAllocEnv(SQLHENV *EnvironmentHandle) { static SQLRETURN doSQLAllocEnv(SQLHENV *EnvironmentHandle)
{
pthread_once(&init_once, init_routine); pthread_once(&init_once, init_routine);
env_t *env = (env_t*)calloc(1, sizeof(*env)); env_t *env = (env_t*)calloc(1, sizeof(*env));
...@@ -178,7 +223,15 @@ SQLRETURN SQL_API SQLAllocEnv(SQLHENV *EnvironmentHandle) { ...@@ -178,7 +223,15 @@ SQLRETURN SQL_API SQLAllocEnv(SQLHENV *EnvironmentHandle) {
return SQL_SUCCESS; return SQL_SUCCESS;
} }
SQLRETURN SQL_API SQLFreeEnv(SQLHENV EnvironmentHandle) { SQLRETURN SQL_API SQLAllocEnv(SQLHENV *EnvironmentHandle)
{
SQLRETURN r;
r = doSQLAllocEnv(EnvironmentHandle);
return r;
}
static SQLRETURN doSQLFreeEnv(SQLHENV EnvironmentHandle)
{
env_t *env = (env_t*)EnvironmentHandle; env_t *env = (env_t*)EnvironmentHandle;
if (!env) return SQL_ERROR; if (!env) return SQL_ERROR;
...@@ -197,8 +250,16 @@ SQLRETURN SQL_API SQLFreeEnv(SQLHENV EnvironmentHandle) { ...@@ -197,8 +250,16 @@ SQLRETURN SQL_API SQLFreeEnv(SQLHENV EnvironmentHandle) {
return SQL_SUCCESS; return SQL_SUCCESS;
} }
SQLRETURN SQL_API SQLAllocConnect(SQLHENV EnvironmentHandle, SQLRETURN SQL_API SQLFreeEnv(SQLHENV EnvironmentHandle)
SQLHDBC *ConnectionHandle) { {
SQLRETURN r;
r = doSQLFreeEnv(EnvironmentHandle);
return r;
}
static SQLRETURN doSQLAllocConnect(SQLHENV EnvironmentHandle,
SQLHDBC *ConnectionHandle)
{
env_t *env = (env_t*)EnvironmentHandle; env_t *env = (env_t*)EnvironmentHandle;
if (!env) return SQL_ERROR; if (!env) return SQL_ERROR;
...@@ -208,7 +269,7 @@ SQLRETURN SQL_API SQLAllocConnect(SQLHENV EnvironmentHandle, ...@@ -208,7 +269,7 @@ SQLRETURN SQL_API SQLAllocConnect(SQLHENV EnvironmentHandle,
do { do {
conn = (conn_t*)calloc(1, sizeof(*conn)); conn = (conn_t*)calloc(1, sizeof(*conn));
if (!conn) { if (!conn) {
SET_ERROR(env, "HY000", TSDB_CODE_COM_OUT_OF_MEMORY, "failed to alloc connection handle"); SET_ERROR(env, "HY000", TSDB_CODE_ODBC_OOM, "failed to alloc connection handle");
break; break;
} }
...@@ -225,7 +286,16 @@ SQLRETURN SQL_API SQLAllocConnect(SQLHENV EnvironmentHandle, ...@@ -225,7 +286,16 @@ SQLRETURN SQL_API SQLAllocConnect(SQLHENV EnvironmentHandle,
return SQL_ERROR; return SQL_ERROR;
} }
SQLRETURN SQL_API SQLFreeConnect(SQLHDBC ConnectionHandle) { SQLRETURN SQL_API SQLAllocConnect(SQLHENV EnvironmentHandle,
SQLHDBC *ConnectionHandle)
{
SQLRETURN r;
r = doSQLAllocConnect(EnvironmentHandle, ConnectionHandle);
return r;
}
static SQLRETURN doSQLFreeConnect(SQLHDBC ConnectionHandle)
{
conn_t *conn = (conn_t*)ConnectionHandle; conn_t *conn = (conn_t*)ConnectionHandle;
if (!conn) return SQL_ERROR; if (!conn) return SQL_ERROR;
...@@ -250,10 +320,18 @@ SQLRETURN SQL_API SQLFreeConnect(SQLHDBC ConnectionHandle) { ...@@ -250,10 +320,18 @@ SQLRETURN SQL_API SQLFreeConnect(SQLHDBC ConnectionHandle) {
return SQL_SUCCESS; return SQL_SUCCESS;
} }
SQLRETURN SQL_API SQLConnect(SQLHDBC ConnectionHandle, SQLRETURN SQL_API SQLFreeConnect(SQLHDBC ConnectionHandle)
{
SQLRETURN r;
r = doSQLFreeConnect(ConnectionHandle);
return r;
}
static SQLRETURN doSQLConnect(SQLHDBC ConnectionHandle,
SQLCHAR *ServerName, SQLSMALLINT NameLength1, SQLCHAR *ServerName, SQLSMALLINT NameLength1,
SQLCHAR *UserName, SQLSMALLINT NameLength2, SQLCHAR *UserName, SQLSMALLINT NameLength2,
SQLCHAR *Authentication, SQLSMALLINT NameLength3) { SQLCHAR *Authentication, SQLSMALLINT NameLength3)
{
conn_t *conn = (conn_t*)ConnectionHandle; conn_t *conn = (conn_t*)ConnectionHandle;
if (!conn) return SQL_ERROR; if (!conn) return SQL_ERROR;
...@@ -267,15 +345,16 @@ SQLRETURN SQL_API SQLConnect(SQLHDBC ConnectionHandle, ...@@ -267,15 +345,16 @@ SQLRETURN SQL_API SQLConnect(SQLHDBC ConnectionHandle,
const char *auth = SDUP(Authentication, NameLength3); const char *auth = SDUP(Authentication, NameLength3);
do { do {
if (!serverName || !userName || !auth) { if ((ServerName && !serverName) || (UserName && !userName) || (Authentication && !auth)) {
SET_ERROR(conn, "HY000", TSDB_CODE_COM_OUT_OF_MEMORY, "failed to connect to database"); SET_ERROR(conn, "HY000", TSDB_CODE_ODBC_OOM, "failed to allocate resources");
break; break;
} }
// TODO: data-race // TODO: data-race
// TODO: shall receive ip/port from odbc.ini // TODO: shall receive ip/port from odbc.ini
conn->taos = taos_connect("localhost", userName, auth, NULL, 0); conn->taos = taos_connect("localhost", userName, auth, NULL, 0);
if (!conn->taos) { if (!conn->taos) {
SET_ERROR(conn, "HY000", terrno, "failed to connect to database"); SET_ERROR(conn, "HY000", terrno, "failed to connect to data source");
break; break;
} }
} while (0); } while (0);
...@@ -287,7 +366,20 @@ SQLRETURN SQL_API SQLConnect(SQLHDBC ConnectionHandle, ...@@ -287,7 +366,20 @@ SQLRETURN SQL_API SQLConnect(SQLHDBC ConnectionHandle,
return conn->taos ? SQL_SUCCESS : SQL_ERROR; return conn->taos ? SQL_SUCCESS : SQL_ERROR;
} }
SQLRETURN SQL_API SQLDisconnect(SQLHDBC ConnectionHandle) { SQLRETURN SQL_API SQLConnect(SQLHDBC ConnectionHandle,
SQLCHAR *ServerName, SQLSMALLINT NameLength1,
SQLCHAR *UserName, SQLSMALLINT NameLength2,
SQLCHAR *Authentication, SQLSMALLINT NameLength3)
{
SQLRETURN r;
r = doSQLConnect(ConnectionHandle, ServerName, NameLength1,
UserName, NameLength2,
Authentication, NameLength3);
return r;
}
static SQLRETURN doSQLDisconnect(SQLHDBC ConnectionHandle)
{
conn_t *conn = (conn_t*)ConnectionHandle; conn_t *conn = (conn_t*)ConnectionHandle;
if (!conn) return SQL_ERROR; if (!conn) return SQL_ERROR;
...@@ -299,8 +391,16 @@ SQLRETURN SQL_API SQLDisconnect(SQLHDBC ConnectionHandle) { ...@@ -299,8 +391,16 @@ SQLRETURN SQL_API SQLDisconnect(SQLHDBC ConnectionHandle) {
return SQL_SUCCESS; return SQL_SUCCESS;
} }
SQLRETURN SQL_API SQLAllocStmt(SQLHDBC ConnectionHandle, SQLRETURN SQL_API SQLDisconnect(SQLHDBC ConnectionHandle)
SQLHSTMT *StatementHandle) { {
SQLRETURN r;
r = doSQLDisconnect(ConnectionHandle);
return r;
}
static SQLRETURN doSQLAllocStmt(SQLHDBC ConnectionHandle,
SQLHSTMT *StatementHandle)
{
conn_t *conn = (conn_t*)ConnectionHandle; conn_t *conn = (conn_t*)ConnectionHandle;
if (!conn) return SQL_ERROR; if (!conn) return SQL_ERROR;
...@@ -309,7 +409,7 @@ SQLRETURN SQL_API SQLAllocStmt(SQLHDBC ConnectionHandle, ...@@ -309,7 +409,7 @@ SQLRETURN SQL_API SQLAllocStmt(SQLHDBC ConnectionHandle,
do { do {
sql_t *sql = (sql_t*)calloc(1, sizeof(*sql)); sql_t *sql = (sql_t*)calloc(1, sizeof(*sql));
if (!sql) { if (!sql) {
SET_ERROR(conn, "HY000", TSDB_CODE_COM_OUT_OF_MEMORY, "failed to alloc statement handle"); SET_ERROR(conn, "HY000", TSDB_CODE_ODBC_OOM, "failed to alloc statement handle");
break; break;
} }
...@@ -326,13 +426,23 @@ SQLRETURN SQL_API SQLAllocStmt(SQLHDBC ConnectionHandle, ...@@ -326,13 +426,23 @@ SQLRETURN SQL_API SQLAllocStmt(SQLHDBC ConnectionHandle,
return SQL_ERROR; return SQL_ERROR;
} }
SQLRETURN SQL_API SQLFreeStmt(SQLHSTMT StatementHandle, SQLRETURN SQL_API SQLAllocStmt(SQLHDBC ConnectionHandle,
SQLUSMALLINT Option) { SQLHSTMT *StatementHandle)
{
SQLRETURN r;
r = doSQLAllocStmt(ConnectionHandle, StatementHandle);
return r;
}
static SQLRETURN doSQLFreeStmt(SQLHSTMT StatementHandle,
SQLUSMALLINT Option)
{
sql_t *sql = (sql_t*)StatementHandle; sql_t *sql = (sql_t*)StatementHandle;
if (!sql) return SQL_ERROR; if (!sql) return SQL_ERROR;
if (Option == SQL_CLOSE) return SQL_SUCCESS;
if (Option != SQL_DROP) { if (Option != SQL_DROP) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "failed to free statement"); SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "free statement with Option[%x] not supported yet", Option);
return SQL_ERROR; return SQL_ERROR;
} }
...@@ -370,12 +480,29 @@ SQLRETURN SQL_API SQLFreeStmt(SQLHSTMT StatementHandle, ...@@ -370,12 +480,29 @@ SQLRETURN SQL_API SQLFreeStmt(SQLHSTMT StatementHandle,
return SQL_SUCCESS; return SQL_SUCCESS;
} }
SQLRETURN SQL_API SQLExecDirect(SQLHSTMT StatementHandle, SQLRETURN SQL_API SQLFreeStmt(SQLHSTMT StatementHandle,
SQLCHAR *StatementText, SQLINTEGER TextLength) { SQLUSMALLINT Option)
{
SQLRETURN r;
r = doSQLFreeStmt(StatementHandle, Option);
return r;
}
static SQLRETURN doSQLExecDirect(SQLHSTMT StatementHandle,
SQLCHAR *StatementText, SQLINTEGER TextLength)
{
sql_t *sql = (sql_t*)StatementHandle; sql_t *sql = (sql_t*)StatementHandle;
if (!sql) return SQL_ERROR; if (!sql) return SQL_ERROR;
if (!sql->conn) return SQL_ERROR;
if (!sql->conn->taos) return SQL_ERROR; if (!sql->conn) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection yet");
return SQL_ERROR;
}
if (!sql->conn->taos) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection to data source yet");
return SQL_ERROR;
}
if (sql->rs) { if (sql->rs) {
taos_free_result(sql->rs); taos_free_result(sql->rs);
...@@ -404,7 +531,7 @@ SQLRETURN SQL_API SQLExecDirect(SQLHSTMT StatementHandle, ...@@ -404,7 +531,7 @@ SQLRETURN SQL_API SQLExecDirect(SQLHSTMT StatementHandle,
SQLRETURN r = SQL_ERROR; SQLRETURN r = SQL_ERROR;
do { do {
if (!stxt) { if (!stxt) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OUT_OF_MEMORY, "failed to query"); SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_OOM, "failed to allocate resources");
break; break;
} }
sql->rs = taos_query(sql->conn->taos, stxt); sql->rs = taos_query(sql->conn->taos, stxt);
...@@ -416,13 +543,34 @@ SQLRETURN SQL_API SQLExecDirect(SQLHSTMT StatementHandle, ...@@ -416,13 +543,34 @@ SQLRETURN SQL_API SQLExecDirect(SQLHSTMT StatementHandle,
return r; return r;
} }
SQLRETURN SQL_API SQLNumResultCols(SQLHSTMT StatementHandle, SQLRETURN SQL_API SQLExecDirect(SQLHSTMT StatementHandle,
SQLSMALLINT *ColumnCount) { SQLCHAR *StatementText, SQLINTEGER TextLength)
{
SQLRETURN r;
r = doSQLExecDirect(StatementHandle, StatementText, TextLength);
return r;
}
static SQLRETURN doSQLNumResultCols(SQLHSTMT StatementHandle,
SQLSMALLINT *ColumnCount)
{
sql_t *sql = (sql_t*)StatementHandle; sql_t *sql = (sql_t*)StatementHandle;
if (!sql) return SQL_ERROR; if (!sql) return SQL_ERROR;
if (!sql->conn) return SQL_ERROR;
if (!sql->conn->taos) return SQL_ERROR; if (!sql->conn) {
if (!sql->rs) return SQL_ERROR; SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection yet");
return SQL_ERROR;
}
if (!sql->conn->taos) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection to data source yet");
return SQL_ERROR;
}
if (!sql->rs) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_QUERY_CACHE_ERASED, "no result set cached or not ready");
return SQL_ERROR;
}
int fields = taos_field_count(sql->rs); int fields = taos_field_count(sql->rs);
if (ColumnCount) { if (ColumnCount) {
...@@ -432,13 +580,35 @@ SQLRETURN SQL_API SQLNumResultCols(SQLHSTMT StatementHandle, ...@@ -432,13 +580,35 @@ SQLRETURN SQL_API SQLNumResultCols(SQLHSTMT StatementHandle,
return SQL_SUCCESS; return SQL_SUCCESS;
} }
SQLRETURN SQL_API SQLRowCount(SQLHSTMT StatementHandle, SQLRETURN SQL_API SQLNumResultCols(SQLHSTMT StatementHandle,
SQLLEN *RowCount) { SQLSMALLINT *ColumnCount)
{
SQLRETURN r;
r = doSQLNumResultCols(StatementHandle, ColumnCount);
return r;
}
static SQLRETURN doSQLRowCount(SQLHSTMT StatementHandle,
SQLLEN *RowCount)
{
sql_t *sql = (sql_t*)StatementHandle; sql_t *sql = (sql_t*)StatementHandle;
if (!sql) return SQL_ERROR; if (!sql) return SQL_ERROR;
if (!sql->conn) return SQL_ERROR;
if (!sql->conn->taos) return SQL_ERROR; if (!sql->conn) {
if (!sql->rs) return SQL_ERROR; SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection yet");
return SQL_ERROR;
}
if (!sql->conn->taos) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection to data source yet");
return SQL_ERROR;
}
if (!sql->rs) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_QUERY_CACHE_ERASED, "no result set cached or not ready");
return SQL_ERROR;
}
int rows = taos_affected_rows(sql->rs); int rows = taos_affected_rows(sql->rs);
if (RowCount) { if (RowCount) {
*RowCount = rows; *RowCount = rows;
...@@ -446,20 +616,60 @@ SQLRETURN SQL_API SQLRowCount(SQLHSTMT StatementHandle, ...@@ -446,20 +616,60 @@ SQLRETURN SQL_API SQLRowCount(SQLHSTMT StatementHandle,
return SQL_SUCCESS; return SQL_SUCCESS;
} }
SQLRETURN SQL_API SQLColAttribute(SQLHSTMT StatementHandle, SQLRETURN SQL_API SQLRowCount(SQLHSTMT StatementHandle,
SQLLEN *RowCount)
{
SQLRETURN r;
r = doSQLRowCount(StatementHandle, RowCount);
return r;
}
static SQLRETURN doSQLColAttribute(SQLHSTMT StatementHandle,
SQLUSMALLINT ColumnNumber, SQLUSMALLINT FieldIdentifier, SQLUSMALLINT ColumnNumber, SQLUSMALLINT FieldIdentifier,
SQLPOINTER CharacterAttribute, SQLSMALLINT BufferLength, SQLPOINTER CharacterAttribute, SQLSMALLINT BufferLength,
SQLSMALLINT *StringLength, SQLLEN *NumericAttribute ) { SQLSMALLINT *StringLength, SQLLEN *NumericAttribute )
{
D("......");
sql_t *sql = (sql_t*)StatementHandle; sql_t *sql = (sql_t*)StatementHandle;
if (!sql) return SQL_ERROR; if (!sql) return SQL_ERROR;
if (!sql->conn) return SQL_ERROR;
if (!sql->conn->taos) return SQL_ERROR; if (!sql->conn) {
if (!sql->rs) return SQL_ERROR; SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection yet");
return SQL_ERROR;
}
if (!sql->conn->taos) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection to data source yet");
return SQL_ERROR;
}
if (!sql->rs) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_QUERY_CACHE_ERASED, "no result set cached or not ready");
return SQL_ERROR;
}
int nfields = taos_field_count(sql->rs); int nfields = taos_field_count(sql->rs);
TAOS_FIELD *fields = taos_fetch_fields(sql->rs); TAOS_FIELD *fields = taos_fetch_fields(sql->rs);
if (nfields==0 || fields==NULL) return SQL_ERROR; if (nfields==0 || fields==NULL) {
if (ColumnNumber>nfields) return SQL_ERROR; SET_ERROR(sql, "HY000", TSDB_CODE_MND_FIELD_NOT_EXIST, "no fields in result set");
return SQL_ERROR;
}
if (ColumnNumber<0) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_APP_ERROR, "ColumnNumber[%d] underflow", ColumnNumber);
return SQL_ERROR;
}
if (ColumnNumber==0) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "ColumnNumber[0] not supported");
return SQL_ERROR;
}
if (ColumnNumber>nfields) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_APP_ERROR, "ColumnNumber[%d] overflow", ColumnNumber);
return SQL_ERROR;
}
TAOS_FIELD *field = fields + ColumnNumber-1; TAOS_FIELD *field = fields + ColumnNumber-1;
...@@ -468,65 +678,454 @@ SQLRETURN SQL_API SQLColAttribute(SQLHSTMT StatementHandle, ...@@ -468,65 +678,454 @@ SQLRETURN SQL_API SQLColAttribute(SQLHSTMT StatementHandle,
*NumericAttribute = do_field_display_size(field); *NumericAttribute = do_field_display_size(field);
} break; } break;
case SQL_COLUMN_LABEL: { case SQL_COLUMN_LABEL: {
strncpy(CharacterAttribute, field->name, field->bytes); size_t n = sizeof(field->name);
strncpy(CharacterAttribute, field->name, (n>BufferLength ? BufferLength : n));
} break;
case SQL_COLUMN_UNSIGNED: {
*NumericAttribute = SQL_FALSE;
} break; } break;
default: { default: {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT,
"ColumnNumber[%d] FieldIdentifier[%d] not supported yet",
ColumnNumber, FieldIdentifier);
return SQL_ERROR; return SQL_ERROR;
} break; } break;
} }
return SQL_SUCCESS; return SQL_SUCCESS;
} }
SQLRETURN SQL_API SQLGetData(SQLHSTMT StatementHandle, SQLRETURN SQL_API SQLColAttribute(SQLHSTMT StatementHandle,
SQLUSMALLINT ColumnNumber, SQLUSMALLINT FieldIdentifier,
SQLPOINTER CharacterAttribute, SQLSMALLINT BufferLength,
SQLSMALLINT *StringLength, SQLLEN *NumericAttribute )
{
SQLRETURN r;
r = doSQLColAttribute(StatementHandle, ColumnNumber, FieldIdentifier,
CharacterAttribute, BufferLength,
StringLength, NumericAttribute);
return r;
}
static SQLRETURN conv_tsdb_bool_to_c_bit(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
static SQLRETURN conv_tsdb_bool_to_c_tinyint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
static SQLRETURN conv_tsdb_bool_to_c_short(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
static SQLRETURN conv_tsdb_bool_to_c_long(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
static SQLRETURN conv_tsdb_bool_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
static SQLRETURN conv_tsdb_bool_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
static SQLRETURN conv_tsdb_bool_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
static SQLRETURN conv_tsdb_bool_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
static SQLRETURN conv_tsdb_bool_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
static SQLRETURN conv_tsdb_v1_to_c_tinyint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1);
static SQLRETURN conv_tsdb_v1_to_c_short(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1);
static SQLRETURN conv_tsdb_v1_to_c_long(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1);
static SQLRETURN conv_tsdb_v1_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1);
static SQLRETURN conv_tsdb_v1_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1);
static SQLRETURN conv_tsdb_v1_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1);
static SQLRETURN conv_tsdb_v1_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1);
static SQLRETURN conv_tsdb_v1_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1);
static SQLRETURN conv_tsdb_v2_to_c_short(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2);
static SQLRETURN conv_tsdb_v2_to_c_long(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2);
static SQLRETURN conv_tsdb_v2_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2);
static SQLRETURN conv_tsdb_v2_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2);
static SQLRETURN conv_tsdb_v2_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2);
static SQLRETURN conv_tsdb_v2_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2);
static SQLRETURN conv_tsdb_v2_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2);
static SQLRETURN conv_tsdb_v4_to_c_long(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4);
static SQLRETURN conv_tsdb_v4_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4);
static SQLRETURN conv_tsdb_v4_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4);
static SQLRETURN conv_tsdb_v4_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4);
static SQLRETURN conv_tsdb_v4_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4);
static SQLRETURN conv_tsdb_v4_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4);
static SQLRETURN conv_tsdb_v8_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8);
static SQLRETURN conv_tsdb_v8_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8);
static SQLRETURN conv_tsdb_v8_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8);
static SQLRETURN conv_tsdb_v8_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8);
static SQLRETURN conv_tsdb_v8_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8);
static SQLRETURN conv_tsdb_f4_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, float f4);
static SQLRETURN conv_tsdb_f4_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, float f4);
static SQLRETURN conv_tsdb_f4_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, float f4);
static SQLRETURN conv_tsdb_f4_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, float f4);
static SQLRETURN conv_tsdb_f8_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, double f8);
static SQLRETURN conv_tsdb_f8_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, double f8);
static SQLRETURN conv_tsdb_f8_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, double f8);
static SQLRETURN conv_tsdb_ts_to_c_v8(sql_t *sql, c_target_t *target, TAOS_FIELD *field, TIMESTAMP_STRUCT *ts);
static SQLRETURN conv_tsdb_ts_to_c_str(sql_t *sql, c_target_t *target, TAOS_FIELD *field, TIMESTAMP_STRUCT *ts);
static SQLRETURN conv_tsdb_ts_to_c_bin(sql_t *sql, c_target_t *target, TAOS_FIELD *field, TIMESTAMP_STRUCT *ts);
static SQLRETURN conv_tsdb_ts_to_c_ts(sql_t *sql, c_target_t *target, TAOS_FIELD *field, TIMESTAMP_STRUCT *ts);
static SQLRETURN conv_tsdb_bin_to_c_str(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const unsigned char *bin);
static SQLRETURN conv_tsdb_bin_to_c_bin(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const unsigned char *bin);
static SQLRETURN conv_tsdb_str_to_c_bit(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
static SQLRETURN conv_tsdb_str_to_c_v1(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
static SQLRETURN conv_tsdb_str_to_c_v2(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
static SQLRETURN conv_tsdb_str_to_c_v4(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
static SQLRETURN conv_tsdb_str_to_c_v8(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
static SQLRETURN conv_tsdb_str_to_c_f4(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
static SQLRETURN conv_tsdb_str_to_c_f8(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
static SQLRETURN conv_tsdb_str_to_c_str(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
static SQLRETURN conv_tsdb_str_to_c_bin(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
static SQLRETURN doSQLGetData(SQLHSTMT StatementHandle,
SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType, SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
SQLPOINTER TargetValue, SQLLEN BufferLength, SQLPOINTER TargetValue, SQLLEN BufferLength,
SQLLEN *StrLen_or_Ind) { SQLLEN *StrLen_or_Ind)
{
sql_t *sql = (sql_t*)StatementHandle; sql_t *sql = (sql_t*)StatementHandle;
if (!sql) return SQL_ERROR; if (!sql) return SQL_ERROR;
if (!sql->conn) return SQL_ERROR;
if (!sql->conn->taos) return SQL_ERROR; if (!sql->conn) {
if (!sql->rs) return SQL_ERROR; SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection yet");
if (!sql->row) return SQL_ERROR; return SQL_ERROR;
}
if (!sql->conn->taos) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection to data source yet");
return SQL_ERROR;
}
if (!sql->rs) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_QUERY_CACHE_ERASED, "no result set cached or not ready");
return SQL_ERROR;
}
if (!sql->row) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_QUERY_CACHE_ERASED, "no rows cached or not ready");
return SQL_ERROR;
}
DASSERT(TargetValue);
int nfields = taos_field_count(sql->rs); int nfields = taos_field_count(sql->rs);
TAOS_FIELD *fields = taos_fetch_fields(sql->rs); TAOS_FIELD *fields = taos_fetch_fields(sql->rs);
if (nfields==0 || fields==NULL) return SQL_ERROR; if (nfields==0 || fields==NULL) {
if (ColumnNumber>nfields) return SQL_ERROR; SET_ERROR(sql, "HY000", TSDB_CODE_MND_FIELD_NOT_EXIST, "no fields in result set");
return SQL_ERROR;
}
if (ColumnNumber<0) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_APP_ERROR, "ColumnNumber[%d] underflow", ColumnNumber);
return SQL_ERROR;
}
if (ColumnNumber==0) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "ColumnNumber[0] not supported");
return SQL_ERROR;
}
if (ColumnNumber>nfields) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_APP_ERROR, "ColumnNumber[%d] overflow", ColumnNumber);
return SQL_ERROR;
}
TAOS_FIELD *field = fields + ColumnNumber-1; TAOS_FIELD *field = fields + ColumnNumber-1;
void *row = sql->row[ColumnNumber-1];
if (!row) {
if (StrLen_or_Ind) {
*StrLen_or_Ind = SQL_NULL_DATA;
}
return SQL_SUCCESS;
}
c_target_t target = {0};
target.col = ColumnNumber;
target.ct = TargetType;
target.ptr = TargetValue;
target.len = BufferLength;
target.soi = StrLen_or_Ind;
SQLRETURN r = SQL_ERROR;
switch (field->type) {
case TSDB_DATA_TYPE_BOOL: {
int8_t v = *(int8_t*)row;
if (v) v = 1;
switch (target.ct) {
case SQL_C_BIT: return conv_tsdb_bool_to_c_bit(sql, &target, field, v);
case SQL_C_TINYINT: return conv_tsdb_bool_to_c_tinyint(sql, &target, field, v);
case SQL_C_SHORT: return conv_tsdb_bool_to_c_short(sql, &target, field, v);
case SQL_C_LONG: return conv_tsdb_bool_to_c_long(sql, &target, field, v);
case SQL_C_SBIGINT: return conv_tsdb_bool_to_c_sbigint(sql, &target, field, v);
case SQL_C_FLOAT: return conv_tsdb_bool_to_c_float(sql, &target, field, v);
case SQL_C_DOUBLE: return conv_tsdb_bool_to_c_double(sql, &target, field, v);
case SQL_C_CHAR: return conv_tsdb_bool_to_c_char(sql, &target, field, v);
case SQL_C_BINARY: return conv_tsdb_bool_to_c_binary(sql, &target, field, v);
default: {
SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_CONV_NOT_SUPPORT, "from TSDB_DATA_TYPE [%d] to SQL_C_TYPE [%d] not supported", field->type, target.ct);
return SQL_ERROR;
}
}
} break;
case TSDB_DATA_TYPE_TINYINT: {
int8_t v = *(int8_t*)row;
switch (target.ct) {
case SQL_C_TINYINT: return conv_tsdb_v1_to_c_tinyint(sql, &target, field, v);
case SQL_C_SHORT: return conv_tsdb_v1_to_c_short(sql, &target, field, v);
case SQL_C_LONG: return conv_tsdb_v1_to_c_long(sql, &target, field, v);
case SQL_C_SBIGINT: return conv_tsdb_v1_to_c_sbigint(sql, &target, field, v);
case SQL_C_FLOAT: return conv_tsdb_v1_to_c_float(sql, &target, field, v);
case SQL_C_DOUBLE: return conv_tsdb_v1_to_c_double(sql, &target, field, v);
case SQL_C_CHAR: return conv_tsdb_v1_to_c_char(sql, &target, field, v);
case SQL_C_BINARY: return conv_tsdb_v1_to_c_binary(sql, &target, field, v);
default: {
SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_CONV_NOT_SUPPORT, "from TSDB_DATA_TYPE [%d] to SQL_C_TYPE [%d] not supported", field->type, target.ct);
return SQL_ERROR;
}
}
} break;
case TSDB_DATA_TYPE_SMALLINT: {
int16_t v = *(int16_t*)row;
switch (target.ct) {
case SQL_C_SHORT: return conv_tsdb_v2_to_c_short(sql, &target, field, v);
case SQL_C_LONG: return conv_tsdb_v2_to_c_long(sql, &target, field, v);
case SQL_C_SBIGINT: return conv_tsdb_v2_to_c_sbigint(sql, &target, field, v);
case SQL_C_FLOAT: return conv_tsdb_v2_to_c_float(sql, &target, field, v);
case SQL_C_DOUBLE: return conv_tsdb_v2_to_c_double(sql, &target, field, v);
case SQL_C_CHAR: return conv_tsdb_v2_to_c_char(sql, &target, field, v);
case SQL_C_BINARY: return conv_tsdb_v2_to_c_binary(sql, &target, field, v);
default: {
SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_CONV_NOT_SUPPORT, "from TSDB_DATA_TYPE [%d] to SQL_C_TYPE [%d] not supported", field->type, target.ct);
return SQL_ERROR;
}
}
} break;
case TSDB_DATA_TYPE_INT: {
int32_t v = *(int32_t*)row;
switch (target.ct) {
case SQL_C_LONG: return conv_tsdb_v4_to_c_long(sql, &target, field, v);
case SQL_C_SBIGINT: return conv_tsdb_v4_to_c_sbigint(sql, &target, field, v);
case SQL_C_FLOAT: return conv_tsdb_v4_to_c_float(sql, &target, field, v);
case SQL_C_DOUBLE: return conv_tsdb_v4_to_c_double(sql, &target, field, v);
case SQL_C_CHAR: return conv_tsdb_v4_to_c_char(sql, &target, field, v);
case SQL_C_BINARY: return conv_tsdb_v4_to_c_binary(sql, &target, field, v);
default: {
SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_CONV_NOT_SUPPORT, "from TSDB_DATA_TYPE [%d] to SQL_C_TYPE [%d] not supported", field->type, target.ct);
return SQL_ERROR;
}
}
} break;
case TSDB_DATA_TYPE_BIGINT: {
int64_t v = *(int64_t*)row;
switch (target.ct) {
case SQL_C_SBIGINT: return conv_tsdb_v8_to_c_sbigint(sql, &target, field, v);
case SQL_C_FLOAT: return conv_tsdb_v8_to_c_float(sql, &target, field, v);
case SQL_C_DOUBLE: return conv_tsdb_v8_to_c_double(sql, &target, field, v);
case SQL_C_CHAR: return conv_tsdb_v8_to_c_char(sql, &target, field, v);
case SQL_C_BINARY: return conv_tsdb_v8_to_c_binary(sql, &target, field, v);
default: {
SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_CONV_NOT_SUPPORT, "from TSDB_DATA_TYPE [%d] to SQL_C_TYPE [%d] not supported", field->type, target.ct);
return SQL_ERROR;
}
}
} break;
case TSDB_DATA_TYPE_FLOAT: {
float v = *(float*)row;
switch (target.ct) {
case SQL_C_FLOAT: return conv_tsdb_f4_to_c_float(sql, &target, field, v);
case SQL_C_DOUBLE: return conv_tsdb_f4_to_c_double(sql, &target, field, v);
case SQL_C_CHAR: return conv_tsdb_f4_to_c_char(sql, &target, field, v);
case SQL_C_BINARY: return conv_tsdb_f4_to_c_binary(sql, &target, field, v);
default: {
SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_CONV_NOT_SUPPORT, "from TSDB_DATA_TYPE [%d] to SQL_C_TYPE [%d] not supported", field->type, target.ct);
return SQL_ERROR;
}
}
} break;
case TSDB_DATA_TYPE_DOUBLE: {
double v = *(double*)row;
switch (target.ct) {
case SQL_C_DOUBLE: return conv_tsdb_f8_to_c_double(sql, &target, field, v);
case SQL_C_CHAR: return conv_tsdb_f8_to_c_char(sql, &target, field, v);
case SQL_C_BINARY: return conv_tsdb_f8_to_c_binary(sql, &target, field, v);
default: {
SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_CONV_NOT_SUPPORT, "from TSDB_DATA_TYPE [%d] to SQL_C_TYPE [%d] not supported", field->type, target.ct);
return SQL_ERROR;
}
}
} break;
case TSDB_DATA_TYPE_TIMESTAMP: {
TIMESTAMP_STRUCT ts = {0};
int64_t v = *(int64_t*)row;
time_t t = v/1000;
struct tm tm = {0};
localtime_r(&t, &tm);
ts.year = tm.tm_year + 1900;
ts.month = tm.tm_mon + 1;
ts.day = tm.tm_mday;
ts.hour = tm.tm_hour;
ts.minute = tm.tm_min;
ts.second = tm.tm_sec;
ts.fraction = v%1000;
switch (target.ct) {
case SQL_C_SBIGINT: return conv_tsdb_ts_to_c_v8(sql, &target, field, &ts);
case SQL_C_CHAR: return conv_tsdb_ts_to_c_str(sql, &target, field, &ts);
case SQL_C_BINARY: return conv_tsdb_ts_to_c_bin(sql, &target, field, &ts);
case SQL_C_TIMESTAMP: return conv_tsdb_ts_to_c_ts(sql, &target, field, &ts);
default: {
SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_CONV_NOT_SUPPORT, "from TSDB_DATA_TYPE [%d] to SQL_C_TYPE [%d] not supported", field->type, target.ct);
return SQL_ERROR;
}
}
} break;
case TSDB_DATA_TYPE_BINARY: {
const unsigned char *bin = (const unsigned char *)row;
switch (target.ct) {
case SQL_C_CHAR: return conv_tsdb_bin_to_c_str(sql, &target, field, bin);
case SQL_C_BINARY: return conv_tsdb_bin_to_c_bin(sql, &target, field, bin);
default: {
SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_CONV_NOT_SUPPORT, "from TSDB_DATA_TYPE [%d] to SQL_C_TYPE [%d] not supported", field->type, target.ct);
return SQL_ERROR;
}
}
} break;
case TSDB_DATA_TYPE_NCHAR: {
const char *str = (const char *)row;
switch (target.ct) {
case SQL_C_BIT: return conv_tsdb_str_to_c_bit(sql, &target, field, str);
case SQL_C_TINYINT: return conv_tsdb_str_to_c_v1(sql, &target, field, str);
case SQL_C_SHORT: return conv_tsdb_str_to_c_v2(sql, &target, field, str);
case SQL_C_LONG: return conv_tsdb_str_to_c_v4(sql, &target, field, str);
case SQL_C_SBIGINT: return conv_tsdb_str_to_c_v8(sql, &target, field, str);
case SQL_C_FLOAT: return conv_tsdb_str_to_c_f4(sql, &target, field, str);
case SQL_C_DOUBLE: return conv_tsdb_str_to_c_f8(sql, &target, field, str);
case SQL_C_CHAR: return conv_tsdb_str_to_c_str(sql, &target, field, str);
case SQL_C_BINARY: return conv_tsdb_str_to_c_bin(sql, &target, field, str);
default: {
SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_CONV_NOT_SUPPORT, "from TSDB_DATA_TYPE [%d] to SQL_C_TYPE [%d] not supported", field->type, target.ct);
return SQL_ERROR;
}
}
} break;
default: {
SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_CONV_NOT_SUPPORT, "field [@%d] type [%d] not supported yet", ColumnNumber, field->type);
return SQL_ERROR;
} break;
}
if (1) return r;
switch (TargetType) { switch (TargetType) {
case SQL_CHAR: { case SQL_C_CHAR: {
if (sql->row[ColumnNumber-1]) { do_convert(TargetValue, BufferLength, StrLen_or_Ind, field, row);
do_convert(TargetValue, BufferLength, StrLen_or_Ind, field, sql->row[ColumnNumber-1]); } break;
*StrLen_or_Ind = SQL_NTS; case SQL_C_TIMESTAMP: {
TIMESTAMP_STRUCT ts = {0};
DASSERT(BufferLength == sizeof(ts));
int64_t v = *(int64_t*)row;
time_t t = v/1000;
struct tm tm = {0};
localtime_r(&t, &tm);
ts.year = tm.tm_year + 1900;
ts.month = tm.tm_mon + 1;
ts.day = tm.tm_mday;
ts.hour = tm.tm_hour;
ts.minute = tm.tm_min;
ts.second = tm.tm_sec;
ts.fraction = 0;
memcpy(TargetValue, &ts, sizeof(ts));
} break;
case SQL_C_LONG: {
int32_t v = *(int32_t*)row;
DASSERT(BufferLength == sizeof(v));
memcpy(TargetValue, &v, sizeof(v));
} break;
case SQL_C_SBIGINT: {
int64_t v = *(int64_t*)row;
DASSERT(BufferLength == sizeof(v));
memcpy(TargetValue, &v, sizeof(v));
} break;
case SQL_C_FLOAT: {
float v = *(float*)row;
DASSERT(BufferLength == sizeof(v));
memcpy(TargetValue, &v, sizeof(v));
} break;
case SQL_C_DOUBLE: {
double v = *(double*)row;
DASSERT(BufferLength == sizeof(v));
memcpy(TargetValue, &v, sizeof(v));
} break;
case SQL_C_BINARY: {
if (StrLen_or_Ind) {
if (field->type == TSDB_DATA_TYPE_NCHAR) {
*StrLen_or_Ind = strnlen((const char*)row, field->bytes);
} else { } else {
*StrLen_or_Ind = SQL_NULL_DATA; *StrLen_or_Ind = field->bytes;
}
} }
size_t n = field->bytes;
if (n>BufferLength) n = BufferLength;
memcpy(TargetValue, (const char*)row, n);
} break; } break;
default: { default: {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT,
"ColumnNumber[%d] TargetType[%d] BufferLength[%ld] not supported yet",
ColumnNumber, TargetType, BufferLength);
return SQL_ERROR; return SQL_ERROR;
} break; } break;
} }
return SQL_SUCCESS; return SQL_SUCCESS;
} }
SQLRETURN SQL_API SQLFetch(SQLHSTMT StatementHandle) { SQLRETURN SQL_API SQLGetData(SQLHSTMT StatementHandle,
SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
SQLPOINTER TargetValue, SQLLEN BufferLength,
SQLLEN *StrLen_or_Ind)
{
SQLRETURN r;
r = doSQLGetData(StatementHandle, ColumnNumber, TargetType,
TargetValue, BufferLength,
StrLen_or_Ind);
return r;
}
static SQLRETURN doSQLFetch(SQLHSTMT StatementHandle)
{
sql_t *sql = (sql_t*)StatementHandle; sql_t *sql = (sql_t*)StatementHandle;
if (!sql) return SQL_ERROR; if (!sql) return SQL_ERROR;
if (!sql->conn) return SQL_ERROR;
if (!sql->conn->taos) return SQL_ERROR; if (!sql->conn) {
if (!sql->rs) return SQL_ERROR; SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection yet");
return SQL_ERROR;
}
if (!sql->conn->taos) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection to data source yet");
return SQL_ERROR;
}
if (!sql->rs) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_QUERY_CACHE_ERASED, "no result set cached or not ready");
return SQL_ERROR;
}
sql->row = taos_fetch_row(sql->rs); sql->row = taos_fetch_row(sql->rs);
return sql->row ? SQL_SUCCESS : SQL_NO_DATA; return sql->row ? SQL_SUCCESS : SQL_NO_DATA;
} }
SQLRETURN SQL_API SQLPrepare(SQLHSTMT StatementHandle, SQLRETURN SQL_API SQLFetch(SQLHSTMT StatementHandle)
SQLCHAR *StatementText, SQLINTEGER TextLength) { {
SQLRETURN r;
r = doSQLFetch(StatementHandle);
return r;
}
static SQLRETURN doSQLPrepare(SQLHSTMT StatementHandle,
SQLCHAR *StatementText, SQLINTEGER TextLength)
{
sql_t *sql = (sql_t*)StatementHandle; sql_t *sql = (sql_t*)StatementHandle;
if (!sql) return SQL_ERROR; if (!sql) return SQL_ERROR;
if (!sql->conn) return SQL_ERROR;
if (!sql->conn->taos) return SQL_ERROR; if (!sql->conn) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection yet");
return SQL_ERROR;
}
if (!sql->conn->taos) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection to data source yet");
return SQL_ERROR;
}
if (sql->rs) { if (sql->rs) {
taos_free_result(sql->rs); taos_free_result(sql->rs);
...@@ -568,17 +1167,38 @@ SQLRETURN SQL_API SQLPrepare(SQLHSTMT StatementHandle, ...@@ -568,17 +1167,38 @@ SQLRETURN SQL_API SQLPrepare(SQLHSTMT StatementHandle,
return sql->stmt ? SQL_SUCCESS : SQL_ERROR; return sql->stmt ? SQL_SUCCESS : SQL_ERROR;
} }
SQLRETURN SQL_API SQLExecute(SQLHSTMT StatementHandle) { SQLRETURN SQL_API SQLPrepare(SQLHSTMT StatementHandle,
SQLCHAR *StatementText, SQLINTEGER TextLength)
{
SQLRETURN r;
r = doSQLPrepare(StatementHandle, StatementText, TextLength);
return r;
}
static SQLRETURN doSQLExecute(SQLHSTMT StatementHandle)
{
sql_t *sql = (sql_t*)StatementHandle; sql_t *sql = (sql_t*)StatementHandle;
if (!sql) return SQL_ERROR; if (!sql) return SQL_ERROR;
if (!sql->conn) return SQL_ERROR;
if (!sql->conn->taos) return SQL_ERROR;
if (!sql->stmt) return SQL_ERROR;
if (sql->rs) { if (!sql->conn) {
taos_free_result(sql->rs); SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection yet");
sql->rs = NULL; return SQL_ERROR;
sql->row = NULL; }
if (!sql->conn->taos) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection to data source yet");
return SQL_ERROR;
}
if (!sql->stmt) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_SQL, "no statement cached or not ready");
return SQL_ERROR;
}
if (sql->rs) {
taos_free_result(sql->rs);
sql->rs = NULL;
sql->row = NULL;
} }
int r = 0; int r = 0;
...@@ -635,20 +1255,20 @@ SQLRETURN SQL_API SQLExecute(SQLHSTMT StatementHandle) { ...@@ -635,20 +1255,20 @@ SQLRETURN SQL_API SQLExecute(SQLHSTMT StatementHandle) {
} }
if (sql->n_params > 0) { if (sql->n_params > 0) {
r = taos_stmt_bind_param(sql->stmt, sql->binds); PROFILE(r = taos_stmt_bind_param(sql->stmt, sql->binds));
if (r) { if (r) {
SET_ERROR(sql, "HY000", r, "failed to bind parameters"); SET_ERROR(sql, "HY000", r, "failed to bind parameters");
return SQL_ERROR; return SQL_ERROR;
} }
r = taos_stmt_add_batch(sql->stmt); PROFILE(r = taos_stmt_add_batch(sql->stmt));
if (r) { if (r) {
SET_ERROR(sql, "HY000", r, "failed to add batch"); SET_ERROR(sql, "HY000", r, "failed to add batch");
return SQL_ERROR; return SQL_ERROR;
} }
} }
r = taos_stmt_execute(sql->stmt); PROFILE(r = taos_stmt_execute(sql->stmt));
if (r) { if (r) {
SET_ERROR(sql, "HY000", r, "failed to execute statement"); SET_ERROR(sql, "HY000", r, "failed to execute statement");
return SQL_ERROR; return SQL_ERROR;
...@@ -656,25 +1276,48 @@ SQLRETURN SQL_API SQLExecute(SQLHSTMT StatementHandle) { ...@@ -656,25 +1276,48 @@ SQLRETURN SQL_API SQLExecute(SQLHSTMT StatementHandle) {
SQLRETURN ret = SQL_ERROR; SQLRETURN ret = SQL_ERROR;
sql->rs = taos_stmt_use_result(sql->stmt); PROFILE(sql->rs = taos_stmt_use_result(sql->stmt));
CHK_RS(ret, sql, "failed to use result"); CHK_RS(ret, sql, "failed to use result");
return ret; return ret;
} }
SQLRETURN SQL_API SQLGetDiagField(SQLSMALLINT HandleType, SQLHANDLE Handle, SQLRETURN SQL_API SQLExecute(SQLHSTMT StatementHandle)
{
SQLRETURN r;
PROFILE(r = doSQLExecute(StatementHandle));
return r;
}
static SQLRETURN doSQLGetDiagField(SQLSMALLINT HandleType, SQLHANDLE Handle,
SQLSMALLINT RecNumber, SQLSMALLINT DiagIdentifier, SQLSMALLINT RecNumber, SQLSMALLINT DiagIdentifier,
SQLPOINTER DiagInfo, SQLSMALLINT BufferLength, SQLPOINTER DiagInfo, SQLSMALLINT BufferLength,
SQLSMALLINT *StringLength) { SQLSMALLINT *StringLength)
{
// if this function is not exported, isql will never call SQLGetDiagRec // if this function is not exported, isql will never call SQLGetDiagRec
return SQL_ERROR; return SQL_ERROR;
} }
SQLRETURN SQL_API SQLGetDiagRec(SQLSMALLINT HandleType, SQLHANDLE Handle, SQLRETURN SQL_API SQLGetDiagField(SQLSMALLINT HandleType, SQLHANDLE Handle,
SQLSMALLINT RecNumber, SQLSMALLINT DiagIdentifier,
SQLPOINTER DiagInfo, SQLSMALLINT BufferLength,
SQLSMALLINT *StringLength)
{
SQLRETURN r;
r = doSQLGetDiagField(HandleType, Handle,
RecNumber, DiagIdentifier,
DiagInfo, BufferLength,
StringLength);
return r;
}
static SQLRETURN doSQLGetDiagRec(SQLSMALLINT HandleType, SQLHANDLE Handle,
SQLSMALLINT RecNumber, SQLCHAR *Sqlstate, SQLSMALLINT RecNumber, SQLCHAR *Sqlstate,
SQLINTEGER *NativeError, SQLCHAR *MessageText, SQLINTEGER *NativeError, SQLCHAR *MessageText,
SQLSMALLINT BufferLength, SQLSMALLINT *TextLength) { SQLSMALLINT BufferLength, SQLSMALLINT *TextLength)
{
if (RecNumber>1) return SQL_NO_DATA; if (RecNumber>1) return SQL_NO_DATA;
switch (HandleType) { switch (HandleType) {
case SQL_HANDLE_ENV: { case SQL_HANDLE_ENV: {
env_t *env = (env_t*)Handle; env_t *env = (env_t*)Handle;
...@@ -698,10 +1341,24 @@ SQLRETURN SQL_API SQLGetDiagRec(SQLSMALLINT HandleType, SQLHANDLE Handle, ...@@ -698,10 +1341,24 @@ SQLRETURN SQL_API SQLGetDiagRec(SQLSMALLINT HandleType, SQLHANDLE Handle,
} break; } break;
} }
// how to return error?
return SQL_ERROR; return SQL_ERROR;
} }
SQLRETURN SQL_API SQLBindParameter( SQLRETURN SQL_API SQLGetDiagRec(SQLSMALLINT HandleType, SQLHANDLE Handle,
SQLSMALLINT RecNumber, SQLCHAR *Sqlstate,
SQLINTEGER *NativeError, SQLCHAR *MessageText,
SQLSMALLINT BufferLength, SQLSMALLINT *TextLength)
{
SQLRETURN r;
r = doSQLGetDiagRec(HandleType, Handle,
RecNumber, Sqlstate,
NativeError, MessageText,
BufferLength, TextLength);
return r;
}
static SQLRETURN doSQLBindParameter(
SQLHSTMT StatementHandle, SQLHSTMT StatementHandle,
SQLUSMALLINT ParameterNumber, SQLUSMALLINT ParameterNumber,
SQLSMALLINT fParamType, SQLSMALLINT fParamType,
...@@ -711,95 +1368,144 @@ SQLRETURN SQL_API SQLBindParameter( ...@@ -711,95 +1368,144 @@ SQLRETURN SQL_API SQLBindParameter(
SQLSMALLINT ParameterScale, SQLSMALLINT ParameterScale,
SQLPOINTER ParameterValue, SQLPOINTER ParameterValue,
SQLLEN cbValueMax, // ignore for now, since only SQL_PARAM_INPUT is supported now SQLLEN cbValueMax, // ignore for now, since only SQL_PARAM_INPUT is supported now
SQLLEN *StrLen_or_Ind) { SQLLEN *StrLen_or_Ind)
{
sql_t *sql = (sql_t*)StatementHandle; sql_t *sql = (sql_t*)StatementHandle;
if (!sql) return SQL_ERROR; if (!sql) return SQL_ERROR;
if (!sql->conn) return SQL_ERROR;
if (!sql->conn->taos) return SQL_ERROR; if (!sql->conn) {
if (!sql->stmt) return SQL_ERROR; SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection yet");
return SQL_ERROR;
}
if (!sql->conn->taos) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection to data source yet");
return SQL_ERROR;
}
if (!sql->stmt) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_SQL, "no statement cached or not ready");
return SQL_ERROR;
}
if (fParamType != SQL_PARAM_INPUT) { if (fParamType != SQL_PARAM_INPUT) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "non-input parameter [@%d] not supported yet", ParameterNumber); SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "non-input parameter [@%d] not supported yet", ParameterNumber);
return SQL_ERROR; return SQL_ERROR;
} }
int buffer_type = 0;
// ref: https://docs.microsoft.com/en-us/sql/odbc/reference/appendixes/converting-data-from-c-to-sql-data-types?view=sql-server-ver15
switch (ValueType) {
case SQL_C_BIT: {
switch (ParameterType) { switch (ParameterType) {
case SQL_BIT: { // TSDB_DATA_TYPE_BOOL case SQL_BIT: buffer_type = TSDB_DATA_TYPE_BOOL; break;
if (ValueType!=SQL_C_BIT) { case SQL_TINYINT: buffer_type = TSDB_DATA_TYPE_TINYINT; break;
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "parameter [@%d] not matching value type", ParameterNumber); case SQL_SMALLINT: buffer_type = TSDB_DATA_TYPE_SMALLINT; break;
case SQL_INTEGER: buffer_type = TSDB_DATA_TYPE_INT; break;
case SQL_BIGINT: buffer_type = TSDB_DATA_TYPE_BIGINT; break;
case SQL_FLOAT: buffer_type = TSDB_DATA_TYPE_FLOAT; break;
case SQL_DOUBLE: buffer_type = TSDB_DATA_TYPE_DOUBLE; break;
case SQL_VARCHAR: buffer_type = TSDB_DATA_TYPE_NCHAR; break;
default: {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT,
"parameter[@%d] no conversion from [%d] to [%d]",
ParameterNumber, ValueType, ParameterType);
return SQL_ERROR; return SQL_ERROR;
} break;
} }
// LengthPrecision ignored; } break;
// ParameterScale ignored; case SQL_C_TINYINT:
param_bind_t *ar = (param_bind_t*)(sql->n_params>=ParameterNumber ? sql->params : realloc(sql->params, ParameterNumber * sizeof(*ar))); case SQL_C_SHORT:
TAOS_BIND *binds = (TAOS_BIND*)(sql->n_params>=ParameterNumber ? sql->binds : realloc(sql->binds, ParameterNumber * sizeof(*binds))); case SQL_C_LONG:
if (!ar || !binds) { case SQL_C_SBIGINT:
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OUT_OF_MEMORY, "failed to bind parameter [@%d]", ParameterNumber); case SQL_C_FLOAT:
if (ar) sql->params = ar; case SQL_C_DOUBLE:
if (binds) sql->binds = binds; case SQL_C_NUMERIC: {
switch (ParameterType) {
case SQL_BIT: buffer_type = TSDB_DATA_TYPE_BOOL; break;
case SQL_TINYINT: buffer_type = TSDB_DATA_TYPE_TINYINT; break;
case SQL_SMALLINT: buffer_type = TSDB_DATA_TYPE_SMALLINT; break;
case SQL_INTEGER: buffer_type = TSDB_DATA_TYPE_INT; break;
case SQL_BIGINT: buffer_type = TSDB_DATA_TYPE_BIGINT; break;
case SQL_FLOAT: buffer_type = TSDB_DATA_TYPE_FLOAT; break;
case SQL_DOUBLE: buffer_type = TSDB_DATA_TYPE_DOUBLE; break;
case SQL_VARCHAR: buffer_type = TSDB_DATA_TYPE_NCHAR; break;
case SQL_TIMESTAMP: buffer_type = TSDB_DATA_TYPE_TIMESTAMP; break; // extention to taos
default: {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT,
"parameter[@%d] no conversion from [%d] to [%d]",
ParameterNumber, ValueType, ParameterType);
return SQL_ERROR; return SQL_ERROR;
} break;
} }
sql->params = ar;
sql->binds = binds;
if (sql->n_params<ParameterNumber) {
sql->n_params = ParameterNumber;
}
param_bind_t *pb = ar + ParameterNumber - 1;
TAOS_BIND *b = binds + ParameterNumber - 1;
b->buffer_type = TSDB_DATA_TYPE_BOOL;
b->buffer_length = LengthPrecision;
b->buffer = NULL;
b->length = NULL;
b->is_null = NULL;
b->is_unsigned = 0;
b->error = NULL;
pb->ParameterValue = ParameterValue;
pb->StrLen_or_Ind = StrLen_or_Ind;
pb->valid = 1;
} break; } break;
case SQL_TINYINT: { // TSDB_DATA_TYPE_TINYINT case SQL_C_DATE:
if (ValueType!=SQL_C_TINYINT) { case SQL_C_TIME:
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "parameter [@%d] not matching value type", ParameterNumber); case SQL_C_TIMESTAMP: {
switch (ParameterType) {
case SQL_VARCHAR: buffer_type = TSDB_DATA_TYPE_NCHAR; break;
case SQL_TIMESTAMP: buffer_type = TSDB_DATA_TYPE_TIMESTAMP; break; // extention to taos
default: {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT,
"parameter[@%d] no conversion from [%d] to [%d]",
ParameterNumber, ValueType, ParameterType);
return SQL_ERROR; return SQL_ERROR;
} break;
} }
// LengthPrecision ignored; } break;
// ParameterScale ignored; case SQL_C_CHAR: {
param_bind_t *ar = (param_bind_t*)(sql->n_params>=ParameterNumber ? sql->params : realloc(sql->params, ParameterNumber * sizeof(*ar))); switch (ParameterType) {
TAOS_BIND *binds = (TAOS_BIND*)(sql->n_params>=ParameterNumber ? sql->binds : realloc(sql->binds, ParameterNumber * sizeof(*binds))); case SQL_BIT: buffer_type = TSDB_DATA_TYPE_BOOL; break;
if (!ar || !binds) { case SQL_TINYINT: buffer_type = TSDB_DATA_TYPE_TINYINT; break;
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OUT_OF_MEMORY, "failed to bind parameter [@%d]", ParameterNumber); case SQL_SMALLINT: buffer_type = TSDB_DATA_TYPE_SMALLINT; break;
if (ar) sql->params = ar; case SQL_INTEGER: buffer_type = TSDB_DATA_TYPE_INT; break;
if (binds) sql->binds = binds; case SQL_BIGINT: buffer_type = TSDB_DATA_TYPE_BIGINT; break;
case SQL_FLOAT: buffer_type = TSDB_DATA_TYPE_FLOAT; break;
case SQL_DOUBLE: buffer_type = TSDB_DATA_TYPE_DOUBLE; break;
case SQL_VARCHAR: buffer_type = TSDB_DATA_TYPE_NCHAR; break;
case SQL_VARBINARY: buffer_type = TSDB_DATA_TYPE_BINARY; break;
case SQL_TIMESTAMP: buffer_type = TSDB_DATA_TYPE_TIMESTAMP; break; // extention to taos
default: {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT,
"parameter[@%d] no conversion from [%d] to [%d]",
ParameterNumber, ValueType, ParameterType);
return SQL_ERROR; return SQL_ERROR;
} break;
} }
sql->params = ar; } break;
sql->binds = binds; case SQL_C_BINARY: {
if (sql->n_params<ParameterNumber) { switch (ParameterType) {
sql->n_params = ParameterNumber; case SQL_BIT: buffer_type = TSDB_DATA_TYPE_BOOL; break;
case SQL_TINYINT: buffer_type = TSDB_DATA_TYPE_TINYINT; break;
case SQL_SMALLINT: buffer_type = TSDB_DATA_TYPE_SMALLINT; break;
case SQL_INTEGER: buffer_type = TSDB_DATA_TYPE_INT; break;
case SQL_BIGINT: buffer_type = TSDB_DATA_TYPE_BIGINT; break;
case SQL_FLOAT: buffer_type = TSDB_DATA_TYPE_FLOAT; break;
case SQL_DOUBLE: buffer_type = TSDB_DATA_TYPE_DOUBLE; break;
case SQL_VARCHAR: buffer_type = TSDB_DATA_TYPE_NCHAR; break;
case SQL_VARBINARY: buffer_type = TSDB_DATA_TYPE_BINARY; break;
case SQL_TIMESTAMP: buffer_type = TSDB_DATA_TYPE_TIMESTAMP; break; // extention to taos
default: {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT,
"parameter[@%d] no conversion from [%d] to [%d]",
ParameterNumber, ValueType, ParameterType);
return SQL_ERROR;
} break;
} }
param_bind_t *pb = ar + ParameterNumber - 1;
TAOS_BIND *b = binds + ParameterNumber - 1;
b->buffer_type = TSDB_DATA_TYPE_TINYINT;
b->buffer_length = LengthPrecision;
b->buffer = NULL;
b->length = NULL;
b->is_null = NULL;
b->is_unsigned = 0;
b->error = NULL;
pb->ParameterValue = ParameterValue;
pb->StrLen_or_Ind = StrLen_or_Ind;
pb->valid = 1;
} break; } break;
case SQL_SMALLINT: { // TSDB_DATA_TYPE_SMALLINT default: {
if (ValueType!=SQL_C_SHORT) { SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT,
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "parameter [@%d] not matching value type", ParameterNumber); "parameter[@%d] no conversion from [%d] to [%d]",
ParameterNumber, ValueType, ParameterType);
return SQL_ERROR; return SQL_ERROR;
} break;
} }
// LengthPrecision ignored;
// ParameterScale ignored;
param_bind_t *ar = (param_bind_t*)(sql->n_params>=ParameterNumber ? sql->params : realloc(sql->params, ParameterNumber * sizeof(*ar))); param_bind_t *ar = (param_bind_t*)(sql->n_params>=ParameterNumber ? sql->params : realloc(sql->params, ParameterNumber * sizeof(*ar)));
TAOS_BIND *binds = (TAOS_BIND*)(sql->n_params>=ParameterNumber ? sql->binds : realloc(sql->binds, ParameterNumber * sizeof(*binds))); TAOS_BIND *binds = (TAOS_BIND*)(sql->n_params>=ParameterNumber ? sql->binds : realloc(sql->binds, ParameterNumber * sizeof(*binds)));
if (!ar || !binds) { if (!ar || !binds) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OUT_OF_MEMORY, "failed to bind parameter [@%d]", ParameterNumber); SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_OOM, "failed to allocate resources for Parameter[%d]", ParameterNumber);
if (ar) sql->params = ar; if (ar) sql->params = ar;
if (binds) sql->binds = binds; if (binds) sql->binds = binds;
return SQL_ERROR; return SQL_ERROR;
...@@ -809,264 +1515,286 @@ SQLRETURN SQL_API SQLBindParameter( ...@@ -809,264 +1515,286 @@ SQLRETURN SQL_API SQLBindParameter(
if (sql->n_params<ParameterNumber) { if (sql->n_params<ParameterNumber) {
sql->n_params = ParameterNumber; sql->n_params = ParameterNumber;
} }
param_bind_t *pb = ar + ParameterNumber - 1; param_bind_t *pb = ar + ParameterNumber - 1;
TAOS_BIND *b = binds + ParameterNumber - 1; TAOS_BIND *b = binds + ParameterNumber - 1;
b->buffer_type = TSDB_DATA_TYPE_SMALLINT;
b->buffer_type = buffer_type;
b->buffer_length = LengthPrecision; b->buffer_length = LengthPrecision;
b->buffer = NULL; b->buffer = NULL;
b->length = NULL; b->length = NULL;
b->is_null = NULL; b->is_null = NULL;
b->is_unsigned = 0; b->is_unsigned = 0;
b->error = NULL; b->error = NULL;
pb->ParameterNumber = ParameterNumber;
pb->ValueType = ValueType;
pb->ParameterType = ParameterType;
pb->LengthPrecision = LengthPrecision;
pb->ParameterScale = ParameterScale;
pb->ParameterValue = ParameterValue; pb->ParameterValue = ParameterValue;
pb->StrLen_or_Ind = StrLen_or_Ind; pb->StrLen_or_Ind = StrLen_or_Ind;
pb->valid = 1; pb->valid = 1;
} break; return SQL_SUCCESS;
case SQL_INTEGER: { // TSDB_DATA_TYPE_INT }
if (ValueType!=SQL_C_LONG) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "parameter [@%d] not matching value type", ParameterNumber); SQLRETURN SQL_API SQLBindParameter(
SQLHSTMT StatementHandle,
SQLUSMALLINT ParameterNumber,
SQLSMALLINT fParamType,
SQLSMALLINT ValueType,
SQLSMALLINT ParameterType,
SQLULEN LengthPrecision,
SQLSMALLINT ParameterScale,
SQLPOINTER ParameterValue,
SQLLEN cbValueMax, // ignore for now, since only SQL_PARAM_INPUT is supported now
SQLLEN *StrLen_or_Ind)
{
SQLRETURN r;
r = doSQLBindParameter(StatementHandle, ParameterNumber, fParamType, ValueType, ParameterType,
LengthPrecision, ParameterScale, ParameterValue, cbValueMax, StrLen_or_Ind);
return r;
}
static SQLRETURN doSQLDriverConnect(
SQLHDBC hdbc,
SQLHWND hwnd,
SQLCHAR *szConnStrIn,
SQLSMALLINT cbConnStrIn,
SQLCHAR *szConnStrOut,
SQLSMALLINT cbConnStrOutMax,
SQLSMALLINT *pcbConnStrOut,
SQLUSMALLINT fDriverCompletion)
{
conn_t *conn = (conn_t*)hdbc;
if (!conn) return SQL_ERROR;
if (fDriverCompletion!=SQL_DRIVER_NOPROMPT) {
SET_ERROR(conn, "HY000", TSDB_CODE_TSC_APP_ERROR, "option[%d] other than SQL_DRIVER_NOPROMPT not supported yet", fDriverCompletion);
return SQL_ERROR; return SQL_ERROR;
} }
// LengthPrecision ignored;
// ParameterScale ignored; if (conn->taos) {
param_bind_t *ar = (param_bind_t*)(sql->n_params>=ParameterNumber ? sql->params : realloc(sql->params, ParameterNumber * sizeof(*ar))); SET_ERROR(conn, "HY000", TSDB_CODE_TSC_APP_ERROR, "connection still in use");
TAOS_BIND *binds = (TAOS_BIND*)(sql->n_params>=ParameterNumber ? sql->binds : realloc(sql->binds, ParameterNumber * sizeof(*binds)));
if (!ar || !binds) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OUT_OF_MEMORY, "failed to bind parameter [@%d]", ParameterNumber);
if (ar) sql->params = ar;
if (binds) sql->binds = binds;
return SQL_ERROR; return SQL_ERROR;
} }
sql->params = ar;
sql->binds = binds; // DSN=<dsn>; UID=<uid>; PWD=<pwd>
if (sql->n_params<ParameterNumber) {
sql->n_params = ParameterNumber; const char *connStr = SDUP(szConnStrIn, cbConnStrIn);
char *serverName = NULL;
char *userName = NULL;
char *auth = NULL;
int bytes = 0;
do {
if (szConnStrIn && !connStr) {
SET_ERROR(conn, "HY000", TSDB_CODE_ODBC_OOM, "failed to allocate resources");
break;
} }
param_bind_t *pb = ar + ParameterNumber - 1;
TAOS_BIND *b = binds + ParameterNumber - 1; int n = sscanf((const char*)connStr, "DSN=%m[^;]; UID=%m[^;]; PWD=%m[^;] %n", &serverName, &userName, &auth, &bytes);
b->buffer_type = TSDB_DATA_TYPE_INT; if (n<1) {
b->buffer_length = LengthPrecision; SET_ERROR(conn, "HY000", TSDB_CODE_RPC_NETWORK_UNAVAIL, "unrecognized connection string: [%s]", (const char*)szConnStrIn);
b->buffer = NULL; break;
b->length = NULL;
b->is_null = NULL;
b->is_unsigned = 0;
b->error = NULL;
pb->ParameterValue = ParameterValue;
pb->StrLen_or_Ind = StrLen_or_Ind;
pb->valid = 1;
} break;
case SQL_BIGINT: { // TSDB_DATA_TYPE_BIGINT
if (ValueType!=SQL_C_SBIGINT) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "parameter [@%d] not matching value type", ParameterNumber);
return SQL_ERROR;
} }
// LengthPrecision ignored;
// ParameterScale ignored; D("DSN:[%s];UID:[%s];PWD:[%s]", serverName, userName, auth);
param_bind_t *ar = (param_bind_t*)(sql->n_params>=ParameterNumber ? sql->params : realloc(sql->params, ParameterNumber * sizeof(*ar)));
TAOS_BIND *binds = (TAOS_BIND*)(sql->n_params>=ParameterNumber ? sql->binds : realloc(sql->binds, ParameterNumber * sizeof(*binds))); // TODO: data-race
if (!ar || !binds) { // TODO: shall receive ip/port from odbc.ini
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OUT_OF_MEMORY, "failed to bind parameter [@%d]", ParameterNumber); conn->taos = taos_connect("localhost", userName, auth, NULL, 0);
if (ar) sql->params = ar; if (!conn->taos) {
if (binds) sql->binds = binds; SET_ERROR(conn, "HY000", terrno, "failed to connect to data source");
break;
}
if (szConnStrOut) {
snprintf((char*)szConnStrOut, cbConnStrOutMax, "%s", connStr);
}
if (pcbConnStrOut) {
*pcbConnStrOut = cbConnStrIn;
}
} while (0);
if (serverName) free(serverName);
if (userName) free(userName);
if (auth) free(auth);
SFRE(connStr, szConnStrIn, cbConnStrIn);
return conn->taos ? SQL_SUCCESS : SQL_ERROR;
}
SQLRETURN SQL_API SQLDriverConnect(
SQLHDBC hdbc,
SQLHWND hwnd,
SQLCHAR *szConnStrIn,
SQLSMALLINT cbConnStrIn,
SQLCHAR *szConnStrOut,
SQLSMALLINT cbConnStrOutMax,
SQLSMALLINT *pcbConnStrOut,
SQLUSMALLINT fDriverCompletion)
{
SQLRETURN r;
r = doSQLDriverConnect(hdbc, hwnd, szConnStrIn, cbConnStrIn, szConnStrOut, cbConnStrOutMax, pcbConnStrOut, fDriverCompletion);
return r;
}
static SQLRETURN doSQLSetConnectAttr(SQLHDBC ConnectionHandle,
SQLINTEGER Attribute, SQLPOINTER Value,
SQLINTEGER StringLength)
{
conn_t *conn = (conn_t*)ConnectionHandle;
if (!conn) return SQL_ERROR;
if (Attribute != SQL_ATTR_AUTOCOMMIT) {
SET_ERROR(conn, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "Attribute other than SQL_ATTR_AUTOCOMMIT not supported yet");
return SQL_ERROR; return SQL_ERROR;
} }
sql->params = ar; if (Value != (SQLPOINTER)SQL_AUTOCOMMIT_ON) {
sql->binds = binds; SET_ERROR(conn, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "Attribute Value other than SQL_AUTOCOMMIT_ON not supported yet[%p]", Value);
if (sql->n_params<ParameterNumber) { return SQL_ERROR;
sql->n_params = ParameterNumber;
} }
param_bind_t *pb = ar + ParameterNumber - 1;
TAOS_BIND *b = binds + ParameterNumber - 1; return SQL_SUCCESS;
b->buffer_type = TSDB_DATA_TYPE_BIGINT; }
b->buffer_length = LengthPrecision;
b->buffer = NULL; SQLRETURN SQL_API SQLSetConnectAttr(SQLHDBC ConnectionHandle,
b->length = NULL; SQLINTEGER Attribute, SQLPOINTER Value,
b->is_null = NULL; SQLINTEGER StringLength)
b->is_unsigned = 0; {
b->error = NULL; SQLRETURN r;
pb->ParameterValue = ParameterValue; r = doSQLSetConnectAttr(ConnectionHandle, Attribute, Value, StringLength);
pb->StrLen_or_Ind = StrLen_or_Ind; return r;
pb->valid = 1; }
} break;
case SQL_FLOAT: { // TSDB_DATA_TYPE_FLOAT static SQLRETURN doSQLDescribeCol(SQLHSTMT StatementHandle,
if (ValueType!=SQL_C_FLOAT) { SQLUSMALLINT ColumnNumber, SQLCHAR *ColumnName,
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "parameter [@%d] not matching value type", ParameterNumber); SQLSMALLINT BufferLength, SQLSMALLINT *NameLength,
SQLSMALLINT *DataType, SQLULEN *ColumnSize,
SQLSMALLINT *DecimalDigits, SQLSMALLINT *Nullable)
{
sql_t *sql = (sql_t*)StatementHandle;
if (!sql) return SQL_ERROR;
if (!sql->conn) {
SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection yet");
return SQL_ERROR; return SQL_ERROR;
} }
// LengthPrecision ignored;
// ParameterScale ignored; if (!sql->conn->taos) {
param_bind_t *ar = (param_bind_t*)(sql->n_params>=ParameterNumber ? sql->params : realloc(sql->params, ParameterNumber * sizeof(*ar))); SET_ERROR(sql, "HY000", TSDB_CODE_TSC_INVALID_CONNECTION, "no connection to data source yet");
TAOS_BIND *binds = (TAOS_BIND*)(sql->n_params>=ParameterNumber ? sql->binds : realloc(sql->binds, ParameterNumber * sizeof(*binds)));
if (!ar || !binds) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OUT_OF_MEMORY, "failed to bind parameter [@%d]", ParameterNumber);
if (ar) sql->params = ar;
if (binds) sql->binds = binds;
return SQL_ERROR; return SQL_ERROR;
} }
sql->params = ar;
sql->binds = binds; if (!sql->rs) {
if (sql->n_params<ParameterNumber) { SET_ERROR(sql, "HY000", TSDB_CODE_TSC_QUERY_CACHE_ERASED, "no result set cached or not ready");
sql->n_params = ParameterNumber; return SQL_ERROR;
} }
param_bind_t *pb = ar + ParameterNumber - 1;
TAOS_BIND *b = binds + ParameterNumber - 1; TAOS_FIELD *fields = taos_fetch_fields(sql->rs);
b->buffer_type = TSDB_DATA_TYPE_FLOAT; if (!fields) {
b->buffer_length = LengthPrecision; SET_ERROR(sql, "HY000", TSDB_CODE_MND_FIELD_NOT_EXIST, "fields not ready or unavailable");
b->buffer = NULL;
b->length = NULL;
b->is_null = NULL;
b->is_unsigned = 0;
b->error = NULL;
pb->ParameterValue = ParameterValue;
pb->StrLen_or_Ind = StrLen_or_Ind;
pb->valid = 1;
} break;
case SQL_DOUBLE: { // TSDB_DATA_TYPE_DOUBLE
if (ValueType!=SQL_C_DOUBLE) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "parameter [@%d] not matching value type", ParameterNumber);
return SQL_ERROR; return SQL_ERROR;
} }
// LengthPrecision ignored; int nfields = taos_field_count(sql->rs);
// ParameterScale ignored; if (ColumnNumber<1 || ColumnNumber>nfields) {
param_bind_t *ar = (param_bind_t*)(sql->n_params>=ParameterNumber ? sql->params : realloc(sql->params, ParameterNumber * sizeof(*ar))); SET_ERROR(sql, "HY000", TSDB_CODE_MND_FIELD_NOT_EXIST, "ColumnNumber not in valid range");
TAOS_BIND *binds = (TAOS_BIND*)(sql->n_params>=ParameterNumber ? sql->binds : realloc(sql->binds, ParameterNumber * sizeof(*binds)));
if (!ar || !binds) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OUT_OF_MEMORY, "failed to bind parameter [@%d]", ParameterNumber);
if (ar) sql->params = ar;
if (binds) sql->binds = binds;
return SQL_ERROR; return SQL_ERROR;
} }
sql->params = ar;
sql->binds = binds; TAOS_FIELD *field = fields + ColumnNumber - 1;
if (sql->n_params<ParameterNumber) { if (ColumnName) {
sql->n_params = ParameterNumber; size_t n = sizeof(field->name);
if (n>BufferLength) n = BufferLength;
strncpy((char*)ColumnName, field->name, n);
} }
param_bind_t *pb = ar + ParameterNumber - 1; if (NameLength) {
TAOS_BIND *b = binds + ParameterNumber - 1; *NameLength = strnlen(field->name, sizeof(field->name));
b->buffer_type = TSDB_DATA_TYPE_DOUBLE;
b->buffer_length = LengthPrecision;
b->buffer = NULL;
b->length = NULL;
b->is_null = NULL;
b->is_unsigned = 0;
b->error = NULL;
pb->ParameterValue = ParameterValue;
pb->StrLen_or_Ind = StrLen_or_Ind;
pb->valid = 1;
} break;
case SQL_TIMESTAMP: { // TSDB_DATA_TYPE_TIMESTAMP
if (ValueType!=SQL_C_SBIGINT) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "parameter [@%d] not matching value type", ParameterNumber);
return SQL_ERROR;
} }
// LengthPrecision ignored; if (DataType) {
// ParameterScale ignored; switch (field->type) {
param_bind_t *ar = (param_bind_t*)(sql->n_params>=ParameterNumber ? sql->params : realloc(sql->params, ParameterNumber * sizeof(*ar))); case TSDB_DATA_TYPE_BOOL: {
TAOS_BIND *binds = (TAOS_BIND*)(sql->n_params>=ParameterNumber ? sql->binds : realloc(sql->binds, ParameterNumber * sizeof(*binds))); *DataType = SQL_C_TINYINT;
if (!ar || !binds) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OUT_OF_MEMORY, "failed to bind parameter [@%d]", ParameterNumber);
if (ar) sql->params = ar;
if (binds) sql->binds = binds;
return SQL_ERROR;
}
sql->params = ar;
sql->binds = binds;
if (sql->n_params<ParameterNumber) {
sql->n_params = ParameterNumber;
}
param_bind_t *pb = ar + ParameterNumber - 1;
TAOS_BIND *b = binds + ParameterNumber - 1;
b->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
b->buffer_length = LengthPrecision;
b->buffer = NULL;
b->length = NULL;
b->is_null = NULL;
b->is_unsigned = 0;
b->error = NULL;
pb->ParameterValue = ParameterValue;
pb->StrLen_or_Ind = StrLen_or_Ind;
pb->valid = 1;
} break; } break;
case SQL_VARBINARY: { // TSDB_DATA_TYPE_BINARY
if (ValueType!=SQL_C_BINARY) { case TSDB_DATA_TYPE_TINYINT: {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "parameter [@%d] not matching value type", ParameterNumber); *DataType = SQL_C_TINYINT;
return SQL_ERROR;
}
if (LengthPrecision <=0) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "parameter [@%d] not matching length precision", ParameterNumber);
return SQL_ERROR;
}
// ParameterScale ignored;
param_bind_t *ar = (param_bind_t*)(sql->n_params>=ParameterNumber ? sql->params : realloc(sql->params, ParameterNumber * sizeof(*ar)));
TAOS_BIND *binds = (TAOS_BIND*)(sql->n_params>=ParameterNumber ? sql->binds : realloc(sql->binds, ParameterNumber * sizeof(*binds)));
if (!ar || !binds) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OUT_OF_MEMORY, "failed to bind parameter [@%d]", ParameterNumber);
if (ar) sql->params = ar;
if (binds) sql->binds = binds;
return SQL_ERROR;
}
sql->params = ar;
sql->binds = binds;
if (sql->n_params<ParameterNumber) {
sql->n_params = ParameterNumber;
}
param_bind_t *pb = ar + ParameterNumber - 1;
TAOS_BIND *b = binds + ParameterNumber - 1;
b->buffer_type = TSDB_DATA_TYPE_BINARY;
b->buffer_length = LengthPrecision;
b->buffer = NULL;
b->length = NULL;
b->is_null = NULL;
b->is_unsigned = 0;
b->error = NULL;
pb->ParameterValue = ParameterValue;
pb->StrLen_or_Ind = StrLen_or_Ind;
pb->valid = 1;
} break; } break;
case SQL_VARCHAR: { // TSDB_DATA_TYPE_NCHAR
if (ValueType!=SQL_C_CHAR) { case TSDB_DATA_TYPE_SMALLINT: {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "parameter [@%d] not matching value type", ParameterNumber); *DataType = SQL_C_SHORT;
} break;
case TSDB_DATA_TYPE_INT: {
*DataType = SQL_C_LONG;
} break;
case TSDB_DATA_TYPE_BIGINT: {
*DataType = SQL_BIGINT;
} break;
case TSDB_DATA_TYPE_FLOAT: {
*DataType = SQL_C_FLOAT;
} break;
case TSDB_DATA_TYPE_DOUBLE: {
*DataType = SQL_C_DOUBLE;
} break;
case TSDB_DATA_TYPE_TIMESTAMP: {
*DataType = SQL_C_TIMESTAMP;
} break;
case TSDB_DATA_TYPE_NCHAR: {
*DataType = SQL_C_CHAR; // unicode ?
} break;
case TSDB_DATA_TYPE_BINARY: {
*DataType = SQL_C_BINARY;
} break;
default:
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "unknown TSDB_DATA_TYPE [%x]", field->type);
return SQL_ERROR; return SQL_ERROR;
break;
} }
if (LengthPrecision <=0) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "parameter [@%d] not matching length precision", ParameterNumber);
return SQL_ERROR;
} }
// ParameterScale ignored; if (ColumnSize) {
param_bind_t *ar = (param_bind_t*)(sql->n_params>=ParameterNumber ? sql->params : realloc(sql->params, ParameterNumber * sizeof(*ar))); *ColumnSize = field->bytes;
TAOS_BIND *binds = (TAOS_BIND*)(sql->n_params>=ParameterNumber ? sql->binds : realloc(sql->binds, ParameterNumber * sizeof(*binds)));
if (!ar || !binds) {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OUT_OF_MEMORY, "failed to bind parameter [@%d]", ParameterNumber);
if (ar) sql->params = ar;
if (binds) sql->binds = binds;
return SQL_ERROR;
} }
sql->params = ar; if (DecimalDigits) {
sql->binds = binds; if (field->type == TSDB_DATA_TYPE_TIMESTAMP) {
if (sql->n_params<ParameterNumber) { *DecimalDigits = 3;
sql->n_params = ParameterNumber; } else {
*DecimalDigits = 0;
} }
param_bind_t *pb = ar + ParameterNumber - 1;
TAOS_BIND *b = binds + ParameterNumber - 1;
b->buffer_type = TSDB_DATA_TYPE_NCHAR;
b->buffer_length = LengthPrecision;
b->buffer = NULL;
b->length = NULL;
b->is_null = NULL;
b->is_unsigned = 0;
b->error = NULL;
pb->ParameterValue = ParameterValue;
pb->StrLen_or_Ind = StrLen_or_Ind;
pb->valid = 1;
} break;
default: {
SET_ERROR(sql, "HY000", TSDB_CODE_COM_OPS_NOT_SUPPORT, "xdoes not support parameter type[%x]", ParameterType);
return SQL_ERROR;
} break;
} }
if (Nullable) {
*Nullable = SQL_NULLABLE_UNKNOWN;
}
return SQL_SUCCESS; return SQL_SUCCESS;
} }
SQLRETURN SQL_API SQLDescribeCol(SQLHSTMT StatementHandle,
SQLUSMALLINT ColumnNumber, SQLCHAR *ColumnName,
SQLSMALLINT BufferLength, SQLSMALLINT *NameLength,
SQLSMALLINT *DataType, SQLULEN *ColumnSize,
SQLSMALLINT *DecimalDigits, SQLSMALLINT *Nullable)
{
SQLRETURN r;
r = doSQLDescribeCol(StatementHandle, ColumnNumber, ColumnName,
BufferLength, NameLength,
DataType, ColumnSize,
DecimalDigits, Nullable);
return r;
}
static void init_routine(void) { static void init_routine(void) {
...@@ -1096,7 +1824,7 @@ static int do_field_display_size(TAOS_FIELD *field) { ...@@ -1096,7 +1824,7 @@ static int do_field_display_size(TAOS_FIELD *field) {
} break; } break;
case TSDB_DATA_TYPE_DOUBLE: { case TSDB_DATA_TYPE_DOUBLE: {
return 12; return 20;
} break; } break;
case TSDB_DATA_TYPE_BINARY: case TSDB_DATA_TYPE_BINARY:
...@@ -1105,7 +1833,7 @@ static int do_field_display_size(TAOS_FIELD *field) { ...@@ -1105,7 +1833,7 @@ static int do_field_display_size(TAOS_FIELD *field) {
} break; } break;
case TSDB_DATA_TYPE_TIMESTAMP: case TSDB_DATA_TYPE_TIMESTAMP:
return 22; return 26;
break; break;
case TSDB_DATA_TYPE_BOOL: case TSDB_DATA_TYPE_BOOL:
...@@ -1162,6 +1890,7 @@ static void do_convert(SQLPOINTER TargetValue, SQLLEN BufferLength, SQLLEN *StrL ...@@ -1162,6 +1890,7 @@ static void do_convert(SQLPOINTER TargetValue, SQLLEN BufferLength, SQLLEN *StrL
} }
if (n>0) *p = '\0'; if (n>0) *p = '\0';
((char*)TargetValue)[BufferLength-1] = '\0'; ((char*)TargetValue)[BufferLength-1] = '\0';
*StrLen_or_Ind = BufferLength - n;
} break; } break;
case TSDB_DATA_TYPE_TIMESTAMP: case TSDB_DATA_TYPE_TIMESTAMP:
...@@ -1175,3 +1904,692 @@ static void do_convert(SQLPOINTER TargetValue, SQLLEN BufferLength, SQLLEN *StrL ...@@ -1175,3 +1904,692 @@ static void do_convert(SQLPOINTER TargetValue, SQLLEN BufferLength, SQLLEN *StrL
} }
} }
// convertion from TSDB_DATA_TYPE_XXX to SQL_C_XXX
static SQLRETURN conv_tsdb_bool_to_c_bit(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
{
int8_t v = b;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_bool_to_c_tinyint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
{
int8_t v = b;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_bool_to_c_short(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
{
int16_t v = b;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_bool_to_c_long(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
{
int32_t v = b;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_bool_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
{
int64_t v = b;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_bool_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
{
float v = b;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_bool_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
{
double v = b;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_bool_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
{
DASSERT(target->len>0);
*target->soi = 1;
if (target->ptr) {
target->ptr[0] = '0' + b;
if (target->len>1) {
target->ptr[1] = '\0';
}
}
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_bool_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
{
DASSERT(target->len>0);
*target->soi = 1;
target->ptr[0] = '0' + b;
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v1_to_c_tinyint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1)
{
int8_t v = v1;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v1_to_c_short(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1)
{
int16_t v = v1;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v1_to_c_long(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1)
{
int32_t v = v1;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v1_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1)
{
int64_t v = v1;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v1_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1)
{
float v = v1;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v1_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1)
{
double v = v1;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v1_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1)
{
char buf[64];
int n = snprintf(buf, sizeof(buf), "%d", v1);
DASSERT(n<sizeof(buf));
*target->soi = n;
if (target->ptr) strncpy(target->ptr, buf, (n>=target->len ? target->len : n+1));
if (n<=target->len) return SQL_SUCCESS;
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_TINYINT -> SQL_C_BIT");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_v1_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1)
{
char buf[64];
int n = snprintf(buf, sizeof(buf), "%d", v1);
DASSERT(n<sizeof(buf));
*target->soi = n;
if (target->ptr) strncpy(target->ptr, buf, (n>target->len ? target->len : n));
if (n<=target->len) return SQL_SUCCESS;
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_TINYINT -> SQL_C_BIT");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_v2_to_c_short(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2)
{
int16_t v = v2;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v2_to_c_long(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2)
{
int32_t v = v2;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v2_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2)
{
int64_t v = v2;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v2_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2)
{
float v = v2;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v2_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2)
{
double v = v2;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v2_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2)
{
char buf[64];
int n = snprintf(buf, sizeof(buf), "%d", v2);
DASSERT(n<sizeof(buf));
*target->soi = n;
if (target->ptr) strncpy(target->ptr, buf, (n>=target->len ? target->len : n+1));
if (n<=target->len) return SQL_SUCCESS;
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_SMALLINT -> SQL_C_CHAR");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_v2_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2)
{
char buf[64];
int n = snprintf(buf, sizeof(buf), "%d", v2);
DASSERT(n<sizeof(buf));
*target->soi = n;
if (target->ptr) strncpy(target->ptr, buf, (n>target->len ? target->len : n));
if (n<=target->len) return SQL_SUCCESS;
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_SMALLINT -> SQL_C_CHAR");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_v4_to_c_long(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4)
{
int32_t v = v4;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v4_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4)
{
int64_t v = v4;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v4_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4)
{
float v = v4;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v4_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4)
{
double v = v4;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v4_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4)
{
char buf[64];
int n = snprintf(buf, sizeof(buf), "%d", v4);
DASSERT(n<sizeof(buf));
*target->soi = n;
if (target->ptr) strncpy(target->ptr, buf, (n>=target->len ? target->len : n+1));
if (n<=target->len) return SQL_SUCCESS;
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_INTEGER -> SQL_C_CHAR");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_v4_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4)
{
char buf[64];
int n = snprintf(buf, sizeof(buf), "%d", v4);
DASSERT(n<sizeof(buf));
*target->soi = n;
if (target->ptr) strncpy(target->ptr, buf, (n>target->len ? target->len : n));
if (n<=target->len) return SQL_SUCCESS;
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_INTEGER -> SQL_C_BINARY");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_v8_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8)
{
int64_t v = v8;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v8_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8)
{
float v = v8;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v8_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8)
{
double v = v8;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_v8_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8)
{
char buf[64];
int n = snprintf(buf, sizeof(buf), "%ld", v8);
DASSERT(n<sizeof(buf));
*target->soi = n;
if (target->ptr) strncpy(target->ptr, buf, (n>=target->len ? target->len : n+1));
if (n<=target->len) return SQL_SUCCESS;
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_BIGINT -> SQL_C_CHAR");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_v8_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8)
{
char buf[64];
int n = snprintf(buf, sizeof(buf), "%ld", v8);
DASSERT(n<sizeof(buf));
*target->soi = n;
if (target->ptr) strncpy(target->ptr, buf, (n>target->len ? target->len : n));
if (n<=target->len) return SQL_SUCCESS;
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_BIGINT -> SQL_C_BINARY");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_f4_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, float f4)
{
float v = f4;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_f4_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, float f4)
{
double v = f4;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_f4_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, float f4)
{
char buf[64];
int n = snprintf(buf, sizeof(buf), "%g", f4);
DASSERT(n<sizeof(buf));
*target->soi = n;
if (target->ptr) strncpy(target->ptr, buf, (n>=target->len ? target->len : n+1));
if (n<=target->len) return SQL_SUCCESS;
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_FLOAT -> SQL_C_CHAR");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_f4_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, float f4)
{
char buf[64];
int n = snprintf(buf, sizeof(buf), "%g", f4);
DASSERT(n<sizeof(buf));
*target->soi = n;
if (target->ptr) strncpy(target->ptr, buf, (n>target->len ? target->len : n));
if (n<=target->len) return SQL_SUCCESS;
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_FLOAT -> SQL_C_BINARY");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_f8_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, double f8)
{
double v = f8;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_f8_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, double f8)
{
char buf[64];
int n = snprintf(buf, sizeof(buf), "%.6f", f8);
DASSERT(n<sizeof(buf));
*target->soi = n;
if (target->ptr) strncpy(target->ptr, buf, (n>=target->len ? target->len : n+1));
if (n<=target->len) return SQL_SUCCESS;
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_DOUBLE -> SQL_C_CHAR");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_f8_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, double f8)
{
char buf[64];
int n = snprintf(buf, sizeof(buf), "%g", f8);
DASSERT(n<sizeof(buf));
*target->soi = n;
if (target->ptr) strncpy(target->ptr, buf, (n>target->len ? target->len : n));
if (n<=target->len) return SQL_SUCCESS;
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_DOUBLE -> SQL_C_BINARY");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_ts_to_c_v8(sql_t *sql, c_target_t *target, TAOS_FIELD *field, TIMESTAMP_STRUCT *ts)
{
struct tm tm = {0};
tm.tm_sec = ts->second;
tm.tm_min = ts->minute;
tm.tm_hour = ts->hour;
tm.tm_mday = ts->day;
tm.tm_mon = ts->month - 1;
tm.tm_year = ts->year - 1900;
time_t t = mktime(&tm);
DASSERT(sizeof(t) == sizeof(int64_t));
int64_t v = (int64_t)t;
v *= 1000;
v += ts->fraction % 1000;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_ts_to_c_str(sql_t *sql, c_target_t *target, TAOS_FIELD *field, TIMESTAMP_STRUCT *ts)
{
struct tm tm = {0};
tm.tm_sec = ts->second;
tm.tm_min = ts->minute;
tm.tm_hour = ts->hour;
tm.tm_mday = ts->day;
tm.tm_mon = ts->month - 1;
tm.tm_year = ts->year - 1900;
char buf[64];
int n = strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", &tm);
DASSERT(n < sizeof(buf));
*target->soi = n;
if (target->ptr) {
snprintf(target->ptr, target->len, "%s.%03d", buf, ts->fraction);
}
if (n <= target->len) {
return SQL_SUCCESS;
}
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_TIMESTAMP -> SQL_C_CHAR");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_ts_to_c_bin(sql_t *sql, c_target_t *target, TAOS_FIELD *field, TIMESTAMP_STRUCT *ts)
{
struct tm tm = {0};
tm.tm_sec = ts->second;
tm.tm_min = ts->minute;
tm.tm_hour = ts->hour;
tm.tm_mday = ts->day;
tm.tm_mon = ts->month - 1;
tm.tm_year = ts->year - 1900;
char buf[64];
int n = strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", &tm);
DASSERT(n < sizeof(buf));
*target->soi = n;
if (target->ptr) memcpy(target->ptr, buf, (n>target->len ? target->len : n));
if (n <= target->len) {
return SQL_SUCCESS;
}
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_TIMESTAMP -> SQL_C_BINARY");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_ts_to_c_ts(sql_t *sql, c_target_t *target, TAOS_FIELD *field, TIMESTAMP_STRUCT *ts)
{
if (target->ptr) memcpy(target->ptr, ts, sizeof(*ts));
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_bin_to_c_str(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const unsigned char *bin)
{
size_t n = field->bytes;
*target->soi = n;
if (target->ptr) memcpy(target->ptr, bin, (n>target->len ? target->len : n));
if (n <= target->len) return SQL_SUCCESS;
SET_ERROR(sql, "01004", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_BINARY -> SQL_C_CHAR");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_bin_to_c_bin(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const unsigned char *bin)
{
size_t n = field->bytes;
*target->soi = n;
if (target->ptr) memcpy(target->ptr, bin, (n>target->len ? target->len : n));
if (n <= target->len) return SQL_SUCCESS;
SET_ERROR(sql, "01004", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_BINARY -> SQL_C_CHAR");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_str_to_c_bit(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
{
int bytes = 0;
double f8 = 0;
int n = sscanf(str, "%lf%n", &f8, &bytes);
int8_t v = f8;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
*target->soi = 1;
if (n!=1 || bytes!=strlen(str)) {
SET_ERROR(sql, "22018", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_BIT");
return SQL_SUCCESS_WITH_INFO;
}
char buf[64];
snprintf(buf, sizeof(buf), "%d", v);
if (strcmp(buf, str)==0) {
if (v==0 || v==1) return SQL_SUCCESS;
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_BIT");
return SQL_SUCCESS_WITH_INFO;
}
if (f8>0 || f8<2) {
SET_ERROR(sql, "01S07", TSDB_CODE_ODBC_CONV_TRUNC, "TSDB_DATA_TYPE_NCHAR -> SQL_C_BIT");
return SQL_SUCCESS_WITH_INFO;
}
if (f8<0 || f8>2) {
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_BIT");
return SQL_SUCCESS_WITH_INFO;
}
SET_ERROR(sql, "01S07", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_BIT");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_str_to_c_v1(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
{
int bytes = 0;
double f8 = 0;
int n = sscanf(str, "%lf%n", &f8, &bytes);
int8_t v = f8;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
*target->soi = 1;
if (n!=1 || bytes!=strlen(str)) {
SET_ERROR(sql, "22018", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_TINYINT");
return SQL_SUCCESS_WITH_INFO;
}
char buf[64];
snprintf(buf, sizeof(buf), "%d", v);
if (strcmp(buf, str)==0) return SQL_SUCCESS;
if (f8>INT8_MAX || f8<INT8_MIN) {
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_TINYINT");
return SQL_SUCCESS_WITH_INFO;
}
SET_ERROR(sql, "01S07", TSDB_CODE_ODBC_CONV_TRUNC, "TSDB_DATA_TYPE_NCHAR -> SQL_C_TINYINT");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_str_to_c_v2(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
{
int bytes = 0;
double f8 = 0;
int n = sscanf(str, "%lf%n", &f8, &bytes);
int16_t v = f8;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
*target->soi = 2;
if (n!=1 || bytes!=strlen(str)) {
SET_ERROR(sql, "22018", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_SHORT");
return SQL_SUCCESS_WITH_INFO;
}
char buf[64];
snprintf(buf, sizeof(buf), "%d", v);
if (strcmp(buf, str)==0) return SQL_SUCCESS;
if (f8>INT16_MAX || f8<INT16_MIN) {
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_SHORT");
return SQL_SUCCESS_WITH_INFO;
}
SET_ERROR(sql, "01S07", TSDB_CODE_ODBC_CONV_TRUNC, "TSDB_DATA_TYPE_NCHAR -> SQL_C_SHORT");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_str_to_c_v4(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
{
int bytes = 0;
double f8 = 0;
int n = sscanf(str, "%lf%n", &f8, &bytes);
int32_t v = f8;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
*target->soi = 4;
if (n!=1 || bytes!=strlen(str)) {
SET_ERROR(sql, "22018", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_LONG");
return SQL_SUCCESS_WITH_INFO;
}
char buf[64];
snprintf(buf, sizeof(buf), "%d", v);
if (strcmp(buf, str)==0) return SQL_SUCCESS;
if (f8>INT32_MAX || f8<INT32_MIN) {
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_LONG");
return SQL_SUCCESS_WITH_INFO;
}
SET_ERROR(sql, "01S07", TSDB_CODE_ODBC_CONV_TRUNC, "TSDB_DATA_TYPE_NCHAR -> SQL_C_LONG");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_str_to_c_v8(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
{
int bytes = 0;
double f8 = 0;
int n = sscanf(str, "%lf%n", &f8, &bytes);
int64_t v = f8;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
*target->soi = 8;
if (n!=1 || bytes!=strlen(str)) {
SET_ERROR(sql, "22018", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_SBIGINT");
return SQL_SUCCESS_WITH_INFO;
}
char buf[64];
snprintf(buf, sizeof(buf), "%ld", v);
if (strcmp(buf, str)==0) return SQL_SUCCESS;
if (f8>INT64_MAX || f8<INT64_MIN) {
SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_SBIGINT");
return SQL_SUCCESS_WITH_INFO;
}
SET_ERROR(sql, "01S07", TSDB_CODE_ODBC_CONV_TRUNC, "TSDB_DATA_TYPE_NCHAR -> SQL_C_SBIGINT");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_str_to_c_f4(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
{
int bytes = 0;
double f8 = 0;
int n = sscanf(str, "%lf%n", &f8, &bytes);
float v = f8;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
*target->soi = 4;
if (n!=1 || bytes!=strlen(str)) {
SET_ERROR(sql, "22018", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_FLOAT");
return SQL_SUCCESS_WITH_INFO;
}
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_str_to_c_f8(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
{
int bytes = 0;
double f8 = 0;
int n = sscanf(str, "%lf%n", &f8, &bytes);
float v = f8;
if (target->ptr) memcpy(target->ptr, &v, sizeof(v));
*target->soi = 8;
if (n!=1 || bytes!=strlen(str)) {
SET_ERROR(sql, "22018", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_DOUBLE");
return SQL_SUCCESS_WITH_INFO;
}
return SQL_SUCCESS;
}
static SQLRETURN conv_tsdb_str_to_c_str(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
{
size_t n = strlen(str);
*target->soi = n;
if (target->ptr) strncpy(target->ptr, str, (n < target->len ? n+1 : target->len));
if (n < target->len) return SQL_SUCCESS;
SET_ERROR(sql, "01004", TSDB_CODE_ODBC_CONV_TRUNC, "TSDB_DATA_TYPE_NCHAR -> SQL_C_CHAR");
return SQL_SUCCESS_WITH_INFO;
}
static SQLRETURN conv_tsdb_str_to_c_bin(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
{
size_t n = strlen(str);
*target->soi = n;
if (target->ptr) memcpy(target->ptr, str, (n < target->len ? n : target->len));
if (n <= target->len) return SQL_SUCCESS;
SET_ERROR(sql, "01004", TSDB_CODE_ODBC_CONV_TRUNC, "TSDB_DATA_TYPE_NCHAR -> SQL_C_BINARY");
return SQL_SUCCESS_WITH_INFO;
}
src/connector/odbc/tests/main.c
浏览文件 @ f1f5c0c4
...@@ -118,8 +118,7 @@ static int do_insert(SQLHSTMT stmt, data_t data) { ...@@ -118,8 +118,7 @@ static int do_insert(SQLHSTMT stmt, data_t data) {
if (r) break; if (r) break;
fprintf(stderr, "bind 8 [%s]\n", statement); fprintf(stderr, "bind 8 [%s]\n", statement);
SQLLEN l8 = SQL_NULL_DATA; r = SQLBindParameter(stmt, 8, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, ignored, ignored, &data.f8, ignored, NULL);
r = SQLBindParameter(stmt, 8, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, ignored, ignored, &data.f8, ignored, &l8);
CHK_RESULT(r, SQL_HANDLE_STMT, stmt); CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
if (r) break; if (r) break;
...@@ -196,6 +195,7 @@ int main(int argc, char *argv[]) { ...@@ -196,6 +195,7 @@ int main(int argc, char *argv[]) {
memset(data.blob, 0, sizeof(data.blob)); memset(data.blob, 0, sizeof(data.blob));
snprintf(data.bin, sizeof(data.bin), "hello"); snprintf(data.bin, sizeof(data.bin), "hello");
snprintf(data.blob, sizeof(data.blob), "world"); snprintf(data.blob, sizeof(data.blob), "world");
snprintf(data.blob, sizeof(data.blob), "wo人rld");
SQLHSTMT stmt = {0}; SQLHSTMT stmt = {0};
r = SQLAllocHandle(SQL_HANDLE_STMT, conn, &stmt); r = SQLAllocHandle(SQL_HANDLE_STMT, conn, &stmt);
if (r!=SQL_SUCCESS) break; if (r!=SQL_SUCCESS) break;
......
src/inc/taoserror.h
浏览文件 @ f1f5c0c4
...@@ -350,6 +350,12 @@ TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_TAG_VALUE_TOO_LONG, 0, 0x11A4, "tag value ...@@ -350,6 +350,12 @@ TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_TAG_VALUE_TOO_LONG, 0, 0x11A4, "tag value
TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_VALUE_NULL, 0, 0x11A5, "value not find") TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_VALUE_NULL, 0, 0x11A5, "value not find")
TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_VALUE_TYPE, 0, 0x11A6, "value type should be boolean, number or string") TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_VALUE_TYPE, 0, 0x11A6, "value type should be boolean, number or string")
TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_OOM, 0, 0x2101, "out of memory")
TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_UNDEF, 0, 0x2102, "convertion undefined")
TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_TRUNC, 0, 0x2103, "convertion truncated")
TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_NOT_SUPPORT, 0, 0x2104, "convertion not supported")
#ifdef TAOS_ERROR_C #ifdef TAOS_ERROR_C
}; };
#endif #endif
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或