var endBlock int
row := db.QueryRow(ctx, `select relpages from pg_class where oid = 'table1'::regclass::oid`)
err = row.Scan(&endBlock)
if err != nil {
  return
}

startBlock := 0
blocksPerIteration := 50
maxTuplesPerBlock := 150

for {
  var rows pgx.Rows
  rows, err = db.Query(ctx, `
      select id
      from table1
      where ctid = any (
        array(
            select format('(%s, %s)', a, b)::tid
            from generate_series($1::int, $2::int) a(a)
            cross join generate_series(0, $3) b(b)
        ))
        and value = '100000'`,
    startBlock,
    startBlock+blocksPerIteration,
    maxTuplesPerBlock,
  )
  if err != nil {
    return
  }
  var id int
  for rows.Next() {
    err = rows.Scan(&id)
    if err != nil {
      return
    }

    slog.Info("found row", "id", id)
  }
  rows.Close()

  startBlock += blocksPerIteration
  if startBlock > endBlock {
    break
  }
  time.Sleep(100 * time.Millisecond)
}

  r, w := io.Pipe()

  doneChan := make(chan struct{}, 1)

  go func() {
      defer close(doneChan)

      _, err := db1.PgConn().CopyTo(ctx, w, `copy table1 to stdin binary`)
      if err != nil {
          slog.Error("error", "error", err)
          return
      }
      _ = w.Close()
      doneChan <- struct{}{}
  }()

  _, err = db2.PgConn().CopyFrom(ctx, r, `copy table1 from stdout binary`)
  _ = r.Close()

  select {
  case <-doneChan:
  case <-ctx.Done():
  }

for i, v := range []int{2, 4, 6} {...}

for k, v := range map[string]int{“two”: 2, “four”: 4, “six”: 6} {...}

s := []int{2, 4, 6}
for i := len(s)-1; i >= 0; i-- {
  // ...  
}

type Iter[E any] func(body func(index int, value E))

func Backward[S ~[]E, E any](s S) Iter[E] {
  return func(body func(int, E)) {
    for i := len(s) - 1; i >= 0; i-- {
      body(i, s[i])
    }
  }
}

// Использование
backwardIter := Backward([]int{2, 4, 6})
backwardIter(func(index int, value int) {
  fmt.Printf("[%d]=%d\n", index, value)
})