Contents Menu Expand Light mode Dark mode Auto light/dark, in light mode Auto light/dark, in dark mode Skip to content
RowGuard
Light Logo Dark Logo

Getting started

  • Start here
  • Installation
  • Quickstart
  • SQLRules pushdown
  • FAQ
  • Troubleshooting

Guides

  • Rejection policies
  • Streaming
  • Async
  • ORM and SQLModel
  • Performance
  • Upgrading
  • Best practices
  • Examples

Reference

  • API.md
  • RowGuard Public API
  • Python autodoc
  • Error catalog
  • SPEC.md
  • RowGuard Specification
  • Scope
  • Core Pipeline
  • Primary API
  • QueryResult
  • RejectedRow
  • Rejection Policies
  • SQLRules Integration
  • Validation
  • Supported Inputs
  • Streaming
  • Async
  • Statistics
  • Diagnostics
  • Error Model
  • SQLModel Position
  • Performance Goals
  • Plugin Opportunities
  • Compatibility
  • Design Principles
  • Success Criteria

Architecture

  • ARCHITECTURE.md
  • RowGuard Architecture
  • Architectural Principles
  • Layered Design
  • SQLRules Integration
  • Internal Components
  • Query Lifecycle
  • Thread Safety
  • Extension Points
  • Non-Goals
  • Design Goals
  • Design philosophy

Maintainer design notes

  • EXECUTION_PIPELINE.md
  • RowGuard Execution Pipeline
  • High-Level Flow
  • Stage 1 – Build Execution Plan
  • Stage 2 – Query Construction
  • Stage 3 – SQLRules Integration
  • Stage 4 – Execute Statement
  • Stage 5 – Adapt Rows
  • Stage 6 – Validate
  • Stage 7 – Handle Rejections
  • Stage 8 – Collect Statistics
  • Stage 9 – Assemble Result
  • Error Propagation
  • Pipeline Invariants
  • Extensibility
  • Design Principles
  • QUERY_ENGINE.md
  • RowGuard Query Engine
  • Responsibilities
  • Execution Pipeline
  • Inputs
  • Execution Modes
  • SQLAlchemy Integration
  • Row Adaptation
  • Validation
  • Rejection Handling
  • Statistics
  • Error Handling
  • Concurrency
  • Extension Points
  • Performance Goals
  • Design Principles
  • QUERY_COMPILATION.md
  • RowGuard Query Compilation
  • Compilation vs Execution
  • Inputs
  • Compilation Stages
  • Caching
  • Diagnostics
  • Error Handling
  • Performance
  • Testing
  • MVP Scope
  • Design Principles
  • FILTER_PUSHDOWN.md
  • RowGuard Filter Pushdown
  • Core Principle
  • Goals
  • Responsibility Boundary
  • Pushdown Modes
  • Example
  • Why Validation Still Runs
  • Supported Constraint Categories
  • Unsupported Constraints
  • User-Supplied Filters
  • Existing Statements
  • Column Mapping
  • Joins
  • Outer Joins
  • Optional Fields and Nullability
  • Limits and Pagination
  • Counts and Aggregates
  • Ordering
  • Security Filters
  • Semantic Equivalence
  • Conservative Pushdown
  • Pushdown Safety Classes
  • Execution Plan Representation
  • Precompiled Rules
  • Caching
  • Observability
  • Explainability
  • Error Handling
  • Failure Policies
  • Streaming
  • Async
  • Plugins
  • Testing Requirements
  • MVP Scope
  • Design Principles
  • SQLRULES_INTEGRATION.md
  • SQLRules Integration
  • Architecture
  • Responsibilities
  • Integration Contract
  • Query Construction
  • SQL Pushdown
  • Validation Remains Required
  • Unsupported Constraints
  • Diagnostics
  • Caching
  • Execution Plans
  • Version Compatibility
  • Error Handling
  • Optional Usage
  • Future Integration
  • Testing Requirements
  • Design Principles
  • VALIDATION_ENGINE.md
  • RowGuard Validation Engine
  • Responsibilities
  • Position in the Pipeline
  • Inputs
  • Outputs
  • Validation Contract
  • Validation Modes
  • Nested Models
  • Validation Errors
  • ValidationResult
  • Statistics
  • Performance
  • Error Handling
  • Extension Points
  • Testing Requirements
  • MVP Scope
  • Design Principles
  • ROW_ADAPTER.md
  • RowGuard Row Adapter
  • Responsibilities
  • Core Contract
  • Default Adapter
  • Adaptation Context
  • Field Name Resolution
  • Pydantic Aliases
  • SQLAlchemy Core Rows
  • Labeled Columns
  • Joined Queries
  • ORM Entity Rows
  • SQLModel Compatibility
  • Scalar Results
  • Tuple and Sequence Rows
  • Extra Columns
  • Missing Fields
  • Duplicate Keys
  • Nested Models
  • Null Values
  • Type Conversion
  • Adaptation Result
  • Adaptation Errors
  • Diagnostics
  • Performance
  • Adapter Registry
  • Plugin Contract
  • Testing Requirements
  • Security and Correctness
  • MVP Scope
  • Design Principles
  • RESULT_OBJECT.md
  • RowGuard Result Object
  • Core Contract
  • Suggested Data Model
  • Models
  • Rejected Rows
  • QueryStatistics
  • Statement
  • Diagnostics
  • Convenience Properties
  • Iteration
  • Length
  • Indexing
  • Truthiness
  • Rejection Policy Effects
  • QueryOutcome vs QueryResult
  • Streaming Results
  • Async Results
  • Serialization
  • Memory Behavior
  • Type Safety
  • Equality and Hashing
  • RejectedRow Structure
  • Diagnostic Structure
  • Partial Results
  • Result Invariants
  • Error Handling
  • Extension Points
  • Testing Requirements
  • MVP Scope
  • Design Principles
  • STREAMING.md
  • RowGuard Streaming
  • Philosophy
  • Pipeline
  • Public API
  • StreamResult
  • Rejection Policies
  • Statistics
  • Backpressure
  • Resource Management
  • Error Handling
  • Ordering
  • Memory Goals
  • Extension Points
  • Testing
  • MVP Scope
  • Design Principles
  • ASYNC.md
  • RowGuard Async Architecture
  • Goals
  • Design Principles
  • Public API
  • Execution Pipeline
  • AsyncSession Support
  • Async Streaming
  • Rejection Handling
  • Event-loop blocking
  • Statistics
  • Cancellation
  • Error Handling
  • Testing
  • MVP Scope
  • Design Principles
  • PERFORMANCE.md
  • RowGuard Performance Architecture
  • Performance Priorities
  • Cost Model
  • Primary Performance Goals
  • Two-Phase Architecture
  • Planning Performance
  • Execution Plan Caching
  • SQLRules Pushdown
  • SQLAlchemy Statement Caching
  • Column Projection
  • Full Entity vs Projection Performance
  • Row Adaptation Performance
  • Mapping Views vs Dictionaries
  • Nested Adaptation
  • Pydantic Validation Performance
  • Custom Validator Cost
  • Strict vs Non-Strict Validation
  • Rejection Path Performance
  • Rejection Retention
  • Callback Performance
  • Quarantine Performance
  • Buffered Execution
  • Streaming Execution
  • Fetch Size and Batching
  • Backpressure
  • Async Performance
  • Parallel Validation
  • Diagnostics Overhead
  • Logging Overhead
  • Metrics Overhead
  • Tracing Overhead
  • Result Assembly Performance
  • Memory Retention
  • ORM Identity Map
  • Raw SQL Performance
  • Reflection Performance
  • Plan Reuse
  • Benchmark Categories
  • Representative Model Sizes
  • Representative Row Counts
  • Metrics to Record
  • Performance Targets
  • Baseline Comparison
  • Performance Regression Policy
  • Profiling
  • Hot Path Rules
  • Prebinding
  • Dataclasses and Slots
  • Generators and Iterators
  • Error Construction Cost
  • Quarantine Serialization Cost
  • Large Payload Handling
  • Time Measurement
  • Sampling Timers
  • Thread Safety
  • Process Safety
  • Startup Cost
  • Optional Dependencies
  • Rust or Native Acceleration
  • Performance Documentation
  • Testing Requirements
  • MVP Performance Scope
  • Recommended Performance Defaults
  • Design Principles
  • CACHE.md
  • RowGuard Cache Architecture
  • Goals
  • Non-Goals
  • Cache Layers
  • Model Metadata Cache
  • SQLRules Compilation Cache
  • Source Metadata Cache
  • Adapter Plan Cache
  • Validation Plan Cache
  • Execution Plan Cache
  • Plan Template vs Execution Plan
  • Cache Key Design
  • Statement Shape Fingerprints
  • Source Identity
  • Mapping Fingerprints
  • Plugin Fingerprints
  • Dialect Sensitivity
  • Validation Context
  • Rejection Policy Caching
  • Quarantine Provider Caching
  • Diagnostics Exporter Caching
  • Cache Scope
  • Recommended Default Scope
  • Cache Interface
  • Bounded LRU Cache
  • Weak References
  • Time-Based Expiration
  • Schema Changes
  • Model Changes
  • Plugin Changes
  • SQLRules Changes
  • Pydantic Changes
  • SQLAlchemy Changes
  • Cache Invalidation API
  • Automatic Invalidation
  • Cache Namespaces
  • Thread Safety
  • Async Safety
  • Cache Stampede
  • Negative Caching
  • Sensitive Data
  • Query Results Must Never Be Cached
  • Accepted Model Caching
  • Rejection Caching
  • SQLAlchemy Session Safety
  • Cache Diagnostics
  • Cache Statistics
  • Cache Failures
  • Determinism
  • Performance Tradeoffs
  • Development Mode
  • Testing Mode
  • Persistent Caching
  • Distributed Caching
  • Cache Plugin Interface
  • Default Cache Configuration
  • Cache Key Example
  • Object Identity vs Structural Identity
  • Execution ID
  • Bound Parameters
  • Partial Validation
  • Strictness
  • Redaction and Retention
  • Streaming
  • Sync and Async
  • Result Shape Changes
  • Cache Conformance Tests
  • Testing Requirements
  • MVP Scope
  • Recommended API Examples
  • Design Principles
  • INTERNAL_API.md
  • RowGuard Internal API
  • Design Goals
  • Package Layout
  • Public API Boundary
  • QueryRequest
  • Planner
  • Planning Stages
  • ExecutionPlan
  • Plan Immutability
  • ExecutionState
  • Sync Execution Engine
  • Async Execution Engine
  • Execution Contexts
  • Streaming Engine
  • Resource Management
  • Row Adapter Protocol
  • AdapterPlan
  • Validator Protocol
  • ValidationPlan
  • ValidationResult
  • Rejection Policy Protocol
  • RejectionDecision
  • RejectionContext
  • RejectedRow
  • SQLRules Bridge
  • CompiledRules
  • PushdownPlan
  • Statement Builder
  • Source Resolver
  • Statistics
  • Diagnostics Collector
  • Diagnostic Factory
  • Result Assembler
  • QueryResult
  • StreamResult
  • Configuration Objects
  • Configuration Validation
  • Registries
  • RowGuard Client
  • Dependency Injection
  • Error Boundaries
  • Internal Assertions
  • Caching
  • Concurrency
  • Sync and Async Code Sharing
  • Buffered and Streaming Code Sharing
  • Per-Row Processor
  • Plugin Boundaries
  • Internal vs Public Modules
  • Versioning Policy
  • Testing Strategy
  • Performance Requirements
  • Security Requirements
  • MVP Internal Components
  • Design Principles
  • DESIGN_DECISIONS.md
  • RowGuard Design Decisions
  • Decision 1: RowGuard Is a Validation-First Query Layer
  • Decision 2: SQLAlchemy Remains the SQL Foundation
  • Decision 3: Pydantic Is the Validation Authority
  • Decision 4: SQLRules Is a Separate Dependency
  • Decision 5: SQL Pushdown Is an Optimization, Not Proof
  • Decision 6: Full Validation Is the Default
  • Decision 7: Projection Models Are Preferred Over Dynamic Partial Validation
  • Decision 8: Mapping-Based Validation Is the Default
  • Decision 9: Row Adaptation Changes Structure, Not Meaning
  • Decision 10: Rejected Rows Are First-Class Results
  • Decision 11: Rejection Policy Is Explicit
  • Decision 12: raise Is the Default Policy
  • Decision 13: Rejection Policies Use Strategy Objects Internally
  • Decision 14: Callbacks Are Observable and Synchronous by Default
  • Decision 15: Quarantine Is a Dedicated Abstraction
  • Decision 16: Source and Quarantine Transactions Are Separate by Default
  • Decision 17: Planning and Execution Are Separate Phases
  • Decision 18: Execution Plans Are Immutable
  • Decision 19: Public APIs Stay Small
  • Decision 20: Buffered and Streaming Results Are Different Types
  • Decision 21: Sync and Async Share the Same Core Pipeline
  • Decision 22: No Implicit ORM Relationship Traversal
  • Decision 23: Explicit Projections Are Preferred for ORM Reads
  • Decision 24: SQLModel Is Complementary, Not a Competitor
  • Decision 25: Separate Persistence and Read Models Are Recommended
  • Decision 26: Raw SQL Is Supported but Never Rewritten
  • Decision 27: Reflection Is Delegated to SQLAlchemy
  • Decision 28: Authorization Filters Are Not Validation Rules
  • Decision 29: Diagnostics Are Structured and Stable
  • Decision 30: Diagnostics Never Change Behavior
  • Decision 31: Sensitive Values Are Not Emitted by Default
  • Decision 32: Missing and Null Remain Distinct
  • Decision 33: Ambiguity Fails by Default
  • Decision 34: Exactness Is Preferred Over Aggressive Pushdown
  • Decision 35: Query Result Objects Are Immutable
  • Decision 36: Type Support Is Broader Than Pushdown Support
  • Decision 37: Strict Validation Is Explicit
  • Decision 38: Repair Is Separate from Validation
  • Decision 39: RowGuard Does Not Write Back Automatically
  • Decision 40: Internal APIs Are Flexible; Public Protocols Are Deliberate
  • Open Questions
  • Decision Review Process
  • Summary
  • DIALECT_SUPPORT.md
  • RowGuard Dialect Support
  • Core Principle
  • Goals
  • Non-Goals
  • Support Levels
  • Initial Dialect Targets
  • Driver Matrix
  • Portable Core Features
  • Portable SQLRules Constraints
  • Dialect-Specific SQLRules Extensions
  • RowGuard Dialect Plugins
  • Capability Model
  • Capability Detection
  • User Overrides
  • SQLite
  • SQLite In-Memory Databases
  • SQLite Type Behavior
  • SQLite Streaming
  • PostgreSQL
  • PostgreSQL JSON
  • PostgreSQL Arrays
  • PostgreSQL Enums
  • PostgreSQL Timezones
  • MySQL and MariaDB
  • MySQL SQL Modes
  • MySQL Collations
  • SQL Server
  • SQL Server UUID Values
  • SQL Server Date/Time Types
  • Oracle
  • Oracle Empty String Semantics
  • DuckDB
  • Other SQLAlchemy Dialects
  • Cloud and Warehouse Dialects
  • Type Differences Across Dialects
  • Driver-Specific Row Adapters
  • String Length Semantics
  • Collation and Case Sensitivity
  • Null Semantics
  • Numeric Semantics
  • Date and Time Semantics
  • Enum Semantics
  • JSON Semantics
  • Regular Expressions
  • Streaming Differences
  • Async Differences
  • Reflection Differences
  • Raw SQL Differences
  • Transaction Differences
  • Quarantine Dialect Considerations
  • Dialect Diagnostics
  • Dialect Profile
  • Strict Dialect Mode
  • Fallback Behavior
  • Version-Specific Features
  • Optional Dependencies
  • Plugin Registration
  • Compatibility Validation
  • Error Hierarchy
  • Testing Strategy
  • Containerized Test Matrix
  • Golden Behavior Tests
  • Dialect Documentation Requirements
  • MVP Scope
  • Recommended Configuration Examples
  • Design Principles
  • PYDANTIC.md
  • RowGuard Pydantic Integration
  • Architectural Position
  • Goals
  • Non-Goals
  • Supported Model Types
  • Primary Validation API
  • Mapping-Based Validation
  • Attribute-Based Validation
  • Model Configuration
  • Strictness
  • Coercion
  • Field Aliases
  • Validation Aliases
  • Alias Choices and Paths
  • Extra Fields
  • Missing Fields
  • Defaults
  • Null Values
  • Field Validators
  • Model Validators
  • Before and Wrap Validators
  • Nested Models
  • Lists and Collections
  • Enums
  • Date, Time, and Datetime
  • Decimal and Numeric Values
  • UUID and Specialized Types
  • Arbitrary Types
  • RootModel
  • Generic Models
  • Discriminated Unions
  • Validation Context
  • Context and Caching
  • Revalidation of Existing Models
  • Validation Result
  • Validation Errors
  • Error Serialization
  • Privacy and Redaction
  • Rejection Handling
  • Raise Policy
  • Validation Thresholds
  • Repair Workflows
  • SQLRules Relationship
  • Schema Introspection
  • Projection Planning
  • Model Validators and Projection Risks
  • Serialization Is Separate
  • Computed Fields
  • Private Attributes
  • Frozen Models
  • Dataclasses and TypeAdapter
  • Validator Adapter Interface
  • Validator Construction
  • Thread Safety
  • Async Behavior
  • Streaming Behavior
  • Performance
  • Statistics
  • Diagnostics
  • Error Hierarchy
  • Custom Validator Exceptions
  • Determinism
  • Side Effects
  • Version Compatibility
  • Pydantic v1
  • Testing Requirements
  • MVP Scope
  • Recommended Public Examples
  • Design Principles
  • TYPE_SUPPORT.md
  • RowGuard Validation Type Support
  • Scope
  • Type Support Model
  • Core Principle: No Hidden Semantic Coercion
  • Compatibility Targets
  • Scalar Type Matrix
  • Boolean Values
  • Integer Values
  • Floating-Point Values
  • Decimal Values
  • String Values
  • Fixed-Width Character Data
  • Binary Values
  • UUID Values
  • Date Values
  • Time Values
  • Datetime Values
  • Timedelta and Interval Values
  • Optional and Nullable Fields
  • Missing vs Null
  • Literal Types
  • Enum Types
  • Union Types
  • Discriminated Unions
  • Lists
  • Tuples
  • Sets and Frozen Sets
  • Dictionaries and Mappings
  • Nested Models
  • Recursive Models
  • JSON Values
  • JSON Strings
  • Database Arrays
  • Database Range Types
  • Geospatial Types
  • Network Types
  • Path and File Types
  • Secret Types
  • Constrained and Annotated Types
  • Custom Pydantic Types
  • Arbitrary Types
  • ORM Entity Types
  • SQLModel Types
  • Root Models
  • TypeAdapter Targets
  • ORM Attribute Extraction Types
  • Composite Types
  • Large Objects
  • Driver-Specific Types
  • Unknown Types
  • Type Mismatches
  • Strict Storage Auditing
  • Type Support vs SQL Pushdown
  • Type Support Classification
  • Validation Type Matrix
  • Row Adapter Responsibilities
  • Error Handling
  • Error Redaction
  • Serialization Considerations
  • Performance Considerations
  • Async Considerations
  • Testing Requirements
  • MVP Scope
  • Recommended Public Examples
  • Design Principles
  • VALIDATION_ERRORS.md
  • RowGuard Validation Errors
  • Core Principle
  • Position in the Pipeline
  • Error Categories
  • Public Error Hierarchy
  • RowValidationError
  • RejectedRow Error Payload
  • Preserving Pydantic Errors
  • Error Locations
  • Error Codes
  • Error Messages
  • Model-Level Errors
  • Multiple Errors per Row
  • Source Identity
  • Row Index
  • Statement Context
  • Redaction
  • Field-Level Redaction
  • Raw Row Retention
  • Raise Policy
  • Collect Policy
  • Skip Policy
  • Callback Policy
  • Quarantine Policy
  • Logging
  • Error Aggregation
  • Validation Error Statistics
  • Rejection Thresholds
  • Unexpected Validator Exceptions
  • Adaptation Errors vs Validation Errors
  • Missing Fields
  • Extra Fields
  • Nested Errors
  • Union Errors
  • Contextual Validation Errors
  • Error Serialization
  • JSON Serialization
  • Exception String Representation
  • Equality and Testing
  • Diagnostics
  • Observability
  • Privacy and Compliance
  • Streaming Errors
  • Async Errors
  • Repair Integration
  • API Examples
  • Error Invariants
  • Testing Requirements
  • MVP Scope
  • Design Principles
  • PARTIAL_VALIDATION.md
  • RowGuard Partial Validation
  • Philosophy
  • Motivation
  • Explicit API
  • What Partial Validation Means
  • Recommended Pattern
  • Relationship to SQLRules
  • Missing Fields
  • Statistics
  • Error Reporting
  • Performance
  • Security
  • Testing
  • MVP Scope
  • Design Principles
  • REJECTION_POLICIES.md
  • RowGuard Rejection Policies
  • Core Principle
  • Built-in Policies
  • Policy Comparison
  • Thresholds
  • Retry and Repair
  • Streaming
  • Async
  • Diagnostics
  • Security
  • Testing
  • MVP Scope
  • Design Principles
  • REJECTION_HANDLING.md
  • RowGuard Rejection Handling
  • Philosophy
  • Pipeline Position
  • Rejection Policies
  • RejectedRow
  • Classification
  • Reject Handler Interface
  • Reject Decision
  • Reject Context
  • Handler Failures
  • Ordering
  • Statistics
  • Diagnostics
  • Security
  • Streaming
  • Async
  • Plugin Support
  • Error Hierarchy
  • Testing Requirements
  • MVP Scope
  • Design Principles
  • DIAGNOSTICS.md
  • RowGuard Rejection Diagnostics
  • Design Principles
  • Lifecycle
  • Diagnostic Event
  • Standard Diagnostic Codes
  • Severity
  • Metrics
  • Logging
  • Tracing
  • QueryResult Integration
  • Streaming
  • Async
  • Privacy
  • Testing
  • MVP Scope
  • Design Principles

Integrations (shipped)

  • CORE.md
  • RowGuard SQLAlchemy Core Integration
  • Goals
  • Non-Goals
  • Architectural Position
  • Supported Core Inputs
  • Table-Based Queries
  • Existing Select Statements
  • Statement Validation
  • Column Projection
  • Field-to-Column Mapping
  • Column Labels
  • Aliases
  • Subqueries
  • Common Table Expressions
  • Joins
  • Outer Joins
  • Compound Selects
  • Aggregates
  • Window Functions
  • Textual SQL
  • Execution Contexts
  • Transaction Boundaries
  • Execution Options
  • Bound Parameters
  • Result Consumption
  • Mapping Results
  • Scalar Results
  • Duplicate Result Keys
  • Pydantic Validation
  • SQLRules Pushdown
  • Additional Filters
  • Ordering
  • Limit and Offset
  • Locking Clauses
  • Server-Side Cursors and Streaming
  • Reflection
  • Dialects
  • Errors
  • Diagnostics
  • Performance
  • Security
  • Testing Requirements
  • MVP Scope
  • Recommended Public Examples
  • Design Principles
  • ORM.md
  • RowGuard SQLAlchemy ORM Integration
  • Core Distinction
  • Goals
  • Non-Goals
  • Architectural Position
  • Supported ORM Inputs
  • Querying a Mapped Class
  • Existing ORM Statements
  • Entity Validation Strategy
  • from_attributes Support
  • Selected Columns vs Full Entities
  • Identity Map
  • Pending Changes and Autoflush
  • Expired Attributes
  • Lazy-Loaded Relationships
  • Eager Loading
  • Relationship Projections
  • Aliased Classes
  • ORM Joins
  • Outer Joins
  • Polymorphic Mappings
  • Hybrid Properties
  • Column Properties
  • Synonyms and Descriptors
  • Deferred Columns
  • SQLRules Pushdown
  • Field Mapping
  • Result Shapes
  • Session Integration
  • AsyncSession Integration
  • Streaming ORM Results
  • Validation Target
  • Rejected Rows
  • Identity Metadata
  • Rejection Callbacks
  • Transaction Semantics
  • ORM Events
  • Mapper Introspection
  • Pydantic Aliases
  • Extra Attributes
  • Missing Attributes
  • Performance
  • Diagnostics
  • Errors
  • Security and Correctness
  • Testing Requirements
  • MVP Scope
  • Recommended Usage Patterns
  • Design Principles
  • SQLMODEL.md
  • RowGuard SQLModel Integration
  • Current Ecosystem Position
  • The Core Difference
  • Why Read-Time Validation Matters
  • Relationship to Pydantic Validation
  • Recommended Model Separation
  • Using a SQLModel Data Model as the Read Contract
  • Using the Table Model as the Read Contract
  • Integration with SQLModel Session
  • Existing SQLModel Select Statements
  • Preferred Query Shape: Explicit Projection
  • Entity-Based Validation
  • SQLModel Instances Are Not Automatically Trusted
  • SQLRules Pushdown with SQLModel
  • Separate Pushdown and Adaptation Maps
  • Relationships
  • Lazy Loading
  • Response Models vs RowGuard
  • Multiple SQLModel Classes
  • Read Contracts Can Be Stricter Than Table Models
  • Read Contracts Can Be Narrower Than Table Models
  • Cross-Field and Model Validators
  • Rejection Handling
  • Raw SQLModel Entity Retention
  • Repair and Write-Back
  • Session and Transaction Behavior
  • Autoflush
  • Identity Map Considerations
  • Async SQLModel
  • Streaming SQLModel Queries
  • SQLModel session.exec() Compatibility
  • Direct Pydantic Revalidation
  • API Examples
  • Error Model
  • Diagnostics
  • Performance Guidance
  • Security and Correctness
  • Testing Requirements
  • MVP Scope
  • What RowGuard Must Never Claim
  • Recommended Positioning
  • Design Principles
  • WHY_NOT_SQLMODEL.md
  • Why RowGuard Is Not SQLModel
  • Different Responsibilities
  • The Long-Standing Gap
  • SQLModel Already Validates…
  • Query Validation vs Persistence Validation
  • Why Not Just Call model_validate() Yourself?
  • SQLRules + RowGuard
  • Why Not Put This Into SQLModel?
  • Complementary Example
  • What RowGuard Does Not Replace
  • Choosing Between Them
  • Design Principles

Future / design (not shipped)

  • REFLECTION.md
  • RowGuard Reflection
  • Goals
  • Architecture
  • Basic Usage
  • Supported Objects
  • Column Mapping
  • SQLRules Integration
  • Reflection Caching
  • Dynamic Schemas
  • Error Handling
  • Diagnostics
  • Performance
  • Security
  • Testing
  • MVP Scope
  • Design Principles
  • RAW_SQL.md
  • RowGuard Raw SQL Integration
  • Design Philosophy
  • Architecture
  • Supported APIs
  • Result Shape
  • Parameter Binding
  • SQLRules Integration
  • Streaming
  • Rejection Handling
  • Diagnostics
  • Security
  • Error Handling
  • Testing
  • MVP Scope
  • Design Principles
  • PLUGIN_SYSTEM.md
  • RowGuard Plugin System
  • Core Principle
  • Goals
  • Non-Goals
  • Plugin Categories
  • Architecture
  • Registration Model
  • Why Explicit Registration
  • Registry Design
  • Conflict Resolution
  • Plugin Names
  • Plugin Metadata
  • Plugin API Version
  • Capability Declarations
  • Row Adapter Plugins
  • Adapter Factory
  • Source Resolver Plugins
  • Resolver Ambiguity
  • Rejection Policy Plugins
  • Async Rejection Policies
  • Callback Plugins
  • Quarantine Provider Plugins
  • Quarantine Provider Security Contract
  • Diagnostic Exporter Plugins
  • Exporter Failure Policy
  • Result Exporter Plugins
  • Streaming Result Exporters
  • Pushdown Policy Plugins
  • Execution Observer Plugins
  • Plugin Lifecycle
  • Lifecycle Ownership
  • Stateful Plugins
  • Stateless Plugins
  • Plugin Configuration
  • Configuration Validation
  • Plugin Factories
  • Dependency Injection
  • Plugin Dependencies
  • Plugin-to-Plugin Dependencies
  • Entry Point Discovery
  • Why Discovery Is Not Default
  • Plugin Selection
  • Plugin Context Objects
  • Session and Connection Access
  • Plugin Failure Boundaries
  • Plugin Failure Policies
  • Validation Guarantees
  • Unsafe Plugins
  • Determinism
  • Side Effects
  • Ordering
  • Plugin Composition
  • Security Review
  • Privacy Contract
  • Plugin Diagnostics
  • Plugin Inventory
  • Compatibility Checks
  • Thread Safety
  • Async Safety
  • Performance
  • Plugin Benchmarking
  • Conformance Test Suite
  • Adapter Conformance Requirements
  • Rejection Policy Conformance Requirements
  • Quarantine Provider Conformance Requirements
  • Diagnostic Exporter Conformance Requirements
  • Public Plugin Package Naming
  • Official vs Community Plugins
  • Built-in Plugins
  • Plugin Configuration Serialization
  • Reproducibility
  • Dependency Isolation
  • Deprecation
  • Error Hierarchy
  • Testing Requirements
  • MVP Scope
  • Recommended Usage Examples
  • Design Principles

Rejection design notes (shipped 0.6)

  • CALLBACKS.md
  • RowGuard Rejection Callbacks
  • Core Principle
  • Goals
  • Non-Goals
  • Callback Interface
  • RejectedRow Input
  • CallbackContext
  • Callback Decisions
  • Default Behavior
  • Public API
  • Callback Ordering
  • Callback Timing
  • Buffered Execution
  • Streaming Execution
  • Async Callbacks
  • Blocking Work
  • Callback Failures
  • CallbackError
  • Original Rejection Preservation
  • Transactions
  • Session Access
  • Mutation
  • Repair Callbacks
  • Retention Decisions
  • Sampling
  • Batching
  • Idempotency
  • Rejection Fingerprints
  • Privacy and Redaction
  • Logging Callbacks
  • Metrics Callbacks
  • Notification Callbacks
  • Quarantine Callbacks
  • Callback Composition
  • Decision Precedence
  • Diagnostics
  • Statistics
  • Performance
  • Concurrency
  • Cancellation
  • Callback Registration
  • Plugin Integration
  • Error Hierarchy
  • Security
  • Testing Requirements
  • MVP Scope
  • Recommended Public Examples
  • Design Principles
  • QUARANTINE.md
  • RowGuard Quarantine
  • Core Principle
  • Goals
  • Non-Goals
  • Why Quarantine Is Separate from Collect
  • Public API
  • Quarantine Provider Protocol
  • QuarantineRecord
  • Schema Versioning
  • Error Representation
  • Rejection Types
  • Source Identity
  • Quarantine Context
  • QuarantineReceipt
  • Retention Modes
  • Redaction
  • Field-Level Redaction
  • Hashing Sensitive Values
  • Provider Types
  • SQL Table Provider
  • File Providers
  • Message Queue Providers
  • Transaction Strategies
  • Provider Failure Policy
  • Retry Policy
  • Idempotency
  • Rejection Fingerprints
  • Batching
  • Batch Failure
  • Streaming
  • Async Quarantine
  • Cancellation
  • Resource Management
  • Background Delivery
  • Replay
  • Repair
  • Quarantine Record States
  • Observability
  • Diagnostics
  • Error Hierarchy
  • Serialization
  • Unsupported Values
  • Metadata
  • Model Versioning
  • Source Schema Version
  • Access Control
  • Data Retention
  • Provider Capabilities
  • Provider Registration
  • Testing Providers
  • Testing Requirements
  • MVP Scope
  • Recommended Public Examples
  • Design Principles

Project

  • Supported vs planned
  • Changelog
  • ROADMAP.md
  • RowGuard Roadmap
  • Design Principles
  • 0.1.0 — Validation-First Core (shipped)
  • 0.2.0 — Execution Planning (shipped)
  • 0.3.0 — Streaming Engine (shipped)
  • 0.4.0 — Async Engine (shipped)
  • 0.5.0 — ORM and SQLModel Integration (shipped)
  • 0.6.0 — Rejection Platform (shipped)
  • 0.7.0 — Plugin System
  • 0.8.0 — Dialects, Reflection, and Raw SQL
  • 0.9.0 — Stabilization and Release Candidate
  • 1.0.0 — Stable
  • Post-1.0
  • Long-Term Ecosystem
  • Security Policy
  • Releasing
  • Contributor Covenant Code of Conduct
  • CONTRIBUTING.md
  • Contributing to RowGuard
  • Project Mission
  • Ways to Contribute
  • Before Starting
  • Development Setup
  • Supported Tooling
  • Common Commands
  • Architecture First
  • Design Boundaries
  • Coding Standards
  • Type Checking
  • Public API Changes
  • Error Design
  • Diagnostics
  • Security
  • Testing Requirements
  • Test Style
  • Database Tests
  • Async Contributions
  • Streaming Contributions
  • Performance Contributions
  • Plugin Contributions
  • Dialect Contributions
  • Documentation Style
  • Commit Style
  • Pull Requests
  • Pull Request Checklist
  • Review Priorities
  • Backward Compatibility
  • Deprecation
  • Dependency Policy
  • Release Notes
  • Issue Reports
  • Feature Requests
  • Security Reports
  • Code of Conduct
  • Good First Contributions
  • Maintainer Responsibilities
  • Design Principles
  • TESTING.md
  • RowGuard Testing Strategy
  • Testing Principles
  • Test Layers
  • Test Matrix
  • Model Fixtures
  • Database Fixtures
  • SQLRules Integration Tests
  • Row Adapter Tests
  • Validation Engine Tests
  • Rejection Policy Tests
  • Streaming Tests
  • Async Tests
  • Core Integration Tests
  • ORM Tests
  • SQLModel Tests
  • Raw SQL Tests
  • Reflection Tests
  • Cache Tests
  • Plugin Tests
  • Diagnostics Tests
  • Statistics Tests
  • Security Tests
  • Property-Based Testing
  • Golden and Snapshot Tests
  • Dialect Test Matrix
  • Test Isolation
  • Temporary Resources
  • Error Injection
  • Coverage
  • Type Checking
  • Linting and Formatting
  • Documentation Tests
  • Compatibility Tests
  • CI Workflow
  • Flaky Tests
  • Test Naming
  • Test Directory Layout
  • MVP Testing Requirements
  • Release Gates
  • Design Principles
  • BENCHMARKS.md
  • RowGuard Benchmarking
  • Benchmark Principles
  • Baselines
  • Benchmark Categories
  • Representative Models
  • Representative Data Quality
  • Representative Row Counts
  • Database Backends
  • Driver Versions
  • Metrics
  • Timing
  • Statistical Reporting
  • Warm-Up
  • Planning Benchmarks
  • Pushdown Benchmarks
  • Projection Benchmarks
  • Adapter Benchmarks
  • Validation Benchmarks
  • Rejection Benchmarks
  • Quarantine Benchmarks
  • Streaming Memory Benchmark
  • Async Benchmarks
  • Cache Benchmarks
  • Diagnostics Benchmarks
  • Plugin Overhead
  • Benchmark Dataset Generation
  • Correctness During Benchmarks
  • Tooling
  • Benchmark Directory
  • CI Strategy
  • Regression Policy
  • Benchmark History
  • Performance Budgets
  • Benchmark Reporting
  • User-Facing Benchmarks
  • Profiling Workflow
  • MVP Benchmark Requirements
  • Design Principles
  • MILESTONES.md
  • RowGuard Milestones
  • Release Philosophy
  • 0.1.0 — Validation-First Core
  • 0.2.0 — Execution Planning
  • 0.3.0 — Streaming Engine (shipped)
  • 0.4.0 — Async Engine
  • 0.5.0 — ORM and SQLModel Integration
  • 0.6.0 — Rejection Platform
  • 0.7.0 — Plugin System
  • 0.8.0 — Dialects, Reflection, and Raw SQL
  • 0.9.0 — Stabilization and Release Candidate
  • 1.0.0 — Stable Release
  • Post-1.0 Roadmap
  • Cross-Cutting Workstreams
  • Milestone Dependencies
  • Scope Control
  • Release Checklist
  • Design Principles
  • Cursor Build Prompt
Back to top
Copyright © 2026, RowGuard Contributors
Made with Sphinx and @pradyunsg's Furo
◆ GitHub PyPI