Ограничительное предложение работает в postgres?

Итак, у меня есть таблица с 1000 строками, я просто говорю select * from hugedata limit 1 план запроса просто говорит table scan затем limit operator прилагается план запроса

    [
  {
    "Plan": {
      "Node Type": "Limit",
      "Parallel Aware": false,
      "Async Capable": false,
      "Startup Cost": 0.00,
      "Total Cost": 0.02,
      "Plan Rows": 1,
      "Plan Width": 41,
      "Actual Startup Time": 0.007,
      "Actual Total Time": 0.007,
      "Actual Rows": 1,
      "Actual Loops": 1,
      "Output": ["pk", "description", "flags"],
      "Shared Hit Blocks": 1,
      "Shared Read Blocks": 0,
      "Shared Dirtied Blocks": 0,
      "Shared Written Blocks": 0,
      "Local Hit Blocks": 0,
      "Local Read Blocks": 0,
      "Local Dirtied Blocks": 0,
      "Local Written Blocks": 0,
      "Temp Read Blocks": 0,
      "Temp Written Blocks": 0,
      "WAL Records": 0,
      "WAL FPI": 0,
      "WAL Bytes": 0,
      "Plans": [
        {
          "Node Type": "Seq Scan",
          "Parent Relationship": "Outer",
          "Parallel Aware": false,
          "Async Capable": false,
          "Relation Name": "hugedata",
          "Schema": "public",
          "Alias": "hugedata",
          "Startup Cost": 0.00,
          "Total Cost": 15406.01,
          "Plan Rows": 1000001,
          "Plan Width": 41,
          "Actual Startup Time": 0.006,
          "Actual Total Time": 0.006,
          "Actual Rows": 1,
          "Actual Loops": 1,
          "Output": ["pk", "description", "flags"],
          "Shared Hit Blocks": 1,
          "Shared Read Blocks": 0,
          "Shared Dirtied Blocks": 0,
          "Shared Written Blocks": 0,
          "Local Hit Blocks": 0,
          "Local Read Blocks": 0,
          "Local Dirtied Blocks": 0,
          "Local Written Blocks": 0,
          "Temp Read Blocks": 0,
          "Temp Written Blocks": 0,
          "WAL Records": 0,
          "WAL FPI": 0,
          "WAL Bytes": 0
        }
      ]
    },
    "Settings": {
    },
    "Planning": {
      "Shared Hit Blocks": 0,
      "Shared Read Blocks": 0,
      "Shared Dirtied Blocks": 0,
      "Shared Written Blocks": 0,
      "Local Hit Blocks": 0,
      "Local Read Blocks": 0,
      "Local Dirtied Blocks": 0,
      "Local Written Blocks": 0,
      "Temp Read Blocks": 0,
      "Temp Written Blocks": 0
    },
    "Planning Time": 0.035,
    "Triggers": [
    ],
    "Execution Time": 0.069
  }
]

Вопрос в том, как применяется ограничение в postgres?

1. DB Engine выбирает 1000 (все) записей, затем передает их оператору ограничения, где он принимает первую запись и отбрасывает 999 записей.

ИЛИ

2. DB Engine получает первую проверку записи обратно с помощью оператора ограничения, который принимает ее, затем DB Engines пытается выполнить поиск второй проверки записи с помощью оператора ограничения, который отклоняет ее, и DB Engine прекращает дальнейший поиск... Отличие от 1-го заключается в том, что DB Engine всегда работает (ищет/извлекает) для строк N+1 (ограниченное число), где в первой всегда получаются все строки в таблице.

Судя по моему поиску, оператор ограничения работает так, как было предложено в первом пункте, если это правда, то почему такая неэффективная реализация, или я что-то упускаю?

В документации по ограничениям говорится, что при создании плана запроса учитывается ограничение, но дает ли он результат в строке N+1 или «учтено» означает, что что-то еще не указано... https://www.postgresql.org/docs/ текущий/queries-limit.html