Как увеличить счетчик колонок Cassandra с помощью phantom-dsl?

Есть ли примеры реализации операции counter в phantom-dsl?

Проверил:

http://outworkers.com/blog/post/a-series-on-cassandra-part-3-advanced-features

https://github.com/outworkers/phantom/wiki/Counter-columns

https://github.com/outworkers/phantom/blob/develop/phantom-dsl/src/test/scala/com/websudos/phantom/tables/CounterTableTest.scala

Kinda ищет фантомную версию этой информации:

https://github.com/Netflix/astyanax/wiki/Working-with-counter-columns

Ниже приведена частичная реализация. Возникло два вопроса:

  1. Я не уверен, как получить значения из приложения и реализовать операцию счетчика приращений в столбце счетчика в таблице счетчиков.

  2. Как обновить строки в таблицах, относящиеся к одной и той же записи, где таблицы имеют разное количество строк и ключей.

В примере с thiagos две таблицы; "songs" и "songs_by_artist" имеют одинаковые строки, но с разными разделами (первичные ключи / столбцы кластеризации)

Я не уверен, как в phantom-dsl можно обновить строки, относящиеся к одним и тем же записям, например, в таблицах "records" и "record_transaction_counts" ниже.

например

RecordTransactionCounts.{hash, time} relates to Records.{hash, time}

case class Record(hash: String,
                 size: Int,
                 time: Long,
                 difficulty: Float)


sealed class RecordsModel extends CassandraTable[RecordsModel, Record] {

  override def fromRow(row: Row): Record = {
    Record(
      hash(row),
      size(row),
      time(row),
      difficulty(row)
    )
  }

  object hash extends StringColumn(this) with PartitionKey[String]

  object size extends IntColumn(this)

  object time extends LongColumn(this)

  object difficulty extends FloatColumn(this)

}

abstract class ConcreteRecordsModel extends RecordsModel with RootConnector {

  override val tableName = "records"

  def insertNew(block: Record): Future[ResultSet] = insertNewRecord(block).future()

  def insertNewRecord(r: Record) = {
    insert
      .value(_.hash, r.hash)
      .value(_.size, r.size)
      .value(_.time, r.time)
      .value(_.difficulty, r.difficulty)
  }

}

case class RecordTransactionCounts(hash: String, time: Long, num_transactions: Long )

class RecordTransactionCountsModel extends CassandraTable[RecordTransactionCountsModel, RecordTransactionCounts] {

  override def tableName: String = "record_transaction_counts"

  object hash extends StringColumn(this) with PartitionKey[String]

  object time extends LongColumn(this) with ClusteringOrder[Long]

  object num_transactions extends CounterColumn(this)

  override def fromRow(r: Row): RecordTransactionCounts = {
    RecordTransactionCounts(
      hash(r),
      time(r),
      num_transactions(r)
    )
  }

}

abstract class ConcreteRecordTransactionCountsModel extends TransactionCountsModel with RootConnector {

  def createTable(): Future[ResultSet] = {
    create.ifNotExists().future()
  }

  def store(count: RecordTransactionCounts): Future[ResultSet] = {
    insert
      .value(_.hash, count.hash)
      .value(_.time, count.time)
      .value(_.num_transactions, count.num_transactions)
      .future()
  }

  def getCount(hash: String): Future[Option[Long]] = {
    select(_.count).where(_.hash eqs hash).one()
  }
}

class Database(val keyspace: KeySpaceDef) extends DatabaseImpl(keyspace) {

  def insertRecordTransactionCounts(tc: RecordTransactionCounts) = {
    Batch.logged
      .add(ChainDatabase.tc.store(tc))
      .future()
  }

  object tc extends ConcreteRecordTransactionCountsModel with keyspace.Connector

}

object ChainDatabase extends Database(Config.keySpaceDefinition)
Источник

2 ответа

Решение

Как предположил Тьяго, вы можете использовать += или в качестве альтернативы -= Оператор для уменьшения значения счетчика. Вы также можете использовать increment или же decrement методы соответственно для достижения того же.

def increment(count: RecordTransactionCounts): Future[ResultSet] = {
  update
    .where(_.hash eqs count.hash)
    .and(_.time eqs count.time)
    .modify(_.num_transactions += count.num_transactions)
    .future()
}
// or
def increment(count: RecordTransactionCounts): Future[ResultSet] = {
  update
    .where(_.hash eqs count.hash)
    .and(_.time eqs count.time)
    .modify(_.num_transactions increment count.num_transactions)
    .future()
}

Чтобы уменьшить, просто замените строки:

    ...
    .modify(_.num_transactions -= count.num_transactions)
    // or
    .modify(_.num_transactions decrement count.num_transactions)

Прежде чем вы слишком полагаетесь на счетчики, вам также следует немного погуглить, чтобы выяснить, с какими проблемами сталкиваются другие люди.

Источник

Для того, чтобы использовать CounterColumn в phantom-dsl вы должны использовать следующий шаблон, чтобы увеличить его:

.modify(_.myCounterColumn += 1) //or whatever value you want to increment

В вашем ConcreteRecordTransactionCountsModel Вы можете изменить свой магазин, чтобы увеличить счетчик соответствующим образом, как это:

def increment(count: RecordTransactionCounts): Future[ResultSet] = {
  update
    .where(_.hash eqs count.hash)
    .and(_.time eqs count.time)
    .modify(_.num_transactions += count.num_transactions)
    .future()
}

Я постараюсь обновить свой github, добавив больше примеров, с которыми я работал раньше. Также, если у вас есть какие-либо предложения, пожалуйста, откройте тикет, и я сделаю это.

Источник
Другие вопросы по тегам