duckdb 0.3.2-dev656.0 → 0.3.2-dev668.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.2-dev656.0",
+  "version": "0.3.2-dev668.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -24915,8 +24915,8 @@ static void GatherNestedVector(Vector &rows, const SelectionVector &row_sel, Vec
 	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
 
 	// Build the gather locations
-	data_ptr_t data_locations[STANDARD_VECTOR_SIZE];
-	data_ptr_t mask_locations[STANDARD_VECTOR_SIZE];
+	auto data_locations = unique_ptr<data_ptr_t[]>(new data_ptr_t[count]);
+	auto mask_locations = unique_ptr<data_ptr_t[]>(new data_ptr_t[count]);
 	for (idx_t i = 0; i < count; i++) {
 		auto row_idx = row_sel.get_index(i);
 		mask_locations[i] = ptrs[row_idx];
@@ -24924,7 +24924,7 @@ static void GatherNestedVector(Vector &rows, const SelectionVector &row_sel, Vec
 	}
 
 	// Deserialise into the selected locations
-	RowOperations::HeapGather(col, count, col_sel, col_no, data_locations, mask_locations);
+	RowOperations::HeapGather(col, count, col_sel, col_no, data_locations.get(), mask_locations.get());
 }
 
 void RowOperations::Gather(Vector &rows, const SelectionVector &row_sel, Vector &col, const SelectionVector &col_sel,
@@ -37647,6 +37647,19 @@ T Value::GetValueInternal() const {
 		return Cast::Operation<interval_t, T>(value_.interval);
 	case LogicalTypeId::DECIMAL:
 		return CastAs(LogicalType::DOUBLE).GetValueInternal<T>();
+	case LogicalTypeId::ENUM: {
+		switch (type_.InternalType()) {
+		case PhysicalType::UINT8:
+			return Cast::Operation<uint8_t, T>(value_.utinyint);
+		case PhysicalType::UINT16:
+			return Cast::Operation<uint16_t, T>(value_.usmallint);
+		case PhysicalType::UINT32:
+			return Cast::Operation<uint32_t, T>(value_.uinteger);
+		default:
+			throw InternalException("Invalid Internal Type for ENUMs");
+		}
+	}
+
 	default:
 		throw NotImplementedException("Unimplemented type \"%s\" for GetValue()", type_.ToString());
 	}
@@ -65497,6 +65510,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalChunkGet &
 
 
 
+
 namespace duckdb {
 
 static bool CanPlanIndexJoin(Transaction &transaction, TableScanBindData *bind_data, PhysicalTableScan &scan) {
@@ -65516,6 +65530,30 @@ static bool CanPlanIndexJoin(Transaction &transaction, TableScanBindData *bind_d
 	return true;
 }
 
+bool ExtractNumericValue(Value val, int64_t &result) {
+	if (!val.type().IsIntegral()) {
+		switch (val.type().InternalType()) {
+		case PhysicalType::INT16:
+			result = val.GetValueUnsafe<int16_t>();
+			break;
+		case PhysicalType::INT32:
+			result = val.GetValueUnsafe<int32_t>();
+			break;
+		case PhysicalType::INT64:
+			result = val.GetValueUnsafe<int64_t>();
+			break;
+		default:
+			return false;
+		}
+	} else {
+		if (!val.TryCastAs(LogicalType::BIGINT)) {
+			return false;
+		}
+		result = val.GetValue<int64_t>();
+	}
+	return true;
+}
+
 void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &join_state) {
 	// we only do this optimization for inner joins
 	if (op.join_type != JoinType::INNER) {
@@ -65548,7 +65586,14 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 	if (stats_build->min.is_null || stats_build->max.is_null) {
 		return;
 	}
-	auto build_range = stats_build->max - stats_build->min; // Join Keys Range
+	int64_t min_value, max_value;
+	if (!ExtractNumericValue(stats_build->min, min_value) || !ExtractNumericValue(stats_build->max, max_value)) {
+		return;
+	}
+	int64_t build_range;
+	if (!TrySubtractOperator::Operation(max_value, min_value, build_range)) {
+		return;
+	}
 
 	// Fill join_stats for invisible join
 	auto stats_probe = reinterpret_cast<NumericStatistics *>(op.join_stats[1].get()); // rhs stats
@@ -65560,26 +65605,7 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 	join_state.build_min = stats_build->min;
 	join_state.build_max = stats_build->max;
 	join_state.estimated_cardinality = op.estimated_cardinality;
-	if (!build_range.type().IsIntegral()) {
-		switch (build_range.type().InternalType()) {
-		case PhysicalType::INT16:
-			join_state.build_range = build_range.value_.smallint;
-			break;
-		case PhysicalType::INT32:
-			join_state.build_range = build_range.value_.integer;
-			break;
-		case PhysicalType::INT64:
-			join_state.build_range = build_range.value_.bigint;
-			break;
-		case PhysicalType::INT128:
-			// we do not support hugeint for this optimization
-			return;
-		default:
-			throw InternalException("Invalid Physical Type for Decimals");
-		}
-	} else {
-		join_state.build_range = build_range.GetValue<idx_t>(); // cast integer types into idx_t
-	}
+	join_state.build_range = build_range;
 	if (join_state.build_range > MAX_BUILD_SIZE || stats_probe->max.is_null || stats_probe->min.is_null) {
 		return;
 	}
@@ -77526,6 +77552,7 @@ void BuiltinFunctions::Initialize() {
 	RegisterRegressiveAggregates();
 
 	RegisterDateFunctions();
+	RegisterEnumFunctions();
 	RegisterGenericFunctions();
 	RegisterMathFunctions();
 	RegisterOperators();
@@ -82030,6 +82057,163 @@ void BuiltinFunctions::RegisterDateFunctions() {
 	Register<ToIntervalFun>();
 }
 
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/scalar/enum_functions.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct EnumFirst {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct EnumLast {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct EnumRange {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct EnumRangeBoundary {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+static void EnumFirstFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.GetTypes().size() == 1);
+	auto &enum_vector = EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
+	auto val = Value(enum_vector.GetValue(0));
+	result.Reference(val);
+}
+
+static void EnumLastFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.GetTypes().size() == 1);
+	auto enum_size = EnumType::GetSize(input.GetTypes()[0]);
+	auto &enum_vector = EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
+	auto val = Value(enum_vector.GetValue(enum_size - 1));
+	result.Reference(val);
+}
+
+static void EnumRangeFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.GetTypes().size() == 1);
+	auto enum_size = EnumType::GetSize(input.GetTypes()[0]);
+	auto &enum_vector = EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
+	vector<Value> enum_values;
+	for (idx_t i = 0; i < enum_size; i++) {
+		enum_values.emplace_back(enum_vector.GetValue(i));
+	}
+	auto val = Value::LIST(enum_values);
+	result.Reference(val);
+}
+
+static void EnumRangeBoundaryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.GetTypes().size() == 2);
+	idx_t start, end;
+	auto first_param = input.GetValue(0, 0);
+	auto second_param = input.GetValue(1, 0);
+
+	auto &enum_vector = first_param.is_null ? EnumType::GetValuesInsertOrder(input.GetTypes()[1])
+	                                        : EnumType::GetValuesInsertOrder(input.GetTypes()[0]);
+
+	if (first_param.is_null) {
+		start = 0;
+	} else {
+		start = first_param.GetValue<uint32_t>();
+	}
+	if (second_param.is_null) {
+		end = EnumType::GetSize(input.GetTypes()[0]);
+	} else {
+		end = second_param.GetValue<uint32_t>() + 1;
+	}
+	vector<Value> enum_values;
+	for (idx_t i = start; i < end; i++) {
+		enum_values.emplace_back(enum_vector.GetValue(i));
+	}
+	Value val;
+	if (enum_values.empty()) {
+		val = Value::EMPTYLIST(LogicalType::VARCHAR);
+	} else {
+		val = Value::LIST(enum_values);
+	}
+	result.Reference(val);
+}
+
+unique_ptr<FunctionData> BindEnumFunction(ClientContext &context, ScalarFunction &bound_function,
+                                          vector<unique_ptr<Expression>> &arguments) {
+	if (arguments[0]->return_type.id() != LogicalTypeId::ENUM) {
+		throw BinderException("This function needs an ENUM as an argument");
+	}
+	return nullptr;
+}
+
+unique_ptr<FunctionData> BindEnumRangeBoundaryFunction(ClientContext &context, ScalarFunction &bound_function,
+                                                       vector<unique_ptr<Expression>> &arguments) {
+	if (arguments[0]->return_type.id() != LogicalTypeId::ENUM && arguments[0]->return_type != LogicalType::SQLNULL) {
+		throw BinderException("This function needs an ENUM as an argument");
+	}
+	if (arguments[1]->return_type.id() != LogicalTypeId::ENUM && arguments[1]->return_type != LogicalType::SQLNULL) {
+		throw BinderException("This function needs an ENUM as an argument");
+	}
+	if (arguments[0]->return_type == LogicalType::SQLNULL && arguments[1]->return_type == LogicalType::SQLNULL) {
+		throw BinderException("This function needs an ENUM as an argument");
+	}
+	if (arguments[0]->return_type.id() == LogicalTypeId::ENUM &&
+	    arguments[1]->return_type.id() == LogicalTypeId::ENUM &&
+	    arguments[0]->return_type != arguments[1]->return_type) {
+
+		throw BinderException("The parameters need to link to ONLY one enum OR be NULL ");
+	}
+	return nullptr;
+}
+
+void EnumFirst::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ScalarFunction("enum_first", {LogicalType::ANY}, LogicalType::VARCHAR, EnumFirstFunction, false,
+	                               BindEnumFunction));
+}
+
+void EnumLast::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ScalarFunction("enum_last", {LogicalType::ANY}, LogicalType::VARCHAR, EnumLastFunction, false,
+	                               BindEnumFunction));
+}
+
+void EnumRange::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ScalarFunction("enum_range", {LogicalType::ANY}, LogicalType::LIST(LogicalType::VARCHAR),
+	                               EnumRangeFunction, false, BindEnumFunction));
+}
+
+void EnumRangeBoundary::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ScalarFunction("enum_range_boundary", {LogicalType::ANY, LogicalType::ANY},
+	                               LogicalType::LIST(LogicalType::VARCHAR), EnumRangeBoundaryFunction, false,
+	                               BindEnumRangeBoundaryFunction));
+}
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+void BuiltinFunctions::RegisterEnumFunctions() {
+	Register<EnumFirst>();
+	Register<EnumLast>();
+	Register<EnumRange>();
+	Register<EnumRangeBoundary>();
+}
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -145290,8 +145474,10 @@ BindResult ExpressionBinder::BindExpression(BetweenExpression &expr, idx_t depth
 		lower.expr = PushCollation(context, move(lower.expr), collation, false);
 		upper.expr = PushCollation(context, move(upper.expr), collation, false);
 	}
-	if (!input.expr->HasSideEffects() && !input.expr->HasParameter()) {
-		// the expression does not have side effects: create two comparisons
+	if (!input.expr->HasSideEffects() && !input.expr->HasParameter() && !input.expr->HasSubquery()) {
+		// the expression does not have side effects and can be copied: create two comparisons
+		// the reason we do this is that individual comparisons are easier to handle in optimizers
+		// if both comparisons remain they will be folded together again into a single BETWEEN in the optimizer
 		auto left_compare = make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_GREATERTHANOREQUALTO,
 		                                                           input.expr->Copy(), move(lower.expr));
 		auto right_compare = make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_LESSTHANOREQUALTO,

package/src/duckdb.hpp

@@ -10,8 +10,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #pragma once
 #define DUCKDB_AMALGAMATION 1
-#define DUCKDB_SOURCE_ID "52c01882a"
-#define DUCKDB_VERSION "0.3.2-dev656"
+#define DUCKDB_SOURCE_ID "a5e6d9bd4"
+#define DUCKDB_VERSION "0.3.2-dev668"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -5742,6 +5742,7 @@ private:
 
 	// scalar functions
 	void RegisterDateFunctions();
+	void RegisterEnumFunctions();
 	void RegisterGenericFunctions();
 	void RegisterMathFunctions();
 	void RegisterOperators();