bc-code-intelligence-mcp 1.3.4 → 1.3.6

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

@@ -0,0 +1,117 @@
+# DeleteAll Alternative Implementation Patterns
+
+## Conditional DeleteAll vs Direct SQL
+```al
+procedure CleanupTempData(TableID: Integer; BusinessLogicRequired: Boolean)
+var
+    TempDataBuffer: Record "Temp Data Buffer";
+begin
+    TempDataBuffer.SetRange("Source Table ID", TableID);
+    
+    if BusinessLogicRequired then begin
+        // Use DeleteAll when OnDelete triggers must execute
+        TempDataBuffer.DeleteAll(true);
+    end else begin
+        // Use direct deletion for simple cleanup
+        if TempDataBuffer.FindSet() then
+            TempDataBuffer.DeleteAll(false);
+    end;
+end;
+```
+
+## Batch Processing with Size Limits
+```al
+procedure ProcessLargeDataDeletion(var RecordToDelete: Record "Large Data Table")
+var
+    BatchSize: Integer;
+    ProcessedCount: Integer;
+begin
+    BatchSize := 1000;
+    ProcessedCount := 0;
+    
+    RecordToDelete.SetCurrentKey("Created Date Time");
+    if RecordToDelete.FindSet() then
+        repeat
+            RecordToDelete.Delete(true); // Individual delete with trigger execution
+            ProcessedCount += 1;
+            
+            // Commit periodically to avoid large transactions
+            if ProcessedCount mod BatchSize = 0 then begin
+                Commit();
+                Message('Processed %1 records...', ProcessedCount);
+            end;
+        until RecordToDelete.Next() = 0;
+end;
+```
+
+## Hybrid Approach with Validation
+```al
+procedure SmartDeleteWithValidation(var OrderLine: Record "Sales Line")
+var
+    SalesHeader: Record "Sales Header";
+    HasComplexRelationships: Boolean;
+begin
+    // Analyze data complexity before choosing deletion method
+    HasComplexRelationships := CheckForReservations(OrderLine) or 
+                              CheckForItemTracking(OrderLine) or
+                              CheckForJobRelations(OrderLine);
+    
+    if HasComplexRelationships then begin
+        // Use DeleteAll with trigger execution for complex scenarios
+        OrderLine.DeleteAll(true);
+    end else begin
+        // Use faster approach for simple scenarios
+        if OrderLine.FindSet() then begin
+            SalesHeader.Get(OrderLine."Document Type", OrderLine."Document No.");
+            OrderLine.DeleteAll(false);
+            // Manual header update since OnDelete didn't run
+            SalesHeader.Modify(true);
+        end;
+    end;
+end;
+```
+
+## Performance-Optimized Cleanup
+```al
+procedure OptimizedCleanupRoutine()
+var
+    LogEntry: Record "Activity Log";
+    CutoffDate: Date;
+    RecordCount: Integer;
+begin
+    CutoffDate := CalcDate('-1Y', WorkDate());
+    
+    // First pass: Count records for performance estimation
+    LogEntry.SetFilter("Activity Date", '<%1', CutoffDate);
+    RecordCount := LogEntry.Count();
+    
+    case RecordCount of
+        0..999:
+            // Small dataset: Use DeleteAll with business logic
+            LogEntry.DeleteAll(true);
+        1000..9999:
+            // Medium dataset: Use DeleteAll without triggers
+            LogEntry.DeleteAll(false);
+        else begin
+            // Large dataset: Process in batches
+            ProcessLargeDeletionBatch(LogEntry);
+        end;
+    end;
+end;
+
+local procedure ProcessLargeDeletionBatch(var LogEntry: Record "Activity Log")
+var
+    BatchCounter: Integer;
+begin
+    if LogEntry.FindSet() then
+        repeat
+            LogEntry.Delete(false);
+            BatchCounter += 1;
+            
+            if BatchCounter mod 5000 = 0 then begin
+                Commit();
+                Sleep(100); // Brief pause to reduce system load
+            end;
+        until LogEntry.Next() = 0;
+end;
+```

package/embedded-knowledge/domains/sam-coder/samples/deleteall-triggers.md

@@ -0,0 +1,75 @@
+# DeleteAll Method - OnDelete Trigger Integration
+
+## Understanding Trigger Execution with DeleteAll
+```al
+table 50200 "Order Processing Log"
+{
+    fields
+    {
+        field(1; "Entry No."; Integer) { AutoIncrement = true; }
+        field(10; "Order No."; Code[20]) { }
+        field(20; "Customer No."; Code[20]) { TableRelation = Customer; }
+        field(30; "Process Status"; Enum "Process Status") { }
+        field(40; "Created DateTime"; DateTime) { }
+    }
+    
+    keys
+    {
+        key(PK; "Entry No.") { Clustered = true; }
+        key(OrderStatus; "Order No.", "Process Status") { }
+    }
+    
+    trigger OnDelete()
+    var
+        RelatedOrderLine: Record "Order Line Processing";
+        AuditEntry: Record "Deletion Audit Log";
+    begin
+        // CRITICAL: This trigger ALWAYS executes during DeleteAll
+        // No way to bypass this - ensures data integrity is maintained
+        
+        // 1. Validate deletion is allowed
+        if "Process Status" = "Process Status"::Active then
+            Error('Cannot delete active processing log entry %1', "Entry No.");
+        
+        // 2. Clean up related records
+        RelatedOrderLine.Reset();
+        RelatedOrderLine.SetRange("Log Entry No.", "Entry No.");
+        if not RelatedOrderLine.IsEmpty() then
+            RelatedOrderLine.DeleteAll(true);  // Cascaded deletion with triggers
+        
+        // 3. Create audit trail
+        AuditEntry.Init();
+        AuditEntry."Table ID" := Database::"Order Processing Log";
+        AuditEntry."Record ID" := RecordId();
+        AuditEntry."Deletion Time" := CurrentDateTime;
+        AuditEntry."User ID" := UserId;
+        AuditEntry.Insert(true);
+        
+        // 4. Update related master data
+        UpdateOrderStatistics("Order No.");
+    end;
+    
+    local procedure UpdateOrderStatistics(OrderNo: Code[20])
+    var
+        OrderHeader: Record "Sales Header";
+    begin
+        // Update order processing statistics after log deletion
+        if OrderHeader.Get(OrderHeader."Document Type"::Order, OrderNo) then begin
+            OrderHeader."Processing Log Count" -= 1;
+            OrderHeader.Modify(true);
+        end;
+    end;
+}
+```
+
+## Key Principles
+
+### 1. Triggers Always Execute
+- DeleteAll with RunTrigger=true executes OnDelete for every record
+- No bypass mechanism exists - ensures data integrity
+- Plan trigger logic for bulk operation scenarios
+
+### 2. Error Propagation
+- Any trigger error stops entire DeleteAll operation
+- Consider try-function patterns for graceful error handling
+- Individual record processing may be needed for partial success scenarios

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

@@ -0,0 +1,169 @@
+# DeleteAll Method - Basic Usage Patterns
+
+## Simple DeleteAll Implementation
+```al
+codeunit 50100 "Customer Data Cleanup"
+{
+    procedure CleanupInactiveCustomers(DaysInactive: Integer)
+    var
+        Customer: Record Customer;
+        CutoffDate: Date;
+    begin
+        CutoffDate := CalcDate(StrSubstNo('-%1D', DaysInactive), Today());
+        
+        // Filter customers who haven't placed orders since cutoff date
+        Customer.Reset();
+        Customer.SetFilter("Last Date Modified", '<%1', CutoffDate);
+        Customer.SetRange(Blocked, Customer.Blocked::" ");  // Only non-blocked customers
+        
+        // DeleteAll removes all matching records and executes OnDelete triggers
+        if Customer.FindSet() then
+            Customer.DeleteAll(true);  // RunTrigger = true (recommended)
+    end;
+}
+```
+
+## DeleteAll with Record Validation
+```al
+table 50100 "Temporary Sales Data"
+{
+    DataPerCompany = true;
+    
+    fields
+    {
+        field(1; "Entry No."; Integer) { AutoIncrement = true; }
+        field(10; "Customer No."; Code[20]) { TableRelation = Customer; }
+        field(20; "Sales Amount"; Decimal) { }
+        field(30; "Process Date"; Date) { }
+    }
+    
+    keys
+    {
+        key(PK; "Entry No.") { Clustered = true; }
+        key(ProcessDate; "Process Date") { }
+    }
+    
+    trigger OnDelete()
+    begin
+        // This trigger ALWAYS executes during DeleteAll operations
+        // Cannot be bypassed - critical for data integrity
+        if "Sales Amount" > 10000 then
+            Error('Cannot delete high-value sales record: Entry %1', "Entry No.");
+            
+        // Log deletion for audit trail
+        LogDeletion(Rec);
+    end;
+    
+    local procedure LogDeletion(var TempSalesRec: Record "Temporary Sales Data")
+    var
+        AuditLog: Record "Change Log Entry";
+    begin
+        // Audit logging implementation
+        // This ensures all deletions are tracked
+    end;
+}
+
+codeunit 50101 "Sales Data Management"
+{
+    procedure CleanupProcessedData(ProcessDate: Date)
+    var
+        TempSalesData: Record "Temporary Sales Data";
+    begin
+        // Clean up processed sales data older than specified date
+        TempSalesData.Reset();
+        TempSalesData.SetFilter("Process Date", '<%1', ProcessDate);
+        
+        // DeleteAll will execute OnDelete trigger for each record
+        // This ensures audit logging and validation occurs
+        if not TempSalesData.IsEmpty() then begin
+            Message('Cleaning up %1 processed sales records', TempSalesData.Count());
+            TempSalesData.DeleteAll(true);  // Always use RunTrigger = true for safety
+        end;
+    end;
+}
+```
+
+## Error Handling with DeleteAll
+```al
+codeunit 50102 "Order Cleanup Service"
+{
+    procedure DeleteCancelledOrders(var ErrorsOccurred: Boolean): Integer
+    var
+        SalesHeader: Record "Sales Header";
+        DeleteCount: Integer;
+        OriginalCount: Integer;
+    begin
+        ErrorsOccurred := false;
+        
+        // Find cancelled orders older than 30 days
+        SalesHeader.Reset();
+        SalesHeader.SetRange("Document Type", SalesHeader."Document Type"::Order);
+        SalesHeader.SetRange(Status, SalesHeader.Status::Released);
+        SalesHeader.SetFilter("Order Date", '<%1', CalcDate('-30D', Today()));
+        
+        OriginalCount := SalesHeader.Count();
+        
+        // Attempt deletion with error handling
+        if not SalesHeader.IsEmpty() then begin
+            if not TryDeleteOrders(SalesHeader) then begin
+                ErrorsOccurred := true;
+                Error('Failed to delete cancelled orders: %1', GetLastErrorText());
+            end;
+            
+            // Calculate how many were actually deleted
+            SalesHeader.Reset();
+            SalesHeader.SetRange("Document Type", SalesHeader."Document Type"::Order);
+            SalesHeader.SetRange(Status, SalesHeader.Status::Released);
+            SalesHeader.SetFilter("Order Date", '<%1', CalcDate('-30D', Today()));
+            DeleteCount := OriginalCount - SalesHeader.Count();
+        end;
+        
+        exit(DeleteCount);
+    end;
+    
+    [TryFunction]
+    local procedure TryDeleteOrders(var SalesHeader: Record "Sales Header")
+    begin
+        // DeleteAll with error handling
+        // OnDelete triggers will execute and may raise errors
+        SalesHeader.DeleteAll(true);
+    end;
+}
+```
+
+## Best Practices Demonstrated
+
+### 1. Always Use RunTrigger Parameter
+```al
+// CORRECT: Always specify RunTrigger parameter explicitly
+Customer.DeleteAll(true);   // Recommended - ensures data integrity
+
+// AVOID: Omitting parameter (defaults to false in some contexts)
+Customer.DeleteAll();       // May skip important validation logic
+```
+
+### 2. Proper Filter Management
+```al
+// CORRECT: Clear filters before deletion
+MyRecord.Reset();
+MyRecord.SetRange("Status", MyRecord.Status::Processed);
+MyRecord.DeleteAll(true);
+
+// INCORRECT: Assuming current filters
+// MyRecord.DeleteAll(true);  // May delete unexpected records
+```
+
+### 3. Transaction Safety
+```al
+procedure SafeBulkDeletion(var TempData: Record "Temporary Data")
+begin
+    // Large deletions should be performed in manageable chunks
+    if TempData.Count() > 10000 then begin
+        // Process in batches to avoid transaction timeout
+        ProcessDeletionInBatches(TempData);
+    end else begin
+        // Small dataset - single operation is safe
+        TempData.DeleteAll(true);
+    end;
+end;
+```