Best code snippets using com.facebook.presto.spi.type(Showing top 15 results out of 324)

protected static SqlDecimal decimal(String decimalString)
{
  DecimalParseResult parseResult = Decimals.parseIncludeLeadingZerosInPrecision(decimalString);
  BigInteger unscaledValue;
  if (parseResult.getType().isShort()) {
    unscaledValue = BigInteger.valueOf((Long) parseResult.getObject());
  }
  else {
    unscaledValue = Decimals.decodeUnscaledValue((Slice) parseResult.getObject());
  }
  return new SqlDecimal(unscaledValue, parseResult.getType().getPrecision(), parseResult.getType().getScale());
}

@Override
public boolean equals(Object o)
{
  if (this == o) {
    return true;
  }
  if (o == null || getClass() != o.getClass()) {
    return false;
  }
  return this.getTypeSignature().equals(((Type) o).getTypeSignature());
}

public static MapType mapType(Type keyType, Type valueType)
{
  return (MapType) TYPE_MANAGER.getParameterizedType(StandardTypes.MAP, ImmutableList.of(
      TypeSignatureParameter.of(keyType.getTypeSignature()),
      TypeSignatureParameter.of(valueType.getTypeSignature())));
}

private boolean satisfiesCoercion(boolean allowCoercion, Type fromType, TypeSignature toTypeSignature)
{
  if (allowCoercion) {
    return typeManager.canCoerce(fromType, typeManager.getType(toTypeSignature));
  }
  else {
    return fromType.getTypeSignature().equals(toTypeSignature);
  }
}

@Override
public Object getObjectValue(ConnectorSession session, Block block, int position)
{
  if (block.isNull(position)) {
    return null;
  }
  Slice slice = block.getSlice(position, 0, getFixedSize());
  return new SqlDecimal(decodeUnscaledValue(slice), getPrecision(), getScale());
}

private void assertParseResult(String value, Object expectedObject, int expectedPrecision, int expectedScale)
{
  assertEquals(Decimals.parse(value),
      new DecimalParseResult(
          expectedObject,
          createDecimalType(expectedPrecision, expectedScale)));
}

public static DecimalType createDecimalType(int precision, int scale)
{
  if (precision <= MAX_SHORT_PRECISION) {
    return new ShortDecimalType(precision, scale);
  }
  else {
    return new LongDecimalType(precision, scale);
  }
}

@Override
protected String formatOneLine()
{
  return type.getTypeSignature().toString();
}

@Override
public Type getType(TypeSignature signature)
{
  for (Type type : getTypes()) {
    if (signature.getBase().equals(type.getTypeSignature().getBase())) {
      return type;
    }
  }
  return null;
}

public static void writeType(SliceOutput sliceOutput, Type type)
{
  if (sliceOutput == null) {
    throw new NullPointerException("sliceOutput is null");
  }
  if (type == null) {
    throw new NullPointerException("type is null");
  }
  writeLengthPrefixedString(sliceOutput, type.getTypeSignature().toString());
}

public ArrayType(Type elementType)
{
  super(new TypeSignature(ARRAY, TypeSignatureParameter.of(elementType.getTypeSignature())), Block.class);
  this.elementType = requireNonNull(elementType, "elementType is null");
}

public ClassifierType(Type type)
{
  super(new TypeSignature(ClassifierParametricType.NAME, TypeSignatureParameter.of(type.getTypeSignature())));
  checkArgument(type.isComparable(), "type must be comparable");
  labelType = type;
}

private void assertParseResultIncludeLeadingZerosInPrecision(String value, Object expectedObject, int expectedPrecision, int expectedScale)
{
  assertEquals(Decimals.parseIncludeLeadingZerosInPrecision(value),
      new DecimalParseResult(
          expectedObject,
          createDecimalType(expectedPrecision, expectedScale)));
}

private static MapType createMapType(Type type)
{
  return (MapType) TYPE_MANAGER.getParameterizedType(StandardTypes.MAP, ImmutableList.of(
      TypeSignatureParameter.of(type.getTypeSignature()),
      TypeSignatureParameter.of(type.getTypeSignature())));
}

  public static MapType mapType(Type keyType, Type valueType)
  {
    return (MapType) TYPE_MANAGER.getParameterizedType(StandardTypes.MAP, ImmutableList.of(
        TypeSignatureParameter.of(keyType.getTypeSignature()),
        TypeSignatureParameter.of(valueType.getTypeSignature())));
  }
}