duckdb 0.7.2-dev333.0 → 0.7.2-dev457.0

package/src/duckdb/ub_src_optimizer_rule.cpp

@@ -24,5 +24,7 @@
 
 #include "src/optimizer/rule/in_clause_simplification_rule.cpp"
 
+#include "src/optimizer/rule/ordered_aggregate_optimizer.cpp"
+
 #include "src/optimizer/rule/regex_optimizations.cpp"
 

package/src/duckdb/ub_src_planner_binder_expression.cpp

@@ -28,6 +28,8 @@
 
 #include "src/planner/binder/expression/bind_positional_reference_expression.cpp"
 
+#include "src/planner/binder/expression/bind_star_expression.cpp"
+
 #include "src/planner/binder/expression/bind_subquery_expression.cpp"
 
 #include "src/planner/binder/expression/bind_unnest_expression.cpp"

package/src/duckdb_node.hpp

@@ -198,7 +198,8 @@ struct TaskHolder {
 
 class Utils {
 public:
-	static Napi::Value CreateError(Napi::Env env, std::string msg);
+	static Napi::Object CreateError(Napi::Env env, duckdb::PreservedError &e);
+	static Napi::Object CreateError(Napi::Env env, std::string msg);
 	static bool OtherIsInt(Napi::Number source);
 
 	template <class T>

package/src/statement.cpp

@@ -78,7 +78,7 @@ struct PrepareTask : public Task {
 
 		auto cb = callback.Value();
 		if (statement.statement->HasError()) {
-			cb.MakeCallback(statement.Value(), {Utils::CreateError(env, statement.statement->error.Message())});
+			cb.MakeCallback(statement.Value(), {Utils::CreateError(env, statement.statement->error)});
 			return;
 		}
 		cb.MakeCallback(statement.Value(), {env.Null(), statement.Value()});
@@ -282,11 +282,11 @@ struct RunPreparedTask : public Task {
 			return;
 		}
 		if (statement.statement->HasError()) {
-			cb.MakeCallback(statement.Value(), {Utils::CreateError(env, statement.statement->GetError())});
+			cb.MakeCallback(statement.Value(), {Utils::CreateError(env, statement.statement->GetErrorObject())});
 			return;
 		}
 		if (result->HasError()) {
-			cb.MakeCallback(statement.Value(), {Utils::CreateError(env, result->GetError())});
+			cb.MakeCallback(statement.Value(), {Utils::CreateError(env, result->GetErrorObject())});
 			return;
 		}
 
@@ -427,9 +427,9 @@ struct RunQueryTask : public Task {
 		if (!statement.statement) {
 			deferred.Reject(Utils::CreateError(env, "statement was finalized"));
 		} else if (statement.statement->HasError()) {
-			deferred.Reject(Utils::CreateError(env, statement.statement->GetError()));
+			deferred.Reject(Utils::CreateError(env, statement.statement->GetErrorObject()));
 		} else if (result->HasError()) {
-			deferred.Reject(Utils::CreateError(env, result->GetError()));
+			deferred.Reject(Utils::CreateError(env, result->GetErrorObject()));
 		} else {
 			auto db = statement.connection_ref->database_ref->Value();
 			auto query_result = QueryResult::constructor.New({db});

package/src/utils.cpp

@@ -12,11 +12,24 @@ bool Utils::OtherIsInt(Napi::Number source) {
 	}
 }
 
-Napi::Value Utils::CreateError(Napi::Env env, std::string msg) {
+static void SetString(Napi::Object &obj, const std::string &key, const std::string &value) {
+	obj.Set(Napi::String::New(obj.Env(), key), Napi::String::New(obj.Env(), value));
+}
+
+Napi::Object Utils::CreateError(Napi::Env env, duckdb::PreservedError &error) {
+	auto obj = Utils::CreateError(env, error.Message());
+
+	SetString(obj, "errorType", duckdb::Exception::ExceptionTypeToString(error.Type()));
+
+	return obj;
+}
+
+Napi::Object Utils::CreateError(Napi::Env env, std::string msg) {
 	auto err = Napi::Error::New(env, Napi::String::New(env, msg).Utf8Value()).Value();
 	Napi::Object obj = err.As<Napi::Object>();
 	obj.Set(Napi::String::New(env, "errno"), Napi::Number::New(env, Database::DUCKDB_NODEJS_ERROR));
-	obj.Set(Napi::String::New(env, "code"), Napi::String::New(env, "DUCKDB_NODEJS_ERROR"));
+	SetString(obj, "code", "DUCKDB_NODEJS_ERROR");
+	SetString(obj, "errorType", "Invalid");
 
 	return obj;
 }

package/test/syntax_error.test.ts

@@ -8,8 +8,10 @@ describe('exec', function() {
     });
 
     it("doesn't crash on a syntax error", function(done) {
-        db.exec("syntax error", function(err: null | Error) {
+        db.exec("syntax error", function(err: null | duckdb.DuckDbError) {
             assert.notEqual(err, null, "Expected an error")
+            assert.equal(err?.errorType, 'Parser');
+            assert.ok(err?.message.startsWith('Parser Error: syntax error at or near "syntax"'))
             done();
         });
     });