Removed unused functions

Removed metapage logging [skip ci]
Removed metapage [skip ci]
2026-07-22 03:57:34 +08:00 · 2023-12-19 19:47:03 -05:00 · 2023-12-19 17:23:35 -05:00 · 2023-12-19 17:20:55 -05:00 · 2023-12-19 17:01:11 -05:00 · 2023-12-19 17:00:14 -05:00
33 changed files with 1068 additions and 530 deletions
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -8,6 +8,8 @@ jobs:
      fail-fast: false
      matrix:
        include:
+          - postgres: 17
+            os: ubuntu-22.04
          - postgres: 16
            os: ubuntu-22.04
          - postgres: 15
@@ -21,7 +23,7 @@ jobs:
          - postgres: 11
            os: ubuntu-20.04
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: ankane/setup-postgres@v1
        with:
          postgres-version: ${{ matrix.postgres }}
@@ -43,7 +45,7 @@ jobs:
    runs-on: macos-latest
    if: ${{ !startsWith(github.ref_name, 'windows') }}
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: ankane/setup-postgres@v1
        with:
          postgres-version: 14
@@ -65,7 +67,7 @@ jobs:
    runs-on: windows-latest
    if: ${{ !startsWith(github.ref_name, 'mac') }}
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: ankane/setup-postgres@v1
        with:
          postgres-version: 14
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,15 @@
+## 0.5.2 (unreleased)
+
+- Improved performance of HNSW
+- Added support for on-disk parallel index builds for HNSW
+- Reduced WAL generation for HNSW index builds
+- Fixed `invalid memory alloc request size` error with HNSW index build
+
+## 0.5.1 (2023-10-10)
+
+- Improved performance of HNSW index builds
+- Added check for MVCC-compliant snapshot for index scans
+
 ## 0.5.0 (2023-08-28)

 - Added HNSW index type
--- a/META.json
+++ b/META.json
@@ -2,7 +2,7 @@
 	"name": "vector",
 	"abstract": "Open-source vector similarity search for Postgres",
 	"description": "Supports L2 distance, inner product, and cosine distance",
-	"version": "0.5.0",
+	"version": "0.5.1",
 	"maintainer": [
 		"Andrew Kane <andrew@ankane.org>"
 	],
@@ -20,7 +20,7 @@
 		"vector": {
 			"file": "sql/vector.sql",
 			"docfile": "README.md",
-			"version": "0.5.0",
+			"version": "0.5.1",
 			"abstract": "Open-source vector similarity search for Postgres"
 		}
 	},
--- a/4
+++ b/4
@@ -1,5 +1,5 @@
 EXTENSION = vector
-EXTVERSION = 0.5.0
+EXTVERSION = 0.5.1

 MODULE_big = vector
 DATA = $(wildcard sql/*--*.sql)
@@ -8,7 +8,7 @@ HEADERS = src/vector.h

 TESTS = $(wildcard test/sql/*.sql)
 REGRESS = $(patsubst test/sql/%.sql,%,$(TESTS))
-REGRESS_OPTS = --inputdir=test --load-extension=vector
+REGRESS_OPTS = --inputdir=test --load-extension=$(EXTENSION)

 OPTFLAGS = -march=native

--- a/Makefile.win
+++ b/Makefile.win
@@ -1,11 +1,11 @@
 EXTENSION = vector
-EXTVERSION = 0.5.0
+EXTVERSION = 0.5.1

 OBJS = src\hnsw.obj src\hnswbuild.obj src\hnswinsert.obj src\hnswscan.obj src\hnswutils.obj src\hnswvacuum.obj src\ivfbuild.obj src\ivfflat.obj src\ivfinsert.obj src\ivfkmeans.obj src\ivfscan.obj src\ivfutils.obj src\ivfvacuum.obj src\vector.obj
 HEADERS = src\vector.h

 REGRESS = btree cast copy functions input ivfflat_cosine ivfflat_ip ivfflat_l2 ivfflat_options ivfflat_unlogged
-REGRESS_OPTS = --inputdir=test --load-extension=vector
+REGRESS_OPTS = --inputdir=test --load-extension=$(EXTENSION)

 # For /arch flags
 # https://learn.microsoft.com/en-us/cpp/build/reference/arch-minimum-cpu-architecture
@@ -56,7 +56,7 @@ install:
 	copy $(EXTENSION).control "$(SHAREDIR)\extension"
 	copy sql\$(EXTENSION)--*.sql "$(SHAREDIR)\extension"
 	mkdir "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)"
-	copy $(HEADERS) "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)"
+	for %f in ($(HEADERS)) do copy %f "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)"

 installcheck:
 	"$(BINDIR)\pg_regress" --bindir="$(BINDIR)" $(REGRESS_OPTS) $(REGRESS)
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@ Store your vectors with the rest of your data. Supports:

 Plus [ACID](https://en.wikipedia.org/wiki/ACID) compliance, point-in-time recovery, JOINs, and all of the other [great features](https://www.postgresql.org/about/) of Postgres

-[![Build Status](https://github.com/pgvector/pgvector/workflows/build/badge.svg?branch=master)](https://github.com/pgvector/pgvector/actions)
+[![Build Status](https://github.com/pgvector/pgvector/actions/workflows/build.yml/badge.svg)](https://github.com/pgvector/pgvector/actions)

 ## Installation

@@ -18,7 +18,7 @@ Compile and install the extension (supports Postgres 11+)

 ```sh
 cd /tmp
-git clone --branch v0.5.0 https://github.com/pgvector/pgvector.git
+git clone --branch v0.5.1 https://github.com/pgvector/pgvector.git
 cd pgvector
 make
 make install # may need sudo
@@ -26,7 +26,7 @@ make install # may need sudo

 See the [installation notes](#installation-notes) if you run into issues

-You can also install it with [Docker](#docker), [Homebrew](#homebrew), [PGXN](#pgxn), [APT](#apt), [Yum](#yum), or [conda-forge](#conda-forge), and it comes preinstalled with [Postgres.app](#postgresapp) and many [hosted providers](#hosted-postgres)
+You can also install it with [Docker](#docker), [Homebrew](#homebrew), [PGXN](#pgxn), [APT](#apt), [Yum](#yum), or [conda-forge](#conda-forge), and it comes preinstalled with [Postgres.app](#postgresapp) and many [hosted providers](#hosted-postgres). There are also instructions for [GitHub Actions](https://github.com/pgvector/setup-pgvector).

 ## Getting Started

@@ -215,6 +215,23 @@ SELECT ...
 COMMIT;
 ```

+### Indexing Progress
+
+Check [indexing progress](https://www.postgresql.org/docs/current/progress-reporting.html#CREATE-INDEX-PROGRESS-REPORTING) with Postgres 12+
+
+```sql
+SELECT phase, round(100.0 * tuples_done / nullif(tuples_total, 0), 1) AS "%" FROM pg_stat_progress_create_index;
+```
+
+The phases for IVFFlat are:
+
+1. `initializing`
+2. `performing k-means`
+3. `assigning tuples`
+4. `loading tuples`
+
+Note: `%` is only populated during the `loading tuples` phase
+
 ## HNSW

 An HNSW index creates a multilayer graph. It has slower build times and uses more memory than IVFFlat, but has better query performance (in terms of speed-recall tradeoff). There’s no training step like IVFFlat, so the index can be created without any data in the table.
@@ -252,6 +269,8 @@ Specify HNSW parameters
 CREATE INDEX ON items USING hnsw (embedding vector_l2_ops) WITH (m = 16, ef_construction = 64);
 ```

+A higher value of `ef_construction` provides better recall at the cost of index build time / insert speed.
+
 ### Query Options

 Specify the size of the dynamic candidate list for search (40 by default)
@@ -271,22 +290,18 @@ SELECT ...
 COMMIT;
 ```

-## Indexing Progress
+### Indexing Progress

 Check [indexing progress](https://www.postgresql.org/docs/current/progress-reporting.html#CREATE-INDEX-PROGRESS-REPORTING) with Postgres 12+

 ```sql
-SELECT phase, tuples_done, tuples_total FROM pg_stat_progress_create_index;
+SELECT phase, round(100.0 * blocks_done / nullif(blocks_total, 0), 1) AS "%" FROM pg_stat_progress_create_index;
 ```

-The phases are:
+The phases for HNSW are:

 1. `initializing`
-2. `performing k-means` - IVFFlat only
-3. `assigning tuples` - IVFFlat only
-4. `loading tuples`
-
-Note: `tuples_done` and `tuples_total` are only populated during the `loading tuples` phase
+2. `loading tuples`

 ## Filtering

@@ -317,13 +332,15 @@ CREATE TABLE items (embedding vector(3), category_id int) PARTITION BY LIST(cate

 ## Hybrid Search

-Use together with Postgres [full-text search](https://www.postgresql.org/docs/current/textsearch-intro.html) for hybrid search ([Python example](https://github.com/pgvector/pgvector-python/blob/master/examples/hybrid_search.py)).
+Use together with Postgres [full-text search](https://www.postgresql.org/docs/current/textsearch-intro.html) for hybrid search.

 ```sql
 SELECT id, content FROM items, plainto_tsquery('hello search') query
    WHERE textsearch @@ query ORDER BY ts_rank_cd(textsearch, query) DESC LIMIT 5;
 ```

+You can use [Reciprocal Rank Fusion](https://github.com/pgvector/pgvector-python/blob/master/examples/hybrid_search_rrf.py) or a [cross-encoder](https://github.com/pgvector/pgvector-python/blob/master/examples/hybrid_search.py) to combine results.
+
 ## Performance

 Use `EXPLAIN ANALYZE` to debug performance.
@@ -360,17 +377,21 @@ Use pgvector from any language with a Postgres client. You can even generate and

 Language | Libraries / Examples
 --- | ---
+C | [pgvector-c](https://github.com/pgvector/pgvector-c)
 C++ | [pgvector-cpp](https://github.com/pgvector/pgvector-cpp)
-C# | [pgvector-dotnet](https://github.com/pgvector/pgvector-dotnet)
+C#, F#, Visual Basic | [pgvector-dotnet](https://github.com/pgvector/pgvector-dotnet)
 Crystal | [pgvector-crystal](https://github.com/pgvector/pgvector-crystal)
 Dart | [pgvector-dart](https://github.com/pgvector/pgvector-dart)
 Elixir | [pgvector-elixir](https://github.com/pgvector/pgvector-elixir)
 Go | [pgvector-go](https://github.com/pgvector/pgvector-go)
 Haskell | [pgvector-haskell](https://github.com/pgvector/pgvector-haskell)
-Java, Scala | [pgvector-java](https://github.com/pgvector/pgvector-java)
+Java, Kotlin, Groovy, Scala | [pgvector-java](https://github.com/pgvector/pgvector-java)
+JavaScript, TypeScript | [pgvector-node](https://github.com/pgvector/pgvector-node)
 Julia | [pgvector-julia](https://github.com/pgvector/pgvector-julia)
+Lisp | [pgvector-lisp](https://github.com/pgvector/pgvector-lisp)
 Lua | [pgvector-lua](https://github.com/pgvector/pgvector-lua)
-Node.js | [pgvector-node](https://github.com/pgvector/pgvector-node)
+Nim | [pgvector-nim](https://github.com/pgvector/pgvector-nim)
+OCaml | [pgvector-ocaml](https://github.com/pgvector/pgvector-ocaml)
 Perl | [pgvector-perl](https://github.com/pgvector/pgvector-perl)
 PHP | [pgvector-php](https://github.com/pgvector/pgvector-php)
 Python | [pgvector-python](https://github.com/pgvector/pgvector-python)
@@ -378,6 +399,7 @@ R | [pgvector-r](https://github.com/pgvector/pgvector-r)
 Ruby | [pgvector-ruby](https://github.com/pgvector/pgvector-ruby), [Neighbor](https://github.com/ankane/neighbor)
 Rust | [pgvector-rust](https://github.com/pgvector/pgvector-rust)
 Swift | [pgvector-swift](https://github.com/pgvector/pgvector-swift)
+Zig | [pgvector-zig](https://github.com/pgvector/pgvector-zig)

 ## Frequently Asked Questions

@@ -393,6 +415,63 @@ Yes, pgvector uses the write-ahead log (WAL), which allows for replication and p

 You’ll need to use [dimensionality reduction](https://en.wikipedia.org/wiki/Dimensionality_reduction) at the moment.

+#### Can I store vectors with different dimensions in the same column?
+
+You can use `vector` as the type (instead of `vector(3)`).
+
+```sql
+CREATE TABLE embeddings (model_id bigint, item_id bigint, embedding vector, PRIMARY KEY (model_id, item_id));
+```
+
+However, you can only create indexes on rows with the same number of dimensions (using [expression](https://www.postgresql.org/docs/current/indexes-expressional.html) and [partial](https://www.postgresql.org/docs/current/indexes-partial.html) indexing):
+
+```sql
+CREATE INDEX ON embeddings USING hnsw ((embedding::vector(3)) vector_l2_ops) WHERE (model_id = 123);
+```
+
+and query with:
+
+```sql
+SELECT * FROM embeddings WHERE model_id = 123 ORDER BY embedding::vector(3) <-> '[3,1,2]' LIMIT 5;
+```
+
+#### Can I store vectors with more precision?
+
+You can use the `double precision[]` or `numeric[]` type to store vectors with more precision.
+
+```sql
+CREATE TABLE items (id bigserial PRIMARY KEY, embedding double precision[]);
+
+-- use {} instead of [] for Postgres arrays
+INSERT INTO items (embedding) VALUES ('{1,2,3}'), ('{4,5,6}');
+```
+
+Optionally, add a [check constraint](https://www.postgresql.org/docs/current/ddl-constraints.html) to ensure data can be converted to the `vector` type and has the expected dimensions.
+
+```sql
+ALTER TABLE items ADD CHECK (vector_dims(embedding::vector) = 3);
+```
+
+Use [expression indexing](https://www.postgresql.org/docs/current/indexes-expressional.html) to index (at a lower precision):
+
+```sql
+CREATE INDEX ON items USING hnsw ((embedding::vector(3)) vector_l2_ops);
+```
+
+and query with:
+
+```sql
+SELECT * FROM items ORDER BY embedding::vector(3) <-> '[3,1,2]' LIMIT 5;
+```
+
+#### Do indexes need to fit into memory?
+
+No, but like other index types, you’ll likely see better performance if they do. You can get the size of an index with:
+
+```sql
+SELECT pg_size_pretty(pg_relation_size('index_name'));
+```
+
 ## Troubleshooting

 #### Why isn’t a query using an index?
@@ -406,6 +485,8 @@ SELECT ...
 COMMIT;
 ```

+Also, if the table is small, a table scan may be faster.
+
 #### Why isn’t a query using a parallel table scan?

 The planner doesn’t consider [out-of-line storage](https://www.postgresql.org/docs/current/storage-toast.html) in cost estimates, which can make a serial scan look cheaper. You can reduce the cost of a parallel scan for a query with:
@@ -509,7 +590,7 @@ Then use `nmake` to build:

 ```cmd
 set "PGROOT=C:\Program Files\PostgreSQL\15"
-git clone --branch v0.5.0 https://github.com/pgvector/pgvector.git
+git clone --branch v0.5.1 https://github.com/pgvector/pgvector.git
 cd pgvector
 nmake /F Makefile.win
 nmake /F Makefile.win install
@@ -530,7 +611,7 @@ This adds pgvector to the [Postgres image](https://hub.docker.com/_/postgres) (r
 You can also build the image manually:

 ```sh
-git clone --branch v0.5.0 https://github.com/pgvector/pgvector.git
+git clone --branch v0.5.1 https://github.com/pgvector/pgvector.git
 cd pgvector
 docker build --build-arg PG_MAJOR=15 -t myuser/pgvector .
 ```
@@ -595,12 +676,18 @@ pgvector is available on [these providers](https://github.com/pgvector/pgvector/

 ## Upgrading

-Install the latest version and run:
+[Install](#installation) the latest version (use the same method as the original installation). Then in each database you want to upgrade, run:

 ```sql
 ALTER EXTENSION vector UPDATE;
 ```

+You can check the version in the current database with:
+
+```sql
+SELECT extversion FROM pg_extension WHERE extname = 'vector';
+```
+
 ## Upgrade Notes

 ### 0.4.0
--- a/sql/vector--0.5.0--0.5.1.sql
+++ b/sql/vector--0.5.0--0.5.1.sql
@@ -0,0 +1,2 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.5.1'" to load this file. \quit
--- a/src/hnsw.c
+++ b/src/hnsw.c
@@ -14,6 +14,7 @@
 #endif

 int			hnsw_ef_search;
+bool		hnsw_enable_parallel_build;
 static relopt_kind hnsw_relopt_kind;

 /*
@@ -39,6 +40,11 @@ HnswInit(void)
 	DefineCustomIntVariable("hnsw.ef_search", "Sets the size of the dynamic candidate list for search",
 							"Valid range is 1..1000.", &hnsw_ef_search,
 							HNSW_DEFAULT_EF_SEARCH, HNSW_MIN_EF_SEARCH, HNSW_MAX_EF_SEARCH, PGC_USERSET, 0, NULL, NULL, NULL);
+
+	/* Behind a variable for now since can be slower than building in memory */
+	DefineCustomBoolVariable("hnsw.enable_parallel_build", "Enables or disables building indexes in parallel",
+							 NULL, &hnsw_enable_parallel_build,
+							 false, PGC_USERSET, 0, NULL, NULL, NULL);
 }

 /*
@@ -91,7 +97,7 @@ hnswcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	MemSet(&costs, 0, sizeof(costs));

 	index = index_open(path->indexinfo->indexoid, NoLock);
-	m = HnswGetM(index);
+	HnswGetMetaPageInfo(index, &m, NULL);
 	index_close(index, NoLock);

 	/* Approximate entry level */
@@ -196,7 +202,7 @@ hnswhandler(PG_FUNCTION_ARGS)
 	amroutine->aminsert = hnswinsert;
 	amroutine->ambulkdelete = hnswbulkdelete;
 	amroutine->amvacuumcleanup = hnswvacuumcleanup;
-	amroutine->amcanreturn = NULL;	/* tuple not included in heapsort */
+	amroutine->amcanreturn = NULL;
 	amroutine->amcostestimate = hnswcostestimate;
 	amroutine->amoptions = hnswoptions;
 	amroutine->amproperty = NULL;	/* TODO AMPROP_DISTANCE_ORDERABLE */
--- a/src/hnsw.h
+++ b/src/hnsw.h
@@ -62,7 +62,9 @@
 /* PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE is 1 */
 #define PROGRESS_HNSW_PHASE_LOAD		2

-#define HNSW_ELEMENT_TUPLE_SIZE(_dim)	MAXALIGN(offsetof(HnswElementTupleData, vec) + VECTOR_SIZE(_dim))
+#define HNSW_MAX_SIZE (BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData)) - sizeof(ItemIdData))
+
+#define HNSW_ELEMENT_TUPLE_SIZE(size)	MAXALIGN(offsetof(HnswElementTupleData, data) + (size))
 #define HNSW_NEIGHBOR_TUPLE_SIZE(level, m)	MAXALIGN(offsetof(HnswNeighborTupleData, indextids) + ((level) + 2) * (m) * sizeof(ItemPointerData))

 #define HnswPageGetOpaque(page)	((HnswPageOpaque) PageGetSpecialPointer(page))
@@ -93,6 +95,7 @@

 /* Variables */
 extern int	hnsw_ef_search;
+extern bool hnsw_enable_parallel_build;

 typedef struct HnswNeighborArray HnswNeighborArray;

@@ -101,12 +104,13 @@ typedef struct HnswElementData
 	List	   *heaptids;
 	uint8		level;
 	uint8		deleted;
+	uint32		hash;
 	HnswNeighborArray *neighbors;
 	BlockNumber blkno;
 	OffsetNumber offno;
 	OffsetNumber neighborOffno;
 	BlockNumber neighborPage;
-	Vector	   *vec;
+	Datum		value;
 }			HnswElementData;

 typedef HnswElementData * HnswElement;
@@ -115,11 +119,13 @@ typedef struct HnswCandidate
 {
 	HnswElement element;
 	float		distance;
+	bool		closer;
 }			HnswCandidate;

 typedef struct HnswNeighborArray
 {
 	int			length;
+	bool		closerSet;
 	HnswCandidate *items;
 }			HnswNeighborArray;

@@ -207,7 +213,7 @@ typedef struct HnswBuildState
 	HnswElement entryPoint;
 	double		ml;
 	int			maxLevel;
-	double		maxInMemoryElements;
+	long		memoryLeft;
 	bool		flushed;
 	Vector	   *normvec;

@@ -216,6 +222,7 @@ typedef struct HnswBuildState

 	/* Parallel builds */
 	HnswLeader *hnswleader;
+	HnswShared *hnswshared;
 }			HnswBuildState;

 typedef struct HnswMetaPageData
@@ -251,7 +258,7 @@ typedef struct HnswElementTupleData
 	ItemPointerData heaptids[HNSW_HEAPTIDS];
 	ItemPointerData neighbortid;
 	uint16		unused2;
-	Vector		vec;
+	Vector		data;
 }			HnswElementTupleData;

 typedef HnswElementTupleData * HnswElementTuple;
@@ -269,7 +276,6 @@ typedef HnswNeighborTupleData * HnswNeighborTuple;
 typedef struct HnswScanOpaqueData
 {
 	bool		first;
-	Buffer		buf;
 	List	   *w;
 	MemoryContext tmpCtx;

@@ -298,7 +304,7 @@ typedef struct HnswVacuumState
 	Oid			collation;

 	/* Variables */
-	HTAB	   *deleted;
+	struct tidhash_hash *deleted;
 	BufferAccessStrategy bas;
 	HnswNeighborTuple ntup;
 	HnswElementData highestPoint;
@@ -310,32 +316,31 @@ typedef struct HnswVacuumState
 /* Methods */
 int			HnswGetM(Relation index);
 int			HnswGetEfConstruction(Relation index);
-FmgrInfo   *HnswOptionalProcInfo(Relation rel, uint16 procnum);
+FmgrInfo   *HnswOptionalProcInfo(Relation index, uint16 procnum);
 bool		HnswNormValue(FmgrInfo *procinfo, Oid collation, Datum *value, Vector * result);
-void		HnswCommitBuffer(Buffer buf, GenericXLogState *state);
 Buffer		HnswNewBuffer(Relation index, ForkNumber forkNum);
 void		HnswInitPage(Buffer buf, Page page);
-void		HnswInitRegisterPage(Relation index, Buffer *buf, Page *page, GenericXLogState **state);
 void		HnswInit(void);
-List	   *HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, bool inserting, HnswElement skipElement);
+List	   *HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, int m, bool inserting, HnswElement skipElement);
 HnswElement HnswGetEntryPoint(Relation index);
+void		HnswGetMetaPageInfo(Relation index, int *m, HnswElement * entryPoint);
 HnswElement HnswInitElement(ItemPointer tid, int m, double ml, int maxLevel);
 void		HnswFreeElement(HnswElement element);
 HnswElement HnswInitElementFromBlock(BlockNumber blkno, OffsetNumber offno);
 void		HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, FmgrInfo *procinfo, Oid collation, int m, int efConstruction, bool existing);
 HnswElement HnswFindDuplicate(HnswElement e);
 HnswCandidate *HnswEntryCandidate(HnswElement em, Datum q, Relation rel, FmgrInfo *procinfo, Oid collation, bool loadVec);
-void		HnswUpdateMetaPage(Relation index, int updateEntry, HnswElement entryPoint, BlockNumber insertPage, ForkNumber forkNum);
+void		HnswUpdateMetaPage(Relation index, int updateEntry, HnswElement entryPoint, BlockNumber insertPage, ForkNumber forkNum, bool building);
 void		HnswSetNeighborTuple(HnswNeighborTuple ntup, HnswElement e, int m);
 void		HnswAddHeapTid(HnswElement element, ItemPointer heaptid);
 void		HnswInitNeighbors(HnswElement element, int m);
-bool		HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, Relation heapRel);
-void		HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting);
+bool		HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, Relation heapRel, bool building);
+void		HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting, bool building);
 void		HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHeaptids, bool loadVec);
 void		HnswLoadElement(HnswElement element, float *distance, Datum *q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadVec);
 void		HnswSetElementTuple(HnswElementTuple etup, HnswElement element);
 void		HnswUpdateConnection(HnswElement element, HnswCandidate * hc, int m, int lc, int *updateIdx, Relation index, FmgrInfo *procinfo, Oid collation);
-void		HnswLoadNeighbors(HnswElement element, Relation index);
+void		HnswLoadNeighbors(HnswElement element, Relation index, int m);
 PGDLLEXPORT void HnswParallelBuildMain(dsm_segment *seg, shm_toc *toc);

 /* Index access methods */
@@ -354,4 +359,31 @@ void		hnswrescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys,
 bool		hnswgettuple(IndexScanDesc scan, ScanDirection dir);
 void		hnswendscan(IndexScanDesc scan);

+/* Hash tables */
+typedef struct TidHashEntry
+{
+	ItemPointerData tid;
+	char		status;
+}			TidHashEntry;
+
+#define SH_PREFIX tidhash
+#define SH_ELEMENT_TYPE TidHashEntry
+#define SH_KEY_TYPE ItemPointerData
+#define SH_SCOPE extern
+#define SH_DECLARE
+#include "lib/simplehash.h"
+
+typedef struct PointerHashEntry
+{
+	uintptr_t	ptr;
+	char		status;
+}			PointerHashEntry;
+
+#define SH_PREFIX pointerhash
+#define SH_ELEMENT_TYPE PointerHashEntry
+#define SH_KEY_TYPE uintptr_t
+#define SH_SCOPE extern
+#define SH_DECLARE
+#include "lib/simplehash.h"
+
 #endif
--- a/src/hnswbuild.c
+++ b/src/hnswbuild.c
@@ -11,6 +11,7 @@
 #include "nodes/pg_list.h"
 #include "storage/bufmgr.h"
 #include "tcop/tcopprot.h"
+#include "utils/datum.h"
 #include "utils/memutils.h"

 #if PG_VERSION_NUM >= 140000
@@ -55,6 +56,8 @@
 #define PARALLEL_KEY_HNSW_SHARED		UINT64CONST(0xA000000000000001)
 #define PARALLEL_KEY_QUERY_TEXT			UINT64CONST(0xA000000000000002)

+#define LIST_MAX_LENGTH ((1 << 26) - 1)
+
 /*
 * Create the metapage
 */
@@ -65,11 +68,11 @@ CreateMetaPage(HnswBuildState * buildstate)
 	ForkNumber	forkNum = buildstate->forkNum;
 	Buffer		buf;
 	Page		page;
-	GenericXLogState *state;
 	HnswMetaPage metap;

 	buf = HnswNewBuffer(index, forkNum);
-	HnswInitRegisterPage(index, &buf, &page, &state);
+	page = BufferGetPage(buf);
+	HnswInitPage(buf, page);

 	/* Set metapage data */
 	metap = HnswPageGetMeta(page);
@@ -85,14 +88,14 @@ CreateMetaPage(HnswBuildState * buildstate)
 	((PageHeader) page)->pd_lower =
 		((char *) metap + sizeof(HnswMetaPageData)) - (char *) page;

-	HnswCommitBuffer(buf, state);
+	UnlockReleaseBuffer(buf);
 }

 /*
 * Add a new page
 */
 static void
-HnswBuildAppendPage(Relation index, Buffer *buf, Page *page, GenericXLogState **state, ForkNumber forkNum)
+HnswBuildAppendPage(Relation index, Buffer *buf, Page *page, ForkNumber forkNum)
 {
 	/* Add a new page */
 	Buffer		newbuf = HnswNewBuffer(index, forkNum);
@@ -101,8 +104,6 @@ HnswBuildAppendPage(Relation index, Buffer *buf, Page *page, GenericXLogState **
 	HnswPageGetOpaque(*page)->nextblkno = BufferGetBlockNumber(newbuf);

 	/* Commit */
-	MarkBufferDirty(*buf);
-	GenericXLogFinish(*state);
 	UnlockReleaseBuffer(*buf);

 	/* Can take a while, so ensure we can interrupt */
@@ -113,8 +114,7 @@ HnswBuildAppendPage(Relation index, Buffer *buf, Page *page, GenericXLogState **

 	/* Prepare new page */
 	*buf = newbuf;
-	*state = GenericXLogStart(index);
-	*page = GenericXLogRegisterBuffer(*state, *buf, GENERIC_XLOG_FULL_IMAGE);
+	*page = BufferGetPage(*buf);
 	HnswInitPage(*buf, *page);
 }

@@ -126,46 +126,52 @@ CreateElementPages(HnswBuildState * buildstate)
 {
 	Relation	index = buildstate->index;
 	ForkNumber	forkNum = buildstate->forkNum;
-	int			dimensions = buildstate->dimensions;
-	Size		etupSize;
+	Size		etupAllocSize;
 	Size		maxSize;
 	HnswElementTuple etup;
 	HnswNeighborTuple ntup;
 	BlockNumber insertPage;
 	Buffer		buf;
 	Page		page;
-	GenericXLogState *state;
 	ListCell   *lc;

 	/* Calculate sizes */
-	maxSize = BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData));
-	etupSize = HNSW_ELEMENT_TUPLE_SIZE(dimensions);
+	etupAllocSize = BLCKSZ;
+	maxSize = HNSW_MAX_SIZE;

 	/* Allocate once */
-	etup = palloc0(etupSize);
-	ntup = palloc0(maxSize);
+	etup = palloc0(etupAllocSize);
+	ntup = palloc0(BLCKSZ);

 	/* Prepare first page */
 	buf = HnswNewBuffer(index, forkNum);
-	state = GenericXLogStart(index);
-	page = GenericXLogRegisterBuffer(state, buf, GENERIC_XLOG_FULL_IMAGE);
+	page = BufferGetPage(buf);
 	HnswInitPage(buf, page);

 	foreach(lc, buildstate->elements)
 	{
 		HnswElement element = lfirst(lc);
+		Size		etupSize;
 		Size		ntupSize;
 		Size		combinedSize;

-		HnswSetElementTuple(etup, element);
+		/* Zero memory for each element */
+		MemSet(etup, 0, etupAllocSize);

 		/* Calculate sizes */
+		etupSize = HNSW_ELEMENT_TUPLE_SIZE(VARSIZE_ANY(DatumGetPointer(element->value)));
 		ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(element->level, buildstate->m);
 		combinedSize = etupSize + ntupSize + sizeof(ItemIdData);

+		/* Initial size check */
+		if (etupSize > etupAllocSize)
+			elog(ERROR, "index tuple too large");
+
+		HnswSetElementTuple(etup, element);
+
 		/* Keep element and neighbors on the same page if possible */
 		if (PageGetFreeSpace(page) < etupSize || (combinedSize <= maxSize && PageGetFreeSpace(page) < combinedSize))
-			HnswBuildAppendPage(index, &buf, &page, &state, forkNum);
+			HnswBuildAppendPage(index, &buf, &page, forkNum);

 		/* Calculate offsets */
 		element->blkno = BufferGetBlockNumber(buf);
@@ -189,7 +195,7 @@ CreateElementPages(HnswBuildState * buildstate)

 		/* Add new page if needed */
 		if (PageGetFreeSpace(page) < ntupSize)
-			HnswBuildAppendPage(index, &buf, &page, &state, forkNum);
+			HnswBuildAppendPage(index, &buf, &page, forkNum);

 		/* Add placeholder for neighbors */
 		if (PageAddItem(page, (Item) ntup, ntupSize, InvalidOffsetNumber, false, false) != element->neighborOffno)
@@ -199,11 +205,9 @@ CreateElementPages(HnswBuildState * buildstate)
 	insertPage = BufferGetBlockNumber(buf);

 	/* Commit */
-	MarkBufferDirty(buf);
-	GenericXLogFinish(state);
 	UnlockReleaseBuffer(buf);

-	HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_ALWAYS, buildstate->entryPoint, insertPage, forkNum);
+	HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_ALWAYS, buildstate->entryPoint, insertPage, forkNum, true);

 	pfree(etup);
 	pfree(ntup);
@@ -229,7 +233,6 @@ CreateNeighborPages(HnswBuildState * buildstate)
 		HnswElement e = lfirst(lc);
 		Buffer		buf;
 		Page		page;
-		GenericXLogState *state;
 		Size		ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(e->level, m);

 		/* Can take a while, so ensure we can interrupt */
@@ -238,8 +241,7 @@ CreateNeighborPages(HnswBuildState * buildstate)

 		buf = ReadBufferExtended(index, forkNum, e->neighborPage, RBM_NORMAL, NULL);
 		LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
-		state = GenericXLogStart(index);
-		page = GenericXLogRegisterBuffer(state, buf, 0);
+		page = BufferGetPage(buf);

 		HnswSetNeighborTuple(ntup, e, m);

@@ -247,8 +249,6 @@ CreateNeighborPages(HnswBuildState * buildstate)
 			elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));

 		/* Commit */
-		MarkBufferDirty(buf);
-		GenericXLogFinish(state);
 		UnlockReleaseBuffer(buf);
 	}

@@ -287,13 +287,14 @@ FlushPages(HnswBuildState * buildstate)
 * Insert tuple
 */
 static bool
-InsertTuple(Relation index, Datum *values, HnswElement element, HnswBuildState * buildstate, HnswElement * dup)
+InsertTuple(Relation index, Datum *values, HnswElement element, HnswBuildState * buildstate, HnswElement * dup, MemoryContext outerCtx)
 {
 	FmgrInfo   *procinfo = buildstate->procinfo;
 	Oid			collation = buildstate->collation;
 	HnswElement entryPoint = buildstate->entryPoint;
 	int			efConstruction = buildstate->efConstruction;
 	int			m = buildstate->m;
+	MemoryContext oldCtx;

 	/* Detoast once for all calls */
 	Datum		value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
@@ -306,7 +307,9 @@ InsertTuple(Relation index, Datum *values, HnswElement element, HnswBuildState *
 	}

 	/* Copy value to element so accessible outside of memory context */
-	memcpy(element->vec, DatumGetVector(value), VECTOR_SIZE(buildstate->dimensions));
+	oldCtx = MemoryContextSwitchTo(outerCtx);
+	element->value = datumCopy(value, false, -1);
+	MemoryContextSwitchTo(oldCtx);

 	/* Insert element in graph */
 	HnswInsertElement(element, entryPoint, NULL, procinfo, collation, m, efConstruction, false);
@@ -336,6 +339,21 @@ InsertTuple(Relation index, Datum *values, HnswElement element, HnswBuildState *
 	return *dup == NULL;
 }

+/*
+ * Get the memory used by an element
+ */
+static long
+HnswElementMemory(HnswElement e, int m)
+{
+	long		elementSize = sizeof(HnswElementData);
+
+	elementSize += sizeof(HnswNeighborArray) * (e->level + 1);
+	elementSize += sizeof(HnswCandidate) * (m * (e->level + 2));
+	elementSize += sizeof(ItemPointerData);
+	elementSize += VARSIZE_ANY(DatumGetPointer(e->value));
+	return elementSize;
+}
+
 /*
 * Callback for table_index_build_scan
 */
@@ -357,23 +375,34 @@ BuildCallback(Relation index, CALLBACK_ITEM_POINTER, Datum *values,
 	if (isnull[0])
 		return;

-	if (buildstate->indtuples >= buildstate->maxInMemoryElements)
+	if (buildstate->flushed || buildstate->memoryLeft <= 0 || list_length(buildstate->elements) == LIST_MAX_LENGTH)
 	{
 		if (!buildstate->flushed)
 		{
-			ereport(NOTICE,
-					(errmsg("hnsw graph no longer fits into maintenance_work_mem after " INT64_FORMAT " tuples", (int64) buildstate->indtuples),
-					 errdetail("Building will take significantly more time."),
-					 errhint("Increase maintenance_work_mem to speed up builds.")));
+			if (buildstate->memoryLeft <= 0)
+				ereport(NOTICE,
+						(errmsg("hnsw graph no longer fits into maintenance_work_mem after " INT64_FORMAT " tuples", (int64) buildstate->indtuples),
+						 errdetail("Building will take significantly more time."),
+						 errhint("Increase maintenance_work_mem to speed up builds.")));

 			FlushPages(buildstate);
 		}

 		oldCtx = MemoryContextSwitchTo(buildstate->tmpCtx);

-		/* TODO Fix progress for parallel builds */
-		if (HnswInsertTuple(buildstate->index, values, isnull, tid, buildstate->heap))
-			UpdateProgress(PROGRESS_CREATEIDX_TUPLES_DONE, ++buildstate->indtuples);
+		if (HnswInsertTuple(buildstate->index, values, isnull, tid, buildstate->heap, true))
+		{
+			if (buildstate->hnswshared)
+			{
+				HnswShared *hnswshared = buildstate->hnswshared;
+
+				SpinLockAcquire(&hnswshared->mutex);
+				UpdateProgress(PROGRESS_CREATEIDX_TUPLES_DONE, ++hnswshared->indtuples);
+				SpinLockRelease(&hnswshared->mutex);
+			}
+			else
+				UpdateProgress(PROGRESS_CREATEIDX_TUPLES_DONE, ++buildstate->indtuples);
+		}

 		/* Reset memory context */
 		MemoryContextSwitchTo(oldCtx);
@@ -384,13 +413,12 @@ BuildCallback(Relation index, CALLBACK_ITEM_POINTER, Datum *values,

 	/* Allocate necessary memory outside of memory context */
 	element = HnswInitElement(tid, buildstate->m, buildstate->ml, buildstate->maxLevel);
-	element->vec = palloc(VECTOR_SIZE(buildstate->dimensions));

 	/* Use memory context since detoast can allocate */
 	oldCtx = MemoryContextSwitchTo(buildstate->tmpCtx);

 	/* Insert tuple */
-	inserted = InsertTuple(index, values, element, buildstate, &dup);
+	inserted = InsertTuple(index, values, element, buildstate, &dup, oldCtx);

 	/* Reset memory context */
 	MemoryContextSwitchTo(oldCtx);
@@ -398,31 +426,21 @@ BuildCallback(Relation index, CALLBACK_ITEM_POINTER, Datum *values,

 	/* Add outside memory context */
 	if (dup != NULL)
+	{
 		HnswAddHeapTid(dup, tid);
+		buildstate->memoryLeft -= sizeof(ItemPointerData);
+	}

 	/* Add to buildstate or free */
 	if (inserted)
+	{
 		buildstate->elements = lappend(buildstate->elements, element);
+		buildstate->memoryLeft -= HnswElementMemory(element, buildstate->m);
+	}
 	else
 		HnswFreeElement(element);
 }

-/*
- * Get the max number of elements that fit into maintenance_work_mem
- */
-static double
-HnswGetMaxInMemoryElements(int m, double ml, int dimensions)
-{
-	Size		elementSize = sizeof(HnswElementData);
-	double		avgLevel = -log(0.5) * ml;
-
-	elementSize += sizeof(HnswNeighborArray) * (avgLevel + 1);
-	elementSize += sizeof(HnswCandidate) * (m * (avgLevel + 2));
-	elementSize += sizeof(ItemPointerData);
-	elementSize += VECTOR_SIZE(dimensions);
-	return (maintenance_work_mem * 1024L) / elementSize;
-}
-
 /*
 * Initialize the build state
 */
@@ -460,7 +478,7 @@ InitBuildState(HnswBuildState * buildstate, Relation heap, Relation index, Index
 	buildstate->entryPoint = NULL;
 	buildstate->ml = HnswGetMl(buildstate->m);
 	buildstate->maxLevel = HnswGetMaxLevel(buildstate->m);
-	buildstate->maxInMemoryElements = HnswGetMaxInMemoryElements(buildstate->m, buildstate->ml, buildstate->dimensions);
+	buildstate->memoryLeft = maintenance_work_mem * 1024L;
 	buildstate->flushed = false;

 	/* Reuse for each tuple */
@@ -471,6 +489,7 @@ InitBuildState(HnswBuildState * buildstate, Relation heap, Relation index, Index
 											   ALLOCSET_DEFAULT_SIZES);

 	buildstate->hnswleader = NULL;
+	buildstate->hnswshared = NULL;
 }

 /*
@@ -535,8 +554,9 @@ HnswParallelScanAndInsert(HnswSpool * hnswspool, HnswShared * hnswshared, bool p
 	indexInfo->ii_Concurrent = hnswshared->isconcurrent;
 	InitBuildState(&buildstate, hnswspool->heap, hnswspool->index, indexInfo, MAIN_FORKNUM);
 	/* TODO Support in-memory builds */
-	buildstate.maxInMemoryElements = 0;
+	buildstate.memoryLeft = 0;
 	buildstate.flushed = true;
+	buildstate.hnswshared = hnswshared;
 #if PG_VERSION_NUM >= 120000
 	scan = table_beginscan_parallel(hnswspool->heap,
 									ParallelTableScanFromHnswShared(hnswshared));
@@ -554,7 +574,6 @@ HnswParallelScanAndInsert(HnswSpool * hnswspool, HnswShared * hnswshared, bool p
 	SpinLockAcquire(&hnswshared->mutex);
 	hnswshared->nparticipantsdone++;
 	hnswshared->reltuples += reltuples;
-	hnswshared->indtuples += buildstate.indtuples;
 	SpinLockRelease(&hnswshared->mutex);

 	/* Log statistics */
@@ -823,7 +842,8 @@ BuildGraph(HnswBuildState * buildstate, ForkNumber forkNum)
 	UpdateProgress(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_HNSW_PHASE_LOAD);

 	/* Calculate parallel workers */
-	parallel_workers = plan_create_index_workers(RelationGetRelid(buildstate->heap), RelationGetRelid(buildstate->index));
+	if (hnsw_enable_parallel_build)
+		parallel_workers = plan_create_index_workers(RelationGetRelid(buildstate->heap), RelationGetRelid(buildstate->index));

 	/* Attempt to launch parallel worker scan when required */
 	if (parallel_workers > 0)
@@ -852,6 +872,22 @@ BuildGraph(HnswBuildState * buildstate, ForkNumber forkNum)
 		HnswEndParallel(buildstate->hnswleader);
 }

+#if PG_VERSION_NUM < 110008
+void
+log_newpage_range(Relation rel, ForkNumber forkNum, BlockNumber startblk, BlockNumber endblk, bool page_std)
+{
+	for (BlockNumber blkno = startblk; blkno < endblk; blkno++)
+	{
+		Buffer		buf = ReadBufferExtended(rel, forkNum, blkno, RBM_NORMAL, NULL);
+
+		LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
+		MarkBufferDirty(buf);
+		log_newpage_buffer(buf, page_std);
+		UnlockReleaseBuffer(buf);
+	}
+}
+#endif
+
 /*
 * Build the index
 */
@@ -867,6 +903,9 @@ BuildIndex(Relation heap, Relation index, IndexInfo *indexInfo,
 	if (!buildstate->flushed)
 		FlushPages(buildstate);

+	if (RelationNeedsWAL(index))
+		log_newpage_range(index, forkNum, 0, RelationGetNumberOfBlocks(index), true);
+
 	FreeBuildState(buildstate);
 }

--- a/src/hnswinsert.c
+++ b/src/hnswinsert.c
@@ -92,7 +92,7 @@ HnswFreeOffset(Relation index, Buffer buf, Page page, HnswElement element, Size
 * Add a new page
 */
 static void
-HnswInsertAppendPage(Relation index, Buffer *nbuf, Page *npage, GenericXLogState *state, Page page)
+HnswInsertAppendPage(Relation index, Buffer *nbuf, Page *npage, GenericXLogState *state, Page page, bool building)
 {
 	/* Add a new page */
 	LockRelationForExtension(index, ExclusiveLock);
@@ -100,7 +100,11 @@ HnswInsertAppendPage(Relation index, Buffer *nbuf, Page *npage, GenericXLogState
 	UnlockRelationForExtension(index, ExclusiveLock);

 	/* Init new page */
-	*npage = GenericXLogRegisterBuffer(state, *nbuf, GENERIC_XLOG_FULL_IMAGE);
+	if (building)
+		*npage = BufferGetPage(*nbuf);
+	else
+		*npage = GenericXLogRegisterBuffer(state, *nbuf, GENERIC_XLOG_FULL_IMAGE);
+
 	HnswInitPage(*nbuf, *npage);

 	/* Update previous buffer */
@@ -111,7 +115,7 @@ HnswInsertAppendPage(Relation index, Buffer *nbuf, Page *npage, GenericXLogState
 * Add to element and neighbor pages
 */
 static void
-WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPage, BlockNumber *updatedInsertPage)
+WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPage, BlockNumber *updatedInsertPage, bool building)
 {
 	Buffer		buf;
 	Page		page;
@@ -123,7 +127,6 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 	Size		minCombinedSize;
 	HnswElementTuple etup;
 	BlockNumber currentPage = insertPage;
-	int			dimensions = e->vec->dim;
 	HnswNeighborTuple ntup;
 	Buffer		nbuf;
 	Page		npage;
@@ -132,10 +135,10 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 	BlockNumber newInsertPage = InvalidBlockNumber;

 	/* Calculate sizes */
-	etupSize = HNSW_ELEMENT_TUPLE_SIZE(dimensions);
+	etupSize = HNSW_ELEMENT_TUPLE_SIZE(VARSIZE_ANY(DatumGetPointer(e->value)));
 	ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(e->level, m);
 	combinedSize = etupSize + ntupSize + sizeof(ItemIdData);
-	maxSize = BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData));
+	maxSize = HNSW_MAX_SIZE;
 	minCombinedSize = etupSize + HNSW_NEIGHBOR_TUPLE_SIZE(0, m) + sizeof(ItemIdData);

 	/* Prepare element tuple */
@@ -152,8 +155,16 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 		buf = ReadBuffer(index, currentPage);
 		LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);

-		state = GenericXLogStart(index);
-		page = GenericXLogRegisterBuffer(state, buf, 0);
+		if (building)
+		{
+			state = NULL;
+			page = BufferGetPage(buf);
+		}
+		else
+		{
+			state = GenericXLogStart(index);
+			page = GenericXLogRegisterBuffer(state, buf, 0);
+		}

 		/* Keep track of first page where element at level 0 can fit */
 		if (!BlockNumberIsValid(newInsertPage) && PageGetFreeSpace(page) >= minCombinedSize)
@@ -173,7 +184,12 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 		if (HnswFreeOffset(index, buf, page, e, ntupSize, &nbuf, &npage, &freeOffno, &freeNeighborOffno, &newInsertPage))
 		{
 			if (nbuf != buf)
-				npage = GenericXLogRegisterBuffer(state, nbuf, 0);
+			{
+				if (building)
+					npage = BufferGetPage(nbuf);
+				else
+					npage = GenericXLogRegisterBuffer(state, nbuf, 0);
+			}

 			break;
 		}
@@ -182,7 +198,7 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 		/* Skip if both tuples can fit on the same page */
 		if (combinedSize > maxSize && PageGetFreeSpace(page) >= etupSize && !BlockNumberIsValid(HnswPageGetOpaque(page)->nextblkno))
 		{
-			HnswInsertAppendPage(index, &nbuf, &npage, state, page);
+			HnswInsertAppendPage(index, &nbuf, &npage, state, page, building);
 			break;
 		}

@@ -191,7 +207,8 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 		if (BlockNumberIsValid(currentPage))
 		{
 			/* Move to next page */
-			GenericXLogAbort(state);
+			if (!building)
+				GenericXLogAbort(state);
 			UnlockReleaseBuffer(buf);
 		}
 		else
@@ -199,24 +216,31 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 			Buffer		newbuf;
 			Page		newpage;

-			HnswInsertAppendPage(index, &newbuf, &newpage, state, page);
+			HnswInsertAppendPage(index, &newbuf, &newpage, state, page, building);

 			/* Commit */
-			MarkBufferDirty(newbuf);
-			MarkBufferDirty(buf);
-			GenericXLogFinish(state);
+			if (!building)
+				GenericXLogFinish(state);

 			/* Unlock previous buffer */
 			UnlockReleaseBuffer(buf);

 			/* Prepare new buffer */
-			state = GenericXLogStart(index);
 			buf = newbuf;
-			page = GenericXLogRegisterBuffer(state, buf, 0);
+			if (building)
+			{
+				state = NULL;
+				page = BufferGetPage(buf);
+			}
+			else
+			{
+				state = GenericXLogStart(index);
+				page = GenericXLogRegisterBuffer(state, buf, 0);
+			}

 			/* Create new page for neighbors if needed */
 			if (PageGetFreeSpace(page) < combinedSize)
-				HnswInsertAppendPage(index, &nbuf, &npage, state, page);
+				HnswInsertAppendPage(index, &nbuf, &npage, state, page, building);
 			else
 			{
 				nbuf = buf;
@@ -270,10 +294,8 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 	}

 	/* Commit */
-	MarkBufferDirty(buf);
-	if (nbuf != buf)
-		MarkBufferDirty(nbuf);
-	GenericXLogFinish(state);
+	if (!building)
+		GenericXLogFinish(state);
 	UnlockReleaseBuffer(buf);
 	if (nbuf != buf)
 		UnlockReleaseBuffer(nbuf);
@@ -307,7 +329,7 @@ ConnectionExists(HnswElement e, HnswNeighborTuple ntup, int startIdx, int lm)
 * Update neighbors
 */
 void
-HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting)
+HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting, bool building)
 {
 	for (int lc = e->level; lc >= 0; lc--)
 	{
@@ -329,7 +351,7 @@ HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswE

 			/* Get latest neighbors since they may have changed */
 			/* Do not lock yet since selecting neighbors can take time */
-			HnswLoadNeighbors(hc->element, index);
+			HnswLoadNeighbors(hc->element, index, m);

 			/*
 			 * Could improve performance for vacuuming by checking neighbors
@@ -348,8 +370,16 @@ HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswE
 			/* Register page */
 			buf = ReadBuffer(index, hc->element->neighborPage);
 			LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
-			state = GenericXLogStart(index);
-			page = GenericXLogRegisterBuffer(state, buf, 0);
+			if (building)
+			{
+				state = NULL;
+				page = BufferGetPage(buf);
+			}
+			else
+			{
+				state = GenericXLogStart(index);
+				page = GenericXLogRegisterBuffer(state, buf, 0);
+			}

 			/* Get tuple */
 			itemid = PageGetItemId(page, offno);
@@ -391,10 +421,10 @@ HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswE
 					elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));

 				/* Commit */
-				MarkBufferDirty(buf);
-				GenericXLogFinish(state);
+				if (!building)
+					GenericXLogFinish(state);
 			}
-			else
+			else if (!building)
 				GenericXLogAbort(state);

 			UnlockReleaseBuffer(buf);
@@ -406,23 +436,34 @@ HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswE
 * Add a heap TID to an existing element
 */
 static bool
-HnswAddDuplicate(Relation index, HnswElement element, HnswElement dup)
+HnswAddDuplicate(Relation index, HnswElement element, HnswElement dup, bool building)
 {
 	Buffer		buf;
 	Page		page;
 	GenericXLogState *state;
-	Size		etupSize = HNSW_ELEMENT_TUPLE_SIZE(dup->vec->dim);
+	ItemId		itemid;
 	HnswElementTuple etup;
+	Size		etupSize;
 	int			i;

 	/* Read page */
 	buf = ReadBuffer(index, dup->blkno);
 	LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
-	state = GenericXLogStart(index);
-	page = GenericXLogRegisterBuffer(state, buf, 0);
+	if (building)
+	{
+		state = NULL;
+		page = BufferGetPage(buf);
+	}
+	else
+	{
+		state = GenericXLogStart(index);
+		page = GenericXLogRegisterBuffer(state, buf, 0);
+	}

 	/* Find space */
-	etup = (HnswElementTuple) PageGetItem(page, PageGetItemId(page, dup->offno));
+	itemid = PageGetItemId(page, dup->offno);
+	etup = (HnswElementTuple) PageGetItem(page, itemid);
+	etupSize = ItemIdGetLength(itemid);
 	for (i = 0; i < HNSW_HEAPTIDS; i++)
 	{
 		if (!ItemPointerIsValid(&etup->heaptids[i]))
@@ -432,7 +473,8 @@ HnswAddDuplicate(Relation index, HnswElement element, HnswElement dup)
 	/* Either being deleted or we lost our chance to another backend */
 	if (i == 0 || i == HNSW_HEAPTIDS)
 	{
-		GenericXLogAbort(state);
+		if (!building)
+			GenericXLogAbort(state);
 		UnlockReleaseBuffer(buf);
 		return false;
 	}
@@ -445,8 +487,8 @@ HnswAddDuplicate(Relation index, HnswElement element, HnswElement dup)
 		elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));

 	/* Commit */
-	MarkBufferDirty(buf);
-	GenericXLogFinish(state);
+	if (!building)
+		GenericXLogFinish(state);
 	UnlockReleaseBuffer(buf);

 	return true;
@@ -456,45 +498,44 @@ HnswAddDuplicate(Relation index, HnswElement element, HnswElement dup)
 * Write changes to disk
 */
 static void
-WriteElement(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement element, int m, int efConstruction, HnswElement dup, HnswElement entryPoint)
+WriteElement(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement element, int m, int efConstruction, HnswElement dup, HnswElement entryPoint, bool building)
 {
 	BlockNumber newInsertPage = InvalidBlockNumber;

 	/* Try to add to existing page */
 	if (dup != NULL)
 	{
-		if (HnswAddDuplicate(index, element, dup))
+		if (HnswAddDuplicate(index, element, dup, building))
 			return;
 	}

 	/* Write element and neighbor tuples */
-	WriteNewElementPages(index, element, m, GetInsertPage(index), &newInsertPage);
+	WriteNewElementPages(index, element, m, GetInsertPage(index), &newInsertPage, building);

 	/* Update insert page if needed */
 	if (BlockNumberIsValid(newInsertPage))
-		HnswUpdateMetaPage(index, 0, NULL, newInsertPage, MAIN_FORKNUM);
+		HnswUpdateMetaPage(index, 0, NULL, newInsertPage, MAIN_FORKNUM, building);

 	/* Update neighbors */
-	HnswUpdateNeighborPages(index, procinfo, collation, element, m, false);
+	HnswUpdateNeighborPages(index, procinfo, collation, element, m, false, building);

 	/* Update metapage if needed */
 	if (entryPoint == NULL || element->level > entryPoint->level)
-		HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_GREATER, element, InvalidBlockNumber, MAIN_FORKNUM);
+		HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_GREATER, element, InvalidBlockNumber, MAIN_FORKNUM, building);
 }

 /*
 * Insert a tuple into the index
 */
 bool
-HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, Relation heapRel)
+HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, Relation heapRel, bool building)
 {
 	Datum		value;
 	FmgrInfo   *normprocinfo;
 	HnswElement entryPoint;
 	HnswElement element;
-	int			m = HnswGetM(index);
+	int			m;
 	int			efConstruction = HnswGetEfConstruction(index);
-	double		ml = HnswGetMl(m);
 	FmgrInfo   *procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
 	Oid			collation = index->rd_indcollation[0];
 	HnswElement dup;
@@ -511,10 +552,6 @@ HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_ti
 			return false;
 	}

-	/* Create an element */
-	element = HnswInitElement(heap_tid, m, ml, HnswGetMaxLevel(m));
-	element->vec = DatumGetVector(value);
-
 	/*
 	 * Get a shared lock. This allows vacuum to ensure no in-flight inserts
 	 * before repairing graph. Use a page lock so it does not interfere with
@@ -522,8 +559,12 @@ HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_ti
 	 */
 	LockPage(index, HNSW_UPDATE_LOCK, lockmode);

-	/* Get entry point */
-	entryPoint = HnswGetEntryPoint(index);
+	/* Get m and entry point */
+	HnswGetMetaPageInfo(index, &m, &entryPoint);
+
+	/* Create an element */
+	element = HnswInitElement(heap_tid, m, HnswGetMl(m), HnswGetMaxLevel(m));
+	element->value = value;

 	/* Prevent concurrent inserts when likely updating entry point */
 	if (entryPoint == NULL || element->level > entryPoint->level)
@@ -546,7 +587,7 @@ HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_ti
 	dup = HnswFindDuplicate(element);

 	/* Write to disk */
-	WriteElement(index, procinfo, collation, element, m, efConstruction, dup, entryPoint);
+	WriteElement(index, procinfo, collation, element, m, efConstruction, dup, entryPoint, building);

 	/* Release lock */
 	UnlockPage(index, HNSW_UPDATE_LOCK, lockmode);
@@ -580,7 +621,7 @@ hnswinsert(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid,
 	oldCtx = MemoryContextSwitchTo(insertCtx);

 	/* Insert tuple */
-	HnswInsertTuple(index, values, isnull, heap_tid, heap);
+	HnswInsertTuple(index, values, isnull, heap_tid, heap, false);

 	/* Delete memory context */
 	MemoryContextSwitchTo(oldCtx);
--- a/src/hnswscan.c
+++ b/src/hnswscan.c
@@ -19,7 +19,11 @@ GetScanItems(IndexScanDesc scan, Datum q)
 	Oid			collation = so->collation;
 	List	   *ep;
 	List	   *w;
-	HnswElement entryPoint = HnswGetEntryPoint(index);
+	int			m;
+	HnswElement entryPoint;
+
+	/* Get m and entry point */
+	HnswGetMetaPageInfo(index, &m, &entryPoint);

 	if (entryPoint == NULL)
 		return NIL;
@@ -28,11 +32,11 @@ GetScanItems(IndexScanDesc scan, Datum q)

 	for (int lc = entryPoint->level; lc >= 1; lc--)
 	{
-		w = HnswSearchLayer(q, ep, 1, lc, index, procinfo, collation, false, NULL);
+		w = HnswSearchLayer(q, ep, 1, lc, index, procinfo, collation, m, false, NULL);
 		ep = w;
 	}

-	return HnswSearchLayer(q, ep, hnsw_ef_search, 0, index, procinfo, collation, false, NULL);
+	return HnswSearchLayer(q, ep, hnsw_ef_search, 0, index, procinfo, collation, m, false, NULL);
 }

 /*
@@ -58,6 +62,33 @@ GetDimensions(Relation index)
 	return dimensions;
 }

+/*
+ * Get scan value
+ */
+static Datum
+GetScanValue(IndexScanDesc scan)
+{
+	HnswScanOpaque so = (HnswScanOpaque) scan->opaque;
+	Datum		value;
+
+	if (scan->orderByData->sk_flags & SK_ISNULL)
+		value = PointerGetDatum(InitVector(GetDimensions(scan->indexRelation)));
+	else
+	{
+		value = scan->orderByData->sk_argument;
+
+		/* Value should not be compressed or toasted */
+		Assert(!VARATT_IS_COMPRESSED(DatumGetPointer(value)));
+		Assert(!VARATT_IS_EXTENDED(DatumGetPointer(value)));
+
+		/* Fine if normalization fails */
+		if (so->normprocinfo != NULL)
+			HnswNormValue(so->normprocinfo, so->collation, &value, NULL);
+	}
+
+	return value;
+}
+
 /*
 * Prepare for an index scan
 */
@@ -70,7 +101,6 @@ hnswbeginscan(Relation index, int nkeys, int norderbys)
 	scan = RelationGetIndexScan(index, nkeys, norderbys);

 	so = (HnswScanOpaque) palloc(sizeof(HnswScanOpaqueData));
-	so->buf = InvalidBuffer;
 	so->first = true;
 	so->tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
 									   "Hnsw scan temporary context",
@@ -130,20 +160,13 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 		if (scan->orderByData == NULL)
 			elog(ERROR, "cannot scan hnsw index without order");

-		if (scan->orderByData->sk_flags & SK_ISNULL)
-			value = PointerGetDatum(InitVector(GetDimensions(scan->indexRelation)));
-		else
-		{
-			value = scan->orderByData->sk_argument;
+		/* Requires MVCC-compliant snapshot as not able to maintain a pin */
+		/* https://www.postgresql.org/docs/current/index-locking.html */
+		if (!IsMVCCSnapshot(scan->xs_snapshot))
+			elog(ERROR, "non-MVCC snapshots are not supported with hnsw");

-			/* Value should not be compressed or toasted */
-			Assert(!VARATT_IS_COMPRESSED(DatumGetPointer(value)));
-			Assert(!VARATT_IS_EXTENDED(DatumGetPointer(value)));
-
-			/* Fine if normalization fails */
-			if (so->normprocinfo != NULL)
-				HnswNormValue(so->normprocinfo, so->collation, &value, NULL);
-		}
+		/* Get scan value */
+		value = GetScanValue(scan);

 		/*
 		 * Get a shared lock. This allows vacuum to ensure no in-flight scans
@@ -162,41 +185,27 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 	while (list_length(so->w) > 0)
 	{
 		HnswCandidate *hc = llast(so->w);
-		ItemPointer tid;
-		BlockNumber indexblkno;
+		ItemPointer heaptid;

-		/* Move to next element if no valid heap tids */
+		/* Move to next element if no valid heap TIDs */
 		if (list_length(hc->element->heaptids) == 0)
 		{
 			so->w = list_delete_last(so->w);
 			continue;
 		}

-		tid = llast(hc->element->heaptids);
-		indexblkno = hc->element->blkno;
+		heaptid = llast(hc->element->heaptids);

 		hc->element->heaptids = list_delete_last(hc->element->heaptids);

 		MemoryContextSwitchTo(oldCtx);

 #if PG_VERSION_NUM >= 120000
-		scan->xs_heaptid = *tid;
+		scan->xs_heaptid = *heaptid;
 #else
-		scan->xs_ctup.t_self = *tid;
+		scan->xs_ctup.t_self = *heaptid;
 #endif

-		/* Unpin buffer */
-		if (BufferIsValid(so->buf))
-			ReleaseBuffer(so->buf);
-
-		/*
-		 * An index scan must maintain a pin on the index page holding the
-		 * item last returned by amgettuple
-		 *
-		 * https://www.postgresql.org/docs/current/index-locking.html
-		 */
-		so->buf = ReadBuffer(scan->indexRelation, indexblkno);
-
 		scan->xs_recheckorderby = false;
 		return true;
 	}
@@ -213,10 +222,6 @@ hnswendscan(IndexScanDesc scan)
 {
 	HnswScanOpaque so = (HnswScanOpaque) scan->opaque;

-	/* Release pin */
-	if (BufferIsValid(so->buf))
-		ReleaseBuffer(so->buf);
-
 	MemoryContextDelete(so->tmpCtx);

 	pfree(so);
--- a/src/hnswutils.c
+++ b/src/hnswutils.c
@@ -4,8 +4,92 @@

 #include "hnsw.h"
 #include "storage/bufmgr.h"
+#include "utils/datum.h"
 #include "vector.h"

+#if PG_VERSION_NUM >= 130000
+#include "common/hashfn.h"
+#else
+#include "utils/hashutils.h"
+#endif
+
+#if PG_VERSION_NUM < 170000
+static inline uint64
+murmurhash64(uint64 data)
+{
+	uint64		h = data;
+
+	h ^= h >> 33;
+	h *= 0xff51afd7ed558ccd;
+	h ^= h >> 33;
+	h *= 0xc4ceb9fe1a85ec53;
+	h ^= h >> 33;
+
+	return h;
+}
+#endif
+
+/* TID hash table */
+static uint32
+hash_tid(ItemPointerData tid)
+{
+	union
+	{
+		uint64		i;
+		ItemPointerData tid;
+	}			x;
+
+	/* Initialize unused bytes */
+	x.i = 0;
+	x.tid = tid;
+
+	return murmurhash64(x.i);
+}
+
+#define SH_PREFIX		tidhash
+#define SH_ELEMENT_TYPE	TidHashEntry
+#define SH_KEY_TYPE		ItemPointerData
+#define	SH_KEY			tid
+#define SH_HASH_KEY(tb, key)	hash_tid(key)
+#define SH_EQUAL(tb, a, b)		ItemPointerEquals(&a, &b)
+#define	SH_SCOPE		extern
+#define SH_DEFINE
+#include "lib/simplehash.h"
+
+/* Needed to include simplehash.h twice */
+#if PG_VERSION_NUM < 120000
+#undef SH_EQUAL
+#define sh_log2 pointerhash_sh_log2
+#define sh_pow2 pointerhash_sh_pow2
+#endif
+
+/* Pointer hash table */
+static uint32
+hash_pointer(uintptr_t ptr)
+{
+#if SIZEOF_VOID_P == 8
+	return murmurhash64((uint64) ptr);
+#else
+	return murmurhash32((uint32) ptr);
+#endif
+}
+
+#define SH_PREFIX		pointerhash
+#define SH_ELEMENT_TYPE	PointerHashEntry
+#define SH_KEY_TYPE		uintptr_t
+#define	SH_KEY			ptr
+#define SH_HASH_KEY(tb, key)	hash_pointer(key)
+#define SH_EQUAL(tb, a, b)		(a == b)
+#define	SH_SCOPE		extern
+#define SH_DEFINE
+#include "lib/simplehash.h"
+
+typedef union
+{
+	pointerhash_hash *pointers;
+	tidhash_hash *tids;
+}			visited_hash;
+
 /*
 * Get the max number of connections in an upper layer for each element in the index
 */
@@ -38,12 +122,12 @@ HnswGetEfConstruction(Relation index)
 * Get proc
 */
 FmgrInfo *
-HnswOptionalProcInfo(Relation rel, uint16 procnum)
+HnswOptionalProcInfo(Relation index, uint16 procnum)
 {
-	if (!OidIsValid(index_getprocid(rel, 1, procnum)))
+	if (!OidIsValid(index_getprocid(index, 1, procnum)))
 		return NULL;

-	return index_getprocinfo(rel, 1, procnum);
+	return index_getprocinfo(index, 1, procnum);
 }

 /*
@@ -100,28 +184,6 @@ HnswInitPage(Buffer buf, Page page)
 	HnswPageGetOpaque(page)->page_id = HNSW_PAGE_ID;
 }

-/*
- * Init and register page
- */
-void
-HnswInitRegisterPage(Relation index, Buffer *buf, Page *page, GenericXLogState **state)
-{
-	*state = GenericXLogStart(index);
-	*page = GenericXLogRegisterBuffer(*state, *buf, GENERIC_XLOG_FULL_IMAGE);
-	HnswInitPage(*buf, *page);
-}
-
-/*
- * Commit buffer
- */
-void
-HnswCommitBuffer(Buffer buf, GenericXLogState *state)
-{
-	MarkBufferDirty(buf);
-	GenericXLogFinish(state);
-	UnlockReleaseBuffer(buf);
-}
-
 /*
 * Allocate neighbors
 */
@@ -140,9 +202,21 @@ HnswInitNeighbors(HnswElement element, int m)
 		a = &element->neighbors[lc];
 		a->length = 0;
 		a->items = palloc(sizeof(HnswCandidate) * lm);
+		a->closerSet = false;
 	}
 }

+/*
+ * Free neighbors
+ */
+static void
+HnswFreeNeighbors(HnswElement element)
+{
+	for (int lc = 0; lc <= element->level; lc++)
+		pfree(element->neighbors[lc].items);
+	pfree(element->neighbors);
+}
+
 /*
 * Allocate an element
 */
@@ -165,6 +239,8 @@ HnswInitElement(ItemPointer heaptid, int m, double ml, int maxLevel)

 	HnswInitNeighbors(element, m);

+	element->value = PointerGetDatum(NULL);
+
 	return element;
 }

@@ -174,11 +250,10 @@ HnswInitElement(ItemPointer heaptid, int m, double ml, int maxLevel)
 void
 HnswFreeElement(HnswElement element)
 {
+	HnswFreeNeighbors(element);
 	list_free_deep(element->heaptids);
-	for (int lc = 0; lc <= element->level; lc++)
-		pfree(element->neighbors[lc].items);
-	pfree(element->neighbors);
-	pfree(element->vec);
+	if (DatumGetPointer(element->value))
+		pfree(DatumGetPointer(element->value));
 	pfree(element);
 }

@@ -205,30 +280,48 @@ HnswInitElementFromBlock(BlockNumber blkno, OffsetNumber offno)
 	element->blkno = blkno;
 	element->offno = offno;
 	element->neighbors = NULL;
-	element->vec = NULL;
+	element->value = PointerGetDatum(NULL);
 	return element;
 }

+/*
+ * Get the metapage info
+ */
+void
+HnswGetMetaPageInfo(Relation index, int *m, HnswElement * entryPoint)
+{
+	Buffer		buf;
+	Page		page;
+	HnswMetaPage metap;
+
+	buf = ReadBuffer(index, HNSW_METAPAGE_BLKNO);
+	LockBuffer(buf, BUFFER_LOCK_SHARE);
+	page = BufferGetPage(buf);
+	metap = HnswPageGetMeta(page);
+
+	if (m != NULL)
+		*m = metap->m;
+
+	if (entryPoint != NULL)
+	{
+		if (BlockNumberIsValid(metap->entryBlkno))
+			*entryPoint = HnswInitElementFromBlock(metap->entryBlkno, metap->entryOffno);
+		else
+			*entryPoint = NULL;
+	}
+
+	UnlockReleaseBuffer(buf);
+}
+
 /*
 * Get the entry point
 */
 HnswElement
 HnswGetEntryPoint(Relation index)
 {
-	Buffer		buf;
-	Page		page;
-	HnswMetaPage metap;
-	HnswElement entryPoint = NULL;
+	HnswElement entryPoint;

-	buf = ReadBuffer(index, HNSW_METAPAGE_BLKNO);
-	LockBuffer(buf, BUFFER_LOCK_SHARE);
-	page = BufferGetPage(buf);
-	metap = HnswPageGetMeta(page);
-
-	if (BlockNumberIsValid(metap->entryBlkno))
-		entryPoint = HnswInitElementFromBlock(metap->entryBlkno, metap->entryOffno);
-
-	UnlockReleaseBuffer(buf);
+	HnswGetMetaPageInfo(index, NULL, &entryPoint);

 	return entryPoint;
 }
@@ -265,7 +358,7 @@ HnswUpdateMetaPageInfo(Page page, int updateEntry, HnswElement entryPoint, Block
 * Update the metapage
 */
 void
-HnswUpdateMetaPage(Relation index, int updateEntry, HnswElement entryPoint, BlockNumber insertPage, ForkNumber forkNum)
+HnswUpdateMetaPage(Relation index, int updateEntry, HnswElement entryPoint, BlockNumber insertPage, ForkNumber forkNum, bool building)
 {
 	Buffer		buf;
 	Page		page;
@@ -273,12 +366,22 @@ HnswUpdateMetaPage(Relation index, int updateEntry, HnswElement entryPoint, Bloc

 	buf = ReadBufferExtended(index, forkNum, HNSW_METAPAGE_BLKNO, RBM_NORMAL, NULL);
 	LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
-	state = GenericXLogStart(index);
-	page = GenericXLogRegisterBuffer(state, buf, 0);
+	if (building)
+	{
+		state = NULL;
+		page = BufferGetPage(buf);
+	}
+	else
+	{
+		state = GenericXLogStart(index);
+		page = GenericXLogRegisterBuffer(state, buf, 0);
+	}

 	HnswUpdateMetaPageInfo(page, updateEntry, entryPoint, insertPage);

-	HnswCommitBuffer(buf, state);
+	if (!building)
+		GenericXLogFinish(state);
+	UnlockReleaseBuffer(buf);
 }

 /*
@@ -297,7 +400,7 @@ HnswSetElementTuple(HnswElementTuple etup, HnswElement element)
 		else
 			ItemPointerSetInvalid(&etup->heaptids[i]);
 	}
-	memcpy(&etup->vec, element->vec, VECTOR_SIZE(element->vec->dim));
+	memcpy(&etup->data, DatumGetPointer(element->value), VARSIZE_ANY(DatumGetPointer(element->value)));
 }

 /*
@@ -337,10 +440,9 @@ HnswSetNeighborTuple(HnswNeighborTuple ntup, HnswElement e, int m)
 * Load neighbors from page
 */
 static void
-LoadNeighborsFromPage(HnswElement element, Relation index, Page page)
+LoadNeighborsFromPage(HnswElement element, Relation index, Page page, int m)
 {
 	HnswNeighborTuple ntup = (HnswNeighborTuple) PageGetItem(page, PageGetItemId(page, element->neighborOffno));
-	int			m = HnswGetM(index);
 	int			neighborCount = (element->level + 2) * m;

 	Assert(HnswIsNeighborTuple(ntup));
@@ -381,7 +483,7 @@ LoadNeighborsFromPage(HnswElement element, Relation index, Page page)
 * Load neighbors
 */
 void
-HnswLoadNeighbors(HnswElement element, Relation index)
+HnswLoadNeighbors(HnswElement element, Relation index, int m)
 {
 	Buffer		buf;
 	Page		page;
@@ -390,7 +492,7 @@ HnswLoadNeighbors(HnswElement element, Relation index)
 	LockBuffer(buf, BUFFER_LOCK_SHARE);
 	page = BufferGetPage(buf);

-	LoadNeighborsFromPage(element, index, page);
+	LoadNeighborsFromPage(element, index, page, m);

 	UnlockReleaseBuffer(buf);
 }
@@ -420,10 +522,7 @@ HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHe
 	}

 	if (loadVec)
-	{
-		element->vec = palloc(VECTOR_SIZE(etup->vec.dim));
-		memcpy(element->vec, &etup->vec, VECTOR_SIZE(etup->vec.dim));
-	}
+		element->value = datumCopy(PointerGetDatum(&etup->data), false, -1);
 }

 /*
@@ -450,7 +549,7 @@ HnswLoadElement(HnswElement element, float *distance, Datum *q, Relation index,

 	/* Calculate distance */
 	if (distance != NULL)
-		*distance = (float) DatumGetFloat8(FunctionCall2Coll(procinfo, collation, *q, PointerGetDatum(&etup->vec)));
+		*distance = (float) DatumGetFloat8(FunctionCall2Coll(procinfo, collation, *q, PointerGetDatum(&etup->data)));

 	UnlockReleaseBuffer(buf);
 }
@@ -461,7 +560,7 @@ HnswLoadElement(HnswElement element, float *distance, Datum *q, Relation index,
 static float
 GetCandidateDistance(HnswCandidate * hc, Datum q, FmgrInfo *procinfo, Oid collation)
 {
-	return DatumGetFloat8(FunctionCall2Coll(procinfo, collation, q, PointerGetDatum(hc->element->vec)));
+	return DatumGetFloat8(FunctionCall2Coll(procinfo, collation, q, hc->element->value));
 }

 /*
@@ -526,16 +625,22 @@ CreatePairingHeapNode(HnswCandidate * c)
 * Add to visited
 */
 static inline void
-AddToVisited(HTAB *v, HnswCandidate * hc, Relation index, bool *found)
+AddToVisited(visited_hash v, HnswCandidate * hc, Relation index, bool *found)
 {
 	if (index == NULL)
-		hash_search(v, &hc->element, HASH_ENTER, found);
+	{
+#if PG_VERSION_NUM >= 130000
+		pointerhash_insert_hash(v.pointers, (uintptr_t) hc->element, hc->element->hash, found);
+#else
+		pointerhash_insert(v.pointers, (uintptr_t) hc->element, found);
+#endif
+	}
 	else
 	{
 		ItemPointerData indextid;

 		ItemPointerSet(&indextid, hc->element->blkno, hc->element->offno);
-		hash_search(v, &indextid, HASH_ENTER, found);
+		tidhash_insert(v.tids, indextid, found);
 	}
 }

@@ -543,7 +648,7 @@ AddToVisited(HTAB *v, HnswCandidate * hc, Relation index, bool *found)
 * Algorithm 2 from paper
 */
 List *
-HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, bool inserting, HnswElement skipElement)
+HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, int m, bool inserting, HnswElement skipElement)
 {
 	ListCell   *lc2;

@@ -551,30 +656,21 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 	pairingheap *C = pairingheap_allocate(CompareNearestCandidates, NULL);
 	pairingheap *W = pairingheap_allocate(CompareFurthestCandidates, NULL);
 	int			wlen = 0;
-	HASHCTL		hash_ctl;
-	HTAB	   *v;
+	visited_hash v;

 	/* Create hash table */
 	if (index == NULL)
-	{
-		hash_ctl.keysize = sizeof(HnswElement *);
-		hash_ctl.entrysize = sizeof(HnswElement *);
-	}
+		v.pointers = pointerhash_create(CurrentMemoryContext, ef * m * 2, NULL);
 	else
-	{
-		hash_ctl.keysize = sizeof(ItemPointerData);
-		hash_ctl.entrysize = sizeof(ItemPointerData);
-	}
-
-	hash_ctl.hcxt = CurrentMemoryContext;
-	v = hash_create("hnsw visited", 256, &hash_ctl, HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
+		v.tids = tidhash_create(CurrentMemoryContext, ef * m * 2, NULL);

 	/* Add entry points to v, C, and W */
 	foreach(lc2, ep)
 	{
 		HnswCandidate *hc = (HnswCandidate *) lfirst(lc2);
+		bool		found;

-		AddToVisited(v, hc, index, NULL);
+		AddToVisited(v, hc, index, &found);

 		pairingheap_add(C, &(CreatePairingHeapNode(hc)->ph_node));
 		pairingheap_add(W, &(CreatePairingHeapNode(hc)->ph_node));
@@ -598,7 +694,7 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 			break;

 		if (c->element->neighbors == NULL)
-			HnswLoadNeighbors(c->element, index);
+			HnswLoadNeighbors(c->element, index, m);

 		/* Get the neighborhood at layer lc */
 		neighborhood = &c->element->neighbors[lc];
@@ -667,6 +763,34 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 	return w;
 }

+/*
+ * Compare candidate distances
+ */
+static int
+#if PG_VERSION_NUM >= 130000
+CompareCandidateDistances(const ListCell *a, const ListCell *b)
+#else
+CompareCandidateDistances(const void *a, const void *b)
+#endif
+{
+	HnswCandidate *hca = lfirst((ListCell *) a);
+	HnswCandidate *hcb = lfirst((ListCell *) b);
+
+	if (hca->distance < hcb->distance)
+		return 1;
+
+	if (hca->distance > hcb->distance)
+		return -1;
+
+	if (hca->element < hcb->element)
+		return 1;
+
+	if (hca->element > hcb->element)
+		return -1;
+
+	return 0;
+}
+
 /*
 * Calculate the distance between elements
 */
@@ -696,7 +820,7 @@ HnswGetDistance(HnswElement a, HnswElement b, int lc, FmgrInfo *procinfo, Oid co
 		}
 	}

-	return DatumGetFloat8(FunctionCall2Coll(procinfo, collation, PointerGetDatum(a->vec), PointerGetDatum(b->vec)));
+	return DatumGetFloat8(FunctionCall2Coll(procinfo, collation, a->value, b->value));
 }

 /*
@@ -723,33 +847,77 @@ CheckElementCloser(HnswCandidate * e, List *r, int lc, FmgrInfo *procinfo, Oid c
 * Algorithm 4 from paper
 */
 static List *
-SelectNeighbors(List *c, int m, int lc, FmgrInfo *procinfo, Oid collation, HnswCandidate * *pruned)
+SelectNeighbors(List *c, int m, int lc, FmgrInfo *procinfo, Oid collation, HnswElement e2, HnswCandidate * newCandidate, HnswCandidate * *pruned, bool sortCandidates)
 {
 	List	   *r = NIL;
 	List	   *w = list_copy(c);
 	pairingheap *wd;
+	bool		mustCalculate = !e2->neighbors[lc].closerSet;
+	List	   *added = NIL;
+	bool		removedAny = false;

 	if (list_length(w) <= m)
 		return w;

 	wd = pairingheap_allocate(CompareNearestCandidates, NULL);

+	/* Ensure order of candidates is deterministic for closer caching */
+	if (sortCandidates)
+		list_sort(w, CompareCandidateDistances);
+
 	while (list_length(w) > 0 && list_length(r) < m)
 	{
 		/* Assumes w is already ordered desc */
 		HnswCandidate *e = llast(w);
-		bool		closer;

 		w = list_delete_last(w);

-		closer = CheckElementCloser(e, r, lc, procinfo, collation);
+		/* Use previous state of r and wd to skip work when possible */
+		if (mustCalculate)
+			e->closer = CheckElementCloser(e, r, lc, procinfo, collation);
+		else if (list_length(added) > 0)
+		{
+			/*
+			 * If the current candidate was closer, we only need to compare it
+			 * with the other candidates that we have added.
+			 */
+			if (e->closer)
+			{
+				e->closer = CheckElementCloser(e, added, lc, procinfo, collation);

-		if (closer)
+				if (!e->closer)
+					removedAny = true;
+			}
+			else
+			{
+				/*
+				 * If we have removed any candidates from closer, a candidate
+				 * that was not closer earlier might now be.
+				 */
+				if (removedAny)
+				{
+					e->closer = CheckElementCloser(e, r, lc, procinfo, collation);
+					if (e->closer)
+						added = lappend(added, e);
+				}
+			}
+		}
+		else if (e == newCandidate)
+		{
+			e->closer = CheckElementCloser(e, r, lc, procinfo, collation);
+			if (e->closer)
+				added = lappend(added, e);
+		}
+
+		if (e->closer)
 			r = lappend(r, e);
 		else
 			pairingheap_add(wd, &(CreatePairingHeapNode(e)->ph_node));
 	}

+	/* Cached value can only be used in future if sorted deterministically */
+	e2->neighbors[lc].closerSet = sortCandidates;
+
 	/* Keep pruned connections */
 	while (!pairingheap_is_empty(wd) && list_length(r) < m)
 		r = lappend(r, ((HnswPairingHeapNode *) pairingheap_remove_first(wd))->inner);
@@ -779,7 +947,7 @@ HnswFindDuplicate(HnswElement e)
 		HnswCandidate *neighbor = &neighbors->items[i];

 		/* Exit early since ordered by distance */
-		if (vector_cmp_internal(e->vec, neighbor->element->vec) != 0)
+		if (!datumIsEqual(e->value, neighbor->element->value, false, -1))
 			break;

 		/* Check for space */
@@ -803,28 +971,6 @@ AddConnections(HnswElement element, List *neighbors, int m, int lc)
 		a->items[a->length++] = *((HnswCandidate *) lfirst(lc2));
 }

-/*
- * Compare candidate distances
- */
-static int
-#if PG_VERSION_NUM >= 130000
-CompareCandidateDistances(const ListCell *a, const ListCell *b)
-#else
-CompareCandidateDistances(const void *a, const void *b)
-#endif
-{
-	HnswCandidate *hca = lfirst((ListCell *) a);
-	HnswCandidate *hcb = lfirst((ListCell *) b);
-
-	if (hca->distance < hcb->distance)
-		return 1;
-
-	if (hca->distance > hcb->distance)
-		return -1;
-
-	return 0;
-}
-
 /*
 * Update connections
 */
@@ -854,13 +1000,13 @@ HnswUpdateConnection(HnswElement element, HnswCandidate * hc, int m, int lc, int
 		/* Load elements on insert */
 		if (index != NULL)
 		{
-			Datum		q = PointerGetDatum(hc->element->vec);
+			Datum		q = hc->element->value;

 			for (int i = 0; i < currentNeighbors->length; i++)
 			{
 				HnswCandidate *hc3 = &currentNeighbors->items[i];

-				if (hc3->element->vec == NULL)
+				if (DatumGetPointer(hc3->element->value) == NULL)
 					HnswLoadElement(hc3->element, &hc3->distance, &q, index, procinfo, collation, true);
 				else
 					hc3->distance = GetCandidateDistance(hc3, q, procinfo, collation);
@@ -878,13 +1024,12 @@ HnswUpdateConnection(HnswElement element, HnswCandidate * hc, int m, int lc, int
 		{
 			List	   *c = NIL;

-			/* Add and sort candidates */
+			/* Add candidates */
 			for (int i = 0; i < currentNeighbors->length; i++)
 				c = lappend(c, &currentNeighbors->items[i]);
 			c = lappend(c, &hc2);
-			list_sort(c, CompareCandidateDistances);

-			SelectNeighbors(c, m, lc, procinfo, collation, &pruned);
+			SelectNeighbors(c, m, lc, procinfo, collation, hc->element, &hc2, &pruned, true);

 			/* Should not happen */
 			if (pruned == NULL)
@@ -942,9 +1087,15 @@ HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, F
 	List	   *w;
 	int			level = element->level;
 	int			entryLevel;
-	Datum		q = PointerGetDatum(element->vec);
+	Datum		q = element->value;
 	HnswElement skipElement = existing ? element : NULL;

+#if PG_VERSION_NUM >= 130000
+	/* Precompute hash */
+	if (index == NULL)
+		element->hash = hash_pointer((uintptr_t) element);
+#endif
+
 	/* No neighbors if no entry point */
 	if (entryPoint == NULL)
 		return;
@@ -956,7 +1107,7 @@ HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, F
 	/* 1st phase: greedy search to insert level */
 	for (int lc = entryLevel; lc >= level + 1; lc--)
 	{
-		w = HnswSearchLayer(q, ep, 1, lc, index, procinfo, collation, true, skipElement);
+		w = HnswSearchLayer(q, ep, 1, lc, index, procinfo, collation, m, true, skipElement);
 		ep = w;
 	}

@@ -974,7 +1125,7 @@ HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, F
 		List	   *neighbors;
 		List	   *lw;

-		w = HnswSearchLayer(q, ep, efConstruction, lc, index, procinfo, collation, true, skipElement);
+		w = HnswSearchLayer(q, ep, efConstruction, lc, index, procinfo, collation, m, true, skipElement);

 		/* Elements being deleted or skipped can help with search */
 		/* but should be removed before selecting neighbors */
@@ -983,7 +1134,12 @@ HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, F
 		else
 			lw = w;

-		neighbors = SelectNeighbors(lw, lm, lc, procinfo, collation, NULL);
+		/*
+		 * Candidates are sorted, but not deterministically. Could set
+		 * sortCandidates to true for in-memory builds to enable closer
+		 * caching, but there does not seem to be a difference in performance.
+		 */
+		neighbors = SelectNeighbors(lw, lm, lc, procinfo, collation, element, NULL, NULL, false);

 		AddConnections(element, neighbors, lm, lc);

--- a/src/hnswvacuum.c
+++ b/src/hnswvacuum.c
@@ -12,12 +12,9 @@
 * Check if deleted list contains an index TID
 */
 static bool
-DeletedContains(HTAB *deleted, ItemPointer indextid)
+DeletedContains(tidhash_hash * deleted, ItemPointer indextid)
 {
-	bool		found;
-
-	hash_search(deleted, indextid, HASH_FIND, &found);
-	return found;
+	return tidhash_lookup(deleted, *indextid) != NULL;
 }

 /*
@@ -62,7 +59,8 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 		/* Iterate over nodes */
 		for (offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
 		{
-			HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, PageGetItemId(page, offno));
+			ItemId		itemid = PageGetItemId(page, offno);
+			HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, itemid);
 			int			idx = 0;
 			bool		itemUpdated = false;

@@ -93,7 +91,7 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)

 				if (itemUpdated)
 				{
-					Size		etupSize = HNSW_ELEMENT_TUPLE_SIZE(etup->vec.dim);
+					Size		etupSize = ItemIdGetLength(itemid);

 					/* Mark rest as invalid */
 					for (int i = idx; i < HNSW_HEAPTIDS; i++)
@@ -109,11 +107,13 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 			if (!ItemPointerIsValid(&etup->heaptids[0]))
 			{
 				ItemPointerData ip;
+				bool		found;

 				/* Add to deleted list */
 				ItemPointerSet(&ip, blkno, offno);

-				(void) hash_search(vacuumstate->deleted, &ip, HASH_ENTER, NULL);
+				tidhash_insert(vacuumstate->deleted, ip, &found);
+				Assert(!found);
 			}
 			else if (etup->level > highestLevel && !(entryPoint != NULL && blkno == entryPoint->blkno && offno == entryPoint->offno))
 			{
@@ -128,10 +128,7 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 		blkno = HnswPageGetOpaque(page)->nextblkno;

 		if (updated)
-		{
-			MarkBufferDirty(buf);
 			GenericXLogFinish(state);
-		}
 		else
 			GenericXLogAbort(state);

@@ -229,12 +226,11 @@ RepairGraphElement(HnswVacuumState * vacuumstate, HnswElement element, HnswEleme
 		elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));

 	/* Commit */
-	MarkBufferDirty(buf);
 	GenericXLogFinish(state);
 	UnlockReleaseBuffer(buf);

 	/* Update neighbors */
-	HnswUpdateNeighborPages(index, procinfo, collation, element, m, true);
+	HnswUpdateNeighborPages(index, procinfo, collation, element, m, true, false);
 }

 /*
@@ -290,7 +286,7 @@ RepairGraphEntryPoint(HnswVacuumState * vacuumstate)
 			 * point is outdated and empty, the entry point will be empty
 			 * until an element is repaired.
 			 */
-			HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_ALWAYS, highestPoint, InvalidBlockNumber, MAIN_FORKNUM);
+			HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_ALWAYS, highestPoint, InvalidBlockNumber, MAIN_FORKNUM, false);
 		}
 		else
 		{
@@ -330,7 +326,10 @@ RepairGraph(HnswVacuumState * vacuumstate)
 	BufferAccessStrategy bas = vacuumstate->bas;
 	BlockNumber blkno = HNSW_HEAD_BLKNO;

-	/* Wait for inserts to complete */
+	/*
+	 * Wait for inserts to complete. Inserts before this point may have
+	 * neighbors about to be deleted. Inserts after this point will not.
+	 */
 	LockPage(index, HNSW_UPDATE_LOCK, ExclusiveLock);
 	UnlockPage(index, HNSW_UPDATE_LOCK, ExclusiveLock);

@@ -420,7 +419,7 @@ RepairGraph(HnswVacuumState * vacuumstate)
 			 * was replaced and highest point was outdated.
 			 */
 			if (entryPoint == NULL || element->level > entryPoint->level)
-				HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_GREATER, element, InvalidBlockNumber, MAIN_FORKNUM);
+				HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_GREATER, element, InvalidBlockNumber, MAIN_FORKNUM, false);

 			/* Release lock */
 			UnlockPage(index, HNSW_UPDATE_LOCK, lockmode);
@@ -443,7 +442,11 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 	Relation	index = vacuumstate->index;
 	BufferAccessStrategy bas = vacuumstate->bas;

-	/* Wait for selects to complete */
+	/*
+	 * Wait for index scans to complete. Scans before this point may contain
+	 * tuples about to be deleted. Scans after this point will not, since the
+	 * graph has been repaired.
+	 */
 	LockPage(index, HNSW_SCAN_LOCK, ExclusiveLock);
 	UnlockPage(index, HNSW_SCAN_LOCK, ExclusiveLock);

@@ -474,7 +477,8 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 		/* Update element and neighbors together */
 		for (offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
 		{
-			HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, PageGetItemId(page, offno));
+			ItemId		itemid = PageGetItemId(page, offno);
+			HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, itemid);
 			HnswNeighborTuple ntup;
 			Size		etupSize;
 			Size		ntupSize;
@@ -502,7 +506,7 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 				continue;

 			/* Calculate sizes */
-			etupSize = HNSW_ELEMENT_TUPLE_SIZE(etup->vec.dim);
+			etupSize = ItemIdGetLength(itemid);
 			ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(etup->level, vacuumstate->m);

 			/* Get neighbor page */
@@ -525,7 +529,7 @@ MarkDeleted(HnswVacuumState * vacuumstate)

 			/* Overwrite element */
 			etup->deleted = 1;
-			MemSet(&etup->vec.x, 0, etup->vec.dim * sizeof(float));
+			MemSet(&etup->data, 0, VARSIZE_ANY(&etup->data));

 			/* Overwrite neighbors */
 			for (int i = 0; i < ntup->count; i++)
@@ -540,9 +544,6 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 				elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));

 			/* Commit */
-			MarkBufferDirty(buf);
-			if (nbuf != buf)
-				MarkBufferDirty(nbuf);
 			GenericXLogFinish(state);
 			if (nbuf != buf)
 				UnlockReleaseBuffer(nbuf);
@@ -563,7 +564,7 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 	}

 	/* Update insert page last, after everything has been marked as deleted */
-	HnswUpdateMetaPage(index, 0, NULL, insertPage, MAIN_FORKNUM);
+	HnswUpdateMetaPage(index, 0, NULL, insertPage, MAIN_FORKNUM, false);
 }

 /*
@@ -573,7 +574,6 @@ static void
 InitVacuumState(HnswVacuumState * vacuumstate, IndexVacuumInfo *info, IndexBulkDeleteResult *stats, IndexBulkDeleteCallback callback, void *callback_state)
 {
 	Relation	index = info->index;
-	HASHCTL		hash_ctl;

 	if (stats == NULL)
 		stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
@@ -582,7 +582,6 @@ InitVacuumState(HnswVacuumState * vacuumstate, IndexVacuumInfo *info, IndexBulkD
 	vacuumstate->stats = stats;
 	vacuumstate->callback = callback;
 	vacuumstate->callback_state = callback_state;
-	vacuumstate->m = HnswGetM(index);
 	vacuumstate->efConstruction = HnswGetEfConstruction(index);
 	vacuumstate->bas = GetAccessStrategy(BAS_BULKREAD);
 	vacuumstate->procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
@@ -592,11 +591,11 @@ InitVacuumState(HnswVacuumState * vacuumstate, IndexVacuumInfo *info, IndexBulkD
 												"Hnsw vacuum temporary context",
 												ALLOCSET_DEFAULT_SIZES);

+	/* Get m from metapage */
+	HnswGetMetaPageInfo(index, &vacuumstate->m, NULL);
+
 	/* Create hash table */
-	hash_ctl.keysize = sizeof(ItemPointerData);
-	hash_ctl.entrysize = sizeof(ItemPointerData);
-	hash_ctl.hcxt = CurrentMemoryContext;
-	vacuumstate->deleted = hash_create("hnswbulkdelete indextids", 256, &hash_ctl, HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
+	vacuumstate->deleted = tidhash_create(CurrentMemoryContext, 256, NULL);
 }

 /*
@@ -605,7 +604,7 @@ InitVacuumState(HnswVacuumState * vacuumstate, IndexVacuumInfo *info, IndexBulkD
 static void
 FreeVacuumState(HnswVacuumState * vacuumstate)
 {
-	hash_destroy(vacuumstate->deleted);
+	tidhash_destroy(vacuumstate->deleted);
 	FreeAccessStrategy(vacuumstate->bas);
 	pfree(vacuumstate->ntup);
 	MemoryContextDelete(vacuumstate->tmpCtx);
--- a/src/ivfbuild.c
+++ b/src/ivfbuild.c
@@ -10,8 +10,8 @@
 #include "ivfflat.h"
 #include "miscadmin.h"
 #include "storage/bufmgr.h"
-#include "utils/memutils.h"
 #include "tcop/tcopprot.h"
+#include "utils/memutils.h"

 #if PG_VERSION_NUM >= 140000
 #include "utils/backend_progress.h"
@@ -506,29 +506,30 @@ CreateListPages(Relation index, VectorArray centers, int dimensions,
 	Buffer		buf;
 	Page		page;
 	GenericXLogState *state;
-	OffsetNumber offno;
-	Size		itemsz;
+	Size		listSize;
 	IvfflatList list;

-	itemsz = MAXALIGN(IVFFLAT_LIST_SIZE(dimensions));
-	list = palloc(itemsz);
+	listSize = MAXALIGN(IVFFLAT_LIST_SIZE(dimensions));
+	list = palloc(listSize);

 	buf = IvfflatNewBuffer(index, forkNum);
 	IvfflatInitRegisterPage(index, &buf, &page, &state);

 	for (int i = 0; i < lists; i++)
 	{
+		OffsetNumber offno;
+
 		/* Load list */
 		list->startPage = InvalidBlockNumber;
 		list->insertPage = InvalidBlockNumber;
 		memcpy(&list->center, VectorArrayGet(centers, i), VECTOR_SIZE(dimensions));

 		/* Ensure free space */
-		if (PageGetFreeSpace(page) < itemsz)
+		if (PageGetFreeSpace(page) < listSize)
 			IvfflatAppendPage(index, &buf, &page, &state, forkNum);

 		/* Add the item */
-		offno = PageAddItem(page, (Item) list, itemsz, InvalidOffsetNumber, false, false);
+		offno = PageAddItem(page, (Item) list, listSize, InvalidOffsetNumber, false, false);
 		if (offno == InvalidOffsetNumber)
 			elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));

--- a/src/ivfflat.c
+++ b/src/ivfflat.c
@@ -71,7 +71,7 @@ ivfflatcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	int			lists;
 	double		ratio;
 	double		spc_seq_page_cost;
-	Relation	indexRel;
+	Relation	index;
 #if PG_VERSION_NUM < 120000
 	List	   *qinfos;
 #endif
@@ -89,9 +89,9 @@ ivfflatcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,

 	MemSet(&costs, 0, sizeof(costs));

-	indexRel = index_open(path->indexinfo->indexoid, NoLock);
-	lists = IvfflatGetLists(indexRel);
-	index_close(indexRel, NoLock);
+	index = index_open(path->indexinfo->indexoid, NoLock);
+	IvfflatGetMetaPageInfo(index, &lists, NULL);
+	index_close(index, NoLock);

 	/* Get the ratio of lists that we need to visit */
 	ratio = ((double) ivfflat_probes) / lists;
--- a/src/ivfflat.h
+++ b/src/ivfflat.h
@@ -244,8 +244,8 @@ typedef struct IvfflatScanList
 typedef struct IvfflatScanOpaqueData
 {
 	int			probes;
+	int			dimensions;
 	bool		first;
-	Buffer		buf;

 	/* Sorting */
 	Tuplesortstate *sortstate;
@@ -275,9 +275,10 @@ VectorArray VectorArrayInit(int maxlen, int dimensions);
 void		VectorArrayFree(VectorArray arr);
 void		PrintVectorArray(char *msg, VectorArray arr);
 void		IvfflatKmeans(Relation index, VectorArray samples, VectorArray centers);
-FmgrInfo   *IvfflatOptionalProcInfo(Relation rel, uint16 procnum);
+FmgrInfo   *IvfflatOptionalProcInfo(Relation index, uint16 procnum);
 bool		IvfflatNormValue(FmgrInfo *procinfo, Oid collation, Datum *value, Vector * result);
 int			IvfflatGetLists(Relation index);
+void		IvfflatGetMetaPageInfo(Relation index, int *lists, int *dimensions);
 void		IvfflatUpdateList(Relation index, ListInfo listInfo, BlockNumber insertPage, BlockNumber originalInsertPage, BlockNumber startPage, ForkNumber forkNum);
 void		IvfflatCommitBuffer(Buffer buf, GenericXLogState *state);
 void		IvfflatAppendPage(Relation index, Buffer *buf, Page *page, GenericXLogState **state, ForkNumber forkNum);
--- a/src/ivfinsert.c
+++ b/src/ivfinsert.c
@@ -11,36 +11,37 @@
 * Find the list that minimizes the distance function
 */
 static void
-FindInsertPage(Relation rel, Datum *values, BlockNumber *insertPage, ListInfo * listInfo)
+FindInsertPage(Relation index, Datum *values, BlockNumber *insertPage, ListInfo * listInfo)
 {
-	Buffer		cbuf;
-	Page		cpage;
-	IvfflatList list;
-	double		distance;
 	double		minDistance = DBL_MAX;
 	BlockNumber nextblkno = IVFFLAT_HEAD_BLKNO;
 	FmgrInfo   *procinfo;
 	Oid			collation;
-	OffsetNumber offno;
-	OffsetNumber maxoffno;

 	/* Avoid compiler warning */
 	listInfo->blkno = nextblkno;
 	listInfo->offno = FirstOffsetNumber;

-	procinfo = index_getprocinfo(rel, 1, IVFFLAT_DISTANCE_PROC);
-	collation = rel->rd_indcollation[0];
+	procinfo = index_getprocinfo(index, 1, IVFFLAT_DISTANCE_PROC);
+	collation = index->rd_indcollation[0];

 	/* Search all list pages */
 	while (BlockNumberIsValid(nextblkno))
 	{
-		cbuf = ReadBuffer(rel, nextblkno);
+		Buffer		cbuf;
+		Page		cpage;
+		OffsetNumber maxoffno;
+
+		cbuf = ReadBuffer(index, nextblkno);
 		LockBuffer(cbuf, BUFFER_LOCK_SHARE);
 		cpage = BufferGetPage(cbuf);
 		maxoffno = PageGetMaxOffsetNumber(cpage);

-		for (offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
+		for (OffsetNumber offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
 		{
+			IvfflatList list;
+			double		distance;
+
 			list = (IvfflatList) PageGetItem(cpage, PageGetItemId(cpage, offno));
 			distance = DatumGetFloat8(FunctionCall2Coll(procinfo, collation, values[0], PointerGetDatum(&list->center)));

@@ -63,7 +64,7 @@ FindInsertPage(Relation rel, Datum *values, BlockNumber *insertPage, ListInfo *
 * Insert a tuple into the index
 */
 static void
-InsertTuple(Relation rel, Datum *values, bool *isnull, ItemPointer heap_tid, Relation heapRel)
+InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, Relation heapRel)
 {
 	IndexTuple	itup;
 	Datum		value;
@@ -80,33 +81,33 @@ InsertTuple(Relation rel, Datum *values, bool *isnull, ItemPointer heap_tid, Rel
 	value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));

 	/* Normalize if needed */
-	normprocinfo = IvfflatOptionalProcInfo(rel, IVFFLAT_NORM_PROC);
+	normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_NORM_PROC);
 	if (normprocinfo != NULL)
 	{
-		if (!IvfflatNormValue(normprocinfo, rel->rd_indcollation[0], &value, NULL))
+		if (!IvfflatNormValue(normprocinfo, index->rd_indcollation[0], &value, NULL))
 			return;
 	}

 	/* Find the insert page - sets the page and list info */
-	FindInsertPage(rel, values, &insertPage, &listInfo);
+	FindInsertPage(index, values, &insertPage, &listInfo);
 	Assert(BlockNumberIsValid(insertPage));
 	originalInsertPage = insertPage;

 	/* Form tuple */
-	itup = index_form_tuple(RelationGetDescr(rel), &value, isnull);
+	itup = index_form_tuple(RelationGetDescr(index), &value, isnull);
 	itup->t_tid = *heap_tid;

 	/* Get tuple size */
 	itemsz = MAXALIGN(IndexTupleSize(itup));
-	Assert(itemsz <= BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(IvfflatPageOpaqueData)));
+	Assert(itemsz <= BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(IvfflatPageOpaqueData)) - sizeof(ItemIdData));

 	/* Find a page to insert the item */
 	for (;;)
 	{
-		buf = ReadBuffer(rel, insertPage);
+		buf = ReadBuffer(index, insertPage);
 		LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);

-		state = GenericXLogStart(rel);
+		state = GenericXLogStart(index);
 		page = GenericXLogRegisterBuffer(state, buf, 0);

 		if (PageGetFreeSpace(page) >= itemsz)
@@ -126,9 +127,9 @@ InsertTuple(Relation rel, Datum *values, bool *isnull, ItemPointer heap_tid, Rel
 			Page		newpage;

 			/* Add a new page */
-			LockRelationForExtension(rel, ExclusiveLock);
-			newbuf = IvfflatNewBuffer(rel, MAIN_FORKNUM);
-			UnlockRelationForExtension(rel, ExclusiveLock);
+			LockRelationForExtension(index, ExclusiveLock);
+			newbuf = IvfflatNewBuffer(index, MAIN_FORKNUM);
+			UnlockRelationForExtension(index, ExclusiveLock);

 			/* Init new page */
 			newpage = GenericXLogRegisterBuffer(state, newbuf, GENERIC_XLOG_FULL_IMAGE);
@@ -141,15 +142,13 @@ InsertTuple(Relation rel, Datum *values, bool *isnull, ItemPointer heap_tid, Rel
 			IvfflatPageGetOpaque(page)->nextblkno = insertPage;

 			/* Commit */
-			MarkBufferDirty(newbuf);
-			MarkBufferDirty(buf);
 			GenericXLogFinish(state);

 			/* Unlock previous buffer */
 			UnlockReleaseBuffer(buf);

 			/* Prepare new buffer */
-			state = GenericXLogStart(rel);
+			state = GenericXLogStart(index);
 			buf = newbuf;
 			page = GenericXLogRegisterBuffer(state, buf, 0);
 			break;
@@ -158,13 +157,13 @@ InsertTuple(Relation rel, Datum *values, bool *isnull, ItemPointer heap_tid, Rel

 	/* Add to next offset */
 	if (PageAddItem(page, (Item) itup, itemsz, InvalidOffsetNumber, false, false) == InvalidOffsetNumber)
-		elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(rel));
+		elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));

 	IvfflatCommitBuffer(buf, state);

 	/* Update the insert page */
 	if (insertPage != originalInsertPage)
-		IvfflatUpdateList(rel, listInfo, insertPage, originalInsertPage, InvalidBlockNumber, MAIN_FORKNUM);
+		IvfflatUpdateList(index, listInfo, insertPage, originalInsertPage, InvalidBlockNumber, MAIN_FORKNUM);
 }

 /*
--- a/src/ivfkmeans.c
+++ b/src/ivfkmeans.c
@@ -17,10 +17,6 @@ InitCenters(Relation index, VectorArray samples, VectorArray centers, float *low
 	FmgrInfo   *procinfo;
 	Oid			collation;
 	int64		j;
-	double		distance;
-	double		sum;
-	double		choice;
-	Vector	   *vec;
 	float	   *weight = palloc(samples->length * sizeof(float));
 	int			numCenters = centers->maxlen;
 	int			numSamples = samples->length;
@@ -33,17 +29,21 @@ InitCenters(Relation index, VectorArray samples, VectorArray centers, float *low
 	centers->length++;

 	for (j = 0; j < numSamples; j++)
-		weight[j] = DBL_MAX;
+		weight[j] = FLT_MAX;

 	for (int i = 0; i < numCenters; i++)
 	{
+		double		sum;
+		double		choice;
+
 		CHECK_FOR_INTERRUPTS();

 		sum = 0.0;

 		for (j = 0; j < numSamples; j++)
 		{
-			vec = VectorArrayGet(samples, j);
+			Vector	   *vec = VectorArrayGet(samples, j);
+			double		distance;

 			/* Only need to compute distance for new center */
 			/* TODO Use triangle inequality to reduce distance calculations */
@@ -112,7 +112,6 @@ CompareVectors(const void *a, const void *b)
 static void
 QuickCenters(Relation index, VectorArray samples, VectorArray centers)
 {
-	Vector	   *vec;
 	int			dimensions = centers->dim;
 	Oid			collation = index->rd_indcollation[0];
 	FmgrInfo   *normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_KMEANS_NORM_PROC);
@@ -123,7 +122,7 @@ QuickCenters(Relation index, VectorArray samples, VectorArray centers)
 		qsort(samples->items, samples->length, VECTOR_SIZE(samples->dim), CompareVectors);
 		for (int i = 0; i < samples->length; i++)
 		{
-			vec = VectorArrayGet(samples, i);
+			Vector	   *vec = VectorArrayGet(samples, i);

 			if (i == 0 || CompareVectors(vec, VectorArrayGet(samples, i - 1)) != 0)
 			{
@@ -136,7 +135,7 @@ QuickCenters(Relation index, VectorArray samples, VectorArray centers)
 	/* Fill remaining with random data */
 	while (centers->length < centers->maxlen)
 	{
-		vec = VectorArrayGet(centers, centers->length);
+		Vector	   *vec = VectorArrayGet(centers, centers->length);

 		SET_VARSIZE(vec, VECTOR_SIZE(dimensions));
 		vec->dim = dimensions;
@@ -168,7 +167,6 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 	Oid			collation;
 	Vector	   *vec;
 	Vector	   *newCenter;
-	int			iteration;
 	int64		j;
 	int64		k;
 	int			dimensions = centers->dim;
@@ -182,14 +180,6 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 	float	   *s;
 	float	   *halfcdist;
 	float	   *newcdist;
-	int			changes;
-	double		minDistance;
-	int			closestCenter;
-	double		distance;
-	bool		rj;
-	bool		rjreset;
-	double		dxcx;
-	double		dxc;

 	/* Calculate allocation sizes */
 	Size		samplesSize = VECTOR_ARRAY_SIZE(samples->maxlen, samples->dim);
@@ -247,14 +237,14 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 	/* Assign each x to its closest initial center c(x) = argmin d(x,c) */
 	for (j = 0; j < numSamples; j++)
 	{
-		minDistance = DBL_MAX;
-		closestCenter = 0;
+		float		minDistance = FLT_MAX;
+		int			closestCenter = 0;

 		/* Find closest center */
 		for (k = 0; k < numCenters; k++)
 		{
 			/* TODO Use Lemma 1 in k-means++ initialization */
-			distance = lowerBound[j * numCenters + k];
+			float		distance = lowerBound[j * numCenters + k];

 			if (distance < minDistance)
 			{
@@ -268,13 +258,14 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 	}

 	/* Give 500 iterations to converge */
-	for (iteration = 0; iteration < 500; iteration++)
+	for (int iteration = 0; iteration < 500; iteration++)
 	{
+		int			changes = 0;
+		bool		rjreset;
+
 		/* Can take a while, so ensure we can interrupt */
 		CHECK_FOR_INTERRUPTS();

-		changes = 0;
-
 		/* Step 1: For all centers, compute distance */
 		for (j = 0; j < numCenters; j++)
 		{
@@ -282,7 +273,8 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)

 			for (k = j + 1; k < numCenters; k++)
 			{
-				distance = 0.5 * DatumGetFloat8(FunctionCall2Coll(procinfo, collation, PointerGetDatum(vec), PointerGetDatum(VectorArrayGet(centers, k))));
+				float		distance = 0.5 * DatumGetFloat8(FunctionCall2Coll(procinfo, collation, PointerGetDatum(vec), PointerGetDatum(VectorArrayGet(centers, k))));
+
 				halfcdist[j * numCenters + k] = distance;
 				halfcdist[k * numCenters + j] = distance;
 			}
@@ -291,10 +283,12 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 		/* For all centers c, compute s(c) */
 		for (j = 0; j < numCenters; j++)
 		{
-			minDistance = DBL_MAX;
+			float		minDistance = FLT_MAX;

 			for (k = 0; k < numCenters; k++)
 			{
+				float		distance;
+
 				if (j == k)
 					continue;

@@ -310,6 +304,8 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)

 		for (j = 0; j < numSamples; j++)
 		{
+			bool		rj;
+
 			/* Step 2: Identify all points x such that u(x) <= s(c(x)) */
 			if (upperBound[j] <= s[closestCenters[j]])
 				continue;
@@ -318,6 +314,8 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)

 			for (k = 0; k < numCenters; k++)
 			{
+				float		dxcx;
+
 				/* Step 3: For all remaining points x and centers c */
 				if (k == closestCenters[j])
 					continue;
@@ -347,7 +345,7 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 				/* Step 3b */
 				if (dxcx > lowerBound[j * numCenters + k] || dxcx > halfcdist[closestCenters[j] * numCenters + k])
 				{
-					dxc = DatumGetFloat8(FunctionCall2Coll(procinfo, collation, PointerGetDatum(vec), PointerGetDatum(VectorArrayGet(centers, k))));
+					float		dxc = DatumGetFloat8(FunctionCall2Coll(procinfo, collation, PointerGetDatum(vec), PointerGetDatum(VectorArrayGet(centers, k))));

 					/* d(x,c) calculated */
 					lowerBound[j * numCenters + k] = dxc;
@@ -361,7 +359,6 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)

 						changes++;
 					}
-
 				}
 			}
 		}
@@ -378,6 +375,8 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)

 		for (j = 0; j < numSamples; j++)
 		{
+			int			closestCenter;
+
 			vec = VectorArrayGet(samples, j);
 			closestCenter = closestCenters[j];

@@ -426,7 +425,7 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 		{
 			for (k = 0; k < numCenters; k++)
 			{
-				distance = lowerBound[j * numCenters + k] - newcdist[k];
+				float		distance = lowerBound[j * numCenters + k] - newcdist[k];

 				if (distance < 0)
 					distance = 0;
@@ -442,7 +441,7 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)

 		/* Step 7 */
 		for (j = 0; j < numCenters; j++)
-			memcpy(VectorArrayGet(centers, j), VectorArrayGet(newCenters, j), VECTOR_SIZE(dimensions));
+			VectorArraySet(centers, j, VectorArrayGet(newCenters, j));

 		if (changes == 0 && iteration != 0)
 			break;
@@ -465,9 +464,6 @@ static void
 CheckCenters(Relation index, VectorArray centers)
 {
 	FmgrInfo   *normprocinfo;
-	Oid			collation;
-	Vector	   *vec;
-	double		norm;

 	if (centers->length != centers->maxlen)
 		elog(ERROR, "Not enough centers. Please report a bug.");
@@ -475,7 +471,7 @@ CheckCenters(Relation index, VectorArray centers)
 	/* Ensure no NaN or infinite values */
 	for (int i = 0; i < centers->length; i++)
 	{
-		vec = VectorArrayGet(centers, i);
+		Vector	   *vec = VectorArrayGet(centers, i);

 		for (int j = 0; j < vec->dim; j++)
 		{
@@ -501,11 +497,12 @@ CheckCenters(Relation index, VectorArray centers)
 	normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_NORM_PROC);
 	if (normprocinfo != NULL)
 	{
-		collation = index->rd_indcollation[0];
+		Oid			collation = index->rd_indcollation[0];

 		for (int i = 0; i < centers->length; i++)
 		{
-			norm = DatumGetFloat8(FunctionCall1Coll(normprocinfo, collation, PointerGetDatum(VectorArrayGet(centers, i))));
+			double		norm = DatumGetFloat8(FunctionCall1Coll(normprocinfo, collation, PointerGetDatum(VectorArrayGet(centers, i))));
+
 			if (norm == 0)
 				elog(ERROR, "Zero norm detected. Please report a bug.");
 		}
--- a/src/ivfscan.c
+++ b/src/ivfscan.c
@@ -31,36 +31,36 @@ CompareLists(const pairingheap_node *a, const pairingheap_node *b, void *arg)
 static void
 GetScanLists(IndexScanDesc scan, Datum value)
 {
-	Buffer		cbuf;
-	Page		cpage;
-	IvfflatList list;
-	OffsetNumber offno;
-	OffsetNumber maxoffno;
+	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
 	BlockNumber nextblkno = IVFFLAT_HEAD_BLKNO;
 	int			listCount = 0;
-	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
-	double		distance;
-	IvfflatScanList *scanlist;
 	double		maxDistance = DBL_MAX;

 	/* Search all list pages */
 	while (BlockNumberIsValid(nextblkno))
 	{
+		Buffer		cbuf;
+		Page		cpage;
+		OffsetNumber maxoffno;
+
 		cbuf = ReadBuffer(scan->indexRelation, nextblkno);
 		LockBuffer(cbuf, BUFFER_LOCK_SHARE);
 		cpage = BufferGetPage(cbuf);

 		maxoffno = PageGetMaxOffsetNumber(cpage);

-		for (offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
+		for (OffsetNumber offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
 		{
-			list = (IvfflatList) PageGetItem(cpage, PageGetItemId(cpage, offno));
+			IvfflatList list = (IvfflatList) PageGetItem(cpage, PageGetItemId(cpage, offno));
+			double		distance;

 			/* Use procinfo from the index instead of scan key for performance */
 			distance = DatumGetFloat8(FunctionCall2Coll(so->procinfo, so->collation, PointerGetDatum(&list->center), value));

 			if (listCount < so->probes)
 			{
+				IvfflatScanList *scanlist;
+
 				scanlist = &so->lists[listCount];
 				scanlist->startPage = list->startPage;
 				scanlist->distance = distance;
@@ -75,6 +75,8 @@ GetScanLists(IndexScanDesc scan, Datum value)
 			}
 			else if (distance < maxDistance)
 			{
+				IvfflatScanList *scanlist;
+
 				/* Remove */
 				scanlist = (IvfflatScanList *) pairingheap_remove_first(so->listQueue);

@@ -101,14 +103,6 @@ static void
 GetScanItems(IndexScanDesc scan, Datum value)
 {
 	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
-	Buffer		buf;
-	Page		page;
-	IndexTuple	itup;
-	BlockNumber searchPage;
-	OffsetNumber offno;
-	OffsetNumber maxoffno;
-	Datum		datum;
-	bool		isnull;
 	TupleDesc	tupdesc = RelationGetDescr(scan->indexRelation);
 	double		tuples = 0;

@@ -128,19 +122,28 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	/* Search closest probes lists */
 	while (!pairingheap_is_empty(so->listQueue))
 	{
-		searchPage = ((IvfflatScanList *) pairingheap_remove_first(so->listQueue))->startPage;
+		BlockNumber searchPage = ((IvfflatScanList *) pairingheap_remove_first(so->listQueue))->startPage;

 		/* Search all entry pages for list */
 		while (BlockNumberIsValid(searchPage))
 		{
+			Buffer		buf;
+			Page		page;
+			OffsetNumber maxoffno;
+
 			buf = ReadBufferExtended(scan->indexRelation, MAIN_FORKNUM, searchPage, RBM_NORMAL, bas);
 			LockBuffer(buf, BUFFER_LOCK_SHARE);
 			page = BufferGetPage(buf);
 			maxoffno = PageGetMaxOffsetNumber(page);

-			for (offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
+			for (OffsetNumber offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
 			{
-				itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offno));
+				IndexTuple	itup;
+				Datum		datum;
+				bool		isnull;
+				ItemId		itemid = PageGetItemId(page, offno);
+
+				itup = (IndexTuple) PageGetItem(page, itemid);
 				datum = index_getattr(itup, 1, tupdesc, &isnull);

 				/*
@@ -154,8 +157,6 @@ GetScanItems(IndexScanDesc scan, Datum value)
 				slot->tts_isnull[0] = false;
 				slot->tts_values[1] = PointerGetDatum(&itup->t_tid);
 				slot->tts_isnull[1] = false;
-				slot->tts_values[2] = Int32GetDatum((int) searchPage);
-				slot->tts_isnull[2] = false;
 				ExecStoreVirtualTuple(slot);

 				tuplesort_puttupleslot(so->sortstate, slot);
@@ -180,29 +181,6 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	tuplesort_performsort(so->sortstate);
 }

-/*
- * Get dimensions from metapage
- */
-static int
-GetDimensions(Relation index)
-{
-	Buffer		buf;
-	Page		page;
-	IvfflatMetaPage metap;
-	int			dimensions;
-
-	buf = ReadBuffer(index, IVFFLAT_METAPAGE_BLKNO);
-	LockBuffer(buf, BUFFER_LOCK_SHARE);
-	page = BufferGetPage(buf);
-	metap = IvfflatPageGetMeta(page);
-
-	dimensions = metap->dimensions;
-
-	UnlockReleaseBuffer(buf);
-
-	return dimensions;
-}
-
 /*
 * Prepare for an index scan
 */
@@ -212,6 +190,7 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	IndexScanDesc scan;
 	IvfflatScanOpaque so;
 	int			lists;
+	int			dimensions;
 	AttrNumber	attNums[] = {1};
 	Oid			sortOperators[] = {Float8LessOperator};
 	Oid			sortCollations[] = {InvalidOid};
@@ -219,15 +198,17 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	int			probes = ivfflat_probes;

 	scan = RelationGetIndexScan(index, nkeys, norderbys);
-	lists = IvfflatGetLists(scan->indexRelation);
+
+	/* Get lists and dimensions from metapage */
+	IvfflatGetMetaPageInfo(index, &lists, &dimensions);

 	if (probes > lists)
 		probes = lists;

 	so = (IvfflatScanOpaque) palloc(offsetof(IvfflatScanOpaqueData, lists) + probes * sizeof(IvfflatScanList));
-	so->buf = InvalidBuffer;
 	so->first = true;
 	so->probes = probes;
+	so->dimensions = dimensions;

 	/* Set support functions */
 	so->procinfo = index_getprocinfo(index, 1, IVFFLAT_DISTANCE_PROC);
@@ -236,13 +217,12 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)

 	/* Create tuple description for sorting */
 #if PG_VERSION_NUM >= 120000
-	so->tupdesc = CreateTemplateTupleDesc(3);
+	so->tupdesc = CreateTemplateTupleDesc(2);
 #else
-	so->tupdesc = CreateTemplateTupleDesc(3, false);
+	so->tupdesc = CreateTemplateTupleDesc(2, false);
 #endif
 	TupleDescInitEntry(so->tupdesc, (AttrNumber) 1, "distance", FLOAT8OID, -1, 0);
-	TupleDescInitEntry(so->tupdesc, (AttrNumber) 2, "tid", TIDOID, -1, 0);
-	TupleDescInitEntry(so->tupdesc, (AttrNumber) 3, "indexblkno", INT4OID, -1, 0);
+	TupleDescInitEntry(so->tupdesc, (AttrNumber) 2, "heaptid", TIDOID, -1, 0);

 	/* Prep sort */
 	so->sortstate = tuplesort_begin_heap(so->tupdesc, 1, attNums, sortOperators, sortCollations, nullsFirstFlags, work_mem, NULL, false);
@@ -308,8 +288,13 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 		if (scan->orderByData == NULL)
 			elog(ERROR, "cannot scan ivfflat index without order");

+		/* Requires MVCC-compliant snapshot as not able to pin during sorting */
+		/* https://www.postgresql.org/docs/current/index-locking.html */
+		if (!IsMVCCSnapshot(scan->xs_snapshot))
+			elog(ERROR, "non-MVCC snapshots are not supported with ivfflat");
+
 		if (scan->orderByData->sk_flags & SK_ISNULL)
-			value = PointerGetDatum(InitVector(GetDimensions(scan->indexRelation)));
+			value = PointerGetDatum(InitVector(so->dimensions));
 		else
 		{
 			value = scan->orderByData->sk_argument;
@@ -334,27 +319,14 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)

 	if (tuplesort_gettupleslot(so->sortstate, true, false, so->slot, NULL))
 	{
-		ItemPointer tid = (ItemPointer) DatumGetPointer(slot_getattr(so->slot, 2, &so->isnull));
-		BlockNumber indexblkno = DatumGetInt32(slot_getattr(so->slot, 3, &so->isnull));
+		ItemPointer heaptid = (ItemPointer) DatumGetPointer(slot_getattr(so->slot, 2, &so->isnull));

 #if PG_VERSION_NUM >= 120000
-		scan->xs_heaptid = *tid;
+		scan->xs_heaptid = *heaptid;
 #else
-		scan->xs_ctup.t_self = *tid;
+		scan->xs_ctup.t_self = *heaptid;
 #endif

-		/* Unpin buffer */
-		if (BufferIsValid(so->buf))
-			ReleaseBuffer(so->buf);
-
-		/*
-		 * An index scan must maintain a pin on the index page holding the
-		 * item last returned by amgettuple
-		 *
-		 * https://www.postgresql.org/docs/current/index-locking.html
-		 */
-		so->buf = ReadBuffer(scan->indexRelation, indexblkno);
-
 		scan->xs_recheckorderby = false;
 		return true;
 	}
@@ -370,10 +342,6 @@ ivfflatendscan(IndexScanDesc scan)
 {
 	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;

-	/* Release pin */
-	if (BufferIsValid(so->buf))
-		ReleaseBuffer(so->buf);
-
 	pairingheap_free(so->listQueue);
 	tuplesort_end(so->sortstate);

--- a/src/ivfutils.c
+++ b/src/ivfutils.c
@@ -57,12 +57,12 @@ IvfflatGetLists(Relation index)
 * Get proc
 */
 FmgrInfo *
-IvfflatOptionalProcInfo(Relation rel, uint16 procnum)
+IvfflatOptionalProcInfo(Relation index, uint16 procnum)
 {
-	if (!OidIsValid(index_getprocid(rel, 1, procnum)))
+	if (!OidIsValid(index_getprocid(index, 1, procnum)))
 		return NULL;

-	return index_getprocinfo(rel, 1, procnum);
+	return index_getprocinfo(index, 1, procnum);
 }

 /*
@@ -136,7 +136,6 @@ IvfflatInitRegisterPage(Relation index, Buffer *buf, Page *page, GenericXLogStat
 void
 IvfflatCommitBuffer(Buffer buf, GenericXLogState *state)
 {
-	MarkBufferDirty(buf);
 	GenericXLogFinish(state);
 	UnlockReleaseBuffer(buf);
 }
@@ -160,8 +159,6 @@ IvfflatAppendPage(Relation index, Buffer *buf, Page *page, GenericXLogState **st
 	IvfflatInitPage(newbuf, newpage);

 	/* Commit */
-	MarkBufferDirty(*buf);
-	MarkBufferDirty(newbuf);
 	GenericXLogFinish(*state);

 	/* Unlock */
@@ -172,6 +169,29 @@ IvfflatAppendPage(Relation index, Buffer *buf, Page *page, GenericXLogState **st
 	*buf = newbuf;
 }

+/*
+ * Get the metapage info
+ */
+void
+IvfflatGetMetaPageInfo(Relation index, int *lists, int *dimensions)
+{
+	Buffer		buf;
+	Page		page;
+	IvfflatMetaPage metap;
+
+	buf = ReadBuffer(index, IVFFLAT_METAPAGE_BLKNO);
+	LockBuffer(buf, BUFFER_LOCK_SHARE);
+	page = BufferGetPage(buf);
+	metap = IvfflatPageGetMeta(page);
+
+	*lists = metap->lists;
+
+	if (dimensions != NULL)
+		*dimensions = metap->dimensions;
+
+	UnlockReleaseBuffer(buf);
+}
+
 /*
 * Update the start or insert page of a list
 */
--- a/src/ivfvacuum.c
+++ b/src/ivfvacuum.c
@@ -107,7 +107,6 @@ ivfflatbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 				{
 					/* Delete tuples */
 					PageIndexMultiDelete(page, deletable, ndeletable);
-					MarkBufferDirty(buf);
 					GenericXLogFinish(state);
 				}
 				else
--- a/src/vector.c
+++ b/src/vector.c
@@ -89,7 +89,7 @@ CheckDim(int dim)
 }

 /*
- * Ensure finite elements
+ * Ensure finite element
 */
 static inline void
 CheckElement(float value)
@@ -437,17 +437,18 @@ vector_send(PG_FUNCTION_ARGS)

 /*
 * Convert vector to vector
+ * This is needed to check the type modifier
 */
 PGDLLEXPORT PG_FUNCTION_INFO_V1(vector);
 Datum
 vector(PG_FUNCTION_ARGS)
 {
-	Vector	   *arg = PG_GETARG_VECTOR_P(0);
+	Vector	   *vec = PG_GETARG_VECTOR_P(0);
 	int32		typmod = PG_GETARG_INT32(1);

-	CheckExpectedDim(typmod, arg->dim);
+	CheckExpectedDim(typmod, vec->dim);

-	PG_RETURN_POINTER(arg);
+	PG_RETURN_POINTER(vec);
 }

 /*
@@ -464,7 +465,6 @@ array_to_vector(PG_FUNCTION_ARGS)
 	bool		typbyval;
 	char		typalign;
 	Datum	   *elemsp;
-	bool	   *nullsp;
 	int			nelemsp;

 	if (ARR_NDIM(array) > 1)
@@ -478,7 +478,7 @@ array_to_vector(PG_FUNCTION_ARGS)
 				 errmsg("array must not contain nulls")));

 	get_typlenbyvalalign(ARR_ELEMTYPE(array), &typlen, &typbyval, &typalign);
-	deconstruct_array(array, ARR_ELEMTYPE(array), typlen, typbyval, typalign, &elemsp, &nullsp, &nelemsp);
+	deconstruct_array(array, ARR_ELEMTYPE(array), typlen, typbyval, typalign, &elemsp, NULL, &nelemsp);

 	CheckDim(nelemsp);
 	CheckExpectedDim(typmod, nelemsp);
@@ -512,6 +512,12 @@ array_to_vector(PG_FUNCTION_ARGS)
 				 errmsg("unsupported array type")));
 	}

+	/*
+	 * Free allocation from deconstruct_array. Do not free individual elements
+	 * when pass-by-reference since they point to original array.
+	 */
+	pfree(elemsp);
+
 	/* Check elements */
 	for (int i = 0; i < result->dim; i++)
 		CheckElement(result->x[i]);
@@ -695,6 +701,8 @@ vector_spherical_distance(PG_FUNCTION_ARGS)
 {
 	Vector	   *a = PG_GETARG_VECTOR_P(0);
 	Vector	   *b = PG_GETARG_VECTOR_P(1);
+	float	   *ax = a->x;
+	float	   *bx = b->x;
 	float		dp = 0.0;
 	double		distance;

@@ -702,7 +710,7 @@ vector_spherical_distance(PG_FUNCTION_ARGS)

 	/* Auto-vectorized */
 	for (int i = 0; i < a->dim; i++)
-		dp += a->x[i] * b->x[i];
+		dp += ax[i] * bx[i];

 	distance = (double) dp;

@@ -716,7 +724,7 @@ vector_spherical_distance(PG_FUNCTION_ARGS)
 }

 /*
- * Get the L1 distance between vectors
+ * Get the L1 distance between two vectors
 */
 PGDLLEXPORT PG_FUNCTION_INFO_V1(l1_distance);
 Datum
@@ -895,8 +903,8 @@ PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_lt);
 Datum
 vector_lt(PG_FUNCTION_ARGS)
 {
-	Vector	   *a = (Vector *) PG_GETARG_VECTOR_P(0);
-	Vector	   *b = (Vector *) PG_GETARG_VECTOR_P(1);
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	Vector	   *b = PG_GETARG_VECTOR_P(1);

 	PG_RETURN_BOOL(vector_cmp_internal(a, b) < 0);
 }
@@ -908,8 +916,8 @@ PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_le);
 Datum
 vector_le(PG_FUNCTION_ARGS)
 {
-	Vector	   *a = (Vector *) PG_GETARG_VECTOR_P(0);
-	Vector	   *b = (Vector *) PG_GETARG_VECTOR_P(1);
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	Vector	   *b = PG_GETARG_VECTOR_P(1);

 	PG_RETURN_BOOL(vector_cmp_internal(a, b) <= 0);
 }
@@ -921,8 +929,8 @@ PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_eq);
 Datum
 vector_eq(PG_FUNCTION_ARGS)
 {
-	Vector	   *a = (Vector *) PG_GETARG_VECTOR_P(0);
-	Vector	   *b = (Vector *) PG_GETARG_VECTOR_P(1);
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	Vector	   *b = PG_GETARG_VECTOR_P(1);

 	PG_RETURN_BOOL(vector_cmp_internal(a, b) == 0);
 }
@@ -934,8 +942,8 @@ PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_ne);
 Datum
 vector_ne(PG_FUNCTION_ARGS)
 {
-	Vector	   *a = (Vector *) PG_GETARG_VECTOR_P(0);
-	Vector	   *b = (Vector *) PG_GETARG_VECTOR_P(1);
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	Vector	   *b = PG_GETARG_VECTOR_P(1);

 	PG_RETURN_BOOL(vector_cmp_internal(a, b) != 0);
 }
@@ -947,8 +955,8 @@ PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_ge);
 Datum
 vector_ge(PG_FUNCTION_ARGS)
 {
-	Vector	   *a = (Vector *) PG_GETARG_VECTOR_P(0);
-	Vector	   *b = (Vector *) PG_GETARG_VECTOR_P(1);
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	Vector	   *b = PG_GETARG_VECTOR_P(1);

 	PG_RETURN_BOOL(vector_cmp_internal(a, b) >= 0);
 }
@@ -960,8 +968,8 @@ PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_gt);
 Datum
 vector_gt(PG_FUNCTION_ARGS)
 {
-	Vector	   *a = (Vector *) PG_GETARG_VECTOR_P(0);
-	Vector	   *b = (Vector *) PG_GETARG_VECTOR_P(1);
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	Vector	   *b = PG_GETARG_VECTOR_P(1);

 	PG_RETURN_BOOL(vector_cmp_internal(a, b) > 0);
 }
@@ -973,8 +981,8 @@ PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_cmp);
 Datum
 vector_cmp(PG_FUNCTION_ARGS)
 {
-	Vector	   *a = (Vector *) PG_GETARG_VECTOR_P(0);
-	Vector	   *b = (Vector *) PG_GETARG_VECTOR_P(1);
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	Vector	   *b = PG_GETARG_VECTOR_P(1);

 	PG_RETURN_INT32(vector_cmp_internal(a, b));
 }
--- a/test/expected/functions.out
+++ b/test/expected/functions.out
@@ -106,6 +106,12 @@ SELECT cosine_distance('[1,1]', '[1,1]');
               0
 (1 row)

+SELECT cosine_distance('[1,0]', '[0,2]');
+ cosine_distance 
+-----------------
+               1
+(1 row)
+
 SELECT cosine_distance('[1,1]', '[-1,-1]');
 cosine_distance 
 -----------------
--- a/test/sql/functions.sql
+++ b/test/sql/functions.sql
@@ -25,6 +25,7 @@ SELECT inner_product('[3e38]', '[3e38]');
 SELECT cosine_distance('[1,2]', '[2,4]');
 SELECT cosine_distance('[1,2]', '[0,0]');
 SELECT cosine_distance('[1,1]', '[1,1]');
+SELECT cosine_distance('[1,0]', '[0,2]');
 SELECT cosine_distance('[1,1]', '[-1,-1]');
 SELECT cosine_distance('[1,2]', '[3]');
 SELECT cosine_distance('[1,1]', '[1.1,1.1]');
--- a/test/t/001_ivfflat_wal.pl
+++ b/test/t/001_ivfflat_wal.pl
@@ -19,8 +19,6 @@ sub test_index_replay

 	# Wait for replica to catch up
 	my $applname = $node_replica->name;
-
-	my $server_version_num = $node_primary->safe_psql("postgres", "SHOW server_version_num");
 	my $caughtup_query = "SELECT pg_current_wal_lsn() <= replay_lsn FROM pg_stat_replication WHERE application_name = '$applname';";
 	$node_primary->poll_query_until('postgres', $caughtup_query)
 	  or die "Timed out while waiting for replica 1 to catch up";
--- a/test/t/003_ivfflat_build_recall.pl
+++ b/test/t/003_ivfflat_build_recall.pl
@@ -94,7 +94,7 @@ for my $i (0 .. $#operators)
 	# Test approximate results
 	if ($operator ne "<#>")
 	{
-		# TODO fix test
+		# TODO Fix test (uniform random vectors all have similar inner product)
 		test_recall(1, 0.71, $operator);
 		test_recall(10, 0.95, $operator);
 	}
@@ -115,7 +115,7 @@ for my $i (0 .. $#operators)
 	# Test approximate results
 	if ($operator ne "<#>")
 	{
-		# TODO fix test
+		# TODO Fix test (uniform random vectors all have similar inner product)
 		test_recall(1, 0.71, $operator);
 		test_recall(10, 0.95, $operator);
 	}
--- a/test/t/010_hnsw_wal.pl
+++ b/test/t/010_hnsw_wal.pl
@@ -19,8 +19,6 @@ sub test_index_replay

 	# Wait for replica to catch up
 	my $applname = $node_replica->name;
-
-	my $server_version_num = $node_primary->safe_psql("postgres", "SHOW server_version_num");
 	my $caughtup_query = "SELECT pg_current_wal_lsn() <= replay_lsn FROM pg_stat_replication WHERE application_name = '$applname';";
 	$node_primary->poll_query_until('postgres', $caughtup_query)
 	  or die "Timed out while waiting for replica 1 to catch up";
--- a/test/t/012_hnsw_build_recall.pl
+++ b/test/t/012_hnsw_build_recall.pl
@@ -99,6 +99,7 @@ for my $i (0 .. $#operators)
 	my ($ret, $stdout, $stderr) = $node->psql("postgres", qq(
 		SET client_min_messages = DEBUG;
 		SET min_parallel_table_scan_size = 1;
+		SET hnsw.enable_parallel_build = on;
 		CREATE INDEX idx ON tst USING hnsw (v $opclass);
 	));
 	is($ret, 0, $stderr);
--- a/test/t/016_hnsw_vacuum_recall.pl
+++ b/test/t/016_hnsw_vacuum_recall.pl
@@ -89,7 +89,7 @@ foreach (@queries)
 test_recall(0.20, $limit, "before vacuum");
 test_recall(0.95, 100, "before vacuum");

-# TODO test concurrent inserts with vacuum
+# TODO Test concurrent inserts with vacuum
 $node->safe_psql("postgres", "VACUUM tst;");

 test_recall(0.95, $limit, "after vacuum");
--- a/test/t/017_ivfflat_insert_recall.pl
+++ b/test/t/017_ivfflat_insert_recall.pl
@@ -0,0 +1,117 @@
+use strict;
+use warnings;
+use PostgresNode;
+use TestLib;
+use Test::More;
+
+my $node;
+my @queries = ();
+my @expected;
+my $limit = 20;
+
+sub test_recall
+{
+	my ($probes, $min, $operator) = @_;
+	my $correct = 0;
+	my $total = 0;
+
+	my $explain = $node->safe_psql("postgres", qq(
+		SET enable_seqscan = off;
+		SET ivfflat.probes = $probes;
+		EXPLAIN ANALYZE SELECT i FROM tst ORDER BY v $operator '$queries[0]' LIMIT $limit;
+	));
+	like($explain, qr/Index Scan using idx on tst/);
+
+	for my $i (0 .. $#queries)
+	{
+		my $actual = $node->safe_psql("postgres", qq(
+			SET enable_seqscan = off;
+			SET ivfflat.probes = $probes;
+			SELECT i FROM tst ORDER BY v $operator '$queries[$i]' LIMIT $limit;
+		));
+		my @actual_ids = split("\n", $actual);
+		my %actual_set = map { $_ => 1 } @actual_ids;
+
+		my @expected_ids = split("\n", $expected[$i]);
+
+		foreach (@expected_ids)
+		{
+			if (exists($actual_set{$_}))
+			{
+				$correct++;
+			}
+			$total++;
+		}
+	}
+
+	cmp_ok($correct / $total, ">=", $min, $operator);
+}
+
+# Initialize node
+$node = get_new_node('node');
+$node->init;
+$node->start;
+
+# Create table
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (i serial, v vector(3));");
+
+# Generate queries
+for (1 .. 20)
+{
+	my $r1 = rand();
+	my $r2 = rand();
+	my $r3 = rand();
+	push(@queries, "[$r1,$r2,$r3]");
+}
+
+# Check each index type
+my @operators = ("<->", "<#>", "<=>");
+my @opclasses = ("vector_l2_ops", "vector_ip_ops", "vector_cosine_ops");
+
+for my $i (0 .. $#operators)
+{
+	my $operator = $operators[$i];
+	my $opclass = $opclasses[$i];
+
+	# Add index
+	$node->safe_psql("postgres", "CREATE INDEX idx ON tst USING ivfflat (v $opclass);");
+
+	# Use concurrent inserts
+	$node->pgbench(
+		"--no-vacuum --client=10 --transactions=1000",
+		0,
+		[qr{actually processed}],
+		[qr{^$}],
+		"concurrent INSERTs",
+		{
+			"017_ivfflat_insert_recall_$opclass" => "INSERT INTO tst (v) SELECT ARRAY[random(), random(), random()] FROM generate_series(1, 10) i;"
+		}
+	);
+
+	# Get exact results
+	@expected = ();
+	foreach (@queries)
+	{
+		my $res = $node->safe_psql("postgres", qq(
+			SET enable_indexscan = off;
+			SELECT i FROM tst ORDER BY v $operator '$_' LIMIT $limit;
+		));
+		push(@expected, $res);
+	}
+
+	# Test approximate results
+	if ($operator ne "<#>")
+	{
+		# TODO Fix test (uniform random vectors all have similar inner product)
+		test_recall(1, 0.71, $operator);
+		test_recall(10, 0.95, $operator);
+	}
+	# Account for equal distances
+	test_recall(100, 0.9925, $operator);
+
+	$node->safe_psql("postgres", "DROP INDEX idx;");
+	$node->safe_psql("postgres", "TRUNCATE tst;");
+}
+
+done_testing();
--- a/test/t/018_ivfflat_deletes.pl
+++ b/test/t/018_ivfflat_deletes.pl
@@ -0,0 +1,43 @@
+use strict;
+use warnings;
+use PostgresNode;
+use TestLib;
+use Test::More;
+
+my $dim = 3;
+
+my $array_sql = join(",", ('random()') x $dim);
+
+# Initialize node
+my $node = get_new_node('node');
+$node->init;
+$node->start;
+
+# Create table and index
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (i serial, v vector($dim));");
+$node->safe_psql("postgres",
+	"INSERT INTO tst (v) SELECT ARRAY[$array_sql] FROM generate_series(1, 10000) i;"
+);
+$node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v vector_l2_ops);");
+
+# Delete data
+$node->safe_psql("postgres", "DELETE FROM tst WHERE i % 100 != 0;");
+
+my $exp = $node->safe_psql("postgres", qq(
+	SET enable_indexscan = off;
+	SELECT i FROM tst ORDER BY v <-> '[0,0,0]';
+));
+
+# Run twice to make sure correct tuples marked as dead
+for (1 .. 2)
+{
+	my $res = $node->safe_psql("postgres", qq(
+		SET enable_seqscan = off;
+		SET ivfflat.probes = 100;
+		SELECT i FROM tst ORDER BY v <-> '[0,0,0]';
+	));
+	is($res, $exp);
+}
+
+done_testing();
--- a/vector.control
+++ b/vector.control
@@ -1,4 +1,4 @@
-comment = 'vector data type and ivfflat access method'
-default_version = '0.5.0'
+comment = 'vector data type and ivfflat and hnsw access methods'
+default_version = '0.5.1'
 module_pathname = '$libdir/vector'
 relocatable = true
Author	SHA1	Message	Date
Andrew Kane	6c347b7f3e	Removed unused functions	2023-12-19 19:47:03 -05:00
Andrew Kane	3e628986a1	Removed metapage logging [skip ci]	2023-12-19 17:23:35 -05:00
Andrew Kane	858a89575b	Removed metapage [skip ci]	2023-12-19 17:20:55 -05:00
Andrew Kane	d81c1c9de0	Improved code [skip ci]	2023-12-19 17:01:11 -05:00
Andrew Kane	4988d04338	Improved code [skip ci]	2023-12-19 17:00:14 -05:00
Andrew Kane	c640def56c	Use forkNum [skip ci]	2023-12-19 13:58:58 -05:00
Andrew Kane	87fe23d9ec	Added code for Postgres < 11.8	2023-12-19 13:55:56 -05:00
Andrew Kane	041f939bde	Fixed warnings	2023-12-19 12:01:09 -05:00
Andrew Kane	5d7bf9509d	Reduced WAL generation for HNSW index builds	2023-12-19 11:49:40 -05:00
Andrew Kane	921427ee03	Replace dynahash hash table in HNSW with simplehash for speed - #378 Co-authored-by: Heikki Linnakangas <heikki.linnakangas@iki.fi>	2023-12-17 11:24:13 -05:00
Andrew Kane	a59aa02dd9	Only show message if flushed due to memory [skip ci]	2023-12-04 15:29:23 -08:00
Andrew Kane	2fef497b7e	Fixed check	2023-12-04 15:22:12 -08:00
Andrew Kane	0e19a984fb	Updated changelog [skip ci]	2023-12-04 15:15:20 -08:00
Andrew Kane	a156f6c7ae	Fixed invalid memory alloc request size error with HNSW - fixes #43	2023-12-04 15:00:32 -08:00
Andrew Kane	c653ac524f	Simplified code [skip ci]	2023-12-04 12:19:38 -08:00
Andrew Kane	bf0d56e78e	Updated comment [skip ci]	2023-12-03 13:09:57 -08:00
Andrew Kane	4d6739a7af	Added Lisp to readme [skip ci]	2023-12-03 10:58:54 -08:00
Andrew Kane	ff744214d0	Added Visual Basic to readme [skip ci]	2023-12-03 00:25:07 -08:00
Andrew Kane	7ca9298163	Updated badge [skip ci]	2023-12-01 15:36:49 -08:00
Andrew Kane	ff3bffd9a8	Moved FAQ [skip ci]	2023-11-29 22:09:09 -08:00
Andrew Kane	014753eb9c	Added FAQ about memory [skip ci]	2023-11-29 22:02:27 -08:00
Andrew Kane	6763661d3d	Added OCaml to readme [skip ci]	2023-11-28 21:42:30 -08:00
Andrew Kane	d287921d15	Added F# to readme [skip ci]	2023-11-28 01:22:12 -08:00
Andrew Kane	5b12ae8225	Added note about ef_construction [skip ci]	2023-11-16 18:53:48 -08:00
Japin Li	4549e8aeb1	Fix coredump about HnswFreeElement() (#357 ) The HnswInitElement() allocate an element with not initialize value filed, which may has garbage that lead HnswFreeElement() free an invalid pointer.	2023-11-15 16:19:59 -08:00
Andrew Kane	3263b350f5	Updated HnswLoadElementFromTuple to be less vector-specific	2023-11-11 21:14:12 -08:00
Andrew Kane	dfee5d4045	Added support for on-disk parallel index builds for HNSW	2023-11-11 19:29:45 -08:00
Andrew Kane	69a2ce0d43	Use datumIsEqual to compare	2023-11-10 10:46:48 -08:00
Andrew Kane	c5e8c46b80	Switched from VECTOR_SIZE to VARSIZE_ANY [skip ci]	2023-11-09 19:41:38 -08:00
Andrew Kane	94f7304ccd	Keep vector for now to be overly cautious about packing [skip ci]	2023-11-09 18:43:55 -08:00
Andrew Kane	d078db3d25	Switched HnswElementTuple to generic data and zero full section	2023-11-09 18:28:25 -08:00
Andrew Kane	fbb904ae2f	Use pointer for VARSIZE_ANY	2023-11-09 17:50:28 -08:00
Andrew Kane	3cf6f62900	Switched to datum for HnswElement	2023-11-09 17:35:39 -08:00
Andrew Kane	2a69e22ca4	Switched from VECTOR_SIZE to VARSIZE_ANY where possible (less vector-specific)	2023-11-09 17:16:43 -08:00
Andrew Kane	84e073888c	Removed vector-specific code from HNSW_ELEMENT_TUPLE_SIZE [skip ci]	2023-11-09 16:57:01 -08:00
Andrew Kane	81a62d55d1	Switched from HNSW_ELEMENT_TUPLE_SIZE to ItemIdGetLength where possible (less vector-specific)	2023-11-09 16:32:00 -08:00
Andrew Kane	3f3463bde5	Improved memory calculation for HNSW and removed vector-specific code	2023-11-09 16:21:26 -08:00
Andrew Kane	a01a72d812	Updated comment [skip ci]	2023-11-05 08:42:06 -08:00
Andrew Kane	0c2fc18a80	Updated comment [skip ci]	2023-11-05 08:40:21 -08:00
Andrew Kane	e860042d3c	Improved variable name [skip ci]	2023-11-05 08:35:54 -08:00
Andrew Kane	5986862bd2	Added note about check constraint [skip ci]	2023-11-04 15:01:37 -07:00
Andrew Kane	5d24f5d09a	Improved header installation on Windows	2023-11-04 11:16:40 -07:00
Andrew Kane	7c43b0d8ee	Updated example [skip ci]	2023-11-03 23:54:50 -07:00
Andrew Kane	7be40036f4	Updated readme [skip ci]	2023-11-03 23:46:23 -07:00
Andrew Kane	9b5a1a69db	Updated readme [skip ci]	2023-11-03 23:43:47 -07:00
Andrew Kane	04b96506f5	Added info on storing vectors with more precision [skip ci]	2023-11-03 20:14:28 -07:00
Andrew Kane	35cd7b63cb	Updated readme [skip ci]	2023-11-03 17:02:30 -07:00
Andrew Kane	b5416d6f10	Updated readme [skip ci]	2023-11-03 16:48:57 -07:00
Andrew Kane	f361bf2704	Improved docs on indexing vectors with different dimensions [skip ci]	2023-11-03 16:42:14 -07:00
Andrew Kane	3d8c1921aa	Improved upgrading docs - #339 [skip ci]	2023-11-03 16:15:06 -07:00
Andrew Kane	154207bc17	Added info on columns with different dimensions [skip ci]	2023-11-03 16:02:00 -07:00
Andrew Kane	8e507f3bf5	Free remaining allocation from deconstruct_array - #332	2023-11-02 21:20:21 -07:00
Andrew Kane	e115773a55	Removed unneeded allocation	2023-11-02 21:16:06 -07:00
Andrew Kane	9333bef046	Added link to setup-pgvector [skip ci]	2023-11-02 13:22:19 -07:00
Andrew Kane	4851e47d9f	Added Reciprocal Rank Fusion example to readme [skip ci]	2023-11-01 13:20:49 -07:00
Andrew Kane	12aecfb4f5	Added Nim and Zig to readme [skip ci]	2023-10-31 02:26:18 -07:00
Andrew Kane	800697fb14	Updated column alias [skip ci]	2023-10-29 16:47:55 -07:00
Andrew Kane	de1f2b09dd	Improved indexing progress queries [skip ci]	2023-10-29 16:41:39 -07:00
Andrew Kane	bcccb7f5a5	Improved docs for indexing progress - closes #320 and closes #321 [skip ci]	2023-10-29 16:13:12 -07:00
Andrew Kane	bec3d30d68	Added TypeScript to readme [skip ci]	2023-10-29 12:49:01 -07:00
Andrew Kane	588de60445	Added Groovy to readme [skip ci]	2023-10-29 12:39:53 -07:00
Andrew Kane	c599f92b52	Updated readme [skip ci]	2023-10-27 13:22:37 -07:00
Andrew Kane	2a17b335da	Added Kotlin to readme [skip ci]	2023-10-26 12:25:58 -07:00
Andrew Kane	6ede6ac301	Added link to pgvector-c [skip ci]	2023-10-26 00:30:06 -07:00
Andrew Kane	3f49b95f01	Added Postgres 17 to CI [skip ci]	2023-10-19 00:37:24 -07:00
Andrew Kane	ef1bea7163	Updated checkout action [skip ci]	2023-10-19 00:36:53 -07:00
Andrew Kane	e630efd195	Version bump to 0.5.1 [skip ci]	2023-10-10 17:40:57 -07:00
Andrew Kane	b5b912906b	Added check for MVCC-compliant snapshot and removed marking tuples as dead for IVFFlat index scans - closes #260	2023-10-10 17:28:48 -07:00
Andrew Kane	4b5db94307	Disable closer caching for new elements for now	2023-10-06 14:27:09 -07:00
Andrew Kane	65e70326b8	Updated comment [skip ci]	2023-10-06 14:07:35 -07:00
Andrew Kane	71641ed84e	Updated comment [skip ci]	2023-10-06 13:58:07 -07:00
Andrew Kane	f3dba25036	Added comment [skip ci]	2023-10-06 13:56:25 -07:00
Andrew Kane	5588ba6410	Improved variable name [skip ci]	2023-10-06 13:46:19 -07:00
Andrew Kane	ec9fac5456	Improved closerSet logic	2023-10-06 13:39:55 -07:00
Andrew Kane	8085d3e538	Moved sorting logic into SelectNeighbors	2023-10-06 12:56:15 -07:00
Andrew Kane	cae162ffc6	Ensure order is deterministic for SelectNeighbors closer caching	2023-10-06 12:26:53 -07:00
Andrew Kane	62482e3760	Use e for consistency	2023-10-05 16:15:13 -07:00
Heikki Linnakangas	c81302b835	Improve HNSW index build performance more (#295 ) This takes the approach from commit `a713e2acaa` further. Once we have remove a candidate from the "closer" set, we still don't need to recalculate everything that follows. Any candidates that were in the closer set before still only need to be compared with any new candidates that we have added.	2023-10-05 16:04:50 -07:00
Andrew Kane	a713e2acaa	Improved performance of HNSW index builds - closes #292 Co-authored-by: Heikki Linnakangas <heikki.linnakangas@iki.fi>	2023-10-05 13:21:26 -07:00
Andrew Kane	6e1312ddbe	DRY max size	2023-10-04 21:43:34 -07:00
Andrew Kane	4ef5bca275	Use BLCKSZ for consistency	2023-10-04 21:37:55 -07:00
Xiaoran Wang	1ecf6ada76	Include `ItemIdData` when computing the maxSize for the data in a page (#274 ) As the data is aligned, for hnsw, the combined size won't be in the range (8156 (maxSize exlucding `ItemIdData`), 8160]. So even if the ItemIdData is not included in the maxSize, it works well now, but I think it's better to make it correct.	2023-10-04 21:26:46 -07:00
Andrew Kane	564a3d45fc	Added check for MVCC-compliant snapshot for HNSW index scans - closes #281	2023-10-04 20:14:50 -07:00
Andrew Kane	8d7abb6590	Revert "Fixed locking for index scans for HNSW - #256 " This reverts commit `d032726976`.	2023-09-26 23:00:14 -07:00
jeff-davis	b247b688a8	No need to MarkBufferDirty(); GenericXLogFinish() does that. (#265 )	2023-09-15 13:14:10 -07:00
Andrew Kane	9672446a4c	Updated order [skip ci]	2023-09-12 19:53:12 -07:00
Andrew Kane	334614b7f7	Added HnswFreeNeighbors function [skip ci]	2023-09-12 19:49:31 -07:00
Andrew Kane	643eacd9dc	Improved variable name [skip ci]	2023-09-12 19:37:42 -07:00
Andrew Kane	bca50a03fa	Use consistent variable name	2023-09-12 19:24:31 -07:00
Andrew Kane	d87833cacc	Improved variable scoping [skip ci]	2023-09-12 19:16:55 -07:00
Andrew Kane	4c01073ac1	Improved variable scoping [skip ci]	2023-09-12 18:43:43 -07:00
Andrew Kane	6fed8f1e78	Improved types and scoping for k-means [skip ci]	2023-09-12 18:37:56 -07:00
Andrew Kane	611f5b1047	Improved variable scoping [skip ci]	2023-09-12 18:35:53 -07:00
Andrew Kane	e367155732	Improved types and scoping for k-means	2023-09-12 18:33:31 -07:00
Andrew Kane	466c556b1a	Improved variable scoping [skip ci]	2023-09-12 18:24:46 -07:00
Andrew Kane	75e09265d6	Improved variable scoping [skip ci]	2023-09-12 18:14:20 -07:00
Andrew Kane	77c5070fb6	Improved variable scoping [skip ci]	2023-09-12 16:50:51 -07:00
Andrew Kane	1006fdf3f2	Improved variable scoping [skip ci]	2023-09-12 16:44:09 -07:00
Andrew Kane	4209c9b3af	Improved variable scoping	2023-09-12 16:13:10 -07:00
Andrew Kane	ec0bb4e4ff	Improved code	2023-09-12 15:43:28 -07:00
Andrew Kane	b164833933	Removed pinning for HNSW index scan	2023-09-11 12:12:28 -07:00
Andrew Kane	30fb4dd602	Updated comments [skip ci]	2023-09-07 15:29:54 -07:00
Andrew Kane	d032726976	Fixed locking for index scans for HNSW - #256	2023-09-07 15:27:26 -07:00
Andrew Kane	8fa9001474	Improved Makefiles	2023-09-05 16:43:23 -07:00
Andrew Kane	3431acef94	Improved variable names	2023-09-03 16:49:24 -07:00
Andrew Kane	41bdf24cb7	Fixed flaky test	2023-09-03 15:24:40 -07:00
Andrew Kane	3469a0e74c	Simplified test [skip ci]	2023-09-03 15:18:23 -07:00
Andrew Kane	0fe43ca675	Added test for marking tuples as dead	2023-09-03 15:15:02 -07:00
Andrew Kane	bbbe1db72b	Improved performance of index scans for IVFFlat after updates and deletes	2023-09-03 14:21:57 -07:00
Andrew Kane	bab5fea9e7	Improved variable name [skip ci]	2023-09-03 12:32:59 -07:00
Andrew Kane	b1f9519689	Get info from metapage to determine cost	2023-09-03 12:31:01 -07:00
Andrew Kane	4571fccc60	Fixed previous commit	2023-09-03 10:51:56 -07:00
Andrew Kane	db747e5aa0	Get lists from metapage	2023-09-03 10:34:44 -07:00
Andrew Kane	2179414c05	Updated extension comment [skip ci]	2023-09-03 03:08:35 -07:00
Andrew Kane	8426ee61d2	Improved upgrading instructions [skip ci]	2023-09-03 03:02:10 -07:00
Andrew Kane	c98c4e13aa	Added query for checking version to readme [skip ci]	2023-09-03 02:57:56 -07:00
Andrew Kane	04312f6638	Simplified HNSW vacuum logic	2023-09-03 02:25:19 -07:00
Andrew Kane	72ea3c1210	Added GetScanValue function	2023-09-03 01:59:27 -07:00
Andrew Kane	b0801b8833	Fixed vacuum from previous commit	2023-09-03 01:58:45 -07:00
Andrew Kane	d05d6ee83d	Get m from metapage	2023-09-03 01:35:21 -07:00
Andrew Kane	4022bb66a0	Improved variable scoping	2023-09-02 21:14:31 -07:00
Andrew Kane	034d4acaea	Removed comment [skip ci]	2023-09-02 18:23:08 -07:00
Andrew Kane	01f58e470a	Revert "Use int64 for wlen" This reverts commit `dbef8d1ad1`.	2023-09-02 18:09:10 -07:00
Andrew Kane	dbef8d1ad1	Use int64 for wlen	2023-09-02 17:55:48 -07:00
Andrew Kane	5c005cf57c	Revert "No need to increment wlen when removing" This reverts commit `6b2e215447`.	2023-09-02 17:41:31 -07:00
Andrew Kane	5665a11a05	Updated comment [skip ci]	2023-09-02 15:34:33 -07:00
Andrew Kane	6b2e215447	No need to increment wlen when removing	2023-09-02 15:33:40 -07:00
Andrew Kane	0d86191eaf	Improved test for cosine distance [skip ci]	2023-09-01 19:59:21 -07:00
Andrew Kane	cf9f7aeea9	Added another test for cosine distance [skip ci]	2023-09-01 19:57:28 -07:00
Andrew Kane	0b0e542ce6	Fixed auto-vectorization for vector_spherical_distance with MSVC	2023-09-01 18:42:37 -07:00
Andrew Kane	a4590d2d9d	Simplified WAL tests [skip ci]	2023-09-01 15:49:52 -07:00
Andrew Kane	9ebec1529b	Updated comments [skip ci]	2023-09-01 00:35:06 -07:00
Andrew Kane	77ff4c18f0	Updated comments [skip ci]	2023-09-01 00:32:42 -07:00
Andrew Kane	88dabaa41c	Added test for IVFFlat insert recall	2023-09-01 00:30:02 -07:00
Andrew Kane	1809ffa52b	Renamed test [skip ci]	2023-09-01 00:15:07 -07:00
Andrew Kane	024f283ee8	Updated header order [skip ci]	2023-09-01 00:14:03 -07:00