1AnyData(3)            User Contributed Perl Documentation           AnyData(3)
2
3
4

NAME

6       AnyData - (DEPRECATED) easy access to data in many formats
7

SYNOPSIS

9        use AnyData;
10        my $table = adTie( 'CSV','my_db.csv','o',            # create a table
11                        {col_names=>'name,country,sex'}
12                      );
13        $table->{Sue} = {country=>'de',sex=>'f'};         # insert a row
14        delete $table->{Tom};                             # delete a single row
15        $str  = $table->{Sue}->{country};                 # select a single value
16        while ( my $row = each %$table ) {                # loop through table
17          print $row->{name} if $row->{sex} eq 'f';
18        }
19        $rows = $table->{{age=>'> 25'}};                  # select multiple rows
20        delete $table->{{country=>qr/us|mx|ca/}};         # delete multiple rows
21        $table->{{country=>'Nz'}}={country=>'nz'};        # update multiple rows
22        my $num = adRows( $table, age=>'< 25' );          # count matching rows
23        my @names = adNames( $table );                    # get column names
24        my @cars = adColumn( $table, 'cars' );            # group a column
25        my @formats = adFormats();                        # list available parsers
26        adExport( $table, $format, $file, $flags );       # save in specified format
27        print adExport( $table, $format, $flags );        # print to screen in format
28        print adDump($table);                             # dump table to screen
29        undef $table;                                     # close the table
30
31        #adConvert( $format1, $file1, $format2, $file2 );  # convert btwn formats
32        #print adConvert( $format1, $file1, $format2 );    # convert to screen
33

DESCRIPTION

35       The rather wacky idea behind this module and its sister module
36       DBD::AnyData is that any data, regardless of source or format should be
37       accessible and modifiable with the same simple set of methods.  This
38       module provides a multidimensional tied hash interface to data in a
39       dozen different formats. The DBD::AnyData module adds a DBI/SQL
40       interface for those same formats.
41
42       Both modules provide built-in protections including appropriate
43       flocking() for all I/O and (in most cases) record-at-a-time access to
44       files rather than slurping of entire files.
45
46       Currently supported formats include general format flat files (CSV,
47       Fixed Length, etc.), specific formats (passwd files, httpd logs, etc.),
48       and a variety of other kinds of formats (XML, Mp3, HTML tables).  The
49       number of supported formats will continue to grow rapidly since there
50       is an open API making it easy for any author to create additional
51       format parsers which can be plugged in to AnyData itself and thereby be
52       accessible by either the tiedhash or DBI/SQL interface.
53

PREREQUISITES

55       The AnyData.pm module itself is pure Perl and does not depend on
56       anything other than modules that come standard with Perl.  Some formats
57       and some advanced features require additional modules: to use the
58       remote ftp/http features, you must have the LWP bundle installed; to
59       use the XML format, you must have XML::Parser and XML::Twig installed;
60       to use the HTMLtable format for reading, you must have HTML::Parser and
61       HTML::TableExtract installed but you can use the HTMLtable for writing
62       with just the standard CGI module.  To use DBI/SQL commands, you must
63       have DBI, DBD::AnyData, SQL::Statement and DBD::File installed.
64

USAGE

66       The AnyData module imports eight methods (functions):
67
68         adTie()     -- create a new table or open an existing table
69         adExport()  -- save an existing table in a specified format
70         adConvert() -- convert data in one format into another format
71         adFormats() -- list available formats
72         adNames()   -- get the column names of a table
73         adRows()    -- get the number of rows in a table or query
74         adDump()    -- display the data formatted as an array of rows
75         adColumn()  -- group values in a single column
76
77       The adTie() command returns a special tied hash.  The tied hash can
78       then be used to access and/or modify data.  See below for details
79
80       With the exception of the XML, HTMLtable, and ARRAY formats, the
81       adTie() command saves all modifications of the data directly to file as
82       they are made.  With XML and HTMLtable, you must make your
83       modifications in memory and then explicitly save them to file with
84       adExport().
85
86   adTie()
87        my $table = adTie( $format, $data, $open_mode, $flags );
88
89       The adTie() command creates a reference to a multidimensional tied
90       hash. In its simplest form, it simply reads a file in a specified
91       format into the tied hash:
92
93        my $table = adTie( $format, $file );
94
95       $format is the name of any supported format 'CSV','Fixed','Passwd',
96       etc.  $file is the name of a relative or absolute path to a local file
97
98       e.g.
99            my $table = adTie( 'CSV', '/usr/me/myfile.csv' );
100
101       this creates a tied hash called $table by reading data in the CSV
102       (comma separated values) format from the file 'myfile.csv'.
103
104       The hash reference resulting from adTie() can be accessed and modified
105       as follows:
106
107        use AnyData;
108        my $table = adTie( $format, $file );
109        $table->{$key}->{$column};                       # select a value
110        $table->{$key} = {$col1=>$val1,$col2=>$val2...}; # update a row
111        delete $table->{$key};                           # delete a row
112        while(my $row = each %$table) {                  # loop through rows
113          print $row->{$col1} if $row->{$col2} ne 'baz';
114        }
115
116       The thing returned by adTie ($table in the example) is not an object,
117       it is a reference to a tied hash. This means that hash operations such
118       as exists, values, keys, may be used, keeping in mind that this is a
119       *reference* to a tied hash so the syntax would be
120
121           for( keys %$table ) {...}
122           for( values %$table ) {...}
123
124       Also keep in mind that if the table is really large, you probably do
125       not want to use keys and values because they create arrays in memory
126       containing data from every row in the table.  Instead use 'each' as
127       shown above since that cycles through the file one record at a time and
128       never puts the entire table into memory.
129
130       It is also possible to use more advanced searching on the hash, see
131       "Multiple Row Operations" below.
132
133       In addition to the simple adTie($format,$file), there are other ways to
134       specify additional information in the adTie() command.  The full syntax
135       is:
136
137        my $table = adTie( $format, $data, $open_mode, $flags );
138
139        The $data parameter allows you to read data from remote files accessible by
140        http or ftp, see "Using Remote Files" below.  It also allows you to treat
141        strings and arrays as data sources without needing a file at all, see
142        "Working with Strings and Arrays" below.
143
144       The optional $mode parameter defaults to 'r' if none is supplied or
145       must be one of
146
147        'r' read      # read only access
148        'u' update    # read/write access
149        'c' create    # create a new file unless it already exists
150        'o' overwrite # create a new file, overwriting any that already exist
151
152       The $flags parameter allows you to specify additional information such
153       as column names.  See the sections in "Further Details" below.
154
155       With the exception of the XML, HTMLtable, and ARRAY formats, the
156       adTie() command saves all modifications of the data directly to file as
157       they are made.  With XML and HTMLtable, you must make your
158       modifications in memory and then explicitly save them to file with
159       adExport().
160
161   adConvert()
162        adConvert( $format1, $data1, $format2, $file2, $flags1, $flags2 );
163
164        or
165
166        print adConvert( $format1, $data1, $format2, undef, $flags1, $flags2 );
167
168        or
169
170        my $aryref = adConvert( $format1, $data1, 'ARRAY', undef, $flags1 );
171
172        This method converts data in any supported format into any other supported
173        format.  The resulting data may either be saved to a file (if $file2 is
174        supplied as a parameter) or sent back as  a string to e.g. print the data
175        to the screen in the new format (if no $file2 is supplied), or sent back
176        as an array reference if $format2 is 'ARRAY'.
177
178        Some examples:
179
180          # convert a CSV file into an XML file
181          #
182          adConvert('CSV','foo.csv','XML','foo.xml');
183
184          # convert a CSV file into an HTML table and print it to the screen
185          #
186          print adConvert('CSV','foo.csv','HTMLtable');
187
188          # convert an XML string into a CSV file
189          #
190          adConvert('XML', ["<x><motto id='perl'>TIMTOWTDI</motto></x>"],
191                    'CSV','foo.csv'
192                   );
193
194          # convert an array reference into an XML file
195          #
196          adConvert('ARRAY', [['id','motto'],['perl','TIMTOWTDI']],
197                    'XML','foo.xml'
198                   );
199
200          # convert an XML file into an array reference
201          #
202          my $aryref = adConvert('XML','foo.xml','ARRAY');
203
204        See section below "Using strings and arrays" for details.
205
206   adExport()
207        adExport( $table, $format, $file, $flags );
208
209        or
210
211        print adExport( $table, $format );
212
213        or
214
215        my $aryref = adExport( $table, 'ARRAY' );
216
217        This method converts an existing tied hash into another format and/or
218        saves the tied hash as a file in the specified format.
219
220        Some examples:
221
222          all assume a previous call to my $table= adTie(...);
223
224          # export table to an XML file
225          #
226          adExport($table','XML','foo.xml');
227
228          # export table to an HTML string and print it to the screen
229          #
230          print adExport($table,'HTMLtable');
231
232          # export the table to an array reference
233          #
234          my $aryref = adExport($table,'ARRAY');
235
236        See section below "Using strings and arrays" for details.
237
238   adNames()
239        my $table = adTie(...);
240        my @column_names = adNames($table);
241
242       This method returns an array of the column names for the specified
243       table.
244
245   adRows()
246        my $table = adTie(...);
247        adRows( $table, %search_hash );
248
249       This method takes an AnyData tied hash created with adTie() and counts
250       the rows in the table that match the search hash.
251
252       For example, this snippet returns a count of the rows in the file that
253       contain the specified page in the request column
254
255         my $hits = adTie( 'Weblog', 'access.log');
256         print adRows( $hits , request => 'mypage.html' );
257
258       The search hash may contain multiple search criteria, see the section
259       on multiple row operations below.
260
261       If the search_hash is omitted, it returns a count of all rows.
262
263   adColumn()
264        my @col_vals = adColumn( $table, $column_name, $distinct_flag );
265
266       This method returns an array of values taken from the specified column.
267       If there is a distinct_flag parameter, duplicates will be eliminated
268       from the list.
269
270       For example, this snippet returns a unique list of the values in the
271       'player' column of the table.
272
273         my $game = adTie( 'Pipe','games.db' );
274         my @players  = adColumn( $game, 'player', 1 );
275
276   adDump()
277         my $table = adTie(...);
278         print adDump($table);
279
280       This method prints the raw data in the table.  Column names are printed
281       inside angle brackets and separated by colons on the first line, then
282       each row is printed as a list of values inside square brackets.
283
284   adFormats()
285         print "$_\n for adFormats();
286
287       This method shows the available format parsers, e.g. 'CSV', 'XML', etc.
288       It looks in your @INC for the .../AnyData/Format directory and prints
289       the names of format parsing files there.  If the parser requires
290       further modules (e.g. XML requires XML::Parser) and you do not have the
291       additional modules installed, the format will not work even if listed
292       by this command.  Otherwise, all formats should work as described in
293       this documentation.
294

FURTHER DETAILS

296   Column Names
297       Column names may be assigned in three ways:
298
299        * pre  -- The format parser preassigns column
300                  names (e.g. Passwd files automatically have
301                  columns named 'username', 'homedir', 'GID', etc.).
302
303        * user -- The user specifies the column names as a comma
304                  separated string associated with the key 'cols':
305
306                  my $table = adTie( $format,
307                                     $file,
308                                     $mode,
309                                     {cols=>'name,age,gender'}
310                                   );
311
312        * auto -- If there is no preassigned list of column names
313                  and none defined by the user, the first line of
314                  the file is treated as a list of column names;
315                  the line is parsed according to the specific
316                  format (e.g. CSV column names are a comma-separated
317                  list, Tab column names are a tab separated list);
318
319       When creating a new file in a format that does not preassign column
320       names, the user *must* manually assign them as shown above.
321
322       Some formats have special rules for assigning column names
323       (XML,Fixed,HTMLtable), see the sections below on those formats.
324
325   Key Columns
326       The AnyData modules support tables that have a single key column that
327       uniquely identifies each row as well as tables that do not have such
328       keys.  For tables where there is a unique key, that key may be assigned
329       in three ways:
330
331        * pre --  The format parser automatically preassigns the
332                  key column name e.g. Passwd files automatically
333                  have 'username' as the key column.
334
335        * user -- The user specifies the key column name:
336
337                  my $table = adTie( $format,
338                                     $file,
339                                     $mode,
340                                     {key=>'country'}
341                                   );
342
343        * auto    If there is no preassigned key column and the user
344                  does not define one, the first column becomes the
345                  default key column
346
347   Format Specific Details
348        For full details, see the documentation for AnyData::Format::Foo
349        where Foo is any of the formats listed in the adFormats() command
350        e.g. 'CSV', 'XML', etc.
351
352        Included below are only some of the more important details of the
353        specific parsers.
354
355       Fixed Format
356           When using the Fixed format for fixed length records you must
357           always specify a pattern indicating the lengths of the fields.
358           This should be a string as would be passed to the unpack() function
359           to unpack the records in your Fixed length definition:
360
361            my $t = adTie( 'Fixed', $file, 'r', {pattern=>'A3 A7 A9'} );
362
363           If you want the column names to appear on the first line of a Fixed
364           file, they should be in comma-separated format, not in Fixed
365           format.  This is different from other formats which use their own
366           format to display the column names on the first line.  This is
367           necessary because the name of the column might be longer than the
368           length of the column.
369
370       XML Format
371            The XML format does not allow you to specify column names as a flag,
372            rather you specify a "record_tag" and the column names are determined
373            from the contents of the tag.  If no record_tag is specified, the
374            record tag will be assumed to be the first child of the root of the
375            XML tree.  That child and its structure will be determined from the
376            DTD if there is one, or from the first occurring record if there is
377            no DTD.
378
379           For simple XML, no flags are necessary:
380
381            <table>
382               <row row_id="1"><name>Joe</name><location>Seattle</location></row>
383               <row row_id="2"><name>Sue</name><location>Portland</location></row>
384            </table>
385
386           The record_tag will default to the first child, namely "row".  The
387           column names will be generated from the attributes of the record
388           tag and all of the tags included under the record tag, so the
389           column names in this example will be "row_id","name","location".
390
391           If the record_tag is not the first child, you will need to specify
392           it.  For example:
393
394            <db>
395              <table table_id="1">
396                <row row_id="1"><name>Joe</name><location>Seattle</location></row>
397                <row row_id="2"><name>Sue</name><location>Portland</location></row>
398              </table>
399              <table table_id="2">
400                <row row_id="1"><name>Bob</name><location>Boise</location></row>
401                <row row_id="2"><name>Bev</name><location>Billings</location></row>
402              </table>
403            </db>
404
405           In this case you will need to specify "row" as the record_tag since
406           it is not the first child of the tree.  The column names will be
407           generated from the attributes of row's parent (if the parent is not
408           the root), from row's attributes and sub tags, i.e.
409           "table_id","row_id","name","location".
410
411           When exporting XML, you can specify a DTD to control the output.
412           For example, if you import a table from CSV or from an Array, you
413           can output as XML and specify which of the columns become tags and
414           which become attributes and also specify the nesting of the tags in
415           your DTD.
416
417           The XML format parser is built on top of Michel Rodriguez's
418           excellent XML::Twig which is itself based on XML::Parser.
419           Parameters to either of those modules may be passed in the flags
420           for adTie() and the other commands including the "prettyPrint" flag
421           to specify how the output XML is displayed and things like
422           ProtocolEncoding.  ProtocolEncoding defaults to 'ISO-8859-1', all
423           other flags keep the defaults of XML::Twig and XML::Parser.  See
424           the documentation of those modules for details;
425
426            CAUTION: Unlike other formats, the XML format does not save changes to
427            the file as they are entered, but only saves the changes when you explicitly
428            request them to be saved with the adExport() command.
429
430       HTMLtable Format
431            This format is based on Matt Sisk's excelletn HTML::TableExtract.
432
433            It can be used to read an existing table from an html page, or to
434            create a new HTML table from any data source.
435
436            You may control which table in an HTML page is used with the column_names,
437            depth and count flags.
438
439            If a column_names flag is passed, the first table that contains those names
440            as the cells in a row will be selected.
441
442            If depth and or count parameters are passed, it will look for tables as
443            specified in the HTML::TableExtract documentation.
444
445            If none of column_names, depth, or count flags are passed, the first table
446            encountered in the file will be the table selected and its first row will
447            be used to determine the column names for the table.
448
449            When exporting to an HTMLtable, you may pass flags to specify properties
450            of the whole table (table_flags), the top row containing the column names
451            (top_row_flags), and the data rows (data_row_flags).  These flags follow
452            the syntax of CGI.pm table constructors, e.g.:
453
454            print adExport( $table, 'HTMLtable', {
455                table_flags    => {Border=>3,bgColor=>'blue'};
456                top_row_flags  => {bgColor=>'red'};
457                data_row_flags => {valign='top'};
458            });
459
460            The table_flags will default to {Border=>1,bgColor=>'white'} if none
461            are specified.
462
463            The top_row_flags will default to {bgColor=>'#c0c0c0'} if none are
464            specified;
465
466            The data_row_flags will be empty if none are specified.
467
468            In other words, if no flags are specified the table will print out with
469            a border of 1, the column headings in gray, and the data rows in white.
470
471            CAUTION: This module will *not* preserve anything in the html file except
472            the selected table so if your file contains more than the selected table,
473            you will want to use adTie() to read the table and then adExport() to write
474            the table to a different file.  When using the HTMLtable format, this is the
475            only way to preserve changes to the data, the adTie() command will *not*
476            write to a file.
477
478   Multiple Row Operations
479       The AnyData hash returned by adTie() may use either single values as
480       keys, or a reference to a hash of comparisons as a key.  If the key to
481       the hash is a single value, the hash operates on a single row but if
482       the key to the hash is itself a hash reference, the hash operates on a
483       group of rows.
484
485        my $num_deleted = delete $table->{Sue};
486
487       This example deletes a single row where the key column has the value
488       'Sue'.  If multiple rows have the value 'Sue' in that column, only the
489       first is deleted.  It uses a simple string as a key, therefore it
490       operates on only a single row.
491
492        my $num_deleted = delete $table->{ {name=>'Sue'} };
493
494       This example deletes all rows where the column 'name' is equal to
495       'Sue'.  It uses a hashref as a key and therefore operates on multiple
496       rows.
497
498       The hashref used in this example is a single column comparison but the
499       hashref could also include multiple column comparisons.  This deletes
500       all rows where the the values listed for the country, gender, and age
501       columns are equal to those specified:
502
503         my $num_deleted = delete $table->{{ country => 'us',
504                                              gender => 'm',
505                                                 age => '25'
506                                          }}
507
508       In addition to simple strings, the values may be specified as regular
509       expressions or as numeric or alphabetic comparisons.  This will delete
510       all North American males under the age of 25:
511
512         my $num_deleted = delete $table->{{ country => qr/mx|us|ca/,
513                                             gender  => 'm',
514                                             age     => '< 25'
515                                          }}
516
517       If numeric or alphabetic comparisons are used, they should be a string
518       with the comparison operator separated from the value by a space, e.g.
519       '> 4' or 'lt b'.
520
521       This kind of search hashref can be used not only to delete multiple
522       rows, but also to update rows.  In fact you *must* use a hashref key in
523       order to update your table.  Updating is the only operation that can
524       not be done with a single string key.
525
526       The search hashref can be used with a select statement, in which case
527       it returns a reference to an array of rows matching the criteria:
528
529        my $male_players = $table->{{gender=>'m'}};
530        for my $player( @$male_players ) { print $player->{name},"\n" }
531
532       This should be used with caution with a large table since it gathers
533       all of the selected rows into an array in memory.  Again, 'each' is a
534       much better way for large tables.  This accomplishes the same thing as
535       the example above, but without ever pulling more than a row into memory
536       at a time:
537
538        while( my $row= each %$table ) {
539          print $row->{name}, "\n" if $row->{gender}=>'m';
540        }
541
542       Search criteria for multiple rows can also be used with the adRows()
543       function:
544
545         my $num_of_women = adRows( $table, gender => 'w' );
546
547       That does *not* pull the entire table into memory, it counts the rows a
548       record at a time.
549
550   Using Remote Files
551       If the first file parameter of adTie() or adConvert() begins with
552       "http://" or "ftp://", the file is treated as a remote URL and the LWP
553       module is called behind the scenes to fetch the file.  If the files are
554       in an area that requires authentication, that may be supplied in the
555       $flags parameter.
556
557       For example:
558
559         # read a remote file and access it via a tied hash
560         #
561         my $table = adTie( 'XML', 'http://www.foo.edu/bar.xml' );
562
563         # same with username/password
564         #
565         my $table = ( 'XML', 'ftp://www.foo.edu/pub/bar.xml', 'r'
566                       { user => 'me', pass => 'x7dy4'
567                     );
568
569         # read a remote file, convert it to an HTML table, and print it
570         #
571         print adConvert( 'XML', 'ftp://www.foo.edu/pub/bar.xml', 'HTMLtable' );
572
573   Using Strings and Arrays
574       Strings and arrays may be used as either the source of data input or as
575       the target of data output.  Strings should be passed as the only
576       element of an array reference (in other words, inside square brackets).
577       Arrays should be a reference to an array whose first element is a
578       reference to an array of column names and whose succeeding elements are
579       references to arrays of row values.
580
581       For example:
582
583         my $table = adTie( 'XML', ["<x><motto id='perl'>TIMTOWTDI</motto></x>"] );
584
585         This uses the XML format to parse the supplied string and returns a tied
586         hash to the resulting table.
587
588
589         my $table = adTie( 'ARRAY', [['id','motto'],['perl','TIMTOWTDI']] );
590
591         This uses the column names "id" and "motto" and the supplied row values
592         and returns a tied hash to the resulting table.
593
594       It is also possible to use an empty array to create a new empty tied
595       hash in any format, for example:
596
597         my $table = adTie('XML',[],'c');
598
599         creates a new empty tied hash;
600
601       See adConvert() and adExport() for further examples of using strings
602       and arrays.
603
604   Ties, Flocks, I/O, and Atomicity
605       AnyData provides flocking which works under the limitations of flock --
606       that it only works if other processes accessing the files are also
607       using flock and only on platforms that support flock.  See the flock()
608       man page for details.
609
610       Here is what the user supplied open modes actually do:
611
612        r = read only  (LOCK_SH)  O_RDONLY
613        u = update     (LOCK_EX)  O_RDWR
614        c = create     (LOCK_EX)  O_CREAT | O_RDWR | O_EXCL
615        o = overwrite  (LOCK_EX)  O_CREAT | O_RDWR | O_TRUNC
616
617       When you use something like "my $table = adTie(...)", it opens the file
618       with a lock and leaves the file and lock open until 1) the hash
619       variable ($table) goes out of scope or 2) the hash is undefined (e.g.
620       "undef $table") or 3) the hash is re-assigned to another tie.  In all
621       cases the file is closed and the lock released.
622
623       If adTie is called without creating a tied hash variable, the file is
624       closed and the lock released immediately after the call to adTie.
625
626        For example:  print adTie('XML','foo.xml')->{main_office}->{phone}.
627
628        That obtains a shared lock, opens the file, retrieves the one value
629        requested, closes the file and releases the lock.
630
631       These two examples accomplish the same thing but the first example
632       opens the file once, does all of the deletions, keeping the exclusive
633       lock in place until they are all done, then closes the file.  The
634       second example opens and closes the file three times, once for each
635       deletion and releases the exclusive lock between each deletion:
636
637        1. my $t = adTie('Pipe','games.db','u');
638           delete $t->{"user$_"} for (0..3);
639           undef $t; # closes file and releases lock
640
641        2. delete adTie('Pipe','games.db','u')->{"user$_"} for (0..3);
642           # no undef needed since no hash variable created
643
644   Deletions and Packing
645       In order to save time and to prevent having to do writes anywhere
646       except at the end of the file, deletions and updates are *not* done at
647       the time of issuing a delete command.  Rather when the user does a
648       delete, the position of the deleted record is stored in a hash and when
649       the file is saved to disk, the deletions are only then physically
650       removed by packing the entire database.  Updates are done by inserting
651       the new record at the end of the file and marking the old record for
652       deletion.  In the normal course of events, all of this should be
653       transparent and you'll never need to worry about it.  However, if your
654       server goes down after you've made updates or deletions but before
655       you've saved the file, then the deleted rows will remain in the
656       database and for updates there will be duplicate rows -- the old non
657       updated row and the new updated row.  If you are worried about this
658       kind of event, then use atomic deletes and updates as shown in the
659       section above.  There's still a very small possibility of a crash in
660       between the deletion and the save, but in this case it should impact at
661       most a single row.  (BIG thanks to Matthew Wickline for suggestions on
662       handling deletes)
663

MORE HELP

665       See the README file and the test.pl included with the module for
666       further examples.
667
668       See the AnyData/Format/*.pm PODs for further details of specific
669       formats.
670
671       For further support, please use comp.lang.perl.modules
672

ACKNOWLEDGEMENTS

674       Special thanks to Andy Duncan, Tom Lowery, Randal Schwartz, Michel
675       Rodriguez, Jochen Wiedmann, Tim Bunce, Alligator Descartes, Mathew
676       Persico, Chris Nandor, Malcom Cook and to many others on the DBI
677       mailing lists and the clp* newsgroups.
678
680        Jeff Zucker <jeff@vpservices.com>
681
682        This module is copyright (c), 2000 by Jeff Zucker.
683        Some changes (c) 2012 Sven Dowideit L<mailto:SvenDowideit@fosiki.com>
684        It may be freely distributed under the same terms as Perl itself.
685
686
687
688perl v5.34.0                      2022-01-20                        AnyData(3)
Impressum