Moltres

Getting started & migration

  • Getting Started with Moltres
    • 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
  • 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 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

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
      • Options
      • Interactive Mode
      • Example Queries
    • Template Tags
      • Basic Usage
      • With Filtering
      • Caching
      • Custom Cache Key
      • Formatting Results
      • Template Tag Options
    • Complete Example
      • settings.py
      • views.py
      • template.html
      • urls.py
    • Best Practices
      • 1. Use Database Routing
      • 2. Cache Template Queries
      • 3. Use Transactions
      • 4. Error Handling
      • 5. 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
    • 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
  • 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
  • Frequently Asked Questions (FAQ)
    • 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

Internal & archive

  • Business Case: Moltres - The Missing DataFrame Layer for SQL in Python
    • Executive Summary
    • Problem Statement
    • Problem Analysis
      • Current State Assessment
      • Evidence of the Problem
      • Business Impact
      • Competitive Landscape Gap
    • Options
      • Option 1: Do Nothing (Status Quo)
      • Option 2: Build Custom Internal Solution
      • Option 3: Adopt Existing Alternatives (Ibis, SQLAlchemy Core, etc.)
      • Option 4: Fund and Accelerate Moltres Development (RECOMMENDED)
      • Option 5: Migrate to PySpark/Spark
    • Project Definition
      • Project Scope
      • Current Status
      • Development Roadmap (6-12 Months)
        • Phase 1: Core Enhancement (Months 1-3)
        • Phase 2: Ecosystem Integration (Months 4-6)
        • Phase 3: Enterprise Features (Months 7-9)
        • Phase 4: Community and Adoption (Months 10-12)
      • Resources Needed
      • Success Metrics
    • Financial Overview
      • Investment Required
        • Breakdown:
      • Return on Investment (ROI)
        • Cost Savings
        • Revenue Opportunities
      • ROI Calculation
      • Financial Assumptions
      • Risk Assessment
    • Recommendation
      • Recommended Option: Fund and Accelerate Moltres Development (Option 4)
      • Implementation Plan
      • Success Criteria
      • Conclusion
    • Appendix
      • A. Competitive Analysis
      • B. Technical Architecture
      • C. Market Research
      • D. Risk Mitigation Strategies
  • Project Charter: Moltres Development Acceleration
    • Project Purpose
    • Project Objectives
      • Primary Objectives
      • Success Criteria
    • Project Scope
      • In Scope
      • Out of Scope
    • Timeline
      • Key Milestones
    • Budget
      • Budget Breakdown
      • Expected ROI
    • Project Manager Authority
    • High-Level Risks
    • Stakeholders
      • Primary Stakeholders
      • Secondary Stakeholders
    • Project Vision
    • Assumptions and Constraints
      • Assumptions
      • Constraints
    • Approval
    • Document Control
  • Preliminary Project Scope Statement: Moltres Development Acceleration
    • 1. Project Scope Description
    • 2. Project Acceptance Criteria
      • Technical Acceptance Criteria
      • Adoption Acceptance Criteria
      • Quality Acceptance Criteria
      • Business Acceptance Criteria
    • 3. Project Deliverables (In Scope)
      • Phase 1: Core Enhancement (Months 1-3)
      • Phase 2: Ecosystem Integration (Months 4-6)
      • Phase 3: Enterprise Features (Months 7-9)
      • Phase 4: Community and Adoption (Months 10-12)
      • Supporting Deliverables
    • 4. Project Exclusions (Out of Scope)
      • Distributed Computing Capabilities
      • Database Engine Development
      • Feature Parity with Other Libraries
      • Commercial and Proprietary Features
      • Infrastructure and Operations
      • Documentation and Training Beyond Core Scope
      • Integration with Specific Proprietary Tools
      • Research and Experimental Features
    • 5. Assumptions
      • Technical Assumptions
      • Community and Adoption Assumptions
      • Resource and Timeline Assumptions
      • Business and Strategic Assumptions
      • Quality and Standards Assumptions
    • 6. Constraints
      • Technical Constraints
      • Resource Constraints
      • Process Constraints
      • Scope Constraints
      • External Constraints
      • Regulatory and Compliance Constraints
    • Document Control
    • Notes
  • Moltres Package Plan
    • 1. Name
    • 2. Project Goal
    • 3. High-Level Architecture
      • Core Layers (Bottom → Top)
    • 4. Package Directory Structure
    • 5. API Design
      • Connect to DB
      • Select & Filter
      • Joins
      • GroupBy & Aggregations
      • Insert
      • Update
      • Delete
    • 6. Internal Components
      • Expression System
      • Logical Plan Nodes
      • SQL Compiler
      • Execution Engine
      • Mutation Engine
    • 7. Development Roadmap
      • Week 1: Foundation
      • Week 2: Logical Plan + Compiler
      • Week 3: Full Query Support
      • Week 4: Mutation
      • Week 5: Polars Integration
      • Week 6: Stabilize API + Docs
    • 8. Testing Plan
    • 9. Value Proposition
  • 🐦🔥 Moltres: The Missing DataFrame Layer for SQL in Python
    • 🌟 Overview
    • 🧩 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
  • Moltres Integration Features Plan
    • Overview
    • Goals
    • Integration 1: Django Integration
      • Overview
      • Features to Implement
        • 1.1 Django Middleware for Error Handling
        • 1.2 Django Database Connection Helpers
        • 1.3 Django Management Commands
        • 1.4 Django Template Tags
      • Implementation Steps
      • Dependencies
      • Testing Strategy
    • Integration 2: Streamlit Integration
      • Overview
      • Features to Implement
        • 2.1 Streamlit DataFrame Components
        • 2.2 Streamlit Caching Integration
        • 2.3 Streamlit Session State Helpers
        • 2.4 Streamlit Query Visualization
      • Implementation Steps
      • Dependencies
      • Testing Strategy
    • Integration 3: Pytest Integration
      • Overview
      • Features to Implement
        • 3.1 Pytest Fixtures for Database Connections
        • 3.2 Pytest Fixtures for Test Data
        • 3.3 Pytest Assertions for DataFrames
        • 3.4 Pytest Markers for Database Tests
        • 3.5 Pytest Plugins for Query Logging
      • Implementation Steps
      • Dependencies
      • Testing Strategy
    • Integration 4: Airflow/Prefect Integration
      • Overview
      • Features to Implement
        • 4.1 Airflow Operators
        • 4.2 Prefect Tasks
        • 4.3 Data Quality Checks
        • 4.4 ETL Pipeline Helpers
      • Implementation Steps
      • Dependencies
      • Testing Strategy
    • Common Patterns Across All Integrations
      • Error Handling
      • Dependency Management
      • Testing
      • Documentation
    • Implementation Priority
      • Phase 1: High Priority (Immediate Value)
      • Phase 2: Medium Priority (High Impact)
    • Success Criteria
    • Timeline Estimate
    • Notes
  • Priority Implementation Roadmap
    • 🚀 Immediate Next Steps (v0.13.0)
      • 1. Schema Inspection & Reflection (High Impact, Medium Effort) ✅ COMPLETED
      • 2. FILTER Clause for Conditional Aggregation (High Impact, Low-Medium Effort) ✅ COMPLETED
      • 3. Schema Management - Constraints (High Impact, Medium Effort) ✅ COMPLETED
    • 📈 Short-term (v0.14.0)
    • 🔧 Developer Experience (v0.15.0)
      • 7. Better Type Safety (Medium Impact, High Effort)
      • 8. Test Coverage Improvements (Medium Impact, Medium Effort)
    • 🌐 Ecosystem Expansion (v0.16.0+)
      • 9. DuckDB Support (High Impact, Low Effort) ✅ COMPLETED
      • 10. BigQuery Support (High Impact, Medium Effort)
    • 🛠️ Infrastructure Improvements
      • 11. Automated Release Process (Low Impact, Low Effort)
      • 12. Enhanced Documentation (Medium Impact, Medium Effort)
    • 📊 Advanced Features (Future)
      • 13. UNNEST / Table-Valued Functions (High Impact, High Effort)
      • 14. Transaction Control Enhancements (Medium Impact, Medium Effort)
    • 🎯 Strategic Recommendations
      • Quick Wins (Do First)
      • Foundation Building (Do Early)
      • High-Value Features (Do Soon)
      • Ecosystem Expansion (Do When Ready)
      • Nice-to-Have (Do Later)
    • 📝 Implementation Notes
      • Dependencies
      • Risk Assessment
      • Effort vs Impact Matrix
    • 🎯 Recommended Sprint Plan
      • Sprint 1 (v0.13.0) - 4-6 weeks ✅ COMPLETED
      • Sprint 2 (v0.14.0) - 4-6 weeks
      • Sprint 3 (v0.15.0) - 4-6 weeks
      • Sprint 4 (v0.16.0) - 4-6 weeks
    • 💡 Key Insights
  • Migration Guide
    • Migrating from Pandas
      • Basic Operations
      • Key Differences
    • Migrating from SQLAlchemy ORM
      • Query Building
      • CRUD Operations
    • Migrating from PySpark
      • DataFrame Operations
      • Key Differences
    • Migrating from Ibis
      • Query Building
      • Key Differences
    • Migration Checklist
      • Pre-Migration
      • Migration Steps
      • Post-Migration
    • Common Migration Patterns
      • Pattern 1: Gradual Migration
      • Pattern 2: Big Bang Migration
      • Pattern 3: Hybrid Approach
    • Troubleshooting
      • Common Issues
    • Getting Help
  • PySpark to Moltres Migration Guide
    • Overview
    • Key Differences
      • 1. Initialization
      • 2. Reading Data
      • 3. Basic Operations
      • 4. Aggregations
      • 5. Joins
      • 6. Window Functions
      • 7. UDFs (User-Defined Functions)
      • 8. Collecting Results
      • 9. Writing Data
    • Migration Checklist
    • Common Patterns
      • Pattern 1: Filtering and Aggregation
      • Pattern 2: Window Functions
      • Pattern 3: Complex Joins
    • Limitations
    • Benefits
    • Getting Help
  • 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
  • PySpark Feature Comparison
    • Status Indicators
    • Selection & Projection
    • Filtering
    • Joins
    • GroupBy & Aggregations
    • Sorting
    • Window Functions
    • Set Operations
    • Column Manipulation
    • Null Handling
    • String Operations
    • Date/Time Operations
    • File I/O
    • Schema Operations
    • Execution Methods
    • Statistics & Descriptive
    • Data Reshaping
    • Sampling & Limiting
    • CTEs & SQL
    • Interface-Specific Features
      • Pandas-Style Unique Features
      • Polars-Style Unique Features
      • Async-Specific Features
    • Summary
      • Overall Coverage
      • Key Differences
      • Implementation Notes
  • PySpark Interface Audit for Moltres
    • Executive Summary
    • Method-by-Method Comparison
      • 1. Select Operations
      • 2. Filter Operations
      • 3. Sorting Operations
      • 4. Grouping Operations
      • 5. Aggregation Operations
      • 6. Join Operations
      • 7. Column Operations
      • 8. Set Operations
      • 9. Limit Operations
      • 10. Window Functions
    • Summary of Inconsistencies
      • High Priority
      • Medium Priority
      • Low Priority
    • Recommendations
      • Immediate Action (High Priority)
      • Future Enhancements (Medium/Low Priority)
    • Testing Recommendations
    • Conclusion
  • 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. Use col() Wrapper for Column References
      • 3. Check Method Signatures
      • 4. Use PySpark-Style Aliases
    • Complete Migration Example
      • PySpark Code
      • Moltres Code (With Workarounds)
    • Testing Your Migration
    • Getting Help
    • Recent Improvements (v0.16.0)
  • Performance Service Level Agreements (SLAs)
    • Benchmark Methodology
    • Query Performance SLAs
      • Simple SELECT Operations
      • Filter Operations
      • Aggregation Operations
      • Join Operations
      • Window Functions
    • Write Performance SLAs
      • INSERT Operations
      • UPDATE Operations
      • DELETE Operations
    • File I/O Performance SLAs
      • CSV Reading
      • JSON Reading
      • Parquet Reading
      • CSV Writing
      • JSON Writing
      • Parquet Writing
    • Connection Pool Performance
      • Connection Acquisition
      • Pool Sizing Recommendations
    • Memory Usage SLAs
      • Query Execution
      • File Reading
    • Performance Monitoring
      • Metrics to Track
      • Performance Hooks
    • Performance Tuning Tips
    • Regression Testing
    • Notes
  • Runtime Support Matrix
    • Python Versions
      • Python Version Support Policy
    • Database Backends
      • SQLite
      • PostgreSQL
      • MySQL / MariaDB
      • Other SQLAlchemy-Supported Databases
    • Operating Systems
    • Driver Version Requirements
      • Core Dependencies
      • Optional Dependencies
        • Async Support
        • Database-Specific Async Drivers
        • Data Format Support
        • Testing Dependencies
    • CI Testing Matrix
      • Python × OS Matrix
      • Database Backend Testing
    • Installation
      • Minimal Installation
      • With Async Support
      • With Database-Specific Async Drivers
      • With Data Format Support
      • Development Installation
    • Version Compatibility Notes
      • SQLAlchemy 2.0+
      • Python 3.9+
    • Known Limitations
    • Support and Reporting Issues
  • Test Harness Reference
    • When to Use Which Harness
    • Unique Table Management
    • Patterns for New Tests
      • 1. Sync tests against multiple backends
      • 2. Async tests
      • 3. File / staging heavy tests
    • Checklist Before Submitting a New Test
  • Operational Runbooks
    • Deployment
      • Pre-Deployment Checklist
      • Deployment Steps
    • Schema Migrations
      • Adding New Tables
  • Create new table
  • Use ALTER TABLE (database-specific)
    • Migration Best Practices
    • Incident Response
      • Database Connection Issues
      • Query Performance Issues
      • Memory Issues
  • Use streaming mode
    • Monitoring
      • Key Metrics to Monitor
      • Setting Up Monitoring
      • Alerting Thresholds
    • Backup and Recovery
      • Backup Procedures
      • Recovery Procedures
    • Scaling
      • Horizontal Scaling
      • Vertical Scaling
    • Maintenance Windows
      • Scheduled Maintenance
      • Maintenance Checklist
    • Troubleshooting
      • Common Issues
      • Debug Mode
      • Getting Help
  • Plan: Improve pytest-green-light for Parallel Test Execution
    • Problem Statement
    • Current Workaround
    • Goals
    • Implementation Plan
      • Phase 1: Detect Parallel Execution Environment
      • Phase 2: Event Loop Management
      • Phase 3: Update ensure_greenlet_context Fixture
      • Phase 4: Testing
      • Phase 5: Documentation
    • Technical Details
      • Event Loop Strategy
      • Fixture Implementation
    • Dependencies
    • Success Criteria
    • Migration Path
    • Open Questions
    • Related Issues
    • Timeline Estimate
    • Notes
  • Release Process
    • Release Checklist
      • Pre-Release
      • Release Steps
      • Post-Release
    • Version Numbering
      • Examples
    • 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

API reference

  • DataFrame API
    • AsyncDataFrame
    • GroupedDataFrame
      • AsyncGroupedDataFrame
        • AsyncGroupedDataFrame.agg()
        • AsyncGroupedDataFrame.pivot()
      • AsyncPandasGroupBy
        • AsyncPandasGroupBy.agg()
        • AsyncPandasGroupBy.count()
        • AsyncPandasGroupBy.first()
        • AsyncPandasGroupBy.last()
        • AsyncPandasGroupBy.max()
        • AsyncPandasGroupBy.mean()
        • AsyncPandasGroupBy.min()
        • AsyncPandasGroupBy.nunique()
        • AsyncPandasGroupBy.size()
        • AsyncPandasGroupBy.sum()
      • AsyncPolarsGroupBy
        • AsyncPolarsGroupBy.agg()
        • AsyncPolarsGroupBy.count()
        • AsyncPolarsGroupBy.first()
        • AsyncPolarsGroupBy.last()
        • AsyncPolarsGroupBy.max()
        • AsyncPolarsGroupBy.mean()
        • AsyncPolarsGroupBy.min()
        • AsyncPolarsGroupBy.n_unique()
        • AsyncPolarsGroupBy.std()
        • AsyncPolarsGroupBy.sum()
        • AsyncPolarsGroupBy.var()
      • GroupedDataFrame
        • GroupedDataFrame.agg()
        • GroupedDataFrame.keys
        • GroupedDataFrame.parent
        • GroupedDataFrame.pivot()
        • GroupedDataFrame.plan
      • PandasGroupBy
        • PandasGroupBy.agg()
        • PandasGroupBy.count()
        • PandasGroupBy.first()
        • PandasGroupBy.last()
        • PandasGroupBy.max()
        • PandasGroupBy.mean()
        • PandasGroupBy.min()
        • PandasGroupBy.nunique()
        • PandasGroupBy.size()
        • PandasGroupBy.sum()
      • PolarsGroupBy
        • PolarsGroupBy.agg()
        • PolarsGroupBy.count()
        • PolarsGroupBy.first()
        • PolarsGroupBy.last()
        • PolarsGroupBy.max()
        • PolarsGroupBy.mean()
        • PolarsGroupBy.min()
        • PolarsGroupBy.n_unique()
        • PolarsGroupBy.std()
        • PolarsGroupBy.sum()
        • PolarsGroupBy.var()
  • 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.partitionBy()
        • Window.rangeBetween()
        • Window.rowsBetween()
      • 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.config
        • Database.dialect
        • Database.batch()
        • Database.close()
        • Database.compile_plan()
        • Database.connection_manager
        • Database.createDataFrame()
        • 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_view_names()
        • Database.insert()
        • 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.name
        • TableHandle.database
        • TableHandle.model
        • TableHandle.columns()
        • TableHandle.database
        • TableHandle.model
        • TableHandle.model_class
        • TableHandle.name
        • TableHandle.pandas()
        • TableHandle.polars()
        • TableHandle.select()
      • Transaction
        • Transaction.commit()
        • Transaction.rollback()
    • AsyncTableHandle
      • AsyncDatabase
        • AsyncDatabase.close()
        • AsyncDatabase.compile_plan()
        • AsyncDatabase.connection_manager
        • AsyncDatabase.createDataFrame()
        • AsyncDatabase.create_index()
        • AsyncDatabase.create_table()
        • 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_view_names()
        • AsyncDatabase.load
        • 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()
      • AsyncTableHandle
        • AsyncTableHandle.database
        • AsyncTableHandle.model
        • AsyncTableHandle.model_class
        • AsyncTableHandle.name
        • AsyncTableHandle.pandas()
        • AsyncTableHandle.polars()
        • AsyncTableHandle.select()
      • AsyncTransaction
        • AsyncTransaction.commit()
        • AsyncTransaction.rollback()
    • 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
    • Database
      • Database
        • Database.config
        • Database.dialect
        • Database.batch()
        • Database.close()
        • Database.compile_plan()
        • Database.connection_manager
        • Database.createDataFrame()
        • 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_view_names()
        • Database.insert()
        • 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.name
        • TableHandle.database
        • TableHandle.model
        • TableHandle.columns()
        • TableHandle.database
        • TableHandle.model
        • TableHandle.model_class
        • TableHandle.name
        • TableHandle.pandas()
        • TableHandle.polars()
        • TableHandle.select()
      • Transaction
        • Transaction.commit()
        • Transaction.rollback()
    • QueryExecutor
      • QueryExecutor
        • QueryExecutor.execute()
        • QueryExecutor.execute_many()
        • QueryExecutor.fetch()
        • QueryExecutor.fetch_stream()
      • QueryResult
        • QueryResult.rowcount
        • QueryResult.rows
      • register_performance_hook()
      • unregister_performance_hook()
    • ConnectionManager
      • ConnectionManager
        • ConnectionManager.active_transaction
        • ConnectionManager.begin_transaction()
        • ConnectionManager.commit_transaction()
        • ConnectionManager.connect()
        • ConnectionManager.engine
        • ConnectionManager.rollback_transaction()
Moltres
  • Overview: module code

All modules for which code is available

  • moltres.dataframe.groupby.async_groupby
  • moltres.dataframe.groupby.async_pandas_groupby
  • moltres.dataframe.groupby.async_polars_groupby
  • moltres.dataframe.groupby.groupby
  • moltres.dataframe.groupby.pandas_groupby
  • moltres.dataframe.groupby.polars_groupby
  • moltres.engine.connection
  • 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.table.async_table
  • moltres.table.schema
  • moltres.table.table

© Copyright 2024, Odos Matthews.

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