批量迭代表格

User.in_batches(of: 10) do |relation|
  relation.update_all(updated_at: Time.now)
end

class User < ActiveRecord::Base
  include EachBatch
end

User.each_batch(of: 10) do |relation|
  relation.update_all(updated_at: Time.now)
end

User Load (0.7ms)  SELECT  "users"."id" FROM "users" WHERE ("users"."id" >= 41654)  ORDER BY "users"."id" ASC LIMIT 1 OFFSET 1000
  (0.7ms)  SELECT COUNT(*) FROM "users" WHERE ("users"."id" >= 41654) AND ("users"."id" < 42687)

[ gstg ] production> Ci::Build.where(user_id: (1..10_000)).size
=> 1215178

[ gstg ] production> puts Ci::Build.where(user_id: (1..10_000)).to_sql
SELECT "ci_builds".* FROM "ci_builds" WHERE "ci_builds"."type" = 'Ci::Build' AND "ci_builds"."user_id" BETWEEN 1 AND 10000
=> nil

Issue.distinct_each_batch(column: :author_id, of: 1000) do |relation|
  users = User.where(id: relation.select(:author_id)).to_a
end

Project.distinct.each_batch(column: :creator_id, of: 10) do |relation|
  puts User.where(id: relation.select(:creator_id)).map(&:id)
end

users = User.all
users.each { |user| puts user.inspect }

# 注意：本示例选择 5 作为批次大小，默认为 1_000
User.each_batch(of: 5) do |relation|
  relation.each { |user| puts user.inspect }
end

SELECT "users"."id" FROM "users" ORDER BY "users"."id" ASC LIMIT 1

SELECT "users"."id" FROM "users" WHERE "users"."id" >= 1 ORDER BY "users"."id" ASC LIMIT 1 OFFSET 5

SELECT "users".* FROM "users" WHERE "users"."id" >= 1 AND "users"."id" < 302

SELECT "users"."id" FROM "users" WHERE "users"."id" >= 302 ORDER BY "users"."id" ASC LIMIT 1 OFFSET 5

SELECT "users".* FROM "users" WHERE "users"."id" >= 302 AND "users"."id" < 353

users = User.where(sign_in_count: 0)
users.each_batch(of: 5) do |relation|
  relation.each { |user| puts user.inspect }
end

SELECT "users"."id" FROM "users" WHERE "users"."sign_in_count" = 0 ORDER BY "users"."id" ASC LIMIT 1

CREATE INDEX index_on_users_never_logged_in ON users (id) WHERE sign_in_count = 0

CREATE INDEX index_on_users_never_logged_in ON users (id, sign_in_count)

SELECT "users"."id" FROM "users" WHERE "users"."sign_in_count" = 0 ORDER BY "users"."id" ASC LIMIT 1

CREATE INDEX index_on_users_never_logged_in ON users (sign_in_count, id)

CREATE INDEX index_on_users_never_logged_in ON users (sign_in_count)

User.each_batch(of: 5) do |relation|
  relation.where(sign_in_count: 0).each { |user| puts user.inspect }
end

projects = Project.where(creator_id: Issue.where(confidential: true).select(:author_id))
projects.each_batch do |relation|
  # do something
end

projects = Project.all
projects.each_batch do |relation|
  relation.where(creator_id: Issue.where(confidential: true).select(:author_id))
end

projects = Project.all
projects.each_batch do |relation|
  issues = Issue.where(confidential: true)
  issues.each_batch do |issues_relation|
    relation.where(creator_id: issues_relation.select(:author_id))
  end
end

User.each_batch do |relation|
  relation
    .joins("LEFT JOIN personal_access_tokens on personal_access_tokens.user_id = users.id")
    .where("personal_access_tokens.name = 'name'")
end

User.each_batch do |relation|
  relation.where("EXISTS (SELECT 1 FROM ...")
end

Issue.each_batch do |relation|
  relation
    .joins(:metrics)
    .joins(:merge_requests_closing_issues)
    .where("id IN (SELECT ...)")
    .where(confidential: true)
end

Issue.each_batch(of: 1000) do |relation|
  cte = Gitlab::SQL::CTE.new(:batched_relation, relation.limit(1000))
  scope = cte
    .apply_to(Issue.all)
    .joins(:metrics)
    .joins(:merge_requests_closing_issues)
    .where("id IN (SELECT ...)")
    .where(confidential: true)
  puts scope.to_a
end

count = 0
Issue.each_batch do |relation|
  count += relation.count
end
puts count

count, _last_value = Issue.each_batch_count # 此处可忽略 last_value

stop_at = Time.current + 3.minutes
count, last_value = Issue.each_batch_count do
  stop_at.past? # 停止计数的条件
end

# 稍后继续计数
stop_at = Time.current + 3.minutes
count, last_value = Issue.each_batch_count(last_count: count, last_value: last_value) do
  stop_at.past?
end

idx_issues_on_project_id_and_created_at_and_id" btree (project_id, created_at, id)

scope = Issue.where(project_id: 278964).order(:created_at, :id) # id 是决胜列
iterator = Gitlab::Pagination::Keyset::Iterator.new(scope: scope)
iterator.each_batch(of: 100) do |records|
  puts records.map(&:id)
end

scope = Issue.where(project_id: 278964).where('created_at > ?', 30.days.ago).order(:created_at, :id) # id 是决胜列
iterator = Gitlab::Pagination::Keyset::Iterator.new(scope: scope)
iterator.each_batch(of: 100) do |records|
  puts records.map(&:id)
end

scope = Issue.where(project_id: 278964).order(:created_at, :id) # id 是决胜列
iterator = Gitlab::Pagination::Keyset::Iterator.new(scope: scope)
iterator.each_batch(of: 100) do |records|
  ApplicationRecord.connection.execute("UPDATE issues SET updated_at=NOW() WHERE issues.id in (#{records.dup.reselect(:id).to_sql})")
end

# 自定义顺序对象配置：
order = Gitlab::Pagination::Keyset::Order.build([
  Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
    attribute_name: 'merge_request_diff_id',
    order_expression: MergeRequestDiffCommit.arel_table[:merge_request_diff_id].asc,
    nullable: :not_nullable
  ),
  Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
    attribute_name: 'relative_order',
    order_expression: MergeRequestDiffCommit.arel_table[:relative_order].asc,
    nullable: :not_nullable
  )
])
MergeRequestDiffCommit.include(FromUnion) # 键集分页生成 UNION 查询
scope = MergeRequestDiffCommit.order(order)
iterator = Gitlab::Pagination::Keyset::Iterator.new(scope: scope)
iterator.each_batch(of: 100) do |records|
  puts records.map { |record| [record.merge_request_diff_id, record.relative_order] }.inspect
end