The hash I'm referencing is a query to a MySQL database.

No, the error means you don't have a reference to a hash.

Despite this, the error still reports those hash keys as strings.

That's not what the error is reporting. For starters, hash keys are necessarily strings.

is there a way to ensure that when the hash is built they are of type 'HASH' and not strings?

The question makes no sense. If a hash is built, it's not a string.

Here's the documentation for the fetchall_hashref method.

If that doesn't help, please post your code so we can help you further.

my $column1value = \$result_hash{'col1'};
[download]

note the back slash, dereferencing the hash reference

I don't understand what you're trying to say here, and I'm fairly certain this will only confuse other people. The backslash operator takes a reference. You might end up with a reference to a reference if the value in the hash associated with col1 is itself a reference.

... and that's not the OP's problem, anyway. The real problem is attempting to dereference something which is not a reference at all.

It is sort of confusing to me as to why, but if you have a multi-level hash, the first key must be able to vary, it cannot be a scalar reference to some other data structure or object.

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

my %hash;
my @array = (1..100);

# this will be ok
$hash{\@array} = 42;

# but this will issue an error, because \@array 
# cannot be used as a key which varies
$hash{\@array}{1} = 42;

# this will be ok
$hash{1}{\@array}{1} = 42;

#this will be ok
$hash{1}{\@array}{1}{1} = 42;
[download]

I think your explanations are very misleading ...

my %hash;
my @array = (1..100);

# this will be ok
$hash{\@array} = 42;
[download]

What happens here is that \@array gets stringified, so the key in the hash is a string (not a reference!) that looks something like "ARRAY(0x987f468)".

Such a construction is (unfortunately) not causing an error, but it almost never is what you want, so it is not ok. It usually is a programming error.

my %hash;
my @array = (1..100);

# this will be ok
$hash{\@array} = 42;

# but this will issue an error, because \@array 
# cannot be used as a key which varies
$hash{\@array}{1} = 42;
[download]

What happens here is that you stringify \@array twice (resulting in the same string each time), so in $hash{\@array}{1} you try to use $hash{\@array} as a hash, but you have assigned 42 (which is not a hash) to that before. The error has nothing to do at all with \@array being used as a hash-key.

Witness:

use strict;

my %hash;
my @array = (1..100);
$hash{\@array} = {};
$hash{\@array}{1} = 42;
[download]

This does not produce an error (but I would not say it is ok just because of that).

If you want to use references as hash-keys you have to use Tie::RefHash.

Good point is made. Just wanted to summarize it. Every time when you see "Can't use something as reference to something" error, search for the existing element of the hash or array which is not reference as you expect it to be.

Non-existing elements are automatically created by perl for you, and probably this is what is confusing you.

# this will be ok
$hash{1}{\@array}{1} = 42;

#this will be ok
$hash{1}{\@array}{1}{1} = 42;
[download]

The latter doesn't work either (it just doesn't issue an error here, 'cos the script is dying after the first problem on line 13).

The reason is simply that if you assign 42 to $hash{\@array}, or $hash{1}{\@array}{1} for that matter, and then try to deference that value in the next statement, you're essentially trying to say

  "42"->{1} = 42
[download]

which obviously doesn't make sense.

Thanks for all of the replies. It sounds like I have a dereferencing issue. I'm going to take another whack at it and post back. Each time I use hashes and think I've got it 'licked' ....