@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); } }
/** * Append the text preserving the formatting (space symbols) between tokens */ void append(StringBuilder str, String appendStr, Token start, Token stop) { String spaces = start.getInputStream().getText(new org.antlr.v4.runtime.misc.Interval(start.getStartIndex(), stop.getStopIndex())); spaces = spaces.substring(start.getText().length(), spaces.length() - stop.getText().length()); str.append(spaces); str.append(appendStr); }
@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())); } }
@Override public Optional<IndexSegment> extract(final ParserRuleContext ancestorNode) { Optional<ParserRuleContext> indexNameNode = ExtractorUtils.findFirstChildNode(ancestorNode, RuleName.INDEX_NAME); return indexNameNode.isPresent() ? Optional.of(new IndexSegment(new IndexToken(indexNameNode.get().getStop().getStartIndex(), indexNameNode.get().getStop().getStopIndex()))) : Optional.<IndexSegment>absent(); } }
@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 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 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()); }
/** * Get node text including spaces */ String getText(ParserRuleContext ctx) { return ctx.start.getInputStream().getText(new org.antlr.v4.runtime.misc.Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex())); }
/** * Get formatted text between 2 tokens */ public String getFormattedText(ParserRuleContext ctx) { return ctx.start.getInputStream().getText( new org.antlr.v4.runtime.misc.Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex())); }
/** * Get node text including spaces */ String getText(ParserRuleContext ctx) { return ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex())); }
private static String getStatementString( final SingleStatementContext singleStatementContext ) { final CharStream charStream = singleStatementContext.start.getInputStream(); return charStream.getText(Interval.of( singleStatementContext.start.getStartIndex(), singleStatementContext.stop.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); }
@Override public void enterFunctionCall(@NotNull PQL2Parser.FunctionCallContext ctx) { String expression = _expression.substring(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex() + 1); pushNode(new FunctionCallAstNode(ctx.getChild(0).getText(), expression)); }
/** * Executing OS command */ @Override public Integer visitHost_cmd(HplsqlParser.Host_cmdContext ctx) { trace(ctx, "HOST"); execHost(ctx, ctx.start.getInputStream().getText( new org.antlr.v4.runtime.misc.Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()))); return 0; }
@Override public void exitNonReserved(SqlBaseParser.NonReservedContext context) { // we can't modify the tree during rule enter/exit event handling unless we're dealing with a terminal. // Otherwise, ANTLR gets confused an fires spurious notifications. if (!(context.getChild(0) instanceof TerminalNode)) { int rule = ((ParserRuleContext) context.getChild(0)).getRuleIndex(); throw new AssertionError("nonReserved can only contain tokens. Found nested rule: " + ruleNames.get(rule)); } // replace nonReserved words with IDENT tokens context.getParent().removeLastChild(); Token token = (Token) context.getChild(0).getPayload(); context.getParent().addChild(new CommonToken( new Pair<>(token.getTokenSource(), token.getInputStream()), SqlBaseLexer.IDENTIFIER, token.getChannel(), token.getStartIndex(), token.getStopIndex())); } }