code: def read(self, table, columns, keyset, index="", limit=0, partition=None):
          
          if self._read_request_count > 0:
              if not self._multi_use:
                  raise ValueError("Cannot re-use single-use snapshot.")
              if self._transaction_id is None:
                  raise ValueError("Transaction ID pending.")
  
          database = self._session._database
          api = database.spanner_api
          metadata = _metadata_with_prefix(database.name)
          transaction = self._make_txn_selector()
  
          restart = functools.partial(
              api.streaming_read,
              self._session.name,
              table,
              columns,
              keyset._to_pb(),
              transaction=transaction,
              index=index,
              limit=limit,
              partition_token=partition,
              metadata=metadata,
          )
  
          iterator = _restart_on_unavailable(restart)
  
          self._read_request_count += 1
  
          if self._multi_use:
              return StreamedResultSet(iterator, source=self)
          else:
              return StreamedResultSet(iterator)
docs: Perform a ``StreamingRead`` API request for rows in a table.
  
          :type table: str
          :param table: name of the table from which to fetch data
  
          :type columns: list of str
          :param columns: names of columns to be retrieved
  
          :type keyset: :class:`~google.cloud.spanner_v1.keyset.KeySet`
          :param keyset: keys / ranges identifying rows to be retrieved
  
          :type index: str
          :param index: (Optional) name of index to use, rather than the
                        table's primary key
  
          :type limit: int
          :param limit: (Optional) maximum number of rows to return.
                        Incompatible with ``partition``.
  
          :type partition: bytes
          :param partition: (Optional) one of the partition tokens returned
                            from :meth:`partition_read`.  Incompatible with
                            ``limit``.
  
          :rtype: :class:`~google.cloud.spanner_v1.streamed.StreamedResultSet`
          :returns: a result set instance which can be used to consume rows.
  
          :raises ValueError:
              for reuse of single-use snapshots, or if a transaction ID is
              already pending for multiple-use snapshots.