sequel_core 1.0.10 → 1.1

data/CHANGELOG

@@ -1,3 +1,21 @@
+=== 1.1 (2008-02-15)
+
+* Fixed Dataset#join_table to support joining of datasets (#156).
+
+* Changed Dataset#empty? to use EXISTS condition instead of counting records, for much better performance (#158).
+
+* Implemented insertion of multiple records in a single statement for postgres adapter. This feature is available only in postgres 8.2 and newer.
+
+* Implemented Postgres::Database#server_version.
+
+* Implemented Database#get, short for dataset.get(...).
+
+* Refactored Dataset#multi_insert, added #import alias, added support for calling #multi_insert using array of columns and array of value arrays (thanks David Lee).
+
+* Implemented Dataset#get, a replacement for select(column).first[column].
+
+* Implemented Dataset#grep method, poor man's text search.
+
 === 1.0.10 (2008-02-13)
 
 * Fixed Datset#group_and_count to work inside a query block (#152).

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel_core"
-VERS = "1.0.10"
+VERS = "1.1"
 CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
 RDOC_OPTS = [
   "--quiet", 

data/lib/sequel_core/adapters/mysql.rb

@@ -358,33 +358,10 @@ module Sequel
         self
       end
       
-      def multi_insert_sql(keys, array)
-        values = array.map {|r| "(#{literal(keys.map {|k| r[k]})})"}.join(COMMA_SEPARATOR)
-        columns = keys.map {|c| literal(c)}.join(COMMA_SEPARATOR)
-        "INSERT INTO #{@opts[:from]} (#{columns}) VALUES #{values}"
-      end
-      
-      # Inserts multiple records into the associated table. This method can be
-      # to efficiently insert a large amounts of records into a table. Inserts
-      # are automatically wrapped in a transaction. If the :commit_every 
-      # option is specified, the method will generate a separate transaction 
-      # for each batch of records, e.g.:
-      #
-      #   dataset.multi_insert(list, :commit_every => 1000)
-      def multi_insert(list, opts = {})
-        keys = list.first.keys
-        
-        if every = (opts[:commit_every] || opts[:slice])
-          list.each_slice(every) do |s|
-            @db.transaction do
-              @db.execute(multi_insert_sql(keys, s))
-            end
-          end
-        else
-          @db.transaction do
-            @db.execute(multi_insert_sql(keys, list))
-          end
-        end
+      def multi_insert_sql(columns, values)
+        columns = literal(columns)
+        values = values.map {|r| "(#{literal(r)})"}.join(COMMA_SEPARATOR)
+        ["INSERT INTO #{@opts[:from]} (#{columns}) VALUES #{values}"]
       end
     end
   end

data/lib/sequel_core/adapters/postgres.rb

@@ -263,6 +263,17 @@ module Sequel
         end
       end
       
+      def server_version
+        @server_version ||= pool.hold do |conn|
+          if conn.respond_to?(:server_version)
+            pool.hold {|c| c.server_version}
+          else
+            get(:version[]) =~ /PostgreSQL (\d+)\.(\d+)\.(\d+)/
+            ($1.to_i * 10000) + ($2.to_i * 100) + $3.to_i
+          end
+        end
+      end
+      
       def execute_insert(sql, table, values)
         @logger.info(sql) if @logger
         @pool.hold do |conn|
@@ -428,7 +439,16 @@ module Sequel
           end
         end
       end
-  
+      
+      def multi_insert_sql(columns, values)
+        return super if @db.server_version < 80200
+        
+        # postgresql 8.2 introduces support for insert
+        columns = literal(columns)
+        values = values.map {|r| "(#{literal(r)})"}.join(COMMA_SEPARATOR)
+        ["INSERT INTO #{@opts[:from]} (#{columns}) VALUES #{values}"]
+      end
+
       def insert(*values)
         @db.execute_insert(insert_sql(*values), @opts[:from],
           values.size == 1 ? values.first : values)

data/lib/sequel_core/database.rb

@@ -135,6 +135,17 @@ module Sequel
       (String === args.first) ? fetch(*args) : from(*args)
     end
     
+    # Returns a single value from the database, e.g.:
+    #
+    #   # SELECT 1
+    #   DB.get(1) #=> 1 
+    #
+    #   # SELECT version()
+    #   DB.get(:version[]) #=> ...
+    def get(expr)
+      dataset.get(expr)
+    end
+    
     # Raises a Sequel::Error::NotImplemented. This method is overriden in descendants.
     def execute(sql)
       raise NotImplementedError, "#execute should be overriden by adapters"

data/lib/sequel_core/dataset/convenience.rb

@@ -8,9 +8,10 @@ module Sequel
         each {|a| block[a.to_hash]}
       end
       
-      # Returns true if the record count is 0
+      # Returns true if no records exists in the dataset
       def empty?
-        count == 0
+        db.dataset.where(exists).get(1) == nil
+        # count == 0
       end
       
       # Returns the first record in the dataset.
@@ -29,6 +30,10 @@ module Sequel
         each(opts) {|r| @columns = nil; return r.values.first}
         nil
       end
+      
+      def get(column)
+        select(column).single_value
+      end
 
       # Returns the first record in the dataset. If the num argument is specified,
       # an array is returned with the first <i>num</i> records.
@@ -217,29 +222,49 @@ module Sequel
         records.each {|r| csv << "#{r.join(COMMA_SEPARATOR)}\r\n"}
         csv
       end
-
+      
       # Inserts multiple records into the associated table. This method can be
       # to efficiently insert a large amounts of records into a table. Inserts
-      # are automatically wrapped in a transaction. If the :commit_every 
-      # or :slice option is specified, the method will generate a separate 
-      # transaction for each batch of records, e.g.:
+      # are automatically wrapped in a transaction.
+      # 
+      # This method can be called either with an array of hashes:
+      # 
+      #   dataset.multi_insert({:x => 1}, {:x => 2})
       #
-      #   dataset.multi_insert(list, :commit_every => 1000)
-      def multi_insert(list, opts = {})
-        if every = (opts[:commit_every] || opts[:slice])
-          list.each_slice(every) do |s|
-            @db.transaction do
-              s.each {|r| @db.execute(insert_sql(r))}
-              # @db.execute(s.map {|r| insert_sql(r)}.join)
-            end
-          end
+      # Or with a columns array and an array of value arrays:
+      #
+      #   dataset.multi_insert([:x, :y], [[1, 2], [3, 4]])
+      #
+      # The method also accepts a :slice or :commit_every option that specifies
+      # the number of records to insert per transaction. This is useful especially
+      # when inserting a large number of records, e.g.:
+      #
+      #   # this will commit every 50 records
+      #   dataset.multi_insert(lots_of_records, :slice => 50)
+      def multi_insert(*args)
+        if args[0].is_a?(Array) && args[1].is_a?(Array)
+          columns, values, opts = *args
         else
-          @db.transaction do
-            # @db.execute(list.map {|r| insert_sql(r)}.join)
-            list.each {|r| @db.execute(insert_sql(r))}
+          # we assume that an array of hashes is given
+          hashes, opts = *args
+          columns = hashes.first.keys
+          # convert the hashes into arrays
+          values = hashes.map {|h| columns.map {|c| h[c]}}
+        end
+        
+        slice_size = opts && (opts[:commit_every] || opts[:slice])
+        
+        if slice_size
+          values.each_slice(slice_size) do |slice|
+            statements = multi_insert_sql(columns, slice)
+            @db.transaction {statements.each {|st| @db.execute(st)}}
           end
+        else
+          statements = multi_insert_sql(columns, values)
+          @db.transaction {statements.each {|st| @db.execute(st)}}
         end
       end
+      alias_method :import, :multi_insert
       
       module QueryBlockCopy #:nodoc:
         def each(*args); raise Error, "#each cannot be invoked inside a query block."; end

data/lib/sequel_core/dataset/sql.rb

@@ -18,7 +18,9 @@ module Sequel
         if s =~ QUALIFIED_REGEXP
           return column
         else
-          if (table =~ ALIASED_REGEXP)
+          if table.is_a?(Dataset)
+            table = :t1
+          elsif (table =~ ALIASED_REGEXP)
             table = $2
           end
           Sequel::SQL::QualifiedColumnRef.new(table, column)
@@ -341,6 +343,14 @@ module Sequel
           filter(*cond, &block)
         end
       end
+      
+      def grep(cols, terms)
+        conds = [];
+        cols = [cols] unless cols.is_a?(Array)
+        terms = [terms] unless terms.is_a?(Array)
+        cols.each {|c| terms.each {|t| conds << match_expr(c, t)}}
+        filter(conds.join(' OR '))
+      end
 
       # Adds a UNION clause using a second dataset object. If all is true the
       # clause used is UNION ALL, which may return duplicate rows.
@@ -380,6 +390,9 @@ module Sequel
           v = qualified_column_name(v, @opts[:last_joined_table] || first_source) if v.is_a?(Symbol)
           join_conditions[k] = v
         end
+        if table.is_a?(Dataset)
+          table = "(#{table.sql}) t1"
+        end
         " #{join_type} #{table} ON #{expression_list(join_conditions)}"
       end
 
@@ -524,6 +537,19 @@ module Sequel
           end
         end
       end
+      
+      # Returns an array of insert statements for inserting multiple records.
+      # This method is used by #multi_insert to format insert statements and
+      # expects a keys array and and an array of value arrays.
+      #
+      # This method may be overriden by descendants.
+      def multi_insert_sql(columns, values)
+        table = @opts[:from]
+        columns = literal(columns)
+        values.map do |r|
+          "INSERT INTO #{table} (#{columns}) VALUES (#{literal(r)})"
+        end
+      end
 
       # Formats an UPDATE statement using the given values.
       #
@@ -600,9 +626,10 @@ module Sequel
 
       # Returns an EXISTS clause for the dataset.
       #
-      #   dataset.exists #=> "EXISTS (SELECT 1 FROM items)"
+      #   DB.select(1).where(DB[:items].exists).sql
+      #   #=> "SELECT 1 WHERE EXISTS (SELECT * FROM items)"
       def exists(opts = nil)
-        "EXISTS (#{sql({:select => [1]}.merge(opts || {}))})"
+        "EXISTS (#{select_sql(opts)})"
       end
 
       # If given an integer, the dataset will contain only the first l results.

data/spec/adapters/mysql_spec.rb

@@ -537,4 +537,19 @@ context "MySQL::Dataset#multi_insert" do
       {:name => nil, :value => 4}
     ]
   end
+  
+  specify "should support inserting using columns and values arrays" do
+    @d.multi_insert([:name, :value], [['abc', 1], ['def', 2]])
+
+    MYSQL_DB.sqls.should == [
+      'BEGIN',
+      "INSERT INTO items (`name`, `value`) VALUES ('abc', 1), ('def', 2)",
+      'COMMIT'
+    ]
+    
+    @d.all.should == [
+      {:name => 'abc', :value => 1}, 
+      {:name => 'def', :value => 2}
+    ]
+  end
 end

data/spec/adapters/postgres_spec.rb

@@ -24,6 +24,10 @@ context "A PostgreSQL database" do
     @db.disconnect
     @db.pool.size.should == 0
   end
+  
+  specify "should provide the server version" do
+    @db.server_version.should > 70000
+  end
 end
 
 context "A PostgreSQL dataset" do
@@ -246,7 +250,7 @@ context "A PostgreSQL database" do
   end
 end  
 
-context "A PostgreSSQL database" do
+context "A PostgreSQL database" do
   setup do
   end
   
@@ -284,4 +288,33 @@ context "A PostgreSSQL database" do
     PGSQL_DB[:posts].full_text_search(:title, 'ruby', :language => 'french').sql.should ==
       "SELECT * FROM posts WHERE (to_tsvector('french', \"title\") @@ to_tsquery('french', 'ruby'))"
   end
+end
+
+context "Postgres::Dataset#multi_insert_sql / #import" do
+  setup do
+    @ds = PGSQL_DB[:test]
+  end
+  
+  specify "should return separate insert statements if server_version < 80200" do
+    @ds.db.meta_def(:server_version) {80199}
+    
+    @ds.multi_insert_sql([:x, :y], [[1, 2], [3, 4]]).should == [
+      'INSERT INTO test ("x", "y") VALUES (1, 2)',
+      'INSERT INTO test ("x", "y") VALUES (3, 4)'
+    ]
+  end
+  
+  specify "should a single insert statement if server_version >= 80200" do
+    @ds.db.meta_def(:server_version) {80200}
+    
+    @ds.multi_insert_sql([:x, :y], [[1, 2], [3, 4]]).should == [
+      'INSERT INTO test ("x", "y") VALUES (1, 2), (3, 4)'
+    ]
+
+    @ds.db.meta_def(:server_version) {80201}
+    
+    @ds.multi_insert_sql([:x, :y], [[1, 2], [3, 4]]).should == [
+      'INSERT INTO test ("x", "y") VALUES (1, 2), (3, 4)'
+    ]
+  end
 end

data/spec/database_spec.rb

@@ -846,4 +846,26 @@ context "Database#inspect" do
   specify "should include the class name and the connection url" do
     @db.inspect.should == '#<DummyDatabase: "blah://blahblah/blah">'
   end
+end
+
+context "Database#get" do
+  setup do
+    @c = Class.new(DummyDatabase) do
+      def dataset
+        ds = super
+        ds.meta_def(:get) {|c| @db.execute select(c).sql; c}
+        ds
+      end
+    end
+    
+    @db = @c.new
+  end
+  
+  specify "should use Dataset#get to get a single value" do
+    @db.get(1).should == 1
+    @db.sqls.last.should == 'SELECT 1'
+    
+    @db.get(:version[])
+    @db.sqls.last.should == 'SELECT version()'
+  end
 end

data/spec/dataset_spec.rb

@@ -342,7 +342,7 @@ context "Dataset#where" do
   specify "should accept a subquery for an EXISTS clause" do
     a = @dataset.filter {:price < 100}
     @dataset.filter(a.exists).sql.should ==
-      'SELECT * FROM test WHERE EXISTS (SELECT 1 FROM test WHERE (price < 100))'
+      'SELECT * FROM test WHERE EXISTS (SELECT * FROM test WHERE (price < 100))'
   end
   
   specify "should accept proc expressions" do
@@ -1048,22 +1048,34 @@ context "Dataset#group_and_count" do
 end
 
 context "Dataset#empty?" do
-  specify "should return true if #count == 0" do
-    @c = Class.new(Sequel::Dataset) do
-      def count
-        0
+  specify "should return true if records exist in the dataset" do
+    @db = Sequel::Database.new
+    @db.meta_def(:execute) {|sql| puts "blah";@sqls ||=[]; @sqls << sql}
+    @db.meta_def(:sqls) {@sqls ||= []}
+    
+    $cccc = Class.new(Sequel::Dataset) do
+      def fetch_rows(sql)
+        @db.execute(sql)
+        yield(:x => 'blah')
       end
     end
-    @dataset = @c.new(nil).from(:test)
-    @dataset.empty?.should be_true
-
-    @c = Class.new(Sequel::Dataset) do
-      def count
-        1
-      end
+    
+    @db.meta_def(:dataset) do
+      $cccc.new(self)
     end
-    @dataset = @c.new(nil).from(:test)
-    @dataset.empty?.should be_false
+    
+    @dataset = Sequel::Dataset.new(@db).from(:test)
+    
+    @dataset.should_not be_empty
+    @db.sqls.last.should == 'SELECT 1 WHERE EXISTS (SELECT * FROM test)'
+    
+    @db.meta_def(:dataset) do
+      ds = $cccc.new(self)
+      ds.meta_def(:get) {|c| nil}
+      ds
+    end
+
+    @dataset.should be_empty
   end
 end
 
@@ -1170,6 +1182,17 @@ context "Dataset#join_table" do
       should raise_error(Sequel::Error)
   end
 
+  specify "should support joining datasets" do
+    ds = Sequel::Dataset.new(nil).from(:categories)
+    
+    @d.join_table(:left_outer, ds, :item_id => :id).sql.should ==
+      'SELECT * FROM items LEFT OUTER JOIN (SELECT * FROM categories) t1 ON (t1.item_id = items.id)'
+      
+    ds.filter!(:active => true)
+
+    @d.join_table(:left_outer, ds, :item_id => :id).sql.should ==
+      'SELECT * FROM items LEFT OUTER JOIN (SELECT * FROM categories WHERE (active = \'t\')) t1 ON (t1.item_id = items.id)'
+  end
 end
 
 context "Dataset#[]=" do
@@ -1575,7 +1598,34 @@ context "Dataset#single_value" do
   specify "should return nil" do
     @e.single_value.should be_nil
   end
+end
 
+context "Dataset#get" do
+  setup do
+    @c = Class.new(Sequel::Dataset) do
+      attr_reader :last_sql
+      
+      def fetch_rows(sql)
+        @last_sql = sql
+        yield(:name => sql)
+      end
+    end
+    
+    @d = @c.new(nil).from(:test)
+  end
+  
+  specify "should select the specified column and fetch its value" do
+    @d.get(:name).should == "SELECT name FROM test"
+    @d.get(:abc).should == "SELECT abc FROM test" # the first available value is returned always
+  end
+  
+  specify "should work with filters" do
+    @d.filter(:id => 1).get(:name).should == "SELECT name FROM test WHERE (id = 1)"
+  end
+  
+  specify "should work with aliased fields" do
+    @d.get(:x__b.as(:name)).should == "SELECT x.b AS name FROM test"
+  end
 end
 
 context "Dataset#set_row_proc" do
@@ -2085,6 +2135,42 @@ context "Dataset#multi_insert" do
       'COMMIT'
     ]
   end
+  
+  specify "should accept a columns array and a values array" do
+    @ds.multi_insert([:x, :y], [[1, 2], [3, 4]])
+    @db.sqls.should == [
+      'BEGIN',
+      "INSERT INTO items (x, y) VALUES (1, 2)",
+      "INSERT INTO items (x, y) VALUES (3, 4)",
+      'COMMIT'
+    ]
+  end
+
+  specify "should accept a columns array and a values array with slice option" do
+    @ds.multi_insert([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice => 2)
+    @db.sqls.should == [
+      'BEGIN',
+      "INSERT INTO items (x, y) VALUES (1, 2)",
+      "INSERT INTO items (x, y) VALUES (3, 4)",
+      'COMMIT',
+      'BEGIN',
+      "INSERT INTO items (x, y) VALUES (5, 6)",
+      'COMMIT'
+    ]
+  end
+  
+  specify "should be aliased by #import" do
+    @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice => 2)
+    @db.sqls.should == [
+      'BEGIN',
+      "INSERT INTO items (x, y) VALUES (1, 2)",
+      "INSERT INTO items (x, y) VALUES (3, 4)",
+      'COMMIT',
+      'BEGIN',
+      "INSERT INTO items (x, y) VALUES (5, 6)",
+      'COMMIT'
+    ]
+  end
 end
 
 context "Dataset#query" do
@@ -2698,3 +2784,48 @@ context "Dataset#all" do
     a.should == [1, 3, "SELECT * FROM items"]
   end
 end
+
+context "Dataset#grep" do
+  setup do
+    @ds = Sequel::Dataset.new(nil).from(:posts)
+  end
+  
+  specify "should format a SQL filter correctly" do
+    @ds.grep(:title, 'ruby').sql.should ==
+      "SELECT * FROM posts WHERE (title LIKE 'ruby')"
+  end
+
+  specify "should support multiple columns" do
+    @ds.grep([:title, :body], 'ruby').sql.should ==
+      "SELECT * FROM posts WHERE ((title LIKE 'ruby') OR (body LIKE 'ruby'))"
+  end
+  
+  specify "should support multiple search terms" do
+    @ds.grep(:title, ['abc', 'def']).sql.should == 
+      "SELECT * FROM posts WHERE ((title LIKE 'abc') OR (title LIKE 'def'))"
+  end
+  
+  specify "should support multiple columns and search terms" do
+    @ds.grep([:title, :body], ['abc', 'def']).sql.should ==
+      "SELECT * FROM posts WHERE ((title LIKE 'abc') OR (title LIKE 'def') OR (body LIKE 'abc') OR (body LIKE 'def'))"
+  end
+  
+  specify "should support regexps if the dataset allows it" do
+    @ds.meta_def(:match_expr) do |l, r|
+      case r
+      when String
+        "(#{literal(l)} LIKE #{literal(r)})"
+      when Regexp
+        "(#{literal(l)} =~ #{literal(r.source)})"
+      else
+        raise Sequel::Error, "Unsupported match pattern class (#{r.class})."
+      end
+    end
+    
+    @ds.grep(:title, /ruby/).sql.should ==
+      "SELECT * FROM posts WHERE (title =~ 'ruby')"
+
+    @ds.grep(:title, [/^ruby/, 'ruby']).sql.should ==
+      "SELECT * FROM posts WHERE ((title =~ '^ruby') OR (title LIKE 'ruby'))"
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_core
 version: !ruby/object:Gem::Version 
-  version: 1.0.10
+  version: "1.1"
 platform: ruby
 authors: 
 - Sharon Rosner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-02-14 00:00:00 +02:00
+date: 2008-02-15 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency