fix: infer Nullable/Array/LowCardinality with reflection

helps re #152

couple fixes needed to get Array(Nullable(...)) & Nullable(DateTime64(...)) cases to work

proto/cmd/ch-gen-col/infer.go.tmpl

@@ -6,10 +6,6 @@ package proto
 func inferGenerated(t ColumnType) Column {
 	switch t {
 	{{- range . }}
-	case ColumnTypeArray.Sub({{ .ColumnType }}):
-		return new({{ .Type }}).Array()
-	case ColumnTypeNullable.Sub({{ .ColumnType }}):
-		return new({{ .Type }}).Nullable()
 	case {{ .ColumnType }}:
 		return new({{ .Type }})
 	{{- end }}

proto/col_auto.go

@@ -1,6 +1,7 @@
 package proto
 
 import (
+	"reflect"
 	"strconv"
 	"strings"
 
@@ -37,20 +38,8 @@ func (c *ColAuto) Infer(t ColumnType) error {
 	switch t {
 	case ColumnTypeNothing:
 		c.Data = new(ColNothing)
-	case ColumnTypeNullable.Sub(ColumnTypeNothing):
-		c.Data = new(ColNothing).Nullable()
-	case ColumnTypeArray.Sub(ColumnTypeNothing):
-		c.Data = new(ColNothing).Array()
 	case ColumnTypeString:
 		c.Data = new(ColStr)
-	case ColumnTypeArray.Sub(ColumnTypeString):
-		c.Data = new(ColStr).Array()
-	case ColumnTypeNullable.Sub(ColumnTypeString):
-		c.Data = new(ColStr).Nullable()
-	case ColumnTypeLowCardinality.Sub(ColumnTypeString):
-		c.Data = new(ColStr).LowCardinality()
-	case ColumnTypeArray.Sub(ColumnTypeLowCardinality.Sub(ColumnTypeString)):
-		c.Data = new(ColStr).LowCardinality().Array()
 	case ColumnTypeBool:
 		c.Data = new(ColBool)
 	case ColumnTypeDateTime:
@@ -61,12 +50,50 @@ func (c *ColAuto) Infer(t ColumnType) error {
 		c.Data = NewMap[string, string](new(ColStr), new(ColStr))
 	case ColumnTypeUUID:
 		c.Data = new(ColUUID)
-	case ColumnTypeArray.Sub(ColumnTypeUUID):
-		c.Data = new(ColUUID).Array()
-	case ColumnTypeNullable.Sub(ColumnTypeUUID):
-		c.Data = new(ColUUID).Nullable()
 	default:
 		switch t.Base() {
+		case ColumnTypeArray:
+			inner := new(ColAuto)
+			if err := inner.Infer(t.Elem()); err != nil {
+				return errors.Wrap(err, "array")
+			}
+			innerValue := reflect.ValueOf(inner.Data)
+			arrayMethod := innerValue.MethodByName("Array")
+			if arrayMethod.IsValid() && arrayMethod.Type().NumOut() == 1 {
+				if col, ok := arrayMethod.Call(nil)[0].Interface().(Column); ok {
+					c.Data = col
+					c.DataType = t
+					return nil
+				}
+			}
+		case ColumnTypeNullable:
+			inner := new(ColAuto)
+			if err := inner.Infer(t.Elem()); err != nil {
+				return errors.Wrap(err, "nullable")
+			}
+			innerValue := reflect.ValueOf(inner.Data)
+			nullableMethod := innerValue.MethodByName("Nullable")
+			if nullableMethod.IsValid() && nullableMethod.Type().NumOut() == 1 {
+				if col, ok := nullableMethod.Call(nil)[0].Interface().(Column); ok {
+					c.Data = col
+					c.DataType = t
+					return nil
+				}
+			}
+		case ColumnTypeLowCardinality:
+			inner := new(ColAuto)
+			if err := inner.Infer(t.Elem()); err != nil {
+				return errors.Wrap(err, "low cardinality")
+			}
+			innerValue := reflect.ValueOf(inner.Data)
+			lowCardinalityMethod := innerValue.MethodByName("LowCardinality")
+			if lowCardinalityMethod.IsValid() && lowCardinalityMethod.Type().NumOut() == 1 {
+				if col, ok := lowCardinalityMethod.Call(nil)[0].Interface().(Column); ok {
+					c.Data = col
+					c.DataType = t
+					return nil
+				}
+			}
 		case ColumnTypeDateTime:
 			v := new(ColDateTime)
 			if err := v.Infer(t); err != nil {

proto/col_auto_test.go

@@ -57,6 +57,8 @@ func TestColAuto_Infer(t *testing.T) {
 		"Decimal64(2)",
 		"Decimal128(3)",
 		"Decimal256(4)",
+		"Array(Nullable(Int8))",
+		"Nullable(DateTime64(3))",
 	} {
 		r := AutoResult("foo")
 		require.NoError(t, r.Data.(Inferable).Infer(columnType))

proto/col_datetime64.go

@@ -125,6 +125,10 @@ func (c ColDateTime64) Raw() *ColDateTime64Raw {
 	return &ColDateTime64Raw{ColDateTime64: c}
 }
 
+func (c *ColDateTime64) Nullable() *ColNullable[time.Time] {
+	return &ColNullable[time.Time]{Values: c}
+}
+
 func (c *ColDateTime64) Array() *ColArr[time.Time] {
 	return &ColArr[time.Time]{Data: c}
 }

proto/col_nullable.go

@@ -117,6 +117,12 @@ func (c ColNullable[T]) Row(i int) Nullable[T] {
 	}
 }
 
+func (c *ColNullable[T]) Array() *ColArr[Nullable[T]] {
+	return &ColArr[Nullable[T]]{
+		Data: c,
+	}
+}
+
 func (c *ColNullable[T]) Reset() {
 	c.Nulls.Reset()
 	c.Values.Reset()