sequel_core 1.0.7 → 1.0.8

data/CHANGELOG

@@ -1,3 +1,11 @@
+=== 1.0.8 (2008-02-08)
+
+* Added support for multiple choices in string matching expressions (#147).
+
+* Renamed Dataset#clone_merge to Dataset#clone, works with or without options for merging (#148).
+
+* Fixed MySQL::Database#<< method to always free the result in order to allow multiple calls in a row (#149). Same also for PostgreSQL adapter.
+
 === 1.0.7 (2008-02-05)
 
 * Added support for conditional filters (using if else statements) inside block filters (thanks Kee).

data/Rakefile

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

data/lib/sequel_core/adapters/adapter_skeleton.rb

@@ -16,7 +16,7 @@ module Sequel
       def dataset(opts = nil)
         Adapter::Dataset.new(self, opts)
       end
-    
+      
       def execute(sql)
         @logger.info(sql) if @logger
         @pool.hold {|conn| conn.exec(sql)}

data/lib/sequel_core/adapters/mysql.rb

@@ -119,34 +119,22 @@ module Sequel
         MySQL::Dataset.new(self, opts)
       end
 
-      def execute(sql)
+      def execute(sql, &block)
         @logger.info(sql) if @logger
         @pool.hold do |conn|
           conn.query(sql)
+          block[conn] if block
         end
       end
 
-      def execute_select(sql)
-        @logger.info(sql) if @logger
-        @pool.hold do |conn|
-          conn.query(sql)
-          conn.use_result
-        end
-      end
-
-      def execute_insert(sql)
-        @logger.info(sql) if @logger
-        @pool.hold do |conn|
-          conn.query(sql)
-          conn.insert_id
-        end
-      end
-
-      def execute_affected(sql)
-        @logger.info(sql) if @logger
-        @pool.hold do |conn|
-          conn.query(sql)
-          conn.affected_rows
+      def execute_select(sql, &block)
+        execute(sql) do |c|
+          r = c.use_result
+          begin
+            block[r]
+          ensure
+            r.free
+          end
         end
       end
 
@@ -327,39 +315,29 @@ module Sequel
       end
 
       def insert(*values)
-        @db.execute_insert(insert_sql(*values))
+        @db.execute(insert_sql(*values)) {|c| c.insert_id}
       end
 
       def update(*args, &block)
-        @db.execute_affected(update_sql(*args, &block))
+        @db.execute(update_sql(*args, &block)) {|c| c.affected_rows}
       end
 
       def delete(opts = nil)
-        @db.execute_affected(delete_sql(opts))
+        @db.execute(delete_sql(opts)) {|c| c.affected_rows}
       end
 
       def fetch_rows(sql)
-        @db.synchronize do
-          r = @db.execute_select(sql)
-          begin
-            @columns = r.columns
-            r.each_hash {|row| yield row}
-          ensure
-            r.free
-          end
+        @db.execute_select(sql) do |r|
+          @columns = r.columns
+          r.each_hash {|row| yield row}
         end
         self
       end
 
       def array_tuples_fetch_rows(sql, &block)
-        @db.synchronize do
-          r = @db.execute_select(sql)
-          begin
-            @columns = r.columns
-            r.each_array(&block)
-          ensure
-            r.free
-          end
+        @db.execute_select(sql) do |r|
+          @columns = r.columns
+          r.each_array(&block)
         end
         self
       end

data/lib/sequel_core/adapters/odbc_mssql.rb

@@ -16,7 +16,7 @@ module Sequel
       class Dataset < ODBC::Dataset
         # Allows you to do .nolock on a query
         def nolock
-          clone_merge(:with => "(NOLOCK)")
+          clone(:with => "(NOLOCK)")
         end
 
         # Formats a SELECT statement using the given options and the dataset

data/lib/sequel_core/adapters/postgres.rb

@@ -47,17 +47,23 @@ class PGconn
     alias_method :async_exec, :exec
   end
   
-  def execute(sql)
+  def execute(sql, &block)
+    q = nil
     begin
-      async_exec(sql)
+      q = async_exec(sql)
     rescue PGError => e
       unless connected?
         reset
-        async_exec(sql)
+        q = async_exec(sql)
       else
         raise e
       end
     end
+    begin
+      block ? block[q] : q.cmdtuples
+    ensure
+      q.clear
+    end
   end
   
   attr_accessor :transaction_in_progress
@@ -218,22 +224,14 @@ module Sequel
           filter("pg_class.relfilenode=pg_locks.relation")
       end
     
-      def execute(sql)
+      def execute(sql, &block)
         @logger.info(sql) if @logger
-        @pool.hold {|conn| conn.execute(sql)}
+        @pool.hold {|conn| conn.execute(sql, &block)}
       rescue => e
         @logger.error(e.message) if @logger
         raise e
       end
     
-      def execute_and_forget(sql)
-        @logger.info(sql) if @logger
-        @pool.hold {|conn| conn.execute(sql).clear}
-      rescue => e
-        @logger.error(e.message) if @logger
-        raise e
-      end
-      
       def primary_key_for_table(conn, table)
         @primary_keys ||= {}
         @primary_keys[table] ||= conn.primary_key(table)
@@ -268,7 +266,7 @@ module Sequel
       def execute_insert(sql, table, values)
         @logger.info(sql) if @logger
         @pool.hold do |conn|
-          conn.execute(sql).clear
+          conn.execute(sql)
           insert_result(conn, table, values)
         end
       rescue => e
@@ -276,10 +274,6 @@ module Sequel
         raise e
       end
     
-      def synchronize(&block)
-        @pool.hold(&block)
-      end
-      
       SQL_BEGIN = 'BEGIN'.freeze
       SQL_COMMIT = 'COMMIT'.freeze
       SQL_ROLLBACK = 'ROLLBACK'.freeze
@@ -363,11 +357,11 @@ module Sequel
       end
     
       def for_update
-        clone_merge(:lock => :update)
+        clone(:lock => :update)
       end
     
       def for_share
-        clone_merge(:lock => :share)
+        clone(:lock => :share)
       end
     
       EXPLAIN = 'EXPLAIN '.freeze
@@ -406,9 +400,9 @@ module Sequel
         sql = LOCK % [@opts[:from], mode]
         @db.synchronize do
           if block # perform locking inside a transaction and yield to block
-            @db.transaction {@db.execute_and_forget(sql); yield}
+            @db.transaction {@db.execute(sql); yield}
           else
-            @db.execute_and_forget(sql) # lock without a transaction
+            @db.execute(sql) # lock without a transaction
             self
           end
         end
@@ -420,38 +414,17 @@ module Sequel
       end
     
       def update(*args, &block)
-        @db.synchronize do
-          result = @db.execute(update_sql(*args, &block))
-          begin
-            affected = result.cmdtuples
-          ensure
-            result.clear
-          end
-          affected
-        end
+        @db.execute(update_sql(*args, &block))
       end
     
       def delete(opts = nil)
-        @db.synchronize do
-          result = @db.execute(delete_sql(opts))
-          begin
-            affected = result.cmdtuples
-          ensure
-            result.clear
-          end
-          affected
-        end
+        @db.execute(delete_sql(opts))
       end
       
       def fetch_rows(sql, &block)
-        @db.synchronize do
-          result = @db.execute(sql)
-          begin
-            conv = row_converter(result)
-            result.each {|r| yield conv[r]}
-          ensure
-            result.clear
-          end
+        @db.execute(sql) do |q|
+          conv = row_converter(q)
+          q.each {|r| yield conv[r]}
         end
       end
       
@@ -489,14 +462,9 @@ module Sequel
       end
 
       def array_tuples_fetch_rows(sql, &block)
-        @db.synchronize do
-          result = @db.execute(sql)
-          begin
-            conv = array_tuples_row_converter(result)
-            result.each {|r| yield conv[r]}
-          ensure
-            result.clear
-          end
+        @db.execute(sql) do |q|
+          conv = array_tuples_row_converter(q)
+          q.each {|r| yield conv[r]}
         end
       end
       

data/lib/sequel_core/database.rb

@@ -134,7 +134,7 @@ module Sequel
     def [](*args)
       (String === args.first) ? fetch(*args) : from(*args)
     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.rb

@@ -91,12 +91,13 @@ module Sequel
       @transform = nil
     end
     
-    # Returns a new instance of the dataset with with the give options merged.
-    def clone_merge(opts)
-      new_dataset = clone
-      new_dataset.set_options(@opts.merge(opts))
-      new_dataset
+    # Returns a new clone of the dataset with with the given options merged.
+    def clone(opts = {})
+      c = super()
+      c.set_options @opts.merge(opts)
+      c
     end
+    alias_method :clone_merge, :clone # should be deprecated in the next major release.
     
     def set_options(opts) #:nodoc:
       @opts = opts
@@ -178,7 +179,7 @@ module Sequel
     # Returns a naked dataset clone - i.e. a dataset that returns records as
     # hashes rather than model objects.
     def naked
-      d = clone_merge(:naked => true, :models => nil, :polymorphic_key => nil)
+      d = clone(:naked => true, :models => nil, :polymorphic_key => nil)
       d.set_model(nil)
       d
     end

data/lib/sequel_core/dataset/convenience.rb

@@ -74,7 +74,7 @@ module Sequel
           if args == 1
             single_record(opts)
           else
-            clone_merge(opts).all
+            clone(opts).all
           end
         else
           filter(args).last(1)
@@ -247,7 +247,7 @@ module Sequel
         def update(*args); raise Error, "#update cannot be invoked inside a query block."; end
         def delete(*args); raise Error, "#delete cannot be invoked inside a query block."; end
         
-        def clone_merge(opts)
+        def clone(opts)
           @opts.merge!(opts)
         end
       end
@@ -262,10 +262,10 @@ module Sequel
       #   end
       #
       def query(&block)
-        copy = clone_merge({})
+        copy = clone({})
         copy.extend(QueryBlockCopy)
         copy.instance_eval(&block)
-        clone_merge(copy.opts)
+        clone(copy.opts)
       end
       
       MUTATION_RE = /^(.+)!$/.freeze

data/lib/sequel_core/dataset/sequelizer.rb

@@ -49,12 +49,22 @@ class Sequel::Dataset
       when NilClass
         "(#{literal(l)} IS NULL)"
       when Regexp
-        match_expr(l, r)
+        collate_match_expr(l, r)
       else
         "(#{literal(l)} = #{literal(r)})"
       end
     end
     
+    # Formats a string matching expression with support for multiple choices. 
+    # For more information see #match_expr.
+    def collate_match_expr(l, r)
+      if r.is_a?(Array)
+        "(#{r.map {|i| match_expr(l, i)}.join(' OR ')})"
+      else
+        match_expr(l, r)
+      end
+    end
+    
     # Formats a string matching expression. The stock implementation supports
     # matching against strings only using the LIKE operator. Specific adapters
     # can override this method to provide support for regular expressions.
@@ -121,7 +131,7 @@ class Sequel::Dataset
       when :=~
         l = eval_expr(e[1], b, opts)
         r = eval_expr(e[3][1], b, opts)
-        match_expr(l, r)
+        collate_match_expr(l, r)
       when :+, :-, :*, :%, :/
         l = eval_expr(e[1], b, opts)
         r = eval_expr(e[3][1], b, opts)
@@ -156,7 +166,7 @@ class Sequel::Dataset
       when :like, :like?
         l = eval_expr(e[1], b, opts)
         r = eval_expr(e[3][1], b, opts)
-        match_expr(l, r)
+        collate_match_expr(l, r)
       else
         if (op == :[]) && (e[1][0] == :lit) && (Symbol === e[1][1])
           # SQL Functions, e.g.: :sum[:x]

data/lib/sequel_core/dataset/sql.rb

@@ -152,7 +152,7 @@ module Sequel
 
       # Returns a copy of the dataset with the source changed.
       def from(*source)
-        clone_merge(:from => source)
+        clone(:from => source)
       end
       
       # Returns a dataset selecting from the current dataset.
@@ -161,7 +161,7 @@ module Sequel
       #   ds.sql #=> "SELECT * FROM items ORDER BY name"
       #   ds.from_self.sql #=> "SELECT * FROM (SELECT * FROM items ORDER BY name)"
       def from_self
-        clone_merge(:from => [self], :select => nil, :group => nil, 
+        clone(:from => [self], :select => nil, :group => nil, 
           :sql => nil, :distinct => nil, :join => nil, :where => nil,
           :order => nil, :having => nil, :limit => nil, :offset => nil,
           :union => nil)
@@ -169,41 +169,41 @@ module Sequel
 
       # Returns a copy of the dataset with the selected columns changed.
       def select(*columns)
-        clone_merge(:select => columns)
+        clone(:select => columns)
       end
       
       # Returns a copy of the dataset with additional selected columns.
       def select_more(*columns)
         if @opts[:select]
-          clone_merge(:select => @opts[:select] + columns)
+          clone(:select => @opts[:select] + columns)
         else
-          clone_merge(:select => columns)
+          clone(:select => columns)
         end
       end
       
       # Returns a copy of the dataset selecting the wildcard.
       def select_all
-        clone_merge(:select => nil)
+        clone(:select => nil)
       end
 
       # Returns a copy of the dataset with the distinct option.
       def uniq(*args)
-        clone_merge(:distinct => args)
+        clone(:distinct => args)
       end
       alias_method :distinct, :uniq
 
       # Returns a copy of the dataset with the order changed.
       def order(*order)
-        clone_merge(:order => order)
+        clone(:order => order)
       end
       alias_method :order_by, :order
       
       # Returns a copy of the dataset with the order changed.
       def order_more(*order)
         if @opts[:order]
-          clone_merge(:order => @opts[:order] + order)
+          clone(:order => @opts[:order] + order)
         else
-          clone_merge(:order => order)
+          clone(:order => order)
         end
       end
       
@@ -233,7 +233,7 @@ module Sequel
       # Returns a copy of the dataset with the results grouped by the value of 
       # the given columns
       def group(*columns)
-        clone_merge(:group => columns)
+        clone(:group => columns)
       end
       
       alias_method :group_by, :group
@@ -270,9 +270,9 @@ module Sequel
         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}")
+          clone(clause => "#{l} AND #{r}")
         else
-          clone_merge(:filter => cond, clause => expression_list(block || cond))
+          clone(:filter => cond, clause => expression_list(block || cond))
         end
       end
 
@@ -285,7 +285,7 @@ module Sequel
         if @opts[clause]
           l = expression_list(@opts[clause])
           r = expression_list(block || cond, parenthesize)
-          clone_merge(clause => "#{l} OR #{r}")
+          clone(clause => "#{l} OR #{r}")
         else
           raise Error::NoExistingFilter, "No existing filter found."
         end
@@ -317,7 +317,7 @@ module Sequel
         else
           cond = "(NOT #{expression_list(block || cond, true)})"
         end
-        clone_merge(clause => cond)
+        clone(clause => cond)
       end
 
       # Returns a copy of the dataset with the where conditions changed. Raises 
@@ -340,19 +340,19 @@ module Sequel
       # Adds a UNION clause using a second dataset object. If all is true the
       # clause used is UNION ALL, which may return duplicate rows.
       def union(dataset, all = false)
-        clone_merge(:union => dataset, :union_all => all)
+        clone(:union => dataset, :union_all => all)
       end
 
       # Adds an INTERSECT clause using a second dataset object. If all is true 
       # the clause used is INTERSECT ALL, which may return duplicate rows.
       def intersect(dataset, all = false)
-        clone_merge(:intersect => dataset, :intersect_all => all)
+        clone(:intersect => dataset, :intersect_all => all)
       end
 
       # Adds an EXCEPT clause using a second dataset object. If all is true the
       # clause used is EXCEPT ALL, which may return duplicate rows.
       def except(dataset, all = false)
-        clone_merge(:except => dataset, :except_all => all)
+        clone(:except => dataset, :except_all => all)
       end
 
       JOIN_TYPES = {
@@ -385,7 +385,7 @@ module Sequel
         end
         clause = join_expr(type, table, expr)
         join = @opts[:join] ? @opts[:join] + clause : clause
-        clone_merge(:join => join, :last_joined_table => table)
+        clone(:join => join, :last_joined_table => table)
       end
 
       # Returns a LEFT OUTER joined dataset.
@@ -617,7 +617,7 @@ module Sequel
         else
           opts = {:limit => l}
         end
-        clone_merge(opts)
+        clone(opts)
       end
       
       STOCK_COUNT_OPTS = {:select => ["COUNT(*)".lit], :order => nil}.freeze

data/spec/adapters/mysql_spec.rb

@@ -362,6 +362,17 @@ context "A MySQL database" do
       "CREATE TABLE items (`p_id` integer NOT NULL, FOREIGN KEY (`p_id`) REFERENCES users(`id`) ON DELETE CASCADE)"
     ]
   end
+  
+  specify "should accept repeated raw sql statements using Database#<<" do
+    @db << 'DELETE FROM items'
+    @db[:items].count.should == 0
+    
+    @db << "INSERT INTO items (name, value) VALUES ('tutu', 1234)"
+    @db[:items].first.should == {:name => 'tutu', :value => 1234}
+    
+    @db << 'DELETE FROM items'
+    @db[:items].first.should == nil
+  end
 end  
 
 context "A MySQL database" do
@@ -401,4 +412,5 @@ context "A grouped MySQL dataset" do
     ds = MYSQL_DB[:test2].select(:name).where(:name => '11').group(:name)
     ds.count.should == 1
   end
-end
+end
+

data/spec/dataset_spec.rb

@@ -18,15 +18,15 @@ context "Dataset" do
     d.opts.should == {}
   end
   
-  specify "should provide clone_merge for chainability." do
-    d1 = @dataset.clone_merge(:from => :test)
+  specify "should provide clone for chainability." do
+    d1 = @dataset.clone(:from => :test)
     d1.class.should == @dataset.class
     d1.should_not == @dataset
     d1.db.should be(@dataset.db)
     d1.opts[:from].should == :test
     @dataset.opts[:from].should be_nil
     
-    d2 = d1.clone_merge(:order => :name)
+    d2 = d1.clone(:order => :name)
     d2.class.should == @dataset.class
     d2.should_not == d1
     d2.should_not == @dataset
@@ -48,30 +48,48 @@ context "Dataset" do
   end
 end
 
-context "Dataset#clone_merge" do
+context "Dataset#clone" do
   setup do
     @dataset = Sequel::Dataset.new(nil).from(:items)
   end
   
+  specify "should create an exact copy of the dataset" do
+    @c = Class.new
+    @dataset.set_model(@c)
+    @clone = @dataset.clone
+
+    @clone.should_not === @dataset
+    @clone.class.should == @dataset.class
+    @clone.model_classes.should == @dataset.model_classes
+  end
+  
+  specify "should deep-copy the dataset opts" do
+    @clone = @dataset.clone
+
+    @clone.opts.should_not eql(@dataset.opts)
+    @dataset.filter!(:a => 'b')
+    @clone.opts[:filter].should be_nil
+  end
+  
   specify "should return a clone self" do
-    clone = @dataset.clone_merge({})
+    clone = @dataset.clone({})
     clone.class.should == @dataset.class
     clone.db.should == @dataset.db
     clone.opts.should == @dataset.opts
   end
   
   specify "should merge the specified options" do
-    clone = @dataset.clone_merge(1 => 2)
+    clone = @dataset.clone(1 => 2)
     clone.opts.should == {1 => 2, :from => [:items]}
   end
   
   specify "should overwrite existing options" do
-    clone = @dataset.clone_merge(:from => [:other])
+    clone = @dataset.clone(:from => [:other])
     clone.opts.should == {:from => [:other]}
   end
   
   specify "should create a clone with a deep copy of options" do
-    clone = @dataset.clone_merge(:from => [:other])
+    clone = @dataset.clone(:from => [:other])
     @dataset.opts[:from].should == [:items]
     clone.opts[:from].should == [:other]
   end
@@ -81,7 +99,7 @@ context "Dataset#clone_merge" do
       def __xyz__; "xyz"; end
     end
     @dataset.extend(m)
-    @dataset.clone_merge({}).should respond_to(:__xyz__)
+    @dataset.clone({}).should respond_to(:__xyz__)
   end
 end
 
@@ -355,6 +373,9 @@ context "Dataset#where" do
 
     @dataset.filter {:c.like? 'ABC%'}.sql.should ==
       "SELECT * FROM test WHERE (c LIKE 'ABC%')"
+
+    @dataset.filter {:c.like? ['ABC%', '%XYZ']}.sql.should ==
+      "SELECT * FROM test WHERE ((c LIKE 'ABC%') OR (c LIKE '%XYZ'))"
   end
   
   specify "should raise if receiving a single boolean value" do
@@ -1379,7 +1400,7 @@ context "Dataset#last" do
       end
 
       def single_record(opts = nil)
-        @@last_dataset = clone_merge(opts) if opts
+        @@last_dataset = clone(opts) if opts
         {:a => 1, :b => 2}
       end
       
@@ -1477,7 +1498,7 @@ context "Dataset#[]" do
       end
 
       def single_record(opts = nil)
-        @@last_dataset = opts ? clone_merge(opts) : self
+        @@last_dataset = opts ? clone(opts) : self
         {1 => 2, 3 => 4}
       end
     end
@@ -1941,7 +1962,7 @@ context "A paginated dataset" do
   end
   
   specify "should work with fixed sql" do
-    ds = @d.clone_merge(:sql => 'select * from blah')
+    ds = @d.clone(:sql => 'select * from blah')
     ds.meta_def(:count) {150}
     ds.paginate(2, 50).sql.should == 'SELECT * FROM (select * from blah) t1 LIMIT 50 OFFSET 50'
   end

data/spec/sequelizer_spec.rb

@@ -196,6 +196,11 @@ context "Proc#to_sql" do
     proc {:x.like? '%abc'}.sql.should == "(x LIKE '%abc')"
   end
   
+  specify "should support like? pattern with multiple choices" do
+    proc {:x.like? ['%abc', '%def', '%ghi']}.sql.should == \
+      "((x LIKE '%abc') OR (x LIKE '%def') OR (x LIKE '%ghi'))"
+  end
+  
   specify "should support =~ operator" do
     # stock SQL version does not know about regexps
     proc {:x =~ '123'}.sql.should == "(x LIKE '123')"
@@ -203,6 +208,15 @@ context "Proc#to_sql" do
     proc {:x =~ /^123/}.sql.should == "(x ~ '^123')"
   end
   
+  specify "should support =~ operator with multiple choices" do
+    # stock SQL version does not know about regexps
+    proc {:x =~ ['123', '456', '789']}.sql.should == "((x LIKE '123') OR (x LIKE '456') OR (x LIKE '789'))"
+
+    proc {:x =~ [/^123/, /^456/, /^789/]}.sql.should == "((x ~ '^123') OR (x ~ '^456') OR (x ~ '^789'))"
+
+    proc {:x =~ [/^123/, '456%', /^789/]}.sql.should == "((x ~ '^123') OR (x LIKE '456%') OR (x ~ '^789'))"
+  end
+  
   specify "should raise on =~ operator for unsupported types" do
     proc {proc {:x =~ 123}.sql}.should raise_error(Sequel::Error)
   end
@@ -211,10 +225,18 @@ context "Proc#to_sql" do
     proc {:x != 100}.sql.should == "(NOT (x = 100))"
   end
 
+  specify "should support != operator with multiple choices" do
+    proc {:x != [100, 200, 300]}.sql.should == "(NOT (x IN (100, 200, 300)))"
+  end
+
   specify "should support !~ operator" do
     proc {:x !~ '123'}.sql.should == "(NOT (x LIKE '123'))"
   end
   
+  specify "should support !~ operator with multiple choices" do
+    proc {:x !~ ['123', '456']}.sql.should == "(NOT ((x LIKE '123') OR (x LIKE '456')))"
+  end
+  
   specify "should support ! operator" do
     proc {!:x}.sql.should == "(x = 'f')"
     proc {!(:x > 100)}.sql.should == "(NOT (x > 100))"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_core
 version: !ruby/object:Gem::Version 
-  version: 1.0.7
+  version: 1.0.8
 platform: ruby
 authors: 
 - Sharon Rosner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-02-05 00:00:00 +02:00
+date: 2008-02-09 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -73,59 +73,59 @@ files:
 - Rakefile
 - bin/sequel
 - spec/adapters
+- spec/adapters/informix_spec.rb
 - spec/adapters/mysql_spec.rb
 - spec/adapters/oracle_spec.rb
 - spec/adapters/postgres_spec.rb
-- spec/adapters/informix_spec.rb
 - spec/adapters/sqlite_spec.rb
-- spec/database_spec.rb
-- spec/schema_generator_spec.rb
-- spec/core_sql_spec.rb
-- spec/core_ext_spec.rb
 - spec/array_keys_spec.rb
-- spec/worker_spec.rb
-- spec/spec_helper.rb
-- spec/rcov.opts
+- spec/core_ext_spec.rb
+- spec/core_sql_spec.rb
+- spec/database_spec.rb
 - spec/dataset_spec.rb
-- spec/sequelizer_spec.rb
 - spec/migration_spec.rb
 - spec/pretty_table_spec.rb
+- spec/rcov.opts
+- spec/schema_generator_spec.rb
 - spec/schema_spec.rb
+- spec/sequelizer_spec.rb
 - spec/spec.opts
-- lib/sequel_core.rb
+- spec/spec_helper.rb
+- spec/worker_spec.rb
 - lib/sequel_core
-- lib/sequel_core/schema
-- lib/sequel_core/schema/schema_sql.rb
-- lib/sequel_core/schema/schema_generator.rb
 - lib/sequel_core/adapters
+- lib/sequel_core/adapters/adapter_skeleton.rb
+- lib/sequel_core/adapters/ado.rb
+- lib/sequel_core/adapters/db2.rb
 - lib/sequel_core/adapters/dbi.rb
-- lib/sequel_core/adapters/sqlite.rb
+- lib/sequel_core/adapters/informix.rb
 - lib/sequel_core/adapters/jdbc.rb
-- lib/sequel_core/adapters/ado.rb
-- lib/sequel_core/adapters/adapter_skeleton.rb
 - lib/sequel_core/adapters/mysql.rb
-- lib/sequel_core/adapters/oracle.rb
-- lib/sequel_core/adapters/postgres.rb
-- lib/sequel_core/adapters/odbc_mssql.rb
-- lib/sequel_core/adapters/db2.rb
 - lib/sequel_core/adapters/odbc.rb
-- lib/sequel_core/adapters/informix.rb
+- lib/sequel_core/adapters/odbc_mssql.rb
 - lib/sequel_core/adapters/openbase.rb
+- lib/sequel_core/adapters/oracle.rb
+- lib/sequel_core/adapters/postgres.rb
+- lib/sequel_core/adapters/sqlite.rb
+- lib/sequel_core/array_keys.rb
+- lib/sequel_core/core_ext.rb
+- lib/sequel_core/core_sql.rb
+- lib/sequel_core/database.rb
 - lib/sequel_core/dataset
-- lib/sequel_core/dataset/sql.rb
-- lib/sequel_core/dataset/sequelizer.rb
 - lib/sequel_core/dataset/convenience.rb
-- lib/sequel_core/pretty_table.rb
-- lib/sequel_core/schema.rb
-- lib/sequel_core/model.rb
-- lib/sequel_core/exceptions.rb
-- lib/sequel_core/database.rb
+- lib/sequel_core/dataset/sequelizer.rb
+- lib/sequel_core/dataset/sql.rb
 - lib/sequel_core/dataset.rb
-- lib/sequel_core/core_sql.rb
-- lib/sequel_core/core_ext.rb
+- lib/sequel_core/exceptions.rb
 - lib/sequel_core/migration.rb
+- lib/sequel_core/model.rb
+- lib/sequel_core/pretty_table.rb
+- lib/sequel_core/schema
+- lib/sequel_core/schema/schema_generator.rb
+- lib/sequel_core/schema/schema_sql.rb
+- lib/sequel_core/schema.rb
 - lib/sequel_core/worker.rb
-- lib/sequel_core/array_keys.rb
+- lib/sequel_core.rb
 - CHANGELOG
 has_rdoc: true
 homepage: http://sequel.rubyforge.org