private final String getNsOrDefault(String ns) { // This is only needed for old clients not setting NS in requests. // Not clear how to handle this... this is properly a HS2 config but metastore needs its default // value for backward compat, and we don't want it configurable separately because it's also // used in upgrade scripts, were it cannot be configured. return normalizeIdentifier(ns == null ? "default" : ns); }
public static boolean matches(String name, String pattern) { String[] subpatterns = pattern.trim().split("\\|"); for (String subpattern : subpatterns) { subpattern = "(?i)" + subpattern.replaceAll("\\?", ".{1}").replaceAll("\\*", ".*") .replaceAll("\\^", "\\\\^").replaceAll("\\$", "\\\\$"); if (Pattern.matches(subpattern, StringUtils.normalizeIdentifier(name))) { return true; } } return false; } }
@Override void setCommandLineArguments(SchemaToolCommandLine cl) { fromCatName = normalizeIdentifier(cl.getOptionValue("fromCatalog")); toCatName = normalizeIdentifier(cl.getOptionValue("toCatalog")); dbName = normalizeIdentifier(cl.getOptionValue("moveDatabase")); }
@Override public boolean dropDatabase(String catName, String dbName) throws NoSuchObjectException, MetaException { boolean succ = rawStore.dropDatabase(catName, dbName); if (succ && !canUseEvents) { // in case of event based cache update, cache will be updated during commit. sharedCache.removeDatabaseFromCache(StringUtils.normalizeIdentifier(catName), StringUtils.normalizeIdentifier(dbName)); } return succ; }
@Override public boolean alterDatabase(String catName, String dbName, Database db) throws NoSuchObjectException, MetaException { boolean succ = rawStore.alterDatabase(catName, dbName, db); if (succ && !canUseEvents) { // in case of event based cache update, cache will be updated during commit. sharedCache.alterDatabaseInCache(StringUtils.normalizeIdentifier(catName), StringUtils.normalizeIdentifier(dbName), db); } return succ; }
private StringBuilder appendPatternCondition(StringBuilder builder, String fieldName, String elements, List<String> parameters) { elements = normalizeIdentifier(elements); return appendCondition(builder, fieldName, elements.split("\\|"), true, parameters); }
@Override void setCommandLineArguments(SchemaToolCommandLine cl) { fromCat = normalizeIdentifier(cl.getOptionValue("fromCatalog")); toCat = normalizeIdentifier(cl.getOptionValue("toCatalog")); fromDb = normalizeIdentifier(cl.getOptionValue("fromDatabase")); toDb = normalizeIdentifier(cl.getOptionValue("toDatabase")); tableName = normalizeIdentifier(cl.getOptionValue("moveTable")); }
@Override public List<TableMeta> getTableMeta(String catName, String dbNames, String tableNames, List<String> tableTypes) throws MetaException { // TODO Check if all required tables are allowed, if so, get it from cache if (!isBlacklistWhitelistEmpty(conf) || !isCachePrewarmed.get() || (canUseEvents && rawStore.isActiveTransaction())) { return rawStore.getTableMeta(catName, dbNames, tableNames, tableTypes); } return sharedCache.getTableMeta(StringUtils.normalizeIdentifier(catName), StringUtils.normalizeIdentifier(dbNames), StringUtils.normalizeIdentifier(tableNames), tableTypes); }
private void updateTablePartitions(RawStore rawStore, String catName, String dbName, String tblName) { try { Deadline.startTimer("getPartitions"); List<Partition> partitions = rawStore.getPartitions(catName, dbName, tblName, Integer.MAX_VALUE); Deadline.stopTimer(); sharedCache.refreshPartitionsInCache(StringUtils.normalizeIdentifier(catName), StringUtils.normalizeIdentifier(dbName), StringUtils.normalizeIdentifier(tblName), partitions); } catch (MetaException | NoSuchObjectException e) { LOG.info("Updating CachedStore: unable to read partitions of table: " + tblName, e); } }
public List<String> listCachedTableNames(String catName, String dbName) { List<String> tableNames = new ArrayList<>(); try { cacheLock.readLock().lock(); for (TableWrapper wrapper : tableCache.values()) { if (wrapper.sameDatabase(catName, dbName)) { tableNames.add(StringUtils.normalizeIdentifier(wrapper.getTable().getTableName())); } } } finally { cacheLock.readLock().unlock(); } return tableNames; }
private List<MOrder> convertToMOrders(List<Order> keys) { List<MOrder> mkeys = null; if (keys != null) { mkeys = new ArrayList<>(keys.size()); for (Order part : keys) { mkeys.add(new MOrder(normalizeIdentifier(part.getCol()), part.getOrder())); } } return mkeys; }
@Override public List<String> getTables(String catName, String dbName, String pattern) throws MetaException { if (!isBlacklistWhitelistEmpty(conf) || !isCachePrewarmed.get() || (canUseEvents && rawStore.isActiveTransaction())) { return rawStore.getTables(catName, dbName, pattern); } return sharedCache.listCachedTableNames(StringUtils.normalizeIdentifier(catName), StringUtils.normalizeIdentifier(dbName), pattern, (short) -1); }
@Override public List<String> getTables(String catName, String dbName, String pattern, TableType tableType) throws MetaException { if (!isBlacklistWhitelistEmpty(conf) || !isCachePrewarmed.get() || (canUseEvents && rawStore.isActiveTransaction())) { return rawStore.getTables(catName, dbName, pattern, tableType); } return sharedCache.listCachedTableNames(StringUtils.normalizeIdentifier(catName), StringUtils.normalizeIdentifier(dbName), pattern, tableType); }
@Override public List<String> getAllTables(String catName, String dbName) throws MetaException { if (!isBlacklistWhitelistEmpty(conf) || !isCachePrewarmed.get() || (canUseEvents && rawStore.isActiveTransaction())) { return rawStore.getAllTables(catName, dbName); } return sharedCache.listCachedTableNames(StringUtils.normalizeIdentifier(catName), StringUtils.normalizeIdentifier(dbName)); }
@Override public void alterCatalog(String catName, Catalog cat) throws MetaException, InvalidOperationException { rawStore.alterCatalog(catName, cat); // in case of event based cache update, cache will not be updated for catalog. if (!canUseEvents) { sharedCache.alterCatalogInCache(StringUtils.normalizeIdentifier(catName), cat); } }
@Override void setCommandLineArguments(SchemaToolCommandLine cl) { catName = normalizeIdentifier(cl.getOptionValue("alterCatalog")); location = cl.getOptionValue("catalogLocation"); description = cl.getOptionValue("catalogDescription"); }
@Override public Catalog getCatalog(String catalogName) throws NoSuchObjectException, MetaException { // in case of event based cache update, cache will not be updated for catalog. if (!sharedCache.isCatalogCachePrewarmed() || canUseEvents) { return rawStore.getCatalog(catalogName); } Catalog cat = sharedCache.getCatalogFromCache(normalizeIdentifier(catalogName)); if (cat == null) { throw new NoSuchObjectException(); } return cat; }
@Override void setCommandLineArguments(SchemaToolCommandLine cl) { catName = normalizeIdentifier(cl.getOptionValue("createCatalog")); location = cl.getOptionValue("catalogLocation"); description = cl.getOptionValue("catalogDescription"); ifNotExists = cl.hasOption("ifNotExists"); }
private MCatalog catToMCat(Catalog cat) { MCatalog mCat = new MCatalog(); mCat.setName(normalizeIdentifier(cat.getName())); if (cat.isSetDescription()) { mCat.setDescription(cat.getDescription()); } mCat.setLocationUri(cat.getLocationUri()); mCat.setCreateTime(cat.getCreateTime()); return mCat; }
private MISchema convertToMISchema(ISchema schema) throws NoSuchObjectException { return new MISchema(schema.getSchemaType().getValue(), normalizeIdentifier(schema.getName()), getMDatabase(schema.getCatName(), schema.getDbName()), schema.getCompatibility().getValue(), schema.getValidationLevel().getValue(), schema.isCanEvolve(), schema.isSetSchemaGroup() ? schema.getSchemaGroup() : null, schema.isSetDescription() ? schema.getDescription() : null); }