sequel 4.41.0 → 4.42.0

data/lib/sequel/dataset/features.rb

@@ -10,11 +10,7 @@ module Sequel
     
     # Whether this dataset quotes identifiers.
     def quote_identifiers?
-      if defined?(@quote_identifiers)
-        @quote_identifiers
-      else
-        @quote_identifiers = db.quote_identifiers?
-      end
+      @opts.fetch(:quote_identifiers, true)
     end
     
     # Whether this dataset will provide accurate number of rows matched for

data/lib/sequel/dataset/graph.rb

@@ -11,7 +11,7 @@ module Sequel
     
     # Adds the given graph aliases to the list of graph aliases to use,
     # unlike +set_graph_aliases+, which replaces the list (the equivalent
-    # of +select_more+ when graphing).  See +set_graph_aliases+.
+    # of +select_append+ when graphing).  See +set_graph_aliases+.
     #
     #   DB[:table].add_graph_aliases(:some_alias=>[:table, :column])
     #   # SELECT ..., table.column AS some_alias
@@ -20,7 +20,7 @@ module Sequel
         raise Error, "cannot call add_graph_aliases on a dataset that has not been called with graph or set_graph_aliases"
       end
       columns, graph_aliases = graph_alias_columns(graph_aliases)
-      select_more(*columns).clone(:graph_aliases => Hash[ga].merge!(graph_aliases))
+      select_append(*columns).clone(:graph_aliases => Hash[ga].merge!(graph_aliases).freeze)
     end
 
     # Similar to Dataset#join_table, but uses unambiguous aliases for selected
@@ -196,11 +196,12 @@ module Sequel
             ident = SQL::QualifiedIdentifier.new(table_alias_qualifier, column)
             [column, ident]
           end
-          column_aliases[col_alias] = [table_alias, column]
+          column_aliases[col_alias] = [table_alias, column].freeze
           select.push(identifier)
         end
       end
-      ds = ds.clone(:graph=>graph)
+      [:column_aliases, :table_aliases, :column_alias_num].each{|k| graph[k].freeze}
+      ds = ds.clone(:graph=>graph.freeze)
       add_columns ? ds.select(*select) : ds
     end
 
@@ -229,9 +230,7 @@ module Sequel
     #   # SELECT artists.name, albums.name AS album_name, 42 AS forty_two ...
     def set_graph_aliases(graph_aliases)
       columns, graph_aliases = graph_alias_columns(graph_aliases)
-      ds = select(*columns)
-      ds.opts[:graph_aliases] = graph_aliases
-      ds
+      select(*columns).clone(:graph_aliases=>graph_aliases.freeze)
     end
 
     # Remove the splitting of results into subhashes, and all metadata
@@ -269,7 +268,7 @@ module Sequel
       identifiers = graph_aliases.collect do |col_alias, tc| 
         table, column, value = Array(tc)
         column ||= col_alias
-        gas[col_alias] = [table, column]
+        gas[col_alias] = [table, column].freeze
         identifier = value || SQL::QualifiedIdentifier.new(table, column)
         identifier = SQL::AliasedExpression.new(identifier, col_alias) if value || column != col_alias
         identifier

data/lib/sequel/dataset/misc.rb

@@ -29,13 +29,14 @@ module Sequel
     # the Database#dataset method return an instance of that subclass.
     def initialize(db)
       @db = db
-      @opts = OPTS
+      @opts = {}
+      @cache = {}
     end
 
-    # Define a hash value such that datasets with the same DB, opts, and SQL
+    # Define a hash value such that datasets with the same class, DB, and opts
     # will be considered equal.
     def ==(o)
-      o.is_a?(self.class) && db == o.db && opts == o.opts && sql == o.sql
+      o.is_a?(self.class) && db == o.db && opts == o.opts
     end
 
     # An object representing the current date or time, should be an instance
@@ -49,11 +50,19 @@ module Sequel
       self == o
     end
 
-    # Similar to #clone, but returns an unfrozen clone if the receiver is frozen.
-    def dup
-      o = clone
-      o.instance_variable_set(:@frozen, false) if frozen?
-      o
+    if TRUE_FREEZE
+      # Similar to #clone, but returns an unfrozen clone if the receiver is frozen.
+      def dup
+        _clone(:freeze=>false)
+      end
+    else
+      # :nocov:
+      def dup
+        c = clone
+        c.instance_variable_set(:@opts, Hash[c.opts])
+        c
+      end
+      # :nocov:
     end
     
     # Yield a dataset for each server in the connection pool that is tied to that server.
@@ -74,15 +83,25 @@ module Sequel
       string.gsub(/[\\%_]/){|m| "\\#{m}"}
     end
 
-    # Sets the frozen flag on the dataset, so you can't modify it. Returns the receiver.
-    def freeze
-      @frozen = true
-      self
-    end
+    if TRUE_FREEZE
+      # Freeze the opts when freezing the dataset.
+      def freeze
+        @opts.freeze
+        super
+      end
+    else
+      # :nocov:
+      # :nodoc:
+      def freeze
+        @opts.freeze
+        self
+      end
 
-    # Whether the object is frozen.
-    def frozen?
-      @frozen == true
+      # :nodoc:
+      def frozen?
+        @opts.frozen?
+      end
+      # :nocov:
     end
    
     # Alias of +first_source_alias+
@@ -139,30 +158,10 @@ module Sequel
       end
     end
 
-    # Define a hash value such that datasets with the same DB, opts, and SQL
-    # will have the same hash value
+    # Define a hash value such that datasets with the same class, DB, and opts,
+    # will have the same hash value.
     def hash
-      [db, opts, sql].hash
-    end
-    
-    # The String instance method to call on identifiers before sending them to
-    # the database.
-    def identifier_input_method
-      if defined?(@identifier_input_method)
-        @identifier_input_method
-      else
-        @identifier_input_method = db.identifier_input_method
-      end
-    end
-    
-    # The String instance method to call on identifiers before sending them to
-    # the database.
-    def identifier_output_method
-      if defined?(@identifier_output_method)
-        @identifier_output_method
-      else
-        @identifier_output_method = db.identifier_output_method
-      end
+      [self.class, db, opts].hash
     end
     
     # Returns a string representation of the dataset including the class name 
@@ -182,6 +181,12 @@ module Sequel
       :x_sequel_row_number_x
     end
 
+    # 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.
+    def row_proc
+      @opts[:row_proc]
+    end
+    
     # Splits a possible implicit alias in +c+, handling both SQL::AliasedExpressions
     # and Symbols.  Returns an array of two elements, with the first being the
     # main expression, and the second being the alias.
@@ -250,29 +255,95 @@ module Sequel
 
     # Return a modified dataset with quote_identifiers set.
     def with_quote_identifiers(v)
-      c = clone
-      c.send(:skip_symbol_cache!)
-      c.instance_variable_set(:@quote_identifiers, v)
-      c
+      clone(:quote_identifiers=>v, :skip_symbol_cache=>true)
     end
-    
-    # Return a modified dataset with identifier_input_method set.
-    def with_identifier_input_method(meth)
-      c = clone
-      c.send(:skip_symbol_cache!)
-      c.instance_variable_set(:@identifier_input_method, meth)
-      c
+      
+    protected
+
+    # Access the cache for the current dataset.  Should be used with caution,
+    # as access to the cache is not thread safe without a mutex if other
+    # threads can reference the dataset.  Symbol keys prefixed with an
+    # underscore are reserved for internal use.
+    attr_reader :cache
+
+    # Retreive a value from the dataset's cache in a thread safe manner.
+    def cache_get(k)
+      Sequel.synchronize{@cache[k]}
     end
-    
-    # Return a modified dataset with identifier_output_method set.
-    def with_identifier_output_method(meth)
-      c = clone
-      c.instance_variable_set(:@identifier_output_method, meth)
-      c
+
+    # Set a value in the dataset's cache in a thread safe manner.
+    def cache_set(k, v)
+      Sequel.synchronize{@cache[k] = v}
+    end
+
+    # Clear the columns hash for the current dataset.  This is not a
+    # thread safe operation, so it should only be used if the dataset
+    # could not be used by another thread (such as one that was just
+    # created via clone).
+    def clear_columns_cache
+      @cache.delete(:_columns)
+    end
+
+    # The cached columns for the current dataset.
+    def _columns
+      cache_get(:_columns)
     end
 
     private
 
+    # Check the cache for the given key, returning the value.
+    # Otherwise, yield to get the dataset, and if the current dataset
+    # is frozen, cache the dataset under the given key.
+    def cached_dataset(key)
+      unless ds = cache_get(key)
+        ds = yield
+        cache_set(key, ds) if frozen?
+      end
+
+      ds
+    end
+
+    # Return a cached placeholder literalizer for the given key if there
+    # is one for this dataset.  If there isn't one, increment the counter
+    # for the number of calls for the key, and if the counter is at least
+    # three, then create a placeholder literalizer by yielding to the block,
+    # and cache it.
+    def cached_placeholder_literalizer(key)
+      if loader = cache_get(key)
+        return loader unless loader.is_a?(Integer)
+        loader += 1
+
+        if loader >= 3
+          loader = Sequel::Dataset::PlaceholderLiteralizer.loader(self){|pl, _| yield pl}
+          cache_set(key, loader)
+        else
+          cache_set(key, loader + 1)
+          loader = nil
+        end
+      elsif cache_sql?
+        cache_set(key, 1)
+      end
+
+      loader
+    end
+
+    # Set the columns for the current dataset.
+    def columns=(v)
+      cache_set(:_columns, v)
+    end
+
+    # Set the db, opts, and cache for the copy of the dataset.
+    def initialize_copy(c)
+      @db = c.db
+      @opts = Hash[c.opts]
+      if cols = c.cache_get(:_columns)
+        @cache = {:_columns=>cols}
+      else
+        @cache = {}
+      end
+    end
+    alias initialize_clone initialize_copy
+
     # Internal recursive version of unqualified_column_for, handling Strings inside
     # of other objects.
     def _unqualified_column_for(v)

data/lib/sequel/dataset/mutation.rb

@@ -28,10 +28,6 @@ module Sequel
     # Add the mutation methods via metaprogramming
     def_mutation_method(*MUTATION_METHODS)
     
-    # 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_reader :row_proc
-    
     # Like #extension, but modifies and returns the receiver instead of returning a modified clone.
     def extension!(*exts)
       raise_if_frozen!
@@ -45,23 +41,10 @@ module Sequel
       self
     end
 
-    # Set the method to call on identifiers going into the database for this dataset
-    def identifier_input_method=(v)
-      raise_if_frozen!
-      skip_symbol_cache!
-      @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
+      @opts[:row_proc] = nil
       self
     end
     
@@ -69,13 +52,13 @@ module Sequel
     def quote_identifiers=(v)
       raise_if_frozen!
       skip_symbol_cache!
-      @quote_identifiers = v
+      @opts[:quote_identifiers] = v
     end
 
     # Override the row_proc for this dataset
     def row_proc=(v)
       raise_if_frozen!
-      @row_proc = v
+      @opts[:row_proc] = v
     end
     
     private
@@ -99,6 +82,7 @@ module Sequel
     def mutation_method(meth, *args, &block)
       raise_if_frozen!
       @opts = send(meth, *args, &block).opts
+      @cache = {}
       self
     end
 
@@ -108,5 +92,10 @@ module Sequel
         raise RuntimeError, "can't modify frozen #{visible_class_name}"
       end
     end
+
+    # Set the dataset to skip the symbol cache
+    def skip_symbol_cache!
+      @opts[:skip_symbol_cache] = true
+    end
   end
 end

data/lib/sequel/dataset/placeholder_literalizer.rb

@@ -51,6 +51,7 @@ module Sequel
           @recorder = recorder
           @pos = pos
           @transformer = transformer
+          freeze
         end
 
         # Record the SQL query offset, argument position, and transforming block where the
@@ -125,13 +126,21 @@ module Sequel
         @fragments = fragments
         @final_sql = final_sql
         @arity = arity
+        freeze
+      end
+
+      # Freeze the fragments and final SQL when freezing the literalizer.
+      def freeze
+        @fragments.freeze
+        @final_sql.freeze
+        super
       end
 
       # Return a new PlaceholderLiteralizer with a modified dataset.  This yields the
       # receiver's dataset to the block, and the block should return the new dataset
       # to use.
       def with_dataset
-        dup.instance_exec{@dataset = yield @dataset; self}
+        dup.instance_exec{@dataset = yield @dataset; self}.freeze
       end
 
       # Return an array of all objects by running the SQL query for the given arguments.

data/lib/sequel/dataset/prepared_statements.rb

@@ -36,33 +36,49 @@ module Sequel
       end
     end
     private_class_method :prepared_statements_module
+
+    def self.def_deprecated_opts_setter(mod, *meths)
+      meths.each do |meth|
+        mod.send(:define_method, :"#{meth}=") do |v|
+          # :nocov:
+          Sequel::Deprecation.deprecate("Dataset##{meth}=", "The API has changed, and this value should now be passed in as an option via Dataset#clone.")
+          @opts[meth] = v
+          # :nocov:
+        end
+      end
+    end
     
     # Default implementation of the argument mapper to allow
     # native database support for bind variables and prepared
     # statements (as opposed to the emulated ones used by default).
     module ArgumentMapper
-      # The name of the prepared statement, if any.
-      attr_accessor :prepared_statement_name
+      Dataset.def_deprecated_opts_setter(self, :prepared_statement_name, :bind_arguments)
       
+      # The name of the prepared statement, if any.
+      def prepared_statement_name
+        @opts[:prepared_statement_name]
+      end
+
       # The bind arguments to use for running this prepared statement
-      attr_accessor :bind_arguments
+      def bind_arguments
+        @opts[:bind_arguments]
+      end
 
       # Set the bind arguments based on the hash and call super.
       def call(bind_vars={}, &block)
-        ds = bind(bind_vars)
-        ds.prepared_sql
-        ds.bind_arguments = ds.map_to_prepared_args(ds.opts[:bind_vars])
-        ds.run(&block)
+        sql = prepared_sql
+        prepared_args.freeze
+        ps = bind(bind_vars)
+        ps.clone(:bind_arguments=>ps.map_to_prepared_args(ps.opts[:bind_vars]), :sql=>sql, :prepared_sql=>sql).run(&block)
       end
         
       # Override the given *_sql method based on the type, and
       # cache the result of the sql.
       def prepared_sql
-        return @prepared_sql if @prepared_sql
-        @prepared_args ||= []
-        @prepared_sql = super
-        @opts[:sql] = @prepared_sql
-        @prepared_sql
+        if sql = @opts[:prepared_sql] || cache_get(:_prepared_sql)
+          return sql
+        end
+        cache_set(:_prepared_sql, super)
       end
     end
 
@@ -73,25 +89,37 @@ module Sequel
     # into the query, which works on all databases, as it is no different
     # from using the dataset without bind variables.
     module PreparedStatementMethods
+      Dataset.def_deprecated_opts_setter(self, :log_sql, :prepared_type, :prepared_args, :orig_dataset, :prepared_modify_values)
+
       PLACEHOLDER_RE = /\A\$(.*)\z/
       
       # Whether to log the full SQL query.  By default, just the prepared statement
       # name is generally logged on adapters that support native prepared statements.
-      attr_accessor :log_sql
+      def log_sql
+        @opts[:log_sql]
+      end
       
       # The type of prepared statement, should be one of :select, :first,
       # :insert, :update, or :delete
-      attr_accessor :prepared_type
+      def prepared_type
+        @opts[:prepared_type]
+      end
       
       # The array/hash of bound variable placeholder names.
-      attr_accessor :prepared_args
+      def prepared_args
+        @opts[:prepared_args]
+      end
       
       # The dataset that created this prepared statement.
-      attr_accessor :orig_dataset
+      def orig_dataset
+        @opts[:orig_dataset]
+      end
       
       # The argument to supply to insert and update, which may use
       # placeholders specified by prepared_args
-      attr_accessor :prepared_modify_values
+      def prepared_modify_values
+        @opts[:prepared_modify_values]
+      end
 
       # Sets the prepared_args to the given hash and runs the
       # prepared statement.
@@ -115,18 +143,18 @@ module Sequel
       # Returns the SQL for the prepared statement, depending on
       # the type of the statement and the prepared_modify_values.
       def prepared_sql
-        case @prepared_type
+        case prepared_type
         when :select, :all, :each
           # Most common scenario, so listed first.
           select_sql
         when :first
           clone(:limit=>1).select_sql
         when :insert_select
-          insert_select_sql(*@prepared_modify_values)
-        when :insert
-          insert_sql(*@prepared_modify_values)
+          insert_select_sql(*prepared_modify_values)
+        when :insert, :insert_pk
+          insert_sql(*prepared_modify_values)
         when :update
-          update_sql(*@prepared_modify_values)
+          update_sql(*prepared_modify_values)
         when :delete
           delete_sql
         else
@@ -163,7 +191,7 @@ module Sequel
       # :select running #all to get all of the rows, and the other
       # types running the method with the same name as the type.
       def run(&block)
-        case @prepared_type
+        case prepared_type
         when :select, :all
           # Most common scenario, so listed first
           all(&block)
@@ -174,17 +202,19 @@ module Sequel
         when :first
           first
         when :insert, :update, :delete
-          if opts[:returning] && supports_returning?(@prepared_type)
+          if opts[:returning] && supports_returning?(prepared_type)
             returning_fetch_rows(prepared_sql)
-          elsif @prepared_type == :delete
+          elsif prepared_type == :delete
             delete
           else
-            send(@prepared_type, *@prepared_modify_values)
+            send(prepared_type, *prepared_modify_values)
           end
+        when :insert_pk
+          fetch_rows(prepared_sql){|r| return r.values.first}
         when Array
-          case @prepared_type.at(0)
+          case prepared_type.at(0)
           when :map, :to_hash, :to_hash_groups
-            send(*@prepared_type, &block) 
+            send(*prepared_type, &block) 
           end
         else
           all(&block)
@@ -213,10 +243,9 @@ module Sequel
       # support and using the same argument hash so that you can use
       # bind variables/prepared arguments in subselects.
       def subselect_sql_append(sql, ds)
-        ps = ds.clone(:append_sql=>sql).prepare(:select)
-        ps = ps.bind(@opts[:bind_vars]) if @opts[:bind_vars]
-        ps.prepared_args = prepared_args
-        ps.prepared_sql
+        ds.clone(:append_sql=>sql, :prepared_args=>prepared_args, :bind_vars=>@opts[:bind_vars]).
+          send(:to_prepared_statement, :select, nil, :extend=>prepared_statement_modules).
+          prepared_sql
       end
     end
     
@@ -255,22 +284,32 @@ module Sequel
     # already been set for this dataset, they are updated with the contents
     # of bind_vars.
     #
-    #   DB[:table].filter(:id=>:$id).bind(:id=>1).call(:first)
+    #   DB[:table].where(:id=>:$id).bind(:id=>1).call(:first)
     #   # SELECT * FROM table WHERE id = ? LIMIT 1 -- (1)
     #   # => {:id=>1}
     def bind(bind_vars={})
-      clone(:bind_vars=>@opts[:bind_vars] ? Hash[@opts[:bind_vars]].merge!(bind_vars) : bind_vars)
+      bind_vars = if bv = @opts[:bind_vars]
+        Hash[bv].merge!(bind_vars).freeze
+      else
+        if bind_vars.frozen?
+          bind_vars
+        else
+          Hash[bind_vars]
+        end
+      end
+
+      clone(:bind_vars=>bind_vars)
     end
     
     # For the given type (:select, :first, :insert, :insert_select, :update, or :delete),
     # run the sql with the bind variables specified in the hash.  +values+ is a hash passed to
     # insert or update (if one of those types is used), which may contain placeholders.
     #
-    #   DB[:table].filter(:id=>:$id).call(:first, :id=>1)
+    #   DB[:table].where(:id=>:$id).call(:first, :id=>1)
     #   # SELECT * FROM table WHERE id = ? LIMIT 1 -- (1)
     #   # => {:id=>1}
     def call(type, bind_variables={}, *values, &block)
-      prepare(type, nil, *values).call(bind_variables, &block)
+      to_prepared_statement(type, values, :extend=>bound_variable_modules).call(bind_variables, &block)
     end
     
     # Prepare an SQL statement for later execution.  Takes a type similar to #call,
@@ -284,7 +323,7 @@ module Sequel
     # the associated database, where it can be called by name.
     # The following usage is identical:
     #
-    #   ps = DB[:table].filter(:name=>:$name).prepare(:first, :select_by_name)
+    #   ps = DB[:table].where(:name=>:$name).prepare(:first, :select_by_name)
     #
     #   ps.call(:name=>'Blah')
     #   # SELECT * FROM table WHERE name = ? -- ('Blah')
@@ -292,8 +331,17 @@ module Sequel
     #
     #   DB.call(:select_by_name, :name=>'Blah') # Same thing
     def prepare(type, name=nil, *values)
-      ps = to_prepared_statement(type, values)
-      db.set_prepared_statement(name, ps) if name
+      ps = to_prepared_statement(type, values, :name=>name, :extend=>prepared_statement_modules)
+
+      if name
+        ps.prepared_sql
+        db.set_prepared_statement(name, ps)
+      else
+        # :nocov:
+        Sequel::Deprecation.deprecate("Dataset#prepare will change to requiring a name argument in Sequel 5, please update your code.") unless name
+        # :nocov:
+      end
+
       ps
     end
     
@@ -301,13 +349,13 @@ module Sequel
     
     # Return a cloned copy of the current dataset extended with
     # PreparedStatementMethods, setting the type and modify values.
-    def to_prepared_statement(type, values=nil)
-      ps = bind
-      ps.extend(PreparedStatementMethods)
-      ps.orig_dataset = self
-      ps.prepared_type = type
-      ps.prepared_modify_values = values
-      ps
+    def to_prepared_statement(type, values=nil, opts=OPTS)
+      mods = opts[:extend] || []
+      mods += [PreparedStatementMethods]
+
+      bind.
+        clone(:prepared_statement_name=>opts[:name], :prepared_type=>type, :prepared_modify_values=>values, :orig_dataset=>self, :no_cache_sql=>true, :prepared_args=>@opts[:prepared_args]||[]).
+        with_extend(*mods)
     end
 
     private
@@ -317,6 +365,14 @@ module Sequel
       false
     end
 
+    def bound_variable_modules
+      prepared_statement_modules
+    end
+
+    def prepared_statement_modules
+      []
+    end
+
     # The argument placeholder.  Most databases used unnumbered
     # arguments with question marks, so that is the default.
     def prepared_arg_placeholder