SqlStatement 1.0.0

data/bin/example.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+require_gem 'SqlStatement'
+require 'sql/statement'
+require 'sql/expression'
+
+# We subclass the standard classes so that we can construct
+# a query with a complex computed field. The newlists method
+# makes this easy, giving us a constructor and combination
+# operators for free.
+
+class ProbabilityParts < SQLStatement::SelectParts
+   newlists :multiply
+end
+class ProbabilityStatement < SQLStatement::SelectCreate
+   newlists :multiply
+
+   # Add our own special fields here, computed
+   # from the list we added to this class.
+   def allfields
+      retval=super
+      retval.merge! :probability =>
+	 SQLFunc(@multiply.collect{|x| x.to_sqlpart}.join('*'))
+      retval
+   end
+end
+
+
+#In real life, I use a special library for detecting what attributes
+#are available based on the columns in my tables.
+#We'll mimic that functionality here.
+#
+#The first definition of this module mocks the stuff that's in my more
+#complicated library
+module AttributeDetection
+   class Attribute
+      def initialize(domain,name)
+	 @domain=domain
+	 @name=name
+      end
+      attr_reader :name, :domain
+   end
+   class Hierarchy < Attribute
+      def initialize(leftcolumn)
+	 ignored1,m_domain,m_name,ignored2=leftcolumn.split(/_/)
+	 super(m_domain,m_name)
+      end
+   end
+   class DomainlessPerGroup < Attribute
+      def initialize (colname)
+	 name=@colname=colname
+	 domain="!"
+	 super(domain,name)
+      end
+   end
+
+   #I have a few other attribute types, none of which
+   #are used in this code yet.
+
+end
+
+include SQLHelpers
+
+#The second definition of this module is the code that I actually define
+#in this particular program.
+module AttributeDetection
+   class Attribute
+      def condname
+	 :"cond_#{name}"
+      end
+      def priorname
+	 :"prior_#{name}"
+      end
+      #parts that go in to the CREATE TABLE `probabilities` statement
+      #which relate to the attribute we are disambiguating
+      def probability_disambig 
+	 parts=ProbabilityParts.new
+	 parts.add_fields [priorname[probkey]]
+	 parts.add_tables [priorname]
+	 parts.multiply << priorname[:pt]
+	 parts
+      end
+      #parts that go in to the CREATE TABLE `probabilities` statement
+      #which relate to the attributes we are using as features
+      def probability_features(conditionalon)
+	 parts=ProbabilityParts.new
+	 parts.tables={priorname=>priorname,condname=>condname}
+	 parts.add_fields [priorname[probkey]]
+	 parts.conditions << sql_func{ condname[probkey]==priorname[probkey]}
+	 parts.conditions << sql_func{
+	    condname[conditionalon.probkey]==
+	    conditionalon.priorname[conditionalon.probkey]
+	    }
+	 parts.multiply << sql_func{condname[:pt]/priorname[:pt]}
+	 parts
+      end
+   end
+   class Hierarchy
+      def probkey
+	 "att_#{domain}_#{name}_left".to_sym
+      end
+   end
+   class DomainlessPerGroup
+      def probkey
+	 @colname.to_sym
+      end
+   end
+end
+
+include AttributeDetection
+include SQLHelpers
+
+#And this code calls methods to actually build the query.
+
+#First we define the names of the attributes
+att_disambig=Hierarchy.new("att_appraisal_attitude_left")
+att_features=[Hierarchy.new("att_products_appraisedtype_left"),
+   DomainlessPerGroup.new("priority")]
+
+
+#Then we construct the statement
+stmt=ProbabilityStatement.new :probabilities,true
+
+stmt << att_disambig.probability_disambig 
+att_features.each { |x| stmt<< x.probability_features(att_disambig) }
+
+#Finally, we print it (or execute it against the database)
+puts stmt.to_s
+   
+

data/lib/sql/bathon-sxp.rb

@@ -0,0 +1,265 @@
+#Copyright 2006 Dominik Bathon, released under the BSD license.
+#
+#Written for Ruby Quiz #95[http://www.rubyquiz.com/quiz95.html]. If you 
+#dislike the use of rubynode (or rubynode breaks in some future 
+#version), you can probably substitute in any solution to the quiz, 
+#although you may lose some functionality by doing so. Particularly, the 
+#+or+, +and+, +not+, +||+, +&&+, +!+ and +!=+ operators are difficult or 
+#impossible to make work correctly in a pure ruby s-expression 
+#generator.
+
+require 'rubygems'
+require "rubynode"
+
+class Node2Sexp
+   BINARY_METHODS = [:+, :-, :*, :/, :%, :**, :^, :<, :>, :<=, :>=, :==, :|, :&]
+   def initialize(binding)
+     @binding = binding
+   end
+
+   # (transformed) nodes are arrays, that look like:
+   # [:type, attribute hash or array of nodes]
+   def to_sexp(node)
+     node && send("#{node.first}_to_sexp", node.last)
+   end
+
+   # fixed argument lists are represented as :array nodes, e.g.
+   # [:array, [argnode1, argnode2, ...]]
+   def process_args(args_node)
+     return [] unless args_node
+     if args_node.first == :array
+       args_node.last.map { |node| to_sexp(node) }
+     else
+       raise "variable arguments not allowed"
+     end
+   end
+
+   def is_sql?(arg)
+      return true if arg[0]==:vcall and arg[1][:mid]==:sql
+      return true if [:lvar,:dvar].include?(arg[0]) and arg[1][:vid]==:sql
+      return false
+   end
+
+   #returns the +self+ in which the block was contained
+   def origself
+      eval("self",@binding)
+   end
+
+   # :call nodes: method call with explicit receiver:
+   # nil.foo => [:call, {:args=>false, :mid=>:foo, :recv=>[:nil, {}]}]
+   # nil == nil =>
+   # [:call, {:args=>[:array, [[:nil, {}]]], :mid=>:==, :recv=>[:nil, {}]}]
+   def call_to_sexp(hash)
+     mid=hash[:mid]
+     args=process_args(hash[:args])
+     if is_sql?(hash[:recv])
+        return [mid, *args]
+     end
+     recv=to_sexp(hash[:recv])
+     if BINARY_METHODS.include?(mid)
+	[mid, recv, *args]
+     else
+        recv.send(mid,*args)
+     end
+   end
+
+   # :fcall nodes: function call (no explicit receiver):
+   # foo() => [:fcall, {:args=>false, :mid=>:foo}]
+   # foo(nil) => [:fcall, {:args=>[:array, [[:nil, {}]]], :mid=>:foo]
+   def fcall_to_sexp(hash)
+     if origself.methods.include?(hash[:mid].to_s)
+        origself.send(hash[:mid],*process_args(hash[:args]))
+     else
+	[hash[:mid], *process_args(hash[:args])]
+     end
+   end
+
+   # :vcall nodes: function call that looks like variable
+   # foo => [:vcall, {:mid=>:foo}]
+   alias vcall_to_sexp fcall_to_sexp
+
+   # :lit nodes: literals
+   # 1 => [:lit, {:lit=>1}]
+   # :abc => [:lit, {:lit=>:abc}]
+   def lit_to_sexp(hash)
+     hash[:lit]
+   end
+
+   # :str nodes: strings without interpolation
+   # "abc" => [:str, {:lit=>"abc"}]
+   alias str_to_sexp lit_to_sexp
+
+   def nil_to_sexp(hash) nil end
+   def false_to_sexp(hash) false end
+   def true_to_sexp(hash) true end
+
+   # :lvar nodes: local variables
+   # var => [:lvar, {:cnt=>3, :vid=>:var}]
+   # cnt is the index in the lvar  table
+   def lvar_to_sexp(hash)
+     eval(hash[:vid].to_s, @binding)
+   end
+   # :dvar nodes: block local variables
+   # var => [:dvar, {:vid=>:var}]
+   alias dvar_to_sexp lvar_to_sexp
+   # :ivar nodes: instance variables
+   alias ivar_to_sexp lvar_to_sexp
+   # :cvar nodes: class variables
+   alias cvar_to_sexp lvar_to_sexp
+   alias const_to_sexp lvar_to_sexp
+
+   def self_to_sexp(hash)
+      origself
+   end
+
+   # :not nodes: boolean negation
+   # not :field => [:not, {:body=>[:lit, {:lit=>:field}]}]
+   # !:field => [:not, {:body=>[:lit, {:lit=>:field}]}]
+   def not_to_sexp(hash)
+     body = to_sexp(hash[:body])
+     if Array === body && body[0] == :== && body.size == 3
+       [:"!=", body[1], body[2]]
+     else
+       [:not, body]
+     end
+   end
+
+   def and_to_sexp(hash)
+      [:& , to_sexp(hash[:first]), to_sexp(hash[:second])]
+   end
+
+   def or_to_sexp(hash)
+      [:| , to_sexp(hash[:first]), to_sexp(hash[:second])]
+   end
+
+end
+
+def sxp(&block)
+   body = block.body_node
+   return nil unless body
+   Node2Sexp.new(block).to_sexp(body.transform)
+end
+
+if $0 == __FILE__ then
+   require 'test/unit'
+
+   class TestQuiz < Test::Unit::TestCase
+     def test_sxp_nested_calls
+       assert_equal [:max, [:count, :name]], sxp{max(count(:name))}
+     end
+
+     def test_sxp_vcall
+       assert_equal [:abc], sxp{abc}
+     end
+
+     def test_sxp_call_plus_eval
+       assert_equal [:count, [:+, 3, 7]], sxp{count(3+7)}
+     end
+
+     def test_sxp_call_with_multiple_args
+       assert_equal [:count, 3, 7], sxp{count(3,7)}
+     end
+
+     def test_sxp_binarymsg_mixed_1
+       assert_equal [:+, 3, :symbol], sxp{3+:symbol}
+     end
+
+     def test_sxp_binarymsg_mixed_call
+       assert_equal [:+, 3, [:count, :field]], sxp{3+count(:field)}
+     end
+
+     def test_sxp_binarymsg_mixed_2
+       assert_equal [:/, 7, :field], sxp{7/:field}
+     end
+
+     def test_sxp_binarymsg_mixed_3
+       assert_equal [:>, :field, 5], sxp{:field > 5}
+     end
+
+     def test_sxp_lits
+       assert_equal 8, sxp{8}
+     end
+
+     def test_sxp_true_false_nil
+       assert_equal [:+, true, false], sxp{true+false}
+       assert_equal nil, sxp{nil}
+     end
+
+     def test_sxp_empty
+       assert_equal nil, sxp{}
+     end
+
+     def test_sxp_binarymsg_syms
+       assert_equal [:==, :field1, :field2], sxp{:field1 == :field2 }
+     end
+
+     def test_sxp_variables
+       lvar = :field # local variable
+       assert_equal [:count, :field], sxp{ count(lvar) }
+       proc {
+         dvar = :field2 # dynavar (block local variable)
+         assert_equal [:==, :field, :field2], sxp{ lvar == dvar }
+       }.call
+     end
+
+     def test_sxp_not
+       assert_equal [:not, :field], sxp{ not :field }
+       assert_equal [:"!=", :a, :b], sxp{ :a != :b }
+     end
+
+     def test_sxp_from_sander_dot_land_at_gmail_com
+       assert_equal [:==,[:^, 2, 3], [:^, 1, 1]], sxp{ 2^3 == 1^1}
+       assert_equal [:==, [:+, 3.0, 0.1415], 3], sxp{3.0 + 0.1415 == 3}
+
+       assert_equal([:|,
+                     [:==, [:+, :hello, :world], :helloworld],
+                     [:==, [:+, [:+, "hello", " "], "world"], "hello world"]] ,
+                    sxp {
+                      (:hello + :world == :helloworld) |
+                      ('hello' + ' ' + 'world' == 'hello world')
+                    })
+
+#       assert_equal  [:==, [:+, [:abs, [:factorial, 3]],
+#                            [:*, [:factorial,  4], 42]],
+#                      [:+, [:+, 4000000, [:**, 2, 32]], [:%, 2.7, 1.1]]],
+#       sxp{ 3.factorial.abs + 4.factorial * 42 ==  4_000_000 + 2**32 + 2.7  % 1.1 }
+     end
+
+     def test_ihavenocluewhy
+       assert_equal 11, 5 + 6
+       assert_raise(TypeError) { 7 / :field }
+       assert_raise(NoMethodError) { 7+count(:field) }
+       assert_raise(NoMethodError) { :field > 5 }
+     end
+
+     def test_methodcall
+       #free functions should be turned in to s-expressions
+       #binary operators (which are specially-named methods) should be
+       # turned into s-expressions
+       #(these are tested in other tests)
+
+       #but bound functions should be called, and this is what's tested 
+       #here
+       assert_equal [:+,3,5], sxp{ 3 + "hello".length }
+     end
+
+     def test_indexoperator
+	Symbol.class_eval { define_method :[] do |arg| self end }
+	assert_equal :table, sxp{:table[:field]}
+     end
+
+     def test_keywords_and_or
+        assert_equal [:|, [:<, 1, 2], [:<, 3, 4]], sxp{1<2 or 3<4}
+	assert_equal [:|, [:<, 1, 2], [:<, 3, 4]], sxp{1<2 || 3<4}
+	assert_equal [:&, [:<, 1, 2], [:<, 3, 4]], sxp{1<2 and 3<4}
+	assert_equal [:&, [:<, 1, 2], [:<, 3, 4]], sxp{1<2 && 3<4}
+     end
+
+     def test_self
+        assert_equal self, sxp{self}
+	assert_equal [:object_id], sxp{object_id}
+	assert_equal object_id, sxp{self.object_id}
+     end
+   end
+end
+

data/lib/sql/expression.rb

@@ -0,0 +1,59 @@
+require 'sql/bathon-sxp'
+
+class Array
+   def rest
+      self[1..-1]
+   end
+   def rest_sqlpart
+      rest.collect {|x| x.to_sqlpart}.join(", ")
+   end
+   def to_sqlpart
+      if first==:count_distinct
+	 "count(distinct "+rest_sqlpart+")"
+      elsif first.to_s =~ /[a-zA-Z]/
+	 first.to_s+"("+rest_sqlpart+")"
+      elsif x={:& => " and ", :| => " or ", :== => "="}[first]
+	 "("+self[1].to_sqlpart+x+self[2].to_sqlpart+")"
+      else
+	 "("+self[1].to_sqlpart+first.to_s+self[2].to_sqlpart+")"
+      end
+   end
+   def placeheld
+      rest.collect{|x| x.placeheld}.flatten
+   end
+end
+
+module SQLHelpers
+   #this function takes a block containing an expression, and converts 
+   #it to a proper SQL expression.
+   #
+   #The rules for doing so are quite complex:
+   #* all Ruby binary operaters are converted to their SQL equivalents
+   #* the + operator on strings is never converted to the
+   #  <tt>concat()</tt> function. Use the concat() function directly.
+   #* the <tt>count_distinct(...)</tt> function is converted to
+   #  <tt>count(distinct ...)</tt>.
+   #* all Ruby variable references are evaluated and their values
+   #  substituted, with the exception of the special +sql+ logical
+   #  method reciever.
+   #* method calls on ruby objects are evaluated, with the exception of
+   #  the logical +sql+ method reciever.
+   #* free functions (for example <tt>count(:field)</tt>) that are
+   #  undefined in the surrounding scope are returned as SQL
+   #  function calls.
+   #* free functions that are defined in the surrounding scope are
+   #  called by Ruby. To override this behavior, specify the function
+   #  as a method call on the virtual reciever +sql+ (for example,
+   #  <tt>sql.object_id</tt> becomes <tt>object_id()</tt>, because
+   #  in ordinary Ruby contexts, object_id is almost always defined,
+   #  and will therefore be evaluated.)
+   #* Symbols are interpreted as field names, just like everywhere else 
+   #  in this library. Array indexes evaluate to tablename.fieldname
+   #  references. The special symbol <tt>:*</tt> converts to a literal 
+   #  SQL <tt>*</tt>
+   #* <tt>#{...}</tt> interpolated strings are not supported (yet).
+   #* Other objects (except Arrays) are treated as themselves.
+   def sql_func(&block)
+      sxp(&block)
+   end
+end

data/lib/sql/statement.rb

@@ -0,0 +1,539 @@
+=begin rdoc
+= sqlstatement - Generate complex SQL statements programmatically
+
+The main goal of this library is to be able to construct an SQL statement
+from "slices" that concern different aspects of the final query (perhaps
+in different places in your code) and then combine them all together into
+one statement easily.
+
+Another important goal of this library is to give some consistent Ruby
+syntax to three statements (INSERT, SELECT, and UPDATE) that seem to have
+different enough syntax that one has two write different code to generate
+each kind of statement.
+
+I use my SQL database (specifically MySQL) largely as a bulk data
+processing engine, by doing INSERT...SELECT or CREATE TABLE...SELECT
+statements. This library is intended to make that kind of coding easier. I
+expect that Object Relational mappers (such as ActiveRecord) are more
+useful for most people, who are performing queries and
+inserting/updating/querying for individual records. I have nevertheless 
+added INSERT...VALUES statements, and will add other statements soon, for 
+consistency.
+
+This library is inspired by CLSQL[http://clsql.b9.com/] for Common LISP,
+or SchemeQL[http://schematics.sourceforge.net/schemeql.html] for Scheme,
+although it is very different from these two libraries. Scheme and
+LISP's use of s-expressions make it very easy to construct an entire
+sublanguage for the WHERE clause, simply by list parsing.  The
+Criteria[http://mephle.org/Criteria/] library for Ruby has attempted
+this, but in a more limited manner than SchemeQL or CLSQL.  My library
+aims to cover much of the functionality in these libraries.
+
+This library doesn't try to abstract out the limitations of your DBMS, and
+I think that the SQL it uses should be fairly portable, in large measure
+because it hasn't attempted to deal with serious CREATE TABLE statements,
+where a lot of syntax concerning types, keys and sequences is much more
+variable.
+
+==License
+
+Copyright (c) 2006 Ken Bloom
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. 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.
+3. Neither Ken Bloom's name, nor the name of any of his contributors may
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE KEN BLOOM 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 REGENTS 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.
+=end
+
+# Everything in Ruby is a descendant of the Object class. Practically
+# speaking, this means that any object that hasn't otherwise defined
+# the +placeheld+ and <tt>to_sqlpart</tt> methods will be treated as a piece
+# of data (rather than as an SQL instruction).
+class Object
+
+   # Generates a string representation to be included in the SQL statement's string representation.
+   def to_sqlpart
+      "?"
+   end
+   # When the string representation includes unbound variables (represented in sql with a +?+),
+   # then the values to be bound to them are returned here, in the proper order.
+   # This allows SQL statements to be called in a manner similar to
+   #    s=Select.new
+   #    s << SelectParts.new {...}
+   #    dbh.execute(s.to_s, *s.placeheld)
+   # When there are no unbound variables, and empty array is returned.
+   def placeheld; [self]; end
+end
+
+# Symbols are used for representing table names and field names, and aliases for these.
+# They correctly expand into SQL so as not to cause syntax errors, even if the symbol happens
+# to be the same as a reserved word in SQL.
+class Symbol
+
+   def to_sqlpart
+      if self==:*
+	 to_s
+      else
+	 "`"+to_s+"`"
+      end
+   end
+
+   def placeheld; []; end
+
+   #Create an SQL_Field object referencing the column +column+ in the
+   #table named by this symbol.
+   def [](column)
+      SQLStatement::SQL_Field.new(self,column)
+   end
+end
+
+module SQLStatement
+
+# This class is used to represent complex SQL expressions, so that
+# queries can return expressions. This is also meant to be used for
+# conditions in a WHERE clause. There are no utility classes for
+# generating these (even though they'll probably include field names
+# and other kinds of values), but for convenience, they can be generated
+# with <tt>Kernel#SQLFunc</tt>.
+class Function < String
+
+   def initialize(val="",placeheld=[])
+      super
+      @placeheld=placeheld
+   end
+
+   #you need to manually keep this list of values for placeholders in
+   #sync with the actual string contained in this expression.
+   attr_accessor :placeheld
+
+   def to_sqlpart
+      self
+   end
+end
+
+
+# +SQL_Field+ is used for representing field names qualified by table names.
+# Their text expansion looks like <tt>`tablename`.`fieldname`</tt>.
+class SQL_Field
+
+   def initialize(table,field)
+      @table,@field=table,field
+   end
+
+   attr_reader :table, :field
+
+   def to_sqlpart
+      @table.to_sqlpart+"."+@field.to_sqlpart
+   end
+
+   #This is used when performing #{...} substitions
+   #although technically, it should be made to work like the Symbol.to_s 
+   #(which gives unquoted results), this works just fine giving quoted 
+   #results.
+   def to_s
+      to_sqlpart
+   end	 
+
+   def placeheld; []; end
+end
+
+
+# This class is used to represent a (possibly coherent) set of parts to add to a SQL statement.
+# If we wanted to generate SQL code similar to
+#    SELECT `value1`,`value2`
+#    FROM `jointable`,`dictionary1`,`dictionary2`
+#    WHERE `jointable`.`id1`=`dictionary1`.`id` AND `jointable`.`id2`=`dictionary2`.`id`
+# then it may make sense for your application to generate
+# the +dictionary1+ code and the +dictionary2+ code separately,
+# in different +SelectParts+ objects, then combine them into one +Select+.
+#    stmt=Select.new
+#    stmt.tablesarray << :jointable
+#    (1..2).each do |x|
+#       s=SelectParts.new
+#       s.add_fields [:"value#{x}"]
+#       s.add_tables [:"dictionary#{x}"]
+#       s.conditions << SQLFunc("`jointable`.`id#{x}`=`dictionary#{x}`.`id`")
+#       stmt << s
+#    end
+#    dbh.execute(stmt.to_s,*stmt.placeheld)
+class SelectParts
+
+   def expectarray (arg,hash)
+      v=hash[arg]
+      if v==nil
+	 []
+      elsif Array===v
+	 v
+      else
+	 [v]
+      end
+   end
+
+   def expecthash (arg,hash,*options)
+      v=hash[arg]
+      if v==nil
+	 v={}
+      elsif Array===v and not options.include?(:PreserveArray)
+	 v=Hash[*([v,v].transpose.flatten)]
+      elsif Array===v
+	 v
+      elsif Hash===v
+	 v
+      else
+	 [v]
+      end
+   end
+
+   protected :expectarray,:expecthash
+
+   #Initializes the various pieces of the SQL statement to values specified in the hash.
+   #Use Symbols corresponding to the attribute names to set an attribute here, otherwise a default
+   #empty array or hash will be used.
+   def initialize(hash={})
+      @fields=expecthash :fields,hash,:PreserveArray
+      @tables=expecthash :tables,hash,:PreserveArray
+      @conditions=expectarray :conditions,hash
+      @groupby=expectarray :groupby,hash
+      @orderby=expectarray :orderby,hash
+   end
+
+   #See the documentation for SelectStatement which describes these.
+   attr_accessor :conditions, :groupby, :orderby, :fields, :tables
+
+   #Adds an array of unaliased fields to this SQL statement. See 
+   #documentation at SelectStatement
+   def add_fields (newfields)
+      newfields.each do |x|
+	 @fields[x]=x
+      end
+   end
+
+   #Adds an array of unaliased tables to this SQL statement. See 
+   #documentation for SelectStatement
+   def add_tables (newtables)
+      newtables.each do |x|
+	 @tables[x]=x
+      end
+   end
+
+   #Merge several SelectParts objects into one.
+   def +(rhs)
+      b=self.dup
+      b.fields.merge!(rhs.fields)
+      b.tables.merge!(rhs.tables)
+      b.conditions+=rhs.conditions
+      b.groupby+=rhs.groupby
+      b.orderby+=rhs.orderby
+      b
+   end
+
+   class << self
+      #Use this to define additional array attributes in descendant classes
+      #with all of the necessary addition, initialization and merging (<<) 
+      #semantics. <b>You can only call this function once per class, as
+      #it redefines methods each time it is called.</b>
+      def newlists *lists
+	 attr_accessor *lists
+
+	 lines=lists.collect do |listname|
+	    ["@#{listname}=expectarray :#{listname},hash",
+	     "b.#{listname}+=rhs.#{listname}"]
+	 end.transpose
+	 class_eval <<-"end;"
+	    def initialize hash={}
+	       super
+	       #{lines[0].join("\n")}
+	    end
+	    def + (rhs)
+	       b=super
+	       #{lines[1].join("\n")}
+	       b
+	    end
+	 end;
+      end
+      protected :newlists
+   end
+
+end
+
+# Creates a SELECT statement
+class Select
+   def initialize
+      @fields={}
+      @tables={}
+      @conditions=[]
+      @groupby=[]
+      @orderby=[]
+   end
+
+   #This is the list of fields or instructions to be retrieved. In a
+   #+SELECT+ statement, this appears immediately after the +SELECT+ keyword.
+   #In an +UPDATE+ statement, this appears after the +SET+ keyword. (And in other
+   #places for other kinds of queries  #In an +UPDATE+ statement, this appears after the +SET+ keyword. (And in other
+   #places for other kinds of queries. The SQL inventors were nothing if not consistent.)
+   #
+   #This is a hash of fields to be used in the SQL statmenet. Entries are in the 
+   #form <tt>alias => underlying_expression</tt>. If you are not 
+   #aliasing a field name, use the form <tt>fieldname => fieldname</tt>.
+   attr_accessor :fields
+
+   #Adds an array of unaliased fields to this SQL statement.
+   def add_fields (newfields)
+      newfields.each do |x|
+	 @fields[x]=x
+      end
+   end
+
+   #This is the tables to include in the query (i.e. the +FROM+ clause). 
+   #
+   #This is a hash of tables to be used in the SQL statmenet. Entries are in the 
+   #form <tt>alias => underlying_expression</tt>. If you are not 
+   #aliasing a table name, use the form <tt>tablename => tablename</tt>.
+   attr_accessor :tables
+
+   #Adds an array of unaliased tables to this SQL statement.
+   def add_tables (newtables)
+      newtables.each do |x|
+	 @tables[x]=x
+      end
+   end
+
+   #This is an array of Function objects that specify the contents of 
+   #the +WHERE+ clause.
+   attr_accessor :conditions
+
+   #Specifieds fields or expressions to group by, as an array.
+   attr_accessor :groupby
+
+   #Specifieds fields or expressions to sort by, as an array.
+   attr_accessor :orderby
+
+   #If you overriding this class (or any of its subclasses) to constructing other fields
+   #from other lists, override this function, call +super+, construct the additional fields here,
+   #and add them to the result of +super+. Then return the resulting hash.
+   def allfields
+      @fields.dup
+   end
+
+   #Select whether this is a SELECT statement or a SELECT DISTINCT 
+   #statement. (non-distinct by default)
+   attr_writer :distinct
+
+   def distinct
+      @distinct ||= false
+   end
+
+   #Merges the various parts of a SelectParts into the correct places in this SQL statement.
+   def << (parts)
+      @fields.merge!(parts.fields)
+      @tables.merge!(parts.tables)
+      @conditions += parts.conditions
+      @groupby += parts.groupby
+      @orderby += parts.orderby
+      self
+   end
+
+   #Returns the SQL string that you would actually want to execute on the database.
+   #it may contain placeholders for actual data. Those actual data can
+   #be retrieved with the placeheld method, and used in a manner similar to
+   #    dbh.execute(s.to_s,*s.placeheld)
+   def to_s
+      statement="SELECT #{distinct ? 'DISTINCT' : ''} #{fields_s} FROM #{tables_s}"
+      v=conditions_s; statement << " WHERE "<< v if v
+      v=groupby_s; statement << " GROUP BY "<< v if v
+      v=orderby_s; statement << " ORDER BY "<< v if v
+      return statement
+   end
+
+   def placeheld
+      (allfields.values+@tables.values+conditions+groupby+orderby).collect{|x| x.placeheld}.flatten
+   end
+
+   #This is useful for writing nested queries.
+   def to_sqlpart
+      "("+to_s+")"
+   end
+   protected
+
+   def tables_s
+      @tables.collect{|key,value| value==key ? key.to_sqlpart : "#{value.to_sqlpart} as #{key.to_sqlpart}"}.join(", ")
+   end
+
+   def conditions_s
+      @conditions==[] ? nil : @conditions.collect{|x| x.to_sqlpart}.join(" AND ")
+   end
+
+   def groupby_s
+      @groupby==[] ? nil : @groupby.collect{|x| x.to_sqlpart}.join(", ")
+   end
+
+   def orderby_s
+      @orderby==[] ? nil : @orderby.collect{|x| x.to_sqlpart}.join(", ")
+   end
+
+   def fields_s
+      allfields.collect{|key,value| value==key ? key.to_sqlpart : "#{value.to_sqlpart} as #{key.to_sqlpart}"}.join(", ")
+   end
+
+   class << self
+      #Use this to define additional array attributes in descendant classes
+      #with all of the necessary addition, initialization and merging (<<) 
+      #semantics. You still need to appropriately define +allfields+ to make
+      #appropriate use of the lists you have added. <b> You can only call
+      #this method once, as it redefines methods each time it is called</b>
+      def newlists *lists
+	 attr_accessor *lists
+
+	 lines=lists.collect do |listname|
+	    ["@#{listname}=[]","@#{listname} += parts.#{listname}"]
+	 end.transpose
+	 class_eval <<-"end;"
+	    def initialize *args
+	       super
+	       #{lines[0].join("\n")}
+	    end
+	    def << (parts)
+	       super
+	       #{lines[1].join("\n")}
+	       self
+	    end
+	 end;
+      end
+      protected :newlists
+   end
+
+end
+
+#Creates a statement of the form
+#  CREATE [TEMPORARY] TABLE targettable SELECT ... FROM ... WHERE ...
+class SelectCreate < Select
+   #The name of the table to create.
+   attr_accessor :targettable
+
+   #Indicates whether a temporary table (which automatically deletes
+   #itself when the connection to the database closes) should be created.
+   #This may not be supported by all databases.
+   attr_accessor :temporary
+
+   def initialize(targettable,temporary=false)
+      super()
+      @targettable=targettable
+      @temporary=temporary
+   end
+
+   def to_s
+      "CREATE #{ @temporary ? 'TEMPORARY':''} TABLE #{@targettable.to_sqlpart} #{super}"
+   end
+end
+
+#Creates a statement of the form
+#  INSERT INTO targettable (fields) SELECT values FROM ... WHERE ...
+#(The generated sql statement may contain aliases in the SELECT clause. This should be harmless.)
+class SelectInsert < Select
+   #The name of the table to insert into.
+   attr_accessor :targettable
+
+   def initialize(targettable)
+      super()
+      @targettable=targettable
+   end
+
+   def to_s
+      "INSERT INTO #{@targettable.to_sqlpart} #{names_s} #{super}" 
+   end
+
+   protected
+
+   def names_s
+      intermediate=allfields.keys.collect do |x|
+	 if x.is_a? SQL_Field
+	    x.field.to_sqlpart
+	 else
+	    x.to_sqlpart
+	 end
+      end
+      "("+intermediate.join(", ")+")"
+   end
+end
+
+#Creates a statement of the form
+#   UPDATE tables SET field=value, field2=value2 WHERE ...
+#This descends from SelectStatement. Even though the strings are very 
+#different, they have lots of other stuff in common.
+class Update < Select
+
+   def to_s
+      statement="UPDATE #{tables_s} SET #{updatepart_s}"
+      v=conditions_s; statement << " WHERE "<< v if v
+      statement
+   end
+
+   def placeheld
+      (allfields.values+conditions).collect{|x| x.placeheld}.flatten
+   end
+
+   protected
+
+   def updatepart_s
+      allfields.collect{|key,value| key.to_sqlpart+"="+value.to_sqlpart}.join(", ")
+   end
+end
+
+#Insert values directly into a table. This class does not support the 
+#use of SelectParts, rather it behaves like a hash of column names (as 
+#symbols) to values. You can get the "slice" functionality by merging 
+#hashes into the statement using <tt>Hash.merge</tt>.
+class Insert < Hash
+   def initialize table
+      @targettable=table
+   end
+   #The name of the table to insert into.
+   attr_accessor :targettable
+   #Returns the SQL code to execute. May contain ?'s as placeholders for 
+   #values.
+   def to_s
+      "INSERT INTO #{@targettable.to_sqlpart} ("+
+      keys.collect{|x| x.to_sqlpart}.join(", ")+")"+
+      "VALUES ("+values.collect{|x| x.to_sqlpart}.join(", ")+")"
+   end
+   #Returns the objects corresponding to ?'s in the SQL code, in the 
+   #proper order. Insert into the database using the statement:
+   #  i=Insert.new(:tablename)
+   #  #add values
+   #  dbh.do(i.to_s,*i.placeheld)
+   def placeheld
+      values.collect{|x| x.placeheld}.flatten
+   end
+end
+
+end
+
+module SQLHelpers
+
+   #This helper method takes a string, and encapsulates it as a proper 
+   #SQL expression, so that it won't get passed to the database as 
+   #though it were a (potentially hostile) string value.
+   def string_func(str,placeheld=[])
+      SQLStatement::Function.new(str,placeheld)
+   end
+end

data/lib/sqlstatement.rb

@@ -0,0 +1,2 @@
+require 'sql/statement'
+require 'sql/expression'

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: SqlStatement
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2006-10-09 00:00:00 -05:00
+summary: A library for generating arbitrary SQL statements using convenient Ruby objects.
+require_paths: 
+- lib
+email: kbloom@gmail.com
+homepage: http://www.rubyforge.org/sqlstatement/
+rubyforge_project: 
+description: 
+autorequire: sqlstatement
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.8"
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Ken Bloom
+files: 
+- bin/example.rb
+- lib/sql
+- lib/sqlstatement.rb
+- lib/sql/expression.rb
+- lib/sql/bathon-sxp.rb
+- lib/sql/statement.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubynode
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: