From fe86eb27d0a837064fabe1327c127496909dd2a8 Mon Sep 17 00:00:00 2001 From: "Andrey.Tarashevskiy" Date: Mon, 29 Mar 2021 22:35:12 +0300 Subject: [PATCH] Add set operations #402 / More places where Union can be used --- .../org/jetbrains/exposed/gradle/Publishing.kt | 3 --- .../main/kotlin/org/jetbrains/exposed/sql/Alias.kt | 10 +++++----- .../kotlin/org/jetbrains/exposed/sql/Exceptions.kt | 3 ++- .../main/kotlin/org/jetbrains/exposed/sql/Op.kt | 14 +++++++------- .../kotlin/org/jetbrains/exposed/sql/Queries.kt | 4 ++-- .../jetbrains/exposed/sql/SQLExpressionBuilder.kt | 8 ++++---- .../sql/statements/InsertSelectStatement.kt | 7 ++----- 7 files changed, 22 insertions(+), 27 deletions(-) diff --git a/buildSrc/src/main/kotlin/org/jetbrains/exposed/gradle/Publishing.kt b/buildSrc/src/main/kotlin/org/jetbrains/exposed/gradle/Publishing.kt index 82c098aa50..bfc5d540eb 100644 --- a/buildSrc/src/main/kotlin/org/jetbrains/exposed/gradle/Publishing.kt +++ b/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 Property.by(value: T) { set(value) } - fun MavenPom.configureMavenCentralMetadata(project: Project) { name by project.name description by "Exposed, an ORM framework for Kotlin" diff --git a/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Alias.kt b/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Alias.kt index 75451eb219..17f25a2ccb 100644 --- a/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Alias.kt +++ b/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Alias.kt @@ -56,7 +56,7 @@ class ExpressionAlias(val delegate: Expression, 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.alias(alias: String) = Alias(this, alias) -fun T.alias(alias: String) = QueryAlias(this, alias) +fun > T.alias(alias: String) = QueryAlias(this, alias) fun Expression.alias(alias: String) = ExpressionAlias(this, alias) -fun Join.joinQuery(on: (SqlExpressionBuilder.(QueryAlias)->Op), joinType: JoinType = JoinType.INNER, joinPart: () -> Query): Join { +fun Join.joinQuery(on: (SqlExpressionBuilder.(QueryAlias)->Op), 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), joinType: JoinType = JoinType.INNER, joinPart: () -> Query) +fun Table.joinQuery(on: (SqlExpressionBuilder.(QueryAlias)->Op), 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 wrapAsExpression(query: Query) = object : Expression() { +fun wrapAsExpression(query: AbstractQuery<*>) = object : Expression() { override fun toQueryBuilder(queryBuilder: QueryBuilder) = queryBuilder { append("(") query.prepareSQL(this) diff --git a/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Exceptions.kt b/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Exceptions.kt index 814b1fc1af..09d2249146 100644 --- a/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Exceptions.kt +++ b/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)?.prepareSQL(QueryBuilder(!transaction.debug)) } catch (e: Throwable) { null } ?: "Failed on expanding args for ${it.statement.type}: ${it.statement}" diff --git a/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Op.kt b/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Op.kt index e2aeb420ac..e966c9c595 100644 --- a/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Op.kt +++ b/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() { 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() { override fun toQueryBuilder(queryBuilder: QueryBuilder): Unit = queryBuilder { append("NOT EXISTS (") @@ -364,7 +364,7 @@ sealed class SubQueryOp( /** Returns the expression compared to each row of the query result. */ val expr: Expression, /** Returns the query to check against. */ - val query: Query + val query: AbstractQuery<*> ) : Op(), ComplexExpression { override fun toQueryBuilder(queryBuilder: QueryBuilder): Unit = queryBuilder { append(expr, " $operator (") @@ -376,22 +376,22 @@ sealed class SubQueryOp( /** * Represents an SQL operator that checks if [expr] is equals to any row returned from [query]. */ -class InSubQueryOp(expr: Expression, query: Query) : SubQueryOp("IN", expr, query) +class InSubQueryOp(expr: Expression, query: AbstractQuery<*>) : SubQueryOp("IN", expr, query) /** * Represents an SQL operator that checks if [expr] is not equals to any row returned from [query]. */ -class NotInSubQueryOp(expr: Expression, query: Query) : SubQueryOp("NOT IN", expr, query) +class NotInSubQueryOp(expr: Expression, query: AbstractQuery<*>) : SubQueryOp("NOT IN", expr, query) /** * Represents an SQL operator that checks if [expr] is equals to single value returned from [query]. */ -class EqSubQueryOp(expr: Expression, query: Query) : SubQueryOp("=", expr, query) +class EqSubQueryOp(expr: Expression, query: AbstractQuery<*>) : SubQueryOp("=", expr, query) /** * Represents an SQL operator that checks if [expr] is not equals to single value returned from [query]. */ -class NotEqSubQueryOp(expr: Expression, query: Query) : SubQueryOp("!=", expr, query) +class NotEqSubQueryOp(expr: Expression, query: AbstractQuery<*>) : SubQueryOp("!=", expr, query) // Array Comparisons diff --git a/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Queries.kt b/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Queries.kt index 160d640337..3a5adb901f 100644 --- a/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Queries.kt +++ b/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Queries.kt @@ -159,11 +159,11 @@ fun T.replace(body: T.(UpdateBuilder<*>)->Unit): ReplaceStatement T.insert(selectQuery: Query, columns: List> = this.columns.filterNot { it.columnType.isAutoInc }) = +fun T.insert(selectQuery: AbstractQuery<*>, columns: List> = this.columns.filterNot { it.columnType.isAutoInc }) = InsertSelectStatement(columns, selectQuery).execute(TransactionManager.current()) -fun T.insertIgnore(selectQuery: Query, columns: List> = this.columns.filterNot { it.columnType.isAutoInc }) = +fun T.insertIgnore(selectQuery: AbstractQuery<*>, columns: List> = this.columns.filterNot { it.columnType.isAutoInc }) = InsertSelectStatement(columns, selectQuery, true).execute(TransactionManager.current()) diff --git a/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/SQLExpressionBuilder.kt b/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/SQLExpressionBuilder.kt index 18c02cf60d..fe9918bb98 100644 --- a/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/SQLExpressionBuilder.kt +++ b/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 Expression.inSubQuery(query: Query): InSubQueryOp = InSubQueryOp(this, query) + infix fun Expression.inSubQuery(query: AbstractQuery<*>): InSubQueryOp = InSubQueryOp(this, query) /** Checks if this expression is not equals to any row returned from [query]. */ - infix fun Expression.notInSubQuery(query: Query): NotInSubQueryOp = NotInSubQueryOp(this, query) + infix fun Expression.notInSubQuery(query: AbstractQuery<*>): NotInSubQueryOp = NotInSubQueryOp(this, query) /** Checks if this expression is equals to single value returned from [query]. */ - infix fun Expression.eqSubQuery(query: Query): EqSubQueryOp = EqSubQueryOp(this, query) + infix fun Expression.eqSubQuery(query: AbstractQuery<*>): EqSubQueryOp = EqSubQueryOp(this, query) /** Checks if this expression is not equals to single value returned from [query]. */ - infix fun Expression.notEqSubQuery(query: Query): NotEqSubQueryOp = NotEqSubQueryOp(this, query) + infix fun Expression.notEqSubQuery(query: AbstractQuery<*>): NotEqSubQueryOp = NotEqSubQueryOp(this, query) // Array Comparisons diff --git a/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/statements/InsertSelectStatement.kt b/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/statements/InsertSelectStatement.kt index 1ca0b8d10b..c9cdd72b16 100644 --- a/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/statements/InsertSelectStatement.kt +++ b/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>, val selectQuery: Query, val isIgnore: Boolean = false): Statement(StatementType.INSERT, listOf(columns.first().table)) { +open class InsertSelectStatement(val columns: List>, val selectQuery: AbstractQuery<*>, val isIgnore: Boolean = false): Statement(StatementType.INSERT, listOf(columns.first().table)) { init { if (columns.isEmpty()) error("Can't insert without provided columns")