Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package pt.webdetails.cda.dataaccess;
  
  import java.util.List;
  
  
 import  org.apache.commons.logging.Log;
 import  org.apache.commons.logging.LogFactory;
 import  org.dom4j.Element;
 import  org.pentaho.reporting.engine.classic.core.ParameterDataRow;
 
 
Implementation of the SimpleDataAccess User: pedro Date: Feb 3, 2010 Time: 11:04:10 AM
 
 public abstract class SimpleDataAccess extends AbstractDataAccess implements DomVisitable
 {
 
   private static final Log logger = LogFactory.getLog(SimpleDataAccess.class);
   protected String connectionId;
   protected String query;
   private static final String QUERY_TIME_THRESHOLD_PROPERTY = "pt.webdetails.cda.QueryTimeThreshold";
   private static int queryTimeThreshold = getQueryTimeThresholdFromConfig(3600);//seconds
 
 
   public SimpleDataAccess()
   {
   }
 
 
   public SimpleDataAccess(final Element element)
   {
 
     super(element);
      = element.attributeValue("connection");
      = element.selectSingleNode("./Query").getText();
 
   }


  

Parameters:
id DataAccess ID
name
connectionId
query
 
   public SimpleDataAccess(String idString nameString connectionIdString query)
   {
     super(idname);
     this. = query;
     this. = connectionId;
   }
 
 
   protected TableModel queryDataSource(final QueryOptions queryOptionsthrows QueryException
   {
     final List<Parameterparameters = getFilledParameters(queryOptions); 
 
     final ParameterDataRow parameterDataRow;
     try
     {
       parameterDataRow = Parameter.createParameterDataRowFromParameters(parameters);
     }
     catch (InvalidParameterException e)
     {
       throw new QueryException("Error parsing parameters "e);
     }
 
     // create the cache-key which is both query and parameter values
     TableCacheKey key;
     TableModel tableModelCopy;
     IDataSourceQuery rawQueryExecution = null;
     Long queryTime = null;
     try
     {
       key = createCacheKey(parameters);
 
       if (isCacheEnabled() && !queryOptions.isCacheBypass())
       {
        try
        {
          final TableModel cachedTableModel = getCdaCache().getTableModel(key);
          if(cachedTableModel != null)
          {
            .debug("Found table in cache, returning.");
            return cachedTableModel;
          }
        }
        catch(Exception e){
          .error("Error while attempting to load from cache, bypassing cache (cause: " + e.getClass() + ")"e);
        }
      }
      //start timing query
      long beginTime = System.currentTimeMillis();
      
      rawQueryExecution = performRawQuery(parameterDataRow);
      final TableModel tableModel = postProcessTableModel(rawQueryExecution.getTableModel());
      queryTime = logIfDurationAboveThreshold(beginTimegetId(), getQuery(), parameters);
      // Copy the tableModel and cache it
      tableModelCopy = TableModelUtils.getInstance().copyTableModel(thistableModel);
    }
    catch (Exception e)
    {
      throw new QueryException("Found an unhandled exception:"e);
    }
    finally
    {
      if(rawQueryExecution != nullrawQueryExecution.closeDataSource();
    }
    // put the copy into the cache ...
    if (isCacheEnabled())
    {
      ExtraCacheInfo cInfo = new ExtraCacheInfo(this.getCdaSettings().getId(), queryOptions.getDataAccessId(), queryTimetableModelCopy);
      getCdaCache().putTableModel(keytableModelCopygetCacheDuration(), cInfo);
    }
    // and finally return the copy.
    return tableModelCopy;
  }
  private List<ParametergetFilledParameters(final QueryOptions queryOptionsthrows QueryException {
    // Get parameters from definition and apply their values
    //TODO: use queryOptions' parameters instead of copying?
    final List<Parameterparameters = new ArrayList<Parameter>(getParameters().size());
    for(Parameter param : getParameters())
    {
      parameters.add(new Parameter(param));
    }
    for (final Parameter parameter : parameters)
    {
      final Parameter parameterPassed = queryOptions.getParameter(parameter.getName());
      try 
      {
        if (parameter.getAccess().equals(..) && parameterPassed != null) {
          //complete passed parameter and get its value
          parameterPassed.inheritDefaults(parameter);
          parameter.setValue(parameterPassed.getValue());
        } else {
          //just force evaluation of default value
          parameter.setValue(parameter.getValue());
        }
      } 
      catch (InvalidParameterException e) {
        throw new QueryException("Error parsing parameters "e);
      }
    }
    return parameters;
  }
  private TableCacheKey createCacheKey(final List<Parameterparametersthrows QueryException {
    try
    {
      final Connection connection;
      {
        connection = new DummyConnection();
      }
      else
      {
        connection = getCdaSettings().getConnection(getConnectionId());
      }
      return new TableCacheKey(connectiongetQuery(), parametersgetExtraCacheKey());
    }
    catch (UnknownConnectionException e)
    {
      // I'm sure I'll never be here
      throw new QueryException("Unable to get a Connection for this dataAccess "e);
    }
  }


  

Parameters:
beginTime When query execution began.
Returns:
duration (in seconds)
  private long logIfDurationAboveThreshold(final long beginTimefinal String queryIdfinal String queryfinal List<Parameterparameters)
  {
    long endTime = System.currentTimeMillis();
    long duration = (endTime - beginTime) / 1000;//precision not an issue: integer op is ok
    if (duration > )
    {
      //log query and duration
      String logMsg = "Query " + queryId + " took " + duration + "s.\n";
      logMsg += "\t Query contents: << " + query.trim() + " >>\n";
      if (parameters.size() > 0)
      {
        logMsg += "\t Parameters: \n";
        for (Parameter parameter : parameters)
        {
          logMsg += "\t\t" + parameter.toString() + "\n";
        }
      }
      .debug(logMsg);
    }
    return duration;
  }
  {
    // we can use this method to override the general behavior. By default, no post processing is done
    return tm;
  }


  
Extra arguments to be used for the cache key. Defaults to null but classes that extend SimpleDataAccess may decide to implement it

Returns:
  {
    return null;
  }
  
  //TODO:
  
Query state.
  public static interface IDataSourceQuery {
    
    public TableModel getTableModel();
    
    public void closeDataSource() throws QueryException;
  }
  protected abstract IDataSourceQuery performRawQuery(ParameterDataRow parameterDataRowthrows QueryException;
//  public abstract void closeDataSource() throws QueryException;
  public String getQuery()
  {
    return ;
  }
  public String getConnectionId()
  {
    return ;
  }
  {
    ArrayList<PropertyDescriptorproperties = super.getInterface();
    return properties;
  }
  private static int getQueryTimeThresholdFromConfig(int defaultValue)
  {
    String strVal = CdaBoot.getInstance().getGlobalConfig().getConfigProperty();
    if (!Util.isNullOrEmpty(strVal))
    {
      try
      {
        return Integer.parseInt(strVal);
      }
      catch (NumberFormatException nfe)
      {
        .warn(MessageFormat.format("Could not parse {0} in property {1}, using default {2}."strValdefaultValue) );
      }
    }
    return defaultValue;
  }
  
  public void accept(DomVisitor xmlVisitor, Element root) {
	  xmlVisitor.visit((SimpleDataAccess)thisroot);
  }
public void setQuery(String query) {
	this. = query;
  
New to GrepCode? Check out our FAQ X