resultsetbuilder.java

搞算法预测的可以来看。有移动平均法

//
//  OpenForecast - open source, general-purpose forecasting package.
//  Copyright (C) 2002-2003  Steven R. Gould
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 of the License, or (at your option) any later version.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//

package net.sourceforge.openforecast.input;


import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;

import net.sourceforge.openforecast.DataPoint;
import net.sourceforge.openforecast.DataSet;
import net.sourceforge.openforecast.Observation;

/**
 * Defines a Builder that can be used to construct a DataSet from a ResultSet.
 * This class makes for a quick and easy "import" of data from a JDBC data
 * source such as an Oracle database.
 *
 * <p><strong>WARNING: This class has not been tested. It has been made
 * available as a starting point for anyone interested in implementing this
 * kind of Builder. It <em>should</em> work fine but, like I said, has not
 * been tested.</strong> If you use this class and fine it works, as is, let
 * me know (and perhaps I can remove this message). Alternatively, if you
 * find any changes are necessary, please submit them for inclusion in the
 * project.
 *
 * <p>Each record in the result set is assumed to define one data point. The
 * last value on each row is assumed to represent the dependent variable. For
 * example, if the independent variables are represented by x1, x2, x3 and so
 * on, and the dependent variable is represented by y, then a row should be
 * of the form:
 *
 * <pre>
 *  x1, x2, ..., xi, y
 * </pre>
 *
 * <p>For example, the following represents data points (1,3), (2,5), (3,6),
 * and (4,7):
 *
 * <pre>
 *  1, 3
 *  2, 5
 *  3, 6
 *  4, 7
 * </pre>
 *
 * <p>where the values 3, 5, 6 and 7 are the observed values of the dependent
 * variable corresponding to the associated values of the independent variables
 * with the values 1, 2, 3, and 4 respectively. The independent variables will
 * be given the column names as defined by the query.
 *
 * <p>For example, consider the following query:
 *
 * <pre>
 *  SELECT period, sales_revenue FROM sales_summary
 * </pre>
 *
 * This would create a series of data points with the single independent
 * variable, <code>period</code>. The <code>sales_revenue</code> column is
 * assumed to represent the dependent variable (for which we don't currently
 * use the name).
 * @author Steven R. Gould
 * @since 0.4
 */
public class ResultSetBuilder extends AbstractBuilder
{
	 /**
	  * Stores the result set from which this builder is to read its data.
	  */
	 private ResultSet rs;
	 
	 /**
	  * Constructs a new ResultSetBuilder that reads its input from the given
	  * ResultSet. The fields will be named according to the column labels
	  * defined by the ResultSet's meta data.
	  * @param resultSet the ResultSet containing data to be used to build the
	  * DataSet.
	  */
	 public ResultSetBuilder( ResultSet resultSet )
	 {
		  this.rs = resultSet;
	 }
	 
	 /**
	  * Retrieves a DataSet - a collection of DataPoints - from the current
	  * input source. The DataSet should contain all DataPoints defined by
	  * the input source.
	  *
	  * <p>In general, build will attempt to convert all rows in the ResultSet
	  * to data points. In this implementation, all columns are assumed to
	  * contain numeric data. This restriction may be relaxed at a later date.
	  * @return a DataSet built from the current input source.
	  * @throws SQLException if a database access error occurs.
	  */
	 public DataSet build()
		  throws SQLException
	 {
		  DataSet dataSet = new DataSet();
		  
		  setColumnNames();
		  
		  // Make sure we're on the first record
		  if ( !rs.isBeforeFirst() )
				rs.beforeFirst();
		  
		  // Iterate through ResultSet,
		  //  creating new DataPoint instance for each row
		  while ( rs.next() )
				{
					 DataPoint dp = build( rs );
					 dataSet.add( dp );
				}
		  
		  return dataSet;
	 }
	 
	 /**
	  * Builds a DataPoint from the given row in the ResultSet. Assumes the
	  * ResultSet has been positioned on the required row. This method does not
	  * change the ResultSet, or the cursor within the ResultSet. The row is
	  * expected/assumed to be made up of numeric fields only.
	  * @param rs the ResultSet from which a row is to be read and used to
	  * construct a new DataPoint.
	  * @return a DataPoint object with values as specified by the current row
	  * in the given ResultSet.
	  * @throws SQLException if a database access error occurs.
	  */
	 private DataPoint build( ResultSet rs )
		  throws SQLException
	 {
		  Observation dataPoint = new Observation( 0.0 );
		  
		  int n = getNumberOfVariables();
		  for ( int column=0; column<n; column++ )
				{
					 // Treat all columns as numeric data
					 double value = rs.getDouble( column );
					 
					 // If this is the last value on the line, treat it
					 //  as the dependent variable value
					 if ( column == n )
						  dataPoint.setDependentValue( value );
					 else
						  dataPoint.setIndependentValue( getVariableName(column),
																	value );
				}
		  
		  return dataPoint;
	 }
	 
	 /**
	  * Reads the column names from the meta data associated with the current
	  * ResultSet, and initializes this object using those names.
	  * @throws SQLException if a database access error occurs.
	  */
	 private void setColumnNames()
		  throws SQLException
	 {
		  ResultSetMetaData metaData = rs.getMetaData();
		  
		  // Store names of independent variables. Last column is assumed
		  //  to be the dependent variable value (we don't actually use that)
		  int n = metaData.getColumnCount()-1;
		  for ( int column=0; column<n; column++ )
				setVariableName( column, metaData.getColumnLabel(column) );
	 }
}