diff --git a/src/duckdb/extension/json/json_functions/json_create.cpp b/src/duckdb/extension/json/json_functions/json_create.cpp index dcea02b6..3927daa1 100644 --- a/src/duckdb/extension/json/json_functions/json_create.cpp +++ b/src/duckdb/extension/json/json_functions/json_create.cpp @@ -550,6 +550,7 @@ static void CreateValues(const StructNames &names, yyjson_mut_doc *doc, yyjson_m case LogicalTypeId::TIMESTAMP_NS: case LogicalTypeId::TIMESTAMP_MS: case LogicalTypeId::TIMESTAMP_SEC: + case LogicalTypeId::VARINT: case LogicalTypeId::UUID: { Vector string_vector(LogicalTypeId::VARCHAR, count); VectorOperations::DefaultCast(value_v, string_vector, count); @@ -562,7 +563,17 @@ static void CreateValues(const StructNames &names, yyjson_mut_doc *doc, yyjson_m TemplatedCreateValues(doc, vals, double_vector, count); break; } - default: + case LogicalTypeId::INVALID: + case LogicalTypeId::UNKNOWN: + case LogicalTypeId::ANY: + case LogicalTypeId::USER: + case LogicalTypeId::CHAR: + case LogicalTypeId::STRING_LITERAL: + case LogicalTypeId::INTEGER_LITERAL: + case LogicalTypeId::POINTER: + case LogicalTypeId::VALIDITY: + case LogicalTypeId::TABLE: + case LogicalTypeId::LAMBDA: throw InternalException("Unsupported type arrived at JSON create function"); } } diff --git a/src/duckdb/extension/json/json_functions/read_json_objects.cpp b/src/duckdb/extension/json/json_functions/read_json_objects.cpp index 46d4e798..7e97b647 100644 --- a/src/duckdb/extension/json/json_functions/read_json_objects.cpp +++ b/src/duckdb/extension/json/json_functions/read_json_objects.cpp @@ -33,8 +33,9 @@ static void ReadJSONObjectsFunction(ClientContext &context, TableFunctionInput & if (!gstate.names.empty()) { // Create the strings without copying them - auto strings = FlatVector::GetData(output.data[0]); - auto &validity = FlatVector::Validity(output.data[0]); + const auto col_idx = gstate.column_indices[0]; + auto strings = FlatVector::GetData(output.data[col_idx]); + auto &validity = FlatVector::Validity(output.data[col_idx]); for (idx_t i = 0; i < count; i++) { if (objects[i]) { strings[i] = string_t(units[i].pointer, units[i].size); diff --git a/src/duckdb/src/common/types/varint.cpp b/src/duckdb/src/common/types/varint.cpp index 2a5fe3b8..121b9a3c 100644 --- a/src/duckdb/src/common/types/varint.cpp +++ b/src/duckdb/src/common/types/varint.cpp @@ -120,7 +120,7 @@ bool Varint::VarcharFormatting(const string_t &value, idx_t &start_pos, idx_t &e is_zero = true; return true; } - // This is either a '+' or '-'. Hence invalid. + // This is either a '+' or '-'. Hence, invalid. return false; } idx_t cur_pos = start_pos; @@ -262,9 +262,8 @@ string Varint::VarcharToVarInt(const string_t &value) { return result; } -bool Varint::VarintToDouble(string_t &blob, double &result, bool &strict) { +bool Varint::VarintToDouble(const string_t &blob, double &result, bool &strict) { result = 0; - bool is_negative; if (blob.GetSize() < 4) { throw InvalidInputException("Invalid blob size."); @@ -272,7 +271,7 @@ bool Varint::VarintToDouble(string_t &blob, double &result, bool &strict) { auto blob_ptr = blob.GetData(); // Determine if the number is negative - is_negative = (blob_ptr[0] & 0x80) == 0; + bool is_negative = (blob_ptr[0] & 0x80) == 0; idx_t byte_pos = 0; for (idx_t i = blob.GetSize() - 1; i > 2; i--) { if (is_negative) { @@ -286,7 +285,11 @@ bool Varint::VarintToDouble(string_t &blob, double &result, bool &strict) { if (is_negative) { result *= -1; } - return std::isfinite(result); + if (!std::isfinite(result)) { + // We throw an error + throw ConversionException("Could not convert varint '%s' to Double", VarIntToVarchar(blob)); + } + return true; } } // namespace duckdb diff --git a/src/duckdb/src/function/table/arrow_conversion.cpp b/src/duckdb/src/function/table/arrow_conversion.cpp index 256e52c9..b83bbf56 100644 --- a/src/duckdb/src/function/table/arrow_conversion.cpp +++ b/src/duckdb/src/function/table/arrow_conversion.cpp @@ -476,7 +476,7 @@ static void UUIDConversion(Vector &vector, const ArrowArray &array, const ArrowS if (!validity_mask.RowIsValid(row)) { continue; } - tgt_ptr[row].lower = BSwap(src_ptr[row].upper); + tgt_ptr[row].lower = static_cast(BSwap(src_ptr[row].upper)); // flip Upper MSD tgt_ptr[row].upper = static_cast(static_cast(BSwap(src_ptr[row].lower)) ^ (static_cast(1) << 63)); diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp index d08fcf44..9ea02723 100644 --- a/src/duckdb/src/function/table/version/pragma_version.cpp +++ b/src/duckdb/src/function/table/version/pragma_version.cpp @@ -1,5 +1,5 @@ #ifndef DUCKDB_PATCH_VERSION -#define DUCKDB_PATCH_VERSION "1-dev5190" +#define DUCKDB_PATCH_VERSION "1-dev5272" #endif #ifndef DUCKDB_MINOR_VERSION #define DUCKDB_MINOR_VERSION 0 @@ -8,10 +8,10 @@ #define DUCKDB_MAJOR_VERSION 1 #endif #ifndef DUCKDB_VERSION -#define DUCKDB_VERSION "v1.0.1-dev5190" +#define DUCKDB_VERSION "v1.0.1-dev5272" #endif #ifndef DUCKDB_SOURCE_ID -#define DUCKDB_SOURCE_ID "ee74ca92ff" +#define DUCKDB_SOURCE_ID "4d18b9d05c" #endif #include "duckdb/function/table/system_functions.hpp" #include "duckdb/main/database.hpp" diff --git a/src/duckdb/src/include/duckdb.h b/src/duckdb/src/include/duckdb.h index 51878906..944134b7 100644 --- a/src/duckdb/src/include/duckdb.h +++ b/src/duckdb/src/include/duckdb.h @@ -16,11 +16,15 @@ //! duplicate of duckdb/main/winapi.hpp #ifndef DUCKDB_API #ifdef _WIN32 +#ifdef DUCKDB_STATIC_BUILD +#define DUCKDB_API +#else #if defined(DUCKDB_BUILD_LIBRARY) && !defined(DUCKDB_BUILD_LOADABLE_EXTENSION) #define DUCKDB_API __declspec(dllexport) #else #define DUCKDB_API __declspec(dllimport) #endif +#endif #else #define DUCKDB_API #endif @@ -29,11 +33,15 @@ //! duplicate of duckdb/main/winapi.hpp #ifndef DUCKDB_EXTENSION_API #ifdef _WIN32 +#ifdef DUCKDB_STATIC_BUILD +#define DUCKDB_EXTENSION_API +#else #ifdef DUCKDB_BUILD_LOADABLE_EXTENSION #define DUCKDB_EXTENSION_API __declspec(dllexport) #else #define DUCKDB_EXTENSION_API #endif +#endif #else #define DUCKDB_EXTENSION_API __attribute__((visibility("default"))) #endif diff --git a/src/duckdb/src/include/duckdb/common/types/varint.hpp b/src/duckdb/src/include/duckdb/common/types/varint.hpp index 34ac7707..023c2cfe 100644 --- a/src/duckdb/src/include/duckdb/common/types/varint.hpp +++ b/src/duckdb/src/include/duckdb/common/types/varint.hpp @@ -52,7 +52,7 @@ class Varint { //! Function to convert Varchar to VARINT blob DUCKDB_API static string VarcharToVarInt(const string_t &value); //! ----------------------------------- Double Cast ----------------------------------- // - DUCKDB_API static bool VarintToDouble(string_t &blob, double &result, bool &strict); + DUCKDB_API static bool VarintToDouble(const string_t &blob, double &result, bool &strict); }; //! ----------------------------------- (u)Integral Cast ----------------------------------- // diff --git a/src/duckdb/src/include/duckdb/common/winapi.hpp b/src/duckdb/src/include/duckdb/common/winapi.hpp index 1b77335c..6579a9ce 100644 --- a/src/duckdb/src/include/duckdb/common/winapi.hpp +++ b/src/duckdb/src/include/duckdb/common/winapi.hpp @@ -10,11 +10,15 @@ #ifndef DUCKDB_API #if defined(_WIN32) && !defined(__MINGW32__) +#ifdef DUCKDB_STATIC_BUILD +#define DUCKDB_API +#else #if defined(DUCKDB_BUILD_LIBRARY) && !defined(DUCKDB_BUILD_LOADABLE_EXTENSION) #define DUCKDB_API __declspec(dllexport) #else #define DUCKDB_API __declspec(dllimport) #endif +#endif #else #define DUCKDB_API #endif @@ -22,11 +26,15 @@ #ifndef DUCKDB_EXTENSION_API #ifdef _WIN32 +#ifdef DUCKDB_STATIC_BUILD +#define DUCKDB_EXTENSION_API +#else #ifdef DUCKDB_BUILD_LOADABLE_EXTENSION #define DUCKDB_EXTENSION_API __declspec(dllexport) #else #define DUCKDB_EXTENSION_API #endif +#endif #else #define DUCKDB_EXTENSION_API __attribute__((visibility("default"))) #endif diff --git a/src/duckdb/src/include/duckdb/main/extension_entries.hpp b/src/duckdb/src/include/duckdb/main/extension_entries.hpp index 76e4aa70..d4f86112 100644 --- a/src/duckdb/src/include/duckdb/main/extension_entries.hpp +++ b/src/duckdb/src/include/duckdb/main/extension_entries.hpp @@ -421,6 +421,7 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = { {"pg_connection_limit", "postgres_scanner"}, {"pg_debug_show_queries", "postgres_scanner"}, {"pg_experimental_filter_pushdown", "postgres_scanner"}, + {"pg_null_byte_replacement", "postgres_scanner"}, {"pg_pages_per_task", "postgres_scanner"}, {"pg_use_binary_copy", "postgres_scanner"}, {"pg_use_ctid_scan", "postgres_scanner"}, diff --git a/src/duckdb/src/include/duckdb/parser/transformer.hpp b/src/duckdb/src/include/duckdb/parser/transformer.hpp index 0646660c..760526b1 100644 --- a/src/duckdb/src/include/duckdb/parser/transformer.hpp +++ b/src/duckdb/src/include/duckdb/parser/transformer.hpp @@ -112,9 +112,8 @@ class Transformer { // Statement transformation //===--------------------------------------------------------------------===// //! Transform a Postgres duckdb_libpgquery::T_PGSelectStmt node into a SelectStatement - unique_ptr TransformSelect(optional_ptr node, bool is_select = true); - //! Transform a Postgres duckdb_libpgquery::T_PGSelectStmt node into a SelectStatement - unique_ptr TransformSelect(duckdb_libpgquery::PGSelectStmt &select, bool is_select = true); + unique_ptr TransformSelectStmt(duckdb_libpgquery::PGSelectStmt &select, bool is_select = true); + unique_ptr TransformSelectStmt(duckdb_libpgquery::PGNode &node, bool is_select = true); //! Transform a Postgres T_AlterStmt node into a AlterStatement unique_ptr TransformAlter(duckdb_libpgquery::PGAlterTableStmt &stmt); //! Transform a Postgres duckdb_libpgquery::T_PGRenameStmt node into a RenameStatement @@ -170,8 +169,10 @@ class Transformer { unique_ptr TransformImport(duckdb_libpgquery::PGImportStmt &stmt); unique_ptr TransformExplain(duckdb_libpgquery::PGExplainStmt &stmt); unique_ptr TransformVacuum(duckdb_libpgquery::PGVacuumStmt &stmt); - unique_ptr TransformShow(duckdb_libpgquery::PGVariableShowStmt &stmt); - unique_ptr TransformShowSelect(duckdb_libpgquery::PGVariableShowSelectStmt &stmt); + unique_ptr TransformShow(duckdb_libpgquery::PGVariableShowStmt &stmt); + unique_ptr TransformShowStmt(duckdb_libpgquery::PGVariableShowStmt &stmt); + unique_ptr TransformShowSelect(duckdb_libpgquery::PGVariableShowSelectStmt &stmt); + unique_ptr TransformShowSelectStmt(duckdb_libpgquery::PGVariableShowSelectStmt &stmt); unique_ptr TransformAttach(duckdb_libpgquery::PGAttachStmt &stmt); unique_ptr TransformDetach(duckdb_libpgquery::PGDetachStmt &stmt); unique_ptr TransformUse(duckdb_libpgquery::PGUseStmt &stmt); @@ -204,7 +205,8 @@ class Transformer { // Query Node Transform //===--------------------------------------------------------------------===// //! Transform a Postgres duckdb_libpgquery::T_PGSelectStmt node into a QueryNode - unique_ptr TransformSelectNode(duckdb_libpgquery::PGSelectStmt &select); + unique_ptr TransformSelectNode(duckdb_libpgquery::PGNode &select, bool is_select = true); + unique_ptr TransformSelectNodeInternal(duckdb_libpgquery::PGSelectStmt &select, bool is_select = true); unique_ptr TransformSelectInternal(duckdb_libpgquery::PGSelectStmt &select); void TransformModifiers(duckdb_libpgquery::PGSelectStmt &stmt, QueryNode &node); diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder.hpp index c454be64..eded041b 100644 --- a/src/duckdb/src/include/duckdb/planner/expression_binder.hpp +++ b/src/duckdb/src/include/duckdb/planner/expression_binder.hpp @@ -154,8 +154,6 @@ class ExpressionBinder { static LogicalType GetExpressionReturnType(const Expression &expr); private: - //! Maximum stack depth - static constexpr const idx_t MAXIMUM_STACK_DEPTH = 128; //! Current stack depth idx_t stack_depth = DConstants::INVALID_INDEX; @@ -204,6 +202,8 @@ class ExpressionBinder { virtual BindResult BindUnnest(FunctionExpression &expr, idx_t depth, bool root_expression); virtual BindResult BindMacro(FunctionExpression &expr, ScalarMacroCatalogEntry ¯o, idx_t depth, unique_ptr &expr_ptr); + void UnfoldMacroExpression(FunctionExpression &function, ScalarMacroCatalogEntry ¯o_func, + unique_ptr &expr); virtual string UnsupportedAggregateMessage(); virtual string UnsupportedUnnestMessage(); diff --git a/src/duckdb/src/main/buffered_data/simple_buffered_data.cpp b/src/duckdb/src/main/buffered_data/simple_buffered_data.cpp index dee90984..4b6a3a53 100644 --- a/src/duckdb/src/main/buffered_data/simple_buffered_data.cpp +++ b/src/duckdb/src/main/buffered_data/simple_buffered_data.cpp @@ -53,7 +53,9 @@ StreamExecutionResult SimpleBufferedData::ExecuteTaskInternal(StreamQueryResult if (!cc) { return StreamExecutionResult::EXECUTION_CANCELLED; } - + if (!cc->IsActiveResult(context_lock, result)) { + return StreamExecutionResult::EXECUTION_CANCELLED; + } if (BufferIsFull()) { // The buffer isn't empty yet, just return return StreamExecutionResult::CHUNK_READY; diff --git a/src/duckdb/src/main/extension/extension_helper.cpp b/src/duckdb/src/main/extension/extension_helper.cpp index 8baaea30..49483241 100644 --- a/src/duckdb/src/main/extension/extension_helper.cpp +++ b/src/duckdb/src/main/extension/extension_helper.cpp @@ -770,17 +770,6 @@ EMS5gLv50CzQqJXK9mNzPuYXNUIc4Pw4ssVWe0OfN3Od90gl5uFUwk/G9lWSYnBN static const char *const community_public_keys[] = { R"( -----BEGIN PUBLIC KEY----- -MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAv+Jki3aiZt0eOzShgD2g -BYPjPpkhHowOwPzUKtTVPob7vxyzd2wPyWDF/Zn6sN8QzravAdlXFE3SNF7ayO86 -IPHhMxO6P2YlxbipyKzPOUJsasXBiwYw2aSvb0RtwnYwD5lJs8Tz2ET1RQCFgXGc -LW7bDjKRbHSME0Me5rLRWVztOqULeoMeY1oCOmKKeAYxjFOASJJfQF9oQxkuu3j1 -qpcXnfHldlPGzFM77OFlWFtlc9QW4WNoxkO3HwskFW6ZRaQipM8vgSzkIfPFESGL -TtDRw+RcUPqmS6NVW8nhaiptBIMXy+9cP/l1LGmGwrZRhWP0YBlk6V9MUMzjyo+R -JQIDAQAB ------END PUBLIC KEY----- -)", - R"( ------BEGIN PUBLIC KEY----- MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtXl28loGwAH3ZGQXXgJQ 3omhIEiUb3z9Petjl+jmdtEQnMNUFEZiXkfJB02UFWBL1OoKKnjiGhcr5oGiIZKR CoaL6SfmWe//7o8STM44stE0exzZcv8W4tWwjrzSWQnwh2JgSnHN64xoDQjdvG3X diff --git a/src/duckdb/src/parser/parsed_data/create_index_info.cpp b/src/duckdb/src/parser/parsed_data/create_index_info.cpp index 3d41ea4f..01e2840f 100644 --- a/src/duckdb/src/parser/parsed_data/create_index_info.cpp +++ b/src/duckdb/src/parser/parsed_data/create_index_info.cpp @@ -8,9 +8,9 @@ CreateIndexInfo::CreateIndexInfo() : CreateInfo(CatalogType::INDEX_ENTRY, INVALI } CreateIndexInfo::CreateIndexInfo(const duckdb::CreateIndexInfo &info) - : CreateInfo(CatalogType::INDEX_ENTRY), table(info.table), index_name(info.index_name), options(info.options), - index_type(info.index_type), constraint_type(info.constraint_type), column_ids(info.column_ids), - scan_types(info.scan_types), names(info.names) { + : CreateInfo(CatalogType::INDEX_ENTRY, info.schema), table(info.table), index_name(info.index_name), + options(info.options), index_type(info.index_type), constraint_type(info.constraint_type), + column_ids(info.column_ids), scan_types(info.scan_types), names(info.names) { } static void RemoveTableQualificationRecursive(unique_ptr &expr, const string &table_name) { diff --git a/src/duckdb/src/parser/transform/expression/transform_subquery.cpp b/src/duckdb/src/parser/transform/expression/transform_subquery.cpp index 2a06d590..9d93b548 100644 --- a/src/duckdb/src/parser/transform/expression/transform_subquery.cpp +++ b/src/duckdb/src/parser/transform/expression/transform_subquery.cpp @@ -24,7 +24,7 @@ void RemoveOrderQualificationRecursive(unique_ptr &expr) { unique_ptr Transformer::TransformSubquery(duckdb_libpgquery::PGSubLink &root) { auto subquery_expr = make_uniq(); - subquery_expr->subquery = TransformSelect(root.subselect); + subquery_expr->subquery = TransformSelectStmt(*root.subselect); SetQueryLocation(*subquery_expr, root.location); D_ASSERT(subquery_expr->subquery); D_ASSERT(!subquery_expr->subquery->node->GetSelectList().empty()); diff --git a/src/duckdb/src/parser/transform/helpers/transform_cte.cpp b/src/duckdb/src/parser/transform/helpers/transform_cte.cpp index 0e216471..a344d730 100644 --- a/src/duckdb/src/parser/transform/helpers/transform_cte.cpp +++ b/src/duckdb/src/parser/transform/helpers/transform_cte.cpp @@ -70,8 +70,7 @@ void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause, info->query = TransformRecursiveCTE(cte, *info); } else { Transformer cte_transformer(*this); - info->query = - cte_transformer.TransformSelect(*PGPointerCast(cte.ctequery)); + info->query = cte_transformer.TransformSelectStmt(*cte.ctequery); } D_ASSERT(info->query); auto cte_name = string(cte.ctename); @@ -114,16 +113,20 @@ unique_ptr Transformer::TransformRecursiveCTE(duckdb_libpgquery auto with_clause = PGPointerCast(stmt.withClause); TransformCTE(*with_clause, result.cte_map); } - result.left = TransformSelectNode(*PGPointerCast(stmt.larg)); - result.right = TransformSelectNode(*PGPointerCast(stmt.rarg)); + result.left = TransformSelectNode(*stmt.larg); + result.right = TransformSelectNode(*stmt.rarg); result.aliases = info.aliases; break; } case duckdb_libpgquery::PG_SETOP_EXCEPT: case duckdb_libpgquery::PG_SETOP_INTERSECT: - default: + default: { // This CTE is not recursive. Fallback to regular query transformation. - return TransformSelect(*PGPointerCast(cte.ctequery)); + auto node = TransformSelectNode(*cte.ctequery); + auto result = make_uniq(); + result->node = std::move(node); + return result; + } } if (stmt.limitCount || stmt.limitOffset) { diff --git a/src/duckdb/src/parser/transform/statement/transform_copy.cpp b/src/duckdb/src/parser/transform/statement/transform_copy.cpp index 5da207dd..1fa2464f 100644 --- a/src/duckdb/src/parser/transform/statement/transform_copy.cpp +++ b/src/duckdb/src/parser/transform/statement/transform_copy.cpp @@ -117,7 +117,7 @@ unique_ptr Transformer::TransformCopy(duckdb_libpgquery::PGCopySt info.schema = table.schema_name; info.catalog = table.catalog_name; } else { - info.select_statement = TransformSelectNode(*PGPointerCast(stmt.query)); + info.select_statement = TransformSelectNode(*stmt.query); } // handle the different options of the COPY statement diff --git a/src/duckdb/src/parser/transform/statement/transform_create_function.cpp b/src/duckdb/src/parser/transform/statement/transform_create_function.cpp index fda65d8b..82917ee2 100644 --- a/src/duckdb/src/parser/transform/statement/transform_create_function.cpp +++ b/src/duckdb/src/parser/transform/statement/transform_create_function.cpp @@ -13,8 +13,7 @@ unique_ptr Transformer::TransformMacroFunction(duckdb_libpgquery: auto expression = TransformExpression(def.function); macro_func = make_uniq(std::move(expression)); } else if (def.query) { - auto query_node = - TransformSelect(*PGPointerCast(def.query), true)->node->Copy(); + auto query_node = TransformSelectNode(*def.query); macro_func = make_uniq(std::move(query_node)); } diff --git a/src/duckdb/src/parser/transform/statement/transform_create_table_as.cpp b/src/duckdb/src/parser/transform/statement/transform_create_table_as.cpp index 0c3406c2..6af7fe4e 100644 --- a/src/duckdb/src/parser/transform/statement/transform_create_table_as.cpp +++ b/src/duckdb/src/parser/transform/statement/transform_create_table_as.cpp @@ -15,7 +15,7 @@ unique_ptr Transformer::TransformCreateTableAs(duckdb_libpgquer if (stmt.query->type != duckdb_libpgquery::T_PGSelectStmt) { throw ParserException("CREATE TABLE AS requires a SELECT clause"); } - auto query = TransformSelect(stmt.query, false); + auto query = TransformSelectStmt(*stmt.query, false); auto result = make_uniq(); auto info = make_uniq(); diff --git a/src/duckdb/src/parser/transform/statement/transform_create_type.cpp b/src/duckdb/src/parser/transform/statement/transform_create_type.cpp index 3235ed3b..3b6753b6 100644 --- a/src/duckdb/src/parser/transform/statement/transform_create_type.cpp +++ b/src/duckdb/src/parser/transform/statement/transform_create_type.cpp @@ -49,7 +49,7 @@ unique_ptr Transformer::TransformCreateType(duckdb_libpgquery:: if (stmt.query) { // CREATE TYPE mood AS ENUM (SELECT ...) D_ASSERT(stmt.vals == nullptr); - auto query = TransformSelect(stmt.query, false); + auto query = TransformSelectStmt(*stmt.query, false); info->query = std::move(query); info->type = LogicalType::INVALID; } else { diff --git a/src/duckdb/src/parser/transform/statement/transform_create_view.cpp b/src/duckdb/src/parser/transform/statement/transform_create_view.cpp index 0f3cac00..8504ecfc 100644 --- a/src/duckdb/src/parser/transform/statement/transform_create_view.cpp +++ b/src/duckdb/src/parser/transform/statement/transform_create_view.cpp @@ -21,7 +21,7 @@ unique_ptr Transformer::TransformCreateView(duckdb_libpgquery:: } info->on_conflict = TransformOnConflict(stmt.onconflict); - info->query = TransformSelect(*PGPointerCast(stmt.query), false); + info->query = TransformSelectStmt(*PGPointerCast(stmt.query), false); PivotEntryCheck("view"); diff --git a/src/duckdb/src/parser/transform/statement/transform_insert.cpp b/src/duckdb/src/parser/transform/statement/transform_insert.cpp index dfa3c250..57c895cf 100644 --- a/src/duckdb/src/parser/transform/statement/transform_insert.cpp +++ b/src/duckdb/src/parser/transform/statement/transform_insert.cpp @@ -41,7 +41,7 @@ unique_ptr Transformer::TransformInsert(duckdb_libpgquery::PGIn TransformExpressionList(*stmt.returningList, result->returning_list); } if (stmt.selectStmt) { - result->select_statement = TransformSelect(stmt.selectStmt, false); + result->select_statement = TransformSelectStmt(*stmt.selectStmt, false); } else { result->default_values = true; } diff --git a/src/duckdb/src/parser/transform/statement/transform_select.cpp b/src/duckdb/src/parser/transform/statement/transform_select.cpp index 7b85d1f5..2e5135ef 100644 --- a/src/duckdb/src/parser/transform/statement/transform_select.cpp +++ b/src/duckdb/src/parser/transform/statement/transform_select.cpp @@ -4,20 +4,19 @@ namespace duckdb { -unique_ptr Transformer::TransformSelectNode(duckdb_libpgquery::PGSelectStmt &select) { - unique_ptr stmt = nullptr; - if (select.pivot) { - stmt = TransformPivotStatement(select); - } else { - stmt = TransformSelectInternal(select); +unique_ptr Transformer::TransformSelectNode(duckdb_libpgquery::PGNode &node, bool is_select) { + switch (node.type) { + case duckdb_libpgquery::T_PGVariableShowSelectStmt: + return TransformShowSelect(PGCast(node)); + case duckdb_libpgquery::T_PGVariableShowStmt: + return TransformShow(PGCast(node)); + default: + return TransformSelectNodeInternal(PGCast(node), is_select); } - - return TransformMaterializedCTE(std::move(stmt)); } -unique_ptr Transformer::TransformSelect(duckdb_libpgquery::PGSelectStmt &select, bool is_select) { - auto result = make_uniq(); - +unique_ptr Transformer::TransformSelectNodeInternal(duckdb_libpgquery::PGSelectStmt &select, + bool is_select) { // Both Insert/Create Table As uses this. if (is_select) { if (select.intoClause) { @@ -27,20 +26,26 @@ unique_ptr Transformer::TransformSelect(duckdb_libpgquery::PGSe throw ParserException("SELECT locking clause is not supported!"); } } + unique_ptr stmt = nullptr; + if (select.pivot) { + stmt = TransformPivotStatement(select); + } else { + stmt = TransformSelectInternal(select); + } + return TransformMaterializedCTE(std::move(stmt)); +} - result->node = TransformSelectNode(select); +unique_ptr Transformer::TransformSelectStmt(duckdb_libpgquery::PGSelectStmt &select, bool is_select) { + auto result = make_uniq(); + result->node = TransformSelectNodeInternal(select, is_select); return result; } -unique_ptr Transformer::TransformSelect(optional_ptr node, bool is_select) { - switch (node->type) { - case duckdb_libpgquery::T_PGVariableShowSelectStmt: - return TransformShowSelect(PGCast(*node)); - case duckdb_libpgquery::T_PGVariableShowStmt: - return TransformShow(PGCast(*node)); - default: - return TransformSelect(PGCast(*node), is_select); - } +unique_ptr Transformer::TransformSelectStmt(duckdb_libpgquery::PGNode &node, bool is_select) { + auto select_node = TransformSelectNode(node, is_select); + auto select_statement = make_uniq(); + select_statement->node = std::move(select_node); + return select_statement; } } // namespace duckdb diff --git a/src/duckdb/src/parser/transform/statement/transform_show.cpp b/src/duckdb/src/parser/transform/statement/transform_show.cpp index c80ea92a..12e6d686 100644 --- a/src/duckdb/src/parser/transform/statement/transform_show.cpp +++ b/src/duckdb/src/parser/transform/statement/transform_show.cpp @@ -9,7 +9,7 @@ namespace duckdb { -unique_ptr Transformer::TransformShow(duckdb_libpgquery::PGVariableShowStmt &stmt) { +unique_ptr Transformer::TransformShow(duckdb_libpgquery::PGVariableShowStmt &stmt) { string name = stmt.name; auto select_node = make_uniq(); @@ -18,9 +18,12 @@ unique_ptr Transformer::TransformShow(duckdb_libpgquery::PGVari showref->table_name = std::move(name); showref->show_type = stmt.is_summary ? ShowType::SUMMARY : ShowType::DESCRIBE; select_node->from_table = std::move(showref); + return std::move(select_node); +} +unique_ptr Transformer::TransformShowStmt(duckdb_libpgquery::PGVariableShowStmt &stmt) { auto result = make_uniq(); - result->node = std::move(select_node); + result->node = TransformShow(stmt); return result; } diff --git a/src/duckdb/src/parser/transform/statement/transform_show_select.cpp b/src/duckdb/src/parser/transform/statement/transform_show_select.cpp index 78e19d17..bd6f52a8 100644 --- a/src/duckdb/src/parser/transform/statement/transform_show_select.cpp +++ b/src/duckdb/src/parser/transform/statement/transform_show_select.cpp @@ -7,19 +7,21 @@ namespace duckdb { -unique_ptr Transformer::TransformShowSelect(duckdb_libpgquery::PGVariableShowSelectStmt &stmt) { +unique_ptr Transformer::TransformShowSelect(duckdb_libpgquery::PGVariableShowSelectStmt &stmt) { // we capture the select statement of SHOW auto select_node = make_uniq(); select_node->select_list.push_back(make_uniq()); auto show_ref = make_uniq(); show_ref->show_type = stmt.is_summary ? ShowType::SUMMARY : ShowType::DESCRIBE; - auto select = TransformSelect(stmt.stmt); - show_ref->query = std::move(select->node); + show_ref->query = TransformSelectNode(*stmt.stmt); select_node->from_table = std::move(show_ref); + return std::move(select_node); +} +unique_ptr Transformer::TransformShowSelectStmt(duckdb_libpgquery::PGVariableShowSelectStmt &stmt) { auto result = make_uniq(); - result->node = std::move(select_node); + result->node = TransformShowSelect(stmt); return result; } diff --git a/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp b/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp index 1223994d..62ca0e1b 100644 --- a/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp +++ b/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp @@ -79,7 +79,7 @@ PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot, } } if (pivot.subquery) { - col.subquery = TransformSelectNode(*PGPointerCast(pivot.subquery)); + col.subquery = TransformSelectNode(*pivot.subquery); } if (pivot.pivot_enum) { col.pivot_enum = pivot.pivot_enum; diff --git a/src/duckdb/src/parser/transform/tableref/transform_subquery.cpp b/src/duckdb/src/parser/transform/tableref/transform_subquery.cpp index 1d5105ad..58c61811 100644 --- a/src/duckdb/src/parser/transform/tableref/transform_subquery.cpp +++ b/src/duckdb/src/parser/transform/tableref/transform_subquery.cpp @@ -5,7 +5,7 @@ namespace duckdb { unique_ptr Transformer::TransformRangeSubselect(duckdb_libpgquery::PGRangeSubselect &root) { Transformer subquery_transformer(*this); - auto subquery = subquery_transformer.TransformSelect(root.subquery); + auto subquery = subquery_transformer.TransformSelectStmt(*root.subquery); if (!subquery) { return nullptr; } diff --git a/src/duckdb/src/parser/transformer.cpp b/src/duckdb/src/parser/transformer.cpp index 6a30a9d3..123a3b5f 100644 --- a/src/duckdb/src/parser/transformer.cpp +++ b/src/duckdb/src/parser/transformer.cpp @@ -144,7 +144,7 @@ unique_ptr Transformer::TransformStatementInternal(duckdb_libpgque return result; } case duckdb_libpgquery::T_PGSelectStmt: - return TransformSelect(PGCast(stmt)); + return TransformSelectStmt(PGCast(stmt)); case duckdb_libpgquery::T_PGCreateStmt: return TransformCreateTable(PGCast(stmt)); case duckdb_libpgquery::T_PGCreateSchemaStmt: @@ -194,9 +194,9 @@ unique_ptr Transformer::TransformStatementInternal(duckdb_libpgque case duckdb_libpgquery::T_PGVacuumStmt: return TransformVacuum(PGCast(stmt)); case duckdb_libpgquery::T_PGVariableShowStmt: - return TransformShow(PGCast(stmt)); + return TransformShowStmt(PGCast(stmt)); case duckdb_libpgquery::T_PGVariableShowSelectStmt: - return TransformShowSelect(PGCast(stmt)); + return TransformShowSelectStmt(PGCast(stmt)); case duckdb_libpgquery::T_PGCallStmt: return TransformCall(PGCast(stmt)); case duckdb_libpgquery::T_PGVariableSetStmt: diff --git a/src/duckdb/src/planner/binder/expression/bind_macro_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_macro_expression.cpp index ffb9a72d..caa6ba77 100644 --- a/src/duckdb/src/planner/binder/expression/bind_macro_expression.cpp +++ b/src/duckdb/src/planner/binder/expression/bind_macro_expression.cpp @@ -99,8 +99,8 @@ void ExpressionBinder::ReplaceMacroParameters(unique_ptr &expr *expr, [&](unique_ptr &child) { ReplaceMacroParameters(child, lambda_params); }); } -BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacroCatalogEntry ¯o_func, idx_t depth, - unique_ptr &expr) { +void ExpressionBinder::UnfoldMacroExpression(FunctionExpression &function, ScalarMacroCatalogEntry ¯o_func, + unique_ptr &expr) { // validate the arguments and separate positional and default arguments vector> positionals; unordered_map> defaults; @@ -143,6 +143,14 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacro // now replace the parameters vector> lambda_params; ReplaceMacroParameters(expr, lambda_params); +} + +BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacroCatalogEntry ¯o_func, idx_t depth, + unique_ptr &expr) { + auto stack_checker = StackCheck(*expr, 3); + + // unfold the macro expression + UnfoldMacroExpression(function, macro_func, expr); // bind the unfolded macro return BindExpression(expr, depth); diff --git a/src/duckdb/src/planner/binder/statement/bind_create.cpp b/src/duckdb/src/planner/binder/statement/bind_create.cpp index c461713e..f03f260c 100644 --- a/src/duckdb/src/planner/binder/statement/bind_create.cpp +++ b/src/duckdb/src/planner/binder/statement/bind_create.cpp @@ -588,6 +588,7 @@ unique_ptr DuckCatalog::BindCreateIndex(Binder &binder, CreateS create_index_info->scan_types.emplace_back(LogicalType::ROW_TYPE); create_index_info->names = get.names; create_index_info->column_ids = column_ids; + create_index_info->schema = table.schema.name; auto &bind_data = get.bind_data->Cast(); bind_data.is_create_index = true; get.AddColumnId(COLUMN_IDENTIFIER_ROW_ID); diff --git a/src/duckdb/src/planner/binder/statement/bind_insert.cpp b/src/duckdb/src/planner/binder/statement/bind_insert.cpp index ac430ede..f02be800 100644 --- a/src/duckdb/src/planner/binder/statement/bind_insert.cpp +++ b/src/duckdb/src/planner/binder/statement/bind_insert.cpp @@ -295,7 +295,7 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl auto entry = specified_columns.find(col.Name()); if (entry != specified_columns.end()) { // column was specified, set to the index - insert.on_conflict_filter.insert(col.Oid()); + insert.on_conflict_filter.insert(col.Physical().index); } } bool index_references_columns = false; @@ -353,8 +353,12 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl // add a bind context entry for it auto excluded_index = GenerateTableIndex(); insert.excluded_table_index = excluded_index; - auto table_column_names = columns.GetColumnNames(); - auto table_column_types = columns.GetColumnTypes(); + vector table_column_names; + vector table_column_types; + for (auto &col : columns.Physical()) { + table_column_names.push_back(col.Name()); + table_column_types.push_back(col.Type()); + } bind_context.AddGenericBinding(excluded_index, "excluded", table_column_names, table_column_types); if (on_conflict.condition) { diff --git a/src/duckdb/src/planner/expression_binder.cpp b/src/duckdb/src/planner/expression_binder.cpp index e26d04ae..146f1790 100644 --- a/src/duckdb/src/planner/expression_binder.cpp +++ b/src/duckdb/src/planner/expression_binder.cpp @@ -7,6 +7,7 @@ #include "duckdb/planner/expression/list.hpp" #include "duckdb/planner/expression_iterator.hpp" #include "duckdb/common/operator/cast_operators.hpp" +#include "duckdb/main/client_config.hpp" namespace duckdb { @@ -36,18 +37,21 @@ ExpressionBinder::~ExpressionBinder() { } void ExpressionBinder::InitializeStackCheck() { + static constexpr idx_t INITIAL_DEPTH = 5; if (binder.HasActiveBinder()) { - stack_depth = binder.GetActiveBinder().stack_depth; + stack_depth = binder.GetActiveBinder().stack_depth + INITIAL_DEPTH; } else { - stack_depth = 0; + stack_depth = INITIAL_DEPTH; } } StackChecker ExpressionBinder::StackCheck(const ParsedExpression &expr, idx_t extra_stack) { D_ASSERT(stack_depth != DConstants::INVALID_INDEX); - if (stack_depth + extra_stack >= MAXIMUM_STACK_DEPTH) { - throw BinderException("Maximum recursion depth exceeded (Maximum: %llu) while binding \"%s\"", - MAXIMUM_STACK_DEPTH, expr.ToString()); + auto &options = ClientConfig::GetConfig(context); + if (stack_depth + extra_stack >= options.max_expression_depth) { + throw BinderException("Max expression depth limit of %lld exceeded. Use \"SET max_expression_depth TO x\" to " + "increase the maximum expression depth.", + options.max_expression_depth); } return StackChecker(*this, extra_stack); } diff --git a/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp b/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp index 5410e53c..c58be310 100644 --- a/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp +++ b/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp @@ -87,6 +87,8 @@ void WriteOverflowStringsToDisk::Flush() { // write to disk auto &block_manager = partial_block_manager.GetBlockManager(); block_manager.Write(handle.GetFileBuffer(), block_id); + + auto lock = partial_block_manager.GetLock(); partial_block_manager.AddWrittenBlock(block_id); } block_id = INVALID_BLOCK; diff --git a/src/duckdb/src/storage/wal_replay.cpp b/src/duckdb/src/storage/wal_replay.cpp index 85fe1bf3..890a5a61 100644 --- a/src/duckdb/src/storage/wal_replay.cpp +++ b/src/duckdb/src/storage/wal_replay.cpp @@ -87,10 +87,9 @@ class WriteAheadLogDeserializer { // compute and verify the checksum auto computed_checksum = Checksum(buffer.get(), size); if (stored_checksum != computed_checksum) { - throw SerializationException( - "Corrupt WAL file: entry at byte position %llu computed checksum %llu does not match " - "stored checksum %llu", - offset, computed_checksum, stored_checksum); + throw IOException("Corrupt WAL file: entry at byte position %llu computed checksum %llu does not match " + "stored checksum %llu", + offset, computed_checksum, stored_checksum); } return WriteAheadLogDeserializer(state_p, std::move(buffer), size, deserialize_only); } diff --git a/src/duckdb/third_party/libpg_query/include/nodes/parsenodes.hpp b/src/duckdb/third_party/libpg_query/include/nodes/parsenodes.hpp index 82302a18..19fdc6f5 100644 --- a/src/duckdb/third_party/libpg_query/include/nodes/parsenodes.hpp +++ b/src/duckdb/third_party/libpg_query/include/nodes/parsenodes.hpp @@ -1287,8 +1287,8 @@ typedef struct PGSelectStmt { */ PGSetOperation op; /* type of set op */ bool all; /* ALL specified? */ - struct PGSelectStmt *larg; /* left child */ - struct PGSelectStmt *rarg; /* right child */ + struct PGNode *larg; /* left child */ + struct PGNode *rarg; /* right child */ /* Eventually add fields for CORRESPONDING spec here */ } PGSelectStmt; diff --git a/src/duckdb/third_party/libpg_query/src_backend_parser_gram.cpp b/src/duckdb/third_party/libpg_query/src_backend_parser_gram.cpp index 77f152c4..5e3b28c0 100644 --- a/src/duckdb/third_party/libpg_query/src_backend_parser_gram.cpp +++ b/src/duckdb/third_party/libpg_query/src_backend_parser_gram.cpp @@ -31729,8 +31729,8 @@ makeSetOp(PGSetOperation op, bool all, PGNode *larg, PGNode *rarg) n->op = op; n->all = all; - n->larg = (PGSelectStmt *) larg; - n->rarg = (PGSelectStmt *) rarg; + n->larg = larg; + n->rarg = rarg; return (PGNode *) n; }