sequel 0.1.9.12 → 0.2.0

data/lib/sequel/dataset/{dataset_sql.rb → sql.rb}

@@ -86,7 +86,7 @@ module Sequel
       # If an unsupported object is given, an exception is raised.
       def literal(v)
         case v
-        when ExpressionString: v
+        when LiteralString: v
         when String: "'#{v.gsub(/'/, "''")}'"
         when Integer, Float: v.to_s
         when NilClass: NULL
@@ -103,92 +103,24 @@ module Sequel
       end
 
       AND_SEPARATOR = " AND ".freeze
-
-      # Formats an equality expression involving a left value and a right value.
-      # Equality expressions differ according to the class of the right value.
-      # The stock implementation supports Range (inclusive and exclusive), Array
-      # (as a list of values to compare against), Dataset (as a subquery to
-      # compare against), or a regular value.
-      #
-      #   dataset.format_eq_expression('id', 1..20) #=>
-      #     "(id >= 1 AND id <= 20)"
-      #   dataset.format_eq_expression('id', [3,6,10]) #=>
-      #     "(id IN (3, 6, 10))"
-      #   dataset.format_eq_expression('id', DB[:items].select(:id)) #=>
-      #     "(id IN (SELECT id FROM items))"
-      #   dataset.format_eq_expression('id', nil) #=>
-      #     "(id IS NULL)"
-      #   dataset.format_eq_expression('id', 3) #=>
-      #     "(id = 3)"
-      def format_eq_expression(left, right)
-        case right
-        when Range:
-          right.exclude_end? ? \
-            "(#{left} >= #{literal(right.begin)} AND #{left} < #{literal(right.end)})" : \
-            "(#{left} >= #{literal(right.begin)} AND #{left} <= #{literal(right.end)})"
-        when Array:
-          "(#{left} IN (#{literal(right)}))"
-        when Dataset:
-          "(#{left} IN (#{right.sql}))"
-        when NilClass:
-          "(#{left} IS NULL)"
-        else
-          "(#{left} = #{literal(right)})"
-        end
-      end
-
-      # Formats an expression comprising a left value, a binary operator and a
-      # right value. The supported operators are :eql (=), :not (!=), :lt (<),
-      # :lte (<=), :gt (>), :gte (>=) and :like (LIKE operator). Examples:
-      #
-      #   dataset.format_expression('price', :gte, 100) #=> "(price >= 100)"
-      #   dataset.format_expression('id', :not, 30) #=> "NOT (id = 30)"
-      #   dataset.format_expression('name', :like, 'abc%') #=>
-      #     "(name LIKE 'abc%')"
-      #
-      # If an unsupported operator is given, an exception is raised.
-      def format_expression(left, op, right)
-        left = field_name(left)
-        case op
-        when :eql:
-          format_eq_expression(left, right)
-        when :not:
-          "NOT #{format_eq_expression(left, right)}"
-        when :lt:
-          "(#{left} < #{literal(right)})"
-        when :lte:
-          "(#{left} <= #{literal(right)})"
-        when :gt:
-          "(#{left} > #{literal(right)})"
-        when :gte:
-          "(#{left} >= #{literal(right)})"
-        when :like:
-          "(#{left} LIKE #{literal(right)})"
-        else
-          raise SequelError, "Invalid operator specified: #{op}"
-        end
-      end
-
       QUESTION_MARK = '?'.freeze
 
       # Formats a where clause. If parenthesize is true, then the whole 
       # generated clause will be enclosed in a set of parentheses.
-      def expression_list(where, parenthesize = false)
-        case where
+      def expression_list(expr, parenthesize = false)
+        case expr
         when Hash:
-          parenthesize = false if where.size == 1
-          fmt = where.map {|i| format_expression(i[0], :eql, i[1])}.
-            join(AND_SEPARATOR)
+          parenthesize = false if expr.size == 1
+          fmt = expr.map {|i| compare_expr(i[0], i[1])}.join(AND_SEPARATOR)
         when Array:
-          fmt = where.shift.gsub(QUESTION_MARK) {literal(where.shift)}
+          fmt = expr.shift.gsub(QUESTION_MARK) {literal(expr.shift)}
         when Proc:
-          fmt = where.to_expressions.map {|e| format_expression(e.left, e.op, e.right)}.
-            join(AND_SEPARATOR)
+          fmt = proc_to_sql(expr)
         else
           # if the expression is compound, it should be parenthesized in order for 
           # things to be predictable (when using #or and #and.)
-          parenthesize |= where =~ /\).+\(/
-          fmt = where
+          parenthesize |= expr =~ /\).+\(/
+          fmt = expr
         end
         parenthesize ? "(#{fmt})" : fmt
       end
@@ -272,10 +204,6 @@ module Sequel
         parenthesize = !(cond.is_a?(Hash) || cond.is_a?(Array))
         filter = cond.is_a?(Hash) && cond
         if @opts[clause]
-          if filter && cond.is_a?(Hash)
-            filter
-          end
-          filter = 
           l = expression_list(@opts[clause])
           r = expression_list(block || cond, parenthesize)
           clone_merge(clause => "#{l} AND #{r}")
@@ -427,6 +355,10 @@ module Sequel
       # options.
       def select_sql(opts = nil)
         opts = opts ? @opts.merge(opts) : @opts
+        
+        if sql = opts[:sql]
+          return sql
+        end
 
         fields = opts[:select]
         select_fields = fields ? field_list(fields) : WILDCARD

data/lib/sequel/model.rb

@@ -82,7 +82,7 @@ module Sequel
     end
     
     def self.drop_table
-      db.execute schema.drop_sql
+      db.execute db.drop_table_sql(table_name)
     end
     
     def self.recreate_table
@@ -224,13 +224,13 @@ module Sequel
       Thread.exclusive do
         method_name = m.to_s
         if method_name =~ FIND_BY_REGEXP
-          c = $1
+          c = $1.to_sym
           meta_def(method_name) {|arg| find(c => arg)}
         elsif method_name =~ FILTER_BY_REGEXP
-          c = $1
+          c = $1.to_sym
           meta_def(method_name) {|arg| filter(c => arg)}
         elsif method_name =~ ALL_BY_REGEXP
-          c = $1
+          c = $1.to_sym
           meta_def(method_name) {|arg| filter(c => arg).all}
         elsif dataset.respond_to?(m)
           instance_eval("def #{m}(*args, &block); dataset.#{m}(*args, &block); end")

data/lib/sequel/mysql.rb

@@ -156,10 +156,22 @@ module Sequel
         end
       end
       
+      TRUE = '1'
+      FALSE = '0'
+      
       def literal(v)
         case v
-        when true: '1'
-        when false: '0'
+        when true: TRUE
+        when false: FALSE
+        else
+          super
+        end
+      end
+      
+      def match_expr(l, r)
+        case r
+        when Regexp:
+          "(#{literal(l)} REGEXP #{literal(r.source)})"
         else
           super
         end

data/lib/sequel/postgres.rb

@@ -285,14 +285,12 @@ module Sequel
       LIKE = '(%s ~ %s)'.freeze
       LIKE_CI = '%s ~* %s'.freeze
       
-      def format_eq_expression(left, right)
-        case right
+      def match_expr(l, r)
+        case r
         when Regexp:
-          l = field_name(left)
-          r = PGconn.quote(right.source)
-          right.casefold? ? \
-            "(#{l} ~* #{r})" : \
-            "(#{l} ~ #{r})"
+          r.casefold? ? \
+            "(#{literal(l)} ~* #{literal(r.source)})" :
+            "(#{literal(l)} ~ #{literal(r.source)})"
         else
           super
         end

data/lib/sequel/schema/schema_generator.rb

@@ -10,8 +10,7 @@ module Sequel
       end
       
       def method_missing(type, name = nil, opts = nil)
-        return super unless name
-        column(name, type, opts)
+        name ? column(name, type, opts) : super
       end
       
       def primary_key_name

data/spec/adapters/mysql_spec.rb

@@ -116,4 +116,11 @@ context "A MySQL dataset" do
 
     @d.count.should == 1
   end
+  
+  specify "should support regexps" do
+    @d << {:name => 'abc', :value => 1}
+    @d << {:name => 'bcd', :value => 2}
+    @d.filter(:name => /bc/).count.should == 2
+    @d.filter(:name => /^bc/).count.should == 1
+  end
 end

data/spec/adapters/postgres_spec.rb

@@ -0,0 +1,87 @@
+require File.join(File.dirname(__FILE__), '../../lib/sequel/postgres')
+
+PGSQL_DB = Sequel('postgres://postgres:postgres@localhost:5432/reality_spec')
+if PGSQL_DB.table_exists?(:test)
+  PGSQL_DB.drop_table :test
+end
+PGSQL_DB.create_table :test do
+  text :name
+  integer :value
+  
+  index :value
+end
+
+context "A MySQL dataset" do
+  setup do
+    @d = PGSQL_DB[:test]
+    @d.delete # remove all records
+  end
+  
+  specify "should return the correct record count" do
+    @d.count.should == 0
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    @d.count.should == 3
+  end
+  
+  # specify "should return the last inserted id when inserting records" do
+  #   id = @d << {:name => 'abc', :value => 1.23}
+  #   id.should == @d.first[:id]
+  # end
+  #
+  
+  specify "should return all records" do
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    
+    @d.order(:value).all.should == [
+      {:name => 'abc', :value => 123},
+      {:name => 'abc', :value => 456},
+      {:name => 'def', :value => 789}
+    ]
+  end
+   
+  specify "should update records correctly" do
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    @d.filter(:name => 'abc').update(:value => 530)
+    
+    # the third record should stay the same
+    # floating-point precision bullshit
+    @d[:name => 'def'][:value].should == 789
+    @d.filter(:value => 530).count.should == 2
+  end
+  
+  specify "should delete records correctly" do
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    @d.filter(:name => 'abc').delete
+    
+    @d.count.should == 1
+    @d.first[:name].should == 'def'
+  end
+  
+  specify "should be able to literalize booleans" do
+    proc {@d.literal(true)}.should_not raise_error
+    proc {@d.literal(false)}.should_not raise_error
+  end
+  
+  specify "should support transactions" do
+    PGSQL_DB.transaction do
+      @d << {:name => 'abc', :value => 1}
+    end
+
+    @d.count.should == 1
+  end
+  
+  specify "should support regexps" do
+    @d << {:name => 'abc', :value => 1}
+    @d << {:name => 'bcd', :value => 2}
+    @d.filter(:name => /bc/).count.should == 2
+    @d.filter(:name => /^bc/).count.should == 1
+  end
+end

data/spec/adapters/sqlite_spec.rb

@@ -152,10 +152,10 @@ context "SQLite::Dataset#delete" do
   
   specify "should return the number of records affected when filtered" do
     @d.count.should == 3
-    @d.filter {value < 3}.delete.should == 1
+    @d.filter {:value < 3}.delete.should == 1
     @d.count.should == 2
 
-    @d.filter {value < 3}.delete.should == 0
+    @d.filter {:value < 3}.delete.should == 0
     @d.count.should == 2
   end
   

data/spec/connection_pool_spec.rb

@@ -152,7 +152,7 @@ context "A connection pool with a max size of 1" do
     @pool.allocated.should == {t1 => cc}
     
     cc.gsub!('rr', 'll')
-    sleep 0.2
+    sleep 0.5
     
     # connection held by t2
     t1.should_not be_alive
@@ -164,7 +164,7 @@ context "A connection pool with a max size of 1" do
     @pool.allocated.should == {t2 => cc}
     
     cc.gsub!('ll', 'rr')
-    sleep 0.2
+    sleep 0.5
     
     #connection released
     t2.should_not be_alive

data/spec/core_ext_spec.rb

@@ -52,11 +52,34 @@ context "String#to_sql" do
   end
 end
 
+context "String#lit" do
+  specify "should return an LiteralString object" do
+    'xyz'.lit.should be_a_kind_of(Sequel::LiteralString)
+    'xyz'.lit.to_s.should == 'xyz'
+  end
+  
+  specify "should inhibit string literalization" do
+    db = Sequel::Database.new
+    ds = db[:t]
+    
+    ds.update_sql(:stamp => "NOW()".lit).should == \
+      "UPDATE t SET stamp = NOW()"
+  end
+end
+
 context "String#expr" do
-  specify "should return an ExpressionString object" do
-    'xyz'.expr.should be_a_kind_of(Sequel::ExpressionString)
+  specify "should return an LiteralString object" do
+    'xyz'.expr.should be_a_kind_of(Sequel::LiteralString)
     'xyz'.expr.to_s.should == 'xyz'
   end
+
+  specify "should inhibit string literalization" do
+    db = Sequel::Database.new
+    ds = db[:t]
+    
+    ds.update_sql(:stamp => "NOW()".expr).should == \
+      "UPDATE t SET stamp = NOW()"
+  end
 end
 
 context "String#split_sql" do
@@ -150,4 +173,22 @@ context "Symbol" do
   specify "should support AVG for specifying avg function" do
     :abc__def.AVG.should == 'avg(abc.def)'
   end
+  
+  specify "should support COUNT for specifying count function" do
+    :abc__def.COUNT.should == 'count(abc.def)'
+  end
+  
+  specify "should support any other function using upper case letters" do
+    :abc__def.DADA.should == 'dada(abc.def)'
+  end
+  
+  specify "should support upper case outer functions" do
+    :COUNT['1'].should == 'COUNT(1)'
+  end
+  
+  specify "should inhibit string literalization" do
+    db = Sequel::Database.new
+    ds = db[:t]
+    ds.select(:COUNT['1']).sql.should == "SELECT COUNT(1) FROM t"
+  end
 end

data/spec/database_spec.rb

@@ -82,6 +82,12 @@ context "Database#dataset" do
     e.sql.should == 'SELECT * FROM miu'
   end
   
+  specify "should provide a filtered #from dataset if a block is given" do
+    d = @db.from(:mau) {:x > 100}
+    d.should be_a_kind_of(Sequel::Dataset)
+    d.sql.should == 'SELECT * FROM mau WHERE (x > 100)'
+  end
+  
   specify "should provide a #select dataset" do
     d = @db.select(:a, :b, :c).from(:mau)
     d.should be_a_kind_of(Sequel::Dataset)

data/spec/dataset_spec.rb

@@ -110,6 +110,11 @@ context "A simple dataset" do
     @dataset.update_sql(:name => 'abc').should ==
       "UPDATE test SET name = 'abc'"
   end
+  
+  specify "should be able to return rows for arbitrary SQL" do
+    @dataset.select_sql(:sql => 'xxx yyy zzz').should ==
+      "xxx yyy zzz"
+  end
 end
 
 context "A dataset with multiple tables in its FROM clause" do
@@ -208,7 +213,7 @@ context "Dataset#where" do
       "SELECT * FROM test WHERE (a = 1) AND (d = 4)"
       
     # string and proc expr
-    @d3.where {e < 5}.select_sql.should ==
+    @d3.where {:e < 5}.select_sql.should ==
       "SELECT * FROM test WHERE (a = 1) AND (e < 5)"
   end
   
@@ -222,10 +227,10 @@ context "Dataset#where" do
     @dataset.filter(:id => 4...7).sql.should ==
       'SELECT * FROM test WHERE (id >= 4 AND id < 7)'
 
-    @dataset.filter {id == (4..7)}.sql.should ==
+    @dataset.filter {:id == (4..7)}.sql.should ==
       'SELECT * FROM test WHERE (id >= 4 AND id <= 7)'
 
-    @dataset.filter {id.in 4..7}.sql.should ==
+    @dataset.filter {:id.in?(4..7)}.sql.should ==
       'SELECT * FROM test WHERE (id >= 4 AND id <= 7)'
   end
   
@@ -233,7 +238,7 @@ context "Dataset#where" do
     @dataset.filter(:owner_id => nil).sql.should ==
       'SELECT * FROM test WHERE (owner_id IS NULL)'
 
-    @dataset.filter{owner_id.nil?}.sql.should ==
+    @dataset.filter{:owner_id.nil?}.sql.should ==
       'SELECT * FROM test WHERE (owner_id IS NULL)'
   end
   
@@ -247,45 +252,39 @@ context "Dataset#where" do
   end
   
   specify "should accept a subquery for an EXISTS clause" do
-    a = @dataset.filter {price < 100}
+    a = @dataset.filter {:price < 100}
     @dataset.filter(a.exists).sql.should ==
       'SELECT * FROM test WHERE EXISTS (SELECT 1 FROM test WHERE (price < 100))'
   end
   
-  specify "should accept proc expressions (nice!)" do
+  specify "should accept proc expressions" do
     d = @d1.select(:gdp.AVG)
-    @dataset.filter {gdp > d}.sql.should ==
+    @dataset.filter {:gdp > d}.sql.should ==
       "SELECT * FROM test WHERE (gdp > (SELECT avg(gdp) FROM test WHERE (region = 'Asia')))"
     
-    @dataset.filter {id.in 4..7}.sql.should ==
+    @dataset.filter {:id.in(4..7)}.sql.should ==
       'SELECT * FROM test WHERE (id >= 4 AND id <= 7)'
     
-    @dataset.filter {c == 3}.sql.should ==
+    @dataset.filter {:c == 3}.sql.should ==
       'SELECT * FROM test WHERE (c = 3)'
       
-    @dataset.filter {id == :items__id}.sql.should ==
+    @dataset.filter {:id == :items__id}.sql.should ==
       'SELECT * FROM test WHERE (id = items.id)'
       
-    @dataset.filter {a < 1}.sql.should ==
+    @dataset.filter {:a < 1}.sql.should ==
       'SELECT * FROM test WHERE (a < 1)'
 
-    @dataset.filter {a <=> 1}.sql.should ==
-      'SELECT * FROM test WHERE NOT (a = 1)'
+    @dataset.filter {:a != 1}.sql.should ==
+      'SELECT * FROM test WHERE (NOT (a = 1))'
       
-    @dataset.filter {a >= 1 && b <= 2}.sql.should ==
-      'SELECT * FROM test WHERE (a >= 1) AND (b <= 2)'
+    @dataset.filter {:a >= 1 && :b <= 2}.sql.should ==
+      'SELECT * FROM test WHERE ((a >= 1) AND (b <= 2))'
       
-    @dataset.filter {c =~ 'ABC%'}.sql.should ==
+    @dataset.filter {:c.like 'ABC%'}.sql.should ==
       "SELECT * FROM test WHERE (c LIKE 'ABC%')"
 
-    @dataset.filter {test.ccc =~ 'ABC%'}.sql.should ==
-      "SELECT * FROM test WHERE (test.ccc LIKE 'ABC%')"
-  end
-  
-  specify "should raise SequelError for invalid proc expressions" do
-    proc {@dataset.filter {Object.czxczxcz}}.should raise_error(SequelError)
-    proc {@dataset.filter {a.bcvxv}}.should raise_error(SequelError)
-    proc {@dataset.filter {x}}.should raise_error(SequelError)
+    @dataset.filter {:c.like? 'ABC%'}.sql.should ==
+      "SELECT * FROM test WHERE (c LIKE 'ABC%')"
   end
 end
 
@@ -309,7 +308,7 @@ context "Dataset#or" do
     @d1.or('(y > ?)', 2).sql.should ==
       'SELECT * FROM test WHERE (x = 1) OR (y > 2)'
       
-    (@d1.or {yy > 3}).sql.should ==
+    (@d1.or {:yy > 3}).sql.should ==
       'SELECT * FROM test WHERE (x = 1) OR (yy > 3)'
   end
   
@@ -342,7 +341,7 @@ context "Dataset#and" do
     @d1.and('(y > ?)', 2).sql.should ==
       'SELECT * FROM test WHERE (x = 1) AND (y > 2)'
       
-    (@d1.and {yy > 3}).sql.should ==
+    (@d1.and {:yy > 3}).sql.should ==
       'SELECT * FROM test WHERE (x = 1) AND (yy > 3)'
   end
   
@@ -387,7 +386,7 @@ context "Dataset#exclude" do
   end
   
   specify "should support proc expressions" do
-    @dataset.exclude {id == (6...12)}.sql.should == 
+    @dataset.exclude {:id == (6...12)}.sql.should == 
       'SELECT * FROM test WHERE NOT ((id >= 6 AND id < 12))'
   end
 end
@@ -411,7 +410,7 @@ context "Dataset#having" do
   end
 
   specify "should support proc expressions" do
-    @grouped.having {SUM(:population) > 10}.sql.should == 
+    @grouped.having {:sum[:population] > 10}.sql.should == 
       "SELECT #{@fields} FROM test GROUP BY region HAVING (sum(population) > 10)"
   end
 end
@@ -753,7 +752,7 @@ context "Dataset#count" do
   end
   
   specify "should include the where clause if it's there" do
-    @dataset.filter {abc < 30}.count.should == 1
+    @dataset.filter {:abc < 30}.count.should == 1
     @c.sql.should == 'SELECT COUNT(*) FROM test WHERE (abc < 30)'
   end
 end
@@ -769,7 +768,7 @@ context "Dataset#join_table" do
   end
   
   specify "should include WHERE clause if applicable" do
-    @d.filter {price < 100}.join_table(:right_outer, :categories, :category_id => :id).sql.should ==
+    @d.filter {:price < 100}.join_table(:right_outer, :categories, :category_id => :id).sql.should ==
       'SELECT * FROM items RIGHT OUTER JOIN categories ON (categories.category_id = items.id) WHERE (price < 100)'
   end