diff --git a/golden_test.go b/golden_test.go index b31c854..46c1428 100644 --- a/golden_test.go +++ b/golden_test.go @@ -52,6 +52,10 @@ var goldenGQLGen = []Golden{ {"primeGQLGen", primeGQLGenIn}, } +var goldenIntGQLGen = []Golden{ + {"primeIntSql", primeGQLGenIn}, +} + var goldenJSONAndSQL = []Golden{ {"primeJsonAndSql", primeJsonAndSqlIn}, } @@ -377,6 +381,12 @@ func TestGolden(t *testing.T) { transformMethod: "noop", }) } + for _, test := range goldenIntGQLGen { + runGoldenTest(t, test, generateOptions{ + includeIntSQL: true, + transformMethod: "noop", + }) + } for _, test := range goldenTrimPrefix { runGoldenTest(t, test, generateOptions{ trimPrefix: "Day", diff --git a/intsql.go b/intsql.go new file mode 100644 index 0000000..bab28a7 --- /dev/null +++ b/intsql.go @@ -0,0 +1,95 @@ +package main + +// Arguments to format are: [1]: type name +const intValueMethod = `func (i %[1]s) Value() (driver.Value, error) { + return int64(i), nil +} +` + +const intScanMethod = ` +var err%[1]sNilPtr = fmt.Errorf("nil pointer") + +func (i *%[1]s) Scan(value interface{}) (err error) { + if value == nil { + *i = %[1]s(0) + return + } + + switch v := value.(type) { + case int64: + *i = %[1]s(v) + case string: + var val int + // try parsing the integer value as a string + val, err = strconv.Atoi(v) + if err == nil { + *i = %[1]s(val) + } + case []byte: + var val int + val, err = strconv.Atoi(string(v)) + if err == nil { + *i = %[1]s(val) + } + case %[1]s: + *i = v + case int: + *i = %[1]s(v) + case *%[1]s: + if v == nil { + return err%[1]sNilPtr + } + *i = *v + case uint: + *i = %[1]s(v) + case uint64: + *i = %[1]s(v) + case *int: + if v == nil { + return err%[1]sNilPtr + } + *i = %[1]s(*v) + case *int64: + if v == nil { + return err%[1]sNilPtr + } + *i = %[1]s(*v) + case float64: + *i = %[1]s(v) + case *float64: + if v == nil { + return err%[1]sNilPtr + } + *i = %[1]s(*v) + case *uint: + if v == nil { + return err%[1]sNilPtr + } + *i = %[1]s(*v) + case *uint64: + if v == nil { + return err%[1]sNilPtr + } + *i = %[1]s(*v) + case *string: + if v == nil { + return err%[1]sNilPtr + } + var val int + // try parsing the integer value as a string + val, err = strconv.Atoi(*v) + if err == nil { + *i, err = %[1]s(val), nil + } + } + + return +} +` + +func (g *Generator) addIntValueAndScanMethod(typeName string) { + g.Printf("\n") + g.Printf(intValueMethod, typeName) + g.Printf("\n\n") + g.Printf(intScanMethod, typeName) +} diff --git a/stringer.go b/stringer.go index 807e673..bd6e0ee 100644 --- a/stringer.go +++ b/stringer.go @@ -47,6 +47,7 @@ type generateOptions struct { includeJSON bool includeYAML bool includeSQL bool + includeIntSQL bool includeText bool includeGQLGen bool transformMethod string @@ -70,6 +71,7 @@ func init() { flag.StringVar(&typeNames, "type", "", "comma-separated list of type names; must be set") flag.BoolVar(&opts.includeSQL, "sql", false, "if true, the Scanner and Valuer interface will be implemented.") + flag.BoolVar(&opts.includeIntSQL, "intsql", false, "if true, the Scanner and Valuer interface will be implemented with storing as integer") flag.BoolVar(&opts.includeJSON, "json", false, "if true, json marshaling methods will be generated. Default: false") flag.BoolVar(&opts.includeYAML, "yaml", false, "if true, yaml marshaling methods will be generated. Default: false") flag.BoolVar(&opts.includeText, "text", false, "if true, text marshaling methods will be generated. Default: false") @@ -148,9 +150,12 @@ func main() { } g.Printf("\t\"fmt\"\n") g.Printf("\t\"strings\"\n") - if opts.includeSQL { + if opts.includeSQL || opts.includeIntSQL { g.Printf("\t\"database/sql/driver\"\n") } + if opts.includeIntSQL { + g.Printf("\t\"strconv\"\n") + } if opts.includeJSON { g.Printf("\t\"encoding/json\"\n") } @@ -506,6 +511,9 @@ func (g *Generator) generate(typeName string, opts generateOptions) { if opts.includeSQL { g.addValueAndScanMethod(typeName) } + if opts.includeIntSQL { + g.addIntValueAndScanMethod(typeName) + } if opts.includeGQLGen { g.buildGQLGenMethods(runs, typeName) } diff --git a/testdata/primeIntSql.golden b/testdata/primeIntSql.golden new file mode 100644 index 0000000..964eafb --- /dev/null +++ b/testdata/primeIntSql.golden @@ -0,0 +1,206 @@ + +const _PrimeName = "p2p3p5p7p11p13p17p19p23p29p37p41p43" +const _PrimeLowerName = "p2p3p5p7p11p13p17p19p23p29p37p41p43" + +var _PrimeMap = map[Prime]string{ + 2: _PrimeName[0:2], + 3: _PrimeName[2:4], + 5: _PrimeName[4:6], + 7: _PrimeName[6:8], + 11: _PrimeName[8:11], + 13: _PrimeName[11:14], + 17: _PrimeName[14:17], + 19: _PrimeName[17:20], + 23: _PrimeName[20:23], + 29: _PrimeName[23:26], + 31: _PrimeName[26:29], + 41: _PrimeName[29:32], + 43: _PrimeName[32:35], +} + +func (i Prime) String() string { + if str, ok := _PrimeMap[i]; ok { + return str + } + return fmt.Sprintf("Prime(%d)", i) +} + +// An "invalid array index" compiler error signifies that the constant values have changed. +// Re-run the stringer command to generate them again. +func _PrimeNoOp() { + var x [1]struct{} + _ = x[p2-(2)] + _ = x[p3-(3)] + _ = x[p5-(5)] + _ = x[p7-(7)] + _ = x[p11-(11)] + _ = x[p13-(13)] + _ = x[p17-(17)] + _ = x[p19-(19)] + _ = x[p23-(23)] + _ = x[p29-(29)] + _ = x[p37-(31)] + _ = x[p41-(41)] + _ = x[p43-(43)] +} + +var _PrimeValues = []Prime{p2, p3, p5, p7, p11, p13, p17, p19, p23, p29, p37, p41, p43} + +var _PrimeNameToValueMap = map[string]Prime{ + _PrimeName[0:2]: p2, + _PrimeLowerName[0:2]: p2, + _PrimeName[2:4]: p3, + _PrimeLowerName[2:4]: p3, + _PrimeName[4:6]: p5, + _PrimeLowerName[4:6]: p5, + _PrimeName[6:8]: p7, + _PrimeLowerName[6:8]: p7, + _PrimeName[8:11]: p11, + _PrimeLowerName[8:11]: p11, + _PrimeName[11:14]: p13, + _PrimeLowerName[11:14]: p13, + _PrimeName[14:17]: p17, + _PrimeLowerName[14:17]: p17, + _PrimeName[17:20]: p19, + _PrimeLowerName[17:20]: p19, + _PrimeName[20:23]: p23, + _PrimeLowerName[20:23]: p23, + _PrimeName[23:26]: p29, + _PrimeLowerName[23:26]: p29, + _PrimeName[26:29]: p37, + _PrimeLowerName[26:29]: p37, + _PrimeName[29:32]: p41, + _PrimeLowerName[29:32]: p41, + _PrimeName[32:35]: p43, + _PrimeLowerName[32:35]: p43, +} + +var _PrimeNames = []string{ + _PrimeName[0:2], + _PrimeName[2:4], + _PrimeName[4:6], + _PrimeName[6:8], + _PrimeName[8:11], + _PrimeName[11:14], + _PrimeName[14:17], + _PrimeName[17:20], + _PrimeName[20:23], + _PrimeName[23:26], + _PrimeName[26:29], + _PrimeName[29:32], + _PrimeName[32:35], +} + +// PrimeString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func PrimeString(s string) (Prime, error) { + if val, ok := _PrimeNameToValueMap[s]; ok { + return val, nil + } + + if val, ok := _PrimeNameToValueMap[strings.ToLower(s)]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to Prime values", s) +} + +// PrimeValues returns all values of the enum +func PrimeValues() []Prime { + return _PrimeValues +} + +// PrimeStrings returns a slice of all String values of the enum +func PrimeStrings() []string { + strs := make([]string, len(_PrimeNames)) + copy(strs, _PrimeNames) + return strs +} + +// IsAPrime returns "true" if the value is listed in the enum definition. "false" otherwise +func (i Prime) IsAPrime() bool { + _, ok := _PrimeMap[i] + return ok +} + +func (i Prime) Value() (driver.Value, error) { + return int64(i), nil +} + +var errPrimeNilPtr = fmt.Errorf("nil pointer") + +func (i *Prime) Scan(value interface{}) (err error) { + if value == nil { + *i = Prime(0) + return + } + + switch v := value.(type) { + case int64: + *i = Prime(v) + case string: + var val int + // try parsing the integer value as a string + val, err = strconv.Atoi(v) + if err == nil { + *i = Prime(val) + } + case []byte: + var val int + val, err = strconv.Atoi(string(v)) + if err == nil { + *i = Prime(val) + } + case Prime: + *i = v + case int: + *i = Prime(v) + case *Prime: + if v == nil { + return errPrimeNilPtr + } + *i = *v + case uint: + *i = Prime(v) + case uint64: + *i = Prime(v) + case *int: + if v == nil { + return errPrimeNilPtr + } + *i = Prime(*v) + case *int64: + if v == nil { + return errPrimeNilPtr + } + *i = Prime(*v) + case float64: + *i = Prime(v) + case *float64: + if v == nil { + return errPrimeNilPtr + } + *i = Prime(*v) + case *uint: + if v == nil { + return errPrimeNilPtr + } + *i = Prime(*v) + case *uint64: + if v == nil { + return errPrimeNilPtr + } + *i = Prime(*v) + case *string: + if v == nil { + return errPrimeNilPtr + } + var val int + // try parsing the integer value as a string + val, err = strconv.Atoi(*v) + if err == nil { + *i, err = Prime(val), nil + } + } + + return +}