def new_delete_parser(db_type, sharding_rule, lexer_engine):
if db_type == DatabaseType.MySQL:
from shardingpy.parsing.parser.dialect.mysql import MySQLDeleteParser
return MySQLDeleteParser(sharding_rule, lexer_engine)
else:
raise UnsupportedOperationException(
"Cannot support database {}".format(db_type))
def get_sharding_value(self, parameters):
condition_values = self.get_condition_values(parameters)
if self.operator in [ShardingOperator.EQUAL, ShardingOperator.IN]:
return ListShardingValue(self.column.table_name, self.column.name,
condition_values)
elif self.operator == ShardingOperator.BETWEEN:
return RangeShardingValue(
self.column.table_name, self.column.name,
Range(condition_values[0], RangeType.CLOSED,
condition_values[1], RangeType))
else:
raise UnsupportedOperationException(
"sharding condition not support :" + self.operator.value)
def rewrite(self, is_rewrite_limit):
result = SQLBuilder(self.parameters)
if not self.sql_tokens:
return result.append_literals(self.orignial_sql)
count = 0
self._sort_by_begin_position(self.sql_tokens)
for token in self.sql_tokens:
if count == 0:
result.append_literals(
self.orignial_sql[:token.begin_position])
if isinstance(token, TableToken):
self._append_table_placehodler(result, token, count,
self.sql_tokens)
elif isinstance(token, SchemaToken):
# TODO schema
raise UnsupportedOperationException('schema')
elif isinstance(token, IndexToken):
# TODO index
raise UnsupportedOperationException('force index')
elif isinstance(token, ItemsToken):
self._append_items_token(result, token, count, self.sql_tokens)
elif isinstance(token, InsertValuesToken):
self._append_insert_values_token(result, token, count,
self.sql_tokens)
elif isinstance(token, RowCountToken):
self._append_limit_row_count(result, token, count,
self.sql_tokens, is_rewrite_limit)
elif isinstance(token, OffsetToken):
self._append_limit_offset_token(result, token, count,
self.sql_tokens,
is_rewrite_limit)
elif isinstance(token, OrderByToken):
self._append_order_by_token(result, count, self.sql_tokens)
elif isinstance(token, InsertColumnToken):
self._append_symbol_token(result, token, count,
self.sql_tokens)
count += 1
return result
def parse(self):
self.lexer_engine.next_token()
result = InsertStatement()
self.insert_clause_parser_facade.insert_into_clause_parser.parse(
result)
self.insert_clause_parser_facade.insert_columns_clause_parser.parse(
result, self.sharding_meta_data)
if self.lexer_engine.equal_any(DefaultKeyword.SELECT,
Symbol.LEFT_PAREN):
raise UnsupportedOperationException('Cannot INSERT SELECT')
self.insert_clause_parser_facade.insert_values_clause_parser.parse(
result)
self.insert_clause_parser_facade.insert_set_clause_parser.parse(result)
self.insert_clause_parser_facade.insert_duplicate_key_update_clause_parser.parse(
result)
self._process_generated_key(result)
return result
def parse_table_factor(self, sql_statement, is_single_table_only):
literals = self.lexer_engine.get_current_token().literals
begin_position = self.lexer_engine.get_current_token().end_position - len(literals)
skipped_schema_name_length = 0
self.lexer_engine.next_token()
if self.lexer_engine.skip_if_equal(Symbol.DOT):
skipped_schema_name_length += len(literals) + len(Symbol.DOT.value)
literals = self.lexer_engine.get_current_token().literals
table_name = sqlutil.get_exactly_value(literals)
if not table_name:
return
alias = self.alias_expression_parser.parse_table_alias()
if is_single_table_only or self.sharding_rule.try_find_table_rule_by_logic_table(
table_name) or self.sharding_rule.find_binding_table_rule(
table_name) or self.sharding_rule.sharding_data_source_names.get_default_data_source_name() in \
self.sharding_rule.sharding_data_source_names.data_source_names:
sql_statement.sql_tokens.append(TableToken(begin_position, skipped_schema_name_length, literals))
sql_statement.tables.add(Table(table_name, alias))
self._parse_force_index(table_name, sql_statement)
self._parse_join_table(sql_statement)
if is_single_table_only and not sql_statement.tables.is_single_table():
raise UnsupportedOperationException("Cannot support Multiple-Table")
def new_instance(cls, db_type, sql):
assert isinstance(db_type, DatabaseType)
if db_type == DatabaseType.MySQL:
return LexerEngine(MySQLLexer(sql))
else:
raise UnsupportedOperationException("Cannot support database {}".format(db_type))
def get_database_type(self):
if isinstance(self.lexer, MySQLLexer):
return DatabaseType.MySQL
raise UnsupportedOperationException("Cannot support lexer class: {}".format(self.lexer))
def parse_row_number_select_item(self, select_statement):
raise UnsupportedOperationException("Cannot support special select item")
def _parse_join_table(self, sql_statement):
while self._parse_join_type():
if self.lexer_engine.equal_any(Symbol.LEFT_PAREN):
raise UnsupportedOperationException("Cannot support sub query for join table")
self.parse_table_factor(sql_statement, False)
self._parse_join_condition(sql_statement)