Skip to content

Commit 71a7a4a

Browse files
rscalesrscales
committed
Implement SQLAllocConnect and SQLFreeConnect
1 parent 0983cb0 commit 71a7a4a

4 files changed

Lines changed: 180 additions & 55 deletions

File tree

‎cpp/src/arrow/flight/sql/odbc/entry_points.cc‎

Lines changed: 52 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -27,21 +27,66 @@
2727
#include "arrow/flight/sql/odbc/odbc_api.h"
2828
#include "arrow/flight/sql/odbc/visibility.h"
2929

30-
SQLRETURN SQL_API SQLAllocHandle(SQLSMALLINT type, SQLHANDLE parent,
31-
SQLHANDLE* result) {
32-
return arrow::SQLAllocHandle(type, parent, result);
30+
SQLRETURN SQL_API SQLAllocHandle(SQLSMALLINT type, SQLHANDLE parent, SQLHANDLE* result) {
31+
32+
switch (type) {
33+
case SQL_HANDLE_ENV: {
34+
return arrow::SQLAllocEnv(result);
35+
}
36+
37+
case SQL_HANDLE_DBC: {
38+
return arrow::SQLAllocConnect(parent, result);
39+
}
40+
41+
case SQL_HANDLE_STMT: {
42+
return SQL_INVALID_HANDLE;
43+
}
44+
45+
default: {
46+
return SQL_ERROR;
47+
}
48+
}
3349
}
3450

3551
SQLRETURN SQL_API SQLAllocEnv(SQLHENV* env) {
36-
return arrow::SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, env);
52+
return arrow::SQLAllocEnv(env);
53+
}
54+
55+
SQLRETURN SQL_API SQLAllocConnect(SQLHENV env, SQLHDBC* conn) {
56+
return arrow::SQLAllocConnect(env, conn);
57+
}
58+
59+
SQLRETURN SQL_API SQLFreeHandle(SQLSMALLINT type, SQLHANDLE handle) {
60+
61+
switch (type) {
62+
case SQL_HANDLE_ENV: {
63+
return arrow::SQLFreeEnv(handle);
64+
}
65+
66+
case SQL_HANDLE_DBC: {
67+
return arrow::SQLFreeConnect(handle);
68+
}
69+
70+
case SQL_HANDLE_STMT: {
71+
return SQL_INVALID_HANDLE;
72+
}
73+
74+
case SQL_HANDLE_DESC: {
75+
return SQL_INVALID_HANDLE;
76+
}
77+
78+
default: {
79+
return SQL_ERROR;
80+
}
81+
}
3782
}
3883

3984
SQLRETURN SQL_API SQLFreeEnv(SQLHENV env) {
40-
return arrow::SQLFreeHandle(SQL_HANDLE_ENV, env);
85+
return arrow::SQLFreeEnv(env);
4186
}
4287

43-
SQLRETURN SQLFreeHandle(SQLSMALLINT type, SQLHANDLE handle) {
44-
return arrow::SQLFreeHandle(type, handle);
88+
SQLRETURN SQL_API SQLFreeConnect(SQLHDBC conn) {
89+
return arrow::SQLFreeConnect(conn);
4590
}
4691

4792
SQLRETURN SQL_API SQLDriverConnect(SQLHDBC conn, SQLHWND windowHandle,

‎cpp/src/arrow/flight/sql/odbc/odbc_api.cc‎

Lines changed: 45 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,7 @@
1717

1818

1919
#include <arrow/flight/sql/odbc/odbcabstraction/include/odbcabstraction/odbc_impl/odbc_environment.h>
20+
#include <arrow/flight/sql/odbc/odbcabstraction/include/odbcabstraction/spi/connection.h>
2021
#include <arrow/flight/sql/odbc/flight_sql/include/flight_sql/flight_sql_driver.h>
2122

2223
// odbc_api includes windows.h, which needs to be put behind winsock2.h.
@@ -25,71 +26,70 @@
2526

2627
namespace arrow
2728
{
28-
SQLRETURN SQLAllocHandle(SQLSMALLINT type, SQLHANDLE parent, SQLHANDLE* result) {
29-
// TODO: implement SQLAllocHandle by linking to `odbc_impl`
30-
*result = 0;
29+
SQLRETURN SQLAllocEnv(SQLHENV* env) {
30+
using driver::flight_sql::FlightSqlDriver;
31+
using ODBC::ODBCEnvironment;
3132

32-
switch (type)
33-
{
34-
case SQL_HANDLE_ENV: {
35-
using ODBC::ODBCEnvironment;
36-
using driver::flight_sql::FlightSqlDriver;
33+
*env = SQL_NULL_HENV;
3734

38-
std::shared_ptr<FlightSqlDriver> odbc_driver = std::make_shared<FlightSqlDriver>();
39-
*result = reinterpret_cast<SQLHENV>(new ODBCEnvironment(odbc_driver));
35+
std::shared_ptr<FlightSqlDriver> odbc_driver = std::make_shared<FlightSqlDriver>();
36+
*env = reinterpret_cast<SQLHENV>(new ODBCEnvironment(odbc_driver));
4037

41-
return SQL_SUCCESS;
42-
}
38+
return SQL_SUCCESS;
39+
}
40+
41+
SQLRETURN SQLAllocConnect(SQLHENV env, SQLHDBC* conn) {
42+
using ODBC::ODBCConnection;
43+
using ODBC::ODBCEnvironment;
4344

44-
case SQL_HANDLE_DBC: {
45-
return SQL_INVALID_HANDLE;
46-
}
45+
*conn = SQL_NULL_HDBC;
4746

48-
case SQL_HANDLE_STMT: {
49-
return SQL_INVALID_HANDLE;
50-
}
47+
ODBCEnvironment* environment = reinterpret_cast<ODBCEnvironment*>(env);
5148

52-
default:
53-
break;
49+
if (!environment) {
50+
return SQL_INVALID_HANDLE;
5451
}
5552

56-
return SQL_ERROR;
57-
}
53+
std::shared_ptr<ODBCConnection> connection = environment->CreateConnection();
54+
55+
if (!connection) {
56+
return environment->GetDiagnostics().GetNativeError(0);
57+
}
58+
59+
*connection = reinterpret_cast<SQLHANDLE>(&connection);
5860

59-
SQLRETURN SQLFreeHandle(SQLSMALLINT type, SQLHANDLE handle)
60-
{
61-
switch (type) {
62-
case SQL_HANDLE_ENV: {
63-
using ODBC::ODBCEnvironment;
61+
return SQL_SUCCESS;
62+
}
6463

65-
ODBCEnvironment* environment = reinterpret_cast<ODBCEnvironment*>(handle);
64+
SQLRETURN SQLFreeEnv(SQLHENV env) {
65+
using ODBC::ODBCEnvironment;
6666

67-
if (!environment) {
68-
return SQL_INVALID_HANDLE;
69-
}
67+
ODBCEnvironment* environment = reinterpret_cast<ODBCEnvironment*>(env);
7068

71-
delete environment;
69+
if (!environment) {
70+
return SQL_INVALID_HANDLE;
71+
}
7272

73-
return SQL_SUCCESS;
74-
}
73+
delete environment;
7574

76-
case SQL_HANDLE_DBC:
77-
return SQL_INVALID_HANDLE;
75+
return SQL_SUCCESS;
76+
}
7877

79-
case SQL_HANDLE_STMT:
80-
return SQL_INVALID_HANDLE;
78+
SQLRETURN SQLFreeConnect(SQLHDBC conn) {
79+
using ODBC::ODBCConnection;
8180

82-
case SQL_HANDLE_DESC:
83-
return SQL_INVALID_HANDLE;
81+
ODBCConnection* odbc_conn = reinterpret_cast<ODBCConnection*>(conn);
8482

85-
default:
86-
break;
83+
if (!odbc_conn) {
84+
return SQL_INVALID_HANDLE;
8785
}
8886

89-
return SQL_ERROR;
90-
}
91-
87+
// TODO: Fix Pointer or Reference to an incomplete type
88+
// odbc_connection->releaseConnection();
9289

90+
delete odbc_conn;
9391

92+
return SQL_SUCCESS;
93+
}
9494

9595
} // namespace arrow

‎cpp/src/arrow/flight/sql/odbc/odbc_api.h‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,7 @@
3232
namespace arrow
3333
{
3434
SQLRETURN SQLAllocEnv(SQLHENV* env);
35-
SQLRETURN SQLAllocHandle(SQLSMALLINT type, SQLHANDLE parent, SQLHANDLE* result);
35+
SQLRETURN SQLAllocConnect(SQLHENV env, SQLHDBC* conn);
3636
SQLRETURN SQLFreeEnv(SQLHENV env);
37-
SQLRETURN SQLFreeHandle(SQLSMALLINT type, SQLHANDLE handle);
38-
} //arrow
37+
SQLRETURN SQLFreeConnect(SQLHDBC conn);
38+
} // namespace arrow

‎cpp/src/arrow/flight/sql/odbc/tests/connection_test.cc‎

Lines changed: 80 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,42 @@ TEST(SQLAllocEnv, TestSQLAllocEnv) {
5151
EXPECT_TRUE(return_value == SQL_SUCCESS);
5252
}
5353

54+
TEST(SQLAllocHandle, TestSQLAllocHandleConnect) {
55+
56+
// ODBC Environment
57+
SQLHENV env;
58+
SQLHDBC conn;
59+
60+
// Allocate an environment handle
61+
SQLRETURN return_value = SQLAllocEnv(&env);
62+
63+
EXPECT_TRUE(return_value == SQL_SUCCESS);
64+
65+
// Allocate a connection using alloc handle
66+
SQLRETURN return_alloc_handle = SQLAllocHandle(SQL_HANDLE_DBC, env, &conn);
67+
68+
EXPECT_TRUE(return_alloc_handle == SQL_SUCCESS);
69+
}
70+
71+
TEST(SQLAllocConnect, TestSQLAllocHandleConnect) {
72+
73+
// ODBC Environment
74+
SQLHENV env;
75+
SQLHDBC conn;
76+
77+
// Allocate an environment handle
78+
SQLRETURN return_value = SQLAllocEnv(&env);
79+
80+
EXPECT_TRUE(return_value == SQL_SUCCESS);
81+
82+
// Allocate a connection using alloc handle
83+
SQLRETURN return_alloc_connect = SQLAllocConnect(env, &conn);
84+
85+
EXPECT_TRUE(return_alloc_connect == SQL_SUCCESS);
86+
}
87+
5488
TEST(SQLFreeHandle, TestSQLFreeHandleEnv) {
89+
5590
// ODBC Environment
5691
SQLHENV env;
5792

@@ -65,6 +100,7 @@ TEST(SQLFreeHandle, TestSQLFreeHandleEnv) {
65100
}
66101

67102
TEST(SQLFreeEnv, TestSQLFreeEnv) {
103+
68104
// ODBC Environment
69105
SQLHENV env;
70106

@@ -77,6 +113,50 @@ TEST(SQLFreeEnv, TestSQLFreeEnv) {
77113
EXPECT_TRUE(return_value == SQL_SUCCESS);
78114
}
79115

116+
TEST(SQLFreeHandle, TestSQLFreeHandleConnect) {
117+
118+
// ODBC Environment
119+
SQLHENV env;
120+
SQLHDBC conn;
121+
122+
// Allocate an environment handle
123+
SQLRETURN return_value = SQLAllocEnv(&env);
124+
125+
EXPECT_TRUE(return_value == SQL_SUCCESS);
126+
127+
// Allocate a connection using alloc handle
128+
SQLRETURN return_alloc_handle = SQLAllocHandle(SQL_HANDLE_DBC, env, &conn);
129+
130+
EXPECT_TRUE(return_alloc_handle == SQL_SUCCESS);
131+
132+
// Free the created connection using free handle
133+
SQLRETURN return_free_handle = SQLFreeHandle(SQL_HANDLE_DBC, conn);
134+
135+
EXPECT_TRUE(return_free_handle == SQL_SUCCESS);
136+
}
137+
138+
TEST(SQLFreeConnect, TestSQLFreeConnect) {
139+
140+
// ODBC Environment
141+
SQLHENV env;
142+
SQLHDBC conn;
143+
144+
// Allocate an environment handle
145+
SQLRETURN return_env = SQLAllocEnv(&env);
146+
147+
EXPECT_TRUE(return_env == SQL_SUCCESS);
148+
149+
// Allocate a connection using alloc handle
150+
SQLRETURN return_alloc_handle = SQLAllocHandle(SQL_HANDLE_DBC, env, &conn);
151+
152+
EXPECT_TRUE(return_alloc_handle == SQL_SUCCESS);
153+
154+
// Free the created connection using free connect
155+
SQLRETURN return_free_connect = SQLFreeConnect(conn);
156+
157+
EXPECT_TRUE(return_free_connect == SQL_SUCCESS);
158+
}
159+
80160
} // namespace integration_tests
81161
} // namespace odbc
82162
} // namespace flight

0 commit comments

Comments
 (0)