Merge pull request #12 from ergon/feature/dope-186-upgrade-clauses

Feature/dope 186 upgrade clauses

core/src/main/kotlin/ch/ergon/dope/QueryBuilder.kt

@@ -0,0 +1,23 @@
+package ch.ergon.dope
+
+import ch.ergon.dope.resolvable.clause.FromClause
+import ch.ergon.dope.resolvable.clause.SelectClause
+import ch.ergon.dope.resolvable.clause.SelectDistinctClause
+import ch.ergon.dope.resolvable.clause.SelectRawClause
+import ch.ergon.dope.resolvable.expression.AsteriskExpression
+import ch.ergon.dope.resolvable.expression.Expression
+import ch.ergon.dope.resolvable.expression.SingleExpression
+import ch.ergon.dope.resolvable.fromable.Fromable
+
+class QueryBuilder {
+    fun select(expression: Expression, vararg expressions: Expression): SelectClause = SelectClause(expression, *expressions)
+
+    fun selectAsterisk(): SelectClause = SelectClause(AsteriskExpression())
+
+    fun selectDistinct(expression: Expression, vararg expressions: Expression): SelectDistinctClause =
+        SelectDistinctClause(expression, *expressions)
+
+    fun selectRaw(expression: SingleExpression): SelectRawClause = SelectRawClause(expression)
+
+    fun selectFrom(fromable: Fromable): FromClause = SelectClause(AsteriskExpression()).from(fromable)
+}

core/src/main/kotlin/ch/ergon/dope/resolvable/QueryStringBuilder.kt

@@ -3,6 +3,8 @@ package ch.ergon.dope.resolvable
 fun formatToQueryString(left: String, right: String) = "$left $right"
 fun formatToQueryString(left: Resolvable, right: String) = "${left.toQueryString()} $right"
 fun formatToQueryString(left: String, symbol: String, right: String) = "$left $symbol $right"
+fun formatToQueryString(left: Resolvable, symbol: String, vararg right: Resolvable) =
+    "${left.toQueryString()} $symbol ${right.joinToString { it.toQueryString() }}"
 fun formatToQueryString(symbol: String, vararg argument: Resolvable) =
     "$symbol ${argument.joinToString(separator = ", ") { it.toQueryString() }}"
 

core/src/main/kotlin/ch/ergon/dope/resolvable/clause/Clause.kt

@@ -1,5 +1,11 @@
 package ch.ergon.dope.resolvable.clause
 
 import ch.ergon.dope.resolvable.Resolvable
+import ch.ergon.dope.resolvable.expression.unaliased.type.resetCounter
 
-interface Clause : Resolvable
+interface Clause : Resolvable {
+    fun build(): String {
+        resetCounter()
+        return toQueryString()
+    }
+}

core/src/main/kotlin/ch/ergon/dope/resolvable/clause/ISelectClause.kt

@@ -0,0 +1,57 @@
+package ch.ergon.dope.resolvable.clause
+
+import ch.ergon.dope.resolvable.expression.TypeExpression
+import ch.ergon.dope.resolvable.expression.unaliased.type.Field
+import ch.ergon.dope.resolvable.expression.unaliased.type.toNumberType
+import ch.ergon.dope.resolvable.fromable.AliasedSelectClause
+import ch.ergon.dope.resolvable.fromable.Bucket
+import ch.ergon.dope.resolvable.fromable.Fromable
+import ch.ergon.dope.validtype.BooleanType
+import ch.ergon.dope.validtype.NumberType
+import ch.ergon.dope.validtype.StringType
+import ch.ergon.dope.validtype.ValidType
+
+interface IOffsetClause : Clause
+
+interface ILimitClause : IOffsetClause {
+    fun offset(numberExpression: TypeExpression<NumberType>): OffsetClause = OffsetClause(numberExpression, this)
+}
+
+interface IOrderByClause : ILimitClause {
+    fun limit(numberExpression: TypeExpression<NumberType>): LimitClause = LimitClause(numberExpression, this)
+    fun limit(number: Number): LimitClause = limit(number.toNumberType())
+}
+
+interface IGroupByClause : IOrderByClause {
+    fun orderBy(stringField: Field<StringType>): OrderByClause = OrderByClause(stringField, this)
+    fun orderBy(stringField: Field<StringType>, orderByType: OrderByType): OrderByTypeClause = OrderByTypeClause(stringField, orderByType, this)
+}
+
+interface IWhereClause : IGroupByClause {
+    fun groupBy(field: Field<out ValidType>, vararg fields: Field<out ValidType>): GroupByClause =
+        GroupByClause(field, *fields, parentClause = this)
+}
+
+interface IFromClause : IWhereClause {
+    fun where(whereExpression: TypeExpression<BooleanType>) = WhereClause(whereExpression, this)
+}
+
+interface IJoinClause : IFromClause {
+    fun join(bucket: Bucket, onCondition: TypeExpression<BooleanType>) = StandardJoinClause(this, bucket, onCondition)
+    fun join(bucket: Bucket, onKeys: Field<out ValidType>) = StandardJoinClause(this, bucket, onKeys)
+
+    fun innerJoin(bucket: Bucket, onCondition: TypeExpression<BooleanType>) = InnerJoinClause(this, bucket, onCondition)
+    fun innerJoin(bucket: Bucket, onKeys: Field<out ValidType>) = InnerJoinClause(this, bucket, onKeys)
+
+    fun leftJoin(bucket: Bucket, onCondition: TypeExpression<BooleanType>) = LeftJoinClause(this, bucket, onCondition)
+    fun leftJoin(bucket: Bucket, onKeys: Field<out ValidType>) = LeftJoinClause(this, bucket, onKeys)
+
+    fun rightJoin(bucket: Bucket, onCondition: TypeExpression<BooleanType>) = RightJoinClause(this, bucket, onCondition)
+    fun rightJoin(bucket: Bucket, onKeys: Field<out ValidType>) = RightJoinClause(this, bucket, onKeys)
+}
+
+interface ISelectClause : IFromClause {
+    fun from(fromable: Fromable) = FromClause(fromable, this)
+
+    fun alias(alias: String) = AliasedSelectClause(alias, this)
+}

core/src/main/kotlin/ch/ergon/dope/resolvable/clause/JoinClause.kt

@@ -0,0 +1,53 @@
+package ch.ergon.dope.resolvable.clause
+
+import ch.ergon.dope.resolvable.expression.TypeExpression
+import ch.ergon.dope.resolvable.expression.unaliased.type.Field
+import ch.ergon.dope.resolvable.fromable.Bucket
+import ch.ergon.dope.validtype.BooleanType
+import ch.ergon.dope.validtype.ValidType
+
+sealed class JoinClause : IJoinClause {
+    private val queryString: String
+
+    constructor(parentClause: IFromClause, joinType: String, bucket: Bucket, onCondition: TypeExpression<BooleanType>) {
+        queryString = "${parentClause.toQueryString()} $joinType ${bucket.toQueryString()} ON ${onCondition.toQueryString()}"
+    }
+
+    constructor(parentClause: IFromClause, joinType: String, bucket: Bucket, key: Field<out ValidType>) {
+        queryString = "${parentClause.toQueryString()} $joinType ${bucket.toQueryString()} ON KEYS ${key.toQueryString()}"
+    }
+
+    override fun toQueryString(): String = queryString
+}
+
+class StandardJoinClause : JoinClause {
+    constructor(parentClause: IFromClause, bucket: Bucket, onCondition: TypeExpression<BooleanType>) :
+        super(parentClause, "JOIN", bucket, onCondition)
+
+    constructor(parentClause: IFromClause, bucket: Bucket, onKeys: Field<out ValidType>) :
+        super(parentClause, "JOIN", bucket, onKeys)
+}
+
+class LeftJoinClause : JoinClause {
+    constructor(parentClause: IFromClause, bucket: Bucket, onCondition: TypeExpression<BooleanType>) :
+        super(parentClause, "LEFT JOIN", bucket, onCondition)
+
+    constructor(parentClause: IFromClause, bucket: Bucket, onKeys: Field<out ValidType>) :
+        super(parentClause, "LEFT JOIN", bucket, onKeys)
+}
+
+class InnerJoinClause : JoinClause {
+    constructor(parentClause: IFromClause, bucket: Bucket, onCondition: TypeExpression<BooleanType>) :
+        super(parentClause, "INNER JOIN", bucket, onCondition)
+
+    constructor(parentClause: IFromClause, bucket: Bucket, onKeys: Field<out ValidType>) :
+        super(parentClause, "INNER JOIN", bucket, onKeys)
+}
+
+class RightJoinClause : JoinClause {
+    constructor(parentClause: IFromClause, bucket: Bucket, onCondition: TypeExpression<BooleanType>) :
+        super(parentClause, "RIGHT JOIN", bucket, onCondition)
+
+    constructor(parentClause: IFromClause, bucket: Bucket, onKeys: Field<out ValidType>) :
+        super(parentClause, "RIGHT JOIN", bucket, onKeys)
+}

core/src/main/kotlin/ch/ergon/dope/resolvable/clause/OrderByType.kt

@@ -0,0 +1,6 @@
+package ch.ergon.dope.resolvable.clause
+
+enum class OrderByType(val type: String) {
+    ASC("ASC"),
+    DESC("DESC"),
+}

core/src/main/kotlin/ch/ergon/dope/resolvable/clause/SelectClause.kt

@@ -0,0 +1,59 @@
+package ch.ergon.dope.resolvable.clause
+
+import ch.ergon.dope.resolvable.expression.Expression
+import ch.ergon.dope.resolvable.expression.TypeExpression
+import ch.ergon.dope.resolvable.expression.unaliased.type.Field
+import ch.ergon.dope.resolvable.formatToQueryString
+import ch.ergon.dope.resolvable.fromable.Fromable
+import ch.ergon.dope.validtype.BooleanType
+import ch.ergon.dope.validtype.NumberType
+import ch.ergon.dope.validtype.StringType
+import ch.ergon.dope.validtype.ValidType
+
+class OffsetClause(private val numberExpression: TypeExpression<NumberType>, private val parentClause: ILimitClause) : IOffsetClause {
+    override fun toQueryString(): String = formatToQueryString(parentClause, "OFFSET", numberExpression)
+}
+
+class LimitClause(private val numberExpression: TypeExpression<NumberType>, private val parentClause: IOrderByClause) : ILimitClause {
+    override fun toQueryString(): String = formatToQueryString(parentClause, "LIMIT", numberExpression)
+}
+
+open class OrderByClause(private val stringField: Field<StringType>, private val parentClause: IGroupByClause) : IOrderByClause {
+    override fun toQueryString(): String = formatToQueryString(parentClause, "ORDER BY", stringField)
+}
+
+class OrderByTypeClause(
+    stringField: Field<StringType>,
+    private val orderByType: OrderByType,
+    parentClause: IGroupByClause,
+) : OrderByClause(stringField, parentClause) {
+    override fun toQueryString(): String = super.toQueryString() + " ${orderByType.type}"
+}
+
+class GroupByClause(
+    private val field: Field<out ValidType>,
+    private vararg val fields: Field<out ValidType>,
+    private val parentClause: IWhereClause,
+) : IGroupByClause {
+    override fun toQueryString(): String = formatToQueryString(parentClause, "GROUP BY", field, *fields)
+}
+
+class WhereClause(private val whereExpression: TypeExpression<BooleanType>, private val parentClause: IFromClause) : IWhereClause {
+    override fun toQueryString(): String = formatToQueryString(parentClause, "WHERE", whereExpression)
+}
+
+class FromClause(private val fromable: Fromable, private val parentClause: ISelectClause) : IJoinClause {
+    override fun toQueryString(): String = formatToQueryString(parentClause, "FROM", fromable)
+}
+
+class SelectRawClause(private val expression: Expression) : ISelectClause {
+    override fun toQueryString(): String = formatToQueryString("SELECT RAW", expression)
+}
+
+class SelectDistinctClause(private val expression: Expression, private vararg val expressions: Expression) : ISelectClause {
+    override fun toQueryString(): String = formatToQueryString("SELECT DISTINCT", expression, *expressions)
+}
+
+class SelectClause(private val expression: Expression, private vararg val expressions: Expression) : ISelectClause {
+    override fun toQueryString(): String = formatToQueryString("SELECT", expression, *expressions)
+}