sequel 0.4.4.1 → 0.4.4.2

data/lib/sequel/adapters/odbc.rb

@@ -35,10 +35,15 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
+      BOOL_TRUE = '1'.freeze
+      BOOL_FALSE = '0'.freeze
+      
       def literal(v)
         case v
-        when true: '1'
-        when false: '0'
+        when true
+          BOOL_TRUE
+        when false
+          BOOL_FALSE
         else
           super
         end

data/lib/sequel/adapters/odbc_mssql.rb

@@ -31,7 +31,7 @@ module Sequel
           # ADD TOP to SELECT string for LIMITS
           if limit = opts[:limit]
             top = "TOP #{limit} "
-            raise SequelError, "Offset not supported" if opts[:offset]
+            raise Error, "Offset not supported" if opts[:offset]
           end
 
           columns = opts[:select]

data/lib/sequel/adapters/openbase.rb

@@ -34,7 +34,8 @@ module Sequel
     class Dataset < Sequel::Dataset
       def literal(v)
         case v
-        when Time: literal(v.iso8601)
+        when Time
+          literal(v.iso8601)
         else
           super
         end

data/lib/sequel/adapters/oracle.rb

@@ -43,7 +43,8 @@ module Sequel
     class Dataset < Sequel::Dataset
       def literal(v)
         case v
-        when Time: literal(v.iso8601)
+        when Time
+          literal(v.iso8601)
         else
           super
         end

data/lib/sequel/adapters/postgres.rb

@@ -2,14 +2,23 @@ require 'postgres'
 
 class PGconn
   # the pure-ruby postgres adapter does not have a quote method.
+  TRUE = 't'.freeze
+  FALSE = 'f'.freeze
+  NULL = 'NULL'.freeze
+  
   unless methods.include?('quote')
     def self.quote(obj)
       case obj
-      when true: 't'
-      when false: 'f'
-      when nil: 'NULL'
-      when String: "'#{obj}'"
-      else obj.to_s
+      when true
+        TRUE
+      when false
+        FALSE
+      when nil
+        NULL
+      when String
+        "'#{obj}'"
+      else
+        obj.to_s
       end
     end
   end
@@ -125,10 +134,13 @@ class PGconn
 end
 
 class String
+  POSTGRES_BOOL_TRUE = 't'.freeze
+  POSTGRES_BOOL_FALSE = 'f'.freeze
+  
   def postgres_to_bool
-    if self == 't'
+    if self == POSTGRES_BOOL_TRUE
       true
-    elsif self == 'f'
+    elsif self == POSTGRES_BOOL_FALSE
       false
     else
       nil
@@ -227,16 +239,16 @@ module Sequel
           # An error could occur if the inserted values include a primary key
           # value, while the primary key is serial.
           if e.message =~ RE_CURRVAL_ERROR
-            raise SequelError, "Could not return primary key value for the inserted record. Are you specifying a primary key value for a serial primary key?"
+            raise Error, "Could not return primary key value for the inserted record. Are you specifying a primary key value for a serial primary key?"
           else
             raise e
           end
         end
         
         case values
-        when Hash:
+        when Hash
           values[primary_key_for_table(conn, table)]
-        when Array:
+        when Array
           values.first
         else
           nil
@@ -283,7 +295,7 @@ module Sequel
             rescue => e
               @logger.info(SQL_ROLLBACK) if @logger
               conn.async_exec(SQL_ROLLBACK) rescue nil
-              raise e unless SequelRollbackError === e
+              raise e unless Error::Rollback === e
             ensure
               conn.transaction_in_progress = nil
             end
@@ -303,8 +315,10 @@ module Sequel
     class Dataset < Sequel::Dataset
       def literal(v)
         case v
-        when LiteralString: v
-        when String, Fixnum, Float, TrueClass, FalseClass: PGconn.quote(v)
+        when LiteralString
+          v
+        when String, Fixnum, Float, TrueClass, FalseClass
+          PGconn.quote(v)
         else
           super
         end
@@ -312,7 +326,7 @@ module Sequel
     
       def match_expr(l, r)
         case r
-        when Regexp:
+        when Regexp
           r.casefold? ? \
             "(#{literal(l)} ~* #{literal(r.source)})" :
             "(#{literal(l)} ~ #{literal(r.source)})"
@@ -328,8 +342,10 @@ module Sequel
         row_lock_mode = opts ? opts[:lock] : @opts[:lock]
         sql = super
         case row_lock_mode
-        when :update : sql << FOR_UPDATE
-        when :share  : sql << FOR_SHARE
+        when :update
+          sql << FOR_UPDATE
+        when :share
+          sql << FOR_SHARE
         end
         sql
       end

data/lib/sequel/adapters/sqlite.rb

@@ -71,7 +71,7 @@ module Sequel
       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.")
+        value = AUTO_VACUUM.index(value) || (raise Error, "Invalid value for auto_vacuum option. Please specify one of :none, :full, :incremental.")
         pragma_set(:auto_vacuum, value)
       end
       
@@ -82,7 +82,7 @@ module Sequel
       end
       
       def synchronous=(value)
-        value = SYNCHRONOUS.index(value) || (raise SequelError, "Invalid value for synchronous option. Please specify one of :off, :normal, :full.")
+        value = SYNCHRONOUS.index(value) || (raise Error, "Invalid value for synchronous option. Please specify one of :off, :normal, :full.")
         pragma_set(:synchronous, value)
       end
       
@@ -93,7 +93,7 @@ module Sequel
       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.")
+        value = TEMP_STORE.index(value) || (raise Error, "Invalid value for temp_store option. Please specify one of :default, :file, :memory.")
         pragma_set(:temp_store, value)
       end
       
@@ -102,7 +102,7 @@ module Sequel
         when :add_column
           "ALTER TABLE #{table} ADD #{column_definition_sql(op)}"
         else
-          raise SequelError, "Unsupported ALTER TABLE operation"
+          raise Error, "Unsupported ALTER TABLE operation"
         end
       end
       
@@ -116,7 +116,7 @@ module Sequel
             conn.transaction {result = yield(conn)}
             result
           rescue => e
-            raise e unless SequelRollbackError === e
+            raise e unless Error::Rollback === e
           end
         end
       end
@@ -125,7 +125,8 @@ module Sequel
     class Dataset < Sequel::Dataset
       def literal(v)
         case v
-        when Time: literal(v.iso8601)
+        when Time
+          literal(v.iso8601)
         else
           super
         end

data/lib/sequel/array_keys.rb

@@ -1,296 +1,296 @@
-# ArrayKeys provide support for accessing array elements by keys. ArrayKeys are
-# based on the arrayfields gem by Ara Howard, and can be used as substitutes
-# for fetching records tuples as Ruby hashes.
-#
-# The main advantage offered by ArrayKeys over hashes is that the values are 
-# always ordered according to the column order in the query. Another purported
-# advantage is that they reduce the memory footprint, but this has turned out
-# to be a false claim.
-module ArrayKeys
-  # The KeySet module contains methods that extend an array of keys to return
-  # a key's position in the key set.
-  module KeySet
-    # Returns the key's position in the key set. Provides indifferent access
-    # for symbols and strings.
-    def key_pos(key)
-      @key_indexes ||= inject({}) {|h, k| h[k.to_sym] = h.size; h}
-      @key_indexes[key] || @key_indexes[key.to_sym] || @key_indexes[key.to_s]
-    end
- 
-    # Adds a key to the key set.
-    def add_key(key)
-      self << key
-      @key_indexes[key] = @key_indexes.size
-    end
-    
-    # Removes a key from the key set by its index.
-    def del_key(idx)
-      delete_at(idx)
-      @key_indexes = nil # reset key indexes
-    end
-  end
-  
-  # The KeyAccess provides a large part of the Hash API for arrays with keys.
-  module KeyAccess
-    # Returns a value referenced by an array index or a key.
-    def [](idx, *args)
-      if String === idx or Symbol === idx
-        (idx = @keys.key_pos(idx)) ? super(idx, *args) : nil
-      else
-        super
-      end
-    end
- 
-    # Sets the value referenced by an array index or a key.
-    def []=(idx,*args)
-      if String === idx or Symbol === idx
-        idx = @keys.key_pos(idx) || @keys.add_key(idx.to_sym)
-      end
-      super(idx, *args)
-    end
-    
-    # Stores a value by index or key.
-    def store(k, v); self[k] = v; end
-    
-    # Slices the array, and returns an array with its keys sliced accordingly.
-    def slice(*args)
-      s = super(*args)
-      s.keys = @keys.slice(*args)
-      s
-    end
-    
-    # Converts the array into a hash.
-    def to_hash
-      h = {}
-      each_with_index {|v, i| h[@keys[i].to_sym] = v}
-      h
-    end
-    alias_method :to_h, :to_hash
-    
-    # Iterates over each key-value pair in the array.
-    def each_pair
-      each_with_index {|v, i| yield @keys[i], v}
-    end
-    
-    # Iterates over the array's associated keys.
-    def each_key(&block)
-      @keys.each(&block)
-    end
-    
-    # Iterates over the array's values.
-    def each_value(&block)
-      each(&block)
-    end
-    
-    # Deletes a value by its key.
-    def delete(key, *args)
-      if (idx = @keys.key_pos(key))
-        delete_at(idx)
-      end
-    end
-    
-    # Deletes a value by its index.
-    def delete_at(idx)
-      super(idx)
-      @keys = @keys.clone
-      @keys.del_key(idx)
-    end
-    
-    # Returns true if the array's key set contains the given key.
-    def include?(k)
-      @keys.include?(k) || @keys.include?(k.to_sym) || @keys.include?(k.to_s)
-    end
-    
-    # Returns true if the array's key set contains the given key.
-    def has_key?(k)
-      @keys.include?(k) || @keys.include?(k.to_sym) || @keys.include?(k.to_s)
-    end
-    alias_method :member?, :has_key?
-    alias_method :key?, :has_key?
-    
-    # Returns true if the array contains the given value.
-    def has_value?(k); orig_include?(k); end
-    alias_method :value?, :has_value?
-    
-    # Fetches a value by its key and optionally passes it through the given
-    # block:
-    #
-    #   row.fetch(:name) {|v| v.to_sym}
-    #
-    # You can also give a default value
-    #
-    #   row.fetch(:name, 'untitled')
-    #
-    def fetch(k, *args, &block)
-      if idx = @keys.key_pos(k)
-        v = at idx
-      else
-        !args.empty? ? (v = args.first) : (raise IndexError, "key not found")
-      end
-      block ? block[v] : v
-    end
-    
-    # Returns self.
-    def values
-      self
-    end
-    
-    # Creates a copy of self with the same key set.
-    def dup
-      copy = super
-      copy.keys = @keys
-      copy
-    end
-    
-    # Creates a copy of self with a copy of the key set.
-    def clone
-      copy = super
-      copy.keys = @keys.clone
-      copy
-    end
-    
-    # Returns an array merged from self and the given array.
-    def merge(values, &block)
-      clone.merge!(values, &block)
-    end
-    
-    # Merges the given array with self, optionally passing the values from self
-    # through the given block:
-    #
-    #   row.merge!(new_values) {|k, old, new| (k == :name) ? old : new}
-    #
-    def merge!(values, &block)
-      values.each_pair do |k, v|
-        self[k] = (has_key?(k) && block) ? block[k, self[k], v] : v
-      end
-      self
-    end
-    alias_method :update, :merge!
-    alias_method :update!, :merge!
-  end
-  
-  # The ArrayExtensions module provides extensions for the Array class.
-  module ArrayExtensions
-    attr_reader :keys
-    
-    # Sets the key set for the array. Once a key set has been set for an array,
-    # it is extended with the KeyAccess API
-    def keys=(keys)
-      extend ArrayKeys::KeyAccess if keys
-      @keys = keys.frozen? ? keys.dup : keys
-      unless @keys.respond_to?(:key_pos)
-        @keys.extend(ArrayKeys::KeySet)
-      end
-    end
- 
-    alias_method :columns, :keys
-    alias_method :columns=, :keys=
-  end
-  
-  # The DatasetExtensions module provides extensions that modify
-  # a dataset to return Array tuples instead of Hash tuples.
-  module DatasetExtensions
-    # Fetches a dataset's records, converting each tuple into an array with 
-    # keys.
-    def array_tuples_each(opts = nil, &block)
-      fetch_rows(select_sql(opts)) {|h| block[Array.from_hash(h)]}
-    end
-
-    # Provides the corresponding behavior to Sequel::Dataset#update_each_method,
-    # using array tuples.
-    def array_tuples_update_each_method
-      # warning: ugly code generation ahead
-      if @row_proc && @transform
-        class << self
-          def each(opts = nil, &block)
-            if opts && opts[:naked]
-              fetch_rows(select_sql(opts)) {|r| block[transform_load(Array.from_hash(r))]}
-            else
-              fetch_rows(select_sql(opts)) {|r| block[@row_proc[transform_load(Array.from_hash(r))]]}
-            end
-            self
-          end
-        end
-      elsif @row_proc
-        class << self
-          def each(opts = nil, &block)
-            if opts && opts[:naked]
-              fetch_rows(select_sql(opts)) {|r| block[Array.from_hash(r)]}
-            else
-              fetch_rows(select_sql(opts)) {|r| block[@row_proc[Array.from_hash(r)]]}
-            end
-            self
-          end
-        end
-      elsif @transform
-        class << self
-          def each(opts = nil, &block)
-            fetch_rows(select_sql(opts)) {|r| block[transform_load(Array.from_hash(r))]}
-            self
-          end
-        end
-      else
-        class << self
-          def each(opts = nil, &block)
-            fetch_rows(select_sql(opts)) {|r| block[Array.from_hash(r)]}
-            self
-          end
-        end
-      end
-    end
-  end
-end
-
-# Array extensions.
-class Array
-  alias_method :orig_include?, :include?
-
-  include ArrayKeys::ArrayExtensions
-
-  # Converts a hash into an array with keys.
-  def self.from_hash(h)
-    a = []; a.keys = []
-    a.merge!(h)
-  end
-end
-
-module Sequel
-  # Modifies all dataset classes to fetch records as arrays with keys. By 
-  # default records are fetched as hashes.
-  def self.use_array_tuples
-    Dataset.dataset_classes.each do |c|
-      c.class_eval do
-        if method_defined?(:array_tuples_fetch_rows)
-          alias_method :hash_tuples_fetch_rows, :fetch_rows
-          alias_method :fetch_rows, :array_tuples_fetch_rows
-        else
-          alias_method :orig_each, :each
-          alias_method :orig_update_each_method, :update_each_method
-          include ArrayKeys::DatasetExtensions
-          alias_method :each, :array_tuples_each
-          alias_method :update_each_method, :array_tuples_update_each_method
-        end
-      end
-    end
-  end
-  
-  # Modifies all dataset classes to fetch records as hashes.
-  def self.use_hash_tuples
-    Dataset.dataset_classes.each do |c|
-      c.class_eval do
-        if method_defined?(:hash_tuples_fetch_rows)
-          alias_method :fetch_rows, :hash_tuples_fetch_rows
-        else
-          if method_defined?(:orig_each)
-            alias_method :each, :orig_each
-            undef_method :orig_each
-          end
-          if method_defined?(:orig_update_each_method)
-            alias_method :update_each_method, :orig_update_each_method
-            undef_method :orig_update_each_method
-          end
-        end
-      end
-    end
-  end
+# ArrayKeys provide support for accessing array elements by keys. ArrayKeys are
+# based on the arrayfields gem by Ara Howard, and can be used as substitutes
+# for fetching records tuples as Ruby hashes.
+#
+# The main advantage offered by ArrayKeys over hashes is that the values are 
+# always ordered according to the column order in the query. Another purported
+# advantage is that they reduce the memory footprint, but this has turned out
+# to be a false claim.
+module ArrayKeys
+  # The KeySet module contains methods that extend an array of keys to return
+  # a key's position in the key set.
+  module KeySet
+    # Returns the key's position in the key set. Provides indifferent access
+    # for symbols and strings.
+    def key_pos(key)
+      @key_indexes ||= inject({}) {|h, k| h[k.to_sym] = h.size; h}
+      @key_indexes[key] || @key_indexes[key.to_sym] || @key_indexes[key.to_s]
+    end
+ 
+    # Adds a key to the key set.
+    def add_key(key)
+      self << key
+      @key_indexes[key] = @key_indexes.size
+    end
+    
+    # Removes a key from the key set by its index.
+    def del_key(idx)
+      delete_at(idx)
+      @key_indexes = nil # reset key indexes
+    end
+  end
+  
+  # The KeyAccess provides a large part of the Hash API for arrays with keys.
+  module KeyAccess
+    # Returns a value referenced by an array index or a key.
+    def [](idx, *args)
+      if String === idx or Symbol === idx
+        (idx = @keys.key_pos(idx)) ? super(idx, *args) : nil
+      else
+        super
+      end
+    end
+ 
+    # Sets the value referenced by an array index or a key.
+    def []=(idx,*args)
+      if String === idx or Symbol === idx
+        idx = @keys.key_pos(idx) || @keys.add_key(idx.to_sym)
+      end
+      super(idx, *args)
+    end
+    
+    # Stores a value by index or key.
+    def store(k, v); self[k] = v; end
+    
+    # Slices the array, and returns an array with its keys sliced accordingly.
+    def slice(*args)
+      s = super(*args)
+      s.keys = @keys.slice(*args)
+      s
+    end
+    
+    # Converts the array into a hash.
+    def to_hash
+      h = {}
+      each_with_index {|v, i| h[@keys[i].to_sym] = v}
+      h
+    end
+    alias_method :to_h, :to_hash
+    
+    # Iterates over each key-value pair in the array.
+    def each_pair
+      each_with_index {|v, i| yield @keys[i], v}
+    end
+    
+    # Iterates over the array's associated keys.
+    def each_key(&block)
+      @keys.each(&block)
+    end
+    
+    # Iterates over the array's values.
+    def each_value(&block)
+      each(&block)
+    end
+    
+    # Deletes a value by its key.
+    def delete(key, *args)
+      if (idx = @keys.key_pos(key))
+        delete_at(idx)
+      end
+    end
+    
+    # Deletes a value by its index.
+    def delete_at(idx)
+      super(idx)
+      @keys = @keys.clone
+      @keys.del_key(idx)
+    end
+    
+    # Returns true if the array's key set contains the given key.
+    def include?(k)
+      @keys.include?(k) || @keys.include?(k.to_sym) || @keys.include?(k.to_s)
+    end
+    
+    # Returns true if the array's key set contains the given key.
+    def has_key?(k)
+      @keys.include?(k) || @keys.include?(k.to_sym) || @keys.include?(k.to_s)
+    end
+    alias_method :member?, :has_key?
+    alias_method :key?, :has_key?
+    
+    # Returns true if the array contains the given value.
+    def has_value?(k); orig_include?(k); end
+    alias_method :value?, :has_value?
+    
+    # Fetches a value by its key and optionally passes it through the given
+    # block:
+    #
+    #   row.fetch(:name) {|v| v.to_sym}
+    #
+    # You can also give a default value
+    #
+    #   row.fetch(:name, 'untitled')
+    #
+    def fetch(k, *args, &block)
+      if idx = @keys.key_pos(k)
+        v = at idx
+      else
+        !args.empty? ? (v = args.first) : (raise IndexError, "key not found")
+      end
+      block ? block[v] : v
+    end
+    
+    # Returns self.
+    def values
+      self
+    end
+    
+    # Creates a copy of self with the same key set.
+    def dup
+      copy = super
+      copy.keys = @keys
+      copy
+    end
+    
+    # Creates a copy of self with a copy of the key set.
+    def clone
+      copy = super
+      copy.keys = @keys.clone
+      copy
+    end
+    
+    # Returns an array merged from self and the given array.
+    def merge(values, &block)
+      clone.merge!(values, &block)
+    end
+    
+    # Merges the given array with self, optionally passing the values from self
+    # through the given block:
+    #
+    #   row.merge!(new_values) {|k, old, new| (k == :name) ? old : new}
+    #
+    def merge!(values, &block)
+      values.each_pair do |k, v|
+        self[k] = (has_key?(k) && block) ? block[k, self[k], v] : v
+      end
+      self
+    end
+    alias_method :update, :merge!
+    alias_method :update!, :merge!
+  end
+  
+  # The ArrayExtensions module provides extensions for the Array class.
+  module ArrayExtensions
+    attr_reader :keys
+    
+    # Sets the key set for the array. Once a key set has been set for an array,
+    # it is extended with the KeyAccess API
+    def keys=(keys)
+      extend ArrayKeys::KeyAccess if keys
+      @keys = keys.frozen? ? keys.dup : keys
+      unless @keys.respond_to?(:key_pos)
+        @keys.extend(ArrayKeys::KeySet)
+      end
+    end
+ 
+    alias_method :columns, :keys
+    alias_method :columns=, :keys=
+  end
+  
+  # The DatasetExtensions module provides extensions that modify
+  # a dataset to return Array tuples instead of Hash tuples.
+  module DatasetExtensions
+    # Fetches a dataset's records, converting each tuple into an array with 
+    # keys.
+    def array_tuples_each(opts = nil, &block)
+      fetch_rows(select_sql(opts)) {|h| block[Array.from_hash(h)]}
+    end
+
+    # Provides the corresponding behavior to Sequel::Dataset#update_each_method,
+    # using array tuples.
+    def array_tuples_update_each_method
+      # warning: ugly code generation ahead
+      if @row_proc && @transform
+        class << self
+          def each(opts = nil, &block)
+            if opts && opts[:naked]
+              fetch_rows(select_sql(opts)) {|r| block[transform_load(Array.from_hash(r))]}
+            else
+              fetch_rows(select_sql(opts)) {|r| block[@row_proc[transform_load(Array.from_hash(r))]]}
+            end
+            self
+          end
+        end
+      elsif @row_proc
+        class << self
+          def each(opts = nil, &block)
+            if opts && opts[:naked]
+              fetch_rows(select_sql(opts)) {|r| block[Array.from_hash(r)]}
+            else
+              fetch_rows(select_sql(opts)) {|r| block[@row_proc[Array.from_hash(r)]]}
+            end
+            self
+          end
+        end
+      elsif @transform
+        class << self
+          def each(opts = nil, &block)
+            fetch_rows(select_sql(opts)) {|r| block[transform_load(Array.from_hash(r))]}
+            self
+          end
+        end
+      else
+        class << self
+          def each(opts = nil, &block)
+            fetch_rows(select_sql(opts)) {|r| block[Array.from_hash(r)]}
+            self
+          end
+        end
+      end
+    end
+  end
+end
+
+# Array extensions.
+class Array
+  alias_method :orig_include?, :include?
+
+  include ArrayKeys::ArrayExtensions
+
+  # Converts a hash into an array with keys.
+  def self.from_hash(h)
+    a = []; a.keys = []
+    a.merge!(h)
+  end
+end
+
+module Sequel
+  # Modifies all dataset classes to fetch records as arrays with keys. By 
+  # default records are fetched as hashes.
+  def self.use_array_tuples
+    Dataset.dataset_classes.each do |c|
+      c.class_eval do
+        if method_defined?(:array_tuples_fetch_rows)
+          alias_method :hash_tuples_fetch_rows, :fetch_rows
+          alias_method :fetch_rows, :array_tuples_fetch_rows
+        else
+          alias_method :orig_each, :each
+          alias_method :orig_update_each_method, :update_each_method
+          include ArrayKeys::DatasetExtensions
+          alias_method :each, :array_tuples_each
+          alias_method :update_each_method, :array_tuples_update_each_method
+        end
+      end
+    end
+  end
+  
+  # Modifies all dataset classes to fetch records as hashes.
+  def self.use_hash_tuples
+    Dataset.dataset_classes.each do |c|
+      c.class_eval do
+        if method_defined?(:hash_tuples_fetch_rows)
+          alias_method :fetch_rows, :hash_tuples_fetch_rows
+        else
+          if method_defined?(:orig_each)
+            alias_method :each, :orig_each
+            undef_method :orig_each
+          end
+          if method_defined?(:orig_update_each_method)
+            alias_method :update_each_method, :orig_update_each_method
+            undef_method :orig_update_each_method
+          end
+        end
+      end
+    end
+  end
 end