$store = DBIx::NoSQL->connect( $path )

Returns a new DBIx::NoSQL store connected to the SQLite database located at $path

If the SQLite database file at $path does not exist, it will be created

$store->set( $model, $key, $value )

Set $key (a string) to $value (a HASH reference) in $model

If $model has index, this command will also update the index entry corresponding to $key.

The $key can be omitted, in which case a UUID key will be auto-generated for the entry.

Returns the new entry's key.

$value = $store->exists( $model, $key )

Returns true if some data for $key is present in $model

$value = $store->get( $model, $key )

Get $value matching $key in $model

$value = $store->delete( $model, $key )

Delete the entry matching $key in $model

If $model has index, this command will also delete the index entry corresponding to $key

$store->reindex

Reindex the searchable/orderable data in $store

This method is smart, in that it won't reindex a model unless the schema for $store is different/has changed. That is, if the schema for $store is the same as it is in the database, this call will do nothing

Refer to "Model USAGE" below for more information

$store->dbh

Return the DBI database handle for the store, if you need/want to do your own thing

$search = $store->search( $model, [ $where ] )

    $search = $store->search( 'Artist' => { name => { -like => 'Smashing%' } } )

Return a DBIx::NoSQL::Search object for $model, filtering on the optional $where

An index is required for the filtering columns

Refer to SQL::Abstract for the format of $where (actually uses DBIx::Class::SQLMaker under the hood)

@all = $search->all

Returns every result for $search in a list

Returns an empty list if nothing is found

$result = $search->next

Returns the next item found for $search via "$search->cursor"

Returns undef if nothing is left for $search

$sth = $search->cursor->sth

Returns the DBI sth (statement handle) for $search

$search = $search->search( $where )

Further refine the search in the same way "$search->where( ... )" does

$search = $search->where( $where )

    $search = $search->where( { genre => 'rock' } )

Further refine $search with the given $where

A new object is cloned from the original (the original $search is left untouched)

An index is required for the filtering columns

Refer to SQL::Abstract for the format of $where (actually uses DBIx::Class::SQLMaker under the hood)

$search = $search->order_by( $order_by )

    $search->order_by( 'name DESC' )
    $search->order_by([ 'name DESC', 'age' ])

Return the results in the given order

A new object is cloned from the original, which is left untouched

An index is required for the ordering columns

Refer to SQL::Abstract for the format of $order_by (actually uses DBIx::Class::SQLMaker under the hood)

$model = $store->model( $model_name )

Retrieve or create the $model_name model object

$model->index( $field_name )

    $store->model( 'Artist' )->index( 'name' ) # 'name' is now searchable/orderable, etc.

Index $field_name on $model

Every time the store for c<$model> is written to, the index will be updated with the value of $field

$model->index( $field_name, isa => $type )

    $store->model( 'Artist' )->index( 'website', isa => 'URI' )
    $store->model( 'Artist' )->index( 'founded', isa => 'DateTime' )

Index $field_name on $model as a special type/object (e.g. DateTime or URI)

Every time the store for c<$model> is written to, the index will be updated with the deflated value of $field (since JSON can not trivially serialize blessed references)

$model->reindex

Reindex the $model data in the store after making a field indexing change:

    1. Rebuild the DBIx::Class::ResultSource
    2. Drop and recreate the search table for $model
    3. Iterate through all the data for $model, repopulating the search table

If $model does not have an index, this method will simply return

To rebuild the index for _every_ model (on startup, for example), you can do:

    $store->reindex