Gleipnir/jet
4
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Add support for EXTRACT time/date function.

Browse source
This commit is contained in:
go-jet 2022-05-06 11:54:44 +02:00
parent bc776f947b
commit 2101088d0e
15 changed files with 222 additions and 14 deletions
Download patch file Download diff file Expand all files Collapse all files

8
tests/Makefile
View file

@ -32,8 +32,14 @@ init-sqlite:
# jet-gen will call generator on each of the test databases to generate sql builder and model files need to run the tests.
jet-gen-all: install-jet-gen jet-gen-postgres jet-gen-mysql jet-gen-mariadb jet-gen-sqlite
ifeq ($(OS),Windows_NT)
target := jet.exe
else
target := jet
endif
install-jet-gen:
go build -o ${GOPATH}/bin/jet ../cmd/jet/
go build -o ${GOPATH}/bin/${target} ../cmd/jet/
jet-gen-postgres:
jet -dsn=postgres://jet:jet@localhost:50901/jetdb?sslmode=disable -schema=dvds -path=./.gentestdata/

1
tests/init/init.go
View file

@ -30,6 +30,7 @@ func init() {
flag.Parse()
}
// Database names
const (
Postgres = "postgres"
MySql = "mysql"

59
tests/mysql/alltypes_test.go
View file

@ -539,6 +539,8 @@ func TestTimeExpressions(t *testing.T) {
AllTypes.Time.ADD(INTERVAL(20, MINUTE)).SUB(INTERVAL(11, HOUR)),
EXTRACT(DAY_HOUR, AllTypes.Time),
CURRENT_TIME(),
CURRENT_TIME(3),
)
@ -574,6 +576,7 @@ SELECT CAST('20:34:58' AS TIME),
all_types.time - INTERVAL all_types.small_int MINUTE,
all_types.time - INTERVAL 3 MINUTE,
(all_types.time + INTERVAL 20 MINUTE) - INTERVAL 11 HOUR,
EXTRACT(DAY_HOUR FROM all_types.time),
CURRENT_TIME,
CURRENT_TIME(3)
FROM test_sample.all_types;
@ -936,6 +939,62 @@ func TestINTERVAL(t *testing.T) {
require.NoError(t, err)
}
func TestTimeEXTRACT(t *testing.T) {
stmt := SELECT(
EXTRACT(MICROSECOND, TimeT(time.Now())),
EXTRACT(SECOND, AllTypes.Time),
EXTRACT(MINUTE, AllTypes.Timestamp),
EXTRACT(HOUR, AllTypes.Timestamp),
EXTRACT(DAY, AllTypes.Date),
EXTRACT(WEEK, AllTypes.Timestamp),
EXTRACT(MONTH, AllTypes.Timestamp.ADD(INTERVAL(1, DAY))),
EXTRACT(QUARTER, AllTypes.Timestamp),
EXTRACT(YEAR, AllTypes.Timestamp).EQ(Int(1189654)),
EXTRACT(SECOND_MICROSECOND, AllTypes.Time),
EXTRACT(MINUTE_MICROSECOND, AllTypes.DateTime),
EXTRACT(MINUTE_SECOND, AllTypes.Timestamp),
EXTRACT(HOUR_MICROSECOND, AllTypes.Timestamp),
EXTRACT(HOUR_SECOND, AllTypes.Timestamp),
EXTRACT(HOUR_MINUTE, AllTypes.Timestamp),
EXTRACT(DAY_MICROSECOND, AllTypes.Timestamp),
EXTRACT(DAY_SECOND, AllTypes.Timestamp),
EXTRACT(DAY_MINUTE, AllTypes.Timestamp),
EXTRACT(DAY_HOUR, AllTypes.Timestamp),
EXTRACT(YEAR_MONTH, AllTypes.Timestamp),
).FROM(
AllTypes,
)
//fmt.Println(stmt.Sql())
testutils.AssertStatementSql(t, stmt, `
SELECT EXTRACT(MICROSECOND FROM CAST(? AS TIME)),
EXTRACT(SECOND FROM all_types.time),
EXTRACT(MINUTE FROM all_types.timestamp),
EXTRACT(HOUR FROM all_types.timestamp),
EXTRACT(DAY FROM all_types.date),
EXTRACT(WEEK FROM all_types.timestamp),
EXTRACT(MONTH FROM all_types.timestamp + INTERVAL 1 DAY),
EXTRACT(QUARTER FROM all_types.timestamp),
EXTRACT(YEAR FROM all_types.timestamp) = ?,
EXTRACT(SECOND_MICROSECOND FROM all_types.time),
EXTRACT(MINUTE_MICROSECOND FROM all_types.date_time),
EXTRACT(MINUTE_SECOND FROM all_types.timestamp),
EXTRACT(HOUR_MICROSECOND FROM all_types.timestamp),
EXTRACT(HOUR_SECOND FROM all_types.timestamp),
EXTRACT(HOUR_MINUTE FROM all_types.timestamp),
EXTRACT(DAY_MICROSECOND FROM all_types.timestamp),
EXTRACT(DAY_SECOND FROM all_types.timestamp),
EXTRACT(DAY_MINUTE FROM all_types.timestamp),
EXTRACT(DAY_HOUR FROM all_types.timestamp),
EXTRACT(YEAR_MONTH FROM all_types.timestamp)
FROM test_sample.all_types;
`)
err := stmt.Query(db, &struct{}{})
require.NoError(t, err)
}
func TestAllTypesInsert(t *testing.T) {
tx, err := db.Begin()
require.NoError(t, err)

64
tests/postgres/alltypes_test.go
View file

@ -899,9 +899,9 @@ func TestTimeExpression(t *testing.T) {
NOW(),
)
//fmt.Println(query.DebugSql())
// fmt.Println(query.DebugSql())
dest := []struct{}{}
var dest []struct{}
err := query.Query(db, &dest)
require.NoError(t, err)
@ -963,6 +963,66 @@ func TestInterval(t *testing.T) {
requireLogged(t, stmt)
}
func TestTimeEXTRACT(t *testing.T) {
stmt := SELECT(
EXTRACT(CENTURY, AllTypes.Timestampz),
EXTRACT(DAY, AllTypes.Timestamp),
EXTRACT(DECADE, AllTypes.Date),
EXTRACT(DOW, AllTypes.TimestampzPtr),
EXTRACT(DOY, DateT(time.Now())),
EXTRACT(EPOCH, TimestampT(time.Now())),
EXTRACT(HOUR, AllTypes.Time.ADD(INTERVAL(1, HOUR))),
EXTRACT(ISODOW, AllTypes.Timestampz),
EXTRACT(ISOYEAR, AllTypes.Timestampz),
EXTRACT(JULIAN, AllTypes.Timestampz).EQ(Float(3456.123)),
EXTRACT(MICROSECOND, AllTypes.Timestampz),
EXTRACT(MILLENNIUM, AllTypes.Timestampz),
EXTRACT(MILLISECOND, AllTypes.Timez),
EXTRACT(MINUTE, INTERVAL(1, HOUR, 2, MINUTE)),
EXTRACT(MONTH, AllTypes.Timestampz),
EXTRACT(QUARTER, AllTypes.Timestampz),
EXTRACT(SECOND, AllTypes.Timestampz),
EXTRACT(TIMEZONE, AllTypes.Timestampz),
EXTRACT(TIMEZONE_HOUR, AllTypes.Timestampz),
EXTRACT(TIMEZONE_MINUTE, AllTypes.Timestampz),
EXTRACT(WEEK, AllTypes.Timestampz),
EXTRACT(YEAR, AllTypes.Timestampz),
).FROM(
AllTypes,
)
// fmt.Println(stmt.Sql())
testutils.AssertStatementSql(t, stmt, `
SELECT EXTRACT(CENTURY FROM all_types.timestampz),
EXTRACT(DAY FROM all_types.timestamp),
EXTRACT(DECADE FROM all_types.date),
EXTRACT(DOW FROM all_types.timestampz_ptr),
EXTRACT(DOY FROM $1::date),
EXTRACT(EPOCH FROM $2::timestamp without time zone),
EXTRACT(HOUR FROM all_types.time + INTERVAL '1 HOUR'),
EXTRACT(ISODOW FROM all_types.timestampz),
EXTRACT(ISOYEAR FROM all_types.timestampz),
EXTRACT(JULIAN FROM all_types.timestampz) = $3,
EXTRACT(MICROSECOND FROM all_types.timestampz),
EXTRACT(MILLENNIUM FROM all_types.timestampz),
EXTRACT(MILLISECOND FROM all_types.timez),
EXTRACT(MINUTE FROM INTERVAL '1 HOUR 2 MINUTE'),
EXTRACT(MONTH FROM all_types.timestampz),
EXTRACT(QUARTER FROM all_types.timestampz),
EXTRACT(SECOND FROM all_types.timestampz),
EXTRACT(TIMEZONE FROM all_types.timestampz),
EXTRACT(TIMEZONE_HOUR FROM all_types.timestampz),
EXTRACT(TIMEZONE_MINUTE FROM all_types.timestampz),
EXTRACT(WEEK FROM all_types.timestampz),
EXTRACT(YEAR FROM all_types.timestampz)
FROM test_sample.all_types;
`)
err := stmt.Query(db, &struct{}{})
require.NoError(t, err)
}
func TestSubQueryColumnReference(t *testing.T) {
type expected struct {
sql string

2
tests/postgres/insert_test.go
View file

@ -380,6 +380,6 @@ func TestInsertWithExecContext(t *testing.T) {
time.Sleep(10 * time.Millisecond)
testutils.ExecuteInTxAndRollback(t, db, func(tx *sql.Tx) {
testutils.AssertExecContextErr(t, stmt, ctx, tx, "context deadline exceeded")
testutils.AssertExecContextErr(ctx, t, stmt, tx, "context deadline exceeded")
})
}

2
tests/postgres/update_test.go
View file

@ -344,7 +344,7 @@ func TestUpdateExecContext(t *testing.T) {
time.Sleep(10 * time.Millisecond)
testutils.AssertExecContextErr(t, updateStmt, ctx, db, "context deadline exceeded")
testutils.AssertExecContextErr(ctx, t, updateStmt, db, "context deadline exceeded")
}
func TestUpdateFrom(t *testing.T) {

2
tests/testdata

@ -1 +1 @@
Subproject commit 895bf5760d055c717df77c3b872af276f34d06f1
Subproject commit 3895a98c275c11840213e05e8d83cde80eeb0a0c