Java Type.STRING屬性代碼示例

private static Type getUsedTypeFromUnion(Object avroObjField) {
    if (GenericRecord.class.isAssignableFrom(avroObjField.getClass())) {
        return Type.RECORD;
    } else if (Number.class.isAssignableFrom(avroObjField.getClass())) {
        return Type.LONG;
    } else if (Boolean.class.isAssignableFrom(avroObjField.getClass())) {
        return Type.BOOLEAN;
    } else if (String.class.isAssignableFrom(avroObjField.getClass())) {
        return Type.STRING;
    } else if (byte[].class.isAssignableFrom(avroObjField.getClass()) || ByteBuffer.class.isAssignableFrom(avroObjField.getClass())) {
        return Type.BYTES;
    } else if (Map.class.isAssignableFrom(avroObjField.getClass())) {
        return Type.MAP;
    } else if (List.class.isAssignableFrom(avroObjField.getClass())) {
        return Type.ARRAY;
    } else if (Enum.class.isAssignableFrom(avroObjField.getClass())) {
        return Type.ENUM;
    } else {
        LOGGER.error("Used type of union is unknown.");
        return null;
    }
}
 

private Type toAvroType(String columnName, int sqlType) {
  Properties mapping = options.getMapColumnJava();

  if (mapping.containsKey(columnName)) {
    String type = mapping.getProperty(columnName);
    if (LOG.isDebugEnabled()) {
      LOG.info("Overriding type of column " + columnName + " to " + type);
    }

    if (type.equalsIgnoreCase("INTEGER")) { return Type.INT; }
    if (type.equalsIgnoreCase("LONG")) { return Type.LONG; }
    if (type.equalsIgnoreCase("BOOLEAN")) { return Type.BOOLEAN; }
    if (type.equalsIgnoreCase("FLOAT")) { return Type.FLOAT; }
    if (type.equalsIgnoreCase("DOUBLE")) { return Type.DOUBLE; }
    if (type.equalsIgnoreCase("STRING")) { return Type.STRING; }
    if (type.equalsIgnoreCase("BYTES")) { return Type.BYTES; }

    // Mapping was not found
    throw new IllegalArgumentException("Cannot convert to AVRO type " + type);
  }

  return connManager.toAvroType(tableName, columnName, sqlType);
}
 

@SuppressWarnings({ "rawtypes", "unchecked" })
public static <T> Serializer<T> getSerializer(Type type) {
  Serializer serializer = null;
  if (type == Type.STRING) {
    serializer = CharSequenceSerializer.get();
  } else if (type == Type.BOOLEAN) {
    serializer = BooleanSerializer.get();
  } else if (type == Type.BYTES) {
    serializer = ByteBufferSerializer.get();
  } else if (type == Type.DOUBLE) {
    serializer = DoubleSerializer.get();
  } else if (type == Type.FLOAT) {
    serializer = FloatSerializer.get();
  } else if (type == Type.INT) {
    serializer = IntegerSerializer.get();
  } else if (type == Type.LONG) {
    serializer = LongSerializer.get();
  } else if (type == Type.FIXED) {
    serializer = SpecificFixedSerializer.get();
  } else {
    serializer = null;
  }
  return serializer;
}
 

public static Type getType(Class<?> clazz) {
  if (clazz.equals(Utf8.class)) {
    return Type.STRING;
  } else if (clazz.equals(Boolean.class) || clazz.equals(boolean.class)) {
    return Type.BOOLEAN;
  } else if (clazz.equals(ByteBuffer.class)) {
    return Type.BYTES;
  } else if (clazz.equals(Double.class) || clazz.equals(double.class)) {
    return Type.DOUBLE;
  } else if (clazz.equals(Float.class) || clazz.equals(float.class)) {
    return Type.FLOAT;
  } else if (clazz.equals(Integer.class) || clazz.equals(int.class)) {
    return Type.INT;
  } else if (clazz.equals(Long.class) || clazz.equals(long.class)) {
    return Type.LONG;
  } else if (clazz.isAssignableFrom(List.class)) {
    return Type.ARRAY;
  } else if (clazz.isAssignableFrom(Map.class)) {
    return Type.MAP;
  } else if (clazz.equals(Persistent.class)) {
    return Type.RECORD;
  } else if (clazz.getSuperclass().equals(SpecificFixed.class)) {
    return Type.FIXED;
  } else {
    return null;
  }
}
 

public static Class<?> getClass(Type type) {
  if (type == Type.STRING) {
    return Utf8.class;
  } else if (type == Type.BOOLEAN) {
    return Boolean.class;
  } else if (type == Type.BYTES) {
    return ByteBuffer.class;
  } else if (type == Type.DOUBLE) {
    return Double.class;
  } else if (type == Type.FLOAT) {
    return Float.class;
  } else if (type == Type.INT) {
    return Integer.class;
  } else if (type == Type.LONG) {
    return Long.class;
  } else if (type == Type.ARRAY) {
    return List.class;
  } else if (type == Type.MAP) {
    return Map.class;
  } else if (type == Type.RECORD) {
    return Persistent.class;
  } else if (type == Type.FIXED) {
    // return SpecificFixed.class;
    return null;
  } else {
    return null;
  }
}
 

/**
 * Resolve a database-specific type to Avro data type.
 * @param sqlType     sql type
 * @return            avro type
 */
public Type toAvroType(int sqlType) {
  switch (sqlType) {
  case Types.TINYINT:
  case Types.SMALLINT:
  case Types.INTEGER:
    return Type.INT;
  case Types.BIGINT:
    return Type.LONG;
  case Types.BIT:
  case Types.BOOLEAN:
    return Type.BOOLEAN;
  case Types.REAL:
    return Type.FLOAT;
  case Types.FLOAT:
  case Types.DOUBLE:
    return Type.DOUBLE;
  case Types.NUMERIC:
  case Types.DECIMAL:
    return Type.STRING;
  case Types.CHAR:
  case Types.VARCHAR:
  case Types.LONGVARCHAR:
  case Types.LONGNVARCHAR:
  case Types.NVARCHAR:
  case Types.NCHAR:
    return Type.STRING;
  case Types.DATE:
  case Types.TIME:
  case Types.TIMESTAMP:
    return Type.LONG;
  case Types.BLOB:
  case Types.BINARY:
  case Types.VARBINARY:
  case Types.LONGVARBINARY:
    return Type.BYTES;
  default:
    throw new IllegalArgumentException("Cannot convert SQL type "
        + sqlType);
  }
}