Merge pull request #202 from dolthub/taylor/name-type

Implement `name` type
dolthub · Apr 30, 2024 · 5df6f24 · 5df6f24
2 parents 1b37960 + 7db4d34
commit 5df6f24
Show file tree

Hide file tree

Showing 25 changed files with 857 additions and 7 deletions.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
@@ -280,7 +280,7 @@ Type structs should not handle PostgreSQL types, even which is different compare
 For example `SMALLINT` and `INTEGER` are classified as two different types in DoltgreSQL, while they both fall under a generic `Number` type in [GMS](https://github.com/dolthub/go-mysql-server).
 This difference is due to how types are treated in PostgreSQL, with one such example being function overloading, where two different functions sharing the same name are differentiated only by their parameter types.
 
-When adding types, it is usually necessary to also add any relevant casts to `server/functions/framework/cast.go::init()`.
+When adding types, it is usually necessary to also add any relevant casts to `server/cast/init.go::Init()`.
 You'll need to add casts that go from existing types to the new type, and also from the new type to existing types (casts are not bidirectional).
 
 TODO: adding operator functions

diff --git a/server/ast/resolvable_type_reference.go b/server/ast/resolvable_type_reference.go
@@ -98,6 +98,8 @@ func nodeResolvableTypeReference(typ tree.ResolvableTypeReference) (*vitess.Conv
 				columnTypeName = "JSON"
 			case oid.T_jsonb:
 				columnTypeName = "JSON"
+			case oid.T_name:
+				resolvedType = pgtypes.Name
 			case oid.T_numeric:
 				if columnType.Precision() == 0 && columnType.Scale() == 0 {
 					resolvedType = pgtypes.Numeric

diff --git a/server/cast/bool.go b/server/cast/bool.go
@@ -56,6 +56,17 @@ func boolExplicit() {
 			}
 		},
 	})
+	framework.MustAddExplicitTypeCast(framework.TypeCast{
+		FromType: pgtypes.Bool,
+		ToType:   pgtypes.Name,
+		Function: func(ctx framework.Context, val any, targetType pgtypes.DoltgresType) (any, error) {
+			str := "false"
+			if val.(bool) {
+				str = "true"
+			}
+			return handleCharExplicitCast(str, targetType)
+		},
+	})
 	framework.MustAddExplicitTypeCast(framework.TypeCast{
 		FromType: pgtypes.Bool,
 		ToType:   pgtypes.Text,
@@ -100,6 +111,17 @@ func boolImplicit() {
 			return handleCharImplicitCast(str, targetType)
 		},
 	})
+	framework.MustAddImplicitTypeCast(framework.TypeCast{
+		FromType: pgtypes.Bool,
+		ToType:   pgtypes.Name,
+		Function: func(ctx framework.Context, val any, targetType pgtypes.DoltgresType) (any, error) {
+			str := "false"
+			if val.(bool) {
+				str = "true"
+			}
+			return handleCharImplicitCast(str, targetType)
+		},
+	})
 	framework.MustAddImplicitTypeCast(framework.TypeCast{
 		FromType: pgtypes.Bool,
 		ToType:   pgtypes.Text,

diff --git a/server/cast/bytea.go b/server/cast/bytea.go
@@ -45,6 +45,14 @@ func byteaExplicit() {
 			return val, nil
 		},
 	})
+	framework.MustAddExplicitTypeCast(framework.TypeCast{
+		FromType: pgtypes.Bytea,
+		ToType:   pgtypes.Name,
+		Function: func(ctx framework.Context, val any, targetType pgtypes.DoltgresType) (any, error) {
+			str := `\x` + hex.EncodeToString(val.([]byte))
+			return handleCharExplicitCast(str, targetType)
+		},
+	})
 	framework.MustAddExplicitTypeCast(framework.TypeCast{
 		FromType: pgtypes.Bytea,
 		ToType:   pgtypes.Text,
@@ -79,6 +87,14 @@ func byteaImplicit() {
 			return val, nil
 		},
 	})
+	framework.MustAddImplicitTypeCast(framework.TypeCast{
+		FromType: pgtypes.Bytea,
+		ToType:   pgtypes.Name,
+		Function: func(ctx framework.Context, val any, targetType pgtypes.DoltgresType) (any, error) {
+			str := `\x` + hex.EncodeToString(val.([]byte))
+			return handleCharImplicitCast(str, targetType)
+		},
+	})
 	framework.MustAddImplicitTypeCast(framework.TypeCast{
 		FromType: pgtypes.Bytea,
 		ToType:   pgtypes.Text,

diff --git a/server/cast/char.go b/server/cast/char.go
@@ -128,6 +128,13 @@ func charExplicit() {
 			return out, nil
 		},
 	})
+	framework.MustAddExplicitTypeCast(framework.TypeCast{
+		FromType: pgtypes.BpChar,
+		ToType:   pgtypes.Name,
+		Function: func(ctx framework.Context, val any, targetType pgtypes.DoltgresType) (any, error) {
+			return handleCharExplicitCast(val.(string), targetType)
+		},
+	})
 	framework.MustAddExplicitTypeCast(framework.TypeCast{
 		FromType: pgtypes.BpChar,
 		ToType:   pgtypes.Numeric,
@@ -261,6 +268,13 @@ func charImplicit() {
 			return out, nil
 		},
 	})
+	framework.MustAddImplicitTypeCast(framework.TypeCast{
+		FromType: pgtypes.BpChar,
+		ToType:   pgtypes.Name,
+		Function: func(ctx framework.Context, val any, targetType pgtypes.DoltgresType) (any, error) {
+			return handleCharImplicitCast(val.(string), targetType)
+		},
+	})
 	framework.MustAddImplicitTypeCast(framework.TypeCast{
 		FromType: pgtypes.BpChar,
 		ToType:   pgtypes.Numeric,

diff --git a/server/cast/float32.go b/server/cast/float32.go
@@ -88,6 +88,14 @@ func float32Explicit() {
 			return int64(val), nil
 		},
 	})
+	framework.MustAddExplicitTypeCast(framework.TypeCast{
+		FromType: pgtypes.Float32,
+		ToType:   pgtypes.Name,
+		Function: func(ctx framework.Context, val any, targetType pgtypes.DoltgresType) (any, error) {
+			str := strconv.FormatFloat(float64(val.(float32)), 'g', -1, 32)
+			return handleCharExplicitCast(str, targetType)
+		},
+	})
 	framework.MustAddExplicitTypeCast(framework.TypeCast{
 		FromType: pgtypes.Float32,
 		ToType:   pgtypes.Numeric,
@@ -169,6 +177,14 @@ func float32Implicit() {
 			return int64(val), nil
 		},
 	})
+	framework.MustAddImplicitTypeCast(framework.TypeCast{
+		FromType: pgtypes.Float32,
+		ToType:   pgtypes.Name,
+		Function: func(ctx framework.Context, val any, targetType pgtypes.DoltgresType) (any, error) {
+			str := strconv.FormatFloat(float64(val.(float32)), 'g', -1, 32)
+			return handleCharImplicitCast(str, targetType)
+		},
+	})
 	framework.MustAddImplicitTypeCast(framework.TypeCast{
 		FromType: pgtypes.Float32,
 		ToType:   pgtypes.Numeric,

diff --git a/server/cast/float64.go b/server/cast/float64.go
@@ -88,6 +88,14 @@ func float64Explicit() {
 			return int64(val), nil
 		},
 	})
+	framework.MustAddExplicitTypeCast(framework.TypeCast{
+		FromType: pgtypes.Float64,
+		ToType:   pgtypes.Name,
+		Function: func(ctx framework.Context, val any, targetType pgtypes.DoltgresType) (any, error) {
+			str := strconv.FormatFloat(val.(float64), 'g', -1, 64)
+			return handleCharExplicitCast(str, targetType)
+		},
+	})
 	framework.MustAddExplicitTypeCast(framework.TypeCast{
 		FromType: pgtypes.Float64,
 		ToType:   pgtypes.Numeric,
@@ -169,6 +177,14 @@ func float64Implicit() {
 			return int64(val), nil
 		},
 	})
+	framework.MustAddImplicitTypeCast(framework.TypeCast{
+		FromType: pgtypes.Float64,
+		ToType:   pgtypes.Name,
+		Function: func(ctx framework.Context, val any, targetType pgtypes.DoltgresType) (any, error) {
+			str := strconv.FormatFloat(val.(float64), 'g', -1, 64)
+			return handleCharImplicitCast(str, targetType)
+		},
+	})
 	framework.MustAddImplicitTypeCast(framework.TypeCast{
 		FromType: pgtypes.Float64,
 		ToType:   pgtypes.Numeric,

diff --git a/server/cast/init.go b/server/cast/init.go
@@ -24,6 +24,7 @@ func Init() {
 	initInt16()
 	initInt32()
 	initInt64()
+	initName()
 	initNumeric()
 	initText()
 	initUuid()

diff --git a/server/cast/int16.go b/server/cast/int16.go
@@ -74,6 +74,14 @@ func int16Explicit() {
 			return int64(val.(int16)), nil
 		},
 	})
+	framework.MustAddExplicitTypeCast(framework.TypeCast{
+		FromType: pgtypes.Int16,
+		ToType:   pgtypes.Name,
+		Function: func(ctx framework.Context, val any, targetType pgtypes.DoltgresType) (any, error) {
+			str := strconv.FormatInt(int64(val.(int16)), 10)
+			return handleCharExplicitCast(str, targetType)
+		},
+	})
 	framework.MustAddExplicitTypeCast(framework.TypeCast{
 		FromType: pgtypes.Int16,
 		ToType:   pgtypes.Numeric,
@@ -143,6 +151,14 @@ func int16Implicit() {
 			return int64(val.(int16)), nil
 		},
 	})
+	framework.MustAddImplicitTypeCast(framework.TypeCast{
+		FromType: pgtypes.Int16,
+		ToType:   pgtypes.Name,
+		Function: func(ctx framework.Context, val any, targetType pgtypes.DoltgresType) (any, error) {
+			str := strconv.FormatInt(int64(val.(int16)), 10)
+			return handleCharImplicitCast(str, targetType)
+		},
+	})
 	framework.MustAddImplicitTypeCast(framework.TypeCast{
 		FromType: pgtypes.Int16,
 		ToType:   pgtypes.Numeric,

diff --git a/server/cast/int32.go b/server/cast/int32.go
@@ -78,6 +78,14 @@ func int32Explicit() {
 			return int64(val.(int32)), nil
 		},
 	})
+	framework.MustAddExplicitTypeCast(framework.TypeCast{
+		FromType: pgtypes.Int32,
+		ToType:   pgtypes.Name,
+		Function: func(ctx framework.Context, val any, targetType pgtypes.DoltgresType) (any, error) {
+			str := strconv.FormatInt(int64(val.(int32)), 10)
+			return handleCharExplicitCast(str, targetType)
+		},
+	})
 	framework.MustAddExplicitTypeCast(framework.TypeCast{
 		FromType: pgtypes.Int32,
 		ToType:   pgtypes.Numeric,
@@ -150,6 +158,14 @@ func int32Implicit() {
 			return int64(val.(int32)), nil
 		},
 	})
+	framework.MustAddImplicitTypeCast(framework.TypeCast{
+		FromType: pgtypes.Int32,
+		ToType:   pgtypes.Name,
+		Function: func(ctx framework.Context, val any, targetType pgtypes.DoltgresType) (any, error) {
+			str := strconv.FormatInt(int64(val.(int32)), 10)
+			return handleCharImplicitCast(str, targetType)
+		},
+	})
 	framework.MustAddImplicitTypeCast(framework.TypeCast{
 		FromType: pgtypes.Int32,
 		ToType:   pgtypes.Numeric,

diff --git a/server/cast/int64.go b/server/cast/int64.go
@@ -81,6 +81,14 @@ func int64Explicit() {
 			return val, nil
 		},
 	})
+	framework.MustAddExplicitTypeCast(framework.TypeCast{
+		FromType: pgtypes.Int64,
+		ToType:   pgtypes.Name,
+		Function: func(ctx framework.Context, val any, targetType pgtypes.DoltgresType) (any, error) {
+			str := strconv.FormatInt(val.(int64), 10)
+			return handleCharExplicitCast(str, targetType)
+		},
+	})
 	framework.MustAddExplicitTypeCast(framework.TypeCast{
 		FromType: pgtypes.Int64,
 		ToType:   pgtypes.Numeric,
@@ -156,6 +164,14 @@ func int64Implicit() {
 			return val, nil
 		},
 	})
+	framework.MustAddImplicitTypeCast(framework.TypeCast{
+		FromType: pgtypes.Int64,
+		ToType:   pgtypes.Name,
+		Function: func(ctx framework.Context, val any, targetType pgtypes.DoltgresType) (any, error) {
+			str := strconv.FormatInt(val.(int64), 10)
+			return handleCharImplicitCast(str, targetType)
+		},
+	})
 	framework.MustAddImplicitTypeCast(framework.TypeCast{
 		FromType: pgtypes.Int64,
 		ToType:   pgtypes.Numeric,