Package org.apache.cassandra.db

Class VirtualTableSinglePartitionReadQuery

    • Method Detail

      • create

        public static VirtualTableSinglePartitionReadQuery create​(TableMetadata metadata,
                                                          int nowInSec,
                                                          ColumnFilter columnFilter,
                                                          RowFilter rowFilter,
                                                          DataLimits limits,
                                                          DecoratedKey partitionKey,
                                                          ClusteringIndexFilter clusteringIndexFilter)
        Description copied from interface: SinglePartitionReadQuery
        Creates a new read query on a single partition.
        Parameters:
        metadata - the table to query.
        nowInSec - the time in seconds to use are "now" for this query.
        columnFilter - the column filter to use for the query.
        rowFilter - the row filter to use for the query.
        limits - the limits to use for the query.
        partitionKey - the partition key for the partition to query.
        clusteringIndexFilter - the clustering index filter to use for the query.
        Returns:
        a newly created read query.

      • appendCQLWhereClause

        protected void appendCQLWhereClause​(java.lang.StringBuilder sb)

      • selectsFullPartition

        public boolean selectsFullPartition()
        Description copied from interface: ReadQuery
        Checks if this ReadQuery selects full partitions, that is it has no filtering on clustering or regular columns.
        Specified by:
        selectsFullPartition in interface ReadQuery
        Returns:
        true if this ReadQuery selects full partitions, false otherwise.

      • forPaging

        public SinglePartitionReadQuery forPaging​(Clustering<?> lastReturned,
                                          DataLimits limits)
        Description copied from interface: SinglePartitionReadQuery
        Returns a new SinglePartitionReadQuery suitable to paging from the last returned row.
        Specified by:
        forPaging in interface SinglePartitionReadQuery
        Parameters:
        lastReturned - the last row returned by the previous page. The newly created query will only query row that comes after this (in query order). This can be null if this is the first page.
        limits - the limits to use for the page to query.
        Returns:
        the newly create query.

      • metadata

        public TableMetadata metadata()
        Description copied from interface: ReadQuery
        The metadata for the table this is a query on.
        Specified by:
        metadata in interface ReadQuery
        Returns:
        the metadata for the table this is a query on.

      • name

        public java.lang.String name()
        Specified by:
        name in interface Monitorable

      • executeInternal

        public PartitionIterator executeInternal​(ReadExecutionController controller)
        Description copied from interface: ReadQuery
        Execute the query for internal queries (that is, it basically executes the query locally).
        Specified by:
        executeInternal in interface ReadQuery
        Parameters:
        controller - the ReadExecutionController protecting the read.
        Returns:
        the result of the query.

      • limits

        public DataLimits limits()
        Description copied from interface: ReadQuery
        The limits for the query.
        Specified by:
        limits in interface ReadQuery
        Returns:
        The limits for the query.

      • nowInSec

        public int nowInSec()
        Description copied from interface: ReadQuery
        The time in seconds to use as "now" for this query.

        We use the same time as "now" for the whole query to avoid considering different values as expired during the query, which would be buggy (would throw of counting amongst other things).

        Specified by:
        nowInSec in interface ReadQuery
        Returns:
        the time (in seconds) to use as "now".

      • rowFilter

        public RowFilter rowFilter()
        Description copied from interface: ReadQuery
        Filters/Resrictions on CQL rows.

        This contains the restrictions that are not directly handled by the ClusteringIndexFilter. More specifically, this includes any non-PK column restrictions and can include some PK columns restrictions when those can't be satisfied entirely by the clustering index filter (because not all clustering columns have been restricted for instance). If there is 2ndary indexes on the table, one of this restriction might be handled by a 2ndary index.

        Specified by:
        rowFilter in interface ReadQuery
        Returns:
        the filter holding the expression that rows must satisfy.

      • columnFilter

        public ColumnFilter columnFilter()
        Description copied from interface: ReadQuery
        A filter on which (non-PK) columns must be returned by the query.
        Specified by:
        columnFilter in interface ReadQuery
        Returns:
        which columns must be fetched by this query.

      • toCQLString

        public java.lang.String toCQLString()
        Recreate the CQL string corresponding to this query.

        Note that in general the returned string will not be exactly the original user string, first because there isn't always a single syntax for a given query, but also because we don't have all the information needed (we know the non-PK columns queried but not the PK ones as internally we query them all). So this shouldn't be relied too strongly, but this should be good enough for debugging purpose which is what this is for.