gqlite 1.0.0 → 1.1.0

data/ext/gqlite/gqlite-amalgamate.cpp

@@ -68,6 +68,11 @@ namespace gqlite
     return _v;
   }
   template<>
+  inline std::string to_string<std::string_view>(const std::string_view& _v)
+  {
+    return std::string(_v);
+  }
+  template<>
   inline std::string to_string<const char*>(const char* const& _v)
   {
     return _v;
@@ -249,7 +254,9 @@ namespace gqlite
     unimplemented_error,
     // OpenCypher error code
     column_name_conflict = 100,
+    delete_connected_node,
     integer_overflow,
+    invalid_aggregation,
     invalid_argument_type,
     invalid_delete,
     invalid_number_literal,
@@ -523,12 +530,13 @@ namespace gqlite::oc::algebra
 {
   enum class expression_type
   {
-    empty, value, boolean, integer, floating_point, string, map, vector, node, edge, path
+    empty, value, boolean, integer, floating_point, string, map, vector, node, edge, path, all
   };
   struct expression_info
   {
     expression_type type = expression_type::empty;
     bool constant = true;
+    bool aggregation_result;
   };
 }
 //END oc/algebra/expression_info.h
@@ -669,6 +677,7 @@ TOKEN_KEYWORD(NOT)
 TOKEN_KEYWORD(MATCH)
 TOKEN_KEYWORD2(NULL_CAPS, "NULL")
 TOKEN_KEYWORD2(NULL_TOKEN, "null")
+TOKEN_KEYWORD(OPTIONAL)
 TOKEN_KEYWORD(OR)
 TOKEN_KEYWORD(ORDER)
 TOKEN_KEYWORD(REMOVE)
@@ -775,7 +784,8 @@ OC_ALGEBRA_GENERATE(create, OC_ALGEBRA_CREATE_NODES_MEMBERS)
 
 #define OC_ALGEBRA_MATCH_NODES_MEMBERS(_KLASS_NAME_, F)                                     \
   F(_KLASS_NAME_, std::vector<alternative<GQLITE_LIST(graph_node, graph_edge)>>, patterns)  \
-  F(_KLASS_NAME_, node_csp, where)
+  F(_KLASS_NAME_, node_csp, where)                                                          \
+  F(_KLASS_NAME_, bool, optional)
 
 OC_ALGEBRA_GENERATE(match, OC_ALGEBRA_MATCH_NODES_MEMBERS)
 
@@ -877,6 +887,7 @@ OC_ALGEBRA_GENERATE(edit_labels, OC_ALGEBRA_EDIT_LABELS_MEMBERS)
 
 #define OC_ALGEBRA_NO_MEMBERS(_KLASS_NAME_, F)
 
+OC_ALGEBRA_GENERATE(all, OC_ALGEBRA_NO_MEMBERS)
 OC_ALGEBRA_GENERATE(end_of_list, OC_ALGEBRA_NO_MEMBERS)
 
 #define OC_ALGEBRA_GRAPH_NODE_MEMBERS(_KLASS_NAME_, F)          \
@@ -901,7 +912,6 @@ OC_ALGEBRA_GENERATE(graph_edge, OC_ALGEBRA_GRAPH_EDGE_MEMBERS)
 
 OC_ALGEBRA_GENERATE(value, OC_ALGEBRA_VALUE_MEMBERS)
 
-
 #define OC_ALGEBRA_MAP_MEMBERS(_KLASS_NAME_, F) \
   F(_KLASS_NAME_, std::unordered_map<GQLITE_LIST(std::string, node_csp)>, map)
 
@@ -1133,7 +1143,8 @@ OC_ALGEBRA_GENERATE(create, OC_ALGEBRA_CREATE_NODES_MEMBERS)
 
 #define OC_ALGEBRA_MATCH_NODES_MEMBERS(_KLASS_NAME_, F)                                     \
   F(_KLASS_NAME_, std::vector<alternative<GQLITE_LIST(graph_node, graph_edge)>>, patterns)  \
-  F(_KLASS_NAME_, node_csp, where)
+  F(_KLASS_NAME_, node_csp, where)                                                          \
+  F(_KLASS_NAME_, bool, optional)
 
 OC_ALGEBRA_GENERATE(match, OC_ALGEBRA_MATCH_NODES_MEMBERS)
 
@@ -1235,6 +1246,7 @@ OC_ALGEBRA_GENERATE(edit_labels, OC_ALGEBRA_EDIT_LABELS_MEMBERS)
 
 #define OC_ALGEBRA_NO_MEMBERS(_KLASS_NAME_, F)
 
+OC_ALGEBRA_GENERATE(all, OC_ALGEBRA_NO_MEMBERS)
 OC_ALGEBRA_GENERATE(end_of_list, OC_ALGEBRA_NO_MEMBERS)
 
 #define OC_ALGEBRA_GRAPH_NODE_MEMBERS(_KLASS_NAME_, F)          \
@@ -1259,7 +1271,6 @@ OC_ALGEBRA_GENERATE(graph_edge, OC_ALGEBRA_GRAPH_EDGE_MEMBERS)
 
 OC_ALGEBRA_GENERATE(value, OC_ALGEBRA_VALUE_MEMBERS)
 
-
 #define OC_ALGEBRA_MAP_MEMBERS(_KLASS_NAME_, F) \
   F(_KLASS_NAME_, std::unordered_map<GQLITE_LIST(std::string, node_csp)>, map)
 
@@ -1376,7 +1387,8 @@ OC_ALGEBRA_GENERATE(create, OC_ALGEBRA_CREATE_NODES_MEMBERS)
 
 #define OC_ALGEBRA_MATCH_NODES_MEMBERS(_KLASS_NAME_, F)                                     \
   F(_KLASS_NAME_, std::vector<alternative<GQLITE_LIST(graph_node, graph_edge)>>, patterns)  \
-  F(_KLASS_NAME_, node_csp, where)
+  F(_KLASS_NAME_, node_csp, where)                                                          \
+  F(_KLASS_NAME_, bool, optional)
 
 OC_ALGEBRA_GENERATE(match, OC_ALGEBRA_MATCH_NODES_MEMBERS)
 
@@ -1478,6 +1490,7 @@ OC_ALGEBRA_GENERATE(edit_labels, OC_ALGEBRA_EDIT_LABELS_MEMBERS)
 
 #define OC_ALGEBRA_NO_MEMBERS(_KLASS_NAME_, F)
 
+OC_ALGEBRA_GENERATE(all, OC_ALGEBRA_NO_MEMBERS)
 OC_ALGEBRA_GENERATE(end_of_list, OC_ALGEBRA_NO_MEMBERS)
 
 #define OC_ALGEBRA_GRAPH_NODE_MEMBERS(_KLASS_NAME_, F)          \
@@ -1502,7 +1515,6 @@ OC_ALGEBRA_GENERATE(graph_edge, OC_ALGEBRA_GRAPH_EDGE_MEMBERS)
 
 OC_ALGEBRA_GENERATE(value, OC_ALGEBRA_VALUE_MEMBERS)
 
-
 #define OC_ALGEBRA_MAP_MEMBERS(_KLASS_NAME_, F) \
   F(_KLASS_NAME_, std::unordered_map<GQLITE_LIST(std::string, node_csp)>, map)
 
@@ -1618,7 +1630,8 @@ OC_ALGEBRA_GENERATE(create, OC_ALGEBRA_CREATE_NODES_MEMBERS)
 
 #define OC_ALGEBRA_MATCH_NODES_MEMBERS(_KLASS_NAME_, F)                                     \
   F(_KLASS_NAME_, std::vector<alternative<GQLITE_LIST(graph_node, graph_edge)>>, patterns)  \
-  F(_KLASS_NAME_, node_csp, where)
+  F(_KLASS_NAME_, node_csp, where)                                                          \
+  F(_KLASS_NAME_, bool, optional)
 
 OC_ALGEBRA_GENERATE(match, OC_ALGEBRA_MATCH_NODES_MEMBERS)
 
@@ -1720,6 +1733,7 @@ OC_ALGEBRA_GENERATE(edit_labels, OC_ALGEBRA_EDIT_LABELS_MEMBERS)
 
 #define OC_ALGEBRA_NO_MEMBERS(_KLASS_NAME_, F)
 
+OC_ALGEBRA_GENERATE(all, OC_ALGEBRA_NO_MEMBERS)
 OC_ALGEBRA_GENERATE(end_of_list, OC_ALGEBRA_NO_MEMBERS)
 
 #define OC_ALGEBRA_GRAPH_NODE_MEMBERS(_KLASS_NAME_, F)          \
@@ -1744,7 +1758,6 @@ OC_ALGEBRA_GENERATE(graph_edge, OC_ALGEBRA_GRAPH_EDGE_MEMBERS)
 
 OC_ALGEBRA_GENERATE(value, OC_ALGEBRA_VALUE_MEMBERS)
 
-
 #define OC_ALGEBRA_MAP_MEMBERS(_KLASS_NAME_, F) \
   F(_KLASS_NAME_, std::unordered_map<GQLITE_LIST(std::string, node_csp)>, map)
 
@@ -1877,7 +1890,8 @@ OC_ALGEBRA_GENERATE(create, OC_ALGEBRA_CREATE_NODES_MEMBERS)
 
 #define OC_ALGEBRA_MATCH_NODES_MEMBERS(_KLASS_NAME_, F)                                     \
   F(_KLASS_NAME_, std::vector<alternative<GQLITE_LIST(graph_node, graph_edge)>>, patterns)  \
-  F(_KLASS_NAME_, node_csp, where)
+  F(_KLASS_NAME_, node_csp, where)                                                          \
+  F(_KLASS_NAME_, bool, optional)
 
 OC_ALGEBRA_GENERATE(match, OC_ALGEBRA_MATCH_NODES_MEMBERS)
 
@@ -1979,6 +1993,7 @@ OC_ALGEBRA_GENERATE(edit_labels, OC_ALGEBRA_EDIT_LABELS_MEMBERS)
 
 #define OC_ALGEBRA_NO_MEMBERS(_KLASS_NAME_, F)
 
+OC_ALGEBRA_GENERATE(all, OC_ALGEBRA_NO_MEMBERS)
 OC_ALGEBRA_GENERATE(end_of_list, OC_ALGEBRA_NO_MEMBERS)
 
 #define OC_ALGEBRA_GRAPH_NODE_MEMBERS(_KLASS_NAME_, F)          \
@@ -2003,7 +2018,6 @@ OC_ALGEBRA_GENERATE(graph_edge, OC_ALGEBRA_GRAPH_EDGE_MEMBERS)
 
 OC_ALGEBRA_GENERATE(value, OC_ALGEBRA_VALUE_MEMBERS)
 
-
 #define OC_ALGEBRA_MAP_MEMBERS(_KLASS_NAME_, F) \
   F(_KLASS_NAME_, std::unordered_map<GQLITE_LIST(std::string, node_csp)>, map)
 
@@ -2137,7 +2151,8 @@ OC_ALGEBRA_GENERATE(create, OC_ALGEBRA_CREATE_NODES_MEMBERS)
 
 #define OC_ALGEBRA_MATCH_NODES_MEMBERS(_KLASS_NAME_, F)                                     \
   F(_KLASS_NAME_, std::vector<alternative<GQLITE_LIST(graph_node, graph_edge)>>, patterns)  \
-  F(_KLASS_NAME_, node_csp, where)
+  F(_KLASS_NAME_, node_csp, where)                                                          \
+  F(_KLASS_NAME_, bool, optional)
 
 OC_ALGEBRA_GENERATE(match, OC_ALGEBRA_MATCH_NODES_MEMBERS)
 
@@ -2239,6 +2254,7 @@ OC_ALGEBRA_GENERATE(edit_labels, OC_ALGEBRA_EDIT_LABELS_MEMBERS)
 
 #define OC_ALGEBRA_NO_MEMBERS(_KLASS_NAME_, F)
 
+OC_ALGEBRA_GENERATE(all, OC_ALGEBRA_NO_MEMBERS)
 OC_ALGEBRA_GENERATE(end_of_list, OC_ALGEBRA_NO_MEMBERS)
 
 #define OC_ALGEBRA_GRAPH_NODE_MEMBERS(_KLASS_NAME_, F)          \
@@ -2263,7 +2279,6 @@ OC_ALGEBRA_GENERATE(graph_edge, OC_ALGEBRA_GRAPH_EDGE_MEMBERS)
 
 OC_ALGEBRA_GENERATE(value, OC_ALGEBRA_VALUE_MEMBERS)
 
-
 #define OC_ALGEBRA_MAP_MEMBERS(_KLASS_NAME_, F) \
   F(_KLASS_NAME_, std::unordered_map<GQLITE_LIST(std::string, node_csp)>, map)
 
@@ -2400,7 +2415,8 @@ OC_ALGEBRA_GENERATE(create, OC_ALGEBRA_CREATE_NODES_MEMBERS)
 
 #define OC_ALGEBRA_MATCH_NODES_MEMBERS(_KLASS_NAME_, F)                                     \
   F(_KLASS_NAME_, std::vector<alternative<GQLITE_LIST(graph_node, graph_edge)>>, patterns)  \
-  F(_KLASS_NAME_, node_csp, where)
+  F(_KLASS_NAME_, node_csp, where)                                                          \
+  F(_KLASS_NAME_, bool, optional)
 
 OC_ALGEBRA_GENERATE(match, OC_ALGEBRA_MATCH_NODES_MEMBERS)
 
@@ -2502,6 +2518,7 @@ OC_ALGEBRA_GENERATE(edit_labels, OC_ALGEBRA_EDIT_LABELS_MEMBERS)
 
 #define OC_ALGEBRA_NO_MEMBERS(_KLASS_NAME_, F)
 
+OC_ALGEBRA_GENERATE(all, OC_ALGEBRA_NO_MEMBERS)
 OC_ALGEBRA_GENERATE(end_of_list, OC_ALGEBRA_NO_MEMBERS)
 
 #define OC_ALGEBRA_GRAPH_NODE_MEMBERS(_KLASS_NAME_, F)          \
@@ -2526,7 +2543,6 @@ OC_ALGEBRA_GENERATE(graph_edge, OC_ALGEBRA_GRAPH_EDGE_MEMBERS)
 
 OC_ALGEBRA_GENERATE(value, OC_ALGEBRA_VALUE_MEMBERS)
 
-
 #define OC_ALGEBRA_MAP_MEMBERS(_KLASS_NAME_, F) \
   F(_KLASS_NAME_, std::unordered_map<GQLITE_LIST(std::string, node_csp)>, map)
 
@@ -2639,19 +2655,19 @@ namespace gqlite::oc::algebra::visitors
       switch(_var->get_value().get_type())
       {
         case value_type::invalid:
-          return {expression_type::empty, true };
+          return {expression_type::empty, true, false};
         case value_type::boolean:
-          return {expression_type::boolean, true };
+          return {expression_type::boolean, true, false};
         case value_type::integer:
-          return {expression_type::integer, true };
+          return {expression_type::integer, true , false};
         case value_type::floating_point:
-          return {expression_type::floating_point, true };
+          return {expression_type::floating_point, true, false};
         case value_type::string:
-          return {expression_type::string, true };
+          return {expression_type::string, true, false};
         case value_type::map:
-          return {expression_type::map, true };
+          return {expression_type::map, true, false};
         case value_type::vector:
-          return {expression_type::vector, true };
+          return {expression_type::vector, true, false};
       };
       throw_exception(exception_stage::unspecified, exception_code::internal_error, "Unknown value type.");
     }
@@ -2667,32 +2683,50 @@ namespace gqlite::oc::algebra::visitors
       }
       return true;
     }
+    template<typename _T_>
+    bool aggregation_result_nodes(const _T_& _nodes)
+    {
+      for(algebra::node_csp n : _nodes)
+      {
+        if(start(n).aggregation_result)
+        {
+          return true;
+        }
+      }
+      return false;
+    }
     expression_info visit(algebra::array_csp _value) override
     {
-      return {expression_type::vector, constant_nodes(_value->get_array())};
+      return {expression_type::vector, constant_nodes(_value->get_array()), aggregation_result_nodes(_value->get_array())};
     }
     expression_info visit(algebra::map_csp _value) override
     {
-      return {expression_type::map, constant_nodes(workarounds::views::values(_value->get_map()))};
+      return {expression_type::map, constant_nodes(workarounds::views::values(_value->get_map())), aggregation_result_nodes(workarounds::views::values(_value->get_map()))};
     }
     expression_info visit(algebra::member_access_csp _ma) override
     {
-      return {expression_type::value, start(_ma->get_left()).constant};
+      return {expression_type::value, start(_ma->get_left()).constant, false};
+    }
+    expression_info visit(algebra::all_csp) override
+    {
+      return {expression_type::all, false, false};
     }
     expression_info visit(algebra::indexed_access_csp _ia) override
     {
-      return {expression_type::value, start(_ia->get_left()).constant};
+      return {expression_type::value, start(_ia->get_left()).constant, false};
     }
     expression_info visit(algebra::has_labels_csp) override
     {
-      return {expression_type::boolean, false};
+      return {expression_type::boolean, false, false};
     }
-#define GQLITE_ET_LOGICAL_OP(_NAME_)                              \
-    expression_info visit(algebra::_NAME_ ## _csp _node) override \
-    {                                                             \
-      bool constant = start(_node->get_left()).constant           \
-                  and start(_node->get_right()).constant;         \
-      return {expression_type::boolean, constant};                \
+#define GQLITE_ET_LOGICAL_OP(_NAME_)                                                  \
+    expression_info visit(algebra::_NAME_ ## _csp _node) override                     \
+    {                                                                                 \
+      expression_info left = start(_node->get_left());                                \
+      expression_info right = start(_node->get_right());                              \
+      bool constant = left.constant and right.constant;                               \
+      bool aggregation_result = left.aggregation_result or right.aggregation_result;  \
+      return {expression_type::boolean, constant, aggregation_result};                \
     }
     GQLITE_ET_LOGICAL_OP(logical_and)
     GQLITE_ET_LOGICAL_OP(logical_or)
@@ -2705,11 +2739,11 @@ namespace gqlite::oc::algebra::visitors
     GQLITE_ET_LOGICAL_OP(relational_superior_equal)
     GQLITE_ET_LOGICAL_OP(relational_in)
     GQLITE_ET_LOGICAL_OP(relational_not_in)
-#define GQLITE_ET_LOGICAL_UNARY_OP(_NAME_)                          \
-    expression_info visit(algebra::_NAME_ ## _csp _node) override   \
-    {                                                               \
-      bool constant = start(_node->get_value()).constant;           \
-      return {expression_type::boolean, constant};                  \
+#define GQLITE_ET_LOGICAL_UNARY_OP(_NAME_)                                        \
+    expression_info visit(algebra::_NAME_ ## _csp _node) override                 \
+    {                                                                             \
+      expression_info info = start(_node->get_value());                           \
+      return {expression_type::boolean, info.constant, info.aggregation_result};  \
     }
     GQLITE_ET_LOGICAL_UNARY_OP(is_null)
     GQLITE_ET_LOGICAL_UNARY_OP(is_not_null)
@@ -2719,21 +2753,22 @@ namespace gqlite::oc::algebra::visitors
       expression_info left = start(_node->get_left());                                                    \
       expression_info right = start(_node->get_right());                                                  \
       bool constant = left.constant and right.constant;                                                   \
-      if(left.type == right.type) return {left.type, constant};                                           \
+      bool aggregation_result = left.aggregation_result or right.aggregation_result;                      \
+      if(left.type == right.type) return {left.type, constant, aggregation_result};                       \
       if(left.type == expression_type::value or right.type == expression_type::value)                     \
-        return {expression_type::value, constant};                                                        \
+        return {expression_type::value, constant, aggregation_result};                                    \
       if(left.type == expression_type::floating_point or right.type == expression_type::floating_point)   \
       {                                                                                                   \
-        return {expression_type::floating_point, constant};                                               \
+        return {expression_type::floating_point, constant, aggregation_result};                           \
       }                                                                                                   \
       if(left.type == expression_type::string or right.type == expression_type::string)                   \
       {                                                                                                   \
-        return {expression_type::string, constant};                                                       \
+        return {expression_type::string, constant, aggregation_result};                                   \
       }                                                                                                   \
       if(std::is_same_v<algebra::_NAME_ ## _csp, algebra::addition_csp>                                   \
             and left.type == expression_type::vector)                                                     \
       {                                                                                                   \
-        return {expression_type::vector, constant};                                                       \
+        return {expression_type::vector, constant, aggregation_result};                                   \
       }                                                                                                   \
       errors::invalid_argument_type(stage, "In binary operation.");                                       \
     }
@@ -2745,18 +2780,19 @@ namespace gqlite::oc::algebra::visitors
 
     expression_info visit(algebra::logical_negation_csp _node)
     {
-      bool constant = start(_node->get_value()).constant;
-      return {expression_type::boolean, constant};
+      expression_info ei = start(_node->get_value());
+      return {expression_type::boolean, ei.constant, ei.aggregation_result};
     }
     expression_info visit(algebra::variable_csp _var) override
     {
-      return {variables_f(_var->get_identifier()), false};
+      return {variables_f(_var->get_identifier()), false, false};
     }
     struct function_info
     {
       expression_type return_type;
       std::vector<expression_type> arguments_types;
       bool deterministic;
+      bool aggregation;
     };
     static std::unordered_multimap<std::string, function_info> create_functions()
     {
@@ -2764,29 +2800,52 @@ namespace gqlite::oc::algebra::visitors
       using enum expression_type;
       using FI = function_info;
       using V = std::vector<expression_type>;
-      f.emplace("head", FI{value, V{vector}, true});
-      f.emplace("id", FI{integer, V{node}, true});
-      f.emplace("id", FI{integer, V{edge}, true});
-      f.emplace("keys", FI{vector, V{edge}, true});
-      f.emplace("keys", FI{vector, V{node}, true});
-      f.emplace("keys", FI{vector, V{map}, true});
-      f.emplace("labels", FI{vector, V{node}, true});
-      f.emplace("properties", FI{map, V{node}, true});
-      f.emplace("properties", FI{map, V{edge}, true});
-      f.emplace("properties", FI{map, V{map}, true});
-      f.emplace("range", FI{string, V{integer, integer}, true});
-      f.emplace("size", FI{integer, V{vector}, true});
-      f.emplace("tail", FI{vector, V{vector}, true});
-      f.emplace("toInteger", FI{integer, V{integer}, true});
-      f.emplace("toInteger", FI{integer, V{floating_point}, true});
-      f.emplace("type", FI{string, V{edge}, true});
+      f.emplace("head", FI{value, V{vector}, true, false});
+      f.emplace("id", FI{integer, V{node}, true, false});
+      f.emplace("id", FI{integer, V{edge}, true, false});
+      f.emplace("keys", FI{vector, V{edge}, true, false});
+      f.emplace("keys", FI{vector, V{node}, true, false});
+      f.emplace("keys", FI{vector, V{map}, true, false});
+      f.emplace("labels", FI{vector, V{node}, true, false});
+      f.emplace("properties", FI{map, V{node}, true, false});
+      f.emplace("properties", FI{map, V{edge}, true, false});
+      f.emplace("properties", FI{map, V{map}, true, false});
+      f.emplace("range", FI{string, V{integer, integer}, true, false});
+      f.emplace("size", FI{integer, V{vector}, true, false});
+      f.emplace("tail", FI{vector, V{vector}, true, false});
+      f.emplace("toInteger", FI{integer, V{integer}, true, false});
+      f.emplace("toInteger", FI{integer, V{floating_point}, true, false});
+      f.emplace("type", FI{string, V{edge}, true, false});
+      // aggregations
+      f.emplace("avg", FI{integer, V{value}, true, true});
+      f.emplace("count", FI{integer, V{value}, true, true});
+      f.emplace("count", FI{integer, V{all}, true, true});
+      f.emplace("collect", FI{vector, V{value}, true, true});
+      f.emplace("max", FI{value, V{value}, true, true});
+      f.emplace("min", FI{value, V{value}, true, true});
+      f.emplace("sum", FI{value, V{value}, true, true});
       return f;
     }
     expression_info visit(algebra::function_call_csp _node) override
     {
       if(_node->get_name() == "coalesce")
       { // coalesce is a special case that can accept any value
-        return {expression_type::value, constant_nodes(_node->get_arguments())};
+        expression_type et = expression_type::empty;
+        bool first = true;
+        for(const algebra::node_csp& n : _node->get_arguments())
+        {
+          expression_info ei = start(n);
+          if(first)
+          {
+            first = false;
+            et = ei.type;
+          } else if(et != ei.type)
+          {
+            et = expression_type::value;
+            break;
+          }
+        }
+        return {et, constant_nodes(_node->get_arguments()), aggregation_result_nodes(_node->get_arguments())};
       }
       // 1) Check if all arguments are constant and get their type
       bool constant_arguments = true;
@@ -2815,7 +2874,7 @@ namespace gqlite::oc::algebra::visitors
             }
             break;
           }
-          if(match) return {it->second.return_type, it->second.deterministic and constant_arguments};
+          if(match) return {it->second.return_type, it->second.deterministic and constant_arguments, it->second.aggregation};
         }
       }
       // 3) If no function was found, return an exception for unknown function or invalid arguments
@@ -2876,6 +2935,10 @@ namespace gqlite::oc::algebra::visitors
     std::string visit(algebra::value_csp _var) override
     {
       return _var->get_value().to_json();
+    }
+    std::string visit(algebra::all_csp) override
+    {
+      return "*";
     }
      std::string visit(algebra::array_csp _var) override
     {
@@ -2922,9 +2985,16 @@ namespace gqlite::oc::algebra::visitors
 #define GQLITE_STRINGIFY_UNARY_OP(_NAME_, _OP_)                                   \
     std::string visit(algebra::_NAME_ ## _csp _var) override                      \
     {                                                                             \
-      return # _OP_ " " + start(_var->get_value());                                 \
+      return # _OP_ " " + start(_var->get_value());                               \
     }
     GQLITE_STRINGIFY_UNARY_OP(logical_negation, NOT)
+#define GQLITE_STRINGIFY_UNARY_END_OP(_NAME_, _OP_)                               \
+    std::string visit(algebra::_NAME_ ## _csp _var) override                      \
+    {                                                                             \
+      return start(_var->get_value()) + " " # _OP_;                               \
+    }
+    GQLITE_STRINGIFY_UNARY_END_OP(is_null, IS NULL)
+    GQLITE_STRINGIFY_UNARY_END_OP(is_not_null, IS NOT NULL)
     std::string visit(algebra::variable_csp _var) override
     {
       return _var->get_identifier();
@@ -2984,7 +3054,7 @@ namespace gqlite
 
 namespace gqlite::backends::sqlite_queries
 {
-  std::string edge_add_properties(const std::string& _graph_name, const std::string& _what, const std::string& _expr, const std::string& _path, const std::string& _edge_id)
+  inline std::string edge_add_properties(const std::string& _graph_name, const std::string& _what, const std::string& _expr, const std::string& _path, const std::string& _edge_id)
   {
     std::stringstream stream;
     
@@ -2996,11 +3066,11 @@ stream << "_edges AS tblu SET properties=json_patch(tblu.properties, json_set('{
 
 stream << ( _path );
 
-stream << "\", ";
+stream << "\", gqlite_jsonify(";
 
 stream << ( _expr );
 
-stream << ")) ";
+stream << "))) ";
 
 stream << ( _what );
 
@@ -3010,19 +3080,24 @@ stream << ( _edge_id );
 
     return stream.str();
   }
-  std::string edge_count_by_node(const std::string& _graph_name)
+  inline std::string edge_count_by_nodes(const std::string& _graph_name, const std::string& _what)
   {
     std::stringstream stream;
     
-stream << "SELECT count(*) FROM gqlite_";
+stream << "WITH source_delete AS NOT MATERIALIZED (";
+
+stream << ( _what );
+
+stream << ")\n"
+"SELECT count(*) FROM gqlite_";
 
 stream << ( _graph_name );
 
-stream << "_edges WHERE left=?001 or right=?001";
+stream << "_edges WHERE left IN source_delete or right IN source_delete";
 
     return stream.str();
   }
-  std::string edge_create(const std::string& _graph_name, const std::string& _values)
+  inline std::string edge_create(const std::string& _graph_name, const std::string& _values)
   {
     std::stringstream stream;
     
@@ -3030,7 +3105,7 @@ stream << "INSERT INTO gqlite_";
 
 stream << ( _graph_name );
 
-stream << "_edges (label, properties, left, right) ";
+stream << "_edges (id, label, properties, left, right) ";
 
 stream << ( _values );
 
@@ -3040,7 +3115,7 @@ stream << "\n"
 
     return stream.str();
   }
-  std::string edge_delete(const std::string& _graph_name, const std::string& _what)
+  inline std::string edge_delete(const std::string& _graph_name, const std::string& _what)
   {
     std::stringstream stream;
     
@@ -3056,7 +3131,7 @@ stream << ")";
 
     return stream.str();
   }
-  std::string edge_delete_by_node(const std::string& _graph_name, const std::string& _what)
+  inline std::string edge_delete_by_nodes(const std::string& _graph_name, const std::string& _what)
   {
     std::stringstream stream;
     
@@ -3073,7 +3148,7 @@ stream << "_edges WHERE left IN source_delete or right IN source_delete";
 
     return stream.str();
   }
-  std::string edge_get_label_properties(const std::string& _graph_name)
+  inline std::string edge_get_label_properties(const std::string& _graph_name)
   {
     std::stringstream stream;
     
@@ -3085,7 +3160,7 @@ stream << "_edges WHERE id = ?001";
 
     return stream.str();
   }
-  std::string edge_set_property(const std::string& _graph_name, const std::string& _what, const std::string& _expr, const std::string& _path, const std::string& _edge_id)
+  inline std::string edge_set_property(const std::string& _graph_name, const std::string& _what, const std::string& _expr, const std::string& _path, const std::string& _edge_id)
   {
     std::stringstream stream;
     
@@ -3097,11 +3172,11 @@ stream << "_edges AS tblu SET properties=json_patch('{}', json_set(tblu.properti
 
 stream << ( _path );
 
-stream << "\", ";
+stream << "\", gqlite_jsonify(";
 
 stream << ( _expr );
 
-stream << ")) ";
+stream << "))) ";
 
 stream << ( _what );
 
@@ -3111,7 +3186,7 @@ stream << ( _edge_id );
 
     return stream.str();
   }
-  std::string edge_remove_property(const std::string& _graph_name, const std::string& _what, const std::string& _path, const std::string& _edge_id)
+  inline std::string edge_remove_property(const std::string& _graph_name, const std::string& _what, const std::string& _path, const std::string& _edge_id)
   {
     std::stringstream stream;
     
@@ -3133,26 +3208,34 @@ stream << ( _edge_id );
 
     return stream.str();
   }
-  std::string function_labels(const std::string& _graph_name, const std::string& _node_id)
+  inline std::string function_labels(const std::string& _graph_name, const std::string& _node_id)
   {
     std::stringstream stream;
     
-stream << "(SELECT json_group_array(labels.label)\n"
-"            FROM gqlite_";
+stream << "(CASE WHEN ";
+
+stream << ( _node_id );
+
+stream << " IS NULL\n"
+"  THEN NULL\n"
+"  ELSE\n"
+"    (SELECT json_group_array(labels.label)\n"
+"                FROM gqlite_";
 
 stream << ( _graph_name );
 
 stream << "_labels as l\n"
-"            JOIN gqlite_labels AS labels ON labels.id = l.label WHERE l.node_id = ";
+"                JOIN gqlite_labels AS labels ON labels.id = l.label WHERE l.node_id = ";
 
 stream << ( _node_id );
 
 stream << ")\n"
+"  END)\n"
 "";
 
     return stream.str();
   }
-  std::string get_debug_stats(const std::string& _graph_name)
+  inline std::string get_debug_stats(const std::string& _graph_name)
   {
     std::stringstream stream;
     
@@ -3186,11 +3269,26 @@ stream << "_edges t, json_each(properties) j\n"
 
 stream << ( _graph_name );
 
-stream << "_labels";
+stream << "_labels\n"
+"UNION ALL SELECT COUNT(DISTINCT label) FROM (SELECT label FROM gqlite_";
+
+stream << ( _graph_name );
+
+stream << "_edges UNION SELECT label FROM gqlite_";
+
+stream << ( _graph_name );
+
+stream << "_labels)\n"
+"UNION ALL SELECT COUNT(DISTINCT label) FROM gqlite_";
+
+stream << ( _graph_name );
+
+stream << "_labels\n"
+"";
 
     return stream.str();
   }
-  std::string graph_create(const std::string& _graph_name)
+  inline std::string graph_create(const std::string& _graph_name)
   {
     std::stringstream stream;
     
@@ -3269,7 +3367,8 @@ stream << ( _graph_name );
 
 stream << "_labels as l ON l.node_id = n.id\n"
 "            LEFT JOIN gqlite_labels AS labels ON labels.id = l.label\n"
-"            GROUP BY n.id);\n"
+"            GROUP BY n.id)\n"
+"        UNION SELECT NULL, NULL;\n"
 "\n"
 "CREATE VIEW gqlite_";
 
@@ -3285,12 +3384,12 @@ stream << ( _graph_name );
 
 stream << "_edges e\n"
 "          JOIN gqlite_labels label ON label.id = e.label\n"
-"\n"
+"        UNION SELECT NULL, NULL\n"
 "";
 
     return stream.str();
   }
-  std::string graph_has(const std::string& _graph_name)
+  inline std::string graph_has(const std::string& _graph_name)
   {
     std::stringstream stream;
     
@@ -3312,7 +3411,7 @@ stream << "_labels')";
 
     return stream.str();
   }
-  std::string label_create_table()
+  inline std::string label_create_table()
   {
     std::stringstream stream;
     
@@ -3321,7 +3420,7 @@ stream << "CREATE TABLE gqlite_labels(id INTEGER PRIMARY KEY AUTOINCREMENT, labe
 
     return stream.str();
   }
-  std::string label_get_from_id()
+  inline std::string label_get_from_id()
   {
     std::stringstream stream;
     
@@ -3330,7 +3429,7 @@ stream << "SELECT label FROM gqlite_labels WHERE id = ?001\n"
 
     return stream.str();
   }
-  std::string label_get_from_name()
+  inline std::string label_get_from_name()
   {
     std::stringstream stream;
     
@@ -3339,7 +3438,7 @@ stream << "SELECT id FROM gqlite_labels WHERE label = ?001\n"
 
     return stream.str();
   }
-  std::string label_insert()
+  inline std::string label_insert()
   {
     std::stringstream stream;
     
@@ -3347,7 +3446,7 @@ stream << "INSERT INTO gqlite_labels(label) VALUES (?001)";
 
     return stream.str();
   }
-  std::string node_add_label(const std::string& _graph_name)
+  inline std::string node_add_label(const std::string& _graph_name)
   {
     std::stringstream stream;
     
@@ -3355,11 +3454,11 @@ stream << "INSERT INTO gqlite_";
 
 stream << ( _graph_name );
 
-stream << "_labels(label, node_id)  SELECT label.value, node.value FROM json_each(?001) label  JOIN json_each(?002) node";
+stream << "_labels(label, node_id)  SELECT label.value, node.value FROM json_each(?001) label  JOIN json_each(?002) node WHERE node.value IS NOT NULL";
 
     return stream.str();
   }
-  std::string node_add_labels(const std::string& _graph_name, const std::string& _what)
+  inline std::string node_add_labels(const std::string& _graph_name, const std::string& _what)
   {
     std::stringstream stream;
     
@@ -3376,7 +3475,7 @@ stream << "\n"
 
     return stream.str();
   }
-  std::string node_add_properties(const std::string& _graph_name, const std::string& _what, const std::string& _expr, const std::string& _path, const std::string& _node_id)
+  inline std::string node_add_properties(const std::string& _graph_name, const std::string& _what, const std::string& _expr, const std::string& _path, const std::string& _node_id)
   {
     std::stringstream stream;
     
@@ -3388,11 +3487,11 @@ stream << "_nodes AS tblu SET properties=json_patch(tblu.properties, json_set('{
 
 stream << ( _path );
 
-stream << "\", ";
+stream << "\", gqlite_jsonify(";
 
 stream << ( _expr );
 
-stream << ")) ";
+stream << "))) ";
 
 stream << ( _what );
 
@@ -3402,7 +3501,7 @@ stream << ( _node_id );
 
     return stream.str();
   }
-  std::string node_create(const std::string& _graph_name, const std::string& _values)
+  inline std::string node_create(const std::string& _graph_name, const std::string& _values)
   {
     std::stringstream stream;
     
@@ -3410,7 +3509,7 @@ stream << "INSERT INTO gqlite_";
 
 stream << ( _graph_name );
 
-stream << "_nodes (properties) ";
+stream << "_nodes (id, properties) ";
 
 stream << ( _values );
 
@@ -3419,7 +3518,7 @@ stream << "\n"
 
     return stream.str();
   }
-  std::string node_delete(const std::string& _graph_name, const std::string& _what)
+  inline std::string node_delete(const std::string& _graph_name, const std::string& _what)
   {
     std::stringstream stream;
     
@@ -3444,7 +3543,7 @@ stream << ")";
 
     return stream.str();
   }
-  std::string node_get_labels(const std::string& _graph_name)
+  inline std::string node_get_labels(const std::string& _graph_name)
   {
     std::stringstream stream;
     
@@ -3456,7 +3555,7 @@ stream << "_labels WHERE node_id = ?001";
 
     return stream.str();
   }
-  std::string node_get_properties(const std::string& _graph_name)
+  inline std::string node_get_properties(const std::string& _graph_name)
   {
     std::stringstream stream;
     
@@ -3468,7 +3567,7 @@ stream << "_nodes WHERE id = ?001";
 
     return stream.str();
   }
-  std::string node_remove_label(const std::string& _graph_name, const std::string& _what, const std::string& _labels)
+  inline std::string node_remove_label(const std::string& _graph_name, const std::string& _what, const std::string& _labels)
   {
     std::stringstream stream;
     
@@ -3489,7 +3588,7 @@ stream << ")\n"
 
     return stream.str();
   }
-  std::string node_remove_property(const std::string& _graph_name, const std::string& _what, const std::string& _path, const std::string& _node_id)
+  inline std::string node_remove_property(const std::string& _graph_name, const std::string& _what, const std::string& _path, const std::string& _node_id)
   {
     std::stringstream stream;
     
@@ -3511,7 +3610,7 @@ stream << ( _node_id );
 
     return stream.str();
   }
-  std::string node_set_property(const std::string& _graph_name, const std::string& _what, const std::string& _expr, const std::string& _path, const std::string& _node_id)
+  inline std::string node_set_property(const std::string& _graph_name, const std::string& _what, const std::string& _expr, const std::string& _path, const std::string& _node_id)
   {
     std::stringstream stream;
     
@@ -3523,11 +3622,11 @@ stream << "_nodes AS tblu SET properties=json_patch('{}', json_set(tblu.properti
 
 stream << ( _path );
 
-stream << "\", ";
+stream << "\", gqlite_jsonify(";
 
 stream << ( _expr );
 
-stream << ")) ";
+stream << "))) ";
 
 stream << ( _what );
 
@@ -3537,7 +3636,7 @@ stream << ( _node_id );
 
     return stream.str();
   }
-  std::string node_select_many(const std::string& _graph_name, int _idx)
+  inline std::string node_select_many(const std::string& _graph_name, int _idx)
   {
     std::stringstream stream;
     
@@ -3556,12 +3655,32 @@ stream << ") s ON s.value = nas.id\n"
 
     return stream.str();
   }
-  std::string table_has()
+  inline std::string table_has()
   {
     std::stringstream stream;
     
 stream << "SELECT count(*) FROM sqlite_master WHERE type='table' AND (name=?001)";
 
+    return stream.str();
+  }
+  inline std::string uid_create_table()
+  {
+    std::stringstream stream;
+    
+stream << "CREATE TABLE gqlite_uids(name TEXT PRIMARY KEY, value INTEGER NOT NULL);\n"
+"INSERT INTO gqlite_uids VALUES ('nodes', 0);\n"
+"INSERT INTO gqlite_uids VALUES ('edges', 0)\n"
+"";
+
+    return stream.str();
+  }
+  inline std::string uid_next()
+  {
+    std::stringstream stream;
+    
+stream << "UPDATE gqlite_uids SET value=value+1 WHERE name=?001\n"
+"RETURNING value";
+
     return stream.str();
   }
 }
@@ -3646,6 +3765,11 @@ connection connection::create_from_sqlite_file(const std::string& _filename, con
 
 value connection::execute_oc_query(const std::string& _string, const value_map& _bindings)
 {
+#if 0
+  std::cout << "============= execute_oc_query =============\n"
+            << _string <<
+             "\n============================================" << std::endl;
+#endif
   std::stringstream ss(_string);
   oc::lexer l(&ss);
   oc::parser parser(&l, _bindings);
@@ -3776,8 +3900,12 @@ const char* exception::what() const throw()
         d->full_error += "UnimplementedError: "; break;
       case column_name_conflict:
         d->full_error += "ColumnNameConflict: "; break;
+      case delete_connected_node:
+        d->full_error += "DeleteConnectedNode: "; break;
       case integer_overflow:
         d->full_error += "IntegerOverflow: "; break;
+      case invalid_aggregation:
+        d->full_error += "InvalidAggregation: "; break;
       case invalid_argument_type:
         d->full_error += "InvalidArgumentType: "; break;
       case invalid_delete:
@@ -4549,6 +4677,7 @@ TOKEN_KEYWORD(NOT)
 TOKEN_KEYWORD(MATCH)
 TOKEN_KEYWORD2(NULL_CAPS, "NULL")
 TOKEN_KEYWORD2(NULL_TOKEN, "null")
+TOKEN_KEYWORD(OPTIONAL)
 TOKEN_KEYWORD(OR)
 TOKEN_KEYWORD(ORDER)
 TOKEN_KEYWORD(REMOVE)
@@ -4786,14 +4915,14 @@ struct parser::data
   int id = 0;
   algebra::node_csp parse_call();
   algebra::node_csp parse_create();
-  algebra::node_csp parse_match();
+  algebra::node_csp parse_match(bool _optional);
   algebra::node_csp parse_return();
   algebra::node_csp parse_with();
   algebra::node_csp parse_unwind();
   algebra::node_csp parse_delete();
   algebra::node_csp parse_set();
   algebra::node_csp parse_remove();
-  algebra::modifiers_csp parse_modifiers();
+  algebra::modifiers_csp parse_modifiers(const std::vector<algebra::named_expression_csp>& _expressions);
   std::vector<algebra::alternative<algebra::graph_node, algebra::graph_edge>> parse_patterns(bool _creation_mode);
   algebra::node_csp parse_map();
   algebra::node_csp parse_properties();
@@ -4973,7 +5102,7 @@ algebra::node_csp parser::data::parse_create()
   return std::make_shared<algebra::create>(parse_patterns(true));
 }
 
-algebra::node_csp parser::data::parse_match()
+algebra::node_csp parser::data::parse_match(bool _optional)
 {
   get_next_token();
   std::vector<algebra::alternative<algebra::graph_node, algebra::graph_edge>> patterns = parse_patterns(false);
@@ -4982,8 +5111,12 @@ algebra::node_csp parser::data::parse_match()
   {
     get_next_token();
     where = parse_expression();
+    if(expression_analyser.start(where).aggregation_result)
+    {
+      report_error(tok, exception_code::invalid_aggregation, "in where expression.");
+    }
   }
-  return std::make_shared<algebra::match>(patterns, where);
+  return std::make_shared<algebra::match>(patterns, where, _optional);
 }
 
 std::vector<algebra::named_expression_csp> parser::data::parse_named_expressions()
@@ -5030,7 +5163,7 @@ algebra::node_csp parser::data::parse_with()
   if(tok.type == token_type::STAR)
   {
     get_next_token();
-    return std::make_shared<algebra::with>(true, std::vector<algebra::named_expression_csp>(), parse_modifiers());
+    return std::make_shared<algebra::with>(true, std::vector<algebra::named_expression_csp>(), parse_modifiers({}));
   }
   std::vector<algebra::named_expression_csp> named_expressions = parse_named_expressions();
   std::vector<std::string> new_variables;
@@ -5048,8 +5181,8 @@ algebra::node_csp parser::data::parse_with()
       ++it;
     }
   }
-  gqlite_debug("With new variables {} kept variables {}", new_variables, std::views::keys(bounded_variables));
-  return std::make_shared<algebra::with>(false, named_expressions, parse_modifiers());
+  // gqlite_debug("With new variables {} kept variables {}", new_variables, std::views::keys(bounded_variables));
+  return std::make_shared<algebra::with>(false, named_expressions, parse_modifiers(named_expressions));
 }
 
 algebra::node_csp parser::data::parse_unwind()
@@ -5218,14 +5351,14 @@ algebra::node_csp parser::data::parse_return()
   if(tok.type == token_type::STAR)
   {
     get_next_token();
-    return std::make_shared<algebra::return_statement>(true, std::vector<algebra::named_expression_csp>(), parse_modifiers());
+    return std::make_shared<algebra::return_statement>(true, std::vector<algebra::named_expression_csp>(), parse_modifiers({}));
   }
   std::vector<algebra::named_expression_csp> named_expressions = parse_named_expressions();
   for(algebra::named_expression_csp ne : named_expressions)
   {
     bind_variable(ne->get_name(), ne->get_expression(), expression_analyser.start(ne->get_expression()).type, true);
   }
-  return std::make_shared<algebra::return_statement>(false, named_expressions, parse_modifiers());
+  return std::make_shared<algebra::return_statement>(false, named_expressions, parse_modifiers(named_expressions));
 }
 
 namespace
@@ -5241,7 +5374,7 @@ namespace
   };
 }
 
-algebra::modifiers_csp parser::data::parse_modifiers()
+algebra::modifiers_csp parser::data::parse_modifiers(const std::vector<algebra::named_expression_csp>& _expressions)
 {
   algebra::node_csp skip, limit;
   algebra::order_by_csp order_by;
@@ -5285,6 +5418,24 @@ algebra::modifiers_csp parser::data::parse_modifiers()
         {
           bool asc = true;
           algebra::node_csp expression = parse_expression();
+          if(expression_analyser.start(expression).aggregation_result)
+          {
+            bool has_same = false;
+
+            for(const algebra::named_expression_csp& ne : _expressions)
+            {
+              if(ne->get_expression()->equals(expression))
+              {
+                has_same = true;
+                break;
+              }
+            }
+            if(not has_same)
+            {
+              report_error(tok, exception_code::invalid_aggregation, "in order by expression.");
+            }
+
+          }
           if(tok.type == token_type::ASC)
           {
             get_next_token();
@@ -5660,6 +5811,11 @@ algebra::node_csp parser::data::parse_terminal_expression()
     get_next_token();
     return std::make_shared<algebra::value>(it->second);
   }
+  case token_type::STAR:
+  {
+    get_next_token();
+    return std::make_shared<algebra::all>();
+  }
   default:
     report_unexpected(tok);
   }
@@ -5769,29 +5925,71 @@ algebra::node_csp parser::data::parse_relational_expression()
       }
     }
     case token_type::EQUAL:
-      get_next_token();
-      return std::make_shared<algebra::relational_equal>(node, parse_relational_expression());
     case token_type::DIFFERENT:
-      get_next_token();
-      return std::make_shared<algebra::relational_different>(node, parse_relational_expression());
     case token_type::INFERIOR:
-      get_next_token();
-      return std::make_shared<algebra::relational_inferior>(node, parse_relational_expression());
     case token_type::SUPERIOR:
-      get_next_token();
-      return std::make_shared<algebra::relational_superior>(node, parse_relational_expression());
     case token_type::INFERIOR_EQUAL:
-      get_next_token();
-      return std::make_shared<algebra::relational_inferior_equal>(node, parse_relational_expression());
     case token_type::SUPERIOR_EQUAL:
-      get_next_token();
-      return std::make_shared<algebra::relational_superior_equal>(node, parse_relational_expression());
+    {
+      algebra::node_csp out_node;
+      while(tok.type != token_type::END_OF_FILE)
+      {
+        token_type current_op = tok.type;
+        get_next_token();
+        algebra::node_csp node_rhs = parse_additive_expression();
+        algebra::node_csp current_rel_node;
+        switch (current_op)
+        {
+        case token_type::EQUAL:
+          current_rel_node = std::make_shared<algebra::relational_equal>(node, node_rhs);
+          break;
+        case token_type::DIFFERENT:
+          current_rel_node =  std::make_shared<algebra::relational_different>(node, node_rhs);
+          break;
+        case token_type::INFERIOR:
+          current_rel_node =  std::make_shared<algebra::relational_inferior>(node, node_rhs);
+          break;
+        case token_type::SUPERIOR:
+          current_rel_node =  std::make_shared<algebra::relational_superior>(node, node_rhs);
+          break;
+        case token_type::INFERIOR_EQUAL:
+          current_rel_node =  std::make_shared<algebra::relational_inferior_equal>(node, node_rhs);
+          break;
+        case token_type::SUPERIOR_EQUAL:
+          current_rel_node =  std::make_shared<algebra::relational_superior_equal>(node, node_rhs);
+          break;
+        default:
+          report_error(tok, exception_code::internal_error, "While parsing relational expression.");
+        }
+        if(out_node)
+        {
+          out_node = std::make_shared<algebra::logical_and>(out_node, current_rel_node);
+        } else {
+          out_node = current_rel_node;
+        }
+        switch(tok.type)
+        {
+        case token_type::EQUAL:
+        case token_type::DIFFERENT:
+        case token_type::INFERIOR:
+        case token_type::SUPERIOR:
+        case token_type::INFERIOR_EQUAL:
+        case token_type::SUPERIOR_EQUAL:
+          node = node_rhs;
+          break;
+        default:
+          return out_node;
+        }
+      }
+      report_unexpected(tok);
+    }
+
     case token_type::IN:
       {
         get_next_token();
         algebra::node_csp container = parse_expression();
         algebra::expression_type container_type = expression_analyser.start(container).type;
-        errors::check_argument_types(container_type, {algebra::expression_type::map, algebra::expression_type::vector, algebra::expression_type::value}, exception_stage::compiletime, "Relational IN can only be applied on vector/map.");
+        errors::check_argument_types(container_type, {algebra::expression_type::map, algebra::expression_type::vector, algebra::expression_type::value, algebra::expression_type::empty}, exception_stage::compiletime, "Relational IN can only be applied on vector/map.");
         if(container_type == algebra::expression_type::map)
         {
           errors::check_argument_types(expression_analyser.start(node).type, {algebra::expression_type::string, algebra::expression_type::value}, exception_stage::compiletime, "Relational IN on map expect a string.");
@@ -6021,8 +6219,13 @@ algebra::node_csp parser::parse()
     case token_type::CREATE:
       nodes.push_back(d->parse_create());
       break;
+    case token_type::OPTIONAL:
+      d->get_next_token();
+      d->is_of_type(token_type::MATCH);
+      nodes.push_back(d->parse_match(true));
+      break;
     case token_type::MATCH:
-      nodes.push_back(d->parse_match());
+      nodes.push_back(d->parse_match(false));
       break;
     case token_type::WITH:
       nodes.push_back(d->parse_with());
@@ -6175,6 +6378,7 @@ TOKEN_KEYWORD(NOT)
 TOKEN_KEYWORD(MATCH)
 TOKEN_KEYWORD2(NULL_CAPS, "NULL")
 TOKEN_KEYWORD2(NULL_TOKEN, "null")
+TOKEN_KEYWORD(OPTIONAL)
 TOKEN_KEYWORD(OR)
 TOKEN_KEYWORD(ORDER)
 TOKEN_KEYWORD(REMOVE)
@@ -6245,7 +6449,8 @@ OC_ALGEBRA_GENERATE(create, OC_ALGEBRA_CREATE_NODES_MEMBERS)
 
 #define OC_ALGEBRA_MATCH_NODES_MEMBERS(_KLASS_NAME_, F)                                     \
   F(_KLASS_NAME_, std::vector<alternative<GQLITE_LIST(graph_node, graph_edge)>>, patterns)  \
-  F(_KLASS_NAME_, node_csp, where)
+  F(_KLASS_NAME_, node_csp, where)                                                          \
+  F(_KLASS_NAME_, bool, optional)
 
 OC_ALGEBRA_GENERATE(match, OC_ALGEBRA_MATCH_NODES_MEMBERS)
 
@@ -6347,6 +6552,7 @@ OC_ALGEBRA_GENERATE(edit_labels, OC_ALGEBRA_EDIT_LABELS_MEMBERS)
 
 #define OC_ALGEBRA_NO_MEMBERS(_KLASS_NAME_, F)
 
+OC_ALGEBRA_GENERATE(all, OC_ALGEBRA_NO_MEMBERS)
 OC_ALGEBRA_GENERATE(end_of_list, OC_ALGEBRA_NO_MEMBERS)
 
 #define OC_ALGEBRA_GRAPH_NODE_MEMBERS(_KLASS_NAME_, F)          \
@@ -6371,7 +6577,6 @@ OC_ALGEBRA_GENERATE(graph_edge, OC_ALGEBRA_GRAPH_EDGE_MEMBERS)
 
 OC_ALGEBRA_GENERATE(value, OC_ALGEBRA_VALUE_MEMBERS)
 
-
 #define OC_ALGEBRA_MAP_MEMBERS(_KLASS_NAME_, F) \
   F(_KLASS_NAME_, std::unordered_map<GQLITE_LIST(std::string, node_csp)>, map)
 
@@ -6592,7 +6797,8 @@ OC_ALGEBRA_GENERATE(create, OC_ALGEBRA_CREATE_NODES_MEMBERS)
 
 #define OC_ALGEBRA_MATCH_NODES_MEMBERS(_KLASS_NAME_, F)                                     \
   F(_KLASS_NAME_, std::vector<alternative<GQLITE_LIST(graph_node, graph_edge)>>, patterns)  \
-  F(_KLASS_NAME_, node_csp, where)
+  F(_KLASS_NAME_, node_csp, where)                                                          \
+  F(_KLASS_NAME_, bool, optional)
 
 OC_ALGEBRA_GENERATE(match, OC_ALGEBRA_MATCH_NODES_MEMBERS)
 
@@ -6694,6 +6900,7 @@ OC_ALGEBRA_GENERATE(edit_labels, OC_ALGEBRA_EDIT_LABELS_MEMBERS)
 
 #define OC_ALGEBRA_NO_MEMBERS(_KLASS_NAME_, F)
 
+OC_ALGEBRA_GENERATE(all, OC_ALGEBRA_NO_MEMBERS)
 OC_ALGEBRA_GENERATE(end_of_list, OC_ALGEBRA_NO_MEMBERS)
 
 #define OC_ALGEBRA_GRAPH_NODE_MEMBERS(_KLASS_NAME_, F)          \
@@ -6718,7 +6925,6 @@ OC_ALGEBRA_GENERATE(graph_edge, OC_ALGEBRA_GRAPH_EDGE_MEMBERS)
 
 OC_ALGEBRA_GENERATE(value, OC_ALGEBRA_VALUE_MEMBERS)
 
-
 #define OC_ALGEBRA_MAP_MEMBERS(_KLASS_NAME_, F) \
   F(_KLASS_NAME_, std::unordered_map<GQLITE_LIST(std::string, node_csp)>, map)
 
@@ -7233,11 +7439,17 @@ namespace gqlite::backends::sqlite_oc_executor
   struct sql_query_builder
   {
     std::size_t uid = 0;
-    std::size_t table_count = 0;
     std::string variables;
-    std::string tables;
+    std::string group_variables;
+    bool has_aggregation_result = false;
+    struct table
+    {
+      sql_join join;
+      std::string table, name;
+    };
+    std::vector<table> tables;
     std::string join_conditions;
-    std::string where_conditions;
+    // std::string where_conditions;
     std::string modifiers;
     std::map<int, value> bindings;
     std::size_t next_uid()
@@ -7253,40 +7465,35 @@ namespace gqlite::backends::sqlite_oc_executor
     /**
      * Add a new variable with a generic name format.
      */
-    std::string add_variable(const std::string& _expression, const char* _format = "var_{}")
+    std::string add_variable(const std::string& _expression, bool _is_aggregation_result, const char* _format = "var_{}")
     {
       std::string name = format_string(_format, next_uid());
-      return add_variable_with_name(_expression, name);
+      return add_variable_with_name(_expression, name, _is_aggregation_result);
     }
     /**
      * Add a new variable with the given name.
      */
-    std::string add_variable_with_name(const std::string& _expression, const std::string& _name)
+    std::string add_variable_with_name(const std::string& _expression, const std::string& _name, bool _is_aggregation_result)
     {
+      has_aggregation_result = has_aggregation_result or _is_aggregation_result;
       if(not variables.empty()) variables += ", ";
       variables += format_string("{} AS {}", _expression, _name);
+      if(not _is_aggregation_result) group_variables += _name + ", ";
       return _name;
     }
+    void add_fake_table()
+    {
+      errors::check_condition(tables.empty(), exception_stage::runtime, exception_code::internal_error, "Fake table can only be added when the number of table is 0.");
+      tables.push_back({sql_join::inner, "(SELECT 1 AS fake)", "faketable"});
+    }
     std::string add_table(const std::string& _table, sql_join _join, const char* _table_name_format= "tbl_{}")
     {
-      if(table_count == 0)
+      if(tables.empty())
       {
         errors::check_condition(_join == sql_join::inner, exception_stage::runtime, exception_code::internal_error, "Joining with non-inner join on first table.");
-        tables += " FROM ";
-      } else {
-        switch(_join)
-        {
-          case sql_join::inner:
-            tables += " JOIN ";
-            break;
-          case sql_join::left:
-            tables += " LEFT JOIN ";
-            break;
-        }
       }
-      ++table_count;
       std::string table_name = format_string(_table_name_format, next_uid());
-      tables += format_string(" {} {} ", _table, table_name);
+      tables.push_back({_join, _table, table_name});
       return table_name;
     }
     template<typename... _T_>
@@ -7299,9 +7506,10 @@ namespace gqlite::backends::sqlite_oc_executor
     template<typename... _T_>
     void add_where_condition(const std::string& _condition, const _T_&... _args)
     {
-      if(_condition.empty()) return;
-      where_conditions += where_conditions.empty() ? " WHERE " : " AND ";
-      where_conditions += format_string(_condition, _args...);
+      add_join_condition(_condition, _args...);
+      // if(_condition.empty()) return;
+      // where_conditions += where_conditions.empty() ? " WHERE " : " AND ";
+      // where_conditions += format_string(_condition, _args...);
     }
     void add_modifier(const std::string& _modifier)
     {
@@ -7311,10 +7519,38 @@ namespace gqlite::backends::sqlite_oc_executor
     {
       std::string q = "SELECT ";
       q += variables.empty() ? " null " : variables;
-      q += tables;
+      if(not tables.empty())
+      {
+      // errors::check_condition(not tables.empty(), exception_stage::runtime, exception_code::internal_error, "Missing tables in query.");
+        q += format_string(" FROM {} {}", tables[0].table, tables[0].name);
+        for(std::size_t i = 1; i < tables.size(); ++i)
+        {
+          table& tbl = tables[i];
+          const char* join_type;
+          switch(tbl.join)
+          {
+            case sql_join::inner:
+              join_type = "JOIN";
+              break;
+            case sql_join::left:
+              join_type = "LEFT JOIN";
+              break;
+          }
+          if(i == tables.size() - 1)
+          {
+            q += format_string(" {} {} {}", join_type, tbl.table, tbl.name);
+          } else {
+            q += format_string(" {} ({} {}", join_type, tbl.table, tbl.name);          
+          }
+        }
+        for(std::size_t i = 1; i < tables.size() - 1; ++i)
+        {
+          q += ")";
+        }
+      }
       if(not join_conditions.empty())
       {
-        if(table_count == 1)
+        if(tables.size() == 1)
         {
           q += " WHERE ";
         } else {
@@ -7322,7 +7558,11 @@ namespace gqlite::backends::sqlite_oc_executor
         }
         q += join_conditions;
       }
-      q += where_conditions;
+      // q += where_conditions;
+      if(has_aggregation_result and not group_variables.empty())
+      {
+        q += " GROUP BY {}" % std::string_view(group_variables).substr(0, group_variables.size() - 2);
+      }
       q += modifiers;
       return q;
     }
@@ -7341,7 +7581,7 @@ namespace gqlite::backends::sqlite_oc_executor
     // std::string view_name;
     oc::algebra::visitors::expression_analyser expression_analyser;
 
-    table prepare(const table& _table, bool _create_new_table)
+    table prepare(const table& _table, bool _create_new_table, bool _optional)
     {
       expression_analyser.stage = exception_stage::runtime;
       expression_analyser.variables_f = [this](const std::string& _var_name)
@@ -7350,8 +7590,13 @@ namespace gqlite::backends::sqlite_oc_executor
       };
       table new_table;
       if(_create_new_table) new_table.view_name = "__view" + std::to_string(++exec_c->next_view_id);
-      if(not _table.view_name.empty())
+      if(_table.view_name.empty())
       {
+        if(_optional)
+        {
+          query_builder.add_fake_table();
+        }
+      } else {
         previous_table_ref = query_builder.add_table(_table.view_name, sql_join::inner, "pt_{}");
 
         for(auto const& [k, v] : _table.variables)
@@ -7360,7 +7605,7 @@ namespace gqlite::backends::sqlite_oc_executor
           variables[k] = { sql_var, v.type };
           if(_create_new_table)
           {
-            std::string col_name = query_builder.add_variable(sql_var);
+            std::string col_name = query_builder.add_variable(sql_var, false);
             new_table.variables[k] = { col_name, v.type };
           }
         }
@@ -7428,6 +7673,10 @@ namespace gqlite::backends::sqlite_oc_executor
     {
       return eval_c->query_builder.bind_value(_node->get_value());
     }
+    std::string visit(algebra::all_csp) override
+    {
+      return "*";
+    }
     std::string visit(algebra::has_labels_csp _node) override
     {
       oc::algebra::expression_type et = eval_c->get_variable_info(_node->get_left()).type;
@@ -7463,7 +7712,7 @@ namespace gqlite::backends::sqlite_oc_executor
       {
         if(not first)
         {
-          map += " UNION ";
+          map += " UNION ALL ";
         }
         map += "SELECT " + eval_c->query_builder.bind_value(k);
         if(first)
@@ -7488,7 +7737,7 @@ namespace gqlite::backends::sqlite_oc_executor
       {
         if(not first)
         {
-          array += " UNION ";
+          array += " UNION ALL ";
         }
         array += "SELECT " + start(v);
         if(first)
@@ -7590,7 +7839,7 @@ namespace gqlite::backends::sqlite_oc_executor
         return "(SELECT json_group_array(key) FROM json_each({}))" % map_expr;
       } else if(_node->get_name() == "toInteger")
       {
-        return "CAST({} AS INTEGER)"s % start(_node->get_arguments()[0]);
+        return "gqlite_to_integer({})"s % start(_node->get_arguments()[0]);
       } else if(_node->get_name() == "size")
       {
         return "json_array_length({})"s % start(_node->get_arguments()[0]);
@@ -7603,6 +7852,24 @@ namespace gqlite::backends::sqlite_oc_executor
       } else if(_node->get_name() == "tail")
       {
         return "gqlite_tail({})" % start(_node->get_arguments()[0]);
+      } else if(_node->get_name() == "avg")
+      {
+        return "avg({})" % start(_node->get_arguments()[0]);
+      } else if(_node->get_name() == "count")
+      {
+        return "count({})" % start(_node->get_arguments()[0]);
+      } else if(_node->get_name() == "collect")
+      {
+        return "json_group_array({})" % start(_node->get_arguments()[0]);
+      } else if(_node->get_name() == "max")
+      {
+        return "max({})" % start(_node->get_arguments()[0]);
+      } else if(_node->get_name() == "min")
+      {
+        return "min({})" % start(_node->get_arguments()[0]);
+      } else if(_node->get_name() == "sum")
+      {
+        return "sum({})" % start(_node->get_arguments()[0]);
       }
       throw_exception(exception_stage::runtime, exception_code::unimplemented_error, "Function call to {} is not implemented.", _node->get_name());
     }
@@ -7618,8 +7885,8 @@ namespace gqlite::backends::sqlite_oc_executor
     FILTER_VISITOR_BINARY_OP(relational_different, "!=")
     FILTER_VISITOR_BINARY_OP(relational_inferior, "<")
     FILTER_VISITOR_BINARY_OP(relational_superior, ">")
-    FILTER_VISITOR_BINARY_OP(relational_inferior_equal, "<")
-    FILTER_VISITOR_BINARY_OP(relational_superior_equal, ">")
+    FILTER_VISITOR_BINARY_OP(relational_inferior_equal, "<=")
+    FILTER_VISITOR_BINARY_OP(relational_superior_equal, ">=")
     FILTER_VISITOR_BINARY_OP(substraction, "-")
     FILTER_VISITOR_BINARY_OP(multiplication, "*")
     FILTER_VISITOR_BINARY_OP(division, "/")
@@ -7726,8 +7993,9 @@ namespace gqlite::backends::sqlite_oc_executor
     {
       sql_evaluation_context mc;
       mc.exec_c = &exec_c;
-      mc.prepare(current_table, false);
+      mc.prepare(current_table, false, false);
       sql_expression_visitor sev{&mc};
+      mc.query_builder.add_variable("gqlite_next_uid('nodes')", false);
 
       std::string properties_str;
       if(_node->get_properties())
@@ -7736,9 +8004,9 @@ namespace gqlite::backends::sqlite_oc_executor
       } else {
         properties_str = "'{}'";
       }
-      sev.eval_c->query_builder.add_variable(properties_str);
+      mc.query_builder.add_variable(properties_str, false);
       std::string query = sqlite_queries::node_create(
-        sev.eval_c->exec_c->graph_name, sev.eval_c->query_builder.assemble());
+        exec_c.graph_name, sev.eval_c->query_builder.assemble());
       value res = exec_c.data->execute_sql(query, sev.eval_c->query_builder.bindings);
       value_vector ret_v;
       value_vector res_v = res.to_vector();
@@ -7792,13 +8060,13 @@ namespace gqlite::backends::sqlite_oc_executor
     {
       sql_evaluation_context mc;
       mc.exec_c = &exec_c;
-      mc.prepare(current_table, false);
+      mc.prepare(current_table, false, false);
       sql_expression_visitor sev{&mc};
-
+      mc.query_builder.add_variable("gqlite_next_uid('edges')", false);
       // Handle label
       std::string label = _edge->get_labels().empty() ? std::string() : _edge->get_labels().front();
       std::string label_binding_idx = sev.eval_c->query_builder.bind_value(exec_c.data->id_for_label(label));
-      mc.query_builder.add_variable(label_binding_idx, "label_{}");
+      mc.query_builder.add_variable(label_binding_idx, false, "label_{}");
 
       // Handle properties
       std::string properties_str;
@@ -7808,18 +8076,18 @@ namespace gqlite::backends::sqlite_oc_executor
       } else {
         properties_str = "'{}'";
       }
-      mc.query_builder.add_variable(properties_str, "properties_{}");
+      mc.query_builder.add_variable(properties_str, false, "properties_{}");
 
       // Handle source
       auto const&[left_value, new_left_value, left_expr] = create_node_if_needed(&sev, _edge->get_source(), _new_nodes, "source_node_{}");
-      mc.query_builder.add_variable(left_expr, "source_{}");
+      mc.query_builder.add_variable(left_expr, false, "source_{}");
 
       // Check if destination == source
       auto const&[right_value, new_right_value, right_expr]
         = (_edge->get_source()->get_variable() == _edge->get_destination()->get_variable()) ?
             std::make_tuple(gqlite::value(), false, left_expr)
           : create_node_if_needed(&sev, _edge->get_destination(), _new_nodes, "destination_node_{}");
-      mc.query_builder.add_variable(right_expr, "destination_{}");
+      mc.query_builder.add_variable(right_expr, false, "destination_{}");
 
       // Execute queries
       std::string query = sqlite_queries::edge_create(exec_c.graph_name, sev.eval_c->query_builder.assemble());
@@ -7881,7 +8149,7 @@ namespace gqlite::backends::sqlite_oc_executor
         // 2) Create the resulting table
         sql_evaluation_context mc;
         mc.exec_c = &exec_c;
-        table new_table = mc.prepare(current_table, true);
+        table new_table = mc.prepare(current_table, true, false);
         sql_expression_visitor sev{&mc};
         std::string first_table_ref;
         // loop over new things
@@ -7901,7 +8169,7 @@ namespace gqlite::backends::sqlite_oc_executor
               } else {
                 mc.query_builder.add_join_condition("{}.key = {}.key", first_table_ref, table_ref);
               }
-              mc.query_builder.add_variable_with_name(format_string(" {}.value ", table_ref), table_ref);
+              mc.query_builder.add_variable_with_name(format_string(" {}.value ", table_ref), table_ref, false);
               new_table.variables[k] = {table_ref, type};
             }
           }
@@ -7988,7 +8256,7 @@ namespace gqlite::backends::sqlite_oc_executor
         auto it = _mc->variables.find(_oc_var);
         if(it == _mc->variables.end())
         {
-          std::string var_name = _mc->query_builder.add_variable(_sql_var, "new_match_{}");
+          std::string var_name = _mc->query_builder.add_variable(_sql_var, false, "new_match_{}");
           _table->variables[_oc_var] = {var_name, _variable_type};
           _mc->variables[_oc_var] = {_sql_var, _variable_type, _sql_properties_var, _label_var};
         } else {
@@ -8002,15 +8270,18 @@ namespace gqlite::backends::sqlite_oc_executor
     {
       sql_match_evaluation_context mc;
       mc.exec_c = &exec_c;
-      table new_table = mc.prepare(current_table, true);
+      table new_table = mc.prepare(current_table, true, _node->get_optional());
       sql_match_expression_visitor sev{&mc};
 
+      const bool is_optional = _node->get_optional();
+
       // 1) Go through the patterns
       for(const algebra::alternative<algebra::graph_node, algebra::graph_edge>& pattern : _node->get_patterns())
       {
-        pattern.visit<void>([this, &mc, &sev, &new_table](const algebra::graph_node_csp _node)
+        pattern.visit<void>([this, &mc, &sev, &new_table, is_optional](const algebra::graph_node_csp _node)
         {
-          std::string table_ref = sev.eval_c->query_builder.add_table(format_string("gqlite_{}_nodes", exec_c.graph_name), sql_join::inner, "node_{}");
+          sql_join s_join = is_optional ? sql_join::left : sql_join::inner;
+          std::string table_ref = sev.eval_c->query_builder.add_table(format_string("gqlite_{}_nodes", exec_c.graph_name), s_join, "node_{}");
           std::string sql_var = format_string("{}.id", table_ref);
           std::string sql_properties_var = format_string("{}.properties", table_ref);
           mc.query_builder.add_join_condition(mc.generate_labels_match(_node->get_labels(), format_string("{}.id", table_ref)));
@@ -8020,14 +8291,15 @@ namespace gqlite::backends::sqlite_oc_executor
           }
           generate_var_match(&mc, &new_table, _node->get_variable(), sql_var, sql_properties_var, std::string(), algebra::expression_type::node);
         },
-        [this, &mc, &sev, &new_table](const algebra::graph_edge_csp _edge)
+        [this, &mc, &sev, &new_table, is_optional](const algebra::graph_edge_csp _edge)
         {
+          sql_join s_join = is_optional ? sql_join::left : sql_join::inner;
           std::string table_ref;
           if(_edge->get_directivity() == algebra::edge_directivity::undirected)
           {
-            table_ref = sev.eval_c->query_builder.add_table(format_string("gqlite_{}_edges_undirected", exec_c.graph_name), sql_join::inner, "undirected_edge_{}");
+            table_ref = sev.eval_c->query_builder.add_table(format_string("gqlite_{}_edges_undirected", exec_c.graph_name), s_join, "undirected_edge_{}");
           } else {
-            table_ref = sev.eval_c->query_builder.add_table(format_string("gqlite_{}_edges", exec_c.graph_name), sql_join::inner, "edge_{}");
+            table_ref = sev.eval_c->query_builder.add_table(format_string("gqlite_{}_edges", exec_c.graph_name), s_join, "edge_{}");
           }
           std::string sql_source_var = format_string("{}.left", table_ref);
           std::string sql_edge_var = format_string("{}.id", table_ref);
@@ -8040,7 +8312,13 @@ namespace gqlite::backends::sqlite_oc_executor
           mc.query_builder.add_where_condition(mc.generate_labels_match(_edge->get_destination()->get_labels(), table_ref + ".right"));
           if(not _edge->get_labels().empty())
           {
-            std::string label_conds = "(FALSE ";
+            std::string label_conds;
+            if(is_optional)
+            {
+              label_conds = format_string("({} IS NULL", sql_label_edge_var);
+            } else {
+              label_conds = "(FALSE ";
+            }
             for(const std::string& label : _edge->get_labels())
             {
               label_conds += format_string(" OR {} = {}", sql_label_edge_var, exec_c.data->id_for_label(label));
@@ -8099,10 +8377,10 @@ namespace gqlite::backends::sqlite_oc_executor
       {
         sql_match_evaluation_context mc;
         mc.exec_c = &exec_c;
-        mc.prepare(current_table, false);
+        mc.prepare(current_table, false, false);
         sql_match_expression_visitor sev{&mc};
         std::string expr = sev.start(node);
-        mc.query_builder.add_variable(expr);
+        mc.query_builder.add_variable(expr, false);
         std::string what = mc.query_builder.assemble();
 
         switch(mc.expression_analyser.start(node).type)
@@ -8111,8 +8389,15 @@ namespace gqlite::backends::sqlite_oc_executor
           {
             if(_ds->get_detach())
             {
-              std::string query = sqlite_queries::edge_delete_by_node(exec_c.graph_name, what);
+              std::string query = sqlite_queries::edge_delete_by_nodes(exec_c.graph_name, what);
               mc.exec_c->data->execute_sql(query, mc.query_builder.bindings);
+            } else {
+              std::string query = sqlite_queries::edge_count_by_nodes(exec_c.graph_name, what);
+              gqlite::value count = mc.exec_c->data->execute_sql(query, mc.query_builder.bindings);
+              if(count.to_vector().front().to_vector().front().to_integer() > 0)
+              {
+                throw_exception(exception_stage::runtime, exception_code::delete_connected_node, "delete connected node not allowed, unless using detach.");
+              }
             }
             std::string query = sqlite_queries::node_delete(exec_c.graph_name, what);
             mc.exec_c->data->execute_sql(query, mc.query_builder.bindings);
@@ -8129,59 +8414,6 @@ namespace gqlite::backends::sqlite_oc_executor
         }
       }
       return value();
-      #if 0
-      evaluation_context eval_c;
-      eval_c.table = table;
-      evaluator_visitor eval_v;
-      eval_v.exec_c = &exec_c;
-      eval_v.eval_c = &eval_c;
-
-      struct deleter
-      {
-        statement_visitor* self;
-        bool detach;
-        void operator()(const node_ref_sp& _node)
-        {
-          if(detach)
-          {
-            self->exec_c.data->execute_sql(sqlite_queries::edge_delete_by_node(self->exec_c.graph_name), {{1, _node->id}});
-          } else {
-            value result = self->exec_c.data->execute_sql(sqlite_queries::edge_count_by_node(self->exec_c.graph_name), {{1, _node->id}});
-            value_vector rows = result.to_vector();
-            errors::check_condition(rows.size() == 1, exception_stage::runtime, exception_code::internal_error, "Invalid number of rows for counting edges got {} expected 1.", rows.size());
-            value_vector row = rows.front().to_vector();
-            errors::check_condition(row.size() == 1, exception_stage::runtime, exception_code::internal_error, "Invalid number of columns for counting edges got {} expected 1.", rows.size());
-            int count = row.front().to_integer();
-            errors::check_condition(count == 0, exception_stage::runtime, exception_code::unspecified, "Cannot delete node with {} relationships.", count);
-          }
-          self->exec_c.data->execute_sql(sqlite_queries::node_delete(self->exec_c.graph_name), {{1, _node->id}});
-        }
-        void operator()(const edge_ref_sp& _edge)
-        {
-          self->exec_c.data->execute_sql(sqlite_queries::edge_delete(self->exec_c.graph_name), {{1, _edge->id}});
-        }
-        void operator()(const value&)
-        {
-          throw_exception(exception_stage::runtime, exception_code::invalid_argument_type, "Cannot delete a value.");
-        }
-        void operator()(const empty&)
-        {
-          throw_exception(exception_stage::runtime, exception_code::invalid_argument_type, "Cannot delete an empty value.");
-        }
-      };
-
-      for(std::size_t i = 0; i < table.get_rows_count(); ++i)
-      {
-        value_vector row;
-        eval_c.prepare_current_row(table, i, false);
-        for(const algebra::node_csp& rv : _ds->get_expressions())
-        {
-          exec_value ev =eval_v.start(rv);
-          std::visit(deleter{this, _ds->get_detach()}, ev);
-        }
-      }
-      return value();
-      #endif
     }
     std::string to_sqlite_path(const std::vector<std::string>& _path)
     {
@@ -8209,7 +8441,7 @@ namespace gqlite::backends::sqlite_oc_executor
           {
             sql_match_evaluation_context mc;
             mc.exec_c = &self->exec_c;
-            mc.prepare(self->current_table, false);
+            mc.prepare(self->current_table, false, false);
             sql_match_expression_visitor sev{&mc};
             sql_variable_info svi = mc.get_variable_info(_property->get_left());
             // mc.query_builder.add_variable(svi.sql_var_name);
@@ -8238,7 +8470,7 @@ namespace gqlite::backends::sqlite_oc_executor
           {
             sql_match_evaluation_context mc;
             mc.exec_c = &self->exec_c;
-            mc.prepare(self->current_table, false);
+            mc.prepare(self->current_table, false, false);
             sql_match_expression_visitor sev{&mc};
             sql_variable_info svi = mc.get_variable_info(_property->get_left());
             std::string expr = sev.start(_property->get_expression());
@@ -8266,14 +8498,15 @@ namespace gqlite::backends::sqlite_oc_executor
           {
             sql_match_evaluation_context mc;
             mc.exec_c = &self->exec_c;
-            mc.prepare(self->current_table, false);
+            mc.prepare(self->current_table, false, false);
             sql_match_expression_visitor sev{&mc};
             sql_variable_info svi = mc.get_variable_info(_edit_label->get_target());
             std::vector<std::string> labels = _edit_label->get_labels();
             auto label_ids_view = labels | std::views::transform([this](const std::string& _label) { return value(self->exec_c.data->id_for_label(_label)); });
             std::string labels_ref = mc.query_builder.add_table("json_each({})"s % mc.query_builder.bind_value(value_vector(label_ids_view.begin(), label_ids_view.end())), sql_join::inner);
-            mc.query_builder.add_variable("{}.value" % labels_ref);
-            mc.query_builder.add_variable(svi.sql_var_name);
+            mc.query_builder.add_variable("{}.value" % labels_ref, false);
+            mc.query_builder.add_variable(svi.sql_var_name, false);
+            mc.query_builder.add_where_condition("{} IS NOT NULL", svi.sql_var_name);
             std::string what = mc.query_builder.assemble();
 
             switch(svi.type)
@@ -8312,7 +8545,7 @@ namespace gqlite::backends::sqlite_oc_executor
           {
             sql_match_evaluation_context mc;
             mc.exec_c = &self->exec_c;
-            mc.prepare(self->current_table, false);
+            mc.prepare(self->current_table, false, false);
             sql_match_expression_visitor sev{&mc};
             sql_variable_info svi = mc.get_variable_info(_property->get_left());
             std::string what = mc.query_builder.assemble().substr(sizeof("SELECT null"));
@@ -8339,13 +8572,13 @@ namespace gqlite::backends::sqlite_oc_executor
           {
             sql_match_evaluation_context mc;
             mc.exec_c = &self->exec_c;
-            mc.prepare(self->current_table, false);
+            mc.prepare(self->current_table, false, false);
             sql_match_expression_visitor sev{&mc};
             sql_variable_info svi = mc.get_variable_info(_edit_label->get_target());
             std::vector<std::string> labels = _edit_label->get_labels();
             auto label_ids_view = labels | std::views::transform([this](const std::string& _label) { return std::to_string(self->exec_c.data->id_for_label(_label)); });
             std::string labels_ref = string::join(label_ids_view, ", ");
-            mc.query_builder.add_variable(svi.sql_var_name);
+            mc.query_builder.add_variable(svi.sql_var_name, false);
             std::string what = mc.query_builder.assemble();
 
             switch(svi.type)
@@ -8410,16 +8643,16 @@ namespace gqlite::backends::sqlite_oc_executor
 
       sql_evaluation_context mc;
       mc.exec_c = &exec_c;
-      table new_table = mc.prepare(current_table, true);
+      table new_table = mc.prepare(current_table, true, false);
       new_table.variables.clear();
       sql_expression_visitor sev{&mc};
       // Generate SQL Query
       for(const algebra::named_expression_csp& rv : w->get_expressions())
       {
-        std::string var = mc.query_builder.add_variable(sev.start(rv->get_expression()));
-        algebra::expression_type et = mc.expression_analyser.start(rv->get_expression()).type; 
-        new_table.variables[rv->get_name()] = {var, et};
-        mc.variables[rv->get_name()] = {var, et};
+        algebra::expression_info expr_info = mc.expression_analyser.start(rv->get_expression()); 
+        std::string var = mc.query_builder.add_variable(sev.start(rv->get_expression()), expr_info.aggregation_result);
+        new_table.variables[rv->get_name()] = {var, expr_info.type};
+        mc.variables[rv->get_name()] = {var, expr_info.type};
       }
       add_filter_expressions(&sev, w->get_modifiers());
       std::string query = "CREATE TEMPORARY TABLE " + new_table.view_name + " AS " + mc.query_builder.assemble();
@@ -8434,10 +8667,10 @@ namespace gqlite::backends::sqlite_oc_executor
     {
       sql_evaluation_context mc;
       mc.exec_c = &exec_c;
-      table new_table = mc.prepare(current_table, true);
+      table new_table = mc.prepare(current_table, true, false);
       sql_expression_visitor sev{&mc};
       std::string table_ref = mc.query_builder.add_table("json_each(" + sev.start(uw->get_expression()) + ")", sql_join::inner, "a_uw_{}");
-      std::string var = mc.query_builder.add_variable(format_string("{}.value", table_ref));
+      std::string var = mc.query_builder.add_variable(format_string("{}.value", table_ref), false);
       std::string query = "CREATE TEMPORARY TABLE " + new_table.view_name + " AS " + mc.query_builder.assemble();
       new_table.variables[uw->get_name()] = {var, oc::algebra::expression_type::value};
       exec_c.data->execute_sql(query, mc.query_builder.bindings);
@@ -8450,7 +8683,7 @@ namespace gqlite::backends::sqlite_oc_executor
     {
       sql_evaluation_context mc;
       mc.exec_c = &exec_c;
-      mc.prepare(current_table, false);
+      mc.prepare(current_table, false, false);
       sql_expression_visitor sev{&mc};
       std::vector<gqlite::oc::algebra::named_expression_csp> expressions;
       if(_rs->get_all())
@@ -8472,14 +8705,14 @@ namespace gqlite::backends::sqlite_oc_executor
 
       for(const algebra::named_expression_csp& rv : expressions)
       {
-        oc::algebra::expression_type et = mc.expression_analyser.start(rv->get_expression()).type;
-        switch(et)
+        oc::algebra::expression_info expr_info = mc.expression_analyser.start(rv->get_expression());
+        switch(expr_info.type)
         {
         case oc::algebra::expression_type::node:
           {
             std::string table_ref = mc.query_builder.add_table(format_string("gqlite_{}_nodes_as_json", exec_c.graph_name), sql_join::inner, "node_{}");
-            mc.query_builder.add_join_condition("{}.id = {}", table_ref, sev.start(rv->get_expression()));
-            std::string var_expr = mc.query_builder.add_variable("{}.node" % table_ref);
+            mc.query_builder.add_join_condition("{}.id IS {}", table_ref, sev.start(rv->get_expression()));
+            std::string var_expr = mc.query_builder.add_variable("{}.node" % table_ref, expr_info.aggregation_result);
             variables_extra[rv->get_name()] = {var_expr, oc::algebra::expression_type::node,
                                   "json_extract({}, '$.properties')" % var_expr, "json_extract({}, '$.labels')" % var_expr};
             break;
@@ -8487,8 +8720,8 @@ namespace gqlite::backends::sqlite_oc_executor
         case oc::algebra::expression_type::edge:
           {
             std::string table_ref = mc.query_builder.add_table(format_string("gqlite_{}_edges_as_json", exec_c.graph_name), sql_join::inner, "edge_{}");
-            mc.query_builder.add_join_condition("{}.id = {}", table_ref, sev.start(rv->get_expression()));
-            std::string var_expr = mc.query_builder.add_variable("{}.edge" % table_ref);
+            mc.query_builder.add_join_condition("{}.id IS {}", table_ref, sev.start(rv->get_expression()));
+            std::string var_expr = mc.query_builder.add_variable("{}.edge" % table_ref, expr_info.aggregation_result);
             variables_extra[rv->get_name()] = {var_expr, oc::algebra::expression_type::edge,
                                     "json_extract({}, '$.properties')" % var_expr, "json_extract({}, '$.label')" % var_expr};
             break;
@@ -8499,18 +8732,19 @@ namespace gqlite::backends::sqlite_oc_executor
           [[fallthrough]];
         default:
           {
-            std::string var_expr = mc.query_builder.add_variable(sev.start(rv->get_expression()));
-            variables_extra[rv->get_name()] = {var_expr, et};
+            std::string var_expr = mc.query_builder.add_variable(sev.start(rv->get_expression()), expr_info.aggregation_result);
+            variables_extra[rv->get_name()] = {var_expr, expr_info.type};
             break;
           }
         }
         labels.push_back(rv->get_name());
-        column_types.push_back(et);
+        column_types.push_back(expr_info.type);
       }
       // Execute SQL query
       if(_rs->get_modifiers())
       {
-        mc.variables.insert(variables_extra.begin(), variables_extra.end());
+        std::swap(mc.variables, variables_extra);
+        mc.variables.merge(variables_extra);
         add_filter_expressions(&sev, _rs->get_modifiers());
       }
       value res = exec_c.data->execute_sql(mc.query_builder.assemble(), mc.query_builder.bindings);
@@ -8524,35 +8758,38 @@ namespace gqlite::backends::sqlite_oc_executor
         for(std::size_t c = 0; c < r_v.size(); ++c)
         {
           value& v = r_v[c];
-          switch(column_types[c])
+          if(v.get_type() != value_type::invalid)
           {
-          case oc::algebra::expression_type::boolean:
-            if(v.get_type() != value_type::invalid)
+            switch(column_types[c])
             {
-              v = (v.to_integer() == 1);
-            }
-            break;
-          case oc::algebra::expression_type::map:
-          case oc::algebra::expression_type::vector:
-            v = value::from_json(v.to_string());
-            break;
-          case oc::algebra::expression_type::node:
-          case oc::algebra::expression_type::edge:
-            v = value::from_json(v.to_string());
-            break;
-          default:
-            if(v.get_type() == value_type::string)
-            {
-              // Attempt to parse strings as json
-              try
+            case oc::algebra::expression_type::boolean:
+              if(v.get_type() != value_type::invalid)
               {
-                v = value::from_json(v.to_string());
+                v = (v.to_integer() == 1);
               }
-              catch(const exception&)
+              break;
+            case oc::algebra::expression_type::map:
+            case oc::algebra::expression_type::vector:
+              v = value::from_json(v.to_string());
+              break;
+            case oc::algebra::expression_type::node:
+            case oc::algebra::expression_type::edge:
+              v = value::from_json(v.to_string());
+              break;
+            default:
+              if(v.get_type() == value_type::string)
               {
-                // ignore, that probably means it is a real string
+                // Attempt to parse strings as json
+                try
+                {
+                  v = value::from_json(v.to_string());
+                }
+                catch(const exception&)
+                {
+                  // ignore, that probably means it is a real string
+                }
+                break;
               }
-              break;
             }
           }
         }
@@ -8597,6 +8834,10 @@ sqlite::sqlite(void* _db) : d(new data)
   {
     d->execute_sql(sqlite_queries::label_create_table());
   }
+  if(not d->table_has("gqlite_uids"))
+  {
+    d->execute_sql(sqlite_queries::uid_create_table());
+  }
   if(not d->graph_has("default"))
   {
     d->graph_create("default");
@@ -8606,7 +8847,7 @@ sqlite::sqlite(void* _db) : d(new data)
   {
     gqlite::value result = d->execute_sql(sqlite_queries::get_debug_stats("default"));
     value_vector rows = result.to_vector();
-    errors::check_condition(rows.size() == 7, exception_stage::runtime, exception_code::internal_error, "Invalid number of debug stats got {} expected 7.", rows.size());
+    errors::check_condition(rows.size() == 9, exception_stage::runtime, exception_code::internal_error, "Invalid number of debug stats got {} expected 7.", rows.size());
     value_map stats;
     stats["nodes_count"] = rows[0].to_vector()[0].to_integer();
     stats["edges_count"] = rows[1].to_vector()[0].to_integer();
@@ -8614,6 +8855,8 @@ sqlite::sqlite(void* _db) : d(new data)
     stats["properties_count"] = rows[3].to_vector()[0].to_integer() + rows[4].to_vector()[0].to_integer();
     stats["labels_count"] = rows[5].to_vector()[0].to_integer();
     stats["labels_assignment_nodes_count"] = rows[6].to_vector()[0].to_integer();
+    stats["used_labels_count"] = rows[7].to_vector()[0].to_integer();
+    stats["used_labels_nodes_count"] = rows[8].to_vector()[0].to_integer();
     return stats;
   };
 }
@@ -8667,6 +8910,13 @@ gqlite::value sqlite::execute_oc_query(oc::algebra::node_csp _node)
 
 
 
+
+
+// Older version of SQLITE don*t have SQLITE_RESULT_SUBTYPE
+#ifndef SQLITE_RESULT_SUBTYPE
+#define SQLITE_RESULT_SUBTYPE 0
+#endif
+
 namespace gqlite::backends
 {
   template<typename... _TArgs_>
@@ -8692,6 +8942,15 @@ namespace gqlite::backends
   {                                           \
     report_exception(_context, ex); return;   \
   }
+
+#define NULL_CHECK_AT(_ARG_INDEX_)                            \
+  {                                                           \
+    if(sqlite3_value_type(_argv[_ARG_INDEX_]) == SQLITE_NULL) \
+    {                                                         \
+      sqlite3_result_null(_context); return ;                 \
+    }                                                         \
+  }
+
 #define NULL_CHECK(_ARGS_COUNT_)                      \
   for(std::size_t i = 0; i < _ARGS_COUNT_; ++i)       \
   {                                                   \
@@ -8808,7 +9067,7 @@ namespace gqlite::backends
     using enum value_type;
     if(_value.get_type() == invalid)
     {
-      return comparison_result::compared_null;
+      return _container.empty() ? comparison_result::false_result : comparison_result::compared_null;
     }
     bool has_compared_to_null = false;
     for(const value& v_c : _container)
@@ -8834,7 +9093,232 @@ namespace gqlite::backends
     }
     return false;
   }
+  /**
+   * @internal
+   * class use to read json files
+   */
+  struct is_valid_json
+  {
+    struct invalid
+    {};
+    std::stringstream stream;
+    int last_char;
+    /// @brief get the next char
+    void fetch_next_non_space_char()
+    {
+      while(std::isspace(fetch_next_char()))
+      {
+        if(last_char == std::stringstream::traits_type::eof())
+        {
+          return;
+        } else if(stream.fail())
+        {
+          throw invalid();
+        }
+      }
+    };
+    int fetch_next_char()
+    {
+      return (last_char = stream.get());
+    }
+    /// @brief start parsing
+    /// @throw gqlite::exception
+    /// @return the parsed value
+    bool start()
+    {
+      try
+      {
+        fetch_next_non_space_char();
+        validate_value();
+        return true;
+      } catch(const invalid&)
+      {
+        return false;
+      }
+    }
+    static bool validate(const char* _string)
+    {
+      is_valid_json ivj{std::stringstream(_string), 0};
+      return ivj.start();
+    }
+    /// @brief read a string
+    /// @return the string without quotation
+    void validate_string()
+    {
+      is_char('"');
+      fetch_next_char();
+      bool keep_nc = false; // this is used to indicate if the last character was a '\' or not
+      while(keep_nc or last_char != '"')
+      {
+        keep_nc = (not keep_nc and last_char == '\\');
+        fetch_next_char();
+      }
+      fetch_next_char(); // eat the '"'
+    }
+    /// @brief throw an exception if last_char different from @param _c 
+    void is_char(int _c)
+    {
+      if(last_char != _c) throw invalid();
+    }
+    /// @brief read the next value
+    /// @return and return it
+    void validate_value()
+    {
+      switch (last_char)
+      {
+      case '{':
+      {
+        // Parse object
+        fetch_next_non_space_char();
+        while(last_char != '}')
+        {
+          validate_string();
+          is_char(':');
+          fetch_next_non_space_char();
+          validate_value();
+          if(last_char == ',')
+          {
+            fetch_next_non_space_char();
+          } else {
+            break;
+          }
+        }
+        is_char('}');
+        fetch_next_non_space_char();
+        return;
+      }
+      case '[':
+      {
+        // Parse array
+        fetch_next_non_space_char();
+        while(last_char != ']')
+        {
+          validate_value();
+          if(last_char == ',')
+          {
+            fetch_next_non_space_char();
+          } else {
+            break;
+          }
+        }
+        is_char(']');
+        fetch_next_non_space_char();
+        return;
+      }
+      case '"':
+        validate_string();
+        return;
+      case 't':
+      {
+        // Parse true
+        fetch_next_non_space_char(); is_char('r');
+        fetch_next_non_space_char(); is_char('u');
+        fetch_next_non_space_char(); is_char('e');
+        fetch_next_non_space_char();
+        return;
+      }
+      case 'f':
+      {
+        // Parse false
+        fetch_next_non_space_char(); is_char('a');
+        fetch_next_non_space_char(); is_char('l');
+        fetch_next_non_space_char(); is_char('s');
+        fetch_next_non_space_char(); is_char('e');
+        fetch_next_non_space_char();
+        return;
+      }
+      case 'n':
+      {
+        // Parse null
+        fetch_next_non_space_char(); is_char('u');
+        fetch_next_non_space_char(); is_char('l');
+        fetch_next_non_space_char(); is_char('l');
+        fetch_next_non_space_char();
+        return;
+      }
+      // Parse number
+      case '-':
+      case '0':
+      case '1':
+      case '2':
+      case '3':
+      case '4':
+      case '5':
+      case '6':
+      case '7':
+      case '8':
+      case '9':
+      {
+        fetch_next_non_space_char();
+        bool is_integer = true;
+        while((last_char >= '0' and last_char <= '9') or last_char == '.' or last_char == 'e' or last_char == '+' or last_char == '-')
+        {
+          is_integer = is_integer and (last_char != '.' and last_char != 'e');
+          fetch_next_non_space_char();
+        }
+        return;
+      }
+      default:
+        throw invalid{};
+      }
+    }
+  };
+  void gqlite_next_uid(sqlite3_context* _context,int,sqlite3_value** _argv)
+  {
+    // We get our db connection from the context
+    sqlite3 *db = sqlite3_context_db_handle(_context);
+    const char* label = reinterpret_cast<const char*>(sqlite3_value_text(_argv[0]));
+    sqlite3_stmt *ps;
+    int rc = sqlite3_prepare_v2(db, sqlite_queries::uid_next().c_str(), -1, &ps, 0);
+    if (rc != SQLITE_OK) {
+      // Something bad happened, we'll come back to look at this later
+      return;
+    }
+    sqlite3_bind_text(ps, 1, label, -1, SQLITE_STATIC);
 
+    rc = sqlite3_step(ps);
+    if (rc == SQLITE_ROW)
+    {
+      sqlite3_result_int64(_context, sqlite3_column_int64(ps, 0));
+    } else {
+      report_error(_context, gqlite::exception_code::internal_error, "No uid counter for '{}'.", label);
+    }
+    sqlite3_finalize(ps);    
+  }
+  void gqlite_jsonify(sqlite3_context* _context,int,sqlite3_value** _argv)
+  {
+    constexpr int JSON_TYPE = 74;
+    if(sqlite3_value_subtype(_argv[0]) == JSON_TYPE)
+    {
+      sqlite3_result_subtype(_context, JSON_TYPE);
+      sqlite3_result_text(_context, reinterpret_cast<const char*>(sqlite3_value_text(_argv[0])), -1, SQLITE_TRANSIENT);
+    } else {
+      switch(sqlite3_value_type(_argv[0]))
+      {
+        case SQLITE_NULL:
+          sqlite3_result_null(_context);
+          break;
+        case SQLITE_INTEGER:
+          sqlite3_result_int64(_context, sqlite3_value_int64(_argv[0]));
+          break;
+        case SQLITE_FLOAT:
+          sqlite3_result_double(_context, sqlite3_value_double(_argv[0]));
+          break;
+        case SQLITE_TEXT:
+        {
+          const char* str =reinterpret_cast<const char*>(sqlite3_value_text(_argv[0]));
+          sqlite3_result_text(_context, str, -1, SQLITE_TRANSIENT);
+          if(is_valid_json::validate(str))
+          {
+            sqlite3_result_subtype(_context, JSON_TYPE);
+          }
+        }
+          break;
+        default:
+          report_error(_context, exception_code::invalid_argument_type, "Invalid arguments for addition.");
+      }
+    }
+  }
   void gqlite_range(sqlite3_context* _context,int,sqlite3_value** _argv)
   {
     int start = sqlite3_value_int(_argv[0]);
@@ -8893,7 +9377,7 @@ namespace gqlite::backends
         }
           break;
         default:
-          report_error(_context, exception_code::invalid_argument_type, "Inavlid arguments for addition.");
+          report_error(_context, exception_code::invalid_argument_type, "Invalid arguments for addition.");
       }
     } else {
       double left_v = 0.0, right_v = 0.0;
@@ -9013,7 +9497,7 @@ namespace gqlite::backends
   }
   void gqlite_contains(sqlite3_context* _context,int,sqlite3_value** _argv)
   {
-    NULL_CHECK(2);
+    NULL_CHECK_AT(0);
     std::string left = reinterpret_cast<const char*>(sqlite3_value_text(_argv[0]));
     value val_left;
     SAFE(val_left = value::from_json(left));
@@ -9022,11 +9506,13 @@ namespace gqlite::backends
     {
       case value_type::vector:
       {
-        std::string right = reinterpret_cast<const char*>(sqlite3_value_text(_argv[1]));
-        value_vector vv = val_left.to_vector();
         value val_right;
-        SAFE(val_right = value::from_json(right));
-
+        value_vector vv = val_left.to_vector();
+        if(sqlite3_value_type(_argv[1]) != SQLITE_NULL)
+        {
+          std::string right = reinterpret_cast<const char*>(sqlite3_value_text(_argv[1]));
+          SAFE(val_right = value::from_json(right));
+        }
         switch(contains(vv, val_right))
         {
         case comparison_result::true_result:
@@ -9076,9 +9562,31 @@ namespace gqlite::backends
       report_error(_context, exception_code::invalid_argument_type, "Invalid argument to function tail, list was expected.");
     }
   }
-
+  void gqlite_to_integer(sqlite3_context* _context,int,sqlite3_value** _argv)
+  {
+    int type = sqlite3_value_type(_argv[0]);
+    switch(type)
+    {
+      case SQLITE_INTEGER:
+        sqlite3_result_int64(_context, sqlite3_value_int64(_argv[0]));
+        break;
+      case SQLITE_FLOAT:
+        sqlite3_result_int64(_context, sqlite3_value_double(_argv[0]));
+        break;
+      case SQLITE_TEXT:
+      {
+        std::string s(reinterpret_cast<const char*>(sqlite3_value_text(_argv[0])));
+        sqlite3_result_int64(_context, std::stol(s));
+      }
+        break;
+      default:
+        report_error(_context, exception_code::invalid_argument_type, "Invalid arguments for toInteger.");
+    }
+  }
   void initialise_sqlite_ext(sqlite3* db)
   {
+    sqlite3_create_function(db, "gqlite_jsonify", 1, SQLITE_SUBTYPE | SQLITE_RESULT_SUBTYPE | SQLITE_UTF8, nullptr, &gqlite_jsonify, nullptr, nullptr);
+    sqlite3_create_function(db, "gqlite_next_uid", 1, SQLITE_UTF8, nullptr, &gqlite_next_uid, nullptr, nullptr);
     sqlite3_create_function(db, "gqlite_range", 2, SQLITE_DETERMINISTIC | SQLITE_UTF8, nullptr, &gqlite_range, nullptr, nullptr);
     sqlite3_create_function(db, "gqlite_concat", 2, SQLITE_DETERMINISTIC | SQLITE_UTF8, nullptr, &gqlite_concat, nullptr, nullptr);
     sqlite3_create_function(db, "gqlite_addition", 2, SQLITE_DETERMINISTIC | SQLITE_UTF8, nullptr, &gqlite_addition, nullptr, nullptr);
@@ -9086,5 +9594,6 @@ namespace gqlite::backends
     sqlite3_create_function(db, "gqlite_range_access", 3, SQLITE_DETERMINISTIC | SQLITE_UTF8, nullptr, &gqlite_range_access, nullptr, nullptr);
     sqlite3_create_function(db, "gqlite_contains", 2, SQLITE_DETERMINISTIC | SQLITE_UTF8, nullptr, &gqlite_contains, nullptr, nullptr);
     sqlite3_create_function(db, "gqlite_tail", 1, SQLITE_DETERMINISTIC | SQLITE_UTF8, nullptr, &gqlite_tail, nullptr, nullptr);
+    sqlite3_create_function(db, "gqlite_to_integer", 1, SQLITE_DETERMINISTIC | SQLITE_UTF8, nullptr, &gqlite_to_integer, nullptr, nullptr);
   }
 }//END backends/sqlite_ext.cpp