duckdb 0.8.2-dev1968.0 → 0.8.2-dev2068.0

package/src/duckdb/src/storage/serialization/serialize_query_node.cpp

@@ -41,6 +41,42 @@ unique_ptr<QueryNode> QueryNode::FormatDeserialize(FormatDeserializer &deseriali
 	return result;
 }
 
+void CTENode::FormatSerialize(FormatSerializer &serializer) const {
+	QueryNode::FormatSerialize(serializer);
+	serializer.WriteProperty("cte_name", ctename);
+	serializer.WriteProperty("query", *query);
+	serializer.WriteProperty("child", *child);
+	serializer.WriteProperty("aliases", aliases);
+}
+
+unique_ptr<QueryNode> CTENode::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CTENode>(new CTENode());
+	deserializer.ReadProperty("cte_name", result->ctename);
+	deserializer.ReadProperty("query", result->query);
+	deserializer.ReadProperty("child", result->child);
+	deserializer.ReadProperty("aliases", result->aliases);
+	return std::move(result);
+}
+
+void RecursiveCTENode::FormatSerialize(FormatSerializer &serializer) const {
+	QueryNode::FormatSerialize(serializer);
+	serializer.WriteProperty("cte_name", ctename);
+	serializer.WriteProperty("union_all", union_all);
+	serializer.WriteProperty("left", *left);
+	serializer.WriteProperty("right", *right);
+	serializer.WriteProperty("aliases", aliases);
+}
+
+unique_ptr<QueryNode> RecursiveCTENode::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<RecursiveCTENode>(new RecursiveCTENode());
+	deserializer.ReadProperty("cte_name", result->ctename);
+	deserializer.ReadProperty("union_all", result->union_all);
+	deserializer.ReadProperty("left", result->left);
+	deserializer.ReadProperty("right", result->right);
+	deserializer.ReadProperty("aliases", result->aliases);
+	return std::move(result);
+}
+
 void SelectNode::FormatSerialize(FormatSerializer &serializer) const {
 	QueryNode::FormatSerialize(serializer);
 	serializer.WriteProperty("select_list", select_list);
@@ -83,40 +119,4 @@ unique_ptr<QueryNode> SetOperationNode::FormatDeserialize(FormatDeserializer &de
 	return std::move(result);
 }
 
-void RecursiveCTENode::FormatSerialize(FormatSerializer &serializer) const {
-	QueryNode::FormatSerialize(serializer);
-	serializer.WriteProperty("cte_name", ctename);
-	serializer.WriteProperty("union_all", union_all);
-	serializer.WriteProperty("left", *left);
-	serializer.WriteProperty("right", *right);
-	serializer.WriteProperty("aliases", aliases);
-}
-
-unique_ptr<QueryNode> RecursiveCTENode::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::unique_ptr<RecursiveCTENode>(new RecursiveCTENode());
-	deserializer.ReadProperty("cte_name", result->ctename);
-	deserializer.ReadProperty("union_all", result->union_all);
-	deserializer.ReadProperty("left", result->left);
-	deserializer.ReadProperty("right", result->right);
-	deserializer.ReadProperty("aliases", result->aliases);
-	return std::move(result);
-}
-
-void CTENode::FormatSerialize(FormatSerializer &serializer) const {
-	QueryNode::FormatSerialize(serializer);
-	serializer.WriteProperty("cte_name", ctename);
-	serializer.WriteProperty("query", *query);
-	serializer.WriteProperty("child", *child);
-	serializer.WriteProperty("aliases", aliases);
-}
-
-unique_ptr<QueryNode> CTENode::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::unique_ptr<CTENode>(new CTENode());
-	deserializer.ReadProperty("cte_name", result->ctename);
-	deserializer.ReadProperty("query", result->query);
-	deserializer.ReadProperty("child", result->child);
-	deserializer.ReadProperty("aliases", result->aliases);
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/storage/serialization/serialize_result_modifier.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/common/serializer/format_serializer.hpp"
 #include "duckdb/common/serializer/format_deserializer.hpp"
 #include "duckdb/parser/result_modifier.hpp"
+#include "duckdb/planner/bound_result_modifier.hpp"
 
 namespace duckdb {
 
@@ -35,17 +36,14 @@ unique_ptr<ResultModifier> ResultModifier::FormatDeserialize(FormatDeserializer
 	return result;
 }
 
-void LimitModifier::FormatSerialize(FormatSerializer &serializer) const {
-	ResultModifier::FormatSerialize(serializer);
-	serializer.WriteOptionalProperty("limit", limit);
-	serializer.WriteOptionalProperty("offset", offset);
+void BoundOrderModifier::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("orders", orders);
 }
 
-unique_ptr<ResultModifier> LimitModifier::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::unique_ptr<LimitModifier>(new LimitModifier());
-	deserializer.ReadOptionalProperty("limit", result->limit);
-	deserializer.ReadOptionalProperty("offset", result->offset);
-	return std::move(result);
+unique_ptr<BoundOrderModifier> BoundOrderModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<BoundOrderModifier>(new BoundOrderModifier());
+	deserializer.ReadProperty("orders", result->orders);
+	return result;
 }
 
 void DistinctModifier::FormatSerialize(FormatSerializer &serializer) const {
@@ -59,14 +57,16 @@ unique_ptr<ResultModifier> DistinctModifier::FormatDeserialize(FormatDeserialize
 	return std::move(result);
 }
 
-void OrderModifier::FormatSerialize(FormatSerializer &serializer) const {
+void LimitModifier::FormatSerialize(FormatSerializer &serializer) const {
 	ResultModifier::FormatSerialize(serializer);
-	serializer.WriteProperty("orders", orders);
+	serializer.WriteOptionalProperty("limit", limit);
+	serializer.WriteOptionalProperty("offset", offset);
 }
 
-unique_ptr<ResultModifier> OrderModifier::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::unique_ptr<OrderModifier>(new OrderModifier());
-	deserializer.ReadProperty("orders", result->orders);
+unique_ptr<ResultModifier> LimitModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<LimitModifier>(new LimitModifier());
+	deserializer.ReadOptionalProperty("limit", result->limit);
+	deserializer.ReadOptionalProperty("offset", result->offset);
 	return std::move(result);
 }
 
@@ -83,4 +83,15 @@ unique_ptr<ResultModifier> LimitPercentModifier::FormatDeserialize(FormatDeseria
 	return std::move(result);
 }
 
+void OrderModifier::FormatSerialize(FormatSerializer &serializer) const {
+	ResultModifier::FormatSerialize(serializer);
+	serializer.WriteProperty("orders", orders);
+}
+
+unique_ptr<ResultModifier> OrderModifier::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<OrderModifier>(new OrderModifier());
+	deserializer.ReadProperty("orders", result->orders);
+	return std::move(result);
+}
+
 } // namespace duckdb

package/src/duckdb/src/storage/serialization/serialize_statement.cpp

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+// This file is automatically generated by scripts/generate_serialization.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
+
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/parser/statement/select_statement.hpp"
+
+namespace duckdb {
+
+void SelectStatement::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("node", *node);
+}
+
+unique_ptr<SelectStatement> SelectStatement::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<SelectStatement>(new SelectStatement());
+	deserializer.ReadProperty("node", result->node);
+	return result;
+}
+
+} // namespace duckdb

package/src/duckdb/src/storage/serialization/serialize_tableref.cpp

@@ -67,6 +67,30 @@ unique_ptr<TableRef> BaseTableRef::FormatDeserialize(FormatDeserializer &deseria
 	return std::move(result);
 }
 
+void EmptyTableRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+}
+
+unique_ptr<TableRef> EmptyTableRef::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<EmptyTableRef>(new EmptyTableRef());
+	return std::move(result);
+}
+
+void ExpressionListRef::FormatSerialize(FormatSerializer &serializer) const {
+	TableRef::FormatSerialize(serializer);
+	serializer.WriteProperty("expected_names", expected_names);
+	serializer.WriteProperty("expected_types", expected_types);
+	serializer.WriteProperty("values", values);
+}
+
+unique_ptr<TableRef> ExpressionListRef::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<ExpressionListRef>(new ExpressionListRef());
+	deserializer.ReadProperty("expected_names", result->expected_names);
+	deserializer.ReadProperty("expected_types", result->expected_types);
+	deserializer.ReadProperty("values", result->values);
+	return std::move(result);
+}
+
 void JoinRef::FormatSerialize(FormatSerializer &serializer) const {
 	TableRef::FormatSerialize(serializer);
 	serializer.WriteProperty("left", *left);
@@ -88,6 +112,29 @@ unique_ptr<TableRef> JoinRef::FormatDeserialize(FormatDeserializer &deserializer
 	return std::move(result);
 }
 
+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::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<PivotRef>(new PivotRef());
+	deserializer.ReadProperty("source", result->source);
+	deserializer.ReadProperty("aggregates", result->aggregates);
+	deserializer.ReadProperty("unpivot_names", result->unpivot_names);
+	deserializer.ReadProperty("pivots", result->pivots);
+	deserializer.ReadProperty("groups", result->groups);
+	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
+	deserializer.ReadProperty("include_nulls", result->include_nulls);
+	return std::move(result);
+}
+
 void SubqueryRef::FormatSerialize(FormatSerializer &serializer) const {
 	TableRef::FormatSerialize(serializer);
 	serializer.WriteProperty("subquery", *subquery);
@@ -116,51 +163,4 @@ unique_ptr<TableRef> TableFunctionRef::FormatDeserialize(FormatDeserializer &des
 	return std::move(result);
 }
 
-void EmptyTableRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
-}
-
-unique_ptr<TableRef> EmptyTableRef::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::unique_ptr<EmptyTableRef>(new EmptyTableRef());
-	return std::move(result);
-}
-
-void ExpressionListRef::FormatSerialize(FormatSerializer &serializer) const {
-	TableRef::FormatSerialize(serializer);
-	serializer.WriteProperty("expected_names", expected_names);
-	serializer.WriteProperty("expected_types", expected_types);
-	serializer.WriteProperty("values", values);
-}
-
-unique_ptr<TableRef> ExpressionListRef::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::unique_ptr<ExpressionListRef>(new ExpressionListRef());
-	deserializer.ReadProperty("expected_names", result->expected_names);
-	deserializer.ReadProperty("expected_types", result->expected_types);
-	deserializer.ReadProperty("values", result->values);
-	return std::move(result);
-}
-
-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::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::unique_ptr<PivotRef>(new PivotRef());
-	deserializer.ReadProperty("source", result->source);
-	deserializer.ReadProperty("aggregates", result->aggregates);
-	deserializer.ReadProperty("unpivot_names", result->unpivot_names);
-	deserializer.ReadProperty("pivots", result->pivots);
-	deserializer.ReadProperty("groups", result->groups);
-	deserializer.ReadProperty("column_name_alias", result->column_name_alias);
-	deserializer.ReadProperty("include_nulls", result->include_nulls);
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/storage/serialization/serialize_types.cpp

@@ -52,6 +52,21 @@ shared_ptr<ExtraTypeInfo> ExtraTypeInfo::FormatDeserialize(FormatDeserializer &d
 	return result;
 }
 
+void AggregateStateTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
+	ExtraTypeInfo::FormatSerialize(serializer);
+	serializer.WriteProperty("function_name", state_type.function_name);
+	serializer.WriteProperty("return_type", state_type.return_type);
+	serializer.WriteProperty("bound_argument_types", state_type.bound_argument_types);
+}
+
+shared_ptr<ExtraTypeInfo> AggregateStateTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::shared_ptr<AggregateStateTypeInfo>(new AggregateStateTypeInfo());
+	deserializer.ReadProperty("function_name", result->state_type.function_name);
+	deserializer.ReadProperty("return_type", result->state_type.return_type);
+	deserializer.ReadProperty("bound_argument_types", result->state_type.bound_argument_types);
+	return std::move(result);
+}
+
 void DecimalTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
 	serializer.WriteProperty("width", width);
@@ -65,17 +80,6 @@ shared_ptr<ExtraTypeInfo> DecimalTypeInfo::FormatDeserialize(FormatDeserializer
 	return std::move(result);
 }
 
-void StringTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
-	ExtraTypeInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("collation", collation);
-}
-
-shared_ptr<ExtraTypeInfo> StringTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::shared_ptr<StringTypeInfo>(new StringTypeInfo());
-	deserializer.ReadProperty("collation", result->collation);
-	return std::move(result);
-}
-
 void ListTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
 	serializer.WriteProperty("child_type", child_type);
@@ -87,29 +91,25 @@ shared_ptr<ExtraTypeInfo> ListTypeInfo::FormatDeserialize(FormatDeserializer &de
 	return std::move(result);
 }
 
-void StructTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
+void StringTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("child_types", child_types);
+	serializer.WriteProperty("collation", collation);
 }
 
-shared_ptr<ExtraTypeInfo> StructTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::shared_ptr<StructTypeInfo>(new StructTypeInfo());
-	deserializer.ReadProperty("child_types", result->child_types);
+shared_ptr<ExtraTypeInfo> StringTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::shared_ptr<StringTypeInfo>(new StringTypeInfo());
+	deserializer.ReadProperty("collation", result->collation);
 	return std::move(result);
 }
 
-void AggregateStateTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
+void StructTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
-	serializer.WriteProperty("function_name", state_type.function_name);
-	serializer.WriteProperty("return_type", state_type.return_type);
-	serializer.WriteProperty("bound_argument_types", state_type.bound_argument_types);
+	serializer.WriteProperty("child_types", child_types);
 }
 
-shared_ptr<ExtraTypeInfo> AggregateStateTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = duckdb::shared_ptr<AggregateStateTypeInfo>(new AggregateStateTypeInfo());
-	deserializer.ReadProperty("function_name", result->state_type.function_name);
-	deserializer.ReadProperty("return_type", result->state_type.return_type);
-	deserializer.ReadProperty("bound_argument_types", result->state_type.bound_argument_types);
+shared_ptr<ExtraTypeInfo> StructTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::shared_ptr<StructTypeInfo>(new StructTypeInfo());
+	deserializer.ReadProperty("child_types", result->child_types);
 	return std::move(result);
 }
 

package/src/duckdb/src/storage/storage_info.cpp

@@ -2,14 +2,15 @@
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 52;
+const uint64_t VERSION_NUMBER = 53;
 
 struct StorageVersionInfo {
 	const char *version_name;
 	idx_t storage_version;
 };
 
-static StorageVersionInfo storage_version_info[] = {{"v0.7.0 or v0.7.1", 43},
+static StorageVersionInfo storage_version_info[] = {{"v0.8.0 or v0.8.1", 51},
+                                                    {"v0.7.0 or v0.7.1", 43},
                                                     {"v0.6.0 or v0.6.1", 39},
                                                     {"v0.5.0 or v0.5.1", 38},
                                                     {"v0.3.3, v0.3.4 or v0.4.0", 33},

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

@@ -195,7 +195,7 @@ void ReplayState::ReplayEntry(WALType entry_type) {
 // Replay Table
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateTable() {
-	auto info = TableCatalogEntry::Deserialize(source, context);
+	auto info = TableCatalogEntry::Deserialize(source);
 	if (deserialize_only) {
 		return;
 	}
@@ -234,12 +234,12 @@ void ReplayState::ReplayAlter() {
 // Replay View
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateView() {
-	auto entry = ViewCatalogEntry::Deserialize(source, context);
+	auto entry = CatalogEntry::Deserialize(source);
 	if (deserialize_only) {
 		return;
 	}
 
-	catalog.CreateView(context, *entry);
+	catalog.CreateView(context, entry->Cast<CreateViewInfo>());
 }
 
 void ReplayState::ReplayDropView() {
@@ -309,7 +309,7 @@ void ReplayState::ReplayCreateSequence() {
 		return;
 	}
 
-	catalog.CreateSequence(context, *entry);
+	catalog.CreateSequence(context, entry->Cast<CreateSequenceInfo>());
 }
 
 void ReplayState::ReplayDropSequence() {
@@ -345,12 +345,12 @@ void ReplayState::ReplaySequenceValue() {
 // Replay Macro
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateMacro() {
-	auto entry = ScalarMacroCatalogEntry::Deserialize(source, context);
+	auto entry = ScalarMacroCatalogEntry::Deserialize(source);
 	if (deserialize_only) {
 		return;
 	}
 
-	catalog.CreateFunction(context, *entry);
+	catalog.CreateFunction(context, entry->Cast<CreateMacroInfo>());
 }
 
 void ReplayState::ReplayDropMacro() {
@@ -369,12 +369,12 @@ void ReplayState::ReplayDropMacro() {
 // Replay Table Macro
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateTableMacro() {
-	auto entry = TableMacroCatalogEntry::Deserialize(source, context);
+	auto entry = TableMacroCatalogEntry::Deserialize(source);
 	if (deserialize_only) {
 		return;
 	}
 
-	catalog.CreateFunction(context, *entry);
+	catalog.CreateFunction(context, entry->Cast<CreateMacroInfo>());
 }
 
 void ReplayState::ReplayDropTableMacro() {
@@ -393,30 +393,31 @@ void ReplayState::ReplayDropTableMacro() {
 // Replay Index
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateIndex() {
-	auto info = IndexCatalogEntry::Deserialize(source, context);
+	auto info = IndexCatalogEntry::Deserialize(source);
 	if (deserialize_only) {
 		return;
 	}
+	auto &index_info = info->Cast<CreateIndexInfo>();
 
 	// get the physical table to which we'll add the index
-	auto &table = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table->table_name);
+	auto &table = catalog.GetEntry<TableCatalogEntry>(context, info->schema, index_info.table);
 	auto &data_table = table.GetStorage();
 
 	// bind the parsed expressions
-	if (info->expressions.empty()) {
-		for (auto &parsed_expr : info->parsed_expressions) {
-			info->expressions.push_back(parsed_expr->Copy());
+	if (index_info.expressions.empty()) {
+		for (auto &parsed_expr : index_info.parsed_expressions) {
+			index_info.expressions.push_back(parsed_expr->Copy());
 		}
 	}
 	auto binder = Binder::CreateBinder(context);
-	auto expressions = binder->BindCreateIndexExpressions(table, *info);
+	auto expressions = binder->BindCreateIndexExpressions(table, index_info);
 
 	// create the empty index
 	unique_ptr<Index> index;
-	switch (info->index_type) {
+	switch (index_info.index_type) {
 	case IndexType::ART: {
-		index = make_uniq<ART>(info->column_ids, TableIOManager::Get(data_table), expressions, info->constraint_type,
-		                       data_table.db);
+		index = make_uniq<ART>(index_info.column_ids, TableIOManager::Get(data_table), expressions,
+		                       index_info.constraint_type, data_table.db);
 		break;
 	}
 	default:
@@ -424,10 +425,10 @@ void ReplayState::ReplayCreateIndex() {
 	}
 
 	// add the index to the catalog
-	auto &index_entry = catalog.CreateIndex(context, *info)->Cast<DuckIndexEntry>();
+	auto &index_entry = catalog.CreateIndex(context, index_info)->Cast<DuckIndexEntry>();
 	index_entry.index = index.get();
 	index_entry.info = data_table.info;
-	for (auto &parsed_expr : info->parsed_expressions) {
+	for (auto &parsed_expr : index_info.parsed_expressions) {
 		index_entry.parsed_expressions.push_back(parsed_expr->Copy());
 	}
 

package/src/duckdb/third_party/concurrentqueue/lightweightsemaphore.h

@@ -29,6 +29,7 @@ extern "C" {
 #include <chrono>
 #elif defined(__MVS__)
 #include <zos-semaphore.h>
+#include <chrono>
 #endif
 
 namespace duckdb_moodycamel
@@ -162,9 +163,9 @@ public:
 		}
 	}
 };
-#elif defined(__unix__)
+#elif defined(__unix__) || defined(__MVS__)
 //---------------------------------------------------------
-// Semaphore (POSIX, Linux)
+// Semaphore (POSIX, Linux, zOS aka MVS)
 //---------------------------------------------------------
 class Semaphore
 {
@@ -256,80 +257,6 @@ public:
 		}
 	}
 };
-#elif defined(__MVS__)
-//---------------------------------------------------------
-// Semaphore (MVS aka z/OS)
-//---------------------------------------------------------
-class Semaphore
-{
-private:
-	sem_t m_sema;
-
-	Semaphore(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
-	Semaphore& operator=(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
-
-public:
-	Semaphore(int initialCount = 0)
-	{
-		assert(initialCount >= 0);
-		int rc = sem_init(&m_sema, 0, initialCount);
-		assert(rc == 0);
-		(void)rc;
-	}
-
-	~Semaphore()
-	{
-		sem_destroy(&m_sema);
-	}
-
-	bool wait()
-	{
-		// http://stackoverflow.com/questions/2013181/gdb-causes-sem-wait-to-fail-with-eintr-error
-		int rc;
-		do {
-			rc = sem_wait(&m_sema);
-		} while (rc == -1 && errno == EINTR);
-		return rc == 0;
-	}
-
-	bool try_wait()
-	{
-		int rc;
-		do {
-			rc = sem_trywait(&m_sema);
-		} while (rc == -1 && errno == EINTR);
-		return rc == 0;
-	}
-
-	bool timed_wait(std::uint64_t usecs)
-	{
-		struct timespec ts;
-		const int usecs_in_1_sec = 1000000;
-		const int nsecs_in_1_sec = 1000000000;
-
-		ts.tv_sec = usecs / usecs_in_1_sec;
-		ts.tv_nsec = (usecs % usecs_in_1_sec) * 1000;
-
-		int rc;
-		do {
-			rc = sem_timedwait(&m_sema, &ts);
-		} while (rc == -1 && errno == EINTR);
-		return rc == 0;
-	}
-
-	void signal()
-	{
-		while (sem_post(&m_sema) == -1);
-	}
-
-	void signal(int count)
-	{
-		while (count-- > 0)
-		{
-			while (sem_post(&m_sema) == -1);
-		}
-	}
-};
 #else
 #error Unsupported platform! (No semaphore wrapper available)
 #endif

package/src/duckdb/third_party/libpg_query/pg_functions.cpp

@@ -8,6 +8,9 @@
 #include <mutex>
 #include <cstring>
 
+#ifdef __MVS__
+#include <zos-tls.h>
+#endif
 
 // max parse tree size approx 100 MB, should be enough
 #define PG_MALLOC_SIZE 10240
@@ -26,7 +29,17 @@ struct pg_parser_state_str {
 	size_t malloc_ptr_size;
 };
 
+#ifdef __MVS__
+// --------------------------------------------------------
+// Permanent - WIP
+// static __tlssim<parser_state> pg_parser_state_impl();
+// #define pg_parser_state (*pg_parser_state_impl.access())
+// --------------------------------------------------------
+// Temporary
+static parser_state pg_parser_state;
+#else
 static __thread parser_state pg_parser_state;
+#endif
 
 #ifndef __GNUC__
 __thread PGNode *duckdb_newNodeMacroHolder;

package/src/duckdb/third_party/libpg_query/src_backend_parser_scansup.cpp

@@ -30,6 +30,10 @@
 #include "parser/scansup.hpp"
 #include "mb/pg_wchar.hpp"
 
+#ifdef __MVS__
+#include <zos-tls.h>
+#endif
+
 namespace duckdb_libpgquery {
 
 /* ----------------
@@ -60,7 +64,12 @@ char *downcase_truncate_identifier(const char *ident, int len, bool warn) {
 	return downcase_identifier(ident, len, warn, true);
 }
 
+#ifdef __MVS__
+static __tlssim<bool> pg_preserve_identifier_case_impl(false);
+#define pg_preserve_identifier_case (*pg_preserve_identifier_case_impl.access())
+#else
 static __thread bool pg_preserve_identifier_case = false;
+#endif
 
 void set_preserve_identifier_case(bool preserve) {
 	pg_preserve_identifier_case = preserve;

package/src/duckdb/ub_src_parser.cpp

@@ -6,8 +6,6 @@
 
 #include "src/parser/constraint.cpp"
 
-#include "src/parser/common_table_expression_info.cpp"
-
 #include "src/parser/expression_util.cpp"
 
 #include "src/parser/keyword_helper.cpp"