src/org/objectweb/cjdbc/controller/cache/metadata/MetadataCache.java

説明を見る。

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

import java.util.Hashtable;

import org.objectweb.cjdbc.common.i18n.Translate;
import org.objectweb.cjdbc.common.sql.AbstractRequest;
import org.objectweb.cjdbc.common.xml.DatabasesXmlTags;
import org.objectweb.cjdbc.driver.Field;

public class MetadataCache
{
  private Hashtable metadataCache;  // SQL -> Field[]
  private Hashtable fieldCache;     // Column name -> Field
  private int       maxNbOfMetadata;
  private int       maxNbOfField;

  public MetadataCache(int maxNbOfMetadata, int maxNbOfField)
  {
    metadataCache = new Hashtable(maxNbOfMetadata == 0
        ? 10000
        : maxNbOfMetadata);
    fieldCache = new Hashtable(maxNbOfField == 0 ? 100 : maxNbOfField);
    if (maxNbOfMetadata < 0)
      throw new RuntimeException(Translate.get("cache.metadata.invalid.size",
          maxNbOfMetadata));
    if (maxNbOfMetadata == 0)
      this.maxNbOfMetadata = Integer.MAX_VALUE;
    else
      this.maxNbOfMetadata = maxNbOfMetadata;
    if (maxNbOfField < 0)
      throw new RuntimeException(Translate.get("cache.metadata.invalid.size",
          maxNbOfField));
    if (maxNbOfField == 0)
      this.maxNbOfField = Integer.MAX_VALUE;
    else
      this.maxNbOfField = maxNbOfField;
  }

  public Field[] getMetadata(AbstractRequest request)
  {
    String sqlSkeleton = request.getSqlSkeleton();
    if (sqlSkeleton != null)
      return (Field[]) metadataCache.get(sqlSkeleton);
    else
      return (Field[]) metadataCache.get(request.getSQL());
  }

  public void addMetadata(AbstractRequest request, Field[] metadata)
  {
    // 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 (metadataCache.size() > maxNbOfMetadata)
    { // 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 (metadataCache)
      {
        try
        {
          metadataCache.remove(metadataCache.keys().nextElement());
        }
        catch (Exception ignore)
        {
          break;
        }
      }
    }

    // Add to cache
    String sqlSkeleton = request.getSqlSkeleton();
    if (sqlSkeleton != null)
      metadataCache.put(sqlSkeleton, metadata);
    else
      metadataCache.put(request.getSQL(), metadata);
  }

  public Field getField(String columnName)
  {
    return (Field) fieldCache.get(columnName);
  }

  public void addField(String columnName, Field field)
  {
    // 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 (fieldCache.size() > maxNbOfField)
    { // 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 (fieldCache)
      {
        try
        {
          fieldCache.remove(fieldCache.keys().nextElement());
        }
        catch (Exception ignore)
        {
          break;
        }
      }
    }
    // Add to cache
    fieldCache.put(columnName, field);
  }

  public String getXml()
  {
    return "<" + DatabasesXmlTags.ELT_MetadataCache + " "
        + DatabasesXmlTags.ATT_maxNbOfMetadata + "=\"" + maxNbOfMetadata
        + "\" " + DatabasesXmlTags.ATT_maxNbOfField + "=\"" + (maxNbOfField == Integer.MAX_VALUE ? 0 : maxNbOfField)
        + "\"/>";
  }

}

---