From 0df7af18839f87d9b2c4e2f2405ea97b4d3f38b2 Mon Sep 17 00:00:00 2001 From: Andy Stark Date: Fri, 12 Sep 2025 16:12:32 +0100 Subject: [PATCH] DOC-5072 C# and Jedis vector set examples --- local_examples/tmp/VectorSetExample.java | 258 +++++++++++++++++++ local_examples/tmp/VectorSetTutorial.cs | 303 +++++++++++++++++++++++ 2 files changed, 561 insertions(+) create mode 100644 local_examples/tmp/VectorSetExample.java create mode 100644 local_examples/tmp/VectorSetTutorial.cs diff --git a/local_examples/tmp/VectorSetExample.java b/local_examples/tmp/VectorSetExample.java new file mode 100644 index 000000000..af21c465e --- /dev/null +++ b/local_examples/tmp/VectorSetExample.java @@ -0,0 +1,258 @@ +// EXAMPLE: vecset_tutorial +// REMOVE_START +package io.redis.examples; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; +// REMOVE_END +import redis.clients.jedis.UnifiedJedis; +import redis.clients.jedis.params.VAddParams; +import redis.clients.jedis.params.VSimParams; + +import java.util.*; + +public class VectorSetExample { + + @Test + public void run() { + try (UnifiedJedis jedis = new UnifiedJedis("redis://localhost:6379")) { + // REMOVE_START + jedis.del("points", "quantSetQ8", "quantSetNoQ", "quantSetBin", "setNotReduced", + "setReduced"); + // REMOVE_END + + // STEP_START vadd + boolean res1 = jedis.vadd("points", new float[] { 1.0f, 1.0f }, "pt:A"); + System.out.println(res1); // >>> true + + boolean res2 = jedis.vadd("points", new float[] { -1.0f, -1.0f }, "pt:B"); + System.out.println(res2); // >>> true + + boolean res3 = jedis.vadd("points", new float[] { -1.0f, 1.0f }, "pt:C"); + System.out.println(res3); // >>> true + + boolean res4 = jedis.vadd("points", new float[] { 1.0f, -1.0f }, "pt:D"); + System.out.println(res4); // >>> true + + boolean res5 = jedis.vadd("points", new float[] { 1.0f, 0.0f }, "pt:E"); + System.out.println(res5); // >>> true + + String res6 = jedis.type("points"); + System.out.println(res6); // >>> vectorset + // STEP_END + // REMOVE_START + assertTrue(res1); + assertTrue(res2); + assertTrue(res3); + assertTrue(res4); + assertTrue(res5); + assertEquals("vectorset", res6); + // REMOVE_END + + // STEP_START vcardvdim + long res7 = jedis.vcard("points"); + System.out.println(res7); // >>> 5 + + long res8 = jedis.vdim("points"); + System.out.println(res8); // >>> 2 + // STEP_END + // REMOVE_START + assertEquals(5L, res7); + assertEquals(2L, res8); + // REMOVE_END + + // STEP_START vemb + List res9 = jedis.vemb("points", "pt:A"); + System.out.println(res9); // >>> [0.9999999..., 0.9999999...] + + List res10 = jedis.vemb("points", "pt:B"); + System.out.println(res10); // >>> [-0.9999999..., -0.9999999...] + + List res11 = jedis.vemb("points", "pt:C"); + System.out.println(res11); // >>> [-0.9999999..., 0.9999999...] + + List res12 = jedis.vemb("points", "pt:D"); + System.out.println(res12); // >>> [0.9999999..., -0.9999999...] + + List res13 = jedis.vemb("points", "pt:E"); + System.out.println(res13); // >>> [1, 0] + // STEP_END + // REMOVE_START + assertTrue(Math.abs(1 - res9.get(0)) < 0.01); + assertTrue(Math.abs(1 - res9.get(1)) < 0.01); + assertTrue(Math.abs(-1 - res10.get(0)) < 0.01); + assertTrue(Math.abs(-1 - res10.get(1)) < 0.01); + assertTrue(Math.abs(-1 - res11.get(0)) < 0.01); + assertTrue(Math.abs(1 - res11.get(1)) < 0.01); + assertTrue(Math.abs(1 - res12.get(0)) < 0.01); + assertTrue(Math.abs(-1 - res12.get(1)) < 0.01); + assertEquals(Arrays.asList(1.0, 0.0), res13); + // REMOVE_END + + // STEP_START attr + boolean res14 = jedis.vsetattr("points", "pt:A", + "{\"name\":\"Point A\",\"description\":\"First point added\"}"); + System.out.println(res14); // >>> true + + String res15 = jedis.vgetattr("points", "pt:A"); + System.out.println(res15); + // >>> {"name":"Point A","description":"First point added"} + + boolean res16 = jedis.vsetattr("points", "pt:A", ""); + System.out.println(res16); // >>> true + + String res17 = jedis.vgetattr("points", "pt:A"); + System.out.println(res17); // >>> null + // STEP_END + // REMOVE_START + assertTrue(res14); + assertTrue(res15.contains("\"name\":\"Point A\"")); + assertTrue(res15.contains("\"description\":\"First point added\"")); + assertTrue(res16); + assertNull(res17); + // REMOVE_END + + // STEP_START vrem + boolean res18 = jedis.vadd("points", new float[] { 0.0f, 0.0f }, "pt:F"); + System.out.println(res18); // >>> true + + long res19 = jedis.vcard("points"); + System.out.println(res19); // >>> 6 + + boolean res20 = jedis.vrem("points", "pt:F"); + System.out.println(res20); // >>> true + + long res21 = jedis.vcard("points"); + System.out.println(res21); // >>> 5 + // STEP_END + // REMOVE_START + assertTrue(res18); + assertEquals(6L, res19); + assertTrue(res20); + assertEquals(5L, res21); + // REMOVE_END + + // STEP_START vsim_basic + List res22 = jedis.vsim("points", new float[] { 0.9f, 0.1f }); + System.out.println(res22); + // >>> ["pt:E", "pt:A", "pt:D", "pt:C", "pt:B"] + // STEP_END + // REMOVE_START + assertEquals(Arrays.asList("pt:E", "pt:A", "pt:D", "pt:C", "pt:B"), res22); + // REMOVE_END + + // STEP_START vsim_options + Map res23 = jedis.vsimByElementWithScores("points", "pt:A", + new VSimParams().count(4)); + System.out.println(res23); + // >>> {pt:A=1.0, pt:E≈0.85355, pt:D=0.5, pt:C=0.5} + // STEP_END + // REMOVE_START + assertEquals(1.0, res23.get("pt:A"), 0.0001); + assertEquals(0.5, res23.get("pt:C"), 0.0001); + assertEquals(0.5, res23.get("pt:D"), 0.0001); + assertTrue(Math.abs(res23.get("pt:E") - 0.8535) < 0.01); + // REMOVE_END + + // STEP_START vsim_filter + boolean res24 = jedis.vsetattr("points", "pt:A", "{\"size\":\"large\",\"price\":18.99}"); + System.out.println(res24); // >>> true + + boolean res25 = jedis.vsetattr("points", "pt:B", "{\"size\":\"large\",\"price\":35.99}"); + System.out.println(res25); // >>> true + + boolean res26 = jedis.vsetattr("points", "pt:C", "{\"size\":\"large\",\"price\":25.99}"); + System.out.println(res26); // >>> true + + boolean res27 = jedis.vsetattr("points", "pt:D", "{\"size\":\"small\",\"price\":21.00}"); + System.out.println(res27); // >>> true + + boolean res28 = jedis.vsetattr("points", "pt:E", "{\"size\":\"small\",\"price\":17.75}"); + System.out.println(res28); // >>> true + + List res29 = jedis.vsimByElement("points", "pt:A", + new VSimParams().filter(".size == \"large\"")); + System.out.println(res29); // >>> ["pt:A", "pt:C", "pt:B"] + + List res30 = jedis.vsimByElement("points", "pt:A", + new VSimParams().filter(".size == \"large\" && .price > 20.00")); + System.out.println(res30); // >>> ["pt:C", "pt:B"] + // STEP_END + // REMOVE_START + assertTrue(res24); + assertTrue(res25); + assertTrue(res26); + assertTrue(res27); + assertTrue(res28); + assertEquals(Arrays.asList("pt:C", "pt:B"), res30); + // REMOVE_END + + // STEP_START add_quant + boolean res31 = jedis.vadd("quantSetQ8", new float[] { 1.262185f, 1.958231f }, "quantElement", + new VAddParams().q8()); + System.out.println(res31); // >>> true + + List res32 = jedis.vemb("quantSetQ8", "quantElement"); + System.out.println("Q8: " + res32); + // >>> Q8: [~1.264, ~1.958] + + boolean res33 = jedis.vadd("quantSetNoQ", new float[] { 1.262185f, 1.958231f }, + "quantElement", new VAddParams().noQuant()); + System.out.println(res33); // >>> true + + List res34 = jedis.vemb("quantSetNoQ", "quantElement"); + System.out.println("NOQUANT: " + res34); + // >>> NOQUANT: [~1.262185, ~1.958231] + + boolean res35 = jedis.vadd("quantSetBin", new float[] { 1.262185f, 1.958231f }, + "quantElement", new VAddParams().bin()); + System.out.println(res35); // >>> true + + List res36 = jedis.vemb("quantSetBin", "quantElement"); + System.out.println("BIN: " + res36); + // >>> BIN: [1, 1] + // STEP_END + // REMOVE_START + assertTrue(res31); + assertTrue(res33); + assertTrue(res35); + assertEquals(2, res32.size()); + assertEquals(2, res34.size()); + assertEquals(2, res36.size()); + assertTrue(Math.abs(res32.get(0) - 1.26) < 0.05); + assertTrue(Math.abs(res32.get(1) - 1.958) < 0.01); + assertTrue(Math.abs(res34.get(0) - 1.2622) < 0.01); + assertTrue(Math.abs(res34.get(1) - 1.9582) < 0.01); + assertEquals(Arrays.asList(1.0, 1.0), res36); + // REMOVE_END + + // STEP_START add_reduce + float[] values = new float[300]; + for (int i = 0; i < 300; i++) + values[i] = i / 299.0f; + + boolean res37 = jedis.vadd("setNotReduced", values, "element"); + System.out.println(res37); // >>> true + + long res38 = jedis.vdim("setNotReduced"); + System.out.println(res38); // >>> 300 + + boolean res39 = jedis.vadd("setReduced", values, "element", 100, new VAddParams()); + System.out.println(res39); // >>> true + + long res40 = jedis.vdim("setReduced"); + System.out.println(res40); // >>> 100 + // STEP_END + // REMOVE_START + assertTrue(res37); + assertEquals(300L, res38); + assertTrue(res39); + assertEquals(100L, res40); + // REMOVE_END + + // HIDE_START + jedis.close(); + } + } +} +// HIDE_END diff --git a/local_examples/tmp/VectorSetTutorial.cs b/local_examples/tmp/VectorSetTutorial.cs new file mode 100644 index 000000000..d2fe608da --- /dev/null +++ b/local_examples/tmp/VectorSetTutorial.cs @@ -0,0 +1,303 @@ +// EXAMPLE: vecset_tutorial +using StackExchange.Redis; +// REMOVE_START +using NRedisStack.Tests; + +#pragma warning disable SER001 // Experimental StackExchange.Redis API usage is expected in doc samples + +namespace Doc; +[Collection("DocsTests")] +// REMOVE_END + +public class VectorSetTutorial +// REMOVE_START +: AbstractNRedisStackTest, IDisposable +// REMOVE_END +{ + // REMOVE_START + public VectorSetTutorial(EndpointsFixture fixture) : base(fixture) { } + + [SkippableFact] + // REMOVE_END + public void Run() + { + //REMOVE_START + // This is needed because we're constructing ConfigurationOptions in the test before calling GetConnection + SkipIfTargetConnectionDoesNotExist(EndpointsFixture.Env.Standalone); + var _ = GetCleanDatabase(EndpointsFixture.Env.Standalone); + //REMOVE_END + ConnectionMultiplexer muxer = ConnectionMultiplexer.Connect("localhost:6379"); + IDatabase db = muxer.GetDatabase(); + // REMOVE_START + db.KeyDelete(new RedisKey[] { "points", "quantSetQ8", "quantSetNoQ", "quantSetBin", "setNotReduced", "setReduced" }); + // REMOVE_END + + // STEP_START vadd + bool r1 = db.VectorSetAdd("points", VectorSetAddRequest.Member("pt:A", new float[] { 1f, 1f }, null)); + Console.WriteLine(r1); // >>> True + + bool r2 = db.VectorSetAdd("points", VectorSetAddRequest.Member("pt:B", new float[] { -1f, -1f }, null)); + Console.WriteLine(r2); // >>> True + + bool r3 = db.VectorSetAdd("points", VectorSetAddRequest.Member("pt:C", new float[] { -1f, 1f }, null)); + Console.WriteLine(r3); // >>> True + + bool r4 = db.VectorSetAdd("points", VectorSetAddRequest.Member("pt:D", new float[] { 1f, -1f }, null)); + Console.WriteLine(r4); // >>> True + + bool r5 = db.VectorSetAdd("points", VectorSetAddRequest.Member("pt:E", new float[] { 1f, 0f }, null)); + Console.WriteLine(r5); // >>> True + // STEP_END + // REMOVE_START + Assert.True(r1 && r2 && r3 && r4 && r5); + // REMOVE_END + + // STEP_START vcardvdim + long card = db.VectorSetLength("points"); + Console.WriteLine(card); // >>> 5 + + int dim = db.VectorSetDimension("points"); + Console.WriteLine(dim); // >>> 2 + // STEP_END + // REMOVE_START + Assert.Equal(5, card); + Assert.Equal(2, dim); + // REMOVE_END + + // STEP_START vemb + using (Lease? eA = db.VectorSetGetApproximateVector("points", "pt:A")) + { + Span a = eA!.Span; + Console.WriteLine($"[{a[0]}, {a[1]}]"); // >>> [0.9999999403953552, 0.9999999403953552] + // REMOVE_START + Assert.True(Math.Abs(1 - a[0]) < 0.001); + Assert.True(Math.Abs(1 - a[1]) < 0.001); + // REMOVE_END + } + using (Lease? eB = db.VectorSetGetApproximateVector("points", "pt:B")) + { + Span b = eB!.Span; + Console.WriteLine($"[{b[0]}, {b[1]}]"); // >>> [-0.9999999403953552, -0.9999999403953552] + // REMOVE_START + Assert.True(Math.Abs(1 + b[0]) < 0.001); + Assert.True(Math.Abs(1 + b[1]) < 0.001); + // REMOVE_END + } + using (Lease? eC = db.VectorSetGetApproximateVector("points", "pt:C")) + { + Span c = eC!.Span; + Console.WriteLine($"[{c[0]}, {c[1]}]"); // >>> [-0.9999999403953552, 0.9999999403953552] + // REMOVE_START + Assert.True(Math.Abs(1 + c[0]) < 0.001); + Assert.True(Math.Abs(1 - c[1]) < 0.001); + // REMOVE_END + } + using (Lease? eD = db.VectorSetGetApproximateVector("points", "pt:D")) + { + Span d = eD!.Span; + Console.WriteLine($"[{d[0]}, {d[1]}]"); // >>> [0.9999999403953552, -0.9999999403953552] + // REMOVE_START + Assert.True(Math.Abs(1 - d[0]) < 0.001); + Assert.True(Math.Abs(1 + d[1]) < 0.001); + // REMOVE_END + } + using (Lease? eE = db.VectorSetGetApproximateVector("points", "pt:E")) + { + Span e = eE!.Span; + Console.WriteLine($"[{e[0]}, {e[1]}]"); // >>> [1, 0] + // REMOVE_START + Assert.True(Math.Abs(1 - e[0]) < 0.001 && Math.Abs(0 - e[1]) < 0.001); + // REMOVE_END + } + // STEP_END + + // STEP_START attr + string attrJson = "{\"name\":\"Point A\",\"description\":\"First point added\"}"; + bool setAttr1 = db.VectorSetSetAttributesJson("points", "pt:A", attrJson); + Console.WriteLine(setAttr1); // >>> True + + string? getAttr1 = db.VectorSetGetAttributesJson("points", "pt:A"); + Console.WriteLine(getAttr1); // >>> {"name":"Point A","description":"First point added"} + + bool clearAttr = db.VectorSetSetAttributesJson("points", "pt:A", ""); + Console.WriteLine(clearAttr); // >>> True + + string? getAttr2 = db.VectorSetGetAttributesJson("points", "pt:A"); + Console.WriteLine(getAttr2 is null ? "None" : getAttr2); // >>> None + // STEP_END + // REMOVE_START + Assert.True(setAttr1); + Assert.Contains("Point A", getAttr1); + Assert.True(clearAttr); + Assert.True(getAttr2 is null); + // REMOVE_END + + // STEP_START vrem + bool addF = db.VectorSetAdd("points", VectorSetAddRequest.Member("pt:F", new float[] { 0f, 0f }, null)); + Console.WriteLine(addF); // >>> True + + long card1 = db.VectorSetLength("points"); + Console.WriteLine(card1); // >>> 6 + + bool remF = db.VectorSetRemove("points", "pt:F"); + Console.WriteLine(remF); // >>> True + + long card2 = db.VectorSetLength("points"); + Console.WriteLine(card2); // >>> 5 + // STEP_END + // REMOVE_START + Assert.True(addF); + Assert.Equal(6, card1); + Assert.True(remF); + Assert.Equal(5, card2); + // REMOVE_END + + // STEP_START vsim_basic + VectorSetSimilaritySearchRequest qBasic = VectorSetSimilaritySearchRequest.ByVector(new float[] { 0.9f, 0.1f }); + using (Lease? res = db.VectorSetSimilaritySearch("points", qBasic)) + { + VectorSetSimilaritySearchResult[] items = res!.Span.ToArray(); + string[] ordered = items.Select(x => (string?)x.Member).Where(s => s is not null).Select(s => s!).ToArray(); + Console.WriteLine("[" + string.Join(", ", ordered.Select(s => $"'{s}'")) + "]"); + // >>> ['pt:E', 'pt:A', 'pt:D', 'pt:C', 'pt:B'] + // REMOVE_START + Assert.Equal(new[] { "pt:E", "pt:A", "pt:D", "pt:C", "pt:B" }, ordered); + // REMOVE_END + } + // STEP_END + + // STEP_START vsim_options + VectorSetSimilaritySearchRequest qOpts = VectorSetSimilaritySearchRequest.ByMember("pt:A"); + qOpts.WithScores = true; + qOpts.Count = 4; + using (Lease? res = db.VectorSetSimilaritySearch("points", qOpts)) + { + VectorSetSimilaritySearchResult[] items = res!.Span.ToArray(); + Dictionary dict = items + .Select(i => new { Key = (string?)i.Member, i.Score }) + .Where(x => x.Key is not null) + .ToDictionary(x => x.Key!, x => x.Score); + Console.WriteLine("{" + string.Join(", ", dict.Select(kv => $"'{kv.Key}': {kv.Value}")) + "}"); + // >>> {'pt:A': 1.0, 'pt:E': 0.8535534143447876, 'pt:D': 0.5, 'pt:C': 0.5} + // REMOVE_START + Assert.Equal(1.0, dict["pt:A"]); + Assert.Equal(0.5, dict["pt:C"]); + Assert.Equal(0.5, dict["pt:D"]); + Assert.True(Math.Abs(dict["pt:E"] - 0.85) < 0.005); + // REMOVE_END + } + // STEP_END + + // STEP_START vsim_filter + bool okA = db.VectorSetSetAttributesJson("points", "pt:A", "{\"size\":\"large\",\"price\":18.99}"); + Console.WriteLine(okA); // >>> True + bool okB = db.VectorSetSetAttributesJson("points", "pt:B", "{\"size\":\"large\",\"price\":35.99}"); + Console.WriteLine(okB); // >>> True + bool okC = db.VectorSetSetAttributesJson("points", "pt:C", "{\"size\":\"large\",\"price\":25.99}"); + Console.WriteLine(okC); // >>> True + bool okD = db.VectorSetSetAttributesJson("points", "pt:D", "{\"size\":\"small\",\"price\":21.00}"); + Console.WriteLine(okD); // >>> True + bool okE = db.VectorSetSetAttributesJson("points", "pt:E", "{\"size\":\"small\",\"price\":17.75}"); + Console.WriteLine(okE); // >>> True + // REMOVE_START + Assert.True(okA && okB && okC && okD && okE); + // REMOVE_END + + VectorSetSimilaritySearchRequest qFilt1 = VectorSetSimilaritySearchRequest.ByMember("pt:A"); + qFilt1.FilterExpression = ".size == \"large\""; + using (Lease? res = db.VectorSetSimilaritySearch("points", qFilt1)) + { + string[] ids = res!.Span.ToArray() + .Select(i => (string?)i.Member) + .Where(s => s is not null) + .Select(s => s!) + .ToArray(); + Console.WriteLine("[" + string.Join(", ", ids.Select(s => $"'{s}'")) + "]"); + // >>> ['pt:A', 'pt:C', 'pt:B'] + // REMOVE_START + Assert.Equal(new[] { "pt:A", "pt:C", "pt:B" }, ids); + // REMOVE_END + + } + + VectorSetSimilaritySearchRequest qFilt2 = VectorSetSimilaritySearchRequest.ByMember("pt:A"); + qFilt2.FilterExpression = ".size == \"large\" && .price > 20.00"; + using (Lease? res = db.VectorSetSimilaritySearch("points", qFilt2)) + { + string[] ids = res!.Span.ToArray() + .Select(i => (string?)i.Member) + .Where(s => s is not null) + .Select(s => s!) + .ToArray(); + Console.WriteLine("[" + string.Join(", ", ids.Select(s => $"'{s}'")) + "]"); + // >>> ['pt:C', 'pt:B'] + // REMOVE_START + Assert.Equal(new[] { "pt:C", "pt:B" }, ids); + // REMOVE_END + } + // STEP_END + + // STEP_START add_quant + VectorSetAddRequest addInt8 = VectorSetAddRequest.Member("quantElement", new float[] { 1.262185f, 1.958231f }, null); + addInt8.Quantization = VectorSetQuantization.Int8; + bool q8Added = db.VectorSetAdd("quantSetQ8", addInt8); + Console.WriteLine(q8Added); // >>> True + using (Lease? eInt8 = db.VectorSetGetApproximateVector("quantSetQ8", "quantElement")) + { + Span v = eInt8!.Span; + Console.WriteLine($"Q8: [{v[0]}, {v[1]}]"); + // >>> Q8: [1.2643694877624512, 1.958230972290039] + } + + VectorSetAddRequest addNone = VectorSetAddRequest.Member("quantElement", new float[] { 1.262185f, 1.958231f }, null); + addNone.Quantization = VectorSetQuantization.None; + bool noQuantAdded = db.VectorSetAdd("quantSetNoQ", addNone); + Console.WriteLine(noQuantAdded); // >>> True + using (Lease? eNone = db.VectorSetGetApproximateVector("quantSetNoQ", "quantElement")) + { + Span v = eNone!.Span; + Console.WriteLine($"NOQUANT: [{v[0]}, {v[1]}]"); + // >>> NOQUANT: [1.262184977531433, 1.958230972290039] + } + + VectorSetAddRequest addBinary = VectorSetAddRequest.Member("quantElement", new float[] { 1.262185f, 1.958231f }, null); + addBinary.Quantization = VectorSetQuantization.Binary; + bool binAdded = db.VectorSetAdd("quantSetBin", addBinary); + Console.WriteLine(binAdded); // >>> True + using (Lease? eBinary = db.VectorSetGetApproximateVector("quantSetBin", "quantElement")) + { + Span v = eBinary!.Span; + Console.WriteLine($"BIN: [{v[0]}, {v[1]}]"); + // >>> BIN: [1, 1] + } + // REMOVE_START + Assert.True(q8Added); + Assert.True(noQuantAdded); + Assert.True(binAdded); + // REMOVE_END + // STEP_END + + // STEP_START add_reduce + float[] values = Enumerable.Range(0, 300).Select(x => (float)(x / 299.0)).ToArray(); + bool addedNotReduced = db.VectorSetAdd("setNotReduced", VectorSetAddRequest.Member("element", values, null)); + Console.WriteLine(addedNotReduced); // >>> True + Console.WriteLine(db.VectorSetDimension("setNotReduced")); // >>> 300 + // REMOVE_START + Assert.True(addedNotReduced); + Assert.Equal(300, db.VectorSetDimension("setNotReduced")); + // REMOVE_END + + VectorSetAddRequest addReduced = VectorSetAddRequest.Member("element", values, null); + addReduced.ReducedDimensions = 100; + bool addedReduced = db.VectorSetAdd("setReduced", addReduced); + Console.WriteLine(addedReduced); // >>> True + Console.WriteLine(db.VectorSetDimension("setReduced")); // >>> 100 + // REMOVE_START + Assert.True(addedReduced); + Assert.Equal(100, db.VectorSetDimension("setReduced")); + // REMOVE_END + // STEP_END + + } +} +