bc-code-intelligence-mcp 1.3.2 → 1.3.4

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

@@ -1,117 +0,0 @@
-# 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

@@ -1,75 +0,0 @@
-# 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

@@ -1,169 +0,0 @@
-# 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;
-```