RubyGems - gqlite - Versions diffs - 1.0.0 → 1.1.0 - Mend

gqlite 1.0.0 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

checksums.yaml +4 -4
data/ext/gqlite/gqlite-amalgamate.cpp +816 -307
metadata +2 -2

data/ext/gqlite/gqlite-amalgamate.cpp CHANGED Viewed

@@ -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