Cassandra Cluster Manager is a development tool for testing local Cassandra clusters. It creates, launches and removes Cassandra clusters on localhost.

Sqitch is a standalone change management system for database schemas, which uses SQL to describe changes.

This package provides a Python interface to the Redis key-value store.

This package adds the support of pgvector vectors to Tortoise-ORM as a new type of fields, it helps to filter/order by cosine similarity distances for scementic search using embeddings.

Apache Arrow is a columnar in-memory analytics layer designed to accelerate big data. It houses a set of canonical in-memory representations of flat and hierarchical data along with multiple language-bindings for structure manipulation. It also provides IPC and common algorithm implementations.

TDB is a Trivial Database. In concept, it is very much like GDBM, and BSD's DB except that it allows multiple simultaneous writers and uses locking internally to keep writers from trampling on each other. TDB is also extremely small.

asyncmy is a fast asyncio MySQL driver, which reuses most of pymysql and aiomysql but rewrites the core protocol with Cython for performance.

This package contains bindings for the ADBC Driver Manager, as well as a DBAPI 2.0/PEP 249-compatible interface on top. This can be used to load ADBC drivers at runtime and use them from Python. Backend-specific packages like adbc_driver_postgresql wrap this package in a more convenient interface, and should be preferred where they exist.

FreeTDS is an implementation of the Tabular DataStream protocol, used for connecting to MS SQL and Sybase servers over TCP/IP.

MySQLdb is an interface to the popular MySQL database server for Python. The design goals are:

1. Compliance with Python database API version 2.0 [PEP-0249],

2. Thread-safety,

3. Thread-friendliness (threads will not block each other).

This package provides a PostgreSQL driver for the Perl5 Database Interface (DBI).

Firebird is an SQL RDBMS with rich support for ANSI SQL (e.g., INSERT...RETURNING) including UDFs and PSQL stored procedures, cursors, and triggers. Transactions provide full ACID-compliant referential integrity.

The database requires very little manual maintenance once set up, making it ideal for small business or embedded use.

When installed as a traditional local or remote (network) database server, Firebird can grow to terabyte scale with proper tuning---although PostgreSQL may be a better choice for such very large environments.

Firebird can also be embedded into stand-alone applications that don't want or need a full client & server. Used in this manner, it offers richer SQL support than SQLite as well as the option to seamlessly migrate to a client/server database later.

This module provides connection pool implementations that can be used with the psycopg PostgreSQL driver.

This module tries to split any SQL code, even including non-standard extensions, into the atomic statements it is composed of.

WiredTiger is an extensible platform for data management. It supports row-oriented storage (where all columns of a row are stored together), column-oriented storage (where columns are stored in groups, allowing for more efficient access and storage of column subsets) and log-structured merge trees (LSM), for sustained throughput under random insert workloads.

Perform basic numeric, textual and statistical operations on plain text files. Designed to work within standard pipelines without additional code.

Vnlog (pronounced vanillog) is a toolkit for manipulating tabular ASCII data with labelled fields using regular command-line tools.

liburcu is a user-space Read-Copy-Update (RCU) data synchronisation library. It provides read-side access that scales linearly with the number of cores. liburcu-cds provides efficient data structures based on RCU and lock-free algorithms. These structures include hash tables, queues, stacks, and doubly-linked lists.

uthash implements a hash table and a few other basic data structures as C preprocessor macros. It aims to be minimalistic and efficient: it's around 1,000 lines of code which, being macros, inline automatically.

Unlike function calls with fixed prototypes, macros operate on untyped arguments. Thus, they are able to work with any type of structure and key. Any C structure can be stored in a hash table by adding UT_hash_handle to the structure and choosing one or more fields to act as the key.

Zix is a C library of portability wrappers and data structures. It provides the following components:

ZixAllocator A customizable allocator.

ZixBumpAllocator A simple realtime-safe bump-pointer allocator.

ZixBTree A page-allocated B-tree.

ZixHash An open-addressing hash table.

ZixRing A lock-free realtime-safe ring buffer.

ZixSem A portable semaphore wrapper.

ZixThread A portable thread wrapper.

ZixTree A binary search tree.

zixgest.h Digest functions suitable for hashing arbitrary data.

zix/filesystem.h Functions for working with filesystems.

zix/path.h Functions for working with filesystem paths lexically.

MARISA is a static and space-efficient trie data structure C++ library.

Coucal is an implementation of the Cuckoo hashing algorithm with a stash area using by default the MurmurHash hash function.

The Succinct Data Structure Library (SDSL) is a powerful and flexible C++11 library implementing succinct data structures. In total, the library contains the highlights of 40 research publications. Succinct data structures can represent an object (such as a bitvector or a tree) in space close to the information-theoretic lower bound of the object while supporting operations of the original object efficiently. The theoretical time complexity of an operation performed on the classical data structure and the equivalent succinct data structure are (most of the time) identical.

The Generic Data Structures Library (GDSL) is a collection of routines for generic data structures manipulation. It is a re-entrant library fully written from scratch in pure ANSI C. It is designed to offer for C programmers common data structures with powerful algorithms, and hidden implementation. Available structures are lists, queues, stacks, hash tables, binary trees, binary search trees, red-black trees, 2D arrays, permutations and heaps.