duckdb 0.7.2-dev586.0 → 0.7.2-dev654.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev586.0",
+  "version": "0.7.2-dev654.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/icu/icu-table-range.cpp

@@ -13,13 +13,13 @@ struct ICUTableRange {
 	using CalendarPtr = unique_ptr<icu::Calendar>;
 
 	struct BindData : public TableFunctionData {
-		explicit BindData(const BindData &other)
-		    : tz_setting(other.tz_setting), cal_setting(other.cal_setting), calendar(other.calendar->clone()),
-		      start(other.start), end(other.end), increment(other.increment), inclusive_bound(other.inclusive_bound),
-		      greater_than_check(other.greater_than_check) {
+		BindData(const BindData &other)
+		    : TableFunctionData(other), tz_setting(other.tz_setting), cal_setting(other.cal_setting),
+		      calendar(other.calendar->clone()), start(other.start), end(other.end), increment(other.increment),
+		      inclusive_bound(other.inclusive_bound), greater_than_check(other.greater_than_check) {
 		}
 
-		BindData(ClientContext &context) {
+		explicit BindData(ClientContext &context) {
 			Value tz_value;
 			if (context.TryGetCurrentSetting("TimeZone", tz_value)) {
 				tz_setting = tz_value.ToString();
@@ -54,14 +54,14 @@ struct ICUTableRange {
 		bool inclusive_bound;
 		bool greater_than_check;
 
-		bool Equals(const FunctionData &other_p) const {
+		bool Equals(const FunctionData &other_p) const override {
 			auto &other = (const BindData &)other_p;
 			return other.start == start && other.end == end && other.increment == increment &&
 			       other.inclusive_bound == inclusive_bound && other.greater_than_check == greater_than_check &&
 			       *calendar == *other.calendar;
 		}
 
-		unique_ptr<FunctionData> Copy() const {
+		unique_ptr<FunctionData> Copy() const override {
 			return make_unique<BindData>(*this);
 		}
 

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

@@ -320,7 +320,7 @@ unique_ptr<ColumnReader> ParquetReader::CreateReaderRecursive(const FileMetaData
 			                                     std::move(struct_reader));
 		}
 		if (child_types.size() > 1 || (!is_list && !is_map && !is_repeated)) {
-			result_type = LogicalType::STRUCT(std::move(child_types));
+			result_type = LogicalType::STRUCT(child_types);
 			result = make_unique<StructColumnReader>(*this, result_type, s_ele, this_idx, max_define, max_repeat,
 			                                         std::move(child_readers));
 		} else {

package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -193,14 +193,14 @@ const vector<unique_ptr<Constraint>> &TableCatalogEntry::GetConstraints() {
 }
 
 DataTable &TableCatalogEntry::GetStorage() {
-	throw InternalException("Calling GetStorage on a TableCatalogEntry that is not a DTableCatalogEntry");
+	throw InternalException("Calling GetStorage on a TableCatalogEntry that is not a DuckTableEntry");
 }
 
 DataTable *TableCatalogEntry::GetStoragePtr() {
-	throw InternalException("Calling GetStoragePtr on a TableCatalogEntry that is not a DTableCatalogEntry");
+	throw InternalException("Calling GetStoragePtr on a TableCatalogEntry that is not a DuckTableEntry");
 }
 
 const vector<unique_ptr<BoundConstraint>> &TableCatalogEntry::GetBoundConstraints() {
-	throw InternalException("Calling GetBoundConstraints on a TableCatalogEntry that is not a DTableCatalogEntry");
+	throw InternalException("Calling GetBoundConstraints on a TableCatalogEntry that is not a DuckTableEntry");
 }
 } // namespace duckdb

package/src/duckdb/src/catalog/dependency_list.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/catalog/dependency_list.hpp"
 #include "duckdb/catalog/catalog_entry.hpp"
+#include "duckdb/catalog/catalog.hpp"
 
 namespace duckdb {
 
@@ -10,4 +11,15 @@ void DependencyList::AddDependency(CatalogEntry *entry) {
 	set.insert(entry);
 }
 
+void DependencyList::VerifyDependencies(Catalog *catalog, const string &name) {
+	for (auto &dep : set) {
+		if (dep->catalog != catalog) {
+			throw DependencyException(
+			    "Error adding dependency for object \"%s\" - dependency \"%s\" is in catalog "
+			    "\"%s\", which does not match the catalog \"%s\".\nCross catalog dependencies are not supported.",
+			    name, dep->name, dep->catalog->GetName(), catalog->GetName());
+		}
+	}
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/string_util.cpp

@@ -191,11 +191,14 @@ vector<string> StringUtil::Split(const string &input, const string &split) {
 
 		// Push the substring [last, next) on to splits
 		string substr = input.substr(last, next - last);
-		if (substr.empty() == false) {
+		if (!substr.empty()) {
 			splits.push_back(substr);
 		}
 		last = next + split_len;
 	}
+	if (splits.empty()) {
+		splits.push_back(input);
+	}
 	return splits;
 }
 

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

@@ -20,7 +20,7 @@ const int Blob::HEX_MAP[256] = {
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
 
 bool IsRegularCharacter(data_t c) {
-	return c >= 32 && c <= 127 && c != '\\' && c != '\'' && c != '"';
+	return c >= 32 && c <= 126 && c != '\\' && c != '\'' && c != '"';
 }
 
 idx_t Blob::GetStringSize(string_t blob) {

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

@@ -143,7 +143,7 @@ void ChunkCollection::Fuse(ChunkCollection &other) {
 			auto &rhs = other.GetChunk(chunk_idx);
 			lhs->data.reserve(rhs.data.size());
 			for (auto &v : rhs.data) {
-				lhs->data.emplace_back(Vector(v));
+				lhs->data.emplace_back(v);
 			}
 			lhs->SetCardinality(rhs.size());
 			chunks.push_back(std::move(lhs));
@@ -156,7 +156,7 @@ void ChunkCollection::Fuse(ChunkCollection &other) {
 			auto &rhs = other.GetChunk(chunk_idx);
 			D_ASSERT(lhs.size() == rhs.size());
 			for (auto &v : rhs.data) {
-				lhs.data.emplace_back(Vector(v));
+				lhs.data.emplace_back(v);
 			}
 		}
 	}

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

@@ -62,7 +62,7 @@ void DataChunk::InitializeEmpty(vector<LogicalType>::const_iterator begin, vecto
 	D_ASSERT(data.empty());                   // can only be initialized once
 	D_ASSERT(std::distance(begin, end) != 0); // empty chunk not allowed
 	for (; begin != end; begin++) {
-		data.emplace_back(Vector(*begin, nullptr));
+		data.emplace_back(*begin, nullptr);
 	}
 }
 

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

@@ -604,22 +604,22 @@ Value Value::STRUCT(child_list_t<Value> values) {
 		struct_values.push_back(std::move(child.second));
 	}
 	result.value_info_ = make_shared<NestedValueInfo>(std::move(struct_values));
-	result.type_ = LogicalType::STRUCT(std::move(child_types));
+	result.type_ = LogicalType::STRUCT(child_types);
 	result.is_null = false;
 	return result;
 }
 
-Value Value::MAP(LogicalType child_type, vector<Value> values) {
+Value Value::MAP(const LogicalType &child_type, vector<Value> values) {
 	Value result;
 
-	result.type_ = LogicalType::MAP(std::move(child_type));
+	result.type_ = LogicalType::MAP(child_type);
 	result.is_null = false;
 	result.value_info_ = make_shared<NestedValueInfo>(std::move(values));
 	return result;
 }
 
 Value Value::UNION(child_list_t<LogicalType> members, uint8_t tag, Value value) {
-	D_ASSERT(members.size() > 0);
+	D_ASSERT(!members.empty());
 	D_ASSERT(members.size() <= UnionType::MAX_UNION_MEMBERS);
 	D_ASSERT(members.size() > tag);
 
@@ -660,9 +660,9 @@ Value Value::LIST(vector<Value> values) {
 	return result;
 }
 
-Value Value::LIST(LogicalType child_type, vector<Value> values) {
+Value Value::LIST(const LogicalType &child_type, vector<Value> values) {
 	if (values.empty()) {
-		return Value::EMPTYLIST(std::move(child_type));
+		return Value::EMPTYLIST(child_type);
 	}
 	for (auto &val : values) {
 		val = val.DefaultCastAs(child_type);
@@ -670,9 +670,9 @@ Value Value::LIST(LogicalType child_type, vector<Value> values) {
 	return Value::LIST(std::move(values));
 }
 
-Value Value::EMPTYLIST(LogicalType child_type) {
+Value Value::EMPTYLIST(const LogicalType &child_type) {
 	Value result;
-	result.type_ = LogicalType::LIST(std::move(child_type));
+	result.type_ = LogicalType::LIST(child_type);
 	result.value_info_ = make_shared<NestedValueInfo>();
 	result.is_null = false;
 	return result;

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

@@ -522,7 +522,7 @@ LogicalType GetUserTypeRecursive(const LogicalType &type, ClientContext &context
 		for (auto &child : StructType::GetChildTypes(type)) {
 			children.emplace_back(child.first, GetUserTypeRecursive(child.second, context));
 		}
-		return LogicalType::STRUCT(std::move(children));
+		return LogicalType::STRUCT(children);
 	}
 	if (type.id() == LogicalTypeId::LIST) {
 		return LogicalType::LIST(GetUserTypeRecursive(ListType::GetChildType(type), context));
@@ -773,12 +773,12 @@ LogicalType LogicalType::MaxLogicalType(const LogicalType &left, const LogicalTy
 	if (type_id == LogicalTypeId::LIST) {
 		// list: perform max recursively on child type
 		auto new_child = MaxLogicalType(ListType::GetChildType(left), ListType::GetChildType(right));
-		return LogicalType::LIST(std::move(new_child));
+		return LogicalType::LIST(new_child);
 	}
 	if (type_id == LogicalTypeId::MAP) {
 		// list: perform max recursively on child type
 		auto new_child = MaxLogicalType(ListType::GetChildType(left), ListType::GetChildType(right));
-		return LogicalType::MAP(std::move(new_child));
+		return LogicalType::MAP(new_child);
 	}
 	if (type_id == LogicalTypeId::STRUCT) {
 		// struct: perform recursively
@@ -795,7 +795,7 @@ LogicalType LogicalType::MaxLogicalType(const LogicalType &left, const LogicalTy
 			child_types.emplace_back(left_child_types[i].first, std::move(child_type));
 		}
 
-		return LogicalType::STRUCT(std::move(child_types));
+		return LogicalType::STRUCT(child_types);
 	}
 	if (type_id == LogicalTypeId::UNION) {
 		auto left_member_count = UnionType::GetMemberCount(left);
@@ -1076,8 +1076,8 @@ const LogicalType &ListType::GetChildType(const LogicalType &type) {
 	return ((ListTypeInfo &)*info).child_type;
 }
 
-LogicalType LogicalType::LIST(LogicalType child) {
-	auto info = make_shared<ListTypeInfo>(std::move(child));
+LogicalType LogicalType::LIST(const LogicalType &child) {
+	auto info = make_shared<ListTypeInfo>(child);
 	return LogicalType(LogicalTypeId::LIST, std::move(info));
 }
 
@@ -1207,8 +1207,8 @@ idx_t StructType::GetChildCount(const LogicalType &type) {
 	return StructType::GetChildTypes(type).size();
 }
 
-LogicalType LogicalType::STRUCT(child_list_t<LogicalType> children) {
-	auto info = make_shared<StructTypeInfo>(std::move(children));
+LogicalType LogicalType::STRUCT(const child_list_t<LogicalType> &children) {
+	auto info = make_shared<StructTypeInfo>(children);
 	return LogicalType(LogicalTypeId::STRUCT, std::move(info));
 }
 
@@ -1220,8 +1220,8 @@ LogicalType LogicalType::AGGREGATE_STATE(aggregate_state_t state_type) { // NOLI
 //===--------------------------------------------------------------------===//
 // Map Type
 //===--------------------------------------------------------------------===//
-LogicalType LogicalType::MAP(LogicalType child) {
-	auto info = make_shared<ListTypeInfo>(std::move(child));
+LogicalType LogicalType::MAP(const LogicalType &child) {
+	auto info = make_shared<ListTypeInfo>(child);
 	return LogicalType(LogicalTypeId::MAP, std::move(info));
 }
 
@@ -1229,7 +1229,7 @@ LogicalType LogicalType::MAP(LogicalType key, LogicalType value) {
 	child_list_t<LogicalType> child_types;
 	child_types.emplace_back("key", std::move(key));
 	child_types.emplace_back("value", std::move(value));
-	return LogicalType::MAP(LogicalType::STRUCT(std::move(child_types)));
+	return LogicalType::MAP(LogicalType::STRUCT(child_types));
 }
 
 const LogicalType &MapType::KeyType(const LogicalType &type) {

package/src/duckdb/src/execution/operator/aggregate/physical_window.cpp

@@ -1289,15 +1289,24 @@ void WindowExecutor::Evaluate(idx_t row_idx, DataChunk &input_chunk, Vector &res
 			break;
 		}
 		case ExpressionType::WINDOW_FIRST_VALUE: {
+			//	Same as NTH_VALUE(..., 1)
 			idx_t n = 1;
 			const auto first_idx = FindNextStart(ignore_nulls, bounds.window_start, bounds.window_end, n);
-			CopyCell(payload_collection, 0, first_idx, result, output_offset);
+			if (!n) {
+				CopyCell(payload_collection, 0, first_idx, result, output_offset);
+			} else {
+				FlatVector::SetNull(result, output_offset, true);
+			}
 			break;
 		}
 		case ExpressionType::WINDOW_LAST_VALUE: {
 			idx_t n = 1;
-			CopyCell(payload_collection, 0, FindPrevStart(ignore_nulls, bounds.window_start, bounds.window_end, n),
-			         result, output_offset);
+			const auto last_idx = FindPrevStart(ignore_nulls, bounds.window_start, bounds.window_end, n);
+			if (!n) {
+				CopyCell(payload_collection, 0, last_idx, result, output_offset);
+			} else {
+				FlatVector::SetNull(result, output_offset, true);
+			}
 			break;
 		}
 		case ExpressionType::WINDOW_NTH_VALUE: {
@@ -1550,6 +1559,9 @@ TaskExecutionResult WindowMergeTask::ExecuteTask(TaskExecutionMode mode) {
 	size_t sorted = 0;
 	while (sorted < hash_groups.states.size()) {
 		// First check if there is an unfinished task for this thread
+		if (executor.HasError()) {
+			return TaskExecutionResult::TASK_ERROR;
+		}
 		if (!local_state.TaskFinished()) {
 			local_state.ExecuteTask();
 			continue;

package/src/duckdb/src/execution/operator/helper/physical_vacuum.cpp

@@ -49,6 +49,9 @@ SinkResultType PhysicalVacuum::Sink(ExecutionContext &context, GlobalSinkState &
 	D_ASSERT(lstate.column_distinct_stats.size() == info->column_id_map.size());
 
 	for (idx_t col_idx = 0; col_idx < input.data.size(); col_idx++) {
+		if (!DistinctStatistics::TypeIsSupported(input.data[col_idx].GetType())) {
+			continue;
+		}
 		lstate.column_distinct_stats[col_idx]->Update(input.data[col_idx], input.size(), false);
 	}
 

package/src/duckdb/src/execution/operator/join/physical_iejoin.cpp

@@ -386,7 +386,7 @@ IEJoinUnion::IEJoinUnion(ClientContext &context, const PhysicalIEJoin &op, Sorte
 	// Sort on the first expression
 	auto ref = make_unique<BoundReferenceExpression>(order1.expression->return_type, 0);
 	vector<BoundOrderByNode> orders;
-	orders.emplace_back(BoundOrderByNode(order1.type, order1.null_order, std::move(ref)));
+	orders.emplace_back(order1.type, order1.null_order, std::move(ref));
 
 	l1 = make_unique<SortedTable>(context, orders, payload_layout);
 
@@ -422,7 +422,7 @@ IEJoinUnion::IEJoinUnion(ClientContext &context, const PhysicalIEJoin &op, Sorte
 	// Sort on the first expression
 	orders.clear();
 	ref = make_unique<BoundReferenceExpression>(order2.expression->return_type, 0);
-	orders.emplace_back(BoundOrderByNode(order2.type, order2.null_order, std::move(ref)));
+	orders.emplace_back(order2.type, order2.null_order, std::move(ref));
 
 	ExpressionExecutor executor(context);
 	executor.AddExpression(*orders[0].expression);

package/src/duckdb/src/execution/operator/join/physical_piecewise_merge_join.cpp

@@ -30,25 +30,20 @@ PhysicalPiecewiseMergeJoin::PhysicalPiecewiseMergeJoin(LogicalOperator &op, uniq
 		switch (cond.comparison) {
 		case ExpressionType::COMPARE_LESSTHAN:
 		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			lhs_orders.emplace_back(
-			    BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(left)));
-			rhs_orders.emplace_back(
-			    BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(right)));
+			lhs_orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(left));
+			rhs_orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(right));
 			break;
 		case ExpressionType::COMPARE_GREATERTHAN:
 		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			lhs_orders.emplace_back(
-			    BoundOrderByNode(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, std::move(left)));
-			rhs_orders.emplace_back(
-			    BoundOrderByNode(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, std::move(right)));
+			lhs_orders.emplace_back(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, std::move(left));
+			rhs_orders.emplace_back(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, std::move(right));
 			break;
 		case ExpressionType::COMPARE_NOTEQUAL:
 		case ExpressionType::COMPARE_DISTINCT_FROM:
 			// Allowed in multi-predicate joins, but can't be first/sort.
 			D_ASSERT(!lhs_orders.empty());
-			lhs_orders.emplace_back(BoundOrderByNode(OrderType::INVALID, OrderByNullType::NULLS_LAST, std::move(left)));
-			rhs_orders.emplace_back(
-			    BoundOrderByNode(OrderType::INVALID, OrderByNullType::NULLS_LAST, std::move(right)));
+			lhs_orders.emplace_back(OrderType::INVALID, OrderByNullType::NULLS_LAST, std::move(left));
+			rhs_orders.emplace_back(OrderType::INVALID, OrderByNullType::NULLS_LAST, std::move(right));
 			break;
 
 		default:

package/src/duckdb/src/execution/operator/join/physical_range_join.cpp

@@ -46,7 +46,7 @@ void PhysicalRangeJoin::LocalSortedTable::Sink(DataChunk &input, GlobalSortState
 
 	//	Only sort the primary key
 	DataChunk join_head;
-	join_head.data.emplace_back(Vector(keys.data[0]));
+	join_head.data.emplace_back(keys.data[0]);
 	join_head.SetCardinality(keys.size());
 
 	// Sink the data into the local sort state

package/src/duckdb/src/execution/operator/persistent/physical_copy_to_file.cpp

@@ -85,8 +85,8 @@ static string CreateDirRecursive(const vector<idx_t> &cols, const vector<string>
 	CreateDir(path, fs);
 
 	for (idx_t i = 0; i < cols.size(); i++) {
-		auto partition_col_name = names[cols[i]];
-		auto partition_value = values[i];
+		const auto &partition_col_name = names[cols[i]];
+		const auto &partition_value = values[i];
 		string p_dir = partition_col_name + "=" + partition_value.ToString();
 		path = fs.JoinPath(path, p_dir);
 		CreateDir(path, fs);

package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp

@@ -154,6 +154,9 @@ static void CanUseIndexJoin(TableScanBindData *tbl, Expression &expr, Index **re
 
 void TransformIndexJoin(ClientContext &context, LogicalComparisonJoin &op, Index **left_index, Index **right_index,
                         PhysicalOperator *left, PhysicalOperator *right) {
+	if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
+		return;
+	}
 	// check if one of the tables has an index on column
 	if (op.join_type == JoinType::INNER && op.conditions.size() == 1) {
 		// check if one of the children are table scans and if they have an index in the join attribute

package/src/duckdb/src/function/aggregate/distributive/bitstring_agg.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/storage/statistics/base_statistics.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/common/types/cast_helpers.hpp"
+#include "duckdb/common/operator/subtract.hpp"
 
 namespace duckdb {
 
@@ -93,7 +94,16 @@ struct BitStringAggOperation {
 
 	template <class INPUT_TYPE>
 	static idx_t GetRange(INPUT_TYPE min, INPUT_TYPE max) {
-		return max - min + 1;
+		D_ASSERT(max >= min);
+		INPUT_TYPE result;
+		if (!TrySubtractOperator::Operation(max, min, result)) {
+			return NumericLimits<idx_t>::Maximum();
+		}
+		idx_t val(result);
+		if (val == NumericLimits<idx_t>::Maximum()) {
+			return val;
+		}
+		return val + 1;
 	}
 
 	template <class INPUT_TYPE, class STATE>
@@ -162,12 +172,15 @@ void BitStringAggOperation::Execute(BitAggState<hugeint_t> *state, hugeint_t inp
 
 template <>
 idx_t BitStringAggOperation::GetRange(hugeint_t min, hugeint_t max) {
-	idx_t val;
-	if (Hugeint::TryCast(max - min + 1, val)) {
-		return val;
-	} else {
-		throw OutOfRangeException("Range too large for bitstring aggregation");
+	hugeint_t result;
+	if (!TrySubtractOperator::Operation(max, min, result)) {
+		return NumericLimits<idx_t>::Maximum();
+	}
+	idx_t range;
+	if (!Hugeint::TryCast(result + 1, range)) {
+		return NumericLimits<idx_t>::Maximum();
 	}
+	return range;
 }
 
 unique_ptr<BaseStatistics> BitstringPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
@@ -185,8 +198,10 @@ unique_ptr<BaseStatistics> BitstringPropagateStats(ClientContext &context, Bound
 
 unique_ptr<FunctionData> BindBitstringAgg(ClientContext &context, AggregateFunction &function,
                                           vector<unique_ptr<Expression>> &arguments) {
-
 	if (arguments.size() == 3) {
+		if (!arguments[1]->IsFoldable() && !arguments[2]->IsFoldable()) {
+			throw BinderException("bitstring_agg requires a constant min and max argument");
+		}
 		auto min = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
 		auto max = ExpressionExecutor::EvaluateScalar(context, *arguments[2]);
 		Function::EraseArgument(function, arguments, 2);

package/src/duckdb/src/function/aggregate/distributive/first.cpp

@@ -79,6 +79,7 @@ struct FirstFunctionString : public FirstFunctionBase {
 			}
 		} else {
 			state->is_set = true;
+			state->is_null = false;
 			if (value.IsInlined()) {
 				state->value = value;
 			} else {

package/src/duckdb/src/function/aggregate/holistic/approximate_quantile.cpp

@@ -70,11 +70,14 @@ struct ApproxQuantileOperation {
 
 	template <class INPUT_TYPE, class STATE, class OP>
 	static void Operation(STATE *state, AggregateInputData &, INPUT_TYPE *data, ValidityMask &mask, idx_t idx) {
+		auto val = Cast::template Operation<INPUT_TYPE, SAVE_TYPE>(data[idx]);
+		if (!Value::DoubleIsFinite(val)) {
+			return;
+		}
 		if (!state->h) {
 			state->h = new duckdb_tdigest::TDigest(100);
 		}
-
-		state->h->add(Cast::template Operation<INPUT_TYPE, SAVE_TYPE>(data[idx]));
+		state->h->add(val);
 		state->pos++;
 	}
 

package/src/duckdb/src/function/aggregate/holistic/quantile.cpp

@@ -414,7 +414,7 @@ struct QuantileBindData : public FunctionData {
 		size_t pos = 0;
 		size_t neg = 0;
 		for (idx_t i = 0; i < quantiles_p.size(); ++i) {
-			const auto q = quantiles_p[i];
+			const auto &q = quantiles_p[i];
 			pos += (q > 0);
 			neg += (q < 0);
 			quantiles.emplace_back(QuantileAbs(q));

package/src/duckdb/src/function/aggregate/nested/list.cpp

@@ -723,9 +723,9 @@ static void GetSegmentDataFunctions(WriteDataToSegment &write_data_to_segment,
 		read_data_from_segment.segment_function = ReadDataFromVarcharSegment;
 		copy_data_from_segment.segment_function = CopyDataFromListSegment;
 
-		write_data_to_segment.child_functions.emplace_back(WriteDataToSegment());
+		write_data_to_segment.child_functions.emplace_back();
 		write_data_to_segment.child_functions.back().create_segment = CreatePrimitiveSegment<char>;
-		copy_data_from_segment.child_functions.emplace_back(CopyDataFromSegment());
+		copy_data_from_segment.child_functions.emplace_back();
 		copy_data_from_segment.child_functions.back().segment_function = CopyDataFromPrimitiveSegment<char>;
 		break;
 	}
@@ -736,9 +736,9 @@ static void GetSegmentDataFunctions(WriteDataToSegment &write_data_to_segment,
 		copy_data_from_segment.segment_function = CopyDataFromListSegment;
 
 		// recurse
-		write_data_to_segment.child_functions.emplace_back(WriteDataToSegment());
-		read_data_from_segment.child_functions.emplace_back(ReadDataFromSegment());
-		copy_data_from_segment.child_functions.emplace_back(CopyDataFromSegment());
+		write_data_to_segment.child_functions.emplace_back();
+		read_data_from_segment.child_functions.emplace_back();
+		copy_data_from_segment.child_functions.emplace_back();
 		GetSegmentDataFunctions(write_data_to_segment.child_functions.back(),
 		                        read_data_from_segment.child_functions.back(),
 		                        copy_data_from_segment.child_functions.back(), ListType::GetChildType(type));
@@ -753,9 +753,9 @@ static void GetSegmentDataFunctions(WriteDataToSegment &write_data_to_segment,
 		// recurse
 		auto child_types = StructType::GetChildTypes(type);
 		for (idx_t i = 0; i < child_types.size(); i++) {
-			write_data_to_segment.child_functions.emplace_back(WriteDataToSegment());
-			read_data_from_segment.child_functions.emplace_back(ReadDataFromSegment());
-			copy_data_from_segment.child_functions.emplace_back(CopyDataFromSegment());
+			write_data_to_segment.child_functions.emplace_back();
+			read_data_from_segment.child_functions.emplace_back();
+			copy_data_from_segment.child_functions.emplace_back();
 			GetSegmentDataFunctions(write_data_to_segment.child_functions.back(),
 			                        read_data_from_segment.child_functions.back(),
 			                        copy_data_from_segment.child_functions.back(), child_types[i].second);

package/src/duckdb/src/function/cast/struct_cast.cpp

@@ -129,7 +129,7 @@ BoundCastInfo DefaultCasts::StructCastSwitch(BindCastInput &input, const Logical
 		for (auto &child_entry : struct_children) {
 			varchar_children.push_back(make_pair(child_entry.first, LogicalType::VARCHAR));
 		}
-		auto varchar_type = LogicalType::STRUCT(std::move(varchar_children));
+		auto varchar_type = LogicalType::STRUCT(varchar_children);
 		return BoundCastInfo(StructToVarcharCast,
 		                     StructBoundCastData::BindStructToStructCast(input, source, varchar_type));
 	}

package/src/duckdb/src/function/scalar/date/date_part.cpp

@@ -1332,7 +1332,7 @@ struct StructDatePart {
 		}
 
 		Function::EraseArgument(bound_function, arguments, 0);
-		bound_function.return_type = LogicalType::STRUCT(std::move(struct_children));
+		bound_function.return_type = LogicalType::STRUCT(struct_children);
 		return make_unique<BindData>(bound_function.return_type, part_codes);
 	}
 

package/src/duckdb/src/function/scalar/list/list_concat.cpp

@@ -82,9 +82,10 @@ static unique_ptr<FunctionData> ListConcatBind(ClientContext &context, ScalarFun
 		throw ParameterNotResolvedException();
 	} else if (lhs.id() == LogicalTypeId::SQLNULL || rhs.id() == LogicalTypeId::SQLNULL) {
 		// we mimic postgres behaviour: list_concat(NULL, my_list) = my_list
-		bound_function.arguments[0] = lhs;
-		bound_function.arguments[1] = rhs;
-		bound_function.return_type = rhs.id() == LogicalTypeId::SQLNULL ? lhs : rhs;
+		auto return_type = rhs.id() == LogicalTypeId::SQLNULL ? lhs : rhs;
+		bound_function.arguments[0] = return_type;
+		bound_function.arguments[1] = return_type;
+		bound_function.return_type = return_type;
 	} else {
 		D_ASSERT(lhs.id() == LogicalTypeId::LIST);
 		D_ASSERT(rhs.id() == LogicalTypeId::LIST);
@@ -94,7 +95,7 @@ static unique_ptr<FunctionData> ListConcatBind(ClientContext &context, ScalarFun
 		for (const auto &argument : arguments) {
 			child_type = LogicalType::MaxLogicalType(child_type, ListType::GetChildType(argument->return_type));
 		}
-		auto list_type = LogicalType::LIST(std::move(child_type));
+		auto list_type = LogicalType::LIST(child_type);
 
 		bound_function.arguments[0] = list_type;
 		bound_function.arguments[1] = list_type;

package/src/duckdb/src/function/scalar/list/list_lambdas.cpp

@@ -124,7 +124,7 @@ static void ExecuteExpression(vector<LogicalType> &types, vector<LogicalType> &r
 	// set the other vectors
 	vector<Vector> slices;
 	for (idx_t col_idx = 0; col_idx < args.ColumnCount() - 1; col_idx++) {
-		slices.emplace_back(Vector(args.data[col_idx + 1], sel_vectors[col_idx], elem_cnt));
+		slices.emplace_back(args.data[col_idx + 1], sel_vectors[col_idx], elem_cnt);
 		slices[col_idx].Flatten(elem_cnt);
 		input_chunk.data[col_idx + 2].Reference(slices[col_idx]);
 	}
@@ -195,10 +195,10 @@ static void ListLambdaFunction(DataChunk &args, ExpressionState &state, Vector &
 
 	// skip the list column
 	for (idx_t i = 1; i < args.ColumnCount(); i++) {
-		columns.emplace_back(UnifiedVectorFormat());
+		columns.emplace_back();
 		args.data[i].ToUnifiedFormat(count, columns[i - 1]);
 		indexes.push_back(0);
-		sel_vectors.emplace_back(SelectionVector(STANDARD_VECTOR_SIZE));
+		sel_vectors.emplace_back(STANDARD_VECTOR_SIZE);
 		types.push_back(args.data[i].GetType());
 	}
 

package/src/duckdb/src/function/scalar/list/list_value.cpp

@@ -42,7 +42,7 @@ static unique_ptr<FunctionData> ListValueBind(ClientContext &context, ScalarFunc
 
 	// this is more for completeness reasons
 	bound_function.varargs = child_type;
-	bound_function.return_type = LogicalType::LIST(std::move(child_type));
+	bound_function.return_type = LogicalType::LIST(child_type);
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 

package/src/duckdb/src/function/scalar/map/map_entries.cpp

@@ -44,7 +44,7 @@ static unique_ptr<FunctionData> MapEntriesBind(ClientContext &context, ScalarFun
 	child_types.push_back(make_pair("k", key_type));
 	child_types.push_back(make_pair("v", value_type));
 
-	auto row_type = LogicalType::STRUCT(std::move(child_types));
+	auto row_type = LogicalType::STRUCT(child_types);
 
 	bound_function.return_type = LogicalType::LIST(row_type);
 	return make_unique<VariableReturnBindData>(bound_function.return_type);