ODBC MVP

Author: Gazizonoki

CMakeLists.txt

@@ -65,7 +65,7 @@ add_subdirectory(c_api)
 #_ydb_sdk_validate_public_headers()
 
 if (YDB_SDK_ODBC)
-  #add_subdirectory(odbc)
+  add_subdirectory(odbc)
 endif()
 
 if (YDB_SDK_EXAMPLES)

c_api/CMakeLists.txt

@@ -1,4 +1,6 @@
-add_library(ydb-c-api STATIC
+_ydb_sdk_add_library(ydb-c-api SHARED)
+
+target_sources(ydb-c-api PRIVATE
   src/driver.cpp
   src/query.cpp
   src/result.cpp

cmake/common.cmake

@@ -115,7 +115,7 @@ function(generate_enum_serilization Tgt Input)
 endfunction()
 
 function(add_global_library_for TgtName MainName)
-  add_library(${TgtName} STATIC ${ARGN})
+  _ydb_sdk_add_library(${TgtName} STATIC ${ARGN})
   if(APPLE)
     target_link_options(${MainName} INTERFACE "SHELL:-Wl,-force_load,$<TARGET_FILE:$<INSTALL_INTERFACE:YDB-CPP-SDK::>${TgtName}>")
   else()
@@ -182,7 +182,7 @@ endfunction()
 
 function(_ydb_sdk_add_library Tgt)
   cmake_parse_arguments(ARG
-    "INTERFACE;OBJECT" "" ""
+    "INTERFACE;OBJECT;SHARED" "" ""
     ${ARGN}
   )
 
@@ -195,6 +195,9 @@ function(_ydb_sdk_add_library Tgt)
   if (ARG_OBJECT)
     set(libraryMode "OBJECT")
   endif()
+  if (ARG_SHARED)
+    set(libraryMode "SHARED")
+  endif()
   add_library(${Tgt} ${libraryMode})
   target_include_directories(${Tgt} ${includeMode}
     $<BUILD_INTERFACE:${YDB_SDK_SOURCE_DIR}>
@@ -204,6 +207,7 @@ function(_ydb_sdk_add_library Tgt)
   target_compile_definitions(${Tgt} ${includeMode}
     YDB_SDK_USE_STD_STRING
   )
+  set_property(TARGET ${Tgt} PROPERTY POSITION_INDEPENDENT_CODE ON)
 endfunction()
 
 function(_ydb_sdk_validate_public_headers)

cmake/external_libs.cmake

@@ -15,6 +15,10 @@ find_package(jwt-cpp REQUIRED)
 find_package(GTest REQUIRED)
 find_package(double-conversion REQUIRED)
 
+if (YDB_SDK_ODBC)
+  find_package(ODBC REQUIRED)
+endif()
+
 # RapidJSON
 if (YDB_SDK_USE_RAPID_JSON)
   find_package(RapidJSON REQUIRED)

odbc/CMakeLists.txt

@@ -1,41 +1,31 @@
-cmake_minimum_required(VERSION 3.14)
-project(ydb-odbc VERSION 0.1.0 LANGUAGES C CXX)
-
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_EXTENSIONS OFF)
-
-# Находим зависимости
-find_package(ODBC REQUIRED)
-
 # Добавляем исходники
 add_library(ydb-odbc SHARED
-  src/driver.c
-  src/connection.c
-  src/statement.c
-  src/descriptor.c
-  src/client/driver.cpp
-  src/client/query.cpp
+  src/odbc_driver.cpp
+  src/connection.cpp
+  src/statement.cpp
+  src/environment.cpp
 )
 
 # Добавляем заголовочные файлы
 target_include_directories(ydb-odbc
-  PUBLIC
+  PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}/include
     ${ODBC_INCLUDE_DIRS}
-    /usr/include
-    /usr/local/include
 )
 
 # Линкуем с YDB SDK и ODBC
 target_link_libraries(ydb-odbc
-  PUBLIC
+  PRIVATE
     ydb-cpp-sdk::Query
     ydb-cpp-sdk::Table
     ydb-cpp-sdk::Driver
     ODBC::ODBC
 )
 
+set_target_properties(ydb-odbc PROPERTIES
+  POSITION_INDEPENDENT_CODE ON
+)
+
 # Устанавливаем драйвер
 install(TARGETS ydb-odbc
   LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
@@ -46,6 +36,8 @@ install(DIRECTORY include/
   DESTINATION include/ydb-odbc
 )
 
+add_subdirectory(examples)
+
 # Добавляем тесты
 # add_subdirectory(tests)
 

odbc/examples/CMakeLists.txt

@@ -0,0 +1 @@
+add_subdirectory(basic)

odbc/examples/basic/CMakeLists.txt

@@ -0,0 +1,14 @@
+add_executable(odbc_basic
+    main.cpp
+)
+
+target_link_libraries(odbc_basic
+    PRIVATE
+        ODBC::ODBC
+)
+target_compile_definitions(odbc_basic 
+    PRIVATE 
+        ODBC_DRIVER_PATH="$<TARGET_FILE:ydb-odbc>"
+)
+
+add_dependencies(odbc_basic ydb-odbc)

odbc/examples/basic/main.cpp

@@ -0,0 +1,141 @@
+#include <sql.h>
+#include <sqlext.h>
+
+#include <iostream>
+#include <cstring>
+#include <cstdlib>
+#include <cstdint>
+
+void PrintOdbcError(SQLSMALLINT handleType, SQLHANDLE handle) {
+    SQLCHAR sqlState[6] = {0};
+    SQLINTEGER nativeError = 0;
+    SQLCHAR message[256] = {0};
+    SQLSMALLINT textLength = 0;
+    SQLGetDiagRec(handleType, handle, 1, sqlState, &nativeError, message, sizeof(message), &textLength);
+    std::cerr << "ODBC error: [" << sqlState << "] " << message << std::endl;
+}
+
+int main() {
+    SQLHENV henv = nullptr;
+    SQLHDBC hdbc = nullptr;
+    SQLHSTMT hstmt = nullptr;
+    SQLRETURN ret;
+
+    std::cout << "1. Allocating environment handle" << std::endl;
+    ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
+    if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) {
+        std::cerr << "Error allocating environment handle" << std::endl;
+        return 1;
+    }
+    SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0);
+
+    std::cout << "2. Allocating connection handle" << std::endl;
+    ret = SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc);
+    if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) {
+        std::cerr << "Error allocating connection handle" << std::endl;
+        SQLFreeHandle(SQL_HANDLE_ENV, henv);
+        return 1;
+    }
+
+    std::cout << "3. Building connection string" << std::endl;
+    std::string connStr = "Driver=" ODBC_DRIVER_PATH ";Endpoint=localhost:2136;Database=/local;";
+    SQLCHAR outConnStr[1024] = {0};
+    SQLSMALLINT outConnStrLen = 0;
+
+    std::cout << "4. Connecting with SQLDriverConnect" << std::endl;
+    ret = SQLDriverConnect(hdbc, NULL, (SQLCHAR*)connStr.c_str(), SQL_NTS,
+                          outConnStr, sizeof(outConnStr), &outConnStrLen, SQL_DRIVER_COMPLETE);
+    if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) {
+        std::cerr << "Error connecting with SQLDriverConnect" << std::endl;
+        PrintOdbcError(SQL_HANDLE_DBC, hdbc);
+        SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
+        SQLFreeHandle(SQL_HANDLE_ENV, henv);
+        return 1;
+    }
+
+    std::cout << "5. Allocating statement handle" << std::endl;
+    ret = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt);
+    if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) {
+        std::cerr << "Error allocating statement handle" << std::endl;
+        SQLDisconnect(hdbc);
+        SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
+        SQLFreeHandle(SQL_HANDLE_ENV, henv);
+        return 1;
+    }
+
+    std::cout << "6. Executing query" << std::endl;
+    SQLCHAR query[] = R"(
+        DECLARE $p1 AS Int64;
+        SELECT $p1 + 1, 'test1' as String;
+        SELECT $p1 + 2, 'test2' as String;
+        SELECT $p1 + 3, 'test3' as String;
+        SELECT $p1 + 4, 'test4' as String;
+        SELECT $p1 + 5, 'test5' as String;
+        SELECT $p1 + 6, 'test6' as String;
+        SELECT $p1 + 7, 'test7' as String;
+        SELECT $p1 + 8, 'test8' as String;
+        SELECT $p1 + 9, 'test9' as String;
+    )";
+
+    int64_t paramValue = 42;
+    SQLLEN paramInd = 0;
+    ret = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_SBIGINT, SQL_BIGINT, 0, 0, &paramValue, 0, &paramInd);
+    if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) {
+        std::cerr << "Error binding parameter" << std::endl;
+        PrintOdbcError(SQL_HANDLE_STMT, hstmt);
+        SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
+        SQLDisconnect(hdbc);
+        SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
+        SQLFreeHandle(SQL_HANDLE_ENV, henv);
+        return 1;
+    }
+
+    ret = SQLExecDirect(hstmt, query, SQL_NTS);
+    if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) {
+        std::cerr << "Error executing query" << std::endl;
+        PrintOdbcError(SQL_HANDLE_STMT, hstmt);
+        SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
+        SQLDisconnect(hdbc);
+        SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
+        SQLFreeHandle(SQL_HANDLE_ENV, henv);
+        return 1;
+    }
+
+    std::cout << "7. Fetching result" << std::endl;
+
+    SQLLEN ind = 0;
+    int value1 = 0;
+    if (SQLBindCol(hstmt, 1, SQL_C_SLONG, &value1, 0, &ind) != SQL_SUCCESS) {
+        std::cerr << "Error binding column 1" << std::endl;
+        PrintOdbcError(SQL_HANDLE_STMT, hstmt);
+        return 1;
+    }
+
+    SQLCHAR value2[1024] = {0};
+    if (SQLBindCol(hstmt, 2, SQL_C_CHAR, &value2, 1024, &ind) != SQL_SUCCESS) {
+        std::cerr << "Error binding column 2" << std::endl;
+        PrintOdbcError(SQL_HANDLE_STMT, hstmt);
+        return 1;
+    }
+
+    while ((ret = SQLFetch(hstmt)) == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO) {
+        if (ret != SQL_SUCCESS) {
+            std::cerr << "Error fetching result" << std::endl;
+            PrintOdbcError(SQL_HANDLE_STMT, hstmt);
+            return 1;
+        }
+
+        std::cout << "Result column 1: " << value1 << std::endl;
+        std::cout << "Result column 2: " << value2 << std::endl;
+
+        std::cout << "--------------------------------" << std::endl;
+    }
+
+    std::cout << "8. Cleaning up" << std::endl;
+    SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
+    SQLDisconnect(hdbc);
+    SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
+    SQLFreeHandle(SQL_HANDLE_ENV, henv);
+
+    return 0;
+}