Selecto is a query builder for Elixir that uses Postgrex to execute queries. It is designed to be a flexible and powerful tool for building complex SQL queries without writing SQL by hand.

Array operations support for PostgreSQL array functionality.

Specification for array operations in SELECT, WHERE, and other clauses.

Error raised when array operation specification is invalid.

Common Table Expression (CTE) support for PostgreSQL WITH clauses.

Specification for Common Table Expression definitions.

Error raised when CTE specification is invalid.

CASE expression support for PostgreSQL conditional logic.

Specification for CASE expression definitions.

Error raised when CASE expression specification is invalid.

JSON operations support for PostgreSQL JSON and JSONB functionality.

Specification for JSON operations in SELECT, WHERE, and other clauses.

Error raised when JSON operation specification is invalid.

LATERAL join support for correlated subqueries and advanced join patterns.

Error raised when LATERAL join correlations are invalid.

Specification for a LATERAL join operation.

VALUES clause support for inline table generation and data transformations.

Specification for a VALUES clause operation.

Error raised when VALUES clause data is invalid.

Automatic pivot detection and application for Selecto queries.

SQL builder for PostgreSQL array operations.

SQL generation for PostgreSQL CASE expressions.

SQL generation for PostgreSQL Common Table Expressions (CTEs).

Join dependency utilities used by the SQL builder pipeline.

SQL generation for PostgreSQL JSON operations.

SQL generation for LATERAL joins.

SQL generation logic for Pivot functionality.

SQL generation for set operations (UNION, INTERSECT, EXCEPT).

Main SQL compilation entry point for a configured Selecto query.

GROUP BY clause builder for Selecto queries.

Helper functions shared by SQL builder modules.

Hierarchical SQL pattern generation for self-referencing relationships.

OLAP dimension optimization SQL patterns for star and snowflake schemas.

ORDER BY clause builder for Selecto queries.

SELECT-expression compiler for Selecto query AST values.

Many-to-many tagging SQL pattern generation for join table relationships.

WHERE-clause compiler for Selecto predicate expressions.

SQL generation logic for Subselect functionality.

SQL generation for VALUES clauses in PostgreSQL queries.

Builds SQL for window functions.

Merges overlay configurations into base domain configurations.

A DSL (Domain-Specific Language) for defining overlay configurations.

Domain configuration and initialization for Selecto.

Connection pooling and management for Selecto.

Behaviour contract for Selecto database adapters.

Microsoft SQL Server adapter for Selecto.

MariaDB adapter for Selecto.

MySQL adapter for Selecto.

PostgreSQL adapter for Selecto.

SQLite adapter for Selecto.

Query diagnostics helpers (EXPLAIN / EXPLAIN ANALYZE).

Domain validation for Selecto configurations.

Exception raised when domain validation fails.

Handles dynamic join additions at runtime.

Ecto integration for Selecto query builder.

Enhanced join types and patterns for Selecto.

Standardized error structure for all Selecto operations.

Query execution engine for Selecto.

Behavior contract for Selecto ecosystem extensions.

Shared extension loading and callback dispatch for the Selecto ecosystem.

Enhanced field resolution system for Selecto with disambiguation, aliasing, and dynamic resolution.

Parser for parameterized joins with dot notation support.

Field access and resolution operations for Selecto.

Shared utility helpers used across Selecto internals.

Date helper functions for Selecto.

JSONB column support with dot notation for filtering and selection.

Convenience helpers for interactive notebooks and demos.

Sanitizes SQL queries and parameters for safe logging.

Format registry and configuration system for Selecto output formats.

CSV transformer for Selecto query results.

JSON transformer for Selecto query results.

Transforms query results to list of maps format.

Transforms query results to streaming format for memory-efficient processing of large datasets.

Transforms query results into structured data using Elixir structs.

Database type coercion system for transforming raw database values to appropriate Elixir types based on PostgreSQL column types.

Analyzes query complexity to prevent database overload.

Behaviour for implementing custom performance monitoring hooks.

Performance monitoring hooks for Selecto query execution.

Collects and tracks query performance metrics for Selecto.

Query analysis and optimization using PostgreSQL's EXPLAIN ANALYZE.

High-performance query result caching for Selecto.

Pivot functionality for retargeting joined tables as primary query focus.

Core query building operations for Selecto.

Lightweight SQL formatting and highlighting helpers.

Advanced SQL function support for Selecto.

Namespace module for schema processing helpers.

Builds normalized column definitions for domain fields and join fields.

Join Configuration and Patterns

This module handles join configuration for various database join patterns, providing simplified configuration helpers for common scenarios.

Processing and configuration for parameterized joins.

Structured selection helpers for building and materializing nested result shapes.

Set operations for combining query results using UNION, INTERSECT, and EXCEPT.

Specification for a set operation between two or more queries.

Schema validation for set operations between queries.

Core subfilter data structures and specifications.

Specification for compound subfilter operations (AND/OR).

Subfilter-specific error structure.

Filter specification for subfilter conditions.

Resolve relationship paths into join sequences using domain join-path configuration.

Structure representing a resolved join path with all necessary join information.

Parse subfilter configurations into structured subfilter specs.

Registry system for managing multiple subfilters with strategy selection and optimization.

Parsed relationship path information.

Generate SQL WHERE clauses for subfilters from the Subfilter Registry.

Builds subqueries with aggregations (COUNT, SUM, AVG, etc.).

Builds ANY and ALL subqueries for subfilters.

Builds EXISTS subqueries for subfilters.

Builds IN subqueries for subfilters.

Specification for a single subfilter operation.

Subselect functionality for array-based data aggregation from related tables.

Multi-tenant helpers for Selecto query state.

Type inference and coercion system for Selecto SQL expressions.

Comprehensive type definitions for the Selecto query builder.

Window functions provide powerful analytical capabilities for PostgreSQL queries.

Window frame specification (ROWS or RANGE).

Specification for a window function operation.