duckdb 0.7.2-dev329.0 → 0.7.2-dev402.0

package/binding.gyp

@@ -230,6 +230,7 @@
                 "src/duckdb/extension/icu/./icu-datefunc.cpp", 
                 "src/duckdb/extension/icu/./icu-extension.cpp", 
                 "src/duckdb/extension/icu/./icu-makedate.cpp", 
+                "src/duckdb/extension/icu/./icu-list-range.cpp", 
                 "src/duckdb/extension/icu/./icu-timezone.cpp", 
                 "src/duckdb/extension/icu/./icu-datesub.cpp", 
                 "src/duckdb/extension/icu/./icu-timebucket.cpp", 

package/lib/duckdb.d.ts

@@ -4,12 +4,54 @@
  * on Node.JS API
  */
 
+export type ExceptionType =
+    | "Invalid"          // invalid type
+    | "Out of Range"     // value out of range error
+    | "Conversion"       // conversion/casting error
+    | "Unknown Type"     // unknown type
+    | "Decimal"          // decimal related
+    | "Mismatch Type"    // type mismatch
+    | "Divide by Zero"   // divide by 0
+    | "Object Size"      // object size exceeded
+    | "Invalid type"     // incompatible for operation
+    | "Serialization"    // serialization
+    | "TransactionContext" // transaction management
+    | "Not implemented"  // method not implemented
+    | "Expression"       // expression parsing
+    | "Catalog"          // catalog related
+    | "Parser"           // parser related
+    | "Binder"           // binder related
+    | "Planner"          // planner related
+    | "Scheduler"        // scheduler related
+    | "Executor"         // executor related
+    | "Constraint"       // constraint related
+    | "Index"            // index related
+    | "Stat"             // stat related
+    | "Connection"       // connection related
+    | "Syntax"           // syntax related
+    | "Settings"         // settings related
+    | "Optimizer"        // optimizer related
+    | "NullPointer"      // nullptr exception
+    | "IO"               // IO exception
+    | "INTERRUPT"        // interrupt
+    | "FATAL"            // Fatal exceptions are non-recoverable and render the entire DB in an unusable state
+    | "INTERNAL"         // Internal exceptions indicate something went wrong internally (i.e. bug in the code base)
+    | "Invalid Input"    // Input or arguments error
+    | "Out of Memory"    // out of memory
+    | "Permission"       // insufficient permissions
+    | "Parameter Not Resolved" // parameter types could not be resolved
+    | "Parameter Not Allowed"  // parameter types not allowed
+    | "Dependency"       // dependency
+    | "Unknown"
+    ;
+
 /**
  * Standard error shape for DuckDB errors
  */
 export interface DuckDbError extends Error {
   errno: -1; // value of ERROR
   code: 'DUCKDB_NODEJS_ERROR';
+  errorType: ExceptionType;
 }
 
 type Callback<T> = (err: DuckDbError | null, res: T) => void;

package/package.json

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

package/src/connection.cpp

@@ -388,8 +388,7 @@ struct ExecTask : public Task {
 	void Callback() override {
 		auto env = object.Env();
 		Napi::HandleScope scope(env);
-		callback.Value().MakeCallback(object.Value(),
-		                              {success ? env.Null() : Utils::CreateError(env, error.Message())});
+		callback.Value().MakeCallback(object.Value(), {success ? env.Null() : Utils::CreateError(env, error)});
 	};
 
 	std::string sql;

package/src/database.cpp

@@ -73,7 +73,7 @@ struct OpenTask : public Task {
 
 		std::vector<napi_value> args;
 		if (!success) {
-			args.push_back(Utils::CreateError(env, error.Message()));
+			args.push_back(Utils::CreateError(env, error));
 		} else {
 			args.push_back(env.Null());
 		}

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

@@ -13,6 +13,7 @@
 #include "include/icu-datesub.hpp"
 #include "include/icu-datetrunc.hpp"
 #include "include/icu-makedate.hpp"
+#include "include/icu-list-range.hpp"
 #include "include/icu-table-range.hpp"
 #include "include/icu-strptime.hpp"
 #include "include/icu-timebucket.hpp"
@@ -268,6 +269,7 @@ void ICUExtension::Load(DuckDB &db) {
 	RegisterICUDateTruncFunctions(*con.context);
 	RegisterICUMakeDateFunctions(*con.context);
 	RegisterICUTableRangeFunctions(*con.context);
+	RegisterICUListRangeFunctions(*con.context);
 	RegisterICUStrptimeFunctions(*con.context);
 	RegisterICUTimeBucketFunctions(*con.context);
 	RegisterICUTimeZoneFunctions(*con.context);

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

@@ -0,0 +1,207 @@
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/types/interval.hpp"
+#include "duckdb/common/types/timestamp.hpp"
+#include "duckdb/common/types/vector.hpp"
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/function/scalar_function.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
+#include "include/icu-datefunc.hpp"
+
+namespace duckdb {
+
+struct ICUListRange : public ICUDateFunc {
+	template <bool INCLUSIVE_BOUND>
+	class RangeInfoStruct {
+	public:
+		explicit RangeInfoStruct(DataChunk &args_p) : args(args_p) {
+			if (args.ColumnCount() == 3) {
+				args.data[0].ToUnifiedFormat(args.size(), vdata[0]);
+				args.data[1].ToUnifiedFormat(args.size(), vdata[1]);
+				args.data[2].ToUnifiedFormat(args.size(), vdata[2]);
+			} else {
+				throw InternalException("Unsupported number of parameters for range");
+			}
+		}
+
+		bool RowIsValid(idx_t row_idx) {
+			for (idx_t i = 0; i < args.ColumnCount(); i++) {
+				auto idx = vdata[i].sel->get_index(row_idx);
+				if (!vdata[i].validity.RowIsValid(idx)) {
+					return false;
+				}
+			}
+			return true;
+		}
+
+		timestamp_t StartListValue(idx_t row_idx) {
+			auto data = (timestamp_t *)vdata[0].data;
+			auto idx = vdata[0].sel->get_index(row_idx);
+			return data[idx];
+		}
+
+		timestamp_t EndListValue(idx_t row_idx) {
+			auto data = (timestamp_t *)vdata[1].data;
+			auto idx = vdata[1].sel->get_index(row_idx);
+			return data[idx];
+		}
+
+		interval_t ListIncrementValue(idx_t row_idx) {
+			auto data = (interval_t *)vdata[2].data;
+			auto idx = vdata[2].sel->get_index(row_idx);
+			return data[idx];
+		}
+
+		void GetListValues(idx_t row_idx, timestamp_t &start_value, timestamp_t &end_value,
+		                   interval_t &increment_value) {
+			start_value = StartListValue(row_idx);
+			end_value = EndListValue(row_idx);
+			increment_value = ListIncrementValue(row_idx);
+		}
+
+		uint64_t ListLength(idx_t row_idx, icu::Calendar *calendar) {
+			timestamp_t start_value;
+			timestamp_t end_value;
+			interval_t increment_value;
+			GetListValues(row_idx, start_value, end_value, increment_value);
+			return ListLength(start_value, end_value, increment_value, INCLUSIVE_BOUND, calendar);
+		}
+
+		void Increment(timestamp_t &input, interval_t increment, icu::Calendar *calendar) {
+			input = Add(calendar, input, increment);
+		}
+
+	private:
+		DataChunk &args;
+		UnifiedVectorFormat vdata[3];
+
+		uint64_t ListLength(timestamp_t start_value, timestamp_t end_value, interval_t increment_value,
+		                    bool inclusive_bound, icu::Calendar *calendar) {
+			bool is_positive = increment_value.months > 0 || increment_value.days > 0 || increment_value.micros > 0;
+			bool is_negative = increment_value.months < 0 || increment_value.days < 0 || increment_value.micros < 0;
+			if (!is_negative && !is_positive) {
+				// interval is 0: no result
+				return 0;
+			}
+			// We don't allow infinite bounds because they generate errors or infinite loops
+			if (!Timestamp::IsFinite(start_value) || !Timestamp::IsFinite(end_value)) {
+				throw InvalidInputException("Interval infinite bounds not supported");
+			}
+
+			if (is_negative && is_positive) {
+				// we don't allow a mix of
+				throw InvalidInputException("Interval with mix of negative/positive entries not supported");
+			}
+			if (start_value > end_value && is_positive) {
+				return 0;
+			}
+			if (start_value < end_value && is_negative) {
+				return 0;
+			}
+			int64_t total_values = 0;
+			if (is_negative) {
+				// negative interval, start_value is going down
+				while (inclusive_bound ? start_value >= end_value : start_value > end_value) {
+					start_value = Add(calendar, start_value, increment_value);
+					total_values++;
+					if (total_values > NumericLimits<uint32_t>::Maximum()) {
+						throw InvalidInputException("Lists larger than 2^32 elements are not supported");
+					}
+				}
+			} else {
+				// positive interval, start_value is going up
+				while (inclusive_bound ? start_value <= end_value : start_value < end_value) {
+					start_value = Add(calendar, start_value, increment_value);
+					total_values++;
+					if (total_values > NumericLimits<uint32_t>::Maximum()) {
+						throw InvalidInputException("Lists larger than 2^32 elements are not supported");
+					}
+				}
+			}
+			return total_values;
+		}
+	};
+
+	template <bool INCLUSIVE_BOUND>
+	static void ICUListRangeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+		D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
+		D_ASSERT(args.ColumnCount() == 3);
+
+		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &bind_info = (BindData &)*func_expr.bind_info;
+		CalendarPtr calendar_ptr(bind_info.calendar->clone());
+		auto calendar = calendar_ptr.get();
+
+		RangeInfoStruct<INCLUSIVE_BOUND> info(args);
+		idx_t args_size = 1;
+		auto result_type = VectorType::CONSTANT_VECTOR;
+		for (idx_t i = 0; i < args.ColumnCount(); i++) {
+			if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
+				args_size = args.size();
+				result_type = VectorType::FLAT_VECTOR;
+				break;
+			}
+		}
+		auto list_data = FlatVector::GetData<list_entry_t>(result);
+		auto &result_validity = FlatVector::Validity(result);
+		int64_t total_size = 0;
+		for (idx_t i = 0; i < args_size; i++) {
+			if (!info.RowIsValid(i)) {
+				result_validity.SetInvalid(i);
+				list_data[i].offset = total_size;
+				list_data[i].length = 0;
+			} else {
+				list_data[i].offset = total_size;
+				list_data[i].length = info.ListLength(i, calendar);
+				total_size += list_data[i].length;
+			}
+		}
+
+		// now construct the child vector of the list
+		ListVector::Reserve(result, total_size);
+		auto range_data = FlatVector::GetData<timestamp_t>(ListVector::GetEntry(result));
+		idx_t total_idx = 0;
+		for (idx_t i = 0; i < args_size; i++) {
+			timestamp_t start_value = info.StartListValue(i);
+			interval_t increment = info.ListIncrementValue(i);
+
+			timestamp_t range_value = start_value;
+			for (idx_t range_idx = 0; range_idx < list_data[i].length; range_idx++) {
+				if (range_idx > 0) {
+					info.Increment(range_value, increment, calendar);
+				}
+				range_data[total_idx++] = range_value;
+			}
+		}
+
+		ListVector::SetListSize(result, total_size);
+		result.SetVectorType(result_type);
+
+		result.Verify(args.size());
+	}
+
+	static void AddICUListRangeFunction(ClientContext &context) {
+		auto &catalog = Catalog::GetSystemCatalog(context);
+
+		ScalarFunctionSet range("range");
+		range.AddFunction(ScalarFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
+		                                 LogicalType::LIST(LogicalType::TIMESTAMP_TZ), ICUListRangeFunction<false>,
+		                                 Bind));
+		CreateScalarFunctionInfo range_func_info(range);
+		catalog.AddFunction(context, &range_func_info);
+
+		// generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS
+		ScalarFunctionSet generate_series("generate_series");
+		generate_series.AddFunction(
+		    ScalarFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
+		                   LogicalType::LIST(LogicalType::TIMESTAMP_TZ), ICUListRangeFunction<true>, Bind));
+		CreateScalarFunctionInfo generate_series_func_info(generate_series);
+		catalog.AddFunction(context, &generate_series_func_info);
+	}
+};
+
+void RegisterICUListRangeFunctions(ClientContext &context) {
+	ICUListRange::AddICUListRangeFunction(context);
+}
+
+} // namespace duckdb

package/src/duckdb/extension/icu/include/icu-list-range.hpp

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// icu-list-range.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb.hpp"
+
+namespace duckdb {
+
+void RegisterICUListRangeFunctions(ClientContext &context);
+
+} // namespace duckdb

package/src/duckdb/extension/json/json_functions/read_json.cpp

@@ -20,6 +20,12 @@ void JSONScan::AutoDetect(ClientContext &context, JSONScanData &bind_data, vecto
 	idx_t remaining = bind_data.sample_size;
 	while (remaining != 0) {
 		allocator.Reset();
+
+		if (gstate.file_index >= 10) {
+			// We really shouldn't open more than 10 files when sampling
+			break;
+		}
+
 		auto read_count = lstate.ReadNext(gstate);
 		if (lstate.scan_count > 1) {
 			more_than_one = true;
@@ -46,11 +52,6 @@ void JSONScan::AutoDetect(ClientContext &context, JSONScanData &bind_data, vecto
 		node.InitializeCandidateTypes(bind_data.max_depth);
 		node.RefineCandidateTypes(values, next, string_vector, allocator, bind_data.date_format_map);
 		remaining -= next;
-
-		if (gstate.file_index == 10) {
-			// We really shouldn't open more than 10 files when sampling
-			break;
-		}
 	}
 	bind_data.type = original_scan_type;
 

package/src/duckdb/src/common/exception.cpp

@@ -138,12 +138,22 @@ string Exception::ExceptionTypeToString(ExceptionType type) {
 		return "Parameter Not Allowed";
 	case ExceptionType::DEPENDENCY:
 		return "Dependency";
+	case ExceptionType::HTTP:
+		return "HTTP";
 	default:
 		return "Unknown";
 	}
 }
 
-void Exception::ThrowAsTypeWithMessage(ExceptionType type, const string &message) {
+const HTTPException &Exception::AsHTTPException() const {
+	D_ASSERT(type == ExceptionType::HTTP);
+	const auto &e = static_cast<const HTTPException *>(this);
+	D_ASSERT(e->GetStatusCode() != 0);
+	return *e;
+}
+
+void Exception::ThrowAsTypeWithMessage(ExceptionType type, const string &message,
+                                       const std::shared_ptr<Exception> &original) {
 	switch (type) {
 	case ExceptionType::OUT_OF_RANGE:
 		throw OutOfRangeException(message);
@@ -191,6 +201,10 @@ void Exception::ThrowAsTypeWithMessage(ExceptionType type, const string &message
 		throw FatalException(message);
 	case ExceptionType::DEPENDENCY:
 		throw DependencyException(message);
+	case ExceptionType::HTTP: {
+		auto exc = original->AsHTTPException();
+		throw HTTPException(exc.GetStatusCode(), exc.GetResponse(), exc.what());
+	}
 	default:
 		throw Exception(type, message);
 	}

package/src/duckdb/src/common/preserved_error.cpp

@@ -7,15 +7,17 @@
 
 namespace duckdb {
 
-PreservedError::PreservedError() : initialized(false) {
+PreservedError::PreservedError() : initialized(false), exception_instance(nullptr) {
 }
 
 PreservedError::PreservedError(const Exception &exception)
-    : initialized(true), type(exception.type), raw_message(SanitizeErrorMessage(exception.RawMessage())) {
+    : initialized(true), type(exception.type), raw_message(SanitizeErrorMessage(exception.RawMessage())),
+      exception_instance(exception.Copy()) {
 }
 
 PreservedError::PreservedError(const string &message)
-    : initialized(true), type(ExceptionType::INVALID), raw_message(SanitizeErrorMessage(message)) {
+    : initialized(true), type(ExceptionType::INVALID), raw_message(SanitizeErrorMessage(message)),
+      exception_instance(nullptr) {
 }
 
 const string &PreservedError::Message() {
@@ -33,9 +35,9 @@ void PreservedError::Throw(const string &prepended_message) const {
 	D_ASSERT(initialized);
 	if (!prepended_message.empty()) {
 		string new_message = prepended_message + raw_message;
-		Exception::ThrowAsTypeWithMessage(type, new_message);
+		Exception::ThrowAsTypeWithMessage(type, new_message, exception_instance);
 	}
-	Exception::ThrowAsTypeWithMessage(type, raw_message);
+	Exception::ThrowAsTypeWithMessage(type, raw_message, exception_instance);
 }
 
 const ExceptionType &PreservedError::Type() const {

package/src/duckdb/src/execution/operator/scan/physical_positional_scan.cpp

@@ -12,13 +12,28 @@ namespace duckdb {
 PhysicalPositionalScan::PhysicalPositionalScan(vector<LogicalType> types, unique_ptr<PhysicalOperator> left,
                                                unique_ptr<PhysicalOperator> right)
     : PhysicalOperator(PhysicalOperatorType::POSITIONAL_SCAN, std::move(types),
-                       MinValue(left->estimated_cardinality, right->estimated_cardinality)) {
+                       MaxValue(left->estimated_cardinality, right->estimated_cardinality)) {
 
 	// Manage the children ourselves
-	D_ASSERT(left->type == PhysicalOperatorType::TABLE_SCAN);
-	D_ASSERT(right->type == PhysicalOperatorType::TABLE_SCAN);
-	child_tables.emplace_back(std::move(left));
-	child_tables.emplace_back(std::move(right));
+	if (left->type == PhysicalOperatorType::TABLE_SCAN) {
+		child_tables.emplace_back(std::move(left));
+	} else if (left->type == PhysicalOperatorType::POSITIONAL_SCAN) {
+		auto &left_scan = (PhysicalPositionalScan &)*left;
+		child_tables = std::move(left_scan.child_tables);
+	} else {
+		throw InternalException("Invalid left input for PhysicalPositionalScan");
+	}
+
+	if (right->type == PhysicalOperatorType::TABLE_SCAN) {
+		child_tables.emplace_back(std::move(right));
+	} else if (right->type == PhysicalOperatorType::POSITIONAL_SCAN) {
+		auto &right_scan = (PhysicalPositionalScan &)*right;
+		auto &right_tables = right_scan.child_tables;
+		child_tables.reserve(child_tables.size() + right_tables.size());
+		std::move(right_tables.begin(), right_tables.end(), std::back_inserter(child_tables));
+	} else {
+		throw InternalException("Invalid right input for PhysicalPositionalScan");
+	}
 }
 
 class PositionalScanGlobalSourceState : public GlobalSourceState {

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

@@ -10,12 +10,21 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalPositional
 
 	auto left = CreatePlan(*op.children[0]);
 	auto right = CreatePlan(*op.children[1]);
-	if (left->type == PhysicalOperatorType::TABLE_SCAN && right->type == PhysicalOperatorType::TABLE_SCAN) {
-		return make_unique<PhysicalPositionalScan>(op.types, std::move(left), std::move(right));
-	} else {
-		return make_unique<PhysicalPositionalJoin>(op.types, std::move(left), std::move(right),
-		                                           op.estimated_cardinality);
+	switch (left->type) {
+	case PhysicalOperatorType::TABLE_SCAN:
+	case PhysicalOperatorType::POSITIONAL_SCAN:
+		switch (right->type) {
+		case PhysicalOperatorType::TABLE_SCAN:
+		case PhysicalOperatorType::POSITIONAL_SCAN:
+			return make_unique<PhysicalPositionalScan>(op.types, std::move(left), std::move(right));
+		default:
+			break;
+		}
+	default:
+		break;
 	}
+
+	return make_unique<PhysicalPositionalJoin>(op.types, std::move(left), std::move(right), op.estimated_cardinality);
 }
 
 } // namespace duckdb

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

@@ -69,7 +69,7 @@ BoundCastInfo DefaultCasts::TimestampCastSwitch(BindCastInput &input, const Logi
 		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::Cast>);
 	case LogicalTypeId::TIMESTAMP_TZ:
 		// timestamp (us) to timestamp with time zone
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::Cast>);
+		return ReinterpretCast;
 	case LogicalTypeId::TIMESTAMP_NS:
 		// timestamp (us) to timestamp (ns)
 		return BoundCastInfo(
@@ -100,7 +100,7 @@ BoundCastInfo DefaultCasts::TimestampTzCastSwitch(BindCastInput &input, const Lo
 		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::Cast>);
 	case LogicalTypeId::TIMESTAMP:
 		// timestamp with time zone to timestamp (us)
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::Cast>);
+		return ReinterpretCast;
 	default:
 		return TryVectorNullCast;
 	}

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev329"
+#define DUCKDB_VERSION "0.7.2-dev402"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "fa70db552b"
+#define DUCKDB_SOURCE_ID "ab9736bed0"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/common/exception.hpp

@@ -76,8 +76,10 @@ enum class ExceptionType {
 	PERMISSION = 34,      // insufficient permissions
 	PARAMETER_NOT_RESOLVED = 35, // parameter types could not be resolved
 	PARAMETER_NOT_ALLOWED = 36,  // parameter types not allowed
-	DEPENDENCY = 37              // dependency
+	DEPENDENCY = 37,             // dependency
+	HTTP = 38
 };
+class HTTPException;
 
 class Exception : public std::exception {
 public:
@@ -91,7 +93,12 @@ public:
 	DUCKDB_API const string &RawMessage() const;
 
 	DUCKDB_API static string ExceptionTypeToString(ExceptionType type);
-	[[noreturn]] DUCKDB_API static void ThrowAsTypeWithMessage(ExceptionType type, const string &message);
+	[[noreturn]] DUCKDB_API static void ThrowAsTypeWithMessage(ExceptionType type, const string &message,
+	                                                           const std::shared_ptr<Exception> &original);
+	virtual std::shared_ptr<Exception> Copy() const {
+		return make_shared<Exception>(type, raw_message_);
+	}
+	DUCKDB_API const HTTPException &AsHTTPException() const;
 
 	template <typename... Args>
 	static string ConstructMessage(const string &msg, Args... params) {
@@ -256,6 +263,8 @@ public:
 class IOException : public Exception {
 public:
 	DUCKDB_API explicit IOException(const string &msg);
+	DUCKDB_API explicit IOException(ExceptionType exception_type, const string &msg) : Exception(exception_type, msg) {
+	}
 
 	template <typename... Args>
 	explicit IOException(const string &msg, Args... params) : IOException(ConstructMessage(msg, params...)) {
@@ -272,6 +281,33 @@ public:
 	}
 };
 
+class HTTPException : public IOException {
+public:
+	DUCKDB_API explicit HTTPException(int status_code, string response, const string &msg)
+	    : IOException(ExceptionType::HTTP, msg), status_code(status_code), response(std::move(response)) {
+	}
+
+	template <typename... ARGS>
+	explicit HTTPException(int status_code, string response, const string &msg, ARGS... params)
+	    : HTTPException(status_code, std::move(response), ConstructMessage(msg, params...)) {
+	}
+
+	std::shared_ptr<Exception> Copy() const {
+		return make_shared<HTTPException>(status_code, response, RawMessage());
+	}
+
+	int GetStatusCode() const {
+		return status_code;
+	}
+	const string &GetResponse() const {
+		return response;
+	}
+
+private:
+	int status_code;
+	string response; // we can keep a copy for the user
+};
+
 class SerializationException : public Exception {
 public:
 	DUCKDB_API explicit SerializationException(const string &msg);

package/src/duckdb/src/include/duckdb/common/preserved_error.hpp

@@ -19,7 +19,8 @@ public:
 	DUCKDB_API PreservedError();
 	//! From std::exception
 	PreservedError(const std::exception &ex)
-	    : initialized(true), type(ExceptionType::INVALID), raw_message(SanitizeErrorMessage(ex.what())) {
+	    : initialized(true), type(ExceptionType::INVALID), raw_message(SanitizeErrorMessage(ex.what())),
+	      exception_instance(nullptr) {
 	}
 	//! From a raw string
 	DUCKDB_API explicit PreservedError(const string &raw_message);
@@ -48,6 +49,7 @@ private:
 	string raw_message;
 	//! The final message (stored in the preserved error for compatibility reasons with C-API)
 	string final_message;
+	std::shared_ptr<Exception> exception_instance;
 
 private:
 	DUCKDB_API static string SanitizeErrorMessage(string error);

package/src/duckdb/src/include/duckdb/main/prepared_statement.hpp

@@ -48,6 +48,8 @@ public:
 public:
 	//! Returns the stored error message
 	DUCKDB_API const string &GetError();
+	//! Returns the stored error object
+	DUCKDB_API PreservedError &GetErrorObject();
 	//! Returns whether or not an error occurred
 	DUCKDB_API bool HasError() const;
 	//! Returns the number of columns in the result

package/src/duckdb/src/include/duckdb/main/relation/explain_relation.hpp

@@ -14,10 +14,11 @@ namespace duckdb {
 
 class ExplainRelation : public Relation {
 public:
-	explicit ExplainRelation(shared_ptr<Relation> child);
+	explicit ExplainRelation(shared_ptr<Relation> child, ExplainType type = ExplainType::EXPLAIN_STANDARD);
 
 	shared_ptr<Relation> child;
 	vector<ColumnDefinition> columns;
+	ExplainType type;
 
 public:
 	BoundStatement Bind(Binder &binder) override;

package/src/duckdb/src/include/duckdb/main/relation.hpp

@@ -17,6 +17,7 @@
 #include "duckdb/common/named_parameter_map.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/external_dependencies.hpp"
+#include "duckdb/parser/statement/explain_statement.hpp"
 
 #include <memory>
 
@@ -66,7 +67,7 @@ public:
 	DUCKDB_API unique_ptr<QueryResult> Query(const string &name, const string &sql);
 
 	//! Explain the query plan of this relation
-	DUCKDB_API unique_ptr<QueryResult> Explain();
+	DUCKDB_API unique_ptr<QueryResult> Explain(ExplainType type = ExplainType::EXPLAIN_STANDARD);
 
 	DUCKDB_API virtual unique_ptr<TableRef> GetTableRef();
 	DUCKDB_API virtual bool IsReadOnly() {

package/src/duckdb/src/main/extension/extension_install.cpp

@@ -206,8 +206,8 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 		if (exact_match) {
 			message += "\nAre you using a development build? In this case, extensions might not (yet) be uploaded.";
 		}
-		throw IOException("Failed to download extension \"%s\" at URL \"%s%s\"\n%s", extension_name, url_base,
-		                  url_local_part, message);
+		throw HTTPException(res.value().status, res->body, "Failed to download extension \"%s\" at URL \"%s%s\"\n%s",
+		                    extension_name, url_base, url_local_part, message);
 	}
 	auto decompressed_body = GZipFileSystem::UncompressGZIPString(res->body);
 	std::ofstream out(temp_path, std::ios::binary);

package/src/duckdb/src/main/prepared_statement.cpp

@@ -23,6 +23,10 @@ const string &PreparedStatement::GetError() {
 	return error.Message();
 }
 
+PreservedError &PreparedStatement::GetErrorObject() {
+	return error;
+}
+
 bool PreparedStatement::HasError() const {
 	return !success;
 }

package/src/duckdb/src/main/relation/explain_relation.cpp

@@ -7,15 +7,15 @@
 
 namespace duckdb {
 
-ExplainRelation::ExplainRelation(shared_ptr<Relation> child_p)
-    : Relation(child_p->context, RelationType::EXPLAIN_RELATION), child(std::move(child_p)) {
+ExplainRelation::ExplainRelation(shared_ptr<Relation> child_p, ExplainType type)
+    : Relation(child_p->context, RelationType::EXPLAIN_RELATION), child(std::move(child_p)), type(type) {
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement ExplainRelation::Bind(Binder &binder) {
 	auto select = make_unique<SelectStatement>();
 	select->node = child->GetQueryNode();
-	ExplainStatement explain(std::move(select));
+	ExplainStatement explain(std::move(select), type);
 	return binder.Bind((SQLStatement &)explain);
 }
 

package/src/duckdb/src/main/relation.cpp

@@ -25,6 +25,7 @@
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/main/relation/join_relation.hpp"
 #include "duckdb/main/relation/value_relation.hpp"
+#include "duckdb/parser/statement/explain_statement.hpp"
 
 namespace duckdb {
 
@@ -303,8 +304,8 @@ unique_ptr<QueryResult> Relation::Query(const string &name, const string &sql) {
 	return Query(sql);
 }
 
-unique_ptr<QueryResult> Relation::Explain() {
-	auto explain = make_shared<ExplainRelation>(shared_from_this());
+unique_ptr<QueryResult> Relation::Explain(ExplainType type) {
+	auto explain = make_shared<ExplainRelation>(shared_from_this(), type);
 	return explain->Execute();
 }
 

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();
         });
     });