*: Geospatial support

DEPS.bzl

@@ -4192,6 +4192,21 @@ def go_deps():
         sum = "h1:mqrRot1BRxm+Yct+vavLMou2/iJt0tNVTTC0QoIjaZg=",
         version = "v1.1.6",
     )
+    go_repository(
+        name = "com_github_twpayne_go_geom",
+        build_file_proto_mode = "disable",
+        importpath = "github.com/twpayne/go-geom",
+        sum = "h1:lVzRztQgP4GvJ+VuVDv9tICZIfGFtB9uQQQa7w72Wdk=",
+        version = "v1.4.3",
+    )
+    go_repository(
+        name = "com_github_twpayne_go_kml",
+        build_file_proto_mode = "disable",
+        importpath = "github.com/twpayne/go-kml",
+        sum = "h1:rFMw2/EwgkVssGS2MT6YfWSPZz6BgcJkLxQ53jnE8rQ=",
+        version = "v1.5.2",
+    )
+
     go_repository(
         name = "com_github_uber_jaeger_client_go",
         build_file_proto_mode = "disable_global",

ddl/ddl_api.go

@@ -1159,6 +1159,9 @@ func columnDefToCol(ctx sessionctx.Context, offset int, colDef *ast.ColumnDef, o
 				ctx.GetSessionVars().StmtCtx.AppendWarning(dbterror.ErrTableCantHandleFt.GenWithStackByArgs())
 			case ast.ColumnOptionCheck:
 				ctx.GetSessionVars().StmtCtx.AppendWarning(dbterror.ErrUnsupportedConstraintCheck.GenWithStackByArgs("CONSTRAINT CHECK"))
+			case ast.ColumnOptionSrid:
+				col.AddFlag(mysql.SridFlag)
+				col.Srid = v.Srid
 			}
 		}
 	}

errno/errcode.go

@@ -894,6 +894,7 @@ const (
 	ErrCTEMaxRecursionDepth                                  = 3636
 	ErrNotHintUpdatable                                      = 3637
 	ErrExistsInHistoryPassword                               = 3638
+	ErrWrongSridForColumn                                    = 3643
 	ErrForeignKeyCannotDropParent                            = 3730
 	ErrForeignKeyCannotUseVirtualColumn                      = 3733
 	ErrForeignKeyNoColumnInParent                            = 3734

errno/errname.go

@@ -890,6 +890,7 @@ var MySQLErrName = map[uint16]*mysql.ErrMessage{
 	ErrLockAcquireFailAndNoWaitSet:                           mysql.Message("Statement aborted because lock(s) could not be acquired immediately and NOWAIT is set.", nil),
 	ErrNotHintUpdatable:                                      mysql.Message("Variable '%s' cannot be set using SET_VAR hint.", nil),
 	ErrExistsInHistoryPassword:                               mysql.Message("Cannot use these credentials for '%s@%s' because they contradict the password history policy.", nil),
+	ErrWrongSridForColumn:                                    mysql.Message("The SRID of the geometry does not match the SRID of the column '%s'. The SRID of the geometry is %d, but the SRID of the column is %d. Consider changing the SRID of the geometry or the SRID property of the column.", nil),
 	ErrForeignKeyCannotDropParent:                            mysql.Message("Cannot drop table '%s' referenced by a foreign key constraint '%s' on table '%s'.", nil),
 	ErrForeignKeyCannotUseVirtualColumn:                      mysql.Message("Foreign key '%s' uses virtual column '%s' which is not supported.", nil),
 	ErrForeignKeyNoColumnInParent:                            mysql.Message("Failed to add the foreign key constraint. Missing column '%s' for constraint '%s' in the referenced table '%s'", nil),

executor/show.go

@@ -1009,6 +1009,9 @@ func ConstructResultOfShowCreateTable(ctx sessionctx.Context, tableInfo *model.T
 				buf.WriteString(" VIRTUAL")
 			}
 		}
+		if mysql.HasSridFlag(col.GetFlag()) {
+			buf.WriteString(fmt.Sprintf(" /*!80003 SRID %d */", col.Srid))
+		}
 		if mysql.HasAutoIncrementFlag(col.GetFlag()) {
 			hasAutoIncID = true
 			buf.WriteString(" NOT NULL AUTO_INCREMENT")

expression/BUILD.bazel

@@ -17,6 +17,7 @@ go_library(
         "builtin_encryption.go",
         "builtin_encryption_vec.go",
         "builtin_func_param.go",
+        "builtin_geo.go",
         "builtin_ilike.go",
         "builtin_ilike_vec.go",
         "builtin_info.go",
@@ -118,6 +119,10 @@ go_library(
         "@com_github_pingcap_tipb//go-tipb",
         "@com_github_pkg_errors//:errors",
         "@com_github_tikv_client_go_v2//oracle",
+        "@com_github_twpayne_go_geom//:go-geom",
+        "@com_github_twpayne_go_geom//encoding/wkb",
+        "@com_github_twpayne_go_geom//encoding/wkt",
+        "@com_github_twpayne_go_geom//xy",
         "@org_golang_x_exp//slices",
         "@org_golang_x_tools//container/intsets",
         "@org_uber_go_atomic//:atomic",
@@ -142,6 +147,7 @@ go_test(
         "builtin_control_vec_generated_test.go",
         "builtin_encryption_test.go",
         "builtin_encryption_vec_test.go",
+        "builtin_geo_test.go",
         "builtin_ilike_test.go",
         "builtin_info_test.go",
         "builtin_info_vec_test.go",

expression/builtin.go

@@ -907,6 +907,11 @@ var funcs = map[string]functionClass{
 	ast.NextVal: &nextValFunctionClass{baseFunctionClass{ast.NextVal, 1, 1}},
 	ast.LastVal: &lastValFunctionClass{baseFunctionClass{ast.LastVal, 1, 1}},
 	ast.SetVal:  &setValFunctionClass{baseFunctionClass{ast.SetVal, 2, 2}},
+
+	// Geospatial function.
+	ast.StGeomFromText: &stGeomFromTextFunctionClass{baseFunctionClass{ast.StGeomFromText, 1, -1}},
+	ast.StAsText:       &stAsTextFunctionClass{baseFunctionClass{ast.StAsText, 1, 1}},
+	ast.StDistance:     &stDistanceFunctionClass{baseFunctionClass{ast.StDistance, 1, 2}},
 }
 
 // IsFunctionSupported check if given function name is a builtin sql function.

expression/builtin_geo.go

@@ -0,0 +1,208 @@
+// Copyright 2022 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package expression
+
+import (
+	"bytes"
+	"encoding/binary"
+
+	"github.com/pingcap/errors"
+	"github.com/pingcap/tidb/sessionctx"
+	"github.com/pingcap/tidb/types"
+	"github.com/pingcap/tidb/util/chunk"
+	"github.com/twpayne/go-geom"
+	"github.com/twpayne/go-geom/encoding/wkb"
+	"github.com/twpayne/go-geom/encoding/wkt"
+	"github.com/twpayne/go-geom/xy"
+)
+
+var (
+	_ functionClass = &stAsTextFunctionClass{}
+	_ functionClass = &stDistanceFunctionClass{}
+	_ functionClass = &stGeomFromTextFunctionClass{}
+)
+
+var (
+	_ builtinFunc = &builtinStAsTextSig{}
+	_ builtinFunc = &builtinStDistanceSig{}
+	_ builtinFunc = &builtinStGeomFromTextSig{}
+)
+
+type stGeomFromTextFunctionClass struct {
+	baseFunctionClass
+}
+
+func (c *stGeomFromTextFunctionClass) getFunction(ctx sessionctx.Context, args []Expression) (builtinFunc, error) {
+	if err := c.verifyArgs(args); err != nil {
+		return nil, err
+	}
+	if len(args) > 2 {
+		return nil, ErrIncorrectParameterCount.GenWithStackByArgs(c.funcName)
+	}
+	argTps := make([]types.EvalType, 0, len(args))
+	for i := 0; i < len(args); i++ {
+		argTps = append(argTps, types.ETString)
+	}
+	bf, err := newBaseBuiltinFuncWithTp(ctx, c.funcName, args, types.ETString, argTps...)
+	if err != nil {
+		return nil, err
+	}
+	types.SetBinChsClnFlag(bf.tp)
+	sig := &builtinStGeomFromTextSig{bf}
+	return sig, nil
+}
+
+type builtinStGeomFromTextSig struct {
+	baseBuiltinFunc
+}
+
+func (b *builtinStGeomFromTextSig) Clone() builtinFunc {
+	newSig := &builtinStGeomFromTextSig{}
+	newSig.cloneFrom(&b.baseBuiltinFunc)
+	return newSig
+}
+
+// ST_GeomFromText(wkt) -> geom.
+// geom = <encoded_srid><wkb>, Compatible with MySQL 8.0
+func (b *builtinStGeomFromTextSig) evalString(row chunk.Row) (string, bool, error) {
+	wktVal, isNull, err := b.args[0].EvalString(b.ctx, row)
+	if isNull || err != nil {
+		return "", isNull, err
+	}
+	var srid int64 = 0
+	if len(b.args) == 2 {
+		srid, _, err = b.args[1].EvalInt(b.ctx, row)
+		if err != nil {
+			return "", isNull, err
+		}
+	}
+	g, err := wkt.Unmarshal(wktVal)
+	if err != nil {
+		return "", isNull, err
+	}
+	wkbVal, err := wkb.Marshal(g, binary.LittleEndian)
+	if err != nil {
+		return "", isNull, err
+	}
+	buf := new(bytes.Buffer)
+	err = binary.Write(buf, binary.LittleEndian, int32(srid))
+	if err != nil {
+		return "", isNull, err
+	}
+	return string(append(buf.Bytes(), wkbVal...)), false, nil
+}
+
+type stAsTextFunctionClass struct {
+	baseFunctionClass
+}
+
+func (c *stAsTextFunctionClass) getFunction(ctx sessionctx.Context, args []Expression) (builtinFunc, error) {
+	if err := c.verifyArgs(args); err != nil {
+		return nil, err
+	}
+	bf, err := newBaseBuiltinFuncWithTp(ctx, c.funcName, args, types.ETString, types.ETString)
+	if err != nil {
+		return nil, err
+	}
+	sig := &builtinStAsTextSig{bf}
+	return sig, nil
+}
+
+type builtinStAsTextSig struct {
+	baseBuiltinFunc
+}
+
+func (b *builtinStAsTextSig) Clone() builtinFunc {
+	newSig := &builtinStAsTextSig{}
+	newSig.cloneFrom(&b.baseBuiltinFunc)
+	return newSig
+}
+
+// ST_AsText(geom) -> wkt
+func (b *builtinStAsTextSig) evalString(row chunk.Row) (string, bool, error) {
+	wkbValRaw, isNull, err := b.args[0].EvalString(b.ctx, row)
+	if isNull || err != nil {
+		return "", isNull, err
+	}
+	wkbVal := wkbValRaw[4:]
+
+	g, err := wkb.Unmarshal([]byte(wkbVal))
+	if err != nil {
+		return "", isNull, err
+	}
+	wktVal, err := wkt.Marshal(g)
+	if err != nil {
+		return "", isNull, err
+	}
+	return wktVal, false, nil
+}
+
+type stDistanceFunctionClass struct {
+	baseFunctionClass
+}
+
+func (c *stDistanceFunctionClass) getFunction(ctx sessionctx.Context, args []Expression) (builtinFunc, error) {
+	if err := c.verifyArgs(args); err != nil {
+		return nil, err
+	}
+	bf, err := newBaseBuiltinFuncWithTp(ctx, c.funcName, args, types.ETReal, types.ETString, types.ETString)
+	if err != nil {
+		return nil, err
+	}
+	sig := &builtinStDistanceSig{bf}
+	return sig, nil
+}
+
+type builtinStDistanceSig struct {
+	baseBuiltinFunc
+}
+
+func (b *builtinStDistanceSig) Clone() builtinFunc {
+	newSig := &builtinStDistanceSig{}
+	newSig.cloneFrom(&b.baseBuiltinFunc)
+	return newSig
+}
+
+// ST_Distance(geom, geom) -> distance
+// Only supports SRID 0 for now, result is in degrees
+func (b *builtinStDistanceSig) evalReal(row chunk.Row) (float64, bool, error) {
+	g1r, isNull, err := b.args[0].EvalString(b.ctx, row)
+	if isNull || err != nil {
+		return 0, isNull, err
+	}
+	g2r, _, err := b.args[1].EvalString(b.ctx, row)
+	if isNull || err != nil {
+		return 0, isNull, err
+	}
+	g1, err := wkb.Unmarshal([]byte(g1r[4:]))
+	if err != nil {
+		return 0, isNull, err
+	}
+	g2, err := wkb.Unmarshal([]byte(g2r[4:]))
+	if err != nil {
+		return 0, isNull, err
+	}
+	g1srid := int(binary.LittleEndian.Uint32([]byte(g1r[:4])))
+	g2srid := int(binary.LittleEndian.Uint32([]byte(g2r[:4])))
+	if g1srid != g2srid {
+		return 0, isNull, errors.New("SRID mismatch")
+	}
+	if g1srid != 0 {
+		return 0, isNull, errors.New("Distance only supported for SRID 0")
+	}
+	g1p := geom.NewPoint(g1.Layout()).MustSetCoords(g1.FlatCoords()).SetSRID(g1srid)
+	g2p := geom.NewPoint(g2.Layout()).MustSetCoords(g2.FlatCoords()).SetSRID(g2srid)
+	return xy.Distance(g1p.Coords(), g2p.Coords()), false, nil
+}