jeremyevans/sequel

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.

Star history