@Override public Field getField() { return vector.getField(); }
@Override public Object getObject(int index) throws InvalidAccessException { return v.getObject(index); }
private boolean nullFilled(ValueVector vector) { for (int r = 0; r < vector.getValueCount(); r++) { if (!vector.isNull(r)) { return false; } } return true; }
/** * Decodes a dictionary encoded array using the provided dictionary. * * @param indices dictionary encoded values, must be int type * @param dictionary dictionary used to decode the values * @return vector with values restored from dictionary */ public static ValueVector decode(ValueVector indices, Dictionary dictionary) { int count = indices.getValueCount(); ValueVector dictionaryVector = dictionary.getVector(); int dictionaryCount = dictionaryVector.getValueCount(); // copy the dictionary values into the decoded vector TransferPair transfer = dictionaryVector.getTransferPair(indices.getAllocator()); transfer.getTo().allocateNewSafe(); for (int i = 0; i < count; i++) { Object index = indices.getObject(i); if (index != null) { int indexAsInt = ((Number) index).intValue(); if (indexAsInt > dictionaryCount) { throw new IllegalArgumentException("Provided dictionary does not contain value for index " + indexAsInt); } transfer.copyValueSafe(indexAsInt, i); } } // TODO do we need to worry about the field? ValueVector decoded = transfer.getTo(); decoded.setValueCount(count); return decoded; }
@Override public Object getObject(int index) { Map<String, Object> vv = new JsonStringHashMap<>(); for (String child : getChildFieldNames()) { ValueVector v = getChild(child); if (v != null && index < v.getValueCount()) { Object value = v.getObject(index); if (value != null) { vv.put(child, value); } } } return vv; }
public void setValueCount(int valueCount){ vector.setValueCount(valueCount); }
@Override public void dataArrived(QueryDataBatch result, ConnectionThrottle throttle) { QueryData queryHeader = result.getHeader(); int rows = queryHeader.getRowCount(); try { if ( result.hasData() ) { ArrowBuf data = result.getData(); loader.load(queryHeader.getDef(), data); for (int i = 0; i < rows; i++) { Map<String,String> record = Maps.newHashMap(); for (VectorWrapper<?> vw : loader) { final String field = vw.getValueVector().getField().getName(); final ValueVector vv = vw.getValueVector(); final Object value = i < vv.getValueCount() ? vv.getObject(i) : null; final String display = value == null ? null : value.toString(); record.put(field, display); } records.add(record); } loader.clear(); } result.release(); } catch (SchemaChangeException e) { fail(e.getMessage()); } }
@Override public void allocate() { vector.allocateNew(); }
@Override public void clear() { if (!releasable) { return; } for (T x : vectors) { x.clear(); } }
@Override public TimeStampNanoTZWriter timeStampNanoTZ(String name, String timezone) { FieldWriter writer = fields.get(handleCase(name)); if(writer == null) { ValueVector vector; ValueVector currentVector = container.getChild(name); TimeStampNanoTZVector v = container.addOrGet(name, FieldType.nullable( new org.apache.arrow.vector.types.pojo.ArrowType.Timestamp(org.apache.arrow.vector.types.TimeUnit.NANOSECOND, timezone) ), TimeStampNanoTZVector.class); writer = new PromotableWriter(v, container, getNullableStructWriterFactory()); vector = v; if (currentVector == null || currentVector != vector) { if(this.initialCapacity > 0) { vector.setInitialCapacity(this.initialCapacity); } vector.allocateNewSafe(); } writer.setPosition(idx()); fields.put(handleCase(name), writer); } else { if (writer instanceof PromotableWriter) { // ensure writers are initialized ((PromotableWriter)writer).getWriter(MinorType.TIMESTAMPNANOTZ); } } return writer; }
@Override public int outputData() { if(checkForStraightCopy && incoming.getRecordCount() == randomVector.getValueCount()){ for(TransferPair tp : transferPairs){ tp.transfer(); } output.setRecordCount(incoming.getRecordCount()); state = State.CAN_CONSUME; return incoming.getRecordCount(); } int recordCount = incoming.getRecordCount() - this.copyOffset; int copiedRecords = copier.copyRecords(copyOffset, recordCount); if(copiedRecords < recordCount){ copyOffset = copyOffset + copiedRecords; }else{ copyOffset = 0; state = State.CAN_CONSUME; } if(copiedRecords > 0){ for(VectorWrapper<?> v : output){ v.getValueVector().setValueCount(copiedRecords); } } output.setRecordCount(copiedRecords); return copiedRecords; }
public void getFieldById(int fieldId, ComplexHolder holder) { final ValueVector vv = vectors[fieldId]; if (vv instanceof BaseValueVector) { holder.isSet =vv.isNull(currentIndex) ? 1 : 0; } else { holder.isSet = vv.isNull(currentIndex) ? 1 : 0; } holder.reader = vv.getReader(); holder.reader.setPosition(currentIndex); }
@SuppressWarnings("unchecked") @Override public VectorWrapper<T> cloneAndTransfer(BufferAllocator allocator, CallBack callback) { try{ TransferPair tp = vector.getTransferPair(vector.getField().getName(), allocator, callback); tp.transfer(); return new SimpleVectorWrapper<T>((T) tp.getTo()); }catch(RuntimeException ex){ throw ex; } }
final void close() { vector.close(); }
/** * Returns an instance sitting at the given index if exists, null otherwise. * * @see com.dremio.exec.vector.accessor.SqlAccessor#getObject(int) */ @Override public Object getObject(int rowOffset) throws InvalidAccessException { // In case some vectors have fewer values than others, and callee invokes // this method with index >= getValueCount(), this should still yield null. if (rowOffset < vector.getValueCount()) { return delegate.getObject(rowOffset); } return null; } }
boolean isNullAt(int rowId) { return vector.isNull(rowId); }
@Override public ArrowBuf[] getBuffers(boolean clear) { final List<ArrowBuf> buffers = new ArrayList<>(); for (final ValueVector vector : vectors.values()) { for (final ArrowBuf buf : vector.getBuffers(false)) { buffers.add(buf); if (clear) { buf.retain(1); } } if (clear) { vector.clear(); } } return buffers.toArray(new ArrowBuf[buffers.size()]); }
public boolean allocateNewSafe() { for (VectorWrapper<?> w : wrappers) { if (!w.getValueVector().allocateNewSafe()) { return false; } } return true; }
@Override public Object next() { if (currVec == null || indexInCurrentVector == currVec.getValueCount()) { currVec = hyperVector.getValueVectors()[indexInVectorList]; indexInVectorList++; indexInCurrentVector = 0; } Object obj = currVec.getObject(indexInCurrentVector); indexInCurrentVector++; totalValuesRead++; return obj; }