diff --git a/velox/benchmarks/basic/Preproc.cpp b/velox/benchmarks/basic/Preproc.cpp
index 74f4d1f0f74c..aa7e3fe4a06f 100644
--- a/velox/benchmarks/basic/Preproc.cpp
+++ b/velox/benchmarks/basic/Preproc.cpp
@@ -39,8 +39,8 @@ class BaseFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& resultType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     if (args[0]->isConstantEncoding() &&
         args[1]->encoding() == VectorEncoding::Simple::FLAT) {
       // Fast path for (flat, const).
@@ -51,7 +51,7 @@ class BaseFunction : public exec::VectorFunction {
       auto rawResults =
           getRawResults(rows, args[1], rawValues, resultType, context, result);
 
-      context->applyToSelectedNoThrow(rows, [&](auto row) {
+      context.applyToSelectedNoThrow(rows, [&](auto row) {
         rawResults[row] = Operation::apply(constant, rawValues[row]);
       });
     } else if (
@@ -65,7 +65,7 @@ class BaseFunction : public exec::VectorFunction {
       auto rawResults =
           getRawResults(rows, args[0], rawValues, resultType, context, result);
 
-      context->applyToSelectedNoThrow(rows, [&](auto row) {
+      context.applyToSelectedNoThrow(rows, [&](auto row) {
         rawResults[row] = Operation::apply(rawValues[row], constant);
       });
     } else if (
@@ -78,20 +78,20 @@ class BaseFunction : public exec::VectorFunction {
       auto rawB = flatB->mutableRawValues();
 
       T* rawResults = nullptr;
-      if (!(*result)) {
+      if (!result) {
         if (BaseVector::isReusableFlatVector(args[0])) {
           rawResults = rawA;
-          *result = std::move(args[0]);
+          result = std::move(args[0]);
         } else if (BaseVector::isReusableFlatVector(args[1])) {
           rawResults = rawB;
-          *result = std::move(args[1]);
+          result = std::move(args[1]);
         }
       }
       if (!rawResults) {
         rawResults = prepareResults(rows, resultType, context, result);
       }
 
-      context->applyToSelectedNoThrow(rows, [&](auto row) {
+      context.applyToSelectedNoThrow(rows, [&](auto row) {
         rawResults[row] = Operation::apply(rawA[row], rawB[row]);
       });
     } else {
@@ -100,11 +100,11 @@ class BaseFunction : public exec::VectorFunction {
       auto a = decodedArgs.at(0);
       auto b = decodedArgs.at(1);
 
-      BaseVector::ensureWritable(rows, resultType, context->pool(), result);
+      BaseVector::ensureWritable(rows, resultType, context.pool(), result);
       auto rawResults =
-          (*result)->asUnchecked<FlatVector<T>>()->mutableRawValues();
+          result->asUnchecked<FlatVector<T>>()->mutableRawValues();
 
-      context->applyToSelectedNoThrow(rows, [&](auto row) {
+      context.applyToSelectedNoThrow(rows, [&](auto row) {
         rawResults[row] =
             Operation::apply(a->valueAt<T>(row), b->valueAt<T>(row));
       });
@@ -115,11 +115,11 @@ class BaseFunction : public exec::VectorFunction {
   T* prepareResults(
       const SelectivityVector& rows,
       const TypePtr& resultType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const {
-    BaseVector::ensureWritable(rows, resultType, context->pool(), result);
-    (*result)->clearNulls(rows);
-    return (*result)->asUnchecked<FlatVector<T>>()->mutableRawValues();
+      exec::EvalCtx& context,
+      VectorPtr& result) const {
+    BaseVector::ensureWritable(rows, resultType, context.pool(), result);
+    result->clearNulls(rows);
+    return result->asUnchecked<FlatVector<T>>()->mutableRawValues();
   }
 
   T* getRawResults(
@@ -127,13 +127,13 @@ class BaseFunction : public exec::VectorFunction {
       VectorPtr& flat,
       T* rawValues,
       const TypePtr& resultType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const {
+      exec::EvalCtx& context,
+      VectorPtr& result) const {
     // Check if input can be reused for results.
     T* rawResults;
-    if (!(*result) && BaseVector::isReusableFlatVector(flat)) {
+    if (!result && BaseVector::isReusableFlatVector(flat)) {
       rawResults = rawValues;
-      *result = std::move(flat);
+      result = std::move(flat);
     } else {
       rawResults = prepareResults(rows, resultType, context, result);
     }
diff --git a/velox/docs/develop/lambda-functions.rst b/velox/docs/develop/lambda-functions.rst
index 32213acf8757..19dd2e258395 100644
--- a/velox/docs/develop/lambda-functions.rst
+++ b/velox/docs/develop/lambda-functions.rst
@@ -48,7 +48,7 @@ to "b":
 .. code-block:: sql
 
     > select filter(a, x -> x >= b)
-    
+
     [3, 4]
     [5, 6, 7]
 
@@ -86,7 +86,7 @@ compact form. In most cases lambda expression is the same for all rows, but it
 is possible for different rows to be associated with different lambdas as we
 have seen above. FunctionVector stores a list of different lambdas along with a
 set of rows each lambda applies to. Each lambda is represented as an object of
-type Callable which allows for evaluating the lambda on a set of rows. 
+type Callable which allows for evaluating the lambda on a set of rows.
 
 .. code-block:: c++
 
@@ -96,9 +96,9 @@ type Callable which allows for evaluating the lambda on a set of rows.
       void apply(
           const SelectivityVector& rows,
           BufferPtr wrapCapture,
-          exec::EvalCtx* context,
+          exec::EvalCtx& context,
           const std::vector<VectorPtr>& args,
-          VectorPtr* result);
+          VectorPtr& result);
     };
 
 The "apply" method of Callable is similar to the "apply" method of
@@ -210,20 +210,20 @@ in a test:
 .. code-block:: c++
 
   auto rowType = ROW({"a", "b"}, {ARRAY(BIGINT()), BIGINT()});
-  
+
   registerLambda("lambda", ROW({"x"}, {BIGINT()}), rowType, "x >= b"));
 
   auto result =
       evaluate<BaseVector>("filter(a, function('lambda'))", data);
 
 The first argument to registerLambda is the name for the lambda. This name can
-later be used to refer to the lambda in a function call. 
+later be used to refer to the lambda in a function call.
 
 The second argument is the signature of the lambda, e.g. the list of lambda
-parameters along with their names and types. 
+parameters along with their names and types.
 
 The third argument is the type of the input data to the overall expression. This
-is used to resolve the types of captures. 
+is used to resolve the types of captures.
 
 The last argument is the lambda body as SQL expression.
 
diff --git a/velox/docs/develop/scalar-functions.rst b/velox/docs/develop/scalar-functions.rst
index 38f061e96772..92a0ea610365 100644
--- a/velox/docs/develop/scalar-functions.rst
+++ b/velox/docs/develop/scalar-functions.rst
@@ -803,8 +803,8 @@ implement the “apply” method.
               const SelectivityVector& rows,
               std::vector<VectorPtr>& args,
               Expr* caller,
-              EvalCtx* context,
-              VectorPtr* result) const
+              EvalCtx& context,
+              VectorPtr& result) const
 
 Input rows
 ^^^^^^^^^^
@@ -918,13 +918,13 @@ Here is an example of using moveOrCopyResult to implement map_keys function:
         const SelectivityVector& rows,
         std::vector<VectorPtr>& args,
         exec::Expr* /* caller */,
-        exec::EvalCtx* context,
-        VectorPtr* result) const override {
+        exec::EvalCtx& context,
+        VectorPtr& result) const override {
       auto mapVector = args[0]->as<MapVector>();
       auto mapKeys = mapVector->mapKeys();
 
       auto localResult = std::make_shared<ArrayVector>(
-          context->pool(),
+          context.pool(),
           ARRAY(mapKeys->type()),
           mapVector->nulls(),
           rows.end(),
@@ -933,7 +933,7 @@ Here is an example of using moveOrCopyResult to implement map_keys function:
           mapKeys,
           mapVector->getNullCount());
 
-      context->moveOrCopyResult(localResult, rows, result);
+      context.moveOrCopyResult(localResult, rows, result);
     }
 
 Use BaseVector::ensureWritable method to initialize “result” to a flat
@@ -958,12 +958,12 @@ cardinality function for maps:
         const SelectivityVector& rows,
         std::vector<VectorPtr>& args,
         exec::Expr* /* caller */,
-        exec::EvalCtx* context,
-        VectorPtr* result) const override {
+        exec::EvalCtx& context,
+        VectorPtr& result) const override {
 
-      BaseVector::ensureWritable(rows, BIGINT(), context->pool(), result);
+      BaseVector::ensureWritable(rows, BIGINT(), context.pool(), result);
       BufferPtr resultValues =
-          (*result)->as<FlatVector<int64_t>>()->mutableValues(rows.size());
+           result->as<FlatVector<int64_t>>()->mutableValues(rows.size());
       auto rawResult = resultValues->asMutable<int64_t>();
 
       auto mapVector = args[0]->as<MapVector>();
@@ -987,8 +987,8 @@ as a simple function. I’m using it here for illustration purposes only.
 .. code-block:: c++
 
     // Initialize flat results vector.
-    BaseVector::ensureWritable(rows, DOUBLE(), context->pool(), result);
-    auto rawResults = (*result)->as<FlatVector<int64_t>>()->mutableRawValues();
+    BaseVector::ensureWritable(rows, DOUBLE(), context.pool(), result);
+    auto rawResults = result->as<FlatVector<int64_t>>()->mutableRawValues();
 
     // Decode the arguments.
     DecodedArgs decodedArgs(rows, args, context);
@@ -1074,7 +1074,7 @@ catch block.
       try {
         // ... calculate and store the result for the row
       } catch (const std::exception& e) {
-        context->setError(row, std::current_exception());
+        context.setError(row, std::current_exception());
       }
     });
 
@@ -1083,14 +1083,14 @@ instead of the explicit try-catch block above:
 
 .. code-block:: c++
 
-    context->applyToSelectedNoThrow(rows, [&](auto row) {
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
       // ... calculate and store the result for the row
     });
 
 
 Simple functions are compatible with the TRY expression by default. The framework
 wraps the “call” and “callNullable” methods in a try-catch and reports errors
-using context->setError.
+using context.setError.
 
 Registration
 ^^^^^^^^^^^^
diff --git a/velox/docs/monthly-updates/march-2022.rst b/velox/docs/monthly-updates/march-2022.rst
index 8bd46274035c..9093a7ac4dfd 100644
--- a/velox/docs/monthly-updates/march-2022.rst
+++ b/velox/docs/monthly-updates/march-2022.rst
@@ -133,7 +133,7 @@ Now consider a function that generates Array<int64_t> as an output. The result v
 
     VectorPtr result;
     // Here type is ArrayType(BIGINT()).
-    BaseVector::ensureWritable(rows, type, pool_, &result);
+    BaseVector::ensureWritable(rows, type, pool_, result);
 
     // Define a vector writer. ArrayWriterT is a temp holder. Eventually, Array will be used
     // once old writers are deprecated.
diff --git a/velox/duckdb/functions/DuckFunctions.cpp b/velox/duckdb/functions/DuckFunctions.cpp
index 43bc74f8de0e..0de35b1220da 100644
--- a/velox/duckdb/functions/DuckFunctions.cpp
+++ b/velox/duckdb/functions/DuckFunctions.cpp
@@ -380,10 +380,10 @@ VectorPtr createVeloxVector(
     const SelectivityVector& rows,
     LogicalType type,
     size_t count,
-    exec::EvalCtx* context) {
+    exec::EvalCtx& context) {
   auto resultType = toVeloxType(type);
-  auto result = BaseVector::create(resultType, count, context->pool());
-  context->ensureWritable(rows, resultType, result);
+  auto result = BaseVector::create(resultType, count, context.pool());
+  context.ensureWritable(rows, resultType, result);
   return result;
 }
 
@@ -420,22 +420,22 @@ class DuckDBFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      EvalCtx* context,
-      VectorPtr* result) const override {
+      EvalCtx& context,
+      VectorPtr& result) const override {
     // FIXME: this binding does not need to be performed on every function call
     std::vector<LogicalType> inputTypes;
     for (auto& arg : args) {
       inputTypes.push_back(fromVeloxType(arg->typeKind()));
     }
 
-    duckdb::VeloxPoolAllocator duckDBAllocator(*context->pool());
+    duckdb::VeloxPoolAllocator duckDBAllocator(*context.pool());
     auto state = initializeState(move(inputTypes), duckDBAllocator);
     assert(state->functionIndex < set_.size());
     auto& function = set_[state->functionIndex];
     idx_t nrow = rows.size();
 
-    if (!*result) {
-      *result = createVeloxVector(rows, function.return_type, nrow, context);
+    if (!result) {
+      result = createVeloxVector(rows, function.return_type, nrow, context);
     }
     for (auto offset = 0; offset < nrow; offset += STANDARD_VECTOR_SIZE) {
       // reset the input chunk by referencing the base chunk
@@ -443,7 +443,7 @@ class DuckDBFunction : public exec::VectorFunction {
       // convert arguments to duck arguments
       toDuck(rows, args, offset, *state->castChunk, *state->input);
       // run the function
-      callFunction(function, *state, offset, *result);
+      callFunction(function, *state, offset, result);
     }
   }
 
diff --git a/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.cpp
index d03a560d3d3d..c9999d53cc6a 100644
--- a/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.cpp
@@ -274,7 +274,7 @@ void SelectiveStringDictionaryColumnReader::getValues(
 
   if (scanSpec_->makeFlat()) {
     BaseVector::ensureWritable(
-        SelectivityVector::empty(), (*result)->type(), &memoryPool_, result);
+        SelectivityVector::empty(), (*result)->type(), &memoryPool_, *result);
   }
 }
 
diff --git a/velox/examples/OpaqueType.cpp b/velox/examples/OpaqueType.cpp
index f4540eff17ed..c39746846e07 100644
--- a/velox/examples/OpaqueType.cpp
+++ b/velox/examples/OpaqueType.cpp
@@ -116,8 +116,8 @@ class MapResolverVectorFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     // We cannot make any assumptions about the encoding of the input vectors.
     // In order to access their data as FlatVectors, we need to decode them
     // first:
@@ -134,8 +134,8 @@ class MapResolverVectorFunction : public exec::VectorFunction {
 
     // Ensure we have an output vector where we can write the output opaqued
     // values.
-    context->ensureWritable(rows, outputType, *result);
-    auto* output = (*result)->as<KindToFlatVector<TypeKind::OPAQUE>::type>();
+    context.ensureWritable(rows, outputType, result);
+    auto* output = result->as<KindToFlatVector<TypeKind::OPAQUE>::type>();
 
     // `applyToSelected()` will execute the lambda below on each row enabled in
     // the input selectivity vector (rows). We don't need to check for null
diff --git a/velox/exec/tests/FunctionResolutionTest.cpp b/velox/exec/tests/FunctionResolutionTest.cpp
index 69a1275718ff..d31ce5727d70 100644
--- a/velox/exec/tests/FunctionResolutionTest.cpp
+++ b/velox/exec/tests/FunctionResolutionTest.cpp
@@ -41,10 +41,10 @@ class VectorFunctionTwoArgs : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& /*args*/,
       const TypePtr& /*outputType*/,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
-    BaseVector::ensureWritable(rows, BOOLEAN(), context->pool(), result);
-    auto resultVector = (*result)->asUnchecked<FlatVector<bool>>();
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    BaseVector::ensureWritable(rows, BOOLEAN(), context.pool(), result);
+    auto resultVector = result->asUnchecked<FlatVector<bool>>();
 
     rows.applyToSelected([&](auto row) { resultVector->set(row, false); });
   }
@@ -64,8 +64,8 @@ class VectorFunctionOneArg : public VectorFunctionTwoArgs {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& ptr,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 1);
     VectorFunctionTwoArgs::apply(rows, args, ptr, context, result);
   }
diff --git a/velox/experimental/codegen/benchmark/CodegenBenchmark.h b/velox/experimental/codegen/benchmark/CodegenBenchmark.h
index a365cfd460a7..5fe6429da13b 100644
--- a/velox/experimental/codegen/benchmark/CodegenBenchmark.h
+++ b/velox/experimental/codegen/benchmark/CodegenBenchmark.h
@@ -319,8 +319,8 @@ class CodegenBenchmark : public CodegenTestCore {
                   arguments, // See D27826068
                   // batch.get()->children(),
                   nullptr,
-                  &context,
-                  &batchResult);
+                  context,
+                  batchResult);
           return batchResult;
         }
 
@@ -336,8 +336,8 @@ class CodegenBenchmark : public CodegenTestCore {
                 arguments, // See D27826068
                 // batch.get()->children(),
                 nullptr,
-                &context,
-                &filterResult);
+                context,
+                filterResult);
 
         auto numOut = facebook::velox::exec::processFilterResults(
             filterResult->as<RowVector>()->childAt(0),
@@ -358,7 +358,7 @@ class CodegenBenchmark : public CodegenTestCore {
         dynamic_cast<facebook::velox::exec::VectorFunction*>(
             info.projectionFunc.get())
             ->apply(
-                rows, batch.get()->children(), nullptr, &context, &batchResult);
+                rows, batch.get()->children(), nullptr, context, batchResult);
 
         if (numOut != batch->size()) {
           batchResult = facebook::velox::exec::wrap(
diff --git a/velox/experimental/codegen/vector_function/GeneratedVectorFunction-inl.h b/velox/experimental/codegen/vector_function/GeneratedVectorFunction-inl.h
index fe159398ecce..83085a96ce52 100644
--- a/velox/experimental/codegen/vector_function/GeneratedVectorFunction-inl.h
+++ b/velox/experimental/codegen/vector_function/GeneratedVectorFunction-inl.h
@@ -124,7 +124,7 @@ class GeneratedVectorFunctionBase
       const facebook::velox::SelectivityVector& rows,
       std::vector<facebook::velox::VectorPtr>& args,
       const TypePtr& /* outputType */,
-      facebook::velox::exec::EvalCtx* context,
+      facebook::velox::exec::EvalCtx& context,
       std::vector<facebook::velox::VectorPtr>& results) const = 0;
 #pragma clang diagnostic pop
 
@@ -172,17 +172,16 @@ class GeneratedVectorFunction : public GeneratedVectorFunctionBase {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK(result != nullptr);
     VELOX_CHECK(rowType_ != nullptr);
-    VELOX_CHECK(
-        (*result == nullptr) or (result->get()->as<RowVector>() != nullptr));
+    VELOX_CHECK(result == nullptr or (result->as<RowVector>() != nullptr));
 
     // all-constant expressions shouldn't be compiled
     VELOX_CHECK(args.size() > 0);
 
-    BaseVector::ensureWritable(rows, rowType_, context->pool(), result);
+    BaseVector::ensureWritable(rows, rowType_, context.pool(), result);
 
     // TODO: We should probably move this loop inside ensureWritable
     for (size_t columnIndex = 0; columnIndex < rowType_->size();
@@ -190,12 +189,12 @@ class GeneratedVectorFunction : public GeneratedVectorFunctionBase {
       BaseVector::ensureWritable(
           rows,
           rowType_->childAt(columnIndex),
-          context->pool(),
-          &(result->get()->as<RowVector>()->childAt(columnIndex)));
+          context.pool(),
+          result->as<RowVector>()->childAt(columnIndex));
     }
 
     // Constuct nulls
-    for (auto& child : result->get()->as<RowVector>()->children()) {
+    for (auto& child : result->as<RowVector>()->children()) {
       child->setCodegenOutput();
       if constexpr (
           (GeneratedCodeConfig::isDefaultNull ||
@@ -209,9 +208,9 @@ class GeneratedVectorFunction : public GeneratedVectorFunctionBase {
       }
     }
 
-    (*result)->setCodegenOutput();
+    result->setCodegenOutput();
 
-    VELOX_CHECK(result->get()->as<RowVector>() != nullptr);
+    VELOX_CHECK(result->as<RowVector>() != nullptr);
 
     // Shared string input buffer
     // TODO: write now we are sharing everything, this not ideal. We should do
@@ -222,13 +221,9 @@ class GeneratedVectorFunction : public GeneratedVectorFunctionBase {
         for (size_t columnIndex = 0; columnIndex < rowType_->size();
              ++columnIndex) {
           // Ensures that the results vectors are nullables.
-          if (result->get()
-                  ->as<RowVector>()
-                  ->childAt(columnIndex)
-                  ->type()
-                  ->kind() == TypeKind::VARCHAR) {
-            result->get()
-                ->as<RowVector>()
+          if (result->as<RowVector>()->childAt(columnIndex)->type()->kind() ==
+              TypeKind::VARCHAR) {
+            result->as<RowVector>()
                 ->childAt(columnIndex)
                 ->template asFlatVector<StringView>()
                 ->acquireSharedStringBuffers(arg.get());
@@ -270,27 +265,20 @@ class GeneratedVectorFunction : public GeneratedVectorFunctionBase {
           args,
           outputType,
           context,
-          result->get()->as<RowVector>()->children());
+          result->as<RowVector>()->children());
 
     } else {
       resultSize = apply(
-          rows,
-          args,
-          outputType,
-          context,
-          result->get()->as<RowVector>()->children());
+          rows, args, outputType, context, result->as<RowVector>()->children());
     }
 
     // truncate result
     if (resultSize != args[0]->size()) {
       for (size_t columnIndex = 0; columnIndex < rowType_->size();
            ++columnIndex) {
-        result->get()
-            ->as<RowVector>()
-            ->childAt(columnIndex)
-            ->resize(resultSize);
+        result->as<RowVector>()->childAt(columnIndex)->resize(resultSize);
       }
-      result->get()->resize(resultSize);
+      result->resize(resultSize);
     }
   }
 
@@ -298,10 +286,9 @@ class GeneratedVectorFunction : public GeneratedVectorFunctionBase {
       const facebook::velox::SelectivityVector& rows,
       std::vector<facebook::velox::VectorPtr>& args,
       const TypePtr& /* outputType */,
-      facebook::velox::exec::EvalCtx* context,
+      facebook::velox::exec::EvalCtx& context,
       std::vector<facebook::velox::VectorPtr>& results) const override {
     VELOX_CHECK(rowType_ != nullptr);
-    VELOX_CHECK(context != nullptr);
     VELOX_CHECK(results.size() == rowType_->size());
 
     auto inReaders = createReaders(
diff --git a/velox/expression/DecodedArgs.h b/velox/expression/DecodedArgs.h
index d3efa93897d0..e56a9555da72 100644
--- a/velox/expression/DecodedArgs.h
+++ b/velox/expression/DecodedArgs.h
@@ -35,9 +35,9 @@ class DecodedArgs {
   DecodedArgs(
       const SelectivityVector& rows,
       const std::vector<VectorPtr>& args,
-      exec::EvalCtx* FOLLY_NONNULL context) {
+      exec::EvalCtx& context) {
     for (auto& arg : args) {
-      holders_.emplace_back(*context, *arg.get(), rows);
+      holders_.emplace_back(context, *arg, rows);
     }
   }
 
diff --git a/velox/expression/EvalCtx.h b/velox/expression/EvalCtx.h
index 783207d4b2dc..345d31098be6 100644
--- a/velox/expression/EvalCtx.h
+++ b/velox/expression/EvalCtx.h
@@ -206,20 +206,13 @@ class EvalCtx {
       const SelectivityVector& rows,
       VectorPtr& result) const {
     if (result && !isFinalSelection() && *finalSelection() != rows) {
-      BaseVector::ensureWritable(rows, result->type(), result->pool(), &result);
+      BaseVector::ensureWritable(rows, result->type(), result->pool(), result);
       result->copy(localResult.get(), rows, nullptr);
     } else {
       result = localResult;
     }
   }
 
-  void moveOrCopyResult(
-      const VectorPtr& localResult,
-      const SelectivityVector& rows,
-      VectorPtr* FOLLY_NONNULL result) const {
-    moveOrCopyResult(localResult, rows, *result);
-  }
-
   VectorPool& vectorPool() const {
     return execCtx_->vectorPool();
   }
@@ -243,7 +236,7 @@ class EvalCtx {
       const TypePtr& type,
       VectorPtr& result) {
     BaseVector::ensureWritable(
-        rows, type, execCtx_->pool(), &result, &execCtx_->vectorPool());
+        rows, type, execCtx_->pool(), result, &execCtx_->vectorPool());
   }
 
  private:
@@ -408,9 +401,6 @@ class LocalDecodedVector {
  public:
   explicit LocalDecodedVector(core::ExecCtx& context) : context_(context) {}
 
-  explicit LocalDecodedVector(core::ExecCtx* FOLLY_NONNULL context)
-      : LocalDecodedVector(*context) {}
-
   explicit LocalDecodedVector(EvalCtx& context)
       : context_(*context.execCtx()) {}
 
@@ -426,13 +416,6 @@ class LocalDecodedVector {
     get()->decode(vector, rows, loadLazy);
   }
 
-  LocalDecodedVector(
-      const EvalCtx* FOLLY_NONNULL context,
-      const BaseVector& vector,
-      const SelectivityVector& rows,
-      bool loadLazy = true)
-      : LocalDecodedVector(*context, vector, rows, loadLazy) {}
-
   LocalDecodedVector(LocalDecodedVector&& other) noexcept
       : context_{other.context_}, vector_{std::move(other.vector_)} {}
 
diff --git a/velox/expression/Expr.cpp b/velox/expression/Expr.cpp
index 0ba3232befa1..326e028d73ca 100644
--- a/velox/expression/Expr.cpp
+++ b/velox/expression/Expr.cpp
@@ -275,7 +275,7 @@ void Expr::evalSimplifiedImpl(
     auto& inputValue = inputValues_[i];
     inputs_[i]->evalSimplified(remainingRows, context, inputValue);
 
-    BaseVector::flattenVector(&inputValue, rows.end());
+    BaseVector::flattenVector(inputValue, rows.end());
     VELOX_CHECK_EQ(VectorEncoding::Simple::FLAT, inputValue->encoding());
 
     // If the resulting vector has nulls, merge them into our current remaining
@@ -298,8 +298,7 @@ void Expr::evalSimplifiedImpl(
   }
 
   // Apply the actual function.
-  vectorFunction_->apply(
-      remainingRows, inputValues_, type(), &context, &result);
+  vectorFunction_->apply(remainingRows, inputValues_, type(), context, result);
 
   // Make sure the returned vector has its null bitmap properly set.
   addNulls(rows, remainingRows.asRange().bits(), context, result);
@@ -752,7 +751,7 @@ void Expr::addNulls(
 
   if (!result.unique() || !result->isNullsWritable()) {
     BaseVector::ensureWritable(
-        SelectivityVector::empty(), type(), context.pool(), &result);
+        SelectivityVector::empty(), type(), context.pool(), result);
   }
 
   if (result->size() < rows.end()) {
@@ -899,7 +898,7 @@ void Expr::setAllNulls(
     EvalCtx& context,
     VectorPtr& result) const {
   if (result) {
-    BaseVector::ensureWritable(rows, type(), context.pool(), &result);
+    BaseVector::ensureWritable(rows, type(), context.pool(), result);
     LocalSelectivityVector notNulls(context, rows.end());
     notNulls.get()->setAll();
     notNulls.get()->deselect(rows);
@@ -1210,7 +1209,7 @@ void Expr::applyFunction(
       ? computeIsAsciiForResult(vectorFunction_.get(), inputValues_, rows)
       : std::nullopt;
 
-  vectorFunction_->apply(rows, inputValues_, type(), &context, &result);
+  vectorFunction_->apply(rows, inputValues_, type(), context, result);
 
   if (isAscii.has_value()) {
     result->asUnchecked<SimpleVector<StringView>>()->setIsAscii(
diff --git a/velox/expression/FieldReference.cpp b/velox/expression/FieldReference.cpp
index e97bfff9970b..e58e2b8f0cb4 100644
--- a/velox/expression/FieldReference.cpp
+++ b/velox/expression/FieldReference.cpp
@@ -98,6 +98,6 @@ void FieldReference::evalSpecialFormSimplified(
 
   auto row = context.row();
   result = row->childAt(index(context));
-  BaseVector::flattenVector(&result, rows.end());
+  BaseVector::flattenVector(result, rows.end());
 }
 } // namespace facebook::velox::exec
diff --git a/velox/expression/SimpleFunctionAdapter.h b/velox/expression/SimpleFunctionAdapter.h
index 957d5d40298d..c810f02e7df7 100644
--- a/velox/expression/SimpleFunctionAdapter.h
+++ b/velox/expression/SimpleFunctionAdapter.h
@@ -138,29 +138,29 @@ class SimpleFunctionAdapter : public VectorFunction {
     ApplyContext(
         const SelectivityVector* _rows,
         const TypePtr& outputType,
-        EvalCtx* _context,
-        VectorPtr* _result,
+        EvalCtx& _context,
+        VectorPtr& _result,
         bool isResultReused)
         : rows{_rows}, context{_context} {
       // If we're reusing the input, we've already checked that the vector
       // is unique, as is nulls.  We also know the size of the vector is
       // at least as large as the size of rows.
       if (!isResultReused) {
-        context->ensureWritable(*rows, outputType, *_result);
+        context.ensureWritable(*rows, outputType, _result);
       }
-      result = reinterpret_cast<result_vector_t*>((*_result).get());
+      result = reinterpret_cast<result_vector_t*>(_result.get());
       resultWriter.init(*result);
     }
 
     template <typename Callable>
     void applyToSelectedNoThrow(Callable func) {
-      context->template applyToSelectedNoThrow<Callable>(*rows, func);
+      context.template applyToSelectedNoThrow<Callable>(*rows, func);
     }
 
     const SelectivityVector* rows;
     result_vector_t* result;
     VectorWriter<typename FUNC::return_type> resultWriter;
-    EvalCtx* context;
+    EvalCtx& context;
     bool allAscii{false};
     bool mayHaveNullsRecursive{false};
   };
@@ -256,9 +256,9 @@ class SimpleFunctionAdapter : public VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      EvalCtx* context,
-      VectorPtr* result) const override {
-    auto* reusableResult = result;
+      EvalCtx& context,
+      VectorPtr& result) const override {
+    auto* reusableResult = &result;
     // If result is null, check if one of the arguments can be re-used for
     // storing the result. This is possible if all the following conditions are
     // met:
@@ -282,13 +282,13 @@ class SimpleFunctionAdapter : public VectorFunction {
     }
 
     ApplyContext applyContext{
-        &rows, outputType, context, reusableResult, isResultReused};
+        &rows, outputType, context, *reusableResult, isResultReused};
 
     // If the function provides an initialize() method and it threw, we set that
     // exception in all active rows and we're done with it.
     if constexpr (FUNC::udf_has_initialize) {
       if (UNLIKELY(initializeException_ != nullptr)) {
-        applyContext.context->setErrors(
+        applyContext.context.setErrors(
             *applyContext.rows, initializeException_);
         return;
       }
@@ -352,7 +352,7 @@ class SimpleFunctionAdapter : public VectorFunction {
       }
     }
 
-    *result = std::move(*reusableResult);
+    result = std::move(*reusableResult);
   }
 
   // Acquire string buffer from source if vector is a string flat vector.
@@ -522,7 +522,7 @@ class SimpleFunctionAdapter : public VectorFunction {
 
     // Compute allNotNull.
     bool allNotNull;
-    if (applyContext.context->nullsPruned()) {
+    if (applyContext.context.nullsPruned()) {
       allNotNull = true;
     } else {
       allNotNull = (!readers.mayHaveNulls() && ...);
diff --git a/velox/expression/VectorFunction.h b/velox/expression/VectorFunction.h
index f45f8310fcfa..2b23dde31eb7 100644
--- a/velox/expression/VectorFunction.h
+++ b/velox/expression/VectorFunction.h
@@ -50,7 +50,7 @@ class VectorFunction {
   /// see a null row in any of the arguments. They can safely assume that there
   /// are no nulls in any of the arguments in specified positions.
   ///
-  /// If context->isFinalSelection() is false, the result may have been
+  /// If context.isFinalSelection() is false, the result may have been
   /// partially populated for the positions not specified in rows. The function
   /// must take care not to overwrite these values. This happens when evaluating
   /// conditional expressions. Consider if(a = 1, f(b), g(c)) expression. The
@@ -59,14 +59,14 @@ class VectorFunction {
   /// but g(c) is called with partially populated result which has f(b) values
   /// in some positions. Function g must preserve these values.
   ///
-  /// Use context->isFinalSelection() to determine whether partially populated
+  /// Use context.isFinalSelection() to determine whether partially populated
   /// results must be preserved or not.
   ///
   /// If 'result' is not null, it can be dictionary, constant or sequence
   /// encoded and therefore may be read-only. Call BaseVector::ensureWritable
   /// before writing into the "result", e.g.
   ///
-  ///    BaseVector::ensureWritable(&rows, caller->type(), context->pool(),
+  ///    BaseVector::ensureWritable(&rows, caller->type(), context.pool(),
   ///        result);
   ///
   /// If 'result' is null, the function can allocate a new vector using
@@ -77,8 +77,8 @@ class VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args, // Not using const ref so we can reuse args
       const TypePtr& outputType,
-      EvalCtx* context,
-      VectorPtr* result) const = 0;
+      EvalCtx& context,
+      VectorPtr& result) const = 0;
 
   virtual bool isDeterministic() const {
     return true;
diff --git a/velox/expression/tests/ArrayWriterTest.cpp b/velox/expression/tests/ArrayWriterTest.cpp
index 65ceced5f053..f64203e53af8 100644
--- a/velox/expression/tests/ArrayWriterTest.cpp
+++ b/velox/expression/tests/ArrayWriterTest.cpp
@@ -63,7 +63,7 @@ class ArrayWriterTest : public functions::test::FunctionBaseTest {
   VectorPtr prepareResult(const TypePtr& arrayType, vector_size_t size = 1) {
     VectorPtr result;
     BaseVector::ensureWritable(
-        SelectivityVector(size), arrayType, this->execCtx_.pool(), &result);
+        SelectivityVector(size), arrayType, this->execCtx_.pool(), result);
     return result;
   }
 
@@ -375,7 +375,7 @@ TEST_F(ArrayWriterTest, nestedArray) {
   auto result = prepareResult(std::make_shared<ArrayType>(elementType));
 
   exec::VectorWriter<Array<Array<int32_t>>> vectorWriter;
-  vectorWriter.init(*result.get()->as<ArrayVector>());
+  vectorWriter.init(*result->as<ArrayVector>());
   vectorWriter.setOffset(0);
   auto& arrayWriter = vectorWriter.current();
   // Only general interface is allowed for nested arrays.
@@ -771,7 +771,7 @@ TEST_F(ArrayWriterTest, finishPostSize) {
   auto result = prepareResult(CppToType<out_t>::create());
 
   exec::VectorWriter<out_t> vectorWriter;
-  vectorWriter.init(*result.get()->as<ArrayVector>());
+  vectorWriter.init(*result->as<ArrayVector>());
   vectorWriter.setOffset(0);
 
   // Add 3 items in top level array and 10 in inner array.
diff --git a/velox/expression/tests/CastExprTest.cpp b/velox/expression/tests/CastExprTest.cpp
index 598ba251d109..a848d88f51f8 100644
--- a/velox/expression/tests/CastExprTest.cpp
+++ b/velox/expression/tests/CastExprTest.cpp
@@ -40,12 +40,12 @@ class TestingDictionaryFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK(rows.isAllSelected());
     const auto size = rows.size();
-    auto indices = makeIndicesInReverse(size, context->pool());
-    *result = BaseVector::wrapInDictionary(
+    auto indices = makeIndicesInReverse(size, context.pool());
+    result = BaseVector::wrapInDictionary(
         BufferPtr(nullptr), indices, size, args[0]);
   }
 
diff --git a/velox/expression/tests/ExprTest.cpp b/velox/expression/tests/ExprTest.cpp
index b81cb07852ff..f0825bf4cbfd 100644
--- a/velox/expression/tests/ExprTest.cpp
+++ b/velox/expression/tests/ExprTest.cpp
@@ -450,8 +450,8 @@ class PlusConstantFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 1);
 
     auto& arg = args[0];
@@ -459,10 +459,10 @@ class PlusConstantFunction : public exec::VectorFunction {
     // The argument may be flat or constant.
     VELOX_CHECK(arg->isFlatEncoding() || arg->isConstantEncoding());
 
-    BaseVector::ensureWritable(rows, INTEGER(), context->pool(), result);
+    BaseVector::ensureWritable(rows, INTEGER(), context.pool(), result);
 
-    auto flatResult = (*result)->asFlatVector<int32_t>();
-    auto rawResult = flatResult->mutableRawValues();
+    auto* flatResult = result->asFlatVector<int32_t>();
+    auto* rawResult = flatResult->mutableRawValues();
 
     flatResult->clearNulls(rows);
 
@@ -576,13 +576,13 @@ class PlusRandomIntegerFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 1);
     VELOX_CHECK_EQ(args[0]->typeKind(), facebook::velox::TypeKind::INTEGER);
 
-    BaseVector::ensureWritable(rows, INTEGER(), context->pool(), result);
-    auto flatResult = (*result)->asFlatVector<int32_t>();
+    BaseVector::ensureWritable(rows, INTEGER(), context.pool(), result);
+    auto flatResult = result->asFlatVector<int32_t>();
 
     DecodedVector decoded(*args[0], rows);
     std::srand(1);
@@ -707,18 +707,18 @@ class AddSuffixFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     auto input = args[0]->asFlatVector<StringView>();
     auto localResult = std::dynamic_pointer_cast<FlatVector<StringView>>(
-        BaseVector::create(VARCHAR(), rows.end(), context->pool()));
+        BaseVector::create(VARCHAR(), rows.end(), context.pool()));
     rows.applyToSelected([&](auto row) {
       auto value = fmt::format("{}{}", input->valueAt(row).str(), suffix_);
       localResult->set(row, StringView(value));
       return true;
     });
 
-    context->moveOrCopyResult(localResult, rows, result);
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
@@ -974,16 +974,16 @@ class StatefulVectorFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), numInputs_);
     auto numInputs =
-        BaseVector::createConstant(numInputs_, rows.size(), context->pool());
+        BaseVector::createConstant(numInputs_, rows.size(), context.pool());
     if (!result) {
-      *result = numInputs;
+      result = numInputs;
     } else {
-      BaseVector::ensureWritable(rows, INTEGER(), context->pool(), result);
-      (*result)->copy(numInputs.get(), rows, nullptr);
+      BaseVector::ensureWritable(rows, INTEGER(), context.pool(), result);
+      result->copy(numInputs.get(), rows, nullptr);
     }
   }
 
@@ -1341,10 +1341,10 @@ class TestingConstantFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* /*context*/,
-      VectorPtr* result) const override {
+      exec::EvalCtx& /*context*/,
+      VectorPtr& result) const override {
     VELOX_CHECK(rows.isAllSelected());
-    *result = BaseVector::wrapInConstant(rows.size(), 0, args[0]);
+    result = BaseVector::wrapInConstant(rows.size(), 0, args[0]);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
@@ -1369,11 +1369,11 @@ class TestingDictionaryFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* /*context*/,
-      VectorPtr* result) const override {
+      exec::EvalCtx& /*context*/,
+      VectorPtr& result) const override {
     VELOX_CHECK(rows.isAllSelected());
-    auto indices = args[1]->as<FlatVector<int32_t>>()->values();
-    *result = BaseVector::wrapInDictionary(
+    auto& indices = args[1]->as<FlatVector<int32_t>>()->values();
+    result = BaseVector::wrapInDictionary(
         BufferPtr(nullptr), indices, rows.size(), args[0]);
   }
 
@@ -1401,11 +1401,11 @@ class TestingSequenceFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK(rows.isAllSelected());
     auto lengths = args[1]->as<FlatVector<int32_t>>()->values();
-    *result = BaseVector::wrapInSequence(lengths, rows.size(), args[0]);
+    result = BaseVector::wrapInSequence(lengths, rows.size(), args[0]);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
@@ -1427,12 +1427,12 @@ class TestingSingleArgDeterministicFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     auto& arg = args[0];
     VELOX_CHECK(arg->isFlatEncoding() || arg->isConstantEncoding());
-    BaseVector::ensureWritable(rows, outputType, context->pool(), result);
-    (*result)->copy(arg.get(), rows, nullptr);
+    BaseVector::ensureWritable(rows, outputType, context.pool(), result);
+    result->copy(arg.get(), rows, nullptr);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
@@ -1537,11 +1537,11 @@ class NullArrayFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     // This function returns a vector of all nulls
-    BaseVector::ensureWritable(rows, ARRAY(VARCHAR()), context->pool(), result);
-    (*result)->addNulls(nullptr, rows);
+    BaseVector::ensureWritable(rows, ARRAY(VARCHAR()), context.pool(), result);
+    result->addNulls(nullptr, rows);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
@@ -1944,14 +1944,14 @@ class TestingShrinkingDictionary : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     BufferPtr indices =
-        AlignedBuffer::allocate<vector_size_t>(rows.end(), context->pool());
+        AlignedBuffer::allocate<vector_size_t>(rows.end(), context.pool());
     auto rawIndices = indices->asMutable<vector_size_t>();
     rows.applyToSelected([&](int row) { rawIndices[row] = row; });
 
-    *result =
+    result =
         BaseVector::wrapInDictionary(nullptr, indices, rows.end() - 1, args[0]);
   }
 
diff --git a/velox/expression/tests/GenericWriterTest.cpp b/velox/expression/tests/GenericWriterTest.cpp
index c0f664412dd4..7c4c7e347e1d 100644
--- a/velox/expression/tests/GenericWriterTest.cpp
+++ b/velox/expression/tests/GenericWriterTest.cpp
@@ -34,7 +34,7 @@ class GenericWriterTest : public functions::test::FunctionBaseTest {};
 
 TEST_F(GenericWriterTest, boolean) {
   VectorPtr result;
-  BaseVector::ensureWritable(SelectivityVector(5), BOOLEAN(), pool(), &result);
+  BaseVector::ensureWritable(SelectivityVector(5), BOOLEAN(), pool(), result);
 
   VectorWriter<Any> writer;
   writer.init(*result);
@@ -61,7 +61,7 @@ TEST_F(GenericWriterTest, boolean) {
 
 TEST_F(GenericWriterTest, integer) {
   VectorPtr result;
-  BaseVector::ensureWritable(SelectivityVector(100), BIGINT(), pool(), &result);
+  BaseVector::ensureWritable(SelectivityVector(100), BIGINT(), pool(), result);
 
   VectorWriter<Any> writer;
   writer.init(*result);
@@ -82,7 +82,7 @@ TEST_F(GenericWriterTest, integer) {
 
 TEST_F(GenericWriterTest, varchar) {
   VectorPtr result;
-  BaseVector::ensureWritable(SelectivityVector(6), VARCHAR(), pool(), &result);
+  BaseVector::ensureWritable(SelectivityVector(6), VARCHAR(), pool(), result);
 
   VectorWriter<Any> writer;
   writer.init(*result);
@@ -109,7 +109,7 @@ TEST_F(GenericWriterTest, varchar) {
 TEST_F(GenericWriterTest, array) {
   VectorPtr result;
   BaseVector::ensureWritable(
-      SelectivityVector(5), ARRAY(BIGINT()), pool(), &result);
+      SelectivityVector(5), ARRAY(BIGINT()), pool(), result);
 
   VectorWriter<Any> writer;
   writer.init(*result);
@@ -143,7 +143,7 @@ TEST_F(GenericWriterTest, array) {
 TEST_F(GenericWriterTest, arrayWriteThenCommitNull) {
   VectorPtr result;
   SelectivityVector rows(2);
-  BaseVector::ensureWritable(rows, ARRAY(BIGINT()), pool(), &result);
+  BaseVector::ensureWritable(rows, ARRAY(BIGINT()), pool(), result);
 
   VectorWriter<Any> writer;
   writer.init(*result);
@@ -177,8 +177,7 @@ TEST_F(GenericWriterTest, genericWriteThenCommitNull) {
   SelectivityVector rows(2);
   using test_t = Row<Array<int64_t>>;
 
-  BaseVector::ensureWritable(
-      rows, CppToType<test_t>::create(), pool(), &result);
+  BaseVector::ensureWritable(rows, CppToType<test_t>::create(), pool(), result);
 
   VectorWriter<Any> writer;
   writer.init(*result);
@@ -213,7 +212,7 @@ TEST_F(GenericWriterTest, genericWriteThenCommitNull) {
 TEST_F(GenericWriterTest, map) {
   VectorPtr result;
   BaseVector::ensureWritable(
-      SelectivityVector(4), MAP(VARCHAR(), BIGINT()), pool(), &result);
+      SelectivityVector(4), MAP(VARCHAR(), BIGINT()), pool(), result);
 
   VectorWriter<Any> writer;
   writer.init(*result);
@@ -251,7 +250,7 @@ TEST_F(GenericWriterTest, row) {
       SelectivityVector(4),
       ROW({VARCHAR(), BIGINT(), DOUBLE()}),
       pool(),
-      &result);
+      result);
 
   VectorWriter<Any> writer;
   writer.init(*result);
@@ -296,7 +295,7 @@ TEST_F(GenericWriterTest, nested) {
       SelectivityVector(3),
       MAP(BIGINT(), ROW({ARRAY(BIGINT()), TINYINT()})),
       pool(),
-      &result);
+      result);
 
   VectorWriter<Any> writer;
   writer.init(*result);
@@ -366,7 +365,7 @@ TEST_F(GenericWriterTest, nested) {
 
 TEST_F(GenericWriterTest, commitNull) {
   VectorPtr result;
-  BaseVector::ensureWritable(SelectivityVector(3), BIGINT(), pool(), &result);
+  BaseVector::ensureWritable(SelectivityVector(3), BIGINT(), pool(), result);
 
   VectorWriter<Any> writer;
   writer.init(*result);
@@ -396,7 +395,7 @@ TEST_F(GenericWriterTest, handleMisuse) {
   // Test finish without commit.
   VectorPtr result;
   BaseVector::ensureWritable(
-      SelectivityVector(1), ARRAY(BIGINT()), pool(), &result);
+      SelectivityVector(1), ARRAY(BIGINT()), pool(), result);
 
   VectorWriter<Any> writer1;
   initializeAndAddElements(result, writer1);
diff --git a/velox/expression/tests/MapWriterTest.cpp b/velox/expression/tests/MapWriterTest.cpp
index 2464375cfeb7..9b38c8ef4421 100644
--- a/velox/expression/tests/MapWriterTest.cpp
+++ b/velox/expression/tests/MapWriterTest.cpp
@@ -78,7 +78,7 @@ class MapWriterTest : public functions::test::FunctionBaseTest {
   VectorPtr prepareResult(const TypePtr& mapType, vector_size_t size = 1) {
     VectorPtr result;
     BaseVector::ensureWritable(
-        SelectivityVector(size), mapType, this->execCtx_.pool(), &result);
+        SelectivityVector(size), mapType, this->execCtx_.pool(), result);
     return result;
   }
 
diff --git a/velox/expression/tests/RowWriterTest.cpp b/velox/expression/tests/RowWriterTest.cpp
index c3abd7e69352..b6e21484a045 100644
--- a/velox/expression/tests/RowWriterTest.cpp
+++ b/velox/expression/tests/RowWriterTest.cpp
@@ -53,7 +53,7 @@ class RowWriterTest : public functions::test::FunctionBaseTest {
   VectorPtr prepareResult(const TypePtr& rowType, vector_size_t size = 1) {
     VectorPtr result;
     BaseVector::ensureWritable(
-        SelectivityVector(size), rowType, this->execCtx_.pool(), &result);
+        SelectivityVector(size), rowType, this->execCtx_.pool(), result);
     return result;
   }
 
@@ -503,7 +503,7 @@ TEST_F(RowWriterTest, finishPostSize) {
   auto result = prepareResult(CppToType<out_t>::create());
 
   exec::VectorWriter<out_t> vectorWriter;
-  vectorWriter.init(*result.get()->as<RowVector>());
+  vectorWriter.init(*result->as<RowVector>());
   vectorWriter.setOffset(0);
 
   auto& rowWriter = vectorWriter.current();
diff --git a/velox/expression/tests/SimpleFunctionTest.cpp b/velox/expression/tests/SimpleFunctionTest.cpp
index ba69356189b7..114899e4c18c 100644
--- a/velox/expression/tests/SimpleFunctionTest.cpp
+++ b/velox/expression/tests/SimpleFunctionTest.cpp
@@ -949,7 +949,7 @@ VectorPtr testVariadicArgReuse(
   exec::EvalCtx evalCtx(execCtx, &exprSet, inputRows.get());
 
   VectorPtr resultPtr;
-  function->apply(rows, inputs, outputType, &evalCtx, &resultPtr);
+  function->apply(rows, inputs, outputType, evalCtx, resultPtr);
 
   return resultPtr;
 }
diff --git a/velox/expression/tests/TryExprTest.cpp b/velox/expression/tests/TryExprTest.cpp
index 5d93e1eff7f4..555ed14316cb 100644
--- a/velox/expression/tests/TryExprTest.cpp
+++ b/velox/expression/tests/TryExprTest.cpp
@@ -143,13 +143,12 @@ class CreateConstantAndThrow : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& /* args */,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
-    *result =
-        BaseVector::createConstant((int64_t)1, rows.end(), context->pool());
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    result = BaseVector::createConstant((int64_t)1, rows.end(), context.pool());
 
     rows.applyToSelected([&](int row) {
-      context->setError(
+      context.setError(
           row, std::make_exception_ptr(std::invalid_argument("expected")));
     });
   }
diff --git a/velox/expression/tests/VariadicViewTest.cpp b/velox/expression/tests/VariadicViewTest.cpp
index 77c642e609cc..50565d748c9b 100644
--- a/velox/expression/tests/VariadicViewTest.cpp
+++ b/velox/expression/tests/VariadicViewTest.cpp
@@ -64,7 +64,7 @@ class VariadicViewTest : public functions::test::FunctionBaseTest {
     EvalCtx ctx(&execCtx_);
     std::vector<std::optional<LocalDecodedVector>> args;
     for (const auto& vector : vectors) {
-      args.emplace_back(LocalDecodedVector(&ctx, *vector, rows));
+      args.emplace_back(LocalDecodedVector(ctx, *vector, rows));
     }
 
     size_t startIndex = additionalVectors.size();
@@ -140,7 +140,7 @@ class VariadicViewTest : public functions::test::FunctionBaseTest {
     EvalCtx ctx(&execCtx_);
     std::vector<std::optional<LocalDecodedVector>> args;
     for (const auto& vector : vectors) {
-      args.emplace_back(LocalDecodedVector(&ctx, *vector, rows));
+      args.emplace_back(LocalDecodedVector(ctx, *vector, rows));
     }
 
     VectorReader<Variadic<int64_t>> reader(args, 0);
@@ -170,7 +170,7 @@ class VariadicViewTest : public functions::test::FunctionBaseTest {
     EvalCtx ctx(&execCtx_);
     std::vector<std::optional<LocalDecodedVector>> args;
     for (const auto& vector : vectors) {
-      args.emplace_back(LocalDecodedVector(&ctx, *vector, rows));
+      args.emplace_back(LocalDecodedVector(ctx, *vector, rows));
     }
 
     VectorReader<Variadic<int64_t>> reader(args, 0);
@@ -203,7 +203,7 @@ class VariadicViewTest : public functions::test::FunctionBaseTest {
     EvalCtx ctx(&execCtx_);
     std::vector<std::optional<LocalDecodedVector>> args;
     for (const auto& vector : vectors) {
-      args.emplace_back(LocalDecodedVector(&ctx, *vector, rows));
+      args.emplace_back(LocalDecodedVector(ctx, *vector, rows));
     }
 
     VectorReader<Variadic<int64_t>> reader(args, 0);
@@ -235,7 +235,7 @@ class VariadicViewTest : public functions::test::FunctionBaseTest {
     EvalCtx ctx(&execCtx_);
     std::vector<std::optional<LocalDecodedVector>> args;
     for (const auto& vector : vectors) {
-      args.emplace_back(LocalDecodedVector(&ctx, *vector, rows));
+      args.emplace_back(LocalDecodedVector(ctx, *vector, rows));
     }
 
     VectorReader<Variadic<int64_t>> reader(args, 0);
@@ -306,7 +306,7 @@ TEST_F(NullableVariadicViewTest, notNullContainer) {
   EvalCtx ctx(&execCtx_);
   std::vector<std::optional<LocalDecodedVector>> args;
   for (const auto& vector : vectors) {
-    args.emplace_back(LocalDecodedVector(&ctx, *vector, rows));
+    args.emplace_back(LocalDecodedVector(ctx, *vector, rows));
   }
 
   VectorReader<Variadic<int64_t>> reader(args, 0);
diff --git a/velox/expression/tests/VectorReaderTest.cpp b/velox/expression/tests/VectorReaderTest.cpp
index a106480d67f0..372c8ccbaebe 100644
--- a/velox/expression/tests/VectorReaderTest.cpp
+++ b/velox/expression/tests/VectorReaderTest.cpp
@@ -462,7 +462,7 @@ TEST_F(VectorReaderTest, variadicContainsNull) {
   exec::EvalCtx ctx(&execCtx_);
   std::vector<std::optional<LocalDecodedVector>> args;
   for (const auto& vector : {field1Vector, field2Vector, field3Vector}) {
-    args.emplace_back(LocalDecodedVector(&ctx, *vector, rows));
+    args.emplace_back(LocalDecodedVector(ctx, *vector, rows));
   }
   exec::VectorReader<Variadic<int32_t>> reader(args, 0);
 
@@ -536,7 +536,7 @@ TEST_F(VectorReaderTest, dictionaryEncodedVariadicContainsNull) {
   exec::EvalCtx ctx(&execCtx_);
   std::vector<std::optional<LocalDecodedVector>> args;
   for (const auto& vector : {field1Vector, field2Vector, field3Vector}) {
-    args.emplace_back(LocalDecodedVector(&ctx, *vector, rows));
+    args.emplace_back(LocalDecodedVector(ctx, *vector, rows));
   }
   exec::VectorReader<Variadic<int32_t>> reader(args, 0);
 
diff --git a/velox/functions/lib/IsNull.cpp b/velox/functions/lib/IsNull.cpp
index 2344dd98d9a5..ac9a26b66e1d 100644
--- a/velox/functions/lib/IsNull.cpp
+++ b/velox/functions/lib/IsNull.cpp
@@ -31,23 +31,23 @@ class IsNullFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     auto* arg = args[0].get();
-
+    auto* pool = context.pool();
     if (arg->isConstantEncoding()) {
       bool isNull = arg->isNullAt(rows.begin());
       auto localResult = BaseVector::createConstant(
-          IsNotNULL ? !isNull : isNull, rows.size(), context->pool());
-      context->moveOrCopyResult(localResult, rows, *result);
+          IsNotNULL ? !isNull : isNull, rows.size(), pool);
+      context.moveOrCopyResult(localResult, rows, result);
       return;
     }
 
     if (!arg->mayHaveNulls()) {
       // No nulls.
       auto localResult = BaseVector::createConstant(
-          IsNotNULL ? true : false, rows.size(), context->pool());
-      context->moveOrCopyResult(localResult, rows, *result);
+          IsNotNULL ? true : false, rows.size(), pool);
+      context.moveOrCopyResult(localResult, rows, result);
       return;
     }
 
@@ -56,7 +56,7 @@ class IsNullFunction : public exec::VectorFunction {
       if constexpr (IsNotNULL) {
         isNull = arg->nulls();
       } else {
-        isNull = AlignedBuffer::allocate<bool>(rows.size(), context->pool());
+        isNull = AlignedBuffer::allocate<bool>(rows.size(), pool);
         memcpy(
             isNull->asMutable<int64_t>(),
             arg->rawNulls(),
@@ -66,7 +66,7 @@ class IsNullFunction : public exec::VectorFunction {
     } else {
       exec::DecodedArgs decodedArgs(rows, args, context);
 
-      isNull = AlignedBuffer::allocate<bool>(rows.size(), context->pool());
+      isNull = AlignedBuffer::allocate<bool>(rows.size(), pool);
       memcpy(
           isNull->asMutable<int64_t>(),
           decodedArgs.at(0)->nulls(),
@@ -78,12 +78,8 @@ class IsNullFunction : public exec::VectorFunction {
     }
 
     auto localResult = std::make_shared<FlatVector<bool>>(
-        context->pool(),
-        nullptr,
-        rows.size(),
-        isNull,
-        std::vector<BufferPtr>{});
-    context->moveOrCopyResult(localResult, rows, *result);
+        pool, nullptr, rows.size(), isNull, std::vector<BufferPtr>{});
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
diff --git a/velox/functions/lib/Re2Functions.cpp b/velox/functions/lib/Re2Functions.cpp
index d0e2409930bc..e6a10ec47c4e 100644
--- a/velox/functions/lib/Re2Functions.cpp
+++ b/velox/functions/lib/Re2Functions.cpp
@@ -69,18 +69,18 @@ void checkForBadPattern(const RE2& re) {
 
 FlatVector<bool>& ensureWritableBool(
     const SelectivityVector& rows,
-    EvalCtx* context,
-    std::shared_ptr<BaseVector>* result) {
-  context->ensureWritable(rows, BOOLEAN(), *result);
-  return *(*result)->as<FlatVector<bool>>();
+    EvalCtx& context,
+    VectorPtr& result) {
+  context.ensureWritable(rows, BOOLEAN(), result);
+  return *result->as<FlatVector<bool>>();
 }
 
 FlatVector<StringView>& ensureWritableStringView(
     const SelectivityVector& rows,
-    EvalCtx* context,
-    std::shared_ptr<BaseVector>* result) {
-  context->ensureWritable(rows, VARCHAR(), *result);
-  auto* flat = (*result)->as<FlatVector<StringView>>();
+    EvalCtx& context,
+    std::shared_ptr<BaseVector>& result) {
+  context.ensureWritable(rows, VARCHAR(), result);
+  auto* flat = result->as<FlatVector<StringView>>();
   flat->mutableValues(rows.end());
   return *flat;
 }
@@ -191,8 +191,8 @@ class Re2MatchConstantPattern final : public VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      EvalCtx* context,
-      VectorPtr* resultRef) const final {
+      EvalCtx& context,
+      VectorPtr& resultRef) const final {
     VELOX_CHECK_EQ(args.size(), 2);
     FlatVector<bool>& result = ensureWritableBool(rows, context, resultRef);
     exec::LocalDecodedVector toSearch(context, *args[0], rows);
@@ -213,8 +213,8 @@ class Re2Match final : public VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      EvalCtx* context,
-      VectorPtr* resultRef) const override {
+      EvalCtx& context,
+      VectorPtr& resultRef) const override {
     VELOX_CHECK_EQ(args.size(), 2);
     if (auto pattern = getIfConstant<StringView>(*args[1])) {
       Re2MatchConstantPattern<Fn>(*pattern).apply(
@@ -251,8 +251,8 @@ class Re2SearchAndExtractConstantPattern final : public VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      EvalCtx* context,
-      VectorPtr* resultRef) const final {
+      EvalCtx& context,
+      VectorPtr& resultRef) const final {
     VELOX_CHECK(args.size() == 2 || args.size() == 3);
     // TODO: Potentially re-use the string vector, not just the buffer.
     FlatVector<StringView>& result =
@@ -327,8 +327,8 @@ class Re2SearchAndExtract final : public VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      EvalCtx* context,
-      VectorPtr* resultRef) const final {
+      EvalCtx& context,
+      VectorPtr& resultRef) const final {
     VELOX_CHECK(args.size() == 2 || args.size() == 3);
     // Handle the common case of a constant pattern.
     if (auto pattern = getIfConstant<StringView>(*args[1])) {
@@ -384,14 +384,14 @@ class LikeConstantPattern final : public VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      EvalCtx* context,
-      VectorPtr* resultRef) const final {
+      EvalCtx& context,
+      VectorPtr& resultRef) const final {
     VELOX_CHECK(args.size() == 2 || args.size() == 3);
 
     if (!validPattern_) {
       auto error = std::make_exception_ptr(std::invalid_argument(
           "Escape character must be followed by '%%', '_' or the escape character itself\""));
-      rows.applyToSelected([&](auto row) { context->setError(row, error); });
+      rows.applyToSelected([&](auto row) { context.setError(row, error); });
       return;
     }
 
@@ -463,13 +463,13 @@ class Re2ExtractAllConstantPattern final : public VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      EvalCtx* context,
-      VectorPtr* resultRef) const final {
+      EvalCtx& context,
+      VectorPtr& resultRef) const final {
     VELOX_CHECK(args.size() == 2 || args.size() == 3);
     checkForBadPattern(re_);
 
     ArrayBuilder<Varchar> builder(
-        rows.size(), rows.countSelected() * 3, context->pool());
+        rows.size(), rows.countSelected() * 3, context.pool());
     exec::LocalDecodedVector inputStrs(context, *args[0], rows);
     FOLLY_DECLARE_REUSED(groups, std::vector<re2::StringPiece>);
 
@@ -477,7 +477,7 @@ class Re2ExtractAllConstantPattern final : public VectorFunction {
       // Case 1: No groupId -- use 0 as the default groupId
       //
       groups.resize(1);
-      context->applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+      context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
         re2ExtractAll(builder, re_, inputStrs, row, groups, 0);
       });
     } else if (const auto _groupId = getIfConstant<T>(*args[2])) {
@@ -485,7 +485,7 @@ class Re2ExtractAllConstantPattern final : public VectorFunction {
       //
       checkForBadGroupId(*_groupId, re_);
       groups.resize(*_groupId + 1);
-      context->applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+      context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
         re2ExtractAll(builder, re_, inputStrs, row, groups, *_groupId);
       });
     } else {
@@ -494,14 +494,14 @@ class Re2ExtractAllConstantPattern final : public VectorFunction {
       //
       exec::LocalDecodedVector groupIds(context, *args[2], rows);
       T maxGroupId = 0, minGroupId = 0;
-      context->applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+      context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
         maxGroupId = std::max(groupIds->valueAt<T>(row), maxGroupId);
         minGroupId = std::min(groupIds->valueAt<T>(row), minGroupId);
       });
       checkForBadGroupId(maxGroupId, re_);
       checkForBadGroupId(minGroupId, re_);
       groups.resize(maxGroupId + 1);
-      context->applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+      context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
         const T groupId = groupIds->valueAt<T>(row);
         checkForBadGroupId(groupId, re_);
         re2ExtractAll(builder, re_, inputStrs, row, groups, groupId);
@@ -512,8 +512,8 @@ class Re2ExtractAllConstantPattern final : public VectorFunction {
       builder.setStringBuffers(fv->stringBuffers());
     }
     std::shared_ptr<ArrayVector> arrayVector =
-        std::move(builder).finish(context->pool());
-    context->moveOrCopyResult(arrayVector, rows, resultRef);
+        std::move(builder).finish(context.pool());
+    context.moveOrCopyResult(arrayVector, rows, resultRef);
   }
 
  private:
@@ -527,8 +527,8 @@ class Re2ExtractAll final : public VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      EvalCtx* context,
-      VectorPtr* resultRef) const final {
+      EvalCtx& context,
+      VectorPtr& resultRef) const final {
     VELOX_CHECK(args.size() == 2 || args.size() == 3);
     // Use Re2ExtractAllConstantPattern if it's constant regexp pattern.
     //
@@ -539,7 +539,7 @@ class Re2ExtractAll final : public VectorFunction {
     }
 
     ArrayBuilder<Varchar> builder(
-        rows.size(), rows.countSelected() * 3, context->pool());
+        rows.size(), rows.countSelected() * 3, context.pool());
     exec::LocalDecodedVector inputStrs(context, *args[0], rows);
     exec::LocalDecodedVector pattern(context, *args[1], rows);
     FOLLY_DECLARE_REUSED(groups, std::vector<re2::StringPiece>);
@@ -548,7 +548,7 @@ class Re2ExtractAll final : public VectorFunction {
       // Case 1: No groupId -- use 0 as the default groupId
       //
       groups.resize(1);
-      context->applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+      context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
         RE2 re(toStringPiece(pattern->valueAt<StringView>(row)), RE2::Quiet);
         checkForBadPattern(re);
         re2ExtractAll(builder, re, inputStrs, row, groups, 0);
@@ -557,7 +557,7 @@ class Re2ExtractAll final : public VectorFunction {
       // Case 2: Has groupId
       //
       exec::LocalDecodedVector groupIds(context, *args[2], rows);
-      context->applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+      context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
         const T groupId = groupIds->valueAt<T>(row);
         RE2 re(toStringPiece(pattern->valueAt<StringView>(row)), RE2::Quiet);
         checkForBadPattern(re);
@@ -571,8 +571,8 @@ class Re2ExtractAll final : public VectorFunction {
       builder.setStringBuffers(fv->stringBuffers());
     }
     std::shared_ptr<ArrayVector> arrayVector =
-        std::move(builder).finish(context->pool());
-    context->moveOrCopyResult(arrayVector, rows, resultRef);
+        std::move(builder).finish(context.pool());
+    context.moveOrCopyResult(arrayVector, rows, resultRef);
   }
 };
 
diff --git a/velox/functions/lib/StringEncodingUtils.cpp b/velox/functions/lib/StringEncodingUtils.cpp
index 2a29ac45de38..4dafe40e3e8c 100644
--- a/velox/functions/lib/StringEncodingUtils.cpp
+++ b/velox/functions/lib/StringEncodingUtils.cpp
@@ -20,23 +20,23 @@
 namespace facebook::velox::functions {
 
 bool prepareFlatResultsVector(
-    VectorPtr* result,
+    VectorPtr& result,
     const SelectivityVector& rows,
-    exec::EvalCtx* context,
+    exec::EvalCtx& context,
     VectorPtr& argToReuse) {
-  if (!*result && BaseVector::isReusableFlatVector(argToReuse)) {
+  if (!result && BaseVector::isReusableFlatVector(argToReuse)) {
     // Move input vector to result
     VELOX_CHECK(
         VectorEncoding::isFlat(argToReuse.get()->encoding()) &&
         argToReuse.get()->typeKind() == TypeKind::VARCHAR);
 
-    *result = std::move(argToReuse);
+    result = std::move(argToReuse);
     return true;
   }
   // This will allocate results if not allocated
-  BaseVector::ensureWritable(rows, VARCHAR(), context->pool(), result);
+  BaseVector::ensureWritable(rows, VARCHAR(), context.pool(), result);
 
-  VELOX_CHECK(VectorEncoding::isFlat((*result).get()->encoding()));
+  VELOX_CHECK(VectorEncoding::isFlat(result->encoding()));
   return false;
 }
 
diff --git a/velox/functions/lib/StringEncodingUtils.h b/velox/functions/lib/StringEncodingUtils.h
index eac370cbe4f5..eeacd155d5fe 100644
--- a/velox/functions/lib/StringEncodingUtils.h
+++ b/velox/functions/lib/StringEncodingUtils.h
@@ -25,9 +25,9 @@ namespace facebook::velox::functions {
 /// It will use the input argToReuse vector instead of creating new one when
 /// possible. Returns true if argToReuse vector was moved to results
 bool prepareFlatResultsVector(
-    VectorPtr* result,
+    VectorPtr& result,
     const SelectivityVector& rows,
-    exec::EvalCtx* context,
+    exec::EvalCtx& context,
     VectorPtr& argToReuse);
 
 /// Return the string encoding of a vector, if not set UTF8 is returned
diff --git a/velox/functions/lib/SubscriptUtil.h b/velox/functions/lib/SubscriptUtil.h
index c356f77f23e2..b97f2ab58aa1 100644
--- a/velox/functions/lib/SubscriptUtil.h
+++ b/velox/functions/lib/SubscriptUtil.h
@@ -44,8 +44,8 @@ class SubscriptImpl : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 2);
     VectorPtr localResult;
 
@@ -61,7 +61,7 @@ class SubscriptImpl : public exec::VectorFunction {
       default:
         VELOX_UNREACHABLE();
     }
-    context->moveOrCopyResult(localResult, rows, result);
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
@@ -95,7 +95,7 @@ class SubscriptImpl : public exec::VectorFunction {
   VectorPtr applyArray(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
-      exec::EvalCtx* context) const {
+      exec::EvalCtx& context) const {
     VELOX_CHECK_EQ(args[0]->typeKind(), TypeKind::ARRAY);
 
     auto arrayArg = args[0];
@@ -118,7 +118,7 @@ class SubscriptImpl : public exec::VectorFunction {
   VectorPtr applyMap(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
-      exec::EvalCtx* context) const {
+      exec::EvalCtx& context) const {
     VELOX_CHECK_EQ(args[0]->typeKind(), TypeKind::MAP);
 
     auto mapArg = args[0];
@@ -153,8 +153,8 @@ class SubscriptImpl : public exec::VectorFunction {
       const SelectivityVector& rows,
       const VectorPtr& arrayArg,
       const VectorPtr& indexArg,
-      exec::EvalCtx* context) const {
-    auto pool = context->pool();
+      exec::EvalCtx& context) const {
+    auto* pool = context.pool();
 
     BufferPtr indices = allocateIndices(rows.size(), pool);
     auto rawIndices = indices->asMutable<vector_size_t>();
@@ -181,14 +181,13 @@ class SubscriptImpl : public exec::VectorFunction {
       try {
         adjustedIndex = adjustIndex(decodedIndices->valueAt<I>(0));
       } catch (const std::exception& e) {
-        rows.applyToSelected([&](auto row) {
-          context->setError(row, std::current_exception());
-        });
+        rows.applyToSelected(
+            [&](auto row) { context.setError(row, std::current_exception()); });
         allFailed = true;
       }
 
       if (!allFailed) {
-        context->applyToSelectedNoThrow(rows, [&](auto row) {
+        context.applyToSelectedNoThrow(rows, [&](auto row) {
           auto elementIndex =
               getIndex(adjustedIndex, row, rawSizes, rawOffsets, arrayIndices);
           rawIndices[row] = elementIndex;
@@ -198,7 +197,7 @@ class SubscriptImpl : public exec::VectorFunction {
         });
       }
     } else {
-      context->applyToSelectedNoThrow(rows, [&](auto row) {
+      context.applyToSelectedNoThrow(rows, [&](auto row) {
         auto adjustedIndex = adjustIndex(decodedIndices->valueAt<I>(row));
         auto elementIndex =
             getIndex(adjustedIndex, row, rawSizes, rawOffsets, arrayIndices);
@@ -281,8 +280,8 @@ class SubscriptImpl : public exec::VectorFunction {
       const SelectivityVector& rows,
       const VectorPtr& mapArg,
       const VectorPtr& indexArg,
-      exec::EvalCtx* context) const {
-    auto pool = context->pool();
+      exec::EvalCtx& context) const {
+    auto* pool = context.pool();
 
     BufferPtr indices = allocateIndices(rows.size(), pool);
     auto rawIndices = indices->asMutable<vector_size_t>();
diff --git a/velox/functions/prestosql/ArrayConstructor.cpp b/velox/functions/prestosql/ArrayConstructor.cpp
index ca9bb7be7671..83ff089f6dde 100644
--- a/velox/functions/prestosql/ArrayConstructor.cpp
+++ b/velox/functions/prestosql/ArrayConstructor.cpp
@@ -29,13 +29,13 @@ class ArrayConstructor : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     auto numArgs = args.size();
 
-    context->ensureWritable(rows, outputType, *result);
-    (*result)->clearNulls(rows);
-    auto arrayResult = (*result)->as<ArrayVector>();
+    context.ensureWritable(rows, outputType, result);
+    result->clearNulls(rows);
+    auto arrayResult = result->as<ArrayVector>();
     auto sizes = arrayResult->mutableSizes(rows.size());
     auto rawSizes = sizes->asMutable<int32_t>();
     auto offsets = arrayResult->mutableOffsets(rows.size());
diff --git a/velox/functions/prestosql/ArrayContains.cpp b/velox/functions/prestosql/ArrayContains.cpp
index a30488b804a5..0a69b2d84e76 100644
--- a/velox/functions/prestosql/ArrayContains.cpp
+++ b/velox/functions/prestosql/ArrayContains.cpp
@@ -160,8 +160,8 @@ class ArrayContainsFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 2);
     const auto& arrayVector = args[0];
     const auto& searchVector = args[1];
@@ -170,8 +170,8 @@ class ArrayContainsFunction : public exec::VectorFunction {
     VELOX_CHECK(arrayVector->type()->asArray().elementType()->kindEquals(
         searchVector->type()));
 
-    context->ensureWritable(rows, BOOLEAN(), *result);
-    auto flatResult = (*result)->asFlatVector<bool>();
+    context.ensureWritable(rows, BOOLEAN(), result);
+    auto flatResult = result->asFlatVector<bool>();
 
     exec::LocalDecodedVector arrayHolder(context, *arrayVector, rows);
     auto elements = arrayHolder.get()->base()->as<ArrayVector>()->elements();
diff --git a/velox/functions/prestosql/ArrayDistinct.cpp b/velox/functions/prestosql/ArrayDistinct.cpp
index 59b7bf334f44..414261bae159 100644
--- a/velox/functions/prestosql/ArrayDistinct.cpp
+++ b/velox/functions/prestosql/ArrayDistinct.cpp
@@ -47,8 +47,8 @@ class ArrayDistinctFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     auto& arg = args[0];
 
     VectorPtr localResult;
@@ -70,14 +70,14 @@ class ArrayDistinctFunction : public exec::VectorFunction {
       localResult = applyFlat(rows, arg, context);
     }
 
-    context->moveOrCopyResult(localResult, rows, result);
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
  private:
   VectorPtr applyFlat(
       const SelectivityVector& rows,
       const VectorPtr& arg,
-      exec::EvalCtx* context) const {
+      exec::EvalCtx& context) const {
     auto arrayVector = arg->as<ArrayVector>();
     auto elementsVector = arrayVector->elements();
     auto elementsRows =
@@ -88,7 +88,7 @@ class ArrayDistinctFunction : public exec::VectorFunction {
     vector_size_t rowCount = arrayVector->size();
 
     // Allocate new vectors for indices, length and offsets.
-    memory::MemoryPool* pool = context->pool();
+    memory::MemoryPool* pool = context.pool();
     BufferPtr newIndices = allocateIndices(elementsCount, pool);
     BufferPtr newLengths = allocateSizes(rowCount, pool);
     BufferPtr newOffsets = allocateOffsets(rowCount, pool);
diff --git a/velox/functions/prestosql/ArrayDuplicates.cpp b/velox/functions/prestosql/ArrayDuplicates.cpp
index 8dc42666262e..5bf7ebc8655e 100644
--- a/velox/functions/prestosql/ArrayDuplicates.cpp
+++ b/velox/functions/prestosql/ArrayDuplicates.cpp
@@ -48,8 +48,8 @@ class ArrayDuplicatesFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args, // Not using const ref so we can reuse args
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     auto& arg = args[0];
 
     VectorPtr localResult;
@@ -71,14 +71,14 @@ class ArrayDuplicatesFunction : public exec::VectorFunction {
       localResult = applyFlat(rows, arg, context);
     }
 
-    context->moveOrCopyResult(localResult, rows, result);
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
  private:
   VectorPtr applyFlat(
       const SelectivityVector& rows,
       const VectorPtr& arg,
-      exec::EvalCtx* context) const {
+      exec::EvalCtx& context) const {
     auto arrayVector = arg->as<ArrayVector>();
     VELOX_CHECK(arrayVector);
     auto elementsVector = arrayVector->elements();
@@ -91,7 +91,7 @@ class ArrayDuplicatesFunction : public exec::VectorFunction {
     vector_size_t numRows = arrayVector->size();
 
     // Allocate new vectors for indices, length and offsets.
-    memory::MemoryPool* pool = context->pool();
+    memory::MemoryPool* pool = context.pool();
     BufferPtr newIndices = allocateIndices(numElements, pool);
     BufferPtr newSizes = allocateSizes(numRows, pool);
     BufferPtr newOffsets = allocateOffsets(numRows, pool);
diff --git a/velox/functions/prestosql/ArrayIntersectExcept.cpp b/velox/functions/prestosql/ArrayIntersectExcept.cpp
index f3b7a35ac532..2b4fb6585571 100644
--- a/velox/functions/prestosql/ArrayIntersectExcept.cpp
+++ b/velox/functions/prestosql/ArrayIntersectExcept.cpp
@@ -123,9 +123,9 @@ class ArrayIntersectExceptFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
-    memory::MemoryPool* pool = context->pool();
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    memory::MemoryPool* pool = context.pool();
     BaseVector* left = args[0].get();
     BaseVector* right = args[1].get();
 
@@ -257,7 +257,7 @@ class ArrayIntersectExceptFunction : public exec::VectorFunction {
         newLengths,
         newElements,
         0);
-    context->moveOrCopyResult(resultArray, rows, result);
+    context.moveOrCopyResult(resultArray, rows, result);
   }
 
   // If one of the arrays is constant, this member will store a pointer to the
@@ -281,8 +281,8 @@ class ArraysOverlapFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     BaseVector* left = args[0].get();
     BaseVector* right = args[1].get();
     if (constantSet_.has_value() && isLeftConstant_) {
@@ -294,8 +294,8 @@ class ArraysOverlapFunction : public exec::VectorFunction {
         decodeArrayElements(arrayDecoder, elementsDecoder, rows);
     auto decodedLeftArray = arrayDecoder.get();
     auto baseLeftArray = decodedLeftArray->base()->as<ArrayVector>();
-    context->ensureWritable(rows, BOOLEAN(), *result);
-    auto resultBoolVector = (*result)->template asFlatVector<bool>();
+    context.ensureWritable(rows, BOOLEAN(), result);
+    auto resultBoolVector = result->template asFlatVector<bool>();
     auto processRow = [&](auto row, const SetWithNull<T>& rightSet) {
       auto idx = decodedLeftArray->index(row);
       auto offset = baseLeftArray->offsetAt(idx);
diff --git a/velox/functions/prestosql/ArrayPosition.cpp b/velox/functions/prestosql/ArrayPosition.cpp
index 2742986d494a..df3076e59126 100644
--- a/velox/functions/prestosql/ArrayPosition.cpp
+++ b/velox/functions/prestosql/ArrayPosition.cpp
@@ -344,16 +344,16 @@ class ArrayPositionFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     const auto& arrayVector = args[0];
     const auto& searchVector = args[1];
     VELOX_CHECK(arrayVector->type()->isArray());
     VELOX_CHECK(arrayVector->type()->asArray().elementType()->kindEquals(
         searchVector->type()));
 
-    context->ensureWritable(rows, BIGINT(), *result);
-    auto flatResult = (*result)->asFlatVector<int64_t>();
+    context.ensureWritable(rows, BIGINT(), result);
+    auto flatResult = result->asFlatVector<int64_t>();
 
     exec::DecodedArgs decodedArgs(rows, args, context);
     auto elements = decodedArgs.at(0)->base()->as<ArrayVector>()->elements();
diff --git a/velox/functions/prestosql/ArraySort.cpp b/velox/functions/prestosql/ArraySort.cpp
index 7d1f1b06a913..34c8af5e02b4 100644
--- a/velox/functions/prestosql/ArraySort.cpp
+++ b/velox/functions/prestosql/ArraySort.cpp
@@ -27,8 +27,8 @@ namespace {
 void applyComplexType(
     const SelectivityVector& rows,
     ArrayVector* inputArray,
-    exec::EvalCtx* context,
-    VectorPtr* resultElements) {
+    exec::EvalCtx& context,
+    VectorPtr& resultElements) {
   auto inputElements = inputArray->elements();
   const SelectivityVector inputElementRows =
       toElementRows(inputElements->size(), rows, inputArray);
@@ -37,7 +37,7 @@ void applyComplexType(
   const auto* baseElementsVector = decodedElements->base();
 
   // Allocate new vectors for indices.
-  BufferPtr indices = allocateIndices(inputElements->size(), context->pool());
+  BufferPtr indices = allocateIndices(inputElements->size(), context.pool());
   vector_size_t* rawIndices = indices->asMutable<vector_size_t>();
 
   const CompareFlags flags{.nullsFirst = false, .ascending = true};
@@ -56,7 +56,7 @@ void applyComplexType(
         });
   });
 
-  *resultElements = BaseVector::transpose(indices, std::move(inputElements));
+  resultElements = BaseVector::transpose(indices, std::move(inputElements));
 }
 
 template <typename T>
@@ -78,8 +78,8 @@ template <TypeKind kind>
 void applyScalarType(
     const SelectivityVector& rows,
     const ArrayVector* inputArray,
-    exec::EvalCtx* context,
-    VectorPtr* resultElements) {
+    exec::EvalCtx& context,
+    VectorPtr& resultElements) {
   using T = typename TypeTraits<kind>::NativeType;
 
   // Copy array elements to new vector.
@@ -94,13 +94,12 @@ void applyScalarType(
   // TODO: consider to use dictionary wrapping to avoid the direct sorting on
   // the scalar values as we do for complex data type if this runs slow in
   // practice.
-  *resultElements =
-      BaseVector::create(inputElements->type(), elementsCount, context->pool());
-  (*resultElements)
-      ->copy(
-          decodedElements->base(), inputElementRows, /*toSourceRow=*/nullptr);
+  resultElements =
+      BaseVector::create(inputElements->type(), elementsCount, context.pool());
+  resultElements->copy(
+      decodedElements->base(), inputElementRows, /*toSourceRow=*/nullptr);
 
-  auto flatResults = (*resultElements)->asFlatVector<T>();
+  auto flatResults = resultElements->asFlatVector<T>();
 
   auto processRow = [&](vector_size_t row) {
     const auto size = inputArray->sizeAt(row);
@@ -161,8 +160,8 @@ class ArraySortFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /*outputType*/,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 1);
     auto& arg = args[0];
 
@@ -185,28 +184,28 @@ class ArraySortFunction : public exec::VectorFunction {
       localResult = applyFlat(rows, arg, context);
     }
 
-    context->moveOrCopyResult(localResult, rows, result);
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
  private:
   VectorPtr applyFlat(
       const SelectivityVector& rows,
       const VectorPtr& arg,
-      exec::EvalCtx* context) const {
+      exec::EvalCtx& context) const {
     // Acquire the array elements vector.
     auto inputArray = arg->as<ArrayVector>();
     VectorPtr resultElements;
 
     if (velox::TypeTraits<T>::isPrimitiveType) {
       VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-          applyScalarType, T, rows, inputArray, context, &resultElements);
+          applyScalarType, T, rows, inputArray, context, resultElements);
 
     } else {
-      applyComplexType(rows, inputArray, context, &resultElements);
+      applyComplexType(rows, inputArray, context, resultElements);
     }
 
     return std::make_shared<ArrayVector>(
-        context->pool(),
+        context.pool(),
         inputArray->type(),
         inputArray->nulls(),
         rows.end(),
diff --git a/velox/functions/prestosql/ArraySum.cpp b/velox/functions/prestosql/ArraySum.cpp
index 5fe2366f06d5..4f435121c1db 100644
--- a/velox/functions/prestosql/ArraySum.cpp
+++ b/velox/functions/prestosql/ArraySum.cpp
@@ -102,11 +102,11 @@ class ArraySumFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args, // Not using const ref so we can reuse args
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     // Prepare result vector for writing
-    BaseVector::ensureWritable(rows, outputType, context->pool(), result);
-    auto resultValues = (*result)->template asFlatVector<TOutput>();
+    BaseVector::ensureWritable(rows, outputType, context.pool(), result);
+    auto resultValues = result->template asFlatVector<TOutput>();
 
     // Acquire the array elements vector.
     auto arrayVector = args[0]->as<ArrayVector>();
diff --git a/velox/functions/prestosql/Comparisons.cpp b/velox/functions/prestosql/Comparisons.cpp
index 086a3f96c35d..05b287fdd36a 100644
--- a/velox/functions/prestosql/Comparisons.cpp
+++ b/velox/functions/prestosql/Comparisons.cpp
@@ -104,13 +104,13 @@ struct SimdComparator {
       const SelectivityVector& rows,
       DecodedVector& lhs,
       DecodedVector& rhs,
-      exec::EvalCtx* context,
-      VectorPtr* result) {
+      exec::EvalCtx& context,
+      VectorPtr& result) {
     using T = typename TypeTraits<kind>::NativeType;
 
     auto rawRhs = rhs.template data<T>();
     auto rawLhs = lhs.template data<T>();
-    auto resultVector = (*result)->asUnchecked<FlatVector<bool>>();
+    auto resultVector = result->asUnchecked<FlatVector<bool>>();
     auto rawResult = resultVector->mutableRawValues<uint8_t>();
 
     auto isSimdizable = (lhs.isConstantMapping() || lhs.isIdentityMapping()) &&
@@ -118,7 +118,7 @@ struct SimdComparator {
         rows.isAllSelected();
 
     if (!isSimdizable) {
-      context->template applyToSelectedNoThrow(rows, [&](auto row) {
+      context.template applyToSelectedNoThrow(rows, [&](auto row) {
         auto l = lhs.template valueAt<T>(row);
         auto r = rhs.template valueAt<T>(row);
         auto filtered = ComparisonOp()(l, r);
@@ -155,8 +155,8 @@ struct SimdComparator {
       const SelectivityVector& rows,
       DecodedVector& lhs,
       DecodedVector& rhs,
-      exec::EvalCtx* context,
-      VectorPtr* result) {
+      exec::EvalCtx& context,
+      VectorPtr& result) {
     VELOX_FAIL("Unsupported type for SIMD comparison");
   }
 };
@@ -168,13 +168,13 @@ class ComparisonSimdFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 2, "Comparison requires two arguments");
     VELOX_CHECK_EQ(args[0]->typeKind(), args[1]->typeKind());
     VELOX_USER_CHECK_EQ(outputType, BOOLEAN());
 
-    context->ensureWritable(rows, outputType, *result);
+    context.ensureWritable(rows, outputType, result);
 
     exec::LocalDecodedVector lhs(context, *args[0], rows);
     exec::LocalDecodedVector rhs(context, *args[1], rows);
diff --git a/velox/functions/prestosql/DecimalArithmetic.cpp b/velox/functions/prestosql/DecimalArithmetic.cpp
index 4e5862dd2fbd..19926d44667f 100644
--- a/velox/functions/prestosql/DecimalArithmetic.cpp
+++ b/velox/functions/prestosql/DecimalArithmetic.cpp
@@ -34,15 +34,15 @@ class DecimalBaseFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& resultType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     auto rawResults = prepareResults(rows, resultType, context, result);
     if (args[0]->isConstantEncoding() && args[1]->isFlatEncoding()) {
       // Fast path for (const, flat).
       auto constant = args[0]->asUnchecked<SimpleVector<A>>()->valueAt(0);
       auto flatValues = args[1]->asUnchecked<FlatVector<B>>();
       auto rawValues = flatValues->mutableRawValues();
-      context->applyToSelectedNoThrow(rows, [&](auto row) {
+      context.applyToSelectedNoThrow(rows, [&](auto row) {
         Operation::template apply<R, A, B>(
             rawResults[row], constant, rawValues[row], aRescale_, bRescale_);
       });
@@ -51,7 +51,7 @@ class DecimalBaseFunction : public exec::VectorFunction {
       auto flatValues = args[0]->asUnchecked<FlatVector<A>>();
       auto constant = args[1]->asUnchecked<SimpleVector<B>>()->valueAt(0);
       auto rawValues = flatValues->mutableRawValues();
-      context->applyToSelectedNoThrow(rows, [&](auto row) {
+      context.applyToSelectedNoThrow(rows, [&](auto row) {
         Operation::template apply<R, A, B>(
             rawResults[row], rawValues[row], constant, aRescale_, bRescale_);
       });
@@ -61,7 +61,7 @@ class DecimalBaseFunction : public exec::VectorFunction {
       auto rawA = flatA->mutableRawValues();
       auto flatB = args[1]->asUnchecked<FlatVector<B>>();
       auto rawB = flatB->mutableRawValues();
-      context->applyToSelectedNoThrow(rows, [&](auto row) {
+      context.applyToSelectedNoThrow(rows, [&](auto row) {
         Operation::template apply<R, A, B>(
             rawResults[row], rawA[row], rawB[row], aRescale_, bRescale_);
       });
@@ -70,7 +70,7 @@ class DecimalBaseFunction : public exec::VectorFunction {
       exec::DecodedArgs decodedArgs(rows, args, context);
       auto a = decodedArgs.at(0);
       auto b = decodedArgs.at(1);
-      context->applyToSelectedNoThrow(rows, [&](auto row) {
+      context.applyToSelectedNoThrow(rows, [&](auto row) {
         Operation::template apply<R, A, B>(
             rawResults[row],
             a->valueAt<A>(row),
@@ -85,11 +85,11 @@ class DecimalBaseFunction : public exec::VectorFunction {
   R* prepareResults(
       const SelectivityVector& rows,
       const TypePtr& resultType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const {
-    context->ensureWritable(rows, resultType, *result);
-    (*result)->clearNulls(rows);
-    return (*result)->asUnchecked<FlatVector<R>>()->mutableRawValues();
+      exec::EvalCtx& context,
+      VectorPtr& result) const {
+    context.ensureWritable(rows, resultType, result);
+    result->clearNulls(rows);
+    return result->asUnchecked<FlatVector<R>>()->mutableRawValues();
   }
 
   const uint8_t aRescale_;
diff --git a/velox/functions/prestosql/FilterFunctions.cpp b/velox/functions/prestosql/FilterFunctions.cpp
index ab372372fc3f..406c5de775a2 100644
--- a/velox/functions/prestosql/FilterFunctions.cpp
+++ b/velox/functions/prestosql/FilterFunctions.cpp
@@ -54,14 +54,14 @@ class FilterFunctionBase : public exec::VectorFunction {
       const std::shared_ptr<T>& input,
       const VectorPtr& lambdas,
       const std::vector<VectorPtr>& lambdaArgs,
-      exec::EvalCtx* context,
+      exec::EvalCtx& context,
       BufferPtr& resultOffsets,
       BufferPtr& resultSizes,
       BufferPtr& selectedIndices) {
     auto inputOffsets = input->rawOffsets();
     auto inputSizes = input->rawSizes();
 
-    auto pool = context->pool();
+    auto* pool = context.pool();
     resultSizes = allocateSizes(rows.size(), pool);
     resultOffsets = allocateOffsets(rows.size(), pool);
     auto rawResultSizes = resultSizes->asMutable<vector_size_t>();
@@ -69,9 +69,9 @@ class FilterFunctionBase : public exec::VectorFunction {
     auto numElements = lambdaArgs[0]->size();
 
     SelectivityVector finalSelection;
-    if (!context->isFinalSelection()) {
-      finalSelection = toElementRows<T>(
-          numElements, *context->finalSelection(), input.get());
+    if (!context.isFinalSelection()) {
+      finalSelection =
+          toElementRows<T>(numElements, *context.finalSelection(), input.get());
     }
 
     exec::LocalDecodedVector bitsDecoder(context);
@@ -84,7 +84,12 @@ class FilterFunctionBase : public exec::VectorFunction {
 
       VectorPtr bits;
       entry.callable->apply(
-          elementRows, finalSelection, wrapCapture, context, lambdaArgs, &bits);
+          elementRows,
+          finalSelection,
+          wrapCapture,
+          &context,
+          lambdaArgs,
+          &bits);
       bitsDecoder.get()->decode(*bits, elementRows);
       entry.rows->applyToSelected([&](vector_size_t row) {
         if (input->isNullAt(row)) {
@@ -120,8 +125,8 @@ class ArrayFilterFunction : public FilterFunctionBase {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 2);
     exec::LocalDecodedVector arrayDecoder(context, *args[0], rows);
     auto& decodedArray = *arrayDecoder.get();
@@ -156,7 +161,7 @@ class ArrayFilterFunction : public FilterFunctionBase {
         std::move(resultOffsets),
         std::move(resultSizes),
         wrappedElements);
-    context->moveOrCopyResult(localResult, rows, result);
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
@@ -180,8 +185,8 @@ class MapFilterFunction : public FilterFunctionBase {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 2);
     exec::LocalDecodedVector mapDecoder(context, *args[0], rows);
     auto& decodedMap = *mapDecoder.get();
@@ -222,7 +227,7 @@ class MapFilterFunction : public FilterFunctionBase {
         std::move(resultSizes),
         wrappedKeys,
         wrappedValues);
-    context->moveOrCopyResult(localResult, rows, result);
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
diff --git a/velox/functions/prestosql/FromUnixTime.cpp b/velox/functions/prestosql/FromUnixTime.cpp
index 74b6a912262e..946c1866be27 100644
--- a/velox/functions/prestosql/FromUnixTime.cpp
+++ b/velox/functions/prestosql/FromUnixTime.cpp
@@ -30,15 +30,15 @@ class FromUnixtimeFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     exec::DecodedArgs decodedArgs(rows, args, context);
 
     auto unixtimes = decodedArgs.at(0);
     auto timezoneNames = decodedArgs.at(1);
 
     const auto size = rows.end();
-    auto* pool = context->pool();
+    auto* pool = context.pool();
 
     auto timestamps = BaseVector::create(BIGINT(), size, pool);
     auto* rawTimestamps =
@@ -77,7 +77,7 @@ class FromUnixtimeFunction : public exec::VectorFunction {
         std::vector<VectorPtr>{timestamps, timezones},
         0 /*nullCount*/);
 
-    context->moveOrCopyResult(localResult, rows, result);
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
diff --git a/velox/functions/prestosql/GreatestLeast.cpp b/velox/functions/prestosql/GreatestLeast.cpp
index 70b208d4cc7e..77c745102fba 100644
--- a/velox/functions/prestosql/GreatestLeast.cpp
+++ b/velox/functions/prestosql/GreatestLeast.cpp
@@ -65,11 +65,11 @@ class ExtremeValueFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       const std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const {
-    context->ensureWritable(rows, outputType, *result);
+      exec::EvalCtx& context,
+      VectorPtr& result) const {
+    context.ensureWritable(rows, outputType, result);
     BufferPtr resultValues =
-        (*result)->as<FlatVector<T>>()->mutableValues(rows.end());
+        result->as<FlatVector<T>>()->mutableValues(rows.end());
     T* __restrict rawResult = resultValues->asMutable<T>();
 
     exec::DecodedArgs decodedArgs(rows, args, context);
@@ -96,7 +96,7 @@ class ExtremeValueFunction : public exec::VectorFunction {
 
     if constexpr (std::
                       is_same_v<T, TypeTraits<TypeKind::VARCHAR>::NativeType>) {
-      auto* flatResult = (*result)->as<FlatVector<T>>();
+      auto* flatResult = result->as<FlatVector<T>>();
       for (auto index : usedInputs) {
         flatResult->acquireSharedStringBuffers(args[index].get());
       }
@@ -108,8 +108,8 @@ class ExtremeValueFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     switch (outputType.get()->kind()) {
       case TypeKind::BIGINT:
         applyTyped<TypeTraits<TypeKind::BIGINT>::NativeType>(
diff --git a/velox/functions/prestosql/InPredicate.cpp b/velox/functions/prestosql/InPredicate.cpp
index 8b4e5ee2b066..1fda1e3b49dd 100644
--- a/velox/functions/prestosql/InPredicate.cpp
+++ b/velox/functions/prestosql/InPredicate.cpp
@@ -143,8 +143,8 @@ class InPredicate : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     const auto& input = args[0];
     switch (input->typeKind()) {
       case TypeKind::BIGINT:
@@ -198,23 +198,23 @@ class InPredicate : public exec::VectorFunction {
  private:
   static VectorPtr createBoolConstantNull(
       vector_size_t size,
-      exec::EvalCtx* context) {
+      exec::EvalCtx& context) {
     return BaseVector::createConstant(
-        variant(TypeKind::BOOLEAN), size, context->pool());
+        variant(TypeKind::BOOLEAN), size, context.pool());
   }
 
   static VectorPtr
-  createBoolConstant(bool value, vector_size_t size, exec::EvalCtx* context) {
-    return BaseVector::createConstant(value, size, context->pool());
+  createBoolConstant(bool value, vector_size_t size, exec::EvalCtx& context) {
+    return BaseVector::createConstant(value, size, context.pool());
   }
 
   template <typename T, typename F>
   void applyTyped(
       const SelectivityVector& rows,
       const VectorPtr& arg,
-      exec::EvalCtx* context,
-      VectorPtr* result,
-      F testFunction) const {
+      exec::EvalCtx& context,
+      VectorPtr& result,
+      F&& testFunction) const {
     VELOX_CHECK(filter_, "IN predicate supports only constant IN list");
 
     // Indicates whether result can be true or null only, e.g. no false results.
@@ -234,7 +234,7 @@ class InPredicate : public exec::VectorFunction {
         }
       }
 
-      context->moveOrCopyResult(localResult, rows, result);
+      context.moveOrCopyResult(localResult, rows, result);
       return;
     }
 
@@ -242,10 +242,10 @@ class InPredicate : public exec::VectorFunction {
     auto flatArg = arg->asUnchecked<FlatVector<T>>();
     auto rawValues = flatArg->rawValues();
 
-    context->ensureWritable(rows, BOOLEAN(), *result);
-    auto boolResult = static_cast<FlatVector<bool>*>((*result).get());
+    context.ensureWritable(rows, BOOLEAN(), result);
+    auto* boolResult = result->asUnchecked<FlatVector<bool>>();
 
-    auto rawResults = boolResult->mutableRawValues<uint64_t>();
+    auto* rawResults = boolResult->mutableRawValues<uint64_t>();
 
     if (flatArg->mayHaveNulls() || passOrNull) {
       rows.applyToSelected([&](auto row) {
diff --git a/velox/functions/prestosql/Map.cpp b/velox/functions/prestosql/Map.cpp
index 6c3434abb711..4c5c815206db 100644
--- a/velox/functions/prestosql/Map.cpp
+++ b/velox/functions/prestosql/Map.cpp
@@ -26,8 +26,8 @@ class MapFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 2);
 
     auto keys = args[0];
@@ -58,7 +58,7 @@ class MapFunction : public exec::VectorFunction {
       });
 
       mapVector = std::make_shared<MapVector>(
-          context->pool(),
+          context.pool(),
           outputType,
           BufferPtr(nullptr),
           rows.size(),
@@ -87,16 +87,16 @@ class MapFunction : public exec::VectorFunction {
         totalElements += keysArray->sizeAt(keyIndices[row]);
       });
 
-      BufferPtr offsets = allocateOffsets(rows.size(), context->pool());
+      BufferPtr offsets = allocateOffsets(rows.size(), context.pool());
       auto rawOffsets = offsets->asMutable<vector_size_t>();
 
-      BufferPtr sizes = allocateSizes(rows.size(), context->pool());
+      BufferPtr sizes = allocateSizes(rows.size(), context.pool());
       auto rawSizes = sizes->asMutable<vector_size_t>();
 
-      BufferPtr valuesIndices = allocateIndices(totalElements, context->pool());
+      BufferPtr valuesIndices = allocateIndices(totalElements, context.pool());
       auto rawValuesIndices = valuesIndices->asMutable<vector_size_t>();
 
-      BufferPtr keysIndices = allocateIndices(totalElements, context->pool());
+      BufferPtr keysIndices = allocateIndices(totalElements, context.pool());
       auto rawKeysIndices = keysIndices->asMutable<vector_size_t>();
 
       vector_size_t offset = 0;
@@ -128,7 +128,7 @@ class MapFunction : public exec::VectorFunction {
           valuesArray->elements());
 
       mapVector = std::make_shared<MapVector>(
-          context->pool(),
+          context.pool(),
           outputType,
           BufferPtr(nullptr),
           rows.size(),
@@ -158,7 +158,7 @@ class MapFunction : public exec::VectorFunction {
         }
       });
     }
-    context->moveOrCopyResult(mapVector, rows, result);
+    context.moveOrCopyResult(mapVector, rows, result);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
diff --git a/velox/functions/prestosql/MapConcat.cpp b/velox/functions/prestosql/MapConcat.cpp
index 2a020aa77aee..5a7b983b6f64 100644
--- a/velox/functions/prestosql/MapConcat.cpp
+++ b/velox/functions/prestosql/MapConcat.cpp
@@ -32,8 +32,8 @@ class MapConcatFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK(args.size() >= 2);
     auto mapType = args[0]->type();
     VELOX_CHECK_EQ(mapType->kind(), TypeKind::MAP);
@@ -57,16 +57,16 @@ class MapConcatFunction : public exec::VectorFunction {
     auto keyType = outputType->asMap().keyType();
     auto valueType = outputType->asMap().valueType();
 
-    auto combinedKeys = BaseVector::create(keyType, maxSize, context->pool());
-    auto combinedValues =
-        BaseVector::create(valueType, maxSize, context->pool());
+    auto* pool = context.pool();
+    auto combinedKeys = BaseVector::create(keyType, maxSize, pool);
+    auto combinedValues = BaseVector::create(valueType, maxSize, pool);
 
     // Initialize offsets and sizes to 0 so that canonicalize() will
     // work also for sparse 'rows'.
-    BufferPtr offsets = allocateOffsets(rows.size(), context->pool());
+    BufferPtr offsets = allocateOffsets(rows.size(), pool);
     auto rawOffsets = offsets->asMutable<vector_size_t>();
 
-    BufferPtr sizes = allocateSizes(rows.size(), context->pool());
+    BufferPtr sizes = allocateSizes(rows.size(), pool);
     auto rawSizes = sizes->asMutable<vector_size_t>();
 
     vector_size_t offset = 0;
@@ -92,7 +92,7 @@ class MapConcatFunction : public exec::VectorFunction {
     });
 
     auto combinedMap = std::make_shared<MapVector>(
-        context->pool(),
+        pool,
         outputType,
         BufferPtr(nullptr),
         rows.size(),
@@ -130,7 +130,7 @@ class MapConcatFunction : public exec::VectorFunction {
       uniqueKeys.updateBounds();
       auto uniqueCount = uniqueKeys.countSelected();
 
-      BufferPtr uniqueIndices = allocateIndices(uniqueCount, context->pool());
+      BufferPtr uniqueIndices = allocateIndices(uniqueCount, pool);
       auto rawUniqueIndices = uniqueIndices->asMutable<vector_size_t>();
       vector_size_t index = 0;
       uniqueKeys.applyToSelected(
@@ -141,7 +141,7 @@ class MapConcatFunction : public exec::VectorFunction {
           BaseVector::transpose(uniqueIndices, std::move(combinedValues));
 
       combinedMap = std::make_shared<MapVector>(
-          context->pool(),
+          pool,
           outputType,
           BufferPtr(nullptr),
           rows.size(),
@@ -151,7 +151,7 @@ class MapConcatFunction : public exec::VectorFunction {
           values);
     }
 
-    context->moveOrCopyResult(combinedMap, rows, result);
+    context.moveOrCopyResult(combinedMap, rows, result);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
diff --git a/velox/functions/prestosql/MapEntries.cpp b/velox/functions/prestosql/MapEntries.cpp
index fd724321017e..56de59043b0b 100644
--- a/velox/functions/prestosql/MapEntries.cpp
+++ b/velox/functions/prestosql/MapEntries.cpp
@@ -26,8 +26,8 @@ class MapEntriesFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     auto& arg = args[0];
 
     VectorPtr localResult;
@@ -49,7 +49,7 @@ class MapEntriesFunction : public exec::VectorFunction {
       localResult = applyFlat(rows, arg, outputType, context);
     }
 
-    context->moveOrCopyResult(localResult, rows, result);
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
@@ -67,18 +67,18 @@ class MapEntriesFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       const VectorPtr& arg,
       const TypePtr& outputType,
-      exec::EvalCtx* context) const {
+      exec::EvalCtx& context) const {
     const auto inputMap = arg->as<MapVector>();
 
     VectorPtr resultElements = std::make_shared<RowVector>(
-        context->pool(),
+        context.pool(),
         outputType->childAt(0),
         BufferPtr(nullptr),
         inputMap->mapKeys()->size(),
         std::vector<VectorPtr>{inputMap->mapKeys(), inputMap->mapValues()});
 
     return std::make_shared<ArrayVector>(
-        context->pool(),
+        context.pool(),
         outputType,
         inputMap->nulls(),
         rows.size(),
diff --git a/velox/functions/prestosql/MapKeysAndValues.cpp b/velox/functions/prestosql/MapKeysAndValues.cpp
index 7cf5213c2dde..89fa8c023333 100644
--- a/velox/functions/prestosql/MapKeysAndValues.cpp
+++ b/velox/functions/prestosql/MapKeysAndValues.cpp
@@ -25,8 +25,8 @@ class MapKeyValueFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     auto& arg = args[0];
 
     VectorPtr localResult;
@@ -48,7 +48,7 @@ class MapKeyValueFunction : public exec::VectorFunction {
       localResult = applyFlat(rows, arg, context);
     }
 
-    context->moveOrCopyResult(localResult, rows, result);
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
  protected:
@@ -57,7 +57,7 @@ class MapKeyValueFunction : public exec::VectorFunction {
   virtual VectorPtr applyFlat(
       const SelectivityVector& rows,
       const VectorPtr& arg,
-      exec::EvalCtx* context) const = 0;
+      exec::EvalCtx& context) const = 0;
 
  private:
   const std::string name_;
@@ -70,7 +70,7 @@ class MapKeysFunction : public MapKeyValueFunction {
   VectorPtr applyFlat(
       const SelectivityVector& rows,
       const VectorPtr& arg,
-      exec::EvalCtx* context) const override {
+      exec::EvalCtx& context) const override {
     VELOX_CHECK(
         arg->typeKind() == TypeKind::MAP,
         "Unsupported type for map_keys function {}",
@@ -79,7 +79,7 @@ class MapKeysFunction : public MapKeyValueFunction {
     auto mapVector = arg->as<MapVector>();
     auto mapKeys = mapVector->mapKeys();
     return std::make_shared<ArrayVector>(
-        context->pool(),
+        context.pool(),
         ARRAY(mapKeys->type()),
         mapVector->nulls(),
         rows.size(),
@@ -107,7 +107,7 @@ class MapValuesFunction : public MapKeyValueFunction {
   VectorPtr applyFlat(
       const SelectivityVector& rows,
       const VectorPtr& arg,
-      exec::EvalCtx* context) const override {
+      exec::EvalCtx& context) const override {
     VELOX_CHECK(
         arg->typeKind() == TypeKind::MAP,
         "Unsupported type for map_keys function {}",
@@ -116,7 +116,7 @@ class MapValuesFunction : public MapKeyValueFunction {
     auto mapVector = arg->as<MapVector>();
     auto mapValues = mapVector->mapValues();
     return std::make_shared<ArrayVector>(
-        context->pool(),
+        context.pool(),
         ARRAY(mapValues->type()),
         mapVector->nulls(),
         rows.size(),
diff --git a/velox/functions/prestosql/Not.cpp b/velox/functions/prestosql/Not.cpp
index d63fa19d3cea..6f8202212c18 100644
--- a/velox/functions/prestosql/Not.cpp
+++ b/velox/functions/prestosql/Not.cpp
@@ -24,8 +24,8 @@ class NotFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(
         args.size(), 1, "Incorrect number of arguments passed to not");
     const auto& input = args[0];
@@ -39,9 +39,9 @@ class NotFunction : public exec::VectorFunction {
     if (input->isConstantEncoding()) {
       bool value = input->as<ConstantVector<bool>>()->valueAt(0);
       negated =
-          AlignedBuffer::allocate<bool>(rows.size(), context->pool(), !value);
+          AlignedBuffer::allocate<bool>(rows.size(), context.pool(), !value);
     } else {
-      negated = AlignedBuffer::allocate<bool>(rows.size(), context->pool());
+      negated = AlignedBuffer::allocate<bool>(rows.size(), context.pool());
       auto rawNegated = negated->asMutable<char>();
 
       auto rawInput = input->asFlatVector<bool>()->rawValues<uint64_t>();
@@ -51,13 +51,13 @@ class NotFunction : public exec::VectorFunction {
     }
 
     auto localResult = std::make_shared<FlatVector<bool>>(
-        context->pool(),
+        context.pool(),
         nullptr,
         rows.size(),
         negated,
         std::vector<BufferPtr>{});
 
-    context->moveOrCopyResult(localResult, rows, result);
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
diff --git a/velox/functions/prestosql/Reduce.cpp b/velox/functions/prestosql/Reduce.cpp
index 26f6724d0d88..fea7da30cc5d 100644
--- a/velox/functions/prestosql/Reduce.cpp
+++ b/velox/functions/prestosql/Reduce.cpp
@@ -70,8 +70,8 @@ class ReduceFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 4);
 
     // Flatten input array.
@@ -82,7 +82,7 @@ class ReduceFunction : public exec::VectorFunction {
 
     const auto& initialState = args[1];
     auto partialResult =
-        BaseVector::create(initialState->type(), rows.end(), context->pool());
+        BaseVector::create(initialState->type(), rows.end(), context.pool());
 
     // Process null and empty arrays.
     auto* rawNulls = flatArray->rawNulls();
@@ -97,16 +97,16 @@ class ReduceFunction : public exec::VectorFunction {
 
     // Fix finalSelection at "rows" unless already fixed.
     VarSetter finalSelection(
-        context->mutableFinalSelection(), &rows, context->isFinalSelection());
-    VarSetter isFinalSelection(context->mutableIsFinalSelection(), false);
-    const SelectivityVector& finalSelectionRows = *context->finalSelection();
+        context.mutableFinalSelection(), &rows, context.isFinalSelection());
+    VarSetter isFinalSelection(context.mutableIsFinalSelection(), false);
+    const SelectivityVector& finalSelectionRows = *context.finalSelection();
 
     // Loop over lambda functions and apply these to elements of the base array.
     // In most cases there will be only one function and the loop will run once.
     auto inputFuncIt = args[2]->asUnchecked<FunctionVector>()->iterator(&rows);
 
     BufferPtr elementIndices =
-        allocateIndices(flatArray->size(), context->pool());
+        allocateIndices(flatArray->size(), context.pool());
     SelectivityVector arrayRows(flatArray->size(), false);
 
     // Iteratively apply input function to array elements.
@@ -143,7 +143,7 @@ class ReduceFunction : public exec::VectorFunction {
             arrayRows,
             finalSelectionRows,
             nullptr,
-            context,
+            &context,
             lambdaArgs,
             &partialResult);
         state = partialResult;
@@ -159,9 +159,9 @@ class ReduceFunction : public exec::VectorFunction {
           *entry.rows,
           finalSelectionRows,
           nullptr,
-          context,
+          &context,
           lambdaArgs,
-          result);
+          &result);
     }
   }
 
diff --git a/velox/functions/prestosql/Reverse.cpp b/velox/functions/prestosql/Reverse.cpp
index 426d46e988a0..fd30298bd7d7 100644
--- a/velox/functions/prestosql/Reverse.cpp
+++ b/velox/functions/prestosql/Reverse.cpp
@@ -49,8 +49,8 @@ class ReverseFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 1);
 
     switch (args[0]->typeKind()) {
@@ -70,14 +70,14 @@ class ReverseFunction : public exec::VectorFunction {
   void applyVarchar(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
-      exec::EvalCtx* context,
-      VectorPtr* result) const {
+      exec::EvalCtx& context,
+      VectorPtr& result) const {
     auto* arg = args[0].get();
 
     auto ascii = isAscii(arg, rows);
 
     prepareFlatResultsVector(result, rows, context, args[0]);
-    auto* flatResult = (*result)->as<FlatVector<StringView>>();
+    auto* flatResult = result->as<FlatVector<StringView>>();
 
     // Input can be constant or flat.
     if (arg->isConstantEncoding()) {
@@ -114,8 +114,8 @@ class ReverseFunction : public exec::VectorFunction {
   void applyArray(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
-      exec::EvalCtx* context,
-      VectorPtr* result) const {
+      exec::EvalCtx& context,
+      VectorPtr& result) const {
     auto& arg = args[0];
 
     VectorPtr localResult;
@@ -137,18 +137,18 @@ class ReverseFunction : public exec::VectorFunction {
       localResult = applyArrayFlat(rows, arg, context);
     }
 
-    context->moveOrCopyResult(localResult, rows, result);
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
   VectorPtr applyArrayFlat(
       const SelectivityVector& rows,
       const VectorPtr& vector,
-      exec::EvalCtx* context) const {
+      exec::EvalCtx& context) const {
     auto arrayVector = vector->as<ArrayVector>();
     auto elementCount = arrayVector->elements()->size();
 
     // Allocate new vectors for indices.
-    auto pool = context->pool();
+    auto* pool = context.pool();
     BufferPtr indices = allocateIndices(elementCount, pool);
     auto rawIndices = indices->asMutable<vector_size_t>();
 
diff --git a/velox/functions/prestosql/RowFunction.cpp b/velox/functions/prestosql/RowFunction.cpp
index 7ae97804307d..3855be8627a6 100644
--- a/velox/functions/prestosql/RowFunction.cpp
+++ b/velox/functions/prestosql/RowFunction.cpp
@@ -25,17 +25,17 @@ class RowFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     auto argsCopy = args;
     RowVectorPtr row = std::make_shared<RowVector>(
-        context->pool(),
+        context.pool(),
         outputType,
         BufferPtr(nullptr),
         rows.size(),
         std::move(argsCopy),
         0 /*nullCount*/);
-    context->moveOrCopyResult(row, rows, *result);
+    context.moveOrCopyResult(row, rows, result);
   }
 
   bool isDefaultNullBehavior() const override {
diff --git a/velox/functions/prestosql/Slice.cpp b/velox/functions/prestosql/Slice.cpp
index 7348c7b3abcc..d41b6b27e02d 100644
--- a/velox/functions/prestosql/Slice.cpp
+++ b/velox/functions/prestosql/Slice.cpp
@@ -54,8 +54,8 @@ class SliceFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_USER_CHECK_EQ(
         args[0]->typeKind(),
         TypeKind::ARRAY,
@@ -71,7 +71,7 @@ class SliceFunction : public exec::VectorFunction {
 
     VectorPtr localResult =
         applyArray<int64_t>(rows, args, context, outputType);
-    context->moveOrCopyResult(localResult, rows, result);
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
  private:
@@ -81,9 +81,9 @@ class SliceFunction : public exec::VectorFunction {
   VectorPtr applyArray(
       const SelectivityVector& rows,
       const std::vector<VectorPtr>& args,
-      exec::EvalCtx* context,
+      exec::EvalCtx& context,
       const TypePtr& outputType) const {
-    auto pool = context->pool();
+    auto pool = context.pool();
     BufferPtr offsets = allocateOffsets(rows.end(), pool);
     auto rawOffsets = offsets->asMutable<vector_size_t>();
     BufferPtr sizes = allocateSizes(rows.end(), pool);
@@ -124,13 +124,13 @@ class SliceFunction : public exec::VectorFunction {
       try {
         vector_size_t adjustedStart = adjustIndex(
             static_cast<vector_size_t>(decodedStart->valueAt<T>(0)));
-        context->applyToSelectedNoThrow(
+        context.applyToSelectedNoThrow(
             rows, [&](auto row) { fillResultVectorFunc(row, adjustedStart); });
       } catch (const std::exception& /*e*/) {
-        context->setErrors(rows, std::current_exception());
+        context.setErrors(rows, std::current_exception());
       }
     } else {
-      context->applyToSelectedNoThrow(rows, [&](auto row) {
+      context.applyToSelectedNoThrow(rows, [&](auto row) {
         auto adjustedStart = adjustIndex(
             static_cast<vector_size_t>(decodedStart->valueAt<T>(row)));
         fillResultVectorFunc(row, adjustedStart);
diff --git a/velox/functions/prestosql/Split.cpp b/velox/functions/prestosql/Split.cpp
index 8a5281434181..4bc04325cab2 100644
--- a/velox/functions/prestosql/Split.cpp
+++ b/velox/functions/prestosql/Split.cpp
@@ -72,8 +72,8 @@ class SplitFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     // If no 'limit' specified we just pick some int type.
     // Should we have two passes, with limit and without?
     TypeKind limitType =
@@ -96,8 +96,8 @@ class SplitFunction : public exec::VectorFunction {
   void applyTyped(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
-      exec::EvalCtx* context,
-      VectorPtr* result) const {
+      exec::EvalCtx& context,
+      VectorPtr& result) const {
     // Get the decoded vectors out of arguments.
     const bool noLimit = (args.size() == 2);
     exec::DecodedArgs decodedArgs(rows, args, context);
@@ -107,7 +107,7 @@ class SplitFunction : public exec::VectorFunction {
 
     // Build the result vector (arrays of strings) using Array Builder.
     ArrayBuilder<Varchar> builder(
-        rows.end(), 3 * rows.countSelected(), context->pool());
+        rows.end(), 3 * rows.countSelected(), context.pool());
 
     // Optimization for the (flat, const, const) case.
     if (strings->isIdentityMapping() and delims->isConstantMapping() and
@@ -131,7 +131,7 @@ class SplitFunction : public exec::VectorFunction {
           auto pex = std::make_exception_ptr(
               std::invalid_argument("Limit must be positive"));
           rows.applyToSelected(
-              [&](vector_size_t row) { context->setError(row, pex); });
+              [&](vector_size_t row) { context.setError(row, pex); });
         }
       }
 
@@ -150,14 +150,14 @@ class SplitFunction : public exec::VectorFunction {
     }
 
     std::shared_ptr<ArrayVector> arrayVector =
-        std::move(builder).finish(context->pool());
-    context->moveOrCopyResult(arrayVector, rows, result);
+        std::move(builder).finish(context.pool());
+    context.moveOrCopyResult(arrayVector, rows, result);
   }
 
   template <typename I>
   void applyDecoded(
       const SelectivityVector& rows,
-      exec::EvalCtx* context,
+      exec::EvalCtx& context,
       DecodedVector* strings,
       DecodedVector* delims,
       DecodedVector* limits,
@@ -185,7 +185,7 @@ class SplitFunction : public exec::VectorFunction {
         } else {
           auto pex = std::make_exception_ptr(
               std::invalid_argument("Limit must be positive"));
-          context->setError(row, pex);
+          context.setError(row, pex);
         }
       });
     }
diff --git a/velox/functions/prestosql/StringFunctions.cpp b/velox/functions/prestosql/StringFunctions.cpp
index ba47c9ae825a..dfe2e7c117e8 100644
--- a/velox/functions/prestosql/StringFunctions.cpp
+++ b/velox/functions/prestosql/StringFunctions.cpp
@@ -84,8 +84,8 @@ class UpperLowerTemplateFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK(args.size() == 1);
     VELOX_CHECK(args[0]->typeKind() == TypeKind::VARCHAR);
 
@@ -104,7 +104,7 @@ class UpperLowerTemplateFunction : public exec::VectorFunction {
     // buffer can be reused as output.
     if (tryInplace &&
         prepareFlatResultsVector(result, rows, context, args.at(0))) {
-      auto* resultFlatVector = (*result)->as<FlatVector<StringView>>();
+      auto* resultFlatVector = result->as<FlatVector<StringView>>();
       applyInternalInPlace(rows, decodedInput, resultFlatVector);
       return;
     }
@@ -112,7 +112,7 @@ class UpperLowerTemplateFunction : public exec::VectorFunction {
     // Not in place path.
     VectorPtr emptyVectorPtr;
     prepareFlatResultsVector(result, rows, context, emptyVectorPtr);
-    auto* resultFlatVector = (*result)->as<FlatVector<StringView>>();
+    auto* resultFlatVector = result->as<FlatVector<StringView>>();
 
     StringEncodingTemplateWrapper<ApplyInternal>::apply(
         ascii, rows, decodedInput, resultFlatVector);
@@ -151,11 +151,11 @@ class ConcatFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VectorPtr emptyVectorPtr;
     prepareFlatResultsVector(result, rows, context, emptyVectorPtr);
-    auto* resultFlatVector = (*result)->as<FlatVector<StringView>>();
+    auto* resultFlatVector = result->as<FlatVector<StringView>>();
 
     exec::DecodedArgs decodedArgs(rows, args, context);
 
@@ -223,16 +223,16 @@ class StringPosition : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     exec::DecodedArgs decodedArgs(rows, args, context);
     auto decodedStringInput = decodedArgs.at(0);
     auto decodedSubStringInput = decodedArgs.at(1);
 
     auto stringArgStringEncoding = isAscii(args.at(0).get(), rows);
-    context->ensureWritable(rows, BIGINT(), *result);
+    context.ensureWritable(rows, BIGINT(), result);
 
-    auto* resultFlatVector = (*result)->as<FlatVector<int64_t>>();
+    auto* resultFlatVector = result->as<FlatVector<int64_t>>();
 
     auto stringReader = [&](const vector_size_t row) {
       return decodedStringInput->valueAt<StringView>(row);
@@ -362,8 +362,8 @@ class Replace : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     // Read string input
     exec::LocalDecodedVector decodedStringHolder(context, *args[0], rows);
     auto decodedStringInput = decodedStringHolder.get();
@@ -421,7 +421,7 @@ class Replace : public exec::VectorFunction {
 
     if (tryInplace) {
       if (prepareFlatResultsVector(result, rows, context, args.at(0))) {
-        auto* resultFlatVector = (*result)->as<FlatVector<StringView>>();
+        auto* resultFlatVector = result->as<FlatVector<StringView>>();
         applyInPlace(
             stringReader, searchReader, replaceReader, rows, resultFlatVector);
         return;
@@ -431,7 +431,7 @@ class Replace : public exec::VectorFunction {
     // Not in place path
     VectorPtr emptyVectorPtr;
     prepareFlatResultsVector(result, rows, context, emptyVectorPtr);
-    auto* resultFlatVector = (*result)->as<FlatVector<StringView>>();
+    auto* resultFlatVector = result->as<FlatVector<StringView>>();
 
     applyInternal(
         stringReader, searchReader, replaceReader, rows, resultFlatVector);
diff --git a/velox/functions/prestosql/ToUtf8.cpp b/velox/functions/prestosql/ToUtf8.cpp
index 26548e1c138c..7cc4bef62cce 100644
--- a/velox/functions/prestosql/ToUtf8.cpp
+++ b/velox/functions/prestosql/ToUtf8.cpp
@@ -24,8 +24,8 @@ class ToUtf8Function : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VectorPtr localResult;
 
     // Input can be constant or flat.
@@ -33,13 +33,13 @@ class ToUtf8Function : public exec::VectorFunction {
     if (arg->isConstantEncoding()) {
       auto value = arg->as<ConstantVector<StringView>>()->valueAt(0);
       localResult = std::make_shared<ConstantVector<StringView>>(
-          context->pool(), rows.size(), false, VARBINARY(), std::move(value));
+          context.pool(), rows.size(), false, VARBINARY(), std::move(value));
     } else {
       auto flatInput = arg->asFlatVector<StringView>();
 
       auto stringBuffers = flatInput->stringBuffers();
       localResult = std::make_shared<FlatVector<StringView>>(
-          context->pool(),
+          context.pool(),
           VARBINARY(),
           nullptr,
           rows.size(),
@@ -47,7 +47,7 @@ class ToUtf8Function : public exec::VectorFunction {
           std::move(stringBuffers));
     }
 
-    context->moveOrCopyResult(localResult, rows, result);
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
diff --git a/velox/functions/prestosql/Transform.cpp b/velox/functions/prestosql/Transform.cpp
index e74fea5585ba..922d2d11e5b9 100644
--- a/velox/functions/prestosql/Transform.cpp
+++ b/velox/functions/prestosql/Transform.cpp
@@ -36,8 +36,8 @@ class TransformFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 2);
 
     // Flatten input array.
@@ -50,9 +50,9 @@ class TransformFunction : public exec::VectorFunction {
     auto newNumElements = flatArray->elements()->size();
 
     SelectivityVector finalSelection;
-    if (!context->isFinalSelection()) {
+    if (!context.isFinalSelection()) {
       finalSelection = toElementRows<ArrayVector>(
-          newNumElements, *context->finalSelection(), flatArray.get());
+          newNumElements, *context.finalSelection(), flatArray.get());
     }
 
     // transformed elements
@@ -71,7 +71,7 @@ class TransformFunction : public exec::VectorFunction {
           elementRows,
           finalSelection,
           wrapCapture,
-          context,
+          &context,
           lambdaArgs,
           &newElements);
     }
@@ -84,7 +84,7 @@ class TransformFunction : public exec::VectorFunction {
         flatArray->offsets(),
         flatArray->sizes(),
         newElements);
-    context->moveOrCopyResult(localResult, rows, result);
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
diff --git a/velox/functions/prestosql/TransformKeys.cpp b/velox/functions/prestosql/TransformKeys.cpp
index a21a9777a1b6..bf0d69fd2c76 100644
--- a/velox/functions/prestosql/TransformKeys.cpp
+++ b/velox/functions/prestosql/TransformKeys.cpp
@@ -36,8 +36,8 @@ class TransformKeysFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 2);
 
     // Flatten input map.
@@ -51,9 +51,9 @@ class TransformKeysFunction : public exec::VectorFunction {
     auto numKeys = flatMap->mapKeys()->size();
 
     SelectivityVector finalSelection;
-    if (!context->isFinalSelection()) {
+    if (!context.isFinalSelection()) {
       finalSelection = toElementRows<MapVector>(
-          numKeys, *context->finalSelection(), flatMap.get());
+          numKeys, *context.finalSelection(), flatMap.get());
     }
 
     VectorPtr transformedKeys;
@@ -71,7 +71,7 @@ class TransformKeysFunction : public exec::VectorFunction {
           keyRows,
           finalSelection,
           wrapCapture,
-          context,
+          &context,
           lambdaArgs,
           &transformedKeys);
     }
@@ -88,7 +88,7 @@ class TransformKeysFunction : public exec::VectorFunction {
 
     checkDuplicateKeys(localResult, rows);
 
-    context->moveOrCopyResult(localResult, rows, result);
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
diff --git a/velox/functions/prestosql/TransformValues.cpp b/velox/functions/prestosql/TransformValues.cpp
index 0241e6173149..6114945445b4 100644
--- a/velox/functions/prestosql/TransformValues.cpp
+++ b/velox/functions/prestosql/TransformValues.cpp
@@ -36,8 +36,8 @@ class TransformValuesFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 2);
 
     // Flatten input map.
@@ -51,9 +51,9 @@ class TransformValuesFunction : public exec::VectorFunction {
     auto numValues = flatMap->mapValues()->size();
 
     SelectivityVector finalSelection;
-    if (!context->isFinalSelection()) {
+    if (!context.isFinalSelection()) {
       finalSelection = toElementRows<MapVector>(
-          numValues, *context->finalSelection(), flatMap.get());
+          numValues, *context.finalSelection(), flatMap.get());
     }
 
     VectorPtr transformedValues;
@@ -71,7 +71,7 @@ class TransformValuesFunction : public exec::VectorFunction {
           valueRows,
           finalSelection,
           wrapCapture,
-          context,
+          &context,
           lambdaArgs,
           &transformedValues);
     }
@@ -85,7 +85,7 @@ class TransformValuesFunction : public exec::VectorFunction {
         flatMap->sizes(),
         flatMap->mapKeys(),
         transformedValues);
-    context->moveOrCopyResult(localResult, rows, result);
+    context.moveOrCopyResult(localResult, rows, result);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
diff --git a/velox/functions/prestosql/VectorArithmetic.cpp b/velox/functions/prestosql/VectorArithmetic.cpp
index 92e40e0f44be..af950662aa76 100644
--- a/velox/functions/prestosql/VectorArithmetic.cpp
+++ b/velox/functions/prestosql/VectorArithmetic.cpp
@@ -74,8 +74,8 @@ class VectorArithmetic : public VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      EvalCtx* context,
-      VectorPtr* result) const override {
+      EvalCtx& context,
+      VectorPtr& result) const override {
     // Same basic checks on the number of inputs and their kinds
     VELOX_CHECK(args.size() == 2);
     VELOX_CHECK(args[0]->typeKind() == args[1]->typeKind());
@@ -116,8 +116,8 @@ class VectorArithmetic : public VectorFunction {
       const SelectivityVector& rows,
       const std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      EvalCtx* context,
-      VectorPtr* result) const {
+      EvalCtx& context,
+      VectorPtr& result) const {
     BaseVector* left = args[0].get();
     BaseVector* right = args[1].get();
     auto leftEncoding = left->encoding();
@@ -131,23 +131,24 @@ class VectorArithmetic : public VectorFunction {
     // (1) Its unique() property must be true!
     // (2) the input type must match the output vector type
     // (3) usually we try to reuse inputs with flat encoding
-    if (!*result) {
+    if (!result) {
       if (args[0].unique() && leftEncoding == VectorEncoding::Simple::FLAT) {
-        *result = std::move(args[0]);
+        result = std::move(args[0]);
       } else if (
+
           args[1].unique() && rightEncoding == VectorEncoding::Simple::FLAT) {
-        *result = std::move(args[1]);
+        result = std::move(args[1]);
       } else {
-        *result = BaseVector::create(outputType, rows.size(), context->pool());
+        result = BaseVector::create(outputType, rows.size(), context.pool());
       }
     } else {
       // if the output is previously initialized, we prepare it for writing
       // here using ensureWritable
-      context->ensureWritable(rows, outputType, *result);
+      context.ensureWritable(rows, outputType, result);
     }
     // Here we provide a pointer to the raw flat results.
     BufferPtr resultValues =
-        (*result)->as<FlatVector<T>>()->mutableValues(rows.end());
+        result->as<FlatVector<T>>()->mutableValues(rows.end());
     T* __restrict rawResult = resultValues->asMutable<T>();
 
     // Step 2: handle input encodings and call the inner kernels
@@ -250,14 +251,14 @@ class VectorArithmetic : public VectorFunction {
   template <typename T>
   inline static bool processAsDense(
       const SelectivityVector& rows,
-      EvalCtx* context) {
+      EvalCtx& context) {
     // Consider it dense if one of these:
     // 1) If the rows are all valid
     // 2) type is integral and is safe to leave the values uninitialized
     // and the number of valid rows is larger than half of the row (heuristic)
     return rows.isAllSelected() ||
         (std::is_integral_v<T> && Operation::isSafeForUninitialized &&
-         context->isFinalSelection() && rows.countSelected() > rows.size() / 2);
+         context.isFinalSelection() && rows.countSelected() > rows.size() / 2);
   }
 };
 
diff --git a/velox/functions/prestosql/WidthBucketArray.cpp b/velox/functions/prestosql/WidthBucketArray.cpp
index d41dd416fe2a..7b14280ec83f 100644
--- a/velox/functions/prestosql/WidthBucketArray.cpp
+++ b/velox/functions/prestosql/WidthBucketArray.cpp
@@ -60,10 +60,10 @@ class WidthBucketArrayFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
-    context->ensureWritable(rows, BIGINT(), *result);
-    auto flatResult = (*result)->asFlatVector<int64_t>()->mutableRawValues();
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    context.ensureWritable(rows, BIGINT(), result);
+    auto flatResult = result->asFlatVector<int64_t>()->mutableRawValues();
 
     exec::DecodedArgs decodedArgs(rows, args, context);
     auto operand = decodedArgs.at(0);
@@ -86,7 +86,7 @@ class WidthBucketArrayFunction : public exec::VectorFunction {
         flatResult[row] = widthBucket<T>(
             operand->valueAt<double>(row), *elementsHolder.get(), offset, size);
       } catch (const std::exception& e) {
-        context->setError(row, std::current_exception());
+        context.setError(row, std::current_exception());
       }
     });
   }
@@ -101,10 +101,10 @@ class WidthBucketArrayFunctionConstantBins : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
-    context->ensureWritable(rows, BIGINT(), *result);
-    auto flatResult = (*result)->asFlatVector<int64_t>()->mutableRawValues();
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    context.ensureWritable(rows, BIGINT(), result);
+    auto flatResult = result->asFlatVector<int64_t>()->mutableRawValues();
 
     exec::DecodedArgs decodedArgs(rows, args, context);
     auto operand = decodedArgs.at(0);
@@ -113,7 +113,7 @@ class WidthBucketArrayFunctionConstantBins : public exec::VectorFunction {
       try {
         flatResult[row] = widthBucket(operand->valueAt<double>(row), bins_);
       } catch (const std::exception& e) {
-        context->setError(row, std::current_exception());
+        context.setError(row, std::current_exception());
       }
     });
   }
diff --git a/velox/functions/prestosql/Zip.cpp b/velox/functions/prestosql/Zip.cpp
index ee870ea0c1b1..2d0dd46dd469 100644
--- a/velox/functions/prestosql/Zip.cpp
+++ b/velox/functions/prestosql/Zip.cpp
@@ -64,8 +64,8 @@ class ZipFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     validateInputTypes(args);
     const vector_size_t numInputArrays = args.size();
 
@@ -84,7 +84,7 @@ class ZipFunction : public exec::VectorFunction {
 
     // Size of elements in result vector.
     vector_size_t resultElementsSize = 0;
-    auto pool = context->pool();
+    auto* pool = context.pool();
     // This is true if for all rows, all the arrays within a row are the same
     // size.
     bool allSameSize = true;
@@ -146,7 +146,7 @@ class ZipFunction : public exec::VectorFunction {
             resultArraySizesBuffer,
             std::move(rowVector));
 
-        context->moveOrCopyResult(arrayVector, rows, result);
+        context.moveOrCopyResult(arrayVector, rows, result);
 
         return;
       }
@@ -224,7 +224,7 @@ class ZipFunction : public exec::VectorFunction {
         resultArraySizesBuffer,
         std::move(rowVector));
 
-    context->moveOrCopyResult(arrayVector, rows, result);
+    context.moveOrCopyResult(arrayVector, rows, result);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
diff --git a/velox/functions/prestosql/benchmarks/ArrayMinMaxBenchmark.h b/velox/functions/prestosql/benchmarks/ArrayMinMaxBenchmark.h
index 09d61f8268c1..a386f8a7f5f0 100644
--- a/velox/functions/prestosql/benchmarks/ArrayMinMaxBenchmark.h
+++ b/velox/functions/prestosql/benchmarks/ArrayMinMaxBenchmark.h
@@ -215,8 +215,8 @@ class ArrayMinMaxFunctionBasic : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 1);
     auto arrayVector = args[0]->asUnchecked<ArrayVector>();
 
@@ -226,7 +226,7 @@ class ArrayMinMaxFunctionBasic : public exec::VectorFunction {
         context, *elementsVector, *elementsRows.get());
 
     BaseVector::ensureWritable(
-        rows, elementsVector->type(), context->pool(), result);
+        rows, elementsVector->type(), context.pool(), result);
 
     VELOX_DYNAMIC_SCALAR_TEMPLATE_TYPE_DISPATCH(
         applyTyped,
@@ -235,7 +235,7 @@ class ArrayMinMaxFunctionBasic : public exec::VectorFunction {
         rows,
         *arrayVector,
         *elementsHolder.get(),
-        *result);
+        result);
   }
 };
 
diff --git a/velox/functions/prestosql/benchmarks/ArrayPositionBasic.h b/velox/functions/prestosql/benchmarks/ArrayPositionBasic.h
index d8a847cbbde2..3086bc833005 100644
--- a/velox/functions/prestosql/benchmarks/ArrayPositionBasic.h
+++ b/velox/functions/prestosql/benchmarks/ArrayPositionBasic.h
@@ -207,16 +207,16 @@ class ArrayPositionFunctionBasic : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     const auto& arrayVector = args[0];
     const auto& searchVector = args[1];
     VELOX_CHECK(arrayVector->type()->isArray());
     VELOX_CHECK(arrayVector->type()->asArray().elementType()->kindEquals(
         searchVector->type()));
 
-    context->ensureWritable(rows, BIGINT(), *result);
-    auto flatResult = (*result)->asFlatVector<int64_t>();
+    context.ensureWritable(rows, BIGINT(), result);
+    auto flatResult = result->asFlatVector<int64_t>();
 
     exec::DecodedArgs decodedArgs(rows, args, context);
     auto elements = decodedArgs.at(0)->base()->as<ArrayVector>()->elements();
diff --git a/velox/functions/prestosql/benchmarks/ArrayWriterBenchmark.cpp b/velox/functions/prestosql/benchmarks/ArrayWriterBenchmark.cpp
index 5620d2e4d10b..f171e3178806 100644
--- a/velox/functions/prestosql/benchmarks/ArrayWriterBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/ArrayWriterBenchmark.cpp
@@ -35,13 +35,13 @@ class VectorFunctionImpl : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     LocalDecodedVector decoded_(context, *args[0], rows); // NOLINT
 
     // Prepare results.
-    BaseVector::ensureWritable(rows, ARRAY(BIGINT()), context->pool(), result);
-    auto flatResult = (*result)->as<ArrayVector>();
+    BaseVector::ensureWritable(rows, ARRAY(BIGINT()), context.pool(), result);
+    auto flatResult = result->as<ArrayVector>();
     auto currentOffset = 0;
     auto elementsFlat = flatResult->elements()->asFlatVector<int64_t>();
 
diff --git a/velox/functions/prestosql/benchmarks/DateTimeBenchmark.cpp b/velox/functions/prestosql/benchmarks/DateTimeBenchmark.cpp
index 76fe0203b88e..97aad7af6b8b 100644
--- a/velox/functions/prestosql/benchmarks/DateTimeBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/DateTimeBenchmark.cpp
@@ -44,20 +44,20 @@ class HourFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 1);
     const auto* timestamps =
         static_cast<const Timestamp*>(args[0]->valuesAsVoid());
 
     // Initialize flat results vector.
-    BaseVector::ensureWritable(rows, BIGINT(), context->pool(), result);
-    auto rawResults = (*result)->as<FlatVector<int64_t>>()->mutableRawValues();
+    BaseVector::ensureWritable(rows, BIGINT(), context.pool(), result);
+    auto rawResults = result->as<FlatVector<int64_t>>()->mutableRawValues();
 
     // Check if we need to adjust the current UTC timestamps to
     // the user provided session timezone.
     const auto* timeZone =
-        getTimeZoneIfNeeded(context->execCtx()->queryCtx()->config());
+        getTimeZoneIfNeeded(context.execCtx()->queryCtx()->config());
     if (timeZone != nullptr) {
       rows.applyToSelected([&](int row) {
         auto timestamp = timestamps[row];
diff --git a/velox/functions/prestosql/benchmarks/MapInputBenchmark.cpp b/velox/functions/prestosql/benchmarks/MapInputBenchmark.cpp
index ab73802bf607..b4ec779d4d6b 100644
--- a/velox/functions/prestosql/benchmarks/MapInputBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/MapInputBenchmark.cpp
@@ -33,8 +33,8 @@ class MapSumValuesAndKeysVector : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     auto arg = args.at(0);
 
     exec::LocalDecodedVector mapHolder(context, *arg, rows);
@@ -55,8 +55,8 @@ class MapSumValuesAndKeysVector : public exec::VectorFunction {
     auto rawOffsets = mapVector->rawOffsets();
     auto rawSizes = mapVector->rawSizes();
 
-    BaseVector::ensureWritable(rows, BIGINT(), context->pool(), result);
-    auto flatResult = (*result)->asFlatVector<int64_t>();
+    BaseVector::ensureWritable(rows, BIGINT(), context.pool(), result);
+    auto flatResult = result->asFlatVector<int64_t>();
 
     rows.applyToSelected([&](vector_size_t row) {
       size_t mapIndex = mapIndices[row];
@@ -79,8 +79,8 @@ class NestedMapSumValuesAndKeysVector : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     auto arg = args.at(0);
 
     exec::LocalDecodedVector mapHolder(context, *arg, rows);
@@ -126,8 +126,8 @@ class NestedMapSumValuesAndKeysVector : public exec::VectorFunction {
     auto innerRawSizes = innerMapVector->rawSizes();
 
     // Prepare results
-    BaseVector::ensureWritable(rows, BIGINT(), context->pool(), result);
-    auto flatResult = (*result)->asFlatVector<int64_t>();
+    BaseVector::ensureWritable(rows, BIGINT(), context.pool(), result);
+    auto flatResult = result->asFlatVector<int64_t>();
 
     rows.applyToSelected([&](vector_size_t row) {
       size_t mapIndex = mapIndices[row];
@@ -163,16 +163,16 @@ class NestedMapWithMapView : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     LocalDecodedVector decoded_(context, *args[0], rows);
     using exec_in_t = typename VectorExec::template resolver<
         Map<int64_t, Map<int64_t, int64_t>>>::in_type;
     VectorReader<Map<int64_t, Map<int64_t, int64_t>>> reader{decoded_.get()};
 
     // Prepare results
-    BaseVector::ensureWritable(rows, BIGINT(), context->pool(), result);
-    auto flatResult = (*result)->asFlatVector<int64_t>();
+    BaseVector::ensureWritable(rows, BIGINT(), context.pool(), result);
+    auto flatResult = result->asFlatVector<int64_t>();
 
     rows.applyToSelected([&](vector_size_t row) {
       auto sum = 0;
diff --git a/velox/functions/prestosql/benchmarks/MapWriterBenchmarks.cpp b/velox/functions/prestosql/benchmarks/MapWriterBenchmarks.cpp
index b34cc7e5f82a..5b6d3cf7f0c9 100644
--- a/velox/functions/prestosql/benchmarks/MapWriterBenchmarks.cpp
+++ b/velox/functions/prestosql/benchmarks/MapWriterBenchmarks.cpp
@@ -37,15 +37,15 @@ class VectorFunctionImpl : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     LocalDecodedVector decoded_(context, *args[0], rows); // NOLINT
 
     // Prepare results.
     BaseVector::ensureWritable(
-        rows, MAP(BIGINT(), BIGINT()), context->pool(), result);
+        rows, MAP(BIGINT(), BIGINT()), context.pool(), result);
 
-    auto flatResult = (*result)->as<MapVector>();
+    auto flatResult = result->as<MapVector>();
     auto currentOffset = 0;
     auto keysFlat = flatResult->mapKeys()->asFlatVector<int64_t>();
     auto valuesFlat = flatResult->mapValues()->asFlatVector<int64_t>();
diff --git a/velox/functions/prestosql/benchmarks/NestedArrayWriterBenchmark.cpp b/velox/functions/prestosql/benchmarks/NestedArrayWriterBenchmark.cpp
index 58035f364562..bc12cbbc2d5b 100644
--- a/velox/functions/prestosql/benchmarks/NestedArrayWriterBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/NestedArrayWriterBenchmark.cpp
@@ -35,20 +35,17 @@ class VectorFunctionImpl : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     LocalDecodedVector decoded_(context, *args[0], rows); // NOLINT
 
     // Prepare results
     auto elementType =
         ArrayType(std::make_shared<ArrayType>(ArrayType(BIGINT())));
     BaseVector::ensureWritable(
-        rows,
-        std::make_shared<ArrayType>(elementType),
-        context->pool(),
-        result);
+        rows, std::make_shared<ArrayType>(elementType), context.pool(), result);
 
-    auto arrayVectorOuter = (*result)->as<ArrayVector>();
+    auto arrayVectorOuter = result->as<ArrayVector>();
     auto arrayVectorInner = arrayVectorOuter->elements()->as<ArrayVector>();
     auto flatElements = arrayVectorInner->elements()->as<FlatVector<int64_t>>();
 
diff --git a/velox/functions/prestosql/benchmarks/RowWriterBenchmark.cpp b/velox/functions/prestosql/benchmarks/RowWriterBenchmark.cpp
index 2d4f6a759997..3f3b4169cb47 100644
--- a/velox/functions/prestosql/benchmarks/RowWriterBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/RowWriterBenchmark.cpp
@@ -31,15 +31,15 @@ class VectorFunctionImpl : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     LocalDecodedVector decoded_(context, *args[0], rows); // NOLINT
 
     // Prepare results.
     BaseVector::ensureWritable(
-        rows, ROW({BIGINT(), BIGINT()}), context->pool(), result);
+        rows, ROW({BIGINT(), BIGINT()}), context.pool(), result);
 
-    auto rowVector = (*result)->as<RowVector>();
+    auto rowVector = result->as<RowVector>();
     rowVector->childAt(0)->resize(rows.size());
     rowVector->childAt(1)->resize(rows.size());
     auto flat1 = rowVector->childAt(0)->asFlatVector<int64_t>();
diff --git a/velox/functions/prestosql/tests/StringFunctionsTest.cpp b/velox/functions/prestosql/tests/StringFunctionsTest.cpp
index 314e1ceb4164..c7c38fc2e998 100644
--- a/velox/functions/prestosql/tests/StringFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/StringFunctionsTest.cpp
@@ -1089,8 +1089,7 @@ void StringFunctionsTest::testReplaceInPlace(
     ExprSet exprSet({}, &execCtx_);
     RowVectorPtr inputRows = makeRowVector({});
     exec::EvalCtx evalCtx(&execCtx_, &exprSet, inputRows.get());
-    replaceFunction->apply(
-        rows, functionInputs, VARCHAR(), &evalCtx, &resultPtr);
+    replaceFunction->apply(rows, functionInputs, VARCHAR(), evalCtx, resultPtr);
   };
 
   std::vector<VectorPtr> functionInputs = {
@@ -1422,9 +1421,9 @@ class MultiStringFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* /*context*/,
-      VectorPtr* result) const override {
-    *result = BaseVector::wrapInConstant(rows.size(), 0, args[0]);
+      exec::EvalCtx& /*context*/,
+      VectorPtr& result) const override {
+    result = BaseVector::wrapInConstant(rows.size(), 0, args[0]);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
@@ -1577,9 +1576,9 @@ class InputModifyingFunction : public MultiStringFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* ctx,
-      VectorPtr* result) const override {
-    MultiStringFunction::apply(rows, args, outputType, ctx, result);
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    MultiStringFunction::apply(rows, args, outputType, context, result);
 
     // Modify args and remove its asciness
     for (auto& arg : args) {
diff --git a/velox/functions/prestosql/types/JsonType.cpp b/velox/functions/prestosql/types/JsonType.cpp
index 71d1b7700b2f..e096b41cbeaa 100644
--- a/velox/functions/prestosql/types/JsonType.cpp
+++ b/velox/functions/prestosql/types/JsonType.cpp
@@ -80,7 +80,7 @@ template <
     typename std::enable_if_t<TypeTraits<kind>::isPrimitiveType, int> = 0>
 void castToJson(
     const BaseVector& input,
-    exec::EvalCtx* context,
+    exec::EvalCtx& context,
     const SelectivityVector& rows,
     FlatVector<StringView>& flatResult,
     bool isMapKey = false) {
@@ -91,7 +91,7 @@ void castToJson(
 
   std::string result;
   if (!isMapKey) {
-    context->applyToSelectedNoThrow(rows, [&](auto row) {
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
       if (inputVector->isNullAt(row)) {
         flatResult.set(row, "null");
       } else {
@@ -102,7 +102,7 @@ void castToJson(
       }
     });
   } else {
-    context->applyToSelectedNoThrow(rows, [&](auto row) {
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
       if (inputVector->isNullAt(row)) {
         VELOX_FAIL("Map keys cannot be null.");
       } else {
@@ -118,19 +118,19 @@ void castToJson(
 // Forward declaration.
 void castToJsonFromArray(
     const BaseVector& input,
-    exec::EvalCtx* context,
+    exec::EvalCtx& context,
     const SelectivityVector& rows,
     FlatVector<StringView>& flatResult);
 
 void castToJsonFromMap(
     const BaseVector& input,
-    exec::EvalCtx* context,
+    exec::EvalCtx& context,
     const SelectivityVector& rows,
     FlatVector<StringView>& flatResult);
 
 void castToJsonFromRow(
     const BaseVector& input,
-    exec::EvalCtx* context,
+    exec::EvalCtx& context,
     const SelectivityVector& rows,
     FlatVector<StringView>& flatResult);
 
@@ -140,7 +140,7 @@ template <
     typename std::enable_if_t<!TypeTraits<kind>::isPrimitiveType, int> = 0>
 void castToJson(
     const BaseVector& input,
-    exec::EvalCtx* context,
+    exec::EvalCtx& context,
     const SelectivityVector& rows,
     FlatVector<StringView>& flatResult,
     bool isMapKey = false) {
@@ -162,13 +162,13 @@ void castToJson(
 // Helper struct representing the Json vector of input.
 struct AsJson {
   AsJson(
-      exec::EvalCtx* context,
+      exec::EvalCtx& context,
       const VectorPtr& input,
       const SelectivityVector& rows,
       bool isMapKey = false)
       : decoded_(context, *input, rows) {
     if (isMapKey && decoded_->mayHaveNulls()) {
-      context->applyToSelectedNoThrow(rows, [&](auto row) {
+      context.applyToSelectedNoThrow(rows, [&](auto row) {
         if (decoded_->isNullAt(row)) {
           VELOX_FAIL("Cannot cast map with null keys to JSON.");
         }
@@ -184,14 +184,14 @@ struct AsJson {
     // Translates the selected rows of input into the corresponding rows of the
     // base of the decoded input.
     exec::LocalSelectivityVector baseRows(
-        *context->execCtx(), decoded_->base()->size());
+        *context.execCtx(), decoded_->base()->size());
     baseRows->clearAll();
-    context->applyToSelectedNoThrow(rows, [&](auto row) {
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
       baseRows->setValid(decoded_->index(row), true);
     });
     baseRows->updateBounds();
 
-    context->ensureWritable(*baseRows, JSON(), json_);
+    context.ensureWritable(*baseRows, JSON(), json_);
     auto flatJsonStrings = json_->as<FlatVector<StringView>>();
 
     VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
@@ -238,7 +238,7 @@ struct AsJson {
 
 void castToJsonFromArray(
     const BaseVector& input,
-    exec::EvalCtx* context,
+    exec::EvalCtx& context,
     const SelectivityVector& rows,
     FlatVector<StringView>& flatResult) {
   // input is guaranteed to be in flat encoding when passed in.
@@ -253,7 +253,7 @@ void castToJsonFromArray(
   // input according to the length of all elements Json strings and the
   // delimiters to be added.
   size_t elementsStringSize = 0;
-  context->applyToSelectedNoThrow(rows, [&](auto row) {
+  context.applyToSelectedNoThrow(rows, [&](auto row) {
     if (inputArray->isNullAt(row)) {
       // "null" will be inlined in the StringView.
       return;
@@ -272,7 +272,7 @@ void castToJsonFromArray(
   flatResult.getBufferWithSpace(elementsStringSize);
 
   // Constructs the Json string of each array from Json strings of its elements.
-  context->applyToSelectedNoThrow(rows, [&](auto row) {
+  context.applyToSelectedNoThrow(rows, [&](auto row) {
     if (inputArray->isNullAt(row)) {
       flatResult.set(row, "null");
       return;
@@ -298,7 +298,7 @@ void castToJsonFromArray(
 
 void castToJsonFromMap(
     const BaseVector& input,
-    exec::EvalCtx* context,
+    exec::EvalCtx& context,
     const SelectivityVector& rows,
     FlatVector<StringView>& flatResult) {
   // input is guaranteed to be in flat encoding when passed in.
@@ -317,7 +317,7 @@ void castToJsonFromMap(
   // input according to the length of all elements Json strings and the
   // delimiters to be added.
   size_t elementsStringSize = 0;
-  context->applyToSelectedNoThrow(rows, [&](auto row) {
+  context.applyToSelectedNoThrow(rows, [&](auto row) {
     if (inputMap->isNullAt(row)) {
       // "null" will be inlined in the StringView.
       return;
@@ -339,7 +339,7 @@ void castToJsonFromMap(
   // Constructs the Json string of each map from Json strings of its keys and
   // values.
   std::vector<std::pair<StringView, vector_size_t>> sortedKeys;
-  context->applyToSelectedNoThrow(rows, [&](auto row) {
+  context.applyToSelectedNoThrow(rows, [&](auto row) {
     if (inputMap->isNullAt(row)) {
       flatResult.set(row, "null");
       return;
@@ -374,7 +374,7 @@ void castToJsonFromMap(
 
 void castToJsonFromRow(
     const BaseVector& input,
-    exec::EvalCtx* context,
+    exec::EvalCtx& context,
     const SelectivityVector& rows,
     FlatVector<StringView>& flatResult) {
   // input is guaranteed to be in flat encoding when passed in.
@@ -389,7 +389,7 @@ void castToJsonFromRow(
   for (int i = 0; i < childrenSize; ++i) {
     childrenAsJson.emplace_back(context, inputRow->childAt(i), rows);
 
-    context->applyToSelectedNoThrow(rows, [&](auto row) {
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
       if (inputRow->isNullAt(row)) {
         // "null" will be inlined in the StringView.
         return;
@@ -404,7 +404,7 @@ void castToJsonFromRow(
   flatResult.getBufferWithSpace(childrenStringSize);
 
   // Constructs Json string of each row from Json strings of its children.
-  context->applyToSelectedNoThrow(rows, [&](auto row) {
+  context.applyToSelectedNoThrow(rows, [&](auto row) {
     if (inputRow->isNullAt(row)) {
       flatResult.set(row, "null");
       return;
@@ -724,7 +724,7 @@ void JsonCastOperator::castTo(
   // Casting from VARBINARY and OPAQUE are not supported and should have been
   // rejected by isSupportedType() in the caller.
   VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
-      castToJson, input.typeKind(), input, &context, rows, *flatResult);
+      castToJson, input.typeKind(), input, context, rows, *flatResult);
 }
 
 /// Converts an input vector from Json type to the type of result vector.
diff --git a/velox/functions/sparksql/ArraySort.cpp b/velox/functions/sparksql/ArraySort.cpp
index 12a14075115d..f34b2533a4d8 100644
--- a/velox/functions/sparksql/ArraySort.cpp
+++ b/velox/functions/sparksql/ArraySort.cpp
@@ -37,12 +37,12 @@ void applyComplexType(
     ArrayVector* inputArray,
     bool ascending,
     bool nullsFirst,
-    exec::EvalCtx* context,
+    exec::EvalCtx& context,
     VectorPtr* resultElements) {
   auto elementsVector = inputArray->elements();
 
   // Allocate new vectors for indices.
-  BufferPtr indices = allocateIndices(elementsVector->size(), context->pool());
+  BufferPtr indices = allocateIndices(elementsVector->size(), context.pool());
   vector_size_t* rawIndices = indices->asMutable<vector_size_t>();
 
   const CompareFlags flags{.nullsFirst = nullsFirst, .ascending = ascending};
@@ -87,7 +87,7 @@ void applyTyped(
     const ArrayVector* inputArray,
     bool ascending,
     bool nullsFirst,
-    exec::EvalCtx* context,
+    exec::EvalCtx& context,
     VectorPtr* resultElements) {
   using T = typename TypeTraits<kind>::NativeType;
 
@@ -97,7 +97,7 @@ void applyTyped(
       toElementRows(inputElements->size(), rows, inputArray);
 
   *resultElements = BaseVector::create(
-      inputElements->type(), inputElements->size(), context->pool());
+      inputElements->type(), inputElements->size(), context.pool());
   (*resultElements)
       ->copy(inputElements.get(), elementRows, /*toSourceRow=*/nullptr);
 
@@ -161,8 +161,8 @@ void ArraySort::apply(
     const SelectivityVector& rows,
     std::vector<VectorPtr>& args,
     const TypePtr& /*outputType*/,
-    exec::EvalCtx* context,
-    VectorPtr* result) const {
+    exec::EvalCtx& context,
+    VectorPtr& result) const {
   auto& arg = args[0];
 
   VectorPtr localResult;
@@ -184,13 +184,13 @@ void ArraySort::apply(
     localResult = applyFlat(rows, arg, context);
   }
 
-  context->moveOrCopyResult(localResult, rows, result);
+  context.moveOrCopyResult(localResult, rows, result);
 }
 
 VectorPtr ArraySort::applyFlat(
     const SelectivityVector& rows,
     const VectorPtr& arg,
-    exec::EvalCtx* context) const {
+    exec::EvalCtx& context) const {
   ArrayVector* inputArray = arg->as<ArrayVector>();
   VectorPtr resultElements;
 
@@ -212,7 +212,7 @@ VectorPtr ArraySort::applyFlat(
   }
 
   return std::make_shared<ArrayVector>(
-      context->pool(),
+      context.pool(),
       inputArray->type(),
       inputArray->nulls(),
       rows.end(),
diff --git a/velox/functions/sparksql/ArraySort.h b/velox/functions/sparksql/ArraySort.h
index 9e0cdb57449a..62dfa295b30e 100644
--- a/velox/functions/sparksql/ArraySort.h
+++ b/velox/functions/sparksql/ArraySort.h
@@ -37,14 +37,14 @@ class ArraySort : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override;
+      exec::EvalCtx& context,
+      VectorPtr& result) const override;
 
  private:
   VectorPtr applyFlat(
       const SelectivityVector& rows,
       const VectorPtr& arg,
-      exec::EvalCtx* context) const;
+      exec::EvalCtx& context) const;
 
   const bool ascending_;
   const bool nullsFirst_;
diff --git a/velox/functions/sparksql/CompareFunctionsNullSafe.cpp b/velox/functions/sparksql/CompareFunctionsNullSafe.cpp
index 672bd9fbed22..d88ccf524989 100644
--- a/velox/functions/sparksql/CompareFunctionsNullSafe.cpp
+++ b/velox/functions/sparksql/CompareFunctionsNullSafe.cpp
@@ -30,7 +30,7 @@ void applyTyped(
     std::vector<VectorPtr>& args,
     DecodedVector* decoded0,
     DecodedVector* decoded1,
-    exec::EvalCtx* context,
+    exec::EvalCtx& context,
     FlatVector<bool>* flatResult) {
   using T = typename TypeTraits<kind>::NativeType;
 
@@ -64,7 +64,7 @@ void applyTyped<TypeKind::ARRAY>(
     std::vector<VectorPtr>& /* args */,
     DecodedVector* /* decoded0 */,
     DecodedVector* /* decoded1 */,
-    exec::EvalCtx* /* context */,
+    exec::EvalCtx& /* context */,
     FlatVector<bool>* /* flatResult */) {
   VELOX_NYI("equalnullsafe does not support arrays.");
 }
@@ -75,7 +75,7 @@ void applyTyped<TypeKind::MAP>(
     std::vector<VectorPtr>& /* args */,
     DecodedVector* /* decoded0 */,
     DecodedVector* /* decoded1 */,
-    exec::EvalCtx* /* context */,
+    exec::EvalCtx& /* context */,
     FlatVector<bool>* /* flatResult */) {
   VELOX_NYI("equalnullsafe does not support maps.");
 }
@@ -86,7 +86,7 @@ void applyTyped<TypeKind::ROW>(
     std::vector<VectorPtr>& /* args */,
     DecodedVector* /* decoded0 */,
     DecodedVector* /* decoded1 */,
-    exec::EvalCtx* /* context */,
+    exec::EvalCtx& /* context */,
     FlatVector<bool>* /* flatResult */) {
   VELOX_NYI("equalnullsafe does not support structs.");
 }
@@ -101,14 +101,14 @@ class EqualtoNullSafe final : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     exec::DecodedArgs decodedArgs(rows, args, context);
 
     DecodedVector* decoded0 = decodedArgs.at(0);
     DecodedVector* decoded1 = decodedArgs.at(1);
-    context->ensureWritable(rows, BOOLEAN(), *result);
-    FlatVector<bool>* flatResult = (*result)->asFlatVector<bool>();
+    context.ensureWritable(rows, BOOLEAN(), result);
+    auto* flatResult = result->asFlatVector<bool>();
     flatResult->mutableRawValues<int64_t>();
 
     VELOX_DYNAMIC_TYPE_DISPATCH(
diff --git a/velox/functions/sparksql/Hash.cpp b/velox/functions/sparksql/Hash.cpp
index 1f1258bcb716..1110675fac18 100644
--- a/velox/functions/sparksql/Hash.cpp
+++ b/velox/functions/sparksql/Hash.cpp
@@ -115,13 +115,13 @@ class HashFunction final : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args, // Not using const ref so we can reuse args
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* resultRef) const final {
+      exec::EvalCtx& context,
+      VectorPtr& resultRef) const final {
     constexpr int32_t kSeed = 42;
 
-    context->ensureWritable(rows, INTEGER(), *resultRef);
+    context.ensureWritable(rows, INTEGER(), resultRef);
 
-    FlatVector<int32_t>& result = *(*resultRef)->as<FlatVector<int32_t>>();
+    FlatVector<int32_t>& result = *resultRef->as<FlatVector<int32_t>>();
     rows.applyToSelected([&](int row) { result.set(row, kSeed); });
 
     exec::LocalSelectivityVector selectedMinusNulls(context);
diff --git a/velox/functions/sparksql/LeastGreatest.cpp b/velox/functions/sparksql/LeastGreatest.cpp
index 919ba5e8b6b3..5cb3108daabe 100644
--- a/velox/functions/sparksql/LeastGreatest.cpp
+++ b/velox/functions/sparksql/LeastGreatest.cpp
@@ -35,14 +35,14 @@ class LeastGreatestFunction final : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     const size_t nargs = args.size();
     const auto nrows = rows.end();
 
     // Setup result vector.
-    context->ensureWritable(rows, outputType, *result);
-    FlatVector<T>& flatResult = *(*result)->as<FlatVector<T>>();
+    context.ensureWritable(rows, outputType, result);
+    FlatVector<T>& flatResult = *result->as<FlatVector<T>>();
 
     // NULL all elements.
     rows.applyToSelected(
diff --git a/velox/functions/sparksql/Map.cpp b/velox/functions/sparksql/Map.cpp
index c8f22b015a35..066c5cd4dbfa 100644
--- a/velox/functions/sparksql/Map.cpp
+++ b/velox/functions/sparksql/Map.cpp
@@ -37,7 +37,7 @@ void setKeysResultTyped(
     vector_size_t mapSize,
     std::vector<VectorPtr>& args,
     const VectorPtr& keysResult,
-    exec::EvalCtx* context,
+    exec::EvalCtx& context,
     const SelectivityVector& rows) {
   using T = typename KindToFlatVector<kind>::WrapperType;
   auto flatKeys = keysResult->asFlatVector<T>()
@@ -60,7 +60,7 @@ void setValuesResultTyped(
     vector_size_t mapSize,
     std::vector<VectorPtr>& args,
     const VectorPtr& valuesResult,
-    exec::EvalCtx* context,
+    exec::EvalCtx& context,
     const SelectivityVector& rows) {
   using T = typename KindToFlatVector<kind>::WrapperType;
   auto flatValues = valuesResult->asFlatVector<T>()
@@ -90,8 +90,8 @@ class MapFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /*outputType*/,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK(
         args.size() >= 2 && args.size() % 2 == 0,
         "Map function must take an even number of arguments");
@@ -113,10 +113,10 @@ class MapFunction : public exec::VectorFunction {
     }
 
     // Initializing input
-    context->ensureWritable(
-        rows, std::make_shared<MapType>(keyType, valueType), *result);
+    context.ensureWritable(
+        rows, std::make_shared<MapType>(keyType, valueType), result);
 
-    auto mapResult = (*result)->as<MapVector>();
+    auto mapResult = result->as<MapVector>();
     auto sizes = mapResult->mutableSizes(rows.size());
     auto rawSizes = sizes->asMutable<int32_t>();
     auto offsets = mapResult->mutableOffsets(rows.size());
diff --git a/velox/functions/sparksql/SplitFunctions.cpp b/velox/functions/sparksql/SplitFunctions.cpp
index 9738ba593115..574262266688 100644
--- a/velox/functions/sparksql/SplitFunctions.cpp
+++ b/velox/functions/sparksql/SplitFunctions.cpp
@@ -37,14 +37,14 @@ class SplitCharacter final : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     exec::LocalDecodedVector input(context, *args[0], rows);
 
     ArrayBuilder<Varchar> builder(
         /*numArrays=*/rows.size(),
         /*estimatedNumElements=*/rows.countSelected() * 3,
-        context->pool());
+        context.pool());
 
     rows.applyToSelected([&](vector_size_t row) {
       ArrayBuilder<Varchar>::Ref array = builder.startArray(row);
@@ -62,8 +62,8 @@ class SplitCharacter final : public exec::VectorFunction {
     builder.setStringBuffers(
         args[0]->asFlatVector<StringView>()->stringBuffers());
     std::shared_ptr<ArrayVector> arrayVector =
-        std::move(builder).finish(context->pool());
-    context->moveOrCopyResult(arrayVector, rows, result);
+        std::move(builder).finish(context.pool());
+    context.moveOrCopyResult(arrayVector, rows, result);
   }
 
  private:
@@ -80,8 +80,8 @@ class Split final : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     auto delimiterVector = args[1]->as<ConstantVector<StringView>>();
     VELOX_CHECK(
         delimiterVector, "Split function supports only constant delimiter");
diff --git a/velox/functions/sparksql/String.cpp b/velox/functions/sparksql/String.cpp
index cfd1e8ee5780..13960af7dfb1 100644
--- a/velox/functions/sparksql/String.cpp
+++ b/velox/functions/sparksql/String.cpp
@@ -44,15 +44,15 @@ class Instr : public exec::VectorFunction {
       const SelectivityVector& selected,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 2);
     VELOX_CHECK_EQ(args[0]->typeKind(), TypeKind::VARCHAR);
     VELOX_CHECK_EQ(args[1]->typeKind(), TypeKind::VARCHAR);
     exec::LocalDecodedVector haystack(context, *args[0], selected);
     exec::LocalDecodedVector needle(context, *args[1], selected);
-    context->ensureWritable(selected, INTEGER(), *result);
-    auto* output = (*result)->as<FlatVector<int32_t>>();
+    context.ensureWritable(selected, INTEGER(), result);
+    auto* output = result->as<FlatVector<int32_t>>();
 
     if (isAscii(args[0].get(), selected)) {
       selected.applyToSelected([&](vector_size_t row) {
@@ -83,15 +83,15 @@ class Length : public exec::VectorFunction {
       const SelectivityVector& selected,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK_EQ(args.size(), 1);
     VELOX_CHECK(
         args[0]->typeKind() == TypeKind::VARCHAR ||
         args[0]->typeKind() == TypeKind::VARBINARY);
     exec::LocalDecodedVector input(context, *args[0], selected);
-    context->ensureWritable(selected, INTEGER(), *result);
-    auto* output = (*result)->as<FlatVector<int32_t>>();
+    context.ensureWritable(selected, INTEGER(), result);
+    auto* output = result->as<FlatVector<int32_t>>();
 
     if (args[0]->typeKind() == TypeKind::VARCHAR &&
         !isAscii(args[0].get(), selected)) {
diff --git a/velox/functions/sparksql/tests/InTest.cpp b/velox/functions/sparksql/tests/InTest.cpp
index c984d83a71fd..6855ba1ec76a 100644
--- a/velox/functions/sparksql/tests/InTest.cpp
+++ b/velox/functions/sparksql/tests/InTest.cpp
@@ -39,12 +39,12 @@ class TestingDictionaryFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /* outputType */,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK(rows.isAllSelected());
     const auto size = rows.size();
-    auto indices = allocateIndices(size, context->pool());
-    *result = BaseVector::wrapInDictionary(nullptr, indices, size, args[0]);
+    auto indices = allocateIndices(size, context.pool());
+    result = BaseVector::wrapInDictionary(nullptr, indices, size, args[0]);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
diff --git a/velox/functions/tests/FunctionRegistryTest.cpp b/velox/functions/tests/FunctionRegistryTest.cpp
index 7723b8a65436..426578f9a640 100644
--- a/velox/functions/tests/FunctionRegistryTest.cpp
+++ b/velox/functions/tests/FunctionRegistryTest.cpp
@@ -100,8 +100,8 @@ class VectorFuncOne : public velox::exec::VectorFunction {
       const velox::SelectivityVector& /* rows */,
       std::vector<velox::VectorPtr>& /* args */,
       const TypePtr& /* outputType */,
-      velox::exec::EvalCtx* /* context */,
-      velox::VectorPtr* /* result */) const override {}
+      velox::exec::EvalCtx& /* context */,
+      velox::VectorPtr& /* result */) const override {}
 
   static std::vector<std::shared_ptr<velox::exec::FunctionSignature>>
   signatures() {
@@ -119,8 +119,8 @@ class VectorFuncTwo : public velox::exec::VectorFunction {
       const velox::SelectivityVector& /* rows */,
       std::vector<velox::VectorPtr>& /* args */,
       const TypePtr& /* outputType */,
-      velox::exec::EvalCtx* /* context */,
-      velox::VectorPtr* /* result */) const override {}
+      velox::exec::EvalCtx& /* context */,
+      velox::VectorPtr& /* result */) const override {}
 
   static std::vector<std::shared_ptr<velox::exec::FunctionSignature>>
   signatures() {
@@ -138,8 +138,8 @@ class VectorFuncThree : public velox::exec::VectorFunction {
       const velox::SelectivityVector& /* rows */,
       std::vector<velox::VectorPtr>& /* args */,
       const TypePtr& /* outputType */,
-      velox::exec::EvalCtx* /* context */,
-      velox::VectorPtr* /* result */) const override {}
+      velox::exec::EvalCtx& /* context */,
+      velox::VectorPtr& /* result */) const override {}
 
   static std::vector<std::shared_ptr<velox::exec::FunctionSignature>>
   signatures() {
@@ -157,8 +157,8 @@ class VectorFuncFour : public velox::exec::VectorFunction {
       const velox::SelectivityVector& /* rows */,
       std::vector<velox::VectorPtr>& /* args */,
       const TypePtr& /* outputType */,
-      velox::exec::EvalCtx* /* context */,
-      velox::VectorPtr* /* result */) const override {}
+      velox::exec::EvalCtx& /* context */,
+      velox::VectorPtr& /* result */) const override {}
 
   static std::vector<std::shared_ptr<velox::exec::FunctionSignature>>
   signatures() {
diff --git a/velox/vector/BaseVector.cpp b/velox/vector/BaseVector.cpp
index 7021d10c00b6..3c9ddadb3b8c 100644
--- a/velox/vector/BaseVector.cpp
+++ b/velox/vector/BaseVector.cpp
@@ -546,32 +546,32 @@ void BaseVector::ensureWritable(
     const SelectivityVector& rows,
     const TypePtr& type,
     velox::memory::MemoryPool* pool,
-    VectorPtr* result,
+    VectorPtr& result,
     VectorPool* vectorPool) {
-  if (!*result) {
+  if (!result) {
     if (vectorPool) {
-      *result = vectorPool->get(type, rows.size());
+      result = vectorPool->get(type, rows.size());
     } else {
-      *result = BaseVector::create(type, rows.size(), pool);
+      result = BaseVector::create(type, rows.size(), pool);
     }
     return;
   }
-  auto resultType = (*result)->type();
+  auto resultType = result->type();
   bool isUnknownType = resultType->containsUnknown();
-  if ((*result)->encoding() == VectorEncoding::Simple::LAZY) {
+  if (result->encoding() == VectorEncoding::Simple::LAZY) {
     // TODO Figure out how to allow memory reuse for a newly loaded vector.
     // LazyVector holds a reference to loaded vector, hence, unique() check
     // below will never pass.
     VELOX_NYI();
   }
-  if (result->unique() && !isUnknownType) {
-    switch ((*result)->encoding()) {
+  if (result.unique() && !isUnknownType) {
+    switch (result->encoding()) {
       case VectorEncoding::Simple::FLAT:
       case VectorEncoding::Simple::ROW:
       case VectorEncoding::Simple::ARRAY:
       case VectorEncoding::Simple::MAP:
       case VectorEncoding::Simple::FUNCTION: {
-        (*result)->ensureWritable(rows);
+        result->ensureWritable(rows);
         return;
       }
       default:
@@ -581,7 +581,7 @@ void BaseVector::ensureWritable(
 
   // The copy-on-write size is the max of the writable row set and the
   // vector.
-  auto targetSize = std::max<vector_size_t>(rows.size(), (*result)->size());
+  auto targetSize = std::max<vector_size_t>(rows.size(), result->size());
 
   VectorPtr copy;
   if (vectorPool) {
@@ -591,12 +591,12 @@ void BaseVector::ensureWritable(
         BaseVector::create(isUnknownType ? type : resultType, targetSize, pool);
   }
   SelectivityVector copyRows(
-      std::min<vector_size_t>(targetSize, (*result)->size()));
+      std::min<vector_size_t>(targetSize, result->size()));
   copyRows.deselect(rows);
   if (copyRows.hasSelections()) {
-    copy->copy(result->get(), copyRows, nullptr);
+    copy->copy(result.get(), copyRows, nullptr);
   }
-  *result = std::move(copy);
+  result = std::move(copy);
 }
 
 template <TypeKind kind>
diff --git a/velox/vector/BaseVector.h b/velox/vector/BaseVector.h
index 871f808c4ae1..1aa21a3a41c2 100644
--- a/velox/vector/BaseVector.h
+++ b/velox/vector/BaseVector.h
@@ -453,7 +453,7 @@ class BaseVector {
       const SelectivityVector& rows,
       const TypePtr& type,
       velox::memory::MemoryPool* pool,
-      std::shared_ptr<BaseVector>* result,
+      std::shared_ptr<BaseVector>& result,
       VectorPool* vectorPool = nullptr);
 
   virtual void ensureWritable(const SelectivityVector& rows);
@@ -466,12 +466,12 @@ class BaseVector {
   //
   // We don't necessarily need (b) if we only want to flatten vectors.
   static void flattenVector(
-      std::shared_ptr<BaseVector>* vector,
+      std::shared_ptr<BaseVector>& vector,
       size_t vectorSize) {
     BaseVector::ensureWritable(
         SelectivityVector::empty(vectorSize),
-        (*vector)->type(),
-        (*vector)->pool(),
+        vector->type(),
+        vector->pool(),
         vector);
   }
 
diff --git a/velox/vector/ComplexVector.cpp b/velox/vector/ComplexVector.cpp
index c37b5b878a57..41ed4e1e68b6 100644
--- a/velox/vector/ComplexVector.cpp
+++ b/velox/vector/ComplexVector.cpp
@@ -163,7 +163,7 @@ void RowVector::copy(
     const vector_size_t* toSourceRow) {
   for (auto i = 0; i < children_.size(); ++i) {
     BaseVector::ensureWritable(
-        rows, type()->asRow().childAt(i), pool(), &children_[i]);
+        rows, type()->asRow().childAt(i), pool(), children_[i]);
   }
 
   // Copy non-null values.
@@ -278,7 +278,7 @@ void RowVector::ensureWritable(const SelectivityVector& rows) {
   for (int i = 0; i < childrenSize_; i++) {
     if (children_[i]) {
       BaseVector::ensureWritable(
-          rows, children_[i]->type(), BaseVector::pool_, &children_[i]);
+          rows, children_[i]->type(), BaseVector::pool_, children_[i]);
     }
   }
   BaseVector::ensureWritable(rows);
@@ -339,13 +339,13 @@ void ArrayVectorBase::copyRangesImpl(
         SelectivityVector::empty(),
         targetKeys->get()->type(),
         pool(),
-        targetKeys);
+        *targetKeys);
   } else {
     BaseVector::ensureWritable(
         SelectivityVector::empty(),
         targetValues->get()->type(),
         pool(),
-        targetValues);
+        *targetValues);
   }
   auto setNotNulls = mayHaveNulls() || source->mayHaveNulls();
   auto wantWidth = type()->isFixedWidth() ? type()->fixedElementsWidth() : 0;
@@ -625,7 +625,7 @@ void ArrayVector::ensureWritable(const SelectivityVector& rows) {
       SelectivityVector::empty(),
       type()->childAt(0),
       BaseVector::pool_,
-      &elements_);
+      elements_);
   BaseVector::ensureWritable(rows);
 }
 
@@ -886,15 +886,12 @@ void MapVector::ensureWritable(const SelectivityVector& rows) {
   // Vectors are write-once and nested elements are append only,
   // hence, all values already written must be preserved.
   BaseVector::ensureWritable(
-      SelectivityVector::empty(),
-      type()->childAt(0),
-      BaseVector::pool_,
-      &keys_);
+      SelectivityVector::empty(), type()->childAt(0), BaseVector::pool_, keys_);
   BaseVector::ensureWritable(
       SelectivityVector::empty(),
       type()->childAt(1),
       BaseVector::pool_,
-      &values_);
+      values_);
   BaseVector::ensureWritable(rows);
 }
 
diff --git a/velox/vector/benchmarks/CopyBenchmark.cpp b/velox/vector/benchmarks/CopyBenchmark.cpp
index 01e1a54d8405..2c824afabbc2 100644
--- a/velox/vector/benchmarks/CopyBenchmark.cpp
+++ b/velox/vector/benchmarks/CopyBenchmark.cpp
@@ -43,7 +43,7 @@ size_t runBenchmark(
     vector_size_t copyBatchSize) {
   VectorPtr result;
   folly::BenchmarkSuspender suspender;
-  BaseVector::ensureWritable(selected, type, pool, &result);
+  BaseVector::ensureWritable(selected, type, pool, result);
   suspender.dismiss();
 
   size_t numIters = 100;
diff --git a/velox/vector/tests/EnsureWritableVectorTest.cpp b/velox/vector/tests/EnsureWritableVectorTest.cpp
index 1a42ebaaadbd..2a90540b83a9 100644
--- a/velox/vector/tests/EnsureWritableVectorTest.cpp
+++ b/velox/vector/tests/EnsureWritableVectorTest.cpp
@@ -34,7 +34,7 @@ TEST_F(EnsureWritableVectorTest, flat) {
   SelectivityVector rows(1'000);
 
   VectorPtr result;
-  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), &result);
+  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), result);
   ASSERT_TRUE(result);
   ASSERT_EQ(rows.size(), result->size());
   ASSERT_EQ(TypeKind::BIGINT, result->typeKind());
@@ -53,14 +53,14 @@ TEST_F(EnsureWritableVectorTest, flat) {
   // as-is
   auto* rawNulls = flatResult->nulls().get();
   auto* rawValues = flatResult->values().get();
-  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), &result);
+  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), result);
   ASSERT_EQ(flatResult, result.get());
   ASSERT_EQ(rawNulls, flatResult->nulls().get());
   ASSERT_EQ(rawValues, flatResult->values().get());
 
   // Resize upwards singly-referenced vector with singly referenced buffers
   rows.resize(2'000);
-  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), &result);
+  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), result);
   ASSERT_EQ(rows.size(), result->size());
   ASSERT_EQ(flatResult, result.get());
   rawNulls = flatResult->nulls().get();
@@ -76,7 +76,7 @@ TEST_F(EnsureWritableVectorTest, flat) {
 
   // Resize downwards
   rows.resize(1'024);
-  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), &result);
+  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), result);
   ASSERT_EQ(2'000, result->size());
   ASSERT_EQ(rawNulls, flatResult->nulls().get());
   ASSERT_EQ(rawValues, flatResult->values().get());
@@ -84,7 +84,7 @@ TEST_F(EnsureWritableVectorTest, flat) {
   // Add second reference to the vector -> new vector should be allocated
   auto resultCopy = result;
 
-  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), &result);
+  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), result);
   ASSERT_NE(flatResult, result.get());
   flatResult = result->asFlatVector<int64_t>();
   ASSERT_NE(rawNulls, flatResult->nulls().get());
@@ -115,7 +115,7 @@ TEST_F(EnsureWritableVectorTest, flat) {
   resultCopy.reset();
   auto nullsCopy = result->nulls();
 
-  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), &result);
+  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), result);
   ASSERT_EQ(flatResult, result.get());
   ASSERT_NE(rawNulls, flatResult->nulls().get());
   rawNulls = flatResult->nulls().get();
@@ -137,7 +137,7 @@ TEST_F(EnsureWritableVectorTest, flat) {
   // Add a reference to values buffer
   auto valuesCopy = result->values();
 
-  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), &result);
+  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), result);
   ASSERT_EQ(flatResult, result.get());
   ASSERT_EQ(rawNulls, flatResult->nulls().get());
   ASSERT_NE(rawValues, flatResult->values().get());
@@ -162,7 +162,7 @@ TEST_F(EnsureWritableVectorTest, flatStrings) {
   SelectivityVector rows(1'000);
 
   VectorPtr result;
-  BaseVector::ensureWritable(rows, VARCHAR(), pool_.get(), &result);
+  BaseVector::ensureWritable(rows, VARCHAR(), pool_.get(), result);
   ASSERT_TRUE(result);
   ASSERT_EQ(rows.size(), result->size());
   ASSERT_EQ(TypeKind::VARCHAR, result->typeKind());
@@ -176,7 +176,7 @@ TEST_F(EnsureWritableVectorTest, flatStrings) {
   // buffer.
   auto valuesCopy = result->values();
 
-  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), &result);
+  BaseVector::ensureWritable(rows, BIGINT(), pool_.get(), result);
   ASSERT_TRUE(result);
   ASSERT_EQ(rows.size(), result->size());
   ASSERT_EQ(TypeKind::VARCHAR, result->typeKind());
@@ -390,7 +390,7 @@ TEST_F(EnsureWritableVectorTest, dictionary) {
       BufferPtr(nullptr), indices, size, dictionary);
 
   auto oddRows = selectOddRows(size);
-  BaseVector::ensureWritable(oddRows, BIGINT(), pool_.get(), &result);
+  BaseVector::ensureWritable(oddRows, BIGINT(), pool_.get(), result);
   ASSERT_EQ(size, result->size());
   ASSERT_EQ(TypeKind::BIGINT, result->typeKind());
   ASSERT_EQ(VectorEncoding::Simple::FLAT, result->encoding());
@@ -414,7 +414,7 @@ TEST_F(EnsureWritableVectorTest, constant) {
     auto constant = BaseVector::createConstant(
         variant::create<TypeKind::BIGINT>(123), size, pool_.get());
     BaseVector::ensureWritable(
-        SelectivityVector::empty(), BIGINT(), pool_.get(), &constant);
+        SelectivityVector::empty(), BIGINT(), pool_.get(), constant);
     EXPECT_EQ(VectorEncoding::Simple::FLAT, constant->encoding());
     EXPECT_EQ(size, constant->size());
   }
@@ -429,7 +429,7 @@ TEST_F(EnsureWritableVectorTest, constant) {
         SelectivityVector::empty(selectivityVectorSize),
         BIGINT(),
         pool_.get(),
-        &constant);
+        constant);
     EXPECT_EQ(VectorEncoding::Simple::FLAT, constant->encoding());
     EXPECT_EQ(selectivityVectorSize, constant->size());
   }
@@ -447,7 +447,7 @@ TEST_F(EnsureWritableVectorTest, constant) {
         SelectivityVector::empty(selectivityVectorSize),
         BIGINT(),
         pool_.get(),
-        &constant);
+        constant);
     EXPECT_EQ(VectorEncoding::Simple::FLAT, constant->encoding());
     EXPECT_EQ(constantVectorSize, constant->size());
   }
@@ -469,7 +469,7 @@ TEST_F(EnsureWritableVectorTest, array) {
 
   SelectivityVector rows(size);
   VectorPtr result;
-  BaseVector::ensureWritable(rows, ARRAY(INTEGER()), pool_.get(), &result);
+  BaseVector::ensureWritable(rows, ARRAY(INTEGER()), pool_.get(), result);
   ASSERT_EQ(size, result->size());
   ASSERT_TRUE(ARRAY(INTEGER())->kindEquals(result->type()));
   ASSERT_EQ(VectorEncoding::Simple::ARRAY, result->encoding());
@@ -481,7 +481,7 @@ TEST_F(EnsureWritableVectorTest, array) {
   ASSERT_FALSE(result.unique());
 
   auto oddRows = selectOddRows(size);
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), &result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
   ASSERT_TRUE(result.unique());
   ASSERT_NE(resultCopy.get(), result.get());
 
@@ -510,7 +510,7 @@ TEST_F(EnsureWritableVectorTest, array) {
   pointers.setElementsUnique(false);
   pointers.assertUnique(result);
 
-  BaseVector::ensureWritable(oddRows, ARRAY(INTEGER()), pool_.get(), &result);
+  BaseVector::ensureWritable(oddRows, ARRAY(INTEGER()), pool_.get(), result);
   pointers.assertPointers(result);
 
   // Verify that even rows were copied over
@@ -540,7 +540,7 @@ TEST_F(EnsureWritableVectorTest, array) {
   pointers.setOffsetsUnique(false);
   pointers.assertUnique(result);
 
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), &result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
   pointers.assertPointers(result);
 
   result->copy(b.get(), oddRows, nullptr);
@@ -562,7 +562,7 @@ TEST_F(EnsureWritableVectorTest, array) {
   pointers.setSizesUnique(false);
   pointers.assertUnique(result);
 
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), &result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
   pointers.assertPointers(result);
 
   result->copy(b.get(), oddRows, nullptr);
@@ -595,7 +595,7 @@ TEST_F(EnsureWritableVectorTest, map) {
   SelectivityVector rows(size);
   VectorPtr result;
   BaseVector::ensureWritable(
-      rows, MAP(INTEGER(), INTEGER()), pool_.get(), &result);
+      rows, MAP(INTEGER(), INTEGER()), pool_.get(), result);
   ASSERT_EQ(size, result->size());
   ASSERT_TRUE(MAP(INTEGER(), INTEGER())->kindEquals(result->type()));
   ASSERT_EQ(VectorEncoding::Simple::MAP, result->encoding());
@@ -607,7 +607,7 @@ TEST_F(EnsureWritableVectorTest, map) {
   ASSERT_FALSE(result.unique());
 
   auto oddRows = selectOddRows(size);
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), &result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
   ASSERT_TRUE(result.unique());
   ASSERT_NE(resultCopy.get(), result.get());
 
@@ -636,7 +636,7 @@ TEST_F(EnsureWritableVectorTest, map) {
   pointers.setKeysUnique(false);
   pointers.assertUnique(result);
 
-  BaseVector::ensureWritable(oddRows, ARRAY(INTEGER()), pool_.get(), &result);
+  BaseVector::ensureWritable(oddRows, ARRAY(INTEGER()), pool_.get(), result);
   pointers.assertPointers(result);
 
   // Verify that even rows were copied over
@@ -665,7 +665,7 @@ TEST_F(EnsureWritableVectorTest, map) {
   pointers.setValuesUnique(false);
   pointers.assertUnique(result);
 
-  BaseVector::ensureWritable(oddRows, ARRAY(INTEGER()), pool_.get(), &result);
+  BaseVector::ensureWritable(oddRows, ARRAY(INTEGER()), pool_.get(), result);
   pointers.assertPointers(result);
 
   // Verify that even rows were copied over
@@ -695,7 +695,7 @@ TEST_F(EnsureWritableVectorTest, map) {
   pointers.setOffsetsUnique(false);
   pointers.assertUnique(result);
 
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), &result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
   pointers.assertPointers(result);
 
   result->copy(b.get(), oddRows, nullptr);
@@ -717,7 +717,7 @@ TEST_F(EnsureWritableVectorTest, map) {
   pointers.setSizesUnique(false);
   pointers.assertUnique(result);
 
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), &result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
   pointers.assertPointers(result);
 
   result->copy(b.get(), oddRows, nullptr);
@@ -742,7 +742,7 @@ TEST_F(EnsureWritableVectorTest, allNullArray) {
   VectorPtr result = vectorMaker_->allNullArrayVector(size, BIGINT());
 
   SelectivityVector oddRows = selectOddRows(size);
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), &result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
 
   result->copy(a.get(), oddRows, nullptr);
 
@@ -758,7 +758,7 @@ TEST_F(EnsureWritableVectorTest, allNullArray) {
   result = vectorMaker_->allNullArrayVector(size, BIGINT());
   auto resultCopy = result;
 
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), &result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
   ASSERT_NE(resultCopy.get(), result.get());
 
   result->copy(a.get(), oddRows, nullptr);
@@ -786,7 +786,7 @@ TEST_F(EnsureWritableVectorTest, allNullMap) {
   VectorPtr result = vectorMaker_->allNullMapVector(size, BIGINT(), VARCHAR());
 
   SelectivityVector oddRows = selectOddRows(size);
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), &result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
 
   result->copy(a.get(), oddRows, nullptr);
 
@@ -802,7 +802,7 @@ TEST_F(EnsureWritableVectorTest, allNullMap) {
   result = vectorMaker_->allNullMapVector(size, BIGINT(), VARCHAR());
   auto resultCopy = result;
 
-  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), &result);
+  BaseVector::ensureWritable(oddRows, result->type(), pool_.get(), result);
   ASSERT_NE(resultCopy.get(), result.get());
 
   result->copy(a.get(), oddRows, nullptr);
diff --git a/velox/vector/tests/TestingDictionaryFunction.h b/velox/vector/tests/TestingDictionaryFunction.h
index 55d92010e876..53919263b6ec 100644
--- a/velox/vector/tests/TestingDictionaryFunction.h
+++ b/velox/vector/tests/TestingDictionaryFunction.h
@@ -31,12 +31,12 @@ class TestingDictionaryFunction : public exec::VectorFunction {
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& /*outputType*/,
-      exec::EvalCtx* context,
-      VectorPtr* result) const override {
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
     VELOX_CHECK(rows.isAllSelected());
     const auto size = rows.size();
-    auto indices = makeIndicesInReverse(size, context->pool());
-    *result = BaseVector::wrapInDictionary(
+    auto indices = makeIndicesInReverse(size, context.pool());
+    result = BaseVector::wrapInDictionary(
         BufferPtr(nullptr), indices, size, args[0]);
   }