Examples with ColumnTypes io.questdb.cairo.ColumnTypes used on opensource projects

Example 1 with ColumnTypes

use of io.questdb.cairo.ColumnTypes in project Mycat2 by MyCATApache.

the class MapFactory method createMap.

public static Map createMap(IntInnerType[] keys, InnerType[] values) {
    ColumnTypes keyTypes = getKeyTypes(keys);
    int[] valueTypes = Arrays.stream(values).mapToInt(i -> toQuestDbType(i)).toArray();
    int MB = 1024 * 1024;
    return new FastMap(16 * MB, keyTypes, new ColumnTypes() {

        @Override
        public int getColumnCount() {
            return valueTypes.length;
        }

        @Override
        public int getColumnType(int columnIndex) {
            return valueTypes[columnIndex];
        }
    }, 128, 0.5, 64);
}

Example 2 with ColumnTypes

use of io.questdb.cairo.ColumnTypes in project Mycat2 by MyCATApache.

the class GroupByKeyWithAggPlan method execute.

@Override
public Observable<VectorSchemaRoot> execute(RootContext rootContext) {
    List<Field> fields = schema().getFields();
    InnerType[] innerTypes = schema().getFields().stream().map(i -> InnerType.from(i.getType())).toArray(n -> new InnerType[n]);
    if (groupByKeys.length > 0) {
        ColumnTypes arrayColumnTypes = RecordUtil.getArrayColumnTypes(accumulators);
        Map map = MapFactory.createMap2(innerTypes, arrayColumnTypes);
        RecordSink[] recordSinks = buildRecordSink(fields);
        return physicalPlan.execute(rootContext).reduce(map, (mapKey, input) -> {
            int rowCount = input.getRowCount();
            VectorBatchRecord record = new VectorBatchRecord(input);
            for (RecordSink recordSink : recordSinks) {
                for (int rowId = 0; rowId < rowCount; rowId++) {
                    record.setPosition(rowId);
                    MapKey key = mapKey.withKey();
                    RecordSetter recordSinkSPI = RecordSinkFactory.INSTANCE.getRecordSinkSPI(key);
                    recordSink.copy(record, recordSinkSPI);
                    MapValue value = key.createValue();
                    if (value.isNew()) {
                        for (AccumulatorFunction accumulator : accumulators) {
                            accumulator.computeFirst(value, record);
                        }
                    } else {
                        for (AccumulatorFunction accumulator : accumulators) {
                            accumulator.computeNext(value, record);
                        }
                    }
                }
            }
            physicalPlan.eachFree(input);
            return mapKey;
        }).map(map1 -> {
            int size = (int) map1.size();
            VectorSchemaRoot output = rootContext.getVectorSchemaRoot(schema(), size);
            RecordCursor cursor = map1.getCursor();
            cursor.toTop();
            int index = 0;
            while (cursor.hasNext()) {
                Record record = cursor.getRecord();
                functionSink.copy(accumulators, RecordUtil.wrapAsAggRecord(record), index++, output);
            }
            output.setRowCount(index);
            map1.clear();
            return output;
        }).toObservable().doOnComplete(() -> map.close());
    } else {
        SimpleMapValue mapValue = new SimpleMapValue(RecordUtil.getContextSize(accumulators));
        return physicalPlan.execute(rootContext).reduce(mapValue, new BiFunction<SimpleMapValue, VectorSchemaRoot, SimpleMapValue>() {

            AtomicBoolean first = new AtomicBoolean(true);

            @Override
            public SimpleMapValue apply(SimpleMapValue simpleMapValue, VectorSchemaRoot root) throws Throwable {
                int rowCount = root.getRowCount();
                VectorBatchRecord record = new VectorBatchRecord(root);
                if (first.compareAndSet(true, false)) {
                    record.setPosition(0);
                    for (AccumulatorFunction accumulator : accumulators) {
                        accumulator.computeFirst(mapValue, record);
                    }
                    for (int i = 1; i < rowCount; i++) {
                        record.setPosition(i);
                        for (AccumulatorFunction accumulator : accumulators) {
                            accumulator.computeNext(mapValue, record);
                        }
                    }
                } else {
                    for (int i = 0; i < rowCount; i++) {
                        record.setPosition(i);
                        for (AccumulatorFunction accumulator : accumulators) {
                            accumulator.computeNext(mapValue, record);
                        }
                    }
                }
                root.close();
                return simpleMapValue;
            }
        }).map(new Function<SimpleMapValue, VectorSchemaRoot>() {

            @Override
            public VectorSchemaRoot apply(SimpleMapValue simpleMapValue) throws Throwable {
                VectorSchemaRoot vectorSchemaRoot = rootContext.getVectorSchemaRoot(schema(), 1);
                vectorSchemaRoot.setRowCount(1);
                functionSink.copy(accumulators, RecordUtil.wrapAsAggRecord(simpleMapValue), 0, vectorSchemaRoot);
                return vectorSchemaRoot;
            }
        }).toObservable();
    }
}