view release on metacpan or  search on metacpan

lib/Catmandu/Store/MongoDB/CQL.pm  view on Meta::CPAN

        my $search_clause;

        if ($base eq 'scr') {
            if ($self->mapping && $self->mapping->{default_relation}) {
                $base = $self->mapping->{default_relation};
            }
            else {
                $base = '=';
            }
        }

        #fields to search for
        if ($qualifier =~ $any_field) {

            #set default field explicitely
            if ($self->mapping && $self->mapping->{default_index}) {
                $search_field = $self->mapping->{default_index};
            }
            else {
                $search_field = '_all';
            }
        }
        else {
            $search_field = $qualifier;

            #change search field
            $search_field =~ s/(?<=[^_])_(?=[^_])//g
                if $self->mapping
                && $self->mapping->{strip_separating_underscores};
            my $q_mapping = $indexes->{$search_field}
                or confess "cql error: unknown index $search_field";
            $q_mapping->{op}->{$base}
                or confess "cql error: relation $base not allowed";

            my $op = $q_mapping->{op}->{$base};

            if (ref $op && $op->{field}) {
                $search_field = $op->{field};
            }
            elsif ($q_mapping->{field}) {
                $search_field = $q_mapping->{field};
            }

            #change term using filters
            my $filters;
            if (ref $op && $op->{filter}) {
                $filters = $op->{filter};
            }
            elsif ($q_mapping->{filter}) {
                $filters = $q_mapping->{filter};
            }

            if ($filters) {
                for my $filter (@$filters) {
                    if ($filter eq 'lowercase') {
                        $term = lc $term;
                    }
                }
            }

            #change term using callbacks
            if (ref $op && $op->{cb}) {
                my ($pkg, $sub) = @{$op->{cb}};
                $term = require_package($pkg)->$sub($term);
            }
            elsif ($q_mapping->{cb}) {
                my ($pkg, $sub) = @{$q_mapping->{cb}};
                $term = require_package($pkg)->$sub($term);
            }
        }

        #field search
        my $unmasked
            = array_includes([map {$_->[1]} @modifiers], "cql.unmasked");

        # trick to force numeric values interpreted as integers
        $term = $term + 0 if ($term =~ /^[1-9]\d*$/);

        if ($base eq '=' or $base eq 'scr') {
            unless ($unmasked) {
                $term
                    = _is_wildcard($term) ? _wildcard_to_regex($term) : $term;
            }

            $search_clause = +{$search_field => $term};
        }
        elsif ($base eq '<') {
            $search_clause = +{$search_field => {'$lt' => $term}};
        }
        elsif ($base eq '>') {
            $search_clause = +{$search_field => {'$gt' => $term}};
        }
        elsif ($base eq '<=') {
            $search_clause = +{$search_field => {'$lte' => $term}};
        }
        elsif ($base eq '>=') {
            $search_clause = +{$search_field => {'$gte' => $term}};
        }
        elsif ($base eq '<>') {
            $search_clause = +{$search_field => {'$ne' => $term}};
        }
        elsif ($base eq 'exact') {
            $search_clause = +{$search_field => $term};
        }
        elsif ($base eq 'all') {
            my @terms = split /\s+/, $term;

#query $all in mongo means exact matching, so we always need regular expressions here
            for (my $i = 0; $i < scalar(@terms); $i++) {

                my $term = $terms[$i];

                if ($unmasked) {

                    $term = _quote_wildcard($term);
                    $term = qr($term);

                }
                elsif (_is_wildcard($term)) {

                    $term = _wildcard_to_regex($term);