seaquel 0.1 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f51aa6cb26dbabeed5e62e1544877377b44090bc
-  data.tar.gz: 982a28e72454c041dd21129416c7def66b95ff32
+  metadata.gz: cb2280004405139dd8f18d4de19167e109237cbf
+  data.tar.gz: 6f69df626061268803471fcfd054ba3add31b9d6
 SHA512:
-  metadata.gz: d50b0346f4288a0974d2b0364b3f6596cde261fbcb126662a3aaf9f92fcd5c0255d688c5707afcf2b0d6d4639861427172aac652c20ed5347667175904c97290
-  data.tar.gz: cb41ddc3e7e14f77ab0f0774660fc66a414c5c6c4a4f02e7d42ad205a5ac1a5c6e32d08f48a88ea2c2a8189d6eaa1e9e12d338365a11ed6870791962ac1cef2f
+  metadata.gz: feb75d0e123f642bcf68cdd1e2806c2735b8600713702a1967d1db1e438df76100f28dafd35bff14fa7dbd4e5a1f6c613c3de8eac8bb24348901345801ddc897
+  data.tar.gz: 0b88723ab4fba22324ef8acf496a5edbdddd34ed16ca8e70c0af72aa495cc2333d5c7c0a4df139c2f9e839be3810ccf8d11e0ab6f2c8796ae0a9d645742c4134

data/lib/seaquel/ast.rb

@@ -2,6 +2,7 @@
 module Seaquel::AST
 end
 
+require 'seaquel/ast/expression'
 require 'seaquel/ast/node'
 require 'seaquel/ast/bin_op'
 require 'seaquel/ast/join_op'
@@ -12,8 +13,8 @@ require 'seaquel/ast/column_list'
 require 'seaquel/ast/column'
 require 'seaquel/ast/table'
 require 'seaquel/ast/literal'
-require 'seaquel/ast/immediate'
 require 'seaquel/ast/binding'
 require 'seaquel/ast/funcall'
 require 'seaquel/ast/table_alias'
-require 'seaquel/ast/order'
+require 'seaquel/ast/order'
+require 'seaquel/ast/unary'

data/lib/seaquel/ast/alias.rb

@@ -11,5 +11,9 @@ module Seaquel::AST
     def visit visitor
       visitor.visit_alias(name, expression)
     end
+
+    def inspect
+      "(alias #{name.inspect} #{expression.inspect})"
+    end
   end
 end

data/lib/seaquel/ast/bin_op.rb

@@ -3,7 +3,7 @@ module Seaquel::AST
   # A binary statement as in left=right. 
   # This class can be visited.
   #
-  class BinOp
+  class BinOp < Expression
     attr_reader :op, :left, :right
     
     def initialize op, left, right

data/lib/seaquel/ast/column.rb

@@ -44,7 +44,11 @@ module Seaquel::AST
     end
 
     def inspect
-      "(column #{name})"
+      if table
+        lisp_inspect(:column, name, table)
+      else
+        lisp_inspect(:column, name)
+      end
     end
   end
 end

data/lib/seaquel/ast/expression.rb

@@ -3,24 +3,79 @@ module Seaquel::AST
   # Base class for all expression-type AST nodes. 
   #
   class Expression
-    def self.binop op
+    def self.binop op, *aliases
       define_method(op) do |exp|
         BinOp.new(op, self, exp)
       end
+
+      aliases.each do |op_alias|
+        alias_method(op_alias, op)
+      end
+    end
+    def self.joinop op, *aliases
+      define_method(op) do |exp|
+        JoinOp.new(op, [self, exp])
+      end
+
+      aliases.each do |op_alias|
+        alias_method(op_alias, op)
+      end
+    end
+    def self.unaryop op, *aliases
+      define_method(op) do
+        Unary.new(op, self)
+      end
+
+      aliases.each do |op_alias|
+        alias_method(op_alias, op)
+      end
     end
 
-    binop :eq
-    binop :noteq
+    binop :eq, :==
+    binop :noteq, :"!="
     
-    binop :lt
-    binop :lteq
+    binop :lt, :<
+    binop :lteq, :<=
 
-    binop :gt
-    binop :gteq
+    binop :gt, :>
+    binop :gteq, :>=
 
     binop :is
     binop :isnot
 
+    binop :in
+
+    binop :like
+    binop :not_like
+    binop :ilike
+    binop :not_ilike
+    binop :similar_to
+    binop :not_similar_to
+
+    binop :plus, :+
+    binop :minus, :-
+    binop :times, :*
+    binop :div, :/
+    binop :mod, :%
+
+    binop :pow, :**
+    binop :sqrt
+    binop :cbrt
+
+    binop :bitand
+    binop :bitor
+    binop :bitxor
+
+    binop :sleft, :<<
+    binop :sright, :>>
+
+    joinop :and, :&
+    joinop :or, :|
+
+    unaryop :not, :!
+    unaryop :fact
+    unaryop :bitnot
+
     def as name
       Alias.new(name, self)
     end
@@ -31,5 +86,10 @@ module Seaquel::AST
     def desc
       Order.new(:desc, self)
     end
+
+    def lisp_inspect type, *args
+      "(" + 
+        [type.to_s, args.map(&:inspect)].join(' ') + ")"
+    end
   end
 end

data/lib/seaquel/ast/join_op.rb

@@ -1,8 +1,13 @@
+
+require 'forwardable'
+
 module Seaquel::AST
   # A binary operation that can be used to join things together,  like 'AND' or
   # 'OR'.
   #
-  class JoinOp
+  class JoinOp < Expression
+    extend Forwardable
+
     attr_reader :op
     attr_reader :elements
 
@@ -10,8 +15,10 @@ module Seaquel::AST
       @op, @elements = op, elements
     end
 
-    def concat element
-      elements << element
+    def concat *more
+      more.each do |el|
+        elements << el
+      end
     end
 
     def empty?
@@ -23,7 +30,7 @@ module Seaquel::AST
     end
 
     def inspect
-      [:join_op, op, *elements].inspect
+      lisp_inspect(:join_op, op, elements)
     end
   end
 end

data/lib/seaquel/ast/node.rb

@@ -51,6 +51,13 @@ module Seaquel::AST
       node(:offset, n)
     end
 
+    def having *exps
+      node(:having, exps)
+    end
+    def group_by *fields
+      node(:group_by, fields)
+    end
+
     # Replaces previous ORDER BY specification with this one. 
     #
     # @param list [Array<Column>]
@@ -71,7 +78,7 @@ module Seaquel::AST
     #
     # Example: 
     #   include Seaquel
-    #   insert.into(table('foo')).values(immediate(1), immediate(2))
+    #   insert.into(table('foo')).values(1, 2)
     #   # => INSERT INTO "foo" VALUES (1, 2)
     #
     # @param list [Array<AST::Expression>] values to insert

data/lib/seaquel/ast/table.rb

@@ -1,5 +1,5 @@
 module Seaquel::AST
-  class Table
+  class Table < Expression
     attr_reader :name
 
     def initialize name
@@ -32,5 +32,9 @@ module Seaquel::AST
     def as_column_prefix quoter
       quote(quoter)
     end
+
+    def inspect
+      lisp_inspect(:table, name)
+    end
   end
 end

data/lib/seaquel/ast/unary.rb

@@ -0,0 +1,20 @@
+
+module Seaquel::AST
+  class Unary < Expression
+    attr_reader :exp
+    attr_reader :op
+
+    def initialize op, exp
+      @exp = exp
+      @op = op
+    end
+
+    def visit visitor
+      visitor.visit_unary op, exp
+    end
+
+    def inspect
+      "(#{op.inspect} #{exp.inspect})"
+    end
+  end
+end

data/lib/seaquel/bit.rb

@@ -17,7 +17,7 @@ module Seaquel
     # bit is lower than target_precedence, it will not be put in parenthesis.
     #
     def at target_precedence
-      if precedence != :inf && target_precedence >= precedence
+      if precedence == :inf || target_precedence <= precedence
         @str
       else
         "(#{@str})"
@@ -30,5 +30,11 @@ module Seaquel
     def toplevel
       str
     end
+
+    def == other
+      return toplevel == other if other.kind_of?(String)
+
+      super
+    end
   end
 end

data/lib/seaquel/expression_converter.rb

@@ -5,26 +5,15 @@ module Seaquel
     extend Forwardable
 
     attr_reader :quoter
-    attr_reader :symbols
 
     def initialize quoter
       @quoter = quoter
-      @symbols = {
-        :eq   => '=',
-        :gt   => '>', 
-        :gteq => '>=', 
-        :lt   => '<', 
-        :lteq => '<=', 
-        :is   => ' IS ', 
-        :isnot => ' IS NOT ', 
-        :noteq => '!='
-      }
     end
 
     # Gets called whenever the expression contains a statement-type AST::Node. 
     #
     def visit_node node
-      bit(node.to_sql, :inf)
+      bit(node.to_sql, 0)
     end
 
     def_delegator :@quoter, :string, :quote_string
@@ -40,10 +29,6 @@ module Seaquel
       end
     end
 
-    def visit_immediate sql_val
-      bit(sql_val)
-    end
-
     def visit_new_statement *args
       ::Seaquel::Generator.new(self).compact_sql
     end
@@ -86,8 +71,21 @@ module Seaquel
         op = :isnot if op==:noteq
       end
 
-      if symbols.has_key?(op)
-        symbol = symbols[op]
+      if op==:in && right.kind_of?(Range)
+        raise "Ranges excluding the right side are not permitted in Seaquel." \
+          if right.exclude_end?
+
+        return bit([
+          sql(left).at(0), 
+          'BETWEEN', 
+          right.begin, 
+          'AND', 
+          right.end].join(' '))
+      end
+
+      if binops.has_key?(op)
+        symbol = binops[op]
+
         return bit(
           [sql(left).at(prec), symbol, sql(right).at(prec)].join, 
           prec)
@@ -109,11 +107,31 @@ module Seaquel
       sql = case op
         when :and
           parts.join(' AND ')
+        when :or
+          parts.join(' OR ')
+      else
+        raise "AF: JoinOp called for #{op.inspect}, but has no branch for it."
       end
 
       bit(sql, prec)
     end
 
+    def visit_unary op, exp
+      raise "No such unary operation #{op.inspect}." \
+        unless unaryops.has_key?(op)
+
+      symbol, prefix = unaryops[op]
+      prec = precedences[op]
+
+      parts = []
+
+      parts << symbol if prefix 
+      parts << sql(exp).at(0)
+      parts << symbol unless prefix 
+
+      bit(parts.join, prec)
+    end
+
     def visit_column col
       bit(col.as_full_reference(quoter))
     end
@@ -136,6 +154,9 @@ module Seaquel
       case node
         when nil
           bit('NULL')
+        when Array
+          sql_bits = node.map { |el| sql(el).at(0) }
+          bit("(" + sql_bits.join(', ') + ")")
         when String
           bit(quote_string(node))
         when Fixnum
@@ -148,7 +169,7 @@ module Seaquel
     end
 
   private
-    def bit str, precedence=0
+    def bit str, precedence=:inf
       Bit.new(str, precedence)
     end
 
@@ -156,6 +177,48 @@ module Seaquel
       precedences[op]
     end
 
+    def binops
+      @binops ||= {
+        :eq   => '=',
+        :gt   => '>', 
+        :gteq => '>=', 
+        :lt   => '<', 
+        :lteq => '<=', 
+        :is   => ' IS ', 
+        :isnot => ' IS NOT ', 
+        :noteq => '!=', 
+        :in   => ' IN ', 
+        :like => ' LIKE ', 
+        :not_like => ' NOT LIKE ', 
+        :ilike => ' ILIKE ', 
+        :not_ilike => ' NOT ILIKE ', 
+        :similar_to => ' SIMILAR TO ',
+        :not_similar_to => ' NOT SIMILAR TO ', 
+        :plus => '+', 
+        :minus => '-', 
+        :div => '/', 
+        :times => '*', 
+        :mod => '%', 
+        :pow => '^', 
+        :sqrt => '|/', 
+        :cbrt => '||/',
+        :bitand => '&', 
+        :bitor => '|', 
+        :bitxor => '#', 
+        :sleft => '<<', 
+        :sright => '>>'
+      }
+    end
+
+    def unaryops
+      @unaryops ||= {
+                # sym,   prefix?
+        :not => ['NOT ', true], 
+        :bitnot => ['~', true],
+        :fact => ['!', false],
+      }
+    end
+
     def precedences
       @precedences ||= begin
         prec = 1 # 0 reserved for simple values
@@ -169,10 +232,13 @@ module Seaquel
         # By listing something above something else, it gets a lower precedence
         # assigned. List from lower to higher precedences. Equivalence classes
         # by extending the argument list.
+        assign[:not]
         assign[:as, :is, :isnot]
         assign[:or]
         assign[:and]
         assign[:eq, :gt, :gteq, :lt, :lteq]
+        assign[:plus, :minus]
+        assign[:times, :div]
 
         precs
       end

data/lib/seaquel/module.rb

@@ -27,9 +27,6 @@ module Seaquel
   def literal text
     AST::Literal.new(text)
   end
-  def immediate ruby_obj
-    AST::Immediate.new(ruby_obj)
-  end
   def binding position
     AST::Binding.new(position)
   end

data/lib/seaquel/statement.rb

@@ -16,7 +16,6 @@ module Seaquel
     attr_reader :expression_convertor
 
     attr_reader :from
-    attr_reader :project
     attr_reader :where
     attr_reader :set
     attr_reader :target
@@ -25,7 +24,12 @@ module Seaquel
     attr_reader :joins
     attr_reader :limit
     attr_reader :offset
+    attr_reader :having
+    
+    # These are overwritten, not appended to. 
+    attr_reader :project
     attr_reader :order_by
+    attr_reader :group_by
 
     def initialize expression_convertor
       @expression_convertor = expression_convertor
@@ -38,6 +42,8 @@ module Seaquel
       @values = list()
       @fields = column_list()
       @joins = []
+      @having = AST::JoinOp.new(:and, [])
+      @group_by = list()
     end
 
     def set_limit n
@@ -204,6 +210,16 @@ module Seaquel
         parts << convert(where)
       end
 
+      unless group_by.empty?
+        parts << 'GROUP BY'
+        parts << convert(group_by)
+      end
+
+      unless having.empty?
+        parts << 'HAVING'
+        parts << convert(having)
+      end
+
       unless order_by.empty?
         parts << 'ORDER BY'
         parts << convert(order_by)

data/lib/seaquel/statement/join.rb

@@ -13,7 +13,7 @@ module Seaquel
         @ons = AST::JoinOp.new(:and, [])
       end
 
-      def on exps
+      def on *exps
         ons.concat(*exps)
       end
 

data/lib/seaquel/statement_gatherer.rb

@@ -63,7 +63,18 @@ module Seaquel
       raise InvalidExpression, ".on without a .join encoutered" \
         unless current_join
       
-      current_join.on(exps)
+      current_join.on(*exps)
+    end
+
+    def visit_group_by parent, list
+      continue(parent)
+
+      s.group_by.replace(list)
+    end
+    def visit_having parent, exps
+      continue(parent)
+
+      s.having.concat(*exps)
     end
 
     def visit_insert parent

data/qed/generation.md

@@ -1,8 +1,8 @@
 
 # Overview
 
-This library deals with generation of valid SQL. What one would like to have is
-a programmatic interface to SQL that allows to create a query and turn it into
+This library deals with generation of SQL. What one would like to have is a
+programmatic interface to SQL that allows to create a query and turn it into
 SQL.
 
 ~~~ruby

data/spec/functional/select_spec.rb

@@ -20,6 +20,22 @@ describe 'SELECT statements' do
     SQL
   end
 
+  describe '#group_by' do
+    it 'works by replacing earlier group_bys' do
+      a = column(:a)
+      b = column(:b)
+      select.group_by(a).group_by(b).generates <<-SQL
+        SELECT * GROUP BY "b"
+      SQL
+    end
+  end
+  describe '#having' do
+    it 'works like #where' do
+      select.having(1).having(2).generates <<-SQL
+        SELECT * HAVING 1 AND 2
+      SQL
+    end
+  end
   describe '#join' do
     it 'allows joining tables (INNER JOIN being the default)' do
       foo = table(:foo)

data/spec/functional/update_spec.rb

@@ -5,14 +5,14 @@ describe 'UPDATE statements' do
   include Seaquel
 
   it 'can be used' do
-    update(table('bar')).set(column('foo').to(immediate(1))).generates <<-SQL
+    update(table('bar')).set(column('foo').to(1)).generates <<-SQL
       UPDATE "bar" SET "foo"=1
     SQL
   end
   it 'set statements can be chained' do
     update(table('bar')).
-      set(column('foo').to(immediate(1))).
-      set(column('bar').to(immediate(2))).generates <<-SQL
+      set(column('foo').to(1)).
+      set(column('bar').to(2)).generates <<-SQL
       UPDATE "bar" SET "foo"=1, "bar"=2
     SQL
   end

data/spec/lib/ast/column_spec.rb

@@ -39,6 +39,11 @@ describe Seaquel::AST::Column do
       SELECT * WHERE "foo" IS NOT 1
     SQL
   end
+  it 'allows comparison "IN"' do
+    select.where(column('foo').in([1,2])).generates <<-SQL
+      SELECT * WHERE "foo" IN (1, 2)
+    SQL
+  end
 
   it 'allows ASC modifier for use in ORDER BY' do
     select.order_by(column('foo').asc).generates <<-SQL
@@ -50,4 +55,37 @@ describe Seaquel::AST::Column do
       SELECT * ORDER BY "foo" DESC
     SQL
   end
+
+  describe 'string comparison functions' do
+    it 'allows comparison "LIKE"' do
+      select.where(column('foo').like('test')).generates <<-SQL
+        SELECT * WHERE "foo" LIKE 'test'
+      SQL
+    end    
+    it 'allows comparison "NOT LIKE"' do
+      select.where(column('foo').not_like('test')).generates <<-SQL
+        SELECT * WHERE "foo" NOT LIKE 'test'
+      SQL
+    end    
+    it 'allows comparison "SIMILAR TO"' do
+      select.where(column('foo').similar_to('test')).generates <<-SQL
+        SELECT * WHERE "foo" SIMILAR TO 'test'
+      SQL
+    end    
+    it 'allows comparison "NOT SIMILAR TO"' do
+      select.where(column('foo').not_similar_to('test')).generates <<-SQL
+        SELECT * WHERE "foo" NOT SIMILAR TO 'test'
+      SQL
+    end    
+    it 'allows comparison "ILIKE"' do
+      select.where(column('foo').ilike('test')).generates <<-SQL
+        SELECT * WHERE "foo" ILIKE 'test'
+      SQL
+    end    
+    it 'allows comparison "NOT ILIKE"' do
+      select.where(column('foo').not_ilike('test')).generates <<-SQL
+        SELECT * WHERE "foo" NOT ILIKE 'test'
+      SQL
+    end    
+  end
 end

data/spec/lib/ast/expression_spec.rb

@@ -0,0 +1,86 @@
+
+require 'spec_helper'
+
+describe Seaquel::AST::Expression do
+  let(:q) { Seaquel::Quoter.new }
+  let(:ec) { Seaquel::ExpressionConverter.new(q) }
+
+  # ----------------------------------------------------------------------------
+  # Using a, b and c (all columns) or e1, e2 and e3 (any expression), various 
+  # patterns are formulated and tested against SQL that should be aequivalent.
+  #
+  extend Seaquel
+
+  a, b, c = [:a, :b, :c].map { |e| column(e) }
+
+  e1 = Seaquel::AST::Expression.new
+  e2 = Seaquel::AST::Expression.new
+  e3 = Seaquel::AST::Expression.new
+
+  # Define an ad-hoc #visit method for each of those expressions, so that we
+  # can test operators in general: 
+  [e1, e2, e3].each_with_index do |e, i|
+    e.define_singleton_method(:visit) do |visitor|
+      Seaquel::Bit.new("e#{i+1}", :inf)
+    end
+  end
+
+  # Here are the test cases:
+  [
+    # basic column AND/OR
+    [a & b, '"a" AND "b"'],             # 1, 
+    [a | b, '"a" OR "b"'], 
+    # basic expression AND/OR
+    [e1 & e2, 'e1 AND e2'],
+    [e1 | e2, 'e1 OR e2'],
+    [e1 & e2 | e3, 'e1 AND e2 OR e3'],  # 5
+    [(e1 & e2) | e3, 'e1 AND e2 OR e3'],
+    [e1 & (e2 | e3), 'e1 AND (e2 OR e3)'],
+    # Basic algebra
+    [e1 + e2, 'e1+e2'],
+    [e1 - e2, 'e1-e2'],
+    [e1 * e2, 'e1*e2'],                 # 10
+    [e1 / e2, 'e1/e2'],                 
+    # NOT
+    [!e1, 'NOT e1'],
+    # Equalities, Inequalities
+    [e1 != e2, 'e1!=e2'],
+    [e1 == e2, 'e1=e2'],
+    [e1 < e2, 'e1<e2'],                 # 15
+    [e1 > e2, 'e1>e2'],
+    [e1 <= e2, 'e1<=e2'],
+    [e1 >= e2, 'e1>=e2'],
+    # Mixed bag
+    [(e1.not) == e2, '(NOT e1)=e2'],
+    [(!e1) == e2, '(NOT e1)=e2'],       # 20
+    [!e1 == e2, '(NOT e1)=e2'],
+    # More algebra
+    [e1 % e2, 'e1%e2'],
+    [e1 ** e2, 'e1^e2'],
+    [e1.sqrt(e2), 'e1|/e2'],
+    [e1.cbrt(e2), 'e1||/e2'],           # 25
+    [e1.fact, 'e1!'],                   
+    # Bitwise operators: more rare and thus more verbose.
+    [e1.bitand(e2), 'e1&e2'],
+    [e1.bitor(e2), 'e1|e2'],
+    [e1.bitxor(e2), 'e1#e2'],
+    [e1.bitnot, '~e1'],                 # 30
+    # Bit shifts
+    [e1 << e2, 'e1<<e2'],
+    [e1 >> e2, 'e1>>e2'],
+    # Precedences
+    [(e1+e2)*e3, '(e1+e2)*e3'],                 
+
+  ].each_with_index do |(exp, sql), idx|
+    begin
+      it "line #{"%2d:"%(idx+1)} turns into #{sql}" do
+        ec.sql(exp).toplevel.assert == sql
+      end
+    rescue Exception => ex
+      ex.set_backtrace(["example in spec at line #{idx+1}", *ex.backtrace])
+      raise ex
+    end
+  end
+
+
+end

data/spec/lib/expression_converter_spec.rb

@@ -0,0 +1,23 @@
+
+require 'spec_helper'
+
+describe Seaquel::ExpressionConverter do
+  include Seaquel
+
+  let(:quoter) { Seaquel::Quoter.new }
+  let(:ec) { Seaquel::ExpressionConverter.new(quoter) }
+
+  it 'converts arrays by iterating on them' do
+    ec.sql([1,2,3]).assert == '(1, 2, 3)'
+  end
+  it 'converts ranges' do
+    ec.visit_binop(:in, "left", 1..10).assert == "'left' BETWEEN 1 AND 10"
+  end
+
+  describe 'expressions' do
+    it '= binds higher than AND' do
+      exp = column(:a).eq(1).and(column(:b).eq(2))
+      ec.sql(exp).assert == '"a"=1 AND "b"=2'
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: seaquel
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
 platform: ruby
 authors:
 - Kaspar Schiess
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-18 00:00:00.000000000 Z
+date: 2015-02-19 00:00:00.000000000 Z
 dependencies: []
 description: "    Generates SQL from Ruby code. \n"
 email: kaspar.schiess@technologyastronauts.ch
@@ -30,7 +30,6 @@ files:
 - lib/seaquel/ast/column_list.rb
 - lib/seaquel/ast/expression.rb
 - lib/seaquel/ast/funcall.rb
-- lib/seaquel/ast/immediate.rb
 - lib/seaquel/ast/join_op.rb
 - lib/seaquel/ast/list.rb
 - lib/seaquel/ast/literal.rb
@@ -38,6 +37,7 @@ files:
 - lib/seaquel/ast/order.rb
 - lib/seaquel/ast/table.rb
 - lib/seaquel/ast/table_alias.rb
+- lib/seaquel/ast/unary.rb
 - lib/seaquel/bit.rb
 - lib/seaquel/expression_converter.rb
 - lib/seaquel/generator.rb
@@ -54,7 +54,8 @@ files:
 - spec/functional/select_spec.rb
 - spec/functional/update_spec.rb
 - spec/lib/ast/column_spec.rb
-- spec/lib/ast/immediate_spec.rb
+- spec/lib/ast/expression_spec.rb
+- spec/lib/expression_converter_spec.rb
 - spec/spec_helper.rb
 homepage: https://bitbucket.org/technologyastronauts/seaquel
 licenses:
@@ -89,6 +90,7 @@ test_files:
 - spec/functional/select_spec.rb
 - spec/functional/update_spec.rb
 - spec/lib/ast/column_spec.rb
-- spec/lib/ast/immediate_spec.rb
+- spec/lib/ast/expression_spec.rb
+- spec/lib/expression_converter_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/lib/seaquel/ast/immediate.rb

@@ -1,16 +0,0 @@
-
-require_relative 'expression'
-
-module Seaquel::AST
-  class Immediate < Expression
-    attr_reader :val
-
-    def initialize ruby_val
-      @val = ruby_val
-    end
-
-    def visit visitor
-      visitor.visit_immediate val.to_s
-    end
-  end
-end

data/spec/lib/ast/immediate_spec.rb

@@ -1,42 +0,0 @@
-
-require 'spec_helper'
-
-describe Seaquel::AST::Immediate do
-  include Seaquel
-
-  it 'allows comparison ">"' do
-    select.where(immediate(2).gt(1)).generates <<-SQL
-      SELECT * WHERE 2>1
-    SQL
-  end
-  it 'allows comparison ">="' do
-    select.where(immediate(2).gteq(1)).generates <<-SQL
-      SELECT * WHERE 2>=1
-    SQL
-  end
-  it 'allows comparison "<"' do
-    select.where(immediate(2).lt(1)).generates <<-SQL
-      SELECT * WHERE 2<1
-    SQL
-  end
-  it 'allows comparison "<="' do
-    select.where(immediate(2).lteq(1)).generates <<-SQL
-      SELECT * WHERE 2<=1
-    SQL
-  end
-  it 'allows comparison "!="' do
-    select.where(immediate(2).noteq(1)).generates <<-SQL
-      SELECT * WHERE 2!=1
-    SQL
-  end
-  it 'allows comparison "IS"' do
-    select.where(immediate(2).is(1)).generates <<-SQL
-      SELECT * WHERE 2 IS 1
-    SQL
-  end
-  it 'allows comparison "IS NOT"' do
-    select.where(immediate(2).isnot(1)).generates <<-SQL
-      SELECT * WHERE 2 IS NOT 1
-    SQL
-  end
-end