SqlStatement 1.0.2 → 2.0

data/doc/ChangeLog

@@ -1,4 +1,18 @@
 =Change Log
+==2.0
+* Vastly redesign the DSL. The methods for adding components to an
+  SQL statement have all been renamed, and internal state is no longer
+  directly exposed to the outside. The interface is now much more intutive and
+  consistent. Please read the documentation to find out how this version of
+  the library works.
+* Left joins have been added
+* There's no more SelectParts class --
+  the corresponding semantics have been built directly into the Select class.
+* <tt>Select.new do |s| ... end</tt> syntax has been added
+* Select statements now remember the order of fields and tables. This makes
+  the next two changes feasible.
+  * Support for Mysql's STRAIGHT_JOIN modifier has been added
+  * Unit tests have been added
 ==1.0.2
 * Make the methods in SQLHelpers available as module functions too, so
   not only can you call "include SQLHelpers; sql_func", you can call

data/lib/sql/statement.rb

@@ -1,3 +1,4 @@
+
 # 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
@@ -12,7 +13,7 @@ class Object
    # 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 {...}
+   #    s << Select.new {...}
    #    dbh.execute(s.to_s, *s.placeheld)
    # When there are no unbound variables, and empty array is returned.
    def placeheld; [self]; end
@@ -49,6 +50,17 @@ class NilClass
    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
+   extend self
+end
+
 module SQLStatement
 
 # This class is used to represent complex SQL expressions, so that
@@ -56,7 +68,7 @@ module SQLStatement
 # 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>.
+# with <tt>SQLHelpers#string_func</tt>.
 class Function < String
 
    def initialize(val="",placeheld=[])
@@ -73,6 +85,32 @@ class Function < String
    end
 end
 
+#This class is used to represent table names and field names. It's like a
+#+Symbol+ in this regard, but it can be garbage collected.
+class Identifier < String
+  alias_method :_ken_sqlstatement_old_idx, :[]
+  def self.[] param
+    self.new param
+  end
+  def [] *params
+    if params.length==1 and params[0].is_a?(Symbol)
+      SQL_Field.new(self,params[0])
+    elsif params.length==1 and params[0].is_a?(Identifier)
+      SQL_Field.new(self,params[0])
+    else
+      _ken_sqlstatement_old_idx *params
+    end
+  end
+  def to_sqlpart
+    "`#{self}`"
+  end
+  def placeheld
+    []
+  end
+  def dbid
+    self
+  end
+end
 
 # +SQL_Field+ is used for representing field names qualified by table names.
 # Their text expansion looks like <tt>`tablename`.`fieldname`</tt>.
@@ -99,211 +137,148 @@ class SQL_Field
    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
+# This class is used to represent a SELECT statement, or an incomplete set of
+# parts to add to a SELECT 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+.
+# in different +Select+ objects, then combine them into one +Select+.
+#    def foo(x)
+#       Select.new do |s|
+#         s.field :"value#{x}"
+#         s.table :"dictionary#{x}"
+#         s.condition string_func("`jointable`.`id#{x}`=`dictionary#{x}`.`id`")
+#       end
+#    end
+#
 #    stmt=Select.new
-#    stmt.tablesarray << :jointable
+#    stmt.table :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
+#       stmt << foo(x)
 #    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
-
+#    dbh.execute(stmt)
+class Select
    #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, or a hash of aliased fields to 
-   #this SQL statement. See documentation at SelectStatement
-   def add_fields (newfields)
-      if newfields.is_a?(Hash)
-	 @fields.merge! newfields
-      else
-	 newfields.each { |x| @fields[x]=x }
-      end
-      nil
-   end
-
-   #Adds an array of unaliased tables or a hash of aliased tables to 
-   #this SQL statement. See documentation for SelectStatement
-   def add_tables (newtables)
-      if newtables.is_a?(Hash)
-	 @tables.merge! newtables
-      else
-	 newtables.each { |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
+   #
+   #The block is a convenient way to scpe the creation of the whole statement into one block.
    def initialize
-      @fields={}
-      @tables={}
-      @conditions=[]
-      @groupby=[]
-      @orderby=[]
-   end
-
-   #This is the list of fields or instructions to be retrieved. In a
+     @field_names=[]
+     @field_aliases=[]
+     @table_names=[]
+     @table_aliases=[]
+     @conditions=[]
+     @groupby_fields=[]
+     @orderby_fields=[]
+     @leftjoin_alias=[]
+     @leftjoin_table=[]
+     @leftjoin_condition=[]
+     yield self if block_given?
+   end
+
+   #Add a condition to the WHERE clause of the SQL statment. Conditions will be
+   #joined by AND. This should either be an array representing an s-expression
+   #for the condition, or it should be a SQLStatement::Function containing a
+   #string for the condition.
+   def condition c
+     @conditions << c
+     self
+   end
+   def groupby c
+     @groupby_fields << c
+     self
+   end
+   def orderby c
+     @orderby_fields << c
+     self
+   end
+
+
+   
+   #Add a field or expression to be retrieved in the expression. 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, or a hash of aliased fields to 
-   #this SQL statement.
-   def add_fields (newfields)
-      if newfields.is_a?(Hash)
-	 @fields.merge! newfields
-      else
-	 newfields.each { |x| @fields[x]=x }
-      end
-      nil
+   # +thefield+ is a field or expression to put in the result of this Select statement
+   # +thealias+ is a name to use for the column, and can be omitted to use the default
+   def field thefield, thealias=nil
+     @field_names << thefield
+     @field_aliases << thealias
    end
-
-   #This is the tables to include in the query (i.e. the +FROM+ clause). 
+   # Add a table to join into the expression, either as the first table, or by using an inner join
    #
-   #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 or a hash of aliased tables to 
-   #this SQL statement.
-   def add_tables (newtables)
-      if newtables.is_a?(Hash)
-	 @tables.merge! newtables
-      else
-	 newtables.each { |x| @tables[x]=x }
-      end
+   #+thefield+ is a field or expression to put in the result of this Select statement
+   #+thealias+ is a name to use for the column, and can be omitted to use the default
+   #
+   #If the table/alias pair is already included in the query, it is not included again, but
+   #if a table can be included again by using a new alias
+   def table thetable, thealias=nil
+     return if @table_names.zip(@table_aliases).include? [thetable,thealias]
+     @table_names << thetable
+     @table_aliases << thealias
+   end
+   #Adds a left-join with join conditon
+   def leftjoin table, condition, the_alias=nil
+     return if @leftjoin_table.zip(@leftjoin_alias).include? [table,the_alias]
+      @leftjoin_alias << the_alias
+      @leftjoin_table << table
+      @leftjoin_condition << condition
    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
+  
+   #Merge several SelectParts objects into one.
+   def +(rhs)
+      b=self.dup
+      b << rhs
+   end
 
-   #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.
+
+   #Returns two lists: a list of field names (aliases) in the expression, and a
+   #list of field values. 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 results.
    def allfields
-      @fields.dup
+      [@field_aliases.dup, @field_names.dup]
    end
 
    #Select whether this is a SELECT statement or a SELECT DISTINCT 
    #statement. (non-distinct by default)
-   attr_writer :distinct
+   attr_accessor :distinct
+   
+   #Determine whether to use MySQL's STRAIGHT_JOIN modifier to override the query optimizer
+   attr_accessor :straight_join
 
-   def distinct
-      @distinct ||= false
+   def straight_join
+      @straight_join ||= 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)
+      parts.table_names.zip(parts.table_aliases).each do |name,thealias|
+        next if @table_names.zip(@table_aliases).include? [name,thealias]
+        @table_names << name
+        @table_aliases << thealias
+      end
+      parts.leftjoin_alias.zip(parts.leftjoin_table,parts.leftjoin_condition).each \
+          do |thealias,thetable,thecondition|
+        next if @leftjoin_alias.zip(@leftjoin_table).include? [thealias,thetable]
+        @leftjoin_alias << thealias
+        @leftjoin_table << thetable
+        @leftjoin_condition << thecondition
+      end
+      @field_names += parts.field_names
+      @field_aliases += parts.field_aliases
       @conditions += parts.conditions
-      @groupby += parts.groupby
-      @orderby += parts.orderby
+      @groupby_fields += parts.groupby_fields
+      @orderby_fields += parts.orderby_fields
       self
    end
 
@@ -312,15 +287,26 @@ class Select
    #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
+      statement="SELECT"
+      statement << " DISTINCT" if distinct 
+      statement << " STRAIGHT_JOIN" if straight_join
+      statement << "\n " << fields_s
+      statement << "\nFROM " << tables_s
+      v=conditions_s; statement << "\nWHERE "<< v if v
+      v=groupby_s; statement << "\nGROUP BY "<< v if v
+      v=orderby_s; statement << "\nORDER BY "<< v if v
       return statement
    end
 
    def placeheld
-      (allfields.values+@tables.values+conditions+groupby+orderby).collect{|x| x.placeheld}.flatten
+      (
+        allfields[1] +
+        @table_names +
+        @leftjoin_table.zip(@leftjoin_alias,@leftjoin_condition).flatten +
+        conditions +
+        groupby_fields +
+        orderby_fields
+      ).collect{|x| x.placeheld}.flatten
    end
 
    #This is useful for writing nested queries.
@@ -329,42 +315,66 @@ class Select
    end
    protected
 
+  attr_reader :field_names, :field_aliases, :table_names, :table_aliases,
+    :conditions, :groupby_fields, :orderby_fields, :leftjoin_alias,
+    :leftjoin_table, :leftjoin_condition
+
    def tables_s
-      @tables.collect{|key,value| value==key ? key.to_sqlpart : "#{value.to_sqlpart} as #{key.to_sqlpart}"}.join(", ")
+      part1=@table_aliases.zip(@table_names).collect do |a,t|
+        if a
+          "#{t.to_sqlpart} as #{a.to_sqlpart}"
+        else
+          t.to_sqlpart
+        end
+      end.join("\n INNER JOIN ")
+      part2=@leftjoin_alias.zip(@leftjoin_table, @leftjoin_condition).collect do |a,t,c|
+        if a==nil
+          "\n LEFT JOIN #{t.to_sqlpart} ON #{c.to_sqlpart}"
+        else
+          "\n LEFT JOIN #{t.to_sqlpart} as #{a.to_sqlpart} ON #{c.to_sqlpart}"
+        end
+      end.join
+      part1+part2
    end
 
    def conditions_s
-      @conditions==[] ? nil : @conditions.collect{|x| x.to_sqlpart}.join(" AND ")
+      @conditions==[] ? nil : @conditions.collect{|x| x.to_sqlpart}.join("\n AND ")
    end
 
    def groupby_s
-      @groupby==[] ? nil : @groupby.collect{|x| x.to_sqlpart}.join(", ")
+      @groupby_fields==[] ? nil : @groupby_fields.collect{|x| x.to_sqlpart}.join(", ")
    end
 
    def orderby_s
-      @orderby==[] ? nil : @orderby.collect{|x| x.to_sqlpart}.join(", ")
+      @orderby_fields==[] ? nil : @orderby_fields.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(", ")
+      allfields.transpose.collect do |a,f|
+        if a
+          "#{f.to_sqlpart} as #{a.to_sqlpart}"
+        else
+          f.to_sqlpart 
+        end
+      end.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>
+      #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}=[]","@#{listname} += parts.#{listname}"]
+ 	 lines=lists.collect do |listname|
+	    ["@#{listname}=[]",
+             "@#{listname} += parts.#{listname}"]
 	 end.transpose
 	 class_eval <<-"end;"
-	    def initialize *args
-	       super
+	    def initialize &block
 	       #{lines[0].join("\n")}
+	       super &block
 	    end
 	    def << (parts)
 	       super
@@ -389,14 +399,8 @@ class SelectCreate < Select
    #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}"
+      "CREATE #{ @temporary ? 'TEMPORARY ':''}TABLE #{@targettable.to_sqlpart} #{super}"
    end
 end
 
@@ -407,26 +411,21 @@ 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}" 
+      "INSERT INTO #{@targettable.to_sqlpart} (#{names_s}) #{super}" 
    end
 
    protected
 
    def names_s
-      intermediate=allfields.keys.collect do |x|
+      intermediate=allfields[0].collect do |x|
 	 if x.is_a? SQL_Field
 	    x.field.to_sqlpart
 	 else
 	    x.to_sqlpart
 	 end
       end
-      "("+intermediate.join(", ")+")"
+      intermediate.join(", ")
    end
 end
 
@@ -443,20 +442,28 @@ class Update < Select
    end
 
    def placeheld
-      (allfields.values+conditions).collect{|x| x.placeheld}.flatten
+      (@table_names+allfields[1]+conditions).collect{|x| x.placeheld}.flatten
+   end
+
+   # Set a field to contain a value. Note the order of the parameters matches
+   # the order used for the Select statement
+   def field expression, targetfield
+     super expression, targetfield
    end
 
    protected
 
    def updatepart_s
-      allfields.collect{|key,value| key.to_sqlpart+"="+value.to_sqlpart}.join(", ")
+      allfields.transpose.collect do |target,value|
+        target.to_sqlpart+"="+value.to_sqlpart
+      end.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>.
+#ability to merge a Select object, 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
@@ -482,13 +489,16 @@ end
 
 end
 
-module SQLHelpers
+class String
+  #Returns a SQLStatement::Identifier for this string
+  def dbid
+    SQLStatement::Identifier.new(self)
+  end
+end
 
-   #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
-   extend self
+class Symbol
+  #Returns a SQLStatement::Identifier for this Symbol
+  def dbid
+    SQLStatement::Identifier.new(to_s)
+  end
 end

data/test/test_combine_statement.rb

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'test/unit'
+require '../lib/sql/statement.rb'
+
+class TestStatementParts < Test::Unit::TestCase
+  include SQLHelpers
+    
+  def test_shiftop
+    part=SQLStatement::Select.new do |s|
+      s.table :foo
+      s.leftjoin :faz, string_func("a=b")
+      s.field :bar
+      s.field :baz
+    end
+    targetstmt=SQLStatement::Select.new do |s|
+      s.table :foo
+      s.leftjoin :faz, string_func("a=b")
+      s.field :bar
+      s.field :baz
+    end
+
+    targetstmt << part
+
+    assert_equal "`foo`\n LEFT JOIN `faz` ON a=b", targetstmt.send(:tables_s)
+    assert_equal "`bar`, `baz`, `bar`, `baz`", targetstmt.send(:fields_s)
+  end
+  
+  def test_plus
+    part=SQLStatement::Select.new do |s|
+      s.table :foo
+      s.leftjoin :faz, string_func("a=b")
+      s.field :bar
+      s.field :baz
+    end
+    part2=SQLStatement::Select.new do |s|
+      s.table :foo
+      s.leftjoin :faz, string_func("a=b")
+      s.field :bar
+      s.field :baz
+    end
+
+    targetstmt=part+part2
+
+    #neither of the original parts is modified
+    assert_equal "`bar`, `baz`", part.send(:fields_s)
+    assert_equal "`bar`, `baz`", part2.send(:fields_s)
+
+    #but the new one conforms to the semantics of <<
+    assert_equal "`foo`\n LEFT JOIN `faz` ON a=b", targetstmt.send(:tables_s)
+    assert_equal "`bar`, `baz`, `bar`, `baz`", targetstmt.send(:fields_s)
+  end
+end

data/test/test_primatives.rb

@@ -0,0 +1,31 @@
+require 'test/unit'
+require '../lib/sql/statement.rb'
+
+class Primatives < Test::Unit::TestCase
+  def test_construction
+    foo=SQLStatement::Identifier.new("foo")
+    bar=SQLStatement::Identifier["bar"]
+    assert_kind_of SQLStatement::Identifier, foo
+    assert_kind_of SQLStatement::Identifier, bar
+  end
+
+  def test_dbid
+    assert_kind_of SQLStatement::Identifier, :foo.dbid
+    assert_kind_of SQLStatement::Identifier, "foo".dbid
+  end
+
+  def test_indexing
+    foo=SQLStatement::Identifier.new("foo")
+    bar=SQLStatement::Identifier["bar"]
+    assert_kind_of SQLStatement::SQL_Field, foo[bar]
+    assert_kind_of SQLStatement::SQL_Field, foo[:bar]
+    if RUBY_VERSION=~/^1\.8/
+      assert_kind_of Numeric, foo[1]
+    elsif RUBY_VERSION=~/^1\.9/
+      #I don't guarantee that this library can work with Ruby 1.9 to begin
+      #with, but just for good measure, let's get this test right.
+      assert_kind_of String, foo[1]
+    end
+    assert_kind_of String, foo[1,1]
+  end
+end

data/test/test_statementparts.rb

@@ -0,0 +1,127 @@
+require 'rubygems'
+require 'test/unit'
+require '../lib/sql/statement.rb'
+
+class TestStatementParts < Test::Unit::TestCase
+  include SQLHelpers
+
+  def test_table
+    s=SQLStatement::Select.new
+    s.table :foo
+    assert_equal "`foo`", s.send(:tables_s)
+    s.table :bar
+    assert_equal "`foo`\n INNER JOIN `bar`", s.send(:tables_s)
+    
+    #adding an existing table/alias pair doesn't add anything to the statement
+    s.table :foo
+    assert_equal "`foo`\n INNER JOIN `bar`", s.send(:tables_s)
+    
+    #but adding the same table with a new alias does
+    s.table :foo, :alias
+    assert_equal "`foo`\n INNER JOIN `bar`\n INNER JOIN `foo` as `alias`", s.send(:tables_s)
+  end
+
+  def test_leftjoin
+    s=SQLStatement::Select.new
+    s.table :foo
+    assert_equal "`foo`", s.send(:tables_s)
+    s.leftjoin :bar, string_func("`foo`.`a`=`bar`.`a`")
+    assert_equal "`foo`\n LEFT JOIN `bar` ON `foo`.`a`=`bar`.`a`", s.send(:tables_s)
+    
+    #adding the same table/alias pair adds nothing, and doesn't update the join condition
+    s.leftjoin :bar, string_func("`foo`.`b`=`bar`.`b`")
+    assert_equal "`foo`\n LEFT JOIN `bar` ON `foo`.`a`=`bar`.`a`", s.send(:tables_s)
+
+    #but adding the same table with a new alias adds a new join with the new condition
+    s.leftjoin :bar, string_func("`foo`.`b`=`baz`.`b`"), :baz
+    assert_equal "`foo`\n LEFT JOIN `bar` ON `foo`.`a`=`bar`.`a`
+ LEFT JOIN `bar` as `baz` ON `foo`.`b`=`baz`.`b`", s.send(:tables_s)
+  end
+
+  def test_fields
+    s=SQLStatement::Select.new
+    s.field :foo
+    assert_equal "`foo`", s.send(:fields_s)
+
+    #adding a field/alias pair does add it to the statement a second time
+    s.field :foo
+    assert_equal "`foo`, `foo`", s.send(:fields_s)
+
+    s.field :foo, :bar
+    assert_equal "`foo`, `foo`, `foo` as `bar`", s.send(:fields_s)
+
+    s.field string_func("1")
+    assert_equal "`foo`, `foo`, `foo` as `bar`, 1", s.send(:fields_s)
+  end
+
+  def test_conditions
+    s=SQLStatement::Select.new
+    assert_nil s.send(:conditions_s)
+    s.condition string_func("a=b")
+    assert_equal "a=b",s.send(:conditions_s)
+    s.condition string_func("b=c")
+    assert_equal "a=b\n AND b=c",s.send(:conditions_s)
+  end
+
+  def test_orderby
+    s=SQLStatement::Select.new
+    assert_nil s.send(:orderby_s)
+    s.orderby :foo
+    assert_equal "`foo`", s.send(:orderby_s)
+    s.orderby :bar
+    assert_equal "`foo`, `bar`", s.send(:orderby_s)
+    s.orderby string_func("`baz` desc")
+    assert_equal "`foo`, `bar`, `baz` desc", s.send(:orderby_s)
+  end
+
+  def test_groupby
+    s=SQLStatement::Select.new
+    assert_nil s.send(:groupby_s)
+    s.groupby :foo
+    assert_equal "`foo`", s.send(:groupby_s)
+    s.groupby :bar
+    assert_equal "`foo`, `bar`", s.send(:groupby_s)
+  end
+
+  # the names of the fields we are inserting into
+  def test_selectinsert_names
+    s=SQLStatement::SelectInsert.new
+    s.field :foo, :bar
+    assert_equal "`bar`",s.send(:names_s)
+    s.field :foo2, :baz
+    assert_equal "`bar`, `baz`",s.send(:names_s)
+  end
+  
+  #the same tests as for Select, but for SelectInsert we are specifically
+  #specifying that the aliases show up in both as destination fields and as
+  #aliases in the select part
+  def test_selectinsert_fields
+    s=SQLStatement::SelectInsert.new
+    s.field :foo
+    assert_equal "`foo`", s.send(:fields_s)
+
+    #adding a field/alias pair does add it to the statement a second time
+    s.field :foo
+    assert_equal "`foo`, `foo`", s.send(:fields_s)
+
+    s.field :foo, :bar
+    assert_equal "`foo`, `foo`, `foo` as `bar`", s.send(:fields_s)
+
+    s.field string_func("1")
+    assert_equal "`foo`, `foo`, `foo` as `bar`, 1", s.send(:fields_s)
+  end
+  def test_updatepart
+    s=SQLStatement::Update.new
+    assert_raise ArgumentError do
+      #an alias is required, because it's going to be the name of the field to update
+      s.field :foo
+    end
+
+    s.field :foo, :bar
+    assert_equal "`bar`=`foo`", s.send(:updatepart_s)
+
+    s.field string_func("1"), :baz
+    assert_equal "`bar`=`foo`, `baz`=1", s.send(:updatepart_s)
+  end
+
+end

data/test/test_statements.rb

@@ -0,0 +1,68 @@
+require 'rubygems'
+require 'test/unit'
+require '../lib/sql/statement.rb'
+
+class TestStatements < Test::Unit::TestCase
+  include SQLHelpers
+
+
+  def test_createselect
+    parts=SQLStatement::SelectCreate.new do |s|
+      s.targettable = :targettable
+      s.field :a[:b],:targetcol
+      s.table :extracted_appraisal_expressions_26, :a
+      s.table :extracted_appraisal_26, :d
+      s.leftjoin :dictionary_appraisal_attitude, string_func("a.att_appraisal_attitude_left=b.left_key"), :b
+      s.leftjoin :dictionary_deixis_deixis, string_func("a.att_deixis_deixis_left=c.left_key"), :c
+      s.condition string_func("a>1")
+    end
+    expected="CREATE TABLE `targettable` SELECT
+ `a`.`b` as `targetcol`
+FROM `extracted_appraisal_expressions_26` as `a`
+ INNER JOIN `extracted_appraisal_26` as `d`
+ LEFT JOIN `dictionary_appraisal_attitude` as `b` ON a.att_appraisal_attitude_left=b.left_key
+ LEFT JOIN `dictionary_deixis_deixis` as `c` ON a.att_deixis_deixis_left=c.left_key
+WHERE a>1"
+  assert_equal expected, parts.to_s
+  end
+
+  def test_insertselect
+    parts=SQLStatement::SelectInsert.new do |s|
+      s.targettable = :targettable
+      s.field :a[:b],:targetcol
+      s.table :extracted_appraisal_expressions_26, :a
+      s.table :extracted_appraisal_26, :d
+      s.leftjoin :dictionary_appraisal_attitude, string_func("a.att_appraisal_attitude_left=b.left_key"), :b
+      s.leftjoin :dictionary_deixis_deixis, string_func("a.att_deixis_deixis_left=c.left_key"), :c
+      s.condition string_func("a>1")
+    end
+    expected="INSERT INTO `targettable` (`targetcol`) SELECT
+ `a`.`b` as `targetcol`
+FROM `extracted_appraisal_expressions_26` as `a`
+ INNER JOIN `extracted_appraisal_26` as `d`
+ LEFT JOIN `dictionary_appraisal_attitude` as `b` ON a.att_appraisal_attitude_left=b.left_key
+ LEFT JOIN `dictionary_deixis_deixis` as `c` ON a.att_deixis_deixis_left=c.left_key
+WHERE a>1"
+  assert_equal expected, parts.to_s
+  end
+  def test_select
+    parts=SQLStatement::Select.new do |s|
+      s.straight_join=true
+      s.distinct=true
+      s.field :a[:*]
+      s.table :extracted_appraisal_expressions_26, :a
+      s.table :extracted_appraisal_26, :d
+      s.leftjoin :dictionary_appraisal_attitude, string_func("a.att_appraisal_attitude_left=b.left_key"), :b
+      s.leftjoin :dictionary_deixis_deixis, string_func("a.att_deixis_deixis_left=c.left_key"), :c
+      s.condition string_func("a>1")
+    end
+    expected="SELECT DISTINCT STRAIGHT_JOIN
+ `a`.*
+FROM `extracted_appraisal_expressions_26` as `a`
+ INNER JOIN `extracted_appraisal_26` as `d`
+ LEFT JOIN `dictionary_appraisal_attitude` as `b` ON a.att_appraisal_attitude_left=b.left_key
+ LEFT JOIN `dictionary_deixis_deixis` as `c` ON a.att_deixis_deixis_left=c.left_key
+WHERE a>1"
+  assert_equal expected, parts.to_s
+  end
+end

metadata

@@ -1,63 +1,75 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
-specification_version: 1
 name: SqlStatement
 version: !ruby/object:Gem::Version 
-  version: 1.0.2
-date: 2006-12-18 00:00:00 -06: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: 
+  version: "2.0"
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Ken Bloom
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-01-20 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubynode
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: kbloom@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- doc/ChangeLog
 files: 
-- lib/sql
 - lib/sqlstatement.rb
-- lib/sql/expression.rb
+- lib/sql
+- lib/sql/dbi-support.rb
 - lib/sql/bathon-sxp.rb
+- lib/sql/expression.rb
 - lib/sql/statement.rb
-- lib/sql/dbi-support.rb
-- doc/EXAMPLE
+- test/test_combine_statement.rb
+- test/test_statements.rb
+- test/test_statementparts.rb
+- test/test_primatives.rb
 - doc/ChangeLog
-test_files: []
-
+has_rdoc: true
+homepage: http://www.rubyforge.org/sqlstatement/
+post_install_message: 
 rdoc_options: 
 - --main
 - lib/sqlstatement.rb
-extra_rdoc_files: 
-- doc/EXAMPLE
-- doc/ChangeLog
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.8"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 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: 
+rubyforge_project: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: A library for generating arbitrary SQL statements using convenient Ruby objects.
+test_files: 
+- test/test_combine_statement.rb
+- test/test_statements.rb
+- test/test_statementparts.rb
+- test/test_primatives.rb

data/doc/EXAMPLE

@@ -1,124 +0,0 @@
-#=Example
-#  # 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 execute it against the database. Assume dbh is a
-#  #dbi connection handle.
-#  dbh.execute(stmt.to_s,*stmt.placeheld)