Commit 0413f93e authored by tristaZero's avatar tristaZero
Browse files

Merge branch 'dev' of ssh://github.com/shardingjdbc/sharding-jdbc into dev

parents 05f1cc30 98de0de4

sharding-core/sharding-core-common/src/main/java/org/apache/shardingsphere/core/metadata/table/ShardingTableMetaData.java

+1 −1
Original line number Diff line number Diff line
@@ -90,7 +90,7 @@ public final class ShardingTableMetaData { 
     * Get all column names via table.

     *

     * @param tableName table name

     * @return column names.

     * @return column names

     */

    public Collection<String> getAllColumnNames(final String tableName) {

        return tables.containsKey(tableName) ? tables.get(tableName).getColumns().keySet() : Collections.<String>emptyList();

sharding-core/sharding-core-common/src/main/java/org/apache/shardingsphere/core/rule/EncryptRule.java

+1 −1
Original line number Diff line number Diff line
@@ -28,9 +28,9 @@ import java.util.Collection; 
 *

 * @author panjuan

 */

@Getter

public final class EncryptRule implements BaseRule {

    

    @Getter

    private final ShardingEncryptorEngine encryptorEngine;

    

    public EncryptRule(final EncryptRuleConfiguration encryptRuleConfiguration) {

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/result/insert/InsertOptimizeResultUnit.java

+3 −0
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ import lombok.Getter; 
import lombok.RequiredArgsConstructor;

import org.apache.shardingsphere.core.exception.ShardingException;

import org.apache.shardingsphere.core.parse.old.parser.expression.SQLExpression;

import org.apache.shardingsphere.core.parse.old.parser.expression.SQLIgnoreExpression;

import org.apache.shardingsphere.core.parse.old.parser.expression.SQLNumberExpression;

import org.apache.shardingsphere.core.parse.old.parser.expression.SQLPlaceholderExpression;

import org.apache.shardingsphere.core.parse.old.parser.expression.SQLTextExpression;
@@ -132,6 +133,8 @@ public abstract class InsertOptimizeResultUnit { 
            return "?";

        } else if (sqlExpression instanceof SQLTextExpression) {

            return String.format("'%s'", ((SQLTextExpression) sqlExpression).getText());

        } else if (sqlExpression instanceof SQLIgnoreExpression) {

            return ((SQLIgnoreExpression) sqlExpression).getExpression();

        } else {

            return String.valueOf(((SQLNumberExpression) sqlExpression).getNumber());

        }

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

+65 −0
Original line number Diff line number Diff line
@@ -15,18 +15,20 @@ 
 * limitations under the License.

 */



package org.apache.shardingsphere.core.parse.antlr.extractor.impl.dml;

package org.apache.shardingsphere.core.parse.antlr.extractor.impl.common.expression;



import com.google.common.base.Optional;

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.expression.impl.CommonExpressionExtractor;

import org.apache.shardingsphere.core.parse.antlr.extractor.impl.common.expression.impl.LiteralExpressionExtractor;

import org.apache.shardingsphere.core.parse.antlr.extractor.impl.common.expression.impl.ParameterMarkerExpressionExtractor;

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.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.LiteralExpressionSegment;

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

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



import java.util.Map;
@@ -34,59 +36,30 @@ import java.util.Map; 
 * Expression extractor.

 *

 * @author duhongjun

 * @author zhangliang

 */

public final class ExpressionExtractor implements OptionalSQLSegmentExtractor {

    

    @Override

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

        Optional<ParserRuleContext> subqueryNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.SUBQUERY);

        return subqueryNode.isPresent() ? new SubqueryExtractor().extract(subqueryNode.get(), parameterMarkerIndexes) : Optional.of(extractExpression(expressionNode, parameterMarkerIndexes));

    }

    private final ParameterMarkerExpressionExtractor parameterMarkerExpressionExtractor = new ParameterMarkerExpressionExtractor();

    

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

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

        if (functionNode.isPresent()) {

            return extractCommonExpressionSegment(functionNode.get());

        }

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

            return extractCommonExpressionSegment(expressionNode);

        }

        return extractCommonExpressionSegment(expressionNode, parameterMarkerIndexes);

    }

    private final LiteralExpressionExtractor literalExpressionExtractor = new LiteralExpressionExtractor();

    

    // TODO extract column name and value from function

    private ExpressionSegment extractCommonExpressionSegment(final ParserRuleContext functionNode) {

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

    }

    private final CommonExpressionExtractor commonExpressionExtractor = new CommonExpressionExtractor();

    

    /**

     * Extract common expression segment.

     *

     * @param parameterMarkerIndexes parameter marker indexes

     * @param expressionNode expression node

     * @return common expression segment

     */

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

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

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

        if (questionNode.isPresent()) {

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

            result.setPlaceholderIndex(index);

            return result;

        }

        Optional<ParserRuleContext> bitExprNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.BIT_EXPR);

        if (bitExprNode.isPresent() && 1 != bitExprNode.get().getChildCount()) {

            return result;

    @Override

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

        Optional<ParserRuleContext> subqueryNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.SUBQUERY);

        if (subqueryNode.isPresent()) {

            return new SubqueryExtractor().extract(subqueryNode.get(), parameterMarkerIndexes);

        }

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

        if (numberNode.isPresent()) {

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

        Optional<ParameterMarkerExpressionSegment> parameterMarkerExpressionSegment = parameterMarkerExpressionExtractor.extract(expressionNode, parameterMarkerIndexes);

        if (parameterMarkerExpressionSegment.isPresent()) {

            return parameterMarkerExpressionSegment;

        }

        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));

        Optional<LiteralExpressionSegment> literalExpressionSegment = literalExpressionExtractor.extract(expressionNode, parameterMarkerIndexes);

        if (literalExpressionSegment.isPresent()) {

            return literalExpressionSegment;

        }

        return result;

        return commonExpressionExtractor.extract(expressionNode, parameterMarkerIndexes);

    }

}

sharding-core/sharding-core-parse/sharding-core-parse-common/src/main/java/org/apache/shardingsphere/core/parse/antlr/filler/encrypt/dml/EncryptWhereFiller.java→sharding-core/sharding-core-parse/sharding-core-parse-common/src/main/java/org/apache/shardingsphere/core/parse/antlr/extractor/impl/common/expression/impl/CommonExpressionExtractor.java

+39 −0
Original line number Diff line number Diff line
@@ -15,42 +15,25 @@ 
 * limitations under the License.

 */



package org.apache.shardingsphere.core.parse.antlr.filler.encrypt.dml;

package org.apache.shardingsphere.core.parse.antlr.extractor.impl.common.expression.impl;



import lombok.Getter;

import lombok.Setter;

import org.apache.shardingsphere.core.metadata.table.ShardingTableMetaData;

import org.apache.shardingsphere.core.parse.antlr.filler.api.EncryptRuleAwareFiller;

import org.apache.shardingsphere.core.parse.antlr.filler.api.SQLSegmentFiller;

import org.apache.shardingsphere.core.parse.antlr.filler.api.ShardingTableMetaDataAwareFiller;

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

import org.apache.shardingsphere.core.parse.antlr.sql.statement.SQLStatement;

import org.apache.shardingsphere.core.parse.antlr.sql.statement.dml.DeleteStatement;

import org.apache.shardingsphere.core.rule.EncryptRule;

import com.google.common.base.Optional;

import org.antlr.v4.runtime.ParserRuleContext;

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

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



import java.util.Map;



/**

 * Where filler for encrypt.

 * Common expression extractor.

 *

 * @author duhongjun

 * @author zhangliang

 */

@Getter

@Setter

public class EncryptWhereFiller implements SQLSegmentFiller<WhereSegment>, EncryptRuleAwareFiller, ShardingTableMetaDataAwareFiller {

    

    private EncryptRule encryptRule;

    

    private ShardingTableMetaData shardingTableMetaData;

public final class CommonExpressionExtractor implements OptionalSQLSegmentExtractor {

    

    // TODO extract column name and value from expression

    @Override

    public void fill(final WhereSegment sqlSegment, final SQLStatement sqlStatement) {

        new EncryptOrConditionFiller(encryptRule, shardingTableMetaData).fill(sqlSegment.getOrPredicate(), sqlStatement);

        sqlStatement.setParametersIndex(sqlSegment.getParameterCount());

        if (sqlStatement instanceof DeleteStatement) {

            DeleteStatement deleteStatement = (DeleteStatement) sqlStatement;

            deleteStatement.setWhereStartIndex(sqlSegment.getWhereStartIndex());

            deleteStatement.setWhereStopIndex(sqlSegment.getWhereStopIndex());

            deleteStatement.setWhereParameterStartIndex(sqlSegment.getWhereParameterStartIndex());

            deleteStatement.setWhereParameterEndIndex(sqlSegment.getWhereParameterEndIndex());

        }

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

        return Optional.of(new CommonExpressionSegment(expressionNode.getStart().getStartIndex(), expressionNode.getStop().getStopIndex()));

    }

}