Function getVectorFunction

bolt/expression/VectorFunction.cpp:71–113

}

std::shared_ptr<VectorFunction> getVectorFunction(
    const std::string& name,
    const std::vector<TypePtr>& inputTypes,
    const std::vector<VectorPtr>& constantInputs,
    const core::QueryConfig& config,
    const TypePtr& resultType) {
  auto sanitizedName = sanitizeName(name);

  if (!constantInputs.empty()) {
    BOLT_CHECK_EQ(inputTypes.size(), constantInputs.size());
  }

  // Zip `inputTypes` and `constantInputs` vectors into a single vector of
  // `VectorFunctionArg`.
  std::vector<VectorFunctionArg> inputArgs;
  inputArgs.reserve(inputTypes.size());

  for (vector_size_t i = 0; i < inputTypes.size(); ++i) {
    inputArgs.push_back({
        inputTypes[i],
        constantInputs.size() > i ? constantInputs[i] : nullptr,
    });
  }

  return vectorFunctionFactories().withRLock(
      [&sanitizedName, &inputArgs, &config, &inputTypes, &resultType, &name](
          auto& functionMap) -> std::shared_ptr<VectorFunction> {
        if (auto destType = resolveVectorFunction(sanitizedName, inputTypes)) {
          BOLT_USER_CHECK(
              (resultType == nullptr ||
               (destType != nullptr && destType->equivalent(*resultType))),
              "Found incompatible return types for vector function '{}' ({} vs. {}) with input types ({}).",
              name,
              destType,
              resultType,
              folly::join(", ", inputTypes));
          auto functionIterator = functionMap.find(sanitizedName);
          return functionIterator->second.factory(
              sanitizedName, inputArgs, config);
        }
        return nullptr;
      });
}

/// Registers a new vector function. When overwrite = true, previous functions
/// with the given name will be replaced.