jet/tests/mysql/values_test.go

package mysql

import (
	"source.gleipnir.technology/Gleipnir/jet/internal/testutils"
	"github.com/stretchr/testify/require"
	"strings"
	"testing"
	"time"

	. "source.gleipnir.technology/Gleipnir/jet/mysql"

	"source.gleipnir.technology/Gleipnir/jet/v2/tests/.gentestdata/mysql/dvds/model"
	. "source.gleipnir.technology/Gleipnir/jet/v2/tests/.gentestdata/mysql/dvds/table"
)

func TestVALUES(t *testing.T) {
	skipForMariaDB(t)

	valuesTable := VALUES(
		ROW(Int32(1), Int32(2), Float(4.666), Bool(false), String("txt")),
		ROW(Int32(11).ADD(Int32(2)), Int32(22), Float(33.222), Bool(true), String("png")),
		ROW(Int32(11), Int32(22), Float(33.222), Bool(true), NULL),
	).AS("values_table")

	stmt := SELECT(
		valuesTable.AllColumns(),
	).FROM(
		valuesTable,
	)

	testutils.AssertStatementSql(t, stmt, `
SELECT values_table.column_0 AS "column_0",
     values_table.column_1 AS "column_1",
     values_table.column_2 AS "column_2",
     values_table.column_3 AS "column_3",
     values_table.column_4 AS "column_4"
FROM (
          VALUES ROW(?, ?, ?, ?, ?),
                 ROW(? + ?, ?, ?, ?, ?),
                 ROW(?, ?, ?, ?, NULL)
     ) AS values_table;
`)

	var dest []struct {
		Column0 int
		Column1 int
		Column2 float32
		Column3 bool
		Column4 *string
	}

	err := stmt.Query(db, &dest)

	require.NoError(t, err)
	testutils.AssertJSON(t, dest, `
[
	{
		"Column0": 1,
		"Column1": 2,
		"Column2": 4.666,
		"Column3": false,
		"Column4": "txt"
	},
	{
		"Column0": 13,
		"Column1": 22,
		"Column2": 33.222,
		"Column3": true,
		"Column4": "png"
	},
	{
		"Column0": 11,
		"Column1": 22,
		"Column2": 33.222,
		"Column3": true,
		"Column4": null
	}
]
`)
}

func TestVALUES_Join(t *testing.T) {
	skipForMariaDB(t)

	title := StringColumn("title")
	releaseYear := IntegerColumn("ReleaseYear")
	rentalRate := FloatColumn("rental_rate")

	lastUpdate := Timestamp(2007, time.February, 11, 12, 0, 0)

	films := VALUES(
		ROW(String("Chamber Italian"), Int64(117), Int32(2005), Float(5.82), lastUpdate),
		ROW(String("Grosse Wonderful"), Int64(49), Int32(2004), Float(6.242), lastUpdate.ADD(INTERVAL(1, HOUR))),
		ROW(String("Airport Pollock"), Int64(54), Int32(2001), Float(7.22), NULL),
		ROW(String("Bright Encounters"), Int64(73), Int32(2002), Float(8.25), NULL),
		ROW(String("Academy Dinosaur"), Int64(83), Int32(2010), Float(9.22), lastUpdate.SUB(INTERVAL(2, MINUTE))),
	).AS("film_values",
		title, IntegerColumn("length"), releaseYear, rentalRate, TimestampColumn("last_update"))

	stmt := SELECT(
		Film.AllColumns,
		films.AllColumns(),
	).FROM(
		Film.
			INNER_JOIN(films, title.EQ(Film.Title)),
	).WHERE(AND(
		Film.ReleaseYear.GT(releaseYear),
		Film.RentalRate.LT(rentalRate),
	)).ORDER_BY(
		title,
	)

	testutils.AssertDebugStatementSql(t, stmt, strings.ReplaceAll(`
SELECT film.film_id AS "film.film_id",
     film.title AS "film.title",
     film.description AS "film.description",
     film.release_year AS "film.release_year",
     film.language_id AS "film.language_id",
     film.original_language_id AS "film.original_language_id",
     film.rental_duration AS "film.rental_duration",
     film.rental_rate AS "film.rental_rate",
     film.length AS "film.length",
     film.replacement_cost AS "film.replacement_cost",
     film.rating AS "film.rating",
     film.special_features AS "film.special_features",
     film.last_update AS "film.last_update",
     film_values.title AS "title",
     film_values.length AS "length",
     film_values.''ReleaseYear'' AS "ReleaseYear",
     film_values.rental_rate AS "rental_rate",
     film_values.last_update AS "last_update"
FROM dvds.film
     INNER JOIN (
          VALUES ROW('Chamber Italian', 117, 2005, 5.82, TIMESTAMP('2007-02-11 12:00:00')),
                 ROW('Grosse Wonderful', 49, 2004, 6.242, TIMESTAMP('2007-02-11 12:00:00') + INTERVAL 1 HOUR),
                 ROW('Airport Pollock', 54, 2001, 7.22, NULL),
                 ROW('Bright Encounters', 73, 2002, 8.25, NULL),
                 ROW('Academy Dinosaur', 83, 2010, 9.22, TIMESTAMP('2007-02-11 12:00:00') - INTERVAL 2 MINUTE)
     ) AS film_values (title, length, ''ReleaseYear'', rental_rate, last_update) ON (film_values.title = film.title)
WHERE (
          (film.release_year > film_values.''ReleaseYear'')
              AND (film.rental_rate < film_values.rental_rate)
      )
ORDER BY film_values.title;
`, "''", "`"))

	var dest []struct {
		Film model.Film

		Title       string
		Length      int
		ReleaseYear int
		RentalRate  float32
		LastUpdate  *time.Time
	}

	err := stmt.Query(db, &dest)

	require.NoError(t, err)
	require.Len(t, dest, 4)
	testutils.AssertJSON(t, dest[0:2], `
[
	{
		"Film": {
			"FilmID": 8,
			"Title": "AIRPORT POLLOCK",
			"Description": "A Epic Tale of a Moose And a Girl who must Confront a Monkey in Ancient India",
			"ReleaseYear": 2006,
			"LanguageID": 1,
			"OriginalLanguageID": null,
			"RentalDuration": 6,
			"RentalRate": 4.99,
			"Length": 54,
			"ReplacementCost": 15.99,
			"Rating": "R",
			"SpecialFeatures": "Trailers",
			"LastUpdate": "2006-02-15T05:03:42Z"
		},
		"Title": "Airport Pollock",
		"Length": 54,
		"ReleaseYear": 2001,
		"RentalRate": 7.22,
		"LastUpdate": null
	},
	{
		"Film": {
			"FilmID": 98,
			"Title": "BRIGHT ENCOUNTERS",
			"Description": "A Fateful Yarn of a Lumberjack And a Feminist who must Conquer a Student in A Jet Boat",
			"ReleaseYear": 2006,
			"LanguageID": 1,
			"OriginalLanguageID": null,
			"RentalDuration": 4,
			"RentalRate": 4.99,
			"Length": 73,
			"ReplacementCost": 12.99,
			"Rating": "PG-13",
			"SpecialFeatures": "Trailers",
			"LastUpdate": "2006-02-15T05:03:42Z"
		},
		"Title": "Bright Encounters",
		"Length": 73,
		"ReleaseYear": 2002,
		"RentalRate": 8.25,
		"LastUpdate": null
	}
]
`)
}

func TestVALUES_CTE_Update(t *testing.T) {
	skipForMariaDB(t)

	paymentID := IntegerColumn("payment_id")
	increase := FloatColumn("increase")
	paymentsToUpdate := CTE("values_cte", paymentID, increase)

	stmt := WITH(
		paymentsToUpdate.AS(
			VALUES(
				ROW(Int32(204), Float(1.21)),
				ROW(Int32(207), Float(1.02)),
				ROW(Int32(200), Float(1.34)),
				ROW(Int32(203), Float(1.72)),
			),
		),
	)(
		Payment.INNER_JOIN(paymentsToUpdate, paymentID.EQ(Payment.PaymentID)).
			UPDATE().
			SET(
				Payment.Amount.SET(Payment.Amount.MUL(increase)),
			).WHERE(Bool(true)),
	)

	testutils.AssertStatementSql(t, stmt, `
WITH values_cte (payment_id, increase) AS (
     VALUES ROW(?, ?),
            ROW(?, ?),
            ROW(?, ?),
            ROW(?, ?)
)
UPDATE dvds.payment
INNER JOIN values_cte ON (values_cte.payment_id = payment.payment_id)
SET amount = (payment.amount * values_cte.increase)
WHERE ?;
`)

	testutils.AssertExecAndRollback(t, stmt, db, 4)
}

func TestVALUES_MariaDB(t *testing.T) {
	onlyMariaDB(t) // mariadb won't accept values rows if all the elements are placeholders, so we have to use raw statement

	paymentID := IntegerColumn("payment_id")
	increase := FloatColumn("increase")
	paymentsToUpdate := CTE("values_cte", paymentID, increase)

	stmt := WITH(
		paymentsToUpdate.AS(
			RawStatement(`
				 VALUES (204, 1.21),
						(207, 1.02),
						(200, 1.34),
						(203, 1.72)
			`),
		),
	)(
		SELECT(
			Payment.AllColumns,
			paymentsToUpdate.AllColumns(),
		).FROM(
			Payment.
				INNER_JOIN(paymentsToUpdate, paymentID.EQ(Payment.PaymentID)),
		).WHERE(
			increase.GT(Float(1.03)),
		).ORDER_BY(
			increase,
		),
	)

	testutils.AssertStatementSql(t, stmt, `
WITH values_cte (payment_id, increase) AS (
				 VALUES (204, 1.21),
						(207, 1.02),
						(200, 1.34),
						(203, 1.72)
			
)
SELECT payment.payment_id AS "payment.payment_id",
     payment.customer_id AS "payment.customer_id",
     payment.staff_id AS "payment.staff_id",
     payment.rental_id AS "payment.rental_id",
     payment.amount AS "payment.amount",
     payment.payment_date AS "payment.payment_date",
     payment.last_update AS "payment.last_update",
     values_cte.payment_id AS "payment_id",
     values_cte.increase AS "increase"
FROM dvds.payment
     INNER JOIN values_cte ON (values_cte.payment_id = payment.payment_id)
WHERE values_cte.increase > ?
ORDER BY values_cte.increase;
`)

	var dest []struct {
		model.Payment

		Increase float64
	}

	err := stmt.Query(db, &dest)

	require.NoError(t, err)
	testutils.AssertJSON(t, dest, `
[
	{
		"PaymentID": 204,
		"CustomerID": 7,
		"StaffID": 1,
		"RentalID": 13476,
		"Amount": 2.99,
		"PaymentDate": "2005-08-20T01:06:04Z",
		"LastUpdate": "2006-02-15T22:12:31Z",
		"Increase": 1.21
	},
	{
		"PaymentID": 200,
		"CustomerID": 7,
		"StaffID": 2,
		"RentalID": 11542,
		"Amount": 7.99,
		"PaymentDate": "2005-08-17T00:51:32Z",
		"LastUpdate": "2006-02-15T22:12:31Z",
		"Increase": 1.34
	},
	{
		"PaymentID": 203,
		"CustomerID": 7,
		"StaffID": 2,
		"RentalID": 13373,
		"Amount": 2.99,
		"PaymentDate": "2005-08-19T21:23:31Z",
		"LastUpdate": "2006-02-15T22:12:31Z",
		"Increase": 1.72
	}
]
`)
}