Documentation
¶
Overview ¶
Package wkb implements Well Known Binary encoding and decoding.
If you are encoding geometries in WKB to send to PostgreSQL/PostGIS, then you must specify binary_parameters=yes in the data source name that you pass to sql.Open.
Example (Scan) ¶
package main
import (
"fmt"
"log"
"github.com/DATA-DOG/go-sqlmock"
"github.com/twpayne/go-geom/encoding/wkb"
"github.com/twpayne/go-geom/internal/geomtest"
)
func main() {
type City struct {
Name string
Location wkb.Point
}
db, mock, err := sqlmock.New()
if err != nil {
log.Fatal(err)
}
defer db.Close()
mock.ExpectQuery(`SELECT name, ST_AsBinary\(location\) FROM cities WHERE name = \?;`).
WithArgs("London").
WillReturnRows(
sqlmock.NewRows([]string{"name", "location"}).
AddRow("London", geomtest.MustHexDecode("010100000052B81E85EB51C03F45F0BF95ECC04940")),
)
var c City
if err := db.QueryRow(`SELECT name, ST_AsBinary(location) FROM cities WHERE name = ?;`, "London").Scan(&c.Name, &c.Location); err != nil {
log.Fatal(err)
}
fmt.Printf("Longitude: %v\n", c.Location.X())
fmt.Printf("Latitude: %v\n", c.Location.Y())
}
Output: Longitude: 0.1275 Latitude: 51.50722
Example (Scan_different_shapes) ¶
package main
import (
"fmt"
"log"
"github.com/DATA-DOG/go-sqlmock"
"github.com/twpayne/go-geom/encoding/wkb"
"github.com/twpayne/go-geom/internal/geomtest"
)
func main() {
type Shape struct {
Name string
Geom wkb.Geom
}
db, mock, err := sqlmock.New()
if err != nil {
log.Fatal(err)
}
defer db.Close()
mock.ExpectQuery(`SELECT name, ST_AsBinary\(geom\) FROM shapes`).
WillReturnRows(
sqlmock.NewRows([]string{"name", "location"}).
AddRow("Point", geomtest.MustHexDecode("0101000000000000000000F03F0000000000000040")).
AddRow("LineString", geomtest.MustHexDecode("010200000002000000000000000000F03F000000000000004000000000000008400000000000001040")).
AddRow("Polygon", geomtest.MustHexDecode("01030000000100000004000000000000000000F03F00000000000000400000000000000840000000000000104000000000000014400000000000001840000000000000F03F0000000000000040")),
)
rows, err := db.Query(`SELECT name, ST_AsBinary(geom) FROM shapes`)
if err != nil {
log.Fatal(err)
}
defer rows.Close()
for rows.Next() {
var s Shape
err := rows.Scan(&s.Name, &s.Geom)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%s: %v\n", s.Name, s.Geom.FlatCoords())
}
if err := rows.Err(); err != nil {
log.Fatal(err)
}
}
Output: Point: [1 2] LineString: [1 2 3 4] Polygon: [1 2 3 4 5 6 1 2]
Example (Value) ¶
package main
import (
"fmt"
"log"
"github.com/DATA-DOG/go-sqlmock"
"github.com/twpayne/go-geom"
"github.com/twpayne/go-geom/encoding/wkb"
"github.com/twpayne/go-geom/internal/geomtest"
)
func main() {
type City struct {
Name string
Location wkb.Point
}
db, mock, err := sqlmock.New()
if err != nil {
log.Fatal(err)
}
defer db.Close()
mock.ExpectExec(`INSERT INTO cities \(name, location\) VALUES \(\?, \?\);`).
WithArgs("London", geomtest.MustHexDecode("010100000052B81E85EB51C03F45F0BF95ECC04940")).
WillReturnResult(sqlmock.NewResult(1, 1))
c := City{
Name: "London",
Location: wkb.Point{Point: geom.NewPoint(geom.XY).MustSetCoords(geom.Coord{0.1275, 51.50722})},
}
result, err := db.Exec(`INSERT INTO cities (name, location) VALUES (?, ?);`, c.Name, &c.Location)
if err != nil {
log.Fatal(err)
}
rowsAffected, _ := result.RowsAffected()
fmt.Printf("%d rows affected", rowsAffected)
}
Output: 1 rows affected
Example (Value_different_shapes) ¶
package main
import (
"fmt"
"log"
"github.com/DATA-DOG/go-sqlmock"
"github.com/twpayne/go-geom"
"github.com/twpayne/go-geom/encoding/wkb"
"github.com/twpayne/go-geom/internal/geomtest"
)
func main() {
type Shape struct {
Name string
Geom wkb.Geom
}
db, mock, err := sqlmock.New()
if err != nil {
log.Fatal(err)
}
defer db.Close()
mock.ExpectExec(`INSERT INTO objects \(name, location\) VALUES \(\?, \?\);`).
WithArgs("Point", geomtest.MustHexDecode("0101000000000000000000F03F0000000000000040")).
WillReturnResult(sqlmock.NewResult(1, 1))
mock.ExpectExec(`INSERT INTO objects \(name, location\) VALUES \(\?, \?\);`).
WithArgs("LineString", geomtest.MustHexDecode("010200000002000000000000000000F03F000000000000004000000000000008400000000000001040")).
WillReturnResult(sqlmock.NewResult(1, 1))
mock.ExpectExec(`INSERT INTO objects \(name, location\) VALUES \(\?, \?\);`).
WithArgs("Polygon", geomtest.MustHexDecode("01030000000100000004000000000000000000F03F00000000000000400000000000000840000000000000104000000000000014400000000000001840000000000000F03F0000000000000040")).
WillReturnResult(sqlmock.NewResult(1, 1))
shapes := []Shape{
{
Name: "Point",
Geom: wkb.Geom{T: geom.NewPoint(geom.XY).MustSetCoords(geom.Coord{1, 2})},
},
{
Name: "LineString",
Geom: wkb.Geom{T: geom.NewLineString(geom.XY).MustSetCoords([]geom.Coord{{1, 2}, {3, 4}})},
},
{
Name: "Polygon",
Geom: wkb.Geom{
T: geom.NewPolygon(geom.XY).MustSetCoords([][]geom.Coord{
{{1, 2}, {3, 4}, {5, 6}, {1, 2}},
}),
},
},
}
for _, s := range shapes {
result, err := db.Exec(`INSERT INTO objects (name, location) VALUES (?, ?);`, s.Name, &s.Geom)
if err != nil {
log.Fatal(err)
}
rowsAffected, _ := result.RowsAffected()
fmt.Printf("%d rows affected\n", rowsAffected)
}
}
Output: 1 rows affected 1 rows affected 1 rows affected
Index ¶
- Variables
- func Marshal(g geom.T, byteOrder binary.ByteOrder, opts ...wkbcommon.WKBOption) ([]byte, error)
- func Read(r io.Reader, opts ...wkbcommon.WKBOption) (geom.T, error)
- func Unmarshal(data []byte, opts ...wkbcommon.WKBOption) (geom.T, error)
- func Write(w io.Writer, byteOrder binary.ByteOrder, g geom.T, opts ...wkbcommon.WKBOption) error
- type ErrExpectedByteSlice
- type Geom
- type GeometryCollection
- type LineString
- type MultiLineString
- type MultiPoint
- type MultiPolygon
- type Point
- type Polygon
Examples ¶
Constants ¶
This section is empty.
Variables ¶
View Source
var ( // XDR is big endian. XDR = wkbcommon.XDR // NDR is little endian. NDR = wkbcommon.NDR )
Functions ¶
Types ¶
type ErrExpectedByteSlice ¶
type ErrExpectedByteSlice struct {
Value interface{}
}
ErrExpectedByteSlice is returned when a []byte is expected.
func (ErrExpectedByteSlice) Error ¶
func (e ErrExpectedByteSlice) Error() string
type Geom ¶ added in v1.3.3
A Geom is a WKB-ecoded Geometry that implements the sql.Scanner and driver.Value interfaces. It can be used when the geometry shape is not defined.
type GeometryCollection ¶
type GeometryCollection struct {
*geom.GeometryCollection
// contains filtered or unexported fields
}
A GeometryCollection is a WKB-encoded GeometryCollection that implements the sql.Scanner and driver.Valuer interfaces.
func (*GeometryCollection) Scan ¶
func (gc *GeometryCollection) Scan(src interface{}) error
Scan scans from a []byte.
type LineString ¶
type LineString struct {
*geom.LineString
// contains filtered or unexported fields
}
A LineString is a WKB-encoded LineString that implements the sql.Scanner and driver.Valuer interfaces.
func (*LineString) Scan ¶
func (ls *LineString) Scan(src interface{}) error
Scan scans from a []byte.
type MultiLineString ¶
type MultiLineString struct {
*geom.MultiLineString
// contains filtered or unexported fields
}
A MultiLineString is a WKB-encoded MultiLineString that implements the sql.Scanner and driver.Valuer interfaces.
func (*MultiLineString) Scan ¶
func (mls *MultiLineString) Scan(src interface{}) error
Scan scans from a []byte.
type MultiPoint ¶
type MultiPoint struct {
*geom.MultiPoint
// contains filtered or unexported fields
}
A MultiPoint is a WKB-encoded MultiPoint that implements the sql.Scanner and driver.Valuer interfaces.
func (*MultiPoint) Scan ¶
func (mp *MultiPoint) Scan(src interface{}) error
Scan scans from a []byte.
type MultiPolygon ¶
type MultiPolygon struct {
*geom.MultiPolygon
// contains filtered or unexported fields
}
A MultiPolygon is a WKB-encoded MultiPolygon that implements the sql.Scanner and driver.Valuer interfaces.
func (*MultiPolygon) Scan ¶
func (mp *MultiPolygon) Scan(src interface{}) error
Scan scans from a []byte.
type Point ¶
A Point is a WKB-encoded Point that implements the sql.Scanner and driver.Valuer interfaces.
Source Files
Click to show internal directories.
Click to hide internal directories.