duckdb 0.7.2-dev0.0 → 0.7.2-dev1138.0

package/src/duckdb/src/function/table/arrow_conversion.cpp

@@ -20,7 +20,13 @@ void ShiftRight(unsigned char *ar, int size, int shift) {
 
 void GetValidityMask(ValidityMask &mask, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
                      int64_t nested_offset = -1, bool add_null = false) {
-	if (array.null_count != 0 && array.buffers[0]) {
+	// In certains we don't need to or cannot copy arrow's validity mask to duckdb.
+	//
+	// The conditions where we do want to copy arrow's mask to duckdb are:
+	// 1. nulls exist
+	// 2. n_buffers > 0, meaning the array's arrow type is not `null`
+	// 3. the validity buffer (the first buffer) is not a nullptr
+	if (array.null_count != 0 && array.n_buffers > 0 && array.buffers[0]) {
 		auto bit_offset = scan_state.chunk_offset + array.offset;
 		if (nested_offset != -1) {
 			bit_offset = nested_offset;
@@ -316,6 +322,20 @@ void IntervalConversionMonths(Vector &vector, ArrowArray &array, ArrowScanLocalS
 	}
 }
 
+void IntervalConversionMonthDayNanos(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state,
+                                     int64_t nested_offset, idx_t size) {
+	auto tgt_ptr = (interval_t *)FlatVector::GetData(vector);
+	auto src_ptr = (ArrowInterval *)array.buffers[1] + scan_state.chunk_offset + array.offset;
+	if (nested_offset != -1) {
+		src_ptr = (ArrowInterval *)array.buffers[1] + nested_offset + array.offset;
+	}
+	for (idx_t row = 0; row < size; row++) {
+		tgt_ptr[row].days = src_ptr[row].days;
+		tgt_ptr[row].micros = src_ptr[row].nanoseconds / Interval::NANOS_PER_MICRO;
+		tgt_ptr[row].months = src_ptr[row].months;
+	}
+}
+
 void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
                          std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx,
                          std::pair<idx_t, idx_t> &arrow_convert_idx, int64_t nested_offset, ValidityMask *parent_mask) {
@@ -509,6 +529,10 @@ void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLocalState
 			IntervalConversionMonths(vector, array, scan_state, nested_offset, size);
 			break;
 		}
+		case ArrowDateTimeType::MONTH_DAY_NANO: {
+			IntervalConversionMonthDayNanos(vector, array, scan_state, nested_offset, size);
+			break;
+		}
 		default:
 			throw std::runtime_error("Unsupported precision for Interval/Duration Type ");
 		}

package/src/duckdb/src/function/table/checkpoint.cpp

@@ -32,7 +32,11 @@ static unique_ptr<FunctionData> CheckpointBind(ClientContext &context, TableFunc
 	AttachedDatabase *db;
 	auto &db_manager = DatabaseManager::Get(context);
 	if (!input.inputs.empty()) {
-		db = db_manager.GetDatabase(context, StringValue::Get(input.inputs[0]));
+		auto &db_name = StringValue::Get(input.inputs[0]);
+		db = db_manager.GetDatabase(context, db_name);
+		if (!db) {
+			throw BinderException("Database \"%s\" not found", db_name);
+		}
 	} else {
 		db = db_manager.GetDatabase(context, DatabaseManager::GetDefaultDatabase(context));
 	}

package/src/duckdb/src/function/table/read_csv.cpp

@@ -31,6 +31,9 @@ void ReadCSVData::InitializeFiles(ClientContext &context, const vector<string> &
 		auto found_files = fs.GlobFiles(file_pattern, context);
 		files.insert(files.end(), found_files.begin(), found_files.end());
 	}
+	if (files.empty()) {
+		throw IOException("CSV reader needs at least one file to read");
+	}
 }
 
 void ReadCSVData::FinalizeRead(ClientContext &context) {
@@ -50,6 +53,25 @@ void ReadCSVData::FinalizeRead(ClientContext &context) {
 	}
 }
 
+uint8_t GetCandidateSpecificity(const LogicalType &candidate_type) {
+	//! Const ht with accepted auto_types and their weights in specificity
+	const duckdb::unordered_map<uint8_t, uint8_t> auto_type_candidates_specificity {
+	    {(uint8_t)LogicalTypeId::VARCHAR, 0},  {(uint8_t)LogicalTypeId::TIMESTAMP, 1},
+	    {(uint8_t)LogicalTypeId::DATE, 2},     {(uint8_t)LogicalTypeId::TIME, 3},
+	    {(uint8_t)LogicalTypeId::DOUBLE, 4},   {(uint8_t)LogicalTypeId::FLOAT, 5},
+	    {(uint8_t)LogicalTypeId::BIGINT, 6},   {(uint8_t)LogicalTypeId::INTEGER, 7},
+	    {(uint8_t)LogicalTypeId::SMALLINT, 8}, {(uint8_t)LogicalTypeId::TINYINT, 9},
+	    {(uint8_t)LogicalTypeId::BOOLEAN, 10}, {(uint8_t)LogicalTypeId::SQLNULL, 11}};
+
+	auto id = (uint8_t)candidate_type.id();
+	auto it = auto_type_candidates_specificity.find(id);
+	if (it == auto_type_candidates_specificity.end()) {
+		throw BinderException("Auto Type Candidate of type %s is not accepted as a valid input",
+		                      LogicalTypeIdToString(candidate_type.id()));
+	}
+	return it->second;
+}
+
 static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctionBindInput &input,
                                             vector<LogicalType> &return_types, vector<string> &names) {
 	auto &config = DBConfig::GetConfig(context);
@@ -61,9 +83,15 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 	auto &options = result->options;
 
 	vector<string> patterns;
+	if (input.inputs[0].IsNull()) {
+		throw ParserException("CSV reader cannot take NULL as parameter");
+	}
 	if (input.inputs[0].type().id() == LogicalTypeId::LIST) {
 		// list of globs
 		for (auto &val : ListValue::GetChildren(input.inputs[0])) {
+			if (val.IsNull()) {
+				throw ParserException("CSV reader cannot take NULL input as parameter");
+			}
 			patterns.push_back(StringValue::Get(val));
 		}
 	} else {
@@ -96,6 +124,32 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 			if (names.empty()) {
 				throw BinderException("read_csv requires at least a single column as input!");
 			}
+		} else if (loption == "auto_type_candidates") {
+			options.auto_type_candidates.clear();
+			map<uint8_t, LogicalType> candidate_types;
+			// We always have the extremes of Null and Varchar, so we can default to varchar if the
+			// sniffer is not able to confidently detect that column type
+			candidate_types[GetCandidateSpecificity(LogicalType::VARCHAR)] = LogicalType::VARCHAR;
+			candidate_types[GetCandidateSpecificity(LogicalType::SQLNULL)] = LogicalType::SQLNULL;
+
+			auto &child_type = kv.second.type();
+			if (child_type.id() != LogicalTypeId::LIST) {
+				throw BinderException("read_csv auto_types requires a list as input");
+			}
+			auto &list_children = ListValue::GetChildren(kv.second);
+			if (list_children.empty()) {
+				throw BinderException("auto_type_candidates requires at least one type");
+			}
+			for (auto &child : list_children) {
+				if (child.type().id() != LogicalTypeId::VARCHAR) {
+					throw BinderException("auto_type_candidates requires a type specification as string");
+				}
+				auto candidate_type = TransformStringToLogicalType(StringValue::Get(child), context);
+				candidate_types[GetCandidateSpecificity(candidate_type)] = candidate_type;
+			}
+			for (auto &candidate_type : candidate_types) {
+				options.auto_type_candidates.emplace_back(candidate_type.second);
+			}
 		} else if (loption == "column_names" || loption == "names") {
 			if (!options.name_list.empty()) {
 				throw BinderException("read_csv_auto column_names/names can only be supplied once");
@@ -786,6 +840,7 @@ static void ReadCSVAddNamedParameters(TableFunction &table_function) {
 	table_function.named_parameters["escape"] = LogicalType::VARCHAR;
 	table_function.named_parameters["nullstr"] = LogicalType::VARCHAR;
 	table_function.named_parameters["columns"] = LogicalType::ANY;
+	table_function.named_parameters["auto_type_candidates"] = LogicalType::ANY;
 	table_function.named_parameters["header"] = LogicalType::BOOLEAN;
 	table_function.named_parameters["auto_detect"] = LogicalType::BOOLEAN;
 	table_function.named_parameters["sample_size"] = LogicalType::BIGINT;
@@ -806,6 +861,7 @@ static void ReadCSVAddNamedParameters(TableFunction &table_function) {
 	table_function.named_parameters["buffer_size"] = LogicalType::UBIGINT;
 	table_function.named_parameters["decimal_separator"] = LogicalType::VARCHAR;
 	table_function.named_parameters["parallel"] = LogicalType::BOOLEAN;
+	table_function.named_parameters["null_padding"] = LogicalType::BOOLEAN;
 }
 
 double CSVReaderProgress(ClientContext &context, const FunctionData *bind_data_p,
@@ -873,6 +929,7 @@ void BufferedCSVReaderOptions::Serialize(FieldWriter &writer) const {
 	// read options
 	writer.WriteList<string>(names);
 	writer.WriteField<idx_t>(skip_rows);
+	writer.WriteField<bool>(skip_rows_set);
 	writer.WriteField<idx_t>(maximum_line_size);
 	writer.WriteField<bool>(normalize_names);
 	writer.WriteListNoReference<bool>(force_not_null);
@@ -884,6 +941,7 @@ void BufferedCSVReaderOptions::Serialize(FieldWriter &writer) const {
 	writer.WriteField<bool>(include_file_name);
 	writer.WriteField<bool>(include_parsed_hive_partitions);
 	writer.WriteString(decimal_separator);
+	writer.WriteField<bool>(null_padding);
 	// write options
 	writer.WriteListNoReference<bool>(force_quote);
 }
@@ -906,6 +964,7 @@ void BufferedCSVReaderOptions::Deserialize(FieldReader &reader) {
 	// read options
 	names = reader.ReadRequiredList<string>();
 	skip_rows = reader.ReadRequired<idx_t>();
+	skip_rows_set = reader.ReadRequired<bool>();
 	maximum_line_size = reader.ReadRequired<idx_t>();
 	normalize_names = reader.ReadRequired<bool>();
 	force_not_null = reader.ReadRequiredList<bool>();
@@ -917,6 +976,7 @@ void BufferedCSVReaderOptions::Deserialize(FieldReader &reader) {
 	include_file_name = reader.ReadRequired<bool>();
 	include_parsed_hive_partitions = reader.ReadRequired<bool>();
 	decimal_separator = reader.ReadRequired<string>();
+	null_padding = reader.ReadRequired<bool>();
 	// write options
 	force_quote = reader.ReadRequiredList<bool>();
 }

package/src/duckdb/src/function/table/system/duckdb_constraints.cpp

@@ -204,8 +204,8 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 					const auto &bound_foreign_key = (const BoundForeignKeyConstraint &)bound_constraint;
 					const auto &info = bound_foreign_key.info;
 					// find the other table
-					auto table_entry =
-					    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, info.schema, info.table, true);
+					auto table_entry = Catalog::GetEntry<TableCatalogEntry>(context, table.catalog->GetName(),
+					                                                        info.schema, info.table, true);
 					if (!table_entry) {
 						throw InternalException("dukdb_constraints: entry %s.%s referenced in foreign key not found",
 						                        info.schema, info.table);

package/src/duckdb/src/function/table/system/test_all_types.cpp

@@ -138,7 +138,7 @@ vector<TestType> TestAllTypesFun::GetTestTypes() {
 	child_list_t<LogicalType> struct_type_list;
 	struct_type_list.push_back(make_pair("a", LogicalType::INTEGER));
 	struct_type_list.push_back(make_pair("b", LogicalType::VARCHAR));
-	auto struct_type = LogicalType::STRUCT(std::move(struct_type_list));
+	auto struct_type = LogicalType::STRUCT(struct_type_list);
 
 	child_list_t<Value> min_struct_list;
 	min_struct_list.push_back(make_pair("a", Value(LogicalType::INTEGER)));
@@ -156,7 +156,7 @@ vector<TestType> TestAllTypesFun::GetTestTypes() {
 	child_list_t<LogicalType> struct_list_type_list;
 	struct_list_type_list.push_back(make_pair("a", int_list_type));
 	struct_list_type_list.push_back(make_pair("b", varchar_list_type));
-	auto struct_list_type = LogicalType::STRUCT(std::move(struct_list_type_list));
+	auto struct_list_type = LogicalType::STRUCT(struct_list_type_list);
 
 	child_list_t<Value> min_struct_vl_list;
 	min_struct_vl_list.push_back(make_pair("a", Value(int_list_type)));

package/src/duckdb/src/function/table/table_scan.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/function/table/table_scan.hpp"
 
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/mutex.hpp"
@@ -15,6 +14,7 @@
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/catalog/dependency_list.hpp"
 #include "duckdb/function/function_set.hpp"
+#include "duckdb/storage/table/scan_state.hpp"
 
 namespace duckdb {
 
@@ -40,17 +40,14 @@ static storage_t GetStorageIndex(TableCatalogEntry &table, column_t column_id) {
 }
 
 struct TableScanGlobalState : public GlobalTableFunctionState {
-	TableScanGlobalState(ClientContext &context, const FunctionData *bind_data_p) : row_count(0) {
+	TableScanGlobalState(ClientContext &context, const FunctionData *bind_data_p) {
 		D_ASSERT(bind_data_p);
 		auto &bind_data = (const TableScanBindData &)*bind_data_p;
 		max_threads = bind_data.table->GetStorage().MaxThreads(context);
 	}
 
 	ParallelTableScanState state;
-	mutex lock;
 	idx_t max_threads;
-	//! How many rows we already scanned
-	atomic<idx_t> row_count;
 
 	vector<idx_t> projection_ids;
 	vector<LogicalType> scanned_types;
@@ -131,7 +128,6 @@ static void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, Da
 			storage.Scan(transaction, output, state.scan_state);
 		}
 		if (output.size() > 0) {
-			gstate.row_count += output.size();
 			return;
 		}
 		if (!TableScanParallelStateNext(context, data_p.bind_data, data_p.local_state, data_p.global_state)) {
@@ -147,7 +143,6 @@ bool TableScanParallelStateNext(ClientContext &context, const FunctionData *bind
 	auto &state = (TableScanLocalState &)*local_state;
 	auto &storage = bind_data.table->GetStorage();
 
-	lock_guard<mutex> parallel_lock(parallel_state.lock);
 	return storage.NextParallelScan(context, parallel_state.state, state.scan_state);
 }
 
@@ -161,7 +156,9 @@ double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p
 		//! Table is either empty or smaller than a vector size, so it is finished
 		return 100;
 	}
-	auto percentage = 100 * (double(gstate.row_count) / total_rows);
+	idx_t scanned_rows = gstate.state.scan_state.processed_rows;
+	scanned_rows += gstate.state.local_state.processed_rows;
+	auto percentage = 100 * (double(scanned_rows) / total_rows);
 	if (percentage > 100) {
 		//! In case the last chunk has less elements than STANDARD_VECTOR_SIZE, if our percentage is over 100
 		//! It means we finished this table.
@@ -171,12 +168,12 @@ double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p
 }
 
 idx_t TableScanGetBatchIndex(ClientContext &context, const FunctionData *bind_data_p,
-                             LocalTableFunctionState *local_state, GlobalTableFunctionState *global_state) {
+                             LocalTableFunctionState *local_state, GlobalTableFunctionState *gstate_p) {
 	auto &state = (TableScanLocalState &)*local_state;
-	if (state.scan_state.table_state.row_group_state.row_group) {
+	if (state.scan_state.table_state.row_group) {
 		return state.scan_state.table_state.batch_index;
 	}
-	if (state.scan_state.local_state.row_group_state.row_group) {
+	if (state.scan_state.local_state.row_group) {
 		return state.scan_state.table_state.batch_index + state.scan_state.local_state.batch_index;
 	}
 	return 0;
@@ -332,7 +329,7 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 				auto comparison_type = comparison->type;
 				if (comparison->left->type == ExpressionType::VALUE_CONSTANT) {
 					// the expression is on the right side, we flip them around
-					comparison_type = FlipComparisionExpression(comparison_type);
+					comparison_type = FlipComparisonExpression(comparison_type);
 				}
 				if (comparison_type == ExpressionType::COMPARE_EQUAL) {
 					// equality value

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.1"
+#define DUCKDB_VERSION "0.7.2-dev1138"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "b00b93f0b1"
+#define DUCKDB_SOURCE_ID "41104b611e"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/function/table_function.cpp

@@ -14,12 +14,12 @@ TableFunctionInfo::~TableFunctionInfo() {
 TableFunction::TableFunction(string name, vector<LogicalType> arguments, table_function_t function,
                              table_function_bind_t bind, table_function_init_global_t init_global,
                              table_function_init_local_t init_local)
-    : SimpleNamedParameterFunction(std::move(name), std::move(arguments)), bind(bind), init_global(init_global),
-      init_local(init_local), function(function), in_out_function(nullptr), in_out_function_final(nullptr),
-      statistics(nullptr), dependency(nullptr), cardinality(nullptr), pushdown_complex_filter(nullptr),
-      to_string(nullptr), table_scan_progress(nullptr), get_batch_index(nullptr), get_batch_info(nullptr),
-      serialize(nullptr), deserialize(nullptr), projection_pushdown(false), filter_pushdown(false),
-      filter_prune(false) {
+    : SimpleNamedParameterFunction(std::move(name), std::move(arguments)), bind(bind), bind_replace(nullptr),
+      init_global(init_global), init_local(init_local), function(function), in_out_function(nullptr),
+      in_out_function_final(nullptr), statistics(nullptr), dependency(nullptr), cardinality(nullptr),
+      pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr), get_batch_index(nullptr),
+      get_batch_info(nullptr), serialize(nullptr), deserialize(nullptr), projection_pushdown(false),
+      filter_pushdown(false), filter_prune(false) {
 }
 
 TableFunction::TableFunction(const vector<LogicalType> &arguments, table_function_t function,
@@ -28,11 +28,30 @@ TableFunction::TableFunction(const vector<LogicalType> &arguments, table_functio
     : TableFunction(string(), arguments, function, bind, init_global, init_local) {
 }
 TableFunction::TableFunction()
-    : SimpleNamedParameterFunction("", {}), bind(nullptr), init_global(nullptr), init_local(nullptr), function(nullptr),
-      in_out_function(nullptr), statistics(nullptr), dependency(nullptr), cardinality(nullptr),
-      pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr), get_batch_index(nullptr),
-      get_batch_info(nullptr), serialize(nullptr), deserialize(nullptr), projection_pushdown(false),
-      filter_pushdown(false), filter_prune(false) {
+    : SimpleNamedParameterFunction("", {}), bind(nullptr), bind_replace(nullptr), init_global(nullptr),
+      init_local(nullptr), function(nullptr), in_out_function(nullptr), statistics(nullptr), dependency(nullptr),
+      cardinality(nullptr), pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr),
+      get_batch_index(nullptr), get_batch_info(nullptr), serialize(nullptr), deserialize(nullptr),
+      projection_pushdown(false), filter_pushdown(false), filter_prune(false) {
+}
+
+bool TableFunction::Equal(const TableFunction &rhs) const {
+	// number of types
+	if (this->arguments.size() != rhs.arguments.size()) {
+		return false;
+	}
+	// argument types
+	for (idx_t i = 0; i < this->arguments.size(); ++i) {
+		if (this->arguments[i] != rhs.arguments[i]) {
+			return false;
+		}
+	}
+	// varargs
+	if (this->varargs != rhs.varargs) {
+		return false;
+	}
+
+	return true; // they are equal
 }
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/catalog.hpp

@@ -14,6 +14,7 @@
 #include "duckdb/catalog/catalog_transaction.hpp"
 #include "duckdb/common/unordered_set.hpp"
 #include "duckdb/common/atomic.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 #include <functional>
 
@@ -80,6 +81,8 @@ public:
 	DUCKDB_API static Catalog &GetCatalog(ClientContext &context, const string &catalog_name);
 	//! Get the specified Catalog from the DatabaseInstance
 	DUCKDB_API static Catalog &GetCatalog(DatabaseInstance &db, const string &catalog_name);
+	//! Gets the specified Catalog from the database if it exists
+	DUCKDB_API static optional_ptr<Catalog> GetCatalogEntry(ClientContext &context, const string &catalog_name);
 	//! Get the specific Catalog from the AttachedDatabase
 	DUCKDB_API static Catalog &GetCatalog(AttachedDatabase &db);
 
@@ -205,6 +208,9 @@ public:
 	DUCKDB_API static LogicalType GetType(ClientContext &context, const string &catalog_name, const string &schema,
 	                                      const string &name);
 
+	static bool TypeExists(ClientContext &context, const string &catalog_name, const string &schema,
+	                       const string &name);
+
 	template <class T>
 	T *GetEntry(ClientContext &context, const string &schema_name, const string &name, bool if_exists = false,
 	            QueryErrorContext error_context = QueryErrorContext()) {

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_table_entry.hpp

@@ -35,7 +35,7 @@ public:
 
 	void SetAsRoot() override;
 
-	void CommitAlter(AlterInfo &info);
+	void CommitAlter(string &column_name);
 	void CommitDrop();
 
 	TableFunction GetScanFunction(ClientContext &context, unique_ptr<FunctionData> &bind_data) override;

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp

@@ -9,17 +9,12 @@
 #pragma once
 
 #include "duckdb/catalog/standard_entry.hpp"
-#include "duckdb/function/table_function.hpp"
-#include "duckdb/common/vector.hpp"
-#include "duckdb/function/function_set.hpp"
+#include "duckdb/catalog/catalog_set.hpp"
+#include "duckdb/function/function.hpp"
+#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
 
 namespace duckdb {
 
-class Catalog;
-class Constraint;
-
-struct CreateTableFunctionInfo;
-
 //! A table function in the catalog
 class TableFunctionCatalogEntry : public StandardEntry {
 public:
@@ -31,5 +26,8 @@ public:
 
 	//! The table function
 	TableFunctionSet functions;
+
+public:
+	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo *info) override;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/dependency_list.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/common/unordered_set.hpp"
 
 namespace duckdb {
+class Catalog;
 class CatalogEntry;
 
 //! The DependencyList
@@ -21,6 +22,8 @@ class DependencyList {
 public:
 	DUCKDB_API void AddDependency(CatalogEntry *entry);
 
+	DUCKDB_API void VerifyDependencies(Catalog *catalog, const string &name);
+
 private:
 	unordered_set<CatalogEntry *> set;
 };

package/src/duckdb/src/include/duckdb/catalog/duck_catalog.hpp

@@ -59,8 +59,9 @@ public:
 	DUCKDB_API string GetDBPath() override;
 
 private:
+	DUCKDB_API void DropSchema(CatalogTransaction transaction, DropInfo *info);
 	DUCKDB_API void DropSchema(ClientContext &context, DropInfo *info) override;
-
+	CatalogEntry *CreateSchemaInternal(CatalogTransaction transaction, CreateSchemaInfo *info);
 	void Verify() override;
 
 private:

package/src/duckdb/src/include/duckdb/common/box_renderer.hpp

@@ -18,6 +18,7 @@ class ColumnDataCollection;
 class ColumnDataRowCollection;
 
 enum class ValueRenderAlignment { LEFT, MIDDLE, RIGHT };
+enum class RenderMode { ROWS, COLUMNS };
 
 struct BoxRendererConfig {
 	// a max_width of 0 means we default to the terminal width
@@ -30,7 +31,10 @@ struct BoxRendererConfig {
 	// the max col width determines the maximum size of a single column
 	// note that the max col width is only used if the result does not fit on the screen
 	idx_t max_col_width = 20;
+	//! how to render NULL values
 	string null_value = "NULL";
+	//! Whether or not to render row-wise or column-wise
+	RenderMode render_mode = RenderMode::ROWS;
 
 #ifndef DUCKDB_ASCII_TREE_RENDERER
 	const char *LTCORNER = "\342\224\214"; // "┌";
@@ -94,10 +98,12 @@ private:
 	string RenderType(const LogicalType &type);
 	ValueRenderAlignment TypeAlignment(const LogicalType &type);
 	string GetRenderValue(ColumnDataRowCollection &rows, idx_t c, idx_t r);
-
 	list<ColumnDataCollection> FetchRenderCollections(ClientContext &context, const ColumnDataCollection &result,
 	                                                  idx_t top_rows, idx_t bottom_rows);
-	vector<idx_t> ComputeRenderWidths(const vector<string> &names, const ColumnDataCollection &result,
+	list<ColumnDataCollection> PivotCollections(ClientContext &context, list<ColumnDataCollection> input,
+	                                            vector<string> &column_names, vector<LogicalType> &result_types,
+	                                            idx_t row_count);
+	vector<idx_t> ComputeRenderWidths(const vector<string> &names, const vector<LogicalType> &result_types,
 	                                  list<ColumnDataCollection> &collections, idx_t min_width, idx_t max_width,
 	                                  vector<idx_t> &column_map, idx_t &total_length);
 	void RenderHeader(const vector<string> &names, const vector<LogicalType> &result_types,

package/src/duckdb/src/include/duckdb/common/constants.hpp

@@ -15,25 +15,6 @@
 
 namespace duckdb {
 
-// API versions
-// if no explicit API version is defined, the latest API version is used
-// Note that using older API versions (i.e. not using DUCKDB_API_LATEST) is deprecated.
-// These will not be supported long-term, and will be removed in future versions.
-
-#ifndef DUCKDB_API_0_3_1
-#define DUCKDB_API_0_3_1 1
-#endif
-#ifndef DUCKDB_API_0_3_2
-#define DUCKDB_API_0_3_2 2
-#endif
-#ifndef DUCKDB_API_LATEST
-#define DUCKDB_API_LATEST DUCKDB_API_0_3_2
-#endif
-
-#ifndef DUCKDB_API_VERSION
-#define DUCKDB_API_VERSION DUCKDB_API_LATEST
-#endif
-
 //! inline std directives that we use frequently
 #ifndef DUCKDB_DEBUG_MOVE
 using std::move;

package/src/duckdb/src/include/duckdb/common/enums/aggregate_handling.hpp

@@ -19,4 +19,6 @@ enum class AggregateHandling : uint8_t {
 	FORCE_AGGREGATES       // force aggregates: any non-aggregate select list entry will become a GROUP
 };
 
+const char *ToString(AggregateHandling value);
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/expression_type.hpp

@@ -205,11 +205,10 @@ string ExpressionTypeToOperator(ExpressionType type);
 
 // Operator String to ExpressionType (e.g. + => OPERATOR_ADD)
 ExpressionType OperatorToExpressionType(const string &op);
-
 //! Negate a comparison expression, turning e.g. = into !=, or < into >=
-ExpressionType NegateComparisionExpression(ExpressionType type);
+ExpressionType NegateComparisonExpression(ExpressionType type);
 //! Flip a comparison expression, turning e.g. < into >, or = into =
-ExpressionType FlipComparisionExpression(ExpressionType type);
+ExpressionType FlipComparisonExpression(ExpressionType type);
 
 DUCKDB_API string ExpressionClassToString(ExpressionClass type);
 

package/src/duckdb/src/include/duckdb/common/enums/joinref_type.hpp

@@ -16,10 +16,13 @@ namespace duckdb {
 // Join Reference Types
 //===--------------------------------------------------------------------===//
 enum class JoinRefType : uint8_t {
-	REGULAR,   // Explicit conditions
-	NATURAL,   // Implied conditions
-	CROSS,     // No condition
-	POSITIONAL // Positional condition
+	REGULAR,    // Explicit conditions
+	NATURAL,    // Implied conditions
+	CROSS,      // No condition
+	POSITIONAL, // Positional condition
+	ASOF        // AsOf conditions
 };
 
+const char *ToString(JoinRefType value);
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/logical_operator_type.hpp

@@ -49,6 +49,7 @@ enum class LogicalOperatorType : uint8_t {
 	LOGICAL_ANY_JOIN = 53,
 	LOGICAL_CROSS_PRODUCT = 54,
 	LOGICAL_POSITIONAL_JOIN = 55,
+	LOGICAL_ASOF_JOIN = 56,
 	// -----------------------------
 	// SetOps
 	// -----------------------------

package/src/duckdb/src/include/duckdb/common/enums/order_type.hpp

@@ -9,10 +9,12 @@
 #pragma once
 
 #include "duckdb/common/constants.hpp"
+#include "duckdb/common/exception.hpp"
 
 namespace duckdb {
 
 enum class OrderType : uint8_t { INVALID = 0, ORDER_DEFAULT = 1, ASCENDING = 2, DESCENDING = 3 };
+
 enum class OrderByNullType : uint8_t { INVALID = 0, ORDER_DEFAULT = 1, NULLS_FIRST = 2, NULLS_LAST = 3 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/set_operation_type.hpp

@@ -13,4 +13,5 @@
 namespace duckdb {
 
 enum class SetOperationType : uint8_t { NONE = 0, UNION = 1, EXCEPT = 2, INTERSECT = 3, UNION_BY_NAME = 4 };
-}
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/enums/statement_type.hpp

@@ -44,7 +44,8 @@ enum class StatementType : uint8_t {
 	EXTENSION_STATEMENT,
 	LOGICAL_PLAN_STATEMENT,
 	ATTACH_STATEMENT,
-	DETACH_STATEMENT
+	DETACH_STATEMENT,
+	MULTI_STATEMENT
 
 };
 

package/src/duckdb/src/include/duckdb/common/enums/tableref_type.hpp

@@ -23,7 +23,8 @@ enum class TableReferenceType : uint8_t {
 	TABLE_FUNCTION = 5,  // table producing function
 	EXPRESSION_LIST = 6, // expression list
 	CTE = 7,             // Recursive CTE
-	EMPTY = 8            // placeholder for empty FROM
+	EMPTY = 8,           // placeholder for empty FROM
+	PIVOT = 9            // pivot statement
 };
 
 } // namespace duckdb