Fix varchar limitation when max-len-attr is set (#231)

* Fix varchar limitation when max-len-attr is set

This fixes the result rewriting of the SQLColumns due to varchar limit
setting in case the SQL_ATTR_MAX_LENGTH attribute is set. The attribute
changes the lenght indicator given by SQLGetData to the value of the
attribute (which a setting application expects).
Since the rewriting is serialized on the statment, simply reset this
attribute's value while doing the writing.

The types of the columns in the rewritten result are also corrected
(they were copied from ES/SQL output, which are wrong and need fixing).

(cherry picked from commit c6556af)

Author: bpintea

driver/catalogue.c

@@ -176,7 +176,7 @@ SQLSMALLINT fetch_server_attr(esodbc_dbc_st *dbc, SQLINTEGER attr_id,
 	} else {
 		if (1 < row_cnt) {
 			WARNH(dbc, "more than one value (%lld) available for "
-				"attribute %ld; picking first.", row_cnt, attr_id);
+				"attribute %ld; picking first.", (int64_t)row_cnt, attr_id);
 		}
 
 		if (! SQL_SUCCEEDED(EsSQLBindCol(stmt, /*col#*/1, SQL_C_WCHAR, buff,
@@ -522,7 +522,7 @@ static SQLRETURN copy_one_cell(esodbc_stmt_st *stmt, wstr_st *dest,
 	/* fetch data's length (always converted to w-string) */
 	ret = EsSQLGetData(stmt, col_idx, SQL_C_WCHAR, dest->str, 0, &len_ind);
 	if (! SQL_SUCCEEDED(ret)) {
-		ERRH(stmt, "failed to get data lenght for cell@[%ld, %hd].",
+		ERRH(stmt, "failed to get data length for cell@[%ld, %hd].",
 			row_cnt, col_idx);
 		return ret;
 	}
@@ -577,17 +577,17 @@ SQLRETURN TEST_API update_varchar_defs(esodbc_stmt_st *stmt)
 			"{\"name\":\"TABLE_SCHEM\", \"type\":\"keyword\"},"
 			"{\"name\":\"TABLE_NAME\", \"type\":\"keyword\"},"
 			"{\"name\":\"COLUMN_NAME\", \"type\":\"keyword\"},"
-			"{\"name\":\"DATA_TYPE\", \"type\":\"integer\"},"
+			"{\"name\":\"DATA_TYPE\", \"type\":\"short\"},"
 			"{\"name\":\"TYPE_NAME\", \"type\":\"keyword\"},"
 			"{\"name\":\"COLUMN_SIZE\", \"type\":\"integer\"},"
 			"{\"name\":\"BUFFER_LENGTH\", \"type\":\"integer\"},"
-			"{\"name\":\"DECIMAL_DIGITS\", \"type\":\"integer\"},"
-			"{\"name\":\"NUM_PREC_RADIX\", \"type\":\"integer\"},"
-			"{\"name\":\"NULLABLE\", \"type\":\"integer\"},"
+			"{\"name\":\"DECIMAL_DIGITS\", \"type\":\"short\"},"
+			"{\"name\":\"NUM_PREC_RADIX\", \"type\":\"short\"},"
+			"{\"name\":\"NULLABLE\", \"type\":\"short\"},"
 			"{\"name\":\"REMARKS\", \"type\":\"keyword\"},"
 			"{\"name\":\"COLUMN_DEF\", \"type\":\"keyword\"},"
-			"{\"name\":\"SQL_DATA_TYPE\", \"type\":\"integer\"},"
-			"{\"name\":\"SQL_DATETIME_SUB\", \"type\":\"integer\"},"
+			"{\"name\":\"SQL_DATA_TYPE\", \"type\":\"short\"},"
+			"{\"name\":\"SQL_DATETIME_SUB\", \"type\":\"short\"},"
 			"{\"name\":\"CHAR_OCTET_LENGTH\", \"type\":\"integer\"},"
 			"{\"name\":\"ORDINAL_POSITION\", \"type\":\"integer\"},"
 			"{\"name\":\"IS_NULLABLE\", \"type\":\"keyword\"}"
@@ -605,9 +605,15 @@ SQLRETURN TEST_API update_varchar_defs(esodbc_stmt_st *stmt)
 	long row_cnt;
 	wstr_st dest = {0};
 	size_t pos;
+	SQLULEN max_length;
 	cstr_st u8mb;
 	wstr_st *lim = &HDRH(stmt)->dbc->varchar_limit_str;
 
+	/* save and reset SQL_ATTR_MAX_LENGTH attribute, it'll interfere with
+	 * reading length of avail data with SQLGetData() otherwise. */
+	max_length = stmt->max_length;
+	stmt->max_length = 0;
+
 	/* check that we have as many columns as members in target row struct */
 	ret = EsSQLNumResultCols(stmt, &col_cnt);
 	if (! SQL_SUCCEEDED(ret)) {
@@ -689,6 +695,8 @@ SQLRETURN TEST_API update_varchar_defs(esodbc_stmt_st *stmt)
 		free(dest.str);
 		dest.cnt = 0;
 	}
+	/* reinstate any saved SQL_ATTR_MAX_LENGTH value */
+	stmt->max_length = max_length;
 	return ret;
 }
 

driver/convert.c

@@ -52,7 +52,7 @@ static thread_local struct tm today;
 	} while (0)
 
 #define DBL_BASE10_MAX_LEN /*-0.*/3 + DBL_DIG - DBL_MIN_10_EXP
-/* maximum lenght of an interval literal (with terminator; both ISO and SQL),
+/* maximum length of an interval literal (with terminator; both ISO and SQL),
  * with no field sanity checks: five longs with separators and sign */
 #define INTERVAL_VAL_MAX_LEN (5 * sizeof("4294967295"))
 
@@ -2836,7 +2836,7 @@ static size_t print_interval_sec(esodbc_rec_st *rec, SQL_INTERVAL_STRUCT *ivl,
 
 		if (wide) {
 			wfmt[2] = L'0' + rec->precision;
-			/* printf's limits: max lenght of '<second>.<fraction>', accounted
+			/* printf's limits: max length of '<second>.<fraction>', accounted
 			 * in buffer's max len estimation. */
 			res = swprintf((wchar_t *)dest, 2 * sizeof("4294967295") + 1,
 					wfmt, dbl);

driver/defs.h

@@ -124,7 +124,7 @@
  */
 /* maximum URL size */
 #define ESODBC_MAX_URL_LEN				2048
-/* maximum DNS attribute value lenght (should be long enought to accomodate a
+/* maximum DNS attribute value length (should be long enought to accomodate a
  * decently long FQ file path name) */
 #define ESODBC_DSN_MAX_ATTR_LEN			1024
 

driver/dsn.c

@@ -93,7 +93,7 @@ int assign_dsn_attr(esodbc_dsn_attrs_st *attrs,
 		ESODBC_DSN_ATTRS_COUNT);
 
 	if (ESODBC_DSN_MAX_ATTR_LEN < value->cnt) {
-		ERR("attribute value lenght too large: %zu; max=%zu.", value->cnt,
+		ERR("attribute value length too large: %zu; max=%zu.", value->cnt,
 			ESODBC_DSN_MAX_ATTR_LEN);
 		return -1;
 	}
@@ -356,7 +356,7 @@ BOOL TEST_API parse_00_list(esodbc_dsn_attrs_st *attrs, SQLWCHAR *list00)
 		cnt = wcslen(pos);
 
 		if (SHRT_MAX < cnt) {
-			ERR("invalid list lenght (%zu).", cnt);
+			ERR("invalid list length (%zu).", cnt);
 			return FALSE;
 		}
 		if (! parse_connection_string(attrs, pos, (SQLSMALLINT)cnt)) {

driver/dsn.h

@@ -90,7 +90,7 @@ typedef struct {
 	wstr_st trace_level;
 #define ESODBC_DSN_ATTRS_COUNT	29
 	SQLWCHAR buff[ESODBC_DSN_ATTRS_COUNT * ESODBC_DSN_MAX_ATTR_LEN];
-	/* DSN reading/writing functions are passed a SQLSMALLINT lenght param */
+	/* DSN reading/writing functions are passed a SQLSMALLINT length param */
 #if SHRT_MAX < ESODBC_DSN_ATTRS_COUNT * ESODBC_DSN_MAX_ATTR_LEN
 #error "attrs buffer too large"
 #endif

driver/handles.h

@@ -176,7 +176,7 @@ typedef struct struct_dbc {
 	/* maximum precision/length of types using same SQL data type ID */
 	esodbc_estype_st *max_varchar_type; /* pointer to TEXT type */
 	esodbc_estype_st *max_float_type; /* pointer to DOUBLE type */
-	/* configuration imposed lenghts for the ES/SQL string types */
+	/* configuration imposed lengths for the ES/SQL string types */
 	SQLUINTEGER varchar_limit;
 	wstr_st varchar_limit_str; /* convenience w-string of varchar limit */
 

driver/util.h

@@ -336,7 +336,7 @@ char *cstr_hex_dump(const cstr_st *buff);
 #endif /* _WIN32 */
 
 
-/* ISO time formats lenghts.
+/* ISO time formats lengths.
  * ES/SQL interface should only use UTC ('Z'ulu offset). */
 #define ISO8601_TIMESTAMP_LEN(prec)		\
 	(sizeof("yyyy-mm-ddThh:mm:ss+hh:mm") - /*\0*/1 + /*'.'*/!!prec + prec)

test/test_catalogue.cc

@@ -92,6 +92,11 @@ TEST_F(Catalogue, Columns_update_varchar_defs) {
 		"]"
 	"}";
 
+	/* setting this attribute should not affect the outcome */
+	ret = SQLSetStmtAttr(stmt, SQL_ATTR_MAX_LENGTH, (SQLPOINTER)INT_MAX,
+			SQL_IS_UINTEGER);
+	ASSERT_TRUE(SQL_SUCCEEDED(ret));
+
 	prepareStatement(response);
 
 	/* needs to be lower than ESODBC_MAX_KEYWORD_PRECISION (~32k) */
@@ -120,6 +125,26 @@ TEST_F(Catalogue, Columns_update_varchar_defs) {
 		ASSERT_EQ(val, VARCHAR_LIMIT);
 	}
 
+	/* above SYS COLUMNS result contains wrong (integer) type for the following
+	 * columns that should be short */
+	const SQLUSMALLINT short_cols[] = {
+		SQLCOLS_IDX_DATA_TYPE,
+		SQLCOLS_IDX_DECIMAL_DIGITS,
+		SQLCOLS_IDX_NUM_PREC_RADIX,
+		SQLCOLS_IDX_NULLABLE,
+		SQLCOLS_IDX_SQL_DATA_TYPE,
+		SQLCOLS_IDX_SQL_DATETIME_SUB
+	};
+	SQLWCHAR col_name[128];
+	SQLSMALLINT col_name_len, sql_type, scale, nullable;
+	SQLULEN col_size;
+	for (size_t i = 0; i < sizeof(short_cols)/sizeof(short_cols[0]); i ++) {
+		ret = SQLDescribeCol(stmt, short_cols[i], col_name, sizeof(col_name),
+				&col_name_len, &sql_type, &col_size, &scale, &nullable);
+		ASSERT_TRUE(SQL_SUCCEEDED(ret));
+		ASSERT_EQ(sql_type, SQL_SMALLINT);
+	}
+
 	HDRH(stmt)->dbc->varchar_limit = 0;
 	memset(&HDRH(stmt)->dbc->varchar_limit_str, 0, sizeof(wstr_st));
 

test/test_queries.cc

@@ -267,6 +267,66 @@ TEST_F(Queries, SQLDescribeCol_char) {
 	ASSERT_EQ(nullable, SQL_NULLABLE_UNKNOWN);
 }
 
+TEST_F(Queries, SQLDescribeCol_varchar_lim) {
+
+#	undef COL_NAME
+#	define COL_NAME "SQLDescribeCol_varchar_lim"
+#	define VARCHAR_LIMIT 333
+#	define CONN_STR CONNECT_STRING "VarcharLimit=" STR(VARCHAR_LIMIT) ";"
+
+	const char json_answer[] = "\
+{\
+  \"columns\": [\
+    {\"name\": \"" COL_NAME "\", \"type\": \"text\"},\
+    {\"name\": \"binary\", \"type\": \"binary\"}\
+  ],\
+  \"rows\": [\
+    [\"foo\", \"binary\"]\
+  ]\
+}\
+";
+
+	/* set varchar limit: this is set onto the varchar types structures, so the
+	 * DBC needs "reconnecting" and the corresponding DSN param set */
+	ret = SQLFreeHandle(SQL_HANDLE_STMT, stmt);
+	assert(SQL_SUCCEEDED(ret));
+	ret = SQLFreeHandle(SQL_HANDLE_DBC, dbc);
+	assert(SQL_SUCCEEDED(ret));
+	ret = SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc);
+	assert(SQL_SUCCEEDED(ret));
+	cstr_st types = {0};
+	types.str = (SQLCHAR *)strdup(SYSTYPES_ANSWER);
+	assert(types.str != NULL);
+	types.cnt = sizeof(SYSTYPES_ANSWER) - 1;
+	ret = SQLDriverConnect(dbc, (SQLHWND)&types, (SQLWCHAR *)CONN_STR,
+			sizeof(CONN_STR) / sizeof(CONN_STR[0]) - 1, NULL, 0, NULL,
+			ESODBC_SQL_DRIVER_TEST);
+	assert(SQL_SUCCEEDED(ret));
+	ret = SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt);
+	assert(SQL_SUCCEEDED(ret));
+	assert(stmt != NULL);
+
+	prepareStatement(json_answer);
+
+	SQLWCHAR col_name[sizeof(COL_NAME)];
+	SQLSMALLINT col_name_len, sql_type, scale, nullable;
+	SQLULEN col_size;
+	/* text column */
+	ret = SQLDescribeCol(stmt, /*col#*/1, col_name, sizeof(col_name),
+			&col_name_len, &sql_type, &col_size, &scale, &nullable);
+	ASSERT_TRUE(SQL_SUCCEEDED(ret));
+	ASSERT_EQ(col_name_len, sizeof(COL_NAME) - 1);
+	ASSERT_STREQ(col_name, MK_WPTR(COL_NAME));
+	ASSERT_EQ(sql_type, ES_WVARCHAR_SQL);
+	ASSERT_EQ(col_size, VARCHAR_LIMIT); /* limit enforced */
+	ASSERT_EQ(nullable, SQL_NULLABLE_UNKNOWN);
+
+	/* binary column */
+	ret = SQLDescribeCol(stmt, /*col#*/2, col_name, sizeof(col_name),
+			&col_name_len, &sql_type, &col_size, &scale, &nullable);
+	ASSERT_TRUE(SQL_SUCCEEDED(ret));
+	ASSERT_EQ(col_size, INT_MAX); /* binary col's length must not be affected */
+}
 
 } // test namespace