view release on metacpan or  search on metacpan

lib/DR/Tarantool/Spaces.pm  view on Meta::CPAN

    use DR::Tarantool::Spaces;
    my $s = new DR::Tarantool::Spaces({
            1   => {
                name            => 'users',         # space name
                default_type    => 'STR',           # undescribed fields
                fields  => [
                    qw(login password role),
                    {
                        name    => 'counter',
                        type    => 'NUM'
                    },
                    {
                        name    => 'something',
                        type    => 'UTF8STR',
                    },
                    {
                        name    => 'opts',
                        type    => 'JSON',
                    }
                ],
                indexes => {
                    0   => 'login',
                    1   => [ qw(login password) ],
                    2   => {
                        name    => 'my_idx',
                        fields  => 'login',
                    },
                    3   => {
                        name    => 'my_idx2',
                        fields  => [ 'counter', 'something' ]
                    }
                }
            },

            0 => {
                ...
            }
    });

    my $f = $s->pack_field('users', 'counter', 10);
    my $f = $s->pack_field('users', 3, 10);             # the same
    my $f = $s->pack_field(1, 3, 10);                   # the same

    my $ts = $s->pack_keys([1,2,3] => 'my_idx');
    my $t = $s->pack_primary_key([1,2,3]);


=head1 DESCRIPTION

The package describes all spaces used in an application.
It supports the following field types:

=over

=item NUM, NUM64, STR

The standard L<Tarantool|http://tarantool.org> types.

=item UTF8STR

The same as B<STR>, but the string is utf8-decoded 
after it's received from the server.

=item INT & INT64

The same as B<NUM> and B<NUM64>, but contain signed values.

=item JSON

The field is encoded with L<JSON::XS> when putting
into a database, and decoded after is received back 
from the server.

=back

=head1 METHODS

=head2 new

    my $spaces = DR::Tarantool::Spaces->new( $spaces );

=cut

sub new {
    my ($class, $spaces, %opts) = @_;

    $opts{family} ||= 1;

    $spaces = {} unless defined $spaces;
    croak 'spaces must be a HASHREF' unless 'HASH' eq ref $spaces;

    my (%spaces, %fast);
    for (keys %$spaces) {
        my $s = new DR::Tarantool::Space($_ => $spaces->{ $_ }, %opts);
        $spaces{ $s->name } = $s;
        $fast{ $_ } = $s->name;
    }

    return bless {
        spaces  => \%spaces,
        fast    => \%fast,
        family  => $opts{family},
    } => ref($class) || $class;
}


sub family {
    my ($self, $family) = @_;
    return $self->{family} if @_ == 1;
    $self->{family} = $family;
    $_->family($family) for values %{ $self->{spaces} };
    return $self->{family};
}


=head2 space

Return space object by number or name.

    my $space = $spaces->space('name');
    my $space = $spaces->space(0);

=cut

sub space {
    my ($self, $space) = @_;
    croak 'space name or number is not defined' unless defined $space;
    if ($space =~ /^\d+$/) {
        croak "space '$space' is not defined"
            unless exists $self->{fast}{$space};
        return $self->{spaces}{ $self->{fast}{$space} };