src/org/objectweb/cjdbc/controller/cache/parsing/ParsingCache.java

説明を見る。

package org.objectweb.cjdbc.controller.cache.parsing;

import java.sql.SQLException;
import java.util.Hashtable;

import org.objectweb.cjdbc.common.i18n.Translate;
import org.objectweb.cjdbc.common.sql.AbstractRequest;
import org.objectweb.cjdbc.common.sql.ParsingGranularities;
import org.objectweb.cjdbc.common.sql.RequestType;
import org.objectweb.cjdbc.common.xml.DatabasesXmlTags;
import org.objectweb.cjdbc.controller.requestmanager.ParserThread;
import org.objectweb.cjdbc.controller.requestmanager.RequestManager;

public class ParsingCache
{
  private Hashtable      cache;               // SQL -> parsed request
  private Hashtable      currentlyParsing;    // SQL -> CurrentlyParsingEntry
  private RequestManager requestManager;
  private int            granularity;
  private int            maxNbOfEntries;
  private boolean        backgroundParsing;   // Default is parse when needed
  private boolean        caseSensitiveParsing; // Default is case insensitive

  private class CurrentlyParsingEntry
  {
    private ParserThread    parserThread;
    private AbstractRequest request;

    public CurrentlyParsingEntry(ParserThread parserThread,
        AbstractRequest request)
    {
      this.parserThread = parserThread;
      this.request = request;
    }

    public ParserThread getParserThread()
    {
      return parserThread;
    }

    public AbstractRequest getRequest()
    {
      return request;
    }

  }

  public ParsingCache(int size, boolean backgroundParsing)
  {
    cache = new Hashtable(size == 0 ? 10000 : size);
    currentlyParsing = new Hashtable();
    if (size < 0)
      throw new RuntimeException(Translate.get("cache.parsing.invalid.size",
          size));
    if (size == 0)
      this.maxNbOfEntries = Integer.MAX_VALUE;
    else
      this.maxNbOfEntries = size;
    this.backgroundParsing = backgroundParsing;
    caseSensitiveParsing = false;
  }

  public int getGranularity()
  {
    return granularity;
  }

  public void setGranularity(int granularity)
  {
    this.granularity = granularity;
  }

  public RequestManager getRequestManager()
  {
    return requestManager;
  }

  public void setRequestManager(RequestManager requestManager)
  {
    this.requestManager = requestManager;
  }

  public void getParsingFromCache(AbstractRequest request)
  {
    if (request.isParsed())
      return;

    String sql = request.getSqlSkeleton();
    if (sql == null)
      sql = request.getSQL();
    AbstractRequest parsedRequest = (AbstractRequest) cache.get(sql);

    if (parsedRequest != null)
    { // Cache hit, clone the parsing
      request.cloneParsing(parsedRequest);
      return;
    }
    else if (backgroundParsing)
    { // Cache miss, start parsing the request in background
      synchronized (currentlyParsing)
      {
        if (!currentlyParsing.contains(sql))
        { // Nobody else is trying to parse the same SQL query
          ParserThread pt = new ParserThread(request, requestManager
              .getDatabaseSchema(), granularity, caseSensitiveParsing);
          currentlyParsing.put(sql, new CurrentlyParsingEntry(pt, request));
        }
      }
    }
  }

  public void getParsingFromCacheAndParseIfMissing(AbstractRequest request)
      throws SQLException
  {
    if (request.isParsed())
      return;

    // Check cache
    String instanciatedSQL = request.getSQL();
    AbstractRequest parsedRequest = (AbstractRequest) cache
        .get(instanciatedSQL);

    if (parsedRequest == null)
    { // Cache miss
      String sqlSkeleton = request.getSqlSkeleton();
      String sql;
      if (sqlSkeleton != null)
      { // Missed with instanciated query, try with skeleton
        sql = sqlSkeleton;
        parsedRequest = (AbstractRequest) cache.get(sql);
        if (parsedRequest != null)
        { // Cache hit with skeleton
          request.cloneParsing(parsedRequest);
          return;
        }
      }
      else
        sql = instanciatedSQL;

      // Full cache miss. Note that the underlying cache Hashtable is
      // synchronized and we usually do not need to synchronize on it.
      // As we will have to add a cache entry, check if the cache size is ok
      // else remove the first entry of the hashtable.
      while (cache.size() > maxNbOfEntries)
      { // Remove first entry from Hashtable. We need to synchronize here to be
        // sure that we are not trying to concurrently remove the first cache
        // entry.
        synchronized (cache)
        {
          try
          {
            cache.remove(cache.keys().nextElement());
          }
          catch (Exception ignore)
          {
            break;
          }
        }
      }

      // Both skeleton and instanciated missed
      if (backgroundParsing)
      {
        // Find the parsing thread and request (note that Hasthtable is
        // synchronized)
        CurrentlyParsingEntry cpe = (CurrentlyParsingEntry) currentlyParsing
            .get(sql);
        if (cpe != null)
        {
          ParserThread pt = cpe.getParserThread();
          try
          {
            if (pt != null)
            {
              // Wait for completion
              pt.join();
              synchronized (currentlyParsing)
              {
                currentlyParsing.remove(sql);
              }

              // Update cache
              if ((granularity != ParsingGranularities.COLUMN_UNIQUE)
                  || (sqlSkeleton == null))
                // No skeleton or no uniqueness criteria, add the query
                cache.put(instanciatedSQL, cpe.getRequest());
              else
              { // We have a skeleton and COLUMN_UNIQUE parsing
                if (request.getCacheAbility() != RequestType.UNIQUE_CACHEABLE)
                  // It is NOT UNIQUE, add the skeleton
                  cache.put(sqlSkeleton, cpe.getRequest());
                else
                  // It is UNIQUE, add the instanciated query
                  cache.put(instanciatedSQL, cpe.getRequest());
              }
            }
          }
          catch (InterruptedException failed)
          {
            throw new SQLException(Translate.get(
                "cache.parsing.failed.join.parser.thread", new String[]{
                    "" + request.getId(), failed.getMessage()}));
          }
        }
      }
      // Parse it now because we didn't parse in background or
      // backgroundParsing has failed for any obscure reason.
      request.parse(requestManager.getDatabaseSchema(), granularity,
          caseSensitiveParsing);

      // Update cache
      if ((sqlSkeleton != null)
          && (granularity == ParsingGranularities.COLUMN_UNIQUE)
          && (request.getCacheAbility() == RequestType.UNIQUE_CACHEABLE))
        // If this is a unique request, we must put the instanciated query in
        // the cache to retrieve the exact pk value.
        cache.put(instanciatedSQL, request);
      else
        cache.put(sql, request);
    }
    else
      // Cache hit
      request.cloneParsing(parsedRequest);
  }

  public boolean isBackgroundParsing()
  {
    return backgroundParsing;
  }

  public void setBackgroundParsing(boolean backgroundParsing)
  {
    this.backgroundParsing = backgroundParsing;
  }

  public void setCaseSensitiveParsing(boolean isCaseSensitiveParsing)
  {
    this.caseSensitiveParsing = isCaseSensitiveParsing;
  }

  public boolean isCaseSensitiveParsing()
  {
    return caseSensitiveParsing;
  }

  public String getXml()
  {
    return "<" + DatabasesXmlTags.ELT_ParsingCache + " "
        + DatabasesXmlTags.ATT_backgroundParsing + "=\"" + backgroundParsing
        + "\" " + DatabasesXmlTags.ATT_maxNbOfEntries + "=\"" + maxNbOfEntries
        + "\"/>";
  }

}

---