sequel 0.1.7 → 0.1.8

data/lib/sequel/dbi.rb

@@ -44,10 +44,11 @@ module Sequel
         end
       end
 
-      def each(opts = nil, &block)
+      def fetch_rows(sql, &block)
         @db.synchronize do
-          s = @db.execute select_sql(opts)
+          s = @db.execute sql
           begin
+            @columns = stmt.column_names.map {|c| c.to_sym}
             s.fetch {|r| yield hash_row(s, r)}
           ensure
             s.finish rescue nil
@@ -57,8 +58,8 @@ module Sequel
       end
       
       def hash_row(stmt, row)
-        stmt.column_names.inject({}) do |m, n|
-          m[n.to_sym] = row.shift
+        @columns.inject({}) do |m, c|
+          m[c] = row.shift
           m
         end
       end

data/lib/sequel/model.rb

@@ -26,14 +26,14 @@ module Sequel
         raise SequelError, "Database not specified for #{self}."
       end
       @dataset = db[table_name]
-      @dataset.model_class = self
+      @dataset.set_model(self)
       @dataset
     end
 
     def self.set_dataset(ds)
       @db = ds.db
       @dataset = ds
-      @dataset.model_class = self
+      @dataset.set_model(self)
     end
     
     def self.cache_by(column, expiration)

data/lib/sequel/mysql.rb

@@ -48,15 +48,6 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
-      def each(opts = nil, &block)
-        query_each(select_sql(opts), true, &block)
-        self
-      end
-      
-      def count(opts = nil)
-        query_single_value(count_sql(opts)).to_i
-      end
-    
       def insert(*values)
         @db.execute_insert(insert_sql(*values))
       end
@@ -69,15 +60,12 @@ module Sequel
         @db.execute_affected(delete_sql(opts))
       end
       
-      def query_each(sql, use_model_class = false)
+      def fetch_rows(sql)
         @db.synchronize do
           result = @db.execute(sql)
           begin
-            if use_model_class && @model_class
-              result.each_hash {|r| yield @model_class.new(r)}
-            else
-              result.each_hash {|r| yield r}
-            end
+            fetch_columns(result)
+            result.each_hash {|r| yield r}
           ensure
             result.free
           end
@@ -85,39 +73,8 @@ module Sequel
         self
       end
       
-      def single_record(opts = nil)
-        query_single(select_sql(opts), true)
-      end
-      
-      def single_value(opts = nil)
-        query_single_value(select_sql(opts))
-      end
-      
-      def query_single(sql, use_model_class = false)
-        @db.synchronize do
-          result = @db.execute(sql)
-          begin
-            if use_model_class && @model_class
-              row = @model_class.new(result.fetch_hash)
-            else
-              row = result.fetch_hash
-            end
-          ensure
-            result.free
-          end
-          row
-        end
-      end
-      
-      def query_single_value(sql)
-        @db.synchronize do
-          result = @db.execute(sql)
-          begin
-            return result.fetch_hash.values[0]
-          ensure
-            result.free
-          end
-        end
+      def fetch_columns(result)
+        @columns = result.fetch_fields.map {|c| c.name.to_sym}
       end
     end
   end

data/lib/sequel/odbc.rb

@@ -44,12 +44,13 @@ module Sequel
         end
       end
 
-      def each(opts = nil, &block)
+      def fetch_rows(sql, &block)
         @db.synchronize do
-          s = @db.execute select_sql(opts)
+          s = @db.execute select_sql(sql)
           begin
-            fetch_rows(s, &block)
-            s.fetch {|r| yield hash_row(s, r)}
+            @columns = s.columns(true).map {|c| c.name.to_sym}
+            rows = s.fetch_all
+            rows.each {|row| yield hash_row(row)}
           ensure
             s.drop unless s.nil? rescue nil
           end
@@ -57,16 +58,10 @@ module Sequel
         self
       end
       
-      def fetch_rows(stmt)
-        columns = stmt.columns(true).map {|c| c.name.to_sym}
-        rows = stmt.fetch_all
-        rows.each {|row| yield hash_row(stmt, columns, row)}
-      end
-      
-      def hash_row(stmt, columns, row)
+      def hash_row(row)
         hash = {}
         row.each_with_index do |v, idx|
-          hash[columns[idx]] = convert_odbc_value(v)
+          hash[@columns[idx]] = convert_odbc_value(v)
         end
         hash
       end

data/lib/sequel/postgres.rb

@@ -277,19 +277,6 @@ module Sequel
       
       def literal(v)
         case v
-        # when String: "'%s'" % v.gsub(/'/, "''")
-        # when Integer, Float: v.to_s
-        # when NilClass: NULL
-        # when Symbol: v.to_field_name
-        # when Array: v.empty? ? NULL : v.map {|i| literal(i)}.join(COMMA_SEPARATOR)
-        # when Time: v.strftime(TIMESTAMP_FORMAT)
-        # when Date: v.strftime(DATE_FORMAT)
-        # when Dataset: "(#{v.sql})"
-        # when true: TRUE
-        # when false: FALSE
-        # else
-        #   raise SequelError, "can't express #{v.inspect}:#{v.class} as a SQL literal"
-        # end
         when String, Fixnum, Float, TrueClass, FalseClass: PGconn.quote(v)
         else
           super
@@ -309,11 +296,6 @@ module Sequel
         end
       end
       
-      def each(opts = nil, &block)
-        query_each(select_sql(opts), true, &block)
-        self
-      end
-      
       FOR_UPDATE = ' FOR UPDATE'.freeze
       FOR_SHARE = ' FOR SHARE'.freeze
     
@@ -328,19 +310,28 @@ module Sequel
       end
     
       def for_update
-        dup_merge(:lock => :update)
+        clone_merge(:lock => :update)
       end
     
       def for_share
-        dup_merge(:lock => :share)
+        clone_merge(:lock => :share)
       end
     
       EXPLAIN = 'EXPLAIN '.freeze
+      EXPLAIN_ANALYZE = 'EXPLAIN ANALYZE '.freeze
       QUERY_PLAN = 'QUERY PLAN'.to_sym
     
       def explain(opts = nil)
         analysis = []
-        query_each(select_sql(EXPLAIN + select_sql(opts))) do |r|
+        fetch_rows(EXPLAIN + select_sql(opts)) do |r|
+          analysis << r[QUERY_PLAN]
+        end
+        analysis.join("\r\n")
+      end
+      
+      def analyze(opts = nil)
+        analysis = []
+        fetch_rows(EXPLAIN_ANALYZE + select_sql(opts)) do |r|
           analysis << r[QUERY_PLAN]
         end
         analysis.join("\r\n")
@@ -399,20 +390,11 @@ module Sequel
         end
       end
       
-      def single_record(opts = nil)
-        query_single(select_sql(opts), true)
-      end
-      
-      def single_value(opts = nil)
-        query_single_value(select_sql(opts))
-      end
-      
-      def query_each(sql, use_model_class = false, &block)
+      def fetch_rows(sql, &block)
         @db.synchronize do
           result = @db.execute(sql)
           begin
-            # each_row(result, use_model_class, &block)
-            conv = row_converter(result, use_model_class)
+            conv = row_converter(result)
             result.each {|r| yield conv[r]}
           ensure
             result.clear
@@ -420,54 +402,25 @@ module Sequel
         end
       end
       
-      def query_single(sql, use_model_class = false)
-        @db.synchronize do
-          result = @db.execute(sql)
-          begin
-            row = nil
-            conv = row_converter(result, use_model_class)
-            result.each {|r| row = conv.call(r)}
-          ensure
-            result.clear
-          end
-          row
-        end
-      end
-      
-      def query_single_value(sql)
-        @db.synchronize do
-          result = @db.execute(sql)
-          begin
-            value = result.getvalue(0, 0)
-            if value
-              value = value.send(PG_TYPES[result.type(0)])
-            end
-          ensure
-            result.clear
-          end
-          value
-        end
-      end
-      
       @@converters_mutex = Mutex.new
       @@converters = {}
 
-      def row_converter(result, use_model_class)
+      def row_converter(result)
         fields = []; translators = []
         result.fields.each_with_index do |f, idx|
           fields << f.to_sym
           translators << PG_TYPES[result.type(idx)]
         end
-        klass = use_model_class && @model_class
+        @columns = fields
         
         # create result signature and memoize the converter
-        sig = [fields, translators, klass].hash
+        sig = [fields, translators].hash
         @@converters_mutex.synchronize do
-          @@converters[sig] ||= compile_converter(fields, translators, klass)
+          @@converters[sig] ||= compile_converter(fields, translators)
         end
       end
     
-      def compile_converter(fields, translators, klass)
+      def compile_converter(fields, translators)
         used_fields = []
         kvs = []
         fields.each_with_index do |field, idx|
@@ -475,16 +428,12 @@ module Sequel
           used_fields << field
         
           if translator = translators[idx]
-            kvs << ":#{field} => ((t = r[#{idx}]) ? t.#{translator} : nil)"
+            kvs << ":\"#{field}\" => ((t = r[#{idx}]) ? t.#{translator} : nil)"
           else
-            kvs << ":#{field} => r[#{idx}]"
+            kvs << ":\"#{field}\" => r[#{idx}]"
           end
         end
-        if klass
-          eval("lambda {|r| #{klass}.new(#{kvs.join(COMMA_SEPARATOR)})}")
-        else
-          eval("lambda {|r| {#{kvs.join(COMMA_SEPARATOR)}}}")
-        end
+        eval("lambda {|r| {#{kvs.join(COMMA_SEPARATOR)}}}")
       end
     end
   end

data/lib/sequel/sqlite.rb

@@ -44,20 +44,52 @@ module Sequel
         @pool.hold {|conn| conn.get_first_value(sql)}
       end
       
-      def result_set(sql, model_class, &block)
+      def query(sql, &block)
         @logger.info(sql) if @logger
-        @pool.hold do |conn|
-          conn.query(sql) do |result|
-            columns = result.columns
-            column_count = columns.size
-            result.each do |values|
-              row = {}
-              column_count.times {|i| row[columns[i].to_sym] = values[i]}
-              block.call(model_class ? model_class.new(row) : row)
-            end
-          end
-        end
+        @pool.hold {|conn| conn.query(sql, &block)}
+      end
+      
+      def pragma_get(name)
+        single_value("PRAGMA #{name};")
       end
+      
+      def pragma_set(name, value)
+        execute("PRAGMA #{name} = #{value};")
+      end
+      
+      AUTO_VACUUM = {'0' => :none, '1' => :full, '2' => :incremental}.freeze
+      
+      def auto_vacuum
+        AUTO_VACUUM[pragma_get(:auto_vacuum)]
+      end
+      
+      def auto_vacuum=(value)
+        value = AUTO_VACUUM.index(value) || (raise SequelError, "Invalid value for auto_vacuum option. Please specify one of :none, :full, :incremental.")
+        pragma_set(:auto_vacuum, value)
+      end
+      
+      SYNCHRONOUS = {'0' => :off, '1' => :normal, '2' => :full}.freeze
+      
+      def synchronous
+        SYNCHRONOUS[pragma_get(:synchronous)]
+      end
+      
+      def synchronous=(value)
+        value = SYNCHRONOUS.index(value) || (raise SequelError, "Invalid value for synchronous option. Please specify one of :off, :normal, :full.")
+        pragma_set(:synchronous, value)
+      end
+      
+      TEMP_STORE = {'0' => :default, '1' => :file, '2' => :memory}.freeze
+      
+      def temp_store
+        TEMP_STORE[pragma_get(:temp_store)]
+      end
+      
+      def temp_store=(value)
+        value = TEMP_STORE.index(value) || (raise SequelError, "Invalid value for temp_store option. Please specify one of :default, :file, :memory.")
+        pragma_set(:temp_store, value)
+      end
+      
     end
     
     class Dataset < Sequel::Dataset
@@ -69,9 +101,16 @@ module Sequel
         end
       end
 
-      def each(opts = nil, &block)
-        @db.result_set(select_sql(opts), @model_class, &block)
-        self
+      def fetch_rows(sql, &block)
+        @db.query(sql) do |result|
+          @columns = result.columns.map {|c| c.to_sym}
+          column_count = @columns.size
+          result.each do |values|
+            row = {}
+            column_count.times {|i| row[@columns[i]] = values[i]}
+            block.call(row)
+          end
+        end
       end
     
       def insert(*values)

data/spec/adapters/sqlite_spec.rb

@@ -0,0 +1,104 @@
+require File.join(File.dirname(__FILE__), '../../lib/sequel/sqlite')
+
+SQLITE_DB = Sequel('sqlite:/')
+SQLITE_DB.create_table :items do
+  integer :id, :primary_key => true, :auto_increment => true
+  text :name
+  float :value
+end
+
+context "An SQLite database" do
+  setup do
+    @db = Sequel('sqlite:/')
+  end
+  
+  specify "should provide a list of existing tables" do
+    @db.tables.should == []
+    
+    @db.create_table :testing do
+      text :name
+    end
+    @db.tables.should include(:testing)
+  end
+  
+  specify "should support getting pragma values" do
+    @db.pragma_get(:auto_vacuum).should == '0'
+  end
+  
+  specify "should support setting pragma values" do
+    @db.pragma_set(:auto_vacuum, '1')
+    @db.pragma_get(:auto_vacuum).should == '1'
+  end
+  
+  specify "should support getting and setting the auto_vacuum pragma" do
+    @db.auto_vacuum = :full
+    @db.auto_vacuum.should == :full
+    @db.auto_vacuum = :none
+    @db.auto_vacuum.should == :none
+    
+    proc {@db.auto_vacuum = :invalid}.should raise_error(SequelError)
+  end
+
+  specify "should support getting and setting the synchronous pragma" do
+    @db.synchronous = :off
+    @db.synchronous.should == :off
+    @db.synchronous = :normal
+    @db.synchronous.should == :normal
+    @db.synchronous = :full
+    @db.synchronous.should == :full
+    
+    proc {@db.synchronous = :invalid}.should raise_error(SequelError)
+  end
+  
+  specify "should support getting and setting the temp_store pragma" do
+    @db.temp_store = :default
+    @db.temp_store.should == :default
+    @db.temp_store = :file
+    @db.temp_store.should == :file
+    @db.temp_store = :memory
+    @db.temp_store.should == :memory
+    
+    proc {@db.temp_store = :invalid}.should raise_error(SequelError)
+  end
+end
+
+context "An SQLite dataset" do
+  setup do
+    @d = SQLITE_DB[:items]
+    @d.delete # remove all records
+  end
+  
+  specify "should return the correct record count" do
+    @d.count.should == 0
+    @d << {:name => 'abc', :value => 1.23}
+    @d << {:name => 'abc', :value => 4.56}
+    @d << {:name => 'def', :value => 7.89}
+    @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 update records correctly" do
+    @d << {:name => 'abc', :value => 1.23}
+    @d << {:name => 'abc', :value => 4.56}
+    @d << {:name => 'def', :value => 7.89}
+    @d.filter(:name => 'abc').update(:value => 5.3)
+    
+    # the third record should stay the same
+    @d[:name => 'def'][:value].should == 7.89
+    @d.filter(:value => 5.3).count.should == 2
+  end
+  
+  specify "should delete records correctly" do
+    @d << {:name => 'abc', :value => 1.23}
+    @d << {:name => 'abc', :value => 4.56}
+    @d << {:name => 'def', :value => 7.89}
+    @d.filter(:name => 'abc').delete
+    
+    @d.count.should == 1
+    @d.first[:name].should == 'def'
+  end
+end