Add support for {t ...} escape sequence

Author: slabko

driver/escaping/escape_sequences.cpp

@@ -20,18 +20,19 @@ std::optional<std::string> processFunction(const StringView seq, Lexer & lex);
 std::optional<std::string> processEscapeSequencesImpl(const StringView seq, Lexer & lex);
 
 const std::map<const std::string, const std::string> fn_convert_map {
-    {"SQL_TINYINT", "toUInt8"},
-    {"SQL_SMALLINT", "toUInt16"},
-    {"SQL_INTEGER", "toInt32"},
-    {"SQL_BIGINT", "toInt64"},
-    {"SQL_REAL", "toFloat32"},
-    {"SQL_DOUBLE", "toFloat64"},
-    {"SQL_CHAR", "toString"},
-    {"SQL_VARCHAR", "toString"},
-    {"SQL_DATE", "toDate"},
-    {"SQL_TYPE_DATE", "toDate"},
-    {"SQL_TIMESTAMP", "toDateTime"},
-    {"SQL_TYPE_TIMESTAMP", "toDateTime"},
+    {"SQL_TINYINT", "UInt8"},
+    {"SQL_SMALLINT", "UInt16"},
+    {"SQL_INTEGER", "Int32"},
+    {"SQL_BIGINT", "Int64"},
+    {"SQL_REAL", "Float32"},
+    {"SQL_DOUBLE", "Float64"},
+    {"SQL_CHAR", "String"},
+    {"SQL_VARCHAR", "String"},
+    {"SQL_TIME", "Time"},
+    {"SQL_DATE", "Date"},
+    {"SQL_TYPE_DATE", "Date"},
+    {"SQL_TIMESTAMP", "DateTime"},
+    {"SQL_TYPE_TIMESTAMP", "DateTime"},
 };
 
 #define DECLARE2(TOKEN, NAME) \
@@ -204,7 +205,7 @@ std::optional<std::string> processFunction(const StringView seq, Lexer & lex) {
         }
         if (!lex.Match(Token::RPARENT))
             return std::nullopt;
-        return func_it->second + "(" + result + ")";
+        return "CAST(" + result + " AS " + func_it->second + ")";
     } else if (fn.type == Token::FN_BIT_LENGTH) {
         if (!lex.Match(Token::LPARENT))
             return std::nullopt;
@@ -406,6 +407,15 @@ std::optional<std::string> processFunction(const StringView seq, Lexer & lex) {
     return seq.to_string();
 }
 
+std::optional<std::string> processTime(const StringView seq, Lexer & lex) {
+    Token data = lex.Consume(Token::STRING);
+    if (data.isInvalid()) {
+        return std::nullopt;
+    } else {
+        return std::string("cast(") + data.literal.to_string() + " as Time)";
+    }
+}
+
 std::optional<std::string> processDate(const StringView seq, Lexer & lex) {
     Token data = lex.Consume(Token::STRING);
     if (data.isInvalid()) {
@@ -462,6 +472,14 @@ std::optional<std::string> processEscapeSequencesImpl(const StringView seq, Lexe
                 break;
             }
 
+            case Token::T: {
+                auto processed = processTime(seq, lex);
+                if (!processed)
+                    return std::nullopt;
+                result += *processed;
+                break;
+            }
+
             case Token::D: {
                 auto processed = processDate(seq, lex);
                 if (!processed)
@@ -482,10 +500,6 @@ std::optional<std::string> processEscapeSequencesImpl(const StringView seq, Lexe
                 // End of escape sequence
                 return result;
 
-            case Token::T:
-                // Unimplemented
-                return std::nullopt;
-
             default:
                 // Positional query parameters, just like ODBC escape sequences, also wrapped in
                 // curly braces. However they always have a fixed `{name : type}` format, with colon

driver/test/escape_sequences_ut.cpp

@@ -291,6 +291,8 @@ TEST(EscapeSequencesCase, ParameterizedFunctionCalls) {
 }
 
 TEST(EscapeSequencesCase, DateTime) {
+    ASSERT_EQ(replaceEscapeSequences("SELECT {t '15:04:05'}"), "SELECT cast('15:04:05' as Time)");
+
     ASSERT_EQ(replaceEscapeSequences("SELECT {d '2017-01-01'}"), "SELECT toDate('2017-01-01')");
 
     ASSERT_EQ(replaceEscapeSequences("SELECT {ts '2017-01-01 10:01:01'}"), "SELECT toDateTime64('2017-01-01 10:01:01', 9)");

driver/test/scalar_functions_it.cpp

@@ -1058,9 +1058,8 @@ TEST_F(ScalarFunctionsTest, CONVERT) {
     ASSERT_EQ(query<SQL_DATE_STRUCT>("SELECT {fn CONVERT('2024-03-15', SQL_DATE)}"),
         (SQL_DATE_STRUCT{.year = 2024, .month = 3, .day = 15}));
 
-    // TODO(slabko): SQL_TIME does not work
-    // ASSERT_EQ(query<SQL_TIME_STRUCT>("SELECT {fn CONVERT('14:30:45', SQL_TIME)}"),
-    //    (SQL_TIME_STRUCT{.hour = 14, .minute = 30, .second = 45}));
+    ASSERT_EQ(query<SQL_TIME_STRUCT>("SELECT {fn CONVERT('14:30:45', SQL_TIME)}"),
+       (SQL_TIME_STRUCT{.hour = 14, .minute = 30, .second = 45}));
 
     ASSERT_EQ(query<SQL_TIMESTAMP_STRUCT>("SELECT {fn CONVERT('2024-03-15 14:30:45', SQL_TIMESTAMP)}"),
         (SQL_TIMESTAMP_STRUCT{.year = 2024, .month = 3, .day = 15, .hour = 14, .minute = 30, .second = 45}));
@@ -1069,10 +1068,8 @@ TEST_F(ScalarFunctionsTest, CONVERT) {
     ASSERT_EQ(query<SQL_DATE_STRUCT>("SELECT {fn CONVERT({ts '2024-03-15 14:30:45'}, SQL_DATE)}"),
         (SQL_DATE_STRUCT{.year = 2024, .month = 3, .day = 15}));
 
-    // TODO(slabko): SQL_TIME does not work
-    // Timestamp to time
-    // ASSERT_EQ(query<SQL_TIME_STRUCT>("SELECT {fn CONVERT({ts '2024-03-15 14:30:45'}, SQL_TIME)}"),
-    //    (SQL_TIME_STRUCT{.hour = 14, .minute = 30, .second = 45}));
+    ASSERT_EQ(query<SQL_TIME_STRUCT>("SELECT {fn CONVERT({ts '2024-03-15 14:30:45'}, SQL_TIME)}"),
+       (SQL_TIME_STRUCT{.hour = 14, .minute = 30, .second = 45}));
 
     ASSERT_EQ(query<SQLINTEGER>("SELECT {fn CONVERT(?, SQL_INTEGER)}", "456"), 456);
     ASSERT_EQ(query<std::string>("SELECT {fn CONVERT(?, SQL_VARCHAR)}", 789), "789");