Merge branch 'enh/stmt2testcase' into fix/main/TD-33417

source/client/inc/clientStmt2.h

@@ -221,11 +221,8 @@ int         stmtPrepare2(TAOS_STMT2 *stmt, const char *sql, unsigned long length
 int         stmtSetTbName2(TAOS_STMT2 *stmt, const char *tbName);
 int         stmtSetTbTags2(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *tags);
 int         stmtBindBatch2(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *bind, int32_t colIdx);
-int         stmtGetTagFields2(TAOS_STMT2 *stmt, int *nums, TAOS_FIELD_E **fields);
-int         stmtGetColFields2(TAOS_STMT2 *stmt, int *nums, TAOS_FIELD_E **fields);
 int         stmtGetStbColFields2(TAOS_STMT2 *stmt, int *nums, TAOS_FIELD_ALL **fields);
 int         stmtGetParamNum2(TAOS_STMT2 *stmt, int *nums);
-int         stmtGetParamTbName(TAOS_STMT2 *stmt, int *nums);
 int         stmtIsInsert2(TAOS_STMT2 *stmt, int *insert);
 TAOS_RES   *stmtUseResult2(TAOS_STMT2 *stmt);
 const char *stmtErrstr2(TAOS_STMT2 *stmt);

source/client/src/clientMain.c

@@ -24,13 +24,13 @@
 #include "query.h"
 #include "scheduler.h"
 #include "tcompare.h"
+#include "tconv.h"
 #include "tdatablock.h"
 #include "tglobal.h"
 #include "tmsg.h"
 #include "tref.h"
 #include "trpc.h"
 #include "version.h"
-#include "tconv.h"
 
 #define TSC_VAR_NOT_RELEASE 1
 #define TSC_VAR_RELEASED    0
@@ -2129,6 +2129,11 @@ int taos_stmt_close(TAOS_STMT *stmt) {
 }
 
 TAOS_STMT2 *taos_stmt2_init(TAOS *taos, TAOS_STMT2_OPTION *option) {
+  if (NULL == taos) {
+    tscError("NULL parameter for %s", __FUNCTION__);
+    terrno = TSDB_CODE_INVALID_PARA;
+    return NULL;
+  }
   STscObj *pObj = acquireTscObj(*(int64_t *)taos);
   if (NULL == pObj) {
     tscError("invalid parameter for %s", __FUNCTION__);
@@ -2257,16 +2262,7 @@ int taos_stmt2_close(TAOS_STMT2 *stmt) {
 
   return stmtClose2(stmt);
 }
-/*
+
-int taos_stmt2_param_count(TAOS_STMT2 *stmt, int *nums) {
-  if (stmt == NULL || nums == NULL) {
-    tscError("NULL parameter for %s", __FUNCTION__);
-    terrno = TSDB_CODE_INVALID_PARA;
-    return terrno;
-  }
-  return stmtGetParamNum2(stmt, nums);
-}
-*/
 int taos_stmt2_is_insert(TAOS_STMT2 *stmt, int *insert) {
   if (stmt == NULL || insert == NULL) {
     tscError("NULL parameter for %s", __FUNCTION__);
@@ -2277,28 +2273,6 @@ int taos_stmt2_is_insert(TAOS_STMT2 *stmt, int *insert) {
   return stmtIsInsert2(stmt, insert);
 }
 
-// int taos_stmt2_get_fields(TAOS_STMT2 *stmt, TAOS_FIELD_T field_type, int *count, TAOS_FIELD_E **fields) {
-//   if (stmt == NULL || count == NULL) {
-//     tscError("NULL parameter for %s", __FUNCTION__);
-//     terrno = TSDB_CODE_INVALID_PARA;
-//     return terrno;
-//   }
-
-//   if (field_type == TAOS_FIELD_COL) {
-//     return stmtGetColFields2(stmt, count, fields);
-//   } else if (field_type == TAOS_FIELD_TAG) {
-//     return stmtGetTagFields2(stmt, count, fields);
-//   } else if (field_type == TAOS_FIELD_QUERY) {
-//     return stmtGetParamNum2(stmt, count);
-//   } else if (field_type == TAOS_FIELD_TBNAME) {
-//     return stmtGetParamTbName(stmt, count);
-//   } else {
-//     tscError("invalid parameter for %s", __FUNCTION__);
-//     terrno = TSDB_CODE_INVALID_PARA;
-//     return terrno;
-//   }
-// }
-
 int taos_stmt2_get_fields(TAOS_STMT2 *stmt, int *count, TAOS_FIELD_ALL **fields) {
   if (stmt == NULL || count == NULL) {
     tscError("NULL parameter for %s", __FUNCTION__);

source/client/src/clientStmt2.c

@@ -1037,28 +1037,6 @@ int stmtSetTbTags2(TAOS_STMT2* stmt, TAOS_STMT2_BIND* tags) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int stmtFetchTagFields2(STscStmt2* pStmt, int32_t* fieldNum, TAOS_FIELD_E** fields) {
-  if (pStmt->errCode != TSDB_CODE_SUCCESS) {
-    return pStmt->errCode;
-  }
-
-  if (STMT_TYPE_QUERY == pStmt->sql.type) {
-    tscError("invalid operation to get query tag fileds");
-    STMT_ERR_RET(TSDB_CODE_TSC_STMT_API_ERROR);
-  }
-
-  STableDataCxt** pDataBlock =
-      (STableDataCxt**)taosHashGet(pStmt->exec.pBlockHash, pStmt->bInfo.tbFName, strlen(pStmt->bInfo.tbFName));
-  if (NULL == pDataBlock) {
-    tscError("table %s not found in exec blockHash", pStmt->bInfo.tbFName);
-    STMT_ERR_RET(TSDB_CODE_APP_ERROR);
-  }
-
-  STMT_ERR_RET(qBuildStmtTagFields(*pDataBlock, pStmt->bInfo.boundTags, fieldNum, fields));
-
-  return TSDB_CODE_SUCCESS;
-}
-
 static int stmtFetchColFields2(STscStmt2* pStmt, int32_t* fieldNum, TAOS_FIELD_E** fields) {
   if (pStmt->errCode != TSDB_CODE_SUCCESS) {
     return pStmt->errCode;
@@ -1820,47 +1798,6 @@ int stmtAffectedRows(TAOS_STMT* stmt) { return ((STscStmt2*)stmt)->affectedRows;
 
 int stmtAffectedRowsOnce(TAOS_STMT* stmt) { return ((STscStmt2*)stmt)->exec.affectedRows; }
 */
-int stmtGetTagFields2(TAOS_STMT2* stmt, int* nums, TAOS_FIELD_E** fields) {
-  int32_t    code = 0;
-  STscStmt2* pStmt = (STscStmt2*)stmt;
-  int32_t    preCode = pStmt->errCode;
-
-  STMT_DLOG_E("start to get tag fields");
-
-  if (pStmt->errCode != TSDB_CODE_SUCCESS) {
-    return pStmt->errCode;
-  }
-
-  if (STMT_TYPE_QUERY == pStmt->sql.type) {
-    STMT_ERRI_JRET(TSDB_CODE_TSC_STMT_API_ERROR);
-  }
-
-  STMT_ERRI_JRET(stmtSwitchStatus(pStmt, STMT_FETCH_FIELDS));
-
-  if (pStmt->bInfo.needParse && pStmt->sql.runTimes && pStmt->sql.type > 0 &&
-      STMT_TYPE_MULTI_INSERT != pStmt->sql.type) {
-    pStmt->bInfo.needParse = false;
-  }
-
-  if (pStmt->exec.pRequest && STMT_TYPE_QUERY == pStmt->sql.type && pStmt->sql.runTimes) {
-    taos_free_result(pStmt->exec.pRequest);
-    pStmt->exec.pRequest = NULL;
-  }
-
-  STMT_ERRI_JRET(stmtCreateRequest(pStmt));
-
-  if (pStmt->bInfo.needParse) {
-    STMT_ERRI_JRET(stmtParseSql(pStmt));
-  }
-
-  STMT_ERRI_JRET(stmtFetchTagFields2(stmt, nums, fields));
-
-_return:
-
-  pStmt->errCode = preCode;
-
-  return code;
-}
 
 int stmtParseColFields2(TAOS_STMT2* stmt) {
   int32_t    code = 0;
@@ -1903,15 +1840,6 @@ _return:
   return code;
 }
 
-int stmtGetColFields2(TAOS_STMT2* stmt, int* nums, TAOS_FIELD_E** fields) {
-  int32_t code = stmtParseColFields2(stmt);
-  if (code != TSDB_CODE_SUCCESS) {
-    return code;
-  }
-
-  return stmtFetchColFields2(stmt, nums, fields);
-}
-
 int stmtGetStbColFields2(TAOS_STMT2* stmt, int* nums, TAOS_FIELD_ALL** fields) {
   int32_t code = stmtParseColFields2(stmt);
   if (code != TSDB_CODE_SUCCESS) {
@@ -1957,95 +1885,6 @@ int stmtGetParamNum2(TAOS_STMT2* stmt, int* nums) {
   return TSDB_CODE_SUCCESS;
 }
 
-int stmtGetParamTbName(TAOS_STMT2* stmt, int* nums) {
-  STscStmt2* pStmt = (STscStmt2*)stmt;
-  int32_t    code = 0;
-  int32_t    preCode = pStmt->errCode;
-
-  STMT_DLOG_E("start to get param num");
-
-  if (pStmt->errCode != TSDB_CODE_SUCCESS) {
-    return pStmt->errCode;
-  }
-
-  STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_FETCH_FIELDS));
-
-  if (pStmt->bInfo.needParse && pStmt->sql.runTimes && pStmt->sql.type > 0 &&
-      STMT_TYPE_MULTI_INSERT != pStmt->sql.type) {
-    pStmt->bInfo.needParse = false;
-  }
-
-  if (pStmt->exec.pRequest && STMT_TYPE_QUERY == pStmt->sql.type && pStmt->sql.runTimes) {
-    taos_free_result(pStmt->exec.pRequest);
-    pStmt->exec.pRequest = NULL;
-  }
-
-  STMT_ERR_RET(stmtCreateRequest(pStmt));
-
-  if (pStmt->bInfo.needParse) {
-    STMT_ERRI_JRET(stmtParseSql(pStmt));
-  }
-
-  *nums = STMT_TYPE_MULTI_INSERT == pStmt->sql.type ? 1 : 0;
-
-_return:
-  if (TSDB_CODE_TSC_STMT_TBNAME_ERROR == code) {
-    *nums = 1;
-    code = TSDB_CODE_SUCCESS;
-  }
-
-  pStmt->errCode = preCode;
-  return code;
-}
-/*
-int stmtGetParam(TAOS_STMT* stmt, int idx, int* type, int* bytes) {
-  STscStmt2* pStmt = (STscStmt2*)stmt;
-
-  STMT_DLOG_E("start to get param");
-
-  if (pStmt->errCode != TSDB_CODE_SUCCESS) {
-    return pStmt->errCode;
-  }
-
-  if (STMT_TYPE_QUERY == pStmt->sql.type) {
-    STMT_RET(TSDB_CODE_TSC_STMT_API_ERROR);
-  }
-
-  STMT_ERR_RET(stmtSwitchStatus(pStmt, STMT_FETCH_FIELDS));
-
-  if (pStmt->bInfo.needParse && pStmt->sql.runTimes && pStmt->sql.type > 0 &&
-      STMT_TYPE_MULTI_INSERT != pStmt->sql.type) {
-    pStmt->bInfo.needParse = false;
-  }
-
-  if (pStmt->exec.pRequest && STMT_TYPE_QUERY == pStmt->sql.type && pStmt->sql.runTimes) {
-    taos_free_result(pStmt->exec.pRequest);
-    pStmt->exec.pRequest = NULL;
-  }
-
-  STMT_ERR_RET(stmtCreateRequest(pStmt));
-
-  if (pStmt->bInfo.needParse) {
-    STMT_ERR_RET(stmtParseSql(pStmt));
-  }
-
-  int32_t       nums = 0;
-  TAOS_FIELD_E* pField = NULL;
-  STMT_ERR_RET(stmtFetchColFields(stmt, &nums, &pField));
-  if (idx >= nums) {
-    tscError("idx %d is too big", idx);
-    taosMemoryFree(pField);
-    STMT_ERR_RET(TSDB_CODE_INVALID_PARA);
-  }
-
-  *type = pField[idx].type;
-  *bytes = pField[idx].bytes;
-
-  taosMemoryFree(pField);
-
-  return TSDB_CODE_SUCCESS;
-}
-*/
 TAOS_RES* stmtUseResult2(TAOS_STMT2* stmt) {
   STscStmt2* pStmt = (STscStmt2*)stmt;
 

source/client/test/CMakeLists.txt

@@ -41,6 +41,12 @@ TARGET_LINK_LIBRARIES(
         PUBLIC ${TAOS_LIB}
 )
 
+ADD_EXECUTABLE(stmt2Test stmt2Test.cpp)
+TARGET_LINK_LIBRARIES(
+        stmt2Test
+        os util common transport parser catalog scheduler gtest ${TAOS_LIB_STATIC} qcom executor function
+)
+
 TARGET_INCLUDE_DIRECTORIES(
         clientTest
         PUBLIC "${TD_SOURCE_DIR}/include/client/"
@@ -62,6 +68,10 @@ IF(${TD_LINUX})
                 NAME connectOptionsTest
                 COMMAND connectOptionsTest
         )
+        add_test(
+                NAME stmt2Test
+                COMMAND stmt2Test
+        )
 ENDIF ()
 
 TARGET_INCLUDE_DIRECTORIES(
@@ -82,6 +92,12 @@ TARGET_INCLUDE_DIRECTORIES(
 #        PRIVATE "${TD_SOURCE_DIR}/source/client/inc"
 #)
 
+TARGET_INCLUDE_DIRECTORIES(
+        stmt2Test
+        PUBLIC "${TD_SOURCE_DIR}/include/client/"
+        PRIVATE "${TD_SOURCE_DIR}/source/client/inc"
+)
+
 add_test(
         NAME smlTest
         COMMAND smlTest
@@ -96,4 +112,3 @@ add_test(
         NAME userOperTest
         COMMAND userOperTest
 )
-

source/libs/parser/inc/parInsertUtil.h

@@ -50,6 +50,7 @@ int32_t insInitColValues(STableMeta *pTableMeta, SArray *aColValues);
 void    insCheckTableDataOrder(STableDataCxt *pTableCxt, SRowKey *rowKey);
 int32_t insGetTableDataCxt(SHashObj *pHash, void *id, int32_t idLen, STableMeta *pTableMeta,
                            SVCreateTbReq **pCreateTbReq, STableDataCxt **pTableCxt, bool colMode, bool ignoreColVals);
+int32_t initTableColSubmitDataWithBoundInfo(STableDataCxt *pTableCxt, SBoundColInfo pBoundColsInfo);
 int32_t initTableColSubmitData(STableDataCxt *pTableCxt);
 int32_t insMergeTableDataCxt(SHashObj *pTableHash, SArray **pVgDataBlocks, bool isRebuild);
 //int32_t insMergeStmtTableDataCxt(STableDataCxt* pTableCxt, SArray* pTableList, SArray** pVgDataBlocks, bool isRebuild, int32_t tbNum);

source/libs/parser/src/parInsertSql.c

@@ -1446,6 +1446,27 @@ int32_t initTableColSubmitData(STableDataCxt* pTableCxt) {
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t initTableColSubmitDataWithBoundInfo(STableDataCxt* pTableCxt, SBoundColInfo pBoundColsInfo) {
+  insDestroyBoundColInfo(&(pTableCxt->boundColsInfo));
+  pTableCxt->boundColsInfo = pBoundColsInfo;
+  pTableCxt->boundColsInfo.pColIndex = taosMemoryCalloc(pBoundColsInfo.numOfBound - 1, sizeof(int16_t));
+  if (NULL == pTableCxt->boundColsInfo.pColIndex) {
+    return terrno;
+  }
+  (void)memcpy(pTableCxt->boundColsInfo.pColIndex, pBoundColsInfo.pColIndex,
+               sizeof(int16_t) * pBoundColsInfo.numOfBound - 1);
+  for (int32_t i = 0; i < pBoundColsInfo.numOfBound; ++i) {
+    SSchema*  pSchema = &pTableCxt->pMeta->schema[pTableCxt->boundColsInfo.pColIndex[i]];
+    SColData* pCol = taosArrayReserve(pTableCxt->pData->aCol, 1);
+    if (NULL == pCol) {
+      return terrno;
+    }
+    tColDataInit(pCol, pSchema->colId, pSchema->type, pSchema->flags);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
 // input pStmt->pSql:
 //   1. [(tag1_name, ...)] ...
 //   2. VALUES ... | FILE ...
@@ -1815,7 +1836,7 @@ static int32_t processCtbTagsAfterCtbName(SInsertParseContext* pCxt, SVnodeModif
 static int32_t doGetStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt, const char** ppSql,
                                  SStbRowsDataContext* pStbRowsCxt, SToken* pToken, const SBoundColInfo* pCols,
                                  const SSchema* pSchemas, SToken* tagTokens, SSchema** tagSchemas, int* pNumOfTagTokens,
-                                 bool* bFoundTbName) {
+                                 bool* bFoundTbName, bool* setCtbName, SBoundColInfo* ctbCols) {
   int32_t code = TSDB_CODE_SUCCESS;
   SArray* pTagNames = pStbRowsCxt->aTagNames;
   SArray* pTagVals = pStbRowsCxt->aTagVals;
@@ -1824,7 +1845,8 @@ static int32_t doGetStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt*
   int32_t numOfTags = getNumOfTags(pStbRowsCxt->pStbMeta);
   int32_t tbnameIdx = getTbnameSchemaIndex(pStbRowsCxt->pStbMeta);
   uint8_t precision = getTableInfo(pStbRowsCxt->pStbMeta).precision;
-  int     idx = 0;
+  int     tag_index = 0;
+  int     col_index = 0;
   for (int i = 0; i < pCols->numOfBound && (code) == TSDB_CODE_SUCCESS; ++i) {
     const char* pTmpSql = *ppSql;
     bool        ignoreComma = false;
@@ -1847,6 +1869,7 @@ static int32_t doGetStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt*
       pCxt->isStmtBind = true;
       pStmt->usingTableProcessing = true;
       if (pCols->pColIndex[i] == tbnameIdx) {
+        *bFoundTbName = true;
         char* tbName = NULL;
         if ((*pCxt->pComCxt->pStmtCb->getTbNameFn)(pCxt->pComCxt->pStmtCb->pStmt, &tbName) == TSDB_CODE_SUCCESS) {
           tstrncpy(pStbRowsCxt->ctbName.tname, tbName, sizeof(pStbRowsCxt->ctbName.tname));
@@ -1855,10 +1878,20 @@ static int32_t doGetStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt*
           tstrncpy(pStmt->usingTableName.dbname, pStmt->targetTableName.dbname, sizeof(pStmt->usingTableName.dbname));
           pStmt->usingTableName.type = 1;
           pStmt->pTableMeta->tableType = TSDB_CHILD_TABLE;  // set the table type to child table for parse cache
-          *bFoundTbName = true;
+          *setCtbName = true;
         }
       } else if (pCols->pColIndex[i] < numOfCols) {
         // bind column
+        if (ctbCols->pColIndex == NULL) {
+          ctbCols->pColIndex = taosMemoryCalloc(numOfCols, sizeof(int16_t));
+          if (NULL == ctbCols->pColIndex) {
+            return terrno;
+          }
+        }
+        ctbCols->pColIndex[col_index++] = pCols->pColIndex[i];
+        ctbCols->numOfBound++;
+        ctbCols->numOfCols++;
+
       } else if (pCols->pColIndex[i] < tbnameIdx) {
         if (pCxt->tags.pColIndex == NULL) {
           pCxt->tags.pColIndex = taosMemoryCalloc(numOfTags, sizeof(int16_t));
@@ -1866,10 +1899,10 @@ static int32_t doGetStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt*
             return terrno;
           }
         }
-        if (!(idx < numOfTags)) {
+        if (!(tag_index < numOfTags)) {
           return buildInvalidOperationMsg(&pCxt->msg, "not expected numOfTags");
         }
-        pCxt->tags.pColIndex[idx++] = pCols->pColIndex[i] - numOfCols;
+        pCxt->tags.pColIndex[tag_index++] = pCols->pColIndex[i] - numOfCols;
         pCxt->tags.mixTagsCols = true;
         pCxt->tags.numOfBound++;
         pCxt->tags.numOfCols++;
@@ -1927,7 +1960,8 @@ static int32_t doGetStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt*
 }
 
 static int32_t getStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt, const char** ppSql,
-                               SStbRowsDataContext* pStbRowsCxt, bool* pGotRow, SToken* pToken, bool* pCtbFirst) {
+                               SStbRowsDataContext* pStbRowsCxt, bool* pGotRow, SToken* pToken, bool* pCtbFirst,
+                               bool* setCtbName, SBoundColInfo* ctbCols) {
   SBoundColInfo* pCols = &pStbRowsCxt->boundColsInfo;
   SSchema*       pSchemas = getTableColumnSchema(pStbRowsCxt->pStbMeta);
 
@@ -1940,19 +1974,14 @@ static int32_t getStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pS
   int      numOfTagTokens = 0;
 
   code = doGetStbRowValues(pCxt, pStmt, ppSql, pStbRowsCxt, pToken, pCols, pSchemas, tagTokens, tagSchemas,
-                           &numOfTagTokens, &bFoundTbName);
+                           &numOfTagTokens, &bFoundTbName, setCtbName, ctbCols);
 
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
 
   if (!bFoundTbName) {
-    if (!pCxt->isStmtBind) {
     code = buildSyntaxErrMsg(&pCxt->msg, "tbname value expected", pOrigSql);
-    } else {
-      *pGotRow = true;
-      return TSDB_CODE_TSC_STMT_TBNAME_ERROR;
-    }
   }
 
   bool ctbFirst = true;
@@ -2079,9 +2108,11 @@ static int32_t parseOneStbRow(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pSt
                               SStbRowsDataContext* pStbRowsCxt, bool* pGotRow, SToken* pToken,
                               STableDataCxt** ppTableDataCxt) {
   bool    bFirstTable = false;
-  int32_t code = getStbRowValues(pCxt, pStmt, ppSql, pStbRowsCxt, pGotRow, pToken, &bFirstTable);
+  bool    setCtbName = false;
+  SBoundColInfo ctbCols = {0};
+  int32_t code = getStbRowValues(pCxt, pStmt, ppSql, pStbRowsCxt, pGotRow, pToken, &bFirstTable, &setCtbName, &ctbCols);
 
-  if (code == TSDB_CODE_TSC_STMT_TBNAME_ERROR && *pGotRow) {
+  if (!setCtbName && pCxt->isStmtBind) {
     return parseStbBoundInfo(pStmt, pStbRowsCxt, ppTableDataCxt);
   }
 
@@ -2108,8 +2139,14 @@ static int32_t parseOneStbRow(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pSt
     }
   }
   if (code == TSDB_CODE_SUCCESS) {
+    if (pCxt->isStmtBind) {
+      int32_t tbnameIdx = getTbnameSchemaIndex(pStbRowsCxt->pStbMeta);
+      code = initTableColSubmitDataWithBoundInfo(*ppTableDataCxt, ctbCols);
+      insDestroyBoundColInfo(&ctbCols);
+    } else {
       code = initTableColSubmitData(*ppTableDataCxt);
     }
+  }
   if (code == TSDB_CODE_SUCCESS && !pCxt->isStmtBind) {
     SRow** pRow = taosArrayReserve((*ppTableDataCxt)->pData->aRowP, 1);
     code = tRowBuild(pStbRowsCxt->aColVals, (*ppTableDataCxt)->pSchema, pRow);