Introduce new varchar limitation option (#229)

* introduce new varchar limitation option

This commit adds a new feature that allows the user to limit the size of
the string types (TEXT, KEYWORD & co.). This is needed for those
applications that won't accept the large maxes that ES does for the
fields of these types.

The change will manifest itself as:
- limitation of the COLUMN_SIZE, BUFFER_LENGHT and CHAR_OCTET_LENGTH in
the SQLColumns output;
- limitation of the "display size" attribute in the description of the
columns of the above mentioned types;
- truncation of the results to the configured limit for the columns of
the above mentioned types.

The commit also adds unit tests for the "faked" (i.e. driver-returned
results) catalog functions, removes stale DSN attribute definition (left
over from #215) and corrects the row index in a debug statement.

* add new integration testing running mode

Add new option to execute only the tests requiring no indexing of data
(currently server info-fetching tests and the protocol tests).

The commit also sets the autocommit as parameter to connection function,
instead of the subsequent operation.

(cherry picked from commit 77dc4ff)

Author: bpintea

driver/catalogue.c

@@ -10,10 +10,33 @@
 #include "error.h"
 #include "handles.h"
 
+/* SQLColumns' name to (1-based) index mapping */
+enum {
+	SQLCOLS_IDX_TABLE_CAT = 1,
+	SQLCOLS_IDX_TABLE_SCHEM,
+	SQLCOLS_IDX_TABLE_NAME,
+	SQLCOLS_IDX_COLUMN_NAME,
+	SQLCOLS_IDX_DATA_TYPE,
+	SQLCOLS_IDX_TYPE_NAME,
+	SQLCOLS_IDX_COLUMN_SIZE,
+	SQLCOLS_IDX_BUFFER_LENGTH,
+	SQLCOLS_IDX_DECIMAL_DIGITS,
+	SQLCOLS_IDX_NUM_PREC_RADIX,
+	SQLCOLS_IDX_NULLABLE,
+	SQLCOLS_IDX_REMARKS,
+	SQLCOLS_IDX_COLUMN_DEF,
+	SQLCOLS_IDX_SQL_DATA_TYPE,
+	SQLCOLS_IDX_SQL_DATETIME_SUB,
+	SQLCOLS_IDX_CHAR_OCTET_LENGTH,
+	SQLCOLS_IDX_ORDINAL_POSITION,
+	SQLCOLS_IDX_IS_NULLABLE, /* 18 */
+	SQLCOLS_IDX_MAX = 18
+};
 
 SQLSMALLINT fetch_server_attr(esodbc_dbc_st *dbc, SQLINTEGER attr_id,
 	SQLWCHAR *dest, SQLSMALLINT room);
 BOOL TEST_API set_current_catalog(esodbc_dbc_st *dbc, wstr_st *catalog);
+SQLRETURN TEST_API update_varchar_defs(esodbc_stmt_st *stmt);
 
 
 SQLRETURN EsSQLStatisticsW(

driver/catalogue.h

@@ -1133,8 +1133,7 @@ SQLRETURN config_dbc(esodbc_dbc_st *dbc, esodbc_dsn_attrs_st *attrs)
 	const static wstr_st https_prefix = WSTR_INIT("https://");
 	wstr_st prefix;
 	int cnt, ipv6;
-	SQLBIGINT secure;
-	long long timeout, max_body_size, max_fetch_size;
+	SQLBIGINT secure, timeout, max_body_size, max_fetch_size, varchar_limit;
 	SQLWCHAR buff_url[ESODBC_MAX_URL_LEN];
 	wstr_st url = (wstr_st) {
 		buff_url, /*will be init'ed later*/0
@@ -1188,7 +1187,7 @@ SQLRETURN config_dbc(esodbc_dbc_st *dbc, esodbc_dsn_attrs_st *attrs)
 		SET_HDIAG(dbc, SQL_STATE_HY000, "invalid security setting", 0);
 		goto err;
 	} else {
-		dbc->secure = (long)secure;
+		dbc->secure = (int)secure;
 		INFOH(dbc, "connection security level: %ld.", dbc->secure);
 	}
 
@@ -1297,16 +1296,16 @@ SQLRETURN config_dbc(esodbc_dbc_st *dbc, esodbc_dsn_attrs_st *attrs)
 	/*
 	 * request timeout for liburl: negative reset to 0
 	 */
-	if (str2bigint(&attrs->timeout, /*wide?*/TRUE,
-			(SQLBIGINT *)&timeout, /*strict*/TRUE) < 0) {
+	if (str2bigint(&attrs->timeout, /*wide?*/TRUE, &timeout,
+			/*strict*/TRUE) < 0) {
 		ERRH(dbc, "failed to convert `" LWPDL "` [%zu] to big int.",
 			LWSTR(&attrs->timeout), attrs->timeout.cnt);
 		SET_HDIAG(dbc, SQL_STATE_HY000, "timeout setting number "
 			"conversion failure", 0);
 		goto err;
 	}
-	if (timeout < 0) {
-		WARNH(dbc, "set timeout is negative (%ld), normalized to 0.", timeout);
+	if (ULONG_MAX <= timeout || timeout < 0) {
+		WARNH(dbc, "invalid timeout value (%lld), normalized to 0.", timeout);
 		timeout = 0;
 	}
 	dbc->timeout = (SQLUINTEGER)timeout;
@@ -1315,19 +1314,18 @@ SQLRETURN config_dbc(esodbc_dbc_st *dbc, esodbc_dsn_attrs_st *attrs)
 	/*
 	 * set max body size
 	 */
-	if (str2bigint(&attrs->max_body_size, /*wide?*/TRUE,
-			(SQLBIGINT *)&max_body_size, /*strict*/TRUE) < 0) {
-		ERRH(dbc, "failed to convert max body size `" LWPDL "` [%zu] to LL.",
-			LWSTR(&attrs->max_body_size), attrs->max_body_size.cnt);
+	if (str2bigint(&attrs->max_body_size, /*wide?*/TRUE, &max_body_size,
+			/*strict*/TRUE) < 0) {
+		ERRH(dbc, "failed to convert max body size [%zu] `" LWPDL "`.",
+			attrs->max_body_size.cnt, LWSTR(&attrs->max_body_size));
 		SET_HDIAG(dbc, SQL_STATE_HY000, "max body size setting number "
 			"conversion failure", 0);
 		goto err;
 	}
-	if (max_body_size < 0) {
-		ERRH(dbc, "'%s' setting can't be negative (%ld).",
+	if ((SIZE_MAX / (1024 * 1024)) <= max_body_size || max_body_size < 0) {
+		ERRH(dbc, "invalid '%s' setting value (%lld).",
 			ESODBC_DSN_MAX_BODY_SIZE_MB, max_body_size);
-		SET_HDIAG(dbc, SQL_STATE_HY000, "invalid max body size setting "
-			"(negative)", 0);
+		SET_HDIAG(dbc, SQL_STATE_HY000, "invalid max body size setting", 0);
 		goto err;
 	} else {
 		dbc->amax = (size_t)max_body_size * 1024 * 1024;
@@ -1340,19 +1338,18 @@ SQLRETURN config_dbc(esodbc_dbc_st *dbc, esodbc_dsn_attrs_st *attrs)
 	/*
 	 * set max fetch size
 	 */
-	if (str2bigint(&attrs->max_fetch_size, /*wide?*/TRUE,
-			(SQLBIGINT *)&max_fetch_size, /*strict*/TRUE) < 0) {
-		ERRH(dbc, "failed to convert max fetch size `" LWPDL "` [%zu] to LL.",
-			LWSTR(&attrs->max_fetch_size), attrs->max_fetch_size.cnt);
+	if (str2bigint(&attrs->max_fetch_size, /*wide?*/TRUE, &max_fetch_size,
+			/*strict*/TRUE) < 0) {
+		ERRH(dbc, "failed to convert max fetch size [%zu] `" LWPDL "`.",
+			attrs->max_fetch_size.cnt, LWSTR(&attrs->max_fetch_size));
 		SET_HDIAG(dbc, SQL_STATE_HY000, "max fetch size setting number "
 			"conversion failure", 0);
 		goto err;
 	}
-	if (max_fetch_size < 0) {
-		ERRH(dbc, "'%s' setting can't be negative (%ld).",
+	if (SIZE_MAX <= max_fetch_size || max_fetch_size < 0) {
+		ERRH(dbc, "invalid '%s' setting value (%lld).",
 			ESODBC_DSN_MAX_FETCH_SIZE, max_fetch_size);
-		SET_HDIAG(dbc, SQL_STATE_HY000, "invalid max fetch size setting "
-			"(negative)", 0);
+		SET_HDIAG(dbc, SQL_STATE_HY000, "invalid max fetch size setting", 0);
 		goto err;
 	} else {
 		dbc->fetch.max = (size_t)max_fetch_size;
@@ -1370,7 +1367,6 @@ SQLRETURN config_dbc(esodbc_dbc_st *dbc, esodbc_dsn_attrs_st *attrs)
 	}
 	INFOH(dbc, "fetch_size: %s.", dbc->fetch.str ? dbc->fetch.str : "none" );
 
-	// TODO: catalog handling
 
 	/*
 	 * set the REST body format: JSON/CBOR
@@ -1433,6 +1429,35 @@ SQLRETURN config_dbc(esodbc_dbc_st *dbc, esodbc_dsn_attrs_st *attrs)
 	/* auto escape pattern value argument */
 	dbc->auto_esc_pva = wstr2bool(&attrs->auto_esc_pva);
 	INFOH(dbc, "auto escape PVA: %s.", dbc->auto_esc_pva ? "true" : "false");
+	/* varchar limit */
+	if (str2bigint(&attrs->varchar_limit, /*wide?*/TRUE, &varchar_limit,
+			/*strict*/TRUE) < 0) {
+		ERRH(dbc, "failed to convert varchar limit [%zu] `" LWPDL "`.",
+			attrs->varchar_limit.cnt, LWSTR(&attrs->varchar_limit));
+		SET_HDIAG(dbc, SQL_STATE_HY000, "varchar limit value conversion "
+			"failure", 0);
+		goto err;
+	} else if (ESODBC_MAX_KEYWORD_PRECISION < varchar_limit ||
+		varchar_limit < 0) {
+		ERRH(dbc, "varchar limit (`" LWPDL "`) outside the allowed range "
+			"[%d, %d].", LWSTR(&attrs->varchar_limit), 0,
+			ESODBC_MAX_KEYWORD_PRECISION);
+		SET_HDIAG(dbc, SQL_STATE_HY000, "invalid varchar limit setting", 0);
+		goto err;
+	} else {
+		dbc->varchar_limit = (SQLUINTEGER)varchar_limit;
+		/* duplicate w-char setting */
+		if (! (dbc->varchar_limit_str.str = calloc(attrs->varchar_limit.cnt +
+						/*\0*/1, sizeof(SQLWCHAR)))) {
+			ERRNH(dbc, "OOM: %zu w-chars.", attrs->varchar_limit.cnt + 1);
+			SET_HDIAG(dbc, SQL_STATE_HY001, "Memory allocation error", 0);
+			goto err;
+		}
+		wmemcpy(dbc->varchar_limit_str.str, attrs->varchar_limit.str,
+			attrs->varchar_limit.cnt);
+		dbc->varchar_limit_str.cnt = attrs->varchar_limit.cnt;
+		INFOH(dbc, "varchar limit: %lu.", dbc->varchar_limit);
+	}
 
 	return SQL_SUCCESS;
 err:
@@ -1524,6 +1549,11 @@ void cleanup_dbc(esodbc_dbc_st *dbc)
 	} else {
 		assert(dbc->catalog.cnt == 0);
 	}
+	if (dbc->varchar_limit_str.str) {
+		free(dbc->varchar_limit_str.str);
+		dbc->varchar_limit_str.str = NULL;
+		dbc->varchar_limit_str.cnt = 0;
+	}
 
 	assert(dbc->abuff == NULL);
 	cleanup_curl(dbc);
@@ -2516,7 +2546,7 @@ static void *copy_types_rows(esodbc_dbc_st *dbc, estype_row_st *type_row,
 				types[i].maximum_scale, types[i].minimum_scale);
 		}
 
-		/* resolve ES type to SQL C type */
+		/* resolve ES type to SQL and SQL C type */
 		if (! elastic_name2types(&types[i].type_name, &types[i].c_concise_type,
 				&sql_type)) {
 			/* ES version newer than driver's? */
@@ -2529,8 +2559,8 @@ static void *copy_types_rows(esodbc_dbc_st *dbc, estype_row_st *type_row,
 
 		/* BOOLEAN is used in catalog calls (like SYS TYPES / SQLGetTypeInfo),
 		 * and the data type is piped through to the app (just like with any
-		 * other statement), which causes issues, since it's a non-SQL type
-		 * => change it to SQL_BIT */
+		 * other statement), which causes issues, since it's not a standard
+		 * type => change it to SQL_BIT */
 		if (types[i].data_type == ESODBC_SQL_BOOLEAN) {
 			types[i].data_type = ES_BOOLEAN_TO_SQL;
 		}
@@ -2555,6 +2585,15 @@ static void *copy_types_rows(esodbc_dbc_st *dbc, estype_row_st *type_row,
 		concise_to_type_code(types[i].data_type, &types[i].sql_data_type,
 			&types[i].sql_datetime_sub);
 
+		/* if there's a varchar limit, apply it to string types */
+		if (types[i].sql_data_type == ESODBC_SQL_STRING) {
+			assert(0 <= types[i].column_size);
+			if (dbc->varchar_limit &&
+				dbc->varchar_limit < (SQLUINTEGER)types[i].column_size) {
+				types[i].column_size = dbc->varchar_limit;
+			}
+		}
+
 		set_display_size(types + i);
 
 		/* There's no explicit coverage in the docs on how to communicate the
@@ -2691,10 +2730,10 @@ static BOOL load_es_types(esodbc_dbc_st *dbc)
 		goto end;
 	} else if (col_cnt != ESODBC_TYPES_COLUMNS) {
 		ERRH(stmt, "Elasticsearch returned an unexpected number of columns "
-			"(%d vs expected %d).", col_cnt, ESODBC_TYPES_COLUMNS);
+			"(%hd vs expected %d).", col_cnt, ESODBC_TYPES_COLUMNS);
 		goto end;
 	} else {
-		DBGH(stmt, "Elasticsearch types columns count: %d.", col_cnt);
+		DBGH(stmt, "Elasticsearch types columns count: %hd.", col_cnt);
 	}
 
 	/* check that we have received proper number of rows (non-0, less than

driver/connect.c

@@ -1450,7 +1450,7 @@ static SQLRETURN wstr_to_cstr(esodbc_rec_st *arec, esodbc_rec_st *irec,
 
 	assert(xstr.w.str[xstr.w.cnt] == L'\0');
 	/* how much space would the converted string take? */
-	in_bytes = U16WC_TO_MBU8(xstr.w.str, xstr.w.cnt + 1, NULL, 0);
+	in_bytes = U16WC_TO_MBU8(xstr.w.str, xstr.w.cnt + /*\0*/1, NULL, 0);
 	if (in_bytes <= 0) {
 		ERRNH(stmt, "failed to convert wchar* to char* for string `"
 			LWPDL "`.", LWSTR(&xstr.w));
@@ -3321,6 +3321,26 @@ static SQLRETURN wstr_to_string(esodbc_rec_st *arec, esodbc_rec_st *irec,
 	return ret;
 }
 
+/* apply early truncation to the source data, to the limit enforced by the
+ * varchar limit; many functions downstream expect the 0-terminator in place,
+ * so an update of the count only would not suffice. */
+void varchar_limit_apply(esodbc_rec_st *irec, wchar_t *wstr, size_t *chars_0)
+{
+	esodbc_stmt_st *stmt = HDRH(irec->desc)->stmt;
+	SQLUINTEGER varchar_limit = HDRH(stmt)->dbc->varchar_limit;
+
+	if (varchar_limit <= 0) {
+		return;
+	}
+	if (*chars_0 - /*\0*/1 <= varchar_limit) {
+		return;
+	}
+	DBGH(stmt, "applying varchar limit truncation: %zu -> [%lu] `" LWPDL "`.",
+		*chars_0 - 1, varchar_limit, varchar_limit, wstr);
+	*chars_0 = varchar_limit + 1;
+	wstr[varchar_limit] = L'\0';
+}
+
 /*
  * wstr: is 0-terminated and terminator is counted in 'chars_0'.
  * However: "[w]hen C strings are used to hold character data, the
@@ -3344,6 +3364,11 @@ SQLRETURN sql2c_string(esodbc_rec_st *arec, esodbc_rec_st *irec,
 
 	stmt = arec->desc->hdr.stmt;
 
+	/* function updates the const wstr; this is however not the
+	 * originally received network buffer, but a re-allocated chunk by the
+	 * respective parsing library (json/cbor), so it should be safe; */
+	varchar_limit_apply(irec, (wchar_t *)wstr, &chars_0);
+
 	assert(1 <= chars_0); /* _0 is really counted */
 
 	/* pointer where to write how many characters we will/would use */

driver/convert.c

@@ -37,7 +37,7 @@
  * columns than this def, recs will be allocated dynamically. */
 #define ESODBC_GD_DESC_COUNT		128
 /* values for SQL_ATTR_MAX_LENGTH statement attribute */
-#define ESODBC_UP_MAX_LENGTH		0 // USHORT_MAX
+#define ESODBC_UP_MAX_LENGTH		0
 #define ESODBC_LO_MAX_LENGTH		0
 /* Prepare a STMT for a new SQL operation.
  * To be used with catalog functions, that can be all called with same stmt.
@@ -82,6 +82,8 @@
  * (Should move to 9 with nanosecond implementation) */
 #define ESODBC_MAX_SEC_PRECISION		9
 #define ESODBC_DEF_SEC_PRECISION		3
+/* max keyword column/"buffer" size ("Lucene's term byte-length limit") */
+#define ESODBC_MAX_KEYWORD_PRECISION	32766
 /*
  * standard specified defaults:
  * https://docs.microsoft.com/en-us/sql/odbc/reference/syntax/sqlsetdescfield-function##record-fields
@@ -184,6 +186,7 @@
 #define ESODBC_DEF_MFIELD_LENIENT	"true"
 #define ESODBC_DEF_ESC_PVA			"true"
 #define ESODBC_DEF_IDX_INC_FROZEN	"false"
+#define ESODBC_DEF_VARCHAR_LIMIT	"0"
 
 /*
  *
@@ -401,6 +404,9 @@
 #define ODBC_SQL92_VALUE_EXPRESSIONS			(0LU | \
 	SQL_SVE_CASE | SQL_SVE_CAST | SQL_SVE_COALESCE | SQL_SVE_NULLIF)
 
+/* the type ES/SQL uses for string types (KEYWORD, TEXT, CONSTANT_KEYWORD),
+ * plus IP and GEO */
+#define ESODBC_SQL_STRING			SQL_VARCHAR
 /*
  * ES specific data types
  */

driver/defs.h

@@ -78,7 +78,7 @@ int assign_dsn_attr(esodbc_dsn_attrs_st *attrs,
 		{&MK_WSTR(ESODBC_DSN_APPLY_TZ), &attrs->apply_tz},
 		{&MK_WSTR(ESODBC_DSN_EARLY_EXEC), &attrs->early_exec},
 		{&MK_WSTR(ESODBC_DSN_SCI_FLOATS), &attrs->sci_floats},
-		{&MK_WSTR(ESODBC_DSN_VERSION_CHECKING), &attrs->version_checking},
+		{&MK_WSTR(ESODBC_DSN_VARCHAR_LIMIT), &attrs->varchar_limit},
 		{&MK_WSTR(ESODBC_DSN_MFIELD_LENIENT), &attrs->mfield_lenient},
 		{&MK_WSTR(ESODBC_DSN_ESC_PVA), &attrs->auto_esc_pva},
 		{&MK_WSTR(ESODBC_DSN_IDX_INC_FROZEN), &attrs->idx_inc_frozen},
@@ -414,7 +414,7 @@ long TEST_API write_00_list(esodbc_dsn_attrs_st *attrs,
 		{&MK_WSTR(ESODBC_DSN_APPLY_TZ), &attrs->apply_tz},
 		{&MK_WSTR(ESODBC_DSN_EARLY_EXEC), &attrs->early_exec},
 		{&MK_WSTR(ESODBC_DSN_SCI_FLOATS), &attrs->sci_floats},
-		{&MK_WSTR(ESODBC_DSN_VERSION_CHECKING), &attrs->version_checking},
+		{&MK_WSTR(ESODBC_DSN_VARCHAR_LIMIT), &attrs->varchar_limit},
 		{&MK_WSTR(ESODBC_DSN_MFIELD_LENIENT), &attrs->mfield_lenient},
 		{&MK_WSTR(ESODBC_DSN_ESC_PVA), &attrs->auto_esc_pva},
 		{&MK_WSTR(ESODBC_DSN_IDX_INC_FROZEN), &attrs->idx_inc_frozen},
@@ -686,9 +686,8 @@ BOOL write_system_dsn(esodbc_dsn_attrs_st *new_attrs,
 			old_attrs ? &old_attrs->sci_floats : NULL
 		},
 		{
-			&MK_WSTR(ESODBC_DSN_VERSION_CHECKING),
-			&new_attrs->version_checking,
-			old_attrs ? &old_attrs->version_checking : NULL
+			&MK_WSTR(ESODBC_DSN_VARCHAR_LIMIT), &new_attrs->varchar_limit,
+			old_attrs ? &old_attrs->varchar_limit : NULL
 		},
 		{
 			&MK_WSTR(ESODBC_DSN_MFIELD_LENIENT),
@@ -794,7 +793,7 @@ long TEST_API write_connection_string(esodbc_dsn_attrs_st *attrs,
 		{&attrs->apply_tz, &MK_WSTR(ESODBC_DSN_APPLY_TZ)},
 		{&attrs->early_exec, &MK_WSTR(ESODBC_DSN_EARLY_EXEC)},
 		{&attrs->sci_floats, &MK_WSTR(ESODBC_DSN_SCI_FLOATS)},
-		{&attrs->version_checking, &MK_WSTR(ESODBC_DSN_VERSION_CHECKING)},
+		{&attrs->varchar_limit, &MK_WSTR(ESODBC_DSN_VARCHAR_LIMIT)},
 		{&attrs->mfield_lenient, &MK_WSTR(ESODBC_DSN_MFIELD_LENIENT)},
 		{&attrs->auto_esc_pva, &MK_WSTR(ESODBC_DSN_ESC_PVA)},
 		{&attrs->idx_inc_frozen, &MK_WSTR(ESODBC_DSN_IDX_INC_FROZEN)},
@@ -897,6 +896,9 @@ void assign_dsn_defaults(esodbc_dsn_attrs_st *attrs)
 	res |= assign_dsn_attr(attrs,
 			&MK_WSTR(ESODBC_DSN_SCI_FLOATS), &MK_WSTR(ESODBC_DEF_SCI_FLOATS),
 			/*overwrite?*/FALSE);
+	res |= assign_dsn_attr(attrs,
+			&MK_WSTR(ESODBC_DSN_VARCHAR_LIMIT),
+			&MK_WSTR(ESODBC_DEF_VARCHAR_LIMIT), /*overwrite?*/FALSE);
 	res |= assign_dsn_attr(attrs,
 			&MK_WSTR(ESODBC_DSN_MFIELD_LENIENT),
 			&MK_WSTR(ESODBC_DEF_MFIELD_LENIENT), /*overwrite?*/FALSE);

driver/dsn.c

@@ -37,7 +37,7 @@
 #define ESODBC_DSN_APPLY_TZ			"ApplyTZ"
 #define ESODBC_DSN_EARLY_EXEC		"EarlyExecution"
 #define ESODBC_DSN_SCI_FLOATS		"ScientificFloats"
-#define ESODBC_DSN_VERSION_CHECKING	"VersionChecking"
+#define ESODBC_DSN_VARCHAR_LIMIT	"VarcharLimit"
 #define ESODBC_DSN_MFIELD_LENIENT	"MultiFieldLenient"
 #define ESODBC_DSN_ESC_PVA			"AutoEscapePVA"
 #define ESODBC_DSN_IDX_INC_FROZEN	"IndexIncludeFrozen"
@@ -81,7 +81,7 @@ typedef struct {
 	wstr_st apply_tz;
 	wstr_st early_exec;
 	wstr_st sci_floats;
-	wstr_st version_checking;
+	wstr_st varchar_limit;
 	wstr_st mfield_lenient;
 	wstr_st auto_esc_pva;
 	wstr_st idx_inc_frozen;

driver/dsn.h

@@ -176,6 +176,9 @@ 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 */
+	SQLUINTEGER varchar_limit;
+	wstr_st varchar_limit_str; /* convenience w-string of varchar limit */
 
 	CURL *curl; /* cURL handle */
 	CURLcode curl_err;