undef-safe equality

[hubb0r]

I've been doing a lot of database work, and I end up doing a lot of comarisons between my returned dataset and other things. The problem I'm encountering is that if I pull back a NULL value in the dataset, and do a string comparison against it, perl throws warnings about "Use of uninitialized value in string comparison" (paraphrased).

Now, I understand that these are only warnings, but I like to run with -w, and I also have a logfile that stdout and stderr are piped to, and I HATE seeing errors in it!!

I thought that in one of the PERL6 snippets I've seen that there is an operator like what I am talking about, but I don't know of a clean way to do it in PERL5. I find myself writing this:

if ($ret->{'val1'} eq $this->{'val1'}) {
    ###
}

Which throws the warnings when $ret->{'val1'} is undef. So I end up going back and cluttering up my if statement like:

if ($ret->{'val1'} and $ret->{'val1'} eq $this->{'val1'} {
    ###
}

This makes the warnings go away, but definitely looks more cluttered and can become downright unruly depending on the if statement (and depending on which values might be undef).

Anyone have any better suggestions?

[dragonchild]

Write your own function. (This one is adapated from Test::Builder, the basis for Test::More's is() test.)

sub is_eq {
    my ($l, $r) = @_;
    if (defined $l && defined $r) {
        return $l eq $r;
    }
    else {
        return !defined $l && !defined $r;
    }
}

Updated: Fixed typo in transcription from Test::Builder::is_eq()

[tall_man]

Your second return should be:

        return !defined $l && !defined $r;

Otherwise, two undefs will compare unequal.

[tlm]

In this case, I think dragonchild's solution is the way to go, but in general, you can switch warnings off locally and selectively; e.g.:

{
  no warnings 'uninitialized';
  if ( $ret->{'val1'} eq $this->{'val1'} ) {
    # ...
  }
}

Read more... (1028 Bytes)

[tye]

Here's a shorter version (compared to the others I saw posted):

sub iseq {
    return  defined($_[0]) == defined($_[1])  &&  $_[0] eq $_[1];
}

Update: Drat. You can't get away with that shortcut and still avoid the warning.

[Roy Johnson]

But you can do

sub iseq {
  (!defined $_[0] || $_[0].9) eq (!defined $_[1] || $_[1].9);
}

Update - shorter:

  1 == keys %{{map {(!defined()||$_.9)=>1} @_}};

[ysth]

Is there some value like "" that you want a NULL to be considered equal to? If so,

if ( ($ret->{val1}||"") eq ($this->{val1}||"") ) ...

Otherwise,

if ( defined($ret->{val1}) == defined($this->{val1}) &&
     ($ret->{val1}||"") eq ($this->{val1}||"") ) ...

[donarb]

One other option not mentioned, but some databases allow you to modify the returned NULL value to some standard string value, like "(null)". Of course, you have to choose a value that will never, ever be used in your data.

Postgres, for example uses the 'pset' command to modify printed values. You should be able to pass pset values in the options parameter of DBI->connect. Note that the following is not tested, but I think should work based in DBI and Postgres documentation. If you cannot modify the printed NULL value through DBI, you may be able to modify it in the database startup configuration.



my $options = "--pset null='(null)'";
my $dbh = DBI->connect("dbi:Pg:dbname=test;" . "options=$options",
      "user", "password");

[hubb0r]

Thanks for all the responses. I like the idea of having my own sub that does the checking and returns a reasonable answer. That (I think) will definitely make for a cleaner representation of what the code is actually doing.