You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: active_record_querying.rb
    path of file: ./repos/sorbet-rails/lib/sorbet-rails/model_plugins
    
    the code of the file until where you have to start completion: # typed: strict
require ('sorbet-rails/model_plugins/base')
class SorbetRails::ModelPlugins::ActiveRecordQuerying < SorbetRails::ModelPlugins::Base

  sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
  def generate(root)
    # All is a named scope that most method from ActiveRecord::Querying delegate to
    # rails/activerecord/lib/active_record/querying.rb:21
    add_relation_query
    
  def generate(root)
    # All is a named scope that most method from ActiveRecord::Querying delegate to
    # rails/activerecord/lib/active_record/querying.rb:21
    add_relation_query_method(
      root,
      "all",
      builtin_query_method: true,
    )
    add_relation_query_method(
      root,
      "unscoped",
      parameters: [
        Parameter.new("&block", type: "T.nilable(T.proc.void)"),
      ],
      builtin_query_method: true,
    )

    # It's not possible to typedef all methods in ActiveRecord::Querying module to have the
    # matching type. By generating model-specific sig, we can typedef these methods to return
    # <Model>::Relation class.
    # rails/activerecord/lib/active_record/querying.rb
    model_query_relation_methods = [
      # :select,
      :reselect, :order, :reorder, :group, :limit, :offset, :joins, :left_joins, :left_outer_joins,
      :where, :rewhere, :preload, :extract_associated, :eager_load, :includes, :from, :lock, :readonly, :or,
      :having, :create_with, :distinct, :references, :none, :unscope, :optimizer_hints, :merge, :except, :only,
    ]

    model_query_relation_methods.each do |method_name|
      add_relation_query_method(
        root,
        method_name.to_s,
        parameters: [
          Parameter.new("*args", type: "T.untyped"),
        ],
        builtin_query_method: true,
      ) if exists_class_method?(method_name)
    end
    if exists_class_method?("select")
      # `select` can be used with a block to return an array, or with a list of column name
      # to return a relation object that can be chained.
      # I've seen usage of `select` with a block more often than with a list of column name.
      # here we define select as taking a block, and add a `select_column` method for the other usage
      add_relation_query_method(
        root,
        "select",
        parameters: [
          Parameter.new("&block", type: "T.proc.params(e: #{self.model_class_name}).returns(T::Boolean)"),
        ],
        builtin_query_method: true,
        custom_return_value: "T::Array[#{self.model_class_name}]",
      )
      add_relation_query_method(
        root,
        "select_columns", # select_column is injected by sorbet-rails
        parameters: [
          Parameter.new("*args", type: "T.any(String, Symbol, T::Array[T.any(String, Symbol)])"),
        ],
        builtin_query_method: true,
      )
    end