home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 June / PCWorld_2005-06_cd.bin / software / vyzkuste / firewally / firewally.exe / framework-2.3.exe / ODBC.pm < prev    next >
Encoding:
Perl POD Document  |  2002-07-08  |  39.8 KB  |  1,494 lines
  1. package Win32::ODBC;
  2.  
  3. $VERSION = '0.032';
  4.  
  5. # Win32::ODBC.pm
  6. #       +==========================================================+
  7. #       |                                                          |
  8. #       |                     ODBC.PM package                      |
  9. #       |                     ---------------                      |
  10. #       |                                                          |
  11. #       | Copyright (c) 1996, 1997 Dave Roth. All rights reserved. |
  12. #       |   This program is free software; you can redistribute    |
  13. #       | it and/or modify it under the same terms as Perl itself. |
  14. #       |                                                          |
  15. #       +==========================================================+
  16. #
  17. #
  18. #         based on original code by Dan DeMaggio (dmag@umich.edu)
  19. #
  20. #    Use under GNU General Public License or Larry Wall's "Artistic License"
  21. #
  22. #    Check the README.TXT file that comes with this package for details about
  23. #    it's history.
  24. #
  25.  
  26. require Exporter;
  27. require DynaLoader;
  28.  
  29. $ODBCPackage = "Win32::ODBC";
  30. $ODBCPackage::Version = 970208;
  31. $::ODBC = $ODBCPackage;
  32. $CacheConnection = 0;
  33.  
  34.     #   Reserve ODBC in the main namespace for US!
  35. *ODBC::=\%Win32::ODBC::;
  36.  
  37.  
  38. @ISA= qw( Exporter DynaLoader );
  39.     # Items to export into callers namespace by default. Note: do not export
  40.     # names by default without a very good reason. Use EXPORT_OK instead.
  41.     # Do not simply export all your public functions/methods/constants.
  42. @EXPORT = qw(
  43.             ODBC_ADD_DSN
  44.             ODBC_REMOVE_DSN
  45.             ODBC_CONFIG_DSN
  46.             ODBC_ADD_SYS_DSN
  47.             ODBC_REMOVE_SYS_DSN
  48.             ODBC_CONFIG_SYS_DSN
  49.  
  50.             SQL_DONT_CLOSE
  51.             SQL_DROP
  52.             SQL_CLOSE
  53.             SQL_UNBIND
  54.             SQL_RESET_PARAMS
  55.  
  56.             SQL_FETCH_NEXT
  57.             SQL_FETCH_FIRST
  58.             SQL_FETCH_LAST
  59.             SQL_FETCH_PRIOR
  60.             SQL_FETCH_ABSOLUTE
  61.             SQL_FETCH_RELATIVE
  62.             SQL_FETCH_BOOKMARK
  63.  
  64.             SQL_COLUMN_COUNT
  65.             SQL_COLUMN_NAME
  66.             SQL_COLUMN_TYPE
  67.             SQL_COLUMN_LENGTH
  68.             SQL_COLUMN_PRECISION
  69.             SQL_COLUMN_SCALE
  70.             SQL_COLUMN_DISPLAY_SIZE
  71.             SQL_COLUMN_NULLABLE
  72.             SQL_COLUMN_UNSIGNED
  73.             SQL_COLUMN_MONEY
  74.             SQL_COLUMN_UPDATABLE
  75.             SQL_COLUMN_AUTO_INCREMENT
  76.             SQL_COLUMN_CASE_SENSITIVE
  77.             SQL_COLUMN_SEARCHABLE
  78.             SQL_COLUMN_TYPE_NAME
  79.             SQL_COLUMN_TABLE_NAME
  80.             SQL_COLUMN_OWNER_NAME
  81.             SQL_COLUMN_QUALIFIER_NAME
  82.             SQL_COLUMN_LABEL
  83.             SQL_COLATT_OPT_MAX
  84.             SQL_COLUMN_DRIVER_START
  85.             SQL_COLATT_OPT_MIN
  86.             SQL_ATTR_READONLY
  87.             SQL_ATTR_WRITE
  88.             SQL_ATTR_READWRITE_UNKNOWN
  89.             SQL_UNSEARCHABLE
  90.             SQL_LIKE_ONLY
  91.             SQL_ALL_EXCEPT_LIKE
  92.             SQL_SEARCHABLE
  93.         );
  94.     #The above are included for backward compatibility
  95.  
  96.  
  97. sub new
  98. {
  99.     my ($n, $self);
  100.     my ($type) = shift;
  101.     my ($DSN) = shift;
  102.     my (@Results) = @_;
  103.  
  104.     if (ref $DSN){
  105.         @Results = ODBCClone($DSN->{'connection'});
  106.     }else{
  107.         @Results = ODBCConnect($DSN, @Results);
  108.     }
  109.     @Results = processError(-1, @Results);
  110.     if (! scalar(@Results)){
  111.         return undef;
  112.     }
  113.     $self = bless {};
  114.     $self->{'connection'} = $Results[0];
  115.     $ErrConn = $Results[0];
  116.     $ErrText = $Results[1];
  117.     $ErrNum = 0;
  118.     $self->{'DSN'} = $DSN;
  119.     $self;
  120. }
  121.  
  122. ####
  123. #   Close this ODBC session (or all sessions)
  124. ####
  125. sub Close
  126. {
  127.     my ($self, $Result) = shift;
  128.     $Result = DESTROY($self);
  129.     $self->{'connection'} = -1;
  130.     return $Result;
  131. }
  132.  
  133. ####
  134. #   Auto-Kill an instance of this module
  135. ####
  136. sub DESTROY
  137. {
  138.     my ($self) = shift;
  139.     my (@Results) = (0);
  140.     if($self->{'connection'} > -1){
  141.         @Results = ODBCDisconnect($self->{'connection'});
  142.         @Results = processError($self, @Results);
  143.         if ($Results[0]){
  144.             undef $self->{'DSN'};
  145.             undef @{$self->{'fnames'}};
  146.             undef %{$self->{'field'}};
  147.             undef %{$self->{'connection'}};
  148.         }
  149.     }
  150.     return $Results[0];
  151. }
  152.  
  153.  
  154. sub sql{
  155.     return (Sql(@_));
  156. }
  157.  
  158. ####
  159. #   Submit an SQL Execute statement for processing
  160. ####
  161. sub Sql{
  162.     my ($self, $Sql, @Results) = @_;
  163.     @Results = ODBCExecute($self->{'connection'}, $Sql);
  164.     return updateResults($self, @Results);
  165. }
  166.  
  167. ####
  168. #   Retrieve data from a particular field
  169. ####
  170. sub Data{
  171.  
  172.         #   Change by JOC 06-APR-96
  173.         #   Altered by Dave Roth <dave@roth.net> 96.05.07
  174.     my($self) = shift;
  175.     my(@Fields) = @_;
  176.     my(@Results, $Results, $Field);
  177.  
  178.     if ($self->{'Dirty'}){
  179.         GetData($self);
  180.         $self->{'Dirty'} = 0;
  181.     }
  182.     @Fields = @{$self->{'fnames'}} if (! scalar(@Fields));
  183.     foreach $Field (@Fields) {
  184.         if (wantarray) {
  185.             push(@Results, data($self, $Field));
  186.         } else {
  187.             $Results .= data($self, $Field);
  188.         }
  189.     }
  190.     return wantarray ? @Results : $Results;
  191. }
  192.  
  193. sub DataHash{
  194.     my($self, @Results) = @_;
  195.     my(%Results, $Element);
  196.  
  197.     if ($self->{'Dirty'}){
  198.         GetData($self);
  199.         $self->{'Dirty'} = 0;
  200.     }
  201.     @Results = @{$self->{'fnames'}} if (! scalar(@Results));
  202.     foreach $Element (@Results) {
  203.         $Results{$Element} = data($self, $Element);
  204.     }
  205.  
  206.     return %Results;
  207. }
  208.  
  209. ####
  210. #   Retrieve data from the data buffer
  211. ####
  212. sub data
  213. {  $_[0]->{'data'}->{$_[1]}; }
  214.  
  215.  
  216. sub fetchrow{
  217.     return (FetchRow(@_));
  218. }
  219. ####
  220. #   Put a row from an ODBC data set into data buffer
  221. ####
  222. sub FetchRow{
  223.     my ($self, @Results) = @_;
  224.     my ($item, $num, $sqlcode);
  225.         # Added by JOC 06-APR-96
  226.         #   $num = 0;
  227.     $num = 0;
  228.     undef $self->{'data'};
  229.  
  230.  
  231.     @Results = ODBCFetch($self->{'connection'}, @Results);
  232.     if (! (@Results = processError($self, @Results))){
  233.         ####
  234.         #   There should be an innocuous error "No records remain"
  235.         #   This indicates no more records in the dataset
  236.         ####
  237.         return undef;
  238.     }
  239.         #   Set the Dirty bit so we will go and extract data via the
  240.         #   ODBCGetData function. Otherwise use the cache.
  241.     $self->{'Dirty'} = 1;
  242.  
  243.         #   Return the array of field Results.
  244.     return @Results;
  245. }
  246.  
  247. sub GetData{
  248.     my($self) = @_;
  249.     my @Results;
  250.     my $num = 0;
  251.  
  252.     @Results = ODBCGetData($self->{'connection'});
  253.     if (!(@Results = processError($self, @Results))){
  254.         return undef;
  255.     }
  256.         ####
  257.         #   This is a special case. Do not call processResults
  258.         ####
  259.     ClearError();
  260.     foreach (@Results){
  261.         s/ +$// if defined $_; # HACK
  262.         $self->{'data'}->{ ${$self->{'fnames'}}[$num] } = $_;
  263.         $num++;
  264.     }
  265.         #   return is a hack to interface with a assoc array.
  266.     return wantarray? (1, 1): 1;
  267. }
  268.  
  269. ####
  270. #   See if any more ODBC Results Sets
  271. #        Added by Brian Dunfordshore <Brian_Dunfordshore@bridge.com> 
  272. #        96.07.10
  273. ####
  274. sub MoreResults{
  275.     my ($self) = @_;
  276.  
  277.     my(@Results) = ODBCMoreResults($self->{'connection'});
  278.     return (processError($self, @Results))[0];
  279. }
  280.  
  281. ####
  282. #   Retrieve the catalog from the current DSN
  283. #    NOTE: All Field names are uppercase!!!
  284. ####
  285. sub Catalog{
  286.     my ($self) = shift;
  287.     my ($Qualifier, $Owner, $Name, $Type) = @_;
  288.     my (@Results) = ODBCTableList($self->{'connection'}, $Qualifier, $Owner, $Name, $Type);
  289.  
  290.         #   If there was an error return 0 else 1
  291.     return (updateResults($self, @Results) != 1);
  292. }
  293.  
  294. ####
  295. #   Return an array of names from the catalog for the current DSN
  296. #       TableList($Qualifier, $Owner, $Name, $Type)
  297. #           Return: (array of names of tables)
  298. #    NOTE: All Field names are uppercase!!!
  299. ####
  300. sub TableList{
  301.     my ($self) = shift;
  302.     my (@Results) = @_;
  303.     if (! scalar(@Results)){
  304.         @Results = ("", "", "%", "TABLE");
  305.     }
  306.  
  307.     if (! Catalog($self, @Results)){
  308.         return undef;
  309.     }
  310.     undef @Results;
  311.     while (FetchRow($self)){
  312.         push(@Results, Data($self, "TABLE_NAME"));
  313.     }
  314.     return sort(@Results);
  315. }
  316.  
  317.  
  318. sub fieldnames{
  319.     return (FieldNames(@_));
  320. }
  321. ####
  322. #   Return an array of fieldnames extracted from the current dataset
  323. ####
  324. sub FieldNames { $self = shift; return @{$self->{'fnames'}}; }
  325.  
  326.  
  327. ####
  328. #   Closes this connection. This is used mostly for testing. You should
  329. #   probably use Close().
  330. ####
  331. sub ShutDown{
  332.     my($self) = @_;
  333.     print "\nClosing connection $self->{'connection'}...";
  334.     $self->Close();
  335.     print "\nDone\n";
  336. }
  337.  
  338. ####
  339. #   Return this connection number
  340. ####
  341. sub Connection{
  342.     my($self) = @_;
  343.     return $self->{'connection'};
  344. }
  345.  
  346. ####
  347. #   Returns the current connections that are in use.
  348. ####
  349. sub GetConnections{
  350.     return ODBCGetConnections();
  351. }
  352.  
  353. ####
  354. #   Set the Max Buffer Size for this connection. This determines just how much
  355. #   ram can be allocated when a fetch() is performed that requires a HUGE amount
  356. #   of memory. The default max is 10k and the absolute max is 100k.
  357. #   This will probably never be used but I put it in because I noticed a fetch()
  358. #   of a MEMO field in an Access table was something like 4Gig. Maybe I did
  359. #   something wrong, but after checking several times I decided to impliment
  360. #   this limit thingie.
  361. ####
  362. sub SetMaxBufSize{
  363.     my($self, $Size) = @_;
  364.     my(@Results) = ODBCSetMaxBufSize($self->{'connection'}, $Size);
  365.     return (processError($self, @Results))[0];
  366. }
  367.  
  368. ####
  369. #   Returns the Max Buffer Size for this connection. See SetMaxBufSize().
  370. ####
  371. sub GetMaxBufSize{
  372.     my($self) = @_;
  373.     my(@Results) = ODBCGetMaxBufSize($self->{'connection'});
  374.     return (processError($self, @Results))[0];
  375. }
  376.  
  377.  
  378. ####
  379. #   Returns the DSN for this connection as an associative array.
  380. ####
  381. sub GetDSN{
  382.     my($self, $DSN) = @_;
  383.     if(! ref($self)){
  384.         $DSN = $self;
  385.         $self = 0;
  386.     }
  387.     if (! $DSN){
  388.         $self = $self->{'connection'};
  389.     }
  390.     my(@Results) = ODBCGetDSN($self, $DSN);
  391.     return (processError($self, @Results));
  392. }
  393.  
  394. ####
  395. #   Returns an associative array of $XXX{'DSN'}=Description
  396. ####
  397. sub DataSources{
  398.     my($self, $DSN) = @_;
  399.     if(! ref $self){
  400.         $DSN = $self;
  401.         $self = 0;
  402.     }
  403.     my(@Results) = ODBCDataSources($DSN);
  404.     return (processError($self, @Results));
  405. }
  406.  
  407. ####
  408. #   Returns an associative array of $XXX{'Driver Name'}=Driver Attributes
  409. ####
  410. sub Drivers{
  411.     my($self) = @_;
  412.     if(! ref $self){
  413.         $self = 0;
  414.     }
  415.     my(@Results) = ODBCDrivers();
  416.     return (processError($self, @Results));
  417. }
  418.  
  419. ####
  420. #   Returns the number of Rows that were affected by the previous SQL command.
  421. ####
  422. sub RowCount{
  423.     my($self, $Connection) = @_;
  424.     if (! ref($self)){
  425.         $Connection = $self;
  426.         $self = 0;
  427.     }
  428.     if (! $Connection){$Connection = $self->{'connection'};}
  429.     my(@Results) = ODBCRowCount($Connection);
  430.     return (processError($self, @Results))[0];
  431. }
  432.  
  433. ####
  434. #   Returns the Statement Close Type -- how does ODBC Close a statment.
  435. #       Types:
  436. #           SQL_DROP
  437. #           SQL_CLOSE
  438. #           SQL_UNBIND
  439. #           SQL_RESET_PARAMS
  440. ####
  441. sub GetStmtCloseType{
  442.     my($self, $Connection) = @_;
  443.     if (! ref($self)){
  444.         $Connection = $self;
  445.         $self = 0;
  446.     }
  447.     if (! $Connection){$Connection = $self->{'connection'};}
  448.     my(@Results) = ODBCGetStmtCloseType($Connection);
  449.     return (processError($self, @Results));
  450. }
  451.  
  452. ####
  453. #   Sets the Statement Close Type -- how does ODBC Close a statment.
  454. #       Types:
  455. #           SQL_DROP
  456. #           SQL_CLOSE
  457. #           SQL_UNBIND
  458. #           SQL_RESET_PARAMS
  459. #   Returns the newly set value.
  460. ####
  461. sub SetStmtCloseType{
  462.     my($self, $Type, $Connection) = @_;
  463.     if (! ref($self)){
  464.         $Connection = $Type;
  465.         $Type = $self;
  466.         $self = 0;
  467.     }
  468.     if (! $Connection){$Connection = $self->{'connection'};}
  469.     my(@Results) = ODBCSetStmtCloseType($Connection, $Type);
  470.     return (processError($self, @Results))[0];
  471. }
  472.  
  473. sub ColAttributes{
  474.     my($self, $Type, @Field) = @_;
  475.     my(%Results, @Results, $Results, $Attrib, $Connection, $Temp);
  476.     if (! ref($self)){
  477.         $Type = $Field;
  478.         $Field = $self;
  479.         $self = 0;
  480.     }
  481.     $Connection = $self->{'connection'};
  482.     if (! scalar(@Field)){ @Field = $self->fieldnames;}
  483.     foreach $Temp (@Field){
  484.         @Results = ODBCColAttributes($Connection, $Temp, $Type);
  485.         ($Attrib) = processError($self, @Results);
  486.         if (wantarray){
  487.             $Results{$Temp} = $Attrib;
  488.         }else{
  489.             $Results .= "$Temp";
  490.         }
  491.     }
  492.     return wantarray? %Results:$Results;
  493. }
  494.  
  495. sub GetInfo{
  496.     my($self, $Type) = @_;
  497.     my($Connection, @Results);
  498.     if(! ref $self){
  499.         $Type = $self;
  500.         $self = 0;
  501.         $Connection = 0;
  502.     }else{
  503.         $Connection = $self->{'connection'};
  504.     }
  505.     @Results = ODBCGetInfo($Connection, $Type);
  506.     return (processError($self, @Results))[0];
  507. }
  508.  
  509. sub GetConnectOption{
  510.     my($self, $Type) = @_;
  511.     my(@Results);
  512.     if(! ref $self){
  513.         $Type = $self;
  514.         $self = 0;
  515.     }
  516.     @Results = ODBCGetConnectOption($self->{'connection'}, $Type);
  517.     return (processError($self, @Results))[0];
  518. }
  519.  
  520. sub SetConnectOption{
  521.     my($self, $Type, $Value) = @_;
  522.     if(! ref $self){
  523.         $Value = $Type;
  524.         $Type = $self;
  525.         $self = 0;
  526.     }
  527.     my(@Results) = ODBCSetConnectOption($self->{'connection'}, $Type, $Value);
  528.     return (processError($self, @Results))[0];
  529. }
  530.  
  531.  
  532. sub Transact{
  533.     my($self, $Type) = @_;
  534.     my(@Results);
  535.     if(! ref $self){
  536.         $Type = $self;
  537.         $self = 0;
  538.     }
  539.     @Results = ODBCTransact($self->{'connection'}, $Type);
  540.     return (processError($self, @Results))[0];
  541. }
  542.  
  543.  
  544. sub SetPos{
  545.     my($self, @Results) = @_;
  546.     @Results = ODBCSetPos($self->{'connection'}, @Results);
  547.     $self->{'Dirty'} = 1;
  548.     return (processError($self, @Results))[0];
  549. }
  550.  
  551. sub ConfigDSN{
  552.     my($self) = shift @_;
  553.     my($Type, $Connection);
  554.     if(! ref $self){
  555.         $Type = $self;
  556.         $Connection = 0;
  557.         $self = 0;
  558.     }else{
  559.         $Type = shift @_;
  560.         $Connection = $self->{'connection'};
  561.     }
  562.     my($Driver, @Attributes) = @_;
  563.     @Results = ODBCConfigDSN($Connection, $Type, $Driver, @Attributes);
  564.     return (processError($self, @Results))[0];
  565. }
  566.  
  567.  
  568. sub Version{
  569.     my($self, @Packages) = @_;
  570.     my($Temp, @Results);
  571.     if (! ref($self)){
  572.         push(@Packages, $self);
  573.     }
  574.     my($ExtName, $ExtVersion) = Info();
  575.     if (! scalar(@Packages)){
  576.         @Packages = ("ODBC.PM", "ODBC.PLL");
  577.     }
  578.     foreach $Temp (@Packages){
  579.         if ($Temp =~ /pll/i){
  580.             push(@Results, "ODBC.PM:$Win32::ODBC::Version");
  581.         }elsif ($Temp =~ /pm/i){
  582.             push(@Results, "ODBC.PLL:$ExtVersion");
  583.         }
  584.     }
  585.     return @Results;
  586. }
  587.  
  588.  
  589. sub SetStmtOption{
  590.     my($self, $Option, $Value) = @_;
  591.     if(! ref $self){
  592.         $Value = $Option;
  593.         $Option = $self;
  594.         $self = 0;
  595.     }
  596.     my(@Results) = ODBCSetStmtOption($self->{'connection'}, $Option, $Value);
  597.     return (processError($self, @Results))[0];
  598. }
  599.  
  600. sub GetStmtOption{
  601.     my($self, $Type) = @_;
  602.     if(! ref $self){
  603.         $Type = $self;
  604.         $self = 0;
  605.     }
  606.     my(@Results) = ODBCGetStmtOption($self->{'connection'}, $Type);
  607.     return (processError($self, @Results))[0];
  608. }
  609.  
  610. sub GetFunctions{
  611.     my($self, @Results)=@_;
  612.     @Results = ODBCGetFunctions($self->{'connection'}, @Results);
  613.     return (processError($self, @Results));
  614. }
  615.  
  616. sub DropCursor{
  617.     my($self) = @_;
  618.     my(@Results) = ODBCDropCursor($self->{'connection'});
  619.     return (processError($self, @Results))[0];
  620. }
  621.  
  622. sub SetCursorName{
  623.     my($self, $Name) = @_;
  624.     my(@Results) = ODBCSetCursorName($self->{'connection'}, $Name);
  625.     return (processError($self, @Results))[0];
  626. }
  627.  
  628. sub GetCursorName{
  629.     my($self) = @_;
  630.     my(@Results) = ODBCGetCursorName($self->{'connection'});
  631.     return (processError($self, @Results))[0];
  632. }
  633.  
  634. sub GetSQLState{
  635.     my($self) = @_;
  636.     my(@Results) = ODBCGetSQLState($self->{'connection'});
  637.     return (processError($self, @Results))[0];
  638. }
  639.  
  640.  
  641. # ----------- R e s u l t   P r o c e s s i n g   F u n c t i o n s ----------
  642. ####
  643. #   Generic processing of data into associative arrays
  644. ####
  645. sub updateResults{
  646.     my ($self, $Error, @Results) = @_;
  647.  
  648.     undef %{$self->{'field'}};
  649.  
  650.     ClearError($self);
  651.     if ($Error){
  652.         SetError($self, $Results[0], $Results[1]);
  653.         return ($Error);
  654.     }
  655.  
  656.     @{$self->{'fnames'}} = @Results;
  657.  
  658.     foreach (0..$#{$self->{'fnames'}}){
  659.         s/ +$//;
  660.         $self->{'field'}->{${$self->{'fnames'}}[$_]} = $_;
  661.     }
  662.     return undef;
  663. }
  664.  
  665. # ----------------------------------------------------------------------------
  666. # ----------------- D e b u g g i n g   F u n c t i o n s --------------------
  667.  
  668. sub Debug{
  669.     my($self, $iDebug, $File) = @_;
  670.     my(@Results);
  671.     if (! ref($self)){
  672.         if (defined $self){
  673.             $File = $iDebug;
  674.             $iDebug = $self;
  675.         }
  676.         $Connection = 0;
  677.         $self = 0;
  678.     }else{
  679.         $Connection = $self->{'connection'};
  680.     }
  681.     push(@Results, ($Connection, $iDebug));
  682.     push(@Results, $File) if ($File ne "");
  683.     @Results = ODBCDebug(@Results);
  684.     return (processError($self, @Results))[0];
  685. }
  686.  
  687. ####
  688. #   Prints out the current dataset (used mostly for testing)
  689. ####
  690. sub DumpData {
  691.     my($self) = @_; my($f, $goo);
  692.  
  693.         #   Changed by JOC 06-Apr-96
  694.         #   print "\nDumping Data for connection: $conn->{'connection'}\n";
  695.     print "\nDumping Data for connection: $self->{'connection'}\n";
  696.     print "Error: \"";
  697.     print $self->Error();
  698.     print "\"\n";
  699.     if (! $self->Error()){
  700.        foreach $f ($self->FieldNames){
  701.             print $f . " ";
  702.             $goo .= "-" x length($f);
  703.             $goo .= " ";
  704.         }
  705.         print "\n$goo\n";
  706.         while ($self->FetchRow()){
  707.             foreach $f ($self->FieldNames){
  708.                 print $self->Data($f) . " ";
  709.             }
  710.             print "\n";
  711.         }
  712.     }
  713. }
  714.  
  715. sub DumpError{
  716.     my($self) = @_;
  717.     my($ErrNum, $ErrText, $ErrConn);
  718.     my($Temp);
  719.  
  720.     print "\n---------- Error Report: ----------\n";
  721.     if (ref $self){
  722.         ($ErrNum, $ErrText, $ErrConn) = $self->Error();
  723.         ($Temp = $self->GetDSN()) =~ s/.*DSN=(.*?);.*/$1/i;
  724.         print "Errors for \"$Temp\" on connection " . $self->{'connection'} . ":\n";
  725.     }else{
  726.         ($ErrNum, $ErrText, $ErrConn) = Error();
  727.         print "Errors for the package:\n";
  728.     }
  729.  
  730.     print "Connection Number: $ErrConn\nError number: $ErrNum\nError message: \"$ErrText\"\n";
  731.     print "-----------------------------------\n";
  732.  
  733. }
  734.  
  735. ####
  736. #   Submit an SQL statement and print data about it (used mostly for testing)
  737. ####
  738. sub Run{
  739.     my($self, $Sql) = @_;
  740.  
  741.     print "\nExcecuting connection $self->{'connection'}\nsql statement: \"$Sql\"\n";
  742.     $self->Sql($Sql);
  743.     print "Error: \"";
  744.     print $self->error;
  745.     print "\"\n";
  746.     print "--------------------\n\n";
  747. }
  748.  
  749. # ----------------------------------------------------------------------------
  750. # ----------- E r r o r   P r o c e s s i n g   F u n c t i o n s ------------
  751.  
  752. ####
  753. #   Process Errors returned from a call to ODBCxxxx().
  754. #   It is assumed that the Win32::ODBC function returned the following structure:
  755. #      ($ErrorNumber, $ResultsText, ...)
  756. #           $ErrorNumber....0 = No Error
  757. #                           >0 = Error Number
  758. #           $ResultsText.....if no error then this is the first Results element.
  759. #                           if error then this is the error text.
  760. ####
  761. sub processError{
  762.     my($self, $Error, @Results) = @_;
  763.     if ($Error){
  764.         SetError($self, $Results[0], $Results[1]);
  765.         undef @Results;
  766.     }
  767.     return @Results;
  768. }
  769.  
  770. ####
  771. #   Return the last recorded error message
  772. ####
  773. sub error{
  774.     return (Error(@_));
  775. }
  776.  
  777. sub Error{
  778.     my($self) = @_;
  779.     if(ref($self)){
  780.         if($self->{'ErrNum'}){
  781.             my($State) = ODBCGetSQLState($self->{'connection'});
  782.             return (wantarray)? ($self->{'ErrNum'}, $self->{'ErrText'}, $self->{'connection'}, $State) :"[$self->{'ErrNum'}] [$self->{'connection'}] [$State] \"$self->{'ErrText'}\"";
  783.         }
  784.     }elsif ($ErrNum){
  785.         return (wantarray)? ($ErrNum, $ErrText, $ErrConn):"[$ErrNum] [$ErrConn] \"$ErrText\"";
  786.     }
  787.     return undef
  788. }
  789.  
  790. ####
  791. #   SetError:
  792. #       Assume that if $self is not a reference then it is just a placeholder
  793. #       and should be ignored.
  794. ####
  795. sub SetError{
  796.     my($self, $Num, $Text, $Conn) = @_;
  797.     if (ref $self){
  798.         $self->{'ErrNum'} = $Num;
  799.         $self->{'ErrText'} = $Text;
  800.         $Conn = $self->{'connection'} if ! $Conn;
  801.     }
  802.     $ErrNum = $Num;
  803.     $ErrText = $Text;
  804.  
  805.         ####
  806.         #   Test Section Begin
  807.         ####
  808. #    $! = ($Num, $Text);
  809.         ####
  810.         #   Test Section End
  811.         ####
  812.  
  813.     $ErrConn = $Conn;
  814. }
  815.  
  816. sub ClearError{
  817.     my($self, $Num, $Text) = @_;
  818.     if (ref $self){
  819.         undef $self->{'ErrNum'};
  820.         undef $self->{'ErrText'};
  821.     }else{
  822.         undef $ErrConn;
  823.         undef $ErrNum;
  824.         undef $ErrText;
  825.     }
  826.     ODBCCleanError();
  827.     return 1;
  828. }
  829.  
  830.  
  831. sub GetError{
  832.     my($self, $Connection) = @_;
  833.     my(@Results);
  834.     if (! ref($self)){
  835.         $Connection = $self;
  836.         $self = 0;
  837.     }else{
  838.         if (! defined($Connection)){
  839.             $Connection = $self->{'connection'};
  840.         }
  841.     }
  842.  
  843.     @Results = ODBCGetError($Connection);
  844.     return @Results;
  845. }
  846.  
  847.  
  848.  
  849.  
  850. # ----------------------------------------------------------------------------
  851. # ------------------ A U T O L O A D   F U N C T I O N -----------------------
  852.  
  853. sub AUTOLOAD {
  854.     # This AUTOLOAD is used to 'autoload' constants from the constant()
  855.     # XS function.  If a constant is not found then control is passed
  856.     # to the AUTOLOAD in AutoLoader.
  857.  
  858.     my($constname);
  859.     ($constname = $AUTOLOAD) =~ s/.*:://;
  860.     #reset $! to zero to reset any current errors.
  861.     local $! = 0;
  862.     $val = constant($constname);
  863.  
  864.     if ($! != 0) {
  865.     if ($! =~ /Invalid/) {
  866.         $AutoLoader::AUTOLOAD = $AUTOLOAD;
  867.         goto &AutoLoader::AUTOLOAD;
  868.     }
  869.     else {
  870.  
  871.             # Added by JOC 06-APR-96
  872.             # $pack = 0;
  873.         $pack = 0;
  874.         ($pack,$file,$line) = caller;
  875.             print "Your vendor has not defined Win32::ODBC macro $constname, used in $file at line $line.";
  876.     }
  877.     }
  878.     eval "sub $AUTOLOAD { $val }";
  879.     goto &$AUTOLOAD;
  880. }
  881.  
  882.  
  883.     #   --------------------------------------------------------------
  884.     #
  885.     #
  886.     #   Make sure that we shutdown ODBC and free memory even if we are
  887.     #   using perlis.dll on Win32 platform!
  888. END{
  889. #    ODBCShutDown() unless $CacheConnection;
  890. }
  891.  
  892.  
  893. bootstrap Win32::ODBC;
  894.  
  895. # Preloaded methods go here.
  896.  
  897. # Autoload methods go after __END__, and are processed by the autosplit program.
  898.  
  899. 1;
  900. __END__
  901.  
  902. =head1 NAME
  903.  
  904. Win32::ODBC - ODBC Extension for Win32
  905.  
  906. =head1 SYNOPSIS
  907.  
  908. To use this module, include the following statement at the top of your
  909. script:
  910.  
  911.     use Win32::ODBC;
  912.  
  913. Next, create a data connection to your DSN:
  914.  
  915.     $Data = new Win32::ODBC("MyDSN");
  916.  
  917. B<NOTE>: I<MyDSN> can be either the I<DSN> as defined in the ODBC
  918. Administrator, I<or> it can be an honest-to-God I<DSN Connect String>.
  919.  
  920.     Example: "DSN=My Database;UID=Brown Cow;PWD=Moo;"
  921.  
  922. You should check to see if C<$Data> is indeed defined, otherwise there
  923. has been an error.
  924.  
  925. You can now send SQL queries and retrieve info to your heart's
  926. content! See the description of the methods provided by this module
  927. below and also the file F<TEST.PL> as referred to in L<INSTALLATION
  928. NOTES> to see how it all works.
  929.  
  930. Finally, B<MAKE SURE> that you close your connection when you are
  931. finished:
  932.  
  933.     $Data->Close();
  934.  
  935. =head1 DESCRIPTION
  936.  
  937. =head2 Background
  938.  
  939. This is a hack of Dan DeMaggio's <dmag@umich.edu> F<NTXS.C> ODBC
  940. implementation. I have recoded and restructured most of it including
  941. most of the F<ODBC.PM> package, but its very core is still based on
  942. Dan's code (thanks Dan!).
  943.  
  944. The history of this extension is found in the file F<HISTORY.TXT> that
  945. comes with the original archive (see L<INSTALLATION NOTES> below).
  946.  
  947. =head2 Benefits
  948.  
  949. And what are the benefits of this module?
  950.  
  951. =over
  952.  
  953. =item *
  954.  
  955. The number of ODBC connections is limited by memory and ODBC itself
  956. (have as many as you want!).
  957.  
  958. =item *
  959.  
  960. The working limit for the size of a field is 10,240 bytes, but you can
  961. increase that limit (if needed) to a max of 2,147,483,647 bytes. (You
  962. can always recompile to increase the max limit.)
  963.  
  964. =item *
  965.  
  966. You can open a connection by either specifing a DSN or a connection
  967. string!
  968.  
  969. =item *
  970.  
  971. You can open and close the connections in any order!
  972.  
  973. =item *
  974.  
  975. Other things that I can not think of right now... :)
  976.  
  977. =back
  978.  
  979. =head1 CONSTANTS
  980.  
  981. This package defines a number of constants. You may refer to each of
  982. these constants using the notation C<ODBC::xxxxx>, where C<xxxxx> is
  983. the constant.
  984.  
  985. Example:
  986.  
  987.    print ODBC::SQL_SQL_COLUMN_NAME, "\n";
  988.  
  989. =head1 SPECIAL NOTATION
  990.  
  991. For the method documentation that follows, an B<*> following the
  992. method parameters indicates that that method is new or has been
  993. modified for this version.
  994.  
  995. =head1 CONSTRUCTOR
  996.  
  997. =over
  998.  
  999. =item new ( ODBC_OBJECT | DSN [, (OPTION1, VALUE1), (OPTION2, VALUE2) ...] )
  1000. *
  1001.  
  1002. Creates a new ODBC connection based on C<DSN>, or, if you specify an
  1003. already existing ODBC object, then a new ODBC object will be created
  1004. but using the ODBC Connection specified by C<ODBC_OBJECT>. (The new
  1005. object will be a new I<hstmt> using the I<hdbc> connection in
  1006. C<ODBC_OBJECT>.)
  1007.  
  1008. C<DSN> is I<Data Source Name> or a proper C<ODBCDriverConnect> string.
  1009.  
  1010. You can specify SQL Connect Options that are implemented before the
  1011. actual connection to the DSN takes place. These option/values are the
  1012. same as specified in C<GetConnectOption>/C<SetConnectOption> (see
  1013. below) and are defined in the ODBC API specs.
  1014.  
  1015. Returns a handle to the database on success, or I<undef> on failure.
  1016.  
  1017. =back
  1018.  
  1019. =head1 METHODS
  1020.  
  1021. =over
  1022.  
  1023. =item Catalog ( QUALIFIER, OWNER, NAME, TYPE )
  1024.  
  1025. Tells ODBC to create a data set that contains table information about
  1026. the DSN. Use C<Fetch> and C<Data> or C<DataHash> to retrieve the data.
  1027. The returned format is:
  1028.  
  1029.     [Qualifier] [Owner] [Name] [Type]
  1030.  
  1031. Returns I<true> on error.
  1032.  
  1033. =item ColAttributes ( ATTRIBUTE [, FIELD_NAMES ] )
  1034.  
  1035. Returns the attribute C<ATTRIBUTE> on each of the fields in the list
  1036. C<FIELD_NAMES> in the current record set. If C<FIELD_NAMES> is empty,
  1037. then all fields are assumed. The attributes are returned as an
  1038. associative array.
  1039.  
  1040. =item ConfigDSN ( OPTION, DRIVER, ATTRIBUTE1 [, ATTRIBUTE2, ATTRIBUTE3, ...
  1041. ] )
  1042.  
  1043. Configures a DSN. C<OPTION> takes on one of the following values:
  1044.  
  1045.     ODBC_ADD_DSN.......Adds a new DSN.
  1046.     ODBC_MODIFY_DSN....Modifies an existing DSN.
  1047.     ODBC_REMOVE_DSN....Removes an existing DSN.
  1048.  
  1049.     ODBC_ADD_SYS_DSN.......Adds a new System DSN.
  1050.     ODBC_MODIFY_SYS_DSN....Modifies an existing System DSN.
  1051.     ODBC_REMOVE_SYS_DSN....Removes an existing System DSN.
  1052.  
  1053. You must specify the driver C<DRIVER> (which can be retrieved by using
  1054. C<DataSources> or C<Drivers>).
  1055.  
  1056. C<ATTRIBUTE1> B<should> be I<"DSN=xxx"> where I<xxx> is the name of
  1057. the DSN. Other attributes can be any DSN attribute such as:
  1058.  
  1059.     "UID=Cow"
  1060.     "PWD=Moo"
  1061.     "Description=My little bitty Data Source Name"
  1062.  
  1063. Returns I<true> on success, I<false> on failure.
  1064.  
  1065. B<NOTE 1>: If you use C<ODBC_ADD_DSN>, then you must include at least
  1066. I<"DSN=xxx"> and the location of the database.
  1067.  
  1068. Example: For MS Access databases, you must specify the
  1069. I<DatabaseQualifier>:
  1070.  
  1071.     "DBQ=c:\\...\\MyDatabase.mdb"
  1072.  
  1073. B<NOTE 2>: If you use C<ODBC_MODIFY_DSN>, then you need only specify
  1074. the I<"DNS=xxx"> attribute. Any other attribute you include will be
  1075. changed to what you specify.
  1076.  
  1077. B<NOTE 3>: If you use C<ODBC_REMOVE_DSN>, then you need only specify
  1078. the I<"DSN=xxx"> attribute.
  1079.  
  1080. =item Connection ()
  1081.  
  1082. Returns the connection number associated with the ODBC connection.
  1083.  
  1084. =item Close ()
  1085.  
  1086. Closes the ODBC connection. No return value.
  1087.  
  1088. =item Data ( [ FIELD_NAME ] )
  1089.  
  1090. Returns the contents of column name C<FIELD_NAME> or the current row
  1091. (if nothing is specified).
  1092.  
  1093. =item DataHash ( [ FIELD1, FIELD2, ... ] )
  1094.  
  1095. Returns the contents for C<FIELD1, FIELD2, ...> or the entire row (if
  1096. nothing is specified) as an associative array consisting of:
  1097.  
  1098.     {Field Name} => Field Data
  1099.  
  1100. =item DataSources ()
  1101.  
  1102. Returns an associative array of Data Sources and ODBC remarks about them.
  1103. They are returned in the form of:
  1104.  
  1105.     $ArrayName{'DSN'}=Driver
  1106.  
  1107. where I<DSN> is the Data Source Name and ODBC Driver used.
  1108.  
  1109. =item Debug ( [ 1 | 0 ] )
  1110.  
  1111. Sets the debug option to on or off. If nothing is specified, then
  1112. nothing is changed.
  1113.  
  1114. Returns the debugging value (I<1> or I<0>).
  1115.  
  1116. =item Drivers ()
  1117.  
  1118. Returns an associative array of ODBC Drivers and their attributes.
  1119. They are returned in the form of:
  1120.  
  1121.     $ArrayName{'DRIVER'}=Attrib1;Attrib2;Attrib3;...
  1122.  
  1123. where I<DRIVER> is the ODBC Driver Name and I<AttribX> are the
  1124. driver-defined attributes.
  1125.  
  1126. =item DropCursor ( [ CLOSE_TYPE ] )
  1127.  
  1128. Drops the cursor associated with the ODBC object. This forces the
  1129. cursor to be deallocated. This overrides C<SetStmtCloseType>, but the
  1130. ODBC object does not lose the C<StmtCloseType> setting. C<CLOSE_TYPE>
  1131. can be any valid C<SmtpCloseType> and will perform a close on the stmt
  1132. using the specified close type.
  1133.  
  1134. Returns I<true> on success, I<false> on failure.
  1135.  
  1136. =item DumpData ()
  1137.  
  1138. Dumps to the screen the fieldnames and all records of the current data
  1139. set. Used primarily for debugging. No return value.
  1140.  
  1141. =item Error ()
  1142.  
  1143. Returns the last encountered error. The returned value is context
  1144. dependent:
  1145.  
  1146. If called in a I<scalar> context, then a I<3-element array> is
  1147. returned:
  1148.  
  1149.     ( ERROR_NUMBER, ERROR_TEXT, CONNECTION_NUMBER )
  1150.  
  1151. If called in a I<string> context, then a I<string> is returned:
  1152.  
  1153.     "[ERROR_NUMBER] [CONNECTION_NUMBER] [ERROR_TEXT]"
  1154.  
  1155. If debugging is on then two more variables are returned:
  1156.  
  1157.     ( ..., FUNCTION, LEVEL )
  1158.  
  1159. where C<FUNCTION> is the name of the function in which the error
  1160. occurred, and C<LEVEL> represents extra information about the error
  1161. (usually the location of the error).
  1162.  
  1163. =item FetchRow ( [ ROW [, TYPE ] ] )
  1164.  
  1165. Retrieves the next record from the keyset. When C<ROW> and/or C<TYPE>
  1166. are specified, the call is made using C<SQLExtendedFetch> instead of
  1167. C<SQLFetch>.
  1168.  
  1169. B<NOTE 1>: If you are unaware of C<SQLExtendedFetch> and its
  1170. implications, stay with just regular C<FetchRow> with no parameters.
  1171.  
  1172. B<NOTE 2>: The ODBC API explicitly warns against mixing calls to
  1173. C<SQLFetch> and C<SQLExtendedFetch>; use one or the other but not
  1174. both.
  1175.  
  1176. If I<ROW> is specified, it moves the keyset B<RELATIVE> C<ROW> number
  1177. of rows.
  1178.  
  1179. If I<ROW> is specified and C<TYPE> is B<not>, then the type used is
  1180. B<RELATIVE>.
  1181.  
  1182. Returns I<true> when another record is available to read, and I<false>
  1183. when there are no more records.
  1184.  
  1185. =item FieldNames ()
  1186.  
  1187. Returns an array of fieldnames found in the current data set. There is
  1188. no guarantee on order.
  1189.  
  1190. =item GetConnections ()
  1191.  
  1192. Returns an array of connection numbers showing what connections are
  1193. currently open.
  1194.  
  1195. =item GetConnectOption ( OPTION )
  1196.  
  1197. Returns the value of the specified connect option C<OPTION>. Refer to
  1198. ODBC documentation for more information on the options and values.
  1199.  
  1200. Returns a string or scalar depending upon the option specified.
  1201.  
  1202. =item GetCursorName ()
  1203.  
  1204. Returns the name of the current cursor as a string or I<undef>.
  1205.  
  1206. =item GetData ()
  1207.  
  1208. Retrieves the current row from the dataset. This is not generally
  1209. used by users; it is used internally.
  1210.  
  1211. Returns an array of field data where the first element is either
  1212. I<false> (if successful) and I<true> (if B<not> successful).
  1213.  
  1214. =item getDSN ( [ DSN ] )
  1215.  
  1216. Returns an associative array indicating the configuration for the
  1217. specified DSN.
  1218.  
  1219. If no DSN is specified then the current connection is used.
  1220.  
  1221. The returned associative array consists of:
  1222.  
  1223.     keys=DSN keyword; values=Keyword value. $Data{$Keyword}=Value
  1224.  
  1225. =item GetFunctions ( [ FUNCTION1, FUNCTION2, ... ] )
  1226.  
  1227. Returns an associative array indicating the ability of the ODBC Driver
  1228. to support the specified functions. If no functions are specified,
  1229. then a 100 element associative array is returned containing all
  1230. possible functions and their values.
  1231.  
  1232. C<FUNCTION> must be in the form of an ODBC API constant like
  1233. C<SQL_API_SQLTRANSACT>.
  1234.  
  1235. The returned array will contain the results like:
  1236.  
  1237.     $Results{SQL_API_SQLTRANSACT}=Value
  1238.  
  1239. Example:
  1240.  
  1241.     $Results = $O->GetFunctions(
  1242.                                 $O->SQL_API_SQLTRANSACT,
  1243.                                 SQL_API_SQLSETCONNECTOPTION
  1244.                                );
  1245.     $ConnectOption = $Results{SQL_API_SQLSETCONNECTOPTION};
  1246.     $Transact = $Results{SQL_API_SQLTRANSACT};
  1247.  
  1248. =item GetInfo ( OPTION )
  1249.  
  1250. Returns a string indicating the value of the particular
  1251. option specified.
  1252.  
  1253. =item GetMaxBufSize ()
  1254.  
  1255. Returns the current allocated limit for I<MaxBufSize>. For more info,
  1256. see C<SetMaxBufSize>.
  1257.  
  1258. =item GetSQLState () *
  1259.  
  1260. Returns a string indicating the SQL state as reported by ODBC. The SQL
  1261. state is a code that the ODBC Manager or ODBC Driver returns after the
  1262. execution of a SQL function. This is helpful for debugging purposes.
  1263.  
  1264. =item GetStmtCloseType ( [ CONNECTION ] )
  1265.  
  1266. Returns a string indicating the type of closure that will be used
  1267. everytime the I<hstmt> is freed. See C<SetStmtCloseType> for details.
  1268.  
  1269. By default, the connection of the current object will be used. If
  1270. C<CONNECTION> is a valid connection number, then it will be used.
  1271.  
  1272. =item GetStmtOption ( OPTION )
  1273.  
  1274. Returns the value of the specified statement option C<OPTION>. Refer
  1275. to ODBC documentation for more information on the options and values.
  1276.  
  1277. Returns a string or scalar depending upon the option specified.
  1278.  
  1279. =item MoreResults ()
  1280.  
  1281. This will report whether there is data yet to be retrieved from the
  1282. query. This can happen if the query was a multiple select.
  1283.  
  1284. Example:
  1285.  
  1286.     "SELECT * FROM [foo] SELECT * FROM [bar]"
  1287.  
  1288. B<NOTE>: Not all drivers support this.
  1289.  
  1290. Returns I<1> if there is more data, I<undef> otherwise.
  1291.  
  1292. =item RowCount ( CONNECTION )
  1293.  
  1294. For I<UPDATE>, I<INSERT> and I<DELETE> statements, the returned value
  1295. is the number of rows affected by the request or I<-1> if the number
  1296. of affected rows is not available.
  1297.  
  1298. B<NOTE 1>: This function is not supported by all ODBC drivers! Some
  1299. drivers do support this but not for all statements (e.g., it is
  1300. supported for I<UPDATE>, I<INSERT> and I<DELETE> commands but not for
  1301. the I<SELECT> command).
  1302.  
  1303. B<NOTE 2>: Many data sources cannot return the number of rows in a
  1304. result set before fetching them; for maximum interoperability,
  1305. applications should not rely on this behavior.
  1306.  
  1307. Returns the number of affected rows, or I<-1> if not supported by the
  1308. driver in the current context.
  1309.  
  1310. =item Run ( SQL )
  1311.  
  1312. Executes the SQL command B<SQL> and dumps to the screen info about
  1313. it. Used primarily for debugging.
  1314.  
  1315. No return value.
  1316.  
  1317. =item SetConnectOption ( OPTION ) *
  1318.  
  1319. Sets the value of the specified connect option B<OPTION>. Refer to
  1320. ODBC documentation for more information on the options and values.
  1321.  
  1322. Returns I<true> on success, I<false> otherwise.
  1323.  
  1324. =item SetCursorName ( NAME ) *
  1325.  
  1326. Sets the name of the current cursor.
  1327.  
  1328. Returns I<true> on success, I<false> otherwise.
  1329.  
  1330. =item SetPos ( ROW [, OPTION, LOCK ] ) *
  1331.  
  1332. Moves the cursor to the row C<ROW> within the current keyset (B<not>
  1333. the current data/result set).
  1334.  
  1335. Returns I<true> on success, I<false> otherwise.
  1336.  
  1337. =item SetMaxBufSize ( SIZE )
  1338.  
  1339. This sets the I<MaxBufSize> for a particular connection. This will
  1340. most likely never be needed but...
  1341.  
  1342. The amount of memory that is allocated to retrieve the field data of a
  1343. record is dynamic and changes when it need to be larger. I found that
  1344. a memo field in an MS Access database ended up requesting 4 Gig of
  1345. space. This was a bit much so there is an imposed limit (2,147,483,647
  1346. bytes) that can be allocated for data retrieval.
  1347.  
  1348. Since it is possible that someone has a database with field data
  1349. greater than 10,240, you can use this function to increase the limit
  1350. up to a ceiling of 2,147,483,647 (recompile if you need more).
  1351.  
  1352. Returns the max number of bytes.
  1353.  
  1354. =item SetStmtCloseType ( TYPE [, CONNECTION ] )
  1355.  
  1356. Sets a particular I<hstmt> close type for the connection. This is the
  1357. same as C<ODBCFreeStmt(hstmt, TYPE)>. By default, the connection of
  1358. the current object will be used. If C<CONNECTION> is a valid
  1359. connection number, then it will be used.
  1360.  
  1361. C<TYPE> may be one of:
  1362.  
  1363.     SQL_CLOSE
  1364.     SQL_DROP
  1365.     SQL_UNBIND
  1366.     SQL_RESET_PARAMS
  1367.  
  1368. Returns a string indicating the newly set type.
  1369.  
  1370. =item SetStmtOption ( OPTION ) *
  1371.  
  1372. Sets the value of the specified statement option C<OPTION>. Refer to
  1373. ODBC documentation for more information on the options and values.
  1374.  
  1375. Returns I<true> on success, I<false> otherwise.
  1376.  
  1377. =item ShutDown ()
  1378.  
  1379. Closes the ODBC connection and dumps to the screen info about
  1380. it. Used primarily for debugging.
  1381.  
  1382. No return value.
  1383.  
  1384. =item Sql ( SQL_STRING )
  1385.  
  1386. Executes the SQL command C<SQL_STRING> on the current connection.
  1387.  
  1388. Returns I<?> on success, or an error number on failure.
  1389.  
  1390. =item TableList ( QUALIFIER, OWNER, NAME, TYPE )
  1391.  
  1392. Returns the catalog of tables that are available in the DSN. For an
  1393. unknown parameter, just specify the empty string I<"">.
  1394.  
  1395. Returns an array of table names.
  1396.  
  1397. =item Transact ( TYPE ) *
  1398.  
  1399. Forces the ODBC connection to perform a I<rollback> or I<commit>
  1400. transaction.
  1401.  
  1402. C<TYPE> may be one of:
  1403.  
  1404.     SQL_COMMIT
  1405.     SQL_ROLLBACK
  1406.  
  1407. B<NOTE>: This only works with ODBC drivers that support transactions.
  1408. Your driver supports it if I<true> is returned from:
  1409.  
  1410.     $O->GetFunctions($O->SQL_API_SQLTRANSACT)[1]
  1411.  
  1412. (See C<GetFunctions> for more details.)
  1413.  
  1414. Returns I<true> on success, I<false> otherwise.
  1415.  
  1416. =item Version ( PACKAGES )
  1417.  
  1418. Returns an array of version numbers for the requested packages
  1419. (F<ODBC.pm> or F<ODBC.PLL>). If the list C<PACKAGES> is empty, then
  1420. all version numbers are returned.
  1421.  
  1422. =back
  1423.  
  1424. =head1 LIMITATIONS
  1425.  
  1426. What known problems does this thing have?
  1427.  
  1428. =over
  1429.  
  1430. =item *
  1431.  
  1432. If the account under which the process runs does not have write
  1433. permission on the default directory (for the process, not the ODBC
  1434. DSN), you will probably get a runtime error during a
  1435. C<SQLConnection>. I don't think that this is a problem with the code,
  1436. but more like a problem with ODBC. This happens because some ODBC
  1437. drivers need to write a temporary file. I noticed this using the MS
  1438. Jet Engine (Access Driver).
  1439.  
  1440. =item *
  1441.  
  1442. This module has been neither optimized for speed nor optimized for
  1443. memory consumption.
  1444.  
  1445. =back
  1446.  
  1447. =head1 INSTALLATION NOTES
  1448.  
  1449. If you wish to use this module with a build of Perl other than
  1450. ActivePerl, you may wish to fetch the original source distribution for
  1451. this module at:
  1452.  
  1453.   ftp://ftp.roth.net:/pub/ntperl/ODBC/970208/Bin/Win32_ODBC_Build_CORE.zip
  1454.  
  1455. or one of the other archives at that same location. See the included
  1456. README for hints on installing this module manually, what to do if you
  1457. get a I<parse exception>, and a pointer to a test script for this
  1458. module.
  1459.  
  1460. =head1 OTHER DOCUMENTATION
  1461.  
  1462. Find a FAQ for Win32::ODBC at:
  1463.  
  1464.   http://www.roth.net/odbc/odbcfaq.htm
  1465.  
  1466. =head1 AUTHOR
  1467.  
  1468. Dave Roth <rothd@roth.net>
  1469.  
  1470. =head1 CREDITS
  1471.  
  1472. Based on original code by Dan DeMaggio <dmag@umich.edu>
  1473.  
  1474. =head1 DISCLAIMER
  1475.  
  1476. I do not guarantee B<ANYTHING> with this package. If you use it you
  1477. are doing so B<AT YOUR OWN RISK>! I may or may not support this
  1478. depending on my time schedule.
  1479.  
  1480. =head1 HISTORY
  1481.  
  1482. Last Modified 1999.09.25.
  1483.  
  1484. =head1 COPYRIGHT
  1485.  
  1486. Copyright (c) 1996-1998 Dave Roth. All rights reserved.
  1487.  
  1488. Courtesy of Roth Consulting:  http://www.roth.net/consult/
  1489.  
  1490. Use under GNU General Public License. Details can be found at:
  1491. http://www.gnu.org/copyleft/gpl.html
  1492.  
  1493. =cut
  1494.