duckdb 0.8.2-dev2090.0 → 0.8.2-dev2208.0

package/binding.gyp

@@ -207,6 +207,7 @@
                 "src/duckdb/third_party/mbedtls/mbedtls_wrapper.cpp", 
                 "src/duckdb/extension/parquet/parquet_extension.cpp", 
                 "src/duckdb/extension/parquet/column_writer.cpp", 
+                "src/duckdb/extension/parquet/serialize_parquet.cpp", 
                 "src/duckdb/extension/parquet/parquet_reader.cpp", 
                 "src/duckdb/extension/parquet/parquet_timestamp.cpp", 
                 "src/duckdb/extension/parquet/parquet_writer.cpp", 
@@ -258,12 +259,14 @@
                 "src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp", 
                 "src/duckdb/extension/icu/third_party/icu/stubdata/stubdata.cpp", 
                 "src/duckdb/extension/json/buffered_json_reader.cpp", 
+                "src/duckdb/extension/json/json_enums.cpp", 
                 "src/duckdb/extension/json/json_extension.cpp", 
                 "src/duckdb/extension/json/json_common.cpp", 
                 "src/duckdb/extension/json/json_functions.cpp", 
                 "src/duckdb/extension/json/json_scan.cpp", 
                 "src/duckdb/extension/json/json_serializer.cpp", 
                 "src/duckdb/extension/json/json_deserializer.cpp", 
+                "src/duckdb/extension/json/serialize_json.cpp", 
                 "src/duckdb/ub_extension_json_json_functions.cpp", 
                 "src/duckdb/extension/json/yyjson/yyjson.cpp"
             ], 

package/package.json

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

package/src/duckdb/extension/json/buffered_json_reader.cpp

@@ -3,6 +3,8 @@
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/file_opener.hpp"
 #include "duckdb/common/printer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 

package/src/duckdb/extension/json/include/buffered_json_reader.hpp

@@ -14,28 +14,11 @@
 #include "duckdb/common/multi_file_reader.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "json_common.hpp"
+#include "json_enums.hpp"
+#include "duckdb/common/enum_util.hpp"
 
 namespace duckdb {
 
-enum class JSONFormat : uint8_t {
-	//! Auto-detect format (UNSTRUCTURED / NEWLINE_DELIMITED)
-	AUTO_DETECT = 0,
-	//! One unit after another, newlines can be anywhere
-	UNSTRUCTURED = 1,
-	//! Units are separated by newlines, newlines do not occur within Units (NDJSON)
-	NEWLINE_DELIMITED = 2,
-	//! File is one big array of units
-	ARRAY = 3,
-};
-
-enum class JSONRecordType : uint8_t {
-	AUTO_DETECT = 0,
-	//! Sequential objects that are unpacked
-	RECORDS = 1,
-	//! Any other JSON type, e.g., ARRAY
-	VALUES = 2,
-};
-
 struct BufferedJSONReaderOptions {
 public:
 	//! The format of the JSON
@@ -50,6 +33,9 @@ public:
 public:
 	void Serialize(FieldWriter &writer) const;
 	void Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static BufferedJSONReaderOptions FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 struct JSONBufferHandle {

package/src/duckdb/extension/json/include/json_enums.hpp

@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+// This file is automatically generated by scripts/generate_enums.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/constants.hpp"
+#include "duckdb/common/enum_util.hpp"
+
+namespace duckdb {
+
+enum class JSONScanType : uint8_t {
+	INVALID = 0,
+	//! Read JSON straight to columnar data
+	READ_JSON = 1,
+	//! Read JSON values as strings
+	READ_JSON_OBJECTS = 2,
+	//! Sample run for schema detection
+	SAMPLE = 3,
+};
+
+enum class JSONRecordType : uint8_t {
+	AUTO_DETECT = 0,
+	//! Sequential objects that are unpacked
+	RECORDS = 1,
+	//! Any other JSON type, e.g., ARRAY
+	VALUES = 2,
+};
+
+enum class JSONFormat : uint8_t {
+	//! Auto-detect format (UNSTRUCTURED / NEWLINE_DELIMITED)
+	AUTO_DETECT = 0,
+	//! One unit after another, newlines can be anywhere
+	UNSTRUCTURED = 1,
+	//! Units are separated by newlines, newlines do not occur within Units (NDJSON)
+	NEWLINE_DELIMITED = 2,
+	//! File is one big array of units
+	ARRAY = 3,
+};
+
+template<>
+const char* EnumUtil::ToChars<JSONScanType>(JSONScanType value);
+
+template<>
+JSONScanType EnumUtil::FromString<JSONScanType>(const char *value);
+
+template<>
+const char* EnumUtil::ToChars<JSONRecordType>(JSONRecordType value);
+
+template<>
+JSONRecordType EnumUtil::FromString<JSONRecordType>(const char *value);
+
+template<>
+const char* EnumUtil::ToChars<JSONFormat>(JSONFormat value);
+
+template<>
+JSONFormat EnumUtil::FromString<JSONFormat>(const char *value);
+
+} // namespace duckdb

package/src/duckdb/extension/json/include/json_scan.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "buffered_json_reader.hpp"
+#include "json_enums.hpp"
 #include "duckdb/common/multi_file_reader.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/common/pair.hpp"
@@ -19,16 +20,6 @@
 
 namespace duckdb {
 
-enum class JSONScanType : uint8_t {
-	INVALID = 0,
-	//! Read JSON straight to columnar data
-	READ_JSON = 1,
-	//! Read JSON values as strings
-	READ_JSON_OBJECTS = 2,
-	//! Sample run for schema detection
-	SAMPLE = 3,
-};
-
 struct JSONString {
 public:
 	JSONString() {
@@ -104,6 +95,9 @@ public:
 	void Serialize(FieldWriter &writer) const;
 	void Deserialize(ClientContext &context, FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<JSONScanData> FormatDeserialize(FormatDeserializer &deserializer);
+
 public:
 	//! Scan type
 	JSONScanType type;
@@ -144,6 +138,12 @@ public:
 
 	//! The inferred avg tuple size
 	idx_t avg_tuple_size = 420;
+
+private:
+	JSONScanData(ClientContext &context, vector<string> files, string date_format, string timestamp_format);
+
+	string GetDateFormat() const;
+	string GetTimestampFormat() const;
 };
 
 struct JSONScanInfo : public TableFunctionInfo {
@@ -295,6 +295,10 @@ public:
 	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
 	                                            TableFunction &function);
 
+	static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data,
+	                            const TableFunction &function);
+	static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, TableFunction &function);
+
 	static void TableFunctionDefaults(TableFunction &table_function);
 };
 

package/src/duckdb/extension/json/include/json_transform.hpp

@@ -44,6 +44,9 @@ public:
 public:
 	void Serialize(FieldWriter &writer) const;
 	void Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static JSONTransformOptions FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 struct TryParseDate {

package/src/duckdb/extension/json/json_enums.cpp

@@ -0,0 +1,105 @@
+//===----------------------------------------------------------------------===//
+// This file is automatically generated by scripts/generate_enums.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
+
+#include "json_enums.hpp"
+#include "duckdb/common/string_util.hpp"
+
+namespace duckdb {
+
+template<>
+const char* EnumUtil::ToChars<JSONScanType>(JSONScanType value) {
+	switch(value) {
+	case JSONScanType::INVALID:
+		return "INVALID";
+	case JSONScanType::READ_JSON:
+		return "READ_JSON";
+	case JSONScanType::READ_JSON_OBJECTS:
+		return "READ_JSON_OBJECTS";
+	case JSONScanType::SAMPLE:
+		return "SAMPLE";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value of type JSONScanType: '%d' not implemented", value));
+	}
+}
+
+template<>
+JSONScanType EnumUtil::FromString<JSONScanType>(const char *value) {
+    if (StringUtil::Equals(value, "INVALID")) {
+		return JSONScanType::INVALID;
+	}
+    if (StringUtil::Equals(value, "READ_JSON")) {
+		return JSONScanType::READ_JSON;
+	}
+    if (StringUtil::Equals(value, "READ_JSON_OBJECTS")) {
+		return JSONScanType::READ_JSON_OBJECTS;
+	}
+    if (StringUtil::Equals(value, "SAMPLE")) {
+		return JSONScanType::SAMPLE;
+	}
+   throw NotImplementedException(StringUtil::Format("Enum value of type JSONScanType: '%s' not implemented", value));
+}
+
+template<>
+const char* EnumUtil::ToChars<JSONRecordType>(JSONRecordType value) {
+	switch(value) {
+	case JSONRecordType::AUTO_DETECT:
+		return "AUTO_DETECT";
+	case JSONRecordType::RECORDS:
+		return "RECORDS";
+	case JSONRecordType::VALUES:
+		return "VALUES";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value of type JSONRecordType: '%d' not implemented", value));
+	}
+}
+
+template<>
+JSONRecordType EnumUtil::FromString<JSONRecordType>(const char *value) {
+    if (StringUtil::Equals(value, "AUTO_DETECT")) {
+		return JSONRecordType::AUTO_DETECT;
+	}
+    if (StringUtil::Equals(value, "RECORDS")) {
+		return JSONRecordType::RECORDS;
+	}
+    if (StringUtil::Equals(value, "VALUES")) {
+		return JSONRecordType::VALUES;
+	}
+   throw NotImplementedException(StringUtil::Format("Enum value of type JSONRecordType: '%s' not implemented", value));
+}
+
+template<>
+const char* EnumUtil::ToChars<JSONFormat>(JSONFormat value) {
+	switch(value) {
+	case JSONFormat::AUTO_DETECT:
+		return "AUTO_DETECT";
+	case JSONFormat::UNSTRUCTURED:
+		return "UNSTRUCTURED";
+	case JSONFormat::NEWLINE_DELIMITED:
+		return "NEWLINE_DELIMITED";
+	case JSONFormat::ARRAY:
+		return "ARRAY";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value of type JSONFormat: '%d' not implemented", value));
+	}
+}
+
+template<>
+JSONFormat EnumUtil::FromString<JSONFormat>(const char *value) {
+    if (StringUtil::Equals(value, "AUTO_DETECT")) {
+		return JSONFormat::AUTO_DETECT;
+	}
+    if (StringUtil::Equals(value, "UNSTRUCTURED")) {
+		return JSONFormat::UNSTRUCTURED;
+	}
+    if (StringUtil::Equals(value, "NEWLINE_DELIMITED")) {
+		return JSONFormat::NEWLINE_DELIMITED;
+	}
+    if (StringUtil::Equals(value, "ARRAY")) {
+		return JSONFormat::ARRAY;
+	}
+   throw NotImplementedException(StringUtil::Format("Enum value of type JSONFormat: '%s' not implemented", value));
+}
+
+} // namespace duckdb

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

@@ -8,6 +8,8 @@
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "json_functions.hpp"
 #include "json_scan.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 

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

@@ -209,7 +209,8 @@ unique_ptr<TableRef> JSONFunctions::ReadJSONReplacement(ClientContext &context,
 	table_function->function = make_uniq<FunctionExpression>("read_json_auto", std::move(children));
 
 	if (!FileSystem::HasGlob(table_name)) {
-		table_function->alias = FileSystem::ExtractBaseName(table_name);
+		auto &fs = FileSystem::GetFileSystem(context);
+		table_function->alias = fs.ExtractBaseName(table_name);
 	}
 
 	return std::move(table_function);

package/src/duckdb/extension/json/json_scan.cpp

@@ -5,12 +5,22 @@
 #include "duckdb/main/extension_helper.hpp"
 #include "duckdb/parallel/task_scheduler.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
 JSONScanData::JSONScanData() {
 }
 
+JSONScanData::JSONScanData(ClientContext &context, vector<string> files_p, string date_format_p,
+                           string timestamp_format_p)
+    : files(std::move(files_p)), date_format(std::move(date_format_p)),
+      timestamp_format(std::move(timestamp_format_p)) {
+	InitializeReaders(context);
+	InitializeFormats();
+}
+
 void JSONScanData::Bind(ClientContext &context, TableFunctionBindInput &input) {
 	auto &info = input.info->Cast<JSONScanInfo>();
 	type = info.type;
@@ -164,6 +174,26 @@ void JSONScanData::Deserialize(ClientContext &context, FieldReader &reader) {
 	transform_options.date_format_map = &date_format_map;
 }
 
+string JSONScanData::GetDateFormat() const {
+	if (!date_format.empty()) {
+		return date_format;
+	} else if (date_format_map.HasFormats(LogicalTypeId::DATE)) {
+		return date_format_map.GetFormat(LogicalTypeId::DATE).format_specifier;
+	} else {
+		return string();
+	}
+}
+
+string JSONScanData::GetTimestampFormat() const {
+	if (!timestamp_format.empty()) {
+		return timestamp_format;
+	} else if (date_format_map.HasFormats(LogicalTypeId::TIMESTAMP)) {
+		return date_format_map.GetFormat(LogicalTypeId::TIMESTAMP).format_specifier;
+	} else {
+		return string();
+	}
+}
+
 JSONScanGlobalState::JSONScanGlobalState(ClientContext &context, const JSONScanData &bind_data_p)
     : bind_data(bind_data_p), transform_options(bind_data.transform_options),
       allocator(BufferManager::GetBufferManager(context).GetBufferAllocator()),
@@ -966,6 +996,18 @@ unique_ptr<FunctionData> JSONScan::Deserialize(PlanDeserializationState &state,
 	return std::move(result);
 }
 
+void JSONScan::FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+                               const TableFunction &function) {
+	auto &bind_data = bind_data_p->Cast<JSONScanData>();
+	serializer.WriteProperty("scan_data", bind_data);
+}
+
+unique_ptr<FunctionData> JSONScan::FormatDeserialize(FormatDeserializer &deserializer, TableFunction &function) {
+	unique_ptr<JSONScanData> result;
+	deserializer.ReadProperty("scan_data", result);
+	return std::move(result);
+}
+
 void JSONScan::TableFunctionDefaults(TableFunction &table_function) {
 	MultiFileReader::AddParameters(table_function);
 
@@ -980,6 +1022,8 @@ void JSONScan::TableFunctionDefaults(TableFunction &table_function) {
 
 	table_function.serialize = Serialize;
 	table_function.deserialize = Deserialize;
+	table_function.format_serialize = FormatSerialize;
+	table_function.format_deserialize = FormatDeserialize;
 
 	table_function.projection_pushdown = true;
 	table_function.filter_pushdown = false;

package/src/duckdb/extension/json/serialize_json.cpp

@@ -0,0 +1,92 @@
+//===----------------------------------------------------------------------===//
+// This file is automatically generated by scripts/generate_serialization.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
+
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "buffered_json_reader.hpp"
+#include "json_transform.hpp"
+#include "json_scan.hpp"
+
+namespace duckdb {
+
+void BufferedJSONReaderOptions::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("format", format);
+	serializer.WriteProperty("record_type", record_type);
+	serializer.WriteProperty("compression", compression);
+	serializer.WriteProperty("file_options", file_options);
+}
+
+BufferedJSONReaderOptions BufferedJSONReaderOptions::FormatDeserialize(FormatDeserializer &deserializer) {
+	BufferedJSONReaderOptions result;
+	deserializer.ReadProperty("format", result.format);
+	deserializer.ReadProperty("record_type", result.record_type);
+	deserializer.ReadProperty("compression", result.compression);
+	deserializer.ReadProperty("file_options", result.file_options);
+	return result;
+}
+
+void JSONScanData::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("json_type", type);
+	serializer.WriteProperty("options", options);
+	serializer.WriteProperty("reader_bind", reader_bind);
+	serializer.WriteProperty("files", files);
+	serializer.WriteProperty("ignore_errors", ignore_errors);
+	serializer.WriteProperty("maximum_object_size", maximum_object_size);
+	serializer.WriteProperty("auto_detect", auto_detect);
+	serializer.WriteProperty("sample_size", sample_size);
+	serializer.WriteProperty("max_depth", max_depth);
+	serializer.WriteProperty("transform_options", transform_options);
+	serializer.WriteProperty("names", names);
+	serializer.WriteProperty("date_format", GetDateFormat());
+	serializer.WriteProperty("timestamp_format", GetTimestampFormat());
+}
+
+unique_ptr<JSONScanData> JSONScanData::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto type = deserializer.ReadProperty<JSONScanType>("json_type");
+	auto options = deserializer.ReadProperty<BufferedJSONReaderOptions>("options");
+	auto reader_bind = deserializer.ReadProperty<MultiFileReaderBindData>("reader_bind");
+	auto files = deserializer.ReadProperty<vector<string>>("files");
+	auto ignore_errors = deserializer.ReadProperty<bool>("ignore_errors");
+	auto maximum_object_size = deserializer.ReadProperty<idx_t>("maximum_object_size");
+	auto auto_detect = deserializer.ReadProperty<bool>("auto_detect");
+	auto sample_size = deserializer.ReadProperty<idx_t>("sample_size");
+	auto max_depth = deserializer.ReadProperty<idx_t>("max_depth");
+	auto transform_options = deserializer.ReadProperty<JSONTransformOptions>("transform_options");
+	auto names = deserializer.ReadProperty<vector<string>>("names");
+	auto date_format = deserializer.ReadProperty<string>("date_format");
+	auto timestamp_format = deserializer.ReadProperty<string>("timestamp_format");
+	auto result = duckdb::unique_ptr<JSONScanData>(new JSONScanData(deserializer.Get<ClientContext &>(), std::move(files), std::move(date_format), std::move(timestamp_format)));
+	result->type = type;
+	result->options = options;
+	result->reader_bind = reader_bind;
+	result->ignore_errors = ignore_errors;
+	result->maximum_object_size = maximum_object_size;
+	result->auto_detect = auto_detect;
+	result->sample_size = sample_size;
+	result->max_depth = max_depth;
+	result->transform_options = transform_options;
+	result->names = std::move(names);
+	return result;
+}
+
+void JSONTransformOptions::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("strict_cast", strict_cast);
+	serializer.WriteProperty("error_duplicate_key", error_duplicate_key);
+	serializer.WriteProperty("error_missing_key", error_missing_key);
+	serializer.WriteProperty("error_unknown_key", error_unknown_key);
+	serializer.WriteProperty("delay_error", delay_error);
+}
+
+JSONTransformOptions JSONTransformOptions::FormatDeserialize(FormatDeserializer &deserializer) {
+	JSONTransformOptions result;
+	deserializer.ReadProperty("strict_cast", result.strict_cast);
+	deserializer.ReadProperty("error_duplicate_key", result.error_duplicate_key);
+	deserializer.ReadProperty("error_missing_key", result.error_missing_key);
+	deserializer.ReadProperty("error_unknown_key", result.error_unknown_key);
+	deserializer.ReadProperty("delay_error", result.delay_error);
+	return result;
+}
+
+} // namespace duckdb

package/src/duckdb/extension/parquet/include/parquet_reader.hpp

@@ -76,6 +76,9 @@ struct ParquetOptions {
 public:
 	void Serialize(FieldWriter &writer) const;
 	void Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static ParquetOptions FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class ParquetReader {

package/src/duckdb/extension/parquet/parquet_extension.cpp

@@ -35,6 +35,8 @@
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
 #include "duckdb/storage/table/row_group.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 #endif
 
 namespace duckdb {
@@ -181,6 +183,8 @@ public:
 		table_function.get_batch_index = ParquetScanGetBatchIndex;
 		table_function.serialize = ParquetScanSerialize;
 		table_function.deserialize = ParquetScanDeserialize;
+		table_function.format_serialize = ParquetScanFormatSerialize;
+		table_function.format_deserialize = ParquetScanFormatDeserialize;
 		table_function.get_batch_info = ParquetGetBatchInfo;
 		table_function.projection_pushdown = true;
 		table_function.filter_pushdown = true;
@@ -430,6 +434,25 @@ public:
 		return ParquetScanBindInternal(context, files, types, names, options);
 	}
 
+	static void ParquetScanFormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+	                                       const TableFunction &function) {
+		auto &bind_data = bind_data_p->Cast<ParquetReadBindData>();
+		serializer.WriteProperty("files", bind_data.files);
+		serializer.WriteProperty("types", bind_data.types);
+		serializer.WriteProperty("names", bind_data.names);
+		serializer.WriteProperty("parquet_options", bind_data.parquet_options);
+	}
+
+	static unique_ptr<FunctionData> ParquetScanFormatDeserialize(FormatDeserializer &deserializer,
+	                                                             TableFunction &function) {
+		auto &context = deserializer.Get<ClientContext &>();
+		auto files = deserializer.ReadProperty<vector<string>>("files");
+		auto types = deserializer.ReadProperty<vector<LogicalType>>("types");
+		auto names = deserializer.ReadProperty<vector<string>>("names");
+		auto parquet_options = deserializer.ReadProperty<ParquetOptions>("parquet_options");
+		return ParquetScanBindInternal(context, files, types, names, parquet_options);
+	}
+
 	static void ParquetScanImplementation(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 		if (!data_p.local_state) {
 			return;
@@ -938,7 +961,8 @@ unique_ptr<TableRef> ParquetScanReplacement(ClientContext &context, const string
 	table_function->function = make_uniq<FunctionExpression>("parquet_scan", std::move(children));
 
 	if (!FileSystem::HasGlob(table_name)) {
-		table_function->alias = FileSystem::ExtractBaseName(table_name);
+		auto &fs = FileSystem::GetFileSystem(context);
+		table_function->alias = fs.ExtractBaseName(table_name);
 	}
 
 	return std::move(table_function);

package/src/duckdb/extension/parquet/parquet_reader.cpp

@@ -72,6 +72,9 @@ static shared_ptr<ParquetFileMetadataCache> LoadMetadata(Allocator &allocator, F
 	transport.read((uint8_t *)buf.ptr, 8);
 
 	if (memcmp(buf.ptr + 4, "PAR1", 4) != 0) {
+		if (memcmp(buf.ptr + 4, "PARE", 4) == 0) {
+			throw InvalidInputException("Encrypted Parquet files are not supported for file '%s'", file_handle.path);
+		}
 		throw InvalidInputException("No magic bytes found at end of file '%s'", file_handle.path);
 	}
 	// read four-byte footer length from just before the end magic bytes

package/src/duckdb/extension/parquet/serialize_parquet.cpp

@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+// This file is automatically generated by scripts/generate_serialization.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
+
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "parquet_reader.hpp"
+
+namespace duckdb {
+
+void ParquetOptions::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("binary_as_string", binary_as_string);
+	serializer.WriteProperty("file_row_number", file_row_number);
+	serializer.WriteProperty("file_options", file_options);
+}
+
+ParquetOptions ParquetOptions::FormatDeserialize(FormatDeserializer &deserializer) {
+	ParquetOptions result;
+	deserializer.ReadProperty("binary_as_string", result.binary_as_string);
+	deserializer.ReadProperty("file_row_number", result.file_row_number);
+	deserializer.ReadProperty("file_options", result.file_options);
+	return result;
+}
+
+} // namespace duckdb

package/src/duckdb/src/catalog/catalog.cpp

@@ -655,17 +655,13 @@ LogicalType Catalog::GetType(ClientContext &context, const string &schema, const
 	if (!type_entry) {
 		return LogicalType::INVALID;
 	}
-	auto result_type = type_entry->user_type;
-	EnumType::SetCatalog(result_type, type_entry.get());
-	return result_type;
+	return type_entry->user_type;
 }
 
 LogicalType Catalog::GetType(ClientContext &context, const string &catalog_name, const string &schema,
                              const string &name) {
 	auto &type_entry = Catalog::GetEntry<TypeCatalogEntry>(context, catalog_name, schema, name);
-	auto result_type = type_entry.user_type;
-	EnumType::SetCatalog(result_type, &type_entry);
-	return result_type;
+	return type_entry.user_type;
 }
 
 vector<reference<SchemaCatalogEntry>> Catalog::GetSchemas(ClientContext &context) {

package/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp

@@ -527,10 +527,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::DropNotNull(ClientContext &context, Dro
 }
 
 unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info) {
-	if (info.target_type.id() == LogicalTypeId::USER) {
-		info.target_type =
-		    Catalog::GetType(context, catalog.GetName(), schema.name, UserType::GetTypeName(info.target_type));
-	}
+	Binder::BindLogicalType(context, info.target_type, &catalog, schema.name);
 	auto change_idx = GetColumnIndex(info.column_name);
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;

package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -172,10 +172,6 @@ const ColumnList &TableCatalogEntry::GetColumns() const {
 	return columns;
 }
 
-ColumnList &TableCatalogEntry::GetColumnsMutable() {
-	return columns;
-}
-
 const ColumnDefinition &TableCatalogEntry::GetColumn(LogicalIndex idx) {
 	return columns.GetColumn(idx);
 }