public static GTInfo basicInfo() { Builder builder = infoBuilder(); GTInfo info = builder.build(); return info; }
@Override protected Object[] finalizeResult(GTRecord record) { decodeAndSetDimensions(record); // decode metrics for (int i = 0; i < gtMetricsIdx.length; i++) { result[gtDimsIdx.length + i] = record.decodeValue(gtMetricsIdx[i]); } return result; }
public static GTInfo advancedInfo() { Builder builder = infoBuilder(); builder.enableColumnBlock(new ImmutableBitSet[] { setOf(0), setOf(1, 2), setOf(3, 4) }); builder.enableRowBlock(4); return builder.build(); }
public void append(GTRecord r) { // add record to block if (isEmpty()) { r.exportColumns(info.primaryKey, primaryKey); } for (int i = 0; i < info.colBlocks.length; i++) { r.exportColumnBlock(i, cellBlockBuffers[i]); } nRows++; }
protected GTFunctionScanner(IGTScanner rawScanner, GTScanRequest req) { this.rawScanner = rawScanner; this.tupleExpressionMap = req.getTupleExpressionMap(); this.rtAggrMetrics = req.getRtAggrMetrics(); this.oneTuple = new IEvaluatableTuple() { @Override public Object getValue(TblColRef col) { int idx = col.getColumnDesc().getZeroBasedIndex(); return rtAggrMetrics.get(idx) ? DecimalUtil.toBigDecimal(next.getValue(idx)) : next.get(idx); } }; this.filterCodeSystem = GTUtil.wrap(getInfo().codeSystem.getComparator()); }
public FilterResultCache(GTInfo info, TupleFilter filter) { colsInFilter = collectColumnsInFilter(filter); lastValues = new byte[info.getMaxColumnLength(colsInFilter)]; lastResult = new boolean[1]; }
@Override public Iterator<GTRecord> iterator() { return new StreamMergeGTRecordIterator(delegated.iterator()); }
public IGTScanner scan(GTScanRequest req) throws IOException { IGTScanner result = store.scan(req); return req.decorateScanner(result); }
public Iterator<Object[]> valuesIterator(int[] gtDimsIdx, int[] gtMetricsIdx) { return new StreamMergeValuesIterator(delegated.iterator(), gtDimsIdx, gtMetricsIdx); }
private static TupleFilter convertFilter(TupleFilter rootFilter, final GTInfo info, // final Map<TblColRef, Integer> colMapping, final boolean encodeConstants, // final Set<TblColRef> unevaluatableColumnCollector) { IFilterCodeSystem<ByteArray> filterCodeSystem = wrap(info.codeSystem.getComparator()); GTConvertDecorator decorator = new GTConvertDecorator(unevaluatableColumnCollector, colMapping, info, encodeConstants); byte[] bytes = TupleFilterSerializer.serialize(rootFilter, decorator, filterCodeSystem); return TupleFilterSerializer.deserialize(bytes, filterCodeSystem); }
/** decode and return the values of this record */ public Object[] getValues() { return getValues(info.colAll, new Object[info.getColumnCount()]); }
@Override public Iterator<GTRecord> iterator() { return delegated.iterator(); } }
@Override public IGTCodeSystem deserialize(ByteBuffer in) { return new GTSampleCodeSystem(); } };
public CubeCodeSystem(DimensionEncoding[] dimEncs, Map<Integer, Integer> dependentMetricsMap) { this.dimEncs = dimEncs; this.comparator = new DefaultGTComparator(); this.dependentMetricsMap = dependentMetricsMap; }
public static long estimateSizeOfAggrCache(byte[] keySample, MeasureAggregator<?>[] aggrSample, int size) { // Aggregation cache is basically a tree map. The tree map entry overhead is // - 40 according to http://java-performance.info/memory-consumption-of-java-data-types-2/ // - 41~52 according to AggregationCacheMemSizeTest return (estimateSizeOf(keySample) + estimateSizeOf(aggrSample) + 64) * size; }
@Override public void encodeColumnValue(int col, Object value, int roundingFlag, ByteBuffer buf) { // ignore rounding encodeColumnValue(col, value, buf); }
public GTInfo build() { info.validate(); return info; } }
@Override protected Object[] finalizeResult(GTRecord record, Object[] aggStates) { decodeAndSetDimensions(record); // set metrics for (int i = 0; i < aggIdx.length; i++) { result[gtDimsIdx.length + i] = aggStates[aggIdx[i]]; } return result; } }