I'd like to be able to pass a subroutine a conditional test and a value to test against it. For example the conditional could be a hash ...

Just a thought in case you do go ahead and implement this yourself: Implementing a query language means grammar design + parser + interpreter + tests for everything... why not write the conditionals in Perl?

my $conditional_test = sub {
   my $value = shift;
   return $value==10022 || $value==96813 || $value==55401;
};

if( $conditional_test->($redis_handle->get('key')) ) {
   # do something
}
[download]

Plenty of examples of this: sort, File::Find, ... MJD's Higher-Order Perl is an excellent read in this respect.

my $allowed = sub { grep $_[0] == $_, 10022, 96813, 55401 };
if ($allowed->($redis_handle->get('key')) {
    # do something
}
[download]

But, if users will be creating those conditionals, you need a language + parser (or a GUI to build the conditionals graphically).

I think you need to elaborate a bit more what you want to achieve. If you want to test a single value against a number of possible allowed values and a number of disallowed values, then writing a subroutine for exactly that purpose would be simpler (providing the lists of allowed and disallowed values). When testing against values, AND is not useful as a variable can only have one value.

Or if you want something more complex, please provide a more elaborate example. Like testing the values of several keys, more complex tests etc.

Thanks hdb,

I provided a little more detail in response to "choroba" below. AND was included for exactly the use case you mentioned, testing multiple keys (in the response below I give an example of a single key being used as a composite so it can be tested against multiple conditionals). I understand the deconstruction of the composite key in itself will require a bit of logic but I have already written a fair amount of code that deals building and breaking apart the composite keys.

It seems as if your response to choroba got lost...

For this purpose, I've always just stored the ad-hoc value relationships as key/value pairs in a hash, and then returned the value for the key:

#!/usr/bin/perl
use strict;

my  $TRUE           = 1;
my  $FALSE          = 0;

my  $KEY_ADHQRY     = 'ADHQRY';         # Hash key for the ad hoc Quer
+y
my  $KEY_ADHVAL     = 'ADHVAL';         # Hash key for the ad hoc Valu
+e

my   %Adhinf = ();                      # Ad hoc information

# Get the ad hoc query/response values and populate the hash
{
    print "Enter ad hoc values list in the following format:  query->v
+alue|query->value|query->value\n";
    my $reqahv = <STDIN>;
    chomp $reqahv;
    my @adhelt = split /\|/, $reqahv;
    foreach my $adhelt (@adhelt)
    {
        my $wrkelt = $adhelt;
        $wrkelt =~ s/^\s+//;
        $wrkelt =~ s/\s+$//;
        my ($adhqry, $adhval) = split /\s*\-\>\s*/, $wrkelt, 2;
        my $adhkey = uc $adhqry;
        $Adhinf{$adhkey}{$KEY_ADHQRY} = $adhqry;
        $Adhinf{$adhkey}{$KEY_ADHVAL} = $adhval;
    }
}

# Test the query/response behavior
{
    my $prcflg = $TRUE;
    while ($prcflg)
    {
        print "    Enter query: ";
        my $reqqry = <STDIN>;
        chomp $reqqry;
        if ($reqqry =~ /^\s*$/)
        {
            $prcflg = $FALSE;
            last;
        }
        else
        {
            my $reqrsp = getAdHocResponse($reqqry);
            print "       Response: $reqrsp\n";
            print "\n";
        }
    }
}

exit;

sub getAdHocResponse
{
    my ($reqqry, @arglst) = @_;
    if (!defined $reqqry) { $reqqry = ''; }

    my $retval = '{No Response}';

    my $reqkey = uc $reqqry;
    if (defined $Adhinf{$reqkey})
    {
        $retval = $Adhinf{$reqkey}{$KEY_ADHVAL};
    }

    return $retval;
}
[download]

And the test results: