view release on metacpan or  search on metacpan

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

                unless ($qualifier eq $old_qualifier) {
                    $self->log->debug(
                        "value of qualifier '$old_qualifier' reset to '$qualifier' because of setting 'strip_separating_underscores'"
                    );
                }
                my $q_mapping = $indexes->{$qualifier}
                    or confess "cql error: unknown index $qualifier";
                $q_mapping->{op}->{$base}
                    or confess "cql error: relation $base not allowed";

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

                $old_qualifier = $qualifier;
                if (ref $op && $op->{field}) {

                    $qualifier = $op->{field};

                }
                elsif ($q_mapping->{field}) {

                    $qualifier = $q_mapping->{field};

                }

                unless ($qualifier eq $old_qualifier) {
                    $self->log->debug(
                        "value of qualifier '$old_qualifier' reset to '$qualifier' because of field mapping"
                    );
                }

                #add solr ':'
                $qualifier = "$qualifier:";

                #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') {
                            $self->log->debug(
                                "term '$term' filtered to lowercase");
                            $term = lc $term;
                        }
                    }
                }

                #change term using callbacks
                if (ref $op && $op->{cb}) {
                    my ($pkg, $sub) = @{$op->{cb}};
                    $self->log->debug(
                        "term '$term' changed to ${pkg}->${sub}");
                    $term = require_package($pkg)->$sub($term);
                }
                elsif ($q_mapping->{cb}) {
                    my ($pkg, $sub) = @{$q_mapping->{cb}};
                    $self->log->debug(
                        "term '$term' changed to ${pkg}->${sub}");
                    $term = require_package($pkg)->$sub($term);
                }

            }

        }

        #field search: old way
        else {
            #add solr ':'
            $qualifier = "$qualifier:" if is_string $qualifier;
        }

        if ($base eq '=' or $base eq 'scr') {
            $term = quote_term($term);
            for my $m (@modifiers) {
                if ($m->[1] eq 'fuzzy') {
                    return "$qualifier$term~";
                }
            }
            return $qualifier . $term;
        }
        elsif ($base eq '<') {
            $term = quote_term($term);
            return $qualifier . "{* TO $term}";
        }
        elsif ($base eq '>') {
            $term = quote_term($term);
            return $qualifier . "{$term TO *}";
        }
        elsif ($base eq '<=') {
            $term = quote_term($term);
            return $qualifier . "[* TO $term]";
        }
        elsif ($base eq '>=') {
            $term = quote_term($term);
            return $qualifier . "[$term TO *]";
        }
        elsif ($base eq '<>') {
            $term = quote_term($term);
            return "-$qualifier$term";
        }
        elsif ($base eq 'exact') {
            return $qualifier . quote_term($term);
        }
        elsif ($base eq 'all') {
            my @terms = split /\s+/, $term;
            if (@terms == 1) {
                return $qualifier . $term;
            }
            $term = join ' ', map {"+$_"} @terms;
            if ($qualifier) {
                return "$qualifier($term)";
            }
            return $term;
        }
        elsif ($base eq 'any') {
            $term = join ' OR ', map {$qualifier . $_} split /\s+/, $term;
            return "( $term)";
        }
        elsif ($base eq 'within') {