Merge branch '3.0' of https://github.com/taosdata/TDengine into feat/row_refact

docs-en/14-reference/03-connector/go.mdx

@@ -15,9 +15,9 @@ import GoOpenTSDBTelnet from "../../07-develop/03-insert-data/_go_opts_telnet.md
 import GoOpenTSDBJson from "../../07-develop/03-insert-data/_go_opts_json.mdx"
 import GoQuery from "../../07-develop/04-query-data/_go.mdx"
 
-`driver-go` is the official Go language connector for TDengine, which implements the interface to the Go language [database/sql](https://golang.org/pkg/database/sql/) package. Go developers can use it to develop applications that access TDengine cluster data.
+`driver-go` is the official Go language connector for TDengine. It implements the [database/sql](https://golang.org/pkg/database/sql/) package, the generic Go language interface to SQL databases. Go developers can use it to develop applications that access TDengine cluster data.
 
-`driver-go` provides two ways to establish connections. One is **native connection**, which connects to TDengine instances natively through the TDengine client driver (taosc), supporting data writing, querying, subscriptions, schemaless writing, and bind interface. The other is the **REST connection**, which connects to TDengine instances via the REST interface provided by taosAdapter. The set of features implemented by the REST connection differs slightly from the native connection.
+`driver-go` provides two ways to establish connections. One is **native connection**, which connects to TDengine instances natively through the TDengine client driver (taosc), supporting data writing, querying, subscriptions, schemaless writing, and bind interface. The other is the **REST connection**, which connects to TDengine instances via the REST interface provided by taosAdapter. The set of features implemented by the REST connection differs slightly from those implemented by the native connection.
 
 This article describes how to install `driver-go` and connect to TDengine clusters and perform basic operations such as data query and data writing through `driver-go`.
 
@@ -213,7 +213,7 @@ func main() {
 
 Since the REST interface is stateless, the `use db` syntax will not work. You need to put the db name into the SQL command, e.g. `create table if not exists tb1 (ts timestamp, a int)` to `create table if not exists test.tb1 (ts timestamp, a int)` otherwise it will report the error `[0x217] Database not specified or available`.
 
-You can also put the db name in the DSN by changing `root:taosdata@http(localhost:6041)/` to `root:taosdata@http(localhost:6041)/test`. This method is supported by taosAdapter in TDengine 2.4.0.5. is supported since TDengine 2.4.0.5. Executing the `create database` statement when the specified db does not exist will not report an error while executing other queries or writing against that db will report an error.
+You can also put the db name in the DSN by changing `root:taosdata@http(localhost:6041)/` to `root:taosdata@http(localhost:6041)/test`. This method is supported by taosAdapter since TDengine 2.4.0.5. Executing the `create database` statement when the specified db does not exist will not report an error while executing other queries or writing against that db will report an error.
 
 The complete example is as follows.
 
@@ -289,7 +289,7 @@ func main() {
 
 6. `readBufferSize` parameter has no significant effect after being increased
 
-  If you increase `readBufferSize` will reduce the number of `syscall` calls when fetching results. If the query result is smaller, modifying this parameter will not improve significantly. If you increase the parameter value too much, the bottleneck will be parsing JSON data. If you need to optimize the query speed, you must adjust the value according to the actual situation to achieve the best query result.
+  Increasing `readBufferSize` will reduce the number of `syscall` calls when fetching results. If the query result is smaller, modifying this parameter will not improve performance significantly. If you increase the parameter value too much, the bottleneck will be parsing JSON data. If you need to optimize the query speed, you must adjust the value based on the actual situation to achieve the best query performance.
 
 7. `disableCompression` parameter is set to `false` when the query efficiency is reduced
 

docs-en/14-reference/03-connector/java.mdx

@@ -9,19 +9,19 @@ description: TDengine Java based on JDBC API and provide both native and REST co
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';
 
-'taos-jdbcdriver' is TDengine's official Java language connector, which allows Java developers to develop applications that access the TDengine database. 'taos-jdbcdriver' implements the interface of the JDBC driver standard and provides two forms of connectors. One is to connect to a TDengine instance natively through the TDengine client driver (taosc), which supports functions including data writing, querying, subscription, schemaless writing, and bind interface. And the other is to connect to a TDengine instance through the REST interface provided by taosAdapter (2.4.0.0 and later). REST connections implement has a slight differences to compare the set of features implemented and native connections.
+'taos-jdbcdriver' is TDengine's official Java language connector, which allows Java developers to develop applications that access the TDengine database. 'taos-jdbcdriver' implements the interface of the JDBC driver standard and provides two forms of connectors. One is to connect to a TDengine instance natively through the TDengine client driver (taosc), which supports functions including data writing, querying, subscription, schemaless writing, and bind interface. And the other is to connect to a TDengine instance through the REST interface provided by taosAdapter (2.4.0.0 and later). The implementation of the REST connection and those of the native connections have slight differences in features.
 
 ![TDengine Database tdengine-connector](tdengine-jdbc-connector.webp)
 
 The preceding diagram shows two ways for a Java app to access TDengine via connector:
 
 - JDBC native connection: Java applications use TSDBDriver on physical node 1 (pnode1) to call client-driven directly (`libtaos.so` or `taos.dll`) APIs to send writing and query requests to taosd instances located on physical node 2 (pnode2).
-- JDBC REST connection: The Java application encapsulates the SQL as a REST request via RestfulDriver, sends it to the REST server of physical node 2 (taosAdapter), requests TDengine server through the REST server, and returns the result.
+- JDBC REST connection: The Java application encapsulates the SQL as a REST request via RestfulDriver, sends it to the REST server (taosAdapter) on physical node 2. taosAdapter forwards the request to TDengine server and returns the result.
 
-Using REST connection, which does not rely on TDengine client drivers.It can be cross-platform more convenient and flexible but introduce about 30% lower performance than native connection.
+The REST connection, which does not rely on TDengine client drivers, is more convenient and flexible, in addition to being cross-platform. However the performance is about 30% lower than that of the native connection.
 
 :::info
-TDengine's JDBC driver implementation is as consistent as possible with the relational database driver. Still, there are differences in the use scenarios and technical characteristics of TDengine and relational object databases, so 'taos-jdbcdriver' also has some differences from traditional JDBC drivers. You need to pay attention to the following points when using:
+TDengine's JDBC driver implementation is as consistent as possible with the relational database driver. Still, there are differences in the use scenarios and technical characteristics of TDengine and relational object databases. So 'taos-jdbcdriver' also has some differences from traditional JDBC drivers. It is important to keep the following points in mind:
 
 - TDengine does not currently support delete operations for individual data records.
 - Transactional operations are not currently supported.
@@ -88,7 +88,7 @@ Add following dependency in the `pom.xml` file of your Maven project:
 </TabItem>
 <TabItem value="source" label="Build from source code">
 
-You can build Java connector from source code after clone TDengine project:
+You can build Java connector from source code after cloning the TDengine project:
 
 ```shell
 git clone https://github.com/taosdata/TDengine.git
@@ -96,7 +96,7 @@ cd TDengine/src/connector/jdbc
 mvn clean install -Dmaven.test.skip=true
 ```
 
-After compilation, a jar package of taos-jdbcdriver-2.0.XX-dist .jar is generated in the target directory, and the compiled jar file is automatically placed in the local Maven repository.
+After compilation, a jar package named taos-jdbcdriver-2.0.XX-dist.jar is generated in the target directory, and the compiled jar file is automatically placed in the local Maven repository.
 
 </TabItem>
 </Tabs>
@@ -186,7 +186,7 @@ Connection conn = DriverManager.getConnection(jdbcUrl);
 
 In the above example, a RestfulDriver with a JDBC REST connection is used to establish a connection to a database named `test` with hostname `taosdemo.com` on port `6041`. The URL specifies the user name as `root` and the password as `taosdata`.
 
-There is no dependency on the client driver when Using a JDBC REST connection. Compared to a JDBC native connection, only the following are required: 1.
+There is no dependency on the client driver when Using a JDBC REST connection. Compared to a JDBC native connection, only the following are required:
 
 1. driverClass specified as "com.taosdata.jdbc.rs.RestfulDriver".
 2. jdbcUrl starting with "jdbc:TAOS-RS://".
@@ -209,7 +209,7 @@ The configuration parameters in the URL are as follows.
 INSERT INTO test.t1 USING test.weather (ts, temperature) TAGS('California.SanFrancisco') VALUES(now, 24.6);
 ```
 
-- Starting from taos-jdbcdriver-2.0.36 and TDengine 2.2.0.0, if dbname is specified in the URL, JDBC REST connections will use `/rest/sql/dbname` as the URL for REST requests by default, and there is no need to specify dbname in SQL. For example, if the URL is `jdbc:TAOS-RS://127.0.0.1:6041/test`, then the SQL can be executed: insert into t1 using weather(ts, temperature) tags('California.SanFrancisco') values(now, 24.6);
+- Starting from taos-jdbcdriver-2.0.36 and TDengine 2.2.0.0, if dbname is specified in the URL, JDBC REST connections will use `/rest/sql/dbname` as the URL for REST requests by default, and there is no need to specify dbname in SQL. For example, if the URL is `jdbc:TAOS-RS://127.0.0.1:6041/test`, then the SQL can be executed: insert into test using weather(ts, temperature) tags('California.SanFrancisco') values(now, 24.6);
 
 :::
 
@@ -271,7 +271,7 @@ If the configuration parameters are duplicated in the URL, Properties, or client
 2. Properties connProps
 3. the configuration file taos.cfg of the TDengine client driver when using a native connection
 
-For example, if you specify the password as `taosdata` in the URL and specify the password as `taosdemo` in the Properties simultaneously. In this case, JDBC will use the password in the URL to establish the connection.
+For example, if you specify the password as `taosdata` in the URL and specify the password as `taosdemo` in the Properties simultaneously, JDBC will use the password in the URL to establish the connection.
 
 ## Usage examples
 
@@ -323,7 +323,7 @@ while(resultSet.next()){
 }
 ```
 
-> The query is consistent with operating a relational database. When using subscripts to get the contents of the returned fields, starting from 1, it is recommended to use the field names to get them.
+> The query is consistent with operating a relational database. When using subscripts to get the contents of the returned fields, you have to start from 1. However, we recommend using the field names to get the values of the fields in the result set.
 
 ### Handling exceptions
 
@@ -623,7 +623,7 @@ public void setNString(int columnIndex, ArrayList<String> list, int size) throws
 
 ### Schemaless Writing
 
-Starting with version 2.2.0.0, TDengine has added the ability to schemaless writing. It is compatible with InfluxDB's Line Protocol, OpenTSDB's telnet line protocol, and OpenTSDB's JSON format protocol. See [schemaless writing](/reference/schemaless/) for details.
+Starting with version 2.2.0.0, TDengine has added the ability to perform schemaless writing. It is compatible with InfluxDB's Line Protocol, OpenTSDB's telnet line protocol, and OpenTSDB's JSON format protocol. See [schemaless writing](/reference/schemaless/) for details.
 
 **Note**.
 
@@ -666,16 +666,16 @@ The TDengine Java Connector supports subscription functionality with the followi
 #### Create subscriptions
 
 ```java
-TSDBSubscribe sub = ((TSDBConnection)conn).subscribe("topic", "select * from meters", false);
+TSDBSubscribe sub = ((TSDBConnection)conn).subscribe("topicname", "select * from meters", false);
 ```
 
 The three parameters of the `subscribe()` method have the following meanings.
 
-- topic: the subscribed topic (i.e., name). This parameter is the unique identifier of the subscription
-- sql: the query statement of the subscription, this statement can only be `select` statement, only the original data should be queried, and you can query only the data in the positive time order
+- topicname: the name of the subscribed topic. This parameter is the unique identifier of the subscription.
+- sql: the query statement of the subscription. This statement can only be a `select` statement. Only original data can be queried, and you can query the data only temporal order.
 - restart: if the subscription already exists, whether to restart or continue the previous subscription
 
-The above example will use the SQL command `select * from meters` to create a subscription named `topic`. If the subscription exists, it will continue the progress of the previous query instead of consuming all the data from the beginning.
+The above example will use the SQL command `select * from meters` to create a subscription named `topicname`. If the subscription exists, it will continue the progress of the previous query instead of consuming all the data from the beginning.
 
 #### Subscribe to consume data
 

docs-en/14-reference/03-connector/python.mdx

@@ -11,18 +11,18 @@ import TabItem from "@theme/TabItem";
 `taospy` is the official Python connector for TDengine. `taospy` provides a rich set of APIs that makes it easy for Python applications to access TDengine. `taospy` wraps both the [native interface](/reference/connector/cpp) and [REST interface](/reference/rest-api) of TDengine, which correspond to the `taos` and `taosrest` modules of the `taospy` package, respectively.
 In addition to wrapping the native and REST interfaces, `taospy` also provides a set of programming interfaces that conforms to the [Python Data Access Specification (PEP 249)](https://peps.python.org/pep-0249/). It is easy to integrate `taospy` with many third-party tools, such as [SQLAlchemy](https://www.sqlalchemy.org/) and [pandas](https://pandas.pydata.org/).
 
-The connection to the server directly using the native interface provided by the client driver is referred to hereinafter as a "native connection"; the connection to the server using the REST interface provided by taosAdapter is referred to hereinafter as a "REST connection".
+The direct connection to the server using the native interface provided by the client driver is referred to hereinafter as a "native connection"; the connection to the server using the REST interface provided by taosAdapter is referred to hereinafter as a "REST connection".
 
 The source code for the Python connector is hosted on [GitHub](https://github.com/taosdata/taos-connector-python).
 
 ## Supported Platforms
 
-- The native connection [supported platforms](/reference/connector/#supported-platforms) is the same as the one supported by the TDengine client.
+- The [supported platforms](/reference/connector/#supported-platforms) for the native connection are the same as the ones supported by the TDengine client.
 - REST connections are supported on all platforms that can run Python.
 
 ## Version selection
 
-We recommend using the latest version of `taospy`, regardless what the version of TDengine is.
+We recommend using the latest version of `taospy`, regardless of the version of TDengine.
 
 ## Supported features
 
@@ -139,7 +139,7 @@ The FQDN above can be the FQDN of any dnode in the cluster, and the PORT is the
 </TabItem>
 <TabItem value="rest" label="REST connection" groupId="connect">
 
-For REST connections and making sure the cluster is up, make sure the taosAdapter component is up. This can be tested using the following `curl ` command.
+For REST connections, make sure the cluster and taosAdapter component, are running. This can be tested using the following `curl ` command.
 
 ```
 curl -u root:taosdata http://<FQDN>:<PORT>/rest/sql -d "select server_version()"
@@ -312,7 +312,7 @@ For a more detailed description of the `sql()` method, please refer to [RestClie
 
 ### Exception handling
 
-All database operations will be thrown directly if an exception occurs. The application is responsible for exception handling. For example:
+All errors from database operations are thrown directly as exceptions and the error message from the database is passed up the exception stack. The application is responsible for exception handling. For example:
 
 ```python
 {{#include docs-examples/python/handle_exception.py}}

docs-en/14-reference/03-connector/rust.mdx

@@ -30,7 +30,7 @@ REST connections are supported on all platforms that can run Rust.
 
 Please refer to [version support list](/reference/connector#version-support).
 
-The Rust Connector is still under rapid development and is not guaranteed to be backward compatible before 1.0. Recommend to use TDengine version 2.4 or higher to avoid known issues.
+The Rust Connector is still under rapid development and is not guaranteed to be backward compatible before 1.0. We recommend using TDengine version 2.4 or higher to avoid known issues.
 
 ## Installation
 
@@ -206,7 +206,7 @@ let conn: Taos = cfg.connect();
 
 ### Connection pooling
 
-In complex applications, recommand to enable connection pool. Connection pool for [libtaos] is implemented using [r2d2].
+In complex applications, we recommend enabling connection pools. Connection pool for [libtaos] is implemented using [r2d2].
 
 As follows, a connection pool with default parameters can be generated.
 
@@ -269,7 +269,7 @@ The [Taos] structure is the connection manager in [libtaos] and provides two mai
 
 Note that Rust asynchronous functions and an asynchronous runtime are required.
 
-[Taos] provides partial Rust methodization of SQL to reduce the frequency of `format!` code blocks.
+[Taos] provides a few Rust methods that encapsulate SQL to reduce the frequency of `format!` code blocks.
 
 - `.describe(table: &str)`: Executes `DESCRIBE` and returns a Rust data structure.
 - `.create_database(database: &str)`: Executes the `CREATE DATABASE` statement.
@@ -279,7 +279,7 @@ In addition, this structure is also the entry point for [Parameter Binding](#Par
 
 ### Bind Interface
 
-Similar to the C interface, Rust provides the bind interface's wraping. First, create a bind object [Stmt] for a SQL command from the [Taos] object.
+Similar to the C interface, Rust provides the bind interface's wrapping. First, create a bind object [Stmt] for a SQL command from the [Taos] object.
 
 ```rust
 let mut stmt: Stmt = taos.stmt("insert into ? values(? ,?)") ? ;

source/libs/executor/inc/executorimpl.h

@@ -160,7 +160,7 @@ struct SOperatorInfo;
 //struct SOptrBasicInfo;
 
 typedef int32_t (*__optr_encode_fn_t)(struct SOperatorInfo* pOperator, char** result, int32_t* length);
-typedef int32_t (*__optr_decode_fn_t)(struct SOperatorInfo* pOperator, char* result, int32_t length);
+typedef int32_t (*__optr_decode_fn_t)(struct SOperatorInfo* pOperator, char* result);
 
 typedef int32_t (*__optr_open_fn_t)(struct SOperatorInfo* pOptr);
 typedef SSDataBlock* (*__optr_fn_t)(struct SOperatorInfo* pOptr);
@@ -821,7 +821,7 @@ int32_t createExecTaskInfoImpl(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, SRead
 int32_t getOperatorExplainExecInfo(SOperatorInfo* operatorInfo, SExplainExecInfo** pRes, int32_t* capacity,
                                    int32_t* resNum);
 
-int32_t aggDecodeResultRow(SOperatorInfo* pOperator, char* result, int32_t length);
+int32_t aggDecodeResultRow(SOperatorInfo* pOperator, char* result);
 int32_t aggEncodeResultRow(SOperatorInfo* pOperator, char** result, int32_t* length);
 
 STimeWindow getActiveTimeWindow(SDiskbasedBuf* pBuf, SResultRowInfo* pResultRowInfo, int64_t ts,

source/libs/executor/src/executorimpl.c

@@ -3448,14 +3448,14 @@ static int32_t doOpenAggregateOptr(SOperatorInfo* pOperator) {
     }
 
 #if 0  // test for encode/decode result info
-    if(pOperator->encodeResultRow){
+    if(pOperator->fpSet.encodeResultRow){
       char *result = NULL;
       int32_t length = 0;
-      SAggSupporter   *pSup = &pAggInfo->aggSup;
-      pOperator->encodeResultRow(pOperator, pSup, pInfo, &result, &length);
+      pOperator->fpSet.encodeResultRow(pOperator, &result, &length);
+      SAggSupporter* pSup = &pAggInfo->aggSup;
       taosHashClear(pSup->pResultRowHashTable);
       pInfo->resultRowInfo.size = 0;
-      pOperator->decodeResultRow(pOperator, pSup, pInfo, result, length);
+      pOperator->fpSet.decodeResultRow(pOperator, result);
       if(result){
         taosMemoryFree(result);
       }
@@ -3567,17 +3567,20 @@ int32_t aggEncodeResultRow(SOperatorInfo* pOperator, char** result, int32_t* len
   return TDB_CODE_SUCCESS;
 }
 
-int32_t aggDecodeResultRow(SOperatorInfo* pOperator, char* result, int32_t length) {
-  if(result == NULL || length <= 0){
+int32_t aggDecodeResultRow(SOperatorInfo* pOperator, char* result) {
+  if(result == NULL){
     return TSDB_CODE_TSC_INVALID_INPUT;
   }
   SOptrBasicInfo* pInfo = (SOptrBasicInfo*)(pOperator->info);
   SAggSupporter* pSup = (SAggSupporter*)POINTER_SHIFT(pOperator->info, sizeof(SOptrBasicInfo));
 
   //  int32_t size = taosHashGetSize(pSup->pResultRowHashTable);
-  int32_t count = *(int32_t*)(result);
-
+  int32_t length = *(int32_t*)(result);
   int32_t offset = sizeof(int32_t);
+
+  int32_t count = *(int32_t*)(result + offset);
+  offset += sizeof(int32_t);
+
   while (count-- > 0 && length > offset) {
     int32_t keyLen = *(int32_t*)(result + offset);
     offset += sizeof(int32_t);
@@ -5048,17 +5051,19 @@ int32_t encodeOperator(SOperatorInfo* ops, char** result, int32_t *length){
 int32_t decodeOperator(SOperatorInfo* ops, char* result, int32_t length){
   int32_t code = TDB_CODE_SUCCESS;
   if(ops->fpSet.decodeResultRow){
-    if(result == NULL || length <= 0){
+    if(result == NULL){
       return TSDB_CODE_TSC_INVALID_INPUT;
     }
-    char* data = result + 2 * sizeof(int32_t);
-    int32_t dataLength = *(int32_t*)(result + sizeof(int32_t));
-    code = ops->fpSet.decodeResultRow(ops, data, dataLength - sizeof(int32_t));
+    ASSERT(length == *(int32_t*)result);
+    char* data = result + sizeof(int32_t);
+    code = ops->fpSet.decodeResultRow(ops, data);
     if(code != TDB_CODE_SUCCESS){
       return code;
     }
 
     int32_t totalLength = *(int32_t*)result;
+    int32_t dataLength = *(int32_t*)data;
+
     if(totalLength == dataLength + sizeof(int32_t)) { // the last data
       result = NULL;
       length = 0;

source/libs/executor/src/groupoperator.c

@@ -318,7 +318,20 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator) {
   //    updateNumOfRowsInResultRows(pInfo->binfo.pCtx, pOperator->numOfExprs, &pInfo->binfo.resultRowInfo,
   //    pInfo->binfo.rowCellInfoOffset);
   //  }
-
+#if 0
+  if(pOperator->fpSet.encodeResultRow){
+    char *result = NULL;
+    int32_t length = 0;
+    pOperator->fpSet.encodeResultRow(pOperator, &result, &length);
+    SAggSupporter* pSup = &pInfo->aggSup;
+    taosHashClear(pSup->pResultRowHashTable);
+    pInfo->binfo.resultRowInfo.size = 0;
+    pOperator->fpSet.decodeResultRow(pOperator, result);
+    if(result){
+      taosMemoryFree(result);
+    }
+  }
+#endif
   blockDataEnsureCapacity(pRes, pOperator->resultInfo.capacity);
   initGroupedResultInfo(&pInfo->groupResInfo, pInfo->aggSup.pResultRowHashTable, 0);
 

source/libs/executor/src/timewindowoperator.c

@@ -880,14 +880,14 @@ static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) {
     hashIntervalAgg(pOperator, &pInfo->binfo.resultRowInfo, pBlock, pBlock->info.groupId, NULL);
 
 #if 0  // test for encode/decode result info
-    if(pOperator->encodeResultRow){
+    if(pOperator->fpSet.encodeResultRow){
       char *result = NULL;
       int32_t length = 0;
       SAggSupporter   *pSup = &pInfo->aggSup;
-      pOperator->encodeResultRow(pOperator, pSup, &pInfo->binfo, &result, &length);
+      pOperator->fpSet.encodeResultRow(pOperator, &result, &length);
       taosHashClear(pSup->pResultRowHashTable);
       pInfo->binfo.resultRowInfo.size = 0;
-      pOperator->decodeResultRow(pOperator, pSup, &pInfo->binfo, result, length);
+      pOperator->fpSet.decodeResultRow(pOperator, result);
       if(result){
         taosMemoryFree(result);
       }