gda 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 90fd4381e4ad8e36706b5668d06a7aefd38bddb3
+  data.tar.gz: d4decc43386524ae4bb1b5f013b9c8e61284cf7d
+SHA512:
+  metadata.gz: 1a1cff3f1c41b0797b0acfc4432e8bdee15f37dd3a82737f44f30a5b39480450065c8f3d6e52e54dcf8c443023683b1c76910d0ab64cd5d6b6ffb2ff337eb3f6
+  data.tar.gz: a46766066ba0905568447e5d2b0068299cd4693dccc578683b17593cbd5feba30af797c44459786a7fdf6e21d9415a61851aaa6b6700b6ce21d964fb5f80c854

data/.autotest

@@ -0,0 +1,12 @@
+require "autotest/restart"
+require 'rbconfig'
+
+Autotest.add_hook :initialize do |at|
+  at.find_directories = ARGV unless ARGV.empty?
+  at.testlib = "minitest/autorun"
+end
+
+Autotest.add_hook :run_command do |at|
+  at.unit_diff = 'cat'
+  system "ruby -S rake compile"
+end

data/CHANGELOG.rdoc

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2012-07-13
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,27 @@
+.autotest
+CHANGELOG.rdoc
+Manifest.txt
+README.rdoc
+Rakefile
+ext/gda/extconf.rb
+ext/gda/gda.c
+ext/gda/gda.h
+ext/gda/gda_nodes.c
+ext/gda/gda_nodes.h
+ext/gda/gda_provider.c
+ext/gda/gda_provider.h
+ext/gda/gda_statement.c
+ext/gda/gda_statement.h
+lib/gda.rb
+lib/gda/visitors/dot.rb
+lib/gda/visitors/each.rb
+lib/gda/visitors/max_depth.rb
+lib/gda/visitors/visitor.rb
+test/helper.rb
+test/sqllog.sqlite3
+test/test_dot_visitor.rb
+test/test_gda.rb
+test/test_max_depth.rb
+test/test_node_attributes.rb
+test/test_nodes.rb
+test/test_statement.rb

data/README.rdoc

@@ -0,0 +1,61 @@
+= gda
+
+* http://github.com/tenderlove/gda
+
+== DESCRIPTION:
+
+An SQL parser. Wraps libgda in a loving embrace to give you a ruby level SQL
+parser.
+
+== FEATURES/PROBLEMS:
+
+* Not done yet
+* Do not use
+
+== SYNOPSIS:
+
+  parser = GDA::SQL::Parser.new
+
+  stmt = parser.parse 'SELECT * FROM FOO WHERE 1 = 1 GROUP BY omg HAVING omg(id) < 2 ORDER BY foo, bar LIMIT 50 OFFSET 2'
+
+  stmt.ast.each do |node|
+    p node
+  end
+
+  puts stmt.ast.to_dot
+
+== HACKING:
+
+    $ brew install libgda
+    $ gem install hoe rake-compiler
+    $ rake
+
+== INSTALL:
+
+* brew install libgda
+* gem install gda
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2012-2013 Aaron Patterson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,34 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.plugins.delete :rubyforge
+Hoe.plugin :minitest
+Hoe.plugin :gemspec # `gem install hoe-gemspec`
+Hoe.plugin :git     # `gem install hoe-git`
+
+Hoe.spec 'gda' do
+  developer('Aaron Patterson', 'tenderlove@ruby-lang.org')
+  self.readme_file   = 'README.rdoc'
+  self.history_file  = 'CHANGELOG.rdoc'
+  self.extra_rdoc_files  = FileList['*.rdoc']
+
+  extra_dev_deps << ['rake-compiler', '>= 0.4.1']
+  extra_dev_deps << ['sqlite3']
+
+  self.spec_extras = {
+    :extensions            => ["ext/gda/extconf.rb"],
+    :required_ruby_version => '>= 1.9.3'
+  }
+
+  require "rake/extensiontask"
+
+  Rake::ExtensionTask.new "gda", spec do |ext|
+    ext.lib_dir = File.join(*['lib', ENV['FAT_DIR']].compact)
+  end
+end
+
+task :test => :compile
+
+# vim: syntax=ruby

data/ext/gda/extconf.rb

@@ -0,0 +1,19 @@
+require 'mkmf'
+
+# :stopdoc:
+
+ENV['PKG_CONFIG_PATH']= '/usr/local/Library/ENV/pkgconfig/mountain_lion'
+
+dir_config 'libgda'
+
+def asplode missing
+  abort "#{missing} is missing. Try 'brew install libgda'"
+end
+
+pkg_config 'libgda-5.0'
+find_header('libgda/sql-parser/gda-sql-parser.h') || asplode("libgda")
+
+create_makefile 'gda'
+
+
+# :startdoc:

data/ext/gda/gda.c

@@ -0,0 +1,99 @@
+#include <gda.h>
+
+VALUE mGDA;
+VALUE mSQL;
+VALUE cParser;
+
+static VALUE allocate(VALUE klass)
+{
+    GdaSqlParser * parser;
+
+    parser = gda_sql_parser_new();
+    return Data_Wrap_Struct(klass, NULL, g_object_unref, parser);
+}
+
+static VALUE parse(VALUE self, VALUE sql)
+{
+    GdaSqlParser * parser;
+    GdaStatement * stmt;
+    GError * error;
+    const gchar * rest;
+
+    Data_Get_Struct(self, GdaSqlParser, parser);
+
+    stmt = gda_sql_parser_parse_string(parser, StringValuePtr(sql), &rest, &error);
+
+    if (!stmt) {
+	rb_raise(rb_eRuntimeError, "error parsing sql");
+    }
+
+    return Data_Wrap_Struct(cStatement, NULL, g_object_unref, stmt);
+}
+
+static VALUE providers(VALUE klass)
+{
+    GdaDataModel * providers;
+    gint i, nb;
+    VALUE list;
+
+    list = rb_ary_new();
+    providers = gda_config_list_providers();
+    nb = gda_data_model_get_n_rows(providers);
+
+    for (i = 0; i < nb; i++) {
+	const gchar *pname;
+	const GValue *cvalue;
+
+	cvalue = gda_data_model_get_value_at(providers, 0, i, NULL);
+
+	if (!cvalue)
+	    rb_raise(rb_eRuntimeError, "can't load provider");
+
+	pname = g_value_get_string(cvalue);
+
+	rb_ary_push(list, rb_str_new2(pname));
+    }
+
+    g_object_unref(providers);
+
+    return list;
+}
+
+static VALUE sql_identifier_split(VALUE klass, VALUE string)
+{
+    gchar ** list;
+    int i;
+    VALUE ids;
+
+    ids = rb_ary_new();
+    list = gda_sql_identifier_split(StringValuePtr(string));
+    for (i = 0; list[i]; i++) {
+	rb_ary_push(ids, rb_str_new2(list[i]));
+    }
+    g_strfreev(list);
+
+    return ids;
+}
+
+void Init_gda()
+{
+
+    mGDA = rb_define_module("GDA");
+    mSQL = rb_define_module_under(mGDA, "SQL");
+
+    Init_gda_statement();
+    Init_gda_nodes();
+    Init_gda_provider();
+    cParser = rb_define_class_under(mSQL, "Parser", rb_cObject);
+
+    rb_define_alloc_func(cParser, allocate);
+
+    rb_define_method(cParser, "parse", parse, 1);
+
+    rb_define_singleton_method(mSQL, "providers", providers, 0);
+    rb_define_singleton_method(mGDA, "sql_identifier_split", sql_identifier_split, 1);
+
+    gda_init();
+}
+
+/* vim: set noet sws=4 sw=4: */

data/ext/gda/gda.h

@@ -0,0 +1,18 @@
+#ifndef _RUBY_GDA
+#define _RUBY_GDA
+
+#include <ruby.h>
+#include <libgda/libgda.h>
+#include <libgda/sql-parser/gda-sql-parser.h>
+#include <libgda/sql-parser/gda-sql-statement.h>
+
+extern VALUE mGDA;
+extern VALUE mSQL;
+extern VALUE cStatement;
+extern VALUE cParser;
+
+#include <gda_statement.h>
+#include <gda_nodes.h>
+#include <gda_provider.h>
+
+#endif

data/ext/gda/gda_nodes.c

@@ -0,0 +1,516 @@
+#include <gda.h>
+
+VALUE mNodes;
+VALUE cSelect;
+VALUE cFrom;
+VALUE cSelectField;
+VALUE cExpr;
+VALUE cOrder;
+VALUE cNode;
+VALUE cOperation;
+VALUE cTarget;
+VALUE cFunction;
+VALUE cInsert;
+VALUE cDelete;
+VALUE cUpdate;
+VALUE cTable;
+VALUE cUnknown;
+VALUE cJoin;
+VALUE cField;
+VALUE cRollbackSavepoint;
+VALUE cDeleteSavepoint;
+VALUE cSavepoint;
+VALUE cBegin;
+VALUE cRollback;
+VALUE cCommit;
+
+#define WrapInteger(klass, type, lname) \
+    static VALUE rb_##klass##_##lname(VALUE self) \
+{ \
+    type *st;\
+    Data_Get_Struct(self, type, st); \
+    return INT2NUM(st->lname); \
+}
+
+#define WrapBoolean(klass, type, lname) \
+    static VALUE rb_##klass##_##lname(VALUE self) \
+{ \
+    type *st;\
+    Data_Get_Struct(self, type, st); \
+    if (st->lname) \
+      return Qtrue; \
+    else \
+      return Qfalse; \
+}
+
+#define WrapString(klass, type, lname) \
+    static VALUE rb_##klass##_##lname(VALUE self) \
+{ \
+    type *st;\
+    Data_Get_Struct(self, type, st); \
+    if (st->lname) \
+      return rb_str_new2(st->lname); \
+    else \
+      return Qnil; \
+}
+
+#define WrapNode(klass, type, lname) \
+    static VALUE rb_##klass##_##lname(VALUE self) \
+{ \
+    type *st;\
+    VALUE stmt;\
+    Data_Get_Struct(self, type, st); \
+    stmt = rb_iv_get(self, "stmt"); \
+    return WrapAnyPart(stmt, (GdaSqlAnyPart *)st->lname); \
+}
+
+#define WrapList(klass, type, lname) \
+    static VALUE rb_##klass##_##lname(VALUE self) \
+{ \
+    type *ptr; \
+    GSList *list; \
+    VALUE rb_list; \
+    VALUE stmt; \
+    Data_Get_Struct(self, type, ptr);\
+    stmt = rb_iv_get(self, "stmt"); \
+    rb_list = rb_ary_new(); \
+    list = ptr->lname; \
+    while(list) { \
+	rb_ary_push(rb_list, WrapAnyPart(stmt, (GdaSqlAnyPart *)list->data)); \
+	list = list->next; \
+    } \
+    return rb_list; \
+}
+
+#define WrapperMethod(klass, lname) \
+    rb_define_method(klass, #lname, rb_##klass##_##lname, 0);
+
+WrapString(cTable, GdaSqlTable, table_name);
+
+WrapString(cField, GdaSqlField, field_name);
+
+WrapNode(cSelect, GdaSqlStatementSelect, distinct_expr);
+WrapList(cSelect, GdaSqlStatementSelect, expr_list);
+WrapNode(cSelect, GdaSqlStatementSelect, from);
+WrapNode(cSelect, GdaSqlStatementSelect, where_cond);
+WrapList(cSelect, GdaSqlStatementSelect, group_by);
+WrapNode(cSelect, GdaSqlStatementSelect, having_cond);
+WrapList(cSelect, GdaSqlStatementSelect, order_by);
+WrapNode(cSelect, GdaSqlStatementSelect, limit_count);
+WrapNode(cSelect, GdaSqlStatementSelect, limit_offset);
+
+WrapNode(cSelectField, GdaSqlSelectField, expr);
+WrapString(cSelectField, GdaSqlSelectField, field_name);
+WrapString(cSelectField, GdaSqlSelectField, table_name);
+WrapString(cSelectField, GdaSqlSelectField, as);
+
+WrapNode(cExpr, GdaSqlExpr, func);
+WrapNode(cExpr, GdaSqlExpr, cond);
+WrapNode(cExpr, GdaSqlExpr, select);
+WrapNode(cExpr, GdaSqlExpr, case_s);
+WrapNode(cExpr, GdaSqlExpr, param_spec);
+WrapString(cExpr, GdaSqlExpr, cast_as);
+WrapBoolean(cExpr, GdaSqlExpr, value_is_ident);
+
+WrapList(cFrom, GdaSqlSelectFrom, targets);
+WrapList(cFrom, GdaSqlSelectFrom, joins);
+
+WrapList(cOperation, GdaSqlOperation, operands);
+
+WrapNode(cTarget, GdaSqlSelectTarget, expr);
+WrapString(cTarget, GdaSqlSelectTarget, table_name);
+WrapString(cTarget, GdaSqlSelectTarget, as);
+
+WrapList(cFunction, GdaSqlFunction, args_list);
+WrapString(cFunction, GdaSqlFunction, function_name);
+
+WrapNode(cOrder, GdaSqlSelectOrder, expr);
+WrapBoolean(cOrder, GdaSqlSelectOrder, asc);
+WrapString(cOrder, GdaSqlSelectOrder, collation_name);
+
+WrapNode(cInsert, GdaSqlStatementInsert, table);
+WrapList(cInsert, GdaSqlStatementInsert, fields_list);
+WrapNode(cInsert, GdaSqlStatementInsert, select);
+WrapString(cInsert, GdaSqlStatementInsert, on_conflict);
+
+WrapNode(cUpdate, GdaSqlStatementUpdate, table);
+WrapList(cUpdate, GdaSqlStatementUpdate, fields_list);
+WrapList(cUpdate, GdaSqlStatementUpdate, expr_list);
+WrapNode(cUpdate, GdaSqlStatementUpdate, cond);
+WrapString(cUpdate, GdaSqlStatementUpdate, on_conflict);
+
+WrapNode(cDelete, GdaSqlStatementDelete, table);
+WrapNode(cDelete, GdaSqlStatementDelete, cond);
+
+WrapNode(cJoin, GdaSqlSelectJoin, expr);
+WrapList(cJoin, GdaSqlSelectJoin, use);
+WrapInteger(cJoin, GdaSqlSelectJoin, position);
+
+WrapList(cUnknown, GdaSqlStatementUnknown, expressions);
+
+static VALUE distinct_p(VALUE self)
+{
+    GdaSqlStatementSelect * st;
+
+    Data_Get_Struct(self, GdaSqlStatementSelect, st);
+
+    if (st->distinct)
+	return Qtrue;
+
+    return Qfalse;
+}
+
+static VALUE Wrap(VALUE stmt, VALUE klass, GdaSqlAnyPart *part)
+{
+    VALUE obj = Data_Wrap_Struct(klass, NULL, NULL, part);
+    rb_iv_set(obj, "stmt", stmt);
+    return obj;
+}
+
+VALUE WrapAnyPart(VALUE stmt, GdaSqlAnyPart *part)
+{
+    if (!part)
+	return Qnil;
+
+    switch(part->type) {
+	case GDA_SQL_ANY_STMT_SELECT:
+	    return Wrap(stmt, cSelect, part);
+	    break;
+	case GDA_SQL_ANY_STMT_INSERT:
+	    return Wrap(stmt, cInsert, part);
+	    break;
+	case GDA_SQL_ANY_STMT_UPDATE:
+	    return Wrap(stmt, cUpdate, part);
+	    break;
+	case GDA_SQL_ANY_STMT_DELETE:
+	    return Wrap(stmt, cDelete, part);
+	    break;
+	case GDA_SQL_ANY_STMT_BEGIN:
+	    return Wrap(stmt, cBegin, part);
+	    break;
+	case GDA_SQL_ANY_STMT_ROLLBACK:
+	    return Wrap(stmt, cRollback, part);
+	    break;
+	case GDA_SQL_ANY_STMT_COMMIT:
+	    return Wrap(stmt, cCommit, part);
+	    break;
+	case GDA_SQL_ANY_STMT_SAVEPOINT:
+	    return Wrap(stmt, cSavepoint, part);
+	    break;
+	case GDA_SQL_ANY_STMT_ROLLBACK_SAVEPOINT:
+	    return Wrap(stmt, cRollbackSavepoint, part);
+	    break;
+	case GDA_SQL_ANY_STMT_DELETE_SAVEPOINT:
+	    return Wrap(stmt, cDeleteSavepoint, part);
+	    break;
+	case GDA_SQL_ANY_STMT_UNKNOWN:
+	    return Wrap(stmt, cUnknown, part);
+	    break;
+	case GDA_SQL_ANY_SQL_SELECT_FROM:
+	    return Wrap(stmt, cFrom, part);
+	    break;
+	case GDA_SQL_ANY_SQL_SELECT_FIELD:
+	    return Wrap(stmt, cSelectField, part);
+	    break;
+	case GDA_SQL_ANY_EXPR:
+	    return Wrap(stmt, cExpr, part);
+	    break;
+	case GDA_SQL_ANY_SQL_FIELD:
+	    return Wrap(stmt, cField, part);
+	    break;
+	case GDA_SQL_ANY_SQL_SELECT_ORDER:
+	    return Wrap(stmt, cOrder, part);
+	    break;
+	case GDA_SQL_ANY_SQL_TABLE:
+	    return Wrap(stmt, cTable, part);
+	    break;
+	case GDA_SQL_ANY_SQL_OPERATION:
+	    return Wrap(stmt, cOperation, part);
+	    break;
+	case GDA_SQL_ANY_SQL_FUNCTION:
+	    return Wrap(stmt, cFunction, part);
+	    break;
+	case GDA_SQL_ANY_SQL_SELECT_TARGET:
+	    return Wrap(stmt, cTarget, part);
+	    break;
+	case GDA_SQL_ANY_SQL_SELECT_JOIN:
+	    return Wrap(stmt, cJoin, part);
+	    break;
+	default:
+	    rb_raise(rb_eRuntimeError, "unknown node type: %d\n", part->type);
+	    return Qnil;
+    }
+}
+
+static VALUE rb_cInsert_values_list(VALUE self)
+{
+    GdaSqlStatementInsert * st;
+    GSList * list;
+    VALUE array;
+    VALUE stmt;
+
+    Data_Get_Struct(self, GdaSqlStatementInsert, st);
+
+    stmt = rb_iv_get(self, "stmt");
+
+    array = rb_ary_new();
+    list = st->values_list;
+    while(list) {
+	VALUE iarray = rb_ary_new();
+	GSList * inner = (GSList *)list->data;
+
+	while(inner) {
+	  rb_ary_push(iarray, WrapAnyPart(stmt, (GdaSqlAnyPart *)inner->data));
+	  inner = inner->next;
+	}
+
+	rb_ary_push(array, iarray);
+	list = list->next;
+    }
+
+    return array;
+}
+
+static VALUE rb_cOperation_operator(VALUE self)
+{
+    GdaSqlOperation * st;
+
+    Data_Get_Struct(self, GdaSqlOperation, st);
+
+    if (st->operator_type)
+	return rb_str_new2(gda_sql_operation_operator_to_string(st->operator_type));
+
+    return Qnil;
+}
+
+static VALUE rb_cJoin_join_type(VALUE self)
+{
+    GdaSqlSelectJoin * st;
+
+    Data_Get_Struct(self, GdaSqlSelectJoin, st);
+
+    if (st->type)
+	return rb_str_new2(gda_sql_select_join_type_to_string(st->type));
+
+    return Qnil;
+}
+
+static VALUE rb_st_type(VALUE self)
+{
+    GdaSqlAnyPart * st;
+
+    Data_Get_Struct(self, GdaSqlAnyPart, st);
+
+    switch(st->type) {
+	case GDA_SQL_ANY_STMT_BEGIN:
+	    return rb_str_new2("BEGIN");
+	    break;
+	case GDA_SQL_ANY_STMT_ROLLBACK:
+	    return rb_str_new2("ROLLBACK");
+	    break;
+	case GDA_SQL_ANY_STMT_COMMIT:
+	    return rb_str_new2("COMMIT");
+	    break;
+	case GDA_SQL_ANY_STMT_SAVEPOINT:
+	    return rb_str_new2("SAVEPOINT");
+	    break;
+	case GDA_SQL_ANY_STMT_ROLLBACK_SAVEPOINT:
+	    return rb_str_new2("ROLLBACK SAVEPOINT");
+	    break;
+	case GDA_SQL_ANY_STMT_DELETE_SAVEPOINT:
+	    return rb_str_new2("DELETE SAVEPOINT");
+	    break;
+	default:
+	    return Qnil;
+    }
+}
+
+static VALUE rb_st_isolation_level(VALUE self)
+{
+    GdaSqlStatementTransaction * st;
+
+    Data_Get_Struct(self, GdaSqlStatementTransaction, st);
+
+    switch(st->isolation_level) {
+	default:
+	case GDA_TRANSACTION_ISOLATION_UNKNOWN:
+	    return rb_str_new2("UNKNOWN");
+	    break;
+	case GDA_TRANSACTION_ISOLATION_READ_COMMITTED:
+	    return rb_str_new2("READ COMMITTED");
+	    break;
+	case GDA_TRANSACTION_ISOLATION_READ_UNCOMMITTED:
+	    return rb_str_new2("READ UNCOMMITTED");
+	    break;
+	case GDA_TRANSACTION_ISOLATION_REPEATABLE_READ:
+	    return rb_str_new2("REPEATABLE READ");
+	    break;
+	case GDA_TRANSACTION_ISOLATION_SERIALIZABLE:
+	    return rb_str_new2("SERIALIZABLE");
+	    break;
+    }
+}
+
+static VALUE rb_st_trans_mode(VALUE self)
+{
+    GdaSqlStatementTransaction * st;
+
+    Data_Get_Struct(self, GdaSqlStatementTransaction, st);
+
+    if (st->trans_mode)
+	return rb_str_new2(st->trans_mode);
+
+    return Qnil;
+}
+
+static VALUE rb_st_trans_name(VALUE self)
+{
+    GdaSqlStatementTransaction * st;
+
+    Data_Get_Struct(self, GdaSqlStatementTransaction, st);
+
+    if (st->trans_name)
+	return rb_str_new2(st->trans_name);
+
+    return Qnil;
+}
+
+static VALUE rb_cExpr_value(VALUE self)
+{
+    GdaSqlExpr * st;
+    GValue * val;
+
+    Data_Get_Struct(self, GdaSqlExpr, st);
+
+    val = st->value;
+
+    return rb_str_new2(gda_value_stringify(val));
+}
+
+void Init_gda_nodes()
+{
+    mNodes = rb_define_module_under(mGDA, "Nodes");
+
+    cNode = rb_define_class_under(mNodes, "Node", rb_cObject);
+
+    cSelect = rb_define_class_under(mNodes, "Select", cNode);
+    rb_define_method(cSelect, "distinct?", distinct_p, 0);
+
+    WrapperMethod(cSelect, from);
+    WrapperMethod(cSelect, distinct_expr);
+    WrapperMethod(cSelect, expr_list);
+    WrapperMethod(cSelect, where_cond);
+    WrapperMethod(cSelect, group_by);
+    WrapperMethod(cSelect, having_cond);
+    WrapperMethod(cSelect, order_by);
+    WrapperMethod(cSelect, limit_count);
+    WrapperMethod(cSelect, limit_offset);
+
+    cSelectField = rb_define_class_under(mNodes, "SelectField", cNode);
+    WrapperMethod(cSelectField, expr);
+    WrapperMethod(cSelectField, field_name);
+    WrapperMethod(cSelectField, table_name);
+    WrapperMethod(cSelectField, as);
+
+    cExpr = rb_define_class_under(mNodes, "Expr", cNode);
+    WrapperMethod(cExpr, func);
+    WrapperMethod(cExpr, cond);
+    WrapperMethod(cExpr, select);
+    WrapperMethod(cExpr, case_s);
+    WrapperMethod(cExpr, param_spec);
+    WrapperMethod(cExpr, cast_as);
+    WrapperMethod(cExpr, value);
+    WrapperMethod(cExpr, value_is_ident);
+
+    cFrom = rb_define_class_under(mNodes, "From", cNode);
+    WrapperMethod(cFrom, targets);
+    WrapperMethod(cFrom, joins);
+
+    cOperation = rb_define_class_under(mNodes, "Operation", cNode);
+    WrapperMethod(cOperation, operands);
+    WrapperMethod(cOperation, operator);
+
+    cTarget = rb_define_class_under(mNodes, "Target", cNode);
+    WrapperMethod(cTarget, expr);
+    WrapperMethod(cTarget, table_name);
+    WrapperMethod(cTarget, as);
+
+    cFunction = rb_define_class_under(mNodes, "Function", cNode);
+    WrapperMethod(cFunction, args_list);
+    WrapperMethod(cFunction, function_name);
+
+    cOrder = rb_define_class_under(mNodes, "Order", cNode);
+    WrapperMethod(cOrder, expr);
+    WrapperMethod(cOrder, asc);
+    WrapperMethod(cOrder, collation_name);
+
+    cInsert = rb_define_class_under(mNodes, "Insert", cNode);
+    WrapperMethod(cInsert, table);
+    WrapperMethod(cInsert, values_list);
+    WrapperMethod(cInsert, fields_list);
+    WrapperMethod(cInsert, select);
+    WrapperMethod(cInsert, on_conflict);
+
+    cDelete = rb_define_class_under(mNodes, "Delete", cNode);
+    WrapperMethod(cDelete, table);
+    WrapperMethod(cDelete, cond);
+
+    cUpdate = rb_define_class_under(mNodes, "Update", cNode);
+    WrapperMethod(cUpdate, table);
+    WrapperMethod(cUpdate, fields_list);
+    WrapperMethod(cUpdate, expr_list);
+    WrapperMethod(cUpdate, cond);
+    WrapperMethod(cUpdate, on_conflict);
+
+    cTable = rb_define_class_under(mNodes, "Table", cNode);
+    WrapperMethod(cTable, table_name);
+
+    cUnknown = rb_define_class_under(mNodes, "Unknown", cNode);
+    WrapperMethod(cUnknown, expressions);
+
+    cJoin = rb_define_class_under(mNodes, "Join", cNode);
+    WrapperMethod(cJoin, expr);
+    WrapperMethod(cJoin, use);
+    WrapperMethod(cJoin, join_type);
+    WrapperMethod(cJoin, position);
+
+    cField = rb_define_class_under(mNodes, "Field", cNode);
+    WrapperMethod(cField, field_name);
+
+    cBegin = rb_define_class_under(mNodes, "Begin", cNode);
+    cRollback = rb_define_class_under(mNodes, "Rollback", cNode);
+    cCommit = rb_define_class_under(mNodes, "Commit", cNode);
+    cSavepoint = rb_define_class_under(mNodes, "Savepoint", cNode);
+    cRollbackSavepoint = rb_define_class_under(mNodes, "RollbackSavepoint", cNode);
+    cDeleteSavepoint = rb_define_class_under(mNodes, "DeleteSavepoint", cNode);
+
+    rb_define_method(cRollbackSavepoint, "__type__", rb_st_type, 0);
+    rb_define_method(cBegin, "__type__", rb_st_type, 0);
+    rb_define_method(cSavepoint, "__type__", rb_st_type, 0);
+    rb_define_method(cCommit, "__type__", rb_st_type, 0);
+    rb_define_method(cRollback, "__type__", rb_st_type, 0);
+    rb_define_method(cDeleteSavepoint, "__type__", rb_st_type, 0);
+
+    rb_define_method(cRollbackSavepoint, "isolation_level", rb_st_isolation_level, 0);
+    rb_define_method(cBegin, "isolation_level", rb_st_isolation_level, 0);
+    rb_define_method(cSavepoint, "isolation_level", rb_st_isolation_level, 0);
+    rb_define_method(cCommit, "isolation_level", rb_st_isolation_level, 0);
+    rb_define_method(cRollback, "isolation_level", rb_st_isolation_level, 0);
+    rb_define_method(cDeleteSavepoint, "isolation_level", rb_st_isolation_level, 0);
+
+    rb_define_method(cRollbackSavepoint, "trans_mode", rb_st_trans_mode, 0);
+    rb_define_method(cBegin, "trans_mode", rb_st_trans_mode, 0);
+    rb_define_method(cSavepoint, "trans_mode", rb_st_trans_mode, 0);
+    rb_define_method(cCommit, "trans_mode", rb_st_trans_mode, 0);
+    rb_define_method(cRollback, "trans_mode", rb_st_trans_mode, 0);
+    rb_define_method(cDeleteSavepoint, "trans_mode", rb_st_trans_mode, 0);
+
+    rb_define_method(cRollbackSavepoint, "trans_name", rb_st_trans_name, 0);
+    rb_define_method(cBegin, "trans_name", rb_st_trans_name, 0);
+    rb_define_method(cSavepoint, "trans_name", rb_st_trans_name, 0);
+    rb_define_method(cCommit, "trans_name", rb_st_trans_name, 0);
+    rb_define_method(cRollback, "trans_name", rb_st_trans_name, 0);
+    rb_define_method(cDeleteSavepoint, "trans_name", rb_st_trans_name, 0);
+}
+
+/* vim: set noet sws=4 sw=4: */