develop

gradle/libs.versions.toml

@@ -1,5 +1,5 @@
 [versions]
-agp = "8.13.0"
+agp = "8.13.1"
 kotlin = "2.0.21"
 coreKtx = "1.17.0"
 junit = "4.13.2"

query/src/main/java/com/blipblipcode/query/InnerJoint.kt

@@ -38,6 +38,12 @@ class InnerJoint private constructor(
     override fun asSql(): String {
         require(queries.isNotEmpty()) { "At least one query is required for an INNER JOIN" }
         require(queries.size == onClauses.size) { "The number of queries must be equal to the number of ON clauses (including a placeholder for the base query)" }
+        val orders = queries.fold(mutableListOf<OrderBy>()) { acc, query ->
+            query.getOrderBy()?.let { acc.add(it) }
+            query.orderBy(null)
+            acc
+        }
+        orders.addAll(orderBy?.let { listOf(it) } ?: emptyList())
 
         val baseQuery = queries.first()
         val joins = queries.drop(1).zip(onClauses.drop(1)) { query, onClause ->
@@ -46,9 +52,9 @@ class InnerJoint private constructor(
 
         return buildString {
             append("${baseQuery.asSql()} ${joins.joinToString(" ")}")
-            if (orderBy != null) {
+            if (orders.isNotEmpty()) {
                 appendLine()
-                append(orderBy!!.asString())
+                append(OrderBy.Multiple(orders).asString())
             }
         }
     }

query/src/main/java/com/blipblipcode/query/QueryDelete.kt

@@ -162,8 +162,8 @@ class QueryDelete private constructor(
          * @param operator The SQL operator for this condition.
          * @return The `QueryBuilder` instance for chaining.
          */
-        fun like(key: String, operator: SQLOperator<*>): QueryBuilder {
-            operations[key] = LogicalOperation(LogicalType.LIKE, operator)
+        fun like(key: String, operator: SQLOperator.Like): QueryBuilder {
+            operations[key] = LogicalOperation(LogicalType.AND, operator)
             return this
         }
 

query/src/main/java/com/blipblipcode/query/QuerySelect.kt

@@ -17,7 +17,7 @@ import com.blipblipcode.query.operator.SQLOperator
  * @property fields The list of columns to be returned in the result set. Defaults to "*".
  */
 class QuerySelect private constructor(
-    private var where: SQLOperator<*>,
+    private var where: SQLOperator<*>?,
     private val table: String,
     private val operations: LinkedHashMap<String, LogicalOperation>,
     private val fields: List<String>
@@ -87,9 +87,10 @@ class QuerySelect private constructor(
         }
     }
 
+
     override fun getSqlOperators(): List<SQLOperator<*>> {
         return buildList {
-            add(where)
+            where?.let { add(it) }
             operations.values.forEach { add(it.operator) }
         }
     }
@@ -110,7 +111,11 @@ class QuerySelect private constructor(
         val fieldStr = if (fields.isEmpty()) "*" else fields.joinToString(", ")
         val operationsStr = if (operations.isNotEmpty()) operations.values.joinToString(" ") { it.asString() } else ""
         return buildString {
-            append("SELECT $fieldStr FROM $table WHERE ${where.toSQLString()} $operationsStr".trim())
+            if (where == null) {
+                append("SELECT $fieldStr FROM $table")
+            }else{
+                append("SELECT $fieldStr FROM $table WHERE ${where?.toSQLString()} $operationsStr".trim())
+            }
             if (orderBy != null) {
                 append(" ")
                 append(orderBy!!.asString())
@@ -129,7 +134,7 @@ class QuerySelect private constructor(
      * @param operator A vararg of `[OrderBy]` objects specifying the columns and direction for sorting.
      * @return A new `QuerySelect` instance representing the UNION query with the added ORDER BY clause.
      */
-    fun orderBy(operator: OrderBy): Queryable {
+    fun orderBy(operator: OrderBy?): Queryable {
         orderBy = operator
         return this
     }
@@ -157,6 +162,10 @@ class QuerySelect private constructor(
         return this
     }
 
+    fun getOrderBy(): OrderBy? {
+        return this.orderBy
+    }
+
 
     /**
      * A builder for creating `QuerySelect` instances.
@@ -237,8 +246,8 @@ class QuerySelect private constructor(
          * @param operator The SQL operator for this condition.
          * @return The `QueryBuilder` instance for chaining.
          */
-        fun like(key: String, operator: SQLOperator<*>): QueryBuilder {
-            operations[key] = LogicalOperation(LogicalType.LIKE, operator)
+        fun like(key: String, operator: SQLOperator.Like): QueryBuilder {
+            operations[key] = LogicalOperation(LogicalType.AND, operator)
             return this
         }
 
@@ -292,6 +301,9 @@ class QuerySelect private constructor(
             this.orderBy = orderBy
             return this
         }
+        fun getOrderBy(): OrderBy? {
+            return this.orderBy
+        }
 
         /**
          * Sets a LIMIT clause for the query to limit the number of rows returned.
@@ -320,9 +332,11 @@ class QuerySelect private constructor(
          * @throws IllegalArgumentException if the WHERE clause is not set.
          */
         fun build(): QuerySelect {
-            require(where != null) { "WHERE clause is required for QuerySelect" }
+            if(operations.isNotEmpty()){
+                require(where != null) { "WHERE clause is required for QuerySelect" }
+            }
             return QuerySelect(
-                where = where!!,
+                where = where,
                 table = table,
                 operations = LinkedHashMap(operations),
                 fields = fields

query/src/main/java/com/blipblipcode/query/UnionQuery.kt

@@ -35,14 +35,19 @@ class UnionQuery private constructor(
      */
     override fun asSql(): String {
         require(queries.size >= 2) { "At least two queries are required for a UNION" }
-
+        val orders = queries.fold(mutableListOf<OrderBy>()) { acc, query ->
+            query.getOrderBy()?.let { acc.add(it) }
+            query.orderBy(null)
+            acc
+        }
+        orders.addAll(orderBy?.let { listOf(it) } ?: emptyList())
         val unionKeyword = if (useUnionAll) "UNION ALL" else "UNION"
 
         return buildString {
             append(queries.joinToString("\n$unionKeyword\n") { it.asSql() })
-            if (orderBy != null) {
+            if (orders.isNotEmpty()) {
                 appendLine()
-                append(orderBy!!.asString())
+                append(OrderBy.Multiple(orders).asString())
             }
         }
     }
@@ -51,7 +56,7 @@ class UnionQuery private constructor(
      * Appends an ORDER BY clause to the entire UNION query.
      * Note that in most SQL dialects, an ORDER BY clause can only be applied to the final result of a UNION, not to individual `SELECT` statements within it.
      *
-     * @param columns A vararg of `OrderExpression` objects specifying the columns and direction for sorting.
+     * @param operator A vararg of `OrderExpression` objects specifying the columns and direction for sorting.
      * @return A new `QuerySelect` instance representing the UNION query with the added ORDER BY clause.
      */
     fun orderBy(operator: OrderBy): Queryable {

query/src/main/java/com/blipblipcode/query/operator/LogicalType.kt

@@ -8,8 +8,6 @@ enum class LogicalType(val sql: String) {
     AND("AND"),
     /** Represents a logical OR operation. */
     OR("OR"),
-    /** Represents a SQL LIKE operation. */
-    LIKE("LIKE"),
     /** Represents a SQL ALL operation. */
     ALL("ALL"),
 

query/src/main/java/com/blipblipcode/query/operator/OrdenBy.kt

@@ -3,6 +3,14 @@ package com.blipblipcode.query.operator
 sealed interface OrderBy {
     val column: String
     fun asString(): String
+
+    fun asSqlClause(): String {
+        return when (this) {
+            is Asc -> "$column ASC"
+            is Desc -> "$column DESC"
+            is Multiple -> orders.joinToString(", ") { it.asSqlClause() }
+        }
+    }
     data class Asc(override val column: String) : OrderBy{
         override fun asString(): String {
             return "ORDER BY $column ASC"
@@ -19,4 +27,17 @@ sealed interface OrderBy {
             return "ORDER BY $column DESC"
         }
     }
+
+    data class Multiple(val orders: List<OrderBy>) : OrderBy{
+        override val column: String
+            get() = orders.joinToString(", ") { it.column }
+
+        override fun asString(): String {
+            return "ORDER BY ${asSqlClause()}"
+        }
+
+        override fun toString(): String {
+            return "ORDER BY ${asSqlClause()}"
+        }
+    }
 }