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

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

@@ -0,0 +1,316 @@
+# SetLoadFields Placement Before Case Statements - AL Code Samples
+
+## Basic Case Statement Placement
+```al
+codeunit 50400 "Case Statement Placement"
+{
+    procedure CorrectCaseStatementPattern()
+    var
+        SalesHeader: Record "Sales Header";
+    begin
+        // CORRECT: SetLoadFields before case statement evaluation
+        SalesHeader.SetLoadFields("Document Type", "No.", "Sell-to Customer Name", "Amount Including VAT");
+        SalesHeader.SetRange(Status, SalesHeader.Status::Open);
+        
+        if SalesHeader.FindSet() then
+            repeat
+                // Case statement after SetLoadFields - all needed fields already loaded
+                case SalesHeader."Document Type" of
+                    SalesHeader."Document Type"::Quote:
+                        ProcessQuote(SalesHeader."No.", SalesHeader."Sell-to Customer Name");
+                    SalesHeader."Document Type"::Order:
+                        ProcessOrder(SalesHeader."No.", SalesHeader."Sell-to Customer Name", SalesHeader."Amount Including VAT");
+                    SalesHeader."Document Type"::Invoice:
+                        ProcessInvoice(SalesHeader."No.", SalesHeader."Amount Including VAT");
+                    SalesHeader."Document Type"::"Credit Memo":
+                        ProcessCreditMemo(SalesHeader."No.", SalesHeader."Amount Including VAT");
+                end;
+            until SalesHeader.Next() = 0;
+    end;
+    
+    procedure IncorrectCaseStatementPattern()
+    var
+        SalesHeader: Record "Sales Header";
+    begin
+        // INCORRECT: SetLoadFields inside case statement branches
+        SalesHeader.SetRange(Status, SalesHeader.Status::Open);
+        
+        if SalesHeader.FindSet() then
+            repeat
+                case SalesHeader."Document Type" of
+                    SalesHeader."Document Type"::Quote:
+                        begin
+                            // SetLoadFields called too late - Document Type field already accessed for case evaluation
+                            SalesHeader.SetLoadFields("No.", "Sell-to Customer Name");
+                            ProcessQuote(SalesHeader."No.", SalesHeader."Sell-to Customer Name");
+                        end;
+                    SalesHeader."Document Type"::Order:
+                        begin
+                            SalesHeader.SetLoadFields("No.", "Sell-to Customer Name", "Amount Including VAT");
+                            ProcessOrder(SalesHeader."No.", SalesHeader."Sell-to Customer Name", SalesHeader."Amount Including VAT");
+                        end;
+                end;
+            until SalesHeader.Next() = 0;
+    end;
+
+    local procedure ProcessQuote(DocumentNo: Code[20]; CustomerName: Text[100])
+    begin
+        // Process quote
+    end;
+    
+    local procedure ProcessOrder(DocumentNo: Code[20]; CustomerName: Text[100]; Amount: Decimal)
+    begin
+        // Process order
+    end;
+    
+    local procedure ProcessInvoice(DocumentNo: Code[20]; Amount: Decimal)
+    begin
+        // Process invoice
+    end;
+    
+    local procedure ProcessCreditMemo(DocumentNo: Code[20]; Amount: Decimal)
+    begin
+        // Process credit memo
+    end;
+}
+```
+
+## Advanced Case Statement Patterns
+```al
+codeunit 50401 "Advanced Case Placement"
+{
+    procedure ComplexCaseStatementOptimization()
+    var
+        SalesLine: Record "Sales Line";
+    begin
+        // Load all fields that might be needed by any case branch
+        SalesLine.SetLoadFields("Document Type", "Document No.", "Line No.", "Type", "No.", 
+                               "Quantity", "Unit Price", "Line Amount");
+        SalesLine.SetRange("Document Type", SalesLine."Document Type"::Order);
+        
+        if SalesLine.FindSet() then
+            repeat
+                // Primary case statement for line type
+                case SalesLine.Type of
+                    SalesLine.Type::Item:
+                        ProcessItemLine(SalesLine);
+                    SalesLine.Type::Resource:
+                        ProcessResourceLine(SalesLine);
+                    SalesLine.Type::"G/L Account":
+                        ProcessGLAccountLine(SalesLine);
+                    SalesLine.Type::"Charge (Item)":
+                        ProcessItemChargeLine(SalesLine);
+                    else
+                        HandleUnknownLineType(SalesLine);
+                end;
+            until SalesLine.Next() = 0;
+    end;
+    
+    procedure NestedCaseStatementExample()
+    var
+        Item: Record Item;
+    begin
+        // SetLoadFields covers all fields needed by nested case statements
+        Item.SetLoadFields("No.", "Type", "Item Category Code", "Unit Price", "Inventory", "Blocked");
+        Item.SetRange("No.", '1000', '9999');
+        
+        if Item.FindSet() then
+            repeat
+                // Outer case statement
+                case Item.Type of
+                    Item.Type::Inventory,
+                    Item.Type::"Non-Inventory":
+                        begin
+                            // Inner case statement - fields already loaded
+                            case Item."Item Category Code" of
+                                'CHAIR':
+                                    ProcessChairItem(Item."No.", Item."Unit Price");
+                                'TABLE':
+                                    ProcessTableItem(Item."No.", Item.Inventory);
+                                'DESK':
+                                    ProcessDeskItem(Item."No.", Item."Unit Price", Item.Inventory);
+                                else
+                                    ProcessGeneralItem(Item."No.");
+                            end;
+                        end;
+                    Item.Type::Service:
+                        ProcessServiceItem(Item."No.", Item."Unit Price");
+                end;
+            until Item.Next() = 0;
+    end;
+
+    procedure ConditionalCaseStatements()
+    var
+        Customer: Record Customer;
+        ProcessHighPriority: Boolean;
+    begin
+        // SetLoadFields accounts for all possible case statement branches
+        Customer.SetLoadFields("No.", "Name", "Customer Posting Group", "Credit Limit (LCY)", 
+                               "Balance (LCY)", "Phone No.");
+        
+        ProcessHighPriority := Time > 120000T; // After noon, process high priority
+        
+        if Customer.FindSet() then
+            repeat
+                if ProcessHighPriority then begin
+                    // High priority case statement
+                    case Customer."Customer Posting Group" of
+                        'VIP':
+                            if Customer."Credit Limit (LCY)" > 100000 then
+                                ProcessVIPCustomer(Customer."No.", Customer.Name, Customer."Credit Limit (LCY)");
+                        'CORPORATE':
+                            ProcessCorporateCustomer(Customer."No.", Customer."Balance (LCY)");
+                    end;
+                end else begin
+                    // Standard priority case statement
+                    case Customer."Customer Posting Group" of
+                        'DOMESTIC':
+                            ProcessDomesticCustomer(Customer."No.", Customer.Name);
+                        'FOREIGN':
+                            ProcessForeignCustomer(Customer."No.", Customer."Phone No.");
+                    end;
+                end;
+            until Customer.Next() = 0;
+    end;
+
+    // Helper procedures for line processing
+    local procedure ProcessItemLine(var SalesLine: Record "Sales Line")
+    begin
+        // Item line processing using pre-loaded fields
+        Message('Processing Item Line: %1, Qty: %2', SalesLine."No.", SalesLine.Quantity);
+    end;
+    
+    local procedure ProcessResourceLine(var SalesLine: Record "Sales Line")
+    begin
+        // Resource line processing
+        Message('Processing Resource Line: %1, Amount: %2', SalesLine."No.", SalesLine."Line Amount");
+    end;
+    
+    local procedure ProcessGLAccountLine(var SalesLine: Record "Sales Line")
+    begin
+        // G/L Account line processing
+        Message('Processing G/L Account Line: %1', SalesLine."No.");
+    end;
+    
+    local procedure ProcessItemChargeLine(var SalesLine: Record "Sales Line")
+    begin
+        // Item charge processing
+        Message('Processing Item Charge Line: %1', SalesLine."No.");
+    end;
+    
+    local procedure HandleUnknownLineType(var SalesLine: Record "Sales Line")
+    begin
+        Error('Unknown line type for document %1, line %2', SalesLine."Document No.", SalesLine."Line No.");
+    end;
+
+    local procedure ProcessChairItem(ItemNo: Code[20]; UnitPrice: Decimal)
+    begin
+        Message('Chair Item: %1, Price: %2', ItemNo, UnitPrice);
+    end;
+
+    local procedure ProcessTableItem(ItemNo: Code[20]; Inventory: Decimal)
+    begin
+        Message('Table Item: %1, Inventory: %2', ItemNo, Inventory);
+    end;
+
+    local procedure ProcessDeskItem(ItemNo: Code[20]; UnitPrice: Decimal; Inventory: Decimal)
+    begin
+        Message('Desk Item: %1, Price: %2, Inventory: %3', ItemNo, UnitPrice, Inventory);
+    end;
+
+    local procedure ProcessGeneralItem(ItemNo: Code[20])
+    begin
+        Message('General Item: %1', ItemNo);
+    end;
+
+    local procedure ProcessServiceItem(ItemNo: Code[20]; UnitPrice: Decimal)
+    begin
+        Message('Service Item: %1, Price: %2', ItemNo, UnitPrice);
+    end;
+
+    local procedure ProcessVIPCustomer(CustomerNo: Code[20]; Name: Text[100]; CreditLimit: Decimal)
+    begin
+        Message('VIP Customer: %1 - %2, Credit Limit: %3', CustomerNo, Name, CreditLimit);
+    end;
+
+    local procedure ProcessCorporateCustomer(CustomerNo: Code[20]; Balance: Decimal)
+    begin
+        Message('Corporate Customer: %1, Balance: %2', CustomerNo, Balance);
+    end;
+
+    local procedure ProcessDomesticCustomer(CustomerNo: Code[20]; Name: Text[100])
+    begin
+        Message('Domestic Customer: %1 - %2', CustomerNo, Name);
+    end;
+
+    local procedure ProcessForeignCustomer(CustomerNo: Code[20]; PhoneNo: Text[30])
+    begin
+        Message('Foreign Customer: %1, Phone: %2', CustomerNo, PhoneNo);
+    end;
+}
+```
+
+## Performance Impact Analysis
+```al
+codeunit 50402 "Case Statement Performance"
+{
+    procedure DemonstratePerformanceImpact()
+    var
+        Item: Record Item;
+        StartTime: DateTime;
+        EndTime: DateTime;
+    begin
+        // Scenario 1: SetLoadFields after case statement evaluation (inefficient)
+        StartTime := CurrentDateTime();
+        Item.SetRange("Item Category Code", 'CHAIR');
+        
+        if Item.FindSet() then
+            repeat
+                // Item Category Code accessed before SetLoadFields - loads all fields
+                case Item."Item Category Code" of
+                    'CHAIR':
+                        begin
+                            Item.SetLoadFields("No.", "Unit Price"); // Too late
+                            ProcessChairItem(Item."No.", Item."Unit Price");
+                        end;
+                    'TABLE':
+                        begin
+                            Item.SetLoadFields("No.", "Inventory"); // Too late
+                            ProcessTableItem(Item."No.", Item.Inventory);
+                        end;
+                end;
+            until Item.Next() = 0;
+        EndTime := CurrentDateTime();
+        Message('Inefficient approach: %1 ms', EndTime - StartTime);
+        
+        // Scenario 2: SetLoadFields before case statement evaluation (efficient)
+        StartTime := CurrentDateTime();
+        Item.Reset();
+        Item.SetLoadFields("Item Category Code", "No.", "Unit Price", "Inventory"); // Before case evaluation
+        Item.SetRange("Item Category Code", 'CHAIR');
+        
+        if Item.FindSet() then
+            repeat
+                // Item Category Code already loaded efficiently
+                case Item."Item Category Code" of
+                    'CHAIR':
+                        ProcessChairItem(Item."No.", Item."Unit Price");
+                    'TABLE':
+                        ProcessTableItem(Item."No.", Item.Inventory);
+                end;
+            until Item.Next() = 0;
+        EndTime := CurrentDateTime();
+        Message('Efficient approach: %1 ms', EndTime - StartTime);
+    end;
+    
+    local procedure ProcessChairItem(ItemNo: Code[20]; UnitPrice: Decimal)
+    begin
+        // Process chair item
+    end;
+    
+    local procedure ProcessTableItem(ItemNo: Code[20]; Inventory: Decimal)
+    begin
+        // Process table item
+    end;
+}
+```

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

@@ -0,0 +1,223 @@
+# SetLoadFields Placement Before Filters - AL Code Samples
+
+## Basic Before Filter Placement
+```al
+codeunit 50300 "Before Filter Placement"
+{
+    procedure CorrectPlacementExample()
+    var
+        SalesHeader: Record "Sales Header";
+    begin
+        // CORRECT: SetLoadFields called before any filters
+        SalesHeader.SetLoadFields("No.", "Sell-to Customer Name", "Amount Including VAT");
+        
+        // Filters applied after SetLoadFields
+        SalesHeader.SetRange("Sell-to Customer No.", '10000', '50000');
+        SalesHeader.SetRange("Document Date", WorkDate() - 30, WorkDate());
+        SalesHeader.SetRange(Status, SalesHeader.Status::Open);
+        
+        if SalesHeader.FindSet() then
+            repeat
+                ProcessOrder(SalesHeader."No.", SalesHeader."Sell-to Customer Name", SalesHeader."Amount Including VAT");
+            until SalesHeader.Next() = 0;
+    end;
+    
+    procedure IncorrectPlacementExample()
+    var
+        SalesHeader: Record "Sales Header";
+    begin
+        // INCORRECT: Filters applied before SetLoadFields
+        SalesHeader.SetRange("Sell-to Customer No.", '10000', '50000');
+        SalesHeader.SetRange("Document Date", WorkDate() - 30, WorkDate());
+        
+        // SetLoadFields called after filters - may not be fully effective
+        SalesHeader.SetLoadFields("No.", "Sell-to Customer Name", "Amount Including VAT");
+        SalesHeader.SetRange(Status, SalesHeader.Status::Open);
+        
+        if SalesHeader.FindSet() then
+            repeat
+                ProcessOrder(SalesHeader."No.", SalesHeader."Sell-to Customer Name", SalesHeader."Amount Including VAT");
+            until SalesHeader.Next() = 0;
+    end;
+
+    procedure MultipleFilterSetExample()
+    var
+        Item: Record Item;
+    begin
+        // SetLoadFields must be first, before any filtering operations
+        Item.SetLoadFields("No.", "Description", "Unit Price", "Inventory");
+        
+        // Multiple filter operations - all after SetLoadFields
+        Item.SetRange("No.", '1000', '9999');
+        Item.SetFilter("Last Date Modified", '>=%1', CalcDate('-6M', WorkDate()));
+        Item.SetFilter("Item Category Code", 'CHAIR|TABLE|DESK');
+        Item.SetFilter("Unit Price", '>=%1', 50);
+        
+        if Item.FindSet() then
+            repeat
+                ProcessInventoryItem(Item."No.", Item.Description, Item."Unit Price", Item.Inventory);
+            until Item.Next() = 0;
+    end;
+
+    local procedure ProcessOrder(OrderNo: Code[20]; CustomerName: Text[100]; Amount: Decimal)
+    begin
+        // Process order data
+    end;
+
+    local procedure ProcessInventoryItem(ItemNo: Code[20]; Description: Text[100]; UnitPrice: Decimal; Inventory: Decimal)
+    begin
+        // Process inventory item
+    end;
+}
+```
+
+## Advanced Placement Patterns
+```al
+codeunit 50301 "Advanced Filter Placement"
+{
+    procedure ConditionalFilteringExample(CustomerNo: Code[20]; IncludeShipped: Boolean)
+    var
+        SalesHeader: Record "Sales Header";
+    begin
+        // SetLoadFields always first, regardless of conditional logic
+        SalesHeader.SetLoadFields("No.", "Sell-to Customer Name", "Amount Including VAT", "Shipment Date");
+        
+        // Base filters
+        SalesHeader.SetRange("Sell-to Customer No.", CustomerNo);
+        SalesHeader.SetRange("Document Date", WorkDate() - 90, WorkDate());
+        
+        // Conditional filters - still after SetLoadFields
+        if not IncludeShipped then
+            SalesHeader.SetRange("Completely Shipped", false);
+            
+        if SalesHeader.FindSet() then
+            repeat
+                ProcessCustomerOrder(SalesHeader."No.", SalesHeader."Sell-to Customer Name", 
+                                   SalesHeader."Amount Including VAT", SalesHeader."Shipment Date");
+            until SalesHeader.Next() = 0;
+    end;
+    
+    procedure ResetAndRefilterExample()
+    var
+        Customer: Record Customer;
+    begin
+        // Initial setup with SetLoadFields first
+        Customer.SetLoadFields("No.", "Name", "Credit Limit (LCY)");
+        Customer.SetRange("No.", '10000', '30000');
+        
+        ProcessCustomerSet(Customer, 'First batch');
+        
+        // When resetting filters, SetLoadFields should be called again if changing field selection
+        Customer.Reset();
+        Customer.SetLoadFields("No.", "Name", "Phone No."); // Different fields
+        Customer.SetRange("No.", '40000', '60000');
+        
+        ProcessCustomerSet(Customer, 'Second batch');
+    end;
+
+    procedure DynamicFilteringExample()
+    var
+        Item: Record Item;
+        FilterCategoryCode: Code[20];
+        FilterBlocked: Boolean;
+        i: Integer;
+    begin
+        // SetLoadFields established before any dynamic filtering
+        Item.SetLoadFields("No.", "Description", "Item Category Code", "Unit Price");
+        
+        // Dynamic filtering loop - filters change but SetLoadFields remains effective
+        for i := 1 to 3 do begin
+            case i of
+                1: FilterCategoryCode := 'CHAIR';
+                2: FilterCategoryCode := 'TABLE';
+                3: FilterCategoryCode := 'DESK';
+            end;
+            FilterBlocked := i mod 2 = 0; // Alternate blocked status
+            
+            Item.Reset();
+            Item.SetRange("Item Category Code", FilterCategoryCode);
+            Item.SetRange(Blocked, FilterBlocked);
+            
+            ProcessItemSet(Item, StrSubstNo('Category %1', FilterCategoryCode));
+        end;
+    end;
+
+    local procedure ProcessCustomerOrder(OrderNo: Code[20]; CustomerName: Text[100]; Amount: Decimal; ShipmentDate: Date)
+    begin
+        // Process customer order
+    end;
+    
+    local procedure ProcessCustomerSet(var Customer: Record Customer; BatchName: Text)
+    begin
+        if Customer.FindSet() then
+            repeat
+                // Process customer based on loaded fields
+                Message('Processing %1: Customer %2', BatchName, Customer."No.");
+            until Customer.Next() = 0;
+    end;
+
+    local procedure ProcessItemSet(var Item: Record Item; BatchName: Text)
+    begin
+        if Item.FindSet() then
+            repeat
+                // Process item based on loaded fields
+                Message('Processing %1: Item %2 - %3', BatchName, Item."No.", Item.Description);
+            until Item.Next() = 0;
+    end;
+}
+```
+
+## Common Placement Mistakes
+```al
+codeunit 50302 "Filter Placement Mistakes"
+{
+    procedure MistakeExample_FiltersFirst()
+    var
+        Customer: Record Customer;
+    begin
+        // MISTAKE: Applying filters before SetLoadFields
+        Customer.SetRange("No.", '10000');
+        Customer.SetRange("Customer Posting Group", 'DOMESTIC');
+        
+        // SetLoadFields less effective when called after filters
+        Customer.SetLoadFields("No.", "Name", "Credit Limit (LCY)");
+        
+        // This works but is suboptimal
+        if Customer.FindSet() then
+            repeat
+                ProcessCustomer(Customer."No.", Customer.Name, Customer."Credit Limit (LCY)");
+            until Customer.Next() = 0;
+    end;
+    
+    procedure BestPracticePattern()
+    var
+        Customer: Record Customer;
+    begin
+        // BEST PRACTICE: Clear separation of concerns
+        // 1. Field loading configuration
+        Customer.SetLoadFields("No.", "Name", "Credit Limit (LCY)", "Phone No.");
+        
+        // 2. Data filtering
+        Customer.SetRange("No.", '10000', '50000');
+        Customer.SetFilter("Last Date Modified", '>=%1', CalcDate('-3M', WorkDate()));
+        Customer.SetRange("Customer Posting Group", 'DOMESTIC');
+        
+        // 3. Data processing
+        if Customer.FindSet() then
+            repeat
+                ProcessCustomerWithPhone(Customer."No.", Customer.Name, 
+                                        Customer."Credit Limit (LCY)", Customer."Phone No.");
+            until Customer.Next() = 0;
+    end;
+
+    local procedure ProcessCustomer(CustomerNo: Code[20]; Name: Text[100]; CreditLimit: Decimal)
+    begin
+        // Process basic customer data
+    end;
+
+    local procedure ProcessCustomerWithPhone(CustomerNo: Code[20]; Name: Text[100]; CreditLimit: Decimal; PhoneNo: Text[30])
+    begin
+        // Process customer with phone information
+    end;
+}
+```

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

@@ -0,0 +1,149 @@
+# SetLoadFields Filter Field Exclusion - AL Code Samples
+
+## Basic Filter Field Exclusion
+```al
+codeunit 50200 "Filter Field Exclusion Examples"
+{
+    procedure ExcludeFilterFieldsBasic()
+    var
+        Customer: Record Customer;
+    begin
+        // Exclude filter fields from loading - they're used for filtering only
+        Customer.SetLoadFields("Name", "Credit Limit (LCY)", "Phone No.");
+        
+        // Filter fields (No., Customer Posting Group) not loaded - filtering uses cached values
+        Customer.SetRange("No.", '10000', '20000');
+        Customer.SetRange("Customer Posting Group", 'DOMESTIC');
+        Customer.SetRange("Blocked", Customer.Blocked::" ");
+        
+        if Customer.FindSet() then
+            repeat
+                // Only non-filter fields loaded, improving performance
+                ProcessCustomerData(Customer.Name, Customer."Credit Limit (LCY)", Customer."Phone No.");
+            until Customer.Next() = 0;
+    end;
+
+    procedure ComplexFilterExclusion()
+    var
+        Item: Record Item;
+    begin
+        // Complex filtering scenario - exclude all filter fields from loading
+        Item.SetLoadFields("Description", "Unit Price", "Inventory");
+        
+        // Multiple filter fields - all excluded from SetLoadFields
+        Item.SetRange("No.", '1000', '9999');
+        Item.SetFilter("Item Category Code", 'CHAIR|TABLE|DESK');
+        Item.SetRange("Blocked", false);
+        Item.SetFilter("Unit Price", '>%1', 100);
+        Item.SetRange("Type", Item.Type::Inventory);
+        
+        if Item.FindSet() then
+            repeat
+                // Filter fields available for validation but not loaded from database
+                if ShouldProcessItem(Item."No.", Item."Item Category Code") then
+                    ProcessItemData(Item.Description, Item."Unit Price", Item.Inventory);
+            until Item.Next() = 0;
+    end;
+
+    procedure ConditionalFilterExclusion(IncludeFilterFields: Boolean)
+    var
+        SalesLine: Record "Sales Line";
+    begin
+        if IncludeFilterFields then
+            // When filter fields needed for processing, include them
+            SalesLine.SetLoadFields("Document No.", "Line No.", "Type", "No.", "Quantity", "Unit Price")
+        else
+            // When filter fields not needed for processing, exclude them
+            SalesLine.SetLoadFields("Quantity", "Unit Price");
+            
+        SalesLine.SetRange("Document Type", SalesLine."Document Type"::Order);
+        SalesLine.SetRange("Document No.", 'SO001');
+        SalesLine.SetRange("Type", SalesLine.Type::Item);
+        
+        if SalesLine.FindSet() then
+            repeat
+                if IncludeFilterFields then
+                    ProcessWithFilterData(SalesLine."Document No.", SalesLine."No.", SalesLine.Quantity)
+                else
+                    ProcessWithoutFilterData(SalesLine.Quantity, SalesLine."Unit Price");
+            until SalesLine.Next() = 0;
+    end;
+
+    local procedure ProcessCustomerData(Name: Text[100]; CreditLimit: Decimal; PhoneNo: Text[30])
+    begin
+        // Process loaded customer data
+    end;
+
+    local procedure ShouldProcessItem(ItemNo: Code[20]; CategoryCode: Code[20]): Boolean
+    begin
+        exit((ItemNo <> '') and (CategoryCode <> ''));
+    end;
+
+    local procedure ProcessItemData(Description: Text[100]; UnitPrice: Decimal; Inventory: Decimal)
+    begin
+        // Process non-filter item data
+    end;
+
+    local procedure ProcessWithFilterData(DocumentNo: Code[20]; ItemNo: Code[20]; Quantity: Decimal)
+    begin
+        // Process including filter field data
+    end;
+
+    local procedure ProcessWithoutFilterData(Quantity: Decimal; UnitPrice: Decimal)
+    begin
+        // Process excluding filter field data
+    end;
+}
+```
+
+## Performance Impact Examples
+```al
+codeunit 50201 "Filter Exclusion Performance"
+{
+    procedure DemonstratePerformanceImpact()
+    var
+        Customer: Record Customer;
+        StartTime: DateTime;
+        EndTime: DateTime;
+    begin
+        // Scenario 1: Including filter fields unnecessarily
+        StartTime := CurrentDateTime();
+        Customer.SetLoadFields(); // Loads all fields including filters
+        Customer.SetRange("No.", '10000', '50000');
+        Customer.SetRange("Customer Posting Group", 'DOMESTIC');
+        
+        if Customer.FindSet() then
+            repeat
+                // Only using non-filter fields but all were loaded
+                ProcessCustomerSales(Customer.Name, Customer."Credit Limit (LCY)");
+            until Customer.Next() = 0;
+        EndTime := CurrentDateTime();
+        LogPerformance('With filter fields loaded', EndTime - StartTime);
+        
+        // Scenario 2: Excluding filter fields appropriately
+        StartTime := CurrentDateTime();
+        Customer.Reset();
+        Customer.SetLoadFields("Name", "Credit Limit (LCY)"); // Exclude filter fields
+        Customer.SetRange("No.", '10000', '50000');
+        Customer.SetRange("Customer Posting Group", 'DOMESTIC');
+        
+        if Customer.FindSet() then
+            repeat
+                // Only non-filter fields loaded, better performance
+                ProcessCustomerSales(Customer.Name, Customer."Credit Limit (LCY)");
+            until Customer.Next() = 0;
+        EndTime := CurrentDateTime();
+        LogPerformance('With filter fields excluded', EndTime - StartTime);
+    end;
+
+    local procedure ProcessCustomerSales(Name: Text[100]; CreditLimit: Decimal)
+    begin
+        // Process customer sales data
+    end;
+
+    local procedure LogPerformance(Scenario: Text; Duration: Duration)
+    begin
+        Message('%1: %2 ms', Scenario, Duration);
+    end;
+}
+```