From 5c44a272b9a6c98da8224314adff2af6a9d2b639 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Thu, 9 Dec 2021 15:58:36 -0800
Subject: [PATCH 01/51] added geometry type information

---
 .../doltcore/schema/typeinfo/geometry.go      | 207 ++++++++++++++++++
 .../doltcore/schema/typeinfo/typeinfo.go      |   6 +
 2 files changed, 213 insertions(+)
 create mode 100644 go/libraries/doltcore/schema/typeinfo/geometry.go

diff --git a/go/libraries/doltcore/schema/typeinfo/geometry.go b/go/libraries/doltcore/schema/typeinfo/geometry.go
new file mode 100644
index 0000000000..37c4bf100c
--- /dev/null
+++ b/go/libraries/doltcore/schema/typeinfo/geometry.go
@@ -0,0 +1,207 @@
+// Copyright 2020 Dolthub, 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 typeinfo
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/dolthub/go-mysql-server/sql"
+
+	"github.com/dolthub/dolt/go/store/types"
+)
+
+// This is a dolt implementation of the MySQL type Geometry, thus most of the functionality
+// within is directly reliant on the go-mysql-server implementation.
+type geometryType struct {
+	sqlGeometryType sql.GeometryType
+}
+
+var _ TypeInfo = (*geometryType)(nil)
+
+var GeometryType = &geometryType{sql.Geometry}
+
+// ConvertNomsValueToValue implements TypeInfo interface.
+func (ti *geometryType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
+	if val, ok := v.(types.Int); ok {
+		return int16(val), nil
+	}
+	if _, ok := v.(types.Null); ok || v == nil {
+		return nil, nil
+	}
+	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), v.Kind())
+}
+
+// ReadFrom reads a go value from a noms types.CodecReader directly
+func (ti *geometryType) ReadFrom(_ *types.NomsBinFormat, reader types.CodecReader) (interface{}, error) {
+	k := reader.ReadKind()
+	switch k {
+	case types.IntKind:
+		val := reader.ReadInt()
+		return int16(val), nil
+	case types.NullKind:
+		return nil, nil
+	}
+
+	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), k)
+}
+
+// ConvertValueToNomsValue implements TypeInfo interface.
+func (ti *geometryType) ConvertValueToNomsValue(ctx context.Context, vrw types.ValueReadWriter, v interface{}) (types.Value, error) {
+	if v == nil {
+		return types.NullValue, nil
+	}
+	intVal, err := ti.sqlGeometryType.Convert(v)
+	if err != nil {
+		return nil, err
+	}
+	val, ok := intVal.(int16)
+	if ok {
+		return types.Int(val), nil
+	}
+	return nil, fmt.Errorf(`"%v" has unexpectedly encountered a value of type "%T" from embedded type`, ti.String(), v)
+}
+
+// Equals implements TypeInfo interface.
+func (ti *geometryType) Equals(other TypeInfo) bool {
+	if other == nil {
+		return false
+	}
+	_, ok := other.(*geometryType)
+	return ok
+}
+
+// FormatValue implements TypeInfo interface.
+func (ti *geometryType) FormatValue(v types.Value) (*string, error) {
+	if val, ok := v.(types.Int); ok {
+		convVal, err := ti.ConvertNomsValueToValue(val)
+		if err != nil {
+			return nil, err
+		}
+		val, ok := convVal.(int16)
+		if !ok {
+			return nil, fmt.Errorf(`"%v" has unexpectedly encountered a value of type "%T" from embedded type`, ti.String(), v)
+		}
+		res := strconv.FormatInt(int64(val), 10)
+		return &res, nil
+	}
+	if _, ok := v.(types.Null); ok || v == nil {
+		return nil, nil
+	}
+	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a string`, ti.String(), v.Kind())
+}
+
+// GetTypeIdentifier implements TypeInfo interface.
+func (ti *geometryType) GetTypeIdentifier() Identifier {
+	return GeometryTypeIdentifier
+}
+
+// GetTypeParams implements TypeInfo interface.
+func (ti *geometryType) GetTypeParams() map[string]string {
+	return nil
+}
+
+// IsValid implements TypeInfo interface.
+func (ti *geometryType) IsValid(v types.Value) bool {
+	if val, ok := v.(types.Int); ok {
+		_, err := ti.sqlGeometryType.Convert(int64(val))
+		if err != nil {
+			return false
+		}
+		return true
+	}
+	if _, ok := v.(types.Null); ok || v == nil {
+		return true
+	}
+	return false
+}
+
+// NomsKind implements TypeInfo interface.
+func (ti *geometryType) NomsKind() types.NomsKind {
+	return types.IntKind
+}
+
+// ParseValue implements TypeInfo interface.
+func (ti *geometryType) ParseValue(ctx context.Context, vrw types.ValueReadWriter, str *string) (types.Value, error) {
+	if str == nil || *str == "" {
+		return types.NullValue, nil
+	}
+	intVal, err := ti.sqlGeometryType.Convert(*str)
+	if err != nil {
+		return nil, err
+	}
+	if val, ok := intVal.(int16); ok {
+		return types.Int(val), nil
+	}
+	return nil, fmt.Errorf(`"%v" cannot convert the string "%v" to a value`, ti.String(), str)
+}
+
+// Promote implements TypeInfo interface.
+func (ti *geometryType) Promote() TypeInfo {
+	return &geometryType{ti.sqlGeometryType.Promote().(sql.GeometryType)}
+}
+
+// String implements TypeInfo interface.
+func (ti *geometryType) String() string {
+	return "Geometry"
+}
+
+// ToSqlType implements TypeInfo interface.
+func (ti *geometryType) ToSqlType() sql.Type {
+	return ti.sqlGeometryType
+}
+
+// geometryTypeConverter is an internal function for GetTypeConverter that handles the specific type as the source TypeInfo.
+func geometryTypeConverter(ctx context.Context, src *geometryType, destTi TypeInfo) (tc TypeConverter, needsConversion bool, err error) {
+	switch dest := destTi.(type) {
+	case *bitType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *blobStringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *boolType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *datetimeType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *decimalType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *enumType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *floatType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *inlineBlobType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *intType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *jsonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *setType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *timeType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *uintType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *uuidType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *varBinaryType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *varStringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *geometryType:
+		return identityTypeConverter, false, nil
+	default:
+		return nil, false, UnhandledTypeConversion.New(src.String(), destTi.String())
+	}
+}
diff --git a/go/libraries/doltcore/schema/typeinfo/typeinfo.go b/go/libraries/doltcore/schema/typeinfo/typeinfo.go
index cecee115d9..517f76bf8a 100644
--- a/go/libraries/doltcore/schema/typeinfo/typeinfo.go
+++ b/go/libraries/doltcore/schema/typeinfo/typeinfo.go
@@ -47,6 +47,7 @@ const (
 	VarBinaryTypeIdentifier  Identifier = "varbinary"
 	VarStringTypeIdentifier  Identifier = "varstring"
 	YearTypeIdentifier       Identifier = "year"
+	GeometryTypeIdentifier   Identifier = "geometry"
 )
 
 var Identifiers = map[Identifier]struct{}{
@@ -69,6 +70,7 @@ var Identifiers = map[Identifier]struct{}{
 	VarBinaryTypeIdentifier:  {},
 	VarStringTypeIdentifier:  {},
 	YearTypeIdentifier:       {},
+	GeometryTypeIdentifier:   {},
 }
 
 // TypeInfo is an interface used for encoding type information.
@@ -158,6 +160,8 @@ func FromSqlType(sqlType sql.Type) (TypeInfo, error) {
 		return DatetimeType, nil
 	case sqltypes.Year:
 		return YearType, nil
+	case sqltypes.Geometry:
+		return GeometryType, nil
 	case sqltypes.Decimal:
 		decimalSQLType, ok := sqlType.(sql.DecimalType)
 		if !ok {
@@ -268,6 +272,8 @@ func FromTypeParams(id Identifier, params map[string]string) (TypeInfo, error) {
 		return CreateVarStringTypeFromParams(params)
 	case YearTypeIdentifier:
 		return YearType, nil
+	case GeometryTypeIdentifier:
+		return GeometryType, nil
 	default:
 		return nil, fmt.Errorf(`"%v" cannot be made from an identifier and params`, id)
 	}

From a87eb739c83f8fe0be366f3ff23853c04a52875c Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Tue, 14 Dec 2021 16:00:39 -0800
Subject: [PATCH 02/51] added geometry type to everything

---
 .../doltcore/schema/typeinfo/geometry.go      |  99 +++++-----
 .../sqle/geometry/noms_geometry_value.go      | 142 ++++++++++++++
 go/libraries/doltcore/sqle/sqlutil/sql_row.go |   8 +-
 go/store/types/geometry.go                    | 185 ++++++++++++++++++
 go/store/types/noms_kind.go                   |   4 +
 go/store/types/value_decoder.go               |   5 +
 6 files changed, 390 insertions(+), 53 deletions(-)
 create mode 100644 go/libraries/doltcore/sqle/geometry/noms_geometry_value.go
 create mode 100644 go/store/types/geometry.go

diff --git a/go/libraries/doltcore/schema/typeinfo/geometry.go b/go/libraries/doltcore/schema/typeinfo/geometry.go
index 37c4bf100c..7b8ced1e45 100644
--- a/go/libraries/doltcore/schema/typeinfo/geometry.go
+++ b/go/libraries/doltcore/schema/typeinfo/geometry.go
@@ -17,7 +17,7 @@ package typeinfo
 import (
 	"context"
 	"fmt"
-	"strconv"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/geometry"
 
 	"github.com/dolthub/go-mysql-server/sql"
 
@@ -27,17 +27,16 @@ import (
 // This is a dolt implementation of the MySQL type Geometry, thus most of the functionality
 // within is directly reliant on the go-mysql-server implementation.
 type geometryType struct {
-	sqlGeometryType sql.GeometryType
+	geometryType sql.GeometryType
 }
 
 var _ TypeInfo = (*geometryType)(nil)
-
 var GeometryType = &geometryType{sql.Geometry}
 
 // ConvertNomsValueToValue implements TypeInfo interface.
 func (ti *geometryType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
-	if val, ok := v.(types.Int); ok {
-		return int16(val), nil
+	if val, ok := v.(types.Geometry); ok {
+		return geometry.NomsGeometry(val), nil
 	}
 	if _, ok := v.(types.Null); ok || v == nil {
 		return nil, nil
@@ -49,9 +48,12 @@ func (ti *geometryType) ConvertNomsValueToValue(v types.Value) (interface{}, err
 func (ti *geometryType) ReadFrom(_ *types.NomsBinFormat, reader types.CodecReader) (interface{}, error) {
 	k := reader.ReadKind()
 	switch k {
-	case types.IntKind:
-		val := reader.ReadInt()
-		return int16(val), nil
+	case types.GeometryKind:
+		gs, err := reader.ReadGeometry()
+		if err != nil {
+			return nil, err
+		}
+		return geometry.NomsGeometry(gs), nil
 	case types.NullKind:
 		return nil, nil
 	}
@@ -64,44 +66,44 @@ func (ti *geometryType) ConvertValueToNomsValue(ctx context.Context, vrw types.V
 	if v == nil {
 		return types.NullValue, nil
 	}
-	intVal, err := ti.sqlGeometryType.Convert(v)
+
+	gsObj, err := ti.geometryType.Convert(v)
 	if err != nil {
 		return nil, err
 	}
-	val, ok := intVal.(int16)
-	if ok {
-		return types.Int(val), nil
+
+	gsVal, ok := gsObj.(sql.GeometryValue)
+	if !ok {
+		return nil, fmt.Errorf(`"%v" cannot convert value "%v" of type "%T" as it is invalid`, ti.String(), v, v)
 	}
-	return nil, fmt.Errorf(`"%v" has unexpectedly encountered a value of type "%T" from embedded type`, ti.String(), v)
+
+	noms, err := geometry.NomsGeometryFromGeometryValue(ctx, vrw, gsVal)
+	if err != nil {
+		return nil, err
+	}
+
+	return types.Geometry(noms), err
 }
 
 // Equals implements TypeInfo interface.
 func (ti *geometryType) Equals(other TypeInfo) bool {
-	if other == nil {
-		return false
-	}
-	_, ok := other.(*geometryType)
-	return ok
+	return ti.GetTypeIdentifier() == other.GetTypeIdentifier()
 }
 
 // FormatValue implements TypeInfo interface.
 func (ti *geometryType) FormatValue(v types.Value) (*string, error) {
-	if val, ok := v.(types.Int); ok {
-		convVal, err := ti.ConvertNomsValueToValue(val)
-		if err != nil {
-			return nil, err
-		}
-		val, ok := convVal.(int16)
-		if !ok {
-			return nil, fmt.Errorf(`"%v" has unexpectedly encountered a value of type "%T" from embedded type`, ti.String(), v)
-		}
-		res := strconv.FormatInt(int64(val), 10)
-		return &res, nil
-	}
 	if _, ok := v.(types.Null); ok || v == nil {
 		return nil, nil
 	}
-	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a string`, ti.String(), v.Kind())
+
+	if noms, ok := v.(types.Geometry); ok {
+		s, err := geometry.NomsGeometry(noms).ToString(sql.NewEmptyContext())
+		if err != nil {
+			return nil, err
+		}
+		return &s, nil
+	}
+	return nil, fmt.Errorf(`"%v" has unexpectedly encountered a value of type "%T" from embedded type`, ti.String(), v)
 }
 
 // GetTypeIdentifier implements TypeInfo interface.
@@ -116,42 +118,35 @@ func (ti *geometryType) GetTypeParams() map[string]string {
 
 // IsValid implements TypeInfo interface.
 func (ti *geometryType) IsValid(v types.Value) bool {
-	if val, ok := v.(types.Int); ok {
-		_, err := ti.sqlGeometryType.Convert(int64(val))
-		if err != nil {
-			return false
-		}
+	if v == nil {
 		return true
 	}
-	if _, ok := v.(types.Null); ok || v == nil {
+	switch v.(type) {
+	case types.Geometry:
 		return true
+	case types.Null:
+		return true
+	default:
+		return false
 	}
-	return false
 }
 
 // NomsKind implements TypeInfo interface.
 func (ti *geometryType) NomsKind() types.NomsKind {
-	return types.IntKind
+	return types.GeometryKind
 }
 
 // ParseValue implements TypeInfo interface.
 func (ti *geometryType) ParseValue(ctx context.Context, vrw types.ValueReadWriter, str *string) (types.Value, error) {
-	if str == nil || *str == "" {
+	if str == nil {
 		return types.NullValue, nil
 	}
-	intVal, err := ti.sqlGeometryType.Convert(*str)
-	if err != nil {
-		return nil, err
-	}
-	if val, ok := intVal.(int16); ok {
-		return types.Int(val), nil
-	}
-	return nil, fmt.Errorf(`"%v" cannot convert the string "%v" to a value`, ti.String(), str)
+	return ti.ConvertValueToNomsValue(ctx, vrw, *str)
 }
 
 // Promote implements TypeInfo interface.
 func (ti *geometryType) Promote() TypeInfo {
-	return &geometryType{ti.sqlGeometryType.Promote().(sql.GeometryType)}
+	return &geometryType{ti.geometryType.Promote().(sql.GeometryType)}
 }
 
 // String implements TypeInfo interface.
@@ -161,7 +156,7 @@ func (ti *geometryType) String() string {
 
 // ToSqlType implements TypeInfo interface.
 func (ti *geometryType) ToSqlType() sql.Type {
-	return ti.sqlGeometryType
+	return ti.geometryType
 }
 
 // geometryTypeConverter is an internal function for GetTypeConverter that handles the specific type as the source TypeInfo.
@@ -185,6 +180,8 @@ func geometryTypeConverter(ctx context.Context, src *geometryType, destTi TypeIn
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *intType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *geometryType:
+		return wrapIsValid(dest.IsValid, src, dest)
 	case *jsonType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
@@ -199,8 +196,6 @@ func geometryTypeConverter(ctx context.Context, src *geometryType, destTi TypeIn
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *varStringType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
-	case *geometryType:
-		return identityTypeConverter, false, nil
 	default:
 		return nil, false, UnhandledTypeConversion.New(src.String(), destTi.String())
 	}
diff --git a/go/libraries/doltcore/sqle/geometry/noms_geometry_value.go b/go/libraries/doltcore/sqle/geometry/noms_geometry_value.go
new file mode 100644
index 0000000000..38185185fb
--- /dev/null
+++ b/go/libraries/doltcore/sqle/geometry/noms_geometry_value.go
@@ -0,0 +1,142 @@
+// Copyright 2021 Dolthub, 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 geometry
+
+import (
+	"context"
+	"errors"
+	"strings"
+
+	"github.com/dolthub/go-mysql-server/sql"
+
+	"github.com/dolthub/dolt/go/store/types"
+)
+
+var ErrUnexpectedGeometryTypeIn = errors.New("unexpected type during Geometry marshalling")
+var ErrUnexpectedGeometryTypeOut = errors.New("unexpected type during Geometry unmarshalling")
+
+const (
+	GeometryNull = "null"
+)
+
+// NomsGeometry is a type alias for types.Geometry. The alias allows MySQL-specific
+// logic to be kept separate from the storage-layer code in pkg types.
+type NomsGeometry types.Geometry
+
+var _ sql.GeometryValue = NomsGeometry{}
+
+// NomsGeometryFromGeometryValue converts a sql.GeometryValue to a NomsGeometry value.
+func NomsGeometryFromGeometryValue(ctx context.Context, vrw types.ValueReadWriter, val sql.GeometryValue) (NomsGeometry, error) {
+	if noms, ok := val.(NomsGeometry); ok {
+		return noms, nil
+	}
+
+	sqlObj, err := val.Unmarshall(sql.NewContext(ctx))
+	if err != nil {
+		return NomsGeometry{}, err
+	}
+
+	v, err := marshalGeometry(ctx, vrw, sqlObj.Val)
+	if err != nil {
+		return NomsGeometry{}, err
+	}
+
+	obj, err := types.NewGeometryObj(vrw.Format(), vrw, v)
+	if err != nil {
+		return NomsGeometry{}, err
+	}
+
+	return NomsGeometry(obj), nil
+}
+
+// marshalGeometry converts primitive interfaces to something from types package
+func marshalGeometry(ctx context.Context, vrw types.ValueReadWriter, val interface{}) (types.Value, error) {
+	if val == nil {
+		return types.NullValue, nil
+	}
+
+	// TODO: how is this supposed to work? Everything under geometry is multiple values?
+	switch val := val.(type) {
+	case bool: // TODO: this is impossible?
+		return types.Bool(val), nil
+	default:
+		return nil, ErrUnexpectedGeometryTypeIn
+	}
+}
+
+// Unmarshall implements the sql.Geometry interface.
+func (v NomsGeometry) Unmarshall(ctx *sql.Context) (doc sql.GeometryObject, err error) {
+	nomsVal, err := types.Geometry(v).Inner()
+	if err != nil {
+		return sql.GeometryObject{}, err
+	}
+
+	val, err := unmarshalGeometry(nomsVal)
+	if err != nil {
+		return sql.GeometryObject{}, err
+	}
+
+	return sql.GeometryObject{Val: val}, nil
+}
+
+func unmarshalGeometry(val types.Value) (interface{}, error) {
+	//switch val := val.(type) {
+	switch val.(type) {
+	case types.Null:
+		return nil, nil
+	default:
+		return nil, ErrUnexpectedGeometryTypeIn
+	}
+}
+
+// Compare implements the sql.GeometryValue interface.
+func (v NomsGeometry) Compare(ctx *sql.Context, other sql.GeometryValue) (cmp int, err error) {
+	noms, ok := other.(NomsGeometry)
+	if !ok {
+		doc, err := v.Unmarshall(ctx)
+		if err != nil {
+			return 0, err
+		}
+		return doc.Compare(ctx, other)
+	}
+
+	return types.Geometry(v).Compare(types.Geometry(noms))
+}
+
+// ToString implements the sql.GeometryValue interface.
+func (v NomsGeometry) ToString(ctx *sql.Context) (string, error) {
+	jd, err := types.Geometry(v).Inner()
+	if err != nil {
+		return "", err
+	}
+
+	sb := &strings.Builder{}
+	if err = marshalToString(ctx, sb, jd); err != nil {
+		return "", err
+	}
+
+	return sb.String(), nil
+}
+
+func marshalToString(ctx context.Context, sb *strings.Builder, val types.Value) (err error) {
+	//switch val := val.(type) {
+	switch val.(type) {
+	case types.Null:
+		sb.WriteString(GeometryNull)
+	default:
+		err = ErrUnexpectedGeometryTypeOut
+	}
+	return
+}
diff --git a/go/libraries/doltcore/sqle/sqlutil/sql_row.go b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
index 0900baf96f..2d0c8f0ad4 100644
--- a/go/libraries/doltcore/sqle/sqlutil/sql_row.go
+++ b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
@@ -302,6 +302,12 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 			}
 		case time.Time:
 			return typedCol.Format("2006-01-02 15:04:05.999999 -0700 MST")
+		case sql.PointValue:
+			s, err := typedCol.ToString(sql.NewContext(ctx)) // TODO: do I need sql.NewContext()
+			if err != nil {
+				s = err.Error()
+			}
+			return s
 		case sql.JSONValue:
 			s, err := typedCol.ToString(sql.NewContext(ctx))
 			if err != nil {
@@ -309,7 +315,7 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 			}
 			return s
 		default:
-			return fmt.Sprintf("%v", typedCol)
+			return fmt.Sprintf("no match: %v", typedCol)
 		}
 	}
 
diff --git a/go/store/types/geometry.go b/go/store/types/geometry.go
new file mode 100644
index 0000000000..6e5e978ceb
--- /dev/null
+++ b/go/store/types/geometry.go
@@ -0,0 +1,185 @@
+// Copyright 2019 Dolthub, 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.
+//
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//
+// Copyright 2016 Attic Labs, Inc. All rights reserved.
+// Licensed under the Apache License, version 2.0:
+// http://www.apache.org/licenses/LICENSE-2.0
+
+package types
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/dolthub/dolt/go/store/d"
+
+	"github.com/dolthub/dolt/go/store/hash"
+)
+
+type Geometry struct {
+	valueImpl
+}
+
+// NewGeometryObj wraps value in a Geometry value.
+func NewGeometryObj(nbf *NomsBinFormat, vrw ValueReadWriter, value Value) (Geometry, error) {
+	w := newBinaryNomsWriter()
+	if err := GeometryKind.writeTo(&w, nbf); err != nil {
+		return EmptyGeometryObj(nbf), err
+	}
+
+	if err := value.writeTo(&w, nbf); err != nil {
+		return EmptyGeometryObj(nbf), err
+	}
+
+	return Geometry{valueImpl{vrw, nbf, w.data(), nil}}, nil
+}
+
+// EmptyGeometryObj creates an empty Geometry value.
+func EmptyGeometryObj(nbf *NomsBinFormat) Geometry {
+	w := newBinaryNomsWriter()
+	if err := GeometryKind.writeTo(&w, nbf); err != nil {
+		d.PanicIfError(err)
+	}
+
+	return Geometry{valueImpl{nil, nbf, w.data(), nil}}
+}
+
+// readGeometry reads the data provided by a decoder and moves the decoder forward.
+func readGeometry(nbf *NomsBinFormat, dec *valueDecoder) (Geometry, error) {
+	start := dec.pos()
+
+	k := dec.PeekKind()
+	if k == NullKind {
+		dec.skipKind()
+		return EmptyGeometryObj(nbf), nil
+	}
+	if k != GeometryKind {
+		return Geometry{}, errors.New("current value is not a Geometry")
+	}
+
+	if err := skipJSON(nbf, dec); err != nil {
+		return Geometry{}, err
+	}
+
+	end := dec.pos()
+	return Geometry{valueImpl{dec.vrw, nbf, dec.byteSlice(start, end), nil}}, nil
+}
+
+// Value implements the Value interface
+func (v Geometry) Value(ctx context.Context) (Value, error) {
+	return v, nil
+}
+
+// Inner returns the Geometry value's inner value.
+func (v Geometry) Inner() (Value, error) {
+	dec := newValueDecoder(v.buff, v.vrw)
+	dec.skipKind()
+	return dec.readValue(v.nbf)
+}
+
+// Equals implements the Value interface
+func (v Geometry) Equals(other Value) bool {
+	return other == nil || other.Kind() == GeometryKind
+}
+
+// Hash implements the Value interface
+func (v Geometry) Hash(nbf *NomsBinFormat) (hash.Hash, error) {
+	return getHash(NullValue, nbf)
+}
+
+// isPrimitive implements the Value interface
+func (v Geometry) isPrimitive() bool {
+	return false
+}
+
+// WalkValues implements the Value interface
+func (v Geometry) WalkValues(ctx context.Context, cb ValueCallback) error {
+	return nil
+}
+
+// WalkRefs implements the Value interface
+func (v Geometry) WalkRefs(nbf *NomsBinFormat, cb RefCallback) error {
+	return nil
+}
+
+func compareGeometry(a, b Value) (int, error) {
+	aNull := a.Kind() == NullKind
+	bNull := b.Kind() == NullKind
+	if aNull && bNull {
+		return 0, nil
+	} else if aNull && !bNull {
+		return -1, nil
+	} else if !aNull && bNull {
+		return 1, nil
+	}
+
+	switch a := a.(type) {
+	default:
+		return 0, fmt.Errorf("unexpected type: %v", a)
+	}
+}
+
+// Compare implements MySQL Geometry type compare semantics.
+func (t Geometry) Compare(other Geometry) (int, error) {
+	left, err := t.Inner()
+	if err != nil {
+		return 0, err
+	}
+
+	right, err := other.Inner()
+	if err != nil {
+		return 0, err
+	}
+
+	return compareGeometry(left, right)
+}
+
+// HumanReadableString implements the Value interface
+func (v Geometry) HumanReadableString() string {
+	val, err := v.Inner()
+	if err != nil {
+		d.PanicIfError(err)
+	}
+	h, err := val.Hash(v.nbf)
+	if err != nil {
+		d.PanicIfError(err)
+	}
+	return fmt.Sprintf("Geometry(%s)", h.String())
+}
+
+func (v Geometry) typeOf() (*Type, error) {
+	return PrimitiveTypeMap[GeometryKind], nil
+}
+
+// Kind implements the Valuable interface.
+func (v Geometry) Kind() NomsKind {
+	return GeometryKind
+}
+
+func (v Geometry) valueReadWriter() ValueReadWriter {
+	return nil
+}
+
+func (v Geometry) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
+	return GeometryKind.writeTo(w, nbf)
+}
+
+func (v Geometry) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
+	return NullValue, nil
+}
+
+func (v Geometry) skip(nbf *NomsBinFormat, b *binaryNomsReader) {}
diff --git a/go/store/types/noms_kind.go b/go/store/types/noms_kind.go
index 499c8a1830..72eb1b1015 100644
--- a/go/store/types/noms_kind.go
+++ b/go/store/types/noms_kind.go
@@ -56,6 +56,7 @@ const (
 	TimestampKind
 	DecimalKind
 	JSONKind
+	GeometryKind
 
 	UnknownKind NomsKind = 255
 )
@@ -83,6 +84,7 @@ func init() {
 	KindToType[TimestampKind] = Timestamp{}
 	KindToType[DecimalKind] = Decimal{}
 	KindToType[JSONKind] = JSON{}
+	KindToType[GeometryKind] = Geometry{}
 
 	SupportedKinds[BlobKind] = true
 	SupportedKinds[BoolKind] = true
@@ -106,6 +108,7 @@ func init() {
 	SupportedKinds[TimestampKind] = true
 	SupportedKinds[DecimalKind] = true
 	SupportedKinds[JSONKind] = true
+	SupportedKinds[GeometryKind] = true
 }
 
 var KindToTypeSlice []Value
@@ -134,6 +137,7 @@ var KindToString = map[NomsKind]string{
 	TimestampKind:  "Timestamp",
 	DecimalKind:    "Decimal",
 	JSONKind:       "JSON",
+	GeometryKind:       "Geometry",
 }
 
 // String returns the name of the kind.
diff --git a/go/store/types/value_decoder.go b/go/store/types/value_decoder.go
index ea9b0ddcee..9f8fe1a1b9 100644
--- a/go/store/types/value_decoder.go
+++ b/go/store/types/value_decoder.go
@@ -48,6 +48,7 @@ type CodecReader interface {
 	ReadDecimal() (decimal.Decimal, error)
 	ReadBlob() (Blob, error)
 	ReadJSON() (JSON, error)
+	ReadGeometry() (Geometry, error)
 }
 
 var _ CodecReader = (*valueDecoder)(nil)
@@ -84,6 +85,10 @@ func (r *valueDecoder) ReadJSON() (JSON, error) {
 	return readJSON(r.vrw.Format(), r)
 }
 
+func (r *valueDecoder) ReadGeometry() (Geometry, error) {
+	return readGeometry(r.vrw.Format(), r)
+}
+
 func (r *valueDecoder) readRef(nbf *NomsBinFormat) (Ref, error) {
 	return readRef(nbf, &(r.typedBinaryNomsReader))
 }

From c26ab41bd7048f5c207031b5364a632ca6fc4ebb Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Wed, 15 Dec 2021 15:15:43 -0800
Subject: [PATCH 03/51] can make point and point col and add not sure how it
 works

---
 .../doltcore/schema/typeinfo/geometry.go      |  13 +-
 .../doltcore/schema/typeinfo/point.go         | 158 ++++++++++++++++++
 .../doltcore/schema/typeinfo/typeinfo.go      |   8 +-
 .../sqle/geometry/noms_geometry_value.go      |   5 +-
 go/libraries/doltcore/sqle/sqlutil/sql_row.go |   2 +-
 go/store/types/geometry.go                    |  10 +-
 go/store/types/noms_kind.go                   |   4 +-
 go/store/types/point.go                       |  99 +++++++++++
 go/store/types/value_decoder.go               |   8 +-
 9 files changed, 285 insertions(+), 22 deletions(-)
 create mode 100644 go/libraries/doltcore/schema/typeinfo/point.go
 create mode 100644 go/store/types/point.go

diff --git a/go/libraries/doltcore/schema/typeinfo/geometry.go b/go/libraries/doltcore/schema/typeinfo/geometry.go
index 7b8ced1e45..8b273ba08d 100644
--- a/go/libraries/doltcore/schema/typeinfo/geometry.go
+++ b/go/libraries/doltcore/schema/typeinfo/geometry.go
@@ -14,17 +14,7 @@
 
 package typeinfo
 
-import (
-	"context"
-	"fmt"
-	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/geometry"
-
-	"github.com/dolthub/go-mysql-server/sql"
-
-	"github.com/dolthub/dolt/go/store/types"
-)
-
-// This is a dolt implementation of the MySQL type Geometry, thus most of the functionality
+/*// This is a dolt implementation of the MySQL type Geometry, thus most of the functionality
 // within is directly reliant on the go-mysql-server implementation.
 type geometryType struct {
 	geometryType sql.GeometryType
@@ -200,3 +190,4 @@ func geometryTypeConverter(ctx context.Context, src *geometryType, destTi TypeIn
 		return nil, false, UnhandledTypeConversion.New(src.String(), destTi.String())
 	}
 }
+*/
\ No newline at end of file
diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
new file mode 100644
index 0000000000..922b62e069
--- /dev/null
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -0,0 +1,158 @@
+// Copyright 2020 Dolthub, 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 typeinfo
+
+import (
+	"context"
+	"fmt"
+	"github.com/dolthub/dolt/go/store/types"
+	"github.com/dolthub/go-mysql-server/sql"
+)
+
+// This is a dolt implementation of the MySQL type Point, thus most of the functionality
+// within is directly reliant on the go-mysql-server implementation.
+type pointType struct {
+	sqlPointType sql.PointType
+}
+
+var _ TypeInfo = (*pointType)(nil)
+
+var PointType = &pointType{sql.Point}
+
+// ConvertNomsValueToValue implements TypeInfo interface.
+func (ti *pointType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
+	if val, ok := v.(types.Point); ok {
+		return string(val), nil
+	}
+	if _, ok := v.(types.Null); ok || v == nil {
+		return nil, nil
+	}
+	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), v.Kind())
+}
+
+// ReadFrom reads a go value from a noms types.CodecReader directly
+func (ti *pointType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecReader) (interface{}, error) {
+	k := reader.ReadKind()
+	switch k {
+	case types.GeometryKind:
+		s := reader.ReadString()
+		return s, nil
+	case types.NullKind:
+		return nil, nil
+	}
+
+	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), k)
+}
+
+// ConvertValueToNomsValue implements TypeInfo interface.
+func (ti *pointType) ConvertValueToNomsValue(ctx context.Context, vrw types.ValueReadWriter, v interface{}) (types.Value, error) {
+	if v == nil {
+		return types.NullValue, nil
+	}
+
+	strVal, err := ti.sqlPointType.Convert(v)
+	if err != nil {
+		return nil, err
+	}
+
+	val, ok := strVal.(string)
+	if !ok {
+		return nil, fmt.Errorf(`"%v" cannot convert value "%v" of type "%T" as it is invalid`, ti.String(), v, v)
+	}
+	return types.Point(val), nil
+}
+
+// Equals implements TypeInfo interface.
+func (ti *pointType) Equals(other TypeInfo) bool {
+	if other == nil {
+		return false
+	}
+	if ti2, ok := other.(*pointType); ok {
+		return ti.sqlPointType.Type() == ti2.sqlPointType.Type()
+	}
+	return false
+}
+
+// FormatValue implements TypeInfo interface.
+func (ti *pointType) FormatValue(v types.Value) (*string, error) {
+	if val, ok := v.(types.Point); ok {
+		res, err := ti.ConvertNomsValueToValue(val)
+		if err != nil {
+			return nil, err
+		}
+		if resStr, ok := res.(string); ok {
+			return &resStr, nil
+		}
+		return nil, fmt.Errorf(`"%v" has unexpectedly encountered a value of type "%T" from embedded type`, ti.String(), v)
+	}
+	if _, ok := v.(types.Null); ok || v == nil {
+		return nil, nil
+	}
+
+	return nil, fmt.Errorf(`"%v" has unexpectedly encountered a value of type "%T" from embedded type`, ti.String(), v.Kind())
+}
+
+// GetTypeIdentifier implements TypeInfo interface.
+func (ti *pointType) GetTypeIdentifier() Identifier {
+	return GeometryTypeIdentifier
+}
+
+// GetTypeParams implements TypeInfo interface.
+func (ti *pointType) GetTypeParams() map[string]string {
+	return map[string]string{}
+}
+
+// IsValid implements TypeInfo interface.
+func (ti *pointType) IsValid(v types.Value) bool {
+	if val, ok := v.(types.Point); ok {
+		_, err := ti.sqlPointType.Convert(string(val))
+		if err != nil {
+			return false
+		}
+		return true
+	}
+	if _, ok := v.(types.Null); ok || v == nil {
+		return true
+	}
+	return false
+}
+
+// NomsKind implements TypeInfo interface.
+func (ti *pointType) NomsKind() types.NomsKind {
+	return types.GeometryKind
+}
+
+// ParseValue implements TypeInfo interface.
+func (ti *pointType) ParseValue(ctx context.Context, vrw types.ValueReadWriter, str *string) (types.Value, error) {
+	if str == nil || *str == "" {
+		return types.NullValue, nil
+	}
+	return ti.ConvertValueToNomsValue(context.Background(), nil, *str)
+}
+
+// Promote implements TypeInfo interface.
+func (ti *pointType) Promote() TypeInfo {
+	return &pointType{ti.sqlPointType.Promote().(sql.PointType)}
+}
+
+// String implements TypeInfo interface.
+func (ti *pointType) String() string {
+	return "Point()"
+}
+
+// ToSqlType implements TypeInfo interface.
+func (ti *pointType) ToSqlType() sql.Type {
+	return ti.sqlPointType
+}
\ No newline at end of file
diff --git a/go/libraries/doltcore/schema/typeinfo/typeinfo.go b/go/libraries/doltcore/schema/typeinfo/typeinfo.go
index 517f76bf8a..33f109e214 100644
--- a/go/libraries/doltcore/schema/typeinfo/typeinfo.go
+++ b/go/libraries/doltcore/schema/typeinfo/typeinfo.go
@@ -161,7 +161,11 @@ func FromSqlType(sqlType sql.Type) (TypeInfo, error) {
 	case sqltypes.Year:
 		return YearType, nil
 	case sqltypes.Geometry:
-		return GeometryType, nil
+		pointSQLType, ok := sqlType.(sql.PointType)
+		if !ok {
+			return nil, fmt.Errorf(`expected "PointTypeIdentifier" from SQL basetype "Point"`)
+		}
+		return &pointType{pointSQLType}, nil
 	case sqltypes.Decimal:
 		decimalSQLType, ok := sqlType.(sql.DecimalType)
 		if !ok {
@@ -273,7 +277,7 @@ func FromTypeParams(id Identifier, params map[string]string) (TypeInfo, error) {
 	case YearTypeIdentifier:
 		return YearType, nil
 	case GeometryTypeIdentifier:
-		return GeometryType, nil
+		return PointType, nil
 	default:
 		return nil, fmt.Errorf(`"%v" cannot be made from an identifier and params`, id)
 	}
diff --git a/go/libraries/doltcore/sqle/geometry/noms_geometry_value.go b/go/libraries/doltcore/sqle/geometry/noms_geometry_value.go
index 38185185fb..cf67c1aa3b 100644
--- a/go/libraries/doltcore/sqle/geometry/noms_geometry_value.go
+++ b/go/libraries/doltcore/sqle/geometry/noms_geometry_value.go
@@ -14,7 +14,7 @@
 
 package geometry
 
-import (
+/*import (
 	"context"
 	"errors"
 	"strings"
@@ -71,6 +71,8 @@ func marshalGeometry(ctx context.Context, vrw types.ValueReadWriter, val interfa
 	switch val := val.(type) {
 	case bool: // TODO: this is impossible?
 		return types.Bool(val), nil
+	case sql.PointType:
+		return nil, nil
 	default:
 		return nil, ErrUnexpectedGeometryTypeIn
 	}
@@ -140,3 +142,4 @@ func marshalToString(ctx context.Context, sb *strings.Builder, val types.Value)
 	}
 	return
 }
+*/
\ No newline at end of file
diff --git a/go/libraries/doltcore/sqle/sqlutil/sql_row.go b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
index 2d0c8f0ad4..e6f08aaf53 100644
--- a/go/libraries/doltcore/sqle/sqlutil/sql_row.go
+++ b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
@@ -303,7 +303,7 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 		case time.Time:
 			return typedCol.Format("2006-01-02 15:04:05.999999 -0700 MST")
 		case sql.PointValue:
-			s, err := typedCol.ToString(sql.NewContext(ctx)) // TODO: do I need sql.NewContext()
+			s, err := typedCol.ToString() // TODO: do I need sql.NewContext()
 			if err != nil {
 				s = err.Error()
 			}
diff --git a/go/store/types/geometry.go b/go/store/types/geometry.go
index 6e5e978ceb..a1b9dcae4c 100644
--- a/go/store/types/geometry.go
+++ b/go/store/types/geometry.go
@@ -21,7 +21,7 @@
 
 package types
 
-import (
+/*import (
 	"context"
 	"errors"
 	"fmt"
@@ -71,7 +71,7 @@ func readGeometry(nbf *NomsBinFormat, dec *valueDecoder) (Geometry, error) {
 		return Geometry{}, errors.New("current value is not a Geometry")
 	}
 
-	if err := skipJSON(nbf, dec); err != nil {
+	if err := skipGeometry(nbf, dec); err != nil {
 		return Geometry{}, err
 	}
 
@@ -79,6 +79,11 @@ func readGeometry(nbf *NomsBinFormat, dec *valueDecoder) (Geometry, error) {
 	return Geometry{valueImpl{dec.vrw, nbf, dec.byteSlice(start, end), nil}}, nil
 }
 
+func skipGeometry(nbf *NomsBinFormat, dec *valueDecoder) error {
+	dec.skipKind()
+	return dec.SkipValue(nbf)
+}
+
 // Value implements the Value interface
 func (v Geometry) Value(ctx context.Context) (Value, error) {
 	return v, nil
@@ -183,3 +188,4 @@ func (v Geometry) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, erro
 }
 
 func (v Geometry) skip(nbf *NomsBinFormat, b *binaryNomsReader) {}
+*/
\ No newline at end of file
diff --git a/go/store/types/noms_kind.go b/go/store/types/noms_kind.go
index 72eb1b1015..dbe82f7580 100644
--- a/go/store/types/noms_kind.go
+++ b/go/store/types/noms_kind.go
@@ -84,7 +84,7 @@ func init() {
 	KindToType[TimestampKind] = Timestamp{}
 	KindToType[DecimalKind] = Decimal{}
 	KindToType[JSONKind] = JSON{}
-	KindToType[GeometryKind] = Geometry{}
+	KindToType[GeometryKind] = Point("")
 
 	SupportedKinds[BlobKind] = true
 	SupportedKinds[BoolKind] = true
@@ -137,7 +137,7 @@ var KindToString = map[NomsKind]string{
 	TimestampKind:  "Timestamp",
 	DecimalKind:    "Decimal",
 	JSONKind:       "JSON",
-	GeometryKind:       "Geometry",
+	GeometryKind:   "Geometry",
 }
 
 // String returns the name of the kind.
diff --git a/go/store/types/point.go b/go/store/types/point.go
new file mode 100644
index 0000000000..c803cc7c1c
--- /dev/null
+++ b/go/store/types/point.go
@@ -0,0 +1,99 @@
+// Copyright 2019 Dolthub, 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.
+//
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//
+// Copyright 2016 Attic Labs, Inc. All rights reserved.
+// Licensed under the Apache License, version 2.0:
+// http://www.apache.org/licenses/LICENSE-2.0
+
+package types
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/dolthub/dolt/go/store/hash"
+)
+
+// Point is a Noms Value wrapper around the primitive string type (for now).
+type Point string
+
+// Value interface
+func (v Point) Value(ctx context.Context) (Value, error) {
+	return v, nil
+}
+
+func (v Point) Equals(other Value) bool {
+	return v == other
+}
+
+func (v Point) Less(nbf *NomsBinFormat, other LesserValuable) (bool, error) {
+	if v2, ok := other.(Point); ok {
+		return v < v2, nil
+	}
+	return GeometryKind < other.Kind(), nil
+}
+
+func (v Point) Hash(nbf *NomsBinFormat) (hash.Hash, error) {
+	return getHash(v, nbf)
+}
+
+func (v Point) isPrimitive() bool {
+	return true
+}
+
+func (v Point) WalkValues(ctx context.Context, cb ValueCallback) error {
+	return nil
+}
+
+func (v Point) WalkRefs(nbf *NomsBinFormat, cb RefCallback) error {
+	return nil
+}
+
+func (v Point) typeOf() (*Type, error) {
+	return PrimitiveTypeMap[GeometryKind], nil
+}
+
+func (v Point) Kind() NomsKind {
+	return GeometryKind
+}
+
+func (v Point) valueReadWriter() ValueReadWriter {
+	return nil
+}
+
+func (v Point) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
+	err := GeometryKind.writeTo(w, nbf)
+
+	if err != nil {
+		return err
+	}
+
+	w.writeString(string(v))
+	return nil
+}
+
+func (v Point) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
+	return Point(b.ReadString()), nil
+}
+
+func (v Point) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
+	b.skipString()
+}
+
+func (v Point) HumanReadableString() string {
+	return strconv.Quote(string(v))
+}
diff --git a/go/store/types/value_decoder.go b/go/store/types/value_decoder.go
index 9f8fe1a1b9..b6299c978d 100644
--- a/go/store/types/value_decoder.go
+++ b/go/store/types/value_decoder.go
@@ -48,7 +48,7 @@ type CodecReader interface {
 	ReadDecimal() (decimal.Decimal, error)
 	ReadBlob() (Blob, error)
 	ReadJSON() (JSON, error)
-	ReadGeometry() (Geometry, error)
+	ReadGeometry() (Point, error)
 }
 
 var _ CodecReader = (*valueDecoder)(nil)
@@ -85,8 +85,8 @@ func (r *valueDecoder) ReadJSON() (JSON, error) {
 	return readJSON(r.vrw.Format(), r)
 }
 
-func (r *valueDecoder) ReadGeometry() (Geometry, error) {
-	return readGeometry(r.vrw.Format(), r)
+func (r *valueDecoder) ReadGeometry() (Point, error) {
+	return Point(1), nil
 }
 
 func (r *valueDecoder) readRef(nbf *NomsBinFormat) (Ref, error) {
@@ -361,6 +361,8 @@ func (r *valueDecoder) readValue(nbf *NomsBinFormat) (Value, error) {
 		return r.readTuple(nbf)
 	case JSONKind:
 		return r.ReadJSON()
+	case GeometryKind:
+		return r.ReadGeometry()
 	case TypeKind:
 		r.skipKind()
 		return r.readType()

From 82bad57f9daaa78d7ebbd8a8c62281d4302b85d5 Mon Sep 17 00:00:00 2001
From: JCOR11599 <JCOR11599@users.noreply.github.com>
Date: Wed, 15 Dec 2021 23:40:21 +0000
Subject: [PATCH 04/51] [ga-format-pr] Run go/utils/repofmt/format_repo.sh and
 go/Godeps/update.sh

---
 go/libraries/doltcore/schema/typeinfo/geometry.go          | 2 +-
 go/libraries/doltcore/schema/typeinfo/point.go             | 6 ++++--
 go/libraries/doltcore/sqle/geometry/noms_geometry_value.go | 2 +-
 go/store/types/geometry.go                                 | 2 +-
 4 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/geometry.go b/go/libraries/doltcore/schema/typeinfo/geometry.go
index 8b273ba08d..acaeeea8ad 100644
--- a/go/libraries/doltcore/schema/typeinfo/geometry.go
+++ b/go/libraries/doltcore/schema/typeinfo/geometry.go
@@ -190,4 +190,4 @@ func geometryTypeConverter(ctx context.Context, src *geometryType, destTi TypeIn
 		return nil, false, UnhandledTypeConversion.New(src.String(), destTi.String())
 	}
 }
-*/
\ No newline at end of file
+*/
diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index 922b62e069..4970868b45 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -17,8 +17,10 @@ package typeinfo
 import (
 	"context"
 	"fmt"
-	"github.com/dolthub/dolt/go/store/types"
+
 	"github.com/dolthub/go-mysql-server/sql"
+
+	"github.com/dolthub/dolt/go/store/types"
 )
 
 // This is a dolt implementation of the MySQL type Point, thus most of the functionality
@@ -155,4 +157,4 @@ func (ti *pointType) String() string {
 // ToSqlType implements TypeInfo interface.
 func (ti *pointType) ToSqlType() sql.Type {
 	return ti.sqlPointType
-}
\ No newline at end of file
+}
diff --git a/go/libraries/doltcore/sqle/geometry/noms_geometry_value.go b/go/libraries/doltcore/sqle/geometry/noms_geometry_value.go
index cf67c1aa3b..1188b76295 100644
--- a/go/libraries/doltcore/sqle/geometry/noms_geometry_value.go
+++ b/go/libraries/doltcore/sqle/geometry/noms_geometry_value.go
@@ -142,4 +142,4 @@ func marshalToString(ctx context.Context, sb *strings.Builder, val types.Value)
 	}
 	return
 }
-*/
\ No newline at end of file
+*/
diff --git a/go/store/types/geometry.go b/go/store/types/geometry.go
index a1b9dcae4c..0b19afbd6f 100644
--- a/go/store/types/geometry.go
+++ b/go/store/types/geometry.go
@@ -188,4 +188,4 @@ func (v Geometry) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, erro
 }
 
 func (v Geometry) skip(nbf *NomsBinFormat, b *binaryNomsReader) {}
-*/
\ No newline at end of file
+*/

From 767491efd028e9c3e60e5ae7ca515b619dad11e0 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Thu, 16 Dec 2021 16:47:34 -0800
Subject: [PATCH 05/51] can select linestring

---
 go/libraries/doltcore/sqle/sqlutil/sql_row.go | 10 +++++++++-
 go/store/types/point.go                       |  1 +
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/go/libraries/doltcore/sqle/sqlutil/sql_row.go b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
index e6f08aaf53..655f8caf8d 100644
--- a/go/libraries/doltcore/sqle/sqlutil/sql_row.go
+++ b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
@@ -302,8 +302,16 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 			}
 		case time.Time:
 			return typedCol.Format("2006-01-02 15:04:05.999999 -0700 MST")
+		case sql.GeometryValue:
+			return "encountered a geometry value somehow!"
 		case sql.PointValue:
-			s, err := typedCol.ToString() // TODO: do I need sql.NewContext()
+			s, err := typedCol.ToString()
+			if err != nil {
+				s = err.Error()
+			}
+			return s
+		case sql.LineStringValue:
+			s, err := typedCol.ToString()
 			if err != nil {
 				s = err.Error()
 			}
diff --git a/go/store/types/point.go b/go/store/types/point.go
index c803cc7c1c..8cf10bf58b 100644
--- a/go/store/types/point.go
+++ b/go/store/types/point.go
@@ -29,6 +29,7 @@ import (
 )
 
 // Point is a Noms Value wrapper around the primitive string type (for now).
+//TODO: type Point sql.PointValue
 type Point string
 
 // Value interface

From f7c62d597f225e55b487f196a5b9905e31655241 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Fri, 17 Dec 2021 11:49:32 -0800
Subject: [PATCH 06/51] adding polygon

---
 go/libraries/doltcore/sqle/sqlutil/sql_row.go | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/go/libraries/doltcore/sqle/sqlutil/sql_row.go b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
index 655f8caf8d..3320f7bd82 100644
--- a/go/libraries/doltcore/sqle/sqlutil/sql_row.go
+++ b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
@@ -303,7 +303,7 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 		case time.Time:
 			return typedCol.Format("2006-01-02 15:04:05.999999 -0700 MST")
 		case sql.GeometryValue:
-			return "encountered a geometry value somehow!"
+			return "encountered a geometry value somehow"
 		case sql.PointValue:
 			s, err := typedCol.ToString()
 			if err != nil {
@@ -316,6 +316,12 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 				s = err.Error()
 			}
 			return s
+		case sql.PolygonValue:
+			s, err := typedCol.ToString()
+			if err != nil {
+				s = err.Error()
+			}
+			return s
 		case sql.JSONValue:
 			s, err := typedCol.ToString(sql.NewContext(ctx))
 			if err != nil {

From c8375310345085063223e3c15b1d3ecdd2a38f74 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Mon, 20 Dec 2021 13:45:12 -0800
Subject: [PATCH 07/51] points work, but linestrings don't

---
 .../doltcore/schema/typeinfo/geometry.go      | 193 ------------------
 .../doltcore/schema/typeinfo/linestring.go    | 167 +++++++++++++++
 .../doltcore/schema/typeinfo/point.go         |  16 +-
 .../doltcore/schema/typeinfo/polygon.go       | 173 ++++++++++++++++
 .../doltcore/schema/typeinfo/typeinfo.go      |  32 ++-
 go/libraries/doltcore/sqle/sqlutil/sql_row.go |   4 +-
 go/store/types/linestring.go                  | 134 ++++++++++++
 go/store/types/noms_kind.go                   |  16 +-
 go/store/types/point.go                       |   8 +-
 go/store/types/polygon.go                     | 125 ++++++++++++
 go/store/types/value_decoder.go               |  25 ++-
 11 files changed, 668 insertions(+), 225 deletions(-)
 delete mode 100644 go/libraries/doltcore/schema/typeinfo/geometry.go
 create mode 100644 go/libraries/doltcore/schema/typeinfo/linestring.go
 create mode 100644 go/libraries/doltcore/schema/typeinfo/polygon.go
 create mode 100644 go/store/types/linestring.go
 create mode 100644 go/store/types/polygon.go

diff --git a/go/libraries/doltcore/schema/typeinfo/geometry.go b/go/libraries/doltcore/schema/typeinfo/geometry.go
deleted file mode 100644
index acaeeea8ad..0000000000
--- a/go/libraries/doltcore/schema/typeinfo/geometry.go
+++ /dev/null
@@ -1,193 +0,0 @@
-// Copyright 2020 Dolthub, 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 typeinfo
-
-/*// This is a dolt implementation of the MySQL type Geometry, thus most of the functionality
-// within is directly reliant on the go-mysql-server implementation.
-type geometryType struct {
-	geometryType sql.GeometryType
-}
-
-var _ TypeInfo = (*geometryType)(nil)
-var GeometryType = &geometryType{sql.Geometry}
-
-// ConvertNomsValueToValue implements TypeInfo interface.
-func (ti *geometryType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
-	if val, ok := v.(types.Geometry); ok {
-		return geometry.NomsGeometry(val), nil
-	}
-	if _, ok := v.(types.Null); ok || v == nil {
-		return nil, nil
-	}
-	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), v.Kind())
-}
-
-// ReadFrom reads a go value from a noms types.CodecReader directly
-func (ti *geometryType) ReadFrom(_ *types.NomsBinFormat, reader types.CodecReader) (interface{}, error) {
-	k := reader.ReadKind()
-	switch k {
-	case types.GeometryKind:
-		gs, err := reader.ReadGeometry()
-		if err != nil {
-			return nil, err
-		}
-		return geometry.NomsGeometry(gs), nil
-	case types.NullKind:
-		return nil, nil
-	}
-
-	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), k)
-}
-
-// ConvertValueToNomsValue implements TypeInfo interface.
-func (ti *geometryType) ConvertValueToNomsValue(ctx context.Context, vrw types.ValueReadWriter, v interface{}) (types.Value, error) {
-	if v == nil {
-		return types.NullValue, nil
-	}
-
-	gsObj, err := ti.geometryType.Convert(v)
-	if err != nil {
-		return nil, err
-	}
-
-	gsVal, ok := gsObj.(sql.GeometryValue)
-	if !ok {
-		return nil, fmt.Errorf(`"%v" cannot convert value "%v" of type "%T" as it is invalid`, ti.String(), v, v)
-	}
-
-	noms, err := geometry.NomsGeometryFromGeometryValue(ctx, vrw, gsVal)
-	if err != nil {
-		return nil, err
-	}
-
-	return types.Geometry(noms), err
-}
-
-// Equals implements TypeInfo interface.
-func (ti *geometryType) Equals(other TypeInfo) bool {
-	return ti.GetTypeIdentifier() == other.GetTypeIdentifier()
-}
-
-// FormatValue implements TypeInfo interface.
-func (ti *geometryType) FormatValue(v types.Value) (*string, error) {
-	if _, ok := v.(types.Null); ok || v == nil {
-		return nil, nil
-	}
-
-	if noms, ok := v.(types.Geometry); ok {
-		s, err := geometry.NomsGeometry(noms).ToString(sql.NewEmptyContext())
-		if err != nil {
-			return nil, err
-		}
-		return &s, nil
-	}
-	return nil, fmt.Errorf(`"%v" has unexpectedly encountered a value of type "%T" from embedded type`, ti.String(), v)
-}
-
-// GetTypeIdentifier implements TypeInfo interface.
-func (ti *geometryType) GetTypeIdentifier() Identifier {
-	return GeometryTypeIdentifier
-}
-
-// GetTypeParams implements TypeInfo interface.
-func (ti *geometryType) GetTypeParams() map[string]string {
-	return nil
-}
-
-// IsValid implements TypeInfo interface.
-func (ti *geometryType) IsValid(v types.Value) bool {
-	if v == nil {
-		return true
-	}
-	switch v.(type) {
-	case types.Geometry:
-		return true
-	case types.Null:
-		return true
-	default:
-		return false
-	}
-}
-
-// NomsKind implements TypeInfo interface.
-func (ti *geometryType) NomsKind() types.NomsKind {
-	return types.GeometryKind
-}
-
-// ParseValue implements TypeInfo interface.
-func (ti *geometryType) ParseValue(ctx context.Context, vrw types.ValueReadWriter, str *string) (types.Value, error) {
-	if str == nil {
-		return types.NullValue, nil
-	}
-	return ti.ConvertValueToNomsValue(ctx, vrw, *str)
-}
-
-// Promote implements TypeInfo interface.
-func (ti *geometryType) Promote() TypeInfo {
-	return &geometryType{ti.geometryType.Promote().(sql.GeometryType)}
-}
-
-// String implements TypeInfo interface.
-func (ti *geometryType) String() string {
-	return "Geometry"
-}
-
-// ToSqlType implements TypeInfo interface.
-func (ti *geometryType) ToSqlType() sql.Type {
-	return ti.geometryType
-}
-
-// geometryTypeConverter is an internal function for GetTypeConverter that handles the specific type as the source TypeInfo.
-func geometryTypeConverter(ctx context.Context, src *geometryType, destTi TypeInfo) (tc TypeConverter, needsConversion bool, err error) {
-	switch dest := destTi.(type) {
-	case *bitType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
-	case *blobStringType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
-	case *boolType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
-	case *datetimeType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
-	case *decimalType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
-	case *enumType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
-	case *floatType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
-	case *inlineBlobType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
-	case *intType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
-	case *geometryType:
-		return wrapIsValid(dest.IsValid, src, dest)
-	case *jsonType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
-	case *setType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
-	case *timeType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
-	case *uintType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
-	case *uuidType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
-	case *varBinaryType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
-	case *varStringType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
-	default:
-		return nil, false, UnhandledTypeConversion.New(src.String(), destTi.String())
-	}
-}
-*/
diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
new file mode 100644
index 0000000000..e7e3702464
--- /dev/null
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -0,0 +1,167 @@
+// Copyright 2020 Dolthub, 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 typeinfo
+
+import (
+	"context"
+	"fmt"
+	"github.com/dolthub/go-mysql-server/sql"
+
+	"github.com/dolthub/dolt/go/store/types"
+)
+
+// This is a dolt implementation of the MySQL type Point, thus most of the functionality
+// within is directly reliant on the go-mysql-server implementation.
+type linestringType struct {
+	sqlLinestringType sql.LinestringType
+}
+
+var _ TypeInfo = (*linestringType)(nil)
+
+var LinestringType = &linestringType{sql.Linestring}
+
+// ConvertNomsValueToValue implements TypeInfo interface.
+func (ti *linestringType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
+	if val, ok := v.(types.Linestring); ok {
+		return val, nil
+	}
+	if _, ok := v.(types.Null); ok || v == nil {
+		return nil, nil
+	}
+	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), v.Kind())
+}
+
+// ReadFrom reads a go value from a noms types.CodecReader directly
+func (ti *linestringType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecReader) (interface{}, error) {
+	k := reader.ReadKind()
+	switch k {
+	case types.LinestringKind:
+		s := reader.ReadString()
+		return s, nil
+	case types.NullKind:
+		return nil, nil
+	}
+
+	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), k)
+}
+
+// ConvertValueToNomsValue implements TypeInfo interface.
+func (ti *linestringType) ConvertValueToNomsValue(ctx context.Context, vrw types.ValueReadWriter, v interface{}) (types.Value, error) {
+	if v == nil {
+		return types.NullValue, nil
+	}
+
+	strVal, err := ti.sqlLinestringType.Convert(v)
+	if err != nil {
+		return nil, err
+	}
+
+	var res []types.Point
+	for _, pv := range strVal.(sql.LinestringValue).Points {
+		p, err := PointType.ConvertValueToNomsValue(ctx, vrw, pv)
+		if err != nil {
+			return nil, err
+		}
+		res = append(res, p.(types.Point))
+	}
+
+	return types.Linestring(res), nil
+	//return nil, fmt.Errorf(`"%v" cannot convert value "%v" of type "%T" as it is invalid`, ti.String(), v, v)
+}
+
+// Equals implements TypeInfo interface.
+func (ti *linestringType) Equals(other TypeInfo) bool {
+	if other == nil {
+		return false
+	}
+	if ti2, ok := other.(*linestringType); ok {
+		return ti.sqlLinestringType.Type() == ti2.sqlLinestringType.Type()
+	}
+	return false
+}
+
+// FormatValue implements TypeInfo interface.
+func (ti *linestringType) FormatValue(v types.Value) (*string, error) {
+	if val, ok := v.(types.Linestring); ok {
+		res, err := ti.ConvertNomsValueToValue(val)
+		if err != nil {
+			return nil, err
+		}
+		if resStr, ok := res.(string); ok {
+			return &resStr, nil
+		}
+		return nil, fmt.Errorf(`"%v" has unexpectedly encountered a value of type "%T" from embedded type`, ti.String(), v)
+	}
+	if _, ok := v.(types.Null); ok || v == nil {
+		return nil, nil
+	}
+
+	return nil, fmt.Errorf(`"%v" has unexpectedly encountered a value of type "%T" from embedded type`, ti.String(), v.Kind())
+}
+
+// GetTypeIdentifier implements TypeInfo interface.
+func (ti *linestringType) GetTypeIdentifier() Identifier {
+	return LinestringTypeIdentifier
+}
+
+// GetTypeParams implements TypeInfo interface.
+func (ti *linestringType) GetTypeParams() map[string]string {
+	return map[string]string{}
+}
+
+// IsValid implements TypeInfo interface.
+func (ti *linestringType) IsValid(v types.Value) bool {
+	if val, ok := v.(types.Linestring); ok {
+		// LineString is valid if every point in it is valid
+		for _, p := range val {
+			if !PointType.IsValid(p) {
+				return false
+			}
+		}
+		return true
+	}
+	if _, ok := v.(types.Null); ok || v == nil {
+		return true
+	}
+	return false
+}
+
+// NomsKind implements TypeInfo interface.
+func (ti *linestringType) NomsKind() types.NomsKind {
+	return types.LinestringKind
+}
+
+// ParseValue implements TypeInfo interface.
+func (ti *linestringType) ParseValue(ctx context.Context, vrw types.ValueReadWriter, str *string) (types.Value, error) {
+	if str == nil || *str == "" {
+		return types.NullValue, nil
+	}
+	return ti.ConvertValueToNomsValue(context.Background(), nil, *str)
+}
+
+// Promote implements TypeInfo interface.
+func (ti *linestringType) Promote() TypeInfo {
+	return &linestringType{ti.sqlLinestringType.Promote().(sql.LinestringType)}
+}
+
+// String implements TypeInfo interface.
+func (ti *linestringType) String() string {
+	return "Linestring()"
+}
+
+// ToSqlType implements TypeInfo interface.
+func (ti *linestringType) ToSqlType() sql.Type {
+	return ti.sqlLinestringType
+}
diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index 4970868b45..8d0fc49b53 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -36,7 +36,7 @@ var PointType = &pointType{sql.Point}
 // ConvertNomsValueToValue implements TypeInfo interface.
 func (ti *pointType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
 	if val, ok := v.(types.Point); ok {
-		return string(val), nil
+		return val, nil
 	}
 	if _, ok := v.(types.Null); ok || v == nil {
 		return nil, nil
@@ -48,7 +48,7 @@ func (ti *pointType) ConvertNomsValueToValue(v types.Value) (interface{}, error)
 func (ti *pointType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecReader) (interface{}, error) {
 	k := reader.ReadKind()
 	switch k {
-	case types.GeometryKind:
+	case types.PointKind:
 		s := reader.ReadString()
 		return s, nil
 	case types.NullKind:
@@ -69,11 +69,11 @@ func (ti *pointType) ConvertValueToNomsValue(ctx context.Context, vrw types.Valu
 		return nil, err
 	}
 
-	val, ok := strVal.(string)
-	if !ok {
-		return nil, fmt.Errorf(`"%v" cannot convert value "%v" of type "%T" as it is invalid`, ti.String(), v, v)
+	if val, ok := strVal.(string); ok {
+		return types.Point(val), nil
 	}
-	return types.Point(val), nil
+
+	return nil, fmt.Errorf(`"%v" cannot convert value "%v" of type "%T" as it is invalid`, ti.String(), v, v)
 }
 
 // Equals implements TypeInfo interface.
@@ -108,7 +108,7 @@ func (ti *pointType) FormatValue(v types.Value) (*string, error) {
 
 // GetTypeIdentifier implements TypeInfo interface.
 func (ti *pointType) GetTypeIdentifier() Identifier {
-	return GeometryTypeIdentifier
+	return PointTypeIdentifier
 }
 
 // GetTypeParams implements TypeInfo interface.
@@ -133,7 +133,7 @@ func (ti *pointType) IsValid(v types.Value) bool {
 
 // NomsKind implements TypeInfo interface.
 func (ti *pointType) NomsKind() types.NomsKind {
-	return types.GeometryKind
+	return types.PointKind
 }
 
 // ParseValue implements TypeInfo interface.
diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
new file mode 100644
index 0000000000..bf804cdc30
--- /dev/null
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -0,0 +1,173 @@
+// Copyright 2020 Dolthub, 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 typeinfo
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/dolthub/go-mysql-server/sql"
+
+	"github.com/dolthub/dolt/go/store/types"
+)
+
+// This is a dolt implementation of the MySQL type Point, thus most of the functionality
+// within is directly reliant on the go-mysql-server implementation.
+type polygonType struct {
+	sqlPolygonType sql.PolygonType
+}
+
+var _ TypeInfo = (*polygonType)(nil)
+
+var PolygonType = &polygonType{sql.Polygon}
+
+// ConvertNomsValueToValue implements TypeInfo interface.
+func (ti *polygonType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
+	if val, ok := v.(types.Linestring); ok {
+		var res []string
+		for _, l := range val {
+			res = append(res, string(l))
+		}
+		return strings.Join(res, ","), nil
+	}
+	if _, ok := v.(types.Null); ok || v == nil {
+		return nil, nil
+	}
+	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), v.Kind())
+}
+
+// ReadFrom reads a go value from a noms types.CodecReader directly
+func (ti *polygonType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecReader) (interface{}, error) {
+	k := reader.ReadKind()
+	switch k {
+	case types.PolygonKind:
+		s := reader.ReadString()
+		return s, nil
+	case types.NullKind:
+		return nil, nil
+	}
+
+	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), k)
+}
+
+// ConvertValueToNomsValue implements TypeInfo interface.
+func (ti *polygonType) ConvertValueToNomsValue(ctx context.Context, vrw types.ValueReadWriter, v interface{}) (types.Value, error) {
+	if v == nil {
+		return types.NullValue, nil
+	}
+
+	strVal, err := ti.sqlPolygonType.Convert(v)
+	if err != nil {
+		return nil, err
+	}
+
+	//val, ok := strVal.(string)
+	_, ok := strVal.(string)
+	if !ok {
+		return nil, fmt.Errorf(`"%v" cannot convert value "%v" of type "%T" as it is invalid`, ti.String(), v, v)
+	}
+	// TODO: figure out string constructor
+	return types.Polygon([]types.Linestring{}), nil
+}
+
+// Equals implements TypeInfo interface.
+func (ti *polygonType) Equals(other TypeInfo) bool {
+	if other == nil {
+		return false
+	}
+	if ti2, ok := other.(*linestringType); ok {
+		return ti.sqlPolygonType.Type() == ti2.sqlLinestringType.Type()
+	}
+	return false
+}
+
+// FormatValue implements TypeInfo interface.
+func (ti *polygonType) FormatValue(v types.Value) (*string, error) {
+	if val, ok := v.(types.Linestring); ok {
+		res, err := ti.ConvertNomsValueToValue(val)
+		if err != nil {
+			return nil, err
+		}
+		if resStr, ok := res.(string); ok {
+			return &resStr, nil
+		}
+		return nil, fmt.Errorf(`"%v" has unexpectedly encountered a value of type "%T" from embedded type`, ti.String(), v)
+	}
+	if _, ok := v.(types.Null); ok || v == nil {
+		return nil, nil
+	}
+
+	return nil, fmt.Errorf(`"%v" has unexpectedly encountered a value of type "%T" from embedded type`, ti.String(), v.Kind())
+}
+
+// GetTypeIdentifier implements TypeInfo interface.
+func (ti *polygonType) GetTypeIdentifier() Identifier {
+	return PolygonTypeIdentifier
+}
+
+// GetTypeParams implements TypeInfo interface.
+func (ti *polygonType) GetTypeParams() map[string]string {
+	return map[string]string{}
+}
+
+// IsValid implements TypeInfo interface.
+func (ti *polygonType) IsValid(v types.Value) bool {
+	if val, ok := v.(types.Polygon); ok {
+		// Polygon is valid if every linestring in it is valid
+		// TODO: figure out how to call linetype.isvalid
+		for _, l := range val {
+			for _, p := range l {
+				_, err := ti.sqlPolygonType.Convert(string(p))
+				if err != nil {
+					return false
+				}
+			}
+		}
+		return true
+	}
+	if _, ok := v.(types.Null); ok || v == nil {
+		return true
+	}
+	return false
+}
+
+// NomsKind implements TypeInfo interface.
+func (ti *polygonType) NomsKind() types.NomsKind {
+	return types.PolygonKind
+}
+
+// ParseValue implements TypeInfo interface.
+func (ti *polygonType) ParseValue(ctx context.Context, vrw types.ValueReadWriter, str *string) (types.Value, error) {
+	if str == nil || *str == "" {
+		return types.NullValue, nil
+	}
+	return ti.ConvertValueToNomsValue(context.Background(), nil, *str)
+}
+
+// Promote implements TypeInfo interface.
+func (ti *polygonType) Promote() TypeInfo {
+	return &polygonType{ti.sqlPolygonType.Promote().(sql.PolygonType)}
+}
+
+// String implements TypeInfo interface.
+func (ti *polygonType) String() string {
+	return "Polygon()"
+}
+
+// ToSqlType implements TypeInfo interface.
+func (ti *polygonType) ToSqlType() sql.Type {
+	return ti.sqlPolygonType
+}
diff --git a/go/libraries/doltcore/schema/typeinfo/typeinfo.go b/go/libraries/doltcore/schema/typeinfo/typeinfo.go
index 33f109e214..bd61fd2b76 100644
--- a/go/libraries/doltcore/schema/typeinfo/typeinfo.go
+++ b/go/libraries/doltcore/schema/typeinfo/typeinfo.go
@@ -47,7 +47,9 @@ const (
 	VarBinaryTypeIdentifier  Identifier = "varbinary"
 	VarStringTypeIdentifier  Identifier = "varstring"
 	YearTypeIdentifier       Identifier = "year"
-	GeometryTypeIdentifier   Identifier = "geometry"
+	PointTypeIdentifier      Identifier = "point"
+	LinestringTypeIdentifier Identifier = "linestring"
+	PolygonTypeIdentifier    Identifier = "polygon"
 )
 
 var Identifiers = map[Identifier]struct{}{
@@ -70,7 +72,9 @@ var Identifiers = map[Identifier]struct{}{
 	VarBinaryTypeIdentifier:  {},
 	VarStringTypeIdentifier:  {},
 	YearTypeIdentifier:       {},
-	GeometryTypeIdentifier:   {},
+	PointTypeIdentifier:      {},
+	LinestringTypeIdentifier: {},
+	PolygonTypeIdentifier:    {},
 }
 
 // TypeInfo is an interface used for encoding type information.
@@ -161,11 +165,17 @@ func FromSqlType(sqlType sql.Type) (TypeInfo, error) {
 	case sqltypes.Year:
 		return YearType, nil
 	case sqltypes.Geometry:
-		pointSQLType, ok := sqlType.(sql.PointType)
-		if !ok {
+		// TODO: bad, but working way to determine which specific geometry type
+		switch sqlType.String() {
+		case sql.Polygon.String():
+			return &polygonType{sqlType.(sql.PolygonType)}, nil
+		case sql.Linestring.String():
+			return &linestringType{sqlType.(sql.LinestringType)}, nil
+		case sql.Point.String():
+			return &pointType{sqlType.(sql.PointType)}, nil
+		default:
 			return nil, fmt.Errorf(`expected "PointTypeIdentifier" from SQL basetype "Point"`)
 		}
-		return &pointType{pointSQLType}, nil
 	case sqltypes.Decimal:
 		decimalSQLType, ok := sqlType.(sql.DecimalType)
 		if !ok {
@@ -276,8 +286,12 @@ func FromTypeParams(id Identifier, params map[string]string) (TypeInfo, error) {
 		return CreateVarStringTypeFromParams(params)
 	case YearTypeIdentifier:
 		return YearType, nil
-	case GeometryTypeIdentifier:
+	case PointTypeIdentifier:
 		return PointType, nil
+	case LinestringTypeIdentifier:
+		return LinestringType, nil
+	case PolygonTypeIdentifier:
+		return PolygonType, nil
 	default:
 		return nil, fmt.Errorf(`"%v" cannot be made from an identifier and params`, id)
 	}
@@ -298,8 +312,14 @@ func FromKind(kind types.NomsKind) TypeInfo {
 		return Int64Type
 	case types.JSONKind:
 		return JSONType
+	case types.LinestringKind:
+		return LinestringType
 	case types.NullKind:
 		return UnknownType
+	case types.PointKind:
+		return PointType
+	case types.PolygonKind:
+		return PolygonType
 	case types.StringKind:
 		return StringDefaultType
 	case types.TimestampKind:
diff --git a/go/libraries/doltcore/sqle/sqlutil/sql_row.go b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
index 3320f7bd82..cb86e5ad1b 100644
--- a/go/libraries/doltcore/sqle/sqlutil/sql_row.go
+++ b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
@@ -302,15 +302,13 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 			}
 		case time.Time:
 			return typedCol.Format("2006-01-02 15:04:05.999999 -0700 MST")
-		case sql.GeometryValue:
-			return "encountered a geometry value somehow"
 		case sql.PointValue:
 			s, err := typedCol.ToString()
 			if err != nil {
 				s = err.Error()
 			}
 			return s
-		case sql.LineStringValue:
+		case sql.LinestringValue:
 			s, err := typedCol.ToString()
 			if err != nil {
 				s = err.Error()
diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
new file mode 100644
index 0000000000..b882baad04
--- /dev/null
+++ b/go/store/types/linestring.go
@@ -0,0 +1,134 @@
+// Copyright 2019 Dolthub, 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.
+//
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//
+// Copyright 2016 Attic Labs, Inc. All rights reserved.
+// Licensed under the Apache License, version 2.0:
+// http://www.apache.org/licenses/LICENSE-2.0
+
+package types
+
+import (
+	"context"
+	"strconv"
+	"strings"
+
+	"github.com/dolthub/dolt/go/store/hash"
+)
+
+// Linestring is a Noms Value wrapper around an array of Point.
+type Linestring []Point
+
+// Value interface
+func (v Linestring) Value(ctx context.Context) (Value, error) {
+	return v, nil
+}
+
+func (v Linestring) Equals(other Value) bool {
+	// Cast other to LineString
+	_other, ok := other.(Linestring)
+	if !ok {
+		return false
+	}
+	// Check that they have same length
+	if len(v) != len(_other) {
+		return false
+	}
+
+	// Check that every point is equal
+	for i := 0; i < len(v); i++ {
+		if !v[i].Equals(_other[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+func (v Linestring) Less(nbf *NomsBinFormat, other LesserValuable) (bool, error) {
+	if v2, ok := other.(Linestring); ok {
+		return v[0].Less(nbf, v2[0])
+	}
+	return LinestringKind < other.Kind(), nil
+}
+
+func (v Linestring) Hash(nbf *NomsBinFormat) (hash.Hash, error) {
+	return getHash(v, nbf)
+}
+
+func (v Linestring) isPrimitive() bool {
+	return false
+}
+
+func (v Linestring) WalkValues(ctx context.Context, cb ValueCallback) error {
+	return nil
+}
+
+func (v Linestring) WalkRefs(nbf *NomsBinFormat, cb RefCallback) error {
+	return nil
+}
+
+func (v Linestring) typeOf() (*Type, error) {
+	return PrimitiveTypeMap[LinestringKind], nil
+}
+
+func (v Linestring) Kind() NomsKind {
+	return LinestringKind
+}
+
+func (v Linestring) valueReadWriter() ValueReadWriter {
+	return nil
+}
+
+func (v Linestring) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
+	err := LinestringKind.writeTo(w, nbf)
+	if err != nil {
+		return err
+	}
+
+	// TODO: might have to combine and comma separate
+	for _, p := range v {
+		p.writeTo(w, nbf)
+	}
+
+	return nil
+}
+
+func (v Linestring) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
+	val := b.ReadString()
+	val = val[len("linestring")+1:len(val)-1]
+	pStrings := strings.Split(val, "),")
+	var points []Point
+	for i, p := range pStrings {
+		if i != len(pStrings) - 1 {
+			p = p + ")"
+		}
+		points = append(points, Point(p))
+	}
+
+	return Linestring(points), nil
+}
+
+func (v Linestring) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
+	b.skipString()
+}
+
+func (v Linestring) HumanReadableString() string {
+	var res []string
+	for _, p := range v {
+		res = append(res, p.HumanReadableString())
+	}
+	return strconv.Quote(strings.Join(res, ","))
+}
diff --git a/go/store/types/noms_kind.go b/go/store/types/noms_kind.go
index dbe82f7580..ee56425c37 100644
--- a/go/store/types/noms_kind.go
+++ b/go/store/types/noms_kind.go
@@ -56,7 +56,9 @@ const (
 	TimestampKind
 	DecimalKind
 	JSONKind
-	GeometryKind
+	PointKind
+	LinestringKind
+	PolygonKind
 
 	UnknownKind NomsKind = 255
 )
@@ -84,7 +86,9 @@ func init() {
 	KindToType[TimestampKind] = Timestamp{}
 	KindToType[DecimalKind] = Decimal{}
 	KindToType[JSONKind] = JSON{}
-	KindToType[GeometryKind] = Point("")
+	KindToType[PointKind] = Point("")
+	KindToType[LinestringKind] = Linestring([]Point{})
+	KindToType[PolygonKind] = Polygon([]Linestring{})
 
 	SupportedKinds[BlobKind] = true
 	SupportedKinds[BoolKind] = true
@@ -108,7 +112,9 @@ func init() {
 	SupportedKinds[TimestampKind] = true
 	SupportedKinds[DecimalKind] = true
 	SupportedKinds[JSONKind] = true
-	SupportedKinds[GeometryKind] = true
+	SupportedKinds[PointKind] = true
+	SupportedKinds[LinestringKind] = true
+	SupportedKinds[PolygonKind] = true
 }
 
 var KindToTypeSlice []Value
@@ -137,7 +143,9 @@ var KindToString = map[NomsKind]string{
 	TimestampKind:  "Timestamp",
 	DecimalKind:    "Decimal",
 	JSONKind:       "JSON",
-	GeometryKind:   "Geometry",
+	PointKind:      "Point",
+	LinestringKind: "Linestring",
+	PolygonKind:    "Polygon",
 }
 
 // String returns the name of the kind.
diff --git a/go/store/types/point.go b/go/store/types/point.go
index 8cf10bf58b..c09bcc17ad 100644
--- a/go/store/types/point.go
+++ b/go/store/types/point.go
@@ -45,7 +45,7 @@ func (v Point) Less(nbf *NomsBinFormat, other LesserValuable) (bool, error) {
 	if v2, ok := other.(Point); ok {
 		return v < v2, nil
 	}
-	return GeometryKind < other.Kind(), nil
+	return PointKind < other.Kind(), nil
 }
 
 func (v Point) Hash(nbf *NomsBinFormat) (hash.Hash, error) {
@@ -65,11 +65,11 @@ func (v Point) WalkRefs(nbf *NomsBinFormat, cb RefCallback) error {
 }
 
 func (v Point) typeOf() (*Type, error) {
-	return PrimitiveTypeMap[GeometryKind], nil
+	return PrimitiveTypeMap[PointKind], nil
 }
 
 func (v Point) Kind() NomsKind {
-	return GeometryKind
+	return PointKind
 }
 
 func (v Point) valueReadWriter() ValueReadWriter {
@@ -77,7 +77,7 @@ func (v Point) valueReadWriter() ValueReadWriter {
 }
 
 func (v Point) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
-	err := GeometryKind.writeTo(w, nbf)
+	err := PointKind.writeTo(w, nbf)
 
 	if err != nil {
 		return err
diff --git a/go/store/types/polygon.go b/go/store/types/polygon.go
new file mode 100644
index 0000000000..55f33ad965
--- /dev/null
+++ b/go/store/types/polygon.go
@@ -0,0 +1,125 @@
+// Copyright 2019 Dolthub, 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.
+//
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//
+// Copyright 2016 Attic Labs, Inc. All rights reserved.
+// Licensed under the Apache License, version 2.0:
+// http://www.apache.org/licenses/LICENSE-2.0
+
+package types
+
+import (
+	"context"
+	"strconv"
+	"strings"
+
+	"github.com/dolthub/dolt/go/store/hash"
+)
+
+// Polygon is a Noms Value wrapper around an array of Point.
+type Polygon []Linestring
+
+// Value interface
+func (v Polygon) Value(ctx context.Context) (Value, error) {
+	return v, nil
+}
+
+func (v Polygon) Equals(other Value) bool {
+	// Cast other to LineString
+	_other, ok := other.(Polygon)
+	if !ok {
+		return false
+	}
+	// Check that they have same length
+	if len(v) != len(_other) {
+		return false
+	}
+
+	// Check that every point is equal
+	for i := 0; i < len(v); i++ {
+		if !v[i].Equals(_other[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+func (v Polygon) Less(nbf *NomsBinFormat, other LesserValuable) (bool, error) {
+	if v2, ok := other.(Polygon); ok {
+		return v[0].Less(nbf, v2[0])
+	}
+	return PolygonKind < other.Kind(), nil
+}
+
+func (v Polygon) Hash(nbf *NomsBinFormat) (hash.Hash, error) {
+	return getHash(v, nbf)
+}
+
+func (v Polygon) isPrimitive() bool {
+	return false
+}
+
+func (v Polygon) WalkValues(ctx context.Context, cb ValueCallback) error {
+	return nil
+}
+
+func (v Polygon) WalkRefs(nbf *NomsBinFormat, cb RefCallback) error {
+	return nil
+}
+
+func (v Polygon) typeOf() (*Type, error) {
+	return PrimitiveTypeMap[PolygonKind], nil
+}
+
+func (v Polygon) Kind() NomsKind {
+	return PolygonKind
+}
+
+func (v Polygon) valueReadWriter() ValueReadWriter {
+	return nil
+}
+
+func (v Polygon) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
+	err := PolygonKind.writeTo(w, nbf)
+	if err != nil {
+		return err
+	}
+
+	// TODO: might have to combine and comma separate
+	for _, l := range v {
+		l.writeTo(w, nbf)
+	}
+
+	return nil
+}
+
+func (v Polygon) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
+	// TODO: convert b.ReadString to []Point somehow
+	//return Linestring(b.ReadString()), nil
+	return Polygon([]Linestring{}), nil
+}
+
+func (v Polygon) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
+	b.skipString()
+}
+
+func (v Polygon) HumanReadableString() string {
+	var res []string
+	for _, l := range v {
+		res = append(res, l.HumanReadableString())
+	}
+	return strconv.Quote(strings.Join(res, ","))
+}
diff --git a/go/store/types/value_decoder.go b/go/store/types/value_decoder.go
index b6299c978d..26762ebf88 100644
--- a/go/store/types/value_decoder.go
+++ b/go/store/types/value_decoder.go
@@ -48,7 +48,6 @@ type CodecReader interface {
 	ReadDecimal() (decimal.Decimal, error)
 	ReadBlob() (Blob, error)
 	ReadJSON() (JSON, error)
-	ReadGeometry() (Point, error)
 }
 
 var _ CodecReader = (*valueDecoder)(nil)
@@ -85,10 +84,6 @@ func (r *valueDecoder) ReadJSON() (JSON, error) {
 	return readJSON(r.vrw.Format(), r)
 }
 
-func (r *valueDecoder) ReadGeometry() (Point, error) {
-	return Point(1), nil
-}
-
 func (r *valueDecoder) readRef(nbf *NomsBinFormat) (Ref, error) {
 	return readRef(nbf, &(r.typedBinaryNomsReader))
 }
@@ -361,8 +356,15 @@ func (r *valueDecoder) readValue(nbf *NomsBinFormat) (Value, error) {
 		return r.readTuple(nbf)
 	case JSONKind:
 		return r.ReadJSON()
-	case GeometryKind:
-		return r.ReadGeometry()
+	case PointKind:
+		r.skipKind()
+		return Point(r.ReadString()), nil
+	case LinestringKind:
+		r.skipKind()
+		return Linestring([]Point{Point(r.ReadString())}), nil
+	case PolygonKind:
+		r.skipKind()
+		return Polygon([]Linestring{[]Point{Point(r.ReadString())}}), nil
 	case TypeKind:
 		r.skipKind()
 		return r.readType()
@@ -412,6 +414,15 @@ func (r *valueDecoder) SkipValue(nbf *NomsBinFormat) error {
 	case StringKind:
 		r.skipKind()
 		r.skipString()
+	case PointKind:
+		r.skipKind()
+		r.skipString()
+	case LinestringKind:
+		r.skipKind()
+		r.skipString()
+	case PolygonKind:
+		r.skipKind()
+		r.skipString()
 	case ListKind:
 		err := r.skipList(nbf)
 		if err != nil {

From b17832077f0b337c1c87204690bd1c84e28dcc38 Mon Sep 17 00:00:00 2001
From: JCOR11599 <JCOR11599@users.noreply.github.com>
Date: Mon, 20 Dec 2021 21:46:09 +0000
Subject: [PATCH 08/51] [ga-format-pr] Run go/utils/repofmt/format_repo.sh and
 go/Godeps/update.sh

---
 go/libraries/doltcore/schema/typeinfo/linestring.go | 1 +
 go/store/types/linestring.go                        | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
index e7e3702464..7cedc0b8c6 100644
--- a/go/libraries/doltcore/schema/typeinfo/linestring.go
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -17,6 +17,7 @@ package typeinfo
 import (
 	"context"
 	"fmt"
+
 	"github.com/dolthub/go-mysql-server/sql"
 
 	"github.com/dolthub/dolt/go/store/types"
diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
index b882baad04..9298ee6a46 100644
--- a/go/store/types/linestring.go
+++ b/go/store/types/linestring.go
@@ -108,11 +108,11 @@ func (v Linestring) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 
 func (v Linestring) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
 	val := b.ReadString()
-	val = val[len("linestring")+1:len(val)-1]
+	val = val[len("linestring")+1 : len(val)-1]
 	pStrings := strings.Split(val, "),")
 	var points []Point
 	for i, p := range pStrings {
-		if i != len(pStrings) - 1 {
+		if i != len(pStrings)-1 {
 			p = p + ")"
 		}
 		points = append(points, Point(p))

From c760445030a3c673a1cbcd31ef5dc1f4c99807e9 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Tue, 21 Dec 2021 11:05:06 -0800
Subject: [PATCH 09/51] linestring just needed to be primitive

---
 go/store/types/linestring.go | 2 +-
 go/store/types/point.go      | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
index b882baad04..46d93b45ed 100644
--- a/go/store/types/linestring.go
+++ b/go/store/types/linestring.go
@@ -69,7 +69,7 @@ func (v Linestring) Hash(nbf *NomsBinFormat) (hash.Hash, error) {
 }
 
 func (v Linestring) isPrimitive() bool {
-	return false
+	return true
 }
 
 func (v Linestring) WalkValues(ctx context.Context, cb ValueCallback) error {
diff --git a/go/store/types/point.go b/go/store/types/point.go
index c09bcc17ad..c2a90262a5 100644
--- a/go/store/types/point.go
+++ b/go/store/types/point.go
@@ -29,8 +29,7 @@ import (
 )
 
 // Point is a Noms Value wrapper around the primitive string type (for now).
-//TODO: type Point sql.PointValue
-type Point string
+type Point string // TODO: 16 bytes to fit 2 float64
 
 // Value interface
 func (v Point) Value(ctx context.Context) (Value, error) {

From c6e6dcaf02b688d79176c783523e8b0772ce3c79 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Wed, 22 Dec 2021 15:44:18 -0800
Subject: [PATCH 10/51] change linestring to be string, instead of []point in
 dolt layer

---
 .../doltcore/schema/typeinfo/linestring.go    | 21 +++-----
 go/store/types/linestring.go                  | 52 +++----------------
 go/store/types/noms_kind.go                   |  2 +-
 go/store/types/value_decoder.go               |  4 +-
 4 files changed, 17 insertions(+), 62 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
index 7cedc0b8c6..2d15b6d6e8 100644
--- a/go/libraries/doltcore/schema/typeinfo/linestring.go
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -17,7 +17,6 @@ package typeinfo
 import (
 	"context"
 	"fmt"
-
 	"github.com/dolthub/go-mysql-server/sql"
 
 	"github.com/dolthub/dolt/go/store/types"
@@ -69,17 +68,11 @@ func (ti *linestringType) ConvertValueToNomsValue(ctx context.Context, vrw types
 		return nil, err
 	}
 
-	var res []types.Point
-	for _, pv := range strVal.(sql.LinestringValue).Points {
-		p, err := PointType.ConvertValueToNomsValue(ctx, vrw, pv)
-		if err != nil {
-			return nil, err
-		}
-		res = append(res, p.(types.Point))
+	if val, ok := strVal.(string); ok {
+		return types.Linestring(val), nil
 	}
 
-	return types.Linestring(res), nil
-	//return nil, fmt.Errorf(`"%v" cannot convert value "%v" of type "%T" as it is invalid`, ti.String(), v, v)
+	return nil, fmt.Errorf(`"%v" cannot convert value "%v" of type "%T" as it is invalid`, ti.String(), v, v)
 }
 
 // Equals implements TypeInfo interface.
@@ -125,11 +118,9 @@ func (ti *linestringType) GetTypeParams() map[string]string {
 // IsValid implements TypeInfo interface.
 func (ti *linestringType) IsValid(v types.Value) bool {
 	if val, ok := v.(types.Linestring); ok {
-		// LineString is valid if every point in it is valid
-		for _, p := range val {
-			if !PointType.IsValid(p) {
-				return false
-			}
+		_, err := ti.sqlLinestringType.Convert(string(val))
+		if err != nil {
+			return false
 		}
 		return true
 	}
diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
index 58d28f2d3b..eaa0b6b4f8 100644
--- a/go/store/types/linestring.go
+++ b/go/store/types/linestring.go
@@ -23,14 +23,12 @@ package types
 
 import (
 	"context"
-	"strconv"
-	"strings"
-
 	"github.com/dolthub/dolt/go/store/hash"
+	"strconv"
 )
 
 // Linestring is a Noms Value wrapper around an array of Point.
-type Linestring []Point
+type Linestring string
 
 // Value interface
 func (v Linestring) Value(ctx context.Context) (Value, error) {
@@ -38,28 +36,12 @@ func (v Linestring) Value(ctx context.Context) (Value, error) {
 }
 
 func (v Linestring) Equals(other Value) bool {
-	// Cast other to LineString
-	_other, ok := other.(Linestring)
-	if !ok {
-		return false
-	}
-	// Check that they have same length
-	if len(v) != len(_other) {
-		return false
-	}
-
-	// Check that every point is equal
-	for i := 0; i < len(v); i++ {
-		if !v[i].Equals(_other[i]) {
-			return false
-		}
-	}
-	return true
+	return v == other
 }
 
 func (v Linestring) Less(nbf *NomsBinFormat, other LesserValuable) (bool, error) {
 	if v2, ok := other.(Linestring); ok {
-		return v[0].Less(nbf, v2[0])
+		return v < v2, nil
 	}
 	return LinestringKind < other.Kind(), nil
 }
@@ -94,31 +76,17 @@ func (v Linestring) valueReadWriter() ValueReadWriter {
 
 func (v Linestring) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	err := LinestringKind.writeTo(w, nbf)
+
 	if err != nil {
 		return err
 	}
 
-	// TODO: might have to combine and comma separate
-	for _, p := range v {
-		p.writeTo(w, nbf)
-	}
-
+	w.writeString(string(v))
 	return nil
 }
 
 func (v Linestring) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
-	val := b.ReadString()
-	val = val[len("linestring")+1 : len(val)-1]
-	pStrings := strings.Split(val, "),")
-	var points []Point
-	for i, p := range pStrings {
-		if i != len(pStrings)-1 {
-			p = p + ")"
-		}
-		points = append(points, Point(p))
-	}
-
-	return Linestring(points), nil
+	return Point(b.ReadString()), nil
 }
 
 func (v Linestring) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
@@ -126,9 +94,5 @@ func (v Linestring) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
 }
 
 func (v Linestring) HumanReadableString() string {
-	var res []string
-	for _, p := range v {
-		res = append(res, p.HumanReadableString())
-	}
-	return strconv.Quote(strings.Join(res, ","))
+	return strconv.Quote(string(v))
 }
diff --git a/go/store/types/noms_kind.go b/go/store/types/noms_kind.go
index ee56425c37..77cfbe8570 100644
--- a/go/store/types/noms_kind.go
+++ b/go/store/types/noms_kind.go
@@ -87,7 +87,7 @@ func init() {
 	KindToType[DecimalKind] = Decimal{}
 	KindToType[JSONKind] = JSON{}
 	KindToType[PointKind] = Point("")
-	KindToType[LinestringKind] = Linestring([]Point{})
+	KindToType[LinestringKind] = Linestring("")
 	KindToType[PolygonKind] = Polygon([]Linestring{})
 
 	SupportedKinds[BlobKind] = true
diff --git a/go/store/types/value_decoder.go b/go/store/types/value_decoder.go
index 26762ebf88..ea4461dde0 100644
--- a/go/store/types/value_decoder.go
+++ b/go/store/types/value_decoder.go
@@ -361,10 +361,10 @@ func (r *valueDecoder) readValue(nbf *NomsBinFormat) (Value, error) {
 		return Point(r.ReadString()), nil
 	case LinestringKind:
 		r.skipKind()
-		return Linestring([]Point{Point(r.ReadString())}), nil
+		return Linestring(r.ReadString()), nil
 	case PolygonKind:
 		r.skipKind()
-		return Polygon([]Linestring{[]Point{Point(r.ReadString())}}), nil
+		return Polygon([]Linestring{Linestring(r.ReadString())}), nil
 	case TypeKind:
 		r.skipKind()
 		return r.readType()

From 5982ea28445bb2bedcbf7599158ed5f2411682e7 Mon Sep 17 00:00:00 2001
From: JCOR11599 <JCOR11599@users.noreply.github.com>
Date: Wed, 22 Dec 2021 23:45:16 +0000
Subject: [PATCH 11/51] [ga-format-pr] Run go/utils/repofmt/format_repo.sh and
 go/Godeps/update.sh

---
 go/libraries/doltcore/schema/typeinfo/linestring.go | 1 +
 go/store/types/linestring.go                        | 3 ++-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
index 2d15b6d6e8..e331c564a9 100644
--- a/go/libraries/doltcore/schema/typeinfo/linestring.go
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -17,6 +17,7 @@ package typeinfo
 import (
 	"context"
 	"fmt"
+
 	"github.com/dolthub/go-mysql-server/sql"
 
 	"github.com/dolthub/dolt/go/store/types"
diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
index eaa0b6b4f8..d03508f4f5 100644
--- a/go/store/types/linestring.go
+++ b/go/store/types/linestring.go
@@ -23,8 +23,9 @@ package types
 
 import (
 	"context"
-	"github.com/dolthub/dolt/go/store/hash"
 	"strconv"
+
+	"github.com/dolthub/dolt/go/store/hash"
 )
 
 // Linestring is a Noms Value wrapper around an array of Point.

From 50cdf5dfe53b8ab8aa80f5690815a24d572a20f3 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Mon, 27 Dec 2021 11:53:00 -0800
Subject: [PATCH 12/51] added polygons

---
 .../doltcore/schema/typeinfo/polygon.go       | 36 +++++----------
 go/store/types/linestring.go                  |  3 +-
 go/store/types/noms_kind.go                   |  2 +-
 go/store/types/polygon.go                     | 46 ++++---------------
 go/store/types/value_decoder.go               |  2 +-
 5 files changed, 23 insertions(+), 66 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
index bf804cdc30..ed67f3cf99 100644
--- a/go/libraries/doltcore/schema/typeinfo/polygon.go
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -17,8 +17,6 @@ package typeinfo
 import (
 	"context"
 	"fmt"
-	"strings"
-
 	"github.com/dolthub/go-mysql-server/sql"
 
 	"github.com/dolthub/dolt/go/store/types"
@@ -37,11 +35,7 @@ var PolygonType = &polygonType{sql.Polygon}
 // ConvertNomsValueToValue implements TypeInfo interface.
 func (ti *polygonType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
 	if val, ok := v.(types.Linestring); ok {
-		var res []string
-		for _, l := range val {
-			res = append(res, string(l))
-		}
-		return strings.Join(res, ","), nil
+		return val, nil
 	}
 	if _, ok := v.(types.Null); ok || v == nil {
 		return nil, nil
@@ -74,13 +68,11 @@ func (ti *polygonType) ConvertValueToNomsValue(ctx context.Context, vrw types.Va
 		return nil, err
 	}
 
-	//val, ok := strVal.(string)
-	_, ok := strVal.(string)
-	if !ok {
-		return nil, fmt.Errorf(`"%v" cannot convert value "%v" of type "%T" as it is invalid`, ti.String(), v, v)
+	if val, ok := strVal.(string); ok {
+		return types.Polygon(val), nil
 	}
-	// TODO: figure out string constructor
-	return types.Polygon([]types.Linestring{}), nil
+
+	return nil, fmt.Errorf(`"%v" cannot convert value "%v" of type "%T" as it is invalid`, ti.String(), v, v)
 }
 
 // Equals implements TypeInfo interface.
@@ -88,8 +80,8 @@ func (ti *polygonType) Equals(other TypeInfo) bool {
 	if other == nil {
 		return false
 	}
-	if ti2, ok := other.(*linestringType); ok {
-		return ti.sqlPolygonType.Type() == ti2.sqlLinestringType.Type()
+	if ti2, ok := other.(*polygonType); ok {
+		return ti.sqlPolygonType.Type() == ti2.sqlPolygonType.Type()
 	}
 	return false
 }
@@ -125,16 +117,10 @@ func (ti *polygonType) GetTypeParams() map[string]string {
 
 // IsValid implements TypeInfo interface.
 func (ti *polygonType) IsValid(v types.Value) bool {
-	if val, ok := v.(types.Polygon); ok {
-		// Polygon is valid if every linestring in it is valid
-		// TODO: figure out how to call linetype.isvalid
-		for _, l := range val {
-			for _, p := range l {
-				_, err := ti.sqlPolygonType.Convert(string(p))
-				if err != nil {
-					return false
-				}
-			}
+	if val, ok := v.(types.Linestring); ok {
+		_, err := ti.sqlPolygonType.Convert(string(val))
+		if err != nil {
+			return false
 		}
 		return true
 	}
diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
index eaa0b6b4f8..e37cdfd715 100644
--- a/go/store/types/linestring.go
+++ b/go/store/types/linestring.go
@@ -27,7 +27,7 @@ import (
 	"strconv"
 )
 
-// Linestring is a Noms Value wrapper around an array of Point.
+// Linestring is a Noms Value wrapper around a string.
 type Linestring string
 
 // Value interface
@@ -76,7 +76,6 @@ func (v Linestring) valueReadWriter() ValueReadWriter {
 
 func (v Linestring) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	err := LinestringKind.writeTo(w, nbf)
-
 	if err != nil {
 		return err
 	}
diff --git a/go/store/types/noms_kind.go b/go/store/types/noms_kind.go
index 77cfbe8570..d8a18ea118 100644
--- a/go/store/types/noms_kind.go
+++ b/go/store/types/noms_kind.go
@@ -88,7 +88,7 @@ func init() {
 	KindToType[JSONKind] = JSON{}
 	KindToType[PointKind] = Point("")
 	KindToType[LinestringKind] = Linestring("")
-	KindToType[PolygonKind] = Polygon([]Linestring{})
+	KindToType[PolygonKind] = Polygon("")
 
 	SupportedKinds[BlobKind] = true
 	SupportedKinds[BoolKind] = true
diff --git a/go/store/types/polygon.go b/go/store/types/polygon.go
index 55f33ad965..817b607a0e 100644
--- a/go/store/types/polygon.go
+++ b/go/store/types/polygon.go
@@ -23,14 +23,12 @@ package types
 
 import (
 	"context"
-	"strconv"
-	"strings"
-
 	"github.com/dolthub/dolt/go/store/hash"
+	"strconv"
 )
 
-// Polygon is a Noms Value wrapper around an array of Point.
-type Polygon []Linestring
+// Polygon is a Noms Value wrapper around a string.
+type Polygon string
 
 // Value interface
 func (v Polygon) Value(ctx context.Context) (Value, error) {
@@ -38,28 +36,12 @@ func (v Polygon) Value(ctx context.Context) (Value, error) {
 }
 
 func (v Polygon) Equals(other Value) bool {
-	// Cast other to LineString
-	_other, ok := other.(Polygon)
-	if !ok {
-		return false
-	}
-	// Check that they have same length
-	if len(v) != len(_other) {
-		return false
-	}
-
-	// Check that every point is equal
-	for i := 0; i < len(v); i++ {
-		if !v[i].Equals(_other[i]) {
-			return false
-		}
-	}
-	return true
+	return v == other
 }
 
 func (v Polygon) Less(nbf *NomsBinFormat, other LesserValuable) (bool, error) {
 	if v2, ok := other.(Polygon); ok {
-		return v[0].Less(nbf, v2[0])
+		return v < v2, nil
 	}
 	return PolygonKind < other.Kind(), nil
 }
@@ -69,7 +51,7 @@ func (v Polygon) Hash(nbf *NomsBinFormat) (hash.Hash, error) {
 }
 
 func (v Polygon) isPrimitive() bool {
-	return false
+	return true
 }
 
 func (v Polygon) WalkValues(ctx context.Context, cb ValueCallback) error {
@@ -98,18 +80,12 @@ func (v Polygon) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 		return err
 	}
 
-	// TODO: might have to combine and comma separate
-	for _, l := range v {
-		l.writeTo(w, nbf)
-	}
-
+	w.writeString(string(v))
 	return nil
 }
 
 func (v Polygon) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
-	// TODO: convert b.ReadString to []Point somehow
-	//return Linestring(b.ReadString()), nil
-	return Polygon([]Linestring{}), nil
+	return Polygon(b.ReadString()), nil
 }
 
 func (v Polygon) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
@@ -117,9 +93,5 @@ func (v Polygon) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
 }
 
 func (v Polygon) HumanReadableString() string {
-	var res []string
-	for _, l := range v {
-		res = append(res, l.HumanReadableString())
-	}
-	return strconv.Quote(strings.Join(res, ","))
+	return strconv.Quote(string(v))
 }
diff --git a/go/store/types/value_decoder.go b/go/store/types/value_decoder.go
index ea4461dde0..17da985e93 100644
--- a/go/store/types/value_decoder.go
+++ b/go/store/types/value_decoder.go
@@ -364,7 +364,7 @@ func (r *valueDecoder) readValue(nbf *NomsBinFormat) (Value, error) {
 		return Linestring(r.ReadString()), nil
 	case PolygonKind:
 		r.skipKind()
-		return Polygon([]Linestring{Linestring(r.ReadString())}), nil
+		return Polygon(r.ReadString()), nil
 	case TypeKind:
 		r.skipKind()
 		return r.readType()

From a2a8bdf8315f924de443cdc3c7dd2b9675c41f8e Mon Sep 17 00:00:00 2001
From: JCOR11599 <JCOR11599@users.noreply.github.com>
Date: Mon, 27 Dec 2021 22:20:22 +0000
Subject: [PATCH 13/51] [ga-format-pr] Run go/utils/repofmt/format_repo.sh and
 go/Godeps/update.sh

---
 go/libraries/doltcore/schema/typeinfo/polygon.go | 1 +
 go/store/types/polygon.go                        | 3 ++-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
index ed67f3cf99..a940588d72 100644
--- a/go/libraries/doltcore/schema/typeinfo/polygon.go
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -17,6 +17,7 @@ package typeinfo
 import (
 	"context"
 	"fmt"
+
 	"github.com/dolthub/go-mysql-server/sql"
 
 	"github.com/dolthub/dolt/go/store/types"
diff --git a/go/store/types/polygon.go b/go/store/types/polygon.go
index 817b607a0e..d50e5ce72a 100644
--- a/go/store/types/polygon.go
+++ b/go/store/types/polygon.go
@@ -23,8 +23,9 @@ package types
 
 import (
 	"context"
-	"github.com/dolthub/dolt/go/store/hash"
 	"strconv"
+
+	"github.com/dolthub/dolt/go/store/hash"
 )
 
 // Polygon is a Noms Value wrapper around a string.

From 4e885db7d12f36788d21f97fc174eeff672649ac Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Mon, 27 Dec 2021 16:30:35 -0800
Subject: [PATCH 14/51] small change

---
 go/store/types/linestring.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
index 019cdd9136..12a9e5b0c4 100644
--- a/go/store/types/linestring.go
+++ b/go/store/types/linestring.go
@@ -86,7 +86,8 @@ func (v Linestring) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 }
 
 func (v Linestring) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
-	return Point(b.ReadString()), nil
+	return Linestring(b.ReadString()), nil
+
 }
 
 func (v Linestring) skip(nbf *NomsBinFormat, b *binaryNomsReader) {

From f08a9cab5be9ef738bc36cf53aca13b1b7703e62 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Tue, 28 Dec 2021 15:34:40 -0800
Subject: [PATCH 15/51] updating types

---
 .../doltcore/schema/typeinfo/point.go         | 40 ++++++++++++++-----
 go/libraries/doltcore/sqle/sqlutil/sql_row.go | 30 +++++++-------
 2 files changed, 45 insertions(+), 25 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index 8d0fc49b53..beb0bba6f1 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -17,6 +17,8 @@ package typeinfo
 import (
 	"context"
 	"fmt"
+	"strconv"
+	"strings"
 
 	"github.com/dolthub/go-mysql-server/sql"
 
@@ -31,13 +33,30 @@ type pointType struct {
 
 var _ TypeInfo = (*pointType)(nil)
 
-var PointType = &pointType{sql.Point}
+var PointType = &pointType{sql.PointType{}}
 
 // ConvertNomsValueToValue implements TypeInfo interface.
 func (ti *pointType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
+	// Expect a types.Point, return a sql.Point
 	if val, ok := v.(types.Point); ok {
-		return val, nil
+		// Get everything between parentheses
+		val = val[len("point("):len(val)-1]
+		// Split into x and y strings; maybe should length check
+		vals := strings.Split(string(val), ",")
+		// Parse x as float64
+		x, err := strconv.ParseFloat(vals[0], 64)
+		if err != nil {
+			return nil, err
+		}
+		// Parse y as float64
+		y, err := strconv.ParseFloat(vals[1], 64)
+		if err != nil {
+			return nil, err
+		}
+		// Create sql.Point object
+		return sql.Point{X: x, Y: y}, nil
 	}
+	// Check for null
 	if _, ok := v.(types.Null); ok || v == nil {
 		return nil, nil
 	}
@@ -53,27 +72,30 @@ func (ti *pointType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecReader
 		return s, nil
 	case types.NullKind:
 		return nil, nil
+	default:
+		return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), k)
 	}
-
-	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), k)
 }
 
 // ConvertValueToNomsValue implements TypeInfo interface.
 func (ti *pointType) ConvertValueToNomsValue(ctx context.Context, vrw types.ValueReadWriter, v interface{}) (types.Value, error) {
+	// Check for null
 	if v == nil {
 		return types.NullValue, nil
 	}
 
-	strVal, err := ti.sqlPointType.Convert(v)
+	// Convert to sql.PointType
+	point, err := ti.sqlPointType.Convert(v)
 	if err != nil {
 		return nil, err
 	}
+	p := point.(sql.Point)
 
-	if val, ok := strVal.(string); ok {
-		return types.Point(val), nil
-	}
+	// Convert point to string / types.Point
+	pointStr := fmt.Sprintf("POINT(%s, %s)",strconv.FormatFloat(p.X, 'g', -1, 64), strconv.FormatFloat(p.Y, 'g', -1, 64))
 
-	return nil, fmt.Errorf(`"%v" cannot convert value "%v" of type "%T" as it is invalid`, ti.String(), v, v)
+	// Create types.Point
+	return types.Point(pointStr), nil
 }
 
 // Equals implements TypeInfo interface.
diff --git a/go/libraries/doltcore/sqle/sqlutil/sql_row.go b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
index cb86e5ad1b..c287b5904f 100644
--- a/go/libraries/doltcore/sqle/sqlutil/sql_row.go
+++ b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
@@ -19,6 +19,7 @@ import (
 	"errors"
 	"fmt"
 	"strconv"
+	"strings"
 	"time"
 
 	"github.com/dolthub/go-mysql-server/sql"
@@ -302,24 +303,21 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 			}
 		case time.Time:
 			return typedCol.Format("2006-01-02 15:04:05.999999 -0700 MST")
-		case sql.PointValue:
-			s, err := typedCol.ToString()
-			if err != nil {
-				s = err.Error()
+		case sql.Point:
+			// TODO: Convert to byte array to match MySQL; leave for readability
+			return fmt.Sprintf("POINT(%s, %s)",strconv.FormatFloat(typedCol.X, 'g', -1, 64), strconv.FormatFloat(typedCol.Y, 'g', -1, 64))
+		case sql.Linestring:
+			var s = make([]string, len(typedCol.Points))
+			for i, p := range typedCol.Points {
+				s[i] = SqlColToStr(ctx, p)
 			}
-			return s
-		case sql.LinestringValue:
-			s, err := typedCol.ToString()
-			if err != nil {
-				s = err.Error()
+			return fmt.Sprintf("LINESTRING(%s)", strings.Join(s, ","))
+		case sql.Polygon:
+			var s = make([]string, len(typedCol.Lines))
+			for i, l := range typedCol.Lines {
+				s[i] = SqlColToStr(ctx, l)
 			}
-			return s
-		case sql.PolygonValue:
-			s, err := typedCol.ToString()
-			if err != nil {
-				s = err.Error()
-			}
-			return s
+			return fmt.Sprintf("POLYGON(%s)", strings.Join(s, ","))
 		case sql.JSONValue:
 			s, err := typedCol.ToString(sql.NewContext(ctx))
 			if err != nil {

From d0820c6b4e4b930d9317f9b962b8cac46d744175 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Tue, 28 Dec 2021 21:40:59 -0800
Subject: [PATCH 16/51] updating spatial types

---
 .../doltcore/schema/typeinfo/linestring.go    | 62 +++++++++++++++---
 .../doltcore/schema/typeinfo/point.go         | 56 +++++++++-------
 .../doltcore/schema/typeinfo/polygon.go       | 64 +++++++++++++++----
 3 files changed, 137 insertions(+), 45 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
index e331c564a9..6c07865129 100644
--- a/go/libraries/doltcore/schema/typeinfo/linestring.go
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -17,6 +17,7 @@ package typeinfo
 import (
 	"context"
 	"fmt"
+	"strings"
 
 	"github.com/dolthub/go-mysql-server/sql"
 
@@ -31,13 +32,43 @@ type linestringType struct {
 
 var _ TypeInfo = (*linestringType)(nil)
 
-var LinestringType = &linestringType{sql.Linestring}
+var LinestringType = &linestringType{sql.LinestringType{}}
+
+func ConvertStringToSQLLinestring(s string) (interface{}, error) {
+	// Get everything between parentheses
+	s = s[len("LINESTRING("):len(s)-1]
+	// Split into points
+	vals := strings.Split(s, ",POINT")
+	// Parse points
+	var points = make([]sql.Point, len(vals))
+	for i, s := range vals {
+		// Re-add delimiter
+		if i != 0 {
+			s = "POINT" + s
+		}
+		// Convert to Point type
+		point, err := ConvertStringToSQLPoint(s)
+		// TODO: This is never true
+		if err != nil {
+			return nil, err
+		}
+		// TODO: necessary? should throw error
+		if point == nil {
+			return nil, nil
+		}
+		points[i] = point.(sql.Point)
+	}
+	// Create sql.Linestring object
+	return sql.Linestring{Points: points}, nil
+}
 
 // ConvertNomsValueToValue implements TypeInfo interface.
 func (ti *linestringType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
+	// Expect a types.Linestring, return a sql.Linestring
 	if val, ok := v.(types.Linestring); ok {
-		return val, nil
+		return ConvertStringToSQLLinestring(string(val))
 	}
+	// Check for null
 	if _, ok := v.(types.Null); ok || v == nil {
 		return nil, nil
 	}
@@ -49,8 +80,7 @@ func (ti *linestringType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecR
 	k := reader.ReadKind()
 	switch k {
 	case types.LinestringKind:
-		s := reader.ReadString()
-		return s, nil
+		return reader.ReadString(), nil
 	case types.NullKind:
 		return nil, nil
 	}
@@ -58,22 +88,34 @@ func (ti *linestringType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecR
 	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), k)
 }
 
+func ConvertSQLLinestringToString(l sql.Linestring) (types.Linestring, error) {
+	// Convert each sql.Point into types.Point
+	var pointStrs = make([]string, len(l.Points))
+	for i, p := range l.Points {
+		pointStr, err := ConvertSQLPointToString(p)
+		if err != nil {
+			return "", err
+		}
+		pointStrs[i] = string(pointStr)
+	}
+	lineStr := fmt.Sprintf("LINESTRING(%s)", strings.Join(pointStrs, ","))
+	return types.Linestring(lineStr), nil
+}
+
 // ConvertValueToNomsValue implements TypeInfo interface.
 func (ti *linestringType) ConvertValueToNomsValue(ctx context.Context, vrw types.ValueReadWriter, v interface{}) (types.Value, error) {
+	// Check for null
 	if v == nil {
 		return types.NullValue, nil
 	}
 
-	strVal, err := ti.sqlLinestringType.Convert(v)
+	// Convert to sql.LinestringType
+	line, err := ti.sqlLinestringType.Convert(v)
 	if err != nil {
 		return nil, err
 	}
 
-	if val, ok := strVal.(string); ok {
-		return types.Linestring(val), nil
-	}
-
-	return nil, fmt.Errorf(`"%v" cannot convert value "%v" of type "%T" as it is invalid`, ti.String(), v, v)
+	return ConvertSQLLinestringToString(line.(sql.Linestring))
 }
 
 // Equals implements TypeInfo interface.
diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index beb0bba6f1..277767c8c6 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -35,26 +35,30 @@ var _ TypeInfo = (*pointType)(nil)
 
 var PointType = &pointType{sql.PointType{}}
 
+func ConvertStringToSQLPoint(s string) (interface{}, error) {
+	// Get everything between parentheses
+	s = s[len("POINT("):len(s)-1]
+	// Split into x and y strings; maybe should length check
+	vals := strings.Split(s, ",")
+	// Parse x as float64
+	x, err := strconv.ParseFloat(vals[0], 64)
+	if err != nil {
+		return nil, err
+	}
+	// Parse y as float64
+	y, err := strconv.ParseFloat(vals[1], 64)
+	if err != nil {
+		return nil, err
+	}
+	// Create sql.Point object
+	return sql.Point{X: x, Y: y}, nil
+}
+
 // ConvertNomsValueToValue implements TypeInfo interface.
 func (ti *pointType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
 	// Expect a types.Point, return a sql.Point
 	if val, ok := v.(types.Point); ok {
-		// Get everything between parentheses
-		val = val[len("point("):len(val)-1]
-		// Split into x and y strings; maybe should length check
-		vals := strings.Split(string(val), ",")
-		// Parse x as float64
-		x, err := strconv.ParseFloat(vals[0], 64)
-		if err != nil {
-			return nil, err
-		}
-		// Parse y as float64
-		y, err := strconv.ParseFloat(vals[1], 64)
-		if err != nil {
-			return nil, err
-		}
-		// Create sql.Point object
-		return sql.Point{X: x, Y: y}, nil
+		return ConvertStringToSQLPoint(string(val))
 	}
 	// Check for null
 	if _, ok := v.(types.Null); ok || v == nil {
@@ -68,8 +72,7 @@ func (ti *pointType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecReader
 	k := reader.ReadKind()
 	switch k {
 	case types.PointKind:
-		s := reader.ReadString()
-		return s, nil
+		return reader.ReadString(), nil
 	case types.NullKind:
 		return nil, nil
 	default:
@@ -77,6 +80,16 @@ func (ti *pointType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecReader
 	}
 }
 
+func ConvertSQLPointToString(p sql.Point) (types.Point, error) {
+	// Convert point to string / types.Point
+	x := strconv.FormatFloat(p.X, 'g', -1, 64)
+	y := strconv.FormatFloat(p.Y, 'g', -1, 64)
+	pointStr := fmt.Sprintf("POINT(%s, %s)", x, y)
+
+	// Create types.Point
+	return types.Point(pointStr), nil
+}
+
 // ConvertValueToNomsValue implements TypeInfo interface.
 func (ti *pointType) ConvertValueToNomsValue(ctx context.Context, vrw types.ValueReadWriter, v interface{}) (types.Value, error) {
 	// Check for null
@@ -89,13 +102,8 @@ func (ti *pointType) ConvertValueToNomsValue(ctx context.Context, vrw types.Valu
 	if err != nil {
 		return nil, err
 	}
-	p := point.(sql.Point)
 
-	// Convert point to string / types.Point
-	pointStr := fmt.Sprintf("POINT(%s, %s)",strconv.FormatFloat(p.X, 'g', -1, 64), strconv.FormatFloat(p.Y, 'g', -1, 64))
-
-	// Create types.Point
-	return types.Point(pointStr), nil
+	return ConvertSQLPointToString(point.(sql.Point))
 }
 
 // Equals implements TypeInfo interface.
diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
index a940588d72..fd5d0714c5 100644
--- a/go/libraries/doltcore/schema/typeinfo/polygon.go
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -17,6 +17,7 @@ package typeinfo
 import (
 	"context"
 	"fmt"
+	"strings"
 
 	"github.com/dolthub/go-mysql-server/sql"
 
@@ -31,13 +32,43 @@ type polygonType struct {
 
 var _ TypeInfo = (*polygonType)(nil)
 
-var PolygonType = &polygonType{sql.Polygon}
+var PolygonType = &polygonType{sql.PolygonType{}}
+
+func ConvertStringToSQLPolygon(s string) (interface{}, error) {
+	// Get everything between parentheses
+	s = s[len("POLYGON("):len(s)-1]
+	// Split into lines
+	vals := strings.Split(s, ",LINESTRING")
+	// Parse points
+	var lines = make([]sql.Linestring, len(vals))
+	for i, s := range vals {
+		// Re-add delimiter
+		if i != 0 {
+			s = "LINESTRING" + s
+		}
+		// Convert to Linestring type
+		line, err := ConvertStringToSQLLinestring(s)
+		// TODO: This is never true
+		if err != nil {
+			return nil, err
+		}
+		// TODO: necessary? should throw error
+		if line == nil {
+			return nil, nil
+		}
+		lines[i] = line.(sql.Linestring)
+	}
+	// Create sql.Polygon object
+	return sql.Polygon{Lines: lines}, nil
+}
 
 // ConvertNomsValueToValue implements TypeInfo interface.
 func (ti *polygonType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
-	if val, ok := v.(types.Linestring); ok {
-		return val, nil
+	// Expect a types.Polygon, return a sql.Polygon
+	if val, ok := v.(types.Polygon); ok {
+		return ConvertStringToSQLPolygon(string(val))
 	}
+	// Check for null
 	if _, ok := v.(types.Null); ok || v == nil {
 		return nil, nil
 	}
@@ -49,8 +80,7 @@ func (ti *polygonType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecRead
 	k := reader.ReadKind()
 	switch k {
 	case types.PolygonKind:
-		s := reader.ReadString()
-		return s, nil
+		return reader.ReadString(), nil
 	case types.NullKind:
 		return nil, nil
 	}
@@ -58,22 +88,34 @@ func (ti *polygonType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecRead
 	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), k)
 }
 
+func ConvertSQLPolygonToString(p sql.Polygon) (types.Polygon, error) {
+	// Convert each sql.Point into types.Point
+	var lineStrs = make([]string, len(p.Lines))
+	for i, l := range p.Lines {
+		lineStr, err := ConvertSQLLinestringToString(l)
+		if err != nil {
+			return "", err
+		}
+		lineStrs[i] = string(lineStr)
+	}
+	polygonStr := fmt.Sprintf("POLYGON(%s)", strings.Join(lineStrs, ","))
+	return types.Polygon(polygonStr), nil
+}
+
 // ConvertValueToNomsValue implements TypeInfo interface.
 func (ti *polygonType) ConvertValueToNomsValue(ctx context.Context, vrw types.ValueReadWriter, v interface{}) (types.Value, error) {
+	// Check for null
 	if v == nil {
 		return types.NullValue, nil
 	}
 
-	strVal, err := ti.sqlPolygonType.Convert(v)
+	// Convert to sql.PolygonType
+	polygon, err := ti.sqlPolygonType.Convert(v)
 	if err != nil {
 		return nil, err
 	}
 
-	if val, ok := strVal.(string); ok {
-		return types.Polygon(val), nil
-	}
-
-	return nil, fmt.Errorf(`"%v" cannot convert value "%v" of type "%T" as it is invalid`, ti.String(), v, v)
+	return ConvertSQLPolygonToString(polygon.(sql.Polygon))
 }
 
 // Equals implements TypeInfo interface.

From 438ab0f87f314b1203a58058e32e7642dadc2a51 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Tue, 28 Dec 2021 22:18:57 -0800
Subject: [PATCH 17/51] fixing small typos

---
 go/libraries/doltcore/schema/typeinfo/point.go    | 2 +-
 go/libraries/doltcore/schema/typeinfo/typeinfo.go | 6 +++---
 go/libraries/doltcore/sqle/sqlutil/sql_row.go     | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index 277767c8c6..0906c07a2f 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -84,7 +84,7 @@ func ConvertSQLPointToString(p sql.Point) (types.Point, error) {
 	// Convert point to string / types.Point
 	x := strconv.FormatFloat(p.X, 'g', -1, 64)
 	y := strconv.FormatFloat(p.Y, 'g', -1, 64)
-	pointStr := fmt.Sprintf("POINT(%s, %s)", x, y)
+	pointStr := fmt.Sprintf("POINT(%s,%s)", x, y)
 
 	// Create types.Point
 	return types.Point(pointStr), nil
diff --git a/go/libraries/doltcore/schema/typeinfo/typeinfo.go b/go/libraries/doltcore/schema/typeinfo/typeinfo.go
index bd61fd2b76..8ad0cca392 100644
--- a/go/libraries/doltcore/schema/typeinfo/typeinfo.go
+++ b/go/libraries/doltcore/schema/typeinfo/typeinfo.go
@@ -167,11 +167,11 @@ func FromSqlType(sqlType sql.Type) (TypeInfo, error) {
 	case sqltypes.Geometry:
 		// TODO: bad, but working way to determine which specific geometry type
 		switch sqlType.String() {
-		case sql.Polygon.String():
+		case sql.PolygonType{}.String():
 			return &polygonType{sqlType.(sql.PolygonType)}, nil
-		case sql.Linestring.String():
+		case sql.LinestringType{}.String():
 			return &linestringType{sqlType.(sql.LinestringType)}, nil
-		case sql.Point.String():
+		case sql.PointType{}.String():
 			return &pointType{sqlType.(sql.PointType)}, nil
 		default:
 			return nil, fmt.Errorf(`expected "PointTypeIdentifier" from SQL basetype "Point"`)
diff --git a/go/libraries/doltcore/sqle/sqlutil/sql_row.go b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
index c287b5904f..8fd4e286f8 100644
--- a/go/libraries/doltcore/sqle/sqlutil/sql_row.go
+++ b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
@@ -305,7 +305,7 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 			return typedCol.Format("2006-01-02 15:04:05.999999 -0700 MST")
 		case sql.Point:
 			// TODO: Convert to byte array to match MySQL; leave for readability
-			return fmt.Sprintf("POINT(%s, %s)",strconv.FormatFloat(typedCol.X, 'g', -1, 64), strconv.FormatFloat(typedCol.Y, 'g', -1, 64))
+			return fmt.Sprintf("POINT(%s,%s)",strconv.FormatFloat(typedCol.X, 'g', -1, 64), strconv.FormatFloat(typedCol.Y, 'g', -1, 64))
 		case sql.Linestring:
 			var s = make([]string, len(typedCol.Points))
 			for i, p := range typedCol.Points {

From cb6ed2739194e98f4a8a17ce5ef874153ac4f6a4 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Mon, 3 Jan 2022 10:12:12 -0800
Subject: [PATCH 18/51] deleting geometry

---
 .../sqle/geometry/noms_geometry_value.go      | 145 -------------
 go/store/types/geometry.go                    | 191 ------------------
 2 files changed, 336 deletions(-)
 delete mode 100644 go/libraries/doltcore/sqle/geometry/noms_geometry_value.go
 delete mode 100644 go/store/types/geometry.go

diff --git a/go/libraries/doltcore/sqle/geometry/noms_geometry_value.go b/go/libraries/doltcore/sqle/geometry/noms_geometry_value.go
deleted file mode 100644
index 1188b76295..0000000000
--- a/go/libraries/doltcore/sqle/geometry/noms_geometry_value.go
+++ /dev/null
@@ -1,145 +0,0 @@
-// Copyright 2021 Dolthub, 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 geometry
-
-/*import (
-	"context"
-	"errors"
-	"strings"
-
-	"github.com/dolthub/go-mysql-server/sql"
-
-	"github.com/dolthub/dolt/go/store/types"
-)
-
-var ErrUnexpectedGeometryTypeIn = errors.New("unexpected type during Geometry marshalling")
-var ErrUnexpectedGeometryTypeOut = errors.New("unexpected type during Geometry unmarshalling")
-
-const (
-	GeometryNull = "null"
-)
-
-// NomsGeometry is a type alias for types.Geometry. The alias allows MySQL-specific
-// logic to be kept separate from the storage-layer code in pkg types.
-type NomsGeometry types.Geometry
-
-var _ sql.GeometryValue = NomsGeometry{}
-
-// NomsGeometryFromGeometryValue converts a sql.GeometryValue to a NomsGeometry value.
-func NomsGeometryFromGeometryValue(ctx context.Context, vrw types.ValueReadWriter, val sql.GeometryValue) (NomsGeometry, error) {
-	if noms, ok := val.(NomsGeometry); ok {
-		return noms, nil
-	}
-
-	sqlObj, err := val.Unmarshall(sql.NewContext(ctx))
-	if err != nil {
-		return NomsGeometry{}, err
-	}
-
-	v, err := marshalGeometry(ctx, vrw, sqlObj.Val)
-	if err != nil {
-		return NomsGeometry{}, err
-	}
-
-	obj, err := types.NewGeometryObj(vrw.Format(), vrw, v)
-	if err != nil {
-		return NomsGeometry{}, err
-	}
-
-	return NomsGeometry(obj), nil
-}
-
-// marshalGeometry converts primitive interfaces to something from types package
-func marshalGeometry(ctx context.Context, vrw types.ValueReadWriter, val interface{}) (types.Value, error) {
-	if val == nil {
-		return types.NullValue, nil
-	}
-
-	// TODO: how is this supposed to work? Everything under geometry is multiple values?
-	switch val := val.(type) {
-	case bool: // TODO: this is impossible?
-		return types.Bool(val), nil
-	case sql.PointType:
-		return nil, nil
-	default:
-		return nil, ErrUnexpectedGeometryTypeIn
-	}
-}
-
-// Unmarshall implements the sql.Geometry interface.
-func (v NomsGeometry) Unmarshall(ctx *sql.Context) (doc sql.GeometryObject, err error) {
-	nomsVal, err := types.Geometry(v).Inner()
-	if err != nil {
-		return sql.GeometryObject{}, err
-	}
-
-	val, err := unmarshalGeometry(nomsVal)
-	if err != nil {
-		return sql.GeometryObject{}, err
-	}
-
-	return sql.GeometryObject{Val: val}, nil
-}
-
-func unmarshalGeometry(val types.Value) (interface{}, error) {
-	//switch val := val.(type) {
-	switch val.(type) {
-	case types.Null:
-		return nil, nil
-	default:
-		return nil, ErrUnexpectedGeometryTypeIn
-	}
-}
-
-// Compare implements the sql.GeometryValue interface.
-func (v NomsGeometry) Compare(ctx *sql.Context, other sql.GeometryValue) (cmp int, err error) {
-	noms, ok := other.(NomsGeometry)
-	if !ok {
-		doc, err := v.Unmarshall(ctx)
-		if err != nil {
-			return 0, err
-		}
-		return doc.Compare(ctx, other)
-	}
-
-	return types.Geometry(v).Compare(types.Geometry(noms))
-}
-
-// ToString implements the sql.GeometryValue interface.
-func (v NomsGeometry) ToString(ctx *sql.Context) (string, error) {
-	jd, err := types.Geometry(v).Inner()
-	if err != nil {
-		return "", err
-	}
-
-	sb := &strings.Builder{}
-	if err = marshalToString(ctx, sb, jd); err != nil {
-		return "", err
-	}
-
-	return sb.String(), nil
-}
-
-func marshalToString(ctx context.Context, sb *strings.Builder, val types.Value) (err error) {
-	//switch val := val.(type) {
-	switch val.(type) {
-	case types.Null:
-		sb.WriteString(GeometryNull)
-	default:
-		err = ErrUnexpectedGeometryTypeOut
-	}
-	return
-}
-*/
diff --git a/go/store/types/geometry.go b/go/store/types/geometry.go
deleted file mode 100644
index 0b19afbd6f..0000000000
--- a/go/store/types/geometry.go
+++ /dev/null
@@ -1,191 +0,0 @@
-// Copyright 2019 Dolthub, 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.
-//
-// This file incorporates work covered by the following copyright and
-// permission notice:
-//
-// Copyright 2016 Attic Labs, Inc. All rights reserved.
-// Licensed under the Apache License, version 2.0:
-// http://www.apache.org/licenses/LICENSE-2.0
-
-package types
-
-/*import (
-	"context"
-	"errors"
-	"fmt"
-	"github.com/dolthub/dolt/go/store/d"
-
-	"github.com/dolthub/dolt/go/store/hash"
-)
-
-type Geometry struct {
-	valueImpl
-}
-
-// NewGeometryObj wraps value in a Geometry value.
-func NewGeometryObj(nbf *NomsBinFormat, vrw ValueReadWriter, value Value) (Geometry, error) {
-	w := newBinaryNomsWriter()
-	if err := GeometryKind.writeTo(&w, nbf); err != nil {
-		return EmptyGeometryObj(nbf), err
-	}
-
-	if err := value.writeTo(&w, nbf); err != nil {
-		return EmptyGeometryObj(nbf), err
-	}
-
-	return Geometry{valueImpl{vrw, nbf, w.data(), nil}}, nil
-}
-
-// EmptyGeometryObj creates an empty Geometry value.
-func EmptyGeometryObj(nbf *NomsBinFormat) Geometry {
-	w := newBinaryNomsWriter()
-	if err := GeometryKind.writeTo(&w, nbf); err != nil {
-		d.PanicIfError(err)
-	}
-
-	return Geometry{valueImpl{nil, nbf, w.data(), nil}}
-}
-
-// readGeometry reads the data provided by a decoder and moves the decoder forward.
-func readGeometry(nbf *NomsBinFormat, dec *valueDecoder) (Geometry, error) {
-	start := dec.pos()
-
-	k := dec.PeekKind()
-	if k == NullKind {
-		dec.skipKind()
-		return EmptyGeometryObj(nbf), nil
-	}
-	if k != GeometryKind {
-		return Geometry{}, errors.New("current value is not a Geometry")
-	}
-
-	if err := skipGeometry(nbf, dec); err != nil {
-		return Geometry{}, err
-	}
-
-	end := dec.pos()
-	return Geometry{valueImpl{dec.vrw, nbf, dec.byteSlice(start, end), nil}}, nil
-}
-
-func skipGeometry(nbf *NomsBinFormat, dec *valueDecoder) error {
-	dec.skipKind()
-	return dec.SkipValue(nbf)
-}
-
-// Value implements the Value interface
-func (v Geometry) Value(ctx context.Context) (Value, error) {
-	return v, nil
-}
-
-// Inner returns the Geometry value's inner value.
-func (v Geometry) Inner() (Value, error) {
-	dec := newValueDecoder(v.buff, v.vrw)
-	dec.skipKind()
-	return dec.readValue(v.nbf)
-}
-
-// Equals implements the Value interface
-func (v Geometry) Equals(other Value) bool {
-	return other == nil || other.Kind() == GeometryKind
-}
-
-// Hash implements the Value interface
-func (v Geometry) Hash(nbf *NomsBinFormat) (hash.Hash, error) {
-	return getHash(NullValue, nbf)
-}
-
-// isPrimitive implements the Value interface
-func (v Geometry) isPrimitive() bool {
-	return false
-}
-
-// WalkValues implements the Value interface
-func (v Geometry) WalkValues(ctx context.Context, cb ValueCallback) error {
-	return nil
-}
-
-// WalkRefs implements the Value interface
-func (v Geometry) WalkRefs(nbf *NomsBinFormat, cb RefCallback) error {
-	return nil
-}
-
-func compareGeometry(a, b Value) (int, error) {
-	aNull := a.Kind() == NullKind
-	bNull := b.Kind() == NullKind
-	if aNull && bNull {
-		return 0, nil
-	} else if aNull && !bNull {
-		return -1, nil
-	} else if !aNull && bNull {
-		return 1, nil
-	}
-
-	switch a := a.(type) {
-	default:
-		return 0, fmt.Errorf("unexpected type: %v", a)
-	}
-}
-
-// Compare implements MySQL Geometry type compare semantics.
-func (t Geometry) Compare(other Geometry) (int, error) {
-	left, err := t.Inner()
-	if err != nil {
-		return 0, err
-	}
-
-	right, err := other.Inner()
-	if err != nil {
-		return 0, err
-	}
-
-	return compareGeometry(left, right)
-}
-
-// HumanReadableString implements the Value interface
-func (v Geometry) HumanReadableString() string {
-	val, err := v.Inner()
-	if err != nil {
-		d.PanicIfError(err)
-	}
-	h, err := val.Hash(v.nbf)
-	if err != nil {
-		d.PanicIfError(err)
-	}
-	return fmt.Sprintf("Geometry(%s)", h.String())
-}
-
-func (v Geometry) typeOf() (*Type, error) {
-	return PrimitiveTypeMap[GeometryKind], nil
-}
-
-// Kind implements the Valuable interface.
-func (v Geometry) Kind() NomsKind {
-	return GeometryKind
-}
-
-func (v Geometry) valueReadWriter() ValueReadWriter {
-	return nil
-}
-
-func (v Geometry) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
-	return GeometryKind.writeTo(w, nbf)
-}
-
-func (v Geometry) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
-	return NullValue, nil
-}
-
-func (v Geometry) skip(nbf *NomsBinFormat, b *binaryNomsReader) {}
-*/

From 2f06b45d862e0e12d78aca489a2d60b98310d97d Mon Sep 17 00:00:00 2001
From: JCOR11599 <JCOR11599@users.noreply.github.com>
Date: Thu, 6 Jan 2022 19:17:55 +0000
Subject: [PATCH 19/51] [ga-format-pr] Run go/utils/repofmt/format_repo.sh and
 go/Godeps/update.sh

---
 go/libraries/doltcore/schema/typeinfo/linestring.go | 2 +-
 go/libraries/doltcore/schema/typeinfo/point.go      | 2 +-
 go/libraries/doltcore/schema/typeinfo/polygon.go    | 2 +-
 go/libraries/doltcore/sqle/sqlutil/sql_row.go       | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
index 6c07865129..f941fafd70 100644
--- a/go/libraries/doltcore/schema/typeinfo/linestring.go
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -36,7 +36,7 @@ var LinestringType = &linestringType{sql.LinestringType{}}
 
 func ConvertStringToSQLLinestring(s string) (interface{}, error) {
 	// Get everything between parentheses
-	s = s[len("LINESTRING("):len(s)-1]
+	s = s[len("LINESTRING(") : len(s)-1]
 	// Split into points
 	vals := strings.Split(s, ",POINT")
 	// Parse points
diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index 0906c07a2f..2d6cd1fafa 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -37,7 +37,7 @@ var PointType = &pointType{sql.PointType{}}
 
 func ConvertStringToSQLPoint(s string) (interface{}, error) {
 	// Get everything between parentheses
-	s = s[len("POINT("):len(s)-1]
+	s = s[len("POINT(") : len(s)-1]
 	// Split into x and y strings; maybe should length check
 	vals := strings.Split(s, ",")
 	// Parse x as float64
diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
index fd5d0714c5..d9f1410fa9 100644
--- a/go/libraries/doltcore/schema/typeinfo/polygon.go
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -36,7 +36,7 @@ var PolygonType = &polygonType{sql.PolygonType{}}
 
 func ConvertStringToSQLPolygon(s string) (interface{}, error) {
 	// Get everything between parentheses
-	s = s[len("POLYGON("):len(s)-1]
+	s = s[len("POLYGON(") : len(s)-1]
 	// Split into lines
 	vals := strings.Split(s, ",LINESTRING")
 	// Parse points
diff --git a/go/libraries/doltcore/sqle/sqlutil/sql_row.go b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
index 4a7a37d2d7..2bbe8d40c5 100644
--- a/go/libraries/doltcore/sqle/sqlutil/sql_row.go
+++ b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
@@ -304,7 +304,7 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 			return typedCol.Format("2006-01-02 15:04:05.999999 -0700 MST")
 		case sql.Point:
 			// TODO: Convert to byte array to match MySQL; leave for readability
-			return fmt.Sprintf("POINT(%s,%s)",strconv.FormatFloat(typedCol.X, 'g', -1, 64), strconv.FormatFloat(typedCol.Y, 'g', -1, 64))
+			return fmt.Sprintf("POINT(%s,%s)", strconv.FormatFloat(typedCol.X, 'g', -1, 64), strconv.FormatFloat(typedCol.Y, 'g', -1, 64))
 		case sql.Linestring:
 			var s = make([]string, len(typedCol.Points))
 			for i, p := range typedCol.Points {

From d5a0329f1335fc40e01d1dc41f55285bd678b9c5 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Fri, 7 Jan 2022 12:30:21 -0800
Subject: [PATCH 20/51] stored as ewkb, except for when just raw object; pin in
 it for now

---
 .../doltcore/schema/typeinfo/linestring.go    | 73 +++++++--------
 .../doltcore/schema/typeinfo/point.go         | 90 ++++++++++++-------
 .../doltcore/schema/typeinfo/polygon.go       | 88 +++++++++---------
 go/store/types/linestring.go                  | 10 ++-
 go/store/types/point.go                       | 10 ++-
 go/store/types/polygon.go                     | 10 ++-
 6 files changed, 162 insertions(+), 119 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
index f941fafd70..be8cc2cefb 100644
--- a/go/libraries/doltcore/schema/typeinfo/linestring.go
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -16,9 +16,8 @@ package typeinfo
 
 import (
 	"context"
+	"encoding/binary"
 	"fmt"
-	"strings"
-
 	"github.com/dolthub/go-mysql-server/sql"
 
 	"github.com/dolthub/dolt/go/store/types"
@@ -34,39 +33,32 @@ var _ TypeInfo = (*linestringType)(nil)
 
 var LinestringType = &linestringType{sql.LinestringType{}}
 
-func ConvertStringToSQLLinestring(s string) (interface{}, error) {
-	// Get everything between parentheses
-	s = s[len("LINESTRING(") : len(s)-1]
-	// Split into points
-	vals := strings.Split(s, ",POINT")
-	// Parse points
-	var points = make([]sql.Point, len(vals))
-	for i, s := range vals {
-		// Re-add delimiter
-		if i != 0 {
-			s = "POINT" + s
-		}
-		// Convert to Point type
-		point, err := ConvertStringToSQLPoint(s)
-		// TODO: This is never true
-		if err != nil {
-			return nil, err
-		}
-		// TODO: necessary? should throw error
-		if point == nil {
-			return nil, nil
-		}
-		points[i] = point.(sql.Point)
+// ConvertEWKBToLine converts the data portion of a WKB point to Point array
+// Very similar logic to the function in GMS
+func ConvertEWKBToLine(buf []byte, isBig bool, srid uint32) sql.Linestring {
+	// Read length of linestring
+	var numPoints uint32
+	if isBig {
+		numPoints = binary.BigEndian.Uint32(buf[:4])
+	} else {
+		numPoints = binary.LittleEndian.Uint32(buf[:4])
 	}
-	// Create sql.Linestring object
-	return sql.Linestring{Points: points}, nil
+
+	// Parse points
+	points := make([]sql.Point, numPoints)
+	for i := uint32(0); i < numPoints; i++ {
+		points[i] = ConvertEWKBToPoint(buf[4 + 16 * i : 4 + 16 * (i + 1)], isBig, srid)
+	}
+
+	return sql.Linestring{SRID: srid, Points: points}
 }
 
 // ConvertNomsValueToValue implements TypeInfo interface.
 func (ti *linestringType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
 	// Expect a types.Linestring, return a sql.Linestring
 	if val, ok := v.(types.Linestring); ok {
-		return ConvertStringToSQLLinestring(string(val))
+		srid, isBig, _ := ParseEWKBHeader(val)
+		return ConvertEWKBToLine(val[9:], isBig, srid), nil
 	}
 	// Check for null
 	if _, ok := v.(types.Null); ok || v == nil {
@@ -88,18 +80,14 @@ func (ti *linestringType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecR
 	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), k)
 }
 
-func ConvertSQLLinestringToString(l sql.Linestring) (types.Linestring, error) {
-	// Convert each sql.Point into types.Point
-	var pointStrs = make([]string, len(l.Points))
+// WriteEWKBLineData converts a Line into a byte array in EWKB format
+func WriteEWKBLineData(l sql.Linestring, buf[] byte) {
+	// Write length of linestring
+	binary.LittleEndian.PutUint32(buf[:4], uint32(len(l.Points)))
+	// Append each point
 	for i, p := range l.Points {
-		pointStr, err := ConvertSQLPointToString(p)
-		if err != nil {
-			return "", err
-		}
-		pointStrs[i] = string(pointStr)
+		WriteEWKBPointData(p, buf[4 + 16 * i : 4 + 16 * (i + 1)])
 	}
-	lineStr := fmt.Sprintf("LINESTRING(%s)", strings.Join(pointStrs, ","))
-	return types.Linestring(lineStr), nil
 }
 
 // ConvertValueToNomsValue implements TypeInfo interface.
@@ -115,7 +103,14 @@ func (ti *linestringType) ConvertValueToNomsValue(ctx context.Context, vrw types
 		return nil, err
 	}
 
-	return ConvertSQLLinestringToString(line.(sql.Linestring))
+	// Allocate buffer for line
+	buf := make([]byte, 9 + 4 + 16 * len(line.(sql.Linestring).Points))
+
+	// Write header and data to buffer
+	WriteEWKBHeader(line, buf)
+	WriteEWKBLineData(line.(sql.Linestring), buf[9:])
+
+	return types.Linestring(buf), nil
 }
 
 // Equals implements TypeInfo interface.
diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index 2d6cd1fafa..802b2d4948 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -16,13 +16,11 @@ package typeinfo
 
 import (
 	"context"
+	"encoding/binary"
 	"fmt"
-	"strconv"
-	"strings"
-
-	"github.com/dolthub/go-mysql-server/sql"
-
 	"github.com/dolthub/dolt/go/store/types"
+	"github.com/dolthub/go-mysql-server/sql"
+	"math"
 )
 
 // This is a dolt implementation of the MySQL type Point, thus most of the functionality
@@ -35,30 +33,35 @@ var _ TypeInfo = (*pointType)(nil)
 
 var PointType = &pointType{sql.PointType{}}
 
-func ConvertStringToSQLPoint(s string) (interface{}, error) {
-	// Get everything between parentheses
-	s = s[len("POINT(") : len(s)-1]
-	// Split into x and y strings; maybe should length check
-	vals := strings.Split(s, ",")
-	// Parse x as float64
-	x, err := strconv.ParseFloat(vals[0], 64)
-	if err != nil {
-		return nil, err
+func ParseEWKBHeader(buf []byte) (uint32, bool, uint32) {
+	srid := binary.LittleEndian.Uint32(buf[0:4]) // First 4 bytes is SRID always in little endian
+	isBig := buf[4] == 0 // Next byte is endianness
+	geomType := binary.LittleEndian.Uint32(buf[5:9]) // Next 4 bytes is type
+	return srid, isBig, geomType
+}
+
+// ConvertEWKBToPoint converts the data portion of a WKB point to sql.Point
+// Very similar logic to the function in GMS
+func ConvertEWKBToPoint(buf []byte, isBig bool, srid uint32) sql.Point {
+	// Read floats x and y
+	var x, y float64
+	if isBig {
+		x = math.Float64frombits(binary.BigEndian.Uint64(buf[:8]))
+		y = math.Float64frombits(binary.BigEndian.Uint64(buf[8:]))
+	} else {
+		x = math.Float64frombits(binary.LittleEndian.Uint64(buf[:8]))
+		y = math.Float64frombits(binary.LittleEndian.Uint64(buf[8:]))
 	}
-	// Parse y as float64
-	y, err := strconv.ParseFloat(vals[1], 64)
-	if err != nil {
-		return nil, err
-	}
-	// Create sql.Point object
-	return sql.Point{X: x, Y: y}, nil
+	return sql.Point{SRID: srid, X: x, Y: y}
 }
 
 // ConvertNomsValueToValue implements TypeInfo interface.
 func (ti *pointType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
 	// Expect a types.Point, return a sql.Point
 	if val, ok := v.(types.Point); ok {
-		return ConvertStringToSQLPoint(string(val))
+		// Assume buf is correct length (25)
+		srid, isBig, _ := ParseEWKBHeader(val) // TODO: geomType should be impossible to fail
+		return ConvertEWKBToPoint(val[9:], isBig, srid), nil
 	}
 	// Check for null
 	if _, ok := v.(types.Null); ok || v == nil {
@@ -80,14 +83,34 @@ func (ti *pointType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecReader
 	}
 }
 
-func ConvertSQLPointToString(p sql.Point) (types.Point, error) {
-	// Convert point to string / types.Point
-	x := strconv.FormatFloat(p.X, 'g', -1, 64)
-	y := strconv.FormatFloat(p.Y, 'g', -1, 64)
-	pointStr := fmt.Sprintf("POINT(%s,%s)", x, y)
+// TODO: define constants for WKB?
 
-	// Create types.Point
-	return types.Point(pointStr), nil
+// WriteEWKBHeader writes the SRID, endianness, and type to the byte buffer
+// This function assumes v is a valid spatial type
+func WriteEWKBHeader(v interface{}, buf []byte) {
+	// Write endianness byte (always little endian)
+	buf[4] = 1
+
+	// Parse data
+	switch v := v.(type) {
+	case sql.Point:
+		// Write SRID and type
+		binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
+		binary.LittleEndian.PutUint32(buf[5:9], 1)
+	case sql.Linestring:
+		binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
+		binary.LittleEndian.PutUint32(buf[5:9], 2)
+	case sql.Polygon:
+		binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
+		binary.LittleEndian.PutUint32(buf[5:9], 3)
+	}
+}
+
+// WriteEWKBPointData converts a Point into a byte array in EWKB format
+// Very similar to function in GMS
+func WriteEWKBPointData(p sql.Point, buf []byte) {
+	binary.LittleEndian.PutUint64(buf[0:8], math.Float64bits(p.X))
+	binary.LittleEndian.PutUint64(buf[8:16], math.Float64bits(p.Y))
 }
 
 // ConvertValueToNomsValue implements TypeInfo interface.
@@ -103,7 +126,14 @@ func (ti *pointType) ConvertValueToNomsValue(ctx context.Context, vrw types.Valu
 		return nil, err
 	}
 
-	return ConvertSQLPointToString(point.(sql.Point))
+	// Allocate buffer for point 4 + 1 + 4 + 16
+	buf := make([]byte, 25)
+
+	// Write header and data to buffer
+	WriteEWKBHeader(point, buf)
+	WriteEWKBPointData(point.(sql.Point), buf[9:])
+
+	return types.Point(buf), nil
 }
 
 // Equals implements TypeInfo interface.
diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
index d9f1410fa9..919abc93a8 100644
--- a/go/libraries/doltcore/schema/typeinfo/polygon.go
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -16,9 +16,8 @@ package typeinfo
 
 import (
 	"context"
+	"encoding/binary"
 	"fmt"
-	"strings"
-
 	"github.com/dolthub/go-mysql-server/sql"
 
 	"github.com/dolthub/dolt/go/store/types"
@@ -34,39 +33,35 @@ var _ TypeInfo = (*polygonType)(nil)
 
 var PolygonType = &polygonType{sql.PolygonType{}}
 
-func ConvertStringToSQLPolygon(s string) (interface{}, error) {
-	// Get everything between parentheses
-	s = s[len("POLYGON(") : len(s)-1]
-	// Split into lines
-	vals := strings.Split(s, ",LINESTRING")
-	// Parse points
-	var lines = make([]sql.Linestring, len(vals))
-	for i, s := range vals {
-		// Re-add delimiter
-		if i != 0 {
-			s = "LINESTRING" + s
-		}
-		// Convert to Linestring type
-		line, err := ConvertStringToSQLLinestring(s)
-		// TODO: This is never true
-		if err != nil {
-			return nil, err
-		}
-		// TODO: necessary? should throw error
-		if line == nil {
-			return nil, nil
-		}
-		lines[i] = line.(sql.Linestring)
+// ConvertEWKBToPoly converts the data portions of a WKB polygon to Point array
+// Very similar logic to the function in GMS
+func ConvertEWKBToPoly(buf []byte, isBig bool, srid uint32) sql.Polygon {
+	// Read length of Polygon
+	var numLines uint32
+	if isBig {
+		numLines = binary.BigEndian.Uint32(buf[:4])
+	} else {
+		numLines = binary.LittleEndian.Uint32(buf[:4])
 	}
-	// Create sql.Polygon object
-	return sql.Polygon{Lines: lines}, nil
+
+	// Parse lines
+	s := 4
+	lines := make([]sql.Linestring, numLines)
+	for i := uint32(0); i < numLines; i++ {
+		lines[i] = ConvertEWKBToLine(buf[s:], isBig, srid)
+		s += 4 * 16 * len(lines[i].Points)
+	}
+
+	return sql.Polygon{SRID: srid, Lines: lines}
 }
 
+
 // ConvertNomsValueToValue implements TypeInfo interface.
 func (ti *polygonType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
 	// Expect a types.Polygon, return a sql.Polygon
 	if val, ok := v.(types.Polygon); ok {
-		return ConvertStringToSQLPolygon(string(val))
+		srid, isBig, _ := ParseEWKBHeader(val)
+		return ConvertEWKBToPoly(val[9:], isBig, srid), nil
 	}
 	// Check for null
 	if _, ok := v.(types.Null); ok || v == nil {
@@ -88,18 +83,16 @@ func (ti *polygonType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecRead
 	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), k)
 }
 
-func ConvertSQLPolygonToString(p sql.Polygon) (types.Polygon, error) {
-	// Convert each sql.Point into types.Point
-	var lineStrs = make([]string, len(p.Lines))
-	for i, l := range p.Lines {
-		lineStr, err := ConvertSQLLinestringToString(l)
-		if err != nil {
-			return "", err
-		}
-		lineStrs[i] = string(lineStr)
+// WriteEWKBPolyData converts a Polygon into a byte array in EWKB format
+func WriteEWKBPolyData(p sql.Polygon, buf []byte) {
+	// Write length of polygon
+	binary.LittleEndian.PutUint32(buf[:4], uint32(len(p.Lines)))
+	// Write each line
+	start, stop := 0, 4
+	for _, l := range p.Lines {
+		start, stop = stop, stop + 4 + 16 * len(l.Points)
+		WriteEWKBLineData(l, buf[start:stop])
 	}
-	polygonStr := fmt.Sprintf("POLYGON(%s)", strings.Join(lineStrs, ","))
-	return types.Polygon(polygonStr), nil
 }
 
 // ConvertValueToNomsValue implements TypeInfo interface.
@@ -110,12 +103,25 @@ func (ti *polygonType) ConvertValueToNomsValue(ctx context.Context, vrw types.Va
 	}
 
 	// Convert to sql.PolygonType
-	polygon, err := ti.sqlPolygonType.Convert(v)
+	poly, err := ti.sqlPolygonType.Convert(v)
 	if err != nil {
 		return nil, err
 	}
 
-	return ConvertSQLPolygonToString(polygon.(sql.Polygon))
+	// Calculate space for polygon buffer
+	size := 0
+	for _, l := range poly.(sql.Polygon).Lines {
+		size += 4 + 16 * len(l.Points)
+	}
+
+	// Allocate buffer for poly
+	buf := make([]byte, 9 + 4 + size)
+
+	// Write header and data to buffer
+	WriteEWKBHeader(poly, buf)
+	WriteEWKBPolyData(poly.(sql.Polygon), buf[9:])
+
+	return types.Polygon(buf), nil
 }
 
 // Equals implements TypeInfo interface.
diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
index 12a9e5b0c4..ce65d3cd62 100644
--- a/go/store/types/linestring.go
+++ b/go/store/types/linestring.go
@@ -22,6 +22,7 @@
 package types
 
 import (
+	"bytes"
 	"context"
 	"strconv"
 
@@ -29,7 +30,7 @@ import (
 )
 
 // Linestring is a Noms Value wrapper around a string.
-type Linestring string
+type Linestring []byte
 
 // Value interface
 func (v Linestring) Value(ctx context.Context) (Value, error) {
@@ -37,12 +38,15 @@ func (v Linestring) Value(ctx context.Context) (Value, error) {
 }
 
 func (v Linestring) Equals(other Value) bool {
-	return v == other
+	if v2, ok := other.(Linestring); ok {
+		return bytes.Equal(v, v2)
+	}
+	return false
 }
 
 func (v Linestring) Less(nbf *NomsBinFormat, other LesserValuable) (bool, error) {
 	if v2, ok := other.(Linestring); ok {
-		return v < v2, nil
+		return bytes.Compare(v, v2) == -1, nil
 	}
 	return LinestringKind < other.Kind(), nil
 }
diff --git a/go/store/types/point.go b/go/store/types/point.go
index c2a90262a5..f4b12648aa 100644
--- a/go/store/types/point.go
+++ b/go/store/types/point.go
@@ -22,6 +22,7 @@
 package types
 
 import (
+	"bytes"
 	"context"
 	"strconv"
 
@@ -29,7 +30,7 @@ import (
 )
 
 // Point is a Noms Value wrapper around the primitive string type (for now).
-type Point string // TODO: 16 bytes to fit 2 float64
+type Point []byte // TODO: fixed size?
 
 // Value interface
 func (v Point) Value(ctx context.Context) (Value, error) {
@@ -37,12 +38,15 @@ func (v Point) Value(ctx context.Context) (Value, error) {
 }
 
 func (v Point) Equals(other Value) bool {
-	return v == other
+	if v2, ok := other.(Point); ok {
+		return bytes.Equal(v, v2)
+	}
+	return false
 }
 
 func (v Point) Less(nbf *NomsBinFormat, other LesserValuable) (bool, error) {
 	if v2, ok := other.(Point); ok {
-		return v < v2, nil
+		return bytes.Compare(v, v2)  == -1, nil
 	}
 	return PointKind < other.Kind(), nil
 }
diff --git a/go/store/types/polygon.go b/go/store/types/polygon.go
index d50e5ce72a..46ed46dd49 100644
--- a/go/store/types/polygon.go
+++ b/go/store/types/polygon.go
@@ -22,6 +22,7 @@
 package types
 
 import (
+	"bytes"
 	"context"
 	"strconv"
 
@@ -29,7 +30,7 @@ import (
 )
 
 // Polygon is a Noms Value wrapper around a string.
-type Polygon string
+type Polygon []byte
 
 // Value interface
 func (v Polygon) Value(ctx context.Context) (Value, error) {
@@ -37,12 +38,15 @@ func (v Polygon) Value(ctx context.Context) (Value, error) {
 }
 
 func (v Polygon) Equals(other Value) bool {
-	return v == other
+	if v2, ok := other.(Polygon); ok {
+		return bytes.Equal(v, v2)
+	}
+	return false
 }
 
 func (v Polygon) Less(nbf *NomsBinFormat, other LesserValuable) (bool, error) {
 	if v2, ok := other.(Polygon); ok {
-		return v < v2, nil
+		return bytes.Compare(v, v2) == -1, nil
 	}
 	return PolygonKind < other.Kind(), nil
 }

From 074a265c04e7c42d98dd3d6db3e46c7c5a4ec0ec Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Fri, 7 Jan 2022 12:52:14 -0800
Subject: [PATCH 21/51] sql_row changes are ok

---
 go/libraries/doltcore/sqle/sqlutil/sql_row.go | 80 ++++++++++++++++---
 1 file changed, 68 insertions(+), 12 deletions(-)

diff --git a/go/libraries/doltcore/sqle/sqlutil/sql_row.go b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
index 2bbe8d40c5..bc62b52049 100644
--- a/go/libraries/doltcore/sqle/sqlutil/sql_row.go
+++ b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
@@ -16,10 +16,11 @@ package sqlutil
 
 import (
 	"context"
+	"encoding/binary"
 	"errors"
 	"fmt"
+	"math"
 	"strconv"
-	"strings"
 	"time"
 
 	"github.com/dolthub/go-mysql-server/sql"
@@ -262,6 +263,57 @@ func keylessDoltRowFromSqlRow(ctx context.Context, vrw types.ValueReadWriter, sq
 	return row.KeylessRow(vrw.Format(), vals[:j]...)
 }
 
+
+// WriteEWKBHeader writes the SRID, endianness, and type to the byte buffer
+// This function assumes v is a valid spatial type
+func WriteEWKBHeader(v interface{}, buf []byte) {
+	// Write endianness byte (always little endian)
+	buf[4] = 1
+
+	// Parse data
+	switch v := v.(type) {
+	case sql.Point:
+		// Write SRID and type
+		binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
+		binary.LittleEndian.PutUint32(buf[5:9], 1)
+	case sql.Linestring:
+		binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
+		binary.LittleEndian.PutUint32(buf[5:9], 2)
+	case sql.Polygon:
+		binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
+		binary.LittleEndian.PutUint32(buf[5:9], 3)
+	}
+}
+
+// WriteEWKBPointData converts a Point into a byte array in EWKB format
+// Very similar to function in GMS
+func WriteEWKBPointData(p sql.Point, buf []byte) {
+	binary.LittleEndian.PutUint64(buf[0:8], math.Float64bits(p.X))
+	binary.LittleEndian.PutUint64(buf[8:16], math.Float64bits(p.Y))
+}
+
+// WriteEWKBLineData converts a Line into a byte array in EWKB format
+func WriteEWKBLineData(l sql.Linestring, buf[] byte) {
+	// Write length of linestring
+	binary.LittleEndian.PutUint32(buf[:4], uint32(len(l.Points)))
+	// Append each point
+	for i, p := range l.Points {
+		WriteEWKBPointData(p, buf[4 + 16 * i : 4 + 16 * (i + 1)])
+	}
+}
+
+// WriteEWKBPolyData converts a Polygon into a byte array in EWKB format
+func WriteEWKBPolyData(p sql.Polygon, buf []byte) {
+	// Write length of polygon
+	binary.LittleEndian.PutUint32(buf[:4], uint32(len(p.Lines)))
+	// Write each line
+	start, stop := 0, 4
+	for _, l := range p.Lines {
+		start, stop = stop, stop + 4 + 16 * len(l.Points)
+		WriteEWKBLineData(l, buf[start:stop])
+	}
+}
+
 // SqlColToStr is a utility function for converting a sql column of type interface{} to a string
 func SqlColToStr(ctx context.Context, col interface{}) string {
 	if col != nil {
@@ -303,20 +355,24 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 		case time.Time:
 			return typedCol.Format("2006-01-02 15:04:05.999999 -0700 MST")
 		case sql.Point:
-			// TODO: Convert to byte array to match MySQL; leave for readability
-			return fmt.Sprintf("POINT(%s,%s)", strconv.FormatFloat(typedCol.X, 'g', -1, 64), strconv.FormatFloat(typedCol.Y, 'g', -1, 64))
+			buf := make([]byte, 25)
+			WriteEWKBHeader(typedCol, buf)
+			WriteEWKBPointData(typedCol, buf[9:])
+			return SqlColToStr(ctx, buf)
 		case sql.Linestring:
-			var s = make([]string, len(typedCol.Points))
-			for i, p := range typedCol.Points {
-				s[i] = SqlColToStr(ctx, p)
-			}
-			return fmt.Sprintf("LINESTRING(%s)", strings.Join(s, ","))
+			buf := make([]byte, 9 + 4 + 16 * len(typedCol.Points))
+			WriteEWKBHeader(typedCol, buf)
+			WriteEWKBLineData(typedCol, buf[9:])
+			return SqlColToStr(ctx, buf)
 		case sql.Polygon:
-			var s = make([]string, len(typedCol.Lines))
-			for i, l := range typedCol.Lines {
-				s[i] = SqlColToStr(ctx, l)
+			size := 0
+			for _, l := range typedCol.Lines {
+				size += 4 + 16 * len(l.Points)
 			}
-			return fmt.Sprintf("POLYGON(%s)", strings.Join(s, ","))
+			buf := make([]byte, 9 + 4 + size)
+			WriteEWKBHeader(typedCol, buf)
+			WriteEWKBPolyData(typedCol, buf[9:])
+			return SqlColToStr(ctx, buf)
 		case sql.JSONValue:
 			s, err := typedCol.ToString(sql.NewContext(ctx))
 			if err != nil {

From d8632d92ef313f2b68bda46e8bad273e00f4e4f0 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Wed, 12 Jan 2022 14:30:33 -0800
Subject: [PATCH 22/51] working, but table still reads out spatial types are
 strings; might have to change somehting in value_decoder or codec

---
 .../doltcore/schema/typeinfo/linestring.go    |  48 ++------
 .../doltcore/schema/typeinfo/point.go         |  68 ++--------
 .../doltcore/schema/typeinfo/polygon.go       |  61 +++------
 go/libraries/doltcore/sqle/sqlutil/sql_row.go |   1 +
 go/store/types/linestring.go                  | 111 +++++++++++++++--
 go/store/types/noms_kind.go                   |   6 +-
 go/store/types/point.go                       |  80 ++++++++++--
 go/store/types/polygon.go                     | 116 ++++++++++++++++--
 go/store/types/value_decoder.go               |  10 +-
 9 files changed, 324 insertions(+), 177 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
index be8cc2cefb..81a6d653e7 100644
--- a/go/libraries/doltcore/schema/typeinfo/linestring.go
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -16,7 +16,6 @@ package typeinfo
 
 import (
 	"context"
-	"encoding/binary"
 	"fmt"
 	"github.com/dolthub/go-mysql-server/sql"
 
@@ -33,32 +32,20 @@ var _ TypeInfo = (*linestringType)(nil)
 
 var LinestringType = &linestringType{sql.LinestringType{}}
 
-// ConvertEWKBToLine converts the data portion of a WKB point to Point array
-// Very similar logic to the function in GMS
-func ConvertEWKBToLine(buf []byte, isBig bool, srid uint32) sql.Linestring {
-	// Read length of linestring
-	var numPoints uint32
-	if isBig {
-		numPoints = binary.BigEndian.Uint32(buf[:4])
-	} else {
-		numPoints = binary.LittleEndian.Uint32(buf[:4])
+// ConvertTypesLinestringToSQLLinestring basically makes a deep copy of sql.Linestring
+func ConvertTypesLinestringToSQLLinestring(l types.Linestring) sql.Linestring {
+	points := make([]sql.Point, len(l.Points))
+	for i, p := range l.Points {
+		points[i] = ConvertTypesPointToSQLPoint(p)
 	}
-
-	// Parse points
-	points := make([]sql.Point, numPoints)
-	for i := uint32(0); i < numPoints; i++ {
-		points[i] = ConvertEWKBToPoint(buf[4 + 16 * i : 4 + 16 * (i + 1)], isBig, srid)
-	}
-
-	return sql.Linestring{SRID: srid, Points: points}
+	return sql.Linestring{SRID: l.SRID, Points: points}
 }
 
 // ConvertNomsValueToValue implements TypeInfo interface.
 func (ti *linestringType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
 	// Expect a types.Linestring, return a sql.Linestring
 	if val, ok := v.(types.Linestring); ok {
-		srid, isBig, _ := ParseEWKBHeader(val)
-		return ConvertEWKBToLine(val[9:], isBig, srid), nil
+		return ConvertTypesLinestringToSQLLinestring(val), nil
 	}
 	// Check for null
 	if _, ok := v.(types.Null); ok || v == nil {
@@ -80,14 +67,12 @@ func (ti *linestringType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecR
 	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), k)
 }
 
-// WriteEWKBLineData converts a Line into a byte array in EWKB format
-func WriteEWKBLineData(l sql.Linestring, buf[] byte) {
-	// Write length of linestring
-	binary.LittleEndian.PutUint32(buf[:4], uint32(len(l.Points)))
-	// Append each point
+func ConvertSQLLinestringToTypesLinestring(l sql.Linestring) types.Linestring {
+	points := make([]types.Point, len(l.Points))
 	for i, p := range l.Points {
-		WriteEWKBPointData(p, buf[4 + 16 * i : 4 + 16 * (i + 1)])
+		points[i] = ConvertSQLPointToTypesPoint(p)
 	}
+	return types.Linestring{SRID: l.SRID, Points: points}
 }
 
 // ConvertValueToNomsValue implements TypeInfo interface.
@@ -103,14 +88,7 @@ func (ti *linestringType) ConvertValueToNomsValue(ctx context.Context, vrw types
 		return nil, err
 	}
 
-	// Allocate buffer for line
-	buf := make([]byte, 9 + 4 + 16 * len(line.(sql.Linestring).Points))
-
-	// Write header and data to buffer
-	WriteEWKBHeader(line, buf)
-	WriteEWKBLineData(line.(sql.Linestring), buf[9:])
-
-	return types.Linestring(buf), nil
+	return ConvertSQLLinestringToTypesLinestring(line.(sql.Linestring)), nil
 }
 
 // Equals implements TypeInfo interface.
@@ -156,7 +134,7 @@ func (ti *linestringType) GetTypeParams() map[string]string {
 // IsValid implements TypeInfo interface.
 func (ti *linestringType) IsValid(v types.Value) bool {
 	if val, ok := v.(types.Linestring); ok {
-		_, err := ti.sqlLinestringType.Convert(string(val))
+		_, err := ti.sqlLinestringType.Convert(val)
 		if err != nil {
 			return false
 		}
diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index 802b2d4948..69ff315a58 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -16,11 +16,9 @@ package typeinfo
 
 import (
 	"context"
-	"encoding/binary"
 	"fmt"
 	"github.com/dolthub/dolt/go/store/types"
 	"github.com/dolthub/go-mysql-server/sql"
-	"math"
 )
 
 // This is a dolt implementation of the MySQL type Point, thus most of the functionality
@@ -33,35 +31,16 @@ var _ TypeInfo = (*pointType)(nil)
 
 var PointType = &pointType{sql.PointType{}}
 
-func ParseEWKBHeader(buf []byte) (uint32, bool, uint32) {
-	srid := binary.LittleEndian.Uint32(buf[0:4]) // First 4 bytes is SRID always in little endian
-	isBig := buf[4] == 0 // Next byte is endianness
-	geomType := binary.LittleEndian.Uint32(buf[5:9]) // Next 4 bytes is type
-	return srid, isBig, geomType
-}
-
-// ConvertEWKBToPoint converts the data portion of a WKB point to sql.Point
-// Very similar logic to the function in GMS
-func ConvertEWKBToPoint(buf []byte, isBig bool, srid uint32) sql.Point {
-	// Read floats x and y
-	var x, y float64
-	if isBig {
-		x = math.Float64frombits(binary.BigEndian.Uint64(buf[:8]))
-		y = math.Float64frombits(binary.BigEndian.Uint64(buf[8:]))
-	} else {
-		x = math.Float64frombits(binary.LittleEndian.Uint64(buf[:8]))
-		y = math.Float64frombits(binary.LittleEndian.Uint64(buf[8:]))
-	}
-	return sql.Point{SRID: srid, X: x, Y: y}
+// ConvertTypesPointToSQLPoint basically makes a deep copy of sql.Point
+func ConvertTypesPointToSQLPoint(p types.Point) sql.Point {
+	return sql.Point{SRID: p.SRID, X: p.X, Y: p.Y}
 }
 
 // ConvertNomsValueToValue implements TypeInfo interface.
 func (ti *pointType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
 	// Expect a types.Point, return a sql.Point
 	if val, ok := v.(types.Point); ok {
-		// Assume buf is correct length (25)
-		srid, isBig, _ := ParseEWKBHeader(val) // TODO: geomType should be impossible to fail
-		return ConvertEWKBToPoint(val[9:], isBig, srid), nil
+		return ConvertTypesPointToSQLPoint(val), nil
 	}
 	// Check for null
 	if _, ok := v.(types.Null); ok || v == nil {
@@ -85,32 +64,8 @@ func (ti *pointType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecReader
 
 // TODO: define constants for WKB?
 
-// WriteEWKBHeader writes the SRID, endianness, and type to the byte buffer
-// This function assumes v is a valid spatial type
-func WriteEWKBHeader(v interface{}, buf []byte) {
-	// Write endianness byte (always little endian)
-	buf[4] = 1
-
-	// Parse data
-	switch v := v.(type) {
-	case sql.Point:
-		// Write SRID and type
-		binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
-		binary.LittleEndian.PutUint32(buf[5:9], 1)
-	case sql.Linestring:
-		binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
-		binary.LittleEndian.PutUint32(buf[5:9], 2)
-	case sql.Polygon:
-		binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
-		binary.LittleEndian.PutUint32(buf[5:9], 3)
-	}
-}
-
-// WriteEWKBPointData converts a Point into a byte array in EWKB format
-// Very similar to function in GMS
-func WriteEWKBPointData(p sql.Point, buf []byte) {
-	binary.LittleEndian.PutUint64(buf[0:8], math.Float64bits(p.X))
-	binary.LittleEndian.PutUint64(buf[8:16], math.Float64bits(p.Y))
+func ConvertSQLPointToTypesPoint(p sql.Point) types.Point {
+	return types.Point{SRID: p.SRID, X: p.X, Y: p.Y}
 }
 
 // ConvertValueToNomsValue implements TypeInfo interface.
@@ -126,14 +81,7 @@ func (ti *pointType) ConvertValueToNomsValue(ctx context.Context, vrw types.Valu
 		return nil, err
 	}
 
-	// Allocate buffer for point 4 + 1 + 4 + 16
-	buf := make([]byte, 25)
-
-	// Write header and data to buffer
-	WriteEWKBHeader(point, buf)
-	WriteEWKBPointData(point.(sql.Point), buf[9:])
-
-	return types.Point(buf), nil
+	return ConvertSQLPointToTypesPoint(point.(sql.Point)), nil
 }
 
 // Equals implements TypeInfo interface.
@@ -179,7 +127,7 @@ func (ti *pointType) GetTypeParams() map[string]string {
 // IsValid implements TypeInfo interface.
 func (ti *pointType) IsValid(v types.Value) bool {
 	if val, ok := v.(types.Point); ok {
-		_, err := ti.sqlPointType.Convert(string(val))
+		_, err := ti.sqlPointType.Convert(val)
 		if err != nil {
 			return false
 		}
diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
index 919abc93a8..467a1fe0fa 100644
--- a/go/libraries/doltcore/schema/typeinfo/polygon.go
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -16,7 +16,6 @@ package typeinfo
 
 import (
 	"context"
-	"encoding/binary"
 	"fmt"
 	"github.com/dolthub/go-mysql-server/sql"
 
@@ -33,35 +32,20 @@ var _ TypeInfo = (*polygonType)(nil)
 
 var PolygonType = &polygonType{sql.PolygonType{}}
 
-// ConvertEWKBToPoly converts the data portions of a WKB polygon to Point array
-// Very similar logic to the function in GMS
-func ConvertEWKBToPoly(buf []byte, isBig bool, srid uint32) sql.Polygon {
-	// Read length of Polygon
-	var numLines uint32
-	if isBig {
-		numLines = binary.BigEndian.Uint32(buf[:4])
-	} else {
-		numLines = binary.LittleEndian.Uint32(buf[:4])
+// ConvertTypesPolygonToSQLPolygon basically makes a deep copy of sql.Linestring
+func ConvertTypesPolygonToSQLPolygon(p types.Polygon) sql.Polygon {
+	lines := make([]sql.Linestring, len(p.Lines))
+	for i, l := range p.Lines {
+		lines[i] = ConvertTypesLinestringToSQLLinestring(l)
 	}
-
-	// Parse lines
-	s := 4
-	lines := make([]sql.Linestring, numLines)
-	for i := uint32(0); i < numLines; i++ {
-		lines[i] = ConvertEWKBToLine(buf[s:], isBig, srid)
-		s += 4 * 16 * len(lines[i].Points)
-	}
-
-	return sql.Polygon{SRID: srid, Lines: lines}
+	return sql.Polygon{SRID: p.SRID, Lines: lines}
 }
 
-
 // ConvertNomsValueToValue implements TypeInfo interface.
 func (ti *polygonType) ConvertNomsValueToValue(v types.Value) (interface{}, error) {
 	// Expect a types.Polygon, return a sql.Polygon
 	if val, ok := v.(types.Polygon); ok {
-		srid, isBig, _ := ParseEWKBHeader(val)
-		return ConvertEWKBToPoly(val[9:], isBig, srid), nil
+		return ConvertTypesPolygonToSQLPolygon(val), nil
 	}
 	// Check for null
 	if _, ok := v.(types.Null); ok || v == nil {
@@ -83,16 +67,12 @@ func (ti *polygonType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecRead
 	return nil, fmt.Errorf(`"%v" cannot convert NomsKind "%v" to a value`, ti.String(), k)
 }
 
-// WriteEWKBPolyData converts a Polygon into a byte array in EWKB format
-func WriteEWKBPolyData(p sql.Polygon, buf []byte) {
-	// Write length of polygon
-	binary.LittleEndian.PutUint32(buf[:4], uint32(len(p.Lines)))
-	// Write each line
-	start, stop := 0, 4
-	for _, l := range p.Lines {
-		start, stop = stop, stop + 4 + 16 * len(l.Points)
-		WriteEWKBLineData(l, buf[start:stop])
+func ConvertSQLPolygonToTypesPolygon(p sql.Polygon) types.Polygon {
+	lines := make([]types.Linestring, len(p.Lines))
+	for i, l := range p.Lines {
+		lines[i] = ConvertSQLLinestringToTypesLinestring(l)
 	}
+	return types.Polygon{SRID: p.SRID, Lines: lines}
 }
 
 // ConvertValueToNomsValue implements TypeInfo interface.
@@ -108,20 +88,7 @@ func (ti *polygonType) ConvertValueToNomsValue(ctx context.Context, vrw types.Va
 		return nil, err
 	}
 
-	// Calculate space for polygon buffer
-	size := 0
-	for _, l := range poly.(sql.Polygon).Lines {
-		size += 4 + 16 * len(l.Points)
-	}
-
-	// Allocate buffer for poly
-	buf := make([]byte, 9 + 4 + size)
-
-	// Write header and data to buffer
-	WriteEWKBHeader(poly, buf)
-	WriteEWKBPolyData(poly.(sql.Polygon), buf[9:])
-
-	return types.Polygon(buf), nil
+	return ConvertSQLPolygonToTypesPolygon(poly.(sql.Polygon)), nil
 }
 
 // Equals implements TypeInfo interface.
@@ -167,7 +134,7 @@ func (ti *polygonType) GetTypeParams() map[string]string {
 // IsValid implements TypeInfo interface.
 func (ti *polygonType) IsValid(v types.Value) bool {
 	if val, ok := v.(types.Linestring); ok {
-		_, err := ti.sqlPolygonType.Convert(string(val))
+		_, err := ti.sqlPolygonType.Convert(val)
 		if err != nil {
 			return false
 		}
diff --git a/go/libraries/doltcore/sqle/sqlutil/sql_row.go b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
index bc62b52049..a969b8b2c8 100644
--- a/go/libraries/doltcore/sqle/sqlutil/sql_row.go
+++ b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
@@ -358,6 +358,7 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 			buf := make([]byte, 25)
 			WriteEWKBHeader(typedCol, buf)
 			WriteEWKBPointData(typedCol, buf[9:])
+			return "asdfasdf"
 			return SqlColToStr(ctx, buf)
 		case sql.Linestring:
 			buf := make([]byte, 9 + 4 + 16 * len(typedCol.Points))
diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
index ce65d3cd62..f6a785cc24 100644
--- a/go/store/types/linestring.go
+++ b/go/store/types/linestring.go
@@ -22,15 +22,21 @@
 package types
 
 import (
-	"bytes"
 	"context"
+	"encoding/binary"
+	"errors"
+	"fmt"
 	"strconv"
+	"strings"
 
 	"github.com/dolthub/dolt/go/store/hash"
 )
 
 // Linestring is a Noms Value wrapper around a string.
-type Linestring []byte
+type Linestring struct {
+	SRID uint32
+	Points []Point
+}
 
 // Value interface
 func (v Linestring) Value(ctx context.Context) (Value, error) {
@@ -38,17 +44,58 @@ func (v Linestring) Value(ctx context.Context) (Value, error) {
 }
 
 func (v Linestring) Equals(other Value) bool {
-	if v2, ok := other.(Linestring); ok {
-		return bytes.Equal(v, v2)
+	// Compare types
+	v2, ok := other.(Linestring)
+	if !ok {
+		return false
 	}
-	return false
+	// Compare SRID
+	if v.SRID != v2.SRID {
+		return false
+	}
+	// Compare lengths of points
+	if len(v.Points) != len(v2.Points) {
+		return false
+	}
+	// Compare each point
+	for i := 0; i < len(v.Points); i++ {
+		if !v.Points[i].Equals(v2.Points[i]) {
+			return false
+		}
+	}
+	return true
 }
 
 func (v Linestring) Less(nbf *NomsBinFormat, other LesserValuable) (bool, error) {
-	if v2, ok := other.(Linestring); ok {
-		return bytes.Compare(v, v2) == -1, nil
+	// Compare types
+	v2, ok := other.(Linestring)
+	if !ok {
+		return LinestringKind < other.Kind(), nil
 	}
-	return LinestringKind < other.Kind(), nil
+	// TODO: should I even take this into account?
+	// Compare SRID
+	if v.SRID != v2.SRID {
+		return v.SRID < v2.SRID, nil
+	}
+	// Get shorter length
+	var n int
+	len1 := len(v.Points)
+	len2 := len(v2.Points)
+	if len1 < len2 {
+		n = len1
+	} else {
+		n = len2
+	}
+
+	// Compare each point until there's one that is less than
+	for i := 0; i < n; i++ {
+		if !v.Points[i].Equals(v2.Points[i]) {
+			return v.Points[i].Less(nbf, v2.Points[i])
+		}
+	}
+
+	// Determine based off length
+	return len1 < len2, nil
 }
 
 func (v Linestring) Hash(nbf *NomsBinFormat) (hash.Hash, error) {
@@ -79,18 +126,55 @@ func (v Linestring) valueReadWriter() ValueReadWriter {
 	return nil
 }
 
+// WriteEWKBLineData converts a Line into a byte array in EWKB format
+func WriteEWKBLineData(l Linestring, buf[] byte) {
+	// Write length of linestring
+	binary.LittleEndian.PutUint32(buf[:4], uint32(len(l.Points)))
+	// Append each point
+	for i, p := range l.Points {
+		WriteEWKBPointData(p, buf[4 + 16 * i : 4 + 16 * (i + 1)])
+	}
+}
+
 func (v Linestring) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	err := LinestringKind.writeTo(w, nbf)
 	if err != nil {
 		return err
 	}
 
-	w.writeString(string(v))
+	// Allocate buffer for linestring
+	buf := make([]byte, 9 + 4 + 16 * len(v.Points))
+
+	// Write header and data to buffer
+	WriteEWKBHeader(v, buf)
+	WriteEWKBLineData(v, buf[9:])
+
+	w.writeString(string(buf))
 	return nil
 }
 
+// ParseEWKBLine converts the data portion of a WKB point to Linestring
+// Very similar logic to the function in GMS
+func ParseEWKBLine(buf []byte, srid uint32) Linestring {
+	// Read length of linestring
+	numPoints := binary.LittleEndian.Uint32(buf[:4])
+
+	// Parse points
+	points := make([]Point, numPoints)
+	for i := uint32(0); i < numPoints; i++ {
+		points[i] = ParseEWKBPoint(buf[4 + 16 * i : 4 + 16 * (i + 1)], srid)
+	}
+
+	return Linestring{SRID: srid, Points: points}
+}
+
 func (v Linestring) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
-	return Linestring(b.ReadString()), nil
+	buf := []byte(b.ReadString())
+	srid, _, geomType := ParseEWKBHeader(buf)
+	if geomType != 2 {
+		return nil, errors.New("not a linestring")
+	}
+	return ParseEWKBLine(buf[9:], srid), nil
 
 }
 
@@ -99,5 +183,10 @@ func (v Linestring) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
 }
 
 func (v Linestring) HumanReadableString() string {
-	return strconv.Quote(string(v))
+	points := make([]string, len(v.Points))
+	for i, p := range v.Points {
+		points[i] = p.HumanReadableString()
+	}
+	s := fmt.Sprintf("SRID: %d LINESTRING(%s)", strings.Join(points, ","))
+	return strconv.Quote(s)
 }
diff --git a/go/store/types/noms_kind.go b/go/store/types/noms_kind.go
index d8a18ea118..ad573fd37c 100644
--- a/go/store/types/noms_kind.go
+++ b/go/store/types/noms_kind.go
@@ -86,9 +86,9 @@ func init() {
 	KindToType[TimestampKind] = Timestamp{}
 	KindToType[DecimalKind] = Decimal{}
 	KindToType[JSONKind] = JSON{}
-	KindToType[PointKind] = Point("")
-	KindToType[LinestringKind] = Linestring("")
-	KindToType[PolygonKind] = Polygon("")
+	KindToType[PointKind] = Point{}
+	KindToType[LinestringKind] = Linestring{}
+	KindToType[PolygonKind] = Polygon{}
 
 	SupportedKinds[BlobKind] = true
 	SupportedKinds[BoolKind] = true
diff --git a/go/store/types/point.go b/go/store/types/point.go
index f4b12648aa..10849d9056 100644
--- a/go/store/types/point.go
+++ b/go/store/types/point.go
@@ -22,15 +22,22 @@
 package types
 
 import (
-	"bytes"
 	"context"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"math"
 	"strconv"
 
 	"github.com/dolthub/dolt/go/store/hash"
 )
 
 // Point is a Noms Value wrapper around the primitive string type (for now).
-type Point []byte // TODO: fixed size?
+type Point struct {
+	SRID uint32
+	X float64
+	Y float64
+}
 
 // Value interface
 func (v Point) Value(ctx context.Context) (Value, error) {
@@ -39,14 +46,14 @@ func (v Point) Value(ctx context.Context) (Value, error) {
 
 func (v Point) Equals(other Value) bool {
 	if v2, ok := other.(Point); ok {
-		return bytes.Equal(v, v2)
+		return v.SRID == v2.SRID && v.X == v2.X && v.Y == v2.Y
 	}
 	return false
 }
 
 func (v Point) Less(nbf *NomsBinFormat, other LesserValuable) (bool, error) {
 	if v2, ok := other.(Point); ok {
-		return bytes.Compare(v, v2)  == -1, nil
+		return v.SRID < v2.SRID || v.X < v2.X || v.Y < v2.Y, nil
 	}
 	return PointKind < other.Kind(), nil
 }
@@ -79,19 +86,75 @@ func (v Point) valueReadWriter() ValueReadWriter {
 	return nil
 }
 
+// WriteEWKBHeader writes the SRID, endianness, and type to the byte buffer
+// This function assumes v is a valid spatial type
+func WriteEWKBHeader(v interface{}, buf []byte) {
+	// Write endianness byte (always little endian)
+	buf[4] = 1
+
+	// Parse data
+	switch v := v.(type) {
+	case Point:
+		// Write SRID and type
+		binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
+		binary.LittleEndian.PutUint32(buf[5:9], 1)
+		//case Linestring:
+		//	binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
+		//	binary.LittleEndian.PutUint32(buf[5:9], 2)
+		//case Polygon:
+		//	binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
+		//	binary.LittleEndian.PutUint32(buf[5:9], 3)
+	}
+}
+
+// WriteEWKBPointData converts a Point into a byte array in EWKB format
+// Very similar to function in GMS
+func WriteEWKBPointData(p Point, buf []byte) {
+	binary.LittleEndian.PutUint64(buf[0:8], math.Float64bits(p.X))
+	binary.LittleEndian.PutUint64(buf[8:16], math.Float64bits(p.Y))
+}
+
 func (v Point) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	err := PointKind.writeTo(w, nbf)
-
 	if err != nil {
 		return err
 	}
 
-	w.writeString(string(v))
+	// TODO: Write constants for all this
+	// Allocate buffer for point 4 + 1 + 4 + 16
+	buf := make([]byte, 25)
+
+	// Write header and data to buffer
+	WriteEWKBHeader(v, buf)
+	WriteEWKBPointData(v, buf[9:])
+
+	w.writeString(string(buf))
 	return nil
 }
+// ParseEWKBHeader converts the header potion of a EWKB byte array to srid, endianness, and geometry type
+func ParseEWKBHeader(buf []byte) (uint32, bool, uint32) {
+	srid := binary.LittleEndian.Uint32(buf[0:4]) // First 4 bytes is SRID always in little endian
+	isBig := buf[4] == 0 // Next byte is endianness
+	geomType := binary.LittleEndian.Uint32(buf[5:9]) // Next 4 bytes is type
+	return srid, isBig, geomType
+}
+
+// ParseEWKBPoint converts the data portion of a WKB point to sql.Point
+// Very similar logic to the function in GMS
+func ParseEWKBPoint(buf []byte, srid uint32) Point {
+	// Read floats x and y
+	x := math.Float64frombits(binary.LittleEndian.Uint64(buf[:8]))
+	y := math.Float64frombits(binary.LittleEndian.Uint64(buf[8:]))
+	return Point{SRID: srid, X: x, Y: y}
+}
 
 func (v Point) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
-	return Point(b.ReadString()), nil
+	buf := []byte(b.ReadString())
+	srid, _, geomType := ParseEWKBHeader(buf) // Assume it's always little endian
+	if geomType != 1 {
+		return nil, errors.New("not a point")
+	}
+	return ParseEWKBPoint(buf[9:], srid), nil
 }
 
 func (v Point) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
@@ -99,5 +162,6 @@ func (v Point) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
 }
 
 func (v Point) HumanReadableString() string {
-	return strconv.Quote(string(v))
+	s := fmt.Sprintf("SRID: %d POINT(%s %s)", v.SRID, strconv.FormatFloat(v.X, 'g', -1, 64), strconv.FormatFloat(v.Y, 'g', -1, 64))
+	return strconv.Quote(s)
 }
diff --git a/go/store/types/polygon.go b/go/store/types/polygon.go
index 46ed46dd49..e6f7931841 100644
--- a/go/store/types/polygon.go
+++ b/go/store/types/polygon.go
@@ -22,15 +22,21 @@
 package types
 
 import (
-	"bytes"
 	"context"
+	"encoding/binary"
+	"errors"
+	"fmt"
 	"strconv"
+	"strings"
 
 	"github.com/dolthub/dolt/go/store/hash"
 )
 
 // Polygon is a Noms Value wrapper around a string.
-type Polygon []byte
+type Polygon struct {
+	SRID uint32
+	Lines []Linestring
+}
 
 // Value interface
 func (v Polygon) Value(ctx context.Context) (Value, error) {
@@ -38,17 +44,55 @@ func (v Polygon) Value(ctx context.Context) (Value, error) {
 }
 
 func (v Polygon) Equals(other Value) bool {
-	if v2, ok := other.(Polygon); ok {
-		return bytes.Equal(v, v2)
+	// Compare types
+	v2, ok := other.(Polygon)
+	if !ok {
+		return false
+	}
+	// Compare SRID
+	if v.SRID != v2.SRID {
+		return false
+	}
+	// Compare lengths of lines
+	if len(v.Lines) != len(v2.Lines) {
+		return false
+	}
+	// Compare each line
+	for i := 0; i < len(v.Lines); i++ {
+		if !v.Lines[i].Equals(v2.Lines[i]) {
+			return false
+		}
 	}
 	return false
 }
 
 func (v Polygon) Less(nbf *NomsBinFormat, other LesserValuable) (bool, error) {
-	if v2, ok := other.(Polygon); ok {
-		return bytes.Compare(v, v2) == -1, nil
+	// Compare types
+	v2, ok := other.(Polygon)
+	if !ok {
+		return PolygonKind < other.Kind(), nil
 	}
-	return PolygonKind < other.Kind(), nil
+	// Compare SRID
+	if v.SRID != v2.SRID {
+		return v.SRID < v2.SRID, nil
+	}
+	// Get shorter length
+	var n int
+	len1 := len(v.Lines)
+	len2 := len(v2.Lines)
+	if len1 < len2 {
+		n = len1
+	} else {
+		n = len2
+	}
+	// Compare each point until there is one that is less
+	for i := 0; i < n; i++ {
+		if !v.Lines[i].Equals(v2.Lines[i]) {
+			return v.Lines[i].Less(nbf, v2.Lines[i])
+		}
+	}
+	// Determine based off length
+	return len1 < len2, nil
 }
 
 func (v Polygon) Hash(nbf *NomsBinFormat) (hash.Hash, error) {
@@ -79,18 +123,65 @@ func (v Polygon) valueReadWriter() ValueReadWriter {
 	return nil
 }
 
+// WriteEWKBPolyData converts a Polygon into a byte array in EWKB format
+func WriteEWKBPolyData(p Polygon, buf []byte) {
+	// Write length of polygon
+	binary.LittleEndian.PutUint32(buf[:4], uint32(len(p.Lines)))
+	// Write each line
+	start, stop := 0, 4
+	for _, l := range p.Lines {
+		start, stop = stop, stop + 4 + 16 * len(l.Points)
+		WriteEWKBLineData(l, buf[start:stop])
+	}
+}
+
 func (v Polygon) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	err := PolygonKind.writeTo(w, nbf)
 	if err != nil {
 		return err
 	}
 
-	w.writeString(string(v))
+	// Calculate space for polygon buffer
+	size := 0
+	for _, l := range v.Lines {
+		size += 4 + 16 * len(l.Points)
+	}
+
+	// Allocate buffer for poly
+	buf := make([]byte, 9 + 4 + size)
+
+	// Write header and data to buffer
+	WriteEWKBHeader(v, buf)
+	WriteEWKBPolyData(v, buf[9:])
+
+	w.writeString(string(buf))
 	return nil
 }
 
+// ParseEWKBToPoly converts the data portions of a WKB polygon to Point array
+// Very similar logic to the function in GMS
+func ParseEWKBToPoly(buf []byte, srid uint32) Polygon {
+	// Read length of Polygon
+	numLines := binary.LittleEndian.Uint32(buf[:4])
+
+	// Parse lines
+	s := 4
+	lines := make([]Linestring, numLines)
+	for i := uint32(0); i < numLines; i++ {
+		lines[i] = ParseEWKBLine(buf[s:], srid)
+		s += 4 * 16 * len(lines[i].Points)
+	}
+
+	return Polygon{SRID: srid, Lines: lines}
+}
+
 func (v Polygon) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
-	return Polygon(b.ReadString()), nil
+	buf := []byte(b.ReadString())
+	srid, _, geomType := ParseEWKBHeader(buf)
+	if geomType != 3 {
+		return nil, errors.New("not a polygon")
+	}
+	return ParseEWKBToPoly(buf[9:], srid), nil
 }
 
 func (v Polygon) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
@@ -98,5 +189,10 @@ func (v Polygon) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
 }
 
 func (v Polygon) HumanReadableString() string {
-	return strconv.Quote(string(v))
+	lines := make([]string, len(v.Lines))
+	for i, l := range v.Lines {
+		lines[i] = l.HumanReadableString()
+	}
+	s := fmt.Sprintf("SRID: %d POLYGON(%s)", strings.Join(lines, ","))
+	return strconv.Quote(s)
 }
diff --git a/go/store/types/value_decoder.go b/go/store/types/value_decoder.go
index 17da985e93..aaf2656ca4 100644
--- a/go/store/types/value_decoder.go
+++ b/go/store/types/value_decoder.go
@@ -358,13 +358,17 @@ func (r *valueDecoder) readValue(nbf *NomsBinFormat) (Value, error) {
 		return r.ReadJSON()
 	case PointKind:
 		r.skipKind()
-		return Point(r.ReadString()), nil
+		r.ReadString()
+		// TODO: parse ewkb to point?
+		return Point{}, nil
 	case LinestringKind:
 		r.skipKind()
-		return Linestring(r.ReadString()), nil
+		r.ReadString()
+		return Linestring{}, nil
 	case PolygonKind:
 		r.skipKind()
-		return Polygon(r.ReadString()), nil
+		r.ReadString()
+		return Polygon{}, nil
 	case TypeKind:
 		r.skipKind()
 		return r.readType()

From ef2d5eaa776b9133e48b59f6982b88105696b5db Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Thu, 13 Jan 2022 14:14:10 -0800
Subject: [PATCH 23/51] now handles both sql and types geometries; duplicate
 code fix later

---
 go/libraries/doltcore/sqle/sqlutil/sql_row.go | 82 +++++++++++++++----
 1 file changed, 64 insertions(+), 18 deletions(-)

diff --git a/go/libraries/doltcore/sqle/sqlutil/sql_row.go b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
index a969b8b2c8..7dc914f71f 100644
--- a/go/libraries/doltcore/sqle/sqlutil/sql_row.go
+++ b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
@@ -287,30 +287,58 @@ func WriteEWKBHeader(v interface{}, buf []byte) {
 
 // WriteEWKBPointData converts a Point into a byte array in EWKB format
 // Very similar to function in GMS
-func WriteEWKBPointData(p sql.Point, buf []byte) {
-	binary.LittleEndian.PutUint64(buf[0:8], math.Float64bits(p.X))
-	binary.LittleEndian.PutUint64(buf[8:16], math.Float64bits(p.Y))
+func WriteEWKBPointData(p interface{}, buf []byte) {
+	switch p := p.(type) {
+	case sql.Point:
+		binary.LittleEndian.PutUint64(buf[0:8], math.Float64bits(p.X))
+		binary.LittleEndian.PutUint64(buf[8:16], math.Float64bits(p.Y))
+	case types.Point:
+		binary.LittleEndian.PutUint64(buf[0:8], math.Float64bits(p.X))
+		binary.LittleEndian.PutUint64(buf[8:16], math.Float64bits(p.Y))
+	}
 }
 
 // WriteEWKBLineData converts a Line into a byte array in EWKB format
-func WriteEWKBLineData(l sql.Linestring, buf[] byte) {
-	// Write length of linestring
-	binary.LittleEndian.PutUint32(buf[:4], uint32(len(l.Points)))
-	// Append each point
-	for i, p := range l.Points {
-		WriteEWKBPointData(p, buf[4 + 16 * i : 4 + 16 * (i + 1)])
+func WriteEWKBLineData(l interface{}, buf[] byte) {
+	switch l := l.(type) {
+	case sql.Linestring:
+		// Write length of linestring
+		binary.LittleEndian.PutUint32(buf[:4], uint32(len(l.Points)))
+		// Append each point
+		for i, p := range l.Points {
+			WriteEWKBPointData(p, buf[4 + 16 * i : 4 + 16 * (i + 1)])
+		}
+	case types.Linestring:
+		// Write length of linestring
+		binary.LittleEndian.PutUint32(buf[:4], uint32(len(l.Points)))
+		// Append each point
+		for i, p := range l.Points {
+			WriteEWKBPointData(p, buf[4 + 16 * i : 4 + 16 * (i + 1)])
+		}
 	}
 }
 
 // WriteEWKBPolyData converts a Polygon into a byte array in EWKB format
-func WriteEWKBPolyData(p sql.Polygon, buf []byte) {
-	// Write length of polygon
-	binary.LittleEndian.PutUint32(buf[:4], uint32(len(p.Lines)))
-	// Write each line
-	start, stop := 0, 4
-	for _, l := range p.Lines {
-		start, stop = stop, stop + 4 + 16 * len(l.Points)
-		WriteEWKBLineData(l, buf[start:stop])
+func WriteEWKBPolyData(p interface{}, buf []byte) {
+	switch p := p.(type) {
+	case sql.Polygon:
+		// Write length of polygon
+		binary.LittleEndian.PutUint32(buf[:4], uint32(len(p.Lines)))
+		// Write each line
+		start, stop := 0, 4
+		for _, l := range p.Lines {
+			start, stop = stop, stop + 4 + 16 * len(l.Points)
+			WriteEWKBLineData(l, buf[start:stop])
+		}
+	case types.Polygon:
+		// Write length of polygon
+		binary.LittleEndian.PutUint32(buf[:4], uint32(len(p.Lines)))
+		// Write each line
+		start, stop := 0, 4
+		for _, l := range p.Lines {
+			start, stop = stop, stop + 4 + 16 * len(l.Points)
+			WriteEWKBLineData(l, buf[start:stop])
+		}
 	}
 }
 
@@ -358,7 +386,6 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 			buf := make([]byte, 25)
 			WriteEWKBHeader(typedCol, buf)
 			WriteEWKBPointData(typedCol, buf[9:])
-			return "asdfasdf"
 			return SqlColToStr(ctx, buf)
 		case sql.Linestring:
 			buf := make([]byte, 9 + 4 + 16 * len(typedCol.Points))
@@ -374,6 +401,25 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 			WriteEWKBHeader(typedCol, buf)
 			WriteEWKBPolyData(typedCol, buf[9:])
 			return SqlColToStr(ctx, buf)
+		case types.Point:
+			buf := make([]byte, 25)
+			WriteEWKBHeader(typedCol, buf)
+			WriteEWKBPointData(typedCol, buf[9:])
+			return SqlColToStr(ctx, buf)
+		case types.Linestring:
+			buf := make([]byte, 9 + 4 + 16 * len(typedCol.Points))
+			WriteEWKBHeader(typedCol, buf)
+			WriteEWKBLineData(typedCol, buf[9:])
+			return SqlColToStr(ctx, buf)
+		case types.Polygon:
+			size := 0
+			for _, l := range typedCol.Lines {
+				size += 4 + 16 * len(l.Points)
+			}
+			buf := make([]byte, 9 + 4 + size)
+			WriteEWKBHeader(typedCol, buf)
+			WriteEWKBPolyData(typedCol, buf[9:])
+			return SqlColToStr(ctx, buf)
 		case sql.JSONValue:
 			s, err := typedCol.ToString(sql.NewContext(ctx))
 			if err != nil {

From b6a522cef754a3c3f94f729cfa9ea1f11f24df5f Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Thu, 13 Jan 2022 15:10:22 -0800
Subject: [PATCH 24/51] semi janky storage

---
 .../doltcore/schema/typeinfo/linestring.go    |  2 +-
 .../doltcore/schema/typeinfo/point.go         |  2 +-
 .../doltcore/schema/typeinfo/polygon.go       |  2 +-
 go/store/types/linestring.go                  | 10 +++++++-
 go/store/types/point.go                       | 24 +++++++++++++------
 go/store/types/polygon.go                     |  9 +++++++
 go/store/types/value_decoder.go               | 15 ++++++++++++
 7 files changed, 53 insertions(+), 11 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
index 81a6d653e7..ba0875501e 100644
--- a/go/libraries/doltcore/schema/typeinfo/linestring.go
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -59,7 +59,7 @@ func (ti *linestringType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecR
 	k := reader.ReadKind()
 	switch k {
 	case types.LinestringKind:
-		return reader.ReadString(), nil
+		return reader.ReadLinestring()
 	case types.NullKind:
 		return nil, nil
 	}
diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index 69ff315a58..ff12a66af0 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -54,7 +54,7 @@ func (ti *pointType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecReader
 	k := reader.ReadKind()
 	switch k {
 	case types.PointKind:
-		return reader.ReadString(), nil
+		return reader.ReadPoint()
 	case types.NullKind:
 		return nil, nil
 	default:
diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
index 467a1fe0fa..36d6610c28 100644
--- a/go/libraries/doltcore/schema/typeinfo/polygon.go
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -59,7 +59,7 @@ func (ti *polygonType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecRead
 	k := reader.ReadKind()
 	switch k {
 	case types.PolygonKind:
-		return reader.ReadString(), nil
+		return reader.ReadPolygon()
 	case types.NullKind:
 		return nil, nil
 	}
diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
index f6a785cc24..972e905c43 100644
--- a/go/store/types/linestring.go
+++ b/go/store/types/linestring.go
@@ -168,6 +168,15 @@ func ParseEWKBLine(buf []byte, srid uint32) Linestring {
 	return Linestring{SRID: srid, Points: points}
 }
 
+func readLinestring(nbf *NomsBinFormat, b *valueDecoder) (Linestring, error) {
+	buf := []byte(b.ReadString())
+	srid, _, geomType := ParseEWKBHeader(buf)
+	if geomType != 2 {
+		return Linestring{}, errors.New("not a linestring")
+	}
+	return ParseEWKBLine(buf[9:], srid), nil
+}
+
 func (v Linestring) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
 	buf := []byte(b.ReadString())
 	srid, _, geomType := ParseEWKBHeader(buf)
@@ -175,7 +184,6 @@ func (v Linestring) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, er
 		return nil, errors.New("not a linestring")
 	}
 	return ParseEWKBLine(buf[9:], srid), nil
-
 }
 
 func (v Linestring) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
diff --git a/go/store/types/point.go b/go/store/types/point.go
index 10849d9056..572ffc39ed 100644
--- a/go/store/types/point.go
+++ b/go/store/types/point.go
@@ -98,12 +98,12 @@ func WriteEWKBHeader(v interface{}, buf []byte) {
 		// Write SRID and type
 		binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
 		binary.LittleEndian.PutUint32(buf[5:9], 1)
-		//case Linestring:
-		//	binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
-		//	binary.LittleEndian.PutUint32(buf[5:9], 2)
-		//case Polygon:
-		//	binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
-		//	binary.LittleEndian.PutUint32(buf[5:9], 3)
+	case Linestring:
+		binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
+		binary.LittleEndian.PutUint32(buf[5:9], 2)
+	case Polygon:
+		binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
+		binary.LittleEndian.PutUint32(buf[5:9], 3)
 	}
 }
 
@@ -115,6 +115,7 @@ func WriteEWKBPointData(p Point, buf []byte) {
 }
 
 func (v Point) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
+	// Mark as PointKind
 	err := PointKind.writeTo(w, nbf)
 	if err != nil {
 		return err
@@ -148,11 +149,20 @@ func ParseEWKBPoint(buf []byte, srid uint32) Point {
 	return Point{SRID: srid, X: x, Y: y}
 }
 
+func readPoint(nbf *NomsBinFormat, b *valueDecoder) (Point, error) {
+	buf := []byte(b.ReadString())
+	srid, _, geomType := ParseEWKBHeader(buf) // Assume it's always little endian
+	if geomType != 1 {
+		return Point{}, errors.New("not a point")
+	}
+	return ParseEWKBPoint(buf[9:], srid), nil
+}
+
 func (v Point) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
 	buf := []byte(b.ReadString())
 	srid, _, geomType := ParseEWKBHeader(buf) // Assume it's always little endian
 	if geomType != 1 {
-		return nil, errors.New("not a point")
+		return Point{}, errors.New("not a point")
 	}
 	return ParseEWKBPoint(buf[9:], srid), nil
 }
diff --git a/go/store/types/polygon.go b/go/store/types/polygon.go
index e6f7931841..da04647dfc 100644
--- a/go/store/types/polygon.go
+++ b/go/store/types/polygon.go
@@ -175,6 +175,15 @@ func ParseEWKBToPoly(buf []byte, srid uint32) Polygon {
 	return Polygon{SRID: srid, Lines: lines}
 }
 
+func readPolygon(nbf *NomsBinFormat, b *valueDecoder) (Polygon, error) {
+	buf := []byte(b.ReadString())
+	srid, _, geomType := ParseEWKBHeader(buf)
+	if geomType != 3 {
+		return Polygon{}, errors.New("not a polygon")
+	}
+	return ParseEWKBToPoly(buf[9:], srid), nil
+}
+
 func (v Polygon) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
 	buf := []byte(b.ReadString())
 	srid, _, geomType := ParseEWKBHeader(buf)
diff --git a/go/store/types/value_decoder.go b/go/store/types/value_decoder.go
index aaf2656ca4..54df1651f6 100644
--- a/go/store/types/value_decoder.go
+++ b/go/store/types/value_decoder.go
@@ -46,6 +46,9 @@ type CodecReader interface {
 	ReadInlineBlob() []byte
 	ReadTimestamp() (time.Time, error)
 	ReadDecimal() (decimal.Decimal, error)
+	ReadPoint() (Point, error)
+	ReadLinestring() (Linestring, error)
+	ReadPolygon() (Polygon, error)
 	ReadBlob() (Blob, error)
 	ReadJSON() (JSON, error)
 }
@@ -80,6 +83,18 @@ func (r *valueDecoder) ReadBlob() (Blob, error) {
 	return newBlob(seq), nil
 }
 
+func (r *valueDecoder) ReadPoint() (Point, error) {
+	return readPoint(r.vrw.Format(), r)
+}
+
+func (r *valueDecoder) ReadLinestring() (Linestring, error) {
+	return readLinestring(r.vrw.Format(), r)
+}
+
+func (r *valueDecoder) ReadPolygon() (Polygon, error) {
+	return readPolygon(r.vrw.Format(), r)
+}
+
 func (r *valueDecoder) ReadJSON() (JSON, error) {
 	return readJSON(r.vrw.Format(), r)
 }

From 7d20b2492810f93beb8150b605990c9aa9de9348 Mon Sep 17 00:00:00 2001
From: JCOR11599 <JCOR11599@users.noreply.github.com>
Date: Thu, 13 Jan 2022 23:14:32 +0000
Subject: [PATCH 25/51] [ga-format-pr] Run go/utils/repofmt/format_repo.sh and
 go/Godeps/update.sh

---
 .../doltcore/schema/typeinfo/linestring.go    |  1 +
 .../doltcore/schema/typeinfo/point.go         |  4 +++-
 .../doltcore/schema/typeinfo/polygon.go       |  1 +
 go/libraries/doltcore/sqle/sqlutil/sql_row.go | 23 +++++++++----------
 go/store/types/linestring.go                  | 10 ++++----
 go/store/types/point.go                       |  9 ++++----
 go/store/types/polygon.go                     |  8 +++----
 7 files changed, 30 insertions(+), 26 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
index ba0875501e..a6121a20be 100644
--- a/go/libraries/doltcore/schema/typeinfo/linestring.go
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -17,6 +17,7 @@ package typeinfo
 import (
 	"context"
 	"fmt"
+
 	"github.com/dolthub/go-mysql-server/sql"
 
 	"github.com/dolthub/dolt/go/store/types"
diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index ff12a66af0..43f041e8b0 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -17,8 +17,10 @@ package typeinfo
 import (
 	"context"
 	"fmt"
-	"github.com/dolthub/dolt/go/store/types"
+
 	"github.com/dolthub/go-mysql-server/sql"
+
+	"github.com/dolthub/dolt/go/store/types"
 )
 
 // This is a dolt implementation of the MySQL type Point, thus most of the functionality
diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
index 36d6610c28..40d5cc5aee 100644
--- a/go/libraries/doltcore/schema/typeinfo/polygon.go
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -17,6 +17,7 @@ package typeinfo
 import (
 	"context"
 	"fmt"
+
 	"github.com/dolthub/go-mysql-server/sql"
 
 	"github.com/dolthub/dolt/go/store/types"
diff --git a/go/libraries/doltcore/sqle/sqlutil/sql_row.go b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
index 7dc914f71f..78d83c3eda 100644
--- a/go/libraries/doltcore/sqle/sqlutil/sql_row.go
+++ b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
@@ -263,7 +263,6 @@ func keylessDoltRowFromSqlRow(ctx context.Context, vrw types.ValueReadWriter, sq
 	return row.KeylessRow(vrw.Format(), vals[:j]...)
 }
 
-
 // WriteEWKBHeader writes the SRID, endianness, and type to the byte buffer
 // This function assumes v is a valid spatial type
 func WriteEWKBHeader(v interface{}, buf []byte) {
@@ -299,21 +298,21 @@ func WriteEWKBPointData(p interface{}, buf []byte) {
 }
 
 // WriteEWKBLineData converts a Line into a byte array in EWKB format
-func WriteEWKBLineData(l interface{}, buf[] byte) {
+func WriteEWKBLineData(l interface{}, buf []byte) {
 	switch l := l.(type) {
 	case sql.Linestring:
 		// Write length of linestring
 		binary.LittleEndian.PutUint32(buf[:4], uint32(len(l.Points)))
 		// Append each point
 		for i, p := range l.Points {
-			WriteEWKBPointData(p, buf[4 + 16 * i : 4 + 16 * (i + 1)])
+			WriteEWKBPointData(p, buf[4+16*i:4+16*(i+1)])
 		}
 	case types.Linestring:
 		// Write length of linestring
 		binary.LittleEndian.PutUint32(buf[:4], uint32(len(l.Points)))
 		// Append each point
 		for i, p := range l.Points {
-			WriteEWKBPointData(p, buf[4 + 16 * i : 4 + 16 * (i + 1)])
+			WriteEWKBPointData(p, buf[4+16*i:4+16*(i+1)])
 		}
 	}
 }
@@ -327,7 +326,7 @@ func WriteEWKBPolyData(p interface{}, buf []byte) {
 		// Write each line
 		start, stop := 0, 4
 		for _, l := range p.Lines {
-			start, stop = stop, stop + 4 + 16 * len(l.Points)
+			start, stop = stop, stop+4+16*len(l.Points)
 			WriteEWKBLineData(l, buf[start:stop])
 		}
 	case types.Polygon:
@@ -336,7 +335,7 @@ func WriteEWKBPolyData(p interface{}, buf []byte) {
 		// Write each line
 		start, stop := 0, 4
 		for _, l := range p.Lines {
-			start, stop = stop, stop + 4 + 16 * len(l.Points)
+			start, stop = stop, stop+4+16*len(l.Points)
 			WriteEWKBLineData(l, buf[start:stop])
 		}
 	}
@@ -388,16 +387,16 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 			WriteEWKBPointData(typedCol, buf[9:])
 			return SqlColToStr(ctx, buf)
 		case sql.Linestring:
-			buf := make([]byte, 9 + 4 + 16 * len(typedCol.Points))
+			buf := make([]byte, 9+4+16*len(typedCol.Points))
 			WriteEWKBHeader(typedCol, buf)
 			WriteEWKBLineData(typedCol, buf[9:])
 			return SqlColToStr(ctx, buf)
 		case sql.Polygon:
 			size := 0
 			for _, l := range typedCol.Lines {
-				size += 4 + 16 * len(l.Points)
+				size += 4 + 16*len(l.Points)
 			}
-			buf := make([]byte, 9 + 4 + size)
+			buf := make([]byte, 9+4+size)
 			WriteEWKBHeader(typedCol, buf)
 			WriteEWKBPolyData(typedCol, buf[9:])
 			return SqlColToStr(ctx, buf)
@@ -407,16 +406,16 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 			WriteEWKBPointData(typedCol, buf[9:])
 			return SqlColToStr(ctx, buf)
 		case types.Linestring:
-			buf := make([]byte, 9 + 4 + 16 * len(typedCol.Points))
+			buf := make([]byte, 9+4+16*len(typedCol.Points))
 			WriteEWKBHeader(typedCol, buf)
 			WriteEWKBLineData(typedCol, buf[9:])
 			return SqlColToStr(ctx, buf)
 		case types.Polygon:
 			size := 0
 			for _, l := range typedCol.Lines {
-				size += 4 + 16 * len(l.Points)
+				size += 4 + 16*len(l.Points)
 			}
-			buf := make([]byte, 9 + 4 + size)
+			buf := make([]byte, 9+4+size)
 			WriteEWKBHeader(typedCol, buf)
 			WriteEWKBPolyData(typedCol, buf[9:])
 			return SqlColToStr(ctx, buf)
diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
index 972e905c43..e9b74f0675 100644
--- a/go/store/types/linestring.go
+++ b/go/store/types/linestring.go
@@ -34,7 +34,7 @@ import (
 
 // Linestring is a Noms Value wrapper around a string.
 type Linestring struct {
-	SRID uint32
+	SRID   uint32
 	Points []Point
 }
 
@@ -127,12 +127,12 @@ func (v Linestring) valueReadWriter() ValueReadWriter {
 }
 
 // WriteEWKBLineData converts a Line into a byte array in EWKB format
-func WriteEWKBLineData(l Linestring, buf[] byte) {
+func WriteEWKBLineData(l Linestring, buf []byte) {
 	// Write length of linestring
 	binary.LittleEndian.PutUint32(buf[:4], uint32(len(l.Points)))
 	// Append each point
 	for i, p := range l.Points {
-		WriteEWKBPointData(p, buf[4 + 16 * i : 4 + 16 * (i + 1)])
+		WriteEWKBPointData(p, buf[4+16*i:4+16*(i+1)])
 	}
 }
 
@@ -143,7 +143,7 @@ func (v Linestring) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	}
 
 	// Allocate buffer for linestring
-	buf := make([]byte, 9 + 4 + 16 * len(v.Points))
+	buf := make([]byte, 9+4+16*len(v.Points))
 
 	// Write header and data to buffer
 	WriteEWKBHeader(v, buf)
@@ -162,7 +162,7 @@ func ParseEWKBLine(buf []byte, srid uint32) Linestring {
 	// Parse points
 	points := make([]Point, numPoints)
 	for i := uint32(0); i < numPoints; i++ {
-		points[i] = ParseEWKBPoint(buf[4 + 16 * i : 4 + 16 * (i + 1)], srid)
+		points[i] = ParseEWKBPoint(buf[4+16*i:4+16*(i+1)], srid)
 	}
 
 	return Linestring{SRID: srid, Points: points}
diff --git a/go/store/types/point.go b/go/store/types/point.go
index 572ffc39ed..765ac52ff3 100644
--- a/go/store/types/point.go
+++ b/go/store/types/point.go
@@ -35,8 +35,8 @@ import (
 // Point is a Noms Value wrapper around the primitive string type (for now).
 type Point struct {
 	SRID uint32
-	X float64
-	Y float64
+	X    float64
+	Y    float64
 }
 
 // Value interface
@@ -132,10 +132,11 @@ func (v Point) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	w.writeString(string(buf))
 	return nil
 }
+
 // ParseEWKBHeader converts the header potion of a EWKB byte array to srid, endianness, and geometry type
 func ParseEWKBHeader(buf []byte) (uint32, bool, uint32) {
-	srid := binary.LittleEndian.Uint32(buf[0:4]) // First 4 bytes is SRID always in little endian
-	isBig := buf[4] == 0 // Next byte is endianness
+	srid := binary.LittleEndian.Uint32(buf[0:4])     // First 4 bytes is SRID always in little endian
+	isBig := buf[4] == 0                             // Next byte is endianness
 	geomType := binary.LittleEndian.Uint32(buf[5:9]) // Next 4 bytes is type
 	return srid, isBig, geomType
 }
diff --git a/go/store/types/polygon.go b/go/store/types/polygon.go
index da04647dfc..9434a5cc5d 100644
--- a/go/store/types/polygon.go
+++ b/go/store/types/polygon.go
@@ -34,7 +34,7 @@ import (
 
 // Polygon is a Noms Value wrapper around a string.
 type Polygon struct {
-	SRID uint32
+	SRID  uint32
 	Lines []Linestring
 }
 
@@ -130,7 +130,7 @@ func WriteEWKBPolyData(p Polygon, buf []byte) {
 	// Write each line
 	start, stop := 0, 4
 	for _, l := range p.Lines {
-		start, stop = stop, stop + 4 + 16 * len(l.Points)
+		start, stop = stop, stop+4+16*len(l.Points)
 		WriteEWKBLineData(l, buf[start:stop])
 	}
 }
@@ -144,11 +144,11 @@ func (v Polygon) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	// Calculate space for polygon buffer
 	size := 0
 	for _, l := range v.Lines {
-		size += 4 + 16 * len(l.Points)
+		size += 4 + 16*len(l.Points)
 	}
 
 	// Allocate buffer for poly
-	buf := make([]byte, 9 + 4 + size)
+	buf := make([]byte, 9+4+size)
 
 	// Write header and data to buffer
 	WriteEWKBHeader(v, buf)

From e0bb6bbb58382229c74078f090fb58021bad5a77 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Thu, 13 Jan 2022 16:06:40 -0800
Subject: [PATCH 26/51] reverting printing for types.point, types.linestring,
 and types.polygon

---
 go/libraries/doltcore/sqle/sqlutil/sql_row.go | 81 ++++---------------
 1 file changed, 17 insertions(+), 64 deletions(-)

diff --git a/go/libraries/doltcore/sqle/sqlutil/sql_row.go b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
index 7dc914f71f..bc62b52049 100644
--- a/go/libraries/doltcore/sqle/sqlutil/sql_row.go
+++ b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
@@ -287,58 +287,30 @@ func WriteEWKBHeader(v interface{}, buf []byte) {
 
 // WriteEWKBPointData converts a Point into a byte array in EWKB format
 // Very similar to function in GMS
-func WriteEWKBPointData(p interface{}, buf []byte) {
-	switch p := p.(type) {
-	case sql.Point:
-		binary.LittleEndian.PutUint64(buf[0:8], math.Float64bits(p.X))
-		binary.LittleEndian.PutUint64(buf[8:16], math.Float64bits(p.Y))
-	case types.Point:
-		binary.LittleEndian.PutUint64(buf[0:8], math.Float64bits(p.X))
-		binary.LittleEndian.PutUint64(buf[8:16], math.Float64bits(p.Y))
-	}
+func WriteEWKBPointData(p sql.Point, buf []byte) {
+	binary.LittleEndian.PutUint64(buf[0:8], math.Float64bits(p.X))
+	binary.LittleEndian.PutUint64(buf[8:16], math.Float64bits(p.Y))
 }
 
 // WriteEWKBLineData converts a Line into a byte array in EWKB format
-func WriteEWKBLineData(l interface{}, buf[] byte) {
-	switch l := l.(type) {
-	case sql.Linestring:
-		// Write length of linestring
-		binary.LittleEndian.PutUint32(buf[:4], uint32(len(l.Points)))
-		// Append each point
-		for i, p := range l.Points {
-			WriteEWKBPointData(p, buf[4 + 16 * i : 4 + 16 * (i + 1)])
-		}
-	case types.Linestring:
-		// Write length of linestring
-		binary.LittleEndian.PutUint32(buf[:4], uint32(len(l.Points)))
-		// Append each point
-		for i, p := range l.Points {
-			WriteEWKBPointData(p, buf[4 + 16 * i : 4 + 16 * (i + 1)])
-		}
+func WriteEWKBLineData(l sql.Linestring, buf[] byte) {
+	// Write length of linestring
+	binary.LittleEndian.PutUint32(buf[:4], uint32(len(l.Points)))
+	// Append each point
+	for i, p := range l.Points {
+		WriteEWKBPointData(p, buf[4 + 16 * i : 4 + 16 * (i + 1)])
 	}
 }
 
 // WriteEWKBPolyData converts a Polygon into a byte array in EWKB format
-func WriteEWKBPolyData(p interface{}, buf []byte) {
-	switch p := p.(type) {
-	case sql.Polygon:
-		// Write length of polygon
-		binary.LittleEndian.PutUint32(buf[:4], uint32(len(p.Lines)))
-		// Write each line
-		start, stop := 0, 4
-		for _, l := range p.Lines {
-			start, stop = stop, stop + 4 + 16 * len(l.Points)
-			WriteEWKBLineData(l, buf[start:stop])
-		}
-	case types.Polygon:
-		// Write length of polygon
-		binary.LittleEndian.PutUint32(buf[:4], uint32(len(p.Lines)))
-		// Write each line
-		start, stop := 0, 4
-		for _, l := range p.Lines {
-			start, stop = stop, stop + 4 + 16 * len(l.Points)
-			WriteEWKBLineData(l, buf[start:stop])
-		}
+func WriteEWKBPolyData(p sql.Polygon, buf []byte) {
+	// Write length of polygon
+	binary.LittleEndian.PutUint32(buf[:4], uint32(len(p.Lines)))
+	// Write each line
+	start, stop := 0, 4
+	for _, l := range p.Lines {
+		start, stop = stop, stop + 4 + 16 * len(l.Points)
+		WriteEWKBLineData(l, buf[start:stop])
 	}
 }
 
@@ -401,25 +373,6 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 			WriteEWKBHeader(typedCol, buf)
 			WriteEWKBPolyData(typedCol, buf[9:])
 			return SqlColToStr(ctx, buf)
-		case types.Point:
-			buf := make([]byte, 25)
-			WriteEWKBHeader(typedCol, buf)
-			WriteEWKBPointData(typedCol, buf[9:])
-			return SqlColToStr(ctx, buf)
-		case types.Linestring:
-			buf := make([]byte, 9 + 4 + 16 * len(typedCol.Points))
-			WriteEWKBHeader(typedCol, buf)
-			WriteEWKBLineData(typedCol, buf[9:])
-			return SqlColToStr(ctx, buf)
-		case types.Polygon:
-			size := 0
-			for _, l := range typedCol.Lines {
-				size += 4 + 16 * len(l.Points)
-			}
-			buf := make([]byte, 9 + 4 + size)
-			WriteEWKBHeader(typedCol, buf)
-			WriteEWKBPolyData(typedCol, buf[9:])
-			return SqlColToStr(ctx, buf)
 		case sql.JSONValue:
 			s, err := typedCol.ToString(sql.NewContext(ctx))
 			if err != nil {

From 1e8d3fcad33479b7b988208568fb35e9d22a7055 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Thu, 13 Jan 2022 16:17:14 -0800
Subject: [PATCH 27/51] readfrom methods return correct type

---
 go/libraries/doltcore/schema/typeinfo/linestring.go | 6 +++++-
 go/libraries/doltcore/schema/typeinfo/point.go      | 6 +++++-
 go/libraries/doltcore/schema/typeinfo/polygon.go    | 6 +++++-
 go/store/types/point.go                             | 2 +-
 go/store/types/polygon.go                           | 2 +-
 5 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
index ba0875501e..6c5b8e2f49 100644
--- a/go/libraries/doltcore/schema/typeinfo/linestring.go
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -59,7 +59,11 @@ func (ti *linestringType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecR
 	k := reader.ReadKind()
 	switch k {
 	case types.LinestringKind:
-		return reader.ReadLinestring()
+		l, err := reader.ReadLinestring()
+		if err != nil {
+			return nil, err
+		}
+		return ti.ConvertNomsValueToValue(l)
 	case types.NullKind:
 		return nil, nil
 	}
diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index ff12a66af0..38f881930d 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -54,7 +54,11 @@ func (ti *pointType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecReader
 	k := reader.ReadKind()
 	switch k {
 	case types.PointKind:
-		return reader.ReadPoint()
+		p, err := reader.ReadPoint()
+		if err != nil {
+			return nil, err
+		}
+		return ti.ConvertNomsValueToValue(p)
 	case types.NullKind:
 		return nil, nil
 	default:
diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
index 36d6610c28..14f5696b34 100644
--- a/go/libraries/doltcore/schema/typeinfo/polygon.go
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -59,7 +59,11 @@ func (ti *polygonType) ReadFrom(nbf *types.NomsBinFormat, reader types.CodecRead
 	k := reader.ReadKind()
 	switch k {
 	case types.PolygonKind:
-		return reader.ReadPolygon()
+		p, err := reader.ReadPolygon()
+		if err != nil {
+			return nil, err
+		}
+		return ti.ConvertNomsValueToValue(p)
 	case types.NullKind:
 		return nil, nil
 	}
diff --git a/go/store/types/point.go b/go/store/types/point.go
index 572ffc39ed..b0cad005f7 100644
--- a/go/store/types/point.go
+++ b/go/store/types/point.go
@@ -140,7 +140,7 @@ func ParseEWKBHeader(buf []byte) (uint32, bool, uint32) {
 	return srid, isBig, geomType
 }
 
-// ParseEWKBPoint converts the data portion of a WKB point to sql.Point
+// ParseEWKBPoint converts the data portion of a WKB point to Point
 // Very similar logic to the function in GMS
 func ParseEWKBPoint(buf []byte, srid uint32) Point {
 	// Read floats x and y
diff --git a/go/store/types/polygon.go b/go/store/types/polygon.go
index da04647dfc..d248c2b361 100644
--- a/go/store/types/polygon.go
+++ b/go/store/types/polygon.go
@@ -158,7 +158,7 @@ func (v Polygon) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	return nil
 }
 
-// ParseEWKBToPoly converts the data portions of a WKB polygon to Point array
+// ParseEWKBToPoly converts the data portions of a WKB polygon to Polygon
 // Very similar logic to the function in GMS
 func ParseEWKBToPoly(buf []byte, srid uint32) Polygon {
 	// Read length of Polygon

From 03a9adb32c27d9b27aebfe75d9d544f044d8e2d8 Mon Sep 17 00:00:00 2001
From: JCOR11599 <JCOR11599@users.noreply.github.com>
Date: Fri, 14 Jan 2022 00:35:53 +0000
Subject: [PATCH 28/51] [ga-format-pr] Run go/utils/repofmt/format_repo.sh and
 go/Godeps/update.sh

---
 go/libraries/doltcore/sqle/sqlutil/sql_row.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/go/libraries/doltcore/sqle/sqlutil/sql_row.go b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
index 1807fce80e..7d40f64a41 100644
--- a/go/libraries/doltcore/sqle/sqlutil/sql_row.go
+++ b/go/libraries/doltcore/sqle/sqlutil/sql_row.go
@@ -292,12 +292,12 @@ func WriteEWKBPointData(p sql.Point, buf []byte) {
 }
 
 // WriteEWKBLineData converts a Line into a byte array in EWKB format
-func WriteEWKBLineData(l sql.Linestring, buf[] byte) {
+func WriteEWKBLineData(l sql.Linestring, buf []byte) {
 	// Write length of linestring
 	binary.LittleEndian.PutUint32(buf[:4], uint32(len(l.Points)))
 	// Append each point
 	for i, p := range l.Points {
-		WriteEWKBPointData(p, buf[4 + 16 * i : 4 + 16 * (i + 1)])
+		WriteEWKBPointData(p, buf[4+16*i:4+16*(i+1)])
 	}
 }
 
@@ -308,7 +308,7 @@ func WriteEWKBPolyData(p sql.Polygon, buf []byte) {
 	// Write each line
 	start, stop := 0, 4
 	for _, l := range p.Lines {
-		start, stop = stop, stop + 4 + 16 * len(l.Points)
+		start, stop = stop, stop+4+16*len(l.Points)
 		WriteEWKBLineData(l, buf[start:stop])
 	}
 }
@@ -366,7 +366,7 @@ func SqlColToStr(ctx context.Context, col interface{}) string {
 		case sql.Polygon:
 			size := 0
 			for _, l := range typedCol.Lines {
-				size += 4 + 16 * len(l.Points)
+				size += 4 + 16*len(l.Points)
 			}
 			buf := make([]byte, 9+4+size)
 			WriteEWKBHeader(typedCol, buf)

From f70f51fcbe292b560ae8463fce763806e9192add Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Wed, 19 Jan 2022 13:14:20 -0800
Subject: [PATCH 29/51] using constants

---
 go/store/types/linestring.go | 18 ++++++++------
 go/store/types/point.go      | 46 ++++++++++++++++++++++--------------
 go/store/types/polygon.go    | 20 ++++++++--------
 3 files changed, 49 insertions(+), 35 deletions(-)

diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
index e9b74f0675..05f2a153f8 100644
--- a/go/store/types/linestring.go
+++ b/go/store/types/linestring.go
@@ -32,6 +32,10 @@ import (
 	"github.com/dolthub/dolt/go/store/hash"
 )
 
+const (
+	LengthSize = 4
+)
+
 // Linestring is a Noms Value wrapper around a string.
 type Linestring struct {
 	SRID   uint32
@@ -129,10 +133,10 @@ func (v Linestring) valueReadWriter() ValueReadWriter {
 // WriteEWKBLineData converts a Line into a byte array in EWKB format
 func WriteEWKBLineData(l Linestring, buf []byte) {
 	// Write length of linestring
-	binary.LittleEndian.PutUint32(buf[:4], uint32(len(l.Points)))
+	binary.LittleEndian.PutUint32(buf[:LengthSize], uint32(len(l.Points)))
 	// Append each point
 	for i, p := range l.Points {
-		WriteEWKBPointData(p, buf[4+16*i:4+16*(i+1)])
+		WriteEWKBPointData(p, buf[LengthSize+PointDataSize*i:LengthSize+PointDataSize*(i+1)])
 	}
 }
 
@@ -143,11 +147,11 @@ func (v Linestring) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	}
 
 	// Allocate buffer for linestring
-	buf := make([]byte, 9+4+16*len(v.Points))
+	buf := make([]byte, EWKBHeaderSize+LengthSize+PointDataSize*len(v.Points))
 
 	// Write header and data to buffer
 	WriteEWKBHeader(v, buf)
-	WriteEWKBLineData(v, buf[9:])
+	WriteEWKBLineData(v, buf[EWKBHeaderSize:])
 
 	w.writeString(string(buf))
 	return nil
@@ -162,7 +166,7 @@ func ParseEWKBLine(buf []byte, srid uint32) Linestring {
 	// Parse points
 	points := make([]Point, numPoints)
 	for i := uint32(0); i < numPoints; i++ {
-		points[i] = ParseEWKBPoint(buf[4+16*i:4+16*(i+1)], srid)
+		points[i] = ParseEWKBPoint(buf[LengthSize+PointDataSize*i:LengthSize+PointDataSize*(i+1)], srid)
 	}
 
 	return Linestring{SRID: srid, Points: points}
@@ -174,7 +178,7 @@ func readLinestring(nbf *NomsBinFormat, b *valueDecoder) (Linestring, error) {
 	if geomType != 2 {
 		return Linestring{}, errors.New("not a linestring")
 	}
-	return ParseEWKBLine(buf[9:], srid), nil
+	return ParseEWKBLine(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Linestring) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
@@ -183,7 +187,7 @@ func (v Linestring) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, er
 	if geomType != 2 {
 		return nil, errors.New("not a linestring")
 	}
-	return ParseEWKBLine(buf[9:], srid), nil
+	return ParseEWKBLine(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Linestring) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
diff --git a/go/store/types/point.go b/go/store/types/point.go
index 47eb102c72..15b820db28 100644
--- a/go/store/types/point.go
+++ b/go/store/types/point.go
@@ -32,6 +32,17 @@ import (
 	"github.com/dolthub/dolt/go/store/hash"
 )
 
+const (
+	SRIDSize = 4
+	EndianSize = 1
+	TypeSize = 4
+	EWKBHeaderSize = SRIDSize + EndianSize + TypeSize
+	PointDataSize = 16
+	PointID = 1
+	LinestringID = 2
+	PolygonID = 3
+)
+
 // Point is a Noms Value wrapper around the primitive string type (for now).
 type Point struct {
 	SRID uint32
@@ -96,22 +107,22 @@ func WriteEWKBHeader(v interface{}, buf []byte) {
 	switch v := v.(type) {
 	case Point:
 		// Write SRID and type
-		binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
-		binary.LittleEndian.PutUint32(buf[5:9], 1)
+		binary.LittleEndian.PutUint32(buf[0:SRIDSize], v.SRID)
+		binary.LittleEndian.PutUint32(buf[SRIDSize + EndianSize:EWKBHeaderSize], PointID)
 	case Linestring:
-		binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
-		binary.LittleEndian.PutUint32(buf[5:9], 2)
+		binary.LittleEndian.PutUint32(buf[0:SRIDSize], v.SRID)
+		binary.LittleEndian.PutUint32(buf[SRIDSize + EndianSize:EWKBHeaderSize], LinestringID)
 	case Polygon:
-		binary.LittleEndian.PutUint32(buf[0:4], v.SRID)
-		binary.LittleEndian.PutUint32(buf[5:9], 3)
+		binary.LittleEndian.PutUint32(buf[0:SRIDSize], v.SRID)
+		binary.LittleEndian.PutUint32(buf[SRIDSize + EndianSize:EWKBHeaderSize], PolygonID)
 	}
 }
 
 // WriteEWKBPointData converts a Point into a byte array in EWKB format
 // Very similar to function in GMS
 func WriteEWKBPointData(p Point, buf []byte) {
-	binary.LittleEndian.PutUint64(buf[0:8], math.Float64bits(p.X))
-	binary.LittleEndian.PutUint64(buf[8:16], math.Float64bits(p.Y))
+	binary.LittleEndian.PutUint64(buf[:PointDataSize/2], math.Float64bits(p.X))
+	binary.LittleEndian.PutUint64(buf[PointDataSize/2:], math.Float64bits(p.Y))
 }
 
 func (v Point) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
@@ -121,13 +132,12 @@ func (v Point) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 		return err
 	}
 
-	// TODO: Write constants for all this
 	// Allocate buffer for point 4 + 1 + 4 + 16
-	buf := make([]byte, 25)
+	buf := make([]byte, EWKBHeaderSize + PointDataSize)
 
 	// Write header and data to buffer
 	WriteEWKBHeader(v, buf)
-	WriteEWKBPointData(v, buf[9:])
+	WriteEWKBPointData(v, buf[EWKBHeaderSize:])
 
 	w.writeString(string(buf))
 	return nil
@@ -135,9 +145,9 @@ func (v Point) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 
 // ParseEWKBHeader converts the header potion of a EWKB byte array to srid, endianness, and geometry type
 func ParseEWKBHeader(buf []byte) (uint32, bool, uint32) {
-	srid := binary.LittleEndian.Uint32(buf[0:4])     // First 4 bytes is SRID always in little endian
-	isBig := buf[4] == 0                             // Next byte is endianness
-	geomType := binary.LittleEndian.Uint32(buf[5:9]) // Next 4 bytes is type
+	srid := binary.LittleEndian.Uint32(buf[0:SRIDSize])     // First 4 bytes is SRID always in little endian
+	isBig := buf[SRIDSize] == 0                             // Next byte is endianness
+	geomType := binary.LittleEndian.Uint32(buf[SRIDSize + EndianSize:EWKBHeaderSize]) // Next 4 bytes is type
 	return srid, isBig, geomType
 }
 
@@ -145,8 +155,8 @@ func ParseEWKBHeader(buf []byte) (uint32, bool, uint32) {
 // Very similar logic to the function in GMS
 func ParseEWKBPoint(buf []byte, srid uint32) Point {
 	// Read floats x and y
-	x := math.Float64frombits(binary.LittleEndian.Uint64(buf[:8]))
-	y := math.Float64frombits(binary.LittleEndian.Uint64(buf[8:]))
+	x := math.Float64frombits(binary.LittleEndian.Uint64(buf[:PointDataSize/2]))
+	y := math.Float64frombits(binary.LittleEndian.Uint64(buf[PointDataSize/2:]))
 	return Point{SRID: srid, X: x, Y: y}
 }
 
@@ -156,7 +166,7 @@ func readPoint(nbf *NomsBinFormat, b *valueDecoder) (Point, error) {
 	if geomType != 1 {
 		return Point{}, errors.New("not a point")
 	}
-	return ParseEWKBPoint(buf[9:], srid), nil
+	return ParseEWKBPoint(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Point) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
@@ -165,7 +175,7 @@ func (v Point) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error)
 	if geomType != 1 {
 		return Point{}, errors.New("not a point")
 	}
-	return ParseEWKBPoint(buf[9:], srid), nil
+	return ParseEWKBPoint(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Point) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
diff --git a/go/store/types/polygon.go b/go/store/types/polygon.go
index 4f1cf10950..57e0b91b12 100644
--- a/go/store/types/polygon.go
+++ b/go/store/types/polygon.go
@@ -126,11 +126,11 @@ func (v Polygon) valueReadWriter() ValueReadWriter {
 // WriteEWKBPolyData converts a Polygon into a byte array in EWKB format
 func WriteEWKBPolyData(p Polygon, buf []byte) {
 	// Write length of polygon
-	binary.LittleEndian.PutUint32(buf[:4], uint32(len(p.Lines)))
+	binary.LittleEndian.PutUint32(buf[:LengthSize], uint32(len(p.Lines)))
 	// Write each line
-	start, stop := 0, 4
+	start, stop := 0, LengthSize
 	for _, l := range p.Lines {
-		start, stop = stop, stop+4+16*len(l.Points)
+		start, stop = stop, stop+LengthSize+PointDataSize*len(l.Points)
 		WriteEWKBLineData(l, buf[start:stop])
 	}
 }
@@ -144,15 +144,15 @@ func (v Polygon) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	// Calculate space for polygon buffer
 	size := 0
 	for _, l := range v.Lines {
-		size += 4 + 16*len(l.Points)
+		size += LengthSize + PointDataSize*len(l.Points)
 	}
 
 	// Allocate buffer for poly
-	buf := make([]byte, 9+4+size)
+	buf := make([]byte, EWKBHeaderSize+LengthSize+size)
 
 	// Write header and data to buffer
 	WriteEWKBHeader(v, buf)
-	WriteEWKBPolyData(v, buf[9:])
+	WriteEWKBPolyData(v, buf[EWKBHeaderSize:])
 
 	w.writeString(string(buf))
 	return nil
@@ -162,14 +162,14 @@ func (v Polygon) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 // Very similar logic to the function in GMS
 func ParseEWKBToPoly(buf []byte, srid uint32) Polygon {
 	// Read length of Polygon
-	numLines := binary.LittleEndian.Uint32(buf[:4])
+	numLines := binary.LittleEndian.Uint32(buf[:LengthSize])
 
 	// Parse lines
 	s := 4
 	lines := make([]Linestring, numLines)
 	for i := uint32(0); i < numLines; i++ {
 		lines[i] = ParseEWKBLine(buf[s:], srid)
-		s += 4 * 16 * len(lines[i].Points)
+		s += LengthSize * PointDataSize * len(lines[i].Points)
 	}
 
 	return Polygon{SRID: srid, Lines: lines}
@@ -181,7 +181,7 @@ func readPolygon(nbf *NomsBinFormat, b *valueDecoder) (Polygon, error) {
 	if geomType != 3 {
 		return Polygon{}, errors.New("not a polygon")
 	}
-	return ParseEWKBToPoly(buf[9:], srid), nil
+	return ParseEWKBToPoly(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Polygon) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
@@ -190,7 +190,7 @@ func (v Polygon) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error
 	if geomType != 3 {
 		return nil, errors.New("not a polygon")
 	}
-	return ParseEWKBToPoly(buf[9:], srid), nil
+	return ParseEWKBToPoly(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Polygon) skip(nbf *NomsBinFormat, b *binaryNomsReader) {

From 9c5eec05b294aaa6fa5fd1482bab42654d4c68ae Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Wed, 19 Jan 2022 13:19:34 -0800
Subject: [PATCH 30/51] package privating write and parse functions

---
 go/store/types/linestring.go | 24 ++++++++++++------------
 go/store/types/point.go      | 28 ++++++++++++++--------------
 go/store/types/polygon.go    | 24 ++++++++++++------------
 3 files changed, 38 insertions(+), 38 deletions(-)

diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
index 05f2a153f8..23c821e3ef 100644
--- a/go/store/types/linestring.go
+++ b/go/store/types/linestring.go
@@ -130,13 +130,13 @@ func (v Linestring) valueReadWriter() ValueReadWriter {
 	return nil
 }
 
-// WriteEWKBLineData converts a Line into a byte array in EWKB format
-func WriteEWKBLineData(l Linestring, buf []byte) {
+// writeEWKBLineData converts a Line into a byte array in EWKB format
+func writeEWKBLineData(l Linestring, buf []byte) {
 	// Write length of linestring
 	binary.LittleEndian.PutUint32(buf[:LengthSize], uint32(len(l.Points)))
 	// Append each point
 	for i, p := range l.Points {
-		WriteEWKBPointData(p, buf[LengthSize+PointDataSize*i:LengthSize+PointDataSize*(i+1)])
+		writeEWKBPointData(p, buf[LengthSize+PointDataSize*i:LengthSize+PointDataSize*(i+1)])
 	}
 }
 
@@ -150,23 +150,23 @@ func (v Linestring) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	buf := make([]byte, EWKBHeaderSize+LengthSize+PointDataSize*len(v.Points))
 
 	// Write header and data to buffer
-	WriteEWKBHeader(v, buf)
-	WriteEWKBLineData(v, buf[EWKBHeaderSize:])
+	writeEWKBHeader(v, buf)
+	writeEWKBLineData(v, buf[EWKBHeaderSize:])
 
 	w.writeString(string(buf))
 	return nil
 }
 
-// ParseEWKBLine converts the data portion of a WKB point to Linestring
+// parseEWKBLine converts the data portion of a WKB point to Linestring
 // Very similar logic to the function in GMS
-func ParseEWKBLine(buf []byte, srid uint32) Linestring {
+func parseEWKBLine(buf []byte, srid uint32) Linestring {
 	// Read length of linestring
 	numPoints := binary.LittleEndian.Uint32(buf[:4])
 
 	// Parse points
 	points := make([]Point, numPoints)
 	for i := uint32(0); i < numPoints; i++ {
-		points[i] = ParseEWKBPoint(buf[LengthSize+PointDataSize*i:LengthSize+PointDataSize*(i+1)], srid)
+		points[i] = parseEWKBPoint(buf[LengthSize+PointDataSize*i:LengthSize+PointDataSize*(i+1)], srid)
 	}
 
 	return Linestring{SRID: srid, Points: points}
@@ -174,20 +174,20 @@ func ParseEWKBLine(buf []byte, srid uint32) Linestring {
 
 func readLinestring(nbf *NomsBinFormat, b *valueDecoder) (Linestring, error) {
 	buf := []byte(b.ReadString())
-	srid, _, geomType := ParseEWKBHeader(buf)
+	srid, _, geomType := parseEWKBHeader(buf)
 	if geomType != 2 {
 		return Linestring{}, errors.New("not a linestring")
 	}
-	return ParseEWKBLine(buf[EWKBHeaderSize:], srid), nil
+	return parseEWKBLine(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Linestring) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
 	buf := []byte(b.ReadString())
-	srid, _, geomType := ParseEWKBHeader(buf)
+	srid, _, geomType := parseEWKBHeader(buf)
 	if geomType != 2 {
 		return nil, errors.New("not a linestring")
 	}
-	return ParseEWKBLine(buf[EWKBHeaderSize:], srid), nil
+	return parseEWKBLine(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Linestring) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
diff --git a/go/store/types/point.go b/go/store/types/point.go
index 15b820db28..237e8917a2 100644
--- a/go/store/types/point.go
+++ b/go/store/types/point.go
@@ -97,9 +97,9 @@ func (v Point) valueReadWriter() ValueReadWriter {
 	return nil
 }
 
-// WriteEWKBHeader writes the SRID, endianness, and type to the byte buffer
+// writeEWKBHeader writes the SRID, endianness, and type to the byte buffer
 // This function assumes v is a valid spatial type
-func WriteEWKBHeader(v interface{}, buf []byte) {
+func writeEWKBHeader(v interface{}, buf []byte) {
 	// Write endianness byte (always little endian)
 	buf[4] = 1
 
@@ -118,9 +118,9 @@ func WriteEWKBHeader(v interface{}, buf []byte) {
 	}
 }
 
-// WriteEWKBPointData converts a Point into a byte array in EWKB format
+// writeEWKBPointData converts a Point into a byte array in EWKB format
 // Very similar to function in GMS
-func WriteEWKBPointData(p Point, buf []byte) {
+func writeEWKBPointData(p Point, buf []byte) {
 	binary.LittleEndian.PutUint64(buf[:PointDataSize/2], math.Float64bits(p.X))
 	binary.LittleEndian.PutUint64(buf[PointDataSize/2:], math.Float64bits(p.Y))
 }
@@ -136,24 +136,24 @@ func (v Point) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	buf := make([]byte, EWKBHeaderSize + PointDataSize)
 
 	// Write header and data to buffer
-	WriteEWKBHeader(v, buf)
-	WriteEWKBPointData(v, buf[EWKBHeaderSize:])
+	writeEWKBHeader(v, buf)
+	writeEWKBPointData(v, buf[EWKBHeaderSize:])
 
 	w.writeString(string(buf))
 	return nil
 }
 
-// ParseEWKBHeader converts the header potion of a EWKB byte array to srid, endianness, and geometry type
-func ParseEWKBHeader(buf []byte) (uint32, bool, uint32) {
+// parseEWKBHeader converts the header potion of a EWKB byte array to srid, endianness, and geometry type
+func parseEWKBHeader(buf []byte) (uint32, bool, uint32) {
 	srid := binary.LittleEndian.Uint32(buf[0:SRIDSize])     // First 4 bytes is SRID always in little endian
 	isBig := buf[SRIDSize] == 0                             // Next byte is endianness
 	geomType := binary.LittleEndian.Uint32(buf[SRIDSize + EndianSize:EWKBHeaderSize]) // Next 4 bytes is type
 	return srid, isBig, geomType
 }
 
-// ParseEWKBPoint converts the data portion of a WKB point to Point
+// parseEWKBPoint converts the data portion of a WKB point to Point
 // Very similar logic to the function in GMS
-func ParseEWKBPoint(buf []byte, srid uint32) Point {
+func parseEWKBPoint(buf []byte, srid uint32) Point {
 	// Read floats x and y
 	x := math.Float64frombits(binary.LittleEndian.Uint64(buf[:PointDataSize/2]))
 	y := math.Float64frombits(binary.LittleEndian.Uint64(buf[PointDataSize/2:]))
@@ -162,20 +162,20 @@ func ParseEWKBPoint(buf []byte, srid uint32) Point {
 
 func readPoint(nbf *NomsBinFormat, b *valueDecoder) (Point, error) {
 	buf := []byte(b.ReadString())
-	srid, _, geomType := ParseEWKBHeader(buf) // Assume it's always little endian
+	srid, _, geomType := parseEWKBHeader(buf) // Assume it's always little endian
 	if geomType != 1 {
 		return Point{}, errors.New("not a point")
 	}
-	return ParseEWKBPoint(buf[EWKBHeaderSize:], srid), nil
+	return parseEWKBPoint(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Point) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
 	buf := []byte(b.ReadString())
-	srid, _, geomType := ParseEWKBHeader(buf) // Assume it's always little endian
+	srid, _, geomType := parseEWKBHeader(buf) // Assume it's always little endian
 	if geomType != 1 {
 		return Point{}, errors.New("not a point")
 	}
-	return ParseEWKBPoint(buf[EWKBHeaderSize:], srid), nil
+	return parseEWKBPoint(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Point) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
diff --git a/go/store/types/polygon.go b/go/store/types/polygon.go
index 57e0b91b12..e427376b56 100644
--- a/go/store/types/polygon.go
+++ b/go/store/types/polygon.go
@@ -123,15 +123,15 @@ func (v Polygon) valueReadWriter() ValueReadWriter {
 	return nil
 }
 
-// WriteEWKBPolyData converts a Polygon into a byte array in EWKB format
-func WriteEWKBPolyData(p Polygon, buf []byte) {
+// writeEWKBPolyData converts a Polygon into a byte array in EWKB format
+func writeEWKBPolyData(p Polygon, buf []byte) {
 	// Write length of polygon
 	binary.LittleEndian.PutUint32(buf[:LengthSize], uint32(len(p.Lines)))
 	// Write each line
 	start, stop := 0, LengthSize
 	for _, l := range p.Lines {
 		start, stop = stop, stop+LengthSize+PointDataSize*len(l.Points)
-		WriteEWKBLineData(l, buf[start:stop])
+		writeEWKBLineData(l, buf[start:stop])
 	}
 }
 
@@ -151,16 +151,16 @@ func (v Polygon) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	buf := make([]byte, EWKBHeaderSize+LengthSize+size)
 
 	// Write header and data to buffer
-	WriteEWKBHeader(v, buf)
-	WriteEWKBPolyData(v, buf[EWKBHeaderSize:])
+	writeEWKBHeader(v, buf)
+	writeEWKBPolyData(v, buf[EWKBHeaderSize:])
 
 	w.writeString(string(buf))
 	return nil
 }
 
-// ParseEWKBToPoly converts the data portions of a WKB polygon to Polygon
+// parseEWKBToPoly converts the data portions of a WKB polygon to Polygon
 // Very similar logic to the function in GMS
-func ParseEWKBToPoly(buf []byte, srid uint32) Polygon {
+func parseEWKBToPoly(buf []byte, srid uint32) Polygon {
 	// Read length of Polygon
 	numLines := binary.LittleEndian.Uint32(buf[:LengthSize])
 
@@ -168,7 +168,7 @@ func ParseEWKBToPoly(buf []byte, srid uint32) Polygon {
 	s := 4
 	lines := make([]Linestring, numLines)
 	for i := uint32(0); i < numLines; i++ {
-		lines[i] = ParseEWKBLine(buf[s:], srid)
+		lines[i] = parseEWKBLine(buf[s:], srid)
 		s += LengthSize * PointDataSize * len(lines[i].Points)
 	}
 
@@ -177,20 +177,20 @@ func ParseEWKBToPoly(buf []byte, srid uint32) Polygon {
 
 func readPolygon(nbf *NomsBinFormat, b *valueDecoder) (Polygon, error) {
 	buf := []byte(b.ReadString())
-	srid, _, geomType := ParseEWKBHeader(buf)
+	srid, _, geomType := parseEWKBHeader(buf)
 	if geomType != 3 {
 		return Polygon{}, errors.New("not a polygon")
 	}
-	return ParseEWKBToPoly(buf[EWKBHeaderSize:], srid), nil
+	return parseEWKBToPoly(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Polygon) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
 	buf := []byte(b.ReadString())
-	srid, _, geomType := ParseEWKBHeader(buf)
+	srid, _, geomType := parseEWKBHeader(buf)
 	if geomType != 3 {
 		return nil, errors.New("not a polygon")
 	}
-	return ParseEWKBToPoly(buf[EWKBHeaderSize:], srid), nil
+	return parseEWKBToPoly(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Polygon) skip(nbf *NomsBinFormat, b *binaryNomsReader) {

From 681bf06edf2af90be8cf6bba52039e296ecc376e Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Wed, 19 Jan 2022 13:39:31 -0800
Subject: [PATCH 31/51] using walkrefs

---
 go/store/types/linestring.go |  9 +++++++--
 go/store/types/point.go      |  8 ++++----
 go/store/types/polygon.go    | 11 ++++++++---
 3 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
index 23c821e3ef..59500fe1da 100644
--- a/go/store/types/linestring.go
+++ b/go/store/types/linestring.go
@@ -111,6 +111,11 @@ func (v Linestring) isPrimitive() bool {
 }
 
 func (v Linestring) WalkValues(ctx context.Context, cb ValueCallback) error {
+	for _,p := range v.Points {
+		if err := p.WalkValues(ctx, cb); err != nil {
+			return err
+		}
+	}
 	return nil
 }
 
@@ -175,7 +180,7 @@ func parseEWKBLine(buf []byte, srid uint32) Linestring {
 func readLinestring(nbf *NomsBinFormat, b *valueDecoder) (Linestring, error) {
 	buf := []byte(b.ReadString())
 	srid, _, geomType := parseEWKBHeader(buf)
-	if geomType != 2 {
+	if geomType != LinestringID {
 		return Linestring{}, errors.New("not a linestring")
 	}
 	return parseEWKBLine(buf[EWKBHeaderSize:], srid), nil
@@ -184,7 +189,7 @@ func readLinestring(nbf *NomsBinFormat, b *valueDecoder) (Linestring, error) {
 func (v Linestring) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
 	buf := []byte(b.ReadString())
 	srid, _, geomType := parseEWKBHeader(buf)
-	if geomType != 2 {
+	if geomType != LinestringID {
 		return nil, errors.New("not a linestring")
 	}
 	return parseEWKBLine(buf[EWKBHeaderSize:], srid), nil
diff --git a/go/store/types/point.go b/go/store/types/point.go
index 237e8917a2..89db3245d4 100644
--- a/go/store/types/point.go
+++ b/go/store/types/point.go
@@ -78,7 +78,7 @@ func (v Point) isPrimitive() bool {
 }
 
 func (v Point) WalkValues(ctx context.Context, cb ValueCallback) error {
-	return nil
+	return cb(v)
 }
 
 func (v Point) WalkRefs(nbf *NomsBinFormat, cb RefCallback) error {
@@ -101,7 +101,7 @@ func (v Point) valueReadWriter() ValueReadWriter {
 // This function assumes v is a valid spatial type
 func writeEWKBHeader(v interface{}, buf []byte) {
 	// Write endianness byte (always little endian)
-	buf[4] = 1
+	buf[SRIDSize] = 1
 
 	// Parse data
 	switch v := v.(type) {
@@ -163,7 +163,7 @@ func parseEWKBPoint(buf []byte, srid uint32) Point {
 func readPoint(nbf *NomsBinFormat, b *valueDecoder) (Point, error) {
 	buf := []byte(b.ReadString())
 	srid, _, geomType := parseEWKBHeader(buf) // Assume it's always little endian
-	if geomType != 1 {
+	if geomType != PointID {
 		return Point{}, errors.New("not a point")
 	}
 	return parseEWKBPoint(buf[EWKBHeaderSize:], srid), nil
@@ -172,7 +172,7 @@ func readPoint(nbf *NomsBinFormat, b *valueDecoder) (Point, error) {
 func (v Point) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
 	buf := []byte(b.ReadString())
 	srid, _, geomType := parseEWKBHeader(buf) // Assume it's always little endian
-	if geomType != 1 {
+	if geomType != PointID {
 		return Point{}, errors.New("not a point")
 	}
 	return parseEWKBPoint(buf[EWKBHeaderSize:], srid), nil
diff --git a/go/store/types/polygon.go b/go/store/types/polygon.go
index e427376b56..ce13e0ca3f 100644
--- a/go/store/types/polygon.go
+++ b/go/store/types/polygon.go
@@ -104,6 +104,11 @@ func (v Polygon) isPrimitive() bool {
 }
 
 func (v Polygon) WalkValues(ctx context.Context, cb ValueCallback) error {
+	for _, l := range v.Lines {
+		if err := l.WalkValues(ctx, cb); err != nil {
+			return err
+		}
+	}
 	return nil
 }
 
@@ -165,7 +170,7 @@ func parseEWKBToPoly(buf []byte, srid uint32) Polygon {
 	numLines := binary.LittleEndian.Uint32(buf[:LengthSize])
 
 	// Parse lines
-	s := 4
+	s := LengthSize
 	lines := make([]Linestring, numLines)
 	for i := uint32(0); i < numLines; i++ {
 		lines[i] = parseEWKBLine(buf[s:], srid)
@@ -178,7 +183,7 @@ func parseEWKBToPoly(buf []byte, srid uint32) Polygon {
 func readPolygon(nbf *NomsBinFormat, b *valueDecoder) (Polygon, error) {
 	buf := []byte(b.ReadString())
 	srid, _, geomType := parseEWKBHeader(buf)
-	if geomType != 3 {
+	if geomType != PolygonID {
 		return Polygon{}, errors.New("not a polygon")
 	}
 	return parseEWKBToPoly(buf[EWKBHeaderSize:], srid), nil
@@ -187,7 +192,7 @@ func readPolygon(nbf *NomsBinFormat, b *valueDecoder) (Polygon, error) {
 func (v Polygon) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
 	buf := []byte(b.ReadString())
 	srid, _, geomType := parseEWKBHeader(buf)
-	if geomType != 3 {
+	if geomType != PolygonID {
 		return nil, errors.New("not a polygon")
 	}
 	return parseEWKBToPoly(buf[EWKBHeaderSize:], srid), nil

From 82e185181da6768086a6abdb48bfcf0dd63bd0f2 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Wed, 19 Jan 2022 14:05:07 -0800
Subject: [PATCH 32/51] implemented value decoder

---
 go/store/types/polygon.go       |  8 ++++----
 go/store/types/value_decoder.go | 25 ++++++++++++++++++-------
 2 files changed, 22 insertions(+), 11 deletions(-)

diff --git a/go/store/types/polygon.go b/go/store/types/polygon.go
index ce13e0ca3f..ebde13d4db 100644
--- a/go/store/types/polygon.go
+++ b/go/store/types/polygon.go
@@ -163,9 +163,9 @@ func (v Polygon) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	return nil
 }
 
-// parseEWKBToPoly converts the data portions of a WKB polygon to Polygon
+// parseEWKBPoly converts the data portions of a WKB polygon to Polygon
 // Very similar logic to the function in GMS
-func parseEWKBToPoly(buf []byte, srid uint32) Polygon {
+func parseEWKBPoly(buf []byte, srid uint32) Polygon {
 	// Read length of Polygon
 	numLines := binary.LittleEndian.Uint32(buf[:LengthSize])
 
@@ -186,7 +186,7 @@ func readPolygon(nbf *NomsBinFormat, b *valueDecoder) (Polygon, error) {
 	if geomType != PolygonID {
 		return Polygon{}, errors.New("not a polygon")
 	}
-	return parseEWKBToPoly(buf[EWKBHeaderSize:], srid), nil
+	return parseEWKBPoly(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Polygon) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
@@ -195,7 +195,7 @@ func (v Polygon) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error
 	if geomType != PolygonID {
 		return nil, errors.New("not a polygon")
 	}
-	return parseEWKBToPoly(buf[EWKBHeaderSize:], srid), nil
+	return parseEWKBPoly(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Polygon) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
diff --git a/go/store/types/value_decoder.go b/go/store/types/value_decoder.go
index 54df1651f6..f03f0bfeb4 100644
--- a/go/store/types/value_decoder.go
+++ b/go/store/types/value_decoder.go
@@ -373,17 +373,28 @@ func (r *valueDecoder) readValue(nbf *NomsBinFormat) (Value, error) {
 		return r.ReadJSON()
 	case PointKind:
 		r.skipKind()
-		r.ReadString()
-		// TODO: parse ewkb to point?
-		return Point{}, nil
+		buf := []byte(r.ReadString())
+		srid, _, geomType := parseEWKBHeader(buf)
+		if geomType != PointID {
+			return nil, ErrUnknownType
+		}
+		return parseEWKBPoint(buf[EWKBHeaderSize:], srid), nil
 	case LinestringKind:
 		r.skipKind()
-		r.ReadString()
-		return Linestring{}, nil
+		buf := []byte(r.ReadString())
+		srid, _, geomType := parseEWKBHeader(buf)
+		if geomType != LinestringID {
+			return nil, ErrUnknownType
+		}
+		return parseEWKBLine(buf[EWKBHeaderSize:], srid), nil
 	case PolygonKind:
 		r.skipKind()
-		r.ReadString()
-		return Polygon{}, nil
+		buf := []byte(r.ReadString())
+		srid, _, geomType := parseEWKBHeader(buf)
+		if geomType != PolygonID {
+			return nil, ErrUnknownType
+		}
+		return parseEWKBPoly(buf[EWKBHeaderSize:], srid), nil
 	case TypeKind:
 		r.skipKind()
 		return r.readType()

From 49a871b361ef8e1ab5ab875904a98708e17dbe8b Mon Sep 17 00:00:00 2001
From: JCOR11599 <JCOR11599@users.noreply.github.com>
Date: Wed, 19 Jan 2022 22:33:33 +0000
Subject: [PATCH 33/51] [ga-format-pr] Run go/utils/repofmt/format_repo.sh and
 go/Godeps/update.sh

---
 go/store/types/linestring.go |  2 +-
 go/store/types/point.go      | 28 ++++++++++++++--------------
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
index 59500fe1da..436dd40ad3 100644
--- a/go/store/types/linestring.go
+++ b/go/store/types/linestring.go
@@ -111,7 +111,7 @@ func (v Linestring) isPrimitive() bool {
 }
 
 func (v Linestring) WalkValues(ctx context.Context, cb ValueCallback) error {
-	for _,p := range v.Points {
+	for _, p := range v.Points {
 		if err := p.WalkValues(ctx, cb); err != nil {
 			return err
 		}
diff --git a/go/store/types/point.go b/go/store/types/point.go
index 89db3245d4..fb9d008014 100644
--- a/go/store/types/point.go
+++ b/go/store/types/point.go
@@ -33,14 +33,14 @@ import (
 )
 
 const (
-	SRIDSize = 4
-	EndianSize = 1
-	TypeSize = 4
+	SRIDSize       = 4
+	EndianSize     = 1
+	TypeSize       = 4
 	EWKBHeaderSize = SRIDSize + EndianSize + TypeSize
-	PointDataSize = 16
-	PointID = 1
-	LinestringID = 2
-	PolygonID = 3
+	PointDataSize  = 16
+	PointID        = 1
+	LinestringID   = 2
+	PolygonID      = 3
 )
 
 // Point is a Noms Value wrapper around the primitive string type (for now).
@@ -108,13 +108,13 @@ func writeEWKBHeader(v interface{}, buf []byte) {
 	case Point:
 		// Write SRID and type
 		binary.LittleEndian.PutUint32(buf[0:SRIDSize], v.SRID)
-		binary.LittleEndian.PutUint32(buf[SRIDSize + EndianSize:EWKBHeaderSize], PointID)
+		binary.LittleEndian.PutUint32(buf[SRIDSize+EndianSize:EWKBHeaderSize], PointID)
 	case Linestring:
 		binary.LittleEndian.PutUint32(buf[0:SRIDSize], v.SRID)
-		binary.LittleEndian.PutUint32(buf[SRIDSize + EndianSize:EWKBHeaderSize], LinestringID)
+		binary.LittleEndian.PutUint32(buf[SRIDSize+EndianSize:EWKBHeaderSize], LinestringID)
 	case Polygon:
 		binary.LittleEndian.PutUint32(buf[0:SRIDSize], v.SRID)
-		binary.LittleEndian.PutUint32(buf[SRIDSize + EndianSize:EWKBHeaderSize], PolygonID)
+		binary.LittleEndian.PutUint32(buf[SRIDSize+EndianSize:EWKBHeaderSize], PolygonID)
 	}
 }
 
@@ -133,7 +133,7 @@ func (v Point) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	}
 
 	// Allocate buffer for point 4 + 1 + 4 + 16
-	buf := make([]byte, EWKBHeaderSize + PointDataSize)
+	buf := make([]byte, EWKBHeaderSize+PointDataSize)
 
 	// Write header and data to buffer
 	writeEWKBHeader(v, buf)
@@ -145,9 +145,9 @@ func (v Point) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 
 // parseEWKBHeader converts the header potion of a EWKB byte array to srid, endianness, and geometry type
 func parseEWKBHeader(buf []byte) (uint32, bool, uint32) {
-	srid := binary.LittleEndian.Uint32(buf[0:SRIDSize])     // First 4 bytes is SRID always in little endian
-	isBig := buf[SRIDSize] == 0                             // Next byte is endianness
-	geomType := binary.LittleEndian.Uint32(buf[SRIDSize + EndianSize:EWKBHeaderSize]) // Next 4 bytes is type
+	srid := binary.LittleEndian.Uint32(buf[0:SRIDSize])                               // First 4 bytes is SRID always in little endian
+	isBig := buf[SRIDSize] == 0                                                       // Next byte is endianness
+	geomType := binary.LittleEndian.Uint32(buf[SRIDSize+EndianSize : EWKBHeaderSize]) // Next 4 bytes is type
 	return srid, isBig, geomType
 }
 

From 96f094d018877cc22403fb5fbdcb4600aa17a4a7 Mon Sep 17 00:00:00 2001
From: Andy Arthur <andy@dolthub.com>
Date: Thu, 20 Jan 2022 11:18:49 -0800
Subject: [PATCH 34/51] added feature flag for spatial types

---
 .../doltcore/schema/typeinfo/typeinfo.go      | 29 +++++++++++++++----
 1 file changed, 23 insertions(+), 6 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/typeinfo.go b/go/libraries/doltcore/schema/typeinfo/typeinfo.go
index 8ad0cca392..f900979cea 100644
--- a/go/libraries/doltcore/schema/typeinfo/typeinfo.go
+++ b/go/libraries/doltcore/schema/typeinfo/typeinfo.go
@@ -18,6 +18,7 @@ import (
 	"context"
 	"fmt"
 	"math"
+	"os"
 
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/vitess/go/sqltypes"
@@ -25,6 +26,17 @@ import (
 	"github.com/dolthub/dolt/go/store/types"
 )
 
+const spatialTypesFeatureFlagKey = "DOLT_ENABLE_SPATIAL_TYPES"
+
+var spatialTypesFeatureFlag = false
+
+func init() {
+	// set the spatial types feature flag to true if the env var is set
+	if v, ok := os.LookupEnv(spatialTypesFeatureFlagKey); ok && v != "" {
+		spatialTypesFeatureFlag = true
+	}
+}
+
 type Identifier string
 
 const (
@@ -249,6 +261,17 @@ func FromSqlType(sqlType sql.Type) (TypeInfo, error) {
 
 // FromTypeParams constructs a TypeInfo from the given identifier and parameters.
 func FromTypeParams(id Identifier, params map[string]string) (TypeInfo, error) {
+	if spatialTypesFeatureFlag {
+		switch id {
+		case PointTypeIdentifier:
+			return PointType, nil
+		case LinestringTypeIdentifier:
+			return LinestringType, nil
+		case PolygonTypeIdentifier:
+			return PolygonType, nil
+		}
+	}
+
 	switch id {
 	case BitTypeIdentifier:
 		return CreateBitTypeFromParams(params)
@@ -286,12 +309,6 @@ func FromTypeParams(id Identifier, params map[string]string) (TypeInfo, error) {
 		return CreateVarStringTypeFromParams(params)
 	case YearTypeIdentifier:
 		return YearType, nil
-	case PointTypeIdentifier:
-		return PointType, nil
-	case LinestringTypeIdentifier:
-		return LinestringType, nil
-	case PolygonTypeIdentifier:
-		return PolygonType, nil
 	default:
 		return nil, fmt.Errorf(`"%v" cannot be made from an identifier and params`, id)
 	}

From d0840ac6e6ddb1660888c217cce7ce77800f5ec9 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Thu, 20 Jan 2022 13:05:05 -0800
Subject: [PATCH 35/51] adding test for flag being set

---
 integration-tests/bats/sql-spatial-types.bats | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 integration-tests/bats/sql-spatial-types.bats

diff --git a/integration-tests/bats/sql-spatial-types.bats b/integration-tests/bats/sql-spatial-types.bats
new file mode 100644
index 0000000000..89e332d71f
--- /dev/null
+++ b/integration-tests/bats/sql-spatial-types.bats
@@ -0,0 +1,23 @@
+#!/usr/bin/env bats
+load $BATS_TEST_DIRNAME/helper/common.bash
+
+setup() {
+    setup_common
+}
+
+teardown() {
+    assert_feature_version
+    teardown_common
+}
+
+@test "sql-spatial-types: can't make spatial types without enabling feature flag" {
+    run dolt sql -q "create table point_tbl (p point)"
+    [[ "$output" =~ "cannot be made" ]] || false
+    [ "$status" -eq 1 ]
+}
+
+@test "sql-spatial-types: can make spatial types with flag" {
+    DOLT_ENABLE_SPATIAL_TYPES=true run dolt sql -q "create table point_tbl (p point)"
+    [[ "$output" =~ "" ]] || false
+    [ "$status" -eq 0 ]
+}
\ No newline at end of file

From acdcd50e27d01ce38319b6ea4102bf0a54bef27c Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Thu, 20 Jan 2022 13:16:56 -0800
Subject: [PATCH 36/51] fixing typeinfo equals method

---
 go/libraries/doltcore/schema/typeinfo/linestring.go | 6 ++----
 go/libraries/doltcore/schema/typeinfo/point.go      | 6 ++----
 go/libraries/doltcore/schema/typeinfo/polygon.go    | 6 ++----
 3 files changed, 6 insertions(+), 12 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
index 2dbe2d8fb7..125440976a 100644
--- a/go/libraries/doltcore/schema/typeinfo/linestring.go
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -101,10 +101,8 @@ func (ti *linestringType) Equals(other TypeInfo) bool {
 	if other == nil {
 		return false
 	}
-	if ti2, ok := other.(*linestringType); ok {
-		return ti.sqlLinestringType.Type() == ti2.sqlLinestringType.Type()
-	}
-	return false
+	_, ok := other.(*linestringType)
+	return ok
 }
 
 // FormatValue implements TypeInfo interface.
diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index c7922fac6e..88e707e260 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -95,10 +95,8 @@ func (ti *pointType) Equals(other TypeInfo) bool {
 	if other == nil {
 		return false
 	}
-	if ti2, ok := other.(*pointType); ok {
-		return ti.sqlPointType.Type() == ti2.sqlPointType.Type()
-	}
-	return false
+	_, ok := other.(*pointType)
+	return ok
 }
 
 // FormatValue implements TypeInfo interface.
diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
index 784932a504..92ddd05edd 100644
--- a/go/libraries/doltcore/schema/typeinfo/polygon.go
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -101,10 +101,8 @@ func (ti *polygonType) Equals(other TypeInfo) bool {
 	if other == nil {
 		return false
 	}
-	if ti2, ok := other.(*polygonType); ok {
-		return ti.sqlPolygonType.Type() == ti2.sqlPolygonType.Type()
-	}
-	return false
+	_, ok := other.(*polygonType)
+	return ok
 }
 
 // FormatValue implements TypeInfo interface.

From a8c376e2dae272f1f05a95d8131d9efbadccf867 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Thu, 20 Jan 2022 13:46:13 -0800
Subject: [PATCH 37/51] adding type converter functions

---
 .../doltcore/schema/typeinfo/linestring.go    | 48 +++++++++++++++++++
 .../doltcore/schema/typeinfo/point.go         | 48 +++++++++++++++++++
 .../doltcore/schema/typeinfo/polygon.go       | 48 +++++++++++++++++++
 .../doltcore/schema/typeinfo/typeconverter.go |  6 +++
 .../doltcore/schema/typeinfo/typeinfo.go      |  2 +-
 5 files changed, 151 insertions(+), 1 deletion(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
index 125440976a..8c60bcd05a 100644
--- a/go/libraries/doltcore/schema/typeinfo/linestring.go
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -176,3 +176,51 @@ func (ti *linestringType) String() string {
 func (ti *linestringType) ToSqlType() sql.Type {
 	return ti.sqlLinestringType
 }
+
+// linestringTypeConverter is an internal function for GetTypeConverter that handles the specific type as the source TypeInfo.
+func linestringTypeConverter(ctx context.Context, src *linestringType, destTi TypeInfo) (tc TypeConverter, needsConversion bool, err error) {
+	switch dest := destTi.(type) {
+	case *bitType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *blobStringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *boolType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *datetimeType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *decimalType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *enumType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *floatType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *inlineBlobType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *intType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *jsonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return identityTypeConverter, false, nil
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *setType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *timeType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *uintType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *uuidType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *varBinaryType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *varStringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *yearType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	default:
+		return nil, false, UnhandledTypeConversion.New(src.String(), destTi.String())
+	}
+}
diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index 88e707e260..74732b00e4 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -170,3 +170,51 @@ func (ti *pointType) String() string {
 func (ti *pointType) ToSqlType() sql.Type {
 	return ti.sqlPointType
 }
+
+// pointTypeConverter is an internal function for GetTypeConverter that handles the specific type as the source TypeInfo.
+func pointTypeConverter(ctx context.Context, src *pointType, destTi TypeInfo) (tc TypeConverter, needsConversion bool, err error) {
+	switch dest := destTi.(type) {
+	case *bitType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *blobStringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *boolType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *datetimeType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *decimalType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *enumType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *floatType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *inlineBlobType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *intType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *jsonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return identityTypeConverter, false, nil
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *setType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *timeType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *uintType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *uuidType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *varBinaryType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *varStringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *yearType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	default:
+		return nil, false, UnhandledTypeConversion.New(src.String(), destTi.String())
+	}
+}
diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
index 92ddd05edd..03c14d4a12 100644
--- a/go/libraries/doltcore/schema/typeinfo/polygon.go
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -176,3 +176,51 @@ func (ti *polygonType) String() string {
 func (ti *polygonType) ToSqlType() sql.Type {
 	return ti.sqlPolygonType
 }
+
+// polygonTypeConverter is an internal function for GetTypeConverter that handles the specific type as the source TypeInfo.
+func polygonTypeConverter(ctx context.Context, src *polygonType, destTi TypeInfo) (tc TypeConverter, needsConversion bool, err error) {
+	switch dest := destTi.(type) {
+	case *bitType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *blobStringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *boolType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *datetimeType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *decimalType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *enumType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *floatType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *inlineBlobType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *intType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *jsonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return identityTypeConverter, false, nil
+	case *setType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *timeType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *uintType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *uuidType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *varBinaryType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *varStringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *yearType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	default:
+		return nil, false, UnhandledTypeConversion.New(src.String(), destTi.String())
+	}
+}
\ No newline at end of file
diff --git a/go/libraries/doltcore/schema/typeinfo/typeconverter.go b/go/libraries/doltcore/schema/typeinfo/typeconverter.go
index 45969d80b5..77642c1ac3 100644
--- a/go/libraries/doltcore/schema/typeinfo/typeconverter.go
+++ b/go/libraries/doltcore/schema/typeinfo/typeconverter.go
@@ -69,6 +69,12 @@ func GetTypeConverter(ctx context.Context, srcTi TypeInfo, destTi TypeInfo) (tc
 		return intTypeConverter(ctx, src, destTi)
 	case *jsonType:
 		return jsonTypeConverter(ctx, src, destTi)
+	case *linestringType:
+		return linestringTypeConverter(ctx, src, destTi)
+	case *pointType:
+		return pointTypeConverter(ctx, src, destTi)
+	case *polygonType:
+		return polygonTypeConverter(ctx, src, destTi)
 	case *setType:
 		return setTypeConverter(ctx, src, destTi)
 	case *timeType:
diff --git a/go/libraries/doltcore/schema/typeinfo/typeinfo.go b/go/libraries/doltcore/schema/typeinfo/typeinfo.go
index f900979cea..32be35c319 100644
--- a/go/libraries/doltcore/schema/typeinfo/typeinfo.go
+++ b/go/libraries/doltcore/schema/typeinfo/typeinfo.go
@@ -186,7 +186,7 @@ func FromSqlType(sqlType sql.Type) (TypeInfo, error) {
 		case sql.PointType{}.String():
 			return &pointType{sqlType.(sql.PointType)}, nil
 		default:
-			return nil, fmt.Errorf(`expected "PointTypeIdentifier" from SQL basetype "Point"`)
+			return nil, fmt.Errorf(`expected "PointTypeIdentifier" from SQL basetype "Geometry"`)
 		}
 	case sqltypes.Decimal:
 		decimalSQLType, ok := sqlType.(sql.DecimalType)

From 2b1f6b5fc4f1303e8672578f0b094cc2f847b335 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Thu, 20 Jan 2022 14:15:13 -0800
Subject: [PATCH 38/51] adding typeinfo tests

---
 go/libraries/doltcore/schema/typeinfo/typeinfo_test.go | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/go/libraries/doltcore/schema/typeinfo/typeinfo_test.go b/go/libraries/doltcore/schema/typeinfo/typeinfo_test.go
index b31b4a88b3..c484fce9cb 100644
--- a/go/libraries/doltcore/schema/typeinfo/typeinfo_test.go
+++ b/go/libraries/doltcore/schema/typeinfo/typeinfo_test.go
@@ -353,6 +353,9 @@ func generateTypeInfoArrays(t *testing.T) ([][]TypeInfo, [][]types.Value) {
 			{DefaultInlineBlobType},
 			{Int8Type, Int16Type, Int24Type, Int32Type, Int64Type},
 			{JSONType},
+			{LinestringType},
+			{PointType},
+			{PolygonType},
 			generateSetTypes(t, 16),
 			{TimeType},
 			{Uint8Type, Uint16Type, Uint24Type, Uint32Type, Uint64Type},
@@ -385,6 +388,9 @@ func generateTypeInfoArrays(t *testing.T) ([][]TypeInfo, [][]types.Value) {
 			{types.Int(20), types.Int(215), types.Int(237493), types.Int(2035753568), types.Int(2384384576063)},                            //Int
 			{json.MustTypesJSON(`null`), json.MustTypesJSON(`[]`), json.MustTypesJSON(`"lorem ipsum"`), json.MustTypesJSON(`2.71`),
 				json.MustTypesJSON(`false`), json.MustTypesJSON(`{"a": 1, "b": []}`)}, //JSON
+			{types.Linestring{SRID: 0, Points: []types.Point{{SRID: 0, X: 1, Y: 2},{SRID: 0, X: 3, Y: 4}}}}, // Linestring
+			{types.Point{SRID: 0, X: 1, Y: 2}}, // Point
+			{types.Polygon{SRID: 0, Lines: []types.Linestring{{SRID: 0, Points: []types.Point{{SRID: 0, X: 0, Y: 0},{SRID: 0, X: 0, Y: 1}, {SRID: 0, X: 1, Y: 1}, {SRID: 0, X: 0, Y: 0}}}}}}, // Polygon
 			{types.Uint(1), types.Uint(5), types.Uint(64), types.Uint(42), types.Uint(192)},                                                                                                //Set
 			{types.Int(0), types.Int(1000000 /*"00:00:01"*/), types.Int(113000000 /*"00:01:53"*/), types.Int(247019000000 /*"68:36:59"*/), types.Int(458830485214 /*"127:27:10.485214"*/)}, //Time
 			{types.Uint(20), types.Uint(275), types.Uint(328395), types.Uint(630257298), types.Uint(93897259874)},                                                                          //Uint

From d7823365d5aa2c19b56e74ec8060a814b76fa005 Mon Sep 17 00:00:00 2001
From: JCOR11599 <JCOR11599@users.noreply.github.com>
Date: Thu, 20 Jan 2022 22:20:41 +0000
Subject: [PATCH 39/51] [ga-format-pr] Run go/utils/repofmt/format_repo.sh and
 go/Godeps/update.sh

---
 go/libraries/doltcore/schema/typeinfo/polygon.go     |  2 +-
 .../doltcore/schema/typeinfo/typeinfo_test.go        | 12 ++++++------
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
index 03c14d4a12..058f8c6185 100644
--- a/go/libraries/doltcore/schema/typeinfo/polygon.go
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -223,4 +223,4 @@ func polygonTypeConverter(ctx context.Context, src *polygonType, destTi TypeInfo
 	default:
 		return nil, false, UnhandledTypeConversion.New(src.String(), destTi.String())
 	}
-}
\ No newline at end of file
+}
diff --git a/go/libraries/doltcore/schema/typeinfo/typeinfo_test.go b/go/libraries/doltcore/schema/typeinfo/typeinfo_test.go
index c484fce9cb..7499d0789d 100644
--- a/go/libraries/doltcore/schema/typeinfo/typeinfo_test.go
+++ b/go/libraries/doltcore/schema/typeinfo/typeinfo_test.go
@@ -388,13 +388,13 @@ func generateTypeInfoArrays(t *testing.T) ([][]TypeInfo, [][]types.Value) {
 			{types.Int(20), types.Int(215), types.Int(237493), types.Int(2035753568), types.Int(2384384576063)},                            //Int
 			{json.MustTypesJSON(`null`), json.MustTypesJSON(`[]`), json.MustTypesJSON(`"lorem ipsum"`), json.MustTypesJSON(`2.71`),
 				json.MustTypesJSON(`false`), json.MustTypesJSON(`{"a": 1, "b": []}`)}, //JSON
-			{types.Linestring{SRID: 0, Points: []types.Point{{SRID: 0, X: 1, Y: 2},{SRID: 0, X: 3, Y: 4}}}}, // Linestring
+			{types.Linestring{SRID: 0, Points: []types.Point{{SRID: 0, X: 1, Y: 2}, {SRID: 0, X: 3, Y: 4}}}}, // Linestring
 			{types.Point{SRID: 0, X: 1, Y: 2}}, // Point
-			{types.Polygon{SRID: 0, Lines: []types.Linestring{{SRID: 0, Points: []types.Point{{SRID: 0, X: 0, Y: 0},{SRID: 0, X: 0, Y: 1}, {SRID: 0, X: 1, Y: 1}, {SRID: 0, X: 0, Y: 0}}}}}}, // Polygon
-			{types.Uint(1), types.Uint(5), types.Uint(64), types.Uint(42), types.Uint(192)},                                                                                                //Set
-			{types.Int(0), types.Int(1000000 /*"00:00:01"*/), types.Int(113000000 /*"00:01:53"*/), types.Int(247019000000 /*"68:36:59"*/), types.Int(458830485214 /*"127:27:10.485214"*/)}, //Time
-			{types.Uint(20), types.Uint(275), types.Uint(328395), types.Uint(630257298), types.Uint(93897259874)},                                                                          //Uint
-			{types.UUID{3}, types.UUID{3, 13}, types.UUID{128, 238, 82, 12}, types.UUID{31, 54, 23, 13, 63, 43}, types.UUID{83, 64, 21, 14, 42, 6, 35, 7, 54, 234, 6, 32, 1, 4, 2, 4}},     //Uuid
+			{types.Polygon{SRID: 0, Lines: []types.Linestring{{SRID: 0, Points: []types.Point{{SRID: 0, X: 0, Y: 0}, {SRID: 0, X: 0, Y: 1}, {SRID: 0, X: 1, Y: 1}, {SRID: 0, X: 0, Y: 0}}}}}}, // Polygon
+			{types.Uint(1), types.Uint(5), types.Uint(64), types.Uint(42), types.Uint(192)},                                                                                                   //Set
+			{types.Int(0), types.Int(1000000 /*"00:00:01"*/), types.Int(113000000 /*"00:01:53"*/), types.Int(247019000000 /*"68:36:59"*/), types.Int(458830485214 /*"127:27:10.485214"*/)},    //Time
+			{types.Uint(20), types.Uint(275), types.Uint(328395), types.Uint(630257298), types.Uint(93897259874)},                                                                             //Uint
+			{types.UUID{3}, types.UUID{3, 13}, types.UUID{128, 238, 82, 12}, types.UUID{31, 54, 23, 13, 63, 43}, types.UUID{83, 64, 21, 14, 42, 6, 35, 7, 54, 234, 6, 32, 1, 4, 2, 4}},        //Uuid
 			{mustBlobBytes(t, []byte{1}), mustBlobBytes(t, []byte{42, 52}), mustBlobBytes(t, []byte{84, 32, 13, 63, 12, 86}), //VarBinary
 				mustBlobBytes(t, []byte{1, 32, 235, 64, 32, 23, 45, 76}), mustBlobBytes(t, []byte{123, 234, 34, 223, 76, 35, 32, 12, 84, 26, 15, 34, 65, 86, 45, 23, 43, 12, 76, 154, 234, 76, 34})},
 			{types.String(""), types.String("a"), types.String("abc"), //VarString

From 18a96ba1769b3d455bc0de804339a24313bdc1a2 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Thu, 20 Jan 2022 14:48:12 -0800
Subject: [PATCH 40/51] fixing humanreadablestring

---
 go/store/types/linestring.go | 2 +-
 go/store/types/polygon.go    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
index 436dd40ad3..a8059b8ad0 100644
--- a/go/store/types/linestring.go
+++ b/go/store/types/linestring.go
@@ -204,6 +204,6 @@ func (v Linestring) HumanReadableString() string {
 	for i, p := range v.Points {
 		points[i] = p.HumanReadableString()
 	}
-	s := fmt.Sprintf("SRID: %d LINESTRING(%s)", strings.Join(points, ","))
+	s := fmt.Sprintf("SRID: %d LINESTRING(%s)", v.SRID, strings.Join(points, ","))
 	return strconv.Quote(s)
 }
diff --git a/go/store/types/polygon.go b/go/store/types/polygon.go
index ebde13d4db..598a934938 100644
--- a/go/store/types/polygon.go
+++ b/go/store/types/polygon.go
@@ -207,6 +207,6 @@ func (v Polygon) HumanReadableString() string {
 	for i, l := range v.Lines {
 		lines[i] = l.HumanReadableString()
 	}
-	s := fmt.Sprintf("SRID: %d POLYGON(%s)", strings.Join(lines, ","))
+	s := fmt.Sprintf("SRID: %d POLYGON(%s)", v.SRID, strings.Join(lines, ","))
 	return strconv.Quote(s)
 }

From 51346dd1f51e6375c329b307fdf6b770f26f2f34 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Thu, 20 Jan 2022 16:46:26 -0800
Subject: [PATCH 41/51] removing parentheses

---
 go/libraries/doltcore/schema/typeinfo/linestring.go | 2 +-
 go/libraries/doltcore/schema/typeinfo/point.go      | 2 +-
 go/libraries/doltcore/schema/typeinfo/polygon.go    | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
index 8c60bcd05a..ca6831d05d 100644
--- a/go/libraries/doltcore/schema/typeinfo/linestring.go
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -169,7 +169,7 @@ func (ti *linestringType) Promote() TypeInfo {
 
 // String implements TypeInfo interface.
 func (ti *linestringType) String() string {
-	return "Linestring()"
+	return "Linestring"
 }
 
 // ToSqlType implements TypeInfo interface.
diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index 74732b00e4..d0fabe33d2 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -163,7 +163,7 @@ func (ti *pointType) Promote() TypeInfo {
 
 // String implements TypeInfo interface.
 func (ti *pointType) String() string {
-	return "Point()"
+	return "Point"
 }
 
 // ToSqlType implements TypeInfo interface.
diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
index 058f8c6185..1c92d58267 100644
--- a/go/libraries/doltcore/schema/typeinfo/polygon.go
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -169,7 +169,7 @@ func (ti *polygonType) Promote() TypeInfo {
 
 // String implements TypeInfo interface.
 func (ti *polygonType) String() string {
-	return "Polygon()"
+	return "Polygon"
 }
 
 // ToSqlType implements TypeInfo interface.

From e232ccc5c0298470f6f8b2a04b471a4cf83a3288 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Thu, 20 Jan 2022 18:07:31 -0800
Subject: [PATCH 42/51] fixed format and parse typeinfo functions, had the
 spatial types default to true so tests will pass

---
 .../doltcore/schema/typeinfo/linestring.go    | 26 ++++++++--------
 .../doltcore/schema/typeinfo/point.go         | 26 ++++++++--------
 .../doltcore/schema/typeinfo/polygon.go       | 30 ++++++++++---------
 .../doltcore/schema/typeinfo/typeinfo.go      |  2 +-
 go/store/types/linestring.go                  | 24 +++++++--------
 go/store/types/point.go                       | 28 ++++++++---------
 go/store/types/polygon.go                     | 26 ++++++++--------
 go/store/types/value_decoder.go               | 18 +++++------
 8 files changed, 89 insertions(+), 91 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
index ca6831d05d..3794184417 100644
--- a/go/libraries/doltcore/schema/typeinfo/linestring.go
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -108,14 +108,11 @@ func (ti *linestringType) Equals(other TypeInfo) bool {
 // FormatValue implements TypeInfo interface.
 func (ti *linestringType) FormatValue(v types.Value) (*string, error) {
 	if val, ok := v.(types.Linestring); ok {
-		res, err := ti.ConvertNomsValueToValue(val)
-		if err != nil {
-			return nil, err
-		}
-		if resStr, ok := res.(string); ok {
-			return &resStr, nil
-		}
-		return nil, fmt.Errorf(`"%v" has unexpectedly encountered a value of type "%T" from embedded type`, ti.String(), v)
+		buf := make([]byte, types.EWKBHeaderSize + types.LengthSize + types.PointDataSize * len(val.Points))
+		types.WriteEWKBHeader(val, buf[:types.EWKBHeaderSize])
+		types.WriteEWKBLineData(val, buf[types.EWKBHeaderSize:])
+		resStr := string(buf)
+		return &resStr, nil
 	}
 	if _, ok := v.(types.Null); ok || v == nil {
 		return nil, nil
@@ -136,11 +133,7 @@ func (ti *linestringType) GetTypeParams() map[string]string {
 
 // IsValid implements TypeInfo interface.
 func (ti *linestringType) IsValid(v types.Value) bool {
-	if val, ok := v.(types.Linestring); ok {
-		_, err := ti.sqlLinestringType.Convert(val)
-		if err != nil {
-			return false
-		}
+	if _, ok := v.(types.Linestring); ok {
 		return true
 	}
 	if _, ok := v.(types.Null); ok || v == nil {
@@ -159,7 +152,12 @@ func (ti *linestringType) ParseValue(ctx context.Context, vrw types.ValueReadWri
 	if str == nil || *str == "" {
 		return types.NullValue, nil
 	}
-	return ti.ConvertValueToNomsValue(context.Background(), nil, *str)
+	buf := []byte(*str)
+	srid, _ , geomType := types.ParseEWKBHeader(buf)
+	if geomType != types.LinestringID {
+		return types.NullValue, nil
+	}
+	return types.ParseEWKBLine(buf[types.EWKBHeaderSize:], srid), nil
 }
 
 // Promote implements TypeInfo interface.
diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index d0fabe33d2..80e86f241d 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -102,14 +102,11 @@ func (ti *pointType) Equals(other TypeInfo) bool {
 // FormatValue implements TypeInfo interface.
 func (ti *pointType) FormatValue(v types.Value) (*string, error) {
 	if val, ok := v.(types.Point); ok {
-		res, err := ti.ConvertNomsValueToValue(val)
-		if err != nil {
-			return nil, err
-		}
-		if resStr, ok := res.(string); ok {
-			return &resStr, nil
-		}
-		return nil, fmt.Errorf(`"%v" has unexpectedly encountered a value of type "%T" from embedded type`, ti.String(), v)
+		buf := make([]byte, types.EWKBHeaderSize + types.PointDataSize)
+		types.WriteEWKBHeader(val, buf[:types.EWKBHeaderSize])
+		types.WriteEWKBPointData(val, buf[types.EWKBHeaderSize:])
+		resStr := string(buf)
+		return &resStr, nil
 	}
 	if _, ok := v.(types.Null); ok || v == nil {
 		return nil, nil
@@ -130,11 +127,7 @@ func (ti *pointType) GetTypeParams() map[string]string {
 
 // IsValid implements TypeInfo interface.
 func (ti *pointType) IsValid(v types.Value) bool {
-	if val, ok := v.(types.Point); ok {
-		_, err := ti.sqlPointType.Convert(val)
-		if err != nil {
-			return false
-		}
+	if _, ok := v.(types.Point); ok {
 		return true
 	}
 	if _, ok := v.(types.Null); ok || v == nil {
@@ -153,7 +146,12 @@ func (ti *pointType) ParseValue(ctx context.Context, vrw types.ValueReadWriter,
 	if str == nil || *str == "" {
 		return types.NullValue, nil
 	}
-	return ti.ConvertValueToNomsValue(context.Background(), nil, *str)
+	buf := []byte(*str)
+	srid, _ , geomType := types.ParseEWKBHeader(buf)
+	if geomType != types.PointID {
+		return types.NullValue, nil
+	}
+	return types.ParseEWKBPoint(buf[types.EWKBHeaderSize:], srid), nil
 }
 
 // Promote implements TypeInfo interface.
diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
index 1c92d58267..31e5fae374 100644
--- a/go/libraries/doltcore/schema/typeinfo/polygon.go
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -107,15 +107,16 @@ func (ti *polygonType) Equals(other TypeInfo) bool {
 
 // FormatValue implements TypeInfo interface.
 func (ti *polygonType) FormatValue(v types.Value) (*string, error) {
-	if val, ok := v.(types.Linestring); ok {
-		res, err := ti.ConvertNomsValueToValue(val)
-		if err != nil {
-			return nil, err
+	if val, ok := v.(types.Polygon); ok {
+		size := types.EWKBHeaderSize + types.LengthSize
+		for _, l := range val.Lines {
+			size += types.LengthSize + types.PointDataSize * len(l.Points)
 		}
-		if resStr, ok := res.(string); ok {
-			return &resStr, nil
-		}
-		return nil, fmt.Errorf(`"%v" has unexpectedly encountered a value of type "%T" from embedded type`, ti.String(), v)
+		buf := make([]byte, size)
+		types.WriteEWKBHeader(val, buf[:types.EWKBHeaderSize])
+		types.WriteEWKBPolyData(val, buf[types.EWKBHeaderSize:])
+		resStr := string(buf)
+		return &resStr, nil
 	}
 	if _, ok := v.(types.Null); ok || v == nil {
 		return nil, nil
@@ -136,11 +137,7 @@ func (ti *polygonType) GetTypeParams() map[string]string {
 
 // IsValid implements TypeInfo interface.
 func (ti *polygonType) IsValid(v types.Value) bool {
-	if val, ok := v.(types.Linestring); ok {
-		_, err := ti.sqlPolygonType.Convert(val)
-		if err != nil {
-			return false
-		}
+	if _, ok := v.(types.Polygon); ok {
 		return true
 	}
 	if _, ok := v.(types.Null); ok || v == nil {
@@ -159,7 +156,12 @@ func (ti *polygonType) ParseValue(ctx context.Context, vrw types.ValueReadWriter
 	if str == nil || *str == "" {
 		return types.NullValue, nil
 	}
-	return ti.ConvertValueToNomsValue(context.Background(), nil, *str)
+	buf := []byte(*str)
+	srid, _ , geomType := types.ParseEWKBHeader(buf)
+	if geomType != types.PolygonID {
+		return types.NullValue, nil
+	}
+	return types.ParseEWKBPoly(buf[types.EWKBHeaderSize:], srid), nil
 }
 
 // Promote implements TypeInfo interface.
diff --git a/go/libraries/doltcore/schema/typeinfo/typeinfo.go b/go/libraries/doltcore/schema/typeinfo/typeinfo.go
index 32be35c319..bfc18bae00 100644
--- a/go/libraries/doltcore/schema/typeinfo/typeinfo.go
+++ b/go/libraries/doltcore/schema/typeinfo/typeinfo.go
@@ -28,7 +28,7 @@ import (
 
 const spatialTypesFeatureFlagKey = "DOLT_ENABLE_SPATIAL_TYPES"
 
-var spatialTypesFeatureFlag = false
+var spatialTypesFeatureFlag = true // TODO: should be false, but this lets the test pass :)
 
 func init() {
 	// set the spatial types feature flag to true if the env var is set
diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
index a8059b8ad0..11a0dd8c61 100644
--- a/go/store/types/linestring.go
+++ b/go/store/types/linestring.go
@@ -135,13 +135,13 @@ func (v Linestring) valueReadWriter() ValueReadWriter {
 	return nil
 }
 
-// writeEWKBLineData converts a Line into a byte array in EWKB format
-func writeEWKBLineData(l Linestring, buf []byte) {
+// WriteEWKBLineData converts a Line into a byte array in EWKB format
+func WriteEWKBLineData(l Linestring, buf []byte) {
 	// Write length of linestring
 	binary.LittleEndian.PutUint32(buf[:LengthSize], uint32(len(l.Points)))
 	// Append each point
 	for i, p := range l.Points {
-		writeEWKBPointData(p, buf[LengthSize+PointDataSize*i:LengthSize+PointDataSize*(i+1)])
+		WriteEWKBPointData(p, buf[LengthSize+PointDataSize*i:LengthSize+PointDataSize*(i+1)])
 	}
 }
 
@@ -155,23 +155,23 @@ func (v Linestring) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	buf := make([]byte, EWKBHeaderSize+LengthSize+PointDataSize*len(v.Points))
 
 	// Write header and data to buffer
-	writeEWKBHeader(v, buf)
-	writeEWKBLineData(v, buf[EWKBHeaderSize:])
+	WriteEWKBHeader(v, buf)
+	WriteEWKBLineData(v, buf[EWKBHeaderSize:])
 
 	w.writeString(string(buf))
 	return nil
 }
 
-// parseEWKBLine converts the data portion of a WKB point to Linestring
+// ParseEWKBLine converts the data portion of a WKB point to Linestring
 // Very similar logic to the function in GMS
-func parseEWKBLine(buf []byte, srid uint32) Linestring {
+func ParseEWKBLine(buf []byte, srid uint32) Linestring {
 	// Read length of linestring
 	numPoints := binary.LittleEndian.Uint32(buf[:4])
 
 	// Parse points
 	points := make([]Point, numPoints)
 	for i := uint32(0); i < numPoints; i++ {
-		points[i] = parseEWKBPoint(buf[LengthSize+PointDataSize*i:LengthSize+PointDataSize*(i+1)], srid)
+		points[i] = ParseEWKBPoint(buf[LengthSize+PointDataSize*i:LengthSize+PointDataSize*(i+1)], srid)
 	}
 
 	return Linestring{SRID: srid, Points: points}
@@ -179,20 +179,20 @@ func parseEWKBLine(buf []byte, srid uint32) Linestring {
 
 func readLinestring(nbf *NomsBinFormat, b *valueDecoder) (Linestring, error) {
 	buf := []byte(b.ReadString())
-	srid, _, geomType := parseEWKBHeader(buf)
+	srid, _, geomType := ParseEWKBHeader(buf)
 	if geomType != LinestringID {
 		return Linestring{}, errors.New("not a linestring")
 	}
-	return parseEWKBLine(buf[EWKBHeaderSize:], srid), nil
+	return ParseEWKBLine(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Linestring) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
 	buf := []byte(b.ReadString())
-	srid, _, geomType := parseEWKBHeader(buf)
+	srid, _, geomType := ParseEWKBHeader(buf)
 	if geomType != LinestringID {
 		return nil, errors.New("not a linestring")
 	}
-	return parseEWKBLine(buf[EWKBHeaderSize:], srid), nil
+	return ParseEWKBLine(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Linestring) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
diff --git a/go/store/types/point.go b/go/store/types/point.go
index fb9d008014..28edb80faf 100644
--- a/go/store/types/point.go
+++ b/go/store/types/point.go
@@ -97,9 +97,9 @@ func (v Point) valueReadWriter() ValueReadWriter {
 	return nil
 }
 
-// writeEWKBHeader writes the SRID, endianness, and type to the byte buffer
+// WriteEWKBHeader writes the SRID, endianness, and type to the byte buffer
 // This function assumes v is a valid spatial type
-func writeEWKBHeader(v interface{}, buf []byte) {
+func WriteEWKBHeader(v interface{}, buf []byte) {
 	// Write endianness byte (always little endian)
 	buf[SRIDSize] = 1
 
@@ -118,9 +118,9 @@ func writeEWKBHeader(v interface{}, buf []byte) {
 	}
 }
 
-// writeEWKBPointData converts a Point into a byte array in EWKB format
+// WriteEWKBPointData converts a Point into a byte array in EWKB format
 // Very similar to function in GMS
-func writeEWKBPointData(p Point, buf []byte) {
+func WriteEWKBPointData(p Point, buf []byte) {
 	binary.LittleEndian.PutUint64(buf[:PointDataSize/2], math.Float64bits(p.X))
 	binary.LittleEndian.PutUint64(buf[PointDataSize/2:], math.Float64bits(p.Y))
 }
@@ -136,24 +136,24 @@ func (v Point) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	buf := make([]byte, EWKBHeaderSize+PointDataSize)
 
 	// Write header and data to buffer
-	writeEWKBHeader(v, buf)
-	writeEWKBPointData(v, buf[EWKBHeaderSize:])
+	WriteEWKBHeader(v, buf)
+	WriteEWKBPointData(v, buf[EWKBHeaderSize:])
 
 	w.writeString(string(buf))
 	return nil
 }
 
-// parseEWKBHeader converts the header potion of a EWKB byte array to srid, endianness, and geometry type
-func parseEWKBHeader(buf []byte) (uint32, bool, uint32) {
+// ParseEWKBHeader converts the header potion of a EWKB byte array to srid, endianness, and geometry type
+func ParseEWKBHeader(buf []byte) (uint32, bool, uint32) {
 	srid := binary.LittleEndian.Uint32(buf[0:SRIDSize])                               // First 4 bytes is SRID always in little endian
 	isBig := buf[SRIDSize] == 0                                                       // Next byte is endianness
 	geomType := binary.LittleEndian.Uint32(buf[SRIDSize+EndianSize : EWKBHeaderSize]) // Next 4 bytes is type
 	return srid, isBig, geomType
 }
 
-// parseEWKBPoint converts the data portion of a WKB point to Point
+// ParseEWKBPoint converts the data portion of a WKB point to Point
 // Very similar logic to the function in GMS
-func parseEWKBPoint(buf []byte, srid uint32) Point {
+func ParseEWKBPoint(buf []byte, srid uint32) Point {
 	// Read floats x and y
 	x := math.Float64frombits(binary.LittleEndian.Uint64(buf[:PointDataSize/2]))
 	y := math.Float64frombits(binary.LittleEndian.Uint64(buf[PointDataSize/2:]))
@@ -162,20 +162,20 @@ func parseEWKBPoint(buf []byte, srid uint32) Point {
 
 func readPoint(nbf *NomsBinFormat, b *valueDecoder) (Point, error) {
 	buf := []byte(b.ReadString())
-	srid, _, geomType := parseEWKBHeader(buf) // Assume it's always little endian
+	srid, _, geomType := ParseEWKBHeader(buf) // Assume it's always little endian
 	if geomType != PointID {
 		return Point{}, errors.New("not a point")
 	}
-	return parseEWKBPoint(buf[EWKBHeaderSize:], srid), nil
+	return ParseEWKBPoint(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Point) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
 	buf := []byte(b.ReadString())
-	srid, _, geomType := parseEWKBHeader(buf) // Assume it's always little endian
+	srid, _, geomType := ParseEWKBHeader(buf) // Assume it's always little endian
 	if geomType != PointID {
 		return Point{}, errors.New("not a point")
 	}
-	return parseEWKBPoint(buf[EWKBHeaderSize:], srid), nil
+	return ParseEWKBPoint(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Point) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
diff --git a/go/store/types/polygon.go b/go/store/types/polygon.go
index 598a934938..c00f5c062f 100644
--- a/go/store/types/polygon.go
+++ b/go/store/types/polygon.go
@@ -63,7 +63,7 @@ func (v Polygon) Equals(other Value) bool {
 			return false
 		}
 	}
-	return false
+	return true
 }
 
 func (v Polygon) Less(nbf *NomsBinFormat, other LesserValuable) (bool, error) {
@@ -128,15 +128,15 @@ func (v Polygon) valueReadWriter() ValueReadWriter {
 	return nil
 }
 
-// writeEWKBPolyData converts a Polygon into a byte array in EWKB format
-func writeEWKBPolyData(p Polygon, buf []byte) {
+// WriteEWKBPolyData converts a Polygon into a byte array in EWKB format
+func WriteEWKBPolyData(p Polygon, buf []byte) {
 	// Write length of polygon
 	binary.LittleEndian.PutUint32(buf[:LengthSize], uint32(len(p.Lines)))
 	// Write each line
 	start, stop := 0, LengthSize
 	for _, l := range p.Lines {
 		start, stop = stop, stop+LengthSize+PointDataSize*len(l.Points)
-		writeEWKBLineData(l, buf[start:stop])
+		WriteEWKBLineData(l, buf[start:stop])
 	}
 }
 
@@ -156,16 +156,16 @@ func (v Polygon) writeTo(w nomsWriter, nbf *NomsBinFormat) error {
 	buf := make([]byte, EWKBHeaderSize+LengthSize+size)
 
 	// Write header and data to buffer
-	writeEWKBHeader(v, buf)
-	writeEWKBPolyData(v, buf[EWKBHeaderSize:])
+	WriteEWKBHeader(v, buf)
+	WriteEWKBPolyData(v, buf[EWKBHeaderSize:])
 
 	w.writeString(string(buf))
 	return nil
 }
 
-// parseEWKBPoly converts the data portions of a WKB polygon to Polygon
+// ParseEWKBPoly converts the data portions of a WKB polygon to Polygon
 // Very similar logic to the function in GMS
-func parseEWKBPoly(buf []byte, srid uint32) Polygon {
+func ParseEWKBPoly(buf []byte, srid uint32) Polygon {
 	// Read length of Polygon
 	numLines := binary.LittleEndian.Uint32(buf[:LengthSize])
 
@@ -173,7 +173,7 @@ func parseEWKBPoly(buf []byte, srid uint32) Polygon {
 	s := LengthSize
 	lines := make([]Linestring, numLines)
 	for i := uint32(0); i < numLines; i++ {
-		lines[i] = parseEWKBLine(buf[s:], srid)
+		lines[i] = ParseEWKBLine(buf[s:], srid)
 		s += LengthSize * PointDataSize * len(lines[i].Points)
 	}
 
@@ -182,20 +182,20 @@ func parseEWKBPoly(buf []byte, srid uint32) Polygon {
 
 func readPolygon(nbf *NomsBinFormat, b *valueDecoder) (Polygon, error) {
 	buf := []byte(b.ReadString())
-	srid, _, geomType := parseEWKBHeader(buf)
+	srid, _, geomType := ParseEWKBHeader(buf)
 	if geomType != PolygonID {
 		return Polygon{}, errors.New("not a polygon")
 	}
-	return parseEWKBPoly(buf[EWKBHeaderSize:], srid), nil
+	return ParseEWKBPoly(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Polygon) readFrom(nbf *NomsBinFormat, b *binaryNomsReader) (Value, error) {
 	buf := []byte(b.ReadString())
-	srid, _, geomType := parseEWKBHeader(buf)
+	srid, _, geomType := ParseEWKBHeader(buf)
 	if geomType != PolygonID {
 		return nil, errors.New("not a polygon")
 	}
-	return parseEWKBPoly(buf[EWKBHeaderSize:], srid), nil
+	return ParseEWKBPoly(buf[EWKBHeaderSize:], srid), nil
 }
 
 func (v Polygon) skip(nbf *NomsBinFormat, b *binaryNomsReader) {
diff --git a/go/store/types/value_decoder.go b/go/store/types/value_decoder.go
index f03f0bfeb4..9da6e17e93 100644
--- a/go/store/types/value_decoder.go
+++ b/go/store/types/value_decoder.go
@@ -84,15 +84,15 @@ func (r *valueDecoder) ReadBlob() (Blob, error) {
 }
 
 func (r *valueDecoder) ReadPoint() (Point, error) {
-	return readPoint(r.vrw.Format(), r)
+	return readPoint(nil, r)
 }
 
 func (r *valueDecoder) ReadLinestring() (Linestring, error) {
-	return readLinestring(r.vrw.Format(), r)
+	return readLinestring(nil, r)
 }
 
 func (r *valueDecoder) ReadPolygon() (Polygon, error) {
-	return readPolygon(r.vrw.Format(), r)
+	return readPolygon(nil, r)
 }
 
 func (r *valueDecoder) ReadJSON() (JSON, error) {
@@ -374,27 +374,27 @@ func (r *valueDecoder) readValue(nbf *NomsBinFormat) (Value, error) {
 	case PointKind:
 		r.skipKind()
 		buf := []byte(r.ReadString())
-		srid, _, geomType := parseEWKBHeader(buf)
+		srid, _, geomType := ParseEWKBHeader(buf)
 		if geomType != PointID {
 			return nil, ErrUnknownType
 		}
-		return parseEWKBPoint(buf[EWKBHeaderSize:], srid), nil
+		return ParseEWKBPoint(buf[EWKBHeaderSize:], srid), nil
 	case LinestringKind:
 		r.skipKind()
 		buf := []byte(r.ReadString())
-		srid, _, geomType := parseEWKBHeader(buf)
+		srid, _, geomType := ParseEWKBHeader(buf)
 		if geomType != LinestringID {
 			return nil, ErrUnknownType
 		}
-		return parseEWKBLine(buf[EWKBHeaderSize:], srid), nil
+		return ParseEWKBLine(buf[EWKBHeaderSize:], srid), nil
 	case PolygonKind:
 		r.skipKind()
 		buf := []byte(r.ReadString())
-		srid, _, geomType := parseEWKBHeader(buf)
+		srid, _, geomType := ParseEWKBHeader(buf)
 		if geomType != PolygonID {
 			return nil, ErrUnknownType
 		}
-		return parseEWKBPoly(buf[EWKBHeaderSize:], srid), nil
+		return ParseEWKBPoly(buf[EWKBHeaderSize:], srid), nil
 	case TypeKind:
 		r.skipKind()
 		return r.readType()

From 68ffc8d9b535a63fd6dbd7c6e9254b94272907a4 Mon Sep 17 00:00:00 2001
From: JCOR11599 <JCOR11599@users.noreply.github.com>
Date: Fri, 21 Jan 2022 02:25:23 +0000
Subject: [PATCH 43/51] [ga-format-pr] Run go/utils/repofmt/format_repo.sh and
 go/Godeps/update.sh

---
 go/libraries/doltcore/schema/typeinfo/linestring.go | 4 ++--
 go/libraries/doltcore/schema/typeinfo/point.go      | 4 ++--
 go/libraries/doltcore/schema/typeinfo/polygon.go    | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
index 3794184417..1e21a2a79c 100644
--- a/go/libraries/doltcore/schema/typeinfo/linestring.go
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -108,7 +108,7 @@ func (ti *linestringType) Equals(other TypeInfo) bool {
 // FormatValue implements TypeInfo interface.
 func (ti *linestringType) FormatValue(v types.Value) (*string, error) {
 	if val, ok := v.(types.Linestring); ok {
-		buf := make([]byte, types.EWKBHeaderSize + types.LengthSize + types.PointDataSize * len(val.Points))
+		buf := make([]byte, types.EWKBHeaderSize+types.LengthSize+types.PointDataSize*len(val.Points))
 		types.WriteEWKBHeader(val, buf[:types.EWKBHeaderSize])
 		types.WriteEWKBLineData(val, buf[types.EWKBHeaderSize:])
 		resStr := string(buf)
@@ -153,7 +153,7 @@ func (ti *linestringType) ParseValue(ctx context.Context, vrw types.ValueReadWri
 		return types.NullValue, nil
 	}
 	buf := []byte(*str)
-	srid, _ , geomType := types.ParseEWKBHeader(buf)
+	srid, _, geomType := types.ParseEWKBHeader(buf)
 	if geomType != types.LinestringID {
 		return types.NullValue, nil
 	}
diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index 80e86f241d..61e1d36159 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -102,7 +102,7 @@ func (ti *pointType) Equals(other TypeInfo) bool {
 // FormatValue implements TypeInfo interface.
 func (ti *pointType) FormatValue(v types.Value) (*string, error) {
 	if val, ok := v.(types.Point); ok {
-		buf := make([]byte, types.EWKBHeaderSize + types.PointDataSize)
+		buf := make([]byte, types.EWKBHeaderSize+types.PointDataSize)
 		types.WriteEWKBHeader(val, buf[:types.EWKBHeaderSize])
 		types.WriteEWKBPointData(val, buf[types.EWKBHeaderSize:])
 		resStr := string(buf)
@@ -147,7 +147,7 @@ func (ti *pointType) ParseValue(ctx context.Context, vrw types.ValueReadWriter,
 		return types.NullValue, nil
 	}
 	buf := []byte(*str)
-	srid, _ , geomType := types.ParseEWKBHeader(buf)
+	srid, _, geomType := types.ParseEWKBHeader(buf)
 	if geomType != types.PointID {
 		return types.NullValue, nil
 	}
diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
index 31e5fae374..c4695a5876 100644
--- a/go/libraries/doltcore/schema/typeinfo/polygon.go
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -110,7 +110,7 @@ func (ti *polygonType) FormatValue(v types.Value) (*string, error) {
 	if val, ok := v.(types.Polygon); ok {
 		size := types.EWKBHeaderSize + types.LengthSize
 		for _, l := range val.Lines {
-			size += types.LengthSize + types.PointDataSize * len(l.Points)
+			size += types.LengthSize + types.PointDataSize*len(l.Points)
 		}
 		buf := make([]byte, size)
 		types.WriteEWKBHeader(val, buf[:types.EWKBHeaderSize])
@@ -157,7 +157,7 @@ func (ti *polygonType) ParseValue(ctx context.Context, vrw types.ValueReadWriter
 		return types.NullValue, nil
 	}
 	buf := []byte(*str)
-	srid, _ , geomType := types.ParseEWKBHeader(buf)
+	srid, _, geomType := types.ParseEWKBHeader(buf)
 	if geomType != types.PolygonID {
 		return types.NullValue, nil
 	}

From d5141adcb0e3eea74dffd5c3828e8c7313def850 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Thu, 20 Jan 2022 18:32:50 -0800
Subject: [PATCH 44/51] adding point, linestring, and polygon conversions to
 all other types

---
 go/libraries/doltcore/schema/typeinfo/bit.go        | 6 ++++++
 go/libraries/doltcore/schema/typeinfo/blobstring.go | 6 ++++++
 go/libraries/doltcore/schema/typeinfo/bool.go       | 6 ++++++
 go/libraries/doltcore/schema/typeinfo/datetime.go   | 6 ++++++
 go/libraries/doltcore/schema/typeinfo/decimal.go    | 6 ++++++
 go/libraries/doltcore/schema/typeinfo/enum.go       | 6 ++++++
 go/libraries/doltcore/schema/typeinfo/float.go      | 6 ++++++
 go/libraries/doltcore/schema/typeinfo/inlineblob.go | 6 ++++++
 go/libraries/doltcore/schema/typeinfo/int.go        | 6 ++++++
 go/libraries/doltcore/schema/typeinfo/json.go       | 6 ++++++
 go/libraries/doltcore/schema/typeinfo/set.go        | 6 ++++++
 go/libraries/doltcore/schema/typeinfo/time.go       | 6 ++++++
 go/libraries/doltcore/schema/typeinfo/uint.go       | 6 ++++++
 go/libraries/doltcore/schema/typeinfo/uuid.go       | 6 ++++++
 go/libraries/doltcore/schema/typeinfo/varbinary.go  | 6 ++++++
 go/libraries/doltcore/schema/typeinfo/varstring.go  | 6 ++++++
 go/libraries/doltcore/schema/typeinfo/year.go       | 6 ++++++
 17 files changed, 102 insertions(+)

diff --git a/go/libraries/doltcore/schema/typeinfo/bit.go b/go/libraries/doltcore/schema/typeinfo/bit.go
index 5b615124be..8c5b2383fa 100644
--- a/go/libraries/doltcore/schema/typeinfo/bit.go
+++ b/go/libraries/doltcore/schema/typeinfo/bit.go
@@ -238,6 +238,12 @@ func bitTypeConverter(ctx context.Context, src *bitType, destTi TypeInfo) (tc Ty
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *jsonType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
 		return wrapIsValid(dest.IsValid, src, dest)
 	case *timeType:
diff --git a/go/libraries/doltcore/schema/typeinfo/blobstring.go b/go/libraries/doltcore/schema/typeinfo/blobstring.go
index e83fa5c8a1..def31abeb1 100644
--- a/go/libraries/doltcore/schema/typeinfo/blobstring.go
+++ b/go/libraries/doltcore/schema/typeinfo/blobstring.go
@@ -222,6 +222,12 @@ func blobStringTypeConverter(ctx context.Context, src *blobStringType, destTi Ty
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *jsonType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *timeType:
diff --git a/go/libraries/doltcore/schema/typeinfo/bool.go b/go/libraries/doltcore/schema/typeinfo/bool.go
index 558d23cdee..a72a5cfc7c 100644
--- a/go/libraries/doltcore/schema/typeinfo/bool.go
+++ b/go/libraries/doltcore/schema/typeinfo/bool.go
@@ -215,6 +215,12 @@ func boolTypeConverter(ctx context.Context, src *boolType, destTi TypeInfo) (tc
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *jsonType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *intType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
diff --git a/go/libraries/doltcore/schema/typeinfo/datetime.go b/go/libraries/doltcore/schema/typeinfo/datetime.go
index 6edb463230..1353442afb 100644
--- a/go/libraries/doltcore/schema/typeinfo/datetime.go
+++ b/go/libraries/doltcore/schema/typeinfo/datetime.go
@@ -240,6 +240,12 @@ func datetimeTypeConverter(ctx context.Context, src *datetimeType, destTi TypeIn
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *jsonType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *timeType:
diff --git a/go/libraries/doltcore/schema/typeinfo/decimal.go b/go/libraries/doltcore/schema/typeinfo/decimal.go
index 022794ad29..6348564909 100644
--- a/go/libraries/doltcore/schema/typeinfo/decimal.go
+++ b/go/libraries/doltcore/schema/typeinfo/decimal.go
@@ -267,6 +267,12 @@ func decimalTypeConverter(ctx context.Context, src *decimalType, destTi TypeInfo
 		}, true, nil
 	case *jsonType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
 		return func(ctx context.Context, vrw types.ValueReadWriter, v types.Value) (types.Value, error) {
 			s, err := src.ConvertNomsValueToValue(v)
diff --git a/go/libraries/doltcore/schema/typeinfo/enum.go b/go/libraries/doltcore/schema/typeinfo/enum.go
index c317874a58..ff5a0fce66 100644
--- a/go/libraries/doltcore/schema/typeinfo/enum.go
+++ b/go/libraries/doltcore/schema/typeinfo/enum.go
@@ -259,6 +259,12 @@ func enumTypeConverter(ctx context.Context, src *enumType, destTi TypeInfo) (tc
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *jsonType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *timeType:
diff --git a/go/libraries/doltcore/schema/typeinfo/float.go b/go/libraries/doltcore/schema/typeinfo/float.go
index 760eae9966..9b5d7b7722 100644
--- a/go/libraries/doltcore/schema/typeinfo/float.go
+++ b/go/libraries/doltcore/schema/typeinfo/float.go
@@ -263,6 +263,12 @@ func floatTypeConverter(ctx context.Context, src *floatType, destTi TypeInfo) (t
 		return floatTypeConverterRoundToZero(ctx, src, destTi)
 	case *jsonType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
 		return func(ctx context.Context, vrw types.ValueReadWriter, v types.Value) (types.Value, error) {
 			if v == nil || v == types.NullValue {
diff --git a/go/libraries/doltcore/schema/typeinfo/inlineblob.go b/go/libraries/doltcore/schema/typeinfo/inlineblob.go
index 87ca3a1466..3595ae12f2 100644
--- a/go/libraries/doltcore/schema/typeinfo/inlineblob.go
+++ b/go/libraries/doltcore/schema/typeinfo/inlineblob.go
@@ -240,6 +240,12 @@ func inlineBlobTypeConverter(ctx context.Context, src *inlineBlobType, destTi Ty
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *jsonType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *timeType:
diff --git a/go/libraries/doltcore/schema/typeinfo/int.go b/go/libraries/doltcore/schema/typeinfo/int.go
index 2783b57250..c970b93449 100644
--- a/go/libraries/doltcore/schema/typeinfo/int.go
+++ b/go/libraries/doltcore/schema/typeinfo/int.go
@@ -291,6 +291,12 @@ func intTypeConverter(ctx context.Context, src *intType, destTi TypeInfo) (tc Ty
 		return wrapIsValid(dest.IsValid, src, dest)
 	case *jsonType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *timeType:
diff --git a/go/libraries/doltcore/schema/typeinfo/json.go b/go/libraries/doltcore/schema/typeinfo/json.go
index 248c044321..f04c6decdb 100644
--- a/go/libraries/doltcore/schema/typeinfo/json.go
+++ b/go/libraries/doltcore/schema/typeinfo/json.go
@@ -181,6 +181,12 @@ func jsonTypeConverter(ctx context.Context, src *jsonType, destTi TypeInfo) (tc
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *jsonType:
 		return wrapIsValid(dest.IsValid, src, dest)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *timeType:
diff --git a/go/libraries/doltcore/schema/typeinfo/set.go b/go/libraries/doltcore/schema/typeinfo/set.go
index c6248f5b98..c0acb406c9 100644
--- a/go/libraries/doltcore/schema/typeinfo/set.go
+++ b/go/libraries/doltcore/schema/typeinfo/set.go
@@ -235,6 +235,12 @@ func setTypeConverter(ctx context.Context, src *setType, destTi TypeInfo) (tc Ty
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *jsonType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
 		return wrapIsValid(dest.IsValid, src, dest)
 	case *timeType:
diff --git a/go/libraries/doltcore/schema/typeinfo/time.go b/go/libraries/doltcore/schema/typeinfo/time.go
index 3758d49066..c3ddeabd3a 100644
--- a/go/libraries/doltcore/schema/typeinfo/time.go
+++ b/go/libraries/doltcore/schema/typeinfo/time.go
@@ -171,6 +171,12 @@ func timeTypeConverter(ctx context.Context, src *timeType, destTi TypeInfo) (tc
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *jsonType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *timeType:
diff --git a/go/libraries/doltcore/schema/typeinfo/uint.go b/go/libraries/doltcore/schema/typeinfo/uint.go
index d2497121bb..13a2937efd 100644
--- a/go/libraries/doltcore/schema/typeinfo/uint.go
+++ b/go/libraries/doltcore/schema/typeinfo/uint.go
@@ -291,6 +291,12 @@ func uintTypeConverter(ctx context.Context, src *uintType, destTi TypeInfo) (tc
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *jsonType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *timeType:
diff --git a/go/libraries/doltcore/schema/typeinfo/uuid.go b/go/libraries/doltcore/schema/typeinfo/uuid.go
index 64e2e19290..2c92959be2 100644
--- a/go/libraries/doltcore/schema/typeinfo/uuid.go
+++ b/go/libraries/doltcore/schema/typeinfo/uuid.go
@@ -173,6 +173,12 @@ func uuidTypeConverter(ctx context.Context, src *uuidType, destTi TypeInfo) (tc
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *jsonType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *timeType:
diff --git a/go/libraries/doltcore/schema/typeinfo/varbinary.go b/go/libraries/doltcore/schema/typeinfo/varbinary.go
index e057331bee..7bd2f45189 100644
--- a/go/libraries/doltcore/schema/typeinfo/varbinary.go
+++ b/go/libraries/doltcore/schema/typeinfo/varbinary.go
@@ -262,6 +262,12 @@ func varBinaryTypeConverter(ctx context.Context, src *varBinaryType, destTi Type
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *jsonType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *timeType:
diff --git a/go/libraries/doltcore/schema/typeinfo/varstring.go b/go/libraries/doltcore/schema/typeinfo/varstring.go
index 9bd2d8b3f4..47d6b3f81c 100644
--- a/go/libraries/doltcore/schema/typeinfo/varstring.go
+++ b/go/libraries/doltcore/schema/typeinfo/varstring.go
@@ -276,6 +276,12 @@ func varStringTypeConverter(ctx context.Context, src *varStringType, destTi Type
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *jsonType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *timeType:
diff --git a/go/libraries/doltcore/schema/typeinfo/year.go b/go/libraries/doltcore/schema/typeinfo/year.go
index c5df18262d..f82a9c5828 100644
--- a/go/libraries/doltcore/schema/typeinfo/year.go
+++ b/go/libraries/doltcore/schema/typeinfo/year.go
@@ -187,6 +187,12 @@ func yearTypeConverter(ctx context.Context, src *yearType, destTi TypeInfo) (tc
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *jsonType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *linestringType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *pointType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+	case *polygonType:
+		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *setType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *timeType:

From dc9b0adb05aeccb8176d0bff67cd5b88fe3789d6 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Fri, 21 Jan 2022 11:40:16 -0800
Subject: [PATCH 45/51] adding point, linestring, and polygon to
 wrapConverValueToNomsValue

---
 go/libraries/doltcore/schema/typeinfo/typeconverter.go | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/go/libraries/doltcore/schema/typeinfo/typeconverter.go b/go/libraries/doltcore/schema/typeinfo/typeconverter.go
index 77642c1ac3..43d8eabf3f 100644
--- a/go/libraries/doltcore/schema/typeinfo/typeconverter.go
+++ b/go/libraries/doltcore/schema/typeinfo/typeconverter.go
@@ -129,6 +129,12 @@ func wrapConvertValueToNomsValue(
 			vInt = *(*string)(unsafe.Pointer(&val))
 		case types.Int:
 			vInt = int64(val)
+		case types.Linestring:
+			vInt = ConvertTypesLinestringToSQLLinestring(val)
+		case types.Point:
+			vInt = ConvertTypesPointToSQLPoint(val)
+		case types.Polygon:
+			vInt = ConvertTypesPolygonToSQLPolygon(val)
 		case types.String:
 			vInt = string(val)
 		case types.Timestamp:

From 0284fb5b88d3b8d4384ee3eef81270340617684e Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Fri, 21 Jan 2022 11:42:05 -0800
Subject: [PATCH 46/51] fixing copyright header hopefully

---
 go/store/types/linestring.go | 9 +--------
 go/store/types/point.go      | 9 +--------
 go/store/types/polygon.go    | 9 +--------
 3 files changed, 3 insertions(+), 24 deletions(-)

diff --git a/go/store/types/linestring.go b/go/store/types/linestring.go
index 11a0dd8c61..a0957a0e5d 100644
--- a/go/store/types/linestring.go
+++ b/go/store/types/linestring.go
@@ -1,4 +1,4 @@
-// Copyright 2019 Dolthub, Inc.
+// Copyright 2021 Dolthub, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,13 +11,6 @@
 // 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.
-//
-// This file incorporates work covered by the following copyright and
-// permission notice:
-//
-// Copyright 2016 Attic Labs, Inc. All rights reserved.
-// Licensed under the Apache License, version 2.0:
-// http://www.apache.org/licenses/LICENSE-2.0
 
 package types
 
diff --git a/go/store/types/point.go b/go/store/types/point.go
index 28edb80faf..bf27a7d51e 100644
--- a/go/store/types/point.go
+++ b/go/store/types/point.go
@@ -1,4 +1,4 @@
-// Copyright 2019 Dolthub, Inc.
+// Copyright 2021 Dolthub, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,13 +11,6 @@
 // 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.
-//
-// This file incorporates work covered by the following copyright and
-// permission notice:
-//
-// Copyright 2016 Attic Labs, Inc. All rights reserved.
-// Licensed under the Apache License, version 2.0:
-// http://www.apache.org/licenses/LICENSE-2.0
 
 package types
 
diff --git a/go/store/types/polygon.go b/go/store/types/polygon.go
index c00f5c062f..4baf4db7bc 100644
--- a/go/store/types/polygon.go
+++ b/go/store/types/polygon.go
@@ -1,4 +1,4 @@
-// Copyright 2019 Dolthub, Inc.
+// Copyright 2021 Dolthub, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,13 +11,6 @@
 // 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.
-//
-// This file incorporates work covered by the following copyright and
-// permission notice:
-//
-// Copyright 2016 Attic Labs, Inc. All rights reserved.
-// Licensed under the Apache License, version 2.0:
-// http://www.apache.org/licenses/LICENSE-2.0
 
 package types
 

From dce9480010e980687691ccf61b2b0630c5e5ed39 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Fri, 21 Jan 2022 14:01:53 -0800
Subject: [PATCH 47/51] spatial flag disables/enables correctly

---
 .../doltcore/schema/typeinfo/typeinfo.go      | 21 ++++++++++++++++--
 .../doltcore/schema/typeinfo/typeinfo_test.go | 22 ++++++++++++++-----
 2 files changed, 36 insertions(+), 7 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/typeinfo.go b/go/libraries/doltcore/schema/typeinfo/typeinfo.go
index bfc18bae00..22795fb7e9 100644
--- a/go/libraries/doltcore/schema/typeinfo/typeinfo.go
+++ b/go/libraries/doltcore/schema/typeinfo/typeinfo.go
@@ -19,6 +19,7 @@ import (
 	"fmt"
 	"math"
 	"os"
+	"sync"
 
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/vitess/go/sqltypes"
@@ -28,7 +29,8 @@ import (
 
 const spatialTypesFeatureFlagKey = "DOLT_ENABLE_SPATIAL_TYPES"
 
-var spatialTypesFeatureFlag = true // TODO: should be false, but this lets the test pass :)
+// use SpatialTypesEnabled() to check, don't access directly
+var spatialTypesFeatureFlag = false
 
 func init() {
 	// set the spatial types feature flag to true if the env var is set
@@ -37,6 +39,21 @@ func init() {
 	}
 }
 
+var spatialTypesLock = &sync.RWMutex{}
+
+func SpatialTypesEnabled() bool {
+	return spatialTypesFeatureFlag
+}
+
+func TestWithSpatialTypesEnabled(cb func()) {
+	spatialTypesLock.Lock()
+	defer spatialTypesLock.Unlock()
+
+	spatialTypesFeatureFlag = true
+	cb()
+	spatialTypesFeatureFlag = false
+}
+
 type Identifier string
 
 const (
@@ -261,7 +278,7 @@ func FromSqlType(sqlType sql.Type) (TypeInfo, error) {
 
 // FromTypeParams constructs a TypeInfo from the given identifier and parameters.
 func FromTypeParams(id Identifier, params map[string]string) (TypeInfo, error) {
-	if spatialTypesFeatureFlag {
+	if SpatialTypesEnabled() {
 		switch id {
 		case PointTypeIdentifier:
 			return PointType, nil
diff --git a/go/libraries/doltcore/schema/typeinfo/typeinfo_test.go b/go/libraries/doltcore/schema/typeinfo/typeinfo_test.go
index 7499d0789d..736d6ef8b0 100644
--- a/go/libraries/doltcore/schema/typeinfo/typeinfo_test.go
+++ b/go/libraries/doltcore/schema/typeinfo/typeinfo_test.go
@@ -253,11 +253,23 @@ func testTypeInfoGetTypeParams(t *testing.T, tiArrays [][]TypeInfo) {
 	for _, tiArray := range tiArrays {
 		t.Run(tiArray[0].GetTypeIdentifier().String(), func(t *testing.T) {
 			for _, ti := range tiArray {
-				t.Run(ti.String(), func(t *testing.T) {
-					newTi, err := FromTypeParams(ti.GetTypeIdentifier(), ti.GetTypeParams())
-					require.NoError(t, err)
-					require.True(t, ti.Equals(newTi), "%v\n%v", ti.String(), newTi.String())
-				})
+				if ti.GetTypeIdentifier() == PointTypeIdentifier ||
+					ti.GetTypeIdentifier() == LinestringTypeIdentifier ||
+					ti.GetTypeIdentifier() == PolygonTypeIdentifier {
+					t.Run(ti.String(), func(t *testing.T) {
+						TestWithSpatialTypesEnabled(func() {
+							newTi, err := FromTypeParams(ti.GetTypeIdentifier(), ti.GetTypeParams())
+							require.NoError(t, err)
+							require.True(t, ti.Equals(newTi), "%v\n%v", ti.String(), newTi.String())
+						})
+					})
+				} else {
+					t.Run(ti.String(), func(t *testing.T) {
+						newTi, err := FromTypeParams(ti.GetTypeIdentifier(), ti.GetTypeParams())
+						require.NoError(t, err)
+						require.True(t, ti.Equals(newTi), "%v\n%v", ti.String(), newTi.String())
+					})
+				}
 			}
 		})
 	}

From ea8971e8cb755655bc354080a3b3eb2d6f0203f5 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Mon, 24 Jan 2022 10:43:46 -0800
Subject: [PATCH 48/51] hope tests pass this time

---
 integration-tests/bats/sql-spatial-types.bats | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/integration-tests/bats/sql-spatial-types.bats b/integration-tests/bats/sql-spatial-types.bats
index 89e332d71f..bf2cfacad6 100644
--- a/integration-tests/bats/sql-spatial-types.bats
+++ b/integration-tests/bats/sql-spatial-types.bats
@@ -12,12 +12,13 @@ teardown() {
 
 @test "sql-spatial-types: can't make spatial types without enabling feature flag" {
     run dolt sql -q "create table point_tbl (p point)"
-    [[ "$output" =~ "cannot be made" ]] || false
     [ "$status" -eq 1 ]
+    [[ "$output" =~ "cannot be made" ]] || false
+
 }
 
 @test "sql-spatial-types: can make spatial types with flag" {
     DOLT_ENABLE_SPATIAL_TYPES=true run dolt sql -q "create table point_tbl (p point)"
-    [[ "$output" =~ "" ]] || false
     [ "$status" -eq 0 ]
+    [[ "$output" =~ "" ]] || false
 }
\ No newline at end of file

From 6615ad5831a7bae1828c3765592ba569e98ef56b Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Mon, 24 Jan 2022 11:09:01 -0800
Subject: [PATCH 49/51] adding conversion to 0 for bit

---
 go/libraries/doltcore/schema/typeinfo/linestring.go | 4 +++-
 go/libraries/doltcore/schema/typeinfo/point.go      | 4 +++-
 go/libraries/doltcore/schema/typeinfo/polygon.go    | 4 +++-
 3 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
index 1e21a2a79c..ee3f54275f 100644
--- a/go/libraries/doltcore/schema/typeinfo/linestring.go
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -179,7 +179,9 @@ func (ti *linestringType) ToSqlType() sql.Type {
 func linestringTypeConverter(ctx context.Context, src *linestringType, destTi TypeInfo) (tc TypeConverter, needsConversion bool, err error) {
 	switch dest := destTi.(type) {
 	case *bitType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+		return func(ctx context.Context, vrw types.ValueReadWriter, v types.Value) (types.Value, error) {
+			return types.Uint(0), nil
+		}, true, nil
 	case *blobStringType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *boolType:
diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index 61e1d36159..123e97b9ff 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -173,7 +173,9 @@ func (ti *pointType) ToSqlType() sql.Type {
 func pointTypeConverter(ctx context.Context, src *pointType, destTi TypeInfo) (tc TypeConverter, needsConversion bool, err error) {
 	switch dest := destTi.(type) {
 	case *bitType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+		return func(ctx context.Context, vrw types.ValueReadWriter, v types.Value) (types.Value, error) {
+			return types.Uint(0), nil
+		}, true, nil
 	case *blobStringType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *boolType:
diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
index c4695a5876..114e39144e 100644
--- a/go/libraries/doltcore/schema/typeinfo/polygon.go
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -183,7 +183,9 @@ func (ti *polygonType) ToSqlType() sql.Type {
 func polygonTypeConverter(ctx context.Context, src *polygonType, destTi TypeInfo) (tc TypeConverter, needsConversion bool, err error) {
 	switch dest := destTi.(type) {
 	case *bitType:
-		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
+		return func(ctx context.Context, vrw types.ValueReadWriter, v types.Value) (types.Value, error) {
+			return types.Uint(0), nil
+		}, true, nil
 	case *blobStringType:
 		return wrapConvertValueToNomsValue(dest.ConvertValueToNomsValue)
 	case *boolType:

From f7d14337f2d9e4c042327f9411c703f65a7a4e36 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Mon, 24 Jan 2022 12:12:35 -0800
Subject: [PATCH 50/51] fixing test

---
 integration-tests/bats/sql-spatial-types.bats | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/integration-tests/bats/sql-spatial-types.bats b/integration-tests/bats/sql-spatial-types.bats
index bf2cfacad6..49baf5e187 100644
--- a/integration-tests/bats/sql-spatial-types.bats
+++ b/integration-tests/bats/sql-spatial-types.bats
@@ -14,11 +14,10 @@ teardown() {
     run dolt sql -q "create table point_tbl (p point)"
     [ "$status" -eq 1 ]
     [[ "$output" =~ "cannot be made" ]] || false
-
 }
 
 @test "sql-spatial-types: can make spatial types with flag" {
     DOLT_ENABLE_SPATIAL_TYPES=true run dolt sql -q "create table point_tbl (p point)"
     [ "$status" -eq 0 ]
-    [[ "$output" =~ "" ]] || false
+    [[ "$output" = "" ]] || false
 }
\ No newline at end of file

From 0c4a6e2c90029b478c95b9b80b9868c7eb37f553 Mon Sep 17 00:00:00 2001
From: James Cor <james@dolthub.com>
Date: Mon, 24 Jan 2022 20:03:55 -0800
Subject: [PATCH 51/51] removing unnecessary parsevalue function

---
 go/libraries/doltcore/schema/typeinfo/linestring.go | 13 -------------
 go/libraries/doltcore/schema/typeinfo/point.go      | 13 -------------
 go/libraries/doltcore/schema/typeinfo/polygon.go    | 13 -------------
 3 files changed, 39 deletions(-)

diff --git a/go/libraries/doltcore/schema/typeinfo/linestring.go b/go/libraries/doltcore/schema/typeinfo/linestring.go
index ee3f54275f..f51a34b542 100644
--- a/go/libraries/doltcore/schema/typeinfo/linestring.go
+++ b/go/libraries/doltcore/schema/typeinfo/linestring.go
@@ -147,19 +147,6 @@ func (ti *linestringType) NomsKind() types.NomsKind {
 	return types.LinestringKind
 }
 
-// ParseValue implements TypeInfo interface.
-func (ti *linestringType) ParseValue(ctx context.Context, vrw types.ValueReadWriter, str *string) (types.Value, error) {
-	if str == nil || *str == "" {
-		return types.NullValue, nil
-	}
-	buf := []byte(*str)
-	srid, _, geomType := types.ParseEWKBHeader(buf)
-	if geomType != types.LinestringID {
-		return types.NullValue, nil
-	}
-	return types.ParseEWKBLine(buf[types.EWKBHeaderSize:], srid), nil
-}
-
 // Promote implements TypeInfo interface.
 func (ti *linestringType) Promote() TypeInfo {
 	return &linestringType{ti.sqlLinestringType.Promote().(sql.LinestringType)}
diff --git a/go/libraries/doltcore/schema/typeinfo/point.go b/go/libraries/doltcore/schema/typeinfo/point.go
index 123e97b9ff..0ddfec4154 100644
--- a/go/libraries/doltcore/schema/typeinfo/point.go
+++ b/go/libraries/doltcore/schema/typeinfo/point.go
@@ -141,19 +141,6 @@ func (ti *pointType) NomsKind() types.NomsKind {
 	return types.PointKind
 }
 
-// ParseValue implements TypeInfo interface.
-func (ti *pointType) ParseValue(ctx context.Context, vrw types.ValueReadWriter, str *string) (types.Value, error) {
-	if str == nil || *str == "" {
-		return types.NullValue, nil
-	}
-	buf := []byte(*str)
-	srid, _, geomType := types.ParseEWKBHeader(buf)
-	if geomType != types.PointID {
-		return types.NullValue, nil
-	}
-	return types.ParseEWKBPoint(buf[types.EWKBHeaderSize:], srid), nil
-}
-
 // Promote implements TypeInfo interface.
 func (ti *pointType) Promote() TypeInfo {
 	return &pointType{ti.sqlPointType.Promote().(sql.PointType)}
diff --git a/go/libraries/doltcore/schema/typeinfo/polygon.go b/go/libraries/doltcore/schema/typeinfo/polygon.go
index 114e39144e..5c572f28b3 100644
--- a/go/libraries/doltcore/schema/typeinfo/polygon.go
+++ b/go/libraries/doltcore/schema/typeinfo/polygon.go
@@ -151,19 +151,6 @@ func (ti *polygonType) NomsKind() types.NomsKind {
 	return types.PolygonKind
 }
 
-// ParseValue implements TypeInfo interface.
-func (ti *polygonType) ParseValue(ctx context.Context, vrw types.ValueReadWriter, str *string) (types.Value, error) {
-	if str == nil || *str == "" {
-		return types.NullValue, nil
-	}
-	buf := []byte(*str)
-	srid, _, geomType := types.ParseEWKBHeader(buf)
-	if geomType != types.PolygonID {
-		return types.NullValue, nil
-	}
-	return types.ParseEWKBPoly(buf[types.EWKBHeaderSize:], srid), nil
-}
-
 // Promote implements TypeInfo interface.
 func (ti *polygonType) Promote() TypeInfo {
 	return &polygonType{ti.sqlPolygonType.Promote().(sql.PolygonType)}