UserType prepare(String keyspace, Types types) { List<FieldIdentifier> preparedFieldNames = fieldNames.stream() .map(t -> FieldIdentifier.forInternalString(t)) .collect(toList()); List<AbstractType<?>> preparedFieldTypes = fieldTypes.stream() .map(t -> t.prepareInternal(keyspace, types).getType()) .collect(toList()); return new UserType(keyspace, bytes(name), preparedFieldNames, preparedFieldTypes, true); }
UserType prepare(String keyspace, Types types) { List<FieldIdentifier> preparedFieldNames = fieldNames.stream() .map(t -> FieldIdentifier.forInternalString(t)) .collect(toList()); List<AbstractType<?>> preparedFieldTypes = fieldTypes.stream() .map(t -> t.prepareInternal(keyspace, types).getType()) .collect(toList()); return new UserType(keyspace, bytes(name), preparedFieldNames, preparedFieldTypes, true); }
public AssignmentTestable.TestResult testAssignment(String keyspace, ColumnSpecification receiver) { AbstractType<?> castedType = type.prepare(keyspace).getType(); if (receiver.type.equals(castedType)) return AssignmentTestable.TestResult.EXACT_MATCH; else if (receiver.type.isValueCompatibleWith(castedType)) return AssignmentTestable.TestResult.WEAKLY_ASSIGNABLE; else return AssignmentTestable.TestResult.NOT_ASSIGNABLE; }
public AssignmentTestable.TestResult testAssignment(String keyspace, ColumnSpecification receiver) { AbstractType<?> castedType = type.prepare(keyspace).getType(); if (receiver.type.equals(castedType)) return AssignmentTestable.TestResult.EXACT_MATCH; else if (receiver.type.isValueCompatibleWith(castedType)) return AssignmentTestable.TestResult.WEAKLY_ASSIGNABLE; else return AssignmentTestable.TestResult.NOT_ASSIGNABLE; }
public UserType createType() throws InvalidRequestException { List<AbstractType<?>> types = new ArrayList<>(columnTypes.size()); for (CQL3Type.Raw type : columnTypes) types.add(type.prepare(keyspace()).getType()); return new UserType(name.getKeyspace(), name.getUserTypeName(), columnNames, types, true); }
public UserType createType() throws InvalidRequestException { List<AbstractType<?>> types = new ArrayList<>(columnTypes.size()); for (CQL3Type.Raw type : columnTypes) types.add(type.prepare(keyspace()).getType()); return new UserType(name.getKeyspace(), name.getUserTypeName(), columnNames, types, true); }
/** * Returns the Java Driver {@link com.datastax.driver.core.DataType} for the C* internal type. */ public static DataType driverType(AbstractType abstractType) { CQL3Type cqlType = abstractType.asCQL3Type(); String abstractTypeDef = cqlType.getType().toString(); return driverTypeFromAbstractType(abstractTypeDef); }
public static AbstractType<?> parse(String keyspace, String unparsed, Types userTypes) { String lowercased = unparsed.toLowerCase(); // fast path for the common case of a primitive type if (PRIMITIVE_TYPES.contains(lowercased)) return CQL3Type.Native.valueOf(unparsed.toUpperCase()).getType(); // special-case top-level UDTs UserType udt = userTypes.getNullable(bytes(lowercased)); if (udt != null) return udt; return parseRaw(unparsed).prepareInternal(keyspace, userTypes).getType(); }
/** * Returns the Java Driver {@link com.datastax.driver.core.DataType} for the C* internal type. */ public static DataType driverType(AbstractType abstractType) { CQL3Type cqlType = abstractType.asCQL3Type(); String abstractTypeDef = cqlType.getType().toString(); return driverTypeFromAbstractType(abstractTypeDef); }
public static AbstractType<?> parse(KeyspaceMetadata ksm, String unparsed, Types userTypes) { String lowercased = unparsed.toLowerCase(); // fast path for the common case of a primitive type if (PRIMITIVE_TYPES.contains(lowercased)) return CQL3Type.Native.valueOf(unparsed.toUpperCase()).getType(); // special-case top-level UDTs UserType udt = userTypes.getNullable(bytes(lowercased)); if (udt != null) return udt; return parseRaw(unparsed).prepareInternal(ksm, userTypes).getType(); }
private AbstractType<?> prepareType(String typeName, CQL3Type.Raw rawType) { if (rawType.isFrozen()) throw new InvalidRequestException(String.format("The function %s should not be frozen; remove the frozen<> modifier", typeName)); // UDT are not supported non frozen but we do not allow the frozen keyword for argument. So for the moment we // freeze them here if (!rawType.canBeNonFrozen()) rawType.freeze(); AbstractType<?> type = rawType.prepare(functionName.keyspace).getType(); return type; } }
private AbstractType<?> prepareType(String typeName, CQL3Type.Raw rawType) { if (rawType.isFrozen()) throw new InvalidRequestException(String.format("The function %s should not be frozen; remove the frozen<> modifier", typeName)); // UDT are not supported non frozen but we do not allow the frozen keyword for argument. So for the moment we // freeze them here if (!rawType.canBeNonFrozen()) rawType.freeze(); AbstractType<?> type = rawType.prepare(functionName.keyspace).getType(); return type; }
private AbstractType<?> prepareType(String typeName, CQL3Type.Raw rawType) { if (rawType.isFrozen()) throw new InvalidRequestException(String.format("The function %s should not be frozen; remove the frozen<> modifier", typeName)); // UDT are not supported non frozen but we do not allow the frozen keyword for argument. So for the moment we // freeze them here if (!rawType.canBeNonFrozen()) rawType.freeze(); AbstractType<?> type = rawType.prepare(functionName.keyspace).getType(); return type; } }
private AbstractType<?> prepareType(String typeName, CQL3Type.Raw rawType) { if (rawType.isFrozen()) throw new InvalidRequestException(String.format("The function %s should not be frozen; remove the frozen<> modifier", typeName)); // UDT are not supported non frozen but we do not allow the frozen keyword for argument. So for the moment we // freeze them here if (!rawType.canBeNonFrozen()) rawType.freeze(); AbstractType<?> type = rawType.prepare(functionName.keyspace).getType(); return type; } }
private AbstractType<?> prepareType(String typeName, CQL3Type.Raw rawType) { if (rawType.isFrozen()) throw new InvalidRequestException(String.format("The function %s should not be frozen; remove the frozen<> modifier", typeName)); // UDT are not supported non frozen but we do not allow the frozen keyword for argument. So for the moment we // freeze them here if (!rawType.canBeNonFrozen()) rawType.freeze(); AbstractType<?> type = rawType.prepare(functionName.keyspace).getType(); return type; }
private AbstractType<?> prepareType(String typeName, CQL3Type.Raw rawType) { if (rawType.isFrozen()) throw new InvalidRequestException(String.format("The function %s should not be frozen; remove the frozen<> modifier", typeName)); // UDT are not supported non frozen but we do not allow the frozen keyword for argument. So for the moment we // freeze them here if (!rawType.canBeNonFrozen()) rawType.freeze(); AbstractType<?> type = rawType.prepare(functionName.keyspace).getType(); return type; } }
private AbstractType<?> prepareType(String typeName, CQL3Type.Raw rawType) { if (rawType.isFrozen()) throw new InvalidRequestException(String.format("The function %s should not be frozen; remove the frozen<> modifier", typeName)); // UDT are not supported non frozen but we do not allow the frozen keyword for argument. So for the moment we // freeze them here if (!rawType.canBeNonFrozen()) rawType.freeze(); AbstractType<?> type = rawType.prepare(functionName.keyspace).getType(); return type; } }
private AbstractType<?> prepareType(String typeName, CQL3Type.Raw rawType) { if (rawType.isFrozen()) throw new InvalidRequestException(String.format("The function %s should not be frozen; remove the frozen<> modifier", typeName)); // UDT are not supported non frozen but we do not allow the frozen keyword for argument. So for the moment we // freeze them here if (!rawType.canBeNonFrozen()) rawType.freeze(); AbstractType<?> type = rawType.prepare(functionName.keyspace).getType(); return type; }
private AbstractType<?> prepareType(String typeName, CQL3Type.Raw rawType) { if (rawType.isFrozen()) throw new InvalidRequestException(String.format("The function %s should not be frozen; remove the frozen<> modifier", typeName)); // UDT are not supported non frozen but we do not allow the frozen keyword for argument. So for the moment we // freeze them here if (!rawType.canBeNonFrozen()) rawType.freeze(); AbstractType<?> type = rawType.prepare(functionName.keyspace).getType(); return type; } }
public static AbstractType<?> parse(String keyspace, String unparsed, Types userTypes) { String lowercased = unparsed.toLowerCase(); // fast path for the common case of a primitive type if (PRIMITIVE_TYPES.contains(lowercased)) return CQL3Type.Native.valueOf(unparsed.toUpperCase()).getType(); // special-case top-level UDTs UserType udt = userTypes.getNullable(bytes(lowercased)); if (udt != null) return udt; return parseRaw(unparsed).prepareInternal(keyspace, userTypes).getType(); }