Moltres

Start here

  • Quick Start (5 minutes)
    • Install
    • Connect, query, and CRUD
    • Runnable scripts
    • What to read next
  • Complete Getting Started Tutorial
    • Installation
    • Your First Connection
    • Creating Your First Table
    • Inserting Data
    • Your First Query
    • Understanding Lazy Evaluation
    • Common Operations
      • Filtering
      • Sorting
      • Aggregations
      • Joins
    • Working with Results
    • Updating and Deleting Data
    • Debugging and UX Features
      • Viewing Generated SQL
      • Understanding Query Plans
      • Schema Discovery
      • Query Validation and Performance Hints
      • Interactive Help
    • Next Steps
    • Common Pitfalls
    • Getting Help
  • Public API
    • Top-level imports (moltres)
      • col vs column
      • Optional interface wrappers
    • DataFrame (moltres.dataframe)
      • Union semantics (PySpark difference)
    • Expressions (moltres.expressions)
    • Engine (moltres.engine)
    • Records and CRUD (moltres.io.records)
      • Database CRUD (sync and async)
    • Reading data: choose the right API
    • Optional extras
    • Integrations (moltres.integrations)
    • API decision guide
    • PySpark compatibility
    • What is not public API
  • Example Scripts
    • Core usage
    • Interfaces and UX
    • Integrations
    • Transactions (advanced)
  • Changelog
    • Unreleased
    • 1.1.1 - 2026-07-11
      • Added
      • Fixed
      • Changed
    • 1.1.0 - 2026-07-07
      • Added
      • Changed
      • Security
      • Fixed
    • 1.0.1 - 2026-06-07
      • Breaking
      • Changed
      • Security
      • Fixed
    • 1.0.0 - 2026-04-03
      • Breaking
      • Added
      • Changed
      • Fixed
    • [0.23.0] - 2025-12-04
      • Added
    • [0.22.0] - 2025-12-02
      • Added
    • [0.19.6] - 2025-12-02
      • Changed
      • Fixed
    • 0.19.5 - 2025-12-01
      • Changed
      • Fixed
    • 0.19.4 - 2025-12-01
      • Changed
      • Fixed
    • 0.19.3 - 2025-11-30
      • Changed
      • Fixed
    • 0.19.2 - 2025-11-29
      • Changed
    • 0.19.1 - 2025-11-29
      • Fixed
    • 0.19.0 - 2025-11-29
      • Changed
      • Fixed
    • 0.19.0 - 2025-11-27
      • Added
      • Changed
      • Fixed
    • 0.19.0 - 2025-11-27
      • Added
      • Fixed
    • 0.18.0 - 2025-11-26
      • Added
    • 0.17.0 - 2025-11-26
      • Added
      • Fixed
      • Changed
    • 0.16.0 - 2025-11-26
      • Fixed
      • Changed
    • 0.15.0 - 2025-11-25
      • Added
      • Fixed
    • 0.14.0 - 2025-11-24
      • Added
      • Changed
    • 0.13.0 - 2025-11-24
      • Added
      • Changed
      • Fixed
    • 0.11.0 - 2025-11-24
      • Fixed
    • 0.10.0 - 2025-11-23
      • Added
    • 0.9.0 - 2025-11-23
      • Added
      • Changed
      • Fixed
    • 0.12.0 - 2025-11-24
      • Added
      • Changed
      • Fixed
      • Added (continued)
      • Changed
      • Fixed
    • 0.8.0 - 2025-11-21
      • Added
      • Changed
      • Fixed
      • Internal
    • 0.7.0 - 2025-11-21
      • Added
      • Changed
      • Fixed
      • Internal
    • 0.6.0 - 2025-11-21
      • Added
      • Changed
      • Fixed
    • 0.5.0 - 2025-11-21
      • Added
      • Changed
      • Fixed
    • 0.4.0 - 2025-11-20
      • Added
      • Changed
      • Fixed
    • 0.3.0 - 2025-11-20
      • Added
      • Changed
    • 0.2.0 - 2025-11-20
      • Added
      • Changed
      • Fixed
      • Security
    • 0.1.0 - Initial Release
      • Added
  • Frequently Asked Questions (FAQ)
    • Installation
      • What are the prerequisites?
    • General Questions
      • What is Moltres?
      • How is Moltres different from PySpark?
      • How is Moltres different from Pandas?
      • Which databases are supported?
    • Usage Questions
      • How do I connect to a database?
      • How do I read data from a table?
      • How do I read data from files?
      • How do I filter rows?
      • How do I join tables?
      • How do I aggregate data?
      • How do I execute a query and get results?
      • How do I see the generated SQL?
    • Performance Questions
      • Why is my query slow?
      • How do I optimize queries?
      • Does Moltres cache results?
    • Error Questions
      • What does “CompilationError” mean?
      • What does “ExecutionError” mean?
      • How do I debug query errors?
    • Configuration Questions
      • How do I configure connection pooling?
      • How do I set query timeout?
      • How do I enable SQL logging?
    • Feature Questions
      • Does Moltres support UDFs (User-Defined Functions)?
      • Does Moltres support window functions?
      • Does Moltres support recursive queries?
      • Does Moltres support LATERAL joins?
      • Can I use raw SQL?
    • Migration Questions
      • How do I migrate from PySpark?
      • How do I migrate from Pandas?
    • Troubleshooting
      • My query returns no results
      • My query is too slow
      • I get “table does not exist” error
      • Column names are case-sensitive
    • Getting Help
  • Moltres Roadmap
    • Competitive gaps we are closing
    • Release philosophy (1.x)
    • v1.2 — API consolidation (“one obvious way”)
      • Deliverables
      • Success metrics
    • v1.3 — SQL depth and dialect parity
      • Deliverables
      • Success metrics
    • v1.4 — File I/O honesty and performance credibility
      • Deliverables
      • Success metrics
    • v1.5 — PostgreSQL-first backend depth
      • Deliverables
      • Success metrics
    • v1.6 — Ecosystem maturity and adoption
      • Deliverables
      • Success metrics
    • v2.0 preview (breaking window — deprecate throughout 1.x)
    • What we are explicitly not building in 1.x
    • How to influence the roadmap
    • Related documents

Getting started & migration

  • Migrating from Pandas to Moltres
    • Why Migrate?
    • Key Differences
    • Migration Patterns
      • 1. Reading Data
      • 2. Filtering
      • 3. Selecting Columns
      • 4. GroupBy and Aggregations
      • 5. Joins
      • 6. Sorting
      • 7. Adding/Modifying Columns
      • 8. Working with Results
    • Using Pandas-Style Interface
    • Handling Large Datasets
    • Common Migration Challenges
      • Challenge 1: Eager vs Lazy Execution
      • Challenge 2: Boolean Values
      • Challenge 3: String Operations
    • Migration Checklist
    • Next Steps
  • Migrating from PySpark to Moltres
    • Why Migrate?
    • Key Similarities
    • Key Differences
    • Migration footguns
      • union vs unionAll
      • File I/O: db.load.* vs db.read.*
      • Writes and execution
    • Migration Patterns
      • 1. Initialization
      • 2. Reading Data
      • 3. Basic Operations
      • 4. Joins
      • 5. Window Functions
      • 6. UDFs (User-Defined Functions)
      • 7. Writing Data
      • 8. CRUD Operations (Moltres Advantage)
    • Performance Considerations
      • PySpark Optimizations
      • Moltres Optimizations
    • Migration Strategy
      • Step 1: Identify Data Sources
      • Step 2: Convert Transformations
      • Step 3: Handle UDFs
      • Step 4: Test Incrementally
    • Common Migration Challenges
      • Challenge 1: Distributed Processing
      • Challenge 2: Large File Processing
      • Challenge 3: Complex UDFs
    • Migration Checklist
    • Next Steps

Guides & how-to

  • Common Patterns and Use Cases
    • Table of Contents
    • Data Pipeline Patterns
      • Pattern 1: Incremental Data Loading
      • Pattern 2: Data Transformation Pipeline
      • Pattern 3: Data Validation Pipeline
    • Analytics Patterns
      • Pattern 4: Cohort Analysis
      • Pattern 5: Time Series Analysis
      • Pattern 6: Top N Analysis
    • ETL Patterns
      • Pattern 7: Extract, Transform, Load
      • Pattern 8: Data Deduplication
    • Data Quality Patterns
      • Pattern 9: Data Profiling
      • Pattern 10: Data Reconciliation
    • Reporting Patterns
      • Pattern 11: Summary Reports
      • Pattern 12: Pivot Tables
    • CRUD Patterns
      • Pattern 13: Upsert (Insert or Update)
      • Pattern 14: Soft Deletes
      • Pattern 15: Audit Trail
    • Next Steps
  • Performance Optimization Guide
    • Understanding Moltres Performance
    • Best Practices
      • 1. Use Indexes
      • 2. Filter Early
      • 3. Select Only Needed Columns
      • 4. Use LIMIT for Exploration
      • 5. Optimize Joins
      • 6. Use Aggregations Efficiently
      • 7. Connection Pooling
      • 8. Use Streaming for Large Results
      • 9. Batch Operations
      • 10. Avoid N+1 Queries
    • Database-Specific Optimizations
      • PostgreSQL
      • MySQL
      • SQLite
    • Monitoring Performance
      • 1. Enable SQL Logging
      • 2. Use Performance Hooks
      • 3. Check Query Plans
    • Common Performance Pitfalls
      • 1. Loading Entire Tables
      • 2. Multiple Collect Calls
      • 3. Unnecessary Joins
      • 4. Over-aggregation
    • Performance Testing
      • Benchmark Your Queries
    • Next Steps
  • Error Handling and Debugging Guide
    • Common Error Types
      • 1. Connection Errors
      • 2. Compilation Errors
      • 3. Execution Errors
      • 4. Validation Errors
    • Debugging Techniques
      • 1. Enable SQL Logging
      • 2. Inspect Query Plans
      • 3. Check Generated SQL
      • 4. Validate Before Execution
      • 5. Use Try-Except Blocks
    • Common Issues and Solutions
      • Issue 1: “Table does not exist”
      • Issue 2: “Column does not exist”
      • Issue 3: “Ambiguous column name”
      • Issue 4: “Type mismatch”
      • Issue 5: “Boolean value error” (SQLite)
      • Issue 6: “Connection pool exhausted”
    • Performance Debugging
      • Identify Slow Queries
      • Check Query Execution Time
      • Analyze Query Plans
    • Best Practices for Error Handling
      • 1. Validate Inputs Early
      • 2. Use Context Managers
      • 3. Handle Database-Specific Errors
      • 4. Log Errors Appropriately
    • Getting Help
    • Next Steps
  • Advanced Topics
    • Table of Contents
    • Async Operations
      • Basic Async Usage
      • Async Streaming
      • Async CRUD Operations
    • Streaming Large Datasets
      • Streaming Reads
      • Streaming Writes
      • Chunked Processing
    • Custom SQL Functions
      • Using Database Functions
      • Creating Database Functions
    • Transactions
      • Basic Transactions
      • Manual Transaction Control
      • Nested Transactions
    • Schema Management
      • Reflecting Existing Schemas
      • Schema Comparison
      • Schema Migration
    • SQLAlchemy Integration
      • Using SQLAlchemy Models
      • Using SQLAlchemy Engine
      • Mixing SQLAlchemy and Moltres
    • Window Functions
      • Ranking
      • Moving Averages
      • Partitioned Windows
      • Cumulative Sums
    • CTEs and Subqueries
      • Simple CTE
      • Recursive CTE
      • Subqueries
    • Performance Tuning
      • Query Hints
      • Connection Pooling
      • Batch Operations
    • Next Steps
  • Best Practices Guide
    • Code Organization
      • 1. Separate Connection Logic
      • 2. Use Type Hints
      • 3. Organize by Functionality
    • Query Writing
      • 1. Use Descriptive Variable Names
      • 2. Build Queries Incrementally
      • 3. Use Column Aliases
    • Error Handling
      • 1. Always Handle Errors
      • 2. Validate Inputs
      • 3. Use Context Managers
    • Performance
      • 1. Filter Early
      • 2. Select Only Needed Columns
      • 3. Use Indexes
      • 4. Avoid N+1 Queries
    • Security
      • 1. Never Use String Formatting for SQL
      • 2. Validate Table/Column Names
      • 3. Use Least Privilege
    • Testing
      • 1. Use Test Databases
      • 2. Test Query Logic Separately
      • 3. Use Fixtures for Test Data
    • Documentation
      • 1. Document Complex Queries
      • 2. Use Type Hints
    • Configuration
      • 1. Use Environment Variables
      • 2. Centralize Configuration
    • Code Reusability
      • 1. Create Query Builders
      • 2. Use Helper Functions
    • Maintenance
      • 1. Keep Queries Simple
      • 2. Refactor Complex Queries
    • Next Steps
  • Using the Pandas-Style Interface in Moltres
    • Overview
    • Getting Started
      • Creating a PandasDataFrame
      • Column Access
    • Filtering with Query
      • Query Syntax
    • String Accessor
      • Basic String Operations
      • String Matching
      • String Replacement
      • String Length
    • Data Inspection
      • Column Types
      • Shape and Size
      • Head and Tail
      • Unique Values
      • Value Counts
    • GroupBy Operations
      • Basic Aggregations
      • Dictionary Aggregations
      • Multiple Grouping Columns
    • Merging DataFrames
      • Join Types
    • Sorting
    • Dropping Duplicates
    • Assigning New Columns
    • Renaming Columns
    • Dropping Columns
    • Chaining Operations
    • Boolean Indexing
    • Collecting Results
      • Streaming Results
    • Error Handling
    • Limitations and Differences from Pandas
      • Key Differences
      • Not Yet Supported
    • Best Practices
      • 1. Use Query for Simple Filtering
      • 2. Leverage String Accessor
      • 3. Cache Expensive Operations
      • 4. Use Appropriate Join Types
      • 5. Validate Early
    • Performance Considerations
    • Examples
    • Data Reshaping
    • Sampling and Limiting
    • Concatenation
    • Advanced Filtering
    • SQL Expressions and CTEs
    • Next Steps
  • Using the Polars-Style Interface in Moltres
    • Overview
    • Getting Started
      • Creating a PolarsDataFrame
      • Column Access
    • Filtering
    • Selecting Columns
    • Adding and Modifying Columns
    • GroupBy Operations
    • Joins
    • Sorting
    • Data Manipulation
      • Dropping Columns
      • Renaming Columns
      • Removing Duplicates
      • Handling Nulls
    • Limiting and Sampling
    • Data Inspection
    • Collecting Results
    • Chaining Operations
    • Comparison with Polars LazyFrame
    • Key Differences
    • Reading Files (Polars-Style)
    • Writing Files (Polars-Style)
    • String Operations (.str namespace)
    • DateTime Operations (.dt namespace)
    • Window Functions
    • Conditional Expressions (when().then().otherwise())
    • Additional Operations
      • Explode and Unnest
      • Pivot
      • Slice
      • Utility Methods
    • Set Operations
    • SQL Expression Selection
    • Common Table Expressions (CTEs)
    • Additional Utility Methods
    • Best Practices
    • See Also
  • SQL Approaches Comparison Guide
    • Table of Contents
    • Overview
    • Database Setup
      • Schema
      • Target Query
    • Approach 1: Raw SQL
      • Pros
      • Cons
      • Implementation
      • Key Points
      • Common Pitfalls
    • Approach 2: SQLAlchemy Core
      • Pros
      • Cons
      • Implementation
      • Key Points
      • Common Pitfalls
    • Approach 3: Moltres DataFrame API
      • Pros
      • Cons
      • Implementation
      • Alternative: More Concise Version
      • Key Points
      • Inspecting Generated SQL
      • Common Pitfalls
    • Side-by-Side Comparison
      • Code Complexity Comparison
      • Readability Comparison
    • When to Use Each Approach
      • Use Raw SQL When:
      • Use SQLAlchemy Core When:
      • Use Moltres When:
      • Migration Paths
        • From Raw SQL to SQLAlchemy Core
        • From Raw SQL to Moltres
        • From SQLAlchemy Core to Moltres
    • Conclusion
      • Quick Decision Guide
      • Further Reading
  • Transaction Control Guide
    • Basic Transactions
    • Savepoints and Nested Transactions
      • Creating Savepoints
      • Nested Transactions with Savepoints
      • Releasing Savepoints
    • Isolation Levels
    • Read-Only Transactions
    • Transaction Timeouts
    • Transaction State Inspection
    • Row-Level Locking
      • FOR UPDATE
      • FOR SHARE
      • NOWAIT and SKIP LOCKED
    • Async Transactions
    • Transaction Methods
      • Transaction.savepoint(name=None)
      • Transaction.rollback_to_savepoint(name)
      • Transaction.release_savepoint(name)
      • Transaction.is_readonly()
      • Transaction.isolation_level()
      • Transaction.is_active()
    • Best Practices
    • Limitations
    • Error Handling
  • Transaction Utilities Guide
    • Overview
    • Transaction Decorator
      • Basic Usage
      • Decorator Parameters
      • Async Support
      • Automatic Rollback on Errors
    • Transaction Hooks
      • Registering Hooks
      • Async Hooks
      • Unregistering Hooks
      • Use Cases
    • Transaction Metrics
      • Getting Metrics
      • Metrics Available
      • Resetting Metrics
    • Transaction Retry
      • Basic Retry
      • Custom Retry Configuration
      • Retry Callbacks
      • Async Retry
      • Retryable Errors
    • Transaction Testing
      • Concurrent Transaction Testing
      • Async Concurrent Testing
      • Deadlock Simulation
      • Isolation Level Testing
    • Best Practices
    • Complete Example

Integrations

  • SQLAlchemy Integration Guide
    • Overview
    • Using Existing SQLAlchemy Objects
      • From SQLAlchemy Engine
      • From SQLAlchemy Connection
      • From SQLAlchemy Session
      • Async Versions
    • Converting DataFrames to SQLAlchemy Statements
      • Using to_sqlalchemy() Method
      • Using Convenience Function
      • With Pandas/Polars Interfaces
    • Creating DataFrames from SQLAlchemy Statements
      • Using Convenience Function
    • Executing with Existing Connections
      • Using execute_with_connection()
      • Using execute_with_session()
    • Working with Transactions
    • Best Practices
      • Connection Lifecycle
      • Transaction Handling
      • Dialect Detection
    • Async Integration
    • Examples
    • Summary
  • SQLModel and Pydantic Integration Guide
    • Overview
    • Installation
    • Basic Usage
      • Using SQLModel Models
      • Using Pure Pydantic Models
      • Method 1: Using table() with SQLModel
      • Method 2: Using with_model()
      • Method 3: Using Integration Helpers
    • Chaining Operations
    • Streaming with SQLModel
    • Integration with SQLAlchemy
      • Using with SQLAlchemy Sessions
      • Using with SQLAlchemy Connections
    • Async Support
    • Best Practices
      • 1. Use Models for Type Safety
      • 2. Reuse Models Across Operations
      • 3. Choose the Right Model Type
      • 4. Handle Optional Dependencies
    • Common Patterns
      • Filtering and Sorting
      • Aggregations
      • Joins
    • Limitations
    • Troubleshooting
      • ImportError: SQLModel not installed
      • TypeError: Expected SQLModel or Pydantic class
      • Results are dictionaries instead of models
    • See Also
  • Django Integration Guide
    • Overview
    • Installation
    • Quick Start
      • 1. Configure Django Settings
      • 2. Use in Views
      • 3. Use in Templates
    • Middleware for Error Handling
      • Configuration
      • Error Mapping
      • Example
    • Database Connection Helpers
      • Basic Usage
      • Database Routing
      • Supported Databases
      • Transaction Management
    • Management Commands
      • Basic Usage
      • Filtering and Limits
      • Options
      • Interactive Mode
      • Example Queries
    • Template Tags
      • Basic Usage
      • Filtering
      • Caching
      • Custom Cache Key
      • Formatting Results
      • Template Tag Options
    • Complete Example
      • settings.py
      • views.py
      • template.html
      • urls.py
    • Best Practices
      • 1. Keep Complex Queries in Views
      • 2. Use Database Routing
      • 3. Cache Template Queries
      • 4. Use Transactions
      • 5. Error Handling
      • 6. Use Management Commands for Data Exploration
    • Troubleshooting
      • ImportError: Django is required
      • Database Connection Errors
      • Template Tag Not Found
      • Management Command Not Found
    • See Also
  • Streamlit Integration Guide
    • Installation
    • Quick Start
    • Features
      • 1. DataFrame Display
        • Basic Usage
        • With Query Information
        • Custom Display Options
      • 2. Interactive Query Builder
      • 3. Query Result Caching
        • Basic Caching
        • With TTL (Time-To-Live)
        • With Max Entries
        • Cache Management
      • 4. Session State Management
        • Automatic Connection Management
        • Using Streamlit Secrets
        • Manual Connection Management
        • Multiple Database Connections
      • 5. Query Visualization
        • Basic Visualization
        • With All Options
      • 6. Error Handling
    • Complete Example
    • Best Practices
      • 1. Connection Management
      • 2. Caching
      • 3. Error Handling
      • 4. Performance
      • 5. Async DataFrames
    • Troubleshooting
      • Import Errors
      • Connection Issues
      • Caching Issues
      • Performance Issues
    • API Reference
      • moltres_dataframe(df, show_query_info=True, **kwargs)
      • query_builder(db)
      • cached_query(ttl=None, max_entries=None)
      • get_db_from_session(key="db")
      • init_db_connection(dsn, key="db")
      • close_db_connection(key="db")
      • visualize_query(df, show_sql=True, show_plan=True, show_metrics=False)
      • display_moltres_error(error)
      • clear_moltres_cache()
      • invalidate_query_cache(query_sql)
    • See Also
  • Pytest Integration Guide
    • Installation
    • Quick Start
      • Basic Database Fixture
      • Async Database Fixture
    • Features
      • Database Fixtures
        • moltres_db Fixture
        • moltres_async_db Fixture
      • Test Data Fixtures
        • test_data Fixture
        • create_test_df() Helper
      • Custom Assertions
        • assert_dataframe_equal()
        • assert_schema_equal()
        • assert_query_results()
      • Query Logging
        • query_logger Fixture
      • Database-Specific Tests
      • Performance Tests
    • Configuration
      • Environment Variables
      • Pytest Markers
    • Best Practices
    • Examples
    • See Also
  • Workflow Orchestration Integration Guide
    • Installation
      • Airflow
      • Prefect
    • Apache Airflow Integration
      • Quick Start
      • Operators
        • MoltresQueryOperator
        • MoltresToTableOperator
        • MoltresDataQualityOperator
      • Data Quality Checks
      • ETL Pipeline Helper
      • Error Handling
    • Prefect Integration
      • Quick Start
      • Tasks
        • moltres_query
        • moltres_to_table
        • moltres_data_quality
      • Flow Orchestration
      • Error Handling and Retries
    • Common Patterns
      • Multi-Step ETL Pipeline
      • Parallel Processing
      • Conditional Workflows
    • Best Practices
    • Troubleshooting
      • Common Issues
      • Getting Help
    • Examples
  • dbt Integration Guide
    • Installation
    • Quick Start
      • Basic dbt Python Model
    • Features
      • Database Connection
        • get_moltres_connection()
      • Referencing dbt Models
        • moltres_ref()
      • Referencing dbt Sources
        • moltres_source()
      • Accessing dbt Variables
        • moltres_var()
    • Configuration
    • Best Practices
    • Examples
    • See Also

Concepts & operations

  • Why Moltres?
    • The Missing Piece in Python’s Data Ecosystem
    • The Gap in Python’s Ecosystem
      • What Currently Exists
    • What Makes Moltres Unique
    • Who Needs Moltres?
      • Data Engineers
      • Backend Developers
      • Analytics Engineers / dbt Users
      • Product Engineers
      • Teams Migrating Off Spark
    • Why This Matters
      • Pain Today
      • Moltres Fixes This
    • Why Moltres Is Important for the Future of Python Data
    • Summary
    • See Also
  • Moltres Design Notes
    • Layers
    • Workflows
    • Testing & Tooling
  • Performance Tuning Guide
    • Overview
    • SQL Pushdown
    • Performance Best Practices
      • 1. Use Indexes
      • 2. Filter Early
      • 3. Select Only Needed Columns
      • 4. Use LIMIT for Exploratory Queries
      • 5. Optimize Joins
      • 6. Use Aggregations Efficiently
      • 7. Connection Pooling
      • 8. Use Streaming for Large Results
      • 9. Batch Operations
      • 10. Query Timeout
    • Performance Monitoring
    • Database-Specific Optimizations
      • PostgreSQL
      • SQLite
      • MySQL
    • Common Performance Issues
      • Issue 1: Full Table Scans
      • Issue 2: Large Result Sets
      • Issue 3: N+1 Query Problem
      • Issue 4: Inefficient Aggregations
    • Benchmarking
    • Performance Comparison
    • Summary
  • Runtime & Platform Support
    • Python & Operating Systems
    • Database Backends
      • Fixture expectations
    • Optional Dependencies
    • Verifying Your Environment
  • Security Guide
    • Secure DSN Handling
      • Never Hardcode Credentials
      • Use Environment Variables
      • Use Secret Management Services
      • DSN Security Best Practices
    • SQL Injection Prevention
      • Safe Practices
    • Access Control
      • Database-Level Security
      • Application-Level Security
    • Audit Logging
    • File Path Security
    • Integration Caching
    • Dependency Security
      • Regular Updates
      • Vulnerability Scanning
      • Dependency Pinning
    • Network Security
      • Use Encrypted Connections
      • Firewall Rules
    • Data Handling
      • Sensitive Data
      • Data Retention
    • Compliance
      • GDPR
      • HIPAA
    • Incident Response
      • Security Incident Procedures
      • Logging Security Events
    • Best Practices Summary
    • Reporting Security Issues
  • Testing Guide
    • Test Structure
    • Database Support
      • SQLite (Default)
      • PostgreSQL
      • MySQL
    • Test Markers
    • Running Tests
      • Run all tests (SQLite only)
      • Run specific test markers
      • Run with coverage
    • Test Fixtures
      • Database Fixtures
      • Helper Functions
    • Writing Tests
      • Basic Test Example
      • Multi-Database Test Example
      • PostgreSQL-Specific Test Example
    • CI/CD Integration
    • Troubleshooting
      • PostgreSQL tests are skipped
      • MySQL tests are skipped
      • Tests fail with connection errors
  • Debugging Guide
    • Viewing Generated SQL
      • Method 1: show_sql() - Pretty-print SQL
      • Method 2: sql property - Get formatted SQL
      • Method 3: to_sql(pretty=True) - Get formatted SQL
      • Method 4: sql_preview() - Get SQL preview
      • Why This Helps
    • Common Error Patterns
      • 1. CompilationError
      • 2. ExecutionError
      • 3. QueryTimeoutError
      • 4. DatabaseConnectionError
    • Debugging Query Logic
      • 1. Step-by-Step Execution
      • 2. Verify Intermediate Results
      • 3. Compare Expected vs Actual
    • Debugging Performance Issues
      • 1. Use Query Plan Visualization
        • plan_summary() - Get structured plan statistics
        • visualize_plan() - ASCII tree visualization
        • explain() - Database execution plan
        • validate() - Check for common issues
        • performance_hints() - Get optimization suggestions
      • 2. Monitor Query Execution
      • 3. Profile Query Steps
    • Debugging Data Issues
      • 1. Check for NULL Values
      • 2. Verify Data Types
      • 3. Inspect Data Ranges
    • Debugging Join Issues
      • 1. Verify Join Keys
      • 2. Test Join Conditions
    • Debugging Aggregation Issues
      • 1. Verify Grouping Columns
      • 2. Check for NULL in Grouping
    • Tools and Techniques
      • 1. Enable SQL Logging
      • 2. Use Database Tools
      • 3. Create Test Queries
    • Schema Discovery
      • Get table schema
    • Interactive Help
      • help() - Display available operations
      • suggest_next() - Get suggestions for next operations
    • Summary
  • Deployment Guide
    • Pre-Deployment Checklist
    • Configuration
      • Environment Variables
      • Application Configuration
    • Connection Management
      • Connection Pooling
      • Connection Lifecycle
    • Error Handling
      • Production Error Handling
      • Retry Logic
    • Logging
      • Configure Logging
      • Custom Logging
    • Monitoring
      • Health Checks
      • Metrics Collection
    • Security
      • Connection String Security
      • SQL Injection Prevention
    • Database Setup
      • Indexes
      • Database Migrations
    • Deployment Strategies
      • Blue-Green Deployment
      • Canary Deployment
      • Rolling Deployment
    • Scaling
      • Horizontal Scaling
      • Vertical Scaling
      • Database Read Replicas
    • Backup and Recovery
      • Database Backups
      • Application State
    • Performance Tuning
      • Query Optimization
      • Connection Pool Tuning
    • Troubleshooting
      • Common Issues
    • Summary
  • Troubleshooting Guide
    • Connection Issues
      • “Failed to execute query” or Connection Errors
      • “Cannot collect a plan without an attached Database”
    • Query Issues
      • “Unsupported logical plan node” or Compilation Errors
      • “Join requires either equality keys or an explicit condition”
      • Empty Results or Unexpected Data
    • File Reading Issues
      • “File not found” Errors
      • Schema Inference Issues
    • Performance Issues
      • Slow Queries
      • Memory Issues
    • Type and Format Issues
      • “Unknown fetch format” Error
      • Type Errors with Mypy
    • Validation Errors
      • “SQL identifier cannot be empty” or Invalid Identifier Errors
      • “Row does not match expected columns”
    • Getting Help

Comparisons (reference)

  • Moltres vs PySpark API Comparison Report
    • Executive Summary
      • Key Findings
      • Use Case Recommendations
    • 1. Initialization & Connection
      • PySpark
      • Moltres
      • Comparison
    • 2. DataFrame Creation
      • PySpark
      • Moltres
      • Comparison
    • 3. DataFrame Transformations
      • 3.1 Select Operations
        • PySpark
        • Moltres
      • 3.2 Filter Operations
        • PySpark
        • Moltres
      • 3.3 Join Operations
        • PySpark
        • Moltres
      • 3.4 GroupBy and Aggregations
        • PySpark
        • Moltres
      • 3.5 Sorting
        • PySpark
        • Moltres
      • 3.6 Distinct Operations
        • PySpark
        • Moltres
      • 3.7 Column Operations
        • PySpark
        • Moltres
      • 3.8 Window Functions
        • PySpark
        • Moltres
    • 4. Read Operations
      • PySpark
      • Moltres
      • Comparison
    • 5. Write Operations
      • PySpark
      • Moltres
      • Comparison
    • 6. CRUD Operations
      • PySpark
      • Moltres
      • Comparison
      • MERGE/UPSERT Operations
    • 6.1. Transaction Management and Batch Operations
      • PySpark
      • Moltres
    • 6.2. Null Handling
      • PySpark
      • Moltres
    • 6.3. Query Plan Analysis
      • PySpark
      • Moltres
    • 6.4. Random Sampling
      • PySpark
      • Moltres
    • 6.5. Statistical Methods
      • PySpark
      • Moltres
    • 7. Expression System
      • PySpark
      • Moltres
      • Comparison
    • 8. Execution Model
      • PySpark
      • Moltres
      • Comparison
    • 9. Async Support
      • PySpark
      • Moltres
      • Comparison
    • 10. Advanced Features
      • 10.1 Window Functions
      • 10.2 Pivoting
      • 10.3 Explode/Array Operations
      • 10.4 CTEs (Common Table Expressions)
    • 11. API Design Patterns
      • Method Chaining
      • Naming Conventions
      • Return Type Consistency
    • 12. Recent API Improvements (2024)
      • ✅ Fully Compatible Features
      • API Compatibility Score
      • DataFrame Writer Parity (2025 assessment)
    • 13. Feature Gaps Analysis
      • What PySpark Has That Moltres Doesn’t
      • What Moltres Has That PySpark Doesn’t
    • 14. Migration Guide
      • Converting PySpark Code to Moltres
        • Example 1: Basic Operations
        • Example 2: Joins
        • Example 3: Updates
    • 15. Recommendations for Moltres
      • High Priority
      • Medium Priority
      • Low Priority
    • 16. Conclusion
      • Strengths of Moltres
      • Strengths of PySpark
      • When to Choose Each
      • Known Inconsistencies
        • 1. order_by() / orderBy() / sort() - String Parameter Support ✅ FIXED
        • 2. Window Functions Usage Pattern ✅ FIXED
        • 3. drop() - Column Object Support ✅ FIXED
      • Final Thoughts
    • Appendix: Method Comparison Tables
      • DataFrame Transformation Methods
      • Action Methods
      • Read Operations
      • Write Operations
    • Changelog
      • Recent Updates (2024)
      • Version 0.8.0 Updates
      • Version 0.7.0 Updates
      • Version 0.6.0 Updates
      • Version 0.5.0 Updates
  • Moltres vs SQLFrame Comparison
    • Executive Summary
      • Key Findings
      • Use Case Recommendations
    • 1. Initialization and Connection
      • SQLFrame
      • Moltres
      • Comparison
    • 2. DataFrame API and PySpark Compatibility
      • SQLFrame
      • Moltres
      • Comparison
    • 3. Supported Backends and Execution
      • SQLFrame
      • Moltres
      • Comparison
    • 4. CRUD and Mutations
      • SQLFrame
      • Moltres
      • Comparison
    • 5. Async Support
      • SQLFrame
      • Moltres
      • Comparison
    • 6. SQL Visibility and Tooling
      • SQLFrame
      • Moltres
      • Comparison
    • 7. Installation and Optional Dependencies
      • SQLFrame
      • Moltres
      • Comparison
    • 8. Summary Table
    • References
  • Moltres vs Ibis Comparison
    • Executive Summary
      • Key Findings
      • Use Case Recommendations
    • 1. Initialization and Connection
      • Ibis
      • Moltres
      • Comparison
    • 2. DataFrame API Style
      • Ibis
      • Moltres
      • Comparison
    • 3. Supported Backends and Execution
      • Ibis
      • Moltres
      • Comparison
    • 4. SQL and Expression Compilation
      • Ibis
      • Moltres
      • Comparison
    • 5. CRUD and Mutations
      • Ibis
      • Moltres
      • Comparison
    • 6. Async Support
      • Ibis
      • Moltres
      • Comparison
    • 7. Installation and Optional Dependencies
      • Ibis
      • Moltres
      • Comparison
    • 8. Summary Table
    • References
  • PySpark to Moltres Migration: Working Around Inconsistencies
    • Overview
    • High Priority Inconsistencies
      • 1. order_by() / orderBy() / sort() - String Parameter Support ✅ FIXED in v0.16.0
        • PySpark Code
        • Moltres Code (v0.16.0+)
        • Migration Pattern
    • Medium Priority Inconsistencies
      • 2. Window Functions Usage Pattern ✅ FIXED in v0.16.0
        • PySpark Code
        • Moltres Code (v0.16.0+)
        • Migration Pattern
    • Low Priority Inconsistencies
      • 3. drop() - Column Object Support ✅ FIXED in v0.16.0
        • PySpark Code
        • Moltres Code (v0.16.0+)
        • Migration Pattern
    • General Migration Tips
      • 1. Always Import col from Moltres
      • 2. Column References for Sorting and Grouping
      • 3. Check Method Signatures
      • 4. Use PySpark-Style Aliases
    • Complete Migration Example
      • PySpark Code
      • Moltres Code
    • Testing Your Migration
    • Getting Help
    • Union Semantics (Important Difference from PySpark)
    • Recent Improvements (v0.16.0+)

API reference

  • Moltres Package
    • Connection
      • connect()
      • async_connect()
    • Expression helpers
      • col()
      • lit()
      • column()
    • Configuration
      • create_config()
    • Performance hooks
      • register_performance_hook()
      • unregister_performance_hook()
  • Records API
    • AsyncLazyRecords
      • AsyncLazyRecords._read_func
      • AsyncLazyRecords._database
      • AsyncLazyRecords._schema
      • AsyncLazyRecords._options
      • AsyncLazyRecords._materialized
      • AsyncLazyRecords.collect()
      • AsyncLazyRecords.first()
      • AsyncLazyRecords.head()
      • AsyncLazyRecords.insert_into()
      • AsyncLazyRecords.iter()
      • AsyncLazyRecords.last()
      • AsyncLazyRecords.rename()
      • AsyncLazyRecords.rows()
      • AsyncLazyRecords.schema
      • AsyncLazyRecords.select()
      • AsyncLazyRecords.tail()
    • AsyncRecords
      • AsyncRecords.first()
      • AsyncRecords.from_dataframe()
      • AsyncRecords.from_dicts()
      • AsyncRecords.from_list()
      • AsyncRecords.head()
      • AsyncRecords.insert_into()
      • AsyncRecords.iter()
      • AsyncRecords.last()
      • AsyncRecords.rename()
      • AsyncRecords.rows()
      • AsyncRecords.schema
      • AsyncRecords.select()
      • AsyncRecords.tail()
    • LazyRecords
      • LazyRecords._read_func
      • LazyRecords._database
      • LazyRecords._schema
      • LazyRecords._options
      • LazyRecords._materialized
      • LazyRecords.collect()
      • LazyRecords.first()
      • LazyRecords.head()
      • LazyRecords.insert_into()
      • LazyRecords.iter()
      • LazyRecords.last()
      • LazyRecords.rename()
      • LazyRecords.rows()
      • LazyRecords.schema
      • LazyRecords.select()
      • LazyRecords.tail()
    • Records
      • Records.first()
      • Records.from_dataframe()
      • Records.from_dicts()
      • Records.from_list()
      • Records.head()
      • Records.insert_into()
      • Records.iter()
      • Records.last()
      • Records.rename()
      • Records.rows()
      • Records.schema
      • Records.select()
      • Records.tail()
  • DataFrame API
    • DataFrame
      • DataFrame.anti_join()
      • DataFrame.collect()
      • DataFrame.columns
      • DataFrame.count()
      • DataFrame.crossJoin()
      • DataFrame.cross_join()
      • DataFrame.cte()
      • DataFrame.database
      • DataFrame.describe()
      • DataFrame.distinct()
      • DataFrame.drop()
      • DataFrame.dropDuplicates()
      • DataFrame.drop_duplicates()
      • DataFrame.dropna()
      • DataFrame.dtypes
      • DataFrame.except_()
      • DataFrame.explain()
      • DataFrame.explode()
      • DataFrame.fillna()
      • DataFrame.filter()
      • DataFrame.first()
      • DataFrame.from_sqlalchemy()
      • DataFrame.from_table()
      • DataFrame.groupBy()
      • DataFrame.group_by()
      • DataFrame.head()
      • DataFrame.help()
      • DataFrame.intersect()
      • DataFrame.join()
      • DataFrame.limit()
      • DataFrame.model
      • DataFrame.na
      • DataFrame.nunique()
      • DataFrame.orderBy()
      • DataFrame.order_by()
      • DataFrame.performance_hints()
      • DataFrame.pivot()
      • DataFrame.plan
      • DataFrame.plan_summary()
      • DataFrame.polars()
      • DataFrame.printSchema()
      • DataFrame.print_schema()
      • DataFrame.recursive_cte()
      • DataFrame.sample()
      • DataFrame.schema
      • DataFrame.select()
      • DataFrame.selectExpr()
      • DataFrame.select_expr()
      • DataFrame.select_for_share()
      • DataFrame.select_for_update()
      • DataFrame.semi_join()
      • DataFrame.show()
      • DataFrame.show_sql()
      • DataFrame.sort()
      • DataFrame.sql
      • DataFrame.sql_preview()
      • DataFrame.suggest_next()
      • DataFrame.summary()
      • DataFrame.tail()
      • DataFrame.take()
      • DataFrame.to_sql()
      • DataFrame.to_sqlalchemy()
      • DataFrame.union()
      • DataFrame.unionAll()
      • DataFrame.union_all()
      • DataFrame.validate()
      • DataFrame.visualize_plan()
      • DataFrame.where()
      • DataFrame.withColumn()
      • DataFrame.withColumnRenamed()
      • DataFrame.withColumns()
      • DataFrame.with_column()
      • DataFrame.with_column_renamed()
      • DataFrame.with_columns()
      • DataFrame.with_model()
      • DataFrame.write
    • NullHandling
      • NullHandling.drop()
      • NullHandling.fill()
    • AsyncDataFrame
      • AsyncDataFrame
        • AsyncDataFrame.anti_join()
        • AsyncDataFrame.collect()
        • AsyncDataFrame.columns
        • AsyncDataFrame.count()
        • AsyncDataFrame.crossJoin()
        • AsyncDataFrame.cross_join()
        • AsyncDataFrame.cte()
        • AsyncDataFrame.database
        • AsyncDataFrame.describe()
        • AsyncDataFrame.distinct()
        • AsyncDataFrame.drop()
        • AsyncDataFrame.dropDuplicates()
        • AsyncDataFrame.drop_duplicates()
        • AsyncDataFrame.dropna()
        • AsyncDataFrame.dtypes
        • AsyncDataFrame.except_()
        • AsyncDataFrame.explode()
        • AsyncDataFrame.fillna()
        • AsyncDataFrame.filter()
        • AsyncDataFrame.first()
        • AsyncDataFrame.from_sqlalchemy()
        • AsyncDataFrame.from_table()
        • AsyncDataFrame.groupBy()
        • AsyncDataFrame.group_by()
        • AsyncDataFrame.head()
        • AsyncDataFrame.intersect()
        • AsyncDataFrame.join()
        • AsyncDataFrame.limit()
        • AsyncDataFrame.model
        • AsyncDataFrame.na
        • AsyncDataFrame.nunique()
        • AsyncDataFrame.orderBy()
        • AsyncDataFrame.order_by()
        • AsyncDataFrame.pivot()
        • AsyncDataFrame.plan
        • AsyncDataFrame.printSchema()
        • AsyncDataFrame.print_schema()
        • AsyncDataFrame.recursive_cte()
        • AsyncDataFrame.sample()
        • AsyncDataFrame.schema
        • AsyncDataFrame.select()
        • AsyncDataFrame.selectExpr()
        • AsyncDataFrame.select_expr()
        • AsyncDataFrame.select_for_share()
        • AsyncDataFrame.select_for_update()
        • AsyncDataFrame.semi_join()
        • AsyncDataFrame.show()
        • AsyncDataFrame.sort()
        • AsyncDataFrame.summary()
        • AsyncDataFrame.take()
        • AsyncDataFrame.to_sql()
        • AsyncDataFrame.to_sqlalchemy()
        • AsyncDataFrame.union()
        • AsyncDataFrame.unionAll()
        • AsyncDataFrame.union_all()
        • AsyncDataFrame.where()
        • AsyncDataFrame.withColumn()
        • AsyncDataFrame.withColumnRenamed()
        • AsyncDataFrame.withColumns()
        • AsyncDataFrame.with_column()
        • AsyncDataFrame.with_column_renamed()
        • AsyncDataFrame.with_columns()
        • AsyncDataFrame.with_model()
        • AsyncDataFrame.write
      • AsyncNullHandling
        • AsyncNullHandling.drop()
        • AsyncNullHandling.fill()
        • AsyncNullHandling.pandas()
        • AsyncNullHandling.polars()
    • GroupedDataFrame
      • GroupedDataFrame
        • GroupedDataFrame.agg()
        • GroupedDataFrame.keys
        • GroupedDataFrame.parent
        • GroupedDataFrame.pivot()
        • GroupedDataFrame.plan
      • PivotedGroupedDataFrame
        • PivotedGroupedDataFrame.agg()
        • PivotedGroupedDataFrame.keys
        • PivotedGroupedDataFrame.parent
        • PivotedGroupedDataFrame.pivot_column
        • PivotedGroupedDataFrame.pivot_values
        • PivotedGroupedDataFrame.plan
  • Expressions API
    • Column Expressions
      • Column
        • Column.alias()
        • Column.asc()
        • Column.between()
        • Column.cast()
        • Column.contains()
        • Column.desc()
        • Column.endswith()
        • Column.filter()
        • Column.ilike()
        • Column.is_not_null()
        • Column.is_null()
        • Column.isin()
        • Column.like()
        • Column.over()
        • Column.source
        • Column.startswith()
      • col()
      • ensure_column()
      • literal()
    • Functions
      • abs()
      • acos()
      • add_months()
      • array()
      • array_append()
      • array_contains()
      • array_distinct()
      • array_length()
      • array_max()
      • array_min()
      • array_position()
      • array_prepend()
      • array_remove()
      • array_sort()
      • array_sum()
      • asin()
      • atan()
      • atan2()
      • avg()
      • base64()
      • ceil()
      • coalesce()
      • collect_list()
      • collect_set()
      • concat()
      • corr()
      • cos()
      • count()
      • count_distinct()
      • covar()
      • crc32()
      • cume_dist()
      • current_date()
      • current_timestamp()
      • date_add()
      • date_format()
      • date_sub()
      • date_trunc()
      • datediff()
      • day()
      • dayofweek()
      • dayofyear()
      • dense_rank()
      • exists()
      • exp()
      • explode()
      • first_value()
      • floor()
      • from_json()
      • from_unixtime()
      • greatest()
      • hash()
      • hour()
      • hypot()
      • initcap()
      • instr()
      • isinf()
      • isnan()
      • isnotnull()
      • isnull()
      • json_array_length()
      • json_extract()
      • json_tuple()
      • lag()
      • last_day()
      • last_value()
      • lead()
      • least()
      • length()
      • lit()
      • locate()
      • log()
      • log10()
      • log2()
      • lower()
      • lpad()
      • ltrim()
      • max()
      • md5()
      • min()
      • minute()
      • monotonically_increasing_id()
      • month()
      • months_between()
      • not_exists()
      • nth_value()
      • ntile()
      • percent_rank()
      • percentile_cont()
      • percentile_disc()
      • pow()
      • power()
      • quarter()
      • rand()
      • randn()
      • rank()
      • regexp_extract()
      • regexp_replace()
      • replace()
      • round()
      • row_number()
      • rpad()
      • rtrim()
      • scalar_subquery()
      • second()
      • sha1()
      • sha2()
      • sign()
      • signum()
      • sin()
      • soundex()
      • split()
      • sqrt()
      • stddev()
      • substring()
      • sum()
      • tan()
      • to_date()
      • to_json()
      • to_timestamp()
      • translate()
      • trim()
      • unix_timestamp()
      • upper()
      • variance()
      • week()
      • weekofyear()
      • when()
      • year()
    • Window Functions
      • Window
        • Window.orderBy()
        • Window.order_by()
        • Window.partitionBy()
        • Window.partition_by()
        • Window.rangeBetween()
        • Window.range_between()
        • Window.rowsBetween()
        • Window.rows_between()
      • WindowSpec
        • WindowSpec.orderBy()
        • WindowSpec.order_by
        • WindowSpec.partitionBy()
        • WindowSpec.partition_by
        • WindowSpec.rangeBetween()
        • WindowSpec.range_between
        • WindowSpec.rowsBetween()
        • WindowSpec.rows_between
      • dense_rank()
      • first_value()
      • lag()
      • last_value()
      • lead()
      • rank()
      • row_number()
  • Table API
    • TableHandle
      • Database
        • Database.batch()
        • Database.close()
        • Database.compile_plan()
        • Database.connection_manager
        • Database.createDataFrame()
        • Database.create_dataframe()
        • Database.create_index()
        • Database.create_table()
        • Database.delete()
        • Database.dialect
        • Database.drop_index()
        • Database.drop_table()
        • Database.execute_plan()
        • Database.execute_plan_stream()
        • Database.execute_sql()
        • Database.executor
        • Database.explain()
        • Database.from_connection()
        • Database.from_engine()
        • Database.from_session()
        • Database.get_columns()
        • Database.get_table_names()
        • Database.get_transaction_status()
        • Database.get_view_names()
        • Database.insert()
        • Database.is_in_transaction()
        • Database.load
        • Database.merge()
        • Database.read
        • Database.reflect()
        • Database.reflect_table()
        • Database.scan_csv()
        • Database.scan_json()
        • Database.scan_jsonl()
        • Database.scan_parquet()
        • Database.scan_text()
        • Database.schema()
        • Database.show_schema()
        • Database.show_tables()
        • Database.sql()
        • Database.table()
        • Database.tables()
        • Database.transaction()
        • Database.update()
      • TableHandle
        • TableHandle.columns()
        • TableHandle.database
        • TableHandle.model
        • TableHandle.model_class
        • TableHandle.name
        • TableHandle.pandas()
        • TableHandle.polars()
        • TableHandle.select()
      • Transaction
        • Transaction.commit()
        • Transaction.is_active()
        • Transaction.is_readonly()
        • Transaction.isolation_level()
        • Transaction.release_savepoint()
        • Transaction.rollback()
        • Transaction.rollback_to_savepoint()
        • Transaction.savepoint()
    • AsyncTableHandle
      • AsyncDatabase
        • AsyncDatabase.close()
        • AsyncDatabase.compile_plan()
        • AsyncDatabase.connection_manager
        • AsyncDatabase.createDataFrame()
        • AsyncDatabase.create_dataframe()
        • AsyncDatabase.create_index()
        • AsyncDatabase.create_table()
        • AsyncDatabase.delete()
        • AsyncDatabase.dialect
        • AsyncDatabase.drop_index()
        • AsyncDatabase.drop_table()
        • AsyncDatabase.execute_plan()
        • AsyncDatabase.execute_plan_stream()
        • AsyncDatabase.execute_sql()
        • AsyncDatabase.executor
        • AsyncDatabase.from_async_connection()
        • AsyncDatabase.from_async_engine()
        • AsyncDatabase.from_async_session()
        • AsyncDatabase.get_columns()
        • AsyncDatabase.get_table_names()
        • AsyncDatabase.get_transaction_status()
        • AsyncDatabase.get_view_names()
        • AsyncDatabase.insert()
        • AsyncDatabase.is_in_transaction()
        • AsyncDatabase.load
        • AsyncDatabase.merge()
        • AsyncDatabase.read
        • AsyncDatabase.reflect()
        • AsyncDatabase.reflect_table()
        • AsyncDatabase.scan_csv()
        • AsyncDatabase.scan_json()
        • AsyncDatabase.scan_jsonl()
        • AsyncDatabase.scan_parquet()
        • AsyncDatabase.scan_text()
        • AsyncDatabase.sql()
        • AsyncDatabase.table()
        • AsyncDatabase.transaction()
        • AsyncDatabase.update()
      • AsyncTableHandle
        • AsyncTableHandle.database
        • AsyncTableHandle.model
        • AsyncTableHandle.model_class
        • AsyncTableHandle.name
        • AsyncTableHandle.pandas()
        • AsyncTableHandle.polars()
        • AsyncTableHandle.select()
      • AsyncTransaction
        • AsyncTransaction.commit()
        • AsyncTransaction.is_active()
        • AsyncTransaction.is_readonly()
        • AsyncTransaction.isolation_level()
        • AsyncTransaction.release_savepoint()
        • AsyncTransaction.rollback()
        • AsyncTransaction.rollback_to_savepoint()
        • AsyncTransaction.savepoint()
    • Schema
      • CheckConstraint
        • CheckConstraint.expression
        • CheckConstraint.name
      • ColumnDef
        • ColumnDef.default
        • ColumnDef.name
        • ColumnDef.nullable
        • ColumnDef.precision
        • ColumnDef.primary_key
        • ColumnDef.scale
        • ColumnDef.type_name
      • ForeignKeyConstraint
        • ForeignKeyConstraint.columns
        • ForeignKeyConstraint.name
        • ForeignKeyConstraint.on_delete
        • ForeignKeyConstraint.on_update
        • ForeignKeyConstraint.references_columns
        • ForeignKeyConstraint.references_table
      • TableSchema
        • TableSchema.columns
        • TableSchema.constraints
        • TableSchema.if_not_exists
        • TableSchema.name
        • TableSchema.temporary
      • UniqueConstraint
        • UniqueConstraint.columns
        • UniqueConstraint.name
      • check()
      • column()
      • decimal()
      • foreign_key()
      • json()
      • unique()
      • uuid()
  • Engine API
    • QueryExecutor
      • QueryExecutor
        • QueryExecutor.execute()
        • QueryExecutor.execute_many()
        • QueryExecutor.fetch()
      • QueryResult
        • QueryResult.rowcount
        • QueryResult.rows
      • register_performance_hook()
      • unregister_performance_hook()
    • ConnectionManager
      • ConnectionManager
        • ConnectionManager.active_transaction
        • ConnectionManager.begin_transaction()
        • ConnectionManager.close()
        • ConnectionManager.commit_transaction()
        • ConnectionManager.connect()
        • ConnectionManager.create_savepoint()
        • ConnectionManager.engine
        • ConnectionManager.release_savepoint()
        • ConnectionManager.rollback_to_savepoint()
        • ConnectionManager.rollback_transaction()
        • ConnectionManager.savepoint_stack
        • ConnectionManager.transaction_metadata
  • Contributing to Moltres
  • Contributing to Moltres
    • Getting Started
    • Development Setup
      • Running Tests
      • Code Quality
    • Making Changes
      • Code Style
      • Commit Messages
      • Pull Request Process
    • Code Review
    • Areas for Contribution
    • Questions?
  • Common Patterns and Examples
    • Showcase: Memory-Efficient Operations
      • Transform Large Tables Without Loading Data
      • View the Generated SQL
    • Showcase: CRUD + DataFrame Workflow
      • Query → Transform → Update Workflow
      • Bulk Update Based on DataFrame Query
    • Async Examples
      • Basic Async Query
      • Async File Reading
      • Async Mutations
    • Basic Query Patterns
      • Simple Select and Filter
      • Sorting and Limiting
    • Aggregations
      • Basic Aggregations
      • Grouping by Multiple Columns
    • Joins
      • Inner Join
      • Left Join
      • Multiple Join Conditions
      • Same Column Name (Simplest)
      • Table-Qualified Column References
    • Complex Queries
      • Subqueries (via CTEs - when supported)
      • Window Functions
    • Data Mutations
      • Insert Data
      • Update Data
      • Delete Data
    • File Operations
      • Loading Files
      • Writing Files
    • Streaming for Large Datasets
      • Streaming Reads
      • Streaming Writes
      • Streaming SQL Queries
    • Table Management
      • Create Table
      • Drop Table
    • Working with Results
      • Default Format (List of Dicts)
      • Pandas Format
      • Polars Format
    • Error Handling
      • Handling Validation Errors
      • Handling Execution Errors
    • Performance Tips
      • Use Batch Operations
      • Use Streaming for Large Data
      • Optimize Connection Pooling
    • Common Patterns
      • ETL Pipeline
      • Data Validation
      • Data Cleaning
    • Use Cases by Audience
      • For Data Engineers
        • Update Millions of Rows Without Loading into Memory
        • ETL Pipeline Without Materialization
      • For Backend Developers
        • Replace ORM Operations with DataFrame CRUD
        • Type-Safe CRUD Without Hand-Writing SQL
      • For Analytics Engineers / dbt Users
        • Express SQL Models in Python with DataFrame Chaining
        • dbt-like Transformations with Composable Operations
      • For Product Engineers
        • Building Data Features with DataFrame API
      • For Teams Migrating from Spark
        • Spark-like DataFrame API for Traditional SQL Databases
  • pydantable + Moltres SQL engine
    • Install
    • Usage sketch
    • Tests
    • Relationship to moltres
  • Release Process
    • Release Checklist
      • Pre-Release
      • Release Steps
      • Post-Release
    • Version Numbering
      • Examples
    • Deprecation Policy (1.1+)
      • Rules for maintainers
      • Example
    • Release Types
      • Patch Release (X.Y.Z → X.Y.Z+1)
      • Minor Release (X.Y.Z → X.Y+1.0)
      • Major Release (X.Y.Z → X+1.0.0)
    • Release Criteria
      • Must Have
      • Should Have
      • Nice to Have
    • Rollback Procedure
    • Automation
      • GitHub Actions
      • Release Automation (Future)
    • Release Notes Template
    • Approval Process
      • Patch Release
      • Minor Release
      • Major Release
    • Communication
      • Release Announcements
      • Release Channels
    • Emergency Releases
Moltres
  • Overview: module code

All modules for which code is available

  • moltres
    • moltres.config
    • moltres.dataframe.core.async_dataframe
    • moltres.dataframe.core.dataframe
    • moltres.dataframe.groupby.groupby
    • moltres.engine.execution
    • moltres.expressions.column
    • moltres.expressions.functions.aggregation
    • moltres.expressions.functions.array
    • moltres.expressions.functions.datetime
    • moltres.expressions.functions.json
    • moltres.expressions.functions.math
    • moltres.expressions.functions.misc
    • moltres.expressions.functions.string
    • moltres.expressions.functions.window
    • moltres.expressions.window
    • moltres.io.records
    • moltres.table.async_table
    • moltres.table.schema
    • moltres.table.table
  • moltres_core.sql.connection
  • moltres_core.sql.execution

© Copyright 2024, Odos Matthews.

Built with Sphinx using a theme provided by Read the Docs.