import io.netty.buffer.DrillBuf; //导入依赖的package包/类
@Test
public void testVectorCanLoadEmptyBuffer() throws Exception {
  final DrillBuf empty = allocator.getEmpty();

  testVectors(new VectorVerifier() {

    @Override
    public void verify(ValueVector vector) {
      final String hint = String.format("%s failed the test case", vector.getClass().getSimpleName());
      final UserBitShared.SerializedField metadata = vector.getMetadata();
      assertEquals(hint, 0, metadata.getBufferLength());
      assertEquals(hint, 0, metadata.getValueCount());

      vector.load(metadata, empty);

      assertEquals(hint, 0, vector.getValueCapacity());
      assertEquals(hint, 0, vector.getAccessor().getValueCount());

      vector.clear();
    }
  });
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
@Override
public DrillBuf[] getBuffers(boolean clear) {
  DrillBuf[] out;
  if (getBufferSize() == 0) {
    out = new DrillBuf[0];
  } else {
    out = new DrillBuf[]{data};
    if (clear) {
      data.readerIndex(0);
      data.retain(1);
    }
  }
  if (clear) {
    clear();
  }
  return out;
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
@Override
public void load(SerializedField metadata, DrillBuf buffer) {
  final List<SerializedField> children = metadata.getChildList();

  final SerializedField offsetField = children.get(0);
  offsets.load(offsetField, buffer);
  int bufOffset = offsetField.getBufferLength();

  for (int i = 1; i < children.size(); i++) {
    final SerializedField child = children.get(i);
    final MaterializedField fieldDef = MaterializedField.create(child);
    ValueVector vector = getChild(fieldDef.getLastName());
    if (vector == null) {
      // if we arrive here, we didn't have a matching vector.
      vector = TypeHelper.getNewVector(fieldDef, allocator);
      putChild(fieldDef.getLastName(), vector);
    }
    final int vectorLength = child.getBufferLength();
    vector.load(child, buffer.slice(bufOffset, vectorLength));
    bufOffset += vectorLength;
  }

  assert bufOffset == buffer.capacity();
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
@Override
public void load(SerializedField metadata, DrillBuf buf) {
  final List<SerializedField> fields = metadata.getChildList();
  valueCount = metadata.getValueCount();

  int bufOffset = 0;
  for (final SerializedField child : fields) {
    final MaterializedField fieldDef = MaterializedField.create(child);

    ValueVector vector = getChild(fieldDef.getLastName());
    if (vector == null) {
      // if we arrive here, we didn't have a matching vector.
      vector = TypeHelper.getNewVector(fieldDef, allocator);
      putChild(fieldDef.getLastName(), vector);
    }
    if (child.getValueCount() == 0) {
      vector.clear();
    } else {
      vector.load(child, buf.slice(bufOffset, child.getBufferLength()));
    }
    bufOffset += child.getBufferLength();
  }

  assert bufOffset == buf.capacity();
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
@Override
public DrillBuf[] getBuffers(boolean clear) {
  List<DrillBuf> buffers = Lists.newArrayList();

  for (ValueVector vector : vectors.values()) {
    for (DrillBuf buf : vector.getBuffers(false)) {
      buffers.add(buf);
      if (clear) {
        buf.retain();
      }
    }
    if (clear) {
      vector.clear();
    }
  }

  return buffers.toArray(new DrillBuf[buffers.size()]);
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
@Override
public boolean setSafe(int index, DrillBuf bytebuf, int start, int length) {
  if (index >= varCharVector.getValueCapacity()) {
    return false;
  }

  if (usingDictionary) {
    currDictValToWrite = pageReader.dictionaryValueReader.readBytes();
    mutator.setSafe(index, currDictValToWrite.toByteBuffer(), 0, currDictValToWrite.length());
  } else {
    mutator.setSafe(index, start, start + length, bytebuf);
  }
  return true;
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
private boolean transfer(Accountor target, DrillBuf buf, long size, boolean release) {
  boolean withinLimit = target.forceAdditionalReservation(size);
  if(release){
    release(buf, size);
  }

  if (ENABLE_ACCOUNTING) {
    target.buffers.put(buf, new DebugStackTrace(buf.capacity(), Thread.currentThread().getStackTrace()));
  }
  return withinLimit;
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
public void releasePartial(DrillBuf buf, long size) {
  remainder.returnAllocation(size);
  if (ENABLE_ACCOUNTING) {
    if (buf != null) {
      DebugStackTrace dst = buffers.get(buf);
      if (dst == null) {
        throw new IllegalStateException("Partially releasing a buffer that has already been released. Buffer: " + buf);
      }
      dst.size -= size;
      if (dst.size < 0) {
        throw new IllegalStateException("Partially releasing a buffer that has already been released. Buffer: " + buf);
      }
    }
  }
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
public void release(DrillBuf buf, long size) {
  remainder.returnAllocation(size);
  if (ENABLE_ACCOUNTING) {
    if (buf != null && buffers.remove(buf) == null) {
      throw new IllegalStateException("Releasing a buffer that has already been released. Buffer: " + buf);
    }
  }
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
public static int compareSparseSamePrecScale(DrillBuf left, int lStart, byte[] right, int length) {
  // check the sign first
  boolean lSign = (left.getInt(lStart) & 0x80000000) != 0;
  boolean rSign = ByteFunctionHelpers.getSign(right);
  int cmp = 0;

  if (lSign != rSign) {
    return (lSign == false) ? 1 : -1;
  }

  // invert the comparison if we are comparing negative numbers
  int invert = (lSign == true) ? -1 : 1;

  // compare byte by byte
  int n = 0;
  int lPos = lStart;
  int rPos = 0;
  while (n < length/4) {
    int leftInt = Decimal38SparseHolder.getInteger(n, lStart, left);
    int rightInt = ByteFunctionHelpers.getInteger(right, n);
    if (leftInt != rightInt) {
      cmp =  (leftInt - rightInt ) > 0 ? 1 : -1;
      break;
    }
    n++;
  }
  return cmp * invert;
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
public void loadPage(DrillBuf target, int pageLength) throws IOException {
  target.clear();
  ByteBuffer directBuffer = target.nioBuffer(0, pageLength);
  while (directBuffer.remaining() > 0) {
    CompatibilityUtil.getBuf(input, directBuffer, directBuffer.remaining());
  }
  target.writerIndex(pageLength);
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
public static int compareDenseBytes(DrillBuf left, int leftStart, boolean leftSign, DrillBuf right, int rightStart, boolean rightSign, int width) {

      int invert = 1;

      /* If signs are different then simply look at the
       * sign of the two inputs and determine which is greater
       */
      if (leftSign != rightSign) {

        return((leftSign == true) ? -1 : 1);
      } else if(leftSign == true) {
        /* Both inputs are negative, at the end we will
         * have to invert the comparison
         */
        invert = -1;
      }

      int cmp = 0;

      for (int i = 0; i < width; i++) {
        byte leftByte  = left.getByte(leftStart + i);
        byte rightByte = right.getByte(rightStart + i);
        // Unsigned byte comparison
        if ((leftByte & 0xFF) > (rightByte & 0xFF)) {
          cmp = 1;
          break;
        } else if ((leftByte & 0xFF) < (rightByte & 0xFF)) {
          cmp = -1;
          break;
        }
      }
      cmp *= invert; // invert the comparison if both were negative values

      return cmp;
    }
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
public static int getIntegerFromSparseBuffer(DrillBuf buffer, int start, int index) {
  int value = buffer.getInt(start + (index * 4));

  if (index == 0) {
    /* the first byte contains sign bit, return value without it */
    value = (value & 0x7FFFFFFF);
  }
  return value;
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
public QueryDataBatch(QueryData header, DrillBuf data) {
  // logger.debug("New Result Batch with header {} and data {}", header, data);
  this.header = header;
  this.data = data;
  if (this.data != null) {
    data.retain(1);
  }
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
public static void initCap(int start, int end, DrillBuf inBuf, DrillBuf outBuf) {
  boolean capNext = true;
  int out = 0;
  for (int id = start; id < end; id++, out++) {
    byte currentByte = inBuf.getByte(id);

    // 'A - Z' : 0x41 - 0x5A
    // 'a - z' : 0x61 - 0x7A
    // '0-9' : 0x30 - 0x39
    if (capNext) { // curCh is whitespace or first character of word.
      if (currentByte >= 0x30 && currentByte <= 0x39) { // 0-9
        capNext = false;
      } else if (currentByte >= 0x41 && currentByte <= 0x5A) { // A-Z
        capNext = false;
      } else if (currentByte >= 0x61 && currentByte <= 0x7A) { // a-z
        capNext = false;
        currentByte -= 0x20; // Uppercase this character
      }
      // else {} whitespace
    } else { // Inside of a word or white space after end of word.
      if (currentByte >= 0x30 && currentByte <= 0x39) { // 0-9
        // noop
      } else if (currentByte >= 0x41 && currentByte <= 0x5A) { // A-Z
        currentByte -= 0x20; // Lowercase this character
      } else if (currentByte >= 0x61 && currentByte <= 0x7A) { // a-z
        // noop
      } else { // whitespace
        capNext = true;
      }
    }

    outBuf.setByte(out, currentByte);
  } // end of for_loop
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
@Override
public void decompress(DrillBuf input, int compressedSize, DrillBuf output, int uncompressedSize)
    throws IOException {
  BytesInput uncompressed = decompress(new ByteBufBytesInput(input), uncompressedSize);
  output.clear();
  output.setBytes(0, uncompressed.toByteArray());
  output.writerIndex((int) uncompressed.size());
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
private long getBufferSize(VectorAccessible batch) {
  long size = 0;
  for (VectorWrapper<?> w : batch) {
    DrillBuf[] bufs = w.getValueVector().getBuffers(false);
    for (DrillBuf buf : bufs) {
      if (buf.isRootBuffer()) {
        size += buf.capacity();
      }
    }
  }
  return size;
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
@Override
public void close() {
  if (closed) {
    logger.debug("Attempted to close Operator context for {}, but context is already closed", popConfig != null ? popConfig.getClass().getName() : null);
    return;
  }
  logger.debug("Closing context for {}", popConfig != null ? popConfig.getClass().getName() : null);

  // release managed buffers.
  Object[] buffers = ((LongObjectOpenHashMap<Object>)(Object)managedBuffers).values;
  for (int i =0; i < buffers.length; i++) {
    if (managedBuffers.allocated[i]) {
      ((DrillBuf)buffers[i]).release();
    }
  }

  if (allocator != null) {
    allocator.close();
  }

  if (fs != null) {
    try {
      fs.close();
    } catch (IOException e) {
      throw new DrillRuntimeException(e);
    }
  }
  closed = true;
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
@Override
public void close() throws Exception {
  final Object[] mbuffers = ((LongObjectOpenHashMap<Object>) (Object) managedBuffers).values;
  for (int i = 0; i < mbuffers.length; i++) {
    if (managedBuffers.allocated[i]) {
      ((DrillBuf) mbuffers[i]).release(1);
    }
  }
  managedBuffers.clear();
}
 

import io.netty.buffer.DrillBuf; //导入依赖的package包/类
public DrillBuf replace(DrillBuf old, int newSize) {
  if (managedBuffers.remove(old.memoryAddress()) == null) {
    throw new IllegalStateException("Tried to remove unmanaged buffer.");
  }
  old.release(1);
  return getManagedBuffer(newSize);
}