How to use

ValueVector

in

org.apache.arrow.vector

@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;
}

@Before
public void setUp() throws Exception {
 valueVector = mock(ValueVector.class);
 when(valueVector.getObject(anyInt())).thenAnswer(new Answer<Object>() {
 when(valueVector.isNull(anyInt())).thenAnswer(new Answer<Object>() {

@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;
}