sequel 0.2.1.1 → 0.3.0

data/CHANGELOG

@@ -1,3 +1,79 @@
+=== 0.3 (2007-10-20)
+
+* Added stock transforms to Dataset#transform. Refactored Model.serialize.
+
+* Added Database#logger= method for setting the database logger object.
+
+* Fixed Model.[] to act as shortcut to Model.find when a hash is given (#71).
+
+* Added support for old and new decimal types in MySQL adapter, and updated MYSQL_TYPES with MySQL 5.0 constants (#72).
+
+* Implemented Database#disconnect method for all adapters.
+
+* Fixed small bug in ArrayKeys module.
+
+* Implemented model caching by primary key.
+
+* Separated Model.find and Model.[] functionality. Model.find takes a filter. Model.[] is strictly for finding by primary keys.
+
+* Enhanced Dataset#first to accept a filter block. Model#find can also now accept a filter block.
+
+* Changed Database#[] to act as shortcut to #fetch if a string is given.
+
+* Renamed Database#each to #fetch. If no block is given, the method returns an enumerator.
+
+* Changed Dataset#join methods to correctly literalize values in join conditions (#70).
+
+* Fixed #filter with ranges to correctly literalize field names (#69).
+
+* Implemented Database#each method for quickly retrieving records with arbitrary SQL (thanks Aman Gupta).
+
+* Fixed bug in postgres adapter where a LiteralString would be literalized as a regular String.
+
+* Fixed SQLite insert with subquery (#68).
+
+* Reverted back to hashes as default mode. Added Sequel.use_array_tuples and Sequel.use_hash_tuples methods.
+
+* Fixed problem with arrays with keys when using #delete.
+
+* Implemented ArrayKeys as substitute for ArrayFields.
+
+* Added Dataset#each_hash method.
+
+* Rewrote SQLite::Database#transaction to use sqlite3-ruby library implementation of transactions.
+
+* Fixed Model.destroy_all to work correctly in cases where no before_destroy hook is defined and an after_destroy hook is defined.
+
+* Restored Model.has_hooks? implementation.
+
+* Changed Database#<< to strip comments and whitespace only when an array is given.
+
+* Changed Schema::Generator#primary_key to accept calls with the type argument omitted.
+
+* Hooks can now be prepended or appended by choice.
+
+* Changed Model.subset to define filter method on the underlying dataset instead of the model class.
+
+* Fixed Dataset#transform to work with array fields.
+
+* Added Dataset#to_csv method.
+
+* PrettyTable can now extract column names from arrayfields.
+
+* Converted ado, dbi, odbc adapters to use arrayfields instead of hashes.
+
+* Fixed composite key support.
+
+* Fixed Dataset#insert_sql, update_sql to support array fields.
+
+* Converted sqlite, mysql, postgres adapters to use arrayfields instead of hashes.
+
+* Extended Dataset#from to auto alias sub-queries.
+
+* Extended Dataset#from to accept hash for aliasing tables.
+
+* Added before_update, after_update hooks.
+
 === 0.2.1.1 (2007-10-07)
 
 * Added Date literalization to sqlite adapter (#60).

data/Rakefile

@@ -6,7 +6,7 @@ require 'fileutils'
 include FileUtils
 
 NAME = "sequel"
-VERS = "0.2.1.1"
+VERS = "0.3.0"
 CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
 RDOC_OPTS = ['--quiet', '--title', "Sequel: Concise ORM for Ruby",
   "--opname", "index.html",

data/lib/sequel.rb

@@ -1,7 +1,7 @@
 require 'metaid'
 
 files = %w[
-  core_ext error connection_pool pretty_table
+  core_ext array_keys error connection_pool pretty_table
   dataset migration model schema database 
 ]
 dir = File.join(File.dirname(__FILE__), 'sequel')

data/lib/sequel/ado.rb

@@ -21,6 +21,10 @@ module Sequel
         handle.Open(dbname)
         handle
       end
+      
+      def disconnect
+        # how do we disconnect? couldn't find anything in the docs
+      end
     
       def dataset(opts = nil)
         ADO::Dataset.new(self, opts)
@@ -63,6 +67,19 @@ module Sequel
         end
       end
     
+      def array_tuples_fetch_rows(sql, &block)
+        @db.synchronize do
+          s = @db.execute sql
+          
+          fields = s.Fields.extend(Enumerable)
+          @columns = fields.map {|x| x.Name.to_sym}
+          
+          s.moveFirst
+          s.getRows.transpose.each {|r| r.fields = @columns; yield r}
+        end
+        self
+      end
+      
       def insert(*values)
         @db.do insert_sql(*values)
       end

data/lib/sequel/array_keys.rb

@@ -0,0 +1,233 @@
+# Based on the arrayfields gem by Ara Howard
+
+module ArrayKeys
+  module KeySet
+    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
+ 
+    def add_key(key)
+      self << key
+      @key_indexes[key] = @key_indexes.size
+    end
+    
+    def del_key(idx)
+      delete_at(idx)
+      @key_indexes = nil # reset key indexes
+    end
+  end
+  
+  module KeyAccess
+    def [](idx, *args)
+      if String === idx or Symbol === idx
+        (idx = @keys.key_pos(idx)) ? super(idx, *args) : nil
+      else
+        super
+      end
+    end
+ 
+    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
+    
+    def store(k, v); self[k] = v; end
+    
+    def slice(*args)
+      s = super(*args)
+      s.keys = @keys.slice(*args)
+      s
+    end
+    
+    def to_hash
+      h = {}
+      each_with_index {|v, i| h[@keys[i].to_sym] = v}
+      h
+    end
+    alias_method :to_h, :to_hash
+    
+    def each_pair
+      each_with_index {|v, i| yield @keys[i], v}
+    end
+    
+    def each_key(&block)
+      @keys.each(&block)
+    end
+    
+    def each_value(&block)
+      each(&block)
+    end
+    
+    def delete(key, *args)
+      if (idx = @keys.key_pos(key))
+        delete_at(idx)
+      end
+    end
+    
+    def delete_at(idx)
+      super(idx)
+      @keys = @keys.clone
+      @keys.del_key(idx)
+    end
+    
+    def include?(k)
+      @keys.include?(k) || @keys.include?(k.to_sym) || @keys.include?(k.to_s)
+    end
+    
+    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?
+    
+    def has_value?(k); orig_include?(k); end
+    alias_method :value?, :has_value?
+    
+    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
+    
+    def values
+      self
+    end
+    
+    def dup
+      copy = super
+      copy.keys = @keys
+      copy
+    end
+    
+    def clone
+      copy = super
+      copy.keys = @keys.clone
+      copy
+    end
+    
+    def merge(values, &block)
+      clone.merge!(values, &block)
+    end
+    
+    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
+  
+  module ArrayExtensions
+    attr_reader :keys
+    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 :fields, :keys
+    alias_method :fields=, :keys=
+  end
+  
+  module DatasetExtensions
+    def array_tuples_each(opts = nil, &block)
+      fetch_rows(select_sql(opts)) {|h| block[Array.from_hash(h)]}
+    end
+
+    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
+          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
+          end
+        end
+      elsif @transform
+        class << self
+          def each(opts = nil, &block)
+            fetch_rows(select_sql(opts)) {|r| block[transform_load(Array.from_hash(r))]}
+          end
+        end
+      else
+        class << self
+          def each(opts = nil, &block)
+            fetch_rows(select_sql(opts)) {|r| block[Array.from_hash(r)]}
+          end
+        end
+      end
+    end
+  end
+end
+
+class Array
+  alias_method :orig_include?, :include?
+
+  include ArrayKeys::ArrayExtensions
+
+  def self.from_hash(h)
+    a = []; a.keys = []
+    a.merge!(h)
+  end
+end
+
+module Sequel
+  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
+  
+  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

data/lib/sequel/connection_pool.rb

@@ -68,6 +68,14 @@ module Sequel
       raise e.is_a?(StandardError) ? e : e.message
     end
     
+    def disconnect(&block)
+      @mutex.synchronize do
+        @available_connections.each {|c| block[c]} if block
+        @available_connections = []
+        @created_count = @allocated.size
+      end
+    end
+    
     private
       # Returns the connection owned by the supplied thread, if any.
       def owned_connection(thread)
@@ -112,6 +120,7 @@ module Sequel
   # in single-threaded applications. ConnectionPool imposes a substantial
   # performance penalty, so SingleThreadedPool is used to gain some speed.
   class SingleThreadedPool
+    attr_reader :conn
     attr_writer :connection_proc
     
     # Initializes the instance with the supplied block as the connection_proc.
@@ -128,5 +137,10 @@ module Sequel
       # if the error is not a StandardError it is converted into RuntimeError.
       raise e.is_a?(StandardError) ? e : e.message
     end
+    
+    def disconnect(&block)
+      block[@conn] if block && @conn
+      @conn = nil
+    end
   end
 end

data/lib/sequel/core_ext.rb

@@ -70,17 +70,17 @@ end
 module FieldCompositionMethods
   # Constructs a DESC clause for use in an ORDER BY clause.
   def DESC
-    "#{to_field_name} DESC"
+    "#{to_field_name} DESC".lit
   end
   
   # Constructs an AS clause for field aliasing.
   def AS(target)
-    "#{to_field_name} AS #{target}"
+    "#{to_field_name} AS #{target}".lit
   end
 
   # Constructs a qualified wildcard (*) clause.
   def ALL
-    "#{to_s}.*"
+    "#{to_s}.*".lit
   end
   
   FIELD_TITLE_RE1 = /^(.*)\sAS\s(.+)$/i.freeze

data/lib/sequel/database.rb

@@ -5,7 +5,8 @@ module Sequel
   # The Database class is meant to be subclassed by database adapters in order
   # to provide the functionality needed for executing queries.
   class Database
-    attr_reader :opts, :pool, :logger
+    attr_reader :opts, :pool
+    attr_accessor :logger
     
     # Constructs a new instance of a database connection with the specified
     # options hash.
@@ -32,6 +33,10 @@ module Sequel
       raise NotImplementedError, "#connect should be overriden by adapters"
     end
     
+    def disconnect
+      raise NotImplementedError, "#disconnect should be overriden by adapters"
+    end
+    
     def multi_threaded?
       !@single_threaded
     end
@@ -63,6 +68,17 @@ module Sequel
       ds = Sequel::Dataset.new(self)
     end
     
+    def fetch(sql, *args, &block)
+      ds = dataset
+      sql = sql.gsub('?') {|m|  ds.literal(args.shift)}
+      if block
+        ds.fetch_rows(sql, &block)
+      else
+        Enumerable::Enumerator.new(ds, :fetch_rows, sql)
+      end
+    end
+    alias_method :>>, :fetch
+    
     # Converts a query block into a dataset. For more information see 
     # Dataset#query.
     def query(&block)
@@ -79,16 +95,18 @@ module Sequel
     # Returns a new dataset with the select method invoked.
     def select(*args); dataset.select(*args); end
     
-    alias_method :[], :from
-
+    def [](*args)
+      (String === args.first) ? fetch(*args) : from(*args)
+    end
+    
     def execute(sql)
       raise NotImplementedError
     end
     
-    # Executes the supplied SQL. The SQL can be supplied as a string or as an
-    # array of strings. Comments and excessive white space are removed. See
-    # also Array#to_sql.
-    def <<(sql); execute(sql.to_sql); end
+    # Executes the supplied SQL statement. The SQL can be supplied as a string
+    # or as an array of strings. If an array is give, comments and excessive 
+    # white space are removed. See also Array#to_sql.
+    def <<(sql); execute((Array === sql) ? sql.to_sql : sql); end
     
     # Acquires a database connection, yielding it to the passed block.
     def synchronize(&block)