From 89e93710aa72e0e51b82cdf9949b0aaa4cb4662d Mon Sep 17 00:00:00 2001 From: go-jet Date: Fri, 17 Oct 2025 13:41:08 +0200 Subject: [PATCH] Additional tests. --- postgres/functions.go | 4 +- postgres/functions_test.go | 39 +++++++ tests/postgres/array_test.go | 56 +++++---- tests/postgres/generator_test.go | 189 +++++++++++++++++++++++++++++++ 4 files changed, 262 insertions(+), 26 deletions(-) diff --git a/postgres/functions.go b/postgres/functions.go index 5907360..14a5bd7 100644 --- a/postgres/functions.go +++ b/postgres/functions.go @@ -394,8 +394,8 @@ func ARRAY_NDIMS[E Expression](arr Array[E]) IntegerExpression { // If the third argument is given, the search begins at that subscript. // The array must be one-dimensional. // Comparisons are done using IS NOT DISTINCT FROM semantics, so it is possible to search for NULL. -func ARRAY_POSITION[E Expression](arr Array[E], elem E, beginAt ...IntegerExpression) IntegerExpression { - return IntExp(Func("ARRAY_POSITION", optionalAppend([]Expression{arr, elem}, beginAt)...)) +func ARRAY_POSITION[E Expression](arr Array[E], elem E, start ...IntegerExpression) IntegerExpression { + return IntExp(Func("ARRAY_POSITION", optionalAppend([]Expression{arr, elem}, start)...)) } // ARRAY_POSITIONS returns an array of the subscripts of all occurrences of the second argument in the array given as first argument. diff --git a/postgres/functions_test.go b/postgres/functions_test.go index c7afea8..06c1d05 100644 --- a/postgres/functions_test.go +++ b/postgres/functions_test.go @@ -1,6 +1,7 @@ package postgres import ( + "github.com/lib/pq" "testing" ) @@ -34,3 +35,41 @@ func TestGENERATE_SERIES(t *testing.T) { "GENERATE_SERIES(NOW(), NOW() + INTERVAL '10 DAY', INTERVAL '2 DAY')", ) } + +func TestArrayFunctions(t *testing.T) { + + intArray := Int32Array(1, 2, 3) + stringArrayColumn := StringArrayColumn("str_arr_col") + + assertSerialize(t, ARRAY_LOWER(intArray), "ARRAY_LOWER($1::integer[])", pq.Int32Array{1, 2, 3}) + assertSerialize(t, ARRAY_DIMS(stringArrayColumn).EQ(String("[1,1]")), + "(ARRAY_DIMS(str_arr_col) = $1::text)", + "[1,1]", + ) + assertSerialize(t, ARRAY_NDIMS(stringArrayColumn).EQ(Int(1)), "(ARRAY_NDIMS(str_arr_col) = $1)", int64(1)) + assertSerialize(t, ARRAY_REVERSE(stringArrayColumn), "ARRAY_REVERSE(str_arr_col)") + assertSerialize(t, ARRAY_SAMPLE(stringArrayColumn, Int(2)).AT(Int(1)).EQ(String("john")), + "(ARRAY_SAMPLE(str_arr_col, $1)[$2] = $3::text)", + int64(2), int64(1), "john", + ) + + assertSerialize(t, ARRAY_SHUFFLE(intArray).AT(Int(2)).EQ(Int(33)), + "(ARRAY_SHUFFLE($1::integer[])[$2] = $3)", + pq.Int32Array{1, 2, 3}, int64(2), int64(33), + ) + + assertSerialize(t, ARRAY_SORT(stringArrayColumn, Bool(true)), + "ARRAY_SORT(str_arr_col, $1::boolean)", + true, + ) + + assertSerialize(t, ARRAY_SORT(stringArrayColumn, Bool(true), Bool(false)), + "ARRAY_SORT(str_arr_col, $1::boolean, $2::boolean)", + true, false, + ) + + assertSerialize(t, TRIM_ARRAY(stringArrayColumn, Int(6)), + "TRIM_ARRAY(str_arr_col, $1)", + int64(6), + ) +} diff --git a/tests/postgres/array_test.go b/tests/postgres/array_test.go index ef13a73..bc2c7d4 100644 --- a/tests/postgres/array_test.go +++ b/tests/postgres/array_test.go @@ -115,8 +115,10 @@ func TestArrayOperations(t *testing.T) { ARRAY_APPEND(SampleArrays.TextArray, String("after")).AS("append"), ARRAY_CAT(SampleArrays.TimeArray, timeArray2).AS("cat"), ARRAY_LENGTH(timezArray2, Int32(1)).AS("length"), - // ARRAY_LOWER(SampleArrays.UUIDArray).AS("lower"), //newer postgres versions - ARRAY_POSITIONS(stringArray, String("text")).AS("position"), + // ARRAY_LOWER(SampleArrays.UUIDArray).AS("lower"), + ARRAY_POSITION(SampleArrays.Int4Array, Int32(30)).AS("position"), + ARRAY_POSITION(SampleArrays.DoubleArray, Float(33.33), Int(1)).AS("position_from"), + ARRAY_POSITIONS(stringArray, String("text")).AS("positions"), ARRAY_PREPEND(String("before"), SampleArrays.TextArray).AS("prepend"), ARRAY_REMOVE(boolArray, Bool(true)).AS("remove"), ARRAY_REPLACE(SampleArrays.VarcharArray, String("hello"), String("hi")).AS("replace"), @@ -172,15 +174,17 @@ SELECT $1::boolean[] AS "bool_array", ARRAY_APPEND(sample_arrays.text_array, $31::text) AS "append", ARRAY_CAT(sample_arrays.time_array, ARRAY[$32::time without time zone,$33::time without time zone]) AS "cat", ARRAY_LENGTH(ARRAY[$34::time with time zone,$35::time with time zone], $36::integer) AS "length", - ARRAY_POSITIONS($37::text[], $38::text) AS "position", - ARRAY_PREPEND($39::text, sample_arrays.text_array) AS "prepend", - ARRAY_REMOVE($40::boolean[], $41::boolean) AS "remove", - ARRAY_REPLACE(sample_arrays.varchar_array, $42::text, $43::text) AS "replace", - ARRAY_TO_STRING(sample_arrays.mood_enum_array, $44::text) AS "to_string", - ARRAY_UPPER(sample_arrays.int8_array, $45) AS "upper", + ARRAY_POSITION(sample_arrays.int4_array, $37::integer) AS "position", + ARRAY_POSITION(sample_arrays.double_array, $38, $39) AS "position_from", + ARRAY_POSITIONS($40::text[], $41::text) AS "positions", + ARRAY_PREPEND($42::text, sample_arrays.text_array) AS "prepend", + ARRAY_REMOVE($43::boolean[], $44::boolean) AS "remove", + ARRAY_REPLACE(sample_arrays.varchar_array, $45::text, $46::text) AS "replace", + ARRAY_TO_STRING(sample_arrays.mood_enum_array, $47::text) AS "to_string", + ARRAY_UPPER(sample_arrays.int8_array, $48) AS "upper", CARDINALITY(sample_arrays.double_array) AS "cardinality" FROM test_sample.sample_arrays -WHERE sample_arrays.bool_array @> $46::boolean[]; +WHERE sample_arrays.bool_array @> $49::boolean[]; `) var dest struct { @@ -218,20 +222,22 @@ WHERE sample_arrays.bool_array @> $46::boolean[]; StringEqAll bool // functions - Append pq.StringArray - Cat pq.StringArray - Dims string - Length int32 - Lower int32 - NDims int32 - Position pq.Int32Array - Prepend pq.StringArray - Remove pq.BoolArray - Replace pq.StringArray - ToString string - Upper int32 - Cardinality int32 - Trim pq.StringArray + Append pq.StringArray + Cat pq.StringArray + Dims string + Length int32 + Lower int32 + NDims int32 + Position *int32 + PositionFrom *int32 + Positions pq.Int32Array + Prepend pq.StringArray + Remove pq.BoolArray + Replace pq.StringArray + ToString string + Upper int32 + Cardinality int32 + Trim pq.StringArray } err := query.Query(db, &dest) @@ -339,7 +345,9 @@ WHERE sample_arrays.bool_array @> $46::boolean[]; "Length": 2, "Lower": 0, "NDims": 0, - "Position": [ + "Position": 3, + "PositionFrom": 3, + "Positions": [ 2 ], "Prepend": [ diff --git a/tests/postgres/generator_test.go b/tests/postgres/generator_test.go index 20d76c1..46626a5 100644 --- a/tests/postgres/generator_test.go +++ b/tests/postgres/generator_test.go @@ -1688,3 +1688,192 @@ func TestCamelCaseModelJsonTag(t *testing.T) { }) } } + +func TestGeneratorTestSample(t *testing.T) { + + err := postgres.GenerateDSN(defaultDSN(), "test_sample", genTestDir2) + require.NoError(t, err) + + modelDir := filepath.Join(testRoot, "/postgres/.gentestdata2/jetdb/test_sample/model/") + tableDir := filepath.Join(testRoot, "/postgres/.gentestdata2/jetdb/test_sample/table/") + + testutils.AssertFileContent(t, modelDir+"/sample_arrays.go", ` +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/lib/pq" +) + +type SampleArrays struct { + ID int32 `+"`sql:\"primary_key\"`"+` + BoolArray *pq.BoolArray + Int2ArrayPtr *pq.StringArray + Int4Array pq.Int32Array + Int8Array pq.Int64Array + NumericArray pq.Float64Array + DecimalArray pq.Float64Array + RealArray pq.Float32Array + DoubleArray pq.Float64Array + TextArray pq.StringArray + VarcharArray pq.StringArray + CharArray pq.StringArray + ByteaArray pq.ByteaArray + DateArray pq.StringArray + TimestampArray *pq.StringArray + TimestamptzArray pq.StringArray + TimeArray pq.StringArray + TimetzArray pq.StringArray + IntervalArray pq.StringArray + UUIDArray pq.StringArray + MoodEnumArray pq.StringArray +} +`) + + testutils.AssertFileContent(t, tableDir+"/sample_arrays.go", ` +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/go-jet/jet/v2/postgres" +) + +var SampleArrays = newSampleArraysTable("test_sample", "sample_arrays", "") + +type sampleArraysTable struct { + postgres.Table + + // Columns + ID postgres.ColumnInteger + BoolArray postgres.ColumnBoolArray + Int2ArrayPtr postgres.ColumnIntegerArray + Int4Array postgres.ColumnIntegerArray + Int8Array postgres.ColumnIntegerArray + NumericArray postgres.ColumnFloatArray + DecimalArray postgres.ColumnFloatArray + RealArray postgres.ColumnFloatArray + DoubleArray postgres.ColumnFloatArray + TextArray postgres.ColumnStringArray + VarcharArray postgres.ColumnStringArray + CharArray postgres.ColumnStringArray + ByteaArray postgres.ColumnByteaArray + DateArray postgres.ColumnDateArray + TimestampArray postgres.ColumnTimestampArray + TimestamptzArray postgres.ColumnTimestampzArray + TimeArray postgres.ColumnTimeArray + TimetzArray postgres.ColumnTimezArray + IntervalArray postgres.ColumnIntervalArray + UUIDArray postgres.ColumnStringArray + MoodEnumArray postgres.ColumnStringArray + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type SampleArraysTable struct { + sampleArraysTable + + EXCLUDED sampleArraysTable +} + +// AS creates new SampleArraysTable with assigned alias +func (a SampleArraysTable) AS(alias string) *SampleArraysTable { + return newSampleArraysTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new SampleArraysTable with assigned schema name +func (a SampleArraysTable) FromSchema(schemaName string) *SampleArraysTable { + return newSampleArraysTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new SampleArraysTable with assigned table prefix +func (a SampleArraysTable) WithPrefix(prefix string) *SampleArraysTable { + return newSampleArraysTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new SampleArraysTable with assigned table suffix +func (a SampleArraysTable) WithSuffix(suffix string) *SampleArraysTable { + return newSampleArraysTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newSampleArraysTable(schemaName, tableName, alias string) *SampleArraysTable { + return &SampleArraysTable{ + sampleArraysTable: newSampleArraysTableImpl(schemaName, tableName, alias), + EXCLUDED: newSampleArraysTableImpl("", "excluded", ""), + } +} + +func newSampleArraysTableImpl(schemaName, tableName, alias string) sampleArraysTable { + var ( + IDColumn = postgres.IntegerColumn("id") + BoolArrayColumn = postgres.BoolArrayColumn("bool_array") + Int2ArrayPtrColumn = postgres.IntegerArrayColumn("int2_array_ptr") + Int4ArrayColumn = postgres.IntegerArrayColumn("int4_array") + Int8ArrayColumn = postgres.IntegerArrayColumn("int8_array") + NumericArrayColumn = postgres.FloatArrayColumn("numeric_array") + DecimalArrayColumn = postgres.FloatArrayColumn("decimal_array") + RealArrayColumn = postgres.FloatArrayColumn("real_array") + DoubleArrayColumn = postgres.FloatArrayColumn("double_array") + TextArrayColumn = postgres.StringArrayColumn("text_array") + VarcharArrayColumn = postgres.StringArrayColumn("varchar_array") + CharArrayColumn = postgres.StringArrayColumn("char_array") + ByteaArrayColumn = postgres.ByteaArrayColumn("bytea_array") + DateArrayColumn = postgres.DateArrayColumn("date_array") + TimestampArrayColumn = postgres.TimestampArrayColumn("timestamp_array") + TimestamptzArrayColumn = postgres.TimestampzArrayColumn("timestamptz_array") + TimeArrayColumn = postgres.TimeArrayColumn("time_array") + TimetzArrayColumn = postgres.TimezArrayColumn("timetz_array") + IntervalArrayColumn = postgres.IntervalArrayColumn("interval_array") + UUIDArrayColumn = postgres.StringArrayColumn("uuid_array") + MoodEnumArrayColumn = postgres.StringArrayColumn("mood_enum_array") + allColumns = postgres.ColumnList{IDColumn, BoolArrayColumn, Int2ArrayPtrColumn, Int4ArrayColumn, Int8ArrayColumn, NumericArrayColumn, DecimalArrayColumn, RealArrayColumn, DoubleArrayColumn, TextArrayColumn, VarcharArrayColumn, CharArrayColumn, ByteaArrayColumn, DateArrayColumn, TimestampArrayColumn, TimestamptzArrayColumn, TimeArrayColumn, TimetzArrayColumn, IntervalArrayColumn, UUIDArrayColumn, MoodEnumArrayColumn} + mutableColumns = postgres.ColumnList{BoolArrayColumn, Int2ArrayPtrColumn, Int4ArrayColumn, Int8ArrayColumn, NumericArrayColumn, DecimalArrayColumn, RealArrayColumn, DoubleArrayColumn, TextArrayColumn, VarcharArrayColumn, CharArrayColumn, ByteaArrayColumn, DateArrayColumn, TimestampArrayColumn, TimestamptzArrayColumn, TimeArrayColumn, TimetzArrayColumn, IntervalArrayColumn, UUIDArrayColumn, MoodEnumArrayColumn} + defaultColumns = postgres.ColumnList{IDColumn, Int4ArrayColumn, Int8ArrayColumn, TextArrayColumn} + ) + + return sampleArraysTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + ID: IDColumn, + BoolArray: BoolArrayColumn, + Int2ArrayPtr: Int2ArrayPtrColumn, + Int4Array: Int4ArrayColumn, + Int8Array: Int8ArrayColumn, + NumericArray: NumericArrayColumn, + DecimalArray: DecimalArrayColumn, + RealArray: RealArrayColumn, + DoubleArray: DoubleArrayColumn, + TextArray: TextArrayColumn, + VarcharArray: VarcharArrayColumn, + CharArray: CharArrayColumn, + ByteaArray: ByteaArrayColumn, + DateArray: DateArrayColumn, + TimestampArray: TimestampArrayColumn, + TimestamptzArray: TimestamptzArrayColumn, + TimeArray: TimeArrayColumn, + TimetzArray: TimetzArrayColumn, + IntervalArray: IntervalArrayColumn, + UUIDArray: UUIDArrayColumn, + MoodEnumArray: MoodEnumArrayColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} +`) +}