public static Type createType(String baseTypeStr, List<Type> typeParams, List<Integer> valueParams, List<Field> fieldParams) { final TajoDataTypes.Type baseType; try { baseType = TajoDataTypes.Type.valueOf(baseTypeStr); } catch (Throwable t) { throw new TajoInternalError(new UnsupportedException(baseTypeStr)); } return TypeFactory.create(baseType, typeParams, valueParams, fieldParams); }
static Type createPrimitiveType(TypeElement element) { assertPrimitiveType(element); if (isValueParameterized(element.getKind())) { return TypeFactory.create(element.getKind(), EMPTY_LIST, element.getValueParamsList(), EMPTY_LIST); } else if (element.getKind() == PROTOBUF) { // TODO - PROTOBUF type should be removed later return new Protobuf(element.getStringParams(0)); } else { return TypeFactory.create(element.getKind()); } }
/** * It checks both terms in binary expression. If one of both needs type conversion, it inserts a cast expression. * * @param lhs left hand side term * @param rhs right hand side term * @return a pair including left/right hand side terms */ private static Pair<EvalNode, EvalNode> convertTypesIfNecessary(Context ctx, EvalNode lhs, EvalNode rhs) { TajoDataTypes.Type lhsType = lhs.getValueType().kind(); TajoDataTypes.Type rhsType = rhs.getValueType().kind(); // If one of both is NULL, it just returns the original types without casting. if (lhsType == NULL_TYPE || rhsType == NULL_TYPE) { return new Pair<>(lhs, rhs); } TajoDataTypes.Type toBeCasted = TUtil.getFromNestedMap(CatalogUtil.OPERATION_CASTING_MAP, lhsType, rhsType); if (toBeCasted != null) { // if not null, one of either should be converted to another type. // Overwrite lhs, rhs, or both with cast expression. Direction direction = CatalogUtil.getCastingDirection(lhsType, rhsType); if (lhsType != toBeCasted && (direction == Direction.BOTH || direction == Direction.LHS)) { lhs = convertType(ctx, lhs, TypeFactory.create(toBeCasted)); } if (rhsType != toBeCasted && (direction == Direction.BOTH || direction == Direction.RHS)) { rhs = convertType(ctx, rhs, TypeFactory.create(toBeCasted)); } } return new Pair<>(lhs, rhs); }
protected SchemaProto getSchemaProto() { SchemaProto.Builder schemaBuilder = SchemaProto.newBuilder(); ColumnProto.Builder columnBuilder = null; for (ColumnDescriptor columnDescriptor: getColumnDescriptors()) { columnBuilder = ColumnProto.newBuilder(); columnBuilder.setName(columnDescriptor.getName().toLowerCase()); columnBuilder.setType(TypeFactory.create(columnDescriptor.getType()).getProto()); schemaBuilder.addFields(columnBuilder.build()); } return schemaBuilder.build(); }
public static Type convert(TajoDataTypes.DataType legacyType) { switch (legacyType.getType()) { case NCHAR: case CHAR: return Char(legacyType.getLength()); case NVARCHAR: case VARCHAR: return Varchar(legacyType.getLength()); case NUMERIC: return Numeric(legacyType.getLength()); case PROTOBUF: return new Protobuf(legacyType.getCode()); default: return TypeFactory.create(legacyType.getType()); } }
return TypeFactory.create(type);