chore: import upstream snapshot with attribution

dotnet/test/VectorData/PgVector.UnitTests/PostgresSqlBuilderTests.cs

@@ -0,0 +1,669 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Extensions.VectorData;
+using Microsoft.Extensions.VectorData.ProviderServices;
+using Microsoft.SemanticKernel.Connectors.PgVector;
+using Npgsql;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace SemanticKernel.Connectors.PgVector.UnitTests;
+
+public class PostgresSqlBuilderTests
+{
+    private readonly ITestOutputHelper _output;
+    private static readonly float[] s_vector = new float[] { 1.0f, 2.0f, 3.0f };
+
+    public PostgresSqlBuilderTests(ITestOutputHelper output)
+    {
+        this._output = output;
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void TestBuildCreateTableCommand(bool ifNotExists)
+    {
+        var recordDefinition = new VectorStoreCollectionDefinition()
+        {
+            Properties = [
+                new VectorStoreKeyProperty("id", typeof(long)),
+                new VectorStoreDataProperty("name", typeof(string)),
+                new VectorStoreDataProperty("code", typeof(int)),
+                new VectorStoreDataProperty("rating", typeof(float?)),
+                new VectorStoreDataProperty("description", typeof(string)),
+                new VectorStoreDataProperty("parking_is_included", typeof(bool)) { StorageName = "free_parking" },
+                new VectorStoreDataProperty("tags", typeof(List<string>)),
+                new VectorStoreVectorProperty("embedding1", typeof(ReadOnlyMemory<float>), 10)
+                {
+                    Dimensions = 10,
+                    IndexKind = "hnsw",
+                },
+                new VectorStoreVectorProperty("embedding2", typeof(ReadOnlyMemory<float>?), 10)
+                {
+                    Dimensions = 10,
+                    IndexKind = "hnsw",
+                }
+            ]
+        };
+
+        var model = new PostgresModelBuilder().BuildDynamic(recordDefinition, defaultEmbeddingGenerator: null);
+
+        var sql = PostgresSqlBuilder.BuildCreateTableSql(schema: null, "testcollection", model, pgVersion: new Version(18, 0), ifNotExists: ifNotExists);
+
+        // Check for expected properties; integration tests will validate the actual SQL.
+        Assert.Contains("\"testcollection\" (", sql);
+        Assert.DoesNotContain("\"public\"", sql);
+        Assert.Contains("\"name\" TEXT", sql);
+        Assert.Contains("\"code\" INTEGER NOT NULL", sql);
+        Assert.Contains("\"rating\" REAL", sql);
+        Assert.Contains("\"description\" TEXT", sql);
+        Assert.Contains("\"free_parking\" BOOLEAN NOT NULL", sql);
+        Assert.Contains("\"tags\" TEXT[]", sql);
+        Assert.Contains("\"description\" TEXT", sql);
+        Assert.Contains("\"embedding1\" VECTOR(10) NOT NULL", sql);
+        Assert.Contains("\"embedding2\" VECTOR(10)", sql);
+        Assert.Contains("PRIMARY KEY (\"id\")", sql);
+
+        if (ifNotExists)
+        {
+            Assert.Contains("IF NOT EXISTS", sql);
+        }
+
+        // Output
+        this._output.WriteLine(sql);
+    }
+
+    [Fact]
+    public void TestBuildCreateTableCommand_WithTimestampStoreType()
+    {
+        var recordDefinition = new VectorStoreCollectionDefinition()
+        {
+            Properties = [
+                new VectorStoreKeyProperty("id", typeof(long)),
+                new VectorStoreDataProperty("created_utc", typeof(DateTime)),
+                new VectorStoreDataProperty("created_local", typeof(DateTime)).WithStoreType("timestamp"),
+                new VectorStoreDataProperty("created_nullable", typeof(DateTime?)).WithStoreType("timestamp without time zone"),
+                new VectorStoreVectorProperty("embedding", typeof(ReadOnlyMemory<float>), 10)
+            ]
+        };
+
+        var model = new PostgresModelBuilder().BuildDynamic(recordDefinition, defaultEmbeddingGenerator: null);
+
+        var sql = PostgresSqlBuilder.BuildCreateTableSql(schema: null, "testcollection", model, pgVersion: new Version(18, 0));
+
+        Assert.Contains("\"created_utc\" TIMESTAMPTZ NOT NULL", sql);
+        Assert.Contains("\"created_local\" TIMESTAMP NOT NULL", sql);
+        Assert.Contains("\"created_nullable\" TIMESTAMP", sql);
+        // Make sure it's TIMESTAMP (not TIMESTAMPTZ) for the nullable one
+        var idx = sql.IndexOf("\"created_nullable\"", StringComparison.Ordinal);
+        var fragment = sql.Substring(idx, sql.IndexOf('\n', idx) - idx);
+        Assert.DoesNotContain("TIMESTAMPTZ", fragment);
+
+        this._output.WriteLine(sql);
+    }
+
+    [Theory]
+    [InlineData(IndexKind.Hnsw, DistanceFunction.EuclideanDistance, true)]
+    [InlineData(IndexKind.Hnsw, DistanceFunction.EuclideanDistance, false)]
+    [InlineData(IndexKind.IvfFlat, DistanceFunction.DotProductSimilarity, true)]
+    [InlineData(IndexKind.IvfFlat, DistanceFunction.DotProductSimilarity, false)]
+    [InlineData(IndexKind.Hnsw, DistanceFunction.CosineDistance, true)]
+    [InlineData(IndexKind.Hnsw, DistanceFunction.CosineDistance, false)]
+    public void TestBuildCreateIndexCommand(string indexKind, string distanceFunction, bool ifNotExists)
+    {
+        var vectorColumn = "embedding1";
+
+        if (indexKind != IndexKind.Hnsw)
+        {
+            Assert.Throws<NotSupportedException>(() => PostgresSqlBuilder.BuildCreateIndexSql(schema: null, "testcollection", vectorColumn, indexKind, distanceFunction, isVector: true, isFullText: false, fullTextLanguage: null, ifNotExists));
+            Assert.Throws<NotSupportedException>(() => PostgresSqlBuilder.BuildCreateIndexSql(schema: null, "testcollection", vectorColumn, indexKind, distanceFunction, isVector: true, isFullText: false, fullTextLanguage: null, ifNotExists));
+            return;
+        }
+
+        var sql = PostgresSqlBuilder.BuildCreateIndexSql(schema: null, "1testcollection", vectorColumn, indexKind, distanceFunction, isVector: true, isFullText: false, fullTextLanguage: null, ifNotExists);
+
+        // Check for expected properties; integration tests will validate the actual SQL.
+        Assert.Contains("CREATE INDEX ", sql);
+        // Make sure ifNotExists is respected
+        if (ifNotExists)
+        {
+            Assert.Contains("CREATE INDEX IF NOT EXISTS", sql);
+        }
+        else
+        {
+            Assert.DoesNotContain("CREATE INDEX IF NOT EXISTS", sql);
+        }
+        // Make sure the name is escaped, so names starting with a digit are OK.
+        Assert.Contains($"\"1testcollection_{vectorColumn}_index\"", sql);
+
+        Assert.Contains("ON \"1testcollection\" USING hnsw (\"embedding1\" ", sql);
+        if (distanceFunction == null)
+        {
+            // Check for distance function defaults to cosine distance
+            Assert.Contains("vector_cosine_ops)", sql);
+        }
+        else if (distanceFunction == DistanceFunction.CosineDistance)
+        {
+            Assert.Contains("vector_cosine_ops)", sql);
+        }
+        else if (distanceFunction == DistanceFunction.EuclideanDistance)
+        {
+            Assert.Contains("vector_l2_ops)", sql);
+        }
+        else
+        {
+            throw new NotImplementedException($"Test case for Distance function {distanceFunction} is not implemented.");
+        }
+        // Output
+        this._output.WriteLine(sql);
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void TestBuildCreateNonVectorIndexCommand(bool ifNotExists)
+    {
+        var sql = PostgresSqlBuilder.BuildCreateIndexSql("schema", "tableName", "columnName", indexKind: "", distanceFunction: "", isVector: false, isFullText: false, fullTextLanguage: null, ifNotExists);
+
+        var expectedCommandText = ifNotExists
+            ? "CREATE INDEX IF NOT EXISTS \"tableName_columnName_index\" ON \"schema\".\"tableName\" (\"columnName\")"
+            : "CREATE INDEX \"tableName_columnName_index\" ON \"schema\".\"tableName\" (\"columnName\")";
+
+        Assert.Equal(expectedCommandText, sql);
+    }
+
+    [Theory]
+    [InlineData(null, "english")]  // Default language
+    [InlineData("spanish", "spanish")]
+    [InlineData("german", "german")]
+    public void TestBuildCreateFullTextIndexCommand(string? configuredLanguage, string expectedLanguage)
+    {
+        var sql = PostgresSqlBuilder.BuildCreateIndexSql("schema", "tableName", "content", indexKind: "", distanceFunction: "", isVector: false, isFullText: true, fullTextLanguage: configuredLanguage, ifNotExists: true);
+
+        var expectedCommandText = $"CREATE INDEX IF NOT EXISTS \"tableName_content_index\" ON \"schema\".\"tableName\" USING GIN (to_tsvector('{expectedLanguage}', \"content\"))";
+
+        Assert.Equal(expectedCommandText, sql);
+    }
+
+    [Fact]
+    public void TestBuildCreateFullTextIndexCommand_EscapesSingleQuotes()
+    {
+        // Verify that single quotes in the language name are properly escaped to prevent SQL injection
+        var sql = PostgresSqlBuilder.BuildCreateIndexSql("schema", "tableName", "content", indexKind: "", distanceFunction: "", isVector: false, isFullText: true, fullTextLanguage: "test'injection", ifNotExists: true);
+
+        var expectedCommandText = "CREATE INDEX IF NOT EXISTS \"tableName_content_index\" ON \"schema\".\"tableName\" USING GIN (to_tsvector('test''injection', \"content\"))";
+
+        Assert.Equal(expectedCommandText, sql);
+    }
+
+    [Fact]
+    public void TestBuildDropTableCommand()
+    {
+        using var command = new NpgsqlCommand();
+        PostgresSqlBuilder.BuildDropTableCommand(command, schema: null, "testcollection");
+
+        // Check for expected properties; integration tests will validate the actual SQL.
+        Assert.Contains("DROP TABLE IF EXISTS \"testcollection\"", command.CommandText);
+        Assert.DoesNotContain("\"public\"", command.CommandText);
+
+        // Output
+        this._output.WriteLine(command.CommandText);
+    }
+
+    [Fact]
+    public void TestBuildUpsertCommand()
+    {
+        var recordDefinition = new VectorStoreCollectionDefinition()
+        {
+            Properties = [
+                new VectorStoreKeyProperty("id", typeof(int)),
+                new VectorStoreDataProperty("name", typeof(string)),
+                new VectorStoreDataProperty("code", typeof(int)),
+                new VectorStoreDataProperty("rating", typeof(float?)),
+                new VectorStoreDataProperty("description", typeof(string)),
+                new VectorStoreDataProperty("parking_is_included", typeof(bool)) { StorageName = "free_parking" },
+                new VectorStoreDataProperty("tags", typeof(List<string>)),
+                new VectorStoreVectorProperty("embedding1", typeof(ReadOnlyMemory<float>), 10)
+                {
+                    Dimensions = 10,
+                    IndexKind = "hnsw",
+                },
+                new VectorStoreVectorProperty("embedding2", typeof(ReadOnlyMemory<float>?), 10)
+                {
+                    Dimensions = 10,
+                    IndexKind = "hnsw",
+                }
+            ]
+        };
+
+        var model = new PostgresModelBuilder().BuildDynamic(recordDefinition, defaultEmbeddingGenerator: null);
+
+        var record = new Dictionary<string, object?>
+        {
+            ["id"] = 123,
+            ["name"] = "Hotel",
+            ["code"] = 456,
+            ["rating"] = 4.5f,
+            ["description"] = "Hotel description",
+            ["parking_is_included"] = true,
+            ["tags"] = new List<string> { "tag1", "tag2" },
+            ["embedding1"] = new ReadOnlyMemory<float>(s_vector),
+        };
+
+        using var batch = new NpgsqlBatch();
+        _ = PostgresSqlBuilder.BuildUpsertCommand<int>(batch, schema: null, "testcollection", model, [record], generatedEmbeddings: null);
+
+        // Check for expected properties; integration tests will validate the actual SQL.
+        Assert.Single(batch.BatchCommands);
+        var command = batch.BatchCommands[0];
+        Assert.Contains("INSERT INTO \"testcollection\" (", command.CommandText);
+        Assert.Contains("ON CONFLICT (\"id\")", command.CommandText);
+        Assert.Contains("DO UPDATE SET", command.CommandText);
+        Assert.NotNull(command.Parameters);
+
+        foreach (var (column, index) in record.Keys.Select((key, index) => (key, index)))
+        {
+            var expectedValue = column is "embedding1"
+                ? PostgresPropertyMapping.MapVectorForStorageModel((ReadOnlyMemory<float>)record[column]!)
+                : record[column];
+            Assert.Equal(expectedValue, command.Parameters[index].Value);
+
+            // If the key is not the key column, it should be included in the update clause.
+            if (column is "id")
+            {
+                continue;
+            }
+
+            var storageName = column is "parking_is_included" ? "free_parking" : column;
+
+            Assert.Contains($"\"{storageName}\" = EXCLUDED.\"{storageName}\"", command.CommandText);
+        }
+
+        // Output
+        this._output.WriteLine(command.CommandText);
+    }
+
+    [Fact]
+    public void TestBuildGetCommand()
+    {
+        // Arrange
+        var recordDefinition = new VectorStoreCollectionDefinition()
+        {
+            Properties = [
+                new VectorStoreKeyProperty("id", typeof(long)),
+                new VectorStoreDataProperty("name", typeof(string)),
+                new VectorStoreDataProperty("code", typeof(int)),
+                new VectorStoreDataProperty("rating", typeof(float?)),
+                new VectorStoreDataProperty("description", typeof(string)),
+                new VectorStoreDataProperty("parking_is_included", typeof(bool)) { StorageName = "free_parking" },
+                new VectorStoreDataProperty("tags", typeof(List<string>)),
+                new VectorStoreVectorProperty("embedding1", typeof(ReadOnlyMemory<float>), 10)
+                {
+                    IndexKind = "hnsw",
+                },
+                new VectorStoreVectorProperty("embedding2", typeof(ReadOnlyMemory<float>?), 10)
+                {
+                    IndexKind = "hnsw",
+                }
+            ]
+        };
+
+        var model = new PostgresModelBuilder().BuildDynamic(recordDefinition, defaultEmbeddingGenerator: null);
+
+        var key = 123;
+
+        // Act
+        using var command = new NpgsqlCommand();
+        PostgresSqlBuilder.BuildGetCommand(command, schema: null, "testcollection", model, key, includeVectors: true);
+
+        // Assert
+        Assert.Contains("SELECT", command.CommandText);
+        Assert.Contains("\"free_parking\"", command.CommandText);
+        Assert.Contains("\"embedding1\"", command.CommandText);
+        Assert.Contains("FROM \"testcollection\"", command.CommandText);
+        Assert.Contains("WHERE \"id\" = $1", command.CommandText);
+
+        // Output
+        this._output.WriteLine(command.CommandText);
+    }
+
+    [Fact]
+    public void TestBuildGetBatchCommand()
+    {
+        // Arrange
+        var recordDefinition = new VectorStoreCollectionDefinition()
+        {
+            Properties = [
+                new VectorStoreKeyProperty("id", typeof(long)),
+                new VectorStoreDataProperty("name", typeof(string)),
+                new VectorStoreDataProperty("code", typeof(int)),
+                new VectorStoreDataProperty("rating", typeof(float?)),
+                new VectorStoreDataProperty("description", typeof(string)),
+                new VectorStoreDataProperty("parking_is_included", typeof(bool)) { StorageName = "free_parking" },
+                new VectorStoreDataProperty("tags", typeof(List<string>)),
+                new VectorStoreVectorProperty("embedding1", typeof(ReadOnlyMemory<float>), 10)
+                {
+                    IndexKind = "hnsw",
+                },
+                new VectorStoreVectorProperty("embedding2", typeof(ReadOnlyMemory<float>?), 10)
+                {
+                    IndexKind = "hnsw",
+                }
+            ]
+        };
+
+        var keys = new List<long> { 123, 124 };
+
+        var model = new PostgresModelBuilder().BuildDynamic(recordDefinition, defaultEmbeddingGenerator: null);
+
+        // Act
+        using var command = new NpgsqlCommand();
+        PostgresSqlBuilder.BuildGetBatchCommand(command, schema: null, "testcollection", model, keys, includeVectors: true);
+
+        // Assert
+        Assert.Contains("SELECT", command.CommandText);
+        Assert.Contains("\"code\"", command.CommandText);
+        Assert.Contains("\"free_parking\"", command.CommandText);
+        Assert.Contains("FROM \"testcollection\"", command.CommandText);
+        Assert.Contains("WHERE \"id\" = ANY($1)", command.CommandText);
+        Assert.NotNull(command.Parameters);
+        Assert.Single(command.Parameters);
+        Assert.Equal(keys, command.Parameters[0].Value);
+
+        // Output
+        this._output.WriteLine(command.CommandText);
+    }
+
+    [Fact]
+    public void TestBuildDeleteCommand()
+    {
+        // Arrange
+        var key = 123;
+
+        // Act
+        using var command = new NpgsqlCommand();
+        PostgresSqlBuilder.BuildDeleteCommand(command, schema: null, "testcollection", "id", key);
+
+        // Assert
+        Assert.Contains("DELETE", command.CommandText);
+        Assert.Contains("FROM \"testcollection\"", command.CommandText);
+        Assert.Contains("WHERE \"id\" = $1", command.CommandText);
+
+        // Output
+        this._output.WriteLine(command.CommandText);
+    }
+
+    [Fact]
+    public void TestBuildDeleteBatchCommand()
+    {
+        // Arrange
+        var keys = new List<long> { 123, 124 };
+
+        // Act
+        using var command = new NpgsqlCommand();
+        var keyProperty = new KeyPropertyModel("id", typeof(long));
+        PostgresSqlBuilder.BuildDeleteBatchCommand(command, schema: null, "testcollection", keyProperty, keys);
+
+        // Assert
+        Assert.Contains("DELETE", command.CommandText);
+        Assert.Contains("FROM \"testcollection\"", command.CommandText);
+        Assert.Contains("WHERE \"id\" = ANY($1)", command.CommandText);
+        Assert.NotNull(command.Parameters);
+        Assert.Single(command.Parameters);
+        Assert.Equal(keys, command.Parameters[0].Value);
+
+        // Output
+        this._output.WriteLine(command.CommandText);
+    }
+
+    #region Schema-specified tests
+
+    [Theory]
+    [InlineData(null, "public")]
+    [InlineData("myschema", "myschema")]
+    public void TestBuildDoesTableExistCommand(string? schema, string expectedSchema)
+    {
+        using var command = new NpgsqlCommand();
+        PostgresSqlBuilder.BuildDoesTableExistCommand(command, schema, "testcollection");
+
+        Assert.Contains("table_schema = $1", command.CommandText);
+        Assert.Contains("table_name = $2", command.CommandText);
+        Assert.Equal(2, command.Parameters.Count);
+        Assert.Equal(expectedSchema, command.Parameters[0].Value);
+        Assert.Equal("testcollection", command.Parameters[1].Value);
+
+        this._output.WriteLine(command.CommandText);
+    }
+
+    [Theory]
+    [InlineData(null, "public")]
+    [InlineData("myschema", "myschema")]
+    public void TestBuildGetTablesCommand(string? schema, string expectedSchema)
+    {
+        using var command = new NpgsqlCommand();
+        PostgresSqlBuilder.BuildGetTablesCommand(command, schema);
+
+        Assert.Contains("table_schema = $1", command.CommandText);
+        Assert.Single(command.Parameters);
+        Assert.Equal(expectedSchema, command.Parameters[0].Value);
+
+        this._output.WriteLine(command.CommandText);
+    }
+
+    [Fact]
+    public void TestBuildCreateTableCommand_WithSchema()
+    {
+        var recordDefinition = new VectorStoreCollectionDefinition()
+        {
+            Properties = [
+                new VectorStoreKeyProperty("id", typeof(long)),
+                new VectorStoreDataProperty("name", typeof(string)),
+                new VectorStoreVectorProperty("embedding1", typeof(ReadOnlyMemory<float>), 10) { IndexKind = "hnsw" }
+            ]
+        };
+
+        var model = new PostgresModelBuilder().BuildDynamic(recordDefinition, defaultEmbeddingGenerator: null);
+
+        var sql = PostgresSqlBuilder.BuildCreateTableSql(schema: "myschema", "testcollection", model, pgVersion: new Version(18, 0));
+
+        Assert.Contains("\"myschema\".\"testcollection\"", sql);
+
+        this._output.WriteLine(sql);
+    }
+
+    [Fact]
+    public void TestBuildCreateIndexCommand_WithSchema()
+    {
+        var sql = PostgresSqlBuilder.BuildCreateIndexSql("myschema", "testcollection", "embedding1", IndexKind.Hnsw, DistanceFunction.CosineDistance, isVector: true, isFullText: false, fullTextLanguage: null, ifNotExists: true);
+
+        Assert.Contains("ON \"myschema\".\"testcollection\"", sql);
+
+        this._output.WriteLine(sql);
+    }
+
+    [Fact]
+    public void TestBuildDropTableCommand_WithSchema()
+    {
+        using var command = new NpgsqlCommand();
+        PostgresSqlBuilder.BuildDropTableCommand(command, schema: "myschema", "testcollection");
+
+        Assert.Contains("DROP TABLE IF EXISTS \"myschema\".\"testcollection\"", command.CommandText);
+
+        this._output.WriteLine(command.CommandText);
+    }
+
+    [Fact]
+    public void TestBuildUpsertCommand_WithSchema()
+    {
+        var recordDefinition = new VectorStoreCollectionDefinition()
+        {
+            Properties = [
+                new VectorStoreKeyProperty("id", typeof(int)),
+                new VectorStoreDataProperty("name", typeof(string)),
+                new VectorStoreVectorProperty("embedding1", typeof(ReadOnlyMemory<float>), 10) { IndexKind = "hnsw" }
+            ]
+        };
+
+        var model = new PostgresModelBuilder().BuildDynamic(recordDefinition, defaultEmbeddingGenerator: null);
+
+        var record = new Dictionary<string, object?>
+        {
+            ["id"] = 1,
+            ["name"] = "Test",
+            ["embedding1"] = new ReadOnlyMemory<float>(s_vector),
+        };
+
+        using var batch = new NpgsqlBatch();
+        _ = PostgresSqlBuilder.BuildUpsertCommand<int>(batch, schema: "myschema", "testcollection", model, [record], generatedEmbeddings: null);
+
+        var command = batch.BatchCommands[0];
+        Assert.Contains("INSERT INTO \"myschema\".\"testcollection\"", command.CommandText);
+
+        this._output.WriteLine(command.CommandText);
+    }
+
+    [Fact]
+    public void TestBuildGetCommand_WithSchema()
+    {
+        var recordDefinition = new VectorStoreCollectionDefinition()
+        {
+            Properties = [
+                new VectorStoreKeyProperty("id", typeof(long)),
+                new VectorStoreDataProperty("name", typeof(string)),
+                new VectorStoreVectorProperty("embedding1", typeof(ReadOnlyMemory<float>), 10) { IndexKind = "hnsw" }
+            ]
+        };
+
+        var model = new PostgresModelBuilder().BuildDynamic(recordDefinition, defaultEmbeddingGenerator: null);
+
+        using var command = new NpgsqlCommand();
+        PostgresSqlBuilder.BuildGetCommand(command, schema: "myschema", "testcollection", model, 123, includeVectors: true);
+
+        Assert.Contains("FROM \"myschema\".\"testcollection\"", command.CommandText);
+
+        this._output.WriteLine(command.CommandText);
+    }
+
+    [Fact]
+    public void TestBuildGetBatchCommand_WithSchema()
+    {
+        var recordDefinition = new VectorStoreCollectionDefinition()
+        {
+            Properties = [
+                new VectorStoreKeyProperty("id", typeof(long)),
+                new VectorStoreDataProperty("name", typeof(string)),
+                new VectorStoreVectorProperty("embedding1", typeof(ReadOnlyMemory<float>), 10) { IndexKind = "hnsw" }
+            ]
+        };
+
+        var model = new PostgresModelBuilder().BuildDynamic(recordDefinition, defaultEmbeddingGenerator: null);
+
+        using var command = new NpgsqlCommand();
+        PostgresSqlBuilder.BuildGetBatchCommand(command, schema: "myschema", "testcollection", model, new List<long> { 1, 2 }, includeVectors: true);
+
+        Assert.Contains("FROM \"myschema\".\"testcollection\"", command.CommandText);
+
+        this._output.WriteLine(command.CommandText);
+    }
+
+    [Fact]
+    public void TestBuildDeleteCommand_WithSchema()
+    {
+        using var command = new NpgsqlCommand();
+        PostgresSqlBuilder.BuildDeleteCommand(command, schema: "myschema", "testcollection", "id", 123);
+
+        Assert.Contains("FROM \"myschema\".\"testcollection\"", command.CommandText);
+
+        this._output.WriteLine(command.CommandText);
+    }
+
+    [Fact]
+    public void TestBuildDeleteBatchCommand_WithSchema()
+    {
+        using var command = new NpgsqlCommand();
+        var keyProperty = new KeyPropertyModel("id", typeof(long));
+        PostgresSqlBuilder.BuildDeleteBatchCommand(command, schema: "myschema", "testcollection", keyProperty, new List<long> { 1, 2 });
+
+        Assert.Contains("FROM \"myschema\".\"testcollection\"", command.CommandText);
+
+        this._output.WriteLine(command.CommandText);
+    }
+
+    #endregion
+
+    #region NRT (Nullable Reference Type) detection
+
+#if NET // NRT detection via NullabilityInfoContext is only available on .NET 6+
+    [Fact]
+    public void TestBuildCreateTableCommand_WithNrtAnnotations()
+    {
+        var model = new PostgresModelBuilder().Build(
+            typeof(NrtTestRecord),
+            typeof(long),
+            definition: null,
+            defaultEmbeddingGenerator: null);
+
+        var sql = PostgresSqlBuilder.BuildCreateTableSql(schema: null, "testcollection", model, pgVersion: new Version(18, 0));
+
+        // Non-nullable reference types should be NOT NULL
+        Assert.Contains("\"NonNullableString\" TEXT NOT NULL", sql);
+        Assert.Contains("\"NonNullableByteArray\" BYTEA NOT NULL", sql);
+
+        // Nullable reference types should not have NOT NULL
+        Assert.Contains("\"NullableString\" TEXT", sql);
+        Assert.DoesNotContain("\"NullableString\" TEXT NOT NULL", sql);
+        Assert.Contains("\"NullableByteArray\" BYTEA", sql);
+        Assert.DoesNotContain("\"NullableByteArray\" BYTEA NOT NULL", sql);
+
+        // Non-nullable value types should be NOT NULL (unchanged from before)
+        Assert.Contains("\"NonNullableInt\" INTEGER NOT NULL", sql);
+        Assert.Contains("\"NonNullableBool\" BOOLEAN NOT NULL", sql);
+
+        // Nullable value types should not have NOT NULL (unchanged from before)
+        Assert.Contains("\"NullableInt\" INTEGER", sql);
+        Assert.DoesNotContain("\"NullableInt\" INTEGER NOT NULL", sql);
+
+        this._output.WriteLine(sql);
+    }
+
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor
+#pragma warning disable CA1812 // Class is used via reflection
+    private sealed class NrtTestRecord
+    {
+        [VectorStoreKey]
+        public long Id { get; set; }
+
+        [VectorStoreData]
+        public string NonNullableString { get; set; }
+
+        [VectorStoreData]
+        public string? NullableString { get; set; }
+
+        [VectorStoreData]
+        public byte[] NonNullableByteArray { get; set; }
+
+        [VectorStoreData]
+        public byte[]? NullableByteArray { get; set; }
+
+        [VectorStoreData]
+        public int NonNullableInt { get; set; }
+
+        [VectorStoreData]
+        public int? NullableInt { get; set; }
+
+        [VectorStoreData]
+        public bool NonNullableBool { get; set; }
+
+        [VectorStoreVector(10)]
+        public ReadOnlyMemory<float> Embedding { get; set; }
+    }
+#pragma warning restore CA1812
+#pragma warning restore CS8618
+#endif
+
+    #endregion
+}