////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2014-2016 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
///     http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an "AS IS" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Jan Steemann
////////////////////////////////////////////////////////////////////////////////

#include "Functions.h"

#include "ApplicationFeatures/ApplicationServer.h"
#include "ApplicationFeatures/LanguageFeature.h"
#include "Aql/Function.h"
#include "Aql/Query.h"
#include "Aql/RegexCache.h"
#include "Basics/Exceptions.h"
#include "Basics/StringBuffer.h"
#include "Basics/StringRef.h"
#include "Basics/StringUtils.h"
#include "Basics/Utf8Helper.h"
#include "Basics/VPackStringBufferAdapter.h"
#include "Basics/VelocyPackHelper.h"
#include "Basics/fpconv.h"
#include "Basics/tri-strings.h"
#include "GeneralServer/AuthenticationFeature.h"
#include "Indexes/Index.h"
#include "Logger/Logger.h"
#include "Pregel/PregelFeature.h"
#include "Pregel/Worker.h"
#include "Random/UniformCharacter.h"
#include "Ssl/SslInterface.h"
#include "Transaction/Context.h"
#include "Transaction/Helpers.h"
#include "Transaction/Methods.h"
#include "Utils/CollectionNameResolver.h"
#include "Utils/ExecContext.h"
#include "V8Server/v8-collection.h"
#include "VocBase/KeyGenerator.h"
#include "VocBase/LogicalCollection.h"
#include "VocBase/ManagedDocumentResult.h"

#include <date/date.h>
#include <date/iso_week.h>

#include <unicode/stsearch.h>
#include <unicode/uchar.h>
#include <unicode/unistr.h>
#include <unicode/stsearch.h>
#include <unicode/schriter.h>

#include <velocypack/Collection.h>
#include <velocypack/Dumper.h>
#include <velocypack/Iterator.h>
#include <velocypack/velocypack-aliases.h>
#include <algorithm>
#include <regex>

using namespace arangodb;
using namespace arangodb::aql;
using namespace std::chrono;
using namespace date;

enum DateSelectionModifier {
  INVALID = 0,
  MILLI,
  SECOND,
  MINUTE,
  HOUR,
  DAY,
  WEEK,
  MONTH,
  YEAR
};
static_assert(DateSelectionModifier::INVALID < DateSelectionModifier::MILLI,
              "incorrect date selection order");
static_assert(DateSelectionModifier::MILLI < DateSelectionModifier::SECOND,
              "incorrect date selection order");
static_assert(DateSelectionModifier::SECOND < DateSelectionModifier::MINUTE,
              "incorrect date selection order");
static_assert(DateSelectionModifier::MINUTE < DateSelectionModifier::HOUR,
              "incorrect date selection order");
static_assert(DateSelectionModifier::HOUR < DateSelectionModifier::DAY,
              "incorrect date selection order");
static_assert(DateSelectionModifier::DAY < DateSelectionModifier::WEEK,
              "incorrect date selection order");
static_assert(DateSelectionModifier::WEEK < DateSelectionModifier::MONTH,
              "incorrect date selection order");
static_assert(DateSelectionModifier::MONTH < DateSelectionModifier::YEAR,
              "incorrect date selection order");


/*
- always specify your user facing function name MYFUNC in error generators
- errors are broadcasted like this:
    - Wrong parameter types: RegisterInvalidArgumentWarning(query, "MYFUNC")
    - Generic errors: RegisterWarning(query, "MYFUNC", TRI_ERROR_QUERY_INVALID_REGEX);
    - ICU related errors: if (U_FAILURE(status)) { RegisterICUWarning(query, "MYFUNC", status); }
    - close with: return AqlValue(AqlValueHintNull());
- specify the number of parameters you expect at least and at max using: 
  ValidateParameters(parameters, "MYFUNC", 1, 3); (min: 1, max: 3)
- if you support optional parameters, first check whether the count is sufficient
  using parameters.size()
- fetch the values using:
  AqlValue value
  - Anonymous  = ExtractFunctionParameterValue(parameters, 0);
  - GetBooleanParameter() if you expect a bool
  - Stringify() if you need a string.
  - ExtractKeys() if its an object and you need the keys
  - ExtractCollectionName() if you expect a collection
  - ListContainsElement() search for a member
- check the values whether they match your expectations i.e. using:
  - param.isNumber() then extract it using: param.toInt64(trx)
- Available helper functions for working with pamaterers:
  - Variance()
  - SortNumberList()
  - UnsetOrKeep ()
  - GetDocumentByIdentifier ()
  - MergeParameters()
  - FlattenList()

- now do your work with the parameters
- build ub a result using a VPackbuilder like you would with regular velocpyack.
- return it wrapping it into an AqlValue

 */
/// @brief convert a number value into an AqlValue
static inline AqlValue NumberValue(transaction::Methods* trx, int value) {
  return AqlValue(AqlValueHintInt(value));
}

/// @brief convert a number value into an AqlValue
static AqlValue NumberValue(transaction::Methods* trx, double value,
                            bool nullify) {
  if (std::isnan(value) || !std::isfinite(value) || value == HUGE_VAL ||
      value == -HUGE_VAL) {
    if (nullify) {
      // convert to null
      return AqlValue(AqlValueHintNull());
    }
    // convert to 0
    return AqlValue(AqlValueHintZero());
  }

  return AqlValue(AqlValueHintDouble(value));
}

static inline AqlValue TimeAqlValue(tp_sys_clock_ms const& tp) {
  std::string formatted = format("%FT%TZ", floor<milliseconds>(tp));
  return AqlValue(formatted);
}

static DateSelectionModifier ParseDateModifierFlag(VPackSlice flag) {
  if (!flag.isString()) {
    return INVALID;
  }

  std::string flagStr = flag.copyString();
  if (flagStr.empty()) {
    return INVALID;
  }
  TRI_ASSERT(flagStr.size() >= 1);

  std::transform(flagStr.begin(), flagStr.end(), flagStr.begin(), ::tolower);
  switch (flagStr.front()) {
    case 'y':
      if (flagStr == "years" || flagStr == "year" || flagStr == "y") {
        return YEAR;
      }
      break;
    case 'w':
      if (flagStr == "weeks" || flagStr == "week" || flagStr == "w") {
        return WEEK;
      }
      break;
    case 'm':
      if (flagStr == "months" || flagStr == "month" || flagStr == "m") {
        return MONTH;
      }
      // Can be minute as well
      if (flagStr == "minutes" || flagStr == "minute") {
        return MINUTE;
      }
      // Can be millisecond as well
      if (flagStr == "milliseconds" || flagStr == "millisecond") {
        return MILLI;
      }
      break;
    case 'd':
      if (flagStr == "days" || flagStr == "day" || flagStr == "d") {
        return DAY;
      }
      break;
    case 'h':
      if (flagStr == "hours" || flagStr == "hour" || flagStr == "h") {
        return HOUR;
      }
      break;
    case 's':
      if (flagStr == "seconds" || flagStr == "second" || flagStr == "s") {
        return SECOND;
      }
      break;
    case 'i':
      if (flagStr == "i") {
        return MINUTE;
      }
      break;
    case 'f':
      if (flagStr == "f") {
        return MILLI;
      }
      break;
  }
  // If we get here the flag is invalid
  return INVALID;
}

AqlValue Functions::AddOrSubtractUnitFromTimestamp(Query* query,
                                                   tp_sys_clock_ms const& tp,
                                                   VPackSlice durationUnitsSlice,
                                                   VPackSlice durationType,
                                                   bool isSubtract) {
  bool isInteger = durationUnitsSlice.isInteger();
  double durationUnits = durationUnitsSlice.getNumber<double>();
  std::chrono::duration<double, std::ratio<1l, 1000l>> ms{};
  year_month_day ymd{floor<days>(tp)};
  auto day_time = make_time(tp - sys_days(ymd));

  DateSelectionModifier flag = ParseDateModifierFlag(durationType);
  double intPart = 0.0;
  if (durationUnits < 0.0) {
    // Make sure duration is always positive. So we flip isSubtract in this
    // case.
    isSubtract = !isSubtract;
    durationUnits *= -1.0;
  }
  TRI_ASSERT(durationUnits >= 0.0);

  // All Fallthroughs intentional. We still have some remainder
  switch (flag) {
    case YEAR:
      durationUnits = std::modf(durationUnits, &intPart);
      if (isSubtract) {
        ymd -= years{static_cast<int64_t>(intPart)};
      } else {
        ymd += years{static_cast<int64_t>(intPart)};
      }
      if (isInteger || durationUnits == 0.0) {
        break;  // We are done
      }
      durationUnits *= 12;
      // intentionally falls through
    case MONTH:
      durationUnits = std::modf(durationUnits, &intPart);
      if (isSubtract) {
        ymd -= months{static_cast<int64_t>(intPart)};
      } else {
        ymd += months{static_cast<int64_t>(intPart)};
      }
      if (isInteger || durationUnits == 0.0) {
        break;  // We are done
      }
      durationUnits *= 30;  // 1 Month ~= 30 Days
      // intentionally falls through
    // After this fall through the date may actually a bit off
    case DAY:
      // From here on we do not need leap-day handling
      ms = days{1};
      ms *= durationUnits;
      break;
    case WEEK:
      ms = weeks{1};
      ms *= durationUnits;
      break;
    case HOUR:
      ms = hours{1};
      ms *= durationUnits;
      break;
    case MINUTE:
      ms = minutes{1};
      ms *= durationUnits;
      break;
    case SECOND:
      ms = seconds{1};
      ms *= durationUnits;
      break;
    case MILLI:
      ms = milliseconds{1};
      ms *= durationUnits;
      break;
    default:
      if (isSubtract) {
        RegisterWarning(query, "DATE_SUBTRACT",
                        TRI_ERROR_QUERY_INVALID_DATE_VALUE);
      } else {
        RegisterWarning(query, "DATE_ADD", TRI_ERROR_QUERY_INVALID_DATE_VALUE);
      }
      return AqlValue(AqlValueHintNull());
  }
  // Here we reconstruct the timepoint again

  tp_sys_clock_ms resTime;
  if (isSubtract) {
    resTime = tp_sys_clock_ms{sys_days(ymd) + day_time.to_duration() -
                              std::chrono::duration_cast<duration<int64_t, std::milli>>(ms)};
  } else {
    resTime = tp_sys_clock_ms{sys_days(ymd) + day_time.to_duration() +
                              std::chrono::duration_cast<duration<int64_t, std::milli>>(ms)};
  }
  return TimeAqlValue(resTime);
}

AqlValue Functions::AddOrSubtractIsoDurationFromTimestamp(
    Query* query, tp_sys_clock_ms const& tp, std::string const& duration,
    bool isSubtract) {
  year_month_day ymd{floor<days>(tp)};
  auto day_time = make_time(tp - sys_days(ymd));
  std::smatch duration_parts;
  if (!basics::regex_isoDuration(duration, duration_parts)) {
    if (isSubtract) {
      RegisterWarning(query, "DATE_SUBTRACT",
                      TRI_ERROR_QUERY_INVALID_DATE_VALUE);
    } else {
      RegisterWarning(query, "DATE_ADD", TRI_ERROR_QUERY_INVALID_DATE_VALUE);
    }
    return AqlValue(AqlValueHintNull());
  }

  int number = basics::StringUtils::int32(duration_parts[2].str());
  if (isSubtract) {
    ymd -= years{number};
  } else {
    ymd += years{number};
  }

  number = basics::StringUtils::int32(duration_parts[4].str());
  if (isSubtract) {
    ymd -= months{number};
  } else {
    ymd += months{number};
  }

  milliseconds ms{0};
  number = basics::StringUtils::int32(duration_parts[6].str());
  ms += weeks{number};

  number = basics::StringUtils::int32(duration_parts[8].str());
  ms += days{number};

  number = basics::StringUtils::int32(duration_parts[11].str());
  ms += hours{number};

  number = basics::StringUtils::int32(duration_parts[13].str());
  ms += minutes{number};

  number = basics::StringUtils::int32(duration_parts[15].str());
  ms += seconds{number};

  // The Milli seconds can be shortened:
  // .1 => 100ms
  // so we append 00 but only take the first 3 digits
  number = basics::StringUtils::int32(
      (duration_parts[17].str() + "00").substr(0, 3));
  ms += milliseconds{number};

  tp_sys_clock_ms resTime;
  if (isSubtract) {
    resTime = tp_sys_clock_ms{sys_days(ymd) + day_time.to_duration() - ms};
  } else {
    resTime = tp_sys_clock_ms{sys_days(ymd) + day_time.to_duration() + ms};
  }
  return TimeAqlValue(resTime);
}

/// @brief validate the number of parameters
void Functions::ValidateParameters(VPackFunctionParameters const& parameters,
                                   char const* function, int minParams,
                                   int maxParams) {
  if (parameters.size() < static_cast<size_t>(minParams) ||
      parameters.size() > static_cast<size_t>(maxParams)) {
    THROW_ARANGO_EXCEPTION_PARAMS(
        TRI_ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH, function, minParams,
        maxParams);
  }
}

void Functions::ValidateParameters(VPackFunctionParameters const& parameters,
                                   char const* function, int minParams) {
  return ValidateParameters(parameters, function, minParams,
                            static_cast<int>(Function::MaxArguments));
}

/// @brief extract a function parameter from the arguments
AqlValue Functions::ExtractFunctionParameterValue(
    VPackFunctionParameters const& parameters, size_t position) {
  if (position >= parameters.size()) {
    // parameter out of range
    return AqlValue();
  }
  return parameters[position];
}

/// @brief extra a collection name from an AqlValue
std::string Functions::ExtractCollectionName(
    transaction::Methods* trx, VPackFunctionParameters const& parameters,
    size_t position) {
  AqlValue value = ExtractFunctionParameterValue(parameters, position);

  std::string identifier;

  if (value.isString()) {
    // already a string
    identifier = value.slice().copyString();
  } else {
    AqlValueMaterializer materializer(trx);
    VPackSlice slice = materializer.slice(value, true);
    VPackSlice id = slice;

    if (slice.isObject() && slice.hasKey(StaticStrings::IdString)) {
      id = slice.get(StaticStrings::IdString);
    }
    if (id.isString()) {
      identifier = id.copyString();
    } else if (id.isCustom()) {
      identifier = trx->extractIdString(slice);
    }
  }

  if (!identifier.empty()) {
    size_t pos = identifier.find('/');

    if (pos != std::string::npos) {
      return identifier.substr(0, pos);
    }

    return identifier;
  }

  return StaticStrings::Empty;
}

void RegisterICUWarning(arangodb::aql::Query* query,
                        char const* functionName,
                        UErrorCode status) {
  std::string msg;
  msg.append("in function '");
  msg.append(functionName);
  msg.append("()': ");
  msg.append(arangodb::basics::Exception::FillExceptionString(TRI_ERROR_ARANGO_ICU_ERROR,
                                                              u_errorName(status)));
  query->registerWarning(TRI_ERROR_ARANGO_ICU_ERROR, msg.c_str());
}

/// @brief register warning
void Functions::RegisterWarning(arangodb::aql::Query* query, char const* fName,
                                int code) {
  std::string msg;

  if (code == TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH) {
    msg = arangodb::basics::Exception::FillExceptionString(code, fName);
  } else {
    msg.append("in function '");
    msg.append(fName);
    msg.append("()': ");
    msg.append(TRI_errno_string(code));
  }

  query->registerWarning(code, msg.c_str());
}

/// @brief register usage of an invalid function argument
void Functions::RegisterInvalidArgumentWarning(arangodb::aql::Query* query,
                                               char const* functionName) {
  RegisterWarning(query, functionName,
                  TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
}

/// @brief converts a value into a number value
static double ValueToNumber(VPackSlice const& slice, bool& isValid) {
  if (slice.isNull()) {
    isValid = true;
    return 0.0;
  }
  if (slice.isBoolean()) {
    isValid = true;
    return (slice.getBoolean() ? 1.0 : 0.0);
  }
  if (slice.isNumber()) {
    isValid = true;
    return slice.getNumericValue<double>();
  }
  if (slice.isString()) {
    std::string const str = slice.copyString();
    try {
      if (str.empty()) {
        isValid = true;
        return 0.0;
      }
      size_t behind = 0;
      double value = std::stod(str, &behind);
      while (behind < str.size()) {
        char c = str[behind];
        if (c != ' ' && c != '\t' && c != '\r' && c != '\n' && c != '\f') {
          isValid = false;
          return 0.0;
        }
        ++behind;
      }
      isValid = true;
      return value;
    } catch (...) {
      size_t behind = 0;
      while (behind < str.size()) {
        char c = str[behind];
        if (c != ' ' && c != '\t' && c != '\r' && c != '\n' && c != '\f') {
          isValid = false;
          return 0.0;
        }
        ++behind;
      }
      // A string only containing whitespae-characters is valid and should
      // return 0.0
      // It throws in std::stod
      isValid = true;
      return 0.0;
    }
  }
  if (slice.isArray()) {
    VPackValueLength const n = slice.length();
    if (n == 0) {
      isValid = true;
      return 0.0;
    }
    if (n == 1) {
      return ValueToNumber(slice.at(0), isValid);
    }
  }

  // All other values are invalid
  isValid = false;
  return 0.0;
}

/// @brief extract a boolean parameter from an array
static bool GetBooleanParameter(transaction::Methods* trx,
                                VPackFunctionParameters const& parameters,
                                size_t startParameter, bool defaultValue) {
  size_t const n = parameters.size();

  if (startParameter >= n) {
    return defaultValue;
  }

  return parameters[startParameter].toBoolean();
}

/// @brief extract attribute names from the arguments
void Functions::ExtractKeys(std::unordered_set<std::string>& names,
                            arangodb::aql::Query* query,
                            transaction::Methods* trx,
                            VPackFunctionParameters const& parameters,
                            size_t startParameter, char const* functionName) {
  size_t const n = parameters.size();

  for (size_t i = startParameter; i < n; ++i) {
    AqlValue param = ExtractFunctionParameterValue(parameters, i);

    if (param.isString()) {
      names.emplace(param.slice().copyString());
    } else if (param.isNumber()) {
      double number = param.toDouble(trx);

      if (std::isnan(number) || number == HUGE_VAL || number == -HUGE_VAL) {
        names.emplace("null");
      } else {
        char buffer[24];
        int length = fpconv_dtoa(number, &buffer[0]);
        names.emplace(std::string(&buffer[0], static_cast<size_t>(length)));
      }
    } else if (param.isArray()) {
      AqlValueMaterializer materializer(trx);
      VPackSlice s = materializer.slice(param, false);

      for (auto const& v : VPackArrayIterator(s)) {
        if (v.isString()) {
          names.emplace(v.copyString());
        } else {
          RegisterInvalidArgumentWarning(query, functionName);
        }
      }
    }
  }
}

/// @brief append the VelocyPack value to a string buffer
///        Note: Backwards compatibility. Is different than Slice.toJson()
void Functions::Stringify(transaction::Methods* trx,
                          arangodb::basics::VPackStringBufferAdapter& buffer,
                          VPackSlice const& slice) {
  if (slice.isNull()) {
    // null is the empty string
    return;
  }

  if (slice.isString()) {
    // dumping adds additional ''
    VPackValueLength length;
    char const* p = slice.getString(length);
    buffer.append(p, length);
    return;
  }

  VPackOptions* options =
      trx->transactionContextPtr()->getVPackOptionsForDump();
  VPackOptions adjustedOptions = *options;
  adjustedOptions.escapeUnicode = false;
  adjustedOptions.escapeForwardSlashes = false;
  VPackDumper dumper(&buffer, &adjustedOptions);
  dumper.dump(slice);
}

/// @brief append the VelocyPack value to a string buffer
///        Note: Backwards compatibility. Is different than Slice.toJson()
static void AppendAsString(transaction::Methods* trx,
                           arangodb::basics::VPackStringBufferAdapter& buffer,
                           AqlValue const& value) {
  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(value, false);

  Functions::Stringify(trx, buffer, slice);
}

/// @brief Checks if the given list contains the element
static bool ListContainsElement(transaction::Methods* trx,
                                VPackOptions const* options,
                                AqlValue const& list, AqlValue const& testee,
                                size_t& index) {
  TRI_ASSERT(list.isArray());
  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(list, false);

  AqlValueMaterializer testeeMaterializer(trx);
  VPackSlice testeeSlice = testeeMaterializer.slice(testee, false);

  VPackArrayIterator it(slice);
  while (it.valid()) {
    if (arangodb::basics::VelocyPackHelper::compare(testeeSlice, it.value(),
                                                    false, options) == 0) {
      index = static_cast<size_t>(it.index());
      return true;
    }
    it.next();
  }
  return false;
}

/// @brief Checks if the given list contains the element
/// DEPRECATED
static bool ListContainsElement(VPackOptions const* options,
                                VPackSlice const& list,
                                VPackSlice const& testee, size_t& index) {
  TRI_ASSERT(list.isArray());
  for (size_t i = 0; i < static_cast<size_t>(list.length()); ++i) {
    if (arangodb::basics::VelocyPackHelper::compare(testee, list.at(i), false,
                                                    options) == 0) {
      index = i;
      return true;
    }
  }
  return false;
}

static bool ListContainsElement(VPackOptions const* options,
                                VPackSlice const& list,
                                VPackSlice const& testee) {
  size_t unused;
  return ListContainsElement(options, list, testee, unused);
}

/// @brief Computes the Variance of the given list.
///        If successful value will contain the variance and count
///        will contain the number of elements.
///        If not successful value and count contain garbage.
static bool Variance(transaction::Methods* trx, AqlValue const& values,
                     double& value, size_t& count) {
  TRI_ASSERT(values.isArray());
  value = 0.0;
  count = 0;
  bool unused = false;
  double mean = 0.0;

  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(values, false);

  for (auto const& element : VPackArrayIterator(slice)) {
    if (!element.isNull()) {
      if (!element.isNumber()) {
        return false;
      }
      double current = ValueToNumber(element, unused);
      count++;
      double delta = current - mean;
      mean += delta / count;
      value += delta * (current - mean);
    }
  }
  return true;
}

/// @brief Sorts the given list of Numbers in ASC order.
///        Removes all null entries.
///        Returns false if the list contains non-number values.
static bool SortNumberList(transaction::Methods* trx, AqlValue const& values,
                           std::vector<double>& result) {
  TRI_ASSERT(values.isArray());
  TRI_ASSERT(result.empty());
  bool unused;
  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(values, false);

  for (auto const& element : VPackArrayIterator(slice)) {
    if (!element.isNull()) {
      if (!element.isNumber()) {
        return false;
      }
      result.emplace_back(ValueToNumber(element, unused));
    }
  }
  std::sort(result.begin(), result.end());
  return true;
}

/// @brief Helper function to unset or keep all given names in the value.
///        Recursively iterates over sub-object and unsets or keeps their values
///        as well
static void UnsetOrKeep(transaction::Methods* trx, VPackSlice const& value,
                        std::unordered_set<std::string> const& names,
                        bool unset,  // true means unset, false means keep
                        bool recursive, VPackBuilder& result) {
  TRI_ASSERT(value.isObject());
  VPackObjectBuilder b(&result);  // Close the object after this function
  for (auto const& entry : VPackObjectIterator(value, false)) {
    TRI_ASSERT(entry.key.isString());
    std::string key = entry.key.copyString();
    if ((names.find(key) == names.end()) == unset) {
      // not found and unset or found and keep
      if (recursive && entry.value.isObject()) {
        result.add(entry.key);  // Add the key
        UnsetOrKeep(trx, entry.value, names, unset, recursive,
                    result);  // Adds the object
      } else {
        if (entry.value.isCustom()) {
          result.add(key, VPackValue(trx->extractIdString(value)));
        } else {
          result.add(key, entry.value);
        }
      }
    }
  }
}

/// @brief Helper function to get a document by it's identifier
///        Lazy Locks the collection if necessary.
static void GetDocumentByIdentifier(transaction::Methods* trx,
                                    std::string& collectionName,
                                    std::string const& identifier,
                                    bool ignoreError, VPackBuilder& result) {
  transaction::BuilderLeaser searchBuilder(trx);

  size_t pos = identifier.find('/');
  if (pos == std::string::npos) {
    searchBuilder->add(VPackValue(identifier));
  } else {
    if (collectionName.empty()) {
      searchBuilder->add(VPackValue(identifier.substr(pos + 1)));
      collectionName = identifier.substr(0, pos);
    } else if (identifier.substr(0, pos) != collectionName) {
      // Requesting an _id that cannot be stored in this collection
      if (ignoreError) {
        return;
      }
      THROW_ARANGO_EXCEPTION(TRI_ERROR_ARANGO_CROSS_COLLECTION_REQUEST);
    } else {
      searchBuilder->add(VPackValue(identifier.substr(pos + 1)));
    }
  }

  Result res;
  try {
    res = trx->documentFastPath(collectionName, nullptr, searchBuilder->slice(),
                                result, true);
  } catch (arangodb::basics::Exception const& ex) {
    res.reset(ex.code());
  }

  if (!res.ok()) {
    if (ignoreError) {
      if (res.errorNumber() == TRI_ERROR_ARANGO_DOCUMENT_NOT_FOUND ||
          res.errorNumber() == TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND ||
          res.errorNumber() == TRI_ERROR_ARANGO_CROSS_COLLECTION_REQUEST) {
        return;
      }
    }
    if (res.errorNumber() == TRI_ERROR_TRANSACTION_UNREGISTERED_COLLECTION) {
      // special error message to indicate which collection was undeclared
      THROW_ARANGO_EXCEPTION_MESSAGE(
          res.errorNumber(),
          res.errorMessage() + ": " + collectionName + " [" +
              AccessMode::typeString(AccessMode::Type::READ) + "]");
    }
    THROW_ARANGO_EXCEPTION(res);
  }
}

/// @brief Helper function to merge given parameters
///        Works for an array of objects as first parameter or arbitrary many
///        object parameters
AqlValue Functions::MergeParameters(arangodb::aql::Query* query,
                                    transaction::Methods* trx,
                                    VPackFunctionParameters const& parameters,
                                    char const* funcName, bool recursive) {
  size_t const n = parameters.size();

  if (n == 0) {
    return AqlValue(arangodb::basics::VelocyPackHelper::EmptyObjectValue());
  }

  // use the first argument as the preliminary result
  AqlValue initial = ExtractFunctionParameterValue(parameters, 0);
  AqlValueMaterializer materializer(trx);
  VPackSlice initialSlice = materializer.slice(initial, true);

  VPackBuilder builder;

  if (initial.isArray() && n == 1) {
    // special case: a single array parameter
    // Create an empty document as start point
    builder.openObject();
    builder.close();
    // merge in all other arguments
    for (auto const& it : VPackArrayIterator(initialSlice)) {
      if (!it.isObject()) {
        RegisterInvalidArgumentWarning(query, funcName);
        return AqlValue(AqlValueHintNull());
      }
      builder = arangodb::basics::VelocyPackHelper::merge(builder.slice(), it,
                                                          false, recursive);
    }
    return AqlValue(builder);
  }

  if (!initial.isObject()) {
    RegisterInvalidArgumentWarning(query, funcName);
    return AqlValue(AqlValueHintNull());
  }

  // merge in all other arguments
  for (size_t i = 1; i < n; ++i) {
    AqlValue param = ExtractFunctionParameterValue(parameters, i);

    if (!param.isObject()) {
      RegisterInvalidArgumentWarning(query, funcName);
      return AqlValue(AqlValueHintNull());
    }

    AqlValueMaterializer materializer(trx);
    VPackSlice slice = materializer.slice(param, false);

    builder = arangodb::basics::VelocyPackHelper::merge(initialSlice, slice,
                                                        false, recursive);
    initialSlice = builder.slice();
  }
  if (n == 1) {
    // only one parameter. now add original document
    builder.add(initialSlice);
  }
  return AqlValue(builder);
}

/// @brief internal recursive flatten helper
static void FlattenList(VPackSlice const& array, size_t maxDepth,
                        size_t curDepth, VPackBuilder& result) {
  TRI_ASSERT(result.isOpenArray());
  for (auto const& tmp : VPackArrayIterator(array)) {
    if (tmp.isArray() && curDepth < maxDepth) {
      FlattenList(tmp, maxDepth, curDepth + 1, result);
    } else {
      // Copy the content of tmp into the result
      result.add(tmp);
    }
  }
}

/// @brief function IS_NULL
AqlValue Functions::IsNull(arangodb::aql::Query* query,
                           transaction::Methods* trx,
                           VPackFunctionParameters const& parameters) {
  AqlValue a = ExtractFunctionParameterValue(parameters, 0);
  return AqlValue(AqlValueHintBool(a.isNull(true)));
}

/// @brief function IS_BOOL
AqlValue Functions::IsBool(arangodb::aql::Query* query,
                           transaction::Methods* trx,
                           VPackFunctionParameters const& parameters) {
  AqlValue a = ExtractFunctionParameterValue(parameters, 0);
  return AqlValue(AqlValueHintBool(a.isBoolean()));
}

/// @brief function IS_NUMBER
AqlValue Functions::IsNumber(arangodb::aql::Query* query,
                             transaction::Methods* trx,
                             VPackFunctionParameters const& parameters) {
  AqlValue a = ExtractFunctionParameterValue(parameters, 0);
  return AqlValue(AqlValueHintBool(a.isNumber()));
}

/// @brief function IS_STRING
AqlValue Functions::IsString(arangodb::aql::Query* query,
                             transaction::Methods* trx,
                             VPackFunctionParameters const& parameters) {
  AqlValue a = ExtractFunctionParameterValue(parameters, 0);
  return AqlValue(AqlValueHintBool(a.isString()));
}

/// @brief function IS_ARRAY
AqlValue Functions::IsArray(arangodb::aql::Query* query,
                            transaction::Methods* trx,
                            VPackFunctionParameters const& parameters) {
  AqlValue a = ExtractFunctionParameterValue(parameters, 0);
  return AqlValue(AqlValueHintBool(a.isArray()));
}

/// @brief function IS_OBJECT
AqlValue Functions::IsObject(arangodb::aql::Query* query,
                             transaction::Methods* trx,
                             VPackFunctionParameters const& parameters) {
  AqlValue a = ExtractFunctionParameterValue(parameters, 0);
  return AqlValue(AqlValueHintBool(a.isObject()));
}

/// @brief function TYPENAME
AqlValue Functions::Typename(arangodb::aql::Query* query,
                             transaction::Methods* trx,
                             VPackFunctionParameters const& parameters) {
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  char const* type = value.getTypeString();

  return AqlValue(TRI_CHAR_LENGTH_PAIR(type));
}

/// @brief function TO_NUMBER
AqlValue Functions::ToNumber(arangodb::aql::Query* query,
                             transaction::Methods* trx,
                             VPackFunctionParameters const& parameters) {
  AqlValue a = ExtractFunctionParameterValue(parameters, 0);
  bool failed;
  double value = a.toDouble(trx, failed);

  if (failed) {
    return AqlValue(AqlValueHintZero());
  }

  return AqlValue(AqlValueHintDouble(value));
}

/// @brief function TO_STRING
AqlValue Functions::ToString(arangodb::aql::Query* query,
                             transaction::Methods* trx,
                             VPackFunctionParameters const& parameters) {
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

  AppendAsString(trx, adapter, value);
  return AqlValue(buffer->begin(), buffer->length());
}

/// @brief function TO_BOOL
AqlValue Functions::ToBool(arangodb::aql::Query* query,
                           transaction::Methods* trx,
                           VPackFunctionParameters const& parameters) {
  AqlValue a = ExtractFunctionParameterValue(parameters, 0);
  return AqlValue(AqlValueHintBool(a.toBoolean()));
}

/// @brief function TO_ARRAY
AqlValue Functions::ToArray(arangodb::aql::Query* query,
                            transaction::Methods* trx,
                            VPackFunctionParameters const& parameters) {
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  if (value.isArray()) {
    // return copy of the original array
    return value.clone();
  }

  if (value.isNull(true)) {
    return AqlValue(arangodb::basics::VelocyPackHelper::EmptyArrayValue());
  }

  transaction::BuilderLeaser builder(trx);
  builder->openArray();
  if (value.isBoolean() || value.isNumber() || value.isString()) {
    // return array with single member
    builder->add(value.slice());
  } else if (value.isObject()) {
    AqlValueMaterializer materializer(trx);
    VPackSlice slice = materializer.slice(value, false);
    // return an array with the attribute values
    for (auto const& it : VPackObjectIterator(slice, true)) {
      if (it.value.isCustom()) {
        builder->add(VPackValue(trx->extractIdString(slice)));
      } else {
        builder->add(it.value);
      }
    }
  }
  builder->close();
  return AqlValue(builder.get());
}

/// @brief function LENGTH
AqlValue Functions::Length(arangodb::aql::Query* query,
                           transaction::Methods* trx,
                           VPackFunctionParameters const& parameters) {
  static char const* AFN = "LENGTH";
  ValidateParameters(parameters, AFN, 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  if (value.isArray()) {
    // shortcut!
    return AqlValue(AqlValueHintUInt(value.length()));
  }

  size_t length = 0;
  if (value.isNull(true)) {
    length = 0;
  } else if (value.isBoolean()) {
    if (value.toBoolean()) {
      length = 1;
    } else {
      length = 0;
    }
  } else if (value.isNumber()) {
    double tmp = value.toDouble(trx);
    if (std::isnan(tmp) || !std::isfinite(tmp)) {
      length = 0;
    } else {
      char buffer[24];
      length = static_cast<size_t>(fpconv_dtoa(tmp, buffer));
    }
  } else if (value.isString()) {
    VPackValueLength l;
    char const* p = value.slice().getString(l);
    length = TRI_CharLengthUtf8String(p, l);
  } else if (value.isObject()) {
    length = static_cast<size_t>(value.length());
  }

  return AqlValue(AqlValueHintUInt(length));
}

/// @brief function FIND_FIRST
/// FIND_FIRST(text, search, start, end) → position
AqlValue Functions::FindFirst(arangodb::aql::Query* query,
                              transaction::Methods* trx,
                              VPackFunctionParameters const& parameters) {
  static char const* AFN = "FIND_FIRST";
  ValidateParameters(parameters, AFN, 2, 4);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  AqlValue searchValue = ExtractFunctionParameterValue(parameters, 1);

  transaction::StringBufferLeaser buf1(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buf1->stringBuffer());
  AppendAsString(trx, adapter, value);
  UnicodeString uBuf(buf1->c_str(), static_cast<int32_t>(buf1->length()));

  transaction::StringBufferLeaser buf2(trx);
  arangodb::basics::VPackStringBufferAdapter adapter2(buf2->stringBuffer());
  AppendAsString(trx, adapter2, searchValue);
  UnicodeString uSearchBuf(buf2->c_str(), static_cast<int32_t>(buf2->length()));
  auto searchLen = uSearchBuf.length();

  int64_t startOffset = 0;
  int64_t maxEnd = -1;

  if (parameters.size() >= 3) {
    AqlValue optionalStartOffset = ExtractFunctionParameterValue(parameters, 2);
    startOffset = optionalStartOffset.toInt64(trx);
    if (startOffset < 0) {
      return AqlValue(AqlValueHintInt(-1));
    }
  }

  maxEnd = uBuf.length();
  if (parameters.size() == 4) {
    AqlValue optionalEndMax = ExtractFunctionParameterValue(parameters, 3);
    if (!optionalEndMax.isNull(true)) {
      maxEnd = optionalEndMax.toInt64(trx);
      if ((maxEnd < startOffset) || (maxEnd < 0)) {
        return AqlValue(AqlValueHintInt(-1));
      }
    }
  }

  if (searchLen == 0) {
    return AqlValue(AqlValueHintInt(startOffset));
  }
  if (uBuf.length() == 0) {
    return AqlValue(AqlValueHintInt(-1));
  }

  auto locale = LanguageFeature::instance()->getLocale();
  UErrorCode status = U_ZERO_ERROR;
  StringSearch search(uSearchBuf, uBuf, locale, NULL, status);

  for(int pos = search.first(status);
      U_SUCCESS(status) && pos != USEARCH_DONE;
      pos = search.next(status)) {
    if (U_FAILURE(status)) {
      RegisterICUWarning(query, AFN, status);
      return AqlValue(AqlValueHintNull());
    }
    if ((pos >= startOffset) && ((pos + searchLen - 1) <= maxEnd)) {
      return AqlValue(AqlValueHintInt(pos));
    }
  }
  return AqlValue(AqlValueHintInt(-1));
}

/// @brief function FIND_LAST
/// FIND_FIRST(text, search, start, end) → position
AqlValue Functions::FindLast(arangodb::aql::Query* query,
                             transaction::Methods* trx,
                             VPackFunctionParameters const& parameters) {
  static char const* AFN = "FIND_LAST";
  ValidateParameters(parameters, AFN, 2, 4);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  AqlValue searchValue = ExtractFunctionParameterValue(parameters, 1);

  transaction::StringBufferLeaser buf1(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buf1->stringBuffer());
  AppendAsString(trx, adapter, value);
  UnicodeString uBuf(buf1->c_str(), static_cast<int32_t>(buf1->length()));

  transaction::StringBufferLeaser buf2(trx);
  arangodb::basics::VPackStringBufferAdapter adapter2(buf2->stringBuffer());
  AppendAsString(trx, adapter2, searchValue);
  UnicodeString uSearchBuf(buf2->c_str(), static_cast<int32_t>(buf2->length()));
  auto searchLen = uSearchBuf.length();

  int64_t startOffset = 0;
  int64_t maxEnd = -1;

  if (parameters.size() >= 3) {
    AqlValue optionalStartOffset = ExtractFunctionParameterValue(parameters, 2);
    startOffset = optionalStartOffset.toInt64(trx);
    if (startOffset < 0) {
      return AqlValue(AqlValueHintInt(-1));
    }
  }

  maxEnd = uBuf.length();
  int emptySearchCludge = 0;
  if (parameters.size() == 4) {
    AqlValue optionalEndMax = ExtractFunctionParameterValue(parameters, 3);
    if (!optionalEndMax.isNull(true)) {
      maxEnd = optionalEndMax.toInt64(trx);
      if ((maxEnd < startOffset) || (maxEnd < 0)) {
        return AqlValue(AqlValueHintInt(-1));
      }
      emptySearchCludge = 1;
    }
  }

  if (searchLen == 0) {
    return AqlValue(AqlValueHintInt(maxEnd + emptySearchCludge));
  }
  if (uBuf.length() == 0) {
    return AqlValue(AqlValueHintInt(-1));
  }

  auto locale = LanguageFeature::instance()->getLocale();
  UErrorCode status = U_ZERO_ERROR;
  StringSearch search(uSearchBuf, uBuf, locale, NULL, status);

  int foundPos = -1;
  for(int pos = search.first(status);
      U_SUCCESS(status) && pos != USEARCH_DONE;
      pos = search.next(status)) {
    if (U_FAILURE(status)) {
      RegisterICUWarning(query, AFN, status);
      return AqlValue(AqlValueHintNull());
    }
    if ((pos >= startOffset) && ((pos + searchLen - 1) <= maxEnd)) {
      foundPos = pos;
    }
  }
  return AqlValue(AqlValueHintInt(foundPos));
}

/// @brief function REVERSE
AqlValue Functions::Reverse(arangodb::aql::Query* query,
                            transaction::Methods* trx,
                            VPackFunctionParameters const& parameters) {
  static char const* AFN = "REVERSE";
  ValidateParameters(parameters, AFN, 1, 1);
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  if (value.isArray()) {
    transaction::BuilderLeaser builder(trx);
    AqlValueMaterializer materializer(trx);
    VPackSlice slice = materializer.slice(value, false);
    std::vector<VPackSlice> array;
    array.reserve(slice.length());
    for (auto const& it : VPackArrayIterator(slice)) {
      array.push_back(it);
    }
    std::reverse(std::begin(array), std::end(array));
    
    builder->openArray();
    for (auto const &it : array) {
      builder->add(it);
    }
    builder->close();
    return AqlValue(builder.get());
  }
  else if (value.isString()) {
    std::string utf8;
    transaction::StringBufferLeaser buf1(trx);
    arangodb::basics::VPackStringBufferAdapter adapter(buf1->stringBuffer());
    AppendAsString(trx, adapter, value);
    UnicodeString uBuf(buf1->c_str(), static_cast<int32_t>(buf1->length()));
    // reserve the result buffer, but need to set empty afterwards:
    UnicodeString result;
    result.getBuffer(uBuf.length());
    result = "";
    StringCharacterIterator iter(uBuf, uBuf.length());
    UChar c = iter.previous();
    while (c != CharacterIterator::DONE) {
      result.append(c);
      c = iter.previous();
    }
    result.toUTF8String(utf8);

    return AqlValue(utf8);
  }
  else {
    // neither array nor string...
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_ARRAY_EXPECTED);
    return AqlValue(AqlValueHintNull());
  }
}

/// @brief function FIRST
AqlValue Functions::First(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  static char const* AFN = "FIRST";
  ValidateParameters(parameters, AFN, 1, 1);
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  if (!value.isArray()) {
    // not an array
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_ARRAY_EXPECTED);
    return AqlValue(AqlValueHintNull());
  }

  if (value.length() == 0) {
    return AqlValue(AqlValueHintNull());
  }

  bool mustDestroy;
  return value.at(trx, 0, mustDestroy, true);
}

/// @brief function LAST
AqlValue Functions::Last(arangodb::aql::Query* query,
                         transaction::Methods* trx,
                         VPackFunctionParameters const& parameters) {
  static char const* AFN = "LAST";
  ValidateParameters(parameters, AFN, 1, 1);
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  if (!value.isArray()) {
    // not an array
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_ARRAY_EXPECTED);
    return AqlValue(AqlValueHintNull());
  }

  VPackValueLength const n = value.length();

  if (n == 0) {
    return AqlValue(AqlValueHintNull());
  }

  bool mustDestroy;
  return value.at(trx, n - 1, mustDestroy, true);
}

/// @brief function NTH
AqlValue Functions::Nth(arangodb::aql::Query* query, transaction::Methods* trx,
                        VPackFunctionParameters const& parameters) {
  static char const* AFN = "NTH";
  ValidateParameters(parameters, AFN, 2, 2);
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  if (!value.isArray()) {
    // not an array
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_ARRAY_EXPECTED);
    return AqlValue(AqlValueHintNull());
  }

  VPackValueLength const n = value.length();

  if (n == 0) {
    return AqlValue(AqlValueHintNull());
  }

  AqlValue position = ExtractFunctionParameterValue(parameters, 1);
  int64_t index = position.toInt64(trx);

  if (index < 0 || index >= static_cast<int64_t>(n)) {
    return AqlValue(AqlValueHintNull());
  }

  bool mustDestroy;
  return value.at(trx, index, mustDestroy, true);
}

/// @brief function CONTAINS
AqlValue Functions::Contains(arangodb::aql::Query* query,
                             transaction::Methods* trx,
                             VPackFunctionParameters const& parameters) {
  static char const* AFN = "CONTAINS";
  ValidateParameters(parameters, AFN, 2, 3);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  AqlValue search = ExtractFunctionParameterValue(parameters, 1);
  AqlValue returnIndex = ExtractFunctionParameterValue(parameters, 2);

  bool const willReturnIndex = returnIndex.toBoolean();

  int result = -1;  // default is "not found"
  {
    transaction::StringBufferLeaser buffer(trx);
    arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

    AppendAsString(trx, adapter, value);
    size_t const valueLength = buffer->length();

    size_t const searchOffset = buffer->length();
    AppendAsString(trx, adapter, search);
    size_t const searchLength = buffer->length() - valueLength;

    if (searchLength > 0) {
      char const* found = static_cast<char const*>(
          memmem(buffer->c_str(), valueLength, buffer->c_str() + searchOffset,
                 searchLength));

      if (found != nullptr) {
        if (willReturnIndex) {
          // find offset into string
          int bytePosition = static_cast<int>(found - buffer->c_str());
          char const* p = buffer->c_str();
          int pos = 0;
          while (pos < bytePosition) {
            unsigned char c = static_cast<unsigned char>(*p);
            if (c < 128) {
              ++pos;
            } else if (c < 224) {
              pos += 2;
            } else if (c < 240) {
              pos += 3;
            } else if (c < 248) {
              pos += 4;
            }
          }
          result = pos;
        } else {
          // fake result position, but it does not matter as it will
          // only be compared to -1 later
          result = 0;
        }
      }
    }
  }

  if (willReturnIndex) {
    // return numeric value
    return NumberValue(trx, result);
  }

  // return boolean
  return AqlValue(AqlValueHintBool(result != -1));
}

/// @brief function CONCAT
AqlValue Functions::Concat(arangodb::aql::Query* query,
                           transaction::Methods* trx,
                           VPackFunctionParameters const& parameters) {
  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

  size_t const n = parameters.size();

  if (n == 1) {
    AqlValue member = ExtractFunctionParameterValue(parameters, 0);
    if (member.isArray()) {
      AqlValueMaterializer materializer(trx);
      VPackSlice slice = materializer.slice(member, false);

      for (auto const& it : VPackArrayIterator(slice)) {
        if (it.isNull()) {
          continue;
        }
        // convert member to a string and append
        AppendAsString(trx, adapter, AqlValue(it.begin()));
      }
      return AqlValue(buffer->c_str(), buffer->length());
    }
  }

  for (size_t i = 0; i < n; ++i) {
    AqlValue member = ExtractFunctionParameterValue(parameters, i);

    if (member.isNull(true)) {
      continue;
    }

    // convert member to a string and append
    AppendAsString(trx, adapter, member);
  }

  return AqlValue(buffer->c_str(), buffer->length());
}

/// @brief function CONCAT_SEPARATOR
AqlValue Functions::ConcatSeparator(arangodb::aql::Query* query,
                                    transaction::Methods* trx,
                                    VPackFunctionParameters const& parameters) {
  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

  bool found = false;
  size_t const n = parameters.size();

  AqlValue separator = ExtractFunctionParameterValue(parameters, 0);
  AppendAsString(trx, adapter, separator);
  std::string const plainStr(buffer->c_str(), buffer->length());

  buffer->clear();

  if (n == 2) {
    AqlValue member = ExtractFunctionParameterValue(parameters, 1);

    if (member.isArray()) {
      // reserve *some* space
      buffer->reserve((plainStr.size() + 10) * member.length());

      AqlValueMaterializer materializer(trx);
      VPackSlice slice = materializer.slice(member, false);

      for (auto const& it : VPackArrayIterator(slice)) {
        if (it.isNull()) {
          continue;
        }
        if (found) {
          buffer->appendText(plainStr);
        }
        // convert member to a string and append
        AppendAsString(trx, adapter, AqlValue(it.begin()));
        found = true;
      }
      return AqlValue(buffer->c_str(), buffer->length());
    }
  }

  // reserve *some* space
  buffer->reserve((plainStr.size() + 10) * n);
  for (size_t i = 1; i < n; ++i) {
    AqlValue member = ExtractFunctionParameterValue(parameters, i);

    if (member.isNull(true)) {
      continue;
    }
    if (found) {
      buffer->appendText(plainStr);
    }

    // convert member to a string and append
    AppendAsString(trx, adapter, member);
    found = true;
  }

  return AqlValue(buffer->c_str(), buffer->length());
}

/// @brief function CHAR_LENGTH
AqlValue Functions::CharLength(arangodb::aql::Query* query,
                               transaction::Methods* trx,
                               VPackFunctionParameters const& parameters) {
  static char const* AFN = "CHAR_LENGTH";
  ValidateParameters(parameters, AFN, 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  size_t length = 0;

  if (value.isArray() || value.isObject()) {
    AqlValueMaterializer materializer(trx);
    VPackSlice slice = materializer.slice(value, false);

    transaction::StringBufferLeaser buffer(trx);
    arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

    VPackDumper dumper(&adapter,
                       trx->transactionContextPtr()->getVPackOptions());
    dumper.dump(slice);

    length = buffer->length();

  } else if (value.isNull(true)) {
    length = 0;

  } else if (value.isBoolean()) {
    if (value.toBoolean()) {
      length = 4;
    } else {
      length = 5;
    }

  } else if (value.isNumber()) {
    double tmp = value.toDouble(trx);
    if (std::isnan(tmp) || !std::isfinite(tmp)) {
      length = 0;
    } else {
      char buffer[24];
      length = static_cast<size_t>(fpconv_dtoa(tmp, buffer));
    }

  } else if (value.isString()) {
    VPackValueLength l;
    char const* p = value.slice().getString(l);
    length = TRI_CharLengthUtf8String(p, l);
  }

  return AqlValue(AqlValueHintUInt(length));
}

/// @brief function LOWER
AqlValue Functions::Lower(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  static char const* AFN = "LOWER";
  ValidateParameters(parameters, AFN, 1, 1);

  std::string utf8;
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

  AppendAsString(trx, adapter, value);

  UnicodeString unicodeStr(buffer->c_str(),
                           static_cast<int32_t>(buffer->length()));
  unicodeStr.toLower(NULL);
  unicodeStr.toUTF8String(utf8);

  return AqlValue(utf8);
}

/// @brief function UPPER
AqlValue Functions::Upper(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  static char const* AFN = "UPPER";
  ValidateParameters(parameters, AFN, 1, 1);

  std::string utf8;
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

  AppendAsString(trx, adapter, value);

  UnicodeString unicodeStr(buffer->c_str(),
                           static_cast<int32_t>(buffer->length()));
  unicodeStr.toUpper(NULL);
  unicodeStr.toUTF8String(utf8);

  return AqlValue(utf8);
}

/// @brief function SUBSTRING
AqlValue Functions::Substring(arangodb::aql::Query* query,
                              transaction::Methods* trx,
                              VPackFunctionParameters const& parameters) {
  static char const* AFN = "SUBSTRING";
  ValidateParameters(parameters, AFN, 2, 3);
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  int32_t length = INT32_MAX;

  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

  AppendAsString(trx, adapter, value);
  UnicodeString unicodeStr(buffer->c_str(),
                           static_cast<int32_t>(buffer->length()));

  int32_t offset = static_cast<int32_t>(
      ExtractFunctionParameterValue(parameters, 1).toInt64(trx));

  if (parameters.size() == 3) {
    length = static_cast<int32_t>(
        ExtractFunctionParameterValue(parameters, 2).toInt64(trx));
  }

  if (offset < 0) {
    offset = unicodeStr.moveIndex32(
        unicodeStr.moveIndex32(unicodeStr.length(), 0), offset);
  } else {
    offset = unicodeStr.moveIndex32(0, offset);
  }

  std::string utf8;
  unicodeStr
      .tempSubString(offset, unicodeStr.moveIndex32(offset, length) - offset)
      .toUTF8String(utf8);

  return AqlValue(utf8);
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

AqlValue Functions::Substitute(arangodb::aql::Query* query,
                               transaction::Methods* trx,
                               VPackFunctionParameters const& parameters) {
  static char const* AFN = "SUBSTITUTE";
  ValidateParameters(parameters, AFN, 2, 4);

  AqlValue search = ExtractFunctionParameterValue(parameters, 1);
  int64_t limit = -1;
  AqlValueMaterializer materializer(trx);
  std::vector<UnicodeString> matchPatterns;
  std::vector<UnicodeString> replacePatterns;
  bool replaceWasPlainString = false;
  
  if (search.isObject()) {
    if (parameters.size() > 3) {
      RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH);
      return AqlValue(AqlValueHintNull());
    }
    if (parameters.size() == 3) {
      limit = ExtractFunctionParameterValue(parameters, 2).toInt64(trx);
    }
    VPackSlice slice = materializer.slice(search, false);
    matchPatterns.reserve(slice.length());
    replacePatterns.reserve(slice.length());
    for (auto const& it : VPackObjectIterator(slice)) {
      arangodb::velocypack::ValueLength length;
      const char *str = it.key.getString(length);
      matchPatterns.push_back(UnicodeString(str, length));
      if (!it.value.isString()) {
        RegisterInvalidArgumentWarning(query, AFN);
        return AqlValue(AqlValueHintNull());
      }
      str = it.value.getString(length);
      replacePatterns.push_back(UnicodeString(str, length));
    }
  }
  else {
    if (parameters.size() < 2) {
      RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH);
      return AqlValue(AqlValueHintNull());
    }
    if (parameters.size() == 4) {
      limit = ExtractFunctionParameterValue(parameters, 3).toInt64(trx);
    }
    
    VPackSlice slice = materializer.slice(search, false);
    if (search.isArray()) {
      for (auto const& it : VPackArrayIterator(slice)) {
        if (!it.isString()) {
          RegisterInvalidArgumentWarning(query, AFN);
          return AqlValue(AqlValueHintNull());
        }
        arangodb::velocypack::ValueLength length;
        const char *str = it.getString(length);
        matchPatterns.push_back(UnicodeString(str, length));
      }
    }
    else {
      if (!search.isString()) {
        RegisterInvalidArgumentWarning(query, AFN);
        return AqlValue(AqlValueHintNull());
      }
      arangodb::velocypack::ValueLength length;
      const char *str = slice.getString(length);
      matchPatterns.push_back(UnicodeString(str, length));
    }
    if (parameters.size() > 2) {
      AqlValue replace = ExtractFunctionParameterValue(parameters, 2);
      VPackSlice rslice = materializer.slice(replace, false);
      if (replace.isArray()) {
        for (auto const& it : VPackArrayIterator(rslice)) {
          if (!it.isString()) {
            RegisterInvalidArgumentWarning(query, AFN);
            return AqlValue(AqlValueHintNull());
          }
          arangodb::velocypack::ValueLength length;
          const char *str = it.getString(length);
          replacePatterns.push_back(UnicodeString(str, length));
        }
      }
      else if (replace.isString()) {
        // If we have a string as replacement,
        // it counts in for all found values.
        replaceWasPlainString = true;
        arangodb::velocypack::ValueLength length;
        const char *str = rslice.getString(length);
        replacePatterns.push_back(UnicodeString(str, length));
      }
      else {
        RegisterInvalidArgumentWarning(query, AFN);
        return AqlValue(AqlValueHintNull());
      }
    }
  }

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  if ((limit == 0) || (matchPatterns.size() == 0)) {
    // if the limit is 0, or we don't have any match pattern, return the source string.
    return AqlValue(value);
  }

  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

  AppendAsString(trx, adapter, value);
  UnicodeString unicodeStr(buffer->c_str(), static_cast<int32_t>(buffer->length()));

  auto locale = LanguageFeature::instance()->getLocale();
  // we can't copy the search instances, thus use pointers:
  std::vector<std::unique_ptr<StringSearch>> searchVec;
  searchVec.reserve(matchPatterns.size());
  UErrorCode status = U_ZERO_ERROR;
  for (auto const& searchStr : matchPatterns) {
    // create a vector of string searches
    searchVec.push_back(std::make_unique<StringSearch>(searchStr, unicodeStr, locale, nullptr, status));
    if (U_FAILURE(status)) {
      RegisterICUWarning(query, AFN, status);
      return AqlValue(AqlValueHintNull());
    }
  }
  
  std::vector<std::pair<int32_t, int32_t>> srchResultPtrs;
  std::string utf8;
  srchResultPtrs.reserve(matchPatterns.size());
  for (auto& search : searchVec) {
    // We now find the first hit for each search string. 
    auto pos = search->first(status);
    if (U_FAILURE(status)) {
      RegisterICUWarning(query, AFN, status);
      return AqlValue(AqlValueHintNull());
    }

    int32_t len = 0;
    if (pos != USEARCH_DONE) {
      len = search->getMatchedLength();
    }
    srchResultPtrs.push_back(std::make_pair(pos, len));
  }

  UnicodeString result;  
  int32_t lastStart = 0;
  int64_t count = 0;
  while (true) {
    int which = -1;
    int32_t pos = USEARCH_DONE;
    int32_t mLen = 0;
    int i = 0;
    for (auto resultPair : srchResultPtrs) {
      // We locate the nearest matching search result.
      int32_t thisPos;
      thisPos = resultPair.first;
      if ((pos == USEARCH_DONE) || (pos > thisPos)) {
        if (thisPos != USEARCH_DONE) {
          pos = thisPos;
          which = i;
          mLen = resultPair.second;
        }
      }
      i++;
    }
    if (which == -1) {
      break;
    }
    // from last match to this match, copy the original string.
    result.append(unicodeStr, lastStart, pos - lastStart);
    if (replacePatterns.size() != 0) {
      if (replacePatterns.size() > (size_t) which) {
        result.append(replacePatterns[which]);
      }
      else if (replaceWasPlainString) {
        result.append(replacePatterns[0]);
      }
    }
    
    // lastStart is the place up to we searched the source string 
    lastStart = pos + mLen;

    // we try to search the next occurance of this string
    auto& search = searchVec[which];
    pos = search->next(status);
    if (U_FAILURE(status)) {
      RegisterICUWarning(query, AFN, status);
      return AqlValue(AqlValueHintNull());
    }
    if (pos != USEARCH_DONE) {
      mLen = search->getMatchedLength();
    }
    else {
      mLen = -1;
    }
    srchResultPtrs[which] = std::make_pair(pos, mLen);

    which = 0;
    for (auto searchPair : srchResultPtrs) {
      // now we invalidate all search results that overlap with
      // our last search result and see whether we can find the
      // overlapped pattern again.
      // However, that mustn't overlap with the current lastStart
      // position either.
      int32_t thisPos;
      thisPos = searchPair.first;
      if ((thisPos != USEARCH_DONE) && (thisPos < lastStart)) {
        auto &search = searchVec[which];
        pos = thisPos;
        while ((pos < lastStart) && (pos != USEARCH_DONE)) {
          pos = search->next(status);
          if (U_FAILURE(status)) {
            RegisterICUWarning(query, AFN, status);
            return AqlValue(AqlValueHintNull());
          }
          if (pos != USEARCH_DONE) {
            mLen = search->getMatchedLength();
          }
          srchResultPtrs[which] = std::make_pair(pos, mLen);
        }
      }
      which++;
    }
    
    count ++;
    if ((limit != -1) && (count >= limit)) {
      // Do we have a limit count?
      break;
    }
    // check whether none of our search objects has any more results
    bool allFound = true;
    for (auto resultPair : srchResultPtrs) {
      if (resultPair.first != USEARCH_DONE) {
        allFound = false;
        break;
      }
    }
    if (allFound) {
      break;
    }
  }
  // Append from the last found:
  result.append(unicodeStr, lastStart, unicodeStr.length() - lastStart);
  
  result.toUTF8String(utf8);
  return AqlValue(utf8);
}

/// @brief function LEFT str, length
AqlValue Functions::Left(arangodb::aql::Query* query, transaction::Methods* trx,
                         VPackFunctionParameters const& parameters) {
  static char const* AFN = "LEFT";
  ValidateParameters(parameters, AFN, 2, 2);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  uint32_t length = static_cast<int32_t>(
      ExtractFunctionParameterValue(parameters, 1).toInt64(trx));

  std::string utf8;
  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

  AppendAsString(trx, adapter, value);

  UnicodeString unicodeStr(buffer->c_str(),
                           static_cast<int32_t>(buffer->length()));
  UnicodeString left =
      unicodeStr.tempSubString(0, unicodeStr.moveIndex32(0, length));

  left.toUTF8String(utf8);
  return AqlValue(utf8);
}

/// @brief function RIGHT
AqlValue Functions::Right(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "RIGHT", 2, 2);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  uint32_t length = static_cast<int32_t>(
      ExtractFunctionParameterValue(parameters, 1).toInt64(trx));

  std::string utf8;
  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

  AppendAsString(trx, adapter, value);

  UnicodeString unicodeStr(buffer->c_str(),
                           static_cast<int32_t>(buffer->length()));
  UnicodeString right = unicodeStr.tempSubString(unicodeStr.moveIndex32(
      unicodeStr.length(), -static_cast<int32_t>(length)));

  right.toUTF8String(utf8);
  return AqlValue(utf8);
}

namespace {
void ltrimInternal(uint32_t& startOffset, uint32_t& endOffset,
                   UnicodeString& unicodeStr, uint32_t numWhitespaces,
                   UChar32* spaceChars) {
  for (; startOffset < endOffset;
       startOffset = unicodeStr.moveIndex32(startOffset, 1)) {
    bool found = false;

    for (uint32_t pos = 0; pos < numWhitespaces; pos++) {
      if (unicodeStr.char32At(startOffset) == spaceChars[pos]) {
        found = true;
        break;
      }
    }

    if (!found) {
      break;
    }
  }  // for
}
void rtrimInternal(uint32_t& startOffset, uint32_t& endOffset,
                   UnicodeString& unicodeStr, uint32_t numWhitespaces,
                   UChar32* spaceChars) {
  for (uint32_t codeUnitPos = unicodeStr.moveIndex32(unicodeStr.length(), -1);
       startOffset < codeUnitPos;
       codeUnitPos = unicodeStr.moveIndex32(codeUnitPos, -1)) {
    bool found = false;

    for (uint32_t pos = 0; pos < numWhitespaces; pos++) {
      if (unicodeStr.char32At(codeUnitPos) == spaceChars[pos]) {
        found = true;
        break;
      }
    }

    endOffset = unicodeStr.moveIndex32(codeUnitPos, 1);
    if (!found) {
      break;
    }
  }  // for
}
}

/// @brief function TRIM
AqlValue Functions::Trim(arangodb::aql::Query* query, transaction::Methods* trx,
                         VPackFunctionParameters const& parameters) {
  static char const* AFN = "TRIM";
  ValidateParameters(parameters, AFN, 1, 2);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());
  AppendAsString(trx, adapter, value);
  UnicodeString unicodeStr(buffer->c_str(),
                           static_cast<int32_t>(buffer->length()));

  int64_t howToTrim = 0;
  UnicodeString whitespace("\r\n\t ");

  if (parameters.size() == 2) {
    AqlValue optional = ExtractFunctionParameterValue(parameters, 1);

    if (optional.isNumber()) {
      howToTrim = optional.toInt64(trx);

      if (howToTrim < 0 || 2 < howToTrim) {
        howToTrim = 0;
      }
    } else if (optional.isString()) {
      buffer->clear();
      AppendAsString(trx, adapter, optional);
      whitespace = UnicodeString(buffer->c_str(),
                                 static_cast<int32_t>(buffer->length()));
    }
  }

  uint32_t numWhitespaces = whitespace.countChar32();
  UErrorCode errorCode = U_ZERO_ERROR;
  auto spaceChars = std::make_unique<UChar32[]>(numWhitespaces);

  whitespace.toUTF32(spaceChars.get(), numWhitespaces, errorCode);
  if (U_FAILURE(errorCode)) {
    RegisterICUWarning(query, AFN, errorCode);
    return AqlValue(AqlValueHintNull());
  }

  uint32_t startOffset = 0, endOffset = unicodeStr.length();

  if (howToTrim <= 1) {
    ltrimInternal(startOffset, endOffset, unicodeStr, numWhitespaces,
                  spaceChars.get());
  }

  if (howToTrim == 2 || howToTrim == 0) {
    rtrimInternal(startOffset, endOffset, unicodeStr, numWhitespaces,
                  spaceChars.get());
  }

  UnicodeString result =
      unicodeStr.tempSubString(startOffset, endOffset - startOffset);
  std::string utf8;
  result.toUTF8String(utf8);
  return AqlValue(utf8);
}

/// @brief function LTRIM
AqlValue Functions::LTrim(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  static char const* AFN = "LTRIM";
  ValidateParameters(parameters, AFN, 1, 2);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());
  AppendAsString(trx, adapter, value);
  UnicodeString unicodeStr(buffer->c_str(),
                           static_cast<int32_t>(buffer->length()));
  UnicodeString whitespace("\r\n\t ");

  if (parameters.size() == 2) {
    AqlValue pWhitespace = ExtractFunctionParameterValue(parameters, 1);
    buffer->clear();
    AppendAsString(trx, adapter, pWhitespace);
    whitespace =
        UnicodeString(buffer->c_str(), static_cast<int32_t>(buffer->length()));
  }

  uint32_t numWhitespaces = whitespace.countChar32();
  UErrorCode errorCode = U_ZERO_ERROR;
  auto spaceChars = std::make_unique<UChar32[]>(numWhitespaces);

  whitespace.toUTF32(spaceChars.get(), numWhitespaces, errorCode);
  if (U_FAILURE(errorCode)) {
    RegisterICUWarning(query, AFN, errorCode);
    return AqlValue(AqlValueHintNull());
  }

  uint32_t startOffset = 0, endOffset = unicodeStr.length();

  ltrimInternal(startOffset, endOffset, unicodeStr, numWhitespaces,
                spaceChars.get());

  UnicodeString result =
      unicodeStr.tempSubString(startOffset, endOffset - startOffset);
  std::string utf8;
  result.toUTF8String(utf8);
  return AqlValue(utf8);
}

/// @brief function RTRIM
AqlValue Functions::RTrim(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  static char const* AFN = "RTRIM";
  ValidateParameters(parameters, AFN, 1, 2);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());
  AppendAsString(trx, adapter, value);
  UnicodeString unicodeStr(buffer->c_str(),
                           static_cast<int32_t>(buffer->length()));
  UnicodeString whitespace("\r\n\t ");

  if (parameters.size() == 2) {
    AqlValue pWhitespace = ExtractFunctionParameterValue(parameters, 1);
    buffer->clear();
    AppendAsString(trx, adapter, pWhitespace);
    whitespace =
        UnicodeString(buffer->c_str(), static_cast<int32_t>(buffer->length()));
  }

  uint32_t numWhitespaces = whitespace.countChar32();
  UErrorCode errorCode = U_ZERO_ERROR;
  auto spaceChars = std::make_unique<UChar32[]>(numWhitespaces);

  whitespace.toUTF32(spaceChars.get(), numWhitespaces, errorCode);
  if (U_FAILURE(errorCode)) {
    RegisterICUWarning(query, AFN, errorCode);
    return AqlValue(AqlValueHintNull());
  }

  uint32_t startOffset = 0, endOffset = unicodeStr.length();

  rtrimInternal(startOffset, endOffset, unicodeStr, numWhitespaces,
                spaceChars.get());

  UnicodeString result =
      unicodeStr.tempSubString(startOffset, endOffset - startOffset);
  std::string utf8;
  result.toUTF8String(utf8);
  return AqlValue(utf8);
}

/// @brief function LIKE
AqlValue Functions::Like(arangodb::aql::Query* query, transaction::Methods* trx,
                         VPackFunctionParameters const& parameters) {
  static char const* AFN = "LIKE";
  ValidateParameters(parameters, AFN, 2, 3);
  bool const caseInsensitive = GetBooleanParameter(trx, parameters, 2, false);
  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

  // build pattern from parameter #1
  AqlValue regex = ExtractFunctionParameterValue(parameters, 1);
  AppendAsString(trx, adapter, regex);

  // the matcher is owned by the query!
  ::RegexMatcher* matcher = query->regexCache()->buildLikeMatcher(
      buffer->c_str(), buffer->length(), caseInsensitive);

  if (matcher == nullptr) {
    // compiling regular expression failed
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_INVALID_REGEX);
    return AqlValue(AqlValueHintNull());
  }

  // extract value
  buffer->clear();
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  AppendAsString(trx, adapter, value);

  bool error = false;
  bool const result = arangodb::basics::Utf8Helper::DefaultUtf8Helper.matches(
      matcher, buffer->c_str(), buffer->length(), false, error);

  if (error) {
    // compiling regular expression failed
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_INVALID_REGEX);
    return AqlValue(AqlValueHintNull());
  }

  return AqlValue(AqlValueHintBool(result));
}

/// @brief function SPLIT
AqlValue Functions::Split(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  static char const* AFN = "SPLIT";
  ValidateParameters(parameters, AFN, 1, 3);

  // cheapest parameter checks first:
  int64_t limitNumber = -1;
  if (parameters.size() == 3) {
    AqlValue aqlLimit = ExtractFunctionParameterValue(parameters, 2);
    if (aqlLimit.isNumber()) {
      limitNumber = aqlLimit.toInt64(trx);
    }
    else {
      RegisterInvalidArgumentWarning(query, AFN);
      return AqlValue(AqlValueHintNull());
    }

    // these are edge cases which are documented to have these return values:
    if (limitNumber < 0) {
      return AqlValue(AqlValueHintNull());
    }
    if (limitNumber == 0) {
      return AqlValue(VPackSlice::emptyArraySlice());
    }
  }

  transaction::StringBufferLeaser regexBuffer(trx);
  AqlValue aqlSeparatorExpression;
  if (parameters.size() >= 2) {
    aqlSeparatorExpression = ExtractFunctionParameterValue(parameters, 1);
    if (aqlSeparatorExpression.isObject()) {
      RegisterInvalidArgumentWarning(query, AFN);
      return AqlValue(AqlValueHintNull());
    }
  }

  AqlValueMaterializer materializer(trx);
  AqlValue aqlValueToSplit = ExtractFunctionParameterValue(parameters, 0);

  if (parameters.size() == 1) {
    // pre-documented edge-case: if we only have the first parameter, return it.
    VPackBuilder result;
    result.openArray();
    result.add(aqlValueToSplit.slice());
    result.close();
    return AqlValue(result);
  }

   // Get ready for ICU
  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());
  Stringify(trx, adapter, aqlValueToSplit.slice());
  UnicodeString valueToSplit(buffer->c_str(), static_cast<int32_t>(buffer->length()));
  bool isEmptyExpression = false;
  // the matcher is owned by the query!
  ::RegexMatcher* matcher = query->regexCache()->buildSplitMatcher(aqlSeparatorExpression, trx, isEmptyExpression);

  if (matcher == nullptr) {
    // compiling regular expression failed
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_INVALID_REGEX);
    return AqlValue(AqlValueHintNull());
  }

  VPackBuilder result;
  result.openArray();
  if (!isEmptyExpression && (buffer->length() == 0)) {
    // Edge case: splitting an empty string by non-empty expression produces an empty string again.
    result.add(VPackValue(""));
    result.close();
    return AqlValue(result);
  }

  std::string utf8;
  static const uint16_t nrResults = 16;
  UnicodeString uResults[nrResults];
  int64_t totalCount = 0;
  while (true) {
    UErrorCode errorCode = U_ZERO_ERROR;
    auto uCount = matcher->split(valueToSplit, uResults, nrResults, errorCode);
    uint16_t copyThisTime = uCount;
    
    if (U_FAILURE(errorCode)) {
      RegisterWarning(query, AFN, TRI_ERROR_QUERY_INVALID_REGEX);
      return AqlValue(AqlValueHintNull());
    }
    
    if ((copyThisTime > 0) && (copyThisTime > nrResults)) {
      // last hit is the remaining string to be fed into split in a subsequent invocation
      copyThisTime --;
    }
    
    if ((copyThisTime > 0) && ((copyThisTime == nrResults) || isEmptyExpression)) {
      // ICU will give us a traling empty string we don't care for if we split
      // with empty strings.
      copyThisTime --;
    }

    int64_t i = 0;
    while ((i < copyThisTime) &&
           ((limitNumber < 0 ) || (totalCount < limitNumber))) {
      if ((i == 0) && isEmptyExpression) {
        // ICU will give us an empty string that we don't care for
        // as first value of one match-chunk
        i++;
        continue;
      }
      uResults[i].toUTF8String(utf8);
      result.add(VPackValue(utf8));
      utf8.clear();
      i++;
      totalCount++;
    }
           
    if (((uCount != nrResults)) || // fetch any / found less then N
        ((limitNumber >= 0) && (totalCount >= limitNumber))) { // fetch N
      break;
    }
    // ok, we have more to parse in the last result slot, reiterate with it:
    if(uCount == nrResults) {
      valueToSplit = uResults[nrResults - 1];
    }
    else {
      // shoult not go beyound the last match!
      TRI_ASSERT(false);
      break;
    }
  }
  
  result.close();
  return AqlValue(result);
}
/// @brief function REGEX_TEST
AqlValue Functions::RegexTest(arangodb::aql::Query* query,
                              transaction::Methods* trx,
                              VPackFunctionParameters const& parameters) {
  static char const* AFN = "REGEX_TEST";
  ValidateParameters(parameters, AFN, 2, 3);
  bool const caseInsensitive = GetBooleanParameter(trx, parameters, 2, false);
  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

  // build pattern from parameter #1
  AqlValue regex = ExtractFunctionParameterValue(parameters, 1);
  AppendAsString(trx, adapter, regex);

  // the matcher is owned by the query!
  ::RegexMatcher* matcher = query->regexCache()->buildRegexMatcher(
      buffer->c_str(), buffer->length(), caseInsensitive);

  if (matcher == nullptr) {
    // compiling regular expression failed
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_INVALID_REGEX);
    return AqlValue(AqlValueHintNull());
  }

  // extract value
  buffer->clear();
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  AppendAsString(trx, adapter, value);

  bool error = false;
  bool const result = arangodb::basics::Utf8Helper::DefaultUtf8Helper.matches(
      matcher, buffer->c_str(), buffer->length(), true, error);

  if (error) {
    // compiling regular expression failed
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_INVALID_REGEX);
    return AqlValue(AqlValueHintNull());
  }

  return AqlValue(AqlValueHintBool(result));
}

/// @brief function REGEX_REPLACE
AqlValue Functions::RegexReplace(arangodb::aql::Query* query,
                                 transaction::Methods* trx,
                                 VPackFunctionParameters const& parameters) {
  static char const* AFN = "REGEX_REPLACE";
  ValidateParameters(parameters, AFN, 3, 4);
  bool const caseInsensitive = GetBooleanParameter(trx, parameters, 3, false);
  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

  // build pattern from parameter #1
  AqlValue regex = ExtractFunctionParameterValue(parameters, 1);
  AppendAsString(trx, adapter, regex);

  // the matcher is owned by the query!
  ::RegexMatcher* matcher = query->regexCache()->buildRegexMatcher(
      buffer->c_str(), buffer->length(), caseInsensitive);

  if (matcher == nullptr) {
    // compiling regular expression failed
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_INVALID_REGEX);
    return AqlValue(AqlValueHintNull());
  }

  // extract value
  buffer->clear();
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  AppendAsString(trx, adapter, value);

  size_t const split = buffer->length();
  AqlValue replace = ExtractFunctionParameterValue(parameters, 2);
  AppendAsString(trx, adapter, replace);

  bool error = false;
  std::string result = arangodb::basics::Utf8Helper::DefaultUtf8Helper.replace(
      matcher, buffer->c_str(), split, buffer->c_str() + split,
      buffer->length() - split, false, error);

  if (error) {
    // compiling regular expression failed
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_INVALID_REGEX);
    return AqlValue(AqlValueHintNull());
  }

  return AqlValue(result);
}

/// @brief function DATE_NOW
AqlValue Functions::DateNow(arangodb::aql::Query*, transaction::Methods*,
                            VPackFunctionParameters const&) {
  auto millis =
      std::chrono::duration_cast<duration<int64_t, std::milli>>(system_clock::now().time_since_epoch());
  uint64_t dur = millis.count();
  return AqlValue(AqlValueHintUInt(dur));
}

bool Functions::ParameterToTimePoint(Query* query, transaction::Methods* trx,
                                     VPackFunctionParameters const& parameters,
                                     tp_sys_clock_ms& tp,
                                     std::string const& functionName,
                                     size_t parameterIndex) {
  AqlValue value = ExtractFunctionParameterValue(parameters, parameterIndex);

  if (!value.isString() && !value.isNumber()) {
    RegisterInvalidArgumentWarning(query, functionName.c_str());
    return false;
  }

  if (value.isNumber()) {
    tp = tp_sys_clock_ms(milliseconds(value.toInt64(trx)));
  } else {
    std::string const dateVal = value.slice().copyString();
    if (!basics::parse_dateTime(dateVal, tp)) {
      RegisterWarning(query, functionName.c_str(),
                      TRI_ERROR_QUERY_INVALID_DATE_VALUE);
      return false;
    }
  }

  return true;
}

/**
 * @brief Parses 1 or 3-7 input parameters and creates a Date object out of it.
 *        This object can either be a timestamp in milliseconds or an ISO_8601
 * DATE
 *
 * @param query The AQL query
 * @param trx The used transaction
 * @param parameters list of parameters, only 1 or 3-7 are allowed
 * @param asTimestamp If it should return a timestamp (true) or ISO_DATE (false)
 *
 * @return Returns a timestamp if asTimestamp is true, an ISO_DATE otherwise
 */
AqlValue Functions::DateFromParameters(
    arangodb::aql::Query* query, transaction::Methods* trx,
    VPackFunctionParameters const& parameters, bool asTimestamp) {
  std::string funcName;
  if (asTimestamp) {
    funcName = "DATE_TIMESTAMP";
  } else {
    funcName = "DATE_ISO8601";
  }
  tp_sys_clock_ms tp;
  duration<int64_t, std::milli> time;

  if (parameters.size() == 1) {
    if (!ParameterToTimePoint(query, trx, parameters, tp, funcName.c_str(),
                              0)) {
      return AqlValue(AqlValueHintNull());
    }
    time = tp.time_since_epoch();
  } else {
    if (parameters.size() < 3 || parameters.size() > 7) {
      // YMD is a must
      RegisterInvalidArgumentWarning(query, funcName.c_str());
      return AqlValue(AqlValueHintNull());
    }

    for (uint8_t i = 0; i < parameters.size(); i++) {
      AqlValue value = ExtractFunctionParameterValue(parameters, i);

      // All Parameters have to be a number or a string
      if (!value.isNumber() && !value.isString()) {
        RegisterInvalidArgumentWarning(query, funcName.c_str());
        return AqlValue(AqlValueHintNull());
      }
    }

    // Parse the Year
    years y{ExtractFunctionParameterValue(parameters, 0).toInt64(trx)};
    if (y < years{0}) {
      RegisterWarning(query, funcName.c_str(),
                      TRI_ERROR_QUERY_INVALID_DATE_VALUE);
      return AqlValue(AqlValueHintNull());
    }

    // Parse the Month
    months m{ExtractFunctionParameterValue(parameters, 1).toInt64(trx)};
    if (m < months{0}) {
      RegisterWarning(query, funcName.c_str(),
                      TRI_ERROR_QUERY_INVALID_DATE_VALUE);
      return AqlValue(AqlValueHintNull());
    }

    // Parse the Day
    days d{ExtractFunctionParameterValue(parameters, 2).toInt64(trx)};
    if (d < days{0}) {
      RegisterWarning(query, funcName.c_str(),
                      TRI_ERROR_QUERY_INVALID_DATE_VALUE);
      return AqlValue(AqlValueHintNull());
    }

    year_month_day ymd = year{y.count()} / m.count() / d.count();

    // Parse the Hour
    hours h(0);
    if (parameters.size() >= 4) {
      h = hours((ExtractFunctionParameterValue(parameters, 3).toInt64(trx)));
      if (h < hours{0}) {
        RegisterWarning(query, funcName.c_str(),
                        TRI_ERROR_QUERY_INVALID_DATE_VALUE);
        return AqlValue(AqlValueHintNull());
      }
    }

    // Parse the Minutes
    minutes min(0);
    if (parameters.size() >= 5) {
      min =
          minutes((ExtractFunctionParameterValue(parameters, 4).toInt64(trx)));
      if (min < minutes{0}) {
        RegisterWarning(query, funcName.c_str(),
                        TRI_ERROR_QUERY_INVALID_DATE_VALUE);
        return AqlValue(AqlValueHintNull());
      }
    }

    // Parse the Seconds
    seconds s(0);
    if (parameters.size() >= 6) {
      s = seconds((ExtractFunctionParameterValue(parameters, 5).toInt64(trx)));
      if (s < seconds{0}) {
        RegisterWarning(query, funcName.c_str(),
                        TRI_ERROR_QUERY_INVALID_DATE_VALUE);
        return AqlValue(AqlValueHintNull());
      }
    }

    // Parse the Millis
    milliseconds ms(0);
    if (parameters.size() == 7) {
      ms = milliseconds(
          (ExtractFunctionParameterValue(parameters, 6).toInt64(trx)));
      if (ms < milliseconds{0}) {
        RegisterWarning(query, funcName.c_str(),
                        TRI_ERROR_QUERY_INVALID_DATE_VALUE);
        return AqlValue(AqlValueHintNull());
      }
    }

    time = sys_days(ymd).time_since_epoch();
    time += h;
    time += min;
    time += s;
    time += ms;
    tp = tp_sys_clock_ms(time);
  }

  if (asTimestamp) {
    return AqlValue(AqlValueHintInt(time.count()));
  } else {
    return TimeAqlValue(tp);
  }
}

/// @brief function DATE_ISO8601
AqlValue Functions::DateIso8601(arangodb::aql::Query* query,
                                transaction::Methods* trx,
                                VPackFunctionParameters const& parameters) {
  return DateFromParameters(query, trx, parameters, false);
}

/// @brief function DATE_TIMESTAMP
AqlValue Functions::DateTimestamp(arangodb::aql::Query* query,
                                  transaction::Methods* trx,
                                  VPackFunctionParameters const& parameters) {
  return DateFromParameters(query, trx, parameters, true);
}

/// @brief function IS_DATESTRING
AqlValue Functions::IsDatestring(arangodb::aql::Query*, transaction::Methods*,
                                 VPackFunctionParameters const& parameters) {
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  bool isValid = false;

  if (value.isString()) {
    tp_sys_clock_ms tp;  // unused
    isValid = basics::parse_dateTime(value.slice().copyString(), tp);
  }

  return AqlValue(AqlValueHintBool(isValid));
}

/// @brief function DATE_DAYOFWEEK
AqlValue Functions::DateDayOfWeek(arangodb::aql::Query* query,
                                  transaction::Methods* trx,
                                  VPackFunctionParameters const& parameters) {
  tp_sys_clock_ms tp;
  if (!ParameterToTimePoint(query, trx, parameters, tp, "DATE_DAYOFWEEK", 0)) {
    return AqlValue(AqlValueHintNull());
  }
  weekday wd{floor<days>(tp)};

  // Library has unsigned operator implemented
  return AqlValue(AqlValueHintUInt(static_cast<uint64_t>(unsigned(wd))));
}

/// @brief function DATE_YEAR
AqlValue Functions::DateYear(arangodb::aql::Query* query,
                             transaction::Methods* trx,
                             VPackFunctionParameters const& parameters) {
  tp_sys_clock_ms tp;

  if (!ParameterToTimePoint(query, trx, parameters, tp, "DATE_YEAR", 0)) {
    return AqlValue(AqlValueHintNull());
  }
  auto ymd = year_month_day(floor<days>(tp));
  // Not the library has operator (int) implemented...
  int64_t year = static_cast<int64_t>((int)ymd.year());
  return AqlValue(AqlValueHintInt(year));
}

/// @brief function DATE_MONTH
AqlValue Functions::DateMonth(arangodb::aql::Query* query,
                              transaction::Methods* trx,
                              VPackFunctionParameters const& parameters) {
  tp_sys_clock_ms tp;

  if (!ParameterToTimePoint(query, trx, parameters, tp, "DATE_MONTH", 0)) {
    return AqlValue(AqlValueHintNull());
  }
  auto ymd = year_month_day(floor<days>(tp));
  // The library has operator (unsigned) implemented
  uint64_t month = static_cast<uint64_t>((unsigned)ymd.month());
  return AqlValue(AqlValueHintUInt(month));
}

/// @brief function DATE_DAY
AqlValue Functions::DateDay(arangodb::aql::Query* query,
                            transaction::Methods* trx,
                            VPackFunctionParameters const& parameters) {
  tp_sys_clock_ms tp;

  if (!ParameterToTimePoint(query, trx, parameters, tp, "DATE_DAY", 0)) {
    return AqlValue(AqlValueHintNull());
  }

  auto ymd = year_month_day(floor<days>(tp));
  // The library has operator (unsigned) implemented
  uint64_t day = static_cast<uint64_t>((unsigned)ymd.day());
  return AqlValue(AqlValueHintUInt(day));
}

/// @brief function DATE_HOUR
AqlValue Functions::DateHour(arangodb::aql::Query* query,
                             transaction::Methods* trx,
                             VPackFunctionParameters const& parameters) {
  tp_sys_clock_ms tp;

  if (!ParameterToTimePoint(query, trx, parameters, tp, "DATE_HOUR", 0)) {
    return AqlValue(AqlValueHintNull());
  }

  auto day_time = make_time(tp - floor<days>(tp));
  uint64_t hours = day_time.hours().count();
  return AqlValue(AqlValueHintUInt(hours));
}

/// @brief function DATE_MINUTE
AqlValue Functions::DateMinute(arangodb::aql::Query* query,
                               transaction::Methods* trx,
                               VPackFunctionParameters const& parameters) {
  tp_sys_clock_ms tp;

  if (!ParameterToTimePoint(query, trx, parameters, tp, "DATE_MINUTE", 0)) {
    return AqlValue(AqlValueHintNull());
  }

  auto day_time = make_time(tp - floor<days>(tp));
  uint64_t minutes = day_time.minutes().count();
  return AqlValue(AqlValueHintUInt(minutes));
}

/// @brief function DATE_SECOND
AqlValue Functions::DateSecond(arangodb::aql::Query* query,
                               transaction::Methods* trx,
                               VPackFunctionParameters const& parameters) {
  tp_sys_clock_ms tp;

  if (!ParameterToTimePoint(query, trx, parameters, tp, "DATE_SECOND", 0)) {
    return AqlValue(AqlValueHintNull());
  }

  auto day_time = make_time(tp - floor<days>(tp));
  uint64_t seconds = day_time.seconds().count();
  return AqlValue(AqlValueHintUInt(seconds));
}

/// @brief function DATE_MILLISECOND
AqlValue Functions::DateMillisecond(arangodb::aql::Query* query,
                                    transaction::Methods* trx,
                                    VPackFunctionParameters const& parameters) {
  tp_sys_clock_ms tp;

  if (!ParameterToTimePoint(query, trx, parameters, tp, "DATE_MILLISECOND",
                            0)) {
    return AqlValue(AqlValueHintNull());
  }
  auto day_time = make_time(tp - floor<days>(tp));
  uint64_t millis = day_time.subseconds().count();
  return AqlValue(AqlValueHintUInt(millis));
}

/// @brief function DATE_DAYOFYEAR
AqlValue Functions::DateDayOfYear(arangodb::aql::Query* query,
                                  transaction::Methods* trx,
                                  VPackFunctionParameters const& parameters) {
  tp_sys_clock_ms tp;

  if (!ParameterToTimePoint(query, trx, parameters, tp, "DATE_DAYOFYEAR", 0)) {
    return AqlValue(AqlValueHintNull());
  }

  auto ymd = year_month_day(floor<days>(tp));
  auto yyyy = year{ymd.year()};
  auto firstDayInYear = yyyy / 1 / 0;
  uint64_t daysSinceFirst =
      duration_cast<days>(tp - sys_days(firstDayInYear)).count();

  return AqlValue(AqlValueHintUInt(daysSinceFirst));
}

/// @brief function DATE_ISOWEEK
AqlValue Functions::DateIsoWeek(arangodb::aql::Query* query,
                                transaction::Methods* trx,
                                VPackFunctionParameters const& parameters) {
  tp_sys_clock_ms tp;

  if (!ParameterToTimePoint(query, trx, parameters, tp, "DATE_ISOWEEK", 0)) {
    return AqlValue(AqlValueHintNull());
  }

  iso_week::year_weeknum_weekday yww{floor<days>(tp)};
  // The (unsigned) operator is overloaded...
  uint64_t isoWeek = static_cast<uint64_t>((unsigned)(yww.weeknum()));
  return AqlValue(AqlValueHintUInt(isoWeek));
}

/// @brief function DATE_LEAPYEAR
AqlValue Functions::DateLeapYear(arangodb::aql::Query* query,
                                 transaction::Methods* trx,
                                 VPackFunctionParameters const& parameters) {
  tp_sys_clock_ms tp;

  if (!ParameterToTimePoint(query, trx, parameters, tp, "DATE_LEAPYEAR", 0)) {
    return AqlValue(AqlValueHintNull());
  }

  year_month_day ymd{floor<days>(tp)};

  return AqlValue(AqlValueHintBool(ymd.year().is_leap()));
}

/// @brief function DATE_QUARTER
AqlValue Functions::DateQuarter(arangodb::aql::Query* query,
                                transaction::Methods* trx,
                                VPackFunctionParameters const& parameters) {
  tp_sys_clock_ms tp;

  if (!ParameterToTimePoint(query, trx, parameters, tp, "DATE_QUARTER", 0)) {
    return AqlValue(AqlValueHintNull());
  }

  year_month_day ymd{floor<days>(tp)};
  month m = ymd.month();

  // Library has unsigned operator implemented.
  uint64_t part = static_cast<uint64_t>(ceil(unsigned(m) / 3.0f));
  // We only have 4 quarters ;)
  TRI_ASSERT(part <= 4);
  return AqlValue(AqlValueHintUInt(part));
}

/// @brief function DATE_DAYS_IN_MONTH
AqlValue Functions::DateDaysInMonth(arangodb::aql::Query* query,
                                    transaction::Methods* trx,
                                    VPackFunctionParameters const& parameters) {
  tp_sys_clock_ms tp;

  if (!ParameterToTimePoint(query, trx, parameters, tp, "DATE_DAYS_IN_MONTH",
                            0)) {
    return AqlValue(AqlValueHintNull());
  }

  auto ymd = year_month_day{floor<days>(tp)};
  auto lastMonthDay = ymd.year() / ymd.month() / last;

  // The Library has operator unsigned implemented
  return AqlValue(AqlValueHintUInt(static_cast<uint64_t>(unsigned(lastMonthDay.day()))));
}

/// @brief function DATE_ADD
AqlValue Functions::DateAdd(arangodb::aql::Query* query,
                            transaction::Methods* trx,
                            VPackFunctionParameters const& parameters) {
  tp_sys_clock_ms tp;

  if (!ParameterToTimePoint(query, trx, parameters, tp, "DATE_ADD", 0)) {
    return AqlValue(AqlValueHintNull());
  }

  // size == 3 unit / unit type
  // size == 2 iso duration

  if (parameters.size() == 3) {
    AqlValue durationUnit = ExtractFunctionParameterValue(parameters, 1);
    if (!durationUnit.isNumber()) {  // unit must be number
      RegisterInvalidArgumentWarning(query, "DATE_ADD");
      return AqlValue(AqlValueHintNull());
    }

    AqlValue durationType = ExtractFunctionParameterValue(parameters, 2);
    if (!durationType.isString()) {  // unit type must be string
      RegisterInvalidArgumentWarning(query, "DATE_ADD");
      return AqlValue(AqlValueHintNull());
    }

    // Numbers and Strings can both be sliced
    return AddOrSubtractUnitFromTimestamp(query, tp, durationUnit.slice(),
                                          durationType.slice(), false);
  } else {  // iso duration
    AqlValue isoDuration = ExtractFunctionParameterValue(parameters, 1);
    if (!isoDuration.isString()) {
      RegisterInvalidArgumentWarning(query, "DATE_ADD");
      return AqlValue(AqlValueHintNull());
    }

    std::string const duration = isoDuration.slice().copyString();
    return AddOrSubtractIsoDurationFromTimestamp(query, tp, duration, false);
  }
}

/// @brief function DATE_SUBTRACT
AqlValue Functions::DateSubtract(arangodb::aql::Query* query,
                                 transaction::Methods* trx,
                                 VPackFunctionParameters const& parameters) {
  tp_sys_clock_ms tp;

  if (!ParameterToTimePoint(query, trx, parameters, tp, "DATE_SUBTRACT", 0)) {
    return AqlValue(AqlValueHintNull());
  }

  // size == 3 unit / unit type
  // size == 2 iso duration

  year_month_day ymd{floor<days>(tp)};
  if (parameters.size() == 3) {
    AqlValue durationUnit = ExtractFunctionParameterValue(parameters, 1);
    if (!durationUnit.isNumber()) {  // unit must be number
      RegisterInvalidArgumentWarning(query, "DATE_SUBTRACT");
      return AqlValue(AqlValueHintNull());
    }

    AqlValue durationType = ExtractFunctionParameterValue(parameters, 2);
    if (!durationType.isString()) {  // unit type must be string
      RegisterInvalidArgumentWarning(query, "DATE_SUBTRACT");
      return AqlValue(AqlValueHintNull());
    }

    // Numbers and Strings can both be sliced
    return AddOrSubtractUnitFromTimestamp(query, tp, durationUnit.slice(),
                                          durationType.slice(), true);
  } else {  // iso duration
    AqlValue isoDuration = ExtractFunctionParameterValue(parameters, 1);
    if (!isoDuration.isString()) {
      RegisterInvalidArgumentWarning(query, "DATE_SUBTRACT");
      return AqlValue(AqlValueHintNull());
    }

    std::string const duration = isoDuration.slice().copyString();
    return AddOrSubtractIsoDurationFromTimestamp(query, tp, duration, true);
  }
}

/// @brief function DATE_DIFF
AqlValue Functions::DateDiff(arangodb::aql::Query* query,
                             transaction::Methods* trx,
                             VPackFunctionParameters const& parameters) {
  // Extract first date
  tp_sys_clock_ms tp1;
  if (!ParameterToTimePoint(query, trx, parameters, tp1, "DATE_DIFF", 0)) {
    return AqlValue(AqlValueHintNull());
  }

  // Extract second date
  tp_sys_clock_ms tp2;
  if (!ParameterToTimePoint(query, trx, parameters, tp2, "DATE_DIFF", 1)) {
    return AqlValue(AqlValueHintNull());
  }

  double diff = 0.0;
  bool asFloat = false;
  auto diffDuration = tp2 - tp1;

  AqlValue unitValue = ExtractFunctionParameterValue(parameters, 2);
  if (!unitValue.isString()) {
    RegisterInvalidArgumentWarning(query, "DATE_DIFF");
    return AqlValue(AqlValueHintNull());
  }

  DateSelectionModifier flag = ParseDateModifierFlag(unitValue.slice());

  if (parameters.size() == 4) {
    AqlValue asFloatValue = ExtractFunctionParameterValue(parameters, 3);
    if (!asFloatValue.isBoolean()) {
      RegisterInvalidArgumentWarning(query, "DATE_DIFF");
      return AqlValue(AqlValueHintNull());
    }
    asFloat = asFloatValue.toBoolean();
  }

  switch (flag) {
    case YEAR:
      diff = duration_cast<duration<
          double, std::ratio_multiply<std::ratio<146097, 400>, days::period>>>(
                 diffDuration)
                 .count();
      break;
    case MONTH:
      diff =
          duration_cast<
              duration<double, std::ratio_divide<years::period, std::ratio<12>>>>(
              diffDuration)
              .count();
      break;
    case WEEK:
      diff = duration_cast<
                 duration<double, std::ratio_multiply<std::ratio<7>, days::period>>>(
                 diffDuration)
                 .count();
      break;
    case DAY:
      diff = duration_cast<duration<
          double,
          std::ratio_multiply<std::ratio<24>, std::chrono::hours::period>>>(
                 diffDuration)
                 .count();
      break;
    case HOUR:
      diff =
          duration_cast<duration<double, std::ratio<3600>>>(diffDuration).count();
      break;
    case MINUTE:
      diff =
          duration_cast<duration<double, std::ratio<60>>>(diffDuration).count();
      break;
    case SECOND:
      diff = duration_cast<duration<double>>(diffDuration).count();
      break;
    case MILLI:
      diff = duration_cast<duration<double, std::milli>>(diffDuration).count();
      break;
    case INVALID:
      RegisterWarning(query, "DATE_DIFF", TRI_ERROR_QUERY_INVALID_DATE_VALUE);
      return AqlValue(AqlValueHintNull());
  }

  if (asFloat) {
    return AqlValue(AqlValueHintDouble(diff));
  } else {
    return AqlValue(AqlValueHintInt(static_cast<int64_t>(std::round(diff))));
  }
}

/// @brief function DATE_COMPARE
AqlValue Functions::DateCompare(arangodb::aql::Query* query,
                                transaction::Methods* trx,
                                VPackFunctionParameters const& parameters) {
  tp_sys_clock_ms tp1;
  if (!ParameterToTimePoint(query, trx, parameters, tp1, "DATE_COMPARE", 0)) {
    return AqlValue(AqlValueHintNull());
  }

  tp_sys_clock_ms tp2;
  if (!ParameterToTimePoint(query, trx, parameters, tp2, "DATE_COMPARE", 1)) {
    return AqlValue(AqlValueHintNull());
  }

  AqlValue rangeStartValue = ExtractFunctionParameterValue(parameters, 2);

  DateSelectionModifier rangeStart =
      ParseDateModifierFlag(rangeStartValue.slice());

  if (rangeStart == INVALID) {
    RegisterWarning(query, "DATE_COMPARE",
                    TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }

  DateSelectionModifier rangeEnd = rangeStart;
  if (parameters.size() == 4) {
    AqlValue rangeEndValue = ExtractFunctionParameterValue(parameters, 3);
    rangeEnd = ParseDateModifierFlag(rangeEndValue.slice());

    if (rangeEnd == INVALID) {
      RegisterWarning(query, "DATE_COMPARE",
                      TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
      return AqlValue(AqlValueHintNull());
    }
  }
  auto ymd1 = year_month_day{floor<days>(tp1)};
  auto ymd2 = year_month_day{floor<days>(tp2)};
  auto time1 = make_time(tp1 - floor<days>(tp1));
  auto time2 = make_time(tp2 - floor<days>(tp2));

  // This switch has the following feature:
  // It is ordered by the Highest value of
  // the Modifier (YEAR) and flows down to
  // lower values.
  // In each case if the value is significant
  // (above or equal the endRange) we compare it.
  // If this part is not equal we return false.
  // Otherwise we fall down to the next part.
  // As soon as we are below the endRange
  // we bail out.
  // So all Fall throughs here are intentional
  switch (rangeStart) {
    case YEAR:
      // Always check for the year
      if (ymd1.year() != ymd2.year()) {
        return AqlValue(AqlValueHintBool(false));
      }
      // intentionally falls through
    case MONTH:
      if (rangeEnd > MONTH) {
        break;
      }
      if (ymd1.month() != ymd2.month()) {
        return AqlValue(AqlValueHintBool(false));
      }
      // intentionally falls through
    case DAY:
      if (rangeEnd > DAY) {
        break;
      }
      if (ymd1.day() != ymd2.day()) {
        return AqlValue(AqlValueHintBool(false));
      }
      // intentionally falls through
    case HOUR:
      if (rangeEnd > HOUR) {
        break;
      }
      if (time1.hours() != time2.hours()) {
        return AqlValue(AqlValueHintBool(false));
      }
      // intentionally falls through
    case MINUTE:
      if (rangeEnd > MINUTE) {
        break;
      }
      if (time1.minutes() != time2.minutes()) {
        return AqlValue(AqlValueHintBool(false));
      }
      // intentionally falls through
    case SECOND:
      if (rangeEnd > SECOND) {
        break;
      }
      if (time1.seconds() != time2.seconds()) {
        return AqlValue(AqlValueHintBool(false));
      }
      // intentionally falls through
    case MILLI:
      if (rangeEnd > MILLI) {
        break;
      }
      if (time1.subseconds() != time2.subseconds()) {
        return AqlValue(AqlValueHintBool(false));
      }
      break;
    case INVALID:
    case WEEK:
      // Was handled before
      TRI_ASSERT(false);
  }

  // If we get here all significant places are equal
  // Name these two dates as equal
  return AqlValue(AqlValueHintBool(true));
}

/// @brief function PASSTHRU
AqlValue Functions::Passthru(arangodb::aql::Query* query,
                             transaction::Methods* trx,
                             VPackFunctionParameters const& parameters) {
  if (parameters.empty()) {
    return AqlValue(AqlValueHintNull());
  }

  return ExtractFunctionParameterValue(parameters, 0).clone();
}

/// @brief function UNSET
AqlValue Functions::Unset(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  static char const* AFN = "UNSET";
  ValidateParameters(parameters, AFN, 2);
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  if (!value.isObject()) {
    RegisterInvalidArgumentWarning(query, AFN);
    return AqlValue(AqlValueHintNull());
  }

  std::unordered_set<std::string> names;
  ExtractKeys(names, query, trx, parameters, 1, AFN);

  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(value, false);
  transaction::BuilderLeaser builder(trx);
  UnsetOrKeep(trx, slice, names, true, false, *builder.get());
  return AqlValue(builder.get());
}

/// @brief function UNSET_RECURSIVE
AqlValue Functions::UnsetRecursive(arangodb::aql::Query* query,
                                   transaction::Methods* trx,
                                   VPackFunctionParameters const& parameters) {
  static char const* AFN = "UNSET_RECURSIVE";
  ValidateParameters(parameters, AFN, 2);
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  if (!value.isObject()) {
    RegisterInvalidArgumentWarning(query, AFN);
    return AqlValue(AqlValueHintNull());
  }

  std::unordered_set<std::string> names;
  ExtractKeys(names, query, trx, parameters, 1, AFN);

  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(value, false);
  transaction::BuilderLeaser builder(trx);
  UnsetOrKeep(trx, slice, names, true, true, *builder.get());
  return AqlValue(builder.get());
}

/// @brief function KEEP
AqlValue Functions::Keep(arangodb::aql::Query* query, transaction::Methods* trx,
                         VPackFunctionParameters const& parameters) {
  static char const* AFN = "KEEP";
  ValidateParameters(parameters, AFN, 2);
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  if (!value.isObject()) {
    RegisterInvalidArgumentWarning(query, AFN);
    return AqlValue(AqlValueHintNull());
  }

  std::unordered_set<std::string> names;

  ExtractKeys(names, query, trx, parameters, 1, AFN);

  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(value, false);
  transaction::BuilderLeaser builder(trx);
  UnsetOrKeep(trx, slice, names, false, false, *builder.get());
  return AqlValue(builder.get());
}

/// @brief function TRANSLATE
AqlValue Functions::Translate(arangodb::aql::Query* query,
                              transaction::Methods* trx,
                              VPackFunctionParameters const& parameters) {
  static char const* AFN = "TRANSLATE";
  ValidateParameters(parameters, AFN, 2, 3);
  AqlValue key = ExtractFunctionParameterValue(parameters, 0);
  AqlValue lookupDocument = ExtractFunctionParameterValue(parameters, 1);

  if (!lookupDocument.isObject()) {
    RegisterInvalidArgumentWarning(query, AFN);
    return AqlValue(AqlValueHintNull());
  }

  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(lookupDocument, true);
  TRI_ASSERT(slice.isObject());

  VPackSlice result;
  if (key.isString()) {
    result = slice.get(key.slice().copyString());
  } else {
    transaction::StringBufferLeaser buffer(trx);
    arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());
    Functions::Stringify(trx, adapter, key.slice());
    result = slice.get(buffer->toString());
  }

  if (!result.isNone()) {
    return AqlValue(result);
  }

  // attribute not found, now return the default value
  // we must create copy of it however
  AqlValue defaultValue = ExtractFunctionParameterValue(parameters, 2);
  if (defaultValue.isNone()) {
    return key.clone();
  }
  return defaultValue.clone();
}

/// @brief function MERGE
AqlValue Functions::Merge(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  return MergeParameters(query, trx, parameters, "MERGE", false);
}

/// @brief function MERGE_RECURSIVE
AqlValue Functions::MergeRecursive(arangodb::aql::Query* query,
                                   transaction::Methods* trx,
                                   VPackFunctionParameters const& parameters) {
  return MergeParameters(query, trx, parameters, "MERGE_RECURSIVE", true);
}

/// @brief function HAS
AqlValue Functions::Has(arangodb::aql::Query* query, transaction::Methods* trx,
                        VPackFunctionParameters const& parameters) {
  size_t const n = parameters.size();
  if (n < 2) {
    // no parameters
    return AqlValue(AqlValueHintBool(false));
  }

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  if (!value.isObject()) {
    // not an object
    return AqlValue(AqlValueHintBool(false));
  }

  AqlValue name = ExtractFunctionParameterValue(parameters, 1);
  std::string p;
  if (!name.isString()) {
    transaction::StringBufferLeaser buffer(trx);
    arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());
    AppendAsString(trx, adapter, name);
    p = std::string(buffer->c_str(), buffer->length());
  } else {
    p = name.slice().copyString();
  }

  return AqlValue(AqlValueHintBool(value.hasKey(trx, p)));
}

/// @brief function ATTRIBUTES
AqlValue Functions::Attributes(arangodb::aql::Query* query,
                               transaction::Methods* trx,
                               VPackFunctionParameters const& parameters) {
  size_t const n = parameters.size();

  if (n < 1) {
    // no parameters
    return AqlValue(AqlValueHintNull());
  }

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  if (!value.isObject()) {
    // not an object
    RegisterWarning(query, "ATTRIBUTES",
                    TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }

  bool const removeInternal = GetBooleanParameter(trx, parameters, 1, false);
  bool const doSort = GetBooleanParameter(trx, parameters, 2, false);

  TRI_ASSERT(value.isObject());
  if (value.length() == 0) {
    return AqlValue(arangodb::basics::VelocyPackHelper::EmptyArrayValue());
  }

  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(value, false);

  if (doSort) {
    std::set<std::string,
             arangodb::basics::VelocyPackHelper::AttributeSorterUTF8>
        keys;

    VPackCollection::keys(slice, keys);
    VPackBuilder result;
    result.openArray();
    for (auto const& it : keys) {
      TRI_ASSERT(!it.empty());
      if (removeInternal && !it.empty() && it.at(0) == '_') {
        continue;
      }
      result.add(VPackValue(it));
    }
    result.close();

    return AqlValue(result);
  }

  std::unordered_set<std::string> keys;
  VPackCollection::keys(slice, keys);

  VPackBuilder result;
  result.openArray();
  for (auto const& it : keys) {
    if (removeInternal && !it.empty() && it.at(0) == '_') {
      continue;
    }
    result.add(VPackValue(it));
  }
  result.close();
  return AqlValue(result);
}

/// @brief function VALUES
AqlValue Functions::Values(arangodb::aql::Query* query,
                           transaction::Methods* trx,
                           VPackFunctionParameters const& parameters) {
  size_t const n = parameters.size();

  if (n < 1) {
    // no parameters
    return AqlValue(AqlValueHintNull());
  }

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  if (!value.isObject()) {
    // not an object
    RegisterWarning(query, "VALUES",
                    TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }

  bool const removeInternal = GetBooleanParameter(trx, parameters, 1, false);

  TRI_ASSERT(value.isObject());
  if (value.length() == 0) {
    return AqlValue(arangodb::basics::VelocyPackHelper::EmptyArrayValue());
  }

  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(value, false);
  transaction::BuilderLeaser builder(trx);
  builder->openArray();
  for (auto const& entry : VPackObjectIterator(slice, true)) {
    if (!entry.key.isString()) {
      // somehow invalid
      continue;
    }
    if (removeInternal) {
      VPackValueLength l;
      char const* p = entry.key.getString(l);
      if (l > 0 && *p == '_') {
        // skip attribute
        continue;
      }
    }
    if (entry.value.isCustom()) {
      builder->add(VPackValue(trx->extractIdString(slice)));
    } else {
      builder->add(entry.value);
    }
  }
  builder->close();

  return AqlValue(builder.get());
}

/// @brief function MIN
AqlValue Functions::Min(arangodb::aql::Query* query, transaction::Methods* trx,
                        VPackFunctionParameters const& parameters) {
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  if (!value.isArray()) {
    // not an array
    RegisterWarning(query, "MIN", TRI_ERROR_QUERY_ARRAY_EXPECTED);
    return AqlValue(AqlValueHintNull());
  }

  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(value, false);

  VPackSlice minValue;
  auto options = trx->transactionContextPtr()->getVPackOptions();
  for (auto const& it : VPackArrayIterator(slice)) {
    if (it.isNull()) {
      continue;
    }
    if (minValue.isNone() ||
        arangodb::basics::VelocyPackHelper::compare(it, minValue, true,
                                                    options) < 0) {
      minValue = it;
    }
  }
  if (minValue.isNone()) {
    return AqlValue(AqlValueHintNull());
  }
  return AqlValue(minValue);
}

/// @brief function MAX
AqlValue Functions::Max(arangodb::aql::Query* query, transaction::Methods* trx,
                        VPackFunctionParameters const& parameters) {
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  if (!value.isArray()) {
    // not an array
    RegisterWarning(query, "MAX", TRI_ERROR_QUERY_ARRAY_EXPECTED);
    return AqlValue(AqlValueHintNull());
  }

  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(value, false);
  VPackSlice maxValue;
  auto options = trx->transactionContextPtr()->getVPackOptions();
  for (auto const& it : VPackArrayIterator(slice)) {
    if (maxValue.isNone() ||
        arangodb::basics::VelocyPackHelper::compare(it, maxValue, true,
                                                    options) > 0) {
      maxValue = it;
    }
  }
  if (maxValue.isNone()) {
    return AqlValue(AqlValueHintNull());
  }
  return AqlValue(maxValue);
}

/// @brief function SUM
AqlValue Functions::Sum(arangodb::aql::Query* query, transaction::Methods* trx,
                        VPackFunctionParameters const& parameters) {
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  if (!value.isArray()) {
    // not an array
    RegisterWarning(query, "SUM", TRI_ERROR_QUERY_ARRAY_EXPECTED);
    return AqlValue(AqlValueHintNull());
  }

  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(value, false);
  double sum = 0.0;
  for (auto const& it : VPackArrayIterator(slice)) {
    if (it.isNull()) {
      continue;
    }
    if (!it.isNumber()) {
      return AqlValue(AqlValueHintNull());
    }
    double const number = it.getNumericValue<double>();

    if (!std::isnan(number) && number != HUGE_VAL && number != -HUGE_VAL) {
      sum += number;
    }
  }

  return NumberValue(trx, sum, false);
}

/// @brief function AVERAGE
AqlValue Functions::Average(arangodb::aql::Query* query,
                            transaction::Methods* trx,
                            VPackFunctionParameters const& parameters) {
  static char const* AFN = "AVERAGE";
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  if (!value.isArray()) {
    // not an array
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_ARRAY_EXPECTED);
    return AqlValue(AqlValueHintNull());
  }

  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(value, false);

  double sum = 0.0;
  size_t count = 0;
  for (auto const& v : VPackArrayIterator(slice)) {
    if (v.isNull()) {
      continue;
    }
    if (!v.isNumber()) {
      RegisterWarning(query, AFN, TRI_ERROR_QUERY_ARRAY_EXPECTED);
      return AqlValue(AqlValueHintNull());
    }

    // got a numeric value
    double const number = v.getNumericValue<double>();

    if (!std::isnan(number) && number != HUGE_VAL && number != -HUGE_VAL) {
      sum += number;
      ++count;
    }
  }

  if (count > 0 && !std::isnan(sum) && sum != HUGE_VAL && sum != -HUGE_VAL) {
    return NumberValue(trx, sum / static_cast<size_t>(count), false);
  }

  return AqlValue(AqlValueHintNull());
}

/// @brief function SLEEP
AqlValue Functions::Sleep(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  if (!value.isNumber() || value.toDouble(trx) < 0) {
    RegisterWarning(query, "SLEEP",
                    TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }

  double const until = TRI_microtime() + value.toDouble(trx);

  while (TRI_microtime() < until) {
    std::this_thread::sleep_for(std::chrono::microseconds(30000));

    if (query->killed()) {
      THROW_ARANGO_EXCEPTION(TRI_ERROR_QUERY_KILLED);
    } else if (application_features::ApplicationServer::isStopping()) {
      THROW_ARANGO_EXCEPTION(TRI_ERROR_SHUTTING_DOWN);
    }
  }
  return AqlValue(AqlValueHintNull());
}

/// @brief function COLLECTIONS
AqlValue Functions::Collections(arangodb::aql::Query* query,
                                transaction::Methods* trx,
                                VPackFunctionParameters const& parameters) {
  transaction::BuilderLeaser builder(trx);
  builder->openArray();

  TRI_vocbase_t* vocbase = query->vocbase();

  std::vector<LogicalCollection*> colls;

  // clean memory
  std::function<void()> cleanup;

  // if we are a coordinator, we need to fetch the collection info from the
  // agency
  if (ServerState::instance()->isCoordinator()) {
    cleanup = [&colls]() {
      for (auto& it : colls) {
        if (it != nullptr) {
          delete it;
        }
      }
    };
    colls = GetCollectionsCluster(vocbase);
  } else {
    colls = vocbase->collections(false);
    cleanup = []() {};
  }

  // make sure memory is cleaned up
  TRI_DEFER(cleanup());

  std::sort(colls.begin(), colls.end(),
            [](LogicalCollection* lhs, LogicalCollection* rhs) -> bool {
              return basics::StringUtils::tolower(lhs->name()) <
                     basics::StringUtils::tolower(rhs->name());
            });

  size_t const n = colls.size();
  for (size_t i = 0; i < n; ++i) {
    LogicalCollection* coll = colls[i];

    if (ExecContext::CURRENT != nullptr &&
        !ExecContext::CURRENT->canUseCollection(vocbase->name(), coll->name(),
                                                auth::Level::RO)) {
      continue;
    }

    builder->openObject();
    builder->add("_id", VPackValue(std::to_string(coll->id())));
    builder->add("name", VPackValue(coll->name()));
    builder->close();
  }

  builder->close();

  return AqlValue(builder.get());
}

/// @brief function RANDOM_TOKEN
AqlValue Functions::RandomToken(arangodb::aql::Query* query,
                                transaction::Methods* trx,
                                VPackFunctionParameters const& parameters) {
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  int64_t const length = value.toInt64(trx);
  if (length <= 0 || length > 65536) {
    THROW_ARANGO_EXCEPTION_PARAMS(
        TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH, "RANDOM_TOKEN");
  }

  UniformCharacter JSNumGenerator(
      "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
  return AqlValue(JSNumGenerator.random(static_cast<size_t>(length)));
}

/// @brief function MD5
AqlValue Functions::Md5(arangodb::aql::Query* query, transaction::Methods* trx,
                        VPackFunctionParameters const& parameters) {
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

  AppendAsString(trx, adapter, value);

  // create md5
  char hash[17];
  char* p = &hash[0];
  size_t length;

  arangodb::rest::SslInterface::sslMD5(buffer->c_str(), buffer->length(), p,
                                       length);

  // as hex
  char hex[33];
  p = &hex[0];

  arangodb::rest::SslInterface::sslHEX(hash, 16, p, length);

  return AqlValue(&hex[0], 32);
}

/// @brief function SHA1
AqlValue Functions::Sha1(arangodb::aql::Query* query, transaction::Methods* trx,
                         VPackFunctionParameters const& parameters) {
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

  AppendAsString(trx, adapter, value);

  // create sha1
  char hash[21];
  char* p = &hash[0];
  size_t length;

  arangodb::rest::SslInterface::sslSHA1(buffer->c_str(), buffer->length(), p,
                                        length);

  // as hex
  char hex[41];
  p = &hex[0];

  arangodb::rest::SslInterface::sslHEX(hash, 20, p, length);

  return AqlValue(&hex[0], 40);
}

/// @brief function SHA512
AqlValue Functions::Sha512(arangodb::aql::Query* query,
                           transaction::Methods* trx,
                           VPackFunctionParameters const& parameters) {
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

  AppendAsString(trx, adapter, value);

  // create sha512
  char hash[65];
  char* p = &hash[0];
  size_t length;

  arangodb::rest::SslInterface::sslSHA512(buffer->c_str(), buffer->length(), p,
                                          length);

  // as hex
  char hex[129];
  p = &hex[0];

  arangodb::rest::SslInterface::sslHEX(hash, 64, p, length);

  return AqlValue(&hex[0], 128);
}

/// @brief function HASH
AqlValue Functions::Hash(arangodb::aql::Query* query, transaction::Methods* trx,
                         VPackFunctionParameters const& parameters) {
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  // throw away the top bytes so the hash value can safely be used
  // without precision loss when storing in JavaScript etc.
  uint64_t hash = value.hash(trx) & 0x0007ffffffffffffULL;

  return AqlValue(AqlValueHintUInt(hash));
}

/// @brief function IS_KEY
AqlValue Functions::IsKey(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  if (!value.isString()) {
    // not a string, so no valid key
    return AqlValue(AqlValueHintBool(false));
  }

  VPackValueLength l;
  char const* p = value.slice().getString(l);
  return AqlValue(AqlValueHintBool(TraditionalKeyGenerator::validateKey(p, l)));
}

/// @brief function UNIQUE
AqlValue Functions::Unique(arangodb::aql::Query* query,
                           transaction::Methods* trx,
                           VPackFunctionParameters const& parameters) {
  static char const* AFN = "UNIQUE";
  ValidateParameters(parameters, AFN, 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  if (!value.isArray()) {
    // not an array
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_ARRAY_EXPECTED);
    return AqlValue(AqlValueHintNull());
  }

  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(value, false);

  auto options = trx->transactionContextPtr()->getVPackOptions();
  std::unordered_set<VPackSlice, arangodb::basics::VelocyPackHelper::VPackHash,
                     arangodb::basics::VelocyPackHelper::VPackEqual>
      values(512, arangodb::basics::VelocyPackHelper::VPackHash(),
             arangodb::basics::VelocyPackHelper::VPackEqual(options));

  for (VPackSlice s : VPackArrayIterator(slice)) {
    if (!s.isNone()) {
      values.emplace(s.resolveExternal());
    }
  }

  transaction::BuilderLeaser builder(trx);
  builder->openArray();
  for (auto const& it : values) {
    builder->add(it);
  }
  builder->close();
  return AqlValue(builder.get());
}

/// @brief function SORTED_UNIQUE
AqlValue Functions::SortedUnique(arangodb::aql::Query* query,
                                 transaction::Methods* trx,
                                 VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "SORTED_UNIQUE", 1, 1);
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  if (!value.isArray()) {
    // not an array
    return AqlValue(AqlValueHintNull());
  }

  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(value, false);

  arangodb::basics::VelocyPackHelper::VPackLess<true> less(
      trx->transactionContext()->getVPackOptions(), &slice, &slice);
  std::set<VPackSlice, arangodb::basics::VelocyPackHelper::VPackLess<true>>
      values(less);
  for (auto const& it : VPackArrayIterator(slice)) {
    if (!it.isNone()) {
      values.insert(it);
    }
  }

  transaction::BuilderLeaser builder(trx);
  builder->openArray();
  for (auto const& it : values) {
    builder->add(it);
  }
  builder->close();
  return AqlValue(builder.get());
}

/// @brief function SORTED
AqlValue Functions::Sorted(arangodb::aql::Query* query,
                           transaction::Methods* trx,
                           VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "SORTED", 1, 1);
  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  if (!value.isArray()) {
    // not an array
    return AqlValue(AqlValueHintNull());
  }

  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(value, false);

  arangodb::basics::VelocyPackHelper::VPackLess<true> less(
      trx->transactionContext()->getVPackOptions(), &slice, &slice);
  std::map<VPackSlice, size_t,
           arangodb::basics::VelocyPackHelper::VPackLess<true>>
      values(less);
  for (auto const& it : VPackArrayIterator(slice)) {
    if (!it.isNone()) {
      auto f = values.emplace(it, 1);
      if (!f.second) {
        ++(*f.first).second;
      }
    }
  }

  transaction::BuilderLeaser builder(trx);
  builder->openArray();
  for (auto const& it : values) {
    for (size_t i = 0; i < it.second; ++i) {
      builder->add(it.first);
    }
  }
  builder->close();
  return AqlValue(builder.get());
}

/// @brief function UNION
AqlValue Functions::Union(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  static char const* AFN = "UNION";
  ValidateParameters(parameters, AFN, 2);

  transaction::BuilderLeaser builder(trx);
  builder->openArray();
  size_t const n = parameters.size();
  for (size_t i = 0; i < n; ++i) {
    AqlValue value = ExtractFunctionParameterValue(parameters, i);

    if (!value.isArray()) {
      // not an array
      RegisterInvalidArgumentWarning(query, AFN);
      return AqlValue(AqlValueHintNull());
    }

    TRI_IF_FAILURE("AqlFunctions::OutOfMemory1") {
      THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
    }

    AqlValueMaterializer materializer(trx);
    VPackSlice slice = materializer.slice(value, false);

    // this passes ownership for the JSON contens into result
    for (auto const& it : VPackArrayIterator(slice)) {
      builder->add(it);
      TRI_IF_FAILURE("AqlFunctions::OutOfMemory2") {
        THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
      }
    }
  }
  builder->close();
  TRI_IF_FAILURE("AqlFunctions::OutOfMemory3") {
    THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
  }

  return AqlValue(builder.get());
}

/// @brief function UNION_DISTINCT
AqlValue Functions::UnionDistinct(arangodb::aql::Query* query,
                                  transaction::Methods* trx,
                                  VPackFunctionParameters const& parameters) {
  static char const* AFN = "UNION_DISTINCT";
  ValidateParameters(parameters, AFN, 2);
  size_t const n = parameters.size();

  auto options = trx->transactionContextPtr()->getVPackOptions();
  std::unordered_set<VPackSlice, arangodb::basics::VelocyPackHelper::VPackHash,
                     arangodb::basics::VelocyPackHelper::VPackEqual>
      values(512, arangodb::basics::VelocyPackHelper::VPackHash(),
             arangodb::basics::VelocyPackHelper::VPackEqual(options));

  std::vector<AqlValueMaterializer> materializers;
  materializers.reserve(n);
  for (size_t i = 0; i < n; ++i) {
    AqlValue value = ExtractFunctionParameterValue(parameters, i);

    if (!value.isArray()) {
      // not an array
      RegisterInvalidArgumentWarning(query, AFN);
      return AqlValue(AqlValueHintNull());
    }

    materializers.emplace_back(trx);
    VPackSlice slice = materializers.back().slice(value, false);

    for (VPackSlice v : VPackArrayIterator(slice)) {
      v = v.resolveExternal();
      if (values.find(v) == values.end()) {
        TRI_IF_FAILURE("AqlFunctions::OutOfMemory1") {
          THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
        }

        values.emplace(v);
      }
    }
  }

  TRI_IF_FAILURE("AqlFunctions::OutOfMemory2") {
    THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
  }

  transaction::BuilderLeaser builder(trx);
  builder->openArray();
  for (auto const& it : values) {
    builder->add(it);
  }
  builder->close();

  TRI_IF_FAILURE("AqlFunctions::OutOfMemory3") {
    THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
  }

  return AqlValue(builder.get());
}

/// @brief function INTERSECTION
AqlValue Functions::Intersection(arangodb::aql::Query* query,
                                 transaction::Methods* trx,
                                 VPackFunctionParameters const& parameters) {
  static char const* AFN = "INTERSECTION";
  ValidateParameters(parameters, AFN, 2);

  auto options = trx->transactionContextPtr()->getVPackOptions();
  std::unordered_map<VPackSlice, size_t,
                     arangodb::basics::VelocyPackHelper::VPackHash,
                     arangodb::basics::VelocyPackHelper::VPackEqual>
      values(512, arangodb::basics::VelocyPackHelper::VPackHash(),
             arangodb::basics::VelocyPackHelper::VPackEqual(options));

  size_t const n = parameters.size();
  std::vector<AqlValueMaterializer> materializers;
  materializers.reserve(n);
  for (size_t i = 0; i < n; ++i) {
    AqlValue value = ExtractFunctionParameterValue(parameters, i);

    if (!value.isArray()) {
      // not an array
      RegisterWarning(query, AFN, TRI_ERROR_QUERY_ARRAY_EXPECTED);
      return AqlValue(AqlValueHintNull());
    }

    materializers.emplace_back(trx);
    VPackSlice slice = materializers.back().slice(value, false);

    for (auto const& it : VPackArrayIterator(slice)) {
      if (i == 0) {
        // round one

        TRI_IF_FAILURE("AqlFunctions::OutOfMemory1") {
          THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
        }

        values.emplace(it, 1);
      } else {
        // check if we have seen the same element before
        auto found = values.find(it);
        if (found != values.end()) {
          // already seen
          if ((*found).second < i) {
            (*found).second = 0;
          } else {
            (*found).second = i + 1;
          }
        }
      }
    }
  }

  TRI_IF_FAILURE("AqlFunctions::OutOfMemory2") {
    THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
  }

  transaction::BuilderLeaser builder(trx);
  builder->openArray();
  for (auto const& it : values) {
    if (it.second == n) {
      builder->add(it.first);
    }
  }
  builder->close();

  TRI_IF_FAILURE("AqlFunctions::OutOfMemory3") {
    THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
  }
  return AqlValue(builder.get());
}

/// @brief function OUTERSECTION
AqlValue Functions::Outersection(arangodb::aql::Query* query,
                                 transaction::Methods* trx,
                                 VPackFunctionParameters const& parameters) {
  static char const* AFN = "OUTERSECTION";
  ValidateParameters(parameters, AFN, 2);

  auto options = trx->transactionContextPtr()->getVPackOptions();
  std::unordered_map<VPackSlice, size_t,
                     arangodb::basics::VelocyPackHelper::VPackHash,
                     arangodb::basics::VelocyPackHelper::VPackEqual>
      values(512, arangodb::basics::VelocyPackHelper::VPackHash(),
             arangodb::basics::VelocyPackHelper::VPackEqual(options));

  size_t const n = parameters.size();
  std::vector<AqlValueMaterializer> materializers;
  materializers.reserve(n);
  for (size_t i = 0; i < n; ++i) {
    AqlValue value = ExtractFunctionParameterValue(parameters, i);

    if (!value.isArray()) {
      // not an array
      RegisterWarning(query, AFN, TRI_ERROR_QUERY_ARRAY_EXPECTED);
      return AqlValue(AqlValueHintNull());
    }

    materializers.emplace_back(trx);
    VPackSlice slice = materializers.back().slice(value, false);

    for (auto const& it : VPackArrayIterator(slice)) {
      // check if we have seen the same element before
      auto found = values.find(it);
      if (found != values.end()) {
        // already seen
        TRI_ASSERT((*found).second > 0);
        ++(found->second);
      } else {
        values.emplace(it, 1);
      }
    }
  }

  TRI_IF_FAILURE("AqlFunctions::OutOfMemory2") {
    THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
  }

  transaction::BuilderLeaser builder(trx);
  builder->openArray();
  for (auto const& it : values) {
    if (it.second == 1) {
      builder->add(it.first);
    }
  }
  builder->close();

  TRI_IF_FAILURE("AqlFunctions::OutOfMemory3") {
    THROW_ARANGO_EXCEPTION(TRI_ERROR_DEBUG);
  }
  return AqlValue(builder.get());
}

/// @brief function DISTANCE
AqlValue Functions::Distance(arangodb::aql::Query* query,
                             transaction::Methods* trx,
                             VPackFunctionParameters const& parameters) {
  static char const* AFN = "DISTANCE";
  ValidateParameters(parameters, AFN, 4, 4);

  AqlValue lat1 = ExtractFunctionParameterValue(parameters, 0);
  AqlValue lon1 = ExtractFunctionParameterValue(parameters, 1);
  AqlValue lat2 = ExtractFunctionParameterValue(parameters, 2);
  AqlValue lon2 = ExtractFunctionParameterValue(parameters, 3);

  // non-numeric input...
  if (!lat1.isNumber() || !lon1.isNumber() || !lat2.isNumber() ||
      !lon2.isNumber()) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }

  bool failed;
  bool error = false;
  double lat1Value = lat1.toDouble(trx, failed);
  error |= failed;
  double lon1Value = lon1.toDouble(trx, failed);
  error |= failed;
  double lat2Value = lat2.toDouble(trx, failed);
  error |= failed;
  double lon2Value = lon2.toDouble(trx, failed);
  error |= failed;

  if (error) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }

  auto toRadians = [](double degrees) -> double {
    return degrees * (std::acos(-1.0) / 180.0);
  };

  double p1 = toRadians(lat1Value);
  double p2 = toRadians(lat2Value);
  double d1 = toRadians(lat2Value - lat1Value);
  double d2 = toRadians(lon2Value - lon1Value);

  double a =
      std::sin(d1 / 2.0) * std::sin(d1 / 2.0) +
      std::cos(p1) * std::cos(p2) * std::sin(d2 / 2.0) * std::sin(d2 / 2.0);

  double c = 2.0 * std::atan2(std::sqrt(a), std::sqrt(1.0 - a));
  double const EARTHRADIAN = 6371000.0;  // metres

  return NumberValue(trx, EARTHRADIAN * c, true);
}

/// @brief function FLATTEN
AqlValue Functions::Flatten(arangodb::aql::Query* query,
                            transaction::Methods* trx,
                            VPackFunctionParameters const& parameters) {
  static char const* AFN = "FLATTEN";
  ValidateParameters(parameters, AFN, 1, 2);

  AqlValue list = ExtractFunctionParameterValue(parameters, 0);
  if (!list.isArray()) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_ARRAY_EXPECTED);
    return AqlValue(AqlValueHintNull());
  }

  size_t maxDepth = 1;
  if (parameters.size() == 2) {
    AqlValue maxDepthValue = ExtractFunctionParameterValue(parameters, 1);
    bool failed;
    double tmpMaxDepth = maxDepthValue.toDouble(trx, failed);
    if (failed || tmpMaxDepth < 1) {
      maxDepth = 1;
    } else {
      maxDepth = static_cast<size_t>(tmpMaxDepth);
    }
  }

  AqlValueMaterializer materializer(trx);
  VPackSlice listSlice = materializer.slice(list, false);

  transaction::BuilderLeaser builder(trx);
  builder->openArray();
  FlattenList(listSlice, maxDepth, 0, *builder.get());
  builder->close();
  return AqlValue(builder.get());
}

/// @brief function ZIP
AqlValue Functions::Zip(arangodb::aql::Query* query, transaction::Methods* trx,
                        VPackFunctionParameters const& parameters) {
  static char const* AFN = "ZIP";
  ValidateParameters(parameters, AFN, 2, 2);

  AqlValue keys = ExtractFunctionParameterValue(parameters, 0);
  AqlValue values = ExtractFunctionParameterValue(parameters, 1);

  if (!keys.isArray() || !values.isArray() ||
      keys.length() != values.length()) {
    RegisterWarning(query, AFN,
                    TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }

  VPackValueLength n = keys.length();

  AqlValueMaterializer keyMaterializer(trx);
  VPackSlice keysSlice = keyMaterializer.slice(keys, false);

  AqlValueMaterializer valueMaterializer(trx);
  VPackSlice valuesSlice = valueMaterializer.slice(values, false);

  transaction::BuilderLeaser builder(trx);
  builder->openObject();

  // Buffer will temporarily hold the keys
  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());
  for (VPackValueLength i = 0; i < n; ++i) {
    buffer->reset();
    Stringify(trx, adapter, keysSlice.at(i));
    builder->add(buffer->c_str(), buffer->length(), valuesSlice.at(i));
  }
  builder->close();
  return AqlValue(builder.get());
}

/// @brief function JSON_STRINGIFY
AqlValue Functions::JsonStringify(arangodb::aql::Query* query,
                                  transaction::Methods* trx,
                                  VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "JSON_STRINGIFY", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(value, false);

  transaction::StringBufferLeaser buffer(trx);
  arangodb::basics::VPackStringBufferAdapter adapter(buffer->stringBuffer());

  VPackDumper dumper(&adapter, trx->transactionContextPtr()->getVPackOptions());
  dumper.dump(slice);

  return AqlValue(buffer->begin(), buffer->length());
}

/// @brief function JSON_PARSE
AqlValue Functions::JsonParse(arangodb::aql::Query* query,
                              transaction::Methods* trx,
                              VPackFunctionParameters const& parameters) {
  static char const* AFN = "JSON_PARSE";
  ValidateParameters(parameters, AFN, 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(value, false);
   
  if (!slice.isString()) { 
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }

  VPackValueLength l;
  char const* p = slice.getString(l);

  try {
    std::shared_ptr<VPackBuilder> builder = VPackParser::fromJson(p, l);
    return AqlValue(*builder);
  } catch (...) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }
}

/// @brief function PARSE_IDENTIFIER
AqlValue Functions::ParseIdentifier(arangodb::aql::Query* query,
                                    transaction::Methods* trx,
                                    VPackFunctionParameters const& parameters) {
  static char const* AFN = "PARSE_IDENTIFIER";
  ValidateParameters(parameters, AFN, 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);
  std::string identifier;
  if (value.isObject() && value.hasKey(trx, StaticStrings::IdString)) {
    bool localMustDestroy;
    AqlValue valueStr =
        value.get(trx, StaticStrings::IdString, localMustDestroy, false);
    AqlValueGuard guard(valueStr, localMustDestroy);

    if (valueStr.isString()) {
      identifier = valueStr.slice().copyString();
    }
  } else if (value.isString()) {
    identifier = value.slice().copyString();
  }

  if (identifier.empty()) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }

  std::vector<std::string> parts =
      arangodb::basics::StringUtils::split(identifier, "/");

  if (parts.size() != 2) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }

  transaction::BuilderLeaser builder(trx);
  builder->openObject();
  builder->add("collection", VPackValue(parts[0]));
  builder->add("key", VPackValue(parts[1]));
  builder->close();
  return AqlValue(builder.get());
}

/// @brief function Slice
AqlValue Functions::Slice(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  static char const* AFN = "SLICE";
  ValidateParameters(parameters, AFN, 2, 3);

  AqlValue baseArray = ExtractFunctionParameterValue(parameters, 0);

  if (!baseArray.isArray()) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }

  // determine lower bound
  AqlValue fromValue = ExtractFunctionParameterValue(parameters, 1);
  int64_t from = fromValue.toInt64(trx);
  if (from < 0) {
    from = baseArray.length() + from;
    if (from < 0) {
      from = 0;
    }
  }

  // determine upper bound
  AqlValue toValue = ExtractFunctionParameterValue(parameters, 2);
  int64_t to;
  if (toValue.isNull(true)) {
    to = baseArray.length();
  } else {
    to = toValue.toInt64(trx);
    if (to >= 0) {
      to += from;
    } else {
      // negative to value
      to = baseArray.length() + to;
      if (to < 0) {
        to = 0;
      }
    }
  }

  AqlValueMaterializer materializer(trx);
  VPackSlice arraySlice = materializer.slice(baseArray, false);

  transaction::BuilderLeaser builder(trx);
  builder->openArray();

  int64_t pos = 0;
  VPackArrayIterator it(arraySlice);
  while (it.valid()) {
    if (pos >= from && pos < to) {
      builder->add(it.value());
    }
    ++pos;
    if (pos >= to) {
      // done
      break;
    }
    it.next();
  }

  builder->close();
  return AqlValue(builder.get());
}

/// @brief function Minus
AqlValue Functions::Minus(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  static char const* AFN = "MINUS";
  ValidateParameters(parameters, AFN, 2);

  AqlValue baseArray = ExtractFunctionParameterValue(parameters, 0);

  if (!baseArray.isArray()) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }

  auto options = trx->transactionContextPtr()->getVPackOptions();
  std::unordered_map<VPackSlice, size_t,
                     arangodb::basics::VelocyPackHelper::VPackHash,
                     arangodb::basics::VelocyPackHelper::VPackEqual>
      contains(512, arangodb::basics::VelocyPackHelper::VPackHash(),
               arangodb::basics::VelocyPackHelper::VPackEqual(options));

  // Fill the original map
  AqlValueMaterializer materializer(trx);
  VPackSlice arraySlice = materializer.slice(baseArray, false);

  VPackArrayIterator it(arraySlice);
  while (it.valid()) {
    contains.emplace(it.value(), it.index());
    it.next();
  }

  // Iterate through all following parameters and delete found elements from the
  // map
  for (size_t k = 1; k < parameters.size(); ++k) {
    AqlValue next = ExtractFunctionParameterValue(parameters, k);
    if (!next.isArray()) {
      RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
      return AqlValue(AqlValueHintNull());
    }

    AqlValueMaterializer materializer(trx);
    VPackSlice arraySlice = materializer.slice(next, false);

    for (auto const& search : VPackArrayIterator(arraySlice)) {
      auto find = contains.find(search);

      if (find != contains.end()) {
        contains.erase(find);
      }
    }
  }

  // We omit the normalize part from js, cannot occur here
  transaction::BuilderLeaser builder(trx);
  builder->openArray();
  for (auto const& it : contains) {
    builder->add(it.first);
  }
  builder->close();
  return AqlValue(builder.get());
}

/// @brief function Document
AqlValue Functions::Document(arangodb::aql::Query* query,
                             transaction::Methods* trx,
                             VPackFunctionParameters const& parameters) {
  static char const* AFN = "DOCUMENT";
  ValidateParameters(parameters, AFN, 1, 2);

  if (parameters.size() == 1) {
    AqlValue id = ExtractFunctionParameterValue(parameters, 0);
    transaction::BuilderLeaser builder(trx);
    if (id.isString()) {
      std::string identifier(id.slice().copyString());
      std::string colName;
      GetDocumentByIdentifier(trx, colName, identifier, true, *builder.get());
      if (builder->isEmpty()) {
        // not found
        return AqlValue(AqlValueHintNull());
      }
      return AqlValue(builder.get());
    }
    if (id.isArray()) {
      AqlValueMaterializer materializer(trx);
      VPackSlice idSlice = materializer.slice(id, false);
      builder->openArray();
      for (auto const& next : VPackArrayIterator(idSlice)) {
        if (next.isString()) {
          std::string identifier = next.copyString();
          std::string colName;
          GetDocumentByIdentifier(trx, colName, identifier, true,
                                  *builder.get());
        }
      }
      builder->close();
      return AqlValue(builder.get());
    }
    return AqlValue(AqlValueHintNull());
  }

  AqlValue collectionValue = ExtractFunctionParameterValue(parameters, 0);
  if (!collectionValue.isString()) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }
  std::string collectionName(collectionValue.slice().copyString());

  AqlValue id = ExtractFunctionParameterValue(parameters, 1);
  if (id.isString()) {
    transaction::BuilderLeaser builder(trx);
    std::string identifier(id.slice().copyString());
    GetDocumentByIdentifier(trx, collectionName, identifier, true,
                            *builder.get());
    if (builder->isEmpty()) {
      return AqlValue(AqlValueHintNull());
    }
    return AqlValue(builder.get());
  }

  if (id.isArray()) {
    transaction::BuilderLeaser builder(trx);
    builder->openArray();

    AqlValueMaterializer materializer(trx);
    VPackSlice idSlice = materializer.slice(id, false);
    for (auto const& next : VPackArrayIterator(idSlice)) {
      if (next.isString()) {
        std::string identifier(next.copyString());
        GetDocumentByIdentifier(trx, collectionName, identifier, true,
                                *builder.get());
      }
    }

    builder->close();
    return AqlValue(builder.get());
  }

  // Id has invalid format
  return AqlValue(AqlValueHintNull());
}

/// @brief function MATCHES
AqlValue Functions::Matches(arangodb::aql::Query* query,
                            transaction::Methods* trx,
                            VPackFunctionParameters const& parameters) {
  static char const* AFN = "MATCHES";
  ValidateParameters(parameters, AFN, 2, 3);

  AqlValue docToFind = ExtractFunctionParameterValue(parameters, 0);

  if (!docToFind.isObject()) {
    return AqlValue(AqlValueHintBool(false));
  }

  AqlValue exampleDocs = ExtractFunctionParameterValue(parameters, 1);

  bool retIdx = false;
  if (parameters.size() == 3) {
    retIdx = ExtractFunctionParameterValue(parameters, 2).toBoolean();
  }

  AqlValueMaterializer materializer(trx);
  VPackSlice docSlice = materializer.slice(docToFind, false);

  transaction::BuilderLeaser builder(trx);
  VPackSlice examples = materializer.slice(exampleDocs, false);

  if (!examples.isArray()) {
    builder->openArray();
    builder->add(examples);
    builder->close();
    examples = builder->slice();
  }

  auto options = trx->transactionContextPtr()->getVPackOptions();

  bool foundMatch;
  int32_t idx = -1;

  for (auto const& example : VPackArrayIterator(examples)) {
    idx++;

    if (!example.isObject()) {
      RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
      continue;
    }

    foundMatch = true;

    for (auto const& it : VPackObjectIterator(example, true)) {
      std::string key = it.key.copyString();

      if (it.value.isNull() && !docSlice.hasKey(key)) {
        continue;
      }

      if (!docSlice.hasKey(key) ||
          // compare inner content
          basics::VelocyPackHelper::compare(docSlice.get(key), it.value, false,
                                            options, &docSlice,
                                            &example) != 0) {
        foundMatch = false;
        break;
      }
    }

    if (foundMatch) {
      if (retIdx) {
        return AqlValue(AqlValueHintInt(idx));
      } else {
        return AqlValue(AqlValueHintBool(true));
      }
    }
  }

  if (retIdx) {
    return AqlValue(AqlValueHintInt(-1));
  }

  return AqlValue(AqlValueHintBool(false));
}

/// @brief function ROUND
AqlValue Functions::Round(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "ROUND", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double input = value.toDouble(trx);

  // Rounds down for < x.4999 and up for > x.50000
  return NumberValue(trx, std::floor(input + 0.5), true);
}

/// @brief function ABS
AqlValue Functions::Abs(arangodb::aql::Query* query, transaction::Methods* trx,
                        VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "ABS", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double input = value.toDouble(trx);
  return NumberValue(trx, std::abs(input), true);
}

/// @brief function CEIL
AqlValue Functions::Ceil(arangodb::aql::Query* query, transaction::Methods* trx,
                         VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "CEIL", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double input = value.toDouble(trx);
  return NumberValue(trx, std::ceil(input), true);
}

/// @brief function FLOOR
AqlValue Functions::Floor(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "FLOOR", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double input = value.toDouble(trx);
  return NumberValue(trx, std::floor(input), true);
}

/// @brief function SQRT
AqlValue Functions::Sqrt(arangodb::aql::Query* query, transaction::Methods* trx,
                         VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "SQRT", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double input = value.toDouble(trx);
  return NumberValue(trx, std::sqrt(input), true);
}

/// @brief function POW
AqlValue Functions::Pow(arangodb::aql::Query* query, transaction::Methods* trx,
                        VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "POW", 2, 2);

  AqlValue baseValue = ExtractFunctionParameterValue(parameters, 0);
  AqlValue expValue = ExtractFunctionParameterValue(parameters, 1);

  double base = baseValue.toDouble(trx);
  double exp = expValue.toDouble(trx);

  return NumberValue(trx, std::pow(base, exp), true);
}

/// @brief function LOG
AqlValue Functions::Log(arangodb::aql::Query* query, transaction::Methods* trx,
                        VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "LOG", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double input = value.toDouble(trx);
  return NumberValue(trx, std::log(input), true);
}

/// @brief function LOG2
AqlValue Functions::Log2(arangodb::aql::Query* query, transaction::Methods* trx,
                         VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "LOG2", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double input = value.toDouble(trx);
  return NumberValue(trx, std::log2(input), true);
}

/// @brief function LOG10
AqlValue Functions::Log10(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "LOG10", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double input = value.toDouble(trx);
  return NumberValue(trx, std::log10(input), true);
}

/// @brief function EXP
AqlValue Functions::Exp(arangodb::aql::Query* query, transaction::Methods* trx,
                        VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "EXP", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double input = value.toDouble(trx);
  return NumberValue(trx, std::exp(input), true);
}

/// @brief function EXP2
AqlValue Functions::Exp2(arangodb::aql::Query* query, transaction::Methods* trx,
                         VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "EXP2", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double input = value.toDouble(trx);
  return NumberValue(trx, std::exp2(input), true);
}

/// @brief function SIN
AqlValue Functions::Sin(arangodb::aql::Query* query, transaction::Methods* trx,
                        VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "SIN", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double input = value.toDouble(trx);
  return NumberValue(trx, std::sin(input), true);
}

/// @brief function COS
AqlValue Functions::Cos(arangodb::aql::Query* query, transaction::Methods* trx,
                        VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "COS", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double input = value.toDouble(trx);
  return NumberValue(trx, std::cos(input), true);
}

/// @brief function TAN
AqlValue Functions::Tan(arangodb::aql::Query* query, transaction::Methods* trx,
                        VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "TAN", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double input = value.toDouble(trx);
  return NumberValue(trx, std::tan(input), true);
}

/// @brief function ASIN
AqlValue Functions::Asin(arangodb::aql::Query* query, transaction::Methods* trx,
                         VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "ASIN", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double input = value.toDouble(trx);
  return NumberValue(trx, std::asin(input), true);
}

/// @brief function ACOS
AqlValue Functions::Acos(arangodb::aql::Query* query, transaction::Methods* trx,
                         VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "ACOS", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double input = value.toDouble(trx);
  return NumberValue(trx, std::acos(input), true);
}

/// @brief function ATAN
AqlValue Functions::Atan(arangodb::aql::Query* query, transaction::Methods* trx,
                         VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "ATAN", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double input = value.toDouble(trx);
  return NumberValue(trx, std::atan(input), true);
}

/// @brief function ATAN2
AqlValue Functions::Atan2(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "ATAN2", 2, 2);

  AqlValue value1 = ExtractFunctionParameterValue(parameters, 0);
  AqlValue value2 = ExtractFunctionParameterValue(parameters, 1);

  double input1 = value1.toDouble(trx);
  double input2 = value2.toDouble(trx);
  return NumberValue(trx, std::atan2(input1, input2), true);
}

/// @brief function RADIANS
AqlValue Functions::Radians(arangodb::aql::Query* query,
                            transaction::Methods* trx,
                            VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "RADIANS", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double degrees = value.toDouble(trx);
  // acos(-1) == PI
  return NumberValue(trx, degrees * (std::acos(-1.0) / 180.0), true);
}

/// @brief function DEGREES
AqlValue Functions::Degrees(arangodb::aql::Query* query,
                            transaction::Methods* trx,
                            VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "DEGREES", 1, 1);

  AqlValue value = ExtractFunctionParameterValue(parameters, 0);

  double radians = value.toDouble(trx);
  // acos(-1) == PI
  return NumberValue(trx, radians * (180.0 / std::acos(-1.0)), true);
}

/// @brief function PI
AqlValue Functions::Pi(arangodb::aql::Query* query, transaction::Methods* trx,
                       VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "PI", 0, 0);

  // acos(-1) == PI
  return NumberValue(trx, std::acos(-1.0), true);
}

/// @brief function RAND
AqlValue Functions::Rand(arangodb::aql::Query* query, transaction::Methods* trx,
                         VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "RAND", 0, 0);

  // This random functionality is not too good yet...
  return NumberValue(trx, static_cast<double>(std::rand()) / RAND_MAX, true);
}

/// @brief function FIRST_DOCUMENT
AqlValue Functions::FirstDocument(arangodb::aql::Query* query,
                                  transaction::Methods* trx,
                                  VPackFunctionParameters const& parameters) {
  size_t const n = parameters.size();
  for (size_t i = 0; i < n; ++i) {
    AqlValue a = ExtractFunctionParameterValue(parameters, i);
    if (a.isObject()) {
      return a.clone();
    }
  }

  return AqlValue(AqlValueHintNull());
}

/// @brief function FIRST_LIST
AqlValue Functions::FirstList(arangodb::aql::Query* query,
                              transaction::Methods* trx,
                              VPackFunctionParameters const& parameters) {
  size_t const n = parameters.size();
  for (size_t i = 0; i < n; ++i) {
    AqlValue a = ExtractFunctionParameterValue(parameters, i);
    if (a.isArray()) {
      return a.clone();
    }
  }

  return AqlValue(AqlValueHintNull());
}

/// @brief function PUSH
AqlValue Functions::Push(arangodb::aql::Query* query, transaction::Methods* trx,
                         VPackFunctionParameters const& parameters) {
  static char const* AFN = "PUSH";
  ValidateParameters(parameters, AFN, 2, 3);
  
  AqlValue list = ExtractFunctionParameterValue(parameters, 0);
  AqlValue toPush = ExtractFunctionParameterValue(parameters, 1);

  AqlValueMaterializer toPushMaterializer(trx);
  VPackSlice p = toPushMaterializer.slice(toPush, false);

  if (list.isNull(true)) {
    transaction::BuilderLeaser builder(trx);
    builder->openArray();
    builder->add(p);
    builder->close();
    return AqlValue(builder.get());
  }

  if (!list.isArray()) {
    RegisterInvalidArgumentWarning(query, AFN);
    return AqlValue(AqlValueHintNull());
  }

  transaction::BuilderLeaser builder(trx);
  builder->openArray();
  AqlValueMaterializer materializer(trx);
  VPackSlice l = materializer.slice(list, false);

  for (auto const& it : VPackArrayIterator(l)) {
    builder->add(it);
  }
  if (parameters.size() == 3) {
    auto options = trx->transactionContextPtr()->getVPackOptions();
    AqlValue unique = ExtractFunctionParameterValue(parameters, 2);
    if (!unique.toBoolean() || !ListContainsElement(options, l, p)) {
      builder->add(p);
    }
  } else {
    builder->add(p);
  }
  builder->close();
  return AqlValue(builder.get());
}

/// @brief function POP
AqlValue Functions::Pop(arangodb::aql::Query* query, transaction::Methods* trx,
                        VPackFunctionParameters const& parameters) {
  static char const* AFN = "POP";
  ValidateParameters(parameters, AFN, 1, 1);
  AqlValue list = ExtractFunctionParameterValue(parameters, 0);

  if (list.isNull(true)) {
    return AqlValue(AqlValueHintNull());
  }

  if (!list.isArray()) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }

  AqlValueMaterializer materializer(trx);
  VPackSlice slice = materializer.slice(list, false);

  transaction::BuilderLeaser builder(trx);
  builder->openArray();
  auto iterator = VPackArrayIterator(slice);
  while (iterator.valid() && !iterator.isLast()) {
    builder->add(iterator.value());
    iterator.next();
  }
  builder->close();
  return AqlValue(builder.get());
}

/// @brief function APPEND
AqlValue Functions::Append(arangodb::aql::Query* query,
                           transaction::Methods* trx,
                           VPackFunctionParameters const& parameters) {
  static char const* AFN = "APPEND";
  ValidateParameters(parameters, AFN, 2, 3);
  AqlValue list = ExtractFunctionParameterValue(parameters, 0);
  AqlValue toAppend = ExtractFunctionParameterValue(parameters, 1);

  if (toAppend.isNull(true)) {
    return list.clone();
  }

  AqlValueMaterializer toAppendMaterializer(trx);
  VPackSlice t = toAppendMaterializer.slice(toAppend, false);

  if (t.isArray() && t.length() == 0) {
    return list.clone();
  }

  bool unique = false;
  if (parameters.size() == 3) {
    AqlValue a = ExtractFunctionParameterValue(parameters, 2);
    unique = a.toBoolean();
  }

  AqlValueMaterializer materializer(trx);
  VPackSlice l = materializer.slice(list, false);

  if (l.isNull()) {
    return toAppend.clone();
  }

  if (!l.isArray()) {
    RegisterInvalidArgumentWarning(query, AFN);
    return AqlValue(AqlValueHintNull());
  }

  std::unordered_set<VPackSlice> added;

  transaction::BuilderLeaser builder(trx);
  builder->openArray();

  for (auto const& it : VPackArrayIterator(l)) {
    if (unique) {
      if (added.find(it) == added.end()) {
        builder->add(it);
        added.emplace(it);
      }
    } else {
      builder->add(it);
    }
  }

  AqlValueMaterializer materializer2(trx);
  VPackSlice slice = materializer2.slice(toAppend, false);

  if (!slice.isArray()) {
    if (!unique || added.find(slice) == added.end()) {
      builder->add(slice);
    }
  } else {
    for (auto const& it : VPackArrayIterator(slice)) {
      if (unique) {
        if (added.find(it) == added.end()) {
          builder->add(it);
          added.emplace(it);
        }
      } else {
        builder->add(it);
      }
    }
  }
  builder->close();
  return AqlValue(builder.get());
}

/// @brief function UNSHIFT
AqlValue Functions::Unshift(arangodb::aql::Query* query,
                            transaction::Methods* trx,
                            VPackFunctionParameters const& parameters) {
  static char const* AFN = "UNSHIFT";
  ValidateParameters(parameters, AFN, 2, 3);
  AqlValue list = ExtractFunctionParameterValue(parameters, 0);

  if (!list.isNull(true) && !list.isArray()) {
    RegisterInvalidArgumentWarning(query, AFN);
    return AqlValue(AqlValueHintNull());
  }

  AqlValue toAppend = ExtractFunctionParameterValue(parameters, 1);
  bool unique = false;
  if (parameters.size() == 3) {
    AqlValue a = ExtractFunctionParameterValue(parameters, 2);
    unique = a.toBoolean();
  }

  auto options = trx->transactionContextPtr()->getVPackOptions();
  size_t unused;
  if (unique && list.isArray() &&
      ListContainsElement(trx, options, list, toAppend, unused)) {
    // Short circuit, nothing to do return list
    return list.clone();
  }

  AqlValueMaterializer materializer(trx);
  VPackSlice a = materializer.slice(toAppend, false);

  transaction::BuilderLeaser builder(trx);
  builder->openArray();
  builder->add(a);

  if (list.isArray()) {
    AqlValueMaterializer materializer(trx);
    VPackSlice v = materializer.slice(list, false);
    for (auto const& it : VPackArrayIterator(v)) {
      builder->add(it);
    }
  }
  builder->close();
  return AqlValue(builder.get());
}

/// @brief function SHIFT
AqlValue Functions::Shift(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  static char const* AFN = "SHIFT";
  ValidateParameters(parameters, AFN, 1, 1);

  AqlValue list = ExtractFunctionParameterValue(parameters, 0);
  if (list.isNull(true)) {
    return AqlValue(AqlValueHintNull());
  }

  if (!list.isArray()) {
    RegisterInvalidArgumentWarning(query, AFN);
    return AqlValue(AqlValueHintNull());
  }

  transaction::BuilderLeaser builder(trx);
  builder->openArray();

  if (list.length() > 0) {
    AqlValueMaterializer materializer(trx);
    VPackSlice l = materializer.slice(list, false);

    auto iterator = VPackArrayIterator(l);
    // This jumps over the first element
    iterator.next();
    while (iterator.valid()) {
      builder->add(iterator.value());
      iterator.next();
    }
  }
  builder->close();

  return AqlValue(builder.get());
}

/// @brief function REMOVE_VALUE
AqlValue Functions::RemoveValue(arangodb::aql::Query* query,
                                transaction::Methods* trx,
                                VPackFunctionParameters const& parameters) {
  static char const* AFN = "REMOVE_VALUE";
  ValidateParameters(parameters, AFN, 2, 3);

  AqlValue list = ExtractFunctionParameterValue(parameters, 0);

  if (list.isNull(true)) {
    return AqlValue(arangodb::basics::VelocyPackHelper::EmptyArrayValue());
  }

  if (!list.isArray()) {
    RegisterInvalidArgumentWarning(query, AFN);
    return AqlValue(AqlValueHintNull());
  }

  auto options = trx->transactionContextPtr()->getVPackOptions();

  transaction::BuilderLeaser builder(trx);
  builder->openArray();
  bool useLimit = false;
  int64_t limit = list.length();

  if (parameters.size() == 3) {
    AqlValue limitValue = ExtractFunctionParameterValue(parameters, 2);
    if (!limitValue.isNull(true)) {
      limit = limitValue.toInt64(trx);
      useLimit = true;
    }
  }

  AqlValue toRemove = ExtractFunctionParameterValue(parameters, 1);
  AqlValueMaterializer toRemoveMaterializer(trx);
  VPackSlice r = toRemoveMaterializer.slice(toRemove, false);

  AqlValueMaterializer materializer(trx);
  VPackSlice v = materializer.slice(list, false);

  for (auto const& it : VPackArrayIterator(v)) {
    if (useLimit && limit == 0) {
      // Just copy
      builder->add(it);
      continue;
    }
    if (arangodb::basics::VelocyPackHelper::compare(r, it, false, options) ==
        0) {
      --limit;
      continue;
    }
    builder->add(it);
  }
  builder->close();
  return AqlValue(builder.get());
}

/// @brief function REMOVE_VALUES
AqlValue Functions::RemoveValues(arangodb::aql::Query* query,
                                 transaction::Methods* trx,
                                 VPackFunctionParameters const& parameters) {
  static char const* AFN = "REMOVE_VALUES";
  ValidateParameters(parameters, AFN, 2, 2);

  AqlValue list = ExtractFunctionParameterValue(parameters, 0);
  AqlValue values = ExtractFunctionParameterValue(parameters, 1);

  if (values.isNull(true)) {
    return list.clone();
  }

  if (list.isNull(true)) {
    return AqlValue(arangodb::basics::VelocyPackHelper::EmptyArrayValue());
  }

  if (!list.isArray() || !values.isArray()) {
    RegisterInvalidArgumentWarning(query, AFN);
    return AqlValue(AqlValueHintNull());
  }

  auto options = trx->transactionContextPtr()->getVPackOptions();
  AqlValueMaterializer valuesMaterializer(trx);
  VPackSlice v = valuesMaterializer.slice(values, false);

  AqlValueMaterializer listMaterializer(trx);
  VPackSlice l = listMaterializer.slice(list, false);

  transaction::BuilderLeaser builder(trx);
  builder->openArray();
  for (auto const& it : VPackArrayIterator(l)) {
    if (!ListContainsElement(options, v, it)) {
      builder->add(it);
    }
  }
  builder->close();
  return AqlValue(builder.get());
}

/// @brief function REMOVE_NTH
AqlValue Functions::RemoveNth(arangodb::aql::Query* query,
                              transaction::Methods* trx,
                              VPackFunctionParameters const& parameters) {
  static char const* AFN = "REMOVE_NTH";
  ValidateParameters(parameters, AFN, 2, 2);

  AqlValue list = ExtractFunctionParameterValue(parameters, 0);

  if (list.isNull(true)) {
    return AqlValue(arangodb::basics::VelocyPackHelper::EmptyArrayValue());
  }

  if (!list.isArray()) {
    RegisterInvalidArgumentWarning(query, AFN);
    return AqlValue(AqlValueHintNull());
  }

  double const count = static_cast<double>(list.length());
  AqlValue position = ExtractFunctionParameterValue(parameters, 1);
  double p = position.toDouble(trx);
  if (p >= count || p < -count) {
    // out of bounds
    return list.clone();
  }

  if (p < 0) {
    p += count;
  }

  AqlValueMaterializer materializer(trx);
  VPackSlice v = materializer.slice(list, false);

  transaction::BuilderLeaser builder(trx);
  size_t target = static_cast<size_t>(p);
  size_t cur = 0;
  builder->openArray();
  for (auto const& it : VPackArrayIterator(v)) {
    if (cur != target) {
      builder->add(it);
    }
    cur++;
  }
  builder->close();
  return AqlValue(builder.get());
}

/// @brief function NOT_NULL
AqlValue Functions::NotNull(arangodb::aql::Query* query,
                            transaction::Methods* trx,
                            VPackFunctionParameters const& parameters) {
  size_t const n = parameters.size();
  for (size_t i = 0; i < n; ++i) {
    AqlValue element = ExtractFunctionParameterValue(parameters, i);
    if (!element.isNull(true)) {
      return element.clone();
    }
  }
  return AqlValue(AqlValueHintNull());
}

/// @brief function CURRENT_DATABASE
AqlValue Functions::CurrentDatabase(arangodb::aql::Query* query,
                                    transaction::Methods* trx,
                                    VPackFunctionParameters const& parameters) {
  ValidateParameters(parameters, "CURRENT_DATABASE", 0, 0);

  return AqlValue(query->vocbase()->name());
}

/// @brief function COLLECTION_COUNT
AqlValue Functions::CollectionCount(arangodb::aql::Query* query,
                                    transaction::Methods* trx,
                                    VPackFunctionParameters const& parameters) {
  static char const* AFN = "COLLECTION_COUNT";
  ValidateParameters(parameters, AFN, 1, 1);

  AqlValue element = ExtractFunctionParameterValue(parameters, 0);
  if (!element.isString()) {
    THROW_ARANGO_EXCEPTION_PARAMS(
        TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH, AFN);
  }

  TRI_ASSERT(ServerState::instance()->isSingleServerOrCoordinator());
  std::string const collectionName = element.slice().copyString();
  OperationResult res = trx->count(collectionName, true);
  if (res.fail()) {
    THROW_ARANGO_EXCEPTION(res.result);
  }

  return AqlValue(res.slice());
}

/// @brief function VARIANCE_SAMPLE
AqlValue Functions::VarianceSample(arangodb::aql::Query* query,
                                   transaction::Methods* trx,
                                   VPackFunctionParameters const& parameters) {
  static char const* AFN = "VARIANCE_SAMPLE";
  ValidateParameters(parameters, AFN, 1, 1);

  AqlValue list = ExtractFunctionParameterValue(parameters, 0);

  if (!list.isArray()) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_ARRAY_EXPECTED);
    return AqlValue(AqlValueHintNull());
  }

  double value = 0.0;
  size_t count = 0;

  if (!Variance(trx, list, value, count)) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_INVALID_ARITHMETIC_VALUE);
    return AqlValue(AqlValueHintNull());
  }

  if (count < 2) {
    return AqlValue(AqlValueHintNull());
  }

  return NumberValue(trx, value / (count - 1), true);
}

/// @brief function VARIANCE_POPULATION
AqlValue Functions::VariancePopulation(
    arangodb::aql::Query* query, transaction::Methods* trx,
    VPackFunctionParameters const& parameters) {
  static char const* AFN = "VARIANCE_POPULATION";
  ValidateParameters(parameters, AFN, 1, 1);

  AqlValue list = ExtractFunctionParameterValue(parameters, 0);

  if (!list.isArray()) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_ARRAY_EXPECTED);
    return AqlValue(AqlValueHintNull());
  }

  double value = 0.0;
  size_t count = 0;

  if (!Variance(trx, list, value, count)) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_INVALID_ARITHMETIC_VALUE);
    return AqlValue(AqlValueHintNull());
  }

  if (count < 1) {
    return AqlValue(AqlValueHintNull());
  }

  return NumberValue(trx, value / count, true);
}

/// @brief function STDDEV_SAMPLE
AqlValue Functions::StdDevSample(arangodb::aql::Query* query,
                                 transaction::Methods* trx,
                                 VPackFunctionParameters const& parameters) {
  static char const* AFN = "STDDEV_SAMPLE";
  ValidateParameters(parameters, AFN, 1, 1);

  AqlValue list = ExtractFunctionParameterValue(parameters, 0);

  if (!list.isArray()) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_ARRAY_EXPECTED);
    return AqlValue(AqlValueHintNull());
  }

  double value = 0.0;
  size_t count = 0;

  if (!Variance(trx, list, value, count)) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_INVALID_ARITHMETIC_VALUE);
    return AqlValue(AqlValueHintNull());
  }

  if (count < 2) {
    return AqlValue(AqlValueHintNull());
  }

  return NumberValue(trx, std::sqrt(value / (count - 1)), true);
}

/// @brief function STDDEV_POPULATION
AqlValue Functions::StdDevPopulation(
    arangodb::aql::Query* query, transaction::Methods* trx,
    VPackFunctionParameters const& parameters) {
  static char const* AFN = "STDDEV_POPULATION";
  ValidateParameters(parameters, AFN, 1, 1);

  AqlValue list = ExtractFunctionParameterValue(parameters, 0);

  if (!list.isArray()) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_ARRAY_EXPECTED);
    return AqlValue(AqlValueHintNull());
  }

  double value = 0.0;
  size_t count = 0;

  if (!Variance(trx, list, value, count)) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_INVALID_ARITHMETIC_VALUE);
    return AqlValue(AqlValueHintNull());
  }

  if (count < 1) {
    return AqlValue(AqlValueHintNull());
  }

  return NumberValue(trx, std::sqrt(value / count), true);
}

/// @brief function MEDIAN
AqlValue Functions::Median(arangodb::aql::Query* query,
                           transaction::Methods* trx,
                           VPackFunctionParameters const& parameters) {
  static char const* AFN = "MEDIAN";
  ValidateParameters(parameters, AFN, 1, 1);

  AqlValue list = ExtractFunctionParameterValue(parameters, 0);

  if (!list.isArray()) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_ARRAY_EXPECTED);
    return AqlValue(AqlValueHintNull());
  }

  std::vector<double> values;
  if (!SortNumberList(trx, list, values)) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_INVALID_ARITHMETIC_VALUE);
    return AqlValue(AqlValueHintNull());
  }

  if (values.empty()) {
    return AqlValue(AqlValueHintNull());
  }
  size_t const l = values.size();
  size_t midpoint = l / 2;

  if (l % 2 == 0) {
    return NumberValue(trx, (values[midpoint - 1] + values[midpoint]) / 2,
                       true);
  }
  return NumberValue(trx, values[midpoint], true);
}

/// @brief function PERCENTILE
AqlValue Functions::Percentile(arangodb::aql::Query* query,
                               transaction::Methods* trx,
                               VPackFunctionParameters const& parameters) {
  static char const* AFN = "PERCENTILE";
  ValidateParameters(parameters, AFN, 2, 3);

  AqlValue list = ExtractFunctionParameterValue(parameters, 0);

  if (!list.isArray()) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_ARRAY_EXPECTED);
    return AqlValue(AqlValueHintNull());
  }

  AqlValue border = ExtractFunctionParameterValue(parameters, 1);

  if (!border.isNumber()) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }

  bool unused = false;
  double p = border.toDouble(trx, unused);
  if (p <= 0.0 || p > 100.0) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }

  bool useInterpolation = false;

  if (parameters.size() == 3) {
    AqlValue methodValue = ExtractFunctionParameterValue(parameters, 2);
    if (!methodValue.isString()) {
      RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
      return AqlValue(AqlValueHintNull());
    }
    std::string method = methodValue.slice().copyString();
    if (method == "interpolation") {
      useInterpolation = true;
    } else if (method == "rank") {
      useInterpolation = false;
    } else {
      RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
      return AqlValue(AqlValueHintNull());
    }
  }

  std::vector<double> values;
  if (!SortNumberList(trx, list, values)) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_INVALID_ARITHMETIC_VALUE);
    return AqlValue(AqlValueHintNull());
  }

  if (values.empty()) {
    return AqlValue(AqlValueHintNull());
  }

  size_t l = values.size();
  if (l == 1) {
    return NumberValue(trx, values[0], true);
  }

  TRI_ASSERT(l > 1);

  if (useInterpolation) {
    double const idx = p * (l + 1) / 100.0;
    double const pos = floor(idx);

    if (pos >= l) {
      return NumberValue(trx, values[l - 1], true);
    }
    if (pos <= 0) {
      return AqlValue(AqlValueHintNull());
    }

    double const delta = idx - pos;
    return NumberValue(trx, delta * (values[static_cast<size_t>(pos)] -
                                     values[static_cast<size_t>(pos) - 1]) +
                                values[static_cast<size_t>(pos) - 1],
                       true);
  }

  double const idx = p * l / 100.0;
  double const pos = ceil(idx);
  if (pos >= l) {
    return NumberValue(trx, values[l - 1], true);
  }
  if (pos <= 0) {
    return AqlValue(AqlValueHintNull());
  }

  return NumberValue(trx, values[static_cast<size_t>(pos) - 1], true);
}

/// @brief function RANGE
AqlValue Functions::Range(arangodb::aql::Query* query,
                          transaction::Methods* trx,
                          VPackFunctionParameters const& parameters) {
  static char const* AFN = "RANGE";
  ValidateParameters(parameters, AFN, 2, 3);

  AqlValue left = ExtractFunctionParameterValue(parameters, 0);
  AqlValue right = ExtractFunctionParameterValue(parameters, 1);

  double from = left.toDouble(trx);
  double to = right.toDouble(trx);

  if (parameters.size() < 3) {
    return AqlValue(left.toInt64(trx), right.toInt64(trx));
  }

  AqlValue stepValue = ExtractFunctionParameterValue(parameters, 2);
  if (stepValue.isNull(true)) {
    // no step specified. return a real range object
    return AqlValue(left.toInt64(trx), right.toInt64(trx));
  }

  double step = stepValue.toDouble(trx);

  if (step == 0.0 || (from < to && step < 0.0) || (from > to && step > 0.0)) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
    return AqlValue(AqlValueHintNull());
  }

  transaction::BuilderLeaser builder(trx);
  builder->openArray();
  if (step < 0.0 && to <= from) {
    for (; from >= to; from += step) {
      builder->add(VPackValue(from));
    }
  } else {
    for (; from <= to; from += step) {
      builder->add(VPackValue(from));
    }
  }
  builder->close();
  return AqlValue(builder.get());
}

/// @brief function POSITION
AqlValue Functions::Position(arangodb::aql::Query* query,
                             transaction::Methods* trx,
                             VPackFunctionParameters const& parameters) {
  static char const* AFN = "POSITION";
  ValidateParameters(parameters, AFN, 2, 3);

  AqlValue list = ExtractFunctionParameterValue(parameters, 0);

  if (!list.isArray()) {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_ARRAY_EXPECTED);
    return AqlValue(AqlValueHintNull());
  }

  bool returnIndex = false;
  if (parameters.size() == 3) {
    AqlValue a = ExtractFunctionParameterValue(parameters, 2);
    returnIndex = a.toBoolean();
  }

  if (list.length() > 0) {
    AqlValue searchValue = ExtractFunctionParameterValue(parameters, 1);
    auto options = trx->transactionContextPtr()->getVPackOptions();

    size_t index;
    if (ListContainsElement(trx, options, list, searchValue, index)) {
      if (!returnIndex) {
        // return true
        return AqlValue(arangodb::basics::VelocyPackHelper::TrueValue());
      }
      // return position
      transaction::BuilderLeaser builder(trx);
      builder->add(VPackValue(index));
      return AqlValue(builder.get());
    }
  }

  // not found
  if (!returnIndex) {
    // return false
    return AqlValue(arangodb::basics::VelocyPackHelper::FalseValue());
  }

  // return -1
  transaction::BuilderLeaser builder(trx);
  builder->add(VPackValue(-1));
  return AqlValue(builder.get());
}

/// @brief function IS_SAME_COLLECTION
AqlValue Functions::IsSameCollection(
    arangodb::aql::Query* query, transaction::Methods* trx,
    VPackFunctionParameters const& parameters) {
  static char const* AFN = "IS_SAME_COLLECTION";
  ValidateParameters(parameters, AFN, 2, 2);

  std::string const first = ExtractCollectionName(trx, parameters, 0);
  std::string const second = ExtractCollectionName(trx, parameters, 1);

  if (!first.empty() && !second.empty()) {
    return AqlValue(AqlValueHintBool(first == second));
  }

  RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH);
  return AqlValue(AqlValueHintNull());
}

AqlValue Functions::PregelResult(arangodb::aql::Query* query,
                                 transaction::Methods* trx,
                                 VPackFunctionParameters const& parameters) {
  static char const* AFN = "PREGEL_RESULT";
  ValidateParameters(parameters, AFN, 1, 1);
  
  AqlValue arg1 = ExtractFunctionParameterValue(parameters, 0);
  if (!arg1.isNumber()) {
    THROW_ARANGO_EXCEPTION_PARAMS(TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH, AFN);
  }

  uint64_t execNr = arg1.toInt64(trx);
  pregel::PregelFeature* feature = pregel::PregelFeature::instance();
  if (feature) {
    std::shared_ptr<pregel::IWorker> worker = feature->worker(execNr);
    if (!worker) {
      RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_INVALID_CODE);
      return AqlValue(arangodb::basics::VelocyPackHelper::EmptyArrayValue());
    }
    transaction::BuilderLeaser builder(trx);
    worker->aqlResult(builder.get());
    return AqlValue(builder.get());
  } else {
    RegisterWarning(query, AFN, TRI_ERROR_QUERY_FUNCTION_INVALID_CODE);
    return AqlValue(arangodb::basics::VelocyPackHelper::EmptyArrayValue());
  }
}

AqlValue Functions::Assert(arangodb::aql::Query* query,
                           transaction::Methods* trx,
                           VPackFunctionParameters const& parameters) {
  static char const* AFN = "ASSERT";
  ValidateParameters(parameters, AFN, 2, 2);
  auto const expr = ExtractFunctionParameterValue(parameters, 0);
  auto const message = ExtractFunctionParameterValue(parameters, 1);

  if (!message.isString()) {
    RegisterInvalidArgumentWarning(query, AFN);
    return AqlValue(AqlValueHintNull());
  }
  if (!expr.toBoolean()) {
    std::string msg = message.slice().copyString();
    query->registerError(TRI_ERROR_QUERY_USER_ASSERT, msg.data());
  }
  return AqlValue(AqlValueHintBool(true));
}

AqlValue Functions::Warn(arangodb::aql::Query* query, transaction::Methods* trx,
                         VPackFunctionParameters const& parameters) {
  static char const* AFN = "WARN";
  ValidateParameters(parameters, AFN, 2, 2);
  auto const expr = ExtractFunctionParameterValue(parameters, 0);
  auto const message = ExtractFunctionParameterValue(parameters, 1);

  if (!message.isString()) {
    RegisterInvalidArgumentWarning(query, AFN);
    return AqlValue(AqlValueHintNull());
  }

  if (!expr.toBoolean()) {
    std::string msg = message.slice().copyString();
    query->registerWarning(TRI_ERROR_QUERY_USER_WARN, msg.data());
    return AqlValue(AqlValueHintBool(false));
  }
  return AqlValue(AqlValueHintBool(true));
}