code: def _select_most_recent_symbols_chunk(self, sid_group):
          
          cols = self.equity_symbol_mappings.c
  
          # These are the columns we actually want.
          data_cols = (cols.sid,) + tuple(cols[name] for name in symbol_columns)
  
          # Also select the max of end_date so that all non-grouped fields take
          # on the value associated with the max end_date. The SQLite docs say
          # this:
          #
          # When the min() or max() aggregate functions are used in an aggregate
          # query, all bare columns in the result set take values from the input
          # row which also contains the minimum or maximum. Only the built-in
          # min() and max() functions work this way.
          #
          # See https://www.sqlite.org/lang_select.html#resultset, for more info.
          to_select = data_cols + (sa.func.max(cols.end_date),)
  
          return sa.select(
              to_select,
          ).where(
              cols.sid.in_(map(int, sid_group))
          ).group_by(
              cols.sid,
          )
docs: Retrieve the most recent symbol for a set of sids.
  
          Parameters
          ----------
          sid_group : iterable[int]
              The sids to lookup. The length of this sequence must be less than
              or equal to SQLITE_MAX_VARIABLE_NUMBER because the sids will be
              passed in as sql bind params.
  
          Returns
          -------
          sel : Selectable
              The sqlalchemy selectable that will query for the most recent
              symbol for each sid.
  
          Notes
          -----
          This is implemented as an inner select of the columns of interest
          ordered by the end date of the (sid, symbol) mapping. We then group
          that inner select on the sid with no aggregations to select the last
          row per group which gives us the most recently active symbol for all
          of the sids.