1DBD::CSV(3)           User Contributed Perl Documentation          DBD::CSV(3)
2
3
4

NAME

6       DBD::CSV - DBI driver for CSV files
7

SYNOPSIS

9           use DBI;
10           # See "Creating database handle" below
11           $dbh = DBI->connect ("dbi:CSV:", undef, undef, {
12               f_ext      => ".csv/r",
13               RaiseError => 1,
14               }) or die "Cannot connect: $DBI::errstr";
15
16           # Simple statements
17           $dbh->do ("CREATE TABLE foo (id INTEGER, name CHAR (10))");
18
19           # Selecting
20           my $sth = $dbh->prepare ("select * from foo");
21           $sth->execute;
22           $sth->bind_columns (\my ($id, $name));
23           while ($sth->fetch) {
24               print "id: $id, name: $name\n";
25               }
26
27           # Updates
28           my $sth = $dbh->prepare ("UPDATE foo SET name = ? WHERE id = ?");
29           $sth->execute ("DBI rocks!", 1);
30           $sth->finish;
31
32           $dbh->disconnect;
33

DESCRIPTION

35       The DBD::CSV module is yet another driver for the DBI (Database
36       independent interface for Perl). This one is based on the SQL "engine"
37       SQL::Statement and the abstract DBI driver DBD::File and implements
38       access to so-called CSV files (Comma Separated Values). Such files are
39       often used for exporting MS Access and MS Excel data.
40
41       See DBI for details on DBI, SQL::Statement for details on
42       SQL::Statement and DBD::File for details on the base class DBD::File.
43
44   Prerequisites
45       The only system dependent feature that DBD::File uses, is the "flock
46       ()" function. Thus the module should run (in theory) on any system with
47       a working "flock ()", in particular on all Unix machines and on Windows
48       NT. Under Windows 95 and MacOS the use of "flock ()" is disabled, thus
49       the module should still be usable.
50
51       Unlike other DBI drivers, you don't need an external SQL engine or a
52       running server. All you need are the following Perl modules, available
53       from any CPAN mirror, for example
54
55         http://search.cpan.org/
56
57       DBI A recent version of the DBI (Database independent interface for
58           Perl).  See below why.
59
60       DBD::File
61           This is the base class for DBD::CSV, and it is part of the DBI
62           distribution. As DBD::CSV requires a matching version of DBD::File
63           which is (partly) developed by the same team that maintains
64           DBD::CSV. See META.json or Makefile.PL for the minimum versions.
65
66       SQL::Statement
67           A simple SQL engine. This module defines all of the SQL syntax for
68           DBD::CSV, new SQL support is added with each release so you should
69           look for updates to SQL::Statement regularly.
70
71           It is possible to run "DBD::CSV" without this module if you define
72           the environment variable $DBI_SQL_NANO to 1. This will reduce the
73           SQL support a lot though. See DBI::SQL::Nano for more details. Note
74           that the test suite does only test in this mode in the development
75           environment.
76
77       Text::CSV_XS
78           This module is used to read and write rows in a CSV file.
79
80   Installation
81       Installing this module (and the prerequisites from above) is quite
82       simple.  The simplest way is to install the bundle:
83
84           $ cpan Bundle::DBD::CSV
85
86       Alternatively, you can name them all
87
88           $ cpan Text::CSV_XS DBI DBD::CSV
89
90       or even trust "cpan" to resolve all dependencies for you:
91
92           $ cpan DBD::CSV
93
94       If you cannot, for whatever reason, use cpan, fetch all modules from
95       CPAN, and build with a sequence like:
96
97           gzip -d < DBD-CSV-0.40.tgz | tar xf -
98
99       (this is for Unix users, Windows users would prefer WinZip or something
100       similar) and then enter the following:
101
102           cd DBD-CSV-0.40
103           perl Makefile.PL
104           make test
105
106       If any tests fail, let us know. Otherwise go on with
107
108           make install UNINST=1
109
110       Note that you almost definitely need root or administrator permissions.
111       If you don't have them, read the ExtUtils::MakeMaker man page for
112       details on installing in your own directories. ExtUtils::MakeMaker.
113
114   Supported SQL Syntax
115       All SQL processing for DBD::CSV is done by SQL::Statement. See
116       SQL::Statement for more specific information about its feature set.
117       Features include joins, aliases, built-in and user-defined functions,
118       and more.  See SQL::Statement::Syntax for a description of the SQL
119       syntax supported in DBD::CSV.
120
121       Table- and column-names are case insensitive unless quoted. Column
122       names will be sanitized unless "raw_header" is true.
123

Using DBD::CSV with DBI

125       For most things, DBD-CSV operates the same as any DBI driver.  See DBI
126       for detailed usage.
127
128   Creating a database handle (connect)
129       Creating a database handle usually implies connecting to a database
130       server.  Thus this command reads
131
132           use DBI;
133           my $dbh = DBI->connect ("dbi:CSV:", "", "", {
134               f_dir => "/home/user/folder",
135               });
136
137       The directory tells the driver where it should create or open tables
138       (a.k.a.  files). It defaults to the current directory, so the following
139       are equivalent:
140
141           $dbh = DBI->connect ("dbi:CSV:");
142           $dbh = DBI->connect ("dbi:CSV:", undef, undef, { f_dir => "." });
143           $dbh = DBI->connect ("dbi:CSV:f_dir=.");
144
145       We were told, that VMS might - for whatever reason - require:
146
147           $dbh = DBI->connect ("dbi:CSV:f_dir=");
148
149       The preferred way of passing the arguments is by driver attributes:
150
151           # specify most possible flags via driver flags
152           $dbh = DBI->connect ("dbi:CSV:", undef, undef, {
153               f_schema         => undef,
154               f_dir            => "data",
155               f_dir_search     => [],
156               f_ext            => ".csv/r",
157               f_lock           => 2,
158               f_encoding       => "utf8",
159
160               csv_eol          => "\r\n",
161               csv_sep_char     => ",",
162               csv_quote_char   => '"',
163               csv_escape_char  => '"',
164               csv_class        => "Text::CSV_XS",
165               csv_null         => 1,
166               csv_bom          => 0,
167               csv_tables       => {
168                   syspwd => {
169                       sep_char    => ":",
170                       quote_char  => undef,
171                       escape_char => undef,
172                       file        => "/etc/passwd",
173                       col_names   => [qw( login password
174                                           uid gid realname
175                                           directory shell )],
176                       },
177                   },
178
179               RaiseError       => 1,
180               PrintError       => 1,
181               FetchHashKeyName => "NAME_lc",
182               }) or die $DBI::errstr;
183
184       but you may set these attributes in the DSN as well, separated by
185       semicolons.  Pay attention to the semi-colon for "csv_sep_char" (as
186       seen in many CSV exports from MS Excel) is being escaped in below
187       example, as is would otherwise be seen as attribute separator:
188
189           $dbh = DBI->connect (
190               "dbi:CSV:f_dir=$ENV{HOME}/csvdb;f_ext=.csv;f_lock=2;" .
191               "f_encoding=utf8;csv_eol=\n;csv_sep_char=\\;;" .
192               "csv_quote_char=\";csv_escape_char=\\;csv_class=Text::CSV_XS;" .
193               "csv_null=1") or die $DBI::errstr;
194
195       Using attributes in the DSN is easier to use when the DSN is derived
196       from an outside source (environment variable, database entry, or
197       configure file), whereas specifying entries in the attribute hash is
198       easier to read and to maintain.
199
200       The default value for "csv_binary" is 1 (True).
201
202       The default value for "csv_auto_diag" is <1>. Note that this might
203       cause trouble on perl versions older than 5.8.9, so up to and including
204       perl version 5.8.8 it might be required to use ";csv_auto_diag=0"
205       inside the "DSN" or "csv_auto_diag =" 0> inside the attributes.
206
207   Creating and dropping tables
208       You can create and drop tables with commands like the following:
209
210           $dbh->do ("CREATE TABLE $table (id INTEGER, name CHAR (64))");
211           $dbh->do ("DROP TABLE $table");
212
213       Note that currently only the column names will be stored and no other
214       data.  Thus all other information including column type (INTEGER or
215       CHAR (x), for example), column attributes (NOT NULL, PRIMARY KEY, ...)
216       will silently be discarded. This may change in a later release.
217
218       A drop just removes the file without any warning.
219
220       See DBI for more details.
221
222       Table names cannot be arbitrary, due to restrictions of the SQL syntax.
223       I recommend that table names are valid SQL identifiers: The first
224       character is alphabetic, followed by an arbitrary number of
225       alphanumeric characters. If you want to use other files, the file names
226       must start with "/", "./" or "../" and they must not contain white
227       space.
228
229   Inserting, fetching and modifying data
230       The following examples insert some data in a table and fetch it back:
231       First, an example where the column data is concatenated in the SQL
232       string:
233
234           $dbh->do ("INSERT INTO $table VALUES (1, ".
235                      $dbh->quote ("foobar") . ")");
236
237       Note the use of the quote method for escaping the word "foobar". Any
238       string must be escaped, even if it does not contain binary data.
239
240       Next, an example using parameters:
241
242           $dbh->do ("INSERT INTO $table VALUES (?, ?)", undef, 2,
243                     "It's a string!");
244
245       Note that you don't need to quote column data passed as parameters.
246       This version is particularly well designed for loops. Whenever
247       performance is an issue, I recommend using this method.
248
249       You might wonder about the "undef". Don't wonder, just take it as it
250       is. :-) It's an attribute argument that I have never used and will be
251       passed to the prepare method as the second argument.
252
253       To retrieve data, you can use the following:
254
255           my $query = "SELECT * FROM $table WHERE id > 1 ORDER BY id";
256           my $sth   = $dbh->prepare ($query);
257           $sth->execute ();
258           while (my $row = $sth->fetchrow_hashref) {
259               print "Found result row: id = ", $row->{id},
260                     ", name = ", $row->{name};
261               }
262           $sth->finish ();
263
264       Again, column binding works: The same example again.
265
266           my $sth = $dbh->prepare (qq;
267               SELECT * FROM $table WHERE id > 1 ORDER BY id;
268               ;);
269           $sth->execute;
270           my ($id, $name);
271           $sth->bind_columns (undef, \$id, \$name);
272           while ($sth->fetch) {
273               print "Found result row: id = $id, name = $name\n";
274               }
275           $sth->finish;
276
277       Of course you can even use input parameters. Here's the same example
278       for the third time:
279
280           my $sth = $dbh->prepare ("SELECT * FROM $table WHERE id = ?");
281           $sth->bind_columns (undef, \$id, \$name);
282           for (my $i = 1; $i <= 2; $i++) {
283               $sth->execute ($id);
284               if ($sth->fetch) {
285                   print "Found result row: id = $id, name = $name\n";
286                   }
287               $sth->finish;
288               }
289
290       See DBI for details on these methods. See SQL::Statement for details on
291       the WHERE clause.
292
293       Data rows are modified with the UPDATE statement:
294
295           $dbh->do ("UPDATE $table SET id = 3 WHERE id = 1");
296
297       Likewise you use the DELETE statement for removing rows:
298
299           $dbh->do ("DELETE FROM $table WHERE id > 1");
300
301   Error handling
302       In the above examples we have never cared about return codes. Of
303       course, this is not recommended. Instead we should have written (for
304       example):
305
306           my $sth = $dbh->prepare ("SELECT * FROM $table WHERE id = ?") or
307               die "prepare: " . $dbh->errstr ();
308           $sth->bind_columns (undef, \$id, \$name) or
309               die "bind_columns: " . $dbh->errstr ();
310           for (my $i = 1; $i <= 2; $i++) {
311               $sth->execute ($id) or
312                   die "execute: " . $dbh->errstr ();
313               $sth->fetch and
314                   print "Found result row: id = $id, name = $name\n";
315               }
316           $sth->finish ($id) or die "finish: " . $dbh->errstr ();
317
318       Obviously this is tedious. Fortunately we have DBI's RaiseError
319       attribute:
320
321           $dbh->{RaiseError} = 1;
322           $@ = "";
323           eval {
324               my $sth = $dbh->prepare ("SELECT * FROM $table WHERE id = ?");
325               $sth->bind_columns (undef, \$id, \$name);
326               for (my $i = 1; $i <= 2; $i++) {
327                   $sth->execute ($id);
328                   $sth->fetch and
329                       print "Found result row: id = $id, name = $name\n";
330                   }
331               $sth->finish ($id);
332               };
333           $@ and die "SQL database error: $@";
334
335       This is not only shorter, it even works when using DBI methods within
336       subroutines.
337

DBI database handle attributes

339   Metadata
340       The following attributes are handled by DBI itself and not by
341       DBD::File, thus they all work as expected:
342
343           Active
344           ActiveKids
345           CachedKids
346           CompatMode             (Not used)
347           InactiveDestroy
348           Kids
349           PrintError
350           RaiseError
351           Warn                   (Not used)
352
353       The following DBI attributes are handled by DBD::File:
354
355       AutoCommit
356           Always on
357
358       ChopBlanks
359           Works
360
361       NUM_OF_FIELDS
362           Valid after "$sth->execute"
363
364       NUM_OF_PARAMS
365           Valid after "$sth->prepare"
366
367       NAME
368       NAME_lc
369       NAME_uc
370           Valid after "$sth->execute"; undef for Non-Select statements.
371
372       NULLABLE
373           Not really working. Always returns an array ref of one's, as
374           DBD::CSV does not verify input data. Valid after "$sth->execute";
375           undef for non-Select statements.
376
377       These attributes and methods are not supported:
378
379           bind_param_inout
380           CursorName
381           LongReadLen
382           LongTruncOk
383

DBD-CSV specific database handle attributes

385       In addition to the DBI attributes, you can use the following dbh
386       attributes:
387
388   DBD::File attributes
389       f_dir
390           This attribute is used for setting the directory where CSV files
391           are opened. Usually you set it in the dbh and it defaults to the
392           current directory ("."). However, it may be overridden in statement
393           handles.
394
395       f_dir_search
396           This attribute optionally defines a list of extra directories to
397           search when opening existing tables. It should be an anonymous list
398           or an array reference listing all folders where tables could be
399           found.
400
401               my $dbh = DBI->connect ("dbi:CSV:", "", "", {
402                   f_dir        => "data",
403                   f_dir_search => [ "ref/data", "ref/old" ],
404                   f_ext        => ".csv/r",
405                   }) or die $DBI::errstr;
406
407       f_ext
408           This attribute is used for setting the file extension.
409
410       f_schema
411           This attribute allows you to set the database schema name. The
412           default is to use the owner of "f_dir". "undef" is allowed, but not
413           in the DSN part.
414
415               my $dbh = DBI->connect ("dbi:CSV:", "", "", {
416                   f_schema => undef,
417                   f_dir    => "data",
418                   f_ext    => ".csv/r",
419                   }) or die $DBI::errstr;
420
421       f_encoding
422           This attribute allows you to set the encoding of the data. With
423           CSV, it is not possible to set (and remember) the encoding on a
424           column basis, but DBD::File now allows the encoding to be set on
425           the underlying file. If this attribute is not set, or undef is
426           passed, the file will be seen as binary.
427
428       f_lock
429           With this attribute you can specify a locking mode to be used (if
430           locking is supported at all) for opening tables. By default, tables
431           are opened with a shared lock for reading, and with an exclusive
432           lock for writing. The supported modes are:
433
434           0 Force no locking at all.
435
436           1 Only shared locks will be used.
437
438           2 Only exclusive locks will be used.
439
440       But see "KNOWN BUGS" in DBD::File.
441
442   DBD::CSV specific attributes
443       csv_class
444           The attribute csv_class controls the CSV parsing engine. This
445           defaults to "Text::CSV_XS", but "Text::CSV" can be used in some
446           cases, too.  Please be aware that "Text::CSV" does not care about
447           any edge case as "Text::CSV_XS" does and that "Text::CSV" is
448           probably about 100 times slower than "Text::CSV_XS".
449
450           In order to use the specified class other than "Text::CSV_XS", it
451           needs to be loaded before use.  "DBD::CSV" does not "require"/"use"
452           the specified class itself.
453
454   Text::CSV_XS specific attributes
455       csv_eol
456       csv_sep_char
457       csv_quote_char
458       csv_escape_char
459       csv_csv
460           The attributes csv_eol, csv_sep_char, csv_quote_char and
461           csv_escape_char are corresponding to the respective attributes of
462           the csv_class (usually Text::CSV_CS) object. You may want to set
463           these attributes if you have unusual CSV files like /etc/passwd or
464           MS Excel generated CSV files with a semicolon as separator.
465           Defaults are "\015\012"", ",", """ and """, respectively.
466
467           The csv_eol attribute defines the end-of-line pattern, which is
468           better known as a record separator pattern since it separates
469           records.  The default is windows-style end-of-lines "\015\012" for
470           output (writing) and unset for input (reading), so if on unix you
471           may want to set this to newline ("\n") like this:
472
473             $dbh->{csv_eol} = "\n";
474
475           It is also possible to use multi-character patterns as record
476           separators.  For example this file uses newlines as field
477           separators (sep_char) and the pattern "\n__ENDREC__\n" as the
478           record separators (eol):
479
480             name
481             city
482             __ENDREC__
483             joe
484             seattle
485             __ENDREC__
486             sue
487             portland
488             __ENDREC__
489
490           To handle this file, you'd do this:
491
492             $dbh->{eol}      = "\n__ENDREC__\n" ,
493             $dbh->{sep_char} = "\n"
494
495           The attributes are used to create an instance of the class
496           csv_class, by default Text::CSV_XS. Alternatively you may pass an
497           instance as csv_csv, the latter takes precedence. Note that the
498           binary attribute must be set to a true value in that case.
499
500           Additionally you may overwrite these attributes on a per-table base
501           in the csv_tables attribute.
502
503       csv_null
504           With this option set, all new statement handles will set
505           "always_quote" and "blank_is_undef" in the CSV parser and writer,
506           so it knows how to distinguish between the empty string and "undef"
507           or "NULL". You cannot reset it with a false value. You can pass it
508           to connect, or set it later:
509
510             $dbh = DBI->connect ("dbi:CSV:", "", "", { csv_null => 1 });
511
512             $dbh->{csv_null} = 1;
513
514       csv_bom
515           With this option set, the CSV parser will try to detect BOM (Byte
516           Order Mark) in the header line. This requires Text::CSV_XS version
517           1.22 or higher.
518
519             $dbh = DBI->connect ("dbi:CSV:", "", "", { csv_bom => 1 });
520
521             $dbh->{csv_bom} = 1;
522
523       csv_tables
524           This hash ref is used for storing table dependent metadata. For any
525           table it contains an element with the table name as key and another
526           hash ref with the following attributes:
527
528           o   All valid attributes to the CSV parsing module. Any of them can
529               optionally be prefixed with "csv_".
530
531           o   All attributes valid to DBD::File
532
533           If you pass it "f_file" or its alias "file", "f_ext" has no effect,
534           but "f_dir" and "f_encoding" still have.
535
536             csv_tables => {
537                 syspwd => {                   # Table name
538                     csv_sep_char => ":",      # Text::CSV_XS
539                     quote_char   => undef,    # Text::CSV_XS
540                     escape_char  => undef,    # Text::CSV_XS
541                     f_dir        => "/etc",   # DBD::File
542                     f_file       => "passwd", # DBD::File
543                     col_names    =>           # DBD::File
544                       [qw( login password uid gid realname directory shell )],
545                     },
546                 },
547
548       csv_*
549           All other attributes that start with "csv_" and are not described
550           above will be passed to "Text::CSV_XS" (without the "csv_" prefix).
551           These extra options are only likely to be useful for reading
552           (select) handles. Examples:
553
554             $dbh->{csv_allow_whitespace}    = 1;
555             $dbh->{csv_allow_loose_quotes}  = 1;
556             $dbh->{csv_allow_loose_escapes} = 1;
557
558           See the "Text::CSV_XS" documentation for the full list and the
559           documentation.
560
561   Driver specific attributes
562       f_file
563           The name of the file used for the table; defaults to
564
565               "$dbh->{f_dir}/$table"
566
567       eol
568       sep_char
569       quote_char
570       escape_char
571       class
572       csv These correspond to the attributes csv_eol, csv_sep_char,
573           csv_quote_char, csv_escape_char, csv_class and csv_csv.  The
574           difference is that they work on a per-table basis.
575
576       col_names
577       skip_first_row
578           By default DBD::CSV assumes that column names are stored in the
579           first row of the CSV file and sanitizes them (see "raw_header"
580           below). If this is not the case, you can supply an array ref of
581           table names with the col_names attribute. In that case the
582           attribute skip_first_row will be set to FALSE.
583
584           If you supply an empty array ref, the driver will read the first
585           row for you, count the number of columns and create column names
586           like "col0", "col1", ...
587
588           Note that column names that match reserved SQL words will cause
589           unwanted and sometimes confusing errors. If your CSV has headers
590           that match reserved words, you will require these two attributes.
591
592           If "test.csv" looks like
593
594            select,from
595            1,2
596
597           the select query would result in "select select, from from test;",
598           which obviously is illegal SQL.
599
600       raw_header
601           Due to the SQL standard, field names cannot contain special
602           characters like a dot (".") or a space (" ") unless the column
603           names are quoted.  Following the approach of mdb_tools, all these
604           tokens are translated to an underscore ("_") when reading the first
605           line of the CSV file, so all field names are 'sanitized'. If you do
606           not want this to happen, set "raw_header" to a true value and the
607           entries in the first line of the CSV data will be used verbatim for
608           column headers and field names.  DBD::CSV cannot guarantee that any
609           part in the toolchain will work if field names have those
610           characters, and the chances are high that the SQL statements will
611           fail.
612
613           Currently, the sanitizing of headers is as simple as
614
615             s/\W/_/g;
616
617           Note that headers (column names) might be folded in other parts of
618           the code stack, specifically SQL::Statement, whose docs mention:
619
620            Wildcards are expanded to lower cased identifiers. This might
621            confuse some people, but it was easier to implement.
622
623           That means that in
624
625            my $sth = $dbh->prepare ("select * from foo");
626            $sth->execute;
627            while (my $row = $sth->fetchrow_hashref) {
628                say for keys %$row;
629                }
630
631           all keys will show as all lower case, regardless of the original
632           header.
633
634       It's strongly recommended to check the attributes supported by
635       "Metadata" in DBD::File.
636
637       Example: Suppose you want to use /etc/passwd as a CSV file. :-) There
638       simplest way is:
639
640           use DBI;
641           my $dbh = DBI->connect ("dbi:CSV:", undef, undef, {
642               f_dir           => "/etc",
643               csv_sep_char    => ":",
644               csv_quote_char  => undef,
645               csv_escape_char => undef,
646               });
647           $dbh->{csv_tables}{passwd} = {
648               col_names => [qw( login password uid gid realname
649                                 directory shell )];
650               };
651           $sth = $dbh->prepare ("SELECT * FROM passwd");
652
653       Another possibility where you leave all the defaults as they are and
654       override them on a per table basis:
655
656           require DBI;
657           my $dbh = DBI->connect ("dbi:CSV:");
658           $dbh->{csv_tables}{passwd} = {
659               eol         => "\n",
660               sep_char    => ":",
661               quote_char  => undef,
662               escape_char => undef,
663               f_file      => "/etc/passwd",
664               col_names   => [qw( login password uid gid
665                                   realname directory shell )],
666               };
667           $sth = $dbh->prepare ("SELECT * FROM passwd");
668
669   Driver private methods
670       These methods are inherited from DBD::File:
671
672       data_sources
673           The "data_sources" method returns a list of sub-directories of the
674           current directory in the form "dbi:CSV:directory=$dirname".
675
676           If you want to read the sub-directories of another directory, use
677
678               my $drh  = DBI->install_driver ("CSV");
679               my @list = $drh->data_sources (f_dir => "/usr/local/csv_data");
680
681       list_tables
682           This method returns a list of file-names inside $dbh->{directory}.
683           Example:
684
685               my $dbh  = DBI->connect ("dbi:CSV:directory=/usr/local/csv_data");
686               my @list = $dbh->func ("list_tables");
687
688           Note that the list includes all files contained in the directory,
689           even those that have non-valid table names, from the view of SQL.
690           See "Creating and dropping tables" above.
691

KNOWN ISSUES

693       •   The module is using flock () internally. However, this function is
694           not available on some platforms. Use of flock () is disabled on
695           MacOS and Windows 95: There's no locking at all (perhaps not so
696           important on these operating systems, as they are for single users
697           anyways).
698

TODO

700       Tests
701           Aim for a full 100% code coverage
702
703            - eol      Make tests for different record separators.
704            - csv_xs   Test with a variety of combinations for
705                       sep_char, quote_char, and escape_char testing
706            - quoting  $dbh->do ("drop table $_") for DBI-tables ();
707            - errors   Make sure that all documented exceptions are tested.
708                       . write to write-protected file
709                       . read from badly formatted csv
710                       . pass bad arguments to csv parser while fetching
711
712           Add tests that specifically test DBD::File functionality where that
713           is useful.
714
715       RT  Attack all open DBD::CSV bugs in RT
716
717       CPAN::Forum
718           Attack all items in http://www.cpanforum.com/dist/DBD-CSV
719
720       Documentation
721           Expand on error-handling, and document all possible errors.  Use
722           Text::CSV_XS::error_diag () wherever possible.
723
724       Debugging
725           Implement and document dbd_verbose.
726
727       Data dictionary
728           Investigate the possibility to store the data dictionary in a file
729           like .sys$columns that can store the field attributes (type, key,
730           nullable).
731
732       Examples
733           Make more real-life examples from the docs in examples/
734

SEE ALSO

736       DBI, Text::CSV_XS, SQL::Statement, DBI::SQL::Nano
737
738       For help on the use of DBD::CSV, see the DBI users mailing list:
739
740         http://lists.cpan.org/showlist.cgi?name=dbi-users
741
742       For general information on DBI see
743
744         http://dbi.perl.org/ and http://faq.dbi-support.com/
745

AUTHORS and MAINTAINERS

747       This module is currently maintained by
748
749           H.Merijn Brand <h.m.brand@xs4all.nl>
750
751       in close cooperation with and help from
752
753           Jens Rehsack <sno@NetBSD.org>
754
755       The original author is Jochen Wiedmann.  Previous maintainer was Jeff
756       Zucker
757
759       Copyright (C) 2009-2022 by H.Merijn Brand Copyright (C) 2004-2009 by
760       Jeff Zucker Copyright (C) 1998-2004 by Jochen Wiedmann
761
762       All rights reserved.
763
764       You may distribute this module under the terms of either the GNU
765       General Public License or the Artistic License, as specified in the
766       Perl README file.
767
768
769
770perl v5.34.0                      2022-01-21                       DBD::CSV(3)
Impressum