duckdb 0.7.2-dev3117.0 → 0.7.2-dev3154.0

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_fixed_batch_copy.hpp

@@ -0,0 +1,72 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/persistent/physical_fixed_batch_copy.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/physical_operator.hpp"
+#include "duckdb/parser/parsed_data/copy_info.hpp"
+#include "duckdb/function/copy_function.hpp"
+#include "duckdb/common/file_system.hpp"
+#include "duckdb/common/filename_pattern.hpp"
+
+namespace duckdb {
+
+class PhysicalFixedBatchCopy : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::FIXED_BATCH_COPY_TO_FILE;
+
+public:
+	PhysicalFixedBatchCopy(vector<LogicalType> types, CopyFunction function, unique_ptr<FunctionData> bind_data,
+	                       idx_t estimated_cardinality);
+
+	CopyFunction function;
+	unique_ptr<FunctionData> bind_data;
+	string file_path;
+	bool use_tmp_file;
+
+public:
+	// Source interface
+	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
+
+	bool IsSource() const override {
+		return true;
+	}
+
+public:
+	// Sink interface
+	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
+	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
+	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
+	                          GlobalSinkState &gstate) const override;
+	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
+	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
+	void NextBatch(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p) const override;
+
+	bool RequiresBatchIndex() const override {
+		return true;
+	}
+
+	bool IsSink() const override {
+		return true;
+	}
+
+	bool ParallelSink() const override {
+		return true;
+	}
+
+public:
+	void AddRawBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t batch_index,
+	                     unique_ptr<ColumnDataCollection> collection) const;
+	void RepartitionBatches(ClientContext &context, GlobalSinkState &gstate_p, idx_t min_index,
+	                        bool final = false) const;
+	void FlushBatchData(ClientContext &context, GlobalSinkState &gstate_p, idx_t min_index) const;
+	bool ExecuteTask(ClientContext &context, GlobalSinkState &gstate_p) const;
+	void ExecuteTasks(ClientContext &context, GlobalSinkState &gstate_p) const;
+	SinkFinalizeType FinalFlush(ClientContext &context, GlobalSinkState &gstate_p) const;
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/function/copy_function.hpp

@@ -97,6 +97,7 @@ typedef unique_ptr<PreparedBatchData> (*copy_prepare_batch_t)(ClientContext &con
                                                               unique_ptr<ColumnDataCollection> collection);
 typedef void (*copy_flush_batch_t)(ClientContext &context, FunctionData &bind_data, GlobalFunctionData &gstate,
                                    PreparedBatchData &batch);
+typedef idx_t (*copy_desired_batch_size_t)(ClientContext &context, FunctionData &bind_data);
 
 class CopyFunction : public Function {
 public:
@@ -104,7 +105,7 @@ public:
 	    : Function(name), plan(nullptr), copy_to_bind(nullptr), copy_to_initialize_local(nullptr),
 	      copy_to_initialize_global(nullptr), copy_to_sink(nullptr), copy_to_combine(nullptr),
 	      copy_to_finalize(nullptr), execution_mode(nullptr), prepare_batch(nullptr), flush_batch(nullptr),
-	      serialize(nullptr), deserialize(nullptr), copy_from_bind(nullptr) {
+	      desired_batch_size(nullptr), serialize(nullptr), deserialize(nullptr), copy_from_bind(nullptr) {
 	}
 
 	//! Plan rewrite copy function
@@ -120,6 +121,7 @@ public:
 
 	copy_prepare_batch_t prepare_batch;
 	copy_flush_batch_t flush_batch;
+	copy_desired_batch_size_t desired_batch_size;
 
 	copy_to_serialize_t serialize;
 	copy_to_deserialize_t deserialize;

package/src/duckdb/src/planner/operator/logical_delete.cpp

@@ -15,6 +15,7 @@ void LogicalDelete::Serialize(FieldWriter &writer) const {
 	table.Serialize(writer.GetSerializer());
 	writer.WriteField(table_index);
 	writer.WriteField(return_chunk);
+	writer.WriteSerializableList(this->expressions);
 }
 
 unique_ptr<LogicalOperator> LogicalDelete::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
@@ -26,6 +27,7 @@ unique_ptr<LogicalOperator> LogicalDelete::Deserialize(LogicalDeserializationSta
 	auto table_index = reader.ReadRequired<idx_t>();
 	auto result = make_uniq<LogicalDelete>(table_catalog_entry, table_index);
 	result->return_chunk = reader.ReadRequired<bool>();
+	result->expressions = reader.ReadRequiredSerializableList<duckdb::Expression>(state.gstate);
 	return std::move(result);
 }
 

package/src/duckdb/src/planner/operator/logical_update.cpp

@@ -17,6 +17,7 @@ void LogicalUpdate::Serialize(FieldWriter &writer) const {
 	writer.WriteIndexList<PhysicalIndex>(columns);
 	writer.WriteSerializableList(bound_defaults);
 	writer.WriteField(update_is_del_and_insert);
+	writer.WriteSerializableList(this->expressions);
 }
 
 unique_ptr<LogicalOperator> LogicalUpdate::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
@@ -31,6 +32,7 @@ unique_ptr<LogicalOperator> LogicalUpdate::Deserialize(LogicalDeserializationSta
 	result->columns = reader.ReadRequiredIndexList<PhysicalIndex>();
 	result->bound_defaults = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 	result->update_is_del_and_insert = reader.ReadRequired<bool>();
+	result->expressions = reader.ReadRequiredSerializableList<duckdb::Expression>(state.gstate);
 	return std::move(result);
 }
 

package/src/duckdb/third_party/utf8proc/include/utf8proc_wrapper.hpp

@@ -3,6 +3,7 @@
 #include <string>
 #include <cassert>
 #include <cstring>
+#include <cstdint>
 
 namespace duckdb {
 

package/src/duckdb/ub_src_core_functions_scalar_map.cpp

@@ -6,6 +6,8 @@
 
 #include "src/core_functions/scalar/map/map_entries.cpp"
 
+#include "src/core_functions/scalar/map/map_concat.cpp"
+
 #include "src/core_functions/scalar/map/map_keys_values.cpp"
 
 #include "src/core_functions/scalar/map/cardinality.cpp"

package/src/duckdb/ub_src_execution_operator_persistent.cpp

@@ -8,6 +8,8 @@
 
 #include "src/execution/operator/persistent/csv_reader_options.cpp"
 
+#include "src/execution/operator/persistent/physical_fixed_batch_copy.cpp"
+
 #include "src/execution/operator/persistent/physical_batch_copy_to_file.cpp"
 
 #include "src/execution/operator/persistent/physical_batch_insert.cpp"