step

Author: Gazizonoki

cmake/testing.cmake

@@ -102,7 +102,9 @@ if (YDB_SDK_ODBC)
       LINK_LIBRARIES
         ${ODBC_TEST_LINK_LIBRARIES}
         ODBC::ODBC
-      LABELS ${ODBC_TEST_LABELS}
+      LABELS
+        integration
+        ${ODBC_TEST_LABELS}
     )
 
     target_compile_definitions(${ODBC_TEST_NAME} 

odbc/README.md

@@ -1,105 +1,80 @@
 # YDB ODBC Driver
 
-ODBC драйвер для YDB.
+ODBC driver for YDB.
 
-## Требования
+## Requirements
 
-- CMake 3.10 или выше
-- Компилятор C/C++ с поддержкой C11 и C++20
+- CMake 3.10 or higher
+- C/C++ compiler with C11 and C++20 support
 - YDB C++ SDK
-- unixODBC (для Linux/macOS)
+- unixODBC (for Linux/macOS)
 
-## Сборка
+## Build
 
 ```bash
-mkdir build && cd build
-cmake ..
-make
+cmake -DYDB_SDK_ODBC=1 --preset release-clang
+cmake --build --preset default
 ```
 
-## Установка
+## Configuration
 
-```bash
-sudo make install
-```
-
-Это установит:
-- Библиотеку драйвера в `/usr/local/lib/`
-- Конфигурацию драйвера в `/etc/odbcinst.d/`
-- Конфигурацию источников данных в `/etc/odbc.ini`
-
-## Настройка
-
-1. Убедитесь, что драйвер зарегистрирован:
+1. Make sure the driver is registered:
 ```bash
 odbcinst -q -d
 ```
 
-2. Проверьте доступные источники данных:
+2. Check available data sources:
 ```bash
 odbcinst -q -s
 ```
 
-3. Отредактируйте `/etc/odbc.ini` для настройки подключения:
+3. Edit `/etc/odbc.ini` to configure the connection:
 ```ini
 [YDB]
 Driver=YDB
 Description=YDB Database Connection
-Server=grpc://your-server:2136
-Database=your-database
-AuthMode=none  # или token для аутентификации по токену
+Server=your-server:port
+Database=/path/to/database
 ```
 
-## Использование
+## Usage
 
-Пример подключения через isql:
+Example of connecting via isql:
 ```bash
 isql -v YDB
 ```
 
-Пример использования в C:
+Example usage in C:
 ```c
 SQLHENV env;
 SQLHDBC dbc;
 SQLHSTMT stmt;
 
-// Инициализация окружения
+// Initialize environment
 SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env);
 SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0);
 
-// Подключение
+// Connect
 SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc);
 SQLConnect(dbc, (SQLCHAR*)"YDB", SQL_NTS,
           (SQLCHAR*)"", SQL_NTS,
           (SQLCHAR*)"", SQL_NTS);
 
-// Выполнение запроса
+// Execute query
 SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt);
 SQLExecDirect(stmt, (SQLCHAR*)"SELECT * FROM mytable", SQL_NTS);
 
-// Очистка
+// Cleanup
 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 SQLDisconnect(dbc);
 SQLFreeHandle(SQL_HANDLE_DBC, dbc);
 SQLFreeHandle(SQL_HANDLE_ENV, env);
 ```
 
-## Поддерживаемые функции
-
-- SQLAllocHandle
-- SQLConnect
-- SQLDisconnect
-- SQLExecDirect
-- SQLFetch
-- SQLGetData
-- SQLPrepare
-- SQLExecute
-- SQLCloseCursor
-- SQLFreeHandle
-- SQLGetInfo
-- SQLGetDescField
-- SQLSetDescField
-
-## Лицензия
-
-Apache License 2.0 
+## Parameters
+
+Use names $p1, $p2, ... for parameter names
+
+## License
+
+Apache License 2.0

odbc/src/connection.cpp

@@ -57,8 +57,8 @@ SQLRETURN TConnection::Connect(const std::string& serverName,
     char endpoint[256] = {0};
     char database[256] = {0};
 
-    SQLGetPrivateProfileString(serverName.c_str(), "Endpoint", "", endpoint, sizeof(endpoint), nullptr);
-    SQLGetPrivateProfileString(serverName.c_str(), "Database", "", database, sizeof(database), nullptr);
+    //SQLGetPrivateProfileString(serverName.c_str(), "Endpoint", "", endpoint, sizeof(endpoint), nullptr);
+    //SQLGetPrivateProfileString(serverName.c_str(), "Database", "", database, sizeof(database), nullptr);
 
     Endpoint_ = endpoint;
     Database_ = database;

odbc/src/utils/convert.cpp

@@ -312,10 +312,15 @@ SQLRETURN ConvertColumn(TValueParser& parser, SQLSMALLINT targetType, SQLPOINTER
 
     switch (targetType) {
         case SQL_C_SLONG:
+        case SQL_C_LONG:
         {
             int32_t v = 0;
             switch (ydbType) {
-                case EPrimitiveType::Int32: v = parser.GetInt32(); break;
+                case EPrimitiveType::Int16: v = static_cast<int32_t>(parser.GetInt16()); break;
+                case EPrimitiveType::Uint16: v = static_cast<int32_t>(parser.GetUint16()); break;
+                case EPrimitiveType::Int8: v = static_cast<int32_t>(parser.GetInt8()); break;
+                case EPrimitiveType::Uint8: v = static_cast<int32_t>(parser.GetUint8()); break;
+                case EPrimitiveType::Int32: v = static_cast<int32_t>(parser.GetInt32()); break;
                 case EPrimitiveType::Uint32: v = static_cast<int32_t>(parser.GetUint32()); break;
                 case EPrimitiveType::Int64: v = static_cast<int32_t>(parser.GetInt64()); break;
                 case EPrimitiveType::Uint64: v = static_cast<int32_t>(parser.GetUint64()); break;

odbc/tests/CMakeLists.txt

@@ -1,2 +1,2 @@
-#add_subdirectory(integration)
+add_subdirectory(integration)
 add_subdirectory(unit)

odbc/tests/integration/CMakeLists.txt

@@ -0,0 +1,4 @@
+add_odbc_test(NAME odbc-basic_it
+  SOURCES
+    basic_it.cpp
+)

odbc/tests/integration/basic_it.cpp

@@ -0,0 +1,123 @@
+#include <gtest/gtest.h>
+
+#include <sql.h>
+#include <sqlext.h>
+
+#include <string>
+
+
+#define CHECK_ODBC_OK(rc, handle, type) \
+    ASSERT_TRUE((rc) == SQL_SUCCESS || (rc) == SQL_SUCCESS_WITH_INFO) << GetOdbcError(handle, type)
+
+std::string GetOdbcError(SQLHANDLE handle, SQLSMALLINT type) {
+    SQLCHAR sqlState[6], message[256];
+    SQLINTEGER nativeError;
+    SQLSMALLINT textLength;
+    SQLRETURN rc = SQLGetDiagRec(type, handle, 1, sqlState, &nativeError, message, sizeof(message), &textLength);
+    if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO) {
+        return std::string((char*)sqlState) + ": " + (char*)message;
+    }
+    return "Unknown ODBC error";
+}
+
+const char* kConnStr = "Driver=" ODBC_DRIVER_PATH ";Endpoint=localhost:2136;Database=/local;";
+
+TEST(OdbcBasic, SimpleQuery) {
+    SQLHENV env;
+    SQLHDBC dbc;
+    SQLHSTMT stmt;
+    ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env), SQL_SUCCESS);
+    ASSERT_EQ(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0), SQL_SUCCESS);
+    ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS);
+    CHECK_ODBC_OK(SQLDriverConnect(dbc, nullptr, (SQLCHAR*)kConnStr, SQL_NTS, nullptr, 0, nullptr, SQL_DRIVER_COMPLETE), dbc, SQL_HANDLE_DBC);
+    ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS);
+
+    // Simple query
+    CHECK_ODBC_OK(SQLExecDirect(stmt, (SQLCHAR*)"SELECT 1 AS one, 'abc' AS str", SQL_NTS), stmt, SQL_HANDLE_STMT);
+    ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS);
+
+    SQLINTEGER ival = 0;
+    char sval[16] = {0};
+    SQLLEN ival_ind = 0, sval_ind = 0;
+    ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &ival, 0, &ival_ind), SQL_SUCCESS);
+    ASSERT_EQ(SQLGetData(stmt, 2, SQL_C_CHAR, sval, sizeof(sval), &sval_ind), SQL_SUCCESS);
+    ASSERT_EQ(ival, 1);
+    ASSERT_STREQ(sval, "abc");
+    SQLFreeHandle(SQL_HANDLE_STMT, stmt);
+    SQLDisconnect(dbc);
+    SQLFreeHandle(SQL_HANDLE_DBC, dbc);
+    SQLFreeHandle(SQL_HANDLE_ENV, env);
+}
+
+TEST(OdbcBasic, ParameterizedQuery) {
+    SQLHENV env;
+    SQLHDBC dbc;
+    SQLHSTMT stmt;
+    ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env), SQL_SUCCESS);
+    ASSERT_EQ(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0), SQL_SUCCESS);
+    ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS);
+    CHECK_ODBC_OK(SQLDriverConnect(dbc, nullptr, (SQLCHAR*)kConnStr, SQL_NTS, nullptr, 0, nullptr, SQL_DRIVER_COMPLETE), dbc, SQL_HANDLE_DBC);
+    ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS);
+
+    SQLCHAR query[] = R"(
+        DECLARE $p1 AS Int32?;
+        SELECT $p1 + 10 AS res;
+    )";
+
+    // Parameterized query
+    CHECK_ODBC_OK(SQLPrepare(stmt, query, SQL_NTS), stmt, SQL_HANDLE_STMT);
+    SQLINTEGER param = 5;
+    CHECK_ODBC_OK(SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 0, 0, &param, 0, nullptr), stmt, SQL_HANDLE_STMT);
+    CHECK_ODBC_OK(SQLExecute(stmt), stmt, SQL_HANDLE_STMT);
+
+    ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS);
+
+    SQLINTEGER res = 0;
+    SQLLEN res_ind = 0;
+    ASSERT_EQ(SQLGetData(stmt, 1, SQL_C_LONG, &res, 0, &res_ind), SQL_SUCCESS);
+    ASSERT_EQ(res, 15);
+    SQLFreeHandle(SQL_HANDLE_STMT, stmt);
+    SQLDisconnect(dbc);
+    SQLFreeHandle(SQL_HANDLE_DBC, dbc);
+    SQLFreeHandle(SQL_HANDLE_ENV, env);
+}
+
+TEST(OdbcBasic, ColumnBinding) {
+    SQLHENV env;
+    SQLHDBC dbc;
+    SQLHSTMT stmt;
+    ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env), SQL_SUCCESS);
+    ASSERT_EQ(SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0), SQL_SUCCESS);
+    ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc), SQL_SUCCESS);
+    CHECK_ODBC_OK(SQLDriverConnect(dbc, nullptr, (SQLCHAR*)kConnStr, SQL_NTS, nullptr, 0, nullptr, SQL_DRIVER_COMPLETE), dbc, SQL_HANDLE_DBC);
+    ASSERT_EQ(SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt), SQL_SUCCESS);
+
+    SQLCHAR query_ddl[] = R"(
+        DROP TABLE IF EXISTS test_bind;
+        CREATE TABLE test_bind (id Int32, name Text, PRIMARY KEY (id));
+    )";
+
+    SQLCHAR query[] = R"(
+        UPSERT INTO test_bind (id, name) VALUES (1, 'foo'), (2, 'bar');
+        SELECT id, name FROM test_bind ORDER BY id;
+    )";
+
+    CHECK_ODBC_OK(SQLExecDirect(stmt, query_ddl, SQL_NTS), stmt, SQL_HANDLE_STMT);
+    CHECK_ODBC_OK(SQLExecDirect(stmt, query, SQL_NTS), stmt, SQL_HANDLE_STMT);
+
+    SQLINTEGER id = 0;
+    char name[16] = {0};
+    SQLLEN id_ind = 0, name_ind = 0;
+    ASSERT_EQ(SQLBindCol(stmt, 1, SQL_C_LONG, &id, 0, &id_ind), SQL_SUCCESS);
+    ASSERT_EQ(SQLBindCol(stmt, 2, SQL_C_CHAR, name, sizeof(name), &name_ind), SQL_SUCCESS);
+    ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS);
+    ASSERT_EQ(id, 1);
+    ASSERT_STREQ(name, "foo");
+    ASSERT_EQ(SQLFetch(stmt), SQL_SUCCESS);
+    ASSERT_EQ(id, 2);
+    ASSERT_STREQ(name, "bar");
+    SQLFreeHandle(SQL_HANDLE_STMT, stmt);
+    SQLDisconnect(dbc);
+    SQLFreeHandle(SQL_HANDLE_DBC, dbc);
+    SQLFreeHandle(SQL_HANDLE_ENV, env);
+}