Sequel

Sequel is a relational database toolkit for Ruby that provides object-relational mapping, a fluent SQL query builder, and schema migration capabilities. It maps database tables to Ruby classes with support for associations, validations, lifecycle hooks, and eager loading, offering a comprehensive ORM layer for building data-centric applications.

Sequel distinguishes itself through a plugin-based extension architecture that allows composable customization of models, databases, and datasets without relying on deep inheritance hierarchies. It includes a thread-safe connection pool with support for database sharding, read/write splitting across replicas, and nested transactions with savepoint rollback. The library also provides a schema migration DSL with reversible steps, automation tools for database content copying and an interactive shell, and fine-grained control over connection management for multi-server setups.

Beyond its core ORM and query capabilities, Sequel includes a data validation framework with built-in helpers and schema-driven validation generation, a lifecycle callback system covering create, update, destroy, and transaction events, and serialization support for CSV, JSON, XML, and other formats. It offers model instance caching, prepared statement execution, and testing utilities such as transaction-based test isolation and truncation-based cleanup. The library also provides logging, structured error details, and mass assignment protection for security.

Features

Database ORMs - Maps database tables to Ruby objects with associations, validations, and lifecycle hooks.

Object-Relational Mappers - Provides a comprehensive object-relational mapping system for Ruby with associations, validations, hooks, and eager loading.

Migration Executors - Sequel applies pending migrations via the command-line tool or a Rake task, with options for version targeting, logging, and transaction control.

Automated Migrations - Applies migration files from the command line to bring a database to a specified version.

Connection Establishment - Establishes database connections from connection strings or options with automatic adapter selection.

CRUD Operations - Modifies rows in a table with standard CRUD operations and SQL MERGE support.

Mass Assignment Protected Saves - Assigns multiple attributes from a hash with primary key protection and whitelist enforcement.

Attribute Casting - Automatically casts database column values to Ruby types on read and write operations.

Database Connection Managers - Connects to relational databases with connection pooling, read/write splitting, and sharding support.

Database Connectivity - Supports multiple database adapters with thread-safe connection pooling, prepared statements, and sharding.

Connection Pool Managers - Manages a thread-safe connection pool to share and recycle database connections.

Database Schema Migrations - Manages schema changes with versioned migration files that can be applied, rolled back, and inspected.

Table Schemas - Creates database tables by specifying columns, primary keys, indexes, and constraints in a block.

SQL Query Execution - Executes arbitrary SQL strings with parameter placeholders, bypassing the query builder.

Database Migrations - Provides a schema migration DSL with reversible steps to manage versioned database changes.

Database Transactions - Groups database operations into transaction blocks, committing on success and rolling back on exception.

Nested Transactions - Supports nested transactions with savepoints for partial rollback within outer transactions.

Fluent Query Builders - Ships a fluent query builder DSL that constructs SQL queries by chaining Ruby method calls.

General Database Record Retrievers - Fetches rows from database tables with iteration, single retrieval, existence checks, and transaction-based row locking.

Connection Pooling - Provides a thread-safe connection pool that reuses and recycles database connections across threads.

Column, Index, and Constraint Modifications - Alters table structure by adding columns, indexes, constraints, and foreign keys programmatically.

Reversible Migration DSLs - Provides a block-based DSL for defining reversible schema migrations with both forward and reverse operations.

Model-Class Querying - Provides query methods like where and join directly on model classes via delegation.

Model Lifecycle Hooks - Sequel attaches hooks and saving options such as timestamps, optimistic locking, and conflict handling to model instances.

Table Structure Alterations - Alters existing tables by adding, removing, or renaming columns, indexes, and constraints.

Association-Based Filters - Enables querying parent rows based on attributes of their associated records.

Association Record Management - Sequel adds, removes, and clears associated objects through automatically generated methods on the parent model.

ORM Attribute Handlers - Manages attribute storage, access, encryption, lazy loading, and change tracking on model instances.

Dataset Query Customizations - Enriches dataset objects with reusable query methods for column selection, pagination, and date arithmetic.

Eager Loading - Implements eager loading to load all related records in a single query per association, avoiding N+1 issues.

Query Sorting - Orders query results by one or more columns with append and prepend capabilities.

Query Filters - Reduces query results to rows matching specified conditions with a flexible, multi-format input syntax.

Related Object Retrievers - Provides methods on model instances to retrieve and compose queries on associated datasets.

Relationship Modeling - Declares and queries relationships between models, including eager loading and cascading operations.

Association Definitions - Sequel declares one-to-many, many-to-many relationships using foreign keys, join tables, composite keys, or computed keys.

Row Object Representations - Represents each database row as an object supporting direct update and delete operations.

SQL Query Builders - Ships a fluent Ruby DSL for constructing and executing SQL queries with filtering, joining, ordering, and aggregation.

Statement Executions - Executes INSERT, UPDATE, or DELETE statements built from the dataset to modify rows.

Subquery Support - Provides subquery-based filtering via SQL IN clauses for advanced record selection.

Table Joining Operations - Supports inner, left, and other join types to combine data from multiple tables.

Programmatic Table and Index Managements - Creates, drops, and inspects tables, indexes, foreign keys, and columns programmatically.

Schema Migrations - Applies incremental schema modifications from a directory, tracking applied files for synchronization.

Ruby DSL Query Compositions - Provides a Ruby DSL for composing SQL queries with filtering, joining, and aggregation.

Parameterized Query Bindings - Uses named placeholder parameterization to prevent SQL injection and enable query reuse.

Class-Based Data Modeling - Maps database tables to Ruby classes with associations, validations, and lifecycle hooks.

Lifecycle Callbacks - Sequel defines before and after hooks for create, save, update, destroy, and validation events that can be overridden to insert custom logic.

Plugin-Based Architectures - Uses a plugin-based extension architecture for composable customization of models, databases, and datasets.

Thread-Safe Database Access - Ensures thread-safe concurrent database queries without data corruption.

Limit Offset Pagination - Implements limit and offset pagination for controlling result set size and position.

Common Validation Helpers - Provides common validation methods such as presence, format, length, uniqueness, type, and numeric checks.

Extensions and Plugins - Ships a plugin-based architecture for composing custom extensions to models, databases, and datasets.

Multi-Value Column Filters - Filters query results by comparing columns to literal values, arrays, ranges, sets, or nil using a hash syntax.

Model Instance Caches - Caches model instance lookup results to reduce repeated database queries for frequently accessed data.

Database Extensions - Provides mechanisms to load database extensions globally or per-instance for added functionality.

Database Connection Configurations - Supports advanced connection configuration including PostgreSQL types, validation, async, and schema caching.

Schema Introspection - Provides schema introspection to query database system catalogs for table, column, and index metadata.

Table Inheritance Strategies - Implements single-table and class-table inheritance patterns for mapping Ruby class hierarchies.

Transaction Callback Registrations - Sequel registers callbacks that run after a transaction commits or rolls back, enabling side effects on completion.

Database Views - Creates, replaces, or drops virtual tables defined by SELECT statements.

SQL Syntax Tree Construction - Constructs arbitrary SQL conditions using a block syntax and overloaded operators for flexible filtering.

Conditional Validation Rules - Sequel applies validation rules only when a given condition is met, using standard Ruby conditionals inside the validate method.

Index Metadata Readers - Retrieves index metadata from PostgreSQL, including partial and invalid indexes.

Model Serializers - Converts model instances to and from CSV, JSON, XML, and other formats.

Type Mappings - Converts PostgreSQL-specific column types such as arrays, hstore, and JSON into native Ruby objects.

Prepared Statements - Executes database operations through prepared statements for improved performance and SQL injection protection.

Query Aggregates - Groups rows by columns and computes aggregate values such as counts, sums, and averages.

Pattern Matching Filters - Searches columns using LIKE, ILIKE, regex, and concatenated field pattern matching.

Custom Eager Loading Strategies - Sequel defines custom logic for how associations are eagerly loaded for a group of objects.

Parameterized SQL Snippets - Embeds literal SQL fragments with parameterized placeholders for safe raw filtering within queries.

Association Inspections - Sequel lists all defined associations and their configuration details for the model class.

Pagination Controls - Sequel restricts the number of associated records returned for an association with limit and offset.

Arbitrary SQL Executions in Migrations - Allows embedding arbitrary SQL statements within migration blocks for database-specific operations.

Join - Automatically builds many-to-many join tables with foreign keys and composite primary keys.

Table Renaming - Removes or renames tables with optional existence checks before operations.

Tree Hierarchy Mappings - Supports parent-child tree relationships in models with recursive eager loading.

Table Creation - Populates new tables from SELECT query results without explicit column type definitions.

Column Projection - Restricts returned columns to a subset with options to append, prepend, or reset to all columns.

Column Change Trackers - Tracks which columns have changed on a model instance since the last load or save.

Schema Dumps - Outputs the current database schema as a migration file or schema cache for versioning.

Mass Assignment Prevention - Prevents unintended column changes by specifying allowed fields globally or per mass assignment call.

Custom Validation Rules - Sequel lets models add arbitrary validation logic by directly adding errors inside the validate method.

Schema-Driven Validations - Sequel automatically creates presence, type, length, and uniqueness validations based on table constraints and indexes.

Programmatic Plugin Loading - Loads plugins that override model methods and call super for composable customization.

Model-Level Schema Reflections - Retrieves associations, validations, and column info defined on ORM model classes for runtime reflection.

Non-Transactional Migrations - Enables or disables atomic transaction wrapping per migration step or globally.

Table Column Metadata Readers - Returns column names, types, primary keys, and default values from live database tables.

Database Mapping - Flexible and powerful SQL database access toolkit.

jeremyevanssequel

Features

Star history