rusqlite VS Cargo

As far as I know, the only option for an embedded SQL database is SQLite. The most actively maintained one, for rust, seems to be rusqlite (https://github.com/rusqlite/rusqlite).

Yes, but it's readonly. Also they did not merge loadable extensions support, which I need - https://github.com/rusqlite/rusqlite/pull/910

rusqlite 0.27.0, which looks like it's still the latest version

SQLite is written in C, while workers is based on V8 isolates, so it mainly runs JavaScript. Fortunately, it also supports running WASM through initialising and calling WASM modules via JavaScript. Emscripten can be used to build WASM from C, but I'd rather use it through Rust (using rusqlite), so this is what I focus on right away. Workers can also be written entirely in Rust using worker-rs.

For the persistence layer I used Rusqlite and r2d2-sqlite for creating a connection pool.

There are feature flags in chrono that make possible to disable usage of time: https://github.com/rusqlite/rusqlite/pull/1031

I want to use arrays in sqlite but the documentations for rusqlite doesn't have examples of how to use the extra array feature. How do I store and search text arrays in rusqlite?

Since this is a learning project, its probably not a good idea to count on this being production ready. If you need SQLite in your project checkout rusqlite. And for cross compiling issues simply use its bundled feature, makes it a breeze.

> It defaulted to the fully backwards compatible version (vs 2021)

Cargo defaults to the 2021 edition, and has ever since it was stabilized: https://github.com/rust-lang/cargo/pull/9800

Either you accidentally installed a version of cargo from before the 2021 edition was stabilized, or you ran "cargo new --edition ", or you started by cloning an out of date project of some sort, in which case it's not really an issue with "defaults".

Cargo, which is the out-of-the-box tool for running tests, installing packages/dependencies, and more, has conventions for building libraries versus binaries.

Between workspace inheritance and tools like cargo-release, this has become trivial for me. If people don't want to use a third-party tool, we can always be working on improving cargo further, like publishing more than one crate at a time or merging support for modifying versions.

It looks like this might be the commit that fixes the vulnerability: https://github.com/rust-lang/cargo/commit/c9bff1ec6d147e0254ecfcafe6325ef1643edb6d

On other OSs than Linux, the situation is different, e.g. there was a crates.io outage for windows because OCSP servers weren't responding.

Well, on the way, I met the error below when testing a cargo project:

Rust has a lot of features such as functional programming paradigm and zero cost abstractions (!). As to speed and safety, it doesn't have GC, garbage collection, so it runs with much smaller memory and cleanly. As to productivity, it has the nice package manager called cargo and also a tool chain called rustup.

Macro expansion is slow, but only noticeably in the specific situation of a) third-party proc macros, b) a debug build, and c) a few thousand invocations of said proc macros. This is because debug builds compile proc macros in debug mode too, so while the macro itself compiles quickly (because it's a debug build), it ends up running slowly (because it's a debug build).

I know this from observing this on a mostly auto-generated crate that had a couple of thousand types with `#[derive(serde::)]` on each. [1]

This doesn't affect most users, because first-party macros like `#[derive(Debug)]` etc are not slow because they're part of rustc and are thus optimized regardless of the profile, and even with third-party macros it is unlikely that they have thousands of invocations. Even if it is* a problem, users can opt in to compiling just the proc macros in release mode. [2]

[1]: https://github.com/Arnavion/k8s-openapi/issues/4

[2]: https://github.com/rust-lang/cargo/issues/5622