Coding School

Perl Signals

Perl allows you to trap signals using the %SIG associative array. Using the signals you want to trap as the key, you can assign a subroutine to that signal. The %SIG array will only contain those values which the programmer defines. Therefore, you do not have to assign all signals. For example, to exit cleanly from a ^C:

 $SIG{'INT'} = 'CLEANUP';  sub CLEANUP {     print "Caught Interrupt (^C), Aborting\n";     exit(1); }  

There are two special “routines” for signals called DEFAULT and IGNORE. DEFAULT erases the current assignment, restoring the default value of the signal. IGNORE causes the signal to be ignored. In general, you don’t need to remember these as you can emulate their functionality with standard programming features. DEFAULT can be emulated by deleting the signal from the array and IGNORE can be emulated by any undeclared subroutine.

In 5.001, the $SIG{__WARN__} and $SIG{__DIE__} handlers may be used to intercept die() and warn(). For example, here’s how you could promote unitialized variables to trigger a fatal rather merely complaining:

   #!/usr/bin/perl -w   require 5.001;  $SIG{__WARN__} = sub {     if ($_[0] =~ /uninit/) {         die $@;     } else {         warn $@;     } };  

Perl DBI Example

The DBI module enables your Perl applications to access

multiple database types transparently. You can connect to

MySQL, MSSQL, Oracle, Informix, Sybase, ODBC etc. without

having to know the different underlying interfaces of each.

The API defined by DBI will work on all these database types

and many more.

What is DBI and DBD::Oracle and where can one get it from?

DBI (previously called DBperl) is a database independent interface module for Perl. It defines a set of methods, variables and conventions that provide a consistent database interface independent of the actual database being used.

DBD::Oracle is the Oracle specific module for DBI. It can be downloaded from CPAN.

What DBI drivers have I got?

In DBI you can programmatically discover what DBI drivers are installed.

  #!/usr/bin/perl -w  require DBI;    my @drivers = DBI->available_drivers;  print join(", ", @drivers), "n";  

Example:

  use strict;  use DBI;  my $dbh = DBI->connect( 'dbi:Oracle:orcl',                          'username',                          'password',                          {                            RaiseError => 1,                            AutoCommit => 0                          }                        ) || die "Database connection not made: $DBI::errstr";    my $sql = qq{ CREATE TABLE employees ( id INTEGER NOT NULL,                                         name VARCHAR2(128),                                         position VARCHAR2(128),                                       ) };  $dbh->do( $sql );  $dbh->disconnect();  

SYBASE

Sybperl implements three Sybase extension modules to perl (version 5.002 or higher). Sybase::DBlib adds a subset of the Sybase DB-Library API. Sybase::CTlib adds a subset of the Sybase CT-Library (aka the Client Library) API. Sybase::Sybperl is a backwards compatibility module (implemented on top of Sybase::DBlib) to enable scripts written for sybperl 1.0xx to run with Perl 5. Using both the Sybase::Sybperl and Sybase::DBlib modules explicitly in a single script is not garanteed to work correctly.

The general usage format for both Sybase::DBlib and Sybase::CTlib is this:

use Sybase::DBlib;  # Allocate a new connection, usually refered to as a database handle  $dbh = new Sybase::DBlib username, password;  # Set an attribute for this dbh:  $dbh->{UseDateTime} = TRUE;  # Call a method with this dbh:  $dbh->dbcmd(sql code);  

The DBPROCESS or CS_CONNECTION that is opened with the call to new() is automatically closed when the $dbh goes out of scope:

  sub run_a_query {  my $dbh = new Sybase::CTlib $user, $passwd;  my @dat = $dbh->ct_sql("select * from sysusers");  return @dat;  }  # The $dbh is automatically closed when we exit the subroutine.  

Sybase::DBlib

A generic perl script using Sybase::DBlib would look like this:

  use Sybase::DBlib;  $dbh = new Sybase::DBlib 'sa', $pwd, $server, 'test_app';  $dbh->dbcmd("select * from sysprocessesn");  $dbh->dbsqlexec;  $dbh->dbresults;  while(@data = $dbh->dbnextrow)  {   .... do something with @data ....  }  

$dbh = Sybase::DBlib->dbopen([$server [, $appname, [{attributes}] ]])

Open an additional connection, using the current LOGINREC information.

$status = $dbh->dbuse($database)

Executes “use database $database” for the connection $dbh.

$status = $dbh->dbcmd($sql_cmd)

Appends the string $sql_cmd to the current command buffer of this connection.

$status = $dbh->dbsqlexec

Sends the content of the current command buffer to the dataserver for execution. See the DB-library documentation for a discussion of return values.

$status = $dbh->dbresults

Retrieves result information from the dataserver after having executed dbsqlexec().

$status = $dbh->dbcancel

Cancels the current command batch.

$status = $dbh->dbcanquery

Cancels the current query within the currently executing command batch.

$dbh->dbfreebuf

Free the command buffer (required only in special cases – if you don’t know what this is you probably don’t need it 🙂

$dbh->dbclose

Force the closing of a connection. Note that connections are automatically closed when the $dbh goes out of scope.

$dbh->DBDEAD

Returns TRUE if the DBPROCESS has been marked DEAD by DBlibrary.

$status = $dbh->DBCURCMD

Returns the number of the currently executing command in the command batch. The first command is number 1.

$status = $dbh->DBMORECMDS

Returns TRUE if there are additional commands to be executed in the current command batch.

$status = $dbh->DBCMDROW

Returns SUCCEED if the current command can return rows.

$status = $dbh->DBROWS

Returns SUCCEED if the current command did return rows

$status = $dbh->DBCOUNT

Returns the number of rows that the current command affected.

$row_num = $dbh->DBCURROW

Returns the number (counting from 1) of the currently retrieved row in the current result set.

$status = $dbh->dbhasretstat

Did the last executed stored procedure return a status value? dbhasretstats must only be called after dbresults returns NO_MORE_RESULTS, ie after all the selet, insert, update operations of he sored procedure have been processed.

$status = $dbh->dbretstatus

Retrieve the return status of a stored procedure. As with dbhasretstat, call this function after all the result sets of the stored procedure have been processed.

$status = $dbh->dbnumcols

How many columns are in the current result set.

$status = $dbh->dbcoltype($colid)

What is the column type of column $colid in the current result set.

$status = $dbh->dbcollen($colid)

What is the length (in bytes) of column $colid in the current result set.

$string = $dbh->dbcolname($colid)

What is the name of column $colid in the current result set.

@dat = $dbh->dbretdata[$doAssoc])

Retrieve the value of the parameters marked as ‘OUTPUT’ in a stored procedure. If $doAssoc is non-0, then retrieve the data as an associative array with parameter name/value pairs.

Perl OOP

Why Object Oriented approach?

A major factor in the invention of Object-Oriented approach is to remove some of the flaws encountered with the procedural approach. In OOP, data is treated as a critical element and does not allow it to flow freely. It bounds data closely to the functions that operate on it and protects it from accidental modification from outside functions. OOP allows decomposition of a problem into a number of entities called objects and then builds data and functions around these objects. A major advantage of OOP is code re-usability.

Some important features of Object Oriented programming are as follows:

• Emphasis on data rather than procedure
• Programs are divided into Objects
• Data is hidden and cannot be accessed by external functions
• Objects can communicate with each other through functions
• New data and functions can be easily added whenever necessary
• Follows bottom-up approach

Concepts of OOP:

  sub print {      my ($self) = @_; ## creating reference      #print Person info      printf( "Name:%s %snn", $self->firstName, $self->lastName );  }    

  package Person;  sub new {      my $self = {          _firstName => undef,          _lastName  => undef,          _ssn       => undef,          _address   => undef,          _salary    => undef,          _dept      => undef      };      bless $self, 'Person';      return $self;  }    sub print {      my ($self) = @_; ## creating reference      #print Person info      printf( "Name:%s %snn", $self->firstName, $self->lastName );  }  

  #constructor  sub new {      my ($class) = @_;      my $self = {          _firstName => undef,          _lastName  => undef,          _ssn       => undef,          _address   => undef,          _salary    => undef,          _dept      => undef      };      bless $self, $class;      return $self;  }  

  package Person;  use strict;  use Address;  #Person class will contain an Address    #constructor  sub new {      my ($class) = @_;      my $self = {          _firstName => undef,          _lastName  => undef,          _ssn       => undef,          _address   => undef          _salary    => undef,          _dept      => undef      };      bless $self, $class;      return $self;  }    #accessor method for Person first name  sub firstName {      my ( $self, $firstName ) = @_;      $self->{_firstName} = $firstName if defined ($firstName);      return $self->{_firstName};  }    #accessor method for Person last name  sub lastName {      my ( $self, $lastName ) = @_;      $self->{_lastName} = $lastName if defined($lastName);      return $self->{_lastName};  }    #accessor method for Person address  sub address {      my ( $self, $address ) = @_;      $self->{_address} = $address if defined($address);      return $self->{_address};  }    #accessor method for Person social security number  sub ssn {      my ( $self, $ssn ) = @_;      $self->{_ssn} = $ssn if defined($ssn);      return $self->{_ssn};  }    sub salary {      my ( $self, $salary ) = @_;      $self->{_salary} = $salary if defined($salary);      return $self->{_salary};  }    sub dept {      my ( $self, $dept ) = @_;      $self->{_dept} = $dept if defined($dept);      return $self->{_dept};  }        sub print {      my ($self) = @_;      #print Person info      printf( "Name:%s %snn", $self->firstName, $self->lastName );  }    1;    

  # class Employee  package Employee;  use Person;  use strict;  our @ISA = qw(Person);    # inherits from Person  

  #create Employee class instance  my $mike =  new Employee();     #set object attributes  $mike->firstName('mike');  $mike->lastName('Weis');  

  # class Employee  package Employee;  use Person;  use strict;  our @ISA = qw(Person);    # inherits from Person    #constructor  sub new {      my ($class) = @_;      #call the constructor of the parent class, Person.      my $self = $class->SUPER::new();      $self->{_id}   = undef;      $self->{_title} = undef;      bless $self, $class;      return $self;  }    #accessor method for  id  sub id {      my ( $self, $id ) = @_;      $self->{_id} = $id if defined($id);      return ( $self->{_id} );  }    #accessor method for  title  sub title {      my ( $self, $title ) = @_;      $self->{_title} = $title if defined($title);      return ( $self->{_title} );  }    sub print {      my ($self) = @_;        # we will call the print method of the parent class      $self->SUPER::print;      $self->address->print;  }    1;  

  use strict;  use warnings;  use diagnostics;  use Employee;    #create Employee class instance  my $mike =  eval { new Employee(); }  or die ($@);     #set object attributes  $mike->firstName('mike');  $mike->lastName('Weis');  $mike->id(0731034);  $mike->title('Perl Programmer');  $mike->address( new Address() );  $mike->address->street('30 Hudson court');  $mike->address->city('Jersey City');  $mike->address->state('NJ');  $mike->address->zip('665030');    #diplay Employee info  $mike->print();  

Perl File operations

Variables which represent files are called “file handles”, and they are handled differently from other variables. They do not begin with any special character — they are just plain words. By convention, file handle variables are written in all upper case, like FILE_OUT or SOCK. The file handles are all in a global namespace, so you cannot allocate them locally like other variables. File handles can be passed from one routine to another like strings (detailed below).

The standard file handles STDIN, STDOUT, and STDERR are automatically opened before the program runs. Surrounding a file handle with is an expression that returns one line from the file including the “n” character, so returns one line from standard input. The operator returns undef when there is no more input. The “chop” operator removes the last character from a string, so it can be used just after an input operation to remove the trailing “n”. The “chomp” operator is similar, but only removes the character if it is the end-of-line character.

  $line = ; ## read one line from the STDIN file handle   chomp($line); ## remove the trailing "n" if present   

File Open and Close

The “open” and “close” operators operate as in C to connect a file handle to a filename in the file system.

  open(F1, "filename"); ## open "filename" for reading as file handle F1   open(F2, ">filename"); ## open "filename" for writing as file handle F2   open(F3, ">>appendtome") ## open "appendtome" for appending   close(F1); ## close a file handle   

Open can also be used to establish a reading or writing connection to a separate process launched by the OS. This works best on Unix.

  open(F4, "ls -l |"); ## open a pipe to read from an ls process   open(F5, "| mail $addr"); ## open a pipe to write to a mail process   

Passing commands to the shell to launch an OS process in this way can be very convenient, but it’s also a famous source of security problems in CGI programs. When writing a CGI, do not pass a string from the client side as a filename in a call to open().

Open returns undef on failure, so the following phrase is often to exit if a file can’t be opened. The die operator prints an error message and terminates the program.

  open(FILE, $fname) || die "Could not open $fnamen";   

In this example, the logical-or operator || essentially builds an if statement, since it only evaluates the second expression if the first if false. This construct is a little strange, but it is a common code pattern for Perl error handling.

Input Variants

In a scalar context the input operator reads one line at a time. In an array context, the input operator reads the entire file into memory as an array of its lines… @a = ; ## read the whole file in as an array of lines

This syntax can be dangerous. The following statement looks like it reads just a single line, but actually the left hand side is an array context, so it reads the whole file and then discards all but the first line….

my($line) = ;

The behavior of also depends on the special global variable $/ which is the current the end-of-line marker (usually “n”). Setting $/ to undef causes to read the whole file into a single string.

  $/ = undef;   $all = ; ## read the whole file into one string   

You can remember that $/ is the end-of-line marker because “/” is used to designate separate lines of poetry. I thought this mnemonic was silly when I first saw it, but sure enough, I now remember that $/ is the end-of-line marker.

Print Output

Print takes a series of things to print separated by commas. By default, print writes to the STDOUT file handle.

  print "Woo Hoon"; ## print a string to STDOUT     $num = 42;   $str = " Hoo";   print "Woo", $a, " bbb $num", "n"; ## print several things   

An optional first argument to print can specify the destination file handle. There is no comma after the file handle, but I always forget to omit it.

  print FILE "Here", " there", " everywhere!", "n";    

File Processing Example

As an example, here’s some code that opens each of the files listed in the @ARGV array, and reads in and prints out their contents to standard output…

  #!/usr/bin/perl -w   require 5.004;   ## Open each command line file and print its contents to standard out     foreach $fname (@ARGV) {   open(FILE, $fname) || die("Could not open $fnamen");   while($line = ) {   print $line;   }   close(FILE);   }   

The above uses “die” to abort the program if one of the files cannot be opened. We could use a more flexible strategy where we print an error message for that file but continue to try to process the other files. Alternately we could use the function call exit(-1) to exit the program with an error code. Also, the following shift pattern is a common alternative way to iterate through an array…

 
while($fname = shift(@ARGV)) {... 
 
/pre>

Perl Regular Expressions

    Metacharacters
  char meaning  ^      beginning of string   $      end of string   .      any character except newline   *      match 0 or more times   +      match 1 or more times   ?      match 0 or 1 times; or: shortest match   |      alternative   ( )    grouping; "storing"   [ ]    set of characters   { }    repetition modifier         quote or special   

  Repetition  a*     zero or more a's   a+     one or more a's   a?     zero or one a's (i.e., optional a)   a{m}   exactly m a's   a{m,}  at least m a's   a{m,n} at least m but at most n a's repetition?       t     tab   n     newline   r     return (CR)   xhh   character with hex. code hh   b     "word" boundary   B     not a "word" boundary       w     matches any single character classified as a          "word" character (alphanumeric or _)   W     matches any non-"word" character   s     matches any whitespace character (space, tab, newline)   S     matches any non-whitespace character    d     matches any digit character, equiv. to [0-9]   D     matches any non-digit character       [characters] matches any of the characters in the sequence    [x-y]        matches any of the characters from x to y                (inclusively) in the ASCII code    [-]         matches the hyphen character -   [n]         matches the newline; other single character                denotations with  apply normally, too         

Examples

How do I extract everything between a the words “start” and “end”?

$mystring = “The start text always precedes the end of the end text.”;

if($mystring =~ m/start(.*)end/) {

print $1;

}

How do I extract a complete number, like the year?

$mystring = “[2004/04/13] The date of this article.”;

if($mystring =~ m/(d+)/) {

print “The first number is $1.”;

}

# find word that is bolded

# returns: $1 = ‘text’

$line = “This is some text with HTML and “;

$line =~ m/(.*)/i;

Perl Subroutine

  sub mysubroutine  {  	print "Not a very interesting routinen";  	print "This does the same thing every timen";  }  

regardless of any parameters that we may want to pass to it. All of the following will work to call this subroutine. Notice that a subroutine is called with an & character in front of the name:

  &mysubroutine;		# Call the subroutine  &mysubroutine($_);	# Call it with a parameter  &mysubroutine(1+2, $_);	# Call it with two parameters  

Parameters

In the above case the parameters are acceptable but ignored. When the subroutine is called any parameters are passed as a list in the special @_ list array variable. This variable has absolutely nothing to do with the $_ scalar variable. The following subroutine merely prints out the list that it was called with. It is followed by a couple of examples of its use.

  sub printargs  {  	print "@_n";  }    &printargs("perly", "king");	# Example prints "perly king"  &printargs("frog", "and", "toad"); # Prints "frog and toad"  

Just like any other list array the individual elements of @_ can be accessed with the square bracket notation:

  sub printfirsttwo  {  	print "Your first argument was $_[0]n";  	print "and $_[1] was your secondn";  }  

Again it should be stressed that the indexed scalars $_[0] and $_[1] and so on have nothing to with the scalar $_ which can also be used without fear of a clash.

Returning values

Result of a subroutine is always the last thing evaluated. This subroutine returns the maximum of two input parameters. An example of its use follows.

  sub maximum  {  	if ($_[0] > $_[1])  	{  		$_[0];  	}  	else  	{  		$_[1];  	}  }    $biggest = &maximum(37, 24);	# Now $biggest is 37  

The &printfirsttwo subroutine above also returns a value, in this case 1. This is because the last thing that subroutine did was a print statement and the result of a successful print statement is always 1.

Local variables

The @_ variable is local to the current subroutine, and so of course are $_[0], $_[1], $_[2], and so on. Other variables can be made local too, and this is useful if we want to start altering the input parameters. The following subroutine tests to see if one string is inside another, spaces not withstanding. An example follows.

  sub inside  {  	local($a, $b);                  # Make local variables  	($a, $b) = ($_[0], $_[1]);      # Assign values  	$a =~ s/ //g;                   # Strip spaces from  	$b =~ s/ //g;                   # local variables  	($a =~ /$b/ || $b =~ /$a/);     # Is $b inside $a  					# or $a inside $b?  }    &inside("lemon", "dole money");		# true  

In fact, it can even be tidied up by replacing the first two lines with

local($a, $b) = ($_[0], $_[1]);