sequel 4.41.0 → 4.42.0

data/lib/sequel/database/features.rb

@@ -115,6 +115,12 @@ module Sequel
       true
     end
 
+    # Whether this dataset considers unquoted identifiers as uppercase. True
+    # by default as that is the SQL standard
+    def folds_unquoted_identifiers_to_uppercase?
+      true
+    end
+    
     # Whether the database supports combining multiple alter table
     # operations into a single query, false by default.
     def supports_combining_alter_table_ops?

data/lib/sequel/database/misc.rb

@@ -30,7 +30,10 @@ module Sequel
     # included in the database, the identifier mangling defaults are reset correctly.
     module ResetIdentifierMangling
       def extended(obj)
-        obj.send(:reset_identifier_mangling)
+        # :nocov:
+        Sequel::Deprecation.deprecate("Sequel::Database::ResetIdentifierMangling is no longer needed and will be removed in Sequel 5.  Please update your adapter.")
+        obj.send(:reset_identifier_mangling) if obj.respond_to?(:reset_identifier_mangling)
+        # :nocov:
       end
     end
 
@@ -104,8 +107,7 @@ module Sequel
     #
     # Accepts the following options:
     # :default_string_column_size :: The default size of string columns, 255 by default.
-    # :identifier_input_method :: A string method symbol to call on identifiers going into the database.
-    # :identifier_output_method :: A string method symbol to call on identifiers coming from the database.
+    # :identifier_mangling :: Whether to support non-default identifier mangling for the current database.
     # :logger :: A specific logger to use.
     # :loggers :: An array of loggers to use.
     # :name :: A name to use for the Database object.
@@ -131,9 +133,6 @@ module Sequel
       @transactions = {}
       @symbol_literal_cache = {}
 
-      @identifier_input_method = nil
-      @identifier_output_method = nil
-      @quote_identifiers = nil
       @timezone = nil
 
       @dataset_class = dataset_class_default
@@ -147,8 +146,11 @@ module Sequel
 
       @pool = ConnectionPool.get_pool(self, @opts)
 
-      reset_identifier_mangling
+      reset_default_dataset
       adapter_initialize
+      if typecast_value_boolean(@opts.fetch(:identifier_mangling, true))
+        extension(:identifier_mangling)
+      end
 
       unless typecast_value_boolean(@opts[:keep_reference]) == false
         Sequel.synchronize{::Sequel::DATABASES.push(self)}
@@ -248,7 +250,6 @@ module Sequel
 
     # Cache the prepared statement object at the given name.
     def set_prepared_statement(name, ps)
-      ps.prepared_sql
       Sequel.synchronize{prepared_statements[name] = ps}
     end
 
@@ -429,15 +430,15 @@ module Sequel
     def typecast_value_datetime(value)
       Sequel.typecast_to_application_timestamp(value)
     end
-
-    # Typecast the value to a BigDecimal
-    def typecast_value_decimal(value)
-      case value
-      when BigDecimal
-        value
-      when Numeric
-        BigDecimal.new(value.to_s)
-      when String
+    
+    if RUBY_VERSION >= '2.4'
+      # Typecast a string to a BigDecimal
+      def _typecast_value_string_to_decimal(value)
+        BigDecimal.new(value)
+      end
+    else
+      # :nocov:
+      def _typecast_value_string_to_decimal(value)
         d = BigDecimal.new(value)
         if d.zero?
           # BigDecimal parsing is loose by default, returning a 0 value for
@@ -450,6 +451,19 @@ module Sequel
           end
         end
         d
+      end
+      # :nocov:
+    end
+
+    # Typecast the value to a BigDecimal
+    def typecast_value_decimal(value)
+      case value
+      when BigDecimal
+        value
+      when Numeric
+        BigDecimal.new(value.to_s)
+      when String
+        _typecast_value_string_to_decimal(value)
       else
         raise InvalidValue, "invalid value for BigDecimal: #{value.inspect}"
       end

data/lib/sequel/database/query.rb

@@ -32,7 +32,7 @@ module Sequel
     # Call the prepared statement with the given name with the given hash
     # of arguments.
     #
-    #   DB[:items].filter(:id=>1).prepare(:first, :sa)
+    #   DB[:items].where(:id=>1).prepare(:first, :sa)
     #   DB.call(:sa) # SELECT * FROM items WHERE id = 1
     def call(ps_name, hash={}, &block)
       prepared_statement(ps_name).call(hash, &block)
@@ -287,13 +287,16 @@ module Sequel
       (ds || dataset).method(:input_identifier)
     end
     
+    # Uncached version of metadata_dataset, designed for overriding.
+    def _metadata_dataset
+      dataset
+    end
+
     # Return a dataset that uses the default identifier input and output methods
     # for this database.  Used when parsing metadata so that column symbols are
     # returned as expected.
     def metadata_dataset
-      @metadata_dataset ||= dataset.
-        with_identifier_input_method(identifier_input_method_default).
-        with_identifier_output_method(identifier_output_method_default)
+      @metadata_dataset ||= _metadata_dataset
     end
 
     # Return a Method object for the dataset's output_identifier_method.

data/lib/sequel/database/schema_methods.rb

@@ -235,7 +235,7 @@ module Sequel
     # Creates a view, replacing a view with the same name if one already exists.
     #
     #   DB.create_or_replace_view(:some_items, "SELECT * FROM items WHERE price < 100")
-    #   DB.create_or_replace_view(:some_items, DB[:items].filter(:category => 'ruby'))
+    #   DB.create_or_replace_view(:some_items, DB[:items].where(:category => 'ruby'))
     #
     # For databases where replacing a view is not natively supported, support
     # is emulated by dropping a view with the same name before creating the view.

data/lib/sequel/dataset.rb

@@ -8,7 +8,7 @@ module Sequel
   # Query results are always retrieved on demand, so a dataset can be kept
   # around and reused indefinitely (datasets never cache results):
   #
-  #   my_posts = DB[:posts].filter(:author => 'david') # no records are retrieved
+  #   my_posts = DB[:posts].where(:author => 'david') # no records are retrieved
   #   my_posts.all # records are retrieved
   #   my_posts.all # records are retrieved again
   #
@@ -16,9 +16,9 @@ module Sequel
   # reuse different datasets to access data:
   #
   #   posts = DB[:posts]
-  #   davids_posts = posts.filter(:author => 'david')
-  #   old_posts = posts.filter('stamp < ?', Date.today - 7)
-  #   davids_old_posts = davids_posts.filter('stamp < ?', Date.today - 7)
+  #   davids_posts = posts.where(:author => 'david')
+  #   old_posts = posts.where('stamp < ?', Date.today - 7)
+  #   davids_old_posts = davids_posts.where('stamp < ?', Date.today - 7)
   #
   # Datasets are Enumerable objects, so they can be manipulated using any
   # of the Enumerable methods, such as map, inject, etc.
@@ -27,6 +27,10 @@ module Sequel
   class Dataset
     OPTS = Sequel::OPTS
 
+    # Whether Dataset#freeze can actually freeze datasets.  True only on ruby 2.4+,
+    # as it requires clone(freeze: false)
+    TRUE_FREEZE = RUBY_VERSION >= '2.4'
+
     include Enumerable
     include SQL::AliasMethods
     include SQL::BooleanMethods
@@ -36,10 +40,6 @@ module Sequel
     include SQL::NumericMethods
     include SQL::OrderMethods
     include SQL::StringMethods
-
-    private
-
-    attr_writer :columns
   end
   
   require(%w"query actions features graph prepared_statements misc mutation sql placeholder_literalizer", 'dataset')

data/lib/sequel/dataset/actions.rb

@@ -17,6 +17,9 @@ module Sequel
       single_record single_record! single_value single_value! sum to_hash to_hash_groups truncate update
     METHS
 
+    # The clone options to use when retriveing columns for a dataset.
+    COLUMNS_CLONE_OPTIONS = {:distinct => nil, :limit => 1, :offset=>nil, :where=>nil, :having=>nil, :order=>nil, :row_proc=>nil, :graph=>nil, :eager_graph=>nil}.freeze
+
     # Inserts the given argument into the database.  Returns self so it
     # can be used safely when chaining:
     # 
@@ -54,8 +57,8 @@ module Sequel
     #   # => 3
     #   DB[:table].avg{function(column)} # SELECT avg(function(column)) FROM table LIMIT 1
     #   # => 1
-    def avg(column=Sequel.virtual_row(&Proc.new))
-      aggregate_dataset.get{avg(column).as(:avg)}
+    def avg(arg=Sequel.virtual_row(&Proc.new))
+      _aggregate(:avg, arg)
     end
   
     # Returns the columns in the result set in order as an array of symbols.
@@ -68,11 +71,7 @@ module Sequel
     #   DB[:table].columns
     #   # => [:id, :name]
     def columns
-      return @columns if @columns
-      ds = unfiltered.unordered.naked.clone(:distinct => nil, :limit => 1, :offset=>nil)
-      ds.each{break}
-      @columns = ds.instance_variable_get(:@columns)
-      @columns || []
+      _columns || columns!
     end
         
     # Ignore any cached column information and perform a query to retrieve
@@ -81,8 +80,14 @@ module Sequel
     #   DB[:table].columns!
     #   # => [:id, :name]
     def columns!
-      self.columns = nil
-      columns
+      ds = clone(COLUMNS_CLONE_OPTIONS)
+      ds.each{break}
+
+      if cols = ds.cache[:_columns]
+        self.columns = cols
+      else
+        []
+      end
     end
     
     # Returns the number of records in the dataset. If an argument is provided,
@@ -97,20 +102,23 @@ module Sequel
     #   DB[:table].count{foo(column)} # SELECT count(foo(column)) AS count FROM table LIMIT 1
     #   # => 1
     def count(arg=(no_arg=true), &block)
-      if no_arg
+      if no_arg && !block
+        cached_dataset(:_count_ds) do
+          aggregate_dataset.select{count{}.*.as(:count)}.single_value_ds
+        end.single_value!.to_i
+      else
         if block
-          arg = Sequel.virtual_row(&block)
-          aggregate_dataset.get{count(arg).as(:count)}
-        else
-          aggregate_dataset.get{count{}.*.as(:count)}.to_i
+          if no_arg
+            arg = Sequel.virtual_row(&block)
+          else
+            raise Error, 'cannot provide both argument and block to Dataset#count'
+          end
         end
-      elsif block
-        raise Error, 'cannot provide both argument and block to Dataset#count'
-      else
-        aggregate_dataset.get{count(arg).as(:count)}
+
+        _aggregate(:count, arg)
       end
     end
-    
+
     # Deletes the records in the dataset.  The returned value should be 
     # number of records deleted, but that is adapter dependent.
     #
@@ -148,8 +156,9 @@ module Sequel
     #   DB[:table].empty? # SELECT 1 AS one FROM table LIMIT 1
     #   # => false
     def empty?
-      ds = @opts[:order] ? unordered : self
-      ds.get(Sequel::SQL::AliasedExpression.new(1, :one)).nil?
+      cached_dataset(:_empty_ds) do
+        single_value_ds.unordered.select(Sequel::SQL::AliasedExpression.new(1, :one))
+      end.single_value!.nil?
     end
 
     # If a integer argument is given, it is interpreted as a limit, and then returns all 
@@ -188,17 +197,46 @@ module Sequel
     #   DB[:table].first(2){id < 2} # SELECT * FROM table WHERE (id < 2) LIMIT 2
     #   # => [{:id=>1}]
     def first(*args, &block)
-      ds = block ? filter(&block) : self
+      case args.length
+      when 0
+        unless block
+          return single_record
+        end
+      when 1
+        arg = args[0]
+        if arg.is_a?(Integer)
+          res = if block
+            if loader = cached_placeholder_literalizer(:_first_integer_cond_loader) do |pl|
+                where(pl.arg).limit(pl.arg)
+              end
 
-      if args.empty?
-        ds.single_record
-      else
-        args = (args.size == 1) ? args.first : args
-        if args.is_a?(Integer)
-          ds.limit(args).all
-        else
-          ds.filter(args).single_record
+              loader.all(filter_expr(&block), arg)
+            else
+              where(&block).limit(arg).all
+            end
+          else
+            if loader = cached_placeholder_literalizer(:_first_integer_loader) do |pl|
+               limit(pl.arg)
+              end
+
+              loader.all(arg)
+            else
+              limit(arg).all
+            end
+          end
+
+          return res
         end
+        args = arg
+      end
+
+      if loader = cached_placeholder_literalizer(:_first_cond_loader) do |pl|
+          _single_record_ds.where(pl.arg)
+        end
+
+        loader.first(filter_expr(args, &block))
+      else
+        _single_record_ds.where(args, &block).single_record!
       end
     end
 
@@ -234,10 +272,27 @@ module Sequel
         column = ds.opts[:select]
         column = nil if column.is_a?(Array) && column.length < 2
       else
-        ds = if column.is_a?(Array)
-          ds.select(*column)
+        case column
+        when Array
+          ds = ds.select(*column)
+        when LiteralString, Symbol, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression
+          if loader = cached_placeholder_literalizer(:_get_loader) do |pl|
+              ds.single_value_ds.select(pl.arg)
+            end
+
+            return loader.get(column)
+          end
+
+          ds = ds.select(column)
         else
-          ds.select(auto_alias_expression(column))
+          if loader = cached_placeholder_literalizer(:_get_alias_loader) do |pl|
+              ds.single_value_ds.select(Sequel.as(pl.arg, :v))
+            end
+
+            return loader.get(column)
+          end
+
+          ds = ds.select(Sequel.as(column, :v))
         end
       end
 
@@ -347,7 +402,15 @@ module Sequel
     #   DB[:table].interval{function(column)} # SELECT (max(function(column)) - min(function(column))) FROM table LIMIT 1
     #   # => 7
     def interval(column=Sequel.virtual_row(&Proc.new))
-      aggregate_dataset.get{(max(column) - min(column)).as(:interval)}
+      if loader = cached_placeholder_literalizer(:_interval_loader) do |pl|
+          arg = pl.arg
+          aggregate_dataset.limit(1).select((SQL::Function.new(:max, arg) - SQL::Function.new(:min, arg)).as(:interval))
+        end
+
+        loader.get(column)
+      else
+        aggregate_dataset.get{(max(column) - min(column)).as(:interval)}
+      end
     end
 
     # Reverses the order and then runs #first with the given arguments and block.  Note that this
@@ -400,8 +463,8 @@ module Sequel
     #   # => 10
     #   DB[:table].max{function(column)} # SELECT max(function(column)) FROM table LIMIT 1
     #   # => 7
-    def max(column=Sequel.virtual_row(&Proc.new))
-      aggregate_dataset.get{max(column).as(:max)}
+    def max(arg=Sequel.virtual_row(&Proc.new))
+      _aggregate(:max, arg)
     end
 
     # Returns the minimum value for the given column/expression.
@@ -411,8 +474,8 @@ module Sequel
     #   # => 1
     #   DB[:table].min{function(column)} # SELECT min(function(column)) FROM table LIMIT 1
     #   # => 0
-    def min(column=Sequel.virtual_row(&Proc.new))
-      aggregate_dataset.get{min(column).as(:min)}
+    def min(arg=Sequel.virtual_row(&Proc.new))
+      _aggregate(:min, arg)
     end
 
     # This is a front end for import that allows you to submit an array of
@@ -552,7 +615,17 @@ module Sequel
     #   DB[:table].interval{function(column)} # SELECT max(function(column)) AS v1, min(function(column)) AS v2 FROM table LIMIT 1
     #   # => 0..7
     def range(column=Sequel.virtual_row(&Proc.new))
-      if r = aggregate_dataset.select{[min(column).as(v1), max(column).as(v2)]}.first
+      r = if loader = cached_placeholder_literalizer(:_range_loader) do |pl|
+            arg = pl.arg
+            aggregate_dataset.limit(1).select(SQL::Function.new(:min, arg).as(:v1), SQL::Function.new(:max, arg).as(:v2))
+          end
+
+        loader.first(column)
+      else
+        aggregate_dataset.select{[min(column).as(v1), max(column).as(v2)]}.first
+      end
+
+      if r
         (r[:v1]..r[:v2])
       end
     end
@@ -649,7 +722,7 @@ module Sequel
     #   DB[:test].single_record # SELECT * FROM test LIMIT 1
     #   # => {:column_name=>'value'}
     def single_record
-      clone(:limit=>1).single_record!
+      _single_record_ds.single_record!
     end
 
     # Returns the first record in dataset, without limiting the dataset. Returns nil if
@@ -671,9 +744,10 @@ module Sequel
     #   DB[:test].single_value # SELECT * FROM test LIMIT 1
     #   # => 'value'
     def single_value
-      if r = ungraphed.naked.single_record
+      single_value_ds.each do |r|
         r.each{|_, v| return v}
       end
+      nil
     end
 
     # Returns the first value of the first record in the dataset, without limiting the dataset.
@@ -695,8 +769,8 @@ module Sequel
     #   # => 55
     #   DB[:table].sum{function(column)} # SELECT sum(function(column)) FROM table LIMIT 1
     #   # => 10
-    def sum(column=Sequel.virtual_row(&Proc.new))
-      aggregate_dataset.get{sum(column).as(:sum)}
+    def sum(arg=Sequel.virtual_row(&Proc.new))
+      _aggregate(:sum, arg)
     end
 
     # Returns a hash with one column used as key and another used as value.
@@ -902,6 +976,11 @@ module Sequel
       map{|r| r.values.first}
     end
   
+    # A dataset for returning single values from the current dataset.
+    def single_value_ds
+      clone(:limit=>1).ungraphed.naked
+    end
+    
     private
     
     # Internals of all and with_sql_all
@@ -913,6 +992,17 @@ module Sequel
       a
     end
     
+    # Cached placeholder literalizer for methods that return values using aggregate functions.
+    def _aggregate(function, arg)
+      if loader = cached_placeholder_literalizer(:"_#{function}_loader") do |pl|
+            aggregate_dataset.limit(1).select(SQL::Function.new(function, pl.arg).as(function))
+          end
+        loader.get(arg)
+      else
+        aggregate_dataset.get(SQL::Function.new(function, arg).as(function))
+      end
+    end
+    
     # Internals of +select_hash+ and +select_hash_groups+
     def _select_hash(meth, key_column, value_column, opts=OPTS)
       select(*(key_column.is_a?(Array) ? key_column : [key_column]) + (value_column.is_a?(Array) ? value_column : [value_column])).
@@ -933,6 +1023,11 @@ module Sequel
       end
     end
 
+    # A cached dataset for a single record for this dataset.
+    def _single_record_ds
+      cached_dataset(:_single_record_ds){clone(:limit=>1)}
+    end
+
     # Automatically alias the given expression if it does not have an identifiable alias.
     def auto_alias_expression(v)
       case v
@@ -1052,11 +1147,10 @@ module Sequel
       Sequel.|(*cond)
     end
 
-    # Modify the identifier returned from the database based on the
-    # identifier_output_method.
+    # Downcase identifiers by default when outputing them from the database.
     def output_identifier(v)
       v = 'untitled' if v == ''
-      (i = identifier_output_method) ? v.to_s.send(i).to_sym : v.to_sym
+      v.to_s.downcase.to_sym
     end
     
     # This is run inside .all, after all of the records have been loaded