diff --git a/src/duckdb_py/duckdb_python.cpp b/src/duckdb_py/duckdb_python.cpp index 98c3bd13..7683627f 100644 --- a/src/duckdb_py/duckdb_python.cpp +++ b/src/duckdb_py/duckdb_python.cpp @@ -76,7 +76,7 @@ static void InitializeConnectionMethods(py::module_ &m) { // START_OF_CONNECTION_METHODS m.def( "cursor", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -85,7 +85,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "Create a duplicate of the current connection", py::kw_only(), py::arg("connection") = py::none()); m.def( "register_filesystem", - [](AbstractFileSystem filesystem, shared_ptr conn = nullptr) { + [](AbstractFileSystem filesystem, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -95,7 +95,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "unregister_filesystem", - [](const py::str &name, shared_ptr conn = nullptr) { + [](const py::str &name, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -104,7 +104,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "Unregister a filesystem", py::arg("name"), py::kw_only(), py::arg("connection") = py::none()); m.def( "list_filesystems", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -113,7 +113,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "List registered filesystems, including builtin ones", py::kw_only(), py::arg("connection") = py::none()); m.def( "filesystem_is_registered", - [](const string &name, shared_ptr conn = nullptr) { + [](const string &name, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -123,7 +123,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "get_profiling_information", - [](const std::string &format, shared_ptr conn = nullptr) { + [](const std::string &format, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -133,7 +133,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "enable_profiling", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -142,7 +142,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "Enable profiling for the current connection", py::kw_only(), py::arg("connection") = py::none()); m.def( "disable_profiling", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -152,10 +152,10 @@ static void InitializeConnectionMethods(py::module_ &m) { m.def( "create_function", [](const string &name, const py::function &udf, const py::object &arguments = py::none(), - const shared_ptr &return_type = nullptr, PythonUDFType type = PythonUDFType::NATIVE, + const std::shared_ptr &return_type = nullptr, PythonUDFType type = PythonUDFType::NATIVE, FunctionNullHandling null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING, PythonExceptionHandling exception_handling = PythonExceptionHandling::FORWARD_ERROR, - bool side_effects = false, shared_ptr conn = nullptr) { + bool side_effects = false, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -169,7 +169,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "remove_function", - [](const string &name, shared_ptr conn = nullptr) { + [](const string &name, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -178,7 +178,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "Remove a previously created function", py::arg("name"), py::kw_only(), py::arg("connection") = py::none()); m.def( "sqltype", - [](const string &type_str, shared_ptr conn = nullptr) { + [](const string &type_str, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -188,7 +188,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "dtype", - [](const string &type_str, shared_ptr conn = nullptr) { + [](const string &type_str, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -198,7 +198,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "type", - [](const string &type_str, shared_ptr conn = nullptr) { + [](const string &type_str, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -208,7 +208,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "array_type", - [](const shared_ptr &type, idx_t size, shared_ptr conn = nullptr) { + [](const std::shared_ptr &type, idx_t size, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -218,7 +218,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "list_type", - [](const shared_ptr &type, shared_ptr conn = nullptr) { + [](const std::shared_ptr &type, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -228,7 +228,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "union_type", - [](const py::object &members, shared_ptr conn = nullptr) { + [](const py::object &members, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -238,7 +238,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "string_type", - [](const string &collation = string(), shared_ptr conn = nullptr) { + [](const string &collation = string(), std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -248,8 +248,8 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "enum_type", - [](const string &name, const shared_ptr &type, const py::list &values_p, - shared_ptr conn = nullptr) { + [](const string &name, const std::shared_ptr &type, const py::list &values_p, + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -259,7 +259,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("type"), py::arg("values"), py::kw_only(), py::arg("connection") = py::none()); m.def( "decimal_type", - [](int width, int scale, shared_ptr conn = nullptr) { + [](int width, int scale, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -269,7 +269,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "struct_type", - [](const py::object &fields, shared_ptr conn = nullptr) { + [](const py::object &fields, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -279,7 +279,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "row_type", - [](const py::object &fields, shared_ptr conn = nullptr) { + [](const py::object &fields, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -289,8 +289,8 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "map_type", - [](const shared_ptr &key_type, const shared_ptr &value_type, - shared_ptr conn = nullptr) { + [](const std::shared_ptr &key_type, const std::shared_ptr &value_type, + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -300,7 +300,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("value").none(false), py::kw_only(), py::arg("connection") = py::none()); m.def( "duplicate", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -309,7 +309,8 @@ static void InitializeConnectionMethods(py::module_ &m) { "Create a duplicate of the current connection", py::kw_only(), py::arg("connection") = py::none()); m.def( "execute", - [](const py::object &query, py::object params = py::list(), shared_ptr conn = nullptr) { + [](const py::object &query, py::object params = py::list(), + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -319,7 +320,8 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("parameters") = py::none(), py::kw_only(), py::arg("connection") = py::none()); m.def( "executemany", - [](const py::object &query, py::object params = py::list(), shared_ptr conn = nullptr) { + [](const py::object &query, py::object params = py::list(), + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -329,7 +331,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("query"), py::arg("parameters") = py::none(), py::kw_only(), py::arg("connection") = py::none()); m.def( "close", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -338,7 +340,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "Close the connection", py::kw_only(), py::arg("connection") = py::none()); m.def( "interrupt", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -347,7 +349,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "Interrupt pending operations", py::kw_only(), py::arg("connection") = py::none()); m.def( "query_progress", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -356,7 +358,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "Query progress of pending operation", py::kw_only(), py::arg("connection") = py::none()); m.def( "fetchone", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -365,7 +367,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "Fetch a single row from a result following execute", py::kw_only(), py::arg("connection") = py::none()); m.def( "fetchmany", - [](idx_t size, shared_ptr conn = nullptr) { + [](idx_t size, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -375,7 +377,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "fetchall", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -384,7 +386,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "Fetch all rows from a result following execute", py::kw_only(), py::arg("connection") = py::none()); m.def( "fetchnumpy", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -393,7 +395,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "Fetch a result as list of NumPy arrays following execute", py::kw_only(), py::arg("connection") = py::none()); m.def( "fetchdf", - [](bool date_as_object, shared_ptr conn = nullptr) { + [](bool date_as_object, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -403,7 +405,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "fetch_df", - [](bool date_as_object, shared_ptr conn = nullptr) { + [](bool date_as_object, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -413,7 +415,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "df", - [](bool date_as_object, shared_ptr conn = nullptr) { + [](bool date_as_object, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -424,7 +426,7 @@ static void InitializeConnectionMethods(py::module_ &m) { m.def( "fetch_df_chunk", [](const idx_t vectors_per_chunk = 1, bool date_as_object = false, - shared_ptr conn = nullptr) { + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -434,7 +436,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("date_as_object") = false, py::arg("connection") = py::none()); m.def( "pl", - [](idx_t rows_per_batch, bool lazy, shared_ptr conn = nullptr) { + [](idx_t rows_per_batch, bool lazy, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -444,7 +446,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("lazy") = false, py::arg("connection") = py::none()); m.def( "to_arrow_table", - [](idx_t batch_size, shared_ptr conn = nullptr) { + [](idx_t batch_size, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -454,7 +456,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "to_arrow_reader", - [](idx_t batch_size, shared_ptr conn = nullptr) { + [](idx_t batch_size, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -464,7 +466,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "fetch_arrow_table", - [](idx_t rows_per_batch, shared_ptr conn = nullptr) { + [](idx_t rows_per_batch, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -476,7 +478,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "fetch_record_batch", - [](const idx_t rows_per_batch, shared_ptr conn = nullptr) { + [](const idx_t rows_per_batch, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -488,7 +490,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "torch", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -498,7 +500,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "tf", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -508,7 +510,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "begin", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -517,7 +519,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "Start a new transaction", py::kw_only(), py::arg("connection") = py::none()); m.def( "commit", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -526,7 +528,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "Commit changes performed within a transaction", py::kw_only(), py::arg("connection") = py::none()); m.def( "rollback", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -535,7 +537,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "Roll back changes performed within a transaction", py::kw_only(), py::arg("connection") = py::none()); m.def( "checkpoint", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -546,7 +548,7 @@ static void InitializeConnectionMethods(py::module_ &m) { m.def( "append", [](const string &name, const PandasDataFrame &value, bool by_name, - shared_ptr conn = nullptr) { + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -556,7 +558,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("by_name") = false, py::arg("connection") = py::none()); m.def( "register", - [](const string &name, const py::object &python_object, shared_ptr conn = nullptr) { + [](const string &name, const py::object &python_object, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -566,7 +568,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("python_object"), py::kw_only(), py::arg("connection") = py::none()); m.def( "unregister", - [](const string &name, shared_ptr conn = nullptr) { + [](const string &name, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -575,7 +577,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "Unregister the view name", py::arg("view_name"), py::kw_only(), py::arg("connection") = py::none()); m.def( "table", - [](const string &tname, shared_ptr conn = nullptr) { + [](const string &tname, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -585,7 +587,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "view", - [](const string &vname, shared_ptr conn = nullptr) { + [](const string &vname, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -595,7 +597,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "values", - [](const py::args ¶ms, shared_ptr conn = nullptr) { + [](const py::args ¶ms, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -604,7 +606,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "Create a relation object from the passed values", py::kw_only(), py::arg("connection") = py::none()); m.def( "table_function", - [](const string &fname, py::object params = py::list(), shared_ptr conn = nullptr) { + [](const string &fname, py::object params = py::list(), std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -630,7 +632,7 @@ static void InitializeConnectionMethods(py::module_ &m) { const Optional &hive_partitioning = py::none(), const Optional &union_by_name = py::none(), const Optional &hive_types = py::none(), const Optional &hive_types_autocast = py::none(), - shared_ptr conn = nullptr) { + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -652,7 +654,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("hive_types_autocast") = py::none(), py::arg("connection") = py::none()); m.def( "extract_statements", - [](const string &query, shared_ptr conn = nullptr) { + [](const string &query, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -663,7 +665,7 @@ static void InitializeConnectionMethods(py::module_ &m) { m.def( "sql", [](const py::object &query, string alias = "", py::object params = py::list(), - shared_ptr conn = nullptr) { + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -676,7 +678,7 @@ static void InitializeConnectionMethods(py::module_ &m) { m.def( "query", [](const py::object &query, string alias = "", py::object params = py::list(), - shared_ptr conn = nullptr) { + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -689,7 +691,7 @@ static void InitializeConnectionMethods(py::module_ &m) { m.def( "from_query", [](const py::object &query, string alias = "", py::object params = py::list(), - shared_ptr conn = nullptr) { + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -703,7 +705,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "read_csv", [](const py::object &name, py::kwargs &kwargs) { auto connection_arg = kwargs.contains("conn") ? kwargs["conn"] : py::none(); - auto conn = py::cast>(connection_arg); + auto conn = py::cast>(connection_arg); if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); @@ -715,7 +717,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "from_csv_auto", [](const py::object &name, py::kwargs &kwargs) { auto connection_arg = kwargs.contains("conn") ? kwargs["conn"] : py::none(); - auto conn = py::cast>(connection_arg); + auto conn = py::cast>(connection_arg); if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); @@ -725,7 +727,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "Create a relation object from the CSV file in 'name'", py::arg("path_or_buffer"), py::kw_only()); m.def( "from_df", - [](const PandasDataFrame &value, shared_ptr conn = nullptr) { + [](const PandasDataFrame &value, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -735,7 +737,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "from_arrow", - [](py::object &arrow_object, shared_ptr conn = nullptr) { + [](py::object &arrow_object, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -747,7 +749,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "from_parquet", [](const py::object &path_or_buffer, bool binary_as_string, bool file_row_number, bool filename, bool hive_partitioning, bool union_by_name, const py::object &compression = py::none(), - shared_ptr conn = nullptr) { + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -762,7 +764,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "read_parquet", [](const py::object &path_or_buffer, bool binary_as_string, bool file_row_number, bool filename, bool hive_partitioning, bool union_by_name, const py::object &compression = py::none(), - shared_ptr conn = nullptr) { + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -775,7 +777,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("union_by_name") = false, py::arg("compression") = py::none(), py::arg("connection") = py::none()); m.def( "get_table_names", - [](const string &query, bool qualified, shared_ptr conn = nullptr) { + [](const string &query, bool qualified, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -787,7 +789,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "install_extension", [](const string &extension, bool force_install = false, const py::object &repository = py::none(), const py::object &repository_url = py::none(), const py::object &version = py::none(), - shared_ptr conn = nullptr) { + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -798,7 +800,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("repository_url") = py::none(), py::arg("version") = py::none(), py::arg("connection") = py::none()); m.def( "load_extension", - [](const string &extension, shared_ptr conn = nullptr) { + [](const string &extension, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -808,7 +810,7 @@ static void InitializeConnectionMethods(py::module_ &m) { m.def( "project", [](const PandasDataFrame &df, const py::args &args, const string &groups = "", - shared_ptr conn = nullptr) { + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -818,7 +820,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("groups") = "", py::arg("connection") = py::none()); m.def( "distinct", - [](const PandasDataFrame &df, shared_ptr conn = nullptr) { + [](const PandasDataFrame &df, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -836,7 +838,7 @@ static void InitializeConnectionMethods(py::module_ &m) { const py::object &compression = py::none(), const py::object &overwrite = py::none(), const py::object &per_thread_output = py::none(), const py::object &use_tmp_file = py::none(), const py::object &partition_by = py::none(), const py::object &write_partition_columns = py::none(), - shared_ptr conn = nullptr) { + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -855,7 +857,7 @@ static void InitializeConnectionMethods(py::module_ &m) { m.def( "aggregate", [](const PandasDataFrame &df, const py::object &expr, const string &groups = "", - shared_ptr conn = nullptr) { + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -865,7 +867,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("aggr_expr"), py::arg("group_expr") = "", py::kw_only(), py::arg("connection") = py::none()); m.def( "alias", - [](const PandasDataFrame &df, const string &expr, shared_ptr conn = nullptr) { + [](const PandasDataFrame &df, const string &expr, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -875,7 +877,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "filter", - [](const PandasDataFrame &df, const py::object &expr, shared_ptr conn = nullptr) { + [](const PandasDataFrame &df, const py::object &expr, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -885,7 +887,8 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "limit", - [](const PandasDataFrame &df, int64_t n, int64_t offset = 0, shared_ptr conn = nullptr) { + [](const PandasDataFrame &df, int64_t n, int64_t offset = 0, + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -895,7 +898,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("offset") = 0, py::kw_only(), py::arg("connection") = py::none()); m.def( "order", - [](const PandasDataFrame &df, const string &expr, shared_ptr conn = nullptr) { + [](const PandasDataFrame &df, const string &expr, std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -906,7 +909,7 @@ static void InitializeConnectionMethods(py::module_ &m) { m.def( "query_df", [](const PandasDataFrame &df, const string &view_name, const string &sql_query, - shared_ptr conn = nullptr) { + std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -917,7 +920,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "description", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -926,7 +929,7 @@ static void InitializeConnectionMethods(py::module_ &m) { "Get result set attributes, mainly column names", py::kw_only(), py::arg("connection") = py::none()); m.def( "rowcount", - [](shared_ptr conn = nullptr) { + [](std::shared_ptr conn = nullptr) { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -938,7 +941,7 @@ static void InitializeConnectionMethods(py::module_ &m) { // We define these "wrapper" methods manually because they are overloaded m.def( "arrow", - [](idx_t rows_per_batch, shared_ptr conn) -> duckdb::pyarrow::RecordBatchReader { + [](idx_t rows_per_batch, std::shared_ptr conn) -> duckdb::pyarrow::RecordBatchReader { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -948,7 +951,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("rows_per_batch") = 1000000, py::kw_only(), py::arg("connection") = py::none()); m.def( "arrow", - [](py::object &arrow_object, shared_ptr conn) -> unique_ptr { + [](py::object &arrow_object, std::shared_ptr conn) -> std::unique_ptr { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -958,7 +961,7 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "df", - [](bool date_as_object, shared_ptr conn) -> PandasDataFrame { + [](bool date_as_object, std::shared_ptr conn) -> PandasDataFrame { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } @@ -968,7 +971,8 @@ static void InitializeConnectionMethods(py::module_ &m) { py::arg("connection") = py::none()); m.def( "df", - [](const PandasDataFrame &value, shared_ptr conn) -> unique_ptr { + [](const PandasDataFrame &value, + std::shared_ptr conn) -> std::unique_ptr { if (!conn) { conn = DuckDBPyConnection::DefaultConnection(); } diff --git a/src/duckdb_py/include/duckdb_python/expression/pyexpression.hpp b/src/duckdb_py/include/duckdb_python/expression/pyexpression.hpp index 43c0c5c3..2e741cd8 100644 --- a/src/duckdb_py/include/duckdb_python/expression/pyexpression.hpp +++ b/src/duckdb_py/include/duckdb_python/expression/pyexpression.hpp @@ -23,14 +23,14 @@ namespace duckdb { -struct DuckDBPyExpression : public enable_shared_from_this { +struct DuckDBPyExpression : public std::enable_shared_from_this { public: explicit DuckDBPyExpression(unique_ptr expr, OrderType order_type = OrderType::ORDER_DEFAULT, OrderByNullType null_order = OrderByNullType::ORDER_DEFAULT); public: - shared_ptr shared_from_this() { - return enable_shared_from_this::shared_from_this(); + std::shared_ptr shared_from_this() { + return std::enable_shared_from_this::shared_from_this(); } public: @@ -41,92 +41,93 @@ struct DuckDBPyExpression : public enable_shared_from_this { string ToString() const; string GetName() const; void Print() const; - shared_ptr Add(const DuckDBPyExpression &other) const; - shared_ptr Subtract(const DuckDBPyExpression &other) const; - shared_ptr Multiply(const DuckDBPyExpression &other) const; - shared_ptr Division(const DuckDBPyExpression &other) const; - shared_ptr FloorDivision(const DuckDBPyExpression &other) const; - shared_ptr Modulo(const DuckDBPyExpression &other) const; - shared_ptr Power(const DuckDBPyExpression &other) const; - shared_ptr Negate(); + std::shared_ptr Add(const DuckDBPyExpression &other) const; + std::shared_ptr Subtract(const DuckDBPyExpression &other) const; + std::shared_ptr Multiply(const DuckDBPyExpression &other) const; + std::shared_ptr Division(const DuckDBPyExpression &other) const; + std::shared_ptr FloorDivision(const DuckDBPyExpression &other) const; + std::shared_ptr Modulo(const DuckDBPyExpression &other) const; + std::shared_ptr Power(const DuckDBPyExpression &other) const; + std::shared_ptr Negate(); // Equality operations - shared_ptr Equality(const DuckDBPyExpression &other); - shared_ptr Inequality(const DuckDBPyExpression &other); - shared_ptr GreaterThan(const DuckDBPyExpression &other); - shared_ptr GreaterThanOrEqual(const DuckDBPyExpression &other); - shared_ptr LessThan(const DuckDBPyExpression &other); - shared_ptr LessThanOrEqual(const DuckDBPyExpression &other); + std::shared_ptr Equality(const DuckDBPyExpression &other); + std::shared_ptr Inequality(const DuckDBPyExpression &other); + std::shared_ptr GreaterThan(const DuckDBPyExpression &other); + std::shared_ptr GreaterThanOrEqual(const DuckDBPyExpression &other); + std::shared_ptr LessThan(const DuckDBPyExpression &other); + std::shared_ptr LessThanOrEqual(const DuckDBPyExpression &other); - shared_ptr SetAlias(const string &alias) const; - shared_ptr When(const DuckDBPyExpression &condition, const DuckDBPyExpression &value); - shared_ptr Else(const DuckDBPyExpression &value); + std::shared_ptr SetAlias(const string &alias) const; + std::shared_ptr When(const DuckDBPyExpression &condition, const DuckDBPyExpression &value); + std::shared_ptr Else(const DuckDBPyExpression &value); - shared_ptr Cast(const DuckDBPyType &type) const; - shared_ptr Between(const DuckDBPyExpression &lower, const DuckDBPyExpression &upper); - shared_ptr Collate(const string &collation); + std::shared_ptr Cast(const DuckDBPyType &type) const; + std::shared_ptr Between(const DuckDBPyExpression &lower, const DuckDBPyExpression &upper); + std::shared_ptr Collate(const string &collation); // AND, OR and NOT - shared_ptr Not(); - shared_ptr And(const DuckDBPyExpression &other) const; - shared_ptr Or(const DuckDBPyExpression &other) const; + std::shared_ptr Not(); + std::shared_ptr And(const DuckDBPyExpression &other) const; + std::shared_ptr Or(const DuckDBPyExpression &other) const; // IS NULL / IS NOT NULL - shared_ptr IsNull(); - shared_ptr IsNotNull(); + std::shared_ptr IsNull(); + std::shared_ptr IsNotNull(); // IN / NOT IN - shared_ptr CreateCompareExpression(ExpressionType compare_type, const py::args &args); - shared_ptr In(const py::args &args); - shared_ptr NotIn(const py::args &args); + std::shared_ptr CreateCompareExpression(ExpressionType compare_type, const py::args &args); + std::shared_ptr In(const py::args &args); + std::shared_ptr NotIn(const py::args &args); // Order modifiers - shared_ptr Ascending(); - shared_ptr Descending(); + std::shared_ptr Ascending(); + std::shared_ptr Descending(); // Null order modifiers - shared_ptr NullsFirst(); - shared_ptr NullsLast(); + std::shared_ptr NullsFirst(); + std::shared_ptr NullsLast(); public: const ParsedExpression &GetExpression() const; - shared_ptr Copy() const; + std::shared_ptr Copy() const; public: - static shared_ptr StarExpression(py::object exclude = py::none()); - static shared_ptr ColumnExpression(const py::args &column_name); - static shared_ptr DefaultExpression(); - static shared_ptr ConstantExpression(const py::object &value); - static shared_ptr LambdaExpression(const py::object &lhs, const DuckDBPyExpression &rhs); - static shared_ptr CaseExpression(const DuckDBPyExpression &condition, - const DuckDBPyExpression &value); - static shared_ptr FunctionExpression(const string &function_name, const py::args &args); - static shared_ptr Coalesce(const py::args &args); - static shared_ptr SQLExpression(string sql); + static std::shared_ptr StarExpression(py::object exclude = py::none()); + static std::shared_ptr ColumnExpression(const py::args &column_name); + static std::shared_ptr DefaultExpression(); + static std::shared_ptr ConstantExpression(const py::object &value); + static std::shared_ptr LambdaExpression(const py::object &lhs, const DuckDBPyExpression &rhs); + static std::shared_ptr CaseExpression(const DuckDBPyExpression &condition, + const DuckDBPyExpression &value); + static std::shared_ptr FunctionExpression(const string &function_name, const py::args &args); + static std::shared_ptr Coalesce(const py::args &args); + static std::shared_ptr SQLExpression(string sql); public: // Internal functions (not exposed to Python) - static shared_ptr InternalFunctionExpression(const string &function_name, - vector> children, - bool is_operator = false); - - static shared_ptr InternalUnaryOperator(ExpressionType type, const DuckDBPyExpression &arg); - static shared_ptr InternalConjunction(ExpressionType type, const DuckDBPyExpression &arg, - const DuckDBPyExpression &other); - static shared_ptr InternalConstantExpression(Value value); - static shared_ptr BinaryOperator(const string &function_name, const DuckDBPyExpression &arg_one, - const DuckDBPyExpression &arg_two); - static shared_ptr ComparisonExpression(ExpressionType type, const DuckDBPyExpression &left, - const DuckDBPyExpression &right); - static shared_ptr InternalWhen(unique_ptr expr, - const DuckDBPyExpression &condition, - const DuckDBPyExpression &value); + static std::shared_ptr InternalFunctionExpression(const string &function_name, + vector> children, + bool is_operator = false); + + static std::shared_ptr InternalUnaryOperator(ExpressionType type, + const DuckDBPyExpression &arg); + static std::shared_ptr InternalConjunction(ExpressionType type, const DuckDBPyExpression &arg, + const DuckDBPyExpression &other); + static std::shared_ptr InternalConstantExpression(Value value); + static std::shared_ptr + BinaryOperator(const string &function_name, const DuckDBPyExpression &arg_one, const DuckDBPyExpression &arg_two); + static std::shared_ptr ComparisonExpression(ExpressionType type, const DuckDBPyExpression &left, + const DuckDBPyExpression &right); + static std::shared_ptr InternalWhen(unique_ptr expr, + const DuckDBPyExpression &condition, + const DuckDBPyExpression &value); void AssertCaseExpression() const; private: diff --git a/src/duckdb_py/include/duckdb_python/numpy/array_wrapper.hpp b/src/duckdb_py/include/duckdb_python/numpy/array_wrapper.hpp index a9740e2c..4b143aee 100644 --- a/src/duckdb_py/include/duckdb_python/numpy/array_wrapper.hpp +++ b/src/duckdb_py/include/duckdb_python/numpy/array_wrapper.hpp @@ -41,8 +41,8 @@ struct NumpyAppendData { struct ArrayWrapper { explicit ArrayWrapper(const LogicalType &type, const ClientProperties &client_properties, bool pandas = false); - unique_ptr data; - unique_ptr mask; + std::unique_ptr data; + std::unique_ptr mask; bool requires_mask; const ClientProperties client_properties; bool pandas; diff --git a/src/duckdb_py/include/duckdb_python/pandas/pandas_bind.hpp b/src/duckdb_py/include/duckdb_python/pandas/pandas_bind.hpp index ebaf8026..b6a70def 100644 --- a/src/duckdb_py/include/duckdb_python/pandas/pandas_bind.hpp +++ b/src/duckdb_py/include/duckdb_python/pandas/pandas_bind.hpp @@ -18,8 +18,8 @@ struct RegisteredArray { struct PandasColumnBindData { NumpyType numpy_type; - unique_ptr pandas_col; - unique_ptr mask; + std::unique_ptr pandas_col; + std::unique_ptr mask; //! Only for categorical types string internal_categorical_type; //! Hold ownership of objects created during scanning diff --git a/src/duckdb_py/include/duckdb_python/pybind11/conversions/pyconnection_default.hpp b/src/duckdb_py/include/duckdb_python/pybind11/conversions/pyconnection_default.hpp index d6ad6979..e07a9b2e 100644 --- a/src/duckdb_py/include/duckdb_python/pybind11/conversions/pyconnection_default.hpp +++ b/src/duckdb_py/include/duckdb_python/pybind11/conversions/pyconnection_default.hpp @@ -4,7 +4,6 @@ #include "duckdb/common/helper.hpp" using duckdb::DuckDBPyConnection; -using duckdb::shared_ptr; namespace py = pybind11; @@ -12,12 +11,12 @@ namespace PYBIND11_NAMESPACE { namespace detail { template <> -class type_caster> - : public copyable_holder_caster> { +class type_caster> + : public copyable_holder_caster> { using type = DuckDBPyConnection; - using holder_caster = copyable_holder_caster>; + using holder_caster = copyable_holder_caster>; // This is used to generate documentation on duckdb-web - PYBIND11_TYPE_CASTER(shared_ptr, const_name("duckdb.DuckDBPyConnection")); + PYBIND11_TYPE_CASTER(std::shared_ptr, const_name("duckdb.DuckDBPyConnection")); bool load(handle src, bool convert) { if (py::none().is(src)) { @@ -27,17 +26,19 @@ class type_caster> if (!holder_caster::load(src, convert)) { return false; } - value = std::move(holder); + // pybind11's std::shared_ptr holder_caster (smart_holder bakein) has no `holder` member like the + // generic template did for duckdb::shared_ptr; extract the loaded pointer via its conversion operator. + value = static_cast &>(static_cast(*this)); return true; } - static handle cast(shared_ptr base, return_value_policy rvp, handle h) { + static handle cast(std::shared_ptr base, return_value_policy rvp, handle h) { return holder_caster::cast(base, rvp, h); } }; template <> -struct is_holder_type> : std::true_type {}; +struct is_holder_type> : std::true_type {}; } // namespace detail } // namespace PYBIND11_NAMESPACE diff --git a/src/duckdb_py/include/duckdb_python/pyconnection/pyconnection.hpp b/src/duckdb_py/include/duckdb_python/pyconnection/pyconnection.hpp index 0973e857..c1815f20 100644 --- a/src/duckdb_py/include/duckdb_python/pyconnection/pyconnection.hpp +++ b/src/duckdb_py/include/duckdb_python/pyconnection/pyconnection.hpp @@ -53,11 +53,11 @@ struct DefaultConnectionHolder { DefaultConnectionHolder &operator=(DefaultConnectionHolder &&other) = delete; public: - shared_ptr Get(); - void Set(shared_ptr conn); + std::shared_ptr Get(); + void Set(std::shared_ptr conn); private: - shared_ptr connection; + std::shared_ptr connection; mutex l; }; @@ -129,7 +129,7 @@ struct ConnectionGuard { void SetConnection(unique_ptr con) { connection = std::move(con); } - void SetResult(unique_ptr res) { + void SetResult(std::unique_ptr res) { result = std::move(res); } @@ -141,10 +141,10 @@ struct ConnectionGuard { private: shared_ptr database; unique_ptr connection; - unique_ptr result; + std::unique_ptr result; }; -struct DuckDBPyConnection : public enable_shared_from_this { +struct DuckDBPyConnection : public std::enable_shared_from_this { private: class Cursors { public: @@ -152,12 +152,12 @@ struct DuckDBPyConnection : public enable_shared_from_this { } public: - void AddCursor(shared_ptr conn); + void AddCursor(std::shared_ptr conn); void ClearCursors(); private: mutex lock; - vector> cursors; + vector> cursors; }; public: @@ -191,7 +191,7 @@ struct DuckDBPyConnection : public enable_shared_from_this { // duckdb-python#435. std::recursive_mutex py_connection_lock; //! MemoryFileSystem used to temporarily store file-like objects for reading - shared_ptr internal_object_filesystem; + std::shared_ptr internal_object_filesystem; case_insensitive_map_t> registered_functions; case_insensitive_set_t registered_objects; @@ -204,7 +204,7 @@ struct DuckDBPyConnection : public enable_shared_from_this { static void Initialize(py::handle &m); static void Cleanup(); - shared_ptr Enter(); + std::shared_ptr Enter(); static void Exit(DuckDBPyConnection &self, const py::object &exc_type, const py::object &exc, const py::object &traceback); @@ -212,16 +212,16 @@ struct DuckDBPyConnection : public enable_shared_from_this { static bool DetectAndGetEnvironment(); static bool IsJupyter(); static std::string FormattedPythonVersion(); - static shared_ptr DefaultConnection(); - static void SetDefaultConnection(shared_ptr conn); + static std::shared_ptr DefaultConnection(); + static void SetDefaultConnection(std::shared_ptr conn); static PythonImportCache *ImportCache(); static bool IsInteractive(); - unique_ptr ReadCSV(const py::object &name, py::kwargs &kwargs); + std::unique_ptr ReadCSV(const py::object &name, py::kwargs &kwargs); py::list ExtractStatements(const string &query); - unique_ptr ReadJSON( + std::unique_ptr ReadJSON( const py::object &name, const Optional &columns = py::none(), const Optional &sample_size = py::none(), const Optional &maximum_depth = py::none(), const Optional &records = py::none(), const Optional &format = py::none(), @@ -237,28 +237,27 @@ struct DuckDBPyConnection : public enable_shared_from_this { const Optional &union_by_name = py::none(), const Optional &hive_types = py::none(), const Optional &hive_types_autocast = py::none()); - shared_ptr MapType(const shared_ptr &key_type, - const shared_ptr &value_type); - shared_ptr StructType(const py::object &fields); - shared_ptr ListType(const shared_ptr &type); - shared_ptr ArrayType(const shared_ptr &type, idx_t size); - shared_ptr UnionType(const py::object &members); - shared_ptr EnumType(const string &name, const shared_ptr &type, - const py::list &values_p); - shared_ptr DecimalType(int width, int scale); - shared_ptr StringType(const string &collation = string()); - shared_ptr Type(const string &type_str); - - shared_ptr - RegisterScalarUDF(const string &name, const py::function &udf, const py::object &arguments = py::none(), - const shared_ptr &return_type = nullptr, PythonUDFType type = PythonUDFType::NATIVE, - FunctionNullHandling null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING, - PythonExceptionHandling exception_handling = PythonExceptionHandling::FORWARD_ERROR, - bool side_effects = false); - - shared_ptr UnregisterUDF(const string &name); - - shared_ptr ExecuteMany(const py::object &query, py::object params = py::list()); + std::shared_ptr MapType(const std::shared_ptr &key_type, + const std::shared_ptr &value_type); + std::shared_ptr StructType(const py::object &fields); + std::shared_ptr ListType(const std::shared_ptr &type); + std::shared_ptr ArrayType(const std::shared_ptr &type, idx_t size); + std::shared_ptr UnionType(const py::object &members); + std::shared_ptr EnumType(const string &name, const std::shared_ptr &type, + const py::list &values_p); + std::shared_ptr DecimalType(int width, int scale); + std::shared_ptr StringType(const string &collation = string()); + std::shared_ptr Type(const string &type_str); + + std::shared_ptr RegisterScalarUDF( + const string &name, const py::function &udf, const py::object &arguments = py::none(), + const std::shared_ptr &return_type = nullptr, PythonUDFType type = PythonUDFType::NATIVE, + FunctionNullHandling null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING, + PythonExceptionHandling exception_handling = PythonExceptionHandling::FORWARD_ERROR, bool side_effects = false); + + std::shared_ptr UnregisterUDF(const string &name); + + std::shared_ptr ExecuteMany(const py::object &query, py::object params = py::list()); void ExecuteImmediately(vector> statements); unique_ptr PrepareQuery(unique_ptr statement); @@ -266,12 +265,12 @@ struct DuckDBPyConnection : public enable_shared_from_this { unique_ptr PrepareAndExecuteInternal(unique_ptr statement, py::object params = py::list()); - shared_ptr Execute(const py::object &query, py::object params = py::list()); - shared_ptr ExecuteFromString(const string &query); + std::shared_ptr Execute(const py::object &query, py::object params = py::list()); + std::shared_ptr ExecuteFromString(const string &query); - shared_ptr Append(const string &name, const PandasDataFrame &value, bool by_name); + std::shared_ptr Append(const string &name, const PandasDataFrame &value, bool by_name); - shared_ptr RegisterPythonObject(const string &name, const py::object &python_object); + std::shared_ptr RegisterPythonObject(const string &name, const py::object &python_object); void InstallExtension(const string &extension, bool force_install = false, const py::object &repository = py::none(), const py::object &repository_url = py::none(), @@ -279,35 +278,36 @@ struct DuckDBPyConnection : public enable_shared_from_this { void LoadExtension(const string &extension); - unique_ptr RunQuery(const py::object &query, string alias = "", py::object params = py::list()); + std::unique_ptr RunQuery(const py::object &query, string alias = "", + py::object params = py::list()); - unique_ptr Table(const string &tname); + std::unique_ptr Table(const string &tname); - unique_ptr Values(const py::args ¶ms); + std::unique_ptr Values(const py::args ¶ms); - unique_ptr View(const string &vname); + std::unique_ptr View(const string &vname); - unique_ptr TableFunction(const string &fname, py::object params = py::list()); + std::unique_ptr TableFunction(const string &fname, py::object params = py::list()); - unique_ptr FromDF(const PandasDataFrame &value); + std::unique_ptr FromDF(const PandasDataFrame &value); - unique_ptr FromParquet(const py::object &path_or_buffer, bool binary_as_string, - bool file_row_number, bool filename, bool hive_partitioning, - bool union_by_name, const py::object &compression = py::none()); + std::unique_ptr FromParquet(const py::object &path_or_buffer, bool binary_as_string, + bool file_row_number, bool filename, bool hive_partitioning, + bool union_by_name, const py::object &compression = py::none()); - unique_ptr FromArrow(py::object &arrow_object); + std::unique_ptr FromArrow(py::object &arrow_object); unordered_set GetTableNames(const string &query, bool qualified); - shared_ptr UnregisterPythonObject(const string &name); + std::shared_ptr UnregisterPythonObject(const string &name); - shared_ptr Begin(); + std::shared_ptr Begin(); - shared_ptr Commit(); + std::shared_ptr Commit(); - shared_ptr Rollback(); + std::shared_ptr Rollback(); - shared_ptr Checkpoint(); + std::shared_ptr Checkpoint(); void Close(); @@ -318,7 +318,7 @@ struct DuckDBPyConnection : public enable_shared_from_this { ModifiedMemoryFileSystem &GetObjectFileSystem(); // cursor() is stupid - shared_ptr Cursor(); + std::shared_ptr Cursor(); Optional GetDescription(); @@ -344,7 +344,8 @@ struct DuckDBPyConnection : public enable_shared_from_this { duckdb::pyarrow::RecordBatchReader FetchRecordBatchReader(const idx_t rows_per_batch); - static shared_ptr Connect(const py::object &database, bool read_only, const py::dict &config); + static std::shared_ptr Connect(const py::object &database, bool read_only, + const py::dict &config); static vector TransformPythonParamList(ClientContext &context, const py::handle ¶ms); static identifier_map_t TransformPythonParamDict(ClientContext &context, @@ -363,7 +364,7 @@ struct DuckDBPyConnection : public enable_shared_from_this { //! Default connection to an in-memory database static DefaultConnectionHolder default_connection; //! Caches and provides an interface to get frequently used modules+subtypes - static shared_ptr import_cache; + static std::shared_ptr import_cache; static bool IsPandasDataframe(const py::object &object); static PyArrowObjectType GetArrowType(const py::handle &obj); @@ -373,11 +374,11 @@ struct DuckDBPyConnection : public enable_shared_from_this { static unique_ptr CompletePendingQuery(PendingQueryResult &pending_query); private: - unique_ptr CreateRelation(shared_ptr rel); - unique_ptr CreateRelation(shared_ptr result); + std::unique_ptr CreateRelation(shared_ptr rel); + std::unique_ptr CreateRelation(std::shared_ptr result); PathLike GetPathLike(const py::object &object); ScalarFunction CreateScalarUDF(const string &name, const py::function &udf, const py::object ¶meters, - const shared_ptr &return_type, bool vectorized, + const std::shared_ptr &return_type, bool vectorized, FunctionNullHandling null_handling, PythonExceptionHandling exception_handling, bool side_effects); vector> GetStatements(const py::object &query); diff --git a/src/duckdb_py/include/duckdb_python/pyrelation.hpp b/src/duckdb_py/include/duckdb_python/pyrelation.hpp index 577884f4..f77c937f 100644 --- a/src/duckdb_py/include/duckdb_python/pyrelation.hpp +++ b/src/duckdb_py/include/duckdb_python/pyrelation.hpp @@ -22,7 +22,7 @@ namespace duckdb { struct DuckDBPyRelation { public: explicit DuckDBPyRelation(shared_ptr rel); - explicit DuckDBPyRelation(shared_ptr result); + explicit DuckDBPyRelation(std::shared_ptr result); ~DuckDBPyRelation(); public: @@ -32,99 +32,106 @@ struct DuckDBPyRelation { void Close(); - unique_ptr GetAttribute(const string &name); + std::unique_ptr GetAttribute(const string &name); py::str GetAlias(); - static unique_ptr EmptyResult(const shared_ptr &context, - const vector &types, vector names); + static std::unique_ptr EmptyResult(const shared_ptr &context, + const vector &types, vector names); - unique_ptr SetAlias(const string &expr); + std::unique_ptr SetAlias(const string &expr); - unique_ptr ProjectFromExpression(const string &expr); - unique_ptr ProjectFromTypes(const py::object &types); - unique_ptr Project(const py::args &args, const string &groups = ""); - unique_ptr Filter(const py::object &expr); - unique_ptr FilterFromExpression(const string &expr); - unique_ptr Limit(int64_t n, int64_t offset = 0); - unique_ptr Order(const string &expr); - unique_ptr Sort(const py::args &args); + std::unique_ptr ProjectFromExpression(const string &expr); + std::unique_ptr ProjectFromTypes(const py::object &types); + std::unique_ptr Project(const py::args &args, const string &groups = ""); + std::unique_ptr Filter(const py::object &expr); + std::unique_ptr FilterFromExpression(const string &expr); + std::unique_ptr Limit(int64_t n, int64_t offset = 0); + std::unique_ptr Order(const string &expr); + std::unique_ptr Sort(const py::args &args); - unique_ptr Aggregate(const py::object &expr, const string &groups = ""); + std::unique_ptr Aggregate(const py::object &expr, const string &groups = ""); - unique_ptr GenericAggregator(const string &function_name, const string &aggregated_columns, - const string &groups = "", const string &function_parameter = "", - const string &projected_columns = ""); + std::unique_ptr GenericAggregator(const string &function_name, const string &aggregated_columns, + const string &groups = "", + const string &function_parameter = "", + const string &projected_columns = ""); /* General aggregate functions */ - unique_ptr AnyValue(const string &column, const string &groups = "", + std::unique_ptr AnyValue(const string &column, const string &groups = "", + const string &window_spec = "", const string &projected_columns = ""); + std::unique_ptr ArgMax(const string &arg_column, const string &value_column, + const string &groups = "", const string &window_spec = "", + const string &projected_columns = ""); + std::unique_ptr ArgMin(const string &arg_column, const string &value_column, + const string &groups = "", const string &window_spec = "", + const string &projected_columns = ""); + std::unique_ptr Avg(const string &column, const string &groups = "", const string &window_spec = "", const string &projected_columns = ""); - unique_ptr ArgMax(const string &arg_column, const string &value_column, const string &groups = "", - const string &window_spec = "", const string &projected_columns = ""); - unique_ptr ArgMin(const string &arg_column, const string &value_column, const string &groups = "", - const string &window_spec = "", const string &projected_columns = ""); - unique_ptr Avg(const string &column, const string &groups = "", const string &window_spec = "", - const string &projected_columns = ""); - unique_ptr BitAnd(const string &column, const string &groups = "", const string &window_spec = "", - const string &projected_columns = ""); - unique_ptr BitOr(const string &column, const string &groups = "", const string &window_spec = "", - const string &projected_columns = ""); - unique_ptr BitXor(const string &column, const string &groups = "", const string &window_spec = "", - const string &projected_columns = ""); - unique_ptr BitStringAgg(const string &column, const Optional &min, - const Optional &max, const string &groups = "", + std::unique_ptr BitAnd(const string &column, const string &groups = "", + const string &window_spec = "", const string &projected_columns = ""); + std::unique_ptr BitOr(const string &column, const string &groups = "", + const string &window_spec = "", const string &projected_columns = ""); + std::unique_ptr BitXor(const string &column, const string &groups = "", + const string &window_spec = "", const string &projected_columns = ""); + std::unique_ptr BitStringAgg(const string &column, const Optional &min, + const Optional &max, const string &groups = "", + const string &window_spec = "", + const string &projected_columns = ""); + std::unique_ptr BoolAnd(const string &column, const string &groups = "", const string &window_spec = "", const string &projected_columns = ""); - unique_ptr BoolAnd(const string &column, const string &groups = "", - const string &window_spec = "", const string &projected_columns = ""); - unique_ptr BoolOr(const string &column, const string &groups = "", const string &window_spec = "", - const string &projected_columns = ""); - unique_ptr ValueCounts(const string &column, const string &groups = ""); - unique_ptr Count(const string &column, const string &groups = "", const string &window_spec = "", - const string &projected_columns = ""); - unique_ptr FAvg(const string &column, const string &groups = "", const string &window_spec = "", - const string &projected_columns = ""); - unique_ptr First(const string &column, const string &groups = "", - const string &projected_columns = ""); - unique_ptr FSum(const string &column, const string &groups = "", const string &window_spec = "", - const string &projected_columns = ""); - unique_ptr GeoMean(const string &column, const string &groups = "", - const string &projected_columns = ""); - unique_ptr Histogram(const string &column, const string &groups = "", + std::unique_ptr BoolOr(const string &column, const string &groups = "", + const string &window_spec = "", const string &projected_columns = ""); + std::unique_ptr ValueCounts(const string &column, const string &groups = ""); + std::unique_ptr Count(const string &column, const string &groups = "", + const string &window_spec = "", const string &projected_columns = ""); + std::unique_ptr FAvg(const string &column, const string &groups = "", + const string &window_spec = "", const string &projected_columns = ""); + std::unique_ptr First(const string &column, const string &groups = "", + const string &projected_columns = ""); + std::unique_ptr FSum(const string &column, const string &groups = "", const string &window_spec = "", const string &projected_columns = ""); - unique_ptr Last(const string &column, const string &groups = "", - const string &projected_columns = ""); - unique_ptr List(const string &column, const string &groups = "", const string &window_spec = "", - const string &projected_columns = ""); - unique_ptr Max(const string &column, const string &groups = "", const string &window_spec = "", - const string &projected_columns = ""); - unique_ptr Min(const string &column, const string &groups = "", const string &window_spec = "", - const string &projected_columns = ""); - unique_ptr Product(const string &column, const string &groups = "", - const string &window_spec = "", const string &projected_columns = ""); - unique_ptr StringAgg(const string &column, const string &sep = ",", const string &groups = "", + std::unique_ptr GeoMean(const string &column, const string &groups = "", + const string &projected_columns = ""); + std::unique_ptr Histogram(const string &column, const string &groups = "", + const string &window_spec = "", const string &projected_columns = ""); + std::unique_ptr Last(const string &column, const string &groups = "", + const string &projected_columns = ""); + std::unique_ptr List(const string &column, const string &groups = "", const string &window_spec = "", const string &projected_columns = ""); - unique_ptr Sum(const string &column, const string &groups = "", const string &window_spec = "", - const string &projected_columns = ""); + std::unique_ptr Max(const string &column, const string &groups = "", + const string &window_spec = "", const string &projected_columns = ""); + std::unique_ptr Min(const string &column, const string &groups = "", + const string &window_spec = "", const string &projected_columns = ""); + std::unique_ptr Product(const string &column, const string &groups = "", + const string &window_spec = "", const string &projected_columns = ""); + std::unique_ptr StringAgg(const string &column, const string &sep = ",", + const string &groups = "", const string &window_spec = "", + const string &projected_columns = ""); + std::unique_ptr Sum(const string &column, const string &groups = "", + const string &window_spec = "", const string &projected_columns = ""); /* TODO: Approximate aggregate functions */ /* TODO: Statistical aggregate functions */ - unique_ptr Median(const string &column, const string &groups = "", const string &window_spec = "", - const string &projected_columns = ""); - unique_ptr Mode(const string &column, const string &groups = "", const string &window_spec = "", - const string &projected_columns = ""); - unique_ptr QuantileCont(const string &column, const py::object &q, const string &groups = "", + std::unique_ptr Median(const string &column, const string &groups = "", + const string &window_spec = "", const string &projected_columns = ""); + std::unique_ptr Mode(const string &column, const string &groups = "", + const string &window_spec = "", const string &projected_columns = ""); + std::unique_ptr QuantileCont(const string &column, const py::object &q, const string &groups = "", + const string &window_spec = "", + const string &projected_columns = ""); + std::unique_ptr QuantileDisc(const string &column, const py::object &q, const string &groups = "", + const string &window_spec = "", + const string &projected_columns = ""); + std::unique_ptr StdPop(const string &column, const string &groups = "", + const string &window_spec = "", const string &projected_columns = ""); + std::unique_ptr StdSamp(const string &column, const string &groups = "", const string &window_spec = "", const string &projected_columns = ""); - unique_ptr QuantileDisc(const string &column, const py::object &q, const string &groups = "", + std::unique_ptr VarPop(const string &column, const string &groups = "", + const string &window_spec = "", const string &projected_columns = ""); + std::unique_ptr VarSamp(const string &column, const string &groups = "", const string &window_spec = "", const string &projected_columns = ""); - unique_ptr StdPop(const string &column, const string &groups = "", const string &window_spec = "", - const string &projected_columns = ""); - unique_ptr StdSamp(const string &column, const string &groups = "", - const string &window_spec = "", const string &projected_columns = ""); - unique_ptr VarPop(const string &column, const string &groups = "", const string &window_spec = "", - const string &projected_columns = ""); - unique_ptr VarSamp(const string &column, const string &groups = "", - const string &window_spec = "", const string &projected_columns = ""); - unique_ptr Describe(); + std::unique_ptr Describe(); string ToSQL(); @@ -134,35 +141,36 @@ struct DuckDBPyRelation { py::tuple Shape(); - unique_ptr Unique(const string &aggr_columns); + std::unique_ptr Unique(const string &aggr_columns); - unique_ptr GenericWindowFunction(const string &function_name, const string &function_parameters, - const string &aggr_columns, const string &window_spec, - const bool &ignore_nulls, const string &projected_columns); + std::unique_ptr GenericWindowFunction(const string &function_name, + const string &function_parameters, + const string &aggr_columns, const string &window_spec, + const bool &ignore_nulls, const string &projected_columns); /* General purpose window functions */ - unique_ptr RowNumber(const string &window_spec, const string &projected_columns); - unique_ptr Rank(const string &window_spec, const string &projected_columns); - unique_ptr DenseRank(const string &window_spec, const string &projected_columns); - unique_ptr PercentRank(const string &window_spec, const string &projected_columns); - unique_ptr CumeDist(const string &window_spec, const string &projected_columns); - unique_ptr FirstValue(const string &column, const string &window_spec = "", - const string &projected_columns = ""); - unique_ptr NTile(const string &window_spec, const int &num_buckets, - const string &projected_columns); - unique_ptr Lag(const string &column, const string &window_spec, const int &offset, - const string &default_value, const bool &ignore_nulls, - const string &projected_columns); - unique_ptr LastValue(const string &column, const string &window_spec = "", - const string &projected_columns = ""); - unique_ptr Lead(const string &column, const string &window_spec, const int &offset, - const string &default_value, const bool &ignore_nulls, - const string &projected_columns); - - unique_ptr NthValue(const string &column, const string &window_spec, const int &offset, - const bool &ignore_nulls, const string &projected_columns); - - unique_ptr Distinct(); + std::unique_ptr RowNumber(const string &window_spec, const string &projected_columns); + std::unique_ptr Rank(const string &window_spec, const string &projected_columns); + std::unique_ptr DenseRank(const string &window_spec, const string &projected_columns); + std::unique_ptr PercentRank(const string &window_spec, const string &projected_columns); + std::unique_ptr CumeDist(const string &window_spec, const string &projected_columns); + std::unique_ptr FirstValue(const string &column, const string &window_spec = "", + const string &projected_columns = ""); + std::unique_ptr NTile(const string &window_spec, const int &num_buckets, + const string &projected_columns); + std::unique_ptr Lag(const string &column, const string &window_spec, const int &offset, + const string &default_value, const bool &ignore_nulls, + const string &projected_columns); + std::unique_ptr LastValue(const string &column, const string &window_spec = "", + const string &projected_columns = ""); + std::unique_ptr Lead(const string &column, const string &window_spec, const int &offset, + const string &default_value, const bool &ignore_nulls, + const string &projected_columns); + + std::unique_ptr NthValue(const string &column, const string &window_spec, const int &offset, + const bool &ignore_nulls, const string &projected_columns); + + std::unique_ptr Distinct(); PandasDataFrame FetchDF(bool date_as_object); @@ -192,16 +200,16 @@ struct DuckDBPyRelation { duckdb::pyarrow::RecordBatchReader ToRecordBatch(idx_t batch_size); - unique_ptr Union(DuckDBPyRelation *other); + std::unique_ptr Union(DuckDBPyRelation *other); - unique_ptr Except(DuckDBPyRelation *other); + std::unique_ptr Except(DuckDBPyRelation *other); - unique_ptr Intersect(DuckDBPyRelation *other); + std::unique_ptr Intersect(DuckDBPyRelation *other); - unique_ptr Map(py::function fun, Optional schema); + std::unique_ptr Map(py::function fun, Optional schema); - unique_ptr Join(DuckDBPyRelation *other, const py::object &condition, const string &type); - unique_ptr Cross(DuckDBPyRelation *other); + std::unique_ptr Join(DuckDBPyRelation *other, const py::object &condition, const string &type); + std::unique_ptr Cross(DuckDBPyRelation *other); void ToParquet(const string &filename, const py::object &compression = py::none(), const py::object &field_ids = py::none(), const py::object &row_group_size_bytes = py::none(), @@ -221,9 +229,9 @@ struct DuckDBPyRelation { const py::object &write_partition_columns = py::none()); // should this return a rel with the new view? - unique_ptr CreateView(const string &view_name, bool replace = true); + std::unique_ptr CreateView(const string &view_name, bool replace = true); - unique_ptr Query(const string &view_name, const string &sql_query); + std::unique_ptr Query(const string &view_name, const string &sql_query); // Update the internal result of the relation DuckDBPyRelation &Execute(); @@ -257,8 +265,8 @@ struct DuckDBPyRelation { bool ContainsColumnByName(const string &name) const; void SetConnectionOwner(py::object owner); - unique_ptr DeriveRelation(shared_ptr new_rel); - unique_ptr DeriveRelation(shared_ptr result); + std::unique_ptr DeriveRelation(shared_ptr new_rel); + std::unique_ptr DeriveRelation(std::shared_ptr result); private: string ToStringInternal(const BoxRendererConfig &config, bool invalidate_cache = false); @@ -270,10 +278,10 @@ struct DuckDBPyRelation { const string &groups = "", const string &function_parameter = "", bool ignore_nulls = false, const string &projected_columns = "", const string &window_spec = ""); - unique_ptr ApplyAggOrWin(const string &function_name, const string &agg_columns, - const string &function_parameters = "", const string &groups = "", - const string &window_spec = "", const string &projected_columns = "", - bool ignore_nulls = false); + std::unique_ptr ApplyAggOrWin(const string &function_name, const string &agg_columns, + const string &function_parameters = "", const string &groups = "", + const string &window_spec = "", + const string &projected_columns = "", bool ignore_nulls = false); void AssertResult() const; void AssertResultOpen() const; @@ -290,7 +298,7 @@ struct DuckDBPyRelation { shared_ptr rel; vector types; vector names; - shared_ptr result; + std::shared_ptr result; std::string rendered_result; }; diff --git a/src/duckdb_py/include/duckdb_python/pyresult.hpp b/src/duckdb_py/include/duckdb_python/pyresult.hpp index d7da83cc..1a014824 100644 --- a/src/duckdb_py/include/duckdb_python/pyresult.hpp +++ b/src/duckdb_py/include/duckdb_python/pyresult.hpp @@ -32,7 +32,7 @@ struct DuckDBPyResult { py::dict FetchNumpy(); py::dict FetchNumpyInternal(bool stream = false, idx_t vectors_per_chunk = 1, - unique_ptr conversion = nullptr); + std::unique_ptr conversion = nullptr); PandasDataFrame FetchDF(bool date_as_object); @@ -67,7 +67,7 @@ struct DuckDBPyResult { void ConvertDateTimeTypes(PandasDataFrame &df, bool date_as_object) const; unique_ptr FetchNext(QueryResult &result); unique_ptr FetchNextRaw(QueryResult &result); - unique_ptr InitializeNumpyConversion(bool pandas = false); + std::unique_ptr InitializeNumpyConversion(bool pandas = false); //! Re-feed an already-MATERIALIZED result (a ColumnDataCollection, e.g. from //! rel.execute()) back through the engine on the user's own context. The eager diff --git a/src/duckdb_py/include/duckdb_python/pytype.hpp b/src/duckdb_py/include/duckdb_python/pytype.hpp index a6e13dfd..87f56836 100644 --- a/src/duckdb_py/include/duckdb_python/pytype.hpp +++ b/src/duckdb_py/include/duckdb_python/pytype.hpp @@ -21,7 +21,7 @@ class PyUnionType : public py::object { static bool check_(const py::handle &object); }; -class DuckDBPyType : public enable_shared_from_this { +class DuckDBPyType : public std::enable_shared_from_this { public: explicit DuckDBPyType(LogicalType type); @@ -29,9 +29,9 @@ class DuckDBPyType : public enable_shared_from_this { static void Initialize(py::handle &m); public: - bool Equals(const shared_ptr &other) const; + bool Equals(const std::shared_ptr &other) const; bool EqualsString(const string &type_str) const; - shared_ptr GetAttribute(const string &name) const; + std::shared_ptr GetAttribute(const string &name) const; py::list Children() const; string ToString() const; const LogicalType &Type() const; diff --git a/src/duckdb_py/map.cpp b/src/duckdb_py/map.cpp index 47a8418f..10ea9774 100644 --- a/src/duckdb_py/map.cpp +++ b/src/duckdb_py/map.cpp @@ -117,7 +117,7 @@ unique_ptr BindExplicitSchema(unique_ptr function auto type_p = item.second; names.push_back(string(py::str(name))); // TODO: replace with py::try_cast so we can catch the error and throw a better exception - auto type = py::cast>(type_p); + auto type = py::cast>(type_p); types.push_back(type->Type()); } diff --git a/src/duckdb_py/native/python_conversion.cpp b/src/duckdb_py/native/python_conversion.cpp index 879cb22e..722d85c2 100644 --- a/src/duckdb_py/native/python_conversion.cpp +++ b/src/duckdb_py/native/python_conversion.cpp @@ -595,8 +595,8 @@ struct PythonValueConversion { // Extract the internal object and the type from the Value instance auto object = ele.attr("object"); auto type = ele.attr("type"); - shared_ptr internal_type; - if (!py::try_cast>(type, internal_type)) { + std::shared_ptr internal_type; + if (!py::try_cast>(type, internal_type)) { string actual_type = py::str(py::type::of(type)); throw InvalidInputException("The 'type' of a Value should be of type DuckDBPyType, not '%s'", actual_type); diff --git a/src/duckdb_py/numpy/array_wrapper.cpp b/src/duckdb_py/numpy/array_wrapper.cpp index 4b10a8f1..60e9d95d 100644 --- a/src/duckdb_py/numpy/array_wrapper.cpp +++ b/src/duckdb_py/numpy/array_wrapper.cpp @@ -575,8 +575,8 @@ static bool ConvertDecimal(NumpyAppendData &append_data) { ArrayWrapper::ArrayWrapper(const LogicalType &type, const ClientProperties &client_properties_p, bool pandas) : requires_mask(false), client_properties(client_properties_p), pandas(pandas) { - data = make_uniq(type); - mask = make_uniq(LogicalType::BOOLEAN); + data = std::make_unique(type); + mask = std::make_unique(LogicalType::BOOLEAN); } void ArrayWrapper::Initialize(idx_t capacity) { diff --git a/src/duckdb_py/numpy/numpy_bind.cpp b/src/duckdb_py/numpy/numpy_bind.cpp index 7e481093..9ca819af 100644 --- a/src/duckdb_py/numpy/numpy_bind.cpp +++ b/src/duckdb_py/numpy/numpy_bind.cpp @@ -34,7 +34,7 @@ void NumpyBind::Bind(ClientContext &context, py::handle df, vector(py::array(column.attr("astype")("float32"))); + bind_data.pandas_col = std::make_unique(py::array(column.attr("astype")("float32"))); bind_data.numpy_type.type = NumpyNullableType::FLOAT_32; duckdb_col_type = NumpyToLogicalType(bind_data.numpy_type); } else if (bind_data.numpy_type.type == NumpyNullableType::STRING) { @@ -53,9 +53,9 @@ void NumpyBind::Bind(ClientContext &context, py::handle df, vector(pandas_col); + bind_data.pandas_col = std::make_unique(pandas_col); } else { - bind_data.pandas_col = make_uniq(column); + bind_data.pandas_col = std::make_unique(column); duckdb_col_type = NumpyToLogicalType(bind_data.numpy_type); } diff --git a/src/duckdb_py/numpy/numpy_scan.cpp b/src/duckdb_py/numpy/numpy_scan.cpp index 4c0f045a..4e1e61e4 100644 --- a/src/duckdb_py/numpy/numpy_scan.cpp +++ b/src/duckdb_py/numpy/numpy_scan.cpp @@ -362,7 +362,7 @@ void NumpyScan::Scan(ClientContext &context, PandasColumnBindData &bind_data, id // Get the data pointer and the validity mask of the result vector auto tgt_ptr = FlatVector::GetDataMutable(out); auto &out_mask = FlatVector::ValidityMutable(out); - unique_ptr gil; + std::unique_ptr gil; auto &import_cache = *DuckDBPyConnection::ImportCache(); // Loop over every row of the arrays contents @@ -399,7 +399,7 @@ void NumpyScan::Scan(ClientContext &context, PandasColumnBindData &bind_data, id } if (!py::isinstance(val)) { if (!gil) { - gil = make_uniq(); + gil = std::make_unique(); } bind_data.object_str_val.Push(std::move(py::str(val))); val = reinterpret_cast(bind_data.object_str_val.LastAddedObject().ptr()); diff --git a/src/duckdb_py/pandas/bind.cpp b/src/duckdb_py/pandas/bind.cpp index 98e0fc1e..02de2a75 100644 --- a/src/duckdb_py/pandas/bind.cpp +++ b/src/duckdb_py/pandas/bind.cpp @@ -53,7 +53,7 @@ static LogicalType BindColumn(ClientContext &context, PandasBindColumn &column_p if (column_has_mask) { // masked object, fetch the internal data and mask array - bind_data.mask = make_uniq(column.attr("array").attr("_mask")); + bind_data.mask = std::make_unique(column.attr("array").attr("_mask")); } if (bind_data.numpy_type.type == NumpyNullableType::CATEGORY) { @@ -76,31 +76,31 @@ static LogicalType BindColumn(ClientContext &context, PandasBindColumn &column_p column_type = LogicalType::ENUM(enum_entries_vec, size); auto pandas_col = py::array(column.attr("cat").attr("codes")); bind_data.internal_categorical_type = string(py::str(pandas_col.attr("dtype"))); - bind_data.pandas_col = make_uniq(pandas_col); + bind_data.pandas_col = std::make_unique(pandas_col); } else { auto pandas_col = py::array(column.attr("to_numpy")()); auto numpy_type = pandas_col.attr("dtype"); - bind_data.pandas_col = make_uniq(pandas_col); + bind_data.pandas_col = std::make_unique(pandas_col); // for category types (non-strings), we use the converted numpy type bind_data.numpy_type = ConvertNumpyType(numpy_type); column_type = NumpyToLogicalType(bind_data.numpy_type); } } else if (bind_data.numpy_type.type == NumpyNullableType::FLOAT_16) { auto pandas_array = column.attr("array"); - bind_data.pandas_col = make_uniq(py::array(column.attr("to_numpy")("float32"))); + bind_data.pandas_col = std::make_unique(py::array(column.attr("to_numpy")("float32"))); bind_data.numpy_type.type = NumpyNullableType::FLOAT_32; column_type = NumpyToLogicalType(bind_data.numpy_type); } else { auto pandas_array = column.attr("array"); if (py::hasattr(pandas_array, "_data")) { // This means we can access the numpy array directly - bind_data.pandas_col = make_uniq(column.attr("array").attr("_data")); + bind_data.pandas_col = std::make_unique(column.attr("array").attr("_data")); } else if (py::hasattr(pandas_array, "asi8")) { // This is a datetime object, has the option to get the array as int64_t's - bind_data.pandas_col = make_uniq(py::array(pandas_array.attr("asi8"))); + bind_data.pandas_col = std::make_unique(py::array(pandas_array.attr("asi8"))); } else { // Otherwise we have to get it through 'to_numpy()' - bind_data.pandas_col = make_uniq(py::array(column.attr("to_numpy")())); + bind_data.pandas_col = std::make_unique(py::array(column.attr("to_numpy")())); } column_type = NumpyToLogicalType(bind_data.numpy_type); } diff --git a/src/duckdb_py/pyconnection.cpp b/src/duckdb_py/pyconnection.cpp index 8b9ac8f9..5146b38c 100644 --- a/src/duckdb_py/pyconnection.cpp +++ b/src/duckdb_py/pyconnection.cpp @@ -48,7 +48,7 @@ namespace duckdb { DefaultConnectionHolder DuckDBPyConnection::default_connection; // NOLINT: allow global DBInstanceCache instance_cache; // NOLINT: allow global -shared_ptr DuckDBPyConnection::import_cache = nullptr; // NOLINT: allow global +std::shared_ptr DuckDBPyConnection::import_cache = nullptr; // NOLINT: allow global PythonEnvironmentType DuckDBPyConnection::environment = PythonEnvironmentType::NORMAL; // NOLINT: allow global std::string DuckDBPyConnection::formatted_python_version = ""; @@ -70,15 +70,15 @@ DuckDBPyConnection::~DuckDBPyConnection() { } } -unique_ptr DuckDBPyConnection::CreateRelation(shared_ptr rel) { - auto py_rel = make_uniq(std::move(rel)); +std::unique_ptr DuckDBPyConnection::CreateRelation(shared_ptr rel) { + auto py_rel = std::make_unique(std::move(rel)); py::gil_scoped_acquire gil; py_rel->SetConnectionOwner(py::cast(shared_from_this())); return py_rel; } -unique_ptr DuckDBPyConnection::CreateRelation(shared_ptr result) { - auto py_rel = make_uniq(std::move(result)); +std::unique_ptr DuckDBPyConnection::CreateRelation(std::shared_ptr result) { + auto py_rel = std::make_unique(std::move(result)); py::gil_scoped_acquire gil; py_rel->SetConnectionOwner(py::cast(shared_from_this())); return py_rel; @@ -136,7 +136,7 @@ std::string DuckDBPyConnection::FormattedPythonVersion() { // NOTE: this function is generated by tools/pythonpkg/scripts/generate_connection_methods.py. // Do not edit this function manually, your changes will be overwritten! -static void InitializeConnectionMethods(py::class_> &m) { +static void InitializeConnectionMethods(py::class_> &m) { m.def("cursor", &DuckDBPyConnection::Cursor, "Create a duplicate of the current connection"); m.def("register_filesystem", &DuckDBPyConnection::RegisterFilesystem, "Register a fsspec compliant filesystem", py::arg("filesystem")); @@ -386,7 +386,7 @@ py::list DuckDBPyConnection::ExtractStatements(const string &query) { auto &connection = con.GetConnection(); auto statements = connection.ExtractStatements(query); for (auto &statement : statements) { - result.append(make_uniq(std::move(statement))); + result.append(std::make_unique(std::move(statement))); } return result; } @@ -397,7 +397,7 @@ bool DuckDBPyConnection::FileSystemIsRegistered(const string &name) { return std::find(subsystems.begin(), subsystems.end(), name) != subsystems.end(); } -shared_ptr DuckDBPyConnection::UnregisterUDF(const string &name) { +std::shared_ptr DuckDBPyConnection::UnregisterUDF(const string &name) { auto entry = registered_functions.find(name); if (entry == registered_functions.end()) { // Not registered or already unregistered @@ -424,9 +424,9 @@ shared_ptr DuckDBPyConnection::UnregisterUDF(const string &n return shared_from_this(); } -shared_ptr +std::shared_ptr DuckDBPyConnection::RegisterScalarUDF(const string &name, const py::function &udf, const py::object ¶meters_p, - const shared_ptr &return_type_p, PythonUDFType type, + const std::shared_ptr &return_type_p, PythonUDFType type, FunctionNullHandling null_handling, PythonExceptionHandling exception_handling, bool side_effects) { auto &connection = con.GetConnection(); @@ -454,8 +454,8 @@ DuckDBPyConnection::RegisterScalarUDF(const string &name, const py::function &ud } void DuckDBPyConnection::Initialize(py::handle &m) { - auto connection_module = - py::class_>(m, "DuckDBPyConnection", py::module_local()); + auto connection_module = py::class_>( + m, "DuckDBPyConnection", py::module_local()); connection_module.def("__enter__", &DuckDBPyConnection::Enter) .def("__exit__", &DuckDBPyConnection::Exit, py::arg("exc_type"), py::arg("exc"), py::arg("traceback")); @@ -469,7 +469,7 @@ void DuckDBPyConnection::Initialize(py::handle &m) { DuckDBPyConnection::ImportCache(); } -shared_ptr DuckDBPyConnection::ExecuteMany(const py::object &query, py::object params_p) { +std::shared_ptr DuckDBPyConnection::ExecuteMany(const py::object &query, py::object params_p) { py::gil_scoped_acquire gil; ConnectionLockGuard conn_lock(*this); con.SetResult(nullptr); @@ -509,7 +509,7 @@ shared_ptr DuckDBPyConnection::ExecuteMany(const py::object if (query_result) { // Don't use CreateRelation here — the result is stored inside the connection, // so setting connection_owner would create a ref cycle (connection → result → connection). - con.SetResult(make_uniq(make_shared_ptr(std::move(query_result)))); + con.SetResult(std::make_unique(std::make_shared(std::move(query_result)))); } return shared_from_this(); @@ -671,10 +671,10 @@ unique_ptr DuckDBPyConnection::PrepareAndExecuteInternal(unique_ptr } vector> DuckDBPyConnection::GetStatements(const py::object &query) { - shared_ptr statement_obj; - if (py::try_cast(query, statement_obj)) { + if (py::isinstance(query)) { + auto &statement_obj = py::cast(query); vector> result; - result.push_back(statement_obj->GetStatement()); + result.push_back(statement_obj.GetStatement()); return result; } if (py::isinstance(query)) { @@ -686,11 +686,11 @@ vector> DuckDBPyConnection::GetStatements(const py::obj throw InvalidInputException("Please provide either a DuckDBPyStatement or a string representing the query"); } -shared_ptr DuckDBPyConnection::ExecuteFromString(const string &query) { +std::shared_ptr DuckDBPyConnection::ExecuteFromString(const string &query) { return Execute(py::str(query)); } -shared_ptr DuckDBPyConnection::Execute(const py::object &query, py::object params) { +std::shared_ptr DuckDBPyConnection::Execute(const py::object &query, py::object params) { py::gil_scoped_acquire gil; ConnectionLockGuard conn_lock(*this); con.SetResult(nullptr); @@ -713,13 +713,13 @@ shared_ptr DuckDBPyConnection::Execute(const py::object &que if (res) { // Don't use CreateRelation here — the result is stored inside the connection, // so setting connection_owner would create a ref cycle (connection → result → connection). - con.SetResult(make_uniq(make_shared_ptr(std::move(res)))); + con.SetResult(std::make_unique(std::make_shared(std::move(res)))); } return shared_from_this(); } -shared_ptr DuckDBPyConnection::Append(const string &name, const PandasDataFrame &value, - bool by_name) { +std::shared_ptr DuckDBPyConnection::Append(const string &name, const PandasDataFrame &value, + bool by_name) { RegisterPythonObject("__append_df", value); string columns = ""; if (by_name) { @@ -743,8 +743,8 @@ shared_ptr DuckDBPyConnection::Append(const string &name, co return Execute(py::str(sql_query)); } -shared_ptr DuckDBPyConnection::RegisterPythonObject(const string &name, - const py::object &python_object) { +std::shared_ptr DuckDBPyConnection::RegisterPythonObject(const string &name, + const py::object &python_object) { auto &connection = con.GetConnection(); auto &client = *connection.context; auto object = PythonReplacementScan::ReplacementObject(python_object, name, client); @@ -797,7 +797,7 @@ static void ParseMultiFileOptions(ClientContext &context, named_parameter_map_t } } -unique_ptr DuckDBPyConnection::ReadJSON( +std::unique_ptr DuckDBPyConnection::ReadJSON( const py::object &name_p, const Optional &columns, const Optional &sample_size, const Optional &maximum_depth, const Optional &records, const Optional &format, const Optional &date_format, const Optional ×tamp_format, @@ -1064,7 +1064,7 @@ void ConvertBooleanValue(const py::object &value, string param_name, named_param } } -unique_ptr DuckDBPyConnection::ReadCSV(const py::object &name_p, py::kwargs &kwargs) { +std::unique_ptr DuckDBPyConnection::ReadCSV(const py::object &name_p, py::kwargs &kwargs) { py::object header = py::none(); py::object strict_mode = py::none(); py::object auto_detect = py::none(); @@ -1224,7 +1224,7 @@ unique_ptr DuckDBPyConnection::ReadCSV(const py::object &name_ child_list_t struct_fields; py::dict dtype_dict = dtype; for (auto &kv : dtype_dict) { - shared_ptr sql_type; + std::shared_ptr sql_type; if (!py::try_cast(kv.second, sql_type)) { struct_fields.emplace_back(py::str(kv.first), py::str(kv.second)); } else { @@ -1237,7 +1237,7 @@ unique_ptr DuckDBPyConnection::ReadCSV(const py::object &name_ vector list_values; py::list dtype_list = dtype; for (auto &child : dtype_list) { - shared_ptr sql_type; + std::shared_ptr sql_type; if (!py::try_cast(child, sql_type)) { list_values.push_back(Value(py::str(child))); } else { @@ -1584,7 +1584,8 @@ void DuckDBPyConnection::ExecuteImmediately(vector> sta } } -unique_ptr DuckDBPyConnection::RunQuery(const py::object &query, string alias, py::object params) { +std::unique_ptr DuckDBPyConnection::RunQuery(const py::object &query, string alias, + py::object params) { auto &connection = con.GetConnection(); if (alias.empty()) { alias = "unnamed_relation_" + StringUtil::GenerateRandomName(16); @@ -1648,7 +1649,7 @@ unique_ptr DuckDBPyConnection::RunQuery(const py::object &quer return CreateRelation(std::move(relation)); } -unique_ptr DuckDBPyConnection::Table(const string &tname) { +std::unique_ptr DuckDBPyConnection::Table(const string &tname) { auto &connection = con.GetConnection(); auto qualified_name = QualifiedName::Parse(tname); if (qualified_name.Schema().empty()) { @@ -1674,8 +1675,8 @@ static vector> ValueListFromExpressions(const py::a for (idx_t i = 0; i < arg_count; i++) { py::handle arg = expressions[i]; - shared_ptr py_expr; - if (!py::try_cast>(arg, py_expr)) { + std::shared_ptr py_expr; + if (!py::try_cast>(arg, py_expr)) { throw InvalidInputException("Please provide arguments of type Expression!"); } auto expr = py_expr->GetExpression().Copy(); @@ -1710,7 +1711,7 @@ static vector>> ValueListsFromTuples(const p return result; } -unique_ptr DuckDBPyConnection::Values(const py::args &args) { +std::unique_ptr DuckDBPyConnection::Values(const py::args &args) { auto &connection = con.GetConnection(); auto &context = *connection.context; @@ -1736,12 +1737,12 @@ unique_ptr DuckDBPyConnection::Values(const py::args &args) { } } -unique_ptr DuckDBPyConnection::View(const string &vname) { +std::unique_ptr DuckDBPyConnection::View(const string &vname) { auto &connection = con.GetConnection(); return CreateRelation(connection.View(Identifier(vname))); } -unique_ptr DuckDBPyConnection::TableFunction(const string &fname, py::object params) { +std::unique_ptr DuckDBPyConnection::TableFunction(const string &fname, py::object params) { auto &connection = con.GetConnection(); auto &context = *connection.context; if (params.is_none()) { @@ -1755,7 +1756,7 @@ unique_ptr DuckDBPyConnection::TableFunction(const string &fna connection.TableFunction(fname, DuckDBPyConnection::TransformPythonParamList(context, params))); } -unique_ptr DuckDBPyConnection::FromDF(const PandasDataFrame &value) { +std::unique_ptr DuckDBPyConnection::FromDF(const PandasDataFrame &value) { auto &connection = con.GetConnection(); string name = "df_" + StringUtil::GenerateRandomName(); if (PandasDataFrame::IsPyArrowBacked(value)) { @@ -1768,10 +1769,10 @@ unique_ptr DuckDBPyConnection::FromDF(const PandasDataFrame &v return CreateRelation(std::move(rel)); } -unique_ptr DuckDBPyConnection::FromParquet(const py::object &path_or_buffer, bool binary_as_string, - bool file_row_number, bool filename, - bool hive_partitioning, bool union_by_name, - const py::object &compression) { +std::unique_ptr DuckDBPyConnection::FromParquet(const py::object &path_or_buffer, + bool binary_as_string, bool file_row_number, + bool filename, bool hive_partitioning, + bool union_by_name, const py::object &compression) { auto &connection = con.GetConnection(); auto path_like = GetPathLike(path_or_buffer); auto file_like_object_wrapper = std::move(path_like.dependency); @@ -1804,7 +1805,7 @@ unique_ptr DuckDBPyConnection::FromParquet(const py::object &p return CreateRelation(parquet_relation->Alias(name)); } -unique_ptr DuckDBPyConnection::FromArrow(py::object &arrow_object) { +std::unique_ptr DuckDBPyConnection::FromArrow(py::object &arrow_object) { auto &connection = con.GetConnection(); string name = "arrow_object_" + StringUtil::GenerateRandomName(); if (!IsAcceptedArrowObject(arrow_object)) { @@ -1822,7 +1823,7 @@ unordered_set DuckDBPyConnection::GetTableNames(const string &query, boo return connection.GetTableNames(query, qualified); } -shared_ptr DuckDBPyConnection::UnregisterPythonObject(const string &name) { +std::shared_ptr DuckDBPyConnection::UnregisterPythonObject(const string &name) { auto &connection = con.GetConnection(); if (!registered_objects.count(name)) { return shared_from_this(); @@ -1836,12 +1837,12 @@ shared_ptr DuckDBPyConnection::UnregisterPythonObject(const return shared_from_this(); } -shared_ptr DuckDBPyConnection::Begin() { +std::shared_ptr DuckDBPyConnection::Begin() { ExecuteFromString("BEGIN TRANSACTION"); return shared_from_this(); } -shared_ptr DuckDBPyConnection::Commit() { +std::shared_ptr DuckDBPyConnection::Commit() { auto &connection = con.GetConnection(); if (connection.context->transaction.IsAutoCommit()) { return shared_from_this(); @@ -1850,12 +1851,12 @@ shared_ptr DuckDBPyConnection::Commit() { return shared_from_this(); } -shared_ptr DuckDBPyConnection::Rollback() { +std::shared_ptr DuckDBPyConnection::Rollback() { ExecuteFromString("ROLLBACK"); return shared_from_this(); } -shared_ptr DuckDBPyConnection::Checkpoint() { +std::shared_ptr DuckDBPyConnection::Checkpoint() { ExecuteFromString("CHECKPOINT"); return shared_from_this(); } @@ -1956,7 +1957,7 @@ void DuckDBPyConnection::LoadExtension(const string &extension) { ExtensionHelper::LoadExternalExtension(*connection.context, extension_opts); } -shared_ptr DefaultConnectionHolder::Get() { +std::shared_ptr DefaultConnectionHolder::Get() { lock_guard guard(l); if (!connection || connection->con.ConnectionIsClosed()) { py::dict config_dict; @@ -1965,16 +1966,16 @@ shared_ptr DefaultConnectionHolder::Get() { return connection; } -void DefaultConnectionHolder::Set(shared_ptr conn) { +void DefaultConnectionHolder::Set(std::shared_ptr conn) { lock_guard guard(l); connection = conn; } -void DuckDBPyConnection::Cursors::AddCursor(shared_ptr conn) { +void DuckDBPyConnection::Cursors::AddCursor(std::shared_ptr conn) { lock_guard l(lock); // Clean up previously created cursors - vector> compacted_cursors; + vector> compacted_cursors; bool needs_compaction = false; for (auto &cur_p : cursors) { auto cur = cur_p.lock(); @@ -2011,8 +2012,8 @@ void DuckDBPyConnection::Cursors::ClearCursors() { cursors.clear(); } -shared_ptr DuckDBPyConnection::Cursor() { - auto res = make_shared_ptr(); +std::shared_ptr DuckDBPyConnection::Cursor() { + auto res = std::make_shared(); res->con.SetDatabase(con); res->con.SetConnection(make_uniq(res->con.GetDatabase())); cursors.AddCursor(res); @@ -2189,8 +2190,8 @@ void InstantiateNewInstance(DuckDB &db) { system_catalog.CreateFunction(transaction, scan_info); } -static shared_ptr FetchOrCreateInstance(const string &database_path, DBConfig &config) { - auto res = make_shared_ptr(); +static std::shared_ptr FetchOrCreateInstance(const string &database_path, DBConfig &config) { + auto res = std::make_shared(); bool cache_instance = database_path != ":memory:" && !database_path.empty(); config.replacement_scans.emplace_back(PythonReplacementScan::Replace); { @@ -2227,8 +2228,8 @@ static string GetPathString(const py::object &path) { throw InvalidInputException("Please provide either a str or a pathlib.Path, not %s", actual_type); } -shared_ptr DuckDBPyConnection::Connect(const py::object &database_p, bool read_only, - const py::dict &config_options) { +std::shared_ptr DuckDBPyConnection::Connect(const py::object &database_p, bool read_only, + const py::dict &config_options) { auto config_dict = TransformPyConfigDict(config_options); auto database = GetPathString(database_p); if (IsDefaultConnectionString(database, read_only, config_dict)) { @@ -2282,17 +2283,17 @@ identifier_map_t DuckDBPyConnection::TransformPythonParamDic return args; } -shared_ptr DuckDBPyConnection::DefaultConnection() { +std::shared_ptr DuckDBPyConnection::DefaultConnection() { return default_connection.Get(); } -void DuckDBPyConnection::SetDefaultConnection(shared_ptr connection) { +void DuckDBPyConnection::SetDefaultConnection(std::shared_ptr connection) { return default_connection.Set(std::move(connection)); } PythonImportCache *DuckDBPyConnection::ImportCache() { if (!import_cache) { - import_cache = make_shared_ptr(); + import_cache = std::make_shared(); } return import_cache.get(); } @@ -2306,7 +2307,7 @@ ModifiedMemoryFileSystem &DuckDBPyConnection::GetObjectFileSystem() { throw InvalidInputException( "This operation could not be completed because required module 'fsspec' is not installed"); } - internal_object_filesystem = make_shared_ptr(modified_memory_fs()); + internal_object_filesystem = std::make_shared(modified_memory_fs()); auto &abstract_fs = reinterpret_cast(*internal_object_filesystem); RegisterFilesystem(abstract_fs); } @@ -2317,7 +2318,7 @@ bool DuckDBPyConnection::IsInteractive() { return DuckDBPyConnection::environment != PythonEnvironmentType::NORMAL; } -shared_ptr DuckDBPyConnection::Enter() { +std::shared_ptr DuckDBPyConnection::Enter() { return shared_from_this(); } diff --git a/src/duckdb_py/pyconnection/type_creation.cpp b/src/duckdb_py/pyconnection/type_creation.cpp index a2892b14..0a98adbb 100644 --- a/src/duckdb_py/pyconnection/type_creation.cpp +++ b/src/duckdb_py/pyconnection/type_creation.cpp @@ -2,20 +2,20 @@ namespace duckdb { -shared_ptr DuckDBPyConnection::MapType(const shared_ptr &key_type, - const shared_ptr &value_type) { +std::shared_ptr DuckDBPyConnection::MapType(const std::shared_ptr &key_type, + const std::shared_ptr &value_type) { auto map_type = LogicalType::MAP(key_type->Type(), value_type->Type()); - return make_shared_ptr(map_type); + return std::make_shared(map_type); } -shared_ptr DuckDBPyConnection::ListType(const shared_ptr &type) { +std::shared_ptr DuckDBPyConnection::ListType(const std::shared_ptr &type) { auto array_type = LogicalType::LIST(type->Type()); - return make_shared_ptr(array_type); + return std::make_shared(array_type); } -shared_ptr DuckDBPyConnection::ArrayType(const shared_ptr &type, idx_t size) { +std::shared_ptr DuckDBPyConnection::ArrayType(const std::shared_ptr &type, idx_t size) { auto array_type = LogicalType::ARRAY(type->Type(), size); - return make_shared_ptr(array_type); + return std::make_shared(array_type); } static child_list_t GetChildList(const py::object &container) { @@ -24,8 +24,8 @@ static child_list_t GetChildList(const py::object &container) { const py::list &fields = container; idx_t i = 1; for (auto &item : fields) { - shared_ptr pytype; - if (!py::try_cast>(item, pytype)) { + std::shared_ptr pytype; + if (!py::try_cast>(item, pytype)) { string actual_type = py::str(py::type::of(item)); throw InvalidInputException("object has to be a list of DuckDBPyType's, not '%s'", actual_type); } @@ -38,8 +38,8 @@ static child_list_t GetChildList(const py::object &container) { auto &name_p = item.first; auto &type_p = item.second; auto name = Identifier(py::str(name_p)); - shared_ptr pytype; - if (!py::try_cast>(type_p, pytype)) { + std::shared_ptr pytype; + if (!py::try_cast>(type_p, pytype)) { string actual_type = py::str(py::type::of(type_p)); throw InvalidInputException("object has to be a list of DuckDBPyType's, not '%s'", actual_type); } @@ -53,51 +53,51 @@ static child_list_t GetChildList(const py::object &container) { } } -shared_ptr DuckDBPyConnection::StructType(const py::object &fields) { +std::shared_ptr DuckDBPyConnection::StructType(const py::object &fields) { child_list_t types = GetChildList(fields); if (types.empty()) { throw InvalidInputException("Can not create an empty struct type!"); } auto struct_type = LogicalType::STRUCT(std::move(types)); - return make_shared_ptr(struct_type); + return std::make_shared(struct_type); } -shared_ptr DuckDBPyConnection::UnionType(const py::object &members) { +std::shared_ptr DuckDBPyConnection::UnionType(const py::object &members) { child_list_t types = GetChildList(members); if (types.empty()) { throw InvalidInputException("Can not create an empty union type!"); } auto union_type = LogicalType::UNION(std::move(types)); - return make_shared_ptr(union_type); + return std::make_shared(union_type); } -shared_ptr DuckDBPyConnection::EnumType(const string &name, const shared_ptr &type, - const py::list &values_p) { +std::shared_ptr +DuckDBPyConnection::EnumType(const string &name, const std::shared_ptr &type, const py::list &values_p) { throw NotImplementedException("enum_type creation method is not implemented yet"); } -shared_ptr DuckDBPyConnection::DecimalType(int width, int scale) { +std::shared_ptr DuckDBPyConnection::DecimalType(int width, int scale) { auto decimal_type = LogicalType::DECIMAL(width, scale); - return make_shared_ptr(decimal_type); + return std::make_shared(decimal_type); } -shared_ptr DuckDBPyConnection::StringType(const string &collation) { +std::shared_ptr DuckDBPyConnection::StringType(const string &collation) { LogicalType type; if (collation.empty()) { type = LogicalType::VARCHAR; } else { type = LogicalType::VARCHAR_COLLATION(collation); } - return make_shared_ptr(type); + return std::make_shared(type); } -shared_ptr DuckDBPyConnection::Type(const string &type_str) { +std::shared_ptr DuckDBPyConnection::Type(const string &type_str) { auto &connection = con.GetConnection(); auto &context = *connection.context; - shared_ptr result; + std::shared_ptr result; context.RunFunctionInTransaction([&result, &type_str, &context]() { - result = make_shared_ptr(TransformStringToLogicalType(type_str, context)); + result = std::make_shared(TransformStringToLogicalType(type_str, context)); }); return result; } diff --git a/src/duckdb_py/pyexpression.cpp b/src/duckdb_py/pyexpression.cpp index e6d263a6..4d984b36 100644 --- a/src/duckdb_py/pyexpression.cpp +++ b/src/duckdb_py/pyexpression.cpp @@ -43,35 +43,35 @@ const ParsedExpression &DuckDBPyExpression::GetExpression() const { return *expression; } -shared_ptr DuckDBPyExpression::Copy() const { +std::shared_ptr DuckDBPyExpression::Copy() const { auto expr = GetExpression().Copy(); - return make_shared_ptr(std::move(expr), order_type, null_order); + return std::make_shared(std::move(expr), order_type, null_order); } -shared_ptr DuckDBPyExpression::SetAlias(const string &name) const { +std::shared_ptr DuckDBPyExpression::SetAlias(const string &name) const { auto copied_expression = GetExpression().Copy(); copied_expression->SetAlias(Identifier(name)); - return make_shared_ptr(std::move(copied_expression)); + return std::make_shared(std::move(copied_expression)); } -shared_ptr DuckDBPyExpression::Cast(const DuckDBPyType &type) const { +std::shared_ptr DuckDBPyExpression::Cast(const DuckDBPyType &type) const { auto copied_expression = GetExpression().Copy(); auto case_expr = make_uniq(type.Type(), std::move(copied_expression)); - return make_shared_ptr(std::move(case_expr)); + return std::make_shared(std::move(case_expr)); } -shared_ptr DuckDBPyExpression::Between(const DuckDBPyExpression &lower, - const DuckDBPyExpression &upper) { +std::shared_ptr DuckDBPyExpression::Between(const DuckDBPyExpression &lower, + const DuckDBPyExpression &upper) { auto copied_expression = GetExpression().Copy(); auto between_expr = make_uniq(std::move(copied_expression), lower.GetExpression().Copy(), upper.GetExpression().Copy()); - return make_shared_ptr(std::move(between_expr)); + return std::make_shared(std::move(between_expr)); } -shared_ptr DuckDBPyExpression::Collate(const string &collation) { +std::shared_ptr DuckDBPyExpression::Collate(const string &collation) { auto copied_expression = GetExpression().Copy(); auto collation_expression = make_uniq(collation, std::move(copied_expression)); - return make_shared_ptr(std::move(collation_expression)); + return std::make_shared(std::move(collation_expression)); } // Case Expression modifiers @@ -82,18 +82,18 @@ void DuckDBPyExpression::AssertCaseExpression() const { } } -shared_ptr DuckDBPyExpression::InternalWhen(unique_ptr expr, - const DuckDBPyExpression &condition, - const DuckDBPyExpression &value) { +std::shared_ptr DuckDBPyExpression::InternalWhen(unique_ptr expr, + const DuckDBPyExpression &condition, + const DuckDBPyExpression &value) { CaseCheck check; check.when_expr = condition.GetExpression().Copy(); check.then_expr = value.GetExpression().Copy(); expr->CaseChecksMutable().push_back(std::move(check)); - return make_shared_ptr(std::move(expr)); + return std::make_shared(std::move(expr)); } -shared_ptr DuckDBPyExpression::When(const DuckDBPyExpression &condition, - const DuckDBPyExpression &value) { +std::shared_ptr DuckDBPyExpression::When(const DuckDBPyExpression &condition, + const DuckDBPyExpression &value) { AssertCaseExpression(); auto expr_p = expression->Copy(); auto expr = unique_ptr_cast(std::move(expr_p)); @@ -101,99 +101,99 @@ shared_ptr DuckDBPyExpression::When(const DuckDBPyExpression return InternalWhen(std::move(expr), condition, value); } -shared_ptr DuckDBPyExpression::Else(const DuckDBPyExpression &value) { +std::shared_ptr DuckDBPyExpression::Else(const DuckDBPyExpression &value) { AssertCaseExpression(); auto expr_p = expression->Copy(); auto expr = unique_ptr_cast(std::move(expr_p)); expr->ElseMutable() = value.GetExpression().Copy(); - return make_shared_ptr(std::move(expr)); + return std::make_shared(std::move(expr)); } // Binary operators -shared_ptr DuckDBPyExpression::Add(const DuckDBPyExpression &other) const { +std::shared_ptr DuckDBPyExpression::Add(const DuckDBPyExpression &other) const { return DuckDBPyExpression::BinaryOperator("+", *this, other); } -shared_ptr DuckDBPyExpression::Subtract(const DuckDBPyExpression &other) const { +std::shared_ptr DuckDBPyExpression::Subtract(const DuckDBPyExpression &other) const { return DuckDBPyExpression::BinaryOperator("-", *this, other); } -shared_ptr DuckDBPyExpression::Multiply(const DuckDBPyExpression &other) const { +std::shared_ptr DuckDBPyExpression::Multiply(const DuckDBPyExpression &other) const { return DuckDBPyExpression::BinaryOperator("*", *this, other); } -shared_ptr DuckDBPyExpression::Division(const DuckDBPyExpression &other) const { +std::shared_ptr DuckDBPyExpression::Division(const DuckDBPyExpression &other) const { return DuckDBPyExpression::BinaryOperator("/", *this, other); } -shared_ptr DuckDBPyExpression::FloorDivision(const DuckDBPyExpression &other) const { +std::shared_ptr DuckDBPyExpression::FloorDivision(const DuckDBPyExpression &other) const { return DuckDBPyExpression::BinaryOperator("//", *this, other); } -shared_ptr DuckDBPyExpression::Modulo(const DuckDBPyExpression &other) const { +std::shared_ptr DuckDBPyExpression::Modulo(const DuckDBPyExpression &other) const { return DuckDBPyExpression::BinaryOperator("%", *this, other); } -shared_ptr DuckDBPyExpression::Power(const DuckDBPyExpression &other) const { +std::shared_ptr DuckDBPyExpression::Power(const DuckDBPyExpression &other) const { return DuckDBPyExpression::BinaryOperator("**", *this, other); } // Comparison expressions -shared_ptr DuckDBPyExpression::Equality(const DuckDBPyExpression &other) { +std::shared_ptr DuckDBPyExpression::Equality(const DuckDBPyExpression &other) { return ComparisonExpression(ExpressionType::COMPARE_EQUAL, *this, other); } -shared_ptr DuckDBPyExpression::Inequality(const DuckDBPyExpression &other) { +std::shared_ptr DuckDBPyExpression::Inequality(const DuckDBPyExpression &other) { return ComparisonExpression(ExpressionType::COMPARE_NOTEQUAL, *this, other); } -shared_ptr DuckDBPyExpression::GreaterThan(const DuckDBPyExpression &other) { +std::shared_ptr DuckDBPyExpression::GreaterThan(const DuckDBPyExpression &other) { return ComparisonExpression(ExpressionType::COMPARE_GREATERTHAN, *this, other); } -shared_ptr DuckDBPyExpression::GreaterThanOrEqual(const DuckDBPyExpression &other) { +std::shared_ptr DuckDBPyExpression::GreaterThanOrEqual(const DuckDBPyExpression &other) { return ComparisonExpression(ExpressionType::COMPARE_GREATERTHANOREQUALTO, *this, other); } -shared_ptr DuckDBPyExpression::LessThan(const DuckDBPyExpression &other) { +std::shared_ptr DuckDBPyExpression::LessThan(const DuckDBPyExpression &other) { return ComparisonExpression(ExpressionType::COMPARE_LESSTHAN, *this, other); } -shared_ptr DuckDBPyExpression::LessThanOrEqual(const DuckDBPyExpression &other) { +std::shared_ptr DuckDBPyExpression::LessThanOrEqual(const DuckDBPyExpression &other) { return ComparisonExpression(ExpressionType::COMPARE_LESSTHANOREQUALTO, *this, other); } // AND, OR and NOT -shared_ptr DuckDBPyExpression::Not() { +std::shared_ptr DuckDBPyExpression::Not() { return DuckDBPyExpression::InternalUnaryOperator(ExpressionType::OPERATOR_NOT, *this); } -shared_ptr DuckDBPyExpression::And(const DuckDBPyExpression &other) const { +std::shared_ptr DuckDBPyExpression::And(const DuckDBPyExpression &other) const { return DuckDBPyExpression::InternalConjunction(ExpressionType::CONJUNCTION_AND, *this, other); } -shared_ptr DuckDBPyExpression::Or(const DuckDBPyExpression &other) const { +std::shared_ptr DuckDBPyExpression::Or(const DuckDBPyExpression &other) const { return DuckDBPyExpression::InternalConjunction(ExpressionType::CONJUNCTION_OR, *this, other); } // NULL -shared_ptr DuckDBPyExpression::IsNull() { +std::shared_ptr DuckDBPyExpression::IsNull() { return DuckDBPyExpression::InternalUnaryOperator(ExpressionType::OPERATOR_IS_NULL, *this); } -shared_ptr DuckDBPyExpression::IsNotNull() { +std::shared_ptr DuckDBPyExpression::IsNotNull() { return DuckDBPyExpression::InternalUnaryOperator(ExpressionType::OPERATOR_IS_NOT_NULL, *this); } // IN / NOT IN -shared_ptr DuckDBPyExpression::CreateCompareExpression(ExpressionType compare_type, - const py::args &args) { +std::shared_ptr DuckDBPyExpression::CreateCompareExpression(ExpressionType compare_type, + const py::args &args) { D_ASSERT(args.size() >= 1); vector> expressions; @@ -201,25 +201,25 @@ shared_ptr DuckDBPyExpression::CreateCompareExpression(Expre expressions.push_back(GetExpression().Copy()); for (auto arg : args) { - shared_ptr py_expr; - if (!py::try_cast>(arg, py_expr)) { + std::shared_ptr py_expr; + if (!py::try_cast>(arg, py_expr)) { throw InvalidInputException("Please provide arguments of type Expression!"); } auto expr = py_expr->GetExpression().Copy(); expressions.push_back(std::move(expr)); } auto operator_expr = make_uniq(compare_type, std::move(expressions)); - return make_shared_ptr(std::move(operator_expr)); + return std::make_shared(std::move(operator_expr)); } -shared_ptr DuckDBPyExpression::In(const py::args &args) { +std::shared_ptr DuckDBPyExpression::In(const py::args &args) { if (args.size() == 0) { throw InvalidInputException("Incorrect amount of parameters to 'isin', needs at least 1 parameter"); } return CreateCompareExpression(ExpressionType::COMPARE_IN, args); } -shared_ptr DuckDBPyExpression::NotIn(const py::args &args) { +std::shared_ptr DuckDBPyExpression::NotIn(const py::args &args) { if (args.size() == 0) { throw InvalidInputException("Incorrect amount of parameters to 'isnotin', needs at least 1 parameter"); } @@ -228,13 +228,13 @@ shared_ptr DuckDBPyExpression::NotIn(const py::args &args) { // COALESCE -shared_ptr DuckDBPyExpression::Coalesce(const py::args &args) { +std::shared_ptr DuckDBPyExpression::Coalesce(const py::args &args) { vector> expressions; expressions.reserve(args.size()); for (auto arg : args) { - shared_ptr py_expr; - if (!py::try_cast>(arg, py_expr)) { + std::shared_ptr py_expr; + if (!py::try_cast>(arg, py_expr)) { throw InvalidInputException("Please provide arguments of type Expression!"); } auto expr = py_expr->GetExpression().Copy(); @@ -244,18 +244,18 @@ shared_ptr DuckDBPyExpression::Coalesce(const py::args &args throw InvalidInputException("Please provide at least one argument"); } auto operator_expr = make_uniq(ExpressionType::OPERATOR_COALESCE, std::move(expressions)); - return make_shared_ptr(std::move(operator_expr)); + return std::make_shared(std::move(operator_expr)); } // Order modifiers -shared_ptr DuckDBPyExpression::Ascending() { +std::shared_ptr DuckDBPyExpression::Ascending() { auto py_expr = Copy(); py_expr->order_type = OrderType::ASCENDING; return py_expr; } -shared_ptr DuckDBPyExpression::Descending() { +std::shared_ptr DuckDBPyExpression::Descending() { auto py_expr = Copy(); py_expr->order_type = OrderType::DESCENDING; return py_expr; @@ -263,13 +263,13 @@ shared_ptr DuckDBPyExpression::Descending() { // Null order modifiers -shared_ptr DuckDBPyExpression::NullsFirst() { +std::shared_ptr DuckDBPyExpression::NullsFirst() { auto py_expr = Copy(); py_expr->null_order = OrderByNullType::NULLS_FIRST; return py_expr; } -shared_ptr DuckDBPyExpression::NullsLast() { +std::shared_ptr DuckDBPyExpression::NullsLast() { auto py_expr = Copy(); py_expr->null_order = OrderByNullType::NULLS_LAST; return py_expr; @@ -277,7 +277,7 @@ shared_ptr DuckDBPyExpression::NullsLast() { // Unary operators -shared_ptr DuckDBPyExpression::Negate() { +std::shared_ptr DuckDBPyExpression::Negate() { vector> children; children.push_back(GetExpression().Copy()); return DuckDBPyExpression::InternalFunctionExpression("-", std::move(children), true); @@ -297,7 +297,7 @@ static void PopulateExcludeList(qualified_column_set_t &exclude, py::object list exclude.insert(qname); continue; } - shared_ptr expr; + std::shared_ptr expr; if (!py::try_cast(item, expr)) { throw py::value_error("Items in the exclude list should either be 'str' or Expression"); } @@ -309,14 +309,14 @@ static void PopulateExcludeList(qualified_column_set_t &exclude, py::object list } } -shared_ptr DuckDBPyExpression::StarExpression(py::object exclude_list) { +std::shared_ptr DuckDBPyExpression::StarExpression(py::object exclude_list) { case_insensitive_set_t exclude; auto star = make_uniq(); PopulateExcludeList(star->ExcludeListMutable(), std::move(exclude_list)); - return make_shared_ptr(std::move(star)); + return std::make_shared(std::move(star)); } -shared_ptr DuckDBPyExpression::ColumnExpression(const py::args &names) { +std::shared_ptr DuckDBPyExpression::ColumnExpression(const py::args &names) { vector column_names; if (names.size() == 1) { string column_name = std::string(py::str(names[0])); @@ -338,14 +338,14 @@ shared_ptr DuckDBPyExpression::ColumnExpression(const py::ar } } auto column_ref = make_uniq(std::move(column_names)); - return make_shared_ptr(std::move(column_ref)); + return std::make_shared(std::move(column_ref)); } -shared_ptr DuckDBPyExpression::DefaultExpression() { - return make_shared_ptr(make_uniq()); +std::shared_ptr DuckDBPyExpression::DefaultExpression() { + return std::make_shared(make_uniq()); } -shared_ptr DuckDBPyExpression::ConstantExpression(const py::object &value) { +std::shared_ptr DuckDBPyExpression::ConstantExpression(const py::object &value) { auto val = TransformPythonValue(nullptr, value); return InternalConstantExpression(std::move(val)); } @@ -358,8 +358,8 @@ static py::args CreateArgsFromItem(py::handle item) { } } -shared_ptr DuckDBPyExpression::LambdaExpression(const py::object &lhs_p, - const DuckDBPyExpression &rhs) { +std::shared_ptr DuckDBPyExpression::LambdaExpression(const py::object &lhs_p, + const DuckDBPyExpression &rhs) { unique_ptr lhs; if (py::isinstance(lhs_p)) { // LambdaExpression(lhs=(, , )) @@ -369,7 +369,7 @@ shared_ptr DuckDBPyExpression::LambdaExpression(const py::ob unique_ptr column; if (py::isinstance(item)) { // 'item' is already an Expression, check its type and use it - auto column_expr = py::cast>(item); + auto column_expr = py::cast>(item); if (column_expr->GetExpression().GetExpressionType() != ExpressionType::COLUMN_REF) { throw py::value_error("'lhs' was provided as a tuple of columns, but one of the columns is not of " "type ColumnExpression"); @@ -400,7 +400,7 @@ shared_ptr DuckDBPyExpression::LambdaExpression(const py::ob } else if (py::isinstance(lhs_p)) { // LambdaExpression(lhs=Expression) // 'lhs_p' is already an Expression, check its type and use it - auto column_expr = py::cast>(lhs_p); + auto column_expr = py::cast>(lhs_p); if (column_expr->GetExpression().GetExpressionType() != ExpressionType::COLUMN_REF) { throw py::value_error("'lhs' was an Expression, but is not of type ColumnExpression"); } @@ -413,10 +413,10 @@ shared_ptr DuckDBPyExpression::LambdaExpression(const py::ob // parameters) is identical to what the named-parameter constructor produces; only the syntax type differs, and // the single-arrow form is now deprecated and errors by default. lambda_expression->GetLambdaSyntaxTypeMutable() = LambdaSyntaxType::LAMBDA_KEYWORD; - return make_shared_ptr(std::move(lambda_expression)); + return std::make_shared(std::move(lambda_expression)); } -shared_ptr DuckDBPyExpression::SQLExpression(string sql) { +std::shared_ptr DuckDBPyExpression::SQLExpression(string sql) { auto conn = DuckDBPyConnection::DefaultConnection(); auto &context = *conn->con.GetConnection().context; vector> expressions; @@ -432,14 +432,14 @@ shared_ptr DuckDBPyExpression::SQLExpression(string sql) { expressions.size()); } - return make_shared_ptr(std::move(expressions[0])); + return std::make_shared(std::move(expressions[0])); } // Private methods -shared_ptr DuckDBPyExpression::BinaryOperator(const string &function_name, - const DuckDBPyExpression &arg_one, - const DuckDBPyExpression &arg_two) { +std::shared_ptr DuckDBPyExpression::BinaryOperator(const string &function_name, + const DuckDBPyExpression &arg_one, + const DuckDBPyExpression &arg_two) { vector> children; children.push_back(arg_one.GetExpression().Copy()); @@ -447,48 +447,48 @@ shared_ptr DuckDBPyExpression::BinaryOperator(const string & return InternalFunctionExpression(function_name, std::move(children), true); } -shared_ptr +std::shared_ptr DuckDBPyExpression::InternalFunctionExpression(const string &function_name, vector> children, bool is_operator) { auto function_expression = make_uniq(Identifier(function_name), std::move(children), nullptr, nullptr, false, is_operator); - return make_shared_ptr(std::move(function_expression)); + return std::make_shared(std::move(function_expression)); } -shared_ptr DuckDBPyExpression::InternalUnaryOperator(ExpressionType type, - const DuckDBPyExpression &arg) { +std::shared_ptr DuckDBPyExpression::InternalUnaryOperator(ExpressionType type, + const DuckDBPyExpression &arg) { auto expr = arg.GetExpression().Copy(); auto operator_expression = make_uniq(type, std::move(expr)); - return make_shared_ptr(std::move(operator_expression)); + return std::make_shared(std::move(operator_expression)); } -shared_ptr DuckDBPyExpression::InternalConjunction(ExpressionType type, - const DuckDBPyExpression &arg, - const DuckDBPyExpression &other) { +std::shared_ptr DuckDBPyExpression::InternalConjunction(ExpressionType type, + const DuckDBPyExpression &arg, + const DuckDBPyExpression &other) { vector> children; children.reserve(2); children.push_back(arg.GetExpression().Copy()); children.push_back(other.GetExpression().Copy()); auto operator_expression = make_uniq(type, std::move(children)); - return make_shared_ptr(std::move(operator_expression)); + return std::make_shared(std::move(operator_expression)); } -shared_ptr DuckDBPyExpression::InternalConstantExpression(Value val) { - return make_shared_ptr(make_uniq(std::move(val))); +std::shared_ptr DuckDBPyExpression::InternalConstantExpression(Value val) { + return std::make_shared(make_uniq(std::move(val))); } -shared_ptr DuckDBPyExpression::ComparisonExpression(ExpressionType type, - const DuckDBPyExpression &left_p, - const DuckDBPyExpression &right_p) { +std::shared_ptr DuckDBPyExpression::ComparisonExpression(ExpressionType type, + const DuckDBPyExpression &left_p, + const DuckDBPyExpression &right_p) { auto left = left_p.GetExpression().Copy(); auto right = right_p.GetExpression().Copy(); - return make_shared_ptr( + return std::make_shared( make_uniq(type, std::move(left), std::move(right))); } -shared_ptr DuckDBPyExpression::CaseExpression(const DuckDBPyExpression &condition, - const DuckDBPyExpression &value) { +std::shared_ptr DuckDBPyExpression::CaseExpression(const DuckDBPyExpression &condition, + const DuckDBPyExpression &value) { auto expr = make_uniq(); auto case_expr = InternalWhen(std::move(expr), condition, value); @@ -498,12 +498,12 @@ shared_ptr DuckDBPyExpression::CaseExpression(const DuckDBPy return case_expr; } -shared_ptr DuckDBPyExpression::FunctionExpression(const string &function_name, - const py::args &args) { +std::shared_ptr DuckDBPyExpression::FunctionExpression(const string &function_name, + const py::args &args) { vector> expressions; for (auto arg : args) { - shared_ptr py_expr; - if (!py::try_cast>(arg, py_expr)) { + std::shared_ptr py_expr; + if (!py::try_cast>(arg, py_expr)) { string actual_type = py::str(py::type::of(arg)); throw InvalidInputException("Expected argument of type Expression, received '%s' instead", actual_type); } diff --git a/src/duckdb_py/pyexpression/initialize.cpp b/src/duckdb_py/pyexpression/initialize.cpp index 12bbfd8c..c8df85ae 100644 --- a/src/duckdb_py/pyexpression/initialize.cpp +++ b/src/duckdb_py/pyexpression/initialize.cpp @@ -47,7 +47,7 @@ void InitializeStaticMethods(py::module_ &m) { m.def("SQLExpression", &DuckDBPyExpression::SQLExpression, docs, py::arg("expression")); } -static void InitializeDunderMethods(py::class_> &m) { +static void InitializeDunderMethods(py::class_> &m) { const char *docs; docs = R"( @@ -287,7 +287,7 @@ static void InitializeDunderMethods(py::class_> &m) { +static void InitializeImplicitConversion(py::class_> &m) { m.def(py::init<>([](const string &name) { auto names = py::make_tuple(py::str(name)); return DuckDBPyExpression::ColumnExpression(names); @@ -302,7 +302,7 @@ static void InitializeImplicitConversion(py::class_>(m, "Expression", py::module_local()); + py::class_>(m, "Expression", py::module_local()); InitializeStaticMethods(m); InitializeDunderMethods(expression); diff --git a/src/duckdb_py/pyrelation.cpp b/src/duckdb_py/pyrelation.cpp index 10e8aa72..dbc5ee55 100644 --- a/src/duckdb_py/pyrelation.cpp +++ b/src/duckdb_py/pyrelation.cpp @@ -63,7 +63,8 @@ DuckDBPyRelation::~DuckDBPyRelation() { rel.reset(); } -DuckDBPyRelation::DuckDBPyRelation(shared_ptr result_p) : rel(nullptr), result(std::move(result_p)) { +DuckDBPyRelation::DuckDBPyRelation(std::shared_ptr result_p) + : rel(nullptr), result(std::move(result_p)) { if (!result) { throw InternalException("DuckDBPyRelation created without a result"); } @@ -72,7 +73,7 @@ DuckDBPyRelation::DuckDBPyRelation(shared_ptr result_p) : rel(nu this->names = result->GetNames(); } -unique_ptr DuckDBPyRelation::ProjectFromExpression(const string &expression) { +std::unique_ptr DuckDBPyRelation::ProjectFromExpression(const string &expression) { auto projected_relation = DeriveRelation(rel->Project(expression)); for (auto &dep : this->rel->external_dependencies) { projected_relation->rel->AddExternalDependency(dep); @@ -80,7 +81,7 @@ unique_ptr DuckDBPyRelation::ProjectFromExpression(const strin return projected_relation; } -unique_ptr DuckDBPyRelation::Project(const py::args &args, const string &groups) { +std::unique_ptr DuckDBPyRelation::Project(const py::args &args, const string &groups) { if (!rel) { return nullptr; } @@ -95,8 +96,8 @@ unique_ptr DuckDBPyRelation::Project(const py::args &args, con } else { vector> expressions; for (auto arg : args) { - shared_ptr py_expr; - if (!py::try_cast>(arg, py_expr)) { + std::shared_ptr py_expr; + if (!py::try_cast>(arg, py_expr)) { throw InvalidInputException("Please provide arguments of type Expression!"); } auto expr = py_expr->GetExpression().Copy(); @@ -111,7 +112,7 @@ unique_ptr DuckDBPyRelation::Project(const py::args &args, con } } -unique_ptr DuckDBPyRelation::ProjectFromTypes(const py::object &obj) { +std::unique_ptr DuckDBPyRelation::ProjectFromTypes(const py::object &obj) { if (!rel) { return nullptr; } @@ -160,8 +161,9 @@ unique_ptr DuckDBPyRelation::ProjectFromTypes(const py::object return ProjectFromExpression(projection); } -unique_ptr DuckDBPyRelation::EmptyResult(const shared_ptr &context, - const vector &types, vector names) { +std::unique_ptr DuckDBPyRelation::EmptyResult(const shared_ptr &context, + const vector &types, + vector names) { vector dummy_values; D_ASSERT(types.size() == names.size()); dummy_values.reserve(types.size()); @@ -171,12 +173,12 @@ unique_ptr DuckDBPyRelation::EmptyResult(const shared_ptr> single_row(1, dummy_values); auto values_relation = - make_uniq(make_shared_ptr(context, single_row, std::move(names))); + std::make_unique(make_shared_ptr(context, single_row, std::move(names))); // Add a filter on an impossible condition return values_relation->FilterFromExpression("true = false"); } -unique_ptr DuckDBPyRelation::SetAlias(const string &expr) { +std::unique_ptr DuckDBPyRelation::SetAlias(const string &expr) { return DeriveRelation(rel->Alias(expr)); } @@ -184,12 +186,12 @@ py::str DuckDBPyRelation::GetAlias() { return py::str(string(rel->GetAlias())); } -unique_ptr DuckDBPyRelation::Filter(const py::object &expr) { +std::unique_ptr DuckDBPyRelation::Filter(const py::object &expr) { if (py::isinstance(expr)) { string expression = py::cast(expr); return FilterFromExpression(expression); } - shared_ptr expression; + std::shared_ptr expression; if (!py::try_cast(expr, expression)) { throw InvalidInputException("Please provide either a string or a DuckDBPyExpression object to 'filter'"); } @@ -197,25 +199,25 @@ unique_ptr DuckDBPyRelation::Filter(const py::object &expr) { return DeriveRelation(rel->Filter(std::move(expr_p))); } -unique_ptr DuckDBPyRelation::FilterFromExpression(const string &expr) { +std::unique_ptr DuckDBPyRelation::FilterFromExpression(const string &expr) { return DeriveRelation(rel->Filter(expr)); } -unique_ptr DuckDBPyRelation::Limit(int64_t n, int64_t offset) { +std::unique_ptr DuckDBPyRelation::Limit(int64_t n, int64_t offset) { return DeriveRelation(rel->Limit(n, offset)); } -unique_ptr DuckDBPyRelation::Order(const string &expr) { +std::unique_ptr DuckDBPyRelation::Order(const string &expr) { return DeriveRelation(rel->Order(expr)); } -unique_ptr DuckDBPyRelation::Sort(const py::args &args) { +std::unique_ptr DuckDBPyRelation::Sort(const py::args &args) { vector order_nodes; order_nodes.reserve(args.size()); for (auto arg : args) { - shared_ptr py_expr; - if (!py::try_cast>(arg, py_expr)) { + std::shared_ptr py_expr; + if (!py::try_cast>(arg, py_expr)) { string actual_type = py::str(py::type::of(arg)); throw InvalidInputException("Expected argument of type Expression, received '%s' instead", actual_type); } @@ -233,8 +235,8 @@ vector> GetExpressions(ClientContext &context, cons vector> expressions; auto aggregate_list = py::list(expr); for (auto &item : aggregate_list) { - shared_ptr py_expr; - if (!py::try_cast>(item, py_expr)) { + std::shared_ptr py_expr; + if (!py::try_cast>(item, py_expr)) { throw InvalidInputException("Please provide arguments of type Expression!"); } auto expr_ = py_expr->GetExpression().Copy(); @@ -252,7 +254,7 @@ vector> GetExpressions(ClientContext &context, cons } } -unique_ptr DuckDBPyRelation::Aggregate(const py::object &expr, const string &groups) { +std::unique_ptr DuckDBPyRelation::Aggregate(const py::object &expr, const string &groups) { AssertRelation(); auto expressions = GetExpressions(*rel->context->GetContext(), expr); if (!groups.empty()) { @@ -344,7 +346,7 @@ vector CreateExpressionList(const vector &columns, return expressions; } -unique_ptr DuckDBPyRelation::Describe() { +std::unique_ptr DuckDBPyRelation::Describe() { auto &columns = rel->Columns(); vector aggregates; aggregates = {DescribeAggregateInfo("count"), DescribeAggregateInfo("mean", true), @@ -439,10 +441,9 @@ string DuckDBPyRelation::GenerateExpressionList(const string &function_name, vec /* General aggregate functions */ -unique_ptr DuckDBPyRelation::GenericAggregator(const string &function_name, - const string &aggregated_columns, const string &groups, - const string &function_parameter, - const string &projected_columns) { +std::unique_ptr +DuckDBPyRelation::GenericAggregator(const string &function_name, const string &aggregated_columns, const string &groups, + const string &function_parameter, const string &projected_columns) { //! Construct Aggregation Expression auto expr = GenerateExpressionList(function_name, aggregated_columns, groups, function_parameter, false, @@ -450,7 +451,7 @@ unique_ptr DuckDBPyRelation::GenericAggregator(const string &f return Aggregate(py::str(expr), groups); } -unique_ptr +std::unique_ptr DuckDBPyRelation::GenericWindowFunction(const string &function_name, const string &function_parameters, const string &aggr_columns, const string &window_spec, const bool &ignore_nulls, const string &projected_columns) { @@ -459,10 +460,11 @@ DuckDBPyRelation::GenericWindowFunction(const string &function_name, const strin return DeriveRelation(rel->Project(expr)); } -unique_ptr DuckDBPyRelation::ApplyAggOrWin(const string &function_name, const string &agg_columns, - const string &function_parameters, const string &groups, - const string &window_spec, const string &projected_columns, - bool ignore_nulls) { +std::unique_ptr DuckDBPyRelation::ApplyAggOrWin(const string &function_name, + const string &agg_columns, + const string &function_parameters, + const string &groups, const string &window_spec, + const string &projected_columns, bool ignore_nulls) { if (!groups.empty() && !window_spec.empty()) { throw InvalidInputException("Either groups or window must be set (can't be both at the same time)"); } @@ -474,52 +476,54 @@ unique_ptr DuckDBPyRelation::ApplyAggOrWin(const string &funct } } -unique_ptr DuckDBPyRelation::AnyValue(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::AnyValue(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("any_value", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::ArgMax(const std::string &arg_column, const std::string &value_column, - const std::string &groups, const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::ArgMax(const std::string &arg_column, + const std::string &value_column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("arg_max", arg_column, value_column, groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::ArgMin(const std::string &arg_column, const std::string &value_column, - const std::string &groups, const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::ArgMin(const std::string &arg_column, + const std::string &value_column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("arg_min", arg_column, value_column, groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::Avg(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::Avg(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("avg", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::BitAnd(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::BitAnd(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("bit_and", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::BitOr(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::BitOr(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("bit_or", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::BitXor(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::BitXor(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("bit_xor", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::BitStringAgg(const std::string &column, const Optional &min, - const Optional &max, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr +DuckDBPyRelation::BitStringAgg(const std::string &column, const Optional &min, + const Optional &max, const std::string &groups, + const std::string &window_spec, const std::string &projected_columns) { if ((min.is_none() && !max.is_none()) || (!min.is_none() && max.is_none())) { throw InvalidInputException("Both min and max values must be set"); } @@ -533,116 +537,117 @@ unique_ptr DuckDBPyRelation::BitStringAgg(const std::string &c return ApplyAggOrWin("bitstring_agg", column, bitstring_agg_params, groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::BoolAnd(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::BoolAnd(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("bool_and", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::BoolOr(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::BoolOr(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("bool_or", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::ValueCounts(const std::string &column, const std::string &groups) { +std::unique_ptr DuckDBPyRelation::ValueCounts(const std::string &column, const std::string &groups) { return Count(column, groups, "", column); } -unique_ptr DuckDBPyRelation::Count(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::Count(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("count", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::FAvg(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::FAvg(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("favg", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::First(const string &column, const std::string &groups, - const string &projected_columns) { +std::unique_ptr DuckDBPyRelation::First(const string &column, const std::string &groups, + const string &projected_columns) { return GenericAggregator("first", column, groups, "", projected_columns); } -unique_ptr DuckDBPyRelation::FSum(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::FSum(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("fsum", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::GeoMean(const std::string &column, const std::string &groups, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::GeoMean(const std::string &column, const std::string &groups, + const std::string &projected_columns) { return GenericAggregator("geomean", column, groups, "", projected_columns); } -unique_ptr DuckDBPyRelation::Histogram(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::Histogram(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("histogram", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::List(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::List(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("list", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::Last(const std::string &column, const std::string &groups, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::Last(const std::string &column, const std::string &groups, + const std::string &projected_columns) { return GenericAggregator("last", column, groups, "", projected_columns); } -unique_ptr DuckDBPyRelation::Max(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::Max(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("max", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::Min(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::Min(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("min", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::Product(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::Product(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("product", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::StringAgg(const std::string &column, const std::string &sep, - const std::string &groups, const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::StringAgg(const std::string &column, const std::string &sep, + const std::string &groups, const std::string &window_spec, + const std::string &projected_columns) { auto string_agg_params = SQLString::ToString(sep); return ApplyAggOrWin("string_agg", column, string_agg_params, groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::Sum(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::Sum(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("sum", column, "", groups, window_spec, projected_columns); } /* TODO: Approximate aggregate functions */ /* TODO: Statistical aggregate functions */ -unique_ptr DuckDBPyRelation::Median(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::Median(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("median", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::Mode(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::Mode(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("mode", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::QuantileCont(const std::string &column, const py::object &q, - const std::string &groups, const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::QuantileCont(const std::string &column, const py::object &q, + const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { string quantile_params = ""; if (py::isinstance(q)) { quantile_params = std::to_string(q.cast()); @@ -662,9 +667,10 @@ unique_ptr DuckDBPyRelation::QuantileCont(const std::string &c return ApplyAggOrWin("quantile_cont", column, quantile_params, groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::QuantileDisc(const std::string &column, const py::object &q, - const std::string &groups, const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::QuantileDisc(const std::string &column, const py::object &q, + const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { string quantile_params = ""; if (py::isinstance(q)) { quantile_params = std::to_string(q.cast()); @@ -684,27 +690,27 @@ unique_ptr DuckDBPyRelation::QuantileDisc(const std::string &c return ApplyAggOrWin("quantile_disc", column, quantile_params, groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::StdPop(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::StdPop(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("stddev_pop", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::StdSamp(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::StdSamp(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("stddev_samp", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::VarPop(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::VarPop(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("var_pop", column, "", groups, window_spec, projected_columns); } -unique_ptr DuckDBPyRelation::VarSamp(const std::string &column, const std::string &groups, - const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::VarSamp(const std::string &column, const std::string &groups, + const std::string &window_spec, + const std::string &projected_columns) { return ApplyAggOrWin("var_samp", column, "", groups, window_spec, projected_columns); } @@ -721,45 +727,49 @@ py::tuple DuckDBPyRelation::Shape() { return py::make_tuple(length, rel->Columns().size()); } -unique_ptr DuckDBPyRelation::Unique(const string &std_columns) { +std::unique_ptr DuckDBPyRelation::Unique(const string &std_columns) { return DeriveRelation(rel->Project(std_columns)->Distinct()); } /* General-purpose window functions */ -unique_ptr DuckDBPyRelation::RowNumber(const string &window_spec, const string &projected_columns) { +std::unique_ptr DuckDBPyRelation::RowNumber(const string &window_spec, + const string &projected_columns) { return GenericWindowFunction("row_number", "", "*", window_spec, false, projected_columns); } -unique_ptr DuckDBPyRelation::Rank(const string &window_spec, const string &projected_columns) { +std::unique_ptr DuckDBPyRelation::Rank(const string &window_spec, const string &projected_columns) { return GenericWindowFunction("rank", "", "*", window_spec, false, projected_columns); } -unique_ptr DuckDBPyRelation::DenseRank(const string &window_spec, const string &projected_columns) { +std::unique_ptr DuckDBPyRelation::DenseRank(const string &window_spec, + const string &projected_columns) { return GenericWindowFunction("dense_rank", "", "*", window_spec, false, projected_columns); } -unique_ptr DuckDBPyRelation::PercentRank(const string &window_spec, const string &projected_columns) { +std::unique_ptr DuckDBPyRelation::PercentRank(const string &window_spec, + const string &projected_columns) { return GenericWindowFunction("percent_rank", "", "*", window_spec, false, projected_columns); } -unique_ptr DuckDBPyRelation::CumeDist(const string &window_spec, const string &projected_columns) { +std::unique_ptr DuckDBPyRelation::CumeDist(const string &window_spec, + const string &projected_columns) { return GenericWindowFunction("cume_dist", "", "*", window_spec, false, projected_columns); } -unique_ptr DuckDBPyRelation::FirstValue(const string &column, const string &window_spec, - const string &projected_columns) { +std::unique_ptr DuckDBPyRelation::FirstValue(const string &column, const string &window_spec, + const string &projected_columns) { return GenericWindowFunction("first_value", "", column, window_spec, false, projected_columns); } -unique_ptr DuckDBPyRelation::NTile(const string &window_spec, const int &num_buckets, - const string &projected_columns) { +std::unique_ptr DuckDBPyRelation::NTile(const string &window_spec, const int &num_buckets, + const string &projected_columns) { return GenericWindowFunction("ntile", std::to_string(num_buckets), "", window_spec, false, projected_columns); } -unique_ptr DuckDBPyRelation::Lag(const string &column, const string &window_spec, const int &offset, - const string &default_value, const bool &ignore_nulls, - const string &projected_columns) { +std::unique_ptr DuckDBPyRelation::Lag(const string &column, const string &window_spec, + const int &offset, const string &default_value, + const bool &ignore_nulls, const string &projected_columns) { string lag_params = ""; if (offset != 0) { lag_params += std::to_string(offset); @@ -770,14 +780,14 @@ unique_ptr DuckDBPyRelation::Lag(const string &column, const s return GenericWindowFunction("lag", lag_params, column, window_spec, ignore_nulls, projected_columns); } -unique_ptr DuckDBPyRelation::LastValue(const std::string &column, const std::string &window_spec, - const std::string &projected_columns) { +std::unique_ptr DuckDBPyRelation::LastValue(const std::string &column, const std::string &window_spec, + const std::string &projected_columns) { return GenericWindowFunction("last_value", "", column, window_spec, false, projected_columns); } -unique_ptr DuckDBPyRelation::Lead(const string &column, const string &window_spec, const int &offset, - const string &default_value, const bool &ignore_nulls, - const string &projected_columns) { +std::unique_ptr DuckDBPyRelation::Lead(const string &column, const string &window_spec, + const int &offset, const string &default_value, + const bool &ignore_nulls, const string &projected_columns) { string lead_params = ""; if (offset != 0) { lead_params += std::to_string(offset); @@ -788,14 +798,14 @@ unique_ptr DuckDBPyRelation::Lead(const string &column, const return GenericWindowFunction("lead", lead_params, column, window_spec, ignore_nulls, projected_columns); } -unique_ptr DuckDBPyRelation::NthValue(const string &column, const string &window_spec, - const int &offset, const bool &ignore_nulls, - const string &projected_columns) { +std::unique_ptr DuckDBPyRelation::NthValue(const string &column, const string &window_spec, + const int &offset, const bool &ignore_nulls, + const string &projected_columns) { return GenericWindowFunction("nth_value", std::to_string(offset), column, window_spec, ignore_nulls, projected_columns); } -unique_ptr DuckDBPyRelation::Distinct() { +std::unique_ptr DuckDBPyRelation::Distinct() { return DeriveRelation(rel->Distinct()); } @@ -830,7 +840,7 @@ void DuckDBPyRelation::ExecuteOrThrow(bool stream_result) { if (query_result->HasError()) { query_result->ThrowError(); } - result = make_uniq(std::move(query_result)); + result = std::make_unique(std::move(query_result)); } PandasDataFrame DuckDBPyRelation::FetchDF(bool date_as_object) { @@ -1071,14 +1081,14 @@ void DuckDBPyRelation::SetConnectionOwner(py::object owner) { connection_owner = std::move(owner); } -unique_ptr DuckDBPyRelation::DeriveRelation(shared_ptr new_rel) { - auto result_ = make_uniq(std::move(new_rel)); +std::unique_ptr DuckDBPyRelation::DeriveRelation(shared_ptr new_rel) { + auto result_ = std::make_unique(std::move(new_rel)); result_->connection_owner = connection_owner; return result_; } -unique_ptr DuckDBPyRelation::DeriveRelation(shared_ptr result_p) { - auto result_ = make_uniq(std::move(result_p)); +std::unique_ptr DuckDBPyRelation::DeriveRelation(std::shared_ptr result_p) { + auto result_ = std::make_unique(std::move(result_p)); result_->connection_owner = connection_owner; return result_; } @@ -1097,7 +1107,7 @@ static bool ContainsStructFieldByName(LogicalType &type, const string &name) { return false; } -unique_ptr DuckDBPyRelation::GetAttribute(const string &name) { +std::unique_ptr DuckDBPyRelation::GetAttribute(const string &name) { // TODO: support fetching a result containing only column 'name' from a value_relation if (!rel) { throw py::attribute_error( @@ -1126,15 +1136,15 @@ unique_ptr DuckDBPyRelation::GetAttribute(const string &name) return DeriveRelation(rel->Project(std::move(expressions), aliases)); } -unique_ptr DuckDBPyRelation::Union(DuckDBPyRelation *other) { +std::unique_ptr DuckDBPyRelation::Union(DuckDBPyRelation *other) { return DeriveRelation(rel->Union(other->rel)); } -unique_ptr DuckDBPyRelation::Except(DuckDBPyRelation *other) { +std::unique_ptr DuckDBPyRelation::Except(DuckDBPyRelation *other) { return DeriveRelation(rel->Except(other->rel)); } -unique_ptr DuckDBPyRelation::Intersect(DuckDBPyRelation *other) { +std::unique_ptr DuckDBPyRelation::Intersect(DuckDBPyRelation *other) { return DeriveRelation(rel->Intersect(other->rel)); } @@ -1177,8 +1187,8 @@ static JoinType ParseJoinType(const string &type) { throw InvalidInputException("Unsupported join type %s, try one of: %s", provided, options); } -unique_ptr DuckDBPyRelation::Join(DuckDBPyRelation *other, const py::object &condition, - const string &type) { +std::unique_ptr DuckDBPyRelation::Join(DuckDBPyRelation *other, const py::object &condition, + const string &type) { if (!other) { throw InvalidInputException("No relation provided for join"); } @@ -1216,7 +1226,7 @@ unique_ptr DuckDBPyRelation::Join(DuckDBPyRelation *other, con auto join_relation = make_shared_ptr(rel, other->rel, std::move(using_list), join_type); return DeriveRelation(std::move(join_relation)); } - shared_ptr condition_expr; + std::shared_ptr condition_expr; if (!py::try_cast(condition, condition_expr)) { throw InvalidInputException( "Please provide condition as an expression either in string form or as an Expression object"); @@ -1226,7 +1236,7 @@ unique_ptr DuckDBPyRelation::Join(DuckDBPyRelation *other, con return DeriveRelation(rel->Join(other->rel, std::move(conditions), join_type)); } -unique_ptr DuckDBPyRelation::Cross(DuckDBPyRelation *other) { +std::unique_ptr DuckDBPyRelation::Cross(DuckDBPyRelation *other) { return DeriveRelation(rel->CrossProduct(other->rel)); } @@ -1523,7 +1533,7 @@ void DuckDBPyRelation::ToCSV(const string &filename, const py::object &sep, cons } // should this return a rel with the new view? -unique_ptr DuckDBPyRelation::CreateView(const string &view_name, bool replace) { +std::unique_ptr DuckDBPyRelation::CreateView(const string &view_name, bool replace) { rel->CreateView(Identifier(view_name), replace); return DeriveRelation(rel); } @@ -1539,7 +1549,7 @@ static bool IsDescribeStatement(SQLStatement &statement) { return true; } -unique_ptr DuckDBPyRelation::Query(const string &view_name, const string &sql_query) { +std::unique_ptr DuckDBPyRelation::Query(const string &view_name, const string &sql_query) { rel->CreateView(Identifier(view_name), /*replace=*/true, /*temporary=*/true); auto all_dependencies = rel->GetAllDependencies(); @@ -1589,8 +1599,8 @@ void DuckDBPyRelation::Update(const py::object &set_p, const py::object &where) AssertRelation(); unique_ptr condition; if (!py::none().is(where)) { - shared_ptr py_expr; - if (!py::try_cast>(where, py_expr)) { + std::shared_ptr py_expr; + if (!py::try_cast>(where, py_expr)) { throw InvalidInputException("Please provide an Expression to 'condition'"); } condition = py_expr->GetExpression().Copy(); @@ -1616,8 +1626,8 @@ void DuckDBPyRelation::Update(const py::object &set_p, const py::object &where) if (!py::isinstance(item_key)) { throw InvalidInputException("Please provide the column name as the key of the dictionary"); } - shared_ptr py_expr; - if (!py::try_cast>(item_value, py_expr)) { + std::shared_ptr py_expr; + if (!py::try_cast>(item_value, py_expr)) { string actual_type = py::str(py::type::of(item_value)); throw InvalidInputException("Please provide an object of type Expression as the value, not %s", actual_type); @@ -1649,7 +1659,7 @@ void DuckDBPyRelation::Create(const string &table) { PyExecuteRelation(create); } -unique_ptr DuckDBPyRelation::Map(py::function fun, Optional schema) { +std::unique_ptr DuckDBPyRelation::Map(py::function fun, Optional schema) { AssertRelation(); vector params; params.emplace_back(Value::POINTER(CastPointerToValue(fun.ptr()))); diff --git a/src/duckdb_py/pyresult.cpp b/src/duckdb_py/pyresult.cpp index 5de8f848..ed7d0481 100644 --- a/src/duckdb_py/pyresult.cpp +++ b/src/duckdb_py/pyresult.cpp @@ -220,7 +220,7 @@ void InsertCategory(QueryResult &result, unordered_map &categor } } -unique_ptr DuckDBPyResult::InitializeNumpyConversion(bool pandas) { +std::unique_ptr DuckDBPyResult::InitializeNumpyConversion(bool pandas) { if (!result) { throw InvalidInputException("result closed"); } @@ -233,12 +233,12 @@ unique_ptr DuckDBPyResult::InitializeNumpyConversion(bool } auto conversion = - make_uniq(result->types, initial_capacity, result->client_properties, pandas); + std::make_unique(result->types, initial_capacity, result->client_properties, pandas); return conversion; } py::dict DuckDBPyResult::FetchNumpyInternal(bool stream, idx_t vectors_per_chunk, - unique_ptr conversion_p) { + std::unique_ptr conversion_p) { if (!result) { throw InvalidInputException("result closed"); } diff --git a/src/duckdb_py/pystatement.cpp b/src/duckdb_py/pystatement.cpp index eed9976c..cbf254ce 100644 --- a/src/duckdb_py/pystatement.cpp +++ b/src/duckdb_py/pystatement.cpp @@ -4,7 +4,7 @@ namespace duckdb { enum class ExpectedResultType : uint8_t { QUERY_RESULT, NOTHING, CHANGED_ROWS, UNKNOWN }; -static void InitializeReadOnlyProperties(py::class_> &m) { +static void InitializeReadOnlyProperties(py::class_> &m) { m.def_property_readonly("type", &DuckDBPyStatement::Type, "Get the type of the statement.") .def_property_readonly("query", &DuckDBPyStatement::Query, "Get the query equivalent to this statement.") .def_property_readonly("named_parameters", &DuckDBPyStatement::NamedParameters, @@ -16,7 +16,7 @@ static void InitializeReadOnlyProperties(py::class_>(m, "Statement", py::module_local()); + py::class_>(m, "Statement", py::module_local()); InitializeReadOnlyProperties(relation_module); } diff --git a/src/duckdb_py/python_udf.cpp b/src/duckdb_py/python_udf.cpp index 85fa243b..c8199c05 100644 --- a/src/duckdb_py/python_udf.cpp +++ b/src/duckdb_py/python_udf.cpp @@ -423,7 +423,7 @@ struct PythonUDFData { } } - void OverrideReturnType(const shared_ptr &type) { + void OverrideReturnType(const std::shared_ptr &type) { if (!type) { return; } @@ -451,7 +451,7 @@ struct PythonUDFData { } idx_t i = 0; for (auto ¶m : params) { - auto type = py::cast>(param); + auto type = py::cast>(param); parameters[i++] = type->Type(); } } @@ -474,8 +474,8 @@ struct PythonUDFData { auto return_annotation = signature.attr("return_annotation"); auto empty = py::module_::import("inspect").attr("Signature").attr("empty"); if (!py::none().is(return_annotation) && !empty.is(return_annotation)) { - shared_ptr pytype; - if (py::try_cast>(return_annotation, pytype)) { + std::shared_ptr pytype; + if (py::try_cast>(return_annotation, pytype)) { return_type = pytype->Type(); } } @@ -484,8 +484,8 @@ struct PythonUDFData { auto params = py::dict(sig_params); for (auto &item : params) { auto &value = item.second; - shared_ptr pytype; - if (py::try_cast>(value.attr("annotation"), pytype)) { + std::shared_ptr pytype; + if (py::try_cast>(value.attr("annotation"), pytype)) { parameters.push_back(pytype->Type()); } else { std::string kind = py::str(value.attr("kind")); @@ -535,7 +535,7 @@ struct PythonUDFData { ScalarFunction DuckDBPyConnection::CreateScalarUDF(const string &name, const py::function &udf, const py::object ¶meters, - const shared_ptr &return_type, bool vectorized, + const std::shared_ptr &return_type, bool vectorized, FunctionNullHandling null_handling, PythonExceptionHandling exception_handling, bool side_effects) { PythonUDFData data(name, vectorized, null_handling); diff --git a/src/duckdb_py/typing/pytype.cpp b/src/duckdb_py/typing/pytype.cpp index 30192cbe..a9944af4 100644 --- a/src/duckdb_py/typing/pytype.cpp +++ b/src/duckdb_py/typing/pytype.cpp @@ -38,7 +38,7 @@ bool PyUnionType::check_(const py::handle &object) { DuckDBPyType::DuckDBPyType(LogicalType type) : type(std::move(type)) { } -bool DuckDBPyType::Equals(const shared_ptr &other) const { +bool DuckDBPyType::Equals(const std::shared_ptr &other) const { if (!other) { return false; } @@ -49,27 +49,27 @@ bool DuckDBPyType::EqualsString(const string &type_str) const { return StringUtil::CIEquals(type.ToString(), type_str); } -shared_ptr DuckDBPyType::GetAttribute(const string &name) const { +std::shared_ptr DuckDBPyType::GetAttribute(const string &name) const { auto name_identifier = Identifier(name); if (type.id() == LogicalTypeId::STRUCT || type.id() == LogicalTypeId::UNION) { auto &children = StructType::GetChildTypes(type); for (idx_t i = 0; i < children.size(); i++) { auto &child = children[i]; if (child.first == name) { - return make_shared_ptr(StructType::GetChildType(type, i)); + return std::make_shared(StructType::GetChildType(type, i)); } } } if (type.id() == LogicalTypeId::LIST && StringUtil::CIEquals(name, "child")) { - return make_shared_ptr(ListType::GetChildType(type)); + return std::make_shared(ListType::GetChildType(type)); } if (type.id() == LogicalTypeId::MAP) { auto is_key = StringUtil::CIEquals(name, "key"); auto is_value = StringUtil::CIEquals(name, "value"); if (is_key) { - return make_shared_ptr(MapType::KeyType(type)); + return std::make_shared(MapType::KeyType(type)); } else if (is_value) { - return make_shared_ptr(MapType::ValueType(type)); + return std::make_shared(MapType::ValueType(type)); } else { throw py::attribute_error(StringUtil::Format("Tried to get a child from a map by the name of '%s', but " "this type only has 'key' and 'value' children", @@ -118,7 +118,7 @@ static PythonTypeObject GetTypeObjectType(const py::handle &type_object) { return PythonTypeObject::INVALID; } -static LogicalType FromString(const string &type_str, shared_ptr pycon) { +static LogicalType FromString(const string &type_str, std::shared_ptr pycon) { if (!pycon) { pycon = DuckDBPyConnection::DefaultConnection(); } @@ -312,8 +312,8 @@ static LogicalType FromObject(const py::object &object) { return FromString(string_value, nullptr); } case PythonTypeObject::TYPE: { - shared_ptr type_object; - if (!py::try_cast>(object, type_object)) { + std::shared_ptr type_object; + if (!py::try_cast>(object, type_object)) { string actual_type = py::str(py::type::of(object)); throw InvalidInputException("Expected argument of type DuckDBPyType, received '%s' instead", actual_type); } @@ -327,7 +327,7 @@ static LogicalType FromObject(const py::object &object) { } void DuckDBPyType::Initialize(py::handle &m) { - auto type_module = py::class_>(m, "DuckDBPyType", py::module_local()); + auto type_module = py::class_>(m, "DuckDBPyType", py::module_local()); type_module.def("__repr__", &DuckDBPyType::ToString, "Stringified representation of the type object"); type_module.def("__eq__", &DuckDBPyType::Equals, "Compare two types for equality", py::arg("other"), @@ -337,21 +337,21 @@ void DuckDBPyType::Initialize(py::handle &m) { type_module.def("__hash__", [](const DuckDBPyType &type) { return py::hash(py::str(type.ToString())); }); type_module.def_property_readonly("id", &DuckDBPyType::GetId); type_module.def_property_readonly("children", &DuckDBPyType::Children); - type_module.def(py::init<>([](const string &type_str, shared_ptr connection = nullptr) { + type_module.def(py::init<>([](const string &type_str, std::shared_ptr connection = nullptr) { auto ltype = FromString(type_str, std::move(connection)); - return make_shared_ptr(ltype); + return std::make_shared(ltype); })); type_module.def(py::init<>([](const PyGenericAlias &obj) { auto ltype = FromGenericAlias(obj); - return make_shared_ptr(ltype); + return std::make_shared(ltype); })); type_module.def(py::init<>([](const PyUnionType &obj) { auto ltype = FromUnionType(obj); - return make_shared_ptr(ltype); + return std::make_shared(ltype); })); type_module.def(py::init<>([](const py::object &obj) { auto ltype = FromObject(obj); - return make_shared_ptr(ltype); + return std::make_shared(ltype); })); type_module.def("__getattr__", &DuckDBPyType::GetAttribute, "Get the child type by 'name'", py::arg("name")); type_module.def("__getitem__", &DuckDBPyType::GetAttribute, "Get the child type by 'name'", py::arg("name"), @@ -385,11 +385,11 @@ py::list DuckDBPyType::Children() const { py::list children; auto id = type.id(); if (id == LogicalTypeId::LIST) { - children.append(py::make_tuple("child", make_shared_ptr(ListType::GetChildType(type)))); + children.append(py::make_tuple("child", std::make_shared(ListType::GetChildType(type)))); return children; } if (id == LogicalTypeId::ARRAY) { - children.append(py::make_tuple("child", make_shared_ptr(ArrayType::GetChildType(type)))); + children.append(py::make_tuple("child", std::make_shared(ArrayType::GetChildType(type)))); children.append(py::make_tuple("size", ArrayType::GetSize(type))); return children; } @@ -408,13 +408,13 @@ py::list DuckDBPyType::Children() const { for (idx_t i = 0; i < struct_children.size(); i++) { auto &child = struct_children[i]; children.append( - py::make_tuple(child.first, make_shared_ptr(StructType::GetChildType(type, i)))); + py::make_tuple(child.first, std::make_shared(StructType::GetChildType(type, i)))); } return children; } if (id == LogicalTypeId::MAP) { - children.append(py::make_tuple("key", make_shared_ptr(MapType::KeyType(type)))); - children.append(py::make_tuple("value", make_shared_ptr(MapType::ValueType(type)))); + children.append(py::make_tuple("key", std::make_shared(MapType::KeyType(type)))); + children.append(py::make_tuple("value", std::make_shared(MapType::ValueType(type)))); return children; } if (id == LogicalTypeId::DECIMAL) { diff --git a/src/duckdb_py/typing/typing.cpp b/src/duckdb_py/typing/typing.cpp index c86f3712..492dea23 100644 --- a/src/duckdb_py/typing/typing.cpp +++ b/src/duckdb_py/typing/typing.cpp @@ -4,40 +4,40 @@ namespace duckdb { static void DefineBaseTypes(py::handle &m) { - m.attr("SQLNULL") = make_shared_ptr(LogicalType::SQLNULL); - m.attr("BOOLEAN") = make_shared_ptr(LogicalType::BOOLEAN); - m.attr("TINYINT") = make_shared_ptr(LogicalType::TINYINT); - m.attr("UTINYINT") = make_shared_ptr(LogicalType::UTINYINT); - m.attr("SMALLINT") = make_shared_ptr(LogicalType::SMALLINT); - m.attr("USMALLINT") = make_shared_ptr(LogicalType::USMALLINT); - m.attr("INTEGER") = make_shared_ptr(LogicalType::INTEGER); - m.attr("UINTEGER") = make_shared_ptr(LogicalType::UINTEGER); - m.attr("BIGINT") = make_shared_ptr(LogicalType::BIGINT); - m.attr("UBIGINT") = make_shared_ptr(LogicalType::UBIGINT); - m.attr("HUGEINT") = make_shared_ptr(LogicalType::HUGEINT); - m.attr("UHUGEINT") = make_shared_ptr(LogicalType::UHUGEINT); - m.attr("UUID") = make_shared_ptr(LogicalType::UUID); - m.attr("FLOAT") = make_shared_ptr(LogicalType::FLOAT); - m.attr("DOUBLE") = make_shared_ptr(LogicalType::DOUBLE); - m.attr("DATE") = make_shared_ptr(LogicalType::DATE); - - m.attr("TIMESTAMP") = make_shared_ptr(LogicalType::TIMESTAMP); - m.attr("TIMESTAMP_MS") = make_shared_ptr(LogicalType::TIMESTAMP_MS); - m.attr("TIMESTAMP_NS") = make_shared_ptr(LogicalType::TIMESTAMP_NS); - m.attr("TIMESTAMP_S") = make_shared_ptr(LogicalType::TIMESTAMP_S); - - m.attr("TIME") = make_shared_ptr(LogicalType::TIME); - m.attr("TIME_NS") = make_shared_ptr(LogicalType::TIME_NS); - - m.attr("TIME_TZ") = make_shared_ptr(LogicalType::TIME_TZ); - m.attr("TIMESTAMP_TZ") = make_shared_ptr(LogicalType::TIMESTAMP_TZ); - - m.attr("VARCHAR") = make_shared_ptr(LogicalType::VARCHAR); - - m.attr("BLOB") = make_shared_ptr(LogicalType::BLOB); - m.attr("BIT") = make_shared_ptr(LogicalType::BIT); - m.attr("INTERVAL") = make_shared_ptr(LogicalType::INTERVAL); - m.attr("VARIANT") = make_shared_ptr(LogicalType::VARIANT()); + m.attr("SQLNULL") = std::make_shared(LogicalType::SQLNULL); + m.attr("BOOLEAN") = std::make_shared(LogicalType::BOOLEAN); + m.attr("TINYINT") = std::make_shared(LogicalType::TINYINT); + m.attr("UTINYINT") = std::make_shared(LogicalType::UTINYINT); + m.attr("SMALLINT") = std::make_shared(LogicalType::SMALLINT); + m.attr("USMALLINT") = std::make_shared(LogicalType::USMALLINT); + m.attr("INTEGER") = std::make_shared(LogicalType::INTEGER); + m.attr("UINTEGER") = std::make_shared(LogicalType::UINTEGER); + m.attr("BIGINT") = std::make_shared(LogicalType::BIGINT); + m.attr("UBIGINT") = std::make_shared(LogicalType::UBIGINT); + m.attr("HUGEINT") = std::make_shared(LogicalType::HUGEINT); + m.attr("UHUGEINT") = std::make_shared(LogicalType::UHUGEINT); + m.attr("UUID") = std::make_shared(LogicalType::UUID); + m.attr("FLOAT") = std::make_shared(LogicalType::FLOAT); + m.attr("DOUBLE") = std::make_shared(LogicalType::DOUBLE); + m.attr("DATE") = std::make_shared(LogicalType::DATE); + + m.attr("TIMESTAMP") = std::make_shared(LogicalType::TIMESTAMP); + m.attr("TIMESTAMP_MS") = std::make_shared(LogicalType::TIMESTAMP_MS); + m.attr("TIMESTAMP_NS") = std::make_shared(LogicalType::TIMESTAMP_NS); + m.attr("TIMESTAMP_S") = std::make_shared(LogicalType::TIMESTAMP_S); + + m.attr("TIME") = std::make_shared(LogicalType::TIME); + m.attr("TIME_NS") = std::make_shared(LogicalType::TIME_NS); + + m.attr("TIME_TZ") = std::make_shared(LogicalType::TIME_TZ); + m.attr("TIMESTAMP_TZ") = std::make_shared(LogicalType::TIMESTAMP_TZ); + + m.attr("VARCHAR") = std::make_shared(LogicalType::VARCHAR); + + m.attr("BLOB") = std::make_shared(LogicalType::BLOB); + m.attr("BIT") = std::make_shared(LogicalType::BIT); + m.attr("INTERVAL") = std::make_shared(LogicalType::INTERVAL); + m.attr("VARIANT") = std::make_shared(LogicalType::VARIANT()); } void DuckDBPyTyping::Initialize(py::module_ &parent) {