public static NodeLocation getLocation(ParserRuleContext parserRuleContext) { requireNonNull(parserRuleContext, "parserRuleContext is null"); return getLocation(parserRuleContext.getStart()); }
@JsonProperty public int positionInLine() { return ctx.getStart().getCharPositionInLine(); }
@JsonProperty public int line() { return ctx.getStart().getLine(); }
/** * Error message */ public void error(ParserRuleContext ctx, String message) { if (ctx != null) { System.err.println("Ln:" + ctx.getStart().getLine() + " " + message); } else { System.err.println(message); } }
protected SourceLocation getSourceLocation(ParserRuleContext parserRuleContext) { return getSourceLocation(parserRuleContext.getStart()); }
@Override public Optional<ColumnSegment> extract(final ParserRuleContext ancestorNode) { Optional<ParserRuleContext> columnNode = ExtractorUtils.findFirstChildNode(ancestorNode, RuleName.COLUMN_NAME); return columnNode.isPresent() ? Optional.of(new ColumnSegment(columnNode.get().getText(), columnNode.get().getStart().getStartIndex())) : Optional.<ColumnSegment>absent(); } }
@Override public Optional<ColumnPositionSegment> extract(final ParserRuleContext ancestorNode) { Optional<ParserRuleContext> firstOrAfterColumnNode = ExtractorUtils.findFirstChildNode(ancestorNode, RuleName.FIRST_OR_AFTER_COLUMN); if (!firstOrAfterColumnNode.isPresent()) { return Optional.absent(); } Optional<ParserRuleContext> columnNameNode = ExtractorUtils.findFirstChildNode(firstOrAfterColumnNode.get(), RuleName.COLUMN_NAME); ColumnPositionSegment result = columnNameNode.isPresent() ? new ColumnAfterPositionSegment(columnName, firstOrAfterColumnNode.get().getStart().getStartIndex(), columnNameNode.get().getText()) : new ColumnFirstPositionSegment(columnName, firstOrAfterColumnNode.get().getStart().getStartIndex()); return Optional.of(result); } }
@Override public Optional<StarSelectItemSegment> extract(final ParserRuleContext expressionNode) { String text = expressionNode.getText(); if (!text.endsWith(Symbol.STAR.getLiterals())) { return Optional.absent(); } String owner = text.contains(Symbol.DOT.getLiterals()) ? text.substring(0, text.indexOf(Symbol.DOT.getLiterals())) : null; return Optional.of(new StarSelectItemSegment(owner, expressionNode.getStart().getStartIndex())); } }
protected List<Comment> getComments(ParserRuleContext ctx) { Token start = ctx.getStart(); if (start != null) { int tokPos = start.getTokenIndex(); List<Token> refChannel = tokens.getHiddenTokensToLeft(tokPos, CHANNEL_COMMENTS); if (refChannel != null) { return getCommentOnChannel(refChannel); } } return Collections.emptyList(); }
@Override public Optional<ColumnSelectItemSegment> extract(final ParserRuleContext expressionNode) { if (!RuleName.COLUMN_NAME.getName().equals(expressionNode.getChild(0).getClass().getSimpleName())) { return Optional.absent(); } ParserRuleContext columnNode = (ParserRuleContext) expressionNode.getChild(0); ColumnSelectItemSegment result = new ColumnSelectItemSegment(columnNode.getText(), columnNode.getStart().getStartIndex()); Optional<ParserRuleContext> aliasNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.ALIAS); if (aliasNode.isPresent()) { result.setAlias(aliasNode.get().getText()); } return Optional.of(result); } }
private ExpressionSegment extractPropertyExpressionSegment(final ParserRuleContext expressionNode) { ParserRuleContext columnNode = (ParserRuleContext) expressionNode.getChild(0); Optional<ColumnSegment> columnSegment = new ColumnSegmentExtractor().extract(columnNode); Preconditions.checkState(columnSegment.isPresent()); return new PropertyExpressionSegment(columnSegment.get().getName(), columnSegment.get().getOwner().orNull(), columnNode.getStart().getStartIndex(), columnNode.getStop().getStopIndex()); }
private LimitValueSegment createLimitValueSegment(final Map<ParserRuleContext, Integer> placeholderAndNodeIndexMap, final ParserRuleContext limitValueNode) { return Symbol.QUESTION.getLiterals().equals(limitValueNode.getText()) ? new PlaceholderLimitValueSegment(placeholderAndNodeIndexMap.get(limitValueNode.getChild(0)), ((ParserRuleContext) limitValueNode.getChild(0)).getStart().getStartIndex()) : new LiteralLimitValueSegment(NumberUtil.getExactlyNumber(limitValueNode.getText(), 10).intValue(), limitValueNode.getStart().getStartIndex()); } }
@Override public Optional<ExpressionSelectItemSegment> extract(final ParserRuleContext expressionNode) { // TODO parse table inside expression ExpressionSelectItemSegment result = new ExpressionSelectItemSegment(expressionNode.getText(), expressionNode.getStart().getStartIndex(), expressionNode.getStop().getStopIndex()); Optional<ParserRuleContext> aliasNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.ALIAS); if (aliasNode.isPresent()) { result.setAlias(aliasNode.get().getText()); } return Optional.of(result); } }
private SelectItemSegment extractFunctionSelectItemSegment(final ParserRuleContext expressionNode, final ParserRuleContext functionNode) { String functionName = functionNode.getChild(0).getText(); Optional<AggregationType> aggregationType = findAggregationType(functionName); AliasAvailable result = aggregationType.isPresent() ? extractAggregationSelectItemSegment(aggregationType.get(), functionNode) : new ExpressionSelectItemSegment(functionNode.getText(), functionNode.getStart().getStartIndex(), functionNode.getStop().getStopIndex()); Optional<ParserRuleContext> aliasNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.ALIAS); if (aliasNode.isPresent()) { result.setAlias(aliasNode.get().getText()); } return (SelectItemSegment) result; }
private AggregationSelectItemSegment extractAggregationSelectItemSegment(final AggregationType type, final ParserRuleContext functionNode) { return ExtractorUtils.findFirstChildNode(functionNode, RuleName.DISTINCT).isPresent() ? new AggregationDistinctSelectItemSegment( type, getInnerExpression(functionNode), functionNode.getStart().getStartIndex(), functionNode.getStop().getStopIndex(), getDistinctExpression(functionNode)) : new AggregationSelectItemSegment(type, getInnerExpression(functionNode), functionNode.getStart().getStartIndex(), functionNode.getStop().getStopIndex()); }
@Override public Optional<SelectClauseSegment> extract(final ParserRuleContext ancestorNode) { ParserRuleContext selectClauseNode = ExtractorUtils.getFirstChildNode(ancestorNode, RuleName.SELECT_CLAUSE); ParserRuleContext selectExpressionsNode = ExtractorUtils.getFirstChildNode(selectClauseNode, RuleName.SELECT_EXPRS); SelectClauseSegment result = new SelectClauseSegment(selectExpressionsNode.getStart().getStartIndex(), selectExpressionsNode.getStop().getStopIndex(), hasDistinct(selectClauseNode)); for (int i = 0; i < selectExpressionsNode.getChildCount(); i++) { ParseTree selectExpressionNode = selectExpressionsNode.getChild(i); if (selectExpressionNode instanceof TerminalNodeImpl) { continue; } Optional<? extends SelectItemSegment> selectItemSegment = selectItemExtractor.extract((ParserRuleContext) selectExpressionNode); if (selectItemSegment.isPresent()) { result.getSelectItems().add(selectItemSegment.get()); } } return Optional.of(result); }
private ExpressionSegment extractFunctionExpressionSegment(final ParserRuleContext functionNode) { return new FunctionExpressionSegment(functionNode.getChild(0).getText(), functionNode.getStart().getStartIndex(), ((TerminalNode) functionNode.getChild(1)).getSymbol().getStartIndex(), functionNode.getStop().getStopIndex(), -1); }
private void addIgnoredChars(ParserRuleContext ctx, NodeBuilder nodeBuilder) { Token start = ctx.getStart(); int tokenStartIndex = start.getTokenIndex(); List<Token> leftChannel = tokens.getHiddenTokensToLeft(tokenStartIndex, CHANNEL_IGNORED_CHARS); List<IgnoredChar> ignoredCharsLeft = mapTokenToIgnoredChar(leftChannel); Token stop = ctx.getStop(); int tokenStopIndex = stop.getTokenIndex(); List<Token> rightChannel = tokens.getHiddenTokensToRight(tokenStopIndex, CHANNEL_IGNORED_CHARS); List<IgnoredChar> ignoredCharsRight = mapTokenToIgnoredChar(rightChannel); nodeBuilder.ignoredChars(new IgnoredChars(ignoredCharsLeft, ignoredCharsRight)); }