Read from the catalog which arguments are arrays

MEOS.NET.Tests/ArrayArgumentTests.cs

@@ -0,0 +1,44 @@
+using MEOS.NET.Types;
+
+namespace MEOS.NET.Tests
+{
+    /// <summary>
+    /// An array MEOS reads is one parameter to the caller and two to MEOS, the
+    /// pointer and its length. The catalog names both, so a method takes the
+    /// array whatever MEOS calls the length.
+    /// </summary>
+    [TestClass]
+    public class ArrayArgumentTests : MeosTest
+    {
+        [TestMethod]
+        public void ASetIsBuiltFromAnArrayOfGeometries()
+        {
+            Geo[] points =
+            {
+                Geo.FromText("POINT(1 1)", 0)!,
+                Geo.FromText("POINT(2 2)", 0)!,
+            };
+
+            Set? set = GeomSet.Make(points);
+
+            Assert.IsNotNull(set);
+            Assert.AreEqual(2, set!.NumValues());
+        }
+
+        [TestMethod]
+        public void AJsonbIsQueriedWithAnArrayOfKeysWhoseLengthIsNotNamedCount()
+        {
+            // `jsonb_exists_array(jb, text **keys_elems, int keys_len, bool any)`
+            // — the length is `keys_len`, and the catalog is what says so.
+            Jsonb jb = Jsonb.In("{\"a\": 1, \"b\": 2}")!;
+            Text[] keys = { Text.In("a")!, Text.In("z")! };
+
+            Assert.IsTrue(jb.ExistsArray(keys, true));
+            Assert.IsFalse(jb.ExistsArray(keys, false));
+
+            Text[] missing = { Text.In("y")!, Text.In("z")! };
+
+            Assert.IsFalse(jb.ExistsArray(missing, true));
+        }
+    }
+}

MEOS.NET/Types/Geo.g.cs

@@ -111,6 +111,63 @@ public ulong ToQuadbinCell(int resolution)
         public STBox? TstzspanToStbox(Span s)
             => MEOSFactory.WrapSTBox(Meos.GeoTstzspanToStbox(this.Ptr, s.Ptr));
 
+        public static Geo?[] ClusterIntersecting(Geo[] geoms)
+        {
+            IntPtr[] _geomsValues = new IntPtr[geoms.Length];
+            for (int i = 0; i < geoms.Length; i++)
+            {
+                _geomsValues[i] = geoms[i].Ptr;
+            }
+
+            GCHandle _geoms = GCHandle.Alloc(_geomsValues, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapGeoArray(Meos.GeoClusterIntersecting(_geoms.AddrOfPinnedObject(), (uint) geoms.Length));
+            }
+            finally
+            {
+                _geoms.Free();
+            }
+        }
+
+        public static int[] ClusterKmeans(Geo[] geoms, uint k)
+        {
+            IntPtr[] _geomsValues = new IntPtr[geoms.Length];
+            for (int i = 0; i < geoms.Length; i++)
+            {
+                _geomsValues[i] = geoms[i].Ptr;
+            }
+
+            GCHandle _geoms = GCHandle.Alloc(_geomsValues, GCHandleType.Pinned);
+            try
+            {
+                return Meos.GeoClusterKmeans(_geoms.AddrOfPinnedObject(), (uint) geoms.Length, k);
+            }
+            finally
+            {
+                _geoms.Free();
+            }
+        }
+
+        public static Geo?[] ClusterWithin(Geo[] geoms, double tolerance)
+        {
+            IntPtr[] _geomsValues = new IntPtr[geoms.Length];
+            for (int i = 0; i < geoms.Length; i++)
+            {
+                _geomsValues[i] = geoms[i].Ptr;
+            }
+
+            GCHandle _geoms = GCHandle.Alloc(_geomsValues, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapGeoArray(Meos.GeoClusterWithin(_geoms.AddrOfPinnedObject(), (uint) geoms.Length, tolerance));
+            }
+            finally
+            {
+                _geoms.Free();
+            }
+        }
+
         public static Geo? CollectGarray(Geo[] gsarr)
         {
             IntPtr[] _gsarrValues = new IntPtr[gsarr.Length];
@@ -130,6 +187,19 @@ public ulong ToQuadbinCell(int resolution)
             }
         }
 
+        public static Geo? FromEWKB(byte[] wkb, int srid)
+        {
+            GCHandle _wkb = GCHandle.Alloc(wkb, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapGeo(Meos.GeoFromEwkb(_wkb.AddrOfPinnedObject(), (ulong) wkb.Length, srid));
+            }
+            finally
+            {
+                _wkb.Free();
+            }
+        }
+
         public static Geo? FromGEOJSON(string geojson)
             => MEOSFactory.WrapGeo(Meos.GeoFromGeojson(geojson));
 

MEOS.NET/Types/Jsonb.g.cs

@@ -45,18 +45,132 @@ public bool Contained(Jsonb jb2)
         public Jsonb? Delete(Text key)
             => MEOSFactory.WrapJsonb(Meos.JsonbDelete(this.Ptr, key.Ptr));
 
+        public Jsonb? DeleteArray(Text[] keys_elems)
+        {
+            IntPtr[] _keys_elemsValues = new IntPtr[keys_elems.Length];
+            for (int i = 0; i < keys_elems.Length; i++)
+            {
+                _keys_elemsValues[i] = keys_elems[i].Ptr;
+            }
+
+            GCHandle _keys_elems = GCHandle.Alloc(_keys_elemsValues, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapJsonb(Meos.JsonbDeleteArray(this.Ptr, _keys_elems.AddrOfPinnedObject(), keys_elems.Length));
+            }
+            finally
+            {
+                _keys_elems.Free();
+            }
+        }
+
         public Jsonb? DeleteIndex(int idx)
             => MEOSFactory.WrapJsonb(Meos.JsonbDeleteIndex(this.Ptr, idx));
 
+        public Jsonb? DeletePath(Text[] path_elems)
+        {
+            IntPtr[] _path_elemsValues = new IntPtr[path_elems.Length];
+            for (int i = 0; i < path_elems.Length; i++)
+            {
+                _path_elemsValues[i] = path_elems[i].Ptr;
+            }
+
+            GCHandle _path_elems = GCHandle.Alloc(_path_elemsValues, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapJsonb(Meos.JsonbDeletePath(this.Ptr, _path_elems.AddrOfPinnedObject(), path_elems.Length));
+            }
+            finally
+            {
+                _path_elems.Free();
+            }
+        }
+
         public bool Exists(Text key)
             => Meos.JsonbExists(this.Ptr, key.Ptr);
 
+        public bool ExistsArray(Text[] keys_elems, bool any)
+        {
+            IntPtr[] _keys_elemsValues = new IntPtr[keys_elems.Length];
+            for (int i = 0; i < keys_elems.Length; i++)
+            {
+                _keys_elemsValues[i] = keys_elems[i].Ptr;
+            }
+
+            GCHandle _keys_elems = GCHandle.Alloc(_keys_elemsValues, GCHandleType.Pinned);
+            try
+            {
+                return Meos.JsonbExistsArray(this.Ptr, _keys_elems.AddrOfPinnedObject(), keys_elems.Length, any);
+            }
+            finally
+            {
+                _keys_elems.Free();
+            }
+        }
+
+        public Jsonb? ExtractPath(Text[] path_elems)
+        {
+            IntPtr[] _path_elemsValues = new IntPtr[path_elems.Length];
+            for (int i = 0; i < path_elems.Length; i++)
+            {
+                _path_elemsValues[i] = path_elems[i].Ptr;
+            }
+
+            GCHandle _path_elems = GCHandle.Alloc(_path_elemsValues, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapJsonb(Meos.JsonbExtractPath(this.Ptr, _path_elems.AddrOfPinnedObject(), path_elems.Length));
+            }
+            finally
+            {
+                _path_elems.Free();
+            }
+        }
+
+        public Text? ExtractPathText(Text[] path_elems)
+        {
+            IntPtr[] _path_elemsValues = new IntPtr[path_elems.Length];
+            for (int i = 0; i < path_elems.Length; i++)
+            {
+                _path_elemsValues[i] = path_elems[i].Ptr;
+            }
+
+            GCHandle _path_elems = GCHandle.Alloc(_path_elemsValues, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapText(Meos.JsonbExtractPathText(this.Ptr, _path_elems.AddrOfPinnedObject(), path_elems.Length));
+            }
+            finally
+            {
+                _path_elems.Free();
+            }
+        }
+
         public uint Hash()
             => Meos.JsonbHash(this.Ptr);
 
         public ulong HashExtended(ulong seed)
             => Meos.JsonbHashExtended(this.Ptr, seed);
 
+        public Jsonb? Insert(Text[] path_elems, Jsonb newjb, bool after)
+        {
+            IntPtr[] _path_elemsValues = new IntPtr[path_elems.Length];
+            for (int i = 0; i < path_elems.Length; i++)
+            {
+                _path_elemsValues[i] = path_elems[i].Ptr;
+            }
+
+            GCHandle _path_elems = GCHandle.Alloc(_path_elemsValues, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapJsonb(Meos.JsonbInsert(this.Ptr, _path_elems.AddrOfPinnedObject(), path_elems.Length, newjb.Ptr, after));
+            }
+            finally
+            {
+                _path_elems.Free();
+            }
+        }
+
         public Jsonb? ObjectField(Text key)
             => MEOSFactory.WrapJsonb(Meos.JsonbObjectField(this.Ptr, key.Ptr));
 
@@ -72,6 +186,44 @@ public string Out()
         public Text? Pretty()
             => MEOSFactory.WrapText(Meos.JsonbPretty(this.Ptr));
 
+        public Jsonb? Set(Text[] path_elems, Jsonb newjb, bool create)
+        {
+            IntPtr[] _path_elemsValues = new IntPtr[path_elems.Length];
+            for (int i = 0; i < path_elems.Length; i++)
+            {
+                _path_elemsValues[i] = path_elems[i].Ptr;
+            }
+
+            GCHandle _path_elems = GCHandle.Alloc(_path_elemsValues, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapJsonb(Meos.JsonbSet(this.Ptr, _path_elems.AddrOfPinnedObject(), path_elems.Length, newjb.Ptr, create));
+            }
+            finally
+            {
+                _path_elems.Free();
+            }
+        }
+
+        public Jsonb? SetLax(Text[] path_elems, Jsonb newjb, bool create, Text handle_null)
+        {
+            IntPtr[] _path_elemsValues = new IntPtr[path_elems.Length];
+            for (int i = 0; i < path_elems.Length; i++)
+            {
+                _path_elemsValues[i] = path_elems[i].Ptr;
+            }
+
+            GCHandle _path_elems = GCHandle.Alloc(_path_elemsValues, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapJsonb(Meos.JsonbSetLax(this.Ptr, _path_elems.AddrOfPinnedObject(), path_elems.Length, newjb.Ptr, create, handle_null.Ptr));
+            }
+            finally
+            {
+                _path_elems.Free();
+            }
+        }
+
         public Jsonb? StripNulls(bool strip_in_arrays)
             => MEOSFactory.WrapJsonb(Meos.JsonbStripNulls(this.Ptr, strip_in_arrays));
 

MEOS.NET/Types/SpanSet.g.cs

@@ -130,5 +130,8 @@ public bool UpperInc()
             }
         }
 
+        public static SpanSet? Make(Span spans, int count)
+            => MEOSFactory.WrapSpanSet(Meos.SpansetMake(spans.Ptr, count));
+
     }
 }

MEOS.NET/Types/TJsonb.g.cs

@@ -49,6 +49,25 @@ public override string ToString()
         public Temporal? DeleteIndex(int idx)
             => MEOSFactory.WrapTemporal(Meos.TjsonbDeleteIndex(this.Ptr, idx));
 
+        public Temporal? DeletePath(Text[] path_elems)
+        {
+            IntPtr[] _path_elemsValues = new IntPtr[path_elems.Length];
+            for (int i = 0; i < path_elems.Length; i++)
+            {
+                _path_elemsValues[i] = path_elems[i].Ptr;
+            }
+
+            GCHandle _path_elems = GCHandle.Alloc(_path_elemsValues, GCHandleType.Pinned);
+            try
+            {
+                return MEOSFactory.WrapTemporal(Meos.TjsonbDeletePath(this.Ptr, _path_elems.AddrOfPinnedObject(), path_elems.Length));
+            }
+            finally
+            {
+                _path_elems.Free();
+            }
+        }
+
         public Jsonb? EndValue()
             => MEOSFactory.WrapJsonb(Meos.TjsonbEndValue(this.Ptr));