Npgsql: Use NpgsqlPoint .NET type for marshalling GEO_POINT types. Explore communicating and marshalling GeoJSON types.

by-language/csharp-npgsql/BasicPoco.cs

@@ -6,10 +6,10 @@ public class BasicPoco
     public string? name { get; set; }
     public int? age { get; set; }
 
-    public override bool Equals(object obj)
+    public override bool Equals(object? obj)
     {
-        var other = (BasicPoco) obj;
-        return name == other.name && age == other.age;
+        var other = (BasicPoco?) obj;
+        return name == other?.name && age == other?.age;
     }
 
     public override int GetHashCode()

by-language/csharp-npgsql/DemoProgram.cs

@@ -17,12 +17,9 @@ await Parser.Default.ParseArguments<Options>(args)
                 {
                     var connString = $"Host={options.Host};Port={options.Port};SSL Mode={options.SslMode};" +
                                      $"Username={options.Username};Password={options.Password};Database={options.Database}";
-                    Console.WriteLine($"Connecting to {connString}\n");
 
-                    var dataSourceBuilder = new NpgsqlDataSourceBuilder(connString);
-                    dataSourceBuilder.EnableDynamicJson();
-                    await using var dataSource = dataSourceBuilder.Build();
-                    await using var conn = dataSource.OpenConnection();
+                    await using var dataSource = GetDataSource(connString);
+                    var conn = dataSource.OpenConnection();
 
                     await DatabaseWorkloads.SystemQueryExample(conn);
                     await DatabaseWorkloads.BasicConversationExample(conn);
@@ -34,11 +31,35 @@ await Parser.Default.ParseArguments<Options>(args)
                     // await dwt.ArrayJsonDocumentExample();
                     await dwt.ObjectPocoExample();
                     await dwt.ArrayPocoExample();
+                    await dwt.GeoJsonTypesExample();
                     conn.Close();
                 });
 
         }
 
+        public static NpgsqlDataSource GetDataSource(string connString)
+        {
+            // It's just a testing rig. Do NOT log database credentials in production.
+            Console.WriteLine($"Connecting to database: {connString}\n");
+
+            // Enable JSON POCO mapping and PostGIS/GeoJSON Type Plugin.
+            // https://www.npgsql.org/doc/types/json.html
+            // https://www.npgsql.org/doc/types/geojson.html
+            var dataSourceBuilder = new NpgsqlDataSourceBuilder(connString);
+
+            // Enable JSON POCO mapping Plugin.
+            // https://www.npgsql.org/doc/types/json.html
+            dataSourceBuilder.EnableDynamicJson();
+
+            // Enable PostGIS/GeoJSON Type Plugin.
+            // https://www.npgsql.org/doc/types/geojson.html
+            // `NpgsqlDbType.Geometry` can not be used with CrateDB,
+            // see also https://github.com/npgsql/npgsql/issues/2411.
+            // dataSourceBuilder.UseGeoJson();
+
+            return dataSourceBuilder.Build();
+        }
+
         public class Options
         {
             [Option('h', "host", Required = false, HelpText = "Host name to connect to", Default = "localhost")]

by-language/csharp-npgsql/DemoTypes.cs

@@ -4,6 +4,7 @@
 using System.Data;
 using System.Text.Json;
 using System.Threading.Tasks;
+using GeoJSON.Net.Geometry;
 using Newtonsoft.Json;
 using Npgsql;
 using NpgsqlTypes;
@@ -75,6 +76,7 @@ public async Task CreateTable()
 
             await using (var cmd = new NpgsqlCommand("""
                 CREATE TABLE testdrive.example (
+                    id STRING,
                     -- Numeric types
                     null_integer INT,
                     integer INT,
@@ -166,12 +168,27 @@ INSERT INTO testdrive.example (
                 cmd.Parameters.AddWithValue("timestamp_tz", "1970-01-02T00:00:00+01:00");
                 cmd.Parameters.AddWithValue("timestamp_notz", "1970-01-02T00:00:00");
                 cmd.Parameters.AddWithValue("ip", "127.0.0.1");
+
+                // Container types
                 cmd.Parameters.AddWithValue("array", NpgsqlDbType.Json, new List<string>{"foo", "bar"});
                 cmd.Parameters.AddWithValue("object", NpgsqlDbType.Json, new Dictionary<string, string>{{"foo", "bar"}});
-                cmd.Parameters.AddWithValue("geopoint", new List<double>{85.43, 66.23});
-                // TODO: Check if `GEO_SHAPE` types can be represented by real .NET or Npgsql data types.
+
+                // Geospatial types
+
+                // GEO_POINT
+                // Alternatively to `NpgsqlPoint`, you can also use `List<double>{85.43, 66.23}`.
+                cmd.Parameters.AddWithValue("geopoint", new NpgsqlPoint(85.43, 66.23));
+
+                // GEO_SHAPE
+                // While `GEO_POINT` is transparently marshalled as `NpgsqlPoint`,
+                // `GEO_SHAPE` is communicated as scalar `string` type, using WKT or GeoJSON format.
+                // TODO: Possibly support transparently converging `GEO_SHAPE` to one of
+                //       `NpgsqlLSeg`, `NpgsqlBox`, `NpgsqlPath`, `NpgsqlPolygon`, `NpgsqlCircle`.
                 cmd.Parameters.AddWithValue("geoshape", "POLYGON ((5 5, 10 5, 10 10, 5 10, 5 5))");
+
+                // Vector type
                 cmd.Parameters.AddWithValue("float_vector", new List<double> {1.1, 2.2, 3.3});
+
                 cmd.ExecuteNonQuery();
             }
 
@@ -336,6 +353,108 @@ public async Task<List<BasicPoco>> ArrayPocoExample()
             }
         }
 
+        public async Task InsertGeoJsonTyped()
+        {
+            /***
+             * Verify Npgsql PostGIS/GeoJSON Type Plugin with CrateDB.
+             * https://www.npgsql.org/doc/types/geojson.html
+             *
+             * TODO: Does not work yet, because CrateDB communicates GEO_SHAPE as string?
+             *       The error message is:
+             *
+             *       System.NotSupportedException : The NpgsqlDbType 'Geometry' isn't present in your
+             *       database. You may need to install an extension or upgrade to a newer version.
+             *       See also https://github.com/npgsql/npgsql/issues/2411.
+             */
+            Console.WriteLine("Running InsertGeoJsonTyped");
+
+            // Insert single data point.
+            await using (var cmd = new NpgsqlCommand("""
+            INSERT INTO testdrive.example (
+                "geoshape"
+            ) VALUES (
+                @geoshape
+            );
+            """, conn))
+            {
+                var point = new Point(new Position(85.43, 66.23));
+                cmd.Parameters.AddWithValue("geoshape", NpgsqlDbType.Geometry, point);
+                cmd.ExecuteNonQuery();
+            }
+
+            // Flush data.
+            await RefreshTable();
+        }
+
+        public async Task InsertGeoJsonString()
+        {
+            /***
+             * Communicate GeoJSON types as strings, marshall from/to GeoJSON types manually.
+             */
+            Console.WriteLine("Running InsertGeoJsonString");
+
+            // Insert single data point.
+            await using (var cmd = new NpgsqlCommand("""
+            INSERT INTO testdrive.example (
+                "id",
+                "geoshape"
+            ) VALUES (
+                @id,
+                @geoshape
+            );
+            """, conn))
+            {
+                var point = new Point(new Position(85.43, 66.23));
+                var poly = new Polygon([
+                    new LineString([
+                        new Position(longitude: 5.0, latitude: 5.0),
+                        new Position(longitude: 5.0, latitude: 10.0),
+                        new Position(longitude: 10.0, latitude: 10.0),
+                        new Position(longitude: 10.0, latitude: 5.0),
+                        new Position(longitude: 5.0, latitude: 5.0),
+                    ])
+                ]);
+                // TODO: Can GEO_SHAPE types be directly marshalled to a .NET GeoJSON type?
+                //       Currently, `InsertGeoJsonTyped` does not work yet.
+                cmd.Parameters.AddWithValue("id", "point");
+                cmd.Parameters.AddWithValue("geoshape", NpgsqlDbType.Json, JsonConvert.SerializeObject(point));
+                cmd.ExecuteNonQuery();
+
+                cmd.Parameters.Clear();
+
+                cmd.Parameters.AddWithValue("id", "polygon");
+                cmd.Parameters.AddWithValue("geoshape", NpgsqlDbType.Json, JsonConvert.SerializeObject(poly));
+                cmd.ExecuteNonQuery();
+            }
+
+            // Flush data.
+            await RefreshTable();
+
+        }
+
+        public async Task<Point?> GeoJsonTypesExample()
+        {
+            Console.WriteLine("Running GeoJsonTypesExample");
+
+            // Provision data.
+            await CreateTable();
+            // await InsertGeoJsonTyped();
+            await InsertGeoJsonString();
+
+            // Query back data.
+            await using (var cmd = new NpgsqlCommand("SELECT * FROM testdrive.example WHERE id='point'", conn))
+            await using (var reader = cmd.ExecuteReader())
+            {
+                reader.Read();
+                // TODO: Can GEO_SHAPE types be directly marshalled to a .NET GeoJSON type?
+                //       Currently, `InsertGeoJsonTyped` does not work yet.
+                var obj = reader.GetFieldValue<JsonDocument>("geoshape");
+                var payload = obj.RootElement.ToString();
+                var geoJsonObject = JsonConvert.DeserializeObject<Point>(payload);
+                return (Point?) geoJsonObject;
+            }
+        }
+
     }
 
 }

by-language/csharp-npgsql/demo.csproj

@@ -11,6 +11,7 @@
 
   <ItemGroup>
     <PackageReference Include="Npgsql" Version="10.0.0" />
+    <PackageReference Include="GeoJSON.Net" Version="1.4.1" />
     <PackageReference Include="CommandLineParser" Version="2.9.1" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
     <PackageReference Include="xunit" Version="2.9.3" />

by-language/csharp-npgsql/tests/DemoProgramTest.cs

@@ -4,14 +4,17 @@
 using System.Linq;
 using System.Text.Json;
 using System.Threading.Tasks;
+using GeoJSON.Net.Geometry;
 using Npgsql;
+using NpgsqlTypes;
 using Xunit;
 
 namespace demo.tests
 {
 
     public class DatabaseFixture : IDisposable
     {
+        public NpgsqlDataSource Source { get; private set; }
         public NpgsqlConnection Db { get; private set; }
 
         public DatabaseFixture()
@@ -21,17 +24,14 @@ public DatabaseFixture()
             {
                 CRATEDB_DSN = $"Host=localhost;Port=5432;Username=crate;Password=;Database=testdrive";
             }
-            Console.WriteLine($"Connecting to {CRATEDB_DSN}\n");
-
-            var dataSourceBuilder = new NpgsqlDataSourceBuilder(CRATEDB_DSN);
-            dataSourceBuilder.EnableDynamicJson();
-            using var dataSource = dataSourceBuilder.Build();
-            Db = dataSource.OpenConnection();
+            Source = DemoProgram.GetDataSource(CRATEDB_DSN);
+            Db = Source.OpenConnection();
         }
 
         public void Dispose()
         {
             Db.Close();
+            Source.Dispose();
         }
 
     }
@@ -129,11 +129,13 @@ public async Task TestAllTypesNativeExample()
             // Assert.Equal(new Dictionary<string, string>{{"foo", "bar"}}, row["object"]);
 
             // Geospatial types
-            // TODO: Unlock native data types?
-            //       GEO_POINT and GEO_SHAPE types can be marshalled back and forth using STRING.
-            //       GEO_POINT is using a tuple format, GEO_SHAPE is using the GeoJSON format.
-            // Assert.Equal(new List<double>{85.43, 66.23}, row["geopoint"]);  // TODO
-            Assert.Equal("(85.42999997735023,66.22999997343868)", row["geopoint"].ToString());  // FIXME
+            // While `GEO_POINT` is transparently marshalled as `NpgsqlPoint`,
+            // `GEO_SHAPE` is communicated as scalar `string` type, using the GeoJSON format.
+            // TODO: Possibly support transparently converging `GEO_SHAPE` to one of
+            //       `NpgsqlLSeg`, `NpgsqlBox`, `NpgsqlPath`, `NpgsqlPolygon`, `NpgsqlCircle`.
+            var geopoint = (NpgsqlPoint) row["geopoint"];
+            Assert.True(Math.Abs(geopoint.X - 85.43) < 0.0001, "X coordinate mismatch");
+            Assert.True(Math.Abs(geopoint.Y - 66.23) < 0.0001, "Y coordinate mismatch");
             Assert.Equal("""{"coordinates":[[[5.0,5.0],[5.0,10.0],[10.0,10.0],[10.0,5.0],[5.0,5.0]]],"type":"Polygon"}""", row["geoshape"]);
 
             // Vector type
@@ -215,5 +217,21 @@ public async Task TestArrayPocoExample()
 
         }
 
+        [Fact]
+        public async Task TestGeoJsonTypesExample()
+        {
+            var conn = fixture.Db;
+
+            // Provision data.
+            var task = new DatabaseWorkloadsTypes(conn).GeoJsonTypesExample();
+            var point = await task.WaitAsync(TimeSpan.FromSeconds(0.5));
+
+            // Validate the outcome.
+            var coords = new Point(new Position(85.43, 66.23)).Coordinates;
+            Assert.True(Math.Abs(coords.Latitude - (point?.Coordinates.Latitude ?? 0)) < 0.0001, "Latitude mismatch");
+            Assert.True(Math.Abs(coords.Longitude - (point?.Coordinates.Longitude ?? 0)) < 0.0001, "Longitude mismatch");
+
+        }
+
     }
 }