/** * Traverses path segment to extract named segments, omits all other segments (i.e. array). * Order of named segments appearance will be preserved. * * @param currentSegment current segment * @param resultingSegment resulting segment * @return named segment */ private NameSegment getUnIndexedNameSegment(PathSegment currentSegment, NameSegment resultingSegment) { if (!currentSegment.isLastPath()) { resultingSegment = getUnIndexedNameSegment(currentSegment.getChild(), resultingSegment); } if (currentSegment.isNamed()) { String path = currentSegment.getNameSegment().getPath(); return new NameSegment(path, resultingSegment); } return resultingSegment; }
@Override public NameSegment cloneWithNewChild(PathSegment newChild) { NameSegment s = new NameSegment(this.path); if (getChild() != null) { s.setChild(getChild().cloneWithNewChild(newChild)); } else { s.setChild(newChild); } return s; } }
@Override public int hashCode() { int h = hash; if (h == 0) { h = segmentHashCode(); h = h + ((child == null) ? 0 : 31 * child.hashCode()); hash = h; } return h; }
/** * A simple is a path where there are no repeated elements outside the lowest level of the path. * @return Whether this path is a simple path. */ public boolean isSimplePath() { PathSegment seg = rootSegment; while (seg != null) { if (seg.isArray() && !seg.isLastPath()) { return false; } seg = seg.getChild(); } return true; }
/** * Return whether this name refers to an array. The path must be an array if it * ends with an array index; else it may or may not be an entire array. * * @return true if the path ends with an array index, false otherwise */ public boolean isArray() { PathSegment seg = rootSegment; while (seg != null) { if (seg.isArray()) { return true; } seg = seg.getChild(); } return false; }
@Override public Void visitSchemaPath(SchemaPath path, StringBuilder sb) throws RuntimeException { PathSegment seg = path.getRootSegment(); if (seg.isArray()) { throw new IllegalStateException("Drill doesn't currently support top level arrays"); } sb.append('`'); sb.append(escapeBackTick(seg.getNameSegment().getPath())); sb.append('`'); while ( (seg = seg.getChild()) != null) { if (seg.isNamed()) { sb.append('.'); sb.append('`'); sb.append(escapeBackTick(seg.getNameSegment().getPath())); sb.append('`'); } else { sb.append('['); sb.append(seg.getArraySegment().getIndex()); sb.append(']'); } } return null; }
if (!(isRowKey || (!field.getRootSegment().isLastPath() && field.getRootSegment().getChild().isLastPath() && field.getRootSegment().getChild().isNamed()) byte[] qualifier = HBaseUtils.getBytes(field.getRootSegment().getChild().getNameSegment().getPath()); filter = new SingleColumnValueFilter(family, qualifier, compareOp, comparator); ((SingleColumnValueFilter)filter).setLatestVersionOnly(true);
private static FieldPath getFieldPathForProjection(SchemaPath column) { Stack<PathSegment.NameSegment> pathSegments = new Stack<>(); PathSegment seg = column.getRootSegment(); while (seg != null && seg.isNamed()) { pathSegments.push((PathSegment.NameSegment) seg); seg = seg.getChild(); } FieldSegment.NameSegment child = null; while (!pathSegments.isEmpty()) { child = new FieldSegment.NameSegment(pathSegments.pop().getPath(), child, false); } return new FieldPath(child); }
col = colIterator.next(); colPath = col.getRootSegment(); colNextChild = colPath.getChild(); if (colPath != null && colPath.isNamed() && (!SchemaPath.DYNAMIC_STAR.equals(colPath.getNameSegment().getPath()))) { name = colPath.getNameSegment().getPath(); if(colNextChild.isNamed()) { break; colNextChild=colNextChild.getChild(); SchemaPath s = new SchemaPath(colNextChild.getNameSegment()); c.add(s);
public void ensureAtLeastOneField(ComplexWriter writer) { if (!atLeastOneWrite) { // if we had no columns, create one empty one so we can return some data // for count purposes. SchemaPath sp = columns.get(0); PathSegment root = sp.getRootSegment(); BaseWriter.MapWriter fieldWriter = writer.rootAsMap(); while (root.getChild() != null && !root.getChild().isArray()) { fieldWriter = fieldWriter.map(root.getNameSegment().getPath()); root = root.getChild(); } fieldWriter.integer(root.getNameSegment().getPath()); } }
transformed.add(SchemaPath.getSimplePath(root.getPath())); PathSegment child = root.getChild(); if (child != null && child.isNamed()) { byte[] qualifier = child.getNameSegment().getPath().getBytes(); hbaseScanColumnsOnly.addColumn(family, qualifier); if (!completeFamilies.contains(root.getPath())) {
Pattern p = Pattern.compile("(\\w+)_([isdb])(\\d*)"); for (SchemaPath path : columns) { String col = path.getLastSegment().getNameSegment().getPath(); if (SchemaPath.DYNAMIC_STAR.equals(col)) { return this;
@Test public void testIfMultiLevelCloneWorks() { final int levels = 10; final PathSegment segment = new PathSegment.NameSegment("test", makeArraySegment(levels, null)); final PathSegment clone = segment.clone(); assertEquals("result of clone & original segments must be identical", segment, clone); final PathSegment tail = new PathSegment.NameSegment("tail"); final PathSegment newSegment = new PathSegment.NameSegment("test", makeArraySegment(levels, tail)); final PathSegment newClone = segment.cloneWithNewChild(tail); assertEquals("result of cloneWithChild & original segment must be identical", newSegment, newClone); } }
public static TypedFieldId getFieldIdIfMatchesUnion(UnionVector unionVector, TypedFieldId.Builder builder, boolean addToBreadCrumb, PathSegment seg) { if (seg != null) { if (seg.isNamed()) { ValueVector v = unionVector.getMap(); if (v != null) { return getFieldIdIfMatches(v, builder, addToBreadCrumb, seg); } else { return null; } } else if (seg.isArray()) { ValueVector v = unionVector.getList(); if (v != null) { return getFieldIdIfMatches(v, builder, addToBreadCrumb, seg); } else { return null; } } } else { if (addToBreadCrumb) { builder.intermediateType(unionVector.getField().getType()); } return builder.finalType(unionVector.getField().getType()).build(); } return null; }
if (otherSeg.isArray() || this.isArray()) { return true; if (!segmentEquals(otherSeg)) { return false; return true; } else { return child.contains(otherSeg.child);
Preconditions.checkArgument(path.getRootSegment().getChild().isArray(), String.format("Selected column '%s' must be an array index", pathStr)); int index = path.getRootSegment().getChild().getArraySegment().getIndex(); columnIds.add(index);
@Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } PathSegment other = (PathSegment) obj; if (!segmentEquals(other)) { return false; } else if (child == null) { return (other.child == null); } else { return child.equals(other.child); } }
@Override public NameSegment clone() { NameSegment s = new NameSegment(this.path); if (getChild() != null) { s.setChild(getChild().clone()); } return s; }