[Appender] Add AppendDefault

src/execution/expression_executor.cpp

@@ -102,6 +102,12 @@ void ExpressionExecutor::ExecuteExpression(idx_t expr_idx, Vector &result) {
 	Execute(*expressions[expr_idx], states[expr_idx]->root_state.get(), nullptr, chunk ? chunk->size() : 1, result);
 }
 
+void ExpressionExecutor::ExecuteExpression(idx_t expr_idx, Vector &result, SelectionVector &vector) {
+	D_ASSERT(expr_idx < expressions.size());
+	D_ASSERT(result.GetType().id() == expressions[expr_idx]->return_type.id());
+	Execute(*expressions[expr_idx], states[expr_idx]->root_state.get(), &vector, chunk ? chunk->size() : 1, result);
+}
+
 Value ExpressionExecutor::EvaluateScalar(ClientContext &context, const Expression &expr, bool allow_unfoldable) {
 	D_ASSERT(allow_unfoldable || expr.IsFoldable());
 	D_ASSERT(expr.IsScalar());

src/execution/expression_executor/execute_constant.cpp

@@ -14,7 +14,14 @@ unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundConst
 void ExpressionExecutor::Execute(const BoundConstantExpression &expr, ExpressionState *state,
                                  const SelectionVector *sel, idx_t count, Vector &result) {
 	D_ASSERT(expr.value.type() == expr.return_type);
-	result.Reference(expr.value);
+	if (sel) {
+		for (idx_t i = 0; i < count; i++) {
+			auto index = sel->get_index(i);
+			result.SetValue(index, expr.value);
+		}
+	} else {
+		result.Reference(expr.value);
+	}
 }
 
 } // namespace duckdb

src/include/duckdb/execution/expression_executor.hpp

@@ -65,6 +65,8 @@ class ExpressionExecutor {
 
 	//! Execute the expression with index `expr_idx` and store the result in the result vector
 	DUCKDB_API void ExecuteExpression(idx_t expr_idx, Vector &result);
+	//! Same as above, only executing the expression for the rows provided by the SelectionVector
+	DUCKDB_API void ExecuteExpression(idx_t expr_idx, Vector &result, SelectionVector &sel);
 	//! Evaluate a scalar expression and fold it into a single value
 	DUCKDB_API static Value EvaluateScalar(ClientContext &context, const Expression &expr,
 	                                       bool allow_unfoldable = false);

src/include/duckdb/main/appender.hpp

@@ -20,6 +20,7 @@ class ClientContext;
 class DuckDB;
 class TableCatalogEntry;
 class Connection;
+struct SelectionVector;
 
 enum class AppenderType : uint8_t {
 	LOGICAL, // Cast input -> LogicalType
@@ -129,6 +130,7 @@ class Appender : public BaseAppender {
 
 public:
 	void AppendDefault();
+	void AppendDefaultToVector(Vector &result, idx_t column, SelectionVector &sel, idx_t count);
 
 protected:
 	void FlushInternal(ColumnDataCollection &collection) override;

src/main/appender.cpp

@@ -15,6 +15,7 @@
 #include "duckdb/planner/expression_binder/constant_binder.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/common/types/selection_vector.hpp"
 
 namespace duckdb {
 
@@ -410,6 +411,31 @@ void Appender::FlushInternal(ColumnDataCollection &collection) {
 	context->Append(*description, collection);
 }
 
+void Appender::AppendDefaultToVector(Vector &result, idx_t column, SelectionVector &sel, idx_t count) {
+	// TODO: throw if count is > STANDARD_VECTOR_SIZE
+	if (column >= types.size()) {
+		throw InvalidInputException(
+		    "Could not append DEFAULT value of column %d, out of range index, table only has %d columns", column,
+		    types.size());
+	}
+	auto &type = types[column];
+	if (result.GetType() != type) {
+		throw InvalidInputException("Type mismatch, column has type: %s, while the provided Vector has type %s",
+		                            type.ToString(), result.GetType().ToString());
+	}
+
+	auto &executor = *expression_executor;
+
+	// This is only used to tell the ExpressionExecutor the size of our result
+	DataChunk empty_chunk;
+	empty_chunk.SetCardinality(count);
+	executor.SetChunk(empty_chunk);
+
+	// FIXME: if we are feeding the Vector to the ExecuteExpression method, we have to first make sure
+	// that the validity mask of the Vector is clean
+	context->RunFunctionInTransaction([&]() { executor.ExecuteExpression(column, result, sel); });
+}
+
 void Appender::AppendDefault() {
 	auto &default_expr = bound_defaults[column];
 	if (default_expr->type == ExpressionType::VALUE_CONSTANT) {

test/appender/test_appender.cpp

@@ -269,6 +269,41 @@ TEST_CASE("Test default value appender", "[appender]") {
 	con.Query("COMMIT");
 }
 
+TEST_CASE("Test append default into Vector", "[appender]") {
+	DuckDB db(nullptr);
+	Connection con(db);
+
+	REQUIRE_NO_FAIL(con.Query("CREATE TABLE integers(i iNTEGER)"));
+
+	auto result = con.Query("SELECT a::INTEGER FROM RANGE(15) t(a)");
+	auto chunk = result->Fetch();
+	D_ASSERT(result->type == QueryResultType::MATERIALIZED_RESULT);
+
+	{
+		Appender appender(con, "integers");
+
+		auto &column = chunk->data[0];
+		SelectionVector sel(3);
+
+		sel.set_index(0, 5);
+		sel.set_index(1, 8);
+		sel.set_index(2, 3);
+
+		appender.AppendDefaultToVector(column, 0, sel, 3);
+		REQUIRE(column.GetValue(0) == 0);
+		REQUIRE(column.GetValue(1) == 1);
+
+		REQUIRE(column.GetValue(5).IsNull());
+
+		REQUIRE(column.GetValue(8).IsNull());
+
+		REQUIRE(column.GetValue(3).IsNull());
+
+		REQUIRE(!column.GetValue(14).IsNull());
+		REQUIRE(column.GetValue(14) == 14);
+	}
+}
+
 TEST_CASE("Test incorrect usage of appender", "[appender]") {
 	duckdb::unique_ptr<QueryResult> result;
 	DuckDB db(nullptr);