def _add_group_by_item(self, sql_expr, select_statement): self.lexer_engine.unsupported_if_equal(*self.get_unsupported_keyword_before_group_by_item()) order_by_type = OrderDirection.ASC if self.lexer_engine.equal_any(DefaultKeyword.ASC): self.lexer_engine.next_token() elif self.lexer_engine.skip_if_equal(DefaultKeyword.DESC): order_by_type = OrderDirection.DESC if isinstance(sql_expr, SQLPropertyExpression): order_item = OrderItem(sqlutil.get_exactly_value(sql_expr.owner.name), sqlutil.get_exactly_value(sql_expr.name), order_by_type, OrderDirection.ASC, select_statement.get_alias( sqlutil.get_exactly_value(sql_expr.owner.name) + '.' + sqlutil.get_exactly_value( sql_expr.name))) elif isinstance(sql_expr, SQLIdentifierExpression): order_item = OrderItem(None, sqlutil.get_exactly_value(sql_expr.name), order_by_type, OrderDirection.ASC, select_statement.get_alias(sqlutil.get_exactly_value(sql_expr.name))) elif isinstance(sql_expr, SQLIgnoreExpression): order_item = OrderItem(None, sql_expr.expression, order_by_type, OrderDirection.ASC, select_statement.get_alias(sql_expr.expression)) else: return select_statement.group_by_items.append(order_item)
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 _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_common_or_star_select_item(self, select_statement): result = "" literals = self.lexer_engine.get_current_token().literals position = self.lexer_engine.get_current_token().end_position - len(literals) result += literals self.lexer_engine.next_token() if self.lexer_engine.equal_any(Symbol.LEFT_PAREN): result += self.lexer_engine.skip_parentheses(select_statement) elif self.lexer_engine.equal_any(Symbol.DOT): table_name = sqlutil.get_exactly_value(literals) if self.sharding_rule.try_find_table_rule_by_logic_table( table_name) or self.sharding_rule.find_binding_table_rule(table_name): select_statement.sql_tokens.append(TableToken(position, 0, literals)) result += self.lexer_engine.get_current_token().literals self.lexer_engine.next_token() if self.lexer_engine.equal_any(Symbol.STAR): return self._parse_star_select_item() result += self.lexer_engine.get_current_token().literals self.lexer_engine.next_token() return CommonSelectItem(sqlutil.get_exactly_value(result) + self._parse_rest_select_item(select_statement), self.alias_expression_parser.parse_select_item_alias())
def _parse_select_order_by_item(self, select_statement): sql_expr = self.basic_expression_parser.parse(select_statement) order_by_type = OrderDirection.ASC if self.lexer_engine.skip_if_equal(DefaultKeyword.ASC): order_by_type = OrderDirection.ASC elif self.lexer_engine.skip_if_equal(DefaultKeyword.DESC): order_by_type = OrderDirection.DESC if isinstance(sql_expr, SQLNumberExpression): return OrderItem(None, None, order_by_type, OrderDirection.ASC, None, sql_expr.number) if isinstance(sql_expr, SQLIdentifierExpression): return OrderItem(None, sqlutil.get_exactly_value(sql_expr.name), order_by_type, OrderDirection.ASC, select_statement.get_alias(sqlutil.get_exactly_value(sql_expr.name))) if isinstance(sql_expr, SQLPropertyExpression): return OrderItem(sqlutil.get_exactly_value(sql_expr.owner.name), sqlutil.get_exactly_value(sql_expr.name), order_by_type, OrderDirection.ASC, select_statement.get_alias( sqlutil.get_exactly_value(sql_expr.owner.name) + '.' + sqlutil.get_exactly_value( sql_expr.name))) if isinstance(sql_expr, SQLIgnoreExpression): return OrderItem(None, sqlutil.get_exactly_value(sql_expr.expression), order_by_type, OrderDirection.ASC, select_statement.get_alias(sql_expr.expression)) raise SQLParsingException(self.lexer_engine)
def _get_expression(self, literals, sql_statement): if self.lexer_engine.equal_any(Symbol.QUESTION): sql_statement.increase_parameters_index() return SQLPlaceholderExpression(sql_statement.parameters_index - 1) if self.lexer_engine.equal_any(Literals.CHARS): return SQLTextExpression(literals) if self.lexer_engine.equal_any(Literals.INT): return SQLNumberExpression(int(literals)) if self.lexer_engine.equal_any(Literals.FLOAT): return SQLNumberExpression(float(literals)) if self.lexer_engine.equal_any(Literals.HEX): return SQLNumberExpression(int(literals, 16)) if self.lexer_engine.equal_any(Literals.IDENTIFIER): return SQLIdentifierExpression(sqlutil.get_exactly_value(literals)) return SQLIgnoreExpression(literals)
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 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 _parse_alias(self): result = sqlutil.get_exactly_value( self.lexer_engine.get_current_token().literals) self.lexer_engine.next_token() return result
def index_name(self): return sqlutil.get_exactly_value(self.original_literals)
def table_name(self): return sqlutil.get_exactly_value(self._table_name)
def _set_table_token(self, sql_statement, begin_position, property_expr): owner = property_expr.owner.name if sqlutil.get_exactly_value( owner) in sql_statement.tables.get_table_names(): sql_statement.sql_tokens.append( TableToken(begin_position - len(owner), 0, owner))
def expression(self): return sqlutil.get_exactly_value(self.aggregation_type.name + self.inner_expression)
def _get_column_with_owner(self, tables, property_expression): table = tables.find(sqlutil.get_exactly_value(property_expression.owner.name)) if table: return Column(sqlutil.get_exactly_value(property_expression.name), table.name)
def _get_column_without_owner(self, tables, identifier_expression): if tables.is_single_table(): return Column(sqlutil.get_exactly_value(identifier_expression.name), tables.get_single_table_name())
def _is_star_select_item(self): return sqlutil.get_exactly_value(self.lexer_engine.get_current_token().literals) == Symbol.STAR.value
def original_literals(self): return sqlutil.get_exactly_value(self._original_literals)