| //////////////////////////////////////////////////////////////////////////////// |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one or more |
| // contributor license agreements. See the NOTICE file distributed with |
| // this work for additional information regarding copyright ownership. |
| // The ASF licenses this file to You under the Apache License, Version 2.0 |
| // (the "License"); you may not use this file except in compliance with |
| // the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| package mx.olap |
| { |
| import flash.utils.Dictionary; |
| |
| import mx.collections.IList; |
| import mx.core.mx_internal; |
| |
| use namespace mx_internal; |
| |
| /** |
| * @private |
| */ |
| public class QueryCubeBuilder |
| { |
| include "../core/Version.as"; |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Variables |
| // |
| //-------------------------------------------------------------------------- |
| |
| private var prevNodeAtLevel:Array; //of CubeNodes |
| private var allNodeAtLevel:Array; // of CubeNodes |
| private var prevValueAtLevel:Array; // type depends on data (mostly string) |
| |
| // the level at which the new property is going to be placed |
| private var currentLevel:int; |
| private var prevLevel:int; |
| private var nextLevel:int; |
| |
| //the nodes whose values are going to be aggregated as the above node |
| //value has changed. |
| private var closingNodesBelow:Array; |
| private var closingValues:Array; |
| |
| //list of measures in the cube |
| private var measureMembers:IList; |
| |
| // the maps holding nodes which are used to finalize the aggregation |
| |
| // simple aggregation map |
| private var computeEndMap:Dictionary = new Dictionary(false); |
| |
| //aggregation of aggregations map |
| private var computeObjEndMap:Dictionary = new Dictionary(false); |
| |
| private var measureMap:Object = {}; |
| |
| private var allLevelNames:Array; |
| |
| private var nodesToClose:Array = []; |
| private var nodesToAggregate:Array; |
| private var dataToAggregate:Array; |
| private var measureToAggregate:Array; |
| private var valueToAggregate:Array; |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Properties |
| // |
| //-------------------------------------------------------------------------- |
| |
| //---------------------------------- |
| // cube |
| //---------------------------------- |
| |
| private var _cube:OLAPCube; |
| |
| public function set cube(c:IOLAPCube):void |
| { |
| _cube = c as OLAPCube; |
| } |
| |
| //---------------------------------- |
| // rootNode |
| //---------------------------------- |
| |
| /** |
| * Top most node which can be used to access the query cube. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 9 |
| * @playerversion AIR 1.1 |
| * @productversion Flex 3 |
| */ |
| public var rootNode:CubeNode; |
| |
| //---------------------------------- |
| // allNodePropertyName |
| //---------------------------------- |
| |
| /** |
| * The property name used to refer to the property |
| * pointing at the aggregation of nodes below a CubeNode |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 9 |
| * @playerversion AIR 1.1 |
| * @productversion Flex 3 |
| */ |
| public var allNodePropertyName:String ="(QAll)"; |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Methods |
| // |
| //-------------------------------------------------------------------------- |
| |
| public function initNodeBuilding():void |
| { |
| prevNodeAtLevel = []; |
| allNodeAtLevel = []; |
| prevValueAtLevel = []; |
| measureMap = {}; |
| |
| //compute for all the measures |
| measureMembers = _cube.findDimension("Measures").members; |
| |
| for each (var measure:OLAPMeasure in measureMembers) |
| { |
| computeEndMap[measure] = []; |
| computeObjEndMap[measure] = []; |
| measureMap[measure.name] = measure; |
| } |
| |
| nodesToClose = []; |
| |
| nodesToAggregate = []; |
| dataToAggregate = []; |
| measureToAggregate = []; |
| valueToAggregate = []; |
| |
| |
| //prepare a dictionary of all level names |
| allLevelNames = []; |
| |
| for each (var d:OLAPDimension in _cube.dimensions) |
| { |
| if (d.isMeasure) |
| continue; |
| for each (var a:OLAPAttribute in d.attributes) |
| { |
| allLevelNames.push(a.findMember(a.allMemberName).uniqueName); |
| } |
| |
| for each (var h:OLAPHierarchy in d.hierarchies) |
| { |
| allLevelNames.push(h.findMember(h.allMemberName).uniqueName); |
| } |
| } |
| } |
| |
| public function moveToNextRound():void |
| { |
| currentLevel = 0; |
| prevLevel = -1; |
| nextLevel = 1; |
| } |
| |
| private function sortCubeNodes(p1:CubeNode, p2:CubeNode):int |
| { |
| if (p1.level == p2.level) |
| return 0; |
| if (p1.level < p2.level) |
| return 1; |
| return -1; |
| } |
| |
| /** |
| * @private |
| * Check whether the cubeNode has any entry for a (All) field |
| * from any level. |
| */ |
| private function allPropertyPresent(node:CubeNode):Boolean |
| { |
| for (var p:String in node) |
| { |
| if (allLevelNames.indexOf(p) > -1) |
| return true; |
| } |
| return false; |
| } |
| |
| public function completeNodeBuilding():void |
| { |
| //TODO initializing rootNode twice |
| rootNode = prevNodeAtLevel[0]; |
| closingNodesBelow = prevNodeAtLevel.reverse(); |
| closingValues = prevValueAtLevel.reverse(); |
| |
| var tempLevel:int = closingNodesBelow.length-1; |
| var p:String; |
| var n:int = closingNodesBelow.length; |
| for (var i:int = 0; i < n; ++i) |
| { |
| if (tempLevel < 1) |
| continue; |
| var closingValue:Object = closingValues[i]; |
| //OLAPTrace.traceMsg("Closing value:" + closingValues[i], //OLAPTrace.TRACE_LEVEL_2); |
| var closingNode:Object = closingNodesBelow[i]; |
| if (closingNode[closingValue] is CubeNode) |
| { |
| if (closingNode[allNodePropertyName] is CubeNode) |
| { |
| var index:int = nodesToClose.indexOf(closingNode); |
| if (index == -1) |
| nodesToClose.push(closingNode); |
| } |
| } |
| |
| --tempLevel; |
| } |
| |
| n = nodesToAggregate.length; |
| for (i = 0; i < n; ++ i) |
| { |
| var prevNode:Object = nodesToAggregate[i]; |
| if (prevNode.numCells > 2 && allLevelNames.indexOf(valueToAggregate[i]) > -1) |
| continue; |
| var tempAllNode:Object; |
| |
| if (prevNode.numCells == 2) |
| { |
| if (prevNode.hasOwnProperty(allNodePropertyName)) |
| { |
| for (p in prevNode) |
| { |
| if (p == allNodePropertyName) |
| continue; |
| if (prevNode[allNodePropertyName] != prevNode[p]) |
| prevNode[allNodePropertyName] = prevNode[p]; |
| break; |
| } |
| continue; |
| } |
| } |
| |
| if (prevNode[allNodePropertyName] is CubeNode || prevNode[allNodePropertyName] is Number) |
| tempAllNode = prevNode[allNodePropertyName] = new SummaryNode; |
| else |
| tempAllNode = prevNode[allNodePropertyName]; |
| aggregateAllValue(tempAllNode, dataToAggregate[i], measureToAggregate[i]); |
| } |
| |
| // we sort the nodes in their order of level to do aggregation |
| // bottom up to get correct results |
| nodesToClose.sort(sortCubeNodes); |
| |
| // close all nodes pending |
| for each (var node:CubeNode in nodesToClose) |
| { |
| var allPropPresent:Boolean = allPropertyPresent(node); |
| for (p in node) |
| { |
| if (p == allNodePropertyName) |
| continue; |
| // if there are other paths leading to the nodes below |
| // do not include the all property in aggregation because that would |
| // lead to multiple aggregations of same values |
| if (node.numCells > 2 && allLevelNames.indexOf(p) > -1) |
| continue; |
| |
| // if we have only one extra entry in the node other than allNodeProperty |
| // then we can optimize. |
| if (allPropPresent && node.numCells == 3) |
| node[allNodePropertyName] = node[p]; |
| else |
| accumValuesFromNode(node[allNodePropertyName], node[p]); |
| } |
| } |
| |
| for (p in rootNode) |
| { |
| if (p == allNodePropertyName || (rootNode.numCells > 2 && allLevelNames.indexOf(p) > -1)) |
| continue; |
| // can we accumulate everything from the tree to the all tree here? |
| accumValuesFromNode(rootNode[allNodePropertyName], rootNode[p]); |
| } |
| |
| var temp:Array; |
| var y:Object; |
| var measure:OLAPMeasure; |
| var aggregator:IOLAPCustomAggregator; |
| for (var x:Object in computeEndMap) |
| { |
| measure = x as OLAPMeasure; |
| aggregator = measure.aggregator as IOLAPCustomAggregator; |
| temp = computeEndMap[x]; |
| for each (y in temp) |
| y[measure.name] = aggregator.computeEnd(y[measure.name], measure.dataField); |
| } |
| |
| for (x in computeObjEndMap) |
| { |
| measure = x as OLAPMeasure; |
| aggregator = measure.aggregator as IOLAPCustomAggregator; |
| temp = computeObjEndMap[x]; |
| for each (y in temp) |
| y[measure.name] = aggregator.computeObjectEnd(y[measure.name], measure.dataField); |
| } |
| } |
| |
| public function addValueToNodeBuilder(value:Object, currentData:Object):void |
| { |
| // decide whether to create a new node or use the previous node |
| var prevNode:CubeNode = prevNodeAtLevel[currentLevel]; |
| var prevValue:Object = prevValueAtLevel[currentLevel]; |
| var closingValue:Object; |
| var closingNode:Object |
| |
| if (prevValue) |
| { |
| if (prevValue == value) |
| { |
| // continue to process the same value |
| // update nodes |
| //OLAPTrace.traceMsg("Continue with value:" + prevValue, OLAPTrace.TRACE_LEVEL_2); |
| } |
| else |
| { |
| // no more processing of this value. |
| // time to compute update all nodes etc |
| |
| // close all nodes below this node |
| closingNodesBelow = prevNodeAtLevel.splice(nextLevel).reverse(); |
| closingValues = prevValueAtLevel.splice(nextLevel).reverse(); |
| var tempLevel:int = currentLevel + closingNodesBelow.length; |
| var n:int = closingNodesBelow.length; |
| for (var i:int = 0; i < n; ++i) |
| { |
| closingValue = closingValues[i]; |
| //OLAPTrace.traceMsg("Closing value:" + closingValues[i], OLAPTrace.TRACE_LEVEL_2); |
| closingNode = closingNodesBelow[i]; |
| if (closingNode[closingValue] is CubeNode) |
| { |
| if (tempLevel != 0) |
| { |
| if (closingNode[allNodePropertyName] is CubeNode) |
| { |
| if (nodesToClose.indexOf(closingNode) == -1) |
| nodesToClose.push(closingNode); |
| } |
| } |
| } |
| |
| --tempLevel; |
| } |
| |
| //OLAPTrace.traceMsg("Closing value:" + prevValue, //OLAPTrace.TRACE_LEVEL_2); |
| closingValue = prevValue; |
| closingNode = prevNode; |
| if (closingNode[closingValue] is CubeNode) |
| { |
| if (currentLevel != 0) |
| { |
| if (closingNode[allNodePropertyName] is CubeNode) |
| { |
| if (nodesToClose.indexOf(closingNode) == -1) |
| nodesToClose.push(closingNode); |
| } |
| } |
| } |
| |
| //OLAPTrace.traceMsg("New value:" + value, //OLAPTrace.TRACE_LEVEL_2); |
| } |
| } |
| |
| var allNode:CubeNode = allNodeAtLevel[currentLevel]; |
| |
| if (!prevNode) |
| { |
| //OLAPTrace.traceMsg("Creating new node: " + value, //OLAPTrace.TRACE_LEVEL_2); |
| // - create a new node, put the pointer to the ALL node, add new key to the ALL node |
| var newNode:CubeNode = new CubeNode(currentLevel); |
| |
| // create a all node to summaries the cells of this node |
| newNode[allNodePropertyName] = new CubeNode(currentLevel+1); |
| ++newNode.numCells; |
| //TODO initializing rootNode twice |
| if (currentLevel == 0 && prevNodeAtLevel.length == 0) |
| rootNode = newNode; |
| |
| prevNodeAtLevel[currentLevel] = newNode; |
| if (!allNode) |
| { |
| // for the top most level we would have only one node |
| // which is also the all node |
| // for other levels we have one node which is a all node |
| // containing aggr value of all cells in the nodes at that level |
| if (currentLevel > 0) |
| { |
| allNodeAtLevel[currentLevel] = allNode = new CubeNode(currentLevel+1); |
| allNode[allNodePropertyName] = {}; |
| allNodeAtLevel[prevLevel][allNodePropertyName] = allNode; |
| ++allNode.numCells; |
| } |
| else |
| { |
| // special case of zero level |
| allNodeAtLevel[currentLevel] = newNode; |
| } |
| } |
| |
| prevNode = newNode; |
| } |
| else |
| { |
| // add a new cell/property to the previous node if it doesn't exist |
| if (!prevNode.hasOwnProperty(value)) |
| { |
| //prevNode[value] = 0; |
| prevNodeAtLevel.splice(nextLevel); |
| prevValueAtLevel.splice(nextLevel); |
| } |
| else |
| { |
| if (!prevNodeAtLevel[nextLevel]) |
| { |
| //assigning a summary node was causing a issue(1096) |
| if (prevNode[value] is CubeNode) |
| { |
| // a node already seems to be present for this value |
| prevNodeAtLevel[nextLevel] = prevNode[value]; |
| // we cannot set what the previous value for next level should be |
| // because we have already cleared it and lost it. |
| } |
| } |
| } |
| } |
| |
| // make the node at previous level point to the node |
| if (currentLevel > 0) |
| { |
| var prevLevelNode:Object = prevNodeAtLevel[prevLevel]; |
| if (!prevLevelNode.hasOwnProperty(prevValueAtLevel[prevLevel])) |
| { |
| var prevLevelValue:Object = prevValueAtLevel[prevLevel]; |
| prevLevelNode[prevLevelValue] = newNode; |
| ++prevLevelNode.numCells; |
| } |
| } |
| |
| prevValueAtLevel[currentLevel] = value; |
| ++prevLevel; |
| ++currentLevel; |
| ++nextLevel; |
| |
| } |
| |
| public function addMeasureValueToNode(value:Object, currentData:Object, measureToUpdate:OLAPMeasure):void |
| { |
| var prevNode:CubeNode = prevNodeAtLevel[currentLevel-1]; |
| var prevValue:Object = prevValueAtLevel[currentLevel-1]; |
| |
| if (!prevNode.hasOwnProperty(value)) |
| { |
| prevNode[value] = new SummaryNode; |
| ++prevNode.numCells; |
| } |
| |
| aggregateAllValue(prevNode[value], currentData, measureToUpdate); |
| |
| nodesToAggregate.push(prevNode); |
| dataToAggregate.push(currentData); |
| measureToAggregate.push(measureToUpdate); |
| valueToAggregate.push(value); |
| } |
| |
| private function addValueToNode(node:Object, name:String, |
| value:Object, measure:OLAPMeasure):void |
| { |
| var aggregator:IOLAPCustomAggregator; |
| if (value is Number) |
| { |
| aggregator = measure.aggregator as IOLAPCustomAggregator; |
| if (!node.hasOwnProperty(name)) |
| { |
| node[name] = aggregator.computeBegin(name); |
| computeEndMap[measure].push(node); |
| //if (node is SummaryNode) |
| // node["measures"][name] = measure; |
| aggregator.computeLoop(node[name], name, value); |
| } |
| else |
| { |
| aggregator.computeLoop(node[name], name, value); |
| } |
| } |
| else |
| { |
| var temp:Object; |
| if (!node.hasOwnProperty(name)) |
| { |
| node[name] = temp = new SummaryNode; |
| ++node.numCells; |
| for (var p:String in value) |
| { |
| if (value is SummaryNode) |
| measure = measureMap[p]; |
| |
| if (measure) |
| { |
| aggregator = measure.aggregator as IOLAPCustomAggregator; |
| if (value[p] is Number) |
| { |
| temp[name] = aggregator.computeBegin(p); |
| computeEndMap[measure].push(temp); |
| aggregator.computeLoop(temp[name], p, value[p]); |
| } |
| else |
| { |
| if (temp.hasOwnProperty(p)) |
| { |
| aggregator.computeObjectLoop(temp[p], value[p]); |
| } |
| else |
| { |
| temp[p] = aggregator.computeObjectBegin(value[p]); |
| computeObjEndMap[measure].push(temp); |
| } |
| |
| } |
| } |
| } |
| } |
| else |
| { |
| if (value is SummaryNode && !(node[name] is SummaryNode)) |
| { |
| var incr:Boolean = false; |
| if (!node.hasOwnProperty(name)) |
| incr = true; |
| temp = node[name] = new SummaryNode; |
| if (incr) |
| ++node.numCells; |
| } |
| else |
| { |
| temp = node[name]; |
| } |
| |
| for (p in value) |
| { |
| if (temp.hasOwnProperty(p)) |
| { |
| measure = measureMap[p]; |
| aggregator = measure.aggregator as IOLAPCustomAggregator; |
| aggregator.computeObjectLoop(temp[p], value[p]); |
| } |
| else |
| { |
| if (temp is SummaryNode) |
| measure = measureMap[p]; |
| |
| if (measure) |
| { |
| aggregator = measure.aggregator as IOLAPCustomAggregator; |
| if (value[p] is Number) |
| { |
| temp[p] = aggregator.computeBegin(p); |
| aggregator.computeLoop(temp[p], p, value[p]); |
| } |
| else |
| { |
| temp[p] = aggregator.computeObjectBegin(value[p]); |
| computeObjEndMap[measure].push(temp); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| private function accumValuesFromNode(target:Object, |
| source:Object):void |
| { |
| for (var p:String in source) |
| { |
| if (p == allNodePropertyName) |
| continue; |
| |
| // if there are other paths leading to the nodes below |
| // do not include the all property in aggregation because that would |
| // lead to multiple aggregations of same values |
| if (source.numCells > 2 && allLevelNames.indexOf(p) > -1) |
| continue; |
| |
| var value:Object = source[p]; |
| if (value is CubeNode) |
| { |
| var newNode:CubeNode; |
| if (target[p] is CubeNode) |
| { |
| newNode = target[p]; |
| } |
| else |
| { |
| target[p] = newNode = new CubeNode(value.level); |
| ++target.numCells; |
| } |
| accumValuesFromNode(newNode, value); |
| } |
| else |
| { |
| addValueToNode(target, p, value, null); |
| } |
| } |
| |
| if (target.numCells == 1) |
| { |
| for (p in target) |
| { |
| target[allNodePropertyName] = target[p]; |
| break; |
| } |
| ++target.numCells; |
| } |
| else if (target.numCells == 2 && target.hasOwnProperty(allNodePropertyName)) |
| { |
| for (p in target) |
| { |
| if (p == allNodePropertyName) |
| continue; |
| if (target[allNodePropertyName] != target[p]) |
| target[allNodePropertyName] = target[p]; |
| break; |
| } |
| } |
| else |
| { |
| var done:Boolean = false; |
| var otherProperty:String; |
| for (p in target) |
| { |
| if (p == allNodePropertyName) |
| continue; |
| if (target[allNodePropertyName] == target[p]) |
| { |
| value = target[p]; |
| if (value is CubeNode) |
| { |
| target[allNodePropertyName] = newNode = new CubeNode(value.level); |
| accumValuesFromNode(newNode, value); |
| for (otherProperty in target) |
| { |
| if (otherProperty == allNodePropertyName || |
| otherProperty == p) |
| continue; |
| //now we have the other property. |
| accumValuesFromNode(newNode, source[otherProperty]); |
| } |
| done = true; |
| } |
| else |
| { |
| target[allNodePropertyName] = null; |
| addValueToNode(target, allNodePropertyName, value, null); |
| for (otherProperty in target) |
| { |
| if (otherProperty == allNodePropertyName || |
| otherProperty == p) |
| continue; |
| //now we have the other property. |
| addValueToNode(target, allNodePropertyName, target[otherProperty], null); |
| } |
| done = true; |
| } |
| break; |
| } |
| } |
| |
| if (!done) |
| { |
| p = allNodePropertyName; |
| value = source[p]; |
| if (value is CubeNode) |
| { |
| if (target[p] is CubeNode) |
| { |
| newNode = target[p]; |
| } |
| else |
| { |
| target[p] = newNode = new CubeNode(value.level); |
| ++target.numCells; |
| } |
| accumValuesFromNode(newNode, value); |
| } |
| else |
| { |
| addValueToNode(target, p, value, null); |
| } |
| } |
| } |
| } |
| |
| public function aggregateAllValue(node:Object,/* name:String,*/ |
| value:Object, measure:OLAPMeasure):void |
| { |
| var measureName:String = measure.name; |
| var aggregator:IOLAPCustomAggregator = measure.aggregator as IOLAPCustomAggregator; |
| var prop:String = "saved_" + measureName; |
| var temp:Object; |
| if (!node.hasOwnProperty(measureName)) |
| { |
| temp = node; |
| if (measure) |
| { |
| if (temp.hasOwnProperty(measureName)) |
| { |
| aggregator.computeObjectLoop(temp[measureName], value[prop]); |
| } |
| else |
| { |
| temp[measureName] = aggregator.computeObjectBegin(value[prop]); |
| computeObjEndMap[measure].push(temp); |
| } |
| } |
| } |
| else |
| { |
| temp = node; |
| if (temp.hasOwnProperty(measureName)) |
| { |
| aggregator.computeObjectLoop(temp[measureName], value[prop]); |
| } |
| else |
| { |
| if (value[prop] is Number) |
| { |
| temp[prop] = aggregator.computeBegin(prop); |
| aggregator.computeLoop(temp[prop], prop, value[prop]); |
| } |
| else |
| { |
| temp[measureName] = aggregator.computeObjectBegin(value[prop]); |
| computeObjEndMap[measure].push(temp); |
| } |
| } |
| } |
| } |
| } |
| |
| } |
