olapexample.java

一个数据挖掘软件ALPHAMINERR的整个过程的JAVA版源代码

     // Init OLAP task:
     olap.init();

     MiningDataSpecification metaData = olap.getMultMetaData();
     System.out.println("metaData=" + metaData);
     System.out.println("schema: " + dimensionalSchema);
   }

   /**
    * Run example using JOLAP interfaces.
    *
    * @throws Exception error while example is running
    */
   public void runJOLAP() throws Exception {

     // Create connection:
     javax.olap.resource.Connection conn = createOlapConnection();

     // Create OLAP schema:
     createOlapSchema( (Connection)conn );
   }

   /**
    * Run example using local OLAP interface.
    *
    * @throws Exception error while example is running
    */
   public void runLocalOLAP() throws Exception {

     // -------------------- Create OLAP Schema with Cube ----------------------
     // Create local OLAP engine:
     OlapEngine olap = new OlapEngine();

     // Open data source:
     MiningCsvStream inputStream = new MiningCsvStream("data/csv/carsales.csv");
     inputStream.open();

     // Assign source stream to OLAP engine:
     olap.setInputStream(inputStream);

     // Create flat dimensions:
     DimensionClass dimClass = (DimensionClass) olap.getDimension();
     Dimension product = dimClass.createDimension("Product", "product");
     Dimension time    = dimClass.createDimension("Time", "time");
     Dimension channel = dimClass.createDimension("Channel", "channel");

     // Just to show that numeric attributes are transformed to categorical:
     Dimension salesDim = dimClass.createDimension("SalesDim", "sales");

     // Create hierarchical dimension:
     Dimension geog    = dimClass.createHierachicalDimension("Geography");
     geog.addInputAttribute( olap.getInputAttribute("country") );  // level 0
     geog.addInputAttribute( olap.getInputAttribute("city") );     // level 1

     // Create measures:
     MeasureClass measClass = (MeasureClass) olap.getMeasure();
     Measure sales  = measClass.createAggregationMeasure("Sales",
       AggregationMeasure.SUM, olap.getInputAttribute("sales") );
     Measure cost   = measClass.createAggregationMeasure("Cost",
       AggregationMeasure.SUM, olap.getInputAttribute("cost") );
     Measure profit = measClass.createBinaryOperatorMeasure("Profit",
       BinaryOperatorMeasure.MINUS, sales, cost);

     // Create measure dimension:
     Dimension meas    = dimClass.createMeasureDimension("Measures");
     meas.addInputAttribute(sales);
     meas.addInputAttribute(cost);
     meas.addInputAttribute(profit);

     // Create an overall holding schema:
     SchemaClass schemaClass  = (SchemaClass) olap.getSchema();
     Schema dimensionalSchema = schemaClass.createSchema("All");
     dimensionalSchema.addDimension(product);
     dimensionalSchema.addDimension(geog);
     dimensionalSchema.addDimension(time);
     dimensionalSchema.addDimension(channel);
     dimensionalSchema.addDimension(meas);
     dimensionalSchema.addDimension(salesDim);

     // Create the cube:
     CubeClass cubeClass = (CubeClass) olap.getCube();
     Cube salesCube = cubeClass.createCube("Sales Cube");

     // Create the four cube dimension associations:
     salesCube.addDimension(product);
     salesCube.addDimension(geog);
     salesCube.addDimension(time);
     salesCube.addDimension(channel);
     salesCube.addDimension(meas);

     // Add cube to the schema:
     dimensionalSchema.addCube(salesCube);

     // Add schema to OLAP engine:
     olap.setCurrentSchema(dimensionalSchema);

     // Init OLAP task:
     olap.init();

     MiningDataSpecification metaData = olap.getMultMetaData();
     System.out.println("metaData=" + metaData);
     System.out.println("schema: " + dimensionalSchema);

     // -------------------- Run query against the cube ----------------------
     // Create a dimension view for each dimension:
     DimensionView channelView = (DimensionView) olap.createDimensionView();
     channelView.setDimension(channel);
     DimensionView productView = (DimensionView) olap.createDimensionView();
     productView.setDimension(product);
     DimensionView geographyView = (DimensionView) olap.createDimensionView();
     geographyView.setDimension(geog);
     DimensionView timeView = (DimensionView) olap.createDimensionView();
     timeView.setDimension(time);
     MeasureView measView = (MeasureView) olap.createMeasureView();
     measView.setDimension(meas);

     // Add selection and ordering to product view:
     DimensionStepManager productDMS = (DimensionStepManager)
       productView.createDimensionStepManager();

     AttributeFilter prodAttFilter = (AttributeFilter)
       productDMS.createDimensionStep( DimensionStepTypeEnum.ATTRIBUTEFILTER );
     MiningAttribute prodAtt = (MiningAttribute) productView.getDimension().getFeature().get(0);
     prodAttFilter.setAttribute( prodAtt );
     prodAttFilter.setSetAction( SetActionTypeEnum.INITIAL );
     prodAttFilter.setOp( OperatorTypeEnum.NE );
     prodAttFilter.setRhs( "Alfa" );

     AttributeSort prodAttSort = (AttributeSort)
       productDMS.createDimensionStep( DimensionStepTypeEnum.ATTRIBUTESORT );
     prodAttSort.setBasedOn( prodAtt );
     prodAttSort.setDirection( SortTypeEnum.ASCENDING );

     // Add selections to geography view:
     DimensionStepManager geographyDMS = (DimensionStepManager)
       geographyView.createDimensionStepManager();
     AttributeFilter geogAttFilter = (AttributeFilter)
       geographyDMS.createDimensionStep( DimensionStepTypeEnum.ATTRIBUTEFILTER );
     MiningAttribute geogAtt = (MiningAttribute) geographyView.getDimension().getFeature().get(0);
     geogAttFilter.setAttribute( geogAtt );
     geogAttFilter.setSetAction( SetActionTypeEnum.INITIAL );
     geogAttFilter.setOp( OperatorTypeEnum.EQ );
     geogAttFilter.setRhs( "Greece" );
     AttributeFilter geogAttFilter2 = (AttributeFilter)
       geographyDMS.createDimensionStep( DimensionStepTypeEnum.ATTRIBUTEFILTER );
     geogAttFilter2.setAttribute( geogAtt );
     geogAttFilter2.setSetAction( SetActionTypeEnum.APPEND );
     geogAttFilter2.setOp( OperatorTypeEnum.EQ );
     geogAttFilter2.setRhs( "Italy" );

     // Create the query cube view and add edges and the measure:
     CubeView query = (CubeView) olap.createCubeView(salesCube);

     // Create a columns edge and add time and geography views:
     EdgeView columns = (EdgeView) query.createOrdinateEdge();
     columns.addDimensionView(geographyView);
     columns.addDimensionView(timeView);

     // Create a rows edge and add the product view
     EdgeView rows = (EdgeView) query.createOrdinateEdge();
     rows.addDimensionView(productView);

     // Create a pages edge and add the channel dimension view:
     EdgeView pages = (EdgeView) query.createPageEdge();
//     pages.addDimensionView(channelView);
     pages.addDimensionView(measView);

     // Create the cube cursor associated to the query:
     CubeCursor dataCursor = (CubeCursor) query.createCursor();
     System.out.println("aggregateStream: " + dataCursor.getResultTable());

     // Get page and both ordinate cursors:
     EdgeCursor pageCursor = (EdgeCursor) dataCursor.getPageEdge().iterator().next();
     EdgeCursor columnCursor = (EdgeCursor) dataCursor.getOrdinateEdge().get(0);
     EdgeCursor rowCursor = (EdgeCursor) dataCursor.getOrdinateEdge().get(1);

     // Get dimension cursors of all page and ordinate cursors:
     DimensionCursor measureCursor = (DimensionCursor) pageCursor.getDimensionCursor().get(0);
//     DimensionCursor channelCursor = (DimensionCursor) pageCursor.getDimensionCursor().get(1);
     DimensionCursor productCursor = (DimensionCursor) rowCursor.getDimensionCursor().get(0);
     DimensionCursor geographyCursor = (DimensionCursor) columnCursor.getDimensionCursor().get(0);
     DimensionCursor timeCursor = (DimensionCursor) columnCursor.getDimensionCursor().get(1);

     // ----------------------- Show query result -------------------------
     // Iterate through both edge cursors:
     System.out.println("query result with edge cursors:");
     columnCursor.beforeFirst();
     while ( columnCursor.next() ) {
       System.out.println( columnCursor.read() );
       rowCursor.beforeFirst();
       while ( rowCursor.next() ) {
         System.out.println( rowCursor.read() );

         pageCursor.beforeFirst();
         while ( pageCursor.next() )
           System.out.println( pageCursor.read() );
       }
       System.out.println();
     };

     // Iterate through all dimension cursors:
     System.out.println("query result with dimension cursors:");
     geographyCursor.beforeFirst();
     while ( geographyCursor.next() ) {
       System.out.println( "geog: " + geographyCursor.getString(1) );

       timeCursor.beforeFirst();
       while ( timeCursor.next() ) {
         System.out.println( "time: " + timeCursor.getString(1) );

         productCursor.beforeFirst();
         while ( productCursor.next() ) {
           System.out.println( "prod: " + productCursor.getString(1) );

           measureCursor.beforeFirst();
           while ( measureCursor.next() ) {
             for (int i = 0; i < measureCursor.getMetaData().getColumnCount(); i++)
               System.out.print(measureCursor.getDouble(i + 1) + " ");
             System.out.println();
           }
         }
         System.out.println();
       }
       System.out.println();
     }
   }

   /**
    * Run CWM example.
    *
    * @throws Exception error while example is running
    */
   public void runExample() throws Exception {

     // Use CWM:
//     runCwm();

     // Use JOLAP connection:
//     runJOLAP();

     // Use local OLAP object:
     runLocalOLAP();
   }

   /**
    * Simple example of of how to use Xelopes OLAP server.
    *
    * @param args arguments (ignored)
    */
   public static void main(java.lang.String[] args) {

     try {
       new OlapExample().runExample();
     }
     catch (Exception ex) {
       ex.printStackTrace();
     }
   }
}