Int db store sql methods

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",

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)
+}

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)
 	}

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
+}