Wie erhöht man die Cassandra Counter Column mit phantom-dsl?

Question

Gibt es Beispiele für die Implementierung der Counter-Operation innerhalb von Phantom-dsl?

Haben Sie überprüft:

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 der Suche nach einem Phantom-dsl-Version dieser Info:

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

---

Das Folgende ist eine Teilimplementierung. Es hat zwei Fragen aufgegangen:

1. Ich bin nicht sicher, wie Werte nehmen in der Anwendung und Umsetzung der Erhöhung Zählerbetrieb in einem Zähler Spalte innerhalb einer Zählertabelle.

2. So aktualisieren Sie Zeilen innerhalb von Tabellen, die sich auf denselben Eintrag beziehen, bei dem die Tabellen eine unterschiedliche Anzahl von Zeilen und Schlüsseln aufweisen.

In thiagos example die zwei Tabellen; 'Songs' & 'songs_by_artist' beide haben die gleichen Zeilen, aber mit verschiedenen Partitionen (Primärschlüssel/Clustering-Spalten)

Ich bin mir nicht sicher, wie man in phantom-dsl Zeilen mit den gleichen Einträgen aktualisieren würde, wie mit " Datensätze "&" record_transaction_counts "Tabellen unten.

z.B.

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) 

Answer 1

Wie Thiago vorgeschlagen hat, können Sie den += oder alternativ den -= Operator verwenden, um den Wert eines Zählers zu verringern. Sie können auch die Methoden increment oder decrement verwenden, um dasselbe zu erreichen.

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() 
} 

zu verringern, ersetzen Sie einfach die Zeilen mit:

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

Bevor Sie auf Zähler zu viel verlassen, sollten Sie auch ein bisschen Google, um herauszufinden, was andere Leute Probleme haben.

Answer 2

Um die CounterColumn in Phantom-dsl zu verwenden, müssen Sie das folgende Muster verwenden Sie es zu erhöhen:

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

In Ihrem ConcreteRecordTransactionCountsModel Sie könnte sich ändern Ihr Geschäft, um den Zähler in einer richtigen Weise wie folgt zu erhöhen:

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

Ich werde versuchen, meine GitHub mit mehr Beispielen zu aktualisieren, die ich zuvor gearbeitet hatte. Auch wenn Sie irgendwelche Vorschläge haben, öffnen Sie bitte ein Ticket und ich werde es tun.