duckdb 0.3.3-dev1321.0 → 0.3.3-dev1371.0

package/src/duckdb.cpp

@@ -4681,7 +4681,44 @@ static DefaultMacro internal_macros[] = {
 	{DEFAULT_SCHEMA, "generate_subscripts", {"arr", "dim", nullptr}, "unnest(generate_series(1, array_length(arr, dim)))"},
 	{DEFAULT_SCHEMA, "fdiv", {"x", "y", nullptr}, "floor(x/y)"},
 	{DEFAULT_SCHEMA, "fmod", {"x", "y", nullptr}, "(x-y*floor(x/y))"},
-	{nullptr, nullptr, {nullptr}, nullptr}};
+
+	// algebraic list aggregates
+	{DEFAULT_SCHEMA, "list_avg", {"l", nullptr}, "list_aggr(l, 'avg')"},
+	{DEFAULT_SCHEMA, "list_var_samp", {"l", nullptr}, "list_aggr(l, 'var_samp')"},
+	{DEFAULT_SCHEMA, "list_var_pop", {"l", nullptr}, "list_aggr(l, 'var_pop')"},
+	{DEFAULT_SCHEMA, "list_stddev_pop", {"l", nullptr}, "list_aggr(l, 'stddev_pop')"},
+	{DEFAULT_SCHEMA, "list_stddev_samp", {"l", nullptr}, "list_aggr(l, 'stddev_samp')"},
+	{DEFAULT_SCHEMA, "list_sem", {"l", nullptr}, "list_aggr(l, 'sem')"},
+
+	// distributive list aggregates
+	{DEFAULT_SCHEMA, "list_approx_count_distinct", {"l", nullptr}, "list_aggr(l, 'approx_count_distinct')"},
+	{DEFAULT_SCHEMA, "list_bit_xor", {"l", nullptr}, "list_aggr(l, 'bit_xor')"},
+	{DEFAULT_SCHEMA, "list_bit_or", {"l", nullptr}, "list_aggr(l, 'bit_or')"},
+	{DEFAULT_SCHEMA, "list_bit_and", {"l", nullptr}, "list_aggr(l, 'bit_and')"},
+	{DEFAULT_SCHEMA, "list_bool_and", {"l", nullptr}, "list_aggr(l, 'bool_and')"},
+	{DEFAULT_SCHEMA, "list_bool_or", {"l", nullptr}, "list_aggr(l, 'bool_or')"},
+	{DEFAULT_SCHEMA, "list_count", {"l", nullptr}, "list_aggr(l, 'count')"},
+	{DEFAULT_SCHEMA, "list_entropy", {"l", nullptr}, "list_aggr(l, 'entropy')"},
+	{DEFAULT_SCHEMA, "list_last", {"l", nullptr}, "list_aggr(l, 'last')"},
+	{DEFAULT_SCHEMA, "list_first", {"l", nullptr}, "list_aggr(l, 'first')"},
+	{DEFAULT_SCHEMA, "list_kurtosis", {"l", nullptr}, "list_aggr(l, 'kurtosis')"},
+	{DEFAULT_SCHEMA, "list_min", {"l", nullptr}, "list_aggr(l, 'min')"},
+	{DEFAULT_SCHEMA, "list_max", {"l", nullptr}, "list_aggr(l, 'max')"},
+	{DEFAULT_SCHEMA, "list_product", {"l", nullptr}, "list_aggr(l, 'product')"},
+	{DEFAULT_SCHEMA, "list_skewness", {"l", nullptr}, "list_aggr(l, 'skewness')"},
+	{DEFAULT_SCHEMA, "list_sum", {"l", nullptr}, "list_aggr(l, 'sum')"},
+	{DEFAULT_SCHEMA, "list_string_agg", {"l", nullptr}, "list_aggr(l, 'string_agg')"},
+
+	// holistic list aggregates
+	{DEFAULT_SCHEMA, "list_mode", {"l", nullptr}, "list_aggr(l, 'mode')"},
+	{DEFAULT_SCHEMA, "list_median", {"l", nullptr}, "list_aggr(l, 'median')"},
+	{DEFAULT_SCHEMA, "list_mad", {"l", nullptr}, "list_aggr(l, 'mad')"},
+
+	// nested list aggregates
+	{DEFAULT_SCHEMA, "list_histogram", {"l", nullptr}, "list_aggr(l, 'histogram')"},
+
+	{nullptr, nullptr, {nullptr}, nullptr}
+	};
 
 unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalMacroInfo(DefaultMacro &default_macro) {
 	// parse the expression
@@ -26480,6 +26517,7 @@ static void TemplatedMatch(DataChunk &columns, VectorData col_data[], const RowL
 		switch (predicates[col_no]) {
 		case ExpressionType::COMPARE_EQUAL:
 		case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
+		case ExpressionType::COMPARE_DISTINCT_FROM:
 			TemplatedMatchOp<Equals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
 			                                       no_match_count);
 			break;
@@ -47487,7 +47525,7 @@ namespace duckdb {
 //! JoinCondition represents a left-right comparison join condition
 struct JoinCondition {
 public:
-	JoinCondition() : null_values_are_equal(false) {
+	JoinCondition() {
 	}
 
 	//! Turns the JoinCondition into an expression; note that this destroys the JoinCondition as the expression inherits
@@ -47498,17 +47536,14 @@ public:
 	unique_ptr<Expression> left;
 	unique_ptr<Expression> right;
 	ExpressionType comparison;
-	//! NULL values are equal for just THIS JoinCondition (instead of the entire join).
-	//! This is only supported by the HashJoin and can only be used in equality comparisons.
-	bool null_values_are_equal = false;
 };
 
 class JoinSide {
 public:
-	enum join_value : uint8_t { NONE, LEFT, RIGHT, BOTH };
+	enum JoinValue : uint8_t { NONE, LEFT, RIGHT, BOTH };
 
 	JoinSide() = default;
-	constexpr JoinSide(join_value val) : value(val) { // NOLINT: Allow implicit conversion from `join_value`
+	constexpr JoinSide(JoinValue val) : value(val) { // NOLINT: Allow implicit conversion from `join_value`
 	}
 
 	bool operator==(JoinSide a) const {
@@ -47527,7 +47562,7 @@ public:
 	                            unordered_set<idx_t> &right_bindings);
 
 private:
-	join_value value;
+	JoinValue value;
 };
 
 } // namespace duckdb
@@ -50935,7 +50970,8 @@ JoinHashTable::JoinHashTable(BufferManager &buffer_manager, const vector<JoinCon
 		D_ASSERT(condition.left->return_type == condition.right->return_type);
 		auto type = condition.left->return_type;
 		if (condition.comparison == ExpressionType::COMPARE_EQUAL ||
-		    condition.comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
+		    condition.comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM ||
+		    condition.comparison == ExpressionType::COMPARE_DISTINCT_FROM) {
 			// all equality conditions should be at the front
 			// all other conditions at the back
 			// this assert checks that
@@ -50944,10 +50980,8 @@ JoinHashTable::JoinHashTable(BufferManager &buffer_manager, const vector<JoinCon
 		}
 
 		predicates.push_back(condition.comparison);
-		null_values_are_equal.push_back(condition.null_values_are_equal ||
+		null_values_are_equal.push_back(condition.comparison == ExpressionType::COMPARE_DISTINCT_FROM ||
 		                                condition.comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM);
-		D_ASSERT(!condition.null_values_are_equal ||
-		         (condition.null_values_are_equal && condition.comparison == ExpressionType::COMPARE_EQUAL));
 
 		condition_types.push_back(type);
 	}
@@ -68019,7 +68053,7 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 	}
 	// with equality condition and null values not equal
 	for (auto &&condition : op.conditions) {
-		if (condition.comparison != ExpressionType::COMPARE_EQUAL || condition.null_values_are_equal) {
+		if (condition.comparison != ExpressionType::COMPARE_EQUAL) {
 			return;
 		}
 	}
@@ -68140,10 +68174,6 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalComparison
 		default:
 			throw NotImplementedException("Unimplemented comparison join");
 		}
-		if (cond.null_values_are_equal) {
-			D_ASSERT(cond.comparison == ExpressionType::COMPARE_EQUAL ||
-			         cond.comparison == ExpressionType::COMPARE_DISTINCT_FROM);
-		}
 	}
 
 	unique_ptr<PhysicalOperator> plan;
@@ -70555,10 +70585,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSetOperati
 		// create equality condition for all columns
 		for (idx_t i = 0; i < types.size(); i++) {
 			JoinCondition cond;
-			cond.comparison = ExpressionType::COMPARE_EQUAL;
 			cond.left = make_unique<BoundReferenceExpression>(types[i], i);
 			cond.right = make_unique<BoundReferenceExpression>(types[i], i);
-			cond.null_values_are_equal = true;
+			cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
 			conditions.push_back(move(cond));
 		}
 		// EXCEPT is ANTI join
@@ -72448,22 +72477,22 @@ AggregateFunction GetAverageAggregate(PhysicalType type) {
 	switch (type) {
 	case PhysicalType::INT16:
 		return AggregateFunction::UnaryAggregate<AvgState<int64_t>, int16_t, double, IntegerAverageOperation>(
-		    LogicalType::SMALLINT, LogicalType::DOUBLE);
+		    LogicalType::SMALLINT, LogicalType::DOUBLE, true);
 	case PhysicalType::INT32: {
 		auto function =
 		    AggregateFunction::UnaryAggregate<AvgState<hugeint_t>, int32_t, double, IntegerAverageOperationHugeint>(
-		        LogicalType::INTEGER, LogicalType::DOUBLE);
+		        LogicalType::INTEGER, LogicalType::DOUBLE, true);
 		return function;
 	}
 	case PhysicalType::INT64: {
 		auto function =
 		    AggregateFunction::UnaryAggregate<AvgState<hugeint_t>, int64_t, double, IntegerAverageOperationHugeint>(
-		        LogicalType::BIGINT, LogicalType::DOUBLE);
+		        LogicalType::BIGINT, LogicalType::DOUBLE, true);
 		return function;
 	}
 	case PhysicalType::INT128:
 		return AggregateFunction::UnaryAggregate<AvgState<hugeint_t>, hugeint_t, double, HugeintAverageOperation>(
-		    LogicalType::HUGEINT, LogicalType::DOUBLE);
+		    LogicalType::HUGEINT, LogicalType::DOUBLE, true);
 	default:
 		throw InternalException("Unimplemented average aggregate");
 	}
@@ -72483,18 +72512,18 @@ unique_ptr<FunctionData> BindDecimalAvg(ClientContext &context, AggregateFunctio
 void AvgFun::RegisterFunction(BuiltinFunctions &set) {
 	AggregateFunctionSet avg("avg");
 	avg.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
-	                                  nullptr, nullptr, nullptr, BindDecimalAvg));
+	                                  nullptr, nullptr, true, nullptr, BindDecimalAvg));
 	avg.AddFunction(GetAverageAggregate(PhysicalType::INT16));
 	avg.AddFunction(GetAverageAggregate(PhysicalType::INT32));
 	avg.AddFunction(GetAverageAggregate(PhysicalType::INT64));
 	avg.AddFunction(GetAverageAggregate(PhysicalType::INT128));
 	avg.AddFunction(AggregateFunction::UnaryAggregate<AvgState<double>, double, double, NumericAverageOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
+	    LogicalType::DOUBLE, LogicalType::DOUBLE, true));
 	set.AddFunction(avg);
 
 	AggregateFunctionSet favg("favg");
 	favg.AddFunction(AggregateFunction::UnaryAggregate<KahanAvgState, double, double, KahanAverageOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
+	    LogicalType::DOUBLE, LogicalType::DOUBLE, true));
 	set.AddFunction(favg);
 }
 
@@ -74423,24 +74452,24 @@ static AggregateFunction GetUnaryAggregate(LogicalType type) {
 	case LogicalTypeId::TIMESTAMP_TZ:
 	case LogicalTypeId::TIME_TZ:
 	case LogicalTypeId::BIGINT:
-		return AggregateFunction::UnaryAggregate<MinMaxState<int64_t>, int64_t, int64_t, OP>(type, type);
+		return AggregateFunction::UnaryAggregate<MinMaxState<int64_t>, int64_t, int64_t, OP>(type, type, true);
 	case LogicalTypeId::UTINYINT:
-		return AggregateFunction::UnaryAggregate<MinMaxState<uint8_t>, uint8_t, uint8_t, OP>(type, type);
+		return AggregateFunction::UnaryAggregate<MinMaxState<uint8_t>, uint8_t, uint8_t, OP>(type, type, true);
 	case LogicalTypeId::USMALLINT:
-		return AggregateFunction::UnaryAggregate<MinMaxState<uint16_t>, uint16_t, uint16_t, OP>(type, type);
+		return AggregateFunction::UnaryAggregate<MinMaxState<uint16_t>, uint16_t, uint16_t, OP>(type, type, true);
 	case LogicalTypeId::UINTEGER:
-		return AggregateFunction::UnaryAggregate<MinMaxState<uint32_t>, uint32_t, uint32_t, OP>(type, type);
+		return AggregateFunction::UnaryAggregate<MinMaxState<uint32_t>, uint32_t, uint32_t, OP>(type, type, true);
 	case LogicalTypeId::UBIGINT:
-		return AggregateFunction::UnaryAggregate<MinMaxState<uint64_t>, uint64_t, uint64_t, OP>(type, type);
+		return AggregateFunction::UnaryAggregate<MinMaxState<uint64_t>, uint64_t, uint64_t, OP>(type, type, true);
 	case LogicalTypeId::HUGEINT:
 	case LogicalTypeId::UUID:
-		return AggregateFunction::UnaryAggregate<MinMaxState<hugeint_t>, hugeint_t, hugeint_t, OP>(type, type);
+		return AggregateFunction::UnaryAggregate<MinMaxState<hugeint_t>, hugeint_t, hugeint_t, OP>(type, type, true);
 	case LogicalTypeId::FLOAT:
-		return AggregateFunction::UnaryAggregate<MinMaxState<float>, float, float, OP>(type, type);
+		return AggregateFunction::UnaryAggregate<MinMaxState<float>, float, float, OP>(type, type, true);
 	case LogicalTypeId::DOUBLE:
-		return AggregateFunction::UnaryAggregate<MinMaxState<double>, double, double, OP>(type, type);
+		return AggregateFunction::UnaryAggregate<MinMaxState<double>, double, double, OP>(type, type, true);
 	case LogicalTypeId::INTERVAL:
-		return AggregateFunction::UnaryAggregate<MinMaxState<interval_t>, interval_t, interval_t, OP>(type, type);
+		return AggregateFunction::UnaryAggregate<MinMaxState<interval_t>, interval_t, interval_t, OP>(type, type, true);
 	default:
 		throw InternalException("Unimplemented type for min/max aggregate");
 	}
@@ -74921,7 +74950,7 @@ static void AddMinMaxOperator(AggregateFunctionSet &set) {
 			    AggregateFunction::UnaryAggregateDestructor<MinMaxState<string_t>, string_t, string_t, OP_STRING>(
 			        type.id(), type.id()));
 		} else if (type.id() == LogicalTypeId::DECIMAL) {
-			set.AddFunction(AggregateFunction({type}, type, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+			set.AddFunction(AggregateFunction({type}, type, nullptr, nullptr, nullptr, nullptr, nullptr, false, nullptr,
 			                                  BindDecimalMinMax<OP>));
 		} else if (type.id() == LogicalTypeId::LIST || type.id() == LogicalTypeId::MAP ||
 		           type.id() == LogicalTypeId::STRUCT) {
@@ -75350,13 +75379,13 @@ unique_ptr<BaseStatistics> SumPropagateStats(ClientContext &context, BoundAggreg
 		case PhysicalType::INT32:
 			expr.function =
 			    AggregateFunction::UnaryAggregate<SumState<int64_t>, int32_t, hugeint_t, IntegerSumOperation>(
-			        LogicalType::INTEGER, LogicalType::HUGEINT);
+			        LogicalType::INTEGER, LogicalType::HUGEINT, true);
 			expr.function.name = "sum";
 			break;
 		case PhysicalType::INT64:
 			expr.function =
 			    AggregateFunction::UnaryAggregate<SumState<int64_t>, int64_t, hugeint_t, IntegerSumOperation>(
-			        LogicalType::BIGINT, LogicalType::HUGEINT);
+			        LogicalType::BIGINT, LogicalType::HUGEINT, true);
 			expr.function.name = "sum";
 			break;
 		default:
@@ -75370,24 +75399,24 @@ AggregateFunction SumFun::GetSumAggregate(PhysicalType type) {
 	switch (type) {
 	case PhysicalType::INT16:
 		return AggregateFunction::UnaryAggregate<SumState<int64_t>, int16_t, hugeint_t, IntegerSumOperation>(
-		    LogicalType::SMALLINT, LogicalType::HUGEINT);
+		    LogicalType::SMALLINT, LogicalType::HUGEINT, true);
 	case PhysicalType::INT32: {
 		auto function =
 		    AggregateFunction::UnaryAggregate<SumState<hugeint_t>, int32_t, hugeint_t, SumToHugeintOperation>(
-		        LogicalType::INTEGER, LogicalType::HUGEINT);
+		        LogicalType::INTEGER, LogicalType::HUGEINT, true);
 		function.statistics = SumPropagateStats;
 		return function;
 	}
 	case PhysicalType::INT64: {
 		auto function =
 		    AggregateFunction::UnaryAggregate<SumState<hugeint_t>, int64_t, hugeint_t, SumToHugeintOperation>(
-		        LogicalType::BIGINT, LogicalType::HUGEINT);
+		        LogicalType::BIGINT, LogicalType::HUGEINT, true);
 		function.statistics = SumPropagateStats;
 		return function;
 	}
 	case PhysicalType::INT128:
 		return AggregateFunction::UnaryAggregate<SumState<hugeint_t>, hugeint_t, hugeint_t, HugeintSumOperation>(
-		    LogicalType::HUGEINT, LogicalType::HUGEINT);
+		    LogicalType::HUGEINT, LogicalType::HUGEINT, true);
 	default:
 		throw InternalException("Unimplemented sum aggregate");
 	}
@@ -75407,20 +75436,20 @@ void SumFun::RegisterFunction(BuiltinFunctions &set) {
 	AggregateFunctionSet sum("sum");
 	// decimal
 	sum.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
-	                                  nullptr, nullptr, nullptr, BindDecimalSum));
+	                                  nullptr, nullptr, true, nullptr, BindDecimalSum));
 	sum.AddFunction(GetSumAggregate(PhysicalType::INT16));
 	sum.AddFunction(GetSumAggregate(PhysicalType::INT32));
 	sum.AddFunction(GetSumAggregate(PhysicalType::INT64));
 	sum.AddFunction(GetSumAggregate(PhysicalType::INT128));
 	sum.AddFunction(AggregateFunction::UnaryAggregate<SumState<double>, double, double, NumericSumOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
+	    LogicalType::DOUBLE, LogicalType::DOUBLE, true));
 
 	set.AddFunction(sum);
 
 	// fsum
 	AggregateFunctionSet fsum("fsum");
 	fsum.AddFunction(AggregateFunction::UnaryAggregate<KahanSumState, double, double, KahanSumOperation>(
-	    LogicalType::DOUBLE, LogicalType::DOUBLE));
+	    LogicalType::DOUBLE, LogicalType::DOUBLE, true));
 
 	set.AddFunction(fsum);
 
@@ -78309,6 +78338,11 @@ struct ListPositionFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct ListAggregateFun {
+	static ScalarFunction GetFunction();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct CardinalityFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -80080,9 +80114,9 @@ bool SimpleNamedParameterFunction::HasNamedParameters() {
 }
 
 BaseScalarFunction::BaseScalarFunction(string name_p, vector<LogicalType> arguments_p, LogicalType return_type_p,
-                                       bool has_side_effects, LogicalType varargs_p)
+                                       bool has_side_effects, LogicalType varargs_p, bool propagates_null_values_p)
     : SimpleFunction(move(name_p), move(arguments_p), move(varargs_p)), return_type(move(return_type_p)),
-      has_side_effects(has_side_effects) {
+      has_side_effects(has_side_effects), propagates_null_values(propagates_null_values_p) {
 }
 
 BaseScalarFunction::~BaseScalarFunction() {
@@ -81150,8 +81184,8 @@ void CurrentDateFun::RegisterFunction(BuiltinFunctions &set) {
 }
 
 void CurrentTimestampFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"now", "current_timestamp"},
-	                ScalarFunction({}, LogicalType::TIMESTAMP, CurrentTimestampFunction, false, BindCurrentTime));
+	set.AddFunction({"now", "current_timestamp"}, ScalarFunction({}, LogicalType::TIMESTAMP, CurrentTimestampFunction,
+	                                                             false, false, BindCurrentTime));
 }
 
 } // namespace duckdb
@@ -82798,9 +82832,9 @@ void AddGenericDatePartOperator(BuiltinFunctions &set, const string &name, scala
                                 scalar_function_t ts_func, scalar_function_t interval_func,
                                 function_statistics_t date_stats, function_statistics_t ts_stats) {
 	ScalarFunctionSet operator_set(name);
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::DATE}, LogicalType::BIGINT, move(date_func), false, nullptr, nullptr, date_stats));
-	operator_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, move(ts_func), false,
+	operator_set.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::BIGINT, move(date_func), false, false,
+	                                        nullptr, nullptr, date_stats));
+	operator_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, move(ts_func), false, false,
 	                                        nullptr, nullptr, ts_stats));
 	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, move(interval_func)));
 	set.AddFunction(operator_set);
@@ -82819,13 +82853,13 @@ void AddGenericTimePartOperator(BuiltinFunctions &set, const string &name, scala
                                 function_statistics_t date_stats, function_statistics_t ts_stats,
                                 function_statistics_t time_stats) {
 	ScalarFunctionSet operator_set(name);
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::DATE}, LogicalType::BIGINT, move(date_func), false, nullptr, nullptr, date_stats));
-	operator_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, move(ts_func), false,
+	operator_set.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::BIGINT, move(date_func), false, false,
+	                                        nullptr, nullptr, date_stats));
+	operator_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, move(ts_func), false, false,
 	                                        nullptr, nullptr, ts_stats));
 	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, move(interval_func)));
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIME}, LogicalType::BIGINT, move(time_func), false, nullptr, nullptr, time_stats));
+	operator_set.AddFunction(ScalarFunction({LogicalType::TIME}, LogicalType::BIGINT, move(time_func), false, false,
+	                                        nullptr, nullptr, time_stats));
 	set.AddFunction(operator_set);
 }
 
@@ -83024,7 +83058,7 @@ struct StructDatePart {
 	static ScalarFunction GetFunction(const LogicalType &temporal_type) {
 		auto part_type = LogicalType::LIST(LogicalType::VARCHAR);
 		auto result_type = LogicalType::STRUCT({});
-		return ScalarFunction({part_type, temporal_type}, result_type, Function<INPUT_TYPE>, false, Bind);
+		return ScalarFunction({part_type, temporal_type}, result_type, Function<INPUT_TYPE>, false, false, Bind);
 	}
 };
 
@@ -84804,16 +84838,16 @@ void StrfTimeFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet strftime("strftime");
 
 	strftime.AddFunction(ScalarFunction({LogicalType::DATE, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionDate<false>, false, StrfTimeBindFunction<false>));
+	                                    StrfTimeFunctionDate<false>, false, false, StrfTimeBindFunction<false>));
 
 	strftime.AddFunction(ScalarFunction({LogicalType::TIMESTAMP, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionTimestamp<false>, false, StrfTimeBindFunction<false>));
+	                                    StrfTimeFunctionTimestamp<false>, false, false, StrfTimeBindFunction<false>));
 
 	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionDate<true>, false, StrfTimeBindFunction<true>));
+	                                    StrfTimeFunctionDate<true>, false, false, StrfTimeBindFunction<true>));
 
 	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::VARCHAR,
-	                                    StrfTimeFunctionTimestamp<true>, false, StrfTimeBindFunction<true>));
+	                                    StrfTimeFunctionTimestamp<true>, false, false, StrfTimeBindFunction<true>));
 
 	set.AddFunction(strftime);
 }
@@ -85376,7 +85410,7 @@ void StrpTimeFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet strptime("strptime");
 
 	strptime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::TIMESTAMP,
-	                                    StrpTimeFunction, false, StrpTimeBindFunction));
+	                                    StrpTimeFunction, false, false, StrpTimeBindFunction));
 
 	set.AddFunction(strptime);
 }
@@ -86026,22 +86060,23 @@ static void LeastGreatestFunction(DataChunk &args, ExpressionState &state, Vecto
 
 template <typename T, class OP>
 ScalarFunction GetLeastGreatestFunction(const LogicalType &type) {
-	return ScalarFunction({type}, type, LeastGreatestFunction<T, OP>, false, nullptr, nullptr, nullptr, nullptr, type);
+	return ScalarFunction({type}, type, LeastGreatestFunction<T, OP>, true, false, nullptr, nullptr, nullptr, nullptr,
+	                      type);
 }
 
 template <class OP>
 static void RegisterLeastGreatest(BuiltinFunctions &set, const string &fun_name) {
 	ScalarFunctionSet fun_set(fun_name);
 	fun_set.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::BIGINT, LeastGreatestFunction<int64_t, OP>,
-	                                   false, nullptr, nullptr, nullptr, nullptr, LogicalType::BIGINT));
+	                                   true, false, nullptr, nullptr, nullptr, nullptr, LogicalType::BIGINT));
 	fun_set.AddFunction(ScalarFunction({LogicalType::HUGEINT}, LogicalType::HUGEINT,
-	                                   LeastGreatestFunction<hugeint_t, OP>, false, nullptr, nullptr, nullptr, nullptr,
-	                                   LogicalType::HUGEINT));
+	                                   LeastGreatestFunction<hugeint_t, OP>, true, false, nullptr, nullptr, nullptr,
+	                                   nullptr, LogicalType::HUGEINT));
 	fun_set.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, LeastGreatestFunction<double, OP>,
-	                                   false, nullptr, nullptr, nullptr, nullptr, LogicalType::DOUBLE));
+	                                   true, false, nullptr, nullptr, nullptr, nullptr, LogicalType::DOUBLE));
 	fun_set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                   LeastGreatestFunction<string_t, OP, true>, false, nullptr, nullptr, nullptr,
-	                                   nullptr, LogicalType::VARCHAR));
+	                                   LeastGreatestFunction<string_t, OP, true>, true, false, nullptr, nullptr,
+	                                   nullptr, nullptr, LogicalType::VARCHAR));
 
 	fun_set.AddFunction(GetLeastGreatestFunction<timestamp_t, OP>(LogicalType::TIMESTAMP));
 	fun_set.AddFunction(GetLeastGreatestFunction<time_t, OP>(LogicalType::TIME));
@@ -86336,7 +86371,7 @@ static unique_ptr<FunctionData> ArraySliceBind(ClientContext &context, ScalarFun
 void ArraySliceFun::RegisterFunction(BuiltinFunctions &set) {
 	// the arguments and return types are actually set in the binder function
 	ScalarFunction fun({LogicalType::ANY, LogicalType::BIGINT, LogicalType::BIGINT}, LogicalType::ANY,
-	                   ArraySliceFunction, false, ArraySliceBind);
+	                   ArraySliceFunction, false, false, ArraySliceBind);
 	fun.varargs = LogicalType::ANY;
 	set.AddFunction({"array_slice", "list_slice"}, fun);
 }
@@ -86552,13 +86587,13 @@ static unique_ptr<FunctionData> ListPositionBind(ClientContext &context, ScalarF
 ScalarFunction ListContainsFun::GetFunction() {
 	return ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::ANY}, // argument list
 	                      LogicalType::BOOLEAN,                                    // return type
-	                      ListContainsFunction, false, ListContainsBind, nullptr);
+	                      ListContainsFunction, false, false, ListContainsBind, nullptr);
 }
 
 ScalarFunction ListPositionFun::GetFunction() {
 	return ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::ANY}, // argument list
 	                      LogicalType::INTEGER,                                    // return type
-	                      ListPositionFunction, false, ListPositionBind, nullptr);
+	                      ListPositionFunction, false, false, ListPositionBind, nullptr);
 }
 
 void ListContainsFun::RegisterFunction(BuiltinFunctions &set) {
@@ -86734,7 +86769,7 @@ static unique_ptr<BaseStatistics> ListFlattenStats(ClientContext &context, Bound
 
 void ListFlattenFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunction fun({LogicalType::LIST(LogicalType::LIST(LogicalType::ANY))}, LogicalType::LIST(LogicalType::ANY),
-	                   ListFlattenFunction, false, ListFlattenBind, nullptr, ListFlattenStats);
+	                   ListFlattenFunction, false, false, ListFlattenBind, nullptr, ListFlattenStats);
 	set.AddFunction({"flatten"}, fun);
 }
 
@@ -86746,6 +86781,227 @@ void ListFlattenFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+
+namespace duckdb {
+
+// FIXME: use a local state for each thread to increase performance?
+// FIXME: benchmark the use of simple_update against using update (if applicable)
+
+struct ListAggregatesBindData : public FunctionData {
+	ListAggregatesBindData(const LogicalType &stype_p, unique_ptr<Expression> aggr_expr_p);
+	~ListAggregatesBindData() override;
+
+	LogicalType stype;
+	unique_ptr<Expression> aggr_expr;
+
+	unique_ptr<FunctionData> Copy() override;
+};
+
+ListAggregatesBindData::ListAggregatesBindData(const LogicalType &stype_p, unique_ptr<Expression> aggr_expr_p)
+    : stype(stype_p), aggr_expr(move(aggr_expr_p)) {
+}
+
+unique_ptr<FunctionData> ListAggregatesBindData::Copy() {
+	return make_unique<ListAggregatesBindData>(stype, aggr_expr->Copy());
+}
+
+ListAggregatesBindData::~ListAggregatesBindData() {
+}
+
+struct StateVector {
+	StateVector(idx_t count_p, unique_ptr<Expression> aggr_expr_p)
+	    : count(count_p), aggr_expr(move(aggr_expr_p)), state_vector(Vector(LogicalType::POINTER, count_p)) {
+	}
+
+	~StateVector() {
+		// destroy objects within the aggregate states
+		auto &aggr = (BoundAggregateExpression &)*aggr_expr;
+		if (aggr.function.destructor) {
+			aggr.function.destructor(state_vector, count);
+		}
+	}
+
+	idx_t count;
+	unique_ptr<Expression> aggr_expr;
+	Vector state_vector;
+};
+
+static void ListAggregateFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+
+	D_ASSERT(args.ColumnCount() == 2);
+	auto count = args.size();
+	Vector &lists = args.data[0];
+
+	// set the result vector
+	result.SetVectorType(VectorType::FLAT_VECTOR);
+	auto &result_validity = FlatVector::Validity(result);
+
+	if (lists.GetType().id() == LogicalTypeId::SQLNULL) {
+		result_validity.SetInvalid(0);
+		return;
+	}
+
+	// get the aggregate function
+	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	auto &info = (ListAggregatesBindData &)*func_expr.bind_info;
+	auto &aggr = (BoundAggregateExpression &)*info.aggr_expr;
+
+	D_ASSERT(aggr.function.update);
+
+	auto lists_size = ListVector::GetListSize(lists);
+	auto &child_vector = ListVector::GetEntry(lists);
+
+	VectorData child_data;
+	child_vector.Orrify(lists_size, child_data);
+
+	VectorData lists_data;
+	lists.Orrify(count, lists_data);
+	auto list_entries = (list_entry_t *)lists_data.data;
+
+	// state_buffer holds the state for each list of this chunk
+	idx_t size = aggr.function.state_size();
+	auto state_buffer = unique_ptr<data_t[]>(new data_t[size * count]);
+
+	// state vector for initialize and finalize
+	StateVector state_vector(count, info.aggr_expr->Copy());
+	auto states = FlatVector::GetData<data_ptr_t>(state_vector.state_vector);
+
+	// state vector of STANDARD_VECTOR_SIZE holds the pointers to the states
+	Vector state_vector_update = Vector(LogicalType::POINTER);
+	auto states_update = FlatVector::GetData<data_ptr_t>(state_vector_update);
+
+	// selection vector pointing to the data
+	SelectionVector sel_vector(STANDARD_VECTOR_SIZE);
+	idx_t states_idx = 0;
+
+	for (idx_t i = 0; i < count; i++) {
+
+		// initialize the state for this list
+		auto state_ptr = state_buffer.get() + size * i;
+		states[i] = state_ptr;
+		aggr.function.initialize(states[i]);
+
+		auto lists_index = lists_data.sel->get_index(i);
+		const auto &list_entry = list_entries[lists_index];
+
+		// nothing to do for this list
+		if (!lists_data.validity.RowIsValid(lists_index)) {
+			result_validity.SetInvalid(i);
+			continue;
+		}
+
+		// skip empty list
+		if (list_entry.length == 0) {
+			continue;
+		}
+
+		auto source_idx = child_data.sel->get_index(list_entry.offset);
+		idx_t child_idx = 0;
+
+		while (child_idx < list_entry.length) {
+
+			// states vector is full, update
+			if (states_idx == STANDARD_VECTOR_SIZE) {
+
+				// update the aggregate state(s)
+				Vector slice = Vector(child_vector, sel_vector, states_idx);
+				aggr.function.update(&slice, aggr.bind_info.get(), 1, state_vector_update, states_idx);
+
+				// reset values
+				states_idx = 0;
+			}
+
+			sel_vector.set_index(states_idx, source_idx + child_idx);
+			states_update[states_idx] = state_ptr;
+			states_idx++;
+			child_idx++;
+		}
+	}
+
+	// update the remaining elements of the last list(s)
+	if (states_idx != 0) {
+		Vector slice = Vector(child_vector, sel_vector, states_idx);
+		aggr.function.update(&slice, aggr.bind_info.get(), 1, state_vector_update, states_idx);
+	}
+
+	// finalize all the aggregate states
+	aggr.function.finalize(state_vector.state_vector, aggr.bind_info.get(), result, count, 0);
+}
+
+static unique_ptr<FunctionData> ListAggregateBind(ClientContext &context, ScalarFunction &bound_function,
+                                                  vector<unique_ptr<Expression>> &arguments) {
+
+	// the list column and the name of the aggregate function
+	D_ASSERT(bound_function.arguments.size() == 2);
+	D_ASSERT(arguments.size() == 2);
+
+	if (arguments[0]->return_type.id() == LogicalTypeId::SQLNULL) {
+		bound_function.arguments[0] = LogicalType::SQLNULL;
+		bound_function.return_type = LogicalType::SQLNULL;
+		return make_unique<VariableReturnBindData>(bound_function.return_type);
+	}
+
+	D_ASSERT(LogicalTypeId::LIST == arguments[0]->return_type.id());
+	auto list_child_type = ListType::GetChildType(arguments[0]->return_type);
+	bound_function.return_type = list_child_type;
+
+	if (!arguments[1]->IsFoldable()) {
+		throw InvalidInputException("Aggregate function name must be a constant");
+	}
+
+	// get the function name
+	Value function_value = ExpressionExecutor::EvaluateScalar(*arguments[1]);
+	auto function_name = StringValue::Get(function_value);
+
+	vector<LogicalType> types;
+	types.push_back(list_child_type);
+
+	// create the child expression and its type
+	vector<unique_ptr<Expression>> children;
+	auto expr = make_unique<BoundConstantExpression>(Value(LogicalType::SQLNULL));
+	expr->return_type = list_child_type;
+	children.push_back(move(expr));
+
+	// look up the aggregate function in the catalog
+	QueryErrorContext error_context(nullptr, 0);
+	auto func = (AggregateFunctionCatalogEntry *)Catalog::GetCatalog(context).GetEntry<AggregateFunctionCatalogEntry>(
+	    context, DEFAULT_SCHEMA, function_name, false, error_context);
+	D_ASSERT(func->type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
+
+	// find a matching aggregate function
+	string error;
+	auto best_function_idx = Function::BindFunction(func->name, func->functions, types, error);
+	if (best_function_idx == DConstants::INVALID_INDEX) {
+		throw BinderException("No matching aggregate function");
+	}
+
+	// found a matching function, bind it as an aggregate
+	auto &best_function = func->functions[best_function_idx];
+	auto bound_aggr_function = AggregateFunction::BindAggregateFunction(context, best_function, move(children));
+
+	bound_function.arguments[0] =
+	    LogicalType::LIST(bound_aggr_function->function.arguments[0]); // for proper casting of the vectors
+	bound_function.return_type = bound_aggr_function->function.return_type;
+	return make_unique<ListAggregatesBindData>(bound_function.return_type, move(bound_aggr_function));
+}
+
+ScalarFunction ListAggregateFun::GetFunction() {
+	return ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR}, LogicalType::ANY,
+	                      ListAggregateFunction, false, ListAggregateBind, nullptr, nullptr, nullptr);
+}
+
+void ListAggregateFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction({"list_aggregate", "array_aggregate", "list_aggr", "array_aggr"}, GetFunction());
+}
+
+} // namespace duckdb
+
+
+
+
+
+
+
 namespace duckdb {
 
 static void ListConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
@@ -86866,8 +87122,8 @@ static unique_ptr<BaseStatistics> ListConcatStats(ClientContext &context, BoundF
 ScalarFunction ListConcatFun::GetFunction() {
 	// the arguments and return types are actually set in the binder function
 	return ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::LIST(LogicalType::ANY)},
-	                      LogicalType::LIST(LogicalType::ANY), ListConcatFunction, false, ListConcatBind, nullptr,
-	                      ListConcatStats);
+	                      LogicalType::LIST(LogicalType::ANY), ListConcatFunction, false, false, ListConcatBind,
+	                      nullptr, ListConcatStats);
 }
 
 void ListConcatFun::RegisterFunction(BuiltinFunctions &set) {
@@ -87105,10 +87361,10 @@ static unique_ptr<BaseStatistics> ListExtractStats(ClientContext &context, Bound
 void ListExtractFun::RegisterFunction(BuiltinFunctions &set) {
 	// the arguments and return types are actually set in the binder function
 	ScalarFunction lfun({LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT}, LogicalType::ANY,
-	                    ListExtractFunction, false, ListExtractBind, nullptr, ListExtractStats);
+	                    ListExtractFunction, false, false, ListExtractBind, nullptr, ListExtractStats);
 
 	ScalarFunction sfun({LogicalType::VARCHAR, LogicalType::INTEGER}, LogicalType::VARCHAR, ListExtractFunction, false,
-	                    nullptr);
+	                    false, nullptr);
 
 	ScalarFunctionSet list_extract("list_extract");
 	list_extract.AddFunction(lfun);
@@ -87967,7 +88223,7 @@ void AbsFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet abs("abs");
 	for (auto &type : LogicalType::Numeric()) {
 		if (type.id() == LogicalTypeId::DECIMAL) {
-			abs.AddFunction(ScalarFunction({type}, type, nullptr, false, DecimalUnaryOpBind<AbsOperator>));
+			abs.AddFunction(ScalarFunction({type}, type, nullptr, false, false, DecimalUnaryOpBind<AbsOperator>));
 		} else {
 			abs.AddFunction(ScalarFunction({type}, type, ScalarFunction::GetScalarUnaryFunction<AbsOperator>(type)));
 		}
@@ -88141,7 +88397,7 @@ void CeilFun::RegisterFunction(BuiltinFunctions &set) {
 		default:
 			throw InternalException("Unimplemented numeric type for function \"ceil\"");
 		}
-		ceil.AddFunction(ScalarFunction({type}, type, func, false, bind_func));
+		ceil.AddFunction(ScalarFunction({type}, type, func, false, false, bind_func));
 	}
 
 	set.AddFunction(ceil);
@@ -88197,7 +88453,7 @@ void FloorFun::RegisterFunction(BuiltinFunctions &set) {
 		default:
 			throw InternalException("Unimplemented numeric type for function \"floor\"");
 		}
-		floor.AddFunction(ScalarFunction({type}, type, func, false, bind_func));
+		floor.AddFunction(ScalarFunction({type}, type, func, false, false, bind_func));
 	}
 	set.AddFunction(floor);
 }
@@ -88404,8 +88660,9 @@ void RoundFun::RegisterFunction(BuiltinFunctions &set) {
 		default:
 			throw InternalException("Unimplemented numeric type for function \"floor\"");
 		}
-		round.AddFunction(ScalarFunction({type}, type, round_func, false, bind_func));
-		round.AddFunction(ScalarFunction({type, LogicalType::INTEGER}, type, round_prec_func, false, bind_prec_func));
+		round.AddFunction(ScalarFunction({type}, type, round_func, false, false, bind_func));
+		round.AddFunction(
+		    ScalarFunction({type, LogicalType::INTEGER}, type, round_prec_func, false, false, bind_prec_func));
 	}
 	set.AddFunction(round);
 }
@@ -89027,6 +89284,7 @@ void BuiltinFunctions::RegisterNestedFunctions() {
 	Register<ListConcatFun>();
 	Register<ListContainsFun>();
 	Register<ListPositionFun>();
+	Register<ListAggregateFun>();
 	Register<ListValueFun>();
 	Register<ListExtractFun>();
 	Register<ListRangeFun>();
@@ -90003,23 +90261,23 @@ void MultiplyFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet functions("*");
 	for (auto &type : LogicalType::Numeric()) {
 		if (type.id() == LogicalTypeId::DECIMAL) {
-			functions.AddFunction(ScalarFunction({type, type}, type, nullptr, false, BindDecimalMultiply));
+			functions.AddFunction(ScalarFunction({type, type}, type, nullptr, true, false, BindDecimalMultiply));
 		} else if (TypeIsIntegral(type.InternalType()) && type.id() != LogicalTypeId::HUGEINT) {
 			functions.AddFunction(ScalarFunction(
-			    {type, type}, type, GetScalarIntegerFunction<MultiplyOperatorOverflowCheck>(type.InternalType()), false,
-			    nullptr, nullptr,
+			    {type, type}, type, GetScalarIntegerFunction<MultiplyOperatorOverflowCheck>(type.InternalType()), true,
+			    false, nullptr, nullptr,
 			    PropagateNumericStats<TryMultiplyOperator, MultiplyPropagateStatistics, MultiplyOperator>));
 		} else {
-			functions.AddFunction(
-			    ScalarFunction({type, type}, type, GetScalarBinaryFunction<MultiplyOperator>(type.InternalType())));
+			functions.AddFunction(ScalarFunction({type, type}, type,
+			                                     GetScalarBinaryFunction<MultiplyOperator>(type.InternalType()), true));
 		}
 	}
 	functions.AddFunction(
 	    ScalarFunction({LogicalType::INTERVAL, LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                   ScalarFunction::BinaryFunction<interval_t, int64_t, interval_t, MultiplyOperator>));
+	                   ScalarFunction::BinaryFunction<interval_t, int64_t, interval_t, MultiplyOperator>, true));
 	functions.AddFunction(
 	    ScalarFunction({LogicalType::BIGINT, LogicalType::INTERVAL}, LogicalType::INTERVAL,
-	                   ScalarFunction::BinaryFunction<int64_t, interval_t, interval_t, MultiplyOperator>));
+	                   ScalarFunction::BinaryFunction<int64_t, interval_t, interval_t, MultiplyOperator>, true));
 	set.AddFunction(functions);
 }
 
@@ -91257,7 +91515,7 @@ void LowerFun::RegisterFunction(BuiltinFunctions &set) {
 void UpperFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction({"upper", "ucase"},
 	                ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR, CaseConvertFunction<true>, false,
-	                               nullptr, nullptr, CaseConvertPropagateStats<true>));
+	                               false, nullptr, nullptr, CaseConvertPropagateStats<true>));
 }
 
 } // namespace duckdb
@@ -91987,11 +92245,11 @@ static unique_ptr<FunctionData> ListLengthBind(ClientContext &context, ScalarFun
 void LengthFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunction array_length_unary = ScalarFunction(
 	    {LogicalType::LIST(LogicalType::ANY)}, LogicalType::BIGINT,
-	    ScalarFunction::UnaryFunction<list_entry_t, int64_t, ArrayLengthOperator>, false, ListLengthBind);
+	    ScalarFunction::UnaryFunction<list_entry_t, int64_t, ArrayLengthOperator>, false, false, ListLengthBind);
 	ScalarFunctionSet length("length");
 	length.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::BIGINT,
 	                                  ScalarFunction::UnaryFunction<string_t, int64_t, StringLengthOperator>, false,
-	                                  nullptr, nullptr, LengthPropagateStats));
+	                                  false, nullptr, nullptr, LengthPropagateStats));
 	length.AddFunction(array_length_unary);
 	set.AddFunction(length);
 	length.name = "len";
@@ -92002,7 +92260,7 @@ void LengthFun::RegisterFunction(BuiltinFunctions &set) {
 	array_length.AddFunction(
 	    ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT}, LogicalType::BIGINT,
 	                   ScalarFunction::BinaryFunction<list_entry_t, int64_t, int64_t, ArrayLengthBinaryOperator>, false,
-	                   ListLengthBind));
+	                   false, ListLengthBind));
 	set.AddFunction(array_length);
 
 	set.AddFunction(ScalarFunction("strlen", {LogicalType::VARCHAR}, LogicalType::BIGINT,
@@ -94751,34 +95009,36 @@ static unique_ptr<FunctionData> RegexExtractBind(ClientContext &context, ScalarF
 void RegexpFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet regexp_full_match("regexp_full_match");
 	regexp_full_match.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                                             RegexpMatchesFunction<RegexFullMatch>, false, RegexpMatchesBind,
+	                                             RegexpMatchesFunction<RegexFullMatch>, false, false, RegexpMatchesBind,
 	                                             nullptr, nullptr, RegexInitLocalState));
 	regexp_full_match.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
 	                                             LogicalType::BOOLEAN, RegexpMatchesFunction<RegexFullMatch>, false,
-	                                             RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState));
+	                                             false, RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState));
 
 	ScalarFunctionSet regexp_partial_match("regexp_matches");
 	regexp_partial_match.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                                                RegexpMatchesFunction<RegexPartialMatch>, false, RegexpMatchesBind,
-	                                                nullptr, nullptr, RegexInitLocalState));
+	                                                RegexpMatchesFunction<RegexPartialMatch>, false, false,
+	                                                RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState));
 	regexp_partial_match.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
 	                                                LogicalType::BOOLEAN, RegexpMatchesFunction<RegexPartialMatch>,
-	                                                false, RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState));
+	                                                false, false, RegexpMatchesBind, nullptr, nullptr,
+	                                                RegexInitLocalState));
 
 	ScalarFunctionSet regexp_replace("regexp_replace");
 	regexp_replace.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                          LogicalType::VARCHAR, RegexReplaceFunction, false, RegexReplaceBind));
+	                                          LogicalType::VARCHAR, RegexReplaceFunction, false, false,
+	                                          RegexReplaceBind));
 	regexp_replace.AddFunction(
 	    ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                   LogicalType::VARCHAR, RegexReplaceFunction, false, RegexReplaceBind));
+	                   LogicalType::VARCHAR, RegexReplaceFunction, false, false, RegexReplaceBind));
 
 	ScalarFunctionSet regexp_extract("regexp_extract");
 	regexp_extract.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
-	                                          RegexExtractFunction, false, RegexExtractBind, nullptr, nullptr,
+	                                          RegexExtractFunction, false, false, RegexExtractBind, nullptr, nullptr,
 	                                          RegexExtractInitLocalState));
 	regexp_extract.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::INTEGER},
-	                                          LogicalType::VARCHAR, RegexExtractFunction, false, RegexExtractBind,
-	                                          nullptr, nullptr, RegexExtractInitLocalState));
+	                                          LogicalType::VARCHAR, RegexExtractFunction, false, false,
+	                                          RegexExtractBind, nullptr, nullptr, RegexExtractInitLocalState));
 
 	set.AddFunction(regexp_full_match);
 	set.AddFunction(regexp_partial_match);
@@ -95471,10 +95731,10 @@ static unique_ptr<BaseStatistics> SubstringPropagateStats(ClientContext &context
 void SubstringFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet substr("substring");
 	substr.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT, LogicalType::BIGINT},
-	                                  LogicalType::VARCHAR, SubstringFunction, false, nullptr, nullptr,
+	                                  LogicalType::VARCHAR, SubstringFunction, false, false, nullptr, nullptr,
 	                                  SubstringPropagateStats));
 	substr.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR,
-	                                  SubstringFunction, false, nullptr, nullptr, SubstringPropagateStats));
+	                                  SubstringFunction, false, false, nullptr, nullptr, SubstringPropagateStats));
 	set.AddFunction(substr);
 	substr.name = "substr";
 	set.AddFunction(substr);
@@ -96467,7 +96727,7 @@ static void GenerateUUIDFunction(DataChunk &args, ExpressionState &state, Vector
 }
 
 void UUIDFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunction uuid_function({}, LogicalType::UUID, GenerateUUIDFunction, true, UUIDRandomBind);
+	ScalarFunction uuid_function({}, LogicalType::UUID, GenerateUUIDFunction, false, true, UUIDRandomBind);
 	// generate a random uuid
 	set.AddFunction({"uuid", "gen_random_uuid"}, uuid_function);
 }
@@ -96480,18 +96740,19 @@ namespace duckdb {
 ScalarFunction::ScalarFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
                                scalar_function_t function, bool has_side_effects, bind_scalar_function_t bind,
                                dependency_function_t dependency, function_statistics_t statistics,
-                               init_local_state_t init_local_state, LogicalType varargs)
-    : BaseScalarFunction(move(name), move(arguments), move(return_type), has_side_effects, move(varargs)),
+                               init_local_state_t init_local_state, LogicalType varargs, bool propagate_null_values)
+    : BaseScalarFunction(move(name), move(arguments), move(return_type), has_side_effects, move(varargs),
+                         propagate_null_values),
       function(move(function)), bind(bind), init_local_state(init_local_state), dependency(dependency),
       statistics(statistics) {
 }
 
 ScalarFunction::ScalarFunction(vector<LogicalType> arguments, LogicalType return_type, scalar_function_t function,
-                               bool has_side_effects, bind_scalar_function_t bind, dependency_function_t dependency,
-                               function_statistics_t statistics, init_local_state_t init_local_state,
-                               LogicalType varargs)
+                               bool propagate_null_values, bool has_side_effects, bind_scalar_function_t bind,
+                               dependency_function_t dependency, function_statistics_t statistics,
+                               init_local_state_t init_local_state, LogicalType varargs)
     : ScalarFunction(string(), move(arguments), move(return_type), move(function), has_side_effects, bind, dependency,
-                     statistics, init_local_state, move(varargs)) {
+                     statistics, init_local_state, move(varargs), propagate_null_values) {
 }
 
 bool ScalarFunction::operator==(const ScalarFunction &rhs) const {
@@ -119806,7 +120067,11 @@ const vector<ColumnDefinition> &JoinRelation::Columns() {
 
 string JoinRelation::ToString(idx_t depth) {
 	string str = RenderWhitespace(depth);
-	str = "Join " + JoinTypeToString(join_type);
+	str += "Join " + JoinTypeToString(join_type);
+	if (condition) {
+		str += " " + condition->GetName();
+	}
+
 	return str + "\n" + left->ToString(depth + 1) + "\n" + right->ToString(depth + 1);
 }
 
@@ -119917,6 +120182,7 @@ public:
 
 	vector<OrderByNode> orders;
 	shared_ptr<Relation> child;
+	vector<ColumnDefinition> columns;
 
 public:
 	unique_ptr<QueryNode> GetQueryNode() override;
@@ -119939,23 +120205,26 @@ public:
 
 
 
+
+
 namespace duckdb {
 
 OrderRelation::OrderRelation(shared_ptr<Relation> child_p, vector<OrderByNode> orders)
     : Relation(child_p->context, RelationType::ORDER_RELATION), orders(move(orders)), child(move(child_p)) {
 	// bind the expressions
-	vector<ColumnDefinition> dummy_columns;
-	context.GetContext()->TryBindRelation(*this, dummy_columns);
+	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 unique_ptr<QueryNode> OrderRelation::GetQueryNode() {
-	auto child_node = child->GetQueryNode();
+	auto select = make_unique<SelectNode>();
+	select->from_table = child->GetTableRef();
+	select->select_list.push_back(make_unique<StarExpression>());
 	auto order_node = make_unique<OrderModifier>();
 	for (idx_t i = 0; i < orders.size(); i++) {
 		order_node->orders.emplace_back(orders[i].type, orders[i].null_order, orders[i].expression->Copy());
 	}
-	child_node->modifiers.push_back(move(order_node));
-	return child_node;
+	select->modifiers.push_back(move(order_node));
+	return move(select);
 }
 
 string OrderRelation::GetAlias() {
@@ -119963,7 +120232,7 @@ string OrderRelation::GetAlias() {
 }
 
 const vector<ColumnDefinition> &OrderRelation::Columns() {
-	return child->Columns();
+	return columns;
 }
 
 string OrderRelation::ToString(idx_t depth) {
@@ -122396,7 +122665,6 @@ public:
 	void VisitExpression(unique_ptr<Expression> *expression) override;
 	//! Whether the operator has one or more children of type DELIM_GET
 	bool HasChildDelimGet(LogicalOperator &op);
-
 	expression_map_t<Expression *> expr_map;
 	column_binding_map_t<bool> projection_map;
 	unique_ptr<LogicalOperator> temp_ptr;
@@ -122405,12 +122673,12 @@ public:
 void DeliminatorPlanUpdater::VisitOperator(LogicalOperator &op) {
 	VisitOperatorChildren(op);
 	VisitOperatorExpressions(op);
-	// now check if this is a delim join that can be removed
 	if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN && !HasChildDelimGet(op)) {
 		auto &delim_join = (LogicalDelimJoin &)op;
 		auto decs = &delim_join.duplicate_eliminated_columns;
 		for (auto &cond : delim_join.conditions) {
-			if (cond.comparison != ExpressionType::COMPARE_EQUAL) {
+			if (cond.comparison != ExpressionType::COMPARE_EQUAL &&
+			    cond.comparison != ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
 				continue;
 			}
 			auto &colref = (BoundColumnRefExpression &)*cond.right;
@@ -122424,7 +122692,7 @@ void DeliminatorPlanUpdater::VisitOperator(LogicalOperator &op) {
 					}
 				}
 				// whether we applied an IS NOT NULL filter
-				cond.null_values_are_equal = true; // projection_map[colref.binding];
+				cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
 			}
 		}
 		// change type if there are no more duplicate-eliminated columns
@@ -122521,6 +122789,7 @@ bool Deliminator::RemoveCandidate(unique_ptr<LogicalOperator> *op_ptr, Deliminat
 	if (join.join_type != JoinType::INNER && join.join_type != JoinType::SEMI) {
 		return false;
 	}
+
 	// get the index (left or right) of the DelimGet side of the join
 	idx_t delim_idx = OperatorIsDelimGet(*join.children[0]) ? 0 : 1;
 	D_ASSERT(OperatorIsDelimGet(*join.children[delim_idx]));
@@ -122537,7 +122806,8 @@ bool Deliminator::RemoveCandidate(unique_ptr<LogicalOperator> *op_ptr, Deliminat
 	// check if joining with the DelimGet is redundant, and collect relevant column information
 	vector<Expression *> nulls_are_not_equal_exprs;
 	for (auto &cond : join.conditions) {
-		if (cond.comparison != ExpressionType::COMPARE_EQUAL) {
+		if (cond.comparison != ExpressionType::COMPARE_EQUAL &&
+		    cond.comparison != ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
 			// non-equality join condition
 			return false;
 		}
@@ -122549,7 +122819,7 @@ bool Deliminator::RemoveCandidate(unique_ptr<LogicalOperator> *op_ptr, Deliminat
 			return false;
 		}
 		updater.expr_map[delim_side] = other_side;
-		if (!cond.null_values_are_equal) {
+		if (cond.comparison != ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
 			nulls_are_not_equal_exprs.push_back(other_side);
 		}
 	}
@@ -125838,15 +126108,8 @@ JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted
 				bool invert = !JoinRelationSet::IsSubset(left.first, f->left_set);
 				cond.left = !invert ? move(comparison.left) : move(comparison.right);
 				cond.right = !invert ? move(comparison.right) : move(comparison.left);
-				if (condition->type == ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-					cond.comparison = ExpressionType::COMPARE_EQUAL;
-					cond.null_values_are_equal = true;
-				} else if (condition->type == ExpressionType::COMPARE_DISTINCT_FROM) {
-					cond.comparison = condition->type;
-					cond.null_values_are_equal = true;
-				} else {
-					cond.comparison = condition->type;
-				}
+				cond.comparison = condition->type;
+
 				if (invert) {
 					// reverse comparison expression if we reverse the order of the children
 					cond.comparison = FlipComparisionExpression(cond.comparison);
@@ -127517,7 +127780,8 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownMarkJoin(unique_ptr<LogicalO
 					// the filter is NOT(marker), check the join conditions
 					bool all_null_values_are_equal = true;
 					for (auto &cond : comp_join.conditions) {
-						if (!cond.null_values_are_equal) {
+						if (cond.comparison != ExpressionType::COMPARE_DISTINCT_FROM &&
+						    cond.comparison != ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
 							all_null_values_are_equal = false;
 							break;
 						}
@@ -130180,7 +130444,9 @@ void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, uniq
 		auto stats_left = PropagateExpression(condition.left);
 		auto stats_right = PropagateExpression(condition.right);
 		if (stats_left && stats_right) {
-			if (condition.null_values_are_equal && stats_left->CanHaveNull() && stats_right->CanHaveNull()) {
+			if ((condition.comparison == ExpressionType::COMPARE_DISTINCT_FROM ||
+			     condition.comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM) &&
+			    stats_left->CanHaveNull() && stats_right->CanHaveNull()) {
 				// null values are equal in this join, and both sides can have null values
 				// nothing to do here
 				continue;
@@ -130268,7 +130534,8 @@ void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, uniq
 		// anti joins have inverse statistics propagation
 		// (i.e. if we have an anti join on i: [0, 100] and j: [0, 25], the resulting stats are i:[25,100])
 		// for now we don't handle anti joins
-		if (condition.null_values_are_equal) {
+		if (condition.comparison == ExpressionType::COMPARE_DISTINCT_FROM ||
+		    condition.comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
 			// skip update when null values are equal (for now?)
 			continue;
 		}
@@ -151401,10 +151668,16 @@ BindResult BindContext::BindColumn(ColumnRefExpression &colref, idx_t depth) {
 }
 
 string BindContext::BindColumn(PositionalReferenceExpression &ref, string &table_name, string &column_name) {
-	idx_t current_position = ref.index - 1;
 	idx_t total_columns = 0;
+	idx_t current_position = ref.index - 1;
 	for (auto &entry : bindings_list) {
 		idx_t entry_column_count = entry.second->names.size();
+		if (ref.index == 0) {
+			// this is a row id
+			table_name = entry.first;
+			column_name = "rowid";
+			return string();
+		}
 		if (current_position < entry_column_count) {
 			table_name = entry.first;
 			column_name = entry.second->names[current_position];
@@ -154778,7 +155051,7 @@ namespace duckdb {
 //! The FlattenDependentJoins class is responsible for pushing the dependent join down into the plan to create a
 //! flattened subquery
 struct FlattenDependentJoins {
-	FlattenDependentJoins(Binder &binder, const vector<CorrelatedColumnInfo> &correlated);
+	FlattenDependentJoins(Binder &binder, const vector<CorrelatedColumnInfo> &correlated, bool any_join = false);
 
 	//! Detects which Logical Operators have correlated expressions that they are dependent upon, filling the
 	//! has_correlated_expressions map.
@@ -154797,8 +155070,11 @@ struct FlattenDependentJoins {
 	const vector<CorrelatedColumnInfo> &correlated_columns;
 	vector<LogicalType> delim_types;
 
+	bool any_join;
+
 private:
-	unique_ptr<LogicalOperator> PushDownDependentJoinInternal(unique_ptr<LogicalOperator> plan);
+	unique_ptr<LogicalOperator> PushDownDependentJoinInternal(unique_ptr<LogicalOperator> plan,
+	                                                          bool &parent_propagate_null_values);
 };
 
 } // namespace duckdb
@@ -154944,8 +155220,7 @@ static void CreateDelimJoinConditions(LogicalDelimJoin &delim_join, vector<Corre
 		JoinCondition cond;
 		cond.left = make_unique<BoundColumnRefExpression>(col.name, col.type, col.binding);
 		cond.right = make_unique<BoundColumnRefExpression>(col.name, col.type, bindings[base_offset + i]);
-		cond.comparison = ExpressionType::COMPARE_EQUAL;
-		cond.null_values_are_equal = true;
+		cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
 		delim_join.conditions.push_back(move(cond));
 	}
 }
@@ -155036,7 +155311,7 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 		// LHS
 		delim_join->AddChild(move(root));
 		// RHS
-		FlattenDependentJoins flatten(binder, correlated_columns);
+		FlattenDependentJoins flatten(binder, correlated_columns, true);
 		flatten.DetectCorrelatedExpressions(plan.get());
 		auto dependent_join = flatten.PushDownDependentJoin(move(plan));
 
@@ -158922,6 +159197,10 @@ bool BoundAggregateExpression::Equals(const BaseExpression *other_p) const {
 	return true;
 }
 
+bool BoundAggregateExpression::PropagatesNullValues() const {
+	return !function.propagates_null_values ? false : Expression::PropagatesNullValues();
+}
+
 unique_ptr<Expression> BoundAggregateExpression::Copy() {
 	vector<unique_ptr<Expression>> new_children;
 	for (auto &child : children) {
@@ -159233,6 +159512,7 @@ bool BoundComparisonExpression::Equals(const BaseExpression *other_p) const {
 	if (!Expression::Equals(right.get(), other->right.get())) {
 		return false;
 	}
+
 	return true;
 }
 
@@ -159272,6 +159552,10 @@ bool BoundConjunctionExpression::Equals(const BaseExpression *other_p) const {
 	return ExpressionUtil::SetEquals(children, other->children);
 }
 
+bool BoundConjunctionExpression::PropagatesNullValues() const {
+	return false;
+}
+
 unique_ptr<Expression> BoundConjunctionExpression::Copy() {
 	auto copy = make_unique<BoundConjunctionExpression>(type);
 	for (auto &expr : children) {
@@ -159347,6 +159631,9 @@ string BoundFunctionExpression::ToString() const {
 	return FunctionExpression::ToString<BoundFunctionExpression, Expression>(*this, string(), function.name,
 	                                                                         is_operator);
 }
+bool BoundFunctionExpression::PropagatesNullValues() const {
+	return !function.propagates_null_values ? false : Expression::PropagatesNullValues();
+}
 
 hash_t BoundFunctionExpression::Hash() const {
 	hash_t result = Expression::Hash();
@@ -159536,6 +159823,11 @@ unique_ptr<Expression> BoundSubqueryExpression::Copy() {
 	throw SerializationException("Cannot copy BoundSubqueryExpression");
 }
 
+bool BoundSubqueryExpression::PropagatesNullValues() const {
+	// TODO this can be optimized further by checking the actual subquery node
+	return false;
+}
+
 } // namespace duckdb
 
 
@@ -159745,6 +160037,21 @@ bool Expression::HasSideEffects() const {
 	return has_side_effects;
 }
 
+bool Expression::PropagatesNullValues() const {
+	if (type == ExpressionType::OPERATOR_IS_NULL || type == ExpressionType::OPERATOR_IS_NOT_NULL ||
+	    type == ExpressionType::COMPARE_NOT_DISTINCT_FROM || type == ExpressionType::COMPARE_DISTINCT_FROM ||
+	    type == ExpressionType::CONJUNCTION_OR || type == ExpressionType::CONJUNCTION_AND) {
+		return false;
+	}
+	bool propagate_null_values = true;
+	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) {
+		if (!child.PropagatesNullValues()) {
+			propagate_null_values = false;
+		}
+	});
+	return propagate_null_values;
+}
+
 bool Expression::IsFoldable() const {
 	bool is_foldable = true;
 	ExpressionIterator::EnumerateChildren(*this, [&](const Expression &child) {
@@ -161250,7 +161557,8 @@ string IsNotNullFilter::ToString(const string &column_name) {
 namespace duckdb {
 
 unique_ptr<Expression> JoinCondition::CreateExpression(JoinCondition cond) {
-	return make_unique<BoundComparisonExpression>(cond.comparison, move(cond.left), move(cond.right));
+	auto bound_comparison = make_unique<BoundComparisonExpression>(cond.comparison, move(cond.left), move(cond.right));
+	return move(bound_comparison);
 }
 
 JoinSide JoinSide::CombineJoinSide(JoinSide left, JoinSide right) {
@@ -162513,8 +162821,9 @@ public:
 
 namespace duckdb {
 
-FlattenDependentJoins::FlattenDependentJoins(Binder &binder, const vector<CorrelatedColumnInfo> &correlated)
-    : binder(binder), correlated_columns(correlated) {
+FlattenDependentJoins::FlattenDependentJoins(Binder &binder, const vector<CorrelatedColumnInfo> &correlated,
+                                             bool any_join)
+    : binder(binder), correlated_columns(correlated), any_join(any_join) {
 	for (idx_t i = 0; i < correlated_columns.size(); i++) {
 		auto &col = correlated_columns[i];
 		correlated_map[col.binding] = i;
@@ -162543,7 +162852,8 @@ bool FlattenDependentJoins::DetectCorrelatedExpressions(LogicalOperator *op) {
 }
 
 unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoin(unique_ptr<LogicalOperator> plan) {
-	auto result = PushDownDependentJoinInternal(move(plan));
+	bool propagate_null_values = true;
+	auto result = PushDownDependentJoinInternal(move(plan), propagate_null_values);
 	if (!replacement_map.empty()) {
 		// check if we have to replace any COUNT aggregates into "CASE WHEN X IS NULL THEN 0 ELSE COUNT END"
 		RewriteCountAggregates aggr(replacement_map);
@@ -162552,7 +162862,23 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoin(unique_
 	return result;
 }
 
-unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal(unique_ptr<LogicalOperator> plan) {
+bool SubqueryDependentFilter(Expression *expr) {
+	if (expr->expression_class == ExpressionClass::BOUND_CONJUNCTION &&
+	    expr->GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
+		auto bound_conjuction = (BoundConjunctionExpression *)expr;
+		for (auto &child : bound_conjuction->children) {
+			if (SubqueryDependentFilter(child.get())) {
+				return true;
+			}
+		}
+	}
+	if (expr->expression_class == ExpressionClass::BOUND_SUBQUERY) {
+		return true;
+	}
+	return false;
+}
+unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal(unique_ptr<LogicalOperator> plan,
+                                                                                 bool &parent_propagate_null_values) {
 	// first check if the logical operator has correlated expressions
 	auto entry = has_correlated_expressions.find(plan.get());
 	D_ASSERT(entry != has_correlated_expressions.end());
@@ -162573,7 +162899,11 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 	case LogicalOperatorType::LOGICAL_FILTER: {
 		// filter
 		// first we flatten the dependent join in the child of the filter
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]));
+		for (auto &expr : plan->expressions) {
+			any_join |= SubqueryDependentFilter(expr.get());
+		}
+		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
+
 		// then we replace any correlated expressions with the corresponding entry in the correlated_map
 		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map);
 		rewriter.VisitOperator(*plan);
@@ -162582,7 +162912,11 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 	case LogicalOperatorType::LOGICAL_PROJECTION: {
 		// projection
 		// first we flatten the dependent join in the child of the projection
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]));
+		for (auto &expr : plan->expressions) {
+			parent_propagate_null_values &= expr->PropagatesNullValues();
+		}
+		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
+
 		// then we replace any correlated expressions with the corresponding entry in the correlated_map
 		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map);
 		rewriter.VisitOperator(*plan);
@@ -162603,7 +162937,10 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		auto &aggr = (LogicalAggregate &)*plan;
 		// aggregate and group by
 		// first we flatten the dependent join in the child of the projection
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]));
+		for (auto &expr : plan->expressions) {
+			parent_propagate_null_values &= expr->PropagatesNullValues();
+		}
+		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
 		// then we replace any correlated expressions with the corresponding entry in the correlated_map
 		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map);
 		rewriter.VisitOperator(*plan);
@@ -162620,11 +162957,18 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			// we have to perform a LEFT OUTER JOIN between the result of this aggregate and the delim scan
 			// FIXME: this does not always have to be a LEFT OUTER JOIN, depending on whether aggr.expressions return
 			// NULL or a value
-			auto left_outer_join = make_unique<LogicalComparisonJoin>(JoinType::LEFT);
+			unique_ptr<LogicalComparisonJoin> join = make_unique<LogicalComparisonJoin>(JoinType::INNER);
+			for (auto &aggr_exp : aggr.expressions) {
+				auto b_aggr_exp = (BoundAggregateExpression *)aggr_exp.get();
+				if (!b_aggr_exp->PropagatesNullValues() || any_join || !parent_propagate_null_values) {
+					join = make_unique<LogicalComparisonJoin>(JoinType::LEFT);
+					break;
+				}
+			}
 			auto left_index = binder.GenerateTableIndex();
 			auto delim_scan = make_unique<LogicalDelimGet>(left_index, delim_types);
-			left_outer_join->children.push_back(move(delim_scan));
-			left_outer_join->children.push_back(move(plan));
+			join->children.push_back(move(delim_scan));
+			join->children.push_back(move(plan));
 			for (idx_t i = 0; i < correlated_columns.size(); i++) {
 				JoinCondition cond;
 				cond.left =
@@ -162632,9 +162976,8 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 				cond.right = make_unique<BoundColumnRefExpression>(
 				    correlated_columns[i].type,
 				    ColumnBinding(aggr.group_index, (aggr.groups.size() - correlated_columns.size()) + i));
-				cond.comparison = ExpressionType::COMPARE_EQUAL;
-				cond.null_values_are_equal = true;
-				left_outer_join->conditions.push_back(move(cond));
+				cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
+				join->conditions.push_back(move(cond));
 			}
 			// for any COUNT aggregate we replace references to the column with: CASE WHEN COUNT(*) IS NULL THEN 0
 			// ELSE COUNT(*) END
@@ -162652,7 +162995,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			base_binding.table_index = left_index;
 			this->delim_offset = base_binding.column_index = 0;
 			this->data_offset = 0;
-			return move(left_outer_join);
+			return move(join);
 		} else {
 			// update the delim_index
 			base_binding.table_index = aggr.group_index;
@@ -162668,20 +163011,20 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		bool right_has_correlation = has_correlated_expressions.find(plan->children[1].get())->second;
 		if (!right_has_correlation) {
 			// only left has correlation: push into left
-			plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]));
+			plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
 			return plan;
 		}
 		if (!left_has_correlation) {
 			// only right has correlation: push into right
-			plan->children[1] = PushDownDependentJoinInternal(move(plan->children[1]));
+			plan->children[1] = PushDownDependentJoinInternal(move(plan->children[1]), parent_propagate_null_values);
 			return plan;
 		}
 		// both sides have correlation
 		// turn into an inner join
 		auto join = make_unique<LogicalComparisonJoin>(JoinType::INNER);
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]));
+		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
 		auto left_binding = this->base_binding;
-		plan->children[1] = PushDownDependentJoinInternal(move(plan->children[1]));
+		plan->children[1] = PushDownDependentJoinInternal(move(plan->children[1]), parent_propagate_null_values);
 		// add the correlated columns to the join conditions
 		for (idx_t i = 0; i < correlated_columns.size(); i++) {
 			JoinCondition cond;
@@ -162689,8 +163032,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			    correlated_columns[i].type, ColumnBinding(left_binding.table_index, left_binding.column_index + i));
 			cond.right = make_unique<BoundColumnRefExpression>(
 			    correlated_columns[i].type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
-			cond.comparison = ExpressionType::COMPARE_EQUAL;
-			cond.null_values_are_equal = true;
+			cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
 			join->conditions.push_back(move(cond));
 		}
 		join->children.push_back(move(plan->children[0]));
@@ -162709,26 +163051,30 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			// inner join
 			if (!right_has_correlation) {
 				// only left has correlation: push into left
-				plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]));
+				plan->children[0] =
+				    PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
 				return plan;
 			}
 			if (!left_has_correlation) {
 				// only right has correlation: push into right
-				plan->children[1] = PushDownDependentJoinInternal(move(plan->children[1]));
+				plan->children[1] =
+				    PushDownDependentJoinInternal(move(plan->children[1]), parent_propagate_null_values);
 				return plan;
 			}
 		} else if (join.join_type == JoinType::LEFT) {
 			// left outer join
 			if (!right_has_correlation) {
 				// only left has correlation: push into left
-				plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]));
+				plan->children[0] =
+				    PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
 				return plan;
 			}
 		} else if (join.join_type == JoinType::RIGHT) {
 			// left outer join
 			if (!left_has_correlation) {
 				// only right has correlation: push into right
-				plan->children[1] = PushDownDependentJoinInternal(move(plan->children[1]));
+				plan->children[1] =
+				    PushDownDependentJoinInternal(move(plan->children[1]), parent_propagate_null_values);
 				return plan;
 			}
 		} else if (join.join_type == JoinType::MARK) {
@@ -162736,7 +163082,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 				throw Exception("MARK join with correlation in RHS not supported");
 			}
 			// push the child into the LHS
-			plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]));
+			plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
 			// rewrite expressions in the join conditions
 			RewriteCorrelatedExpressions rewriter(base_binding, correlated_map);
 			rewriter.VisitOperator(*plan);
@@ -162746,9 +163092,9 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		}
 		// both sides have correlation
 		// push into both sides
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]));
+		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
 		auto left_binding = this->base_binding;
-		plan->children[1] = PushDownDependentJoinInternal(move(plan->children[1]));
+		plan->children[1] = PushDownDependentJoinInternal(move(plan->children[1]), parent_propagate_null_values);
 		auto right_binding = this->base_binding;
 		// NOTE: for OUTER JOINS it matters what the BASE BINDING is after the join
 		// for the LEFT OUTER JOIN, we want the LEFT side to be the base binding after we push
@@ -162769,8 +163115,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 				JoinCondition cond;
 				cond.left = move(left);
 				cond.right = move(right);
-				cond.comparison = ExpressionType::COMPARE_EQUAL;
-				cond.null_values_are_equal = true;
+				cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
 
 				auto &comparison_join = (LogicalComparisonJoin &)join;
 				comparison_join.conditions.push_back(move(cond));
@@ -162796,7 +163141,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		if (limit.limit) {
 			throw ParserException("Non-constant limit not supported in correlated subquery");
 		}
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]));
+		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
 		if (limit.limit_val == 0) {
 			// limit = 0 means we return zero columns here
 			return plan;
@@ -162811,7 +163156,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 	case LogicalOperatorType::LOGICAL_WINDOW: {
 		auto &window = (LogicalWindow &)*plan;
 		// push into children
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]));
+		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
 		// add the correlated columns to the PARTITION BY clauses in the Window
 		for (auto &expr : window.expressions) {
 			D_ASSERT(expr->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
@@ -162843,7 +163188,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 	case LogicalOperatorType::LOGICAL_EXPRESSION_GET: {
 		// expression get
 		// first we flatten the dependent join in the child
-		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]));
+		plan->children[0] = PushDownDependentJoinInternal(move(plan->children[0]), parent_propagate_null_values);
 		// then we replace any correlated expressions with the corresponding entry in the correlated_map
 		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map);
 		rewriter.VisitOperator(*plan);