public static QualifiedIdentifier toQualifiedIdentifier(String name) { final Collection<String> elems = ImmutableList.copyOf(name.split("\\.")); final Collection<Identifier> identifiers = Collections2.transform(elems, new Function<String, Identifier>() { @Override public Identifier apply(@Nullable String input) { return Identifier._(input, IdentifierUtil.isShouldBeQuoted(input)); } }); return QualifiedIdentifier.$(identifiers); }
@Override public String toString() { return interned(DefaultPolicy()); }
public static QualifiedIdentifier $(Identifier...names) { return new QualifiedIdentifier(ImmutableList.copyOf(names)); }
@Override public QualifiedIdentifierProto apply(@Nullable Field field) { return field.name().getProto(); } });
@Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj instanceof Field) { Field other = (Field) obj; return type.equals(other.type) && name.equals(other.name); } return false; }
/** * Make a string from a field * @param field A field * @return String representation for a field */ static String serializeField(Field field) { return field.name().raw(DefaultPolicy()) + " " + encode(field.type()); }
public static Type decode(TypeProto proto) { Stack<Type> stack = new Stack<>(); for (int curIdx = 0; curIdx < proto.getElementsCount(); curIdx++) { TypeElement e = proto.getElements(curIdx); if (e.hasChildNum()) { // if it is a type-parameterized, that is List<Type> childTypes = popMultiItems(stack, e.getChildNum()); if (e.getKind() == ARRAY || e.getKind() == MAP) { stack.push(createTypeParameterizedType(e, childTypes)); } else { // record assertCondition(e.getKind() == RECORD, "This type must be RECORD type."); assertCondition(childTypes.size() == e.getFieldNamesCount(), "The number of Field types and names must be equal."); ImmutableList.Builder<Field> fields = ImmutableList.builder(); for (int i = 0; i < childTypes.size(); i++) { fields.add(new Field(QualifiedIdentifier.fromProto(e.getFieldNames(i)), childTypes.get(i))); } stack.push(Record(fields.build())); } } else { stack.push(createPrimitiveType(e)); } } assertCondition(stack.size() == 1, "Stack size has two or more items."); return stack.pop(); }
@VisibleForTesting public static Field Field(String name, Type type) { return new Field(QualifiedIdentifier.$(name), type); }
@Override public String getName() { return this.field.name().interned(); }
public static QualifiedIdentifier $(Collection<Identifier> names) { return new QualifiedIdentifier(ImmutableList.copyOf(names)); }
public FieldEval(String columnName, Type type) { super(EvalType.FIELD); this.field = Field($(columnName), type); }
public String interned() { return interned(DefaultPolicy()); }
public static QualifiedIdentifier fromProto(QualifiedIdentifierProto proto) { Collection<Identifier> ids = Collections2.transform(proto.getNamesList(), new Function<IdentifierProto, Identifier>() { @Override public Identifier apply(@Nullable IdentifierProto identifierProto) { return Identifier.fromProto(identifierProto); } }); return new QualifiedIdentifier(ids); }
public static QualifiedIdentifier makeIdentifier(String raw, IdentifierPolicy policy) { if (raw == null || raw.equals("")) { return $(raw); } final String [] splitted = raw.split(IDENTIFIER_DELIMITER_REGEXP); final ImmutableList.Builder<Identifier> builder = ImmutableList.builder(); for (String part : splitted) { boolean quoted = isDelimited(part, policy); if (quoted) { builder.add(_(stripQuote(part), true)); } else { builder.add(internIdentifierPart(part, policy)); } } return $(builder.build()); }
public String getQualifier() { return IdentifierUtil.extractQualifier(field.name().interned()); }
/** * It takes interned strings. It assumes all parameters already stripped. It is used only for tests. * @param names interned strings * @return QualifiedIdentifier */ @VisibleForTesting public static QualifiedIdentifier $(String...names) { final ImmutableList.Builder<Identifier> builder = ImmutableList.builder(); for (String n : names) { for (String split : n.split(StringUtils.escapeRegexp(""+DefaultPolicy().getIdentifierSeperator()))) { builder.add(Identifier._(split, IdentifierUtil.isShouldBeQuoted(split))); } } return new QualifiedIdentifier(builder.build()); }
public FieldEval(String columnName, DataType type) { super(EvalType.FIELD); this.field = Field($(columnName), TypeConverter.convert(type)); }
public String getColumnName() { return IdentifierUtil.extractSimpleName(field.name().interned()); }
"(-|[0-9]*) (-|[0-9]*)(?: ([^ \"]*|\"[^\"]*\") ([^ \"]*|\"[^\"]*\"))?"; Field f1 = Field.Field($("host"), Text); Field f2 = Field.Field($("identity"), Text); Field f3 = Field.Field($("user"), Text); Field f4 = Field.Field($("time"), Text); Field f5 = Field.Field($("request"), Text); Field f6 = Field.Field($("status"), Text); Field f7 = Field.Field($("size"), Text); Field f8 = Field.Field($("referer"), Text); Field f9 = Field.Field($("agent"), Text);
@Deprecated public SchemaLegacy build() { ImmutableList.Builder<Column> columns = new ImmutableList.Builder(); for (Field field : fields.build()) { columns.add(new Column(field.name().interned(), field.type())); } return new SchemaLegacy(columns.build()); }