ygrek.org / p / sqlgg

sqlgg: SQL Guided (code) Generator

SQL query parser and binding code generator for C#, C++, Java, OCaml.

• Problem
• Solution
• Complete example
• Details
• Download

-- @create_person
CREATE TABLE person (id INTEGER PRIMARY KEY AUTOINCREMENT,name TEXT,surname TEXT);
-- @add_person
INSERT INTO person (name,surname) VALUES;

-- @create_money
CREATE TABLE money (src INTEGER, dst INTEGER, amount INTEGER);
-- @add_money
INSERT INTO money VALUES;

-- @calc_total
SELECT name || ' ' || surname AS fullname, SUM(amount) as total FROM person JOIN money ON src = id GROUP BY id;
-- @list_donors
SELECT DISTINCT surname FROM person JOIN money ON src = id AND dst = (SELECT id FROM person WHERE surname LIKE ?) LIMIT ?;

DROP TABLE IF EXISTS person;
DROP TABLE IF EXISTS money;

// DO NOT EDIT MANUALLY
//
// generated by sqlgg 0.2.2+ (f5b76ac7) on 2009-05-30T19:22Z
// visit http://ygrek.org/p/sqlgg/

#pragma once

template <class Traits>
struct sqlgg
{
  struct create_person
  {
    create_person(typename Traits::connection db);
    bool operator()();
  }; // struct create_person

  struct add_person
  {
    add_person(typename Traits::connection db);
    bool operator()(typename Traits::Text const& name, typename Traits::Text const& surname);
  }; // struct add_person

  struct create_money
  {
    create_money(typename Traits::connection db);
    bool operator()();
  }; // struct create_money

  struct add_money
  {
    add_money(typename Traits::connection db);
    bool operator()(typename Traits::Int const& src, typename Traits::Int const& dst, typename Traits::Int const& amount);
  }; // struct add_money

  struct calc_total
  {
    calc_total(typename Traits::connection db);
    template<class T>
    bool operator()(T result);
  }; // struct calc_total

  struct list_donors
  {
    list_donors(typename Traits::connection db);
    template<class T>
    bool operator()(typename Traits::Text const& _0, typename Traits::Int const& _1, T result);
  }; // struct list_donors

  struct drop_person
  {
    drop_person(typename Traits::connection db);
    bool operator()();
  }; // struct drop_person

  struct drop_money
  {
    drop_money(typename Traits::connection db);
    bool operator()();
  }; // struct drop_money

  create_person create_person;
  add_person add_person;
  create_money create_money;
  add_money add_money;
  calc_total calc_total;
  list_donors list_donors;
  drop_person drop_person;
  drop_money drop_money;

  sqlgg(typename Traits::connection db) : create_person(db), add_person(db), create_money(db), add_money(db), calc_total(db), list_donors(db), drop_person(db), drop_money(db)
  {
  }
}; // struct sqlgg

Things to note above:

1. Syntax. All queries are written in plain SQL. Every statement should be terminated with semicolon. There is no need to write (?,?) after VALUES in INSERT statement. The annotation [sqlgg] name=function_name (or simply @function_name) before the query specifies the name of the generated function (this annotation is optional but very convenient).
2. The generated code is parametrized by database-specific class Traits. It specifies the correspondence between SQL and native types, provides types for database connection and implements actual code to execute statements. Traits should be implemented once for every specific database API.
3. Each statement has a corresponding struct which takes connection object as a constructor argument. This allows to reuse prepared statements several times (if database supports this feature).
4. add_money() function call operator takes three data parameters – the values to INSERT into table (note the names and types).
5. calc_total() returns data via result parameter, which is a callback that gets executed for each row of the resulting rowset, with statically typed parameters binding each column of a row. In this case the parameters are fullname of type Traits::Text and total of type Traits::Int.
6. The types of parameters for list_donors were inferred correctly (limit is Int and surname is Text.
7. Statements of arbitrary depth across many tables are supported.
8. Statements are checked for correctness as far as generator is concerned, so it will detect syntax errors, non-existent columns in expressions, mismatched columns in compound statements, ambiguous column names etc.

#include "../impl/sqlite3_traits.hpp" // sqlite3 traits
#include "demo_cxx_gen.hpp" // generated
#include <iostream>
#include <vector>

using namespace std;

typedef sqlgg<sqlite3_traits> gen_t;
typedef long long int64;

struct output_transfers
{
  void operator()(std::string const& fullname, int total)
  {
     cout << fullname << " = " << total << endl;
  }
};

struct output_donors
{
  void operator()(std::string const& surname)
  {
     cout << surname << endl;
  }
};

int main()
{
  sqlite3* db = NULL;
  sqlite3_open(":memory:", &db);

  gen_t gen(db);

  // create tables
  gen.create_person();
  gen.create_money();

  // add all person records
  gen.add_person("John","Black");
  int64 john = sqlite3_last_insert_rowid(db);
  gen.add_person("Ivan","Petrov");
  int64 ivan = sqlite3_last_insert_rowid(db);
  gen.add_person("Sancho","Alvares");
  int64 sancho = sqlite3_last_insert_rowid(db);

  // add money relations
  gen.add_money(john,ivan,200);
  gen.add_money(john,sancho,100);
  gen.add_money(john,sancho,250);
  gen.add_money(sancho,ivan,300);

  // summarize by person
  cout << "Total transfers:" << endl;
  gen.calc_total(output_transfers());

  // list donors
  cout << "Donors:" << endl;
  gen.list_donors("petrov",100,output_donors());

  // properly close database
  sqlite3_close(db);

  return 0;
}

The code is straightforward and free of most database-specific details. More importantly it is statically checked by the compiler – suppose we change the database schema and add one more field to money table (e.g. timestamp of transfer). Compilation rightfully fails:

demo_cxx.cpp: In function `int main()':
demo_cxx.cpp:29: error: no matching function for call to
`sqlgg<sqlite3_traits>::add_money(sqlite3*&, int64&, int64&, int)'
demo_cxx_gen.hpp:75: note: candidates are: static bool sqlgg<Traits>::add_money(typename
Traits::connection, const typename Traits::Int&, const typename Traits::Int&, const typename
Traits::Int&, const typename Traits::Int&) [with Traits = sqlite3_traits]

This project was started when I found myself editing existing code with tons of C++ wrappers for SQL queries, each binding several parameters and decomposing results. I used it successfully for C++ desktop applications with sqlite3 engine and C#/Mono server-side component with mysql database and OCaml projects with sqlite3 and mysql too.

Sqlgg understands the subset of the standard SQL language with arbitrary database-specific extensions. The goal is to cover as much SQL as possible in order to accept most of the real-world SQL statements unmodified. It will not (currently) warn on incompatible syntax (e.g. from two different sql dialects) used in the same project (but it may do so in the future).

Available output languages:

• C#: code for System.Data (generated code example, usage example).
• C++: code is parametrized with template class for database specific code (generated code example, sqlite3 traits, usage example (sqlite3), mysql traits, usage example (mysql)).
• Java: code for JDBC (generated code example, usage example).
• OCaml: functor parametrized with module for database specific code Sqlgg_traits.M (generated code example, OCaml-SQLite3 traits, usage example, complete example for sulci jabber bot).
• XML: input parameters and rowset schema with types and names – everything needed to further generate code (e.g. using XSLT) in some other language (generated xml example)

Install from OPAM with:

opam install sqlgg

Or download latest release and build manually from ygrek.org or github.

See changes history.

Source repository at github or repo.or.cz.

2020-05-22

ygrek at autistici dot org