@jwikman/bc-code-intelligence-mcp 1.5.7-dev.1

package/embedded-knowledge/domains/dean-debug/samples/deleteall-performance.md

@@ -0,0 +1,298 @@
+# DeleteAll SQL Translation and Performance - Examples
+
+## Performance Comparison: DeleteAll vs Loop
+
+```al
+// High-Performance Approach: DeleteAll for bulk operations
+// Translates to single SQL DELETE statement
+codeunit 50200 "Order Cleanup Manager"
+{
+    procedure CleanupOldOrders(CutoffDate: Date): Integer
+    var
+        SalesHeader: Record "Sales Header";
+        DeletedCount: Integer;
+    begin
+        // Single SQL operation - optimal for large datasets
+        SalesHeader.SetRange("Document Type", SalesHeader."Document Type"::Quote);
+        SalesHeader.SetFilter("Document Date", '<%1', CutoffDate);
+        SalesHeader.SetRange(Status, SalesHeader.Status::Open);
+
+        // Count before deletion for reporting
+        DeletedCount := SalesHeader.Count();
+
+        // Execute as single SQL DELETE statement
+        // SQL: DELETE FROM "Sales Header" WHERE "Document Type" = 1
+        //      AND "Document Date" < @CutoffDate AND Status = 0
+        SalesHeader.DeleteAll();
+
+        exit(DeletedCount);
+    end;
+
+    procedure CleanupByStatus(DocumentType: Enum "Sales Document Type"; StatusFilter: Text)
+    var
+        SalesHeader: Record "Sales Header";
+    begin
+        SalesHeader.SetRange("Document Type", DocumentType);
+        SalesHeader.SetFilter(Status, StatusFilter);
+
+        // Leverages database indexing for optimal performance
+        // SQL engine handles WHERE clause optimization
+        SalesHeader.DeleteAll();
+    end;
+}
+```
+
+## Event Bypass Behavior
+
+```al
+// Understanding Event Bypass: DeleteAll skips AL table events
+codeunit 50201 "Archive vs Delete Demo"
+{
+    procedure SafeBulkDeletion(var SalesHeader: Record "Sales Header")
+    var
+        TempSalesHeader: Record "Sales Header" temporary;
+        ArchiveManagement: Codeunit ArchiveManagement;
+    begin
+        // Collect records for event processing if needed
+        if SalesHeader.FindSet() then
+            repeat
+                TempSalesHeader := SalesHeader;
+                TempSalesHeader.Insert();
+            until SalesHeader.Next() = 0;
+
+        // Process AL events manually if required
+        if TempSalesHeader.FindSet() then
+            repeat
+                // Execute necessary validations/archiving before bulk delete
+                ArchiveManagement.StoreSalesDocument(TempSalesHeader, false);
+            until TempSalesHeader.Next() = 0;
+
+        // Now safe to use DeleteAll - events already processed
+        SalesHeader.DeleteAll();
+    end;
+
+    procedure CompareEventBehavior()
+    var
+        SalesLine: Record "Sales Line";
+        SingleLine: Record "Sales Line";
+    begin
+        // DELETEALL APPROACH: Events bypassed
+        SalesLine.SetRange("Document No.", 'ORDER001');
+        SalesLine.DeleteAll(); // OnDelete triggers NOT called
+
+        // ITERATIVE APPROACH: Events execute
+        SingleLine.SetRange("Document No.", 'ORDER002');
+        if SingleLine.FindSet() then
+            repeat
+                SingleLine.Delete(); // OnDelete triggers ARE called
+            until SingleLine.Next() = 0;
+    end;
+}
+```
+
+## SQL Translation Patterns
+
+```al
+// Filter optimization impacts SQL DELETE performance
+codeunit 50202 "SQL Optimization Examples"
+{
+    procedure OptimizedFilters()
+    var
+        ItemLedgerEntry: Record "Item Ledger Entry";
+    begin
+        // GOOD: Uses indexed fields for optimal SQL performance
+        ItemLedgerEntry.SetRange("Item No.", 'ITEM001');
+        ItemLedgerEntry.SetRange("Posting Date", 20240101D, 20241231D);
+        ItemLedgerEntry.SetRange("Entry Type", ItemLedgerEntry."Entry Type"::Sale);
+
+        // SQL: DELETE FROM "Item Ledger Entry"
+        //      WHERE "Item No." = 'ITEM001'
+        //      AND "Posting Date" BETWEEN '2024-01-01' AND '2024-12-31'
+        //      AND "Entry Type" = 1
+        // Database can use compound index efficiently
+        ItemLedgerEntry.DeleteAll();
+    end;
+
+    procedure SuboptimalFilters()
+    var
+        ItemLedgerEntry: Record "Item Ledger Entry";
+    begin
+        // SUBOPTIMAL: Complex filters may require full table scan
+        ItemLedgerEntry.SetFilter("Description", '@*SAMPLE*');
+        ItemLedgerEntry.SetFilter("Quantity", '>0&<100');
+
+        // SQL: DELETE FROM "Item Ledger Entry"
+        //      WHERE "Description" LIKE '%SAMPLE%'
+        //      AND "Quantity" > 0 AND "Quantity" < 100
+        // May require table scan without proper indexing
+        ItemLedgerEntry.DeleteAll();
+    end;
+}
+```
+
+## Transaction Boundary Considerations
+
+```al
+// Managing large DeleteAll operations within transaction limits
+codeunit 50203 "Batch Delete Manager"
+{
+    procedure LargeBatchDeletion(TableID: Integer; FilterText: Text): Boolean
+    var
+        RecRef: RecordRef;
+        TotalRecords: Integer;
+        BatchSize: Integer;
+        ProcessedCount: Integer;
+    begin
+        RecRef.Open(TableID);
+        RecRef.SetView(FilterText);
+
+        TotalRecords := RecRef.Count();
+        BatchSize := 10000; // Adjust based on transaction log limits
+
+        if TotalRecords <= BatchSize then begin
+            // Single DeleteAll for smaller datasets
+            RecRef.DeleteAll();
+            exit(true);
+        end;
+
+        // Process in batches for very large datasets
+        repeat
+            RecRef.SetView(FilterText);
+            if RecRef.FindSet() then begin
+                ProcessedCount := 0;
+                repeat
+                    RecRef.Delete();
+                    ProcessedCount += 1;
+                    if ProcessedCount >= BatchSize then begin
+                        Commit(); // Release transaction log space
+                        RecRef.SetView(FilterText);
+                        RecRef.FindFirst();
+                        ProcessedCount := 0;
+                    end;
+                until (RecRef.Next() = 0) or (ProcessedCount >= BatchSize);
+            end;
+        until RecRef.Count() = 0;
+
+        exit(true);
+    end;
+}
+```
+
+## Performance Monitoring
+
+```al
+// Measuring DeleteAll performance characteristics
+codeunit 50204 "Delete Performance Monitor"
+{
+    procedure BenchmarkDeletionMethods(RecordCount: Integer)
+    var
+        TempInteger: Record "Integer" temporary;
+        StartTime: Time;
+        DeleteAllTime: Duration;
+        IterativeTime: Duration;
+        i: Integer;
+    begin
+        // Setup test data
+        for i := 1 to RecordCount do begin
+            TempInteger.Number := i;
+            TempInteger.Insert();
+        end;
+
+        // Benchmark DeleteAll approach
+        StartTime := Time;
+        TempInteger.DeleteAll();
+        DeleteAllTime := Time - StartTime;
+
+        // Recreate test data for iterative test
+        for i := 1 to RecordCount do begin
+            TempInteger.Number := i;
+            TempInteger.Insert();
+        end;
+
+        // Benchmark iterative deletion
+        StartTime := Time;
+        if TempInteger.FindSet() then
+            repeat
+                TempInteger.Delete();
+            until TempInteger.Next() = 0;
+        IterativeTime := Time - StartTime;
+
+        // Log performance comparison
+        Message('DeleteAll: %1ms, Iterative: %2ms, Ratio: %3:1',
+                DeleteAllTime, IterativeTime,
+                Round(IterativeTime / DeleteAllTime, 0.1));
+    end;
+}
+```
+
+## Anti-Pattern: Mixed Deletion Approaches
+
+```al
+// ANTI-PATTERN: Inconsistent deletion methods in same operation
+codeunit 50299 "Deletion Anti-Patterns" // DON'T DO THIS
+{
+    procedure InconsistentCleanup(OrderNo: Code[20]) // BAD EXAMPLE
+    var
+        SalesHeader: Record "Sales Header";
+        SalesLine: Record "Sales Line";
+        SalesCommentLine: Record "Sales Comment Line";
+    begin
+        // PROBLEM: Mixing deletion methods without understanding implications
+
+        // Uses DeleteAll (bypasses events)
+        SalesLine.SetRange("Document No.", OrderNo);
+        SalesLine.DeleteAll(); // OnDelete events NOT called
+
+        // Uses iterative deletion (processes events)
+        SalesCommentLine.SetRange("Document Type", SalesCommentLine."Document Type"::Order);
+        SalesCommentLine.SetRange("No.", OrderNo);
+        if SalesCommentLine.FindSet() then
+            repeat
+                SalesCommentLine.Delete(); // OnDelete events ARE called
+            until SalesCommentLine.Next() = 0;
+
+        // Manual deletion (bypasses AL Delete method entirely)
+        SalesHeader.Get(SalesHeader."Document Type"::Order, OrderNo);
+        SalesHeader.Delete(); // OnDelete events ARE called
+
+        // PROBLEMS:
+        // 1. Inconsistent event processing across related tables
+        // 2. Potential data integrity issues from partial event execution
+        // 3. Unpredictable behavior for consuming code
+    end;
+
+    procedure UnoptimizedBulkDeletion() // BAD EXAMPLE
+    var
+        Item: Record Item;
+    begin
+        // ANTI-PATTERN: Using loop when DeleteAll would be more efficient
+        Item.SetRange(Blocked, true);
+        Item.SetFilter("Last Date Modified", '<%1', CalcDate('-1Y', Today));
+
+        // INEFFICIENT: Creates individual SQL DELETE statements
+        if Item.FindSet() then
+            repeat
+                Item.Delete(); // Each iteration = separate SQL statement
+            until Item.Next() = 0;
+
+        // BETTER APPROACH: Single SQL operation
+        // Item.DeleteAll(); // One SQL DELETE statement
+    end;
+}
+
+/*
+CORRECT DELETEALL USAGE PRINCIPLES:
+
+1. Consistency: Use same deletion method for related operations
+2. Event Awareness: Understand which events are bypassed
+3. Performance Priority: Choose DeleteAll for bulk operations
+4. Documentation: Clearly document event bypass behavior
+5. Validation: Ensure database constraints handle integrity
+6. Testing: Verify behavior matches expectations in all scenarios
+
+DECISION MATRIX:
+- Large datasets + No critical AL events = DeleteAll
+- Small datasets + Complex AL logic = Iterative deletion
+- Mixed requirements = Separate phases or manual event processing
+*/
+```

package/embedded-knowledge/domains/dean-debug/samples/error-correlation.md

@@ -0,0 +1,324 @@
+# Error Correlation Implementation Patterns - AL Code Samples
+
+## Correlation ID Management
+```al
+codeunit 50140 "Error Correlation Manager"
+{
+    var
+        CurrentCorrelationId: Text;
+        CorrelationIdStack: List of [Text];
+        ErrorContext: Dictionary of [Text, Text];
+
+    // Example 1: Transaction-scoped correlation tracking
+    procedure BeginCorrelatedOperation(OperationName: Text): Text
+    var
+        CorrelationId: Text;
+        CustomDimensions: Dictionary of [Text, Text];
+    begin
+        CorrelationId := CreateCorrelationId();
+        
+        // Push current correlation ID to stack for nested operations
+        if CurrentCorrelationId <> '' then
+            CorrelationIdStack.Add(CurrentCorrelationId);
+            
+        CurrentCorrelationId := CorrelationId;
+        
+        // Initialize error context for this correlation
+        ClearErrorContext();
+        ErrorContext.Add('OperationName', OperationName);
+        ErrorContext.Add('StartTime', Format(CurrentDateTime, 0, 9));
+        ErrorContext.Add('UserID', UserId());
+        ErrorContext.Add('CompanyName', CompanyName());
+        
+        // Log operation start
+        CustomDimensions := BuildCorrelationDimensions(CorrelationId);
+        CustomDimensions.Add('EventType', 'OperationStart');
+        CustomDimensions.Add('OperationName', OperationName);
+        
+        Session.LogMessage('COR001', StrSubstNo('Operation started: %1', OperationName), 
+            Verbosity::Verbose, DataClassification::SystemMetadata, 
+            TelemetryScope::ExtensionPublisher, CustomDimensions);
+            
+        exit(CorrelationId);
+    end;
+
+    procedure EndCorrelatedOperation(CorrelationId: Text; Success: Boolean)
+    var
+        CustomDimensions: Dictionary of [Text, Text];
+        Duration: Duration;
+        StartTimeText: Text;
+        StartTime: DateTime;
+    begin
+        CustomDimensions := BuildCorrelationDimensions(CorrelationId);
+        CustomDimensions.Add('EventType', 'OperationEnd');
+        CustomDimensions.Add('Success', Format(Success));
+        
+        // Calculate operation duration
+        if ErrorContext.Get('StartTime', StartTimeText) then begin
+            if Evaluate(StartTime, StartTimeText) then begin
+                Duration := CurrentDateTime - StartTime;
+                CustomDimensions.Add('DurationMs', Format(Duration));
+            end;
+        end;
+        
+        // Add operation context
+        AddErrorContextToDimensions(CustomDimensions);
+        
+        Session.LogMessage('COR002', 
+            StrSubstNo('Operation completed: %1 (Success: %2)', 
+                ErrorContext.Get('OperationName'), Success), 
+            Verbosity::Normal, DataClassification::SystemMetadata, 
+            TelemetryScope::ExtensionPublisher, CustomDimensions);
+            
+        // Restore previous correlation ID
+        if CorrelationIdStack.Count > 0 then begin
+            CurrentCorrelationId := CorrelationIdStack.Get(CorrelationIdStack.Count);
+            CorrelationIdStack.RemoveAt(CorrelationIdStack.Count);
+        end else begin
+            CurrentCorrelationId := '';
+            ClearErrorContext();
+        end;
+    end;
+
+    // Example 2: Error correlation with full context capture
+    procedure LogCorrelatedError(ErrorMessage: Text; ErrorCode: Text; AdditionalContext: Dictionary of [Text, Text])
+    var
+        CustomDimensions: Dictionary of [Text, Text];
+        StackTrace: Text;
+    begin
+        if CurrentCorrelationId = '' then
+            CurrentCorrelationId := CreateCorrelationId();
+            
+        CustomDimensions := BuildCorrelationDimensions(CurrentCorrelationId);
+        CustomDimensions.Add('EventType', 'Error');
+        CustomDimensions.Add('ErrorCode', ErrorCode);
+        CustomDimensions.Add('ErrorMessage', ErrorMessage);
+        
+        // Add error context
+        AddErrorContextToDimensions(CustomDimensions);
+        
+        // Add additional context provided by caller
+        AddAdditionalContextToDimensions(CustomDimensions, AdditionalContext);
+        
+        // Capture stack trace information
+        StackTrace := CaptureStackTrace();
+        if StackTrace <> '' then
+            CustomDimensions.Add('StackTrace', StackTrace);
+            
+        Session.LogMessage('COR003', StrSubstNo('Correlated error: %1', ErrorMessage),
+            Verbosity::Error, DataClassification::SystemMetadata,
+            TelemetryScope::ExtensionPublisher, CustomDimensions);
+    end;
+
+    local procedure CreateCorrelationId(): Text
+    begin
+        exit(CreateGuid());
+    end;
+
+    local procedure BuildCorrelationDimensions(CorrelationId: Text): Dictionary of [Text, Text]
+    var
+        CustomDimensions: Dictionary of [Text, Text];
+    begin
+        CustomDimensions.Add('CorrelationId', CorrelationId);
+        CustomDimensions.Add('SessionId', Format(SessionId()));
+        CustomDimensions.Add('UserID', UserId());
+        CustomDimensions.Add('CompanyName', CompanyName());
+        CustomDimensions.Add('Timestamp', Format(CurrentDateTime, 0, 9));
+        exit(CustomDimensions);
+    end;
+
+    local procedure ClearErrorContext()
+    begin
+        ErrorContext.Clear();
+    end;
+
+    local procedure AddErrorContextToDimensions(var CustomDimensions: Dictionary of [Text, Text])
+    var
+        Key: Text;
+    begin
+        foreach Key in ErrorContext.Keys do
+            CustomDimensions.Add('Context_' + Key, ErrorContext.Get(Key));
+    end;
+
+    local procedure AddAdditionalContextToDimensions(var CustomDimensions: Dictionary of [Text, Text]; AdditionalContext: Dictionary of [Text, Text])
+    var
+        Key: Text;
+    begin
+        foreach Key in AdditionalContext.Keys do
+            CustomDimensions.Add(Key, AdditionalContext.Get(Key));
+    end;
+
+    local procedure CaptureStackTrace(): Text
+    begin
+        // Implement stack trace capture if available
+        exit('');
+    end;
+}
+```
+
+## Cross-Process Error Correlation
+```al
+codeunit 50141 "Cross Process Correlation"
+{
+    // Example 3: API integration error correlation
+    procedure LogAPICorrelatedCall(APIEndpoint: Text; HTTPMethod: Text; RequestCorrelationId: Text): Text
+    var
+        CallCorrelationId: Text;
+        CustomDimensions: Dictionary of [Text, Text];
+    begin
+        CallCorrelationId := CreateGuid();
+        
+        CustomDimensions.Add('CallCorrelationId', CallCorrelationId);
+        CustomDimensions.Add('RequestCorrelationId', RequestCorrelationId);
+        CustomDimensions.Add('APIEndpoint', APIEndpoint);
+        CustomDimensions.Add('HTTPMethod', HTTPMethod);
+        CustomDimensions.Add('EventType', 'APICallStart');
+        CustomDimensions.Add('UserID', UserId());
+        CustomDimensions.Add('CompanyName', CompanyName());
+        
+        Session.LogMessage('API001', StrSubstNo('API call initiated: %1 %2', HTTPMethod, APIEndpoint),
+            Verbosity::Normal, DataClassification::SystemMetadata,
+            TelemetryScope::ExtensionPublisher, CustomDimensions);
+            
+        exit(CallCorrelationId);
+    end;
+
+    procedure LogAPICorrelatedResponse(CallCorrelationId: Text; HTTPStatusCode: Integer; ResponseTime: Integer; ErrorMessage: Text)
+    var
+        CustomDimensions: Dictionary of [Text, Text];
+        IsSuccess: Boolean;
+    begin
+        IsSuccess := (HTTPStatusCode >= 200) and (HTTPStatusCode < 300);
+        
+        CustomDimensions.Add('CallCorrelationId', CallCorrelationId);
+        CustomDimensions.Add('HTTPStatusCode', Format(HTTPStatusCode));
+        CustomDimensions.Add('ResponseTime', Format(ResponseTime));
+        CustomDimensions.Add('Success', Format(IsSuccess));
+        CustomDimensions.Add('EventType', 'APICallEnd');
+        
+        if not IsSuccess then begin
+            CustomDimensions.Add('ErrorMessage', ErrorMessage);
+            CustomDimensions.Add('ErrorCategory', 'APIError');
+        end;
+        
+        Session.LogMessage('API002', 
+            StrSubstNo('API call completed: Status %1, Duration %2ms', HTTPStatusCode, ResponseTime),
+            if IsSuccess then Verbosity::Normal else Verbosity::Error,
+            DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, CustomDimensions);
+    end;
+
+    // Example 4: Business process correlation
+    procedure TrackBusinessProcessFlow(ProcessName: Text; ProcessStage: Text; BusinessData: Dictionary of [Text, Text])
+    var
+        ProcessCorrelationId: Text;
+        CustomDimensions: Dictionary of [Text, Text];
+    begin
+        ProcessCorrelationId := GetOrCreateProcessCorrelation(ProcessName, BusinessData);
+        
+        CustomDimensions.Add('ProcessCorrelationId', ProcessCorrelationId);
+        CustomDimensions.Add('ProcessName', ProcessName);
+        CustomDimensions.Add('ProcessStage', ProcessStage);
+        CustomDimensions.Add('EventType', 'ProcessFlow');
+        
+        // Add business context
+        AddBusinessContextToDimensions(CustomDimensions, BusinessData);
+        
+        Session.LogMessage('PROC001', StrSubstNo('Business process flow: %1 - %2', ProcessName, ProcessStage),
+            Verbosity::Normal, DataClassification::SystemMetadata,
+            TelemetryScope::ExtensionPublisher, CustomDimensions);
+    end;
+
+    local procedure GetOrCreateProcessCorrelation(ProcessName: Text; BusinessData: Dictionary of [Text, Text]): Text
+    var
+        ProcessKey: Text;
+        ProcessCorrelationMap: Dictionary of [Text, Text];
+    begin
+        ProcessKey := ProcessName + '_' + BusinessData.Get('DocumentNo');
+        
+        if not ProcessCorrelationMap.ContainsKey(ProcessKey) then
+            ProcessCorrelationMap.Add(ProcessKey, CreateGuid());
+            
+        exit(ProcessCorrelationMap.Get(ProcessKey));
+    end;
+
+    local procedure AddBusinessContextToDimensions(var CustomDimensions: Dictionary of [Text, Text]; BusinessData: Dictionary of [Text, Text])
+    var
+        Key: Text;
+    begin
+        foreach Key in BusinessData.Keys do
+            CustomDimensions.Add('Business_' + Key, BusinessData.Get(Key));
+    end;
+}
+```
+
+## Database Transaction Correlation
+```al
+codeunit 50142 "Database Transaction Correlation"
+{
+    var
+        TransactionStartTimes: Dictionary of [Text, DateTime];
+
+    // Example 5: Database transaction correlation
+    procedure BeginDatabaseTransaction(TransactionType: Text; TableName: Text): Text
+    var
+        TransactionId: Text;
+        CustomDimensions: Dictionary of [Text, Text];
+    begin
+        TransactionId := CreateTransactionId();
+        
+        TransactionStartTimes.Add(TransactionId, CurrentDateTime);
+        
+        CustomDimensions.Add('TransactionId', TransactionId);
+        CustomDimensions.Add('TransactionType', TransactionType);
+        CustomDimensions.Add('TableName', TableName);
+        CustomDimensions.Add('EventType', 'TransactionStart');
+        CustomDimensions.Add('UserID', UserId());
+        CustomDimensions.Add('CompanyName', CompanyName());
+        
+        Session.LogMessage('TXN001', StrSubstNo('Database transaction started: %1 on %2', TransactionType, TableName),
+            Verbosity::Verbose, DataClassification::SystemMetadata,
+            TelemetryScope::ExtensionPublisher, CustomDimensions);
+            
+        exit(TransactionId);
+    end;
+
+    procedure LogTransactionError(TransactionId: Text; ErrorMessage: Text; RecordContext: Dictionary of [Text, Text])
+    var
+        CustomDimensions: Dictionary of [Text, Text];
+        TransactionDuration: Duration;
+        StartTime: DateTime;
+    begin
+        CustomDimensions.Add('TransactionId', TransactionId);
+        CustomDimensions.Add('EventType', 'TransactionError');
+        CustomDimensions.Add('ErrorMessage', ErrorMessage);
+        CustomDimensions.Add('ErrorCategory', 'DatabaseError');
+        
+        // Calculate transaction duration
+        if TransactionStartTimes.Get(TransactionId, StartTime) then begin
+            TransactionDuration := CurrentDateTime - StartTime;
+            CustomDimensions.Add('TransactionDuration', Format(TransactionDuration));
+        end;
+        
+        // Add record context for debugging
+        AddRecordContextToDimensions(CustomDimensions, RecordContext);
+        
+        Session.LogMessage('TXN002', StrSubstNo('Database transaction error: %1', ErrorMessage),
+            Verbosity::Error, DataClassification::SystemMetadata,
+            TelemetryScope::ExtensionPublisher, CustomDimensions);
+    end;
+
+    local procedure CreateTransactionId(): Text
+    begin
+        exit('TXN-' + Format(CurrentDateTime, 0, '<Year4><Month,2><Day,2><Hours24><Minutes,2><Seconds,2>') + 
+             '-' + Format(Random(9999), 4, '<Integer,4><Filler Character,0>'));
+    end;
+
+    local procedure AddRecordContextToDimensions(var CustomDimensions: Dictionary of [Text, Text]; RecordContext: Dictionary of [Text, Text])
+    var
+        Key: Text;
+    begin
+        foreach Key in RecordContext.Keys do
+            CustomDimensions.Add('Record_' + Key, RecordContext.Get(Key));
+    end;
+}
+```