duckdb 0.6.2-dev1114.0 → 0.6.2-dev1124.0

package/package.json

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

package/src/duckdb/src/execution/operator/schema/physical_drop.cpp

@@ -1,6 +1,10 @@
 #include "duckdb/execution/operator/schema/physical_drop.hpp"
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/main/database_manager.hpp"
+#include "duckdb/main/database.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/catalog/catalog_search_path.hpp"
+#include "duckdb/main/settings.hpp"
 
 namespace duckdb {
 
@@ -39,6 +43,24 @@ void PhysicalDrop::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSo
 		db_manager.DetachDatabase(context.client, info->name, info->if_exists);
 		break;
 	}
+	case CatalogType::SCHEMA_ENTRY: {
+		auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
+		catalog.DropEntry(context.client, info.get());
+		auto qualified_name = QualifiedName::Parse(info->name);
+
+		// Check if the dropped schema was set as the current schema
+		auto &client_data = ClientData::Get(context.client);
+		auto &default_entry = client_data.catalog_search_path->GetDefault();
+		auto &current_catalog = default_entry.catalog;
+		auto &current_schema = default_entry.schema;
+		D_ASSERT(info->name != DEFAULT_SCHEMA);
+
+		if (info->catalog == current_catalog && current_schema == info->name) {
+			// Reset the schema to default
+			SchemaSetting::SetLocal(context.client, DEFAULT_SCHEMA);
+		}
+		break;
+	}
 	default: {
 		auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
 		catalog.DropEntry(context.client, info.get());

package/src/duckdb/src/function/aggregate/distributive/arg_min_max.cpp

@@ -7,33 +7,54 @@
 
 namespace duckdb {
 
-template <class T, class T2>
-struct ArgMinMaxState {
-	T arg;
-	T2 value;
+struct ArgMinMaxStateBase {
+	ArgMinMaxStateBase() : is_initialized(false) {
+	}
+
+	template <class T>
+	static inline void CreateValue(T &value) {
+	}
+
+	template <class T>
+	static inline void DestroyValue(T &value) {
+	}
+
+	template <class T>
+	static inline void AssignValue(T &target, T new_value, bool is_initialized) {
+		target = new_value;
+	}
+
+	template <typename T>
+	static inline void ReadValue(Vector &result, T &arg, T *target, idx_t idx) {
+		target[idx] = arg;
+	}
+
 	bool is_initialized;
 };
 
-template <class T>
-static void ArgMinMaxDestroyValue(T value) {
+// Out-of-line specialisations
+template <>
+void ArgMinMaxStateBase::CreateValue(Vector *&value) {
+	value = nullptr;
 }
 
 template <>
-void ArgMinMaxDestroyValue(string_t value) {
+void ArgMinMaxStateBase::DestroyValue(string_t &value) {
 	if (!value.IsInlined()) {
 		delete[] value.GetDataUnsafe();
 	}
 }
 
-template <class T>
-static void ArgMinMaxAssignValue(T &target, T new_value, bool is_initialized) {
-	target = new_value;
+template <>
+void ArgMinMaxStateBase::DestroyValue(Vector *&value) {
+	delete value;
+	value = nullptr;
 }
 
 template <>
-void ArgMinMaxAssignValue(string_t &target, string_t new_value, bool is_initialized) {
+void ArgMinMaxStateBase::AssignValue(string_t &target, string_t new_value, bool is_initialized) {
 	if (is_initialized) {
-		ArgMinMaxDestroyValue(target);
+		DestroyValue(target);
 	}
 	if (new_value.IsInlined()) {
 		target = new_value;
@@ -47,27 +68,51 @@ void ArgMinMaxAssignValue(string_t &target, string_t new_value, bool is_initiali
 	}
 }
 
+template <>
+void ArgMinMaxStateBase::ReadValue(Vector &result, string_t &arg, string_t *target, idx_t idx) {
+	target[idx] = StringVector::AddStringOrBlob(result, arg);
+}
+
+template <class A, class B>
+struct ArgMinMaxState : public ArgMinMaxStateBase {
+	using ARG_TYPE = A;
+	using BY_TYPE = B;
+
+	ARG_TYPE arg;
+	BY_TYPE value;
+
+	ArgMinMaxState() {
+		CreateValue(arg);
+		CreateValue(value);
+	}
+
+	~ArgMinMaxState() {
+		if (is_initialized) {
+			DestroyValue(arg);
+			DestroyValue(value);
+			is_initialized = false;
+		}
+	}
+};
+
 template <class COMPARATOR>
 struct ArgMinMaxBase {
 	template <class STATE>
 	static void Destroy(STATE *state) {
-		if (state->is_initialized) {
-			ArgMinMaxDestroyValue(state->arg);
-			ArgMinMaxDestroyValue(state->value);
-		}
+		state->~STATE();
 	}
 
 	template <class STATE>
 	static void Initialize(STATE *state) {
-		state->is_initialized = false;
+		new (state) STATE;
 	}
 
 	template <class A_TYPE, class B_TYPE, class STATE, class OP>
 	static void Operation(STATE *state, AggregateInputData &, A_TYPE *x_data, B_TYPE *y_data, ValidityMask &amask,
 	                      ValidityMask &bmask, idx_t xidx, idx_t yidx) {
 		if (!state->is_initialized) {
-			ArgMinMaxAssignValue<A_TYPE>(state->arg, x_data[xidx], false);
-			ArgMinMaxAssignValue<B_TYPE>(state->value, y_data[yidx], false);
+			STATE::template AssignValue<A_TYPE>(state->arg, x_data[xidx], false);
+			STATE::template AssignValue<B_TYPE>(state->value, y_data[yidx], false);
 			state->is_initialized = true;
 		} else {
 			OP::template Execute<A_TYPE, B_TYPE, STATE>(state, x_data[xidx], y_data[yidx]);
@@ -77,8 +122,8 @@ struct ArgMinMaxBase {
 	template <class A_TYPE, class B_TYPE, class STATE>
 	static void Execute(STATE *state, A_TYPE x_data, B_TYPE y_data) {
 		if (COMPARATOR::Operation(y_data, state->value)) {
-			ArgMinMaxAssignValue<A_TYPE>(state->arg, x_data, true);
-			ArgMinMaxAssignValue<B_TYPE>(state->value, y_data, true);
+			STATE::template AssignValue<A_TYPE>(state->arg, x_data, true);
+			STATE::template AssignValue<B_TYPE>(state->value, y_data, true);
 		}
 	}
 
@@ -88,97 +133,213 @@ struct ArgMinMaxBase {
 			return;
 		}
 		if (!target->is_initialized || COMPARATOR::Operation(source.value, target->value)) {
-			ArgMinMaxAssignValue(target->arg, source.arg, target->is_initialized);
-			ArgMinMaxAssignValue(target->value, source.value, target->is_initialized);
+			STATE::template AssignValue(target->arg, source.arg, target->is_initialized);
+			STATE::template AssignValue(target->value, source.value, target->is_initialized);
 			target->is_initialized = true;
 		}
 	}
 
-	static bool IgnoreNull() {
-		return true;
-	}
-};
-
-template <class COMPARATOR>
-struct StringArgMinMax : public ArgMinMaxBase<COMPARATOR> {
 	template <class T, class STATE>
 	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->is_initialized) {
 			mask.SetInvalid(idx);
 		} else {
-			target[idx] = StringVector::AddStringOrBlob(result, state->arg);
+			STATE::template ReadValue(result, state->arg, target, idx);
 		}
 	}
+
+	static bool IgnoreNull() {
+		return true;
+	}
 };
 
-template <class COMPARATOR>
-struct NumericArgMinMax : public ArgMinMaxBase<COMPARATOR> {
+template <typename COMPARATOR>
+struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR> {
+	template <class STATE>
+	static void AssignVector(STATE *state, Vector &arg, const idx_t idx) {
+		if (!state->is_initialized) {
+			state->arg = new Vector(arg.GetType());
+			state->arg->SetVectorType(VectorType::CONSTANT_VECTOR);
+		}
+		sel_t selv = idx;
+		SelectionVector sel(&selv);
+		VectorOperations::Copy(arg, *state->arg, sel, 1, 0, 0);
+	}
+
+	template <class STATE>
+	static void Update(Vector inputs[], AggregateInputData &, idx_t input_count, Vector &state_vector, idx_t count) {
+		auto &arg = inputs[0];
+		UnifiedVectorFormat adata;
+		arg.ToUnifiedFormat(count, adata);
+
+		using BY_TYPE = typename STATE::BY_TYPE;
+		auto &by = inputs[1];
+		UnifiedVectorFormat bdata;
+		by.ToUnifiedFormat(count, bdata);
+		const auto bys = (BY_TYPE *)bdata.data;
+
+		UnifiedVectorFormat sdata;
+		state_vector.ToUnifiedFormat(count, sdata);
+
+		auto states = (STATE **)sdata.data;
+		for (idx_t i = 0; i < count; i++) {
+			const auto aidx = adata.sel->get_index(i);
+			const auto bidx = bdata.sel->get_index(i);
+			if (!bdata.validity.RowIsValid(bidx)) {
+				continue;
+			}
+			const auto bval = bys[bidx];
+
+			const auto sidx = sdata.sel->get_index(i);
+			auto state = states[sidx];
+			if (!state->is_initialized) {
+				STATE::template AssignValue<BY_TYPE>(state->value, bval, false);
+				AssignVector(state, arg, aidx);
+				state->is_initialized = true;
+
+			} else if (COMPARATOR::template Operation<BY_TYPE>(bval, state->value)) {
+				STATE::template AssignValue<BY_TYPE>(state->value, bval, true);
+				AssignVector(state, arg, aidx);
+			}
+		}
+	}
+
+	template <class STATE, class OP>
+	static void Combine(const STATE &source, STATE *target, AggregateInputData &) {
+		if (!source.is_initialized) {
+			return;
+		}
+		if (!target->is_initialized || COMPARATOR::Operation(source.value, target->value)) {
+			STATE::template AssignValue(target->value, source.value, target->is_initialized);
+			AssignVector(target, *source.arg, 0);
+			target->is_initialized = true;
+		}
+	}
+
 	template <class T, class STATE>
 	static void Finalize(Vector &result, AggregateInputData &, STATE *state, T *target, ValidityMask &mask, idx_t idx) {
 		if (!state->is_initialized) {
-			mask.SetInvalid(idx);
+			// we need to use SetNull here
+			// since for STRUCT columns only setting the validity mask of the struct is incorrect
+			// as for a struct column, we need to also set ALL child columns to NULL
+			switch (result.GetVectorType()) {
+			case VectorType::FLAT_VECTOR:
+				FlatVector::SetNull(result, idx, true);
+				break;
+			case VectorType::CONSTANT_VECTOR:
+				ConstantVector::SetNull(result, true);
+				break;
+			default:
+				throw InternalException("Invalid result vector type for nested arg_min/max");
+			}
 		} else {
-			target[idx] = state->arg;
+			VectorOperations::Copy(*state->arg, result, 1, 0, idx);
 		}
 	}
+
+	static unique_ptr<FunctionData> Bind(ClientContext &context, AggregateFunction &function,
+	                                     vector<unique_ptr<Expression>> &arguments) {
+		function.arguments[0] = arguments[0]->return_type;
+		function.return_type = arguments[0]->return_type;
+		return nullptr;
+	}
 };
 
-using NumericArgMinOperation = NumericArgMinMax<LessThan>;
-using NumericArgMaxOperation = NumericArgMinMax<GreaterThan>;
-using StringArgMinOperation = StringArgMinMax<LessThan>;
-using StringArgMaxOperation = StringArgMinMax<GreaterThan>;
+template <class OP, class ARG_TYPE, class BY_TYPE>
+AggregateFunction GetVectorArgMinMaxFunctionInternal(const LogicalType &by_type, const LogicalType &type) {
+	using STATE = ArgMinMaxState<ARG_TYPE, BY_TYPE>;
+	return AggregateFunction({type, by_type}, type, AggregateFunction::StateSize<STATE>,
+	                         AggregateFunction::StateInitialize<STATE, OP>, OP::template Update<STATE>,
+	                         AggregateFunction::StateCombine<STATE, OP>,
+	                         AggregateFunction::StateFinalize<STATE, void, OP>, nullptr, OP::Bind,
+	                         AggregateFunction::StateDestroy<STATE, OP>);
+}
 
-template <class OP, class T, class T2>
-AggregateFunction GetArgMinMaxFunctionInternal(const LogicalType &arg_2, const LogicalType &arg) {
-	auto function = AggregateFunction::BinaryAggregate<ArgMinMaxState<T, T2>, T, T2, T, OP>(arg, arg_2, arg);
-	if (arg.InternalType() == PhysicalType::VARCHAR || arg_2.InternalType() == PhysicalType::VARCHAR) {
-		function.destructor = AggregateFunction::StateDestroy<ArgMinMaxState<T, T2>, OP>;
+template <class OP, class ARG_TYPE>
+AggregateFunction GetVectorArgMinMaxFunctionBy(const LogicalType &by_type, const LogicalType &type) {
+	switch (by_type.InternalType()) {
+	case PhysicalType::INT32:
+		return GetVectorArgMinMaxFunctionInternal<OP, ARG_TYPE, int32_t>(by_type, type);
+	case PhysicalType::INT64:
+		return GetVectorArgMinMaxFunctionInternal<OP, ARG_TYPE, int64_t>(by_type, type);
+	case PhysicalType::DOUBLE:
+		return GetVectorArgMinMaxFunctionInternal<OP, ARG_TYPE, double>(by_type, type);
+	case PhysicalType::VARCHAR:
+		return GetVectorArgMinMaxFunctionInternal<OP, ARG_TYPE, string_t>(by_type, type);
+	default:
+		throw InternalException("Unimplemented arg_min/arg_max aggregate");
+	}
+}
+
+template <class OP, class ARG_TYPE>
+void AddVectorArgMinMaxFunctionBy(AggregateFunctionSet &fun, const LogicalType &type) {
+	fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::INTEGER, type));
+	fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::BIGINT, type));
+	fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::DOUBLE, type));
+	fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::VARCHAR, type));
+	fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::DATE, type));
+	fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::TIMESTAMP, type));
+	fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::TIMESTAMP_TZ, type));
+	fun.AddFunction(GetVectorArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::BLOB, type));
+}
+
+template <class OP, class ARG_TYPE, class BY_TYPE>
+AggregateFunction GetArgMinMaxFunctionInternal(const LogicalType &by_type, const LogicalType &type) {
+	using STATE = ArgMinMaxState<ARG_TYPE, BY_TYPE>;
+	auto function = AggregateFunction::BinaryAggregate<STATE, ARG_TYPE, BY_TYPE, ARG_TYPE, OP>(type, by_type, type);
+	if (type.InternalType() == PhysicalType::VARCHAR || by_type.InternalType() == PhysicalType::VARCHAR) {
+		function.destructor = AggregateFunction::StateDestroy<STATE, OP>;
 	}
 	return function;
 }
-template <class OP, class T>
-AggregateFunction GetArgMinMaxFunctionArg2(const LogicalType &arg_2, const LogicalType &arg) {
-	switch (arg_2.InternalType()) {
+
+template <class OP, class ARG_TYPE>
+AggregateFunction GetArgMinMaxFunctionBy(const LogicalType &by_type, const LogicalType &type) {
+	switch (by_type.InternalType()) {
 	case PhysicalType::INT32:
-		return GetArgMinMaxFunctionInternal<OP, T, int32_t>(arg_2, arg);
+		return GetArgMinMaxFunctionInternal<OP, ARG_TYPE, int32_t>(by_type, type);
 	case PhysicalType::INT64:
-		return GetArgMinMaxFunctionInternal<OP, T, int64_t>(arg_2, arg);
+		return GetArgMinMaxFunctionInternal<OP, ARG_TYPE, int64_t>(by_type, type);
 	case PhysicalType::DOUBLE:
-		return GetArgMinMaxFunctionInternal<OP, T, double>(arg_2, arg);
+		return GetArgMinMaxFunctionInternal<OP, ARG_TYPE, double>(by_type, type);
 	case PhysicalType::VARCHAR:
-		return GetArgMinMaxFunctionInternal<OP, T, string_t>(arg_2, arg);
+		return GetArgMinMaxFunctionInternal<OP, ARG_TYPE, string_t>(by_type, type);
 	default:
 		throw InternalException("Unimplemented arg_min/arg_max aggregate");
 	}
 }
 
-template <class OP, class T>
-void AddArgMinMaxFunctionArg2(AggregateFunctionSet &fun, const LogicalType &arg) {
-	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::INTEGER, arg));
-	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::BIGINT, arg));
-	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::DOUBLE, arg));
-	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::VARCHAR, arg));
-	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::DATE, arg));
-	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::TIMESTAMP, arg));
-	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::TIMESTAMP_TZ, arg));
-	fun.AddFunction(GetArgMinMaxFunctionArg2<OP, T>(LogicalType::BLOB, arg));
+template <class OP, class ARG_TYPE>
+void AddArgMinMaxFunctionBy(AggregateFunctionSet &fun, const LogicalType &type) {
+	fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::INTEGER, type));
+	fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::BIGINT, type));
+	fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::DOUBLE, type));
+	fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::VARCHAR, type));
+	fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::DATE, type));
+	fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::TIMESTAMP, type));
+	fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::TIMESTAMP_TZ, type));
+	fun.AddFunction(GetArgMinMaxFunctionBy<OP, ARG_TYPE>(LogicalType::BLOB, type));
 }
 
-template <class OP, class STRING_OP>
+template <class COMPARATOR>
 static void AddArgMinMaxFunctions(AggregateFunctionSet &fun) {
-	AddArgMinMaxFunctionArg2<OP, int32_t>(fun, LogicalType::INTEGER);
-	AddArgMinMaxFunctionArg2<OP, int64_t>(fun, LogicalType::BIGINT);
-	AddArgMinMaxFunctionArg2<OP, double>(fun, LogicalType::DOUBLE);
-	AddArgMinMaxFunctionArg2<STRING_OP, string_t>(fun, LogicalType::VARCHAR);
-	AddArgMinMaxFunctionArg2<OP, date_t>(fun, LogicalType::DATE);
-	AddArgMinMaxFunctionArg2<OP, timestamp_t>(fun, LogicalType::TIMESTAMP);
-	AddArgMinMaxFunctionArg2<OP, timestamp_t>(fun, LogicalType::TIMESTAMP_TZ);
-	AddArgMinMaxFunctionArg2<STRING_OP, string_t>(fun, LogicalType::BLOB);
+	using OP = ArgMinMaxBase<COMPARATOR>;
+	AddArgMinMaxFunctionBy<OP, int32_t>(fun, LogicalType::INTEGER);
+	AddArgMinMaxFunctionBy<OP, int64_t>(fun, LogicalType::BIGINT);
+	AddArgMinMaxFunctionBy<OP, double>(fun, LogicalType::DOUBLE);
+	AddArgMinMaxFunctionBy<OP, string_t>(fun, LogicalType::VARCHAR);
+	AddArgMinMaxFunctionBy<OP, date_t>(fun, LogicalType::DATE);
+	AddArgMinMaxFunctionBy<OP, timestamp_t>(fun, LogicalType::TIMESTAMP);
+	AddArgMinMaxFunctionBy<OP, timestamp_t>(fun, LogicalType::TIMESTAMP_TZ);
+	AddArgMinMaxFunctionBy<OP, string_t>(fun, LogicalType::BLOB);
+
+	using VECTOR_OP = VectorArgMinMaxBase<COMPARATOR>;
+	AddVectorArgMinMaxFunctionBy<VECTOR_OP, Vector *>(fun, LogicalType::ANY);
 }
 
 void ArgMinFun::RegisterFunction(BuiltinFunctions &set) {
 	AggregateFunctionSet fun("argmin");
-	AddArgMinMaxFunctions<NumericArgMinOperation, StringArgMinOperation>(fun);
+	AddArgMinMaxFunctions<LessThan>(fun);
 	set.AddFunction(fun);
 
 	//! Add min_by alias
@@ -192,7 +353,7 @@ void ArgMinFun::RegisterFunction(BuiltinFunctions &set) {
 
 void ArgMaxFun::RegisterFunction(BuiltinFunctions &set) {
 	AggregateFunctionSet fun("argmax");
-	AddArgMinMaxFunctions<NumericArgMaxOperation, StringArgMaxOperation>(fun);
+	AddArgMinMaxFunctions<GreaterThan>(fun);
 	set.AddFunction(fun);
 
 	//! Add max_by alias

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.6.2-dev1114"
+#define DUCKDB_VERSION "0.6.2-dev1124"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "51945c68c0"
+#define DUCKDB_SOURCE_ID "aa44cebfc5"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/main/settings/settings.cpp

@@ -875,7 +875,8 @@ void SchemaSetting::SetLocal(ClientContext &context, const Value &input) {
 }
 
 Value SchemaSetting::GetSetting(ClientContext &context) {
-	return SearchPathSetting::GetSetting(context);
+	auto &client_data = ClientData::Get(context);
+	return client_data.catalog_search_path->GetDefault().schema;
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/parser/transform/statement/transform_drop.cpp

@@ -44,15 +44,24 @@ unique_ptr<SQLStatement> Transformer::TransformDrop(duckdb_libpgquery::PGNode *n
 	}
 
 	switch (stmt->removeType) {
-	case duckdb_libpgquery::PG_OBJECT_SCHEMA:
-		info.name = ((duckdb_libpgquery::PGValue *)stmt->objects->head->data.ptr_value)->val.str;
-		break;
 	case duckdb_libpgquery::PG_OBJECT_TYPE: {
 		auto view_list = (duckdb_libpgquery::PGList *)stmt->objects;
 		auto target = (duckdb_libpgquery::PGTypeName *)(view_list->head->data.ptr_value);
 		info.name = (reinterpret_cast<duckdb_libpgquery::PGValue *>(target->names->tail->data.ptr_value)->val.str);
 		break;
 	}
+	case duckdb_libpgquery::PG_OBJECT_SCHEMA: {
+		auto view_list = (duckdb_libpgquery::PGList *)stmt->objects->head->data.ptr_value;
+		if (view_list->length == 2) {
+			info.catalog = ((duckdb_libpgquery::PGValue *)view_list->head->data.ptr_value)->val.str;
+			info.name = ((duckdb_libpgquery::PGValue *)view_list->head->next->data.ptr_value)->val.str;
+		} else if (view_list->length == 1) {
+			info.name = ((duckdb_libpgquery::PGValue *)view_list->head->data.ptr_value)->val.str;
+		} else {
+			throw ParserException("Expected \"catalog.schema\" or \"schema\"");
+		}
+		break;
+	}
 	default: {
 		auto view_list = (duckdb_libpgquery::PGList *)stmt->objects->head->data.ptr_value;
 		if (view_list->length == 3) {

package/src/duckdb/third_party/libpg_query/include/parser/gram.hpp

@@ -1065,7 +1065,7 @@ typedef union YYSTYPE
 	PGSubLinkType subquerytype;
 	PGViewCheckOption viewcheckoption;
 }
-/* Line 1489 of yacc.c.  */
+/* Line 1529 of yacc.c.  */
 #line 1070 "third_party/libpg_query/grammar/grammar_out.hpp"
 	YYSTYPE;
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */