qbits.alia — cc.qbits/alia 4.3.5

batch clj

(batch qs)

(batch qs type)

(batch qs type codec)

Takes a sequence of statements to be executed in batch. By default LOGGED, you can specify :logged :unlogged :counter as an optional second argument to control the type. It also accepts an optional third argument, codec instance (see execute)

bind clj

(bind statement values)

(bind statement values {:keys [encoder]})

Takes a statement and a collection of values and returns a com.datastax.driver.core.BoundStatement instance to be used with execute (or one of its variants)

Where values: Map: for named bindings (i.e. INSERT INTO table (id, date) VALUES (:id :date)) List: for positional bindings (i.e. INSERT INTO table (id, date) VALUES (?, ?))

It also accepts an optional third argument, codec instance (see execute)

cluster clj

(cluster)

(cluster options)

Takes an option map and returns a new com.datastax.driver.core/Cluster instance.

The following options are supported:

• :contact-points : List of nodes ip addresses to connect to.

• :port : port to connect to on the nodes (native transport must be active on the nodes: start_native_transport: true in cassandra.yaml). Defaults to 9042 if not supplied.

• :load-balancing-policy : Configure the Load Balancing Policy to use for the new cluster. * Can be a one of - LoadBalancingPolicy instance - :default - :round-robin - :token-aware/round-robin - :latency-aware/round-robin * or a map of - :type : :whitelist or :token-aware/whitelist - :child : Keyword or map (other load balancing policy configuration) - :whitelist : Seq of maps of:hostnameString:portint or:ipString:portint or:portint * or a map of -:type::latency-aware/white-list-:child: Same as above -:whitelist : Same as above - :exclusion-threshold : double - :min-measure : int - :retry-period : [long (time-unit Keyword)] - :scale : [long (time-unit Keyword)] - :update-rate : [long (time-unit Keyword)] * or a map of - :type : :dc-aware-round-robin, :token-aware/dc-aware-round-robin - :data-centre : String - :used-hosts-per-remote-dc : int * or a map of - :type : :latency-aware/dc-aware-round-robin - :data-centre : String - :used-hosts-per-remote-dc : int - :exclusion-threshold : double - :min-measure : int - :retry-period : [long (time-unit Keyword)] - :scale : [long (time-unit Keyword)] - :update-rate : [long (time-unit Keyword)]

• :reconnection-policy : Configure the Reconnection Policy to use for the new cluster. * Can be - ReconnectionPolicy - :default * or a map of - :type :constant - :contant-delay-ms long * or a map of - :type :exponential - :base-delay-ms long - :max-delay-ms long

• :retry-policy : Configure the Retry Policy to use for the new cluster. * Can be - RetryPolicy, - :default - :fallthrough - :downgrading - :logging/default - :logging/fallthrough - :logging/downgrading

• :speculative-execution The policy that decides if the driver will send speculative queries to the next hosts when the current host takes too long to respond. Speculative Execution Policy * Can be - SpeculativeExecutionPolicy - :default - :none * or a map of - :type : :constant - :constant-delay-millis : long - :max-speculative-executions : int * or - :type : :cluster-wide-percentile-tracker or :per-host-percentile-tracker - :percentile : double - :max-executions : int -:interval: [long (time-unit Keyword)] -:min-recorded-values: int -:significant-value-digits: int -:highest-trackable-latency-millis` : long

• :metrics? : Toggles metrics collection for the created cluster (metrics are enabled by default otherwise).

• :jmx-reporting? : Toggles JMX reporting of the metrics.

• :credentials : Takes a map of :user and :password for use with Cassandra's PasswordAuthenticator

• :compression : Compression supported by the Cassandra binary protocol. Can be :none, :snappy or :lz4.

• :cluster-name : Optional name for create cluster

• max-schema-aggreement-wait-seconds Sets the maximum time to wait for schema agreement before returning from a DDL query.

• :netty-options: (advanced) see http://docs.datastax.com/en/drivers/java/2.1/com/datastax/driver/core/NettyOptions.html

• :address-translator: Configures the address translator to use for the new cluster. Expects a AddressTranslator or you can pass :ec2-multi-region or :identity which would translate in the underlying implementations.

• :timestamp-generator: Configures the timestamp generator to use with the new cluster. Expects a timestamp-generator instance, or :atomic-monotonic , :server-side or :thread-local which would translate in the underlying implementations.

• :ssl?: enables/disables SSL

• :ssl-options : advanced SSL setup using a com.datastax.driver.core.SSLOptions instance or a map of :keystore-path, :keystore-password and optional :ssl-protocol, :cipher-suites. This provides a path/pwd to a KeyStore that can ben generated with keytool Overriding default ssl protocol is supported via :ssl-protocol, which accepts a string like - TLSv1.2 Overriding default cipher suites is supported via :cipher-suites, which accepts a sequence of Strings.

• :pooling-options : The pooling options used by this builder. Options related to connection pooling.

  The driver uses connections in an asynchronous way. Meaning that multiple requests can be submitted on the same connection at the same time. This means that the driver only needs to maintain a relatively small number of connections to each Cassandra host. These options allow to control how many connections are kept exactly.

  For each host, the driver keeps a core amount of connections open at all time. If the utilisation of those connections reaches a configurable threshold ,more connections are created up to a configurable maximum number of connections.

  Once more than core connections have been created, connections in excess are reclaimed if the utilisation of opened connections drops below the configured threshold.

  Each of these parameters can be separately set for :local and :remote hosts (HostDistance). For :ignored hosts, the default for all those settings is 0 and cannot be changed.

  Each of the following configuration keys, take a map of {distance value} : ex:

  :core-connections-per-host {:remote 10 :local 100}
  

  • :core-connections-per-host Number
  • :max-connections-per-host Number
  • :max-requests-per-connection Number
  • :max-queue-size Number
  • :pool-timeout-millis Number
  • :connection-thresholds [[host-distance-kw value]+]

• :socket-options: a map of

  • :connect-timeout Number
  • :read-timeout Number
  • :receive-buffer-size Number
  • :send-buffer-size Number
  • :so-linger Number
  • :tcp-no-delay? Bool
  • :reuse-address? Bool
  • :keep-alive? Bool

• :query-options: a map of

  • :fetch-size Number
  • :consistency (consistency Keyword)
  • :serial-consistency (consistency Keyword)

• :jmx-reporting? Bool, enables/disables JMX reporting of the metrics.

  The handling of these options is achieved with a multimethod that you could extend if you need to handle some special case or want to create your own options templates. See qbits.alia.cluster-options/set-cluster-option! source

  The handling of the individual policy options is achieved with a multimethod in each of the policy namespaces that you could extend if you need to handle some special case or want to create your own policy options template. See - qbits.alia.policy.load-balancing/make - qbits.alia.policy.reconnection/make - qbits.alia.policy.retry/make - qbits.alia.policy.speculative-execution/make

  Values for consistency:

:all :any :each-quorum :local-one :local-quorum :local-serial :one :quorum :serial :three :two

Values for time-unit:

:days :hours :microseconds :milliseconds :minutes :nanoseconds :seconds

connect clj

(connect cluster)

(connect cluster keyspace)

Returns a new com.datastax.driver.core/Session instance. We need to have this separate in order to allow users to connect to multiple keyspaces from a single cluster instance

execute clj

(execute session query)

(execute session
         query
         {:keys [consistency serial-consistency routing-key retry-policy
                 result-set-fn row-generator tracing? idempotent? paging-state
                 fetch-size values timestamp read-timeout codec]})

Executes a query against a session. Returns a collection of rows.

The query can be a raw string, a PreparedStatement (returned by prepare) with values passed via the :values option key will be bound by execute, BoundStatement (returned by qbits.alia/bind).

The following options are supported:

• :values : values to be bound to a prepared query

• :consistency : Keyword, consistency

• :serial-consistency : Keyword, consistency

• :routing-key : ByteBuffer

• :retry-policy : one of qbits.alia.policy.retry/*

• :tracing? : Bool, toggles query tracing (available via query result metadata)

• :fetch-size : Number, sets query fetching size

• :timestamp : Number, sets the timestamp for query (if not specified in CQL)

• :idempotent? : Whether this statement is idempotent, i.e. whether it can be applied multiple times without changing the result beyond the initial application

• :paging-state : Expects a com.datastax.driver.core.PagingState instance. This will cause the next execution of this statement to fetch results from a given page, rather than restarting from the beginning

• :result-set-fn : Defaults to clojure.core/seq By default a result-set is an unchunked lazy seq, you can control this using this option. If you pass a function that supports IReduceInit you can have full control over how the resultset is formed (chunked, unchunked, eager or not, etc). A common use is to pass #(into [] %) as result-set-fn, you then get an eager value, with minimal copies, no intermediary seq and potentially better performance. This can be very powerfull when used right (for instance with transducers #(into [] xform %)).

• :row-generator : implements alia.codec/RowGenerator, Defaults to alia.codec/row-gen->map : A RowGenerator dicts how we construct rows.

• :codec : map of :encoder :decoder functions that control how to apply extra modifications on data sent/received (defaults to qbits.alia.codec/default).

• :read-timeout : Read timeout in milliseconds

  Possible values for consistency:

:all :any :each-quorum :local-one :local-quorum :local-serial :one :quorum :serial :three :two

execute-async clj

(execute-async session query)

(execute-async session
               query
               {:keys [executor consistency serial-consistency routing-key
                       retry-policy result-set-fn row-generator codec tracing?
                       idempotent? fetch-size values timestamp paging-state
                       read-timeout success error]})

Same execute but async and takes optional :success and :error callback functions via options. For options refer to qbits.alia/execute doc

lazy-query clj

(lazy-query session query pred)

(lazy-query session query pred opts)

Takes a session, a query (raw or prepared) and a query modifier fn (that receives the last query and last chunk and returns a new query or nil). The first chunk will be the original query result, then for each subsequent chunk the query will be the result of last query modified by the modifier fn unless the fn returns nil, which would causes the iteration to stop.

It also accepts any of execute options.

ex: (lazy-query session (select :items (limit 2) (where {:x (int 1)})) (fn [q coll] (merge q (where {:si (-> coll last :x inc)}))) {:consistency :quorum :tracing? true})

prepare clj

(prepare session query)

Takes a session and a query (raw string or hayt) and returns a com.datastax.driver.core.PreparedStatement instance to be used in execute after it's been bound with bind. Hayt query parameter will be compiled with qbits.hayt/->raw internaly ex: (prepare session (select :foo (where {:bar ?})))

prepare-async clj

(prepare-async session query {:keys [executor success error]})

Takes a session, a query (raw string or hayt) and success and error callbacks and prepares a statement asynchronously. If successful the success callback will receive the com.datastax.driver.core.PreparedStatement instance, otherwise the error callback will receive an Exception

register! clj

(register! cluster latency-tracker)

Register querylogger/latency tracker to cluster

shutdown clj

(shutdown x)

Shutdowns Session or Cluster instance, clearing the underlying pools/connections

tuple-encoder clj

(tuple-encoder session table column)

(tuple-encoder session ks table column)

(tuple-encoder session ks table column codec)

udt-encoder clj

(udt-encoder session type)

(udt-encoder session ks type)

(udt-encoder session ks type codec)

unregister! clj

(unregister! cluster latency-tracker)

Unregister querylogger/latency tracker from cluster