IGNITE-5923: ODBC: SQLGetTypeInfo now works with SQL_ALL_TYPES

modules/platforms/cpp/odbc-test/Makefile.am

@@ -61,6 +61,7 @@ ignite_odbc_tests_SOURCES = \
     src/column_test.cpp \
     src/configuration_test.cpp \
     src/row_test.cpp \
+    src/meta_queries_test.cpp \
     src/utility_test.cpp \
     src/queries_test.cpp \
     src/test_utils.cpp \

modules/platforms/cpp/odbc-test/include/complex_type.h

@@ -1,4 +1,4 @@
-/*
+/*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
@@ -21,7 +21,6 @@
 #include <string>
 
 #include "ignite/ignite.h"
-#include "ignite/ignition.h"
 
 namespace ignite
 {
@@ -34,6 +33,18 @@ namespace ignite
             // No-op.
         }
 
+        friend bool operator==(TestObject const& lhs, TestObject const& rhs)
+        {
+            return lhs.f1 == rhs.f1 && lhs.f2 == rhs.f2;
+        }
+
+        friend std::ostream& operator<<(std::ostream& str, TestObject const& obj)
+        {
+            str << "TestObject::f1: " << obj.f1
+                << "TestObject::f2: " << obj.f2;
+            return str;
+        }
+
         int32_t f1;
         std::string f2;
     };
@@ -46,35 +57,23 @@ namespace ignite
             // No-op.
         }
 
+        friend bool operator==(ComplexType const& lhs, ComplexType const& rhs)
+        {
+            return lhs.i32Field == rhs.i32Field && lhs.objField == rhs.objField && lhs.strField == rhs.strField;
+        }
+
+        friend std::ostream& operator<<(std::ostream& str, ComplexType const& obj)
+        {
+            str << "ComplexType::i32Field: " << obj.i32Field
+                << "ComplexType::objField: " << obj.objField
+                << "ComplexType::strField: " << obj.strField;
+            return str;
+        }
+
         int32_t i32Field;
         TestObject objField;
         std::string strField;
     };
-
-    bool operator==(TestObject const& lhs, TestObject const& rhs)
-    {
-        return lhs.f1 == rhs.f1 && lhs.f2 == rhs.f2;
-    }
-
-    bool operator==(ComplexType const& lhs, ComplexType const& rhs)
-    {
-        return lhs.i32Field == rhs.i32Field && lhs.objField == rhs.objField && lhs.strField == rhs.strField;
-    }
-
-    std::ostream& operator<<(std::ostream& str, TestObject const& obj)
-    {
-        str << "TestObject::f1: " << obj.f1
-            << "TestObject::f2: " << obj.f2;
-        return str;
-    }
-
-    std::ostream& operator<<(std::ostream& str, ComplexType const& obj)
-    {
-        str << "ComplexType::i32Field: " << obj.i32Field
-            << "ComplexType::objField: " << obj.objField
-            << "ComplexType::strField: " << obj.strField;
-        return str;
-    }
 }
 
 namespace ignite

modules/platforms/cpp/odbc-test/project/vs/odbc-test.vcxproj

@@ -168,6 +168,7 @@
     <ClCompile Include="..\..\src\configuration_test.cpp" />
     <ClCompile Include="..\..\src\connection_info_test.cpp" />
     <ClCompile Include="..\..\src\cursor_test.cpp" />
+    <ClCompile Include="..\..\src\meta_queries_test.cpp" />
     <ClCompile Include="..\..\src\queries_test.cpp" />
     <ClCompile Include="..\..\src\parser_test.cpp" />
     <ClCompile Include="..\..\src\row_test.cpp" />

modules/platforms/cpp/odbc-test/project/vs/odbc-test.vcxproj.filters

@@ -121,6 +121,9 @@
     <ClCompile Include="..\..\..\odbc\src\log.cpp">
       <Filter>Externals</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\src\meta_queries_test.cpp">
+      <Filter>Code</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\include\test_type.h">

modules/platforms/cpp/odbc-test/src/meta_queries_test.cpp

@@ -0,0 +1,189 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifdef _WIN32
+#   include <windows.h>
+#endif
+
+#include <sql.h>
+#include <sqlext.h>
+
+#include <vector>
+#include <string>
+#include <algorithm>
+
+#ifndef _MSC_VER
+#   define BOOST_TEST_DYN_LINK
+#endif
+
+#include <boost/test/unit_test.hpp>
+
+#include "ignite/ignition.h"
+
+#include "ignite/common/fixed_size_array.h"
+#include "ignite/impl/binary/binary_utils.h"
+
+#include "test_type.h"
+#include "complex_type.h"
+#include "test_utils.h"
+
+using namespace ignite;
+using namespace ignite::cache;
+using namespace ignite::cache::query;
+using namespace ignite::common;
+using namespace ignite_test;
+using namespace ignite::binary;
+using namespace ignite::impl::binary;
+using namespace ignite::impl::interop;
+
+using namespace boost::unit_test;
+
+/**
+ * Test setup fixture.
+ */
+struct MetaQueriesTestSuiteFixture 
+{
+    /**
+     * Establish connection to node.
+     *
+     * @param connectStr Connection string.
+     */
+    void Connect(const std::string& connectStr)
+    {
+        // Allocate an environment handle
+        SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env);
+
+        BOOST_REQUIRE(env != NULL);
+
+        // We want ODBC 3 support
+        SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, reinterpret_cast<void*>(SQL_OV_ODBC3), 0);
+
+        // Allocate a connection handle
+        SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc);
+
+        BOOST_REQUIRE(dbc != NULL);
+
+        // Connect string
+        std::vector<SQLCHAR> connectStr0;
+
+        connectStr0.reserve(connectStr.size() + 1);
+        std::copy(connectStr.begin(), connectStr.end(), std::back_inserter(connectStr0));
+
+        SQLCHAR outstr[ODBC_BUFFER_SIZE];
+        SQLSMALLINT outstrlen;
+
+        // Connecting to ODBC server.
+        SQLRETURN ret = SQLDriverConnect(dbc, NULL, &connectStr0[0], static_cast<SQLSMALLINT>(connectStr0.size()),
+            outstr, sizeof(outstr), &outstrlen, SQL_DRIVER_COMPLETE);
+
+        if (!SQL_SUCCEEDED(ret))
+        {
+            Ignition::Stop(grid.GetName(), true);
+
+            BOOST_FAIL(GetOdbcErrorMessage(SQL_HANDLE_DBC, dbc));
+        }
+
+        // Allocate a statement handle
+        SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt);
+
+        BOOST_REQUIRE(stmt != NULL);
+    }
+
+    void Disconnect()
+    {
+        // Releasing statement handle.
+        SQLFreeHandle(SQL_HANDLE_STMT, stmt);
+
+        // Disconneting from the server.
+        SQLDisconnect(dbc);
+
+        // Releasing allocated handles.
+        SQLFreeHandle(SQL_HANDLE_DBC, dbc);
+        SQLFreeHandle(SQL_HANDLE_ENV, env);
+    }
+
+    static Ignite StartAdditionalNode(const char* name)
+    {
+#ifdef IGNITE_TESTS_32
+        return StartNode("queries-test-noodbc-32.xml", name);
+#else
+        return StartNode("queries-test-noodbc.xml", name);
+#endif
+    }
+
+    /**
+     * Constructor.
+     */
+    MetaQueriesTestSuiteFixture() :
+        cache1(0),
+        cache2(0),
+        env(NULL),
+        dbc(NULL),
+        stmt(NULL)
+    {
+#ifdef IGNITE_TESTS_32
+        grid = StartNode("queries-test-32.xml", "NodeMain");
+#else
+        grid = StartNode("queries-test.xml", "NodeMain");
+#endif
+
+        cache1 = grid.GetCache<int64_t, TestType>("cache");
+        cache2 = grid.GetCache<int64_t, ComplexType>("cache2");
+    }
+
+    /**
+     * Destructor.
+     */
+    ~MetaQueriesTestSuiteFixture()
+    {
+        Disconnect();
+
+        Ignition::StopAll(true);
+    }
+
+    /** Node started during the test. */
+    Ignite grid;
+
+    /** Frist cache instance. */
+    Cache<int64_t, TestType> cache1;
+
+    /** Second cache instance. */
+    Cache<int64_t, ComplexType> cache2;
+
+    /** ODBC Environment. */
+    SQLHENV env;
+
+    /** ODBC Connect. */
+    SQLHDBC dbc;
+
+    /** ODBC Statement. */
+    SQLHSTMT stmt;
+};
+
+BOOST_FIXTURE_TEST_SUITE(MetaQueriesTestSuite, MetaQueriesTestSuiteFixture)
+
+BOOST_AUTO_TEST_CASE(TestGetTypeInfoAllTypes)
+{
+    Connect("DRIVER={Apache Ignite};ADDRESS=127.0.0.1:11110;SCHEMA=cache");
+
+    SQLRETURN ret = SQLGetTypeInfo(stmt, SQL_ALL_TYPES);
+
+    if (!SQL_SUCCEEDED(ret))
+        BOOST_FAIL(GetOdbcErrorMessage(SQL_HANDLE_STMT, stmt));
+}
+
+BOOST_AUTO_TEST_SUITE_END()

modules/platforms/cpp/odbc/src/odbc.cpp

@@ -1019,7 +1019,7 @@ namespace ignite
     {
         using odbc::Statement;
 
-        LOG_MSG("SQLGetTypeInfo called");
+        LOG_MSG("SQLGetTypeInfo called: [type=" << type << ']');
 
         Statement *statement = reinterpret_cast<Statement*>(stmt);
 

modules/platforms/cpp/odbc/src/query/type_info_query.cpp

@@ -155,7 +155,7 @@ namespace ignite
                 columnsMeta.push_back(ColumnMeta(sch, tbl, "NUM_PREC_RADIX",     IGNITE_TYPE_INT));
                 columnsMeta.push_back(ColumnMeta(sch, tbl, "INTERVAL_PRECISION", IGNITE_TYPE_SHORT));
 
-                assert(IsSqlTypeSupported(sqlType));
+                assert(IsSqlTypeSupported(sqlType) || sqlType == SQL_ALL_TYPES);
 
                 if (sqlType == SQL_ALL_TYPES)
                 {

modules/platforms/cpp/odbc/src/statement.cpp

@@ -671,7 +671,7 @@ namespace ignite
 
         SqlResult::Type Statement::InternalExecuteGetTypeInfoQuery(int16_t sqlType)
         {
-            if (!type_traits::IsSqlTypeSupported(sqlType))
+            if (sqlType != SQL_ALL_TYPES && !type_traits::IsSqlTypeSupported(sqlType))
             {
                 std::stringstream builder;
                 builder << "Data type is not supported. [typeId=" << sqlType << ']';