1DBIx::Admin::TableInfo(U3s)er Contributed Perl DocumentatDiBoInx::Admin::TableInfo(3)
2
6 DBIx::Admin::TableInfo - A wrapper for all of table_info(),
7 column_info(), *_key_info()
8
10 This is scripts/synopsis.pl:
11 #!/usr/bin/env perl
13 use strict;
15 use warnings;
16 use DBI;
18 use DBIx::Admin::TableInfo 3.02;
19 use Lingua::EN::PluralToSingular 'to_singular';
21 use Text::Table::Manifold ':constants';
23 # ---------------------
25 my($attr) = {};
27 $$attr{sqlite_unicode} = 1 if ($ENV{DBI_DSN} =~ /SQLite/i);
28 my($dbh) = DBI -> connect($ENV{DBI_DSN}, $ENV{DBI_USER}, $ENV{DBI_PASS}, $attr);
29 my($vendor_name) = uc $dbh -> get_info(17);
30 my($info) = DBIx::Admin::TableInfo -> new(dbh => $dbh) -> info;
31 $dbh -> do('pragma foreign_keys = on') if ($ENV{DBI_DSN} =~ /SQLite/i);
33 my($temp_1, $temp_2, $temp_3);
35 if ($vendor_name eq 'MYSQL')
37 {
38 $temp_1 = 'PKTABLE_NAME';
39 $temp_2 = 'FKTABLE_NAME';
40 $temp_3 = 'FKCOLUMN_NAME';
41 }
42 else # ORACLE && POSTGRESQL && SQLITE (at least).
43 {
44 $temp_1 = 'UK_TABLE_NAME';
45 $temp_2 = 'FK_TABLE_NAME';
46 $temp_3 = 'FK_COLUMN_NAME';
47 }
48 my(%special_fk_column) =
50 (
51 spouse_id => 'person_id',
52 );
53 my($destination_port);
55 my($fk_column_name, $fk_table_name, %foreign_key);
56 my($pk_table_name, $primary_key_name);
57 my($singular_name, $source_port);
58 for my $table_name (sort keys %$info)
60 {
61 for my $item (@{$$info{$table_name}{foreign_keys} })
62 {
63 $pk_table_name = $$item{$temp_1};
64 $fk_table_name = $$item{$temp_2};
65 $fk_column_name = $$item{$temp_3};
66 if ($pk_table_name)
68 {
69 $singular_name = to_singular($pk_table_name);
70 if ($special_fk_column{$fk_column_name})
72 {
73 $primary_key_name = $special_fk_column{$fk_column_name};
74 }
75 elsif (defined($$info{$table_name}{columns}{$fk_column_name}) )
76 {
77 $primary_key_name = $fk_column_name;
78 }
79 elsif (defined($$info{$table_name}{columns}{id}) )
80 {
81 $primary_key_name = 'id';
82 }
83 else
84 {
85 die "Primary table '$pk_table_name'. Foreign table '$fk_table_name'. Unable to find primary key name for foreign key '$fk_column_name'\n"
86 }
87 $foreign_key{$fk_table_name} = {} if (! $foreign_key{$fk_table_name});
89 $foreign_key{$fk_table_name}{$fk_column_name} = {} if (! $foreign_key{$fk_table_name}{$fk_column_name});
90 $primary_key_name =~ s/${singular_name}_//;
91 $foreign_key{$fk_table_name}{$fk_column_name}{$table_name} = $primary_key_name;
92 }
93 }
94 }
95 my(@header) =
97 (
98 'Name',
99 'Type',
100 'Null',
101 'Key',
102 'Auto-increment',
103 );
104 my($table) = Text::Table::Manifold -> new
106 (
107 alignment =>
108 [
109 align_left,
110 align_left,
111 align_left,
112 align_left,
113 align_left,
114 ],
115 format => format_text_unicodebox_table,
116 headers => \@header,
117 join => "\n",
118 );
119 my(%type) =
120 (
121 'character varying' => 'varchar',
122 'int(11)' => 'integer',
123 '"timestamp"' => 'timestamp',
124 );
125 my($auto_increment);
127 my(@data);
128 my($index);
129 my($nullable);
130 my($primary_key);
131 my($type);
132 for my $table_name (sort keys %$info)
134 {
135 print "Table: $table_name.\n\n";
136 @data = ();
138 $index = undef;
139 for my $column_name (keys %{$$info{$table_name}{columns} })
141 {
142 $type = $$info{$table_name}{columns}{$column_name}{TYPE_NAME};
143 $type = $type{$type} ? $type{$type} : $type;
144 $nullable = $$info{$table_name}{columns}{$column_name}{IS_NULLABLE} eq 'NO';
145 $primary_key = $$info{$table_name}{primary_keys}{$column_name};
146 $auto_increment = $primary_key; # Database server-independent kludge :-(.
147 push @data,
149 [
150 $column_name,
151 $type,
152 $nullable ? 'not null' : '',
153 $primary_key ? 'primary key' : '',
154 $auto_increment ? 'auto_increment' : '',
155 ];
156 $index = pop @data if ($column_name eq 'id');
158 }
159 @data = sort{$$a[0] cmp $$b[0]} @data;
161 unshift @data, $index if ($index);
163 $table -> data(\@data);
165 print $table -> render_as_string, "\n\n";
167 }
168 If the environment vaiables DBI_DSN, DBI_USER and DBI_PASS are set (the
170 latter 2 are optional [e.g. for SQLite), then this demonstrates
171 extracting a lot of information from a database schema.
172 Also, for Postgres, you can set DBI_SCHEMA to a list of schemas, e.g.
174 when processing the MusicBrainz database.
175 For details, see
177 <http://blogs.perl.org/users/ron_savage/2013/03/graphviz2-and-the-dread-musicbrainz-db.html>.
178 See also xt/author/fk.t, xt/author/mysql.fk.pl and
180 xt/author/person.spouse.t.
181
183 "DBIx::Admin::TableInfo" is a pure Perl module.
184 It is a convenient wrapper around all of these DBI methods:
186 o table_info()
188 o column_info()
189 o primary_key_info()
190 o foreign_key_info()
191 o MySQL
192 Warning:
193 To get foreign key information in the output, the create table
195 statement has to:
196 o Include an index clause
198 o Include a foreign key clause
199 o Include an engine clause
200 As an example, a column definition for Postgres and SQLite,
201 which looks like:
202 site_id integer not null references sites(id),
204 has to, for MySql, look like:
206 site_id integer not null, index (site_id), foreign key (site_id) references sites(id),
208 Further, the create table statement, which for Postgres and
210 SQLite looks like:
211 create table designs (...)
213 has to, for MySql, look like:
215 create table designs (...) engine=innodb
217 o Oracle
219 See the "FAQ" for which tables are ignored under Oracle.
220 o Postgres
222 The latter now takes '%' as the value of the 'table' parameter to
223 new(), whereas older versions of DBD::Pg required 'table' to be set
224 to 'table'.
225 See the "FAQ" for which tables are ignored under Postgres.
227 o SQLite
229 See the "FAQ" for which tables are ignored under SQLite.
230
232 This module is available both as a Unix-style distro (*.tgz) and an
233 ActiveState-style distro (*.ppd). The latter is shipped in a *.zip
234 file.
235 See http://savage.net.au/Perl-modules.html for details.
237 See http://savage.net.au/Perl-modules/html/installing-a-module.html for
239 help on unpacking and installing each type of distro.
240
242 new(...) returns a "DBIx::Admin::TableInfo" object.
243 This is the class contructor.
245 Usage: DBIx::Admin::TableInfo -> new().
247 This method takes a set of parameters. Only the dbh parameter is
249 mandatory.
250 For each parameter you wish to use, call new as new(param_1 => value_1,
252 ...).
253 o catalog
255 This is the value passed in as the catalog parameter to
256 table_info() and column_info().
257 The default value is undef.
259 undef was chosen because it given the best results with MySQL.
261 Note: The MySQL driver DBD::mysql V 2.9002 has a bug in it, in that
263 it aborts if an empty string is used here, even though the DBI docs
264 say an empty string can be used for the catalog parameter to
265 "table_info()".
266 This parameter is optional.
268 o dbh
270 This is a database handle.
271 This parameter is mandatory.
273 o schema
275 This is the value passed in as the schema parameter to table_info()
276 and column_info().
277 The default value is undef.
279 Note: If you are using Oracle, call "new()" with schema set to uc
281 $user_name.
282 Note: If you are using Postgres, call "new()" with schema set to
284 'public'.
285 Note: If you are using SQLite, call "new()" with schema set to
287 'main'.
288 This parameter is optional.
290 o table
292 This is the value passed in as the table parameter to table_info().
293 The default value is '%'.
295 Note: If you are using an 'old' version of DBD::Pg, call "new()"
297 with table set to 'table'.
298 Sorry - I cannot tell you exactly what 'old' means. As stated
300 above, the default value (%) works fine with DBD::Pg V 2.17.1.
301 This parameter is optional.
303 o type
305 This is the value passed in as the type parameter to table_info().
306 The default value is 'TABLE'.
308 This parameter is optional.
310
312 columns($table_name, $by_position)
313 Returns an array ref of column names.
314 By default they are sorted by name.
316 However, if you pass in a true value for $by_position, they are sorted
318 by the column attribute ORDINAL_POSITION. This is Postgres-specific.
319 dbh2schema($dbh)
321 Warning: This is a function, not a method. It is called like this:
322 my($schema) = DBIx::Admin::TableInfo::dbh2schema($dbh);
324 The code is just:
326 my($dbh) = @_;
328 my($vendor) = uc $dbh -> get_info(17); # SQL_DBMS_NAME.
329 my(%schema) =
330 (
331 MYSQL => undef,
332 ORACLE => uc $$dbh{Username},
333 POSTGRESQL => 'public',
334 SQLITE => 'main',
335 );
336 return $schema{$vendor};
338 info()
340 Returns a hash ref of all available data.
341 The structure of this hash is described next:
343 o First level: The keys are the names of the tables
345 my($info) = $obj -> info();
346 my(@table_name) = sort keys %$info;
347 I use singular names for my arrays, hence @table_name rather than
349 @table_names.
350 o Second level: The keys are 'attributes', 'columns', 'foreign_keys'
352 and 'primary_keys'
353 my($table_attributes) = $$info{$table_name}{attributes};
354 This is a hash ref of the attributes of the table. The keys of
356 this hash ref are determined by the database server.
357 my($columns) = $$info{$table_name}{columns};
359 This is a hash ref of the columns of the table. The keys of this
361 hash ref are the names of the columns.
362 my($foreign_keys) = $$info{$table_name}{foreign_keys};
364 This is a hash ref of the foreign keys of the table. The keys of
366 this hash ref are the names of the tables which contain foreign
367 keys pointing to $table_name.
368 For MySQL, $foreign_keys will be the empty hash ref {}, as
370 explained above.
371 my($primary_keys) = $$info{$table_name}{primary_keys};
373 This is a hash ref of the primary keys of the table. The keys of
375 this hash ref are the names of the columns which make up the
376 primary key of $table_name.
377 For any database server, if there is more than 1 column in the
379 primary key, they will be numbered (ordered) according to the hash
380 key 'KEY_SEQ'.
381 For MySQL, if there is more than 1 column in the primary key, they
383 will be artificially numbered according to the order in which they
384 are returned by "column_info()", as explained above.
385 o Third level, after 'attributes': Table attributes
387 my($table_attributes) = $$info{$table_name}{attributes};
388 while ( ($name, $value) = each(%$table_attributes) )
390 {
391 Use...
392 }
393 For the attributes of the tables, there are no more levels in the
395 hash ref.
396 o Third level, after 'columns': The keys are the names of the columns.
398 my($columns) = $$info{$table_name}{columns};
399 my(@column_name) = sort keys %$columns;
401 o Fourth level: Column attributes
403 for $column_name (@column_name)
404 {
405 while ( ($name, $value) = each(%{$columns{$column_name} }) )
406 {
407 Use...
408 }
409 }
410 o Third level, after 'foreign_keys': An arrayref contains the details
412 (if any)
413 But beware slightly differing spellings depending on the database
414 server. This is documented in
415 <https://metacpan.org/pod/DBI#foreign_key_info>. Look closely at
416 the usage of the '_' character.
417 my($vendor) = uc $dbh -> get_info(17); # SQL_DBMS_NAME.
419 for $item (@{$$info{$table_name}{foreign_keys} })
421 {
422 # Get the name of the table pointed to.
423 $primary_table = ($vendor eq 'MYSQL') ? $$item{PKTABLE_NAME} : $$item{UK_TABLE_NAME};
425 }
426 o Third level, after 'primary_keys': The keys are the names of columns
428 These columns make up the primary key of the current table.
429 my($primary_keys) = $$info{$table_name}{primary_keys};
431 for $primary_key (sort{$$a{KEY_SEQ} <=> $$b{KEY_SEQ} } keys %$primary_keys)
433 {
434 $primary = $$primary_keys{$primary_key};
435 for $attribute (sort keys %$primary)
437 {
438 Use...
439 }
440 }
441 refresh()
443 Returns the same hash ref as info().
444 Use this after changing the database schema, when you want this module
446 to re-interrogate the database server.
447 tables()
449 Returns an array ref of table names.
450 They are sorted by name.
452 See the "FAQ" for which tables are ignored under which databases.
454
456 Here are tested parameter values for various database vendors:
457 o MS Access
459 my($admin) = DBIx::Admin::TableInfo -> new(dbh => $dbh);
460 In other words, the default values for catalog, schema, table and type will Just Work.
462 o MySQL
464 my($admin) = DBIx::Admin::TableInfo -> new(dbh => $dbh);
465 In other words, the default values for catalog, schema, table and type will Just Work.
467 o Oracle
469 my($dbh) = DBI -> connect($dsn, $username, $password);
470 my($admin) = DBIx::Admin::TableInfo -> new
471 (
472 dbh => $dbh,
473 schema => uc $username, # Yep, upper case.
474 );
475 See the FAQ for which tables are ignored under Oracle.
477 o PostgreSQL
479 my($admin) = DBIx::Admin::TableInfo -> new
480 (
481 dbh => $dbh,
482 schema => 'public',
483 );
484 For PostgreSQL, you probably want to ignore table names matching /^(pg_|sql_)/.
486 As stated above, for 'old' versions of DBD::Pg, use:
488 my($admin) = DBIx::Admin::TableInfo -> new
490 (
491 dbh => $dbh,
492 schema => 'public',
493 table => 'table', # Yep, lower case.
494 );
495 See the FAQ for which tables are ignored under Postgres.
497 o SQLite
499 my($admin) = DBIx::Admin::TableInfo -> new
500 (
501 dbh => $dbh,
502 schema => 'main',
503 );
504 In other words, the default values for catalog, table and type will Just Work.
506 See the FAQ for which tables are ignored under SQLite.
508 See the examples/ directory in the distro.
510
512 Which versions of the servers did you test?
513 Versions as at 2014-08-06:
514 +----------|-------------+
515 | Vendor | V |
516 +----------|-------------+
517 | MariaDB | 5.5.38 |
518 +----------|-------------+
519 | Oracle | 10.2.0.1.0 | (Not tested for years)
520 +----------|-------------+
521 | Postgres | 9.1.3 |
522 +----------|-------------+
523 | SQLite | 3.8.4.1 |
524 +----------|-------------+
525 But see these warnings
527 <https://metacpan.org/pod/DBIx::Admin::TableInfo#Description> when
528 using MySQL/MariaDB.
529 Which tables are ignored for which databases?
531 Here is the code which skips some tables:
532 next if ( ($vendor eq 'ORACLE') && ($table_name =~ /^BIN\$.+\$./) );
534 next if ( ($vendor eq 'POSTGRESQL') && ($table_name =~ /^(?:pg_|sql_)/) );
535 next if ( ($vendor eq 'SQLITE') && ($table_name eq 'sqlite_sequence') );
536 How do I identify foreign keys?
538 Note: The table names here come from xt/author/person.spouse.t.
539 See "FAQ" in DBIx::Admin::CreateTable for database server-specific
541 create statements to activate foreign keys.
542 Then try:
544 my($info) = DBIx::Admin::TableInfo -> new(dbh => $dbh) -> info;
546 print Data::Dumper::Concise::Dumper($$info{people}{foreign_keys}), "\n";
548 Output follows.
550 But beware slightly differing spellings depending on the database
552 server. This is documented in
553 <https://metacpan.org/pod/DBI#foreign_key_info>. Look closely at the
554 usage of the '_' character.
555 o MySQL
557 [
558 {
559 DEFERABILITY => undef,
560 DELETE_RULE => undef,
561 FKCOLUMN_NAME => "spouse_id",
562 FKTABLE_CAT => "def",
563 FKTABLE_NAME => "spouses",
564 FKTABLE_SCHEM => "testdb",
565 FK_NAME => "spouses_ibfk_2",
566 KEY_SEQ => 1,
567 PKCOLUMN_NAME => "id",
568 PKTABLE_CAT => undef,
569 PKTABLE_NAME => "people",
570 PKTABLE_SCHEM => "testdb",
571 PK_NAME => undef,
572 UNIQUE_OR_PRIMARY => undef,
573 UPDATE_RULE => undef
574 }
575 ]
576 Yes, there is just 1 element in this arrayref. MySQL can sliently
578 drop an index if another index can be used.
579 o Postgres
581 [
582 {
583 DEFERABILITY => 7,
584 DELETE_RULE => 3,
585 FK_COLUMN_NAME => "person_id",
586 FK_DATA_TYPE => "int4",
587 FK_NAME => "spouses_person_id_fkey",
588 FK_TABLE_CAT => undef,
589 FK_TABLE_NAME => "spouses",
590 FK_TABLE_SCHEM => "public",
591 ORDINAL_POSITION => 1,
592 UK_COLUMN_NAME => "id",
593 UK_DATA_TYPE => "int4",
594 UK_NAME => "people_pkey",
595 UK_TABLE_CAT => undef,
596 UK_TABLE_NAME => "people",
597 UK_TABLE_SCHEM => "public",
598 UNIQUE_OR_PRIMARY => "PRIMARY",
599 UPDATE_RULE => 3
600 },
601 {
602 DEFERABILITY => 7,
603 DELETE_RULE => 3,
604 FK_COLUMN_NAME => "spouse_id",
605 FK_DATA_TYPE => "int4",
606 FK_NAME => "spouses_spouse_id_fkey",
607 FK_TABLE_CAT => undef,
608 FK_TABLE_NAME => "spouses",
609 FK_TABLE_SCHEM => "public",
610 ORDINAL_POSITION => 1,
611 UK_COLUMN_NAME => "id",
612 UK_DATA_TYPE => "int4",
613 UK_NAME => "people_pkey",
614 UK_TABLE_CAT => undef,
615 UK_TABLE_NAME => "people",
616 UK_TABLE_SCHEM => "public",
617 UNIQUE_OR_PRIMARY => "PRIMARY",
618 UPDATE_RULE => 3
619 }
620 ]
621 o SQLite
623 [
624 {
625 DEFERABILITY => undef,
626 DELETE_RULE => 3,
627 FK_COLUMN_NAME => "spouse_id",
628 FK_DATA_TYPE => undef,
629 FK_NAME => undef,
630 FK_TABLE_CAT => undef,
631 FK_TABLE_NAME => "spouses",
632 FK_TABLE_SCHEM => undef,
633 ORDINAL_POSITION => 0,
634 UK_COLUMN_NAME => "id",
635 UK_DATA_TYPE => undef,
636 UK_NAME => undef,
637 UK_TABLE_CAT => undef,
638 UK_TABLE_NAME => "people",
639 UK_TABLE_SCHEM => undef,
640 UNIQUE_OR_PRIMARY => undef,
641 UPDATE_RULE => 3
642 },
643 {
644 DEFERABILITY => undef,
645 DELETE_RULE => 3,
646 FK_COLUMN_NAME => "person_id",
647 FK_DATA_TYPE => undef,
648 FK_NAME => undef,
649 FK_TABLE_CAT => undef,
650 FK_TABLE_NAME => "spouses",
651 FK_TABLE_SCHEM => undef,
652 ORDINAL_POSITION => 0,
653 UK_COLUMN_NAME => "id",
654 UK_DATA_TYPE => undef,
655 UK_NAME => undef,
656 UK_TABLE_CAT => undef,
657 UK_TABLE_NAME => "people",
658 UK_TABLE_SCHEM => undef,
659 UNIQUE_OR_PRIMARY => undef,
660 UPDATE_RULE => 3
661 }
662 ]
663 You can also play with xt/author/fk.t and xt/author/dsn.ini (especially
665 the 'active' option).
666 fk.t does not delete the tables as it exits. This is so
668 xt/author/mysql.fk.pl has something to play with.
669 See also xt/author/person.spouse.t.
671 Does DBIx::Admin::TableInfo work with SQLite databases?
673 Yes. As of V 2.08, this module uses the SQLite code "pragma
674 foreign_key_list($table_name)" to emulate the DBI call to
675 foreign_key_info(...).
676 What is returned by the SQLite "pragma foreign_key_list($table_name)" call?
678 An arrayref is returned. Indexes and their interpretations:
679 0: COUNT (0, 1, ...)
681 1: KEY_SEQ (0, or column # (1, 2, ...) within multi-column key)
682 2: PK_TABLE_NAME
683 3: FK_COLUMN_NAME
684 4: PK_COLUMN_NAME
685 5: UPDATE_RULE
686 6: DELETE_RULE
687 7: 'NONE' (Constant string)
688 As these are stored in an arrayref, I use $$row[$i] just below to refer
690 to the elements of the array.
691 How are these values mapped into the output?
693 See also the next point.
694 my(%referential_action) =
696 (
697 'CASCADE' => 0,
698 'RESTRICT' => 1,
699 'SET NULL' => 2,
700 'NO ACTION' => 3,
701 'SET DEFAULT' => 4,
702 );
703 The hashref returned for foreign keys contains these key-value pairs:
705 {
707 DEFERABILITY => undef,
708 DELETE_RULE => $referential_action{$$row[6]},
709 FK_COLUMN_NAME => $$row[3],
710 FK_DATA_TYPE => undef,
711 FK_NAME => undef,
712 FK_TABLE_CAT => undef,
713 FK_TABLE_NAME => $table_name,
714 FK_TABLE_SCHEM => undef,
715 ORDINAL_POSITION => $$row[1],
716 UK_COLUMN_NAME => $$row[4],
717 UK_DATA_TYPE => undef,
718 UK_NAME => undef,
719 UK_TABLE_CAT => undef,
720 UK_TABLE_NAME => $$row[2],
721 UK_TABLE_SCHEM => undef,
722 UNIQUE_OR_PRIMARY => undef,
723 UPDATE_RULE => $referential_action{$$row[5]},
724 }
725 This list of keys matches what is returned when processing a Postgres
727 database.
728 Have you got FK and PK backwards?
730 I certainly hope not. To me the FK_TABLE_NAME points to the
731 UK_TABLE_NAME.
732 The "pragma foreign_key_list($table_name)" call for SQLite returns data
734 from the create statement, and thus it reports what the given table
735 points to. The DBI call to foreign_key_info(...) returns data about
736 foreign keys referencing (pointing to) the given table. This can be
737 confusing.
738 Here is a method from the module App::Office::Contacts::Util::Create,
740 part of App::Office::Contacts.
741 sub create_organizations_table
743 {
744 my($self) = @_;
745 my($table_name) = 'organizations';
746 my($primary_key) = $self -> creator -> generate_primary_key_sql($table_name);
747 my($engine) = $self -> engine;
748 my($result) = $self -> creator -> create_table(<<SQL);
749 create table $table_name
750 (
751 id $primary_key,
752 visibility_id integer not null references visibilities(id),
753 communication_type_id integer not null references communication_types(id),
754 creator_id integer not null,
755 role_id integer not null references roles(id),
756 deleted integer not null,
757 facebook_tag varchar(255) not null,
758 homepage varchar(255) not null,
759 name varchar(255) not null,
760 timestamp timestamp not null default localtimestamp,
761 twitter_tag varchar(255) not null,
762 upper_name varchar(255) not null
763 ) $engine
764 SQL
765 $self -> dbh -> do("create index ${table_name}_upper_name on $table_name (upper_name)");
767 $self -> report($table_name, 'created', $result);
769 } # End of create_organizations_table.
771 Consider this line:
773 visibility_id integer not null references visibilities(id),
775 That means, for the 'visibilities' table, the info() method in the
777 current module will return a hashref like:
778 {
780 visibilities =>
781 {
782 ...
783 foreign_keys =>
784 {
785 ...
786 organizations =>
787 {
788 UK_COLUMN_NAME => 'id',
789 DEFERABILITY => undef,
790 ORDINAL_POSITION => 0,
791 FK_TABLE_CAT => undef,
792 UK_NAME => undef,
793 UK_DATA_TYPE => undef,
794 UNIQUE_OR_PRIMARY => undef,
795 UK_TABLE_SCHEM => undef,
796 UK_TABLE_CAT => undef,
797 FK_COLUMN_NAME => 'visibility_id',
798 FK_TABLE_NAME => 'organizations',
799 FK_TABLE_SCHEM => undef,
800 FK_DATA_TYPE => undef,
801 UK_TABLE_NAME => 'visibilities',
802 DELETE_RULE => 3,
803 FK_NAME => undef,
804 UPDATE_RULE => 3
805 },
806 },
807 }
808 This is saying that for the table 'visibilities', there is a foreign
810 key in the 'organizations' table. That foreign key is called
811 'visibility_id', and it points to the key called 'id' in the
812 'visibilities' table.
813 How do I use schemas in Postgres?
815 You may need to do something like this:
816 $dbh -> do("set search_path to $ENV{DBI_SCHEMA}") if ($ENV{DBI_SCHEMA});
818 $ENV{DBI_SCHEMA} can be a comma-separated list, as in:
820 $dbh -> do("set search_path to my_schema, public");
822 See DBD::Pg for details.
824 See Also
826 DBIx::Admin::CreateTable.
827 DBIx::Admin::DSNManager.
829
831 Version numbers < 1.00 represent development versions. From 1.00 up,
832 they are production versions.
833
835 <https://github.com/ronsavage/DBIx-Admin-TableInfo>
836
838 Log a bug on RT:
839 <https://rt.cpan.org/Public/Dist/Display.html?Name=DBIx-Admin-TableInfo>.
840
842 "DBIx::Admin::TableInfo" was written by Ron Savage <ron@savage.net.au>
843 in 2004.
844 Home page: http://savage.net.au/index.html
846
848 Australian copyright (c) 2004, Ron Savage.
849 All Programs of mine are 'OSI Certified Open Source Software';
851 you can redistribute them and/or modify them under the terms of
852 The Perl License, a copy of which is available at:
853 http://www.opensource.org/licenses/index.html
854perl v5.28.0 2016-09-04 DBIx::Admin::TableInfo(3)