Add set operations #402 / More places where Union can be used

buildSrc/src/main/kotlin/org/jetbrains/exposed/gradle/Publishing.kt

@@ -8,15 +8,12 @@ import org.gradle.api.publish.PublishingExtension
 import org.gradle.api.publish.maven.MavenPom
 import org.gradle.api.publish.maven.MavenPublication
 import org.gradle.plugins.signing.SigningExtension
-import io.github.gradlenexus.publishplugin.*
-import org.gradle.api.plugins.JavaPlatformExtension
 import org.gradle.api.plugins.JavaPluginExtension
 
 infix fun <T> Property<T>.by(value: T) {
     set(value)
 }
 
-
 fun MavenPom.configureMavenCentralMetadata(project: Project) {
     name by project.name
     description by "Exposed, an ORM framework for Kotlin"

exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Alias.kt

@@ -56,7 +56,7 @@ class ExpressionAlias<T>(val delegate: Expression<T>, val alias: String) : Expre
     }
 }
 
-class QueryAlias(val query: Query, val alias: String): ColumnSet() {
+class QueryAlias(val query: AbstractQuery<*>, val alias: String): ColumnSet() {
 
     override fun describe(s: Transaction, queryBuilder: QueryBuilder) = queryBuilder{
         append("(")
@@ -96,20 +96,20 @@ class QueryAlias(val query: Query, val alias: String): ColumnSet() {
 }
 
 fun <T:Table> T.alias(alias: String) = Alias(this, alias)
-fun <T:Query> T.alias(alias: String) = QueryAlias(this, alias)
+fun <T:AbstractQuery<*>> T.alias(alias: String) = QueryAlias(this, alias)
 fun <T> Expression<T>.alias(alias: String) = ExpressionAlias(this, alias)
 
-fun Join.joinQuery(on: (SqlExpressionBuilder.(QueryAlias)->Op<Boolean>), joinType: JoinType = JoinType.INNER, joinPart: () -> Query): Join {
+fun Join.joinQuery(on: (SqlExpressionBuilder.(QueryAlias)->Op<Boolean>), joinType: JoinType = JoinType.INNER, joinPart: () -> AbstractQuery<*>): Join {
     val qAlias = joinPart().alias("q${joinParts.count { it.joinPart is QueryAlias }}")
     return join (qAlias, joinType, additionalConstraint =  { on(qAlias) } )
 }
 
-fun Table.joinQuery(on: (SqlExpressionBuilder.(QueryAlias)->Op<Boolean>), joinType: JoinType = JoinType.INNER, joinPart: () -> Query)
+fun Table.joinQuery(on: (SqlExpressionBuilder.(QueryAlias)->Op<Boolean>), joinType: JoinType = JoinType.INNER, joinPart: () -> AbstractQuery<*>)
     = Join(this).joinQuery(on, joinType, joinPart)
 
 val Join.lastQueryAlias: QueryAlias? get() = joinParts.map { it.joinPart as? QueryAlias }.firstOrNull()
 
-fun <T:Any> wrapAsExpression(query: Query) = object : Expression<T?>() {
+fun <T:Any> wrapAsExpression(query: AbstractQuery<*>) = object : Expression<T?>() {
     override fun toQueryBuilder(queryBuilder: QueryBuilder) = queryBuilder {
         append("(")
         query.prepareSQL(this)

exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Exceptions.kt

@@ -1,6 +1,7 @@
 @file:Suppress("PackageDirectoryMismatch")
 package org.jetbrains.exposed.exceptions
 
+import org.jetbrains.exposed.sql.AbstractQuery
 import org.jetbrains.exposed.sql.Query
 import org.jetbrains.exposed.sql.QueryBuilder
 import org.jetbrains.exposed.sql.Transaction
@@ -19,7 +20,7 @@ class ExposedSQLException(cause: Throwable?, val contexts: List<StatementContext
             }
         } catch (e: Throwable) {
             try {
-                (it.statement as? Query)?.prepareSQL(QueryBuilder(!transaction.debug))
+                (it.statement as? AbstractQuery<*>)?.prepareSQL(QueryBuilder(!transaction.debug))
             } catch (e: Throwable) {
                 null
             } ?: "Failed on expanding args for ${it.statement.type}: ${it.statement}"

exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Op.kt

@@ -336,7 +336,7 @@ class NotRegexpOp(expr1: Expression<*>, expr2: Expression<*>) : ComparisonOp(exp
  */
 class exists(
     /** Returns the query being checked. */
-    val query: Query
+    val query: AbstractQuery<*>
 ) : Op<Boolean>() {
     override fun toQueryBuilder(queryBuilder: QueryBuilder): Unit = queryBuilder {
         append("EXISTS (")
@@ -350,7 +350,7 @@ class exists(
  */
 class notExists(
     /** Returns the query being checked. */
-    val query: Query
+    val query: AbstractQuery<*>
 ) : Op<Boolean>() {
     override fun toQueryBuilder(queryBuilder: QueryBuilder): Unit = queryBuilder {
         append("NOT EXISTS (")
@@ -364,7 +364,7 @@ sealed class SubQueryOp<T>(
     /** Returns the expression compared to each row of the query result. */
     val expr: Expression<T>,
     /** Returns the query to check against. */
-    val query: Query
+    val query: AbstractQuery<*>
 ) : Op<Boolean>(), ComplexExpression {
     override fun toQueryBuilder(queryBuilder: QueryBuilder): Unit = queryBuilder {
         append(expr, " $operator (")
@@ -376,22 +376,22 @@ sealed class SubQueryOp<T>(
 /**
  * Represents an SQL operator that checks if [expr] is equals to any row returned from [query].
  */
-class InSubQueryOp<T>(expr: Expression<T>, query: Query) : SubQueryOp<T>("IN", expr, query)
+class InSubQueryOp<T>(expr: Expression<T>, query: AbstractQuery<*>) : SubQueryOp<T>("IN", expr, query)
 
 /**
  * Represents an SQL operator that checks if [expr] is not equals to any row returned from [query].
  */
-class NotInSubQueryOp<T>(expr: Expression<T>, query: Query) : SubQueryOp<T>("NOT IN", expr, query)
+class NotInSubQueryOp<T>(expr: Expression<T>, query: AbstractQuery<*>) : SubQueryOp<T>("NOT IN", expr, query)
 
 /**
  * Represents an SQL operator that checks if [expr] is equals to single value returned from [query].
  */
-class EqSubQueryOp<T>(expr: Expression<T>, query: Query) : SubQueryOp<T>("=", expr, query)
+class EqSubQueryOp<T>(expr: Expression<T>, query: AbstractQuery<*>) : SubQueryOp<T>("=", expr, query)
 
 /**
  * Represents an SQL operator that checks if [expr] is not equals to single value returned from [query].
  */
-class NotEqSubQueryOp<T>(expr: Expression<T>, query: Query) : SubQueryOp<T>("!=", expr, query)
+class NotEqSubQueryOp<T>(expr: Expression<T>, query: AbstractQuery<*>) : SubQueryOp<T>("!=", expr, query)
 
 
 // Array Comparisons

exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Queries.kt

@@ -159,11 +159,11 @@ fun <T:Table> T.replace(body: T.(UpdateBuilder<*>)->Unit): ReplaceStatement<Long
 /**
  * @sample org.jetbrains.exposed.sql.tests.shared.DMLTests.testInsertSelect01
  */
-fun <T:Table> T.insert(selectQuery: Query, columns: List<Column<*>> = this.columns.filterNot { it.columnType.isAutoInc }) =
+fun <T:Table> T.insert(selectQuery: AbstractQuery<*>, columns: List<Column<*>> = this.columns.filterNot { it.columnType.isAutoInc }) =
     InsertSelectStatement(columns, selectQuery).execute(TransactionManager.current())
 
 
-fun <T:Table> T.insertIgnore(selectQuery: Query, columns: List<Column<*>> = this.columns.filterNot { it.columnType.isAutoInc }) =
+fun <T:Table> T.insertIgnore(selectQuery: AbstractQuery<*>, columns: List<Column<*>> = this.columns.filterNot { it.columnType.isAutoInc }) =
     InsertSelectStatement(columns, selectQuery, true).execute(TransactionManager.current())
 
 

exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/SQLExpressionBuilder.kt

@@ -343,16 +343,16 @@ interface ISqlExpressionBuilder {
     // Subquery Expressions
 
     /** Checks if this expression is equals to any row returned from [query]. */
-    infix fun <T> Expression<T>.inSubQuery(query: Query): InSubQueryOp<T> = InSubQueryOp(this, query)
+    infix fun <T> Expression<T>.inSubQuery(query: AbstractQuery<*>): InSubQueryOp<T> = InSubQueryOp(this, query)
 
     /** Checks if this expression is not equals to any row returned from [query]. */
-    infix fun <T> Expression<T>.notInSubQuery(query: Query): NotInSubQueryOp<T> = NotInSubQueryOp(this, query)
+    infix fun <T> Expression<T>.notInSubQuery(query: AbstractQuery<*>): NotInSubQueryOp<T> = NotInSubQueryOp(this, query)
 
     /** Checks if this expression is equals to single value returned from [query]. */
-    infix fun <T> Expression<T>.eqSubQuery(query: Query): EqSubQueryOp<T> = EqSubQueryOp(this, query)
+    infix fun <T> Expression<T>.eqSubQuery(query: AbstractQuery<*>): EqSubQueryOp<T> = EqSubQueryOp(this, query)
 
     /** Checks if this expression is not equals to single value returned from [query]. */
-    infix fun <T> Expression<T>.notEqSubQuery(query: Query): NotEqSubQueryOp<T> = NotEqSubQueryOp(this, query)
+    infix fun <T> Expression<T>.notEqSubQuery(query: AbstractQuery<*>): NotEqSubQueryOp<T> = NotEqSubQueryOp(this, query)
 
     // Array Comparisons
 

exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/statements/InsertSelectStatement.kt

@@ -1,12 +1,9 @@
 package org.jetbrains.exposed.sql.statements
 
-import org.jetbrains.exposed.sql.Column
-import org.jetbrains.exposed.sql.IColumnType
-import org.jetbrains.exposed.sql.Query
-import org.jetbrains.exposed.sql.Transaction
+import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.statements.api.PreparedStatementApi
 
-open class InsertSelectStatement(val columns: List<Column<*>>, val selectQuery: Query, val isIgnore: Boolean = false): Statement<Int>(StatementType.INSERT, listOf(columns.first().table)) {
+open class InsertSelectStatement(val columns: List<Column<*>>, val selectQuery: AbstractQuery<*>, val isIgnore: Boolean = false): Statement<Int>(StatementType.INSERT, listOf(columns.first().table)) {
 
     init {
         if (columns.isEmpty()) error("Can't insert without provided columns")