duckdb 1.3.4 → 1.4.0

package/src/duckdb/src/transaction/undo_buffer_allocator.cpp

@@ -28,6 +28,7 @@ UndoBufferAllocator::UndoBufferAllocator(BufferManager &buffer_manager) : buffer
 }
 
 UndoBufferReference UndoBufferAllocator::Allocate(idx_t alloc_len) {
+	lock_guard<mutex> guard(lock);
 	D_ASSERT(!head || head->position <= head->capacity);
 	BufferHandle handle;
 	if (!head || head->position + alloc_len > head->capacity) {

package/src/duckdb/src/transaction/wal_write_state.cpp

@@ -281,6 +281,8 @@ void WALWriteState::CommitEntry(UndoFlags type, data_ptr_t data) {
 		}
 		break;
 	}
+	case UndoFlags::ATTACHED_DATABASE:
+		break;
 	case UndoFlags::SEQUENCE_VALUE: {
 		auto info = reinterpret_cast<SequenceValue *>(data);
 		log.WriteSequenceValue(*info);

package/src/duckdb/src/verification/explain_statement_verifier.cpp

@@ -0,0 +1,16 @@
+#include "duckdb/verification/explain_statement_verifier.hpp"
+
+namespace duckdb {
+
+ExplainStatementVerifier::ExplainStatementVerifier(unique_ptr<SQLStatement> statement_p,
+                                                   optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters)
+    : StatementVerifier(VerificationType::EXPLAIN, "Explain", std::move(statement_p), parameters) {
+}
+
+unique_ptr<StatementVerifier>
+ExplainStatementVerifier::Create(const SQLStatement &statement,
+                                 optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters) {
+	return make_uniq<ExplainStatementVerifier>(statement.Copy(), parameters);
+}
+
+} // namespace duckdb

package/src/duckdb/src/verification/prepared_statement_verifier.cpp

@@ -21,7 +21,7 @@ PreparedStatementVerifier::Create(const SQLStatement &statement,
 }
 
 void PreparedStatementVerifier::Extract() {
-	auto &select = *statement;
+	auto &select = *select_statement;
 	// replace all the constants from the select statement and replace them with parameter expressions
 	ParsedExpressionIterator::EnumerateQueryNodeChildren(
 	    *select.node, [&](unique_ptr<ParsedExpression> &child) { ConvertConstants(child); });

package/src/duckdb/src/verification/statement_verifier.cpp

@@ -11,14 +11,17 @@
 #include "duckdb/verification/unoptimized_statement_verifier.hpp"
 #include "duckdb/verification/no_operator_caching_verifier.hpp"
 #include "duckdb/verification/fetch_row_verifier.hpp"
+#include "duckdb/verification/explain_statement_verifier.hpp"
 
 namespace duckdb {
 
 StatementVerifier::StatementVerifier(VerificationType type, string name, unique_ptr<SQLStatement> statement_p,
                                      optional_ptr<case_insensitive_map_t<BoundParameterData>> parameters_p)
-    : type(type), name(std::move(name)),
-      statement(unique_ptr_cast<SQLStatement, SelectStatement>(std::move(statement_p))), parameters(parameters_p),
-      select_list(statement->node->GetSelectList()) {
+    : type(type), name(std::move(name)), statement(std::move(statement_p)),
+      select_statement(statement->type == StatementType::SELECT_STATEMENT ? &statement->Cast<SelectStatement>()
+                                                                          : nullptr),
+      parameters(parameters_p),
+      select_list(select_statement ? select_statement->node->GetSelectList() : empty_select_list) {
 }
 
 StatementVerifier::StatementVerifier(unique_ptr<SQLStatement> statement_p,
@@ -47,6 +50,8 @@ StatementVerifier::Create(VerificationType type, const SQLStatement &statement_p
 		return PreparedStatementVerifier::Create(statement_p, parameters);
 	case VerificationType::EXTERNAL:
 		return ExternalStatementVerifier::Create(statement_p, parameters);
+	case VerificationType::EXPLAIN:
+		return ExplainStatementVerifier::Create(statement_p, parameters);
 	case VerificationType::FETCH_ROW_AS_SCAN:
 		return FetchRowVerifier::Create(statement_p, parameters);
 	case VerificationType::INVALID:
@@ -60,8 +65,8 @@ void StatementVerifier::CheckExpressions(const StatementVerifier &other) const {
 	D_ASSERT(type == VerificationType::ORIGINAL);
 
 	// Check equality
-	if (other.RequireEquality()) {
-		D_ASSERT(statement->Equals(*other.statement));
+	if (other.RequireEquality() && select_statement) {
+		D_ASSERT(select_statement->Equals(*other.select_statement));
 	}
 
 #ifdef DEBUG

package/src/duckdb/third_party/brotli/common/shared_dictionary.cpp

@@ -60,9 +60,9 @@ static BROTLI_BOOL ReadUint16(const uint8_t* encoded, size_t size, size_t* pos,
   return BROTLI_TRUE;
 }
 
-/* Reads a varint into a uint32_t, and returns error if it's too large */
+/* Reads a bignum into a uint32_t, and returns error if it's too large */
 /* Returns BROTLI_TRUE on success, BROTLI_FALSE on failure. */
-static BROTLI_BOOL ReadVarint32(const uint8_t* encoded, size_t size,
+static BROTLI_BOOL ReadBignum32(const uint8_t* encoded, size_t size,
     size_t* pos, uint32_t* result) {
   int num = 0;
   uint8_t byte;
@@ -248,7 +248,7 @@ static BROTLI_BOOL DryParseDictionary(const uint8_t* encoded,
   pos += 2;
 
   /* LZ77_DICTIONARY_LENGTH */
-  if (!ReadVarint32(encoded, size, &pos, &chunk_size)) return BROTLI_FALSE;
+  if (!ReadBignum32(encoded, size, &pos, &chunk_size)) return BROTLI_FALSE;
   if (chunk_size != 0) {
     /* This limitation is not specified but the 32-bit Brotli decoder for now */
     if (chunk_size > 1073741823) return BROTLI_FALSE;
@@ -284,7 +284,7 @@ static BROTLI_BOOL ParseDictionary(const uint8_t* encoded, size_t size,
   pos += 2;
 
   /* LZ77_DICTIONARY_LENGTH */
-  if (!ReadVarint32(encoded, size, &pos, &chunk_size)) return BROTLI_FALSE;
+  if (!ReadBignum32(encoded, size, &pos, &chunk_size)) return BROTLI_FALSE;
   if (chunk_size != 0) {
     if (pos + chunk_size > size) return BROTLI_FALSE;
     dict->prefix_size[dict->num_prefix] = chunk_size;

package/src/duckdb/third_party/fmt/include/fmt/core.h

@@ -8,6 +8,9 @@
 #ifndef FMT_CORE_H_
 #define FMT_CORE_H_
 
+#include "duckdb/common/hugeint.hpp"
+#include "duckdb/common/uhugeint.hpp"
+
 #include <cstdio>  // std::FILE
 #include <cstring>
 #include <iterator>
@@ -231,19 +234,16 @@ using std_string_view = std::experimental::basic_string_view<Char>;
 template <typename T> struct std_string_view {};
 #endif
 
+using int128_t = duckdb::hugeint_t;
+using uint128_t = duckdb::uhugeint_t;
+
 #ifdef FMT_USE_INT128
 // Do nothing.
 #elif defined(__SIZEOF_INT128__)
 #  define FMT_USE_INT128 1
-using int128_t = __int128_t;
-using uint128_t = __uint128_t;
 #else
 #  define FMT_USE_INT128 0
 #endif
-#if !FMT_USE_INT128
-struct int128_t {};
-struct uint128_t {};
-#endif
 
 // Casts a nonnegative integer to unsigned.
 template <typename Int>
@@ -1004,16 +1004,10 @@ FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
     return vis(arg.value_.long_long_value);
   case internal::ulong_long_type:
     return vis(arg.value_.ulong_long_value);
-#if FMT_USE_INT128
   case internal::int128_type:
     return vis(arg.value_.int128_value);
   case internal::uint128_type:
     return vis(arg.value_.uint128_value);
-#else
-  case internal::int128_type:
-  case internal::uint128_type:
-    break;
-#endif
   case internal::bool_type:
     return vis(arg.value_.bool_value);
   case internal::char_type:

package/src/duckdb/third_party/fmt/include/fmt/format-inl.h

@@ -629,7 +629,11 @@ class bigint {
     int num_bigits = static_cast<int>(bigits_.size());
     int num_result_bigits = 2 * num_bigits;
     bigits_.resize(num_result_bigits);
-    using accumulator_t = conditional_t<FMT_USE_INT128, uint128_t, accumulator>;
+#if FMT_USE_INT128
+    using accumulator_t = __uint128_t;
+#else
+    using accumulator_t = accumulator;
+#endif
     auto sum = accumulator_t();
     for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
       // Compute bigit at position bigit_index of the result by adding

package/src/duckdb/third_party/fmt/include/fmt/format.h

@@ -34,6 +34,7 @@
 #define FMT_FORMAT_H_
 
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/limits.hpp"
 #include "duckdb/original/std/memory.hpp"
 #include "fmt/core.h"
 
@@ -254,9 +255,21 @@ inline fallback_uintptr to_uintptr(const void* p) {
 template <typename T> constexpr T max_value() {
   return (std::numeric_limits<T>::max)();
 }
+template <> constexpr int128_t max_value<int128_t>() {
+  return duckdb::NumericLimits<int128_t>::Maximum();
+}
+template <> constexpr uint128_t max_value<uint128_t>() {
+  return duckdb::NumericLimits<uint128_t>::Maximum();
+}
 template <typename T> constexpr int num_bits() {
   return std::numeric_limits<T>::digits;
 }
+template <> constexpr int num_bits<int128_t>() {
+  return 127;
+}
+template <> constexpr int num_bits<uint128_t>() {
+  return 128;
+}
 template <> constexpr int num_bits<fallback_uintptr>() {
   return static_cast<int>(sizeof(void*) *
                           std::numeric_limits<unsigned char>::digits);
@@ -555,7 +568,7 @@ class u8string_view : public basic_string_view<fmt_char8_t> {
 
 #if FMT_USE_USER_DEFINED_LITERALS
 inline namespace literals {
-inline u8string_view operator"" _u(const char* s, std::size_t n) {
+inline u8string_view operator""_u(const char* s, std::size_t n) {
   return {s, n};
 }
 }  // namespace literals
@@ -691,11 +704,11 @@ namespace internal {
 
 // Returns true if value is negative, false otherwise.
 // Same as `value < 0` but doesn't produce warnings if T is an unsigned type.
-template <typename T, FMT_ENABLE_IF(std::numeric_limits<T>::is_signed)>
+template <typename T, FMT_ENABLE_IF(std::numeric_limits<T>::is_signed || std::is_same<T, int128_t>::value)>
 FMT_CONSTEXPR bool is_negative(T value) {
   return value < 0;
 }
-template <typename T, FMT_ENABLE_IF(!std::numeric_limits<T>::is_signed)>
+template <typename T, FMT_ENABLE_IF(!std::numeric_limits<T>::is_signed && !std::is_same<T, int128_t>::value)>
 FMT_CONSTEXPR bool is_negative(T) {
   return false;
 }
@@ -703,9 +716,10 @@ FMT_CONSTEXPR bool is_negative(T) {
 // Smallest of uint32_t, uint64_t, uint128_t that is large enough to
 // represent all values of T.
 template <typename T>
-using uint32_or_64_or_128_t = conditional_t<
-    std::numeric_limits<T>::digits <= 32, uint32_t,
-    conditional_t<std::numeric_limits<T>::digits <= 64, uint64_t, uint128_t>>;
+using uint32_or_64_or_128_t =
+    conditional_t<std::is_same<T, int128_t>::value || std::is_same<T, uint128_t>::value, uint128_t,
+                  conditional_t<std::numeric_limits<T>::digits <= 32, uint32_t,
+                                conditional_t<std::numeric_limits<T>::digits <= 64, uint64_t, uint128_t>>>;
 
 // Static data is placed in this class template for the header-only config.
 template <typename T = void> struct FMT_EXTERN_TEMPLATE_API basic_data {
@@ -755,7 +769,6 @@ inline int count_digits(uint64_t n) {
 }
 #endif
 
-#if FMT_USE_INT128
 inline int count_digits(uint128_t n) {
   int count = 1;
   for (;;) {
@@ -770,7 +783,6 @@ inline int count_digits(uint128_t n) {
     count += 4;
   }
 }
-#endif
 
 // Counts the number of digits in n. BITS = log2(radix).
 template <unsigned BITS, typename UInt> inline int count_digits(UInt n) {
@@ -842,7 +854,7 @@ inline Char* format_decimal(Char* buffer, UInt value, int num_digits,
     add_thousands_sep(buffer);
   }
   if (value < 10) {
-    *--buffer = static_cast<Char>('0' + value);
+    *--buffer = static_cast<Char>('0' + static_cast<uint8_t>(value));
     return end;
   }
   auto index = static_cast<unsigned>(value * 2);
@@ -881,7 +893,7 @@ inline Char* format_uint(Char* buffer, UInt value, int num_digits,
   Char* end = buffer;
   do {
     const char* digits = upper ? "0123456789ABCDEF" : data::hex_digits;
-    unsigned digit = (value & ((1 << BASE_BITS) - 1));
+    unsigned digit = (static_cast<unsigned>(value) & ((1 << BASE_BITS) - 1));
     *--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
                                                 : digits[digit]);
   } while ((value >>= BASE_BITS) != 0);
@@ -1455,7 +1467,7 @@ template <typename Range> class basic_writer {
       if (is_negative(value)) {
         prefix[0] = '-';
         ++prefix_size;
-        abs_value = 0 - abs_value;
+        abs_value = -abs_value;
       } else if (specs.sign != sign::none && specs.sign != sign::minus) {
         prefix[0] = specs.sign == sign::plus ? '+' : ' ';
         ++prefix_size;
@@ -1651,10 +1663,8 @@ template <typename Range> class basic_writer {
   void write(unsigned long value) { write_decimal(value); }
   void write(unsigned long long value) { write_decimal(value); }
 
-#if FMT_USE_INT128
   void write(int128_t value) { write_decimal(value); }
   void write(uint128_t value) { write_decimal(value); }
-#endif
 
   template <typename T, typename Spec>
   void write_int(T value, const Spec& spec) {
@@ -1977,13 +1987,13 @@ template <typename ErrorHandler> class width_checker {
   explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {}
 
   template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T value) {
+  FMT_CONSTEXPR uint64_t operator()(T value) {
     if (is_negative(value)) handler_.on_error("negative width");
-    return static_cast<unsigned long long>(value);
+    return static_cast<uint64_t>(value);
   }
 
   template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T) {
+  FMT_CONSTEXPR uint64_t operator()(T) {
     handler_.on_error("width is not integer");
     return 0;
   }
@@ -1997,13 +2007,13 @@ template <typename ErrorHandler> class precision_checker {
   explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {}
 
   template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T value) {
+  FMT_CONSTEXPR uint64_t operator()(T value) {
     if (is_negative(value)) handler_.on_error("negative precision");
-    return static_cast<unsigned long long>(value);
+    return static_cast<uint64_t>(value);
   }
 
   template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
-  FMT_CONSTEXPR unsigned long long operator()(T) {
+  FMT_CONSTEXPR uint64_t operator()(T) {
     handler_.on_error("precision is not integer");
     return 0;
   }
@@ -2128,7 +2138,7 @@ template <typename Handler> class specs_checker : public Handler {
 template <template <typename> class Handler, typename FormatArg,
           typename ErrorHandler>
 FMT_CONSTEXPR int get_dynamic_spec(FormatArg arg, ErrorHandler eh) {
-  unsigned long long value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
+  uint64_t value = visit_format_arg(Handler<ErrorHandler>(eh), arg);
   if (value > to_unsigned(max_value<int>())) eh.on_error("number is too big");
   return static_cast<int>(value);
 }
@@ -3349,11 +3359,11 @@ FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format() {
     std::string message = "The answer is {}"_format(42);
   \endrst
  */
-FMT_CONSTEXPR internal::udl_formatter<char> operator"" _format(const char* s,
+FMT_CONSTEXPR internal::udl_formatter<char> operator""_format(const char* s,
                                                                std::size_t n) {
   return {{s, n}};
 }
-FMT_CONSTEXPR internal::udl_formatter<wchar_t> operator"" _format(
+FMT_CONSTEXPR internal::udl_formatter<wchar_t> operator""_format(
     const wchar_t* s, std::size_t n) {
   return {{s, n}};
 }
@@ -3369,11 +3379,11 @@ FMT_CONSTEXPR internal::udl_formatter<wchar_t> operator"" _format(
     fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
   \endrst
  */
-FMT_CONSTEXPR internal::udl_arg<char> operator"" _a(const char* s,
+FMT_CONSTEXPR internal::udl_arg<char> operator""_a(const char* s,
                                                     std::size_t n) {
   return {{s, n}};
 }
-FMT_CONSTEXPR internal::udl_arg<wchar_t> operator"" _a(const wchar_t* s,
+FMT_CONSTEXPR internal::udl_arg<wchar_t> operator""_a(const wchar_t* s,
                                                        std::size_t n) {
   return {{s, n}};
 }

package/src/duckdb/third_party/fmt/include/fmt/printf.h

@@ -12,6 +12,9 @@
 #include <limits>     // std::numeric_limits
 
 #include "fmt/ostream.h"
+#include "duckdb/common/hugeint.hpp"
+#include "duckdb/common/uhugeint.hpp"
+#include "duckdb/common/operator/cast_operators.hpp"
 
 #ifdef min
 #undef min
@@ -40,14 +43,14 @@ template <> struct int_checker<true> {
 
 class printf_precision_handler {
  public:
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  template <typename T, FMT_ENABLE_IF(is_integral<T>::value)>
   int operator()(T value) {
-    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
+    if (!int_checker<std::numeric_limits<T>::is_signed || std::is_same<T, int128_t>::value>::fits_in_int(value))
       FMT_THROW(duckdb::InvalidInputException("number is too big"));
     return (std::max)(static_cast<int>(value), 0);
   }
 
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  template <typename T, FMT_ENABLE_IF(!is_integral<T>::value)>
   int operator()(T) {
     FMT_THROW(duckdb::InvalidInputException("precision is not integer"));
     return 0;
@@ -57,12 +60,12 @@ class printf_precision_handler {
 // An argument visitor that returns true iff arg is a zero integer.
 class is_zero_int {
  public:
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  template <typename T, FMT_ENABLE_IF(is_integral<T>::value)>
   bool operator()(T value) {
     return value == 0;
   }
 
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  template <typename T, FMT_ENABLE_IF(!is_integral<T>::value)>
   bool operator()(T) {
     return false;
   }
@@ -71,6 +74,8 @@ class is_zero_int {
 template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
 
 template <> struct make_unsigned_or_bool<bool> { using type = bool; };
+template <> struct make_unsigned_or_bool<int128_t> { using type = uint128_t; };
+template <> struct make_unsigned_or_bool<uint128_t> { using type = uint128_t; };
 
 template <typename T, typename Context> class arg_converter {
  private:
@@ -79,42 +84,65 @@ template <typename T, typename Context> class arg_converter {
   basic_format_arg<Context>& arg_;
   char_type type_;
 
+  bool is_unsigned_type(internal::type t) {
+    return t == uint_type || t == ulong_long_type || t == uint128_type;
+  }
+
+  template <typename To, typename From>
+  To Cast(From x) {
+    return duckdb::Cast::Operation<From, To>(x);
+  }
+  template <typename To, typename From>
+  typename std::enable_if<std::is_constructible<To, From>::value, To>::type UnsafeCast(From x) {
+    return static_cast<To>(x);
+  }
+
+  template <typename To, typename From>
+  typename std::enable_if<!std::is_constructible<To, From>::value, To>::type UnsafeCast(From x) {
+    return static_cast<To>(x.lower);
+  }
+
  public:
   arg_converter(basic_format_arg<Context>& arg, char_type type)
-      : arg_(arg), type_(type) {}
+      : arg_(arg), type_(type) {
+        if ((type_ == 'd' || type_ == 'i') && is_unsigned_type(arg_.type())) {
+          type_ = 'u';
+        }
+      }
 
   void operator()(bool value) {
     if (type_ != 's') operator()<bool>(value);
   }
 
-  template <typename U, FMT_ENABLE_IF(std::is_integral<U>::value)>
+  template <typename U, FMT_ENABLE_IF(is_integral<U>::value)>
   void operator()(U value) {
     bool is_signed = type_ == 'd' || type_ == 'i';
     using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
     if (const_check(sizeof(target_type) <= sizeof(int))) {
       // Extra casts are used to silence warnings.
       if (is_signed) {
-        arg_ = internal::make_arg<Context>(
-            static_cast<int>(static_cast<target_type>(value)));
+        arg_ = internal::make_arg<Context>(UnsafeCast<int32_t>(UnsafeCast<target_type>(value)));
       } else {
         using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
-        arg_ = internal::make_arg<Context>(
-            static_cast<unsigned>(static_cast<unsigned_type>(value)));
+        arg_ = internal::make_arg<Context>(UnsafeCast<uint32_t>(UnsafeCast<unsigned_type>(value)));
       }
     } else {
       if (is_signed) {
         // glibc's printf doesn't sign extend arguments of smaller types:
         //   std::printf("%lld", -42);  // prints "4294967254"
         // but we don't have to do the same because it's a UB.
-        arg_ = internal::make_arg<Context>(static_cast<long long>(value));
+        if (sizeof(target_type) > sizeof(int64_t)) {
+          arg_ = internal::make_arg<Context>(Cast<int128_t>(value));
+        } else {
+          arg_ = internal::make_arg<Context>(UnsafeCast<int64_t>(value));
+        }
       } else {
-        arg_ = internal::make_arg<Context>(
-            static_cast<typename make_unsigned_or_bool<U>::type>(value));
+        arg_ = internal::make_arg<Context>(UnsafeCast<typename make_unsigned_or_bool<U>::type>(value));
       }
     }
   }
 
-  template <typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)>
+  template <typename U, FMT_ENABLE_IF(!is_integral<U>::value)>
   void operator()(U) {}  // No conversion needed for non-integral types.
 };
 
@@ -135,13 +163,13 @@ template <typename Context> class char_converter {
  public:
   explicit char_converter(basic_format_arg<Context>& arg) : arg_(arg) {}
 
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  template <typename T, FMT_ENABLE_IF(is_integral<T>::value)>
   void operator()(T value) {
     arg_ = internal::make_arg<Context>(
-        static_cast<typename Context::char_type>(value));
+        static_cast<typename Context::char_type>(static_cast<uint32_t>(value)));
   }
 
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  template <typename T, FMT_ENABLE_IF(!is_integral<T>::value)>
   void operator()(T) {}  // No conversion needed for non-integral types.
 };
 
@@ -156,19 +184,19 @@ template <typename Char> class printf_width_handler {
  public:
   explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
 
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  template <typename T, FMT_ENABLE_IF(is_integral<T>::value)>
   unsigned operator()(T value) {
     auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
     if (internal::is_negative(value)) {
       specs_.align = align::left;
-      width = 0 - width;
+      width = -width;
     }
     unsigned int_max = max_value<int>();
     if (width > int_max) FMT_THROW(duckdb::InvalidInputException("number is too big"));
     return static_cast<unsigned>(width);
   }
 
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  template <typename T, FMT_ENABLE_IF(!is_integral<T>::value)>
   unsigned operator()(T) {
     FMT_THROW(duckdb::InvalidInputException("width is not integer"));
     return 0;

package/src/duckdb/third_party/httplib/httplib.hpp

@@ -15,6 +15,9 @@
 
 #include "duckdb/original/std/memory.hpp"
 #include "duckdb/common/string.hpp"
+#include <exception>
+#include <stdexcept>
+
 
 /*
  * Configuration
@@ -286,6 +289,7 @@ using socket_t = int;
 #include <iostream>
 #include <sstream>
 
+
 // Disabled OpenSSL version check for CI
 //#if OPENSSL_VERSION_NUMBER < 0x1010100fL
 //#error Sorry, OpenSSL versions prior to 1.1.1 are not supported
@@ -2578,7 +2582,7 @@ inline std::string trim_double_quotes_copy(const std::string &s) {
 
 inline void split(const char *b, const char *e, char d,
                   std::function<void(const char *, const char *)> fn) {
-  return split(b, e, d, std::numeric_limits<size_t>::max(), fn);
+  return split(b, e, d, static_cast<size_t>((std::numeric_limits<size_t>::max)()), fn);
 }
 
 inline void split(const char *b, const char *e, char d, size_t m,
@@ -3426,7 +3430,7 @@ inline unsigned int str2tag(const std::string &s) {
 
 namespace udl {
 
-inline constexpr unsigned int operator "" _t(const char *s, size_t l) {
+inline constexpr unsigned int operator ""_t(const char *s, size_t l) {
   return str2tag_core(s, l, 0);
 }
 
@@ -3441,7 +3445,7 @@ find_content_type(const std::string &path,
   auto it = user_data.find(ext);
   if (it != user_data.end()) { return it->second; }
 
-  using udl::operator "" _t;
+  using udl::operator ""_t;
 
   switch (str2tag(ext)) {
   default: return default_content_type;
@@ -3499,7 +3503,7 @@ find_content_type(const std::string &path,
 }
 
 inline bool can_compress_content_type(const std::string &content_type) {
-  using udl::operator "" _t;
+  using udl::operator ""_t;
 
   auto tag = str2tag(content_type);
 
@@ -8551,7 +8555,11 @@ inline long SSLClient::get_openssl_verify_result() const {
 inline SSL_CTX *SSLClient::ssl_context() const { return ctx_; }
 
 inline bool SSLClient::create_and_connect_socket(Socket &socket, Error &error) {
-  return is_valid() && ClientImpl::create_and_connect_socket(socket, error);
+  if (!is_valid()) {
+    error = Error::SSLConnection;
+    return false;
+  }
+  return ClientImpl::create_and_connect_socket(socket, error);
 }
 
 // Assumes that socket_mutex_ is locked and that there are no requests in flight

package/src/duckdb/third_party/jaro_winkler/details/jaro_impl.hpp

@@ -448,7 +448,7 @@ double jaro_winkler_similarity(InputIt1 P_first, InputIt1 P_last, InputIt2 T_fir
 
     double jaro_score_cutoff = score_cutoff;
     if (jaro_score_cutoff > 0.7) {
-        double prefix_sim = prefix * prefix_weight;
+        double prefix_sim = static_cast<double>(prefix) * prefix_weight;
 
         if (prefix_sim >= 1.0) {
             jaro_score_cutoff = 0.7;
@@ -461,7 +461,7 @@ double jaro_winkler_similarity(InputIt1 P_first, InputIt1 P_last, InputIt2 T_fir
 
     double Sim = jaro_similarity(P_first, P_last, T_first, T_last, jaro_score_cutoff);
     if (Sim > 0.7) {
-        Sim += prefix * prefix_weight * (1.0 - Sim);
+        Sim += static_cast<double>(prefix) * prefix_weight * (1.0 - Sim);
     }
 
     return common::result_cutoff(Sim, score_cutoff);
@@ -486,7 +486,7 @@ double jaro_winkler_similarity(const common::BlockPatternMatchVector& PM, InputI
 
     double jaro_score_cutoff = score_cutoff;
     if (jaro_score_cutoff > 0.7) {
-        double prefix_sim = prefix * prefix_weight;
+        double prefix_sim = static_cast<double>(prefix) * prefix_weight;
 
         if (prefix_sim >= 1.0) {
             jaro_score_cutoff = 0.7;
@@ -499,7 +499,7 @@ double jaro_winkler_similarity(const common::BlockPatternMatchVector& PM, InputI
 
     double Sim = jaro_similarity(PM, P_first, P_last, T_first, T_last, jaro_score_cutoff);
     if (Sim > 0.7) {
-        Sim += prefix * prefix_weight * (1.0 - Sim);
+        Sim += static_cast<double>(prefix) * prefix_weight * (1.0 - Sim);
     }
 
     return common::result_cutoff(Sim, score_cutoff);

package/src/duckdb/third_party/libpg_query/include/nodes/nodes.hpp

@@ -333,6 +333,7 @@ typedef enum PGNodeTag {
 	T_PGTruncateStmt,
 	T_PGCommentStmt,
 	T_PGCommentOnStmt,
+	T_PGMergeIntoStmt,
 	T_PGFetchStmt,
 	T_PGIndexStmt,
 	T_PGFunctionDefinition,
@@ -495,6 +496,8 @@ typedef enum PGNodeTag {
 	T_PGSampleOptions,
 	T_PGLimitPercent,
 	T_PGPositionalReference,
+	T_PGMatchEntry,
+	T_PGMatchAction,
 
 	/*
 	 * TAGS FOR REPLICATION GRAMMAR PARSE NODES (replnodes.h)