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

package/embedded-knowledge/domains/dean-debug/samples/setloadfields-primary-key.md

@@ -0,0 +1,155 @@
+# SetLoadFields Primary Key Optimization - AL Code Samples
+
+## Basic Primary Key Optimization
+```al
+codeunit 50100 "SetLoadFields PK Examples"
+{
+    procedure OptimizedPrimaryKeyLookup(DocumentType: Enum "Sales Document Type"; DocumentNo: Code[20])
+    var
+        SalesHeader: Record "Sales Header";
+    begin
+        // Load only primary key fields for existence checks
+        SalesHeader.SetLoadFields("Document Type", "No.");
+        SalesHeader.SetRange("Document Type", DocumentType);
+        SalesHeader.SetRange("No.", DocumentNo);
+        
+        if SalesHeader.FindSet() then
+            repeat
+                // Primary key fields already loaded, minimal memory usage
+                ProcessDocumentHeader(SalesHeader."Document Type", SalesHeader."No.");
+            until SalesHeader.Next() = 0;
+    end;
+
+    procedure ConditionalPrimaryKeyLoading(CustomerNo: Code[20]; LoadFullData: Boolean)
+    var
+        Customer: Record Customer;
+    begin
+        if LoadFullData then
+            // Load all fields when full processing needed
+            Customer.SetLoadFields()
+        else
+            // Minimal primary key loading for counting/existence
+            Customer.SetLoadFields("No.");
+            
+        Customer.SetRange("No.", CustomerNo);
+        
+        if Customer.FindFirst() then
+            if LoadFullData then
+                ProcessFullCustomer(Customer)
+            else
+                LogCustomerExists(Customer."No.");
+    end;
+
+    procedure BulkPrimaryKeyProcessing()
+    var
+        Item: Record Item;
+        ItemNumbers: List of [Code[20]];
+        ItemNo: Code[20];
+    begin
+        // First pass: collect primary keys only
+        Item.SetLoadFields("No.");
+        if Item.FindSet() then
+            repeat
+                ItemNumbers.Add(Item."No.");
+            until Item.Next() = 0;
+            
+        // Second pass: process specific records with full data
+        foreach ItemNo in ItemNumbers do begin
+            Item.SetLoadFields(); // Load all fields for processing
+            if Item.Get(ItemNo) then
+                ProcessFullItem(Item);
+        end;
+    end;
+
+    local procedure ProcessDocumentHeader(DocumentType: Enum "Sales Document Type"; DocumentNo: Code[20])
+    begin
+        // Processing logic using only primary key data
+    end;
+
+    local procedure ProcessFullCustomer(var Customer: Record Customer)
+    begin
+        // Full customer processing
+    end;
+
+    local procedure LogCustomerExists(CustomerNo: Code[20])
+    begin
+        // Minimal logging using primary key data
+    end;
+
+    local procedure ProcessFullItem(var Item: Record Item)
+    begin
+        // Full item processing
+    end;
+}
+```
+
+## Performance Comparison Examples
+```al
+codeunit 50101 "PK Performance Comparison"
+{
+    procedure UnoptimizedPrimaryKeyAccess()
+    var
+        Customer: Record Customer;
+    begin
+        // BAD: Loading all fields when only checking existence
+        Customer.SetRange("Customer Posting Group", 'DOMESTIC');
+        
+        if Customer.FindSet() then
+            repeat
+                // Only using primary key fields but all fields were loaded
+                if IsValidCustomer(Customer."No.") then
+                    ProcessValidCustomer(Customer."No.");
+            until Customer.Next() = 0;
+    end;
+    
+    procedure OptimizedPrimaryKeyAccess()
+    var
+        Customer: Record Customer;
+    begin
+        // GOOD: Loading only required primary key fields
+        Customer.SetLoadFields("No.");
+        Customer.SetRange("Customer Posting Group", 'DOMESTIC');
+        
+        if Customer.FindSet() then
+            repeat
+                // Minimal memory usage, faster iteration
+                if IsValidCustomer(Customer."No.") then
+                    ProcessValidCustomer(Customer."No.");
+            until Customer.Next() = 0;
+    end;
+
+    procedure SmartPrimaryKeyWithLazyLoading()
+    var
+        Customer: Record Customer;
+        FullDataCustomer: Record Customer;
+    begin
+        // BEST: Minimal loading with selective full data loading
+        Customer.SetLoadFields("No.");
+        Customer.SetRange("Customer Posting Group", 'DOMESTIC');
+        
+        if Customer.FindSet() then
+            repeat
+                if IsValidCustomer(Customer."No.") then begin
+                    // Load full data only when needed
+                    if FullDataCustomer.Get(Customer."No.") then
+                        ProcessFullCustomer(FullDataCustomer);
+                end;
+            until Customer.Next() = 0;
+    end;
+
+    local procedure IsValidCustomer(CustomerNo: Code[20]): Boolean
+    begin
+        exit(CustomerNo <> '');
+    end;
+
+    local procedure ProcessValidCustomer(CustomerNo: Code[20])
+    begin
+        // Processing using only primary key data
+    end;
+
+    local procedure ProcessFullCustomer(var Customer: Record Customer)
+    begin
+        // Full customer processing
+    end;
+}
+```

package/embedded-knowledge/domains/dean-debug/samples/sift-technology-fundamentals.md

@@ -0,0 +1,475 @@
+# SIFT Technology Fundamentals - AL Code Samples
+
+## Basic SIFT Table Configuration
+
+### Standard Implementation
+```al
+table 50100 "Sales Analytics Data"
+{
+    Caption = 'Sales Analytics Data';
+    DataClassification = CustomerContent;
+
+    fields
+    {
+        field(1; "Customer No."; Code[20])
+        {
+            Caption = 'Customer No.';
+            TableRelation = Customer;
+        }
+        field(2; "Item No."; Code[20])
+        {
+            Caption = 'Item No.';
+            TableRelation = Item;
+        }
+        field(3; "Posting Date"; Date)
+        {
+            Caption = 'Posting Date';
+        }
+        field(10; "Sales Amount"; Decimal)
+        {
+            Caption = 'Sales Amount';
+            DecimalPlaces = 2 : 2;
+        }
+        field(11; "Quantity"; Decimal)
+        {
+            Caption = 'Quantity';
+            DecimalPlaces = 0 : 5;
+        }
+        field(12; "Profit Amount"; Decimal)
+        {
+            Caption = 'Profit Amount';
+            DecimalPlaces = 2 : 2;
+        }
+    }
+
+    keys
+    {
+        key(PK; "Customer No.", "Item No.", "Posting Date")
+        {
+            Clustered = true;
+        }
+        
+        // Basic SIFT key for customer totals
+        key(CustomerSIFT; "Customer No.")
+        {
+            SumIndexFields = "Sales Amount", Quantity, "Profit Amount";
+            MaintainSIFTIndex = true;
+        }
+        
+        // Item-based aggregations
+        key(ItemSIFT; "Item No.")
+        {
+            SumIndexFields = "Sales Amount", Quantity;
+            MaintainSIFTIndex = true;
+        }
+    }
+}
+```
+
+## SumIndexFields Property Usage Patterns
+
+### Multiple Aggregation Strategies
+```al
+table 50101 "Order Performance Metrics"
+{
+    Caption = 'Order Performance Metrics';
+    DataClassification = CustomerContent;
+
+    fields
+    {
+        field(1; "Salesperson Code"; Code[20]) { }
+        field(2; "Customer No."; Code[20]) { }
+        field(3; "Order Date"; Date) { }
+        field(10; "Order Amount"; Decimal) { }
+        field(11; "Discount Amount"; Decimal) { }
+        field(12; "Commission Amount"; Decimal) { }
+        field(13; "Processing Time"; Integer) { }
+    }
+
+    keys
+    {
+        key(PK; "Salesperson Code", "Customer No.", "Order Date") { Clustered = true; }
+        
+        // Comprehensive salesperson performance SIFT
+        key(SalespersonPerformance; "Salesperson Code")
+        {
+            SumIndexFields = "Order Amount", "Discount Amount", "Commission Amount";
+            MaintainSIFTIndex = true;
+        }
+        
+        // Customer relationship metrics SIFT
+        key(CustomerMetrics; "Customer No.")
+        {
+            SumIndexFields = "Order Amount", "Discount Amount";
+            MaintainSIFTIndex = true;
+        }
+        
+        // Time-based analysis SIFT
+        key(DateAnalysis; "Order Date")
+        {
+            SumIndexFields = "Order Amount", "Processing Time";
+            MaintainSIFTIndex = false; // On-demand for reporting
+        }
+    }
+}
+
+// Usage in AL code
+codeunit 50100 "SIFT Usage Examples"
+{
+    procedure GetSalespersonTotals(SalespersonCode: Code[20]; var TotalAmount: Decimal; var TotalCommission: Decimal)
+    var
+        OrderMetrics: Record "Order Performance Metrics";
+    begin
+        OrderMetrics.Reset();
+        OrderMetrics.SetRange("Salesperson Code", SalespersonCode);
+        
+        // Leverages SIFT for instant calculation
+        OrderMetrics.CalcSums("Order Amount", "Commission Amount");
+        TotalAmount := OrderMetrics."Order Amount";
+        TotalCommission := OrderMetrics."Commission Amount";
+    end;
+}
+```
+
+## FlowField Integration with SIFT
+
+### Customer Card with SIFT-Optimized FlowFields
+```al
+tableextension 50100 "Customer SIFT Extension" extends Customer
+{
+    fields
+    {
+        // FlowField automatically leverages SIFT when available
+        field(50100; "Total Sales Amount"; Decimal)
+        {
+            Caption = 'Total Sales Amount';
+            FieldClass = FlowField;
+            CalcFormula = sum("Sales Analytics Data"."Sales Amount" where("Customer No." = field("No.")));
+            Editable = false;
+        }
+        
+        field(50101; "Total Quantity Sold"; Decimal)
+        {
+            Caption = 'Total Quantity Sold';
+            FieldClass = FlowField;
+            CalcFormula = sum("Sales Analytics Data".Quantity where("Customer No." = field("No.")));
+            Editable = false;
+        }
+        
+        field(50102; "Average Order Value"; Decimal)
+        {
+            Caption = 'Average Order Value';
+            FieldClass = FlowField;
+            CalcFormula = average("Sales Analytics Data"."Sales Amount" where("Customer No." = field("No.")));
+            Editable = false;
+        }
+    }
+}
+
+// Page implementation with automatic FlowField calculation
+pageextension 50100 "Customer Card SIFT" extends "Customer Card"
+{
+    layout
+    {
+        addafter("Name")
+        {
+            group("Sales Analytics")
+            {
+                Caption = 'Sales Analytics (SIFT-Optimized)';
+                
+                field("Total Sales Amount"; Rec."Total Sales Amount")
+                {
+                    ApplicationArea = All;
+                    // Automatically calculated using SIFT when page opens
+                }
+                field("Total Quantity Sold"; Rec."Total Quantity Sold")
+                {
+                    ApplicationArea = All;
+                }
+                field("Average Order Value"; Rec."Average Order Value")
+                {
+                    ApplicationArea = All;
+                }
+            }
+        }
+    }
+    
+    trigger OnAfterGetRecord()
+    begin
+        // Force calculation of FlowFields (leverages SIFT)
+        Rec.CalcFields("Total Sales Amount", "Total Quantity Sold", "Average Order Value");
+    end;
+}
+```
+
+## Performance Comparison: SIFT vs Non-SIFT
+
+### Performance Testing Framework
+```al
+codeunit 50101 "SIFT Performance Comparison"
+{
+    procedure ComparePerformance(CustomerNo: Code[20])
+    var
+        SalesData: Record "Sales Analytics Data";
+        StartTime: DateTime;
+        EndTime: DateTime;
+        SIFTDuration: Duration;
+        ManualDuration: Duration;
+        TotalAmount: Decimal;
+    begin
+        // Test 1: SIFT-optimized calculation
+        StartTime := CurrentDateTime;
+        TotalAmount := CalculateUsingSIFT(CustomerNo);
+        EndTime := CurrentDateTime;
+        SIFTDuration := EndTime - StartTime;
+        
+        // Test 2: Manual calculation without SIFT
+        StartTime := CurrentDateTime;
+        TotalAmount := CalculateManually(CustomerNo);
+        EndTime := CurrentDateTime;
+        ManualDuration := EndTime - StartTime;
+        
+        // Performance comparison results
+        Message('SIFT Calculation: %1ms\Manual Calculation: %2ms\Performance Improvement: %3x faster',
+                SIFTDuration, ManualDuration, ManualDuration / SIFTDuration);
+    end;
+    
+    local procedure CalculateUsingSIFT(CustomerNo: Code[20]): Decimal
+    var
+        SalesData: Record "Sales Analytics Data";
+    begin
+        // Leverages SIFT index for instant aggregation
+        SalesData.Reset();
+        SalesData.SetRange("Customer No.", CustomerNo);
+        SalesData.CalcSums("Sales Amount");
+        exit(SalesData."Sales Amount");
+    end;
+    
+    local procedure CalculateManually(CustomerNo: Code[20]): Decimal
+    var
+        SalesData: Record "Sales Analytics Data";
+        TotalAmount: Decimal;
+    begin
+        // Forces row-by-row calculation without SIFT
+        SalesData.Reset();
+        SalesData.SetRange("Customer No.", CustomerNo);
+        if SalesData.FindSet() then
+            repeat
+                TotalAmount += SalesData."Sales Amount";
+            until SalesData.Next() = 0;
+        exit(TotalAmount);
+    end;
+}
+
+// Benchmark results table for tracking
+table 50102 "SIFT Performance Benchmark"
+{
+    fields
+    {
+        field(1; "Test Date"; DateTime) { }
+        field(2; "Customer No."; Code[20]) { }
+        field(3; "Record Count"; Integer) { }
+        field(4; "SIFT Duration (ms)"; Integer) { }
+        field(5; "Manual Duration (ms)"; Integer) { }
+        field(6; "Performance Ratio"; Decimal) { }
+    }
+    
+    keys
+    {
+        key(PK; "Test Date", "Customer No.") { }
+    }
+}
+```
+
+## Common SIFT Configuration Mistakes (Anti-Patterns)
+
+### Anti-Pattern Examples with Corrections
+
+#### ❌ Anti-Pattern 1: Excessive SIFT Keys
+```al
+// BAD: Too many SIFT keys with MaintainSIFTIndex = true
+table 50103 "Over-SIFT Example (Bad)"
+{
+    keys
+    {
+        key(PK; ID) { }
+        key(SIFT1; Field1) { SumIndexFields = Amount; MaintainSIFTIndex = true; }
+        key(SIFT2; Field2) { SumIndexFields = Amount; MaintainSIFTIndex = true; }
+        key(SIFT3; Field3) { SumIndexFields = Amount; MaintainSIFTIndex = true; }
+        key(SIFT4; Field4) { SumIndexFields = Amount; MaintainSIFTIndex = true; }
+        key(SIFT5; Field5) { SumIndexFields = Amount; MaintainSIFTIndex = true; }
+        // Problem: Every data modification updates 5 SIFT indexes
+        // Impact: Severe write performance degradation
+    }
+}
+```
+
+#### ✅ Corrected Pattern 1: Selective SIFT Usage
+```al
+// GOOD: Strategic SIFT key selection
+table 50104 "Optimized SIFT Example (Good)"
+{
+    keys
+    {
+        key(PK; ID) { }
+        
+        // Only critical aggregations maintain real-time SIFT
+        key(CriticalSIFT; "Customer No.") 
+        { 
+            SumIndexFields = Amount; 
+            MaintainSIFTIndex = true;  // Dashboard requirement
+        }
+        
+        // Secondary aggregations use on-demand calculation
+        key(ReportingSIFT; "Item No.") 
+        { 
+            SumIndexFields = Amount; 
+            MaintainSIFTIndex = false;  // Monthly reporting only
+        }
+    }
+}
+```
+
+#### ❌ Anti-Pattern 2: SIFT Without SumIndexFields
+```al
+// BAD: SIFT configuration without aggregation fields
+table 50105 "Empty SIFT Example (Bad)"
+{
+    keys
+    {
+        key(PK; ID) { }
+        key(BadSIFT; "Customer No.") 
+        { 
+            MaintainSIFTIndex = true;  // No SumIndexFields specified!
+            // Problem: Wastes storage and processing with no benefit
+        }
+    }
+}
+```
+
+#### ✅ Corrected Pattern 2: Proper SIFT Configuration
+```al
+// GOOD: SIFT with appropriate aggregation fields
+table 50106 "Proper SIFT Example (Good)"
+{
+    keys
+    {
+        key(PK; ID) { }
+        key(GoodSIFT; "Customer No.") 
+        { 
+            SumIndexFields = "Sales Amount", Quantity, "Profit Amount";
+            MaintainSIFTIndex = true;
+        }
+    }
+}
+```
+
+#### ❌ Anti-Pattern 3: Wrong MaintainSIFTIndex Setting
+```al
+// BAD: Real-time SIFT for batch processing scenario
+codeunit 50102 "Batch Import with Bad SIFT"
+{
+    procedure ImportLargeDataset()
+    var
+        DataRecord: Record "Over-SIFT Example (Bad)";
+        i: Integer;
+    begin
+        // Importing 100,000 records
+        for i := 1 to 100000 do begin
+            DataRecord.Init();
+            DataRecord.ID := i;
+            DataRecord.Amount := Random(1000);
+            DataRecord.Insert();  // Each insert updates multiple SIFT indexes!
+            // Performance impact: 10x slower than necessary
+        end;
+    end;
+}
+```
+
+#### ✅ Corrected Pattern 3: Appropriate SIFT for Usage Pattern
+```al
+// GOOD: On-demand SIFT for batch scenarios
+table 50107 "Batch-Optimized SIFT (Good)"
+{
+    keys
+    {
+        key(PK; ID) { }
+        key(BatchSIFT; "Data Type") 
+        { 
+            SumIndexFields = Amount;
+            MaintainSIFTIndex = false;  // Calculated after batch import
+        }
+    }
+}
+
+codeunit 50103 "Batch Import with Good SIFT"
+{
+    procedure ImportLargeDataset()
+    var
+        DataRecord: Record "Batch-Optimized SIFT (Good)";
+        i: Integer;
+    begin
+        // Fast import without real-time SIFT maintenance
+        for i := 1 to 100000 do begin
+            DataRecord.Init();
+            DataRecord.ID := i;
+            DataRecord.Amount := Random(1000);
+            DataRecord.Insert();  // No SIFT overhead during import
+        end;
+        
+        // Calculate aggregations on-demand after import
+        DataRecord.CalcSums(Amount);  // Uses SIFT for efficient calculation
+        Message('Total imported amount: %1', DataRecord.Amount);
+    end;
+}
+```
+
+## Best Practice Decision Matrix
+
+### SIFT Configuration Guidelines
+```al
+// Decision framework for SIFT configuration
+codeunit 50104 "SIFT Decision Framework"
+{
+    // Use this pattern to determine optimal SIFT settings
+    procedure RecommendSIFTSettings(ReadFrequency: Text; WriteFrequency: Text; DataVolume: Text): Text
+    begin
+        case true of
+            (ReadFrequency = 'High') and (WriteFrequency = 'Low'):
+                exit('MaintainSIFTIndex = true - Optimal for dashboards and real-time reporting');
+                
+            (ReadFrequency = 'Low') and (WriteFrequency = 'High'):
+                exit('MaintainSIFTIndex = false - Optimal for transaction processing systems');
+                
+            (ReadFrequency = 'Medium') and (WriteFrequency = 'Medium'):
+                exit('Test both settings and measure performance - Consider time-based switching');
+                
+            DataVolume = 'Very Large':
+                exit('MaintainSIFTIndex = false - Avoid real-time maintenance on large datasets');
+                
+            else
+                exit('Start with MaintainSIFTIndex = false and optimize based on actual usage patterns');
+        end;
+    end;
+}
+
+/*
+SIFT Performance Guidelines:
+
+1. Real-time SIFT (MaintainSIFTIndex = true):
+   - Best for: Dashboards, frequently accessed reports, user interface calculations
+   - Trade-off: Slower writes, faster reads
+   - Limit: Maximum 3-5 real-time SIFT keys per table
+
+2. On-demand SIFT (MaintainSIFTIndex = false):
+   - Best for: Periodic reporting, batch processing, large data imports
+   - Trade-off: Faster writes, acceptable read performance
+   - Benefit: No maintenance overhead during data modifications
+
+3. Monitoring and Optimization:
+   - Measure actual performance in production-like environments
+   - Monitor SIFT calculation times and data modification impact
+   - Consider data growth patterns when choosing SIFT strategy
+   - Review SIFT usage patterns quarterly and adjust as needed
+*/
+```