$array[rand(@array)]

Be careful to not duplicate a pick. Maybe you could load the picks into a hash's key and investigate if you reached the required 1000 element or still under that.
Good luck!

--
tune

To not duplicate a pick you do a Fisher-Yates shuffle and stop after N steps:

my @ssn= getAllSSNs();
my $want= 1000;
for(  0..$want-1  ) {
    my $choice= $want + rand(@ssn-$want);
    @ssn[$_,$choice]= @ssn[$choice,$_];
}
return @ssn[0..$want-1];
[download]

        - tye (but my friends call me "Tye")

SELECT ssn FROM ssn_table ORDER BY RAND LIMIT 3
[download]

I tried this with a 250,000 records mysql table on a really fast machine (one of our production servers), and 20 random records costed 17 seconds to process, so be very careful!

--
tune

[Edited to explain the theory more completely.]

Lifted from the Perl Cookbook recipe 8.6 'Picking a Ranom Line from a File' generalized out to N lines rather than 1. Most deep thought comes from Messrs. Christiansen and Torkington. All errors come from me.

# Call srand if you are on an old perl (< 5.004)

my $statement = 'SELECT ssn FROM ...';
my $sth = $dbh->prepare($statement);
$sth->execute();

my $target_lines = 1000;
my @result = ();
my $item_num = 1;
while (my ($ssn) = $sth->fetchrow_array()) {
    if (@result < $target_lines) {
        # Just add it if we have not hit the limit
        push @result, $ssn;
    }
    elsif (rand($item_num) < $target_lines) {
        # Otherwise pick something to replace if the
        # the odds are right
        $result[rand($target_lines)] = $ssn;
    }
} continue {
    $count++;
}
[download]

You can look in the Cookbook for the full description of why this works for a single target_line. The short form is that it will first fill the list with $target_lines elements, then each subsequent line will have a slightly lessened chance of replacing a predecessor. Basically every element in the array should have the same probability of being there at a given point in time. So until the 1001st element each item has a 100% chance of being there. Then the 1001st element has a 1001/1000 chance of replacing something, then there is a 1/1000 chance for each element. Adding that all up it means each element will have a 1001/1000 chance of staying. Then for the 1002nd element, it has a 1002/1000 chance of replacing an element. Again that all adds up to 1002/1000 (1/1000 + 1001/1000) for each element.

The standard caveats about the randomness of the random numbers returned from random apply.

This solution is good if you don't want to slurp all elements in from the DB and if you have to use standard SQL (i.e. no limit clause).

-ben

I think this is what u're talking about.. you're being vague by the way...

$howmany = 1000; # this is the variable to hold the x number

# assuming that you can get the number of ss#'s in some variable $numb
+erOfss

for (0..$howmany) {
    my $ra = int(rand($numberOfss));
    print $ra,"\n"; # do whatever you want with it here..
}
[download]

and then... probably not..

my $select = 1000;
my @ssns;
 
while (my($ssn) = $sth->fetchrow_array()) {
  push @ssns, $_ if rand() < ($select / ++$count);
  if (@ssns > $select) {
    splice(@ssns, rand($#ssns), 1);
  }
}
[download]

1. Add a FLOAT column to the table:
   ALTER TABLE random_selectable ADD random FLOAT;
2. Fill this column with random numbers:
   UPDATE random_selectable SET random = RAND();
3. Get 1000 values:
   SELECT * FROM random_selectable ORDER BY random LIMIT 1000;

Whoa! Way too complex there! Try this

select * from table order by rand() limit 1000;
[download]

There's no need to modify the table just to select a row at random from it.

To generate the psuedo-random numbers, use this:

push @someArray, int(rand $tot) for(1 .. $x);
[download]