CatalogObjectCache.java

Go to the documentation of this file.

// Copyright 2012 Cloudera Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.cloudera.impala.catalog;

import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.log4j.Logger;

import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;

public class CatalogObjectCache<T extends CatalogObject> implements Iterable<T> {
  private static final Logger LOG = Logger.getLogger(CatalogObjectCache.class);
  private final boolean caseInsensitiveKeys_;

  public CatalogObjectCache() {
    this(true);
  }

  public CatalogObjectCache(boolean caseInsensitiveKeys) {
    caseInsensitiveKeys_ = caseInsensitiveKeys;
  }

  // Map of lower-case object name to CatalogObject. New entries are added
  // by calling add(). Updates of the cache must be synchronized because adding
  // new entries may require two cache accesses that must be performed atomically.
  // TODO: For simplicity, consider using a (non-concurrent) HashMap and marking
  // all methods as synchronized.
  private final ConcurrentHashMap<String, T> metadataCache_ =
      new ConcurrentHashMap<String, T>();

  public synchronized boolean add(T catalogObject) {
    Preconditions.checkNotNull(catalogObject);
    String key = catalogObject.getName();
    if (caseInsensitiveKeys_) key = key.toLowerCase();
    T existingItem = metadataCache_.putIfAbsent(key, catalogObject);
    if (existingItem == null) return true;

    if (existingItem.getCatalogVersion() < catalogObject.getCatalogVersion()) {
      // When existingItem != null it indicates there was already an existing entry
      // associated with the key. Add the updated object iff it has a catalog
      // version greater than the existing entry.
      metadataCache_.put(key, catalogObject);
      return true;
    }
    return false;
  }

  public synchronized T remove(String name) {
    if (caseInsensitiveKeys_) name = name.toLowerCase();
    return metadataCache_.remove(name);
  }

  public synchronized void clear() {
    metadataCache_.clear();
  }

  public Set<String> keySet() {
    return metadataCache_.keySet();
  }

  public List<T> getValues() {
    return Lists.newArrayList(metadataCache_.values());
  }

  public boolean contains(String name) {
    if (caseInsensitiveKeys_) name = name.toLowerCase();
    return metadataCache_.containsKey(name);
  }

  public T get(String name) {
    if (caseInsensitiveKeys_) name = name.toLowerCase();
    return metadataCache_.get(name);
  }

  @Override
  public Iterator<T> iterator() {
    return metadataCache_.values().iterator();
  }
}