db/expressions_test.go

package db_test

import (
	"testing"

	dbv2 "git.fsdpf.net/go/db"
	"git.fsdpf.net/go/db/exp"
	"github.com/stretchr/testify/suite"
)

type (
	dbv2ExpressionsSuite struct {
		suite.Suite
	}
)

func (ges *dbv2ExpressionsSuite) TestCast() {
	ges.Equal(exp.NewCastExpression(dbv2.C("test"), "string"), dbv2.Cast(dbv2.C("test"), "string"))
}

func (ges *dbv2ExpressionsSuite) TestDoNothing() {
	ges.Equal(exp.NewDoNothingConflictExpression(), dbv2.DoNothing())
}

func (ges *dbv2ExpressionsSuite) TestDoUpdate() {
	ges.Equal(exp.NewDoUpdateConflictExpression("test", dbv2.Record{"a": "b"}), dbv2.DoUpdate("test", dbv2.Record{"a": "b"}))
}

func (ges *dbv2ExpressionsSuite) TestOr() {
	e1 := dbv2.C("a").Eq("b")
	e2 := dbv2.C("b").Eq(2)
	ges.Equal(exp.NewExpressionList(exp.OrType, e1, e2), dbv2.Or(e1, e2))
}

func (ges *dbv2ExpressionsSuite) TestAnd() {
	e1 := dbv2.C("a").Eq("b")
	e2 := dbv2.C("b").Eq(2)
	ges.Equal(exp.NewExpressionList(exp.AndType, e1, e2), dbv2.And(e1, e2))
}

func (ges *dbv2ExpressionsSuite) TestFunc() {
	ges.Equal(exp.NewSQLFunctionExpression("count", dbv2.L("*")), dbv2.Func("count", dbv2.L("*")))
}

func (ges *dbv2ExpressionsSuite) TestDISTINCT() {
	ges.Equal(exp.NewSQLFunctionExpression("DISTINCT", dbv2.I("col")), dbv2.DISTINCT("col"))
}

func (ges *dbv2ExpressionsSuite) TestCOUNT() {
	ges.Equal(exp.NewSQLFunctionExpression("COUNT", dbv2.I("col")), dbv2.COUNT("col"))
}

func (ges *dbv2ExpressionsSuite) TestMIN() {
	ges.Equal(exp.NewSQLFunctionExpression("MIN", dbv2.I("col")), dbv2.MIN("col"))
}

func (ges *dbv2ExpressionsSuite) TestMAX() {
	ges.Equal(exp.NewSQLFunctionExpression("MAX", dbv2.I("col")), dbv2.MAX("col"))
}

func (ges *dbv2ExpressionsSuite) TestAVG() {
	ges.Equal(exp.NewSQLFunctionExpression("AVG", dbv2.I("col")), dbv2.AVG("col"))
}

func (ges *dbv2ExpressionsSuite) TestFIRST() {
	ges.Equal(exp.NewSQLFunctionExpression("FIRST", dbv2.I("col")), dbv2.FIRST("col"))
}

func (ges *dbv2ExpressionsSuite) TestLAST() {
	ges.Equal(exp.NewSQLFunctionExpression("LAST", dbv2.I("col")), dbv2.LAST("col"))
}

func (ges *dbv2ExpressionsSuite) TestSUM() {
	ges.Equal(exp.NewSQLFunctionExpression("SUM", dbv2.I("col")), dbv2.SUM("col"))
}

func (ges *dbv2ExpressionsSuite) TestCOALESCE() {
	ges.Equal(exp.NewSQLFunctionExpression("COALESCE", dbv2.I("col"), nil), dbv2.COALESCE(dbv2.I("col"), nil))
}

func (ges *dbv2ExpressionsSuite) TestROW_NUMBER() {
	ges.Equal(exp.NewSQLFunctionExpression("ROW_NUMBER"), dbv2.ROW_NUMBER())
}

func (ges *dbv2ExpressionsSuite) TestRANK() {
	ges.Equal(exp.NewSQLFunctionExpression("RANK"), dbv2.RANK())
}

func (ges *dbv2ExpressionsSuite) TestDENSE_RANK() {
	ges.Equal(exp.NewSQLFunctionExpression("DENSE_RANK"), dbv2.DENSE_RANK())
}

func (ges *dbv2ExpressionsSuite) TestPERCENT_RANK() {
	ges.Equal(exp.NewSQLFunctionExpression("PERCENT_RANK"), dbv2.PERCENT_RANK())
}

func (ges *dbv2ExpressionsSuite) TestCUME_DIST() {
	ges.Equal(exp.NewSQLFunctionExpression("CUME_DIST"), dbv2.CUME_DIST())
}

func (ges *dbv2ExpressionsSuite) TestNTILE() {
	ges.Equal(exp.NewSQLFunctionExpression("NTILE", 1), dbv2.NTILE(1))
}

func (ges *dbv2ExpressionsSuite) TestFIRST_VALUE() {
	ges.Equal(exp.NewSQLFunctionExpression("FIRST_VALUE", dbv2.I("col")), dbv2.FIRST_VALUE("col"))
}

func (ges *dbv2ExpressionsSuite) TestLAST_VALUE() {
	ges.Equal(exp.NewSQLFunctionExpression("LAST_VALUE", dbv2.I("col")), dbv2.LAST_VALUE("col"))
}

func (ges *dbv2ExpressionsSuite) TestNTH_VALUE() {
	ges.Equal(exp.NewSQLFunctionExpression("NTH_VALUE", dbv2.I("col"), 1), dbv2.NTH_VALUE("col", 1))
	ges.Equal(exp.NewSQLFunctionExpression("NTH_VALUE", dbv2.I("col"), 1), dbv2.NTH_VALUE(dbv2.C("col"), 1))
}

func (ges *dbv2ExpressionsSuite) TestI() {
	ges.Equal(exp.NewIdentifierExpression("s", "t", "c"), dbv2.I("s.t.c"))
}

func (ges *dbv2ExpressionsSuite) TestC() {
	ges.Equal(exp.NewIdentifierExpression("", "", "c"), dbv2.C("c"))
}

func (ges *dbv2ExpressionsSuite) TestS() {
	ges.Equal(exp.NewIdentifierExpression("s", "", ""), dbv2.S("s"))
}

func (ges *dbv2ExpressionsSuite) TestT() {
	ges.Equal(exp.NewIdentifierExpression("", "t", ""), dbv2.T("t"))
}

func (ges *dbv2ExpressionsSuite) TestW() {
	ges.Equal(exp.NewWindowExpression(nil, nil, nil, nil), dbv2.W())
	ges.Equal(exp.NewWindowExpression(dbv2.I("a"), nil, nil, nil), dbv2.W("a"))
	ges.Equal(exp.NewWindowExpression(dbv2.I("a"), dbv2.I("b"), nil, nil), dbv2.W("a", "b"))
	ges.Equal(exp.NewWindowExpression(dbv2.I("a"), dbv2.I("b"), nil, nil), dbv2.W("a", "b", "c"))
}

func (ges *dbv2ExpressionsSuite) TestOn() {
	ges.Equal(exp.NewJoinOnCondition(dbv2.Ex{"a": "b"}), dbv2.On(dbv2.Ex{"a": "b"}))
}

func (ges *dbv2ExpressionsSuite) TestUsing() {
	ges.Equal(exp.NewJoinUsingCondition("a", "b"), dbv2.Using("a", "b"))
}

func (ges *dbv2ExpressionsSuite) TestL() {
	ges.Equal(exp.NewLiteralExpression("? + ?", 1, 2), dbv2.L("? + ?", 1, 2))
}

func (ges *dbv2ExpressionsSuite) TestLiteral() {
	ges.Equal(exp.NewLiteralExpression("? + ?", 1, 2), dbv2.Literal("? + ?", 1, 2))
}

func (ges *dbv2ExpressionsSuite) TestV() {
	ges.Equal(exp.NewLiteralExpression("?", "a"), dbv2.V("a"))
}

func (ges *dbv2ExpressionsSuite) TestRange() {
	ges.Equal(exp.NewRangeVal("a", "b"), dbv2.Range("a", "b"))
}

func (ges *dbv2ExpressionsSuite) TestStar() {
	ges.Equal(exp.NewLiteralExpression("*"), dbv2.Star())
}

func (ges *dbv2ExpressionsSuite) TestDefault() {
	ges.Equal(exp.Default(), dbv2.Default())
}

func (ges *dbv2ExpressionsSuite) TestLateral() {
	ds := dbv2.From("test")
	ges.Equal(exp.NewLateralExpression(ds), dbv2.Lateral(ds))
}

func (ges *dbv2ExpressionsSuite) TestAny() {
	ds := dbv2.From("test").Select("id")
	ges.Equal(exp.NewSQLFunctionExpression("ANY ", ds), dbv2.Any(ds))
}

func (ges *dbv2ExpressionsSuite) TestAll() {
	ds := dbv2.From("test").Select("id")
	ges.Equal(exp.NewSQLFunctionExpression("ALL ", ds), dbv2.All(ds))
}

func TestDbv2Expressions(t *testing.T) {
	suite.Run(t, new(dbv2ExpressionsSuite))
}