encoding/ewkb: add PrefixSRIDScanner

Author: paulmach

encoding/ewkb/scanner.go

@@ -3,6 +3,7 @@ package ewkb
 import (
 	"database/sql"
 	"database/sql/driver"
+	"encoding/binary"
 
 	"github.com/paulmach/orb"
 	"github.com/paulmach/orb/encoding/internal/wkbcommon"
@@ -26,10 +27,11 @@ var (
 //	  // NULL value
 //	}
 type GeometryScanner struct {
-	g        interface{}
-	SRID     int
-	Geometry orb.Geometry
-	Valid    bool // Valid is true if the geometry is not NULL
+	sridInPrefix bool
+	g            interface{}
+	SRID         int
+	Geometry     orb.Geometry
+	Valid        bool // Valid is true if the geometry is not NULL
 }
 
 // Scanner will return a GeometryScanner that can scan sql query results.
@@ -58,18 +60,63 @@ func Scanner(g interface{}) *GeometryScanner {
 	return &GeometryScanner{g: g}
 }
 
+// ScannerPrefixSRID will scan ewkb data were the SRID is in the first 4 bytes of the data.
+// Databases like mysql/mariadb use this as their raw format. This method should only be used when
+// working with such a database.
+//
+//	var p orb.Point
+//	err := db.QueryRow("SELECT latlon FROM foo WHERE id=?", id).Scan(wkb.PrefixSRIDScanner(&p))
+//
+// However, it is recommended to covert to wkb explicitly using something like:
+//
+//	var srid int
+//	var p orb.Point
+//	err := db.QueryRow("SELECT ST_SRID(latlon), ST_AsBinary(latlon) FROM foo WHERE id=?", id).
+//		Scan(&srid, wkb.Scanner(&p))
+func ScannerPrefixSRID(g interface{}) *GeometryScanner {
+	return &GeometryScanner{sridInPrefix: true, g: g}
+}
+
 // Scan will scan the input []byte data into a geometry.
 // This could be into the orb geometry type pointer or, if nil,
 // the scanner.Geometry attribute.
 func (s *GeometryScanner) Scan(d interface{}) error {
 	s.Geometry = nil
 	s.Valid = false
 
-	g, srid, valid, err := wkbcommon.Scan(s.g, d)
+	var (
+		srid int
+		data interface{}
+	)
+
+	data = d
+	if s.sridInPrefix {
+		raw, ok := d.([]byte)
+		if !ok {
+			return ErrUnsupportedDataType
+		}
+
+		if raw == nil {
+			return nil
+		}
+
+		if len(raw) < 5 {
+			return ErrNotEWKB
+		}
+
+		srid = int(binary.LittleEndian.Uint32(raw))
+		data = raw[4:]
+	}
+
+	g, embeddedSRID, valid, err := wkbcommon.Scan(s.g, data)
 	if err != nil {
 		return mapCommonError(err)
 	}
 
+	if embeddedSRID != 0 {
+		srid = embeddedSRID
+	}
+
 	s.Geometry = g
 	s.SRID = srid
 	s.Valid = valid

encoding/ewkb/scanner_test.go

@@ -374,6 +374,43 @@ func TestScanPoint_errors(t *testing.T) {
 	}
 }
 
+func TestPrefixScannerPrefixSRID(t *testing.T) {
+	cases := []struct {
+		name     string
+		data     []byte
+		srid     int
+		expected orb.Point
+	}{
+		{
+			name:     "point",
+			data:     append([]byte{230, 16, 0, 0}, MustMarshal(orb.Point{4, 5}, 0)...),
+			srid:     4326,
+			expected: orb.Point{4, 5},
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			var p orb.Point
+			s := ScannerPrefixSRID(&p)
+			err := s.Scan(tc.data)
+			if err != nil {
+				t.Fatalf("scan error: %v", err)
+			}
+
+			if !p.Equal(tc.expected) {
+				t.Errorf("unequal data")
+				t.Log(p)
+				t.Log(tc.expected)
+			}
+
+			if s.SRID != tc.srid {
+				t.Errorf("incorrect SRID: %v != %v", s.SRID, tc.srid)
+			}
+		})
+	}
+}
+
 func TestScanMultiPoint(t *testing.T) {
 	cases := []struct {
 		name     string