duckdb 0.7.2-dev3515.0 → 0.7.2-dev3666.0

package/src/duckdb/src/include/duckdb/common/operator/string_cast.hpp

@@ -20,7 +20,7 @@ class Vector;
 
 struct StringCast {
 	template <class SRC>
-	DUCKDB_API static inline string_t Operation(SRC input, Vector &result) {
+	static inline string_t Operation(SRC input, Vector &result) {
 		throw NotImplementedException("Unimplemented type for string cast!");
 	}
 };

package/src/duckdb/src/include/duckdb/common/operator/subtract.hpp

@@ -72,7 +72,7 @@ bool TrySubtractOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &
 
 struct SubtractOperatorOverflowCheck {
 	template <class TA, class TB, class TR>
-	DUCKDB_API static inline TR Operation(TA left, TB right) {
+	static inline TR Operation(TA left, TB right) {
 		TR result;
 		if (!TrySubtractOperator::Operation(left, right, result)) {
 			throw OutOfRangeException("Overflow in subtraction of %s (%d - %d)!", TypeIdToString(GetTypeId<TA>()), left,

package/src/duckdb/src/include/duckdb/common/preserved_error.hpp

@@ -39,7 +39,7 @@ public:
 	//! Let's us do things like 'if (error)'
 	DUCKDB_API operator bool() const;
 	DUCKDB_API bool operator==(const PreservedError &other) const;
-	DUCKDB_API const shared_ptr<Exception> &GetError() {
+	const shared_ptr<Exception> &GetError() {
 		return exception_instance;
 	}
 

package/src/duckdb/src/include/duckdb/common/re2_regex.hpp

@@ -15,7 +15,7 @@ enum class RegexOptions : uint8_t { NONE, CASE_INSENSITIVE };
 class Regex {
 public:
 	DUCKDB_API Regex(const std::string &pattern, RegexOptions options = RegexOptions::NONE);
-	DUCKDB_API Regex(const char *pattern, RegexOptions options = RegexOptions::NONE) : Regex(std::string(pattern)) {
+	Regex(const char *pattern, RegexOptions options = RegexOptions::NONE) : Regex(std::string(pattern)) {
 	}
 	const duckdb_re2::RE2 &GetRegex() const {
 		return *regex;

package/src/duckdb/src/include/duckdb/common/string_util.hpp

@@ -45,25 +45,25 @@ public:
 		throw InvalidInputException("Invalid input for binary digit: %s", string(c, 1));
 	}
 
-	DUCKDB_API static bool CharacterIsSpace(char c) {
+	static bool CharacterIsSpace(char c) {
 		return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
 	}
-	DUCKDB_API static bool CharacterIsNewline(char c) {
+	static bool CharacterIsNewline(char c) {
 		return c == '\n' || c == '\r';
 	}
-	DUCKDB_API static bool CharacterIsDigit(char c) {
+	static bool CharacterIsDigit(char c) {
 		return c >= '0' && c <= '9';
 	}
-	DUCKDB_API static bool CharacterIsHex(char c) {
+	static bool CharacterIsHex(char c) {
 		return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
 	}
-	DUCKDB_API static char CharacterToLower(char c) {
+	static char CharacterToLower(char c) {
 		if (c >= 'A' && c <= 'Z') {
 			return c - ('A' - 'a');
 		}
 		return c;
 	}
-	DUCKDB_API static char CharacterIsAlpha(char c) {
+	static char CharacterIsAlpha(char c) {
 		return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
 	}
 	static bool CharacterIsOperator(char c) {
@@ -200,7 +200,7 @@ public:
 
 	//! Returns true if two null-terminated strings are equal or point to the same address.
 	//! Returns false if only one of the strings is nullptr
-	DUCKDB_API static bool Equals(const char *s1, const char *s2) {
+	static bool Equals(const char *s1, const char *s2) {
 		if (s1 == s2) {
 			return true;
 		}

package/src/duckdb/src/include/duckdb/common/types/chunk_collection.hpp

@@ -30,7 +30,7 @@ public:
 	explicit ChunkCollection(ClientContext &context);
 
 	//! The types of columns in the ChunkCollection
-	DUCKDB_API vector<LogicalType> &Types() {
+	vector<LogicalType> &Types() {
 		return types;
 	}
 	const vector<LogicalType> &Types() const {
@@ -38,12 +38,12 @@ public:
 	}
 
 	//! The amount of rows in the ChunkCollection
-	DUCKDB_API const idx_t &Count() const {
+	const idx_t &Count() const {
 		return count;
 	}
 
 	//! The amount of columns in the ChunkCollection
-	DUCKDB_API idx_t ColumnCount() const {
+	idx_t ColumnCount() const {
 		return types.size();
 	}
 
@@ -76,12 +76,12 @@ public:
 	DUCKDB_API void Print() const;
 
 	//! Gets a reference to the chunk at the given index
-	DUCKDB_API DataChunk &GetChunkForRow(idx_t row_index) {
+	DataChunk &GetChunkForRow(idx_t row_index) {
 		return *chunks[LocateChunk(row_index)];
 	}
 
 	//! Gets a reference to the chunk at the given index
-	DUCKDB_API DataChunk &GetChunk(idx_t chunk_index) {
+	DataChunk &GetChunk(idx_t chunk_index) {
 		D_ASSERT(chunk_index < chunks.size());
 		return *chunks[chunk_index];
 	}
@@ -90,21 +90,21 @@ public:
 		return *chunks[chunk_index];
 	}
 
-	DUCKDB_API const vector<unique_ptr<DataChunk>> &Chunks() {
+	const vector<unique_ptr<DataChunk>> &Chunks() {
 		return chunks;
 	}
 
-	DUCKDB_API idx_t ChunkCount() const {
+	idx_t ChunkCount() const {
 		return chunks.size();
 	}
 
-	DUCKDB_API void Reset() {
+	void Reset() {
 		count = 0;
 		chunks.clear();
 		types.clear();
 	}
 
-	DUCKDB_API unique_ptr<DataChunk> Fetch() {
+	unique_ptr<DataChunk> Fetch() {
 		if (ChunkCount() == 0) {
 			return nullptr;
 		}
@@ -115,7 +115,7 @@ public:
 	}
 
 	//! Locates the chunk that belongs to the specific index
-	DUCKDB_API idx_t LocateChunk(idx_t index) {
+	idx_t LocateChunk(idx_t index) {
 		idx_t result = index / STANDARD_VECTOR_SIZE;
 		D_ASSERT(result < chunks.size());
 		return result;

package/src/duckdb/src/include/duckdb/common/types/column/column_data_collection.hpp

@@ -44,20 +44,20 @@ public:
 
 public:
 	//! The types of columns in the ColumnDataCollection
-	DUCKDB_API vector<LogicalType> &Types() {
+	vector<LogicalType> &Types() {
 		return types;
 	}
-	DUCKDB_API const vector<LogicalType> &Types() const {
+	const vector<LogicalType> &Types() const {
 		return types;
 	}
 
 	//! The amount of rows in the ColumnDataCollection
-	DUCKDB_API const idx_t &Count() const {
+	const idx_t &Count() const {
 		return count;
 	}
 
 	//! The amount of columns in the ColumnDataCollection
-	DUCKDB_API idx_t ColumnCount() const {
+	idx_t ColumnCount() const {
 		return types.size();
 	}
 
@@ -177,32 +177,32 @@ public:
 
 public:
 	// container API
-	DUCKDB_API bool empty() const {
+	bool empty() const {
 		return rows.empty();
 	}
-	DUCKDB_API idx_t size() const {
+	idx_t size() const {
 		return rows.size();
 	}
 
 	DUCKDB_API ColumnDataRow &operator[](idx_t i);
 	DUCKDB_API const ColumnDataRow &operator[](idx_t i) const;
 
-	DUCKDB_API vector<ColumnDataRow>::iterator begin() {
+	vector<ColumnDataRow>::iterator begin() {
 		return rows.begin();
 	}
-	DUCKDB_API vector<ColumnDataRow>::iterator end() {
+	vector<ColumnDataRow>::iterator end() {
 		return rows.end();
 	}
-	DUCKDB_API vector<ColumnDataRow>::const_iterator cbegin() const {
+	vector<ColumnDataRow>::const_iterator cbegin() const {
 		return rows.cbegin();
 	}
-	DUCKDB_API vector<ColumnDataRow>::const_iterator cend() const {
+	vector<ColumnDataRow>::const_iterator cend() const {
 		return rows.cend();
 	}
-	DUCKDB_API vector<ColumnDataRow>::const_iterator begin() const {
+	vector<ColumnDataRow>::const_iterator begin() const {
 		return rows.begin();
 	}
-	DUCKDB_API vector<ColumnDataRow>::const_iterator end() const {
+	vector<ColumnDataRow>::const_iterator end() const {
 		return rows.end();
 	}
 

package/src/duckdb/src/include/duckdb/common/types/column/column_data_collection_iterators.hpp

@@ -43,10 +43,10 @@ private:
 	};
 
 public:
-	DUCKDB_API ColumnDataChunkIterator begin() {
+	ColumnDataChunkIterator begin() {
 		return ColumnDataChunkIterator(&collection, column_ids);
 	}
-	DUCKDB_API ColumnDataChunkIterator end() {
+	ColumnDataChunkIterator end() {
 		return ColumnDataChunkIterator(nullptr, vector<column_t>());
 	}
 };

package/src/duckdb/src/include/duckdb/common/types/value.hpp

@@ -165,7 +165,7 @@ public:
 
 	//! Create a blob Value from a data pointer and a length: no bytes are interpreted
 	DUCKDB_API static Value BLOB(const_data_ptr_t data, idx_t len);
-	DUCKDB_API static Value BLOB_RAW(const string &data) { // NOLINT
+	static Value BLOB_RAW(const string &data) { // NOLINT
 		return Value::BLOB((const_data_ptr_t)data.c_str(), data.size());
 	}
 	//! Creates a blob by casting a specified string to a blob (i.e. interpreting \x characters)

package/src/duckdb/src/include/duckdb/common/types/vector_buffer.hpp

@@ -241,12 +241,22 @@ public:
 
 	void PushBack(const Value &insert);
 
-	idx_t capacity = 0;
-	idx_t size = 0;
+	idx_t GetSize() {
+		return size;
+	}
+
+	idx_t GetCapacity() {
+		return capacity;
+	}
+
+	void SetCapacity(idx_t new_capacity);
+	void SetSize(idx_t new_size);
 
 private:
 	//! child vectors used for nested data
 	unique_ptr<Vector> child;
+	idx_t capacity = 0;
+	idx_t size = 0;
 };
 
 //! The ManagedVectorBuffer holds a buffer handle

package/src/duckdb/src/include/duckdb/common/types.hpp

@@ -308,14 +308,14 @@ struct LogicalType {
 	DUCKDB_API static LogicalType FormatDeserialize(FormatDeserializer &deserializer);
 
 
-	DUCKDB_API static bool TypeIsTimestamp(LogicalTypeId id) {
+	static bool TypeIsTimestamp(LogicalTypeId id) {
 		return (id == LogicalTypeId::TIMESTAMP ||
 				id == LogicalTypeId::TIMESTAMP_MS ||
 				id == LogicalTypeId::TIMESTAMP_NS ||
 				id == LogicalTypeId::TIMESTAMP_SEC ||
 				id == LogicalTypeId::TIMESTAMP_TZ);
 	}
-	DUCKDB_API static bool TypeIsTimestamp(const LogicalType& type) {
+	static bool TypeIsTimestamp(const LogicalType& type) {
 		return TypeIsTimestamp(type.id());
 	}
 	DUCKDB_API string ToString() const;

package/src/duckdb/src/include/duckdb/common/winapi.hpp

@@ -9,7 +9,7 @@
 #pragma once
 
 #ifndef DUCKDB_API
-#ifdef _WIN32
+#if defined(_WIN32) && !defined(__MINGW32__)
 #if defined(DUCKDB_BUILD_LIBRARY) && !defined(DUCKDB_BUILD_LOADABLE_EXTENSION)
 #define DUCKDB_API __declspec(dllexport)
 #else

package/src/duckdb/src/include/duckdb/execution/expression_executor_state.hpp

@@ -48,7 +48,7 @@ struct ExecuteFunctionState : public ExpressionState {
 	unique_ptr<FunctionLocalState> local_state;
 
 public:
-	DUCKDB_API static FunctionLocalState *GetFunctionState(ExpressionState &state) {
+	static FunctionLocalState *GetFunctionState(ExpressionState &state) {
 		return ((ExecuteFunctionState &)state).local_state.get();
 	}
 };

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

@@ -19,13 +19,15 @@
 
 namespace duckdb {
 
-enum NewLineIdentifier {
+enum class NewLineIdentifier : uint8_t {
 	SINGLE = 1,   // Either \r or \n
 	CARRY_ON = 2, // \r\n
 	MIX = 3,      // Hippie-Land, can't run it multithreaded
 	NOT_SET = 4
 };
 
+enum class ParallelMode { AUTOMATIC = 0, PARALLEL = 1, SINGLE_THREADED = 2 };
+
 struct BufferedCSVReaderOptions {
 	//===--------------------------------------------------------------------===//
 	// CommonCSVOptions
@@ -116,13 +118,16 @@ struct BufferedCSVReaderOptions {
 	//! If we are running the parallel version of the CSV Reader. In general, the system should always auto-detect
 	//! When it can't execute a parallel run before execution. However, there are (rather specific) situations where
 	//! setting up this manually might be important
-	bool run_parallel = true;
+	ParallelMode parallel_mode;
 	//===--------------------------------------------------------------------===//
 	// WriteCSVOptions
 	//===--------------------------------------------------------------------===//
-
 	//! True, if column with that index must be quoted
 	vector<bool> force_quote;
+	//! Prefix/suffix/custom newline the entire file once (enables writing of files as JSON arrays)
+	string prefix;
+	string suffix;
+	string write_newline;
 
 	//! The date format to use (if any is specified)
 	std::map<LogicalTypeId, StrpTimeFormat> date_format = {{LogicalTypeId::DATE, {}}, {LogicalTypeId::TIMESTAMP, {}}};
@@ -130,8 +135,7 @@ struct BufferedCSVReaderOptions {
 	std::map<LogicalTypeId, StrfTimeFormat> write_date_format = {{LogicalTypeId::DATE, {}},
 	                                                             {LogicalTypeId::TIMESTAMP, {}}};
 	//! Whether or not a type format is specified
-	std::map<LogicalTypeId, bool> has_format = {
-	    {LogicalTypeId::DATE, false}, {LogicalTypeId::TIMESTAMP, false}, {LogicalTypeId::TIMESTAMP_TZ, false}};
+	std::map<LogicalTypeId, bool> has_format = {{LogicalTypeId::DATE, false}, {LogicalTypeId::TIMESTAMP, false}};
 
 	void Serialize(FieldWriter &writer) const;
 	void Deserialize(FieldReader &reader);

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_type.hpp

@@ -38,7 +38,7 @@ public:
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
 
 	bool IsSink() const override {
-		return info->query != nullptr;
+		return !children.empty();
 	}
 
 	bool ParallelSink() const override {

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

@@ -81,7 +81,6 @@ typedef unique_ptr<FunctionData> (*aggregate_deserialize_t)(ClientContext &conte
 
 class AggregateFunction : public BaseScalarFunction {
 public:
-	DUCKDB_API
 	AggregateFunction(const string &name, const vector<LogicalType> &arguments, const LogicalType &return_type,
 	                  aggregate_size_t state_size, aggregate_initialize_t initialize, aggregate_update_t update,
 	                  aggregate_combine_t combine, aggregate_finalize_t finalize,
@@ -97,7 +96,6 @@ public:
 	      serialize(serialize), deserialize(deserialize), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
 	}
 
-	DUCKDB_API
 	AggregateFunction(const string &name, const vector<LogicalType> &arguments, const LogicalType &return_type,
 	                  aggregate_size_t state_size, aggregate_initialize_t initialize, aggregate_update_t update,
 	                  aggregate_combine_t combine, aggregate_finalize_t finalize,
@@ -112,21 +110,19 @@ public:
 	      serialize(serialize), deserialize(deserialize), order_dependent(AggregateOrderDependent::ORDER_DEPENDENT) {
 	}
 
-	DUCKDB_API AggregateFunction(const vector<LogicalType> &arguments, const LogicalType &return_type,
-	                             aggregate_size_t state_size, aggregate_initialize_t initialize,
-	                             aggregate_update_t update, aggregate_combine_t combine, aggregate_finalize_t finalize,
-	                             FunctionNullHandling null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING,
-	                             aggregate_simple_update_t simple_update = nullptr,
-	                             bind_aggregate_function_t bind = nullptr, aggregate_destructor_t destructor = nullptr,
-	                             aggregate_statistics_t statistics = nullptr, aggregate_window_t window = nullptr,
-	                             aggregate_serialize_t serialize = nullptr,
-	                             aggregate_deserialize_t deserialize = nullptr)
+	AggregateFunction(const vector<LogicalType> &arguments, const LogicalType &return_type, aggregate_size_t state_size,
+	                  aggregate_initialize_t initialize, aggregate_update_t update, aggregate_combine_t combine,
+	                  aggregate_finalize_t finalize,
+	                  FunctionNullHandling null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING,
+	                  aggregate_simple_update_t simple_update = nullptr, bind_aggregate_function_t bind = nullptr,
+	                  aggregate_destructor_t destructor = nullptr, aggregate_statistics_t statistics = nullptr,
+	                  aggregate_window_t window = nullptr, aggregate_serialize_t serialize = nullptr,
+	                  aggregate_deserialize_t deserialize = nullptr)
 	    : AggregateFunction(string(), arguments, return_type, state_size, initialize, update, combine, finalize,
 	                        null_handling, simple_update, bind, destructor, statistics, window, serialize,
 	                        deserialize) {
 	}
 
-	DUCKDB_API
 	AggregateFunction(const vector<LogicalType> &arguments, const LogicalType &return_type, aggregate_size_t state_size,
 	                  aggregate_initialize_t initialize, aggregate_update_t update, aggregate_combine_t combine,
 	                  aggregate_finalize_t finalize, aggregate_simple_update_t simple_update = nullptr,
@@ -165,11 +161,11 @@ public:
 	//! Whether or not the aggregate is order dependent
 	AggregateOrderDependent order_dependent;
 
-	DUCKDB_API bool operator==(const AggregateFunction &rhs) const {
+	bool operator==(const AggregateFunction &rhs) const {
 		return state_size == rhs.state_size && initialize == rhs.initialize && update == rhs.update &&
 		       combine == rhs.combine && finalize == rhs.finalize && window == rhs.window;
 	}
-	DUCKDB_API bool operator!=(const AggregateFunction &rhs) const {
+	bool operator!=(const AggregateFunction &rhs) const {
 		return !(*this == rhs);
 	}
 

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

@@ -21,7 +21,7 @@ enum class MacroType : uint8_t { VOID_MACRO = 0, TABLE_MACRO = 1, SCALAR_MACRO =
 
 class MacroFunction {
 public:
-	MacroFunction(MacroType type);
+	explicit MacroFunction(MacroType type);
 
 	//! The type
 	MacroType type;
@@ -45,6 +45,12 @@ public:
 
 	virtual string ToSQL(const string &schema, const string &name) const;
 
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<MacroFunction> Deserialize(Deserializer &deserializer);
+
+protected:
+	virtual void SerializeInternal(FieldWriter &writer) const = 0;
+
 public:
 	template <class TARGET>
 	TARGET &Cast() {

package/src/duckdb/src/include/duckdb/function/scalar/strftime_format.hpp

@@ -66,6 +66,9 @@ public:
 		return std::find(specifiers.begin(), specifiers.end(), s) != specifiers.end();
 	}
 
+	//! The full format specifier, for error messages
+	string format_specifier;
+
 protected:
 	//! The format specifiers
 	vector<StrTimeSpecifier> specifiers;
@@ -134,10 +137,6 @@ public:
 		DUCKDB_API string FormatError(string_t input, const string &format_specifier);
 	};
 
-public:
-	//! The full format specifier, for error messages
-	string format_specifier;
-
 public:
 	DUCKDB_API static ParseResult Parse(const string &format, const string &text);
 

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

@@ -23,9 +23,9 @@ public:
 	static constexpr const MacroType TYPE = MacroType::SCALAR_MACRO;
 
 public:
-	ScalarMacroFunction(unique_ptr<ParsedExpression> expression);
-
+	explicit ScalarMacroFunction(unique_ptr<ParsedExpression> expression);
 	ScalarMacroFunction(void);
+
 	//! The macro expression
 	unique_ptr<ParsedExpression> expression;
 
@@ -33,6 +33,11 @@ public:
 	unique_ptr<MacroFunction> Copy() const override;
 
 	string ToSQL(const string &schema, const string &name) const override;
+
+	static unique_ptr<MacroFunction> Deserialize(FieldReader &reader);
+
+protected:
+	void SerializeInternal(FieldWriter &writer) const override;
 };
 
 } // namespace duckdb

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

@@ -48,7 +48,7 @@ public:
 public:
 	DUCKDB_API virtual ~GlobalTableFunctionState();
 
-	DUCKDB_API virtual idx_t MaxThreads() const {
+	virtual idx_t MaxThreads() const {
 		return 1;
 	}
 

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

@@ -33,6 +33,11 @@ public:
 	unique_ptr<MacroFunction> Copy() const override;
 
 	string ToSQL(const string &schema, const string &name) const override;
+
+	static unique_ptr<MacroFunction> Deserialize(FieldReader &reader);
+
+protected:
+	void SerializeInternal(FieldWriter &writer) const override;
 };
 
 } // namespace duckdb