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

Package org.apache.drill.common.types.TypeProtos

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

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

    }


    @Override
    public HoldingContainer visitDecimal38Constant(Decimal38Expression e, ClassGenerator<?> generator)
        throws RuntimeException {
      MajorType majorType = e.getMajorType();
      JBlock setup = generator.getBlock(BlockType.SETUP);
      JType holderType = generator.getHolderType(majorType);
      JVar var = generator.declareClassField("dec38", holderType);
      JExpression stringLiteral = JExpr.lit(e.getBigDecimal().toString());
      setup.assign(var,

View Full Code Here

        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());
        }




        ValueReference p = new ValueReference(type, field.getName());
        if(param != null){
          if (param.constant()) {
            p.setConstant(true);
          }
          params.add(p);
        }else{
          if(outputField != null){
            return failure("You've declared more than one @Output field.  You must declare one and only @Output field per Function class.", clazz, field);
          }else{
            outputField = p;
          }
        }
        
      }else{
        // workspace work.
        WorkspaceReference wsReference = new WorkspaceReference(field.getType(), field.getName());


        if (template.scope() == FunctionScope.POINT_AGGREGATE && !ValueHolder.class.isAssignableFrom(field.getType()) ) {
          return failure(String.format("Aggregate function '%s' workspace variable '%s' is of type '%s'. Please change it to Holder type.", template.name(), field.getName(), field.getType()), clazz, field);
        }


        //If the workspace var is of Holder type, get its MajorType and assign to WorkspaceReference.
        if(ValueHolder.class.isAssignableFrom(field.getType())){
          MajorType majorType = null;
          try{
            majorType = 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

            }
          }
        );


        if(nonNullExpr.isPresent()) {
          MajorType type = nonNullExpr.get().getMajorType();
          conditions = new IfExpression.IfCondition(conditions.condition, rewriteNullExpression(conditions.expression, type));


          newElseExpr = rewriteNullExpression(newElseExpr, type);
        }
      }

View Full Code Here

    public LogicalExpression visitCastExpression(CastExpression e, FunctionImplementationRegistry value){


      // if the cast is pointless, remove it.
      LogicalExpression input = e.getInput().accept(this,  value);


      MajorType newMajor = e.getMajorType();
      MinorType newMinor = input.getMajorType().getMinorType();


      if(castEqual(e.getPosition(), newMajor, input.getMajorType())) return input; // don't do pointless cast.


      if(newMinor == MinorType.LATE){
        // if the type still isn't fully bound, leave as cast expression.
        return new CastExpression(input, e.getMajorType(), e.getPosition());
      } else if (newMinor == MinorType.NULL) {
        // if input is a NULL expression, remove cast expression and return a TypedNullConstant directly.  
        return new TypedNullConstant(Types.optional(e.getMajorType().getMinorType()));
      } else {
        // if the type is fully bound, convert to functioncall and materialze the function.
        MajorType type = e.getMajorType();


        // Get the cast function name from the map
        String castFuncWithType = CastFunctions.getCastFunc(type.getMinorType());


        List<LogicalExpression> newArgs = Lists.newArrayList();
        newArgs.add(e.getInput());  //input_expr


        //VarLen type
        if (!Types.isFixedWidthType(type)) {
          newArgs.add(new ValueExpressions.LongExpression(type.getWidth(), null));
        } else if (type.getMinorType().name().startsWith("DECIMAL")) {
            newArgs.add(new ValueExpressions.LongExpression(type.getPrecision(), null));
            newArgs.add(new ValueExpressions.LongExpression(type.getScale(), null));
        }
        FunctionCall fc = new FunctionCall(castFuncWithType, newArgs, e.getPosition());
        return fc.accept(this, value);
      }
    }

View Full Code Here

    StringBuilder sb = new StringBuilder();
    sb.append("Failure finding function that runtime code generation expected.  Signature: ");
    sb.append(name);
    sb.append("( ");
    for(int i =0; i < args.length; i++){
      MajorType mt = args[i].getMajorType();
      appendType(mt, sb);
      if(i != 0) sb.append(", ");
    }
    sb.append(" ) returns ");
    appendType(returnType, sb);

View Full Code Here

    public String toString() {
      return "ValueReference [type=" + Types.toString(type) + ", name=" + name + "]";
    }


    public static ValueReference createFieldReaderRef(String name) {
      MajorType type = Types.required(MinorType.LATE);
      ValueReference ref = new ValueReference(type, name);
      ref.isFieldReader = true;


      return ref;
    }

View Full Code Here

      }
      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


      return ref;
    }


    public static ValueReference createComplexWriterRef(String name) {
      MajorType type = Types.required(MinorType.LATE);
      ValueReference ref = new ValueReference(type, name);
      ref.isComplexWriter = true;


      return ref;
    }

View Full Code Here

    // 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

    }
    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

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.drill.common.types.TypeProtos.MajorType

org.apache.drill.common.expression.Arg

org.apache.drill.common.expression.ArgumentValidators$PredicateValidator

org.apache.drill.common.expression.ExpressionStringBuilder

org.apache.drill.common.expression.ExpressionValidator

org.apache.drill.common.expression.IfExpression

org.apache.drill.common.expression.visitors.ExpressionValidator

org.apache.drill.exec.expr.EvaluationVisitor$EvalVisitor

org.apache.drill.exec.expr.ExpressionTreeMaterializer$MaterializeVisitor

org.apache.drill.exec.expr.fn.DrillFuncHolder$ValueReference

org.apache.drill.exec.expr.fn.DrillSimpleFuncHolder

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.