Pure Elixir Cassandra ORM built on top of Xandra.
Add triton to your deps.
def deps() do
[{:triton, "~> 0.2"}]
endSingle Cluster
config :triton,
clusters: [
[
conn: Triton.Conn,
nodes: ["127.0.0.1"],
pool: Xandra.Cluster,
underlying_pool: DBConnection.Poolboy,
pool_size: 10,
keyspace: "my_keyspace",
health_check_delay: 2500, # optional: (default is 5000)
health_check_interval: 500 # optional: (default is 1000)
]
]Multi-Cluster
config :triton,
clusters: [
[
conn: Cluster1.Conn,
nodes: ["127.0.0.1"],
pool: Xandra.Cluster,
underlying_pool: DBConnection.Poolboy,
pool_size: 10,
keyspace: "cluster_1_keyspace",
health_check_delay: 2500, # optional: (default is 5000)
health_check_interval: 500 # optional: (default is 1000)
],
[
conn: Cluster2.Conn,
nodes: ["127.0.0.1"],
pool: Xandra.Cluster,
underlying_pool: DBConnection.Poolboy,
pool_size: 10,
keyspace: "cluster_2_keyspace",
health_check_delay: 2500, # optional: (default is 5000)
health_check_interval: 500 # optional: (default is 1000)
]
]If DB gets disconnected, resulting in a DBConnection error, Triton will attempt to reconnect.
You can specify the health_check_delay and health_check_interval via the config for each cluster.
First, define your keyspace. Triton will create the keyspace for your after compile if it does not exist.
defmodule Schema.Keyspace do
use Triton.Keyspace
keyspace :my_keyspace, conn: Triton.Conn do
with_options [
replication: "{'class' : 'SimpleStrategy', 'replication_factor': 3}"
]
end
endYou can define as many tables as you want. Triton will create tables for you if they do not exist.
If you would like Triton to auto-create tables for you after compile, you must require your Keyspace module.
defmodule Schema.User do
require Schema.Keyspace
use Triton.Table
table :users, keyspace: Schema.Keyspace do
field :user_id, :bigint, validators: [presence: true] # validators using vex
field :username, :text
field :display_name, :text
field :password, :text
field :email, :text
field :phone, :text
field :notifications, {:map, "<text, text>"}
field :friends, {:set, "<text>"}
field :posts, {:list, "<text>"}
field :updated, :timestamp
field :created, :timestamp, transform: &Schema.Helper.DateHelper.to_ms/1 # transform field data
partition_key [:user_id]
end
endAn example of a materialized view users_by_email with fields user_id, email, display_name, password.
Also demonstrates adding options like gc_grace_seconds and clustering_order_by.
defmodule Schema.UserByEmail do
require Schema.User # if you want to auto-create after compile
use Triton.MaterializedView
materialized_view :users_by_email, from: Schema.User do
fields [
:user_id,
:email,
:display_name,
:password
]
partition_key [:email]
cluster_columns [:user_id]
with_options [
gc_grace_seconds: 172_800,
clustering_order_by: [
email: :asc,
user_id: :desc
]
]
end
endAn example of materialized view users_by_email with all fields
defmodule Schema.UserByEmail do
require Schema.User
use Triton.MaterializedView
materialized_view :users_by_email, from: Schema.User do
fields :all
partition_key [:email]
cluster_columns [:user_id]
end
endFirst, import Triton.Query
alias Schema.User
import Triton.QuerySelect a single user where user_id = using a prepared statement.
User
|> prepared(user_id: id)
|> select([:user_id, :username])
|> where(user_id: :user_id)
|> User.oneSelect users with IDs of 1, 2, or 3
User
|> select([:user_id, :username])
|> where(user_id: [in: [1, 2, 3]])
|> limit(10)
|> allow_filtering # you can allow filtering on any query
|> User.allSelect user with email [email protected]
UserByEmail
|> select([:display_name])
|> where(email: "[email protected]")
|> User.oneSelect messages created before timestamp
MessagesByDate
|> select([:message_id, :text])
|> where(channel_id: 1, created: ["<=": timestamp])
|> limit(20)
|> MessagesByDate.allSelect messages created between timestamp_a and timestamp_b
MessagesByDate
|> select([:message_id, :text])
|> where(channel_id: 1, created: [">=": timestamp_a], created: [<: timestamp_b])
|> MessagesByDate.allStream all messages
MessagesByDate
|> select(:all)
|> where(channel_id: 1)
|> MessagesByDate.stream(page_size: 20)Which returns {:ok, stream} or {:error, msg}
Again, lets import Triton.Query for the necessary macros.
alias Schema.User
import Triton.QueryAdd a user (if it doesn't already exist) with username username using a prepared statement that substitutes user_id into :user_id
User
|> prepared(user_id: user_id, username: username)
|> insert(user_id: :user_id, username: :username)
|> if_not_exists
|> User.saveUpdate a user's username, and make sure to check that their previous username was what we expected.
User
|> update(username: username)
|> where(user_id: user_id)
|> constrain(username: previous_username)
|> User.saveLets delete a user given a user_id
User
|> prepared(user_id: user_id)
|> delete(:all) # here :all refers to all fields
|> where(user_id: :user_id)
|> User.delLets delete that same user, with consistency: :quorum
User
|> prepared(user_id: user_id)
|> delete(:all) # here :all refers to all fields
|> where(user_id: :user_id)
|> User.del(consistency: :quorum)Batch update 4 users in 1 Cassandra request.
[
User |> update(username: "username1") |> where(user_id: 1),
User |> update(username: "username2") |> where(user_id: 2),
User |> update(username: "username3") |> where(user_id: 3),
User |> update(username: "username4") |> where(user_id: 4)
] |> User.batch_executeUpdate the notifications map to {'mentions': '3', 'replies': '3'}. Overwrites the entire map.
User
|> update(notifications: "{'mentions': '5', 'replies': '3'}")
|> where(user_id: 10)
|> User.saveUpdate notification mentions to '5'.
User
|> update("notifications['mentions']": "5")
|> where(user_id: 10)
|> User.saveUpdate the friends set
User
|> update(friends: "{'jill', 'bob', 'emma'}")
|> where(user_id: 10)
|> User.saveAdd a friend_id to friends set
User
|> update(friends: "friends + {'oscar'}")
|> where(user_id: 10)
|> User.saveRemove friend from set
User
|> update(friends: "friends - {'oscar'}")
|> where(user_id: 10)
|> User.saveUpdate the posts list
User
|> update(posts: "['post1', 'post2', 'post3']")
|> where(user_id: 10)
|> User.saveAppend to posts list
User
|> update(posts: "posts + ['post4']")
|> where(user_id: 10)
|> User.savePrepend to posts list
User
|> update(posts: "['post0'] + posts")
|> where(user_id: 10)
|> User.saveYou can pre-populate data with Triton at compile time with Triton.Setup
defmodule PrepopulateModule do
use Triton.Setup
import Triton.Query
require Schema.User
alias Schema.User
# create an admin user if it doesn't exist
setup do
User
|> insert(
user_id: @admin_user_id,
username: @admin_user_username,
display_name: @admin_user_display_name,
password: Bcrypt.hashpwsalt(@admin_user_password),
email: @admin_user_email,
created: @admin_user_created
) |> if_not_exists
end
endTriton attempts to create your keyspace, tables, and materialized views after compile if they do not exist.
This means that your build server will need access to your production DB if you want to automatically create your schema in prod. The alternative is simply to create your production schemas yourself.
For dev, you may want to consider running ccm with more than 1 node if you are doing queries at anything more than consistency: :one.
For testing, run mix test and mix test --only integration to run integration tests.