def find_routing_table(self, data_source_name, actual_table_name): for each in self.routing_tables: if strutil.equals_ignore_case( self.data_source_name, data_source_name) and strutil.equals_ignore_case( each.actual_table_name, actual_table_name): return each
def get_actual_table_names(self, data_source_name, logic_table_name): if not strutil.equals_ignore_case(self.data_source_name, data_source_name): return set() return { each.actual_table_name for each in self.routing_tables if strutil.equals_ignore_case( each.logic_table_name, logic_table_name) }
def get_alias(self, name): if self.contain_star: return raw_name = sqlutil.get_exactly_value(name) for each in self.select_items: if strutil.equals_ignore_case( raw_name, sqlutil.get_exactly_value(each.expression)): return each.alias if strutil.equals_ignore_case(raw_name, each.alias): return raw_name
def find_actual_table_index(self, data_source_name, table_name): result = 0 for each in self.actual_data_nodes: if strutil.equals_ignore_case( each.data_source_name, data_source_name) and strutil.equals_ignore_case( each.table_name, table_name): return result result += 1 return -1
def _route(self, master_slave_rule, sql_route_result): to_be_removed = list() to_be_added = list() for each in sql_route_result.execution_units: if not strutil.equals_ignore_case(master_slave_rule.name, each.data_source): continue to_be_removed.append(each) if self._is_master_route(sql_route_result.sql_statement.sql_type): MasterVisitedManager.set_master_visited() to_be_added.append( SQLExecutionUnit(master_slave_rule.master_data_source_name, each.sql_unit)) else: to_be_removed.append( SQLExecutionUnit( master_slave_rule.load_balance_algorithm. get_data_source( master_slave_rule.name, master_slave_rule.master_data_source_name, master_slave_rule.slave_data_source_names), each.sql_unit)) sql_route_result.execution_units = [ i for i in sql_route_result.execution_units if i in to_be_removed ] sql_route_result.execution_units.extend(to_be_added)
def _is_contains_item(self, order_item, select_statement): if order_item.index != -1: return True if select_statement.get_star_select_items(): return self._is_contains_item_in_star_select_item( select_statement.get_star_select_items(), order_item, select_statement.tables) for each in select_statement.select_items: if each.alias and order_item.alias and strutil.equals_ignore_case( each.alias, order_item.alias): return True if not each.alias and order_item.get_qualified_name( ) and strutil.equals_ignore_case(each.expression, order_item.get_qualified_name()): return True return False
def _parse_set_column(self, update_statement): if self.lexer_engine.equal_any(Symbol.LEFT_PAREN): self.lexer_engine.skip_parentheses(update_statement) return begin_position = self.lexer_engine.get_current_token().end_position literals = self.lexer_engine.get_current_token().literals self.lexer_engine.next_token() if self.lexer_engine.skip_if_equal(Symbol.DOT): if strutil.equals_ignore_case(update_statement.tables.get_single_table_name(), sqlutil.get_exactly_value(literals)): update_statement.sql_tokens.append(TableToken(begin_position - len(literals), 0, literals)) self.lexer_engine.next_token()
def parse(self, insert_statement, sharding_meta_data): result = list() table_name = insert_statement.tables.get_single_table_name() generated_key_column = self.sharding_rule.get_generate_key_column(table_name) count = 0 if self.lexer_engine.equal_any(Symbol.LEFT_PAREN): while True: self.lexer_engine.next_token() column_name = sqlutil.get_exactly_value(self.lexer_engine.get_current_token().literals) result.append(Column(column_name, table_name)) self.lexer_engine.next_token() if generated_key_column and strutil.equals_ignore_case(generated_key_column.name, column_name): insert_statement.generate_key_column_index = count count += 1 if self.lexer_engine.equal_any(Symbol.RIGHT_PAREN) or self.lexer_engine.equal_any(Assist.END): break insert_statement.columns_list_last_position = self.lexer_engine.get_current_token().end_position - len( self.lexer_engine.get_current_token().literals) self.lexer_engine.next_token() else: column_names = sharding_meta_data.table_meta_data_map.get(table_name).get_all_column_names() begin_position = self.lexer_engine.get_current_token().end_position - len( self.lexer_engine.get_current_token().literals) - 1 insert_statement.sql_tokens.append(InsertColumnToken(begin_position, '(')) columns_token = ItemsToken(begin_position) columns_token.is_first_of_items_special = True for column_name in column_names: result.append(Column(column_name, table_name)) if generated_key_column and strutil.equals_ignore_case(generated_key_column.name, column_name): insert_statement.generate_key_column_index = count columns_token.items.append(column_name) count += 1 insert_statement.sql_tokens.append(columns_token) insert_statement.sql_tokens.append(InsertColumnToken(begin_position, ')')) insert_statement.columns_list_last_position = begin_position insert_statement.columns.extend(result)
def _is_contains_item_in_star_select_item(self, star_select_items, order_item, tables): for each in star_select_items: if not each.owner: return True table_optional_of_star_item = tables.find(each.owner) if order_item.owner and tables.find( order_item.owner) == table_optional_of_star_item: return True if not each.alias and order_item.get_qualified_name( ) and strutil.equals_ignore_case(each.expression, order_item.get_qualified_name()): return True return False
def is_sharding_column(self, column): if column.name in self.default_database_sharding_strategy.get_sharding_columns() or \ column.name in self.default_table_sharding_strategy.get_sharding_columns(): return True for table_rule in self.table_rules: if not strutil.equals_ignore_case(column.table_name, table_rule.logic_table): continue if table_rule.database_sharding_strategy and column.name in table_rule.database_sharding_strategy.get_sharding_columns( ): return True if table_rule.table_sharding_strategy and column.name in table_rule.table_sharding_strategy.get_sharding_columns( ): return True return False
def _index_equals(self, other): return self.get_column_label() and strutil.equals_ignore_case(self.get_column_label(), other.get_column_label())
def _qualified_name_equals(self, other): return self.get_qualified_name() and strutil.equals_ignore_case(self.get_qualified_name(), other.get_qualified_name())
def is_existed(self, actual_table_name): return any([ strutil.equals_ignore_case(actual_table_name, each.table_name) for each in self.actual_data_nodes ])
def __eq__(self, other): return other and isinstance(other, Column) and equals_ignore_case( self.name, other.name) and equals_ignore_case( self.table_name, other.table_name)
def get_generate_key_column(self, logic_table_name): for each in self.table_rules: if strutil.equals_ignore_case( logic_table_name, each.logic_table) and each.generate_key_column: return Column(each.generate_key_column, logic_table_name)
def get_logic_table_names(self, data_source_name): return { each.logic_table_name for each in self.routing_tables if strutil.equals_ignore_case( self.data_source_name, data_source_name) }
def _get_logic_table_names(self, data_source_name): return reduce(lambda a, b: a.union(b), [ e.get_logic_table_names(data_source_name) for e in self.table_units if strutil.equals_ignore_case(data_source_name, e.data_source_name) ])