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
   {
     // 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());
       if (parameter.getAccess().equals(..) && parameterPassed != null)
       {
         try
         {
           parameterPassed.inheritDefaults(parameter);
           parameter.setValue(parameterPassed.getValue());
         }
         catch (InvalidParameterException e){
           throw new QueryException("Error parsing parameters "e);
         } 
       }
      else
      {
        parameter.setValue(parameter.getDefaultValue());
      }
    }
    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
    {
      try
      {
        final Connection connection;
        {
          connection = new DummyConnection();
        }
        else
        {
          connection = getCdaSettings().getConnection(getConnectionId());
        }
        key = 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);
      }
      if (isCache())
      {
        try
        {
          final TableModel cachedTableModel = getCdaCache().getTableModel(key);
          if(cachedTableModel != null && !queryOptions.isCacheBypass())
          {
            .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
      // Handle the TableModel
      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 (isCache())
    {
      ExtraCacheInfo cInfo = new ExtraCacheInfo(this.getCdaSettings().getId(), queryOptions.getDataAccessId(), queryTimetableModelCopy);
      getCdaCache().putTableModel(keytableModelCopygetCacheDuration(), cInfo);
      
//      final net.sf.ehcache.Element storeElement = new net.sf.ehcache.Element(key, tableModelCopy);
//      storeElement.setTimeToLive(getCacheDuration());
//      cache.put(storeElement);
//      cache.flush();
      
//      // Print cache status size
//      logger.debug("Cache status: " + cache.getMemoryStoreSize() + " in memory, " + 
//              cache.getDiskStoreSize() + " in disk");
    }
    // and finally return the copy.
    return tableModelCopy;
  }


  

Parameters:
beginTime When query execution began.
  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