MongoDB

 view release on metacpan or  search on metacpan

lib/MongoDB/GridFSBucket.pm  view on Meta::CPAN

            read_concern    => $self->read_concern,
            max_time_ms     => $self->max_time_ms,
            # XXX: Generate a new bson codec here to
            # prevent users from changing it?
            bson_codec => $self->bson_codec,
        }
    );
    return $coll;
}

# index operations need primary server, regardless of bucket read prefs
sub _create_indexes {
    my ($self) = @_;
    $self->_set__tried_indexing(1);

    my $pf = $self->_files->clone( read_preference => 'primary' );

    return if $pf->count_documents({}) > 0;

    my $pfi = $pf->indexes;
    my $pci = $self->_chunks->clone( read_preference => 'primary' )->indexes;

lib/MongoDB/Op/_Command.pm  view on Meta::CPAN

sub execute {
    my ( $self, $link, $topology_type ) = @_;
    $topology_type ||= 'Single'; # if not specified, assume direct

    $self->_apply_session_and_cluster_time( $link, \$self->{query} );

    my ( $op_bson, $request_id );

    if ( $link->supports_op_msg ) {
        # $query is passed as a reference because it *may* be replaced
        $self->_apply_op_msg_read_prefs( $link, $topology_type, $self->{query_flags}, \$self->{query});
        $self->{query} = to_IxHash( $self->{query} );
        $self->{query}->Push( '$db', $self->db_name );
        ( $op_bson, $request_id ) =
            MongoDB::_Protocol::write_msg( $self->{bson_codec}, undef, $self->{query} );
    } else {
        # $query is passed as a reference because it *may* be replaced
        $self->_apply_op_query_read_prefs( $link, $topology_type, $self->{query_flags}, \$self->{query});
        ( $op_bson, $request_id ) =
          MongoDB::_Protocol::write_query( $self->{db_name} . '.$cmd',
            $self->{bson_codec}->encode_one( $self->{query} ), undef, 0, -1, $self->{query_flags});
    }

    if ( length($op_bson) > MAX_BSON_WIRE_SIZE ) {
        # XXX should this become public?
        MongoDB::_CommandSizeError->throw(
            message => "database command too large",
            size    => length $op_bson,

lib/MongoDB/Op/_Query.pm  view on Meta::CPAN

    my $n_to_return =
        $limit == 0      ? $batch_size
      : $batch_size == 0 ? $limit
      : $limit < 0       ? $limit
      :                    min( $limit, $batch_size );

    my $proj =
      $opts->{projection} ? $self->bson_codec->encode_one( $opts->{projection} ) : undef;

    # $query is passed as a reference because it *may* be replaced
    $self->_apply_op_query_read_prefs( $link, $topology, $query_flags, \$query );

    my $filter = $self->bson_codec->encode_one($query);

    my ( $op_bson, $request_id ) =
      MongoDB::_Protocol::write_query( $full_name, $filter, $proj, $opts->{skip},
        $n_to_return, $query_flags );

    my $result =
      $self->_query_and_receive( $link, $op_bson, $request_id, $self->bson_codec );

lib/MongoDB/Role/_ReadPrefModifier.pm  view on Meta::CPAN

use MongoDB::_Types -types, 'to_IxHash';

use namespace::clean;

requires qw/read_preference/;

my $PRIMARY = MongoDB::ReadPreference->new()->_as_hashref;
my $PRIMARYPREFERRED =
  MongoDB::ReadPreference->new( mode => 'primaryPreferred' )->_as_hashref;

sub _apply_op_msg_read_prefs {
    my ( $self, $link, $topology_type, $query_flags, $query_ref ) = @_;

    $topology_type ||= "<undef>";
    my $read_pref = $self->read_preference;
    my $read_pref_doc = $read_pref ? $read_pref->_as_hashref : $PRIMARY;

    if ( $topology_type eq 'Single' && ! ($link->server && $link->server->type eq 'Mongos') ) {
        # For direct connection to a non-mongos single server, allow any server
        # type, overriding the provided read preference
        $read_pref_doc = $PRIMARYPREFERRED;
    }

    $$query_ref = to_IxHash($$query_ref);
    ($$query_ref)->Push( '$readPreference' => $read_pref_doc );

    return;
}

sub _apply_op_query_read_prefs {
    my ( $self, $link, $topology_type, $query_flags, $query_ref ) = @_;

    $topology_type ||= "<undef>";
    my $read_pref = $self->read_preference;

    if ( $topology_type eq 'Single' ) {
        if ( $link->server && $link->server->type eq 'Mongos' ) {
            $self->_apply_mongos_read_prefs( $read_pref, $query_flags, $query_ref );
        }
        else {
            $query_flags->{slave_ok} = 1;
        }
    }
    elsif ( grep { $topology_type eq $_ } qw/ReplicaSetNoPrimary ReplicaSetWithPrimary/ )
    {
        if ( !$read_pref || $read_pref->mode eq 'primary' ) {
            $query_flags->{slave_ok} = 0;
        }
        else {
            $query_flags->{slave_ok} = 1;
        }
    }
    elsif ( $topology_type eq 'Sharded' ) {
        $self->_apply_mongos_read_prefs( $read_pref, $query_flags, $query_ref );
    }
    else {
        MongoDB::InternalError->throw("can't query topology type '$topology_type'");
    }

    return;
}

sub _apply_mongos_read_prefs {
    my ( $self, $read_pref, $query_flags, $query_ref ) = @_;
    my $mode = $read_pref ? $read_pref->mode : 'primary';
    my $need_read_pref;

    if ( $mode eq 'primary' ) {
        $query_flags->{slave_ok} = 0;
    }
    elsif ( grep { $mode eq $_ } qw/secondary primaryPreferred nearest/ ) {
        $query_flags->{slave_ok} = 1;
        $need_read_pref = 1;