Skip to content

Implement SQLAllocConnect and SQLFreeConnect #21

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
rscales wants to merge 1 commit into from
Closed

Implement SQLAllocConnect and SQLFreeConnect #21

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
59 changes: 52 additions & 7 deletions cpp/src/arrow/flight/sql/odbc/entry_points.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -27,21 +27,66 @@
#include "arrow/flight/sql/odbc/odbc_api.h"
#include "arrow/flight/sql/odbc/visibility.h"

SQLRETURN SQL_API SQLAllocHandle(SQLSMALLINT type, SQLHANDLE parent,
SQLHANDLE* result) {
return arrow::SQLAllocHandle(type, parent, result);
SQLRETURN SQL_API SQLAllocHandle(SQLSMALLINT type, SQLHANDLE parent, SQLHANDLE* result) {

switch (type) {
case SQL_HANDLE_ENV: {
return arrow::SQLAllocEnv(result);
}

case SQL_HANDLE_DBC: {
return arrow::SQLAllocConnect(parent, result);
}

case SQL_HANDLE_STMT: {
return SQL_INVALID_HANDLE;
}

default: {
return SQL_ERROR;
}
}
}

SQLRETURN SQL_API SQLAllocEnv(SQLHENV* env) {
return arrow::SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, env);
return arrow::SQLAllocEnv(env);
}

SQLRETURN SQL_API SQLAllocConnect(SQLHENV env, SQLHDBC* conn) {
return arrow::SQLAllocConnect(env, conn);
}

SQLRETURN SQL_API SQLFreeHandle(SQLSMALLINT type, SQLHANDLE handle) {

switch (type) {
case SQL_HANDLE_ENV: {
return arrow::SQLFreeEnv(handle);
}

case SQL_HANDLE_DBC: {
return arrow::SQLFreeConnect(handle);
}

case SQL_HANDLE_STMT: {
return SQL_INVALID_HANDLE;
}

case SQL_HANDLE_DESC: {
return SQL_INVALID_HANDLE;
}

default: {
return SQL_ERROR;
}
}
}

SQLRETURN SQL_API SQLFreeEnv(SQLHENV env) {
return arrow::SQLFreeHandle(SQL_HANDLE_ENV, env);
return arrow::SQLFreeEnv(env);
}

SQLRETURN SQLFreeHandle(SQLSMALLINT type, SQLHANDLE handle) {
return arrow::SQLFreeHandle(type, handle);
SQLRETURN SQL_API SQLFreeConnect(SQLHDBC conn) {
return arrow::SQLFreeConnect(conn);
}

SQLRETURN SQL_API SQLDriverConnect(SQLHDBC conn, SQLHWND windowHandle,
Expand Down
90 changes: 45 additions & 45 deletions cpp/src/arrow/flight/sql/odbc/odbc_api.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,6 +17,7 @@


#include <arrow/flight/sql/odbc/odbcabstraction/include/odbcabstraction/odbc_impl/odbc_environment.h>
#include <arrow/flight/sql/odbc/odbcabstraction/include/odbcabstraction/spi/connection.h>
#include <arrow/flight/sql/odbc/flight_sql/include/flight_sql/flight_sql_driver.h>

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

namespace arrow
{
SQLRETURN SQLAllocHandle(SQLSMALLINT type, SQLHANDLE parent, SQLHANDLE* result) {
// TODO: implement SQLAllocHandle by linking to `odbc_impl`
*result = 0;
SQLRETURN SQLAllocEnv(SQLHENV* env) {
using driver::flight_sql::FlightSqlDriver;
using ODBC::ODBCEnvironment;

switch (type)
{
case SQL_HANDLE_ENV: {
using ODBC::ODBCEnvironment;
using driver::flight_sql::FlightSqlDriver;
*env = SQL_NULL_HENV;

std::shared_ptr<FlightSqlDriver> odbc_driver = std::make_shared<FlightSqlDriver>();
*result = reinterpret_cast<SQLHENV>(new ODBCEnvironment(odbc_driver));
std::shared_ptr<FlightSqlDriver> odbc_driver = std::make_shared<FlightSqlDriver>();
*env = reinterpret_cast<SQLHENV>(new ODBCEnvironment(odbc_driver));

return SQL_SUCCESS;
}
return SQL_SUCCESS;
}

SQLRETURN SQLAllocConnect(SQLHENV env, SQLHDBC* conn) {
using ODBC::ODBCConnection;
using ODBC::ODBCEnvironment;

case SQL_HANDLE_DBC: {
return SQL_INVALID_HANDLE;
}
*conn = SQL_NULL_HDBC;

case SQL_HANDLE_STMT: {
return SQL_INVALID_HANDLE;
}
ODBCEnvironment* environment = reinterpret_cast<ODBCEnvironment*>(env);

default:
break;
if (!environment) {
return SQL_INVALID_HANDLE;
}

return SQL_ERROR;
}
std::shared_ptr<ODBCConnection> connection = environment->CreateConnection();

if (!connection) {
return environment->GetDiagnostics().GetNativeError(0);
}

*connection = reinterpret_cast<SQLHANDLE>(&connection);

SQLRETURN SQLFreeHandle(SQLSMALLINT type, SQLHANDLE handle)
{
switch (type) {
case SQL_HANDLE_ENV: {
using ODBC::ODBCEnvironment;
return SQL_SUCCESS;
}

ODBCEnvironment* environment = reinterpret_cast<ODBCEnvironment*>(handle);
SQLRETURN SQLFreeEnv(SQLHENV env) {
using ODBC::ODBCEnvironment;

if (!environment) {
return SQL_INVALID_HANDLE;
}
ODBCEnvironment* environment = reinterpret_cast<ODBCEnvironment*>(env);

delete environment;
if (!environment) {
return SQL_INVALID_HANDLE;
}

return SQL_SUCCESS;
}
delete environment;

case SQL_HANDLE_DBC:
return SQL_INVALID_HANDLE;
return SQL_SUCCESS;
}

case SQL_HANDLE_STMT:
return SQL_INVALID_HANDLE;
SQLRETURN SQLFreeConnect(SQLHDBC conn) {
using ODBC::ODBCConnection;

case SQL_HANDLE_DESC:
return SQL_INVALID_HANDLE;
ODBCConnection* odbc_conn = reinterpret_cast<ODBCConnection*>(conn);

default:
break;
if (!odbc_conn) {
return SQL_INVALID_HANDLE;
}

return SQL_ERROR;
}

// TODO: Fix Pointer or Reference to an incomplete type
// odbc_connection->releaseConnection();

delete odbc_conn;

return SQL_SUCCESS;
}

} // namespace arrow
6 changes: 3 additions & 3 deletions cpp/src/arrow/flight/sql/odbc/odbc_api.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -32,7 +32,7 @@
namespace arrow
{
SQLRETURN SQLAllocEnv(SQLHENV* env);
SQLRETURN SQLAllocHandle(SQLSMALLINT type, SQLHANDLE parent, SQLHANDLE* result);
SQLRETURN SQLAllocConnect(SQLHENV env, SQLHDBC* conn);
SQLRETURN SQLFreeEnv(SQLHENV env);
SQLRETURN SQLFreeHandle(SQLSMALLINT type, SQLHANDLE handle);
} //arrow
SQLRETURN SQLFreeConnect(SQLHDBC conn);
} // namespace arrow
80 changes: 80 additions & 0 deletions cpp/src/arrow/flight/sql/odbc/tests/connection_test.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -51,7 +51,42 @@ TEST(SQLAllocEnv, TestSQLAllocEnv) {
EXPECT_TRUE(return_value == SQL_SUCCESS);
}

TEST(SQLAllocHandle, TestSQLAllocHandleConnect) {

// ODBC Environment
SQLHENV env;
SQLHDBC conn;

// Allocate an environment handle
SQLRETURN return_value = SQLAllocEnv(&env);

EXPECT_TRUE(return_value == SQL_SUCCESS);

// Allocate a connection using alloc handle
SQLRETURN return_alloc_handle = SQLAllocHandle(SQL_HANDLE_DBC, env, &conn);

EXPECT_TRUE(return_alloc_handle == SQL_SUCCESS);
}

TEST(SQLAllocConnect, TestSQLAllocHandleConnect) {

// ODBC Environment
SQLHENV env;
SQLHDBC conn;

// Allocate an environment handle
SQLRETURN return_value = SQLAllocEnv(&env);

EXPECT_TRUE(return_value == SQL_SUCCESS);

// Allocate a connection using alloc handle
SQLRETURN return_alloc_connect = SQLAllocConnect(env, &conn);

EXPECT_TRUE(return_alloc_connect == SQL_SUCCESS);
}

TEST(SQLFreeHandle, TestSQLFreeHandleEnv) {

// ODBC Environment
SQLHENV env;

Expand All @@ -65,6 +100,7 @@ TEST(SQLFreeHandle, TestSQLFreeHandleEnv) {
}

TEST(SQLFreeEnv, TestSQLFreeEnv) {

// ODBC Environment
SQLHENV env;

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

TEST(SQLFreeHandle, TestSQLFreeHandleConnect) {

// ODBC Environment
SQLHENV env;
SQLHDBC conn;

// Allocate an environment handle
SQLRETURN return_value = SQLAllocEnv(&env);

EXPECT_TRUE(return_value == SQL_SUCCESS);

// Allocate a connection using alloc handle
SQLRETURN return_alloc_handle = SQLAllocHandle(SQL_HANDLE_DBC, env, &conn);

EXPECT_TRUE(return_alloc_handle == SQL_SUCCESS);

// Free the created connection using free handle
SQLRETURN return_free_handle = SQLFreeHandle(SQL_HANDLE_DBC, conn);

EXPECT_TRUE(return_free_handle == SQL_SUCCESS);
}

TEST(SQLFreeConnect, TestSQLFreeConnect) {

// ODBC Environment
SQLHENV env;
SQLHDBC conn;

// Allocate an environment handle
SQLRETURN return_env = SQLAllocEnv(&env);

EXPECT_TRUE(return_env == SQL_SUCCESS);

// Allocate a connection using alloc handle
SQLRETURN return_alloc_handle = SQLAllocHandle(SQL_HANDLE_DBC, env, &conn);

EXPECT_TRUE(return_alloc_handle == SQL_SUCCESS);

// Free the created connection using free connect
SQLRETURN return_free_connect = SQLFreeConnect(conn);

EXPECT_TRUE(return_free_connect == SQL_SUCCESS);
}

} // namespace integration_tests
} // namespace odbc
} // namespace flight
Expand Down