ArangoDB

 view release on metacpan or  search on metacpan

lib/ArangoDB/AbstractDocument.pm  view on Meta::CPAN

package ArangoDB::AbstractDocument;
use strict;
use warnings;
use utf8;
use 5.008001;
use Scalar::Util qw(weaken);

use overload
    q{""}    => sub { shift->document_handle },
    fallback => 1;

sub new {
    my ( $class, $conn, $doc ) = @_;
    die "Invalid argument for $class : undef" unless defined $doc;
    my $self = bless { connection => $conn, }, $class;
    weaken( $self->{connection} );
    my $id  = CORE::delete $doc->{_id};
    my $rev = CORE::delete $doc->{_rev};
    $self->{is_persistent} = defined $id && defined $rev;
    if ( $self->{is_persistent} ) {
        ( $self->{_collection_id}, $self->{_id} ) = split '/', $id;
        $self->{_document_handle} = $id;
        $self->{_rev}             = $rev;
    }
    map { $self->{$_} = CORE::delete $doc->{$_} } grep {/^_/} keys %$doc;
    $self->{document} = $doc;

lib/ArangoDB/Collection.pm  view on Meta::CPAN

package ArangoDB::Collection;
use strict;
use warnings;
use utf8;
use 5.008001;
use JSON ();
use Carp qw(croak);
use Scalar::Util qw(weaken);
use Class::Accessor::Lite ( ro => [qw/id status/], );
use ArangoDB::Constants qw(:api :status);
use ArangoDB::Document;
use ArangoDB::Edge;
use ArangoDB::Index::Primary;
use ArangoDB::Index::Hash;
use ArangoDB::Index::SkipList;
use ArangoDB::Index::Geo;
use ArangoDB::Index::CapConstraint;
use ArangoDB::Cursor;

lib/ArangoDB/Collection.pm  view on Meta::CPAN

=head2 new($connection, $collection_info)

Constructor.

=cut

sub new {
    my ( $class, $db, $raw_collection ) = @_;
    my $self = bless { db => $db, connection => $db->{connection}, }, $class;
    weaken( $self->{db} );
    weaken( $self->{connection} );
    for my $key (qw/id name status/) {
        $self->{$key} = $raw_collection->{$key};
    }
    $self->{_api_path} = API_COLLECTION . '/' . $self->{id};
    return $self;
}

=pod

=head2 id()

lib/ArangoDB/Cursor.pm  view on Meta::CPAN

package ArangoDB::Cursor;
use strict;
use warnings;
use utf8;
use 5.008001;
use Carp qw(croak);
use Scalar::Util qw(weaken);
use ArangoDB::Document;
use ArangoDB::Constants qw(:api);
use Class::Accessor::Lite ( ro => [qw/id count length/], );

BEGIN {
    if ( eval { require Data::Clone; 1; } ) {
        *_clone = \&Data::Clone::clone;
    }
    else {

lib/ArangoDB/Cursor.pm  view on Meta::CPAN

        id         => $cursor->{id},
        length     => $len,
        count      => $cursor->{count},
        has_more   => $cursor->{hasMore},
        position   => 0,
        result     => $cursor->{result} || [],
    }, $class;
    if ( $self->{id} ) {
        $self->{_api_path} = API_CURSOR . '/' . $self->{id};
    }
    weaken( $self->{connection} );
    return $self;
}

sub next {
    my $self = shift;
    if ( $self->{position} < $self->{length} || $self->_get_next_batch() ) {
        return ArangoDB::Document->new( $self->{connection}, _clone( $self->{result}->[ $self->{position}++ ] ) );
    }
    return;
}

lib/ArangoDB/Index.pm  view on Meta::CPAN

package ArangoDB::Index;
use strict;
use warnings;
use utf8;
use 5.008001;
use Carp qw(croak);
use Scalar::Util qw(weaken);
use ArangoDB::Constants qw(:api);
use Class::Accessor::Lite ( ro => [qw/id collection_id type/] );

use overload
    q{""}    => sub { $_[0]->id },
    fallback => 1;

sub new {
    my ( $class, $conn, $params ) = @_;
    my $self = bless { %$params, connection => $conn, }, $class;
    weaken( $self->{connection} );
    $self->{collection_id} = ( split '/', $self->{id} )[0];
    $self->{_api_path} = API_INDEX . '/' . $self->{id};
    return $self;
}

sub drop {
    my $self = shift;
    my $res = eval { $self->{connection}->http_delete( $self->{_api_path} ) };
    if ($@) {
        $self->_server_error_handler( $@, 'drop' );

lib/ArangoDB/Statement.pm  view on Meta::CPAN

package ArangoDB::Statement;
use strict;
use warnings;
use utf8;
use 5.008001;
use Carp qw(croak);
use JSON ();
use Scalar::Util qw(weaken);
use ArangoDB::Cursor;
use ArangoDB::BindVars;
use ArangoDB::Constants qw(:api);

use overload
    q{""}    => sub { $_[0]->{query} },
    fallback => 1;

sub new {
    my ( $class, $conn, $query ) = @_;
    my $self = bless {
        connection => $conn,
        query      => $query,
        bind_vars  => ArangoDB::BindVars->new(),
    }, $class;
    weaken( $self->{connection} );
    return $self;
}

sub execute {
    my ( $self, $options ) = @_;
    my $data = $self->_build_data($options);
    my $res = eval { $self->{connection}->http_post( API_CURSOR, $data ) };
    if ($@) {
        $self->_server_error_handler( $@, 'Failed to execute query' );
    }