single quote table type arg in SQLTables()

The spec allows for this argument to contain a list of table types to
filter by. The list of types can be given as quoted or unquoted
tokens. ES/SQL only suppots the quoted synthax, so do the quoting in the
driver.
Note: no sanity check done by the driver, though (i.e. mixed
quoted/unquoted or invalid characters). This isn't done for the other
arguments either.

Author: bpintea

driver/catalogue.c

@@ -132,6 +132,53 @@ SQLSMALLINT copy_current_catalog(esodbc_dbc_st *dbc, SQLWCHAR *dest,
 	return used;
 }
 
+/*
+ * Quote the tokens in a string: "a, b,,c" -> "'a','b',,'c'".
+ * No string sanity done (garbage in, garbage out).
+ */
+size_t quote_tokens(SQLWCHAR *src, size_t len, SQLWCHAR *dest)
+{
+	size_t i;
+	BOOL copying;
+	SQLWCHAR *pos;
+
+	DBG("len=%d.", len);
+	copying = FALSE;
+	pos = dest;
+	for (i = 0; i < len; i ++) {
+		DBG("src[%d]=%C, dest:`" LWPD "`.", i, src[i], dest);
+		switch (src[i]) {
+			/* ignore white space */
+			case L' ':
+			case L'\t':
+				TRACE;
+				if (copying) {
+					*pos ++ = L'\''; /* end current token */
+					copying = FALSE;
+				}
+				continue; /* don't copy WS */
+
+			case L',':
+				TRACE;
+				if (copying) {
+					*pos ++ = L'\''; /* end current token */
+					copying = FALSE;
+				} /* else continue; -- to remove extra `,` */
+				break;
+
+			default:
+				TRACE;
+				if (! copying) {
+					*pos ++ = L'\''; /* start a new token */
+				}
+				copying = TRUE;
+		}
+		*pos ++ = src[i];
+	}
+	/* should not overrun */
+	assert(i < 2/*see typ_buf below*/ * ESODBC_MAX_IDENTIFIER_LEN);
+	return pos - dest;
+}
 
 SQLRETURN EsSQLTablesW(
 		SQLHSTMT StatementHandle,
@@ -146,29 +193,47 @@ SQLRETURN EsSQLTablesW(
 {
 	esodbc_stmt_st *stmt = STMH(StatementHandle);
 	SQLRETURN ret;
-	SQLWCHAR wbuf[sizeof(SQL_TABLES) + 2 * ESODBC_MAX_IDENTIFIER_LEN];
-	SQLWCHAR *table, *schema, *catalog;
-	size_t cnt_tab, cnt_sch, cnt_cat, pos;
+	/* b/c declaring an array with a const doesn't work with MSVC's compiler */
+	enum wbuf_len { wbuf_len = sizeof(SQL_TABLES)
+		+ sizeof(SQL_TABLES_CAT)
+		+ sizeof(SQL_TABLES_TAB)
+		+ sizeof(SQL_TABLES_TYP)
+		+ 3 * ESODBC_MAX_IDENTIFIER_LEN /* it has 4x 0-term space */
+	};
+	SQLWCHAR wbuf[wbuf_len];
+	SQLWCHAR *table, *schema, *catalog, *type;
+	size_t cnt_tab, cnt_sch, cnt_cat, cnt_typ, pos;
+	/* 2x: "a,b,c" -> "'a','b','c'" : each "x," => "'x'," */
+	SQLWCHAR typ_buf[2 * ESODBC_MAX_IDENTIFIER_LEN];
 
 	if (stmt->metadata_id == SQL_TRUE)
 		FIXME; // FIXME
 
+	pos = sizeof(SQL_TABLES) - 1;
+	wmemcpy(wbuf, MK_WPTR(SQL_TABLES), pos);
+
 	if (CatalogName) {
 		catalog = CatalogName;
 		if (NameLength1 == SQL_NTS) {
 			cnt_cat = wcslen(catalog);
 			if (ESODBC_MAX_IDENTIFIER_LEN < cnt_cat) {
 				ERRH(stmt, "catalog identifier name '" LTPDL "' too long "
-						"(%d. max=%d).", cnt_cat, catalog, cnt_cat,
+						"(%zd. max=%d).", (int)cnt_cat, catalog, cnt_cat,
 						ESODBC_MAX_IDENTIFIER_LEN);
 				RET_HDIAG(stmt, SQL_STATE_HY090, "catalog name too long", 0);
 			}
 		} else {
 			cnt_cat = NameLength1;
 		}
-	} else {
-		catalog = MK_WPTR(SQL_ALL_CATALOGS);
-		cnt_cat = sizeof(SQL_ALL_CATALOGS) - /*0-term*/1;
+
+		cnt_cat = swprintf(wbuf + pos, wbuf_len - pos, SQL_TABLES_CAT,
+				(int)cnt_cat, catalog);
+		if (cnt_cat <= 0) {
+			ERRH(stmt, "failed to print 'catalog' for tables catalog SQL.");
+			RET_HDIAGS(stmt, SQL_STATE_HY000);
+		} else {
+			pos += cnt_cat;
+		}
 	}
 
 	if (SchemaName) {
@@ -177,23 +242,20 @@ SQLRETURN EsSQLTablesW(
 			cnt_sch = wcslen(schema);
 			if (ESODBC_MAX_IDENTIFIER_LEN < cnt_sch) {
 				ERRH(stmt, "schema identifier name '" LTPDL "' too long "
-						"(%d. max=%d).", cnt_sch, schema, cnt_sch,
+						"(%zd. max=%d).", (int)cnt_sch, schema, cnt_sch,
 						ESODBC_MAX_IDENTIFIER_LEN);
 				RET_HDIAG(stmt, SQL_STATE_HY090, "schema name too long", 0);
 			}
 		} else {
 			cnt_sch = NameLength2;
 		}
-	} else {
-		schema = MK_WPTR(SQL_ALL_SCHEMAS);
-		cnt_sch = sizeof(SQL_ALL_SCHEMAS) - /*0-term*/1;
-	}
 
-	/* TODO: server support needed for sch. name filtering */
-	if (cnt_sch && wszmemcmp(schema, MK_WPTR(SQL_ALL_SCHEMAS),
-				(long)cnt_sch)) {
-		ERRH(stmt, "filtering by schemas is not supported.");
-		RET_HDIAG(stmt, SQL_STATE_IM001, "schema filtering not supported", 0);
+		/* TODO: server support needed for sch. name filtering */
+		if (wszmemcmp(schema, MK_WPTR(SQL_ALL_SCHEMAS), (long)cnt_sch)) {
+			ERRH(stmt, "filtering by schemas is not supported.");
+			RET_HDIAG(stmt, SQL_STATE_IM001, "schema filtering not supported",
+					0);
+		}
 	}
 
 	// FIXME: string needs escaping of % \\ _
@@ -203,31 +265,58 @@ SQLRETURN EsSQLTablesW(
 			cnt_tab = wcslen(table);
 			if (ESODBC_MAX_IDENTIFIER_LEN < cnt_tab) {
 				ERRH(stmt, "table identifier name '" LTPDL "' too long "
-						"(%d. max=%d).", cnt_tab, table, cnt_tab,
+						"(%zd. max=%d).", (int)cnt_tab, table, cnt_tab,
 						ESODBC_MAX_IDENTIFIER_LEN);
 				RET_HDIAG(stmt, SQL_STATE_HY090, "table name too long", 0);
 			}
 		} else {
 			cnt_tab = NameLength3;
 		}
-	} else {
-		table = MK_WPTR(ESODBC_ALL_TABLES);
-		cnt_tab = sizeof(ESODBC_ALL_TABLES) - /*0-term*/1;
-	}
-#if 1 // TODO: GH#4334
-	if (cnt_tab == 0) {
-		table = MK_WPTR(ESODBC_ALL_TABLES);
-		cnt_tab = sizeof(ESODBC_ALL_TABLES) - /*0-term*/1;
+
+		cnt_tab = swprintf(wbuf + pos, wbuf_len - pos, SQL_TABLES_TAB,
+				(int)cnt_tab, table);
+		if (cnt_tab <= 0) {
+			ERRH(stmt, "failed to print 'table' for tables catalog SQL.");
+			RET_HDIAGS(stmt, SQL_STATE_HY000);
+		} else {
+			pos += cnt_tab;
+		}
 	}
-#endif // 1
 
-	/* print SQL to send to server */
-	pos = swprintf(wbuf, sizeof(wbuf)/sizeof(wbuf[0]), SQL_TABLES,
-			(int)cnt_cat, catalog, (int)cnt_tab, table);
-	if (pos <= 0) {
-		ERRH(stmt, "failed to print 'tables' catalog SQL.");
-		RET_HDIAGS(stmt, SQL_STATE_HY000);
+#if 1 // GH#30398
+	if (TableType) {
+		type = TableType;
+		if (NameLength4 == SQL_NTS) {
+			cnt_typ = wcslen(type);
+			if (ESODBC_MAX_IDENTIFIER_LEN < cnt_typ) {
+				ERRH(stmt, "type identifier name '" LTPDL "' too long "
+						"(%zd. max=%d).", (int)cnt_typ, type, cnt_typ,
+						ESODBC_MAX_IDENTIFIER_LEN);
+				RET_HDIAG(stmt, SQL_STATE_HY090, "type name too long", 0);
+			}
+		} else {
+			cnt_typ = NameLength4;
+		}
+
+		/* In this argument, "each value can be enclosed in single quotation
+		 * marks (') or unquoted" => quote if not quoted (see GH#30398). */
+		if (! wcsnstr(type, cnt_typ, L'\'')) {
+			cnt_typ = quote_tokens(type, cnt_typ, typ_buf);
+			type = typ_buf;
+		}
+
+		cnt_typ = swprintf(wbuf + pos, wbuf_len - pos, SQL_TABLES_TYP,
+				(int)cnt_typ, type);
+		if (cnt_typ <= 0) {
+			ERRH(stmt, "failed to print 'type' for tables catalog SQL.");
+			RET_HDIAGS(stmt, SQL_STATE_HY000);
+		} else {
+			pos += cnt_typ;
+		}
 	}
+#endif // 0
+
+	DBGH(stmt, "tables catalog SQL [%d]:`" LWPDL "`.", pos, pos, wbuf);
 
 	ret = EsSQLFreeStmt(stmt, ESODBC_SQL_CLOSE);
 	assert(SQL_SUCCEEDED(ret)); /* can't return error */

driver/defs.h

@@ -59,7 +59,8 @@
 #define ESODBC_MAX_CONCURRENT_ACTIVITIES	16
 /* maximum identifer length */
 /* TODO: review@alpha */
-#define ESODBC_MAX_IDENTIFIER_LEN			128
+/* match 'keyword' ES type lenght */
+#define ESODBC_MAX_IDENTIFIER_LEN			256
 
 
 /*

driver/util.c

@@ -103,7 +103,7 @@ int wmemncasecmp(const SQLWCHAR *a, const SQLWCHAR *b, size_t len)
 		if (diff)
 			break;
 	}
-	//DBG("`" LWPDL "` vs `" LWPDL "` => %d (len=%zd, i=%d).", 
+	//DBG("`" LWPDL "` vs `" LWPDL "` => %d (len=%zd, i=%d).",
 	//		len, a, len, b, diff, len, i);
 	return diff;
 }
@@ -124,6 +124,17 @@ int wszmemcmp(const SQLWCHAR *a, const SQLWCHAR *b, long count)
 	return *a - *b;
 }
 
+const SQLWCHAR* wcsnstr(const SQLWCHAR *hay, size_t len, SQLWCHAR needle)
+{
+	size_t i;
+	for (i = 0; i < len; i ++) {
+		if (hay[i] == needle) {
+			return hay + i;
+		}
+	}
+	return NULL;
+}
+
 /* retuns the length of a buffer to hold the escaped variant of the unescaped
  * given json object  */
 static inline size_t json_escaped_len(const char *json, size_t len)

driver/util.h

@@ -85,14 +85,19 @@ int wmemncasecmp(const SQLWCHAR *a, const SQLWCHAR *b, size_t len);
  * either of them or until 'count' characters are evaluated. If 'count'
  * parameter is negative, it is ignored.
  *
- * This is useful in comparing SQL strings which the API allows to be passed 
+ * This is useful in comparing SQL strings which the API allows to be passed
  * either as 0-terminated or not (SQL_NTS).
  * The function does a single pass (no length evaluation of the strings).
  * wmemcmp() might read over the boundary of one of the objects, if the
  * provided 'count' paramter is not the minimum of the strings' length.
  */
 int wszmemcmp(const SQLWCHAR *a, const SQLWCHAR *b, long count);
 
+/*
+ * wcsstr() variant for non-NTS.
+ */
+const SQLWCHAR* wcsnstr(const SQLWCHAR *hay, size_t len, SQLWCHAR needle);
+
 typedef struct wstr {
 	SQLWCHAR *str;
 	size_t cnt;
@@ -119,7 +124,7 @@ BOOL wstr2bool(wstr_st *val);
 BOOL wstr2long(wstr_st *val, long *out);
 
 #ifdef _WIN32
-/* 
+/*
  * "[D]oes not null-terminate an output string if the input string length is
  * explicitly specified without a terminating null character. To
  * null-terminate an output string for this function, the application should
@@ -155,7 +160,7 @@ typedef cstr_st tstr_st;
 #endif /* UNICODE */
 
 
-/* 
+/*
  * JSON-escapes a string.
  * If string len is 0, it assumes a NTS.
  * If output buffer (jout) is NULL, it returns the buffer size needed for