This repository holds a pure Go SQL parser based on the SQLite SQL definition. It implements nearly all features of the language except ATTACH, DETACH, and some other minor features.

A complete implementation of Tetris in a SQL query. Written for Postgres. Has a Python front-end that uses psycopg2.

DeltaDB is a lightweight, fast, and scalable database built on polars and deltalake. It is designed to streamline data operations, providing features like upsert, delete, commit, and version control while harnessing the high performance of polars and deltalake.

Also known as SQL for Data Scientists in 100 Queries.

Has its own pack of lesson materials (SQLite databases) here: https://github.com/gvwilson/sql-tutorial/raw/main/sql-tutorial.zip

A utility that lets you query CSV, JSON and Parquet files with regular SQL statements. If DuckDB is okay with it, it'll run. Has both a fire-and-forget CLI and an interactive TUI.

In the spirit of Feynman's immortal words, the goal of this project is to better understand the internals of databases by implementing a relational database management system (RDBMS) (sqlite clone) from scratch.

This project was motivated by a desire to: 1) understand databases more deeply and 2) work on a fun project. These dual goals led to a:

• relatively simple code base
• relatively complete RDBMS implementation
• written in pure python
  • No build step
• zero configuration
  • configuration can be overridden

This makes the learndb codebase great for tinkering with. But the product has some key limitations that means it shouldn't be used as an actual storage solution.

RestfulDB is a Web frontend for SQL databases. It provides both a Web GUI and a RESTful API for interaction with any MySQL/MariaDB or SQLite database. RestfulDB is developed with off-the-shelf usage in mind, but nevertheless it provides the means to override the default interpretations of underlying database's schema and data.

Define a JSON document in Python, transparently convert it into a relational database. Supports MySQL/MariaDB, Postgres, SQLserver, and SQLite. Ideal for writing conversion tools.

Dolt is a SQL database that you can fork, clone, branch, merge, push and pull just like a git repository. Connect to Dolt just like any MySQL database to run queries or update the data using SQL commands. Use the command line interface to import CSV files, commit your changes, push them to a remote, or merge your teammate's changes.

All the commands you know for Git work exactly the same for Dolt. Git versions files, Dolt versions tables. It's like Git and MySQL had a baby.

Dolt ships with a MySQL compatible database server built in.

A CLI tool that lets you run SQL queries against CSV and TSV (tab-separated values) files. This includes data from shell pipes, like the output of ps or other tools.

minidb 2 makes it easy to store Python objects in a SQLite 3 database and work with the data in an easy way with concise syntax. Designed for embedded use (imported as a module) and not a stand-alone server. Supports SQL queries.

FormatExpress is an easy-to-use online formatter where you simply paste some bunch of raw XML, JSON, CSS or SQL, to get it automatically beautified. The most common use-case is to help reading minified input found in logs or web services.

psql and shell scripts for maintaining a Matrix Synapse chat server. Currently looking for maintainers.

Since Yahoo killed off their Where-On-Earth (WOEID) API service, it hasn't been possible to use it to get WOEID maprefs for certain APIs. Thankfully, some kind soul uploaded it to the Internet Archive.

The contents are five TSV (tab separated value) files, a Readme.txt file, and a license.txt file.

If you want to read them into a SQLite database (and you'll need to set a primary key on each table), do this:

user@host: sqlite3 geoplanet.sqlite
sqlite> .mode tabs
sqlite> PRAGMA foreign_keys=off;

sqlite> CREATE TABLE adjacencies (id INTEGER PRIMARY KEY, Place_WOE_ID TEXT, Place_ISO TEXT, Neighbour_WOE_ID TEXT, Neighbour_ISO TEXT);
sqlite> .import geoplanet_adjacencies_7.10.0.tsv temp_adjacencies
sqlite> INSERT INTO adjacencies(Place_WOE_ID, Place_ISO, Neighbour_WOE_ID, Neighbour_ISO) SELECT Place_WOE_ID, Place_ISO, Neighbour_WOE_ID, Neighbour_ISO from temp_adjacencies;
sqlite> drop table temp_adjacencies;

sqlite> CREATE TABLE admins (id INTEGER PRIMARY KEY, WOE_ID TEXT, iso TEXT, State TEXT, County TEXT, Local_Admin TEXT, Country TEXT, Continent TEXT);
sqlite> .import geoplanet_admins_7.10.0.tsv temp_admins
sqlite> INSERT INTO admins(WOE_ID, iso, State, County, Local_Admin, Country, Continent) SELECT WOE_ID, iso, State, County, Local_Admin, Country, Continent from temp_admins;
sqlite> drop table temp_admins;

sqlite> CREATE TABLE aliases (id INTEGER PRIMARY KEY, WOE_ID TEXT, Name TEXT, Name_Type TEXT, Language Text);
sqlite> .import geoplanet_aliases_7.10.0.tsv temp_aliases
sqlite> INSERT INTO aliases(WOE_ID, Name, Name_Type, Language) SELECT WOE_ID, Name, Name_Type, Language from temp_aliases;
sqlite> DROP TABLE temp_aliases;

sqlite> CREATE TABLE changes (id INTEGER PRIMARY KEY, Woe_id TEXT, Rep_id TEXT, Data_Version TEXT);
sqlite> .import geoplanet_changes_7.10.0.tsv temp_changes
sqlite> INSERT INTO changes (Woe_id, Rep_id, Data_Version) SELECT Woe_id, Rep_id, Data_Version from temp_changes;
sqlite> DROP TABLE temp_changes;

sqlite> CREATE TABLE places (id INTEGER PRIMARY KEY, WOE_ID TEXT, ISO TEXT, Name TEXT, Language TEXT, PlaceType TEXT, Parent_ID TEXT);
sqlite> .import geoplanet_places_7.10.0.tsv temp_places
sqlite> INSERT INTO places (WOE_ID, ISO, Name, Language, PlaceType, Parent_ID) SELECT WOE_ID, ISO, Name, Language, PlaceType, Parent_ID from temp_places;
sqlite> drop table temp_places;

sqlite> PRAGMA foreign_keys=on;
sqlite> .quit

I would also recommend cleaning up after yourself:
user@host: sqlite3 geoplanet.sqlite
sqlite> VACUUM;
sqlite> .quit

The Geoplanet database is licensed by Yahoo! Geoplanet as Creative Commons By Attribution v3.0:
http://creativecommons.org/licenses/by/3.0/us/

dataset provides a simple abstraction layer removes most direct SQL statements without the necessity for a full ORM model - essentially, databases can be treated like a JSON file, a hash table or a NoSQL datastore.

Schema is automatically generated and updated. If you want to, you can use SQLite's in-memory database functionality. Records are either created or updated automatically, depending on whether or not they exist already. Built on top of SQLalchemy so whatever it supports, dataset supports.

Github: https://github.com/pudo/dataset

A distributed database that speaks MySQL's dialect of SQL and wire protocol on the front end, and is a fully distributed database system on the back end. Automatically shards databases efficiently. Implements ACID compliant distributed transactions for consistency.

Command line utility which lets you run SQL queries against CSV and TSV files.

A utility capable of fingerprinting back-end SQL databases, pulling authentication credentials and schemas, enumerating databases, and generating SQL injection attacks against web applications. Can handle MySQL, Oracle, Postgres, SQL Server, DB2, and other systems.

A handy cheatsheet for crafting SQL injection attacks against web apps backed by Oracle.

A handy cheatsheet for crafting SQL injection attacks against web applications.