duckdb 0.7.2-dev3546.0 → 0.7.2-dev3710.0

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

@@ -15,6 +15,7 @@
 #include <cstring>
 
 namespace duckdb {
+
 /**
  * String Utility Functions
  * Note that these are not the most efficient implementations (i.e., they copy
@@ -45,25 +46,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) {
@@ -85,6 +86,23 @@ public:
 		return false;
 	}
 
+	template <class TO>
+	static vector<TO> ConvertStrings(const vector<string> &strings) {
+		vector<TO> result;
+		for (auto &string : strings) {
+			result.emplace_back(string);
+		}
+		return result;
+	}
+
+	static vector<SQLIdentifier> ConvertToSQLIdentifiers(const vector<string> &strings) {
+		return ConvertStrings<SQLIdentifier>(strings);
+	}
+
+	static vector<SQLString> ConvertToSQLStrings(const vector<string> &strings) {
+		return ConvertStrings<SQLString>(strings);
+	}
+
 	//! Returns true if the needle string exists in the haystack
 	DUCKDB_API static bool Contains(const string &haystack, const string &needle);
 
@@ -200,7 +218,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.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, {}}};

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/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;
 	}