Merge pull request #49 from hasura/codedmart/oracle-dates

Add date/timestamp casts explicitly to `where` predicates

Author: GavinRay97

ndc-connector-oracle/src/main/kotlin/io/hasura/oracle/JSONGenerator.kt

@@ -117,12 +117,23 @@ object JsonQueryGenerator : BaseQueryGenerator() {
                                         (request.query.fields ?: emptyMap()).map { (alias, field) ->
                                             when (field) {
                                                 is ColumnField -> {
+                                                    val field = DSL.field(
+                                                        DSL.name(field.column),
+                                                        columnTypeTojOOQType(request.collection, field)
+                                                    )
+
                                                     DSL.jsonEntry(
                                                         alias,
-                                                        DSL.field(
-                                                            DSL.name(field.column),
-                                                            columnTypeTojOOQType(request.collection, field)
-                                                        )
+                                                        // Oracle JSON functions convert DATE to ISO8601 format, which includes a timestamp
+                                                        // We need to convert it to a date-only format to preserve the actual date value
+                                                        //
+                                                        // SEE: https://docs.oracle.com/en/database/oracle/oracle-database/23/adjsn/overview-json-generation.html
+                                                        //      (Section: "Result Returned by SQL/JSON Generation Functions")
+                                                        when (field.dataType) {
+                                                            SQLDataType.DATE -> DSL.toChar(field, DSL.inline("YYYY-MM-DD"))
+                                                            SQLDataType.TIMESTAMP -> DSL.toChar(field, DSL.inline("YYYY-MM-DD HH24:MI:SS"))
+                                                            else -> field
+                                                        }
                                                     )
                                                 }
 

ndc-sqlgen/src/main/kotlin/io/hasura/ndc/sqlgen/BaseGenerator.kt

@@ -1,8 +1,11 @@
 package io.hasura.ndc.sqlgen
 
+import io.hasura.ndc.common.ConnectorConfiguration
+import io.hasura.ndc.common.NDCScalar
 import io.hasura.ndc.ir.*
 import org.jooq.Condition
 import org.jooq.impl.DSL
+import org.jooq.impl.SQLDataType
 import org.jooq.Field
 
 sealed interface BaseGenerator {
@@ -28,7 +31,8 @@ sealed interface BaseGenerator {
     fun buildComparison(
         col: Field<Any>,
         operator: ApplyBinaryComparisonOperator,
-        listVal: List<Field<Any>>
+        listVal: List<Field<Any>>,
+        columnType: NDCScalar?
     ): Condition {
         if (operator != ApplyBinaryComparisonOperator.IN && listVal.size != 1) {
             error("Only the IN operator supports multiple values")
@@ -37,20 +41,67 @@ sealed interface BaseGenerator {
         // unwrap single value for use in all but the IN operator
         // OR return falseCondition if listVal is empty
         val singleVal = listVal.firstOrNull() ?: return DSL.falseCondition()
+        val castedValue = castValue(singleVal, columnType)
 
         return when (operator) {
-            ApplyBinaryComparisonOperator.EQ -> col.eq(singleVal)
-            ApplyBinaryComparisonOperator.GT -> col.gt(singleVal)
-            ApplyBinaryComparisonOperator.GTE -> col.ge(singleVal)
-            ApplyBinaryComparisonOperator.LT -> col.lt(singleVal)
-            ApplyBinaryComparisonOperator.LTE -> col.le(singleVal)
-            ApplyBinaryComparisonOperator.IN -> col.`in`(listVal)
+            ApplyBinaryComparisonOperator.EQ -> col.eq(castedValue)
+            ApplyBinaryComparisonOperator.GT -> col.gt(castedValue)
+            ApplyBinaryComparisonOperator.GTE -> col.ge(castedValue)
+            ApplyBinaryComparisonOperator.LT -> col.lt(castedValue)
+            ApplyBinaryComparisonOperator.LTE -> col.le(castedValue)
+            ApplyBinaryComparisonOperator.IN -> col.`in`(listVal.map { castValue(it, columnType) })
             ApplyBinaryComparisonOperator.IS_NULL -> col.isNull
             ApplyBinaryComparisonOperator.LIKE -> col.like(singleVal as Field<String>)
             ApplyBinaryComparisonOperator.CONTAINS -> col.contains(singleVal as Field<String>)
         }
     }
 
+    fun castValue(value: Any, scalarType: NDCScalar?): Any {
+        return when (scalarType) {
+            NDCScalar.TIMESTAMPTZ -> DSL.cast(value, SQLDataType.TIMESTAMPWITHTIMEZONE)
+            NDCScalar.TIMESTAMP -> DSL.cast(value, SQLDataType.TIMESTAMP)
+            NDCScalar.DATE -> DSL.cast(value, SQLDataType.DATE)
+            else -> value
+        }
+    }
+
+    fun getColumnType(col: ComparisonTarget, request: QueryRequest): NDCScalar? {
+        val connectorConfig = ConnectorConfiguration.Loader.config
+        val collection = getCollectionForCompCol(col, request)
+        val collectionIsTable = connectorConfig.tables.any { it.tableName == collection }
+        val collectionIsNativeQuery = connectorConfig.nativeQueries.containsKey(collection)
+        val columnType =  when {
+            collectionIsTable -> {
+                val table = connectorConfig.tables.find { it.tableName == collection }
+                    ?: error("Table $collection not found in connector configuration")
+
+                val column = table.columns.find { it.name == col.name }
+                    ?: error("Column ${col.name} not found in table $collection")
+
+                column.type
+            }
+
+            collectionIsNativeQuery -> {
+                val nativeQuery = connectorConfig.nativeQueries[collection]
+                    ?: error("Native query $collection not found in connector configuration")
+
+                val column = nativeQuery.columns[col.name]
+                    ?: error("Column ${col.name} not found in native query $collection")
+
+                Type.extractBaseType(column)
+            }
+
+            else -> error("Collection $collection not found in connector configuration")
+        }
+
+        return when {
+          columnType == "DATE" -> NDCScalar.DATE
+          columnType.contains("TIMESTAMP") && !columnType.contains("TIME ZONE") -> NDCScalar.TIMESTAMP
+          columnType.contains("TIMESTAMP") && columnType.contains("TIME ZONE") -> NDCScalar.TIMESTAMPTZ
+          else -> null
+        }
+    }
+
     private fun getCollectionForCompCol(
         col: ComparisonTarget,
         request: QueryRequest
@@ -124,6 +175,7 @@ sealed interface BaseGenerator {
             }
 
             is Expression.ApplyBinaryComparison -> {
+                val columnType = getColumnType(e.column, request)
                 val column = DSL.field(
                     DSL.name(
                         splitCollectionName(getCollectionForCompCol(e.column, request)) + e.column.name
@@ -143,7 +195,7 @@ sealed interface BaseGenerator {
 
                     is ComparisonValue.VariableComp -> listOf(DSL.field(DSL.name(listOf("vars", v.name))))
                 }
-                return buildComparison(column, e.operator, comparisonValue)
+                return buildComparison(column, e.operator, comparisonValue, columnType)
             }
 
             is Expression.ApplyUnaryComparison -> {