duckdb 0.8.2-dev1212.0 → 0.8.2-dev1435.0

package/src/duckdb/src/include/duckdb/common/operator/cast_operators.hpp

@@ -8,13 +8,18 @@
 
 #pragma once
 
+#include "duckdb/common/assert.hpp"
 #include "duckdb/common/constants.hpp"
+#include "duckdb/common/hugeint.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/typedefs.hpp"
 #include "duckdb/common/types/string_type.hpp"
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/operator/convert_to_string.hpp"
 #include "duckdb/common/types/null_value.hpp"
+#include "duckdb/common/types/bit.hpp"
+#include "duckdb/common/types/vector.hpp"
 
 namespace duckdb {
 struct ValidityMask;
@@ -652,6 +657,15 @@ struct CastFromBlob {
 template <>
 duckdb::string_t CastFromBlob::Operation(duckdb::string_t input, Vector &vector);
 
+struct CastFromBlobToBit {
+	template <class SRC>
+	static inline string_t Operation(SRC input, Vector &result) {
+		throw NotImplementedException("Cast from blob could not be performed!");
+	}
+};
+template <>
+string_t CastFromBlobToBit::Operation(string_t input, Vector &result);
+
 struct TryCastToBlob {
 	template <class SRC, class DST>
 	static inline bool Operation(SRC input, DST &result, Vector &result_vector, string *error_message,
@@ -659,7 +673,6 @@ struct TryCastToBlob {
 		throw InternalException("Unsupported type for try cast to blob");
 	}
 };
-
 template <>
 bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_vector, string *error_message,
                               bool strict);
@@ -667,14 +680,41 @@ bool TryCastToBlob::Operation(string_t input, string_t &result, Vector &result_v
 //===--------------------------------------------------------------------===//
 // Bits
 //===--------------------------------------------------------------------===//
-struct CastFromBit {
+struct CastFromBitToString {
 	template <class SRC>
 	static inline string_t Operation(SRC input, Vector &result) {
 		throw duckdb::NotImplementedException("Cast from bit could not be performed!");
 	}
 };
 template <>
-duckdb::string_t CastFromBit::Operation(duckdb::string_t input, Vector &vector);
+duckdb::string_t CastFromBitToString::Operation(duckdb::string_t input, Vector &vector);
+
+struct CastFromBitToNumeric {
+	template <class SRC = string_t, class DST>
+	static inline bool Operation(SRC input, DST &result, bool strict = false) {
+		D_ASSERT(input.GetSize() > 1);
+
+		// TODO: Allow conversion if the significant bytes of the bitstring can be cast to the target type
+		// Currently only allows bitstring -> numeric if the full bitstring fits inside the numeric type
+		if (input.GetSize() - 1 > sizeof(DST)) {
+			throw ConversionException("Bitstring doesn't fit inside of %s", GetTypeId<DST>());
+		}
+		Bit::BitToNumeric(input, result);
+		return (true);
+	}
+};
+template <>
+bool CastFromBitToNumeric::Operation(string_t input, bool &result, bool strict);
+template <>
+bool CastFromBitToNumeric::Operation(string_t input, hugeint_t &result, bool strict);
+
+struct CastFromBitToBlob {
+	template <class SRC>
+	static inline string_t Operation(SRC input, Vector &result) {
+		D_ASSERT(input.GetSize() > 1);
+		return StringVector::AddStringOrBlob(result, Bit::BitToBlob(input));
+	}
+};
 
 struct TryCastToBit {
 	template <class SRC, class DST>

package/src/duckdb/src/include/duckdb/common/operator/numeric_cast.hpp

@@ -9,8 +9,11 @@
 #pragma once
 
 #include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/types/bit.hpp"
 #include "duckdb/common/types/hugeint.hpp"
+#include "duckdb/common/types/string_type.hpp"
 #include "duckdb/common/types/value.hpp"
+#include "duckdb/common/types/vector.hpp"
 #include <cmath>
 
 namespace duckdb {
@@ -442,6 +445,13 @@ bool TryCastWithOverflowCheck(hugeint_t value, double &result) {
 	return Hugeint::TryCast(value, result);
 }
 
+struct NumericTryCastToBit {
+	template <class SRC>
+	static inline string_t Operation(SRC input, Vector &result) {
+		return StringVector::AddStringOrBlob(result, Bit::NumericToBit(input));
+	}
+};
+
 struct NumericTryCast {
 	template <class SRC, class DST>
 	static inline bool Operation(SRC input, DST &result, bool strict = false) {

package/src/duckdb/src/include/duckdb/common/types/bit.hpp

@@ -8,8 +8,12 @@
 
 #pragma once
 
+#include "duckdb/common/assert.hpp"
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/hugeint.hpp"
+#include "duckdb/common/limits.hpp"
 #include "duckdb/common/types.hpp"
+#include "duckdb/common/types/string_type.hpp"
 
 namespace duckdb {
 
@@ -37,7 +41,33 @@ public:
 	//! Convert a string to a bit. This function should ONLY be called after calling GetBitSize, since it does NOT
 	//! perform data validation.
 	DUCKDB_API static void ToBit(string_t str, string_t &output);
+
 	DUCKDB_API static string ToBit(string_t str);
+
+	//! output needs to have enough space allocated before calling this function (blob size + 1)
+	DUCKDB_API static void BlobToBit(string_t blob, string_t &output);
+
+	DUCKDB_API static string BlobToBit(string_t blob);
+
+	//! output_str needs to have enough space allocated before calling this function (sizeof(T) + 1)
+	template <class T>
+	static void NumericToBit(T numeric, string_t &output_str);
+
+	template <class T>
+	static string NumericToBit(T numeric);
+
+	//! bit is expected to fit inside of output num (bit size <= sizeof(T) + 1)
+	template <class T>
+	static void BitToNumeric(string_t bit, T &output_num);
+
+	template <class T>
+	static T BitToNumeric(string_t bit);
+
+	//! bit is expected to fit inside of output_blob (bit size = output_blob + 1)
+	static void BitToBlob(string_t bit, string_t &output_blob);
+
+	static string BitToBlob(string_t bit);
+
 	//! Creates a new bitstring of determined length
 	DUCKDB_API static void BitString(const string_t &input, const idx_t &len, string_t &result);
 	DUCKDB_API static void SetEmptyBitString(string_t &target, string_t &input);
@@ -58,5 +88,56 @@ private:
 	static idx_t GetBitInternal(string_t bit_string, idx_t n);
 	static void SetBitInternal(string_t &bit_string, idx_t n, idx_t new_value);
 	static idx_t GetBitIndex(idx_t n);
+	static uint8_t GetFirstByte(const string_t &str);
 };
+
+//===--------------------------------------------------------------------===//
+// Bit Template definitions
+//===--------------------------------------------------------------------===//
+template <class T>
+void Bit::NumericToBit(T numeric, string_t &output_str) {
+	D_ASSERT(output_str.GetSize() >= sizeof(T) + 1);
+
+	auto output = output_str.GetDataWriteable();
+	auto data = const_data_ptr_cast(&numeric);
+
+	*output = 0; // set padding to 0
+	++output;
+	for (idx_t idx = 0; idx < sizeof(T); ++idx) {
+		output[idx] = data[sizeof(T) - idx - 1];
+	}
+	Bit::Finalize(output_str);
+}
+
+template <class T>
+string Bit::NumericToBit(T numeric) {
+	auto bit_len = sizeof(T) + 1;
+	auto buffer = make_unsafe_uniq_array<char>(bit_len);
+	string_t output_str(buffer.get(), bit_len);
+	Bit::NumericToBit(numeric, output_str);
+	return output_str.GetString();
+}
+
+template <class T>
+T Bit::BitToNumeric(string_t bit) {
+	T output;
+	Bit::BitToNumeric(bit, output);
+	return (output);
+}
+
+template <class T>
+void Bit::BitToNumeric(string_t bit, T &output_num) {
+	D_ASSERT(bit.GetSize() <= sizeof(T) + 1);
+
+	output_num = 0;
+	auto data = const_data_ptr_cast(bit.GetData());
+	auto output = data_ptr_cast(&output_num);
+
+	idx_t padded_byte_idx = sizeof(T) - bit.GetSize() + 1;
+	output[sizeof(T) - 1 - padded_byte_idx] = GetFirstByte(bit);
+	for (idx_t idx = padded_byte_idx + 1; idx < sizeof(T); ++idx) {
+		output[sizeof(T) - 1 - idx] = data[1 + idx - padded_byte_idx];
+	}
+}
+
 } // namespace duckdb

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

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/file_system.hpp"
 #include "duckdb/common/map.hpp"
+#include "duckdb/common/unordered_set.hpp"
 
 namespace duckdb {
 
@@ -22,120 +23,60 @@ public:
 	                                FileCompressionType compression = FileCompressionType::UNCOMPRESSED,
 	                                FileOpener *opener = nullptr) override;
 
-	void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override {
-		handle.file_system.Read(handle, buffer, nr_bytes, location);
-	};
+	void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override;
+	void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override;
 
-	void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override {
-		handle.file_system.Write(handle, buffer, nr_bytes, location);
-	}
+	int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
 
-	int64_t Read(FileHandle &handle, void *buffer, int64_t nr_bytes) override {
-		return handle.file_system.Read(handle, buffer, nr_bytes);
-	}
+	int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes) override;
 
-	int64_t Write(FileHandle &handle, void *buffer, int64_t nr_bytes) override {
-		return handle.file_system.Write(handle, buffer, nr_bytes);
-	}
+	int64_t GetFileSize(FileHandle &handle) override;
+	time_t GetLastModifiedTime(FileHandle &handle) override;
+	FileType GetFileType(FileHandle &handle) override;
 
-	int64_t GetFileSize(FileHandle &handle) override {
-		return handle.file_system.GetFileSize(handle);
-	}
-	time_t GetLastModifiedTime(FileHandle &handle) override {
-		return handle.file_system.GetLastModifiedTime(handle);
-	}
-	FileType GetFileType(FileHandle &handle) override {
-		return handle.file_system.GetFileType(handle);
-	}
+	void Truncate(FileHandle &handle, int64_t new_size) override;
 
-	void Truncate(FileHandle &handle, int64_t new_size) override {
-		handle.file_system.Truncate(handle, new_size);
-	}
-
-	void FileSync(FileHandle &handle) override {
-		handle.file_system.FileSync(handle);
-	}
+	void FileSync(FileHandle &handle) override;
 
 	// need to look up correct fs for this
-	bool DirectoryExists(const string &directory) override {
-		return FindFileSystem(directory)->DirectoryExists(directory);
-	}
-	void CreateDirectory(const string &directory) override {
-		FindFileSystem(directory)->CreateDirectory(directory);
-	}
+	bool DirectoryExists(const string &directory) override;
+	void CreateDirectory(const string &directory) override;
 
-	void RemoveDirectory(const string &directory) override {
-		FindFileSystem(directory)->RemoveDirectory(directory);
-	}
+	void RemoveDirectory(const string &directory) override;
 
 	bool ListFiles(const string &directory, const std::function<void(const string &, bool)> &callback,
-	               FileOpener *opener = nullptr) override {
-		return FindFileSystem(directory)->ListFiles(directory, callback, opener);
-	}
-
-	void MoveFile(const string &source, const string &target) override {
-		FindFileSystem(source)->MoveFile(source, target);
-	}
-
-	bool FileExists(const string &filename) override {
-		return FindFileSystem(filename)->FileExists(filename);
-	}
-
-	bool IsPipe(const string &filename) override {
-		return FindFileSystem(filename)->IsPipe(filename);
-	}
-	virtual void RemoveFile(const string &filename) override {
-		FindFileSystem(filename)->RemoveFile(filename);
-	}
-
-	virtual vector<string> Glob(const string &path, FileOpener *opener = nullptr) override {
-		return FindFileSystem(path)->Glob(path, opener);
-	}
-
-	void RegisterSubSystem(unique_ptr<FileSystem> fs) override {
-		sub_systems.push_back(std::move(fs));
-	}
-
-	void UnregisterSubSystem(const string &name) override {
-		for (auto sub_system = sub_systems.begin(); sub_system != sub_systems.end(); sub_system++) {
-			if (sub_system->get()->GetName() == name) {
-				sub_systems.erase(sub_system);
-				return;
-			}
-		}
-		throw InvalidInputException("Could not find filesystem with name %s", name);
-	}
-
-	void RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs) override {
-		compressed_fs[compression_type] = std::move(fs);
-	}
-
-	vector<string> ListSubSystems() override {
-		vector<string> names(sub_systems.size());
-		for (idx_t i = 0; i < sub_systems.size(); i++) {
-			names[i] = sub_systems[i]->GetName();
-		}
-		return names;
-	}
-
-	std::string GetName() const override {
-		return "VirtualFileSystem";
-	}
+	               FileOpener *opener = nullptr) override;
+
+	void MoveFile(const string &source, const string &target) override;
+
+	bool FileExists(const string &filename) override;
+
+	bool IsPipe(const string &filename) override;
+	virtual void RemoveFile(const string &filename) override;
+
+	virtual vector<string> Glob(const string &path, FileOpener *opener = nullptr) override;
+
+	void RegisterSubSystem(unique_ptr<FileSystem> fs) override;
+
+	void UnregisterSubSystem(const string &name) override;
+
+	void RegisterSubSystem(FileCompressionType compression_type, unique_ptr<FileSystem> fs) override;
+
+	vector<string> ListSubSystems() override;
+
+	std::string GetName() const override;
+
+	void SetDisabledFileSystems(const vector<string> &names) override;
 
 private:
-	FileSystem *FindFileSystem(const string &path) {
-		for (auto &sub_system : sub_systems) {
-			if (sub_system->CanHandleFile(path)) {
-				return sub_system.get();
-			}
-		}
-		return default_fs.get();
-	}
+	FileSystem &FindFileSystem(const string &path);
+	FileSystem &FindFileSystemInternal(const string &path);
 
 private:
 	vector<unique_ptr<FileSystem>> sub_systems;
 	map<FileCompressionType, unique_ptr<FileSystem>> compressed_fs;
 	const unique_ptr<FileSystem> default_fs;
+	unordered_set<string> disabled_file_systems;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/core_functions/scalar/date_functions.hpp

@@ -162,8 +162,8 @@ struct DecadeFun {
 
 struct EpochFun {
 	static constexpr const char *Name = "epoch";
-	static constexpr const char *Parameters = "ts";
-	static constexpr const char *Description = "Extract the epoch component from a date or timestamp";
+	static constexpr const char *Parameters = "temporal";
+	static constexpr const char *Description = "Extract the epoch component from a temporal type";
 	static constexpr const char *Example = "epoch(timestamp '2021-08-03 11:59:44.123456')";
 
 	static ScalarFunctionSet GetFunctions();
@@ -172,25 +172,25 @@ struct EpochFun {
 struct EpochMsFun {
 	static constexpr const char *Name = "epoch_ms";
 	static constexpr const char *Parameters = "temporal";
-	static constexpr const char *Description = "Return the total number of milliseconds since the epoch";
+	static constexpr const char *Description = "Extract the epoch component in milliseconds from a temporal type";
 	static constexpr const char *Example = "epoch_ms(timestamp '2021-08-03 11:59:44.123456')";
 
 	static ScalarFunctionSet GetFunctions();
 };
 
-struct EpochMicrosecondsFun {
+struct EpochUsFun {
 	static constexpr const char *Name = "epoch_us";
 	static constexpr const char *Parameters = "temporal";
-	static constexpr const char *Description = "Return the total number of microseconds since the epoch";
+	static constexpr const char *Description = "Extract the epoch component in microseconds from a temporal type";
 	static constexpr const char *Example = "epoch_us(timestamp '2021-08-03 11:59:44.123456')";
 
 	static ScalarFunctionSet GetFunctions();
 };
 
-struct EpochNanosecondsFun {
+struct EpochNsFun {
 	static constexpr const char *Name = "epoch_ns";
 	static constexpr const char *Parameters = "temporal";
-	static constexpr const char *Description = "Return the total number of nanooseconds since the epoch";
+	static constexpr const char *Description = "Extract the epoch component in nanoseconds from a temporal type";
 	static constexpr const char *Example = "epoch_ns(timestamp '2021-08-03 11:59:44.123456')";
 
 	static ScalarFunctionSet GetFunctions();
@@ -291,7 +291,7 @@ struct MakeTimeFun {
 
 struct MakeTimestampFun {
 	static constexpr const char *Name = "make_timestamp";
-	static constexpr const char *Parameters = "year,month,day,hour,minute,seconds; or just microseconds since the epoch";
+	static constexpr const char *Parameters = "year,month,day,hour,minute,seconds";
 	static constexpr const char *Description = "The timestamp for the given parts";
 	static constexpr const char *Example = "make_timestamp(1992, 9, 20, 13, 34, 27.123456)";
 
@@ -490,8 +490,8 @@ struct ToSecondsFun {
 struct ToTimestampFun {
 	static constexpr const char *Name = "to_timestamp";
 	static constexpr const char *Parameters = "sec";
-	static constexpr const char *Description = "Converts sec since epoch to a timestamp";
-	static constexpr const char *Example = "to_timestamp(701222400)";
+	static constexpr const char *Description = "Converts secs since epoch to a timestamp with time zone";
+	static constexpr const char *Example = "to_timestamp(1284352323.5)";
 
 	static ScalarFunction GetFunction();
 };
@@ -508,7 +508,7 @@ struct ToYearsFun {
 struct TryStrpTimeFun {
 	static constexpr const char *Name = "try_strptime";
 	static constexpr const char *Parameters = "text,format";
-	static constexpr const char *Description = "Converts string to timestamp with time zone according to the format string if %Z is specified. Returns NULL on failure.";
+	static constexpr const char *Description = "Converts string to timestamp using the format string (timestamp with time zone if %Z is specified). Returns NULL on failure.";
 	static constexpr const char *Example = "try_strptime('Wed, 1 January 1992 - 08:38:40 PM', '%a, %-d %B %Y - %I:%M:%S %p')";
 
 	static ScalarFunctionSet GetFunctions();

package/src/duckdb/src/include/duckdb/execution/operator/scan/physical_table_scan.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/function/table_function.hpp"
 #include "duckdb/planner/table_filter.hpp"
 #include "duckdb/storage/data_table.hpp"
+#include "duckdb/common/extra_operator_info.hpp"
 
 namespace duckdb {
 
@@ -28,7 +29,8 @@ public:
 	//! Table scan that immediately projects out filter columns that are unused in the remainder of the query plan
 	PhysicalTableScan(vector<LogicalType> types, TableFunction function, unique_ptr<FunctionData> bind_data,
 	                  vector<LogicalType> returned_types, vector<column_t> column_ids, vector<idx_t> projection_ids,
-	                  vector<string> names, unique_ptr<TableFilterSet> table_filters, idx_t estimated_cardinality);
+	                  vector<string> names, unique_ptr<TableFilterSet> table_filters, idx_t estimated_cardinality,
+	                  ExtraOperatorInfo extra_info);
 
 	//! The table function
 	TableFunction function;
@@ -44,6 +46,8 @@ public:
 	vector<string> names;
 	//! The table filters
 	unique_ptr<TableFilterSet> table_filters;
+	//! Currently stores any filters applied to file names (as strings)
+	ExtraOperatorInfo extra_info;
 
 public:
 	string GetName() const override;

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

@@ -9,15 +9,18 @@
 #pragma once
 
 #include "duckdb/main/relation.hpp"
+#include "duckdb/common/enums/joinref_type.hpp"
 
 namespace duckdb {
 
 class CrossProductRelation : public Relation {
 public:
-	DUCKDB_API CrossProductRelation(shared_ptr<Relation> left, shared_ptr<Relation> right);
+	DUCKDB_API CrossProductRelation(shared_ptr<Relation> left, shared_ptr<Relation> right,
+	                                JoinRefType join_ref_type = JoinRefType::CROSS);
 
 	shared_ptr<Relation> left;
 	shared_ptr<Relation> right;
+	JoinRefType ref_type;
 	vector<ColumnDefinition> columns;
 
 public:

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

@@ -9,21 +9,24 @@
 #pragma once
 
 #include "duckdb/main/relation.hpp"
+#include "duckdb/common/enums/joinref_type.hpp"
 
 namespace duckdb {
 
 class JoinRelation : public Relation {
 public:
 	DUCKDB_API JoinRelation(shared_ptr<Relation> left, shared_ptr<Relation> right,
-	                        unique_ptr<ParsedExpression> condition, JoinType type);
+	                        unique_ptr<ParsedExpression> condition, JoinType type,
+	                        JoinRefType join_ref_type = JoinRefType::REGULAR);
 	DUCKDB_API JoinRelation(shared_ptr<Relation> left, shared_ptr<Relation> right, vector<string> using_columns,
-	                        JoinType type);
+	                        JoinType type, JoinRefType join_ref_type = JoinRefType::REGULAR);
 
 	shared_ptr<Relation> left;
 	shared_ptr<Relation> right;
 	unique_ptr<ParsedExpression> condition;
 	vector<string> using_columns;
 	JoinType join_type;
+	JoinRefType join_ref_type;
 	vector<ColumnDefinition> columns;
 
 public:

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

@@ -12,6 +12,7 @@
 #include "duckdb/common/enums/join_type.hpp"
 #include "duckdb/common/enums/relation_type.hpp"
 #include "duckdb/common/winapi.hpp"
+#include "duckdb/common/enums/joinref_type.hpp"
 #include "duckdb/main/query_result.hpp"
 #include "duckdb/parser/column_definition.hpp"
 #include "duckdb/common/named_parameter_map.hpp"
@@ -94,10 +95,11 @@ public:
 
 	// JOIN operation
 	DUCKDB_API shared_ptr<Relation> Join(const shared_ptr<Relation> &other, const string &condition,
-	                                     JoinType type = JoinType::INNER);
+	                                     JoinType type = JoinType::INNER, JoinRefType ref_type = JoinRefType::REGULAR);
 
 	// CROSS PRODUCT operation
-	DUCKDB_API shared_ptr<Relation> CrossProduct(const shared_ptr<Relation> &other);
+	DUCKDB_API shared_ptr<Relation> CrossProduct(const shared_ptr<Relation> &other,
+	                                             JoinRefType join_ref_type = JoinRefType::CROSS);
 
 	// SET operations
 	DUCKDB_API shared_ptr<Relation> Union(const shared_ptr<Relation> &other);

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

@@ -122,6 +122,15 @@ struct DefaultNullOrderSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct DisabledFileSystemsSetting {
+	static constexpr const char *Name = "disabled_filesystems";
+	static constexpr const char *Description = "Disable specific file systems preventing access (e.g. LocalFileSystem)";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	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)";

package/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp

@@ -11,6 +11,7 @@
 #include "duckdb/function/table_function.hpp"
 #include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/planner/table_filter.hpp"
+#include "duckdb/common/extra_operator_info.hpp"
 
 namespace duckdb {
 
@@ -49,6 +50,9 @@ public:
 	vector<string> input_table_names;
 	//! For a table-in-out function, the set of projected input columns
 	vector<column_t> projected_input;
+	//! Currently stores File Filters (as strings) applied by hive partitioning/complex filter pushdown
+	//! Stored so the can be included in explain output
+	ExtraOperatorInfo extra_info;
 
 	string GetName() const override;
 	string ParamsToString() const override;

package/src/duckdb/src/main/config.cpp

@@ -63,6 +63,7 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting
                                                  DUCKDB_GLOBAL_LOCAL(DefaultCollationSetting),
                                                  DUCKDB_GLOBAL(DefaultOrderSetting),
                                                  DUCKDB_GLOBAL(DefaultNullOrderSetting),
+                                                 DUCKDB_GLOBAL(DisabledFileSystemsSetting),
                                                  DUCKDB_GLOBAL(DisabledOptimizersSetting),
                                                  DUCKDB_GLOBAL(EnableExternalAccessSetting),
                                                  DUCKDB_GLOBAL(EnableFSSTVectors),

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

@@ -4,8 +4,10 @@
 #include "duckdb/common/string_util.hpp"
 
 #ifndef DISABLE_DUCKDB_REMOTE_INSTALL
+#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
 #include "httplib.hpp"
 #endif
+#endif
 #include "duckdb/common/windows_undefs.hpp"
 
 #include <fstream>
@@ -152,6 +154,9 @@ void WriteExtensionFileToDisk(FileSystem &fs, const string &path, void *data, id
 
 void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *client_config, FileSystem &fs,
                                                const string &local_path, const string &extension, bool force_install) {
+#ifdef DUCKDB_DISABLE_EXTENSION_LOAD
+	throw PermissionException("Installing external extensions is disabled through a compile time flag");
+#else
 	if (!config.options.enable_external_access) {
 		throw PermissionException("Installing extensions is disabled through configuration");
 	}
@@ -237,6 +242,7 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 	WriteExtensionFileToDisk(fs, temp_path, (void *)decompressed_body.data(), decompressed_body.size());
 	fs.MoveFile(temp_path, local_extension_path);
 #endif
+#endif
 }
 
 } // namespace duckdb