/** * Judge is sharding column or not. * * @param column column object * @return is sharding column or not */ public boolean isShardingColumn(final Column column) { for (TableRule each : tableRules) { if (each.getLogicTable().equalsIgnoreCase(column.getTableName()) && isShardingColumn(each, column)) { return true; } } return false; }
/** * Add condition. * * @param condition condition * @param shardingRule databases and tables sharding rule */ public void add(final Condition condition, final ShardingRule shardingRule) { // TODO self-join has problem, table name maybe use alias if (shardingRule.isShardingColumn(condition.getColumn())) { orCondition.add(condition); } } }
private void processDuplicateKey(final ShardingRule shardingRule, final InsertSegment insertSegment, final String tableName) { for (String each : insertSegment.getDuplicateKeyColumns()) { if (shardingRule.isShardingColumn(new Column(SQLUtil.getExactlyValue(each), tableName))) { throw new SQLParsingException("INSERT INTO .... ON DUPLICATE KEY UPDATE can not support on sharding column, token is '%s', literals is '%s'.", Literals.IDENTIFIER, each); } } } }
private Condition parseEqualCondition(final ShardingRule shardingRule, final SQLStatement sqlStatement, final SQLExpression left) { SQLExpression right = basicExpressionParser.parse(sqlStatement); // TODO if have more tables, and cannot find column belong to, should not add to condition, should parse binding table rule. if (!sqlStatement.getTables().isSingleTable() && !(left instanceof SQLPropertyExpression)) { return new NullCondition(); } if (right instanceof SQLNumberExpression || right instanceof SQLTextExpression || right instanceof SQLPlaceholderExpression) { Optional<Column> column = find(sqlStatement.getTables(), left); if (column.isPresent() && shardingRule.isShardingColumn(column.get())) { return new Condition(column.get(), right); } } return new NullCondition(); }
private Condition parseBetweenCondition(final ShardingRule shardingRule, final SQLStatement sqlStatement, final SQLExpression left) { boolean hasComplexExpression = false; List<SQLExpression> rights = new LinkedList<>(); SQLExpression right1 = basicExpressionParser.parse(sqlStatement); rights.add(right1); if (!(right1 instanceof SQLNumberExpression || right1 instanceof SQLTextExpression || right1 instanceof SQLPlaceholderExpression)) { hasComplexExpression = true; } skipsDoubleColon(); lexerEngine.accept(DefaultKeyword.AND); SQLExpression right2 = basicExpressionParser.parse(sqlStatement); rights.add(right2); if (!(right2 instanceof SQLNumberExpression || right2 instanceof SQLTextExpression || right2 instanceof SQLPlaceholderExpression)) { hasComplexExpression = true; } if (!sqlStatement.getTables().isSingleTable() && !(left instanceof SQLPropertyExpression)) { return new NullCondition(); } if (!hasComplexExpression) { Optional<Column> column = find(sqlStatement.getTables(), left); if (column.isPresent() && shardingRule.isShardingColumn(column.get())) { return new Condition(column.get(), rights.get(0), rights.get(1)); } } return new NullCondition(); }
private Condition parseInCondition(final ShardingRule shardingRule, final SQLStatement sqlStatement, final SQLExpression left) { lexerEngine.accept(Symbol.LEFT_PAREN); boolean hasComplexExpression = false; List<SQLExpression> rights = new LinkedList<>(); do { SQLExpression right = basicExpressionParser.parse(sqlStatement); rights.add(right); if (!(right instanceof SQLNumberExpression || right instanceof SQLTextExpression || right instanceof SQLPlaceholderExpression)) { hasComplexExpression = true; } skipsDoubleColon(); } while (lexerEngine.skipIfEqual(Symbol.COMMA)); lexerEngine.accept(Symbol.RIGHT_PAREN); if (!sqlStatement.getTables().isSingleTable() && !(left instanceof SQLPropertyExpression)) { return new NullCondition(); } if (!hasComplexExpression) { Optional<Column> column = find(sqlStatement.getTables(), left); if (column.isPresent() && shardingRule.isShardingColumn(column.get())) { return new Condition(column.get(), rights); } } return new NullCondition(); }
for (CommonExpressionSegment commonExpressionSegment : each.getValues()) { Column column = iterator.next(); boolean shardingColumn = shardingRule.isShardingColumn(column); SQLExpression sqlExpression = orConditionFiller.buildExpression(commonExpressionSegment, sql).get(); insertValue.getColumnValues().add(sqlExpression);
continue; if (shardingRule.isShardingColumn(new Column(condition.getColumn().getName(), getTableName(shardingRule, sqlStatement, condition)))) { shardingCondition.add(condition); needSharding = true;
for (Column each : insertStatement.getColumns()) { SQLExpression sqlExpression = sqlExpressions.get(count); if (shardingRule.isShardingColumn(each)) { if (!(sqlExpression instanceof SQLNumberExpression || sqlExpression instanceof SQLTextExpression || sqlExpression instanceof SQLPlaceholderExpression)) { throw new SQLParsingException("INSERT INTO can not support complex expression value on sharding column '%s'.", each.getName());
if (shardingRule.isShardingColumn(column) && (right instanceof SQLNumberExpression || right instanceof SQLTextExpression || right instanceof SQLPlaceholderExpression)) { insertStatement.getConditions().add(new Condition(column, right), shardingRule);
/** * Parse insert duplicate key update. * * @param insertStatement insert statement */ public void parse(final InsertStatement insertStatement) { if (!lexerEngine.skipIfEqual(getCustomizedInsertKeywords())) { return; } lexerEngine.accept(DefaultKeyword.DUPLICATE); lexerEngine.accept(DefaultKeyword.KEY); lexerEngine.accept(DefaultKeyword.UPDATE); do { Column column = new Column(SQLUtil.getExactlyValue(lexerEngine.getCurrentToken().getLiterals()), insertStatement.getTables().getSingleTableName()); if (shardingRule.isShardingColumn(column)) { throw new SQLParsingException("INSERT INTO .... ON DUPLICATE KEY UPDATE can not support on sharding column, token is '%s', literals is '%s'.", lexerEngine.getCurrentToken().getType(), lexerEngine.getCurrentToken().getLiterals()); } basicExpressionParser.parse(insertStatement); lexerEngine.accept(Symbol.EQ); if (lexerEngine.skipIfEqual(DefaultKeyword.VALUES)) { lexerEngine.accept(Symbol.LEFT_PAREN); basicExpressionParser.parse(insertStatement); lexerEngine.accept(Symbol.RIGHT_PAREN); } else { lexerEngine.nextToken(); } } while (lexerEngine.skipIfEqual(Symbol.COMMA)); }