arangodb · jsteemann · Feb 11, 2021 · Jan 21, 2021 · Jan 21, 2021 · Jan 21, 2021
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1245,7 +1245,6 @@ if (USE_MAINTAINER_MODE)
 
   set(ERROR_FILES
     lib/Basics/voc-errors.h
-    lib/Basics/voc-errors.cpp
     lib/Basics/error-registry.h
     js/common/bootstrap/errors.js
   )

diff --git a/arangod/Aql/Ast.cpp b/arangod/Aql/Ast.cpp
@@ -57,6 +57,7 @@
 
 using namespace arangodb;
 using namespace arangodb::aql;
+namespace StringUtils = arangodb::basics::StringUtils;
 
 namespace {
 
@@ -3686,10 +3687,10 @@ AstNode* Ast::optimizeFor(AstNode* node) {
     // right-hand operand to FOR statement is no array
     THROW_ARANGO_EXCEPTION_MESSAGE(
         TRI_ERROR_QUERY_ARRAY_EXPECTED,
-        std::string("collection or ") + TRI_errno_string(TRI_ERROR_QUERY_ARRAY_EXPECTED) +
-            std::string(" as operand to FOR loop; you specified type '") +
-            expression->getValueTypeString() + std::string("' with content '") +
-            expression->toString() + std::string("'"));
+        StringUtils::concatT(&
23D3
quot;collection or ", TRI_errno_string(TRI_ERROR_QUERY_ARRAY_EXPECTED),
+                             " as operand to FOR loop; you specified type '",
+                             expression->getValueTypeString(),
+                             "' with content '", expression->toString(), "'"));
   }
 
   // no real optimizations will be done here

diff --git a/arangod/Aql/EnumerateListExecutor.cpp b/arangod/Aql/EnumerateListExecutor.cpp
@@ -35,18 +35,20 @@
 #include "Aql/SingleRowFetcher.h"
 #include "Aql/Stats.h"
 #include "Basics/Exceptions.h"
+#include "Basics/StringUtils.h"
 
 using namespace arangodb;
 using namespace arangodb::aql;
+using namespace arangodb::basics;
 
 namespace {
 void throwArrayExpectedException(AqlValue const& value) {
   THROW_ARANGO_EXCEPTION_MESSAGE(
       TRI_ERROR_QUERY_ARRAY_EXPECTED,
-      std::string("collection or ") + TRI_errno_string(TRI_ERROR_QUERY_ARRAY_EXPECTED) +
-          std::string(
-              " as operand to FOR loop; you provided a value of type '") +
-          value.getTypeString() + std::string("'"));
+      StringUtils::concatT(
+          "collection or ", TRI_errno_string(TRI_ERROR_QUERY_ARRAY_EXPECTED),
+          " as operand to FOR loop; you provided a value of type '",
+          value.getTypeString(), "'"));
 }
 }  // namespace
 

diff --git a/arangod/Aql/Parser.cpp b/arangod/Aql/Parser.cpp
@@ -133,21 +133,21 @@ QueryResult Parser::parseWithDetails() {
 
 /// @brief register a parse error, position is specified as line / column
 void Parser::registerParseError(ErrorCode errorCode, char const* format,
-                                char const* data, int line, int column) {
+                                std::string_view data, int line, int column) {
   char buffer[512];
   // make sure the buffer is always initialized
   buffer[0] = '\0';
   buffer[sizeof(buffer) - 1] = '\0';
 
-  snprintf(buffer, sizeof(buffer) - 1, format, data);
+  snprintf(buffer, sizeof(buffer) - 1, format, data.data());
 
   return registerParseError(errorCode, buffer, line, column);
 }
 
 /// @brief register a parse error, position is specified as line / column
-void Parser::registerParseError(ErrorCode errorCode, char const* data, int line, int column) {
+void Parser::registerParseError(ErrorCode errorCode, std::string_view data, int line, int column) {
   TRI_ASSERT(errorCode != TRI_ERROR_NO_ERROR);
-  TRI_ASSERT(data != nullptr);
+  TRI_ASSERT(data.data() != nullptr);
 
   // extract the query string part where the error happened
   std::string const region(queryString().extractRegion(line, column));
@@ -172,11 +172,12 @@ void Parser::registerParseError(ErrorCode errorCode, char const* data, int line,
     errorMessage << '^' << '^' << std::endl;
   }
 
-  _query.warnings().registerError(errorCode, errorMessage.str().c_str());
+  _query.warnings().registerError(errorCode, errorMessage.str());
 }
 
 /// @brief register a warning
-void Parser::registerWarning(ErrorCode errorCode, char const* data, int line, int column) {
+void Parser::registerWarning(ErrorCode errorCode, std::string_view data,
+                             [[maybe_unused]] int line, [[maybe_unused]] int column) {
   // ignore line and column for now
   _query.warnings().registerWarning(errorCode, data);
 }

diff --git a/arangod/Aql/Parser.h b/arangod/Aql/Parser.h
@@ -103,13 +103,13 @@ class Parser {
 
   /// @brief register a parse error, position is specified as line / column
   void registerParseError(ErrorCode errorCode, char const* format,
-                          char const* data, int line, int column);
+                          std::string_view data, int line, int column);
 
   /// @brief register a parse error, position is specified as line / column
-  void registerParseError(ErrorCode errorCode, char const* data, int line, int column);
+  void registerParseError(ErrorCode errorCode, std::string_view data, int line, int column);
 
   /// @brief register a warning
-  void registerWarning(ErrorCode errorCode, char const* data, int line, int column);
+  void registerWarning(ErrorCode errorCode, std::string_view data, int line, int column);
 
   /// @brief push an AstNode array element on top of the stack
   /// the array must be removed from the stack via popArray

diff --git a/arangod/Aql/Query.cpp b/arangod/Aql/Query.cpp
@@ -78,6 +78,7 @@
 
 using namespace arangodb;
 using namespace arangodb::aql;
+using namespace arangodb::basics;
 
 /// @brief internal constructor, Used to construct a full query or a ClusterQuery
 Query::Query(std::shared_ptr<transaction::Context> const& ctx,
@@ -535,18 +536,20 @@ ExecutionState Query::execute(QueryResult& queryResult) {
                                             QueryExecutionState::toStringWithPrefix(_execState)));
     cleanupPlanAndEngine(ex.code(), /*sync*/true);
   } catch (std::bad_alloc const&) {
-    queryResult.reset(Result(TRI_ERROR_OUT_OF_MEMORY,
-                             TRI_errno_string(TRI_ERROR_OUT_OF_MEMORY) +
-                                 QueryExecutionState::toStringWithPrefix(_execState)));
+    queryResult.reset(
+        Result(TRI_ERROR_OUT_OF_MEMORY,
+               StringUtils::concatT(TRI_errno_string(TRI_ERROR_OUT_OF_MEMORY),
+                                    QueryExecutionState::toStringWithPrefix(_execState))));
     cleanupPlanAndEngine(TRI_ERROR_OUT_OF_MEMORY, /*sync*/true);
   } catch (std::exception const& ex) {
     queryResult.reset(Result(TRI_ERROR_INTERNAL,
                              ex.what() + QueryExecutionState::toStringWithPrefix(_execState)));
     cleanupPlanAndEngine(TRI_ERROR_INTERNAL, /*sync*/true);
   } catch (...) {
-    queryResult.reset(Result(TRI_ERROR_INTERNAL,
-                             TRI_errno_string(TRI_ERROR_INTERNAL) +
-                                 QueryExecutionState::toStringWithPrefix(_execState)));
+    queryResult.reset(
+        Result(TRI_ERROR_INTERNAL,
+               StringUtils::concatT(TRI_errno_string(TRI_ERROR_INTERNAL),
+                                    QueryExecutionState::toStringWithPrefix(_execState))));
     cleanupPlanAndEngine(TRI_ERROR_INTERNAL, /*sync*/true);
   }
 
@@ -756,19 +759,21 @@ QueryResultV8 Query::executeV8(v8::Isolate* isolate) {
                                             QueryExecutionState::toStringWithPrefix(_execState)));
     cleanupPlanAndEngine(ex.code(), /*sync*/true);
   } catch (std::bad_alloc const&) {
-    queryResult.reset(Result(TRI_ERROR_OUT_OF_MEMORY,
-                             TRI_errno_string(TRI_ERROR_OUT_OF_MEMORY) +
-                                 QueryExecutionState::toStringWithPrefix(_execState)));
+    queryResult.reset(
+        Result(TRI_ERROR_OUT_OF_MEMORY,
+               StringUtils::concatT(TRI_errno_string(TRI_ERROR_OUT_OF_MEMORY),
+                                    QueryExecutionState::toStringWithPrefix(_execState))));
     cleanupPlanAndEngine(TRI_ERROR_OUT_OF_MEMORY, /*sync*/true);
   } catch (std::exception const& ex) {
     queryResult.reset(Result(TRI_ERROR_INTERNAL,
                              ex.what() + QueryExecutionState::toStringWithPrefix(_execState)));
     cleanupPlanAndEngine(TRI_ERROR_INTERNAL, /*sync*/true);
   } catch (...) {
-    queryResult.reset(Result(TRI_ERROR_INTERNAL,
-                             TRI_errno_string(TRI_ERROR_INTERNAL) +
-                                 QueryExecutionState::toStringWithPrefix(_execState)));
-    cleanupPlanAndEngine(TRI_ERROR_INTERNAL, /*sync*/true);
+    queryResult.reset(
+        Result(TRI_ERROR_INTERNAL,
+               StringUtils::concatT(TRI_errno_string(TRI_ERROR_INTERNAL),
+                                    QueryExecutionState::toStringWithPrefix(_execState))));
+    cleanupPlanAndEngine(TRI_ERROR_INTERNAL, /*sync*/ true);
   }
 
   return queryResult;
@@ -942,13 +947,16 @@ QueryResult Query::explain() {
   } catch (arangodb::basics::Exception const& ex) {
     result.reset(Result(ex.code(), ex.message() + QueryExecutionState::toStringWithPrefix(_execState)));
   } catch (std::bad_alloc const&) {
-    result.reset(Result(TRI_ERROR_OUT_OF_MEMORY,
-                        TRI_errno_string(TRI_ERROR_OUT_OF_MEMORY) +
-                        QueryExecutionState::toStringWithPrefix(_execState)));
+    result.reset(
+        Result(TRI_ERROR_OUT_OF_MEMORY,
+               StringUtils::concatT(TRI_errno_string(TRI_ERROR_OUT_OF_MEMORY),
+                                    QueryExecutionState::toStringWithPrefix(_execState))));
   } catch (std::exception const& ex) {
     result.reset(Result(TRI_ERROR_INTERNAL, ex.what() + QueryExecutionState::toStringWithPrefix(_execState)));
   } catch (...) {
-    result.reset(Result(TRI_ERROR_INTERNAL, TRI_errno_string(TRI_ERROR_INTERNAL) + QueryExecutionState::toStringWithPrefix(_execState)));
+    result.reset(Result(TRI_ERROR_INTERNAL,
+                        StringUtils::concatT(TRI_errno_string(TRI_ERROR_INTERNAL),
+                                             QueryExecutionState::toStringWithPrefix(_execState))));
   }
 
   // will be returned in success or failure case

diff --git a/arangod/Aql/QueryCursor.cpp b/arangod/Aql/QueryCursor.cpp
@@ -30,6 +30,7 @@
 #include "Aql/Query.h"
 #include "Aql/QueryRegistry.h"
 #include "Basics/ScopeGuard.h"
+#include "Basics/StringUtils.h"
 #include "Logger/LogMacros.h"
 #include "RestServer/QueryRegistryFeature.h"
 #include "StorageEngine/TransactionState.h"
@@ -46,6 +47,7 @@
 
 using namespace arangodb;
 using namespace arangodb::aql;
+using namespace arangodb::basics;
 
 QueryResultCursor::QueryResultCursor(TRI_vocbase_t& vocbase, aql::QueryResult&& result,
                                      size_t batchSize, double ttl, bool hasCount)
@@ -233,8 +235,9 @@ std::pair<ExecutionState, Result> QueryStreamCursor::dump(VPackBuilder& builder)
     this->setDeleted();
     return {ExecutionState::DONE,
             Result(TRI_ERROR_OUT_OF_MEMORY,
-                   TRI_errno_string(TRI_ERROR_OUT_OF_MEMORY) +
-                       QueryExecutionState::toStringWithPrefix(_query->state()))};
+                   StringUtils::concatT(TRI_errno_string(TRI_ERROR_OUT_OF_MEMORY),
+                                        QueryExecutionState::toStringWithPrefix(
+                                            _query->state())))};
   } catch (std::exception const& ex) {
     this->setDeleted();
     return {ExecutionState::DONE,
@@ -244,8 +247,8 @@ std::pair<ExecutionState, Result> QueryStreamCursor::dump(VPackBuilder& builder)
     this->setDeleted();
     return {ExecutionState::DONE,
             Result(TRI_ERROR_INTERNAL,
-                   TRI_errno_string(TRI_ERROR_INTERNAL) +
-                       QueryExecutionState::toStringWithPrefix(_query->state()))};
+                   StringUtils::concatT(TRI_errno_string(TRI_ERROR_INTERNAL),
+                                        QueryExecutionState::toStringWithPrefix(_query->state())))};
   }
 }
 
@@ -287,19 +290,21 @@ Result QueryStreamCursor::dumpSync(VPackBuilder& builder) {
   } catch (std::bad_alloc const&) {
     this->setDeleted();
     return Result(TRI_ERROR_OUT_OF_MEMORY,
-                  TRI_errno_string(TRI_ERROR_OUT_OF_MEMORY) +
-                      QueryExecutionState::toStringWithPrefix(_query->state()));
+                  StringUtils::concatT(TRI_errno_string(TRI_ERROR_OUT_OF_MEMORY),
+                                       QueryExecutionState::toStringWithPrefix(
+                                           _query->state())));
   } catch (std::exception const& ex) {
     this->setDeleted();
     return Result(TRI_ERROR_INTERNAL,
                   ex.what() + QueryExecutionState::toStringWithPrefix(_query->state()));
   } catch (...) {
     this->setDeleted();
     return Result(TRI_ERROR_INTERNAL,
-                  TRI_errno_string(TRI_ERROR_INTERNAL) +
-                      QueryExecutionState::toStringWithPrefix(_query->state()));
+                  StringUtils::concatT(TRI_errno_string(TRI_ERROR_INTERNAL),
+                                       QueryExecutionState::toStringWithPrefix(
+                                           _query->state())));
   }
-  
+
   return Result();
 }
 

diff --git a/arangod/Aql/QueryWarnings.cpp b/arangod/Aql/QueryWarnings.cpp
@@ -39,29 +39,25 @@ QueryWarnings::QueryWarnings()
 
 /// @brief register an error
 /// this also makes the query abort
-void QueryWarnings::registerError(ErrorCode code, char const* details) {
+void QueryWarnings::registerError(ErrorCode code, std::string_view details) {
   TRI_ASSERT(code != TRI_ERROR_NO_ERROR);
 
-  if (details == nullptr) {
+  if (details.data() == nullptr) {
     THROW_ARANGO_EXCEPTION(code);
   }
 
   THROW_ARANGO_EXCEPTION_MESSAGE(code, details);
 }
 
-void QueryWarnings::registerWarning(ErrorCode code, std::string const& details) {
-  registerWarning(code, details.c_str());
-}
-
 /// @brief register a warning
-void QueryWarnings::registerWarning(ErrorCode code, char const* details) {
+void QueryWarnings::registerWarning(ErrorCode code, std::string_view details) {
   TRI_ASSERT(code != TRI_ERROR_NO_ERROR);
 
   std::lock_guard<std::mutex> guard(_mutex);
 
   if (_failOnWarning) {
     // make an error from each warning if requested
-    if (details == nullptr) {
+    if (details.data() == nullptr) {
       THROW_ARANGO_EXCEPTION(code);
     }
     THROW_ARANGO_EXCEPTION_MESSAGE(code, details);
@@ -71,7 +67,7 @@ void QueryWarnings::registerWarning(ErrorCode code, char const* details) {
     return;
   }
 
-  if (details == nullptr) {
+  if (details.data() == nullptr) {
     _list.emplace_back(code, TRI_errno_string(code));
   } else {
     _list.emplace_back(code, details);

diff --git a/arangod/Aql/QueryWarnings.h b/arangod/Aql/QueryWarnings.h
@@ -49,13 +49,9 @@ class QueryWarnings final {
 
   /// @brief register an error
   /// this also makes the query abort
-  [[noreturn]] void registerError(ErrorCode code, char const* details = nullptr);
-
+  [[noreturn]] v
D9B2
oid registerError(ErrorCode code, std::string_view details = {});
   /// @brief register a warning
-  void registerWarning(ErrorCode code, char const* details = nullptr);
-
-  /// @brief register a warning (convenience overload)
-  void registerWarning(ErrorCode code, std::string const& details);
+  void registerWarning(ErrorCode code, std::string_view details = {});
 
   void toVelocyPack(arangodb::velocypack::Builder& b) const;
 

diff --git a/arangod/Aql/WindowNode.cpp b/arangod/Aql/WindowNode.cpp
@@ -169,7 +169,7 @@ bool parameterToTimePoint(AqlValue const& value, QueryWarnings& warnings,
     }
     return true;
   }*/
-  warnings.registerWarning(TRI_ERROR_QUERY_INVALID_DATE_VALUE, nullptr);
+  warnings.registerWarning(TRI_ERROR_QUERY_INVALID_DATE_VALUE);
   return false;
 }
 
@@ -232,7 +232,7 @@ WindowBounds::Row WindowBounds::calcRow(AqlValue const& input, QueryWarnings& w)
   bool failed;
   double val = input.toDouble(failed);
   if (failed) {
-    w.registerWarning(TRI_ERROR_QUERY_INVALID_ARITHMETIC_VALUE, nullptr);
+    w.registerWarning(TRI_ERROR_QUERY_INVALID_ARITHMETIC_VALUE);
     return {0, 0, 0, /*valid*/ false};
   }