dbi.3

视频监控网络部分的协议ddns,的模块的实现代码,请大家大胆指正.

\&            or die $DBI::errstr;
\&  $dbh = DBI\->connect_cached($data_source, $username, $password, \e%attr)
\&            or die $DBI::errstr;
.Ve
.PP
\&\f(CW\*(C`connect_cached\*(C'\fR is like \*(L"connect\*(R", except that the database handle
returned is also
stored in a hash associated with the given parameters. If another call
is made to \f(CW\*(C`connect_cached\*(C'\fR with the same parameter values, then the
corresponding cached \f(CW$dbh\fR will be returned if it is still valid.
The cached database handle is replaced with a new connection if it
has been disconnected or if the \f(CW\*(C`ping\*(C'\fR method fails.
.PP
That the behaviour of this method differs in several respects from the
behaviour of persistent connections implemented by Apache::DBI.
However, if Apache::DBI is loaded then \f(CW\*(C`connect_cached\*(C'\fR will use it.
.PP
Caching connections can be useful in some applications, but it can
also cause problems, such as too many connections, and so should
be used with care. In particular, avoid changing the attributes of
a database handle created via \fIconnect_cached()\fR because it will affect
other code that may be using the same handle.
.PP
Where multiple separate parts of a program are using \fIconnect_cached()\fR
to connect to the same database with the same (initial) attributes
it is a good idea to add a private attribute to the \fIconnect_cached()\fR
call to effectively limit the scope of the caching. For example:
.PP
.Vb 1
\&  DBI\->connect_cached(..., { private_foo_cachekey => "Bar", ... });
.Ve
.PP
Handles returned from that \fIconnect_cached()\fR call will only be returned
by other \fIconnect_cached()\fR call elsewhere in the code if those other
calls also pass in the same attribute values, including the private one.
(I've used \f(CW\*(C`private_foo_cachekey\*(C'\fR here as an example, you can use
any attribute name with a \f(CW\*(C`private_\*(C'\fR prefix.)
.PP
Taking that one step further, you can limit a particular \fIconnect_cached()\fR
call to return handles unique to that one place in the code by setting the
private attribute to a unique value for that place:
.PP
.Vb 1
\&  DBI\->connect_cached(..., { private_foo_cachekey => _\|_FILE_\|_._\|_LINE_\|_, ... });
.Ve
.PP
By using a private attribute you still get connection caching for
the individual calls to \fIconnect_cached()\fR but, by making separate
database conections for separate parts of the code, the database
handles are isolated from any attribute changes made to other handles.
.PP
The cache can be accessed (and cleared) via the \*(L"CachedKids\*(R" attribute:
.PP
.Vb 2
\&  my $CachedKids_hashref = $dbh\->{Driver}\->{CachedKids};
\&  %$CachedKids_hashref = () if $CachedKids_hashref;
.Ve
.PP
\fI\f(CI\*(C`available_drivers\*(C'\fI\fR
.IX Subsection "available_drivers"
.PP
.Vb 2
\&  @ary = DBI\->available_drivers;
\&  @ary = DBI\->available_drivers($quiet);
.Ve
.PP
Returns a list of all available drivers by searching for \f(CW\*(C`DBD::*\*(C'\fR modules
through the directories in \f(CW@INC\fR. By default, a warning is given if
some drivers are hidden by others of the same name in earlier
directories. Passing a true value for \f(CW$quiet\fR will inhibit the warning.
.PP
\fI\f(CI\*(C`installed_drivers\*(C'\fI\fR
.IX Subsection "installed_drivers"
.PP
.Vb 1
\&  %drivers = DBI\->installed_drivers();
.Ve
.PP
Returns a list of driver name and driver handle pairs for all drivers
\&'installed' (loaded) into the current process.  The driver name does not
include the '\s-1DBD::\s0' prefix.
.PP
To get a list of all drivers available in your perl instalation you can use
\&\*(L"available_drivers\*(R".
.PP
Added in \s-1DBI\s0 1.49.
.PP
\fI\f(CI\*(C`installed_versions\*(C'\fI\fR
.IX Subsection "installed_versions"
.PP
.Vb 3
\&  DBI\->installed_versions;
\&  @ary  = DBI\->installed_versions;
\&  %hash = DBI\->installed_versions;
.Ve
.PP
Calls \fIavailable_drivers()\fR and attempts to load each of them in turn
using \fIinstall_driver()\fR.  For each load that succeeds the driver
name and version number are added to a hash. When running under
DBI::PurePerl drivers which appear not be pure-perl are ignored.
.PP
When called in array context the list of successfully loaded drivers
is returned (without the '\s-1DBD::\s0' prefix).
.PP
When called in scalar context a reference to the hash is returned
and the hash will also contain other entries for the \f(CW\*(C`DBI\*(C'\fR version,
\&\f(CW\*(C`OS\*(C'\fR name, etc.
.PP
When called in a void context the \fIinstalled_versions()\fR method will
print out a formatted list of the hash contents, one per line.
.PP
Due to the potentially high memory cost and unknown risks of loading
in an unknown number of drivers that just happen to be installed
on the system, this method is not recommended for general use.
Use \fIavailable_drivers()\fR instead.
.PP
The \fIinstalled_versions()\fR method is primarily intended as a quick
way to see from the command line what's installed. For example:
.PP
.Vb 1
\&  perl \-MDBI \-e \*(AqDBI\->installed_versions\*(Aq
.Ve
.PP
The \fIinstalled_versions()\fR method was added in \s-1DBI\s0 1.38.
.PP
\fI\f(CI\*(C`data_sources\*(C'\fI\fR
.IX Subsection "data_sources"
.PP
.Vb 2
\&  @ary = DBI\->data_sources($driver);
\&  @ary = DBI\->data_sources($driver, \e%attr);
.Ve
.PP
Returns a list of data sources (databases) available via the named
driver.  If \f(CW$driver\fR is empty or \f(CW\*(C`undef\*(C'\fR, then the value of the
\&\f(CW\*(C`DBI_DRIVER\*(C'\fR environment variable is used.
.PP
The driver will be loaded if it hasn't been already. Note that if the
driver loading fails then \fIdata_sources()\fR \fIdies\fR with an error message
that includes the string "\f(CW\*(C`install_driver\*(C'\fR" and the underlying problem.
.PP
Data sources are returned in a form suitable for passing to the
\&\*(L"connect\*(R" method (that is, they will include the "\f(CW\*(C`dbi:$driver:\*(C'\fR" prefix).
.PP
Note that many drivers have no way of knowing what data sources might
be available for it. These drivers return an empty or incomplete list
or may require driver-specific attributes.
.PP
There is also a \fIdata_sources()\fR method defined for database handles.
.PP
\fI\f(CI\*(C`trace\*(C'\fI\fR
.IX Subsection "trace"
.PP
.Vb 4
\&  DBI\->trace($trace_setting)
\&  DBI\->trace($trace_setting, $trace_filename)
\&  DBI\->trace($trace_setting, $trace_filehandle)
\&  $trace_setting = DBI\->trace;
.Ve
.PP
The \f(CW\*(C`DBI\->trace\*(C'\fR method sets the \fIglobal default\fR trace
settings and returns the \fIprevious\fR trace settings. It can also
be used to change where the trace output is sent.
.PP
There's a similar method, \f(CW\*(C`$h\->trace\*(C'\fR, which sets the trace
settings for the specific handle it's called on.
.PP
See the \*(L"\s-1TRACING\s0\*(R" section for full details about the \s-1DBI\s0's powerful
tracing facilities.
.Sh "\s-1DBI\s0 Utility Functions"
.IX Subsection "DBI Utility Functions"
In addition to the \s-1DBI\s0 methods listed in the previous section,
the \s-1DBI\s0 package also provides several utility functions.
.PP
These can be imported into your code by listing them in
the \f(CW\*(C`use\*(C'\fR statement. For example:
.PP
.Vb 1
\&  use DBI qw(neat data_diff);
.Ve
.PP
Alternatively, all these utility functions (except hash) can be
imported using the \f(CW\*(C`:utils\*(C'\fR import tag. For example:
.PP
.Vb 1
\&  use DBI qw(:utils);
.Ve
.PP
\fI\f(CI\*(C`data_string_desc\*(C'\fI\fR
.IX Subsection "data_string_desc"
.PP
.Vb 1
\&  $description = data_string_desc($string);
.Ve
.PP
Returns an informal description of the string. For example:
.PP
.Vb 5
\&  UTF8 off, ASCII, 42 characters 42 bytes
\&  UTF8 off, non\-ASCII, 42 characters 42 bytes
\&  UTF8 on, non\-ASCII, 4 characters 6 bytes
\&  UTF8 on but INVALID encoding, non\-ASCII, 4 characters 6 bytes
\&  UTF8 off, undef
.Ve
.PP
The initial \f(CW\*(C`UTF8\*(C'\fR on/off refers to Perl's internal SvUTF8 flag.
If \f(CW$string\fR has the SvUTF8 flag set but the sequence of bytes it
contains are not a valid \s-1UTF\-8\s0 encoding then \fIdata_string_desc()\fR
will report \f(CW\*(C`UTF8 on but INVALID encoding\*(C'\fR.
.PP
The \f(CW\*(C`ASCII\*(C'\fR vs \f(CW\*(C`non\-ASCII\*(C'\fR portion shows \f(CW\*(C`ASCII\*(C'\fR if \fIall\fR the
characters in the string are \s-1ASCII\s0 (have code points <= 127).
.PP
The \fIdata_string_desc()\fR function was added in \s-1DBI\s0 1.46.
.PP
\fI\f(CI\*(C`data_string_diff\*(C'\fI\fR
.IX Subsection "data_string_diff"
.PP
.Vb 1
\&  $diff = data_string_diff($a, $b);
.Ve
.PP
Returns an informal description of the first character difference
between the strings. If both \f(CW$a\fR and \f(CW$b\fR contain the same sequence
of characters then \fIdata_string_diff()\fR returns an empty string.
For example:
.PP
.Vb 6
\& Params a & b     Result
\& \-\-\-\-\-\-\-\-\-\-\-\-     \-\-\-\-\-\-
\& \*(Aqaaa\*(Aq, \*(Aqaaa\*(Aq     \*(Aq\*(Aq
\& \*(Aqaaa\*(Aq, \*(Aqabc\*(Aq     \*(AqStrings differ at index 2: a[2]=a, b[2]=b\*(Aq
\& \*(Aqaaa\*(Aq, undef     \*(AqString b is undef, string a has 3 characters\*(Aq
\& \*(Aqaaa\*(Aq, \*(Aqaa\*(Aq      \*(AqString b truncated after 2 characters\*(Aq
.Ve
.PP
Unicode characters are reported in \f(CW\*(C`\ex{XXXX}\*(C'\fR format. Unicode
code points in the range U+0800 to U+08FF are unassigned and most
likely to occur due to double-encoding. Characters in this range
are reported as \f(CW\*(C`\ex{08XX}=\*(AqC\*(Aq\*(C'\fR where \f(CW\*(C`C\*(C'\fR is the corresponding
latin\-1 character.
.PP
The \fIdata_string_diff()\fR function only considers logical \fIcharacters\fR
and not the underlying encoding. See \*(L"data_diff\*(R" for an alternative.
.PP
The \fIdata_string_diff()\fR function was added in \s-1DBI\s0 1.46.
.PP
\fI\f(CI\*(C`data_diff\*(C'\fI\fR
.IX Subsection "data_diff"
.PP
.Vb 2
\&  $diff = data_diff($a, $b);
\&  $diff = data_diff($a, $b, $logical);
.Ve
.PP
Returns an informal description of the difference between two strings.
It calls \*(L"data_string_desc\*(R" and \*(L"data_string_diff\*(R"
and returns the combined results as a multi-line string.
.PP
For example, \f(CW\*(C`data_diff("abc", "ab\ex{263a}")\*(C'\fR will return:
.PP
.Vb 3
\&  a: UTF8 off, ASCII, 3 characters 3 bytes
\&  b: UTF8 on, non\-ASCII, 3 characters 5 bytes
\&  Strings differ at index 2: a[2]=c, b[2]=\ex{263A}
.Ve
.PP
If \f(CW$a\fR and \f(CW$b\fR are identical in both the characters they contain \fIand\fR
their physical encoding then \fIdata_diff()\fR returns an empty string.
If \f(CW$logical\fR is true then physical encoding differences are ignored
(but are still reported if there is a difference in the characters).
.PP
The \fIdata_diff()\fR function was added in \s-1DBI\s0 1.46.
.PP
\fI\f(CI\*(C`neat\*(C'\fI\fR
.IX Subsection "neat"
.PP
.Vb 2
\&  $str = neat($value);
\&  $str = neat($value, $maxlen);
.Ve
.PP
Return a string containing a neat (and tidy) representation of the
supplied value.
.PP
Strings will be quoted, although internal quotes will \fInot\fR be escaped.
Values known to be numeric will be unquoted. Undefined (\s-1NULL\s0) values
will be shown as \f(CW\*(C`undef\*(C'\fR (without quotes).
.PP
If the string is flagged internally as utf8 then double quotes will
be used, otherwise single quotes are used and unprintable characters
will be replaced by dot (.).
.PP
For result strings longer than \f(CW$maxlen\fR the result string will be
truncated to \f(CW\*(C`$maxlen\-4\*(C'\fR and "\f(CW\*(C`...\*(Aq\*(C'\fR" will be appended.  If \f(CW$maxlen\fR is 0
or \f(CW\*(C`undef\*(C'\fR, it defaults to \f(CW$DBI::neat_maxlen\fR which, in turn, defaults to 400.
.PP
This function is designed to format values for human consumption.
It is used internally by the \s-1DBI\s0 for \*(L"trace\*(R" output. It should
typically \fInot\fR be used for formatting values for database use.
(See also \*(L"quote\*(R".)
.PP
\fI\f(CI\*(C`neat_list\*(C'\fI\fR
.IX Subsection "neat_list"
.PP
.Vb 1
\&  $str = neat_list(\e@listref, $maxlen, $field_sep);
.Ve
.PP
Calls \f(CW\*(C`neat\*(C'\fR on each element of the list and returns a string
containing the results joined with \f(CW$field_sep\fR. \f(CW$field_sep\fR defaults
to \f(CW", "\fR.
.PP
\fI\f(CI\*(C`looks_like_number\*(C'\fI\fR
.IX Subsection "looks_like_number"
.PP
.Vb 1
\&  @bool = looks_like_number(@array);
.Ve
.PP
Returns true for each element that looks like a number.
Returns false for each element that does not look like a number.