feat: add string templating to ReQL

Signed-off-by: Gabor Boros <gabor.brs@gmail.com>

src/pprint/js_pprint.cc

@@ -903,6 +903,7 @@ static void pprint_update_reminder() {
     case Term::FLOOR:
     case Term::CEIL:
     case Term::ROUND:
+    case Term::FORMAT:
         break;
     }
     ql::datum_t::type_t d = ql::datum_t::type_t::R_NULL;

src/rdb_protocol/ql2.proto

@@ -798,6 +798,9 @@ message Term {
         BIT_NOT = 194;
         BIT_SAL = 195;
         BIT_SAR = 196;
+
+        // String formatting
+        FORMAT = 197;
     }
     optional TermType type = 1;
 

src/rdb_protocol/term.cc

@@ -215,6 +215,7 @@ counted_t<const term_t> compile_on_current_stack(
     case Term::FLOOR:              return make_floor_term(env, t);
     case Term::CEIL:               return make_ceil_term(env, t);
     case Term::ROUND:              return make_round_term(env, t);
+    case Term::FORMAT:             return make_format_term(env, t);
     default: unreachable();
     }
     unreachable();

src/rdb_protocol/term_walker.cc

@@ -392,6 +392,7 @@ bool term_type_is_valid(Term::TermType type) {
     case Term::FLOOR:
     case Term::CEIL:
     case Term::ROUND:
+    case Term::FORMAT:
         return true;
     default:
         return false;
@@ -589,6 +590,7 @@ bool term_is_write_or_meta(Term::TermType type) {
     case Term::FLOOR:
     case Term::CEIL:
     case Term::ROUND:
+    case Term::FORMAT:
         return false;
     default: unreachable();
     }
@@ -784,6 +786,7 @@ bool term_forbids_writes(Term::TermType type) {
     case Term::FLOOR:
     case Term::CEIL:
     case Term::ROUND:
+    case Term::FORMAT:
         return false;
     default: unreachable();
     }

src/rdb_protocol/terms/string.cc

@@ -1,12 +1,14 @@
-// Copyright 2010-2015 RethinkDB, all rights reserved.
+// Copyright 2010-2022 RethinkDB, all rights reserved.
 #include "rdb_protocol/terms/terms.hpp"
 
 #include <re2/re2.h>
 
 #include <algorithm>
 
 #include "parsing/utf8.hpp"
+#include "rdb_protocol/datum_string.hpp"
 #include "rdb_protocol/error.hpp"
+#include "rdb_protocol/minidriver.hpp"
 #include "rdb_protocol/op.hpp"
 
 namespace ql {
@@ -125,6 +127,63 @@ class match_term_t : public op_term_t {
     virtual const char *name() const { return "match"; }
 };
 
+class format_term_t : public op_term_t {
+public:
+    format_term_t(compile_env_t *env, const raw_term_t &term)
+            : op_term_t{env, term, argspec_t{2}}, src_term{term}, compile_env{env} {}
+private:
+    virtual scoped_ptr_t <val_t> eval_impl(scope_env_t *env, args_t *args, eval_flags_t) const {
+        const std::string templ = args->arg(env, 0)->as_str().to_std();
+        const datum_t datum = args->arg(env, 1)->as_datum();
+
+        const size_t template_length = templ.size();
+        std::string formatted{};
+
+        for (size_t pos = 0; pos < template_length; ++pos) {
+            rcheck(templ[pos] != '}',
+                   base_exc_t::LOGIC,
+                   "No parameter tags to close");
+
+            if (templ[pos] == '{') {
+                size_t param_end_pos {1};
+                std::string param_name {};
+
+                while (pos + param_end_pos < template_length && templ[pos + param_end_pos] != '}') {
+                    char next_char{templ[pos + param_end_pos]};
+
+                    rcheck(next_char != '{',
+                           base_exc_t::LOGIC,
+                           "Nested template parameters are not allowed");
+
+                    param_name.push_back(next_char);
+                    ++param_end_pos;
+                }
+
+                rcheck(pos + param_end_pos != template_length,
+                       base_exc_t::LOGIC,
+                       "Parameter tag must be closed");
+
+                minidriver_t r{src_term.bt()};
+                datum_t field{datum.get_field(datum_string_t{param_name})};
+                counted_t<const term_t> term = compile_term(
+                        compile_env,r.expr(field).coerce_to("STRING").root_term());
+
+                formatted += term->eval(env)->as_datum().as_str().to_std();
+                pos += param_end_pos;
+            } else {
+                formatted += templ[pos];
+            }
+        }
+
+        return new_val(datum_t(formatted));
+    }
+
+    virtual const char *name() const { return "format"; }
+
+    raw_term_t src_term;
+    compile_env_t *compile_env;
+};
+
 template <typename It>
 It find_utf8_pred(It start, It end, std::function<bool(char32_t)> &&fn) {
     It pos(start);
@@ -304,5 +363,9 @@ counted_t<term_t> make_split_term(
         compile_env_t *env, const raw_term_t &term) {
     return make_counted<split_term_t>(env, term);
 }
+counted_t<term_t> make_format_term(
+        compile_env_t *env, const raw_term_t &term) {
+    return make_counted<format_term_t>(env, term);
+}
 
 }  // namespace ql

src/rdb_protocol/terms/terms.hpp

@@ -184,11 +184,13 @@ counted_t<term_t> make_json_term(
 counted_t<term_t> make_to_json_string_term(
     compile_env_t *env, const raw_term_t &term);
 
-// match.cc
+// string.cc
 counted_t<term_t> make_match_term(
     compile_env_t *env, const raw_term_t &term);
 counted_t<term_t> make_split_term(
     compile_env_t *env, const raw_term_t &term);
+counted_t<term_t> make_format_term(
+    compile_env_t *env, const raw_term_t &term);
 
 // case.cc
 counted_t<term_t> make_upcase_term(

test/rql_test/src/format.yaml

@@ -0,0 +1,51 @@
+desc: Tests string formatting function
+tests:
+    # Formatting at the middle of the text
+    - cd: r.format("With great {noun} comes great responsibility.", {"noun": "power"})
+      rb: r.format("With great {noun} comes great responsibility.", {"noun" => "power"})
+      ot: "With great power comes great responsibility."
+    # Formatting at the beginning and end of the text
+    - cd: r.format("{with} great power comes great {what}", {"with": "With", "what": "responsibility"})
+      rb: r.format("{with} great power comes great {what}", {"with" => "With", "what" => "responsibility"})
+      ot: "With great power comes great responsibility."
+    # Formatting with empty placeholder
+    - cd: r.format("With great {} comes great responsibility.", {"": "power"})
+      rb: r.format("With great {} comes great responsibility.", {"" => "power"})
+      ot: "With great power comes great responsibility."
+    # Parameter not found in text
+    - cd: r.format("With great power comes great responsibility.", {"text": "test" })
+      rb: r.format("With great power comes great responsibility.", {"text" => "test" })
+      ot: "With great power comes great responsibility."
+    # Using integers for formatting
+    - cd: r.format("{bottles} bottles of beer on the wall.", {"bottles": 100})
+      rb: r.format("{bottles} bottles of beer on the wall.", {"bottles" => 100})
+      ot: "100 bottles of beer on the wall."
+    # Using doubles for formatting
+    - cd: r.format("{bottles} bottles of beer on the wall.", {"bottles": 99.12345})
+      rb: r.format("{bottles} bottles of beer on the wall.", {"bottles" => 99.12345})
+      ot: "99.12345 bottles of beer on the wall."
+    # Using mixed values for formatting
+    - cd: r.format("x is not in {list}", {"list": ["one", 2, 3.45678, {"nine": 9}]})
+      rb: r.format("x is not in {list}", {"list" => ["one", 2, 3.45678, {"nine" => 9}]})
+      ot: "x is not in ["one",2,3.45678,{"nine":9}]"
+    # Placeholder not found in replacement parameters
+    - cd: r.format("foo {bar} baz", {})
+      rb: r.format("foo {bar} baz", {})
+      ot: err('ReqlNonExistenceError', 'No attribute `bar` in object'))
+    # Placeholder indicator curly braces is not closed
+    - cd: r.format("foo {bar baz", {"bar": "bar" })
+      rb: r.format("foo {bar baz", {"bar" => "bar" })
+      ot: err('ReqlQueryLogicError', 'Parameter tag must be closed')
+    # Placeholder indicator curly braces is not opened
+    - cd: r.format("foo bar} baz", {"bar": "bar" })
+      rb: r.format("foo bar} baz", {"bar" => "bar" })
+      ot: err('ReqlQueryLogicError', 'No parameter tags to close')
+    - cd: r.format("foo {{nested}} baz", {"nested": "bar" })
+      rb: r.format("foo {{nested}} baz", {"nested" => "bar" })
+      ot: err('ReqlQueryLogicError', 'Nested template parameters are not allowed')
+    - cd: r.format("{foo} {bar} {baz}", ["foo", "bar", "baz"])
+      ot: err('ReqlQueryLogicError', 'Expected type OBJECT but found ARRAY')
+    - cd: r.format("{foo} bar baz", "foo")
+      ot: err('ReqlQueryLogicError', 'Expected type OBJECT but found STRING')
+    - cd: r.format("{foo} bar baz", 1)
+      ot: err('ReqlQueryLogicError', 'Expected type OBJECT but found NUMBER')