duckdb 0.7.2-dev12.0 → 0.7.2-dev1244.0

package/src/duckdb/src/parser/tableref/pivotref.cpp

@@ -0,0 +1,373 @@
+#include "duckdb/parser/tableref/pivotref.hpp"
+
+#include "duckdb/common/limits.hpp"
+#include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// PivotColumn
+//===--------------------------------------------------------------------===//
+string PivotColumn::ToString() const {
+	string result;
+	if (!unpivot_names.empty()) {
+		D_ASSERT(pivot_expressions.empty());
+		// unpivot
+		if (unpivot_names.size() == 1) {
+			result += KeywordHelper::WriteOptionallyQuoted(unpivot_names[0]);
+		} else {
+			result += "(";
+			for (idx_t n = 0; n < unpivot_names.size(); n++) {
+				if (n > 0) {
+					result += ", ";
+				}
+				result += KeywordHelper::WriteOptionallyQuoted(unpivot_names[n]);
+			}
+			result += ")";
+		}
+	} else if (!pivot_expressions.empty()) {
+		// pivot
+		result += "(";
+		for (idx_t n = 0; n < pivot_expressions.size(); n++) {
+			if (n > 0) {
+				result += ", ";
+			}
+			result += pivot_expressions[n]->ToString();
+		}
+		result += ")";
+	}
+	result += " IN ";
+	if (pivot_enum.empty()) {
+		result += "(";
+		for (idx_t e = 0; e < entries.size(); e++) {
+			auto &entry = entries[e];
+			if (e > 0) {
+				result += ", ";
+			}
+			if (entry.star_expr) {
+				D_ASSERT(entry.values.empty());
+				result += entry.star_expr->ToString();
+			} else if (entry.values.size() == 1) {
+				result += entry.values[0].ToSQLString();
+			} else {
+				result += "(";
+				for (idx_t v = 0; v < entry.values.size(); v++) {
+					if (v > 0) {
+						result += ", ";
+					}
+					result += entry.values[v].ToSQLString();
+				}
+				result += ")";
+			}
+			if (!entry.alias.empty()) {
+				result += " AS " + KeywordHelper::WriteOptionallyQuoted(entry.alias);
+			}
+		}
+		result += ")";
+	} else {
+		result += KeywordHelper::WriteOptionallyQuoted(pivot_enum);
+	}
+	return result;
+}
+
+bool PivotColumnEntry::Equals(const PivotColumnEntry &other) const {
+	if (alias != other.alias) {
+		return false;
+	}
+	if (values.size() != other.values.size()) {
+		return false;
+	}
+	for (idx_t i = 0; i < values.size(); i++) {
+		if (!Value::NotDistinctFrom(values[i], other.values[i])) {
+			return false;
+		}
+	}
+	return true;
+}
+
+bool PivotColumn::Equals(const PivotColumn &other) const {
+	if (!ExpressionUtil::ListEquals(pivot_expressions, other.pivot_expressions)) {
+		return false;
+	}
+	if (other.unpivot_names != unpivot_names) {
+		return false;
+	}
+	if (other.pivot_enum != pivot_enum) {
+		return false;
+	}
+	if (other.entries.size() != entries.size()) {
+		return false;
+	}
+	for (idx_t i = 0; i < entries.size(); i++) {
+		if (!entries[i].Equals(other.entries[i])) {
+			return false;
+		}
+	}
+	return true;
+}
+
+PivotColumn PivotColumn::Copy() const {
+	PivotColumn result;
+	for (auto &expr : pivot_expressions) {
+		result.pivot_expressions.push_back(expr->Copy());
+	}
+	result.unpivot_names = unpivot_names;
+	for (auto &entry : entries) {
+		result.entries.push_back(entry.Copy());
+	}
+	result.pivot_enum = pivot_enum;
+	return result;
+}
+
+void PivotColumn::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteSerializableList(pivot_expressions);
+	writer.WriteList<string>(unpivot_names);
+	writer.WriteRegularSerializableList(entries);
+	writer.WriteString(pivot_enum);
+	writer.Finalize();
+}
+
+void PivotColumn::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("pivot_expressions", pivot_expressions);
+	serializer.WriteProperty("unpivot_names", unpivot_names);
+	serializer.WriteProperty("entries", entries);
+	serializer.WriteProperty("pivot_enum", pivot_enum);
+}
+
+PivotColumn PivotColumn::Deserialize(Deserializer &source) {
+	PivotColumn result;
+	FieldReader reader(source);
+	result.pivot_expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
+	result.unpivot_names = reader.ReadRequiredList<string>();
+	result.entries = reader.ReadRequiredSerializableList<PivotColumnEntry, PivotColumnEntry>();
+	result.pivot_enum = reader.ReadRequired<string>();
+	reader.Finalize();
+	return result;
+}
+
+PivotColumn PivotColumn::FormatDeserialize(FormatDeserializer &source) {
+	PivotColumn result;
+	source.ReadProperty("pivot_expressions", result.pivot_expressions);
+	source.ReadProperty("unpivot_names", result.unpivot_names);
+	source.ReadProperty("entries", result.entries);
+	source.ReadProperty("pivot_enum", result.pivot_enum);
+	return result;
+}
+
+//===--------------------------------------------------------------------===//
+// PivotColumnEntry
+//===--------------------------------------------------------------------===//
+PivotColumnEntry PivotColumnEntry::Copy() const {
+	PivotColumnEntry result;
+	result.values = values;
+	result.star_expr = star_expr ? star_expr->Copy() : nullptr;
+	result.alias = alias;
+	return result;
+}
+
+void PivotColumnEntry::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteRegularSerializableList(values);
+	writer.WriteOptional(star_expr);
+	writer.WriteString(alias);
+	writer.Finalize();
+}
+
+void PivotColumnEntry::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("values", values);
+	serializer.WriteOptionalProperty("star_expr", star_expr);
+	serializer.WriteProperty("alias", alias);
+}
+
+PivotColumnEntry PivotColumnEntry::Deserialize(Deserializer &source) {
+	PivotColumnEntry result;
+	FieldReader reader(source);
+	result.values = reader.ReadRequiredSerializableList<Value, Value>();
+	result.star_expr = reader.ReadOptional<ParsedExpression>(nullptr);
+	result.alias = reader.ReadRequired<string>();
+	reader.Finalize();
+	return result;
+}
+
+PivotColumnEntry PivotColumnEntry::FormatDeserialize(FormatDeserializer &source) {
+	PivotColumnEntry result;
+	source.ReadProperty("values", result.values);
+	source.ReadOptionalProperty("star_expr", result.star_expr);
+	source.ReadProperty("alias", result.alias);
+	return result;
+}
+
+//===--------------------------------------------------------------------===//
+// PivotRef
+//===--------------------------------------------------------------------===//
+string PivotRef::ToString() const {
+	string result;
+	result = source->ToString();
+	if (!aggregates.empty()) {
+		// pivot
+		result += " PIVOT (";
+		for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
+			if (aggr_idx > 0) {
+				result += ", ";
+			}
+			result += aggregates[aggr_idx]->ToString();
+			if (!aggregates[aggr_idx]->alias.empty()) {
+				result += " AS " + KeywordHelper::WriteOptionallyQuoted(aggregates[aggr_idx]->alias);
+			}
+		}
+	} else {
+		// unpivot
+		result += " UNPIVOT ";
+		if (include_nulls) {
+			result += "INCLUDE NULLS ";
+		}
+		result += "(";
+		if (unpivot_names.size() == 1) {
+			result += KeywordHelper::WriteOptionallyQuoted(unpivot_names[0]);
+		} else {
+			result += "(";
+			for (idx_t n = 0; n < unpivot_names.size(); n++) {
+				if (n > 0) {
+					result += ", ";
+				}
+				result += KeywordHelper::WriteOptionallyQuoted(unpivot_names[n]);
+			}
+			result += ")";
+		}
+	}
+	result += " FOR";
+	for (auto &pivot : pivots) {
+		result += " ";
+		result += pivot.ToString();
+	}
+	if (!groups.empty()) {
+		result += " GROUP BY ";
+		for (idx_t i = 0; i < groups.size(); i++) {
+			if (i > 0) {
+				result += ", ";
+			}
+			result += groups[i];
+		}
+	}
+	result += ")";
+	if (!alias.empty()) {
+		result += " AS " + KeywordHelper::WriteOptionallyQuoted(alias);
+		if (!column_name_alias.empty()) {
+			result += "(";
+			for (idx_t i = 0; i < column_name_alias.size(); i++) {
+				if (i > 0) {
+					result += ", ";
+				}
+				result += KeywordHelper::WriteOptionallyQuoted(column_name_alias[i]);
+			}
+			result += ")";
+		}
+	}
+	return result;
+}
+
+bool PivotRef::Equals(const TableRef *other_p) const {
+	if (!TableRef::Equals(other_p)) {
+		return false;
+	}
+	auto other = (PivotRef *)other_p;
+	if (!source->Equals(other->source.get())) {
+		return false;
+	}
+	if (aggregates.size() != other->aggregates.size()) {
+		return false;
+	}
+	for (idx_t i = 0; i < aggregates.size(); i++) {
+		if (!BaseExpression::Equals(aggregates[i].get(), other->aggregates[i].get())) {
+			return false;
+		}
+	}
+	if (pivots.size() != other->pivots.size()) {
+		return false;
+	}
+	for (idx_t i = 0; i < pivots.size(); i++) {
+		if (!pivots[i].Equals(other->pivots[i])) {
+			return false;
+		}
+	}
+	if (unpivot_names != other->unpivot_names) {
+		return false;
+	}
+	if (alias != other->alias) {
+		return false;
+	}
+	if (groups != other->groups) {
+		return false;
+	}
+	if (include_nulls != other->include_nulls) {
+		return false;
+	}
+	return true;
+}
+
+unique_ptr<TableRef> PivotRef::Copy() {
+	auto copy = make_unique<PivotRef>();
+	copy->source = source->Copy();
+	for (auto &aggr : aggregates) {
+		copy->aggregates.push_back(aggr->Copy());
+	}
+	copy->unpivot_names = unpivot_names;
+	for (auto &entry : pivots) {
+		copy->pivots.push_back(entry.Copy());
+	}
+	copy->groups = groups;
+	copy->column_name_alias = column_name_alias;
+	copy->include_nulls = include_nulls;
+	copy->alias = alias;
+	return std::move(copy);
+}
+
+void PivotRef::Serialize(FieldWriter &writer) const {
+	writer.WriteSerializable(*source);
+	writer.WriteSerializableList(aggregates);
+	writer.WriteList<string>(unpivot_names);
+	writer.WriteRegularSerializableList(pivots);
+	writer.WriteList<string>(groups);
+	writer.WriteList<string>(column_name_alias);
+	writer.WriteField<bool>(include_nulls);
+}
+
+void PivotRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+	serializer.WriteProperty("source", source);
+	serializer.WriteProperty("aggregates", aggregates);
+	serializer.WriteProperty("unpivot_names", unpivot_names);
+	serializer.WriteProperty("pivots", pivots);
+	serializer.WriteProperty("groups", groups);
+	serializer.WriteProperty("column_name_alias", column_name_alias);
+	serializer.WriteProperty("include_nulls", include_nulls);
+}
+
+unique_ptr<TableRef> PivotRef::Deserialize(FieldReader &reader) {
+	auto result = make_unique<PivotRef>();
+	result->source = reader.ReadRequiredSerializable<TableRef>();
+	result->aggregates = reader.ReadRequiredSerializableList<ParsedExpression>();
+	result->unpivot_names = reader.ReadRequiredList<string>();
+	result->pivots = reader.ReadRequiredSerializableList<PivotColumn, PivotColumn>();
+	result->groups = reader.ReadRequiredList<string>();
+	result->column_name_alias = reader.ReadRequiredList<string>();
+	result->include_nulls = reader.ReadRequired<bool>();
+	return std::move(result);
+}
+
+unique_ptr<TableRef> PivotRef::FormatDeserialize(FormatDeserializer &source) {
+	auto result = make_unique<PivotRef>();
+	source.ReadProperty("source", result->source);
+	source.ReadProperty("aggregates", result->aggregates);
+	source.ReadProperty("unpivot_names", result->unpivot_names);
+	source.ReadProperty("pivots", result->pivots);
+	source.ReadProperty("groups", result->groups);
+	source.ReadProperty("column_name_alias", result->column_name_alias);
+	source.ReadProperty("include_nulls", result->include_nulls);
+	return std::move(result);
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/tableref/subqueryref.cpp

@@ -2,6 +2,8 @@
 
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -35,6 +37,19 @@ void SubqueryRef::Serialize(FieldWriter &writer) const {
 	writer.WriteList<string>(column_name_alias);
 }
 
+void SubqueryRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+	serializer.WriteProperty("subquery", subquery);
+	serializer.WriteProperty("column_name_alias", column_name_alias);
+}
+
+unique_ptr<TableRef> SubqueryRef::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto subquery = deserializer.ReadProperty<unique_ptr<SelectStatement>>("subquery");
+	auto result = make_unique<SubqueryRef>(std::move(subquery));
+	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
+	return std::move(result);
+}
+
 unique_ptr<TableRef> SubqueryRef::Deserialize(FieldReader &reader) {
 	auto subquery = reader.ReadRequiredSerializable<SelectStatement>();
 	auto result = make_unique<SubqueryRef>(std::move(subquery));

package/src/duckdb/src/parser/tableref/table_function.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -25,6 +27,21 @@ void TableFunctionRef::Serialize(FieldWriter &writer) const {
 	writer.WriteList<string>(column_name_alias);
 }
 
+void TableFunctionRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+	serializer.WriteProperty("function", function);
+	serializer.WriteProperty("alias", alias);
+	serializer.WriteProperty("column_name_alias", column_name_alias);
+}
+
+unique_ptr<TableRef> TableFunctionRef::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = make_unique<TableFunctionRef>();
+	deserializer.ReadProperty("function", result->function);
+	deserializer.ReadProperty("alias", result->alias);
+	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
+	return std::move(result);
+}
+
 unique_ptr<TableRef> TableFunctionRef::Deserialize(FieldReader &reader) {
 	auto result = make_unique<TableFunctionRef>();
 	result->function = reader.ReadRequiredSerializable<ParsedExpression>();

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

@@ -3,6 +3,8 @@
 #include "duckdb/common/printer.hpp"
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/tableref/list.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 #include "duckdb/common/to_string.hpp"
 
 namespace duckdb {
@@ -52,6 +54,50 @@ void TableRef::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
+void TableRef::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("type", type);
+	serializer.WriteProperty("alias", alias);
+	serializer.WriteOptionalProperty("sample", sample);
+}
+
+unique_ptr<TableRef> TableRef::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto type = deserializer.ReadProperty<TableReferenceType>("type");
+	auto alias = deserializer.ReadProperty<string>("alias");
+	auto sample = deserializer.ReadOptionalProperty<unique_ptr<SampleOptions>>("sample");
+
+	unique_ptr<TableRef> result;
+
+	switch (type) {
+	case TableReferenceType::BASE_TABLE:
+		result = BaseTableRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::JOIN:
+		result = JoinRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::SUBQUERY:
+		result = SubqueryRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::TABLE_FUNCTION:
+		result = TableFunctionRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::EMPTY:
+		result = EmptyTableRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::EXPRESSION_LIST:
+		result = ExpressionListRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::PIVOT:
+		result = PivotRef::FormatDeserialize(deserializer);
+		break;
+	case TableReferenceType::CTE:
+	case TableReferenceType::INVALID:
+		throw InternalException("Unsupported type for TableRef::FormatDeserialize");
+	}
+	result->alias = alias;
+	result->sample = std::move(sample);
+	return result;
+}
+
 unique_ptr<TableRef> TableRef::Deserialize(Deserializer &source) {
 	FieldReader reader(source);
 
@@ -78,6 +124,9 @@ unique_ptr<TableRef> TableRef::Deserialize(Deserializer &source) {
 	case TableReferenceType::EXPRESSION_LIST:
 		result = ExpressionListRef::Deserialize(reader);
 		break;
+	case TableReferenceType::PIVOT:
+		result = PivotRef::Deserialize(reader);
+		break;
 	case TableReferenceType::CTE:
 	case TableReferenceType::INVALID:
 		throw InternalException("Unsupported type for TableRef::Deserialize");

package/src/duckdb/src/parser/transform/expression/transform_array_access.cpp

@@ -49,6 +49,17 @@ unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery
 			result = make_unique<OperatorExpression>(ExpressionType::STRUCT_EXTRACT, std::move(children));
 			break;
 		}
+		case duckdb_libpgquery::T_PGFuncCall: {
+			auto func = (duckdb_libpgquery::PGFuncCall *)target;
+			auto function = TransformFuncCall(func);
+			if (function->type != ExpressionType::FUNCTION) {
+				throw ParserException("%s.%s() call must be a function", result->ToString(), function->ToString());
+			}
+			auto &f = (FunctionExpression &)*function;
+			f.children.insert(f.children.begin(), std::move(result));
+			result = std::move(function);
+			break;
+		}
 		default:
 			throw NotImplementedException("Unimplemented subscript type");
 		}

package/src/duckdb/src/parser/transform/expression/transform_bool_expr.cpp

@@ -37,7 +37,7 @@ unique_ptr<ParsedExpression> Transformer::TransformBoolExpr(duckdb_libpgquery::P
 			           next->type <= ExpressionType::COMPARE_GREATERTHANOREQUALTO) {
 				// NOT on a comparison: we can negate the comparison
 				// e.g. NOT(x > y) is equivalent to x <= y
-				next->type = NegateComparisionExpression(next->type);
+				next->type = NegateComparisonExpression(next->type);
 				result = std::move(next);
 			} else {
 				result = make_unique<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(next));

package/src/duckdb/src/parser/transform/expression/transform_columnref.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/expression/star_expression.hpp"
 #include "duckdb/parser/transformer.hpp"
 
@@ -36,13 +37,27 @@ unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgqu
 			result->replace_list.insert(make_pair(std::move(exclude_entry), std::move(replace_expression)));
 		}
 	}
-	if (star->regex) {
+	if (star->expr) {
+		D_ASSERT(star->columns);
 		D_ASSERT(result->relation_name.empty());
 		D_ASSERT(result->exclude_list.empty());
 		D_ASSERT(result->replace_list.empty());
-		result->regex = star->regex;
+		result->expr = TransformExpression(star->expr);
+		if (result->expr->type == ExpressionType::STAR) {
+			auto child_star = (StarExpression *)result->expr.get();
+			result->exclude_list = std::move(child_star->exclude_list);
+			result->replace_list = std::move(child_star->replace_list);
+			result->expr.reset();
+		} else if (result->expr->type == ExpressionType::LAMBDA) {
+			vector<unique_ptr<ParsedExpression>> children;
+			children.push_back(make_unique<StarExpression>());
+			children.push_back(std::move(result->expr));
+			auto list_filter = make_unique<FunctionExpression>("list_filter", std::move(children));
+			result->expr = std::move(list_filter);
+		}
 	}
 	result->columns = star->columns;
+	result->query_location = star->location;
 	return std::move(result);
 }