duckdb 0.7.2-dev2820.0 → 0.7.2-dev2867.0

package/src/duckdb/src/parser/transform/statement/transform_pivot_stmt.cpp

@@ -18,33 +18,45 @@
 
 namespace duckdb {
 
-void Transformer::AddPivotEntry(string enum_name, unique_ptr<SelectNode> base, unique_ptr<ParsedExpression> column) {
+void Transformer::AddPivotEntry(string enum_name, unique_ptr<SelectNode> base, unique_ptr<ParsedExpression> column,
+                                unique_ptr<QueryNode> subquery) {
 	if (parent) {
-		parent->AddPivotEntry(std::move(enum_name), std::move(base), std::move(column));
+		parent->AddPivotEntry(std::move(enum_name), std::move(base), std::move(column), std::move(subquery));
 		return;
 	}
 	auto result = make_uniq<CreatePivotEntry>();
 	result->enum_name = std::move(enum_name);
 	result->base = std::move(base);
 	result->column = std::move(column);
+	result->subquery = std::move(subquery);
 
 	pivot_entries.push_back(std::move(result));
 }
 
 bool Transformer::HasPivotEntries() {
-	if (parent) {
-		return parent->HasPivotEntries();
-	}
-	return !pivot_entries.empty();
+	return !GetPivotEntries().empty();
 }
 
 idx_t Transformer::PivotEntryCount() {
+	return GetPivotEntries().size();
+}
+
+vector<unique_ptr<Transformer::CreatePivotEntry>> &Transformer::GetPivotEntries() {
 	if (parent) {
-		return parent->PivotEntryCount();
+		return parent->GetPivotEntries();
 	}
-	return pivot_entries.size();
+	return pivot_entries;
 }
 
+void Transformer::PivotEntryCheck(const string &type) {
+	auto &entries = GetPivotEntries();
+	if (!entries.empty()) {
+		throw ParserException(
+		    "PIVOT statements with pivot elements extracted from the data cannot be used in %ss.\nIn order to use "
+		    "PIVOT in a %s the PIVOT values must be manually specified, e.g.:\nPIVOT ... ON %s IN (val1, val2, ...)",
+		    type, type, entries[0]->column->ToString());
+	}
+}
 unique_ptr<SQLStatement> Transformer::GenerateCreateEnumStmt(unique_ptr<CreatePivotEntry> entry) {
 	auto result = make_uniq<CreateStatement>();
 	auto info = make_uniq<CreateTypeInfo>();
@@ -57,23 +69,30 @@ unique_ptr<SQLStatement> Transformer::GenerateCreateEnumStmt(unique_ptr<CreatePi
 	info->on_conflict = OnCreateConflict::REPLACE_ON_CONFLICT;
 
 	// generate the query that will result in the enum creation
-	auto select_node = std::move(entry->base);
-	auto columnref = entry->column->Copy();
-	auto cast = make_uniq<CastExpression>(LogicalType::VARCHAR, std::move(columnref));
-	select_node->select_list.push_back(std::move(cast));
-
-	auto is_not_null = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, std::move(entry->column));
-	select_node->where_clause = std::move(is_not_null);
-
-	// order by the column
-	select_node->modifiers.push_back(make_uniq<DistinctModifier>());
-	auto modifier = make_uniq<OrderModifier>();
-	modifier->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT,
-	                              make_uniq<ConstantExpression>(Value::INTEGER(1)));
-	select_node->modifiers.push_back(std::move(modifier));
+	unique_ptr<QueryNode> subselect;
+	if (!entry->subquery) {
+		auto select_node = std::move(entry->base);
+		auto columnref = entry->column->Copy();
+		auto cast = make_uniq<CastExpression>(LogicalType::VARCHAR, std::move(columnref));
+		select_node->select_list.push_back(std::move(cast));
+
+		auto is_not_null =
+		    make_uniq<OperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, std::move(entry->column));
+		select_node->where_clause = std::move(is_not_null);
+
+		// order by the column
+		select_node->modifiers.push_back(make_uniq<DistinctModifier>());
+		auto modifier = make_uniq<OrderModifier>();
+		modifier->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT,
+		                              make_uniq<ConstantExpression>(Value::INTEGER(1)));
+		select_node->modifiers.push_back(std::move(modifier));
+		subselect = std::move(select_node);
+	} else {
+		subselect = std::move(entry->subquery);
+	}
 
 	auto select = make_uniq<SelectStatement>();
-	select->node = std::move(select_node);
+	select->node = std::move(subselect);
 	info->query = std::move(select);
 	info->type = LogicalType::INVALID;
 
@@ -150,7 +169,7 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 		auto new_select = make_uniq<SelectNode>();
 		ExtractCTEsRecursive(new_select->cte_map);
 		new_select->from_table = source->Copy();
-		AddPivotEntry(enum_name, std::move(new_select), col.pivot_expressions[0]->Copy());
+		AddPivotEntry(enum_name, std::move(new_select), col.pivot_expressions[0]->Copy(), std::move(col.subquery));
 		col.pivot_enum = enum_name;
 	}
 

package/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp

@@ -59,6 +59,9 @@ PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot *pivot)
 			col.entries.push_back(std::move(entry));
 		}
 	}
+	if (pivot->subquery) {
+		col.subquery = TransformSelectNode(reinterpret_cast<duckdb_libpgquery::PGSelectStmt *>(pivot->subquery));
+	}
 	if (pivot->pivot_enum) {
 		col.pivot_enum = pivot->pivot_enum;
 	}

package/src/duckdb/src/planner/binder/statement/bind_create.cpp

@@ -8,6 +8,8 @@
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/expression/subquery_expression.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
@@ -24,6 +26,7 @@
 #include "duckdb/planner/operator/logical_create_table.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/operator/logical_distinct.hpp"
+#include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/planner/tableref/bound_basetableref.hpp"
@@ -605,41 +608,27 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	}
 	case CatalogType::TYPE_ENTRY: {
 		auto &schema = BindCreateSchema(*stmt.info);
-		auto &create_type_info = (CreateTypeInfo &)(*stmt.info);
+		auto &create_type_info = stmt.info->Cast<CreateTypeInfo>();
 		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_TYPE, std::move(stmt.info), &schema);
 		if (create_type_info.query) {
 			// CREATE TYPE mood AS ENUM (SELECT 'happy')
-			auto &select_stmt = create_type_info.query->Cast<SelectStatement>();
-			auto &query_node = *select_stmt.node;
-
-			// We always add distinct modifier implicitly
-			bool need_to_add = true;
-			if (!query_node.modifiers.empty()) {
-				if (query_node.modifiers[0]->type == ResultModifierType::DISTINCT_MODIFIER) {
-					// There are cases where the same column is grouped repeatedly
-					// CREATE TYPE mood AS ENUM (SELECT DISTINCT ON(x) x FROM test);
-					// When we push into a constant expression
-					// => CREATE TYPE mood AS ENUM (SELECT DISTINCT ON(x, x) x FROM test);
-					auto &distinct_modifier = (DistinctModifier &)*query_node.modifiers[0];
-					if (distinct_modifier.distinct_on_targets.empty()) {
-						need_to_add = false;
-					}
-				}
-			}
-
-			// Add distinct modifier
-			if (need_to_add) {
-				auto distinct_modifier = make_uniq<DistinctModifier>();
-				query_node.modifiers.emplace(query_node.modifiers.begin(), std::move(distinct_modifier));
-			}
-
 			auto query_obj = Bind(*create_type_info.query);
 			auto query = std::move(query_obj.plan);
 
 			auto &sql_types = query_obj.types;
-			if (sql_types.size() != 1 || sql_types[0].id() != LogicalType::VARCHAR) {
+			if (sql_types.size() != 1) {
 				// add cast expression?
-				throw BinderException("The query must return one varchar column");
+				throw BinderException("The query must return a single column");
+			}
+			if (sql_types[0].id() != LogicalType::VARCHAR) {
+				// push a projection casting to varchar
+				vector<unique_ptr<Expression>> select_list;
+				auto ref = make_uniq<BoundColumnRefExpression>(sql_types[0], query->GetColumnBindings()[0]);
+				auto cast_expr = BoundCastExpression::AddCastToType(context, std::move(ref), LogicalType::VARCHAR);
+				select_list.push_back(std::move(cast_expr));
+				auto proj = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(select_list));
+				proj->AddChild(std::move(query));
+				query = std::move(proj);
 			}
 
 			result.plan->AddChild(std::move(query));
@@ -660,7 +649,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	}
 	case CatalogType::DATABASE_ENTRY: {
 		// not supported in DuckDB yet but allow extensions to intercept and implement this functionality
-		auto &base = (CreateDatabaseInfo &)*stmt.info;
+		auto &base = stmt.info->Cast<CreateDatabaseInfo>();
 		string database_name = base.name;
 		string source_path = base.path;
 

package/src/duckdb/third_party/fmt/format.cc

@@ -128,11 +128,6 @@ int (*instantiate_format_float)(double, int, internal::float_specs,
                                 internal::buffer<char>&) =
     internal::format_float;
 
-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
-template FMT_API internal::locale_ref::locale_ref(const std::locale& loc);
-template FMT_API std::locale internal::locale_ref::get<std::locale>() const;
-#endif
-
 // Explicit instantiations for char.
 
 template FMT_API std::string internal::grouping_impl<char>(locale_ref);

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

@@ -62,15 +62,9 @@
 
 // Check if relaxed C++14 constexpr is supported.
 // GCC doesn't allow throw in constexpr until version 6 (bug 67371).
-#ifndef FMT_USE_CONSTEXPR
-#  define FMT_USE_CONSTEXPR                                           \
-    (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || \
-     (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) &&           \
-        !FMT_NVCC
-#endif
 #if FMT_USE_CONSTEXPR
-#  define FMT_CONSTEXPR constexpr
-#  define FMT_CONSTEXPR_DECL constexpr
+#  define FMT_CONSTEXPR inline
+#  define FMT_CONSTEXPR_DECL
 #else
 #  define FMT_CONSTEXPR inline
 #  define FMT_CONSTEXPR_DECL
@@ -323,6 +317,10 @@ template <typename Char> class basic_string_view {
     size_ -= n;
   }
 
+  std::string to_string() {
+	  return std::string((char *) data(), size());
+  }
+
   // Lexicographically compare this string reference to other.
   int compare(basic_string_view other) const {
     size_t str_size = size_ < other.size_ ? size_ : other.size_;
@@ -416,7 +414,7 @@ template <typename S>
 struct is_compile_string : std::is_base_of<compile_string, S> {};
 
 template <typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
-constexpr basic_string_view<typename S::char_type> to_string_view(const S& s) {
+FMT_CONSTEXPR basic_string_view<typename S::char_type> to_string_view(const S& s) {
   return s;
 }
 
@@ -442,7 +440,7 @@ struct error_handler {
   FMT_CONSTEXPR error_handler(const error_handler&) = default;
 
   // This function is intentionally not constexpr to give a compile-time error.
-  FMT_NORETURN FMT_API void on_error(const char* message);
+  FMT_NORETURN FMT_API void on_error(std::string message);
 };
 }  // namespace internal
 
@@ -520,7 +518,7 @@ class basic_format_parse_context : private ErrorHandler {
 
   FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) {}
 
-  FMT_CONSTEXPR void on_error(const char* message) {
+  FMT_CONSTEXPR void on_error(std::string message) {
     ErrorHandler::on_error(message);
   }
 
@@ -1158,7 +1156,7 @@ template <typename OutputIt, typename Char> class basic_format_context {
   format_arg arg(basic_string_view<char_type> name);
 
   internal::error_handler error_handler() { return {}; }
-  void on_error(const char* message) { error_handler().on_error(message); }
+  void on_error(std::string message) { error_handler().on_error(message); }
 
   // Returns an iterator to the beginning of the output range.
   iterator out() { return out_; }

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

@@ -17,10 +17,6 @@
 #include <cstdarg>
 #include <cstring>  // for std::memmove
 #include <cwchar>
-#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
-#  include <locale>
-#endif
-
 #if FMT_EXCEPTIONS
 #  define FMT_TRY try
 #  define FMT_CATCH(x) catch (x)
@@ -162,45 +158,18 @@ FMT_FUNC void report_error(format_func func, int error_code,
 }
 }  // namespace internal
 
-#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
-namespace internal {
-
-template <typename Locale>
-locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
-  static_assert(std::is_same<Locale, std::locale>::value, "");
-}
-
-template <typename Locale> Locale locale_ref::get() const {
-  static_assert(std::is_same<Locale, std::locale>::value, "");
-  return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
-}
-
-template <typename Char> FMT_FUNC std::string grouping_impl(locale_ref loc) {
-  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>()).grouping();
-}
-template <typename Char> FMT_FUNC Char thousands_sep_impl(locale_ref loc) {
-  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
-      .thousands_sep();
-}
-template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
-  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
-      .decimal_point();
-}
-}  // namespace internal
-#else
 template <typename Char>
 FMT_FUNC std::string internal::grouping_impl(locale_ref) {
   return "\03";
 }
 template <typename Char>
 FMT_FUNC Char internal::thousands_sep_impl(locale_ref) {
-  return FMT_STATIC_THOUSANDS_SEPARATOR;
+  return ',';
 }
 template <typename Char>
 FMT_FUNC Char internal::decimal_point_impl(locale_ref) {
   return '.';
 }
-#endif
 
 namespace internal {
 
@@ -1203,7 +1172,7 @@ template <> struct formatter<internal::bigint> {
   }
 };
 
-FMT_FUNC void internal::error_handler::on_error(const char* message) {
+FMT_FUNC void internal::error_handler::on_error(std::string message) {
   FMT_THROW(duckdb::Exception(message));
 }
 

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;