sequel_core 1.0.0.1 → 1.0.1

data/CHANGELOG

@@ -1,3 +1,17 @@
+=== 1.0.1 (2008-01-12)
+
+* Changed postgres adapter to quote column references using double quotes.
+
+* Applied patch for oracle adapter: fix behavior of limit and offset, transactions, #table_exists?, #tables and additional specs (thanks Liming Lian #122).
+
+* Allow for additional filters on a grouped dataset (#119 and #120)
+
+* Changed mysql adapter to default to localhost if :host option is not specified (#114).
+
+* Refactored Sequelizer to use Proc#to_sexp (method provided by r2r).
+
+* Enhanced Database.connect to accept options with string keys, so it can now accept options loaded from YAML files. Database.connect also automatically converts :username option into :user for compatibility with existing YAML configuration files for AR and DataMapper.
+
 === 1.0.0.1 (2008-01-03)
 
 * Changed MySQL adapter to support specifying socket option.

data/COPYING

@@ -1,4 +1,4 @@
-Copyright (c) 2006-2007 Sharon Rosner
+Copyright (c) 2006-2008 Sharon Rosner
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel_core"
-VERS = "1.0.0.1"
+VERS = "1.0.1"
 CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
 RDOC_OPTS = [
   "--quiet", 
@@ -105,6 +105,9 @@ end
 
 task :tag do
   cwd = FileUtils.pwd
+  sh %{rm -rf doc/*}
+  sh %{rm -rf pkg/*}
+  sh %{rm -rf coverage/*}
   sh %{cd ../.. && svn copy #{cwd} tags/#{NAME}-#{VERS} && svn commit -m "#{NAME}-#{VERS} tag." tags}
 end
 

data/lib/sequel_core/adapters/mysql.rb

@@ -86,8 +86,15 @@ module Sequel
       end
 
       def connect
-        conn = Mysql.real_connect(@opts[:host], @opts[:user], @opts[:password], 
-        @opts[:database], @opts[:port], @opts[:socket], Mysql::CLIENT_MULTI_RESULTS)
+        conn = Mysql.real_connect(
+          @opts[:host] || 'localhost',
+          @opts[:user],
+          @opts[:password],
+          @opts[:database],
+          @opts[:port],
+          @opts[:socket],
+          Mysql::CLIENT_MULTI_RESULTS
+        )
         conn.query_with_result = false
         if encoding = @opts[:encoding] || @opts[:charset]
           conn.query("set character_set_connection = '#{encoding}'")

data/lib/sequel_core/adapters/oracle.rb

@@ -38,6 +38,39 @@ module Sequel
       end
       
       alias_method :do, :execute
+      
+      def tables
+        from(:tab).select(:tname).filter(:tabtype => 'TABLE').map do |r|
+          r[:tname].downcase.to_sym
+        end
+      end
+
+      def table_exists?(name)
+        from(:tab).filter(:tname => name.to_s.upcase, :tabtype => 'TABLE').count > 0
+      end
+
+      def transaction
+        @pool.hold do |conn|
+          @transactions ||= []
+          if @transactions.include? Thread.current
+            return yield(conn)
+          end
+          
+          conn.autocommit = false
+          begin
+            @transactions << Thread.current
+            result = yield(conn)
+            conn.commit
+            result
+          rescue => e
+            conn.rollback
+            raise e unless SequelRollbackError === e
+          ensure
+            conn.autocommit = true
+            @transactions.delete(Thread.current)
+          end
+        end
+      end
     end
     
     class Dataset < Sequel::Dataset
@@ -54,10 +87,10 @@ module Sequel
         @db.synchronize do
           cursor = @db.execute sql
           begin
-            @columns = cursor.get_col_names.map {|c| c.to_sym}
+            @columns = cursor.get_col_names.map {|c| c.downcase.to_sym}
             while r = cursor.fetch
               row = {}
-              r.each_with_index {|v, i| row[@columns[i]] = v}
+              r.each_with_index {|v, i| row[columns[i]] = v unless columns[i] == :raw_rnum_}
               yield row
             end
           ensure
@@ -71,9 +104,11 @@ module Sequel
         @db.synchronize do
           cursor = @db.execute sql
           begin
-            @columns = cursor.get_col_names.map {|c| c.to_sym}
+            @columns = cursor.get_col_names.map {|c| c.downcase.to_sym}
+            raw_rnum_index = columns.index(:raw_rnum_)
             while r = cursor.fetch
-              r.keys = columns
+              r.delete_at(raw_rnum_index) if raw_rnum_index
+              r.keys =  columns.delete_if{|x| x == :raw_rnum_}
               yield r
             end
           ensure
@@ -94,6 +129,70 @@ module Sequel
       def delete(opts = nil)
         @db.do delete_sql(opts)
       end
+
+
+      # Formats a SELECT statement using the given options and the dataset
+      # options.
+      def select_sql(opts = nil)
+        opts = opts ? @opts.merge(opts) : @opts
+
+        if sql = opts[:sql]
+          return sql
+        end
+
+        columns = opts[:select]
+        select_columns = columns ? column_list(columns) : WILDCARD
+        sql = opts[:distinct] ? \
+        "SELECT DISTINCT #{select_columns}" : \
+        "SELECT #{select_columns}"
+        
+        if opts[:from]
+          sql << " FROM #{source_list(opts[:from])}"
+        end
+        
+        if join = opts[:join]
+          sql << join
+        end
+
+        if where = opts[:where]
+          sql << " WHERE #{where}"
+        end
+
+        if group = opts[:group]
+          sql << " GROUP BY #{column_list(group)}"
+        end
+
+        if having = opts[:having]
+          sql << " HAVING #{having}"
+        end
+
+        if union = opts[:union]
+          sql << (opts[:union_all] ? \
+            " UNION ALL #{union.sql}" : " UNION #{union.sql}")
+        elsif intersect = opts[:intersect]
+          sql << (opts[:intersect_all] ? \
+            " INTERSECT ALL #{intersect.sql}" : " INTERSECT #{intersect.sql}")
+        elsif except = opts[:except]
+          sql << (opts[:except_all] ? \
+            " EXCEPT ALL #{except.sql}" : " EXCEPT #{except.sql}")
+        end
+
+        if order = opts[:order]
+          sql << " ORDER BY #{column_list(order)}"
+        end
+
+        if limit = opts[:limit]
+          if (offset = opts[:offset]) && (offset > 0)
+            sql = "SELECT * FROM (SELECT raw_sql_.*, ROWNUM raw_rnum_ FROM(#{sql}) raw_sql_ WHERE ROWNUM <= #{limit + offset}) WHERE raw_rnum_ > #{offset}"
+          else
+            sql = "SELECT * FROM (#{sql}) WHERE ROWNUM <= #{limit}"
+          end
+        end
+
+        sql
+      end
+
+      alias sql select_sql
     end
   end
 end

data/lib/sequel_core/adapters/postgres.rb

@@ -313,6 +313,8 @@ module Sequel
     end
   
     class Dataset < Sequel::Dataset
+      def quote_column_ref(c); "\"#{c}\""; end
+      
       def literal(v)
         case v
         when LiteralString

data/lib/sequel_core/database.rb

@@ -414,12 +414,18 @@ module Sequel
         scheme = uri.scheme
         scheme = :dbi if scheme =~ /^dbi-(.+)/
         c = adapter_class(scheme)
-        c.new(c.uri_to_options(uri).merge(opts || {}))
+        opts = c.uri_to_options(uri).merge(opts || {})
       else
         opts = conn_string.merge(opts || {})
-        c = adapter_class(opts[:adapter])
-        c.new(opts)
+        c = adapter_class(opts[:adapter] || opts['adapter'])
       end
+      # process opts a bit
+      opts = opts.inject({}) do |m, kv| k, v = *kv
+        k = :user if k == 'username'
+        m[k.to_sym] = v
+        m
+      end
+      c.new(opts)
     end
     
     @@single_threaded = false

data/lib/sequel_core/dataset/sequelizer.rb

@@ -251,8 +251,8 @@ class Sequel::Dataset
         eval("$#{e[1]}", b)
       when :lvar # local context
         if e[1] == :block
-          pr = eval(e[1].to_s, b)
-          "#{proc_to_sql(pr)}"
+          sub_proc = eval(e[1].to_s, b)
+          sub_proc.to_sql(self)
         else
           eval(e[1].to_s, b)
         end
@@ -324,20 +324,20 @@ class Sequel::Dataset
         end
       end
     end
+  end
+end
 
-    # Translates a Ruby block into an SQL expression.
-    def proc_to_sql(proc, opts = {})
-      c = Class.new {define_method(:m, &proc)}
-      pt_expr(ParseTree.translate(c, :m)[2][2], proc.binding, opts)
-    end
+class Proc
+  def to_sql(dataset, opts = {})
+    dataset.pt_expr(to_sexp[2], self.binding, opts)
   end
 end
 
 begin
   require 'parse_tree'
 rescue Exception
-  module Sequel::Dataset::Sequelizer
-    def proc_to_sql(*args)
+  class Proc
+    def to_sql(*args)
       raise Sequel::Error, "You must have the ParseTree gem installed in order to use block filters."
     end
   end
@@ -352,3 +352,14 @@ rescue Exception
     end
   end
 end
+
+class Proc
+  # replacement for Proc#to_sexp, if it's not available
+  unless instance_methods.include?('to_sexp')
+    def to_sexp
+      block = self
+      c = Class.new {define_method(:m, &block)}
+      ParseTree.translate(c, :m)[2]
+    end
+  end
+end

data/lib/sequel_core/dataset/sql.rb

@@ -128,7 +128,7 @@ module Sequel
         when Array
           fmt = expr.shift.gsub(QUESTION_MARK) {literal(expr.shift)}
         when Proc
-          fmt = proc_to_sql(expr)
+          fmt = expr.to_sql(self)
         else
           # if the expression is compound, it should be parenthesized in order for 
           # things to be predictable (when using #or and #and.)
@@ -223,14 +223,14 @@ module Sequel
       #   software.filter {price < 100}.sql #=>
       #     "SELECT * FROM items WHERE (category = 'software') AND (price < 100)"
       def filter(*cond, &block)
-        clause = (@opts[:group] ? :having : :where)
+        clause = (@opts[:having] ? :having : :where)
         cond = cond.first if cond.size == 1
         if cond === true || cond === false
           raise Error::InvalidFilter, "Invalid filter specified. Did you mean to supply a block?"
         end
         parenthesize = !(cond.is_a?(Hash) || cond.is_a?(Array))
         filter = cond.is_a?(Hash) && cond
-        if @opts[clause]
+        if !@opts[clause].nil? and @opts[clause].any?
           l = expression_list(@opts[clause])
           r = expression_list(block || cond, parenthesize)
           clone_merge(clause => "#{l} AND #{r}")
@@ -242,7 +242,7 @@ module Sequel
       # Adds an alternate filter to an existing filter using OR. If no filter 
       # exists an error is raised.
       def or(*cond, &block)
-        clause = (@opts[:group] ? :having : :where)
+        clause = (@opts[:having] ? :having : :where)
         cond = cond.first if cond.size == 1
         parenthesize = !(cond.is_a?(Hash) || cond.is_a?(Array))
         if @opts[clause]
@@ -258,7 +258,7 @@ module Sequel
       # exists an error is raised. This method is identical to #filter except
       # it expects an existing filter.
       def and(*cond, &block)
-        clause = (@opts[:group] ? :having : :where)
+        clause = (@opts[:having] ? :having : :where)
         unless @opts[clause]
           raise Error::NoExistingFilter, "No existing filter found."
         end
@@ -270,7 +270,7 @@ module Sequel
       #   dataset.exclude(:category => 'software').sql #=>
       #     "SELECT * FROM items WHERE NOT (category = 'software')"
       def exclude(*cond, &block)
-        clause = (@opts[:group] ? :having : :where)
+        clause = (@opts[:having] ? :having : :where)
         cond = cond.first if cond.size == 1
         parenthesize = !(cond.is_a?(Hash) || cond.is_a?(Array))
         if @opts[clause]
@@ -286,11 +286,7 @@ module Sequel
       # Returns a copy of the dataset with the where conditions changed. Raises 
       # if the dataset has been grouped. See also #filter.
       def where(*cond, &block)
-        if @opts[:group]
-          raise Error, "Can't specify a WHERE clause once the dataset has been grouped"
-        else
-          filter(*cond, &block)
-        end
+        filter(*cond, &block)
       end
 
       # Returns a copy of the dataset with the having conditions changed. Raises 
@@ -299,6 +295,7 @@ module Sequel
         unless @opts[:group]
           raise Error, "Can only specify a HAVING clause on a grouped dataset"
         else
+          @opts[:having] = {}
           filter(*cond, &block)
         end
       end
@@ -501,7 +498,7 @@ module Sequel
         
         sql = "UPDATE #{@opts[:from]} SET "
         if block
-          sql << proc_to_sql(block, :comma_separated => true)
+          sql << block.to_sql(self, :comma_separated => true)
         else
           # check if array with keys
           values = values.to_hash if values.is_a?(Array) && values.keys

data/lib/sequel_core/model.rb

@@ -1,7 +1,7 @@
 module Sequel
   class Model
     def self.database_opened(db)
-      @db = db if (self == Model) && !@db
+      @db ||= db if (self == Model)
     end
   end
 end

data/spec/adapters/mysql_spec.rb

@@ -24,6 +24,18 @@ context "A MySQL database" do
     @db.disconnect
     @db.pool.size.should == 0
   end
+
+  specify "should support sequential primary keys" do
+    @db.create_table!(:with_pk) {primary_key :id; text :name}
+    @db[:with_pk] << {:name => 'abc'}
+    @db[:with_pk] << {:name => 'def'}
+    @db[:with_pk] << {:name => 'ghi'}
+    @db[:with_pk].order(:name).all.should == [
+      {:id => 1, :name => 'abc'},
+      {:id => 2, :name => 'def'},
+      {:id => 3, :name => 'ghi'}
+    ]
+  end
 end
 
 context "A MySQL dataset" do
@@ -335,6 +347,11 @@ context "A MySQL database" do
     proc {db.test_connection}.should_not raise_error
   end
   
+  specify "should accept a socket option without host option" do
+    db = Sequel.mysql('sandbox', :user => 'root', :socket => '/tmp/mysql.sock')
+    proc {db.test_connection}.should_not raise_error
+  end
+  
   specify "should fail to connect with invalid socket" do
     db = Sequel.mysql('sandbox', :host => 'localhost', :user => 'root', :socket => 'blah')
     proc {db.test_connection}.should raise_error

data/spec/adapters/oracle_spec.rb

@@ -1,17 +1,35 @@
 require File.join(File.dirname(__FILE__), '../../lib/sequel_core')
 
-ORACLE_DB = Sequel('oracle://hr:hr@loalhost/XE')
-if ORACLE_DB.table_exists?(:test)
-  ORACLE_DB.drop_table :test
+ORACLE_DB = Sequel('oracle://hr:hr@localhost/XE')
+
+if ORACLE_DB.table_exists?(:items)
+  ORACLE_DB.drop_table :items
 end
-ORACLE_DB.create_table :test do
-  text :name
-  integer :value
+ORACLE_DB.create_table :items do
+  varchar2 :name, :size => 50
+  number :value, :size => 38
   
   index :value
 end
 
-context "A Oracle database" do
+if ORACLE_DB.table_exists?(:books)
+  ORACLE_DB.drop_table :books
+end
+ORACLE_DB.create_table :books do
+  number :id, :size => 38
+  varchar2 :title, :size => 50
+  number :category_id, :size => 38
+end
+
+if ORACLE_DB.table_exists?(:categories)
+  ORACLE_DB.drop_table :categories
+end
+ORACLE_DB.create_table :categories do
+  number :id, :size => 38
+  varchar2 :cat_name, :size => 50
+end
+
+context "An Oracle database" do
   specify "should provide disconnect functionality" do
     ORACLE_DB.execute("select user from dual")
     ORACLE_DB.pool.size.should == 1
@@ -20,9 +38,9 @@ context "A Oracle database" do
   end
 end
 
-context "A Oracle dataset" do
+context "An Oracle dataset" do
   setup do
-    @d = ORACLE_DB[:test]
+    @d = ORACLE_DB[:items]
     @d.delete # remove all records
   end
   
@@ -45,6 +63,83 @@ context "A Oracle dataset" do
       {:name => 'abc', :value => 456},
       {:name => 'def', :value => 789}
     ]
+
+    @d.select(:name).uniq.order_by(:name).to_a.should == [
+      {:name => 'abc'},
+      {:name => 'def'}
+    ]
+           
+    @d.order(:value.DESC).limit(1).to_a.should == [
+      {:name => 'def', :value => 789}                                        
+    ]
+
+    @d.filter(:name => 'abc').to_a.should == [
+      {:name => 'abc', :value => 123},
+      {:name => 'abc', :value => 456} 
+    ]
+    
+    @d.order(:value.DESC).filter(:name => 'abc').to_a.should == [
+      {:name => 'abc', :value => 456},
+      {:name => 'abc', :value => 123} 
+    ]
+
+    @d.filter(:name => 'abc').limit(1).to_a.should == [
+      {:name => 'abc', :value => 123}                                        
+    ]
+        
+    @d.filter(:name => 'abc').order(:value.DESC).limit(1).to_a.should == [
+      {:name => 'abc', :value => 456}                                        
+    ]
+    
+    @d.filter(:name => 'abc').order(:value).limit(1).to_a.should == [
+      {:name => 'abc', :value => 123}                                        
+    ]
+        
+    @d.order(:value).limit(1).to_a.should == [
+      {:name => 'abc', :value => 123}                                        
+    ]
+
+    @d.order(:value).limit(1, 1).to_a.should == [
+      {:name => 'abc', :value => 456}
+    ]
+
+    @d.order(:value).limit(1, 2).to_a.should == [
+      {:name => 'def', :value => 789}
+    ]    
+    
+    @d.avg(:value).to_i.should == (789+123+456)/3
+    
+    @d.max(:value).to_i.should == 789
+    
+    @d.select(:name, :AVG[:value]).filter(:name => 'abc').group(:name).to_a.should == [
+      {:name => 'abc', :"avg(value)" => (456+123)/2.0}
+    ]
+
+    @d.select(:AVG[:value]).group(:name).order(:name).limit(1).to_a.should == [
+      {:"avg(value)" => (456+123)/2.0}
+    ]
+        
+    @d.select(:name, :AVG[:value]).group(:name).order(:name).to_a.should == [
+      {:name => 'abc', :"avg(value)" => (456+123)/2.0},
+      {:name => 'def', :"avg(value)" => 789*1.0}
+    ]
+    
+    @d.select(:name, :AVG[:value]).group(:name).order(:name).to_a.should == [
+      {:name => 'abc', :"avg(value)" => (456+123)/2.0},
+      {:name => 'def', :"avg(value)" => 789*1.0}
+    ]
+
+    @d.select(:name, :AVG[:value]).group(:name).having(:name => ['abc', 'def']).order(:name).to_a.should == [
+      {:name => 'abc', :"avg(value)" => (456+123)/2.0},
+      {:name => 'def', :"avg(value)" => 789*1.0}
+    ]
+    
+    @d.select(:name, :value).filter(:name => 'abc').union(@d.select(:name, :value).filter(:name => 'def')).order(:value).to_a.should == [
+      {:name => 'abc', :value => 123},
+      {:name => 'abc', :value => 456},
+      {:name => 'def', :value => 789}
+    ]
+     
   end
   
   specify "should update records correctly" do
@@ -83,9 +178,51 @@ context "A Oracle dataset" do
   end
 end
 
-context "A Oracle dataset in array tuples mode" do
+context "Joined Oracle dataset" do
+  setup do
+    @d1 = ORACLE_DB[:books]
+    @d1.delete # remove all records
+    @d1 << {:id => 1, :title => 'aaa', :category_id => 100}
+    @d1 << {:id => 2, :title => 'bbb', :category_id => 100}
+    @d1 << {:id => 3, :title => 'ccc', :category_id => 101}
+    @d1 << {:id => 4, :title => 'ddd', :category_id => 102}
+    
+    @d2 = ORACLE_DB[:categories]
+    @d2.delete # remove all records
+    @d2 << {:id => 100, :cat_name => 'ruby'}
+    @d2 << {:id => 101, :cat_name => 'rails'}
+  end
+  
+  specify "should return correct result" do
+    @d1.join(:categories, :id => :category_id).select(:books__id, :title, :cat_name).order(:books__id).to_a.should == [
+      {:id => 1, :title => 'aaa', :cat_name => 'ruby'},
+      {:id => 2, :title => 'bbb', :cat_name => 'ruby'},
+      {:id => 3, :title => 'ccc', :cat_name => 'rails'}
+    ]
+
+    @d1.join(:categories, :id => :category_id).select(:books__id, :title, :cat_name).order(:books__id).limit(2, 1).to_a.should == [
+      {:id => 2, :title => 'bbb', :cat_name => 'ruby'},
+      {:id => 3, :title => 'ccc', :cat_name => 'rails'},
+    ]
+   
+    @d1.left_outer_join(:categories, :id => :category_id).select(:books__id, :title, :cat_name).order(:books__id).to_a.should == [
+      {:id => 1, :title => 'aaa', :cat_name => 'ruby'},
+      {:id => 2, :title => 'bbb', :cat_name => 'ruby'},
+      {:id => 3, :title => 'ccc', :cat_name => 'rails'},
+      {:id => 4, :title => 'ddd', :cat_name => nil} 
+    ]
+    
+    @d1.left_outer_join(:categories, :id => :category_id).select(:books__id, :title, :cat_name).order(:books__id.DESC).limit(2, 0).to_a.should == [      
+      {:id => 4, :title => 'ddd', :cat_name => nil}, 
+      {:id => 3, :title => 'ccc', :cat_name => 'rails'}
+    ]      
+  end  
+end
+
+
+context "An Oracle dataset in array tuples mode" do
   setup do
-    @d = ORACLE_DB[:test]
+    @d = ORACLE_DB[:items]
     @d.delete # remove all records
     Sequel.use_array_tuples
   end
@@ -105,6 +242,15 @@ context "A Oracle dataset in array tuples mode" do
       ['abc', 456],
       ['def', 789]
     ]
+
+    @d.order(:value).select(:name, :value).limit(1).to_a.should == [
+      ['abc',123]                                                               
+    ]                                                                                                                  
+
+    @d.order(:value).select(:name, :value).limit(2,1).to_a.should == [
+      ['abc',456],                                                               
+      ['def',789]
+    ]
   end
   
   specify "should work correctly with transforms" do