sequel 4.1.1 → 4.2.0

data/lib/sequel/dataset/misc.rb

@@ -40,6 +40,13 @@ module Sequel
     def eql?(o)
       self == o
     end
+
+    # Similar to #clone, but returns an unfrozen clone if the receiver is frozen.
+    def dup
+      o = clone
+      o.opts.delete(:frozen)
+      o
+    end
     
     # Yield a dataset for each server in the connection pool that is tied to that server.
     # Intended for use in sharded environments where all servers need to be modified
@@ -58,6 +65,17 @@ module Sequel
     def escape_like(string)
       string.gsub(/[\\%_]/){|m| "\\#{m}"}
     end
+
+    # Sets the frozen flag on the dataset, so you can't modify it. Returns the receiver.
+    def freeze
+      @opts[:frozen] = true
+      self
+    end
+
+    # Whether the object is frozen.
+    def frozen?
+      @opts[:frozen]
+    end
    
     # Alias of +first_source_alias+
     def first_source
@@ -142,9 +160,7 @@ module Sequel
     # Returns a string representation of the dataset including the class name 
     # and the corresponding SQL select statement.
     def inspect
-      c = self.class
-      c = c.superclass while c.name.nil? || c.name == ''
-      "#<#{c.name}: #{sql.inspect}>"
+      "#<#{visible_class_name}: #{sql.inspect}>"
     end
     
     # The alias to use for the row_number column, used when emulating OFFSET
@@ -207,5 +223,14 @@ module Sequel
         table_alias
       end
     end
+
+    private
+
+    # Return the class name for this dataset, but skip anonymous classes
+    def visible_class_name
+      c = self.class
+      c = c.superclass while c.name.nil? || c.name == ''
+      c.name
+    end
   end
 end

data/lib/sequel/dataset/mutation.rb

@@ -6,7 +6,7 @@ module Sequel
     # ---------------------
     
     # All methods that should have a ! method added that modifies the receiver.
-    MUTATION_METHODS = QUERY_METHODS - [:paginate, :naked, :from_self]
+    MUTATION_METHODS = QUERY_METHODS - [:naked, :from_self]
     
     # Setup mutation (e.g. filter!) methods.  These operate the same as the
     # non-! methods, but replace the options of the current dataset with the
@@ -26,18 +26,9 @@ module Sequel
     # Add the mutation methods via metaprogramming
     def_mutation_method(*MUTATION_METHODS)
     
-    # Set the method to call on identifiers going into the database for this dataset
-    attr_writer :identifier_input_method
-    
-    # Set the method to call on identifiers coming the database for this dataset
-    attr_writer :identifier_output_method
-
-    # Whether to quote identifiers for this dataset
-    attr_writer :quote_identifiers
-    
     # The row_proc for this database, should be any object that responds to +call+ with
     # a single hash argument and returns the object you want #each to return.
-    attr_accessor :row_proc
+    attr_reader :row_proc
     
     # Load an extension into the receiver.  In addition to requiring the extension file, this
     # also modifies the dataset to work with the extension (usually extending it with a
@@ -45,6 +36,7 @@ module Sequel
     # extension does not have specific support for Database objects, an Error will be raised.
     # Returns self.
     def extension!(*exts)
+      raise_if_frozen!
       Sequel.extension(*exts)
       exts.each do |ext|
         if pr = Sequel.synchronize{EXTENSIONS[ext]}
@@ -58,24 +50,58 @@ module Sequel
 
     # Avoid self-referential dataset by cloning.
     def from_self!(*args, &block)
+      raise_if_frozen!
       @opts = clone.from_self(*args, &block).opts
       self
     end
 
+    # Set the method to call on identifiers going into the database for this dataset
+    def identifier_input_method=(v)
+      raise_if_frozen!
+      @identifier_input_method = v
+    end
+    
+    # Set the method to call on identifiers coming the database for this dataset
+    def identifier_output_method=(v)
+      raise_if_frozen!
+      @identifier_output_method = v
+    end
+
     # Remove the row_proc from the current dataset.
     def naked!
+      raise_if_frozen!
       self.row_proc = nil
       self
     end
     
+    # Set whether to quote identifiers for this dataset
+    def quote_identifiers=(v)
+      raise_if_frozen!
+      @quote_identifiers = v
+    end
+
+    # Override the row_proc for this dataset
+    def row_proc=(v)
+      raise_if_frozen!
+      @row_proc = v
+    end
+    
     private
     
     # Modify the receiver with the results of sending the meth, args, and block
     # to the receiver and merging the options of the resulting dataset into
     # the receiver's options.
     def mutation_method(meth, *args, &block)
+      raise_if_frozen!
       @opts = send(meth, *args, &block).opts
       self
     end
+
+    # Raise a RuntimeError if the receiver is frozen
+    def raise_if_frozen!
+      if frozen?
+        raise RuntimeError, "can't modify frozen #{visible_class_name}"
+      end
+    end
   end
 end

data/lib/sequel/dataset/prepared_statements.rb

@@ -118,9 +118,7 @@ module Sequel
       # with the prepared SQL it represents (which in general won't have
       # substituted variables).
       def inspect
-        c = self.class
-        c = c.superclass while c.name.nil? || c.name == ''
-        "<#{c.name}/PreparedStatement #{prepared_sql.inspect}>"
+        "<#{visible_class_name}/PreparedStatement #{prepared_sql.inspect}>"
       end
       
       protected

data/lib/sequel/dataset/query.rb

@@ -36,12 +36,11 @@ module Sequel
     QUERY_METHODS = (<<-METHS).split.map{|x| x.to_sym} + JOIN_METHODS
       add_graph_aliases and distinct except exclude exclude_having exclude_where
       filter for_update from from_self graph grep group group_and_count group_by having intersect invert
-      limit lock_style naked or order order_append order_by order_more order_prepend paginate qualify query
+      limit lock_style naked or order order_append order_by order_more order_prepend qualify
       reverse reverse_order select select_all select_append select_group select_more server
-      set_defaults set_graph_aliases set_overrides unfiltered ungraphed ungrouped union
+      set_graph_aliases unfiltered ungraphed ungrouped union
       unlimited unordered where with with_recursive with_sql
     METHS
-    # REMOVE40: query paginate set_defaults set_overrides
 
     # Register an extension callback for Dataset objects.  ext should be the
     # extension name symbol, and mod should either be a Module that the
@@ -501,6 +500,16 @@ module Sequel
       class_eval("def #{jtype}_join(table); raise(Sequel::Error, '#{jtype}_join does not accept join table blocks') if block_given?; join_table(:#{jtype}, table) end", __FILE__, __LINE__)
     end
 
+    # Marks this dataset as a lateral dataset.  If used in another dataset's FROM
+    # or JOIN clauses, it will surround the subquery with LATERAL to enable it
+    # to deal with previous tables in the query:
+    #
+    #   DB.from(:a, DB[:b].where(:a__c=>:b__d).lateral)
+    #   # SELECT * FROM a, LATERAL (SELECT * FROM b WHERE (a.c = b.d))
+    def lateral
+      clone(:lateral=>true)
+    end
+
     # If given an integer, the dataset will contain only the first l results.
     # If given a range, it will contain only those at offsets within that
     # range. If a second argument is given, it is used as an offset. To use

data/lib/sequel/dataset/sql.rb

@@ -242,6 +242,7 @@ module Sequel
     INTO = " INTO ".freeze
     IS_LITERALS = {nil=>'NULL'.freeze, true=>'TRUE'.freeze, false=>'FALSE'.freeze}.freeze
     IS_OPERATORS = ::Sequel::SQL::ComplexExpression::IS_OPERATORS
+    LATERAL = 'LATERAL '.freeze
     LIKE_OPERATORS = ::Sequel::SQL::ComplexExpression::LIKE_OPERATORS
     LIMIT = " LIMIT ".freeze
     N_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::N_ARITY_OPERATORS
@@ -533,12 +534,16 @@ module Sequel
       str = pls.str
       sql << PAREN_OPEN if pls.parens
       if args.is_a?(Hash)
-        re = /:(#{args.keys.map{|k| Regexp.escape(k.to_s)}.join('|')})\b/
-        loop do
-          previous, q, str = str.partition(re)
-          sql << previous
-          literal_append(sql, args[($1||q[1..-1].to_s).to_sym]) unless q.empty?
-          break if str.empty?
+        if args.empty?
+          sql << str
+        else
+          re = /:(#{args.keys.map{|k| Regexp.escape(k.to_s)}.join('|')})\b/
+          loop do
+            previous, q, str = str.partition(re)
+            sql << previous
+            literal_append(sql, args[($1||q[1..-1].to_s).to_sym]) unless q.empty?
+            break if str.empty?
+          end
         end
       elsif str.is_a?(Array)
         len = args.length
@@ -1043,6 +1048,7 @@ module Sequel
 
     # SQL fragment for Dataset.  Does a subselect inside parantheses.
     def literal_dataset_append(sql, v)
+      sql << LATERAL if v.opts[:lateral]
       sql << PAREN_OPEN
       subselect_sql_append(sql, v)
       sql << PAREN_CLOSE

data/lib/sequel/deprecated.rb

@@ -37,7 +37,7 @@ module Sequel
     # Print the message and possibly backtrace to the output.
     def self.deprecate(method, instead=nil)
       return unless output
-      message = instead ? "#{method} is deprecated and will be removed in Sequel 4.0.  #{instead}." : method
+      message = instead ? "#{method} is deprecated and will be removed in a future version of Sequel.  #{instead}." : method
       message = "#{prefix}#{message}" if prefix
       output.puts(message)
       case b = backtrace_filter

data/lib/sequel/extensions/columns_introspection.rb

@@ -9,7 +9,7 @@
 #
 # To attempt to introspect columns for a single dataset:
 #
-#   ds.extension(:columns_introspection)
+#   ds = ds.extension(:columns_introspection)
 #
 # To attempt to introspect columns for all datasets on a single database:
 #

data/lib/sequel/extensions/core_extensions.rb

@@ -48,8 +48,6 @@ class Array
   def sql_value_list
     ::Sequel::SQL::ValueList.new(self)
   end
-  
-  # Deprecated alias for sql_value_list
   alias sql_array sql_value_list
 
   # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching all of the

data/lib/sequel/extensions/empty_array_ignore_nulls.rb

@@ -13,7 +13,7 @@
 # You can load this extension into specific datasets:
 #
 #   ds = DB[:table]
-#   ds.extension(:empty_array_ignore_nulls)
+#   ds = ds.extension(:empty_array_ignore_nulls)
 #
 # Or you can load it into all of a database's datasets, which
 # is probably the desired behavior if you are using this extension:

data/lib/sequel/extensions/filter_having.rb

@@ -7,7 +7,7 @@
 # You can load this extension into specific datasets:
 #
 #   ds = DB[:table]
-#   ds.extension(:filter_having)
+#   ds = ds.extension(:filter_having)
 #
 # Or you can load it into all of a database's datasets, which
 # is probably the desired behavior if you are using this extension:

data/lib/sequel/extensions/from_block.rb

@@ -0,0 +1,31 @@
+# The from_block extension changes Database#from so that blocks given
+# to it are treated as virtual rows applying to the FROM clause,
+# instead of virtual rows applying to the WHERE clause.  This will
+# probably be made the default in the next major version of Sequel.
+#
+# This makes it easier to use table returning functions:
+#
+#   DB.from{table_function(1)}
+#   # SELECT * FROM table_function(1)
+#
+# To load the extension into the database:
+#
+#   DB.extension :from_block
+
+module Sequel
+  module Database::FromBlock
+    # If a block is given, make it affect the FROM clause:
+    #   DB.from{table_function(1)}
+    #   # SELECT * FROM table_function(1)
+    def from(*args, &block)
+      if block
+        @default_dataset.from(*args, &block)
+      else
+        super
+      end
+    end
+  end
+
+  Database.register_extension(:from_block, Database::FromBlock)
+end
+

data/lib/sequel/extensions/graph_each.rb

@@ -8,7 +8,7 @@
 # You can load this extension into specific datasets:
 #
 #   ds = DB[:table]
-#   ds.extension(:graph_each)
+#   ds = ds.extension(:graph_each)
 #
 # Or you can load it into all of a database's datasets, which
 # is probably the desired behavior if you are using this extension:

data/lib/sequel/extensions/hash_aliases.rb

@@ -7,7 +7,7 @@
 # You can load this extension into specific datasets:
 #
 #   ds = DB[:table]
-#   ds.extension(:hash_aliases)
+#   ds = ds.extension(:hash_aliases)
 #
 # Or you can load it into all of a database's datasets, which
 # is probably the desired behavior if you are using this extension:

data/lib/sequel/extensions/mssql_emulate_lateral_with_apply.rb

@@ -0,0 +1,78 @@
+# The mssql_emulate_lateral_with_apply extension converts
+# queries that use LATERAL into queries that use CROSS/OUTER
+# APPLY, allowing code that works on databases that support
+# LATERAL via Dataset#lateral to run on Microsoft SQL Server.
+#
+# This is available as a separate extension instead of
+# integrated into the Microsoft SQL Server support because
+# few people need it and there is a performance hit to
+# code that doesn't use it.
+#
+# It is possible there are cases where this emulation does
+# not work.  Users should probably verify that correct
+# results are returned when using this extension.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:mssql_emulate_lateral_with_apply)
+#
+# Or you can load it into all of a database's datasets:
+#
+#   DB.extension(:mssql_emulate_lateral_with_apply)
+
+module Sequel
+  module MSSQL
+    module EmulateLateralWithApply
+      # If the table is a dataset that uses LATERAL,
+      # convert it to a CROSS APPLY if it is a INNER
+      # or CROSS JOIN, and an OUTER APPLY if it is a
+      # LEFT JOIN.
+      def join_table(type, table, expr=nil, *)
+        if table.is_a?(Dataset) && table.opts[:lateral]
+          table = table.clone(:lateral=>nil)
+          case type
+          when :inner
+            type = :cross_apply
+            table = table.where(expr)
+            expr = nil
+          when :cross
+            type = :cross_apply
+          when :left, :left_outer
+            type = :outer_apply
+            table = table.where(expr)
+            expr = nil
+          end
+        end
+        super
+      end
+
+      # When a FROM entry uses a LATERAL subquery,
+      # convert that entry into a CROSS APPLY.
+      def from(*source, &block)
+        virtual_row_columns(source, block)
+        lateral, source = source.partition{|t| t.is_a?(Sequel::Dataset) && t.opts[:lateral] || (t.is_a?(Sequel::SQL::AliasedExpression) && t.expression.is_a?(Sequel::Dataset) && t.expression.opts[:lateral])} unless source.empty?
+        return super(*source, &nil) if !lateral || lateral.empty?
+
+        ds = from(*source)
+        lateral.each do |l|
+          l = if l.is_a?(Sequel::SQL::AliasedExpression)
+            l.expression.clone(:lateral=>nil).as(l.aliaz)
+          else
+            l.clone(:lateral=>nil)
+          end
+          ds = ds.cross_apply(l)
+        end
+        ds
+      end
+      
+      # MSSQL can emulate lateral subqueries via CROSS/OUTER APPLY
+      # when using this extension.
+      def supports_lateral_subqueries?
+        true
+      end
+    end
+  end
+
+  Dataset.register_extension(:mssql_emulate_lateral_with_apply, MSSQL::EmulateLateralWithApply)
+end

data/lib/sequel/extensions/pagination.rb

@@ -7,7 +7,7 @@
 # You can load this extension into specific datasets:
 #
 #   ds = DB[:table]
-#   ds.extension(:pagination)
+#   ds = ds.extension(:pagination)
 #
 # Or you can load it into all of a database's datasets, which
 # is probably the desired behavior if you are using this extension:

data/lib/sequel/extensions/pg_loose_count.rb

@@ -0,0 +1,32 @@
+# The pg_loose_count extension looks at the table statistics
+# in the PostgreSQL system tables to get a fast approximate
+# count of the number of rows in a given table:
+#
+#   DB.loose_count(:table) # => 123456
+#
+# It can also support schema qualified tables:
+#
+#   DB.loose_count(:schema__table) # => 123456
+#
+# How accurate this count is depends on the number of rows
+# added/deleted from the table since the last time it was
+# analyzed.
+# 
+# To load the extension into the database:
+#
+#   DB.extension :pg_loose_count
+
+module Sequel
+  module Postgres
+    module LooseCount
+      # Look at the table statistics for the given table to get
+      # an approximate count of the number of rows.
+      def loose_count(table)
+        from(:pg_class).where(:oid=>regclass_oid(table)).get(Sequel.cast(:reltuples, Integer))
+      end
+    end
+  end
+
+  Database.register_extension(:pg_loose_count, Postgres::LooseCount)
+end
+