sqlite-plus VS go-sqlite3-stdlib

I definitely plan to! I have a much larger list of SQLite extensions I've built here: https://github.com/asg017/sqlite-ecosystem

Here's a few other references you may enjoy if you wanna learn more about SQLite extensions:

- The single source file for sqlite-vec: https://github.com/asg017/sqlite-vec/blob/main/sqlite-vec.c

- sqlean, a project from Anton Zhiyanov which is good base of great SQLite extensions: https://github.com/nalgeon/sqlean

- The official SQLite docs: https://www.sqlite.org/loadext.html

- The "hello world" SQLite extension example: https://www.sqlite.org/src/file/ext/misc/rot13.c

People should check out Nalgeon's work on SQLite extensions: https://github.com/nalgeon/sqlean.

Extra - Not sure what you are doing with the database but I came across this repo of extensions that seem pretty solid - https://github.com/nalgeon/sqlean

The simplicity of tree-navigation in "closure" is pretty amazing for how simple it is: https://github.com/nalgeon/sqlean/issues/27

Given that SQLite supports huge sizes for text, you could almost use the above as a way to create an outliner, with everything stored in the database itself ...

https://github.com/nalgeon/sqlean/blob/main/docs/define.md

I've been considering using that. Anyone have any experience with it?

Author here, happy to answer questions!

Simon already gave a great intro to my SQLite extensions, and I just want to point folks to Anton Zhiyanov's sqlean project, for pure-C extensions: https://github.com/nalgeon/sqlean

Also, some of these extensions are also packaged as Datasette plugins, so you can also run `datasette install datasette-sqlite-regex` or `datasette install datasette-sqlite-ulid` to add these extension to your Datasette instances! https://docs.datasette.io/en/stable/plugins.html

Adding user-defined functions to SQLite is not difficult, and the mechanism is quite flexible. You can create extensions and load them when you create the SQLite connection to have the functions available in queries. I wrote a blog post explaining how to do that using Rust, and the example is precisely a `regex_extract` function [0].

If you need them, you also have a "stdlib" implemented for Go [1] and a pretty extensive collection of extensions [2]

[0]: https://ricardoanderegg.com/posts/extending-sqlite-with-rust...

[1]: https://github.com/multiprocessio/go-sqlite3-stdlib

[2]: https://github.com/nalgeon/sqlean

OctoSQL is an awesome project and Kuba has a lot of great experience to share from building this project I'm excited to learn from.

And while building a custom database engine does allow you to do pretty quick queries, there are a few issues.

First, the SQL implemented is nonstandard. As I was looking for documentation and it pointed me to `SELECT * FROM docs.functions fs`. I tried to count the number of functions but octosql crashed (a Go panic) when I ran `SELECT count(1) FROM docs.functions fs` and `SELECT count() FROM docs.functions fs` which is what I lazily do in standard SQL databases. (`SELECT count(fs.name) FROM docs.function fs` worked.)

This kind of thing will keep happening because this project just doesn't have as much resources today as SQLite, Postgres, DuckDB, etc. It will support a limited subset of SQL.

Second, the standard library seems pretty small. When I counted the builtin functions there were only 29. Now this is an easy thing to rectify over time but just noting about the state today.

And third this project only has builtin support for querying CSV and JSON files. Again this could be easy to rectify over time but just mentioning the state today.

octosql is a great project but there are also different ways to do the same thing.

I build dsq [0] which runs all queries through SQLite so it avoids point 1. It has access to SQLite's standard builtin functions plus* a battery of extra statistic aggregation, string manipulation, url manipulation, date manipulation, hashing, and math functions custom built to help this kind of interactive querying developers commonly do [1].

And dsq supports not just CSV and JSON but parquet, excel, ODS, ORC, YAML, TSV, and Apache and nginx logs.

A downside to dsq is that it is slower for large files (say over 10GB) when you only want a few columns whereas octosql does better in some of those cases. I'm hoping to improve this over time by adding a SQL filtering frontend to dsq but in all cases dsq will ultimately use SQLite as the query engine.

You can find more info about similar projects in octosql's Benchmark section but I also have a comparison section in dsq [2] and an extension of the octosql benchmark with different set of tools [3] including duckdb.

Everyone should check out duckdb. :)

[0] https://github.com/multiprocessio/dsq

[1] https://github.com/multiprocessio/go-sqlite3-stdlib

[2] https://github.com/multiprocessio/dsq#comparisons

[3] https://github.com/multiprocessio/dsq#benchmark

Hey Kuba!

> Especially on the community building aspect, it's really impressive that you've been able to spark so many communities on various platforms (Reddit, GitHub, Discord, etc.)!

Yeah it's been so cool to see so many people come together, hobbyists and professionals.

> On a more technical note, since dsq is based on the "load it into SQLite and query it from there" architecture, have you considered integrating with the plugin ecosystems of other existing projects based on that same architecture, like Datasette[0]? It seems like a way to add a lot of value to your tools without much work.

Interesting idea! I haven't looked into Datasette too much. And I haven't thought about plugins too much either. The most I've done is extend the SQLite standard library [0] and I hope to continue growing that. I'd be curious to hear what specifically people like from Datasette they'd like to see in dsq.

> On a more commercial note, overall I think tools like this are very hard to monetize, because right now they're just a fairly niche use case, between - as you mentioned - full blown data analytics platforms and observability query systems, as well as standard unix tools. Especially since if you need the analytics a lot, you'll probably have time to integrate it into your preferred analytics solution (like BigQuery). Do you have any thoughts on that?

My idea was always to focus on smaller and less mature organizations, probably ones that have been around for 10+ years. They aren't using BigQuery, they prefer to host everything themselves, and they don't yet realize there are tools like DataStation that they can easily run to make analytics easier.

I've worked at a bunch of companies like this so I know the market exists. Actually I have been surprised how many people outside of this market showed up in the DataStation community. I've seen Googlers, MS-ers, modern startups, data science teams show up interested in DataStation compared to what they're already using.

For me it's just been a matter of time (and funding) to build out the product to serve these communities commercially as a SaaS or enterprise product.

[0] https://github.com/multiprocessio/go-sqlite3-stdlib