duckdb 0.7.2-dev0.0 → 0.7.2-dev1034.0

package/src/duckdb/src/storage/table/scan_state.cpp

@@ -2,6 +2,9 @@
 #include "duckdb/storage/table/row_group.hpp"
 #include "duckdb/storage/table/column_segment.hpp"
 #include "duckdb/transaction/duck_transaction.hpp"
+#include "duckdb/storage/table/column_data.hpp"
+#include "duckdb/storage/table/row_group_collection.hpp"
+#include "duckdb/storage/table/row_group_segment_tree.hpp"
 
 namespace duckdb {
 
@@ -35,7 +38,7 @@ void ColumnScanState::NextInternal(idx_t count) {
 	}
 	row_index += count;
 	while (row_index >= current->start + current->count) {
-		current = (ColumnSegment *)current->Next();
+		current = segment_tree->GetNextSegment(current);
 		initialized = false;
 		segment_checked = false;
 		if (!current) {
@@ -92,7 +95,7 @@ bool CollectionScanState::Scan(DuckTransaction &transaction, DataChunk &result)
 			return true;
 		} else {
 			do {
-				current_row_group = row_group_state.row_group = (RowGroup *)current_row_group->Next();
+				current_row_group = row_group_state.row_group = row_groups->GetNextSegment(current_row_group);
 				if (current_row_group) {
 					bool scan_row_group = current_row_group->InitializeScan(row_group_state);
 					if (scan_row_group) {
@@ -106,6 +109,22 @@ bool CollectionScanState::Scan(DuckTransaction &transaction, DataChunk &result)
 	return false;
 }
 
+bool CollectionScanState::ScanCommitted(DataChunk &result, SegmentLock &l, TableScanType type) {
+	auto current_row_group = row_group_state.row_group;
+	while (current_row_group) {
+		current_row_group->ScanCommitted(row_group_state, result, type);
+		if (result.size() > 0) {
+			return true;
+		} else {
+			current_row_group = row_group_state.row_group = row_groups->GetNextSegment(l, current_row_group);
+			if (current_row_group) {
+				current_row_group->InitializeScan(row_group_state);
+			}
+		}
+	}
+	return false;
+}
+
 bool CollectionScanState::ScanCommitted(DataChunk &result, TableScanType type) {
 	auto current_row_group = row_group_state.row_group;
 	while (current_row_group) {
@@ -113,7 +132,7 @@ bool CollectionScanState::ScanCommitted(DataChunk &result, TableScanType type) {
 		if (result.size() > 0) {
 			return true;
 		} else {
-			current_row_group = row_group_state.row_group = (RowGroup *)current_row_group->Next();
+			current_row_group = row_group_state.row_group = row_groups->GetNextSegment(current_row_group);
 			if (current_row_group) {
 				current_row_group->InitializeScan(row_group_state);
 			}

package/src/duckdb/src/storage/table/standard_column_data.cpp

@@ -5,6 +5,7 @@
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/planner/table_filter.hpp"
 #include "duckdb/transaction/transaction.hpp"
+#include "duckdb/storage/table/column_checkpoint_state.hpp"
 
 namespace duckdb {
 
@@ -24,7 +25,7 @@ bool StandardColumnData::CheckZonemap(ColumnScanState &state, TableFilter &filte
 			return true;
 		}
 		state.segment_checked = true;
-		auto prune_result = filter.CheckStatistics(*state.current->stats.statistics);
+		auto prune_result = filter.CheckStatistics(state.current->stats.statistics);
 		if (prune_result != FilterPropagateResult::FILTER_ALWAYS_FALSE) {
 			return true;
 		}
@@ -91,8 +92,7 @@ void StandardColumnData::InitializeAppend(ColumnAppendState &state) {
 void StandardColumnData::AppendData(BaseStatistics &stats, ColumnAppendState &state, UnifiedVectorFormat &vdata,
                                     idx_t count) {
 	ColumnData::AppendData(stats, state, vdata, count);
-
-	validity.AppendData(*stats.validity_stats, state.child_appends[0], vdata, count);
+	validity.AppendData(stats, state.child_appends[0], vdata, count);
 }
 
 void StandardColumnData::RevertAppend(row_t start_row) {
@@ -136,9 +136,11 @@ unique_ptr<BaseStatistics> StandardColumnData::GetUpdateStatistics() {
 		return nullptr;
 	}
 	if (!stats) {
-		stats = BaseStatistics::CreateEmpty(type, StatisticsType::GLOBAL_STATS);
+		stats = BaseStatistics::CreateEmpty(type).ToUnique();
+	}
+	if (validity_stats) {
+		stats->Merge(*validity_stats);
 	}
-	stats->validity_stats = std::move(validity_stats);
 	return stats;
 }
 
@@ -169,7 +171,6 @@ struct StandardColumnCheckpointState : public ColumnCheckpointState {
 public:
 	unique_ptr<BaseStatistics> GetStatistics() override {
 		D_ASSERT(global_stats);
-		global_stats->validity_stats = validity_state->GetStatistics();
 		return std::move(global_stats);
 	}
 

package/src/duckdb/src/storage/table/struct_column_data.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/storage/table/struct_column_data.hpp"
-#include "duckdb/storage/statistics/struct_statistics.hpp"
+#include "duckdb/storage/statistics/struct_stats.hpp"
 #include "duckdb/transaction/transaction.hpp"
+#include "duckdb/storage/table/column_checkpoint_state.hpp"
 
 namespace duckdb {
 
@@ -127,12 +128,12 @@ void StructColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, V
 	vector.Flatten(count);
 
 	// append the null values
-	validity.Append(*stats.validity_stats, state.child_appends[0], vector, count);
+	validity.Append(stats, state.child_appends[0], vector, count);
 
-	auto &struct_stats = (StructStatistics &)stats;
 	auto &child_entries = StructVector::GetEntries(vector);
 	for (idx_t i = 0; i < child_entries.size(); i++) {
-		sub_columns[i]->Append(*struct_stats.child_stats[i], state.child_appends[i + 1], *child_entries[i], count);
+		sub_columns[i]->Append(StructStats::GetChildStats(stats, i), state.child_appends[i + 1], *child_entries[i],
+		                       count);
 	}
 }
 
@@ -190,16 +191,18 @@ void StructColumnData::UpdateColumn(TransactionData transaction, const vector<co
 
 unique_ptr<BaseStatistics> StructColumnData::GetUpdateStatistics() {
 	// check if any child column has updates
-	auto stats = BaseStatistics::CreateEmpty(type, StatisticsType::GLOBAL_STATS);
-	auto &struct_stats = (StructStatistics &)*stats;
-	stats->validity_stats = validity.GetUpdateStatistics();
+	auto stats = BaseStatistics::CreateEmpty(type);
+	auto validity_stats = validity.GetUpdateStatistics();
+	if (validity_stats) {
+		stats.Merge(*validity_stats);
+	}
 	for (idx_t i = 0; i < sub_columns.size(); i++) {
 		auto child_stats = sub_columns[i]->GetUpdateStatistics();
 		if (child_stats) {
-			struct_stats.child_stats[i] = std::move(child_stats);
+			StructStats::SetChildStats(stats, i, std::move(child_stats));
 		}
 	}
-	return stats;
+	return stats.ToUnique();
 }
 
 void StructColumnData::FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
@@ -230,7 +233,7 @@ struct StructColumnCheckpointState : public ColumnCheckpointState {
 	StructColumnCheckpointState(RowGroup &row_group, ColumnData &column_data,
 	                            PartialBlockManager &partial_block_manager)
 	    : ColumnCheckpointState(row_group, column_data, partial_block_manager) {
-		global_stats = make_unique<StructStatistics>(column_data.type);
+		global_stats = StructStats::CreateEmpty(column_data.type).ToUnique();
 	}
 
 	unique_ptr<ColumnCheckpointState> validity_state;
@@ -238,14 +241,11 @@ struct StructColumnCheckpointState : public ColumnCheckpointState {
 
 public:
 	unique_ptr<BaseStatistics> GetStatistics() override {
-		auto stats = make_unique<StructStatistics>(column_data.type);
-		D_ASSERT(stats->child_stats.size() == child_states.size());
-		stats->validity_stats = validity_state->GetStatistics();
+		auto stats = StructStats::CreateEmpty(column_data.type);
 		for (idx_t i = 0; i < child_states.size(); i++) {
-			stats->child_stats[i] = child_states[i]->GetStatistics();
-			D_ASSERT(stats->child_stats[i]);
+			StructStats::SetChildStats(stats, i, child_states[i]->GetStatistics());
 		}
-		return std::move(stats);
+		return stats.ToUnique();
 	}
 
 	void WriteDataPointers(RowGroupWriter &writer) override {

package/src/duckdb/src/storage/table/table_statistics.cpp

@@ -6,10 +6,7 @@ namespace duckdb {
 void TableStatistics::Initialize(const vector<LogicalType> &types, PersistentTableData &data) {
 	D_ASSERT(Empty());
 
-	column_stats.reserve(data.column_stats.size());
-	for (auto &stats : data.column_stats) {
-		column_stats.push_back(make_shared<ColumnStatistics>(std::move(stats)));
-	}
+	column_stats = std::move(data.table_stats.column_stats);
 	if (column_stats.size() != types.size()) { // LCOV_EXCL_START
 		throw IOException("Table statistics column count is not aligned with table column count. Corrupt file?");
 	} // LCOV_EXCL_STOP
@@ -70,7 +67,7 @@ void TableStatistics::MergeStats(TableStatistics &other) {
 	auto l = GetLock();
 	D_ASSERT(column_stats.size() == other.column_stats.size());
 	for (idx_t i = 0; i < column_stats.size(); i++) {
-		column_stats[i]->stats->Merge(*other.column_stats[i]->stats);
+		column_stats[i]->Merge(*other.column_stats[i]);
 	}
 }
 
@@ -80,7 +77,7 @@ void TableStatistics::MergeStats(idx_t i, BaseStatistics &stats) {
 }
 
 void TableStatistics::MergeStats(TableStatisticsLock &lock, idx_t i, BaseStatistics &stats) {
-	column_stats[i]->stats->Merge(stats);
+	column_stats[i]->Statistics().Merge(stats);
 }
 
 ColumnStatistics &TableStatistics::GetStats(idx_t i) {
@@ -89,7 +86,30 @@ ColumnStatistics &TableStatistics::GetStats(idx_t i) {
 
 unique_ptr<BaseStatistics> TableStatistics::CopyStats(idx_t i) {
 	lock_guard<mutex> l(stats_lock);
-	return column_stats[i]->stats->Copy();
+	auto result = column_stats[i]->Statistics().Copy();
+	if (column_stats[i]->HasDistinctStats()) {
+		result.SetDistinctCount(column_stats[i]->DistinctStats().GetCount());
+	}
+	return result.ToUnique();
+}
+
+void TableStatistics::CopyStats(TableStatistics &other) {
+	for (auto &stats : column_stats) {
+		other.column_stats.push_back(stats->Copy());
+	}
+}
+
+void TableStatistics::Serialize(Serializer &serializer) {
+	for (auto &stats : column_stats) {
+		stats->Serialize(serializer);
+	}
+}
+
+void TableStatistics::Deserialize(Deserializer &source, ColumnList &columns) {
+	for (auto &col : columns.Physical()) {
+		auto stats = ColumnStatistics::Deserialize(source, col.GetType());
+		column_stats.push_back(std::move(stats));
+	}
 }
 
 unique_ptr<TableStatisticsLock> TableStatistics::GetLock() {

package/src/duckdb/src/storage/table/update_segment.cpp

@@ -1,9 +1,7 @@
 #include "duckdb/storage/table/update_segment.hpp"
 
 #include "duckdb/storage/statistics/distinct_statistics.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
-#include "duckdb/storage/statistics/validity_statistics.hpp"
+
 #include "duckdb/storage/table/column_data.hpp"
 #include "duckdb/transaction/duck_transaction.hpp"
 #include "duckdb/transaction/update_info.hpp"
@@ -40,7 +38,17 @@ UpdateSegment::UpdateSegment(UpdateSegment &other, ColumnData &owner)
     : column_data(owner), root(std::move(other.root)), stats(std::move(other.stats)), type_size(other.type_size) {
 
 	this->heap.Move(other.heap);
-
+	// update the segment links
+	if (root) {
+		for (idx_t i = 0; i < RowGroup::ROW_GROUP_VECTOR_COUNT; i++) {
+			if (!root->info[i]) {
+				continue;
+			}
+			for (auto info = root->info[i]->info.get(); info; info = info->next) {
+				info->segment = this;
+			}
+		}
+	}
 	initialize_update_function = other.initialize_update_function;
 	merge_update_function = other.merge_update_function;
 	fetch_update_function = other.fetch_update_function;
@@ -54,12 +62,6 @@ UpdateSegment::UpdateSegment(UpdateSegment &other, ColumnData &owner)
 UpdateSegment::~UpdateSegment() {
 }
 
-void UpdateSegment::ClearUpdates() {
-	stats.Reset();
-	root.reset();
-	heap.Destroy();
-}
-
 //===--------------------------------------------------------------------===//
 // Update Info Helpers
 //===--------------------------------------------------------------------===//
@@ -905,17 +907,17 @@ static UpdateSegment::merge_update_function_t GetMergeUpdateFunction(PhysicalTyp
 //===--------------------------------------------------------------------===//
 unique_ptr<BaseStatistics> UpdateSegment::GetStatistics() {
 	lock_guard<mutex> stats_guard(stats_lock);
-	return stats.statistics->Copy();
+	return stats.statistics.ToUnique();
 }
 
 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) {
+	auto &validity = stats.statistics;
+	if (!mask.AllValid() && !validity.CanHaveNull()) {
 		for (idx_t i = 0; i < count; i++) {
 			if (!mask.RowIsValid(i)) {
-				validity.has_null = true;
+				validity.SetHasNull();
 				break;
 			}
 		}
@@ -932,7 +934,7 @@ idx_t TemplatedUpdateNumericStatistics(UpdateSegment *segment, SegmentStatistics
 
 	if (mask.AllValid()) {
 		for (idx_t i = 0; i < count; i++) {
-			NumericStatistics::Update<T>(stats, update_data[i]);
+			NumericStats::Update<T>(stats.statistics, update_data[i]);
 		}
 		sel.Initialize(nullptr);
 		return count;
@@ -942,7 +944,7 @@ idx_t TemplatedUpdateNumericStatistics(UpdateSegment *segment, SegmentStatistics
 		for (idx_t i = 0; i < count; i++) {
 			if (mask.RowIsValid(i)) {
 				sel.set_index(not_null_count++, i);
-				NumericStatistics::Update<T>(stats, update_data[i]);
+				NumericStats::Update<T>(stats.statistics, update_data[i]);
 			}
 		}
 		return not_null_count;
@@ -955,7 +957,7 @@ idx_t UpdateStringStatistics(UpdateSegment *segment, SegmentStatistics &stats, V
 	auto &mask = FlatVector::Validity(update);
 	if (mask.AllValid()) {
 		for (idx_t i = 0; i < count; i++) {
-			((StringStatistics &)*stats.statistics).Update(update_data[i]);
+			StringStats::Update(stats.statistics, update_data[i]);
 			if (!update_data[i].IsInlined()) {
 				update_data[i] = segment->GetStringHeap().AddBlob(update_data[i]);
 			}
@@ -968,7 +970,7 @@ idx_t UpdateStringStatistics(UpdateSegment *segment, SegmentStatistics &stats, V
 		for (idx_t i = 0; i < count; i++) {
 			if (mask.RowIsValid(i)) {
 				sel.set_index(not_null_count++, i);
-				((StringStatistics &)*stats.statistics).Update(update_data[i]);
+				StringStats::Update(stats.statistics, update_data[i]);
 				if (!update_data[i].IsInlined()) {
 					update_data[i] = segment->GetStringHeap().AddBlob(update_data[i]);
 				}

package/src/duckdb/src/storage/wal_replay.cpp

@@ -24,17 +24,19 @@
 namespace duckdb {
 
 bool WriteAheadLog::Replay(AttachedDatabase &database, string &path) {
-	auto initial_reader = make_unique<BufferedFileReader>(FileSystem::Get(database), path.c_str());
+	Connection con(database.GetDatabase());
+	auto initial_reader = make_unique<BufferedFileReader>(FileSystem::Get(database), path.c_str(), con.context.get());
 	if (initial_reader->Finished()) {
 		// WAL is empty
 		return false;
 	}
-	Connection con(database.GetDatabase());
+
 	con.BeginTransaction();
 
 	// first deserialize the WAL to look for a checkpoint flag
 	// if there is a checkpoint flag, we might have already flushed the contents of the WAL to disk
 	ReplayState checkpoint_state(database, *con.context, *initial_reader);
+	initial_reader->catalog = &checkpoint_state.catalog;
 	checkpoint_state.deserialize_only = true;
 	try {
 		while (true) {
@@ -70,7 +72,8 @@ bool WriteAheadLog::Replay(AttachedDatabase &database, string &path) {
 	}
 
 	// we need to recover from the WAL: actually set up the replay state
-	BufferedFileReader reader(FileSystem::Get(database), path.c_str());
+	BufferedFileReader reader(FileSystem::Get(database), path.c_str(), con.context.get());
+	reader.catalog = &checkpoint_state.catalog;
 	ReplayState state(database, *con.context, reader);
 
 	// replay the WAL
@@ -192,6 +195,7 @@ void ReplayState::ReplayEntry(WALType entry_type) {
 // Replay Table
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateTable() {
+
 	auto info = TableCatalogEntry::Deserialize(source, context);
 	if (deserialize_only) {
 		return;
@@ -278,10 +282,9 @@ void ReplayState::ReplayDropSchema() {
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateType() {
 	auto info = TypeCatalogEntry::Deserialize(source);
-	if (deserialize_only) {
+	if (Catalog::TypeExists(context, info->catalog, info->schema, info->name)) {
 		return;
 	}
-
 	catalog.CreateType(context, info.get());
 }
 

package/src/duckdb/src/storage/write_ahead_log.cpp

@@ -281,12 +281,12 @@ void WriteAheadLog::WriteUpdate(DataChunk &chunk, const vector<column_t> &column
 //===--------------------------------------------------------------------===//
 // Write ALTER Statement
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteAlter(AlterInfo &info) {
+void WriteAheadLog::WriteAlter(data_ptr_t ptr, idx_t data_size) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::ALTER_INFO);
-	info.Serialize(*writer);
+	writer->WriteData(ptr, data_size);
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/transaction/commit_state.cpp

@@ -46,12 +46,16 @@ void CommitState::WriteCatalogEntry(CatalogEntry *entry, data_ptr_t dataptr) {
 			// ALTER TABLE statement, read the extra data after the entry
 			auto extra_data_size = Load<idx_t>(dataptr);
 			auto extra_data = (data_ptr_t)(dataptr + sizeof(idx_t));
-			// deserialize it
+
 			BufferedDeserializer source(extra_data, extra_data_size);
-			auto info = AlterInfo::Deserialize(source);
-			// write the alter table in the log
-			table_entry->CommitAlter(*info);
-			log->WriteAlter(*info);
+			string column_name = source.Read<string>();
+
+			if (!column_name.empty()) {
+				// write the alter table in the log
+				table_entry->CommitAlter(column_name);
+			}
+
+			log->WriteAlter(source.ptr, source.endptr - source.ptr);
 		} else {
 			// CREATE TABLE statement
 			log->WriteCreateTable((TableCatalogEntry *)parent);
@@ -71,9 +75,9 @@ void CommitState::WriteCatalogEntry(CatalogEntry *entry, data_ptr_t dataptr) {
 			auto extra_data = (data_ptr_t)(dataptr + sizeof(idx_t));
 			// deserialize it
 			BufferedDeserializer source(extra_data, extra_data_size);
-			auto info = AlterInfo::Deserialize(source);
+			string column_name = source.Read<string>();
 			// write the alter table in the log
-			log->WriteAlter(*info);
+			log->WriteAlter(source.ptr, source.endptr - source.ptr);
 		} else {
 			log->WriteCreateView((ViewCatalogEntry *)parent);
 		}

package/src/duckdb/src/verification/deserialized_statement_verifier.cpp

@@ -1,5 +1,4 @@
 #include "duckdb/verification/deserialized_statement_verifier.hpp"
-
 #include "duckdb/common/serializer/buffered_deserializer.hpp"
 
 namespace duckdb {

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

@@ -194,6 +194,9 @@ typedef enum PGNodeTag {
 	T_PGOnConflictExpr,
 	T_PGIntoClause,
 	T_PGLambdaFunction,
+	T_PGPivotExpr,
+	T_PGPivot,
+	T_PGPivotStmt,
 
 	/*
 	 * TAGS FOR EXPRESSION STATE NODES (execnodes.h)
@@ -678,6 +681,38 @@ typedef enum PGJoinType {
 	 */
 } PGJoinType;
 
+/*
+ * PGJoinRefType -
+ *    enums for the types of implied conditions
+ *
+ * PGJoinRefType specifies the semantics of interpreting the join conditions.
+ * These can be explicit (e.g., REGULAR) implied (e.g., NATURAL)
+ * or interpreted in a particular manner (e.g., ASOF)
+ *
+ * This is a generalisation of the old Postgres isNatural flag.
+ */
+typedef enum PGJoinRefType {
+	PG_JOIN_REGULAR, /* Join conditions are interpreted as is */
+	PG_JOIN_NATURAL, /* Join conditions are inferred from the column names */
+
+	/*
+	 * ASOF joins are joins with a single inequality predicate
+	 * and optional equality predicates.
+	 * The semantics are equivalent to the following window join:
+	 * 		times t
+	 * 	<jointype> JOIN (
+     *		SELECT *,
+     *			LEAD(begin, 1, 'infinity') OVER ([PARTITION BY key] ORDER BY begin) AS end)
+	 * 		FROM events) e
+	 *	ON t.ts >= e.begin AND t.ts < e.end [AND t.key = e.key]
+	 */
+	PG_JOIN_ASOF
+
+	/*
+	 * Positional join is a candidate to move here
+	 */
+} PGJoinRefType;
+
 /*
  * OUTER joins are those for which pushed-down quals must behave differently
  * from the join's own quals.  This is in fact everything except INNER and

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

@@ -307,7 +307,7 @@ typedef struct PGFuncCall {
 typedef struct PGAStar {
 	PGNodeTag type;
 	char *relation;       /* relation name (optional) */
-	char *regex;          /* optional: REGEX to select columns */
+	PGNode *expr;         /* optional: the expression (regex or list) to select columns */
 	PGList *except_list;  /* optional: EXCLUDE list */
 	PGList *replace_list; /* optional: REPLACE list */
 	bool columns;         /* whether or not this is a columns list */
@@ -1162,6 +1162,38 @@ typedef struct PGUpdateStmt {
 	PGWithClause *withClause; /* WITH clause */
 } PGUpdateStmt;
 
+/* ----------------------
+ *		Pivot Expression
+ * ----------------------
+ */
+typedef struct PGPivot {
+	PGNodeTag type;
+	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 */
+	char *pivot_enum;       /* The enum to fetch the unique values from */
+} PGPivot;
+
+typedef struct PGPivotExpr {
+	PGNodeTag type;
+	PGNode *source;      /* the source subtree */
+	PGList *aggrs;       /* The aggregations to pivot over (PIVOT only) */
+	PGList *unpivots;    /* The names to unpivot over (UNPIVOT only) */
+	PGList *pivots;      /* The set of pivot values */
+	PGList *groups;      /* The set of groups to pivot over (if any) */
+	PGAlias *alias;      /* table alias & optional column aliases */
+	bool include_nulls;  /* Whether or not to include NULL values (UNPIVOT only */
+} PGPivotExpr;
+
+typedef struct PGPivotStmt {
+	PGNodeTag type;
+	PGNode *source;      /* The source to pivot */
+	PGList *aggrs;       /* The aggregations to pivot over (PIVOT only) */
+	PGList *unpivots;    /* The names to unpivot over (UNPIVOT only) */
+	PGList *columns;     /* The set of columns to pivot over */
+	PGList *groups;      /* The set of groups to pivot over (if any) */
+} PGPivotStmt;
+
 /* ----------------------
  *		Select Statement
  *
@@ -1204,6 +1236,9 @@ typedef struct PGSelectStmt {
 	 */
 	PGList *valuesLists; /* untransformed list of expression lists */
 
+	/* When representing a pivot statement, all values are NULL besides the pivot field */
+	PGPivotStmt *pivot;       /* PIVOT statement */
+
 	/*
 	 * These fields are used in both "leaf" SelectStmts and upper-level
 	 * SelectStmts.
@@ -2107,5 +2142,4 @@ typedef struct PGUseStmt {
 } PGUseStmt;
 
 
-
 }

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

@@ -1324,7 +1324,7 @@ typedef struct PGRangeTblRef {
 /*----------
  * PGJoinExpr - for SQL JOIN expressions
  *
- * isNatural, usingClause, and quals are interdependent.  The user can write
+ * joinreftype, usingClause, and quals are interdependent.  The user can write
  * only one of NATURAL, USING(), or ON() (this is enforced by the grammar).
  * If he writes NATURAL then parse analysis generates the equivalent USING()
  * list, and from that fills in "quals" with the right equality comparisons.
@@ -1347,7 +1347,7 @@ typedef struct PGRangeTblRef {
 typedef struct PGJoinExpr {
 	PGNodeTag type;
 	PGJoinType jointype; /* type of join */
-	bool isNatural;      /* Natural join? Will need to shape table */
+	PGJoinRefType joinreftype; /* Regular/Natural/AsOf join? Will need to shape table */
 	PGNode *larg;        /* left subtree */
 	PGNode *rarg;        /* right subtree */
 	PGList *usingClause; /* USING clause, if any (list of String) */
@@ -1398,4 +1398,4 @@ typedef struct PGOnConflictExpr {
 	PGList *exclRelTlist;    /* tlist of the EXCLUDED pseudo relation */
 } PGOnConflictExpr;
 
-}
+}