bc-code-intelligence-mcp 1.1.1

package/embedded-knowledge/domains/sam-coder/al-object-navigation-shortcuts.md

@@ -0,0 +1,128 @@
+---
+title: "AL Object Navigation Shortcuts"
+domain: "sam-coder"
+difficulty: "intermediate"
+bc_versions: "14+"
+tags: ["navigation", "al-objects", "workspace", "symbol-search", "dependencies"]
+prerequisites: ["vs-code-al-shortcuts", "al-project-structure"]
+---
+
+# AL Object Navigation Shortcuts
+
+## Overview
+
+Efficient navigation between AL objects is crucial for understanding code relationships, debugging complex scenarios, and maintaining large AL projects. Master these navigation patterns to move fluidly through Business Central codebases.
+
+**Core Concept**: AL object navigation combines symbol search, dependency tracking, and workspace awareness for rapid code exploration.
+
+## Symbol-Based Navigation
+
+### Go-To Definition Patterns
+**F12** on any AL symbol provides immediate navigation:
+- **Object references**: Jump from usage to object definition
+- **Procedure calls**: Navigate to procedure implementation
+- **Variable declarations**: Find where variables are declared
+- **Field references**: Jump to table field definitions
+
+### Peek Definition Workflow
+**Alt+F12** opens inline preview without losing current context:
+- **Quick reference checking**: Verify procedure signatures without navigation
+- **Multi-object comparison**: Compare related objects side-by-side
+- **Context preservation**: Maintain current editing position while exploring
+
+### Reference Discovery
+**Shift+F12** reveals all usages of current symbol:
+- **Impact analysis**: Understand where objects/procedures are used
+- **Refactoring planning**: Identify all affected code before changes
+- **Documentation research**: Find usage examples across codebase
+
+## Workspace-Level Navigation
+
+### Global Symbol Search
+**Ctrl+T** enables rapid workspace-wide object discovery:
+- **Object name search**: Find tables, pages, codeunits by partial name
+- **Procedure location**: Locate specific procedures across all objects
+- **Fuzzy matching**: Use partial strings to find objects quickly
+
+### AL-Specific Object Navigation
+**Ctrl+Shift+P → "AL: Go!"** provides enhanced AL object search:
+- **Object type filtering**: Search within specific object types (tables, pages)
+- **Object ID navigation**: Jump directly to objects by ID number
+- **Extension awareness**: Navigate across multiple AL extensions
+
+### File-Level Symbol Navigation
+**Ctrl+Shift+O** shows current file's symbol outline:
+- **Procedure listing**: Quick access to all procedures in current object
+- **Variable declarations**: Jump to variable declaration sections
+- **Structured navigation**: Navigate by AL object structure (triggers, procedures)
+
+## Dependency Tracking
+
+### Cross-Object Relationships
+Understanding AL object dependencies through navigation:
+- **Table-Page relationships**: Navigate from table fields to related pages
+- **Codeunit dependencies**: Track procedure calls across codeunits
+- **Report-Dataset connections**: Follow data flow from datasets to layout
+
+### Extension Boundary Navigation
+Navigate between AL extensions and base application:
+- **Base application references**: Jump to standard BC objects from extensions
+- **Extension dependencies**: Navigate between dependent AL extensions
+- **Symbol resolution**: Understand which extension provides specific symbols
+
+## Advanced Navigation Techniques
+
+### Multi-Cursor Object Exploration
+Use **Ctrl+D** for simultaneous multi-object navigation:
+- **Pattern identification**: Select similar symbols across multiple objects
+- **Bulk navigation**: Navigate to multiple related definitions simultaneously
+- **Comparison workflows**: Compare similar patterns across objects
+
+### Breadcrumb Navigation
+Leverage VS Code breadcrumbs for AL object context:
+- **Object hierarchy**: Visual representation of current location in AL object
+- **Quick parent navigation**: Click breadcrumbs to navigate to parent scopes
+- **Context awareness**: Understand current position within complex AL objects
+
+### Search Integration with Navigation
+Combine **Ctrl+Shift+F** with navigation shortcuts:
+- **Usage pattern search**: Find specific AL patterns across workspace
+- **Cross-reference validation**: Verify object relationships through search
+- **Documentation discovery**: Find comments and documentation related to objects
+
+## Navigation Efficiency Patterns
+
+### Context-Preserving Exploration
+- **Tab management**: Use multiple tabs for related AL objects
+- **Split editor**: Compare related objects side-by-side
+- **Breadcrumb trails**: Maintain awareness of navigation history
+
+### Rapid Discovery Workflows
+- **Symbol-first navigation**: Start with symbol search, then explore context
+- **Reference-driven exploration**: Use "Find All References" to understand object usage
+- **Definition-to-usage flow**: Navigate from definitions to all usage contexts
+
+### Team Navigation Standards
+- **Consistent naming patterns**: Enable predictable object discovery
+- **Documentation links**: Include navigation hints in object comments
+- **Dependency documentation**: Maintain clear dependency maps for complex solutions
+
+## Common Navigation Scenarios
+
+### Debugging Complex Flows
+Navigate efficiently through call stacks and data flows:
+1. **Start at error location** using diagnostic navigation
+2. **Trace back through call stack** using Go-to-Definition
+3. **Identify data sources** through table/field navigation
+4. **Verify related objects** using Find-All-References
+
+### Code Review Navigation
+Systematic exploration of code changes:
+1. **Start with modified objects** in source control view
+2. **Navigate to related objects** using dependency tracking
+3. **Verify impact scope** using reference discovery
+4. **Check integration points** through cross-object navigation
+
+*Navigation practice exercises: samples/al-navigation-practice.md*
+*Workspace search patterns: sam-coder-index.json#workspace-navigation*
+*AL object relationships: code-design-index.json#object-dependencies*

package/embedded-knowledge/domains/sam-coder/al-readability-optimization.md

@@ -0,0 +1,75 @@
+---
+title: "AL Readability Optimization"
+domain: "sam-coder"
+difficulty: "advanced"
+bc_versions: "14+"
+tags: ["readability", "optimization", "code-quality"]
+type: "improvement-pattern"
+category: "code-quality"
+pattern_type: "good"
+severity: "medium"
+impact_level: "medium"
+improvement_suggestion: "Optimize AL code readability through strategic formatting and organization techniques"
+implementation_steps: ["analyze-readability-factors", "apply-optimization-techniques", "validate-improvement"]
+validation_criteria: ["improved-code-readability", "reduced-cognitive-load"]
+technical_areas: ["al-code"]
+---
+
+# AL Readability Optimization
+
+## Overview
+
+Readability optimization in AL code involves strategic application of formatting, naming, and organizational techniques to minimize cognitive load and maximize code comprehension. Optimized readability directly impacts development productivity and code maintainability.
+
+**Key Principle**: Structure AL code to minimize cognitive effort required for understanding logic, flow, and purpose.
+
+## Strategic Framework
+
+### Cognitive Load Reduction
+- **Visual Hierarchy**: Clear formatting that reveals code structure immediately
+- **Logical Organization**: Code arrangement that follows natural reading patterns
+- **Context Clarity**: Sufficient information for understanding without external references
+- **Complexity Management**: Techniques for handling complex logic readably
+
+### Comprehension Enhancement
+Optimize code layout and organization to support quick understanding of business logic, control flow, and data operations within Business Central context.
+
+## Architecture Focus
+
+### Readability Factors
+- **Visual Structure**: Indentation, spacing, and alignment for clarity
+- **Naming Clarity**: Descriptive identifiers that convey purpose
+- **Logical Flow**: Code organization that matches business process flow
+- **Documentation Integration**: Comments and structure that enhance understanding
+
+### Optimization Techniques
+Apply systematic approaches to improve code readability including strategic formatting, logical organization, and clarity enhancement patterns.
+
+## Best Practices
+
+### Structure Optimization
+- **Logical code grouping** that reflects business operations
+- **Clear visual hierarchy** through consistent formatting
+- **Strategic white space** to separate conceptual sections
+- **Meaningful naming** that conveys purpose and context
+- **Progressive complexity** from simple to complex operations
+
+### Flow Enhancement
+Organize code to follow natural reading patterns, group related operations logically, and use formatting to guide reader attention to important elements.
+
+### Clarity Techniques
+Use consistent patterns for similar operations, eliminate unnecessary complexity, and structure code to support quick mental model building.
+
+## Anti-Patterns
+
+### Avoid These Approaches
+- **Dense code blocks** without logical separation
+- **Unclear naming** requiring mental translation
+- **Random organization** without logical flow
+- **Inconsistent patterns** requiring constant style adaptation
+- **Unnecessary complexity** that obscures business logic
+
+Poor readability optimization increases development time, introduces errors, and makes code maintenance more difficult and expensive.
+
+*Related patterns: al-formatting-consistency-patterns.md, al-statement-per-line-rule.md*
+*Cross-references: See samples in other formatting topics for readability examples*

package/embedded-knowledge/domains/sam-coder/al-record-find-early-exit.md

@@ -0,0 +1,95 @@
+---
+title: "AL Record Find Early Exit"
+domain: "sam-coder"
+difficulty: "intermediate"
+bc_versions: "14+"
+tags: ["record-access", "performance", "early-exit", "database"]
+type: "improvement-pattern"
+category: "performance"
+pattern_type: "good"
+severity: "high"
+impact_level: "high"
+improvement_suggestion: "Implement early exit patterns for record Find operations to prevent unnecessary processing"
+implementation_steps: ["identify-record-operations", "apply-early-exit-patterns", "validate-performance"]
+validation_criteria: ["improved-performance", "reduced-database-load"]
+technical_areas: ["al-code", "database"]
+samples: "samples/al-record-find-early-exit.md"
+---
+
+# AL Record Find Early Exit
+
+## Overview
+
+Implementing early exit patterns for AL record Find operations prevents unnecessary database queries and subsequent processing when records don't exist. This fundamental performance optimization reduces database load and improves response times.
+
+**Key Principle**: Always check Find() results before proceeding with record-dependent operations to avoid processing non-existent data.
+
+## Strategic Framework
+
+### Standard Find Pattern
+```
+if Customer.Find() then begin
+    // Process found record
+end else begin
+    // Handle not found case
+end;
+```
+
+### Early Exit Implementation
+Replace nested if-else with guard clause pattern:
+```
+if not Customer.Find() then
+    exit;
+
+// Process found record directly
+```
+
+### Performance Impact
+Early exits eliminate unnecessary code execution when records don't exist, reducing CPU usage and improving user experience in data-sparse scenarios.
+
+## Architecture Focus
+
+### Database Efficiency
+**Query Optimization**: Early exits prevent cascading database operations when initial record retrieval fails
+**Connection Management**: Reduced database round trips improve connection pool utilization
+**Memory Management**: Avoiding record processing when data doesn't exist conserves memory allocation
+**Transaction Scope**: Early exits keep transaction scope minimal for non-existent record scenarios
+
+### Error Prevention
+Early exit patterns prevent null reference errors and invalid data processing that can occur when assuming record existence without verification.
+
+### Code Flow Clarity
+Guard clause implementation creates clear separation between record existence validation and business logic processing.
+
+## Best Practices
+
+### Implementation Patterns
+- **Guard Clauses First**: Check record existence at procedure start before main logic
+- **Consistent Error Handling**: Standardize response for non-existent records across application
+- **Logging Considerations**: Log appropriate messages for record not found scenarios
+- **Return Value Strategy**: Design clear return patterns for procedures with early exits
+
+### Performance Optimization
+- **Filter Before Find**: Apply appropriate filters before Find() to reduce search scope
+- **Index Utilization**: Ensure Find operations use optimal indexes for best performance
+- **Batch Processing**: Consider FindSet() for multiple record processing scenarios
+- **Existence Checks**: Use IsEmpty() for existence verification without full record loading
+
+### Error Handling Integration
+- **Graceful Degradation**: Handle missing records without disrupting user workflow
+- **Clear Messaging**: Provide meaningful feedback when records cannot be found
+- **Recovery Options**: Offer alternative actions when primary records are unavailable
+- **Audit Trails**: Log record access attempts for troubleshooting and analysis
+
+## Anti-Patterns
+
+### Avoid These Approaches
+- **Assumed Existence**: Processing records without Find() verification
+- **Nested Processing**: Deep conditional nesting instead of early validation
+- **Ignored Return Values**: Not checking Find() boolean result before proceeding
+- **Cascading Failures**: Allowing record-not-found errors to propagate through system
+
+Failing to implement early exits in high-frequency operations creates cumulative performance degradation and unnecessary database load.
+
+*Related patterns: al-record-filtering.md, al-database-optimization.md*
+*Implementation examples: see samples/al-record-find-early-exit.md*

package/embedded-knowledge/domains/sam-coder/command-queue-pattern-al.md

@@ -0,0 +1,141 @@
+---
+title: "Command Queue Pattern in AL"
+domain: "sam-coder"
+difficulty: "intermediate"
+bc_versions: "14+"
+tags: ["command-queue", "async-processing", "message-patterns", "queue-management"]
+prerequisites: ["queue-basics", "command-pattern", "async-programming"]
+samples: "samples/command-queue-pattern.md"
+related_topics: ["task-scheduler-pattern-implementation", "event-bridge-pattern-al"]
+---
+
+# Command Queue Pattern in AL
+
+## Overview
+
+The Command Queue Pattern enables asynchronous command processing by queuing commands for later execution, providing system decoupling and improved responsiveness. This pattern is essential for handling operations that don't require immediate execution or that need to be processed in specific orders.
+
+**Key Benefit**: Enables asynchronous processing that improves system responsiveness while providing reliable command execution guarantees.
+
+## Core Queue Architecture
+
+### Command Encapsulation
+Design command objects that encapsulate all necessary information for execution, including parameters, context, and execution requirements.
+
+### Queue Management System
+Implement queue management that handles command storage, ordering, priority processing, and execution coordination.
+
+### Processing Engine Design
+Create processing engines that can reliably execute queued commands while handling errors, retries, and recovery scenarios.
+
+## Implementation Patterns
+
+### FIFO Queue Processing
+Implement first-in-first-out queue processing for scenarios where command execution order is critical for business logic correctness.
+
+### Priority Queue Handling
+Design priority-based queue processing that ensures high-priority commands receive expedited processing while maintaining overall queue progress.
+
+### Batch Processing Integration
+Integrate queue processing with batch processing capabilities to enable efficient handling of large command volumes.
+
+## Advanced Queue Features
+
+### Command Scheduling
+Implement scheduling capabilities that allow commands to be queued for future execution at specific times or after specific delays.
+
+### Command Dependencies
+Design dependency tracking that ensures prerequisite commands complete successfully before dependent commands execute.
+
+### Transaction Integration
+Integrate command processing with transaction management to ensure data consistency and enable rollback scenarios.
+
+## Error Handling and Reliability
+
+### Retry Mechanisms
+- Implement intelligent retry policies for failed command execution
+- Support different retry strategies based on error types and command characteristics
+- Provide exponential backoff to prevent system overload during error scenarios
+- Log retry attempts for debugging and monitoring purposes
+
+### Dead Letter Queues
+- Design dead letter queues for commands that cannot be processed successfully
+- Implement manual review and reprocessing capabilities for dead letter items
+- Provide analysis tools for understanding command failure patterns
+- Support command modification and requeuing after issue resolution
+
+## Performance Optimization
+
+### Queue Throughput
+Optimize queue processing algorithms to maximize command throughput while maintaining system stability and resource efficiency.
+
+### Memory Management
+Implement efficient memory management for queued commands to prevent memory exhaustion during high-volume processing.
+
+### Parallel Processing
+Design parallel processing capabilities for independent commands to improve overall system throughput and responsiveness.
+
+## Monitoring and Diagnostics
+
+### Queue Health Monitoring
+Implement comprehensive monitoring of queue health including length, processing rates, error rates, and performance metrics.
+
+### Command Execution Tracking
+Provide detailed tracking of command execution including timing, success rates, and failure analysis capabilities.
+
+### Performance Analytics
+Design analytics capabilities that can identify performance bottlenecks and optimization opportunities in queue processing.
+
+## Integration Strategies
+
+### Event-Driven Integration
+Integrate command queues with event-driven architectures to enable reactive command processing based on business events.
+
+### External System Integration
+Design integration patterns that enable command queue coordination with external systems and services.
+
+### API Integration
+Implement API patterns that allow external systems to submit commands to queues while maintaining security and validation requirements.
+
+## Security and Validation
+
+### Command Validation
+- Implement comprehensive validation for queued commands before execution
+- Validate user permissions and authorization for command execution
+- Support command sanitization to prevent security vulnerabilities
+- Audit command execution for compliance and security monitoring
+
+### Access Control
+- Control access to command queuing and management capabilities
+- Implement role-based access to different queue operations
+- Support secure command parameter handling for sensitive data
+- Provide audit trails for command queue operations
+
+## Best Practices
+
+### Design Principles
+- Design commands to be idempotent to support safe retry operations
+- Implement comprehensive logging for command execution and queue operations
+- Use dependency injection for command implementation flexibility
+- Keep command implementations focused and single-purpose
+
+### Operational Excellence
+- Provide clear documentation for command queue configuration and management
+- Implement automated testing for queue processing logic
+- Support queue processing simulation and testing capabilities
+- Maintain clear operational procedures for queue management
+
+## Common Pitfalls
+
+### Queue Overflow
+Avoid scenarios where command queues can grow unbounded, leading to memory exhaustion and system performance degradation.
+
+### Command Coupling
+Prevent tight coupling between command implementations that reduces system flexibility and maintenance.
+
+### Processing Bottlenecks
+Identify and prevent processing bottlenecks that can cause queue backups and system responsiveness issues.
+
+*Complete command queue implementation: samples/command-queue-pattern.md*
+*Task scheduling integration: task-scheduler-pattern-implementation.md*
+*Event-driven patterns: event-bridge-pattern-al.md*

package/embedded-knowledge/domains/sam-coder/deleteall-alternative-implementation.md

@@ -0,0 +1,91 @@
+---
+title: "DeleteAll Alternative Implementation"
+domain: "sam-coder"
+difficulty: "advanced"
+bc_versions: "14+"
+tags: ["deleteall", "alternatives", "implementation", "patterns"]
+samples: "samples/deleteall-alternative-implementation.md"
+---
+# DeleteAll Alternative Implementation
+
+## Overview
+
+While DeleteAll provides comprehensive business logic enforcement through OnDelete trigger execution, many scenarios require alternative approaches that prioritize performance, custom logic, or specific operational requirements.
+
+**Key Consideration**: Alternative implementations trade business logic automation for performance or flexibility - this trade-off must align with specific business requirements.
+
+**Common Scenarios for Alternatives**:
+- High-performance bulk operations where trigger execution creates unacceptable delays
+- Custom business logic requirements that extend beyond standard OnDelete trigger capabilities  
+- Integration scenarios requiring specialized error handling and recovery mechanisms
+- Complex data transformation operations during deletion processes
+
+## Strategic Implementation Approaches
+
+### Direct Database Operations
+
+**SQL DELETE Operations**: Maximum performance approach bypassing all BC business logic layer processing.
+
+**Use Case Scenarios**:
+- Simple cleanup operations on isolated tables without related data dependencies
+- System maintenance operations where business rule enforcement is unnecessary
+- Temporary data removal where audit trails and logging are not required
+- Performance-critical operations where trigger execution overhead is prohibitive
+
+**Risk Assessment**:
+- Data integrity violations possible if business logic requirements are misunderstood
+- Related table orphaned data creation if cleanup logic is inadequate
+- Compliance violation potential if audit trail requirements are not properly implemented
+- Future maintenance complexity increases with custom implementation scope
+
+### Custom Deletion Procedures
+
+**Controlled Business Logic Implementation**: Selective implementation of essential business logic with performance optimization.
+
+**Design Patterns**:
+- Extract critical OnDelete trigger logic into dedicated validation procedures
+- Implement batch processing patterns for large dataset operations with progress tracking
+- Design custom error handling and recovery mechanisms for specific operational scenarios
+- Create specialized audit and logging procedures tailored to deletion operation requirements
+
+**Performance Optimization Techniques**:
+- Batch record processing to reduce database round-trip overhead
+- Optimized transaction boundary management for improved throughput
+- Progress tracking and user communication for long-running operations
+- Parallel processing implementation where business logic constraints permit
+
+### Hybrid Approaches
+
+**Selective DeleteAll Usage**: Combining DeleteAll with alternative approaches based on operation characteristics.
+
+**Conditional Logic Implementation**:
+- Use DeleteAll for small datasets where performance impact is acceptable
+- Implement custom logic for large datasets requiring performance optimization
+- Apply different strategies based on table complexity and related data relationships
+- Design fallback mechanisms for error conditions and exceptional scenarios
+
+## Implementation Framework
+
+### Requirements Analysis
+- Catalog all OnDelete trigger logic and classify by criticality to business operations
+- Identify related table relationships and cascade operation requirements
+- Assess audit trail and compliance logging requirements for deletion operations
+- Define acceptable performance thresholds for different types of deletion operations
+
+### Architecture Design
+- Design modular deletion procedure architecture supporting multiple implementation strategies
+- Implement configuration-driven approach enabling runtime selection of deletion methods
+- Create standardized interfaces for deletion operations supporting consistent error handling
+- Plan integration with existing BC business logic and validation procedures
+
+## Anti-Patterns
+
+### Business Logic Neglect
+**Dangerous Oversimplification**: Implementing alternatives without proper business logic consideration. Bypassing essential validation logic creates data integrity risks and compliance violations.
+
+### Performance Assumption Errors
+**Premature Optimization**: Implementing complex alternatives without validating DeleteAll performance limitations. Thoroughly evaluate DeleteAll performance before committing to alternative implementation effort.
+
+### Incomplete Implementation
+**Partial Logic Implementation**: Creating alternatives that inadequately replace DeleteAll functionality. Ensure alternative solutions provide equivalent functionality where business requirements demand it.
+

package/embedded-knowledge/domains/sam-coder/deleteall-method-usage.md

@@ -0,0 +1,118 @@
+---
+title: "DeleteAll Method Usage"
+domain: "sam-coder"
+difficulty: "intermediate"
+bc_versions: "14+"
+tags: ["deleteall", "data-manipulation", "triggers"]
+prerequisites: ["table-basics", "record-management"]
+samples: "samples/deleteall-usage.md"
+---
+# DeleteAll Method Usage
+
+## Overview
+
+DeleteAll is a BC method that removes all records from a table or filtered set while executing OnDelete triggers for each record. Unlike direct SQL DELETE operations, DeleteAll maintains full BC business logic compliance by triggering all associated validations and cascading operations.
+
+**Key Characteristic**: Always executes OnDelete triggers - this is fundamental BC behavior that cannot be bypassed.
+
+**Primary Use Cases**:
+- Clearing temporary data with proper cleanup
+- Bulk deletions requiring business logic validation
+- Data maintenance operations preserving referential integrity
+- Cleanup operations in test scenarios
+
+**Critical Understanding**: DeleteAll is not a performance optimization - it's a business logic preservation tool that executes triggers for every deleted record.
+
+## Strategic Framework
+
+### When DeleteAll is Appropriate
+
+**Data Integrity Scenarios**:
+- Clearing temporary tables where related data must be cleaned up
+- Removing test data while maintaining proper audit trails
+- Bulk operations where business rules must be enforced
+- Scenarios requiring cascade delete operations
+
+**Business Logic Requirements**:
+- Operations requiring OnDelete trigger execution
+- Scenarios where related table updates are necessary
+- Situations demanding proper logging and audit trail maintenance
+- Cases where validation logic must run for each deletion
+
+### When DeleteAll is Inappropriate
+
+**Performance-Critical Operations**:
+- Large dataset deletions where triggers are unnecessary
+- Bulk cleanup operations on isolated data
+- System maintenance requiring maximum speed
+- Operations on tables without significant business logic
+
+**Alternative Consideration Points**:
+- Direct SQL operations for simple, non-validated deletions
+- Batch processing approaches for very large datasets
+- Specialized cleanup procedures for system maintenance
+- Custom deletion logic for complex business scenarios
+
+## Implementation Considerations
+
+### Trigger Execution Impact
+
+**Performance Implications**:
+- Each record deletion executes full OnDelete trigger logic
+- Related table updates and validations occur for every record
+- Memory usage scales with trigger complexity and related data volume
+- Network traffic increases with extensive related table operations
+
+**Business Logic Preservation**:
+- Maintains complete data integrity across all related tables
+- Ensures proper audit trail and logging execution
+- Preserves cascade delete operations and referential integrity
+- Executes all custom business validation logic
+
+### Error Handling Strategy
+
+**Validation Failures**:
+- Any OnDelete trigger failure stops the entire DeleteAll operation
+- Partial deletions can occur if errors happen mid-process
+- Transaction boundaries depend on implementation context
+- Error recovery requires understanding of deletion state
+
+**Recovery Patterns**:
+- Implement proper transaction management around DeleteAll calls
+- Design retry logic for recoverable validation failures
+- Plan for partial completion scenarios and cleanup procedures
+- Consider logging and monitoring for deletion operation tracking
+
+## Best Practices
+
+### Effective DeleteAll Usage
+
+**Preparation Steps**:
+- Verify that OnDelete triggers contain necessary business logic
+- Ensure related data can handle the deletion operations
+- Test deletion operations in controlled environments first
+- Implement proper error handling and recovery procedures
+
+**Execution Patterns**:
+- Use appropriate filters to limit deletion scope
+- Consider batch processing for very large datasets
+- Implement progress tracking for long-running operations
+- Plan for proper transaction boundaries and commit strategies
+
+### Monitoring and Validation
+- Monitor deletion progress and performance impact
+- Validate that expected business logic executes correctly
+- Verify related table cleanup occurs as designed
+- Validate data integrity across all affected tables
+
+## Anti-Patterns
+
+### Performance Misunderstanding
+**Incorrect Assumption**: Using DeleteAll for performance optimization. DeleteAll executes triggers, making it slower than direct SQL operations.
+
+### Trigger Logic Avoidance
+**Incorrect Pattern**: Attempting to bypass OnDelete triggers with DeleteAll. DeleteAll always executes OnDelete triggers - this cannot be disabled.
+
+### Insufficient Error Handling
+**Problematic Implementation**: Assuming DeleteAll operations always succeed. Implement comprehensive error handling and recovery procedures.
+