I believe this should also use splat operator. Not doing so result in primary keys not getting wrapped into an arel attribute node, which could lead to differences in behaviour in complex scenarios.

Specifically, in ActiveRecord::Calculations#pluck, the argument gets passed to ActiveRecord::QueryMethods#arel_columns, which doesn't have a case for processing array argument, and simply returns it as is. Meaning that scope.pluck(:id, :tenant_id) and scope.pluck([:id, :tenant_id]) are subtly different.

Low level difference:

> User.all.__send__(:arel_columns, [:id, :tenant_id])
=> 
[#<struct Arel::Attributes::Attribute
  relation=
   #<Arel::Table:0x0000000122b14f18
    @klass=User(id: uuid, email: string, password_digest: string, client: boolean, active: boolean, created_at: datetime, updated_at: datetime, practise_id: uuid, full_name: string),
    @name="users",
    @table_alias=nil,
    @type_caster=
     #<ActiveRecord::TypeCaster::Map:0x0000000122ef9a48
      @klass=User(id: uuid, email: string, password_digest: string, client: boolean, active: boolean, created_at: datetime, updated_at: datetime, practise_id: uuid, full_name: string)>>,
  name="id">,
 "\"tenant_id\""]


> User.all.__send__(:arel_columns, [[:id, :tenant_id]])
=> [:id, :tenant_id]

I couln't devise a scenario where this actually breaks things, but by adding a splat operator here, array and singular primary keys get handled the same way, lowering the likelihood of bugs down the line.

@Slotos After diving into the code, I found that using pluck(:id, :post_id) and pluck([:id, :post_id]) will produce the same results. The arguments that passed to pluck method will go through the arel_columns method twice.

The first call occurs when we try to extract the value and assign it to selected_values.

The second call occurs during the construction of the select query, where we call the arel_columns method again on selected_values, even though we had already done so once and assigned the value to selected_values.

When using pluck(:id, :post_id):
The first call goes to this block and generates some Arel objects and assign to selected_values

However, the process is entirely different when using pluck([:id, :post_id]). In this case, the first call passes through the else block because the argument is an array. The second call, however, matches the Symbol case, thus generating the Arel objects.

The second call on arel_columns seems unnecessary. The issue is related to how flat_map is used inside the arel_columns method.

At first glance, it might seem that [[:name, :age]].flat_map { |field| field } and [:name, :age].flat_map { |field| field } behave the same since they produce the same output. However,the underlying process reveals a critical difference, particularly in this case. The main difference is the value of class in both cases

[:id, :post_id].flat_map { |field| field.class }
# Outputs: [Symbol, Symbol]
[[:id, :post_id]].flat_map { |field| field.class }
# Outputs: [Array]

Changing the code as shown below will eliminate the need for the second call. However, I'm not sure about the rationale behind using flat_map. Nonetheless, I think this issue deserves a PR on its own. I will investigate further and open one if necessary.

[:id, :post_id].flatten.map { |field| field.class }
# Outputs: [Symbol, Symbol]
[[:id, :post_id]].flatten.map { |field| field.class }
# Outputs: [Symbol, Symbol]

The doc show pluck with multiple arguments like (:id, :name), but ([:id, :name]) also works. To align with docs, we should use the splat operator here.