Function BindNonRecursive

cpp/src/arrow/compute/expression.cc:539–603

Produce a bound Expression from unbound Call and bound arguments.

// Produce a bound Expression from unbound Call and bound arguments.
Result<Expression> BindNonRecursive(Expression::Call call, bool insert_implicit_casts,
                                    compute::ExecContext* exec_context) {
  DCHECK(std::all_of(call.arguments.begin(), call.arguments.end(),
                     [](const Expression& argument) { return argument.IsBound(); }));

  std::vector<TypeHolder> types = GetTypes(call.arguments);
  ARROW_ASSIGN_OR_RAISE(call.function, GetFunction(call, exec_context));

  // First try and bind exactly
  Result<const Kernel*> maybe_exact_match = call.function->DispatchExact(types);
  if (maybe_exact_match.ok()) {
    call.kernel = *maybe_exact_match;
  } else {
    if (!insert_implicit_casts) {
      return maybe_exact_match.status();
    }

    // If exact binding fails, and we are allowed to cast, then prefer casting literals
    // first.  Since DispatchBest generally prefers up-casting the best way to do this is
    // first down-cast the literals as much as possible
    types = GetTypesWithSmallestLiteralRepresentation(call.arguments);
    ARROW_ASSIGN_OR_RAISE(call.kernel, call.function->DispatchBest(&types));

    for (size_t i = 0; i < types.size(); ++i) {
      if (types[i] == call.arguments[i].type()) continue;

      if (const Datum* lit = call.arguments[i].literal()) {
        ARROW_ASSIGN_OR_RAISE(Datum new_lit,
                              compute::Cast(*lit, types[i].GetSharedPtr()));
        call.arguments[i] = literal(std::move(new_lit));
        continue;
      }

      // construct an implicit cast Expression with which to replace this argument
      Expression::Call implicit_cast;
      implicit_cast.function_name = "cast";
      implicit_cast.arguments = {std::move(call.arguments[i])};

      // TODO(wesm): Use TypeHolder in options
      implicit_cast.options = std::make_shared<compute::CastOptions>(
          compute::CastOptions::Safe(types[i].GetSharedPtr()));

      ARROW_ASSIGN_OR_RAISE(
          call.arguments[i],
          BindNonRecursive(std::move(implicit_cast),
                           /*insert_implicit_casts=*/false, exec_context));
    }
  }

  compute::KernelContext kernel_context(exec_context, call.kernel);
  if (call.kernel->init) {
    const FunctionOptions* options =
        call.options ? call.options.get() : call.function->default_options();
    ARROW_ASSIGN_OR_RAISE(
        call.kernel_state,
        call.kernel->init(&kernel_context, {call.kernel, types, options}));

    kernel_context.SetState(call.kernel_state.get());