Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package pt.webdetails.cda.dataaccess;
  
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
 
 
 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.platform.api.engine.PluginBeanException;
 
This is the top level implementation of a DataAccess. Only the common methods are used here

User: pedro Date: Feb 3, 2010 Time: 11:05:38 AM

 
 public abstract class AbstractDataAccess implements DataAccess
 {
 
   private static final Log logger = LogFactory.getLog(AbstractDataAccess.class);
 //  private static CacheManager cacheManager;
   private static IQueryCache cache;
   
   private CdaSettings cdaSettings;
   private String id;
   private String name;
   private boolean cacheEnabled = false;
   private int cacheDuration = 3600;
   private ArrayList<Parameterparameters;
 
   private static final String PARAM_ITERATOR_BEGIN = "$FOREACH(";
   private static final String PARAM_ITERATOR_END = ")";
   private static final String PARAM_ITERATOR_ARG_SEPARATOR = ",";
 
   protected AbstractDataAccess()
   {
   }
 
 
   protected AbstractDataAccess(final Element element)
   {
      = "";
      = new ArrayList<Parameter>();
      = new HashMap<IntegerArrayList<Integer>>();
     .put(1, new ArrayList<Integer>());
      = new HashMap<IntegerOutputMode>();
 
     parseOptions(element);
 
   }


  

Parameters:
id
name
 
   protected AbstractDataAccess(String idString name)
   {
     this. = name;
     this. = id;
 
      = new ArrayList<Parameter>();
      = new HashMap<IntegerArrayList<Integer>>();
     .put(1, new ArrayList<Integer>());
     = new HashMap<IntegerOutputMode>();
  }


  

Parameters:
params
  public void setParameters(Collection<Parameterparams)
  {
    this..clear();
    this..addAll(params);
  }
  public abstract String getType();
  private void parseOptions(final Element element)
  {
     = element.attributeValue("id");
    final Element nameElement = (Element) element.selectSingleNode("./Name");
    if (nameElement != null)
    {
       = nameElement.getTextTrim();
    }
    if (element.attributeValue("access") != null && element.attributeValue("access").equals("private"))
    {
    }
    if (element.attributeValue("cache") != null && element.attributeValue("cache").equals("true"))
    {
       = true;
    }
    if (element.attribute("cacheDuration") != null && !element.attribute("cacheDuration").toString().equals(""))
    {
       = Integer.parseInt(element.attributeValue("cacheDuration"));
    }
    // Parse parameters
    final List<Element> parameterNodes = element.selectNodes("Parameters/Parameter");
    for (final Element p : parameterNodes)
    {
      .add(new Parameter(p));
    }
    // Parse outputs
    final List<Element> outputNodes = element.selectNodes("Output");
    for (final Element outputNode : outputNodes)
    {
      ArrayList<IntegermyOutputs = new ArrayList<Integer>();
      if (outputNode != null)
      {
        int localId = 1;
        if (outputNode.attribute("id") != null && !outputNode.attribute("id").toString().equals(""))
        {
          // if parseInt fails an exception will be thrown and the cda file will not be accepted
          localId = Integer.parseInt(outputNode.attributeValue("id"));
        }
        else
        {
          // if an output has not a defined or empty id then it will have key = 1
          localId = 1;
        }
        try
        {
          .put(localId, OutputMode.valueOf(outputNode.attributeValue("mode").toUpperCase()));
        }
        catch (Exception e)
        {
          // if there are any errors, go back to the default					
          .put(localId.);
        }
        final String[] indexes = outputNode.attributeValue("indexes").split(",");
        for (final String index : indexes)
        {
          myOutputs.add(Integer.parseInt(index));
        }
        .put(localIdmyOutputs);
      }
    }
    // Parse Columns
    final List<Element> columnNodes = element.selectNodes("Columns/*");
    for (final Element p : columnNodes)
    {
    }
    // Build the columnDefinitionIndexMap
    final ArrayList<ColumnDefinitioncols = getColumns();
    for (final ColumnDefinition columnDefinition : cols)
    {
      .put(columnDefinition.getIndex(), columnDefinition);
    }
  }
  
  public static synchronized IQueryCache getCdaCache(){
    if( == null){
      try {
         = PluginUtils.getPluginBean("cda."IQueryCache.class);
      } catch (PluginBeanException e) {
        .error(e.getMessage());
      }
      if( == null){
        //fallback
         = new EHCacheQueryCache(); 
      }
    }
    return ;
  }
  public static synchronized net.sf.ehcache.Cache getCache()
  {
    return ((EHCacheQueryCachegetCdaCache()).getCache();
  }
  public static synchronized void shutdowCache(){
    if( != null){
       = null;
    }
  }
  public static synchronized void clearCache()
  {
    IQueryCache cache = getCdaCache();
    cache.clearCache();
  }
  public TableModel doQuery(final QueryOptions queryOptionsthrows QueryException
  {
    Map<StringIterable<String>> iterableParameters = getIterableParametersValues(queryOptions);
    if (!iterableParameters.isEmpty())
    {
      return doQueryOnIterableParameters(queryOptionsiterableParameters);
    }
    /*
     *  Do the tableModel PostProcessing
     *  1. Sort
     *  2. Show only the output columns
     *  3. Paginate
     *  4. Call the appropriate exporter
     *
     */
    final TableModel tableModel = queryDataSource(queryOptions);
    
    try
    {
      final TableModel outputTableModel = TableModelUtils.getInstance().postProcessTableModel(thisqueryOptionstableModel);
      .debug("Query " + getId() + " done successfully - returning tableModel");
      return outputTableModel;
    }
    catch (InvalidOutputIndexException e)
    {
      throw new QueryException("Error while setting output index id "e);
    }
    catch (SortException e)
    {
      throw new QueryException("Error while sorting output "e);
    }
    catch (TableModelException e)
    {
      throw new QueryException("Could not create outputTableModel "e);
    }
  }
  public TableModel listParameters(final DiscoveryOptions discoveryOptions)
  {
    return TableModelUtils.getInstance().dataAccessParametersToTableModel(getParameters());
  }
  protected abstract TableModel queryDataSource(final QueryOptions queryOptionsthrows QueryException;
  //public abstract void closeDataSource() throws QueryException;
  {
    final ArrayList<ColumnDefinitionlist = new ArrayList<ColumnDefinition>();
    for (final ColumnDefinition definition : )
    {
      if (definition.getType() == ..)
      {
        list.add(definition);
      }
    }
    return list;
  }
  public ColumnDefinition getColumnDefinition(final int idx)
  {
    return .get(new Integer(idx));
  }
  {
    final ArrayList<ColumnDefinitionlist = new ArrayList<ColumnDefinition>();
    for (final ColumnDefinition definition : )
    {
      if (definition.getType() == ..)
      {
        list.add(definition);
      }
    }
    return list;
  }
  public void storeDescriptor(DataAccessConnectionDescriptor descriptor)
  {
    ////
  }
  public String getId()
  {
    return ;
  }
  public String getName()
  {
    return ;
  }
  public void setName(final String name)
  {
    this. = name;
  }
  {
    return ;
  }

  

Deprecated:
use isCacheEnabled() instead
  public boolean isCache()
  {
    return ;
  }
  
  public boolean isCacheEnabled(){
    return ;
  }
  
  public void setCacheEnabled(boolean enabled){
     = enabled;
  }
  public int getCacheDuration()
  {
    return ;
  }
  
  public void setCacheDuration(int cacheDuration) {
    this. = cacheDuration;
  }
  {
    return ;
  }
  public void setCdaSettings(final CdaSettings cdaSettings)
  {
    this. = cdaSettings;
  }
  {
    return ;
  }
  {
    if (.isEmpty())
    {
      return new ArrayList<Integer>();
    }
    return (ArrayList<Integer>) .get(1);
  }
  public ArrayList<IntegergetOutputs(int id)
  {
    return (ArrayList<Integer>) .get(id);
  }


  

Parameters:
outputIndexes indexes of columns to output
  public void setOutputs(HashMap<IntegerArrayList<Integer>> outputIndexes)
  {
    this. = outputIndexes;
  }
  {
    return .get(1);
  }
  public OutputMode getOutputMode(int id)
  {
    return .get(id);
  }
  {
  }
  {
    return properties;
  }
  public abstract ConnectionType getConnectionType();
  {
    return ConnectionCatalog.getInstance(false).getConnectionsByType(getConnectionType());
  }
  public Connection[] getAvailableConnections(boolean skipCache)
  {
    return ConnectionCatalog.getInstance(skipCache).getConnectionsByType(getConnectionType());
  }
  public String getTypeForFile()
  {
    return this.getClass().toString().toLowerCase().replaceAll("class pt.webdetails.cda.dataaccess.(.*)connection""$1");
  }


  
Identify $FOREACH directives and get their iterators
          final QueryOptions queryOptionsthrows QueryException
  {
    //name, values
    Map<StringIterable<String>> iterableParameters = new HashMap<StringIterable<String>>();
    final String splitRegex =  + "(?=([^\"]*\"[^\"]*\")*[^\"]*$)";//ignore separator inside dquotes
    for (Parameter param : queryOptions.getParameters())
    {
      String value = param.getStringValue();
      if (value != null && value.startsWith())
      {
        String[] args = Util.getContentsBetween(value).split(splitRegex);
        if (args.length < 2)
        {
          throw new QueryException("Parameter '" + param.getName() + "': "
                  + "Error iterating parameter."new IllegalArgumentException("$FOREACH: need at least dataAccessId and column index"));
        }
        //dataAccessId
        String dataAccessId = StringUtils.trim(args[0]);
        try
        {//validate
          getCdaSettings().getDataAccess(dataAccessId);
        }
        catch (UnknownDataAccessException e)
        {
          throw new QueryException("$FOREACH: Invalid dataAccessId."e);
        }
        //column index
        int columnIdx = 0;
        try
        {
          columnIdx = Integer.parseInt(StringUtils.trim(args[1]));
        }
        catch (NumberFormatException nfe)
        {
          throw new QueryException("$FOREACH: Unable to parse 2nd argument."nfe);
        }
        //parameters for query
        String[] dataAccessParams = null;
        if (args.length > 2)
        {
          dataAccessParams = new String[args.length - 2];
          System.arraycopy(args, 2, dataAccessParams, 0, dataAccessParams.length);
        }
        Iterable<StringparamValues = expandParameterIteration(dataAccessIdcolumnIdxdataAccessParams);
        if (paramValues == null)
        {//no values, clear so it can fallback to default (if any)
          param.setValue(null);
        }
        else
        {
          iterableParameters.put(param.getName(), paramValues);
        }
      }
    }
    return iterableParameters;
  }

  
Get a value iterator from a $FOREACH directive

Returns:
Iterable over values, or null if no results
  private Iterable<StringexpandParameterIteration(String dataAccessIdint outColumnIdxString[] dataAccessParameters)
          throws QueryException
  {
    final String EXC_TEXT = "Unable to expand parameter iteration. ";
    QueryOptions queryOptions = new QueryOptions();
    queryOptions.setDataAccessId(dataAccessId);
    //set query parameters
    if (dataAccessParameters != null)
    {
      for (String paramDef : dataAccessParameters)
      {
        int attribIdx = StringUtils.indexOf(paramDef'=');
        if(attribIdx > 0){
          String paramName = StringUtils.trim(StringUtils.substring(paramDef, 0, attribIdx));
          String paramValue = StringUtils.trim(StringUtils.substring(paramDefattribIdx+1));
          queryOptions.addParameter(paramNameparamValue);
        }
        else {
          .error("Bad parameter definition, skipping: " + paramDef);
        }
      }
    }
    //do query and get selected columns
    .debug("expandParameterIteration: Doing inner query on CdaSettings [ " + .getId()
            + " (" + queryOptions.getDataAccessId() + ")]");
    try
    {
      DataAccess dataAccess = getCdaSettings().getDataAccess(queryOptions.getDataAccessId());
      TableModel tableModel = dataAccess.doQuery(queryOptions);
      if (outColumnIdx < 0 || outColumnIdx >= tableModel.getColumnCount())
      {
        throw new QueryException(EXC_TEXTnew IllegalArgumentException("Output column index " + outColumnIdx + " out of range."));
      }
      if (tableModel.getRowCount() < 1)
      {
        return null;
      }
      return new StringColumnIterable(tableModeloutColumnIdx);
    }
    catch (UnknownDataAccessException e)
    {
      throw new QueryException(EXC_TEXTe);
    }
  }
  private TableModel doQueryOnIterableParameters(QueryOptions queryOptionsMap<StringIterable<String>> iterableParameters)
          throws QueryException
  {
    //all iterators need to have at least one value..
    List<Stringnames = new ArrayList<String>();
    List<Iterator<String>> iterators = new ArrayList<Iterator<String>>();
    List<Iterable<String>> iterables = new ArrayList<Iterable<String>>();
    List<Stringvalues = new ArrayList<String>();
    TableModel result = null;
    try
    {
      //0) init
      int paramCount = 0;
      for (String name : iterableParameters.keySet())
      {
        names.add(name);
        iterables.add(iterableParameters.get(name));
        iterators.add(iterables.get(paramCount).iterator());
        values.add(iterators.get(paramCount).next());
        paramCount++;
      }
      boolean exhausted = false;
      while (!exhausted)
      {// til last iteration from bottom of stack
        //1.1) set parameters
        for (int i = 0; i < paramCounti++)
        {
          queryOptions.setParameter(names.get(i), values.get(i));
        }
        //1.2) execute query
        TableModel tableModel = doQuery(queryOptions);
//				//1.3) cache only, just keep last result //join results x
//				if (result == null) { result = tableModel; }
//				else { result = TableModelUtils.getInstance().appendTableModel(result,tableModel); }
        result = tableModel;
        //2) get next set of values
        for (int i = 0; i < paramCounti++)
        {// traverse until we can get a next() or bottom of stack reached
          if (iterators.get(i).hasNext())
          {
            values.set(iiterators.get(i).next());//new value
            break;
          }
          else if (i < paramCount - 1)
          {//this one exhausted, reset if not last
            iterators.set(iiterables.get(i).iterator());//reset
            values.set(iiterators.get(i).next());
          }
          else
          {
            exhausted = true;//end of the line, no more resets
          }
        }
      }
    }
    catch (NoSuchElementException e)
    {
      //will happen if one of the iterators has no value
    }
    return result;
  }

  
Iterates a table model over a given column index.
  private class StringColumnIterable implements Iterable<String>
  {
    private final TableModel table;
    private final int columnIndex;
    public StringColumnIterable(TableModel tableModelint columnIndex)
    {
      this. = tableModel;
      this. = columnIndex;
    }
    @Override
    public Iterator<Stringiterator()
    {
      return new StringColumnIterator();
    }
    private class StringColumnIterator implements Iterator<String>
    {
      int rowIndex = 0;
      @Override
      public boolean hasNext()
      {
        return .getRowCount() > ;
      }
      @Override
      public String next()
      {
        if (!hasNext())
        {
          throw new NoSuchElementException();
        }
        return .getValueAt(++, ).toString();
      }
      @Override
      public void remove()
      {
        throw new UnsupportedOperationException();
      }
    }
  }
	  return ;
  }
  
New to GrepCode? Check out our FAQ X