Relic

https://github.com/wotbrew/relic
Admin
Relic is a Clojure(Script) data structure providing a functional relational programming model with...
Tokens:22,182
Snippets:65
Trust Score:8.5
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### Clojure Join Syntax and Example

Source: https://github.com/wotbrew/relic/blob/master/doc/join.md

Defines the syntax for the :join operation in Clojure, specifying the structure for the right-hand side of the join and the join clause. Includes an example of joining a :Customer table with an :Order table.

```clojure
join = [:join right clause & more]
right = query | table
clause = {left-expr right-expr, ...}
```

```clojure
[[:from :Customer]
 [:join :Order {:id :customer-id}]]
```

--------------------------------

### Install relic with Leiningen

Source: https://github.com/wotbrew/relic/blob/master/README.md

This snippet shows how to add the relic library to your project dependencies using Leiningen, a build automation tool for Clojure.

```clojure
com.wotbrew/relic "0.1.7"
```

--------------------------------

### Clojure :insert-or-replace Example

Source: https://github.com/wotbrew/relic/blob/master/doc/insert-or-replace.md

Demonstrates inserting a new customer record and then replacing an existing record with the same ID using the :insert-or-replace transact form in Clojure. It shows how the entire row is replaced on conflict.

```clojure
(def db (rel/mat {} [[:from :Customer] [:unique :id]]))

;; if there is no conflict, its just insert
(def db (rel/transact db [:insert-or-replace :Customer {:id 42, :name "bob", :age 33}}]))
;; => 
{:Customer #{{:id 42, :name "bob", :age 33}}}

;; with a conflict, the whole row will be replaced - we will change the name, and 
;; drop :age.
(rel/transact db [:insert-or-replace :Customer {:id 42, :name "alice"}])
;; =>
{:Customer #{{:id 42, :name "alice"}}}
```

--------------------------------

### Install relic with Clojure CLI (deps.edn)

Source: https://github.com/wotbrew/relic/blob/master/README.md

This snippet demonstrates how to include the relic library in your Clojure project by specifying it in the deps.edn file for use with the Clojure CLI.

```clojure
com.wotbrew/relic {:mvn/version "0.1.7"}
```

--------------------------------

### Relic: Get Environment Map

Source: https://github.com/wotbrew/relic/blob/master/doc/env.md

Provides the function to retrieve the entire environment map from a Relic database instance. The output shows an example of the environment map containing a 'now' key with a timestamp.

```clojure
;; get the env map
(rel/get-env db)
;; =>
{:now 1640787329215}
```

--------------------------------

### Relic: Update Environment Map

Source: https://github.com/wotbrew/relic/blob/master/doc/env.md

Illustrates how to update the Relic environment map by applying a function to it. This example uses the 'assoc' function to update the 'now' key with the current system time.

```clojure
;; apply a fn to the env map
(rel/update-env db assoc :now (System/currentTimeMillis))
```

--------------------------------

### set-concat Aggregation Example in Clojure

Source: https://github.com/wotbrew/relic/blob/master/doc/set-concat.md

This example shows how to use the `set-concat` aggregation function to combine sets of values from rows within a group. It includes the query, the state data, and the expected results.

```clojure
;; QUERY
[:from :OrderItem]
[:agg [:order-id] [:items [rel/set-concat :%]]]

;; STATE 
{:OrderItem #{{:order-id 0, :product "bread", :qty 2},
              {:order-id 0, :product "eggs", :qty 1}}}
              
;; RESULTS
({:order-id 0, :items #{{:order-id 0, :product "bread", :qty 2}, {:order-id 1, :product "eggs", :qty 1}}})
```

--------------------------------

### Relic Aggregation Example

Source: https://github.com/wotbrew/relic/blob/master/doc/agg.md

Demonstrates how to use the :agg operator in Relic to group customer orders by 'customer-id' and calculate total spend, average spend, and order count. It shows the input data structure and the expected output.

```clojure
[:from :Order]
 [:agg
  ;; the first arg to :agg is the grouping vector
  ;; the columns to group by (can be empty for all rows)
  [:customer-id]
  
  ;; the rest of the args are aggregate extensions to the grouped
  ;; columns
  [:total-spend [rel/sum :total]]
  [:average-spend [rel/avg :total]]
  [:order-count count]]
```

--------------------------------

### Clojure Count Aggregate Function Example

Source: https://github.com/wotbrew/relic/blob/master/doc/count.md

This snippet demonstrates the usage of the `clojure.core/count` aggregate function to count orders and refunded orders for customers. It includes the query, state, and expected result.

```clojure
;; QUERY
[[:from :Order]
 [:agg [:customer-id]
  [:number-of-orders count]
  [:number-of-refunded-orders [count :refunded]]]]
  
;; STATE
{:Order [{:customer-id 42, :order-id 0}, {:customer-id 42, :order-id 1, :refunded true}]}

;; RESULT
[{:customer-id 42, :number-of-orders 2, :number-of-refunded-orders 1}]
```

--------------------------------

### Relic: Reference Environment in Queries

Source: https://github.com/wotbrew/relic/blob/master/doc/env.md

Shows how to access values from the Relic environment within queries using the Frel/env special expression form. This example retrieves the 'now' value from the environment and divides it by 1000.

```clojure
;; you can reference the environment in queries with the Frel/env special expression form
[:select [:seconds [/ [rel/env :now] 1000]]]
```

--------------------------------

### Clojure :insert-ignore Transaction Example

Source: https://github.com/wotbrew/relic/blob/master/doc/insert-ignore.md

Demonstrates the usage of the :insert-ignore transact form in Clojure. It shows how to insert a new row when there is no conflict and how a new row is discarded when a unique key conflict arises.

```clojure
(def db (rel/mat {} [[:from :Customer] [:unique :id]]))

;; if there is no conflict, its just insert
(def db (rel/transact db [:insert-ignore :Customer {:id 42, :name "bob", :age 33}}]))
;; => 
{:Customer #{{:id 42, :name "bob", :age 33}}}

;; with a conflict, the new row will be discarded.
(rel/transact db [:insert-ignore :Customer {:id 42, :name "alice"}])
;; =>
{:Customer #{{:id 42, :name "bob", :age 33}}}
```

--------------------------------

### Clojure Example Query for TPC-H Benchmark

Source: https://github.com/wotbrew/relic/blob/master/doc/query.md

This Clojure code snippet demonstrates a query from the TPC-H benchmark suite using Relic's vector-based query definition. It includes operations for selecting data from 'lineitem', filtering by ship date, and performing various aggregations.

```clojure
;; example query from the tpc-h benchmark suite
[:from :lineitem]
 [:where [<= :l_shipdate #inst "1998-09-02"]]
 [:agg
   [:l_returnflag
    :l_linestatus]
 [:sum_qty [rel/sum :l_quantity]]
 [:sum_base_price [rel/sum :l_extendedprice]]
 [:sum_disc_price  [rel/sum [* :l_extendedprice [- 1 :l_discount]]]]
 [:sum_charge [rel/sum [* :l_extendedprice [- 1 :l_discount] [+ 1 :l_tax]]]]
 [:avg_qty [rel/avg :l_quantity]]
 [:avg_price [rel/avg :l_extendedprice]]
 [:avg_disc [rel/avg :l_discount]]
 [:count_order count]]
```

--------------------------------

### Relic :update with Set-Map and Function

Source: https://github.com/wotbrew/relic/blob/master/doc/update.md

Illustrates using a SQL-style set-map with a function in the value position for the :update transact operation. This example also increments the 'n' column.

```clojure
;; a set map can be terser, it takes functions/relic-expressions in value position. 
(rel/transact db [:update :Counter {:n [inc :n]}])
;; =>
{:Counter #{{:n 1}}}
```

--------------------------------

### Relic: SQL-style EXISTS check with rel/sel1

Source: https://github.com/wotbrew/relic/blob/master/doc/sub-queries.md

Illustrates using `rel/sel1` for a SQL-style EXISTS check. This example defines a query to find customers who have associated orders by checking for the existence of records in the 'Order' table linked by 'customer-id'.

```clojure
(def CustomersWithOrders
  [[:from :Customer] 
   [:where [rel/sel1 :Order {:customer-id :customer-id}]]])
```

--------------------------------

### Relic :update with Filtered Updates

Source: https://github.com/wotbrew/relic/blob/master/doc/update.md

Demonstrates applying the :update transact operation with a set-map and a filter condition. The first example increments 'n' only if 'n' is even, and the second only if 'n' is odd.

```clojure
;; additional expresssions can be passed as args to filter updated rows
(rel/transact db [:update :Counter {:n [inc :n]} [even? :n]])
;; => {:Counter #{{:n 1}}}
(rel/transact db [:update :Counter {:n [inc :n]} [odd? :n]])
;; => {:Counter #{{:n 0}}}
```

--------------------------------

### Get Top 5 Players by Score using top-by

Source: https://github.com/wotbrew/relic/blob/master/doc/top-by.md

This snippet demonstrates how to use the 'top-by' aggregate function to retrieve the top 5 players based on their 'score'. It includes the query, the state data, and the expected result.

```clojure
;; QUERY
[[:from :Player]
 [:agg [] [:highest-scoring [rel/top-by 5 :score]]]]

;; STATE
{:Player [{:score 1
           :name "alice"}
          {:score 200
           :name "bob"}
          {:score 4323
           :name "fred"}
          {:score 5555
           :name "hannah"}
          {:score 4242
           :name "george"}
          {:score -123
           :name "isabel"}
          {:score 330
           :name "dave"}]}

;; RESULT 
({:highest-scoring [{:score 5555, :name "hannah"}
                    {:score 4323, :name "fred"}
                    {:score 4242, :name "george"}
                    {:score 330, :name "dave"}
                    {:score 200, :name "bob"}]})
```

--------------------------------

### Get Lowest 5 Players by Score using bottom-by

Source: https://github.com/wotbrew/relic/blob/master/doc/bottom-by.md

This snippet demonstrates how to use the `rel/bottom-by` function to retrieve the 5 players with the lowest scores. It includes the query, the state data, and the expected result.

```clojure
;; QUERY
[[:from :Player]
 [:agg [] [:lowest-scoring [rel/bottom-by 5 :score]]]]

;; STATE
{:Player [{:score 1
           :name "alice"}
          {:score 200
           :name "bob"}
          {:score 4323
           :name "fred"}
          {:score 5555
           :name "hannah"}
          {:score 4242
           :name "george"}
          {:score -123
           :name "isabel"}
          {:score 330
           :name "dave"}]}

;; RESULT 
 [{:lowest-scoring [{:score -123, :name "isabel"}
                    {:score 1, :name "alice"}
                    {:score 200, :name "bob"}
                    {:score 330, :name "dave"}
                    {:score 4242, :name "george"}]}]
```

--------------------------------

### Define and Use Foreign Key Constraint in Clojure

Source: https://github.com/wotbrew/relic/blob/master/doc/fk.md

Demonstrates how to define a foreign key constraint in Clojure using Relic's syntax. It shows examples of valid transactions that adhere to the constraint and an invalid transaction that violates it, resulting in a foreign key violation.

```clojure
(def OrderMustReferToACustomer
  [[:from :Order] [:fk :Customer {:customer-id :customer-id}]])
  
(def db (rel/mat {} OrderMustReferToACustomer))

;; this is fine
(rel/transact db [:insert :Customer {:customer-id 42}] [:insert :Order {:customer-id 42}])

;; this is also fine, you can insert out-of-order.
(rel/transact db [:insert :Order {:customer-id 42}] [:insert :Customer {:customer-id 42}])

;; BOOM! Foreign key violation
(rel/transact db [:insert :Order {:customer-id "woops"}])
```

--------------------------------

### Initialize Empty Relic Database

Source: https://github.com/wotbrew/relic/blob/master/README.md

Illustrates the creation of an empty database in Relic, represented as a simple Clojure map.

```clojure
(def db {})
```

--------------------------------

### Query All Customers

Source: https://github.com/wotbrew/relic/blob/master/README.md

Shows how to query all records from the 'Customer' table in the Relic database.

```clojure
(rel/q db :Customer)
;; => 
({:name "bob"}, {:name "alice"})
```

--------------------------------

### Insert Data into Relic Database

Source: https://github.com/wotbrew/relic/blob/master/README.md

Demonstrates how to insert data into the 'Customer' table using the `transact` function, returning an updated database.

```clojure
(def db (rel/transact {} [:insert :Customer {:name "bob"} {:name "alice"}]))

db 
;; =>
{:Customer #{{:name "bob"}, {:name "alice"}}}
```

--------------------------------

### Execute Shell Command Safely with Clojure

Source: https://github.com/wotbrew/relic/blob/master/doc/security.md

Demonstrates how to safely execute a shell command using Clojure within the relic framework. It highlights the potential security risks of arbitrary evaluation and the need for careful handling of untrusted input.

```clojure
[sh/sh "rm" "-rf" "/"]
```

--------------------------------

### Relic :update with Function

Source: https://github.com/wotbrew/relic/blob/master/doc/update.md

Demonstrates using the :update transact operation with a Clojure function to modify a row. The example shows incrementing a numeric column 'n' in the 'Counter' table.

```clojure
(def db 
  (rel/transact {} {:Counter [{:n 0}]}))
  
;; functions can be used
(rel/transact db [:update :Counter #(update % :n inc)])
;; =>
{:Counter #{{:n 1}}}
```

--------------------------------

### Basic Relic Query

Source: https://github.com/wotbrew/relic/blob/master/README.md

Demonstrates a simple query to retrieve data from the 'Customer' table, filtering by name.

```clojure
[:from :Customer]
  [:where [= :name "bob"]]
```

--------------------------------

### Create Sorted Index with :btree in Clojure

Source: https://github.com/wotbrew/relic/blob/master/doc/btree.md

This snippet demonstrates how to create a sorted index using the :btree operation in Clojure for the wotbrew/relic library. It shows the query structure, the initial state of the data, and the resulting sorted index, which supports subseq and rsubseq operations.

```clojure
;; QUERY
;; you index expressions, here I am going to use a single expression, 
;; but I could use multiple and get a nested map, e.g [:btree :a, :b, :c]
[[:from :Event] 
 [:btree :ts]]

;; STATE
{:Event [{:ts 0, :msg "hello"}
         {:ts 1, :msg ", world"}
         {:ts 2, :msg "!"}]}
         
;; INDEX
;; a sorted map, that supports subseq and rsubseq
;; get with rel/index
{0 #{{:ts 0, :msg "hello"}}
 1 #{{:ts 1, :msg ", world"}}
 2 #{{:ts 2, :msg "!"}}}
```

--------------------------------

### Relic: Replace Environment with a Map

Source: https://github.com/wotbrew/relic/blob/master/doc/env.md

Demonstrates how to replace the current Relic environment with a new map containing specific parameters, such as the current time. This function returns a new database instance with the updated environment.

```clojure
;; replaces the environment with the given map, returning a new db
(rel/with-env db {:now (System/currentTimeMillis)})
```

--------------------------------

### Query with Aggregation

Source: https://github.com/wotbrew/relic/blob/master/README.md

Demonstrates how to perform aggregations, such as calculating the average length of names in the 'Customer' table.

```clojure
(rel/q db [[:from :Customer] [:agg [] [:avg-name-len [rel/avg [count :name]]]]]) 
;; => 
({:avg-name-len 4})
```

--------------------------------

### Get Lowest 5 Scores using bottom

Source: https://github.com/wotbrew/relic/blob/master/doc/bottom.md

This snippet demonstrates how to use the 'bottom' aggregate function in Relic to find the 5 lowest scores from a 'Player' table. It includes the query, the state of the data, and the expected output.

```clojure
;; QUERY
[[:from :Player]
 [:agg [] [:lowest-scores [rel/bottom 5 :score]]]]

;; STATE
{:Player [{:score 1}
          {:score 200}
          {:score 4323}
          {:score 5555}
          {:score 4242}
          {:score -123}
          {:score 330}]}

;; EXPECTED
[{:lowest-scores [-123
                  1
                  200
                  330
                  4242]}]
```

--------------------------------

### Insert into Multiple Tables with Terser Syntax (Clojure)

Source: https://github.com/wotbrew/relic/blob/master/doc/terse-insert.md

Demonstrates the terse input form for inserting data into 'Customer' and 'Order' tables within a single transaction. It shows the equivalent operation using individual insert statements for comparison.

```clojure
(rel/transact db {:Customer [{:id 0, :name "Fred"}], :Order [{:customer 0, :total 10.0M}]})
```

```clojure
(rel/transact db [:insert :Customer {:id 0, :name "Fred"}] [:insert :Order {:customer 0, :total 10.0M}])
```

--------------------------------

### Materialize a Relic Query

Source: https://github.com/wotbrew/relic/blob/master/README.md

Shows how to materialize a query, ensuring that the results are automatically maintained as the database changes.

```clojure
(rel/mat db [[:from :Customer] [:where [= :name "bob"]]])
;; => returns the database, its value will be the same, but internally some machinery will have been allocated.
{:Customer #{{:name "bob"}, {:name "alice"}}}
```

--------------------------------

### Clojure: Track Transaction Changes with Relic

Source: https://github.com/wotbrew/relic/blob/master/doc/change-tracking.md

This snippet demonstrates how to enable change tracking for a query using `rel/watch`, then track a transaction with `rel/track-transact` to observe changes. It shows how to define a query, update the database, and interpret the returned changes, including added and deleted rows for watched queries. Finally, it shows how to unwatch a query.

```clojure
;; given a query we are interested in watching
(def ViewModel 
  [[:from :User]
   [:where :selected]])
   
;; lets assume the state looks like this:
{:User [{:user "alice", :selected false}
        {:user "bob", :selected false}]}

;; enable change tracking for our query with watch
;; this returns a new relic database, don't worry its totally pure!
(def db (rel/watch db ViewModel))   
  
;; now we have a watched query, we can track-transact and receive changes to it.
(rel/track-transact db [:update :User {:selected true} [= :user "bob"]])
;; =>
{
 ;; the first key is just the :db as with the transactions applied
 :db {:User #{{:user "alice", :selected false}, {:user "bob", :selected true}}},
 ;; you also get a :changes key, which is the map of {query changes} for all watched queries
 :changes
  {
   ;; our watched ViewModel query from earlier
   [[:from :User]
    [:where :selected]] 
    
   ;; added rows and deleted rows are returned.
   {:added [{:user "bob", :selected true}],
    :deleted []}}}
    
    
;; you can unwatch
(def db (rel/unwatch db ViewModel))
```

--------------------------------

### Flatten Nested Order Items in Clojure

Source: https://github.com/wotbrew/relic/blob/master/doc/expand.md

This example demonstrates how to use Relic's :expand functionality in Clojure to flatten nested 'order' maps. It shows the initial nested structure and the resulting flat structure where order items are treated as individual records.

```clojure
;; In this example, Order contains nested 'order' maps with an :items collection.
(rel/q db Order)
;; =>
#{{:customer-id 42, 
  :items [{:product 1, :quantity 2}, {:product 2, :quantity 1}]}}

;; I want to see OrderItems as their own relation, so I :expand them.
(def OrderItem
  [[:from :Order] 
   [:expand [[:product :quantity] :items]]
   [:without :items]])
   
;; You can see the expansion columns are included along with the order header columns.   
(rel/q db OrderItem)
;; =>
#{{:customer-id 42, :product 1, :quantity 2}, {:customer-id 42, :product 2, :quantity 1}}
```

--------------------------------

### Insert Rows into Table with :insert

Source: https://github.com/wotbrew/relic/blob/master/doc/insert.md

Demonstrates how to use the :insert transact form to add multiple rows to a table named :Food. It shows the initial database state and the resulting database after the transaction.

```clojure
(def db {})

(rel/transact db [:insert :Food {:name "pizza"}, {:name "pie"}])
;; =>
{:Food #{{:name "pizza"}, {:name "pie"}}}
```

--------------------------------

### Using Clojure Functions in Relic

Source: https://github.com/wotbrew/relic/blob/master/doc/expr.md

Demonstrates how to integrate custom Clojure functions for predicates, column computations, and expansions within Relic queries. Functions must be referentially transparent.

```clojure
;; you can use any function as an expression

(defn my-pred? [{:keys [foo]}] (= foo 42))

[[:from :A] [:where my-pred?]]

;; same rules apply to computing columns

(defn compute-bar [{:keys [foo]}] (inc foo))

[[:from :A] [:extend [:bar compute-bar]]

[[:from :A] [:select [:bar compute-bar]]

;; and expansions
(defn compute-baz-seq [{:keys [foo]}] (range foo))

[[:from :A] [:expand [:baz compute-baz-seq]]
```

--------------------------------

### Require Relic Library

Source: https://github.com/wotbrew/relic/blob/master/README.md

This snippet shows how to import the Relic library into a Clojure project using a namespace alias.

```clojure
(require '[com.wotbrew.relic :as rel])
```

--------------------------------

### Clojure: Insert or Update Customer Data

Source: https://github.com/wotbrew/relic/blob/master/doc/insert-or-update.md

Demonstrates inserting a new customer record. If a customer with the same ID already exists, it applies an update function to increment the 'updates' field of the existing record.

```clojure
(def db (rel/mat {} [[:from :Customer] [:unique :id]]))

;; if there is no conflict, its just insert
(def db (rel/transact db [:insert-or-update :Customer {:updates [inc [:or :updates 0]]} {:id 42, :name "bob", :age 33}}]))
;; => 
{:Customer #{{:id 42, :name "bob", :age 33}}}

;; with a conflict, the function (or set map) will be applied to the OLD row, and the new row will be discarded.
(rel/transact db [:insert-or-replace :Customer {:updates [inc [:or :updates 0]]} {:id 42, :name "alice"}])
;; =>
{:Customer #{{:id 42, :name "bob", :age 33, :updates 1}}}
```

--------------------------------

### Advanced Relic Query with Extension

Source: https://github.com/wotbrew/relic/blob/master/README.md

Shows how to extend a query to include computed columns, such as a greeting message based on the customer's name.

```clojure
[:from :Customer]
 [:where [= :name "bob"]]
 [:extend [:greeting [str "Hello, " :name "!"]]]
```

--------------------------------

### Relic: Select OrderItems using rel/sel

Source: https://github.com/wotbrew/relic/blob/master/doc/sub-queries.md

Demonstrates using `rel/sel` to select all OrderItems associated with a specific Order. This involves a query to select from the 'Order' table and a sub-query to fetch related items from the 'OrderItem' table.

```clojure
;; QUERY
[[:from :Order]
 [:select :order-id [:items [rel/sel :OrderItem {:order-id :order-id}]]]]

;; STATE
{:Order #{{:order-id 0}}
 :OrderItem #{{:order-id 0, :product "eggs"}, {:order-id 0, :product "bread"} {:order-id 1, :product "cheese"}}}

;; RESULTS
[{:order-id 0, :items #{{:order-id 0, :product "eggs"}, {:order-id 0, :product "bread"}}}]
```

--------------------------------

### Clojure: Create Unique Index on Customer Name

Source: https://github.com/wotbrew/relic/blob/master/doc/unique.md

This snippet demonstrates how to create a unique index on the 'name' field of 'Customer' records using the :unique operation in Wotbrew Relic. It includes the query to define the index, the initial state of the data, and the resulting index structure.

```clojure
;; QUERY
;; you index expressions, here I am going to use a single expression, 
;; but I could use multiple and get a nested map, e.g [:unique :a, :b, :c]
[[:from :Customer] 
 [:unique :name]]

;; STATE
{:Customer [{:name "bob", :age 42}
            {:name "alice", :age 23}]}
         
;; INDEX
;; a clojure map
;; get with rel/index
{"bob" {:name "bob", :age 42}
 "alice" {:name "alice", :age 23}}
```

--------------------------------

### Create Hash Index for Customer Name in Clojure

Source: https://github.com/wotbrew/relic/blob/master/doc/hash.md

This snippet demonstrates how to create a hash index on the 'name' field of the 'Customer' entity using Relic's :hash operation. It includes the query to create the index, the initial state of the data, and the resulting index structure, which is a Clojure map.

```Clojure
;; QUERY
;; you index expressions, here I am going to use a single expression, 
;; but I could use multiple and get a nested map, e.g [:hash :a, :b, :c]
[[:from :Customer] 
 [:hash :name]]

;; STATE
{:Customer [{:name "bob", :age 42}
            {:name "alice", :age 23}]}
         
;; INDEX
;; a clojure map
;; get with rel/index
{"bob" #{{:name "bob", :age 42}}
 "alice" #{{:name "alice", :age 23}}}
```

--------------------------------

### Relic: Define Time Views from Environment

Source: https://github.com/wotbrew/relic/blob/master/doc/env.md

Demonstrates defining derived views for time-related data within Relic, using values from the environment. It includes functions to convert epoch milliseconds to an Instant and to a local date-time for a specific zone.

```clojure
(defn instant [ms] (Instant/ofEpohMilli ms))
(defn local-date-time [instant zone] (LocalDateTime/ofInstant instant (ZoneId/of zone)))

(def Time 
 [[:select 
   [:time/epoch-ms [rel/env :now]]
   [:time/instant [instant :time/epoch-ms]]
   [:time/london [local-date-time :time/instant "Europe/London"]]])
```

--------------------------------

### Preventing Data Exfiltration with Relic Column Keywords

Source: https://github.com/wotbrew/relic/blob/master/doc/security.md

Explains how column keywords in relic expressions can be used for data exfiltration and advises caution when using untrusted input to construct them. It suggests using the :_ sentinel as a safeguard.

```clojure
[:extend [:my-col untrusted]]
```

--------------------------------

### Clojure: Combine Multiple Constraints

Source: https://github.com/wotbrew/relic/blob/master/doc/constraints.md

This Clojure code snippet shows how to use the ':constrain' operator to combine multiple constraints on a 'Customer' query. It includes a check for string types for 'firstname' and 'lastname', a check for 'age' being a natural integer, and a unique constraint on 'customer-id', along with a foreign key constraint to the 'Address' table.

```clojure
[:from Customer]
 [:constrain
   [:check [string? :firstname] [string? :lastname] [nat-int? :age]]
   [:unique :customer-id]
   [:fk Address {:address-id :address-id}]]
```

--------------------------------

### Clojure: Apply Order Item Count Constraint

Source: https://github.com/wotbrew/relic/blob/master/doc/constraints.md

This Clojure code snippet demonstrates how to apply a constraint to an 'Order' query. It ensures that an order associated with a customer named 'bob' on a Tuesday can have at most 10 items. If the condition is not met, it throws a descriptive error.

```clojure
[:from Order]
 [:join Customer {:customer-id :customer-id}]
 [:where [= "bob" :firstname] [tuesday? [rel/env :now]]]
 [:check {:pred [<= [count :items] 10],
          :error [str "order can have at most 10 items if its associated customer is called bob and its tuesday, found: " [count :items]]}]
```
Tokens:
Raw