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)