A few picky comments:

unless (open(INPUT, "$inputfile"))
    {
    print "ERROR: Can't open file for reading : $!\n";

    }
[download]

This would usually be written as:

open INPUT, '<', $inputfile
  or die "ERROR: Can't open file for reading : $!\n";
[download]

while(<INPUT>)
    {
[download]

You probably want to call chomp each time round the loop

my @data = split("\t", $_);
[download]

The first argument to split is a regular expression. Also, the second argument is optional and defaults to $_. So I'd write that as:

my @data = split /\t/;
[download]

Actually, if you omit the first argument then it defaults to /\s+/ which looks like it would work in this case.

my @data = split;
[download]

Then we have:

my $did1 = $data[0];
my $did2 = $data[1];
my $score1 = $data[2];
my $score2 = $data[3];
[download]

I'm can't really see the point of splitting that array into separate variables. If you want to make the code more readable, then I'd put the data into a hash.

my %rec;
@rec{qw(did1 did2 score1 score2)} = @data;
[download]

In fact I'd do away with the need for @data completely and capture the output from split directly into the hash.

my %rec;
@rec{qw(did1 did2 score1 score2)} = split;
[download]

The biggest problem I can see is with your use of DBI. You prepare your statements each time around the loop. Far more efficient to prepare them once and just execute them each time round the loop. You do this by putting placeholders in your SQL and passing the values to the call to execute.

# before the loop
my $sth1 = $dbh->prepare("select d_id, c_id from d where d_id = ?");
        
my $sth2 = $dbh->prepare("select d_id, c_id from d where d_id = ?");

# Then within the loop
$sth1->execute($rec{did1});
$sth2->execute($rec{did2});
[download]

The other thing I was thinking is that you could probably do a lot more of the work in the SQL and not have to do so much processing in your Perl code. But I'm afraid I don't have time to look at that in much detail right now.

    unless (open(INPUT, "$inputfile"))
    {
    print "ERROR: Can't open file for reading : $!\n";

    }
[download]

First, there's no need to quote $inputfile, just pass the scalar as the parameter to open. Second, although you check for an open error (good!) you don't do anything if it fails, aside from printing the error message. I would rewrite it using the following standard Perl idiom:

open INPUT, $inputfile or die "Can't open $inputfile for reading: $!";
[download]

Even better, you may want to use a more modern lexical filehandle instead of a global one, but this isn't a big deal for a small script, IMHO.

    my @data = split("\t", $_);

    # assigning varables

    my $did1 = $data[0];
    my $did2 = $data[1];
    my $score1 = $data[2];
    my $score2 = $data[3];
[download]

Here you put a bunch of stuff in @data just to take it out again. Instead, you can use a parallel assignment to make it more clear:

my ( $did1, $did2, $score1, $score2 ) = split "\t";
[download]

Note that I also ommitted the $_ from the split, since split works on $_ by default.

        my $sth1 = $dbh->prepare("select d_id, c_id from d where d_id 
= '$did1';");
        
        $sth1->execute();
        
        my $sth2 = $dbh->prepare("select d_id, c_id from d where d_id 
= '$did2';");
        
        $sth2->execute();
[download]

This is the biggest red flag for me. You're not using placeholders! What happens if someone sneaks some nasty SQL into $did1? Or if $did2 contains some characters that need escaping? You should always use DBI placeholders (see the DBI documentation for a complete explanation.)

        my $sth1 = $dbh->prepare("select d_id, c_id from d 
           where d_id = ?");
        $sth1->execute( $did1 );
        
        my $sth2 = $dbh->prepare("select d_id, c_id from d 
           where d_id = ?");
        $sth2->execute( $did2 );
[download]

Finally, I'm assuming you've got strict and warnings turned on but you just forgot to paste that, right? :) You are using lexical variables well and the code seems simple and straightforward.

...  # open file; connect to $dbh
my $sth = $dbh->prepare(qq{
    SELECT
      d1.d_id as did1,
      d2.d_id as did2,
      d1.c_id as cid1,
      d2.c_id as cid2
    FROM d as d1, d as d2
    WHERE d1.d_id = ?
      AND d2.d_id = ?
      AND d1.c_id != d2.c_id
});
while(<INPUT>){
  my( $did1, $did2, $score1, $score2 ) = split "\t", $_;
  next unless $score1 >=70 && $score2 >=60;
  $sth->execute($did1,$did2);
  while( my $row = $sth->fetchrow_arrayref ){
    print join(', ', @$row), "\n";
  }
}
close INPUT;
[download]

my $sth2 = $dbh->prepare_cached("select d_id, c_id from d
           where d_id = ?");
$sth2->execute( $did2 );



# And since you need less clutter on the monitor


(my $sth2 = $dbh->prepare_cached(<<"")) -> execute ($did2);
            select d_id, c_id from d where d_id = ?

# line above intentionally left blank
[download]

Actually, he's not using placeholders so in his case, he will have to put the prepare in the loop. Once he switches to placeholders, then preparing it once at the beginning would be much better.

Also, your HEREDOC terminated with an empty line and a mandatory comment (otherwise, it will get broken over and over) seems a lot less clear and more cluttered than your first example.

I would like to notify some points to you, from your code.

 unless (open(INPUT, "$inputfile"))
    {
    print "ERROR: Can't open file for reading : $!\n";

    }
[download]

# splitting on tab character

    my @data = split("\t", $_);

    # assigning varables

    my $did1 = $data[0];
    my $did2 = $data[1];
    my $score1 = $data[2];
    my $score2 = $data[3];
[download]

my ( $did1,$did2,$score1,$score2 ) = (split("\t", $_))[0..3];
[download]

The above code can be written as my ( $did1,$did2,$score1,$score2 ) = (split("\t", $_))[0..3];

As a curiousity, how come you are subscripting split? Split returns a list, so he should be safe with just...

my ($did1, $did2, $score1, $score2) = split("\t", $_);
[download]

Right?