Data Load Differences for ASO
Loading data to Essbase aggregate storage cubes differs from block storage. Data loads only to stored, level-0 members. Temporary buffers help streamline flows from multiple sources, and slices can be merged and replaced. Date format strings help load to date-time dimensions. Aggregations cause recalculation post data load.
Table 35-4 Data Load Differences Between Aggregate Storage and Block Storage
| Data Load Functionality | Aggregate Storage | Block Storage | 
|---|---|---|
| 
                                  Cells loaded through data loads  | 
                              
                                  Only level 0 cells whose values do not depend on formulas in the outline are loaded  | 
                              
                                  Cells at all levels can be loaded (except Dynamic Calc members)  | 
                           
| 
                                  Update of database values  | 
                              
                                  At the end of a data load, if an aggregation exists, the values in the aggregation are recalculated  | 
                              
                                  No automatic update of values. To update data values, you must execute all necessary calculation scripts.  | 
                           
| 
                                  Data load buffers  | 
                              
                                  The loading of multiple data sources into aggregate storage databases is managed through temporary data load buffers  | 
                              
                                  Not supported  | 
                           
| 
                                  Atomic replacement of the contents of a database  | 
                              
                                  When loading data into an aggregate storage database, you can replace the contents of the database or the contents of all incremental data slices in the database  | 
                              
                                  Not supported  | 
                           
| 
                                  Data slices  | 
                              
                                  Aggregate storage databases can contain multiple slices of data. Data slices can be merged  | 
                              
                                  Not supported  | 
                           
| 
                                  Dimension build for shared members  | 
                              
                                  Full support for parent-child build method. Duplicate generation (DUPGEN) build method limited to building alternate hierarchies up to generation 2 (DUPGEN2).  | 
                              
                                  Support for all build methods  | 
                           
| 
                                  Loading data mapped to dates  | 
                              
                                  In a date-time dimension, you can load data into level 0 members using supported date-format strings instead of member names  | 
                              
                                  Date-time dimension type is not supported  | 
                           
| 
                                  Renegade members  | 
                              
                                  Supported  | 
                              
                                  Not supported  | 
                           
| 
                                  Load rules and impact on existing values  | 
                              
                                  Using load rules with the aggregate storage data load buffer, you can choose to overwrite all the cube data, or replace one slice at a time. Slices can be incrementally gathered into the data load buffer before they are loaded to the database.  | 
                              
                                  Using load rules for block storage, you choose for each source of data whether to overwrite existing values, add values to existing values, or subtract values from existing values.  |