duckdb 0.7.2-dev2740.0 → 0.7.2-dev2867.0

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

@@ -951,6 +951,7 @@ template <typename Char> struct basic_format_specs {
   sign_t sign : 3;
   bool alt : 1;  // Alternate form ('#').
   internal::fill_t<Char> fill;
+  char thousands;
 
   constexpr basic_format_specs()
       : width(0),
@@ -959,7 +960,8 @@ template <typename Char> struct basic_format_specs {
         align(align::none),
         sign(sign::none),
         alt(false),
-        fill(internal::fill_t<Char>::make()) {}
+        fill(internal::fill_t<Char>::make()),
+        thousands('\0'){}
 };
 
 using format_specs = basic_format_specs<char>;
@@ -1124,9 +1126,13 @@ int snprintf_float(T value, int precision, float_specs specs,
 template <typename T> T promote_float(T value) { return value; }
 inline double promote_float(float value) { return value; }
 
-template <typename Handler>
-FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler&& handler) {
-  switch (spec) {
+template <typename Spec, typename Handler>
+FMT_CONSTEXPR void handle_int_type_spec(const Spec& specs, Handler&& handler) {
+  if (specs.thousands != '\0') {
+    handler.on_num();
+    return;
+  }
+  switch (specs.type) {
   case 0:
   case 'd':
     handler.on_dec();
@@ -1143,17 +1149,24 @@ FMT_CONSTEXPR void handle_int_type_spec(char spec, Handler&& handler) {
     handler.on_oct();
     break;
   case 'n':
+  case 'l':
+  case 'L':
     handler.on_num();
     break;
   default:
-    handler.on_error();
+    handler.on_error("Invalid type specifier \"" + std::string(1, specs.type) + "\" for formatting a value of type int");
   }
 }
 
 template <typename ErrorHandler = error_handler, typename Char>
 FMT_CONSTEXPR float_specs parse_float_type_spec(
     const basic_format_specs<Char>& specs, ErrorHandler&& eh = {}) {
+
   auto result = float_specs();
+    if (specs.thousands != '\0') {
+      eh.on_error("Thousand separators are not supported for floating point numbers");
+      return result;
+    }
   result.trailing_zeros = specs.alt;
   switch (specs.type) {
   case 0:
@@ -1193,10 +1206,12 @@ FMT_CONSTEXPR float_specs parse_float_type_spec(
     result.format = float_format::hex;
     break;
   case 'n':
+  case 'l':
+  case 'L':
     result.locale = true;
     break;
   default:
-    eh.on_error("invalid type specifier");
+    eh.on_error("Invalid type specifier \"" + std::string(1, specs.type) + "\" for formatting a value of type float");
     break;
   }
   return result;
@@ -1219,17 +1234,17 @@ FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler&& handler) {
   else if (spec == 'p')
     handler.on_pointer();
   else
-    handler.on_error("invalid type specifier");
+    handler.on_error("Invalid type specifier \"" + std::string(1, spec) + "\" for formatting a value of type string");
 }
 
 template <typename Char, typename ErrorHandler>
 FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler&& eh) {
-  if (spec != 0 && spec != 's') eh.on_error("invalid type specifier");
+  if (spec != 0 && spec != 's') eh.on_error("Invalid type specifier \"" + std::string(1, spec) + "\" for formatting a value of type string");
 }
 
 template <typename Char, typename ErrorHandler>
 FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler&& eh) {
-  if (spec != 0 && spec != 'p') eh.on_error("invalid type specifier");
+  if (spec != 0 && spec != 'p') eh.on_error("Invalid type specifier \"" + std::string(1, spec) + "\" for formatting a value of type pointer");
 }
 
 template <typename ErrorHandler> class int_type_checker : private ErrorHandler {
@@ -1242,8 +1257,8 @@ template <typename ErrorHandler> class int_type_checker : private ErrorHandler {
   FMT_CONSTEXPR void on_oct() {}
   FMT_CONSTEXPR void on_num() {}
 
-  FMT_CONSTEXPR void on_error() {
-    ErrorHandler::on_error("invalid type specifier");
+  FMT_CONSTEXPR void on_error(std::string error) {
+    ErrorHandler::on_error(error);
   }
 };
 
@@ -1500,7 +1515,7 @@ template <typename Range> class basic_writer {
     void on_num() {
       std::string groups = grouping<char_type>(writer.locale_);
       if (groups.empty()) return on_dec();
-      auto sep = thousands_sep<char_type>(writer.locale_);
+      auto sep = specs.thousands;
       if (!sep) return on_dec();
       int num_digits = count_digits(abs_value);
       int size = num_digits;
@@ -1514,11 +1529,11 @@ template <typename Range> class basic_writer {
       if (group == groups.cend())
         size += sep_size * ((num_digits - 1) / groups.back());
       writer.write_int(size, get_prefix(), specs,
-                       num_writer{abs_value, size, groups, sep});
+                       num_writer{abs_value, size, groups, static_cast<char_type>(sep)});
     }
 
-    FMT_NORETURN void on_error() {
-      FMT_THROW(duckdb::Exception("invalid type specifier"));
+    FMT_NORETURN void on_error(std::string error) {
+      FMT_THROW(duckdb::Exception(error));
     }
   };
 
@@ -1597,7 +1612,7 @@ template <typename Range> class basic_writer {
 
   template <typename T, typename Spec>
   void write_int(T value, const Spec& spec) {
-    handle_int_type_spec(spec.type, int_writer<T, Spec>(*this, value, spec));
+    handle_int_type_spec(spec, int_writer<T, Spec>(*this, value, spec));
   }
 
   template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
@@ -1958,6 +1973,10 @@ template <typename Char> class specs_setter {
   FMT_CONSTEXPR void on_plus() { specs_.sign = sign::plus; }
   FMT_CONSTEXPR void on_minus() { specs_.sign = sign::minus; }
   FMT_CONSTEXPR void on_space() { specs_.sign = sign::space; }
+  FMT_CONSTEXPR void on_comma() { specs_.thousands = ','; }
+  FMT_CONSTEXPR void on_underscore() { specs_.thousands = '_'; }
+  FMT_CONSTEXPR void on_single_quote() { specs_.thousands = '\''; }
+  FMT_CONSTEXPR void on_thousands(char sep) { specs_.thousands = sep; }
   FMT_CONSTEXPR void on_hash() { specs_.alt = true; }
 
   FMT_CONSTEXPR void on_zero() {
@@ -2066,7 +2085,7 @@ struct auto_id {};
 template <typename Context>
 FMT_CONSTEXPR typename Context::format_arg get_arg(Context& ctx, int id) {
   auto arg = ctx.arg(id);
-  if (!arg) ctx.on_error("argument index out of range");
+  if (!arg) ctx.on_error("Argument index \"" + std::to_string(id) + "\" out of range");
   return arg;
 }
 
@@ -2092,7 +2111,7 @@ class specs_handler : public specs_setter<typename Context::char_type> {
         get_arg(arg_id), context_.error_handler());
   }
 
-  void on_error(const char* message) { context_.on_error(message); }
+  void on_error(std::string message) { context_.on_error(message); }
 
  private:
   // This is only needed for compatibility with gcc 4.4.
@@ -2176,7 +2195,7 @@ class dynamic_specs_handler
     specs_.precision_ref = make_arg_ref(arg_id);
   }
 
-  FMT_CONSTEXPR void on_error(const char* message) {
+  FMT_CONSTEXPR void on_error(std::string message) {
     context_.on_error(message);
   }
 
@@ -2242,7 +2261,7 @@ template <typename SpecHandler, typename Char> struct width_adapter {
     handler.on_dynamic_width(id);
   }
 
-  FMT_CONSTEXPR void on_error(const char* message) {
+  FMT_CONSTEXPR void on_error(std::string message) {
     handler.on_error(message);
   }
 
@@ -2259,7 +2278,7 @@ template <typename SpecHandler, typename Char> struct precision_adapter {
     handler.on_dynamic_precision(id);
   }
 
-  FMT_CONSTEXPR void on_error(const char* message) {
+  FMT_CONSTEXPR void on_error(std::string message) {
     handler.on_error(message);
   }
 
@@ -2370,6 +2389,24 @@ FMT_CONSTEXPR const Char* parse_format_specs(const Char* begin, const Char* end,
     handler.on_space();
     ++begin;
     break;
+  case ',':
+    handler.on_comma();
+    ++begin;
+    break;
+  case '_':
+    handler.on_underscore();
+    ++begin;
+    break;
+  case '\'':
+    handler.on_single_quote();
+    ++begin;
+    break;
+  case 't':
+    ++begin;
+    if (begin == end) return begin;
+    handler.on_thousands(*begin);
+    ++begin;
+    break;
   }
   if (begin == end) return begin;
 
@@ -2420,7 +2457,7 @@ template <typename Handler, typename Char> struct id_adapter {
   FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
     handler.on_arg_id(id);
   }
-  FMT_CONSTEXPR void on_error(const char* message) {
+  FMT_CONSTEXPR void on_error(std::string message) {
     handler.on_error(message);
   }
   Handler& handler;
@@ -2524,7 +2561,7 @@ class format_string_checker {
     return arg_id_ < num_args ? parse_funcs_[arg_id_](context_) : begin;
   }
 
-  FMT_CONSTEXPR void on_error(const char* message) {
+  FMT_CONSTEXPR void on_error(std::string message) {
     context_.on_error(message);
   }
 
@@ -2889,7 +2926,7 @@ typename basic_format_context<Range, Char>::format_arg
 basic_format_context<Range, Char>::arg(basic_string_view<char_type> name) {
   map_.init(args_);
   format_arg arg = map_.find(name);
-  if (arg.type() == internal::none_type) this->on_error("argument not found");
+  if (arg.type() == internal::none_type) this->on_error("Argument with name \"" + name.to_string() + "\" not found, did you mean to use it as a format specifier (e.g. {:" + name.to_string() + "}");
   return arg;
 }
 

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

@@ -363,7 +363,7 @@ template <typename OutputIt, typename Char> class basic_printf_context {
 
   basic_format_parse_context<Char>& parse_context() { return parse_ctx_; }
 
-  FMT_CONSTEXPR void on_error(const char* message) {
+  FMT_CONSTEXPR void on_error(std::string message) {
     parse_ctx_.on_error(message);
   }
 
@@ -393,6 +393,15 @@ void basic_printf_context<OutputIt, Char>::parse_flags(format_specs& specs,
     case '#':
       specs.alt = true;
       break;
+    case ',':
+      specs.thousands = ',';
+      break;
+    case '\'':
+      specs.thousands = '\'';
+      break;
+    case '_':
+      specs.thousands = '_';
+      break;
     default:
       return;
     }
@@ -472,6 +481,7 @@ OutputIt basic_printf_context<OutputIt, Char>::format() {
     if (arg_index == 0) on_error("argument index out of range");
 
     // Parse precision.
+	bool empty_precision = false;
     if (it != end && *it == '.') {
       ++it;
       c = it != end ? *it : 0;
@@ -484,6 +494,7 @@ OutputIt basic_printf_context<OutputIt, Char>::format() {
             static_cast<int>(visit_format_arg(internal::printf_precision_handler(), get_arg()));
       } else {
         specs.precision = 0;
+		empty_precision = true;
       }
     }
 
@@ -554,6 +565,9 @@ OutputIt basic_printf_context<OutputIt, Char>::format() {
         break;
       }
     }
+	if (specs.type == 'd' && empty_precision) {
+		specs.thousands = '.';
+	}
 
     start = it;
 

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

@@ -1171,6 +1171,7 @@ typedef struct PGPivot {
 	PGList *pivot_columns;  /* The column names to pivot on */
 	PGList *unpivot_columns;/* The column names to unpivot */
 	PGList *pivot_value;    /* The set of pivot values */
+	PGNode *subquery;       /* Subquery to fetch valid pivot values (if any) */
 	char *pivot_enum;       /* The enum to fetch the unique values from */
 } PGPivot;