sqldsl 0.0.2

data/README

@@ -0,0 +1,91 @@
+= SQL DSL
+
+SQL DSL is a library for creating SQL statements using ruby code.
+
+by Jay[http://jayfields.blogspot.com] Fields[http://jayfields.blogspot.com]
+
+== Download and Installation
+
+You can download SQL DSL from here[http://rubyforge.org/projects/sqldsl] or install it with the following command.
+
+ $ gem install sqldsl
+
+== License
+ 	
+You may use, copy and redistribute this library under the same terms as Ruby itself (see http://www.ruby-lang.org/en/LICENSE.txt).
+
+== Examples
+
+See the tests for more examples
+
+=== Test Helper
+
+    require 'test/unit'
+    require File.dirname(__FILE__) + '/../lib/sqldsl'
+
+=== Insert Example
+
+    require File.dirname(__FILE__) + '/test_helper'
+    
+    class InsertAcceptanceTest < Test::Unit::TestCase
+      def test_insert_select
+        statement = Insert.into[:table1][:column1, :column2, :column3].values do
+          Select[1]
+        end
+        assert_equal 'insert into table1 (column1, column2, column3) select 1', statement.to_sql
+      end
+      
+      def test_insert_with_values
+        statement = Insert.into[:table1][:column1, :column2, :column3].values(10, 'book', :column4)
+        assert_equal "insert into table1 (column1, column2, column3) values (10, 'book', column4)", statement.to_sql
+      end
+    end
+
+=== Update Example
+
+    require File.dirname(__FILE__) + '/test_helper'
+    
+    class UpdateAcceptanceTest < Test::Unit::TestCase
+      def test_insert_select
+        statement = Update[:table1].set[:column1=>10, :column2=>'book'].where do
+          not_exists(Select[1].from[:table2])
+        end
+        assert_equal "update table1 set column1=10, column2='book' where not exists (select 1 from table2)", statement.to_sql
+      end
+    end
+
+=== Delete Example
+
+    require File.dirname(__FILE__) + '/test_helper'
+    
+    class DeleteAcceptanceTest < Test::Unit::TestCase
+      def test_insert_select
+        statement = Delete.from[:table1].where do
+          exists(Select[1].from[:table2])
+        end
+        assert_equal "delete from table1 where exists (select 1 from table2)", statement.to_sql
+      end
+    end
+
+=== Select Example
+
+    require File.dirname(__FILE__) + '/test_helper'
+    
+    class SelectAcceptanceTest < Test::Unit::TestCase
+      def test_simple_select
+        statement = Select[:column1, 'book', 10].from[:table1].where do
+          equal :column1, 99
+          equal :column2, 'star'
+        end
+        expected = "select column1, 'book', 10 from table1 where column1 = 99 and column2 = 'star'"
+        assert_equal expected, statement.to_sql
+      end
+      
+      def test_select_with_join
+        statement = Select[:column1, :column2].from[:table1, :table2].where do
+          equal :'table1.id', :'table2.table1_id'
+        end
+        expected = "select column1, column2 from table1, table2 where table1.id = table2.table1_id"
+        assert_equal expected, statement.to_sql
+      end
+    end

data/README_TEMPLATE

@@ -0,0 +1,39 @@
+= SQL DSL
+
+SQL DSL is a library for creating SQL statements using ruby code.
+
+by Jay[http://jayfields.blogspot.com] Fields[http://jayfields.blogspot.com]
+
+== Download and Installation
+
+You can download SQL DSL from here[http://rubyforge.org/projects/sqldsl] or install it with the following command.
+
+ $ gem install sqldsl
+
+== License
+ 	
+You may use, copy and redistribute this library under the same terms as Ruby itself (see http://www.ruby-lang.org/en/LICENSE.txt).
+
+== Examples
+
+See the tests for more examples
+
+=== Test Helper
+
+<%= File.readlines("test/test_helper.rb").collect { |line| "    " + line } %>
+
+=== Insert Example
+
+<%= File.readlines("test/insert_acceptance_test.rb").collect { |line| "    " + line } %>
+
+=== Update Example
+
+<%= File.readlines("test/update_acceptance_test.rb").collect { |line| "    " + line } %>
+
+=== Delete Example
+
+<%= File.readlines("test/delete_acceptance_test.rb").collect { |line| "    " + line } %>
+
+=== Select Example
+
+<%= File.readlines("test/select_acceptance_test.rb").collect { |line| "    " + line } %>

data/lib/array.rb

@@ -0,0 +1,20 @@
+class Array
+  # call-seq: array.to_sql -> a_string
+  # 
+  # Returns a string by collecting all elements, calling +to_sql+ on each one, and 
+  # then joins them with ', '.
+  # 
+  #    [10, 'book', :column2].to_sql     #=> "10, 'book', column2"
+  def to_sql
+    self.collect { |element| element.to_sql }.join(', ')
+  end
+  
+  # call-seq: array.to_sql_equal(any) -> a_string
+  # 
+  # Returns a string containing the sql in expression
+  # 
+  #    [10, :column2, 'book'].to_sql_equal(:column1)       #=> "column1 in (10, column2, 'book')"
+  def to_sql_equal(lval)
+    "#{lval.to_sql } in (#{ self.to_sql })" 
+  end
+end

data/lib/delete.rb

@@ -0,0 +1,22 @@
+class Delete < SqlStatement
+  class << self
+    # call-seq: Delete.from -> a_delete
+    # 
+    # Returns a Delete instance with the SQL initialized to 'delete from '
+    # 
+    #    Delete.from.to_sql       #=> "delete from "
+    def from      
+      self.new('delete from ')
+    end
+  end
+  
+  # call-seq: delete[table] -> a_delete
+  # 
+  # Returns a Delete instance with the table appended to the SQL statement.
+  # 
+  #    Delete.from[:table1].to_sql       #=> "delete from table1"
+  def [](table)
+    @to_sql += table.to_sql
+    self
+  end
+end

data/lib/insert.rb

@@ -0,0 +1,55 @@
+class Insert < SqlStatement
+  class << self
+    # call-seq: Insert.into -> Insert
+    # 
+    # Returns the Insert class.  Unnecessary and only available to mimic SQL statements.
+    # 
+    #    Insert.into       #=> Insert
+    def into
+      self
+    end
+    
+    # call-seq: Insert[table] -> an_insert
+    # 
+    # Returns an Insert instance with the SQL initialized to 'insert into [table] '
+    # 
+    #    Insert[:table1].to_sql       #=> "insert into table1 "
+    def [](table)
+      self.new("insert into #{table.to_sql}")
+    end
+  end
+  
+  # call-seq: insert[column1,...] -> an_insert
+  # 
+  # Returns an Insert instance with the columns appended to the SQL statement.
+  # 
+  #    Insert.into[:table1][:column1, :column2].to_sql       #=> "insert into table1 (column1, column2)"
+  def [](*columns)
+    @to_sql += " (#{columns.join(', ')})"
+    self
+  end
+  
+  # call-seq: insert.values { block } -> an_insert
+  #           insert.values(arg,...)
+  # 
+  # If a block is given:
+  # Ignores any parameters given to the method.
+  # Executes the block then calls +to_sql+ on the result.
+  # Returns an Insert instance with the result of the block's execution appended to the SQL statement.
+  # 
+  #    insert = Insert.into[:table1][:column1].values { Select['book'] }       
+  #    insert.to_sql      #=> "insert into table1 (column1) select 'book'"
+  #
+  # If no block is given:
+  # Returns an Insert instance with the args appended to the SQL statement as values
+  # 
+  #    insert = Insert.into[:table1][:column1, :column2].values(10, 'book')
+  #    insert.to_sql      #=> "insert into table1 (column1, column2) values (10, 'book')"
+  def values(*args)
+    @to_sql += case
+      when block_given? then " #{yield.to_sql}"
+      else " values (#{args.to_sql})"
+    end
+    self
+  end
+end

data/lib/numeric.rb

@@ -0,0 +1,10 @@
+class Numeric
+  # call-seq: numeric.to_sql -> a_numeric
+  # 
+  # Returns self
+  # 
+  #    10.to_sql     #=> 10
+  def to_sql
+    self
+  end
+end

data/lib/object.rb

@@ -0,0 +1,34 @@
+class Object
+
+  # call-seq: obj.to_sql_equal(any) -> a_string
+  # 
+  # Returns a string containing the sql equality expression
+  # 
+  #    10.to_sql_equal(:column1)       #=> "column1 = 10"
+  def to_sql_equal(lval)
+    sql_expression(lval, "=")
+  end
+  
+  def to_sql_more_than(lval) #:nodoc:
+    sql_expression(lval, ">")
+  end
+  
+  def to_sql_less_than(lval) #:nodoc:
+    sql_expression(lval, "<")
+  end
+  
+  def to_sql_less_than_or_equal_to(lval) #:nodoc:
+    sql_expression(lval, "<=")
+  end
+
+  def to_sql_more_than_or_equal_to(lval) #:nodoc:
+    sql_expression(lval, ">=")
+  end  
+
+  protected
+
+  def sql_expression(lval, operator) #:nodoc:
+    "#{ lval.to_sql } #{operator} #{ self.to_sql }"
+  end
+
+end

data/lib/select.rb

@@ -0,0 +1,33 @@
+class Select < SqlStatement
+  class << self
+    # call-seq: Select[arg,...] -> a_select
+    # 
+    # Returns a Select instance with the SQL initialized to 'select ' plus the args joined by ', '
+    # 
+    #    Select[1, :column1, 'book'].to_sql       #=> "select 1, column1, 'book'"
+    def [](*columns)
+      self.new("select #{columns.collect{ |column| column.to_sql }.join(', ')}")
+    end
+  end
+  
+  # call-seq: select.from -> a_select
+  # 
+  # Returns a Select instance with ' from ' appended to the SQL statement.
+  # 
+  #    Select[1, :column1, 'book'].from.to_sql       #=> "select 1, column1, 'book' from "
+  def from
+    @to_sql += " from "
+    self
+  end
+  
+  # call-seq: select[table,...] -> a_select
+  # 
+  # Returns a Select instance with the table names, joined by ', ' appended to the SQL statement.
+  # 
+  #    Select[1, :column1, 'book'].from[:table1, :table2].to_sql       #=> "select 1, column1, 'book' from table1, table2"
+  def [](*table_names)
+    @to_sql += table_names.collect{ |table| table.to_s }.sort.join(', ')
+    self
+  end
+  
+end

data/lib/sql_statement.rb

@@ -0,0 +1,19 @@
+class SqlStatement
+  attr_reader :to_sql
+
+  def initialize(sql)  #:nodoc:
+    @to_sql = sql
+  end
+  
+  # call-seq: sql_statement.where { block } -> a_sql_statement
+  # 
+  # Creates a new WhereBuilder instance, passing the block as a parameter, then executes to_sql on the WhereBuilder instance.
+  # The resulting string from the WhereBuilder instance is appended to the SQL statement.
+  # Returns self.
+  # 
+  #    Select[1].where { equal :column1, 1 }.to_sql       #=> "select 1 where column1 = 1"
+  def where(&block)
+    @to_sql += WhereBuilder.new(&block).to_sql
+    self
+  end
+end

data/lib/sqldsl.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/object.rb'
+require File.dirname(__FILE__) + '/symbol.rb'
+require File.dirname(__FILE__) + '/array.rb'
+require File.dirname(__FILE__) + '/string.rb'
+require File.dirname(__FILE__) + '/numeric.rb'
+require File.dirname(__FILE__) + '/time.rb'
+require File.dirname(__FILE__) + '/sql_statement.rb'
+require File.dirname(__FILE__) + '/where_builder.rb'
+require File.dirname(__FILE__) + '/select.rb'
+require File.dirname(__FILE__) + '/insert.rb'
+require File.dirname(__FILE__) + '/update.rb'
+require File.dirname(__FILE__) + '/delete.rb'

data/lib/string.rb

@@ -0,0 +1,12 @@
+class String
+  
+  # call-seq: string.to_sql -> a_string
+  # 
+  # Returns a string with single quotes escaped.
+  # 
+  #    :book.to_sql     #=> "book"
+  def to_sql
+    "'#{self.gsub(/'/, "''")}'"
+  end
+
+end

data/lib/symbol.rb

@@ -0,0 +1,12 @@
+class Symbol
+
+  # call-seq: symbol.to_sql -> a_string
+  # 
+  # Returns a string with single quotes escaped.
+  # 
+  #    "it's".to_sql     #=> "'it''s'"
+  def to_sql
+    to_s
+  end  
+
+end

data/lib/time.rb

@@ -0,0 +1,20 @@
+class Time
+  # call-seq: time.to_sql -> a_string
+  # 
+  # Returns a string that represents a database agnostic time.
+  # 
+  #    Time.at(946702800).to_sql     #=> "to_timestamp('2000-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')"
+  def to_sql
+    "to_timestamp('" + formatted + "', 'YYYY-MM-DD HH24:MI:SS')"
+  end
+  
+  protected
+  
+  def formatted #:nodoc:
+    "#{year.to_s}-#{pad(month)}-#{pad(day)} #{pad(hour)}:#{pad(min)}:#{pad(sec)}"
+  end
+  
+  def pad(num) #:nodoc:
+    num.to_s.rjust(2,'0')
+  end
+end

data/lib/update.rb

@@ -0,0 +1,37 @@
+class Update < SqlStatement
+  class << self
+    # call-seq: Update[table] -> an_update
+    # 
+    # Returns an Update instance with the SQL initialized to 'update [table] '
+    # 
+    #    Update[:table1].to_sql       #=> "update table1"
+    def [](table)
+      self.new("update #{table.to_sql}")
+    end
+  end
+  
+  # call-seq: update.set -> update
+  # 
+  # Returns self.  Unnecessary and only available to mimic SQL statements.
+  # 
+  #    Update[:table1].set.to_sql       #=> "update table1"
+  def set
+    self
+  end
+  
+  # call-seq: update[column1=>'book',...] -> an_update
+  # 
+  # Returns an Update instance with the set values appended to the SQL statement.
+  # 
+  #    update = Update[:table1].set[:column1=>'book', :column2=>10]
+  #    update.to_sql       #=> "update table1 set column1 = 'book, column2 = 10"
+  def [](hash)
+    @to_sql += " set "
+    set_args = []
+    hash.each_pair do |col, val|
+      set_args << "#{col.to_sql}=#{val.to_sql}"
+    end
+    @to_sql += set_args.sort.join(', ')
+    self
+  end
+end

data/lib/where_builder.rb

@@ -0,0 +1,58 @@
+class WhereBuilder
+
+  # call-seq: WhereBuilder.new(&block) -> a_where_builder
+  # 
+  # Returns a new WhereBuilder.  At initialization time the block is instance evaled on the
+  # new WhereBuilder instance.
+  # 
+  #    WhereBuilder.new { equal :column1, 10 }.to_sql       #=> " where column1 = 10"
+  def initialize(&block)
+    instance_eval(&block)
+  end
+  
+  # call-seq: where.equal(arg1, arg2)
+  # 
+  # Appends an equality condition to the where SQL clause.
+  # 
+  #    WhereBuilder.new { equal :column1, 10 }.to_sql       #=> " where column1 = 10"
+  def equal(lval, rval)
+    sql_parts << rval.to_sql_equal(lval)
+  end
+    
+  # call-seq: where.exists(clause)
+  # 
+  # Appends an exists condition to the where SQL clause.
+  # 
+  #    WhereBuilder.new { exists 'select id from table1' }.to_sql       #=> " where exists (select id from table1)"
+  def exists(clause)
+    sql_parts << "exists (#{clause.to_sql})"
+  end
+  
+  # call-seq: where.not_exists(clause)
+  # 
+  # Appends an exists condition to the where SQL clause.
+  # 
+  #    WhereBuilder.new { not_exists 'select id from table1' }.to_sql       #=> " where not exists (select id from table1)"
+  def not_exists(clause)
+    sql_parts << "not exists (#{clause.to_sql})"
+  end
+  
+  # call-seq: where.to_sql -> a_string
+  # 
+  # Returns a string by collecting all the conditions and joins them with ' and '.
+  # 
+  #    WhereBuilder.new do 
+  #      equal :column1, 10
+  #      equal :column2, 'book'
+  #    end.to_sql         #=> " where column1 = 10 and column2 = 'book'"
+  def to_sql
+    " where #{sql_parts.join(' and ')}"
+  end
+  
+  protected
+  
+  def sql_parts  #:nodoc:
+    @sql_parts ||= []
+  end
+  
+end

data/test/all_tests.rb

@@ -0,0 +1 @@
+Dir['**/*_test.rb'].each { |testCase| require testCase }

data/test/array_test.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ArrayTest < Test::Unit::TestCase 
+  def test_to_sql_gives_of_to_sql_objects_comma_delimited
+    assert_equal "too, 'the', 2", [:too, 'the', 2].to_sql
+  end
+  
+  def test_sql_equal_uses_in
+    assert_equal "column1 in (too, 'the', 2)", [:too, 'the', 2].to_sql_equal(:column1)
+  end
+end

data/test/delete_acceptance_test.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class DeleteAcceptanceTest < Test::Unit::TestCase
+  def test_insert_select
+    statement = Delete.from[:table1].where do
+      exists(Select[1].from[:table2])
+    end
+    assert_equal "delete from table1 where exists (select 1 from table2)", statement.to_sql
+  end
+end

data/test/delete_test.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class DeleteTest < Test::Unit::TestCase 
+
+  def test_delete_without_where_clause
+    assert_equal 'delete from foo', Delete.from[:foo].to_sql
+  end
+
+  def test_delete_with_where_clause
+    statement = Delete.from[:table].where do
+      equal :'table.column1', :'table.column2'
+    end
+    assert_equal 'delete from table where table.column1 = table.column2', statement.to_sql
+  end
+    
+  def test_delete_with_select_statement_including_tables_from_delete_context
+    statement = Delete.from[:potential_account_offers].where do
+      exists(Select[:'potential_account_offers.id'].from[:foo].where do
+        equal :'potential_account_offers.id', :'foo.bar' 
+      end)
+    end
+    expected = 'delete from potential_account_offers where exists (select potential_account_offers.id from foo where potential_account_offers.id = foo.bar)'
+    assert_equal expected, statement.to_sql
+  end
+  
+  def test_if_where_is_called_with_no_block_gives_reminder_to_use_parents
+    assert_raise(ArgumentError) do
+      statement = Delete.from[:potential_account_offers].where do
+        exists Select[:'potential_account_offers.id'].from[:foo].where do
+          equal :'foo.id', :'foo.bar' 
+        end
+      end
+    end
+  end
+
+end 

data/test/insert_acceptance_test.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class InsertAcceptanceTest < Test::Unit::TestCase
+  def test_insert_select
+    statement = Insert.into[:table1][:column1, :column2, :column3].values do
+      Select[1]
+    end
+    assert_equal 'insert into table1 (column1, column2, column3) select 1', statement.to_sql
+  end
+  
+  def test_insert_with_values
+    statement = Insert.into[:table1][:column1, :column2, :column3].values(10, 'book', :column4)
+    assert_equal "insert into table1 (column1, column2, column3) values (10, 'book', column4)", statement.to_sql
+  end
+end

data/test/insert_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class InsertTest < Test::Unit::TestCase 
+
+  def test_table_name_saved
+    assert_equal "insert into table", Insert.into[:table].to_sql
+  end
+  
+  def test_insert_with_statement_block
+    statement = Insert.into[:foo].values do
+      Struct.new(:to_sql).new('bar')
+    end
+    assert_equal "insert into foo bar", statement.to_sql    
+  end
+    
+  def test_insert_with_explicit_column_order
+    statement = Insert.into[:foo][:column1, :column2].values do
+      Struct.new(:to_sql).new('more')
+    end
+    assert_equal "insert into foo (column1, column2) more", statement.to_sql
+  end
+    
+  def test_insert_with_multiple_sql_statements_in_block_uses_last
+    statement = Insert.into[:foo].values do
+      Struct.new(:to_sql).new('woo')
+      Struct.new(:to_sql).new('hoo')
+    end
+    assert_equal "insert into foo hoo", statement.to_sql
+  end
+
+
+  def test_values_WITH_no_block
+    statement = Insert.into[:foo].values(10, :book)
+    assert_equal "insert into foo values (10, book)", statement.to_sql
+  end
+end 
+

data/test/object_test.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ObjectTest < Test::Unit::TestCase 
+
+  def test_to_sql_equal
+    assert_equal "column1 = foo", foo.to_sql_equal(:column1)
+  end  
+  
+  def test_to_sql_more_than
+    assert_equal "column1 > foo", foo.to_sql_more_than(:column1)
+  end
+  
+  def test_to_sql_less_than
+    assert_equal "column1 < foo", foo.to_sql_less_than(:column1)
+  end
+  
+  def test_to_sql_less_than_equal
+    assert_equal "column1 <= foo", foo.to_sql_less_than_or_equal_to(:column1)
+  end
+  
+  def test_to_sql_more_than_equal
+    assert_equal "column1 >= foo", foo.to_sql_more_than_or_equal_to(:column1)
+  end
+  
+  def foo
+    Struct.new(:to_sql).new(:foo)
+  end
+
+end 

data/test/select_acceptance_test.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class SelectAcceptanceTest < Test::Unit::TestCase
+  def test_simple_select
+    statement = Select[:column1, 'book', 10].from[:table1].where do
+      equal :column1, 99
+      equal :column2, 'star'
+    end
+    expected = "select column1, 'book', 10 from table1 where column1 = 99 and column2 = 'star'"
+    assert_equal expected, statement.to_sql
+  end
+  
+  def test_select_with_join
+    statement = Select[:column1, :column2].from[:table1, :table2].where do
+      equal :'table1.id', :'table2.table1_id'
+    end
+    expected = "select column1, column2 from table1, table2 where table1.id = table2.table1_id"
+    assert_equal expected, statement.to_sql
+  end
+end

data/test/select_test.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class SelectTest < Test::Unit::TestCase 
+  def test_select_with_single_column
+    assert_equal 'select foo', Select[:foo].to_sql
+  end
+
+  def test_select_with_multiple_columns
+    assert_equal 'select foo, bar', Select[:foo, :bar].to_sql
+  end
+  
+  def test_time_literals_quoted
+    time = Time.at(946702800)
+    assert_equal "select to_timestamp('2000-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')", Select[time].to_sql
+  end
+  
+  def test_select_with_symbol_and_literal_columns
+    assert_equal "select symbol, 'literal'", Select[:symbol, 'literal'].to_sql
+  end
+  
+  def test_select_with_single_table
+    assert_equal 'select foo from foo', Select[:foo].from[:foo].to_sql
+  end
+    
+  def test_select_with_multiple_tables
+    assert_equal 'select column from bar, foo',
+                 Select[:column].from[:foo, :bar].to_sql
+  end
+end 

data/test/string_test.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class StringTest < Test::Unit::TestCase 
+  def test_to_sql_gives_quoted
+    assert_equal "'123'", "123".to_sql
+  end
+
+  def test_to_sql_gives_quoted_and_escapes_single_quotes
+    assert_equal "'it''s'", "it's".to_sql
+  end
+end

data/test/symbol_test.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class SymbolTest < Test::Unit::TestCase 
+  def test_to_sql_returns_to_s
+    assert_equal 'asdf', :asdf.to_sql
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/sqldsl'

data/test/time_test.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class TimeTest < Test::Unit::TestCase 
+  def test_to_sql_gives_quoted
+    t = Time.at(946702800)
+    assert_equal "to_timestamp('2000-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')", t.to_sql
+  end
+end 

data/test/update_acceptance_test.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class UpdateAcceptanceTest < Test::Unit::TestCase
+  def test_insert_select
+    statement = Update[:table1].set[:column1=>10, :column2=>'book'].where do
+      not_exists(Select[1].from[:table2])
+    end
+    assert_equal "update table1 set column1=10, column2='book' where not exists (select 1 from table2)", statement.to_sql
+  end
+end

data/test/update_test.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class UpdateTest < Test::Unit::TestCase
+
+  def test_update_takes_a_table_name
+    assert_equal "update account_info", Update[:account_info].to_sql
+  end
+
+  def test_update_set_appends_hash_values
+    assert_equal "update account_info set bar='cat', foo=1", Update[:account_info].set[:foo=>1, :bar=> 'cat'].to_sql
+  end
+
+end

data/test/where_builder_test.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class WhereBuilderTest < Test::Unit::TestCase
+  
+  def test_single_equal_where_criteria
+    statement = WhereBuilder.new do
+      equal :'foo.column1', :'bar.column2'
+    end
+    assert_equal ' where foo.column1 = bar.column2', statement.to_sql
+  end
+  
+  def test_single_equal_with_array_where_criteria
+    statement = WhereBuilder.new do
+      equal :'foo.column1', ['foo','bar']
+    end
+    assert_equal " where foo.column1 in ('foo', 'bar')", statement.to_sql
+  end
+
+  def test_multiple_equal_with_more_than_one_where_criteria
+    statement = WhereBuilder.new do
+      equal :'foo.column1', :'bar.column2'
+      equal :'foo.column3', :'bar.column5'
+    end
+    expected = " where foo.column1 = bar.column2 and foo.column3 = bar.column5"
+    assert_equal expected, statement.to_sql
+  end
+  
+  def test_with_literal_where_criteria
+    statement = WhereBuilder.new do
+      equal 'foo.column1', :'bar.column2'
+      equal :'foo.column3', 'bar.column5'
+    end
+    expected = " where 'foo.column1' = bar.column2 and foo.column3 = 'bar.column5'"
+    assert_equal expected, statement.to_sql
+  end
+  
+  def test_exists_evaluates_sql_statement_followed
+    statement = WhereBuilder.new do
+      exists Struct.new(:to_sql).new('select foo')
+    end
+    assert_equal ' where exists (select foo)', statement.to_sql
+  end
+  
+  def test_not_exists_evaluates_sql_statement_followed
+    statement = WhereBuilder.new do
+      not_exists Struct.new(:to_sql).new('select foo')
+    end
+    assert_equal ' where not exists (select foo)', statement.to_sql
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: sqldsl
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+date: 2006-09-16 00:00:00 -04:00
+summary: A DSL for creating SQL Statements
+require_paths: 
+- lib
+email: sqldsl-developer@rubyforge.org
+homepage: http://sqldsl.rubyforge.org
+rubyforge_project: sqldsl
+description: A DSL for creating SQL Statements
+autorequire: sqldsl
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Jay Fields
+files: 
+- lib/array.rb
+- lib/delete.rb
+- lib/insert.rb
+- lib/numeric.rb
+- lib/object.rb
+- lib/select.rb
+- lib/sql_statement.rb
+- lib/sqldsl.rb
+- lib/string.rb
+- lib/symbol.rb
+- lib/time.rb
+- lib/update.rb
+- lib/where_builder.rb
+- test/all_tests.rb
+- test/array_test.rb
+- test/delete_acceptance_test.rb
+- test/delete_test.rb
+- test/insert_acceptance_test.rb
+- test/insert_test.rb
+- test/object_test.rb
+- test/select_acceptance_test.rb
+- test/select_test.rb
+- test/string_test.rb
+- test/symbol_test.rb
+- test/test_helper.rb
+- test/time_test.rb
+- test/update_acceptance_test.rb
+- test/update_test.rb
+- test/where_builder_test.rb
+- README
+- README_TEMPLATE
+test_files: 
+- test/all_tests.rb
+rdoc_options: 
+- --title
+- SQL DSL
+- --main
+- README
+- --line-numbers
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+