duckdb 0.3.2-dev358.0 → 0.3.2-dev454.0

package/src/duckdb.cpp

@@ -4703,6 +4703,15 @@ void Catalog::DropEntry(ClientContext &context, DropInfo *info) {
 	lookup.schema->DropEntry(context, info);
 }
 
+CatalogEntry *Catalog::AddFunction(ClientContext &context, CreateFunctionInfo *info) {
+	auto schema = GetSchema(context, info->schema);
+	return AddFunction(context, schema, info);
+}
+
+CatalogEntry *Catalog::AddFunction(ClientContext &context, SchemaCatalogEntry *schema, CreateFunctionInfo *info) {
+	return schema->AddFunction(context, info);
+}
+
 SchemaCatalogEntry *Catalog::GetSchema(ClientContext &context, const string &schema_name, bool if_exists,
                                        QueryErrorContext error_context) {
 	D_ASSERT(!schema_name.empty());
@@ -6659,6 +6668,37 @@ CatalogEntry *SchemaCatalogEntry::CreateFunction(ClientContext &context, CreateF
 	return AddEntry(context, move(function), info->on_conflict);
 }
 
+CatalogEntry *SchemaCatalogEntry::AddFunction(ClientContext &context, CreateFunctionInfo *info) {
+	auto entry = GetCatalogSet(info->type).GetEntry(context, info->name);
+	if (!entry) {
+		return CreateFunction(context, info);
+	}
+
+	info->on_conflict = OnCreateConflict::REPLACE_ON_CONFLICT;
+	switch (info->type) {
+	case CatalogType::SCALAR_FUNCTION_ENTRY: {
+		auto scalar_info = (CreateScalarFunctionInfo *)info;
+		auto &scalars = *(ScalarFunctionCatalogEntry *)entry;
+		for (const auto &scalar : scalars.functions) {
+			scalar_info->functions.emplace_back(scalar);
+		}
+		break;
+	}
+	case CatalogType::AGGREGATE_FUNCTION_ENTRY: {
+		auto agg_info = (CreateAggregateFunctionInfo *)info;
+		auto &aggs = *(AggregateFunctionCatalogEntry *)entry;
+		for (const auto &agg : aggs.functions) {
+			agg_info->functions.AddFunction(agg);
+		}
+		break;
+	}
+	default:
+		// Macros can only be replaced because there is only one of each name.
+		throw InternalException("Unsupported function type \"%s\" for adding", CatalogTypeToString(info->type));
+	}
+	return CreateFunction(context, info);
+}
+
 void SchemaCatalogEntry::DropEntry(ClientContext &context, DropInfo *info) {
 	auto &set = GetCatalogSet(info->type);
 
@@ -21591,7 +21631,7 @@ unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path, uint8_t fla
 	DWORD desired_access;
 	DWORD share_mode;
 	DWORD creation_disposition = OPEN_EXISTING;
-	DWORD flags_and_attributes = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED;
+	DWORD flags_and_attributes = FILE_ATTRIBUTE_NORMAL;
 	bool open_read = flags & FileFlags::FILE_FLAGS_READ;
 	bool open_write = flags & FileFlags::FILE_FLAGS_WRITE;
 	if (open_read && open_write) {
@@ -21612,9 +21652,6 @@ unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path, uint8_t fla
 		} else if (flags & FileFlags::FILE_FLAGS_FILE_CREATE_NEW) {
 			creation_disposition = CREATE_ALWAYS;
 		}
-		if (flags & FileFlags::FILE_FLAGS_DIRECT_IO) {
-			flags_and_attributes |= FILE_FLAG_WRITE_THROUGH;
-		}
 	}
 	if (flags & FileFlags::FILE_FLAGS_DIRECT_IO) {
 		flags_and_attributes |= FILE_FLAG_NO_BUFFERING;
@@ -21644,7 +21681,6 @@ idx_t LocalFileSystem::GetFilePointer(FileHandle &handle) {
 
 static DWORD FSInternalRead(FileHandle &handle, HANDLE hFile, void *buffer, int64_t nr_bytes, idx_t location) {
 	DWORD bytes_read = 0;
-	bool overlapped_read = false;
 	OVERLAPPED ov = {};
 	ov.Internal = 0;
 	ov.InternalHigh = 0;
@@ -21652,20 +21688,9 @@ static DWORD FSInternalRead(FileHandle &handle, HANDLE hFile, void *buffer, int6
 	ov.OffsetHigh = location >> 32;
 	ov.hEvent = 0;
 	auto rc = ReadFile(hFile, buffer, (DWORD)nr_bytes, &bytes_read, &ov);
-	if (rc == 0) {
-		if (GetLastError() != ERROR_IO_PENDING) {
-			auto error = GetLastErrorAsString();
-			throw IOException("Could not read file \"%s\" (error in ReadFile): %s", handle.path, error);
-		} else {
-			overlapped_read = true;
-		}
-	}
-	if (overlapped_read) {
-		rc = GetOverlappedResult(hFile, &ov, &bytes_read, true);
-		if (rc == 0) {
-			auto error = GetLastErrorAsString();
-			throw IOException("Could not read file \"%s\" (error in GetOverlappedResult): %s", handle.path, error);
-		}
+	if (!rc) {
+		auto error = GetLastErrorAsString();
+		throw IOException("Could not read file \"%s\" (error in ReadFile): %s", handle.path, error);
 	}
 	return bytes_read;
 }
@@ -21690,7 +21715,6 @@ int64_t LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes
 
 static DWORD FSInternalWrite(FileHandle &handle, HANDLE hFile, void *buffer, int64_t nr_bytes, idx_t location) {
 	DWORD bytes_written = 0;
-	bool overlapped_write = false;
 	OVERLAPPED ov = {};
 	ov.Internal = 0;
 	ov.InternalHigh = 0;
@@ -21698,20 +21722,9 @@ static DWORD FSInternalWrite(FileHandle &handle, HANDLE hFile, void *buffer, int
 	ov.OffsetHigh = location >> 32;
 	ov.hEvent = 0;
 	auto rc = WriteFile(hFile, buffer, (DWORD)nr_bytes, &bytes_written, &ov);
-	if (rc == 0) {
-		if (GetLastError() != ERROR_IO_PENDING) {
-			auto error = GetLastErrorAsString();
-			throw IOException("Could not write file \"%s\" (error in WriteFile): %s", handle.path, error);
-		} else {
-			overlapped_write = true;
-		}
-	}
-	if (overlapped_write) {
-		rc = GetOverlappedResult(hFile, &ov, &bytes_written, true);
-		if (rc == 0) {
-			auto error = GetLastErrorAsString();
-			throw IOException("Could not write file \"%s\" (error in GetOverlappedResult): %s", handle.path, error);
-		}
+	if (!rc) {
+		auto error = GetLastErrorAsString();
+		throw IOException("Could not write file \"%s\" (error in WriteFile): %s", handle.path, error);
 	}
 	return bytes_written;
 }
@@ -22907,6 +22920,21 @@ duckdb::string_t StringCast::Operation(dtime_t input, Vector &result);
 template <>
 duckdb::string_t StringCast::Operation(timestamp_t input, Vector &result);
 
+//! Temporary casting for Time Zone types. TODO: turn casting into functions.
+struct StringCastTZ {
+	template <typename SRC>
+	static inline string_t Operation(SRC input, Vector &vector) {
+		return StringCast::Operation(input, vector);
+	}
+};
+
+template <>
+duckdb::string_t StringCastTZ::Operation(date_t input, Vector &result);
+template <>
+duckdb::string_t StringCastTZ::Operation(dtime_t input, Vector &result);
+template <>
+duckdb::string_t StringCastTZ::Operation(timestamp_t input, Vector &result);
+
 } // namespace duckdb
 
 //===----------------------------------------------------------------------===//
@@ -26705,6 +26733,90 @@ duckdb::string_t StringCast::Operation(duckdb::string_t input, Vector &result) {
 	return StringVector::AddStringOrBlob(result, input);
 }
 
+template <>
+string_t StringCastTZ::Operation(date_t input, Vector &vector) {
+	int32_t date[3];
+	Date::Convert(input, date[0], date[1], date[2]);
+
+	// format for datetz is DATE+00
+	idx_t year_length;
+	bool add_bc;
+	const idx_t date_length = DateToStringCast::Length(date, year_length, add_bc);
+	const idx_t length = date_length + 3;
+
+	string_t result = StringVector::EmptyString(vector, length);
+	auto data = result.GetDataWriteable();
+
+	idx_t pos = 0;
+	DateToStringCast::Format(data + pos, date, year_length, add_bc);
+	pos += date_length;
+	data[pos++] = '+';
+	data[pos++] = '0';
+	data[pos++] = '0';
+
+	result.Finalize();
+	return result;
+}
+
+template <>
+string_t StringCastTZ::Operation(dtime_t input, Vector &vector) {
+	int32_t time[4];
+	Time::Convert(input, time[0], time[1], time[2], time[3]);
+
+	// format for timetz is TIME+00
+	char micro_buffer[10];
+	const auto time_length = TimeToStringCast::Length(time, micro_buffer);
+	const idx_t length = time_length + 3;
+
+	string_t result = StringVector::EmptyString(vector, length);
+	auto data = result.GetDataWriteable();
+
+	idx_t pos = 0;
+	TimeToStringCast::Format(data + pos, length, time, micro_buffer);
+	pos += time_length;
+	data[pos++] = '+';
+	data[pos++] = '0';
+	data[pos++] = '0';
+
+	result.Finalize();
+	return result;
+}
+
+template <>
+string_t StringCastTZ::Operation(timestamp_t input, Vector &vector) {
+	date_t date_entry;
+	dtime_t time_entry;
+	Timestamp::Convert(input, date_entry, time_entry);
+
+	int32_t date[3], time[4];
+	Date::Convert(date_entry, date[0], date[1], date[2]);
+	Time::Convert(time_entry, time[0], time[1], time[2], time[3]);
+
+	// format for timestamptz is DATE TIME+00 (separated by space)
+	idx_t year_length;
+	bool add_bc;
+	char micro_buffer[6];
+	const idx_t date_length = DateToStringCast::Length(date, year_length, add_bc);
+	const idx_t time_length = TimeToStringCast::Length(time, micro_buffer);
+	const idx_t length = date_length + 1 + time_length + 3;
+
+	string_t result = StringVector::EmptyString(vector, length);
+	auto data = result.GetDataWriteable();
+
+	idx_t pos = 0;
+	DateToStringCast::Format(data + pos, date, year_length, add_bc);
+	pos += date_length;
+	data[pos++] = ' ';
+	TimeToStringCast::Format(data + pos, time_length, time, micro_buffer);
+	pos += time_length;
+	data[pos++] = '+';
+	data[pos++] = '0';
+	data[pos++] = '0';
+
+	result.Finalize();
+	return result;
+}
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -36140,6 +36252,9 @@ void SetArrowChild(DuckDBArrowArrayChildHolder &child_holder, const LogicalType
 	case LogicalTypeId::TIMESTAMP_NS:
 	case LogicalTypeId::TIMESTAMP_SEC:
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::DATE_TZ:
+	case LogicalTypeId::TIMESTAMP_TZ:
+	case LogicalTypeId::TIME_TZ:
 		child_holder.vector = make_unique<Vector>(data);
 		child.n_buffers = 2;
 		child.buffers[1] = (void *)FlatVector::GetData(*child_holder.vector);
@@ -37908,8 +38023,8 @@ enum class DatePartSpecifier : uint8_t {
 	YEARWEEK
 };
 
-bool TryGetDatePartSpecifier(const string &specifier, DatePartSpecifier &result);
-DatePartSpecifier GetDatePartSpecifier(const string &specifier);
+DUCKDB_API bool TryGetDatePartSpecifier(const string &specifier, DatePartSpecifier &result);
+DUCKDB_API DatePartSpecifier GetDatePartSpecifier(const string &specifier);
 
 } // namespace duckdb
 
@@ -39135,6 +39250,28 @@ string Time::ToString(dtime_t time) {
 	return string(buffer.get(), length);
 }
 
+string Time::ToUTCOffset(int hour_offset, int minute_offset) {
+	dtime_t time((hour_offset * Interval::MINS_PER_HOUR + minute_offset) * Interval::MICROS_PER_MINUTE);
+
+	char buffer[1 + 2 + 1 + 2];
+	idx_t length = 0;
+	buffer[length++] = (time.micros < 0 ? '-' : '+');
+	time.micros = std::abs(time.micros);
+
+	int32_t time_units[4];
+	Time::Convert(time, time_units[0], time_units[1], time_units[2], time_units[3]);
+
+	TimeToStringCast::FormatTwoDigits(buffer + length, time_units[0]);
+	length += 2;
+	if (time_units[1]) {
+		buffer[length++] = ':';
+		TimeToStringCast::FormatTwoDigits(buffer + length, time_units[1]);
+		length += 2;
+	}
+
+	return string(buffer, length);
+}
+
 dtime_t Time::FromTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds) {
 	int64_t result;
 	result = hour;                                             // hours
@@ -39801,6 +39938,12 @@ Value Value::MinimumValue(const LogicalType &type) {
 		return Value::TimestampMs(timestamp_t(NumericLimits<int64_t>::Minimum()));
 	case LogicalTypeId::TIMESTAMP_NS:
 		return Value::TimestampNs(timestamp_t(NumericLimits<int64_t>::Minimum()));
+	case LogicalTypeId::DATE_TZ:
+		return Value::DATETZ(date_t(NumericLimits<int32_t>::Minimum()));
+	case LogicalTypeId::TIME_TZ:
+		return Value::TIMETZ(dtime_t(0));
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return Value::TIMESTAMPTZ(timestamp_t(NumericLimits<int64_t>::Minimum()));
 	case LogicalTypeId::FLOAT:
 		return Value::FLOAT(NumericLimits<float>::Minimum());
 	case LogicalTypeId::DOUBLE:
@@ -39886,6 +40029,12 @@ Value Value::MaximumValue(const LogicalType &type) {
 		return Value::TimestampNs(timestamp_t(NumericLimits<int64_t>::Maximum()));
 	case LogicalTypeId::TIMESTAMP_SEC:
 		return Value::TimestampSec(timestamp_t(NumericLimits<int64_t>::Maximum()));
+	case LogicalTypeId::DATE_TZ:
+		return Value::DATETZ(date_t(NumericLimits<int32_t>::Maximum()));
+	case LogicalTypeId::TIME_TZ:
+		return Value::TIMETZ(dtime_t(Interval::SECS_PER_DAY * Interval::MICROS_PER_SEC));
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return Value::TIMESTAMPTZ(timestamp_t(NumericLimits<int64_t>::Maximum()));
 	case LogicalTypeId::FLOAT:
 		return Value::FLOAT(NumericLimits<float>::Maximum());
 	case LogicalTypeId::DOUBLE:
@@ -40118,6 +40267,13 @@ Value Value::DATE(date_t value) {
 	return result;
 }
 
+Value Value::DATETZ(date_t value) {
+	Value result(LogicalType::DATE_TZ);
+	result.value_.date = value;
+	result.is_null = false;
+	return result;
+}
+
 Value Value::DATE(int32_t year, int32_t month, int32_t day) {
 	return Value::DATE(Date::FromDate(year, month, day));
 }
@@ -40129,6 +40285,13 @@ Value Value::TIME(dtime_t value) {
 	return result;
 }
 
+Value Value::TIMETZ(dtime_t value) {
+	Value result(LogicalType::TIME_TZ);
+	result.value_.time = value;
+	result.is_null = false;
+	return result;
+}
+
 Value Value::TIME(int32_t hour, int32_t min, int32_t sec, int32_t micros) {
 	return Value::TIME(Time::FromTime(hour, min, sec, micros));
 }
@@ -40140,6 +40303,13 @@ Value Value::TIMESTAMP(timestamp_t value) {
 	return result;
 }
 
+Value Value::TIMESTAMPTZ(timestamp_t value) {
+	Value result(LogicalType::TIMESTAMP_TZ);
+	result.value_.timestamp = value;
+	result.is_null = false;
+	return result;
+}
+
 Value Value::TimestampNs(timestamp_t timestamp) {
 	Value result(LogicalType::TIMESTAMP_NS);
 	result.value_.timestamp = timestamp;
@@ -40394,10 +40564,13 @@ T Value::GetValueInternal() const {
 	case LogicalTypeId::UUID:
 		return Cast::Operation<hugeint_t, T>(value_.hugeint);
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		return Cast::Operation<date_t, T>(value_.date);
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		return Cast::Operation<dtime_t, T>(value_.time);
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return Cast::Operation<timestamp_t, T>(value_.timestamp);
 	case LogicalTypeId::UTINYINT:
 		return Cast::Operation<uint8_t, T>(value_.utinyint);
@@ -40446,12 +40619,18 @@ int32_t Value::GetValue() const {
 }
 template <>
 int64_t Value::GetValue() const {
-	if (type_.id() == LogicalTypeId::TIMESTAMP || type_.id() == LogicalTypeId::TIME ||
-	    type_.id() == LogicalTypeId::TIMESTAMP_SEC || type_.id() == LogicalTypeId::TIMESTAMP_NS ||
-	    type_.id() == LogicalTypeId::TIMESTAMP_MS) {
+	switch (type_.id()) {
+	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_SEC:
+	case LogicalTypeId::TIMESTAMP_NS:
+	case LogicalTypeId::TIMESTAMP_MS:
+	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return value_.bigint;
+	default:
+		return GetValueInternal<int64_t>();
 	}
-	return GetValueInternal<int64_t>();
 }
 template <>
 hugeint_t Value::GetValue() const {
@@ -40729,6 +40908,12 @@ string Value::ToString() const {
 		return Time::ToString(value_.time);
 	case LogicalTypeId::TIMESTAMP:
 		return Timestamp::ToString(value_.timestamp);
+	case LogicalTypeId::DATE_TZ:
+		return Date::ToString(value_.date) + Time::ToUTCOffset(0, 0);
+	case LogicalTypeId::TIME_TZ:
+		return Time::ToString(value_.time) + Time::ToUTCOffset(0, 0);
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return Timestamp::ToString(value_.timestamp) + Time::ToUTCOffset(0, 0);
 	case LogicalTypeId::TIMESTAMP_SEC:
 		return Timestamp::ToString(Timestamp::FromEpochSeconds(value_.timestamp.value));
 	case LogicalTypeId::TIMESTAMP_MS:
@@ -41403,6 +41588,7 @@ void Vector::SetValue(idx_t index, const Value &val) {
 		((int16_t *)data)[index] = val.value_.smallint;
 		break;
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 	case LogicalTypeId::INTEGER:
 		((int32_t *)data)[index] = val.value_.integer;
 		break;
@@ -41413,6 +41599,8 @@ void Vector::SetValue(idx_t index, const Value &val) {
 	case LogicalTypeId::HASH:
 	case LogicalTypeId::TIME:
 	case LogicalTypeId::BIGINT:
+	case LogicalTypeId::TIMESTAMP_TZ:
+	case LogicalTypeId::TIME_TZ:
 		((int64_t *)data)[index] = val.value_.bigint;
 		break;
 	case LogicalTypeId::UTINYINT:
@@ -41555,8 +41743,12 @@ Value Vector::GetValue(idx_t index) const {
 		return Value::INTEGER(((int32_t *)data)[index]);
 	case LogicalTypeId::DATE:
 		return Value::DATE(((date_t *)data)[index]);
+	case LogicalTypeId::DATE_TZ:
+		return Value::DATETZ(((date_t *)data)[index]);
 	case LogicalTypeId::TIME:
 		return Value::TIME(((dtime_t *)data)[index]);
+	case LogicalTypeId::TIME_TZ:
+		return Value::TIMETZ(((dtime_t *)data)[index]);
 	case LogicalTypeId::BIGINT:
 		return Value::BIGINT(((int64_t *)data)[index]);
 	case LogicalTypeId::UTINYINT:
@@ -41575,6 +41767,8 @@ Value Vector::GetValue(idx_t index) const {
 		return Value::TimestampMs(((timestamp_t *)data)[index]);
 	case LogicalTypeId::TIMESTAMP_SEC:
 		return Value::TimestampSec(((timestamp_t *)data)[index]);
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return Value::TIMESTAMPTZ(((timestamp_t *)data)[index]);
 	case LogicalTypeId::HUGEINT:
 		return Value::HUGEINT(((hugeint_t *)data)[index]);
 	case LogicalTypeId::UUID:
@@ -42148,7 +42342,7 @@ void Vector::Verify(const SelectionVector &sel, idx_t count) {
 
 	if (GetType().InternalType() == PhysicalType::STRUCT) {
 		auto &child_types = StructType::GetChildTypes(GetType());
-		D_ASSERT(child_types.size() > 0);
+		D_ASSERT(!child_types.empty());
 		if (GetVectorType() == VectorType::FLAT_VECTOR || GetVectorType() == VectorType::CONSTANT_VECTOR) {
 			// create a selection vector of the non-null entries of the struct vector
 			auto &children = StructVector::GetEntries(*this);
@@ -42578,13 +42772,16 @@ vector<idx_t> ListVector::Search(Vector &list, Value &key, idx_t row) {
 		                                       entry.length);
 		break;
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		::duckdb::TemplatedSearchInMap<date_t>(list, key.value_.date, offsets, key.is_null, entry.offset, entry.length);
 		break;
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		::duckdb::TemplatedSearchInMap<dtime_t>(list, key.value_.time, offsets, key.is_null, entry.offset,
 		                                        entry.length);
 		break;
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		::duckdb::TemplatedSearchInMap<timestamp_t>(list, key.value_.timestamp, offsets, key.is_null, entry.offset,
 		                                            entry.length);
 		break;
@@ -43381,6 +43578,7 @@ PhysicalType LogicalType::GetInternalType() {
 		return PhysicalType::UINT16;
 	case LogicalTypeId::SQLNULL:
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 	case LogicalTypeId::INTEGER:
 		return PhysicalType::INT32;
 	case LogicalTypeId::UINTEGER:
@@ -43391,6 +43589,8 @@ PhysicalType LogicalType::GetInternalType() {
 	case LogicalTypeId::TIMESTAMP_SEC:
 	case LogicalTypeId::TIMESTAMP_NS:
 	case LogicalTypeId::TIMESTAMP_MS:
+	case LogicalTypeId::TIME_TZ:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return PhysicalType::INT64;
 	case LogicalTypeId::UBIGINT:
 		return PhysicalType::UINT64;
@@ -43484,6 +43684,11 @@ constexpr const LogicalTypeId LogicalType::TIMESTAMP_NS;
 constexpr const LogicalTypeId LogicalType::TIMESTAMP_S;
 
 constexpr const LogicalTypeId LogicalType::TIME;
+
+constexpr const LogicalTypeId LogicalType::DATE_TZ;
+constexpr const LogicalTypeId LogicalType::TIME_TZ;
+constexpr const LogicalTypeId LogicalType::TIMESTAMP_TZ;
+
 constexpr const LogicalTypeId LogicalType::HASH;
 constexpr const LogicalTypeId LogicalType::POINTER;
 
@@ -43512,7 +43717,8 @@ const vector<LogicalType> LogicalType::ALL_TYPES = {
     LogicalType::FLOAT,    LogicalType::VARCHAR,   LogicalType::BLOB,      LogicalType::INTERVAL,
     LogicalType::HUGEINT,  LogicalTypeId::DECIMAL, LogicalType::UTINYINT,  LogicalType::USMALLINT,
     LogicalType::UINTEGER, LogicalType::UBIGINT,   LogicalType::TIME,      LogicalTypeId::LIST,
-    LogicalTypeId::STRUCT, LogicalTypeId::MAP,     LogicalType::UUID};
+    LogicalTypeId::STRUCT, LogicalType::DATE_TZ,   LogicalType::TIME_TZ,   LogicalType::TIMESTAMP_TZ,
+    LogicalTypeId::MAP,    LogicalType::UUID};
 
 const LogicalType LOGICAL_ROW_TYPE = LogicalType::BIGINT;
 const PhysicalType ROW_TYPE = PhysicalType::INT64;
@@ -43694,6 +43900,12 @@ string LogicalTypeIdToString(LogicalTypeId id) {
 		return "TIMESTAMP (NS)";
 	case LogicalTypeId::TIMESTAMP_SEC:
 		return "TIMESTAMP (SEC)";
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return "TIMESTAMP WITH TIME ZONE";
+	case LogicalTypeId::TIME_TZ:
+		return "TIME WITH TIME ZONE";
+	case LogicalTypeId::DATE_TZ:
+		return "DATE WITH TIME ZONE";
 	case LogicalTypeId::FLOAT:
 		return "FLOAT";
 	case LogicalTypeId::DOUBLE:
@@ -43851,6 +44063,12 @@ LogicalTypeId TransformStringToLogicalType(const string &str) {
 		return LogicalTypeId::UINTEGER;
 	} else if (lower_str == "ubigint" || lower_str == "uint64") {
 		return LogicalTypeId::UBIGINT;
+	} else if (lower_str == "timestamptz") {
+		return LogicalTypeId::TIMESTAMP_TZ;
+	} else if (lower_str == "timetz") {
+		return LogicalTypeId::TIME_TZ;
+	} else if (lower_str == "datetz") {
+		return LogicalTypeId::DATE_TZ;
 	} else {
 		// This is a User Type, at this point we don't know if its one of the User Defined Types or an error
 		// It is checked in the binder
@@ -47308,12 +47526,15 @@ static bool StringCastSwitch(Vector &source, Vector &result, idx_t count, bool s
 	// now switch on the result type
 	switch (result.GetType().id()) {
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		return VectorTryCastErrorLoop<string_t, date_t, duckdb::TryCastErrorMessage>(source, result, count, strict,
 		                                                                             error_message);
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		return VectorTryCastErrorLoop<string_t, dtime_t, duckdb::TryCastErrorMessage>(source, result, count, strict,
 		                                                                              error_message);
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return VectorTryCastErrorLoop<string_t, timestamp_t, duckdb::TryCastErrorMessage>(source, result, count, strict,
 		                                                                                  error_message);
 	case LogicalTypeId::TIMESTAMP_NS:
@@ -47346,8 +47567,34 @@ static bool DateCastSwitch(Vector &source, Vector &result, idx_t count, string *
 		VectorStringCast<date_t, duckdb::StringCast>(source, result, count);
 		return true;
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		// date to timestamp
 		return VectorTryCastLoop<date_t, timestamp_t, duckdb::TryCast>(source, result, count, error_message);
+	case LogicalTypeId::DATE_TZ:
+		// date to date with time zone
+		UnaryExecutor::Execute<date_t, date_t, duckdb::Cast>(source, result, count);
+		return true;
+	default:
+		return TryVectorNullCast(source, result, count, error_message);
+	}
+}
+
+static bool DateTzCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
+	// now switch on the result type
+	switch (result.GetType().id()) {
+	case LogicalTypeId::VARCHAR:
+		// date with time zone to varchar
+		VectorStringCast<date_t, duckdb::StringCastTZ>(source, result, count);
+		return true;
+	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
+		// date with time zone to timestamp
+		return VectorTryCastLoop<date_t, timestamp_t, duckdb::TryCast>(source, result, count, error_message);
+	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
+		// date with time zone to date
+		UnaryExecutor::Execute<date_t, date_t, duckdb::Cast>(source, result, count);
+		return true;
 	default:
 		return TryVectorNullCast(source, result, count, error_message);
 	}
@@ -47360,6 +47607,26 @@ static bool TimeCastSwitch(Vector &source, Vector &result, idx_t count, string *
 		// time to varchar
 		VectorStringCast<dtime_t, duckdb::StringCast>(source, result, count);
 		return true;
+	case LogicalTypeId::TIME_TZ:
+		// time to time with time zone
+		UnaryExecutor::Execute<dtime_t, dtime_t, duckdb::Cast>(source, result, count);
+		return true;
+	default:
+		return TryVectorNullCast(source, result, count, error_message);
+	}
+}
+
+static bool TimeTzCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
+	// now switch on the result type
+	switch (result.GetType().id()) {
+	case LogicalTypeId::VARCHAR:
+		// time with time zone to varchar
+		VectorStringCast<dtime_t, duckdb::StringCastTZ>(source, result, count);
+		return true;
+	case LogicalTypeId::TIME:
+		// time with time zone to time
+		UnaryExecutor::Execute<dtime_t, dtime_t, duckdb::Cast>(source, result, count);
+		return true;
 	default:
 		return TryVectorNullCast(source, result, count, error_message);
 	}
@@ -47373,13 +47640,19 @@ static bool TimestampCastSwitch(Vector &source, Vector &result, idx_t count, str
 		VectorStringCast<timestamp_t, duckdb::StringCast>(source, result, count);
 		break;
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		// timestamp to date
 		UnaryExecutor::Execute<timestamp_t, date_t, duckdb::Cast>(source, result, count);
 		break;
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		// timestamp to time
 		UnaryExecutor::Execute<timestamp_t, dtime_t, duckdb::Cast>(source, result, count);
 		break;
+	case LogicalTypeId::TIMESTAMP_TZ:
+		// timestamp (us) to timestamp with time zone
+		UnaryExecutor::Execute<timestamp_t, timestamp_t, duckdb::Cast>(source, result, count);
+		break;
 	case LogicalTypeId::TIMESTAMP_NS:
 		// timestamp (us) to timestamp (ns)
 		UnaryExecutor::Execute<timestamp_t, timestamp_t, duckdb::CastTimestampUsToNs>(source, result, count);
@@ -47398,6 +47671,33 @@ static bool TimestampCastSwitch(Vector &source, Vector &result, idx_t count, str
 	return true;
 }
 
+static bool TimestampTzCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
+	// now switch on the result type
+	switch (result.GetType().id()) {
+	case LogicalTypeId::VARCHAR:
+		// timestamp with time zone to varchar
+		VectorStringCast<timestamp_t, duckdb::StringCastTZ>(source, result, count);
+		break;
+	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
+		// timestamp with time zone to date
+		UnaryExecutor::Execute<timestamp_t, date_t, duckdb::Cast>(source, result, count);
+		break;
+	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
+		// timestamp with time zone to time
+		UnaryExecutor::Execute<timestamp_t, dtime_t, duckdb::Cast>(source, result, count);
+		break;
+	case LogicalTypeId::TIMESTAMP:
+		// timestamp with time zone to timestamp (us)
+		UnaryExecutor::Execute<timestamp_t, timestamp_t, duckdb::Cast>(source, result, count);
+		break;
+	default:
+		return TryVectorNullCast(source, result, count, error_message);
+	}
+	return true;
+}
+
 static bool TimestampNsCastSwitch(Vector &source, Vector &result, idx_t count, string *error_message) {
 	// now switch on the result type
 	switch (result.GetType().id()) {
@@ -47746,10 +48046,16 @@ bool VectorOperations::TryCast(Vector &source, Vector &result, idx_t count, stri
 		return NumericCastSwitch<double>(source, result, count, error_message);
 	case LogicalTypeId::DATE:
 		return DateCastSwitch(source, result, count, error_message);
+	case LogicalTypeId::DATE_TZ:
+		return DateTzCastSwitch(source, result, count, error_message);
 	case LogicalTypeId::TIME:
 		return TimeCastSwitch(source, result, count, error_message);
+	case LogicalTypeId::TIME_TZ:
+		return TimeTzCastSwitch(source, result, count, error_message);
 	case LogicalTypeId::TIMESTAMP:
 		return TimestampCastSwitch(source, result, count, error_message);
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return TimestampTzCastSwitch(source, result, count, error_message);
 	case LogicalTypeId::TIMESTAMP_NS:
 		return TimestampNsCastSwitch(source, result, count, error_message);
 	case LogicalTypeId::TIMESTAMP_MS:
@@ -73441,6 +73747,12 @@ struct ApproxCountDistinctFunctionString : ApproxCountDistinctFunctionBase {
 	}
 };
 
+template <typename INPUT_TYPE, typename RESULT_TYPE>
+AggregateFunction GetApproxCountDistinctFunction(const LogicalType &input_type, const LogicalType &result_type) {
+	return AggregateFunction::UnaryAggregateDestructor<ApproxDistinctCountState, INPUT_TYPE, RESULT_TYPE,
+	                                                   ApproxCountDistinctFunction>(input_type, result_type);
+}
+
 AggregateFunction GetApproxCountDistinctFunction(PhysicalType type) {
 	switch (type) {
 	case PhysicalType::UINT16:
@@ -73496,9 +73808,10 @@ void ApproxCountDistinctFun::RegisterFunction(BuiltinFunctions &set) {
 	approx_count.AddFunction(GetApproxCountDistinctFunction(PhysicalType::INT64));
 	approx_count.AddFunction(GetApproxCountDistinctFunction(PhysicalType::DOUBLE));
 	approx_count.AddFunction(GetApproxCountDistinctFunction(PhysicalType::VARCHAR));
-	approx_count.AddFunction(AggregateFunction::UnaryAggregateDestructor<ApproxDistinctCountState, int64_t, int64_t,
-	                                                                     ApproxCountDistinctFunction>(
-	    LogicalType::TIMESTAMP, LogicalType::BIGINT));
+	approx_count.AddFunction(
+	    GetApproxCountDistinctFunction<int64_t, int64_t>(LogicalType::TIMESTAMP, LogicalType::BIGINT));
+	approx_count.AddFunction(
+	    GetApproxCountDistinctFunction<int64_t, int64_t>(LogicalType::TIMESTAMP_TZ, LogicalType::BIGINT));
 	set.AddFunction(approx_count);
 }
 
@@ -73629,6 +73942,12 @@ AggregateFunction GetArgMinMaxFunctionArg2(LogicalTypeId arg_2, const LogicalTyp
 	case LogicalTypeId::TIMESTAMP:
 		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, timestamp_t>, T, timestamp_t, T, OP>(
 		    arg, LogicalType::TIMESTAMP, arg);
+	case LogicalTypeId::DATE_TZ:
+		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, date_t>, T, date_t, T, OP>(
+		    arg, LogicalType::DATE_TZ, arg);
+	case LogicalTypeId::TIMESTAMP_TZ:
+		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, timestamp_t>, T, timestamp_t, T, OP>(
+		    arg, LogicalType::TIMESTAMP_TZ, arg);
 	case LogicalTypeId::BLOB:
 		return AggregateFunction::BinaryAggregate<ArgMinMaxState<T, string_t>, T, string_t, T, OP>(
 		    arg, LogicalType::BLOB, arg);
@@ -73647,6 +73966,8 @@ void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::VARCHAR, LogicalType::INTEGER));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::DATE, LogicalType::INTEGER));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::TIMESTAMP, LogicalType::INTEGER));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::DATE_TZ, LogicalType::INTEGER));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::INTEGER));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int32_t>(LogicalTypeId::BLOB, LogicalType::INTEGER));
 		break;
 	case LogicalTypeId::BIGINT:
@@ -73656,6 +73977,8 @@ void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::VARCHAR, LogicalType::BIGINT));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::DATE, LogicalType::BIGINT));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::TIMESTAMP, LogicalType::BIGINT));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::DATE_TZ, LogicalType::BIGINT));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::BIGINT));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, int64_t>(LogicalTypeId::BLOB, LogicalType::BIGINT));
 		break;
 	case LogicalTypeId::DOUBLE:
@@ -73665,6 +73988,8 @@ void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::VARCHAR, LogicalType::DOUBLE));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::DATE, LogicalType::DOUBLE));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::TIMESTAMP, LogicalType::DOUBLE));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::DATE_TZ, LogicalType::DOUBLE));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::DOUBLE));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, double>(LogicalTypeId::BLOB, LogicalType::DOUBLE));
 		break;
 	case LogicalTypeId::VARCHAR:
@@ -73674,6 +73999,8 @@ void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::VARCHAR, LogicalType::VARCHAR));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::DATE, LogicalType::VARCHAR));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::TIMESTAMP, LogicalType::VARCHAR));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::DATE_TZ, LogicalType::VARCHAR));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::VARCHAR));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::BLOB, LogicalType::VARCHAR));
 		break;
 	case LogicalTypeId::DATE:
@@ -73683,6 +74010,19 @@ void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::VARCHAR, LogicalType::DATE));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::DATE, LogicalType::DATE));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::TIMESTAMP, LogicalType::DATE));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::DATE_TZ, LogicalType::DATE));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::DATE));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::BLOB, LogicalType::DATE));
+		break;
+	case LogicalTypeId::DATE_TZ:
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::INTEGER, LogicalType::DATE_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::BIGINT, LogicalType::DATE_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::DOUBLE, LogicalType::DATE_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::VARCHAR, LogicalType::DATE_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::DATE, LogicalType::DATE_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::TIMESTAMP, LogicalType::DATE_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::DATE_TZ, LogicalType::DATE_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::DATE_TZ));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, date_t>(LogicalTypeId::BLOB, LogicalType::DATE));
 		break;
 	case LogicalTypeId::TIMESTAMP:
@@ -73692,8 +74032,22 @@ void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::VARCHAR, LogicalType::TIMESTAMP));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::DATE, LogicalType::TIMESTAMP));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::TIMESTAMP, LogicalType::TIMESTAMP));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::DATE_TZ, LogicalType::TIMESTAMP));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::TIMESTAMP));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::BLOB, LogicalType::TIMESTAMP));
 		break;
+	case LogicalTypeId::TIMESTAMP_TZ:
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::INTEGER, LogicalType::TIMESTAMP_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::BIGINT, LogicalType::TIMESTAMP_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::DOUBLE, LogicalType::TIMESTAMP_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::VARCHAR, LogicalType::TIMESTAMP_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::DATE, LogicalType::TIMESTAMP_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::TIMESTAMP, LogicalType::TIMESTAMP_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::DATE_TZ, LogicalType::TIMESTAMP_TZ));
+		fun.AddFunction(
+		    GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, timestamp_t>(LogicalTypeId::BLOB, LogicalType::TIMESTAMP_TZ));
+		break;
 	case LogicalTypeId::BLOB:
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::INTEGER, LogicalType::BLOB));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::BIGINT, LogicalType::BLOB));
@@ -73701,6 +74055,8 @@ void GetArgMinMaxFunction(LogicalTypeId arg_1, AggregateFunctionSet &fun) {
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::VARCHAR, LogicalType::BLOB));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::DATE, LogicalType::BLOB));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::TIMESTAMP, LogicalType::BLOB));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::DATE_TZ, LogicalType::BLOB));
+		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::TIMESTAMP_TZ, LogicalType::BLOB));
 		fun.AddFunction(GetArgMinMaxFunctionArg2<OP, string_t>(LogicalTypeId::BLOB, LogicalType::BLOB));
 		break;
 	default:
@@ -73715,6 +74071,8 @@ void ArgMinFun::RegisterFunction(BuiltinFunctions &set) {
 	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::VARCHAR, fun);
 	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::DATE, fun);
 	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::TIMESTAMP, fun);
+	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::DATE_TZ, fun);
+	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::TIMESTAMP_TZ, fun);
 	GetArgMinMaxFunction<ArgMinOperation>(LogicalTypeId::BLOB, fun);
 	set.AddFunction(fun);
 
@@ -73735,6 +74093,8 @@ void ArgMaxFun::RegisterFunction(BuiltinFunctions &set) {
 	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::VARCHAR, fun);
 	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::DATE, fun);
 	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::TIMESTAMP, fun);
+	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::DATE_TZ, fun);
+	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::TIMESTAMP_TZ, fun);
 	GetArgMinMaxFunction<ArgMaxOperation>(LogicalTypeId::BLOB, fun);
 	set.AddFunction(fun);
 
@@ -74301,6 +74661,12 @@ struct EntropyFunctionString : EntropyFunctionBase {
 	}
 };
 
+template <typename INPUT_TYPE, typename RESULT_TYPE>
+AggregateFunction GetEntropyFunction(const LogicalType &input_type, const LogicalType &result_type) {
+	return AggregateFunction::UnaryAggregateDestructor<EntropyState<INPUT_TYPE>, INPUT_TYPE, RESULT_TYPE,
+	                                                   EntropyFunction>(input_type, result_type);
+}
+
 AggregateFunction GetEntropyFunction(PhysicalType type) {
 	switch (type) {
 	case PhysicalType::UINT16:
@@ -74348,9 +74714,8 @@ void EntropyFun::RegisterFunction(BuiltinFunctions &set) {
 	entropy.AddFunction(GetEntropyFunction(PhysicalType::INT64));
 	entropy.AddFunction(GetEntropyFunction(PhysicalType::DOUBLE));
 	entropy.AddFunction(GetEntropyFunction(PhysicalType::VARCHAR));
-	entropy.AddFunction(
-	    AggregateFunction::UnaryAggregateDestructor<EntropyState<int64_t>, int64_t, double, EntropyFunction>(
-	        LogicalType::TIMESTAMP, LogicalType::DOUBLE));
+	entropy.AddFunction(GetEntropyFunction<int64_t, double>(LogicalType::TIMESTAMP, LogicalType::DOUBLE));
+	entropy.AddFunction(GetEntropyFunction<int64_t, double>(LogicalType::TIMESTAMP_TZ, LogicalType::DOUBLE));
 	set.AddFunction(entropy);
 }
 
@@ -74589,10 +74954,13 @@ static AggregateFunction GetFirstFunction(const LogicalType &type) {
 		return GetFirstAggregateTemplated<int16_t, LAST>(type);
 	case LogicalTypeId::INTEGER:
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		return GetFirstAggregateTemplated<int32_t, LAST>(type);
 	case LogicalTypeId::BIGINT:
 	case LogicalTypeId::TIME:
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIME_TZ:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return GetFirstAggregateTemplated<int64_t, LAST>(type);
 	case LogicalTypeId::UTINYINT:
 		return GetFirstAggregateTemplated<uint8_t, LAST>(type);
@@ -74794,10 +75162,13 @@ static AggregateFunction GetUnaryAggregate(LogicalType type) {
 	case LogicalTypeId::SMALLINT:
 		return AggregateFunction::UnaryAggregate<MinMaxState<int16_t>, int16_t, int16_t, OP>(type, type);
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 	case LogicalTypeId::INTEGER:
 		return AggregateFunction::UnaryAggregate<MinMaxState<int32_t>, int32_t, int32_t, OP>(type, type);
 	case LogicalTypeId::TIMESTAMP:
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIMESTAMP_TZ:
+	case LogicalTypeId::TIME_TZ:
 	case LogicalTypeId::BIGINT:
 		return AggregateFunction::UnaryAggregate<MinMaxState<int64_t>, int64_t, int64_t, OP>(type, type);
 	case LogicalTypeId::UTINYINT:
@@ -77006,7 +77377,8 @@ unique_ptr<FunctionData> BindModeDecimal(ClientContext &context, AggregateFuncti
 }
 
 void ModeFun::RegisterFunction(BuiltinFunctions &set) {
-	const vector<LogicalType> TEMPORAL = {LogicalType::DATE, LogicalType::TIMESTAMP, LogicalType::TIME,
+	const vector<LogicalType> TEMPORAL = {LogicalType::DATE,    LogicalType::TIMESTAMP,    LogicalType::TIME,
+	                                      LogicalType::DATE_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::TIME_TZ,
 	                                      LogicalType::INTERVAL};
 
 	AggregateFunctionSet mode("mode");
@@ -77627,10 +77999,13 @@ AggregateFunction GetDiscreteQuantileAggregateFunction(const LogicalType &type)
 		break;
 
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		return GetTypedDiscreteQuantileAggregateFunction<int32_t, int32_t>(type);
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return GetTypedDiscreteQuantileAggregateFunction<int64_t, int64_t>(type);
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		return GetTypedDiscreteQuantileAggregateFunction<int64_t, int64_t>(type);
 	case LogicalTypeId::INTERVAL:
 		return GetTypedDiscreteQuantileAggregateFunction<interval_t, interval_t>(type);
@@ -77816,10 +78191,13 @@ AggregateFunction GetDiscreteQuantileListAggregateFunction(const LogicalType &ty
 		break;
 
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		return GetTypedDiscreteQuantileListAggregateFunction<date_t, date_t>(type);
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return GetTypedDiscreteQuantileListAggregateFunction<timestamp_t, timestamp_t>(type);
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		return GetTypedDiscreteQuantileListAggregateFunction<dtime_t, dtime_t>(type);
 	case LogicalTypeId::INTERVAL:
 		return GetTypedDiscreteQuantileListAggregateFunction<interval_t, interval_t>(type);
@@ -77877,8 +78255,10 @@ AggregateFunction GetContinuousQuantileAggregateFunction(const LogicalType &type
 	case LogicalTypeId::DATE:
 		return GetTypedContinuousQuantileAggregateFunction<date_t, timestamp_t>(type, LogicalType::TIMESTAMP);
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return GetTypedContinuousQuantileAggregateFunction<timestamp_t, timestamp_t>(type, type);
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		return GetTypedContinuousQuantileAggregateFunction<dtime_t, dtime_t>(type, type);
 
 	default:
@@ -77931,8 +78311,10 @@ AggregateFunction GetContinuousQuantileListAggregateFunction(const LogicalType &
 	case LogicalTypeId::DATE:
 		return GetTypedContinuousQuantileListAggregateFunction<date_t, timestamp_t>(type, LogicalType::TIMESTAMP);
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return GetTypedContinuousQuantileListAggregateFunction<timestamp_t, timestamp_t>(type, type);
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		return GetTypedContinuousQuantileListAggregateFunction<dtime_t, dtime_t>(type, type);
 
 	default:
@@ -78143,9 +78525,11 @@ AggregateFunction GetMedianAbsoluteDeviationAggregateFunction(const LogicalType
 		return GetTypedMedianAbsoluteDeviationAggregateFunction<date_t, timestamp_t, interval_t>(type,
 		                                                                                         LogicalType::INTERVAL);
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return GetTypedMedianAbsoluteDeviationAggregateFunction<timestamp_t, timestamp_t, interval_t>(
 		    type, LogicalType::INTERVAL);
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		return GetTypedMedianAbsoluteDeviationAggregateFunction<dtime_t, dtime_t, interval_t>(type,
 		                                                                                      LogicalType::INTERVAL);
 
@@ -78238,6 +78622,8 @@ unique_ptr<FunctionData> BindContinuousQuantileDecimalList(ClientContext &contex
 
 static bool CanInterpolate(const LogicalType &type) {
 	switch (type.id()) {
+	case LogicalTypeId::DATE_TZ:
+		// DATE_TZ cannot be interpolated without a time zone
 	case LogicalTypeId::INTERVAL:
 	case LogicalTypeId::VARCHAR:
 		return false;
@@ -78291,7 +78677,8 @@ void QuantileFun::RegisterFunction(BuiltinFunctions &set) {
 	const vector<LogicalType> QUANTILES = {LogicalType::TINYINT, LogicalType::SMALLINT, LogicalType::INTEGER,
 	                                       LogicalType::BIGINT,  LogicalType::HUGEINT,  LogicalType::FLOAT,
 	                                       LogicalType::DOUBLE,  LogicalType::DATE,     LogicalType::TIMESTAMP,
-	                                       LogicalType::TIME,    LogicalType::INTERVAL, LogicalType::VARCHAR};
+	                                       LogicalType::TIME,    LogicalType::DATE_TZ,  LogicalType::TIMESTAMP_TZ,
+	                                       LogicalType::TIME_TZ, LogicalType::INTERVAL, LogicalType::VARCHAR};
 
 	AggregateFunctionSet median("median");
 	median.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
@@ -78334,8 +78721,9 @@ void QuantileFun::RegisterFunction(BuiltinFunctions &set) {
 	mad.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
 	                                  nullptr, nullptr, nullptr, BindMedianAbsoluteDeviationDecimal));
 
-	const vector<LogicalType> MADS = {LogicalType::FLOAT, LogicalType::DOUBLE, LogicalType::DATE,
-	                                  LogicalType::TIMESTAMP, LogicalType::TIME};
+	const vector<LogicalType> MADS = {LogicalType::FLOAT,     LogicalType::DOUBLE, LogicalType::DATE,
+	                                  LogicalType::TIMESTAMP, LogicalType::TIME,   LogicalType::TIMESTAMP_TZ,
+	                                  LogicalType::TIME_TZ};
 	for (const auto &type : MADS) {
 		mad.AddFunction(GetMedianAbsoluteDeviationAggregateFunction(type));
 	}
@@ -78854,6 +79242,15 @@ unique_ptr<FunctionData> HistogramBindFunction(ClientContext &context, Aggregate
 	return make_unique<VariableReturnBindData>(function.return_type);
 }
 
+template <typename T>
+AggregateFunction GetHistogramFunction(const LogicalType &type) {
+	using STATE_TYPE = HistogramAggState<T>;
+	return AggregateFunction("histogram", {type}, LogicalTypeId::MAP, AggregateFunction::StateSize<STATE_TYPE>,
+	                         AggregateFunction::StateInitialize<STATE_TYPE, HistogramFunction>,
+	                         HistogramUpdateFunction<T>, HistogramCombineFunction<T>, HistogramFinalize<T>, nullptr,
+	                         HistogramBindFunction, AggregateFunction::StateDestroy<STATE_TYPE, HistogramFunction>);
+}
+
 AggregateFunction GetHistogramFunction(PhysicalType type) {
 	switch (type) {
 	case PhysicalType::UINT16:
@@ -78936,12 +79333,8 @@ void HistogramFun::RegisterFunction(BuiltinFunctions &set) {
 	fun.AddFunction(GetHistogramFunction(PhysicalType::FLOAT));
 	fun.AddFunction(GetHistogramFunction(PhysicalType::DOUBLE));
 	fun.AddFunction(GetHistogramFunction(PhysicalType::VARCHAR));
-	fun.AddFunction(AggregateFunction("histogram", {LogicalType::TIMESTAMP}, LogicalTypeId::MAP,
-	                                  AggregateFunction::StateSize<HistogramAggState<int64_t>>,
-	                                  AggregateFunction::StateInitialize<HistogramAggState<int64_t>, HistogramFunction>,
-	                                  HistogramUpdateFunction<int64_t>, HistogramCombineFunction<int64_t>,
-	                                  HistogramFinalize<int64_t>, nullptr, HistogramBindFunction,
-	                                  AggregateFunction::StateDestroy<HistogramAggState<int64_t>, HistogramFunction>));
+	fun.AddFunction(GetHistogramFunction<int64_t>(LogicalType::TIMESTAMP));
+	fun.AddFunction(GetHistogramFunction<int64_t>(LogicalType::TIMESTAMP_TZ));
 	set.AddFunction(fun);
 }
 
@@ -80228,6 +80621,11 @@ struct RLEFun {
 	static bool TypeIsSupported(PhysicalType type);
 };
 
+struct BitpackingFun {
+	static CompressionFunction GetFunction(PhysicalType type);
+	static bool TypeIsSupported(PhysicalType type);
+};
+
 } // namespace duckdb
 
 
@@ -80247,6 +80645,7 @@ static DefaultCompressionMethod internal_compression_methods[] = {
     {CompressionType::COMPRESSION_CONSTANT, ConstantFun::GetFunction, ConstantFun::TypeIsSupported},
     {CompressionType::COMPRESSION_UNCOMPRESSED, UncompressedFun::GetFunction, UncompressedFun::TypeIsSupported},
     {CompressionType::COMPRESSION_RLE, RLEFun::GetFunction, RLEFun::TypeIsSupported},
+    {CompressionType::COMPRESSION_BITPACKING, BitpackingFun::GetFunction, BitpackingFun::TypeIsSupported},
     {CompressionType::COMPRESSION_AUTO, nullptr, nullptr}};
 
 static CompressionFunction *FindCompressionFunction(CompressionFunctionSet &set, CompressionType type,
@@ -80295,6 +80694,7 @@ vector<CompressionFunction *> DBConfig::GetCompressionFunctions(PhysicalType dat
 	vector<CompressionFunction *> result;
 	TryLoadCompression(*this, result, CompressionType::COMPRESSION_UNCOMPRESSED, data_type);
 	TryLoadCompression(*this, result, CompressionType::COMPRESSION_RLE, data_type);
+	TryLoadCompression(*this, result, CompressionType::COMPRESSION_BITPACKING, data_type);
 	return result;
 }
 
@@ -85150,14 +85550,14 @@ static void LeastGreatestFunction(DataChunk &args, ExpressionState &state, Vecto
 	result.SetVectorType(result_type);
 }
 
+template <typename T, class OP>
+ScalarFunction GetLeastGreatestFunction(const LogicalType &type) {
+	return ScalarFunction({type}, type, LeastGreatestFunction<T, OP>, false, nullptr, nullptr, nullptr, nullptr, type);
+}
+
 template <class OP>
 static void RegisterLeastGreatest(BuiltinFunctions &set, const string &fun_name) {
 	ScalarFunctionSet fun_set(fun_name);
-	fun_set.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::DATE, LeastGreatestFunction<date_t, OP>, false,
-	                                   nullptr, nullptr, nullptr, nullptr, LogicalType::DATE));
-	fun_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP,
-	                                   LeastGreatestFunction<timestamp_t, OP>, false, nullptr, nullptr, nullptr,
-	                                   nullptr, LogicalType::TIMESTAMP));
 	fun_set.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::BIGINT, LeastGreatestFunction<int64_t, OP>,
 	                                   false, nullptr, nullptr, nullptr, nullptr, LogicalType::BIGINT));
 	fun_set.AddFunction(ScalarFunction({LogicalType::HUGEINT}, LogicalType::HUGEINT,
@@ -85168,6 +85568,15 @@ static void RegisterLeastGreatest(BuiltinFunctions &set, const string &fun_name)
 	fun_set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	                                   LeastGreatestFunction<string_t, OP, true>, false, nullptr, nullptr, nullptr,
 	                                   nullptr, LogicalType::VARCHAR));
+
+	fun_set.AddFunction(GetLeastGreatestFunction<timestamp_t, OP>(LogicalType::TIMESTAMP));
+	fun_set.AddFunction(GetLeastGreatestFunction<time_t, OP>(LogicalType::TIME));
+	fun_set.AddFunction(GetLeastGreatestFunction<date_t, OP>(LogicalType::DATE));
+
+	fun_set.AddFunction(GetLeastGreatestFunction<timestamp_t, OP>(LogicalType::TIMESTAMP_TZ));
+	fun_set.AddFunction(GetLeastGreatestFunction<time_t, OP>(LogicalType::TIME_TZ));
+	fun_set.AddFunction(GetLeastGreatestFunction<date_t, OP>(LogicalType::DATE_TZ));
+
 	set.AddFunction(fun_set);
 }
 
@@ -85735,12 +86144,15 @@ static void ExecuteListExtractInternal(const idx_t count, VectorData &list, Vect
 		ListExtractTemplate<double>(count, list, offsets, child_vector, list_size, result);
 		break;
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		ListExtractTemplate<date_t>(count, list, offsets, child_vector, list_size, result);
 		break;
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		ListExtractTemplate<dtime_t>(count, list, offsets, child_vector, list_size, result);
 		break;
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		ListExtractTemplate<timestamp_t>(count, list, offsets, child_vector, list_size, result);
 		break;
 	case LogicalTypeId::BLOB:
@@ -88165,8 +88577,8 @@ ScalarFunction AddFun::GetFunction(const LogicalType &left_type, const LogicalTy
 		}
 		break;
 	case LogicalTypeId::INTEGER:
-		if (right_type.id() == LogicalTypeId::DATE) {
-			return ScalarFunction("+", {left_type, right_type}, LogicalType::DATE,
+		if (right_type.id() == LogicalTypeId::DATE || right_type.id() == LogicalTypeId::DATE_TZ) {
+			return ScalarFunction("+", {left_type, right_type}, right_type,
 			                      ScalarFunction::BinaryFunction<int32_t, date_t, date_t, AddOperator>);
 		}
 		break;
@@ -88197,6 +88609,12 @@ ScalarFunction AddFun::GetFunction(const LogicalType &left_type, const LogicalTy
 			                      ScalarFunction::BinaryFunction<timestamp_t, interval_t, timestamp_t, AddOperator>);
 		}
 		break;
+	case LogicalTypeId::DATE_TZ:
+		if (right_type.id() == LogicalTypeId::INTEGER) {
+			return ScalarFunction("+", {left_type, right_type}, left_type,
+			                      ScalarFunction::BinaryFunction<date_t, int32_t, date_t, AddOperator>);
+		}
+		break;
 	default:
 		break;
 	}
@@ -88217,6 +88635,8 @@ void AddFun::RegisterFunction(BuiltinFunctions &set) {
 	// we can add integers to dates
 	functions.AddFunction(GetFunction(LogicalType::DATE, LogicalType::INTEGER));
 	functions.AddFunction(GetFunction(LogicalType::INTEGER, LogicalType::DATE));
+	functions.AddFunction(GetFunction(LogicalType::DATE_TZ, LogicalType::INTEGER));
+	functions.AddFunction(GetFunction(LogicalType::INTEGER, LogicalType::DATE_TZ));
 	// we can add intervals together
 	functions.AddFunction(GetFunction(LogicalType::INTERVAL, LogicalType::INTERVAL));
 	// we can add intervals to dates/times/timestamps
@@ -88387,6 +88807,15 @@ ScalarFunction SubtractFun::GetFunction(const LogicalType &left_type, const Logi
 			                      ScalarFunction::BinaryFunction<dtime_t, interval_t, dtime_t, SubtractTimeOperator>);
 		}
 		break;
+	case LogicalTypeId::DATE_TZ:
+		if (right_type.id() == LogicalTypeId::DATE_TZ) {
+			return ScalarFunction("-", {left_type, right_type}, LogicalType::BIGINT,
+			                      ScalarFunction::BinaryFunction<date_t, date_t, int64_t, SubtractOperator>);
+		} else if (right_type.id() == LogicalTypeId::INTEGER) {
+			return ScalarFunction("-", {left_type, right_type}, left_type,
+			                      ScalarFunction::BinaryFunction<date_t, int32_t, date_t, SubtractOperator>);
+		}
+		break;
 	default:
 		break;
 	}
@@ -88406,7 +88835,10 @@ void SubtractFun::RegisterFunction(BuiltinFunctions &set) {
 	}
 	// we can subtract dates from each other
 	functions.AddFunction(GetFunction(LogicalType::DATE, LogicalType::DATE));
+	functions.AddFunction(GetFunction(LogicalType::DATE_TZ, LogicalType::DATE_TZ));
+	// we can subtract integers from dates
 	functions.AddFunction(GetFunction(LogicalType::DATE, LogicalType::INTEGER));
+	functions.AddFunction(GetFunction(LogicalType::DATE_TZ, LogicalType::INTEGER));
 	// we can subtract timestamps from each other
 	functions.AddFunction(GetFunction(LogicalType::TIMESTAMP, LogicalType::TIMESTAMP));
 	// we can subtract intervals from each other
@@ -99189,6 +99621,9 @@ void DuckDBTypesFunction(ClientContext &context, const FunctionData *bind_data,
 		case LogicalTypeId::TIMESTAMP:
 		case LogicalTypeId::TIMESTAMP_NS:
 		case LogicalTypeId::INTERVAL:
+		case LogicalTypeId::DATE_TZ:
+		case LogicalTypeId::TIME_TZ:
+		case LogicalTypeId::TIMESTAMP_TZ:
 			category = "DATETIME";
 			break;
 		case LogicalTypeId::CHAR:
@@ -101579,10 +102014,13 @@ duckdb_type ConvertCPPTypeToC(const LogicalType &sql_type) {
 	case LogicalTypeId::TIMESTAMP_SEC:
 	case LogicalTypeId::TIMESTAMP_MS:
 	case LogicalTypeId::TIMESTAMP_NS:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return DUCKDB_TYPE_TIMESTAMP;
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		return DUCKDB_TYPE_DATE;
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		return DUCKDB_TYPE_TIME;
 	case LogicalTypeId::VARCHAR:
 		return DUCKDB_TYPE_VARCHAR;
@@ -101967,12 +102405,15 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 			WriteData<double>(out, result->collection, col);
 			break;
 		case LogicalTypeId::DATE:
+		case LogicalTypeId::DATE_TZ:
 			WriteData<date_t>(out, result->collection, col);
 			break;
 		case LogicalTypeId::TIME:
+		case LogicalTypeId::TIME_TZ:
 			WriteData<dtime_t>(out, result->collection, col);
 			break;
 		case LogicalTypeId::TIMESTAMP:
+		case LogicalTypeId::TIMESTAMP_TZ:
 			WriteData<timestamp_t>(out, result->collection, col);
 			break;
 		case LogicalTypeId::VARCHAR: {
@@ -102081,7 +102522,7 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 
 } // namespace duckdb
 
-static void duckdb_destroy_column(duckdb_column column, idx_t count) {
+static void DuckdbDestroyColumn(duckdb_column column, idx_t count) {
 	if (column.data) {
 		if (column.type == DUCKDB_TYPE_VARCHAR) {
 			// varchar, delete individual strings
@@ -102116,7 +102557,7 @@ void duckdb_destroy_result(duckdb_result *result) {
 	}
 	if (result->columns) {
 		for (idx_t i = 0; i < result->column_count; i++) {
-			duckdb_destroy_column(result->columns[i], result->row_count);
+			DuckdbDestroyColumn(result->columns[i], result->row_count);
 		}
 		duckdb_free(result->columns);
 	}
@@ -113881,12 +114322,15 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		child.format = "u";
 		break;
 	case LogicalTypeId::DATE:
+	case LogicalTypeId::DATE_TZ:
 		child.format = "tdD";
 		break;
 	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
 		child.format = "ttu";
 		break;
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		child.format = "tsu:";
 		break;
 	case LogicalTypeId::TIMESTAMP_SEC:
@@ -144328,7 +144772,11 @@ unique_ptr<CopyStatement> Transformer::TransformCopy(duckdb_libpgquery::PGNode *
 	// get file_path and is_from
 	info.file_path = stmt->filename;
 	info.is_from = stmt->is_from;
-	info.format = "csv";
+	if (StringUtil::EndsWith(info.file_path, ".parquet")) {
+		info.format = "parquet";
+	} else {
+		info.format = "csv";
+	}
 
 	// get select_list
 	if (stmt->attlist) {
@@ -153290,18 +153738,48 @@ bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const
 		}
 		return true;
 	}
-	if (source_type.id() == LogicalTypeId::TIMESTAMP && target_type.id() == LogicalTypeId::DATE) {
-		return false;
+	if (source_type.id() == LogicalTypeId::TIMESTAMP || source_type.id() == LogicalTypeId::TIMESTAMP_TZ) {
+		switch (target_type.id()) {
+		case LogicalTypeId::DATE:
+		case LogicalTypeId::TIME:
+		case LogicalTypeId::DATE_TZ:
+		case LogicalTypeId::TIME_TZ:
+			return false;
+		default:
+			break;
+		}
 	}
 	if (source_type.id() == LogicalTypeId::VARCHAR) {
-		return target_type.id() == LogicalTypeId::DATE || target_type.id() == LogicalTypeId::TIME ||
-		       target_type.id() == LogicalTypeId::TIMESTAMP || target_type.id() == LogicalTypeId::TIMESTAMP_NS ||
-		       target_type.id() == LogicalTypeId::TIMESTAMP_MS || target_type.id() == LogicalTypeId::TIMESTAMP_SEC;
+		switch (target_type.id()) {
+		case LogicalTypeId::DATE:
+		case LogicalTypeId::TIME:
+		case LogicalTypeId::TIMESTAMP:
+		case LogicalTypeId::TIMESTAMP_NS:
+		case LogicalTypeId::TIMESTAMP_MS:
+		case LogicalTypeId::TIMESTAMP_SEC:
+		case LogicalTypeId::DATE_TZ:
+		case LogicalTypeId::TIME_TZ:
+		case LogicalTypeId::TIMESTAMP_TZ:
+			return true;
+		default:
+			return false;
+		}
 	}
 	if (target_type.id() == LogicalTypeId::VARCHAR) {
-		return source_type.id() == LogicalTypeId::DATE || source_type.id() == LogicalTypeId::TIME ||
-		       source_type.id() == LogicalTypeId::TIMESTAMP || source_type.id() == LogicalTypeId::TIMESTAMP_NS ||
-		       source_type.id() == LogicalTypeId::TIMESTAMP_MS || source_type.id() == LogicalTypeId::TIMESTAMP_SEC;
+		switch (source_type.id()) {
+		case LogicalTypeId::DATE:
+		case LogicalTypeId::TIME:
+		case LogicalTypeId::TIMESTAMP:
+		case LogicalTypeId::TIMESTAMP_NS:
+		case LogicalTypeId::TIMESTAMP_MS:
+		case LogicalTypeId::TIMESTAMP_SEC:
+		case LogicalTypeId::DATE_TZ:
+		case LogicalTypeId::TIME_TZ:
+		case LogicalTypeId::TIMESTAMP_TZ:
+			return true;
+		default:
+			return false;
+		}
 	}
 	return true;
 }
@@ -158811,56 +159289,1170 @@ void PartialBlock::FlushToDisk(DatabaseInstance &db) {
 }
 
 } // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/segment/uncompressed.hpp
-//
-//
-//===----------------------------------------------------------------------===//
 
 
+// LICENSE_CHANGE_BEGIN
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #10
+// See the end of this file for a list
 
+/**
+* This code is released under the
+* Apache License Version 2.0 http://www.apache.org/licenses/.
+*
+* (c) Daniel Lemire, http://lemire.me/en/
+*/
 
 
-namespace duckdb {
-class DatabaseInstance;
 
-struct UncompressedFunctions {
-	static unique_ptr<CompressionState> InitCompression(ColumnDataCheckpointer &checkpointer,
-	                                                    unique_ptr<AnalyzeState> state);
-	static void Compress(CompressionState &state_p, Vector &data, idx_t count);
-	static void FinalizeCompress(CompressionState &state_p);
-	static void EmptySkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
+// LICENSE_CHANGE_BEGIN
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #10
+// See the end of this file for a list
+
+/**
+ * This code is released under the
+ * Apache License Version 2.0 http://www.apache.org/licenses/.
+ *
+ * (c) Daniel Lemire, http://fastpforlib.me/en/
+ */
+
+#include <cinttypes>
+#include <string>
+
+namespace duckdb_fastpforlib {
+namespace internal {
+
+// Unpacks 8 uint8_t values
+void __fastunpack0(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastunpack1(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastunpack2(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastunpack3(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastunpack4(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastunpack5(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastunpack6(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastunpack7(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastunpack8(const uint8_t *__restrict in, uint8_t *__restrict out);
+
+// Unpacks 16 uint16_t values
+void __fastunpack0(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack1(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack2(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack3(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack4(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack5(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack6(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack7(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack8(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack9(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack10(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack11(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack12(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack13(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack14(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack15(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastunpack16(const uint16_t *__restrict in, uint16_t *__restrict out);
+
+// Unpacks 32 uint32_t values
+void __fastunpack0(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack1(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack2(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack3(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack4(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack5(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack6(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack7(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack8(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack9(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack10(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack11(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack12(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack13(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack14(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack15(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack16(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack17(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack18(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack19(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack20(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack21(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack22(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack23(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack24(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack25(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack26(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack27(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack28(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack29(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack30(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack31(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastunpack32(const uint32_t *__restrict in, uint32_t *__restrict out);
+
+// Unpacks 32 uint64_t values
+void __fastunpack0(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack1(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack2(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack3(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack4(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack5(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack6(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack7(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack8(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack9(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack10(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack11(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack12(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack13(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack14(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack15(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack16(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack17(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack18(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack19(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack20(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack21(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack22(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack23(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack24(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack25(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack26(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack27(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack28(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack29(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack30(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack31(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack32(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack33(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack34(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack35(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack36(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack37(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack38(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack39(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack40(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack41(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack42(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack43(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack44(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack45(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack46(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack47(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack48(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack49(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack50(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack51(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack52(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack53(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack54(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack55(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack56(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack57(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack58(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack59(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack60(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack61(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack62(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack63(const uint32_t *__restrict in, uint64_t *__restrict out);
+void __fastunpack64(const uint32_t *__restrict in, uint64_t *__restrict out);
+
+// Packs 8 int8_t values
+void __fastpack0(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastpack1(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastpack2(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastpack3(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastpack4(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastpack5(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastpack6(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastpack7(const uint8_t *__restrict in, uint8_t *__restrict out);
+void __fastpack8(const uint8_t *__restrict in, uint8_t *__restrict out);
+
+// Packs 16 int16_t values
+void __fastpack0(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack1(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack2(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack3(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack4(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack5(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack6(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack7(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack8(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack9(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack10(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack11(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack12(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack13(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack14(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack15(const uint16_t *__restrict in, uint16_t *__restrict out);
+void __fastpack16(const uint16_t *__restrict in, uint16_t *__restrict out);
+
+// Packs 32 int32_t values
+void __fastpack0(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack1(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack2(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack3(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack4(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack5(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack6(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack7(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack8(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack9(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack10(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack11(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack12(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack13(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack14(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack15(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack16(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack17(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack18(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack19(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack20(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack21(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack22(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack23(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack24(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack25(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack26(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack27(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack28(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack29(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack30(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack31(const uint32_t *__restrict in, uint32_t *__restrict out);
+void __fastpack32(const uint32_t *__restrict in, uint32_t *__restrict out);
+
+// Packs 32 int64_t values
+void __fastpack0(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack1(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack2(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack3(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack4(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack5(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack6(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack7(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack8(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack9(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack10(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack11(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack12(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack13(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack14(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack15(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack16(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack17(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack18(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack19(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack20(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack21(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack22(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack23(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack24(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack25(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack26(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack27(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack28(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack29(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack30(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack31(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack32(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack33(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack34(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack35(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack36(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack37(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack38(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack39(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack40(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack41(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack42(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack43(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack44(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack45(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack46(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack47(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack48(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack49(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack50(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack51(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack52(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack53(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack54(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack55(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack56(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack57(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack58(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack59(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack60(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack61(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack62(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack63(const uint64_t *__restrict in, uint32_t *__restrict out);
+void __fastpack64(const uint64_t *__restrict in, uint32_t *__restrict out);
+} // namespace internal
+} // namespace duckdb_fastpforlib
+
+
+// LICENSE_CHANGE_END
+
+
+#include <stdexcept>
+
+namespace duckdb_fastpforlib {
+
+namespace internal {
+
+// Note that this only packs 8 values
+inline void fastunpack_quarter(const uint8_t *__restrict in, uint8_t *__restrict out, const uint32_t bit) {
+	// Could have used function pointers instead of switch.
+	// Switch calls do offer the compiler more opportunities for optimization in
+	// theory. In this case, it makes no difference with a good compiler.
+	switch (bit) {
+	case 0:
+		internal::__fastunpack0(in, out);
+		break;
+	case 1:
+		internal::__fastunpack1(in, out);
+		break;
+	case 2:
+		internal::__fastunpack2(in, out);
+		break;
+	case 3:
+		internal::__fastunpack3(in, out);
+		break;
+	case 4:
+		internal::__fastunpack4(in, out);
+		break;
+	case 5:
+		internal::__fastunpack5(in, out);
+		break;
+	case 6:
+		internal::__fastunpack6(in, out);
+		break;
+	case 7:
+		internal::__fastunpack7(in, out);
+		break;
+	case 8:
+		internal::__fastunpack8(in, out);
+		break;
+	default:
+		throw std::logic_error("Invalid bit width for bitpacking");
 	}
-};
+}
 
-struct FixedSizeUncompressed {
-	static CompressionFunction GetFunction(PhysicalType data_type);
-};
+// Note that this only packs 8 values
+inline void fastpack_quarter(const uint8_t *__restrict in, uint8_t *__restrict out, const uint32_t bit) {
+	// Could have used function pointers instead of switch.
+	// Switch calls do offer the compiler more opportunities for optimization in
+	// theory. In this case, it makes no difference with a good compiler.
+	switch (bit) {
+	case 0:
+		internal::__fastpack0(in, out);
+		break;
+	case 1:
+		internal::__fastpack1(in, out);
+		break;
+	case 2:
+		internal::__fastpack2(in, out);
+		break;
+	case 3:
+		internal::__fastpack3(in, out);
+		break;
+	case 4:
+		internal::__fastpack4(in, out);
+		break;
+	case 5:
+		internal::__fastpack5(in, out);
+		break;
+	case 6:
+		internal::__fastpack6(in, out);
+		break;
+	case 7:
+		internal::__fastpack7(in, out);
+		break;
+	case 8:
+		internal::__fastpack8(in, out);
+		break;
+	default:
+		throw std::logic_error("Invalid bit width for bitpacking");
+	}
+}
 
-struct ValidityUncompressed {
-public:
-	static CompressionFunction GetFunction(PhysicalType data_type);
+// Note that this only packs 16 values
+inline void fastunpack_half(const uint16_t *__restrict in, uint16_t *__restrict out, const uint32_t bit) {
+	// Could have used function pointers instead of switch.
+	// Switch calls do offer the compiler more opportunities for optimization in
+	// theory. In this case, it makes no difference with a good compiler.
+	switch (bit) {
+	case 0:
+		internal::__fastunpack0(in, out);
+		break;
+	case 1:
+		internal::__fastunpack1(in, out);
+		break;
+	case 2:
+		internal::__fastunpack2(in, out);
+		break;
+	case 3:
+		internal::__fastunpack3(in, out);
+		break;
+	case 4:
+		internal::__fastunpack4(in, out);
+		break;
+	case 5:
+		internal::__fastunpack5(in, out);
+		break;
+	case 6:
+		internal::__fastunpack6(in, out);
+		break;
+	case 7:
+		internal::__fastunpack7(in, out);
+		break;
+	case 8:
+		internal::__fastunpack8(in, out);
+		break;
+	case 9:
+		internal::__fastunpack9(in, out);
+		break;
+	case 10:
+		internal::__fastunpack10(in, out);
+		break;
+	case 11:
+		internal::__fastunpack11(in, out);
+		break;
+	case 12:
+		internal::__fastunpack12(in, out);
+		break;
+	case 13:
+		internal::__fastunpack13(in, out);
+		break;
+	case 14:
+		internal::__fastunpack14(in, out);
+		break;
+	case 15:
+		internal::__fastunpack15(in, out);
+		break;
+	case 16:
+		internal::__fastunpack16(in, out);
+		break;
+	default:
+		throw std::logic_error("Invalid bit width for bitpacking");
+	}
+}
 
-public:
-	static const validity_t LOWER_MASKS[65];
-	static const validity_t UPPER_MASKS[65];
-};
+// Note that this only packs 16 values
+inline void fastpack_half(const uint16_t *__restrict in, uint16_t *__restrict out, const uint32_t bit) {
+	// Could have used function pointers instead of switch.
+	// Switch calls do offer the compiler more opportunities for optimization in
+	// theory. In this case, it makes no difference with a good compiler.
+	switch (bit) {
+	case 0:
+		internal::__fastpack0(in, out);
+		break;
+	case 1:
+		internal::__fastpack1(in, out);
+		break;
+	case 2:
+		internal::__fastpack2(in, out);
+		break;
+	case 3:
+		internal::__fastpack3(in, out);
+		break;
+	case 4:
+		internal::__fastpack4(in, out);
+		break;
+	case 5:
+		internal::__fastpack5(in, out);
+		break;
+	case 6:
+		internal::__fastpack6(in, out);
+		break;
+	case 7:
+		internal::__fastpack7(in, out);
+		break;
+	case 8:
+		internal::__fastpack8(in, out);
+		break;
+	case 9:
+		internal::__fastpack9(in, out);
+		break;
+	case 10:
+		internal::__fastpack10(in, out);
+		break;
+	case 11:
+		internal::__fastpack11(in, out);
+		break;
+	case 12:
+		internal::__fastpack12(in, out);
+		break;
+	case 13:
+		internal::__fastpack13(in, out);
+		break;
+	case 14:
+		internal::__fastpack14(in, out);
+		break;
+	case 15:
+		internal::__fastpack15(in, out);
+		break;
+	case 16:
+		internal::__fastpack16(in, out);
+		break;
+	default:
+		throw std::logic_error("Invalid bit width for bitpacking");
+	}
+}
+}
 
-struct StringUncompressed {
-public:
-	static CompressionFunction GetFunction(PhysicalType data_type);
+inline void fastunpack(const uint8_t *__restrict in, uint8_t *__restrict out, const uint32_t bit) {
+	for (uint8_t i = 0; i < 4; i++) {
+		internal::fastunpack_quarter(in + (i*bit), out+(i*8), bit);
+	}
+}
 
-public:
-	//! The max string size that is allowed within a block. Strings bigger than this will be labeled as a BIG STRING and
-	//! offloaded to the overflow blocks.
-	static constexpr uint16_t STRING_BLOCK_LIMIT = 4096;
-};
+inline void fastunpack(const uint16_t *__restrict in, uint16_t *__restrict out, const uint32_t bit) {
+	internal::fastunpack_half(in, out, bit);
+	internal::fastunpack_half(in + bit, out+16, bit);
+}
 
-} // namespace duckdb
+inline void fastunpack(const uint32_t *__restrict in,
+                       uint32_t *__restrict out, const uint32_t bit) {
+  // Could have used function pointers instead of switch.
+  // Switch calls do offer the compiler more opportunities for optimization in
+  // theory. In this case, it makes no difference with a good compiler.
+  switch (bit) {
+  case 0:
+    internal::__fastunpack0(in, out);
+    break;
+  case 1:
+    internal::__fastunpack1(in, out);
+    break;
+  case 2:
+    internal::__fastunpack2(in, out);
+    break;
+  case 3:
+    internal::__fastunpack3(in, out);
+    break;
+  case 4:
+    internal::__fastunpack4(in, out);
+    break;
+  case 5:
+    internal::__fastunpack5(in, out);
+    break;
+  case 6:
+    internal::__fastunpack6(in, out);
+    break;
+  case 7:
+    internal::__fastunpack7(in, out);
+    break;
+  case 8:
+    internal::__fastunpack8(in, out);
+    break;
+  case 9:
+    internal::__fastunpack9(in, out);
+    break;
+  case 10:
+    internal::__fastunpack10(in, out);
+    break;
+  case 11:
+    internal::__fastunpack11(in, out);
+    break;
+  case 12:
+    internal::__fastunpack12(in, out);
+    break;
+  case 13:
+    internal::__fastunpack13(in, out);
+    break;
+  case 14:
+    internal::__fastunpack14(in, out);
+    break;
+  case 15:
+    internal::__fastunpack15(in, out);
+    break;
+  case 16:
+    internal::__fastunpack16(in, out);
+    break;
+  case 17:
+    internal::__fastunpack17(in, out);
+    break;
+  case 18:
+    internal::__fastunpack18(in, out);
+    break;
+  case 19:
+    internal::__fastunpack19(in, out);
+    break;
+  case 20:
+    internal::__fastunpack20(in, out);
+    break;
+  case 21:
+    internal::__fastunpack21(in, out);
+    break;
+  case 22:
+    internal::__fastunpack22(in, out);
+    break;
+  case 23:
+    internal::__fastunpack23(in, out);
+    break;
+  case 24:
+    internal::__fastunpack24(in, out);
+    break;
+  case 25:
+    internal::__fastunpack25(in, out);
+    break;
+  case 26:
+    internal::__fastunpack26(in, out);
+    break;
+  case 27:
+    internal::__fastunpack27(in, out);
+    break;
+  case 28:
+    internal::__fastunpack28(in, out);
+    break;
+  case 29:
+    internal::__fastunpack29(in, out);
+    break;
+  case 30:
+    internal::__fastunpack30(in, out);
+    break;
+  case 31:
+    internal::__fastunpack31(in, out);
+    break;
+  case 32:
+    internal::__fastunpack32(in, out);
+    break;
+  default:
+    throw std::logic_error("Invalid bit width for bitpacking");
+  }
+}
 
+inline void fastunpack(const uint32_t *__restrict in,
+                       uint64_t *__restrict out, const uint32_t bit) {
+  // Could have used function pointers instead of switch.
+  // Switch calls do offer the compiler more opportunities for optimization in
+  // theory. In this case, it makes no difference with a good compiler.
+  switch (bit) {
+  case 0:
+    internal::__fastunpack0(in, out);
+    break;
+  case 1:
+    internal::__fastunpack1(in, out);
+    break;
+  case 2:
+    internal::__fastunpack2(in, out);
+    break;
+  case 3:
+    internal::__fastunpack3(in, out);
+    break;
+  case 4:
+    internal::__fastunpack4(in, out);
+    break;
+  case 5:
+    internal::__fastunpack5(in, out);
+    break;
+  case 6:
+    internal::__fastunpack6(in, out);
+    break;
+  case 7:
+    internal::__fastunpack7(in, out);
+    break;
+  case 8:
+    internal::__fastunpack8(in, out);
+    break;
+  case 9:
+    internal::__fastunpack9(in, out);
+    break;
+  case 10:
+    internal::__fastunpack10(in, out);
+    break;
+  case 11:
+    internal::__fastunpack11(in, out);
+    break;
+  case 12:
+    internal::__fastunpack12(in, out);
+    break;
+  case 13:
+    internal::__fastunpack13(in, out);
+    break;
+  case 14:
+    internal::__fastunpack14(in, out);
+    break;
+  case 15:
+    internal::__fastunpack15(in, out);
+    break;
+  case 16:
+    internal::__fastunpack16(in, out);
+    break;
+  case 17:
+    internal::__fastunpack17(in, out);
+    break;
+  case 18:
+    internal::__fastunpack18(in, out);
+    break;
+  case 19:
+    internal::__fastunpack19(in, out);
+    break;
+  case 20:
+    internal::__fastunpack20(in, out);
+    break;
+  case 21:
+    internal::__fastunpack21(in, out);
+    break;
+  case 22:
+    internal::__fastunpack22(in, out);
+    break;
+  case 23:
+    internal::__fastunpack23(in, out);
+    break;
+  case 24:
+    internal::__fastunpack24(in, out);
+    break;
+  case 25:
+    internal::__fastunpack25(in, out);
+    break;
+  case 26:
+    internal::__fastunpack26(in, out);
+    break;
+  case 27:
+    internal::__fastunpack27(in, out);
+    break;
+  case 28:
+    internal::__fastunpack28(in, out);
+    break;
+  case 29:
+    internal::__fastunpack29(in, out);
+    break;
+  case 30:
+    internal::__fastunpack30(in, out);
+    break;
+  case 31:
+    internal::__fastunpack31(in, out);
+    break;
+  case 32:
+    internal::__fastunpack32(in, out);
+    break;
+  case 33:
+    internal::__fastunpack33(in, out);
+    break;
+  case 34:
+    internal::__fastunpack34(in, out);
+    break;
+  case 35:
+    internal::__fastunpack35(in, out);
+    break;
+  case 36:
+    internal::__fastunpack36(in, out);
+    break;
+  case 37:
+    internal::__fastunpack37(in, out);
+    break;
+  case 38:
+    internal::__fastunpack38(in, out);
+    break;
+  case 39:
+    internal::__fastunpack39(in, out);
+    break;
+  case 40:
+    internal::__fastunpack40(in, out);
+    break;
+  case 41:
+    internal::__fastunpack41(in, out);
+    break;
+  case 42:
+    internal::__fastunpack42(in, out);
+    break;
+  case 43:
+    internal::__fastunpack43(in, out);
+    break;
+  case 44:
+    internal::__fastunpack44(in, out);
+    break;
+  case 45:
+    internal::__fastunpack45(in, out);
+    break;
+  case 46:
+    internal::__fastunpack46(in, out);
+    break;
+  case 47:
+    internal::__fastunpack47(in, out);
+    break;
+  case 48:
+    internal::__fastunpack48(in, out);
+    break;
+  case 49:
+    internal::__fastunpack49(in, out);
+    break;
+  case 50:
+    internal::__fastunpack50(in, out);
+    break;
+  case 51:
+    internal::__fastunpack51(in, out);
+    break;
+  case 52:
+    internal::__fastunpack52(in, out);
+    break;
+  case 53:
+    internal::__fastunpack53(in, out);
+    break;
+  case 54:
+    internal::__fastunpack54(in, out);
+    break;
+  case 55:
+    internal::__fastunpack55(in, out);
+    break;
+  case 56:
+    internal::__fastunpack56(in, out);
+    break;
+  case 57:
+    internal::__fastunpack57(in, out);
+    break;
+  case 58:
+    internal::__fastunpack58(in, out);
+    break;
+  case 59:
+    internal::__fastunpack59(in, out);
+    break;
+  case 60:
+    internal::__fastunpack60(in, out);
+    break;
+  case 61:
+    internal::__fastunpack61(in, out);
+    break;
+  case 62:
+    internal::__fastunpack62(in, out);
+    break;
+  case 63:
+    internal::__fastunpack63(in, out);
+    break;
+  case 64:
+    internal::__fastunpack64(in, out);
+    break;
+  default:
+	throw std::logic_error("Invalid bit width for bitpacking");
+  }
+}
+
+inline void fastpack(const uint8_t *__restrict in, uint8_t *__restrict out, const uint32_t bit) {
+
+	for (uint8_t i = 0; i < 4; i++) {
+		internal::fastpack_quarter(in+(i*8), out + (i*bit), bit);
+	}
+}
+
+inline void fastpack(const uint16_t *__restrict in, uint16_t *__restrict out, const uint32_t bit) {
+	internal::fastpack_half(in, out, bit);
+	internal::fastpack_half(in+16, out + bit, bit);
+}
 
+inline void fastpack(const uint32_t *__restrict in,
+                     uint32_t *__restrict out, const uint32_t bit) {
+  // Could have used function pointers instead of switch.
+  // Switch calls do offer the compiler more opportunities for optimization in
+  // theory. In this case, it makes no difference with a good compiler.
+  switch (bit) {
+  case 0:
+    internal::__fastpack0(in, out);
+    break;
+  case 1:
+    internal::__fastpack1(in, out);
+    break;
+  case 2:
+    internal::__fastpack2(in, out);
+    break;
+  case 3:
+    internal::__fastpack3(in, out);
+    break;
+  case 4:
+    internal::__fastpack4(in, out);
+    break;
+  case 5:
+    internal::__fastpack5(in, out);
+    break;
+  case 6:
+    internal::__fastpack6(in, out);
+    break;
+  case 7:
+    internal::__fastpack7(in, out);
+    break;
+  case 8:
+    internal::__fastpack8(in, out);
+    break;
+  case 9:
+    internal::__fastpack9(in, out);
+    break;
+  case 10:
+    internal::__fastpack10(in, out);
+    break;
+  case 11:
+    internal::__fastpack11(in, out);
+    break;
+  case 12:
+    internal::__fastpack12(in, out);
+    break;
+  case 13:
+    internal::__fastpack13(in, out);
+    break;
+  case 14:
+    internal::__fastpack14(in, out);
+    break;
+  case 15:
+    internal::__fastpack15(in, out);
+    break;
+  case 16:
+    internal::__fastpack16(in, out);
+    break;
+  case 17:
+    internal::__fastpack17(in, out);
+    break;
+  case 18:
+    internal::__fastpack18(in, out);
+    break;
+  case 19:
+    internal::__fastpack19(in, out);
+    break;
+  case 20:
+    internal::__fastpack20(in, out);
+    break;
+  case 21:
+    internal::__fastpack21(in, out);
+    break;
+  case 22:
+    internal::__fastpack22(in, out);
+    break;
+  case 23:
+    internal::__fastpack23(in, out);
+    break;
+  case 24:
+    internal::__fastpack24(in, out);
+    break;
+  case 25:
+    internal::__fastpack25(in, out);
+    break;
+  case 26:
+    internal::__fastpack26(in, out);
+    break;
+  case 27:
+    internal::__fastpack27(in, out);
+    break;
+  case 28:
+    internal::__fastpack28(in, out);
+    break;
+  case 29:
+    internal::__fastpack29(in, out);
+    break;
+  case 30:
+    internal::__fastpack30(in, out);
+    break;
+  case 31:
+    internal::__fastpack31(in, out);
+    break;
+  case 32:
+    internal::__fastpack32(in, out);
+    break;
+  default:
+	throw std::logic_error("Invalid bit width for bitpacking");
+  }
+}
+
+inline void fastpack(const uint64_t *__restrict in,
+                     uint32_t *__restrict out, const uint32_t bit) {
+  switch (bit) {
+  case 0:
+    internal::__fastpack0(in, out);
+    break;
+  case 1:
+    internal::__fastpack1(in, out);
+    break;
+  case 2:
+    internal::__fastpack2(in, out);
+    break;
+  case 3:
+    internal::__fastpack3(in, out);
+    break;
+  case 4:
+    internal::__fastpack4(in, out);
+    break;
+  case 5:
+    internal::__fastpack5(in, out);
+    break;
+  case 6:
+    internal::__fastpack6(in, out);
+    break;
+  case 7:
+    internal::__fastpack7(in, out);
+    break;
+  case 8:
+    internal::__fastpack8(in, out);
+    break;
+  case 9:
+    internal::__fastpack9(in, out);
+    break;
+  case 10:
+    internal::__fastpack10(in, out);
+    break;
+  case 11:
+    internal::__fastpack11(in, out);
+    break;
+  case 12:
+    internal::__fastpack12(in, out);
+    break;
+  case 13:
+    internal::__fastpack13(in, out);
+    break;
+  case 14:
+    internal::__fastpack14(in, out);
+    break;
+  case 15:
+    internal::__fastpack15(in, out);
+    break;
+  case 16:
+    internal::__fastpack16(in, out);
+    break;
+  case 17:
+    internal::__fastpack17(in, out);
+    break;
+  case 18:
+    internal::__fastpack18(in, out);
+    break;
+  case 19:
+    internal::__fastpack19(in, out);
+    break;
+  case 20:
+    internal::__fastpack20(in, out);
+    break;
+  case 21:
+    internal::__fastpack21(in, out);
+    break;
+  case 22:
+    internal::__fastpack22(in, out);
+    break;
+  case 23:
+    internal::__fastpack23(in, out);
+    break;
+  case 24:
+    internal::__fastpack24(in, out);
+    break;
+  case 25:
+    internal::__fastpack25(in, out);
+    break;
+  case 26:
+    internal::__fastpack26(in, out);
+    break;
+  case 27:
+    internal::__fastpack27(in, out);
+    break;
+  case 28:
+    internal::__fastpack28(in, out);
+    break;
+  case 29:
+    internal::__fastpack29(in, out);
+    break;
+  case 30:
+    internal::__fastpack30(in, out);
+    break;
+  case 31:
+    internal::__fastpack31(in, out);
+    break;
+  case 32:
+    internal::__fastpack32(in, out);
+    break;
+  case 33:
+    internal::__fastpack33(in, out);
+    break;
+  case 34:
+    internal::__fastpack34(in, out);
+    break;
+  case 35:
+    internal::__fastpack35(in, out);
+    break;
+  case 36:
+    internal::__fastpack36(in, out);
+    break;
+  case 37:
+    internal::__fastpack37(in, out);
+    break;
+  case 38:
+    internal::__fastpack38(in, out);
+    break;
+  case 39:
+    internal::__fastpack39(in, out);
+    break;
+  case 40:
+    internal::__fastpack40(in, out);
+    break;
+  case 41:
+    internal::__fastpack41(in, out);
+    break;
+  case 42:
+    internal::__fastpack42(in, out);
+    break;
+  case 43:
+    internal::__fastpack43(in, out);
+    break;
+  case 44:
+    internal::__fastpack44(in, out);
+    break;
+  case 45:
+    internal::__fastpack45(in, out);
+    break;
+  case 46:
+    internal::__fastpack46(in, out);
+    break;
+  case 47:
+    internal::__fastpack47(in, out);
+    break;
+  case 48:
+    internal::__fastpack48(in, out);
+    break;
+  case 49:
+    internal::__fastpack49(in, out);
+    break;
+  case 50:
+    internal::__fastpack50(in, out);
+    break;
+  case 51:
+    internal::__fastpack51(in, out);
+    break;
+  case 52:
+    internal::__fastpack52(in, out);
+    break;
+  case 53:
+    internal::__fastpack53(in, out);
+    break;
+  case 54:
+    internal::__fastpack54(in, out);
+    break;
+  case 55:
+    internal::__fastpack55(in, out);
+    break;
+  case 56:
+    internal::__fastpack56(in, out);
+    break;
+  case 57:
+    internal::__fastpack57(in, out);
+    break;
+  case 58:
+    internal::__fastpack58(in, out);
+    break;
+  case 59:
+    internal::__fastpack59(in, out);
+    break;
+  case 60:
+    internal::__fastpack60(in, out);
+    break;
+  case 61:
+    internal::__fastpack61(in, out);
+    break;
+  case 62:
+    internal::__fastpack62(in, out);
+    break;
+  case 63:
+    internal::__fastpack63(in, out);
+    break;
+  case 64:
+    internal::__fastpack64(in, out);
+    break;
+  default:
+	throw std::logic_error("Invalid bit width for bitpacking");
+  }
+}
+} // namespace fastpfor_lib
+
+
+// LICENSE_CHANGE_END
 
 
 
@@ -159020,7 +160612,7 @@ public:
 	                      idx_t result_idx);
 
 	virtual void Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-	                    idx_t offset, idx_t update_count);
+	                    idx_t update_count);
 	virtual void UpdateColumn(Transaction &transaction, const vector<column_t> &column_path, Vector &update_vector,
 	                          row_t *row_ids, idx_t update_count, idx_t depth);
 	virtual unique_ptr<BaseStatistics> GetUpdateStatistics();
@@ -159107,6 +160699,691 @@ private:
 } // namespace duckdb
 
 
+
+#include <functional>
+
+namespace duckdb {
+
+using bitpacking_width_t = uint8_t;
+
+// Note that optimizations in scanning only work if this value is equal to STANDARD_VECTOR_SIZE, however we keep them
+// separated to prevent the code from break on lower vector sizes
+static constexpr const idx_t BITPACKING_WIDTH_GROUP_SIZE = 1024;
+
+class BitpackingPrimitives {
+public:
+	static constexpr const idx_t BITPACKING_ALGORITHM_GROUP_SIZE = 32;
+	static constexpr const idx_t BITPACKING_HEADER_SIZE = sizeof(uint64_t);
+	static constexpr const bool BYTE_ALIGNED = false;
+
+	// Packs a block of BITPACKING_ALGORITHM_GROUP_SIZE values
+	template <class T>
+	inline static void PackBlock(data_ptr_t dst, T *src, bitpacking_width_t width) {
+		return PackGroup<T>(dst, src, width);
+	}
+
+	// Unpacks a block of BITPACKING_ALGORITHM_GROUP_SIZE values
+	template <class T>
+	inline static void UnPackBlock(data_ptr_t dst, data_ptr_t src, bitpacking_width_t width,
+	                               bool skip_sign_extension = false) {
+		return UnPackGroup<T>(dst, src, width, skip_sign_extension);
+	}
+
+	// Calculates the minimum required number of bits per value that can store all values
+	template <class T>
+	inline static bitpacking_width_t MinimumBitWidth(T *values, idx_t count) {
+		return FindMinimumBitWidth<T, BYTE_ALIGNED>(values, count);
+	}
+
+private:
+	template <class T>
+	static bitpacking_width_t MinimumBitWidth(T min_value, T max_value) {
+		bitpacking_width_t required_bits;
+
+		if (std::is_signed<T>::value) {
+			if (min_value == NumericLimits<T>::Minimum()) {
+				// handle special case of the minimal value, as it cannot be negated like all other values.
+				return sizeof(T) * 8;
+			} else {
+				max_value = MaxValue((T)-min_value, max_value);
+			}
+		}
+
+		if (max_value == 0) {
+			return 0;
+		}
+
+		if (std::is_signed<T>::value) {
+			required_bits = 1;
+		} else {
+			required_bits = 0;
+		}
+
+		while (max_value) {
+			required_bits++;
+			max_value >>= 1;
+		}
+
+		return GetEffectiveWidth<T>(required_bits);
+	}
+
+	template <class T, bool round_to_next_byte = false>
+	static bitpacking_width_t FindMinimumBitWidth(T *values, idx_t count) {
+		T min_value = values[0];
+		T max_value = values[0];
+
+		for (idx_t i = 1; i < count; i++) {
+			if (values[i] > max_value) {
+				max_value = values[i];
+			}
+
+			if (std::is_signed<T>::value) {
+				if (values[i] < min_value) {
+					min_value = values[i];
+				}
+			}
+		}
+
+		bitpacking_width_t calc_width = MinimumBitWidth<T>(std::is_signed<T>::value ? min_value : 0, max_value);
+
+		// Assert results are correct
+#ifdef DEBUG
+		if (calc_width < sizeof(T) * 8 && calc_width != 0) {
+			if (std::is_signed<T>::value) {
+				D_ASSERT((int64_t)max_value <= (int64_t)(1L << (calc_width - 1)) - 1);
+				D_ASSERT((int64_t)min_value >= (int64_t)(-1 * ((1L << (calc_width - 1)) - 1) - 1));
+			} else {
+				D_ASSERT((uint64_t)max_value <= (uint64_t)(1L << (calc_width)) - 1);
+			}
+		}
+#endif
+		if (round_to_next_byte) {
+			return (calc_width / 8 + (calc_width % 8 != 0)) * 8;
+		} else {
+			return calc_width;
+		}
+	}
+
+	template <class T>
+	static void UnPackGroup(data_ptr_t dst, data_ptr_t src, bitpacking_width_t width,
+	                        bool skip_sign_extension = false) {
+		if (std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) {
+			duckdb_fastpforlib::fastunpack((const uint8_t *)src, (uint8_t *)dst, (uint32_t)width);
+		} else if (std::is_same<T, uint16_t>::value || std::is_same<T, int16_t>::value) {
+			duckdb_fastpforlib::fastunpack((const uint16_t *)src, (uint16_t *)dst, (uint32_t)width);
+		} else if (std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value) {
+			duckdb_fastpforlib::fastunpack((const uint32_t *)src, (uint32_t *)dst, (uint32_t)width);
+		} else if (std::is_same<T, uint64_t>::value || std::is_same<T, int64_t>::value) {
+			duckdb_fastpforlib::fastunpack((const uint32_t *)src, (uint64_t *)dst, (uint32_t)width);
+		} else {
+			throw InternalException("Unsupported type found in bitpacking.");
+		}
+
+		if (NumericLimits<T>::IsSigned() && !skip_sign_extension && width > 0 && width < sizeof(T) * 8) {
+			SignExtend<T>(dst, width);
+		}
+	}
+
+	// Prevent compression at widths that are ineffective
+	template <class T>
+	static bitpacking_width_t GetEffectiveWidth(bitpacking_width_t width) {
+		if (width > 56) {
+			return 64;
+		}
+
+		if (width > 28 && (std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value)) {
+			return 32;
+		}
+
+		else if (width > 14 && (std::is_same<T, uint16_t>::value || std::is_same<T, int16_t>::value)) {
+			return 16;
+		}
+
+		return width;
+	}
+
+	// Sign bit extension
+	template <class T, class T_U = typename std::make_unsigned<T>::type>
+	static void SignExtend(data_ptr_t dst, bitpacking_width_t width) {
+		T const mask = ((T_U)1) << (width - 1);
+		for (idx_t i = 0; i < BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE; ++i) {
+			T value = Load<T>(dst + i * sizeof(T));
+			value = value & ((((T_U)1) << width) - ((T_U)1));
+			T result = (value ^ mask) - mask;
+			Store(result, dst + i * sizeof(T));
+		}
+	}
+
+	template <class T>
+	static void PackGroup(data_ptr_t dst, T *values, bitpacking_width_t width) {
+		if (std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) {
+			duckdb_fastpforlib::fastpack((const uint8_t *)values, (uint8_t *)dst, (uint32_t)width);
+		} else if (std::is_same<T, uint16_t>::value || std::is_same<T, int16_t>::value) {
+			duckdb_fastpforlib::fastpack((const uint16_t *)values, (uint16_t *)dst, (uint32_t)width);
+		} else if (std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value) {
+			duckdb_fastpforlib::fastpack((const uint32_t *)values, (uint32_t *)dst, (uint32_t)width);
+		} else if (std::is_same<T, uint64_t>::value || std::is_same<T, int64_t>::value) {
+			duckdb_fastpforlib::fastpack((const uint64_t *)values, (uint32_t *)dst, (uint32_t)width);
+		} else {
+			throw InternalException("Unsupported type found in bitpacking.");
+		}
+	}
+};
+
+struct EmptyBitpackingWriter {
+	template <class T>
+	static void Operation(T *values, bool *validity, bitpacking_width_t width, idx_t count, void *data_ptr) {
+	}
+};
+
+template <class T>
+struct BitpackingState {
+public:
+	BitpackingState() : compression_buffer_idx(0), total_size(0), data_ptr(nullptr) {
+	}
+
+	T compression_buffer[BITPACKING_WIDTH_GROUP_SIZE];
+	bool compression_buffer_validity[BITPACKING_WIDTH_GROUP_SIZE];
+	idx_t compression_buffer_idx;
+	idx_t total_size;
+	void *data_ptr;
+
+public:
+	template <class OP>
+	void Flush() {
+		bitpacking_width_t width = BitpackingPrimitives::MinimumBitWidth<T>(compression_buffer, compression_buffer_idx);
+		OP::Operation(compression_buffer, compression_buffer_validity, width, compression_buffer_idx, data_ptr);
+		total_size += (BITPACKING_WIDTH_GROUP_SIZE * width) / 8 + sizeof(bitpacking_width_t);
+		compression_buffer_idx = 0;
+	}
+
+	template <class OP = EmptyBitpackingWriter>
+	void Update(T *data, ValidityMask &validity, idx_t idx) {
+
+		if (validity.RowIsValid(idx)) {
+			compression_buffer_validity[compression_buffer_idx] = true;
+			compression_buffer[compression_buffer_idx++] = data[idx];
+		} else {
+			// We write zero for easy bitwidth analysis of the compression buffer later
+			compression_buffer_validity[compression_buffer_idx] = false;
+			compression_buffer[compression_buffer_idx++] = 0;
+		}
+
+		if (compression_buffer_idx == BITPACKING_WIDTH_GROUP_SIZE) {
+			// Calculate bitpacking width;
+			Flush<OP>();
+		}
+	}
+};
+
+//===--------------------------------------------------------------------===//
+// Analyze
+//===--------------------------------------------------------------------===//
+template <class T>
+struct BitpackingAnalyzeState : public AnalyzeState {
+	BitpackingState<T> state;
+};
+
+template <class T>
+unique_ptr<AnalyzeState> BitpackingInitAnalyze(ColumnData &col_data, PhysicalType type) {
+	return make_unique<BitpackingAnalyzeState<T>>();
+}
+
+template <class T>
+bool BitpackingAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
+	auto &analyze_state = (BitpackingAnalyzeState<T> &)state;
+	VectorData vdata;
+	input.Orrify(count, vdata);
+
+	auto data = (T *)vdata.data;
+	for (idx_t i = 0; i < count; i++) {
+		auto idx = vdata.sel->get_index(i);
+		analyze_state.state.template Update<EmptyBitpackingWriter>(data, vdata.validity, idx);
+	}
+
+	return true;
+}
+
+template <class T>
+idx_t BitpackingFinalAnalyze(AnalyzeState &state) {
+	auto &bitpacking_state = (BitpackingAnalyzeState<T> &)state;
+	bitpacking_state.state.template Flush<EmptyBitpackingWriter>();
+	return bitpacking_state.state.total_size;
+}
+
+//===--------------------------------------------------------------------===//
+// Compress
+//===--------------------------------------------------------------------===//
+template <class T>
+struct BitpackingCompressState : public CompressionState {
+public:
+	explicit BitpackingCompressState(ColumnDataCheckpointer &checkpointer) : checkpointer(checkpointer) {
+		auto &db = checkpointer.GetDatabase();
+		auto &type = checkpointer.GetType();
+		auto &config = DBConfig::GetConfig(db);
+		function = config.GetCompressionFunction(CompressionType::COMPRESSION_BITPACKING, type.InternalType());
+		CreateEmptySegment(checkpointer.GetRowGroup().start);
+
+		state.data_ptr = (void *)this;
+	}
+
+	ColumnDataCheckpointer &checkpointer;
+	CompressionFunction *function;
+	unique_ptr<ColumnSegment> current_segment;
+	unique_ptr<BufferHandle> handle;
+
+	// Ptr to next free spot in segment;
+	data_ptr_t data_ptr;
+	// Ptr to next free spot for storing bitwidths (growing downwards).
+	data_ptr_t width_ptr;
+
+	BitpackingState<T> state;
+
+public:
+	struct BitpackingWriter {
+		template <class VALUE_TYPE>
+		static void Operation(VALUE_TYPE *values, bool *validity, bitpacking_width_t width, idx_t count,
+		                      void *data_ptr) {
+			auto state = (BitpackingCompressState<T> *)data_ptr;
+
+			if (state->RemainingSize() < (width * BITPACKING_WIDTH_GROUP_SIZE) / 8 + sizeof(bitpacking_width_t)) {
+				// Segment is full
+				auto row_start = state->current_segment->start + state->current_segment->count;
+				state->FlushSegment();
+				state->CreateEmptySegment(row_start);
+			}
+
+			for (idx_t i = 0; i < count; i++) {
+				if (validity[i]) {
+					NumericStatistics::Update<T>(state->current_segment->stats, values[i]);
+				}
+			}
+
+			state->WriteValues(values, width, count);
+		}
+	};
+
+	// Space remaining between the width_ptr growing down and data ptr growing up
+	idx_t RemainingSize() {
+		return width_ptr - data_ptr;
+	}
+
+	void CreateEmptySegment(idx_t row_start) {
+		auto &db = checkpointer.GetDatabase();
+		auto &type = checkpointer.GetType();
+		auto compressed_segment = ColumnSegment::CreateTransientSegment(db, type, row_start);
+		compressed_segment->function = function;
+		current_segment = move(compressed_segment);
+		auto &buffer_manager = BufferManager::GetBufferManager(db);
+		handle = buffer_manager.Pin(current_segment->block);
+
+		data_ptr = handle->Ptr() + current_segment->GetBlockOffset() + BitpackingPrimitives::BITPACKING_HEADER_SIZE;
+		width_ptr =
+		    handle->Ptr() + current_segment->GetBlockOffset() + Storage::BLOCK_SIZE - sizeof(bitpacking_width_t);
+	}
+
+	void Append(VectorData &vdata, idx_t count) {
+		// TODO Optimization: avoid use of compression buffer if we can compress straight to result vector
+		auto data = (T *)vdata.data;
+
+		for (idx_t i = 0; i < count; i++) {
+			auto idx = vdata.sel->get_index(i);
+			state.template Update<BitpackingCompressState<T>::BitpackingWriter>(data, vdata.validity, idx);
+		}
+	}
+
+	void WriteValues(T *values, bitpacking_width_t width, idx_t count) {
+		// TODO we can optimize this by stopping early if count < BITPACKING_WIDTH_GROUP_SIZE
+		idx_t compress_loops = BITPACKING_WIDTH_GROUP_SIZE / BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
+		for (idx_t i = 0; i < compress_loops; i++) {
+			BitpackingPrimitives::PackBlock<T>(
+			    data_ptr, &values[i * BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE], width);
+			data_ptr += (BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE * width) / 8;
+		}
+
+		Store<bitpacking_width_t>(width, width_ptr);
+		width_ptr -= sizeof(bitpacking_width_t);
+
+		current_segment->count += count;
+	}
+
+	void FlushSegment() {
+		auto &state = checkpointer.GetCheckpointState();
+
+		// Compact the segment by moving the widths next to the data.
+		idx_t minimal_widths_offset = AlignValue(data_ptr - handle->node->buffer);
+		idx_t widths_size = handle->node->buffer + Storage::BLOCK_SIZE - width_ptr - 1;
+		idx_t total_segment_size = minimal_widths_offset + widths_size;
+		memmove(handle->node->buffer + minimal_widths_offset, width_ptr + 1, widths_size);
+
+		// Store the offset of the first width (which is at the highest address).
+		Store<idx_t>(minimal_widths_offset + widths_size - 1, handle->node->buffer);
+		handle.reset();
+
+		state.FlushSegment(move(current_segment), total_segment_size);
+	}
+
+	void Finalize() {
+		state.template Flush<BitpackingCompressState<T>::BitpackingWriter>();
+		FlushSegment();
+		current_segment.reset();
+	}
+};
+
+template <class T>
+unique_ptr<CompressionState> BitpackingInitCompression(ColumnDataCheckpointer &checkpointer,
+                                                       unique_ptr<AnalyzeState> state) {
+	return make_unique<BitpackingCompressState<T>>(checkpointer);
+}
+
+template <class T>
+void BitpackingCompress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
+	auto &state = (BitpackingCompressState<T> &)state_p;
+	VectorData vdata;
+	scan_vector.Orrify(count, vdata);
+	state.Append(vdata, count);
+}
+
+template <class T>
+void BitpackingFinalizeCompress(CompressionState &state_p) {
+	auto &state = (BitpackingCompressState<T> &)state_p;
+	state.Finalize();
+}
+
+//===--------------------------------------------------------------------===//
+// Scan
+//===--------------------------------------------------------------------===//
+template <class T>
+struct BitpackingScanState : public SegmentScanState {
+public:
+	explicit BitpackingScanState(ColumnSegment &segment) {
+		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
+		handle = buffer_manager.Pin(segment.block);
+
+		current_width_group_ptr =
+		    handle->node->buffer + segment.GetBlockOffset() + BitpackingPrimitives::BITPACKING_HEADER_SIZE;
+
+		// load offset to bitpacking widths pointer
+		auto bitpacking_widths_offset = Load<idx_t>(handle->node->buffer + segment.GetBlockOffset());
+		bitpacking_width_ptr = handle->node->buffer + segment.GetBlockOffset() + bitpacking_widths_offset;
+
+		// load the bitwidth of the first vector
+		LoadCurrentBitWidth();
+	}
+
+	unique_ptr<BufferHandle> handle;
+
+	void (*decompress_function)(data_ptr_t, data_ptr_t, bitpacking_width_t, bool skip_sign_extension);
+	T decompression_buffer[BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE];
+
+	idx_t position_in_group = 0;
+	data_ptr_t current_width_group_ptr;
+	data_ptr_t bitpacking_width_ptr;
+	bitpacking_width_t current_width;
+
+public:
+	void LoadCurrentBitWidth() {
+		D_ASSERT(bitpacking_width_ptr > handle->node->buffer &&
+		         bitpacking_width_ptr < handle->node->buffer + Storage::BLOCK_SIZE);
+		current_width = Load<bitpacking_width_t>(bitpacking_width_ptr);
+		LoadDecompressFunction();
+	}
+
+	void Skip(ColumnSegment &segment, idx_t skip_count) {
+		while (skip_count > 0) {
+			if (position_in_group + skip_count < BITPACKING_WIDTH_GROUP_SIZE) {
+				// We're not leaving this bitpacking group, we can perform all skips.
+				position_in_group += skip_count;
+				break;
+			} else {
+				// The skip crosses the current bitpacking group, we skip the remainder of this group.
+				auto skipping = BITPACKING_WIDTH_GROUP_SIZE - position_in_group;
+				position_in_group = 0;
+				current_width_group_ptr += (current_width * BITPACKING_WIDTH_GROUP_SIZE) / 8;
+
+				// Update width pointer and load new width
+				bitpacking_width_ptr -= sizeof(bitpacking_width_t);
+				LoadCurrentBitWidth();
+
+				skip_count -= skipping;
+			}
+		}
+	}
+
+	void LoadDecompressFunction() {
+		decompress_function = &BitpackingPrimitives::UnPackBlock<T>;
+	}
+};
+
+template <class T>
+unique_ptr<SegmentScanState> BitpackingInitScan(ColumnSegment &segment) {
+	auto result = make_unique<BitpackingScanState<T>>(segment);
+	return move(result);
+}
+
+//===--------------------------------------------------------------------===//
+// Scan base data
+//===--------------------------------------------------------------------===//
+template <class T>
+void BitpackingScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
+                           idx_t result_offset) {
+	auto &scan_state = (BitpackingScanState<T> &)*state.scan_state;
+
+	T *result_data = FlatVector::GetData<T>(result);
+	result.SetVectorType(VectorType::FLAT_VECTOR);
+
+	// Fast path for when no compression was used, we can do a single memcopy
+	if (STANDARD_VECTOR_SIZE == BITPACKING_WIDTH_GROUP_SIZE) {
+		if (scan_state.current_width == sizeof(T) * 8 && scan_count <= BITPACKING_WIDTH_GROUP_SIZE &&
+		    scan_state.position_in_group == 0) {
+
+			memcpy(result_data + result_offset, scan_state.current_width_group_ptr, scan_count * sizeof(T));
+			scan_state.current_width_group_ptr += scan_count * sizeof(T);
+			scan_state.bitpacking_width_ptr -= sizeof(bitpacking_width_t);
+			scan_state.LoadCurrentBitWidth();
+			return;
+		}
+	}
+
+	// Determine if we can skip sign extension during compression
+	auto &nstats = (NumericStatistics &)*segment.stats.statistics;
+	bool skip_sign_extend = std::is_signed<T>::value && nstats.min >= 0;
+
+	idx_t scanned = 0;
+
+	while (scanned < scan_count) {
+		// Exhausted this width group, move pointers to next group and load bitwidth for next group.
+		if (scan_state.position_in_group >= BITPACKING_WIDTH_GROUP_SIZE) {
+			scan_state.position_in_group = 0;
+			scan_state.bitpacking_width_ptr -= sizeof(bitpacking_width_t);
+			scan_state.current_width_group_ptr += (scan_state.current_width * BITPACKING_WIDTH_GROUP_SIZE) / 8;
+			scan_state.LoadCurrentBitWidth();
+		}
+
+		idx_t offset_in_compression_group =
+		    scan_state.position_in_group % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
+
+		idx_t to_scan = MinValue<idx_t>(scan_count - scanned, BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE -
+		                                                          offset_in_compression_group);
+
+		// Calculate start of compression algorithm group
+		data_ptr_t current_position_ptr =
+		    scan_state.current_width_group_ptr + scan_state.position_in_group * scan_state.current_width / 8;
+		data_ptr_t decompression_group_start_pointer =
+		    current_position_ptr - offset_in_compression_group * scan_state.current_width / 8;
+
+		T *current_result_ptr = result_data + result_offset + scanned;
+
+		if (to_scan == BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE && offset_in_compression_group == 0) {
+			// Decompress directly into result vector
+			scan_state.decompress_function((data_ptr_t)current_result_ptr, decompression_group_start_pointer,
+			                               scan_state.current_width, skip_sign_extend);
+		} else {
+			// Decompress compression algorithm to buffer
+			scan_state.decompress_function((data_ptr_t)scan_state.decompression_buffer,
+			                               decompression_group_start_pointer, scan_state.current_width,
+			                               skip_sign_extend);
+
+			memcpy(current_result_ptr, scan_state.decompression_buffer + offset_in_compression_group,
+			       to_scan * sizeof(T));
+		}
+
+		scanned += to_scan;
+		scan_state.position_in_group += to_scan;
+	}
+}
+
+template <class T>
+void BitpackingScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
+	BitpackingScanPartial<T>(segment, state, scan_count, result, 0);
+}
+
+//===--------------------------------------------------------------------===//
+// Fetch
+//===--------------------------------------------------------------------===//
+template <class T>
+void BitpackingFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result,
+                        idx_t result_idx) {
+	BitpackingScanState<T> scan_state(segment);
+	scan_state.Skip(segment, row_id);
+	auto result_data = FlatVector::GetData<T>(result);
+	T *current_result_ptr = result_data + result_idx;
+
+	// TODO clean up, is reused in partialscan
+	idx_t offset_in_compression_group =
+	    scan_state.position_in_group % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
+
+	data_ptr_t decompression_group_start_pointer =
+	    scan_state.current_width_group_ptr +
+	    (scan_state.position_in_group - offset_in_compression_group) * scan_state.current_width / 8;
+
+	auto &nstats = (NumericStatistics &)*segment.stats.statistics;
+	bool skip_sign_extend = std::is_signed<T>::value && nstats.min >= 0;
+
+	scan_state.decompress_function((data_ptr_t)scan_state.decompression_buffer, decompression_group_start_pointer,
+	                               scan_state.current_width, skip_sign_extend);
+
+	*current_result_ptr = *(T *)(scan_state.decompression_buffer + offset_in_compression_group);
+}
+template <class T>
+void BitpackingSkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
+	auto &scan_state = (BitpackingScanState<T> &)*state.scan_state;
+	scan_state.Skip(segment, skip_count);
+}
+
+//===--------------------------------------------------------------------===//
+// Get Function
+//===--------------------------------------------------------------------===//
+template <class T>
+CompressionFunction GetBitpackingFunction(PhysicalType data_type) {
+	return CompressionFunction(CompressionType::COMPRESSION_BITPACKING, data_type, BitpackingInitAnalyze<T>,
+	                           BitpackingAnalyze<T>, BitpackingFinalAnalyze<T>, BitpackingInitCompression<T>,
+	                           BitpackingCompress<T>, BitpackingFinalizeCompress<T>, BitpackingInitScan<T>,
+	                           BitpackingScan<T>, BitpackingScanPartial<T>, BitpackingFetchRow<T>, BitpackingSkip<T>);
+}
+
+CompressionFunction BitpackingFun::GetFunction(PhysicalType type) {
+	switch (type) {
+	case PhysicalType::INT8:
+		return GetBitpackingFunction<int8_t>(type);
+	case PhysicalType::INT16:
+		return GetBitpackingFunction<int16_t>(type);
+	case PhysicalType::INT32:
+		return GetBitpackingFunction<int32_t>(type);
+	case PhysicalType::INT64:
+		return GetBitpackingFunction<int64_t>(type);
+	case PhysicalType::BOOL:
+	case PhysicalType::UINT8:
+		return GetBitpackingFunction<uint8_t>(type);
+	case PhysicalType::UINT16:
+		return GetBitpackingFunction<uint16_t>(type);
+	case PhysicalType::UINT32:
+		return GetBitpackingFunction<uint32_t>(type);
+	case PhysicalType::UINT64:
+		return GetBitpackingFunction<uint64_t>(type);
+	default:
+		throw InternalException("Unsupported type for Bitpacking");
+	}
+}
+
+bool BitpackingFun::TypeIsSupported(PhysicalType type) {
+	switch (type) {
+	case PhysicalType::BOOL:
+	case PhysicalType::INT8:
+	case PhysicalType::INT16:
+	case PhysicalType::INT32:
+	case PhysicalType::INT64:
+	case PhysicalType::UINT8:
+	case PhysicalType::UINT16:
+	case PhysicalType::UINT32:
+	case PhysicalType::UINT64:
+		return true;
+	default:
+		return false;
+	}
+}
+
+} // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/segment/uncompressed.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+class DatabaseInstance;
+
+struct UncompressedFunctions {
+	static unique_ptr<CompressionState> InitCompression(ColumnDataCheckpointer &checkpointer,
+	                                                    unique_ptr<AnalyzeState> state);
+	static void Compress(CompressionState &state_p, Vector &data, idx_t count);
+	static void FinalizeCompress(CompressionState &state_p);
+	static void EmptySkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
+	}
+};
+
+struct FixedSizeUncompressed {
+	static CompressionFunction GetFunction(PhysicalType data_type);
+};
+
+struct ValidityUncompressed {
+public:
+	static CompressionFunction GetFunction(PhysicalType data_type);
+
+public:
+	static const validity_t LOWER_MASKS[65];
+	static const validity_t UPPER_MASKS[65];
+};
+
+struct StringUncompressed {
+public:
+	static CompressionFunction GetFunction(PhysicalType data_type);
+
+public:
+	//! The max string size that is allowed within a block. Strings bigger than this will be labeled as a BIG STRING and
+	//! offloaded to the overflow blocks.
+	static constexpr uint16_t STRING_BLOCK_LIMIT = 4096;
+};
+
+} // namespace duckdb
+
+
+
+
+
+
+
+
+
+
+
+
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
@@ -161034,7 +163311,7 @@ public:
 	idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override;
 	void FetchRow(Transaction &transaction, ColumnFetchState &state, row_t row_id, Vector &result,
 	              idx_t result_idx) override;
-	void Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids, idx_t offset,
+	void Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
 	            idx_t update_count) override;
 	void UpdateColumn(Transaction &transaction, const vector<column_t> &column_path, Vector &update_vector,
 	                  row_t *row_ids, idx_t update_count, idx_t depth) override;
@@ -164848,7 +167125,7 @@ public:
 	idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override;
 	void FetchRow(Transaction &transaction, ColumnFetchState &state, row_t row_id, Vector &result,
 	              idx_t result_idx) override;
-	void Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids, idx_t offset,
+	void Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
 	            idx_t update_count) override;
 	void UpdateColumn(Transaction &transaction, const vector<column_t> &column_path, Vector &update_vector,
 	                  row_t *row_ids, idx_t update_count, idx_t depth) override;
@@ -165036,7 +167313,7 @@ public:
 	void FetchUpdates(Transaction &transaction, idx_t vector_index, Vector &result);
 	void FetchCommitted(idx_t vector_index, Vector &result);
 	void FetchCommittedRange(idx_t start_row, idx_t count, Vector &result);
-	void Update(Transaction &transaction, idx_t column_index, Vector &update, row_t *ids, idx_t offset, idx_t count,
+	void Update(Transaction &transaction, idx_t column_index, Vector &update, row_t *ids, idx_t count,
 	            Vector &base_data);
 	void FetchRow(Transaction &transaction, idx_t row_id, Vector &result, idx_t result_idx);
 
@@ -165077,7 +167354,7 @@ public:
 	                                     idx_t row_idx, Vector &result, idx_t result_idx);
 	typedef void (*rollback_update_function_t)(UpdateInfo *base_info, UpdateInfo *rollback_info);
 	typedef idx_t (*statistics_update_function_t)(UpdateSegment *segment, SegmentStatistics &stats, Vector &update,
-	                                              idx_t offset, idx_t count, SelectionVector &sel);
+	                                              idx_t count, SelectionVector &sel);
 
 private:
 	initialize_update_function_t initialize_update_function;
@@ -165151,7 +167428,7 @@ public:
 	idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override;
 	void FetchRow(Transaction &transaction, ColumnFetchState &state, row_t row_id, Vector &result,
 	              idx_t result_idx) override;
-	void Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids, idx_t offset,
+	void Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
 	            idx_t update_count) override;
 	void UpdateColumn(Transaction &transaction, const vector<column_t> &column_path, Vector &update_vector,
 	                  row_t *row_ids, idx_t update_count, idx_t depth) override;
@@ -165464,24 +167741,24 @@ void ColumnData::FetchRow(Transaction &transaction, ColumnFetchState &state, row
 }
 
 void ColumnData::Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                        idx_t offset, idx_t update_count) {
+                        idx_t update_count) {
 	lock_guard<mutex> update_guard(update_lock);
 	if (!updates) {
 		updates = make_unique<UpdateSegment>(*this);
 	}
 	Vector base_vector(type);
 	ColumnScanState state;
-	auto fetch_count = Fetch(state, row_ids[offset], base_vector);
+	auto fetch_count = Fetch(state, row_ids[0], base_vector);
 
 	base_vector.Normalify(fetch_count);
-	updates->Update(transaction, column_index, update_vector, row_ids, offset, update_count, base_vector);
+	updates->Update(transaction, column_index, update_vector, row_ids, update_count, base_vector);
 }
 
 void ColumnData::UpdateColumn(Transaction &transaction, const vector<column_t> &column_path, Vector &update_vector,
                               row_t *row_ids, idx_t update_count, idx_t depth) {
 	// this method should only be called at the end of the path in the base column case
 	D_ASSERT(depth >= column_path.size());
-	ColumnData::Update(transaction, column_path[0], update_vector, row_ids, 0, update_count);
+	ColumnData::Update(transaction, column_path[0], update_vector, row_ids, update_count);
 }
 
 unique_ptr<BaseStatistics> ColumnData::GetUpdateStatistics() {
@@ -166552,7 +168829,7 @@ idx_t ListColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &result
 }
 
 void ListColumnData::Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                            idx_t offset, idx_t update_count) {
+                            idx_t update_count) {
 	throw NotImplementedException("List Update is not supported.");
 }
 
@@ -167292,7 +169569,13 @@ void RowGroup::Update(Transaction &transaction, DataChunk &update_chunk, row_t *
 		auto column = column_ids[i];
 		D_ASSERT(column != COLUMN_IDENTIFIER_ROW_ID);
 		D_ASSERT(columns[column]->type.id() == update_chunk.data[i].GetType().id());
-		columns[column]->Update(transaction, column, update_chunk.data[i], ids, offset, count);
+		if (offset > 0) {
+			Vector sliced_vector(update_chunk.data[i], offset);
+			sliced_vector.Normalify(count);
+			columns[column]->Update(transaction, column, sliced_vector, ids + offset, count);
+		} else {
+			columns[column]->Update(transaction, column, update_chunk.data[i], ids, count);
+		}
 		MergeStatistics(column, *columns[column]->GetUpdateStatistics());
 	}
 }
@@ -167715,16 +169998,16 @@ idx_t StandardColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &re
 }
 
 void StandardColumnData::Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                                idx_t offset, idx_t update_count) {
-	ColumnData::Update(transaction, column_index, update_vector, row_ids, offset, update_count);
-	validity.Update(transaction, column_index, update_vector, row_ids, offset, update_count);
+                                idx_t update_count) {
+	ColumnData::Update(transaction, column_index, update_vector, row_ids, update_count);
+	validity.Update(transaction, column_index, update_vector, row_ids, update_count);
 }
 
 void StandardColumnData::UpdateColumn(Transaction &transaction, const vector<column_t> &column_path,
                                       Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth) {
 	if (depth >= column_path.size()) {
 		// update this column
-		ColumnData::Update(transaction, column_path[0], update_vector, row_ids, 0, update_count);
+		ColumnData::Update(transaction, column_path[0], update_vector, row_ids, update_count);
 	} else {
 		// update the child column (i.e. the validity column)
 		validity.UpdateColumn(transaction, column_path, update_vector, row_ids, update_count, depth + 1);
@@ -167975,11 +170258,11 @@ idx_t StructColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &resu
 }
 
 void StructColumnData::Update(Transaction &transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
-                              idx_t offset, idx_t update_count) {
-	validity.Update(transaction, column_index, update_vector, row_ids, offset, update_count);
+                              idx_t update_count) {
+	validity.Update(transaction, column_index, update_vector, row_ids, update_count);
 	auto &child_entries = StructVector::GetEntries(update_vector);
 	for (idx_t i = 0; i < child_entries.size(); i++) {
-		sub_columns[i]->Update(transaction, column_index, *child_entries[i], row_ids, offset, update_count);
+		sub_columns[i]->Update(transaction, column_index, *child_entries[i], row_ids, update_count);
 	}
 }
 
@@ -169061,60 +171344,56 @@ unique_ptr<BaseStatistics> UpdateSegment::GetStatistics() {
 	return stats.statistics->Copy();
 }
 
-idx_t UpdateValidityStatistics(UpdateSegment *segment, SegmentStatistics &stats, Vector &update, idx_t offset,
-                               idx_t count, SelectionVector &sel) {
+idx_t UpdateValidityStatistics(UpdateSegment *segment, SegmentStatistics &stats, Vector &update, idx_t count,
+                               SelectionVector &sel) {
 	auto &mask = FlatVector::Validity(update);
 	auto &validity = (ValidityStatistics &)*stats.statistics;
 	if (!mask.AllValid() && !validity.has_null) {
 		for (idx_t i = 0; i < count; i++) {
-			auto idx = offset + i;
-			if (!mask.RowIsValid(idx)) {
+			if (!mask.RowIsValid(i)) {
 				validity.has_null = true;
 				break;
 			}
 		}
 	}
-	sel.Initialize((sel_t *)(FlatVector::INCREMENTAL_VECTOR + offset));
+	sel.Initialize((sel_t *)(FlatVector::INCREMENTAL_VECTOR));
 	return count;
 }
 
 template <class T>
-idx_t TemplatedUpdateNumericStatistics(UpdateSegment *segment, SegmentStatistics &stats, Vector &update, idx_t offset,
-                                       idx_t count, SelectionVector &sel) {
+idx_t TemplatedUpdateNumericStatistics(UpdateSegment *segment, SegmentStatistics &stats, Vector &update, idx_t count,
+                                       SelectionVector &sel) {
 	auto update_data = FlatVector::GetData<T>(update);
 	auto &mask = FlatVector::Validity(update);
 
 	if (mask.AllValid()) {
 		for (idx_t i = 0; i < count; i++) {
-			auto idx = offset + i;
-			NumericStatistics::Update<T>(stats, update_data[idx]);
+			NumericStatistics::Update<T>(stats, update_data[i]);
 		}
-		sel.Initialize((sel_t *)(FlatVector::INCREMENTAL_VECTOR + offset));
+		sel.Initialize((sel_t *)(FlatVector::INCREMENTAL_VECTOR));
 		return count;
 	} else {
 		idx_t not_null_count = 0;
 		sel.Initialize(STANDARD_VECTOR_SIZE);
 		for (idx_t i = 0; i < count; i++) {
-			auto idx = offset + i;
-			if (mask.RowIsValid(idx)) {
-				sel.set_index(not_null_count++, idx);
-				NumericStatistics::Update<T>(stats, update_data[idx]);
+			if (mask.RowIsValid(i)) {
+				sel.set_index(not_null_count++, i);
+				NumericStatistics::Update<T>(stats, update_data[i]);
 			}
 		}
 		return not_null_count;
 	}
 }
 
-idx_t UpdateStringStatistics(UpdateSegment *segment, SegmentStatistics &stats, Vector &update, idx_t offset,
-                             idx_t count, SelectionVector &sel) {
+idx_t UpdateStringStatistics(UpdateSegment *segment, SegmentStatistics &stats, Vector &update, idx_t count,
+                             SelectionVector &sel) {
 	auto update_data = FlatVector::GetData<string_t>(update);
 	auto &mask = FlatVector::Validity(update);
 	if (mask.AllValid()) {
 		for (idx_t i = 0; i < count; i++) {
-			auto idx = offset + i;
-			((StringStatistics &)*stats.statistics).Update(update_data[idx]);
-			if (!update_data[idx].IsInlined()) {
-				update_data[idx] = segment->GetStringHeap().AddString(update_data[idx]);
+			((StringStatistics &)*stats.statistics).Update(update_data[i]);
+			if (!update_data[i].IsInlined()) {
+				update_data[i] = segment->GetStringHeap().AddString(update_data[i]);
 			}
 		}
 		sel.Initialize(FlatVector::INCREMENTAL_SELECTION_VECTOR);
@@ -169123,12 +171402,11 @@ idx_t UpdateStringStatistics(UpdateSegment *segment, SegmentStatistics &stats, V
 		idx_t not_null_count = 0;
 		sel.Initialize(STANDARD_VECTOR_SIZE);
 		for (idx_t i = 0; i < count; i++) {
-			auto idx = offset + i;
-			if (mask.RowIsValid(idx)) {
-				sel.set_index(not_null_count++, idx);
-				((StringStatistics &)*stats.statistics).Update(update_data[idx]);
-				if (!update_data[idx].IsInlined()) {
-					update_data[idx] = segment->GetStringHeap().AddString(update_data[idx]);
+			if (mask.RowIsValid(i)) {
+				sel.set_index(not_null_count++, i);
+				((StringStatistics &)*stats.statistics).Update(update_data[i]);
+				if (!update_data[i].IsInlined()) {
+					update_data[i] = segment->GetStringHeap().AddString(update_data[i]);
 				}
 			}
 		}
@@ -169220,8 +171498,8 @@ static idx_t SortSelectionVector(SelectionVector &sel, idx_t count, row_t *ids)
 	return pos;
 }
 
-void UpdateSegment::Update(Transaction &transaction, idx_t column_index, Vector &update, row_t *ids, idx_t offset,
-                           idx_t count, Vector &base_data) {
+void UpdateSegment::Update(Transaction &transaction, idx_t column_index, Vector &update, row_t *ids, idx_t count,
+                           Vector &base_data) {
 	// obtain an exclusive lock
 	auto write_lock = lock.GetExclusiveLock();
 
@@ -169231,7 +171509,7 @@ void UpdateSegment::Update(Transaction &transaction, idx_t column_index, Vector
 	SelectionVector sel;
 	{
 		lock_guard<mutex> stats_guard(stats_lock);
-		count = statistics_update_function(this, stats, update, offset, count, sel);
+		count = statistics_update_function(this, stats, update, count, sel);
 	}
 	if (count == 0) {
 		return;
@@ -207029,6 +209307,1299 @@ void sdfree(void *ptr) { free(ptr); }
 // LICENSE_CHANGE_END
 
 
+// LICENSE_CHANGE_BEGIN
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #10
+// See the end of this file for a list
+
+
+
+#include <cstdint>
+#include <type_traits>
+
+namespace duckdb_fastpforlib {
+namespace internal {
+
+// Used for uint8_t, uint16_t and uint32_t
+template <uint8_t DELTA, uint8_t SHR, class TYPE, uint8_t TYPE_SIZE = sizeof(TYPE) * 8>
+typename std::enable_if<(DELTA + SHR) < TYPE_SIZE>::type unpack_single_out(const TYPE *__restrict in,
+                                                                           TYPE *__restrict out) {
+	*out = ((*in) >> SHR) % (1 << DELTA);
+}
+
+// Used for uint8_t, uint16_t and uint32_t
+template <uint8_t DELTA, uint8_t SHR, class TYPE, uint8_t TYPE_SIZE = sizeof(TYPE) * 8>
+typename std::enable_if<(DELTA + SHR) >= TYPE_SIZE>::type unpack_single_out(const TYPE *__restrict &in,
+                                                                            TYPE *__restrict out) {
+	*out = (*in) >> SHR;
+	++in;
+
+	static const TYPE NEXT_SHR = SHR + DELTA - TYPE_SIZE;
+	*out |= ((*in) % (1U << NEXT_SHR)) << (TYPE_SIZE - SHR);
+}
+
+template <uint8_t DELTA, uint8_t SHR>
+typename std::enable_if<(DELTA + SHR) < 32>::type unpack_single_out(const uint32_t *__restrict in,
+                                                                    uint64_t *__restrict out) {
+	*out = ((static_cast<uint64_t>(*in)) >> SHR) % (1ULL << DELTA);
+}
+
+template <uint8_t DELTA, uint8_t SHR>
+typename std::enable_if<(DELTA + SHR) >= 32 && (DELTA + SHR) < 64>::type
+unpack_single_out(const uint32_t *__restrict &in, uint64_t *__restrict out) {
+	*out = static_cast<uint64_t>(*in) >> SHR;
+	++in;
+	if (DELTA + SHR > 32) {
+		static const uint8_t NEXT_SHR = SHR + DELTA - 32;
+		*out |= static_cast<uint64_t>((*in) % (1U << NEXT_SHR)) << (32 - SHR);
+	}
+}
+
+template <uint8_t DELTA, uint8_t SHR>
+typename std::enable_if<(DELTA + SHR) >= 64>::type unpack_single_out(const uint32_t *__restrict &in,
+                                                                     uint64_t *__restrict out) {
+	*out = static_cast<uint64_t>(*in) >> SHR;
+	++in;
+
+	*out |= static_cast<uint64_t>(*in) << (32 - SHR);
+	++in;
+
+	if (DELTA + SHR > 64) {
+		static const uint8_t NEXT_SHR = DELTA + SHR - 64;
+		*out |= static_cast<uint64_t>((*in) % (1U << NEXT_SHR)) << (64 - SHR);
+	}
+}
+
+// Used for uint8_t, uint16_t and uint32_t
+template <class TYPE, uint16_t DELTA, uint16_t SHL, TYPE MASK, uint8_t TYPE_SIZE = sizeof(TYPE) * 8>
+    typename std::enable_if < DELTA + SHL<TYPE_SIZE>::type pack_single_in(const TYPE in, TYPE *__restrict out) {
+	if (SHL == 0) {
+		*out = in & MASK;
+	} else {
+		*out |= (in & MASK) << SHL;
+	}
+}
+
+// Used for uint8_t, uint16_t and uint32_t
+template <class TYPE, uint16_t DELTA, uint16_t SHL, TYPE MASK, uint8_t TYPE_SIZE = sizeof(TYPE) * 8>
+typename std::enable_if<DELTA + SHL >= TYPE_SIZE>::type pack_single_in(const TYPE in, TYPE *__restrict &out) {
+	*out |= in << SHL;
+	++out;
+
+	if (DELTA + SHL > TYPE_SIZE) {
+		*out = (in & MASK) >> (TYPE_SIZE - SHL);
+	}
+}
+
+template <uint16_t DELTA, uint16_t SHL, uint64_t MASK>
+    typename std::enable_if < DELTA + SHL<32>::type pack_single_in64(const uint64_t in, uint32_t *__restrict out) {
+	if (SHL == 0) {
+		*out = static_cast<uint32_t>(in & MASK);
+	} else {
+		*out |= (in & MASK) << SHL;
+	}
+}
+template <uint16_t DELTA, uint16_t SHL, uint64_t MASK>
+        typename std::enable_if < DELTA + SHL >= 32 &&
+    DELTA + SHL<64>::type pack_single_in64(const uint64_t in, uint32_t *__restrict &out) {
+	if (SHL == 0) {
+		*out = static_cast<uint32_t>(in & MASK);
+	} else {
+		*out |= (in & MASK) << SHL;
+	}
+
+	++out;
+
+	if (DELTA + SHL > 32) {
+		*out = static_cast<uint32_t>((in & MASK) >> (32 - SHL));
+	}
+}
+template <uint16_t DELTA, uint16_t SHL, uint64_t MASK>
+typename std::enable_if<DELTA + SHL >= 64>::type pack_single_in64(const uint64_t in, uint32_t *__restrict &out) {
+	*out |= in << SHL;
+	++out;
+
+	*out = static_cast<uint32_t>((in & MASK) >> (32 - SHL));
+	++out;
+
+	if (DELTA + SHL > 64) {
+		*out = (in & MASK) >> (64 - SHL);
+	}
+}
+template <uint16_t DELTA, uint16_t OINDEX = 0>
+struct Unroller8 {
+	static void Unpack(const uint8_t *__restrict &in, uint8_t *__restrict out) {
+		unpack_single_out<DELTA, (DELTA * OINDEX) % 8>(in, out + OINDEX);
+
+		Unroller8<DELTA, OINDEX + 1>::Unpack(in, out);
+	}
+
+	static void Pack(const uint8_t *__restrict in, uint8_t *__restrict out) {
+		pack_single_in<uint8_t, DELTA, (DELTA * OINDEX) % 8, (1U << DELTA) - 1>(in[OINDEX], out);
+
+		Unroller8<DELTA, OINDEX + 1>::Pack(in, out);
+	}
+
+};\
+template <uint16_t DELTA>
+struct Unroller8<DELTA, 7> {
+	enum { SHIFT = (DELTA * 7) % 8 };
+
+	static void Unpack(const uint8_t *__restrict in, uint8_t *__restrict out) {
+		out[7] = (*in) >> SHIFT;
+	}
+
+	static void Pack(const uint8_t *__restrict in, uint8_t *__restrict out) {
+		*out |= (in[7] << SHIFT);
+	}
+};
+
+template <uint16_t DELTA, uint16_t OINDEX = 0>
+struct Unroller16 {
+	static void Unpack(const uint16_t *__restrict &in, uint16_t *__restrict out) {
+		unpack_single_out<DELTA, (DELTA * OINDEX) % 16>(in, out + OINDEX);
+
+		Unroller16<DELTA, OINDEX + 1>::Unpack(in, out);
+	}
+
+	static void Pack(const uint16_t *__restrict in, uint16_t *__restrict out) {
+		pack_single_in<uint16_t, DELTA, (DELTA * OINDEX) % 16, (1U << DELTA) - 1>(in[OINDEX], out);
+
+		Unroller16<DELTA, OINDEX + 1>::Pack(in, out);
+	}
+
+};
+
+template <uint16_t DELTA>
+struct Unroller16<DELTA, 15> {
+	enum { SHIFT = (DELTA * 15) % 16 };
+
+	static void Unpack(const uint16_t *__restrict in, uint16_t *__restrict out) {
+		out[15] = (*in) >> SHIFT;
+	}
+
+	static void Pack(const uint16_t *__restrict in, uint16_t *__restrict out) {
+		*out |= (in[15] << SHIFT);
+	}
+};
+
+template <uint16_t DELTA, uint16_t OINDEX = 0>
+struct Unroller {
+	static void Unpack(const uint32_t *__restrict &in, uint32_t *__restrict out) {
+		unpack_single_out<DELTA, (DELTA * OINDEX) % 32>(in, out + OINDEX);
+
+		Unroller<DELTA, OINDEX + 1>::Unpack(in, out);
+	}
+
+	static void Unpack(const uint32_t *__restrict &in, uint64_t *__restrict out) {
+		unpack_single_out<DELTA, (DELTA * OINDEX) % 32>(in, out + OINDEX);
+
+		Unroller<DELTA, OINDEX + 1>::Unpack(in, out);
+	}
+
+	static void Pack(const uint32_t *__restrict in, uint32_t *__restrict out) {
+		pack_single_in<uint32_t, DELTA, (DELTA * OINDEX) % 32, (1U << DELTA) - 1>(in[OINDEX], out);
+
+		Unroller<DELTA, OINDEX + 1>::Pack(in, out);
+	}
+
+	static void Pack(const uint64_t *__restrict in, uint32_t *__restrict out) {
+		pack_single_in64<DELTA, (DELTA * OINDEX) % 32, (1ULL << DELTA) - 1>(in[OINDEX], out);
+
+		Unroller<DELTA, OINDEX + 1>::Pack(in, out);
+	}
+};
+
+template <uint16_t DELTA>
+struct Unroller<DELTA, 31> {
+	enum { SHIFT = (DELTA * 31) % 32 };
+
+	static void Unpack(const uint32_t *__restrict in, uint32_t *__restrict out) {
+		out[31] = (*in) >> SHIFT;
+	}
+
+	static void Unpack(const uint32_t *__restrict in, uint64_t *__restrict out) {
+		out[31] = (*in) >> SHIFT;
+		if (DELTA > 32) {
+			++in;
+			out[31] |= static_cast<uint64_t>(*in) << (32 - SHIFT);
+		}
+	}
+
+	static void Pack(const uint32_t *__restrict in, uint32_t *__restrict out) {
+		*out |= (in[31] << SHIFT);
+	}
+
+	static void Pack(const uint64_t *__restrict in, uint32_t *__restrict out) {
+		*out |= (in[31] << SHIFT);
+		if (DELTA > 32) {
+			++out;
+			*out = static_cast<uint32_t>(in[31] >> (32 - SHIFT));
+		}
+	}
+};
+
+// Special cases
+void __fastunpack0(const uint8_t *__restrict, uint8_t *__restrict out) {
+	for (uint8_t i = 0; i < 8; ++i)
+		*(out++) = 0;
+}
+
+void __fastunpack0(const uint16_t *__restrict, uint16_t *__restrict out) {
+	for (uint16_t i = 0; i < 16; ++i)
+		*(out++) = 0;
+}
+
+void __fastunpack0(const uint32_t *__restrict, uint32_t *__restrict out) {
+	for (uint32_t i = 0; i < 32; ++i)
+		*(out++) = 0;
+}
+
+void __fastunpack0(const uint32_t *__restrict, uint64_t *__restrict out) {
+	for (uint32_t i = 0; i < 32; ++i)
+		*(out++) = 0;
+}
+
+void __fastpack0(const uint8_t *__restrict, uint8_t *__restrict) {
+}
+void __fastpack0(const uint16_t *__restrict, uint16_t *__restrict) {
+}
+void __fastpack0(const uint32_t *__restrict, uint32_t *__restrict) {
+}
+void __fastpack0(const uint64_t *__restrict, uint32_t *__restrict) {
+}
+
+// fastunpack for 8 bits
+void __fastunpack1(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<1>::Unpack(in, out);
+}
+
+void __fastunpack2(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<2>::Unpack(in, out);
+}
+
+void __fastunpack3(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<3>::Unpack(in, out);
+}
+
+void __fastunpack4(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	for (uint8_t outer = 0; outer < 4; ++outer) {
+		for (uint8_t inwordpointer = 0; inwordpointer < 8; inwordpointer += 4)
+			*(out++) = ((*in) >> inwordpointer) % (1U << 4);
+		++in;
+	}
+}
+
+void __fastunpack5(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<5>::Unpack(in, out);
+}
+
+void __fastunpack6(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<6>::Unpack(in, out);
+}
+
+void __fastunpack7(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<7>::Unpack(in, out);
+}
+
+void __fastunpack8(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	for (int k = 0; k < 8; ++k)
+		out[k] = in[k];
+}
+
+
+// fastunpack for 16 bits
+void __fastunpack1(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<1>::Unpack(in, out);
+}
+
+void __fastunpack2(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<2>::Unpack(in, out);
+}
+
+void __fastunpack3(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<3>::Unpack(in, out);
+}
+
+void __fastunpack4(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	for (uint16_t outer = 0; outer < 4; ++outer) {
+		for (uint16_t inwordpointer = 0; inwordpointer < 16; inwordpointer += 4)
+			*(out++) = ((*in) >> inwordpointer) % (1U << 4);
+		++in;
+	}
+}
+
+void __fastunpack5(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<5>::Unpack(in, out);
+}
+
+void __fastunpack6(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<6>::Unpack(in, out);
+}
+
+void __fastunpack7(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<7>::Unpack(in, out);
+}
+
+void __fastunpack8(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	for (uint16_t outer = 0; outer < 8; ++outer) {
+		for (uint16_t inwordpointer = 0; inwordpointer < 16; inwordpointer += 8)
+			*(out++) = ((*in) >> inwordpointer) % (1U << 8);
+		++in;
+	}
+}
+
+void __fastunpack9(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<9>::Unpack(in, out);
+}
+
+void __fastunpack10(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<10>::Unpack(in, out);
+}
+
+void __fastunpack11(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<11>::Unpack(in, out);
+}
+
+void __fastunpack12(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<12>::Unpack(in, out);
+}
+
+void __fastunpack13(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<13>::Unpack(in, out);
+}
+
+void __fastunpack14(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<14>::Unpack(in, out);
+}
+
+void __fastunpack15(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<15>::Unpack(in, out);
+}
+
+void __fastunpack16(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	for (int k = 0; k < 16; ++k)
+		out[k] = in[k];
+}
+
+// fastunpack for 32 bits
+void __fastunpack1(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<1>::Unpack(in, out);
+}
+
+void __fastunpack2(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<2>::Unpack(in, out);
+}
+
+void __fastunpack3(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<3>::Unpack(in, out);
+}
+
+void __fastunpack4(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	for (uint32_t outer = 0; outer < 4; ++outer) {
+		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 4)
+			*(out++) = ((*in) >> inwordpointer) % (1U << 4);
+		++in;
+	}
+}
+
+void __fastunpack5(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<5>::Unpack(in, out);
+}
+
+void __fastunpack6(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<6>::Unpack(in, out);
+}
+
+void __fastunpack7(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<7>::Unpack(in, out);
+}
+
+void __fastunpack8(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	for (uint32_t outer = 0; outer < 8; ++outer) {
+		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 8)
+			*(out++) = ((*in) >> inwordpointer) % (1U << 8);
+		++in;
+	}
+}
+
+void __fastunpack9(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<9>::Unpack(in, out);
+}
+
+void __fastunpack10(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<10>::Unpack(in, out);
+}
+
+void __fastunpack11(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<11>::Unpack(in, out);
+}
+
+void __fastunpack12(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<12>::Unpack(in, out);
+}
+
+void __fastunpack13(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<13>::Unpack(in, out);
+}
+
+void __fastunpack14(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<14>::Unpack(in, out);
+}
+
+void __fastunpack15(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<15>::Unpack(in, out);
+}
+
+void __fastunpack16(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	for (uint32_t outer = 0; outer < 16; ++outer) {
+		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 16)
+			*(out++) = ((*in) >> inwordpointer) % (1U << 16);
+		++in;
+	}
+}
+
+void __fastunpack17(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<17>::Unpack(in, out);
+}
+
+void __fastunpack18(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<18>::Unpack(in, out);
+}
+
+void __fastunpack19(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<19>::Unpack(in, out);
+}
+
+void __fastunpack20(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<20>::Unpack(in, out);
+}
+
+void __fastunpack21(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<21>::Unpack(in, out);
+}
+
+void __fastunpack22(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<22>::Unpack(in, out);
+}
+
+void __fastunpack23(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<23>::Unpack(in, out);
+}
+
+void __fastunpack24(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<24>::Unpack(in, out);
+}
+
+void __fastunpack25(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<25>::Unpack(in, out);
+}
+
+void __fastunpack26(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<26>::Unpack(in, out);
+}
+
+void __fastunpack27(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<27>::Unpack(in, out);
+}
+
+void __fastunpack28(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<28>::Unpack(in, out);
+}
+
+void __fastunpack29(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<29>::Unpack(in, out);
+}
+
+void __fastunpack30(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<30>::Unpack(in, out);
+}
+
+void __fastunpack31(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<31>::Unpack(in, out);
+}
+
+void __fastunpack32(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	for (int k = 0; k < 32; ++k)
+		out[k] = in[k];
+}
+
+// fastupack for 64 bits
+void __fastunpack1(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<1>::Unpack(in, out);
+}
+
+void __fastunpack2(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<2>::Unpack(in, out);
+}
+
+void __fastunpack3(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<3>::Unpack(in, out);
+}
+
+void __fastunpack4(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	for (uint32_t outer = 0; outer < 4; ++outer) {
+		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 4)
+			*(out++) = ((*in) >> inwordpointer) % (1U << 4);
+		++in;
+	}
+}
+
+void __fastunpack5(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<5>::Unpack(in, out);
+}
+
+void __fastunpack6(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<6>::Unpack(in, out);
+}
+
+void __fastunpack7(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<7>::Unpack(in, out);
+}
+
+void __fastunpack8(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	for (uint32_t outer = 0; outer < 8; ++outer) {
+		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 8) {
+			*(out++) = ((*in) >> inwordpointer) % (1U << 8);
+		}
+		++in;
+	}
+}
+
+void __fastunpack9(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<9>::Unpack(in, out);
+}
+
+void __fastunpack10(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<10>::Unpack(in, out);
+}
+
+void __fastunpack11(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<11>::Unpack(in, out);
+}
+
+void __fastunpack12(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<12>::Unpack(in, out);
+}
+
+void __fastunpack13(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<13>::Unpack(in, out);
+}
+
+void __fastunpack14(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<14>::Unpack(in, out);
+}
+
+void __fastunpack15(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<15>::Unpack(in, out);
+}
+
+void __fastunpack16(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	for (uint32_t outer = 0; outer < 16; ++outer) {
+		for (uint32_t inwordpointer = 0; inwordpointer < 32; inwordpointer += 16)
+			*(out++) = ((*in) >> inwordpointer) % (1U << 16);
+		++in;
+	}
+}
+
+void __fastunpack17(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<17>::Unpack(in, out);
+}
+
+void __fastunpack18(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<18>::Unpack(in, out);
+}
+
+void __fastunpack19(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<19>::Unpack(in, out);
+}
+
+void __fastunpack20(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<20>::Unpack(in, out);
+}
+
+void __fastunpack21(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<21>::Unpack(in, out);
+}
+
+void __fastunpack22(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<22>::Unpack(in, out);
+}
+
+void __fastunpack23(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<23>::Unpack(in, out);
+}
+
+void __fastunpack24(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<24>::Unpack(in, out);
+}
+
+void __fastunpack25(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<25>::Unpack(in, out);
+}
+
+void __fastunpack26(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<26>::Unpack(in, out);
+}
+
+void __fastunpack27(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<27>::Unpack(in, out);
+}
+
+void __fastunpack28(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<28>::Unpack(in, out);
+}
+
+void __fastunpack29(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<29>::Unpack(in, out);
+}
+
+void __fastunpack30(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<30>::Unpack(in, out);
+}
+
+void __fastunpack31(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<31>::Unpack(in, out);
+}
+
+void __fastunpack32(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	for (int k = 0; k < 32; ++k)
+		out[k] = in[k];
+}
+
+void __fastunpack33(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<33>::Unpack(in, out);
+}
+
+void __fastunpack34(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<34>::Unpack(in, out);
+}
+
+void __fastunpack35(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<35>::Unpack(in, out);
+}
+
+void __fastunpack36(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<36>::Unpack(in, out);
+}
+
+void __fastunpack37(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<37>::Unpack(in, out);
+}
+
+void __fastunpack38(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<38>::Unpack(in, out);
+}
+
+void __fastunpack39(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<39>::Unpack(in, out);
+}
+
+void __fastunpack40(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<40>::Unpack(in, out);
+}
+
+void __fastunpack41(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<41>::Unpack(in, out);
+}
+
+void __fastunpack42(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<42>::Unpack(in, out);
+}
+
+void __fastunpack43(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<43>::Unpack(in, out);
+}
+
+void __fastunpack44(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<44>::Unpack(in, out);
+}
+
+void __fastunpack45(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<45>::Unpack(in, out);
+}
+
+void __fastunpack46(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<46>::Unpack(in, out);
+}
+
+void __fastunpack47(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<47>::Unpack(in, out);
+}
+
+void __fastunpack48(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<48>::Unpack(in, out);
+}
+
+void __fastunpack49(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<49>::Unpack(in, out);
+}
+
+void __fastunpack50(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<50>::Unpack(in, out);
+}
+
+void __fastunpack51(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<51>::Unpack(in, out);
+}
+
+void __fastunpack52(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<52>::Unpack(in, out);
+}
+
+void __fastunpack53(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<53>::Unpack(in, out);
+}
+
+void __fastunpack54(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<54>::Unpack(in, out);
+}
+
+void __fastunpack55(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<55>::Unpack(in, out);
+}
+
+void __fastunpack56(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<56>::Unpack(in, out);
+}
+
+void __fastunpack57(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<57>::Unpack(in, out);
+}
+
+void __fastunpack58(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<58>::Unpack(in, out);
+}
+
+void __fastunpack59(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<59>::Unpack(in, out);
+}
+
+void __fastunpack60(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<60>::Unpack(in, out);
+}
+
+void __fastunpack61(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<61>::Unpack(in, out);
+}
+
+void __fastunpack62(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<62>::Unpack(in, out);
+}
+
+void __fastunpack63(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	Unroller<63>::Unpack(in, out);
+}
+
+void __fastunpack64(const uint32_t *__restrict in, uint64_t *__restrict out) {
+	for (int k = 0; k < 32; ++k) {
+		out[k] = in[k * 2];
+		out[k] |= static_cast<uint64_t>(in[k * 2 + 1]) << 32;
+	}
+}
+
+// fastpack for 8 bits
+
+void __fastpack1(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<1>::Pack(in, out);
+}
+
+void __fastpack2(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<2>::Pack(in, out);
+}
+
+void __fastpack3(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<3>::Pack(in, out);
+}
+
+void __fastpack4(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<4>::Pack(in, out);
+}
+
+void __fastpack5(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<5>::Pack(in, out);
+}
+
+void __fastpack6(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<6>::Pack(in, out);
+}
+
+void __fastpack7(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	Unroller8<7>::Pack(in, out);
+}
+
+void __fastpack8(const uint8_t *__restrict in, uint8_t *__restrict out) {
+	for (int k = 0; k < 8; ++k)
+		out[k] = in[k];
+}
+
+// fastpack for 16 bits
+
+void __fastpack1(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<1>::Pack(in, out);
+}
+
+void __fastpack2(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<2>::Pack(in, out);
+}
+
+void __fastpack3(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<3>::Pack(in, out);
+}
+
+void __fastpack4(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<4>::Pack(in, out);
+}
+
+void __fastpack5(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<5>::Pack(in, out);
+}
+
+void __fastpack6(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<6>::Pack(in, out);
+}
+
+void __fastpack7(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<7>::Pack(in, out);
+}
+
+void __fastpack8(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<8>::Pack(in, out);
+}
+
+void __fastpack9(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<9>::Pack(in, out);
+}
+
+void __fastpack10(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<10>::Pack(in, out);
+}
+
+void __fastpack11(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<11>::Pack(in, out);
+}
+
+void __fastpack12(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<12>::Pack(in, out);
+}
+
+void __fastpack13(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<13>::Pack(in, out);
+}
+
+void __fastpack14(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<14>::Pack(in, out);
+}
+
+void __fastpack15(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	Unroller16<15>::Pack(in, out);
+}
+
+void __fastpack16(const uint16_t *__restrict in, uint16_t *__restrict out) {
+	for (int k = 0; k < 16; ++k)
+		out[k] = in[k];
+}
+
+
+// fastpack for 32 bits
+
+void __fastpack1(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<1>::Pack(in, out);
+}
+
+void __fastpack2(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<2>::Pack(in, out);
+}
+
+void __fastpack3(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<3>::Pack(in, out);
+}
+
+void __fastpack4(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<4>::Pack(in, out);
+}
+
+void __fastpack5(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<5>::Pack(in, out);
+}
+
+void __fastpack6(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<6>::Pack(in, out);
+}
+
+void __fastpack7(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<7>::Pack(in, out);
+}
+
+void __fastpack8(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<8>::Pack(in, out);
+}
+
+void __fastpack9(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<9>::Pack(in, out);
+}
+
+void __fastpack10(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<10>::Pack(in, out);
+}
+
+void __fastpack11(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<11>::Pack(in, out);
+}
+
+void __fastpack12(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<12>::Pack(in, out);
+}
+
+void __fastpack13(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<13>::Pack(in, out);
+}
+
+void __fastpack14(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<14>::Pack(in, out);
+}
+
+void __fastpack15(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<15>::Pack(in, out);
+}
+
+void __fastpack16(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<16>::Pack(in, out);
+}
+
+void __fastpack17(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<17>::Pack(in, out);
+}
+
+void __fastpack18(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<18>::Pack(in, out);
+}
+
+void __fastpack19(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<19>::Pack(in, out);
+}
+
+void __fastpack20(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<20>::Pack(in, out);
+}
+
+void __fastpack21(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<21>::Pack(in, out);
+}
+
+void __fastpack22(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<22>::Pack(in, out);
+}
+
+void __fastpack23(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<23>::Pack(in, out);
+}
+
+void __fastpack24(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<24>::Pack(in, out);
+}
+
+void __fastpack25(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<25>::Pack(in, out);
+}
+
+void __fastpack26(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<26>::Pack(in, out);
+}
+
+void __fastpack27(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<27>::Pack(in, out);
+}
+
+void __fastpack28(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<28>::Pack(in, out);
+}
+
+void __fastpack29(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<29>::Pack(in, out);
+}
+
+void __fastpack30(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<30>::Pack(in, out);
+}
+
+void __fastpack31(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<31>::Pack(in, out);
+}
+
+void __fastpack32(const uint32_t *__restrict in, uint32_t *__restrict out) {
+	for (int k = 0; k < 32; ++k)
+		out[k] = in[k];
+}
+
+// fastpack for 64 bits
+
+void __fastpack1(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<1>::Pack(in, out);
+}
+
+void __fastpack2(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<2>::Pack(in, out);
+}
+
+void __fastpack3(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<3>::Pack(in, out);
+}
+
+void __fastpack4(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<4>::Pack(in, out);
+}
+
+void __fastpack5(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<5>::Pack(in, out);
+}
+
+void __fastpack6(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<6>::Pack(in, out);
+}
+
+void __fastpack7(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<7>::Pack(in, out);
+}
+
+void __fastpack8(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<8>::Pack(in, out);
+}
+
+void __fastpack9(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<9>::Pack(in, out);
+}
+
+void __fastpack10(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<10>::Pack(in, out);
+}
+
+void __fastpack11(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<11>::Pack(in, out);
+}
+
+void __fastpack12(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<12>::Pack(in, out);
+}
+
+void __fastpack13(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<13>::Pack(in, out);
+}
+
+void __fastpack14(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<14>::Pack(in, out);
+}
+
+void __fastpack15(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<15>::Pack(in, out);
+}
+
+void __fastpack16(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<16>::Pack(in, out);
+}
+
+void __fastpack17(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<17>::Pack(in, out);
+}
+
+void __fastpack18(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<18>::Pack(in, out);
+}
+
+void __fastpack19(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<19>::Pack(in, out);
+}
+
+void __fastpack20(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<20>::Pack(in, out);
+}
+
+void __fastpack21(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<21>::Pack(in, out);
+}
+
+void __fastpack22(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<22>::Pack(in, out);
+}
+
+void __fastpack23(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<23>::Pack(in, out);
+}
+
+void __fastpack24(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<24>::Pack(in, out);
+}
+
+void __fastpack25(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<25>::Pack(in, out);
+}
+
+void __fastpack26(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<26>::Pack(in, out);
+}
+
+void __fastpack27(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<27>::Pack(in, out);
+}
+
+void __fastpack28(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<28>::Pack(in, out);
+}
+
+void __fastpack29(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<29>::Pack(in, out);
+}
+
+void __fastpack30(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<30>::Pack(in, out);
+}
+
+void __fastpack31(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<31>::Pack(in, out);
+}
+
+void __fastpack32(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	for (int k = 0; k < 32; ++k) {
+		out[k] = static_cast<uint32_t>(in[k]);
+	}
+}
+
+void __fastpack33(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<33>::Pack(in, out);
+}
+
+void __fastpack34(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<34>::Pack(in, out);
+}
+
+void __fastpack35(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<35>::Pack(in, out);
+}
+
+void __fastpack36(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<36>::Pack(in, out);
+}
+
+void __fastpack37(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<37>::Pack(in, out);
+}
+
+void __fastpack38(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<38>::Pack(in, out);
+}
+
+void __fastpack39(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<39>::Pack(in, out);
+}
+
+void __fastpack40(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<40>::Pack(in, out);
+}
+
+void __fastpack41(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<41>::Pack(in, out);
+}
+
+void __fastpack42(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<42>::Pack(in, out);
+}
+
+void __fastpack43(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<43>::Pack(in, out);
+}
+
+void __fastpack44(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<44>::Pack(in, out);
+}
+
+void __fastpack45(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<45>::Pack(in, out);
+}
+
+void __fastpack46(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<46>::Pack(in, out);
+}
+
+void __fastpack47(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<47>::Pack(in, out);
+}
+
+void __fastpack48(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<48>::Pack(in, out);
+}
+
+void __fastpack49(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<49>::Pack(in, out);
+}
+
+void __fastpack50(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<50>::Pack(in, out);
+}
+
+void __fastpack51(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<51>::Pack(in, out);
+}
+
+void __fastpack52(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<52>::Pack(in, out);
+}
+
+void __fastpack53(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<53>::Pack(in, out);
+}
+
+void __fastpack54(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<54>::Pack(in, out);
+}
+
+void __fastpack55(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<55>::Pack(in, out);
+}
+
+void __fastpack56(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<56>::Pack(in, out);
+}
+
+void __fastpack57(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<57>::Pack(in, out);
+}
+
+void __fastpack58(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<58>::Pack(in, out);
+}
+
+void __fastpack59(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<59>::Pack(in, out);
+}
+
+void __fastpack60(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<60>::Pack(in, out);
+}
+
+void __fastpack61(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<61>::Pack(in, out);
+}
+
+void __fastpack62(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<62>::Pack(in, out);
+}
+
+void __fastpack63(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	Unroller<63>::Pack(in, out);
+}
+
+void __fastpack64(const uint64_t *__restrict in, uint32_t *__restrict out) {
+	for (int i = 0; i < 32; ++i) {
+		out[2 * i] = static_cast<uint32_t>(in[i]);
+		out[2 * i + 1] = in[i] >> 32;
+	}
+}
+} // namespace internal
+} // namespace duckdb_fastpforlib
+
+
+// LICENSE_CHANGE_END
+
+
 // LICENSE_CHANGE_BEGIN
 // The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #2
 // See the end of this file for a list
@@ -257162,4 +260733,199 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 
+
+### THIRD PARTY LICENSE #10 ###
+
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
 */