Skip to content
A type safe SQL template library for C++
C++ C Python CMake Other
Branch: develop
Clone or download

Latest commit


Type Name Latest commit message Commit time
Failed to load latest commit information.
cmake Make sure find_package(Sqlpp11) can be done multiple times (#306) Feb 8, 2020
connector_api Implemented get/set_default_isolation_level() functions to change the Jun 4, 2017
include/sqlpp11 Make connection pool useable Feb 15, 2020
scripts Add begin and end keywords in the reserved names to be escaped (#310) Feb 6, 2020
test_constraints Added string_view tests and C++17 tests for travis Feb 2, 2019
test_scripts Use Python3 for test_scripts (#298) Oct 14, 2019
test_serializer Minimal over() implementation for aggregate functions (#316) Feb 15, 2020
test_static_asserts Added string_view tests and C++17 tests for travis Feb 2, 2019
tests Adjust sample.sql and ddl2cpp to match Sample.h Oct 5, 2019
.appveyor.yml Update CI scripts. Jan 31, 2018
.clang-format Stop clang-format from sorting includes Oct 7, 2016
.gitignore add set(tuple<...>) implementation for insert and update statements Feb 15, 2018
.travis.yml Use Python3 for test_scripts (#298) Oct 14, 2019
CMakeLists.txt Install and export ddl2cpp script Feb 19, 2018
CREDITS shamelessly adding myself to CREDITS May 29, 2015 Update Aug 30, 2016
LICENSE Update LICENSE Mar 5, 2016 Update vcpkg installation instructions (#314) Feb 13, 2020
_config.yml Set theme jekyll-theme-minimal Jun 4, 2017
coveralls add coveralls coverage reporting May 29, 2015
pre-commit Reformatted using clang-format Sep 13, 2015 Fix some formatting in wish list Aug 20, 2019


A type safe embedded domain specific language for SQL queries and results in C++

Documentation is found in the wiki

So what is this about?

SQL and C++ are both strongly typed languages. Still, most C/C++ interfaces to SQL are based on constructing queries as strings and on interpreting arrays or maps of strings as results.

sqlpp11 is a templated library representing an embedded domain specific language (EDSL) that allows you to

  • define types representing tables and columns,
  • construct type safe queries checked at compile time for syntax errors, type errors, name errors and even some semantic errors,
  • interpret results by iterating over query-specific structs with appropriately named and typed members.

This results in several benefits, e.g.

  • the library user operates comfortably on structs and functions,
  • the compiler reports many kinds of errors long before the code enters unit testing or production,
  • the library hides the gory details of string construction for queries and interpreting results returned by select calls.

The library supports both static and dynamic queries. The former offers greater benefit in terms of type and consistency checking. The latter makes it easier to construct queries on the flight.

sqlpp11 is vendor-neutral. Specific traits of databases (e.g. unsupported or non-standard features) are handled by connector libraries. Connector libraries can inform the developer of missing features at compile time. They also interpret expressions specifically where needed. For example, the connector could use the operator|| or the concat method for string concatenation without the developer being required to change the statement.

The library is already used in production but it is certainly not complete yet. Feature requests, bug reports, contributions to code or documentation are most welcome.


For the examples, lets assume you have a table class representing something like

    id bigint,
    name varchar(50),
    hasFun bool

And we assume to have a database connection object:

TabFoo foo;
Db db(/* some arguments*/);

// selecting zero or more results, iterating over the results
for (const auto& row : db(select(, foo.hasFun).from(foo).where( > 17 and"%bar%"))))
    if (
        std::cerr << "name is null, will convert to empty string" << std::endl;
    std::string name =;   // string-like fields are implicitly convertible to string
    bool hasFun = row.hasFun;          // bool fields are implicitly convertible to bool

// selecting ALL columns of a table
for (const auto& row : db(select(all_of(foo)).from(foo).where(foo.hasFun or == "joker")))
    int64_t id =; // numeric fields are implicitly convertible to numeric c++ types

// selecting zero or one row, showing off with an alias:
if (const auto& row = db(select( == 17)))
    std::cerr << "found: " << row.cheese << std::endl;

// selecting a single row with a single result:
return db(select(count(;

Of course there are joins and subqueries, more functions, order_by, group_by etc.
These will be documented soon.

// A sample insert
db(insert_into(foo).set( = 17, = "bar", foo.hasFun = true));

// A sample update
db(update(foo).set(foo.hasFun = not foo.hasFun).where( != "nobody"));

// A sample delete
db(remove_from(foo).where(not foo.hasFun));


sqlpp11 is distributed under the BSD 2-Clause License.


Branch / Compiler clang-3.4, gcc-4.9, Xcode-7 MSVC 2015/2017 Test Coverage
master Build Status Build status Coverage Status
develop Build Status Build status Coverage Status

Additional information available:

Past talks about sqlpp11 and some coding concepts used within the library:


Compiler: sqlpp11 makes heavy use of C++11 and requires a recent compiler and STL. The following compilers are known to compile the test programs:

  • clang-3.4+ on Ubuntu-12.4
  • g++-4.8+ on Ubuntu-12.4
  • g++-4.8+ on cygwin 64bit
  • g++-4.9+ on Debian Unstable
  • Xcode-7 on OS X
  • MSVC 2015 Update 1 on Windows Server 2012

Database Connector: sqlpp11 requires a certain api in order to connect with the database, see database/api.h.

To demonstrate that sqlpp11 can work with other backends as well, here is an experimental backend for structs in standard containers:

Date Library: sqlpp11 requires Howard Hinnant's date library for date and date_time data types. Sqlpp11 includes CMake search module for this, but if you didn't install this library system-wide, you need to point cmake to it:

cmake -DHinnantDate_ROOT_DIR=/%PATH_TO_HinnantDate_SOURCE%/

Build and Install

Build from Source:

Download and unpack the latest release from or clone the repository. Inside the directory run the following commands:

mkdir build
cd build
cmake ..
make install

The last step will install the library system wide.

Install via Homebrew (MacOS):

brew install marvin182/zapfhahn/sqlpp11

Some connectors can be installed with the formula. See brew info marvin182/zapfhahn/sqlpp11 for available options.

Build via vcpkg:

You can download and install sqlpp11 using the vcpkg dependency manager:

git clone
cd vcpkg
./vcpkg integrate install
vcpkg install sqlpp11

The sqlpp11 port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please create an issue or pull request on the vcpkg repository.

The following connector libraries for sqlpp11 are maintained as a separate package in vcpkg:

Basic usage:

Create DDL files:

mysql: 'show create table MyDatabase.MyTable' #or
mysqldump --no-data MyDatabase > MyDatabase.sql

Create headers for them with provided Python script:

%sqlpp11_dir%/scripts/ddl2cpp ~/temp/MyTable.ddl  ~/temp/MyTable %DatabaseNamespaceForExample%

(In case you're getting notes about unsupported column type take a look at the other datatypes in sqlpp11/data_types. They are not hard to implement.)

Include generated header (MyTable.h), that's all.

If you prefer Ruby over Python, you might want to take a look at


Breaking changes in 0.36:

See Changes

You can’t perform that action at this time.