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".