feat: Add support for more PostgreSQL data types (#19)

This commit adds support for several new PostgreSQL data types to the pgtalk library.

The following data types are now supported:
- money
- xml
- real
- smallint
- time without time zone
- character
- line
- lseg
- box
- path
- polygon
- circle
- cidr
- inet
- macaddr
- bit
- bit varying

This change includes:
- New mappings in `cmd/pgtalk-gen/mapping.go`.
- A new accessor for `smallint` in `access_int16.go`.
- New conversion functions in `convert/convert.go`.
- A new test table `new_types` in `test/main_test.go` to test the new data types.
- The generated code for the new test table.
- Removal of an obsolete `mapping.json` file from the test directory.

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>

Author: emicklei

access_int16.go

@@ -0,0 +1,99 @@
+package pgtalk
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jackc/pgx/v5/pgtype"
+)
+
+// int16Access can Read a column value (int2) and Write a column value and Set a struct field (int16).
+type int16Access struct {
+	unimplementedBooleanExpression
+	ColumnInfo
+	fieldWriter   fieldAccessFunc
+	valueToInsert int16
+}
+
+func NewInt16Access(
+	info ColumnInfo,
+	valueWriter func(dest any) any) int16Access {
+	return int16Access{
+		ColumnInfo:  info,
+		fieldWriter: valueWriter}
+}
+
+func (a int16Access) BetweenAnd(begin int16, end int16) betweenAnd {
+	return makeBetweenAnd(a, valuePrinter{v: begin}, valuePrinter{v: end})
+}
+
+func (a int16Access) FieldValueToScan(entity any) any {
+	return a.fieldWriter(entity)
+}
+
+func (a int16Access) ValueToInsert() any {
+	return a.valueToInsert
+}
+
+func (a int16Access) Set(v int16) int16Access {
+	a.valueToInsert = v
+	return a
+}
+
+func (a int16Access) In(values ...int16) SQLExpression {
+	if len(values) == 0 {
+		return makeConstantExpression(false)
+	}
+	vs := make([]any, len(values))
+	for i := 0; i < len(values); i++ {
+		vs[i] = values[i]
+	}
+	return makeBinaryOperator(a, "IN", valuesPrinter{vs: vs})
+}
+
+func (a int16Access) Equals(intLike any) SQLExpression {
+	if i, ok := intLike.(int); ok {
+		return makeBinaryOperator(a, "=", valuePrinter{v: i})
+	}
+	if i, ok := intLike.(int16); ok {
+		return makeBinaryOperator(a, "=", valuePrinter{v: i})
+	}
+	if ia, ok := intLike.(int16Access); ok {
+		return makeBinaryOperator(a, "=", ia)
+	}
+	if p, ok := intLike.(*QueryParameter); ok {
+		return makeBinaryOperator(a, "=", p)
+	}
+	if p, ok := intLike.(FieldAccess[pgtype.Int2]); ok {
+		return makeBinaryOperator(a, "=", p)
+	}
+	panic(fmt.Sprintf("int, int16, Int16Access or *QueryParameter expected, got %T", intLike))
+}
+
+func (a int16Access) Compare(op string, i int) binaryExpression {
+	if !strings.Contains(validComparisonOperators, op) {
+		panic("invalid comparison operator:" + op)
+	}
+	return makeBinaryOperator(a, op, valuePrinter{v: i})
+}
+
+func (a int16Access) Column() ColumnInfo { return a.ColumnInfo }
+
+func (a int16Access) TableAlias(alias string) int16Access {
+	a.ColumnInfo = a.ColumnInfo.TableAlias(alias)
+	return a
+}
+
+// AppendScannable is part of ColumnAccessor
+func (a int16Access) AppendScannable(list []any) []any {
+	return append(list, &a.valueToInsert)
+}
+
+// Get returns the value for its columnName from a map (row).
+func (a int16Access) Get(values map[string]any) any {
+	v, ok := values[a.columnName]
+	if !ok {
+		return int16(0)
+	}
+	return v
+}

cmd/pgtalk-gen/mapping.go

@@ -94,6 +94,59 @@ func (m mapping) validate() error {
 
 // https://www.postgresql.org/docs/9.1/datatype-numeric.html
 var pgMappings = map[string]mapping{
+	"money": {
+		goFieldType:         "pgtype.Money",
+		nullableGoFieldType: "pgtype.Money",
+		newAccessFuncCall:   "p.NewFieldAccess[pgtype.Money]",
+	},
+	"xml": {
+		goFieldType:         "pgtype.XML",
+		nullableGoFieldType: "pgtype.XML",
+		newAccessFuncCall:   "p.NewFieldAccess[pgtype.XML]",
+	},
+	"real": {
+		goFieldType:         "float32",
+		nullableGoFieldType: "pgtype.Float4",
+		newAccessFuncCall:   "p.NewFieldAccess[pgtype.Float4]",
+	},
+	"cidr": {
+		nullableGoFieldType: "pgtype.CIDR",
+		newAccessFuncCall:   "p.NewFieldAccess[pgtype.CIDR]",
+	},
+	"inet": {
+		nullableGoFieldType: "pgtype.Inet",
+		newAccessFuncCall:   "p.NewFieldAccess[pgtype.Inet]",
+	},
+	"macaddr": {
+		nullableGoFieldType: "pgtype.Macaddr",
+		newAccessFuncCall:   "p.NewFieldAccess[pgtype.Macaddr]",
+	},
+	"bit": {
+		nullableGoFieldType: "pgtype.Bit",
+		newAccessFuncCall:   "p.NewFieldAccess[pgtype.Bit]",
+	},
+	"bit varying": {
+		nullableGoFieldType: "pgtype.Varbit",
+		newAccessFuncCall:   "p.NewFieldAccess[pgtype.Varbit]",
+	},
+	"smallint": {
+		goFieldType: "int16",
+		newFuncCall: "p.NewInt16Access",
+
+		nullableValueFieldName: "Int",
+		convertFuncName:        "c.Int16ToInt2",
+		nullableGoFieldType:    "pgtype.Int2",
+		newAccessFuncCall:      "p.NewFieldAccess[pgtype.Int2]",
+	},
+	"time without time zone": {
+		goFieldType: "time.Time",
+		newFuncCall: "p.NewTimeAccess",
+
+		nullableValueFieldName: "Time",
+		convertFuncName:        "c.TimeToTime",
+		nullableGoFieldType:    "pgtype.Time",
+		newAccessFuncCall:      "p.NewFieldAccess[pgtype.Time]",
+	},
 	"timestamp with time zone": {
 		goFieldType: "time.Time",
 		newFuncCall: "p.NewTimeAccess",
@@ -130,6 +183,15 @@ var pgMappings = map[string]mapping{
 		nullableGoFieldType:    "pgtype.Text",
 		newAccessFuncCall:      "p.NewFieldAccess[pgtype.Text]",
 	},
+	"character": {
+		goFieldType: "string",
+		newFuncCall: "p.NewTextAccess",
+
+		nullableValueFieldName: "String",
+		convertFuncName:        "c.StringToText",
+		nullableGoFieldType:    "pgtype.Text",
+		newAccessFuncCall:      "p.NewFieldAccess[pgtype.Text]",
+	},
 	"text": {
 		goFieldType: "string",
 		newFuncCall: "p.NewTextAccess",
@@ -229,4 +291,28 @@ var pgMappings = map[string]mapping{
 		nullableGoFieldType: "pgtype.Interval",
 		newAccessFuncCall:   "p.NewFieldAccess[pgtype.Interval]",
 	},
+	"line": {
+		nullableGoFieldType: "pgtype.Line",
+		newAccessFuncCall:   "p.NewFieldAccess[pgtype.Line]",
+	},
+	"lseg": {
+		nullableGoFieldType: "pgtype.Lseg",
+		newAccessFuncCall:   "p.NewFieldAccess[pgtype.Lseg]",
+	},
+	"box": {
+		nullableGoFieldType: "pgtype.Box",
+		newAccessFuncCall:   "p.NewFieldAccess[pgtype.Box]",
+	},
+	"path": {
+		nullableGoFieldType: "pgtype.Path",
+		newAccessFuncCall:   "p.NewFieldAccess[pgtype.Path]",
+	},
+	"polygon": {
+		nullableGoFieldType: "pgtype.Polygon",
+		newAccessFuncCall:   "p.NewFieldAccess[pgtype.Polygon]",
+	},
+	"circle": {
+		nullableGoFieldType: "pgtype.Circle",
+		newAccessFuncCall:   "p.NewFieldAccess[pgtype.Circle]",
+	},
 }

convert/convert.go

@@ -74,6 +74,14 @@ func TimeToDate(t time.Time) pgtype.Date {
 	return pgtype.Date{Time: t, Valid: true}
 }
 
+func TimeToTime(t time.Time) pgtype.Time {
+	return pgtype.Time{Microseconds: t.UnixMicro(), Valid: true}
+}
+
+func Int16ToInt2(i int16) pgtype.Int2 {
+	return pgtype.Int2{Int16: i, Valid: true}
+}
+
 func StringToText(s string) pgtype.Text {
 	return pgtype.Text{String: s, Valid: true}
 }

test/main_test.go

@@ -75,7 +75,29 @@ func ensureTables(conn *pgx.Conn) error {
 		id serial primary key,
 		title character varying(255),
 		title_tokens tsvector
-	);`)
+	);
+	drop table IF EXISTS new_types;
+	create table new_types(
+		id serial primary key,
+		a_smallint smallint,
+		a_real real,
+		a_time time,
+		a_xml xml,
+		a_money money,
+		a_char char(4),
+		a_line line,
+		a_lseg lseg,
+		a_box box,
+		a_path path,
+		a_polygon polygon,
+		a_circle circle,
+		a_cidr cidr,
+		a_inet inet,
+		a_macaddr macaddr,
+		a_bit bit(8),
+		a_varbit bit varying(8)
+	);
+	`)
 	if err != nil {
 		tx.Rollback(ctx)
 		return err