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