Java SliceQuery.setKey方法代码示例

import me.prettyprint.hector.api.query.SliceQuery; //导入方法依赖的package包/类
public List<CiChangeStateEvent> getCiStateHistory(long ciId, Long startTime, Long endTime, Integer count) {

        if (count == null) count = 1000;
        List<CiChangeStateEvent> states = new ArrayList<CiChangeStateEvent>();
        SliceQuery<Long, Long, String> sliceQuery = HFactory.createSliceQuery(keyspace, longSerializer, longSerializer, stringSerializer);
        sliceQuery.setColumnFamily(SchemaBuilder.CI_STATE_HIST_CF);
        sliceQuery.setRange(startTime, endTime, false, count);
        sliceQuery.setKey(ciId);
        QueryResult<ColumnSlice<Long, String>> result = sliceQuery.execute();
        ColumnSlice<Long, String> resultCols = result.get();
        for (HColumn<Long, String> col : resultCols.getColumns()) {
            CiChangeStateEvent event = gson.fromJson(col.getValue(), CiChangeStateEvent.class);
            states.add(event);
        }
        return states;
    }
 

import me.prettyprint.hector.api.query.SliceQuery; //导入方法依赖的package包/类
private Iterable<String> queryStringIndex(final String key) {
	SliceQuery<String, String, String> sliceQuery =
			HFactory.createSliceQuery(m_keyspace, StringSerializer.get(), StringSerializer.get(),
					StringSerializer.get());

	sliceQuery.setColumnFamily(CF_STRING_INDEX);
	sliceQuery.setKey(key);

	ColumnSliceIterator<String, String, String> columnIterator =
			new ColumnSliceIterator<String, String, String>(sliceQuery, "", (String) null, false, m_singleRowReadSize);

	List<String> ret = new ArrayList<String>();

	while (columnIterator.hasNext()) {
		ret.add(columnIterator.next().getName());
	}

	return ret;
}
 

import me.prettyprint.hector.api.query.SliceQuery; //导入方法依赖的package包/类
@Override
public Message getMessage( UUID messageId ) {
    SliceQuery<UUID, String, ByteBuffer> q =
            createSliceQuery( cass.getApplicationKeyspace( applicationId ), ue, se, be );
    q.setColumnFamily( MESSAGE_PROPERTIES.getColumnFamily() );
    q.setKey( messageId );
    q.setRange( null, null, false, ALL_COUNT );
    QueryResult<ColumnSlice<String, ByteBuffer>> r = q.execute();
    ColumnSlice<String, ByteBuffer> slice = r.get();
    List<HColumn<String, ByteBuffer>> results = slice.getColumns();
    return deserializeMessage( results );
}
 

import me.prettyprint.hector.api.query.SliceQuery; //导入方法依赖的package包/类
@Override
public Set<String> getQueueCounterNames( String queuePath ) throws Exception {
    Set<String> names = new HashSet<String>();
    Keyspace ko = cass.getApplicationKeyspace( applicationId );
    SliceQuery<String, String, ByteBuffer> q = createSliceQuery( ko, se, se, be );
    q.setColumnFamily( QueuesCF.QUEUE_DICTIONARIES.toString() );
    q.setKey( CassandraPersistenceUtils.key( getQueueId( queuePath ), DICTIONARY_COUNTERS ).toString() );
    q.setRange( null, null, false, ALL_COUNT );

    List<HColumn<String, ByteBuffer>> columns = q.execute().get().getColumns();
    for ( HColumn<String, ByteBuffer> column : columns ) {
        names.add( column.getName() );
    }
    return names;
}
 

import me.prettyprint.hector.api.query.SliceQuery; //导入方法依赖的package包/类
public Queue getQueue( String queuePath, UUID queueId ) {
    SliceQuery<UUID, String, ByteBuffer> q =
            createSliceQuery( cass.getApplicationKeyspace( applicationId ), ue, se, be );
    q.setColumnFamily( QUEUE_PROPERTIES.getColumnFamily() );
    q.setKey( queueId );
    q.setRange( null, null, false, ALL_COUNT );
    QueryResult<ColumnSlice<String, ByteBuffer>> r = q.execute();
    ColumnSlice<String, ByteBuffer> slice = r.get();
    List<HColumn<String, ByteBuffer>> results = slice.getColumns();
    return deserializeQueue( results );
}
 

import me.prettyprint.hector.api.query.SliceQuery; //导入方法依赖的package包/类
/**
 * Get all pending transactions that have timed out
 *
 * @param queueId The queue id
 * @param consumerId The consumer id
 * @param params The server params
 * @param startTimeUUID The start time
 */
protected List<TransactionPointer> getConsumerIds( UUID queueId, UUID consumerId, SearchParam params,
                                                   UUID startTimeUUID )
{

    SliceQuery<ByteBuffer, UUID, UUID> q = createSliceQuery( ko, be, ue, ue );
    q.setColumnFamily( CONSUMER_QUEUE_TIMEOUTS.getColumnFamily() );
    q.setKey( getQueueClientTransactionKey( queueId, consumerId ) );
    q.setRange( params.startId, startTimeUUID, false, params.limit + 1 );

    List<HColumn<UUID, UUID>> cassResults = swallowOrderedExecution(q);

    List<TransactionPointer> results = new ArrayList<TransactionPointer>( params.limit );

    for ( HColumn<UUID, UUID> column : cassResults )
    {

        if ( logger.isTraceEnabled() )
        {
            logger.trace( "Adding uuid '{}' for original message '{}' to results for queue '{}' and consumer '{}'",
                    column.getName(), column.getValue(), queueId, consumerId );
            logger.trace( "Max timeuuid : '{}', Current timeuuid : '{}', comparison '{}'",
                    startTimeUUID, column.getName(), UUIDUtils.compare( startTimeUUID, column.getName() )
            );
        }

        results.add( new TransactionPointer( column.getName(), column.getValue() ) );
    }

    return results;
}
 

import me.prettyprint.hector.api.query.SliceQuery; //导入方法依赖的package包/类
public boolean hasOutstandingTransactions( UUID queueId, UUID consumerId )
{
    SliceQuery<ByteBuffer, UUID, UUID> q = createSliceQuery( ko, be, ue, ue );
    q.setColumnFamily( CONSUMER_QUEUE_TIMEOUTS.getColumnFamily() );
    q.setKey( getQueueClientTransactionKey( queueId, consumerId ) );
    q.setRange( null, null, false, 1 );
    return q.execute().get().getColumns().size() > 0;
}
 

import me.prettyprint.hector.api.query.SliceQuery; //导入方法依赖的package包/类
/**
 * Gets the columns.
 *
 * @param ko the keyspace
 * @param columnFamily the column family
 * @param key the key
 *
 * @return columns
 *
 * @throws Exception the exception
 */
public <N, V> List<HColumn<N, V>> getAllColumns( Keyspace ko, Object columnFamily, Object key,
                                                 Serializer<N> nameSerializer, Serializer<V> valueSerializer )
        throws Exception {

    if ( db_logger.isTraceEnabled() ) {
        db_logger.trace( "getColumns cf={} key={}", columnFamily, key );
    }

    SliceQuery<ByteBuffer, N, V> q = createSliceQuery( ko, be, nameSerializer, valueSerializer );
    q.setColumnFamily( columnFamily.toString() );
    q.setKey( bytebuffer( key ) );
    q.setRange( null, null, false, ALL_COUNT );
    QueryResult<ColumnSlice<N, V>> r = q.execute();
    ColumnSlice<N, V> slice = r.get();
    List<HColumn<N, V>> results = slice.getColumns();

    if ( db_logger.isTraceEnabled() ) {
        if ( results == null ) {
            db_logger.trace( "getColumns returned null" );
        }
        else {
            db_logger.trace( "getColumns returned {} columns", results.size() );
        }
    }

    return results;
}
 

import me.prettyprint.hector.api.query.SliceQuery; //导入方法依赖的package包/类
/**
 * Gets the columns.
 *
 * @param ko the keyspace
 * @param columnFamily the column family
 * @param key the key
 * @param columnNames the column names
 *
 * @return columns
 *
 * @throws Exception the exception
 */
@SuppressWarnings("unchecked")
public <N, V> List<HColumn<N, V>> getColumns( Keyspace ko, Object columnFamily, Object key, Set<String> columnNames,
                                              Serializer<N> nameSerializer, Serializer<V> valueSerializer )
        throws Exception {

    if ( db_logger.isTraceEnabled() ) {
        db_logger.trace( "getColumns cf={} key={} names={}", columnFamily, key, columnNames );
    }

    SliceQuery<ByteBuffer, N, V> q = createSliceQuery( ko, be, nameSerializer, valueSerializer );
    q.setColumnFamily( columnFamily.toString() );
    q.setKey( bytebuffer( key ) );
    // q.setColumnNames(columnNames.toArray(new String[0]));
    q.setColumnNames( ( N[] ) nameSerializer.fromBytesSet( se.toBytesSet( new ArrayList<String>( columnNames ) ) )
                                            .toArray() );

    QueryResult<ColumnSlice<N, V>> r = q.execute();
    ColumnSlice<N, V> slice = r.get();
    List<HColumn<N, V>> results = slice.getColumns();

    if ( db_logger.isTraceEnabled() ) {
        if ( results == null ) {
            db_logger.trace( "getColumns returned null" );
        }
        else {
            db_logger.trace( "getColumns returned {} columns", results.size());
        }
    }

    return results;
}
 

import me.prettyprint.hector.api.query.SliceQuery; //导入方法依赖的package包/类
/**
 * Renew the existing transaction. Does so by deleting the exiting timeout, and replacing it with a new value
 *
 * @param queuePath The queue path
 * @param transactionId The transaction id
 * @param query The query params
 *
 * @return The new transaction uuid
 */
public UUID renewTransaction( String queuePath, UUID transactionId, QueueQuery query )
        throws TransactionNotFoundException
{
    long now = System.currentTimeMillis();

    if ( query == null )
    {
        query = new QueueQuery();
    }

    UUID queueId = getQueueId( queuePath );
    UUID consumerId = getConsumerId( queueId, query );
    ByteBuffer key = getQueueClientTransactionKey( queueId, consumerId );

    // read the original transaction, if it's not there, then we can't possibly
    // extend it
    SliceQuery<ByteBuffer, UUID, UUID> q = createSliceQuery( ko, be, ue, ue );
    q.setColumnFamily( CONSUMER_QUEUE_TIMEOUTS.getColumnFamily() );
    q.setKey( key );
    q.setColumnNames( transactionId );

    HColumn<UUID, UUID> col = q.execute().get().getColumnByName( transactionId );

    if ( col == null )
    {
        throw new TransactionNotFoundException(
                String.format( "No transaction with id %s exists", transactionId ) );
    }

    UUID origTrans = col.getName();
    UUID messageId = col.getValue();

    // Generate a new expiration and insert it
    UUID expirationId = UUIDUtils.newTimeUUID( now + query.getTimeout() );

    if (logger.isTraceEnabled()) {
        logger.trace("Writing new timeout at '{}' for message '{}'", expirationId, messageId);
    }


    Mutator<ByteBuffer> mutator = CountingMutator.createFlushingMutator( ko, be );

    mutator.addInsertion( key, CONSUMER_QUEUE_TIMEOUTS.getColumnFamily(),
            createColumn( expirationId, messageId, cass.createTimestamp(), ue, ue ) );

    mutator.execute();

    // now delete the old value
    deleteTransaction( queueId, consumerId, origTrans );

    return expirationId;
}