DOPE-209: moved all classes into model-package, renaming

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

@@ -1,10 +1,10 @@
 package ch.ergon.dope
 
-import ch.ergon.dope.resolvable.clause.DeleteClause
-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.clause.model.DeleteClause
+import ch.ergon.dope.resolvable.clause.model.FromClause
+import ch.ergon.dope.resolvable.clause.model.SelectClause
+import ch.ergon.dope.resolvable.clause.model.SelectDistinctClause
+import ch.ergon.dope.resolvable.clause.model.SelectRawClause
 import ch.ergon.dope.resolvable.expression.AsteriskExpression
 import ch.ergon.dope.resolvable.expression.Expression
 import ch.ergon.dope.resolvable.expression.SingleExpression

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

@@ -1,23 +1,30 @@
 package ch.ergon.dope.resolvable.clause
 
+import ch.ergon.dope.resolvable.clause.model.DeleteLimitClause
+import ch.ergon.dope.resolvable.clause.model.DeleteOffsetClause
+import ch.ergon.dope.resolvable.clause.model.DeleteWhereClause
+import ch.ergon.dope.resolvable.clause.model.ReturningClause
 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.validtype.BooleanType
 import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.ValidType
 
-interface IReturningClause : Clause
+interface IDeleteReturningClause : Clause
 
-interface IDeleteOffsetClass : IReturningClause {
+interface IDeleteOffsetClass : IDeleteReturningClause {
     fun returning(field: Field<out ValidType>, vararg fields: Field<out ValidType>) = ReturningClause(field, *fields, parentClause = this)
 }
 
 interface IDeleteLimitClass : IDeleteOffsetClass {
     fun offset(numberExpression: TypeExpression<NumberType>) = DeleteOffsetClause(numberExpression, this)
+    fun offset(number: Number): DeleteOffsetClause = offset(number.toNumberType())
 }
 
 interface IDeleteWhereClause : IDeleteLimitClass {
     fun limit(numberExpression: TypeExpression<NumberType>) = DeleteLimitClause(numberExpression, this)
+    fun limit(number: Number): DeleteLimitClause = limit(number.toNumberType())
 }
 
 interface IDeleteClause : IDeleteWhereClause {

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

@@ -1,5 +1,17 @@
 package ch.ergon.dope.resolvable.clause
 
+import ch.ergon.dope.resolvable.clause.model.FromClause
+import ch.ergon.dope.resolvable.clause.model.GroupByClause
+import ch.ergon.dope.resolvable.clause.model.InnerJoinClause
+import ch.ergon.dope.resolvable.clause.model.LeftJoinClause
+import ch.ergon.dope.resolvable.clause.model.OrderByType
+import ch.ergon.dope.resolvable.clause.model.RightJoinClause
+import ch.ergon.dope.resolvable.clause.model.SelectLimitClause
+import ch.ergon.dope.resolvable.clause.model.SelectOffsetClause
+import ch.ergon.dope.resolvable.clause.model.SelectOrderByClause
+import ch.ergon.dope.resolvable.clause.model.SelectOrderByTypeClause
+import ch.ergon.dope.resolvable.clause.model.SelectWhereClause
+import ch.ergon.dope.resolvable.clause.model.StandardJoinClause
 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
@@ -11,32 +23,34 @@ import ch.ergon.dope.validtype.NumberType
 import ch.ergon.dope.validtype.StringType
 import ch.ergon.dope.validtype.ValidType
 
-interface IOffsetClause : Clause
+interface ISelectOffsetClause : Clause
 
-interface ILimitClause : IOffsetClause {
+interface ISelectLimitClause : ISelectOffsetClause {
     fun offset(numberExpression: TypeExpression<NumberType>): SelectOffsetClause = SelectOffsetClause(numberExpression, this)
+    fun offset(number: Number): SelectOffsetClause = offset(number.toNumberType())
 }
 
-interface IOrderByClause : ILimitClause {
+interface ISelectOrderByClause : ISelectLimitClause {
     fun limit(numberExpression: TypeExpression<NumberType>): SelectLimitClause = SelectLimitClause(numberExpression, this)
     fun limit(number: Number): SelectLimitClause = 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 ISelectGroupByClause : ISelectOrderByClause {
+    fun orderBy(stringField: Field<StringType>): SelectOrderByClause = SelectOrderByClause(stringField, this)
+    fun orderBy(stringField: Field<StringType>, orderByType: OrderByType): SelectOrderByTypeClause =
+        SelectOrderByTypeClause(stringField, orderByType, this)
 }
 
-interface IWhereClause : IGroupByClause {
+interface ISelectWhereClause : ISelectGroupByClause {
     fun groupBy(field: Field<out ValidType>, vararg fields: Field<out ValidType>): GroupByClause =
         GroupByClause(field, *fields, parentClause = this)
 }
 
-interface IFromClause : IWhereClause {
+interface ISelectFromClause : ISelectWhereClause {
     fun where(whereExpression: TypeExpression<BooleanType>) = SelectWhereClause(whereExpression, this)
 }
 
-interface IJoinClause : IFromClause {
+interface ISelectJoinClause : ISelectFromClause {
     fun join(bucket: Bucket, onCondition: TypeExpression<BooleanType>) = StandardJoinClause(this, bucket, onCondition)
     fun join(bucket: Bucket, onKeys: Field<out ValidType>) = StandardJoinClause(this, bucket, onKeys)
 
@@ -50,7 +64,7 @@ interface IJoinClause : IFromClause {
     fun rightJoin(bucket: Bucket, onKeys: Field<out ValidType>) = RightJoinClause(this, bucket, onKeys)
 }
 
-interface ISelectClause : IFromClause {
+interface ISelectClause : ISelectFromClause {
     fun from(fromable: Fromable) = FromClause(fromable, this)
 
     fun alias(alias: String) = AliasedSelectClause(alias, this)

core/src/main/kotlin/ch/ergon/dope/resolvable/clause/DeleteClause.kt → core/src/main/kotlin/ch/ergon/dope/resolvable/clause/model/DeleteClause.kt

@@ -1,5 +1,6 @@
-package ch.ergon.dope.resolvable.clause
+package ch.ergon.dope.resolvable.clause.model
 
+import ch.ergon.dope.resolvable.clause.IDeleteClause
 import ch.ergon.dope.resolvable.fromable.Bucket
 
 class DeleteClause(private val bucket: Bucket) : IDeleteClause {

core/src/main/kotlin/ch/ergon/dope/resolvable/clause/FromClause.kt → core/src/main/kotlin/ch/ergon/dope/resolvable/clause/model/FromClause.kt

@@ -1,8 +1,10 @@
-package ch.ergon.dope.resolvable.clause
+package ch.ergon.dope.resolvable.clause.model
 
+import ch.ergon.dope.resolvable.clause.ISelectClause
+import ch.ergon.dope.resolvable.clause.ISelectJoinClause
 import ch.ergon.dope.resolvable.formatToQueryString
 import ch.ergon.dope.resolvable.fromable.Fromable
 
-class FromClause(private val fromable: Fromable, private val parentClause: ISelectClause) : IJoinClause {
+class FromClause(private val fromable: Fromable, private val parentClause: ISelectClause) : ISelectJoinClause {
     override fun toQueryString(): String = formatToQueryString(parentClause, "FROM", fromable)
 }

core/src/main/kotlin/ch/ergon/dope/resolvable/clause/GroupByClause.kt → core/src/main/kotlin/ch/ergon/dope/resolvable/clause/model/GroupByClause.kt

@@ -1,13 +1,15 @@
-package ch.ergon.dope.resolvable.clause
+package ch.ergon.dope.resolvable.clause.model
 
+import ch.ergon.dope.resolvable.clause.ISelectGroupByClause
+import ch.ergon.dope.resolvable.clause.ISelectWhereClause
 import ch.ergon.dope.resolvable.expression.unaliased.type.Field
 import ch.ergon.dope.resolvable.formatToQueryString
 import ch.ergon.dope.validtype.ValidType
 
 class GroupByClause(
     private val field: Field<out ValidType>,
     private vararg val fields: Field<out ValidType>,
-    private val parentClause: IWhereClause,
-) : IGroupByClause {
+    private val parentClause: ISelectWhereClause,
+) : ISelectGroupByClause {
     override fun toQueryString(): String = formatToQueryString(parentClause, "GROUP BY", field, *fields)
 }

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

@@ -0,0 +1,55 @@
+package ch.ergon.dope.resolvable.clause.model
+
+import ch.ergon.dope.resolvable.clause.ISelectFromClause
+import ch.ergon.dope.resolvable.clause.ISelectJoinClause
+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 SelectJoinClause : ISelectJoinClause {
+    private val queryString: String
+
+    constructor(parentClause: ISelectFromClause, joinType: String, bucket: Bucket, onCondition: TypeExpression<BooleanType>) {
+        queryString = "${parentClause.toQueryString()} $joinType ${bucket.toQueryString()} ON ${onCondition.toQueryString()}"
+    }
+
+    constructor(parentClause: ISelectFromClause, 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 : SelectJoinClause {
+    constructor(parentClause: ISelectFromClause, bucket: Bucket, onCondition: TypeExpression<BooleanType>) :
+        super(parentClause, "JOIN", bucket, onCondition)
+
+    constructor(parentClause: ISelectFromClause, bucket: Bucket, onKeys: Field<out ValidType>) :
+        super(parentClause, "JOIN", bucket, onKeys)
+}
+
+class LeftJoinClause : SelectJoinClause {
+    constructor(parentClause: ISelectFromClause, bucket: Bucket, onCondition: TypeExpression<BooleanType>) :
+        super(parentClause, "LEFT JOIN", bucket, onCondition)
+
+    constructor(parentClause: ISelectFromClause, bucket: Bucket, onKeys: Field<out ValidType>) :
+        super(parentClause, "LEFT JOIN", bucket, onKeys)
+}
+
+class InnerJoinClause : SelectJoinClause {
+    constructor(parentClause: ISelectFromClause, bucket: Bucket, onCondition: TypeExpression<BooleanType>) :
+        super(parentClause, "INNER JOIN", bucket, onCondition)
+
+    constructor(parentClause: ISelectFromClause, bucket: Bucket, onKeys: Field<out ValidType>) :
+        super(parentClause, "INNER JOIN", bucket, onKeys)
+}
+
+class RightJoinClause : SelectJoinClause {
+    constructor(parentClause: ISelectFromClause, bucket: Bucket, onCondition: TypeExpression<BooleanType>) :
+        super(parentClause, "RIGHT JOIN", bucket, onCondition)
+
+    constructor(parentClause: ISelectFromClause, bucket: Bucket, onKeys: Field<out ValidType>) :
+        super(parentClause, "RIGHT JOIN", bucket, onKeys)
+}

core/src/main/kotlin/ch/ergon/dope/resolvable/clause/LimitClause.kt → core/src/main/kotlin/ch/ergon/dope/resolvable/clause/model/LimitClause.kt

@@ -1,12 +1,17 @@
-package ch.ergon.dope.resolvable.clause
+package ch.ergon.dope.resolvable.clause.model
 
+import ch.ergon.dope.resolvable.clause.IDeleteLimitClass
+import ch.ergon.dope.resolvable.clause.IDeleteWhereClause
+import ch.ergon.dope.resolvable.clause.ISelectLimitClause
+import ch.ergon.dope.resolvable.clause.ISelectOrderByClause
 import ch.ergon.dope.resolvable.expression.TypeExpression
 import ch.ergon.dope.resolvable.formatToQueryString
 import ch.ergon.dope.validtype.NumberType
 
 private const val LIMIT = "LIMIT"
 
-class SelectLimitClause(private val numberExpression: TypeExpression<NumberType>, private val parentClause: IOrderByClause) : ILimitClause {
+class SelectLimitClause(private val numberExpression: TypeExpression<NumberType>, private val parentClause: ISelectOrderByClause) :
+    ISelectLimitClause {
     override fun toQueryString(): String = formatToQueryString(parentClause, LIMIT, numberExpression)
 }
 

core/src/main/kotlin/ch/ergon/dope/resolvable/clause/OffsetClause.kt → core/src/main/kotlin/ch/ergon/dope/resolvable/clause/model/OffsetClause.kt

@@ -1,12 +1,17 @@
-package ch.ergon.dope.resolvable.clause
+package ch.ergon.dope.resolvable.clause.model
 
+import ch.ergon.dope.resolvable.clause.IDeleteLimitClass
+import ch.ergon.dope.resolvable.clause.IDeleteOffsetClass
+import ch.ergon.dope.resolvable.clause.ISelectLimitClause
+import ch.ergon.dope.resolvable.clause.ISelectOffsetClause
 import ch.ergon.dope.resolvable.expression.TypeExpression
 import ch.ergon.dope.resolvable.formatToQueryString
 import ch.ergon.dope.validtype.NumberType
 
 private const val OFFSET = "OFFSET"
 
-class SelectOffsetClause(private val numberExpression: TypeExpression<NumberType>, private val parentClause: ILimitClause) : IOffsetClause {
+class SelectOffsetClause(private val numberExpression: TypeExpression<NumberType>, private val parentClause: ISelectLimitClause) :
+    ISelectOffsetClause {
     override fun toQueryString(): String = formatToQueryString(parentClause, OFFSET, numberExpression)
 }
 

core/src/main/kotlin/ch/ergon/dope/resolvable/clause/OrderByClause.kt → core/src/main/kotlin/ch/ergon/dope/resolvable/clause/model/OrderByClause.kt

@@ -1,5 +1,7 @@
-package ch.ergon.dope.resolvable.clause
+package ch.ergon.dope.resolvable.clause.model
 
+import ch.ergon.dope.resolvable.clause.ISelectGroupByClause
+import ch.ergon.dope.resolvable.clause.ISelectOrderByClause
 import ch.ergon.dope.resolvable.expression.unaliased.type.Field
 import ch.ergon.dope.resolvable.formatToQueryString
 import ch.ergon.dope.validtype.StringType
@@ -9,15 +11,15 @@ enum class OrderByType(val type: String) {
     DESC("DESC"),
 }
 
-open class OrderByClause(private val stringField: Field<StringType>, private val parentClause: IGroupByClause) :
-    IOrderByClause {
+open class SelectOrderByClause(private val stringField: Field<StringType>, private val parentClause: ISelectGroupByClause) :
+    ISelectOrderByClause {
     override fun toQueryString(): String = formatToQueryString(parentClause, "ORDER BY", stringField)
 }
 
-class OrderByTypeClause(
+class SelectOrderByTypeClause(
     stringField: Field<StringType>,
     private val orderByType: OrderByType,
-    parentClause: IGroupByClause,
-) : OrderByClause(stringField, parentClause) {
+    parentClause: ISelectGroupByClause,
+) : SelectOrderByClause(stringField, parentClause) {
     override fun toQueryString(): String = super.toQueryString() + " ${orderByType.type}"
 }

core/src/main/kotlin/ch/ergon/dope/resolvable/clause/ReturningClause.kt → core/src/main/kotlin/ch/ergon/dope/resolvable/clause/model/ReturningClause.kt

@@ -1,5 +1,7 @@
-package ch.ergon.dope.resolvable.clause
+package ch.ergon.dope.resolvable.clause.model
 
+import ch.ergon.dope.resolvable.clause.IDeleteOffsetClass
+import ch.ergon.dope.resolvable.clause.IDeleteReturningClause
 import ch.ergon.dope.resolvable.expression.unaliased.type.Field
 import ch.ergon.dope.resolvable.formatToQueryString
 import ch.ergon.dope.validtype.ValidType
@@ -8,6 +10,6 @@ class ReturningClause(
     private val field: Field<out ValidType>,
     private vararg val fields: Field<out ValidType>,
     private val parentClause: IDeleteOffsetClass,
-) : IReturningClause {
+) : IDeleteReturningClause {
     override fun toQueryString(): String = formatToQueryString(parentClause, "RETURNING", field, *fields)
 }

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

@@ -1,5 +1,6 @@
-package ch.ergon.dope.resolvable.clause
+package ch.ergon.dope.resolvable.clause.model
 
+import ch.ergon.dope.resolvable.clause.ISelectClause
 import ch.ergon.dope.resolvable.expression.Expression
 import ch.ergon.dope.resolvable.formatToQueryString
 

core/src/main/kotlin/ch/ergon/dope/resolvable/clause/SelectWhereClause.kt → core/src/main/kotlin/ch/ergon/dope/resolvable/clause/model/WhereClause.kt

@@ -1,12 +1,17 @@
-package ch.ergon.dope.resolvable.clause
+package ch.ergon.dope.resolvable.clause.model
 
+import ch.ergon.dope.resolvable.clause.IDeleteClause
+import ch.ergon.dope.resolvable.clause.IDeleteWhereClause
+import ch.ergon.dope.resolvable.clause.ISelectFromClause
+import ch.ergon.dope.resolvable.clause.ISelectWhereClause
 import ch.ergon.dope.resolvable.expression.TypeExpression
 import ch.ergon.dope.resolvable.formatToQueryString
 import ch.ergon.dope.validtype.BooleanType
 
 private const val WHERE = "WHERE"
 
-class SelectWhereClause(private val whereExpression: TypeExpression<BooleanType>, private val parentClause: IFromClause) : IWhereClause {
+class SelectWhereClause(private val whereExpression: TypeExpression<BooleanType>, private val parentClause: ISelectFromClause) :
+    ISelectWhereClause {
     override fun toQueryString(): String = formatToQueryString(parentClause, WHERE, whereExpression)
 }
 

core/src/test/kotlin/ch/ergon/dope/OrderByTest.kt

@@ -2,7 +2,7 @@ package ch.ergon.dope
 
 import ch.ergon.dope.helper.someBucket
 import ch.ergon.dope.helper.someStringField
-import ch.ergon.dope.resolvable.clause.OrderByType
+import ch.ergon.dope.resolvable.clause.model.OrderByType
 import junit.framework.TestCase.assertEquals
 import kotlin.test.BeforeTest
 import kotlin.test.Test