public void deleteDataPoint(DataPointsRowKey rowKey, int columnTime) throws IOException { BoundStatement boundStatement = new BoundStatement(m_clusterConnection.psDataPointsDelete); boundStatement.setBytesUnsafe(0, DATA_POINTS_ROW_KEY_SERIALIZER.toByteBuffer(rowKey)); ByteBuffer b = ByteBuffer.allocate(4); b.putInt(columnTime); b.rewind(); boundStatement.setBytesUnsafe(1, b); boundStatement.setConsistencyLevel(m_consistencyLevel); boundStatement.setIdempotent(true); addBoundStatement(boundStatement); }
public void addMetricName(String metricName) { m_newMetrics.add(metricName); BoundStatement bs = new BoundStatement(m_clusterConnection.psStringIndexInsert); bs.setBytesUnsafe(0, ByteBuffer.wrap(ROW_KEY_METRIC_NAMES.getBytes(UTF_8))); bs.setString(1, metricName); bs.setConsistencyLevel(m_consistencyLevel); metricNamesBatch.add(bs); }
public void addDataPoint(DataPointsRowKey rowKey, int columnTime, DataPoint dataPoint, int ttl) throws IOException { KDataOutput kDataOutput = new KDataOutput(); dataPoint.writeValueToBuffer(kDataOutput); BoundStatement boundStatement = new BoundStatement(m_clusterConnection.psDataPointsInsert); boundStatement.setBytesUnsafe(0, DATA_POINTS_ROW_KEY_SERIALIZER.toByteBuffer(rowKey)); ByteBuffer b = ByteBuffer.allocate(4); b.putInt(columnTime); b.rewind(); boundStatement.setBytesUnsafe(1, b); boundStatement.setBytesUnsafe(2, ByteBuffer.wrap(kDataOutput.getBytes())); boundStatement.setInt(3, ttl); boundStatement.setLong(4, m_now); boundStatement.setConsistencyLevel(m_consistencyLevel); boundStatement.setIdempotent(true); addBoundStatement(boundStatement); }
private void setStartEndKeys( BoundStatement boundStatement, String metricName, long startTime, long endTime) { DataPointsRowKey startKey = new DataPointsRowKey(metricName, m_clusterName, CassandraDatastore.calculateRowTime(startTime), ""); DataPointsRowKey endKey = new DataPointsRowKey(metricName, m_clusterName, CassandraDatastore.calculateRowTime(endTime), ""); endKey.setEndSearchKey(true); boundStatement.setBytesUnsafe(1, CassandraDatastore.DATA_POINTS_ROW_KEY_SERIALIZER.toByteBuffer(startKey)); boundStatement.setBytesUnsafe(2, CassandraDatastore.DATA_POINTS_ROW_KEY_SERIALIZER.toByteBuffer(endKey)); }
boundStatement.setBytesUnsafe(0, serializeString(key)); boundStatement.setBytesUnsafe(1, serializeString(prefix)); boundStatement.setBytesUnsafe(2, serializeEndString(prefix)); boundStatement.setConsistencyLevel(cluster.getReadConsistencyLevel()); return cluster.executeAsync(boundStatement);
private void deletePartialRow(DataPointsRowKey rowKey, long start, long end) throws DatastoreException { queryClusters((cluster) -> { if (cluster.psDataPointsDeleteRange != null) { BoundStatement statement = new BoundStatement(cluster.psDataPointsDeleteRange); statement.setBytesUnsafe(0, DATA_POINTS_ROW_KEY_SERIALIZER.toByteBuffer(rowKey)); ByteBuffer b = ByteBuffer.allocate(4); b.putInt(getColumnName(rowKey.getTimestamp(), start)); b.rewind(); statement.setBytesUnsafe(1, b); b = ByteBuffer.allocate(4); b.putInt(getColumnName(rowKey.getTimestamp(), end)); b.rewind(); statement.setBytesUnsafe(2, b); statement.setConsistencyLevel(cluster.getReadConsistencyLevel()); cluster.executeAsync(statement); } else { //note, with multiple old clusters this query could be done multiple times DatastoreMetricQuery deleteQuery = new QueryMetric(start, end, 0, rowKey.getMetricName()); cqlQueryWithRowKeys(deleteQuery, new DeletingCallback(deleteQuery.getName()), Collections.singletonList(rowKey).iterator()); } return null; }); }
private Iterable<String> queryStringIndex(final String key) throws DatastoreException { List<ResultSetFuture> futures = queryClusters((cluster) -> { BoundStatement boundStatement = new BoundStatement(cluster.psStringIndexQuery); boundStatement.setBytesUnsafe(0, serializeString(key)); boundStatement.setConsistencyLevel(cluster.getReadConsistencyLevel()); return cluster.executeAsync(boundStatement); }); ListenableFuture<List<ResultSet>> listListenableFuture = Futures.allAsList(futures); Set<String> ret = new HashSet<String>(); try { Iterator<ResultSet> iterator = listListenableFuture.get().iterator(); while (iterator.hasNext()) { ResultSet resultSet = iterator.next(); while (!resultSet.isExhausted()) { Row row = resultSet.one(); ret.add(row.getString(0)); } } } catch (Exception e) { throw new DatastoreException("CQL Query failure", e); } return ret; }
negStatement.setBytesUnsafe(0, CassandraDatastore.serializeString(metricName)); setStartEndKeys(negStatement, metricName, startTime, -1L); negStatement.setConsistencyLevel(cluster.getReadConsistencyLevel()); posStatement.setBytesUnsafe(0, CassandraDatastore.serializeString(metricName)); setStartEndKeys(posStatement, metricName, 0L, endTime); posStatement.setConsistencyLevel(cluster.getReadConsistencyLevel()); statement.setBytesUnsafe(0, CassandraDatastore.serializeString(metricName)); setStartEndKeys(statement, metricName, startTime, endTime); statement.setConsistencyLevel(cluster.getReadConsistencyLevel());
boundStatement.setBytesUnsafe(0, DATA_POINTS_ROW_KEY_SERIALIZER.toByteBuffer(rowKey)); boundStatement.setBytesUnsafe(1, startBuffer); boundStatement.setBytesUnsafe(2, endBuffer);
statement.setBytesUnsafe(0, DATA_POINTS_ROW_KEY_SERIALIZER.toByteBuffer(rowKey)); statement.setConsistencyLevel(cluster.getReadConsistencyLevel()); cluster.execute(statement); statement.setBytesUnsafe(0, serializeString(rowKey.getMetricName())); statement.setBytesUnsafe(1, DATA_POINTS_ROW_KEY_SERIALIZER.toByteBuffer(rowKey)); statement.setConsistencyLevel(cluster.getReadConsistencyLevel()); cluster.execute(statement); statement.setBytesUnsafe(0, serializeString(deleteQuery.getName())); statement.setConsistencyLevel(cluster.getReadConsistencyLevel()); cluster.executeAsync(statement); statement.setBytesUnsafe(0, serializeString(ROW_KEY_METRIC_NAMES)); statement.setBytesUnsafe(1, serializeString(deleteQuery.getName())); statement.setConsistencyLevel(cluster.getReadConsistencyLevel()); cluster.executeAsync(statement);
@Override public QueryBinder<ENTITY> setBytesUnsafe(int i, ByteBuffer v) { for (BoundStatement statement : statements.values()) { statement.setBytesUnsafe(i, v); } return this; }
/** * Returns a {@link BoundStatement} to insert the given key/value pair. * @param key The key. * @param value The value. * @return A BoundStatement to insert the given key/value pair. */ private BoundStatement getInsertStatement(final K key, final V value) { BoundStatement insertStatement = _insertStatement.bind(); insertStatement.setBytesUnsafe(0, _keySerializer.serialize(key)); insertStatement.setBytesUnsafe(1, _valueSerializer.serialize(value)); return insertStatement; }
@Override public void set(final K key, final V value) { BoundStatement insertStatement = _insertStatement.bind(); insertStatement.setBytesUnsafe(0, _keySerializer.serialize(key)); insertStatement.setLong(1, getValueHash(value)); insertStatement.setBytesUnsafe(2, _valueSerializer.serialize(value)); _session.execute(insertStatement); }
@Override public QueryBinder<ENTITY> setBytesUnsafe(String name, ByteBuffer v) { for (BoundStatement statement : statements.values()) { if (statement.preparedStatement().getVariables().contains(name)) { statement.setBytesUnsafe(name, v); } } return this; }
@Override public boolean contains(final K key) { BoundStatement getValueStatement = _getValueStatement.bind(); getValueStatement.setBytesUnsafe(0, _keySerializer.serialize(key)); return _session.execute(getValueStatement).getAvailableWithoutFetching() > 0; }
@Override public boolean contains(final K key) { BoundStatement getValueStatement = _getValueStatement.bind(); getValueStatement.setBytesUnsafe(0, _keySerializer.serialize(key)); return _session.execute(getValueStatement).getAvailableWithoutFetching() > 0; }
@SuppressWarnings("unchecked") @Override public void delete(final K... keys) { BatchStatement batchStatement = new BatchStatement(); for (K key : keys) { BoundStatement deleteStatement = _deleteStatement.bind(); deleteStatement.setBytesUnsafe(0, _keySerializer.serialize(key)); batchStatement.add(deleteStatement); } _session.execute(batchStatement); }
@Override public V get(final K key) { BoundStatement getValueStatement = _getValueStatement.bind(); getValueStatement.setBytesUnsafe(0, _keySerializer.serialize(key)); ByteBuffer result = _session.execute(getValueStatement).one().getBytesUnsafe(0); if (result != null) { return _valueSerializer.deserialize(result); } else { return null; } }
@Override protected ResultSetFuture newFuture() { return factory.session.executeAsync( factory .preparedStatement .bind() .setLong("trace_id", input.trace_id()) .setBytesUnsafe("ts", factory.timestampCodec.serialize(input.ts())) .setString("span_name", input.span_name()) .setBytes("span", ByteBuffer.wrap(input.span()))); }
@Override protected ResultSetFuture newFuture() { BoundStatement bound = prepared .bind() .setLong("trace_id", input.trace_id()) .setBytesUnsafe("ts", timestampCodec.serialize(input.ts())); index.bindPartitionKey(bound, input.partitionKey()); return session.executeAsync(bound); }