private static void setSourceReporterBindProps( Map<ActiveReservoir, List<Pair<String, Properties>>> sourceReporterBindProperties) { sourceReporterBindProps = Maps.newHashMapWithExpectedSize(sourceReporterBindProperties.size()); for (ActiveReservoir activeReservoir : sourceReporterBindProperties.keySet()) { List<Pair<Class<? extends ActiveReservoirReporter>, Properties>> values = Lists .newArrayListWithExpectedSize(sourceReporterBindProperties.get(activeReservoir).size()); sourceReporterBindProps.put(activeReservoir, values); for (Pair<String, Properties> entry : sourceReporterBindProperties.get(activeReservoir)) { try { Class clz = Class.forName(entry.getFirst()); if (ActiveReservoirReporter.class.isAssignableFrom(clz)) { values.add(new Pair(clz, entry.getSecond())); } else { logger.warn("The class " + clz + " is not a sub class of " + ActiveReservoir.class); } } catch (ClassNotFoundException e) { logger.warn("Cannot find class " + entry.getFirst()); } } } }
@Override public TableSignature getSignature() throws IOException { Pair<Long, Long> sizeAndLastModified; try { sizeAndLastModified = getSizeAndLastModified(path); } catch (FileNotFoundException ex) { sizeAndLastModified = Pair.newPair(-1L, 0L); } return new TableSignature(path, sizeAndLastModified.getFirst(), sizeAndLastModified.getSecond()); }
/** * Constructs a new pair, inferring the type via the passed arguments * @param <T1> type for first * @param <T2> type for second * @param a first element * @param b second element * @return a new pair containing the passed arguments */ public static <T1, T2> Pair<T1, T2> newPair(T1 a, T2 b) { return new Pair<T1, T2>(a, b); }
public void add(FileSystem fs, String path) { list.add(Pair.newPair(fs, path)); } }
@Override public boolean apply(@Nullable Pair<String, Integer> input) { return input.getFirst().equals(encodingName); } });
public Pair<TblColRef, TupleExpression> replaceColumnByIndex(int index, TblColRef newColumn, TupleExpression newTupleExpr) { if (index < 0 || index >= columns.size()) { return null; } TblColRef oldCol = columns.set(index, newColumn); TupleExpression oldExpr = sourceColumns.set(index, newTupleExpr); return new Pair<>(oldCol, oldExpr); }
/** * @return all loaded table names * @throws Exception on error */ public String[] loadTableToProject(TableDesc tableDesc, TableExtDesc extDesc, String project) throws IOException { return loadTablesToProject(Lists.newArrayList(Pair.newPair(tableDesc, extDesc)), project); }
private static String[] parseNamesFromCanonicalNames(String[] canonicalNames) { String[] result = new String[canonicalNames.length]; for (int i = 0; i < canonicalNames.length; i++) { result[i] = parseCanonicalName(canonicalNames[i]).getSecond(); } return result; }
private String renameTableWithinProject(String srcItem) { if (dstProject != null && srcItem.contains(ResourceStore.TABLE_RESOURCE_ROOT)) { String tableIdentity = TableDesc.parseResourcePath(srcItem).getFirst(); if (srcItem.contains(ResourceStore.TABLE_EXD_RESOURCE_ROOT)) return TableExtDesc.concatResourcePath(tableIdentity, dstProject); else return ResourceStore.TABLE_RESOURCE_ROOT + "/" + tableIdentity + "--" + dstProject + ".json"; } return srcItem; }
public static final Pair<ImmutableBitSet, ImmutableBitSet> getDimensionAndMetricColumnBitSet(final long baseCuboidId, final long childCuboidId, final int measureCount) { final Pair<ImmutableBitSet, ImmutableBitSet> parentDimensionAndMetricColumnBitSet = getDimensionAndMetricColumnBitSet(baseCuboidId, measureCount); ImmutableBitSet parentDimensions = parentDimensionAndMetricColumnBitSet.getFirst(); ImmutableBitSet measureColumns = parentDimensionAndMetricColumnBitSet.getSecond(); ImmutableBitSet childDimensions = parentDimensions; long mask = Long.highestOneBit(baseCuboidId); long parentCuboidIdActualLength = (long)Long.SIZE - Long.numberOfLeadingZeros(baseCuboidId); int index = 0; for (int i = 0; i < parentCuboidIdActualLength; i++) { if ((mask & baseCuboidId) > 0) { if ((mask & childCuboidId) == 0) { // this dim will be aggregated childDimensions = childDimensions.set(index, false); } index++; } mask = mask >> 1; } return Pair.newPair(childDimensions, measureColumns); } }
@Override public TupleExpression visitCaseCall(CaseTupleExpression caseExpr) { if (decorator != null) { List<Pair<TupleFilter, TupleExpression>> whenList = Lists .newArrayListWithExpectedSize(caseExpr.getWhenList().size()); for (Pair<TupleFilter, TupleExpression> entry : caseExpr.getWhenList()) { TupleFilter filter = decorator.convertInnerFilter(entry.getFirst()); TupleExpression whenEntry = decorator.convertInnerExpression(entry.getSecond()); whenList.add(new Pair<>(filter, whenEntry)); } TupleExpression elseExpr = caseExpr.getElseExpr(); if (elseExpr != null) { elseExpr = decorator.convertInnerExpression(elseExpr); } caseExpr = new CaseTupleExpression(whenList, elseExpr); } serializeExpression(0, caseExpr, buffer, cs); return caseExpr; }
public static Pair<String, String> getTableNameSplits(String tableName) { if (Strings.isNullOrEmpty(tableName)) { return null; } String[] splits = tableName.split(Pattern.quote(".")); int i = 0; String database = splits.length == 1 ? KYLIN_PREFIX : splits[i++]; String tableNameOnly = splits[i]; return new Pair(database, tableNameOnly); }
public static Pair<Short, Short> getShardAssignment() { String v = getString(DEBUG_TOGGLE_SHARD_ASSIGNMENT); if (v == null) { return null; } else { String[] parts = StringUtils.split(v, "#"); return Pair.newPair(Short.valueOf(parts[0]), Short.valueOf(parts[1])); } }
public static Map<Long, Long> readCuboidStatsFromCube(Set<Long> cuboidIds, CubeInstance cubeInstance) { Map<Long, Long> statisticsMerged = null; try { statisticsMerged = readCuboidStatsAndSizeFromCube(cuboidIds, cubeInstance).getFirst(); } catch (IOException e) { logger.warn("Fail to read statistics for cube " + cubeInstance.getName() + " due to " + e); } return statisticsMerged.isEmpty() ? null : statisticsMerged; }
/** * Re-encode with measures in Object[] format. * @param key * @param value * @return * @throws IOException */ public Pair<Text, Object[]> reEncode2(Text key, Text value) throws IOException { if (initialized == false) { throw new IllegalStateException("Not initialized"); } Object[] measureObjs = new Object[measureDescs.size()]; codec.decode(ByteBuffer.wrap(value.getBytes(), 0, value.getLength()), measureObjs); // re-encode measures if dictionary is used if (dictMeasures.size() > 0) { for (Pair<Integer, MeasureIngester> pair : dictMeasures) { int i = pair.getFirst(); MeasureIngester ingester = pair.getSecond(); measureObjs[i] = ingester.reEncodeDictionary(measureObjs[i], measureDescs.get(i), oldDicts, newDicts); } } return Pair.newPair(processKey(key), measureObjs); }