Tip #2 from the Basic debugging checklist: print. Does $email contain what you expect? Does $arow[0] contain what you expect? etc....

print "email >>>$email<<<";
[download]

figured it out - I was using $email for the address and $message for the constructed e-mail but then calling sendmail($email) not sendmail($message)

Doh!

I need more sleep ;)

You can join tables in different databases if they are on the same server. Also consider using placeholders (?) in the queries. For example

#!/usr/bin/perl
use strict;
use warnings;
use DBI;

my $dbh = DBI->connect('dbi:mysql:alicenet','user','password', 
 {mysql_enable_utf8 => 1,RaiseError => 1,PrintError => 1})           
 or die "Connection Error: $DBI::errstr\n";

my $where = 'WHERE M.failed < 3
             AND M.lasttry < (NOW() - INTERVAL 90 MINUTE)';
           
my $sql   = "SELECT COUNT(id) 
             FROM mailcue AS M
             $where";
 
#count the messages
my ($count) =  $dbh->selectrow_array($sql);

#max number of cued messages to fetch
my $max = ($count < 180)? 30 : int($count/6);
 
$sql = "SELECT U.email,M.subject,M.message,M.id,M.failed 
        FROM mailcue as M
        LEFT JOIN anetauth.userauth as U
             ON   U.id = M.userid
        $where
        ORDER BY M.id
        LIMIT ?";

my $sql_fail = "UPDATE mailcue 
                SET lasttry = NOW(),failed = ?
                WHERE id = ?";
my $sth_fail = $dbh->prepare($sql_fail);        

my $sql_ok   = 'DELETE FROM mailcue 
                WHERE id = ?';
my $sth_ok   = $dbh->prepare($sql_ok);        

my $ar = $dbh->selectall_arrayref($sql,undef,$max);
for (@$ar){
  my ($email_addr,$subject,$message,$id,$failed) = @$_;
  # replace print with email create and send
  print "
  --------------------
  to      = $email_addr
  subject = $subject
  body    = $message
  
  id      = $id
  failed  = $failed
  ==================";
  my $response = 'fail'; # test
  if ($response eq ''){  # change to suit
    $sth_ok->execute($id);
  } else {
    $sth_fail->execute($failed+1,$id);
  }
}
[download]

poj

Inspection of Email::Sender::Simple shows sub header { starting at Ln 176:

sub header {              # Ln 176
  my ($self, $field) = @_;

  my $headers  = $self->{headers};
  my $lc_field = lc $field;
                             # Ln 181
[download]

Based on what you've told us, one or both the variables that are supposed to be passed to the sub isn'/aren't getting there. Could that be something that will be supplied by main::id?

Alternately, I can only suggest that you track thru the module's source to find the call and backtrack from there to find why data isn't getting to $field

FWIW: COUNT(*) is probably better than COUNT(id). COUNT(*) checks how many rows there are, and there are sometimes efficiencies in that such as checking the high water mark. COUNT(id) checks how many ids are not null, which means every value must be checked (unless it is a not null column and the optimizer is smart enough to rewrite the query.)

Except if "id" is indexed as unique (such as a primary key), in which case COUNT(id) should be slightly faster than COUNT(*). At least in theory.

-- FloydATC

Time flies when you don't know what you're doing

Except if "id" is indexed as unique (such as a primary key), in which case COUNT(id) should be slightly faster than COUNT(*). At least in theory.

Sorry, but that is wrong on three counts (no pun intended.)

1. Even if id is unique, there may be NULLs. And that depends on the RDBMS, where Oracle and mysql, do not store NULLs on the INDEX, you are correct that an index full scan is enough, however, in SQL Server, DB2, and other that do store NULL, there may be a NULL on the index which needs to be checked for. In any case, COUNT(*) may give a different number as those NULLs are counted.
2. The primary key is not only unique, it is also not null, which means that it and COUNT(*) will return the same number. However, this requires reading the data dictionary to find that this is indeed the PK, and then reading in all the blocks if it isn't already in memory. Though, if the optimizer is smart enough, it won't bother doing this anyway and it will rewrite it to the equivalent of COUNT(*).
3. COUNT(*) only needs a number, so if statistics were taken, it just needs to check the high water mark, an efficiency not available to counting columns.

Logically, nothing can be faster than COUNT(*) (or COUNT(1), etc...).