def apply_outer_select_joins( self, query: BaseQuery, select_columns: List[str] = None ) -> BaseQuery: if not select_columns: return query for column in select_columns: if is_column_dotted(column): root_relation = get_column_root_relation(column) leaf_column = get_column_leaf(column) if self.is_relation_many_to_many( root_relation ) or self.is_relation_one_to_many(root_relation): query = query.options( Load(self.obj).joinedload(root_relation).load_only(leaf_column) ) else: related_model = self.get_related_model(root_relation) query = query.options(Load(related_model).load_only(leaf_column)) else: query = self._apply_normal_col_select_option(query, column) return query
def _add_prefetch(self, query: BaseQuery) -> BaseQuery: if self.prefetch: # apply joinedloaded rels for rels in self.prefetch: if is_listy(rels): # list/tuple, construct chain of joinedloads if len(rels) > 1: opts = reduce( lambda o, r: o.joinedload(r), rels[1:], joinedload(rels[0]) ) else: opts = joinedload(rels[0]) else: # just a single relationship (not chained) opts = joinedload(rels) query = query.options(opts) return query
def apply_inner_select_joins( self, query: BaseQuery, select_columns: List[str] = None) -> BaseQuery: """ Add select load options to query. The goal is to only SQL select what is requested and join all the necessary models when dotted notation is used. Inner implies non dotted columns and one to many and one to one :param query: :param select_columns: :return: """ if not select_columns: return query joined_models = list() for column in select_columns: if is_column_dotted(column): root_relation = get_column_root_relation(column) leaf_column = get_column_leaf(column) if self.is_relation_many_to_one( root_relation) or self.is_relation_one_to_one( root_relation): if root_relation not in joined_models: query = self._query_join_relation(query, root_relation) # only needed if we need to wrap this query, from_self if select_columns and self.exists_col_to_many( select_columns): related_model = self.get_related_model( root_relation) query = query.add_entity(related_model) joined_models.append(root_relation) query = query.options( (contains_eager(root_relation).load_only(leaf_column))) else: query = self._apply_normal_col_select_option(query, column) return query
def _query_select_options(self, query: BaseQuery, select_columns: List[str] = None) -> BaseQuery: """ Add select load options to query. The goal is to only SQL select what is requested and join all the necessary models when dotted notation is used :param query: SQLAlchemy Query obj to apply joins and selects :param select_columns: (list) of columns :return: Transformed SQLAlchemy Query """ if select_columns: load_options = list() joined_models = list() for column in select_columns: if is_column_dotted(column): root_relation = get_column_root_relation(column) leaf_column = get_column_leaf(column) if self.is_relation_many_to_many( root_relation) or self.is_relation_one_to_many( root_relation): load_options.append((Load(self.obj).joinedload( root_relation).load_only(leaf_column))) continue elif root_relation not in joined_models: query = self._query_join_relation(query, root_relation) joined_models.append(root_relation) load_options.append( (contains_eager(root_relation).load_only(leaf_column))) else: if not self.is_relation( column) and not self.is_property_or_function( column): load_options.append(load_only(column)) query = query.options(*tuple(load_options)) return query
def _query_select_options(self, query: BaseQuery, select_columns: List[str] = None) -> BaseQuery: """ Add select load options to query. The goal is to only SQL select what is requested and join all the necessary models when dotted notation is used :param query: SQLAlchemy Query obj to apply joins and selects :param select_columns: (list) of columns :return: Transformed SQLAlchemy Query """ if select_columns: load_options = list() joined_models = list() for column in select_columns: if is_column_dotted(column): root_relation = get_column_root_relation(column) leaf_column = get_column_leaf(column) if root_relation not in joined_models: query = self._query_join_relation(query, root_relation) joined_models.append(root_relation) load_options.append((Load(self.obj).joinedload( root_relation).load_only(leaf_column))) else: # is a custom property method field? if hasattr(getattr(self.obj, column), "fget"): pass # is not a relation and not a function? elif not self.is_relation(column) and not hasattr( getattr(self.obj, column), "__call__"): load_options.append(Load(self.obj).load_only(column)) # it's a normal column else: load_options.append(Load(self.obj)) query = query.options(*tuple(load_options)) return query