duckdb 0.3.3-dev1232.0 → 0.3.3-dev1251.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.3-dev1232.0",
+  "version": "0.3.3-dev1251.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -64051,14 +64051,15 @@ class DataTable;
 class PhysicalDelete : public PhysicalOperator {
 public:
 	PhysicalDelete(vector<LogicalType> types, TableCatalogEntry &tableref, DataTable &table, idx_t row_id_index,
-	               idx_t estimated_cardinality)
+	               idx_t estimated_cardinality, bool return_chunk)
 	    : PhysicalOperator(PhysicalOperatorType::DELETE_OPERATOR, move(types), estimated_cardinality),
-	      tableref(tableref), table(table), row_id_index(row_id_index) {
+	      tableref(tableref), table(table), row_id_index(row_id_index), return_chunk(return_chunk) {
 	}
 
 	TableCatalogEntry &tableref;
 	DataTable &table;
 	idx_t row_id_index;
+	bool return_chunk;
 
 public:
 	// Source interface
@@ -64069,6 +64070,7 @@ public:
 public:
 	// Sink interface
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
+	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
 	                    DataChunk &input) const override;
 
@@ -64088,6 +64090,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
@@ -64095,21 +64098,46 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 class DeleteGlobalState : public GlobalSinkState {
 public:
-	DeleteGlobalState() : deleted_count(0) {
+	DeleteGlobalState() : deleted_count(0), returned_chunk_count(0) {
 	}
 
 	mutex delete_lock;
 	idx_t deleted_count;
+	ChunkCollection return_chunk_collection;
+	idx_t returned_chunk_count;
+};
+
+class DeleteLocalState : public LocalSinkState {
+public:
+	explicit DeleteLocalState(const vector<LogicalType> &table_types) {
+		delete_chunk.Initialize(table_types);
+	}
+	DataChunk delete_chunk;
 };
 
 SinkResultType PhysicalDelete::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
                                     DataChunk &input) const {
 	auto &gstate = (DeleteGlobalState &)state;
+	auto &ustate = (DeleteLocalState &)lstate;
+
+	// get rows and
+	auto &transaction = Transaction::GetTransaction(context.client);
+	auto &row_identifiers = input.data[row_id_index];
+
+	vector<column_t> column_ids;
+	for (idx_t i = 0; i < table.column_definitions.size(); i++) {
+		column_ids.emplace_back(i);
+	};
+	auto cfs = ColumnFetchState();
 
-	// delete data in the base table
-	// the row ids are given to us as the last column of the child chunk
 	lock_guard<mutex> delete_guard(gstate.delete_lock);
-	gstate.deleted_count += table.Delete(tableref, context.client, input.data[row_id_index], input.size());
+	if (return_chunk) {
+		row_identifiers.Normalify(input.size());
+		table.Fetch(transaction, ustate.delete_chunk, column_ids, row_identifiers, input.size(), cfs);
+		gstate.return_chunk_collection.Append(ustate.delete_chunk);
+	}
+	gstate.deleted_count += table.Delete(tableref, context.client, row_identifiers, input.size());
+
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
@@ -64117,6 +64145,10 @@ unique_ptr<GlobalSinkState> PhysicalDelete::GetGlobalSinkState(ClientContext &co
 	return make_unique<DeleteGlobalState>();
 }
 
+unique_ptr<LocalSinkState> PhysicalDelete::GetLocalSinkState(ExecutionContext &context) const {
+	return make_unique<DeleteLocalState>(table.GetTypes());
+}
+
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
@@ -64140,9 +64172,22 @@ void PhysicalDelete::GetData(ExecutionContext &context, DataChunk &chunk, Global
 		return;
 	}
 
-	chunk.SetCardinality(1);
-	chunk.SetValue(0, 0, Value::BIGINT(g.deleted_count));
-	state.finished = true;
+	if (!return_chunk) {
+		chunk.SetCardinality(1);
+		chunk.SetValue(0, 0, Value::BIGINT(g.deleted_count));
+		state.finished = true;
+	}
+
+	idx_t chunk_return = g.returned_chunk_count;
+	if (chunk_return >= g.return_chunk_collection.Chunks().size()) {
+		return;
+	}
+	chunk.Reference(g.return_chunk_collection.GetChunk(chunk_return));
+	chunk.SetCardinality((g.return_chunk_collection.GetChunk(chunk_return)).size());
+	g.returned_chunk_count += 1;
+	if (g.returned_chunk_count >= g.return_chunk_collection.Chunks().size()) {
+		state.finished = true;
+	}
 }
 
 } // namespace duckdb
@@ -64589,10 +64634,10 @@ class PhysicalUpdate : public PhysicalOperator {
 public:
 	PhysicalUpdate(vector<LogicalType> types, TableCatalogEntry &tableref, DataTable &table, vector<column_t> columns,
 	               vector<unique_ptr<Expression>> expressions, vector<unique_ptr<Expression>> bound_defaults,
-	               idx_t estimated_cardinality)
+	               idx_t estimated_cardinality, bool return_chunk)
 	    : PhysicalOperator(PhysicalOperatorType::UPDATE, move(types), estimated_cardinality), tableref(tableref),
 	      table(table), columns(std::move(columns)), expressions(move(expressions)),
-	      bound_defaults(move(bound_defaults)) {
+	      bound_defaults(move(bound_defaults)), return_chunk(return_chunk) {
 	}
 
 	TableCatalogEntry &tableref;
@@ -64601,6 +64646,8 @@ public:
 	vector<unique_ptr<Expression>> expressions;
 	vector<unique_ptr<Expression>> bound_defaults;
 	bool update_is_del_and_insert;
+	//! If the returning statement is present, return the whole chunk
+	bool return_chunk;
 
 public:
 	// Source interface
@@ -64634,6 +64681,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
@@ -64641,12 +64689,14 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 class UpdateGlobalState : public GlobalSinkState {
 public:
-	UpdateGlobalState() : updated_count(0) {
+	UpdateGlobalState() : updated_count(0), returned_chunk_count(0) {
 	}
 
 	mutex lock;
 	idx_t updated_count;
 	unordered_set<row_t> updated_columns;
+	ChunkCollection return_chunk_collection;
+	idx_t returned_chunk_count;
 };
 
 class UpdateLocalState : public LocalSinkState {
@@ -64726,9 +64776,21 @@ SinkResultType PhysicalUpdate::Sink(ExecutionContext &context, GlobalSinkState &
 		}
 		table.Append(tableref, context.client, mock_chunk);
 	} else {
+		if (return_chunk) {
+			mock_chunk.SetCardinality(update_chunk);
+			for (idx_t i = 0; i < columns.size(); i++) {
+				mock_chunk.data[columns[i]].Reference(update_chunk.data[i]);
+			}
+		}
 		table.Update(tableref, context.client, row_ids, columns, update_chunk);
 	}
+
+	if (return_chunk) {
+		gstate.return_chunk_collection.Append(mock_chunk);
+	}
+
 	gstate.updated_count += chunk.size();
+
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
@@ -64769,10 +64831,22 @@ void PhysicalUpdate::GetData(ExecutionContext &context, DataChunk &chunk, Global
 	if (state.finished) {
 		return;
 	}
+	if (!return_chunk) {
+		chunk.SetCardinality(1);
+		chunk.SetValue(0, 0, Value::BIGINT(g.updated_count));
+		state.finished = true;
+	}
 
-	chunk.SetCardinality(1);
-	chunk.SetValue(0, 0, Value::BIGINT(g.updated_count));
-	state.finished = true;
+	idx_t chunk_return = g.returned_chunk_count;
+	if (chunk_return >= g.return_chunk_collection.Chunks().size()) {
+		return;
+	}
+	chunk.Reference(g.return_chunk_collection.GetChunk(chunk_return));
+	chunk.SetCardinality((g.return_chunk_collection.GetChunk(chunk_return)).size());
+	g.returned_chunk_count += 1;
+	if (g.returned_chunk_count >= g.return_chunk_collection.Chunks().size()) {
+		state.finished = true;
+	}
 }
 
 } // namespace duckdb
@@ -68395,14 +68469,27 @@ namespace duckdb {
 class LogicalDelete : public LogicalOperator {
 public:
 	explicit LogicalDelete(TableCatalogEntry *table)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_DELETE), table(table) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_DELETE), table(table), table_index(0), return_chunk(false) {
 	}
 
 	TableCatalogEntry *table;
+	idx_t table_index;
+	bool return_chunk;
 
 protected:
+	vector<ColumnBinding> GetColumnBindings() override {
+		if (return_chunk) {
+			return GenerateColumnBindings(table_index, table->columns.size());
+		}
+		return {ColumnBinding(0, 0)};
+	}
+
 	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BIGINT);
+		if (return_chunk) {
+			types = table->GetTypes();
+		} else {
+			types.emplace_back(LogicalType::BIGINT);
+		}
 	}
 };
 } // namespace duckdb
@@ -68421,8 +68508,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelete &op
 	auto &bound_ref = (BoundReferenceExpression &)*op.expressions[0];
 
 	dependencies.insert(op.table);
-	auto del =
-	    make_unique<PhysicalDelete>(op.types, *op.table, *op.table->storage, bound_ref.index, op.estimated_cardinality);
+	auto del = make_unique<PhysicalDelete>(op.types, *op.table, *op.table->storage, bound_ref.index,
+	                                       op.estimated_cardinality, op.return_chunk);
 	del->children.push_back(move(plan));
 	return move(del);
 }
@@ -70711,17 +70798,33 @@ namespace duckdb {
 class LogicalUpdate : public LogicalOperator {
 public:
 	explicit LogicalUpdate(TableCatalogEntry *table)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE), table(table) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE), table(table), table_index(0), return_chunk(false) {
 	}
 
+	//! The base table to update
 	TableCatalogEntry *table;
+	//! table catalog index
+	idx_t table_index;
+	//! if returning option is used, return the update chunk
+	bool return_chunk;
 	vector<column_t> columns;
 	vector<unique_ptr<Expression>> bound_defaults;
 	bool update_is_del_and_insert;
 
 protected:
+	vector<ColumnBinding> GetColumnBindings() override {
+		if (return_chunk) {
+			return GenerateColumnBindings(table_index, table->columns.size());
+		}
+		return {ColumnBinding(0, 0)};
+	}
+
 	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BIGINT);
+		if (return_chunk) {
+			types = table->GetTypes();
+		} else {
+			types.emplace_back(LogicalType::BIGINT);
+		}
 	}
 };
 } // namespace duckdb
@@ -70736,7 +70839,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalUpdate &op
 
 	dependencies.insert(op.table);
 	auto update = make_unique<PhysicalUpdate>(op.types, *op.table, *op.table->storage, op.columns, move(op.expressions),
-	                                          move(op.bound_defaults), op.estimated_cardinality);
+	                                          move(op.bound_defaults), op.estimated_cardinality, op.return_chunk);
+
 	update->update_is_del_and_insert = op.update_is_del_and_insert;
 	update->children.push_back(move(plan));
 	return move(update);
@@ -119089,6 +119193,7 @@ public:
 	unique_ptr<ParsedExpression> condition;
 	unique_ptr<TableRef> table;
 	vector<unique_ptr<TableRef>> using_clauses;
+	vector<unique_ptr<ParsedExpression>> returning_list;
 
 protected:
 	DeleteStatement(const DeleteStatement &other);
@@ -120393,6 +120498,8 @@ public:
 	unique_ptr<TableRef> from_table;
 	vector<string> columns;
 	vector<unique_ptr<ParsedExpression>> expressions;
+	//! keep track of optional returningList if statement contains a RETURNING keyword
+	vector<unique_ptr<ParsedExpression>> returning_list;
 
 protected:
 	UpdateStatement(const UpdateStatement &other);
@@ -127788,10 +127895,14 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 		remove.VisitOperator(*op.children[0]);
 		return;
 	}
-	case LogicalOperatorType::LOGICAL_INSERT: {
-		//! When RETURNING is used, a PROJECTION is the top level operator
-		//! We still need to project all values from the insert so the projection
-		//! on top of the INSERT can select from only that table values being inserted
+	case LogicalOperatorType::LOGICAL_INSERT:
+	case LogicalOperatorType::LOGICAL_UPDATE:
+	case LogicalOperatorType::LOGICAL_DELETE: {
+		//! When RETURNING is used, a PROJECTION is the top level operator for INSERTS, UPDATES, and DELETES
+		//! We still need to project all values from these operators so the projection
+		//! on top of them can select from only the table values being inserted.
+		//! TODO: Push down the projections from the returning statement
+		//! TODO: Be careful because you might be adding expressions when a user returns *
 		RemoveUnusedColumns remove(binder, context, true);
 		remove.VisitOperatorExpressions(op);
 		remove.VisitOperator(*op.children[0]);
@@ -149736,6 +149847,10 @@ unique_ptr<DeleteStatement> Transformer::TransformDelete(duckdb_libpgquery::PGNo
 			result->using_clauses.push_back(move(using_entry));
 		}
 	}
+
+	if (stmt->returningList) {
+		Transformer::TransformExpressionList(*(stmt->returningList), result->returning_list);
+	}
 	return result;
 }
 
@@ -150500,6 +150615,11 @@ unique_ptr<UpdateStatement> Transformer::TransformUpdate(duckdb_libpgquery::PGNo
 		result->expressions.push_back(TransformExpression(target->val));
 	}
 
+	// Grab and transform the returning columns from the parser.
+	if (stmt->returningList) {
+		Transformer::TransformExpressionList(*(stmt->returningList), result->returning_list);
+	}
+
 	result->condition = TransformExpression(stmt->whereClause);
 	return result;
 }
@@ -155700,6 +155820,32 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/expression_binder/returning_binder.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+//! The RETURNING binder is responsible for binding expressions within the RETURNING statement
+class ReturningBinder : public ExpressionBinder {
+public:
+	ReturningBinder(Binder &binder, ClientContext &context);
+
+protected:
+	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	                          bool root_expression = false) override;
+};
+
+} // namespace duckdb
+
 
 
 
@@ -155774,10 +155920,21 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 	    LogicalType::ROW_TYPE, ColumnBinding(get.table_index, get.column_ids.size())));
 	get.column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
 
-	result.plan = move(del);
-	result.names = {"Count"};
-	result.types = {LogicalType::BIGINT};
-	this->allow_stream_result = false;
+	if (!stmt.returning_list.empty()) {
+		del->return_chunk = true;
+
+		auto update_table_index = GenerateTableIndex();
+		del->table_index = update_table_index;
+
+		unique_ptr<LogicalOperator> del_as_logicaloperator = move(del);
+		return BindReturning(move(stmt.returning_list), table, update_table_index, move(del_as_logicaloperator),
+		                     move(result));
+	} else {
+		result.plan = move(del);
+		result.names = {"Count"};
+		result.types = {LogicalType::BIGINT};
+		this->allow_stream_result = false;
+	}
 	return result;
 }
 
@@ -156100,31 +156257,6 @@ protected:
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/returning_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! The RETURNING binder is responsible for binding expressions within the RETURNING statement
-class ReturningBinder : public ExpressionBinder {
-public:
-	ReturningBinder(Binder &binder, ClientContext &context);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-};
-
-} // namespace duckdb
 
 
 namespace duckdb {
@@ -156245,57 +156377,15 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 
 	if (!stmt.returning_list.empty()) {
 		insert->return_chunk = true;
-		// clear result type and names because returning list will update them
 		result.types.clear();
 		result.names.clear();
-
 		auto insert_table_index = GenerateTableIndex();
 		insert->table_index = insert_table_index;
+		unique_ptr<LogicalOperator> index_as_logicaloperator = move(insert);
 
-		auto binder = Binder::CreateBinder(context);
-		auto types = table->GetTypes();
-		vector<std::string> names;
-		for (auto &col : table->columns) {
-			names.push_back(col.name);
-		}
-
-		binder->bind_context.AddGenericBinding(insert->table_index, stmt.table, names, types);
-		ReturningBinder returning_binder(*binder, context);
-
-		unique_ptr<LogicalOperator> insert_as_logicaloperator = move(insert);
-
-		vector<unique_ptr<Expression>> projection_expressions;
-		LogicalType result_type;
-		for (auto &returning_expr : stmt.returning_list) {
-			auto expr_type = returning_expr->GetExpressionType();
-			if (expr_type == ExpressionType::STAR) {
-				auto generated_star_list = vector<unique_ptr<ParsedExpression>>();
-				binder->bind_context.GenerateAllColumnExpressions((StarExpression &)*returning_expr,
-				                                                  generated_star_list);
-
-				for (auto &star_column : generated_star_list) {
-					auto star_expr = returning_binder.Bind(star_column, &result_type);
-					result.types.push_back(result_type);
-					result.names.push_back(star_expr->GetName());
-					projection_expressions.push_back(move(star_expr));
-				}
-			} else {
-				auto expr = returning_binder.Bind(returning_expr, &result_type);
-				result.names.push_back(expr->GetName());
-				result.types.push_back(result_type);
-				projection_expressions.push_back(move(expr));
-			}
-		}
-
-		auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), move(projection_expressions));
-		projection->AddChild(move(insert_as_logicaloperator));
-		result.plan = move(projection);
-		D_ASSERT(result.types.size() == result.names.size());
-		this->allow_stream_result = true;
-		return result;
+		return BindReturning(move(stmt.returning_list), table, insert_table_index, move(index_as_logicaloperator),
+		                     move(result));
 	} else {
-		insert->table_index = 0;
-		insert->return_chunk = false;
 		D_ASSERT(result.types.size() == result.names.size());
 		result.plan = move(insert);
 		this->allow_stream_result = false;
@@ -156750,6 +156840,8 @@ static void BindUpdateConstraints(TableCatalogEntry &table, LogicalGet &get, Log
 	}
 	// for index updates we always turn any update into an insert and a delete
 	// we thus need all the columns to be available, hence we check if the update touches any index columns
+	// If the returning keyword is used, we need access to the whole row in case the user requests it.
+	// Therefore switch the update to a delete and insert.
 	update.update_is_del_and_insert = false;
 	table.storage->info->indexes.Scan([&](Index &index) {
 		if (index.IndexIsUpdated(update.columns)) {
@@ -156767,8 +156859,9 @@ static void BindUpdateConstraints(TableCatalogEntry &table, LogicalGet &get, Log
 		}
 	}
 
-	if (update.update_is_del_and_insert) {
-		// the update updates a column required by an index, push projections for all columns
+	if (update.update_is_del_and_insert || update.return_chunk) {
+		// the update updates a column required by an index or requires returning the updated rows,
+		// push projections for all columns
 		unordered_set<column_t> all_columns;
 		for (idx_t i = 0; i < table.storage->column_definitions.size(); i++) {
 			all_columns.insert(i);
@@ -156806,6 +156899,11 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 		this->read_only = false;
 	}
 	auto update = make_unique<LogicalUpdate>(table);
+
+	// set return_chunk boolean early because it needs uses update_is_del_and_insert logic
+	if (!stmt.returning_list.empty()) {
+		update->return_chunk = true;
+	}
 	// bind the default values
 	BindDefaultValues(table->columns, update->bound_defaults);
 
@@ -156824,6 +156922,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 
 	auto proj_index = GenerateTableIndex();
 	vector<unique_ptr<Expression>> projection_expressions;
+
 	for (idx_t i = 0; i < stmt.columns.size(); i++) {
 		auto &colname = stmt.columns[i];
 		auto &expr = stmt.expressions[i];
@@ -156849,6 +156948,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 			projection_expressions.push_back(move(bound_expr));
 		}
 	}
+
 	// now create the projection
 	auto proj = make_unique<LogicalProjection>(proj_index, move(projection_expressions));
 	proj->AddChild(move(root));
@@ -156864,10 +156964,21 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	// set the projection as child of the update node and finalize the result
 	update->AddChild(move(proj));
 
-	result.names = {"Count"};
-	result.types = {LogicalType::BIGINT};
-	result.plan = move(update);
-	this->allow_stream_result = false;
+	if (!stmt.returning_list.empty()) {
+		auto update_table_index = GenerateTableIndex();
+		update->table_index = update_table_index;
+		unique_ptr<LogicalOperator> update_as_logicaloperator = move(update);
+
+		return BindReturning(move(stmt.returning_list), table, update_table_index, move(update_as_logicaloperator),
+		                     move(result));
+
+	} else {
+		update->table_index = 0;
+		result.names = {"Count"};
+		result.types = {LogicalType::BIGINT};
+		result.plan = move(update);
+		this->allow_stream_result = false;
+	}
 	return result;
 }
 
@@ -158130,6 +158241,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableFunction &ref) {
 
 
 
+
 #include <algorithm>
 
 
@@ -158498,6 +158610,53 @@ string Binder::FormatErrorRecursive(idx_t query_location, const string &message,
 	return context.FormatErrorRecursive(message, values);
 }
 
+BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry *table,
+                                     idx_t update_table_index, unique_ptr<LogicalOperator> child_operator,
+                                     BoundStatement result) {
+
+	vector<LogicalType> types;
+	vector<std::string> names;
+
+	auto binder = Binder::CreateBinder(context);
+
+	for (auto &col : table->columns) {
+		names.push_back(col.name);
+		types.push_back(col.type);
+	}
+
+	binder->bind_context.AddGenericBinding(update_table_index, table->name, names, types);
+	ReturningBinder returning_binder(*binder, context);
+
+	vector<unique_ptr<Expression>> projection_expressions;
+	LogicalType result_type;
+	for (auto &returning_expr : returning_list) {
+		auto expr_type = returning_expr->GetExpressionType();
+		if (expr_type == ExpressionType::STAR) {
+			auto generated_star_list = vector<unique_ptr<ParsedExpression>>();
+			binder->bind_context.GenerateAllColumnExpressions((StarExpression &)*returning_expr, generated_star_list);
+
+			for (auto &star_column : generated_star_list) {
+				auto star_expr = returning_binder.Bind(star_column, &result_type);
+				result.types.push_back(result_type);
+				result.names.push_back(star_expr->GetName());
+				projection_expressions.push_back(move(star_expr));
+			}
+		} else {
+			auto expr = returning_binder.Bind(returning_expr, &result_type);
+			result.names.push_back(expr->GetName());
+			result.types.push_back(result_type);
+			projection_expressions.push_back(move(expr));
+		}
+	}
+
+	auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), move(projection_expressions));
+	projection->AddChild(move(child_operator));
+	D_ASSERT(result.types.size() == result.names.size());
+	result.plan = move(projection);
+	this->allow_stream_result = true;
+	return result;
+}
+
 } // namespace duckdb
 
 

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "041fb2cc7"
-#define DUCKDB_VERSION "v0.3.3-dev1232"
+#define DUCKDB_SOURCE_ID "a8cf83273"
+#define DUCKDB_VERSION "v0.3.3-dev1251"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -13542,6 +13542,9 @@ private:
 	BoundStatement Bind(ExportStatement &stmt);
 	BoundStatement Bind(SetStatement &stmt);
 	BoundStatement Bind(LoadStatement &stmt);
+	BoundStatement BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry *table,
+	                             idx_t update_table_index, unique_ptr<LogicalOperator> child_operator,
+	                             BoundStatement result);
 
 	unique_ptr<QueryNode> BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry *macro_func, idx_t depth);