Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* This Source Code Form is subject to the terms of the Mozilla Public
   * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   * You can obtain one at http://mozilla.org/MPL/2.0/. */
  package pt.webdetails.cda.dataaccess;
  
  import java.util.List;
 
 
 import  org.apache.commons.lang.StringUtils;
 import  org.apache.commons.logging.Log;
 import  org.apache.commons.logging.LogFactory;
 import  org.dom4j.Element;
 import  org.pentaho.reporting.engine.classic.core.ParameterDataRow;
 
 
 import  pt.webdetails.cpf.messaging.EventPublisher;
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.copyTableModel(thistableModel);
    }
    catch (Exception e)
    {
      try
      {
        CdaEvent.QueryInfo info = new CdaEvent.QueryInfo(getCdaSettings().getId(), getId(), getQuery(), parameterDataRow);
        if (e instanceof QueryException && e.getCause() != null)
        {
          EventPublisher.getPublisher().publish(new QueryErrorEvent(infoe.getCause()));
        }
        else
        {
          EventPublisher.getPublisher().publish(new QueryErrorEvent(infoe));
        }
      }
      catch (Exception inner)
      {
        .error("Error pushing event"inner);
      }
      throw new QueryException("Found an unhandled exception:"e);
    }
    finally
    {
      if (rawQueryExecution != null)
      {
        rawQueryExecution.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 > )
    {
      //publish
      try
      {
        EventPublisher.getPublisher().publish(new QueryTooLongEvent(
                new QueryTooLongEvent.QueryInfo(this.getCdaSettings().getId(), queryIdquery, Parameter.createParameterDataRowFromParameters(parameters)), duration));
      }
      catch (Exception e)
      {
        //TODO
        .error("Error pushing event"e);
      }
      //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";
        }
      }
      .warn(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 = null//CdaBoot.getInstance().getGlobalConfig().getConfigProperty(QUERY_TIME_THRESHOLD_PROPERTY);
    if (!StringUtils.isEmpty(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((SimpleDataAccessthisroot);
  }
  public void setQuery(String query)
  {
    this. = query;
  }
New to GrepCode? Check out our FAQ X