[td-4030]

src/client/jni/com_taosdata_jdbc_TSDBJNIConnector.h

@@ -100,7 +100,7 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getResultSetImp
 /*
  * Class:     com_taosdata_jdbc_TSDBJNIConnector
  * Method:    isUpdateQueryImp
- * Signature: (J)J
+ * Signature: (JJ)I
  */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_isUpdateQueryImp
   (JNIEnv *env, jobject jobj, jlong con, jlong tres);
@@ -185,6 +185,44 @@ JNIEXPORT void JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_unsubscribeImp
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_validateCreateTableSqlImp
   (JNIEnv *, jobject, jlong, jbyteArray);
 
+/*
+ * Class:     com_taosdata_jdbc_TSDBJNIConnector
+ * Method:    prepareStmtImp
+ * Signature: ([BJ)I
+ */
+JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_prepareStmtImp
+  (JNIEnv *, jobject, jbyteArray, jlong);
+
+/*
+ * Class:     com_taosdata_jdbc_TSDBJNIConnector
+ * Method:    setBindTableNameImp
+ * Signature: (JLjava/lang/String;J)I
+ */
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setBindTableNameImp
+  (JNIEnv *, jobject, jlong, jstring, jlong);
+
+/*
+ * Class:     com_taosdata_jdbc_TSDBJNIConnector
+ * Method:    bindColDataImp
+ * Signature: (J[BIIIJ)J
+ */
+JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_bindColDataImp
+(JNIEnv *, jobject, jlong, jbyteArray, jint, jint, jint, jlong);
+
+/*
+ * Class:     com_taosdata_jdbc_TSDBJNIConnector
+ * Method:    executeBatchImp
+ * Signature: (JJ)I
+ */
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeBatchImp(JNIEnv *env, jobject jobj, jlong stmt, jlong con);
+
+/*
+ * Class:     com_taosdata_jdbc_TSDBJNIConnector
+ * Method:    executeBatchImp
+ * Signature: (JJ)I
+ */
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_closeStmt(JNIEnv *env, jobject jobj, jlong stmt, jlong con);
+
 #ifdef __cplusplus
 }
 #endif

src/client/src/TSDBJNIConnector.c

@@ -688,3 +688,139 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TDDBJNIConnector_getResultTimePrec
 
   return taos_result_precision(result);
 }
+
+JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_prepareStmtImp(JNIEnv *env, jobject jobj, jbyteArray jsql, jlong con) {
+  TAOS *tscon = (TAOS *)con;
+  if (tscon == NULL) {
+    jniError("jobj:%p, connection already closed", jobj);
+    return JNI_CONNECTION_NULL;
+  }
+
+  if (jsql == NULL) {
+    jniError("jobj:%p, conn:%p, empty sql string", jobj, tscon);
+    return JNI_SQL_NULL;
+  }
+
+  jsize len = (*env)->GetArrayLength(env, jsql);
+
+  char *str = (char *) calloc(1, sizeof(char) * (len + 1));
+  if (str == NULL) {
+    jniError("jobj:%p, conn:%p, alloc memory failed", jobj, tscon);
+    return JNI_OUT_OF_MEMORY;
+  }
+
+  (*env)->GetByteArrayRegion(env, jsql, 0, len, (jbyte *)str);
+  if ((*env)->ExceptionCheck(env)) {
+    // todo handle error
+  }
+
+  TAOS_STMT* pStmt = taos_stmt_init(tscon);
+  int32_t code = taos_stmt_prepare(pStmt, str, len);
+  if (code != TSDB_CODE_SUCCESS) {
+    jniError("jobj:%p, conn:%p, code:%s", jobj, tscon, tstrerror(code));
+    return JNI_TDENGINE_ERROR;
+  }
+
+  free(str);
+  return (jlong) pStmt;
+}
+
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setBindTableNameImp(JNIEnv *env, jobject jobj, jlong stmt, jstring jname, jlong conn) {
+  TAOS *tsconn = (TAOS *)conn;
+  if (tsconn == NULL) {
+    jniError("jobj:%p, connection already closed", jobj);
+    return JNI_CONNECTION_NULL;
+  }
+
+  TAOS_STMT* pStmt = (TAOS_STMT*) stmt;
+  if (pStmt == NULL) {
+    jniError("jobj:%p, conn:%p, invalid stmt handle", jobj, tsconn);
+    return JNI_SQL_NULL;
+  }
+
+  const char *name = (*env)->GetStringUTFChars(env, jname, NULL);
+
+  int32_t code = taos_stmt_set_tbname((void*)stmt, name);
+  if (code != TSDB_CODE_SUCCESS) {
+    jniError("jobj:%p, conn:%p, code:%s", jobj, tsconn, tstrerror(code));
+    return JNI_TDENGINE_ERROR;
+  }
+
+  jniDebug("jobj:%p, conn:%p, set stmt bind table name", jobj, tsconn);
+
+  (*env)->ReleaseStringUTFChars(env, jname, name);
+  return JNI_SUCCESS;
+}
+
+JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_bindColDataImp(JNIEnv *env, jobject jobj, jlong stmt,
+    jbyteArray data, jint dataType, jint numOfRows, jint colIndex, jlong con) {
+  TAOS *tscon = (TAOS *)con;
+  if (tscon == NULL) {
+    jniError("jobj:%p, connection already closed", jobj);
+    return JNI_CONNECTION_NULL;
+  }
+
+  TAOS_STMT* pStmt = (TAOS_STMT*) stmt;
+  if (pStmt == NULL) {
+    jniError("jobj:%p, conn:%p, invalid stmt", jobj, tscon);
+    return JNI_SQL_NULL;
+  }
+
+#if 0
+  TAOS_BIND* b = malloc(20);
+  b.num= jrows;
+  int32_t code = taos_stmt_bind_param_batch(stmt, b, colInex);
+  if (code != TSDB_CODE_SUCCESS) {
+    jniError("jobj:%p, conn:%p, code:%s", jobj, tscon, tstrerror(code));
+    return JNI_TDENGINE_ERROR;
+  }
+#endif
+
+  return JNI_SUCCESS;
+}
+
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeBatchImp(JNIEnv *env, jobject jobj, jlong stmt, jlong con) {
+  TAOS *tscon = (TAOS *)con;
+  if (tscon == NULL) {
+    jniError("jobj:%p, connection already closed", jobj);
+    return JNI_CONNECTION_NULL;
+  }
+
+  TAOS_STMT *pStmt = (TAOS_STMT*) stmt;
+  if (pStmt == NULL) {
+    jniError("jobj:%p, conn:%p, invalid stmt", jobj, tscon);
+    return JNI_SQL_NULL;
+  }
+
+  int32_t code = taos_stmt_execute(pStmt);
+  if (code != TSDB_CODE_SUCCESS) {
+    jniError("jobj:%p, conn:%p, code:%s", jobj, tscon, tstrerror(code));
+    return JNI_TDENGINE_ERROR;
+  }
+
+  jniDebug("jobj:%p, conn:%p, batch execute", jobj, tscon);
+  return JNI_SUCCESS;
+}
+
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_closeStmt(JNIEnv *env, jobject jobj, jlong stmt, jlong con) {
+  TAOS *tscon = (TAOS *)con;
+  if (tscon == NULL) {
+    jniError("jobj:%p, connection already closed", jobj);
+    return JNI_CONNECTION_NULL;
+  }
+
+  TAOS_STMT *pStmt = (TAOS_STMT*) stmt;
+  if (pStmt == NULL) {
+    jniError("jobj:%p, conn:%p, invalid stmt", jobj, tscon);
+    return JNI_SQL_NULL;
+  }
+
+  int32_t code = taos_stmt_close(pStmt);
+  if (code != TSDB_CODE_SUCCESS) {
+    jniError("jobj:%p, conn:%p, code:%s", jobj, tscon, tstrerror(code));
+    return JNI_TDENGINE_ERROR;
+  }
+
+  jniDebug("jobj:%p, conn:%p, stmt closed", jobj, tscon);
+  return JNI_SUCCESS;
+}

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java

@@ -18,6 +18,7 @@ package com.taosdata.jdbc;
 
 import com.taosdata.jdbc.utils.TaosInfo;
 
+import java.nio.ByteBuffer;
 import java.sql.SQLException;
 import java.sql.SQLWarning;
 import java.util.List;
@@ -75,7 +76,6 @@ public class TSDBJNIConnector {
 
     public boolean connect(String host, int port, String dbName, String user, String password) throws SQLException {
         if (this.taos != TSDBConstants.JNI_NULL_POINTER) {
-//            this.closeConnectionImp(this.taos);
             closeConnection();
             this.taos = TSDBConstants.JNI_NULL_POINTER;
         }
@@ -97,12 +97,6 @@ public class TSDBJNIConnector {
      * @throws SQLException
      */
     public long executeQuery(String sql) throws SQLException {
-        // close previous result set if the user forgets to invoke the
-        // free method to close previous result set.
-//        if (!this.isResultsetClosed) {
-//            freeResultSet(taosResultSetPointer);
-//        }
-
         Long pSql = 0l;
         try {
             pSql = this.executeQueryImp(sql.getBytes(TaosGlobalConfig.getCharset()), this.taos);
@@ -297,4 +291,54 @@ public class TSDBJNIConnector {
     }
 
     private native int validateCreateTableSqlImp(long connection, byte[] sqlBytes);
+    
+	public long prepareStmt(String sql) throws SQLException {
+    	Long stmt = 0L;
+    	try {
+    	stmt = prepareStmtImp(sql, this.taos);
+    	} catch (Exception e) {
+            e.printStackTrace();
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_ENCODING);
+        }
+    	
+        if (stmt == TSDBConstants.JNI_CONNECTION_NULL) {
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL);
+        }
+        
+        if (stmt == TSDBConstants.JNI_SQL_NULL) {
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_SQL_NULL);
+        }
+        
+        if (stmt == TSDBConstants.JNI_OUT_OF_MEMORY) {
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_OUT_OF_MEMORY);
+        }
+        
+    	return stmt;
+    }
+    
+    private native long prepareStmtImp(String sql, long con);
+    
+    public int setBindTableName(long stmt, String tableName) {
+		return setBindTableNameImp(stmt, tableName, this.taos);
+	}
+    
+    private native int setBindTableNameImp(long stmt, String name, long conn);
+    
+    public int bindColumnDataArray(long stmt, byte[] data, int type, int numOfRows, int columnIndex) {
+		return bindColDataImp(stmt, data, type, numOfRows, columnIndex, this.taos);
+	}
+    
+    private native int bindColDataImp(long stmt, byte[] data, int type, int numOfRows, int columnIndex, long conn);
+    
+    public int executeBatch(long stmt) {
+    	return executeBatchImp(stmt, this.taos);
+    }
+    
+    private native int executeBatchImp(long stmt, long con);
+    
+    public int closeBatch(long stmt) {
+    	return closeStmt(stmt, this.taos);
+    }
+    
+    private native int closeStmt(long stmt, long con);
 }

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBPreparedStatement.java

@@ -14,37 +14,47 @@
  *****************************************************************************/
 package com.taosdata.jdbc;
 
+import com.sun.tools.javac.util.Assert;
 import com.taosdata.jdbc.utils.Utils;
 
 import java.io.InputStream;
 import java.io.Reader;
 import java.math.BigDecimal;
 import java.net.URL;
+import java.nio.ByteBuffer;
+import java.nio.DoubleBuffer;
+import java.nio.IntBuffer;
 import java.sql.*;
 import java.util.ArrayList;
 import java.util.Calendar;
+import java.util.Collections;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /*
- * TDengine only supports a subset of the standard SQL, thus this implemetation of the
+ * TDengine only supports a subset of the standard SQL, thus this implementation of the
  * standard JDBC API contains more or less some adjustments customized for certain
  * compatibility needs.
  */
 public class TSDBPreparedStatement extends TSDBStatement implements PreparedStatement {
-
     private String rawSql;
     private Object[] parameters;
     private boolean isPrepared;
     
+    private ArrayList<ColumnInfo> colData;
+    private int type;
+    
+    private String tableName;
+    private long nativeStmtPtr = 0;
+    
     private volatile TSDBParameterMetaData parameterMetaData;
 
-    TSDBPreparedStatement(TSDBConnection connection, TSDBJNIConnector connecter, String sql) {
-        super(connection, connecter);
+    TSDBPreparedStatement(TSDBConnection connection, TSDBJNIConnector connector, String sql) {
+		super(connection, connector);
         init(sql);
 
-        if (sql.contains("?")) {
         int parameterCnt = 0;
+        if (sql.contains("?")) {
             for (int i = 0; i < sql.length(); i++) {
                 if ('?' == sql.charAt(i)) {
                     parameterCnt++;
@@ -53,6 +63,9 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
             parameters = new Object[parameterCnt];
             this.isPrepared = true;
         }
+        
+        this.colData = new ArrayList<ColumnInfo>(parameterCnt);
+        this.colData.addAll(Collections.nCopies(parameterCnt, null));
     }
 
     private void init(String sql) {
@@ -260,10 +273,14 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
 
     @Override
     public void setObject(int parameterIndex, Object x) throws SQLException {
-        if (isClosed())
+        if (isClosed()) {
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-        if (parameterIndex < 1 && parameterIndex >= parameters.length)
+        }
+        
+        if (parameterIndex < 1 && parameterIndex >= parameters.length) {
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
+        }
+        
         parameters[parameterIndex - 1] = x;
     }
 
@@ -300,8 +317,9 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
 
     @Override
     public void setRef(int parameterIndex, Ref x) throws SQLException {
-        if (isClosed())
+        if (isClosed()) {
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
+        }
         
         throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
     }
@@ -515,4 +533,135 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
         throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
     }
+    
+    ///////////////////////////////////////////////////////////////////////
+    // NOTE: the following APIs are not JDBC compatible
+    // set the bind table name
+    private static class ColumnInfo {
+    	@SuppressWarnings("rawtypes")
+		private ArrayList data;
+    	private int       type;
+    	private boolean   typeIsSet;
+    	
+    	public void ClumnInfo() {
+    		this.typeIsSet = false;
+    	}
+    	
+    	public void setType(int type) {
+    		Assert.check(!this.typeIsSet);
+    		this.typeIsSet = true;
+    		this.type = type;
+    	}
+    	
+    	public boolean isTypeSet() {
+    		return this.typeIsSet;
+    	}
+    };
+    
+    public void setTableName(String name) {
+    	this.tableName = name;
+    }
+    
+    @SuppressWarnings("unchecked")
+	public void setInt(int columnIndex, ArrayList<Integer> list) throws SQLException {
+    	ColumnInfo col = (ColumnInfo) this.colData.get(columnIndex);
+    	if (col == null) {
+    		ColumnInfo p = new ColumnInfo();
+    		p.setType(TSDBConstants.TSDB_DATA_TYPE_INT);
+    		p.data = (ArrayList) list.clone();
+    		this.colData.set(columnIndex, p);
+    	} else {
+    		if (col.type != TSDBConstants.TSDB_DATA_TYPE_INT) {
+                throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
+    		}
+    		
+    		col.data.addAll(list);
+    	}
+    }
+    
+    @SuppressWarnings("unchecked")
+	public void setFloat(int columnIndex, ArrayList<Float> list) throws SQLException {
+    	ColumnInfo col = (ColumnInfo) this.colData.get(columnIndex);
+    	if (col == null) {
+    		ColumnInfo p = new ColumnInfo();
+    		p.setType(TSDBConstants.TSDB_DATA_TYPE_INT);
+    		p.data = (ArrayList) list.clone();
+    		this.colData.set(columnIndex, p);
+    	} else {
+    		if (col.type != TSDBConstants.TSDB_DATA_TYPE_INT) {
+                throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
+    		}
+    		
+    		col.data.addAll(list);
+    	}
+    }
+    
+    public void addColumnDataBatch() {
+    	// do nothing
+    }
+    
+	public void columnDataExecuteBatch() {
+		int size = this.colData.size();
+		ColumnInfo col = (ColumnInfo) this.colData.get(0);
+		int rows = col.data.size();
+
+		// pass the data block to native code
+		TSDBJNIConnector conn = null;
+		try {
+			conn = (TSDBJNIConnector) this.getConnection();
+			this.nativeStmtPtr = conn.prepareStmt(rawSql);
+			conn.setBindTableName(this.nativeStmtPtr, this.tableName);
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+
+		for (int i = 0; i < size; ++i) {
+			ColumnInfo col1 = this.colData.get(i);
+			Assert.check(col.isTypeSet());
+			ByteBuffer ib = ByteBuffer.allocate(rows);
+
+			switch (col1.type) {
+				case TSDBConstants.TSDB_DATA_TYPE_INT: {
+					for (int j = 0; j < rows; ++j) {
+						Integer val = (Integer) col.data.get(j);
+						if (val == null) {
+							ib.putInt(Integer.MIN_VALUE);
+						} else {
+							ib.putInt((int) col.data.get(j));							
+						}
+					}
+					
+					break;
+				}
+	
+				case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP: {
+					for (int j = 0; j < rows; ++j) {
+						ib.putLong((long) col.data.get(j));
+					}
+					break;
+				}
+			};
+			
+			conn.bindColumnDataArray(this.nativeStmtPtr, ib.array(), col1.type, rows, i);
+		}
+		
+		conn.executeBatch(this.nativeStmtPtr);
+	}
+    
+    public void columnDataClearBatchClear() {
+    	// TODO clear data in this.colData
+    }
+    
+    public void close() {
+    	TSDBJNIConnector conn = null;
+		try {
+			conn = (TSDBJNIConnector) this.getConnection();
+			this.nativeStmtPtr = conn.prepareStmt(rawSql);
+			conn.setBindTableName(this.nativeStmtPtr, this.tableName);
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		
+		conn.closeBatch(this.nativeStmtPtr);
+    }
 }

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetBlockData.java

@@ -29,6 +29,8 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
+import com.taosdata.jdbc.utils.NullType;
+
 public class TSDBResultSetBlockData {
     private int numOfRows = 0;
     private int rowIndex = 0;
@@ -164,59 +166,7 @@ public class TSDBResultSetBlockData {
         }
     }
 
-    private static class NullType {
-        private static final byte NULL_BOOL_VAL = 0x2;
-        private static final String NULL_STR = "null";
-
-        public String toString() {
-            return NullType.NULL_STR;
-        }
-
-        public static boolean isBooleanNull(byte val) {
-            return val == NullType.NULL_BOOL_VAL;
-        }
-
-        private static boolean isTinyIntNull(byte val) {
-            return val == Byte.MIN_VALUE;
-        }
-
-        private static boolean isSmallIntNull(short val) {
-            return val == Short.MIN_VALUE;
-        }
-
-        private static boolean isIntNull(int val) {
-            return val == Integer.MIN_VALUE;
-        }
-
-        private static boolean isBigIntNull(long val) {
-            return val == Long.MIN_VALUE;
-        }
-
-        private static boolean isFloatNull(float val) {
-            return Float.isNaN(val);
-        }
-
-        private static boolean isDoubleNull(double val) {
-            return Double.isNaN(val);
-        }
-
-        private static boolean isBinaryNull(byte[] val, int length) {
-            if (length != Byte.BYTES) {
-                return false;
-            }
-
-            return val[0] == 0xFF;
-        }
-
-        private static boolean isNcharNull(byte[] val, int length) {
-            if (length != Integer.BYTES) {
-                return false;
-            }
     
-            return (val[0] & val[1] & val[2] & val[3]) == 0xFF;
-        }
-
-    }
 
     /**
      * The original type may not be a string type, but will be converted to by

src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulPreparedStatement.java

 package com.taosdata.jdbc.rs;
 
-import com.google.common.collect.Range;
-import com.google.common.collect.RangeSet;
-import com.google.common.collect.TreeRangeSet;
 import com.taosdata.jdbc.TSDBError;
 import com.taosdata.jdbc.TSDBErrorNumbers;
-import com.taosdata.jdbc.utils.SqlSyntaxValidator;
 import com.taosdata.jdbc.utils.Utils;
 
 import java.io.InputStream;
 import java.io.Reader;
 import java.math.BigDecimal;
 import java.net.URL;
-import java.nio.charset.Charset;
 import java.sql.*;
 import java.util.Calendar;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
 
 public class RestfulPreparedStatement extends RestfulStatement implements PreparedStatement {
 

src/query/src/qTokenizer.c

@@ -560,9 +560,9 @@ uint32_t tSQLGetToken(char* z, uint32_t* tokenId) {
   return 0;
 }
 
-SStrToken tscReplaceStrToken(char **str, SStrToken *token, const char* new) {
+SStrToken tscReplaceStrToken(char **str, SStrToken *token, const char* newToken) {
   char *src = *str;
-  int32_t nsize = strlen(new);
+  int32_t nsize = strlen(newToken);
   int32_t size = strlen(*str) - token->n + nsize + 1;
   int32_t bsize = (uint64_t)token->z - (uint64_t)src;
   SStrToken ntoken;
@@ -570,7 +570,7 @@ SStrToken tscReplaceStrToken(char **str, SStrToken *token, const char* new) {
   *str = calloc(1, size);
 
   strncpy(*str, src, bsize);
-  strcat(*str, new);
+  strcat(*str, newToken);
   strcat(*str, token->z + token->n);
 
   ntoken.n = nsize;

src/util/inc/tstoken.h

@@ -182,7 +182,7 @@ static FORCE_INLINE int32_t tGetNumericStringType(const SStrToken* pToken) {
 
 void taosCleanupKeywordsTable();
 
-SStrToken tscReplaceStrToken(char **str, SStrToken *token, const char* new);
+SStrToken tscReplaceStrToken(char **str, SStrToken *token, const char* newToken);
 
 
 #ifdef __cplusplus