From 7beaaebb6668bb20808900b04e99847ad245e9ad Mon Sep 17 00:00:00 2001 From: Anshul Data Date: Thu, 12 Sep 2024 15:30:23 +0530 Subject: [PATCH] Address review comments --- extensions/simple_extension.go | 8 ++-- extensions/variants.go | 25 ++++++------- extensions/variants_test.go | 8 ++-- .../concrete_int_param.go | 6 +-- .../integer_parameter_type.go} | 8 ++-- .../integer_parameter_type_test.go} | 14 +++---- .../variable_int_param.go | 6 +-- types/parameterized_decimal_type.go | 14 +++---- types/parameterized_decimal_type_test.go | 14 +++---- types/parameterized_list_type_test.go | 6 +-- types/parameterized_map_type_test.go | 6 +-- ...parameterized_single_integer_param_type.go | 37 ++++++++----------- ...eterized_single_integer_param_type_test.go | 6 +-- types/parameterized_struct_type_test.go | 6 +-- types/parser/type_parser.go | 22 +++++------ types/parser/type_parser_test.go | 16 ++++---- types/types.go | 19 +++++++--- 17 files changed, 110 insertions(+), 111 deletions(-) rename types/{leaf_parameters => integer_parameters}/concrete_int_param.go (76%) rename types/{leaf_parameters/leaf_parameter_type.go => integer_parameters/integer_parameter_type.go} (65%) rename types/{leaf_parameters/leaf_parameter_type_test.go => integer_parameters/integer_parameter_type_test.go} (63%) rename types/{leaf_parameters => integer_parameters}/variable_int_param.go (78%) diff --git a/extensions/simple_extension.go b/extensions/simple_extension.go index f055d73..d9cc4ec 100644 --- a/extensions/simple_extension.go +++ b/extensions/simple_extension.go @@ -57,7 +57,7 @@ type TypeVariation struct { type Argument interface { toTypeString() string - marker() // unexported marker method + argumentMarker() // unexported marker method } type EnumArg struct { @@ -70,7 +70,7 @@ func (EnumArg) toTypeString() string { return "req" } -func (v EnumArg) marker() {} +func (v EnumArg) argumentMarker() {} type ValueArg struct { Name string `yaml:",omitempty"` @@ -83,7 +83,7 @@ func (v ValueArg) toTypeString() string { return v.Value.Expr.(*parser.Type).ShortType() } -func (v ValueArg) marker() {} +func (v ValueArg) argumentMarker() {} type TypeArg struct { Name string `yaml:",omitempty"` @@ -93,7 +93,7 @@ type TypeArg struct { func (TypeArg) toTypeString() string { return "type" } -func (v TypeArg) marker() {} +func (v TypeArg) argumentMarker() {} type ArgumentList []Argument diff --git a/extensions/variants.go b/extensions/variants.go index 3ee85d7..31752fa 100644 --- a/extensions/variants.go +++ b/extensions/variants.go @@ -8,7 +8,7 @@ import ( substraitgo "github.com/substrait-io/substrait-go" "github.com/substrait-io/substrait-go/types" - "github.com/substrait-io/substrait-go/types/leaf_parameters" + "github.com/substrait-io/substrait-go/types/integer_parameters" "github.com/substrait-io/substrait-go/types/parser" ) @@ -379,23 +379,20 @@ func (s *WindowFunctionVariant) WindowType() WindowType { return s.impl.WindowTy // HasSyncParams This API returns if params share a leaf param name func HasSyncParams(params []types.FuncDefArgType) bool { - // get list of parameters from Abstract parameter type - // if any of the parameter is common, it indicates parameters are same across parameters + // if any of the leaf parameters are same, it indicates parameters are same across parameters existingParamMap := make(map[string]bool) for _, p := range params { if !p.HasParameterizedParam() { // not a type which contains abstract parameters, so continue continue } - // get list of parameters for each abstract parameter type - // note, this can be more than one parameter because of nested abstract types - // e.g. Decimal or List, VARCHAR>> + // get list of parameterized parameters + // parameterized param can be a Leaf or another type. If another type we recurse to find leaf abstractParams := p.GetParameterizedParams() var leafParams []string for _, abstractParam := range abstractParams { - leafParams = append(leafParams, getLeafAbstractParams(abstractParam)...) + leafParams = append(leafParams, getLeafParameterizedParams(abstractParam)...) } - // all leaf params for this parameters are found // if map contains any of the leaf params, parameters are synced for _, leafParam := range leafParams { if _, ok := existingParamMap[leafParam]; ok { @@ -412,23 +409,23 @@ func HasSyncParams(params []types.FuncDefArgType) bool { return false } -// from a parameter of abstract type, get the leaf parameters -// an abstract parameter can be a leaf type or a parameterized type itself +// from a parameterized type, get the leaf parameters +// an parameterized param can be a leaf type (e.g. P) or a parameterized type (e.g. VARCHAR) itself // if it is a leaf type, its param name is returned // if it is parameterized type, leaf type is found recursively -func getLeafAbstractParams(abstractTypes interface{}) []string { - if leaf, ok := abstractTypes.(leaf_parameters.LeafParameter); ok { +func getLeafParameterizedParams(abstractTypes interface{}) []string { + if leaf, ok := abstractTypes.(integer_parameters.IntegerParameter); ok { return []string{leaf.String()} } // if it is not a leaf type recurse if pat, ok := abstractTypes.(types.FuncDefArgType); ok { var outLeafParams []string for _, p := range pat.GetParameterizedParams() { - childLeafParams := getLeafAbstractParams(p) + childLeafParams := getLeafParameterizedParams(p) outLeafParams = append(outLeafParams, childLeafParams...) } return outLeafParams } - // for leaf type, return the param name + // invalid type panic("invalid non-leaf, non-parameterized type param") } diff --git a/extensions/variants_test.go b/extensions/variants_test.go index 88b4a23..79280c9 100644 --- a/extensions/variants_test.go +++ b/extensions/variants_test.go @@ -9,7 +9,7 @@ import ( "github.com/stretchr/testify/require" "github.com/substrait-io/substrait-go/extensions" "github.com/substrait-io/substrait-go/types" - "github.com/substrait-io/substrait-go/types/leaf_parameters" + "github.com/substrait-io/substrait-go/types/integer_parameters" "github.com/substrait-io/substrait-go/types/parser" ) @@ -70,9 +70,9 @@ func TestEvaluateTypeExpression(t *testing.T) { func TestHasSyncParams(t *testing.T) { - apt_P := leaf_parameters.NewVariableIntParam("P") - apt_Q := leaf_parameters.NewVariableIntParam("Q") - cpt_38 := leaf_parameters.NewConcreteIntParam(38) + apt_P := integer_parameters.NewVariableIntParam("P") + apt_Q := integer_parameters.NewVariableIntParam("Q") + cpt_38 := integer_parameters.NewConcreteIntParam(38) fct_P := &types.ParameterizedFixedCharType{IntegerOption: apt_P} fct_Q := &types.ParameterizedFixedCharType{IntegerOption: apt_Q} diff --git a/types/leaf_parameters/concrete_int_param.go b/types/integer_parameters/concrete_int_param.go similarity index 76% rename from types/leaf_parameters/concrete_int_param.go rename to types/integer_parameters/concrete_int_param.go index 30f1e32..dd3765a 100644 --- a/types/leaf_parameters/concrete_int_param.go +++ b/types/integer_parameters/concrete_int_param.go @@ -1,6 +1,6 @@ // SPDX-License-Identifier: Apache-2.0 -package leaf_parameters +package integer_parameters import "fmt" @@ -9,12 +9,12 @@ import "fmt" // DECIMAL --> 0 Is an ConcreteIntParam but P not type ConcreteIntParam int32 -func NewConcreteIntParam(v int32) LeafParameter { +func NewConcreteIntParam(v int32) IntegerParameter { m := ConcreteIntParam(v) return &m } -func (m *ConcreteIntParam) IsCompatible(o LeafParameter) bool { +func (m *ConcreteIntParam) IsCompatible(o IntegerParameter) bool { if t, ok := o.(*ConcreteIntParam); ok { return t == m } diff --git a/types/leaf_parameters/leaf_parameter_type.go b/types/integer_parameters/integer_parameter_type.go similarity index 65% rename from types/leaf_parameters/leaf_parameter_type.go rename to types/integer_parameters/integer_parameter_type.go index ba2692b..8c562a1 100644 --- a/types/leaf_parameters/leaf_parameter_type.go +++ b/types/integer_parameters/integer_parameter_type.go @@ -1,15 +1,15 @@ // SPDX-License-Identifier: Apache-2.0 -package leaf_parameters +package integer_parameters import "fmt" -// LeafParameter represents a parameter type +// IntegerParameter represents a parameter type // parameter can of concrete (38) or abstract type (P) // or another parameterized type like VARCHAR<"L1"> -type LeafParameter interface { +type IntegerParameter interface { // IsCompatible is type compatible with other // compatible is other can be used in place of this type - IsCompatible(other LeafParameter) bool + IsCompatible(other IntegerParameter) bool fmt.Stringer } diff --git a/types/leaf_parameters/leaf_parameter_type_test.go b/types/integer_parameters/integer_parameter_type_test.go similarity index 63% rename from types/leaf_parameters/leaf_parameter_type_test.go rename to types/integer_parameters/integer_parameter_type_test.go index 5a7a61f..0a47de2 100644 --- a/types/leaf_parameters/leaf_parameter_type_test.go +++ b/types/integer_parameters/integer_parameter_type_test.go @@ -1,26 +1,26 @@ // SPDX-License-Identifier: Apache-2.0 -package leaf_parameters_test +package integer_parameters_test import ( "testing" "github.com/stretchr/testify/require" - "github.com/substrait-io/substrait-go/types/leaf_parameters" + "github.com/substrait-io/substrait-go/types/integer_parameters" ) func TestConcreteParameterType(t *testing.T) { - concreteType1 := leaf_parameters.ConcreteIntParam(1) + concreteType1 := integer_parameters.ConcreteIntParam(1) require.Equal(t, "1", concreteType1.String()) } func TestLeafParameterType(t *testing.T) { - var concreteType1, concreteType2, abstractType1 leaf_parameters.LeafParameter + var concreteType1, concreteType2, abstractType1 integer_parameters.IntegerParameter - concreteType1 = leaf_parameters.NewConcreteIntParam(1) - concreteType2 = leaf_parameters.NewConcreteIntParam(2) + concreteType1 = integer_parameters.NewConcreteIntParam(1) + concreteType2 = integer_parameters.NewConcreteIntParam(2) - abstractType1 = leaf_parameters.NewVariableIntParam("P") + abstractType1 = integer_parameters.NewVariableIntParam("P") // verify string val require.Equal(t, "1", concreteType1.String()) diff --git a/types/leaf_parameters/variable_int_param.go b/types/integer_parameters/variable_int_param.go similarity index 78% rename from types/leaf_parameters/variable_int_param.go rename to types/integer_parameters/variable_int_param.go index abc3612..76fd5c2 100644 --- a/types/leaf_parameters/variable_int_param.go +++ b/types/integer_parameters/variable_int_param.go @@ -1,18 +1,18 @@ // SPDX-License-Identifier: Apache-2.0 -package leaf_parameters +package integer_parameters // VariableIntParam represents an integer parameter for a parameterized type // Example: VARCHAR(L1) -> L1 is an VariableIntParam // DECIMAL --> P Is an VariableIntParam type VariableIntParam string -func NewVariableIntParam(s string) LeafParameter { +func NewVariableIntParam(s string) IntegerParameter { m := VariableIntParam(s) return &m } -func (m *VariableIntParam) IsCompatible(o LeafParameter) bool { +func (m *VariableIntParam) IsCompatible(o IntegerParameter) bool { switch o.(type) { case *VariableIntParam, *ConcreteIntParam: return true diff --git a/types/parameterized_decimal_type.go b/types/parameterized_decimal_type.go index 0e31c82..2e0fb37 100644 --- a/types/parameterized_decimal_type.go +++ b/types/parameterized_decimal_type.go @@ -5,7 +5,7 @@ package types import ( "fmt" - "github.com/substrait-io/substrait-go/types/leaf_parameters" + "github.com/substrait-io/substrait-go/types/integer_parameters" ) // ParameterizedDecimalType is a decimal type which to hold function arguments @@ -13,8 +13,8 @@ import ( type ParameterizedDecimalType struct { Nullability Nullability TypeVariationRef uint32 - Precision leaf_parameters.LeafParameter - Scale leaf_parameters.LeafParameter + Precision integer_parameters.IntegerParameter + Scale integer_parameters.IntegerParameter } func (m *ParameterizedDecimalType) SetNullability(n Nullability) FuncDefArgType { @@ -29,8 +29,8 @@ func (m *ParameterizedDecimalType) String() string { } func (m *ParameterizedDecimalType) HasParameterizedParam() bool { - _, ok1 := m.Precision.(*leaf_parameters.VariableIntParam) - _, ok2 := m.Scale.(*leaf_parameters.VariableIntParam) + _, ok1 := m.Precision.(*integer_parameters.VariableIntParam) + _, ok2 := m.Scale.(*integer_parameters.VariableIntParam) return ok1 || ok2 } @@ -39,10 +39,10 @@ func (m *ParameterizedDecimalType) GetParameterizedParams() []interface{} { return nil } var params []interface{} - if p, ok := m.Precision.(*leaf_parameters.VariableIntParam); ok { + if p, ok := m.Precision.(*integer_parameters.VariableIntParam); ok { params = append(params, p) } - if p, ok := m.Scale.(*leaf_parameters.VariableIntParam); ok { + if p, ok := m.Scale.(*integer_parameters.VariableIntParam); ok { params = append(params, p) } return params diff --git a/types/parameterized_decimal_type_test.go b/types/parameterized_decimal_type_test.go index 63afc09..5729dee 100644 --- a/types/parameterized_decimal_type_test.go +++ b/types/parameterized_decimal_type_test.go @@ -7,18 +7,18 @@ import ( "github.com/stretchr/testify/require" "github.com/substrait-io/substrait-go/types" - "github.com/substrait-io/substrait-go/types/leaf_parameters" + "github.com/substrait-io/substrait-go/types/integer_parameters" ) func TestParameterizedDecimalType(t *testing.T) { - precision_P := leaf_parameters.NewVariableIntParam("P") - scale_S := leaf_parameters.NewVariableIntParam("S") - precision_38 := leaf_parameters.NewConcreteIntParam(38) - scale_5 := leaf_parameters.NewConcreteIntParam(5) + precision_P := integer_parameters.NewVariableIntParam("P") + scale_S := integer_parameters.NewVariableIntParam("S") + precision_38 := integer_parameters.NewConcreteIntParam(38) + scale_5 := integer_parameters.NewConcreteIntParam(5) for _, td := range []struct { name string - precision leaf_parameters.LeafParameter - scale leaf_parameters.LeafParameter + precision integer_parameters.IntegerParameter + scale integer_parameters.IntegerParameter expectedNullableString string expectedNullableRequiredString string expectedHasParameterizedParam bool diff --git a/types/parameterized_list_type_test.go b/types/parameterized_list_type_test.go index 82166c2..da54387 100644 --- a/types/parameterized_list_type_test.go +++ b/types/parameterized_list_type_test.go @@ -7,13 +7,13 @@ import ( "github.com/stretchr/testify/require" "github.com/substrait-io/substrait-go/types" - "github.com/substrait-io/substrait-go/types/leaf_parameters" + "github.com/substrait-io/substrait-go/types/integer_parameters" ) func TestParameterizedListType(t *testing.T) { decimalType := &types.ParameterizedDecimalType{ - Precision: leaf_parameters.NewVariableIntParam("P"), - Scale: leaf_parameters.NewVariableIntParam("S"), + Precision: integer_parameters.NewVariableIntParam("P"), + Scale: integer_parameters.NewVariableIntParam("S"), Nullability: types.NullabilityRequired, } int8Type := &types.Int8Type{} diff --git a/types/parameterized_map_type_test.go b/types/parameterized_map_type_test.go index 42cb04e..62378ba 100644 --- a/types/parameterized_map_type_test.go +++ b/types/parameterized_map_type_test.go @@ -7,13 +7,13 @@ import ( "github.com/stretchr/testify/require" "github.com/substrait-io/substrait-go/types" - "github.com/substrait-io/substrait-go/types/leaf_parameters" + "github.com/substrait-io/substrait-go/types/integer_parameters" ) func TestParameterizedMapType(t *testing.T) { decimalType := &types.ParameterizedDecimalType{ - Precision: leaf_parameters.NewVariableIntParam("P"), - Scale: leaf_parameters.NewVariableIntParam("S"), + Precision: integer_parameters.NewVariableIntParam("P"), + Scale: integer_parameters.NewVariableIntParam("S"), Nullability: types.NullabilityRequired, } int8Type := &types.Int8Type{Nullability: types.NullabilityNullable} diff --git a/types/parameterized_single_integer_param_type.go b/types/parameterized_single_integer_param_type.go index d5c215b..4582aea 100644 --- a/types/parameterized_single_integer_param_type.go +++ b/types/parameterized_single_integer_param_type.go @@ -4,15 +4,20 @@ package types import ( "fmt" + "reflect" - "github.com/substrait-io/substrait-go/types/leaf_parameters" + "github.com/substrait-io/substrait-go/types/integer_parameters" ) +type singleIntegerParamType interface { + BaseString() string +} + // parameterizedTypeSingleIntegerParam This is a generic type to represent parameterized type with a single integer parameter -type parameterizedTypeSingleIntegerParam[T VarCharType | FixedCharType | FixedBinaryType | PrecisionTimestampType | PrecisionTimestampTzType] struct { +type parameterizedTypeSingleIntegerParam[T singleIntegerParamType] struct { Nullability Nullability TypeVariationRef uint32 - IntegerOption leaf_parameters.LeafParameter + IntegerOption integer_parameters.IntegerParameter } func (m *parameterizedTypeSingleIntegerParam[T]) SetNullability(n Nullability) FuncDefArgType { @@ -29,29 +34,17 @@ func (m *parameterizedTypeSingleIntegerParam[T]) parameterString() string { } func (m *parameterizedTypeSingleIntegerParam[T]) baseString() string { - switch any(m).(type) { - case *ParameterizedVarCharType: - t := VarCharType{} - return t.BaseString() - case *ParameterizedFixedCharType: - t := FixedCharType{} - return t.BaseString() - case *ParameterizedFixedBinaryType: - t := FixedBinaryType{} - return t.BaseString() - case *ParameterizedPrecisionTimestampType: - t := PrecisionTimestampType{} - return t.BaseString() - case *ParameterizedPrecisionTimestampTzType: - t := PrecisionTimestampTzType{} - return t.BaseString() - default: - panic("unknown type") + var t T + tType := reflect.TypeOf(t) + if tType.Kind() == reflect.Ptr { + tType = tType.Elem() } + newInstance := reflect.New(tType).Interface().(T) + return newInstance.BaseString() } func (m *parameterizedTypeSingleIntegerParam[T]) HasParameterizedParam() bool { - _, ok1 := m.IntegerOption.(*leaf_parameters.VariableIntParam) + _, ok1 := m.IntegerOption.(*integer_parameters.VariableIntParam) return ok1 } diff --git a/types/parameterized_single_integer_param_type_test.go b/types/parameterized_single_integer_param_type_test.go index 9f54d3f..1c98491 100644 --- a/types/parameterized_single_integer_param_type_test.go +++ b/types/parameterized_single_integer_param_type_test.go @@ -7,12 +7,12 @@ import ( "github.com/stretchr/testify/require" "github.com/substrait-io/substrait-go/types" - "github.com/substrait-io/substrait-go/types/leaf_parameters" + "github.com/substrait-io/substrait-go/types/integer_parameters" ) func TestParameterizedSingleIntegerType(t *testing.T) { - abstractLeafParam_L1 := leaf_parameters.NewVariableIntParam("L1") - concreteLeafParam_38 := leaf_parameters.NewConcreteIntParam(38) + abstractLeafParam_L1 := integer_parameters.NewVariableIntParam("L1") + concreteLeafParam_38 := integer_parameters.NewConcreteIntParam(38) for _, td := range []struct { name string typ types.FuncDefArgType diff --git a/types/parameterized_struct_type_test.go b/types/parameterized_struct_type_test.go index ac88c6b..68c3bf4 100644 --- a/types/parameterized_struct_type_test.go +++ b/types/parameterized_struct_type_test.go @@ -7,13 +7,13 @@ import ( "github.com/stretchr/testify/require" "github.com/substrait-io/substrait-go/types" - "github.com/substrait-io/substrait-go/types/leaf_parameters" + "github.com/substrait-io/substrait-go/types/integer_parameters" ) func TestParameterizedStructType(t *testing.T) { decimalType := &types.ParameterizedDecimalType{ - Precision: leaf_parameters.NewVariableIntParam("P"), - Scale: leaf_parameters.NewVariableIntParam("S"), + Precision: integer_parameters.NewVariableIntParam("P"), + Scale: integer_parameters.NewVariableIntParam("S"), Nullability: types.NullabilityRequired, } int8Type := &types.Int8Type{Nullability: types.NullabilityNullable} diff --git a/types/parser/type_parser.go b/types/parser/type_parser.go index b32f9c4..4e05aa0 100644 --- a/types/parser/type_parser.go +++ b/types/parser/type_parser.go @@ -12,7 +12,7 @@ import ( "github.com/alecthomas/participle/v2/lexer" substraitgo "github.com/substrait-io/substrait-go" "github.com/substrait-io/substrait-go/types" - "github.com/substrait-io/substrait-go/types/leaf_parameters" + "github.com/substrait-io/substrait-go/types/integer_parameters" ) var defaultParser *Parser @@ -268,12 +268,12 @@ func (p *lengthType) RetType() (types.Type, error) { func (p *lengthType) ArgType() (types.FuncDefArgType, error) { var n types.Nullability - var leafParam leaf_parameters.LeafParameter + var leafParam integer_parameters.IntegerParameter switch t := p.NumericParam.Expr.(type) { case *IntegerLiteral: - leafParam = leaf_parameters.NewConcreteIntParam(t.Value) + leafParam = integer_parameters.NewConcreteIntParam(t.Value) case *ParamName: - leafParam = leaf_parameters.NewVariableIntParam(t.Name) + leafParam = integer_parameters.NewVariableIntParam(t.Name) default: return nil, substraitgo.ErrNotImplemented } @@ -284,7 +284,7 @@ func (p *lengthType) ArgType() (types.FuncDefArgType, error) { return typ, nil } -func getParameterizedTypeSingleParam(typeName string, leafParam leaf_parameters.LeafParameter, n types.Nullability) (types.FuncDefArgType, error) { +func getParameterizedTypeSingleParam(typeName string, leafParam integer_parameters.IntegerParameter, n types.Nullability) (types.FuncDefArgType, error) { switch types.TypeName(typeName) { case types.TypeNameVarChar: return &types.ParameterizedVarCharType{IntegerOption: leafParam, Nullability: n}, nil @@ -326,20 +326,20 @@ func (d *decimalType) ArgType() (types.FuncDefArgType, error) { } else { n = types.NullabilityRequired } - var precision leaf_parameters.LeafParameter + var precision integer_parameters.IntegerParameter if pi, ok := d.Precision.Expr.(*IntegerLiteral); ok { - precision = leaf_parameters.NewConcreteIntParam(pi.Value) + precision = integer_parameters.NewConcreteIntParam(pi.Value) } else { ps := d.Precision.Expr.(*ParamName) - precision = leaf_parameters.NewVariableIntParam(ps.String()) + precision = integer_parameters.NewVariableIntParam(ps.String()) } - var scale leaf_parameters.LeafParameter + var scale integer_parameters.IntegerParameter if si, ok := d.Scale.Expr.(*IntegerLiteral); ok { - scale = leaf_parameters.NewConcreteIntParam(si.Value) + scale = integer_parameters.NewConcreteIntParam(si.Value) } else { ss := d.Scale.Expr.(*ParamName) - scale = leaf_parameters.NewVariableIntParam(ss.String()) + scale = integer_parameters.NewVariableIntParam(ss.String()) } return &types.ParameterizedDecimalType{ diff --git a/types/parser/type_parser_test.go b/types/parser/type_parser_test.go index ddc600b..ba09bd6 100644 --- a/types/parser/type_parser_test.go +++ b/types/parser/type_parser_test.go @@ -9,18 +9,18 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/substrait-io/substrait-go/types" - "github.com/substrait-io/substrait-go/types/leaf_parameters" + "github.com/substrait-io/substrait-go/types/integer_parameters" "github.com/substrait-io/substrait-go/types/parser" ) func TestParser(t *testing.T) { - parameterLeaf_L1 := leaf_parameters.NewVariableIntParam("L1") - parameterLeaf_P := leaf_parameters.NewVariableIntParam("P") - parameterLeaf_S := leaf_parameters.NewVariableIntParam("S") - concreteLeaf_5 := leaf_parameters.NewConcreteIntParam(5) - concreteLeaf_38 := leaf_parameters.NewConcreteIntParam(38) - concreteLeaf_10 := leaf_parameters.NewConcreteIntParam(10) - concreteLeaf_EMinus5 := leaf_parameters.NewConcreteIntParam(int32(types.PrecisionEMinus5Seconds)) + parameterLeaf_L1 := integer_parameters.NewVariableIntParam("L1") + parameterLeaf_P := integer_parameters.NewVariableIntParam("P") + parameterLeaf_S := integer_parameters.NewVariableIntParam("S") + concreteLeaf_5 := integer_parameters.NewConcreteIntParam(5) + concreteLeaf_38 := integer_parameters.NewConcreteIntParam(38) + concreteLeaf_10 := integer_parameters.NewConcreteIntParam(10) + concreteLeaf_EMinus5 := integer_parameters.NewConcreteIntParam(int32(types.PrecisionEMinus5Seconds)) tests := []struct { expr string expected string diff --git a/types/types.go b/types/types.go index c68e9ef..25f05f5 100644 --- a/types/types.go +++ b/types/types.go @@ -374,7 +374,11 @@ type ( // CompositeType this represents a concrete type having components CompositeType interface { Type + // ParameterString this returns parameter string + // for e.g. parameter decimal, ParameterString returns "P,S" ParameterString() string + // BaseString this returns long name for parameter string + // for e.g. parameter decimal, BaseString returns "decimal" BaseString() string } @@ -382,8 +386,13 @@ type ( // These type can't be present in plan (not serializable) FuncDefArgType interface { fmt.Stringer + //SetNullability set nullability as given argument SetNullability(Nullability) FuncDefArgType + // HasParameterizedParam returns true if the type has at least one parameterized parameters + // if all parameters are concrete then it returns false HasParameterizedParam() bool + // GetParameterizedParams returns all parameterized parameters + // it doesn't return concrete parameters GetParameterizedParams() []interface{} } @@ -656,11 +665,11 @@ type ( FixedCharType = FixedLenType[FixedChar] VarCharType = FixedLenType[VarChar] FixedBinaryType = FixedLenType[FixedBinary] - ParameterizedVarCharType = parameterizedTypeSingleIntegerParam[VarCharType] - ParameterizedFixedCharType = parameterizedTypeSingleIntegerParam[FixedCharType] - ParameterizedFixedBinaryType = parameterizedTypeSingleIntegerParam[FixedBinaryType] - ParameterizedPrecisionTimestampType = parameterizedTypeSingleIntegerParam[PrecisionTimestampType] - ParameterizedPrecisionTimestampTzType = parameterizedTypeSingleIntegerParam[PrecisionTimestampTzType] + ParameterizedVarCharType = parameterizedTypeSingleIntegerParam[*VarCharType] + ParameterizedFixedCharType = parameterizedTypeSingleIntegerParam[*FixedCharType] + ParameterizedFixedBinaryType = parameterizedTypeSingleIntegerParam[*FixedBinaryType] + ParameterizedPrecisionTimestampType = parameterizedTypeSingleIntegerParam[*PrecisionTimestampType] + ParameterizedPrecisionTimestampTzType = parameterizedTypeSingleIntegerParam[*PrecisionTimestampTzType] ) // FixedLenType is any of the types which also need to track their specific