gda 1.0.0

data/ext/gda/gda_nodes.h

@@ -0,0 +1,9 @@
+#ifndef _RUBY_GDA_NODES
+#define _RUBY_GDA_NODES
+
+void Init_gda_nodes();
+
+VALUE WrapAnyPart(VALUE stmt, GdaSqlAnyPart *part);
+
+#endif
+

data/ext/gda/gda_provider.c

@@ -0,0 +1,61 @@
+#include <gda.h>
+
+VALUE cProvider;
+
+static VALUE name(VALUE self)
+{
+    GdaServerProvider * pr;
+    Data_Get_Struct(self, GdaServerProvider, pr);
+
+    return rb_tainted_str_new2(gda_server_provider_get_name(pr));
+}
+
+static VALUE find(VALUE klass, VALUE string)
+{
+    GdaServerProvider * pr;
+    GError * error = NULL;
+
+    pr = gda_config_get_provider(StringValuePtr(string), &error);
+
+    if (pr)
+	return Data_Wrap_Struct(klass, NULL, NULL, pr);
+    else {
+	/* FIXME: should actually raise an error here. */
+	g_error_free(error);
+	return Qnil;
+    }
+}
+
+static VALUE parser(VALUE self)
+{
+    GdaSqlParser * parser;
+    GdaServerProvider * pr;
+
+    Data_Get_Struct(self, GdaServerProvider, pr);
+
+    parser = gda_server_provider_create_parser(pr, NULL);
+
+    if (!parser)
+	rb_raise(rb_eRuntimeError, "zomglol");
+
+    return Data_Wrap_Struct(cParser, NULL, g_object_unref, parser);
+}
+
+static VALUE quote_str(VALUE self, VALUE str)
+{
+    GdaServerProvider * pr;
+
+    Data_Get_Struct(self, GdaServerProvider, pr);
+    return rb_str_new2(gda_sql_identifier_quote(StringValuePtr(str), NULL, pr, TRUE, TRUE));
+}
+
+void Init_gda_provider()
+{
+    cProvider = rb_define_class_under(mSQL, "Provider", rb_cObject);
+    rb_define_singleton_method(cProvider, "find", find, 1);
+    rb_define_method(cProvider, "name", name, 0);
+    rb_define_method(cProvider, "parser", parser, 0);
+    rb_define_method(cProvider, "quote", quote_str, 1);
+}
+
+/* vim: set noet sws=4 sw=4: */

data/ext/gda/gda_provider.h

@@ -0,0 +1,7 @@
+#ifndef _RUBY_GDA_PROVIDER
+#define _RUBY_GDA_PROVIDER
+
+void Init_gda_provider();
+
+#endif
+

data/ext/gda/gda_statement.c

@@ -0,0 +1,58 @@
+#include <gda.h>
+
+VALUE cStatement;
+VALUE cStructure;
+
+static VALUE serialize(VALUE self)
+{
+    GdaStatement * stmt;
+    gchar * string;
+
+    Data_Get_Struct(self, GdaStatement, stmt);
+
+    string = gda_statement_serialize(stmt);
+    return rb_str_new2(string);
+}
+
+static VALUE ast(VALUE self)
+{
+    GdaSqlStatement * sqlst;
+
+    Data_Get_Struct(self, GdaSqlStatement, sqlst);
+
+    return WrapAnyPart(self, GDA_SQL_ANY_PART(sqlst->contents));
+}
+
+static VALUE sql(VALUE self)
+{
+    GdaSqlStatement * sqlst;
+
+    Data_Get_Struct(self, GdaSqlStatement, sqlst);
+
+    return rb_str_new2(sqlst->sql);
+}
+
+static VALUE structure(VALUE self)
+{
+    GdaStatement * stmt;
+    GdaSqlStatement * sqlst;
+
+    Data_Get_Struct(self, GdaStatement, stmt);
+
+    g_object_get(G_OBJECT(stmt), "structure", &sqlst, NULL);
+
+    return Data_Wrap_Struct(cStructure, NULL, gda_sql_statement_free, sqlst);
+}
+
+void Init_gda_statement()
+{
+    cStatement = rb_define_class_under(mSQL, "Statement", rb_cObject);
+    cStructure = rb_define_class_under(mSQL, "Structure", rb_cObject);
+
+    rb_define_method(cStatement, "serialize", serialize, 0);
+    rb_define_method(cStatement, "structure", structure, 0);
+    rb_define_method(cStructure, "ast", ast, 0);
+    rb_define_method(cStructure, "sql", sql, 0);
+}
+
+/* vim: set noet sws=4 sw=4: */

data/ext/gda/gda_statement.h

@@ -0,0 +1,6 @@
+#ifndef _RUBY_GDA_STATEMENT
+#define _RUBY_GDA_STATEMENT
+
+void Init_gda_statement();
+
+#endif

data/lib/gda.rb

@@ -0,0 +1,39 @@
+require 'gda.so'
+require 'gda/visitors/each'
+require 'gda/visitors/dot'
+require 'gda/visitors/max_depth'
+
+module GDA
+  VERSION = '1.0.0'
+
+  module SQL
+    class Statement
+      def ast
+        structure.ast
+      end
+
+      def sql
+        structure.sql
+      end
+    end
+  end
+
+  module Nodes
+    class Node
+      include Enumerable
+
+      def each &block
+        Visitors::Each.new(block).accept self
+      end
+
+      def to_dot
+        viz = Visitors::Dot.new
+        viz.accept self
+      end
+
+      def max_depth
+        Visitors::MaxDepth.new.accept(self)
+      end
+    end
+  end
+end

data/lib/gda/visitors/dot.rb

@@ -0,0 +1,188 @@
+require 'gda/visitors/visitor'
+require 'erb'
+require 'stringio'
+
+module GDA
+  module Visitors
+    class Dot < GDA::Visitors::Visitor
+      attr_reader :stack
+
+      def initialize io = StringIO.new
+        @stack  = []
+        @buffer = io
+      end
+
+      HEADER = "digraph G { graph [rankdir = \"TB\"];"
+      FOOTER = "}"
+
+      def accept node
+        puts HEADER
+        super
+        puts FOOTER
+        @buffer.string
+      end
+
+      private
+
+      def puts str
+        @buffer.puts str
+      end
+
+      def printf *args
+        @buffer.printf(*args)
+      end
+
+      NODE = ERB.new <<-eoerb
+node<%= node.object_id %> [shape="plaintext" label=<
+<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0" CELLPADDING="4">
+<TR><TD COLSPAN="2"><%= node.class %></TD></TR>
+<% attrs.each do |attr| %>
+  <% next if node.send(attr).nil? %>
+  <TR><TD><%= ERB::Util.h attr %></TD><TD><%= ERB::Util.h node.send(attr) %></TD></TR>
+<% end %>
+</TABLE>>];
+      eoerb
+
+      LIST = ERB.new <<-eoerb
+node<%= node.object_id %> [shape="invhouse", color=gray, fontcolor=gray, label=list];
+      eoerb
+
+      def add_node node, attrs = []
+        puts NODE.result binding
+        link_node node
+      end
+
+      FMT = "node%d -> node%d [ label = \"%s\" ];\n"
+
+      def link_node node
+        return if stack.empty?
+        printf FMT, stack.last.first.object_id, node.object_id, stack.last.last
+      end
+
+      def add_list node
+        puts LIST.result binding
+        link_node node
+      end
+
+      def visit_edge node, edge
+        stack.push [node, edge]
+        visit node.send edge
+        stack.pop
+      end
+
+      def visit_Array node
+        return if node.empty?
+
+        add_list node
+        node.each_with_index { |n, i|
+          stack.push [node, i]
+          visit n
+          stack.pop
+        }
+      end
+
+      def visit_GDA_Nodes_Insert node
+        add_node node, [:on_conflict]
+        visit_edge node, :table
+        visit_edge node, :fields_list
+        visit_edge node, :values_list
+      end
+
+      def visit_GDA_Nodes_Update node
+        add_node node, [:on_conflict]
+        visit_edge node, :table
+        visit_edge node, :fields_list
+        visit_edge node, :expr_list
+        visit_edge node, :cond
+      end
+
+      def visit_GDA_Nodes_Delete node
+        add_node node
+        visit_edge node, :table
+        visit_edge node, :cond
+      end
+
+      def visit_GDA_Nodes_Select node
+        add_node node
+        visit_edge node, :distinct_expr
+        visit_edge node, :expr_list
+        visit_edge node, :from
+        visit_edge node, :where_cond
+        visit_edge node, :group_by
+        visit_edge node, :having_cond
+        visit_edge node, :order_by
+        visit_edge node, :limit_count
+        visit_edge node, :limit_offset
+      end
+
+      def visit_GDA_Nodes_Table node
+        add_node node, [:table_name]
+      end
+
+      def visit_GDA_Nodes_SelectField node
+        add_node node, [:field_name, :table_name, :as]
+        visit_edge node, :expr
+      end
+
+      def visit_GDA_Nodes_Expr node
+        add_node node, [:value, :cast_as]
+        visit_edge node, :func
+        visit_edge node, :cond
+        visit_edge node, :select
+        visit_edge node, :case_s
+        visit_edge node, :param_spec
+      end
+
+      def visit_GDA_Nodes_Field node
+        add_node node, [:field_name]
+      end
+
+      def visit_GDA_Nodes_Operation node
+        add_node node, [:operator]
+        visit_edge node, :operands
+      end
+
+      def visit_GDA_Nodes_From node
+        add_node  node
+        visit_edge node, :targets
+        visit_edge node, :joins
+      end
+
+      def visit_GDA_Nodes_Target node
+        add_node  node, [:table_name, :as]
+        visit_edge node, :expr
+      end
+
+      def visit_GDA_Nodes_Function node
+        add_node  node, [:function_name]
+        visit_edge node, :args_list
+      end
+
+      def visit_GDA_Nodes_Order node
+        add_node  node, [:asc, :collation_name]
+        visit_edge node, :expr
+      end
+
+      def visit_GDA_Nodes_Unknown node
+        add_node  node
+        visit_edge node, :expressions
+      end
+
+      def visit_GDA_Nodes_Join node
+        add_node node, [:join_type, :position]
+        visit_edge node, :expr
+        visit_edge node, :use
+      end
+
+      def visit_GDA_Nodes_Savepoint node
+        add_node node, [:__type__, :isolation_level, :trans_mode, :trans_name]
+      end
+
+      alias visit_GDA_Nodes_RollbackSavepoint visit_GDA_Nodes_Savepoint
+      alias visit_GDA_Nodes_DeleteSavepoint   visit_GDA_Nodes_Savepoint
+      alias visit_GDA_Nodes_Rollback          visit_GDA_Nodes_Savepoint
+      alias visit_GDA_Nodes_Commit            visit_GDA_Nodes_Savepoint
+      alias visit_GDA_Nodes_Begin             visit_GDA_Nodes_Savepoint
+    end
+  end
+end

data/lib/gda/visitors/each.rb

@@ -0,0 +1,18 @@
+require 'gda/visitors/visitor'
+
+module GDA
+  module Visitors
+    class Each < Visitor
+      def initialize block
+        @block = block
+      end
+
+      def visit node
+        super
+        unless node.nil? || Array === node
+          @block.call node
+        end
+      end
+    end
+  end
+end

data/lib/gda/visitors/max_depth.rb

@@ -0,0 +1,29 @@
+require 'gda/visitors/visitor'
+
+module GDA
+  module Visitors
+    class MaxDepth < Visitor
+      def initialize
+        @max     = 0
+        @current = 0
+        super
+      end
+
+      def accept node
+        super
+        @max
+      end
+
+      private
+
+      def visit node
+        return super if node.nil?
+
+        @current += 1
+        super
+        @max = [@max, @current].max
+        @current -= 1
+      end
+    end
+  end
+end

data/lib/gda/visitors/visitor.rb

@@ -0,0 +1,129 @@
+module GDA
+  module Visitors
+    class Visitor
+      def accept node
+        visit node
+      end
+
+      private
+
+      def visit node
+        return unless node
+
+        method = METHOD_CACHE.fetch(node.class) { |k|
+          "visit_" + k.name.split('::').join('_')
+        }
+
+        send method, node
+      end
+
+      def visit_Array node
+        node.each { |n| visit n }
+      end
+
+      def visit_GDA_Nodes_Select node
+        visit node.distinct_expr
+        visit node.expr_list
+        visit node.from
+        visit node.where_cond
+        visit node.group_by
+        visit node.having_cond
+        visit node.order_by
+        visit node.limit_count
+        visit node.limit_offset
+      end
+
+      def visit_GDA_Nodes_Insert node
+        visit node.table
+        visit node.fields_list
+        visit node.values_list
+        visit node.select
+      end
+
+      def visit_GDA_Nodes_Update node
+        visit node.table
+        visit node.fields_list
+        visit node.expr_list
+        visit node.cond
+      end
+
+      def visit_GDA_Nodes_Join node
+        visit node.expr
+        visit node.use
+      end
+
+      def visit_GDA_Nodes_Delete node
+        visit node.table
+        visit node.cond
+      end
+
+      def visit_GDA_Nodes_SelectField node
+        visit node.expr
+      end
+
+      def visit_GDA_Nodes_Expr node
+        visit node.func
+        visit node.cond
+        visit node.select
+        visit node.case_s
+        visit node.param_spec
+      end
+
+      def visit_GDA_Nodes_From node
+        visit node.targets
+        visit node.joins
+      end
+
+      def visit_GDA_Nodes_Target node
+        visit node.expr
+      end
+
+      def visit_GDA_Nodes_Operation node
+        visit node.operands
+      end
+
+      def visit_GDA_Nodes_Function node
+        visit node.args_list
+      end
+
+      def visit_GDA_Nodes_Order node
+        visit node.expr
+      end
+
+      def visit_GDA_Nodes_Unknown node
+        visit node.expressions
+      end
+
+      ## Terminal nodes
+      def visit_GDA_Nodes_Table node
+      end
+
+      def visit_GDA_Nodes_Field node
+      end
+
+      def visit_GDA_Nodes_Savepoint node
+      end
+
+      def visit_GDA_Nodes_RollbackSavepoint node
+      end
+
+      def visit_GDA_Nodes_Begin node
+      end
+
+      def visit_GDA_Nodes_DeleteSavepoint node
+      end
+
+      def visit_GDA_Nodes_Rollback node
+      end
+
+      def visit_GDA_Nodes_Commit node
+      end
+
+      METHOD_CACHE = {}
+      private_instance_methods.grep(/^visit_(.*)$/) do |method|
+        k = $1.split('_').inject(Object) { |klass,c| klass.const_get c }
+        METHOD_CACHE[k] = method
+      end
+    end
+  end
+end