cascalog.logic.def — cascalog/cascalog-core 3.0.0

This namespace contains the tools required to define custom Cascalog operations, instantiated with appropriate metadata.

aggregatefn clj macro

(aggregatefn & body)

aggregateop clj

aggregateop? clj

(aggregateop? op)

bufferfn clj macro

(bufferfn & body)

bufferiterfn clj macro

(bufferiterfn & body)

bufferiterop clj

bufferop clj

bufferop? clj

(bufferop? op)

defaggregatefn clj macro

(defaggregatefn name doc-string? attr-map? [fn-args*] body)

Defines a filtering operation.

defaggregateop clj macro

(defaggregateop sym__2971__auto__ & body__2972__auto__)

defbufferfn clj macro

(defbufferfn name doc-string? attr-map? [fn-args*] body)

Defines a filtering operation.

defbufferiterfn clj macro

(defbufferiterfn name doc-string? attr-map? [fn-args*] body)

Defines a filtering operation.

defbufferiterop clj macro

(defbufferiterop sym__2971__auto__ & body__2972__auto__)

defbufferop clj macro

(defbufferop sym__2971__auto__ & body__2972__auto__)

defdefop clj macro

(defdefop sym & body)

Helper macro to define the def*op macros.

defdeprecated clj macro

(defdeprecated old new)

deffilterfn clj macro

(deffilterfn name doc-string? attr-map? [fn-args*] body)

Defines a filtering operation.

deffilterop clj macro

(deffilterop sym__2971__auto__ & body__2972__auto__)

defhelper clj

(defhelper name op-sym body)

defmapcatfn clj macro

(defmapcatfn name doc-string? attr-map? [fn-args*] body)

Defines a mapcat operation.

defmapcatop clj macro

(defmapcatop sym__2971__auto__ & body__2972__auto__)

defmapfn clj macro

(defmapfn name doc-string? attr-map? [fn-args*] body)

Defines a map operation.

defmapop clj macro

(defmapop sym__2971__auto__ & body__2972__auto__)

defparallelagg clj macro

(defparallelagg name
                doc-string?
                attr-map?
                &
                {:keys [init-var combine-var present-var]})

Binds an efficient aggregator to the supplied symbol. A parallel aggregator processes each tuple through an initializer function, then combines the results each tuple's initialization until one result is achieved. defparallelagg accepts two keyword arguments:

:init-var -- A var bound to a fn that accepts raw tuples and returns an intermediate result; #'one, for example.

:combine-var -- a var bound to a fn that both accepts and returns intermediate results.

For example,

(defparallelagg sum :init-var #'identity :combine-var #'+)

Used as

(sum ?x :> ?y)

defparallelbuf clj macro

(defparallelbuf name
                doc-string?
                attr-map?
                &
                {:keys [init-var combine-var extract-var
                        num-intermediate-vars-fn buffer-var]})

filterfn clj macro

(filterfn & body)

filterop clj

mapcatfn clj macro

(mapcatfn & body)

mapcatop clj

mapfn clj macro

(mapfn & body)

mapop clj

parallelagg clj