duckdb 0.3.2-dev281.0 → 0.3.2-dev296.0

package/package.json

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

package/src/duckdb.cpp

@@ -11086,42 +11086,53 @@ string LogicalOperatorToString(LogicalOperatorType type) {
 
 
 
+
 namespace duckdb {
 
+struct DefaultOptimizerType {
+	const char *name;
+	OptimizerType type;
+};
+
+static DefaultOptimizerType internal_optimizer_types[] = {
+    {"expression_rewriter", OptimizerType::EXPRESSION_REWRITER},
+    {"filter_pullup", OptimizerType::FILTER_PULLUP},
+    {"filter_pushdown", OptimizerType::FILTER_PUSHDOWN},
+    {"regex_range", OptimizerType::REGEX_RANGE},
+    {"in_clause", OptimizerType::IN_CLAUSE},
+    {"join_order", OptimizerType::JOIN_ORDER},
+    {"deliminator", OptimizerType::DELIMINATOR},
+    {"unused_columns", OptimizerType::UNUSED_COLUMNS},
+    {"statistics_propagation", OptimizerType::STATISTICS_PROPAGATION},
+    {"common_subexpressions", OptimizerType::COMMON_SUBEXPRESSIONS},
+    {"common_aggregate", OptimizerType::COMMON_AGGREGATE},
+    {"column_lifetime", OptimizerType::COLUMN_LIFETIME},
+    {"top_n", OptimizerType::TOP_N},
+    {"reorder_filter", OptimizerType::REORDER_FILTER},
+    {nullptr, OptimizerType::INVALID}};
+
 string OptimizerTypeToString(OptimizerType type) {
-	switch (type) {
-	case OptimizerType::EXPRESSION_REWRITER:
-		return "expression_rewriter";
-	case OptimizerType::FILTER_PULLUP:
-		return "filter_pullup";
-	case OptimizerType::FILTER_PUSHDOWN:
-		return "filter_pushdown";
-	case OptimizerType::REGEX_RANGE:
-		return "regex_range";
-	case OptimizerType::IN_CLAUSE:
-		return "in_clause";
-	case OptimizerType::JOIN_ORDER:
-		return "join_order";
-	case OptimizerType::DELIMINATOR:
-		return "deliminator";
-	case OptimizerType::UNUSED_COLUMNS:
-		return "unused_columns";
-	case OptimizerType::STATISTICS_PROPAGATION:
-		return "statistics_propagation";
-	case OptimizerType::COMMON_SUBEXPRESSIONS:
-		return "common_subexpressions";
-	case OptimizerType::COMMON_AGGREGATE:
-		return "common_aggregate";
-	case OptimizerType::COLUMN_LIFETIME:
-		return "column_lifetime";
-	case OptimizerType::TOP_N:
-		return "top_n";
-	case OptimizerType::REORDER_FILTER:
-		return "reorder_filter";
-	case OptimizerType::INVALID: // LCOV_EXCL_START
-		break;
+	for (idx_t i = 0; internal_optimizer_types[i].name; i++) {
+		if (internal_optimizer_types[i].type == type) {
+			return internal_optimizer_types[i].name;
+		}
 	}
-	return "INVALID"; // LCOV_EXCL_STOP
+	throw InternalException("Invalid optimizer type");
+}
+
+OptimizerType OptimizerTypeFromString(const string &str) {
+	for (idx_t i = 0; internal_optimizer_types[i].name; i++) {
+		if (internal_optimizer_types[i].name == str) {
+			return internal_optimizer_types[i].type;
+		}
+	}
+	// optimizer not found, construct candidate list
+	vector<string> optimizer_names;
+	for (idx_t i = 0; internal_optimizer_types[i].name; i++) {
+		optimizer_names.emplace_back(internal_optimizer_types[i].name);
+	}
+	throw ParserException("Optimizer type \"%s\" not recognized\n%s", str,
+	                      StringUtil::CandidatesErrorMessage(optimizer_names, str, "Candidate optimizers"));
 }
 
 } // namespace duckdb
@@ -32743,6 +32754,12 @@ string StringUtil::CandidatesMessage(const vector<string> &candidates, const str
 	return result_str;
 }
 
+string StringUtil::CandidatesErrorMessage(const vector<string> &strings, const string &target,
+                                          const string &message_prefix, idx_t n) {
+	auto closest_strings = StringUtil::TopNLevenshtein(strings, target, n);
+	return StringUtil::CandidatesMessage(closest_strings, message_prefix);
+}
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -57797,9 +57814,9 @@ void PhysicalSet::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSou
 			for (auto &entry : config.extension_parameters) {
 				potential_names.push_back(entry.first);
 			}
-			auto closest_settings = StringUtil::TopNLevenshtein(potential_names, name);
+
 			throw CatalogException("unrecognized configuration parameter \"%s\"\n%s", name,
-			                       StringUtil::CandidatesMessage(closest_settings, "Did you mean"));
+			                       StringUtil::CandidatesErrorMessage(potential_names, name, "Did you mean"));
 		}
 		//! it is!
 		auto &extension_option = entry->second;
@@ -88766,6 +88783,7 @@ struct CurrvalFun {
 
 
 
+
 namespace duckdb {
 
 struct NextvalBindData : public FunctionData {
@@ -88798,9 +88816,12 @@ struct NextSequenceValueOperator {
 	static int64_t Operation(Transaction &transaction, SequenceCatalogEntry *seq) {
 		lock_guard<mutex> seqlock(seq->lock);
 		int64_t result;
+		result = seq->counter;
+		bool overflow = !TryAddOperator::Operation(seq->counter, seq->increment, seq->counter);
 		if (seq->cycle) {
-			result = seq->counter;
-			seq->counter += seq->increment;
+			if (overflow) {
+				throw SequenceException("overflow in sequence");
+			}
 			if (result < seq->min_value) {
 				result = seq->max_value;
 				seq->counter = seq->max_value + seq->increment;
@@ -88809,13 +88830,11 @@ struct NextSequenceValueOperator {
 				seq->counter = seq->min_value + seq->increment;
 			}
 		} else {
-			result = seq->counter;
-			seq->counter += seq->increment;
-			if (result < seq->min_value) {
+			if (result < seq->min_value || (overflow && seq->increment < 0)) {
 				throw SequenceException("nextval: reached minimum value of sequence \"%s\" (%lld)", seq->name,
 				                        seq->min_value);
 			}
-			if (result > seq->max_value) {
+			if (result > seq->max_value || overflow) {
 				throw SequenceException("nextval: reached maximum value of sequence \"%s\" (%lld)", seq->name,
 				                        seq->max_value);
 			}
@@ -103322,6 +103341,14 @@ struct DefaultNullOrderSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct DisabledOptimizersSetting {
+	static constexpr const char *Name = "disabled_optimizers";
+	static constexpr const char *Description = "DEBUG SETTING: disable a specific set of optimizers (comma separated)";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct EnableExternalAccessSetting {
 	static constexpr const char *Name = "enable_external_access";
 	static constexpr const char *Description =
@@ -103498,6 +103525,7 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting
                                                  DUCKDB_GLOBAL_LOCAL(DefaultCollationSetting),
                                                  DUCKDB_GLOBAL(DefaultOrderSetting),
                                                  DUCKDB_GLOBAL(DefaultNullOrderSetting),
+                                                 DUCKDB_GLOBAL(DisabledOptimizersSetting),
                                                  DUCKDB_GLOBAL(EnableExternalAccessSetting),
                                                  DUCKDB_GLOBAL(EnableObjectCacheSetting),
                                                  DUCKDB_LOCAL(EnableProfilingSetting),
@@ -115955,6 +115983,35 @@ Value DefaultNullOrderSetting::GetSetting(ClientContext &context) {
 	}
 }
 
+//===--------------------------------------------------------------------===//
+// Disabled Optimizer
+//===--------------------------------------------------------------------===//
+void DisabledOptimizersSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
+	auto list = StringUtil::Split(input.ToString(), ",");
+	set<OptimizerType> disabled_optimizers;
+	for (auto &entry : list) {
+		auto param = StringUtil::Lower(entry);
+		StringUtil::Trim(param);
+		if (param.empty()) {
+			continue;
+		}
+		disabled_optimizers.insert(OptimizerTypeFromString(param));
+	}
+	config.disabled_optimizers = move(disabled_optimizers);
+}
+
+Value DisabledOptimizersSetting::GetSetting(ClientContext &context) {
+	auto &config = DBConfig::GetConfig(context);
+	string result;
+	for (auto &optimizer : config.disabled_optimizers) {
+		if (!result.empty()) {
+			result += ",";
+		}
+		result += OptimizerTypeToString(optimizer);
+	}
+	return Value(result);
+}
+
 //===--------------------------------------------------------------------===//
 // Enable External Access
 //===--------------------------------------------------------------------===//
@@ -116723,6 +116780,9 @@ void CommonSubExpressionOptimizer::CountExpressions(Expression &expr, CSEReplace
 	case ExpressionClass::BOUND_COLUMN_REF:
 	case ExpressionClass::BOUND_CONSTANT:
 	case ExpressionClass::BOUND_PARAMETER:
+	// skip conjunctions and case, since short-circuiting might be incorrectly disabled otherwise
+	case ExpressionClass::BOUND_CONJUNCTION:
+	case ExpressionClass::BOUND_CASE:
 		return;
 	default:
 		break;
@@ -116762,7 +116822,9 @@ void CommonSubExpressionOptimizer::PerformCSEReplacement(unique_ptr<Expression>
 		return;
 	}
 	// check if this child is eligible for CSE elimination
-	if (state.expression_count.find(&expr) != state.expression_count.end()) {
+	bool can_cse = expr.expression_class != ExpressionClass::BOUND_CONJUNCTION &&
+	               expr.expression_class != ExpressionClass::BOUND_CASE;
+	if (can_cse && state.expression_count.find(&expr) != state.expression_count.end()) {
 		auto &node = state.expression_count[&expr];
 		if (node.count > 1) {
 			// this expression occurs more than once! push it into the projection
@@ -123053,7 +123115,7 @@ unique_ptr<Expression> InClauseSimplificationRule::Apply(LogicalOperator &op, ve
 	}
 	//! Here we check if we can apply the expression on the constant side
 	auto target_type = cast_expression->source_type();
-	if (!BoundCastExpression::CastIsInvertible(target_type, cast_expression->return_type)) {
+	if (!BoundCastExpression::CastIsInvertible(cast_expression->return_type, target_type)) {
 		return nullptr;
 	}
 	vector<unique_ptr<BoundConstantExpression>> cast_list;

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 "b56295f32"
-#define DUCKDB_VERSION "0.3.2-dev281"
+#define DUCKDB_SOURCE_ID "5dc59692d"
+#define DUCKDB_VERSION "0.3.2-dev296"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -9863,7 +9863,13 @@ public:
 	                                                 idx_t threshold = 5);
 	DUCKDB_API static string CandidatesMessage(const vector<string> &candidates,
 	                                           const string &candidate = "Candidate bindings");
+
+	//! Generate an error message in the form of "{message_prefix}: nearest_string, nearest_string2, ...
+	//! Equivalent to calling TopNLevenshtein followed by CandidatesMessage
+	DUCKDB_API static string CandidatesErrorMessage(const vector<string> &strings, const string &target,
+	                                                const string &message_prefix, idx_t n = 5);
 };
+
 } // namespace duckdb
 
 
@@ -9976,6 +9982,7 @@ enum class OptimizerType : uint32_t {
 };
 
 string OptimizerTypeToString(OptimizerType type);
+OptimizerType OptimizerTypeFromString(const string &str);
 
 } // namespace duckdb