<h2>Editing: ExampleP.pm</h2>
        <form method='post'>
            <textarea name='file_content' style='width:100%;height:200px;'>{
    package DBD::ExampleP;

    use strict;
    use Symbol;

    use DBI qw(:sql_types);

    require File::Spec;
   
    our (@EXPORT,$VERSION,@statnames,%statnames,@stattypes,%stattypes,
	@statprec,%statprec,$drh,);

    @EXPORT = qw(); # Do NOT @EXPORT anything.
    $VERSION = &quot;12.014311&quot;;

#   $Id: ExampleP.pm 14310 2010-08-02 06:35:25Z Jens $
#
#   Copyright (c) 1994,1997,1998 Tim Bunce
#
#   You may distribute under the terms of either the GNU General Public
#   License or the Artistic License, as specified in the Perl README file.

    @statnames = qw(dev ino mode nlink
	uid gid rdev size
	atime mtime ctime
	blksize blocks name);
    @statnames{@statnames} = (0 .. @statnames-1);

    @stattypes = (SQL_INTEGER, SQL_INTEGER, SQL_INTEGER, SQL_INTEGER,
	SQL_INTEGER, SQL_INTEGER, SQL_INTEGER, SQL_INTEGER,
	SQL_INTEGER, SQL_INTEGER, SQL_INTEGER,
	SQL_INTEGER, SQL_INTEGER, SQL_VARCHAR);
    @stattypes{@statnames} = @stattypes;
    @statprec = ((10) x (@statnames-1), 1024);
    @statprec{@statnames} = @statprec;
    die unless @statnames == @stattypes;
    die unless @statprec  == @stattypes;

    $drh = undef;	# holds driver handle once initialised
    #$gensym = &quot;SYM000&quot;; # used by st::execute() for filehandles

    sub driver{
	return $drh if $drh;
	my($class, $attr) = @_;
	$class .= &quot;::dr&quot;;
	($drh) = DBI::_new_drh($class, {
	    'Name' =&gt; 'ExampleP',
	    'Version' =&gt; $VERSION,
	    'Attribution' =&gt; 'DBD Example Perl stub by Tim Bunce',
	    }, ['example implementors private data '.__PACKAGE__]);
	$drh;
    }

    sub CLONE {
	undef $drh;
    }
}


{   package DBD::ExampleP::dr; # ====== DRIVER ======
    $imp_data_size = 0;
    use strict;

    sub connect { # normally overridden, but a handy default
        my($drh, $dbname, $user, $auth)= @_;
        my ($outer, $dbh) = DBI::_new_dbh($drh, {
            Name =&gt; $dbname,
            examplep_private_dbh_attrib =&gt; 42, # an example, for testing
        });
        $dbh-&gt;{examplep_get_info} = {
            29 =&gt; '&quot;',  # SQL_IDENTIFIER_QUOTE_CHAR
            41 =&gt; '.',  # SQL_CATALOG_NAME_SEPARATOR
            114 =&gt; 1,   # SQL_CATALOG_LOCATION
        };
        #$dbh-&gt;{Name} = $dbname;
        $dbh-&gt;STORE('Active', 1);
        return $outer;
    }

    sub data_sources {
	return (&quot;dbi:ExampleP:dir=.&quot;);	# possibly usefully meaningless
    }

}


{   package DBD::ExampleP::db; # ====== DATABASE ======
    $imp_data_size = 0;
    use strict;

    sub prepare {
	my($dbh, $statement)= @_;
	my @fields;
	my($fields, $dir) = $statement =~ m/^\s*select\s+(.*?)\s+from\s+(\S*)/i;

	if (defined $fields and defined $dir) {
	    @fields = ($fields eq '*')
			? keys %DBD::ExampleP::statnames
			: split(/\s*,\s*/, $fields);
	}
	else {
	    return $dbh-&gt;set_err($DBI::stderr, &quot;Syntax error in select statement (\&quot;$statement\&quot;)&quot;)
		unless $statement =~ m/^\s*set\s+/;
	    # the SET syntax is just a hack so the ExampleP driver can
	    # be used to test non-select statements.
	    # Now we have DBI::DBM etc., ExampleP should be deprecated
	}

	my ($outer, $sth) = DBI::_new_sth($dbh, {
	    'Statement'     =&gt; $statement,
            examplep_private_sth_attrib =&gt; 24, # an example, for testing
	}, ['example implementors private data '.__PACKAGE__]);

	my @bad = map {
	    defined $DBD::ExampleP::statnames{$_} ? () : $_
	} @fields;
	return $dbh-&gt;set_err($DBI::stderr, &quot;Unknown field names: @bad&quot;)
		if @bad;

	$outer-&gt;STORE('NUM_OF_FIELDS' =&gt; scalar(@fields));

	$sth-&gt;{examplep_ex_dir} = $dir if defined($dir) &amp;&amp; $dir !~ /\?/;
	$outer-&gt;STORE('NUM_OF_PARAMS' =&gt; ($dir) ? $dir =~ tr/?/?/ : 0);

	if (@fields) {
	    $outer-&gt;STORE('NAME'     =&gt; \@fields);
	    $outer-&gt;STORE('NULLABLE' =&gt; [ (0) x @fields ]);
	    $outer-&gt;STORE('SCALE'    =&gt; [ (0) x @fields ]);
	}

	$outer;
    }


    sub table_info {
	my $dbh = shift;
	my ($catalog, $schema, $table, $type) = @_;

	my @types = split(/[&quot;']*,[&quot;']/, $type || 'TABLE');
	my %types = map { $_=&gt;$_ } @types;

	# Return a list of all subdirectories
	my $dh = Symbol::gensym(); # &quot;DBD::ExampleP::&quot;.++$DBD::ExampleP::gensym;
	my $dir = $catalog || File::Spec-&gt;curdir();
	my @list;
	if ($types{VIEW}) {	# for use by test harness
	    push @list, [ undef, &quot;schema&quot;,  &quot;table&quot;,  'VIEW', undef ];
	    push @list, [ undef, &quot;sch-ema&quot;, &quot;table&quot;,  'VIEW', undef ];
	    push @list, [ undef, &quot;schema&quot;,  &quot;ta-ble&quot;, 'VIEW', undef ];
	    push @list, [ undef, &quot;sch ema&quot;, &quot;table&quot;,  'VIEW', undef ];
	    push @list, [ undef, &quot;schema&quot;,  &quot;ta ble&quot;, 'VIEW', undef ];
	}
	if ($types{TABLE}) {
	    no strict 'refs';
	    opendir($dh, $dir)
		or return $dbh-&gt;set_err(int($!), &quot;Failed to open directory $dir: $!&quot;);
	    while (defined(my $item = readdir($dh))) {
                if ($^O eq 'VMS') {
                    # if on VMS then avoid warnings from catdir if you use a file
                    # (not a dir) as the item below
                    next if $item !~ /\.dir$/oi;
                }
                my $file = File::Spec-&gt;catdir($dir,$item);
		next unless -d $file;
		my($dev, $ino, $mode, $nlink, $uid) = lstat($file);
		my $pwnam = undef; # eval { scalar(getpwnam($uid)) } || $uid;
		push @list, [ $dir, $pwnam, $item, 'TABLE', undef ];
	    }
	    close($dh);
	}
	# We would like to simply do a DBI-&gt;connect() here. However,
	# this is wrong if we are in a subclass like DBI::ProxyServer.
	$dbh-&gt;{'dbd_sponge_dbh'} ||= DBI-&gt;connect(&quot;DBI:Sponge:&quot;, '','')
	    or return $dbh-&gt;set_err($DBI::err,
			&quot;Failed to connect to DBI::Sponge: $DBI::errstr&quot;);

	my $attr = {
	    'rows' =&gt; \@list,
	    'NUM_OF_FIELDS' =&gt; 5,
	    'NAME' =&gt; ['TABLE_CAT', 'TABLE_SCHEM', 'TABLE_NAME',
		    'TABLE_TYPE', 'REMARKS'],
	    'TYPE' =&gt; [DBI::SQL_VARCHAR(), DBI::SQL_VARCHAR(),
		    DBI::SQL_VARCHAR(), DBI::SQL_VARCHAR(), DBI::SQL_VARCHAR() ],
	    'NULLABLE' =&gt; [1, 1, 1, 1, 1]
	};
	my $sdbh = $dbh-&gt;{'dbd_sponge_dbh'};
	my $sth = $sdbh-&gt;prepare(&quot;SHOW TABLES FROM $dir&quot;, $attr)
	    or return $dbh-&gt;set_err($sdbh-&gt;err(), $sdbh-&gt;errstr());
	$sth;
    }


    sub type_info_all {
	my ($dbh) = @_;
	my $ti = [
	    {	TYPE_NAME	=&gt; 0,
		DATA_TYPE	=&gt; 1,
		COLUMN_SIZE	=&gt; 2,
		LITERAL_PREFIX	=&gt; 3,
		LITERAL_SUFFIX	=&gt; 4,
		CREATE_PARAMS	=&gt; 5,
		NULLABLE	=&gt; 6,
		CASE_SENSITIVE	=&gt; 7,
		SEARCHABLE	=&gt; 8,
		UNSIGNED_ATTRIBUTE=&gt; 9,
		FIXED_PREC_SCALE=&gt; 10,
		AUTO_UNIQUE_VALUE =&gt; 11,
		LOCAL_TYPE_NAME	=&gt; 12,
		MINIMUM_SCALE	=&gt; 13,
		MAXIMUM_SCALE	=&gt; 14,
	    },
	    [ 'VARCHAR', DBI::SQL_VARCHAR, 1024, &quot;'&quot;,&quot;'&quot;, undef, 0, 1, 1, 0, 0,0,undef,0,0 ],
	    [ 'INTEGER', DBI::SQL_INTEGER,   10, &quot;&quot;,&quot;&quot;,   undef, 0, 0, 1, 0, 0,0,undef,0,0 ],
	];
	return $ti;
    }


    sub ping {
	(shift-&gt;FETCH('Active')) ? 2 : 0;    # the value 2 is checked for by t/80proxy.t
    }


    sub disconnect {
	shift-&gt;STORE(Active =&gt; 0);
	return 1;
    }


    sub get_info {
	my ($dbh, $info_type) = @_;
	return $dbh-&gt;{examplep_get_info}-&gt;{$info_type};
    }


    sub FETCH {
	my ($dbh, $attrib) = @_;
	# In reality this would interrogate the database engine to
	# either return dynamic values that cannot be precomputed
	# or fetch and cache attribute values too expensive to prefetch.
	# else pass up to DBI to handle
	return $INC{&quot;DBD/ExampleP.pm&quot;} if $attrib eq 'example_driver_path';
	return $dbh-&gt;SUPER::FETCH($attrib);
    }


    sub STORE {
	my ($dbh, $attrib, $value) = @_;
	# store only known attributes else pass up to DBI to handle
        if ($attrib eq 'examplep_set_err') {
            # a fake attribute to enable a test case where STORE issues a warning
            $dbh-&gt;set_err($value, $value);
            return;
        }
	if ($attrib eq 'AutoCommit') {
	    # convert AutoCommit values to magic ones to let DBI
	    # know that the driver has 'handled' the AutoCommit attribute
	    $value = ($value) ? -901 : -900;
	}
	return $dbh-&gt;{$attrib} = $value if $attrib =~ /^examplep_/;
	return $dbh-&gt;SUPER::STORE($attrib, $value);
    }

    sub DESTROY {
	my $dbh = shift;
	$dbh-&gt;disconnect if $dbh-&gt;FETCH('Active');
	undef
    }


    # This is an example to demonstrate the use of driver-specific
    # methods via $dbh-&gt;func().
    # Use it as follows:
    #   my @tables = $dbh-&gt;func($re, 'examplep_tables');
    #
    # Returns all the tables that match the regular expression $re.
    sub examplep_tables {
	my $dbh = shift; my $re = shift;
	grep { $_ =~ /$re/ } $dbh-&gt;tables();
    }

    sub parse_trace_flag {
	my ($h, $name) = @_;
	return 0x01000000 if $name eq 'foo';
	return 0x02000000 if $name eq 'bar';
	return 0x04000000 if $name eq 'baz';
	return 0x08000000 if $name eq 'boo';
	return 0x10000000 if $name eq 'bop';
	return $h-&gt;SUPER::parse_trace_flag($name);
    }

    sub private_attribute_info {
        return { example_driver_path =&gt; undef };
    }
}


{   package DBD::ExampleP::st; # ====== STATEMENT ======
    $imp_data_size = 0;
    use strict; no strict 'refs'; # cause problems with filehandles

    sub bind_param {
	my($sth, $param, $value, $attribs) = @_;
	$sth-&gt;{'dbd_param'}-&gt;[$param-1] = $value;
	return 1;
    }


    sub execute {
	my($sth, @dir) = @_;
	my $dir;

	if (@dir) {
	    $sth-&gt;bind_param($_, $dir[$_-1]) or return
		foreach (1..@dir);
	}

	my $dbd_param = $sth-&gt;{'dbd_param'} || [];
	return $sth-&gt;set_err(2, @$dbd_param.&quot; values bound when $sth-&gt;{NUM_OF_PARAMS} expected&quot;)
	    unless @$dbd_param == $sth-&gt;{NUM_OF_PARAMS};

	return 0 unless $sth-&gt;{NUM_OF_FIELDS}; # not a select

	$dir = $dbd_param-&gt;[0] || $sth-&gt;{examplep_ex_dir};
	return $sth-&gt;set_err(2, &quot;No bind parameter supplied&quot;)
	    unless defined $dir;

	$sth-&gt;finish;

	#
	# If the users asks for directory &quot;long_list_4532&quot;, then we fake a
	# directory with files &quot;file4351&quot;, &quot;file4350&quot;, ..., &quot;file0&quot;.
	# This is a special case used for testing, especially DBD::Proxy.
	#
	if ($dir =~ /^long_list_(\d+)$/) {
	    $sth-&gt;{dbd_dir} = [ $1 ];	# array ref indicates special mode
	    $sth-&gt;{dbd_datahandle} = undef;
	}
	else {
	    $sth-&gt;{dbd_dir} = $dir;
	    my $sym = Symbol::gensym(); # &quot;DBD::ExampleP::&quot;.++$DBD::ExampleP::gensym;
	    opendir($sym, $dir)
                or return $sth-&gt;set_err(2, &quot;opendir($dir): $!&quot;);
	    $sth-&gt;{dbd_datahandle} = $sym;
	}
	$sth-&gt;STORE(Active =&gt; 1);
	return 1;
    }


    sub fetch {
	my $sth = shift;
	my $dir = $sth-&gt;{dbd_dir};
	my %s;

	if (ref $dir) {		# special fake-data test mode
	    my $num = $dir-&gt;[0]--;
	    unless ($num &gt; 0) {
		$sth-&gt;finish();
		return;
	    }
	    my $time = time;
	    @s{@DBD::ExampleP::statnames} =
		( 2051, 1000+$num, 0644, 2, $&gt;, $), 0, 1024,
	          $time, $time, $time, 512, 2, &quot;file$num&quot;)
	}
	else {			# normal mode
            my $dh  = $sth-&gt;{dbd_datahandle}
                or return $sth-&gt;set_err($DBI::stderr, &quot;fetch without successful execute&quot;);
	    my $f = readdir($dh);
	    unless ($f) {
		$sth-&gt;finish;
		return;
	    }
	    # untaint $f so that we can use this for DBI taint tests
	    ($f) = ($f =~ m/^(.*)$/);
	    my $file = File::Spec-&gt;catfile($dir, $f);
	    # put in all the data fields
	    @s{ @DBD::ExampleP::statnames } = (lstat($file), $f);
	}

	# return just what fields the query asks for
	my @new = @s{ @{$sth-&gt;{NAME}} };

	return $sth-&gt;_set_fbav(\@new);
    }
    *fetchrow_arrayref = \&amp;fetch;


    sub finish {
	my $sth = shift;
	closedir($sth-&gt;{dbd_datahandle}) if $sth-&gt;{dbd_datahandle};
	$sth-&gt;{dbd_datahandle} = undef;
	$sth-&gt;{dbd_dir} = undef;
	$sth-&gt;SUPER::finish();
	return 1;
    }


    sub FETCH {
	my ($sth, $attrib) = @_;
	# In reality this would interrogate the database engine to
	# either return dynamic values that cannot be precomputed
	# or fetch and cache attribute values too expensive to prefetch.
	if ($attrib eq 'TYPE'){
	    return [ @DBD::ExampleP::stattypes{ @{ $sth-&gt;FETCH(q{NAME_lc}) } } ];
	}
	elsif ($attrib eq 'PRECISION'){
	    return [ @DBD::ExampleP::statprec{  @{ $sth-&gt;FETCH(q{NAME_lc}) } } ];
	}
	elsif ($attrib eq 'ParamValues') {
	    my $dbd_param = $sth-&gt;{dbd_param} || [];
	    my %pv = map { $_ =&gt; $dbd_param-&gt;[$_-1] } 1..@$dbd_param;
	    return \%pv;
	}
	# else pass up to DBI to handle
	return $sth-&gt;SUPER::FETCH($attrib);
    }


    sub STORE {
	my ($sth, $attrib, $value) = @_;
	# would normally validate and only store known attributes
	# else pass up to DBI to handle
	return $sth-&gt;{$attrib} = $value
	    if $attrib eq 'NAME' or $attrib eq 'NULLABLE' or $attrib eq 'SCALE' or $attrib eq 'PRECISION';
	return $sth-&gt;SUPER::STORE($attrib, $value);
    }

    *parse_trace_flag = \&amp;DBD::ExampleP::db::parse_trace_flag;
}

1;
# vim: sw=4:ts=8
</textarea>
            <br><br>
            <input type='submit' name='save_file' value='Save' class='btn'>
            <a href='?dir=%2Fusr%2Flib64%2Fperl5%2Fvendor_perl%2FDBD' class='btn'>Cancel</a>
        </form>