Merge pull request #622 from manhrev/feat/sub-query-expression

Add EXISTS, ALL, SOME, ANY expressions

Author: stephenafamo

CHANGELOG.md

@@ -15,6 +15,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added `bob.Each` function to iterate over query results (range-over-func). (thanks @toqueteos)
 - Added support for the `VALUES` statement in MySQL, PostgreSQL, and SQLite. (thanks @manhrev)
 - Added MariaDB compatibility check in gen/bobgen-mysql (thanks @dumdev25)
+- Added `ALL`, `SOME`, `ANY` expressions for MySQL and PostgreSQL dialects. Added `EXISTS` expression for all dialects. (thanks @manhrev)
 
 ### Fixed
 

dialect/mysql/starters.go

@@ -96,7 +96,7 @@ func Raw(query string, args ...any) Expression {
 }
 
 // SQL: CAST(a AS int)
-// Go: psql.Cast("a", "int")
+// Go: mysql.Cast("a", "int")
 func Cast(exp bob.Expression, typname string) Expression {
 	return bmod.Cast(exp, typname)
 }
@@ -106,3 +106,27 @@ func Cast(exp bob.Expression, typname string) Expression {
 func Case() expr.CaseChain[Expression, Expression] {
 	return expr.NewCase[Expression, Expression]()
 }
+
+// SQL: EXISTS ((SELECT 1))
+// Go: mysql.Exists(mysql.Select(sm.Columns("1")))
+func Exists(exp bob.Expression) Expression {
+	return bmod.Exists(exp)
+}
+
+// SQL: - 1 - 2
+// Go: mysql.Minus(mysql.Arg(1)).Minus(mysql.Arg(2))
+func Minus(exp bob.Expression) Expression {
+	return bmod.Minus(exp)
+}
+
+// SQL: a = ANY((SELECT name FROM users))
+// Go: mysql.Quote("a").EQ(mysql.Any(mysql.Select(sm.Columns("name"), sm.From("users"))))
+func Any(exp bob.Expression) bob.Expression {
+	return bmod.Any(exp)
+}
+
+// SQL: a = ALL((SELECT name FROM users))
+// Go: mysql.Quote("a").EQ(mysql.All(mysql.Select(sm.Columns("name"), sm.From("users"))))
+func All(exp bob.Expression) bob.Expression {
+	return bmod.All(exp)
+}

dialect/psql/starters.go

@@ -106,3 +106,27 @@ func Cast(exp bob.Expression, typname string) Expression {
 func Case() expr.CaseChain[Expression, Expression] {
 	return expr.NewCase[Expression, Expression]()
 }
+
+// SQL: EXISTS ((SELECT 1))
+// Go: psql.Exists(psql.Select(sm.Columns("1")))
+func Exists(exp bob.Expression) Expression {
+	return bmod.Exists(exp)
+}
+
+// SQL: - 1 - 2
+// Go: psql.Minus(psql.Arg(1)).Minus(psql.Arg(2))
+func Minus(exp bob.Expression) Expression {
+	return bmod.Minus(exp)
+}
+
+// SQL: a = ANY((SELECT name FROM users))
+// Go: psql.Quote("a").EQ(psql.Any(psql.Select(sm.Columns("name"), sm.From("users"))))
+func Any(exp bob.Expression) bob.Expression {
+	return bmod.Any(exp)
+}
+
+// SQL: a = ALL((SELECT name FROM users))
+// Go: psql.Quote("a").EQ(psql.All(psql.Select(sm.Columns("name"), sm.From("users"))))
+func All(exp bob.Expression) bob.Expression {
+	return bmod.All(exp)
+}

dialect/sqlite/starters.go

@@ -96,7 +96,7 @@ func Raw(query string, args ...any) Expression {
 }
 
 // SQL: CAST(a AS int)
-// Go: psql.Cast("a", "int")
+// Go: sqlite.Cast("a", "int")
 func Cast(exp bob.Expression, typname string) Expression {
 	return bmod.Cast(exp, typname)
 }
@@ -106,3 +106,15 @@ func Cast(exp bob.Expression, typname string) Expression {
 func Case() expr.CaseChain[Expression, Expression] {
 	return expr.NewCase[Expression, Expression]()
 }
+
+// SQL: EXISTS ((SELECT 1))
+// Go: sqlite.Exists(sqlite.Select(sm.Columns("1")))
+func Exists(exp bob.Expression) Expression {
+	return bmod.Exists(exp)
+}
+
+// SQL: - 1 - 2
+// Go: sqlite.Minus(sqlite.Arg(1)).Minus(sqlite.Arg(2))
+func Minus(exp bob.Expression) Expression {
+	return bmod.Minus(exp)
+}

expr/builder.go

@@ -45,6 +45,30 @@ func Not[T bob.Expression, B builder[T]](exp bob.Expression) T {
 	return b.New(Join{Exprs: []bob.Expression{not, X[T, B](exp)}})
 }
 
+// Exists expression
+func Exists[T bob.Expression, B builder[T]](exp bob.Expression) T {
+	var b B
+	return b.New(Join{Exprs: []bob.Expression{exists, group{exp}}})
+}
+
+// prefix the expression with a - (minus)
+func Minus[T bob.Expression, B builder[T]](exp bob.Expression) T {
+	var b B
+	return b.New(Join{Exprs: []bob.Expression{minus, X[T, B](exp)}})
+}
+
+// ANY expression
+func Any[T bob.Expression, B builder[T]](exp bob.Expression) T {
+	var b B
+	return b.New(Join{Exprs: []bob.Expression{anyOp, group{exp}}})
+}
+
+// ALL expression
+func All[T bob.Expression, B builder[T]](exp bob.Expression) T {
+	var b B
+	return b.New(Join{Exprs: []bob.Expression{all, group{exp}}})
+}
+
 // To be embedded in query mods
 // T is the chain type, this allows dialects to have custom chain methods
 // F is function type, so that the dialect can change where it
@@ -107,3 +131,23 @@ func (e Builder[T, B]) Quote(aa ...string) T {
 func (e Builder[T, B]) Cast(exp bob.Expression, typname string) T {
 	return X[T, B](Cast(exp, typname))
 }
+
+// EXISTS expression
+func (e Builder[T, B]) Exists(exp bob.Expression) T {
+	return Exists[T, B](exp)
+}
+
+// prefix the expression with a - (minus)
+func (e Builder[T, B]) Minus(exp bob.Expression) T {
+	return Minus[T, B](exp)
+}
+
+// ANY expression
+func (e Builder[T, B]) Any(exp bob.Expression) T {
+	return Any[T, B](exp)
+}
+
+// ALL expression
+func (e Builder[T, B]) All(exp bob.Expression) T {
+	return All[T, B](exp)
+}

expr/constants.go

@@ -18,4 +18,8 @@ var (
 	notBetween        = Raw("NOT BETWEEN")
 	isDistinctFrom    = Raw("IS DISTINCT FROM")
 	isNotDistinctFrom = Raw("IS NOT DISTINCT FROM")
+	exists            = Raw("EXISTS")
+	minus             = Raw("-")
+	anyOp             = Raw("ANY")
+	all               = Raw("ALL")
 )