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.

Author: jameshartig

frame.go

@@ -31,6 +31,7 @@ import (
 	"io"
 	"io/ioutil"
 	"net"
+	"reflect"
 	"runtime"
 	"strings"
 	"time"
@@ -869,68 +870,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 {