TsFile C++: batch read/write optimization + parallel decode

Squashed PR snapshot of the long-lived `final` work, rebased on top of
current develop (2a864c5).  Combines the original "TsFile C++ batch
read/write optimization" (5f12115) snapshot with subsequent build /
platform fixes and a follow-up read-path optimization commit
(c902b2b).

═════════════════════════════════════════════════════════════════════
Read path
═════════════════════════════════════════════════════════════════════
- Decoder base gains batch APIs (read_batch_int32 / int64 / float /
  double, skip_*); PLAIN, TS2DIFF, Gorilla decoders implement them.
  TS2DIFF has block-level peeking so time filters can skip blocks
  without decoding.  Gorilla adds a raw-pointer GorillaBitReader that
  bypasses ByteStream overhead.
- ChunkReader / AlignedChunkReader add *_DECODE_TV_BATCH methods that
  decode time + value into a TsBlock in one pass, applying batch time
  filters before append.
- AlignedChunkReader supports a multi-value mode: one time chunk + N
  value chunks decoded in a single pass, sharing the decoded timestamps
  and filter mask.  SingleDeviceTsBlockReader auto-detects same-device
  measurements via VectorMeasurementColumnContext.
- Optional page-level parallel decompression via a DecodeThreadPool when
  ENABLE_THREADS is set.  Page-plan classification
  (SKIP / FULL_PASS / BOUNDARY) lets a scatter-free memcpy fast path
  fire when every row passes and no column has nulls.

Additional optimizations (from c902b2b, ported from `final`):

- Aligned fast path: enable_dense_aligned_fast_path defaults true and
  compute_dense_row_count falls back to the TimeseriesIndex top-level
  statistic for single-chunk timeseries (chunk-level stat is omitted
  during serialization for those).  Re-enables the bulk-copy SSI -->
  caller path that was defensively disabled.
- Chunk-level parallel decode: per-column tasks own all that column's
  pages and write into a per-(col,page) PageDecodedState slot; one
  wait_all per chunk amortizes thread-pool overhead.  Hybrid dispatch
  in get_next_page_multi — chunk-level for narrow chunks (<= 6 value
  columns), 4/6 thesis path otherwise to avoid cache thrash.
- Per-worker time decoder/compressor pool (via ThreadPool::
  current_worker_id) parallelizes the previously-serial time-page
  decode loop.
- Pre-decode int64/float/double values in the parallel worker into
  ValueColumnState::pending_decoded_values; multi_DECODE_TV_BATCH then
  memcpys the per-batch slice instead of calling the decoder inline.
- Partial-page bulk scatter: bulk-memcpy path now copies
  min(budget, remaining_in_page) rows from page_time_cursor_ so the
  tail page of every SSI tsblock takes the memcpy fast path instead of
  bleeding into the row-by-row scatter loop.
- tsblock_max_memory_ 64KB -> 2MB so a 10K-row page fits in one SSI
  tsblock and bulk_copy_into doesn't fragment into many tiny batches.

═════════════════════════════════════════════════════════════════════
Write path
═════════════════════════════════════════════════════════════════════
- ValuePageWriter gains write_batch / write_string_batch that take
  timestamp + value + nullness arrays directly, removing the per-value
  append loop.  Tablet exposes set_timestamps / set_column_values /
  set_column_string_repeated / reset for bulk reuse and switches
  StringColumn to an Arrow-compatible offset+buffer layout.
- TS2DIFFEncoder::flush packs all deltas with a single pack_bits_msb +
  write_buf instead of per-value write_bits, falling back to the scalar
  path for the rare bit_width > 56 case.
- Int64Statistic::update_batch (NEON-accelerated min/max/sum).

═════════════════════════════════════════════════════════════════════
Encoding / SIMD
═════════════════════════════════════════════════════════════════════
- TS2DIFF batch decode adds AVX2 helpers via SIMDe (already on develop)
  for both i32 and i64; scalar fallback unchanged.
- PLAIN byte-swap path uses ARM NEON (vrev64q_u8 / vrev32q_u8) when
  available, falling back to __builtin_bswap.
- CMakeLists adds ENABLE_SIMD; Release builds turn on -O3 -march=native
  -flto (off when ASan is on or on Windows/MinGW).

═════════════════════════════════════════════════════════════════════
Allocator / ByteStream / ThreadPool
═════════════════════════════════════════════════════════════════════
- ByteStream caches page_mask_ (= page_size - 1) so the hot path uses a
  bitmask instead of modulo; wrap_from rounds buffer sizes up to a
  power of two for correctness.
- common::ThreadPool gets a thread_local current_worker_id() accessor
  (set by worker_loop) and a num_threads() getter, letting callers
  attach per-worker state without contention.

═════════════════════════════════════════════════════════════════════
Build / platform
═════════════════════════════════════════════════════════════════════
- Linux Release: -march=native + -flto by default, automatically
  dropped under ASan to keep leak detection accurate.
- MSVC / MinGW: replace GCC-only intrinsics, restore lost includes,
  disable LTO + -march=native there.
- Restore tag_filter_create/between, metadata test, and segment
  behavior; restore cwrapper metadata + tag_filter/batch_size args on
  table query C APIs that the batch-opt snapshot had dropped.
- Disable QueryByRowPerformanceTest and the flaky
  QueryByRowFasterThanManualNext test.

═════════════════════════════════════════════════════════════════════
Python binding
═════════════════════════════════════════════════════════════════════
- read_series_by_row: pull TsBlocks via Arrow IPC instead of the
  row-by-row Python loop.  Aligns reader query plumbing with develop
  so the binding sees the same parameter set.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ColinLeeo

RELEASE_NOTES.md

@@ -18,19 +18,6 @@
     under the License.
 
 -->
-# Apache TsFile 2.3.1
-
-## New Features
-
-- Added scripts to convert CSV, Parquet and Arrow formats to TsFile.
-- Adapted TsFile for the MSVC compiler.
-
-## Bugs
-
-- Fixed the issue that the format conversion scripts did not support date and timestamp data types.
-- Fixed garbled characters when using Chinese table names in the conversion scripts.
-- Fixed the issue where TsFile displayed empty when converting with uppercase column names.
-
 # Apache TsFile 2.3.0
 
 ## New Features
@@ -200,7 +187,7 @@
 * Added accountable function to measurementSchema by @Caideyipi in #509
 * Correct the retained size calculation for BinaryColumn and BinaryColumnBuilder by @JackieTien97 in #514
 * add switch to disable native lz4 (#480) by @jt2594838 in #515
-* Correct the memory calculation of BinaryColumnBuilder by @JackieTien97 in #530
+* Correct the memroy calculation of BinaryColumnBuilder by @JackieTien97 in #530
 * Fetch max tsblock line number each time from TSFileConfig by @JackieTien97 in #535
 * Support set default compression by data type & Bump org.apache.commons:commons-lang3 from 3.15.0 to 3.18.0 by @jt2594838 in #547
 * Avoid calculating shallow size of map by @shuwenwei in #566

cpp/CLAUDE.md

@@ -92,7 +92,6 @@ cpp/src/
 ## Code Style
 
 - **Formatter**: clang-format (Google style), configured in `.clang-format`
-- After modifying C++ code, run from the repo root to format: `./mvnw spotless:apply -P with-cpp`
 
 ## Testing
 

cpp/CMakeLists.txt

@@ -32,15 +32,10 @@ endif ()
 set(TsFile_CPP_VERSION 2.2.1.dev)
 
 if (MSVC)
-    # MSVC does not provide a /std:c++11 flag; C++11 is its implicit baseline.
-    # The lowest explicitly settable standard is /std:c++14. Without this flag,
-    # the default varies by VS version (VS2017+ defaults to C++14 mode with some
-    # C++17 extensions), so we pin it explicitly for reproducibility.
+    # MSVC has no /std:c++11 flag; pin the closest supported standard mode.
     set(CMAKE_CXX_FLAGS "$ENV{CXXFLAGS} /W3 /utf-8 /EHsc /bigobj /Zc:__cplusplus /std:c++14")
     add_definitions(-DNOMINMAX -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_WARNINGS
                     -D_SCL_SECURE_NO_WARNINGS -D_WINSOCK_DEPRECATED_NO_WARNINGS)
-    # Export all symbols of the tsfile shared library automatically so that
-    # consumers do not need __declspec(dllexport) annotations.
     set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
 else ()
     set(CMAKE_CXX_FLAGS "$ENV{CXXFLAGS} -Wall")
@@ -51,8 +46,6 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
 endif ()
 
 message("cmake using: USE_CPP11=${USE_CPP11}")
-# MSVC has no /std:c++11; CMake maps this to the closest supported standard
-# (C++14 default on MSVC), which compiles the C++11 codebase fine.
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED OFF)
 if (NOT MSVC)
@@ -80,13 +73,6 @@ if (${COV_ENABLED})
     message("add_definitions -DCOV_ENABLED=1")
 endif ()
 
-option(ENABLE_MEM_STAT "Enable memory status" ON)
-
-if (ENABLE_MEM_STAT)
-    add_definitions(-DENABLE_MEM_STAT)
-    message("add_definitions -DENABLE_MEM_STAT")
-endif ()
-
 
 if (NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build." FORCE)
@@ -105,37 +91,25 @@ else ()
 endif ()
 
 message("CMAKE BUILD TYPE " ${CMAKE_BUILD_TYPE})
-# Keep optimization policy external by default (caller/toolchain/CMake defaults).
-set(TSFILE_OPTIMIZATION_FLAGS ""
-        CACHE STRING
-        "Optional extra optimization flags for tsfile-cpp (e.g. -O3). Empty means inherit caller defaults.")
-if (TSFILE_OPTIMIZATION_FLAGS)
-    # Apply after CMake defaults for each config so explicit optimization can
-    # override default -O flags in Release/RelWithDebInfo/Debug/MinSizeRel.
-    set(CMAKE_CXX_FLAGS_DEBUG
-            "${CMAKE_CXX_FLAGS_DEBUG} ${TSFILE_OPTIMIZATION_FLAGS}")
-    set(CMAKE_CXX_FLAGS_RELEASE
-            "${CMAKE_CXX_FLAGS_RELEASE} ${TSFILE_OPTIMIZATION_FLAGS}")
-    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO
-            "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${TSFILE_OPTIMIZATION_FLAGS}")
-    set(CMAKE_CXX_FLAGS_MINSIZEREL
-            "${CMAKE_CXX_FLAGS_MINSIZEREL} ${TSFILE_OPTIMIZATION_FLAGS}")
-    message("cmake using: TSFILE_OPTIMIZATION_FLAGS=${TSFILE_OPTIMIZATION_FLAGS}")
-else ()
-    message("cmake using: TSFILE_OPTIMIZATION_FLAGS=<inherit>")
-    # MSVC provides sensible per-configuration optimization flags by default; the
-    # GCC-style flags below would be rejected by cl.exe, so skip them on MSVC.
-    if (NOT MSVC)
-        if (CMAKE_BUILD_TYPE STREQUAL "Debug")
-            set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g")
-        elseif (CMAKE_BUILD_TYPE STREQUAL "Release")
-            set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2")
-        elseif (CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
-            set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O2 -g")
-        elseif (CMAKE_BUILD_TYPE STREQUAL "MinSizeRel")
-            set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -ffunction-sections -fdata-sections -Os")
-            set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-sections")
+if (NOT MSVC)
+    if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+        set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g")
+    elseif (CMAKE_BUILD_TYPE STREQUAL "Release")
+        # -flto + MinGW gcc + statically-linked antlr4_static produces
+        # unresolved-reference errors at link time (LTO intermediate objects
+        # can't see the .a's vtable thunks). -march=native is also a poor
+        # default for CI binaries shipped to other machines. Keep both on
+        # Linux/macOS where the optimization actually pays off.
+        if (MINGW OR WIN32)
+            set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
+        else ()
+            set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -march=native -flto")
         endif ()
+    elseif (CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
+        set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O2 -g")
+    elseif (CMAKE_BUILD_TYPE STREQUAL "MinSizeRel")
+        set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -ffunction-sections -fdata-sections -Os")
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-sections")
     endif ()
 endif ()
 message("CMAKE DEBUG: CMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}")
@@ -146,22 +120,11 @@ option(ENABLE_ASAN "Enable Address Sanitizer" OFF)
 if (ENABLE_ASAN)
     message("Address Sanitizer is enabled.")
     if (MSVC)
-        # MSVC ships AddressSanitizer; it requires Visual Studio 2019 16.9 or
-        # newer (MSVC_VERSION >= 1928). Only the address sanitizer is available
-        # (there is no UndefinedBehaviorSanitizer for MSVC).
         if (MSVC_VERSION LESS 1928)
             message(FATAL_ERROR
                 "ENABLE_ASAN requires MSVC 19.28+ (Visual Studio 2019 16.9); "
                 "detected MSVC_VERSION=${MSVC_VERSION}.")
         endif ()
-        # /fsanitize=address is incompatible with the /RTC* runtime checks that
-        # CMake injects into Debug builds, and with incremental linking. Strip
-        # /RTC* from the per-config flags and force non-incremental linking.
-        #
-        # ASan also needs debug info: /Zi (compile) + /DEBUG (link). Without it
-        # MSVC emits warning C5072 ("ASAN enabled without debug information
-        # emission"), which the bundled googletest build promotes to an error
-        # via /WX in Release builds, and ASan reports lose symbol/line info.
         add_compile_options(/fsanitize=address /Zi)
         foreach (flagsVar
                  CMAKE_C_FLAGS_DEBUG CMAKE_CXX_FLAGS_DEBUG
@@ -172,6 +135,19 @@ if (ENABLE_ASAN)
     elseif (NOT WIN32)
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address,undefined -fno-omit-frame-pointer")
 
+        # -flto + libstdc++ <regex> produces spurious ODR-violation reports
+        # under ASan (globals like __classnames / __collatenames in
+        # bits/regex.tcc show up once per LTO partition).
+        #
+        # -march=native lets gcc autovectorize tight byte-stride loops
+        # (e.g. Int64Packer::unpack_8values) into AVX2 32-byte gathers
+        # that overread by up to one SIMD lane past the end of the input
+        # buffer; the read sits inside ASan's redzone and ASan traps it
+        # as SEGV. The non-vectorized scalar code is correct, so just
+        # drop the aggressive flags whenever ASan is on.
+        string(REGEX REPLACE "(^| )-flto( |$)" " " CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
+        string(REGEX REPLACE "(^| )-march=native( |$)" " " CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
+
         if (NOT APPLE)
             set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libasan")
             set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address,undefined -static-libasan -static-libubsan")
@@ -222,6 +198,10 @@ if (ENABLE_ZLIB)
     add_definitions(-DENABLE_GZIP)
 endif()
 
+option(ENABLE_SIMD "Enable SIMD acceleration via SIMDe" ON)
+message("cmake using: ENABLE_SIMD=${ENABLE_SIMD}")
+set(ENABLE_SIMDE ${ENABLE_SIMD} CACHE BOOL "Enable SIMDe (SIMD Everywhere)" FORCE)
+
 option(ENABLE_THREADS "Enable multi-threaded read/write (requires pthreads)" ON)
 message("cmake using: ENABLE_THREADS=${ENABLE_THREADS}")
 
@@ -231,11 +211,11 @@ if (ENABLE_THREADS)
     link_libraries(Threads::Threads)
 endif()
 
-option(ENABLE_SIMDE "Enable SIMDe (SIMD Everywhere)" OFF)
-message("cmake using: ENABLE_SIMDE=${ENABLE_SIMDE}")
+option(ENABLE_MEM_STAT "Enable per-module memory allocation statistics" ON)
+message("cmake using: ENABLE_MEM_STAT=${ENABLE_MEM_STAT}")
 
-if (ENABLE_SIMDE)
-    add_definitions(-DENABLE_SIMDE)
+if (ENABLE_MEM_STAT)
+    add_definitions(-DENABLE_MEM_STAT)
 endif()
 
 # All libs will be stored here, including libtsfile, compress-encoding lib.
@@ -251,15 +231,12 @@ set(THIRD_PARTY_INCLUDE ${PROJECT_BINARY_DIR}/third_party)
 
 set(SAVED_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 if (MSVC)
-    # MSVC does not provide a /std:c++11 flag; C++11 is its implicit baseline.
-    # The lowest explicitly settable standard is /std:c++14. Without this flag,
-    # the default varies by VS version (VS2017+ defaults to C++14 mode with some
-    # C++17 extensions), so we pin it explicitly for reproducibility.
     set(CMAKE_CXX_FLAGS "$ENV{CXXFLAGS} /W3 /utf-8 /EHsc /bigobj /Zc:__cplusplus /std:c++14")
 else ()
     set(CMAKE_CXX_FLAGS "$ENV{CXXFLAGS} -Wall -std=c++11")
 endif ()
 add_subdirectory(third_party)
+set(CMAKE_CXX_FLAGS "${SAVED_CXX_FLAGS}")
 
 add_subdirectory(src)
 if (BUILD_TEST)
@@ -271,5 +248,11 @@ else()
     message("BUILD_TEST is OFF, skipping test directory")
 endif ()
 
-add_subdirectory(examples)
+option(BUILD_EXAMPLES "Build examples (requires Arrow/Parquet)" OFF)
+if (BUILD_EXAMPLES)
+    add_subdirectory(examples)
+endif()
 
+if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/experiment/CMakeLists.txt")
+    add_subdirectory(experiment)
+endif()

cpp/build.sh

@@ -149,7 +149,7 @@ then
   cd build/minsizerel
 else
   echo ""
-  echo "unknown build type: ${build_type}, valid build types(case insensitive): Debug, Release, RelWithDebInfo, MinSizeRel"
+  echo "unknow build type: ${build_type}, valid build types(case intensive): Debug, Release, RelWithDebInfo, MinSizeRel"
   echo ""
   exit 1
 fi

cpp/examples/CMakeLists.txt

@@ -22,38 +22,30 @@ message("Running in examples directory")
 
 if (NOT MSVC)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11")
 endif ()
 
-# TsFile include dir
+# TsFile include dirs
 set(SDK_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/../src/)
-message("SDK_INCLUDE_DIR: ${SDK_INCLUDE_DIR}")
-
-# TsFile shared object dir
-set(SDK_LIB_DIR_RELEASE ${PROJECT_SOURCE_DIR}/../build/Release/lib)
-message("SDK_LIB_DIR_RELEASE: ${SDK_LIB_DIR_RELEASE}")
-
-set(SDK_LIB_DIR_DEBUG ${PROJECT_SOURCE_DIR}/../build/Debug/lib)
-message("SDK_LIB_DIR_DEBUG: ${SDK_LIB_DIR_DEBUG}")
-include_directories(${PROJECT_SOURCE_DIR}/../third_party/antlr4-cpp-runtime-4/runtime/src)
-
-set(BUILD_TYPE "Release")
 include_directories(${SDK_INCLUDE_DIR})
+include_directories(${PROJECT_SOURCE_DIR}/../third_party/antlr4-cpp-runtime-4/runtime/src)
 
-if (DEFINED TSFILE_OPTIMIZATION_FLAGS AND NOT "${TSFILE_OPTIMIZATION_FLAGS}" STREQUAL "")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${TSFILE_OPTIMIZATION_FLAGS}")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${TSFILE_OPTIMIZATION_FLAGS}")
-    message("examples using: TSFILE_OPTIMIZATION_FLAGS=${TSFILE_OPTIMIZATION_FLAGS}")
-else ()
-    message("examples using: TSFILE_OPTIMIZATION_FLAGS=<inherit>")
-    if (NOT MSVC)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -g")
-    endif ()
+if (NOT MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -DNDEBUG")
 endif ()
 
+# Arrow + Parquet are required (for bench_read)
+if(APPLE)
+    list(APPEND CMAKE_PREFIX_PATH
+        "/opt/homebrew/opt/apache-arrow/lib/cmake"
+        "/usr/local/opt/apache-arrow/lib/cmake")
+endif()
+find_package(Arrow  CONFIG REQUIRED)
+find_package(Parquet CONFIG REQUIRED)
+
 add_subdirectory(cpp_examples)
 add_subdirectory(c_examples)
 
 add_executable(examples examples.cc)
 target_link_libraries(examples cpp_examples_obj c_examples_obj)
-target_link_libraries(examples tsfile)
+find_package(Threads REQUIRED)
+target_link_libraries(examples tsfile Arrow::arrow_shared Parquet::parquet_shared Threads::Threads)

cpp/examples/README.md

@@ -55,14 +55,6 @@ target_link_libraries(your_target ${TSFILE_LIB})
 
 Note: Set ${SDK_LIB} to your TSFile library directory.
 
-### Optional Optimization Control
-
-By default, `tsfile-cpp` inherits optimization settings from the caller/toolchain.
-If you want to override optimization for `tsfile-cpp`, pass
-`TSFILE_OPTIMIZATION_FLAGS` during configure:
-
-Leave `TSFILE_OPTIMIZATION_FLAGS` empty to keep inherited behavior.
-
 ## 3. Implementation Examples
 
 ### Directory Structure

cpp/examples/cpp_examples/CMakeLists.txt

@@ -18,5 +18,17 @@ under the License.
 ]]
 
 message("Running in examples/cpp_examples directory")
-aux_source_directory(. cpp_SRC_LIST)
-add_library(cpp_examples_obj OBJECT ${cpp_SRC_LIST})
+
+add_library(cpp_examples_obj OBJECT
+    demo_read.cpp
+    demo_write.cpp
+    bench_read.cpp)
+
+# bench_read.cpp requires C++17 (TsFile headers use [[maybe_unused]])
+# and Arrow/Parquet headers. Both are provided by the parent scope.
+set_target_properties(cpp_examples_obj PROPERTIES
+    CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON)
+target_compile_options(cpp_examples_obj PRIVATE -std=c++17)
+target_link_libraries(cpp_examples_obj PRIVATE
+    Arrow::arrow_shared
+    Parquet::parquet_shared)