Creates a cache object of the given TTL and/or queue size. Optionally it can get an initial map of entries. Returns cache object encapsulated in an atom.

Removes entry or entries from the cache. Returns the updated cache from the atom.

Returns metadata value associated with :io.randomseed.utils.db/cache key for the function f.

Looks for the entry of the given ID in a cache which should be a cache object encapsulated in an atom. For multiple IDs, calls cache-lookup-coll. If the entry was not found, returns :io.randomseed.utils.db/not-found.

Looks for a collection of entries identified by the given ID in a cache which should be a cache object encapsulated in an atom. Returns a map with identifiers as keys and values for all found entries. Entries which are missing in the cache are grouped under the :io.randomseed.utils.db/not-found key as a list.

Prepares a cache object of the given TTL and/or queue size. Optionally it can get an initial map of entries. Returns a cache object.

Deletes the cached result of calling the given setting deleter. Purges cache entry after operation succeeded.

Gets the cached result of calling the given setting getter. Updates cache when necessary.

Sets the cached result of calling the given setting setter. Purges cache entry after operation succeeded.

Performs a cache lookup of id on cache and returns the hit. If there is no element found, returns the keyword :io.randomseed.utils.db/not-found.

Given a table name, a vector of column names, and a vector of row values (each row is a vector of its values), return a vector of the full INSERT SQL string and its parameters. Applies any :table-fn / :column-fn supplied in the options. If :suffix is provided in opts, that string is appended to the INSERT IGNORE ... statement. The IGNORE part can be replaced by supplying :alt-clause option key.

Given a table name and a hash map of column names and their values, return a vector of the full INSERT OR IGNORE SQL string and its parameters. Applies any :table-fn / :column-fn supplied in the options. If :suffix is provided in opts, that string is appended to the INSERT ... statement. If :alt-clause is provided in opts, it will replace the default IGNORE string.

Given a table name and a hash map of column names and their values, return a vector of the full REPLACE SQL string and its parameters. Applies any :table-fn / :column-fn supplied in the options. If :suffix is provided in opts, that string is appended to the INSERT ... statement.

Given a table name, a vector of column names, and a vector of row values (each row is a vector of its values), return a vector of the full REPLACE SQL string and its parameters. Applies any :table-fn / :column-fn supplied in the options. If :suffix is provided in opts, that string is appended to the REPLACE ... statement.

Returns a (possibly cached) sequence of maps requested using db-getter for the given IDs. A database connection and a table name can be passed to be used with the standard get-id getter function instead. When multiple IDs are given, calls get-cached-coll.

Returns a (possibly cached) sequence of maps requested using db-getter for the given IDs. When called with a table name it will be passed as a second argument to the given getter function. When no getter is given the standard one (get-ids) is used. Use make-getter-coll to create getter (with or without predefined table name).

Uses get-cached-coll to retrieve a map with keys being IDs and values being requested properties. If there is no data for the given ID, corresponding entry is not added to the resulting map. If the property does not exist, nil is added.

Same as get-cached but retrieves a single property from the result by using the get function. When multiple IDs are given it calls get-cached-coll-prop to handle it.

Same as get-cached-prop but when there is no entry for the given ID, it returns the given default value.

Returns true if getting from a database failed in post-processing phase (e.g. de-serialization) and the data were broken.

Gets properties of the given ID from a database table. For multiple IDs, calls get-ids.

Gets a map of ID-to-properties from a database for the given IDs and a table. Assumes each result will be related to a single, unique ID.

Tries to convert the given argument to a string identifier.

Converts the given ID retrieved from a database to a value suitable to be used in Clojure programs. If v is a number or a keyword, it is returned as is. Otherwise it is converted to a keyword.

Converts the given ID to a value suitable to be stored in a database. If v is a number, it is passed as is. Otherwise it is converted to a string.

Initializes single cache by parsing TTL and queue size.

Initializes in-memory caches by resetting atoms associated with cache parameters.

Syntactic sugar over execute! to make inserting columns/rows easier. Same as insert-or! but supports multiple rows to be inserted at once.

Syntactic sugar over execute-one! to make inserting hash maps easier. Given a connectable object, a table name, and a data hash map, inserts the data as a single row in the database and attempts to return a map of generated keys. By default it uses INSERT OR IGNORE but the IGNORE can be changed to anything by supplying :alt-clause option in opts map.

Syntactic sugar over execute-one! to make inserting hash maps easier. Given a connectable object, a table name, and a data hash map, inserts the data as a single row in the database and attempts to return a map of generated keys.

Syntactic sugar over execute! to make inserting columns/rows easier. Same as insert-multi! but supports :alt-clause option key.

Syntactic sugar over execute-one! to make inserting hash maps easier. Given a connectable object, a table name, and a data hash map, inserts the data as a single row in the database and attempts to return a map of generated keys.

Syntactic sugar over execute! to make inserting columns/rows easier. Same as insert-multi! but supports :alt-clause option key.

Invalidates cache associated with memoized function f. If key-params are given it should be a cache key sequence or other structure (usually function arguments). If only function is given, it clears the whole cache.

Invalidates cache associated with memoized function f. If key-params are given it should be a cache key sequence or other structure (usually function arguments), internally transformed to vector. If only function is given, it clears the whole cache. Supports functions memoized with memoize+.

Generates invalidation function for the given memoized function f. The invalidation function takes arguments in the same way as memoized function. If they match a value in the associated cache, the entry is evicted. Supports functions memoized with memoize and memoize+.

Creates a database getter suitable for use with get-cached-coll- family of functions. The returned function should accept an argument containing multiple identifiers.

Creates a setting deleter on a basis of the given table and entity column.

Returns a function which gets a setting for the given entity and de-serializes it to a Clojure data structure. Table name and entity column name must be quoted if needed before passing to this function.

Returns a function which stores one or more settings for a given entity in a database. Max. object size is 32 KB. Table name and entity column name must be quoted if needed before passing to this function.

Creates memoized version of a database accessing or other function. With only 1 argument defaults to a FIFO cache with length of 256 and TTL cache with expiration of 150 seconds. When 2 arguments are given it only creates FIFO cache of the given length, without TTL. When queue-size is nil or <= 0, the FIFO cache will not be created. When ttl is nil or <= 0, the TTL cache will not be created.

Wrapper around clojure.core.memoize/fifo which uses fast, map-based memoization for cache size up to level1-size size, and then switches to slower memoization based on FIFO cache of level2-size size. The first level of cache is never purged automatically; once an element is there, it stays.

If only one size is given (size), the level-1 cache size will be set to 70% of it, and level-2 cache to 30% of it.

If no size is given, the level-1 cache will have a size of 89000 elements and level-2 cache will have a size of 39000 elements; both having a size of 128000 elements in total.

Be aware that caching key in level-1 cache is a vector of all arguments unless the argument count is greater than 8. In such case all extra arguments (expressed with native Clojure structure used for variadic function arguments) are grouped as 9th element of this vector.

To control caches associated with original function, use a metadata of the returned function object.

Returns true if the given function f is memoized using memoize+. If not, returns false.

Creates a memoized functions with predefined TTL and queue size taken from config. If the function is not given it will try to dereference symbol present in the config under the :memoizer key. Uses io.randomseed.utils.db/memoize to initialize caches.

Returns true when the given value equals to :io.randomseed.utils.db/not-found.

Removes cache structures.

Syntactic sugar over execute-one! to make inserting hash maps easier. Given a connectable object, a table name, and a data hash map, inserts the data as a single row in the database and attempts to return a map of generated keys. By default it uses REPLACE.

Syntactic sugar over execute! to make inserting columns/rows easier. Same as replace! but supports multiple rows to be inserted at once.