Introduce verbatim_clause

This replaces verbatim if used as a clause in a custom query.

This is a breaking change. It allows custom queries with verbatim
components to be used as tables.

Inspired by:

rbock/sqlpp11#631

Author: rbock

docs/change_log.md

@@ -7,6 +7,7 @@
 Breaking changes:
 
 - Added log_category parameter to log function, #86
+- verbatim_clause replaces verbatim if used as a clause in a custom query
 
 Other changes:
 

docs/custom_statements.md

@@ -26,14 +26,15 @@ for (const auto& row :
 }
 ```
 
-`verbatim` can also be used as a custom clause:
+## `verbatim_clause`
+`verbatim_clause` can also be used as a custom clause:
 
 ```c++
 // components of a statement can be combined into custom statement using
 // the `<<` operator.
 for (const auto& row :
      db(select(all_of(t)).from(t)
-        << sqlpp::verbatim("WINDOW window_name AS (window_definition)")
+        << sqlpp::verbatim_clause("WINDOW window_name AS (window_definition)")
         << order_by(t.id))) {
   // ...
 }
@@ -51,7 +52,7 @@ It won't serialize its arguments, but change the return type of the statement, e
 // We can tell the library to treat this like a select of a single column
 // with the correct type.
 for (const auto& row :
-     db(sqlpp::statement_t{} << sqlpp::verbatim("PRAGMA user_version")
+     db(sqlpp::statement_t{} << sqlpp::verbatim_clause("PRAGMA user_version")
                              << with_result_type_of(select(t.id)))) {
   user_version = row.id;
 }
@@ -62,7 +63,7 @@ for (const auto& row :
 // Not recommended, though, as it is clearly more prone to errors than the
 // canonical way.
 for (const auto& row :
-   db(sqlpp::statement_t{} << sqlpp::verbatim("SELECT *") << from(t)
+   db(sqlpp::statement_t{} << sqlpp::verbatim_clause("SELECT *") << from(t)
                            << where(t.id > 17)
                            << with_result_type_of(select(all_of(t))))) {
 (void)row.id;

include/sqlpp23/core/basic/verbatim.h

@@ -47,16 +47,6 @@ struct verbatim_t : public enable_as, enable_comparison {
   std::string _verbatim;
 };
 
-template <typename DataType>
-struct is_clause<verbatim_t<DataType>> : public std::true_type {};
-
-template <typename Statement, typename DataType>
-struct consistency_check<Statement, verbatim_t<DataType>> {
-  using type = consistent_t;
-  constexpr auto operator()() {
-    return type{};
-  }
-};
 template <typename DataType>
 struct data_type_of<verbatim_t<DataType>> {
   // Since we do not know what's going on inside the verbatim, we assume it can

include/sqlpp23/core/clause/verbatim_clause.h

@@ -0,0 +1,66 @@
+#pragma once
+
+/*
+ * Copyright (c) 2026, Roland Bock
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <utility>
+
+#include <sqlpp23/core/to_sql_string.h>
+#include <sqlpp23/core/type_traits.h>
+
+namespace sqlpp {
+struct verbatim_clause_t {
+  verbatim_clause_t(std::string verbatim_clause) : _verbatim_clause(std::move(verbatim_clause)) {}
+  verbatim_clause_t(const verbatim_clause_t&) = default;
+  verbatim_clause_t(verbatim_clause_t&&) = default;
+  verbatim_clause_t& operator=(const verbatim_clause_t&) = default;
+  verbatim_clause_t& operator=(verbatim_clause_t&&) = default;
+  ~verbatim_clause_t() = default;
+
+  std::string _verbatim_clause;
+};
+
+template <>
+struct is_clause<verbatim_clause_t> : public std::true_type {};
+
+template <typename Statement>
+struct consistency_check<Statement, verbatim_clause_t> {
+  using type = consistent_t;
+  constexpr auto operator()() {
+    return type{};
+  }
+};
+
+template <typename Context>
+auto to_sql_string(Context&, const verbatim_clause_t& t) -> std::string {
+  return t._verbatim_clause;
+}
+
+inline auto verbatim_clause(std::string s) -> verbatim_clause_t {
+  return {std::move(s)};
+}
+}  // namespace sqlpp

include/sqlpp23/sqlpp23.h

@@ -37,6 +37,7 @@
 #include <sqlpp23/core/clause/returning.h>
 #include <sqlpp23/core/clause/on_conflict.h>
 #include <sqlpp23/core/clause/using.h>
+#include <sqlpp23/core/clause/verbatim_clause.h>
 #include <sqlpp23/core/database/transaction.h>
 #include <sqlpp23/core/debug_logger.h>
 #include <sqlpp23/core/function.h>

modules/sqlpp23.core.cppm

@@ -37,8 +37,9 @@ export namespace sqlpp {
 using ::sqlpp::column_t;
 using ::sqlpp::table_t;
 using ::sqlpp::table_as_t;
+using ::sqlpp::verbatim_clause_t;
 using ::sqlpp::verbatim_t;
-using ::sqlpp::verbatim_table;
+using ::sqlpp::verbatim_table_t;
 using ::sqlpp::table_columns;
 using ::sqlpp::all_of;
 using ::sqlpp::enable_join;
@@ -51,6 +52,8 @@ using ::sqlpp::cross_join;
 using ::sqlpp::parameter;
 using ::sqlpp::parameter_t; // TODO remove?
 using ::sqlpp::verbatim;
+using ::sqlpp::verbatim_clause;
+using ::sqlpp::verbatim_table;
 using ::sqlpp::parameterized_verbatim;
 using ::sqlpp::schema;
 using ::sqlpp::schema_qualified_table;

tests/core/serialize/query/custom_query.cpp

@@ -67,7 +67,7 @@ int main() {
 
   // A pragma query for sqlite
   SQLPP_COMPARE(sqlpp::statement_t<>{}
-                    << sqlpp::verbatim("PRAGMA user_version")
+                    << sqlpp::verbatim_clause("PRAGMA user_version")
                     << with_result_type_of(select(sqlpp::value(1).as(pragma))),
                 "PRAGMA user_version");
 
@@ -90,7 +90,7 @@ int main() {
   batch.add_values(bar.textN = "sample", bar.boolNn = true);
   batch.add_values(bar.textN = "ample", bar.boolNn = false);
   SQLPP_COMPARE(sqlpp::insert()
-                    << sqlpp::verbatim(" OR IGNORE") << into(bar) << batch,
+                    << sqlpp::verbatim_clause(" OR IGNORE") << into(bar) << batch,
                 "INSERT OR IGNORE INTO tab_bar (text_n, bool_nn) VALUES "
                 "('sample', 1), ('ample', 0)");
 

tests/core/usage/CustomQuery.cpp

@@ -42,8 +42,8 @@ struct on_duplicate_key_update {
     return *this;
   }
 
-  auto get() const -> sqlpp::verbatim_t<::sqlpp::no_value_t> {
-    return ::sqlpp::verbatim(_serialized);
+  auto get() const -> sqlpp::verbatim_clause_t {
+    return ::sqlpp::verbatim_clause(_serialized);
   }
 };
 }  // namespace
@@ -57,7 +57,7 @@ int CustomQuery(int, char*[]) {
 
   // A void custom query
   auto x = sqlpp::statement_t{}
-           << sqlpp::verbatim("PRAGMA writeable_schema = 1");
+           << sqlpp::verbatim_clause("PRAGMA writeable_schema = 1");
   std::cerr << to_sql_string(printer, x) << std::endl;
   db(x);
 
@@ -76,14 +76,14 @@ int CustomQuery(int, char*[]) {
   }
 
   // Create a custom "insert or ignore"
-  db(sqlpp::insert() << sqlpp::verbatim(" OR IGNORE") << into(t)
+  db(sqlpp::insert() << sqlpp::verbatim_clause(" OR IGNORE") << into(t)
                      << insert_set(t.textN = "sample", t.boolNn = true));
 
   // Create a custom multi-row "insert or ignore"
   auto batch = insert_columns(t.textN, t.boolNn);
   batch.add_values(t.textN = "sample", t.boolNn = true);
   batch.add_values(t.textN = "ample", t.boolNn = false);
-  db(sqlpp::insert() << sqlpp::verbatim(" OR IGNORE") << into(t) << batch);
+  db(sqlpp::insert() << sqlpp::verbatim_clause(" OR IGNORE") << into(t) << batch);
 
   // Create a MYSQL style custom "insert on duplicate update"
   db(sqlpp::insert_into(t).set(t.textN = "sample", t.boolNn = true)
@@ -102,22 +102,24 @@ int CustomQuery(int, char*[]) {
                 "insert yields an integral value");
 
   auto d = sqlpp::statement_t{}
-           << sqlpp::verbatim("INSERT INTO tab_sample VALUES()")
+           << sqlpp::verbatim_clause("INSERT INTO tab_sample VALUES()")
            << with_result_type_of(sqlpp::insert());
   auto j = db(d).last_insert_id;
   static_assert(std::is_integral<decltype(j)>::value,
                 "insert yields an integral value");
 
   for (const auto& row :
-       db(sqlpp::statement_t{} << sqlpp::verbatim("PRAGMA user_version")
+       db(sqlpp::statement_t{} << sqlpp::verbatim_clause("PRAGMA user_version")
                                << with_result_type_of(select(all_of(t))))) {
     (void)row.id;
   }
 
+  (select(all_of(t)).from(t) << sqlpp::verbatim_clause("something")).as(sqlpp::alias::a);
+
   // If you really want the statement to contain "SELECT *" instead of every
   // column explicitly (maybe you are running into size limits?)
   for (const auto& row :
-       db(sqlpp::statement_t{} << sqlpp::verbatim("SELECT *") << from(t)
+       db(sqlpp::statement_t{} << sqlpp::verbatim_clause("SELECT *") << from(t)
                                << where(t.id > 17)
                                << with_result_type_of(select(all_of(t))))) {
     (void)row.id;

tests/mysql/usage/CustomQuery.cpp

@@ -44,8 +44,8 @@ struct on_duplicate_key_update {
     return *this;
   }
 
-  auto get() const -> sqlpp::verbatim_t<::sqlpp::no_value_t> {
-    return ::sqlpp::verbatim(_serialized);
+  auto get() const -> sqlpp::verbatim_clause_t {
+    return ::sqlpp::verbatim_clause(_serialized);
   }
 };
 }  // namespace

tests/postgresql/usage/Transaction.cpp

@@ -38,7 +38,7 @@ int Transaction(int, char*[]) {
       require_equal(__LINE__, db.is_transaction_active(), false);
       auto current_level = std::string(
           db(sqlpp::statement_t{}
-             << sqlpp::verbatim("show transaction_isolation;")
+             << sqlpp::verbatim_clause("show transaction_isolation;")
              << with_result_type_of(select(sqlpp::value("").as(level))))
               .front()
               .level);
@@ -50,7 +50,7 @@ int Transaction(int, char*[]) {
       require_equal(__LINE__, db.is_transaction_active(), true);
       current_level =
           db(sqlpp::statement_t{}
-             << sqlpp::verbatim("show transaction_isolation;")
+             << sqlpp::verbatim_clause("show transaction_isolation;")
              << with_result_type_of(select(sqlpp::value("").as(level))))
               .front()
               .level;