activerecord 4.1.16 → 4.2.11.3

data/lib/active_record/relation/predicate_builder.rb

@@ -6,7 +6,9 @@ module ActiveRecord
     autoload :ArrayHandler, 'active_record/relation/predicate_builder/array_handler'
 
     def self.resolve_column_aliases(klass, hash)
-      hash = hash.dup
+      # This method is a hot spot, so for now, use Hash[] to dup the hash.
+      #   https://bugs.ruby-lang.org/issues/7166
+      hash = Hash[hash]
       hash.keys.grep(Symbol) do |key|
         if klass.attribute_alias? key
           hash[klass.attribute_alias(key)] = hash.delete key
@@ -26,7 +28,7 @@ module ActiveRecord
             queries << '1=0'
           else
             table       = Arel::Table.new(column, default_table.engine)
-            association = klass._reflect_on_association(column.to_sym)
+            association = klass._reflect_on_association(column)
 
             value.each do |k, v|
               queries.concat expand(association && association.klass, table, k, v)
@@ -55,8 +57,9 @@ module ActiveRecord
       #
       # For polymorphic relationships, find the foreign key and type:
       # PriceEstimate.where(estimate_of: treasure)
-      if klass && reflection = klass._reflect_on_association(column.to_sym)
+      if klass && reflection = klass._reflect_on_association(column)
         base_class = polymorphic_base_class_from_value(value)
+
         if reflection.polymorphic? && base_class
           queries << build(table[reflection.foreign_type], base_class)
         end
@@ -111,16 +114,15 @@ module ActiveRecord
       @handlers.unshift([klass, handler])
     end
 
-    register_handler(BasicObject, ->(attribute, value) { attribute.eq(value) })
+    BASIC_OBJECT_HANDLER = ->(attribute, value) { attribute.eq(value) } # :nodoc:
+    register_handler(BasicObject, BASIC_OBJECT_HANDLER)
     # FIXME: I think we need to deprecate this behavior
     register_handler(Class, ->(attribute, value) { attribute.eq(value.name) })
     register_handler(Base, ->(attribute, value) { attribute.eq(value.id) })
-    register_handler(Range, ->(attribute, value) { attribute.in(value) })
+    register_handler(Range, ->(attribute, value) { attribute.between(value) })
     register_handler(Relation, RelationHandler.new)
     register_handler(Array, ArrayHandler.new)
 
-    private
-
     def self.build(attribute, value)
       handler_for(value).call(attribute, value)
     end
@@ -138,10 +140,16 @@ module ActiveRecord
       when Array
         value.map { |v| convert_value_to_association_ids(v, primary_key) }
       when Base
-        value.read_attribute(primary_key)
+        value._read_attribute(primary_key)
       else
         value
       end
     end
+
+    def self.can_be_bound?(value) # :nodoc:
+      !value.nil? &&
+        !value.is_a?(Hash) &&
+        handler_for(value) == BASIC_OBJECT_HANDLER
+    end
   end
 end

data/lib/active_record/relation/query_methods.rb

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/string/filters'
 require 'active_model/forbidden_attributes_protection'
 
 module ActiveRecord
@@ -67,6 +68,7 @@ module ActiveRecord
                                              #
         def #{name}_values=(values)          # def select_values=(values)
           raise ImmutableRelation if @loaded #   raise ImmutableRelation if @loaded
+          check_cached_relation
           @values[:#{name}] = values         #   @values[:select] = values
         end                                  # end
       CODE
@@ -84,11 +86,22 @@ module ActiveRecord
       class_eval <<-CODE, __FILE__, __LINE__ + 1
         def #{name}_value=(value)            # def readonly_value=(value)
           raise ImmutableRelation if @loaded #   raise ImmutableRelation if @loaded
+          check_cached_relation
           @values[:#{name}] = value          #   @values[:readonly] = value
         end                                  # end
       CODE
     end
 
+    def check_cached_relation # :nodoc:
+      if defined?(@arel) && @arel
+        @arel = nil
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          Modifying already cached Relation. The cache will be reset. Use a
+          cloned Relation to prevent this warning.
+        MSG
+      end
+    end
+
     def create_with_value # :nodoc:
       @values[:create_with] || {}
     end
@@ -173,7 +186,7 @@ module ActiveRecord
 
     # Use to indicate that the given +table_names+ are referenced by an SQL string,
     # and should therefore be JOINed in any query rather than loaded separately.
-    # This method only works in conjuction with +includes+.
+    # This method only works in conjunction with +includes+.
     # See #includes for more details.
     #
     #   User.includes(:posts).where("posts.name = 'foo'")
@@ -207,7 +220,7 @@ module ActiveRecord
     # fields are retrieved:
     #
     #   Model.select(:field)
-    #   # => [#<Model field:value>]
+    #   # => [#<Model id: nil, field: "value">]
     #
     # Although in the above example it looks as though this method returns an
     # array, it actually returns a relation object and can have other query
@@ -216,12 +229,12 @@ module ActiveRecord
     # The argument to the method can also be an array of fields.
     #
     #   Model.select(:field, :other_field, :and_one_more)
-    #   # => [#<Model field: "value", other_field: "value", and_one_more: "value">]
+    #   # => [#<Model id: nil, field: "value", other_field: "value", and_one_more: "value">]
     #
     # You can also use one or more strings, which will be used unchanged as SELECT fields.
     #
     #   Model.select('field AS field_one', 'other_field AS field_two')
-    #   # => [#<Model field: "value", other_field: "value">]
+    #   # => [#<Model id: nil, field: "value", other_field: "value">]
     #
     # If an alias was specified, it will be accessible from the resulting objects:
     #
@@ -229,7 +242,7 @@ module ActiveRecord
     #   # => "value"
     #
     # Accessing attributes of an object that do not have fields retrieved by a select
-    # will throw <tt>ActiveModel::MissingAttributeError</tt>:
+    # except +id+ will throw <tt>ActiveModel::MissingAttributeError</tt>:
     #
     #   Model.select(:field).first.other_field
     #   # => ActiveModel::MissingAttributeError: missing attribute: other_field
@@ -245,7 +258,7 @@ module ActiveRecord
     def _select!(*fields) # :nodoc:
       fields.flatten!
       fields.map! do |field|
-        klass.attribute_alias?(field) ? klass.attribute_alias(field) : field
+        klass.attribute_alias?(field) ? klass.attribute_alias(field).to_sym : field
       end
       self.select_values += fields
       self
@@ -266,6 +279,10 @@ module ActiveRecord
     #
     #   User.group('name AS grouped_name, age')
     #   => [#<User id: 3, name: "Foo", age: 21, ...>, #<User id: 2, name: "Oscar", age: 21, ...>, #<User id: 5, name: "Foo", age: 23, ...>]
+    #
+    # Passing in an array of attributes to group by is also supported.
+    #   User.select([:id, :first_name]).group(:id, :first_name).first(3)
+    #   => [#<User id: 1, first_name: "Bill">, #<User id: 2, first_name: "Earl">, #<User id: 3, first_name: "Beto">]
     def group(*args)
       check_if_method_has_arguments!(:group, args)
       spawn.group!(*args)
@@ -280,15 +297,6 @@ module ActiveRecord
 
     # Allows to specify an order attribute:
     #
-    #   User.order('name')
-    #   => SELECT "users".* FROM "users" ORDER BY name
-    #
-    #   User.order('name DESC')
-    #   => SELECT "users".* FROM "users" ORDER BY name DESC
-    #
-    #   User.order('name DESC, email')
-    #   => SELECT "users".* FROM "users" ORDER BY name DESC, email
-    #
     #   User.order(:name)
     #   => SELECT "users".* FROM "users" ORDER BY "users"."name" ASC
     #
@@ -297,6 +305,15 @@ module ActiveRecord
     #
     #   User.order(:name, email: :desc)
     #   => SELECT "users".* FROM "users" ORDER BY "users"."name" ASC, "users"."email" DESC
+    #
+    #   User.order('name')
+    #   => SELECT "users".* FROM "users" ORDER BY name
+    #
+    #   User.order('name DESC')
+    #   => SELECT "users".* FROM "users" ORDER BY name DESC
+    #
+    #   User.order('name DESC, email')
+    #   => SELECT "users".* FROM "users" ORDER BY name DESC, email
     def order(*args)
       check_if_method_has_arguments!(:order, args)
       spawn.order!(*args)
@@ -410,19 +427,17 @@ module ActiveRecord
     #   => SELECT "users".* FROM "users" LEFT JOIN bookmarks ON bookmarks.bookmarkable_type = 'Post' AND bookmarks.user_id = users.id
     def joins(*args)
       check_if_method_has_arguments!(:joins, args)
-
-      args.compact!
-      args.flatten!
-
       spawn.joins!(*args)
     end
 
     def joins!(*args) # :nodoc:
+      args.compact!
+      args.flatten!
       self.joins_values += args
       self
     end
 
-    def bind(value)
+    def bind(value) # :nodoc:
       spawn.bind!(value)
     end
 
@@ -560,18 +575,14 @@ module ActiveRecord
       end
     end
 
-    def where!(opts = :chain, *rest) # :nodoc:
-      if opts == :chain
-        WhereChain.new(self)
-      else
-        if Hash === opts
-          opts = sanitize_forbidden_attributes(opts)
-          references!(PredicateBuilder.references(opts))
-        end
-
-        self.where_values += build_where(opts, rest)
-        self
+    def where!(opts, *rest) # :nodoc:
+      if Hash === opts
+        opts = sanitize_forbidden_attributes(opts)
+        references!(PredicateBuilder.references(opts))
       end
+
+      self.where_values += build_where(opts, rest)
+      self
     end
 
     # Allows you to change a previously set where condition for a given attribute, instead of appending to that condition.
@@ -746,6 +757,9 @@ module ActiveRecord
 
     def from!(value, subquery_name = nil) # :nodoc:
       self.from_value = [value, subquery_name]
+      if value.is_a? Relation
+        self.bind_values = value.arel.bind_values + value.bind_values + bind_values
+      end
       self
     end
 
@@ -833,7 +847,9 @@ module ActiveRecord
     end
 
     def reverse_order! # :nodoc:
-      self.reverse_order_value = !reverse_order_value
+      orders = order_values.uniq
+      orders.reject!(&:blank?)
+      self.order_values = reverse_sql_order(orders)
       self
     end
 
@@ -849,7 +865,7 @@ module ActiveRecord
 
       build_joins(arel, joins_values.flatten) unless joins_values.empty?
 
-      collapse_wheres(arel, (where_values - ['']).uniq)
+      collapse_wheres(arel, (where_values - [''])) #TODO: Add uniq with real value comparison / ignore uniqs that have binds
 
       arel.having(*having_values.uniq.reject(&:blank?)) unless having_values.empty?
 
@@ -865,15 +881,6 @@ module ActiveRecord
       arel.from(build_from) if from_value
       arel.lock(lock_value) if lock_value
 
-      # Reorder bind indexes if joins produced bind values
-      bvs = arel.bind_values + bind_values
-      if bvs.any?
-        arel.ast.grep(Arel::Nodes::BindParam).each_with_index do |bp, i|
-          column = bvs[i].first
-          bp.replace connection.substitute_at(column, i)
-        end
-      end
-
       arel
     end
 
@@ -887,8 +894,9 @@ module ActiveRecord
 
       case scope
       when :order
-        self.reverse_order_value = false
         result = []
+      when :where
+        self.bind_values = []
       else
         result = [] unless single_val_method
       end
@@ -899,9 +907,9 @@ module ActiveRecord
     def where_unscoping(target_value)
       target_value = target_value.to_s
 
-      where_values.reject! do |rel|
+      self.where_values = where_values.reject do |rel|
         case rel
-        when Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual
+        when Arel::Nodes::Between, Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual, Arel::Nodes::LessThan, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThan, Arel::Nodes::GreaterThanOrEqual
           subrelation = (rel.left.kind_of?(Arel::Attributes::Attribute) ? rel.left : rel.right)
           subrelation.name == target_value
         end
@@ -939,18 +947,14 @@ module ActiveRecord
     def build_where(opts, other = [])
       case opts
       when String, Array
-        #TODO: Remove duplication with: /activerecord/lib/active_record/sanitization.rb:113
-        values = Hash === other.first ? other.first.values : other
-
-        values.grep(ActiveRecord::Relation) do |rel|
-          self.bind_values += rel.bind_values
-        end
-
         [@klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
       when Hash
         opts = PredicateBuilder.resolve_column_aliases(klass, opts)
-        attributes = @klass.send(:expand_hash_conditions_for_aggregates, opts)
 
+        tmp_opts, bind_values = create_binds(opts)
+        self.bind_values += bind_values
+
+        attributes = @klass.send(:expand_hash_conditions_for_aggregates, tmp_opts)
         add_relations_to_bind_values(attributes)
 
         PredicateBuilder.build_from_hash(klass, attributes, table)
@@ -959,12 +963,50 @@ module ActiveRecord
       end
     end
 
+    def create_binds(opts)
+      bindable, non_binds = opts.partition do |column, value|
+        PredicateBuilder.can_be_bound?(value) &&
+          @klass.columns_hash.include?(column.to_s) &&
+          !@klass.reflect_on_aggregation(column)
+      end
+
+      association_binds, non_binds = non_binds.partition do |column, value|
+        value.is_a?(Hash) && association_for_table(column)
+      end
+
+      new_opts = {}
+      binds = []
+
+      connection = self.connection
+
+      bindable.each do |(column,value)|
+        binds.push [@klass.columns_hash[column.to_s], value]
+        new_opts[column] = connection.substitute_at(column)
+      end
+
+      association_binds.each do |(column, value)|
+        association_relation = association_for_table(column).klass.send(:relation)
+        association_new_opts, association_bind = association_relation.send(:create_binds, value)
+        new_opts[column] = association_new_opts
+        binds += association_bind
+      end
+
+      non_binds.each { |column,value| new_opts[column] = value }
+
+      [new_opts, binds]
+    end
+
+    def association_for_table(table_name)
+      table_name = table_name.to_s
+      @klass._reflect_on_association(table_name) ||
+        @klass._reflect_on_association(table_name.singularize)
+    end
+
     def build_from
       opts, name = from_value
       case opts
       when Relation
         name ||= 'subquery'
-        self.bind_values = opts.bind_values + self.bind_values
         opts.arel.as(name.to_s)
       else
         opts
@@ -1000,9 +1042,12 @@ module ActiveRecord
         join_list
       )
 
-      joins = join_dependency.join_constraints stashed_association_joins
+      join_infos = join_dependency.join_constraints stashed_association_joins
 
-      joins.each { |join| manager.from(join) }
+      join_infos.each do |info|
+        info.joins.each { |join| manager.from(join) }
+        manager.bind_values.concat info.binds
+      end
 
       manager.join_sources.concat(join_list)
 
@@ -1019,8 +1064,10 @@ module ActiveRecord
 
     def arel_columns(columns)
       columns.map do |field|
-        if columns_hash.key?(field.to_s)
+        if (Symbol === field || String === field) && columns_hash.key?(field.to_s) && !from_value
           arel_table[field]
+        elsif Symbol === field
+          connection.quote_table_name(field.to_s)
         else
           field
         end
@@ -1052,15 +1099,19 @@ module ActiveRecord
     def build_order(arel)
       orders = order_values.uniq
       orders.reject!(&:blank?)
-      orders = reverse_sql_order(orders) if reverse_order_value
 
       arel.order(*orders) unless orders.empty?
     end
 
+    VALID_DIRECTIONS = [:asc, :desc, :ASC, :DESC,
+                        'asc', 'desc', 'ASC', 'DESC'] # :nodoc:
+
     def validate_order_args(args)
-      args.grep(Hash) do |h|
-        unless (h.values - [:asc, :desc]).empty?
-          raise ArgumentError, 'Direction should be :asc or :desc'
+      args.each do |arg|
+        next unless arg.is_a?(Hash)
+        arg.each do |_key, value|
+          raise ArgumentError, "Direction \"#{value}\" is invalid. Valid " \
+                               "directions are: #{VALID_DIRECTIONS.inspect}" unless VALID_DIRECTIONS.include?(value)
         end
       end
     end
@@ -1082,7 +1133,7 @@ module ActiveRecord
         when Hash
           arg.map { |field, dir|
             field = klass.attribute_alias(field) if klass.attribute_alias?(field)
-            table[field].send(dir)
+            table[field].send(dir.downcase)
           }
         else
           arg
@@ -1112,13 +1163,11 @@ module ActiveRecord
       end
     end
 
-    # This function is recursive just for better readablity.
-    # #where argument doesn't support more than one level nested hash in real world.
     def add_relations_to_bind_values(attributes)
       if attributes.is_a?(Hash)
         attributes.each_value do |value|
           if value.is_a?(ActiveRecord::Relation)
-            self.bind_values += value.bind_values
+            self.bind_values += value.arel.bind_values + value.bind_values
           else
             add_relations_to_bind_values(value)
           end

data/lib/active_record/relation/spawn_methods.rb

@@ -62,6 +62,9 @@ module ActiveRecord
     #   Post.order('id asc').only(:where)         # discards the order condition
     #   Post.order('id asc').only(:where, :order) # uses the specified order
     def only(*onlies)
+      if onlies.any? { |o| o == :where }
+        onlies << :bind
+      end
       relation_with values.slice(*onlies)
     end
 

data/lib/active_record/relation.rb

@@ -1,16 +1,16 @@
 # -*- coding: utf-8 -*-
+require 'arel/collectors/bind'
 
 module ActiveRecord
   # = Active Record Relation
   class Relation
-    JoinOperation = Struct.new(:relation, :join_class, :on)
-
     MULTI_VALUE_METHODS  = [:includes, :eager_load, :preload, :select, :group,
                             :order, :joins, :where, :having, :bind, :references,
                             :extending, :unscope]
 
     SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :from, :reordering,
                             :reverse_order, :distinct, :create_with, :uniq]
+    INVALID_METHODS_FOR_DELETE_ALL = [:limit, :distinct, :offset, :group, :having]
 
     VALUE_METHODS = MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS
 
@@ -79,22 +79,26 @@ module ActiveRecord
         scope.unscope!(where: @klass.inheritance_column)
       end
 
-      um = scope.where(@klass.arel_table[@klass.primary_key].eq(id_was || id)).arel.compile_update(substitutes, @klass.primary_key)
+      relation = scope.where(@klass.primary_key => (id_was || id))
+      bvs = binds + relation.bind_values
+      um = relation
+        .arel
+        .compile_update(substitutes, @klass.primary_key)
 
       @klass.connection.update(
         um,
         'SQL',
-        binds)
+        bvs,
+      )
     end
 
     def substitute_values(values) # :nodoc:
-      substitutes = values.sort_by { |arel_attr,_| arel_attr.name }
-      binds       = substitutes.map do |arel_attr, value|
+      binds = values.map do |arel_attr, value|
         [@klass.columns_hash[arel_attr.name], value]
       end
 
-      substitutes.each_with_index do |tuple, i|
-        tuple[1] = @klass.connection.substitute_at(binds[i][0], i)
+      substitutes = values.each_with_index.map do |(arel_attr, _), i|
+        [arel_attr, @klass.connection.substitute_at(binds[i][0])]
       end
 
       [substitutes, binds]
@@ -230,6 +234,7 @@ module ActiveRecord
     # Please see further details in the
     # {Active Record Query Interface guide}[http://guides.rubyonrails.org/active_record_querying.html#running-explain].
     def explain
+      #TODO: Fix for binds.
       exec_explain(collecting_queries_for_explain { exec_queries })
     end
 
@@ -239,6 +244,11 @@ module ActiveRecord
       @records
     end
 
+    # Serializes the relation objects Array.
+    def encode_with(coder)
+      coder.represent_seq(nil, to_a)
+    end
+
     def as_json(options = nil) #:nodoc:
       to_a.as_json(options)
     end
@@ -294,10 +304,11 @@ module ActiveRecord
       klass.current_scope = previous
     end
 
-    # Updates all records with details given if they match a set of conditions supplied, limits and order can
-    # also be supplied. This method constructs a single SQL UPDATE statement and sends it straight to the
-    # database. It does not instantiate the involved models and it does not trigger Active Record callbacks
-    # or validations.
+    # Updates all records in the current relation with details given. This method constructs a single SQL UPDATE
+    # statement and sends it straight to the database. It does not instantiate the involved models and it does not
+    # trigger Active Record callbacks or validations. Values passed to `update_all` will not go through
+    # ActiveRecord's type-casting behavior. It should receive only values that can be passed as-is to the SQL
+    # database.
     #
     # ==== Parameters
     #
@@ -330,7 +341,8 @@ module ActiveRecord
         stmt.wheres = arel.constraints
       end
 
-      @klass.connection.update stmt, 'SQL', bind_values
+      bvs = arel.bind_values + bind_values
+      @klass.connection.update stmt, 'SQL', bvs
     end
 
     # Updates an object (or multiple objects) and saves it to the database, if validations pass.
@@ -434,12 +446,21 @@ module ActiveRecord
     # If you need to destroy dependent associations or call your <tt>before_*</tt> or
     # +after_destroy+ callbacks, use the +destroy_all+ method instead.
     #
-    # If a limit scope is supplied, +delete_all+ raises an ActiveRecord error:
+    # If an invalid method is supplied, +delete_all+ raises an ActiveRecord error:
     #
     #   Post.limit(100).delete_all
-    #   # => ActiveRecord::ActiveRecordError: delete_all doesn't support limit scope
+    #   # => ActiveRecord::ActiveRecordError: delete_all doesn't support limit
     def delete_all(conditions = nil)
-      raise ActiveRecordError.new("delete_all doesn't support limit scope") if self.limit_value
+      invalid_methods = INVALID_METHODS_FOR_DELETE_ALL.select { |method|
+        if MULTI_VALUE_METHODS.include?(method)
+          send("#{method}_values").any?
+        else
+          send("#{method}_value")
+        end
+      }
+      if invalid_methods.any?
+        raise ActiveRecordError.new("delete_all doesn't support #{invalid_methods.join(', ')}")
+      end
 
       if conditions
         where(conditions).delete_all
@@ -453,7 +474,8 @@ module ActiveRecord
           stmt.wheres = arel.constraints
         end
 
-        affected = @klass.connection.delete(stmt, 'SQL', bind_values)
+        bvs = arel.bind_values + bind_values
+        affected = @klass.connection.delete(stmt, 'SQL', bvs)
 
         reset
         affected
@@ -523,11 +545,11 @@ module ActiveRecord
                       find_with_associations { |rel| relation = rel }
                     end
 
-                    ast   = relation.arel.ast
-                    binds = relation.bind_values.dup
-                    visitor.accept(ast) do
-                      connection.quote(*binds.shift.reverse)
-                    end
+                    arel  = relation.arel
+                    binds = (arel.bind_values + relation.bind_values).dup
+                    binds.map! { |bv| connection.quote(*bv.reverse) }
+                    collect = visitor.accept(arel.ast, Arel::Collectors::Bind.new)
+                    collect.substitute_binds(binds).join
                   end
     end
 
@@ -544,7 +566,13 @@ module ActiveRecord
 
       Hash[equalities.map { |where|
         name = where.left.name
-        [name, binds.fetch(name.to_s) { where.right }]
+        [name, binds.fetch(name.to_s) {
+          case where.right
+          when Array then where.right.map(&:val)
+          when Arel::Nodes::Casted
+            where.right.val
+          end
+        }]
       }]
     end
 
@@ -608,11 +636,11 @@ module ActiveRecord
     private
 
     def exec_queries
-      @records = eager_loading? ? find_with_associations : @klass.find_by_sql(arel, bind_values)
+      @records = eager_loading? ? find_with_associations : @klass.find_by_sql(arel, arel.bind_values + bind_values)
 
       preload = preload_values
       preload +=  includes_values unless eager_loading?
-      preloader = ActiveRecord::Associations::Preloader.new
+      preloader = build_preloader
       preload.each do |associations|
         preloader.preload @records, associations
       end
@@ -623,6 +651,10 @@ module ActiveRecord
       @records
     end
 
+    def build_preloader
+      ActiveRecord::Associations::Preloader.new
+    end
+
     def references_eager_loaded_tables?
       joined_tables = arel.join_sources.map do |join|
         if join.is_a?(Arel::Nodes::StringJoin)