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

package/embedded-knowledge/domains/dean-debug/samples/maintainsiftindex-examples.md

@@ -0,0 +1,340 @@
+# MaintainSIFTIndex Property Examples
+
+## Real-time SIFT Configuration (MaintainSIFTIndex=Yes)
+
+### Dashboard-Optimized Table
+```al
+table 50100 "Sales Dashboard Data"
+{
+    Caption = 'Sales Dashboard Data';
+    DataClassification = CustomerContent;
+
+    fields
+    {
+        field(1; "Entry No."; Integer) { AutoIncrement = true; }
+        field(10; "Customer No."; Code[20]) { TableRelation = Customer; }
+        field(20; "Sales Amount"; Decimal) { DecimalPlaces = 2 : 2; }
+        field(30; "Quantity"; Decimal) { DecimalPlaces = 0 : 5; }
+        field(40; "Posting Date"; Date) { }
+    }
+
+    keys
+    {
+        key(PK; "Entry No.") { Clustered = true; }
+        
+        // Real-time SIFT for dashboard performance
+        key(CustomerSIFT; "Customer No.")
+        {
+            SumIndexFields = "Sales Amount", Quantity;
+            MaintainSIFTIndex = true; // Updated in real-time for instant dashboard access
+        }
+    }
+}
+
+// Dashboard page leveraging real-time SIFT
+page 50100 "Sales Dashboard"
+{
+    PageType = RoleCenter;
+    SourceTable = Customer;
+
+    layout
+    {
+        area(content)
+        {
+            cuegroup("Sales Performance")
+            {
+                field("Total Sales"; GetCustomerSales())
+                {
+                    Caption = 'Total Sales';
+                    // Leverages real-time SIFT - no calculation delay
+                }
+            }
+        }
+    }
+
+    local procedure GetCustomerSales(): Decimal
+    var
+        SalesDashboard: Record "Sales Dashboard Data";
+    begin
+        SalesDashboard.SetRange("Customer No.", Rec."No.");
+        SalesDashboard.CalcSums("Sales Amount"); // Uses real-time SIFT
+        exit(SalesDashboard."Sales Amount");
+    end;
+}
+```
+
+## Batch Processing Optimized (MaintainSIFTIndex=No)
+
+### Import-Heavy Data Table
+```al
+table 50101 "Import Processing Data"
+{
+    Caption = 'Import Processing Data';
+    DataClassification = CustomerContent;
+
+    fields
+    {
+        field(1; ID; Integer) { AutoIncrement = true; }
+        field(10; "Batch ID"; Code[20]) { }
+        field(20; Amount; Decimal) { DecimalPlaces = 2 : 2; }
+        field(30; "Process Date"; Date) { }
+    }
+
+    keys
+    {
+        key(PK; ID) { Clustered = true; }
+        
+        // On-demand SIFT for batch import optimization
+        key(BatchSIFT; "Batch ID")
+        {
+            SumIndexFields = Amount;
+            MaintainSIFTIndex = false; // No real-time overhead during imports
+        }
+    }
+}
+
+// Fast batch import with deferred aggregation
+codeunit 50100 "Batch Import Manager"
+{
+    procedure ProcessLargeBatch(BatchID: Code[20]; RecordCount: Integer)
+    var
+        ImportData: Record "Import Processing Data";
+        i: Integer;
+        StartTime: DateTime;
+        ImportDuration: Duration;
+        TotalAmount: Decimal;
+    begin
+        StartTime := CurrentDateTime;
+        
+        // Fast import without SIFT maintenance overhead
+        for i := 1 to RecordCount do begin
+            ImportData.Init();
+            ImportData."Batch ID" := BatchID;
+            ImportData.Amount := Random(1000);
+            ImportData."Process Date" := Today;
+            ImportData.Insert(); // No SIFT updates during import
+        end;
+        
+        ImportDuration := CurrentDateTime - StartTime;
+        
+        // Calculate totals using on-demand SIFT after import
+        ImportData.Reset();
+        ImportData.SetRange("Batch ID", BatchID);
+        ImportData.CalcSums(Amount); // SIFT built on first calculation
+        TotalAmount := ImportData.Amount;
+        
+        Message('Imported %1 records in %2ms\nTotal Amount: %3',
+                RecordCount, ImportDuration, TotalAmount);
+    end;
+}
+```
+
+## Dynamic SIFT Management
+
+### Context-Aware SIFT Configuration
+```al
+table 50102 "Flexible Analytics Data"
+{
+    Caption = 'Flexible Analytics Data';
+    DataClassification = CustomerContent;
+
+    fields
+    {
+        field(1; ID; Integer) { AutoIncrement = true; }
+        field(10; "Department Code"; Code[10]) { }
+        field(20; "Transaction Amount"; Decimal) { }
+        field(30; "Transaction Date"; Date) { }
+    }
+
+    keys
+    {
+        key(PK; ID) { Clustered = true; }
+        
+        // SIFT configuration varies by usage mode
+        key(DepartmentAnalytics; "Department Code")
+        {
+            SumIndexFields = "Transaction Amount";
+            // MaintainSIFTIndex set dynamically based on system mode
+        }
+    }
+}
+
+// Dynamic SIFT management based on system state
+codeunit 50101 "Dynamic SIFT Manager"
+{
+    procedure SetSIFTModeForReporting()
+    begin
+        // Enable real-time SIFT during reporting periods
+        SetTableSIFTMode(Database::"Flexible Analytics Data", true);
+        Message('SIFT enabled for real-time reporting');
+    end;
+    
+    procedure SetSIFTModeForDataEntry()
+    begin
+        // Disable real-time SIFT during data entry periods
+        SetTableSIFTMode(Database::"Flexible Analytics Data", false);
+        Message('SIFT disabled for fast data entry');
+    end;
+    
+    local procedure SetTableSIFTMode(TableID: Integer; EnableRealTime: Boolean)
+    var
+        TableMetadata: Record "Table Metadata";
+        KeyRef: KeyRef;
+        RecRef: RecordRef;
+    begin
+        RecRef.Open(TableID);
+        KeyRef := RecRef.KeyIndex(2); // Department Analytics key
+        
+        if EnableRealTime then
+            KeyRef.SetProperty(Property::MaintainSIFTIndex, true)
+        else
+            KeyRef.SetProperty(Property::MaintainSIFTIndex, false);
+            
+        RecRef.Close();
+    end;
+}
+```
+
+## Performance Comparison Implementation
+
+### SIFT Impact Measurement
+```al
+table 50103 "SIFT Performance Log"
+{
+    Caption = 'SIFT Performance Log';
+    DataClassification = CustomerContent;
+
+    fields
+    {
+        field(1; "Log Entry No."; Integer) { AutoIncrement = true; }
+        field(10; "Test Type"; Option) { OptionMembers = "With SIFT","Without SIFT"; }
+        field(20; "Execution Time (ms)"; Integer) { }
+        field(30; "Record Count"; Integer) { }
+        field(40; "Memory Usage (MB)"; Decimal) { }
+        field(50; "Test Date"; DateTime) { }
+    }
+
+    keys
+    {
+        key(PK; "Log Entry No.") { }
+        key(TestAnalysis; "Test Type", "Test Date") { }
+    }
+}
+
+// Performance testing framework
+codeunit 50102 "SIFT Performance Tester"
+{
+    procedure CompareSIFTPerformance(TestRecords: Integer)
+    var
+        TestDataWithSIFT: Record "Sales Dashboard Data";
+        TestDataWithoutSIFT: Record "Import Processing Data";
+        PerformanceLog: Record "SIFT Performance Log";
+        StartTime: DateTime;
+        EndTime: DateTime;
+        TestAmount: Decimal;
+    begin
+        // Test 1: With real-time SIFT
+        StartTime := CurrentDateTime;
+        TestDataWithSIFT.Reset();
+        TestDataWithSIFT.CalcSums("Sales Amount");
+        TestAmount := TestDataWithSIFT."Sales Amount";
+        EndTime := CurrentDateTime;
+        
+        LogPerformanceResult(PerformanceLog."Test Type"::"With SIFT", 
+                           EndTime - StartTime, TestRecords);
+        
+        // Test 2: Without real-time SIFT (forces calculation)
+        StartTime := CurrentDateTime;
+        TestDataWithoutSIFT.Reset();
+        TestDataWithoutSIFT.CalcSums(Amount); // Triggers on-demand calculation
+        TestAmount := TestDataWithoutSIFT.Amount;
+        EndTime := CurrentDateTime;
+        
+        LogPerformanceResult(PerformanceLog."Test Type"::"Without SIFT", 
+                           EndTime - StartTime, TestRecords);
+    end;
+    
+    local procedure LogPerformanceResult(TestType: Option; Duration: Duration; RecordCount: Integer)
+    var
+        PerformanceLog: Record "SIFT Performance Log";
+    begin
+        PerformanceLog.Init();
+        PerformanceLog."Test Type" := TestType;
+        PerformanceLog."Execution Time (ms)" := Duration;
+        PerformanceLog."Record Count" := RecordCount;
+        PerformanceLog."Test Date" := CurrentDateTime;
+        PerformanceLog.Insert();
+    end;
+}
+```
+
+## Best Practice Decision Examples
+
+### Workload-Based Configuration
+```al
+// Configuration patterns for different scenarios
+codeunit 50103 "SIFT Configuration Patterns"
+{
+    // Pattern 1: High-frequency dashboard
+    procedure ConfigureForDashboard()
+    var
+        ConfigNote: Text;
+    begin
+        ConfigNote := 'Dashboard Pattern: MaintainSIFTIndex = true\n' +
+                     '- Read/Write Ratio: 50:1\n' +
+                     '- Update Frequency: Every few minutes\n' +
+                     '- Query Frequency: Constant (dashboard refresh)\n' +
+                     '- Justification: Real-time updates essential for UX';
+        Message(ConfigNote);
+    end;
+    
+    // Pattern 2: Batch processing system
+    procedure ConfigureForBatchProcessing()
+    var
+        ConfigNote: Text;
+    begin
+        ConfigNote := 'Batch Pattern: MaintainSIFTIndex = false\n' +
+                     '- Read/Write Ratio: 1:100\n' +
+                     '- Update Frequency: Continuous during batch\n' +
+                     '- Query Frequency: After batch completion\n' +
+                     '- Justification: Import speed more important than query speed';
+        Message(ConfigNote);
+    end;
+    
+    // Pattern 3: Mixed-mode system
+    procedure ConfigureForMixedMode()
+    var
+        ConfigNote: Text;
+    begin
+        ConfigNote := 'Mixed Pattern: Time-based switching\n' +
+                     '- Business hours: MaintainSIFTIndex = true (reporting)\n' +
+                     '- Off hours: MaintainSIFTIndex = false (batch jobs)\n' +
+                     '- Scheduled switching based on business cycles\n' +
+                     '- Justification: Optimize for primary usage per time period';
+        Message(ConfigNote);
+    end;
+}
+
+/*
+MaintainSIFTIndex Decision Framework:
+
+1. Analysis Questions:
+   - What is the read-to-write ratio for this data?
+   - How frequently are aggregations requested?
+   - Are there specific time periods with different usage patterns?
+   - What are the performance requirements for both reads and writes?
+
+2. Configuration Guidelines:
+   - Read-heavy (10:1 ratio or higher): MaintainSIFTIndex = true
+   - Write-heavy (1:10 ratio or higher): MaintainSIFTIndex = false
+   - Balanced (1:1 to 10:1): Test both and measure actual performance
+   - Time-sensitive queries: MaintainSIFTIndex = true
+   - Batch processing: MaintainSIFTIndex = false
+
+3. Monitoring and Adjustment:
+   - Measure actual performance in production-like environments
+   - Monitor both query response times and data modification speeds
+   - Review usage patterns quarterly
+   - Adjust configuration as business processes evolve
+*/
+```