1DBIx::XHTML_Table(3) User Contributed Perl Documentation DBIx::XHTML_Table(3)
2
6 DBIx::XHTML_Table - SQL query result set to XHTML table.
7
9 use DBIx::XHTML_Table;
10 # database credentials - fill in the blanks
12 my ($data_source,$usr,$pass) = ();
13 my $table = DBIx::XHTML_Table->new($data_source,$usr,$pass);
15 $table->exec_query("
17 select foo from bar
18 where baz='qux'
19 order by foo
20 ");
21 print $table->output();
23 # 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 # and much more - read on ...
31
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
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 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 · Tie::Hash::Attribute
53 Which is used by an HTML tag generator:
55 · HTML::AutoTag
57 Which is used by an HTML table generator:
59 · Spreadsheet::HTML
61 Which is finally wrapped by a DBI extension:
63 · DBIx::HTML
65
67 More documentation (tutorial, cookbook, FAQ, etc.) can be found at
68 http://www.unlocalhost.com/XHTML_Table/
70
72 https://github.com/jeffa/DBIx-XHTML_Table
73
75 style_1
76 $obj_ref = new DBIx::XHTML_Table(@credentials[,$attribs])
77 Note - all optional arguments are denoted inside brackets.
79 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 # 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 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 # 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 my $table = DBIx::XHTML_Table->new(
110 $data_source,$user,$pass,$attribs
111 ) or die "couldn't connect to database";
112 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 style_2
121 $obj_ref = new DBIx::XHTML_Table($DBH[,$attribs])
122 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 my $dbh = DBI->connect(
129 $data_source,$usr,$passwd,
130 {RaiseError => 1},
131 );
132 my $table = DBIx::XHTML_Table->new($dbh);
134 # do stuff
135 $dbh->disconnect;
136 You can also use any class that isa() DBI::db object, such as
138 Apache::DBI or DBIx::Password objects:
139 my $dbh = DBIx::Password->connect($user);
141 my $table = DBIx::XHTML_Table->new($dbh);
142 style_3
144 $obj_ref = new DBIx::XHTML_Table($rows[,$headers])
145 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 my $dbh = DBI->connect($dsource,$usr,$passwd);
154 my $sth = $dbh->prepare('select foo,baz from bar');
155 $sth->execute();
156 # order is essential here
158 my $headers = $sth->{'NAME'};
159 my $rows = $sth->fetchall_arrayref();
160 # do something to $rows
162 my $table = DBIx::XHTML_Table->new($rows,$headers);
164 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 my $rows = [
171 [ qw(Head1 Head2 Head3) ],
172 [ qw(foo bar baz) ],
173 [ qw(one two three) ],
174 [ qw(un deux trois) ]
175 ];
176 my $table = DBIx::XHTML_Table->new($rows);
178 And that is why $headers is optional.
180
182 exec_query
183 $table->exec_query($sql[,$bind_vars])
184 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 $table->exec_query('
191 select bar,baz from foo
192 where bar = ?
193 and baz = ?
194 ',[$foo,$bar]);
195 exec_query() also accepts a prepared DBI::st handle:
197 my $sth = $dbh->prepare('
199 select bar,baz from foo
200 where bar = ?
201 and baz = ?
202 ');
203 $table->exec_query($sth,[$foo,$bar]);
205 Consult the DBI documentation for more details on bind vars.
207 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 output
213 $scalar = $table->output([$attribs])
214 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 # 1 - do not display a thead section
221 print $table->output({ no_head => 1 });
222 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 # 2 - do not format the headers with ucfirst
232 print $table->output({ no_ucfirst => 1 });
233 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 # 3 - 'squash' the output HTML table
240 print $table->output({ no_indent => 1 });
241 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 You can combine these attributes, but there is no reason to use
247 no_ucfirst in conjunction with no_head.
248 Note: versions prior to 0.98 used a two argument form:
250 $scalar = $table->output([$sans_title,$sans_whitespace])
252 You can still use this form to suppress titles and whitespace, but
254 warnings will be generated.
255 HTML encoding of table cells is turned off by default, but can be
257 turned on via:
258 $table->{encode_cells} = 1;
260 get_table
262 $scalar = $table->get_table([ {attribs} ])
263 Deprecated - use output() instead.
265 modify
267 $table->modify($tag,$attribs[,$cols])
268 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 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 $table->modify('table',{
284 border => '2',
285 width => '100%'
286 });
287 # a more Perl-ish way
289 $table->modify(table => {
290 border => 2,
291 width => '100%',
292 });
293 # you can even specify CSS styles
295 $table->modify(td => {
296 style => 'color: blue; text-align: center',
297 });
298 # 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 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 You can even use an array reference as the key values:
314 $table->modify(td => {
316 bgcolor => [qw(red purple blue green yellow orange)],
317 }),
318 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 $table->modify(th => {
326 style => {
327 background => ['#cccccc','#aaaaaa'],
328 }
329 });
330 See the set_row_color() and set_col_color() methods for more info.
332 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 # just modify the titles
342 $table->modify(th => {
343 bgcolor => '#bacaba',
344 }, 'head');
345 # only <td> tags in column FOO will be set
347 $table->modify(td => {
348 style => 'text-align: center'
349 },'foo');
350 # <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 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 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 $table->modify(td => {foo => 'bar'});
367 $table->modify(td => {baz => 'qux'},'Salary');
368 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 $table->modify(td => {foo => 'bar'});
376 $table->modify(td => {foo =>'', baz => 'qux'},'Salary');
377 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 A final caveat is setting the <caption> tag. This one breaks the
384 signature convention:
385 $table->modify(tag => $value, $attrib);
387 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 # with attributes
392 $table->modify(
393 caption => 'A Table Of Contents',
394 { align => 'bottom' }
395 );
396 # without attributes
398 $table->modify(caption => 'A Table Of Contents');
399 The only tag that cannot be modified by modify() is the <col> tag.
401 Use add_col_tag() instead.
402 modify_tag
404 $table->modify_tag($tag,$attribs[,$cols])
405 Deprecated, use the easier to type modify() instead.
407 add_col_tag
409 $table->add_col_tag($cols)
410 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 Advice: use <col> and <colgroup> tags wisely, don't do this:
418 # bad
420 for (0..39) {
421 $table->add_col_tag({
422 foo => 'bar',
423 });
424 }
425 When this will suffice:
427 # good
429 $table->modify(colgroup => {
430 span => 40,
431 foo => 'bar',
432 });
433 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 $table->add_col_tag({
440 span => $table->get_col_count(),
441 style => 'text-align: center',
442 });
443 map_cell
445 $table->map_cell($subroutine[,$cols])
446 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 # uppercase the data in column DEPARTMENT
455 $table->map_cell( sub { return uc shift }, 'department');
456 # uppercase the data in the fifth column
458 $table->map_cell( sub { return uc shift }, 4);
459 One temptation that needs to be addressed is using this method to
461 color the cdata inside a <td> tag pair. For example:
462 # 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 # when CSS styles will work
469 $table->modify(td => {
470 style => 'color: red',
471 }, [qw(first_name last_name)]);
472 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 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 map_col
483 $table->map_col($subroutine[,$cols])
484 Deprecated - use map_cell() instead.
486 map_head
488 $table->map_head($subroutine[,$cols])
489 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 $table->map_head(sub { uc shift });
496 Instead of using map_head() to lower case the column headers, just
498 specify that you don't want default capitalization with output():
499 $table->output({ no_ucfirst => 1 });
501 set_row_colors
503 $table->set_row_colors($colors[,$attrib_name]);
504 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 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 This method is just a more convenient way to do the same thing with
520 the modify() modify.
521 See http://www.unlocalhost.com/XHTML_Table/cookbook.html#5 for more
523 information on coloring the table.
524 set_col_colors
526 $table->set_col_colors($colors[,$attrib_name]);
527 This method will produce vertical stripes. The first argument is
529 an array reference to arrays just like set_row_colors().
530 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 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 See http://www.unlocalhost.com/XHTML_Table/cookbook.html#5 for more
546 information on coloring the table.
547 set_null_value
549 $table->set_null_value($new_null_value)
550 Change the default null_value ( ) to something else. Any
552 column that is undefined will have this value substituted instead.
553 set_pk
555 $table->set_pk([$primary_key]);
556 This method must be called before exec_query() in order to work!
558 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 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 $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 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 Big thanks to Jim Cromie for the idea.
582 set_group
584 $table->set_group($column[,$no_dups,$replace_with])
585 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
592 # replace duplicates with the global 'null_value'
594 $table->set_group('Branch',1);
595 # replace duplicates with a new value
597 $table->set_group('Branch',1,'----');
598 # or in a more Perl-ish way
600 $table->set_group('Branch',nodups=>'----');
601 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 So, what's it good for? If you set a group (via the set_group()
607 method) and supply the following:
608 # well, and you are viewing in IE...
610 $table->modify(table => {
611 cellspacing => 0,
612 rules => 'groups',
613 });
614 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 # this works with or without setting a group, by the way
621 $table->modify(tbody => {
622 bgcolor => [qw(insert rotating colors here)],
623 });
624 calc_totals
626 $table->calc_totals([$cols,$mask])
627 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 calc_subtotals
637 $table->calc_subtotals([$cols,$mask])
638 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 get_col_count
646 $scalar = $table->get_col_count()
647 Returns the number of columns in the table.
649 get_row_count
651 $scalar = $table->get_row_count()
652 Returns the numbers of body rows in the table.
654 get_current_row
656 $scalar = $table->get_current_row()
657 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 get_current_col
664 $scalar = $table->get_current_col()
665 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 add_cols
672 $table->add_cols(
673 { header => '', data => [], before => '' }, { ... }, ...
674 );
675 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 $table->add_cols({name=>'New', data=>\@rows, before => 0});
685 add a new column to the end:
687 $table->add_cols({name=>'New', data=>\@rows});
689 or somewhere in the middle:
691 $table->add_cols({name=>'New', data=>\@rows}, before => 'age'});
693 or combine all three into one call:
695 $table->add_cols(
697 {name=>'Foo', data=>\@rows, before => 0},
698 {name=>'Bar', data=>\@rows},
699 {name=>'Baz', data=>\@rows}, before => 'Bar'},
700 );
701 drop_cols
703 $table->drop_cols([qw(foo bar 5)];
704 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 new Things with the stuff.
711 reset
713 Stuff with the things.
714
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 * All tags use modify() to set attributes
731 except <col>, which uses add_col_tag() instead
732
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 <http://rt.cpan.org/NoAuth/Bugs.html?Dist=DBIx-XHTML_Table>
738 or send mail to <bug-DBIx-XHTML_Table#rt.cpan.org>
740 (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
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 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
761 Briac [OeufMayo] Pilpré for the name.
762 Mark [extremely] Mills for patches and suggestions.
764 Jim Cromie for presenting the whole spreadsheet idea.
766 Stephen Nelson for documentation/code corrections.
768 Matt Sergeant for DBIx::XML_RDB.
770 Aaron [trs80] Johnson for convincing me into writing add and drop cols.
772 Richard Piacentini and Tim Alexander for recommending DBIx::Password
774 and Apache::DBI compatability and Slaven Rezic for recommending using
775 UNIVERSAL::isa().
776 Perl Monks for the education.
778
780 DBI
781
783 Jeff Anderson
784
786 Copyright 2017 Jeff Anderson.
787 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 <http://www.perlfoundation.org/artistic_license_2_0>
793 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 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 This license does not grant you the right to use any trademark, service
804 mark, tradename, or logo of the Copyright Holder.
805 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 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.
824perl v5.28.0 2017-01-04 DBIx::XHTML_Table(3)