duckdb 0.7.2-dev1034.0 → 0.7.2-dev1146.0

package/src/duckdb/extension/parquet/parquet-extension.cpp

@@ -122,7 +122,8 @@ struct ParquetWriteGlobalState : public GlobalFunctionData {
 };
 
 struct ParquetWriteLocalState : public LocalFunctionData {
-	explicit ParquetWriteLocalState(ClientContext &context, const vector<LogicalType> &types) : buffer(context, types) {
+	explicit ParquetWriteLocalState(ClientContext &context, const vector<LogicalType> &types)
+	    : buffer(Allocator::Get(context), types) {
 	}
 
 	ColumnDataCollection buffer;

package/src/duckdb/src/common/hive_partitioning.cpp

@@ -1,9 +1,11 @@
 #include "duckdb/common/hive_partitioning.hpp"
-#include "duckdb/optimizer/statistics_propagator.hpp"
 #include "duckdb/planner/table_filter.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/optimizer/filter_combiner.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "re2/re2.h"
 
 namespace duckdb {

package/src/duckdb/src/common/progress_bar/progress_bar.cpp

@@ -4,6 +4,13 @@
 
 namespace duckdb {
 
+void ProgressBar::SystemOverrideCheck(ClientConfig &config) {
+	if (config.system_progress_bar_disable_reason != nullptr) {
+		throw InvalidInputException("Could not change the progress bar setting because: '%s'",
+		                            config.system_progress_bar_disable_reason);
+	}
+}
+
 unique_ptr<ProgressBarDisplay> ProgressBar::DefaultProgressBarDisplay() {
 	return make_unique<TerminalProgressBarDisplay>();
 }

package/src/duckdb/src/common/serializer/enum_serializer.cpp

@@ -24,11 +24,11 @@ template <>
 OrderType EnumSerializer::StringToEnum(const char *value) {
 	if (StringUtil::Equals(value, "INVALID")) {
 		return OrderType::INVALID;
-	} else if (StringUtil::Equals(value, "ORDER_DEFAULT")) {
+	} else if (StringUtil::Equals(value, "ORDER_DEFAULT") || StringUtil::Equals(value, "DEFAULT")) {
 		return OrderType::ORDER_DEFAULT;
-	} else if (StringUtil::Equals(value, "ASCENDING")) {
+	} else if (StringUtil::Equals(value, "ASCENDING") || StringUtil::Equals(value, "ASC")) {
 		return OrderType::ASCENDING;
-	} else if (StringUtil::Equals(value, "DESCENDING")) {
+	} else if (StringUtil::Equals(value, "DESCENDING") || StringUtil::Equals(value, "DESC")) {
 		return OrderType::DESCENDING;
 	} else {
 		throw NotImplementedException("FromString not implemented for enum value");
@@ -58,11 +58,11 @@ template <>
 OrderByNullType EnumSerializer::StringToEnum(const char *value) {
 	if (StringUtil::Equals(value, "INVALID")) {
 		return OrderByNullType::INVALID;
-	} else if (StringUtil::Equals(value, "ORDER_DEFAULT")) {
+	} else if (StringUtil::Equals(value, "ORDER_DEFAULT") || StringUtil::Equals(value, "DEFAULT")) {
 		return OrderByNullType::ORDER_DEFAULT;
-	} else if (StringUtil::Equals(value, "NULLS_FIRST")) {
+	} else if (StringUtil::Equals(value, "NULLS_FIRST") || StringUtil::Equals(value, "NULLS FIRST")) {
 		return OrderByNullType::NULLS_FIRST;
-	} else if (StringUtil::Equals(value, "NULLS_LAST")) {
+	} else if (StringUtil::Equals(value, "NULLS_LAST") || StringUtil::Equals(value, "NULLS LAST")) {
 		return OrderByNullType::NULLS_LAST;
 	} else {
 		throw NotImplementedException("FromString not implemented for enum value");

package/src/duckdb/src/common/sort/comparators.cpp

@@ -163,17 +163,26 @@ int Comparators::CompareStringAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right
 	if (!valid) {
 		return 0;
 	}
-	// Construct the string_t
 	uint32_t left_string_size = Load<uint32_t>(left_ptr);
 	uint32_t right_string_size = Load<uint32_t>(right_ptr);
 	left_ptr += sizeof(uint32_t);
 	right_ptr += sizeof(uint32_t);
-	string_t left_val((const char *)left_ptr, left_string_size);
-	string_t right_val((const char *)right_ptr, right_string_size);
+	auto memcmp_res = memcmp((const char *)left_ptr, (const char *)right_ptr,
+	                         std::min<uint32_t>(left_string_size, right_string_size));
+
 	left_ptr += left_string_size;
 	right_ptr += right_string_size;
-	// Compare
-	return TemplatedCompareVal<string_t>((data_ptr_t)&left_val, (data_ptr_t)&right_val);
+
+	if (memcmp_res != 0) {
+		return memcmp_res;
+	}
+	if (left_string_size == right_string_size) {
+		return 0;
+	}
+	if (left_string_size < right_string_size) {
+		return -1;
+	}
+	return 1;
 }
 
 int Comparators::CompareStructAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr,

package/src/duckdb/src/common/types/column_data_collection_segment.cpp

@@ -169,11 +169,8 @@ idx_t ColumnDataCollectionSegment::ReadVectorInternal(ChunkManagementState &stat
 		if (type_size > 0) {
 			memcpy(target_data + current_offset * type_size, base_ptr, current_vdata.count * type_size);
 		}
-		// FIXME: use bitwise operations here
 		ValidityMask current_validity(validity_data);
-		for (idx_t k = 0; k < current_vdata.count; k++) {
-			target_validity.Set(current_offset + k, current_validity.RowIsValid(k));
-		}
+		target_validity.SliceInPlace(current_validity, current_offset, 0, current_vdata.count);
 		current_offset += current_vdata.count;
 		next_index = current_vdata.next_data;
 	}

package/src/duckdb/src/common/types/interval.cpp

@@ -397,47 +397,6 @@ interval_t Interval::FromMicro(int64_t delta_us) {
 	return result;
 }
 
-static void NormalizeIntervalEntries(interval_t input, int64_t &months, int64_t &days, int64_t &micros) {
-	int64_t extra_months_d = input.days / Interval::DAYS_PER_MONTH;
-	int64_t extra_months_micros = input.micros / Interval::MICROS_PER_MONTH;
-	input.days -= extra_months_d * Interval::DAYS_PER_MONTH;
-	input.micros -= extra_months_micros * Interval::MICROS_PER_MONTH;
-
-	int64_t extra_days_micros = input.micros / Interval::MICROS_PER_DAY;
-	input.micros -= extra_days_micros * Interval::MICROS_PER_DAY;
-
-	months = input.months + extra_months_d + extra_months_micros;
-	days = input.days + extra_days_micros;
-	micros = input.micros;
-}
-
-bool Interval::Equals(interval_t left, interval_t right) {
-	return left.months == right.months && left.days == right.days && left.micros == right.micros;
-}
-
-bool Interval::GreaterThan(interval_t left, interval_t right) {
-	int64_t lmonths, ldays, lmicros;
-	int64_t rmonths, rdays, rmicros;
-	NormalizeIntervalEntries(left, lmonths, ldays, lmicros);
-	NormalizeIntervalEntries(right, rmonths, rdays, rmicros);
-
-	if (lmonths > rmonths) {
-		return true;
-	} else if (lmonths < rmonths) {
-		return false;
-	}
-	if (ldays > rdays) {
-		return true;
-	} else if (ldays < rdays) {
-		return false;
-	}
-	return lmicros > rmicros;
-}
-
-bool Interval::GreaterThanEquals(interval_t left, interval_t right) {
-	return GreaterThan(left, right) || Equals(left, right);
-}
-
 interval_t Interval::Invert(interval_t interval) {
 	interval.days = -interval.days;
 	interval.micros = -interval.micros;