Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you 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 org.apache.hadoop.hive.metastore;
 
 import static org.apache.hadoop.hive.metastore.MetaStoreUtils.DEFAULT_DATABASE_NAME;
 
 import java.util.List;
 import java.util.Map;
 
 import  org.apache.hadoop.conf.Configuration;
 import  org.apache.hadoop.fs.FileStatus;
 import  org.apache.hadoop.fs.FileSystem;
 import  org.apache.hadoop.fs.Path;
 import  org.apache.hadoop.util.ReflectionUtils;

This class represents a warehouse where data of Hive tables is stored
 
 public class Warehouse {
   private Path whRoot;
   private final Configuration conf;
   private final String whRootString;
 
   private static final String DATABASE_WAREHOUSE_SUFFIX = ".db";
 
   public static final Log LOG = LogFactory.getLog("hive.metastore.warehouse");
   
   private MetaStoreFS fsHandler = null;
 
   public Warehouse(Configuration confthrows MetaException {
     this. = conf;
      = HiveConf.getVar(conf..);
     if (StringUtils.isBlank()) {
           + " is not set in the config or blank");
     }
      = getMetaStoreFsHandler(conf);
   }
   
   private MetaStoreFS getMetaStoreFsHandler(Configuration conf)
       throws MetaException {
     String handlerClassStr = HiveConf.getVar(conf,
     try {
       Class<? extends MetaStoreFShandlerClass = (Class<? extends MetaStoreFS>) Class
           .forName(handlerClassStrtrue, JavaUtils.getClassLoader());
       MetaStoreFS handler = (MetaStoreFS) ReflectionUtils.newInstance(
           handlerClassconf);
       return handler;
     } catch (ClassNotFoundException e) {
       throw new MetaException("Error in loading MetaStoreFS handler."
           + e.getMessage());
     }
   }


  
Helper functions to convert IOException to MetaException
 
   public FileSystem getFs(Path fthrows MetaException {
     try {
       return f.getFileSystem();
     } catch (IOException e) {
       MetaStoreUtils.logAndThrowMetaException(e);
     }
     return null;
   }
 
  public static void closeFs(FileSystem fsthrows MetaException {
    try {
      if (fs != null) {
        fs.close();
      }
    } catch (IOException e) {
      MetaStoreUtils.logAndThrowMetaException(e);
    }
  }


  
Hadoop File System reverse lookups paths with raw ip addresses The File System URI always contains the canonical DNS name of the Namenode. Subsequently, operations on paths with raw ip addresses cause an exception since they don't match the file system URI. This routine solves this problem by replacing the scheme and authority of a path with the scheme and authority of the FileSystem that it maps to.

Parameters:
path Path to be canonicalized
Returns:
Path with canonical scheme and authority
  public Path getDnsPath(Path paththrows MetaException {
    FileSystem fs = getFs(path);
    return (new Path(fs.getUri().getScheme(), fs.getUri().getAuthority(), path
        .toUri().getPath()));
  }

  
Resolve the configured warehouse root dir with respect to the configuration This involves opening the FileSystem corresponding to the warehouse root dir (but that should be ok given that this is only called during DDL statements for non-external tables).
  private Path getWhRoot() throws MetaException {
    if ( != null) {
      return ;
    }
     = getDnsPath(new Path());
    return ;
  }
  public Path getDefaultDatabasePath(String dbNamethrows MetaException {
      return getWhRoot();
    }
    return new Path(getWhRoot(), dbName.toLowerCase() + );
  }
  public Path getDefaultTablePath(String dbNameString tableName)
      throws MetaException {
    return new Path(getDefaultDatabasePath(dbName), tableName.toLowerCase());
  }
  public boolean mkdirs(Path fthrows MetaException {
    FileSystem fs = null;
    try {
      fs = getFs(f);
      .debug("Creating directory if it doesn't exist: " + f);
      return (fs.mkdirs(f) || fs.getFileStatus(f).isDir());
    } catch (IOException e) {
      closeFs(fs);
      MetaStoreUtils.logAndThrowMetaException(e);
    }
    return false;
  }
  public boolean deleteDir(Path fboolean recursivethrows MetaException {
    FileSystem fs = getFs(f);
    return .deleteDir(fsfrecursive);
  }
  /*
  // NOTE: This is for generating the internal path name for partitions. Users
  // should always use the MetaStore API to get the path name for a partition.
  // Users should not directly take partition values and turn it into a path
  // name by themselves, because the logic below may change in the future.
  //
  // In the future, it's OK to add new chars to the escape list, and old data
  // won't be corrupt, because the full path name in metastore is stored.
  // In that case, Hive will continue to read the old data, but when it creates
  // new partitions, it will use new names.
  static BitSet charToEscape = new BitSet(128);
  static {
    for (char c = 0; c < ' '; c++) {
      charToEscape.set(c);
    }
    char[] clist = new char[] { '"', '#', '%', '\'', '*', '/', ':', '=', '?',
        '\\', '\u00FF' };
    for (char c : clist) {
      charToEscape.set(c);
    }
  }
  static boolean needsEscaping(char c) {
    return c >= 0 && c < charToEscape.size() && charToEscape.get(c);
  }
  */
  static String escapePathName(String path) {
    return FileUtils.escapePathName(path);
  }
  static String unescapePathName(String path) {
    return FileUtils.unescapePathName(path);
  }

  
Given a partition specification, return the path corresponding to the partition spec. By default, the specification does not include dynamic partitions.

Parameters:
spec
Returns:
string representation of the partition specification.
Throws:
MetaException
  public static String makePartPath(Map<StringStringspec)
      throws MetaException {
    return makePartName(spectrue);
  }

  
Makes a partition name from a specification

Parameters:
spec
addTrailingSeperator if true, adds a trailing separator e.g. 'ds=1/'
Returns:
Throws:
MetaException
  public static String makePartName(Map<StringStringspec,
      boolean addTrailingSeperator)
      throws MetaException {
    StringBuilder suffixBuf = new StringBuilder();
    int i = 0;
    for (Entry<StringStringe : spec.entrySet()) {
      if (e.getValue() == null || e.getValue().length() == 0) {
        throw new MetaException("Partition spec is incorrect. " + spec);
      }
      if (i>0) {
        suffixBuf.append(Path.SEPARATOR);
      }
      suffixBuf.append(escapePathName(e.getKey()));
      suffixBuf.append('=');
      suffixBuf.append(escapePathName(e.getValue()));
      i++;
    }
    if (addTrailingSeperator) {
      suffixBuf.append(Path.SEPARATOR);
    }
    return suffixBuf.toString();
  }
  
Given a dynamic partition specification, return the path corresponding to the static part of partition specification. This is basically a copy of makePartName but we get rid of MetaException since it is not serializable.

Parameters:
spec
Returns:
string representation of the static part of the partition specification.
  public static String makeDynamicPartName(Map<StringStringspec) {
    StringBuilder suffixBuf = new StringBuilder();
    for (Entry<StringStringe : spec.entrySet()) {
      if (e.getValue() != null && e.getValue().length() > 0) {
        suffixBuf.append(escapePathName(e.getKey()));
        suffixBuf.append('=');
        suffixBuf.append(escapePathName(e.getValue()));
        suffixBuf.append(Path.SEPARATOR);
      } else { // stop once we see a dynamic partition
        break;
      }
    }
    return suffixBuf.toString();
  }
  static final Pattern pat = Pattern.compile("([^/]+)=([^/]+)");
  public static LinkedHashMap<StringStringmakeSpecFromName(String name)
      throws MetaException {
    if (name == null || name.isEmpty()) {
      throw new MetaException("Partition name is invalid. " + name);
    }
    LinkedHashMap<StringStringpartSpec = new LinkedHashMap<StringString>();
    makeSpecFromName(partSpecnew Path(name));
    return partSpec;
  }
  public static void makeSpecFromName(Map<StringStringpartSpec, Path currPath) {
    List<String[]> kvs = new ArrayList<String[]>();
    do {
      String component = currPath.getName();
      Matcher m = .matcher(component);
      if (m.matches()) {
        String k = unescapePathName(m.group(1));
        String v = unescapePathName(m.group(2));
        String[] kv = new String[2];
        kv[0] = k;
        kv[1] = v;
        kvs.add(kv);
      }
      currPath = currPath.getParent();
    } while (currPath != null && !currPath.getName().isEmpty());
    // reverse the list since we checked the part from leaf dir to table's base dir
    for (int i = kvs.size(); i > 0; i--) {
      partSpec.put(kvs.get(i - 1)[0], kvs.get(i - 1)[1]);
    }
  }
  public Path getPartitionPath(String dbNameString tableName,
      LinkedHashMap<StringStringpmthrows MetaException {
    return new Path(getDefaultTablePath(dbNametableName), makePartPath(pm));
  }
  public Path getPartitionPath(Path tblPathLinkedHashMap<StringStringpm)
      throws MetaException {
    return new Path(tblPathmakePartPath(pm));
  }
  public boolean isDir(Path fthrows MetaException {
    FileSystem fs = null;
    try {
      fs = getFs(f);
      FileStatus fstatus = fs.getFileStatus(f);
      if (!fstatus.isDir()) {
        return false;
      }
    } catch (FileNotFoundException e) {
      return false;
    } catch (IOException e) {
      closeFs(fs);
      MetaStoreUtils.logAndThrowMetaException(e);
    }
    return true;
  }
  public static String makePartName(List<FieldSchemapartCols,
      List<Stringvalsthrows MetaException {
    if ((partCols.size() != vals.size()) || (partCols.size() == 0)) {
      throw new MetaException("Invalid partition key & values");
    }
    List<StringcolNames = new ArrayList<String>();
    for (FieldSchema colpartCols) {
      colNames.add(col.getName());
    }
    return FileUtils.makePartName(colNamesvals);
  }
  public static List<StringgetPartValuesFromPartName(String partName)
      throws MetaException {
    LinkedHashMap<StringStringpartSpec = Warehouse.makeSpecFromName(partName);
    List<Stringvalues = new ArrayList<String>();
    values.addAll(partSpec.values());
    return values;
  }
New to GrepCode? Check out our FAQ X