def _configure_pks(self): self.tables = sql_util.find_tables(self.mapped_table) self._pks_by_table = {} self._cols_by_table = {} all_cols = sqlalchemy_util.column_set(chain(*[col.proxy_set for col in self._columntoproperty])) pk_cols = sqlalchemy_util.column_set(c for c in all_cols if c.primary_key) # identify primary key columns which are also mapped by this mapper. tables = set(self.tables + [self.mapped_table]) self._all_tables.update(tables) self._cols_by_table[self.mapped_table] = all_cols primary_key = [c for c in all_cols if c.name in self._primary_key_argument] self._pks_by_table[self.mapped_table] = primary_key self.primary_key = tuple(primary_key) self._log("Identified primary key columns: %s", primary_key) # determine cols that aren't expressed within our tables; mark these # as "read only" properties which are refreshed upon INSERT/UPDATE self._readonly_props = set( self._columntoproperty[col] for col in self._columntoproperty if self._columntoproperty[col] not in self._identity_key_props and (not hasattr(col, "table") or col.table not in self._cols_by_table) )
def _configure_pks(self): self.tables = sql_util.find_tables(self.mapped_table) self._pks_by_table = {} self._cols_by_table = {} all_cols = util.column_set(chain(*[ col.proxy_set for col in self._columntoproperty])) pk_cols = util.column_set(c for c in all_cols if c.primary_key) # identify primary key columns which are also mapped by this mapper. tables = set(self.tables + [self.mapped_table]) self._all_tables.update(tables) self._cols_by_table[self.mapped_table] = all_cols primary_key = [c for c in all_cols if c.name in self._primary_key_argument] self._pks_by_table[self.mapped_table] = primary_key self.primary_key = tuple(primary_key) self._log("Identified primary key columns: %s", primary_key) # determine cols that aren't expressed within our tables; mark these # as "read only" properties which are refreshed upon INSERT/UPDATE self._readonly_props = set( self._columntoproperty[col] for col in self._columntoproperty if self._columntoproperty[col] not in self._identity_key_props and (not hasattr(col, 'table') or col.table not in self._cols_by_table))
def get_dbname(self, mapper, clause): if mapper is not None: info = getattr(mapper.mapped_table, 'info', {}) bind_key = info.get('bind_key') if bind_key: return bind_key if clause is not None: from sqlalchemy.sql import util is_match = False for t in util.find_tables(clause, include_crud=True): # print t,'------------',self.table_dbname_map if t in self.table_binds: is_match = True dn = self.table_binds[t] break if is_match: return dn if dn is not None else "hrms" if read_or_write.__dict__.has_key( 'db_name') and read_or_write.__dict__['db_name'] is not None: db_name = read_or_write.__dict__['db_name'] print '---------------@read(' + str( db_name ) + ') has deprecated,you can easy use @read()----------' if db_name: return db_name return "hrms"
def test_column_element_no_visit(self): class MyElement(ColumnElement): pass eq_( sql_util.find_tables(MyElement(), check_columns=True), [] )
def get_bind(self, mapper=None, clause=None): # todo by terry # 优化流程 if mapper is clause is None: if self.bind: return self.bind else: raise UnboundExecutionError( "This session is not bound to a single Engine or " "Connection, and no context was provided to locate " "a binding.") c_mapper = mapper is not None and getattr(orm_base, '_class_to_mapper')(mapper) or None # manually bound? if self.__binds: if c_mapper: _name = repr(c_mapper.mapped_table) _name_list = _name.split(':') if len(_name_list) > 1: _tag = c_mapper.class_.__get_version__() for t in self.__tags: if contain_version(_tag, t): _name = ':'.join([_name_list[0], t]) break if _name in self.__metadata__: return self.__metadata__[_name] if repr(c_mapper.mapped_table) in self.__binds: return self.__binds[repr(c_mapper.mapped_table)] # 非ORM不支持版本控制 if clause is not None: for t in sql_util.find_tables(clause, include_crud=True): if repr(t) in self.__binds: return self.__binds[repr(t)] elif str(t) in self.__binds: return self.__binds[str(t)] if self.bind: return self.bind if isinstance(clause, ClauseElement) and clause.bind: return clause.bind if c_mapper and c_mapper.mapped_table.bind: return c_mapper.mapped_table.bind context = [] if mapper is not None: context.append('mapper %s' % c_mapper) if clause is not None: context.append('SQL expression') raise UnboundExecutionError( "Could not locate a bind configured on %s or this Session" % ( ', '.join(context)))
def test_find_tables_selectable(self): metadata = MetaData() common = Table( "common", metadata, Column("id", Integer, primary_key=True), Column("data", Integer), Column("extra", String(45)), ) subset_select = select([common.c.id, common.c.data]).alias() eq_(set(sql_util.find_tables(subset_select)), {common})
def test_find_tables_aliases(self): metadata = MetaData() common = Table( "common", metadata, Column("id", Integer, primary_key=True), Column("data", Integer), Column("extra", String(45)), ) calias = common.alias() subset_select = select([common.c.id, calias.c.data]).subquery() eq_( set(sql_util.find_tables(subset_select, include_aliases=True)), {common, calias, subset_select}, )
def test_column_element_no_visit(self): class MyElement(ColumnElement): _traverse_internals = [] eq_(sql_util.find_tables(MyElement(), check_columns=True), [])
def find_selectable_dependencies(selectable: Selectable) -> List[Table]: """Find the tables used in a select query.""" return (table for table in set(find_tables(selectable)))