Cassandra Stress

specname: staff_activities

keyspace: staff

keyspace_definition: |
 CREATE KEYSPACE stresscql WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 3};

table: staff_activities

table_definition: |
  CREATE TABLE staff_activities (
      name text,
      when timeuuid,
      what text,
      PRIMARY KEY(name, when, what)
  )

columnspec:
  - name: name
    size: uniform(5..10) # The names of the staff members are between 5-10 characters
    population: uniform(1..10) # 10 possible staff members to pick from
  - name: when
    cluster: uniform(20..500) # Staff members do between 20 and 500 events
  - name: what
    size: normal(10..100,50)

EXP(min..max)

EXTREME(min..max,shape)

GAUSSIAN(min..max,stdvrng)

GAUSSIAN(min..max,mean,stdev)

UNIFORM(min..max)

FIXED(val)

insert:
  # How many partition to insert per batch
  partitions: fixed(1)
  # How many rows to update per partition
  select: fixed(1)/500
  # UNLOGGED or LOGGED batch for insert
  batchtype: UNLOGGED

queries:
   events:
      cql: select *  from staff_activities where name = ?
      fields: samerow
   latest_event:
      cql: select * from staff_activities where name = ?  LIMIT 1
      fields: samerow

cassandra-stress user profile=./example.yaml duration=1m "ops(insert=1,latest_event=1,events=1)" truncate=once

spacenam: example # idenitifier for this spec if running with multiple yaml files
keyspace: example

# Would almost always be network topology unless running something locally
keyspace_definition: |
  CREATE KEYSPACE example WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 3};

table: staff_activities

# The table under test. Start with a partition per staff member
# Is this a good idea?
table_definition: |
  CREATE TABLE staff_activities (
        name text,
        when timeuuid,
        what text,
        PRIMARY KEY(name, when)
  )

columnspec:
  - name: name
    size: uniform(5..10) # The names of the staff members are between 5-10 characters
    population: uniform(1..10) # 10 possible staff members to pick from
  - name: when
    cluster: uniform(20..500) # Staff members do between 20 and 500 events
  - name: what
    size: normal(10..100,50)

insert:
  # we only update a single partition in any given insert
  partitions: fixed(1)
  # we want to insert a single row per partition and we have between 20 and 500
  # rows per partition
  select: fixed(1)/500
  batchtype: UNLOGGED             # Single partition unlogged batches are essentially noops

queries:
   events:
      cql: select *  from staff_activities where name = ?
      fields: samerow
   latest_event:
      cql: select * from staff_activities where name = ?  LIMIT 1
      fields: samerow

queries:
  regularupdate:
      cql: update blogposts set author = ? where domain = ? and published_date = ?
      fields: samerow
  updatewithlwt:
      cql: update blogposts set author = ? where domain = ? and published_date = ? IF body = ? AND url = ?
      fields: samerow

# Keyspace Name
keyspace: stresscql

# The CQL for creating a keyspace (optional if it already exists)
# Would almost always be network topology unless running something locall
keyspace_definition: |
  CREATE KEYSPACE stresscql WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1};

# Table name
table: blogposts

# The CQL for creating a table you wish to stress (optional if it already exists)
table_definition: |
  CREATE TABLE blogposts (
        domain text,
        published_date timeuuid,
        url text,
        author text,
        title text,
        body text,
        PRIMARY KEY(domain, published_date)
  ) WITH CLUSTERING ORDER BY (published_date DESC)
    AND compaction = { 'class':'LeveledCompactionStrategy' }
    AND comment='A table to hold blog posts'

### Column Distribution Specifications ###

columnspec:
  - name: domain
    size: gaussian(5..100)       #domain names are relatively short
    population: uniform(1..10M)  #10M possible domains to pick from

  - name: published_date
    cluster: fixed(1000)         #under each domain we will have max 1000 posts

  - name: url
    size: uniform(30..300)

  - name: title                  #titles shouldn't go beyond 200 chars
    size: gaussian(10..200)

  - name: author
    size: uniform(5..20)         #author names should be short

  - name: body
    size: gaussian(100..5000)    #the body of the blog post can be long

### Batch Ratio Distribution Specifications ###

insert:
  partitions: fixed(1)            # Our partition key is the domain so only insert one per batch

  select:    fixed(1)/1000        # We have 1000 posts per domain so 1/1000 will allow 1 post per batch

  batchtype: UNLOGGED             # Unlogged batches


#
# A list of queries you wish to run against the schema
#
queries:
   singlepost:
      cql: select * from blogposts where domain = ? LIMIT 1
      fields: samerow
   regularupdate:
      cql: update blogposts set author = ? where domain = ? and published_date = ?
      fields: samerow
   updatewithlwt:
      cql: update blogposts set author = ? where domain = ? and published_date = ? IF body = ? AND url = ?
      fields: samerow