1DBIx::XHTML_Table(3)  User Contributed Perl Documentation DBIx::XHTML_Table(3)
2
3
4

NAME

6       DBIx::XHTML_Table - SQL query result set to XHTML table.
7

SYNOPSIS

9         use DBIx::XHTML_Table;
10
11         # database credentials - fill in the blanks
12         my ($data_source,$usr,$pass) = ();
13
14         my $table = DBIx::XHTML_Table->new($data_source,$usr,$pass);
15
16         $table->exec_query("
17             select foo from bar
18             where baz='qux'
19             order by foo
20         ");
21
22         print $table->output();
23
24         # stackable method calls:
25         print DBIx::XHTML_Table
26           ->new($data_source,$usr,$pass)
27           ->exec_query('select foo,baz from bar')
28           ->output();
29
30         # and much more - read on ...
31

DESCRIPTION

33       DBIx::XHTML_Table is a DBI extension that creates an HTML table from a
34       database query result set. It was created to fill the gap between
35       fetching data from a database and transforming that data into a web
36       browser renderable table. DBIx::XHTML_Table is intended for programmers
37       who want the responsibility of presenting (decorating) data, easily.
38       This module is meant to be used in situations where the concern for
39       presentation and logic seperation is overkill.  Providing logic or
40       editable data is beyond the scope of this module, but it is capable of
41       doing such.
42

CODE FREEZE

44       For the most part, no new functionality will be added to this module.
45       Only bug fixes and documentation corrections/additions. All new efforts
46       will be directed towards the rewrite of this distribution, DBIx::HTML.
47
48       This distribution features a more flexible interface with fewer methods
49       and logically named argument parameters. At the core is an HTML
50       attribute generator:
51
52       •   Tie::Hash::Attribute
53
54       Which is used by an HTML tag generator:
55
56       •   HTML::AutoTag
57
58       Which is used by an HTML table generator:
59
60       •   Spreadsheet::HTML
61
62       Which is finally wrapped by a DBI extension:
63
64       •   DBIx::HTML
65

WEBSITE

67       More documentation (tutorial, cookbook, FAQ, etc.) can be found at
68
69         http://www.unlocalhost.com/XHTML_Table/
70

GITHUB

72         https://github.com/jeffa/DBIx-XHTML_Table
73

CONSTRUCTOR

75       style_1
76             $obj_ref = new DBIx::XHTML_Table(@credentials[,$attribs])
77
78           Note - all optional arguments are denoted inside brackets.
79
80           The constructor will simply pass the credentials to the
81           DBI::connect method - read the DBI documentation as well as the
82           docs for your corresponding DBI driver module (DBD::Oracle,
83           DBD::Sybase, DBD::mysql, etc).
84
85             # MySQL example
86             my $table = DBIx::XHTML_Table->new(
87               'DBI:mysql:database:host',   # datasource
88               'user',                      # user name
89               'password',                  # user password
90             ) or die "couldn't connect to database";
91
92           The last argument, $attribs, is an optional hash reference and
93           should not be confused with the DBI::connect method's similar
94           'attributes' hash reference.'
95
96             # valid example for last argument
97             my $attribs = {
98               table => {
99                 border      => 1,
100                 cellspacing => 0,
101                 rules       => 'groups',
102               },
103               caption => 'Example',
104               td => {
105                 style => 'text-align: right',
106               },
107             };
108
109             my $table = DBIx::XHTML_Table->new(
110                 $data_source,$user,$pass,$attribs
111             ) or die "couldn't connect to database";
112
113           But it is still experimental and unpleasantly limiting.  The
114           purpose of $table_attribs is to bypass having to call modify()
115           multiple times. However, if you find yourself calling modify() more
116           than 4 or 5 times, then DBIx::XHTML_Table might be the wrong tool.
117           I recommend HTML::Template or Template-Toolkit, both available at
118           CPAN.
119
120       style_2
121             $obj_ref = new DBIx::XHTML_Table($DBH[,$attribs])
122
123           The first style will result in the database handle being created
124           and destroyed 'behind the scenes'. If you need to keep the database
125           connection open after the XHTML_Table object is destroyed, then
126           create one yourself and pass it to the constructor:
127
128             my $dbh = DBI->connect(
129               $data_source,$usr,$passwd,
130               {RaiseError => 1},
131             );
132
133             my $table = DBIx::XHTML_Table->new($dbh);
134               # do stuff
135             $dbh->disconnect;
136
137           You can also use any class that isa() DBI::db object, such as
138           Apache::DBI or DBIx::Password objects:
139
140             my $dbh   = DBIx::Password->connect($user);
141             my $table = DBIx::XHTML_Table->new($dbh);
142
143       style_3
144             $obj_ref = new DBIx::XHTML_Table($rows[,$headers])
145
146           The final style allows you to bypass a database altogether if need
147           be. Simply pass a LoL (list of lists) such as the one passed back
148           from the DBI method "selectall_arrayref()". The first row will be
149           treated as the table heading. You are responsible for supplying the
150           column names. Here is one way to create a table after modifying the
151           result set from a database query:
152
153             my $dbh  = DBI->connect($dsource,$usr,$passwd);
154             my $sth = $dbh->prepare('select foo,baz from bar');
155             $sth->execute();
156
157             # order is essential here
158             my $headers = $sth->{'NAME'};
159             my $rows    = $sth->fetchall_arrayref();
160
161             # do something to $rows
162
163             my $table = DBIx::XHTML_Table->new($rows,$headers);
164
165           If $headers is not supplied, then the first row from the first
166           argument will be shifted off and used instead.  While obtaining the
167           data from a database is the entire point of this module, there is
168           nothing stopping you from simply hard coding it:
169
170             my $rows = [
171                [ qw(Head1 Head2 Head3) ],
172                [ qw(foo bar baz)       ],
173                [ qw(one two three)     ],
174                [ qw(un deux trois)     ]
175             ];
176
177             my $table = DBIx::XHTML_Table->new($rows);
178
179           And that is why $headers is optional.
180

OBJECT METHODS

182       exec_query
183             $table->exec_query($sql[,$bind_vars])
184
185           Pass the query off to the database with hopes that data will be
186           returned. The first argument is scalar that contains the SQL code,
187           the optional second argument can either be a scalar for one bind
188           variable or an array reference for multiple bind vars:
189
190             $table->exec_query('
191                 select bar,baz from foo
192                 where bar = ?
193                 and   baz = ?
194             ',[$foo,$bar]);
195
196           exec_query() also accepts a prepared DBI::st handle:
197
198             my $sth = $dbh->prepare('
199                 select bar,baz from foo
200                 where bar = ?
201                 and   baz = ?
202             ');
203
204             $table->exec_query($sth,[$foo,$bar]);
205
206           Consult the DBI documentation for more details on bind vars.
207
208           After the query successfully executes, the results will be stored
209           interally as a 2-D array. The XHTML table tags will not be
210           generated until the output() method is invoked.
211
212       output
213             $scalar = $table->output([$attribs])
214
215           Renders and returns the XHTML table. The only argument is an
216           optional hash reference that can contain any combination of the
217           following keys, set to a true value. Most of the time you will not
218           want to use this argument, but there are three times when you will:
219
220             # 1 - do not display a thead section
221             print $table->output({ no_head => 1 });
222
223           This will cause the thead section to be suppressed, but not the
224           caption if you set one. The column foots can be suppressed by not
225           calculating totals, and the body can be suppressed by an
226           appropriate SQL query. The caption and colgroup cols can be
227           suppressed by not modifying them. The column titles are the only
228           section that has to be specifically 'told' not to generate, and
229           this is where you do that.
230
231             # 2 - do not format the headers with ucfirst
232             print $table->output({ no_ucfirst => 1 });
233
234           This allows you to bypass the automatic upper casing of the first
235           word in each of the column names in the table header. If you just
236           wish to have them displayed as all lower case, then use this
237           option, if you wish to use some other case, use map_head()
238
239             # 3 - 'squash' the output HTML table
240             print $table->output({ no_indent => 1 });
241
242           This will result in the output having no text aligning whitespace,
243           that is no newline(\n) and tab(\t) characters. Useful for squashing
244           the total number of bytes resulting from large return sets.
245
246           You can combine these attributes, but there is no reason to use
247           no_ucfirst in conjunction with no_head.
248
249           Note: versions prior to 0.98 used a two argument form:
250
251             $scalar = $table->output([$sans_title,$sans_whitespace])
252
253           You can still use this form to suppress titles and whitespace, but
254           warnings will be generated.
255
256           HTML encoding of table cells is turned off by default, but can be
257           turned on via:
258
259             $table->{encode_cells} = 1;
260
261       get_table
262             $scalar = $table->get_table([ {attribs} ])
263
264           Deprecated - use output() instead.
265
266       modify
267             $table->modify($tag,$attribs[,$cols])
268
269           This method will store a 'memo' of what attributes you have
270           assigned to various tags within the table. When the table is
271           rendered, these memos will be used to create attributes. The first
272           argument is the name of the tag you wish to modify the attributes
273           of. You can supply any tag name you want without fear of halting
274           the program, but the only tag names that are handled are <table>
275           <caption> <thead> <tfoot> <tbody> <colgroup> <col> <tr> <th> and
276           <td>. The tag name will be converted to lowercase, so you can
277           practice safe case insensitivity.
278
279           The next argument is a reference to a hash that contains the
280           attributes you wish to apply to the tag. For example, this sets the
281           attributes for the <table> tag:
282
283             $table->modify('table',{
284                border => '2',
285                width  => '100%'
286             });
287
288             # a more Perl-ish way
289             $table->modify(table => {
290                border => 2,
291                width  => '100%',
292             });
293
294             # you can even specify CSS styles
295             $table->modify(td => {
296                style => 'color: blue; text-align: center',
297             });
298
299             # there is more than one way to do it
300             $table->modify(td => {
301                style => {
302                   color        => 'blue',
303                   'text-align' => 'center',
304                }
305             });
306
307           Each key in the hash ref will be lower-cased, and each value will
308           be surrounded in quotes. Note that typos in attribute names will
309           not be caught by this module. Any attribute can be used, valid
310           XHTML attributes tend be more effective. And yes, JavaScript works
311           too.
312
313           You can even use an array reference as the key values:
314
315             $table->modify(td => {
316                bgcolor => [qw(red purple blue green yellow orange)],
317             }),
318
319           As the table is rendered row by row, column by column, the elements
320           of the array reference will be 'rotated' across the <td> tags,
321           causing different effects depending upon the number of elements
322           supplied and the number of columns and rows in the table. The
323           following is the preferred XHTML way with CSS styles:
324
325             $table->modify(th => {
326                style => {
327                   background => ['#cccccc','#aaaaaa'],
328                }
329             });
330
331           See the set_row_color() and set_col_color() methods for more info.
332
333           The last argument to modify() is optional and can either be a
334           scalar representing a single column or area, or an array reference
335           containing multilple columns or areas. The columns will be the
336           corresponding names of the columns from the SQL query, or their
337           anticipated index number, starting at zero.  The areas are one of
338           three values: HEAD, BODY, or FOOT.  The columns and areas you
339           specify are case insensitive.
340
341             # just modify the titles
342             $table->modify(th => {
343                bgcolor => '#bacaba',
344             }, 'head');
345
346             # only <td> tags in column FOO will be set
347             $table->modify(td => {
348                style => 'text-align: center'
349             },'foo');
350
351             # <td> tags for the second and third columns (indexes 1 and 2)
352             $table->modify(td => {
353                style => 'text-align: right'
354             },[1,2]);
355
356           You cannot currently mix areas and columns in the same method call.
357           That is, you cannot set a specific column in the 'head' area, but
358           not the 'body' area. This _might_ change in the future, but such
359           specific needs are a symptom of needing a more powerful tool.
360
361           As of Version 1.10, multiple calls to modfiy() are inheritable.
362           For example, if you set an attribute for all <td> tags and set
363           another attribute for a specific column, that specific column will
364           inherit both attributes:
365
366             $table->modify(td => {foo => 'bar'});
367             $table->modify(td => {baz => 'qux'},'Salary');
368
369           In the preceding code, all <td> tags will have the attribute 'foo =
370           "bar"', and the <td> tags for the 'Salary' column will have the
371           attributes 'foo = "bar"' and 'baz = "qux"'. Should you not this
372           behavior, you can 'erase' the unwanted attribute by setting the
373           value of an attribute to the empty string:
374
375             $table->modify(td => {foo => 'bar'});
376             $table->modify(td => {foo =>'', baz => 'qux'},'Salary');
377
378           Note the use of the empty string and not undef or 0. Setting the
379           value to undef will work, but will issue a warning if you have
380           warnings turned on. Setting the value to 0 will set the value of
381           the attribute to 0, not remove it.
382
383           A final caveat is setting the <caption> tag. This one breaks the
384           signature convention:
385
386             $table->modify(tag => $value, $attrib);
387
388           Since there is only one <caption> allowed in an XHTML table, there
389           is no reason to bind it to a column or an area:
390
391             # with attributes
392             $table->modify(
393                caption => 'A Table Of Contents',
394                { align => 'bottom' }
395             );
396
397             # without attributes
398             $table->modify(caption => 'A Table Of Contents');
399
400           The only tag that cannot be modified by modify() is the <col> tag.
401           Use add_col_tag() instead.
402
403       modify_tag
404             $table->modify_tag($tag,$attribs[,$cols])
405
406           Deprecated, use the easier to type modify() instead.
407
408       add_col_tag
409             $table->add_col_tag($cols)
410
411           Add a new <col> tag and attributes. The only argument is reference
412           to a hash that contains the attributes for this <col> tag. Multiple
413           <col> tags require multiple calls to this method. The <colgroup>
414           tag pair will be automatically generated if at least one <col> tag
415           is added.
416
417           Advice: use <col> and <colgroup> tags wisely, don't do this:
418
419             # bad
420             for (0..39) {
421               $table->add_col_tag({
422                  foo => 'bar',
423               });
424             }
425
426           When this will suffice:
427
428             # good
429             $table->modify(colgroup => {
430                span => 40,
431                foo  => 'bar',
432             });
433
434           You should also consider using <col> tags to set the attributes of
435           <td> and <th> instead of the <td> and <th> tags themselves,
436           especially if it is for the entire table. Notice the use of the
437           get_col_count() method in this example to span the entire table:
438
439             $table->add_col_tag({
440                span  => $table->get_col_count(),
441                style => 'text-align: center',
442             });
443
444       map_cell
445             $table->map_cell($subroutine[,$cols])
446
447           Map a supplied subroutine to all the <td> tag's cdata for the
448           specified columns.  The first argument is a reference to a
449           subroutine. This subroutine should shift off a single scalar at the
450           beginning, munge it in some fasion, and then return it.  The second
451           argument is the column (scalar) or columns (reference to a list of
452           scalars) to apply this subroutine to. Example:
453
454             # uppercase the data in column DEPARTMENT
455             $table->map_cell( sub { return uc shift }, 'department');
456
457             # uppercase the data in the fifth column
458             $table->map_cell( sub { return uc shift }, 4);
459
460           One temptation that needs to be addressed is using this method to
461           color the cdata inside a <td> tag pair. For example:
462
463             # don't be tempted to do this
464             $table->map_cell(sub {
465               return qq|<font color="red">| . shift . qq|</font>|;
466             }, [qw(first_name last_name)]);
467
468             # when CSS styles will work
469             $table->modify(td => {
470               style => 'color: red',
471             }, [qw(first_name last_name)]);
472
473           Note that the get_current_row() and get_current_col() can be used
474           inside the sub reference. See set_pk() below for an example.
475
476           All columns are used if none are specified, and you can specify
477           index number(s) as well as name(s).  Also, exec_query() must be
478           called and data must be returned from the database prior to calling
479           this method, otherwise the call back will be ignored and a warning
480           will be generated.  This is true for map_head() as well.
481
482       map_col
483             $table->map_col($subroutine[,$cols])
484
485           Deprecated - use map_cell() instead.
486
487       map_head
488             $table->map_head($subroutine[,$cols])
489
490           Just like map_cell() except it modifies only column headers, i.e.
491           the <th> data located inside the <thead> section. The immediate
492           application is to change capitalization of the column headers,
493           which are defaulted to ucfirst:
494
495             $table->map_head(sub { uc shift });
496
497           Instead of using map_head() to lower case the column headers, just
498           specify that you don't want default capitalization with output():
499
500             $table->output({ no_ucfirst => 1 });
501
502       set_row_colors
503             $table->set_row_colors($colors[,$attrib_name]);
504
505           This method will produce horizontal stripes.  This first argument
506           is an array reference that contains the colors to use. Each row
507           will get a color from the list - when the last color in the list is
508           reached, then the rotation will start over at the beginning.  This
509           will continue until all <tr> tags have been generated. If you don't
510           supply an array reference with at least 2 colors then this method
511           will return without telling you.
512
513           set_row_colors() by default will use CSS styles to color the rows.
514           The optional second argument is a single scalar that can be used to
515           specify another attribute instead of the CSS style 'color'. For
516           example, you could use 'class' or even deprecated HTML attributes
517           such as 'bgcolor' or 'width'.
518
519           This method is just a more convenient way to do the same thing with
520           the modify() modify.
521
522           See http://www.unlocalhost.com/XHTML_Table/cookbook.html#5 for more
523           information on coloring the table.
524
525       set_col_colors
526             $table->set_col_colors($colors[,$attrib_name]);
527
528           This method will produce vertical stripes.  The first argument is
529           an array reference to arrays just like set_row_colors().
530
531           Unlike set_row_colors()  however, this module is more than just a
532           convenient way to do the same with the modify() method.  The
533           problem arises when you supply an odd number of colors for an even
534           number of columns, vice versa, or both odd. The result will be a
535           checkerboard. Not very readable for anything except board games. By
536           using set_col_colors() instead, the result will always be vertical
537           stripes.
538
539           set_col_colors() by default will use CSS styles to color the rows.
540           The optional second argument is a single scalar that can be used to
541           specify another attribute instead of the CSS style 'color'. For
542           example, you could use 'class' or even deprecated HTML attributes
543           such as 'bgcolor' or 'width'.
544
545           See http://www.unlocalhost.com/XHTML_Table/cookbook.html#5 for more
546           information on coloring the table.
547
548       set_null_value
549             $table->set_null_value($new_null_value)
550
551           Change the default null_value (&nbsp;) to something else.  Any
552           column that is undefined will have this value substituted instead.
553
554       set_pk
555             $table->set_pk([$primary_key]);
556
557           This method must be called before exec_query() in order to work!
558
559           Note that the single argument to this method, $primary_key, is
560           optional.  If you do not specify a primary key, then 'id' will be
561           used.
562
563           This is highly specialized method - the need is when you want to
564           select the primary key along with the columns you want to display,
565           but you don't want to display it as well. The value will be
566           accessible via the get_current_row() method. This is useful as a a
567           callback via the map_cell() method.  Consider the following:
568
569             $table->map_cell(sub {
570               my $datum = shift;
571               my $row   = $table->get_current_row();
572               my $col   = $table->get_current_col();
573               return qq|<input type="text" name="$row:$col" value="$datum">|;
574             });
575
576           This will render a "poor man's" spreadsheet, provided that set_pk()
577           was called with the proper primary key before exec_query() was
578           called.  Now each input has a name that can be split to reveal
579           which row and column the value belongs to.
580
581           Big thanks to Jim Cromie for the idea.
582
583       set_group
584             $table->set_group($column[,$no_dups,$replace_with])
585
586           Assign one column as the main column. Every time a new row is
587           encountered for this column, a <tbody> tag is written. An optional
588           second argument that contains a defined, non-zero value will cause
589           duplicates to be permanantly eliminated for this row. An optional
590           third argument specifies what value to replace for duplicates,
591           default is &nbsp;
592
593             # replace duplicates with the global 'null_value'
594             $table->set_group('Branch',1);
595
596             # replace duplicates with a new value
597             $table->set_group('Branch',1,'----');
598
599             # or in a more Perl-ish way
600             $table->set_group('Branch',nodups=>'----');
601
602           Don't assign a column that has a different value each row, choose
603           one that is a super class to the rest of the data, for example,
604           pick album over song, since an album consists of songs.
605
606           So, what's it good for? If you set a group (via the set_group()
607           method) and supply the following:
608
609             # well, and you are viewing in IE...
610             $table->modify(table => {
611               cellspacing => 0,
612               rules       => 'groups',
613             });
614
615           then horizontal lines will only appear at the point where the
616           'grouped' rows change. This had to be implemented in the past with
617           <table>'s inside of <table>'s. Much nicer! Add this for a nice
618           coloring trick:
619
620             # this works with or without setting a group, by the way
621             $table->modify(tbody => {
622               bgcolor => [qw(insert rotating colors here)],
623             });
624
625       calc_totals
626             $table->calc_totals([$cols,$mask])
627
628           Computes totals for specified columns. The first argument is the
629           column or columns to sum, again a scalar or array reference is the
630           requirement.  If $cols is not specified, all columns will be
631           totaled. Non-numbers will be ignored, negatives and floating points
632           are supported, but you have to supply an appropriate sprintf mask,
633           which is the optional second argument, in order for the sum to be
634           correctly formatted. See the sprintf docs for further details.
635
636       calc_subtotals
637             $table->calc_subtotals([$cols,$mask])
638
639           Computes subtotals for specified columns. It is mandatory that you
640           first specify a group via set_group() before you call this method.
641           Each subtotal is tallied from the rows that have the same value in
642           the column that you specified to be the group. At this point, only
643           one subtotal row per group can be calculated and displayed.
644
645       get_col_count
646             $scalar = $table->get_col_count()
647
648           Returns the number of columns in the table.
649
650       get_row_count
651             $scalar = $table->get_row_count()
652
653           Returns the numbers of body rows in the table.
654
655       get_current_row
656             $scalar = $table->get_current_row()
657
658           Returns the value of the primary key for the current row being
659           processed.  This method is only meaningful inside a map_cell()
660           callback; if you access it otherwise, you will either receive undef
661           or the value of the primary key of the last row of data.
662
663       get_current_col
664             $scalar = $table->get_current_col()
665
666           Returns the name of the column being processed.  This method is
667           only meaningful inside a map_cell() callback; if you access it
668           otherwise, you will either receive undef or the the name of the
669           last column specified in your SQL statement.
670
671       add_cols
672              $table->add_cols(
673                 { header => '', data => [], before => '' }, { ... }, ...
674              );
675
676           Going against the philosophy of only select what you need from the
677           database, this sub allows you to remove whole columns. 'header' is
678           the name of the new column, you will have to ucfirst yourself. It
679           is up to you to ensure that that the size of 'data' is the same as
680           the number of rows in the original data set. 'before' can be an
681           index or the name of the column. For example, to add a new column
682           to the beginning:
683
684              $table->add_cols({name=>'New', data=>\@rows, before => 0});
685
686           add a new column to the end:
687
688              $table->add_cols({name=>'New', data=>\@rows});
689
690           or somewhere in the middle:
691
692              $table->add_cols({name=>'New', data=>\@rows}, before => 'age'});
693
694           or combine all three into one call:
695
696              $table->add_cols(
697                 {name=>'Foo', data=>\@rows, before => 0},
698                 {name=>'Bar', data=>\@rows},
699                 {name=>'Baz', data=>\@rows}, before => 'Bar'},
700              );
701
702       drop_cols
703              $table->drop_cols([qw(foo bar 5)];
704
705           Like add_cols, drop_cols goes against said 'philosophy', but it is
706           here for the sake of TIMTWOTDI. Simply pass it an array ref that
707           contains either the name or positions of the columns you want to
708           drop.
709
710       new Things with the stuff.
711
712       reset
713           Stuff with the things.
714

TAG REFERENCE

716           TAG        CREATION    BELONGS TO AREA
717       +------------+----------+--------------------+
718       | <table>    |   auto   |       ----         |
719       | <caption>  |  manual  |       ----         |
720       | <colgroup> |   both   |       ----         |
721       | <col>*     |  manual  |       ----         |
722       | <thead>    |   auto   |       head         |
723       | <tbody>    |   auto   |       body         |
724       | <tfoot>    |   auto   |       foot         |
725       | <tr>       |   auto   |  head,body,foot    |
726       | <td>       |   auto   |       body         |
727       | <th>       |   auto   |  head,body,foot    |
728       +------------+-------------------------------+
729
730        * All tags use modify() to set attributes
731          except <col>, which uses add_col_tag() instead
732

BUGS

734       If you have found a bug, typo, etc. please visit Best Practical
735       Solution's CPAN bug tracker at http://rt.cpan.org:
736
737       <http://rt.cpan.org/NoAuth/Bugs.html?Dist=DBIx-XHTML_Table>
738
739       or send mail to <bug-DBIx-XHTML_Table#rt.cpan.org>
740
741       (you got this far ... you can figure out how to make that a valid
742       address ... and note that i won't respond to bugs sent to my personal
743       address any longer)
744

ISSUES

746       Problems with 'SELECT *'
747           Users are recommended to avoid 'select *' and instead specify the
748           names of the columns. Problems have been reported using 'select *'
749           with SQLServer7 will cause certain 'text' type columns not to
750           display. I have not experienced this problem personally, and tests
751           with Oracle and MySQL show that they are not affected by this.
752           SQLServer7 users, please help me confirm this. :)
753
754       Not specifying <body> tag in CGI scripts
755           I anticipate this module to be used by CGI scripts, and when
756           writing my own 'throw-away' scripts, I noticed that Netscape 4 will
757           not display a table that contains XHTML tags IF a <body> tag is NOT
758           found. Be sure and print one out.
759

CREDITS

761       Briac [OeufMayo] Pilpré for the name.
762
763       Mark [extremely] Mills for patches and suggestions.
764
765       Jim Cromie for presenting the whole spreadsheet idea.
766
767       Stephen Nelson for documentation/code corrections.
768
769       Matt Sergeant for DBIx::XML_RDB.
770
771       Aaron [trs80] Johnson for convincing me into writing add and drop cols.
772
773       Richard Piacentini and Tim Alexander for recommending DBIx::Password
774       and Apache::DBI compatability and Slaven Rezic for recommending using
775       UNIVERSAL::isa().
776
777       Perl Monks for the education.
778

SEE ALSO

780       DBI
781

AUTHOR

783       Jeff Anderson
784
786       Copyright 2017 Jeff Anderson.
787
788       This program is free software; you can redistribute it and/or modify it
789       under the terms of the the Artistic License (2.0). You may obtain a
790       copy of the full license at:
791
792       <http://www.perlfoundation.org/artistic_license_2_0>
793
794       Any use, modification, and distribution of the Standard or Modified
795       Versions is governed by this Artistic License. By using, modifying or
796       distributing the Package, you accept this license. Do not use, modify,
797       or distribute the Package, if you do not accept this license.
798
799       If your Modified Version has been derived from a Modified Version made
800       by someone other than you, you are nevertheless required to ensure that
801       your Modified Version complies with the requirements of this license.
802
803       This license does not grant you the right to use any trademark, service
804       mark, tradename, or logo of the Copyright Holder.
805
806       This license includes the non-exclusive, worldwide, free-of-charge
807       patent license to make, have made, use, offer to sell, sell, import and
808       otherwise transfer the Package with respect to any patent claims
809       licensable by the Copyright Holder that are necessarily infringed by
810       the Package. If you institute patent litigation (including a cross-
811       claim or counterclaim) against any party alleging that the Package
812       constitutes direct or contributory patent infringement, then this
813       Artistic License to you shall terminate on the date that such
814       litigation is filed.
815
816       Disclaimer of Warranty: THE PACKAGE IS PROVIDED BY THE COPYRIGHT HOLDER
817       AND CONTRIBUTORS "AS IS' AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES.
818       THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
819       PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED TO THE EXTENT PERMITTED BY
820       YOUR LOCAL LAW. UNLESS REQUIRED BY LAW, NO COPYRIGHT HOLDER OR
821       CONTRIBUTOR WILL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OR
822       CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THE PACKAGE,
823       EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
824
825
826
827perl v5.34.0                      2022-01-21              DBIx::XHTML_Table(3)
Impressum