feat(qc): add support for SQL NOW() function

Author: LinusU

quaint/src/ast/function.rs

@@ -11,6 +11,7 @@ mod json_unquote;
 mod lower;
 mod maximum;
 mod minimum;
+mod now;
 mod row_number;
 mod row_to_json;
 mod search;
@@ -32,6 +33,7 @@ pub use json_unquote::*;
 pub use lower::*;
 pub use maximum::*;
 pub use minimum::*;
+pub use now::*;
 pub use row_number::*;
 pub use row_to_json::*;
 pub use search::*;
@@ -90,6 +92,7 @@ pub(crate) enum FunctionType<'a> {
     UuidToBin,
     UuidToBinSwapped,
     Uuid,
+    Now,
 }
 
 impl<'a> Aliasable<'a> for Function<'a> {

quaint/src/ast/function/now.rs

@@ -0,0 +1,26 @@
+use super::{Function, FunctionType};
+use crate::ast::Expression;
+
+/// Generates the SQL function NOW() returning the current timestamp in MySQL/PostgreSQL.
+/// ```rust
+/// # use quaint::{ast::*, visitor::{Visitor, Mysql, Postgres}};
+/// # fn main() -> Result<(), quaint::error::Error> {
+///
+/// let query = Select::default().value(now());
+///
+/// let (sql, _) = Mysql::build(query)?;
+/// assert_eq!("SELECT NOW()", sql);
+///
+/// let (sql, _) = Postgres::build(query)?;
+/// assert_eq!("SELECT NOW()", sql);
+/// # Ok(())
+/// # }
+/// ```
+pub fn native_now() -> Expression<'static> {
+    let func = Function {
+        typ_: FunctionType::Now,
+        alias: None,
+    };
+
+    func.into()
+}

quaint/src/visitor.rs

@@ -1205,6 +1205,7 @@ pub trait Visitor<'a> {
                 self.write("uuid_to_bin(uuid(), 1)")?;
             }
             FunctionType::Uuid => self.write("uuid()")?,
+            FunctionType::Now => self.write("NOW()")?,
             FunctionType::Concat(concat) => {
                 self.visit_concat(concat)?;
             }

query-compiler/query-compiler/src/expression.rs

@@ -246,6 +246,7 @@ pub enum FieldOperation {
     Subtract(PrismaValue),
     Multiply(PrismaValue),
     Divide(PrismaValue),
+    Now,
 }
 
 impl TryFrom<ScalarWriteOperation> for FieldOperation {
@@ -258,6 +259,7 @@ impl TryFrom<ScalarWriteOperation> for FieldOperation {
             ScalarWriteOperation::Subtract(val) => Ok(Self::Subtract(val)),
             ScalarWriteOperation::Multiply(val) => Ok(Self::Multiply(val)),
             ScalarWriteOperation::Divide(val) => Ok(Self::Divide(val)),
+            ScalarWriteOperation::Now => Ok(Self::Now),
             ScalarWriteOperation::Field(_) | ScalarWriteOperation::Unset(_) => Err(UnsupportedScalarWriteOperation(op)),
         }
     }

query-compiler/query-compiler/src/expression/format.rs

@@ -453,6 +453,7 @@ where
                             self.keyword("mul").append(self.space()).append(self.value(val))
                         }
                         FieldOperation::Divide(val) => self.keyword("div").append(self.space()).append(self.value(val)),
+                        FieldOperation::Now => self.keyword("now"),
                     },
                 )
             })))

query-engine/connectors/mongodb-query-connector/src/root_queries/update/into_operation.rs

@@ -44,6 +44,10 @@ impl IntoUpdateOperation for ScalarWriteOperation {
                 field_path,
                 doc! { "$divide": [dollar_field_path, (field, rhs).into_bson()?] },
             )),
+            ScalarWriteOperation::Now => Some(UpdateOperation::generic(
+                field_path,
+                doc! { "$currentDate": true },
+            )),
             ScalarWriteOperation::Unset(true) => Some(UpdateOperation::unset(field_path)),
             ScalarWriteOperation::Unset(false) => None,
             ScalarWriteOperation::Field(_) => unimplemented!(),

query-engine/query-builders/sql-query-builder/src/write.rs

@@ -191,6 +191,10 @@ pub fn build_update_and_set_query(
                     e / field.value(rhs, ctx).into()
                 }
 
+                ScalarWriteOperation::Now => {
+                    native_now()
+                },
+
                 ScalarWriteOperation::Unset(_) => unreachable!("Unset is not supported on SQL connectors"),
             };
 

query-engine/query-structure/src/write_args.rs

@@ -150,6 +150,9 @@ pub enum ScalarWriteOperation {
 
     /// Divide field by value.
     Divide(PrismaValue),
+
+    /// Set field to the current date-time
+    Now,
 }
 
 #[derive(Debug, PartialEq, Clone)]
@@ -487,5 +490,6 @@ pub fn apply_expression(val: PrismaValue, scalar_write: ScalarWriteOperation) ->
         ScalarWriteOperation::Multiply(rhs) => val * rhs,
         ScalarWriteOperation::Divide(rhs) => val / rhs,
         ScalarWriteOperation::Unset(_) => unimplemented!(),
+        ScalarWriteOperation::Now => PrismaValue::generator_now(),
     }
 }