Most recent edit on 2007-09-20 17:50:58 by InformaPlus [Spacing]
No differences.
Edited on 2007-09-20 17:49:51 by InformaPlus [Center Image 2]
No differences.
Edited on 2007-09-20 17:48:31 by InformaPlus [Center image]
Additions:
Deletions:
Edited on 2007-09-19 22:59:08 by InformaPlus [Photo from flickr]
Additions:
Deletions:
Edited on 2007-09-19 22:32:46 by InformaPlus [Picture pointer]
Additions:
Deletions:
Edited on 2007-09-18 22:12:47 by InformaPlus [Code Formatter]
Additions:
Update, Running Total (of Category Totals), Exp=Value, How=Incr
Deletions:
Update, Running Total’ of ‘Category Totals’, Exp=Value, How=Incr
Edited on 2007-09-18 22:10:38 by InformaPlus [Recover]
Additions:
Complete Incremental Update Mechanism:
The example previously presented is a simple example in the sense that only one ‘Running total’ may be updated as a result of a user interaction with one detailed row. There are more sophisticated cases where up to two ‘Running Totals’ may need to be updated. In such case, the incremental logic not only needs to factor Original and Final values but also original and final ‘Running Totals’.
Example 2: Supports updating two ‘Running Totals’ in one engine cycle:
To illustrate such need and associated capability, we will add a new ‘Category’ field (Alpha 1) to the ‘List_of_Values’ table previously introduced. Now let’s say that we want accumulate many ‘Running totals’, one for each category in the following separate table:
Table Name: Category Totals
1) Category Code: Alpha (1)
2) Running Total: Numeric (7)
The running total must be maintained and saved as the running total of all the rows assigned to the associated category.
Index: By Category Code (Unique)
The logic to perform in this context is very similar to what was presented to maintain one overall ‘Running Total’. However there is an additional consideration. In modify mode, It must also consider and factor the fact that the ‘Category Code’ of a detailed row can be modified and furthermore can be modified together with the ‘Value’ on this detailed row.
To factor this possibility of a change of ‘Category Code’, the modify mode incremental logic must be slightly enhanced as follow:
Upon modifying the value on an existing line, the engine will perform the following to updates:
1) Reduce the original Category ‘Running Total’ (of the ‘Category Totals’ table) by the original Value.
2) Increase the final Category ‘Running Total’ (of the ‘Category Totals’ table) by the final value.
- Coming back on a line with Category (1) and value (20), modifying the Category to become (2) and the value to become (10), the engine will do the following:
- Reduce the Category (1) original Running Total by the original value of 20.
- Increase the Category (2) final Running Total by the final value of 10.
Notice that two separate rows were updated as a result of the above.
Adding the accumulation logic in our eDeveloper task example, can be done with the following:
1) Add the ‘Category Code’ column added to the ‘List_of_Values’ table to the Data View and form.
2) Add one (but only one) Link Write to the ‘Category Totals’ table after the above ‘Category Code’.
3) In the above Link:
- Locate Init:, From: and to: the ‘Category Code’ of the ‘List_of_Values’
- Select the ‘Running Total’ column.
4) In the Record Suffix, after the update of the overall ‘Running Total’ add the following:
Update, Running Total’ of ‘Category Totals’, Exp=Value, How=Incr
At this point it is preferable to manually delete (from a <Ctrl+G>) all the rows from the ‘List_of_Values’ table before executing the program. This will avoid the creation of a blank ‘Category Code’ row building up a negative ‘Running Total’ value as you assign Categories currently set to blank.
You can now run the program and experience how the incremental fields are all being updated as you assign or modify categories values to each detail.
Notice that only one ‘Link Write’ operation in the Data View and one associated new ‘Update Incremental’ operation in the ‘Record Suffix’ is sufficient to handle all possible scenarios.
Deletions:
Basic Incremental Update Mechanism:
We will illustrate the essence of the Incremental Update mechanism through a simple example.
Example 1: Simple ‘Running Total’.
In this example we will simply accumulate a ‘Running Total’ for list of numerical values entered and maintained by a user in an online task.
Let’s consider the following table with two columns:
Table: List_of_Values
1) Code: Alpha (2)
2) Value: Numeric (5)
Provided the table is empty at the time of executing the process described hereafter.
Lets describe a process that allows basic maintenance with regular Creation, Modification and Deletion capabilities at row level during an Online, Line mode session.
In addition to the above, the process must maintain and display an accurate and up to date ‘Running Total’ of all the values entered during the online session.
Logical Considerations:
Before describing how the above running total can be maintained in an eDeveloper task, lets describe the procedural details required to achieve such result:
1) Upon creating a new line (Create mode), the value entered on the new row must be added to the ‘Running Total’ accumulator.
Example:
- Creating a first line in the table with a value of a hundred (100) results in adding this value to the originally (0) ‘Running Total’ value. The result is Running Total = 0 + 100 = 100.
- Creating a Second line in the same table with a value of a fifty (50) results in adding this value to the actual (100) ‘Running Total’ value. The result is Running Total = 100 + 50 = 150.
- Creating a third line in the same table with a value of a twenty (20) results in adding this value to the actual (150) ‘Running Total’ value. The result is Running Total = 150+ 20 = 170.
2) Upon deleting a line, the value that was on this line (prior to its deletion) must be subtracted from the ‘Running Total’ accumulator.
Deleting the second line (value of 50) of our ongoing example, results in subtracting this value from the actual (170) ‘Running Total’ value. The result is Running Total = 170 – 50 = 120.
3) Upon modifying the value on an existing line, the Net Difference of the modification must be applied to the ‘Running Total’ accumulator. The Net Difference can be described further as:
Net Difference = Final Value – Original Value
For Example:
- Coming back on the line with (20) as the value, modifying this value to make it (30), results in applying the Net Difference (30 - 20=10) to the actual (120) ‘Running Total’ value.
The result is: Running Total = 120 + (30-20) = 120 + 10 = 130
Notice that the Net Difference can be negative if a Value is modified as such that the Final Value is less than the original Value.
- Coming back on the first line with (100) as the value, modifying this value to make it (60), results in applying the Net Difference (60 - 100= -40) to the actual (130) ‘Running Total’ value.
The result is: Running Total = 130 + (60-100) = 130 - 40 = 90
Comments and observations:
1) The above sequence is quite simple to predict, However, it does reveal that even a simple ‘Running Total’ accumulation process must take care of a several scenarios and adjust its execution accordingly in order to guaranty an accurate result.
2) If we list what is required to be known at each accumulation step in order to perform the right calculations, we get:
- The Current Mode of execution (Create, Modify or Delete).
- The Original value of the ‘Value’ field.
- The Final value of the ‘Value’ field.
3) The items of the above list are all items that the eDeveloper engine knows and keeps track of at all time. The Stat() and the Varprev() functions are evidence of such fact.
4) Therefore, it is correct to conclude that the eDeveloper engine knows and is already maintaining everything that is necessary to be able to handle complete and accurate accumulation (“Incremental”) processing.
eDeveloper is not only able to process “Incremental” logic, It actually does it all for us provided we instruct it to:
- Do ‘Incremental’ logic rather than just doing direct assignation of a value.
- Refer to what needs to be accumulated. In our case the ‘Value’ column is what must be accumulated into the ‘Running Total’.
Update, How = Incremental:
We will now describe how simple it is to add to an eDeveloper task what would support the above-described example.
First create a simple program that provides regular line mode access and maintenance to the List_of_Values table. This can be done through the following steps:
1) Create the previously described memory table with the two columns mentioned (Code and Value)
2) Generate a new program on the above table:
- Browse Online
- Line mode
- With the two columns selected.
To add the ‘Running Total’ and associated processing logic, we do the following:
1) Add the following:
- Data View (Record Main): Add a virtual Column: Running Total, Numeric (7).
- In the form editor: Add a control on the form bound to the new ‘Running Total’ variable.
2) In the Record Suffix add the following operation:
Update, Running Total, Exp=Value, How=Incr
The ‘How=Incr’ parameter is what will trigger the engine to perform ‘Incremental’ accumulation rather that direct assignation logic. The expression referring to the ‘Value’ column informs the engine of the seed (detailed subject) of the accumulation. This will vary from one process to the other and is the responsibility of the developer to properly identify and specify. But the engine automatically and accurately performs everything else.
3) Run the program and see how the running total is properly maintained and displayed as the user enters and modify information on the screen.
Edited on 2007-09-18 21:54:48 by InformaPlus [Cf 3]
Additions:
Basic Incremental Update Mechanism:
We will illustrate the essence of the Incremental Update mechanism through a simple example.
Example 1: Simple ‘Running Total’.
In this example we will simply accumulate a ‘Running Total’ for list of numerical values entered and maintained by a user in an online task.
Let’s consider the following table with two columns:
Table: List_of_Values
1) Code: Alpha (2)
2) Value: Numeric (5)
Provided the table is empty at the time of executing the process described hereafter.
Lets describe a process that allows basic maintenance with regular Creation, Modification and Deletion capabilities at row level during an Online, Line mode session.
In addition to the above, the process must maintain and display an accurate and up to date ‘Running Total’ of all the values entered during the online session.
Logical Considerations:
Before describing how the above running total can be maintained in an eDeveloper task, lets describe the procedural details required to achieve such result:
1) Upon creating a new line (Create mode), the value entered on the new row must be added to the ‘Running Total’ accumulator.
Example:
- Creating a first line in the table with a value of a hundred (100) results in adding this value to the originally (0) ‘Running Total’ value. The result is Running Total = 0 + 100 = 100.
- Creating a Second line in the same table with a value of a fifty (50) results in adding this value to the actual (100) ‘Running Total’ value. The result is Running Total = 100 + 50 = 150.
- Creating a third line in the same table with a value of a twenty (20) results in adding this value to the actual (150) ‘Running Total’ value. The result is Running Total = 150+ 20 = 170.
2) Upon deleting a line, the value that was on this line (prior to its deletion) must be subtracted from the ‘Running Total’ accumulator.
Deleting the second line (value of 50) of our ongoing example, results in subtracting this value from the actual (170) ‘Running Total’ value. The result is Running Total = 170 – 50 = 120.
3) Upon modifying the value on an existing line, the Net Difference of the modification must be applied to the ‘Running Total’ accumulator. The Net Difference can be described further as:
Net Difference = Final Value – Original Value
For Example:
- Coming back on the line with (20) as the value, modifying this value to make it (30), results in applying the Net Difference (30 - 20=10) to the actual (120) ‘Running Total’ value.
The result is: Running Total = 120 + (30-20) = 120 + 10 = 130
Notice that the Net Difference can be negative if a Value is modified as such that the Final Value is less than the original Value.
- Coming back on the first line with (100) as the value, modifying this value to make it (60), results in applying the Net Difference (60 - 100= -40) to the actual (130) ‘Running Total’ value.
The result is: Running Total = 130 + (60-100) = 130 - 40 = 90
Comments and observations:
1) The above sequence is quite simple to predict, However, it does reveal that even a simple ‘Running Total’ accumulation process must take care of a several scenarios and adjust its execution accordingly in order to guaranty an accurate result.
2) If we list what is required to be known at each accumulation step in order to perform the right calculations, we get:
- The Current Mode of execution (Create, Modify or Delete).
- The Original value of the ‘Value’ field.
- The Final value of the ‘Value’ field.
3) The items of the above list are all items that the eDeveloper engine knows and keeps track of at all time. The Stat() and the Varprev() functions are evidence of such fact.
4) Therefore, it is correct to conclude that the eDeveloper engine knows and is already maintaining everything that is necessary to be able to handle complete and accurate accumulation (“Incremental”) processing.
eDeveloper is not only able to process “Incremental” logic, It actually does it all for us provided we instruct it to:
- Do ‘Incremental’ logic rather than just doing direct assignation of a value.
- Refer to what needs to be accumulated. In our case the ‘Value’ column is what must be accumulated into the ‘Running Total’.
Update, How = Incremental:
We will now describe how simple it is to add to an eDeveloper task what would support the above-described example.
First create a simple program that provides regular line mode access and maintenance to the List_of_Values table. This can be done through the following steps:
1) Create the previously described memory table with the two columns mentioned (Code and Value)
2) Generate a new program on the above table:
- Browse Online
- Line mode
- With the two columns selected.
To add the ‘Running Total’ and associated processing logic, we do the following:
1) Add the following:
- Data View (Record Main): Add a virtual Column: Running Total, Numeric (7).
- In the form editor: Add a control on the form bound to the new ‘Running Total’ variable.
2) In the Record Suffix add the following operation:
Update, Running Total, Exp=Value, How=Incr
The ‘How=Incr’ parameter is what will trigger the engine to perform ‘Incremental’ accumulation rather that direct assignation logic. The expression referring to the ‘Value’ column informs the engine of the seed (detailed subject) of the accumulation. This will vary from one process to the other and is the responsibility of the developer to properly identify and specify. But the engine automatically and accurately performs everything else.
3) Run the program and see how the running total is properly maintained and displayed as the user enters and modify information on the screen.
Deletions:
Complete Incremental Update Mechanism:
The example previously presented is a simple example in the sense that only one ‘Running total’ may be updated as a result of a user interaction with one detailed row. There are more sophisticated cases where up to two ‘Running Totals’ may need to be updated. In such case, the incremental logic not only needs to factor Original and Final values but also original and final ‘Running Totals’.
Example 2: Supports updating two ‘Running Totals’ in one engine cycle:
To illustrate such need and associated capability, we will add a new ‘Category’ field (Alpha 1) to the ‘List_of_Values’ table previously introduced. Now let’s say that we want accumulate many ‘Running totals’, one for each category in the following separate table:
Table Name: Category Totals
1) Category Code: Alpha (1)
2) Running Total: Numeric (7)
The running total must be maintained and saved as the running total of all the rows assigned to the associated category.
Index: By Category Code (Unique)
The logic to perform in this context is very similar to what was presented to maintain one overall ‘Running Total’. However there is an additional consideration. In modify mode, It must also consider and factor the fact that the ‘Category Code’ of a detailed row can be modified and furthermore can be modified together with the ‘Value’ on this detailed row.
To factor this possibility of a change of ‘Category Code’, the modify mode incremental logic must be slightly enhanced as follow:
Upon modifying the value on an existing line, the engine will perform the following to updates:
1) Reduce the original Category ‘Running Total’ (of the ‘Category Totals’ table) by the original Value.
2) Increase the final Category ‘Running Total’ (of the ‘Category Totals’ table) by the final value.
- Coming back on a line with Category (1) and value (20), modifying the Category to become (2) and the value to become (10), the engine will do the following:
- Reduce the Category (1) original Running Total by the original value of 20.
- Increase the Category (2) final Running Total by the final value of 10.
Notice that two separate rows were updated as a result of the above.
Adding the accumulation logic in our eDeveloper task example, can be done with the following:
1) Add the ‘Category Code’ column added to the ‘List_of_Values’ table to the Data View and form.
2) Add one (but only one) Link Write to the ‘Category Totals’ table after the above ‘Category Code’.
3) In the above Link:
- Locate Init:, From: and to: the ‘Category Code’ of the ‘List_of_Values’
- Select the ‘Running Total’ column.
4) In the Record Suffix, after the update of the overall ‘Running Total’ add the following:
Update, Running Total’ of ‘Category Totals’, Exp=Value, How=Incr
At this point it is preferable to manually delete (from a <Ctrl+G>) all the rows from the ‘List_of_Values’ table before executing the program. This will avoid the creation of a blank ‘Category Code’ row building up a negative ‘Running Total’ value as you assign Categories currently set to blank.
You can now run the program and experience how the incremental fields are all being updated as you assign or modify categories values to each detail.
Notice that only one ‘Link Write’ operation in the Data View and one associated new ‘Update Incremental’ operation in the ‘Record Suffix’ is sufficient to handle all possible scenarios.
Edited on 2007-09-18 21:53:35 by InformaPlus [Cf 2]
Additions:
Update, Running Total’ of ‘Category Totals’, Exp=Value, How=Incr
Deletions:
Update, ‘Running Total’ of ‘Category Totals’, Exp=Value, How=Incr
Edited on 2007-09-18 21:51:29 by InformaPlus [Code formater]
Additions:
Update, ‘Running Total’ of ‘Category Totals’, Exp=Value, How=Incr
Deletions:
Update, ‘Running Total’ of ‘Category Totals’, Exp=Value, How=Incr
Edited on 2007-09-18 21:38:00 by InformaPlus [List 1]
Additions:
- Coming back on a line with Category (1) and value (20), modifying the Category to become (2) and the value to become (10), the engine will do the following:
- Reduce the Category (1) original Running Total by the original value of 20.
- Increase the Category (2) final Running Total by the final value of 10.
- Locate Init:, From: and to: the ‘Category Code’ of the ‘List_of_Values’
- Select the ‘Running Total’ column.
Deletions:
· Coming back on a line with Category (1) and value (20), modifying the Category to become (2) and the value to become (10), the engine will do the following:
· Reduce the Category (1) original Running Total by the original value of 20.
· Increase the Category (2) final Running Total by the final value of 10.
· Locate Init:, From: and to: the ‘Category Code’ of the ‘List_of_Values’
· Select the ‘Running Total’ column.
Edited on 2007-09-18 21:24:48 by InformaPlus [Correcting Photo 4]
No differences.
Edited on 2007-09-18 21:23:44 by InformaPlus [Correcting Photo 3]
No differences.
Edited on 2007-09-18 21:22:31 by InformaPlus [Correcting Photo 2]
No differences.
Edited on 2007-09-18 21:20:22 by InformaPlus [Correcting Photo 1]
Additions:
Deletions:
Edited on 2007-09-18 21:17:59 by InformaPlus [Add pointer to image]
Additions:
The example previously presented is a simple example in the sense that only one ‘Running total’ may be updated as a result of a user interaction with one detailed row. There are more sophisticated cases where up to two ‘Running Totals’ may need to be updated. In such case, the incremental logic not only needs to factor Original and Final values but also original and final ‘Running Totals’.
Example 2: Supports updating two ‘Running Totals’ in one engine cycle:
To illustrate such need and associated capability, we will add a new ‘Category’ field (Alpha 1) to the ‘List_of_Values’ table previously introduced. Now let’s say that we want accumulate many ‘Running totals’, one for each category in the following separate table:
The logic to perform in this context is very similar to what was presented to maintain one overall ‘Running Total’. However there is an additional consideration. In modify mode, It must also consider and factor the fact that the ‘Category Code’ of a detailed row can be modified and furthermore can be modified together with the ‘Value’ on this detailed row.
To factor this possibility of a change of ‘Category Code’, the modify mode incremental logic must be slightly enhanced as follow:
1) Reduce the original Category ‘Running Total’ (of the ‘Category Totals’ table) by the original Value.
2) Increase the final Category ‘Running Total’ (of the ‘Category Totals’ table) by the final value.
1) Add the ‘Category Code’ column added to the ‘List_of_Values’ table to the Data View and form.
2) Add one (but only one) Link Write to the ‘Category Totals’ table after the above ‘Category Code’.
· Locate Init:, From: and to: the ‘Category Code’ of the ‘List_of_Values’
· Select the ‘Running Total’ column.
4) In the Record Suffix, after the update of the overall ‘Running Total’ add the following:
Update, ‘Running Total’ of ‘Category Totals’, Exp=Value, How=Incr
At this point it is preferable to manually delete (from a <Ctrl+G>) all the rows from the ‘List_of_Values’ table before executing the program. This will avoid the creation of a blank ‘Category Code’ row building up a negative ‘Running Total’ value as you assign Categories currently set to blank.
Notice that only one ‘Link Write’ operation in the Data View and one associated new ‘Update Incremental’ operation in the ‘Record Suffix’ is sufficient to handle all possible scenarios.
Deletions:
The example previously presented is a simple example in the sense that only one ‘Running total’ may be updated as a result of a user interaction with one detailed row. There are more sophisticated cases where up to two ‘Running Totals’ may need to be updated. In such case, the incremental logic not only needs to factor Original and Final values but also original and final ‘Running Totals’.
Example 2: Supports updating two ‘Running Totals’ in one engine cycle:
To illustrate such need and associated capability, we will add a new ‘Category’ field (Alpha 1) to the ‘List_of_Values’ table previously introduced. Now let’s say that we want accumulate many ‘Running totals’, one for each category in the following separate table:
The logic to perform in this context is very similar to what was presented to maintain one overall ‘Running Total’. However there is an additional consideration. In modify mode, It must also consider and factor the fact that the ‘Category Code’ of a detailed row can be modified and furthermore can be modified together with the ‘Value’ on this detailed row.
To factor this possibility of a change of ‘Category Code’, the modify mode incremental logic must be slightly enhanced as follow:
1) Reduce the original Category ‘Running Total’ (of the ‘Category Totals’ table) by the original Value.
2) Increase the final Category ‘Running Total’ (of the ‘Category Totals’ table) by the final value.
1) Add the ‘Category Code’ column added to the ‘List_of_Values’ table to the Data View and form.
2) Add one (but only one) Link Write to the ‘Category Totals’ table after the above ‘Category Code’.
· Locate Init:, From: and to: the ‘Category Code’ of the ‘List_of_Values’
· Select the ‘Running Total’ column.
4) In the Record Suffix, after the update of the overall ‘Running Total’ add the following:
Update, ‘Running Total’ of ‘Category Totals’, Exp=Value, How=Incr
At this point it is preferable to manually delete (from a <Ctrl+G>) all the rows from the ‘List_of_Values’ table before executing the program. This will avoid the creation of a blank ‘Category Code’ row building up a negative ‘Running Total’ value as you assign Categories currently set to blank.
Notice that only one ‘Link Write’ operation in the Data View and one associated new ‘Update Incremental’ operation in the ‘Record Suffix’ is sufficient to handle all possible scenarios.
Edited on 2007-09-17 22:15:26 by InformaPlus [C1]
Additions:
Example 2: Supports updating two ‘Running Totals’ in one engine cycle:
To illustrate such need and associated capability, we will add a new ‘Category’ field (Alpha 1) to the ‘List_of_Values’ table previously introduced. Now let’s say that we want accumulate many ‘Running totals’, one for each category in the following separate table:
1) Add the ‘Category Code’ column added to the ‘List_of_Values’ table to the Data View and form.
Deletions:
Example 2: Supports updating two ‘Running Totals’ in one engine cycle:
To illustrate such need and associated capability, we will add a new ‘Category’ field (Alpha 1) to the ‘List_of_Values’ table. Now let’s say that we want accumulate many ‘Running totals’, one for each category in the following separate table:
1) Add the ‘Category Code’ column added to the ‘List_of_Values’ table to the Data View.
Oldest known version of this page was edited on 2007-09-17 22:09:40 by InformaPlus [IU Complete]
Page view:
Complete Incremental Update Mechanism:
The example previously presented is a simple example in the sense that only one ‘Running total’ may be updated as a result of a user interaction with one detailed row. There are more sophisticated cases where up to two ‘Running Totals’ may need to be updated. In such case, the incremental logic not only needs to factor Original and Final values but also original and final ‘Running Totals’.
Example 2: Supports updating two ‘Running Totals’ in one engine cycle:
To illustrate such need and associated capability, we will add a new ‘Category’ field (Alpha 1) to the ‘List_of_Values’ table. Now let’s say that we want accumulate many ‘Running totals’, one for each category in the following separate table:
Table Name: Category Totals
Columns:
1) Category Code: Alpha (1)
2) Running Total: Numeric (7)
The running total must be maintained and saved as the running total of all the rows assigned to the associated category.
Index: By Category Code (Unique)
The logic to perform in this context is very similar to what was presented to maintain one overall ‘Running Total’. However there is an additional consideration. In modify mode, It must also consider and factor the fact that the ‘Category Code’ of a detailed row can be modified and furthermore can be modified together with the ‘Value’ on this detailed row.
To factor this possibility of a change of ‘Category Code’, the modify mode incremental logic must be slightly enhanced as follow:
Upon modifying the value on an existing line, the engine will perform the following to updates:
1) Reduce the original Category ‘Running Total’ (of the ‘Category Totals’ table) by the original Value.
2) Increase the final Category ‘Running Total’ (of the ‘Category Totals’ table) by the final value.
Example:
· Coming back on a line with Category (1) and value (20), modifying the Category to become (2) and the value to become (10), the engine will do the following:
· Reduce the Category (1) original Running Total by the original value of 20.
· Increase the Category (2) final Running Total by the final value of 10.
Notice that two separate rows were updated as a result of the above.
Adding the accumulation logic in our eDeveloper task example, can be done with the following:
1) Add the ‘Category Code’ column added to the ‘List_of_Values’ table to the Data View.
2) Add one (but only one) Link Write to the ‘Category Totals’ table after the above ‘Category Code’.
3) In the above Link:
· Locate Init:, From: and to: the ‘Category Code’ of the ‘List_of_Values’
· Select the ‘Running Total’ column.
4) In the Record Suffix, after the update of the overall ‘Running Total’ add the following:
Update, ‘Running Total’ of ‘Category Totals’, Exp=Value, How=Incr
At this point it is preferable to manually delete (from a <Ctrl+G>) all the rows from the ‘List_of_Values’ table before executing the program. This will avoid the creation of a blank ‘Category Code’ row building up a negative ‘Running Total’ value as you assign Categories currently set to blank.
You can now run the program and experience how the incremental fields are all being updated as you assign or modify categories values to each detail.
Notice that only one ‘Link Write’ operation in the Data View and one associated new ‘Update Incremental’ operation in the ‘Record Suffix’ is sufficient to handle all possible scenarios.
Back To:
Incremental Update
The original version of this page was provided by: InformaPlus
