NAME

Nano::Search - Persisted Index Search

ABSTRACT

Persisted Index Search

SYNOPSIS

use Nano::Nodes;
use Nano::Search;

my $nodes = Nano::Nodes->new(
  type => 'Nano::Node',
);

my $search = Nano::Search->new(
  nodes => $nodes,
);

# $search->count;

DESCRIPTION

This package provides a mechanism for searching a prior persisted index.

LIBRARIES

This package uses type constraints from:

Nano::Types

ATTRIBUTES

This package has the following attributes:

nodes

nodes(Nodes)

This attribute is read-only, accepts (Nodes) values, and is required.

orders

orders(ArrayRef[CodeRef])

This attribute is read-only, accepts (ArrayRef[CodeRef]) values, and is optional.

scopes

scopes(ArrayRef[CodeRef])

This attribute is read-only, accepts (ArrayRef[CodeRef]) values, and is optional.

table

table(Table)

This attribute is read-only, accepts (Table) values, and is optional.

METHODS

This package implements the following methods:

all

all() : ArrayRef[Object]

The all method returns all objects (qualified via scopes, when present) from the index.

all example #1

# given: synopsis

my $result = $search->all;

all example #2

# given: synopsis

use Nano::Node;

$search->nodes->set(Nano::Node->new);
$search->nodes->set(Nano::Node->new);

my $result = $search->all;

count

count() : Int

The count method returns the count of objects (qualified via scopes, when present) in the index.

count example #1

# given: synopsis

my $count = $search->count;

count example #2

# given: synopsis

use Nano::Node;

$search->nodes->set(Nano::Node->new);
$search->nodes->set(Nano::Node->new);

my $count = $search->count;

fetch

fetch(Int $size = 1) : ArrayRef[Object]

The fetch method returns a variable number of objects (qualified via scopes, when present) from the index.

fetch example #1

# given: synopsis

my $result = $search->fetch;

fetch example #2

# given: synopsis

use Nano::Node;

$search->nodes->set(Nano::Node->new);
$search->nodes->set(Nano::Node->new);

my $result = $search->fetch;

fetch example #3

# given: synopsis

use Nano::Node;

$search->nodes->set(Nano::Node->new);
$search->nodes->set(Nano::Node->new);
$search->nodes->set(Nano::Node->new);

my $result = $search->fetch(2);

first

first() : Maybe[Object]

The first method returns the first object (qualified via scopes, when present) from the index.

first example #1

# given: synopsis

my $first = $search->first;

first example #2

# given: synopsis

use Nano::Node;

$search->nodes->set(Nano::Node->new(id => '1st'));
$search->nodes->set(Nano::Node->new(id => '2nd'));
$search->nodes->set(Nano::Node->new(id => '3rd'));

my $first = $search->first;

last

last() : Maybe[Object]

The last method returns the last object (qualified via scopes, when present) from the index.

last example #1

# given: synopsis

my $last = $search->last;

last example #2

# given: synopsis

use Nano::Node;

$search->nodes->set(Nano::Node->new(id => '1st'));
$search->nodes->set(Nano::Node->new(id => '2nd'));
$search->nodes->set(Nano::Node->new(id => '3rd'));

my $last = $search->last;

next() : Maybe[Object]

The next method returns the next object based on the currently held cursor (qualified via scopes, when present) from the index.

next example #1

# given: synopsis

my $next = $search->next;

next example #2

# given: synopsis

use Nano::Node;

$search->nodes->set(Nano::Node->new(id => '1st'));
$search->nodes->set(Nano::Node->new(id => '2nd'));
$search->nodes->set(Nano::Node->new(id => '3rd'));

my $next = $search->next;

next example #3

# given: synopsis

use Nano::Node;

$search->nodes->set(Nano::Node->new(id => '1st'));
$search->nodes->set(Nano::Node->new(id => '2nd'));
$search->nodes->set(Nano::Node->new(id => '3rd'));

my $next;

$next = $search->next;
$next = $search->next;

order

order(ArrayRef[Object] $results) : ArrayRef[Object]

The order method determines the sort order of the array of objects provided based on the registered ordering routines.

order example #1

# given: synopsis

use Nano::Node;

my $results = [
  Nano::Node->new(id => '1st'),
  Nano::Node->new(id => '2nd'),
  Nano::Node->new(id => '3rd'),
];

$search = Nano::Search->new(
  nodes => $nodes,
  orders => [sub {
    my ($a, $b) = @_;
    $a->id cmp $b->id
  }],
);

$results = $search->order($results);

order example #2

# given: synopsis

use Nano::Node;

my $results = [
  Nano::Node->new(id => '1st'),
  Nano::Node->new(id => '2nd'),
  Nano::Node->new(id => '3rd'),
];

$search = Nano::Search->new(
  nodes => $nodes,
  orders => [sub {
    my ($a, $b) = @_;
    $b->id cmp $a->id
  }],
);

$results = $search->order($results);

prev() : Maybe[Object]

The prev method returns the previous object based on the currently held cursor (qualified via scopes, when present) from the index.

prev example #1

# given: synopsis

my $prev = $search->prev;

prev example #2

# given: synopsis

use Nano::Node;

$search->table->position(3);

$search->nodes->set(Nano::Node->new(id => '1st'));
$search->nodes->set(Nano::Node->new(id => '2nd'));
$search->nodes->set(Nano::Node->new(id => '3rd'));

my $prev = $search->prev;

prev example #3

# given: synopsis

use Nano::Node;

$search->table->position(3);

$search->nodes->set(Nano::Node->new(id => '1st'));
$search->nodes->set(Nano::Node->new(id => '2nd'));
$search->nodes->set(Nano::Node->new(id => '3rd'));

my $prev;

$prev = $search->prev;
$prev = $search->prev;

reset

reset() : Object

The reset method resets the position on the currently held cursor.

reset example #1

# given: synopsis

$search = $search->reset;

scope

scope(Object $object) : Maybe[Object]

The scope method determines whether the object provided passes-through the registered scopes and if-so returns the object provided.

scope example #1

# given: synopsis

use Nano::Node;

my $node = Nano::Node->new(id => '0000003');

my $result = $search->scope($node);

scope example #2

# given: synopsis

use Nano::Node;

$search = Nano::Search->new(
  nodes => $nodes,
  scopes => [sub {
    my ($node) = @_;
    $node->id ne '0000003'
  }],
);

my $node = Nano::Node->new(id => '0000003');

my $result = $search->scope($node);

scope example #3

# given: synopsis

use Nano::Node;

$search = Nano::Search->new(
  nodes => $nodes,
  scopes => [sub {
    my ($node) = @_;
    $node->id ne '0000003'
  }],
);

my $node = Nano::Node->new(id => '0000004');

my $result = $search->scope($node);

AUTHOR

Al Newkirk, awncorp@cpan.org

LICENSE

This is free software; you can redistribute it and/or modify it under the terms of the The Apache License, Version 2.0, as elucidated in the "license file".