resolve conflict: Merge remote-tracking branch 'origin/main' into fix-thread-leakings

Author: dantengsky

Cargo.lock

@@ -1,15 +1,24 @@
 ---
 title: Arithmetic Operators
-title_includes: plus, minus, multiply, div, divide, mod, caret, modulo, negate, +, -, /, %, *, ^ 
+title_includes: plus, minus, multiply, div, divide, mod, caret, modulo, negate, +, -, /, %, *, ^, |/, ||/, @, &, |, #, ~, <<, >>
 ---
 
-| Operator      | Description                                           | Example   | Result |
-|---------------|-------------------------------------------------------|-----------|--------|
-| **+ (unary)** | Returns `a`                                           | **+5**    | 5      |
-| **+**         | Adds two numeric expressions                          | **4 + 1** | 5      |
-| **- (unary)** | Negates the numeric expression                        | **-5**    | -5     |
-| **-**         | Subtract two numeric expressions                      | **4 - 1** | 3      |
-| __*__         | Multiplies two numeric expressions                    | **4 * 1** | 4      |
-| **/**         | Divides one numeric expression (`a`) by another (`b`) | **4 / 2** | 2      |
-| **%**         | Computes the modulo of numeric expression             | **4 % 2** | 0      |
-| **^**         | Computes the exponentiation of numeric expression     | **4 ^ 2** | 16     |
+| Operator              | Description                                            | Example                    | Result |
+|-----------------------|--------------------------------------------------------|----------------------------|--------|
+| **+ (unary)**         | Returns `a`                                            | **+5**                     | 5      |
+| **+**                 | Adds two numeric expressions                           | **4 + 1**                  | 5      |
+| **- (unary)**         | Negates the numeric expression                         | **-5**                     | -5     |
+| **-**                 | Subtract two numeric expressions                       | **4 - 1**                  | 3      |
+| __*__                 | Multiplies two numeric expressions                     | **4 * 1**                  | 4      |
+| **/**                 | Divides one numeric expression (`a`) by another (`b`)  | **4 / 2**                  | 2      |
+| **%**                 | Computes the modulo of numeric expression              | **4 % 2**                  | 0      |
+| **^**                 | Computes the exponentiation of numeric expression      | **4 ^ 2**                  | 16     |
+| **&verbar;/**         | Computes the square root of numeric expression         | **&verbar;/ 25.0**         | 5      |
+| **&verbar;&verbar;/** | Computes the cube root of numeric expression           | **&verbar;&verbar;/ 27.0** | 3      |
+| **@**                 | Computes the abs of numeric expression                 | **@ -5.0**                 | 5      |
+| **&**                 | Computes the bitwise and of numeric expression         | **91 & 15**                | 11     |
+| **&verbar;**          | Computes the bitwise or of numeric expression          | **32 &verbar; 3**          | 35     |
+| **#**                 | Computes the bitwise xor of numeric expression         | **17 # 5**                 | 20     |
+| **~**                 | Computes the bitwise not of numeric expression         | **~ 1**                    | ~2     |
+| **<<**                | Computes the bitwise shift left of numeric expression  | **1 << 4**                 | 16     |
+| **>>**                | Computes the bitwise shift right of numeric expression | **8 >> 2**                 | 2      |

docs/doc/15-sql-functions/01-arithmetics-operators/index.md

@@ -35,5 +35,7 @@ The table below shows the available numeric functions.
 | **SIGN(x)**        | Returns the sign of the argument as -1, 0, or 1, depending on whether x is negative, zero, or positive or NULL if the argument was NULL.                                                                                                                                                                                                                       | **SIGN(0)**            | 0                   |
 | **SIN(x)**         | Returns the sine of x, where x is given in radians.                                                                                                                                                                                                                                                                                                            | **SIN(90)**            | 0.8939966636005579  |
 | **SQRT(x)**        | Returns the square root of a nonnegative number x. Return Nan for negative input.                                                                                                                                                                                                                                                                              | **SQRT(4)**            | 2.0                 |
+| **CBRT(x)**        | Returns the cube root of a nonnegative number x.                                                                                                                                                                                                                                                                                                               | **CURT(27)**           | 3.0                 |
 | **TAN(x)**         | Returns the tangent of x, where x is given in radians.                                                                                                                                                                                                                                                                                                         | **TAN(90)**            | -1.995200412208242  |
-| **TRUNCATE(x, d)** | Returns the number x, truncated to d decimal places. If d is 0, the result has no decimal point or fractional part. d can be negative to cause d digits left of the decimal point of the value X to become zero. The maximum absolute value for d is 30; any digits in excess of 30 (or -30) are truncated.                                                    | **TRUNCATE(1.223, 1)** | 1.2                 |
+| **TRUNCATE(x, d)** | Returns the number x, truncated to d decimal places. If d is 0, the result has no decimal point or fractional part. d can be negative to cause d digits left of the decimal point of the value X to become zero. The maximum absolute value for d is 30; any digits in excess of 30 (or -30) are truncated.                                                    | **TRUNCATE(1.223, 1)** | 1.2                 |
+| **FACTORIAL(x)**   | Returns the factorial logarithm of x. If x is less than or equal to 0, the function returns 0.                                                                                                                                                                                                                                                                 | **FACTORIAL(5)**       | 120                 |

docs/doc/15-sql-functions/20-numeric-functions/index.md

@@ -1,39 +1,105 @@
 ---
-title: Getting and Building Databend From Source
-sidebar_label: Building From Source
+title: Building Databend
+sidebar_label: Building Databend
 description:
   Getting and building Databend from Source
 ---
 
-:::note
-
-Note that at least 16GB of RAM is required to build from source and run tests.
+As an open-source platform, Databend provides the flexibility for users to modify, distribute and enhance the software according to their specific needs. Additionally, users have the freedom to build Databend from the source code, allowing them to fully understand how the software works and potentially contribute to its development.
 
+:::tip
+Databend offers a Docker image that includes all the necessary tools for development, but it's currently only available for the amd64 architecture. To use it, ensure that Docker is installed and running, and then run `INTERACTIVE=true scripts/setup/run_build_tool.sh`. This will launch an environment for building and testing, and the `INTERACTIVE=true` flag enables interactive mode.
 :::
 
-### Install prerequisites
+## Prerequisites
+
+Before you build Databend, make sure the following requirements have been met:
+
+- At least 16 GB of RAM will be required to build Databend from the source code.
+- You have installed the following required tools:
+  - Git
+  - cmake
+  - [rustup](https://rustup.rs/)
+
+## Building Databend
 
-Databend is written in Rust, to build Databend from scratch you will need to install the following tools:
-* **Git, cmake**
-* **Rust** Install with [rustup](https://rustup.rs/)
+Follow the steps below to build Databend:
+
+1. Download the source code.
+
+```shell
+git clone https://github.com/datafuselabs/databend.git
+```
 
-### Get the Databend code
+2. Install dependencies and compile the source code.
 
 ```shell
-git clone https://github.com/datafuselabs/databend
 cd databend
+make setup -d
+export PATH=$PATH:~/.cargo/bin
 ```
-### Run make
+
+3. Build Databend.
+
+  - To build Databend with debug information for debugging purposes, run `make build`. The resulting files will be located in the "target/debug/" directory.
+
+```shell
+make build 
+```
+  - To build Databend for production, optimized for your local CPU, run `make build-release`. The resulting files will be located in the "target/release/" directory.
 
 ```shell
 make build-release
 ```
 
-`databend-query` and `databend-meta` will be placed in the `target/release` directory.
+## Start Databend for Debugging
+
+```shell
+# 1. Start databend-meta first:
+nohup target/debug/databend-meta --single --log-level=ERROR & 
+
+# 2. Start databend-query and connect it to databend-meta:
+nohup target/debug/databend-query -c scripts/ci/deploy/config/databend-query-node-1.toml &
+```
+:::tip
+To stop databend-meta and databend-query, run the following commands:
+
+```shell
+killall -9 databend-meta
+killall -9 databend-query
+```
+:::
+
+## Common Errors
+
+1. protoc failed: Unknown flag: --experimental_allow_proto3_optional\n
+
+```bash
+  --- stderr
+  Error: Custom { kind: Other, error: "protoc failed: Unknown flag: --experimental_allow_proto3_optional\n" }
+warning: build failed, waiting for other jobs to finish...
+All done...
+# Reduce binary size by compressing binaries.
+objcopy --compress-debug-sections=zlib-gnu /home/aucker/mldb/databend/target/release/databend-query
+objcopy: '/home/aucker/mldb/databend/target/release/databend-query': No such file
+make: *** [Makefile:51: build-release] Error 1
+```
 
+The error message indicates that there is an issue with building Databend due to an unknown flag (--experimental_allow_proto3_optional) being used with protoc, which is a protocol buffer compiler. This flag is only available in protoc version 3.12 or higher, and the current version being used does not support it.
+
+The recommended solution is to upgrade to a version of protoc that supports that flag. You can do this by downloading the latest version of protoc from the official release page (https://github.com/protocolbuffers/protobuf/releases) and installing it on your system.
+
+```bash
+PB_REL="https://github.com/protocolbuffers/protobuf/releases"
+curl -LO $PB_REL/download/v3.15.8/protoc-3.15.8-linux-x86_64.zip
+unzip protoc-3.15.8-linux-x86_64.zip
+$sudo cp bin/protoc /usr/bin/
+$protoc --version 
+libprotoc 3.15.6
+```
 
-### Build With Docker Image
+2. Coundn't connect to databend-meta in a forked Databend project.
 
-We provide a docker image with full development requirements, currently only on amd64.
+This issue is likely caused by a version check implemented in Databend-meta that is not being met by the forked project. 
 
-Making sure docker is installed and running, just run `INTERACTIVE=true scripts/setup/run_build_tool.sh` to get into the build/test environment.
+One possible solution is to fetch the latest tags from the official Databend repository using the command `git fetch https://github.com/datafuselabs/databend.git --tags`. This should ensure that the project is using the latest version of Databend-meta and will pass the version check.

docs/doc/90-contributing/02-building-from-source.md

@@ -44,7 +44,7 @@ pub async fn query_local(conf: &InnerConfig) -> Result<()> {
             .await?;
         let ctx = session.create_query_context().await?;
         let mut planner = Planner::new(ctx.clone());
-        let (plan, _, _) = planner.plan_sql(&sql).await?;
+        let (plan, _) = planner.plan_sql(&sql).await?;
         let interpreter = InterpreterFactory::get(ctx.clone(), &plan).await?;
         let stream = interpreter.execute(ctx.clone()).await?;
         let blocks = stream.map(|v| v).collect::<Vec<_>>().await;

src/binaries/query/local.rs

@@ -18,7 +18,6 @@ extern crate criterion;
 use common_ast::parser::parse_expr;
 use common_ast::parser::parse_sql;
 use common_ast::parser::tokenize_sql;
-use common_ast::Backtrace;
 use common_ast::Dialect;
 use criterion::black_box;
 use criterion::Criterion;
@@ -31,35 +30,31 @@ fn bench(c: &mut Criterion) {
         b.iter(|| {
             let case = r#"explain SELECT SUM(count) FROM (SELECT ((((((((((((true)and(true)))or((('614')like('998831')))))or(false)))and((true IN (true, true, (-1014651046 NOT BETWEEN -1098711288 AND -1158262473))))))or((('780820706')=('')))) IS NOT NULL AND ((((((((((true)AND(true)))or((('614')like('998831')))))or(false)))and((true IN (true, true, (-1014651046 NOT BETWEEN -1098711288 AND -1158262473))))))OR((('780820706')=(''))))) ::INT64)as count FROM t0) as res;"#;
             let tokens = tokenize_sql(case).unwrap();
-            let backtrace = Backtrace::new();
-            let (stmt, _) = parse_sql(&tokens, Dialect::PostgreSQL, &backtrace).unwrap();
+            let (stmt, _) = parse_sql(&tokens, Dialect::PostgreSQL).unwrap();
             black_box(stmt);
         })
     });
     group.bench_function("large_query", |b| {
         b.iter(|| {
             let case = r#"SELECT SUM(count) FROM (SELECT ((((((((((((true)and(true)))or((('614')like('998831')))))or(false)))and((true IN (true, true, (-1014651046 NOT BETWEEN -1098711288 AND -1158262473))))))or((('780820706')=('')))) IS NOT NULL AND ((((((((((true)AND(true)))or((('614')like('998831')))))or(false)))and((true IN (true, true, (-1014651046 NOT BETWEEN -1098711288 AND -1158262473))))))OR((('780820706')=(''))))) ::INT64)as count FROM t0) as res;"#;
             let tokens = tokenize_sql(case).unwrap();
-            let backtrace = Backtrace::new();
-            let (stmt, _) = parse_sql(&tokens, Dialect::PostgreSQL, &backtrace).unwrap();
+            let (stmt, _) = parse_sql(&tokens, Dialect::PostgreSQL).unwrap();
             black_box(stmt);
         })
     });
     group.bench_function("wide_expr", |b| {
         b.iter(|| {
             let case = r#"a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a AND a"#;
             let tokens = tokenize_sql(case).unwrap();
-            let backtrace = Backtrace::new();
-            let expr = parse_expr(&tokens, Dialect::PostgreSQL, &backtrace).unwrap();
+            let expr = parse_expr(&tokens, Dialect::PostgreSQL).unwrap();
             black_box(expr);
         })
     });
     group.bench_function("deep_expr", |b| {
         b.iter(|| {
             let case = r#"((((((((((((((((((((((((((((((1))))))))))))))))))))))))))))))"#;
             let tokens = tokenize_sql(case).unwrap();
-            let backtrace = Backtrace::new();
-            let expr = parse_expr(&tokens, Dialect::PostgreSQL, &backtrace).unwrap();
+            let expr = parse_expr(&tokens, Dialect::PostgreSQL).unwrap();
             black_box(expr);
         })
     });