Commit bdfc0f92 authored by codefairy08's avatar codefairy08
Browse files

Merge branch 'dev' of https://github.com/apache/incubator-shardingsphere into dev_bug_fixs_2211

parents 6328d4d1 710cd5ff

sharding-core/sharding-core-parse/sharding-core-parse-common/src/main/java/org/apache/shardingsphere/core/parse/antlr/extractor/impl/dml/AssignmentExtractor.java

+2 −2
Original line number Diff line number Diff line
@@ -27,7 +27,7 @@ import org.apache.shardingsphere.core.parse.antlr.extractor.util.ExtractorUtils; 
import org.apache.shardingsphere.core.parse.antlr.extractor.util.RuleName;

import org.apache.shardingsphere.core.parse.antlr.sql.segment.dml.assignment.AssignmentSegment;

import org.apache.shardingsphere.core.parse.antlr.sql.segment.dml.column.ColumnSegment;

import org.apache.shardingsphere.core.parse.antlr.sql.segment.dml.expr.CommonExpressionSegment;

import org.apache.shardingsphere.core.parse.antlr.sql.segment.dml.expr.LiteralExpressionSegment;



import java.util.Map;
@@ -51,7 +51,7 @@ public final class AssignmentExtractor implements OptionalSQLSegmentExtractor { 
        }

        Optional<ColumnSegment> columnSegment = columnExtractor.extract((ParserRuleContext) assignmentNode.get().getChild(0), parameterMarkerIndexes);

        Preconditions.checkState(columnSegment.isPresent());

        CommonExpressionSegment expressionSegment = expressionExtractor.extractCommonExpressionSegment((ParserRuleContext) assignmentNode.get().getChild(2), parameterMarkerIndexes);

        LiteralExpressionSegment expressionSegment = expressionExtractor.extractLiteralExpressionSegment((ParserRuleContext) assignmentNode.get().getChild(2), parameterMarkerIndexes);

        return Optional.of(new AssignmentSegment(columnSegment.get(), expressionSegment));

    }

}

sharding-core/sharding-core-parse/sharding-core-parse-common/src/main/java/org/apache/shardingsphere/core/parse/antlr/extractor/impl/dml/ExpressionExtractor.java

+16 −32
Original line number Diff line number Diff line
@@ -18,18 +18,14 @@ 
package org.apache.shardingsphere.core.parse.antlr.extractor.impl.dml;



import com.google.common.base.Optional;

import com.google.common.base.Preconditions;

import org.antlr.v4.runtime.ParserRuleContext;

import org.apache.shardingsphere.core.parse.antlr.extractor.api.OptionalSQLSegmentExtractor;

import org.apache.shardingsphere.core.parse.antlr.extractor.impl.common.column.ColumnExtractor;

import org.apache.shardingsphere.core.parse.antlr.extractor.impl.dml.select.SubqueryExtractor;

import org.apache.shardingsphere.core.parse.antlr.extractor.util.ExtractorUtils;

import org.apache.shardingsphere.core.parse.antlr.extractor.util.RuleName;

import org.apache.shardingsphere.core.parse.antlr.sql.segment.dml.column.ColumnSegment;

import org.apache.shardingsphere.core.parse.antlr.sql.segment.dml.expr.CommonExpressionSegment;

import org.apache.shardingsphere.core.parse.antlr.sql.segment.dml.expr.ExpressionSegment;

import org.apache.shardingsphere.core.parse.antlr.sql.segment.dml.expr.FunctionExpressionSegment;

import org.apache.shardingsphere.core.parse.antlr.sql.segment.dml.expr.PropertyExpressionSegment;

import org.apache.shardingsphere.core.parse.antlr.sql.segment.dml.expr.LiteralExpressionSegment;

import org.apache.shardingsphere.core.util.NumberUtil;



import java.util.Map;
@@ -41,8 +37,6 @@ import java.util.Map; 
 */

public final class ExpressionExtractor implements OptionalSQLSegmentExtractor {

    

    private final ColumnExtractor columnExtractor = new ColumnExtractor();

    

    @Override

    public Optional<? extends ExpressionSegment> extract(final ParserRuleContext expressionNode, final Map<ParserRuleContext, Integer> parameterMarkerIndexes) {

        Optional<ParserRuleContext> subqueryNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.SUBQUERY);
@@ -50,40 +44,30 @@ public final class ExpressionExtractor implements OptionalSQLSegmentExtractor { 
    }

    

    private ExpressionSegment extractExpression(final ParserRuleContext expressionNode, final Map<ParserRuleContext, Integer> parameterMarkerIndexes) {

        Optional<ParserRuleContext> functionNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.FUNCTION_CALL);

        if (functionNode.isPresent()) {

            return extractFunctionExpressionSegment(functionNode.get());

        }

        if (RuleName.COLUMN_NAME.getName().equals(expressionNode.getChild(0).getClass().getSimpleName())) {

            return extractPropertyExpressionSegment(expressionNode, parameterMarkerIndexes);

        if (ExtractorUtils.findFirstChildNode(expressionNode, RuleName.FUNCTION_CALL).isPresent()

                || ExtractorUtils.findFirstChildNodeNoneRecursive(expressionNode, RuleName.COLUMN_NAME).isPresent()) {

            return extractCommonExpressionSegment(expressionNode);

        }

        return extractCommonExpressionSegment(expressionNode, parameterMarkerIndexes);

    }

    

    // TODO extract column name and value from function

    private ExpressionSegment extractFunctionExpressionSegment(final ParserRuleContext functionNode) {

        return new FunctionExpressionSegment(functionNode.getStart().getStartIndex(), functionNode.getStop().getStopIndex());

        return extractLiteralExpressionSegment(expressionNode, parameterMarkerIndexes);

    }

    

    private ExpressionSegment extractPropertyExpressionSegment(final ParserRuleContext expressionNode, final Map<ParserRuleContext, Integer> parameterMarkerIndexes) {

        ParserRuleContext columnNode = (ParserRuleContext) expressionNode.getChild(0);

        Optional<ColumnSegment> columnSegment = columnExtractor.extract(columnNode, parameterMarkerIndexes);

        Preconditions.checkState(columnSegment.isPresent());

        return new PropertyExpressionSegment(columnNode.getStart().getStartIndex(), columnNode.getStop().getStopIndex(), columnSegment.get().getName(), columnSegment.get().getOwner().orNull());

    // TODO extract column name and value from expression

    private ExpressionSegment extractCommonExpressionSegment(final ParserRuleContext functionNode) {

        return new CommonExpressionSegment(functionNode.getStart().getStartIndex(), functionNode.getStop().getStopIndex());

    }

    

    /**

     * Extract common expression segment.

     * Extract literal expression segment.

     *

     * @param parameterMarkerIndexes parameter marker indexes

     * @param expressionNode expression node

     * @return common expression segment

     */

    public CommonExpressionSegment extractCommonExpressionSegment(final ParserRuleContext expressionNode, final Map<ParserRuleContext, Integer> parameterMarkerIndexes) {

        CommonExpressionSegment result = new CommonExpressionSegment(expressionNode.getStart().getStartIndex(), expressionNode.getStop().getStopIndex());

        Optional<ParserRuleContext> questionNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.PARAMETER_MARKER);

        if (questionNode.isPresent()) {

            Integer index = parameterMarkerIndexes.get(questionNode.get());

    public LiteralExpressionSegment extractLiteralExpressionSegment(final ParserRuleContext expressionNode, final Map<ParserRuleContext, Integer> parameterMarkerIndexes) {

        LiteralExpressionSegment result = new LiteralExpressionSegment(expressionNode.getStart().getStartIndex(), expressionNode.getStop().getStopIndex());

        Optional<ParserRuleContext> parameterMarkerNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.PARAMETER_MARKER);

        if (parameterMarkerNode.isPresent()) {

            Integer index = parameterMarkerIndexes.get(parameterMarkerNode.get());

            result.setPlaceholderIndex(index);

            return result;

        }
@@ -91,11 +75,11 @@ public final class ExpressionExtractor implements OptionalSQLSegmentExtractor { 
        if (bitExprNode.isPresent() && 1 != bitExprNode.get().getChildCount()) {

            return result;

        }

        Optional<ParserRuleContext> numberNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.NUMBER);

        Optional<ParserRuleContext> numberNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.NUMBER_LITERALS);

        if (numberNode.isPresent()) {

            result.setLiterals(NumberUtil.getExactlyNumber(numberNode.get().getText(), 10));

        }

        Optional<ParserRuleContext> stringNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.STRING);

        Optional<ParserRuleContext> stringNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.STRING_LITERALS);

        if (stringNode.isPresent()) {

            String text = stringNode.get().getText();

            result.setLiterals(text.substring(1, text.length() - 1));

sharding-core/sharding-core-parse/sharding-core-parse-common/src/main/java/org/apache/shardingsphere/core/parse/antlr/extractor/impl/dml/PredicateExtractor.java

+6 −6
Original line number Diff line number Diff line
@@ -135,21 +135,21 @@ public final class PredicateExtractor implements OptionalSQLSegmentExtractor { 
    }

    

    private Optional<PredicateSegment> extractBetweenPredicate(final ParserRuleContext predicateNode, final Map<ParserRuleContext, Integer> parameterMarkerIndexes, final ColumnSegment column) {

        Optional<? extends ExpressionSegment> beginSQLExpression = expressionExtractor.extract((ParserRuleContext) predicateNode.getChild(2), parameterMarkerIndexes);

        Optional<? extends ExpressionSegment> endSQLExpression = expressionExtractor.extract((ParserRuleContext) predicateNode.getChild(4), parameterMarkerIndexes);

        return beginSQLExpression.isPresent() && endSQLExpression.isPresent()

        Optional<? extends ExpressionSegment> betweenSQLExpression = expressionExtractor.extract((ParserRuleContext) predicateNode.getChild(2), parameterMarkerIndexes);

        Optional<? extends ExpressionSegment> andSQLExpression = expressionExtractor.extract((ParserRuleContext) predicateNode.getChild(4), parameterMarkerIndexes);

        return betweenSQLExpression.isPresent() && andSQLExpression.isPresent()

                ? Optional.of(new PredicateSegment(

                        column, ShardingOperator.BETWEEN.name(), new BetweenValueExpressionSegment(beginSQLExpression.get(), endSQLExpression.get()), predicateNode.getStop().getStopIndex()))

                        column, ShardingOperator.BETWEEN.name(), new BetweenValueExpressionSegment(betweenSQLExpression.get(), andSQLExpression.get()), predicateNode.getStop().getStopIndex()))

                : Optional.<PredicateSegment>absent();

    }

    

    private Optional<PredicateSegment> extractInPredicate(final ParserRuleContext predicateNode, final Map<ParserRuleContext, Integer> parameterMarkerIndexes, final ColumnSegment column) {

        Collection<ExpressionSegment> sqlExpressions = extractExpressionSegments(predicateNode, parameterMarkerIndexes);

        Collection<ExpressionSegment> sqlExpressions = extractInExpressionSegments(predicateNode, parameterMarkerIndexes);

        return sqlExpressions.isEmpty() ? Optional.<PredicateSegment>absent()

                : Optional.of(new PredicateSegment(column, ShardingOperator.IN.name(), new InValueExpressionSegment(sqlExpressions), predicateNode.getStop().getStopIndex()));

    }

    

    private Collection<ExpressionSegment> extractExpressionSegments(final ParserRuleContext predicateNode, final Map<ParserRuleContext, Integer> parameterMarkerIndexes) {

    private Collection<ExpressionSegment> extractInExpressionSegments(final ParserRuleContext predicateNode, final Map<ParserRuleContext, Integer> parameterMarkerIndexes) {

        List<ExpressionSegment> result = new LinkedList<>();

        for (int i = 3; i < predicateNode.getChildCount(); i++) {

            if (RuleName.EXPR.getName().equals(predicateNode.getChild(i).getClass().getSimpleName())) {

sharding-core/sharding-core-parse/sharding-core-parse-common/src/main/java/org/apache/shardingsphere/core/parse/antlr/extractor/impl/dml/WhereExtractor.java

+4 −4
Original line number Diff line number Diff line
@@ -59,13 +59,13 @@ public final class WhereExtractor implements OptionalSQLSegmentExtractor { 
        if (parameterMarkerIndexes.isEmpty()) {

            return;

        }

        Collection<ParserRuleContext> questionNodes = ExtractorUtils.getAllDescendantNodes(whereNode, RuleName.PARAMETER_MARKER);

        if (questionNodes.isEmpty()) {

        Collection<ParserRuleContext> parameterMarkerNodes = ExtractorUtils.getAllDescendantNodes(whereNode, RuleName.PARAMETER_MARKER);

        if (parameterMarkerNodes.isEmpty()) {

            return;

        }

        int whereParameterStartIndex = parameterMarkerIndexes.get(questionNodes.iterator().next());

        int whereParameterStartIndex = parameterMarkerIndexes.get(parameterMarkerNodes.iterator().next());

        whereSegment.setWhereParameterStartIndex(whereParameterStartIndex);

        whereSegment.setWhereParameterEndIndex(whereParameterStartIndex + questionNodes.size() - 1);

        whereSegment.setWhereParameterEndIndex(whereParameterStartIndex + parameterMarkerNodes.size() - 1);

    }

    

    private Optional<OrPredicateSegment> extractOrConditionSegment(final ParserRuleContext whereNode, final Map<ParserRuleContext, Integer> parameterMarkerIndexes) {

sharding-core/sharding-core-parse/sharding-core-parse-common/src/main/java/org/apache/shardingsphere/core/parse/antlr/extractor/impl/dml/insert/InsertValuesExtractor.java

+4 −4
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ import org.apache.shardingsphere.core.parse.antlr.extractor.impl.dml.ExpressionE 
import org.apache.shardingsphere.core.parse.antlr.extractor.util.ExtractorUtils;

import org.apache.shardingsphere.core.parse.antlr.extractor.util.RuleName;

import org.apache.shardingsphere.core.parse.antlr.sql.segment.dml.InsertValuesSegment;

import org.apache.shardingsphere.core.parse.antlr.sql.segment.dml.expr.CommonExpressionSegment;

import org.apache.shardingsphere.core.parse.antlr.sql.segment.dml.expr.LiteralExpressionSegment;



import java.util.Collection;

import java.util.Collections;
@@ -53,10 +53,10 @@ public final class InsertValuesExtractor implements CollectionSQLSegmentExtracto 
        return result;

    }

    

    private Collection<CommonExpressionSegment> extractCommonExpressionSegments(final ParserRuleContext assignmentValuesNode, final Map<ParserRuleContext, Integer> parameterMarkerIndexes) {

        Collection<CommonExpressionSegment> result = new LinkedList<>();

    private Collection<LiteralExpressionSegment> extractCommonExpressionSegments(final ParserRuleContext assignmentValuesNode, final Map<ParserRuleContext, Integer> parameterMarkerIndexes) {

        Collection<LiteralExpressionSegment> result = new LinkedList<>();

        for (ParserRuleContext each : ExtractorUtils.getAllDescendantNodes(assignmentValuesNode, RuleName.ASSIGNMENT_VALUE)) {

            result.add(expressionExtractor.extractCommonExpressionSegment(each, parameterMarkerIndexes));

            result.add(expressionExtractor.extractLiteralExpressionSegment(each, parameterMarkerIndexes));

        }

        return result;

    }