Require C++17 and CMake 3.13

.claude/skills/sqlitecpp-build-cmake/SKILL.md

@@ -42,8 +42,6 @@ description: Build SQLiteCpp with CMake. Use for CMake builds, tests, options, o
 ## Notes
 - Tests can use a system `GTest`; otherwise they fall back to the `googletest` submodule.
 - If the submodule is needed: `git submodule update --init --recursive`.
-- The minimum CMake version is not required to remain at 3.5. Raising it is acceptable when a modest
-  version bump enables cleaner target-based CMake or matches bundled dependency requirements. Choose
-  the new minimum deliberately and update CMake configuration, documentation, and CI consistently.
-- The bundled GoogleTest 1.16 project already requires CMake 3.13 when tests use the submodule, even
-  though SQLiteCpp currently declares CMake 3.5 at the top level.
+- SQLiteCpp requires C++17 and CMake 3.13 or newer.
+- CMake 3.13 is compatible with the bundled GoogleTest 1.16 minimum and can express C++20 for compatibility tests.
+- Raise build-tool baselines deliberately and update CMake configuration, documentation, and CI consistently.

.claude/skills/sqlitecpp-build-meson/SKILL.md

@@ -31,5 +31,5 @@ description: Builds SQLiteCpp with Meson. Use when configuring Meson builds, tes
 - `SQLITE_OMIT_LOAD_EXTENSION`: omit load extension.
 
 ## Notes
-- Meson defaults to `cpp_std=c++17` to support newer gtest versions.
-- On Windows, Meson enforces at least C++14 if needed by headers.
+- Meson defaults to `cpp_std=c++17` because C++17 is the project minimum.
+- Standards below C++17 are rejected; C++20 or newer can be selected explicitly.

.claude/skills/sqlitecpp-coding-standards/SKILL.md

@@ -8,7 +8,7 @@ description: SQLiteCpp coding standards and API rules for core edits, public hea
 ## Non-negotiables
 - RAII only: acquire in constructors, release in destructors.
 - Never throw in destructors; use `SQLITECPP_ASSERT()` instead.
-- C++11 only in core library (C++14 only in `VariadicBind.h` and `ExecuteMany.h`).
+- C++17 is the minimum across the library; do not require C++20 without an explicit baseline change.
 - Public API headers must not include `sqlite3.h`.
 - Public API must use `SQLITECPP_API` from `SQLiteCppExport.h`.
 - One `Database`/`Statement`/`Column` per thread.

.github/copilot-instructions.md

@@ -4,7 +4,7 @@
 - RAII only. Acquire in constructors, release in destructors.
 - NEVER throw in destructors. Use `SQLITECPP_ASSERT()` instead.
 - Errors: use `SQLite::Exception` for throwing APIs; `tryExec()`, `tryExecuteStep()`, `tryReset()` return SQLite codes.
-- C++11 only in core library. C++14 only in `VariadicBind.h` and `ExecuteMany.h`.
+- C++17 is the minimum across the library. Do not require C++20 without an explicit baseline change.
 - Public API headers must NOT include `sqlite3.h`. Use `SQLite::OPEN_*` flags from `Database.h`.
 - Export public API with `SQLITECPP_API` from `SQLiteCppExport.h`.
 - Threading: one `Database`/`Statement`/`Column` per thread.
@@ -137,8 +137,8 @@ Usually means missing SQLiteCpp library or missing source file in build.
 
 ## Reference
 ### Project Snapshot
-- SQLiteCpp is a lean C++11 RAII wrapper around SQLite3 C APIs.
-- Minimal dependencies (C++11 STL + SQLite3).
+- SQLiteCpp is a lean C++17 RAII wrapper around SQLite3 C APIs.
+- Minimal dependencies (C++17 STL + SQLite3).
 - Cross-platform, thread-safe at SQLite multi-thread level.
 - Keep naming close to SQLite.
 - Public headers avoid `sqlite3.h`; use `SQLite::OPEN_*` flags from `Database.h`.
@@ -156,8 +156,8 @@ SQLiteCpp/
 |   +-- Backup.h          # Online backup
 |   +-- Exception.h       # SQLite::Exception
 |   +-- Assertion.h       # SQLITECPP_ASSERT macro
-|   +-- VariadicBind.h    # Bind helper (C++11/14)
-|   +-- ExecuteMany.h     # Batch execute (C++14)
+|   +-- VariadicBind.h    # Variadic bind helper
+|   +-- ExecuteMany.h     # Batch execute helper
 |   +-- SQLiteCppExport.h # SQLITECPP_API macro
 +-- src/                  # Implementations
 +-- tests/                # Unit tests (*_test.cpp)

.github/workflows/cmake_consumer_standards.yml → .github/workflows/cmake_standards.yml

@@ -1,4 +1,4 @@
-name: CMake consumer standards
+name: CMake C++17/C++20 standards
 
 on: [push, pull_request]
 
@@ -11,12 +11,12 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - library_standard: 11
-            consumer_standard: 11
-          - library_standard: 11
-            consumer_standard: 17
           - library_standard: 17
             consumer_standard: 17
+          - library_standard: 17
+            consumer_standard: 20
+          - library_standard: 20
+            consumer_standard: 20
 
     env:
       CC: gcc

AGENTS.md

@@ -1,8 +1,8 @@
 # SQLiteCpp AI Agents Custom Instructions
 
 ## Project Overview
-- SQLiteCpp is a C++11 RAII wrapper around SQLite3 C APIs
-- Minimal dependencies: C++11 STL + SQLite3
+- SQLiteCpp is a C++17 RAII wrapper around SQLite3 C APIs
+- Minimal dependencies: C++17 STL + SQLite3
 - Cross-platform: Windows, Linux, macOS
 - Thread-safe at SQLite multi-thread level
 
@@ -20,7 +20,7 @@ clarifications.
 
 1. **RAII only**: Acquire resources in constructors, release in destructors
 2. **Never throw in destructors**: Use `SQLITECPP_ASSERT()` instead
-3. **C++11 core library**: C++14 only in VariadicBind.h and ExecuteMany.h
+3. **C++17 baseline**: C++17 is the minimum; do not require C++20 without an explicit baseline change
 4. **Public API isolation**: Headers must NOT include sqlite3.h
 5. **Export macros**: Public API must use `SQLITECPP_API` from SQLiteCppExport.h
 6. **Threading constraint**: One Database/Statement/Column per thread
@@ -58,6 +58,7 @@ clarifications.
 - Max 120 characters per line
 
 ## Build System Compatibility
+- The current baseline is C++17 and CMake 3.13.
 - Minimum build-tool versions are deliberate baselines, not permanent compatibility promises.
 - Raising the minimum CMake version is acceptable when it materially simplifies maintenance,
   enables cleaner modern CMake, or makes external contributions easier.

CHANGELOG.md

@@ -331,3 +331,7 @@ Version 3.4.0 - 2026 Sep 21
 - Remove AppVeyor and retain Visual Studio 2022 Release Win32/x86 coverage in GitHub Actions (#573)
 - Add C++11 & C++17 standard tests (#574)
 - Update copyright years to 2026 across project files (#578)
+
+Unreleased
+- Require C++17 and CMake 3.13 as the new project baseline
+- Replace C++11/C++17 consumer checks with C++17/C++20 compatibility coverage

CMakeLists.txt

@@ -4,17 +4,17 @@
 #
 # Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt
 # or copy at http://opensource.org/licenses/MIT)
-cmake_minimum_required(VERSION 3.5...4.0)
+cmake_minimum_required(VERSION 3.13...4.0)
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake") # custom CMake modules like FindSQLiteCpp
-project(SQLiteCpp VERSION 3.4.0)
+project(SQLiteCpp VERSION 4.0.0)
 
-# SQLiteC++ 3.x requires C++11 features
+# SQLiteCpp requires C++17 or newer.
 if (NOT CMAKE_CXX_STANDARD)
-    set(CMAKE_CXX_STANDARD 11)
-elseif (CMAKE_CXX_STANDARD LESS 11)
-    message(WARNING "CMAKE_CXX_STANDARD has been set to '${CMAKE_CXX_STANDARD}' which is lower than the minimum required standard (c++11).")
+    set(CMAKE_CXX_STANDARD 17)
+elseif (CMAKE_CXX_STANDARD LESS 17)
+    message(FATAL_ERROR "CMAKE_CXX_STANDARD has been set to '${CMAKE_CXX_STANDARD}', but SQLiteCpp requires C++17 or newer.")
 endif ()
-message(STATUS "Using c++ standard c++${CMAKE_CXX_STANDARD}")
+message(STATUS "Using C++ standard C++${CMAKE_CXX_STANDARD}")
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 message (STATUS "CMake version: ${CMAKE_VERSION}")
@@ -66,10 +66,6 @@ if (MSVC)
             set(gtest_force_shared_crt ON CACHE BOOL "Use shared (DLL) run-time lib even when Google Test is built as static lib.")
         endif (SQLITECPP_BUILD_TESTS)
     endif (SQLITECPP_USE_STATIC_RUNTIME)
-    # MSVC versions prior to 2015 are not supported anymore by SQLiteC++ 3.x
-    if (MSVC_VERSION LESS 1900) # OR MSVC_TOOLSET_VERSION LESS 140)
-      message(ERROR "Visual Studio prior to 2015 is not supported anymore.")
-    endif (MSVC_VERSION LESS 1900)
 else (MSVC) # Unix/macOS/MinGW
     set(CPPLINT_ARG_OUTPUT      "--output=eclipse")
     set(CPPCHECK_ARG_TEMPLATE   "--template=gcc")
@@ -211,6 +207,7 @@ endif()
 
 # add sources of the wrapper as a "SQLiteCpp" static library
 add_library(SQLiteCpp ${SQLITECPP_SRC} ${SQLITECPP_INC} ${SQLITECPP_DOC} ${SQLITECPP_SCRIPT})
+target_compile_features(SQLiteCpp PUBLIC cxx_std_17)
 
 # Options relative to SQLite and SQLiteC++ functions
 
@@ -310,18 +307,9 @@ elseif (SQLITECPP_FIND_SQLITE)
         # Make PkgConfig optional since Windows doesn't usually have it installed.
         find_package(PkgConfig QUIET)
         if(PKG_CONFIG_FOUND)
-            # IMPORTED_TARGET was added in 3.6.3
-            if(CMAKE_VERSION VERSION_LESS 3.6.3)
-                pkg_check_modules(sqlcipher REQUIRED sqlcipher)
-                # Only used in Database.cpp so PRIVATE to hide from end-user
-                # Since we can't use IMPORTED_TARGET on this older Cmake version, manually link libs & includes
-                target_link_libraries(SQLiteCpp PRIVATE ${sqlcipher_LIBRARIES})
-                target_include_directories(SQLiteCpp PRIVATE ${sqlcipher_INCLUDE_DIRS})
-            else()
-                pkg_check_modules(sqlcipher REQUIRED IMPORTED_TARGET sqlcipher)
-                # Only used in Database.cpp so PRIVATE to hide from end-user
-                target_link_libraries(SQLiteCpp PRIVATE PkgConfig::sqlcipher)
-            endif()
+            pkg_check_modules(sqlcipher REQUIRED IMPORTED_TARGET sqlcipher)
+            # Only used in Database.cpp so PRIVATE to hide from end-user
+            target_link_libraries(SQLiteCpp PRIVATE PkgConfig::sqlcipher)
         else()
             # Since we aren't using pkgconf here, find it manually
             find_library(sqlcipher_LIBRARY "sqlcipher")
@@ -418,26 +406,14 @@ endif (SQLITECPP_INSTALL)
 
 option(SQLITECPP_RUN_CPPLINT "Run cpplint.py tool for Google C++ StyleGuide." ON)
 if (SQLITECPP_RUN_CPPLINT)
-    # The minimum version of CMAKE is 3.5, but as of 3.12 the PythonInterp package is deprecated.
-    if(${CMAKE_VERSION} VERSION_LESS "3.12.0") 
-        find_package(PythonInterp)
-        if (PYTHONINTERP_FOUND)
-            # add a cpplint target to the "all" target
-            add_custom_target(SQLiteCpp_cpplint
-            ALL
-            COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/cpplint.py ${CPPLINT_ARG_OUTPUT} ${CPPLINT_ARG_VERBOSE} ${CPPLINT_ARG_LINELENGTH} ${SQLITECPP_SRC} ${SQLITECPP_INC}
-            )
-        endif (PYTHONINTERP_FOUND)
-    else()
-        find_package(Python)
-        if (PYTHON_INTERPRETER_FOUND)
-            # add a cpplint target to the "all" target
-            add_custom_target(SQLiteCpp_cpplint
-            ALL
-            COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/cpplint.py ${CPPLINT_ARG_OUTPUT} ${CPPLINT_ARG_VERBOSE} ${CPPLINT_ARG_LINELENGTH} ${SQLITECPP_SRC} ${SQLITECPP_INC}
-            )
-        endif (PYTHON_INTERPRETER_FOUND)
-    endif()
+    find_package(Python3 COMPONENTS Interpreter)
+    if (Python3_Interpreter_FOUND)
+        # add a cpplint target to the "all" target
+        add_custom_target(SQLiteCpp_cpplint
+        ALL
+        COMMAND ${Python3_EXECUTABLE} ${PROJECT_SOURCE_DIR}/cpplint.py ${CPPLINT_ARG_OUTPUT} ${CPPLINT_ARG_VERBOSE} ${CPPLINT_ARG_LINELENGTH} ${SQLITECPP_SRC} ${SQLITECPP_INC}
+        )
+    endif (Python3_Interpreter_FOUND)
 else (SQLITECPP_RUN_CPPLINT)
     message(STATUS "SQLITECPP_RUN_CPPLINT OFF")
 endif (SQLITECPP_RUN_CPPLINT)
@@ -453,7 +429,7 @@ if (SQLITECPP_RUN_CPPCHECK)
                 --enable=style
                 --error-exitcode=1
                 --quiet
-                --std=c++11
+                --std=c++17
                 ${CPPCHECK_ARG_TEMPLATE}
                 ${PROJECT_SOURCE_DIR}/src
         )

Doxyfile

@@ -38,7 +38,7 @@ PROJECT_NAME           = SQLiteC++
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 3.4.0
+PROJECT_NUMBER         = 4.0.0
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

README.md

@@ -46,12 +46,12 @@ All of the code and documentation in SQLite has been dedicated to the public dom
 ### The goals of SQLiteC++ are:
 
 - to offer the best of the existing simple C++ SQLite wrappers
-- to be elegantly written with good C++11 design, STL, exceptions and RAII idiom
-- to keep dependencies to a minimum (C++11 STL and SQLite3)
+- to be elegantly written with modern C++17 design, STL, exceptions and RAII idiom
+- to keep dependencies to a minimum (C++17 STL and SQLite3)
 - to be portable
 - to be light and fast
 
-**C++11 support:** SQLiteCpp 3.4.x is the final release line supporting C++11. After 3.4.0, maintenance fixes for the 3.x series will be made on the `sqlitecpp-3.4.x` branch, while `master` moves to SQLiteCpp 4.x with a newer C++ and CMake baseline.
+**Language baseline:** SQLiteCpp 4.x requires C++17. SQLiteCpp 3.4.x is the final C++11-compatible release line and is maintained on the `sqlitecpp-3.4.x` branch.
 - to be thread-safe only as much as SQLite "Multi-thread" mode (see below)
 - to have a good unit test coverage
 - to use API names sticking with those of the SQLite library
@@ -68,7 +68,7 @@ and then is always valid until destroyed.
 
 ### Supported platforms:
 
-Now requires a C++11 compiler. Use branch [sqlitecpp-2.x](https://github.com/SRombauts/SQLiteCpp/tree/sqlitecpp-2.x) for latest pre-C++11 developments.
+SQLiteCpp 4.x requires a C++17 compiler. Use branch [sqlitecpp-3.4.x](https://github.com/SRombauts/SQLiteCpp/tree/sqlitecpp-3.4.x) for the final C++11-compatible release line, or [sqlitecpp-2.x](https://github.com/SRombauts/SQLiteCpp/tree/sqlitecpp-2.x) for pre-C++11 developments.
 
 The continuous integration builds and tests on:
 
@@ -77,12 +77,12 @@ The continuous integration builds and tests on:
   and static libraries
 - the current macOS GitHub Actions runner
 
-The build matrices cover GCC, Clang, AppleClang, MinGW, and MSVC. The core library requires C++11;
-selected headers use C++14 features as documented below.
+The build matrices cover GCC, Clang, AppleClang, MinGW, and MSVC. SQLiteCpp requires C++17 and the CMake compatibility workflow also exercises C++20.
 
 ### Dependencies
 
-- a modern C++11 STL implementation with GCC, Clang, or Visual Studio 2015
+- a C++17-capable compiler and standard library (GCC, Clang/AppleClang, or MSVC)
+- CMake 3.13 or newer for CMake builds
 - exception support (the class Exception inherits from std::runtime_error)
 - the SQLite library (3.8.7 minimum from 2014-10-17), either by linking to it dynamically or statically
   (install the libsqlite3-dev package under Debian/Ubuntu/Mint Linux),

docs/README.md

@@ -47,12 +47,12 @@ All of the code and documentation in SQLite has been dedicated to the public dom
 ### The goals of SQLiteC++ are:
 
 - to offer the best of the existing simple C++ SQLite wrappers
-- to be elegantly written with good C++11 design, STL, exceptions and RAII idiom
-- to keep dependencies to a minimum (C++11 STL and SQLite3)
+- to be elegantly written with modern C++17 design, STL, exceptions and RAII idiom
+- to keep dependencies to a minimum (C++17 STL and SQLite3)
 - to be portable
 - to be light and fast
 
-**C++11 support:** SQLiteCpp 3.4.x is the final release line supporting C++11. After 3.4.0, maintenance fixes for the 3.x series will be made on the `sqlitecpp-3.4.x` branch, while `master` moves to SQLiteCpp 4.x with a newer C++ and CMake baseline.
+**Language baseline:** SQLiteCpp 4.x requires C++17. SQLiteCpp 3.4.x is the final C++11-compatible release line and is maintained on the `sqlitecpp-3.4.x` branch.
 - to be thread-safe only as much as SQLite "Multi-thread" mode (see below)
 - to have a good unit test coverage
 - to use API names sticking with those of the SQLite library
@@ -69,7 +69,7 @@ and then is always valid until destroyed.
 
 ### Supported platforms:
 
-Now requires a C++11 compiler. Use branch [sqlitecpp-2.x](https://github.com/SRombauts/SQLiteCpp/tree/sqlitecpp-2.x) for latest pre-C++11 developments.
+SQLiteCpp 4.x requires a C++17 compiler. Use branch [sqlitecpp-3.4.x](https://github.com/SRombauts/SQLiteCpp/tree/sqlitecpp-3.4.x) for the final C++11-compatible release line, or [sqlitecpp-2.x](https://github.com/SRombauts/SQLiteCpp/tree/sqlitecpp-2.x) for pre-C++11 developments.
 
 The continuous integration builds and tests on:
 
@@ -78,12 +78,12 @@ The continuous integration builds and tests on:
   and static libraries
 - the current macOS GitHub Actions runner
 
-The build matrices cover GCC, Clang, AppleClang, MinGW, and MSVC. The core library requires C++11;
-selected headers use C++14 features as documented below.
+The build matrices cover GCC, Clang, AppleClang, MinGW, and MSVC. SQLiteCpp requires C++17 and the CMake compatibility workflow also exercises C++20.
 
 ### Dependencies
 
-- a modern C++11 STL implementation with GCC, Clang, or Visual Studio 2015
+- a C++17-capable compiler and standard library (GCC, Clang/AppleClang, or MSVC)
+- CMake 3.13 or newer for CMake builds
 - exception support (the class Exception inherits from std::runtime_error)
 - the SQLite library (3.7.15 minimum from 2012-12-12) either by linking to it dynamically or statically (install the libsqlite3-dev package under Debian/Ubuntu/Mint Linux),
   or by adding its source file in your project code base (source code provided in src/sqlite3 for Windows),

examples/example2/CMakeLists.txt

@@ -4,11 +4,11 @@
 #
 # Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt
 # or copy at http://opensource.org/licenses/MIT) 
-cmake_minimum_required(VERSION 3.5...4.0)
+cmake_minimum_required(VERSION 3.13...4.0)
 project(SQLiteCpp_Example VERSION 2.0)
 
-# SQLiteC++ 3.x now requires C++11 compiler
-set(CMAKE_CXX_STANDARD 11)
+# SQLiteCpp requires a C++17 compiler.
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 # Add SQLite3 C++ wrapper around sqlite3 library (and sqlite3 itself provided for ease of use)

include/SQLiteCpp/SQLiteCpp.h

@@ -41,6 +41,6 @@
  *
  * WARNING: shall always be updated in sync with PROJECT_VERSION in CMakeLists.txt
  */
-#define SQLITECPP_VERSION           "3.04.00"   // 3.4.0
-#define SQLITECPP_VERSION_NUMBER     3004000    // 3.4.0
+#define SQLITECPP_VERSION           "4.00.00"   // 4.0.0
+#define SQLITECPP_VERSION_NUMBER     4000000    // 4.0.0
 

meson.build

@@ -1,10 +1,9 @@
 project(
     'SQLiteCpp', 'cpp',
-    # SQLiteCpp supports C++11
-    # however newer versions of gtest requires C++17
+    # SQLiteCpp requires C++17 or newer.
     default_options: ['cpp_std=c++17', 'warning_level=3'],
     license: 'MIT',
-    version: '3.4.0',
+    version: '4.0.0',
 )
 
 cxx = meson.get_compiler('cpp')
@@ -88,18 +87,8 @@ sqlitecpp_test_srcs = files(
 sqlitecpp_test_args = []
 
 
-## using MSVC headers requires c++14, if not will show an error on xstddef as: 
-## 'auto' return without trailing return type; deduced return types are a C++14 extension
-if host_machine.system() == 'windows'
-    ## check if the std version is less than c++14
-    if cpp_std.version_compare('<c++14')
-        message('[WINDOWS] setting minimal version to c++14')
-        message('[WINDOWS] you can disable this warning by setting cpp_std to c++14 or newer.')
-        cpp_std = 'c++14'
-        sqlitecpp_opts += [
-            'cpp_std=' + cpp_std,
-        ]
-    endif
+if cpp_std != 'none' and cpp_std.version_compare('<c++17')
+    error('SQLiteCpp requires C++17 or newer')
 endif
 # Options relative to SQLite and SQLiteC++ functions
 

package.xml

@@ -1,7 +1,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="3">
   <name>SQLiteCpp</name>
-  <version>3.4.0</version>
+  <version>4.0.0</version>
   <description>A smart and easy to use C++ SQLite3 wrapper.</description>
 
   <maintainer email="sebastien.rombauts@gmail.com">Sébastien Rombauts</maintainer>

tests/consumer/CMakeLists.txt

@@ -1,8 +1,8 @@
-cmake_minimum_required(VERSION 3.5...4.0)
+cmake_minimum_required(VERSION 3.13...4.0)
 project(SQLiteCpp_Consumer LANGUAGES CXX)
 
-set(SQLITECPP_CXX_STANDARD 11 CACHE STRING "C++ standard used to build SQLiteCpp")
-set(CONSUMER_CXX_STANDARD 11 CACHE STRING "C++ standard used to build the consumer")
+set(SQLITECPP_CXX_STANDARD 17 CACHE STRING "C++ standard used to build SQLiteCpp")
+set(CONSUMER_CXX_STANDARD 17 CACHE STRING "C++ standard used to build the consumer")
 
 # Build SQLiteCpp with the requested standard.
 set(CMAKE_CXX_STANDARD ${SQLITECPP_CXX_STANDARD})