Methods related to resolving Toucan 2 models, appropriate table names to use when building queries for them, and namespaces to use for columns in query results.
Methods related to resolving Toucan 2 models, appropriate table names to use when building queries for them, and namespaces to use for columns in query results.
(default-connectable model₁)The default connectable that should be used when executing queries for model if
no toucan2.connection/*current-connectable* is currently bound. By default, this just returns the global default
connectable, :default, but you can tell Toucan to use a different default connectable for a model by implementing
this method.
default-connectable is defined in toucan2.model (toucan2/model.clj:42).
It caches methods using a methodical.impl.cache.watching.WatchingCache.
It uses the method combination methodical.impl.combo.threaded.ThreadingMethodCombination
with the threading strategy :thread-last.
It uses the dispatcher methodical.impl.dispatcher.multi_default.MultiDefaultDispatcher
with hierarchy #'clojure.core/global-hierarchy
and prefs {}.
The default value is :default.
It uses the method table methodical.impl.method_table.standard.StandardMethodTable.
These primary methods are known:
:default, defined in toucan2.model (toucan2/model.clj:50)
It has the following documentation:
Return nil, so we can fall thru to something else (presumably :default anyway)?
The default connectable that should be used when executing queries for `model` if
no [[toucan2.connection/*current-connectable*]] is currently bound. By default, this just returns the global default
connectable, `:default`, but you can tell Toucan to use a different default connectable for a model by implementing
this method.
default-connectable is defined in [[toucan2.model]] (toucan2/model.clj:42).
It caches methods using a `methodical.impl.cache.watching.WatchingCache`.
It uses the method combination `methodical.impl.combo.threaded.ThreadingMethodCombination`
with the threading strategy `:thread-last`.
It uses the dispatcher `methodical.impl.dispatcher.multi_default.MultiDefaultDispatcher`
with hierarchy `#'clojure.core/global-hierarchy`
and prefs `{}`.
The default value is `:default`.
It uses the method table `methodical.impl.method_table.standard.StandardMethodTable`.
These primary methods are known:
* `:default`, defined in [[toucan2.model]] (toucan2/model.clj:50)
It has the following documentation:
Return `nil`, so we can fall thru to something else (presumably `:default` anyway)?(model->namespace model₁)Return a map of namespaces to use when fetching results with this model.
(m/defmethod model->namespace ::my-model
[_model]
{::my-model "x"
::another-model "y"})
model->namespace is defined in toucan2.model (toucan2/model.clj:167).
It caches methods using a methodical.impl.cache.watching.WatchingCache.
It uses the method combination methodical.impl.combo.threaded.ThreadingMethodCombination
with the threading strategy :thread-last.
It uses the dispatcher methodical.impl.dispatcher.multi_default.MultiDefaultDispatcher
with hierarchy #'clojure.core/global-hierarchy
and prefs {}.
The default value is :default.
It uses the method table methodical.impl.method_table.standard.StandardMethodTable.
These primary methods are known:
:default, defined in toucan2.model (toucan2/model.clj:181)
It has the following documentation:
By default, don't namespace column names when fetching rows.
These aux methods are known:
:after methods:
:default, defined in toucan2.model (toucan2/model.clj:186)
It has the following documentation:
Validate the results.
Return a map of namespaces to use when fetching results with this model.
```clj
(m/defmethod model->namespace ::my-model
[_model]
{::my-model "x"
::another-model "y"})
```
model->namespace is defined in [[toucan2.model]] (toucan2/model.clj:167).
It caches methods using a `methodical.impl.cache.watching.WatchingCache`.
It uses the method combination `methodical.impl.combo.threaded.ThreadingMethodCombination`
with the threading strategy `:thread-last`.
It uses the dispatcher `methodical.impl.dispatcher.multi_default.MultiDefaultDispatcher`
with hierarchy `#'clojure.core/global-hierarchy`
and prefs `{}`.
The default value is `:default`.
It uses the method table `methodical.impl.method_table.standard.StandardMethodTable`.
These primary methods are known:
* `:default`, defined in [[toucan2.model]] (toucan2/model.clj:181)
It has the following documentation:
By default, don't namespace column names when fetching rows.
These aux methods are known:
`:after` methods:
* `:default`, defined in [[toucan2.model]] (toucan2/model.clj:186)
It has the following documentation:
Validate the results.(namespace model)Get the namespace that should be used to prefix keys associated with a model in query results. This is taken from the
model's implementation of model->namespace.
Get the namespace that should be used to prefix keys associated with a `model` in query results. This is taken from the model's implementation of [[model->namespace]].
(primary-key-values-map instance)(primary-key-values-map model m)Return a map of primary key values for a Toucan 2 instance.
Return a map of primary key values for a Toucan 2 `instance`.
(primary-keys model₁)Return a sequence of the primary key columns names, as keywords, for a model. The default primary keys for a model are
[:id]; implement this method if your model has different primary keys.
;; tell Toucan that :model/bird has a composite primary key consisting of the columns :id and :name
(m/defmethod primary-keys :model/bird
[_model]
[:id :name])
If an implementation returns a single keyword, the default :around method will automatically wrap it in a vector. It
also validates that the ultimate result is a sequence of keywords, so it is safe to assume that calls to this will
always return a sequence of keywords.
primary-keys is defined in toucan2.model (toucan2/model.clj:106).
It caches methods using a methodical.impl.cache.watching.WatchingCache.
It uses the method combination methodical.impl.combo.threaded.ThreadingMethodCombination
with the threading strategy :thread-last.
It uses the dispatcher methodical.impl.dispatcher.multi_default.MultiDefaultDispatcher
with hierarchy #'clojure.core/global-hierarchy
and prefs {}.
The default value is :default.
It uses the method table methodical.impl.method_table.standard.StandardMethodTable.
These primary methods are known:
:default, defined in toucan2.model (toucan2/model.clj:220)
It has the following documentation:
By default the primary key for a model is the column :id; or :some-namespace/id if the model defines a namespace
for itself with model->namespace.
These aux methods are known:
:around methods:
:default, defined in toucan2.model (toucan2/model.clj:125)
It has the following documentation:
If the PK comes back unwrapped, wrap it -- make sure results are always returned as a vector of keywords. Throw an error if results are in the incorrect format.
Return a sequence of the primary key columns names, as keywords, for a model. The default primary keys for a model are
`[:id]`; implement this method if your model has different primary keys.
```clj
;; tell Toucan that :model/bird has a composite primary key consisting of the columns :id and :name
(m/defmethod primary-keys :model/bird
[_model]
[:id :name])
```
If an implementation returns a single keyword, the default `:around` method will automatically wrap it in a vector. It
also validates that the ultimate result is a sequence of keywords, so it is safe to assume that calls to this will
always return a sequence of keywords.
primary-keys is defined in [[toucan2.model]] (toucan2/model.clj:106).
It caches methods using a `methodical.impl.cache.watching.WatchingCache`.
It uses the method combination `methodical.impl.combo.threaded.ThreadingMethodCombination`
with the threading strategy `:thread-last`.
It uses the dispatcher `methodical.impl.dispatcher.multi_default.MultiDefaultDispatcher`
with hierarchy `#'clojure.core/global-hierarchy`
and prefs `{}`.
The default value is `:default`.
It uses the method table `methodical.impl.method_table.standard.StandardMethodTable`.
These primary methods are known:
* `:default`, defined in [[toucan2.model]] (toucan2/model.clj:220)
It has the following documentation:
By default the primary key for a model is the column `:id`; or `:some-namespace/id` if the model defines a namespace
for itself with [[model->namespace]].
These aux methods are known:
`:around` methods:
* `:default`, defined in [[toucan2.model]] (toucan2/model.clj:125)
It has the following documentation:
If the PK comes back unwrapped, wrap it -- make sure results are always returned as a vector of keywords. Throw an
error if results are in the incorrect format.(resolve-model modelable₁)Resolve a modelable to an actual Toucan model (usually a keyword). A modelable is anything that can be resolved to
a model via this method. You can implement this method to define special model resolution behavior, for example
toucan2-toucan1 defines a method for clojure.lang.Symbol that does namespace resolution to return an appropriate
model keyword.
You can also implement this method to do define behaviors when a model is used, for example making sure some namespace with method implementation for the model is loaded, logging some information, etc.
resolve-model is defined in toucan2.model (toucan2/model.clj:18).
It caches methods using a methodical.impl.cache.watching.WatchingCache.
It uses the method combination methodical.impl.combo.threaded.ThreadingMethodCombination
with the threading strategy :thread-last.
It uses the dispatcher methodical.impl.dispatcher.multi_default.MultiDefaultDispatcher
with hierarchy #'clojure.core/global-hierarchy
and prefs {}.
The default value is :default.
It uses the method table methodical.impl.method_table.standard.StandardMethodTable.
These primary methods are known:
:default, defined in toucan2.model (toucan2/model.clj:29)
It has the following documentation:
Default implementation. Return modelable as is, i.e., there is nothing to resolve, and we can use it directly as a
model.
These aux methods are known:
:around methods:
:default, defined in toucan2.model (toucan2/model.clj:35)
It has the following documentation:
Log model resolution as it happens for debugging purposes.
Resolve a *modelable* to an actual Toucan *model* (usually a keyword). A modelable is anything that can be resolved to
a model via this method. You can implement this method to define special model resolution behavior, for example
`toucan2-toucan1` defines a method for `clojure.lang.Symbol` that does namespace resolution to return an appropriate
model keyword.
You can also implement this method to do define behaviors when a model is used, for example making sure some namespace
with method implementation for the model is loaded, logging some information, etc.
resolve-model is defined in [[toucan2.model]] (toucan2/model.clj:18).
It caches methods using a `methodical.impl.cache.watching.WatchingCache`.
It uses the method combination `methodical.impl.combo.threaded.ThreadingMethodCombination`
with the threading strategy `:thread-last`.
It uses the dispatcher `methodical.impl.dispatcher.multi_default.MultiDefaultDispatcher`
with hierarchy `#'clojure.core/global-hierarchy`
and prefs `{}`.
The default value is `:default`.
It uses the method table `methodical.impl.method_table.standard.StandardMethodTable`.
These primary methods are known:
* `:default`, defined in [[toucan2.model]] (toucan2/model.clj:29)
It has the following documentation:
Default implementation. Return `modelable` as is, i.e., there is nothing to resolve, and we can use it directly as a
model.
These aux methods are known:
`:around` methods:
* `:default`, defined in [[toucan2.model]] (toucan2/model.clj:35)
It has the following documentation:
Log model resolution as it happens for debugging purposes.(select-pks-fn modelable)Return a function to get the value(s) of the primary key(s) from a row, as a single value or vector of values. Used
by toucan2.select/select-pks-reducible and thus
by toucan2.select/select-pks-set, toucan2.select/select-pks-vec, etc.
The primary keys are determined by primary-keys. By default this is simply the keyword :id.
Return a function to get the value(s) of the primary key(s) from a row, as a single value or vector of values. Used by [[toucan2.select/select-pks-reducible]] and thus by [[toucan2.select/select-pks-set]], [[toucan2.select/select-pks-vec]], etc. The primary keys are determined by [[primary-keys]]. By default this is simply the keyword `:id`.
(table-name model₁)Return the actual underlying table name that should be used to query a model.
By default for things that implement name, the table name is just (keyword (name x)).
(t2/table-name :models/user)
;; =>
:user
You can write your own implementations for this for models whose table names do not match their name.
This is guaranteed to return a keyword, so it can easily be used directly in Honey SQL queries and the like; if you
return something else, the default :after method will convert it to a keyword for you.
table-name is defined in toucan2.model (toucan2/model.clj:55).
It caches methods using a methodical.impl.cache.watching.WatchingCache.
It uses the method combination methodical.impl.combo.threaded.ThreadingMethodCombination
with the threading strategy :thread-last.
It uses the dispatcher methodical.impl.dispatcher.multi_default.MultiDefaultDispatcher
with hierarchy #'clojure.core/global-hierarchy
and prefs {}.
The default value is :default.
It uses the method table methodical.impl.method_table.standard.StandardMethodTable.
These primary methods are known:
:default, defined in toucan2.model (toucan2/model.clj:75)
It has the following documentation:
Fallback implementation. Redirects keywords to the implementation for clojure.lang.Named (use the name of the
keyword). For everything else, throws an error, since we don't know how to get a table name from it.
clojure.lang.Named, defined in toucan2.model (toucan2/model.clj:91)
It has the following documentation:
Default implementation for anything that is a clojure.lang.Named, such as a keywords or symbols. Use the name as
the table name.
(t2/table-name :models/user) => :user
java.lang.String, defined in toucan2.model (toucan2/model.clj:101)
It has the following documentation:
Implementation for strings. Use the string name as-is.
These aux methods are known:
:after methods:
:default, defined in toucan2.model (toucan2/model.clj:84)
It has the following documentation:
Always return table names as keywords. This will facilitate using them directly inside Honey SQL, e.g.
{:select [:*], :from [(t2/table-name MyModel)]}
Return the actual underlying table name that should be used to query a `model`.
By default for things that implement `name`, the table name is just `(keyword (name x))`.
```clj
(t2/table-name :models/user)
;; =>
:user
```
You can write your own implementations for this for models whose table names do not match their `name`.
This is guaranteed to return a keyword, so it can easily be used directly in Honey SQL queries and the like; if you
return something else, the default `:after` method will convert it to a keyword for you.
table-name is defined in [[toucan2.model]] (toucan2/model.clj:55).
It caches methods using a `methodical.impl.cache.watching.WatchingCache`.
It uses the method combination `methodical.impl.combo.threaded.ThreadingMethodCombination`
with the threading strategy `:thread-last`.
It uses the dispatcher `methodical.impl.dispatcher.multi_default.MultiDefaultDispatcher`
with hierarchy `#'clojure.core/global-hierarchy`
and prefs `{}`.
The default value is `:default`.
It uses the method table `methodical.impl.method_table.standard.StandardMethodTable`.
These primary methods are known:
* `:default`, defined in [[toucan2.model]] (toucan2/model.clj:75)
It has the following documentation:
Fallback implementation. Redirects keywords to the implementation for `clojure.lang.Named` (use the `name` of the
keyword). For everything else, throws an error, since we don't know how to get a table name from it.
* `clojure.lang.Named`, defined in [[toucan2.model]] (toucan2/model.clj:91)
It has the following documentation:
Default implementation for anything that is a `clojure.lang.Named`, such as a keywords or symbols. Use the `name` as
the table name.
```clj
(t2/table-name :models/user) => :user
```
* `java.lang.String`, defined in [[toucan2.model]] (toucan2/model.clj:101)
It has the following documentation:
Implementation for strings. Use the string name as-is.
These aux methods are known:
`:after` methods:
* `:default`, defined in [[toucan2.model]] (toucan2/model.clj:84)
It has the following documentation:
Always return table names as keywords. This will facilitate using them directly inside Honey SQL, e.g.
{:select [:*], :from [(t2/table-name MyModel)]}(table-name->namespace model)Take the model->namespace map for a model and return a map of string table name -> namespace. This is used to
determine how to prefix columns in results based on their table name;
see toucan2.jdbc.result-set/instance-builder-fn for an example of this usage.
Take the [[model->namespace]] map for a model and return a map of string table name -> namespace. This is used to determine how to prefix columns in results based on their table name; see [[toucan2.jdbc.result-set/instance-builder-fn]] for an example of this usage.
cljdoc builds & hosts documentation for Clojure/Script libraries
| Ctrl+k | Jump to recent docs |
| ← | Move to previous article |
| → | Move to next article |
| Ctrl+/ | Jump to the search field |