bc-code-intelligence-mcp 1.1.1

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

@@ -0,0 +1,412 @@
+# SetLoadFields Performance Optimization - AL Code Examples
+
+## Basic SetLoadFields Implementation
+
+```al
+// Optimized: Load only required fields
+procedure GetCustomerNameOptimized(CustomerNo: Code[20]): Text[100]
+var
+    Customer: Record Customer;
+begin
+    Customer.SetLoadFields(Name);
+    if Customer.Get(CustomerNo) then
+        exit(Customer.Name);
+    exit('');
+end;
+
+// Non-optimized: Loads all fields
+procedure GetCustomerNameUnoptimized(CustomerNo: Code[20]): Text[100]
+var
+    Customer: Record Customer;
+begin
+    if Customer.Get(CustomerNo) then
+        exit(Customer.Name);
+    exit('');
+end;
+```
+
+## Bulk Operations Optimization
+
+```al
+procedure ProcessCustomerListOptimized()
+var
+    Customer: Record Customer;
+    ProcessedCount: Integer;
+begin
+    Customer.SetLoadFields("No.", Name, "Customer Posting Group", Blocked);
+
+    if Customer.FindSet() then
+        repeat
+            if not Customer.Blocked then begin
+                ProcessCustomerRecord(Customer."No.", Customer.Name, Customer."Customer Posting Group");
+                ProcessedCount += 1;
+            end;
+        until Customer.Next() = 0;
+
+    Message('Processed %1 customers with optimized field loading', ProcessedCount);
+end;
+
+procedure ProcessCustomerListUnoptimized()
+var
+    Customer: Record Customer;
+    ProcessedCount: Integer;
+begin
+    if Customer.FindSet() then
+        repeat
+            if not Customer.Blocked then begin
+                ProcessCustomerRecord(Customer."No.", Customer.Name, Customer."Customer Posting Group");
+                ProcessedCount += 1;
+            end;
+        until Customer.Next() = 0;
+
+    Message('Processed %1 customers with full field loading', ProcessedCount);
+end;
+```
+
+## Report Generation with Selective Loading
+
+```al
+procedure GenerateCustomerReportOptimized()
+var
+    Customer: Record Customer;
+    ReportData: JsonObject;
+    CustomerArray: JsonArray;
+    CustomerJson: JsonObject;
+begin
+    Customer.SetLoadFields("No.", Name, "Phone No.", "E-Mail", "Country/Region Code", "Credit Limit (LCY)");
+
+    if Customer.FindSet() then
+        repeat
+            Clear(CustomerJson);
+            CustomerJson.Add('number', Customer."No.");
+            CustomerJson.Add('name', Customer.Name);
+            CustomerJson.Add('phone', Customer."Phone No.");
+            CustomerJson.Add('email', Customer."E-Mail");
+            CustomerJson.Add('country', Customer."Country/Region Code");
+            CustomerJson.Add('creditLimit', Customer."Credit Limit (LCY)");
+            CustomerArray.Add(CustomerJson);
+        until Customer.Next() = 0;
+
+    ReportData.Add('customers', CustomerArray);
+end;
+```
+
+## Advanced Memory Optimization
+
+```al
+procedure ProcessSalesOrdersWithItems()
+var
+    SalesHeader: Record "Sales Header";
+    SalesLine: Record "Sales Line";
+    OrderCount: Integer;
+    LineCount: Integer;
+begin
+    SalesHeader.SetLoadFields("No.", "Sell-to Customer No.", "Order Date", "Amount Including VAT");
+    SalesHeader.SetRange("Document Type", SalesHeader."Document Type"::Order);
+
+    if SalesHeader.FindSet() then
+        repeat
+            OrderCount += 1;
+
+            SalesLine.SetLoadFields("Document No.", "Line No.", "No.", Quantity, "Unit Price", "Line Amount");
+            SalesLine.SetRange("Document Type", SalesLine."Document Type"::Order);
+            SalesLine.SetRange("Document No.", SalesHeader."No.");
+
+            if SalesLine.FindSet() then
+                repeat
+                    LineCount += 1;
+                    ProcessSalesLineData(SalesLine."No.", SalesLine.Quantity, SalesLine."Unit Price");
+                until SalesLine.Next() = 0;
+
+        until SalesHeader.Next() = 0;
+
+    Message('Processed %1 orders with %2 lines using optimized field loading', OrderCount, LineCount);
+end;
+```
+
+## Conditional Field Loading
+
+```al
+procedure ProcessCustomersConditional(IncludeFinancialData: Boolean; IncludeContactData: Boolean)
+var
+    Customer: Record Customer;
+    FieldList: List of [Integer];
+begin
+    FieldList.Add(Customer.FieldNo("No."));
+    FieldList.Add(Customer.FieldNo(Name));
+
+    if IncludeFinancialData then begin
+        FieldList.Add(Customer.FieldNo("Credit Limit (LCY)"));
+        FieldList.Add(Customer.FieldNo("Balance (LCY)"));
+        FieldList.Add(Customer.FieldNo("Sales (LCY)"));
+    end;
+
+    if IncludeContactData then begin
+        FieldList.Add(Customer.FieldNo("Phone No."));
+        FieldList.Add(Customer.FieldNo("E-Mail"));
+        FieldList.Add(Customer.FieldNo("Contact"));
+    end;
+
+    Customer.SetLoadFields(FieldList);
+
+    if Customer.FindSet() then
+        repeat
+            ProcessCustomerConditionally(Customer, IncludeFinancialData, IncludeContactData);
+        until Customer.Next() = 0;
+end;
+```
+
+## Performance Comparison
+
+```al
+procedure CompareMemoryUsage()
+var
+    Customer: Record Customer;
+    StartTime: DateTime;
+    EndTime: DateTime;
+    RecordCount: Integer;
+begin
+    // Test 1: With SetLoadFields optimization
+    StartTime := CurrentDateTime;
+    Customer.SetLoadFields("No.", Name);
+    if Customer.FindSet() then
+        repeat
+            RecordCount += 1;
+            ProcessBasicCustomerInfo(Customer."No.", Customer.Name);
+        until Customer.Next() = 0;
+    EndTime := CurrentDateTime;
+
+    Message('Optimized: Processed %1 records in %2 ms', RecordCount, EndTime - StartTime);
+
+    // Test 2: Without SetLoadFields
+    Clear(Customer);
+    RecordCount := 0;
+    StartTime := CurrentDateTime;
+    if Customer.FindSet() then
+        repeat
+            RecordCount += 1;
+            ProcessBasicCustomerInfo(Customer."No.", Customer.Name);
+        until Customer.Next() = 0;
+    EndTime := CurrentDateTime;
+
+    Message('Unoptimized: Processed %1 records in %2 ms', RecordCount, EndTime - StartTime);
+end;
+```
+
+## Query Efficiency Demonstration
+
+```al
+procedure DemonstrateQueryEfficiency()
+var
+    Item: Record Item;
+    ItemCount: Integer;
+    FilteredCount: Integer;
+begin
+    Item.SetLoadFields("No.", Description, "Unit Price", "Inventory Posting Group", Blocked);
+    Item.SetFilter("Unit Price", '>%1', 100);
+    Item.SetRange(Blocked, false);
+
+    if Item.FindSet() then
+        repeat
+            ItemCount += 1;
+            if StrPos(Item.Description, 'PREMIUM') > 0 then begin
+                FilteredCount += 1;
+                ProcessPremiumItem(Item."No.", Item.Description, Item."Unit Price");
+            end;
+        until Item.Next() = 0;
+
+    Message('Found %1 premium items from %2 total items using optimized loading', FilteredCount, ItemCount);
+end;
+```
+
+## Anti-Pattern Examples
+
+```al
+// ❌ ANTI-PATTERN: Loading unnecessary fields
+procedure AntiPatternUnnecessaryFields()
+var
+    Customer: Record Customer;
+begin
+    Customer.SetLoadFields("No.", Name, "Phone No.", "E-Mail", "Address", "City",
+                          "Credit Limit (LCY)", "Balance (LCY)", "Sales (LCY)");
+
+    if Customer.FindSet() then
+        repeat
+            ProcessBasicCustomerInfo(Customer."No.", Customer.Name);
+        until Customer.Next() = 0;
+end;
+
+// ❌ ANTI-PATTERN: Not using SetLoadFields in loops
+procedure AntiPatternNoOptimizationInLoops()
+var
+    SalesHeader: Record "Sales Header";
+    Customer: Record Customer;
+begin
+    if SalesHeader.FindSet() then
+        repeat
+            if Customer.Get(SalesHeader."Sell-to Customer No.") then
+                ProcessCustomerInOrder(Customer.Name, Customer."Credit Limit (LCY)");
+        until SalesHeader.Next() = 0;
+end;
+
+// ✅ CORRECTED: Proper SetLoadFields usage
+procedure CorrectedOptimizationInLoops()
+var
+    SalesHeader: Record "Sales Header";
+    Customer: Record Customer;
+begin
+    SalesHeader.SetLoadFields("No.", "Sell-to Customer No.");
+
+    if SalesHeader.FindSet() then
+        repeat
+            Customer.SetLoadFields(Name, "Credit Limit (LCY)");
+            if Customer.Get(SalesHeader."Sell-to Customer No.") then
+                ProcessCustomerInOrder(Customer.Name, Customer."Credit Limit (LCY)");
+        until SalesHeader.Next() = 0;
+end;
+```
+
+## Performance Impact Measurement
+
+```al
+procedure MeasureAntiPatternImpact()
+var
+    Item: Record Item;
+    ItemLedgerEntry: Record "Item Ledger Entry";
+    StartTime: DateTime;
+    EndTime: DateTime;
+    EntryCount: Integer;
+begin
+    StartTime := CurrentDateTime;
+
+    if ItemLedgerEntry.FindSet() then
+        repeat
+            EntryCount += 1;
+            if Item.Get(ItemLedgerEntry."Item No.") then begin
+                ProcessItemLedgerWithDescription(ItemLedgerEntry."Entry No.", Item.Description);
+            end;
+        until (ItemLedgerEntry.Next() = 0) or (EntryCount > 1000);
+
+    EndTime := CurrentDateTime;
+    Message('Anti-pattern: Processed %1 entries in %2 ms', EntryCount, EndTime - StartTime);
+
+    ProcessItemLedgerOptimized();
+end;
+
+local procedure ProcessItemLedgerOptimized()
+var
+    Item: Record Item;
+    ItemLedgerEntry: Record "Item Ledger Entry";
+    StartTime: DateTime;
+    EndTime: DateTime;
+    EntryCount: Integer;
+begin
+    StartTime := CurrentDateTime;
+
+    ItemLedgerEntry.SetLoadFields("Entry No.", "Item No.");
+    Item.SetLoadFields(Description);
+
+    if ItemLedgerEntry.FindSet() then
+        repeat
+            EntryCount += 1;
+            if Item.Get(ItemLedgerEntry."Item No.") then
+                ProcessItemLedgerWithDescription(ItemLedgerEntry."Entry No.", Item.Description);
+        until (ItemLedgerEntry.Next() = 0) or (EntryCount > 1000);
+
+    EndTime := CurrentDateTime;
+    Message('Optimized: Processed %1 entries in %2 ms', EntryCount, EndTime - StartTime);
+end;
+```
+
+## Best Practice Implementation
+
+```al
+procedure BestPracticeImplementation()
+var
+    Customer: Record Customer;
+    ProcessedCount: Integer;
+    ErrorCount: Integer;
+begin
+    Customer.SetLoadFields("No.", Name, "Customer Posting Group", Blocked);
+
+    if Customer.FindSet() then
+        repeat
+            if ProcessCustomerSafely(Customer) then
+                ProcessedCount += 1
+            else
+                ErrorCount += 1;
+        until Customer.Next() = 0;
+
+    if ErrorCount > 0 then
+        Message('Processed %1 customers successfully, %2 errors encountered', ProcessedCount, ErrorCount);
+end;
+
+local procedure ProcessCustomerSafely(Customer: Record Customer): Boolean
+begin
+    if (Customer."No." = '') or (Customer.Name = '') then
+        exit(false);
+
+    if Customer.Blocked then
+        exit(true);
+
+    ProcessBasicCustomerInfo(Customer."No.", Customer.Name);
+    exit(true);
+end;
+```
+
+## Dynamic Field Loading
+
+```al
+procedure DynamicFieldLoading(ProcessingMode: Option Basic,Extended,Full)
+var
+    Customer: Record Customer;
+    FieldsToLoad: List of [Integer];
+begin
+    FieldsToLoad.Add(Customer.FieldNo("No."));
+    FieldsToLoad.Add(Customer.FieldNo(Name));
+
+    case ProcessingMode of
+        ProcessingMode::Extended:
+            begin
+                FieldsToLoad.Add(Customer.FieldNo("Phone No."));
+                FieldsToLoad.Add(Customer.FieldNo("E-Mail"));
+            end;
+        ProcessingMode::Full:
+            begin
+                FieldsToLoad.Add(Customer.FieldNo("Phone No."));
+                FieldsToLoad.Add(Customer.FieldNo("E-Mail"));
+                FieldsToLoad.Add(Customer.FieldNo("Credit Limit (LCY)"));
+                FieldsToLoad.Add(Customer.FieldNo("Balance (LCY)"));
+            end;
+    end;
+
+    Customer.SetLoadFields(FieldsToLoad);
+
+    if Customer.FindSet() then
+        repeat
+            ProcessCustomerByMode(Customer, ProcessingMode);
+        until Customer.Next() = 0;
+end;
+```
+
+## Performance Guidelines Summary
+
+### Implementation Strategy
+1. **Analyze field usage** before applying SetLoadFields
+2. **Load minimal field sets** required for processing
+3. **Apply early** - call SetLoadFields immediately after record declaration
+4. **Measure impact** - validate performance improvements
+5. **Document rationale** - explain field selection decisions
+
+### Memory Optimization Benefits
+- 70-90% memory reduction for large recordsets
+- Improved garbage collection performance
+- Better system scalability with reduced memory pressure
+- Faster record processing with smaller data structures
+
+### Common Mistakes to Avoid
+1. Loading fields "just in case" without actual usage
+2. Forgetting SetLoadFields in nested record lookups
+3. Excluding primary key fields needed for record operations
+4. Applying optimization to small datasets where overhead exceeds benefits
+5. Not measuring actual performance improvement

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

@@ -0,0 +1,211 @@
+# SetLoadFields Performance Optimization - AL Examples
+
+## Basic Usage Pattern
+
+```al
+codeunit 50100 "SetLoadFields Examples"
+{
+    // Basic SetLoadFields usage for loading only needed fields
+    procedure GetCustomerNameAndPhone(CustomerNo: Code[20]): Text
+    var
+        Customer: Record Customer;
+        Result: Text;
+    begin
+        Customer.Get(CustomerNo);
+
+        // Load only the fields we actually need
+        Customer.SetLoadFields(Name, "Phone No.");
+        Customer.Find(); // Refresh with partial loading
+
+        Result := Customer.Name + ' - ' + Customer."Phone No.";
+        exit(Result);
+    end;
+}
+```
+
+## Performance Impact Demonstration
+
+### Before: Full Record Loading
+```al
+// Traditional approach - loads all 100+ fields from Customer table
+procedure ProcessCustomerListSlow()
+var
+    Customer: Record Customer;
+    ProcessedCount: Integer;
+begin
+    // This loads ALL fields for each customer record
+    // Network overhead: ~8KB per record for full Customer table
+    // Memory usage: Significant for large datasets
+    if Customer.FindSet() then
+        repeat
+            // Only using Name and "No." but loaded entire record
+            if Customer.Name <> '' then
+                ProcessedCount += 1;
+        until Customer.Next() = 0;
+
+    Message('Processed %1 customers (slow method)', ProcessedCount);
+end;
+```
+
+### After: Optimized with SetLoadFields
+```al
+// Optimized approach - loads only required fields
+procedure ProcessCustomerListFast()
+var
+    Customer: Record Customer;
+    ProcessedCount: Integer;
+begin
+    // Load only the fields we actually use
+    Customer.SetLoadFields("No.", Name);
+
+    // Network overhead: ~50 bytes per record (vs 8KB)
+    // Memory usage: 99% reduction for this scenario
+    // Performance gain: 10-50x faster depending on table size
+    if Customer.FindSet() then
+        repeat
+            if Customer.Name <> '' then
+                ProcessedCount += 1;
+        until Customer.Next() = 0;
+
+    Message('Processed %1 customers (fast method)', ProcessedCount);
+end;
+```
+
+## Anti-Pattern: Field Access After SetLoadFields
+
+```al
+// WRONG: Accessing fields not included in SetLoadFields
+procedure CustomerAnalysisAntiPattern(CustomerNo: Code[20])
+var
+    Customer: Record Customer;
+begin
+    Customer.Get(CustomerNo);
+
+    // Only load basic fields
+    Customer.SetLoadFields("No.", Name);
+    Customer.Find();
+
+    // BAD: Accessing field not in SetLoadFields causes additional database hit
+    // This negates the performance benefit and adds overhead
+    if Customer."Credit Limit (LCY)" > 0 then  // Database hit here!
+        Message('Customer %1 has credit limit', Customer.Name);
+
+    // WORSE: Multiple unloaded field accesses = multiple database hits
+    Customer."Phone No.";           // Database hit!
+    Customer."E-Mail";              // Another database hit!
+    Customer."VAT Registration No."; // Yet another database hit!
+end;
+
+// CORRECT: Include all needed fields in SetLoadFields
+procedure CustomerAnalysisCorrectPattern(CustomerNo: Code[20])
+var
+    Customer: Record Customer;
+begin
+    Customer.Get(CustomerNo);
+
+    // Load ALL fields we plan to use
+    Customer.SetLoadFields("No.", Name, "Credit Limit (LCY)", "Phone No.", "E-Mail", "VAT Registration No.");
+    Customer.Find();
+
+    // Now all field accesses are served from memory - no additional database hits
+    if Customer."Credit Limit (LCY)" > 0 then
+        Message('Customer %1 (%2) has credit limit. Contact: %3',
+                Customer.Name, Customer."VAT Registration No.", Customer."E-Mail");
+end;
+```
+
+## Batch Processing Optimization
+
+```al
+// SetLoadFields optimization for processing large datasets
+procedure OptimizeBatchCustomerUpdate()
+var
+    Customer: Record Customer;
+    SalesHeader: Record "Sales Header";
+    UpdateCount: Integer;
+begin
+    // Scenario: Update customer last sale date based on sales orders
+    // Performance critical when processing thousands of records
+
+    // Step 1: Optimize customer record loading
+    Customer.SetLoadFields("No.", "Last Date Modified");
+
+    if Customer.FindSet(true) then  // Modifiable RecordSet
+        repeat
+            // Step 2: Optimize sales header lookup - only need posting date
+            SalesHeader.SetRange("Sell-to Customer No.", Customer."No.");
+            SalesHeader.SetRange("Document Type", SalesHeader."Document Type"::Order);
+            SalesHeader.SetLoadFields("Posting Date");
+
+            if SalesHeader.FindLast() then begin
+                // Only modify if there's an actual change
+                if Customer."Last Date Modified" <> SalesHeader."Posting Date" then begin
+                    Customer."Last Date Modified" := SalesHeader."Posting Date";
+                    Customer.Modify();  // Only updates loaded fields + modified fields
+                    UpdateCount += 1;
+                end;
+            end;
+        until Customer.Next() = 0;
+
+    Message('Updated %1 customer records', UpdateCount);
+end;
+```
+
+## Performance Monitoring Example
+
+```al
+// Measure SetLoadFields impact
+procedure MeasureSetLoadFieldsImpact()
+var
+    Customer: Record Customer;
+    StartTime: DateTime;
+    EndTime: DateTime;
+    RecordCount: Integer;
+begin
+    // Test 1: Traditional full record loading
+    StartTime := CurrentDateTime;
+    RecordCount := 0;
+
+    if Customer.FindSet() then
+        repeat
+            RecordCount += 1;
+        until Customer.Next() = 0;
+
+    EndTime := CurrentDateTime;
+    Message('Full loading: %1 records in %2ms', RecordCount, EndTime - StartTime);
+
+    // Test 2: Optimized with SetLoadFields
+    StartTime := CurrentDateTime;
+    RecordCount := 0;
+    Customer.Reset();
+    Customer.SetLoadFields("No.");  // Minimal field loading
+
+    if Customer.FindSet() then
+        repeat
+            RecordCount += 1;
+        until Customer.Next() = 0;
+
+    EndTime := CurrentDateTime;
+    Message('SetLoadFields: %1 records in %2ms', RecordCount, EndTime - StartTime);
+
+    // Typical results: 70-90% performance improvement for large datasets
+end;
+```
+
+**Performance Guidelines:**
+
+1. **SetLoadFields Benefits**:
+   - Network traffic reduction: 80-95% for wide tables
+   - Memory usage reduction: Proportional to excluded fields
+   - Query performance: Faster due to less data transfer
+
+2. **Best Practices**:
+   - Always include primary key fields
+   - Plan field usage before calling SetLoadFields
+   - Use SetLoadFields before FindSet() for maximum benefit
+   - Avoid accessing non-loaded fields after SetLoadFields
+
+3. **Performance Impact**:
+   - Small datasets (<1000 records): 20-50% improvement
+   - Medium datasets (1000-10000 records): 50-300% improvement
+   - Large datasets (>10000 records): 300-1000% improvement