Elgato_dark/TDengine
1
0
Fork 0
mirror of https://github.com/taosdata/TDengine synced 2026-05-24 10:09:01 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

sync: backport fixes from internal monorepo (main) #35358
Some checks failed
TDengine Release Build / Run on macos-14 (push) Has been cancelled
Details
TDengine Release Build / Run on ubuntu-22.04 (push) Has been cancelled
Details

Browse source
This commit is contained in:
Simon Guan 2026-05-23 16:46:14 +08:00 committed by GitHub
commit 2bfd5023de
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
270 changed files with 14052 additions and 3471 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

74
CMakeLists.txt
View file

@ -14,62 +14,60 @@ if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.24")
cmake_policy(SET CMP0135 NEW)
endif()
if(NOT DEFINED TD_ENTERPRISE_DIR)
set(TD_COMMUNITY_DIR ${CMAKE_CURRENT_SOURCE_DIR})
set(TD_SOURCE_DIR ${TD_COMMUNITY_DIR})
set(TD_SUPPORT_DIR "${TD_SOURCE_DIR}/cmake")
set(TD_CONTRIB_DIR "${TD_SOURCE_DIR}/contrib")
if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
set(TD_COMMUNITY_STANDALONE TRUE)
else()
set(TD_COMMUNITY_STANDALONE FALSE)
endif()
message(STATUS "Community directory: " ${TD_COMMUNITY_DIR})
message(STATUS "Source directory: " ${TD_SOURCE_DIR})
message(STATUS "Support directory: " ${TD_SUPPORT_DIR})
message(STATUS "Contrib directory: " ${TD_CONTRIB_DIR})
set(TD_COMMUNITY_DIR ${CMAKE_CURRENT_SOURCE_DIR})
set(TD_SOURCE_DIR ${TD_COMMUNITY_DIR})
set(TD_SUPPORT_DIR "${TD_SOURCE_DIR}/cmake")
set(TD_CONTRIB_DIR "${TD_SOURCE_DIR}/contrib")
include(cmake/preinclude.cmake)
include(cmake/platform.cmake)
include(cmake/options.cmake)
include(cmake/check_env.cmake)
include(cmake/define.cmake)
include(cmake/version.cmake)
message(STATUS "=== TDengine Community build configuration ===")
message(STATUS "Standalone: " ${TD_COMMUNITY_STANDALONE})
message(STATUS "Community directory: " ${TD_COMMUNITY_DIR})
message(STATUS "Source directory: " ${TD_SOURCE_DIR})
message(STATUS "Support directory: " ${TD_SUPPORT_DIR})
message(STATUS "Contrib directory: " ${TD_CONTRIB_DIR})
# Support for Conan package manager
option(USE_CONAN "Use Conan for dependency management" OFF)
if(USE_CONAN)
message(STATUS "Using Conan for dependency management")
include(cmake/conan.cmake)
else()
message(STATUS "Using ExternalProject for dependency management")
include(cmake/external.cmake)
endif()
include(cmake/preinclude.cmake)
include(cmake/platform.cmake)
include(cmake/enterprise.cmake)
include(cmake/options.cmake)
include(cmake/check_env.cmake)
include(cmake/define.cmake)
include(cmake/version.cmake)
if(USE_CONAN)
message(STATUS "Using Conan for dependency management")
include(cmake/conan.cmake)
else()
message(STATUS "Using ExternalProject for dependency management")
include(cmake/external.cmake)
endif()
set_property(GLOBAL PROPERTY GLOBAL_DEPENDS_NO_CYCLES OFF)
add_subdirectory(contrib)
if(${BUILD_TEST})
if(BUILD_TEST)
include(CTest)
enable_testing()
endif(${BUILD_TEST})
endif()
add_library(api INTERFACE)
target_include_directories(api INTERFACE "include/client")
add_subdirectory(contrib/TSZ)
add_subdirectory(contrib/libaes)
add_subdirectory(contrib/libmqtt)
add_subdirectory(contrib)
add_subdirectory(source)
add_subdirectory(tools)
add_subdirectory(utils)
add_subdirectory(tests)
add_subdirectory(examples/c)
if(TD_ENTERPRISE)
add_subdirectory("${TD_ENTERPRISE_DIR}" "${CMAKE_BINARY_DIR}/enterprise")
endif()
include(cmake/install.cmake)
include(CPack)
message(STATUS "TAOSADAPTER_BUILD_OPTIONS:${TAOSADAPTER_BUILD_OPTIONS}")
message(STATUS "TAOSADAPTER_GIT_TAG:${TAOSADAPTER_GIT_TAG}")
message(STATUS "TAOSADAPTER_GIT_TAG_NAME:${TAOSADAPTER_GIT_TAG_NAME}")
message(STATUS "TAOSADAPTER_GIT_TAG_SHALLOW:${TAOSADAPTER_GIT_TAG_SHALLOW}")
message(STATUS "TAOSWS_GIT_TAG_NAME:${TAOSWS_GIT_TAG_NAME}")

8
README-CN.md
View file

@ -167,21 +167,19 @@ cmake .. -DBUILD_TOOLS=true -DBUILD_CONTRIB=true
make
```
如果你想要编译 taosAdapter，需要添加 `-DBUILD_HTTP=false` 选项。
如果你想要编译 taosKeeper，需要添加 `-DBUILD_KEEPER=true` 选项。
可以使用 Jemalloc 作为内存分配器，而不是使用 glibc：
```bash
cmake .. -DJEMALLOC_ENABLED=ON
cmake .. -DBUILD_JEMALLOC=ON
```
TDengine 构建脚本可以自动检测 x86、x86-64、arm64 平台上主机的体系结构。
您也可以通过 CPUTYPE 选项手动指定架构：
您也可以通过 BUILD_VER_CPUTYPE 选项手动指定架构：
```bash
cmake .. -DCPUTYPE=aarch64 && cmake --build .
cmake .. -DBUILD_VER_CPUTYPE=aarch64 && cmake --build .
```
</details>

481
README.md
View file

@ -11,7 +11,7 @@
[![TDengine Release Build](https://github.com/taosdata/TDengine/actions/workflows/tdengine-release-build.yml/badge.svg)](https://github.com/taosdata/TDengine/actions/workflows/tdengine-release-build.yml)
[![Coverage Status](https://coveralls.io/repos/github/taosdata/TDengine/badge.svg?branch=3.0)](https://coveralls.io/github/taosdata/TDengine?branch=3.0)
[![GitHub commit activity](https://img.shields.io/github/commit-activity/m/taosdata/tdengine)](https://github.com/feici02/TDengine/commits/main/)
[![GitHub commit activity](https://img.shields.io/github/commit-activity/m/taosdata/tdengine)](https://github.com/taosdata/TDengine/commits/main/)
<br />
[![GitHub Release](https://img.shields.io/github/v/release/taosdata/tdengine)](https://github.com/taosdata/TDengine/releases)
[![GitHub License](https://img.shields.io/github/license/taosdata/tdengine)](https://github.com/taosdata/TDengine/blob/main/LICENSE)
@ -24,45 +24,11 @@
[![StackOverflow](https://img.shields.io/badge/Ask_StackOverflow--white?logo=stackoverflow&style=social&logoColor=orange)](https://stackoverflow.com/questions/tagged/tdengine)
[![DeepWiki](https://img.shields.io/badge/Ask%20DeepWiki-white.svg?logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACwAAAAyCAYAAAAnWDnqAAAAAXNSR0IArs4c6QAAA05JREFUaEPtmUtyEzEQhtWTQyQLHNak2AB7ZnyXZMEjXMGeK/AIi+QuHrMnbChYY7MIh8g01fJoopFb0uhhEqqcbWTp06/uv1saEDv4O3n3dV60RfP947Mm9/SQc0ICFQgzfc4CYZoTPAswgSJCCUJUnAAoRHOAUOcATwbmVLWdGoH//PB8mnKqScAhsD0kYP3j/Yt5LPQe2KvcXmGvRHcDnpxfL2zOYJ1mFwrryWTz0advv1Ut4CJgf5uhDuDj5eUcAUoahrdY/56ebRWeraTjMt/00Sh3UDtjgHtQNHwcRGOC98BJEAEymycmYcWwOprTgcB6VZ5JK5TAJ+fXGLBm3FDAmn6oPPjR4rKCAoJCal2eAiQp2x0vxTPB3ALO2CRkwmDy5WohzBDwSEFKRwPbknEggCPB/imwrycgxX2NzoMCHhPkDwqYMr9tRcP5qNrMZHkVnOjRMWwLCcr8ohBVb1OMjxLwGCvjTikrsBOiA6fNyCrm8V1rP93iVPpwaE+gO0SsWmPiXB+jikdf6SizrT5qKasx5j8ABbHpFTx+vFXp9EnYQmLx02h1QTTrl6eDqxLnGjporxl3NL3agEvXdT0WmEost648sQOYAeJS9Q7bfUVoMGnjo4AZdUMQku50McDcMWcBPvr0SzbTAFDfvJqwLzgxwATnCgnp4wDl6Aa+Ax283gghmj+vj7feE2KBBRMW3FzOpLOADl0Isb5587h/U4gGvkt5v60Z1VLG8BhYjbzRwyQZemwAd6cCR5/XFWLYZRIMpX39AR0tjaGGiGzLVyhse5C9RKC6ai42ppWPKiBagOvaYk8lO7DajerabOZP46Lby5wKjw1HCRx7p9sVMOWGzb/vA1hwiWc6jm3MvQDTogQkiqIhJV0nBQBTU+3okKCFDy9WwferkHjtxib7t3xIUQtHxnIwtx4mpg26/HfwVNVDb4oI9RHmx5WGelRVlrtiw43zboCLaxv46AZeB3IlTkwouebTr1y2NjSpHz68WNFjHvupy3q8TFn3Hos2IAk4Ju5dCo8B3wP7VPr/FGaKiG+T+v+TQqIrOqMTL1VdWV1DdmcbO8KXBz6esmYWYKPwDL5b5FA1a0hwapHiom0r/cKaoqr+27/XcrS5UwSMbQAAAABJRU5ErkJggg==)](https://deepwiki.com/taosdata/TDengine)
</div>
<div align="center">
English | [简体中文](README-CN.md) | [TDengine Cloud](https://cloud.tdengine.com) | [Documentation](https://docs.tdengine.com) | [Learn more about TSDB](https://tdengine.com/time-series-database/)
English | [简体中文](README-CN.md) | [TDengine Cloud](https://cloud.tdengine.com) | [Learn more about TSDB](https://tdengine.com/time-series-database/)
# TDengine
<br />
</div>
# Table of Contents
- [1. Introduction](#1-introduction)
- [2. Documentation](#2-documentation)
- [3. Prerequisites](#3-prerequisites)
- [3.1 Prerequisites on Linux](#31-prerequisites-on-linux)
- [3.1.1 For Ubuntu](#311-for-ubuntu)
- [3.1.2 For CentOS](#312-for-centos)
- [3.2 Prerequisites on macOS](#32-prerequisites-on-macos)
- [3.3 Prerequisites on Windows](#33-prerequisites-on-windows)
- [3.4 Clone the repo](#34-clone-the-repo)
- [4. Building](#4-building)
- [4.1 Build on Linux](#41-build-on-linux)
- [4.2 Build on macOS](#42-build-on-macos)
- [4.3 Build on Windows](#43-build-on-windows)
- [5. Packaging](#5-packaging)
- [6. Installation](#6-installation)
- [6.1 Install on Linux](#61-install-on-linux)
- [6.2 Install on macOS](#62-install-on-macos)
- [6.3 Install on Windows](#63-install-on-windows)
- [7. Running](#7-running)
- [7.1 Run TDengine on Linux](#71-run-tdengine-on-linux)
- [7.2 Run TDengine on macOS](#72-run-tdengine-on-macos)
- [7.3 Run TDengine on Windows](#73-run-tdengine-on-windows)
- [8. Testing](#8-testing)
- [9. Releasing](#9-releasing)
- [10. Workflow](#10-workflow)
- [11. Coverage](#11-coverage)
- [12. Contributing](#12-contributing)
# 1. Introduction
## 1. Introduction
TDengine is an open source, high-performance, cloud native and AI powered [time-series database](https://tdengine.com/tsdb/) designed for Internet of Things (IoT), Connected Cars, and Industrial IoT. It enables efficient, real-time data ingestion, processing, and analysis of TB and even PB scale data per day, generated by billions of sensors and data collectors. TDengine differentiates itself from other time-series databases with the following advantages:
@ -78,271 +44,328 @@ TDengine is an open source, high-performance, cloud native and AI powered [time-
- **[Easy Data Analytics](https://tdengine.com/tdengine/time-series-data-analytics-made-easy/)**: Through super tables, storage and compute separation, data partitioning by time interval, pre-computation and AI agent, TDengine makes it easy to explore, format, and get access to data in a highly efficient way.
- **[Open Source](https://tdengine.com/tdengine/open-source-time-series-database/)**: TDengine’s core modules, including cluster feature and AI agent, are all available under open source licenses. It has gathered 23.7k stars on GitHub. There is an active developer community, and over 730k running instances worldwide.
- **[Open Source](https://tdengine.com/tdengine/open-source-time-series-database/)**: TDengine's core modules, including cluster feature and AI agent, are all available under open source licenses. It has gathered 23.7k stars on GitHub. There is an active developer community, and over 730k running instances worldwide.
For a full list of TDengine competitive advantages, please [check here](https://tdengine.com/tdengine/). The easiest way to experience TDengine is through [TDengine Cloud](https://cloud.tdengine.com). For the latest TDengine component TDgpt, please refer to [TDgpt README](./tools/tdgpt/README.md) for details.
# 2. Documentation
## 2. Documentation
For user manual, system design and architecture, please refer to [TDengine Documentation](https://docs.tdengine.com) ([TDengine 文档](https://docs.taosdata.com))
You can choose to install TDengine via [container](https://docs.tdengine.com/get-started/deploy-in-docker/), [installation package](https://docs.tdengine.com/get-started/deploy-from-package/), [Kubernetes](https://docs.tdengine.com/operations-and-maintenance/deploy-your-cluster/#kubernetes-deployment) or try [fully managed service](https://cloud.tdengine.com/) without installation. This quick guide is for developers who want to contribute, build, release and test TDengine by themselves.
For contributing/building/testing TDengine Connectors, please check the following repositories: [JDBC Connector](https://github.com/taosdata/taos-connector-jdbc), [Go Connector](https://github.com/taosdata/driver-go), [Python Connector](https://github.com/taosdata/taos-connector-python), [Node.js Connector](https://github.com/taosdata/taos-connector-node), [C# Connector](https://github.com/taosdata/taos-connector-dotnet), [Rust Connector](https://github.com/taosdata/taos-connector-rust).
## Table of Contents
# 3. Prerequisites
- [1. Introduction](#1-introduction)
- [2. Documentation](#2-documentation)
- [3. Prerequisites](#3-prerequisites)
- [3.1 System Requirements](#31-system-requirements)
- [3.2 Installing Build Tools](#32-installing-build-tools)
- [3.3 Optional Tools](#33-optional-tools)
- [4. Building](#4-building)
- [4.1 Quick Start](#41-quick-start)
- [4.2 Build Options](#42-build-options)
- [4.3 Build Output](#43-build-output)
- [5. Testing](#5-testing)
- [5.1 Unit Tests](#51-unit-tests)
- [5.2 Integration Tests](#52-integration-tests)
- [6. Packaging](#6-packaging)
- [6.1 Package the Community Tarballs](#61-package-the-community-tarballs)
- [7. Installing from Package](#7-installing-from-package)
- [8. Running](#8-running)
- [9. Workflow](#9-workflow)
- [10. Coverage](#10-coverage)
- [11. Contributing](#11-contributing)
- [12. License](#12-license)
At the moment, TDengine server supports running on Linux/MacOS systems. Any application can also choose the RESTful interface provided by taosAdapter to connect the taosd service. TDengine supports X64/ARM64 CPU, and it will support MIPS64, Alpha64, ARM32, RISC-V and other CPU architectures in the future. Right now we don't support build with cross-compiling environment.
## 3. Prerequisites
Starting from version 3.1.0.0, TDengine supports the Windows system exclusively in its TSDB-Enterprise edition.
### 3.1 System Requirements
If you want to compile taosAdapter or taosKeeper, you need to install Go 1.23 or above.
- **Operating systems:** Linux (Ubuntu 18.04+, CentOS 7+), macOS 10.15+, Windows (limited; open-source builds are primarily Linux/macOS)
- **CPU:** x86_64 or ARM64
- **Memory:** 4 GB RAM or more recommended
- **Disk:** 2 GB free space or more recommended
- **Primary build platform:** Linux
## 3.1 Prerequisites on Linux
TDengine is built and tested primarily on Linux. macOS builds are supported for local development. Windows support in the open-source tree is limited, so Linux should be your default choice for reproducible builds.
<details>
### 3.2 Installing Build Tools
<summary>Install required tools on Linux</summary>
### 3.1.1 For Ubuntu
Verified on Ubuntu 18.04, 20.04, 22.04.
**Ubuntu/Debian:**
```bash
sudo apt-get update
sudo apt-get install -y gcc cmake build-essential git libjansson-dev \
libsnappy-dev liblzma-dev zlib1g-dev pkg-config libtool autoconf automake groff
sudo apt-get install -y build-essential cmake git
```
### 3.1.2 For CentOS
Verified on CentOS 8.
**CentOS/RHEL:**
```bash
sudo yum update
yum install -y epel-release gcc gcc-c++ make cmake git perl dnf-plugins-core autoconf automake libtool groff
yum config-manager --set-enabled powertools
yum install -y zlib-static xz-devel snappy-devel jansson-devel pkgconfig libatomic-static libstdc++-static
sudo yum groupinstall -y "Development Tools"
sudo yum install -y cmake3 git
```
</details>
Note: CMake >= 3.21 is required for external builds. If your distro provides an older version, install a newer release from <https://cmake.org/download/>.
## 3.2 Prerequisites on macOS
You may also need these tools depending on what you build:
<details>
- **Python 3** for the test framework in `tests/`
- **Go 1.23+** if you want to build components such as taosAdapter or taosKeeper
<summary>Install required tools on macOS</summary>
### 3.3 Optional Tools
Please install the dependencies with [brew](https://brew.sh/).
- **ccache** — speeds up rebuilds: `sudo apt install ccache`
- **Conan 2.x** — required only for the `taos-gen` component: `pip3 install conan`
```bash
brew install argp-standalone gflags pkgconfig
```
## 4. Building
</details>
## 3.3 Prerequisites on Windows
Not available for TDengine TSDB-OSS.
## 3.4 Clone the repo
Clone the repository to the target machine:
### 4.1 Quick Start
```bash
git clone https://github.com/taosdata/TDengine.git
cd TDengine
mkdir debug && cd debug
cmake .. -DBUILD_CONTRIB=ON # First build: -DBUILD_CONTRIB=ON is REQUIRED
make -j$(nproc)
```
</details>
> **Important**
> The first source build must use `-DBUILD_CONTRIB=ON`. This downloads and builds external dependencies such as xxhash, zstd, and lz4 into `.externals/`. Subsequent builds can usually omit this flag and reuse the cached artifacts automatically.
# 4. Building
TDengine provide a few useful tools such as taosBenchmark (was named taosdemo) and taosdump. They were part of TDengine. By default, TDengine compiling does not include taosTools. You can use `cmake .. -DBUILD_TOOLS=true` to make them be compiled with TDengine.
TDengine requires [GCC](https://gcc.gnu.org/) 9.3.1 or higher and [CMake](https://cmake.org/) 3.18.0 or higher for building.
## 4.1 Build on Linux
<details>
<summary>Detailed steps to build on Linux</summary>
You can run the bash script `build.sh` to build both TDengine and taosTools including taosBenchmark and taosdump as below:
Useful variants:
```bash
./build.sh
# Release build with CLI tools
cmake .. -DBUILD_CONTRIB=ON -DCMAKE_BUILD_TYPE=Release -DBUILD_TOOLS=ON
make -j$(nproc)
# macOS equivalent parallel build
cmake .. -DBUILD_CONTRIB=ON -DCMAKE_BUILD_TYPE=Release
cmake --build . --parallel "$(sysctl -n hw.ncpu)"
```
It equals to execute following commands:
### 4.2 Build Options
Defaults below are the standalone open-source defaults from `cmake/options.cmake` unless noted otherwise.
| Option | Default | Description |
|---|---:|---|
| `BUILD_CONTRIB` | `OFF` on Linux, `ON` elsewhere | Build third-party dependencies from source. **Required for the first build.** |
| `CMAKE_BUILD_TYPE` | `Debug` | Standard CMake build type (`Debug`, `Release`, `RelWithDebInfo`). |
| `BUILD_TEST` | `OFF` | Build unit tests with googletest. |
| `BUILD_TOOLS` | `OFF` | Build tools such as `taosBenchmark` and `taosdump`. |
| `BUILD_SANITIZER` | `OFF` | Enable sanitizers. |
| `BUILD_COVERAGE` | `OFF` | Enable coverage instrumentation. |
| `BUILD_JEMALLOC` | `OFF` | Enable jemalloc allocator support. |
| `BUILD_WEBSOCKET` | `OFF` | Enable WebSocket support. |
| `BUILD_ASSERT_NOT_CORE` | `OFF` | Avoid generating core files on assert. |
| `BUILD_PTHREAD_TWEAK` | `OFF` | Apply pthread tweaks for older Linux environments. |
| `BUILD_ASTRA` | `OFF` | Build for Astra platform. |
| `BUILD_ASTRA_RPC` | `OFF` | Build with Astra RPC transport. |
| `BUILD_WITH_LEMON` | `ON` | Build with lemon parser support. |
| `BUILD_WITH_UDF` | `ON` | Build with UDF support. |
| `BUILD_GEOS` | `ON` | Build with GEOS support (non-Astra). |
| `BUILD_SHARED_LIBS` | `OFF` | Build shared libraries. |
| `RUST_BINDINGS` | `ON` | Build Rust bindings. |
| `BUILD_PCRE2` | `ON` | Build with PCRE2 support. |
| `BUILD_ADDR2LINE` | `OFF` | Build addr2line helper support. |
| `BUILD_WITH_LEVELDB` | `OFF` | Enable LevelDB support. |
| `BUILD_ROCKSDB` | `OFF` on Linux, `ON` elsewhere | Build RocksDB from source. |
| `ROCKSDB_USE_DEPS` | `ON` on Linux, `OFF` elsewhere | Use prebuilt RocksDB from `deps/` instead of building it. |
| `TD_USE_ROCKSDB` | `ON` | Enable RocksDB support. |
| `BUILD_WITH_LZ4` | `ON` | Build with LZ4 support. |
| `BUILD_S3` | `ON` on Linux, then forced `OFF` for community builds | Enable S3-related build path. Community builds switch this off. |
| `BUILD_WITH_S3` | `ON` on Linux, then forced `OFF` for community builds | Build with S3 support when available. |
| `BUILD_WITH_COS` | `OFF` | Build with COS support. |
| `BUILD_WITH_LZMA2` | `ON` | Build with LZMA2 support. |
| `BUILD_WITH_ANALYSIS` | `ON` on Linux | Enable analysis-related build path. |
| `BUILD_WITH_SQLITE` | `OFF` | Build with SQLite support. |
| `BUILD_WITH_BDB` | `OFF` | Build with Berkeley DB support. |
| `BUILD_WITH_LUCENE` | `OFF` | Build with Lucene support. |
| `BUILD_WITH_NURAFT` | `OFF` | Build with NuRaft support. |
| `BUILD_WITH_UV` | `ON` | Build with libuv support. |
| `BUILD_WITH_UV_TRANS` | `ON` | Build with libuv transport support. |
| `BUILD_DEPENDENCY_TESTS` | `ON` on Linux | Build dependency tests. |
| `BUILD_DOCS` | `OFF` | Build Doxygen documentation. |
| `BUILD_WITH_INVERTEDINDEX` | `ON` | Enable inverted index support. |
| `BUILD_TAOSD_INTEGRATED` | `OFF` | Build `taosd` as an integrated library. |
| `BUILD_AS_LIB` | `OFF` | Build TDengine as a library. |
| `BUILD_RELEASE` | `OFF` | Enable release-version build path. |
| `BUILD_LIBSASL` | `OFF` | Build with libsasl2. |
| `BUILD_FLEX_DEPLOY` | `OFF` | Enable flexible deployment mode. |
| `BUILD_WITH_RAND_ERR` | `OFF` | Enable random error injection. |
| `BUILD_TSZ_ENABLED` | `ON` | Enable TSZ compression support. |
| `BUILD_USE_PUBLIC_DEPS` | `OFF` | Use public internet URLs for external dependencies instead of alternate mirrors. |
Example:
```bash
cmake .. -DBUILD_CONTRIB=ON -DCMAKE_BUILD_TYPE=Release -DBUILD_TOOLS=ON
```
### 4.3 Build Output
The default build tree under `debug/` looks like this:
- Binaries in `debug/build/bin/`
- `taosd` — TDengine server daemon
- `taos` — TDengine CLI client
- `taosBenchmark` — benchmark tool (`BUILD_TOOLS=ON`)
- `taosdump` — import/export tool (`BUILD_TOOLS=ON`)
- Libraries in `debug/build/lib/`
- `libtaos.so` on Linux (or the platform-equivalent client library)
## 5. Testing
### 5.1 Unit Tests
```bash
cd debug
cmake .. -DBUILD_CONTRIB=ON -DBUILD_TEST=ON
make -j$(nproc)
ctest --output-on-failure
```
Some individual test binaries are also emitted into `debug/build/bin/`.
### 5.2 Integration Tests
TDengine includes a Python-based test framework in `tests/`.
```bash
# Build the server and tools first
cd debug
cmake .. -DBUILD_CONTRIB=ON -DBUILD_TOOLS=ON -DBUILD_TEST=ON
make -j$(nproc)
# Start taosd with the generated test configuration
./build/bin/taosd -c test/cfg &
# Run a system test
cd ../tests/system-test
python3 test.py -f 2-query/basic.py
```
For more test details, see [`tests/README.md`](tests/README.md).
## 6. Packaging
Use `source/taos-community/packaging/pack_community_tar.sh` after a successful Linux build to assemble the open-source community tarballs.
This script packages only artifacts that are built from the `taos-community` repository itself:
- `taosd`
- `taos`
- `taosBenchmark` (`BUILD_TOOLS=ON`, when present)
- `taosdump` (`BUILD_TOOLS=ON`, when present)
- `taosudf` (when present)
- `libtaos.so`
- `libtaosnative.so`
- headers, `examples/c`, and the install scripts
It does **not** package components that live in other repositories or require separate build flows, such as `taoskeeper`, `taos-explorer`, `taosx`, connectors, or `taosinspect`.
### 6.1 Package the Community Tarballs
Build first:
```bash
mkdir debug && cd debug
cmake .. -DBUILD_TOOLS=true -DBUILD_CONTRIB=true
make
cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_CONTRIB=ON -DBUILD_TOOLS=ON
make -j$(nproc)
```
If you want to compile taosAdapter, you need to add the `-DBUILD_HTTP=false` option.
If you want to compile taosKeeper, you need to add the `-DBUILD_KEEPER=true` option.
You can use Jemalloc as memory allocator instead of glibc:
Then run the packaging script from the repository root:
```bash
cmake .. -DJEMALLOC_ENABLED=ON
cd ..
./source/taos-community/packaging/pack_community_tar.sh -c debug -n 3.3.6.0
```
TDengine build script can auto-detect the host machine's architecture on x86, x86-64, arm64 platform.
You can also specify architecture manually by CPUTYPE option:
Optional arguments:
- `-m <compatible_version>` — defaults to `3.0.0.0`
- `-V <stable|beta|preRelease>` — defaults to `stable`
Example:
```bash
cmake .. -DCPUTYPE=aarch64 && cmake --build .
./source/taos-community/packaging/pack_community_tar.sh \
-c debug \
-n 3.3.6.0 \
-m 3.0.0.0 \
-V stable
```
</details>
## 4.2 Build on macOS
<details>
<summary>Detailed steps to build on macOS</summary>
Please install XCode command line tools and cmake. Verified with XCode 11.4+ on Catalina and Big Sur.
```shell
mkdir debug && cd debug
cmake .. && cmake --build .
```
If you want to compile taosAdapter, you need to add the `-DBUILD_HTTP=false` option.
If you want to compile taosKeeper, you need to add the `-DBUILD_KEEPER=true` option.
</details>
## 4.3 Build on Windows
Not available for TDengine TSDB-OSS.
# 5. Packaging
The TDengine TSDB-OSS installer can NOT be created by this repository only, due to some component dependencies. We are still working on this improvement.
# 6. Installation
## 6.1 Install on Linux
<details>
<summary>Detailed steps to install on Linux</summary>
After building successfully, TDengine can be installed by:
Generated packages are written to:
```bash
source/taos-community/release/
```
Typical outputs:
```bash
source/taos-community/release/TDengine-server-3.3.6.0-Linux-x64.tar.gz
source/taos-community/release/TDengine-client-3.3.6.0-Linux-x64.tar.gz
```
The server and client archives use the same two-layer layout as the existing packaging flow:
- outer tarball for distribution
- inner `package.tar.gz` containing `bin/`, `cfg/`, and `inc/`
This is the standard packaging approach for repository-local OSS artifacts and should be followed consistently in future repositories as well.
## 7. Installing from Package
For an official installer package produced by `packaging/tools/makepkg.sh`:
```bash
tar -xzf TDengine-server-<version>-Linux-x86_64.tar.gz
cd TDengine-server-<version>
sudo ./install.sh
```
If you are installing directly from a local source build instead of a packaged archive, you can also run:
```bash
cd debug
sudo make install
```
Installing from source code will also configure service management for TDengine. Users can also choose to [install from packages](https://docs.tdengine.com/get-started/deploy-from-package/) for it.
</details>
## 6.2 Install on macOS
<details>
<summary>Detailed steps to install on macOS</summary>
After building successfully, TDengine can be installed by:
```bash
sudo make install
```
</details>
## 6.3 Install on Windows
Not available for TDengine TSDB-OSS.
# 7. Running
## 7.1 Run TDengine on Linux
<details>
<summary>Detailed steps to run on Linux</summary>
To start the service after installation on linux, in a terminal, use:
## 8. Running
```bash
# Start the server after installation
sudo systemctl start taosd
```
Then users can use the TDengine CLI to connect the TDengine server. In a terminal, use:
```bash
# Connect with the CLI
taos
```
If TDengine CLI connects the server successfully, welcome messages and version info are printed. Otherwise, an error message is shown.
If you don't want to run TDengine as a service, you can run it in current shell. For example, to quickly start a TDengine server after building, run the command below in terminal: (We take Linux as an example, command on Windows will be `taosd.exe`)
For a quick local run from the build tree, use:
```bash
cd debug
./build/bin/taosd -c test/cfg
```
In another terminal, use the TDengine CLI to connect the server:
Then, in another shell:
```bash
cd debug
./build/bin/taos -c test/cfg
```
Option `-c test/cfg` specifies the system configuration file directory.
## 9. Workflow
</details>
TDengine build check workflow can be found in this [GitHub Action](https://github.com/taosdata/TDengine/actions/workflows/taosd-ci-build.yml). More workflows will be available soon.
## 7.2 Run TDengine on macOS
## 10. Coverage
<details>
<summary>Detailed steps to run on macOS</summary>
To start the service after installation on macOS, double-click the /applications/TDengine to start the program, or in a terminal, use:
```bash
sudo launchctl start com.tdengine.taosd
```
Then users can use the TDengine CLI to connect the TDengine server. In a terminal, use:
```bash
taos
```
If TDengine CLI connects the server successfully, welcome messages and version info are printed. Otherwise, an error message is shown.
</details>
## 7.3 Run TDengine on Windows
Not available for TDengine TSDB-OSS.
# 8. Testing
For how to run different types of tests on TDengine, please see [Testing TDengine](./tests/README.md).
# 9. Releasing
For the complete list of TDengine Releases, please see [Releases](https://github.com/taosdata/TDengine/releases).
# 10. Workflow
TDengine build check workflow can be found in this [Github Action](https://github.com/taosdata/TDengine/actions/workflows/taosd-ci-build.yml). More workflows will be available soon.
# 11. Coverage
Latest TDengine test coverage report can be found on [coveralls.io](https://coveralls.io/github/taosdata/TDengine)
Latest TDengine test coverage report can be found on [coveralls.io](https://coveralls.io/github/taosdata/TDengine).
<details>
@ -351,8 +374,8 @@ To create the test coverage report (in HTML format) locally, please run followin
```bash
cd tests
bash setup-lcov.sh -v 1.16 && ./run_local_coverage.sh -b main -c task
# on main branch and run cases in longtimeruning_cases.task
bash setup-lcov.sh -v 1.16 && ./run_local_coverage.sh -b main -c task
# on main branch and run cases in longtimeruning_cases.task
# for more information about options please refer to ./run_local_coverage.sh -h
```
@ -361,6 +384,10 @@ bash setup-lcov.sh -v 1.16 && ./run_local_coverage.sh -b main -c task
</details>
# 12. Contributing
## 11. Contributing
Please follow the [contribution guidelines](CONTRIBUTING.md) to contribute to TDengine.
## 12. License
TDengine is licensed under the [GNU Affero General Public License 3.0](https://github.com/taosdata/TDengine/blob/main/LICENSE).

6
cmake/check_env.cmake
View file

@ -1,7 +1,7 @@
# NOTE: if you change this option later, that'll NOT effect unless you remove CMakeCache.txt beforehand
option(TD_CHECK_SYSTEM_EXTERNALS "if check and externals installed on the system or not" OFF)
if(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
if(NOT BREW_PREFIX)
execute_process(COMMAND brew --prefix OUTPUT_VARIABLE BREW_PREFIX OUTPUT_STRIP_TRAILING_WHITESPACE)
set(BREW_PREFIX "${BREW_PREFIX}" CACHE STRING "Homebrew installation prefix")
@ -34,7 +34,7 @@ macro(check_lib)
set(_lib ${arg_check_lib_LIBNAME})
set(_symbol ${arg_check_lib_SYMBOL})
if(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
set(CMAKE_REQUIRED_FLAGS "-I${BREW_PREFIX}/include -L${BREW_PREFIX}/lib")
endif()
@ -49,7 +49,7 @@ macro(check_lib)
endif()
endif()
if(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
# cleanup
set(CMAKE_REQUIRED_FLAGS)
endif()

12
cmake/conan.cmake
View file

@ -48,7 +48,7 @@ if(${BUILD_GEOS})
endif()
if(${JEMALLOC_ENABLED})
if(${BUILD_JEMALLOC})
find_package(jemalloc QUIET)
if(NOT jemalloc_FOUND)
message(STATUS "jemalloc not found in Conan packages, will use ExternalProject")
@ -432,16 +432,6 @@ macro(DEP_ext_avro_LIB tgt)
endif()
endmacro()
macro(DEP_ext_libs3 tgt)
# libs3 not migrated yet
endmacro()
macro(DEP_ext_libs3_INC tgt)
endmacro()
macro(DEP_ext_libs3_LIB tgt)
endmacro()
macro(DEP_ext_azure tgt)
# azure not migrated yet
endmacro()

217
cmake/define.cmake
View file

@ -1,12 +1,10 @@
set(CMAKE_VERBOSE_MAKEFILE FALSE)
set(TD_BUILD_TAOSA_INTERNAL FALSE)
set(TD_BUILD_KEEPER_INTERNAL FALSE)
# set output directory
SET(TD_BUILD_DIR ${PROJECT_BINARY_DIR}/build)
SET(TD_BUILD_DIR ${CMAKE_BINARY_DIR}/build)
SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${TD_BUILD_DIR}/bin)
SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${TD_BUILD_DIR}/lib)
if(${TD_WINDOWS})
if(TD_WINDOWS)
# adapt to the rule of DLL searching on Windows
SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${TD_BUILD_DIR}/bin)
else()
@ -20,125 +18,100 @@ MESSAGE(STATUS "Project binary files output path: " ${PROJECT_BINARY_DIR})
MESSAGE(STATUS "Project executable files output path: " ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
MESSAGE(STATUS "Project library files output path: " ${CMAKE_ARCHIVE_OUTPUT_DIRECTORY})
IF(NOT DEFINED TD_GRANT)
SET(TD_GRANT FALSE)
if(TD_DARWIN_64 AND BUILD_TEST)
add_definitions(-DCOMPILER_SUPPORTS_CXX13)
endif()
add_definitions(
-DUSE_AUDIT
-DUSE_GEOS
-DUSE_UDF
-DUSE_STREAM
-DUSE_PCRE2
-DUSE_RSMA
-DUSE_TSMA
-DUSE_TQ
-DUSE_TOPIC
-DUSE_MONITOR
-DUSE_REPORT
)
if(BUILD_ASTRA)
add_definitions(-DTD_ASTRA)
endif()
if(BUILD_ASTRA_RPC)
add_definitions(-DTD_ASTRA_RPC)
endif()
if(BUILD_TAOSD_INTEGRATED)
add_definitions(-DTAOSD_INTEGRATED)
endif()
if(BUILD_AS_LIB)
add_definitions(-DTD_AS_LIB)
endif()
if(BUILD_WEBSOCKET)
set(TD_WEBSOCKET TRUE)
message(STATUS "Enable websocket")
add_definitions(-DWEBSOCKET)
else()
set(TD_WEBSOCKET FALSE)
endif()
if(BUILD_TOOLS)
message(STATUS "Will build taos_tools!")
set(TD_TAOS_TOOLS TRUE)
else()
message(STATUS "Will _not_ build taos_tools!")
set(TD_TAOS_TOOLS FALSE)
endif()
IF(BUILD_FLEX_DEPLOY)
ADD_DEFINITIONS(-DTD_FLEX_DEPLOY)
ENDIF()
IF(NOT DEFINED BUILD_WITH_RAND_ERR)
SET(BUILD_WITH_RAND_ERR FALSE)
ELSE()
SET(BUILD_WITH_RAND_ERR TRUE)
ENDIF()
IF(${BUILD_SHARED_STORAGE})
add_definitions(-DUSE_SHARED_STORAGE)
IF(${BUILD_WITH_S3})
add_definitions(-DUSE_S3)
ENDIF ()
ENDIF ()
IF("${WEBSOCKET}" MATCHES "true")
SET(TD_WEBSOCKET TRUE)
MESSAGE("Enable websocket")
ADD_DEFINITIONS(-DWEBSOCKET)
ELSE()
SET(TD_WEBSOCKET FALSE)
ENDIF()
IF("${BUILD_HTTP}" STREQUAL "")
IF(TD_LINUX)
IF(TD_ARM_32)
SET(TD_BUILD_HTTP TRUE)
ELSE()
SET(TD_BUILD_HTTP TRUE)
ENDIF()
ELSEIF(TD_DARWIN)
SET(TD_BUILD_HTTP TRUE)
ELSE()
SET(TD_BUILD_HTTP TRUE)
ENDIF()
ELSEIF(${BUILD_HTTP} MATCHES "false")
SET(TD_BUILD_HTTP FALSE)
ELSEIF(${BUILD_HTTP} MATCHES "true")
SET(TD_BUILD_HTTP TRUE)
ELSEIF(${BUILD_HTTP} MATCHES "internal")
SET(TD_BUILD_HTTP FALSE)
SET(TD_BUILD_TAOSA_INTERNAL TRUE)
ELSE()
SET(TD_BUILD_HTTP TRUE)
ENDIF()
IF(TD_BUILD_HTTP)
ADD_DEFINITIONS(-DHTTP_EMBEDDED)
ENDIF()
IF("${BUILD_KEEPER}" STREQUAL "")
SET(TD_BUILD_KEEPER FALSE)
ELSEIF(${BUILD_KEEPER} MATCHES "false")
SET(TD_BUILD_KEEPER FALSE)
ELSEIF(${BUILD_KEEPER} MATCHES "true")
SET(TD_BUILD_KEEPER TRUE)
ELSEIF(${BUILD_KEEPER} MATCHES "internal")
SET(TD_BUILD_KEEPER FALSE)
SET(TD_BUILD_KEEPER_INTERNAL TRUE)
ELSE()
SET(TD_BUILD_KEEPER FALSE)
ENDIF()
IF("${BUILD_TOOLS}" STREQUAL "")
IF(TD_LINUX)
IF(TD_ARM_32)
SET(BUILD_TOOLS "false")
ELSEIF(TD_ARM_64)
SET(BUILD_TOOLS "false")
ELSE()
SET(BUILD_TOOLS "false")
ENDIF()
ELSEIF(TD_DARWIN)
SET(BUILD_TOOLS "false")
ELSE()
SET(BUILD_TOOLS "false")
ENDIF()
ENDIF()
IF("${BUILD_TOOLS}" MATCHES "false")
MESSAGE("${Yellow} Will _not_ build taos_tools! ${ColourReset}")
SET(TD_TAOS_TOOLS FALSE)
ELSE()
MESSAGE("")
MESSAGE("${Green} Will build taos_tools! ${ColourReset}")
MESSAGE("")
SET(TD_TAOS_TOOLS TRUE)
ENDIF()
if(BUILD_WITH_COS)
message(FATAL_ERROR "freemine: not implemented yet")
endif()
# Enable advanced security features
IF("${ADVANCED_SECURITY}" MATCHES "true")
IF(BUILD_ADVANCED_SECURITY)
ADD_DEFINITIONS(-DTD_ENABLE_ADVANCED_SECURITY)
ENDIF()
IF("${ASSERT_NOT_CORE}" MATCHES "true")
IF(BUILD_ASSERT_NOT_CORE)
ADD_DEFINITIONS(-DASSERT_NOT_CORE)
MESSAGE(STATUS "Disable assert not core")
ELSE()
MESSAGE(STATUS "Enable assert not core")
ENDIF()
IF(${FLEX_DEPLOY})
ADD_DEFINITIONS(-DTD_FLEX_DEPLOY)
ENDIF()
SET(TAOS_LIB taos)
SET(TAOS_LIB_STATIC taos_static)
SET(TAOS_NATIVE_LIB taosnative)
SET(TAOS_NATIVE_LIB_STATIC taosnative_static)
# build TSZ by default
IF("${TSZ_ENABLED}" MATCHES "false")
set(VAR_TSZ "" CACHE INTERNAL "global variant empty")
ELSE()
# define add
MESSAGE(STATUS "build with TSZ enabled")
ADD_DEFINITIONS(-DTD_TSZ)
set(VAR_TSZ "TSZ" CACHE INTERNAL "global variant tsz")
ENDIF()
if(BUILD_TSZ_ENABLED)
message(STATUS "build with TSZ enabled")
add_definitions(-DTD_TSZ)
set(VAR_TSZ "TSZ" CACHE INTERNAL "global variant tsz")
else()
set(VAR_TSZ "" CACHE INTERNAL "global variant empty")
endif()
IF(TD_WINDOWS)
MESSAGE("${Yellow} set compiler flag for Windows! ${ColourReset}")
IF(${CMAKE_BUILD_TYPE} MATCHES "Release")
IF(CMAKE_BUILD_TYPE MATCHES "Release")
MESSAGE("${Green} will build Release version! ${ColourReset}")
# NOTE: let cmake to choose default compile options
message(STATUS "do NOT forget to remove the following line and check if it works or not!!!")
@ -158,7 +131,14 @@ IF(TD_WINDOWS)
ELSE()
MESSAGE("${Green} will build Debug version! ${ColourReset}")
# NOTE: let cmake to choose default compile options
SET(COMMON_FLAGS "/w /D_WIN32 /DWIN32 /Zi /MDd")
IF(${BUILD_SANITIZER})
MESSAGE("${Green} will build Debug with AddressSanitizer (MSVC ASan)! ${ColourReset}")
# /fsanitize=address is compatible with /MDd; no /GL or /RTC1 in Debug
# so there are no incompatibility constraints unlike Release.
SET(COMMON_FLAGS "/w /D_WIN32 /DWIN32 /Zi /MDd /fsanitize=address /D_DISABLE_VECTOR_ANNOTATION=1 /D_DISABLE_STRING_ANNOTATION=1")
ELSE()
SET(COMMON_FLAGS "/w /D_WIN32 /DWIN32 /Zi /MDd")
ENDIF()
ENDIF()
SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /MANIFEST:NO /FORCE:MULTIPLE")
@ -230,7 +210,7 @@ IF(TD_WINDOWS)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COMMON_FLAGS} ${_c_cxx_flags}")
ELSE()
IF(${TD_DARWIN})
IF(TD_DARWIN)
set(CMAKE_MACOSX_RPATH 0)
ENDIF()
@ -241,7 +221,7 @@ ELSE()
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COMMON_FLAGS} ${_c_cxx_flags}")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COMMON_FLAGS} ${_c_cxx_flags}")
IF(${COVER} MATCHES "true")
IF(BUILD_COVERAGE)
MESSAGE(STATUS "Test coverage mode, add extra flags")
SET(GCC_COVERAGE_COMPILE_FLAGS "-fprofile-arcs -ftest-coverage")
SET(GCC_COVERAGE_LINK_FLAGS "-lgcov --coverage")
@ -250,7 +230,7 @@ ELSE()
ENDIF()
# disable all assert
IF((${DISABLE_ASSERT} MATCHES "true") OR(${DISABLE_ASSERTS} MATCHES "true"))
IF(DISABLE_ASSERT OR DISABLE_ASSERTS)
ADD_DEFINITIONS(-DDISABLE_ASSERT)
MESSAGE(STATUS "Disable all asserts")
ENDIF()
@ -260,7 +240,7 @@ ELSE()
IF(TD_ARM_64 OR TD_ARM_32)
SET(COMPILER_SUPPORT_SSE42 false)
ELSEIF(("${CMAKE_C_COMPILER_ID}" MATCHES "Clang") OR("${CMAKE_C_COMPILER_ID}" MATCHES "AppleClang"))
ELSEIF(("${CMAKE_C_COMPILER_ID}" MATCHES "Clang") OR ("${CMAKE_C_COMPILER_ID}" MATCHES "AppleClang"))
SET(COMPILER_SUPPORT_SSE42 true)
MESSAGE(STATUS "Always enable sse4.2 for Clang/AppleClang")
ELSE()
@ -299,7 +279,7 @@ ELSE()
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse4.2")
ENDIF()
IF("${SIMD_SUPPORT}" MATCHES "true")
IF(SIMD_SUPPORT)
IF(COMPILER_SUPPORT_FMA)
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfma")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfma")
@ -319,7 +299,7 @@ ELSE()
ENDIF()
ENDIF()
IF("${SIMD_AVX512_SUPPORT}" MATCHES "true")
IF(SIMD_AVX512_SUPPORT)
IF(COMPILER_SUPPORT_AVX512F AND COMPILER_SUPPORT_AVX512BMI)
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mavx512f -mavx512vbmi")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx512f -mavx512vbmi")
@ -333,19 +313,16 @@ ELSE()
ENDIF()
ENDIF()
# build mode
SET(CMAKE_C_FLAGS_REL "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -O3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
SET(CMAKE_CXX_FLAGS_REL "${CMAKE_CXX_FLAGS} -Werror -Wno-reserved-user-defined-literal -Wno-literal-suffix -Werror=return-type -fPIC -O3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
IF(${BUILD_SANITIZER})
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fsanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=shift-base -fno-sanitize=alignment -g3 -Wformat=0")
# SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fsanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=shift-base -fno-sanitize=alignment -g3 -Wformat=0")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=shift-base -fno-sanitize=alignment -g3 -Wformat=0")
IF(BUILD_SANITIZER)
# Note: -fsanitize=undefined is intentionally omitted from C_FLAGS.
# The manylinux2014 (CentOS 7) build container ships GCC 7 which generates
# ubsan v0 ABI calls (e.g. __ubsan_handle_type_mismatch) but the only
# available 64-bit libubsan (devtoolset-10) provides v1 symbols only
# (__ubsan_handle_type_mismatch_v1), causing an unresolvable link error
# with the mold linker. ASan (-fsanitize=address) works correctly.
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize-recover=all -fno-sanitize=shift-base -fno-sanitize=alignment -g3 -Wformat=0")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize-recover=all -fno-sanitize=shift-base -fno-sanitize=alignment -g3 -Wformat=0")
MESSAGE(STATUS "Compile with Address Sanitizer!")
ELSEIF(${BUILD_RELEASE})
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS_REL}")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_REL}")
elseif(TD_LINUX)
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -fPIC -g3 -gdwarf-2 -Wno-format-truncation -Wno-write-strings -Wno-format-overflow")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -fPIC -g3 -gdwarf-2 -Wno-format-truncation -Wno-write-strings -Wno-format-overflow -Wno-conversion-null")
@ -359,7 +336,7 @@ ENDIF()
IF(TD_LINUX_64)
# NOTE: need to test
IF(${JEMALLOC_ENABLED})
IF(BUILD_JEMALLOC)
MESSAGE(STATUS "JEMALLOC Enabled")
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-error=attributes")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=attributes")

33
cmake/enterprise.cmake Normal file
View file

@ -0,0 +1,33 @@
# Enterprise feature configuration.
# -DBUILD_ENTERPRISE=ON enables enterprise build from sibling taos-internal repo.
# Otherwise all enterprise features default to FALSE.
if(BUILD_ENTERPRISE)
set(TD_ENTERPRISE TRUE)
set(TD_ENTERPRISE_DIR "${PROJECT_SOURCE_DIR}/../taos-internal"
CACHE PATH "Path to taos-internal source directory")
set(TD_GRANT_LIB_DIR "${PROJECT_SOURCE_DIR}/../taos-grant-lib"
CACHE PATH "Path to taos-grant-lib precompiled files")
if(NOT EXISTS "${TD_ENTERPRISE_DIR}/source")
message(FATAL_ERROR
"BUILD_ENTERPRISE=ON but enterprise source not found at: ${TD_ENTERPRISE_DIR}/source\n"
"Please ensure taos-internal repo is cloned alongside taos-community\n")
endif()
message(STATUS "Enterprise build enabled, source: ${TD_ENTERPRISE_DIR}")
include("${TD_ENTERPRISE_DIR}/cmake/enterprise_options.cmake")
include("${TD_ENTERPRISE_DIR}/cmake/enterprise_defines.cmake")
else()
set(TD_ENTERPRISE FALSE)
set(TD_ACCOUNT FALSE)
set(TD_ADMIN FALSE)
set(TD_VNODE_PLUGINS FALSE)
set(TD_STORAGE FALSE)
set(TD_PRIVILEGE FALSE)
set(TD_GRANT FALSE)
set(TD_DM_MODULE FALSE)
set(TD_TOPIC FALSE)
set(TD_MODULE FALSE)
set(TD_USB_DONGLE FALSE)
endif()

1281
cmake/external.cmake
View file

File diff suppressed because it is too large Load diff

66
cmake/in/libs3.CMakeLists.txt.in
View file

@ -1,66 +0,0 @@
cmake_minimum_required(VERSION 3.16)
set(LIBS3_VER_MAJOR 4 CACHE STRING "libs3 version major" FORCE)
set(LIBS3_VER_MINOR 1 CACHE STRING "libs3 version minor" FORCE)
set(LIBS3_VER ${LIBS3_VER_MAJOR}.${LIBS3_VER_MINOR} CACHE STRING "libs3 version" FORCE)
project(
libs3
VERSION ${LIBS3_VER}
DESCRIPTION "libs3 - hand-crafted CMakeLists.txt"
)
add_library(libs3
src/bucket.c src/bucket_metadata.c src/error_parser.c src/general.c
src/object.c src/request.c src/request_context.c
src/response_headers_handler.c src/service_access_logging.c
src/service.c src/simplexml.c src/util.c src/multipart.c
)
target_compile_definitions(libs3 PRIVATE
LIBS3_VER_MAJOR="${LIBS3_VER_MAJOR}"
LIBS3_VER_MINOR="${LIBS3_VER_MINOR}"
LIBS3_VER="${LIBS3_VER}"
)
target_include_directories(libs3
PUBLIC
inc
${CURL_INCLUDE}
${OPENSSL_INCLUDE}
${LIBXML2_INCLUDE}
${ZLIB_INCLUDE}
)
if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
find_library(CORE_FOUNDATION CoreFoundation)
find_library(SYSTEM_CONFIGURATION SystemConfiguration)
target_link_libraries(libs3 PRIVATE ${CORE_FOUNDATION} ${SYSTEM_CONFIGURATION})
target_link_libraries(libs3 PRIVATE iconv)
endif()
find_package(Threads REQUIRED)
target_link_libraries(libs3 PUBLIC
${CURL_LIBS}
${OPENSSL_LIBS}
${CRYPTO_LIBS}
${LIBXML2_LIBS}
${ZLIB_LIBS}
m
dl
${CMAKE_THREAD_LIBS_INIT}
)
set_target_properties(libs3 PROPERTIES
PUBLIC_HEADER "inc/libs3.h"
)
add_executable(s3
src/s3.c
)
target_link_libraries(s3 PRIVATE libs3)
add_executable(testsimplexml
src/testsimplexml.c
)
target_link_libraries(testsimplexml PRIVATE libs3)
install(TARGETS libs3 s3 testsimplexml
PUBLIC_HEADER
)

97
cmake/in/taosadapter.CMakeLists.txt.in
View file

@ -1,97 +0,0 @@
cmake_minimum_required(VERSION 3.16)
project(taosadapter)
include(ExternalProject)
message(STATUS "TAOS_H_DIR:${TAOS_H_DIR}")
message(STATUS "TAOS_LIB_DIR:${TAOS_LIB_DIR}")
message(STATUS "TAOS_VERSION:${TAOS_VERSION}")
message(STATUS "TD_VER_OSTYPE:${TD_VER_OSTYPE}")
message(STATUS "TD_VER_CPUTYPE:${TD_VER_CPUTYPE}")
message(STATUS "TD_VER_DATE:${TD_VER_DATE}")
# NOTE: if you wanna pass other go build options, such as -a -x
# you can pass -DTD_GO_BUILD_OPTIONS:STRING="-a:-x"
# Attention: use ':' as a separator
message(STATUS "TD_GO_BUILD_OPTIONS:${TD_GO_BUILD_OPTIONS}")
message(STATUS "CMAKE_INSTALL_PREFIX:${CMAKE_INSTALL_PREFIX}")
string(REPLACE ":" ";" _td_go_build_options "${TD_GO_BUILD_OPTIONS}")
if(NOT DEFINED TAOS_VERSION)
message(FATAL_ERROR "must specify -DTAOS_VERSION:STRING=<...>")
endif()
if(APPLE)
set(_rpath "-Wl,-rpath,\$ORIGIN/../lib")
elseif(UNIX)
set(_rpath "-Wl,-rpath=\$ORIGIN/../lib")
elseif(WIN32)
set(_rpath "")
endif()
set(_cgo_cflags_list)
set(_cgo_ldflags_list)
set(_ldflags_list)
if(DEFINED TAOS_H_DIR)
list(APPEND _cgo_cflags_list
"-I${TAOS_H_DIR}"
)
endif()
if(DEFINED TAOS_LIB_DIR)
list(APPEND _cgo_ldflags_list
"-L${TAOS_LIB_DIR}"
)
list(APPEND _cgo_ldflags_list
"${_rpath}"
)
endif()
list(APPEND _ldflags_list
"-X 'github.com/taosdata/taosadapter/v3/version.Version=${TAOS_VERSION}'"
)
EXECUTE_PROCESS(
COMMAND git rev-parse HEAD
RESULT_VARIABLE commit_sha1
OUTPUT_VARIABLE taosadapter_commit_sha1
)
message(STATUS "taosadapter_commit_sha1:${taosadapter_commit_sha1}")
STRING(STRIP "${taosadapter_commit_sha1}" taosadapter_commit_sha1)
if("z${taosadapter_commit_sha1}" STREQUAL "z")
message(FATAL_ERROR "internal logic error")
endif()
list(APPEND _ldflags_list
"-X 'github.com/taosdata/taosadapter/v3/version.CommitID=${taosadapter_commit_sha1}'"
)
list(APPEND _ldflags_list
"-X 'github.com/taosdata/taosadapter/v3/version.BuildInfo=${TD_VER_OSTYPE}-${TD_VER_CPUTYPE} ${TD_VER_DATE}'"
)
string(JOIN " " _cgo_cflags ${_cgo_cflags_list})
string(JOIN " " _cgo_ldflags ${_cgo_ldflags_list})
string(JOIN " " _ldflags ${_ldflags_list})
message(STATUS "_cgo_cflags:${_cgo_cflags_list}")
message(STATUS "_cgo_ldflags:${_cgo_ldflags_list}")
message(STATUS "_ldflags ${_ldflags_list}")
add_custom_target(build_with_cmake ALL
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
COMMAND_EXPAND_LISTS
VERBATIM
# NOTE: remove -a option, because we wanna avoid unnecessary recompilation.
# NOTE: cgo does not trace modification of header files
# thus go build will not comply with taos.h in a consistent way
# TODO: if you really wanna a rebuild
# you can pass -DTD_GO_BUILD_OPTIONS:STRING="-a"
COMMAND "${CMAKE_COMMAND}" -E env "CGO_CFLAGS=${_cgo_cflags}"
"CGO_LDFLAGS=${_cgo_ldflags}"
go build "${_td_go_build_options}" -ldflags "${_ldflags}"
)

6
cmake/install.cmake
View file

@ -26,13 +26,13 @@ ADD_CUSTOM_TARGET(${PREPARE_ENV_TARGET} ALL WORKING_DIRECTORY ${TD_EXECUTABLE_OU
IF (TD_LINUX)
SET(TD_MAKE_INSTALL_SH "${TD_SOURCE_DIR}/packaging/tools/make_install.sh")
INSTALL(CODE "MESSAGE(\"make install script: ${TD_MAKE_INSTALL_SH}\")")
INSTALL(CODE "execute_process(COMMAND bash ${TD_MAKE_INSTALL_SH} ${TD_SOURCE_DIR} ${CMAKE_BINARY_DIR} Linux ${TD_VER_NUMBER})")
INSTALL(CODE "execute_process(COMMAND bash ${TD_MAKE_INSTALL_SH} ${TD_SOURCE_DIR} ${CMAKE_BINARY_DIR} Linux ${BUILD_VER_NUMBER})")
ELSEIF (TD_WINDOWS)
SET(TD_MAKE_INSTALL_SH "${TD_SOURCE_DIR}/packaging/tools/make_install.bat")
INSTALL(CODE "MESSAGE(\"make install script: ${TD_MAKE_INSTALL_SH}\")")
INSTALL(CODE "execute_process(COMMAND ${TD_MAKE_INSTALL_SH} :needAdmin ${TD_SOURCE_DIR} ${CMAKE_BINARY_DIR} Windows ${TD_VER_NUMBER} ${TD_BUILD_TAOSA_INTERNAL})")
INSTALL(CODE "execute_process(COMMAND ${TD_MAKE_INSTALL_SH} :needAdmin ${TD_SOURCE_DIR} ${CMAKE_BINARY_DIR} Windows ${BUILD_VER_NUMBER})")
ELSEIF (TD_DARWIN)
SET(TD_MAKE_INSTALL_SH "${TD_SOURCE_DIR}/packaging/tools/make_install.sh")
INSTALL(CODE "MESSAGE(\"make install script: ${TD_MAKE_INSTALL_SH}\")")
INSTALL(CODE "execute_process(COMMAND bash ${TD_MAKE_INSTALL_SH} ${TD_SOURCE_DIR} ${CMAKE_BINARY_DIR} Darwin ${TD_VER_NUMBER})")
INSTALL(CODE "execute_process(COMMAND bash ${TD_MAKE_INSTALL_SH} ${TD_SOURCE_DIR} ${CMAKE_BINARY_DIR} Darwin ${BUILD_VER_NUMBER})")
ENDIF ()

458
cmake/options.cmake
View file

@ -1,282 +1,101 @@
# =========================================================
# Deps options
# =========================================================
if(TD_COMMUNITY_STANDALONE)
option(BUILD_ENTERPRISE "If build enterprise edition (requires sibling taos-internal repo)" OFF)
option(BUILD_TEST "If build unit tests using googletest" OFF)
option(BUILD_TOOLS "Build tools component" OFF)
option(BUILD_SANITIZER "Enable sanitizers" OFF)
option(BUILD_COVERAGE "Enable code coverage" OFF)
option(BUILD_JEMALLOC "Enable jemalloc allocator" OFF)
option(
BUILD_TEST
"If build unit tests using googletest"
OFF
)
# TODO: tackle 'undefined pthread_atfork referenced by libuv.a' issue found on CentOS7.9/ubuntu 18
option(TD_PTHREAD_TWEAK "tweaking pthread experimentally, especially for CentOS7.9 or ubuntu 18" OFF)
# NOTE: these are not boolean options, but are very much useful
# TAOSADAPTER_BUILD_OPTIONS
if(NOT DEFINED TAOSADAPTER_BUILD_OPTIONS)
set(TAOSADAPTER_BUILD_OPTIONS "" CACHE STRING "go build options to be used by taosadapter, separated by ':'" FORCE)
set(BUILD_VER_NUMBER "" CACHE STRING "Version number override")
set(BUILD_VER_COMPATIBLE "" CACHE STRING "Compatible version number override")
set(BUILD_VER_TYPE "" CACHE STRING "Version type override (e.g. stable)")
set(BUILD_VER_DATE "" CACHE STRING "Version date override (e.g. %Y-%m-%d %H:%M:%S %z)")
set(BUILD_VER_CPUTYPE "" CACHE STRING "CPU type override")
set(BUILD_VER_OSTYPE "" CACHE STRING "OS type override")
set(BUILD_GITINFO "" CACHE STRING "Git commit ID override")
set(BUILD_GITINFOI "" CACHE STRING "Internal git commit ID override")
endif()
# TAOSADAPTER_GIT_TAG
# <tag/branch/commit-sha1>:[TRUE|FALSE]
# eg.: main
# stands for:
# GIT_TAG main
# GIT_SHALLOW TRUE
# eg.: ver-3.3.6.0
# stands for:
# GIT_TAG ver-3.3.6.0
# GIT_SHALLOW TRUE
# eg.: ba3e38da6cba08a555bd67369b1829cde3dd0348:FALSE
# stands for:
# GIT_TAG ba3e38da6cba08a555bd67369b1829cde3dd0348
# GIT_SHALLOW FALSE
# NOTE: if you specify branch other than main, please change this to FALSE
# otherwise you might encounter the error like:
# error: pathspec 'xxx' did not match any file(s) known to git
if(NOT DEFINED TAOSADAPTER_GIT_TAG)
set(TAOSADAPTER_GIT_TAG "main" CACHE STRING "which tag/branch/commit-sha1 to checkout for taosadapter.git" FORCE)
option(USE_CONAN "Use Conan for dependency management" OFF)
option(BUILD_ADVANCED_SECURITY "If enable advanced security" OFF)
option(BUILD_ASSERT_NOT_CORE "If assert not generate core file" OFF)
option(BUILD_WEBSOCKET "Enable websocket" OFF)
option(BUILD_PTHREAD_TWEAK "Tweak pthread for CentOS7.9/Ubuntu18" OFF)
option(BUILD_ASTRA "Build for Astra platform" OFF)
option(BUILD_ASTRA_RPC "Build with Astra RPC transport" OFF)
if(TD_WINDOWS AND NOT BUILD_ASTRA)
option(BUILD_PTHREAD "If build pthread on Windows" ON)
option(BUILD_GNUREGEX "If build gnu regex on Windows" ON)
option(BUILD_WITH_ICONV "If build iconv on Windows" ON)
option(BUILD_MSVCREGEX "If build msvcregex on Windows" ON)
option(BUILD_WCWIDTH "If build wcwidth on Windows" ON)
option(BUILD_WINGETOPT "If build wingetopt on Windows" ON)
option(BUILD_CRASHDUMP "If build crashdump on Windows" ON)
endif()
# preprocess TAOSADAPTER_GIT_TAG
string(REPLACE ":" ";" _kv "${TAOSADAPTER_GIT_TAG}:TRUE") # NOTE: set GIT_SHALLOW to TRUE by default
list(GET _kv 0 _k)
list(GET _kv 1 _v)
set(TAOSADAPTER_GIT_TAG_NAME "${_k}" CACHE STRING "" FORCE)
if(${_v})
set(TAOSADAPTER_GIT_TAG_SHALLOW TRUE CACHE BOOL "" FORCE)
option(BUILD_WITH_LEMON "If build with lemon" ON)
option(BUILD_WITH_UDF "If build with UDF" ON)
option(BUILD_PYUDF "If build Python UDF plugin (libtaospyudf)" ON)
# Python UDF: auto-download a single CPython SDK from python-build-standalone
# for compile-time headers/import-lib. Runtime still probes installed Python at
# execution time via udfd.
set(BUILD_PYUDF_PYTHON_VERSION "3.15.0b1" CACHE STRING
"Single Python version for pyudf SDK selection (must match PBS release)")
if(NOT BUILD_ASTRA)
option(BUILD_GEOS "If build with geos" ON)
option(BUILD_SHARED_LIBS "If build shared libraries" OFF)
option(RUST_BINDINGS "If build with rust-bindings" ON)
option(BUILD_PCRE2 "If build with pcre2" ON)
option(BUILD_ADDR2LINE "If build addr2line" OFF)
option(BUILD_WITH_LEVELDB "If build with leveldb" OFF)
if(TD_LINUX)
option(BUILD_ROCKSDB "If build rocksdb from source" OFF)
option(ROCKSDB_USE_DEPS "If use prebuilt rocksdb from deps/" ON)
else()
option(BUILD_ROCKSDB "If build rocksdb from source" ON)
option(ROCKSDB_USE_DEPS "If use prebuilt rocksdb from deps/" OFF)
endif()
option(TD_USE_ROCKSDB "If enable rocksdb support" ON)
option(BUILD_WITH_LZ4 "If build with lz4" ON)
else()
set(TAOSADAPTER_GIT_TAG_SHALLOW FALSE CACHE BOOL "" FORCE)
option(BUILD_ROCKSDB "If build rocksdb from source" OFF)
option(TD_USE_ROCKSDB "If enable rocksdb support" OFF)
option(BUILD_WITH_LZMA2 "If build with lzma2" ON)
endif()
# TAOSWS_GIT_TAG
# eg.: main
if(NOT DEFINED TAOSWS_GIT_TAG)
set(TAOSWS_GIT_TAG "main" CACHE STRING "which tag/branch/commit-sha1 to checkout for taosws(rust connector)" FORCE)
if(TD_LINUX OR TD_WINDOWS)
option(BUILD_SHARED_STORAGE "If build with shared storage" ON)
option(BUILD_WITH_S3 "If build with s3" ON)
option(BUILD_WITH_COS "If build with cos" OFF)
endif()
# preprocess TAOSWS_GIT_TAG
string(REPLACE ":" ";" _kv "${TAOSWS_GIT_TAG}:TRUE") # NOTE: set GIT_SHALLOW to TRUE by default
list(GET _kv 0 _k)
list(GET _kv 1 _v)
set(TAOSWS_GIT_TAG_NAME "${_k}" CACHE STRING "" FORCE)
if(${_v})
set(TAOSWS_GIT_TAG_SHALLOW TRUE CACHE BOOL "" FORCE)
if(TD_LINUX)
option(BUILD_WITH_LZMA2 "If build with lzma2" ON)
endif()
if(TD_LINUX OR TD_WINDOWS)
option(BUILD_WITH_ANALYSIS "If build with analysis" ON)
else()
set(TAOSWS_GIT_TAG_SHALLOW FALSE CACHE BOOL "" FORCE)
option(BUILD_WITH_ANALYSIS "If build with analysis" OFF)
endif()
IF(${TD_WINDOWS})
IF(NOT TD_ASTRA)
MESSAGE("build pthread Win32")
option(
BUILD_PTHREAD
"If build pthread on Windows"
ON
)
MESSAGE("build gnu regex for Windows")
option(
BUILD_GNUREGEX
"If build gnu regex on Windows"
ON
)
MESSAGE("build iconv Win32")
option(
BUILD_WITH_ICONV
"If build iconv on Windows"
ON
)
MESSAGE("build msvcregex Win32")
option(
BUILD_MSVCREGEX
"If build msvcregex on Windows"
ON
)
MESSAGE("build wcwidth Win32")
option(
BUILD_WCWIDTH
"If build wcwidth on Windows"
ON
)
MESSAGE("build wingetopt Win32")
option(
BUILD_WINGETOPT
"If build wingetopt on Windows"
ON
)
option(
TDENGINE_3
"TDengine 3.x for taos-tools"
ON
)
option(
BUILD_CRASHDUMP
"If build crashdump on Windows"
ON
)
ENDIF ()
ELSEIF (TD_DARWIN_64)
IF(${BUILD_TEST})
add_definitions(-DCOMPILER_SUPPORTS_CXX13)
ENDIF ()
ENDIF ()
option(
BUILD_WITH_LEMON
"If build with lemon"
ON
)
option(
BUILD_WITH_UDF
"If build with UDF"
ON
)
IF(NOT TD_ASTRA)
option(
BUILD_GEOS
"If build with geos"
ON
)
option(
BUILD_SHARED_LIBS
""
OFF
)
option(
RUST_BINDINGS
"If build with rust-bindings"
ON
)
option(
BUILD_PCRE2
"If build with pcre2"
ON
)
option(
JEMALLOC_ENABLED
"If build with jemalloc"
OFF
)
option(
BUILD_SANITIZER
"If build sanitizer"
OFF
)
option(
BUILD_ADDR2LINE
"If build addr2line"
OFF
)
option(
BUILD_WITH_LEVELDB
"If build with leveldb"
OFF
)
option(
BUILD_WITH_ROCKSDB
"If build with rocksdb"
ON
)
option(
BUILD_WITH_LZ4
"If build with lz4"
ON
)
ELSE ()
option(
BUILD_WITH_LZMA2
"If build with lzma2"
ON
)
ENDIF ()
ADD_DEFINITIONS(-DUSE_AUDIT)
ADD_DEFINITIONS(-DUSE_GEOS)
ADD_DEFINITIONS(-DUSE_UDF)
ADD_DEFINITIONS(-DUSE_STREAM)
ADD_DEFINITIONS(-DUSE_PCRE2)
ADD_DEFINITIONS(-DUSE_RSMA)
ADD_DEFINITIONS(-DUSE_TSMA)
ADD_DEFINITIONS(-DUSE_TQ)
ADD_DEFINITIONS(-DUSE_TOPIC)
ADD_DEFINITIONS(-DUSE_MONITOR)
ADD_DEFINITIONS(-DUSE_REPORT)
IF(${TD_ASTRA_RPC})
ADD_DEFINITIONS(-DTD_ASTRA_RPC)
ENDIF()
IF(${TD_LINUX})
option(
BUILD_SHARED_STORAGE
"If build with shared storage"
ON
)
option(
BUILD_WITH_S3
"If build with s3"
ON
)
option(
BUILD_WITH_COS
"If build with cos"
OFF
)
option(
BUILD_WITH_LZMA2
"If build with lzma2"
ON
)
ENDIF ()
IF (${TD_LINUX} OR ${TD_WINDOWS})
option(BUILD_WITH_ANALYSIS "If build with analysis" ON)
ELSE()
option(BUILD_WITH_ANALYSIS "If build with analysis" OFF)
ENDIF()
# NOTE: set option variable in this ways is not a good practice
IF((NOT TD_ENTERPRISE) OR TD_WINDOWS)
MESSAGE("switch shared storage off with community/windows edition")
if(NOT TD_ENTERPRISE)
MESSAGE("switch shared storage off with community edition")
set(BUILD_SHARED_STORAGE OFF)
set(BUILD_WITH_S3 OFF)
set(BUILD_WITH_COS OFF)
ELSE()
MESSAGE("switch shared storage ON with enterprise Linux edition")
MESSAGE("switch shared storage ON with enterprise edition")
set(BUILD_SHARED_STORAGE ON)
set(BUILD_WITH_S3 ON)
set(BUILD_WITH_S3 ON)
ENDIF ()
IF(${BUILD_SHARED_STORAGE})
add_definitions(-DUSE_SHARED_STORAGE)
IF(${BUILD_WITH_S3})
add_definitions(-DUSE_S3)
# NOTE: BUILD_WITH_S3 does NOT coexist with BUILD_WITH_COS?
option(BUILD_WITH_COS "If build with cos" OFF)
ELSE ()
@ -285,101 +104,46 @@ IF(${BUILD_SHARED_STORAGE})
MESSAGE("shared storage does not support COS at present, please use s3 instead")
ENDIF ()
ELSE ()
option(BUILD_WITH_S3 "If build with s3" OFF)
option(BUILD_WITH_COS "If build with cos" OFF)
ENDIF ()
IF(${TAOSD_INTEGRATED})
add_definitions(-DTAOSD_INTEGRATED)
ENDIF()
IF(${TD_AS_LIB})
add_definitions(-DTD_AS_LIB)
ENDIF()
option(BUILD_WITH_SQLITE "If build with sqlite" OFF)
option(BUILD_WITH_BDB "If build with BDB" OFF)
option(BUILD_WITH_LUCENE "If build with lucene" OFF)
option(BUILD_WITH_NURAFT "If build with NuRaft" OFF)
option(
BUILD_WITH_SQLITE
"If build with sqlite"
OFF
if(NOT BUILD_ASTRA)
option(BUILD_WITH_UV "If build with libuv" ON)
option(BUILD_WITH_UV_TRANS "If build with libuv_trans" ON)
if(TD_LINUX)
option(BUILD_DEPENDENCY_TESTS "If build dependency tests" ON)
endif()
option(BUILD_WITH_INVERTEDINDEX "If use invertedIndex" ON)
endif()
option(BUILD_TAOSD_INTEGRATED "Build taosd as integrated library" OFF)
option(BUILD_AS_LIB "Build TDengine as library" OFF)
option(BUILD_RELEASE "If build release version" OFF)
if(TD_LINUX)
option(BUILD_CONTRIB "If build thirdpart from source" OFF)
else()
option(BUILD_CONTRIB "If build thirdpart from source" ON)
endif()
option(BUILD_LIBSASL "If build libsasl2" ON)
option(BUILD_FLEX_DEPLOY "If enable flexible deployment mode" OFF)
option(BUILD_WITH_RAND_ERR "If build with random error injection" OFF)
option(BUILD_TSZ_ENABLED "If build with TSZ compression" ON)
option(BUILD_USE_PUBLIC_DEPS "Use public (internet) URLs for all external dependencies instead of internal mirrors" OFF)
# When BUILD_RELEASE is ON, force CMAKE_BUILD_TYPE to Release so that
# CMake built-in Release flags and ExternalProject configuration align.
if(BUILD_RELEASE)
set(CMAKE_BUILD_TYPE "Release" CACHE STRING "" FORCE)
message(STATUS "[options] BUILD_RELEASE=ON => CMAKE_BUILD_TYPE forced to Release")
endif()
message(STATUS
"[options] BUILD_CONTRIB=${BUILD_CONTRIB}, BUILD_ROCKSDB=${BUILD_ROCKSDB}"
)
option(
BUILD_WITH_BDB
"If build with BDB"
OFF
)
option(
BUILD_WITH_LUCENE
"If build with lucene"
off
)
option(
BUILD_WITH_NURAFT
"If build with NuRaft"
OFF
)
IF(NOT TD_ASTRA)
option(
BUILD_WITH_UV
"If build with libuv"
ON
)
option(
BUILD_WITH_UV_TRANS
"If build with libuv_trans "
ON
)
IF(${TD_LINUX} MATCHES TRUE)
option(
BUILD_DEPENDENCY_TESTS
"If build dependency tests"
ON
)
ENDIF ()
option(
BUILD_WITH_INVERTEDINDEX
"If use invertedIndex"
ON
)
ENDIF ()
option(
BUILD_RELEASE
"If build release version"
OFF
)
option(
BUILD_CONTRIB
"If build thirdpart from source"
OFF
)
option(
BUILD_LIBSASL
"If build libsasl2"
ON
)
option(
FLEX_DEPLOY
"If enable flexible deployment mode"
OFF
)
message(STATUS "BUILD_SHARED_STORAGE:${BUILD_SHARED_STORAGE}")
message(STATUS "BUILD_WITH_S3:${BUILD_WITH_S3}")
message(STATUS "BUILD_WITH_COS:${BUILD_WITH_COS}")

70
cmake/platform.cmake
View file

@ -9,11 +9,11 @@ else()
set(CXX_COMPILER_IS_GNU FALSE)
endif()
MESSAGE("Current system: ${CMAKE_SYSTEM_NAME}")
MESSAGE(STATUS "Current system: ${CMAKE_SYSTEM_NAME}")
IF (${CMAKE_SYSTEM_NAME} MATCHES "Linux" OR ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
IF (CMAKE_SYSTEM_NAME MATCHES "Linux" OR CMAKE_SYSTEM_NAME MATCHES "Darwin")
IF (${CXX_COMPILER_IS_GNU})
IF (CXX_COMPILER_IS_GNU)
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99")
ELSE ()
ADD_DEFINITIONS("-Wno-tautological-constant-out-of-range-compare -Wno-pointer-sign -Wno-unknown-warning-option")
@ -21,15 +21,15 @@ IF (${CMAKE_SYSTEM_NAME} MATCHES "Linux" OR ${CMAKE_SYSTEM_NAME} MATCHES "Darwin
set(CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS "${CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS} -undefined dynamic_lookup")
ENDIF ()
MESSAGE("Current system processor: ${CMAKE_SYSTEM_PROCESSOR}")
MESSAGE(STATUS "Current system processor: ${CMAKE_SYSTEM_PROCESSOR}")
IF (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
IF (CMAKE_SYSTEM_NAME MATCHES "Linux")
SET(TD_LINUX TRUE)
SET(OSTYPE "Linux")
SET(BUILD_VER_OSTYPE "Linux")
ADD_DEFINITIONS("-DLINUX")
IF (${CMAKE_SIZEOF_VOID_P} MATCHES 8)
IF (CMAKE_SIZEOF_VOID_P MATCHES 8)
SET(TD_LINUX_64 TRUE)
ELSE ()
SET(TD_LINUX_32 TRUE)
@ -39,32 +39,32 @@ IF (${CMAKE_SYSTEM_NAME} MATCHES "Linux" OR ${CMAKE_SYSTEM_NAME} MATCHES "Darwin
EXECUTE_PROCESS(COMMAND readlink /bin/sh OUTPUT_VARIABLE SHELL_LINK)
MESSAGE(STATUS "The shell is: " ${SHELL_LINK})
IF (${SHELL_LINK} MATCHES "dash")
IF (SHELL_LINK MATCHES "dash")
EXECUTE_PROCESS(COMMAND ${CMAKE_CURRENT_LIST_DIR}/../packaging/tools/get_os.sh "" OUTPUT_VARIABLE TD_OS_INFO)
ELSE ()
EXECUTE_PROCESS(COMMAND sh ${CMAKE_CURRENT_LIST_DIR}/../packaging/tools/get_os.sh "" OUTPUT_VARIABLE TD_OS_INFO)
ENDIF ()
MESSAGE(STATUS "The current OS is " ${TD_OS_INFO})
IF (${TD_OS_INFO} MATCHES "Alpine")
IF (TD_OS_INFO MATCHES "Alpine")
SET(TD_ALPINE TRUE)
ADD_DEFINITIONS("-D_ALPINE")
ENDIF ()
ELSEIF (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
ELSEIF (CMAKE_SYSTEM_NAME MATCHES "Darwin")
SET(TD_DARWIN TRUE)
SET(OSTYPE "macOS")
SET(BUILD_VER_OSTYPE "macOS")
ADD_DEFINITIONS("-DDARWIN -Wno-tautological-pointer-compare")
IF (${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm64")
MESSAGE("Current system arch is arm64")
IF (CMAKE_SYSTEM_PROCESSOR MATCHES "arm64")
MESSAGE(STATUS "Current system arch is arm64")
SET(TD_DARWIN_64 TRUE)
SET(TD_DARWIN_ARM64 TRUE)
ADD_DEFINITIONS("-D_TD_DARWIN_64")
ADD_DEFINITIONS("-D_TD_DARWIN_ARM64")
ENDIF ()
IF (${CMAKE_SYSTEM_PROCESSOR} MATCHES "x86_64")
MESSAGE("Current system arch is x86_64")
IF (CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
MESSAGE(STATUS "Current system arch is x86_64")
SET(TD_DARWIN_64 TRUE)
SET(TD_DARWIN_X64 TRUE)
ADD_DEFINITIONS("-D_TD_DARWIN_64")
@ -74,13 +74,13 @@ IF (${CMAKE_SYSTEM_NAME} MATCHES "Linux" OR ${CMAKE_SYSTEM_NAME} MATCHES "Darwin
ADD_DEFINITIONS("-DHAVE_UNISTD_H")
ENDIF ()
ELSEIF (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
ELSEIF (CMAKE_SYSTEM_NAME MATCHES "Windows")
SET(TD_WINDOWS TRUE)
SET(OSTYPE "Windows")
SET(BUILD_VER_OSTYPE "Windows")
ADD_DEFINITIONS("-DWINDOWS")
IF (${CMAKE_SIZEOF_VOID_P} MATCHES 8)
IF (CMAKE_SIZEOF_VOID_P MATCHES 8)
SET(TD_WINDOWS_64 TRUE)
ADD_DEFINITIONS("-D_TD_WINDOWS_64")
ELSE ()
@ -90,43 +90,43 @@ ELSEIF (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
ENDIF()
IF ("${CPUTYPE}" STREQUAL "")
IF ("${BUILD_VER_CPUTYPE}" STREQUAL "")
IF (CMAKE_SYSTEM_PROCESSOR MATCHES "(amd64)|(AMD64)|(x86_64)|(X86_64)")
MESSAGE(STATUS "Current platform is amd64")
SET(PLATFORM_ARCH_STR "amd64")
SET(CPUTYPE "x64")
SET(BUILD_VER_CPUTYPE "x64")
SET(TD_INTEL_64 TRUE)
ADD_DEFINITIONS("-D_TD_X86_")
ELSEIF (CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)")
MESSAGE(STATUS "Current platform is x86")
SET(PLATFORM_ARCH_STR "i386")
SET(CPUTYPE "x86")
SET(BUILD_VER_CPUTYPE "x86")
SET(TD_INTEL_32 TRUE)
ADD_DEFINITIONS("-D_TD_X86_")
ELSEIF (CMAKE_SYSTEM_PROCESSOR MATCHES "armv7l")
MESSAGE(STATUS "Current platform is aarch32")
SET(PLATFORM_ARCH_STR "arm")
SET(CPUTYPE "arm32")
SET(BUILD_VER_CPUTYPE "arm32")
SET(TD_ARM_32 TRUE)
ADD_DEFINITIONS("-D_TD_ARM_")
ADD_DEFINITIONS("-D_TD_ARM_32")
ELSEIF (CMAKE_SYSTEM_PROCESSOR MATCHES "(aarch64)|(arm64)")
MESSAGE(STATUS "Current platform is aarch64")
SET(PLATFORM_ARCH_STR "arm64")
SET(CPUTYPE "arm64")
SET(BUILD_VER_CPUTYPE "arm64")
SET(TD_ARM_64 TRUE)
ADD_DEFINITIONS("-D_TD_ARM_")
ADD_DEFINITIONS("-D_TD_ARM_64")
ELSEIF (CMAKE_SYSTEM_PROCESSOR MATCHES "loongarch64")
MESSAGE(STATUS "The current platform is loongarch64")
SET(PLATFORM_ARCH_STR "loongarch64")
SET(CPUTYPE "loongarch64")
SET(BUILD_VER_CPUTYPE "loongarch64")
SET(TD_LOONGARCH_64 TRUE)
ADD_DEFINITIONS("-D_TD_LOONGARCH_")
ADD_DEFINITIONS("-D_TD_LOONGARCH_64")
ELSEIF (CMAKE_SYSTEM_PROCESSOR MATCHES "mips64")
SET(PLATFORM_ARCH_STR "mips")
SET(CPUTYPE "mips64")
SET(BUILD_VER_CPUTYPE "mips64")
MESSAGE(STATUS "input cpuType: mips64")
SET(TD_MIPS_64 TRUE)
ADD_DEFINITIONS("-D_TD_MIPS_")
@ -134,41 +134,41 @@ IF ("${CPUTYPE}" STREQUAL "")
ENDIF ()
ELSE ()
# if generate ARM version:
# cmake -DCPUTYPE=aarch32 .. or cmake -DCPUTYPE=aarch64
IF (${CPUTYPE} MATCHES "aarch32" OR ${CPUTYPE} MATCHES "arm32")
# cmake -DBUILD_VER_CPUTYPE=aarch32 .. or cmake -DBUILD_VER_CPUTYPE=aarch64
IF (BUILD_VER_CPUTYPE MATCHES "aarch32" OR BUILD_VER_CPUTYPE MATCHES "arm32")
SET(PLATFORM_ARCH_STR "arm")
MESSAGE(STATUS "input cpuType: aarch32")
ADD_DEFINITIONS("-D_TD_ARM_")
ADD_DEFINITIONS("-D_TD_ARM_32")
SET(TD_ARM_32 TRUE)
ELSEIF (${CPUTYPE} MATCHES "aarch64" OR ${CPUTYPE} MATCHES "arm64")
ELSEIF (BUILD_VER_CPUTYPE MATCHES "aarch64" OR BUILD_VER_CPUTYPE MATCHES "arm64")
SET(PLATFORM_ARCH_STR "arm64")
MESSAGE(STATUS "input cpuType: aarch64")
ADD_DEFINITIONS("-D_TD_ARM_")
ADD_DEFINITIONS("-D_TD_ARM_64")
SET(TD_ARM_64 TRUE)
ELSEIF (${CPUTYPE} MATCHES "loongarch64")
ELSEIF (BUILD_VER_CPUTYPE MATCHES "loongarch64")
SET(PLATFORM_ARCH_STR "loongarch64")
MESSAGE(STATUS "input cpuType: loongarch64")
SET(TD_LOONGARCH_64 TRUE)
ADD_DEFINITIONS("-D_TD_LOONGARCH_")
ADD_DEFINITIONS("-D_TD_LOONGARCH_64")
ELSEIF (${CPUTYPE} MATCHES "mips64")
ELSEIF (BUILD_VER_CPUTYPE MATCHES "mips64")
SET(PLATFORM_ARCH_STR "mips")
MESSAGE(STATUS "input cpuType: mips64")
SET(TD_MIPS_64 TRUE)
ADD_DEFINITIONS("-D_TD_MIPS_")
ADD_DEFINITIONS("-D_TD_MIPS_64")
ELSEIF (${CPUTYPE} MATCHES "x64")
ELSEIF (BUILD_VER_CPUTYPE MATCHES "x64")
SET(PLATFORM_ARCH_STR "amd64")
MESSAGE(STATUS "input cpuType: x64")
SET(TD_INTEL_64 TRUE)
ELSEIF (${CPUTYPE} MATCHES "x86")
ELSEIF (BUILD_VER_CPUTYPE MATCHES "x86")
SET(PLATFORM_ARCH_STR "i386")
MESSAGE(STATUS "input cpuType: x86")
SET(TD_INTEL_32 TRUE)
ELSE ()
MESSAGE(STATUS "input cpuType unknown " ${CPUTYPE})
MESSAGE(STATUS "input cpuType unknown " ${BUILD_VER_CPUTYPE})
ENDIF ()
ENDIF ()
@ -216,5 +216,5 @@ else ()
endif()
MESSAGE(STATUS "DEPS_DIR: " ${TD_DEPS_DIR})
MESSAGE("C Compiler: ${CMAKE_C_COMPILER} (${CMAKE_C_COMPILER_ID}, ${CMAKE_C_COMPILER_VERSION})")
MESSAGE("CXX Compiler: ${CMAKE_CXX_COMPILER} (${CMAKE_C_COMPILER_ID}, ${CMAKE_CXX_COMPILER_VERSION})")
MESSAGE(STATUS "C Compiler: ${CMAKE_C_COMPILER} (${CMAKE_C_COMPILER_ID}, ${CMAKE_C_COMPILER_VERSION})")
MESSAGE(STATUS "CXX Compiler: ${CMAKE_CXX_COMPILER} (${CMAKE_C_COMPILER_ID}, ${CMAKE_CXX_COMPILER_VERSION})")

148
cmake/version.cmake
View file

@ -1,8 +1,9 @@
IF (BUILD_VER_NUMBER STREQUAL "")
SET(BUILD_VER_NUMBER "3.4.1.6.alpha")
ENDIF ()
IF (DEFINED VERNUMBER)
SET(TD_VER_NUMBER ${VERNUMBER})
ELSE ()
SET(TD_VER_NUMBER "3.4.1.6.alpha")
IF (BUILD_VER_COMPATIBLE STREQUAL "")
SET(BUILD_VER_COMPATIBLE "3.0.0.0")
ENDIF ()
IF (TD_ENTERPRISE)
@ -21,126 +22,153 @@ ELSE()
ENDIF ()
ENDIF ()
IF (DEFINED VERCOMPATIBLE)
SET(TD_VER_COMPATIBLE ${VERCOMPATIBLE})
ELSE ()
SET(TD_VER_COMPATIBLE "3.0.0.0")
IF (BUILD_VER_COMPATIBLE STREQUAL "")
SET(BUILD_VER_COMPATIBLE "3.0.0.0")
ENDIF ()
IF (TD_PRODUCT_NAME)
ADD_DEFINITIONS(-DTD_PRODUCT_NAME="${TD_PRODUCT_NAME}")
IF (BUILD_CUS_PRODUCT_NAME AND NOT BUILD_CUS_PRODUCT_NAME STREQUAL "")
ADD_DEFINITIONS(-DTD_PRODUCT_NAME="${BUILD_CUS_PRODUCT_NAME}")
ENDIF ()
IF (CUS_NAME)
ADD_DEFINITIONS(-DCUS_NAME="${CUS_NAME}")
IF (BUILD_CUS_NAME AND NOT BUILD_CUS_NAME STREQUAL "")
ADD_DEFINITIONS(-DCUS_NAME="${BUILD_CUS_NAME}")
ENDIF ()
IF (CUS_PROMPT)
ADD_DEFINITIONS(-DCUS_PROMPT="${CUS_PROMPT}")
IF (BUILD_CUS_PROMPT AND NOT BUILD_CUS_PROMPT STREQUAL "")
ADD_DEFINITIONS(-DCUS_PROMPT="${BUILD_CUS_PROMPT}")
ENDIF ()
IF (CUS_EMAIL)
ADD_DEFINITIONS(-DCUS_EMAIL="${CUS_EMAIL}")
IF (BUILD_CUS_EMAIL AND NOT BUILD_CUS_EMAIL STREQUAL "")
ADD_DEFINITIONS(-DCUS_EMAIL="${BUILD_CUS_EMAIL}")
ENDIF ()
find_program(HAVE_GIT NAMES git)
IF (DEFINED GITINFO)
SET(TD_VER_GIT ${GITINFO})
IF (DEFINED BUILD_GITINFO AND NOT BUILD_GITINFO STREQUAL "")
# use value from command line
ELSEIF (HAVE_GIT)
message(STATUS "TD_COMMUNITY_DIR:${TD_COMMUNITY_DIR}")
execute_process(COMMAND git log -1 --format=%H WORKING_DIRECTORY ${TD_COMMUNITY_DIR} OUTPUT_VARIABLE GIT_COMMITID)
#message(STATUS "git log result:${GIT_COMMITID}")
IF (GIT_COMMITID)
string (REGEX REPLACE "[\n\t\r]" "" GIT_COMMITID ${GIT_COMMITID})
SET(TD_VER_GIT ${GIT_COMMITID})
SET(BUILD_GITINFO ${GIT_COMMITID})
ELSE ()
message(STATUS "not a git repository")
SET(TD_VER_GIT "no git commit id")
SET(BUILD_GITINFO "no git commit id")
ENDIF ()
ELSE ()
message(STATUS "no git found")
SET(TD_VER_GIT "no git commit id")
SET(BUILD_GITINFO "no git commit id")
ENDIF ()
IF (DEFINED GITINFOI)
SET(TD_VER_GIT_INTERNAL ${GITINFOI})
IF (DEFINED BUILD_GITINFOI AND NOT BUILD_GITINFOI STREQUAL "")
# use value from command line
ELSEIF (HAVE_GIT AND TD_ENTERPRISE)
execute_process(COMMAND git log -1 --format=%H WORKING_DIRECTORY ${TD_ENTERPRISE_DIR} OUTPUT_VARIABLE GIT_COMMITID)
message(STATUS "git log result:${GIT_COMMITID}")
IF (GIT_COMMITID)
string (REGEX REPLACE "[\n\t\r]" "" GIT_COMMITID ${GIT_COMMITID})
SET(TD_VER_GIT_INTERNAL ${GIT_COMMITID})
SET(BUILD_GITINFOI ${GIT_COMMITID})
ELSE ()
message(STATUS "not a git repository")
SET(TD_VER_GIT "no git commit id")
SET(BUILD_GITINFOI "no git commit id")
ENDIF ()
ELSEIF (HAVE_GIT)
message(STATUS "PROJECT_SOURCE_DIR:${PROJECT_SOURCE_DIR}")
execute_process(COMMAND git log -1 --format=%H WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} OUTPUT_VARIABLE GIT_COMMITID)
ELSE ()
message(STATUS "no git cmd")
SET(TD_VER_GIT_INTERNAL "no git commit id")
SET(BUILD_GITINFOI "no git commit id")
ENDIF ()
message(STATUS "TD_VER_GIT_INTERNAL: ${TD_VER_GIT_INTERNAL}")
message(STATUS "TD_VER_GIT: ${TD_VER_GIT}")
message(STATUS "BUILD_GITINFOI: ${BUILD_GITINFOI}")
message(STATUS "BUILD_GITINFO: ${BUILD_GITINFO}")
IF (DEFINED VERDATE)
SET(TD_VER_DATE ${VERDATE})
ELSE ()
IF (NOT DEFINED BUILD_VER_DATE OR BUILD_VER_DATE STREQUAL "")
STRING(COMPARE GREATER_EQUAL "${CMAKE_VERSION}" "3.26" TD_CMAKE_SUPPORT_TZ)
IF (TD_CMAKE_SUPPORT_TZ)
STRING(TIMESTAMP TD_VER_DATE "%Y-%m-%d %H:%M:%S %z")
STRING(TIMESTAMP BUILD_VER_DATE "%Y-%m-%d %H:%M:%S %z")
ELSE ()
IF (TD_WINDOWS)
STRING(TIMESTAMP TD_VER_DATE "%Y-%m-%d %H:%M:%S")
STRING(TIMESTAMP BUILD_VER_DATE "%Y-%m-%d %H:%M:%S")
ELSE ()
EXECUTE_PROCESS(COMMAND date +"%F %T %z" OUTPUT_VARIABLE TD_VER_DATE)
STRING(REPLACE "\"" "" TD_VER_DATE ${TD_VER_DATE})
STRING(STRIP ${TD_VER_DATE} TD_VER_DATE)
EXECUTE_PROCESS(COMMAND date +"%F %T %z" OUTPUT_VARIABLE BUILD_VER_DATE)
STRING(REPLACE "\"" "" BUILD_VER_DATE ${BUILD_VER_DATE})
STRING(STRIP ${BUILD_VER_DATE} BUILD_VER_DATE)
ENDIF ()
ENDIF ()
ENDIF ()
IF (DEFINED VERTYPE)
SET(TD_VER_VERTYPE ${VERTYPE})
ELSE ()
SET(TD_VER_VERTYPE "stable")
IF (NOT DEFINED BUILD_VER_TYPE OR BUILD_VER_TYPE STREQUAL "")
SET(BUILD_VER_TYPE "stable")
ENDIF ()
IF (DEFINED CPUTYPE)
SET(TD_VER_CPUTYPE ${CPUTYPE})
IF (DEFINED BUILD_VER_CPUTYPE AND NOT BUILD_VER_CPUTYPE STREQUAL "")
# use value from command line
ELSE ()
IF (TD_WINDOWS_32)
SET(TD_VER_CPUTYPE "x86")
SET(BUILD_VER_CPUTYPE "x86")
ELSEIF (TD_LINUX_32)
SET(TD_VER_CPUTYPE "x86")
SET(BUILD_VER_CPUTYPE "x86")
ELSEIF (TD_ARM_32)
SET(TD_VER_CPUTYPE "arm32")
SET(BUILD_VER_CPUTYPE "arm32")
ELSEIF (TD_MIPS_32)
SET(TD_VER_CPUTYPE "mips32")
SET(BUILD_VER_CPUTYPE "mips32")
ELSE ()
SET(TD_VER_CPUTYPE "x64")
SET(BUILD_VER_CPUTYPE "x64")
ENDIF ()
ENDIF ()
IF (DEFINED OSTYPE)
SET(TD_VER_OSTYPE ${OSTYPE})
ELSE ()
SET(TD_VER_OSTYPE "Linux")
IF (NOT DEFINED BUILD_VER_OSTYPE OR BUILD_VER_OSTYPE STREQUAL "")
SET(BUILD_VER_OSTYPE "Linux")
ENDIF ()
MESSAGE(STATUS "============= compile version parameter information start ============= ")
MESSAGE(STATUS "version: " ${TD_VER_NUMBER})
MESSAGE(STATUS "compatible: " ${TD_VER_COMPATIBLE})
MESSAGE(STATUS "commit id: " ${TD_VER_GIT})
MESSAGE(STATUS "build date: " ${TD_VER_DATE})
MESSAGE(STATUS "version: " ${BUILD_VER_NUMBER})
MESSAGE(STATUS "compatible: " ${BUILD_VER_COMPATIBLE})
MESSAGE(STATUS "commit id: " ${BUILD_GITINFO})
MESSAGE(STATUS "build date: " ${BUILD_VER_DATE})
MESSAGE(STATUS "build type: " ${CMAKE_BUILD_TYPE})
MESSAGE(STATUS "type: " ${TD_VER_VERTYPE})
MESSAGE(STATUS "cpu: " ${TD_VER_CPUTYPE})
MESSAGE(STATUS "os: " ${TD_VER_OSTYPE})
MESSAGE(STATUS "type: " ${BUILD_VER_TYPE})
MESSAGE(STATUS "cpu: " ${BUILD_VER_CPUTYPE})
MESSAGE(STATUS "os: " ${BUILD_VER_OSTYPE})
MESSAGE(STATUS "============= compile version parameter information end ============= ")
STRING(REPLACE "." "_" TD_LIB_VER_NUMBER ${TD_VER_NUMBER})
SET(BUILD_VER_NUMBER "${BUILD_VER_NUMBER}" CACHE STRING "Global TD version number" FORCE)
SET(BUILD_VER_OSTYPE "${BUILD_VER_OSTYPE}" CACHE STRING "Global TD target OS type" FORCE)
SET(BUILD_VER_CPUTYPE "${BUILD_VER_CPUTYPE}" CACHE STRING "Global TD target CPU type" FORCE)
SET(BUILD_VER_DATE "${BUILD_VER_DATE}" CACHE STRING "Global TD build date" FORCE)
SET(BUILD_VER_COMPATIBLE "${BUILD_VER_COMPATIBLE}" CACHE STRING "Global TD compatible ver" FORCE)
SET(BUILD_VER_TYPE "${BUILD_VER_TYPE}" CACHE STRING "Global TD version type" FORCE)
SET(BUILD_GITINFO "${BUILD_GITINFO}" CACHE STRING "Global TD git commit" FORCE)
SET(BUILD_GITINFOI "${BUILD_GITINFOI}" CACHE STRING "Global TD internal commit" FORCE)
STRING(REPLACE "." "_" TD_LIB_VER_NUMBER "${BUILD_VER_NUMBER}")
# Generate comma-separated version for Windows .rc FILEVERSION/PRODUCTVERSION
# Extract up to 4 numeric components from BUILD_VER_NUMBER (e.g. "3.4.1.6.alpha" → "3,4,1,6")
STRING(REGEX MATCHALL "[0-9]+" _ver_components "${BUILD_VER_NUMBER}")
LIST(LENGTH _ver_components _ver_len)
IF(_ver_len GREATER_EQUAL 4)
LIST(GET _ver_components 0 _v0)
LIST(GET _ver_components 1 _v1)
LIST(GET _ver_components 2 _v2)
LIST(GET _ver_components 3 _v3)
ELSEIF(_ver_len EQUAL 3)
LIST(GET _ver_components 0 _v0)
LIST(GET _ver_components 1 _v1)
LIST(GET _ver_components 2 _v2)
SET(_v3 "0")
ELSEIF(_ver_len EQUAL 2)
LIST(GET _ver_components 0 _v0)
LIST(GET _ver_components 1 _v1)
SET(_v2 "0")
SET(_v3 "0")
ELSE()
SET(_v0 "0")
SET(_v1 "0")
SET(_v2 "0")
SET(_v3 "0")
ENDIF()
SET(BUILD_VER_NUMBER_COMMA "${_v0},${_v1},${_v2},${_v3}" CACHE STRING "Comma-separated version for RC" FORCE)

89
contrib/CMakeLists.txt
View file

@ -1,96 +1,21 @@
# ================================================================================================
# Download
# ================================================================================================
if(${BUILD_WITH_S3})
# file(MAKE_DIRECTORY $ENV{HOME}/.cos-local.2/)
elseif(${BUILD_WITH_COS})
message(FATAL_ERROR "freemine: not implemented yet")
endif()
# s3
if(${BUILD_WITH_S3})
add_definitions(-DUSE_S3)
# cos
elseif(${BUILD_WITH_COS})
message(FATAL_ERROR "freemine: not implemented yet")
add_definitions(-DUSE_COS)
endif()
# taosadapter
if(${BUILD_HTTP})
MESSAGE("BUILD_HTTP is on")
else()
MESSAGE("BUILD_HTTP is off, use taosAdapter")
endif()
# lemon
add_subdirectory(lemon)
# Force specify CC=cc on MacOS. Because the default CC setting in the generated Makefile has issues finding standard library headers
IF(${TD_DARWIN})
SET(CONTRIB_CONFIG_ENV "CC=cc")
ENDIF()
# # download dependencies
# ================================================================================================
# Build
# ================================================================================================
add_subdirectory(TSZ)
add_subdirectory(libaes)
add_subdirectory(libmqtt)
# leveldb
if(${BUILD_WITH_LEVELDB})
if(BUILD_WITH_LEVELDB)
option(LEVELDB_BUILD_TESTS "" OFF)
add_subdirectory(leveldb EXCLUDE_FROM_ALL)
target_include_directories(
leveldb
PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/leveldb/include>
)
endif(${BUILD_WITH_LEVELDB})
# rocksdb
# To support rocksdb build on ubuntu: sudo apt-get install libgflags-dev
if(${BUILD_WITH_UV})
if(${TD_LINUX})
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS_REL}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_REL}")
if("${CMAKE_BUILD_TYPE}" STREQUAL "")
SET(CMAKE_BUILD_TYPE Release)
endif()
endif(${TD_LINUX})
endif(${BUILD_WITH_UV})
if(${BUILD_WITH_S3})
# INCLUDE_DIRECTORIES($ENV{HOME}/.cos-local.2/include)
MESSAGE("build with s3: ${BUILD_WITH_S3}")
# cos
elseif(${BUILD_WITH_COS})
if(${TD_LINUX})
else()
endif(${TD_LINUX})
endif()
if(${TD_LINUX} AND ${BUILD_WITH_S3})
# add_subdirectory(azure-cmake)
endif()
IF(TD_LINUX)
SET(TZ_OUTPUT_PATH /usr/share/zoneinfo)
ELSEIF(TD_DARWIN)
SET(TZ_OUTPUT_PATH /var/db/timezone/zoneinfo)
ENDIF()
# ================================================================================================
# Build test
# ================================================================================================
MESSAGE("build with dependency tests: ${BUILD_DEPENDENCY_TESTS}")
if(${BUILD_DEPENDENCY_TESTS})
MESSAGE(STATUS "build with dependency tests: ${BUILD_DEPENDENCY_TESTS}")
if(BUILD_DEPENDENCY_TESTS)
add_subdirectory(test EXCLUDE_FROM_ALL)
endif(${BUILD_DEPENDENCY_TESTS})
endif()

6
contrib/TSZ/CMakeLists.txt
View file

@ -1,4 +1,4 @@
IF(NOT "${TSZ_ENABLED}" MATCHES "false")
if(BUILD_TSZ_ENABLED)
# source
AUX_SOURCE_DIRECTORY(sz/src SRC1)
AUX_SOURCE_DIRECTORY(zstd/dictBuilder SRC2)
@ -22,5 +22,5 @@ IF(NOT "${TSZ_ENABLED}" MATCHES "false")
# windows ignore warning
IF(TD_WINDOWS)
SET_TARGET_PROPERTIES(TSZ PROPERTIES COMPILE_FLAGS -w)
ENDIF()
ENDIF()
endif()
endif()

31
contrib/lemon/CMakeLists.txt
View file

@ -1,2 +1,33 @@
add_executable(lemon lemon.c)
# lemon is a host-side parser generator tool; it must not be built with
# sanitizer instrumentation because devtoolset-7 only ships 32-bit ubsan libs
# and the devtoolset-10 workaround in LIBRARY_PATH does not cover host tools.
if(BUILD_SANITIZER AND NOT TD_WINDOWS)
target_compile_options(lemon PRIVATE
-fno-sanitize=address
-fno-sanitize=undefined
-fno-sanitize=float-divide-by-zero
-fno-sanitize=float-cast-overflow
)
target_link_options(lemon PRIVATE
-fno-sanitize=address
-fno-sanitize=undefined
-fno-sanitize=float-divide-by-zero
-fno-sanitize=float-cast-overflow
)
elseif(BUILD_SANITIZER AND TD_WINDOWS)
# MSVC has no per-target equivalent of GCC's -fno-sanitize=address.
# Strip /fsanitize=address and its companion macros from CMAKE_C/CXX_FLAGS
# in this directory scope only (does NOT affect parent or sibling targets).
# Without this, lemon.exe would require clang_rt.asan_dynamic*.dll at build
# time when the build system invokes it to generate taos_lemon_sql.c, and
# that DLL is not guaranteed to be in PATH during the cmake build step.
foreach(_v CMAKE_C_FLAGS CMAKE_CXX_FLAGS
CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_DEBUG
CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG)
string(REPLACE "/fsanitize=address" "" ${_v} "${${_v}}")
string(REPLACE "/D_DISABLE_VECTOR_ANNOTATION=1" "" ${_v} "${${_v}}")
string(REPLACE "/D_DISABLE_STRING_ANNOTATION=1" "" ${_v} "${${_v}}")
endforeach()
endif()

20
contrib/test/CMakeLists.txt
View file

@ -1,24 +1,24 @@
# rocksdb
if(${BUILD_WITH_ROCKSDB})
if(TD_USE_ROCKSDB)
add_subdirectory(rocksdb)
endif(${BUILD_WITH_ROCKSDB})
endif()
# cos
#if(${BUILD_WITH_COS})
#if(BUILD_WITH_COS)
# add_subdirectory(cos)
#endif(${BUILD_WITH_COS})
#endif()
if(${BUILD_WITH_LUCENE})
if(BUILD_WITH_LUCENE)
add_subdirectory(lucene)
endif(${BUILD_WITH_LUCENE})
endif()
if(${BUILD_WITH_BDB})
if(BUILD_WITH_BDB)
add_subdirectory(bdb)
endif(${BUILD_WITH_BDB})
endif()
if(${BUILD_WITH_SQLITE})
if(BUILD_WITH_SQLITE)
add_subdirectory(sqlite)
endif(${BUILD_WITH_SQLITE})
endif()
# if(${BUILD_SHARED_STORAGE})
# add_subdirectory(azure)

2
contrib/test/craft/CMakeLists.txt
View file

@ -1,5 +1,5 @@
add_executable(simulate_vnode "simulate_vnode.c")
target_link_libraries(simulate_vnode PUBLIC craft lz4 uv_a)
if(${BUILD_WINGETOPT})
if(BUILD_WINGETOPT)
target_link_libraries(simulate_vnode PUBLIC wingetopt)
endif()

2
contrib/test/rocksdb/CMakeLists.txt
View file

@ -1,4 +1,4 @@
message("contrib test/rocksdb:" ${BUILD_DEPENDENCY_TESTS})
message(STATUS "contrib test/rocksdb:" ${BUILD_DEPENDENCY_TESTS})
add_executable(rocksdbTest "")
target_sources(rocksdbTest

BIN
deps/arm/rocksdb_static/librocksdb.a vendored
View file

Binary file not shown.

BIN
deps/x86/rocksdb_static/librocksdb.a vendored
View file

Binary file not shown.

143
docs/en/07-develop/09-udf.md
View file

@ -414,25 +414,146 @@ SELECT perm_entropy(val) FROM vibration_stb PARTITION BY tbname;
### Environment Setup
Starting from v3.4.1.12, the Python UDF plugin `libtaospyudf.so` (Linux) or `taospyudf.dll` (Windows) is shipped built-in with the TDengine TSDB installation package. No additional installation is required. Just ensure that Python 3 runtime is available on the system.
The `taosudf` process automatically detects and loads the system-installed Python at runtime. No manual environment variable configuration is needed.
#### Linux
On Linux, `libtaospyudf.so` is **not bound to a specific Python version**. `taosudf` automatically detects and pre-loads the system's `libpython3.XX.so` at runtime, so a single binary package is compatible with any Python 3.9–3.15.
The specific steps to prepare the environment are as follows:
- Step 1, prepare the Python runtime environment. If you compile and install Python locally, be sure to enable the `--enable-shared` option, otherwise the subsequent installation of taospyudf will fail due to failure to generate a shared library.
- Step 2, install the Python package taospyudf. The command is as follows.
- Step 1, install the Python 3 development package (which includes the `libpython3.XX.so` shared library):
```shell
pip3 install taospyudf
```
```shell
# Ubuntu/Debian
apt install python3-dev
# CentOS/RHEL
yum install python3-devel
```
- Step 3, execute the command ldconfig.
- Step 4, start the taosd service.
- Step 2, start the taosd service.
The installation process will compile C++ source code, so cmake and gcc must be present on the system. The compiled libtaospyudf.so file will automatically be copied to the /usr/local/lib/ directory, so if you are not a root user, you need to add sudo during installation. After installation, you can check if this file is in the directory:
After installing TDengine TSDB, you can verify that `libtaospyudf.so` is properly installed:
```shell
root@server11 ~/udf $ ls -l /usr/local/lib/libtaos*
-rw-r--r-- 1 root root 671344 May 24 22:54 /usr/local/lib/libtaospyudf.so
ls -l /usr/lib/libtaospyudf.so
```
:::tip
If auto-detection fails, you can specify the Python installation path via the `PYTHONHOME` environment variable:
```shell
export PYTHONHOME=/usr/local/python3.12
```
:::
#### Windows
On Windows, `taosudf.exe` automatically locates `python.exe` in the system PATH and sets `PYTHONHOME` accordingly. No manual environment variable configuration is required.
The installation package includes a single plugin library: `taospyudf.dll`.
Just ensure the following:
- The system has Python 3.10+ installed. Download from [python.org](https://www.python.org/downloads/).
- During Python installation, check "Add python.exe to PATH", or manually add the Python installation directory to the system PATH.
:::tip
If `python.exe` is not in PATH (e.g., using a portable/embedded Python), you can manually set the `PYTHONHOME` environment variable to point to the Python installation directory:
```powershell
$env:PYTHONHOME = "C:\Python315"
```
:::
:::note
For versions prior to v3.4.1.12, you need to manually install the Python UDF plugin via `pip3 install taospyudf`. Starting from v3.4.1.12, this step is no longer necessary.
:::
### Manually Building taospyudf (Optional)
In most cases, manual compilation is unnecessary because `taospyudf` is already shipped with TDengine. If you need to rebuild it (for development/debugging), build it from the TDengine source tree.
The source files are located in `source/taos-community/source/libs/pyudf/src/` in the TDengine source tree, and can also be downloaded from [GitHub](https://github.com/taosdata/TDengine/tree/main/source/taos-community/source/libs/pyudf/src).
#### Linux / macOS
On Linux, the recommended manual build flow is the lightweight 1/2/3/4 process below (no full-repo `cmake` configure required).
```bash
# 1. Install dependencies (Linux)
# Ubuntu/Debian:
sudo apt install python3-dev g++
# CentOS/RHEL:
sudo yum install python3-devel gcc-c++
# 2. Prepare headers (pybind11 is no longer required)
# plog:
git clone --depth=1 https://github.com/SergiusTheBest/plog.git /tmp/plog
# Python include flags are obtained automatically via python3-config
# 3. Compile (run from pyudf source directory)
cd source/taos-community/source/libs/pyudf/src
g++ -std=c++17 -fPIC -shared taospyudf.cpp \
-o libtaospyudf.so \
-I/tmp/plog/include \
-I/usr/local/taos/include \
-I. \
$(python3-config --includes) \
-Wno-attributes -Wno-deprecated-declarations \
-Wl,--allow-shlib-undefined -ldl
# 4. Install to system path (Linux)
sudo cp libtaospyudf.so /usr/local/taos/driver/
sudo ln -sf /usr/local/taos/driver/libtaospyudf.so /usr/lib/libtaospyudf.so
sudo ldconfig
# Fallback: build only taospyudf target from TDengine source tree
cmake -S source/taos-community -B debug -DCMAKE_BUILD_TYPE=Release -DBUILD_PYUDF=ON
cmake --build debug --target taospyudf -j
```
:::note
The generated library name is `libtaospyudf.so` on Linux and `libtaospyudf.dylib` on macOS.
:::
#### Windows
On Windows, the recommended manual build flow is the lightweight 1/2/3/4 process below (no full-repo `cmake` configure required).
```powershell
# 1. Install dependencies (Windows)
# - Visual Studio 2019/2022 (with "Desktop development with C++" workload)
# - Python 3.10+ (installer build, preferably added to PATH)
# 2. Prepare headers (pybind11 is no longer required)
git clone --depth=1 https://github.com/SergiusTheBest/plog.git C:\tmp\plog
# 3. Compile (run in "Developer PowerShell for VS")
cd source\taos-community\source\libs\pyudf\src
# Get Python include directory from the current interpreter
$pyInc = (python -c "import sysconfig; print(sysconfig.get_path('include'))").Trim()
# Use export macros and build DLL directly
cl /std:c++17 /EHsc /LD taospyudf.cpp /I C:\tmp\plog\include /I C:\TDengine\include /I . /I "$pyInc" /DBUILDING_DLL /D_CRT_SECURE_NO_WARNINGS /link /OUT:taospyudf.dll
# 4. Install to system path (Windows)
copy taospyudf.dll "C:\TDengine\bin\"
# Fallback: build only taospyudf target from TDengine source tree
cmake -S source/taos-community -B debug -G "NMake Makefiles" -DCMAKE_BUILD_TYPE=Release -DBUILD_PYUDF=ON
cmake --build debug --target taospyudf
```
:::note
The generated library name on Windows is `taospyudf.dll`.
:::
### Interface Definition
When developing UDFs in Python, you need to implement the specified interface functions. The specific requirements are as follows.
@ -624,7 +745,7 @@ Found the following error messages.
05/24 22:46:28.733561 01665799 UDF ERROR can not load python plugin. lib path libtaospyudf.so
```
The error is clear: the Python plugin `libtaospyudf.so` was not loaded. If you encounter this error, please refer to the previous section on setting up the environment.
The error is clear: the Python plugin `libtaospyudf.so` was not loaded. Starting from v3.4.1.12, this plugin is shipped built-in with TDengine TSDB. If you encounter this error, ensure that TDengine TSDB is properly installed and run `ldconfig` to refresh the dynamic library cache. For versions prior to v3.4.1.12, install the plugin manually via `pip3 install taospyudf`.
After fixing the environment error, execute again as follows.

2
docs/en/14-reference/01-components/01-taosd.md
View file

@ -380,7 +380,7 @@ The effective value of charset is UTF-8.
| mqRebalanceInterval | | Supported, effective immediately | Internal parameter, interval for consumer rebalancing |
| uptimeInterval | | Supported, effective immediately | Internal parameter, for recording system uptime |
| timeseriesThreshold | | Supported, effective immediately | Internal parameter, for usage statistics |
| udf | | Supported, effective after restart | Whether to start UDF service; 0: do not start, 1: start; default value 1(The default value on Windows is 0.) |
| udf | | Supported, effective after restart | Whether to start UDF service; 0: do not start, 1: start; default value 1 |
| udfdResFuncs | | Supported, effective after restart | Internal parameter, for setting UDF result sets|
| udfdLdLibPath | | Supported, effective after restart | Internal parameter, indicates the library path for loading UDF |
| streamBatchRequestWaitMs | | Supported, effective after restart | Stream computing batch request wait time, range 0-1800000, in milliseconds, default value 5000 |

10
docs/en/14-reference/02-tools/10-taosbenchmark.md
View file

@ -498,7 +498,7 @@ Below are a few examples of configuration files:
<summary>insert.json</summary>
```json
{{#include tools/taos-tools/example/insert.json}}
{{#include source/taos-community/tools/taos-tools/example/insert.json}}
```
</details>
@ -509,7 +509,7 @@ Below are a few examples of configuration files:
<summary>query.json</summary>
```json
{{#include tools/taos-tools/example/query.json}}
{{#include source/taos-community/tools/taos-tools/example/query.json}}
```
</details>
@ -518,7 +518,7 @@ Below are a few examples of configuration files:
<summary>queryStb.json</summary>
```json
{{#include tools/taos-tools/example/queryStb.json}}
{{#include source/taos-community/tools/taos-tools/example/queryStb.json}}
```
</details>
@ -529,7 +529,7 @@ Below are a few examples of configuration files:
<summary>tmq.json</summary>
```json
{{#include tools/taos-tools/example/tmq.json}}
{{#include source/taos-community/tools/taos-tools/example/tmq.json}}
```
</details>
@ -540,7 +540,7 @@ Below are a few examples of configuration files:
<summary>csv-export.json</summary>
```json
{{#include tools/taos-tools/example/csv-export.json}}
{{#include source/taos-community/tools/taos-tools/example/csv-export.json}}
```
</details>

15
docs/en/14-reference/02-tools/11-taosgen.md
View file

@ -28,8 +28,8 @@ Download the [taosgen](https://github.com/taosdata/taosgen/releases) tool as nee
Download the binary release package locally and extract it. For convenient access, you can create a symbolic link in the system executable directory. For example, on Linux:
```shell
tar zxvf tsgen-v0.3.0-linux-amd64.tar.gz
cd tsgen
tar zxvf taosgen-v0.8.6-linux-x64.tar.gz
cd taosgen
ln -sf `pwd`/taosgen /usr/bin/taosgen
```
@ -58,8 +58,9 @@ taosgen -h 127.0.0.1 -c config.yaml
| -c/--config-file | Path to the YAML configuration file |
| -d/--log-dir | Specify log output directory, default is ./log |
| -o/--log-file | Specify complete log file path (overrides --log-dir), -f is deprecated |
| -?/--help | Show help information and exit |
| -v/--verbose | Increase output verbosity |
| -V/--version | Show version information and exit. Cannot be used with other parameters |
| -?/--help | Show help information and exit |
Tip: If no parameters are specified when running taosgen, taosgen will create the TDengine database tsbench, the super table meters, 10,000 child tables, and batch write 10,000 rows of data to each child table.
@ -230,6 +231,8 @@ Each column includes:
- random: Random generation.
- order: Sequential natural number growth (integer only).
- expression: Generated by expression (supports integer, float, double, and string types).
- null_ratio (float): Ratio of NULL values to generate, range [0.0, 1.0], default: 0.0. NULL represents an explicit null value and overwrites the column's latest value.
- none_ratio (float): Ratio of NONE values to generate, range [0.0, 1.0], default: 0.0. NONE represents missing data and does not overwrite the column's latest value (preserves previous value). The sum of null_ratio and none_ratio must not exceed 1.0.
##### Data Generation Methods
@ -318,6 +321,7 @@ The `tdengine/insert` action writes data to specified child tables. Supports obt
- stmt: Write data using parameterized write (Prepared Statement), suitable for high-performance batch writing.
- schemaless: Write data using Line Protocol format, without requiring pre-creation of super tables and child tables. Suitable for simulating data collection agents like Telegraf sending data to TDengine.
- auto_create_table (bool): Whether to enable TDengine's auto-create-table feature to create tables on the fly when writing data; default: false.
- tbname_key (string): Only effective in schemaless format. Specifies the tag key for the child table name in line protocol output. If set to an empty string (""), the child table name tag is not included in the line protocol. Default is "".
- concurrency (int): Number of threads for concurrent data writing, default: 8.
- failure_handling (optional): Failure handling strategy:
- max_retries (int): Maximum retries, default: 0.
@ -358,7 +362,7 @@ The `mqtt/publish` action publishes data to the specified topic. Supports obtain
- `{column}`: Column data, where column is the column field name
- qos (int): QoS level, values: 0, 1, 2, default: 0.
- retain (bool): Whether MQTT Broker retains the last message, default: false.
- tbname_key (string): Specifies the field name for the table name in the JSON output. If set to an empty string (""), the table name is not included. Default is "table".
- tbname_key (string): Specifies the field name for the table name in the output. If set to an empty string (""), the table name is not included. Default is "".
- records_per_message (int): Number of records per message, default: 1.
### Format for Publishing Kafka Data Action
@ -381,7 +385,7 @@ The `kafka/produce` action publishes data to the specified topic. It supports ob
- "1": The producer waits only for the leader replica to acknowledge the message.
- "0": The producer does not wait for any acknowledgment.
- compression (string): Message compression type. Supported values: "none", "gzip", "snappy", "lz4", "zstd". Default is "none".
- tbname_key (string): Specifies the field name for the table name in the JSON output. If set to an empty string (""), the table name is not included. Default is "table".
- tbname_key (string): Specifies the field name for the table name in the output. In JSON format, it serves as the JSON field name; in influx format, it serves as the tag key in line protocol. If set to an empty string (""), the table name is not included. Default is "".
- records_per_message (int): Number of records per message, default: 1.
### Format for Writing Data to InfluxDB Action
@ -395,6 +399,7 @@ The `influxdb/write` action writes data to the specified InfluxDB Bucket via the
- precision (string): Timestamp precision for writing. Options: "ns", "us", "ms", "s". Default is "ns".
- batch_size (int): Number of line protocol rows per HTTP request, default: 5000. InfluxDB officially recommends a value of 5000.
- gzip (bool): Whether to enable gzip compression. Default is false. Enabling gzip significantly reduces bandwidth usage and is recommended for large-batch writes.
- tbname_key (string): Specifies the tag key for the table name in line protocol output. If set to an empty string (""), the table name tag is not included in the line protocol. Default is "".
## Configuration File Examples

8
docs/en/27-train-faq/index.md
View file

@ -462,7 +462,11 @@ To view the size occupied by a single database, specify the database in the comm
Currently, TDengine only provides compression ratios based on tables, not databases or the entire system. To view the compression ratios, execute the `SHOW TABLE DISTRIBUTED table_name;` command in the client TDengine CLI. The table_name can be a super table, regular table, or subtable. For details, see [SHOW TABLE DISTRIBUTED](../14-reference/03-taos-sql/52-show.md#show-table-distributed).
### 6.7 What should I do if restarting taosd via systemd fails with "start-limit-hit"?
### 6.7 How does WAL affect storage space and the observed compression ratio?
The Write-Ahead Log (WAL) is TDengine TSDB's core mechanism for ensuring data durability. Every write is first recorded in the WAL in **raw, uncompressed format** before being flushed to data files. As a result, in the early stages of writing — before WAL files have been cleaned up — the WAL may be larger than the compressed data files, causing total observed storage to **temporarily exceed the compressed data size**. This is expected behavior. As writing continues, old WAL files are cleaned up automatically, and total storage stabilizes near the actual compressed data size.
### 6.8 What should I do if restarting taosd via systemd fails with "start-limit-hit"?
Problem Description:
In TDengine TSDB 3.3.5.1 and later, the `StartLimitInterval` parameter in `taosd.service` was changed from 60 seconds to 900 seconds. If taosd is restarted 3 times within 900 seconds, subsequent `systemctl restart taosd` calls will fail. Running `systemctl status taosd.service` shows: `Failed with result 'start-limit-hit'`.
@ -475,7 +479,7 @@ Problem Solution:
1. **Via systemd**: First reset the failure counter with `systemctl reset-failed taosd.service`, then restart with `systemctl restart taosd.service`. For a permanent adjustment, manually edit `/etc/systemd/system/taosd.service` to lower `StartLimitInterval` or raise `StartLimitBurst` (note: reinstalling taosd will reset this file), then run `systemctl daemon-reload` before restarting.
2. **Direct invocation**: Run taosd directly (not via systemd) to bypass `StartLimitInterval` and `StartLimitBurst` entirely.
### 6.8 I modified the configuration file, but the parameters didn't take effect. Why?
### 6.9 I modified the configuration file, but the parameters didn't take effect. Why?
#### Problem Description

BIN
docs/en/assets/replica3-01.png
View file

Binary file not shown.
Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 445 KiB

After

Width:  |  Height:  |  Size: 396 KiB

4
docs/examples/JDBC/JDBCDemo/src/main/java/com/taos/example/ConsumerLoopImp.java
View file

@ -40,7 +40,7 @@ public class ConsumerLoopImp {
};
// 创建并启动第1个线程
// 创建并启动第 1 个线程
Thread thread1 = new Thread(() -> {
// 在这里执行你的代码
try {
@ -51,7 +51,7 @@ public class ConsumerLoopImp {
});
thread1.start();
// 创建并启动第2个线程
// 创建并启动第 2 个线程
Thread thread2 = new Thread(() -> {
Scanner scanner = new Scanner(System.in);
System.out.println("输入任何字符结束程序：");

4
docs/examples/JDBC/JDBCDemo/src/main/java/com/taos/example/WsConsumerLoopImp.java
View file

@ -37,7 +37,7 @@ public abstract class WsConsumerLoopImp {
};
// 创建并启动第1个线程
// 创建并启动第 1 个线程
Thread thread1 = new Thread(() -> {
// 在这里执行你的代码
try {
@ -48,7 +48,7 @@ public abstract class WsConsumerLoopImp {
});
thread1.start();
// 创建并启动第2个线程
// 创建并启动第 2 个线程
Thread thread2 = new Thread(() -> {
Scanner scanner = new Scanner(System.in);
System.out.println("输入任何字符结束程序：");

1
docs/examples/JDBC/SpringJdbcTemplate/readme.md
View file

@ -27,6 +27,7 @@ Navigate to the `TDengine/tests/examples/JDBC/SpringJdbcTemplate` directory and
```shell
mvn clean package
```
After successfully packaging, navigate to the `target/` directory and execute the following commands to run the tests:
```shell

22
docs/examples/JDBC/connectionPools/README-cn.md
View file

@ -1,22 +1,27 @@
这个example中，我们适配了java常见的连接池:
这个 example 中，我们适配了 java 常见的连接池：
* HikariCP（默认）
* druid
* dbcp
* c3p0
### 说明
ConnectionPoolDemo的程序逻辑：
1. 创建到host的connection连接池
2. 创建名称为pool_test的database，创建表超级weather，创建tableSize个子表
3. 总共插入totalNumber条数据。
### 如何运行这个例子：
ConnectionPoolDemo 的程序逻辑：
1. 创建到 host 的 connection 连接池
2. 创建名称为 pool_test 的 database，创建表超级 weather，创建 tableSize 个子表
3. 总共插入 totalNumber 条数据。
### 如何运行这个例子
```shell script
mvn clean package
java -jar target/ConnectionPoolDemo-jar-with-dependencies.jar -host 127.0.0.1
```
使用mvn运行ConnectionPoolDemo的main方法，可以指定参数
使用 mvn 运行 ConnectionPoolDemo 的 main 方法，可以指定参数
```shell script
Usage:
java -jar target/ConnectionPoolDemo-jar-with-dependencies.jar
@ -29,4 +34,5 @@ java -jar target/ConnectionPoolDemo-jar-with-dependencies.jar
```
### 日志
使用log4j，将日志和错误分别输出到了debug.log和error.log中
使用 log4j，将日志和错误分别输出到了 debug.log 和 error.log 中

27
docs/examples/JDBC/consumer-demo/readme.md
View file

@ -1,20 +1,26 @@
# How to Run the Consumer Demo Code On Linux OS
TDengine's Consumer demo project is organized in a Maven way so that users can easily compile, package and run the project. If you don't have Maven on your server, you may install it using
```
```shell
sudo apt-get install maven
```
```shell
## Install TDengine Client and TaosAdapter
Make sure you have already installed a tdengine client on your current develop environment.
Download the tdengine package on our website: ``https://www.taosdata.com/cn/all-downloads/`` and install the client.
## Run Consumer Demo using mvn plugin
run command:
```
```shell
mvn clean compile exec:java -Dexec.mainClass="com.taosdata.ConsumerDemo"
```
```shell
## Custom configuration
```shell
# the host of TDengine server
export TAOS_HOST="127.0.0.1"
@ -36,17 +42,18 @@ export TAOS_JDBC_RATE_PER_PROCESSOR="1000"
# poll wait time in ms
export TAOS_JDBC_POLL_SLEEP="100"
```
```shell
## Run Consumer Demo using jar
To compile the demo project, go to the source directory ``TDengine/tests/examples/JDBC/consumer-demo`` and execute
```
```shell
mvn clean package assembly:single
```
```shell
To run ConsumerDemo.jar, go to ``TDengine/tests/examples/JDBC/consumer-demo`` and execute
```
java -jar target/ConsumerDemo-jar-with-dependencies.jar
```
```shell
java -jar target/ConsumerDemo-jar-with-dependencies.jar
```shell

14
docs/examples/JDBC/springbootdemo/readme.md
View file

@ -2,13 +2,14 @@
## Need to create a test database in advance
```
$ taos -s 'create database if not exists test'
```shell
taos -s 'create database if not exists test'
$ curl http://localhost:8080/weather/init
curl http://localhost:8080/weather/init
```
### Configure application.properties
```properties
# datasource config
spring.datasource.driver-class-name=com.taosdata.jdbc.TSDBDriver
@ -41,6 +42,7 @@ logging.level.com.taosdata.jdbc.springbootdemo.dao=debug
### Main functions
* Create databases and tables
```xml
<!-- weatherMapper.xml -->
<update id="createDB" >
@ -53,13 +55,16 @@ logging.level.com.taosdata.jdbc.springbootdemo.dao=debug
```
* Insert a single record
```xml
<!-- weatherMapper.xml -->
<insert id="insert" parameterType="Weather" >
insert into test.weather (ts, temperature, humidity) values (now, #{temperature,jdbcType=INTEGER}, #{humidity,jdbcType=FLOAT})
</insert>
```
* Insert multiple records
```xml
<!-- weatherMapper.xml -->
<insert id="batchInsert" parameterType="java.util.List" >
@ -69,7 +74,9 @@ logging.level.com.taosdata.jdbc.springbootdemo.dao=debug
</foreach>
</insert>
```
* Pagination query
```xml
<!-- weatherMapper.xml -->
<?xml version="1.0" encoding="UTF-8"?>
@ -101,4 +108,3 @@ logging.level.com.taosdata.jdbc.springbootdemo.dao=debug
</select>
</mapper>
```

2
docs/examples/JDBC/taosdemo/readme.md
View file

@ -1,4 +1,4 @@
```
```shell
cd tests/examples/JDBC/taosdemo
mvn clean package -Dmaven.test.skip=true
# Create tables first, then insert data

2
docs/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/TaosDemoApplication.java
View file

@ -63,7 +63,7 @@ public class TaosDemoApplication {
long end = System.currentTimeMillis();
logger.info(">>> create database time cost : " + (end - start) + " ms.");
/**********************************************************************************/
// 构造超级表的meta
// 构造超级表的 meta
SuperTableMeta superTableMeta;
// create super table
if (config.superTableSQL != null) {

12
docs/examples/flink/source/Main.java
View file

@ -210,7 +210,7 @@ splitSql.setSelect("ts, current, voltage, phase, groupid, location")
//ANCHOR: source_custom_type_test
void testCustomTypeSource() throws Exception {
System.out.println("testTDengineSourceByTimeSplit start！");
System.out.println("testTDengineSourceByTimeSplit start!");
Properties connProps = new Properties();
connProps.setProperty(TSDBDriver.PROPERTY_KEY_ENABLE_AUTO_RECONNECT, "true");
connProps.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
@ -319,7 +319,7 @@ splitSql.setSelect("ts, current, voltage, phase, groupid, location")
resultStream.print();
JobClient jobClient = env.executeAsync("Flink test cdc Example");
Thread.sleep(5000L);
// The task submitted by Flink UI cannot be cancle and needs to be stopped on the UI page.
// The task submitted by Flink UI cannot be cancel and needs to be stopped on the UI page.
jobClient.cancel().get();
}
//ANCHOR_END: cdc_source
@ -370,7 +370,7 @@ splitSql.setSelect("ts, current, voltage, phase, groupid, location")
//ANCHOR: cdc_custom_type_test
static void testCustomTypeCdc() throws Exception {
System.out.println("testCustomTypeTDengineCdc start！");
System.out.println("testCustomTypeTDengineCdc start!");
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(3);
env.enableCheckpointing(100, AT_LEAST_ONCE);
@ -439,7 +439,7 @@ splitSql.setSelect("ts, current, voltage, phase, groupid, location")
//ANCHOR: CdcRowDataToSink
static void testCdcToSink() throws Exception {
System.out.println("testTDengineCdcToTdSink start！");
System.out.println("testTDengineCdcToTdSink start!");
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(3);
env.enableCheckpointing(500, CheckpointingMode.AT_LEAST_ONCE);
@ -472,13 +472,13 @@ splitSql.setSelect("ts, current, voltage, phase, groupid, location")
JobClient jobClient = env.executeAsync("Flink test cdc Example");
Thread.sleep(6000L);
jobClient.cancel().get();
System.out.println("testTDengineCdcToTdSink finish！");
System.out.println("testTDengineCdcToTdSink finish!");
}
//ANCHOR_END: CdcRowDataToSink
//ANCHOR: source_table
static void testTableToSink() throws Exception {
System.out.println("testTableToSink start！");
System.out.println("testTableToSink start!");
EnvironmentSettings fsSettings = EnvironmentSettings.newInstance().inStreamingMode().build();
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(3);

2
docs/examples/perspective/prsp-viewer.html
View file

@ -77,7 +77,7 @@
// use view configuration
await viewer.restore(config);
} catch (error) {
console.error('发生错误:', error);
console.error('发生错误：', error);
}
}

1
docs/typos.toml
View file

@ -5,6 +5,7 @@ ine = "ine"
datas = "datas"
[default.extend-words]
BRIN = "BRIN"
OT = "OT"
MAPE = "MAPE"
mosquitto = "mosquitto"

2
docs/zh/07-develop/05-stmt.md
View file

@ -103,7 +103,7 @@ stmt 绑定参数的示例代码如下（TDengine TSDB v3.3.5.0 已停止维护
<TabItem label="Node.js" value="node">
```js
{{#include docs/examples/node/websocketexample/stmt_example.js:createConnect}}
{{#include docs/examples/node/websocketexample/stmt_example.js}}
```
</TabItem>

2
docs/zh/07-develop/07-tmq.md
View file

@ -398,7 +398,7 @@ Rust 连接器创建消费者的参数为 DSN，可以设置的参数列表请
<TabItem label="Node.js" value="node">
```js
{{#include docs/examples/node/websocketexample/tmq_seek_example.js:subscribe}}
{{#include docs/examples/node/websocketexample/tmq_seek_example.js}}
```
</TabItem>

143
docs/zh/07-develop/09-udf.md
View file

@ -419,25 +419,146 @@ SELECT perm_entropy(val) FROM vibration_stb PARTITION BY tbname;
### 准备环境
从 v3.4.1.12 起，Python UDF 插件 `libtaospyudf.so`（Linux）或 `taospyudf.dll`（Windows）已随 TDengine TSDB 安装包内置，无需额外安装。只需确保系统中已安装 Python 3 运行环境即可。
`taosudf` 进程会在运行时自动检测并加载系统中安装的 Python，无需手动配置环境变量。
#### Linux
在 Linux 上，`libtaospyudf.so` 不绑定特定 Python 版本。`taosudf` 会在运行时自动检测并加载系统中安装的 `libpython3.XX.so`，因此一套二进制包可以兼容任意 Python 3.9–3.15 版本。
准备环境的具体步骤如下：
- 第 1 步，准备好 Python 运行环境。本地编译安装 python 注意打开 `--enable-shared` 选项，不然后续安装 taospyudf 会因无法生成共享库而导致失败。
- 第 2 步，安装 Python 包 taospyudf。命令如下。
- 第 1 步，安装 Python 3 开发包（需要包含 `libpython3.XX.so` 共享库）：
```shell
pip3 install taospyudf
```
```shell
# Ubuntu/Debian
apt install python3-dev
# CentOS/RHEL
yum install python3-devel
```
- 第 3 步，执行命令 ldconfig。
- 第 4 步，启动 taosd 服务。
- 第 2 步，启动 taosd 服务。
安装过程中会编译 C++ 源码，因此系统上要有 cmake 和 gcc。编译生成的 libtaospyudf.so 文件自动会被复制到 /usr/local/lib/ 目录，因此如果是非 root 用户，安装时需加 sudo。安装完可以检查这个目录是否有了这个文件：
安装 TDengine TSDB 后，可以检查 `libtaospyudf.so` 是否已正确安装：
```shell
root@slave11 ~/udf $ ls -l /usr/local/lib/libtaos*
-rw-r--r-- 1 root root 671344 May 24 22:54 /usr/local/lib/libtaospyudf.so
ls -l /usr/lib/libtaospyudf.so
```
:::tip
如果自动检测失败，可以通过设置 `PYTHONHOME` 环境变量指定 Python 安装路径：
```shell
export PYTHONHOME=/usr/local/python3.12
```
:::
#### Windows
在 Windows 上，`taosudf.exe` 启动时会自动从系统 PATH 中查找 `python.exe` 并设置 `PYTHONHOME` 环境变量，无需手动配置。
安装包内置单一插件库：`taospyudf.dll`。
只需确保以下两点：
- 系统中已安装 Python 3.10+。可以从 [python.org](https://www.python.org/downloads/) 下载安装。
- 安装 Python 时勾选"Add python.exe to PATH"，或手动将 Python 安装目录加入系统 PATH。
:::tip
如果 `python.exe` 不在 PATH 中（例如使用了免安装版 Python），可以手动设置 `PYTHONHOME` 环境变量指向 Python 安装目录：
```powershell
$env:PYTHONHOME = "C:\Python315"
```
:::
:::note
在 v3.4.1.12 之前的版本中，需要通过 `pip3 install taospyudf` 手动安装 Python UDF 插件。从 v3.4.1.12 起，该步骤不再需要。
:::
### 手动编译 taospyudf（可选）
通常无需手动编译，因为安装包已内置 `taospyudf`。如需调试或二次开发，可在 TDengine 源码树中单独构建该目标。
源文件可从 [GitHub](https://github.com/taosdata/TDengine/tree/main/source/taos-community/source/libs/pyudf/src) 下载。
#### Linux / macOS
Linux 下推荐按以下步骤手动编译（轻量方式，不需要 `cmake` 配置整个仓库）。
```bash
# 1. 安装依赖（Linux）
# Ubuntu/Debian:
sudo apt install python3-dev g++
# CentOS/RHEL:
sudo yum install python3-devel gcc-c++
# 2. 准备头文件（不再需要 pybind11）
# plog：
git clone --depth=1 https://github.com/SergiusTheBest/plog.git /tmp/plog
# Python 头文件通过 python3-config 自动获取
# 3. 编译（在 pyudf 源码目录执行）
cd source/taos-community/source/libs/pyudf/src
g++ -std=c++17 -fPIC -shared taospyudf.cpp \
-o libtaospyudf.so \
-I/tmp/plog/include \
-I/usr/local/taos/include \
-I. \
$(python3-config --includes) \
-Wno-attributes -Wno-deprecated-declarations \
-Wl,--allow-shlib-undefined -ldl
# 4. 安装到系统路径（Linux）
sudo cp libtaospyudf.so /usr/local/taos/driver/
sudo ln -sf /usr/local/taos/driver/libtaospyudf.so /usr/lib/libtaospyudf.so
sudo ldconfig
# 备选方式：在 TDengine 源码树中只构建 taospyudf 目标
cmake -S source/taos-community -B debug -DCMAKE_BUILD_TYPE=Release -DBUILD_PYUDF=ON
cmake --build debug --target taospyudf -j
```
:::note
Linux 产物名为 `libtaospyudf.so`，macOS 产物名为 `libtaospyudf.dylib`。
:::
#### Windows
Windows 下推荐按以下步骤手动编译（轻量方式，不需要 `cmake` 配置整个仓库）。
```powershell
# 1. 安装依赖（Windows）
# - Visual Studio 2019/2022（含“C++ 桌面开发”工作负载）
# - Python 3.10+（建议安装版并加入 PATH）
# 2. 准备头文件
git clone --depth=1 https://github.com/SergiusTheBest/plog.git C:\tmp\plog
# 3. 编译（在 "Developer PowerShell for VS" 中执行）
cd source\taos-community\source\libs\pyudf\src
# 通过 python 获取 include 路径
$pyInc = (python -c "import sysconfig; print(sysconfig.get_path('include'))").Trim()
# 使用 C 接口导出宏并生成 DLL
cl /std:c++17 /EHsc /LD taospyudf.cpp /I C:\tmp\plog\include /I C:\TDengine\include /I . /I "$pyInc" /DBUILDING_DLL /D_CRT_SECURE_NO_WARNINGS /link /OUT:taospyudf.dll
# 4. 安装到系统路径（Windows）
copy taospyudf.dll "C:\TDengine\bin\"
# 备选方式：在 TDengine 源码树中只构建 taospyudf 目标
cmake -S source/taos-community -B debug -G "NMake Makefiles" -DCMAKE_BUILD_TYPE=Release -DBUILD_PYUDF=ON
cmake --build debug --target taospyudf
```
:::note
Windows 产物名为 `taospyudf.dll`。
:::
### 接口定义
当使用 Python 语言开发 UDF 时，需要实现规定的接口函数。具体要求如下。
@ -627,7 +748,7 @@ tail -10 /var/log/taos/taosudf.log
05/24 22:46:28.733561 01665799 UDF ERROR can not load python plugin. lib path libtaospyudf.so
```
错误很明确：没有加载到 Python 插件 libtaospyudf.so，如果遇到此错误，请参考前面的准备环境一节。
错误很明确：没有加载到 Python 插件 libtaospyudf.so。从 v3.4.1.12 起，该插件随 TDengine TSDB 安装包内置。如果遇到此错误，请确认 TDengine TSDB 已正确安装，并执行 `ldconfig` 刷新动态链接库缓存。对于 v3.4.1.12 之前的版本，请通过 `pip3 install taospyudf` 手动安装。
修复环境错误后再次执行，如下。

2
docs/zh/14-reference/01-components/01-taosd.md
View file

@ -1801,7 +1801,7 @@ charset 的有效值是 UTF-8。
- 说明：是否启动 UDF 服务
- 类型：整数；0：不启动，1：启动。
- 默认值：1（windows 上默认值为 0）
- 默认值：1
- 最小值：0
- 最大值：1
- 参数类型：全局配置参数

10
docs/zh/14-reference/02-tools/10-taosbenchmark.md
View file

@ -424,7 +424,7 @@ taosBenchmark -f <json file>
<summary>insert.json</summary>
```json
{{#include /TDengine/tools/taos-tools/example/insert.json}}
{{#include source/taos-community/tools/taos-tools/example/insert.json}}
```
</details>
@ -435,7 +435,7 @@ taosBenchmark -f <json file>
<summary>query.json</summary>
```json
{{#include /TDengine/tools/taos-tools/example/query.json}}
{{#include source/taos-community/tools/taos-tools/example/query.json}}
```
</details>
@ -444,7 +444,7 @@ taosBenchmark -f <json file>
<summary>queryStb.json</summary>
```json
{{#include /TDengine/tools/taos-tools/example/queryStb.json}}
{{#include source/taos-community/tools/taos-tools/example/queryStb.json}}
```
</details>
@ -455,7 +455,7 @@ taosBenchmark -f <json file>
<summary>tmq.json</summary>
```json
{{#include /TDengine/tools/taos-tools/example/tmq.json}}
{{#include source/taos-community/tools/taos-tools/example/tmq.json}}
```
</details>
@ -466,7 +466,7 @@ taosBenchmark -f <json file>
<summary>csv-export.json</summary>
```json
{{#include /TDengine/tools/taos-tools/example/csv-export.json}}
{{#include source/taos-community/tools/taos-tools/example/csv-export.json}}
```
</details>

15
docs/zh/14-reference/02-tools/11-taosgen.md
View file

@ -28,8 +28,8 @@ taosgen 解决了 taosBenchmark 难以灵活配置、数据生成方式单一、
下载二进制发布包到本地，解压缩，为了便捷访问，可以创建符号链接存放到系统执行目录中，如 Linux 系统下执行命令：
```shell
tar zxvf tsgen-v0.3.0-linux-amd64.tar.gz
cd tsgen
tar zxvf taosgen-v0.8.6-linux-x64.tar.gz
cd taosgen
ln -sf `pwd`/taosgen /usr/bin/taosgen
```
@ -58,8 +58,9 @@ taosgen -h 127.0.0.1 -c config.yaml
| -c/--config-file | 指定 yaml 格式配置文件的路径 |
| -d/--log-dir | 指定日志输出目录，默认值为 ./log |
| -o/--log-file | 指定完整的日志文件路径（优先级高于 --log-dir），-f 已弃用 |
| -?/--help | 显示帮助信息并退出|
| -v/--verbose | 提高输出详细程度 |
| -V/--version | 显示版本信息并退出，不能与其它参数混用 |
| -?/--help | 显示帮助信息并退出 |
提示：当没有指定参数运行 taosgen 时，默认会创建 TDengine 数据库 tsbench、超级表 meters、1 万张子表，并为每张子表批量写入 1 万条数据。
@ -238,6 +239,8 @@ taosgen -h 127.0.0.1 -c config.yaml
- random：随机方式生成。
- order：按自然数顺序增长，仅适用整数类型。
- expression：根据表达式生成。适用整数类型、浮点数类型 float、double 和字符类型。
- null_ratio（浮点数）：指定生成 NULL 值的比例，取值范围 [0.0, 1.0]，默认值为 0.0。NULL 表示空值，写入后替换该列的最新值为空。
- none_ratio（浮点数）：指定生成 NONE 值的比例，取值范围 [0.0, 1.0]，默认值为 0.0。NONE 表示数据缺失，写入后不替换该列的最新值，保留原有值。null_ratio 与 none_ratio 之和不得超过 1.0。
##### 数据生成方式详解
@ -327,6 +330,7 @@ taosgen -h 127.0.0.1 -c config.yaml
- stmt：使用参数化写入（Prepared Statement）方式写入数据，适合高性能批量写入场景。
- schemaless：使用行协议（Line Protocol）方式写入数据，无需预先创建超级表和子表，适合模拟 Telegraf 等采集器向 TDengine 发送数据的场景。
- auto_create_table（布尔）：表示是否使用 TDengine 自动建表功能在写入数据时动态创建表，默认值为 false。
- tbname_key（字符串）：仅在 schemaless 格式下生效，用于指定行协议（Line Protocol）输出中代表子表名称的 tag key。如果此参数被设置为空字符串（""），则不在行协议中输出子表名称 tag。默认值为 ""。
- concurrency（整数）：并发写入数据的线程数量，默认值为 8。
- failure_handling：表示失败处理策略：
- max_retries（整数）：最大重试次数，默认值为 0。
@ -367,7 +371,7 @@ taosgen -h 127.0.0.1 -c config.yaml
- `{column}`：表示列数据，column 是列字段名称
- qos（整数）：QoS 等级，取值范围为 0、1、2，默认为 0。
- retain（布尔）：MQTT Broker 是否保留最后一条消息，默认值为 false。
- tbname_key (字符串)：用于指定 json 格式输出中代表表名的字段名称。如果此参数被设置为空字符串 ("")，则不输出表名信息。默认值为 "table"。
- tbname_key (字符串)：用于指定输出中代表表名的字段名称。如果此参数被设置为空字符串（""），则不输出表名信息。默认值为 ""。
- records_per_message（整数）：每条消息包含的记录数，默认为 1。
### 发布 Kafka 数据行动的格式
@ -390,7 +394,7 @@ taosgen -h 127.0.0.1 -c config.yaml
- "1"：生产者只需要等待分区 Leader 副本成功接收到消息并将其写入本地日志（Log），就会认为消息发送成功，并立即向应用程序返回确认。
- "0"：生产者完全不等待任何确认。一旦消息被成功发送到网络（甚至只是放入了生产者的发送缓冲区），就立即认为发送成功。
- compression (字符串)：消息压缩类型，支持 "none"、"gzip"、"snappy"、"lz4"、"zstd"，默认为 "none"。
- tbname_key (字符串)：用于指定 json 格式输出中代表表名的字段名称。如果此参数被设置为空字符串 ("")，则不输出表名信息。默认值为 "table"。
- tbname_key (字符串)：用于指定输出中代表表名的字段名称。在 json 格式中作为 JSON 字段名，在 influx 格式中作为行协议的 tag key。如果此参数被设置为空字符串（""），则不输出表名信息。默认值为 ""。
- records_per_message（整数）：每条消息包含的记录数，默认为 1。
### 写入 InfluxDB 数据行动的格式
@ -404,6 +408,7 @@ taosgen -h 127.0.0.1 -c config.yaml
- precision（字符串）：时间戳精度，可选值为 "ns"、"us"、"ms"、"s"，默认为 "ns"。
- batch_size（整数）：每次 HTTP 请求包含的行协议行数，默认为 5000。InfluxDB 官方推荐值为 5000。
- gzip（布尔）：是否对 HTTP 请求体启用 gzip 压缩，默认为 false。启用后可显著减少网络带宽占用。
- tbname_key（字符串）：用于指定行协议（Line Protocol）输出中代表表名称的 tag key。如果此参数被设置为空字符串（""），则不在行协议中输出表名称 tag。默认值为 ""。
## 配置文件示例

396
docs/zh/14-reference/03-taos-sql/95-timezone.md Normal file
View file

@ -0,0 +1,396 @@
---
sidebar_label: 时区与自然时间单位
title: 时区与自然时间单位
description: TDengine 时区语义与自然时间单位使用说明
toc_max_heading_level: 4
---
本文档描述 TDengine 时区语义与自然时间单位的完整状态。功能分版本交付，文中以版本号标注：
| 标记 | 含义 |
| --- | --- |
| （无标记） | v3.4.1 已支持 |
| **[v3.4.2]** | v3.4.2 起支持 |
| **[v3.4.3]** | v3.4.3 起支持（v3.4.2 中尚不可用） |
---
## 时区概述
TDengine 内部以 UTC 时间戳（int64）存储所有时间数据。时区仅在**时间字符串与 UTC 之间的转换**时起作用：写入时将本地时间字符串转为 UTC，读取时将 UTC 转为本地时间字符串展示。
### 支持的时区格式
| 格式 | 示例 | 夏令时感知 |
| --- | --- | --- |
| IANA 名称 | `'Asia/Shanghai'`、`'America/New_York'` | ✅ 是（自动处理 DST 跳变） |
| 固定偏移 | `'+08:00'`、`'-05:00'`、`'Z'` | ❌ 否（恒定偏移） |
**建议**：涉及夏令时的地区使用 IANA 名称，系统自动处理 DST 切换。
### 时区优先级
TDengine 采用五层时区优先级体系，高层覆盖低层：
| 优先级 | 名称 | 设定方式 | 说明 |
| --- | --- | --- | --- |
| 最高 | SQL 级 | 函数时区参数（如 `TO_ISO8601(ts, '+09:00')`）；`TO_ISO8601` IANA 参数 **[v3.4.2]**；流任务 `TIMEZONE` 子句 **[v3.4.3]** | 仅影响本条 SQL 或本流任务 |
| 高 | 连接级 | C API `taos_options_connection`；`SET TIMEZONE` **[v3.4.2]** | 影响当前连接的所有 SQL |
| 中 | 客户端全局 | 客户端侧 `taos.cfg` 中 `timezone` | 仅影响客户端本地时间展示 |
| 低 | 服务端全局 | 服务端侧 `taos.cfg` 中 `timezone` | 连接未设时区时服务端计算的回退 |
| 最低 | 系统默认 | 操作系统自动检测 | 最终兜底 |
**重要**：客户端全局时区仅影响客户端本地展示（如 `SELECT ts` 的输出格式化），不影响服务端计算。未通过连接级设置时区的连接，服务端计算回退到服务端全局时区。
## 设置时区
### SET TIMEZONE [v3.4.2]
设置当前连接的时区：
```sql
SET TIMEZONE 'Asia/Shanghai';
SET TIMEZONE '+08:00';
SET TIMEZONE 'America/New_York';
```
设置后，该连接上所有读写操作和服务端计算均使用此时区。
也可通过 C API `taos_options_connection` 在建立连接时设置时区，效果等同于 `SET TIMEZONE`。
### 查询当前时区
```sql
SELECT TIMEZONE();
```
返回当前连接生效的时区字符串。**[v3.4.2]** 将同时返回连接级、客户端、服务端时区。
### 配置文件设置
在 `taos.cfg` 中配置全局时区：
```text
timezone Asia/Shanghai
timezone UTC-8
timezone GMT-8
```
支持 IANA 名称和 POSIX 偏移（`UTC±N`/`GMT±N`）两种格式。Windows 下不支持 `UTC-8` 写法，须使用 IANA 名称。未配置时使用操作系统检测的时区。
- **服务端侧** `taos.cfg`：连接未通过 `SET TIMEZONE` 设置时区时，服务端计算回退到此值。
- **客户端侧** `taos.cfg`：仅影响客户端本地时间展示（如 `SELECT ts` 的输出格式化），不影响服务端计算。
**注意**：配置文件不支持 `+08:00` 裸偏移格式（该格式仅限 `SET TIMEZONE` 和函数参数使用）。
## 一周起始日
### SET FIRST_DAY_OF_WEEK [v3.4.2]
设置当前连接的一周起始日：
```sql
SET FIRST_DAY_OF_WEEK 0; -- 周日起始
SET FIRST_DAY_OF_WEEK 1; -- 周一起始（默认）
```
取值范围 0-6:0=周日，1=周一，..., 6=周六。
### 配置文件设置 [v3.4.2]
在服务端侧 `taos.cfg` 中配置：
```text
firstDayOfWeek 1
```
默认值为 1（周一，遵循 ISO 8601）。仅提供服务端配置，不提供客户端配置。
### 影响范围 [v3.4.2]
`firstDayOfWeek` 影响所有以 `w`（周）为单位的操作：
- `TIMETRUNCATE(ts, 1w)` 的对齐日
- `INTERVAL(1w)` 的窗口起始日
- `PERIOD(1w)` 的触发日 **[v3.4.3]**
- `SLIDING(1w)` 的触发日 **[v3.4.3]**
## 时间函数
### TO_ISO8601
```sql
SELECT TO_ISO8601(ts) FROM t; -- 使用连接时区
SELECT TO_ISO8601(ts, '+09:00') FROM t; -- 指定固定偏移
SELECT TO_ISO8601(ts, 'America/New_York') FROM t; -- 指定 IANA 时区 [v3.4.2]
```
使用 IANA 时区时，输出的偏移量随时刻的夏令时状态自动变化：
```sql
SET TIMEZONE 'America/New_York'; -- [v3.4.2]
SELECT TO_ISO8601('2026-01-15 12:00:00'); -- ...T12:00:00-05:00 (EST, 冬令时)
SELECT TO_ISO8601('2026-07-15 12:00:00'); -- ...T12:00:00-04:00 (EDT, 夏令时)
```
### TIMETRUNCATE
将时间戳截断到指定单位边界。
```sql
SELECT TIMETRUNCATE(ts, 1d) FROM t; -- 截断到当天 00:00:00
SELECT TIMETRUNCATE(ts, 1w) FROM t; -- 截断到一周起始日 00:00:00
SELECT TIMETRUNCATE(ts, 1n) FROM t; -- 截断到当月 1 日 [v3.4.2]
SELECT TIMETRUNCATE(ts, 1q) FROM t; -- 截断到当季首月 1 日 [v3.4.2]
SELECT TIMETRUNCATE(ts, 1y) FROM t; -- 截断到当年 1 月 1 日 [v3.4.2]
SELECT TIMETRUNCATE(ts, 1d, 'America/New_York') FROM t; -- 指定时区 [v3.4.2]
```
**支持的自然时间单位**：
| 单位 | 含义 | 截断规则 | 版本 |
| --- | --- | --- | --- |
| `d` | 天 | 对齐到当天 00:00:00 | 已支持 |
| `w` | 周 | 对齐到一周起始日（由 `firstDayOfWeek` 决定）00:00:00 | 已支持，v3.4.2 起尊重 firstDayOfWeek |
| `n` | 月 | 对齐到当月 1 日 00:00:00 | **v3.4.2** |
| `q` | 季度 | 对齐到当季首月 1 日 00:00:00（Q1=1 月，Q2=4 月，Q3=7 月，Q4=10 月） | **v3.4.2** |
| `y` | 年 | 对齐到当年 1 月 1 日 00:00:00 | **v3.4.2** |
**示例**：
```sql
SELECT TIMETRUNCATE('2026-03-15', 1n); -- 2026-03-01 00:00:00 [v3.4.2]
SELECT TIMETRUNCATE('2026-05-15', 1q); -- 2026-04-01 00:00:00 [v3.4.2]
SELECT TIMETRUNCATE('2026-08-15', 1y); -- 2026-01-01 00:00:00 [v3.4.2]
```
**第三参数**（时区）：
| 值 | 行为 | 版本 |
| --- | --- | --- |
| `0` | 使用 UTC（旧语义） | 已支持 |
| `1` | 使用连接时区（旧语义） | 已支持 |
| `'Asia/Shanghai'` | 使用指定 IANA 时区 | **v3.4.2** |
| `'+08:00'` | 使用指定固定偏移 | **v3.4.2** |
| 省略 | 使用连接时区 | 已支持 |
### TIMEZONE()
```sql
SELECT TIMEZONE();
```
同时返回连接级、客户端、服务端三个时区，便于用户排查时区配置问题。**[v3.4.2]** 起增强为同时返回三个层级的时区信息：
- **连接级时区**：通过 `SET TIMEZONE` 或 C API 设置的值，未设置时为空
- **客户端时区**：客户端 `taos.cfg` 配置或系统检测值
- **服务端时区**：服务端 `taos.cfg` 配置或系统检测值
## INTERVAL 查询
`INTERVAL` 支持按自然时间单位切分窗口：
```sql
SELECT _wstart, COUNT(*) FROM meters
INTERVAL(1n) -- 按月切分 [v3.4.2]
FILL(PREV);
SELECT _wstart, AVG(voltage) FROM meters
INTERVAL(1q) -- 按季度切分 [v3.4.2]
FILL(NULL);
SELECT _wstart, SUM(energy) FROM meters
INTERVAL(1w) -- 按周切分（尊重 firstDayOfWeek）[v3.4.2]
FILL(LINEAR);
```
**支持的自然时间单位**：
| 单位 | 窗口边界 | 版本 |
| --- | --- | --- |
| `d` | 本地时区每天 00:00:00 | 已支持 |
| `w` | 本地时区一周起始日 00:00:00（由 `firstDayOfWeek` 决定） | **v3.4.2** |
| `n` | 本地时区每月 1 日 00:00:00 | **v3.4.2** |
| `q` | 本地时区每季度首月 1 日 00:00:00 | **v3.4.2** |
| `y` | 本地时区每年 1 月 1 日 00:00:00 | **v3.4.2** |
**多倍数窗口**：
```sql
INTERVAL(2q) -- 半年窗口：[1 月，7 月), [7 月，次年 1 月) [v3.4.2]
INTERVAL(3n) -- 季度窗口（等价 1q）：1/4/7/10 月 [v3.4.2]
INTERVAL(2w) -- 双周窗口 [v3.4.2]
```
**夏令时处理**：窗口始终按本地挂钟时间对齐。DST 切换日窗口物理时长会变化（如春跳日 1d 窗口为 23 小时），这是正确行为。
**闰年/变长月**：窗口宽度自动适应实际天数（如 2 月窗口 28 或 29 天）。`FILL` 填充边界逐月/逐季推进。
## 流计算时区
### 流任务 TIMEZONE 子句 [v3.4.3]
v3.4.3 之前，流计算触发侧自然时间边界对齐始终使用服务端全局时区，无法为单个流任务指定独立时区。v3.4.3 起新增 `TIMEZONE` 子句，为流任务指定独立时区，适用于**所有触发类型**：
```sql
-- PERIOD 触发：东京时区每周触发
CREATE STREAM weekly_tokyo TRIGGER PERIOD(1w) TIMEZONE 'Asia/Tokyo'
INTO tokyo_weekly AS SELECT AVG(current) FROM meters;
-- SLIDING 触发：纽约时区每季度滑动
CREATE STREAM slide_ny TRIGGER SLIDING(1q) TIMEZONE 'America/New_York'
FROM meters
INTO ny_quarterly AS SELECT _tprev_ts, _tcurrent_ts, AVG(current) FROM %%trows;
-- INTERVAL 触发：伦敦时区月窗口
CREATE STREAM monthly_uk TRIGGER INTERVAL(1n) SLIDING(1w) TIMEZONE 'Europe/London'
FROM meters
INTO uk_monthly AS SELECT _wstart, _wend, AVG(current) FROM %%trows;
-- EVENT 触发：计算侧使用东京时区
CREATE STREAM event_tokyo TRIGGER EVENT_WINDOW(START WITH voltage > 220 END WITH voltage <= 220)
TIMEZONE 'Asia/Tokyo'
FROM meters PARTITION BY tbname
INTO event_out AS SELECT _twstart, _twend, AVG(current) FROM %%trows;
```
**固化行为**：`TIMEZONE` 在创建时固化到流元数据。后续修改全局时区不影响已有流任务。
**未指定 TIMEZONE 时**：按连接时区 → 服务端全局时区 → OS 时区的顺序解析后固化。
### 流计算时区的影响
| 影响位置 | 说明 |
| --- | --- |
| 触发侧（PERIOD/SLIDING/INTERVAL） | 自然单位（d/w/n/q/y）的日历边界对齐使用固化时区 |
| 计算侧（AS subquery） | INTERVAL 自然单位窗口切分使用固化时区和 firstDayOfWeek |
### 流触发自然单位支持
以下表格列出 PERIOD、SLIDING、INTERVAL 三种触发类型支持的时间单位及其版本：
**PERIOD 触发**：
| 单位 | 含义 | 版本 |
| --- | --- | --- |
| `a` | 毫秒 | 已支持 |
| `s` | 秒 | 已支持 |
| `m` | 分钟 | 已支持 |
| `h` | 小时 | 已支持 |
| `d` | 天 | 已支持 |
| `w` | 周 | 已支持 |
| `n` | 月 | 已支持 |
| `y` | 年 | 已支持 |
| `q` | 季度 | **v3.4.3** |
**offset 示例**：
```sql
PERIOD(1w, 1d) -- 每周二 00:00:00 触发
PERIOD(1n, 14d) -- 每月 15 日 00:00:00 触发
PERIOD(1y, 31d) -- 每年 2 月 1 日 00:00:00 触发
PERIOD(1q) -- 每季度首月 1 日 00:00:00 触发 [v3.4.3]
PERIOD(1q, 15d) -- 每季度第 16 日触发 [v3.4.3]
```
**SLIDING 触发**：
| 单位 | 含义 | 版本 |
| --- | --- | --- |
| `a` | 毫秒 | 已支持 |
| `s` | 秒 | 已支持 |
| `m` | 分钟 | 已支持 |
| `h` | 小时 | 已支持 |
| `d` | 天 | 已支持 |
| `w` | 周 | 已支持 |
| `n` | 月 | **v3.4.3** |
| `q` | 季度 | **v3.4.3** |
| `y` | 年 | **v3.4.3** |
```sql
SLIDING(1n) -- 每月滑动触发 [v3.4.3]
SLIDING(1q) -- 每季度滑动触发 [v3.4.3]
SLIDING(1y) -- 每年滑动触发 [v3.4.3]
SLIDING(1q, 15d) -- 每季度第 16 日滑动触发 [v3.4.3]
```
**INTERVAL 窗口触发**（interval_val 和 sliding_val 均适用）：
| 单位 | 含义 | 版本 |
| --- | --- | --- |
| `a` | 毫秒 | 已支持 |
| `s` | 秒 | 已支持 |
| `m` | 分钟 | 已支持 |
| `h` | 小时 | 已支持 |
| `d` | 天 | **v3.4.3** |
| `w` | 周 | **v3.4.3** |
| `n` | 月 | **v3.4.3** |
| `q` | 季度 | **v3.4.3** |
| `y` | 年 | **v3.4.3** |
```sql
INTERVAL(1n) SLIDING(1w) -- 月窗口，每周滑动 [v3.4.3]
INTERVAL(1q) SLIDING(1n) -- 季度窗口，每月滑动 [v3.4.3]
INTERVAL(1y) SLIDING(1q) -- 年窗口，每季度滑动 [v3.4.3]
INTERVAL(1w) SLIDING(1d) -- 周窗口，每天滑动 [v3.4.3]
```
### 查看流任务时区 [v3.4.3]
```sql
SELECT stream_name, timezone, first_day_of_week FROM information_schema.ins_streams;
```
## 各场景时区来源速查
| 场景 | 时区来源 | 版本说明 |
| --- | --- | --- |
| 写入 `INSERT` | 连接 → 服务端全局 → OS | 将时间字符串转为 UTC，已支持 |
| 读取 `SELECT ts` | 连接 → 客户端全局 → OS | 将 UTC 格式化为本地时间；连接级回退为 **v3.4.2** 起支持（此前仅用 OS 时区） |
| 函数（`TO_ISO8601` 等） | SQL 参数 → 连接 → 服务端全局 → OS | 固定偏移参数已支持；IANA 参数为 **v3.4.2** |
| `TIMETRUNCATE` | SQL 参数 → 连接 → 服务端全局 → OS | `d`/`w` 已支持；`n`/`q`/`y` 为 **v3.4.2**；时区字符串参数为 **v3.4.2** |
| `INTERVAL` 查询窗口 | 连接 → 服务端全局 → OS | `d` 已支持；`w`/`n`/`q`/`y` 为 **v3.4.2** |
| `SHOW` / `EXPLAIN` | 连接 → 客户端全局 → OS | 连接级回退为 **v3.4.2** 起支持（此前仅用 OS 时区） |
| 流计算触发与计算 | 服务端全局 → OS；**[v3.4.3]** 起支持 `TIMEZONE` 子句 → 连接 → 服务端全局 → OS（创建时固化） | v3.4.3 前使用服务端时区；v3.4.3 起支持固化 |
## 配置参数一览
| 参数 | 配置文件 | 类型 | 默认值 | 说明 | 版本 |
| --- | --- | --- | --- | --- | --- |
| `timezone` | 服务端/客户端侧 `taos.cfg` | 字符串 | OS 检测 | 全局时区 | 已支持 |
| `firstDayOfWeek` | 服务端侧 `taos.cfg` | 整数 0-6 | 1（周一） | 一周起始日 | **v3.4.2** |
## 错误信息
| 错误场景 | 错误信息 |
| --- | --- |
| 无效时区字符串 | `[0x2600] Invalid timezone: '<value>'` |
| firstDayOfWeek 超出范围 | `[0x2601] Invalid firstDayOfWeek: <value>, must be 0-6` |
## 版本支持矩阵
| 功能 | v3.4.2 之前 | v3.4.2 | v3.4.3 |
| --- | --- | --- | --- |
| `timezone` 配置文件（服务端/客户端） | ✅ | ✅ | ✅ |
| `TO_ISO8601` 固定偏移参数 | ✅ | ✅ | ✅ |
| `TIMETRUNCATE` `d`/`w` 截断 | ✅ | ✅ | ✅ |
| `INTERVAL` 查询 `d` 窗口 | ✅ | ✅ | ✅ |
| `TIMEZONE()` 函数 | ✅ | ✅（增强） | ✅ |
| PERIOD 触发 `a`/`s`/`m`/`h`/`d`/`w`/`n`/`y` | ✅ | ✅ | ✅ |
| SLIDING 触发 `a`/`s`/`m`/`h`/`d`/`w` | ✅ | ✅ | ✅ |
| INTERVAL 窗口触发 `a`/`s`/`m`/`h` | ✅ | ✅ | ✅ |
| `SET TIMEZONE` | ❌ | ✅ | ✅ |
| `SET FIRST_DAY_OF_WEEK` | ❌ | ✅ | ✅ |
| `firstDayOfWeek` 配置参数 | ❌ | ✅ | ✅ |
| `TO_ISO8601` IANA 时区参数 | ❌ | ✅ | ✅ |
| `TIMETRUNCATE` 时区字符串参数 | ❌ | ✅ | ✅ |
| `TIMETRUNCATE` `n`/`q`/`y` 截断 | ❌ | ✅ | ✅ |
| `INTERVAL` 查询 `w`/`n`/`q`/`y` 窗口 | ❌ | ✅ | ✅ |
| 普通列读取使用连接时区 | ❌ | ✅ | ✅ |
| SHOW/EXPLAIN 使用连接时区 | ❌ | ✅ | ✅ |
| 流任务 `TIMEZONE` 子句 | ❌ | ❌ | ✅ |
| 流任务时区/firstDayOfWeek 固化 | ❌ | ❌ | ✅ |
| PERIOD 触发 `q` 季度 | ❌ | ❌ | ✅ |
| SLIDING 触发 `n`/`q`/`y` | ❌ | ❌ | ✅ |
| INTERVAL 窗口触发 `d`/`w`/`n`/`q`/`y` | ❌ | ❌ | ✅ |
| `ins_streams` timezone/first_day_of_week 列 | ❌ | ❌ | ✅ |

18
docs/zh/27-train-faq/01-faq.md
View file

@ -496,7 +496,11 @@ TDengine TSDB 3.3.5.0 之前的版本，只提供以表为统计单位的压缩
TDengine TSDB 3.3.5.0 及以上的版本，还提供了数据库整体压缩率和磁盘空间占用统计。查看数据库整体的数据压缩率和磁盘空间占用的命令为 `SHOW db_name.disk_info;`，查看数据库各个模块的磁盘空间占用的命令为 `SELECT * FROM INFORMATION_SCHEMA.INS_DISK_USAGE WHERE db_name='db_name';`，db_name 为要查看的数据库名称。详细可 [查看此处](https://docs.taosdata.com/reference/taos-sql/database/#%E6%9F%A5%E7%9C%8B%E6%95%B0%E6%8D%AE%E5%BA%93%E7%9A%84%E7%A3%81%E7%9B%98%E7%A9%BA%E9%97%B4%E5%8D%A0%E7%94%A8)
### 6.7 短时间内，通过 systemd 重启 taosd 超过一定次数后重启失败，报错：start-limit-hit
### 6.7 WAL 对存储空间和表观压缩率的影响
WAL（Write-Ahead Log，预写式日志）是 TDengine TSDB 保证数据可靠性的核心机制。所有写入请求在落盘到数据文件之前，均以**原始未压缩格式**写入 WAL。因此，在写入初期，WAL 尚未按策略清理时，其大小可能超过已压缩的数据文件，导致观察到的总存储占用**暂时大于压缩后的数据量**，这是正常现象。随着数据持续写入，历史 WAL 会按配置自动清理，总存储占用将趋于稳定并趋近于实际压缩数据的大小。
### 6.8 短时间内，通过 systemd 重启 taosd 超过一定次数后重启失败，报错：start-limit-hit
问题描述：
TDengine TSDB 3.3.5.1 及以上的版本，taosd.service 的 systemd 配置文件中，StartLimitInterval 参数从 60 秒调整为 900 秒。若在 900 秒内 taosd 服务重启达到 3 次，后续通过 systemd 启动 taosd 服务时会失败，执行 `systemctl status taosd.service` 显示错误：Failed with result 'start-limit-hit'。
@ -507,7 +511,7 @@ TDengine TSDB 3.3.5.1 之前的版本，StartLimitInterval 为 60 秒。若在 6
问题解决：
1）通过 systemd 重启 taosd 服务：推荐方法是先执行命令 `systemctl reset-failed taosd.service` 重置失败计数器，然后再通过 `systemctl restart taosd.service` 重启；若需长期调整，可手动修改 /etc/systemd/system/taosd.service 文件，将 StartLimitInterval 调小或将 StartLimitBurst 调大 (注：重新安装 taosd 会重置该参数，需要重新修改)，执行 `systemctl daemon-reload` 重新加载配置，然后再重启。2）也可以不通过 systemd 而是通过 taosd 命令直接重启 taosd 服务，此时不受 StartLimitInterval 和 StartLimitBurst 参数限制。
### 6.8 我确认修改了配置文件中参数但并没有生效？
### 6.9 我确认修改了配置文件中参数但并没有生效？
问题描述：
TDengine TSDB 3.4.0.0 及以上的版本，有些用户可能会遇到一个问题：我在 `taos.cfg` 中修改了某个配置参数，但是重启后发现并没有生效，查看日志也找不到任何报错。
@ -515,11 +519,11 @@ TDengine TSDB 3.4.0.0 及以上的版本，有些用户可能会遇到一个问
问题原因：
这是由于 TDengine TSDB 3.4.0.0 及以上版本，为了进一步提升 TDengine TSDB 的安全等级，防止恶意篡改配置文件，TDengine TSDB 禁止通过修改配置文件来改变配置参数，请您使用 ALTER 命令，通过 SQL 的方式修改配置参数的值。
### 6.9 如何让 TDengine TSDB crash 时生成 core 文件？
### 6.10 如何让 TDengine TSDB crash 时生成 core 文件？
请看为此问题撰写的 [技术博客](https://www.taosdata.com/blog/2019/12/06/974.html)。
### 6.10 如何在命令行程序 taos 中临时调整日志级别
### 6.11 如何在命令行程序 taos 中临时调整日志级别
为了调试方便，命令行程序 taos 新增了与日志记录相关的指令：
@ -540,11 +544,11 @@ local_option: {
- value 的取值可以是：131（输出错误和警告日志）、135（输出错误、警告和调试日志）、143（输出错误、警告、调试和跟踪日志）。
### 6.11 修改 database 的 root 密码后，Grafana 监控插件 TDinsight 无数据展示
### 6.12 修改 database 的 root 密码后，Grafana 监控插件 TDinsight 无数据展示
TDinsight 插件中展示的数据是通过 taosKeeper 和 taosAdapter 服务收集并存储于 TD 的 log 库中，在 root 密码修改后，需要同步更新 taosKeeper 和 taosAdapter 配置文件中对应的密码信息，然后重启 taosKeeper 和 taosAdapter 服务（注：若是集群需要重启每个节点上的对应服务）。
### 6.12 为什么开源版 TDengine TSDB 的主进程会建立一个与公网的连接？
### 6.13 为什么开源版 TDengine TSDB 的主进程会建立一个与公网的连接？
这个连接只会上报不涉及任何用户数据的最基本信息，用于官方了解产品在世界范围内的分布情况，进而优化产品，提升用户体验，具体采集项目为：集群名、操作系统版本、cpu 信息等。
@ -556,7 +560,7 @@ TDinsight 插件中展示的数据是通过 taosKeeper 和 taosAdapter 服务收
此外，对于安全性要求极高的企业版 TDengine TSDB Enterprise 来说，此参数不会工作。
### 6.13 同一台服务器，数据库的数据目录 dataDir 不变，为什么原有数据库丢失且集群 ID 发生了变化？
### 6.14 同一台服务器，数据库的数据目录 dataDir 不变，为什么原有数据库丢失且集群 ID 发生了变化？
背景知识：TDengine TSDB 服务端进程（taosd）在启动时，若数据目录（dataDir，该目录在配置文件 taos.cfg 中指定）下不存在有效的数据文件子目录（如 mnode、dnode 和 vnode 等），则会自动创建这些目录。在创建新的 mnode 目录的同时，会分配一个新的集群 ID，从而产生一个新的集群。

4
examples/c/CMakeLists.txt
View file

@ -1,6 +1,6 @@
PROJECT(TDengine)
if(${BUILD_TEST})
if(BUILD_TEST)
IF(TD_LINUX)
INCLUDE_DIRECTORIES(. ${TD_SOURCE_DIR}/src/inc ${TD_SOURCE_DIR}/src/client/inc ${TD_SOURCE_DIR}/inc)
@ -80,4 +80,4 @@ IF(TD_DARWIN)
AUX_SOURCE_DIRECTORY(. SRC)
ENDIF()
endif(${BUILD_TEST})
endif()

1
include/client/taos.h
View file

@ -104,7 +104,6 @@ typedef enum TAOS_FIELD_T {
TAOS_FIELD_TAG,
TAOS_FIELD_QUERY,
TAOS_FIELD_TBNAME,
TAOS_FIELD_DB,
} TAOS_FIELD_T;
typedef struct taosField {

1
include/common/streamMsg.h
View file

@ -1011,6 +1011,7 @@ typedef struct SStreamRuntimeFuncInfo {
int64_t groupId;
int32_t curIdx; // for pesudo func calculation
int64_t sessionId;
uint64_t streamGen;
bool withExternalWindow;
bool isWindowTrigger;
int8_t precision;

1
include/common/tmsg.h
View file

@ -4383,6 +4383,7 @@ typedef struct {
uint64_t clientId;
uint64_t taskId;
int32_t execId;
int32_t taskType;
} SQueryContinueReq;
typedef struct {

8
include/libs/executor/executor.h
View file

@ -152,6 +152,13 @@ int32_t qGetTableList(int64_t suid, void* pVnode, void* node, SArray** tableList
*/
int32_t qSetTaskId(qTaskInfo_t tinfo, uint64_t taskId, uint64_t queryId);
bool qTaskIsDone(qTaskInfo_t tinfo);
/**
* Update the worker pool callback for a task to match the current executing
* thread's pool. Defense-in-depth: even if CQuery routing is correct, this
* ensures pWorkerCb always matches the actual executing pool.
*/
void qUpdateWorkerCb(qTaskInfo_t tinfo, void* pWorkerCb);
/**
* Set block for sma
* @param tinfo
@ -312,6 +319,7 @@ int32_t streamCalcOneScalarExpr(SNode* pExpr, SScalarParam* pDst, const SStreamR
int32_t streamCalcOneScalarExprInRange(SNode* pExpr, SScalarParam* pDst, int32_t rowStartIdx, int32_t rowEndIdx, const SStreamRuntimeFuncInfo* pExtraParams);
void cleanupQueryTableDataCond(SQueryTableDataCond* pCond);
void setTaskScalarExtraInfo(qTaskInfo_t tinfo);
void qSetStreamGen(qTaskInfo_t tinfo, uint64_t gen);
int32_t dropStreamTable(SMsgCb* pMsgCb, void* pOutput, SSTriggerDropRequest* pReq);
int32_t dropStreamTableByTbName(SMsgCb* pMsgCb, void* pOutput, SSTriggerDropRequest* pReq, char* tbName);
int32_t qSemWait(qTaskInfo_t pTask, tsem_t* pSem);

6
include/libs/function/taosudf.h
View file

@ -352,6 +352,12 @@ typedef int32_t (*TScriptCloseFunc)();
#define fnInfo(...) {}
#define fnDebug(...) {}
#define fnTrace(...) {}
#define udfFatal(...) {}
#define udfError(...) {}
#define udfWarn(...) {}
#define udfInfo(...) {}
#define udfDebug(...) {}
#define udfTrace(...) {}
#else
DLL_EXPORT void taosPrintLog(const char *flags, int32_t level, int32_t dflag, const char *format, ...)
#ifdef __GNUC__

1
include/libs/nodes/querynodes.h
View file

@ -175,6 +175,7 @@ typedef struct SRemoteValueListNode {
int32_t filterValueType;
STypeMod filterValueTypeMod;
int32_t subQIdx;
uint64_t streamGen; // generation when hash was last built (stream mode)
} SRemoteValueListNode;
typedef struct SRemoteRowNode {

2
include/libs/scalar/scalar.h
View file

@ -31,7 +31,9 @@ typedef struct SScalarExtraInfo {
void* pStreamInfo;
void* pStreamRange;
void* pSubJobCtx;
bool isStream;
sclFetchFromRemote fp;
uint64_t streamGen;
} SScalarExtraInfo;
int32_t scalarGetOperatorResultType(SOperatorNode *pOp);

8
include/os/osSystem.h
View file

@ -48,10 +48,18 @@ void taosCloseCmd(TdCmdPtr *ppCmd);
void *taosLoadDll(const char *fileName);
void *taosLoadDllGlobal(const char *fileName);
void taosCloseDll(void *handle);
void *taosLoadDllFunc(void *handle, const char *funcName);
int32_t taosGetEnv(const char *name, char *buf, int32_t bufLen);
int32_t taosSetEnv(const char *name, const char *value);
int32_t taosSetDllSearchPath(const char *path);
int32_t taosSetConsoleEcho(bool on);
int32_t taosSetTerminalMode();

2
include/util/tgeosctx.h
View file

@ -21,6 +21,8 @@ extern "C" {
#endif
#ifdef USE_GEOS
#include "os.h"
#include <geos_c.h>
#include <tpcre2.h>

422
packaging/pack_community_tar.sh Executable file
View file

@ -0,0 +1,422 @@
#!/bin/bash
#
# pack_community_tar.sh — Generate community edition tar.gz packages (server + client)
#
# Usage:
# ./pack_community_tar.sh -c <compile_dir> -n <version> [-m <compat_version>] [-V <verType>]
#
# Parameters:
# -c Compile directory (cmake build output, e.g. debug/)
# -n Version number (e.g. 3.3.6.0)
# -m Compatible version number (default: 3.0.0.0)
# -V Version type: stable | beta (default: stable)
#
# Output:
# <community_dir>/release/TDengine-server-<ver>-Linux-<arch>.tar.gz
# <community_dir>/release/TDengine-client-<ver>-Linux-<arch>.tar.gz
set -e
# ======================== Default Values ========================
version=""
versionComp="3.0.0.0"
verType="stable"
compile_dir=""
productName="TDengine"
clientName="taos"
serverName="taosd"
configFile="taos.cfg"
# ======================== Parse Arguments ========================
while getopts "hc:n:m:V:" arg; do
case $arg in
c) compile_dir="$OPTARG" ;;
n) version="$OPTARG" ;;
m) versionComp="$OPTARG" ;;
V) verType="$OPTARG" ;;
h)
echo "Usage: $(basename $0) -c <compile_dir> -n <version> [-m <compat_version>] [-V stable|beta]"
echo ""
echo " -c Compile directory (cmake build output, e.g. debug/)"
echo " -n Version number (e.g. 3.3.6.0)"
echo " -m Compatible version number (default: 3.0.0.0)"
echo " -V Version type: stable | beta (default: stable)"
exit 0
;;
?)
echo "Unknown argument. Use -h for help."
exit 1
;;
esac
done
# ======================== Validate Inputs ========================
if [ -z "$compile_dir" ]; then
echo "Error: compile directory (-c) is required"
exit 1
fi
if [ -z "$version" ]; then
echo "Error: version number (-n) is required"
exit 1
fi
# Validate version format: digits and dots only, 3-5 segments
version_pattern='^([0-9]+\.){2,4}[0-9]+$'
if [[ ! "$version" =~ $version_pattern ]]; then
echo "Error: invalid version format '$version' (expected e.g. 3.3.6.0)"
exit 1
fi
if [[ "$verType" != "stable" && "$verType" != "beta" && "$verType" != "preRelease" ]]; then
echo "Error: verType must be 'stable', 'beta', or 'preRelease'"
exit 1
fi
# ======================== Detect Environment ========================
script_dir="$(dirname "$(readlink -f "$0")")"
community_dir="$(readlink -f "${script_dir}/..")"
# Resolve compile_dir to absolute path
if [[ "$compile_dir" != /* ]]; then
compile_dir="$(readlink -f "${community_dir}/${compile_dir}")"
fi
build_dir="${compile_dir}/build"
release_dir="${community_dir}/release"
code_dir="${community_dir}"
cfg_dir="${community_dir}/packaging/cfg"
tools_dir="${community_dir}/packaging/tools"
# Verify build directory exists
if [ ! -d "$build_dir" ]; then
echo "Error: build directory not found: $build_dir"
echo "Please run cmake and make before packaging."
exit 1
fi
# Detect OS type
os_type=$(uname)
if [ "$os_type" != "Linux" ]; then
echo "Error: this script only supports Linux. Detected: $os_type"
exit 1
fi
# Detect CPU architecture
arch_raw=$(uname -m)
case "$arch_raw" in
x86_64) arch="x64" ;;
aarch64) arch="arm64" ;;
arm64) arch="arm64" ;;
mips64*) arch="mips64" ;;
loongarch64) arch="loongarch64" ;;
riscv64) arch="riscv64" ;;
*)
echo "Warning: unrecognized architecture '$arch_raw', using as-is"
arch="$arch_raw"
;;
esac
echo "============================================================"
echo " Community tar.gz Packaging"
echo " Version: ${version}"
echo " Compatible: ${versionComp}"
echo " VerType: ${verType}"
echo " Arch: ${arch} (${arch_raw})"
echo " Build dir: ${build_dir}"
echo " Output dir: ${release_dir}"
echo "============================================================"
# ======================== Verify Required Files ========================
# Required binaries
for bin in ${serverName} ${clientName}; do
if [ ! -f "${build_dir}/bin/${bin}" ]; then
echo "Error: required binary not found: ${build_dir}/bin/${bin}"
exit 1
fi
done
# Required libraries
if [ ! -f "${build_dir}/lib/libtaos.so" ]; then
echo "Error: required library not found: ${build_dir}/lib/libtaos.so"
exit 1
fi
if [ ! -f "${build_dir}/lib/libtaosnative.so" ]; then
echo "Error: required library not found: ${build_dir}/lib/libtaosnative.so"
exit 1
fi
# Required packaging files
for f in \
"${tools_dir}/install.sh" \
"${tools_dir}/install_client.sh" \
"${tools_dir}/remove.sh" \
"${tools_dir}/remove_client.sh" \
"${cfg_dir}/${configFile}"; do
if [ ! -f "$f" ]; then
echo "Error: required packaging file not found: $f"
exit 1
fi
done
# ======================== Helper Functions ========================
# Copy a file if it exists; skip silently otherwise
copy_if_exists() {
local src="$1"
local dst="$2"
if [ -f "$src" ]; then
cp "$src" "$dst"
fi
}
patch_server_install_messages() {
local installer="$1"
# The shared install.sh prints guidance for keeper/explorer/UI unconditionally.
# Community tar packages do not ship those components, so trim the misleading
# guidance from the copied installer.
sed -i \
-e '/To configure \${clientName}-explorer /d' \
-e '/To start \${clientName}keeper /d' \
-e '/To start \${clientName}-explorer /d' \
-e '/Graphic User Interface/d' \
"$installer"
}
# ======================== Build Server Package ========================
echo ""
echo ">>> Building server package..."
server_pkg_name="${productName}-server-${version}"
server_dir="${release_dir}/${server_pkg_name}"
# Clean previous output
rm -rf "${server_dir}"
mkdir -p "${server_dir}"
# --- Inner package: bin/ ---
mkdir -p "${server_dir}/bin"
# Core binaries (required)
cp "${build_dir}/bin/${serverName}" "${server_dir}/bin/"
cp "${build_dir}/bin/${clientName}" "${server_dir}/bin/"
# Optional binaries (may or may not be built)
copy_if_exists "${build_dir}/bin/taosBenchmark" "${server_dir}/bin/"
copy_if_exists "${build_dir}/bin/taosdump" "${server_dir}/bin/"
copy_if_exists "${build_dir}/bin/taosudf" "${server_dir}/bin/"
# Packaging helper scripts
copy_if_exists "${tools_dir}/remove.sh" "${server_dir}/bin/"
copy_if_exists "${tools_dir}/set_core.sh" "${server_dir}/bin/"
copy_if_exists "${tools_dir}/startPre.sh" "${server_dir}/bin/"
copy_if_exists "${tools_dir}/taosd-dump-cfg.gdb" "${server_dir}/bin/"
chmod a+x "${server_dir}/bin/"* 2>/dev/null || :
# --- Inner package: cfg/ ---
mkdir -p "${server_dir}/cfg"
copy_if_exists "${cfg_dir}/${configFile}" "${server_dir}/cfg/"
copy_if_exists "${cfg_dir}/${serverName}.service" "${server_dir}/cfg/"
# --- Inner package: inc/ ---
mkdir -p "${server_dir}/inc"
for header in \
"${code_dir}/include/client/taos.h" \
"${code_dir}/include/common/taosdef.h" \
"${code_dir}/include/util/taoserror.h" \
"${code_dir}/include/util/tdef.h" \
"${code_dir}/include/libs/function/taosudf.h"; do
copy_if_exists "$header" "${server_dir}/inc/"
done
# --- Create inner package.tar.gz ---
echo " Creating inner package.tar.gz..."
cd "${server_dir}"
tar -zcf package.tar.gz bin cfg inc --remove-files
# --- Outer package: driver/ ---
mkdir -p "${server_dir}/driver"
cp "${build_dir}/lib/libtaos.so" "${server_dir}/driver/libtaos.so.${version}"
cp "${build_dir}/lib/libtaosnative.so" "${server_dir}/driver/libtaosnative.so.${version}"
echo "${versionComp}" > "${server_dir}/driver/vercomp.txt"
# --- Outer package: examples/ ---
if [ -d "${code_dir}/examples/c" ]; then
mkdir -p "${server_dir}/examples"
cp -r "${code_dir}/examples/c" "${server_dir}/examples/"
fi
# --- Outer package: install.sh ---
cp "${tools_dir}/install.sh" "${server_dir}/"
sed -i 's/verMode=cluster/verMode=edge/g' "${server_dir}/install.sh" 2>/dev/null || :
patch_server_install_messages "${server_dir}/install.sh"
chmod a+x "${server_dir}/install.sh"
# --- Outer package: start-all.sh / stop-all.sh ---
# Community edition: only taosd service (no taosx/adapter/keeper/explorer)
cat > "${server_dir}/start-all.sh" << 'STARTEOF'
#!/bin/bash
prefix="taos"
versionType="community"
SERVICES=("${prefix}d")
OS_TYPE=$(uname)
start_service() {
local service="$1"
if [ "${OS_TYPE}" = "Linux" ]; then
if [ "$(id -u)" -eq 0 ]; then
systemctl start "${service}" 2>/dev/null && echo "✓ ${service} started" || echo "✗ Failed to start ${service}"
else
systemctl --user start "${service}" 2>/dev/null && echo "✓ ${service} started" || echo "✗ Failed to start ${service}"
fi
fi
}
echo "Starting TDengine Community services..."
for service in "${SERVICES[@]}"; do
start_service "${service}"
done
echo "Done."
STARTEOF
chmod a+x "${server_dir}/start-all.sh"
cat > "${server_dir}/stop-all.sh" << 'STOPEOF'
#!/bin/bash
prefix="taos"
versionType="community"
SERVICES=("${prefix}d")
OS_TYPE=$(uname)
stop_service() {
local service="$1"
if [ "${OS_TYPE}" = "Linux" ]; then
if [ "$(id -u)" -eq 0 ]; then
systemctl stop "${service}" 2>/dev/null && echo "${service} stopped" || echo "Failed to stop ${service}"
else
systemctl --user stop "${service}" 2>/dev/null && echo "${service} stopped" || echo "Failed to stop ${service}"
fi
fi
}
echo "Stopping TDengine Community services..."
for service in "${SERVICES[@]}"; do
stop_service "${service}"
done
echo "Done."
STOPEOF
chmod a+x "${server_dir}/stop-all.sh"
# --- Create outer tar.gz ---
echo " Creating server tar.gz..."
cd "${release_dir}"
if [[ "$verType" == "beta" ]] || [[ "$verType" == "preRelease" ]]; then
server_tar_name="${server_pkg_name}-${verType}-${os_type}-${arch}.tar.gz"
else
server_tar_name="${server_pkg_name}-${os_type}-${arch}.tar.gz"
fi
tar -zcf "${server_tar_name}" "$(basename "$server_dir")" --remove-files
echo " ✓ Server package: ${release_dir}/${server_tar_name}"
# ======================== Build Client Package ========================
echo ""
echo ">>> Building client package..."
client_pkg_name="${productName}-client-${version}"
client_dir="${release_dir}/${client_pkg_name}"
# Clean previous output
rm -rf "${client_dir}"
mkdir -p "${client_dir}"
# --- Inner package: bin/ ---
mkdir -p "${client_dir}/bin"
# Core binary
cp "${build_dir}/bin/${clientName}" "${client_dir}/bin/"
# Optional tools
copy_if_exists "${build_dir}/bin/taosBenchmark" "${client_dir}/bin/"
copy_if_exists "${build_dir}/bin/taosdump" "${client_dir}/bin/"
# Packaging helper scripts
copy_if_exists "${tools_dir}/remove_client.sh" "${client_dir}/bin/"
copy_if_exists "${tools_dir}/set_core.sh" "${client_dir}/bin/"
copy_if_exists "${tools_dir}/get_client.sh" "${client_dir}/bin/"
chmod a+x "${client_dir}/bin/"* 2>/dev/null || :
# --- Inner package: cfg/ ---
mkdir -p "${client_dir}/cfg"
copy_if_exists "${cfg_dir}/${configFile}" "${client_dir}/cfg/"
# --- Inner package: inc/ ---
mkdir -p "${client_dir}/inc"
for header in \
"${code_dir}/include/client/taos.h" \
"${code_dir}/include/common/taosdef.h" \
"${code_dir}/include/util/taoserror.h" \
"${code_dir}/include/util/tdef.h" \
"${code_dir}/include/libs/function/taosudf.h"; do
copy_if_exists "$header" "${client_dir}/inc/"
done
# --- Create inner package.tar.gz ---
echo " Creating inner package.tar.gz..."
cd "${client_dir}"
tar -zcf package.tar.gz bin cfg inc --remove-files
# --- Outer package: driver/ ---
mkdir -p "${client_dir}/driver"
cp "${build_dir}/lib/libtaos.so" "${client_dir}/driver/libtaos.so.${version}"
cp "${build_dir}/lib/libtaosnative.so" "${client_dir}/driver/libtaosnative.so.${version}"
echo "${versionComp}" > "${client_dir}/driver/vercomp.txt"
# --- Outer package: examples/ ---
if [ -d "${code_dir}/examples/c" ]; then
mkdir -p "${client_dir}/examples"
cp -r "${code_dir}/examples/c" "${client_dir}/examples/"
fi
# --- Outer package: install_client.sh ---
cp "${tools_dir}/install_client.sh" "${client_dir}/"
sed -i 's/verMode=cluster/verMode=edge/g' "${client_dir}/install_client.sh" 2>/dev/null || :
chmod a+x "${client_dir}/install_client.sh"
# --- Create outer tar.gz ---
echo " Creating client tar.gz..."
cd "${release_dir}"
if [[ "$verType" == "beta" ]] || [[ "$verType" == "preRelease" ]]; then
client_tar_name="${client_pkg_name}-${verType}-${os_type}-${arch}.tar.gz"
else
client_tar_name="${client_pkg_name}-${os_type}-${arch}.tar.gz"
fi
tar -zcf "${client_tar_name}" "$(basename "$client_dir")" --remove-files
echo " ✓ Client package: ${release_dir}/${client_tar_name}"
# ======================== Summary ========================
echo ""
echo "============================================================"
echo " Packaging complete!"
echo ""
echo " Server: ${release_dir}/${server_tar_name}"
echo " Client: ${release_dir}/${client_tar_name}"
echo ""
ls -lh "${release_dir}/${server_tar_name}" "${release_dir}/${client_tar_name}"
echo "============================================================"

43
packaging/setup_env.sh
View file

@ -47,12 +47,22 @@ REPOPATH="$HOME/repos"
# Define the path to the script directory
SCRIPT_DIR=$(dirname "$(realpath "$0")")
# Locate repo root and builder config directory
REPO_ROOT=$(cd "$SCRIPT_DIR/../../.." && pwd)
BUILDER_DIR="$REPO_ROOT/tools/tsdb-builder"
# Define the path to the .bashrc file
BASH_RC=$HOME/.bashrc
# Define the path to the Cargo configuration file
CARGO_CONFIG_FILE=$HOME/.cargo/config.toml
# Read mirror settings from builder config (single source of truth)
if [ -f "$BUILDER_DIR/.build-args" ]; then
DEFAULT_GOPROXY=$(grep '^GO_PROXY=' "$BUILDER_DIR/.build-args" | cut -d= -f2-)
fi
DEFAULT_GOPROXY="${DEFAULT_GOPROXY:-https://nexus.tdengine.net/repository/goproxy/}"
# Define jmeter version to be installed
JMETER_VERSION="5.6.3"
@ -99,26 +109,21 @@ parse_git_branch() {
export PS1="\u@\h \[\e[32m\]\w \[\e[91m\]\$(parse_git_branch)\[\e[00m\]$ "
EOF
read -r -d '' CARGO_CONFIG <<'EOF'
# Read Cargo config from builder (single source of truth)
if [ -f "$BUILDER_DIR/.cargo/config.toml" ]; then
CARGO_CONFIG=$(cat "$BUILDER_DIR/.cargo/config.toml")
else
read -r -d '' CARGO_CONFIG <<'EOF'
[source.crates-io]
replace-with = 'rsproxy-sparse'
[source.rsproxy]
registry = "https://rsproxy.cn/crates.io-index"
[source.rsproxy-sparse]
registry = "sparse+https://rsproxy.cn/index/"
[registries.rsproxy]
index = "https://rsproxy.cn/crates.io-index"
replace-with = 'internal'
[source.internal]
registry = "sparse+https://nora.tdengine.net/cargo/index/"
[registries.internal]
index = "sparse+https://nora.tdengine.net/cargo/index/"
[net]
git-fetch-with-cli = true
[source.tuna]
registry = "https://mirrors.tuna.tsinghua.edu.cn/git/crates.io-index.git"
[source.ustc]
registry = "git://mirrors.ustc.edu.cn/crates.io-index"
[source.sjtu]
registry = "https://mirrors.sjtug.sjtu.edu.cn/git/crates.io-index"
[source.rustcc]
registry = "git://crates.rustcc.cn/crates.io-index"
EOF
fi
# Help function to display usage information
help() {
@ -983,7 +988,7 @@ install_gvm() {
gvm version
check_status "Failed to install GVM" "GVM installed successfully." $?
add_config_if_not_exist "export GO111MODULE=on" "$BASH_RC"
add_config_if_not_exist "export GOPROXY=https://goproxy.cn,direct" "$BASH_RC"
add_config_if_not_exist "export GOPROXY=${DEFAULT_GOPROXY},direct" "$BASH_RC"
add_config_if_not_exist "export GO_BINARY_BASE_URL=https://mirrors.aliyun.com/golang/" "$BASH_RC"
add_config_if_not_exist "export GOROOT_BOOTSTRAP=$GOROOT" "$BASH_RC"
fi
@ -1103,7 +1108,7 @@ deploy_go() {
add_config_if_not_exist "export GOPATH=$GOPATH_DIR" "$BASH_RC"
add_config_if_not_exist "export PATH=\$PATH:\$GOROOT/bin" "$BASH_RC"
add_config_if_not_exist "export GO111MODULE=on" "$BASH_RC"
add_config_if_not_exist "export GOPROXY=https://goproxy.cn,direct" "$BASH_RC"
add_config_if_not_exist "export GOPROXY=${DEFAULT_GOPROXY},direct" "$BASH_RC"
# Apply the environment variables
$GO_INSTALL_DIR/bin/go version
@ -1122,7 +1127,7 @@ install_go_via_gvm() {
install_gvm
source $HOME/.gvm/scripts/gvm
export GO111MODULE=on
export GOPROXY=https://goproxy.cn,direct
export GOPROXY=${DEFAULT_GOPROXY},direct
export GO_BINARY_BASE_URL=https://mirrors.aliyun.com/golang/
export GOROOT_BOOTSTRAP=$GOROOT

59
packaging/smokeTest/test_community_package_install_messages.sh Executable file
View file

@ -0,0 +1,59 @@
#!/bin/bash
set -euo pipefail
ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../../.." && pwd)"
PACKAGING_DIR="${ROOT_DIR}/source/taos-community/packaging"
RELEASE_DIR="${ROOT_DIR}/source/taos-community/release"
IMAGE="harbor.tdengine.net/tsdb-builder/core:latest-arm64"
VERSION="${VERSION:-3.3.6.0}"
COMPILE_DIR="${COMPILE_DIR:-/work/debug}"
SERVER_PKG="${RELEASE_DIR}/TDengine-server-${VERSION}-Linux-arm64.tar.gz"
RED='\033[0;31m'
GREEN='\033[1;32m'
NC='\033[0m'
fail() {
echo -e "${RED}FAIL${NC}: $1"
exit 1
}
pass() {
echo -e "${GREEN}PASS${NC}: $1"
}
echo "=== verify community package install messages ==="
docker run --rm \
-v "${ROOT_DIR}:/work" \
-w /work/source/taos-community/packaging \
"${IMAGE}" \
bash -lc "./pack_community_tar.sh -c ${COMPILE_DIR} -n ${VERSION}" >/dev/null
if [ ! -f "${SERVER_PKG}" ]; then
fail "expected package not found: ${SERVER_PKG}"
fi
install_output="$(
docker run --rm \
-v "${RELEASE_DIR}:/release" \
"${IMAGE}" \
bash -lc "set -e; rm -rf /tmp/pkg && mkdir -p /tmp/pkg && cd /tmp/pkg && tar -xzf /release/TDengine-server-${VERSION}-Linux-arm64.tar.gz && cd TDengine-server-${VERSION} && bash ./install.sh -s" 2>&1
)"
echo "${install_output}"
if grep -q 'taoskeeper' <<<"${install_output}"; then
fail "install output still mentions taoskeeper"
fi
if grep -q 'taos-explorer' <<<"${install_output}"; then
fail "install output still mentions taos-explorer"
fi
if ! grep -q 'To start TDengine TSDB server' <<<"${install_output}"; then
fail "install output did not include server start guidance"
fi
pass "install output excludes taoskeeper and taos-explorer"

18
packaging/tools/make_install.bat
View file

@ -81,6 +81,9 @@ if exist %binary_dir%\\build\\bin\\taosws.dll (
copy %binary_dir%\\build\\bin\\taosws.dll %target_dir%\\ > nul
copy %binary_dir%\\build\\include\\taosws.h %target_dir%\\include > nul
)
if exist %binary_dir%\\build\\bin\\taospyudf.dll (
copy %binary_dir%\\build\\bin\\taospyudf.dll %target_dir%\\ > nul
)
if exist %binary_dir%\\build\\bin\\taosdump.exe (
copy %binary_dir%\\build\\bin\\taosdump.exe %target_dir% > nul
)
@ -119,17 +122,16 @@ if %Enterprise% == TRUE (
copy %binary_dir%\\build\\bin\\taosd.exe %target_dir% > nul
copy %binary_dir%\\build\\bin\\taosudf.exe %target_dir% > nul
rem // ── Archive PDB files for crash-dump symbolication ──────────────────────
rem // PDBs are NOT shipped to end-users. They must be stored internally,
rem // keyed by version number, so that field crash dumps can be analysed.
rem // Layout: <binary_dir>\symbols\<verNumber>\*.pdb
set pdb_archive=%binary_dir%\\symbols\\%verNumber%
if not exist "%pdb_archive%" mkdir "%pdb_archive%"
for %%f in (%binary_dir%\\build\\bin\\*.pdb) do (
copy "%%f" "%pdb_archive%\\" > nul
if exist "%binary_dir%\\build\\bin\\*.pdb" (
if not exist "%pdb_archive%" mkdir "%pdb_archive%"
copy "%binary_dir%\\build\\bin\\*.pdb" "%pdb_archive%\\" > nul
echo PDB files archived to: %pdb_archive%
)
echo PDB files archived to: %pdb_archive%
rem // ─────────────────────────────────────────────────────────────────────────
if exist %binary_dir%\\build\\bin\\taosadapter.exe (
copy %binary_dir%\\build\\bin\\taosadapter.exe %target_dir% > nul
@ -170,6 +172,9 @@ if exist c:\\windows\\sysnative (
if exist C:\\TDengine\\bin\\taosws.dll (
copy /y C:\\TDengine\\bin\\taosws.dll %windir%\\sysnative > nul
)
if exist C:\\TDengine\\bin\\taospyudf.dll (
copy /y C:\\TDengine\\bin\\taospyudf.dll %windir%\\sysnative > nul
)
) else (
echo x64
copy /y C:\\TDengine\\bin\\taos.dll C:\\Windows\\System32 > nul
@ -178,6 +183,9 @@ if exist c:\\windows\\sysnative (
if exist C:\\TDengine\\bin\\taosws.dll (
copy /y C:\\TDengine\\bin\\taosws.dll C:\\Windows\\System32 > nul
)
if exist C:\\TDengine\\bin\\taospyudf.dll (
copy /y C:\\TDengine\\bin\\taospyudf.dll C:\\Windows\\System32 > nul
)
)
rem // create services

23
packaging/tools/make_install.sh
View file

@ -327,7 +327,7 @@ function install_lib() {
remove_links() {
local dir=$1
if [ -d "$dir" ]; then
for pattern in "libtaos.*" "libtaosnative.*" "libtaosws.*"; do
for pattern in "libtaos.*" "libtaosnative.*" "libtaosws.*" "libtaospyudf.*"; do
${csudo}find "$dir" -name "$pattern" -exec ${csudo}rm -f {} \; || :
done
fi
@ -392,6 +392,19 @@ function install_lib() {
${csudo}ln -sf ${lib64_link_dir}/libtaosws.so.1 ${lib64_link_dir}/libtaosws.so > /dev/null 2>&1
fi
fi
if [ -f ${binary_dir}/build/lib/libtaospyudf.so ]; then
${csudo}cp ${binary_dir}/build/lib/libtaospyudf.so \
${install_main_dir}/driver/libtaospyudf.so.${verNumber} &&
${csudo}chmod 777 ${install_main_dir}/driver/libtaospyudf.so.${verNumber} ||:
${csudo}ln -sf ${install_main_dir}/driver/libtaospyudf.so.${verNumber} ${lib_link_dir}/libtaospyudf.so.1 > /dev/null 2>&1
${csudo}ln -sf ${lib_link_dir}/libtaospyudf.so.1 ${lib_link_dir}/libtaospyudf.so > /dev/null 2>&1
if [ -d "${lib64_link_dir}" ]; then
${csudo}ln -sf ${install_main_dir}/driver/libtaospyudf.so.${verNumber} ${lib64_link_dir}/libtaospyudf.so.1 > /dev/null 2>&1
${csudo}ln -sf ${lib64_link_dir}/libtaospyudf.so.1 ${lib64_link_dir}/libtaospyudf.so > /dev/null 2>&1
fi
fi
else
${csudo}cp -Rf ${binary_dir}/build/lib/libtaos.dylib \
${install_main_dir}/driver/libtaos.${verNumber}.dylib && ${csudo}chmod 777 ${install_main_dir}/driver/*
@ -416,6 +429,14 @@ function install_lib() {
${csudo}ln -sf ${install_main_dir}/driver/libtaosws.${verNumber}.dylib ${lib_link_dir}/libtaosws.dylib > /dev/null 2>&1 || :
fi
if [ -f ${binary_dir}/build/lib/libtaospyudf.dylib ]; then
${csudo}cp ${binary_dir}/build/lib/libtaospyudf.dylib \
${install_main_dir}/driver/libtaospyudf.${verNumber}.dylib &&
${csudo}chmod 777 ${install_main_dir}/driver/libtaospyudf.${verNumber}.dylib ||:
${csudo}ln -sf ${install_main_dir}/driver/libtaospyudf.${verNumber}.dylib ${lib_link_dir}/libtaospyudf.dylib > /dev/null 2>&1 || :
fi
fi
install_jemalloc

15
source/client/CMakeLists.txt
View file

@ -1,16 +1,17 @@
aux_source_directory(src CLIENT_SRC)
if(TD_ENTERPRISE)
LIST(APPEND CLIENT_SRC ${TD_ENTERPRISE_DIR}/src/plugins/view/src/clientView.c)
LIST(APPEND CLIENT_SRC ${TD_ENTERPRISE_DIR}/source/plugins/view/src/clientView.c)
endif()
if(TD_WINDOWS)
add_library(${TAOS_NATIVE_LIB} SHARED ${CLIENT_SRC} ${CMAKE_CURRENT_SOURCE_DIR}/src/taosnative.rc.in)
configure_file(src/taosnative.rc.in "${CMAKE_CURRENT_BINARY_DIR}/taosnative.rc")
add_library(${TAOS_NATIVE_LIB} SHARED ${CLIENT_SRC} "${CMAKE_CURRENT_BINARY_DIR}/taosnative.rc")
else()
add_library(${TAOS_NATIVE_LIB} SHARED ${CLIENT_SRC})
endif()
if(${TD_DARWIN})
if(TD_DARWIN)
target_compile_options(${TAOS_NATIVE_LIB} PRIVATE -Wno-error=deprecated-non-prototype)
endif()
@ -26,7 +27,7 @@ target_include_directories(
PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
)
set(TAOSD_MODULE "")
if(${TAOSD_INTEGRATED})
if(BUILD_TAOSD_INTEGRATED)
set(TAOSD_MODULE "taosd")
endif()
target_link_libraries(
@ -38,7 +39,7 @@ target_link_libraries(
add_library(${TAOS_NATIVE_LIB_STATIC} STATIC ${CLIENT_SRC})
if(${TD_DARWIN})
if(TD_DARWIN)
target_compile_options(${TAOS_NATIVE_LIB_STATIC} PRIVATE -Wno-error=deprecated-non-prototype)
endif()
@ -53,8 +54,8 @@ target_link_libraries(
PUBLIC os util common transport monitor nodes parser command planner catalog scheduler function qcom geometry decimal
)
if(${BUILD_TEST})
if(BUILD_TEST)
ADD_SUBDIRECTORY(test)
endif(${BUILD_TEST})
endif()
ADD_SUBDIRECTORY(wrapper)

2
source/client/inc/clientStmt2.h
View file

@ -261,7 +261,7 @@ int stmtSetTbTags2(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *tags, SVCreateTbRe
int stmtCheckTags2(TAOS_STMT2 *stmt, SVCreateTbReq **pCreateTbReq);
int stmtBindBatch2(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *bind, int32_t colIdx, SVCreateTbReq *pCreateTbReq);
int stmtGetStbColFields2(TAOS_STMT2 *stmt, int *nums, TAOS_FIELD_ALL **fields);
int stmtGetParamNum2(TAOS_STMT2 *stmt, int *nums, TAOS_FIELD_ALL **fields);
int stmtGetParamNum2(TAOS_STMT2 *stmt, int *nums);
bool stmt2IsInsert(TAOS_STMT2 *stmt);
bool stmt2IsSelect(TAOS_STMT2 *stmt);
TAOS_RES *stmtUseResult2(TAOS_STMT2 *stmt);

2
source/client/src/clientMain.c
View file

@ -2983,7 +2983,7 @@ int taos_stmt2_get_fields(TAOS_STMT2 *stmt, int *count, TAOS_FIELD_ALL **fields)
return stmtGetStbColFields2(stmt, count, fields);
}
if (STMT_TYPE_QUERY == pStmt->sql.type || (pStmt->sql.type == 0 && stmt2IsSelect(stmt))) {
return stmtGetParamNum2(stmt, count, fields);
return stmtGetParamNum2(stmt, count);
}
tscError("Invalid sql for stmt %s", pStmt->sql.sqlStr);

4
source/client/src/clientSml.c
View file

@ -1024,7 +1024,7 @@ static int32_t smlCheckMeta(SSchema *schema, int32_t length, SArray *cols) {
SML_CHECK_NULL(kv);
SSchema *sTmp = taosHashGet(hashTmp, kv->key, kv->keyLen);
if (sTmp == NULL) {
SML_CHECK_CODE(TSDB_CODE_SML_INVALID_DATA);
SML_CHECK_CODE(TSDB_CODE_MND_INVALID_SCHEMA_VER);
}
if ((kv->type == TSDB_DATA_TYPE_VARCHAR && kv->length + VARSTR_HEADER_SIZE > sTmp->bytes) ||
(kv->type == TSDB_DATA_TYPE_NCHAR && kv->length * TSDB_NCHAR_SIZE + VARSTR_HEADER_SIZE > sTmp->bytes)) {
@ -1737,7 +1737,7 @@ static int smlProcess(SSmlHandle *info, char *lines[], char *rawLine, char *rawL
do {
code = smlModifyDBSchemas(info);
if (code != TSDB_CODE_TDB_INVALID_TABLE_SCHEMA_VER && code != TSDB_CODE_SDB_OBJ_CREATING && code != TSDB_CODE_SYN_NOT_LEADER &&
code != TSDB_CODE_MND_TRANS_CONFLICT) {
code != TSDB_CODE_MND_TRANS_CONFLICT && code != TSDB_CODE_MND_INVALID_SCHEMA_VER) {
break;
}
taosMsleep(100);

130
source/client/src/clientStmt2.c
View file

@ -1,13 +1,10 @@
#include "clientInt.h"
#include "clientLog.h"
#include "taoserror.h"
#include "tdef.h"
#include "tglobal.h"
#include "tname.h"
#include "clientStmt.h"
#include "clientStmt2.h"
#include "querynodes.h"
#include "tencode.h"
#include "tmsg.h"
#include "tname.h"
@ -925,8 +922,7 @@ static void stmtFreeHeapPatchRowsArray(SArray* aHeapRows) {
}
// After refreshMeta: set sver from catalog; decode each row with inferred old schema and tRowBuild with latest schema.
// aHeapRows: receives pointers from tRowBuild so they can be freed before tDestroySubmitReq (decode path does not free
// rows).
// aHeapRows: receives pointers from tRowBuild so they can be freed before tDestroySubmitReq (decode path does not free rows).
static void stmtPatchOneSubmitTbDataSchemaVer(SSubmitTbData* pTb, SHashObj* pUidMetaHash, SArray* aHeapRows) {
if (pTb->uid == 0) {
return;
@ -994,7 +990,8 @@ static int32_t stmtBuildUidToTableMetaHash(STscStmt2* pStmt, SRequestObj* pReque
}
}
SHashObj* pHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_NO_LOCK);
SHashObj* pHash =
taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_NO_LOCK);
if (pHash == NULL) {
return terrno;
}
@ -1085,9 +1082,9 @@ static int32_t stmtUpdateVgDataBlocksSchemaVer(STscStmt2* pStmt, SRequestObj* pR
continue;
}
SDecoder decoder = {0};
int32_t bodyLen = pVg->size - headSz;
SSubmitReq2 req = {0};
SDecoder decoder = {0};
int32_t bodyLen = pVg->size - headSz;
SSubmitReq2 req = {0};
tDecoderInit(&decoder, (uint8_t*)pVg->pData + headSz, bodyLen);
code = tDecodeSubmitReq(&decoder, &req, NULL);
@ -1305,9 +1302,9 @@ static int32_t stmtFetchOneRetryTbMetaPatch(STscStmt2* pStmt, SRequestObj* pRequ
// 1) Auto-create child: look up by child table name (never use STB-only name without child name).
if (pTb->pCreateTbReq != NULL && pTb->pCreateTbReq->name != NULL) {
SName nm = {0};
int32_t nc = TSDB_CODE_SUCCESS;
STableMeta* pMeta = NULL;
SName nm = {0};
int32_t nc = TSDB_CODE_SUCCESS;
STableMeta* pMeta = NULL;
if (pStmt->bInfo.sname.type != 0) {
tNameAssign(&nm, &pStmt->bInfo.sname);
nc = tNameAddTbName(&nm, pTb->pCreateTbReq->name, strlen(pTb->pCreateTbReq->name));
@ -1344,8 +1341,8 @@ static int32_t stmtFetchOneRetryTbMetaPatch(STscStmt2* pStmt, SRequestObj* pRequ
// 2) request->tableList: align tbIdx with the tbIdx-th non-super-table entry (skip super table names).
if (pRequest->tableList != NULL) {
int32_t nList = (int32_t)taosArrayGetSize(pRequest->tableList);
int32_t nonStbOrd = 0;
int32_t nList = (int32_t)taosArrayGetSize(pRequest->tableList);
int32_t nonStbOrd = 0;
for (int32_t li = 0; li < nList; ++li) {
SName* pName = taosArrayGet(pRequest->tableList, li);
STableMeta* pMeta = NULL;
@ -1416,10 +1413,10 @@ static int32_t stmtUpdateVgDataBlocksTbMetaFromCatalog(STscStmt2* pStmt, SReques
continue;
}
SDecoder decoder = {0};
int32_t bodyLen = pVg->size - headSz;
SSubmitReq2 req = {0};
int32_t code = 0;
SDecoder decoder = {0};
int32_t bodyLen = pVg->size - headSz;
SSubmitReq2 req = {0};
int32_t code = 0;
tDecoderInit(&decoder, (uint8_t*)pVg->pData + headSz, bodyLen);
code = tDecodeSubmitReq(&decoder, &req, NULL);
@ -2451,6 +2448,7 @@ int stmtCheckTags2(TAOS_STMT2* stmt, SVCreateTbReq** pCreateTbReq) {
return TSDB_CODE_SUCCESS;
}
if ((*pDataBlock)->pData->pCreateTbReq) {
STMT2_TLOG_E("tags are fixed, set createTbReq first time");
pStmt->sql.fixValueTags = true;
@ -3307,8 +3305,7 @@ static void asyncQueryCb(void* userdata, TAOS_RES* res, int code) {
retryCode = createParseContext(pNewReq, &pWrapper->pParseCtx, pWrapper);
if (retryCode == TSDB_CODE_SUCCESS) {
pNewReq->syncQuery = false;
// Same as first exec: asyncQueryCb invokes user asyncExecFn once with userdata (not raw pStmt as fp's 1st
// arg).
// Same as first exec: asyncQueryCb invokes user asyncExecFn once with userdata (not raw pStmt as fp's 1st arg).
pNewReq->body.queryFp = asyncQueryCb;
((SSyncQueryParam*)(pNewReq)->body.interParam)->userParam = pStmt;
launchAsyncQuery(pNewReq, pStmt->sql.pQuery, NULL, pWrapper);
@ -3639,93 +3636,7 @@ int stmtGetStbColFields2(TAOS_STMT2* stmt, int* nums, TAOS_FIELD_ALL** fields) {
return stmtFetchStbColFields2(stmt, nums, fields);
}
/* When connection has no default DB (no USE), db may still appear as db.table in SQL. */
static const char* stmtGetDbNameFromPrepareSelect(STscStmt2* pStmt) {
if (pStmt->sql.pQuery == NULL || pStmt->sql.pQuery->pPrepareRoot == NULL) {
return NULL;
}
SNode* pRoot = pStmt->sql.pQuery->pPrepareRoot;
if (QUERY_NODE_SELECT_STMT != nodeType(pRoot)) {
return NULL;
}
SSelectStmt* pSelect = (SSelectStmt*)pRoot;
SNode* pFrom = pSelect->pFromTable;
if (pFrom == NULL) {
return NULL;
}
if (QUERY_NODE_REAL_TABLE == nodeType(pFrom)) {
SRealTableNode* pReal = (SRealTableNode*)pFrom;
if (pReal->table.dbName[0] != '\0') {
return pReal->table.dbName;
}
}
return NULL;
}
static int32_t stmtFillDbPrecisionFieldForQuery(STscStmt2* pStmt, TAOS_FIELD_ALL** fields) {
if (pStmt->exec.pRequest == NULL) {
return TSDB_CODE_TSC_INTERNAL_ERROR;
}
const char* pDbName = pStmt->exec.pRequest->pDb;
if (pDbName == NULL || pDbName[0] == '\0') {
pDbName = pStmt->db;
}
if (pDbName == NULL || pDbName[0] == '\0') {
pDbName = stmtGetDbNameFromPrepareSelect(pStmt);
}
if (pDbName == NULL || pDbName[0] == '\0') {
return TSDB_CODE_PAR_DB_NOT_SPECIFIED;
}
TAOS_FIELD_ALL* pField = taosMemoryCalloc(1, sizeof(TAOS_FIELD_ALL));
if (pField == NULL) {
return terrno;
}
tstrncpy(pField->name, pDbName, sizeof(pField->name));
pField->field_type = TAOS_FIELD_DB;
pField->type = TSDB_DATA_TYPE_NULL; // use null type to avoid unexpected behavior
pField->scale = 0;
pField->bytes = 0;
SDbCfgInfo dbCfg = {0};
int32_t code = TSDB_CODE_SUCCESS;
if (IS_SYS_DBNAME(pDbName)) {
dbCfg.precision = TSDB_TIME_PRECISION_MILLI;
} else {
if (NULL == pStmt->pCatalog) {
code = catalogGetHandle(pStmt->taos->pAppInfo->clusterId, &pStmt->pCatalog);
if (code != TSDB_CODE_SUCCESS) {
taosMemoryFree(pField);
return code;
}
pStmt->sql.siInfo.pCatalog = pStmt->pCatalog;
}
SName name = {0};
char dbFname[TSDB_DB_FNAME_LEN] = {0};
code = tNameSetDbName(&name, pStmt->taos->acctId, pDbName, strlen(pDbName));
if (code != TSDB_CODE_SUCCESS) {
taosMemoryFree(pField);
return code;
}
(void)tNameGetFullDbName(&name, dbFname);
SRequestConnInfo conn = {.pTrans = pStmt->taos->pAppInfo->pTransporter,
.requestId = pStmt->exec.pRequest->requestId,
.requestObjRefId = pStmt->exec.pRequest->self,
.mgmtEps = getEpSet_s(&pStmt->taos->pAppInfo->mgmtEp)};
code = catalogGetDBCfg(pStmt->pCatalog, &conn, dbFname, &dbCfg);
if (code != TSDB_CODE_SUCCESS) {
taosMemoryFree(pField);
return code;
}
}
pField->precision = (uint8_t)dbCfg.precision;
*fields = pField;
return TSDB_CODE_SUCCESS;
}
int stmtGetParamNum2(TAOS_STMT2* stmt, int* nums, TAOS_FIELD_ALL** fields) {
int stmtGetParamNum2(TAOS_STMT2* stmt, int* nums) {
int32_t code = 0;
STscStmt2* pStmt = (STscStmt2*)stmt;
int32_t preCode = pStmt->errCode;
@ -3751,11 +3662,8 @@ int stmtGetParamNum2(TAOS_STMT2* stmt, int* nums, TAOS_FIELD_ALL** fields) {
STMT_ERRI_JRET(stmtParseSql(pStmt));
}
if (STMT_TYPE_QUERY == pStmt->sql.type || (pStmt->sql.type == 0 && stmt2IsSelect(stmt))) {
if (STMT_TYPE_QUERY == pStmt->sql.type) {
*nums = taosArrayGetSize(pStmt->sql.pQuery->pPlaceholderValues);
if (fields != NULL) {
STMT_ERRI_JRET(stmtFillDbPrecisionFieldForQuery(pStmt, fields));
}
} else {
STMT_ERRI_JRET(stmtFetchColFields2(stmt, nums, NULL));
}

14
source/client/src/taos.rc.in
View file

@ -1,6 +1,6 @@
1 VERSIONINFO
FILEVERSION ${TD_VER_NUMBER}
PRODUCTVERSION ${TD_VER_NUMBER}
FILEVERSION ${BUILD_VER_NUMBER_COMMA}
PRODUCTVERSION ${BUILD_VER_NUMBER_COMMA}
FILEFLAGSMASK 0x17L
#ifdef _DEBUG
FILEFLAGS 0x1L
@ -16,12 +16,12 @@ BEGIN
BLOCK "040904b0"
BEGIN
VALUE "FileDescription", "C Driver for TDengine"
VALUE "FileVersion", "${TD_VER_NUMBER}"
VALUE "InternalName", "taos.dll(${TD_VER_CPUTYPE})"
VALUE "LegalCopyright", "Copyright (C) 2025 TAOS Data"
VALUE "FileVersion", "${BUILD_VER_NUMBER}"
VALUE "InternalName", "taos.dll(${BUILD_VER_CPUTYPE})"
VALUE "LegalCopyright", "Copyright (C) 2026 TAOS Data"
VALUE "OriginalFilename", ""
VALUE "ProductName", "taos.dll(${TD_VER_CPUTYPE})"
VALUE "ProductVersion", "${TD_VER_NUMBER}"
VALUE "ProductName", "taos.dll(${BUILD_VER_CPUTYPE})"
VALUE "ProductVersion", "${BUILD_VER_NUMBER}"
END
END
BLOCK "VarFileInfo"

14
source/client/src/taosnative.rc.in
View file

@ -1,6 +1,6 @@
1 VERSIONINFO
FILEVERSION ${TD_VER_NUMBER}
PRODUCTVERSION ${TD_VER_NUMBER}
FILEVERSION ${BUILD_VER_NUMBER_COMMA}
PRODUCTVERSION ${BUILD_VER_NUMBER_COMMA}
FILEFLAGSMASK 0x17L
#ifdef _DEBUG
FILEFLAGS 0x1L
@ -16,12 +16,12 @@ BEGIN
BLOCK "040904b0"
BEGIN
VALUE "FileDescription", "Internal C Driver for TDengine"
VALUE "FileVersion", "${TD_VER_NUMBER}"
VALUE "InternalName", "taosnative.dll(${TD_VER_CPUTYPE})"
VALUE "LegalCopyright", "Copyright (C) 2025 TAOS Data"
VALUE "FileVersion", "${BUILD_VER_NUMBER}"
VALUE "InternalName", "taosnative.dll(${BUILD_VER_CPUTYPE})"
VALUE "LegalCopyright", "Copyright (C) 2026 TAOS Data"
VALUE "OriginalFilename", ""
VALUE "ProductName", "taosnative.dll(${TD_VER_CPUTYPE})"
VALUE "ProductVersion", "${TD_VER_NUMBER}"
VALUE "ProductName", "taosnative.dll(${BUILD_VER_CPUTYPE})"
VALUE "ProductVersion", "${BUILD_VER_NUMBER}"
END
END
BLOCK "VarFileInfo"

2
source/client/test/CMakeLists.txt
View file

@ -108,7 +108,7 @@ TARGET_INCLUDE_DIRECTORIES(
PRIVATE "${TD_SOURCE_DIR}/source/client/inc"
)
IF(${TD_LINUX})
IF(TD_LINUX)
add_test(
NAME clientTest
COMMAND clientTest

18
source/client/test/connectOptionsTest.cpp
View file

@ -39,18 +39,20 @@ int main(int argc, char** argv) {
TAOS* getConnWithGlobalOption(const char *tz){
int code = taos_options(TSDB_OPTION_TIMEZONE, tz);
ASSERT(code == 0);
if (code != 0) return nullptr;
TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
ASSERT(pConn != nullptr);
return pConn;
}
TAOS* getConnWithOption(const char *tz){
TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
ASSERT(pConn != nullptr);
if (pConn == nullptr) return nullptr;
if (tz != NULL){
int code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_TIMEZONE, tz);
ASSERT(code == 0);
if (code != 0) {
taos_close(pConn);
return nullptr;
}
}
return pConn;
}
@ -406,13 +408,13 @@ TEST(connectionCase, setConnectionOption_Test) {
TEST(charsetCase, charset_Test) {
// 1. build connection with different charset
TAOS* pConnGbk = taos_connect("localhost", "root", "taosdata", NULL, 0);
ASSERT(pConnGbk != nullptr);
ASSERT_NE(pConnGbk, nullptr);
TAOS* pConnUTF8 = taos_connect("localhost", "root", "taosdata", NULL, 0);
ASSERT(pConnUTF8 != nullptr);
ASSERT_NE(pConnUTF8, nullptr);
TAOS* pConnDefault = taos_connect("localhost", "root", "taosdata", NULL, 0);
ASSERT(pConnDefault != nullptr);
ASSERT_NE(pConnDefault, nullptr);
int32_t code = taos_options_connection(pConnGbk, TSDB_OPTION_CONNECTION_CHARSET, "gbk");
ASSERT(code == 0);
@ -550,7 +552,7 @@ TEST(charsetCase, charset_Test) {
TEST(charsetCase, alter_charset_Test) {
TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
ASSERT(pConn != nullptr);
ASSERT_NE(pConn, nullptr);
execQueryFail(pConn, "alter dnode 1 'charset gbk'");
execQueryFail(pConn, "local 'charset gbk'");

2
source/client/test/session.cpp
View file

@ -955,7 +955,7 @@ TEST(sessionTest, session1) {
ASSERT(code != 0);
}
SSessParam para = {.type = SESSION_PER_USER, .value = 1};
SSessParam para = {}; para.type = SESSION_PER_USER; para.value = 1;
for (int32_t i = 0; i <= 1000; i++) {
for (int32_t i = 0; i < sizeof(users) / sizeof(users[0]); i++) {
code = sessMgtUpdateUserMetric(users[i], &para);

513
source/client/test/stmt2Test.cpp
View file

@ -58,9 +58,33 @@ void checkError(TAOS_STMT2* stmt, int code, const char* file, int line) {
}
}
typedef struct {
const char* col0;
const char* col1;
const char* col2;
int col0_len;
int col1_len;
int col2_len;
} ExpectedRow;
typedef struct {
const char* col0;
const char* col1;
int col2;
const char* col3;
int col0_len;
int col1_len;
int col3_len;
} ExpectedRow4;
typedef struct AsyncArgs {
int async_affected_rows;
tsem_t sem;
ExpectedRow* expected_rows;
int num_expected_rows;
int current_row_idx;
ExpectedRow4* expected_rows4;
int num_expected_rows4;
} AsyncArgs;
void stmtAsyncQueryCb(void* param, TAOS_RES* pRes, int code) {
@ -123,26 +147,7 @@ void getQueryFields(TAOS* taos, const char* sql, int expectedFieldNum) {
code = taos_stmt2_get_fields(stmt, &fieldNum, NULL);
checkError(stmt, code, __FILE__, __LINE__);
ASSERT_EQ(fieldNum, expectedFieldNum);
taos_stmt2_free_fields(stmt, pFields);
taos_stmt2_close(stmt);
}
void assertStmt2QueryDbPrecisionField(TAOS* taos, const char* sql, int expectedFieldNum, const char* expectedDbName,
uint8_t expectedPrecision) {
TAOS_STMT2_OPTION option = {0};
TAOS_STMT2* stmt = taos_stmt2_init(taos, &option);
ASSERT_NE(stmt, nullptr);
int code = taos_stmt2_prepare(stmt, sql, 0);
checkError(stmt, code, __FILE__, __LINE__);
TAOS_FIELD_ALL* pFields = NULL;
int fieldNum = 0;
code = taos_stmt2_get_fields(stmt, &fieldNum, &pFields);
checkError(stmt, code, __FILE__, __LINE__);
ASSERT_EQ(fieldNum, expectedFieldNum);
ASSERT_EQ(pFields[0].field_type, TAOS_FIELD_DB);
ASSERT_STREQ(pFields[0].name, expectedDbName);
ASSERT_EQ(pFields[0].precision, expectedPrecision);
taos_stmt2_free_fields(stmt, pFields);
taos_stmt2_free_fields(stmt, NULL);
taos_stmt2_close(stmt);
}
@ -288,14 +293,113 @@ void do_stmt(const char* msg, TAOS* taos, TAOS_STMT2_OPTION* option, const char*
TAOS* getConnWithTz(const char* tz) {
TAOS* pConn = taos_connect("localhost", "root", "taosdata", NULL, 0);
ASSERT(pConn != nullptr);
if (pConn == nullptr) return nullptr;
if (tz != NULL) {
int code = taos_options_connection(pConn, TSDB_OPTION_CONNECTION_TIMEZONE, tz);
ASSERT(code == 0);
if (code != 0) {
taos_close(pConn);
return nullptr;
}
}
return pConn;
}
// Helper: prepare a stmt2 SELECT with one TIMESTAMP placeholder, bind tsParam,
// execute, and return the number of rows fetched. Returns -1 on any API error.
int stmtSelectTimestampRowCount(TAOS* taos, const char* sql, int64_t tsParam) {
TAOS_STMT2_OPTION option = {0, true, true, NULL, NULL};
TAOS_STMT2* stmt = taos_stmt2_init(taos, &option);
if (!stmt) return -1;
int code = taos_stmt2_prepare(stmt, sql, 0);
if (code != TSDB_CODE_SUCCESS) {
taos_stmt2_close(stmt);
return -1;
}
// get_fields so the stmt knows the parameter schema
int fieldNum = 0;
TAOS_FIELD_ALL* pFields = NULL;
code = taos_stmt2_get_fields(stmt, &fieldNum, &pFields);
taos_stmt2_free_fields(stmt, pFields);
if (code != TSDB_CODE_SUCCESS) {
taos_stmt2_close(stmt);
return -1;
}
TAOS_STMT2_BIND params = {TSDB_DATA_TYPE_TIMESTAMP, &tsParam, NULL, NULL, 1};
TAOS_STMT2_BIND* paramv = &params;
TAOS_STMT2_BINDV bindv = {1, NULL, NULL, &paramv};
code = taos_stmt2_bind_param(stmt, &bindv, -1);
if (code != TSDB_CODE_SUCCESS) {
taos_stmt2_close(stmt);
return -1;
}
code = taos_stmt2_exec(stmt, NULL);
if (code != TSDB_CODE_SUCCESS) {
taos_stmt2_close(stmt);
return -1;
}
TAOS_RES* pRes = taos_stmt2_result(stmt);
int rows = 0;
if (pRes) {
while (taos_fetch_row(pRes)) rows++;
}
taos_stmt2_close(stmt);
return rows;
}
// Helper: prepare a stmt2 SELECT with two TIMESTAMP placeholders (range style), bind
// both params, execute, and return the number of rows fetched. Returns -1 on API error.
int stmtSelectTimestampRangeRowCount(TAOS* taos, const char* sql, int64_t tsStart, int64_t tsEnd) {
TAOS_STMT2_OPTION option = {0, true, true, NULL, NULL};
TAOS_STMT2* stmt = taos_stmt2_init(taos, &option);
if (!stmt) return -1;
int code = taos_stmt2_prepare(stmt, sql, 0);
if (code != TSDB_CODE_SUCCESS) {
taos_stmt2_close(stmt);
return -1;
}
int fieldNum = 0;
TAOS_FIELD_ALL* pFields = NULL;
code = taos_stmt2_get_fields(stmt, &fieldNum, &pFields);
taos_stmt2_free_fields(stmt, pFields);
if (code != TSDB_CODE_SUCCESS) {
taos_stmt2_close(stmt);
return -1;
}
TAOS_STMT2_BIND params[2] = {{TSDB_DATA_TYPE_TIMESTAMP, &tsStart, NULL, NULL, 1},
{TSDB_DATA_TYPE_TIMESTAMP, &tsEnd, NULL, NULL, 1}};
TAOS_STMT2_BIND* paramv[2] = {&params[0], &params[1]};
TAOS_STMT2_BINDV bindv = {1, NULL, NULL, &paramv[0]};
code = taos_stmt2_bind_param(stmt, &bindv, -1);
if (code != TSDB_CODE_SUCCESS) {
taos_stmt2_close(stmt);
return -1;
}
code = taos_stmt2_exec(stmt, NULL);
if (code != TSDB_CODE_SUCCESS) {
taos_stmt2_close(stmt);
return -1;
}
TAOS_RES* pRes = taos_stmt2_result(stmt);
int rows = 0;
if (pRes) {
while (taos_fetch_row(pRes)) rows++;
}
taos_stmt2_close(stmt);
return rows;
}
} // namespace
int main(int argc, char** argv) {
@ -308,6 +412,7 @@ TEST(stmt2Case, timezone) {
// prepare data and check
{
TAOS* taos = getConnWithTz("UTC-8"); // Asia/Shanghai timezone
ASSERT_NE(taos, nullptr);
do_query(taos, "drop database if exists stmt2_testdb_0");
do_query(taos, "create database IF NOT EXISTS stmt2_testdb_0");
do_query(taos, "create table stmt2_testdb_0.tt (ts timestamp, val int)");
@ -345,6 +450,7 @@ TEST(stmt2Case, timezone) {
// stmt2 with time str in Asia/Shanghai timezone
{
TAOS* taos = getConnWithTz("UTC-8");
ASSERT_NE(taos, nullptr);
do_query(taos, "use stmt2_testdb_0");
TAOS_STMT2_OPTION option = {0, true, true, NULL, NULL};
@ -376,6 +482,7 @@ TEST(stmt2Case, timezone) {
// stmt2 wiht time str in UTC timezone
{
TAOS* taos = getConnWithTz("UTC+0");
ASSERT_NE(taos, nullptr);
do_query(taos, "use stmt2_testdb_0");
TAOS_STMT2_OPTION option = {0, true, true, NULL, NULL};
@ -1030,79 +1137,25 @@ TEST(stmt2Case, insert_ntb_get_fields_Test) {
TEST(stmt2Case, select_get_fields_Test) {
TAOS* taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
ASSERT_NE(taos, nullptr);
do_query(taos, "drop database if exists stmt2_gp_ms");
do_query(taos, "drop database if exists stmt2_gp_us");
do_query(taos, "drop database if exists stmt2_gp_ns");
do_query(taos, "create database stmt2_gp_ms PRECISION 'ms'");
do_query(taos, "create database stmt2_gp_us PRECISION 'us'");
do_query(taos, "create database stmt2_gp_ns PRECISION 'ns'");
do_query(taos, "CREATE TABLE stmt2_gp_ms.ntb(nts timestamp, nb binary(10), nvc varchar(16), ni int)");
do_query(taos, "CREATE TABLE stmt2_gp_us.ntb(nts timestamp, nb binary(10), nvc varchar(16), ni int)");
do_query(taos, "CREATE TABLE stmt2_gp_ns.ntb(nts timestamp, nb binary(10), nvc varchar(16), ni int)");
// case 1 : USE ns, placeholder count
do_query(taos, "use stmt2_gp_ns");
do_query(taos, "drop database if exists stmt2_testdb_5");
do_query(taos, "create database IF NOT EXISTS stmt2_testdb_5 PRECISION 'ns'");
do_query(taos, "use stmt2_testdb_5");
do_query(taos, "CREATE TABLE stmt2_testdb_5.ntb(nts timestamp, nb binary(10),nvc varchar(16),ni int);");
{
const char* sql = "select * from ntb where nts = ?";
// case 1 :
const char* sql = "select * from ntb where ts = ?";
printf("case 1 : %s\n", sql);
getQueryFields(taos, sql, 1);
}
// case 2 : USE ns, two placeholders
{
const char* sql = "select * from ntb where nts = ? and nb = ?";
// case 2 :
const char* sql = "select * from ntb where ts = ? and b = ?";
printf("case 2 : %s\n", sql);
getQueryFields(taos, sql, 2);
}
// case 3 : USE ns, get_fields returns DB precision (nano)
{
const char* sql = "select * from ntb where nts = ?";
printf("case 3 : %s (get_fields DB precision, USE ns)\n", sql);
assertStmt2QueryDbPrecisionField(taos, sql, 1, "stmt2_gp_ns", (uint8_t)TSDB_TIME_PRECISION_NANO);
}
// case 4 : USE us, micro precision
do_query(taos, "use stmt2_gp_us");
{
const char* sql = "select nts, nb from ntb where nts = ?";
printf("case 4 : %s (USE us)\n", sql);
assertStmt2QueryDbPrecisionField(taos, sql, 1, "stmt2_gp_us", (uint8_t)TSDB_TIME_PRECISION_MICRO);
}
// case 5 : USE ms, milli precision
do_query(taos, "use stmt2_gp_ms");
{
const char* sql = "select * from ntb where nts = ?";
printf("case 5 : %s (USE ms)\n", sql);
assertStmt2QueryDbPrecisionField(taos, sql, 1, "stmt2_gp_ms", (uint8_t)TSDB_TIME_PRECISION_MILLI);
}
// case 6-8 : no USE on connection; fully qualified dbname.tbname, expect db from qualifier
{
TAOS* taosNoUse = taos_connect("localhost", "root", "taosdata", NULL, 0);
ASSERT_NE(taosNoUse, nullptr);
{
const char* sql = "select nts from stmt2_gp_ms.ntb where nts = ?";
printf("case 6 : %s (no USE, qualified table, ms)\n", sql);
assertStmt2QueryDbPrecisionField(taosNoUse, sql, 1, "stmt2_gp_ms", (uint8_t)TSDB_TIME_PRECISION_MILLI);
}
{
const char* sql = "select * from stmt2_gp_us.ntb where nts = ? and nb = ?";
printf("case 7 : %s (no USE, qualified table, us)\n", sql);
assertStmt2QueryDbPrecisionField(taosNoUse, sql, 2, "stmt2_gp_us", (uint8_t)TSDB_TIME_PRECISION_MICRO);
}
{
const char* sql = "select nts, nb, ni from stmt2_gp_ns.ntb where nts = ?";
printf("case 8 : %s (no USE, qualified table, ns)\n", sql);
assertStmt2QueryDbPrecisionField(taosNoUse, sql, 1, "stmt2_gp_ns", (uint8_t)TSDB_TIME_PRECISION_NANO);
}
taos_close(taosNoUse);
}
do_query(taos, "drop database if exists stmt2_gp_ms");
do_query(taos, "drop database if exists stmt2_gp_us");
do_query(taos, "drop database if exists stmt2_gp_ns");
do_query(taos, "drop database if exists stmt2_testdb_5");
taos_close(taos);
}
@ -1895,23 +1948,26 @@ TEST(stmt2Case, stmt2_insert_duplicate) {
}
void taos_retrieve_call_back(void* param, TAOS_RES* tres, int numOfRows) {
AsyncArgs* args = (AsyncArgs*)param;
if (numOfRows > 0) {
// synchronous API to retrieve a row from batch of records
TAOS_ROW row = taos_fetch_row(tres);
ASSERT_NE(row, nullptr);
ASSERT_EQ(strncmp((char*)row[0], "tb1", 3), 0);
ASSERT_EQ(strncmp((char*)row[1], "abc", 3), 0);
ASSERT_EQ(strncmp((char*)row[2], "abc", 3), 0);
for (int i = 0; i < numOfRows; i++) {
TAOS_ROW row = taos_fetch_row(tres);
ASSERT_NE(row, nullptr);
ASSERT_LT(args->current_row_idx, args->num_expected_rows);
row = taos_fetch_row(tres);
ASSERT_NE(row, nullptr);
ASSERT_EQ(strncmp((char*)row[0], "tb2", 3), 0);
ASSERT_EQ(strncmp((char*)row[1], "xyz", 3), 0);
ASSERT_EQ(strncmp((char*)row[2], "abc", 3), 0);
ExpectedRow* expected = &args->expected_rows[args->current_row_idx];
ASSERT_EQ(strncmp((char*)row[0], expected->col0, expected->col0_len), 0);
ASSERT_EQ(strncmp((char*)row[1], expected->col1, expected->col1_len), 0);
ASSERT_EQ(strncmp((char*)row[2], expected->col2, expected->col2_len), 0);
args->current_row_idx++;
}
taos_fetch_rows_a(tres, taos_retrieve_call_back, param);
} else {
ASSERT_EQ(tsem_post(&((AsyncArgs*)param)->sem), TSDB_CODE_SUCCESS);
ASSERT_EQ(args->current_row_idx, args->num_expected_rows);
ASSERT_EQ(tsem_post(&args->sem), TSDB_CODE_SUCCESS);
}
}
@ -1987,6 +2043,14 @@ TEST(stmt2Case, query) {
aa->async_affected_rows = 0;
ASSERT_EQ(tsem_init(&aa->sem, 0, 0), TSDB_CODE_SUCCESS);
ExpectedRow expected_rows[2] = {
{"tb1", "abc", "abc", 3, 3, 3},
{"tb2", "xyz", "abc", 3, 3, 3},
};
aa->expected_rows = expected_rows;
aa->num_expected_rows = 2;
aa->current_row_idx = 0;
TAOS_STMT2_OPTION option = {0, true, true, asyncExec, (void*)aa};
TAOS_STMT2* stmt = taos_stmt2_init(taos, &option);
@ -2009,6 +2073,8 @@ TEST(stmt2Case, query) {
TAOS_STMT2_BINDV bindv = {1, NULL, NULL, &paramv};
for (int i = 0; i < 3; i++) {
aa->current_row_idx = 0;
code = taos_stmt2_bind_param(stmt, &bindv, -1);
checkError(stmt, code, __FILE__, __LINE__);
@ -2189,7 +2255,13 @@ TEST(stmt2Case, query_use_adapter) {
aa->async_affected_rows = 0;
ASSERT_EQ(tsem_init(&aa->sem, 0, 0), TSDB_CODE_SUCCESS);
TAOS_STMT2_OPTION option = {0, true, true, stmtAsyncQueryCb, (void*)aa};
// Setup expected results
ExpectedRow expected_rows[2] = {{"tb1", "abc", "abc", 3, 3, 3}, {"tb2", "xyz", "abc", 3, 3, 3}};
aa->expected_rows = expected_rows;
aa->num_expected_rows = 2;
aa->current_row_idx = 0;
TAOS_STMT2_OPTION option = {0, true, true, asyncExec, (void*)aa};
TAOS_STMT2* stmt = taos_stmt2_init(taos, &option);
ASSERT_NE(stmt, nullptr);
@ -2198,18 +2270,19 @@ TEST(stmt2Case, query_use_adapter) {
int code = taos_stmt2_prepare(stmt, sql, 0);
checkError(stmt, code, __FILE__, __LINE__);
for (int i = 0; i < 3; i++) {
int fieldNum = 0;
TAOS_FIELD_ALL* pFields = NULL;
code = taos_stmt2_get_fields(stmt, &fieldNum, &pFields);
checkError(stmt, code, __FILE__, __LINE__);
ASSERT_EQ(fieldNum, 1);
int fieldNum = 0;
TAOS_FIELD_ALL* pFields = NULL;
code = taos_stmt2_get_fields(stmt, &fieldNum, &pFields);
checkError(stmt, code, __FILE__, __LINE__);
ASSERT_EQ(fieldNum, 1);
int t64_len = sizeof(int64_t);
int64_t ts = 1591060628000;
TAOS_STMT2_BIND params = {TSDB_DATA_TYPE_TIMESTAMP, &ts, &t64_len, NULL, 1};
TAOS_STMT2_BIND* paramv = &params;
TAOS_STMT2_BINDV bindv = {1, NULL, NULL, &paramv};
int t64_len = sizeof(int64_t);
int64_t ts = 1591060628000;
TAOS_STMT2_BIND params = {TSDB_DATA_TYPE_TIMESTAMP, &ts, &t64_len, NULL, 1};
TAOS_STMT2_BIND* paramv = &params;
TAOS_STMT2_BINDV bindv = {1, NULL, NULL, &paramv};
for (int i = 0; i < 3; i++) {
code = taos_stmt2_bind_param(stmt, &bindv, -1);
checkError(stmt, code, __FILE__, __LINE__);
@ -2217,19 +2290,8 @@ TEST(stmt2Case, query_use_adapter) {
checkError(stmt, code, __FILE__, __LINE__);
tsem_wait(&aa->sem);
// don't suggest to use taosMsleep for this async query, use taos_fetch_rows_a in practice
taosMsleep(3000);
TAOS_RES* pRes = taos_stmt2_result(stmt);
ASSERT_NE(pRes, nullptr);
TAOS_ROW row = taos_fetch_row(pRes);
ASSERT_NE(row, nullptr);
ASSERT_EQ(strncmp((char*)row[0], "tb1", 3), 0);
ASSERT_EQ(strncmp((char*)row[1], "abc", 3), 0);
ASSERT_EQ(strncmp((char*)row[2], "abc", 3), 0);
row = taos_fetch_row(pRes);
ASSERT_NE(row, nullptr);
taos_free_result(pRes);
aa->current_row_idx = 0;
tsem_init(&aa->sem, 0, 0);
}
tsem_destroy(&aa->sem);
@ -2250,6 +2312,34 @@ void asyncSelectError(void* param, TAOS_RES* pRes, int code) {
ASSERT_EQ(tsem_post(&((AsyncArgs*)param)->sem), TSDB_CODE_SUCCESS);
}
void asyncSelectRetrieveCb(void* param, TAOS_RES* pRes, int numOfRows) {
AsyncArgs* aa = (AsyncArgs*)param;
if (numOfRows > 0) {
for (int i = 0; i < numOfRows; ++i) {
TAOS_ROW row = taos_fetch_row(pRes);
ASSERT_NE(row, nullptr);
ASSERT_LT(aa->current_row_idx, aa->num_expected_rows4);
ExpectedRow4* expected = &aa->expected_rows4[aa->current_row_idx];
ASSERT_EQ(strncmp((char*)row[0], expected->col0, expected->col0_len), 0);
ASSERT_EQ(strncmp((char*)row[1], expected->col1, expected->col1_len), 0);
ASSERT_EQ(*(int*)row[2], expected->col2);
ASSERT_EQ(strncmp((char*)row[3], expected->col3, expected->col3_len), 0);
aa->current_row_idx++;
}
taos_fetch_rows_a(pRes, asyncSelectRetrieveCb, param);
return;
}
ASSERT_EQ(aa->current_row_idx, aa->num_expected_rows4);
aa->async_affected_rows = aa->current_row_idx;
ASSERT_EQ(tsem_post(&aa->sem), TSDB_CODE_SUCCESS);
}
void asyncSelectExecAndFetch(void* param, TAOS_RES* pRes, int code) {
ASSERT_EQ(code, TSDB_CODE_SUCCESS);
taos_fetch_rows_a(pRes, asyncSelectRetrieveCb, param);
}
TEST(stmt2Case, query_error) {
TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0);
ASSERT_NE(taos, nullptr);
@ -2337,22 +2427,39 @@ TEST(stmt2Case, query_error) {
tsem_wait(&aa->sem);
tsem_destroy(&aa->sem);
taosMemoryFree(aa);
// correct usage 2 : sync fetch in async query
pRes = taos_stmt2_result(stmt);
ASSERT_NE(pRes, nullptr);
TAOS_ROW row = taos_fetch_row(pRes);
ASSERT_NE(row, nullptr);
ASSERT_EQ(strncmp((char*)row[0], "tb1", 3), 0);
ASSERT_EQ(strncmp((char*)row[1], "abc", 3), 0);
ASSERT_EQ(*(int*)row[2], 1);
ASSERT_EQ(strncmp((char*)row[3], "abc", 3), 0);
row = taos_fetch_row(pRes);
ASSERT_NE(row, nullptr);
ASSERT_EQ(strncmp((char*)row[0], "tb2", 3), 0);
ASSERT_EQ(strncmp((char*)row[1], "abc", 3), 0);
ASSERT_EQ(*(int*)row[2], 2);
ASSERT_EQ(strncmp((char*)row[3], "xyz", 3), 0);
// correct usage 2 : async fetch rows in callback
AsyncArgs* aa2 = (AsyncArgs*)taosMemoryMalloc(sizeof(AsyncArgs));
aa2->async_affected_rows = 0;
aa2->current_row_idx = 0;
ExpectedRow4 expected_rows4[2] = {{"tb1", "abc", 1, "abc", 3, 3, 3}, {"tb2", "abc", 2, "xyz", 3, 3, 3}};
aa2->expected_rows4 = expected_rows4;
aa2->num_expected_rows4 = 2;
ASSERT_EQ(tsem_init(&aa2->sem, 0, 0), TSDB_CODE_SUCCESS);
TAOS_STMT2_OPTION option2 = {0, true, true, asyncSelectExecAndFetch, (void*)aa2};
TAOS_STMT2* stmt2 = taos_stmt2_init(taos, &option2);
ASSERT_NE(stmt2, nullptr);
code = taos_stmt2_prepare(stmt2, "select tbname,b,t1,t2 from stmt2_testdb_27.stb where ts = ? order by tbname", 0);
checkError(stmt2, code, __FILE__, __LINE__);
fieldNum = 0;
code = taos_stmt2_get_fields(stmt2, &fieldNum, NULL);
checkError(stmt2, code, __FILE__, __LINE__);
ASSERT_EQ(fieldNum, 1);
code = taos_stmt2_bind_param(stmt2, &bindv, -1);
checkError(stmt2, code, __FILE__, __LINE__);
code = taos_stmt2_exec(stmt2, NULL);
checkError(stmt2, code, __FILE__, __LINE__);
tsem_wait(&aa2->sem);
ASSERT_EQ(aa2->async_affected_rows, 2);
tsem_destroy(&aa2->sem);
taosMemoryFree(aa2);
taos_stmt2_close(stmt2);
do_query(taos, "drop database if exists stmt2_testdb_7");
taos_stmt2_close(stmt);
@ -4178,6 +4285,12 @@ void stmtAsyncQueryCb3(void* param, TAOS_RES* pRes, int code) {
return;
}
void stmtAsyncExecRetryCb(void* param, TAOS_RES* pRes, int code) {
AsyncArgs* args = (AsyncArgs*)param;
args->async_affected_rows = code;
ASSERT_EQ(tsem_post(&args->sem), TSDB_CODE_SUCCESS);
}
TEST(stmt2Case, exec_retry) {
TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0);
ASSERT_NE(taos, nullptr);
@ -4210,7 +4323,7 @@ TEST(stmt2Case, exec_retry) {
checkError(stmt, code, __FILE__, __LINE__);
// wait async bind finish
taosMsleep(2000);
taosMsleep(500);
do_query(taos, "drop table if exists stmt2_testdb_21.tb1");
code = taos_stmt2_exec(stmt, NULL);
@ -4267,7 +4380,9 @@ TEST(stmt2Case, exec_retry) {
do_query(taos,
"create table stmt2_testdb_21.ntb (ts timestamp, b binary(10),exec_retry_meta_col int)");
TAOS_STMT2_OPTION optionAlter = {0, true, true, stmtAsyncQueryCb2, NULL};
AsyncArgs args = {0, 0};
ASSERT_EQ(tsem_init(&args.sem, 0, 0), TSDB_CODE_SUCCESS);
TAOS_STMT2_OPTION optionAlter = {0, true, true, stmtAsyncExecRetryCb, &args};
TAOS_STMT2* stmtAlter = taos_stmt2_init(taos, &optionAlter);
ASSERT_NE(stmtAlter, nullptr);
@ -4290,7 +4405,8 @@ TEST(stmt2Case, exec_retry) {
code = taos_stmt2_exec(stmtAlter, NULL);
checkError(stmtAlter, code, __FILE__, __LINE__);
taosMsleep(2000);
tsem_wait(&args.sem);
ASSERT_EQ(args.async_affected_rows, TSDB_CODE_SUCCESS);
TAOS_RES* result = taos_query(taos, "select ts,b from stmt2_testdb_21.ntb");
ASSERT_NE(result, nullptr);
@ -4304,6 +4420,7 @@ TEST(stmt2Case, exec_retry) {
taos_free_result(result);
taos_stmt2_close(stmtAlter);
tsem_destroy(&args.sem);
}
// Schema / meta change between bind and exec (ALTER STABLE), sync mode.
@ -4447,15 +4564,9 @@ TEST(stmt2Case, exec_retry) {
code = taos_stmt2_bind_param(stmtAlter, &bindvAlter, -1);
checkError(stmtAlter, code, __FILE__, __LINE__);
taosMsleep(3000);
taosMsleep(1000);
do_query(taos, "drop table if exists stmt2_testdb_21.tb4");
do_query(taos, "create table stmt2_testdb_21.tb4 using stmt2_testdb_21.stb tags(1, 'after')");
// Force the vnode to apply the DROP+CREATE before the INSERT arrives: query the
// new tb4 so the vnode processes all pending operations. Without this, the INSERT
// may reach the vnode while it still has the OLD tb4 uid (race condition), succeed
// silently against the old row-set, and then lose the data when the DROP is applied.
do_query(taos, "select ts from stmt2_testdb_21.tb4 limit 1");
taosMsleep(3000);
do_query(taos, "create table if not exists stmt2_testdb_21.tb4 using stmt2_testdb_21.stb tags(1, 'after')");
int affected_rows = 0;
code = taos_stmt2_exec(stmtAlter, &affected_rows);
@ -5944,4 +6055,112 @@ TEST(stmt2Case, stmt2_decimal_blob_interleaved) {
taos_close(taos);
}
TEST(stmt2Case, query_timestamp_auto_precision) {
TAOS* taos = taos_connect("localhost", "root", "taosdata", "", 0);
ASSERT_NE(taos, nullptr);
// Three representative timestamp values — all denote the same instant:
// 2023-11-14 22:13:20 UTC
const int64_t TS_MS = 1700000000000LL; // 13 digits → auto-detected as ms
const int64_t TS_US = 1700000000000000LL; // 16 digits → auto-detected as us
const int64_t TS_NS = 1700000000000000000LL; // 19 digits → auto-detected as ns
// ── Setup: one table per precision ────────────────────────────────────────
do_query(taos, "drop database if exists stmt2_ts_auto_ms");
do_query(taos, "drop database if exists stmt2_ts_auto_us");
do_query(taos, "drop database if exists stmt2_ts_auto_ns");
do_query(taos, "create database stmt2_ts_auto_ms precision 'ms'");
do_query(taos, "create database stmt2_ts_auto_us precision 'us'");
do_query(taos, "create database stmt2_ts_auto_ns precision 'ns'");
do_query(taos, "create table stmt2_ts_auto_ms.t (ts timestamp, v int)");
do_query(taos, "create table stmt2_ts_auto_us.t (ts timestamp, v int)");
do_query(taos, "create table stmt2_ts_auto_ns.t (ts timestamp, v int)");
// Insert using the natural precision of each database
do_query(taos, "insert into stmt2_ts_auto_ms.t values(1700000000000, 1)");
do_query(taos, "insert into stmt2_ts_auto_us.t values(1700000000000000, 1)");
do_query(taos, "insert into stmt2_ts_auto_ns.t values(1700000000000000000, 1)");
// ── Same-precision queries ────────────────────────────────────────────────
ASSERT_EQ(stmtSelectTimestampRowCount(taos, "select * from stmt2_ts_auto_ms.t where ts = ?", TS_MS), 1);
ASSERT_EQ(stmtSelectTimestampRowCount(taos, "select * from stmt2_ts_auto_us.t where ts = ?", TS_US), 1);
ASSERT_EQ(stmtSelectTimestampRowCount(taos, "select * from stmt2_ts_auto_ns.t where ts = ?", TS_NS), 1);
// ── Cross-precision: ms value into us / ns DB ─────────────────────────────
ASSERT_EQ(stmtSelectTimestampRowCount(taos, "select * from stmt2_ts_auto_us.t where ts = ?", TS_MS), 1);
ASSERT_EQ(stmtSelectTimestampRowCount(taos, "select * from stmt2_ts_auto_ns.t where ts = ?", TS_MS), 1);
// ── Cross-precision: us value into ms / ns DB ─────────────────────────────
ASSERT_EQ(stmtSelectTimestampRowCount(taos, "select * from stmt2_ts_auto_ms.t where ts = ?", TS_US), 1);
ASSERT_EQ(stmtSelectTimestampRowCount(taos, "select * from stmt2_ts_auto_ns.t where ts = ?", TS_US), 1);
// ── Cross-precision: ns value into ms / us DB ─────────────────────────────
ASSERT_EQ(stmtSelectTimestampRowCount(taos, "select * from stmt2_ts_auto_ms.t where ts = ?", TS_NS), 1);
ASSERT_EQ(stmtSelectTimestampRowCount(taos, "select * from stmt2_ts_auto_us.t where ts = ?", TS_NS), 1);
// ── Sanity: a slightly off ms value must not match ────────────────────────
ASSERT_EQ(stmtSelectTimestampRowCount(taos, "select * from stmt2_ts_auto_ms.t where ts = ?", TS_MS + 1), 0);
// ── Range predicate regression: placeholders must be converted before timeRange extraction ──
// This specifically guards against "WHERE fixed but pSelect->timeRange still stale".
ASSERT_EQ(stmtSelectTimestampRangeRowCount(taos, "select * from stmt2_ts_auto_us.t where ts >= ? and ts <= ?", TS_MS,
TS_MS),
1);
ASSERT_EQ(stmtSelectTimestampRangeRowCount(taos, "select * from stmt2_ts_auto_ns.t where ts >= ? and ts <= ?", TS_MS,
TS_MS),
1);
ASSERT_EQ(stmtSelectTimestampRangeRowCount(taos, "select * from stmt2_ts_auto_ms.t where ts >= ? and ts <= ?", TS_US,
TS_US),
1);
// ── stmt2(v2) early-return path regression ────────────────────────────────
// translateWhere() returns early for stmtBindVersion==2. The placeholder
// precision fix must still run before that return. These assertions guard
// that behavior explicitly.
ASSERT_EQ(stmtSelectTimestampRangeRowCount(taos, "select * from stmt2_ts_auto_us.t where ts >= ? and ts <= ?", TS_MS,
TS_MS),
1);
ASSERT_EQ(stmtSelectTimestampRangeRowCount(taos, "select * from stmt2_ts_auto_ns.t where ts >= ? and ts <= ?", TS_US,
TS_US),
1);
ASSERT_EQ(stmtSelectTimestampRangeRowCount(taos, "select * from stmt2_ts_auto_us.t where ts >= ? and ts <= ?",
TS_MS + 1, TS_MS + 1),
0);
// ── Cross-database queries ────────────────────────────────────────────────
// sub-case A: current-db = ms → query us and ns
do_query(taos, "use stmt2_ts_auto_ms");
ASSERT_EQ(stmtSelectTimestampRowCount(taos, "select * from stmt2_ts_auto_us.t where ts = ?", TS_MS), 1);
ASSERT_EQ(stmtSelectTimestampRowCount(taos, "select * from stmt2_ts_auto_ns.t where ts = ?", TS_MS), 1);
ASSERT_EQ(stmtSelectTimestampRangeRowCount(taos, "select * from stmt2_ts_auto_us.t where ts >= ? and ts <= ?", TS_MS,
TS_MS),
1);
ASSERT_EQ(stmtSelectTimestampRangeRowCount(taos, "select * from stmt2_ts_auto_ns.t where ts >= ? and ts <= ?", TS_MS,
TS_MS),
1);
// Fully-qualified reference to current-db itself must still work
ASSERT_EQ(stmtSelectTimestampRowCount(taos, "select * from stmt2_ts_auto_ms.t where ts = ?", TS_MS), 1);
// sub-case B: current-db = us → query ms and ns
do_query(taos, "use stmt2_ts_auto_us");
ASSERT_EQ(stmtSelectTimestampRowCount(taos, "select * from stmt2_ts_auto_ms.t where ts = ?", TS_US), 1);
ASSERT_EQ(stmtSelectTimestampRowCount(taos, "select * from stmt2_ts_auto_ns.t where ts = ?", TS_US), 1);
ASSERT_EQ(stmtSelectTimestampRangeRowCount(taos, "select * from stmt2_ts_auto_ms.t where ts >= ? and ts <= ?", TS_US,
TS_US),
1);
ASSERT_EQ(stmtSelectTimestampRangeRowCount(taos, "select * from stmt2_ts_auto_ns.t where ts >= ? and ts <= ?", TS_US,
TS_US),
1);
// sub-case C: current-db = ns → query ms and us with ns-resolution placeholder
do_query(taos, "use stmt2_ts_auto_ns");
ASSERT_EQ(stmtSelectTimestampRowCount(taos, "select * from stmt2_ts_auto_ms.t where ts = ?", TS_NS), 1);
ASSERT_EQ(stmtSelectTimestampRowCount(taos, "select * from stmt2_ts_auto_us.t where ts = ?", TS_NS), 1);
// ── Cleanup ───────────────────────────────────────────────────────────────
do_query(taos, "drop database if exists stmt2_ts_auto_ms");
do_query(taos, "drop database if exists stmt2_ts_auto_us");
do_query(taos, "drop database if exists stmt2_ts_auto_ns");
taos_close(taos);
}
#pragma GCC diagnostic pop

15
source/client/wrapper/CMakeLists.txt
View file

@ -1,13 +1,20 @@
aux_source_directory(src WRAPPER_SRC)
if(TD_WINDOWS)
add_library(${TAOS_LIB} SHARED ${WRAPPER_SRC} ${CMAKE_CURRENT_SOURCE_DIR}/../src/taos.rc.in)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/../src/taos.rc.in "${CMAKE_CURRENT_BINARY_DIR}/taos.rc")
add_library(${TAOS_LIB} SHARED ${WRAPPER_SRC} "${CMAKE_CURRENT_BINARY_DIR}/taos.rc")
else()
add_library(${TAOS_LIB} SHARED ${WRAPPER_SRC})
endif()
if(${TD_DARWIN})
if(TD_DARWIN)
target_compile_options(${TAOS_LIB} PRIVATE -Wno-error=deprecated-non-prototype)
# Suppress ld64 duplicate static library warnings from deep transitive deps.
include(CheckLinkerFlag)
check_linker_flag(C "-Wl,-no_warn_duplicate_libraries" HAVE_NO_WARN_DUP_LIBS)
if(HAVE_NO_WARN_DUP_LIBS)
target_link_options(${TAOS_LIB} PRIVATE -Wl,-no_warn_duplicate_libraries)
endif()
endif()
# jni include
@ -33,7 +40,7 @@ target_link_libraries(
add_library(${TAOS_LIB_STATIC} STATIC ${WRAPPER_SRC})
if(${TD_DARWIN})
if(TD_DARWIN)
target_compile_options(${TAOS_LIB_STATIC} PRIVATE -Wno-error=deprecated-non-prototype)
endif()
@ -50,4 +57,4 @@ target_link_libraries(
# if(${BUILD_TEST})
# ADD_SUBDIRECTORY(test)
# endif(${BUILD_TEST})
# endif()

22
source/common/CMakeLists.txt
View file

@ -5,7 +5,7 @@ LIST(APPEND COMMON_SRC ${COMMON_MSG_SRC})
LIST(APPEND COMMON_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/dmRepair.c)
if(TD_ENTERPRISE)
LIST(APPEND COMMON_SRC ${TD_ENTERPRISE_DIR}/src/plugins/common/src/tglobal.c)
LIST(APPEND COMMON_SRC ${TD_ENTERPRISE_DIR}/source/plugins/common/src/tglobal.c)
endif()
add_library(common STATIC ${COMMON_SRC})
@ -26,7 +26,7 @@ if(DEFINED GRANT_CFG_INCLUDE_DIR)
add_definitions(-DGRANTS_CFG)
endif()
if(${BUILD_WITH_ANALYSIS})
if(BUILD_WITH_ANALYSIS)
add_definitions(-DUSE_ANALYTICS)
endif()
@ -40,9 +40,9 @@ if(TD_STORAGE)
endif()
if(TD_ENTERPRISE)
if(${BUILD_WITH_S3})
if(BUILD_WITH_S3)
add_definitions(-DUSE_S3)
ELSEIF(${BUILD_WITH_COS})
ELSEIF(BUILD_WITH_COS)
add_definitions(-DUSE_COS)
endif()
endif()
@ -56,7 +56,7 @@ target_include_directories(
PRIVATE "${GRANT_CFG_INCLUDE_DIR}"
)
if(${TD_WINDOWS})
if(TD_WINDOWS)
# This is the Windows Shell32 library, needed by RocksDB
find_library(SHLWAPI_LIBRARY NAMES shlwapi)
if(SHLWAPI_LIBRARY)
@ -98,17 +98,17 @@ else()
DEP_ext_ssl(common)
endif()
if(${BUILD_SHARED_STORAGE})
if(BUILD_SHARED_STORAGE)
add_definitions(-DUSE_SHARED_STORAGE)
if(${BUILD_WITH_S3})
if(BUILD_WITH_S3)
DEP_ext_libs3(common)
DEP_ext_curl(common)
DEP_ext_libxml2(common)
add_definitions(-DUSE_S3)
endif()
if(${BUILD_WITH_COS})
if(BUILD_WITH_COS)
MESSAGE("shared storage does not support COS at present, please use s3 instead")
# set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
@ -140,9 +140,9 @@ if(${BUILD_SHARED_STORAGE})
# include_directories(${APR_INCLUDE_DIR})
# add_definitions(-DUSE_COS)
endif(${BUILD_WITH_COS})
endif()
endif()
if(${BUILD_TEST})
if(BUILD_TEST)
ADD_SUBDIRECTORY(test)
endif(${BUILD_TEST})
endif()

4
source/common/src/msg/streamMsg.c
View file

@ -4221,6 +4221,7 @@ int32_t tSerializeStRtFuncInfo(SEncoder* pEncoder, const SStreamRuntimeFuncInfo*
TAOS_CHECK_EXIT(tEncodeI32(pEncoder, pInfo->triggerType));
TAOS_CHECK_EXIT(tEncodeBool(pEncoder, pInfo->isWindowTrigger));
TAOS_CHECK_EXIT(tEncodeI8(pEncoder, pInfo->precision));
TAOS_CHECK_EXIT(tEncodeU64(pEncoder, pInfo->streamGen));
_exit:
return code;
}
@ -4325,6 +4326,9 @@ int32_t tDeserializeStRtFuncInfo(SDecoder* pDecoder, SStreamRuntimeFuncInfo* pIn
TAOS_CHECK_EXIT(tDecodeBool(pDecoder, &pInfo->isWindowTrigger));
TAOS_CHECK_EXIT(tDecodeI8(pDecoder, &pInfo->precision));
}
if (!tDecodeIsEnd(pDecoder)) {
TAOS_CHECK_EXIT(tDecodeU64(pDecoder, &pInfo->streamGen));
}
_exit:
return code;
}

17
source/common/src/tglobal.c
View file

@ -435,10 +435,10 @@ bool tsIfAdtFse = false; // ADT-FSE algorithom or origina
char tsCompressor[32] = "ZSTD_COMPRESSOR"; // ZSTD_COMPRESSOR or GZIP_COMPRESSOR
// udf
#if defined(WINDOWS) || !defined(USE_UDF)
bool tsStartUdfd = false;
#else
#ifdef USE_UDF
bool tsStartUdfd = true;
#else
bool tsStartUdfd = false;
#endif
// wal
@ -2686,7 +2686,7 @@ int32_t readCfgFile(const char *path, bool isGlobal) {
array = taosGetLocalCfg(tsCfg);
snprintf(filename, sizeof(filename), "%s%sdnode%sconfig%slocal.json", path, TD_DIRSEP, TD_DIRSEP, TD_DIRSEP);
}
uInfo("start to read config file:%s", filename);
uInfo("load config file:%s", filename);
if (!taosCheckExistFile(filename)) {
uInfo("config file:%s does not exist", filename);
@ -3606,6 +3606,7 @@ int32_t taosGranted(int8_t type) {
int32_t globalConfigSerialize(int32_t version, SArray *array, char **serialized) {
char buf[30];
char *pSerialized = NULL;
cJSON *json = cJSON_CreateObject();
if (json == NULL) goto _exit;
if (cJSON_AddNumberToObject(json, "file_version", GLOBAL_CONFIG_FILE_VERSION) == NULL) goto _exit;
@ -3650,7 +3651,7 @@ int32_t globalConfigSerialize(int32_t version, SArray *array, char **serialized)
}
}
}
char *pSerialized = tjsonToString(json);
pSerialized = tjsonToString(json);
_exit:
if (terrno != TSDB_CODE_SUCCESS) {
uError("failed to serialize global config since %s", tstrerror(terrno));
@ -3662,6 +3663,7 @@ _exit:
int32_t localConfigSerialize(SArray *array, char **serialized) {
char buf[30];
char *pSerialized = NULL;
cJSON *json = cJSON_CreateObject();
if (json == NULL) goto _exit;
@ -3735,7 +3737,7 @@ int32_t localConfigSerialize(SArray *array, char **serialized) {
}
}
}
char *pSerialized = tjsonToString(json);
pSerialized = tjsonToString(json);
_exit:
if (terrno != TSDB_CODE_SUCCESS) {
uError("failed to serialize local config since %s", tstrerror(terrno));
@ -3747,6 +3749,7 @@ _exit:
int32_t stypeConfigSerialize(SArray *array, char **serialized) {
char buf[30];
char *pSerialized = NULL;
cJSON *json = cJSON_CreateObject();
if (json == NULL) goto _exit;
@ -3763,7 +3766,7 @@ int32_t stypeConfigSerialize(SArray *array, char **serialized) {
SConfigItem *item = (SConfigItem *)taosArrayGet(array, i);
if (cJSON_AddNumberToObject(cField, item->name, item->stype) == NULL) goto _exit;
}
char *pSerialized = tjsonToString(json);
pSerialized = tjsonToString(json);
_exit:
if (terrno != TSDB_CODE_SUCCESS) {
uError("failed to serialize local config since %s", tstrerror(terrno));

4
source/common/test/CMakeLists.txt
View file

@ -4,7 +4,7 @@ MESSAGE(STATUS "build parser unit test")
# GoogleTest requires at least C++11
SET(CMAKE_CXX_STANDARD 11)
if(${TD_LINUX})
if(TD_LINUX)
add_executable(commonTest "commonTests.cpp")
DEP_ext_gtest(commonTest)
target_link_libraries(commonTest PRIVATE os util common)
@ -77,7 +77,7 @@ add_test(
# )
# endif()
if(${TD_LINUX})
if(TD_LINUX)
# tmsg test
add_executable(tmsgTest "")
DEP_ext_gtest(tmsgTest)

7
source/common/test/dataformatTest.cpp
View file

@ -455,11 +455,14 @@ TEST(testCase, tColDataGetValue) {
SColVal pColVal = {0};
ASSERT_NE(tColDataGetValue(&pColData, 0, &pColVal),0);
pColData = {.flag = 8};
memset(&pColData, 0, sizeof(pColData));
pColData.flag = 8;
pColVal = {0};
ASSERT_NE(tColDataGetValue(&pColData, 0, &pColVal),0);
pColData = {.nVal = 1, .flag = 8};
memset(&pColData, 0, sizeof(pColData));
pColData.nVal = 1;
pColData.flag = 8;
ASSERT_NE(tColDataGetValue(&pColData, 0, &pColVal),0);
}
#endif

14
source/dnode/mgmt/CMakeLists.txt
View file

@ -10,7 +10,7 @@ add_subdirectory(mgmt_dnode)
add_subdirectory(test)
aux_source_directory(exe EXEC_SRC)
if(${TAOSD_INTEGRATED})
if(BUILD_TAOSD_INTEGRATED)
add_library(taosd ${EXEC_SRC})
else()
add_executable(taosd ${EXEC_SRC})
@ -22,10 +22,18 @@ target_include_directories(
target_link_libraries(taosd PUBLIC dnode crypt)
if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
include(CheckLinkerFlag)
check_linker_flag(C "-Wl,-no_warn_duplicate_libraries" HAVE_NO_WARN_DUP_LIBS)
if(HAVE_NO_WARN_DUP_LIBS)
target_link_options(taosd PRIVATE -Wl,-no_warn_duplicate_libraries)
endif()
endif()
if(TD_ENTERPRISE)
if(${BUILD_WITH_S3})
if(BUILD_WITH_S3)
add_definitions(-DUSE_S3)
elseif(${BUILD_WITH_COS})
elseif(BUILD_WITH_COS)
add_definitions(-DUSE_COS)
endif()
endif()

8
source/dnode/mgmt/mgmt_dnode/CMakeLists.txt
View file

@ -5,14 +5,14 @@ if(DEFINED GRANT_CFG_INCLUDE_DIR)
add_definitions(-DGRANTS_CFG)
endif()
if(NOT BUILD_DM_MODULE)
MESSAGE(STATUS "NOT BUILD_DM_MODULE")
if(NOT TD_DM_MODULE)
MESSAGE(STATUS "NOT TD_DM_MODULE")
target_link_directories(
mgmt_dnode
PUBLIC "${TD_SOURCE_DIR}/deps/${TD_DEPS_DIR}/dm_static"
)
else()
MESSAGE(STATUS "BUILD_DM_MODULE")
MESSAGE(STATUS "TD_DM_MODULE Enabled")
endif()
target_include_directories(
@ -25,7 +25,7 @@ if(TD_ENTERPRISE)
# Include taosk headers for encryption key management (now using community CBC encryption)
target_include_directories(
mgmt_dnode
PRIVATE "${TD_ENTERPRISE_DIR}/src/plugins/taosk/inc"
PRIVATE "${TD_ENTERPRISE_DIR}/source/plugins/taosk/inc"
)
endif()

17
source/dnode/mgmt/mgmt_mnode/src/mmWorker.c
View file

@ -15,6 +15,8 @@
#define _DEFAULT_SOURCE
#include "mmInt.h"
#include "query.h"
#include "executor.h"
#include "streamMsg.h"
#include "stream.h"
#include "streamReader.h"
@ -227,7 +229,16 @@ int32_t mmPutMsgToQueue(SMnodeMgmt *pMgmt, EQueueType qtype, SRpcMsg *pRpc) {
pWorker = &pMgmt->writeWorker;
break;
case QUERY_QUEUE:
pWorker = &pMgmt->queryWorker;
if (pRpc->msgType == TDMT_SCH_QUERY_CONTINUE) {
SQueryContinueReq *pReq = (SQueryContinueReq *)pRpc->pCont;
if (pReq != NULL && pReq->taskType == TASK_TYPE_HQUERY) {
pWorker = &pMgmt->mqueryWorker;
} else {
pWorker = &pMgmt->queryWorker;
}
} else {
pWorker = &pMgmt->queryWorker;
}
break;
case FETCH_QUEUE:
pWorker = &pMgmt->fetchWorker;
@ -342,6 +353,10 @@ static int32_t mmProcessStreamFetchMsg(SMnodeMgmt *pMgmt, SRpcMsg* pMsg) {
STREAM_CHECK_NULL_GOTO(pResList, terrno);
uint64_t ts = 0;
bool hasNext = false;
// Init thread_local scalar ctx; mnode workers may not have set it for
// this task, breaking scalar-subquery re-fetch on later events.
qSetStreamGen(sStreamReaderCalcInfo->pTaskInfo, sStreamReaderCalcInfo->rtInfo.funcInfo.streamGen);
setTaskScalarExtraInfo(sStreamReaderCalcInfo->pTaskInfo);
STREAM_CHECK_RET_GOTO(qExecTaskOpt(sStreamReaderCalcInfo->pTaskInfo, pResList, &ts, &hasNext, NULL, true));
for(size_t i = 0; i < taosArrayGetSize(pResList); i++){

2
source/dnode/mgmt/mgmt_snode/CMakeLists.txt
View file

@ -1,7 +1,7 @@
aux_source_directory(src MGMT_SNODE)
add_library(mgmt_snode STATIC ${MGMT_SNODE})
if(${TD_DARWIN})
if(TD_DARWIN)
target_compile_options(mgmt_snode PRIVATE -Wno-error=deprecated-non-prototype)
endif()

2
source/dnode/mgmt/mgmt_vnode/CMakeLists.txt
View file

@ -1,7 +1,7 @@
aux_source_directory(src MGMT_VNODE)
add_library(mgmt_vnode STATIC ${MGMT_VNODE})
if(${TD_DARWIN})
if(TD_DARWIN)
target_compile_options(mgmt_vnode PRIVATE -Wno-error=deprecated-non-prototype)
endif()

2
source/dnode/mgmt/mgmt_xnode/src/xmInt.c
View file

@ -18,7 +18,7 @@
#include "xmInt.h"
static int32_t xmRequire(const SMgmtInputOpt *pInput, bool *required) {
xndInfo("xnode require call path:%s, name:%s", pInput->path, pInput->name);
xndInfo("xnode call path:%s, name:%s", pInput->path, pInput->name);
*required = true;
return TSDB_CODE_SUCCESS;
}

6
source/dnode/mgmt/node_mgmt/CMakeLists.txt
View file

@ -10,9 +10,9 @@ if(TD_ENTERPRISE)
endif()
IF(TD_ENTERPRISE)
IF(${BUILD_WITH_S3})
IF(BUILD_WITH_S3)
add_definitions(-DUSE_S3)
ELSEIF(${BUILD_WITH_COS})
ELSEIF(BUILD_WITH_COS)
add_definitions(-DUSE_COS)
ENDIF()
ENDIF()
@ -30,6 +30,6 @@ if(TD_ENTERPRISE)
# Include taosk headers for encryption key management
target_include_directories(
dnode
PRIVATE "${TD_ENTERPRISE_DIR}/src/plugins/taosk/inc"
PRIVATE "${TD_ENTERPRISE_DIR}/source/plugins/taosk/inc"
)
endif()

2
source/dnode/mgmt/node_util/CMakeLists.txt
View file

@ -9,7 +9,7 @@ if(TD_ENTERPRISE)
# Include taosk headers for encryption key management (now using community CBC encryption)
target_include_directories(
node_util
PRIVATE "${TD_ENTERPRISE_DIR}/src/plugins/taosk/inc"
PRIVATE "${TD_ENTERPRISE_DIR}/source/plugins/taosk/inc"
)
endif()

4
source/dnode/mgmt/node_util/src/dmFile.c
View file

@ -609,7 +609,7 @@ int32_t dmGetEncryptKeyFromTaosk() {
// Check if master.bin exists
if (!taosCheckExistFile(masterKeyFile)) {
dInfo("taosk master key file not found: %s, encryption not configured", masterKeyFile);
dInfo("loading encryption keys, taosk master key file not found: %s, encryption not configured", masterKeyFile);
return TSDB_CODE_DNODE_INVALID_ENCRYPT_CONFIG;
}
@ -721,7 +721,7 @@ int32_t dmGetEncryptKey() {
if (!taosCheckExistFile(encryptFile)) {
code = TSDB_CODE_DNODE_INVALID_ENCRYPT_CONFIG;
dInfo("no exist, checkCode file:%s", encryptFile);
dInfo("encryption key file not exist, checkCode file:%s", encryptFile);
return 0;
}

4
source/dnode/mgmt/test/CMakeLists.txt
View file

@ -1,8 +1,8 @@
if(${BUILD_TEST})
if(BUILD_TEST)
enable_testing()
add_subdirectory(qnode)
add_subdirectory(snode)
#add_subdirectory(mnode)
add_subdirectory(vnode)
add_subdirectory(sut)
endif(${BUILD_TEST})
endif()

30
source/dnode/mnode/impl/CMakeLists.txt
View file

@ -5,23 +5,23 @@ if(TD_PRIVILEGE)
endif()
if(TD_ENTERPRISE)
LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/src/plugins/privilege/src/privilege.c)
LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/src/plugins/mnode/src/mndDb.c)
LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/src/plugins/mnode/src/mndVgroup.c)
LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/src/plugins/mnode/src/mndDnode.c)
LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/src/plugins/view/src/mndView.c)
LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/src/plugins/mnode/src/mndMount.c)
LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/src/plugins/token/src/mndTokenImpl.c)
LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/src/plugins/xnode/src/mndXnodeImpl.c)
LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/source/plugins/privilege/src/privilege.c)
LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/source/plugins/mnode/src/mndDb.c)
LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/source/plugins/mnode/src/mndVgroup.c)
LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/source/plugins/mnode/src/mndDnode.c)
LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/source/plugins/view/src/mndView.c)
LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/source/plugins/mnode/src/mndMount.c)
LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/source/plugins/token/src/mndTokenImpl.c)
LIST(APPEND MNODE_SRC ${TD_ENTERPRISE_DIR}/source/plugins/xnode/src/mndXnodeImpl.c)
if(${BUILD_WITH_S3})
if(BUILD_WITH_S3)
add_definitions(-DUSE_S3)
ELSEIF(${BUILD_WITH_COS})
ELSEIF(BUILD_WITH_COS)
add_definitions(-DUSE_COS)
endif()
endif()
if(${BUILD_WITH_ANALYSIS})
if(BUILD_WITH_ANALYSIS)
add_definitions(-DUSE_ANALYTICS)
endif()
@ -35,13 +35,13 @@ target_include_directories(
PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/inc"
PUBLIC "${TD_SOURCE_DIR}/source/libs/totp/inc"
"${TD_SOURCE_DIR}/include/libs/txnode/inc"
PRIVATE "${TD_ENTERPRISE_DIR}/src/plugins/privilege/inc"
PRIVATE "${TD_ENTERPRISE_DIR}/source/plugins/privilege/inc"
)
if(TD_ENTERPRISE)
target_include_directories(
mnode
PRIVATE "${TD_ENTERPRISE_DIR}/src/plugins/taosk/inc"
PRIVATE "${TD_ENTERPRISE_DIR}/source/plugins/taosk/inc"
)
endif()
target_link_libraries(
@ -57,6 +57,6 @@ if(TD_GRANT)
ADD_DEFINITIONS(-D_GRANT)
endif()
if(${BUILD_TEST})
if(BUILD_TEST)
add_subdirectory(test)
endif(${BUILD_TEST})
endif()

14
source/dnode/mnode/impl/inc/mndStream.h
View file

@ -128,13 +128,13 @@ static const char* gMndStreamState[] = {"X", "W", "N"};
#define MST_LIST_SIZE(_l) ((_l) ? TD_DLIST_NELES(_l) : 0)
// clang-format off
#define mstFatal(...) do { if (stDebugFlag & DEBUG_FATAL) { taosPrintLog("MSTM FATAL ", DEBUG_FATAL, 255, __VA_ARGS__); }} while(0)
#define mstError(...) do { if (stDebugFlag & DEBUG_ERROR) { taosPrintLog("MSTM ERROR ", DEBUG_ERROR, 255, __VA_ARGS__); }} while(0)
#define mstWarn(...) do { if (stDebugFlag & DEBUG_WARN) { taosPrintLog("MSTM WARN ", DEBUG_WARN, 255, __VA_ARGS__); }} while(0)
#define mstInfo(...) do { if (stDebugFlag & DEBUG_INFO) { taosPrintLog("MSTM INFO ", DEBUG_INFO, 255, __VA_ARGS__); }} while(0)
#define mstDebug(...) do { if (stDebugFlag & DEBUG_DEBUG) { taosPrintLog("MSTM DEBUG ", DEBUG_DEBUG, stDebugFlag, __VA_ARGS__); }} while(0)
#define mstDebugL(...) do { if (stDebugFlag & DEBUG_DEBUG) { taosPrintLongString("MSTM DEBUG ", DEBUG_DEBUG, stDebugFlag, __VA_ARGS__); }} while(0)
#define mstTrace(...) do { if (stDebugFlag & DEBUG_TRACE) { taosPrintLog("MSTM TRACE ", DEBUG_TRACE, stDebugFlag, __VA_ARGS__); }} while(0)
#define mstFatal(...) do { if (stDebugFlag & DEBUG_FATAL) { taosPrintLog("MST FATAL ", DEBUG_FATAL, 255, __VA_ARGS__); }} while(0)
#define mstError(...) do { if (stDebugFlag & DEBUG_ERROR) { taosPrintLog("MST ERROR ", DEBUG_ERROR, 255, __VA_ARGS__); }} while(0)
#define mstWarn(...) do { if (stDebugFlag & DEBUG_WARN) { taosPrintLog("MST WARN ", DEBUG_WARN, 255, __VA_ARGS__); }} while(0)
#define mstInfo(...) do { if (stDebugFlag & DEBUG_INFO) { taosPrintLog("MST INFO ", DEBUG_INFO, 255, __VA_ARGS__); }} while(0)
#define mstDebug(...) do { if (stDebugFlag & DEBUG_DEBUG) { taosPrintLog("MST DEBUG ", DEBUG_DEBUG, stDebugFlag, __VA_ARGS__); }} while(0)
#define mstDebugL(...) do { if (stDebugFlag & DEBUG_DEBUG) { taosPrintLongString("MST DEBUG ", DEBUG_DEBUG, stDebugFlag, __VA_ARGS__); }} while(0)
#define mstTrace(...) do { if (stDebugFlag & DEBUG_TRACE) { taosPrintLog("MST TRACE ", DEBUG_TRACE, stDebugFlag, __VA_ARGS__); }} while(0)
// clang-format on
#define msttFatal(param, ...) \

4
source/dnode/mnode/impl/src/mndFunc.c
View file

@ -427,10 +427,6 @@ static int32_t mndProcessCreateFuncReq(SRpcMsg *pReq) {
TAOS_CHECK_GOTO(tDeserializeSCreateFuncReq(pReq->pCont, pReq->contLen, &createReq), NULL, _OVER);
#ifdef WINDOWS
code = TSDB_CODE_MND_INVALID_PLATFORM;
goto _OVER;
#endif
mInfo("func:%s, start to create, size:%d", createReq.name, createReq.codeLen);
TAOS_CHECK_GOTO(mndCheckOperPrivilege(pMnode, RPC_MSG_USER(pReq), RPC_MSG_TOKEN(pReq), MND_OPER_CREATE_FUNC), NULL, _OVER);

2
source/dnode/mnode/impl/src/mndStreamMgmt.c
View file

@ -2843,7 +2843,7 @@ void msmStopAllStreamsByGrant(int32_t errCode) {
}
int32_t msmHandleGrantExpired(SMnode *pMnode, int32_t errCode) {
mstInfo("stream grant expired");
mstWarn("stream grant expired");
if (0 == atomic_load_8(&mStreamMgmt.active)) {
mstWarn("mnode stream is NOT active, ignore handling");

11
source/dnode/mnode/impl/src/mndVgroup.c
View file

@ -3076,15 +3076,14 @@ static int32_t mndAddAlterVgroupElectionBaselineActionToTrans(SMnode *pMnode, SV
return -1;
}
for(int32_t i = 0; i < 3; i++){
if(i == index%3){
for (int32_t i = 0; i < replica; i++) {
if (i == index % replica) {
mInfo("trans:%d, balance leader to dnode:%d", pTrans->id, pVgroup->vnodeGid[i].dnodeId);
TAOS_CHECK_RETURN(mndAddAlterVnodeElectionBaselineActionToTrans(pMnode, pTrans, NULL, pVgroup,
pVgroup->vnodeGid[i].dnodeId, 1500));
}
else{
TAOS_CHECK_RETURN(
mndAddAlterVnodeElectionBaselineActionToTrans(pMnode, pTrans, NULL, pVgroup, pVgroup->vnodeGid[i].dnodeId, 5000));
} else {
TAOS_CHECK_RETURN(mndAddAlterVnodeElectionBaselineActionToTrans(pMnode, pTrans, NULL, pVgroup,
pVgroup->vnodeGid[i].dnodeId, 5000));
}
}
return code;

2
source/dnode/mnode/impl/test/sdb/sdbTest.cpp
View file

@ -382,7 +382,7 @@ TEST_F(MndTestSdb, 00_API) {
taosRemoveDir(opt.path);
SSdb *pSdb = sdbInit(&opt);
SSdbTable table = {.sdbType = SDB_USER, .keyType = SDB_KEY_BINARY};
SSdbTable table = {}; table.sdbType = SDB_USER; table.keyType = SDB_KEY_BINARY;
sdbSetTable(pSdb, table);
// sdbRow.c

2
source/dnode/mnode/impl/test/sma/CMakeLists.txt
View file

@ -5,7 +5,7 @@ target_link_libraries(
PUBLIC sut
)
if(NOT ${TD_WINDOWS})
if(NOT TD_WINDOWS)
add_test(
NAME smaTest
COMMAND smaTest

2
source/dnode/mnode/impl/test/stb/CMakeLists.txt
View file

@ -5,7 +5,7 @@ target_link_libraries(
PUBLIC sut
)
if(NOT ${TD_WINDOWS})
if(NOT TD_WINDOWS)
add_test(
NAME stbTest
COMMAND stbTest

4
source/dnode/mnode/sdb/src/sdbRow.c
View file

@ -42,14 +42,12 @@ void sdbFreeRow(SSdb *pSdb, SSdbRow *pRow, bool callFunc) {
// remove attached object such as trans
SdbDeleteFp deleteFp = pSdb->deleteFps[pRow->type];
if (deleteFp != NULL) {
mInfo("vgId:1, deleteFp:%p, type:%s, row:%p", deleteFp, sdbTableName(pRow->type), pRow);
mDebug("vgId:1, deleteFp:%p, type:%s, row:%p", deleteFp, sdbTableName(pRow->type), pRow);
(void)(*deleteFp)(pSdb, pRow->pObj, callFunc);
}
sdbPrintOper(pSdb, pRow, "free");
#if 1
mTrace("row:%p, is freed", pRow->pObj);
#endif
taosMemoryFreeClear(pRow);
}

4
source/dnode/snode/src/snode.c
View file

@ -258,6 +258,8 @@ static int32_t handleStreamFetchData(SSnode* pSnode, void *pWorkerCb, SRpcMsg* p
_exit:
tDestroySTriggerCalcRequest(&calcReq);
freeOperatorParam(req.pOpParam, OP_GET_PARAM);
req.pOpParam = NULL;
tDestroySResFetchReq(&req);
SRpcMsg rsp = {.code = code, .msgType = TDMT_STREAM_FETCH_FROM_RUNNER_RSP, .contLen = size, .pCont = buf, .info = pRpcMsg->info};
tmsgSendRsp(&rsp);
@ -308,6 +310,8 @@ _exit:
}
blockDataDestroy(readInfo.pBlock);
freeOperatorParam(req.pOpParam, OP_GET_PARAM);
req.pOpParam = NULL;
tDestroySResFetchReq(&req);
return code;

71
source/dnode/vnode/CMakeLists.txt
View file

@ -1,12 +1,12 @@
# vnode
add_library(vnode STATIC "")
if (${BUILD_CONTRIB} OR NOT ${TD_LINUX})
DEP_ext_rocksdb(vnode)
if(TD_USE_ROCKSDB)
DEP_td_rocksdb(vnode)
endif()
if(${TD_DARWIN})
if(TD_DARWIN)
target_compile_options(vnode PRIVATE -Wno-error=single-bit-bitfield-constant-conversion)
endif(${TD_DARWIN})
endif()
set(
VNODE_SOURCE_FILES
@ -108,46 +108,23 @@ if(TD_VNODE_PLUGINS)
target_sources(
vnode
PRIVATE
${TD_ENTERPRISE_DIR}/src/plugins/vnode/src/tsdbCompact.c
${TD_ENTERPRISE_DIR}/src/plugins/vnode/src/metaCompact.c
${TD_ENTERPRISE_DIR}/src/plugins/vnode/src/tsdbCompactMonitor.c
${TD_ENTERPRISE_DIR}/src/plugins/vnode/src/vnodeCompact.c
${TD_ENTERPRISE_DIR}/src/plugins/vnode/src/tsdbRollup.c
${TD_ENTERPRISE_DIR}/source/plugins/vnode/src/tsdbCompact.c
${TD_ENTERPRISE_DIR}/source/plugins/vnode/src/metaCompact.c
${TD_ENTERPRISE_DIR}/source/plugins/vnode/src/tsdbCompactMonitor.c
${TD_ENTERPRISE_DIR}/source/plugins/vnode/src/vnodeCompact.c
${TD_ENTERPRISE_DIR}/source/plugins/vnode/src/tsdbRollup.c
)
endif()
if(${BUILD_CONTRIB})
target_include_directories(
vnode
PUBLIC "inc"
PUBLIC "src/inc"
PUBLIC "${TD_SOURCE_DIR}/include/libs/tss"
PUBLIC "${TD_SOURCE_DIR}/include/libs/scalar"
PUBLIC "${TD_SOURCE_DIR}/include/libs/crypt"
PUBLIC "${TD_SOURCE_DIR}/include/dnode/vnode"
)
else()
target_include_directories(
vnode
PUBLIC "inc"
PUBLIC "src/inc"
PUBLIC "${TD_SOURCE_DIR}/include/libs/tss"
PUBLIC "${TD_SOURCE_DIR}/include/libs/scalar"
PUBLIC "${TD_SOURCE_DIR}/include/libs/crypt"
PUBLIC "${TD_SOURCE_DIR}/include/dnode/vnode"
)
if(${TD_LINUX})
target_include_directories(
vnode
PUBLIC "${TD_SOURCE_DIR}/deps/${TD_DEPS_DIR}/rocksdb_static"
)
target_link_directories(
vnode
PUBLIC "${TD_SOURCE_DIR}/deps/${TD_DEPS_DIR}/rocksdb_static"
)
endif()
endif()
target_include_directories(
vnode
PUBLIC "inc"
PUBLIC "src/inc"
PUBLIC "${TD_SOURCE_DIR}/include/libs/tcs"
PUBLIC "${TD_SOURCE_DIR}/include/libs/scalar"
PUBLIC "${TD_SOURCE_DIR}/include/libs/crypt"
PUBLIC "${TD_SOURCE_DIR}/include/dnode/vnode"
)
target_link_directories(
vnode
@ -184,14 +161,14 @@ endif()
target_compile_definitions(vnode PUBLIC -DMETA_REFACT)
if(${BUILD_WITH_INVERTEDINDEX})
if(BUILD_WITH_INVERTEDINDEX)
add_definitions(-DUSE_INVERTED_INDEX)
endif(${BUILD_WITH_INVERTEDINDEX})
endif()
if(${BUILD_WITH_ROCKSDB})
if(TD_USE_ROCKSDB)
add_definitions(-DUSE_ROCKSDB)
endif(${BUILD_WITH_ROCKSDB})
endif()
if(${BUILD_TEST})
if(BUILD_TEST)
add_subdirectory(test)
endif(${BUILD_TEST})
endif()

Some files were not shown because too many files have changed in this diff Show more