Examples of MajorType


Examples of co.nstant.in.cbor.model.MajorType

    private UnicodeString decodeInfinitiveLength() throws CborException {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        DataItem dataItem;
        for (;;) {
            dataItem = decoder.decodeNext();
            MajorType majorType = dataItem.getMajorType();
            if (Special.BREAK.equals(dataItem)) {
                break;
            } else if (majorType == MajorType.UNICODE_STRING) {
                UnicodeString unicodeString = (UnicodeString) dataItem;
                try {
View Full Code Here

Examples of co.nstant.in.cbor.model.MajorType

    private ByteString decodeInfinitiveLength() throws CborException {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        DataItem dataItem;
        for (;;) {
            dataItem = decoder.decodeNext();
            MajorType majorType = dataItem.getMajorType();
            if (Special.BREAK.equals(dataItem)) {
                break;
            } else if (majorType == MajorType.BYTE_STRING) {
                ByteString byteString = (ByteString) dataItem;
                try {
View Full Code Here

Examples of org.apache.drill.common.types.TypeProtos.MajorType

      }
      throw new UnsupportedOperationException();
  }

  public static ValueVector getNewVector(MaterializedField field, BufferAllocator allocator){
    MajorType type = field.getType();

    switch (type.getMinorType()) {
   
   
    case MAP:
      switch (type.getMode()) {
      case REQUIRED:
        return new MapVector(field, allocator);
      case REPEATED:
        return new RepeatedMapVector(field, allocator);
      }
    case LIST:
      switch (type.getMode()) {
      case REPEATED:
        return new RepeatedListVector(field, allocator);
      }   
    case TINYINT:
      switch (type.getMode()) {
        case REQUIRED:
          return new TinyIntVector(field, allocator);
        case OPTIONAL:
          return new NullableTinyIntVector(field, allocator);
        case REPEATED:
          return new RepeatedTinyIntVector(field, allocator);
      }
    case UINT1:
      switch (type.getMode()) {
        case REQUIRED:
          return new UInt1Vector(field, allocator);
        case OPTIONAL:
          return new NullableUInt1Vector(field, allocator);
        case REPEATED:
          return new RepeatedUInt1Vector(field, allocator);
      }
    case UINT2:
      switch (type.getMode()) {
        case REQUIRED:
          return new UInt2Vector(field, allocator);
        case OPTIONAL:
          return new NullableUInt2Vector(field, allocator);
        case REPEATED:
          return new RepeatedUInt2Vector(field, allocator);
      }
    case SMALLINT:
      switch (type.getMode()) {
        case REQUIRED:
          return new SmallIntVector(field, allocator);
        case OPTIONAL:
          return new NullableSmallIntVector(field, allocator);
        case REPEATED:
          return new RepeatedSmallIntVector(field, allocator);
      }
    case INT:
      switch (type.getMode()) {
        case REQUIRED:
          return new IntVector(field, allocator);
        case OPTIONAL:
          return new NullableIntVector(field, allocator);
        case REPEATED:
          return new RepeatedIntVector(field, allocator);
      }
    case UINT4:
      switch (type.getMode()) {
        case REQUIRED:
          return new UInt4Vector(field, allocator);
        case OPTIONAL:
          return new NullableUInt4Vector(field, allocator);
        case REPEATED:
          return new RepeatedUInt4Vector(field, allocator);
      }
    case FLOAT4:
      switch (type.getMode()) {
        case REQUIRED:
          return new Float4Vector(field, allocator);
        case OPTIONAL:
          return new NullableFloat4Vector(field, allocator);
        case REPEATED:
          return new RepeatedFloat4Vector(field, allocator);
      }
    case TIME:
      switch (type.getMode()) {
        case REQUIRED:
          return new TimeVector(field, allocator);
        case OPTIONAL:
          return new NullableTimeVector(field, allocator);
        case REPEATED:
          return new RepeatedTimeVector(field, allocator);
      }
    case INTERVALYEAR:
      switch (type.getMode()) {
        case REQUIRED:
          return new IntervalYearVector(field, allocator);
        case OPTIONAL:
          return new NullableIntervalYearVector(field, allocator);
        case REPEATED:
          return new RepeatedIntervalYearVector(field, allocator);
      }
    case DECIMAL9:
      switch (type.getMode()) {
        case REQUIRED:
          return new Decimal9Vector(field, allocator);
        case OPTIONAL:
          return new NullableDecimal9Vector(field, allocator);
        case REPEATED:
          return new RepeatedDecimal9Vector(field, allocator);
      }
    case BIGINT:
      switch (type.getMode()) {
        case REQUIRED:
          return new BigIntVector(field, allocator);
        case OPTIONAL:
          return new NullableBigIntVector(field, allocator);
        case REPEATED:
          return new RepeatedBigIntVector(field, allocator);
      }
    case UINT8:
      switch (type.getMode()) {
        case REQUIRED:
          return new UInt8Vector(field, allocator);
        case OPTIONAL:
          return new NullableUInt8Vector(field, allocator);
        case REPEATED:
          return new RepeatedUInt8Vector(field, allocator);
      }
    case FLOAT8:
      switch (type.getMode()) {
        case REQUIRED:
          return new Float8Vector(field, allocator);
        case OPTIONAL:
          return new NullableFloat8Vector(field, allocator);
        case REPEATED:
          return new RepeatedFloat8Vector(field, allocator);
      }
    case DATE:
      switch (type.getMode()) {
        case REQUIRED:
          return new DateVector(field, allocator);
        case OPTIONAL:
          return new NullableDateVector(field, allocator);
        case REPEATED:
          return new RepeatedDateVector(field, allocator);
      }
    case TIMESTAMP:
      switch (type.getMode()) {
        case REQUIRED:
          return new TimeStampVector(field, allocator);
        case OPTIONAL:
          return new NullableTimeStampVector(field, allocator);
        case REPEATED:
          return new RepeatedTimeStampVector(field, allocator);
      }
    case DECIMAL18:
      switch (type.getMode()) {
        case REQUIRED:
          return new Decimal18Vector(field, allocator);
        case OPTIONAL:
          return new NullableDecimal18Vector(field, allocator);
        case REPEATED:
          return new RepeatedDecimal18Vector(field, allocator);
      }
    case TIMESTAMPTZ:
      switch (type.getMode()) {
        case REQUIRED:
          return new TimeStampTZVector(field, allocator);
        case OPTIONAL:
          return new NullableTimeStampTZVector(field, allocator);
        case REPEATED:
          return new RepeatedTimeStampTZVector(field, allocator);
      }
    case INTERVALDAY:
      switch (type.getMode()) {
        case REQUIRED:
          return new IntervalDayVector(field, allocator);
        case OPTIONAL:
          return new NullableIntervalDayVector(field, allocator);
        case REPEATED:
          return new RepeatedIntervalDayVector(field, allocator);
      }
    case INTERVAL:
      switch (type.getMode()) {
        case REQUIRED:
          return new IntervalVector(field, allocator);
        case OPTIONAL:
          return new NullableIntervalVector(field, allocator);
        case REPEATED:
          return new RepeatedIntervalVector(field, allocator);
      }
    case DECIMAL28DENSE:
      switch (type.getMode()) {
        case REQUIRED:
          return new Decimal28DenseVector(field, allocator);
        case OPTIONAL:
          return new NullableDecimal28DenseVector(field, allocator);
        case REPEATED:
          return new RepeatedDecimal28DenseVector(field, allocator);
      }
    case DECIMAL38DENSE:
      switch (type.getMode()) {
        case REQUIRED:
          return new Decimal38DenseVector(field, allocator);
        case OPTIONAL:
          return new NullableDecimal38DenseVector(field, allocator);
        case REPEATED:
          return new RepeatedDecimal38DenseVector(field, allocator);
      }
    case DECIMAL38SPARSE:
      switch (type.getMode()) {
        case REQUIRED:
          return new Decimal38SparseVector(field, allocator);
        case OPTIONAL:
          return new NullableDecimal38SparseVector(field, allocator);
        case REPEATED:
          return new RepeatedDecimal38SparseVector(field, allocator);
      }
    case DECIMAL28SPARSE:
      switch (type.getMode()) {
        case REQUIRED:
          return new Decimal28SparseVector(field, allocator);
        case OPTIONAL:
          return new NullableDecimal28SparseVector(field, allocator);
        case REPEATED:
          return new RepeatedDecimal28SparseVector(field, allocator);
      }
    case VARBINARY:
      switch (type.getMode()) {
        case REQUIRED:
          return new VarBinaryVector(field, allocator);
        case OPTIONAL:
          return new NullableVarBinaryVector(field, allocator);
        case REPEATED:
          return new RepeatedVarBinaryVector(field, allocator);
      }
    case VARCHAR:
      switch (type.getMode()) {
        case REQUIRED:
          return new VarCharVector(field, allocator);
        case OPTIONAL:
          return new NullableVarCharVector(field, allocator);
        case REPEATED:
          return new RepeatedVarCharVector(field, allocator);
      }
    case VAR16CHAR:
      switch (type.getMode()) {
        case REQUIRED:
          return new Var16CharVector(field, allocator);
        case OPTIONAL:
          return new NullableVar16CharVector(field, allocator);
        case REPEATED:
          return new RepeatedVar16CharVector(field, allocator);
      }
    case BIT:
      switch (type.getMode()) {
        case REQUIRED:
          return new BitVector(field, allocator);
        case OPTIONAL:
          return new NullableBitVector(field, allocator);
        case REPEATED:
          return new RepeatedBitVector(field, allocator);
      }
    case GENERIC_OBJECT:
      return new ObjectVector(field, allocator)        ;
    default:
      break;
    }
    // All ValueVector types have been handled.
    throw new UnsupportedOperationException(type.getMinorType() + " type is not supported. Mode: " + type.getMode());
  }
View Full Code Here

Examples of org.apache.drill.common.types.TypeProtos.MajorType

    // All ValueVector types have been handled.
    throw new UnsupportedOperationException(type.getMinorType() + " type is not supported. Mode: " + type.getMode());
  }

  public static ValueHolder getValue(ValueVector vector, int index) {
    MajorType type = vector.getField().getType();
    ValueHolder holder;
    switch(type.getMinorType()) {
    case TINYINT :
      holder = new TinyIntHolder();
      ((TinyIntHolder)holder).value = ((TinyIntVector) vector).getAccessor().get(index);
      break;
    case UINT1 :
      holder = new UInt1Holder();
      ((UInt1Holder)holder).value = ((UInt1Vector) vector).getAccessor().get(index);
      break;
    case UINT2 :
      holder = new UInt2Holder();
      ((UInt2Holder)holder).value = ((UInt2Vector) vector).getAccessor().get(index);
      break;
    case SMALLINT :
      holder = new SmallIntHolder();
      ((SmallIntHolder)holder).value = ((SmallIntVector) vector).getAccessor().get(index);
      break;
    case INT :
      holder = new IntHolder();
      ((IntHolder)holder).value = ((IntVector) vector).getAccessor().get(index);
      break;
    case UINT4 :
      holder = new UInt4Holder();
      ((UInt4Holder)holder).value = ((UInt4Vector) vector).getAccessor().get(index);
      break;
    case FLOAT4 :
      holder = new Float4Holder();
      ((Float4Holder)holder).value = ((Float4Vector) vector).getAccessor().get(index);
      break;
    case TIME :
      holder = new TimeHolder();
      ((TimeHolder)holder).value = ((TimeVector) vector).getAccessor().get(index);
      break;
    case INTERVALYEAR :
      holder = new IntervalYearHolder();
      ((IntervalYearHolder)holder).value = ((IntervalYearVector) vector).getAccessor().get(index);
      break;
    case DECIMAL9 :
      holder = new Decimal9Holder();
      ((Decimal9Holder)holder).value = ((Decimal9Vector) vector).getAccessor().get(index);
      break;
    case BIGINT :
      holder = new BigIntHolder();
      ((BigIntHolder)holder).value = ((BigIntVector) vector).getAccessor().get(index);
      break;
    case UINT8 :
      holder = new UInt8Holder();
      ((UInt8Holder)holder).value = ((UInt8Vector) vector).getAccessor().get(index);
      break;
    case FLOAT8 :
      holder = new Float8Holder();
      ((Float8Holder)holder).value = ((Float8Vector) vector).getAccessor().get(index);
      break;
    case DATE :
      holder = new DateHolder();
      ((DateHolder)holder).value = ((DateVector) vector).getAccessor().get(index);
      break;
    case TIMESTAMP :
      holder = new TimeStampHolder();
      ((TimeStampHolder)holder).value = ((TimeStampVector) vector).getAccessor().get(index);
      break;
    case DECIMAL18 :
      holder = new Decimal18Holder();
      ((Decimal18Holder)holder).value = ((Decimal18Vector) vector).getAccessor().get(index);
      break;
    case TIMESTAMPTZ :
         throw new UnsupportedOperationException(type.getMinorType() + " type is not supported.");
    case INTERVALDAY :
         throw new UnsupportedOperationException(type.getMinorType() + " type is not supported.");
    case INTERVAL :
         throw new UnsupportedOperationException(type.getMinorType() + " type is not supported.");
    case DECIMAL28DENSE :
         throw new UnsupportedOperationException(type.getMinorType() + " type is not supported.");
    case DECIMAL38DENSE :
         throw new UnsupportedOperationException(type.getMinorType() + " type is not supported.");
    case DECIMAL38SPARSE :
         throw new UnsupportedOperationException(type.getMinorType() + " type is not supported.");
    case DECIMAL28SPARSE :
         throw new UnsupportedOperationException(type.getMinorType() + " type is not supported.");
    case VARBINARY :
         throw new UnsupportedOperationException(type.getMinorType() + " type is not supported.");
    case VARCHAR :
         throw new UnsupportedOperationException(type.getMinorType() + " type is not supported.");
    case VAR16CHAR :
         throw new UnsupportedOperationException(type.getMinorType() + " type is not supported.");
    case BIT :
      holder = new BitHolder();
      ((BitHolder)holder).value = ((BitVector) vector).getAccessor().get(index);
      break;
    case GENERIC_OBJECT:
      holder = new ObjectHolder();
      ((ObjectHolder)holder).obj = ((ObjectVector) vector).getAccessor().getObject(index)         ;
      break;
    default:
      throw new UnsupportedOperationException(type.getMinorType() + " type is not supported.");
    }
    return holder;
  }
View Full Code Here

Examples of org.apache.drill.common.types.TypeProtos.MajorType

    }
    return holder;
  }

  public static void setValue(ValueVector vector, int index, ValueHolder holder) {
    MajorType type = vector.getField().getType();

    switch(type.getMinorType()) {
    case TINYINT :
      ((TinyIntVector) vector).getMutator().setSafe(index, (TinyIntHolder) holder);
      break;
    case UINT1 :
      ((UInt1Vector) vector).getMutator().setSafe(index, (UInt1Holder) holder);
      break;
    case UINT2 :
      ((UInt2Vector) vector).getMutator().setSafe(index, (UInt2Holder) holder);
      break;
    case SMALLINT :
      ((SmallIntVector) vector).getMutator().setSafe(index, (SmallIntHolder) holder);
      break;
    case INT :
      ((IntVector) vector).getMutator().setSafe(index, (IntHolder) holder);
      break;
    case UINT4 :
      ((UInt4Vector) vector).getMutator().setSafe(index, (UInt4Holder) holder);
      break;
    case FLOAT4 :
      ((Float4Vector) vector).getMutator().setSafe(index, (Float4Holder) holder);
      break;
    case TIME :
      ((TimeVector) vector).getMutator().setSafe(index, (TimeHolder) holder);
      break;
    case INTERVALYEAR :
      ((IntervalYearVector) vector).getMutator().setSafe(index, (IntervalYearHolder) holder);
      break;
    case DECIMAL9 :
      ((Decimal9Vector) vector).getMutator().setSafe(index, (Decimal9Holder) holder);
      break;
    case BIGINT :
      ((BigIntVector) vector).getMutator().setSafe(index, (BigIntHolder) holder);
      break;
    case UINT8 :
      ((UInt8Vector) vector).getMutator().setSafe(index, (UInt8Holder) holder);
      break;
    case FLOAT8 :
      ((Float8Vector) vector).getMutator().setSafe(index, (Float8Holder) holder);
      break;
    case DATE :
      ((DateVector) vector).getMutator().setSafe(index, (DateHolder) holder);
      break;
    case TIMESTAMP :
      ((TimeStampVector) vector).getMutator().setSafe(index, (TimeStampHolder) holder);
      break;
    case DECIMAL18 :
      ((Decimal18Vector) vector).getMutator().setSafe(index, (Decimal18Holder) holder);
      break;
    case TIMESTAMPTZ :
      ((TimeStampTZVector) vector).getMutator().setSafe(index, (TimeStampTZHolder) holder);
      break;
    case INTERVALDAY :
      ((IntervalDayVector) vector).getMutator().setSafe(index, (IntervalDayHolder) holder);
      break;
    case INTERVAL :
      ((IntervalVector) vector).getMutator().setSafe(index, (IntervalHolder) holder);
      break;
    case DECIMAL28DENSE :
      ((Decimal28DenseVector) vector).getMutator().setSafe(index, (Decimal28DenseHolder) holder);
      break;
    case DECIMAL38DENSE :
      ((Decimal38DenseVector) vector).getMutator().setSafe(index, (Decimal38DenseHolder) holder);
      break;
    case DECIMAL38SPARSE :
      ((Decimal38SparseVector) vector).getMutator().setSafe(index, (Decimal38SparseHolder) holder);
      break;
    case DECIMAL28SPARSE :
      ((Decimal28SparseVector) vector).getMutator().setSafe(index, (Decimal28SparseHolder) holder);
      break;
    case VARBINARY :
      ((VarBinaryVector) vector).getMutator().setSafe(index, (VarBinaryHolder) holder);
      break;
    case VARCHAR :
      ((VarCharVector) vector).getMutator().setSafe(index, (VarCharHolder) holder);
      break;
    case VAR16CHAR :
      ((Var16CharVector) vector).getMutator().setSafe(index, (Var16CharHolder) holder);
      break;
    case BIT :
      ((BitVector) vector).getMutator().setSafe(index, (BitHolder) holder);
      break;
    case GENERIC_OBJECT:
      ((ObjectVector) vector).getMutator().setSafe(index, (ObjectHolder) holder);
      break          ;
    default:
      throw new UnsupportedOperationException(type.getMinorType() + " type is not supported.");   
    }
  }
View Full Code Here

Examples of org.apache.drill.common.types.TypeProtos.MajorType

      throw new UnsupportedOperationException(type.getMinorType() + " type is not supported.");   
    }
  }

  public static boolean compareValues(ValueVector v1, int v1index, ValueVector v2, int v2index) {
    MajorType type1 = v1.getField().getType();
    MajorType type2 = v2.getField().getType();

    if (type1.getMinorType() != type2.getMinorType()) {
      return false;
    }

    switch(type1.getMinorType()) {
    case TINYINT :
View Full Code Here

Examples of org.apache.drill.common.types.TypeProtos.MajorType

 
  public void confirmDataType(ExpressionPosition expr, int argIndex, LogicalExpression e, ErrorCollector errors){
    if(constantsOnly){
      if(ConstantChecker.onlyIncludesConstants(e)) errors.addExpectedConstantValue(expr, argIndex, name);
    }
    MajorType dt = e.getMajorType();
    if(dt.getMinorType() != MinorType.LATE){
     
      // change among allowed types.
      for(MajorType a : allowedTypes){
        if(dt.equals(a)) return;
      }
     
      // didn't find an allowed type.
      errors.addUnexpectedArgumentType(expr, name, dt, allowedTypes, argIndex);
     
View Full Code Here

Examples of org.apache.drill.common.types.TypeProtos.MajorType

      SimpleArrayValue a = new SimpleArrayValue();
      a.addToArray(0, oldValue);
      a.addToArray(1, newValue);
      return a;
    case MERGE_OVERRIDE:
      MajorType oldT = oldValue.getDataType();
      MajorType newT = newValue.getDataType();
      if(oldT.getMinorType() == MinorType.REPEATMAP && newT.getMinorType() == MinorType.REPEATMAP){
        oldValue.getAsContainer().getAsMap().merge(newValue.getAsContainer().getAsMap());
        return oldValue;
      }else if(oldT.getMode() == DataMode.REPEATED && newT.getMode() == DataMode.REPEATED){
        logger.debug("Merging two arrays. {} and {}", oldValue, newValue);
        oldValue.getAsContainer().getAsArray().append(newValue.getAsContainer().getAsArray());
        return oldValue;
      }else if(oldT.getMode() == DataMode.REPEATED || newT.getMode() == DataMode.REPEATED || oldT.getMinorType() == MinorType.REPEATMAP || newT.getMinorType() == MinorType.REPEATMAP){
        throw new RecordException(String.format("Failure while doing query.  You requested a merge of values that were incompatibile.  Examples include merging an array and a map or merging a map/array with a scalar.  Merge Types were %s and %s.", oldT, newT), null);
      }else{
        // scalar type, just override the value.
        return newValue;
      }
View Full Code Here

Examples of org.apache.drill.common.types.TypeProtos.MajorType

        if(!ValueHolder.class.isAssignableFrom(field.getType())){
          return failure(String.format("The field doesn't holds value of type %s which does not implement the ValueHolder interface.  All fields of type @Param or @Output must extend this interface..", field.getType()), clazz, field);
        }
       
        // get the type field from the value holder.
        MajorType type = null;
        try{
          type = getStaticFieldValue("TYPE", field.getType(), MajorType.class);
        }catch(Exception e){
          return failure("Failure while trying to access the ValueHolder's TYPE static variable.  All ValueHolders must contain a static TYPE variable that defines their MajorType.", e, clazz, field.getName());
        }
View Full Code Here

Examples of org.apache.drill.common.types.TypeProtos.MajorType

    }

    @Override
    public void validateArguments(ExpressionPosition expr, List<LogicalExpression> expressions, ErrorCollector errors) {
      int i = -1;
      MajorType t = null;
      for (LogicalExpression le : expressions) {
        i++;
          MajorType majorType = le.getMajorType();
          if (t == null) t = majorType;

        if (!predicate.apply(majorType)) {
          errors.addUnexpectedType(expr, i, majorType);
          continue;
View Full Code Here
TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.