@Override public Optional<? extends SQLSegment> extract(final ParserRuleContext ancestorNode) { Optional<ParserRuleContext> showParamNode = ExtractorUtils.findFirstChildNode(ancestorNode, RuleName.SHOW_PARAM); if (!showParamNode.isPresent()) { return Optional.absent(); } String result = showParamNode.get().getText(); return Optional.of(new ShowParamSegment(result)); } }
@Override public Optional<RenameColumnSegment> extract(final ParserRuleContext ancestorNode) { Optional<ParserRuleContext> modifyColumnNode = ExtractorUtils.findFirstChildNode(ancestorNode, RuleName.RENAME_COLUMN); if (!modifyColumnNode.isPresent()) { return Optional.absent(); } Collection<ParserRuleContext> columnNodes = ExtractorUtils.getAllDescendantNodes(modifyColumnNode.get(), RuleName.COLUMN_NAME); if (2 != columnNodes.size()) { return Optional.absent(); } Iterator<ParserRuleContext> iterator = columnNodes.iterator(); return Optional.of(new RenameColumnSegment(iterator.next().getText(), iterator.next().getText())); } }
@Override public void enterEveryRule(ParserRuleContext ctx) { final Expression expression = parseContext.expressions().get(ctx); if (expression != null && !parseContext.isInnerNode(ctx)) { sb.append(" ( "); sb.append(expression.getClass().getSimpleName()); sb.append(":").append(ctx.getClass().getSimpleName()).append(" "); sb.append(" <").append(expression.getType().getSimpleName()).append("> "); sb.append(ctx.getText()); } }
@Override public Optional<SetAutoCommitSegment> extract(final ParserRuleContext ancestorNode) { Optional<ParserRuleContext> autoCommitValueNode = ExtractorUtils.findFirstChildNode(ancestorNode, RuleName.AUTO_COMMIT_VALUE); return autoCommitValueNode.isPresent() ? Optional.of(new SetAutoCommitSegment("1".equals(SQLUtil.getExactlyValue(autoCommitValueNode.get().getText())))) : Optional.<SetAutoCommitSegment>absent(); } }
private void extractDuplicateKeys(final ParserRuleContext ancestorNode, final InsertSegment insertSegment) { Optional<ParserRuleContext> onDuplicateClauseNode = ExtractorUtils.findFirstChildNode(ancestorNode, RuleName.ON_DUPLICATE_CLAUSE); if (!onDuplicateClauseNode.isPresent()) { return; } for (ParserRuleContext each : ExtractorUtils.getAllDescendantNodes(onDuplicateClauseNode.get(), RuleName.COLUMN_NAME)) { insertSegment.getDuplicateKeyColumns().add(each.getText()); } } }
@Override public Optional<ColumnDefinitionSegment> extract(final ParserRuleContext ancestorNode) { Optional<ParserRuleContext> columnNameNode = ExtractorUtils.findFirstChildNode(ancestorNode, RuleName.COLUMN_NAME); if (!columnNameNode.isPresent()) { return Optional.absent(); } Optional<ParserRuleContext> dataTypeNode = ExtractorUtils.findFirstChildNode(ancestorNode, RuleName.DATA_TYPE); Optional<String> dataTypeText = dataTypeNode.isPresent() ? Optional.of(dataTypeNode.get().getChild(0).getText()) : Optional.<String>absent(); boolean isPrimaryKey = ExtractorUtils.findFirstChildNode(ancestorNode, RuleName.PRIMARY_KEY).isPresent(); return Optional.of(new ColumnDefinitionSegment(columnNameNode.get().getText(), dataTypeText.orNull(), isPrimaryKey)); } }
@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(); } }
protected void verifyNameLength(String constructType, int length, ParserRuleContext ctx) { if (enabledRules.contains(Rules.MAX_NAME_LENGTH) && SourceFileUtil.nameTooLong(ctx, length)) { createErrorMessage(Rules.MAX_NAME_LENGTH, ctx.getText().length(), ctx, constructType, length, Messages.EXCEEDS_CHARACTER_LIMIT); } }
@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); } }
@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<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 void verifyNotSemicolonTerminated(String constructType, ParserRuleContext ctx) { String construct = ctx.getText(); if (construct.endsWith(";")) { Location location = ListenerUtil.getContextStopLocation(ctx); this.printer.error(Rules.TERMINATING_SEMICOLON, constructType + Messages.SEMICOLON, location); } } }
@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); } }
private boolean isValidEqualCondition(final ParserRuleContext comparisionNode) { return Symbol.EQ.getLiterals().equalsIgnoreCase(comparisionNode.getText()) && 3 == comparisionNode.getParent().getChildCount(); }
@Override public Optional<ConstraintDefinitionSegment> extract(final ParserRuleContext ancestorNode) { Optional<ParserRuleContext> primaryKeyNode = ExtractorUtils.findFirstChildNode(ancestorNode, RuleName.PRIMARY_KEY); if (!primaryKeyNode.isPresent()) { return Optional.absent(); } Optional<ParserRuleContext> columnListNode = ExtractorUtils.findFirstChildNode(primaryKeyNode.get().getParent().getParent(), RuleName.COLUMN_LIST); if (!columnListNode.isPresent()) { return Optional.absent(); } Collection<ParserRuleContext> columnNameNodes = ExtractorUtils.getAllDescendantNodes(columnListNode.get(), RuleName.COLUMN_NAME); if (columnNameNodes.isEmpty()) { return Optional.absent(); } ConstraintDefinitionSegment result = new ConstraintDefinitionSegment(); for (ParserRuleContext each : columnNameNodes) { result.getPrimaryKeyColumnNames().add(each.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; }
@Override public Collection<OrderByItemSegment> extract(final ParserRuleContext ancestorNode) { Collection<OrderByItemSegment> result = new LinkedList<>(); for (ParserRuleContext each : ExtractorUtils.getAllDescendantNodes(ancestorNode, RuleName.ORDER_BY_ITEM)) { OrderDirection orderDirection = 2 == each.getChildCount() && OrderDirection.DESC.name().equalsIgnoreCase(each.getChild(1).getText()) ? OrderDirection.DESC : OrderDirection.ASC; Optional<ParserRuleContext> indexNode = ExtractorUtils.findFirstChildNode(each, RuleName.NUMBER); if (indexNode.isPresent()) { result.add(new IndexOrderByItemSegment(NumberUtil.getExactlyNumber(indexNode.get().getText(), 10).intValue(), orderDirection, OrderDirection.ASC)); continue; } Optional<ParserRuleContext> expressionNode = ExtractorUtils.findFirstChildNode(each, RuleName.EXPR); if (expressionNode.isPresent()) { result.add(new ExpressionOrderByItemSegment(expressionNode.get().getText(), orderDirection, OrderDirection.ASC)); continue; } Optional<ParserRuleContext> columnNameNode = ExtractorUtils.findFirstChildNode(each, RuleName.COLUMN_NAME); if (columnNameNode.isPresent()) { result.add(new ColumnNameOrderByItemSegment(columnNameNode.get().getText(), ((ParserRuleContext) each.getChild(0)).getStart().getStartIndex(), orderDirection, OrderDirection.ASC)); } } return result; } }
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()); } }
private void verifyUpperCamelCase(String constructType, ParserRuleContext ctx) { String constructName = ctx.getText(); if (!CharFormatUtil.isUpperCamelCase(constructName)) { Location location = ListenerUtil.getContextStartLocation(ctx); this.printer.error(Rules.UPPER_CAMEL_CASE, constructType + Messages.UPPER_CAMEL_CASE, location); } }
@Test public void testNameTooLongMaxLengthValid() { when(context.getText()).thenReturn(NAME); assertFalse(SourceFileUtil.nameTooLong(context, NAME.length())); assertFalse(SourceFileUtil.nameTooLong(context, NAME.length() + 1)); assertTrue(SourceFileUtil.nameTooLong(context, NAME.length() - 10)); when(context.getText()).thenReturn(""); assertFalse(SourceFileUtil.nameTooLong(context, NAME.length())); }