sequel_core 1.4.0 → 1.5.0

data/lib/sequel_core/dataset/callback.rb

@@ -1,19 +1,17 @@
 module Sequel
   class Dataset
+    # Module with empty methods that can be
+    # override to provide callback behavior
     module Callback
-      # Add a symbol with the name of a method to the list of callbacks for name.
-      def add_callback(name, sym)
-        cbs = (@opts[:callbacks] ||= {})
-        cb = (cbs[name] ||= [])
-        cb.push(sym)
-      end
-      
-      # Run all callbacks for name with the given args
-      def run_callback(name, *args)
-        return unless cbs = @opts[:callbacks]
-        return unless cb = cbs[name]
-        cb.each{|sym| send(sym, *args)}
-      end
+      private
+        # This is run inside .all, after all
+        # of the records have been loaded
+        # via .each, but before any block passed
+        # to all is called.  It is called with
+        # a single argument, an array of all
+        # returned records.
+        def post_load(all_records)
+        end
     end
   end
 end

data/lib/sequel_core/dataset/convenience.rb

@@ -3,15 +3,9 @@ require 'enumerator'
 module Sequel
   class Dataset
     module Convenience
-      # Iterates through each record, converting it into a hash.
-      def each_hash(&block)
-        each {|a| block[a.to_hash]}
-      end
-      
       # Returns true if no records exists in the dataset
       def empty?
         db.dataset.where(exists).get(1) == nil
-        # count == 0
       end
       
       # Returns the first record in the dataset.
@@ -23,10 +17,10 @@ module Sequel
       NAKED_HASH = {:naked => true}.freeze
 
       # Returns the first value of the first reecord in the dataset.
-      # Returns nill if dataset is empty.
+      # Returns nil if dataset is empty.
       def single_value(opts = nil)
         opts = opts ? NAKED_HASH.merge(opts) : NAKED_HASH
-        # reset the columns cache so it won't fuck subsequent calls to columns
+        # don't cache the columns
         each(opts) {|r| @columns = nil; return r.values.first}
         nil
       end
@@ -104,97 +98,27 @@ module Sequel
         end
       end
 
-      # Returns a paginated dataset. The resulting dataset also provides the
-      # total number of pages (Dataset#page_count) and the current page number
-      # (Dataset#current_page), as well as Dataset#prev_page and Dataset#next_page
-      # for implementing pagination controls.
-      def paginate(page_no, page_size)
-        record_count = count
-        total_pages = (record_count / page_size.to_f).ceil
-        paginated = limit(page_size, (page_no - 1) * page_size)
-        paginated.set_pagination_info(page_no, page_size, record_count)
-        paginated
-      end
-      
-      # Sets the pagination info
-      def set_pagination_info(page_no, page_size, record_count)
-        @current_page = page_no
-        @page_size = page_size
-        @pagination_record_count = record_count
-        @page_count = (record_count / page_size.to_f).ceil
-      end
-      
-      def each_page(page_size)
-        record_count = count
-        total_pages = (record_count / page_size.to_f).ceil
-        
-        (1..total_pages).each do |page_no|
-          paginated = limit(page_size, (page_no - 1) * page_size)
-          paginated.set_pagination_info(page_no, page_size, record_count)
-          yield paginated
-        end
-        
-        self
-      end
-
-      attr_accessor :page_size, :page_count, :current_page, :pagination_record_count
-
-      # Returns the previous page number or nil if the current page is the first
-      def prev_page
-        current_page > 1 ? (current_page - 1) : nil
-      end
-
-      # Returns the next page number or nil if the current page is the last page
-      def next_page
-        current_page < page_count ? (current_page + 1) : nil
-      end
-      
-      # Returns the page range
-      def page_range
-        1..page_count
-      end
-      
-      # Returns the record range for the current page
-      def current_page_record_range
-        return (0..0) if @current_page > @page_count
-        
-        a = 1 + (@current_page - 1) * @page_size
-        b = a + @page_size - 1
-        b = @pagination_record_count if b > @pagination_record_count
-        a..b
-      end
-
-      # Returns the number of records in the current page
-      def current_page_record_count
-        return 0 if @current_page > @page_count
-        
-        a = 1 + (@current_page - 1) * @page_size
-        b = a + @page_size - 1
-        b = @pagination_record_count if b > @pagination_record_count
-        b - a + 1
-      end
-
       # Returns the minimum value for the given column.
       def min(column)
-        single_value(:select => [column.MIN.AS(:v)])
+        single_value(:select => [:min[column].as(:v)])
       end
 
       # Returns the maximum value for the given column.
       def max(column)
-        single_value(:select => [column.MAX.AS(:v)])
+        single_value(:select => [:max[column].as(:v)])
       end
 
       # Returns the sum for the given column.
       def sum(column)
-        single_value(:select => [column.SUM.AS(:v)])
+        single_value(:select => [:sum[column].as(:v)])
       end
 
       # Returns the average value for the given column.
       def avg(column)
-        single_value(:select => [column.AVG.AS(:v)])
+        single_value(:select => [:avg[column].as(:v)])
       end
       
-      COUNT_OF_ALL_AS_COUNT = :count['*'.lit].AS(:count)
+      COUNT_OF_ALL_AS_COUNT = :count['*'.lit].as(:count)
       
       # Returns a dataset grouped by the given column with count by group.
       def group_and_count(*columns)
@@ -204,15 +128,17 @@ module Sequel
       # Returns a Range object made from the minimum and maximum values for the
       # given column.
       def range(column)
-        r = select(column.MIN.AS(:v1), column.MAX.AS(:v2)).first
-        r && (r[:v1]..r[:v2])
+        if r = select(:min[column].as(:v1), :max[column].as(:v2)).first
+          (r[:v1]..r[:v2])
+        end
       end
       
       # Returns the interval between minimum and maximum values for the given 
       # column.
       def interval(column)
-        r = select("(max(#{literal(column)}) - min(#{literal(column)})) AS v".lit).first
-        r && r[:v]
+        if r = select("(max(#{literal(column)}) - min(#{literal(column)})) AS v".lit).first
+          r[:v]
+        end
       end
 
       # Pretty prints the records in the dataset as plain-text table.
@@ -227,12 +153,11 @@ module Sequel
       # first line. You can turn that off by passing false as the 
       # include_column_titles argument.
       def to_csv(include_column_titles = true)
-        records = naked.to_a
+        n = naked
+        cols = n.columns
         csv = ''
-        if include_column_titles
-          csv << "#{@columns.join(COMMA_SEPARATOR)}\r\n"
-        end
-        records.each {|r| csv << "#{r.join(COMMA_SEPARATOR)}\r\n"}
+        csv << "#{cols.join(COMMA_SEPARATOR)}\r\n" if include_column_titles
+        n.each{|r| csv << "#{cols.collect{|c| r[c]}.join(COMMA_SEPARATOR)}\r\n"}
         csv
       end
       
@@ -317,49 +242,6 @@ module Sequel
         clone(copy.opts)
       end
       
-      MUTATION_RE = /^(.+)!$/.freeze
-
-      # Provides support for mutation methods (filter!, order!, etc.) and magic
-      # methods.
-      def method_missing(m, *args, &block)
-        if m.to_s =~ MUTATION_RE
-          m = $1.to_sym
-          super unless respond_to?(m)
-          copy = send(m, *args, &block)
-          super if copy.class != self.class
-          @opts.merge!(copy.opts)
-          self
-        elsif magic_method_missing(m)
-          send(m, *args)
-        else
-           super
-        end
-      end
-      
-      MAGIC_METHODS = {
-        /^order_by_(.+)$/   => proc {|c| proc {order(c)}},
-        /^first_by_(.+)$/   => proc {|c| proc {order(c).first}},
-        /^last_by_(.+)$/    => proc {|c| proc {order(c).last}},
-        /^filter_by_(.+)$/  => proc {|c| proc {|v| filter(c => v)}},
-        /^all_by_(.+)$/     => proc {|c| proc {|v| filter(c => v).all}},
-        /^find_by_(.+)$/    => proc {|c| proc {|v| filter(c => v).first}},
-        /^group_by_(.+)$/   => proc {|c| proc {group(c)}},
-        /^count_by_(.+)$/   => proc {|c| proc {group_and_count(c)}}
-      }
-
-      # Checks if the given method name represents a magic method and 
-      # defines it. Otherwise, nil is returned.
-      def magic_method_missing(m)
-        method_name = m.to_s
-        MAGIC_METHODS.each_pair do |r, p|
-          if method_name =~ r
-            impl = p[$1.to_sym]
-            return Dataset.class_def(m, &impl)
-          end
-        end
-        nil
-      end
-      
       def create_view(name)
         @db.create_view(name, self)
       end
@@ -386,4 +268,4 @@ module Sequel
       end
     end
   end
-end
+end

data/lib/sequel_core/dataset/pagination.rb

@@ -0,0 +1,81 @@
+require 'enumerator'
+
+module Sequel
+  class Dataset
+    # Returns a paginated dataset. The resulting dataset also provides the
+    # total number of pages (Dataset#page_count) and the current page number
+    # (Dataset#current_page), as well as Dataset#prev_page and Dataset#next_page
+    # for implementing pagination controls.
+    def paginate(page_no, page_size)
+      raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
+      record_count = count
+      total_pages = (record_count / page_size.to_f).ceil
+      paginated = limit(page_size, (page_no - 1) * page_size)
+      paginated.extend(Pagination)
+      paginated.set_pagination_info(page_no, page_size, record_count)
+      paginated
+    end
+      
+    def each_page(page_size)
+      raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
+      record_count = count
+      total_pages = (record_count / page_size.to_f).ceil
+      
+      (1..total_pages).each do |page_no|
+        paginated = limit(page_size, (page_no - 1) * page_size)
+        paginated.extend(Pagination)
+        paginated.set_pagination_info(page_no, page_size, record_count)
+        yield paginated
+      end
+      
+      self
+    end
+
+    module Pagination
+      attr_accessor :page_size, :page_count, :current_page, :pagination_record_count
+
+      # Sets the pagination info
+      def set_pagination_info(page_no, page_size, record_count)
+        @current_page = page_no
+        @page_size = page_size
+        @pagination_record_count = record_count
+        @page_count = (record_count / page_size.to_f).ceil
+      end
+      
+      # Returns the previous page number or nil if the current page is the first
+      def prev_page
+        current_page > 1 ? (current_page - 1) : nil
+      end
+
+      # Returns the next page number or nil if the current page is the last page
+      def next_page
+        current_page < page_count ? (current_page + 1) : nil
+      end
+      
+      # Returns the page range
+      def page_range
+        1..page_count
+      end
+      
+      # Returns the record range for the current page
+      def current_page_record_range
+        return (0..0) if @current_page > @page_count
+        
+        a = 1 + (@current_page - 1) * @page_size
+        b = a + @page_size - 1
+        b = @pagination_record_count if b > @pagination_record_count
+        a..b
+      end
+
+      # Returns the number of records in the current page
+      def current_page_record_count
+        return 0 if @current_page > @page_count
+        
+        a = 1 + (@current_page - 1) * @page_size
+        b = a + @page_size - 1
+        b = @pagination_record_count if b > @pagination_record_count
+        b - a + 1
+      end
+    end
+  end
+end

data/lib/sequel_core/dataset/sequelizer.rb

@@ -4,7 +4,7 @@ class Sequel::Dataset
   # blocks, e.g.:
   #
   #   DB[:items].filter {:price < 100}
-  #   DB[:items].filter {:category == 'ruby' && :date < 3.days.ago}
+  #   DB[:items].filter {:category == 'ruby' && :date < Date.today - 7}
   #
   # Block filters can refer to literals, variables, constants, arguments, 
   # instance variables or anything else in order to create parameterized 
@@ -20,6 +20,7 @@ class Sequel::Dataset
   #   sudo gem install parsetree
   #   sudo gem install ruby2ruby
   module Sequelizer
+   private
     # Formats an comparison expression involving a left value and a right
     # value. Comparison expressions differ according to the class of the right
     # value. The stock implementation supports Range (inclusive and exclusive),
@@ -311,7 +312,7 @@ class Sequel::Dataset
     
     JOIN_AND = " AND ".freeze
     JOIN_COMMA = ", ".freeze
-    
+  
     def pt_expr(e, b, opts = {}) #:nodoc:
       case e[0]
       when :not # negation: !x, (x != y), (x !~ y)
@@ -346,7 +347,7 @@ end
 
 class Proc
   def to_sql(dataset, opts = {})
-    dataset.pt_expr(to_sexp[2], self.binding, opts)
+    dataset.send(:pt_expr, to_sexp[2], self.binding, opts)
   end
 end
 
@@ -379,4 +380,4 @@ class Proc
     c = Class.new {define_method(:m, &block)}
     ParseTree.translate(c, :m)[2]
   end
-end
+end

data/lib/sequel_core/dataset/sql.rb

@@ -8,8 +8,8 @@ module Sequel
       # behavior.
       def quote_column_ref(name); name.to_s; end
       
-      ALIASED_REGEXP = /^(.*)\s(.*)$/.freeze
-      QUALIFIED_REGEXP = /^(.*)\.(.*)$/.freeze
+      ALIASED_REGEXP = /\A(.*)\s(.*)\z/.freeze
+      QUALIFIED_REGEXP = /\A(.*)\.(.*)\z/.freeze
 
       # Returns a qualified column name (including a table name) if the column
       # name isn't already qualified.
@@ -100,7 +100,7 @@ module Sequel
       # Time (as an SQL TIMESTAMP), Date (as an SQL DATE), Dataset (as a 
       # subquery) and nil (AS NULL).
       # 
-      #   dataset.literal("abc'def") #=> "'abc''def'"
+      #   dataset.literal("abc'def\\") #=> "'abc''def\\\\'"
       #   dataset.literal(:items__id) #=> "items.id"
       #   dataset.literal([1, 2, 3]) => "(1, 2, 3)"
       #   dataset.literal(DB[:items]) => "(SELECT * FROM items)"
@@ -111,7 +111,7 @@ module Sequel
         when LiteralString
           v
         when String
-          "'#{v.gsub(/'/, "''")}'"
+          "'#{v.gsub(/\\/, "\\\\\\\\").gsub(/'/, "''")}'"
         when Integer, Float
           v.to_s
         when BigDecimal
@@ -161,6 +161,7 @@ module Sequel
         end
         parenthesize ? "(#{fmt})" : fmt
       end
+      private :qualified_column_name, :column_list, :table_ref, :source_list, :expression_list
 
       # Returns a copy of the dataset with the source changed.
       def from(*source)
@@ -407,24 +408,18 @@ module Sequel
       }
 
       # Returns a join clause based on the specified join type and condition.
-      def join_expr(type, table, expr)
-        join_type = JOIN_TYPES[type || :inner]
-        unless join_type
-          raise Error::InvalidJoinType, "Invalid join type: #{type}"
-        end
+      def join_expr(type, table, expr, options)
+        raise(Error::InvalidJoinType, "Invalid join type: #{type}") unless join_type = JOIN_TYPES[type || :inner]
         
-        table = table.table_name if table.respond_to?(:table_name)
+        table_alias = options[:table_alias]
 
         join_conditions = {}
         expr.each do |k, v|
-          k = qualified_column_name(k, table) if k.is_a?(Symbol)
+          k = qualified_column_name(k, table_alias || table) if k.is_a?(Symbol)
           v = qualified_column_name(v, @opts[:last_joined_table] || first_source) if v.is_a?(Symbol)
           join_conditions[k] = v
         end
-        if table.is_a?(Dataset)
-          table = "(#{table.sql}) t1"
-        end
-        " #{join_type} #{table} ON #{expression_list(join_conditions)}"
+        " #{join_type} #{table} #{"#{table_alias} " if table_alias}ON #{expression_list(join_conditions)}"
       end
 
       # Returns a joined dataset with the specified join type and condition.
@@ -432,9 +427,20 @@ module Sequel
         unless expr.is_a?(Hash)
           expr = {expr => :id}
         end
-        clause = join_expr(type, table, expr)
-        join = @opts[:join] ? @opts[:join] + clause : clause
-        clone(:join => join, :last_joined_table => table)
+        options = {}
+
+        if Dataset === table
+          table = "(#{table.sql})"
+          table_alias_num = @opts[:num_dataset_joins] || 1
+          options[:table_alias] = "t#{table_alias_num}"
+        elsif table.respond_to?(:table_name)
+          table = table.table_name
+        end
+        
+        clause = join_expr(type, table, expr, options)
+        opts = {:join => @opts[:join] ? @opts[:join] + clause : clause, :last_joined_table => options[:table_alias] || table}
+        opts[:num_dataset_joins] = table_alias_num + 1 if table_alias_num
+        clone(opts)
       end
 
       # Returns a LEFT OUTER joined dataset.
@@ -525,6 +531,11 @@ module Sequel
       end
       alias_method :sql, :select_sql
 
+      # Returns the SQL for formatting an insert statement with default values
+      def insert_default_values_sql
+        "INSERT INTO #{source_list(@opts[:from])} DEFAULT VALUES"
+      end
+
       # Formats an INSERT statement using the given values. If a hash is given,
       # the resulting statement includes column names. If no values are given, 
       # the resulting statement includes a DEFAULT VALUES clause.
@@ -535,7 +546,7 @@ module Sequel
       #     'INSERT INTO items (a, b) VALUES (1, 2)'
       def insert_sql(*values)
         if values.empty?
-          "INSERT INTO #{@opts[:from]} DEFAULT VALUES"
+          insert_default_values_sql
         else
           values = values[0] if values.size == 1
           
@@ -543,32 +554,31 @@ module Sequel
           if @transform && (values.is_a?(Hash) || (values.is_a?(Array) && values.keys))
             values = transform_save(values)
           end
+          from = source_list(@opts[:from])
 
           case values
-          when Sequel::Model
-            insert_sql(values.values)
           when Array
             if values.empty?
-              "INSERT INTO #{@opts[:from]} DEFAULT VALUES"
-            elsif values.keys
-              fl = values.keys.map {|f| literal(f.is_a?(String) ? f.to_sym : f)}
-              vl = values.values.map {|v| literal(v)}
-              "INSERT INTO #{@opts[:from]} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
+              insert_default_values_sql
             else
-              "INSERT INTO #{@opts[:from]} VALUES (#{literal(values)})"
+              "INSERT INTO #{from} VALUES (#{literal(values)})"
             end
           when Hash
             if values.empty?
-              "INSERT INTO #{@opts[:from]} DEFAULT VALUES"
+              insert_default_values_sql
             else
               fl, vl = [], []
               values.each {|k, v| fl << literal(k.is_a?(String) ? k.to_sym : k); vl << literal(v)}
-              "INSERT INTO #{@opts[:from]} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
+              "INSERT INTO #{from} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
             end
           when Dataset
-            "INSERT INTO #{@opts[:from]} #{literal(values)}"
+            "INSERT INTO #{from} #{literal(values)}"
           else
-            "INSERT INTO #{@opts[:from]} VALUES (#{literal(values)})"
+            if values.respond_to?(:values)
+              insert_sql(values.values)
+            else
+              "INSERT INTO #{from} VALUES (#{literal(values)})"
+            end
           end
         end
       end
@@ -599,7 +609,7 @@ module Sequel
           raise Error::InvalidOperation, "A joined dataset cannot be updated"
         end
         
-        sql = "UPDATE #{@opts[:from]} SET "
+        sql = "UPDATE #{source_list(@opts[:from])} SET "
         if block
           sql << block.to_sql(self, :comma_separated => true)
         else
@@ -639,7 +649,7 @@ module Sequel
           raise Error::InvalidOperation, "Joined datasets cannot be deleted from"
         end
 
-        sql = "DELETE FROM #{opts[:from]}"
+        sql = "DELETE FROM #{source_list(opts[:from])}"
 
         if where = opts[:where]
           sql << " WHERE #{where}"