fix: address review feedback

Author: rebasedming

NUGET-README.md

@@ -1,6 +1,6 @@
 # ParadeDB for Entity Framework Core
 
-The official [Entity Framework Core](https://learn.microsoft.com/en-us/ef/core/) integration for [ParadeDB](https://paradedb.com), including first-class support for managing BM25 indexes and running queries using the full ParadeDB API. Follow the [getting started guide](https://docs.paradedb.com/documentation/getting-started/environment#entity-framework-core) to begin.
+The official [Entity Framework Core](https://learn.microsoft.com/en-us/ef/core/) integration for [ParadeDB](https://paradedb.com), including first-class support for managing BM25 indexes and running queries using the full ParadeDB API. The integration covers both full-text and vector search — vector search indexes pgvector `vector` columns directly, with no separate pgvector ORM plugin required. Follow the [getting started guide](https://docs.paradedb.com/documentation/getting-started/environment#entity-framework-core) to begin.
 
 ## Requirements & Compatibility
 
@@ -10,6 +10,7 @@ The official [Entity Framework Core](https://learn.microsoft.com/en-us/ef/core/)
 | EF Core    | 8.0+                          |
 | ParadeDB   | 0.23.0+                       |
 | PostgreSQL | 15+ (with ParadeDB extension) |
+| pgvector   | Required for vector search    |
 
 ## Examples
 

README.md

@@ -36,7 +36,7 @@
 
 ## ParadeDB for Entity Framework Core
 
-The official [Entity Framework Core](https://learn.microsoft.com/en-us/ef/core/) integration for [ParadeDB](https://paradedb.com) (powered by the [`pg_search`](https://github.com/paradedb/paradedb) Postgres extension), including first-class support for managing BM25 indexes and running queries using the full ParadeDB API. Follow the [getting started guide](https://docs.paradedb.com/documentation/getting-started/environment#entity-framework-core) to begin.
+The official [Entity Framework Core](https://learn.microsoft.com/en-us/ef/core/) integration for [ParadeDB](https://paradedb.com) (powered by the [`pg_search`](https://github.com/paradedb/paradedb) Postgres extension), including first-class support for managing BM25 indexes and running queries using the full ParadeDB API. The integration covers both full-text and vector search — vector search indexes pgvector `vector` columns directly, with no separate pgvector ORM plugin required. Follow the [getting started guide](https://docs.paradedb.com/documentation/getting-started/environment#entity-framework-core) to begin.
 
 ## Requirements & Compatibility
 
@@ -46,49 +46,7 @@ The official [Entity Framework Core](https://learn.microsoft.com/en-us/ef/core/)
 | EF Core    | 8.0+                          |
 | ParadeDB   | 0.23.0+                       |
 | PostgreSQL | 15+ (with ParadeDB extension) |
-
-## Vector Search
-
-ParadeDB indexes pgvector `vector` columns directly inside its BM25 index — no
-pgvector ORM plugin is required. Map a `float[]` property to a `vector(n)`
-column, pick a distance metric for the index, and order by the matching
-distance function:
-
-```csharp
-public class Item
-{
-    public int Id { get; set; }
-    public float[]? Embedding { get; set; }
-}
-
-// Model configuration
-modelBuilder.Entity<Item>(entity =>
-{
-    entity.Property(x => x.Embedding).HasVectorType(384);
-
-    entity
-        .HasParadeDbIndex("items_idx", x => x.Id)  // also available as HasBm25Index
-        .HasField(x => x.Embedding, VectorMetric.Cosine);
-});
-
-// Top-K query: a `@@@` predicate (`EF.Functions.All` for match-all here) and
-// a LIMIT (`Take`) are required for the index to serve the query
-float[] queryEmbedding = GetQueryEmbedding();
-
-var results = await db
-    .Items.Where(x => EF.Functions.All(x.Id))
-    .OrderBy(x => EF.Functions.CosineDistance(x.Embedding, queryEmbedding))
-    .Take(10)
-    .ToListAsync();
-```
-
-`VectorMetric.L2` (`<->`, the default), `VectorMetric.Cosine` (`<=>`), and
-`VectorMetric.InnerProduct` (`<#>`) map to the `vector_l2_ops`,
-`vector_cosine_ops`, and `vector_ip_ops` operator classes. The distance
-function used in `OrderBy` must match the metric of the index opclass —
-`L2Distance` with `L2`, `CosineDistance` with `Cosine`, and `InnerProduct`
-with `InnerProduct` — otherwise the query still returns correct results but
-falls back to a sequential scan instead of Top-K index pushdown.
+| pgvector   | Required for vector search    |
 
 ## Examples
 

examples/README.md

@@ -49,8 +49,8 @@ dotnet run --project examples/Examples.csproj -p:Example=HybridRrf
 
 ## Vector Search (`examples/VectorSearch`)
 
-Runs Top-K nearest-neighbor queries over a pgvector column with the native
-vector support, backed by a bm25 index when the server supports it.
+Runs Top-K nearest-neighbor queries over a pgvector column with ParadeDB
+vector support, backed by a paradedb index when the server supports it.
 
 ```bash
 dotnet run --project examples/Examples.csproj -p:Example=VectorSearch

examples/Shared/ExampleSetup.cs

@@ -61,6 +61,9 @@ await db.Database.ExecuteSqlRawAsync(
             "CALL paradedb.create_bm25_test_table(schema_name => 'public', table_name => 'mock_items')"
         );
         await db.Database.ExecuteSqlRawAsync("DROP INDEX IF EXISTS mock_items_bm25_idx");
+        // The VectorSearch example may have left its own index behind, and newer
+        // pg_search versions allow only one ParadeDB index per table
+        await db.Database.ExecuteSqlRawAsync("DROP INDEX IF EXISTS mock_items_vector_idx");
         var accessMethod = await GetIndexAccessMethodAsync(db);
         await db.Database.ExecuteSqlRawAsync(
             """
@@ -119,14 +122,18 @@ public static async Task SetupHybridAsync(DbContext db)
     {
         await SetupMockItemsAsync(db);
         await db.Database.ExecuteSqlRawAsync("CREATE EXTENSION IF NOT EXISTS vector");
+        // Newer pg_search versions create mock_items with an embedding column of a
+        // different dimension; the examples use 384-dimensional embeddings
         await db.Database.ExecuteSqlRawAsync(
             """
             DO $$
             BEGIN
-                IF NOT EXISTS (
-                    SELECT 1 FROM information_schema.columns
-                    WHERE table_name = 'mock_items' AND column_name = 'embedding'
-                ) THEN
+                IF (
+                    SELECT atttypmod FROM pg_attribute
+                    WHERE attrelid = 'mock_items'::regclass
+                      AND attname = 'embedding' AND NOT attisdropped
+                ) IS DISTINCT FROM 384 THEN
+                    ALTER TABLE mock_items DROP COLUMN IF EXISTS embedding;
                     ALTER TABLE mock_items ADD COLUMN embedding vector(384);
                 END IF;
             END $$;

examples/VectorSearch/Program.cs

@@ -19,38 +19,42 @@
 await ExampleSetup.SetupHybridAsync(dbContext);
 await EmbeddingLoader.LoadAsync(dbContext);
 
-var supportsVectorIndex = await SupportsVectorInBm25Async(dbContext);
-if (supportsVectorIndex)
+var vectorAccessMethod = await GetVectorAccessMethodAsync(dbContext);
+if (vectorAccessMethod is not null)
 {
+    // Newer pg_search versions allow only one ParadeDB index per table
+    await dbContext.Database.ExecuteSqlRawAsync("DROP INDEX IF EXISTS mock_items_bm25_idx");
     await dbContext.Database.ExecuteSqlRawAsync("DROP INDEX IF EXISTS mock_items_vector_idx");
     await dbContext.Database.ExecuteSqlRawAsync(
         """
         CREATE INDEX mock_items_vector_idx ON mock_items
-        USING bm25 (id, embedding vector_cosine_ops)
+        USING paradedb (id, embedding vector_cosine_ops)
         WITH (key_field='id');
-        """
+        """.Replace("USING paradedb", $"USING {vectorAccessMethod}")
+    );
+    Console.WriteLine(
+        $"Created a {vectorAccessMethod} index over the embedding column (cosine metric)"
     );
-    Console.WriteLine("Created a bm25 index over the embedding column (cosine metric)");
 }
 else
 {
     Console.WriteLine(
-        "This ParadeDB version does not support vector columns in bm25 indexes; "
-            + "queries fall back to a sequential scan."
+        "This ParadeDB version does not support vector columns in ParadeDB indexes "
+            + "(requires pg_search 0.25.0+, unreleased); queries fall back to a sequential scan."
     );
 }
 
-await Demo(dbContext, "running shoes", supportsVectorIndex);
-await Demo(dbContext, "wireless earbuds", supportsVectorIndex);
+await Demo(dbContext, "running shoes", vectorAccessMethod is not null);
+await Demo(dbContext, "wireless earbuds", vectorAccessMethod is not null);
 return;
 
 static async Task Demo(AppDbContext db, string query, bool useIndex)
 {
     var queryEmbedding = QueryEmbeddings.Values[query];
 
     // The @@@ predicate (EF.Functions.All) and the LIMIT are required for the
-    // bm25 index to serve the query; the ORDER BY metric must match the index
-    // opclass (cosine here)
+    // ParadeDB index to serve the query; the ORDER BY metric must match the
+    // index opclass (cosine here)
     var candidates = useIndex
         ? db.MockItems.Where(x => EF.Functions.All(x.Id))
         : db.MockItems.Where(x => x.Embedding != null);
@@ -76,18 +80,22 @@ static async Task Demo(AppDbContext db, string query, bool useIndex)
     }
 }
 
-static async Task<bool> SupportsVectorInBm25Async(AppDbContext db)
+// The vector operator classes may be declared for the `paradedb` access method, the `bm25`
+// access method, or neither, depending on the pg_search version
+static async Task<string?> GetVectorAccessMethodAsync(AppDbContext db)
 {
-    var count = await db
-        .Database.SqlQueryRaw<long>(
+    var accessMethods = await db
+        .Database.SqlQueryRaw<string>(
             """
-            SELECT count(*) AS "Value"
+            SELECT a.amname AS "Value"
             FROM pg_opclass o
             JOIN pg_am a ON a.oid = o.opcmethod
-            WHERE a.amname = 'bm25' AND o.opcname = 'vector_cosine_ops'
+            WHERE a.amname IN ('paradedb', 'bm25') AND o.opcname = 'vector_cosine_ops'
             """
         )
-        .SingleAsync();
+        .ToListAsync();
 
-    return count > 0;
+    return accessMethods.Contains("paradedb") ? "paradedb"
+        : accessMethods.Contains("bm25") ? "bm25"
+        : null;
 }

src/Internal/ParadeDbOptionsExtension.cs

@@ -13,7 +13,6 @@
 using Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure;
 #endif
 
-
 namespace ParadeDB.EntityFrameworkCore.Internal;
 
 internal sealed class ParadeDbOptionsExtension : IDbContextOptionsExtension

tests/IndexingTest.cs

@@ -537,17 +537,18 @@ public async Task ParadeDbIndex_WithVectorFields()
 
         sql.ShouldBe(
             """
-            CREATE INDEX indexing_items_idx ON indexing_items USING bm25 (id, description, embedding_l2 vector_l2_ops, embedding_cosine vector_cosine_ops, (embedding_ip) vector_ip_ops) WITH (key_field = 'id');
+            CREATE INDEX indexing_items_idx ON indexing_items USING paradedb (id, description, embedding_l2 vector_l2_ops, embedding_cosine vector_cosine_ops, (embedding_ip) vector_ip_ops) WITH (key_field = 'id');
 
             """
         );
 
         await using var context = DbFixture.CreateContext();
         await context.Database.OpenConnectionAsync();
 
+        var vectorAccessMethod = await GetVectorAccessMethodAsync(context);
         Skip.When(
-            !await SupportsVectorInBm25Async(context),
-            "This ParadeDB version does not support vector columns in bm25 indexes"
+            vectorAccessMethod is null,
+            "This ParadeDB version does not support vector columns in ParadeDB indexes (requires pg_search 0.25.0+, unreleased)"
         );
 
         await context.Database.ExecuteSqlRawAsync(
@@ -561,23 +562,31 @@ embedding_ip vector(3)
             );
             """
         );
-        await context.Database.ExecuteSqlRawAsync(sql);
+        await context.Database.ExecuteSqlRawAsync(
+            sql.Replace(" USING paradedb ", $" USING {vectorAccessMethod} ")
+        );
     }
 
-    private static async Task<bool> SupportsVectorInBm25Async(Persistence.TestDbContext context)
+    // The vector operator classes may be declared for the `paradedb` access method, the `bm25`
+    // access method, or neither, depending on the pg_search version
+    internal static async Task<string?> GetVectorAccessMethodAsync(
+        Persistence.TestDbContext context
+    )
     {
-        var count = await context
-            .Database.SqlQueryRaw<long>(
+        var accessMethods = await context
+            .Database.SqlQueryRaw<string>(
                 """
-                SELECT count(*) AS "Value"
+                SELECT a.amname AS "Value"
                 FROM pg_opclass o
                 JOIN pg_am a ON a.oid = o.opcmethod
-                WHERE a.amname = 'bm25' AND o.opcname = 'vector_l2_ops'
+                WHERE a.amname IN ('paradedb', 'bm25') AND o.opcname = 'vector_l2_ops'
                 """
             )
-            .SingleAsync();
+            .ToListAsync();
 
-        return count > 0;
+        return accessMethods.Contains("paradedb") ? "paradedb"
+            : accessMethods.Contains("bm25") ? "bm25"
+            : null;
     }
 
     private Task ExecuteCreateIndexSqlAsync(Persistence.TestDbContext context, string sql) =>

tests/VectorSearchTests.cs

@@ -161,21 +161,22 @@ LIMIT @p
     }
 
     [Test]
-    public async Task VectorSearch_WithBm25Index()
+    public async Task VectorSearch_WithParadeDbIndex()
     {
         await using var context = await CreateContextWithVectorItemsAsync(DbFixture);
 
+        var vectorAccessMethod = await IndexingTest.GetVectorAccessMethodAsync(context);
         Skip.When(
-            !await SupportsVectorInBm25Async(context),
-            "This ParadeDB version does not support vector columns in bm25 indexes"
+            vectorAccessMethod is null,
+            "This ParadeDB version does not support vector columns in ParadeDB indexes (requires pg_search 0.25.0+, unreleased)"
         );
 
         await context.Database.ExecuteSqlRawAsync(
             """
             CREATE INDEX vector_items_idx ON vector_items
-            USING bm25 (id, embedding vector_l2_ops)
+            USING paradedb (id, embedding vector_l2_ops)
             WITH (key_field = 'id');
-            """
+            """.Replace("USING paradedb", $"USING {vectorAccessMethod}")
         );
 
         float[] queryVector = [1, 0, 0];
@@ -189,20 +190,4 @@ USING bm25 (id, embedding vector_l2_ops)
 
         results.ShouldBe([1, 2]);
     }
-
-    private static async Task<bool> SupportsVectorInBm25Async(TestDbContext context)
-    {
-        var count = await context
-            .Database.SqlQueryRaw<long>(
-                """
-                SELECT count(*) AS "Value"
-                FROM pg_opclass o
-                JOIN pg_am a ON a.oid = o.opcmethod
-                WHERE a.amname = 'bm25' AND o.opcname = 'vector_l2_ops'
-                """
-            )
-            .SingleAsync();
-
-        return count > 0;
-    }
 }