- Boost - lists.boost.org

[sqlite] Review ends tomorrow
by Mohammad Nejati 02 Sep '25

02 Sep '25

Just a reminder: the review of Boost.SQLite will end tomorrow, Wednesday, September 3rd. If you are working on a review that you will not be able to finish by tomorrow, please let me know so we can extend the deadline to cover the weekend. Best regards, Mohammad Nejati Review Manager for the proposed Boost.SQLite

3 3

Just testing out mailman.. ignore. :-)
by René Ferdinand Rivera Morell 02 Sep '25

02 Sep '25

Some HTML things.. - A bullet list. - Second item. A number list.. 1. Uno 2. Dos Some *different* *formatting* for *words* and such. -- -- René Ferdinand Rivera Morell -- Don't Assume Anything -- No Supongas Nada -- Robot Dreams - http://robot-dreams.net

6 17

Ten Things I Hate About the Mailing List
by Vinnie Falco 02 Sep '25

02 Sep '25

1. New posters getting moderated and delayed 2. No rich text messages 3. other stuff I can't think of right now, let me get back to you on that. -- Regards, Vinnie Follow me on GitHub: https://github.com/vinniefalco

13 22

Re: [sqlite] Formal review of Boost.SQLite begins
by Darryl Green 01 Sep '25

01 Sep '25

On Tue, 2 Sept 2025 at 02:29, Klemens Morgenstern <klemensdavidmorgenstern(a)gmail.com> wrote: > On Mon, Sep 1, 2025 at 10:38 AM Darryl Green <darryl.green(a)gmail.com> wrote: >> >> On Tue, 2 Sept 2025 at 00:21, Klemens Morgenstern via Boost >> <boost(a)lists.boost.org> wrote: >> > >> > > >> > > Why can't such reference counting be implemented in types >> > > provided by the library, not sqlite3 itself? >> > >> > It's overhead that many users would find undesirable. >> >> So if sqllite3 had the overhead - you would pay the penalty / accept >> it - but you don't think users would pay it if your library added it? > > > I think the sqlite authors made the decision that their users don't accept such overhead. > >> How many users does this library have to make that statement? How bad >> is the performance impact? > > I don't think that's relevant. Introducing overhead to avoid misuse is bad. You say that is like this is some universal axiom. And it presumes misuse is identifiable by the user of the library. And the way to avoid it/use it correctly is clear to them.. Lets say that it is irrelevant (to you as the library author, and hence this is out of scope/not a goal of the library). Making qsqlite easier to use is a stated goal of the library. Some level/form of resource management is a goal of the library (implied by RAII, which is called out as a feature). It is left up to the user of the library to guess when and where safety was sacrificed on the altar of efficiency (which equally, is not absolutely wrong) and where ownership semantics are not clear and misuse is likely. There is a substantial element of surprise here. These behaviours/risks, and the definition of "correct use" needs to be in some pretty large, friendly letters to prevent footguns (aka misuse). > You need to complete one statement (i.e. have the resultset destruct) before using the second, > otherwise the bound parameters might interfere with each other. This is a good point. This is a much better argument against reference counting. As you point out, reference counting doesn't properly describe the relationship between statements and resultsets. >> Perhaps it is practical to do the wrapping as a user of the library >> (ie implement "safesqlite" on top of this library) but at about that >> point I think for ergonomics and efficiency some potential library >> users would just "fork" it i.e. borrow / take inspiration from your >> code. So this mythical "safesqlite" could/should view the presence of a resultset (possibly one containing only an error result) as a distinct state (arising from execution of the prepared statement) as a property of the statement. Viewing the statement as a generator of (expiring on advancing) resultset (refs) looks like it could work/convey/enforce correct usage/no UB without substantial overhead. But I haven't tried this. Maybe I'm missing something.

1 0

Re: [sqlite] Formal review of Boost.SQLite begins
by Maximilian Riemensberger 01 Sep '25

01 Sep '25

On 9/1/25 16:16, Klemens Morgenstern wrote: > > > On Sun, Aug 31, 2025 at 3:24 PM Maximilian Riemensberger <riemaxi(a)gmx.net <mailto:riemaxi@gmx.net>> wrote: > > > >> > >> * The connection type can be owning or non-owning. Why wouldn't one > >> instead have distinct connection (owning) and connection_ref (non-owning) > >> types? > >> > > Because otherwise the complexity goes up unnecessarily. A user can write a > > function just taking `connection&` and not worry about this. > > In the library I have the `transaction` type for example. It holds a > > reference to the connection - if there was a second type like > > `connection_ref`, now I would have a second type of a transaction. > > > > I see this point. However, a user that writes a function that takes `connection&` as an argument likely does not care about whether the connection is owning since the general expection would be that the connection is connected and live before the function is called and remains so until the function returns. All those functions can just take `connection_ref` by value (just like functions take a string_view or span or function_ref) and no duplication is necessary, assuming connection_ref is implicitly constructible from `connection`. > > For example, the transaction: > > class transaction { > connection_ref conn_; > > public: > explicit transaction(connection_ref conn); > > // Many more things > } > > And I would then expect both of the following to compile just fine: > > // 1 > connection c{":memory:"}; > transaction t{c}; > > // 2 > connection c{":memory:"}; > connection_ref cr{c}; > transaction t{cr}; > > and mean the same thing. > > Fair, but I might have the same piece of code that needs to guarantee that the `connection` is alive while it holds the handle. If this is part of a vtable impl (where it's non owning) that'll be the case automatically, > whereas it would take ownership otherwise. Using a connection_ref introduces an additional level of complexity, when the non-owning connection is just used in functions & vtables. I'm not sure I understand. Isn't this the same problem with the current design? If you have a `connection&`, it does not guarantee anything about the validity of the `sqlite*` since it might not be owning and whoever owns it closed it already. So I would think there are few to no functions that care about the ownership. I haven't really looked into the vtable stuff before, but since you mention it in this context, I noticed the following piece of code: ``` template<typename Table> struct module { using table_type = Table; /// @brief Creates the instance /// The instance_type gets used & managed by value, OR a pointer to a class that inherits sqlite3_vtab. /// instance_type must have a member `declaration` that returns a `const char *` for the declaration. BOOST_SQLITE_VIRTUAL result<table_type> create(sqlite::connection db, int argc, const char * const argv[]) BOOST_SQLITE_PURE; /// @brief Create a table /// The table_type gets used & managed by value, OR a pointer to a class that inherits sqlite3_vtab. /// table_type must have a member `declaration` that returns a `const char *` for the declaration. BOOST_SQLITE_VIRTUAL result<table_type> connect(sqlite::connection db, int argc, const char * const argv[]) BOOST_SQLITE_PURE; }; ``` As far as I understand, I as a user would derive from this struct and implement these two functions. Both receive a `sqlite::connection` by value. Is it owning? Does it need to be owning? What happens if I move and store the connection somewhere private? Am I actually allowed to do that, or will it break some lifetime assumptions by the library or sqlite3? Or if it is indeed owning, do I need to store it and keep it alive to avoid the database being closed and pulled away under my feet? Neither docs, tests, or examples use this parameter as far I can see. Digging throught the detail/vtable.hpp header shows it is non-owning in both cases. And now I think I understand your comment, from the implementation point of view since the vtable/module lifetime is managed by sqlite itself and thus tied to the connection on which it was registered (by the user or sqlite?) it behaves kind of like an owner even if it isn't. I still find it both confusing to the user (mostly myself) when starting to learn and understand the library. And I think there is a better way to do that, that clearly communicates ownership. Basically, similar to executor and execution_context in asio. Because if I look again at the above module class, I think it should just receive a non-owing type (like executor, connection_ref, ...) because ownership is clearly managed externally from the modules perspective and this should also be documented. By the way, this is unfortunately an issue I have run into during this review: The primary two pieces of documentation I look at are the boost_sqlite source code and the sqlite3 documentation. The boost_sqlite documentation is not that helpful beyond the simple examples. But regarding the connection type, I still think it would be much better to have a strictly owning type (like execution_context) and a strictly non-owning type (like executor) and almost exclusively use the non-owing type except for where ownership is necessary. And I'm pretty sure ownership is really only necessary on the application level when opening the database. Sorry to be a bit obnoxious about this, but when I look at the public headers and the docs only with a fairly regular C++ type design expectation, it's just confusing me. Best regards, Max

1 0

[boost][sqlite] some feedback on the docs
by Andrzej Krzemienski 30 Aug '25

30 Aug '25

Hi Everyone, First, I wanted to thank Klements for writing and sharing Boost.SQLite and for submitting it for the review. This is by no means a review. But I have started reading the docs and I have some initial feedback that I wanted to share. I am not familiar with sqlite3 interface, so I am reading the docs from the perspective of someone new. [1] Reference section in the documentation is insufficient. With a C++ mindset, I tried to figure out how the session management works, and the documentation of sqlite/connection.hpp does not help me. I cannot find if the resources are allocated in the constructor. Any constructor? Why do you have two? Why do you have a separate function connect()? What is the purpose of having a constructor if I still need to call connect()? According to the docs, connection class has no destructor,from which I gather that I have to manage the session lifetime manually and close it with function close(). If any other function throws an exception, I will not be able to close the connection. Is that intended? There are actually two functions: release() and close(). The docs do not tell me how they differ and which one I should use and when: how is releasing the handle in class connection different from closing the connection? I also cannot see what exception type is thrown from connection functions and under what conditions. The constructor taking handle_type: where would I use it? Or maybe it is only intended to be called by macros? function valid(): not clear what is an d is not valid in this context: does this indicate the default-constructed state, or is it a term specific to sqlite? [2] Dragging the entire <sqlite3.h> The names like SQLITE_OPEN_READWRITE seem to come from <sqlite3>. So this library indirectly drags the entire <sqlite3.h>, and all the declarations into the global namespace. Is this necessary? One could imagine an alternative when this is only included in the library cpp files. No? In any case, this should be documented. [3] It is interesting that "virtual table" has one meaning in the sqlite world and another in the C++ world: a virtual pointer table. Maybe the docs should highlight that. [4] Exposing sqlite for non-eponymous tables https://klemens.dev/sqlite/#non_eponymous_tables I am reviewing this in a hurry, so maybe I am missing something obvious, but it looks to be like this lib could offer an interface that does not use sqlite types, but their Boost.Sqlite wrappers instead: It could be just a pair of two functions -- you do not have to derive from anything. The example has: struct csv_module final : sqlite::vtab::module<csv_table>{ // create the csv file sqlite::result<table_type> What are csv_table and table_type? Regards, &rzej;

1 0

Problem: Mailing List Moderation
by Vinnie Falco 29 Aug '25

29 Aug '25

As far as I know there are two designated moderators for the list: Glen Fernandes, and John Maddock. Possibly there is a third, Marshall Clow, although this isn't clear from the website. Regardless, we have a problem where new people are coming to the list and getting moderated. I have brought in several first-time mailing list posters (and first-time review participants, via Boost.SQLite). They have all reported problems where their messages are stuck in the moderation queue. If we are to bring vital new participation on the mailing list, we need to improve their experience. I'm not sure what the best solution is. Thanks

9 16

Re: [sqlite] Formal review of Boost.SQLite begins
by amlalelmahrouss＠icloud.com 27 Aug '25

27 Aug '25

> May I ask why? I am not hiding the implementation (i.e. sqlite3) on > purpose, so that users can just use the sqlite3 API or another library if > they need. Hiding types such as `sqlite3` with a `void*` in that case would be beneficial, as you would make the user's life easier because they would treat the `handle_type` as a handle, not a specific type accessible by the user. So as the implementer you would be able to extend the library without breaking changes. > Not being able to do that has caused me much frustration in other libraries > before. May I ask about what specific libraries you have in mind? > Which usage do you have in mind? As a query builder? Indeed, The query_builder object takes a `connection` object in the constructor. And that can be swapped with another `connection` when needed. ```cpp class query_builder { public: /// operator<< query_builder& operator<<(const cstring_ref& sql_query); /// operator>> query_builder& operator>>(resultset& res_out); }; /// example void cache_manager::read_local_cache() { resultset res{}; cstring_ref in = "SELECT * FROM cache WHERE key = \"?\""; this->builder_ << in; this->builder_ >> res; } ``` > Thank you for your review! It is my pleasure! Amlal

1 0

Re: [sqlite] Formal review of Boost.SQLite begins
by amlalelmahrouss＠icloud.com 27 Aug '25

27 Aug '25

# Introduction Below is my review of the boost_sqlite library. First off, I believe that this approach of providing a safer and much more expressive C++ interface on top of the SQLite C library, is a step toward the simplification and hardening of database development. ## Author's Background I'm a professional C++ Developer. I've been using the Boost library in both hobby projects and professional ones. I have experience in interacting with similar connectors such as: ADO, ODBC, MySQL, JDBC. ## Initial Thoughts and Use Case The library wraps the standard C API of SQLite into wrapped containers. Such as the connection, field, resultset containers. String helpers and the connection object seems to fulfill their duty correctly. Reflecting industry standard practice of such interfaces. The library is a perfect solution for applications written in C++ with persistence needs without the need of a SQL server. Moreover the boost style codebase makes it even easier to integrate into such applications. ## Thoughts on Design The design is simple, easy to understand, and what I'd expect for such an interface. I believe it would meet my needs. ## Improvements Needed The `handle_type` alias shall be set to a void* in order to hide the implementation details of the library. ```cpp using handle_type = void*; ``` The `connection` constructor with the `int flags` parameter should be abstracted away in a `enum class` as in the following: ```cpp enum class open_flags : int { bad = 0, rw = SQLITE_OPEN_READWRITE, ... } ``` ## Notes on Documentation The readme explains the concepts and gives concrete usage examples of the interface. ```cpp conn.execute(R"( create table if not exists author ( id integer primary key autoincrement, first_name text, last_name text ); create table if not exists library( id integer primary key autoincrement, name text unique, author integer references author(id) ); )" ); ``` ## Comparison to other libraries I notice that other libraries are using the `operator<<` that would be beneficial to Boost.SQLite as well, as it would mean seamless integration into many codebases. As well as future extension capabilities, if there is a need to extend the library in the future. ## Personal Usage Although I did not use Boost.SQLite directly in any production projects, I did study its design, and run its examples with the previous experience I have with other similar libraries in mind. ## Final Thoughts The need of a modern interface for such databases is becoming stronger by the day, the C API of SQLite makes the functionality of persistence and error handling very hard in modern C++ codebases. I would like to see the library with optional dependencies as well I am favorable in the merging of this library in Boost, however improvements in additional operators might be needed for completeness. (such as operator<<, operator>>) Amlal El Mahrouss.

3 2

Forking Asio
by Vinnie Falco 26 Aug '25

26 Aug '25

I would like to measure the interest in a fork of Asio, proposed as a Boost library for review. Currently, Boost.Asio (and the standalone version Asio) is developed and maintained by Christopher Kohlhoff. Unfortunately he has a well-earned reputation for being unresponsive to emails and GitHub issues. For example: https://github.com/chriskohlhoff/asio/pull/904 I believe that Asio is Boost's most valuable asset, because "the C++ Standard cannot connect to the Internet." Every other language has portable networking built-in except for C++. Asio is the industry standard and the gold standard for portable networking, yet it is falling behind due to its lack of evolution. A major component of my revitalization plan for Boost is to promote Asio and build many great things on top of it. For example, clients and servers which speak MCP ("Model Context Protocol"), empowering users to easily connect and talk to AI endpoints (Large Language Models) using REST and JSON. Learn more about MCP here: https://www.pulsemcp.com/ In discussions with our staff engineers, there is a movement to propose a Boost.Crypt library with cryptographic primitives as an alternative to OpenSSL, with the goal of modern interfaces which eliminate broad categories of undefined behavior and usage errors which lead to vulnerabilities. Yet if Asio cannot adopt support for alternatives to OpenSSL we cannot evolve. The fork of Asio is just in the idea stage, no work has been done yet, and it is all open to debate and design. My thinking of how the fork would work goes like this: 1. C++ Alliance allocates dedicated staff to maintain the fork 2. Stakeholders come together, on the mailing list and through GItHub issues, to determine what directions we might like to explore or move towards 3. Dedicated staff implement the work and provide support for stakeholders 4. Changes in Asio would be adopted on an as-needed basis The first order of business would be to go through all of the GitHub issues in Asio and address them one by one. What do you think?

23 100