CASSGO-43: externally-defined type registration

The new RegisterType function can be used to register externally-defined
types. You'll need to define your own marshalling and unmarshalling code
as well as a TypeInfo implementation. The name and id MUST not collide
with existing and future native CQL types.

Additionally, a lot of the type handling was refactored to use the new
format for native types. Performance should be slightly improved thanks
to some simplification. Benchmarks are coming soon.

Patch by James Hartig for CASSGO-43

Author: jameshartig

CHANGELOG.md

@@ -8,6 +8,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- Externally-defined type registration (CASSGO-43)
+
 ### Changed
 
 - Don't restrict server authenticator unless PasswordAuthentictor.AllowedAuthenticators is provided (CASSGO-19)

cassandra_test.go

@@ -2415,18 +2415,19 @@ func TestAggregateMetadata(t *testing.T) {
 		t.Fatal("expected two aggregates")
 	}
 
+	protoVer := byte(session.cfg.ProtoVersion)
 	expectedAggregrate := AggregateMetadata{
 		Keyspace:      "gocql_test",
 		Name:          "average",
-		ArgumentTypes: []TypeInfo{NativeType{typ: TypeInt}},
+		ArgumentTypes: []TypeInfo{NativeType{proto: protoVer, typ: TypeInt}},
 		InitCond:      "(0, 0)",
-		ReturnType:    NativeType{typ: TypeDouble},
+		ReturnType:    NativeType{proto: protoVer, typ: TypeDouble},
 		StateType: TupleTypeInfo{
-			NativeType: NativeType{typ: TypeTuple},
+			NativeType: NativeType{proto: protoVer, typ: TypeTuple},
 
 			Elems: []TypeInfo{
-				NativeType{typ: TypeInt},
-				NativeType{typ: TypeBigInt},
+				NativeType{proto: protoVer, typ: TypeInt},
+				NativeType{proto: protoVer, typ: TypeBigInt},
 			},
 		},
 		stateFunc: "avgstate",
@@ -2439,11 +2440,11 @@ func TestAggregateMetadata(t *testing.T) {
 	}
 
 	if !reflect.DeepEqual(aggregates[0], expectedAggregrate) {
-		t.Fatalf("aggregate 'average' is %+v, but expected %+v", aggregates[0], expectedAggregrate)
+		t.Fatalf("aggregate 'average' is %#v, but expected %#v", aggregates[0], expectedAggregrate)
 	}
 	expectedAggregrate.Name = "average2"
 	if !reflect.DeepEqual(aggregates[1], expectedAggregrate) {
-		t.Fatalf("aggregate 'average2' is %+v, but expected %+v", aggregates[1], expectedAggregrate)
+		t.Fatalf("aggregate 'average2' is %#v, but expected %#v", aggregates[1], expectedAggregrate)
 	}
 }
 
@@ -2465,28 +2466,29 @@ func TestFunctionMetadata(t *testing.T) {
 	avgState := functions[1]
 	avgFinal := functions[0]
 
+	protoVer := byte(session.cfg.ProtoVersion)
 	avgStateBody := "if (val !=null) {state.setInt(0, state.getInt(0)+1); state.setLong(1, state.getLong(1)+val.intValue());}return state;"
 	expectedAvgState := FunctionMetadata{
 		Keyspace: "gocql_test",
 		Name:     "avgstate",
 		ArgumentTypes: []TypeInfo{
 			TupleTypeInfo{
-				NativeType: NativeType{typ: TypeTuple},
+				NativeType: NativeType{proto: protoVer, typ: TypeTuple},
 
 				Elems: []TypeInfo{
-					NativeType{typ: TypeInt},
-					NativeType{typ: TypeBigInt},
+					NativeType{proto: protoVer, typ: TypeInt},
+					NativeType{proto: protoVer, typ: TypeBigInt},
 				},
 			},
-			NativeType{typ: TypeInt},
+			NativeType{proto: protoVer, typ: TypeInt},
 		},
 		ArgumentNames: []string{"state", "val"},
 		ReturnType: TupleTypeInfo{
-			NativeType: NativeType{typ: TypeTuple},
+			NativeType: NativeType{proto: protoVer, typ: TypeTuple},
 
 			Elems: []TypeInfo{
-				NativeType{typ: TypeInt},
-				NativeType{typ: TypeBigInt},
+				NativeType{proto: protoVer, typ: TypeInt},
+				NativeType{proto: protoVer, typ: TypeBigInt},
 			},
 		},
 		CalledOnNullInput: true,
@@ -2503,22 +2505,22 @@ func TestFunctionMetadata(t *testing.T) {
 		Name:     "avgfinal",
 		ArgumentTypes: []TypeInfo{
 			TupleTypeInfo{
-				NativeType: NativeType{typ: TypeTuple},
+				NativeType: NativeType{proto: protoVer, typ: TypeTuple},
 
 				Elems: []TypeInfo{
-					NativeType{typ: TypeInt},
-					NativeType{typ: TypeBigInt},
+					NativeType{proto: protoVer, typ: TypeInt},
+					NativeType{proto: protoVer, typ: TypeBigInt},
 				},
 			},
 		},
 		ArgumentNames:     []string{"state"},
-		ReturnType:        NativeType{typ: TypeDouble},
+		ReturnType:        NativeType{proto: protoVer, typ: TypeDouble},
 		CalledOnNullInput: true,
 		Language:          "java",
 		Body:              finalStateBody,
 	}
 	if !reflect.DeepEqual(avgFinal, expectedAvgFinal) {
-		t.Fatalf("function is %+v, but expected %+v", avgFinal, expectedAvgFinal)
+		t.Fatalf("function is %#v, but expected %#v", avgFinal, expectedAvgFinal)
 	}
 }
 
@@ -2616,19 +2618,20 @@ func TestKeyspaceMetadata(t *testing.T) {
 	if flagCassVersion.Before(3, 0, 0) {
 		textType = TypeVarchar
 	}
+	protoVer := byte(session.cfg.ProtoVersion)
 	expectedType := UserTypeMetadata{
 		Keyspace:   "gocql_test",
 		Name:       "basicview",
 		FieldNames: []string{"birthday", "nationality", "weight", "height"},
 		FieldTypes: []TypeInfo{
-			NativeType{typ: TypeTimestamp},
-			NativeType{typ: textType},
-			NativeType{typ: textType},
-			NativeType{typ: textType},
+			NativeType{proto: protoVer, typ: TypeTimestamp},
+			NativeType{proto: protoVer, typ: textType},
+			NativeType{proto: protoVer, typ: textType},
+			NativeType{proto: protoVer, typ: textType},
 		},
 	}
 	if !reflect.DeepEqual(*keyspaceMetadata.UserTypes["basicview"], expectedType) {
-		t.Fatalf("type is %+v, but expected %+v", keyspaceMetadata.UserTypes["basicview"], expectedType)
+		t.Fatalf("type is %#v, but expected %#v", keyspaceMetadata.UserTypes["basicview"], expectedType)
 	}
 	if flagCassVersion.Major >= 3 {
 		materializedView, found := keyspaceMetadata.MaterializedViews["view_view"]

frame.go

@@ -31,6 +31,7 @@ import (
 	"io"
 	"io/ioutil"
 	"net"
+	"reflect"
 	"runtime"
 	"strings"
 	"time"
@@ -858,68 +859,98 @@ func (w *writePrepareFrame) buildFrame(f *framer, streamID int) error {
 	return f.finish()
 }
 
-func (f *framer) readTypeInfo() TypeInfo {
-	// TODO: factor this out so the same code paths can be used to parse custom
-	// types and other types, as much of the logic will be duplicated.
-	id := f.readShort()
-
-	simple := NativeType{
-		proto: f.proto,
-		typ:   Type(id),
-	}
-
-	if simple.typ == TypeCustom {
-		simple.custom = f.readString()
-		if cassType := getApacheCassandraType(simple.custom); cassType != TypeCustom {
-			simple.typ = cassType
-		}
-	}
+var (
+	typeInfoType     = reflect.TypeOf((*TypeInfo)(nil)).Elem()
+	typeType         = reflect.TypeOf(Type(0))
+	typeInfoListType = reflect.TypeOf([]TypeInfo(nil))
+	stringListType   = reflect.TypeOf([]string(nil))
+	udtFieldListType = reflect.TypeOf([]UDTField(nil))
+	stringType       = reflect.TypeOf("")
+	shortType        = reflect.TypeOf(uint16(0))
+	byteType         = reflect.TypeOf(byte(0))
+	intType          = reflect.TypeOf(int(0))
+)
 
-	switch simple.typ {
-	case TypeTuple:
+func (f *framer) readForType(typ reflect.Type) interface{} {
+	// check simple equality first
+	switch typ {
+	case stringType:
+		return f.readString()
+	case shortType:
+		return f.readShort()
+	case byteType:
+		return f.readByte()
+	case intType:
+		return f.readInt()
+	case stringListType:
+		return f.readStringList()
+	case udtFieldListType:
 		n := f.readShort()
-		tuple := TupleTypeInfo{
-			NativeType: simple,
-			Elems:      make([]TypeInfo, n),
-		}
-
+		fields := make([]UDTField, n)
 		for i := 0; i < int(n); i++ {
-			tuple.Elems[i] = f.readTypeInfo()
-		}
-
-		return tuple
-
-	case TypeUDT:
-		udt := UDTTypeInfo{
-			NativeType: simple,
+			fields[i] = UDTField{
+				Name: f.readString(),
+				Type: f.readTypeInfo(),
+			}
 		}
-		udt.KeySpace = f.readString()
-		udt.Name = f.readString()
-
+		return fields
+	case typeInfoType:
+		return f.readTypeInfo()
+	case typeType:
+		return Type(f.readShort())
+	case typeInfoListType:
 		n := f.readShort()
-		udt.Elements = make([]UDTField, n)
+		types := make([]TypeInfo, n)
 		for i := 0; i < int(n); i++ {
-			field := &udt.Elements[i]
-			field.Name = f.readString()
-			field.Type = f.readTypeInfo()
+			types[i] = f.readTypeInfo()
 		}
+		return types
+	}
 
-		return udt
-	case TypeMap, TypeList, TypeSet:
-		collection := CollectionType{
-			NativeType: simple,
+	// then check the kind and try to convert
+	switch typ.Kind() {
+	case reflect.String:
+		return reflect.ValueOf(f.readString()).Convert(typ).Interface()
+	case reflect.Int:
+		return reflect.ValueOf(f.readInt()).Convert(typ).Interface()
+	case reflect.Slice:
+		n := f.readShort()
+		slice := reflect.MakeSlice(typ, int(n), int(n))
+		for i := 0; i < int(n); i++ {
+			slice.Index(i).Set(reflect.ValueOf(f.readForType(typ.Elem())))
 		}
+		return slice.Interface()
+	}
+	panic(fmt.Errorf("unsupported type for reading from frame: %s", typ.String()))
+}
 
-		if simple.typ == TypeMap {
-			collection.Key = f.readTypeInfo()
+func (f *framer) readTypeInfo() TypeInfo {
+	typ := Type(f.readShort())
+
+	cqlct, ok := registeredCompositeTypes[typ]
+	if ok {
+		paramsTypes := cqlct.Params(int(f.proto))
+		var params []interface{}
+		if len(paramsTypes) > 0 {
+			params = make([]interface{}, len(paramsTypes))
+			for i, paramType := range paramsTypes {
+				params[i] = f.readForType(paramType)
+			}
 		}
+		return cqlct.TypeInfoParams(int(f.proto), params)
+	}
 
-		collection.Elem = f.readTypeInfo()
-
-		return collection
+	// custom is a special case, we need to read the name then get the type info
+	if typ == TypeCustom {
+		name := f.readString()
+		return (customCQLType{}).TypeInfoParams(int(f.proto), []interface{}{name})
 	}
 
-	return simple
+	cqlt, ok := registeredTypes[typ]
+	if !ok {
+		panic(fmt.Errorf("unknown type id: %d", typ))
+	}
+	return cqlt.TypeInfo(int(f.proto))
 }
 
 type preparedMetadata struct {