Example #1
0
  /**
   * Add a new Column <long,byte[]> to a given row in a given column family
   *
   * @param columnFamily column family name
   * @param row row name
   * @param key long key value
   * @param value value as a byte array
   * @param keyspace CassandraKeySpace
   * @throws CassandraDataAccessException
   */
  public static void addLongByteArrayColumnToRow(
      String columnFamily, String row, long key, byte[] value, Keyspace keyspace)
      throws CassandraDataAccessException {
    if (keyspace == null) {
      throw new CassandraDataAccessException("Can't add Data , no keySpace provided ");
    }

    if (columnFamily == null || row == null || value == null) {
      throw new CassandraDataAccessException(
          "Can't add data with columnFamily = "
              + columnFamily
              + " and row="
              + row
              + " key  = "
              + key
              + " value = "
              + value);
    }

    try {
      Mutator<String> messageContentMutator = HFactory.createMutator(keyspace, stringSerializer);
      messageContentMutator.addInsertion(
          row,
          columnFamily,
          HFactory.createColumn(key, value, longSerializer, bytesArraySerializer));
      messageContentMutator.execute();
    } catch (Exception e) {
      throw new CassandraDataAccessException(
          "Error while adding new Column <int,byte[]> to cassandra store", e);
    }
  }
 // TM
 @Override
 protected void batchDeleteRow(String cf, List<Node[]> li, String keyspace) {
   if (cf.equals(CF_C_SPO)) {
     super.batchDeleteRow(cf, li, keyspace);
   } else if (cf.equals(CF_PO_S)) {
     Mutator<byte[]> m = HFactory.createMutator(getExistingKeyspace(keyspace), _bs);
     for (Node[] nx : li) {
       // reorder for the key
       Node[] reordered = Util.reorder(nx, _maps.get(cf));
       ByteBuffer rowKey = createKey(new Node[] {reordered[0], reordered[1]});
       String colKey = reordered[2].toN3();
       // delete the full row
       m.addDeletion(rowKey.array(), cf);
     }
     m.execute();
   } else {
     Mutator<String> m = HFactory.createMutator(getExistingKeyspace(keyspace), _ss);
     for (Node[] nx : li) {
       // reorder for the key
       Node[] reordered = Util.reorder(nx, _maps.get(cf));
       String rowKey = reordered[0].toN3();
       m.addDeletion(rowKey, cf);
       _log.info("Delete full row for " + rowKey + " cf= " + cf);
     }
     m.execute();
   }
 }
Example #3
0
  /**
   * Add Message to a Given Queue in Cassandra
   *
   * @param columnFamily ColumnFamily name
   * @param queue queue name
   * @param messageId Message id
   * @param message message in bytes
   * @param keyspace Cassandra KeySpace
   * @throws CassandraDataAccessException In case of database access error
   */
  public static void addMessageToQueue(
      String columnFamily, String queue, long messageId, byte[] message, Keyspace keyspace)
      throws CassandraDataAccessException {

    if (keyspace == null) {
      throw new CassandraDataAccessException("Can't add Data , no mutator provided ");
    }

    if (columnFamily == null || queue == null || message == null) {
      throw new CassandraDataAccessException(
          "Can't add data with columnFamily = "
              + columnFamily
              + " and queue="
              + queue
              + " message id  = "
              + messageId
              + " message = "
              + message);
    }

    try {
      Mutator<String> mutator = HFactory.createMutator(keyspace, stringSerializer);
      mutator.addInsertion(
          queue.trim(),
          columnFamily,
          HFactory.createColumn(messageId, message, longSerializer, bytesArraySerializer));
      mutator.execute();

    } catch (Exception e) {
      throw new CassandraDataAccessException("Error while adding message to Queue", e);
    }
  }
Example #4
0
  /**
   * Add a Mapping to a Given Row in cassandra column family. Mappings are used as search indexes
   *
   * @param columnFamily columnFamilyName
   * @param row row name
   * @param cKey key name for the adding column
   * @param cValue value for the adding column
   * @param keyspace Cassandra KeySpace
   * @throws CassandraDataAccessException In case of database access error or data error
   */
  public static void addMappingToRaw(
      String columnFamily, String row, String cKey, String cValue, Keyspace keyspace)
      throws CassandraDataAccessException {

    if (keyspace == null) {
      throw new CassandraDataAccessException("Can't add Data , no KeySpace provided ");
    }

    if (columnFamily == null || row == null || cKey == null) {
      throw new CassandraDataAccessException(
          "Can't add data with columnFamily = "
              + columnFamily
              + " and rowName="
              + row
              + " key = "
              + cKey);
    }

    try {
      Mutator<String> mutator = HFactory.createMutator(keyspace, stringSerializer);
      mutator.addInsertion(
          row,
          columnFamily,
          HFactory.createColumn(cKey, cValue.trim(), stringSerializer, stringSerializer));
      mutator.execute();
    } catch (Exception e) {
      throw new CassandraDataAccessException("Error while adding a Mapping to row ", e);
    }
  }
Example #5
0
  /**
   * Add new Column<long,long> to a given row in a given cassandra column family
   *
   * @param columnFamily column family name
   * @param row row name
   * @param key long key value of the column
   * @param value long value of the column
   * @param keyspace Cassandra KeySpace
   * @throws CassandraDataAccessException
   */
  public static void addLongContentToRow(
      String columnFamily, String row, long key, long value, Keyspace keyspace)
      throws CassandraDataAccessException {

    if (keyspace == null) {
      throw new CassandraDataAccessException("Can't add Data , no keySpace provided ");
    }

    if (columnFamily == null || row == null) {
      throw new CassandraDataAccessException(
          "Can't add data with columnFamily = "
              + columnFamily
              + " and rowName="
              + row
              + " key = "
              + key);
    }

    try {
      Mutator<String> mutator = HFactory.createMutator(keyspace, stringSerializer);
      mutator.insert(
          row, columnFamily, HFactory.createColumn(key, value, longSerializer, longSerializer));
      mutator.execute();
    } catch (Exception e) {
      throw new CassandraDataAccessException("Error while adding long content to a row", e);
    }
  }
 public void init() {
   CassandraHostConfigurator hostConfig =
       new CassandraHostConfigurator(darkStarNode + ":" + String.valueOf(darkStarPort));
   cluster = HFactory.createCluster(clusterName, hostConfig);
   keySpace = HFactory.createKeyspace(keyspace, cluster, policy);
   mutator = HFactory.createMutator(keySpace, bfs);
 }
Example #7
0
  /**
   * Create a Cassandra Cluster instance given the connection details
   *
   * @param userName userName to connect to the cassandra
   * @param password password to connect to cassandra
   * @param clusterName Cluster name
   * @param connectionString cassandra connection string
   * @return Cluster instance
   * @throws CassandraDataAccessException In case of and error in accessing database or data error
   */
  public static Cluster createCluster(
      String userName, String password, String clusterName, String connectionString)
      throws CassandraDataAccessException {

    if (userName == null || password == null) {
      throw new CassandraDataAccessException(
          "Can't create cluster with empty userName or Password");
    }

    if (clusterName == null) {
      throw new CassandraDataAccessException("Can't create cluster with empty cluster name");
    }

    if (connectionString == null) {
      throw new CassandraDataAccessException("Can't create cluster with empty connection string");
    }

    Map<String, String> credentials = new HashMap<String, String>();
    credentials.put(USERNAME_KEY, userName);
    credentials.put(PASSWORD_KEY, password);

    CassandraHostConfigurator hostConfigurator = new CassandraHostConfigurator(connectionString);
    hostConfigurator.setMaxActive(2000);
    Cluster cluster = HFactory.getCluster(clusterName);

    if (cluster == null) {
      cluster = HFactory.createCluster(clusterName, hostConfigurator, credentials);
    }
    return cluster;
  }
 public void put(String columnFamily, String key, byte[] value) {
   Mutator<String> mutator = HFactory.createMutator(this._keyspace, StringSerializer.get());
   mutator.insert(
       key,
       columnFamily,
       HFactory.createColumn(
           DEFAULT_COLUMN_NAME, value, StringSerializer.get(), BytesArraySerializer.get()));
 }
 void setEnvironment() throws InvalidRequestException, TException {
   try {
     myCluster = HFactory.getOrCreateCluster("Test Sample", "localhost:9160");
     ksdef = myCluster.describeKeyspace(keyspaceName);
     if (ksdef == null) addKeyspacetoCassandra();
     keyspace = HFactory.createKeyspace("mostkeyspace", myCluster);
   } catch (Exception e) {
     System.out.print("Unalble to setup environment");
     e.printStackTrace();
   }
 }
 void insertData(String dpname, Date d, Timestamp u, double value) {
   try {
     long timeInMicroSeconds = u.getTime();
     // UUID timeUUIDColumnName = TimeUUIDUtils.getTimeUUID(timeInMicroSeconds);
     System.out.println(d + "\t" + timeInMicroSeconds + "\t" + value);
     DateSerializer ds = new DateSerializer();
     Mutator<Date> mu = HFactory.createMutator(keyspace, ds);
     mu.insert(d, dpname, HFactory.createColumn(timeInMicroSeconds, value));
   } catch (Exception e) {
     e.printStackTrace();
   }
 }
  @Override
  public void insertTatamibotConfiguration(TatamibotConfiguration tatamibotConfiguration) {
    UUID tatamibotConfigurationId = TimeUUIDUtils.getUniqueTimeUUIDinMillis();
    Mutator<String> mutator = HFactory.createMutator(keyspaceOperator, StringSerializer.get());
    mutator.insert(
        tatamibotConfiguration.getDomain(),
        ColumnFamilyKeys.DOMAIN_TATAMIBOT_CF,
        HFactory.createColumn(
            tatamibotConfigurationId, "", UUIDSerializer.get(), StringSerializer.get()));

    tatamibotConfiguration.setTatamibotConfigurationId(tatamibotConfigurationId.toString());
    em.persist(tatamibotConfiguration);
  }
Example #12
0
 public void addFriends(String from_uname, List<String> to_unames) {
   long timestamp = System.currentTimeMillis();
   Mutator<String> mutator = cassandra.getMutator();
   for (String uname : to_unames) {
     mutator
         .addInsertion(
             from_uname, FRIENDS, HFactory.createStringColumn(uname, String.valueOf(timestamp)))
         .addInsertion(
             uname, FOLLOWERS, HFactory.createStringColumn(from_uname, String.valueOf(timestamp)))
         .addCounter(from_uname, MISC_COUNTS, HFactory.createCounterColumn("friends", 1))
         .addCounter(uname, MISC_COUNTS, HFactory.createCounterColumn("followers", 1));
   }
   mutator.execute();
 }
  @Override
  @CacheEvict(value = "domain-tags-cache", key = "#domain")
  public void addTag(String domain, String tag) {
    HColumn<UUID, String> column =
        HFactory.createColumn(
            TimeUUIDUtils.getUniqueTimeUUIDinMillis(),
            tag,
            COLUMN_TTL,
            UUIDSerializer.get(),
            StringSerializer.get());

    Mutator<String> mutator = HFactory.createMutator(keyspaceOperator, StringSerializer.get());

    mutator.insert(domain, TRENDS_CF, column);
  }
Example #14
0
  public static void deleteIntegerColumnFromRow(
      String columnFamily, String row, Integer key, Keyspace keyspace)
      throws CassandraDataAccessException {

    if (keyspace == null) {
      throw new CassandraDataAccessException("Can't delete Data , no keyspace provided ");
    }

    if (columnFamily == null || row == null) {
      throw new CassandraDataAccessException(
          "Can't delete data in columnFamily = "
              + columnFamily
              + " and rowName="
              + row
              + " key = "
              + key);
    }

    try {
      Mutator<String> mutator = HFactory.createMutator(keyspace, stringSerializer);
      mutator.addDeletion(row, columnFamily, key, integerSerializer);
      mutator.execute();
    } catch (Exception e) {
      throw new CassandraDataAccessException("Error while deleting data", e);
    }
  }
Example #15
0
  public static List<String> getDestinationQueueNamesFromCounterColumns(
      String columnFamilyName, String rowName, Keyspace keyspace)
      throws CassandraDataAccessException {
    ArrayList<String> rowList = new ArrayList<String>();

    if (keyspace == null) {
      throw new CassandraDataAccessException("Can't access Data , no keyspace provided ");
    }

    if (columnFamilyName == null || rowName == null) {
      throw new CassandraDataAccessException(
          "Can't access data with columnFamily =" + columnFamilyName + " and rowName=" + rowName);
    }

    try {

      SliceCounterQuery<String, String> sliceQuery =
          HFactory.createCounterSliceQuery(keyspace, stringSerializer, stringSerializer);
      sliceQuery.setKey(rowName);
      sliceQuery.setColumnFamily(columnFamilyName);
      sliceQuery.setRange("", "", false, Integer.MAX_VALUE);

      QueryResult<CounterSlice<String>> result = sliceQuery.execute();
      CounterSlice<String> columnSlice = result.get();
      for (HCounterColumn<String> column : columnSlice.getColumns()) {
        rowList.add(column.getName());
      }
    } catch (Exception e) {
      throw new CassandraDataAccessException(
          "Error while accessing data from :" + columnFamilyName, e);
    }
    return rowList;
  }
  @Override
  public String getLastRevision(String executionPlanIdentifier) {
    ColumnSlice<String, byte[]> cs;
    String rangeStart =
        new StringBuffer(String.valueOf(timeAt1970.getTime())).append("_").toString();
    boolean firstLoop = true;
    while (true) {
      SliceQuery<String, String, byte[]> q = HFactory.createSliceQuery(keyspace, sser, sser, bser);
      q.setColumnFamily(INDEX_COLUMN_FAMILY_NAME)
          .setKey(executionPlanIdentifier)
          .setRange(rangeStart, String.valueOf(Long.MAX_VALUE), false, 1000);

      QueryResult<ColumnSlice<String, byte[]>> r = q.execute();

      cs = r.get();
      int size = cs.getColumns().size();
      if (firstLoop && size == 0) {
        return null;
      } else if (size == 0) {
        return rangeStart;
      } else {
        firstLoop = false;
      }
      int lastIndex = size - 1;
      rangeStart = cs.getColumns().get(lastIndex).getName();
      if (size < 1000) {
        break;
      }
    }
    log.info("found revision " + rangeStart);
    return rangeStart;
  }
Example #17
0
  public static void addIntegerByteArrayContentToRaw(
      String columnFamily,
      String row,
      int key,
      byte[] value,
      Mutator<String> mutator,
      boolean execute)
      throws CassandraDataAccessException {

    if (mutator == null) {
      throw new CassandraDataAccessException("Can't add Data , no Mutator provided ");
    }

    if (columnFamily == null || row == null || value == null) {
      throw new CassandraDataAccessException(
          "Can't add data with columnFamily = "
              + columnFamily
              + " and row="
              + row
              + " key  = "
              + key
              + " value = "
              + value);
    }

    mutator.addInsertion(
        row,
        columnFamily,
        HFactory.createColumn(key, value, integerSerializer, bytesArraySerializer));
    if (execute) {
      mutator.execute();
    }
  }
  @Override
  public Collection<TatamibotConfiguration> findTatamibotConfigurationsByDomain(String domain) {

    Set<TatamibotConfiguration> configurations = new HashSet<TatamibotConfiguration>();

    ColumnSlice<UUID, String> results =
        HFactory.createSliceQuery(
                keyspaceOperator,
                StringSerializer.get(),
                UUIDSerializer.get(),
                StringSerializer.get())
            .setColumnFamily(ColumnFamilyKeys.DOMAIN_TATAMIBOT_CF)
            .setKey(domain)
            .setRange(null, null, false, Integer.MAX_VALUE)
            .execute()
            .get();

    for (HColumn<UUID, String> column : results.getColumns()) {
      String tatamibotConfigurationId = column.getName().toString();
      TatamibotConfiguration configuration =
          em.find(TatamibotConfiguration.class, tatamibotConfigurationId);
      configurations.add(configuration);
    }
    return configurations;
  }
Example #19
0
  /**
   * Get set of messages in a column family
   *
   * @param queueName QueueName
   * @param columnFamilyName ColumnFamilyName
   * @param keyspace Cassandra KeySpace
   * @param count max message count limit
   * @return ColumnSlice which contain the messages
   * @throws CassandraDataAccessException
   */
  public static ColumnSlice<Long, byte[]> getMessagesFromQueue(
      String queueName, String columnFamilyName, Keyspace keyspace, int count)
      throws CassandraDataAccessException {
    if (keyspace == null) {
      throw new CassandraDataAccessException("Can't access Data , no keyspace provided ");
    }

    if (columnFamilyName == null || queueName == null) {
      throw new CassandraDataAccessException(
          "Can't access data with columnFamily = "
              + columnFamilyName
              + " and queueName="
              + queueName);
    }

    try {
      SliceQuery<String, Long, byte[]> sliceQuery =
          HFactory.createSliceQuery(
              keyspace, stringSerializer, longSerializer, bytesArraySerializer);
      sliceQuery.setKey(queueName);
      sliceQuery.setRange((long) 0, Long.MAX_VALUE, false, count);
      sliceQuery.setColumnFamily(columnFamilyName);

      QueryResult<ColumnSlice<Long, byte[]>> result = sliceQuery.execute();
      ColumnSlice<Long, byte[]> columnSlice = result.get();

      return columnSlice;
    } catch (Exception e) {
      throw new CassandraDataAccessException(
          "Error while getting data from " + columnFamilyName, e);
    }
  }
Example #20
0
  /**
   * Get a HColumn<Long, byte[]> with a given key in a given row in a given column Family
   *
   * @param rowName name of the row
   * @param columnFamily column Family name
   * @param key long type key of the column we are looking for
   * @param keyspace cassandra keySpace instance
   * @return query result as a cassandra column
   * @throws CassandraDataAccessException in case of an Error when accessing data
   */
  public static HColumn<Long, byte[]> getLongByteArrayColumnInARow(
      String rowName, String columnFamily, long key, Keyspace keyspace)
      throws CassandraDataAccessException {

    if (keyspace == null) {
      throw new CassandraDataAccessException("Can't access Data , no keyspace provided ");
    }

    if (columnFamily == null || rowName == null) {
      throw new CassandraDataAccessException(
          "Can't access data with columnFamily = " + columnFamily + " and rowName=" + rowName);
    }

    try {
      ColumnQuery columnQuery =
          HFactory.createColumnQuery(
              keyspace, stringSerializer, longSerializer, bytesArraySerializer);
      columnQuery.setColumnFamily(columnFamily);
      columnQuery.setKey(rowName);
      columnQuery.setName(key);

      QueryResult<HColumn<Long, byte[]>> result = columnQuery.execute();

      HColumn<Long, byte[]> column = result.get();
      return column;
    } catch (Exception e) {
      throw new CassandraDataAccessException(
          "Error while executing quary for HColumn<Long, byte[]> with key ="
              + key
              + " in column Family = "
              + columnFamily,
          e);
    }
  }
Example #21
0
  /**
   * Get Number of <String,String> type columns in a given row in a cassandra column family
   *
   * @param rowName row Name we are querying for
   * @param columnFamilyName columnFamilName
   * @param keyspace
   * @param count
   * @return
   */
  public static ColumnSlice<String, String> getStringTypeColumnsInARow(
      String rowName, String columnFamilyName, Keyspace keyspace, int count)
      throws CassandraDataAccessException {

    if (keyspace == null) {
      throw new CassandraDataAccessException("Can't access Data , no keyspace provided ");
    }

    if (columnFamilyName == null || rowName == null) {
      throw new CassandraDataAccessException(
          "Can't access data with columnFamily = " + columnFamilyName + " and rowName=" + rowName);
    }

    try {
      SliceQuery sliceQuery =
          HFactory.createSliceQuery(keyspace, stringSerializer, stringSerializer, stringSerializer);
      sliceQuery.setKey(rowName);
      sliceQuery.setColumnFamily(columnFamilyName);
      sliceQuery.setRange("", "", false, count);

      QueryResult<ColumnSlice<String, String>> result = sliceQuery.execute();
      ColumnSlice<String, String> columnSlice = result.get();

      return columnSlice;
    } catch (Exception e) {
      throw new CassandraDataAccessException(
          "Error while getting data from : " + columnFamilyName, e);
    }
  }
  @Override
  public PersistenceObject load(
      PersistenceManagementEvent persistenceManagementEvent, String nodeId) {

    List<NodeSnapshot> list = new ArrayList<NodeSnapshot>();

    ColumnSlice<String, byte[]> cs;

    SliceQuery<String, String, byte[]> q = HFactory.createSliceQuery(keyspace, sser, sser, bser);
    q.setColumnFamily(COLUMN_FAMILY_NAME)
        .setKey(persistenceManagementEvent.getRevision())
        .setRange("", "", false, 1000)
        .setColumnNames(nodeId);

    QueryResult<ColumnSlice<String, byte[]>> r = q.execute();

    cs = r.get();
    PersistenceObject persistenceObject = null;
    for (HColumn<String, byte[]> hc : cs.getColumns()) {
      persistenceObject = (PersistenceObject) ByteSerializer.BToO(hc.getValue());
      //            list.add(new NodeSnapshot(hc.getName(), hc.getValue()));
    }
    //        return list;
    return persistenceObject;
  }
 /**
  * Counts columns in the specified range of a standard column family
  *
  * @param key
  * @param start
  * @param end
  * @param max
  * @return
  */
 public int countColumns(K key, N start, N end, int max) {
   CountQuery<K, N> query = HFactory.createCountQuery(keyspace, keySerializer, topSerializer);
   query.setKey(key);
   query.setColumnFamily(columnFamily);
   query.setRange(start, end, max);
   return query.execute().get();
 }
  private List<String> getTags(
      Keyspace keyspaceOperator,
      String columnfamily,
      String cfId,
      String startRange,
      String endRange) {
    SliceQuery<String, String, String> query =
        HFactory.createSliceQuery(
                keyspaceOperator,
                StringSerializer.get(),
                StringSerializer.get(),
                StringSerializer.get())
            .setColumnFamily(columnfamily)
            .setKey(cfId)
            .setRange(TAG_COLUMN_MIN_NAME, TAG_COLUMN_MAX_NAME, false, Integer.MAX_VALUE);

    QueryResult<ColumnSlice<String, String>> queryResult = query.execute();

    ColumnSlice<String, String> columnSlice = queryResult.get();

    SortedSet<String> tags = new TreeSet<String>();
    for (HColumn<String, String> hColumn : columnSlice.getColumns()) {
      tags.add(hColumn.getValue());
    }

    return new ArrayList<String>(tags);
  }
  public void runQuery() throws IOException {
    MultigetSliceQuery<DataPointsRowKey, Integer, ByteBuffer> msliceQuery =
        HFactory.createMultigetSliceQuery(
            m_keyspace, ROW_KEY_SERIALIZER, IntegerSerializer.get(), ByteBufferSerializer.get());

    msliceQuery.setColumnFamily(m_columnFamily);
    msliceQuery.setKeys(m_rowKeys);
    if (m_descending) msliceQuery.setRange(m_endTime, m_startTime, true, m_multiRowReadSize);
    else msliceQuery.setRange(m_startTime, m_endTime, false, m_multiRowReadSize);

    Rows<DataPointsRowKey, Integer, ByteBuffer> rows = msliceQuery.execute().get();

    List<Row<DataPointsRowKey, Integer, ByteBuffer>> unfinishedRows =
        new ArrayList<Row<DataPointsRowKey, Integer, ByteBuffer>>();

    for (Row<DataPointsRowKey, Integer, ByteBuffer> row : rows) {
      List<HColumn<Integer, ByteBuffer>> columns = row.getColumnSlice().getColumns();
      if (!m_limit && columns.size() == m_multiRowReadSize) unfinishedRows.add(row);

      writeColumns(row.getKey(), columns);
    }

    // Iterate through the unfinished rows and get the rest of the data.
    // todo: use multiple threads to retrieve this data
    for (Row<DataPointsRowKey, Integer, ByteBuffer> unfinishedRow : unfinishedRows) {
      DataPointsRowKey key = unfinishedRow.getKey();

      SliceQuery<DataPointsRowKey, Integer, ByteBuffer> sliceQuery =
          HFactory.createSliceQuery(
              m_keyspace, ROW_KEY_SERIALIZER, IntegerSerializer.get(), ByteBufferSerializer.get());

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

      List<HColumn<Integer, ByteBuffer>> columns = unfinishedRow.getColumnSlice().getColumns();

      do {
        Integer lastTime = columns.get(columns.size() - 1).getName();

        if (m_descending) sliceQuery.setRange(lastTime - 1, m_startTime, true, m_singleRowReadSize);
        else sliceQuery.setRange(lastTime + 1, m_endTime, false, m_singleRowReadSize);

        columns = sliceQuery.execute().get().getColumns();
        writeColumns(key, columns);
      } while (columns.size() == m_singleRowReadSize);
    }
  }
 public void addEventSoftState(EventSoftState state) {
   Mutator<String> mutator = getStringMutator();
   mutator.addInsertion(
       state.getResourceURL(),
       EVENT_SOFT_STATE_COLUMN_FAMILY_NAME,
       HFactory.createColumn(state.getEntityTag(), state, STRING_SERIALIZER, OBJECT_SERIALIZER));
   mutator.execute();
 }
Example #27
0
  public static <A, B> HColumn<A, B> column(final A name, final B value) {

    return HFactory.createColumn(
        name, //
        value, //
        (Serializer<A>) SerializerTypeInferer.getSerializer(name), //
        (Serializer<B>) SerializerTypeInferer.getSerializer(value));
  }
 private void insertSubscription(SubscriptionContext context) {
   Mutator<Object> mutator = getObjectMutator();
   mutator.addInsertion(
       context.getId(),
       SUBSCRIPTION_COLUMN_FAMILY_NAME,
       HFactory.createColumn("value", context, STRING_SERIALIZER, OBJECT_SERIALIZER));
   mutator.execute();
 }
Example #29
0
 public void truncate() {
   Mutator<K> mutator = HFactory.createMutator(keyspace, keySerializer);
   Iterator<K> iterator = new KeyIterator<K>(keyspace, columnFamily, keySerializer).iterator();
   while (iterator.hasNext()) {
     this.removeRowBatch(iterator.next(), mutator);
   }
   this.executeMutator(mutator);
 }
Example #30
0
  public void removeCounterRow(K key) {
    SliceCounterQuery<K, N> query =
        HFactory.createCounterSliceQuery(keyspace, keySerializer, columnNameSerializer)
            .setColumnFamily(columnFamily)
            .setKey(key);

    AchillesCounterSliceIterator<K, N> iterator =
        new AchillesCounterSliceIterator<K, N>(
            policy, columnFamily, query, (N) null, (N) null, false, DEFAULT_LENGTH);

    Mutator<K> mutator = HFactory.createMutator(keyspace, keySerializer);
    while (iterator.hasNext()) {
      HCounterColumn<N> counterCol = iterator.next();
      mutator.decrementCounter(key, columnFamily, counterCol.getName(), counterCol.getValue());
    }
    this.executeMutator(mutator);
  }