Line data    Source code

       1             : /*
       2             :  * SPDX-License-Identifier: MPL-2.0
       3             :  *
       4             :  * This Source Code Form is subject to the terms of the Mozilla Public
       5             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       6             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       7             :  *
       8             :  * Copyright 2024 MonetDB Foundation;
       9             :  * Copyright August 2008 - 2023 MonetDB B.V.;
      10             :  * Copyright 1997 - July 2008 CWI.
      11             :  */
      12             : 
      13             : /*
      14             :  * @f libgeom
      15             :  * @a Niels Nes
      16             :  *
      17             :  * @* The simple geom library
      18             :  */
      19             : 
      20             : #include "monetdb_config.h"
      21             : #include "libgeom.h"
      22             : 
      23             : static void __attribute__((__format__(__printf__, 1, 2)))
      24          57 : geomerror(_In_z_ _Printf_format_string_ const char *fmt, ...)
      25             : {
      26          57 :         va_list va;
      27          57 :         char err[256];
      28          57 :         va_start(va, fmt);
      29          57 :         vsnprintf(err, sizeof(err), fmt, va);
      30          57 :         GDKtracer_log(__FILE__, __func__, __LINE__, M_ERROR,
      31             :                       GDK, NULL, "%s", err);
      32          57 :         va_end(va);
      33          57 : }
      34             : 
      35             : static MT_TLS_t geom_tls_key;
      36             : 
      37             : static void
      38       49679 : libgeom_tls_init(void *dummy)
      39             : {
      40       49679 :         (void)dummy;
      41       49679 :         GEOSContextHandle_t ctx = GEOS_init_r ();
      42       49678 :         GEOSContext_setNoticeHandler_r(ctx, (GEOSMessageHandler) geomerror);
      43       49676 :         GEOSContext_setErrorHandler_r(ctx, (GEOSMessageHandler) geomerror);
      44       49678 :         GEOS_setWKBByteOrder_r(ctx, 1); /* NDR (little endian) */
      45       49679 :         MT_tls_set(geom_tls_key, ctx);
      46       49671 : }
      47             : 
      48             : static void
      49       49678 : libgeom_tls_exit(void *dummy)
      50             : {
      51       49678 :         (void)dummy;
      52       49678 :         GEOSContextHandle_t ctx = MT_tls_get(geom_tls_key);
      53       49678 :         GEOS_finish_r(ctx);
      54       49679 : }
      55             : 
      56             : GEOSContextHandle_t
      57       36288 : libgeom_tls(void)
      58             : {
      59       36288 :         return MT_tls_get(geom_tls_key);
      60             : }
      61             : 
      62             : gdk_return
      63         318 : libgeom_init(void)
      64             : {
      65         636 :         if (MT_alloc_tls(&geom_tls_key) != GDK_SUCCEED ||
      66         318 :                 MT_thread_init_add_callback(libgeom_tls_init, libgeom_tls_exit, NULL) != GDK_SUCCEED)
      67           0 :                 return GDK_FAIL;
      68             : 
      69         318 :         printf("# MonetDB/GIS module loaded\n");
      70         318 :         fflush(stdout);         /* make merovingian see this *now* */
      71         318 :         return GDK_SUCCEED;
      72             : }
      73             : 
      74             : bool
      75        8170 : is_wkb_nil(const wkb *w)
      76             : {
      77        8170 :         if (!w || w->len == ~0)
      78          77 :                 return 1;
      79             :         return 0;
      80             : }
      81             : 
      82             : GEOSGeom
      83        3620 : wkb2geos(const wkb *geomWKB)
      84             : {
      85        3620 :         GEOSGeom geosGeometry;
      86             : 
      87        3620 :         if (is_wkb_nil(geomWKB))
      88             :                 return NULL;
      89             : 
      90        3619 :         geosGeometry = GEOSGeomFromWKB_buf_r(geoshandle, (unsigned char *) geomWKB->data, geomWKB->len);
      91             : 
      92        3624 :         if (geosGeometry != NULL)
      93        3624 :                 GEOSSetSRID_r(geoshandle, geosGeometry, geomWKB->srid);
      94             : 
      95             :         return geosGeometry;
      96             : }
      97             : 
      98             : const char *
      99         178 : geom_type2str(int t, int flag)
     100             : {
     101         178 :         if (flag == 0) {
     102         125 :                 switch (t) {
     103             :                 //case wkbGeometry:
     104             :                 //      return "GEOMETRY";
     105          23 :                 case wkbPoint_mdb:
     106          23 :                         return "POINT";
     107          21 :                 case wkbLineString_mdb:
     108          21 :                         return "LINESTRING";
     109           0 :                 case wkbLinearRing_mdb:
     110           0 :                         return "LINEARRING";
     111          15 :                 case wkbPolygon_mdb:
     112          15 :                         return "POLYGON";
     113          15 :                 case wkbMultiPoint_mdb:
     114          15 :                         return "MULTIPOINT";
     115          22 :                 case wkbMultiLineString_mdb:
     116          22 :                         return "MULTILINESTRING";
     117          19 :                 case wkbMultiPolygon_mdb:
     118          19 :                         return "MULTIPOLYGON";
     119          10 :                 case wkbGeometryCollection_mdb:
     120          10 :                         return "GEOMETRYCOLLECTION";
     121             :                 }
     122          53 :         } else if (flag == 1) {
     123          53 :                 switch (t) {
     124             :                 //case wkbGeometry:
     125             :                 //      return "ST_Geometry";
     126           5 :                 case wkbPoint_mdb:
     127           5 :                         return "ST_Point";
     128          11 :                 case wkbLineString_mdb:
     129          11 :                         return "ST_LineString";
     130           0 :                 case wkbLinearRing_mdb:
     131           0 :                         return "ST_LinearRing";
     132           6 :                 case wkbPolygon_mdb:
     133           6 :                         return "ST_Polygon";
     134           5 :                 case wkbMultiPoint_mdb:
     135           5 :                         return "ST_MultiPoint";
     136          11 :                 case wkbMultiLineString_mdb:
     137          11 :                         return "ST_MultiLinestring";
     138           7 :                 case wkbMultiPolygon_mdb:
     139           7 :                         return "ST_MultiPolygon";
     140           8 :                 case wkbGeometryCollection_mdb:
     141           8 :                         return "ST_GeometryCollection";
     142             :                 }
     143             :         }
     144             :         return "UNKNOWN";
     145             : }