sequel_core 1.4.0 → 1.5.0

data/lib/sequel_core/core_ext.rb

@@ -17,9 +17,50 @@ end
 
 # Object extensions
 class Object
+  # Returns true if the object is a object of one of the classes
   def is_one_of?(*classes)
     classes.each {|c| return c if is_a?(c)}
     nil
   end
+
+  # Objects are blank if they respond true to empty?
+  def blank?
+    nil? || (respond_to?(:empty?) && empty?)
+  end
+end
+
+class Numeric
+  # Numerics are never blank (not even 0)
+  def blank?
+    false
+  end
+end
+
+class NilClass
+  # nil is always blank
+  def blank?
+    true
+  end
 end
 
+class TrueClass
+  # true is never blank
+  def blank?
+    false
+  end
+end
+
+class FalseClass
+  # false is always blank
+  def blank?
+    true
+  end
+end
+
+class String
+  BLANK_STRING_REGEXP = /\A\s*\z/
+  # Strings are blank if they are empty or include only whitespace
+  def blank?
+    empty? || BLANK_STRING_REGEXP.match(self)
+  end
+end

data/lib/sequel_core/core_sql.rb

@@ -11,7 +11,7 @@ end
 module Sequel
   # LiteralString is used to represent literal SQL expressions. An 
   # LiteralString is copied verbatim into an SQL statement. Instances of
-  # LiteralString can be created by calling String#expr.
+  # LiteralString can be created by calling String#lit.
   class LiteralString < ::String
   end
 end
@@ -21,7 +21,7 @@ class String
   # Converts a string into an SQL string by removing comments.
   # See also Array#to_sql.
   def to_sql
-    split($/).to_sql
+    split("\n").to_sql
   end
   
   # Splits a string into separate SQL statements, removing comments
@@ -67,7 +67,27 @@ end
 
 module Sequel
   module SQL
+    module ColumnMethods
+      AS = 'AS'.freeze
+      DESC = 'DESC'.freeze
+      ASC = 'ASC'.freeze
+      
+      def as(a); ColumnExpr.new(self, AS, a); end
+      
+      def desc; ColumnExpr.new(self, DESC); end
+      
+      def asc; ColumnExpr.new(self, ASC); end
+
+      def cast_as(t)
+        if t.is_a?(Symbol)
+          t = t.to_s.lit
+        end
+        Sequel::SQL::Function.new(:cast, self.as(t))
+      end
+    end
+
     class Expression
+      include ColumnMethods
       def lit; self; end
     end
     
@@ -91,8 +111,15 @@ module Sequel
     end
     
     class Function < Expression
+      attr_reader :f, :args
       def initialize(f, *args); @f, @args = f, args; end
 
+      # Functions are considered equivalent if they
+      # have the same class, function, and arguments.
+      def ==(x)
+         x.class == self.class && @f == x.f && @args == x.args
+      end
+
       def to_s(ds)
         args = @args.empty? ? '' : ds.literal(@args)
         "#{@f}(#{args})"
@@ -119,39 +146,19 @@ module Sequel
       def initialize(t); @t = t; end
       def to_s(ds); "#{@t}.*"; end
     end
-    
-    module ColumnMethods
-      AS = 'AS'.freeze
-      DESC = 'DESC'.freeze
-      ASC = 'ASC'.freeze
-      
-      def as(a); ColumnExpr.new(self, AS, a); end
-      alias_method :AS, :as
-      
-      def desc; ColumnExpr.new(self, DESC); end
-      alias_method :DESC, :desc
-      
-      def asc; ColumnExpr.new(self, ASC); end
-      alias_method :ASC, :asc
-
-      def all; Sequel::SQL::ColumnAll.new(self); end
-      alias_method :ALL, :all
-
-      def cast_as(t)
-        if t.is_a?(Symbol)
-          t = t.to_s.lit
-        end
-        Sequel::SQL::Function.new(:cast, self.as(t))
-      end
-    end
   end
 end
 
-class Object
+class String
   include Sequel::SQL::ColumnMethods
 end
 
 class Symbol
+  include Sequel::SQL::ColumnMethods
+  def *
+    Sequel::SQL::ColumnAll.new(self);
+  end
+
   def [](*args); Sequel::SQL::Function.new(self, *args); end
   def |(sub)
     unless Array === sub
@@ -186,14 +193,4 @@ class Symbol
       ds.quote_column_ref(s)
     end
   end
-  
-  # Converts missing method calls into functions on columns, if the
-  # method name is made of all upper case letters.
-  def method_missing(sym, *args)
-    if ((s = sym.to_s) =~ /^([A-Z]+)$/)
-      Sequel::SQL::Function.new(s.downcase, self)
-    else
-      super
-    end
-  end
 end

data/lib/sequel_core/database.rb

@@ -1,19 +1,20 @@
 require 'uri'
 
 module Sequel
+  DATABASES = []
   # A Database object represents a virtual connection to a database.
   # The Database class is meant to be subclassed by database adapters in order
   # to provide the functionality needed for executing queries.
   class Database
+    ADAPTERS = %w'ado db2 dbi informix jdbc mysql odbc odbc_mssql openbase oracle postgres sqlite'.collect{|x| x.to_sym}
     attr_reader :opts, :pool
     attr_accessor :logger
-    
+
     # Constructs a new instance of a database connection with the specified
     # options hash.
     #
     # Sequel::Database is an abstract class that is not useful by itself.
     def initialize(opts = {}, &block)
-      Model.database_opened(self)
       @opts = opts
       
       # Determine if the DB is single threaded or multi threaded
@@ -27,6 +28,7 @@ module Sequel
       @pool.connection_proc = block || proc {connect}
 
       @logger = opts[:logger]
+      ::Sequel::DATABASES.push(self)
     end
     
     # Connects to the database. This method should be overriden by descendants.
@@ -167,7 +169,6 @@ module Sequel
       true
     end
     
-    # include Dataset::SQL
     include Schema::SQL
     
     # default serial primary key definition. this should be overriden for each adapter.
@@ -352,23 +353,26 @@ module Sequel
     # Returns a string representation of the database object including the
     # class name and the connection URI.
     def inspect
-      '#<%s: %s>' % [self.class.to_s, uri.inspect]
+      "#<#{self.class}: #{(uri rescue opts).inspect}>" 
     end
 
     @@adapters = Hash.new
     
-    # Sets the adapter scheme for the Database class. Call this method in
-    # descendnants of Database to allow connection using a URL. For example the
-    # following:
-    #   class DB2::Database < Sequel::Database
-    #     set_adapter_scheme :db2
-    #     ...
-    #   end
-    # would allow connection using:
-    #   Sequel.open('db2://user:password@dbserver/mydb')
-    def self.set_adapter_scheme(scheme)
-      @scheme = scheme
-      @@adapters[scheme.to_sym] = self
+    class << self
+    private
+      # Sets the adapter scheme for the Database class. Call this method in
+      # descendnants of Database to allow connection using a URL. For example the
+      # following:
+      #   class DB2::Database < Sequel::Database
+      #     set_adapter_scheme :db2
+      #     ...
+      #   end
+      # would allow connection using:
+      #   Sequel.open('db2://user:password@dbserver/mydb')
+      def set_adapter_scheme(scheme)
+        @scheme = scheme
+        @@adapters[scheme.to_sym] = self
+      end
     end
     
     # Returns the scheme for the Database class.
@@ -392,7 +396,6 @@ module Sequel
     end
     
     def self.adapter_class(scheme)
-      adapter_name = scheme.to_s =~ /\-/ ? scheme.to_s.gsub('-', '_').to_sym : scheme.to_sym
       scheme = scheme.to_sym
       
       if (klass = @@adapters[scheme]).nil?

data/lib/sequel_core/dataset.rb

@@ -7,6 +7,7 @@ require File.join(File.dirname(__FILE__), 'dataset/sql')
 require File.join(File.dirname(__FILE__), 'dataset/sequelizer')
 require File.join(File.dirname(__FILE__), 'dataset/convenience')
 require File.join(File.dirname(__FILE__), 'dataset/callback')
+require File.join(File.dirname(__FILE__), 'dataset/pagination')
 
 module Sequel
   # A Dataset represents a view of a the data in a database, constrained by
@@ -25,7 +26,7 @@ module Sequel
   # use different datasets to access data:
   #   posts = DB[:posts]
   #   davids_posts = posts.filter(:author => 'david')
-  #   old_posts = posts.filter('stamp < ?', 1.week.ago)
+  #   old_posts = posts.filter('stamp < ?', Date.today - 7)
   #
   # Datasets are Enumerable objects, so they can be manipulated using any
   # of the Enumerable methods, such as map, inject, etc.
@@ -72,8 +73,7 @@ module Sequel
     include Convenience
     include Callback
     
-    attr_accessor :db
-    attr_accessor :opts
+    attr_accessor :db, :opts, :row_proc
     
     alias_method :size, :count
     
@@ -82,7 +82,7 @@ module Sequel
     def all(opts = nil, &block)
       a = []
       each(opts) {|r| a << r}
-      run_callback(:post_load, a)
+      post_load(a)
       a.each(&block) if block
       a
     end
@@ -106,15 +106,10 @@ module Sequel
     # 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.opts = @opts.merge(opts)
+      c.instance_variable_set(:@columns, nil)
       c
     end
-    alias_method :clone_merge, :clone # should be deprecated in the next major release.
-    
-    def set_options(opts) #:nodoc:
-      @opts = opts
-      @columns = nil
-    end
     
     NOTIMPL_MSG = "This method must be overriden in Sequel adapters".freeze
     
@@ -179,7 +174,17 @@ module Sequel
     
     # Iterates over the records in the dataset
     def each(opts = nil, &block)
-      fetch_rows(select_sql(opts), &block)
+      if graph = @opts[:graph]
+        graph_each(opts, &block)
+      else
+        row_proc = @row_proc unless opts && opts[:naked]
+        transform = @transform
+        fetch_rows(select_sql(opts)) do |r|
+          r = transform_load(r) if transform
+          r = row_proc[r] if row_proc
+          yield r
+        end
+      end
       self
     end
 
@@ -248,17 +253,17 @@ module Sequel
       when nil # set_model(nil) => no
         # no argument provided, so the dataset is denuded
         @opts.merge!(:naked => true, :models => nil, :polymorphic_key => nil)
-        remove_row_proc
+        self.row_proc = nil
         # extend_with_stock_each
       when Class
         # isomorphic model
         @opts.merge!(:naked => nil, :models => {nil => key}, :polymorphic_key => nil)
         if key.respond_to?(:load)
           # the class has a values setter method, so we use it
-          set_row_proc {|h| key.load(h, *args)}
+          self.row_proc = proc{|h| key.load(h, *args)}
         else
           # otherwise we just pass the hash to the constructor
-          set_row_proc {|h| key.new(h, *args)}
+          self.row_proc = proc{|h| key.new(h, *args)}
         end
         extend_with_destroy
       when Symbol
@@ -267,14 +272,14 @@ module Sequel
         @opts.merge!(:naked => true, :models => hash, :polymorphic_key => key)
         if hash.values.first.respond_to?(:load)
           # the class has a values setter method, so we use it
-          set_row_proc do |h|
+          self.row_proc = proc do |h|
             c = hash[h[key]] || hash[nil] || \
               raise(Error, "No matching model class for record (#{polymorphic_key} => #{h[polymorphic_key].inspect})")
             c.load(h, *args)
           end
         else
           # otherwise we just pass the hash to the constructor
-          set_row_proc do |h|
+          self.row_proc = proc do |h|
             c = hash[h[key]] || hash[nil] || \
               raise(Error, "No matching model class for record (#{polymorphic_key} => #{h[polymorphic_key].inspect})")
             c.new(h, *args)
@@ -287,25 +292,6 @@ module Sequel
       self
     end
     
-    # Overrides the each method to pass the values through a filter. The filter
-    # receives as argument a hash containing the column values for the current
-    # record. The filter should return a value which is then passed to the 
-    # iterating block. In order to elucidate, here's a contrived example:
-    #
-    #   dataset.set_row_proc {|h| h.merge(:xxx => 'yyy')}
-    #   dataset.first[:xxx] #=> "yyy" # always!
-    #
-    def set_row_proc(&filter)
-      @row_proc = filter
-      update_each_method
-    end
-    
-    # Removes the row making proc.
-    def remove_row_proc
-      @row_proc = nil
-      update_each_method
-    end
-    
     STOCK_TRANSFORMS = {
       :marshal => [
         # for backwards-compatibility we support also non-base64-encoded values.
@@ -354,7 +340,6 @@ module Sequel
           end
         end
       end
-      update_each_method
       self
     end
     
@@ -376,49 +361,6 @@ module Sequel
       end
     end
     
-    # Updates the each method according to whether @row_proc and @transform are
-    # set or not.
-    def 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(r)]}
-            else
-              fetch_rows(select_sql(opts)) {|r| block[@row_proc[transform_load(r)]]}
-            end
-            self
-          end
-        end
-      elsif @row_proc
-        class << self
-          def each(opts = nil, &block)
-            if opts && opts[:naked]
-              fetch_rows(select_sql(opts), &block)
-            else
-              fetch_rows(select_sql(opts)) {|r| block[@row_proc[r]]}
-            end
-            self
-          end
-        end
-      elsif @transform
-        class << self
-          def each(opts = nil, &block)
-            fetch_rows(select_sql(opts)) {|r| block[transform_load(r)]}
-            self
-          end
-        end
-      else
-        class << self
-          def each(opts = nil, &block)
-            fetch_rows(select_sql(opts), &block)
-            self
-          end
-        end
-      end
-    end
-    
     # Extends the dataset with a destroy method, that calls destroy for each
     # record in the dataset.
     def extend_with_destroy
@@ -449,6 +391,33 @@ module Sequel
     def inspect
       '#<%s: %s>' % [self.class.to_s, sql.inspect]
     end
+
+    # Setup mutation (e.g. filter!) methods
+    def self.def_mutation_method(*meths)
+      meths.each do |meth|
+        class_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end")
+      end
+    end
+    def def_mutation_method(*meths)
+      meths.each do |meth|
+        instance_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end")
+      end
+    end
+
+    MUTATION_METHODS = %w'and distinct exclude exists filter from from_self full_outer_join graph
+    group group_and_count group_by having inner_join intersect invert_order join
+    left_outer_join limit naked or order order_by order_more paginate query reject
+    reverse reverse_order right_outer_join select select_all select_more
+    set_graph_aliases set_model sort sort_by union unordered where'.collect{|x| x.to_sym}
+
+    def_mutation_method(*MUTATION_METHODS)
+
+    private
+      def mutation_method(meth, *args, &block)
+        copy = send(meth, *args, &block)
+        @opts.merge!(copy.opts)
+        self
+      end
   end
 end