home *** CD-ROM | disk | FTP | other *** search
/ Chip 2000 May / Chip_2000-05_cd1.bin / zkuste / Perl / ActivePerl-5.6.0.613.msi / 䆊䌷䈹䈙䏵-䞅䞆䞀㡆䞃䄦䠥 / _3b687f6d895053bb138bb80d0f0360c5 < prev    next >
Text File  |  2000-03-23  |  69KB  |  1,483 lines

  1.  
  2. <HTML>
  3. <HEAD>
  4. <TITLE>DBI::DBD - DBD Driver Writer's Guide</TITLE>
  5. <LINK REL="stylesheet" HREF="../../../Active.css" TYPE="text/css">
  6. <LINK REV="made" HREF="mailto:">
  7. </HEAD>
  8.  
  9. <BODY>
  10. <TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>
  11. <TR><TD CLASS=block VALIGN=MIDDLE WIDTH=100% BGCOLOR="#cccccc">
  12. <STRONG><P CLASS=block> DBI::DBD - DBD Driver Writer's Guide</P></STRONG>
  13. </TD></TR>
  14. </TABLE>
  15.  
  16. <A NAME="__index__"></A>
  17. <!-- INDEX BEGIN -->
  18.  
  19. <UL>
  20.  
  21.     <LI><A HREF="#name">NAME</A></LI><LI><A HREF="#supportedplatforms">SUPPORTED PLATFORMS</A></LI>
  22.  
  23.     <LI><A HREF="#synopsis">SYNOPSIS</A></LI>
  24.     <LI><A HREF="#version and volatility">VERSION and VOLATILITY</A></LI>
  25.     <LI><A HREF="#description">DESCRIPTION</A></LI>
  26.     <LI><A HREF="#registering a new driver">REGISTERING A NEW DRIVER</A></LI>
  27.     <UL>
  28.  
  29.         <LI><A HREF="#locating drivers">Locating drivers</A></LI>
  30.         <LI><A HREF="#dbi mailing lists">DBI Mailing Lists</A></LI>
  31.         <LI><A HREF="#registering a new driver">Registering a new driver</A></LI>
  32.     </UL>
  33.  
  34.     <LI><A HREF="#creating a new driver using pure perl">CREATING A NEW DRIVER USING PURE PERL</A></LI>
  35.     <UL>
  36.  
  37.         <LI><A HREF="#makefile.pl">Makefile.PL</A></LI>
  38.         <LI><A HREF="#readme file">README file</A></LI>
  39.         <LI><A HREF="#manifest">MANIFEST</A></LI>
  40.         <LI><A HREF="#driver.pm">Driver.pm</A></LI>
  41.         <LI><A HREF="#tests">Tests</A></LI>
  42.     </UL>
  43.  
  44.     <LI><A HREF="#creating a new driver using c/xs">CREATING A NEW DRIVER USING C/XS</A></LI>
  45.     <UL>
  46.  
  47.         <LI><A HREF="#requirements on a driver">REQUIREMENTS ON A DRIVER</A></LI>
  48.         <LI><A HREF="#code to be written">CODE TO BE WRITTEN</A></LI>
  49.         <LI><A HREF="#driver.pm">Driver.pm</A></LI>
  50.         <LI><A HREF="#driver.xs">Driver.xs</A></LI>
  51.         <LI><A HREF="#driver.h">Driver.h</A></LI>
  52.         <LI><A HREF="#implementation header dbdimp.h">Implementation header dbdimp.h</A></LI>
  53.         <LI><A HREF="#implementation source dbdimp.c">Implementation source dbdimp.c</A></LI>
  54.         <LI><A HREF="#makefile.pl">Makefile.PL</A></LI>
  55.     </UL>
  56.  
  57.     <LI><A HREF="#methods which do not need to be written">METHODS WHICH DO NOT NEED TO BE WRITTEN</A></LI>
  58.     <LI><A HREF="#writing an emulation layer for an old perl interface">WRITING AN EMULATION LAYER FOR AN OLD PERL INTERFACE</A></LI>
  59.     <UL>
  60.  
  61.         <LI><A HREF="#setting emulation perl variables">Setting emulation perl variables</A></LI>
  62.     </UL>
  63.  
  64.     <LI><A HREF="#other miscellaneous information">OTHER MISCELLANEOUS INFORMATION</A></LI>
  65.     <UL>
  66.  
  67.         <LI><A HREF="#the imp_xyz_t types">The imp_xyz_t types</A></LI>
  68.         <LI><A HREF="#using dbic_impset_on">Using DBIc_IMPSET_on</A></LI>
  69.         <LI><A HREF="#using dbic_is(), dbic_has(), dbic_on() and dbic_off()">Using DBIc_is(), DBIc_has(), <CODE>DBIc_on()</CODE> and <CODE>DBIc_off()</CODE></A></LI>
  70.         <LI><A HREF="#using dbis>get_fbav()">Using DBIS-><CODE>get_fbav()</CODE></A></LI>
  71.     </UL>
  72.  
  73.     <LI><A HREF="#subclassing dbi drivers">SUBCLASSING DBI DRIVERS</A></LI>
  74.     <UL>
  75.  
  76.         <LI><A HREF="#overwriting methods">Overwriting methods</A></LI>
  77.         <LI><A HREF="#attribute handling">Attribute handling</A></LI>
  78.     </UL>
  79.  
  80.     <LI><A HREF="#acknowledgements">ACKNOWLEDGEMENTS</A></LI>
  81.     <LI><A HREF="#authors">AUTHORS</A></LI>
  82. </UL>
  83. <!-- INDEX END -->
  84.  
  85. <HR>
  86. <P>
  87. <H1><A NAME="name">NAME</A></H1>
  88. <P>DBI::DBD - DBD Driver Writer's Guide</P>
  89. <P>
  90. <HR>
  91. <H1><A NAME="supportedplatforms">SUPPORTED PLATFORMS</A></H1>
  92. <UL>
  93. <LI>Linux</LI>
  94. <LI>Solaris</LI>
  95. <LI>Windows</LI>
  96. </UL>
  97. <HR>
  98. <H1><A NAME="synopsis">SYNOPSIS</A></H1>
  99. <PRE>
  100.     perldoc DBI::DBD</PRE>
  101. <P>
  102. <HR>
  103. <H1><A NAME="version and volatility">VERSION and VOLATILITY</A></H1>
  104. <PRE>
  105.         $Revision: 10.7 $
  106.         $Date: 1999/05/06 17:29:14 $</PRE>
  107. <P>This document is a minimal draft which is in need of further work.</P>
  108. <P>The changes will occur both because the DBI specification is changing
  109. and hence the requirements on DBD drivers change, and because feedback
  110. from people reading this document will suggest improvements to it.</P>
  111. <P>Please read the DBI documentation first and fully, including the DBI FAQ.
  112. The reread the DBI specification again as you're reading this. It'll help.</P>
  113. <P>This document is a patchwork of contributions from various authors.
  114. More contributions (preferably as patches) are very welcome.</P>
  115. <P>
  116. <HR>
  117. <H1><A NAME="description">DESCRIPTION</A></H1>
  118. <P>This document is primarily intended to help people writing new
  119. database drivers for the Perl Database Interface (Perl DBI).
  120. It may also help others interested in discovering why the internals of
  121. a DBD driver are written the way they are.</P>
  122. <P>This is a guide.  Few (if any) of the statements in it are completely
  123. authoritative under all possible circumstances.  This means you will
  124. need to use judgement in applying the guidelines in this document.
  125. If in <EM>any</EM> doubt at all, please do contact the dbi-dev mailing list
  126. (details given below) where Tim Bunce and other driver authors can help.</P>
  127. <P>
  128. <HR>
  129. <H1><A NAME="registering a new driver">REGISTERING A NEW DRIVER</A></H1>
  130. <P>Before writing a new driver, it is in your interests to find out
  131. whether there already is a driver for your database.  If there is such
  132. a driver, it would be much easier to make use of it than to write your
  133. own!</P>
  134. <P>
  135. <H2><A NAME="locating drivers">Locating drivers</A></H2>
  136. <P>The primary web-site for locating Perl software is
  137. <A HREF="http://www.perl.com/CPAN">http://www.perl.com/CPAN</A>.
  138. You should look under the various modules listings for the software
  139. you are after.
  140. Two of the main pages you should look at are:</P>
  141. <PRE>
  142.   <A HREF="http://www.perl.org/CPAN/modules/by-category/07_Database_Interfaces/DBI">http://www.perl.org/CPAN/modules/by-category/07_Database_Interfaces/DBI</A></PRE>
  143. <PRE>
  144.   <A HREF="http://www.perl.org/CPAN/modules/by-category/07_Database_Interfaces/DBD">http://www.perl.org/CPAN/modules/by-category/07_Database_Interfaces/DBD</A></PRE>
  145. <P>The primary web-site for locating DBI software and information is</P>
  146. <PRE>
  147.   <A HREF="http://www.arcana.co.uk/technologia/perl/DBI">http://www.arcana.co.uk/technologia/perl/DBI</A></PRE>
  148. <P>
  149. <H2><A NAME="dbi mailing lists">DBI Mailing Lists</A></H2>
  150. <P>There are 2 main and one auxilliary mailing lists for people working
  151. with DBI.  The primary lists are <A HREF="mailto:dbi-users@fugue.com">dbi-users@fugue.com</A> for general users
  152. of DBI and DBD drivers, and <A HREF="mailto:dbi-dev@fugue.com">dbi-dev@fugue.com</A> mainly for DBD driver
  153. writers (don't join the dbi-dev list unless you have a good reason).
  154. The auxilliary list is <A HREF="mailto:dbi-announce@fugue.com">dbi-announce@fugue.com</A> for announcing new
  155. releases of DBI or DBD drivers.</P>
  156. <P>You can join these lists by accessing the web-site
  157. <A HREF="http://www.fugue.com/dbi">http://www.fugue.com/dbi</A>.
  158. If you have not got web access, you may send a request to
  159. <A HREF="mailto:dbi-request@fugue.com,">dbi-request@fugue.com,</A> but this will be handled manually when the
  160. people in charge find the time to deal with it.  Use the web-site.</P>
  161. <P>You should also consider monitoring the comp.lang.perl.* newsgroups.</P>
  162. <P>
  163. <H2><A NAME="registering a new driver">Registering a new driver</A></H2>
  164. <P>Before going through any official registration process, you will need
  165. to establish that there is no driver already in the works.
  166. You'll do that by asking the DBI mailing lists whether there is such a
  167. driver available, or whether anybody is working on one.</P>
  168. <P>
  169. <HR>
  170. <H1><A NAME="creating a new driver using pure perl">CREATING A NEW DRIVER USING PURE PERL</A></H1>
  171. <P>Writing a pure Perl driver is surprisingly simple. However, there are
  172. some problems one should be aware of. The best option is of course
  173. picking up an existing driver and carefully modifying one method
  174. after the other.</P>
  175. <P>As an example we take a look at the <EM>DBD::File</EM> driver, a driver for
  176. accessing plain files as tables, which is part of the <EM>DBD::CSV</EM>
  177. package. In what follows I assume the name <CODE>Driver</CODE> for your new
  178. package: The least thing we have to implement are the files
  179. <A HREF="#item_Makefile%2EPL"><CODE>Makefile.PL</CODE></A> and <A HREF="#item_Driver%2Epm"><CODE>Driver.pm</CODE></A>.</P>
  180. <P>
  181. <H2><A NAME="makefile.pl">Makefile.PL</A></H2>
  182. <P>You typically start with writing <A HREF="#item_Makefile%2EPL"><CODE>Makefile.PL</CODE></A>, a Makefile generator.
  183. The contents of this file are described in detail in the MakeMaker
  184. man pages, it's definitely a good idea if you start reading them.
  185. At least you should know about the variables <EM>CONFIGURE</EM>, <EM>DEFINED</EM>,
  186. <EM>DIR</EM>, <EM>EXE_FILES</EM>, <EM>INC</EM>, <EM>LIBS</EM>, <EM>LINKTYPE</EM>, <EM>NAME</EM>, <EM>OPTIMIZE</EM>,
  187. <EM>PL_FILES</EM>, <EM>VERSION</EM>, <EM>VERSION_FROM</EM>, <EM>clean</EM>, <EM>depend</EM>, <EM>realclean</EM>
  188. from the <CODE>ExtUtils::MakeMaker</CODE> man page: These are used in almost any
  189. Makefile.PL. Additionally read the section on <EM>Overriding MakeMaker Methods</EM>
  190. and the descriptions of the <EM>distcheck</EM>, <EM>disttest</EM> and <EM>dist</EM> targets:
  191. They will definitely be useful for you.</P>
  192. <P>Of special importance for DBI drivers is the <EM>postamble</EM> method from
  193. the <CODE>ExtUtils::MM_Unix</CODE> man page. And for Emacs users I recommend
  194. the <EM>libscan</EM> method.</P>
  195. <P>Now an example, I use the word <CODE>Driver</CODE> wherever you should insert
  196. your drivers name:</P>
  197. <PRE>
  198.     # -*- perl -*-</PRE>
  199. <PRE>
  200.     use DBI 1.03;
  201.     use DBI::DBD;
  202.     use ExtUtils::MakeMaker;</PRE>
  203. <PRE>
  204.     ExtUtils::MakeMaker::WriteMakefile(
  205.         'NAME'         => 'DBD::Driver',
  206.         'VERSION_FROM' => 'Driver.pm',
  207.         'INC'          => $DBI_INC_DIR,
  208.         'dist'         => { 'SUFFIX' => '.gz',
  209.                             'COMPRESS' => 'gzip -9f' },
  210.         'realclean'    => '*.xsi'
  211.     );</PRE>
  212. <PRE>
  213.     package MY;
  214.     sub postamble { dbd_postamble(@_); }
  215.     sub libscan {
  216.         my($self, $path) = @_;
  217.         ($path =~ /\~$/) ? undef : $path;
  218.     }</PRE>
  219. <P>See also <A HREF="../../../ExtUtils/MakeMaker(3).html">the ExtUtils::MakeMaker(3) manpage</A>. <A HREF="../../../ExtUtils/MM_Unix(3).html">the ExtUtils::MM_Unix(3) manpage</A>.</P>
  220. <P>
  221. <H2><A NAME="readme file">README file</A></H2>
  222. <P>The README file should describe what the driver is for, the
  223. pre-requisites for the build process, the actual build process, and how
  224. to report errors. Users will find ways of breaking the driver build and
  225. test process which you would never even dreamed to be possible in your
  226. nightmares. :-) Therefore, you need to write this document defensively
  227. and precisely.  Also, it is in your interests to ensure that your tests
  228. work as widely as possible. As always, use the README from one of the
  229. established drivers as a basis for your own.</P>
  230. <P>
  231. <H2><A NAME="manifest">MANIFEST</A></H2>
  232. <P>The MANIFEST will be used by the Makefile'd dist target to build the
  233. distribution tar file that is uploaded to CPAN. It should list every
  234. file that you want to include in your distribution, one per line.</P>
  235. <P>
  236. <H2><A NAME="driver.pm">Driver.pm</A></H2>
  237. <P>The Driver.pm file defines the Perl module DBD::Driver for your driver.
  238. It will define a package DBD::Driver along with some version information,
  239. some variable definitions, and a function <CODE>driver()</CODE> which will have a more
  240. or less standard structure.</P>
  241. <P>It will also define a package DBD::Driver::dr (with methods connect(),
  242. <CODE>data_sources()</CODE> and disconnect_all()), and a package DBD::Driver::db
  243. (which will define a function <CODE>prepare()</CODE> etc), and a package DBD::Driver::st
  244. with methods execute(), <CODE>fetch()</CODE> and the like.</P>
  245. <P>The Driver.pm file will also contain the documentation specific to
  246. DBD::Driver in the format used by perldoc.</P>
  247. <P>Now let's take a closer look at an excerpt of File.pm as an example.
  248. We ignore things that are common to any module (even non-DBI(D) modules)
  249. or really specific for the DBD::File package.</P>
  250. <DL>
  251. <DT><STRONG><A NAME="item_The_header">The header</A></STRONG><BR>
  252. <DD>
  253. <PRE>
  254.   package DBD::File;</PRE>
  255. <PRE>
  256.   use strict;
  257.   use vars qw($err $errstr $state $drh);</PRE>
  258. <PRE>
  259.   $err = 0;             # holds error code   for DBI::err
  260.   $errstr = "";         # holds error string for DBI::errstr
  261.   $sqlstate = "";       # holds SQL state for    DBI::state</PRE>
  262. <P>These variables are used for storing error states and messages.
  263. However, it is crucial to understand that you must not modify
  264. them directly; instead use the <EM>event</EM> method, see below.</P>
  265. <PRE>
  266.   $drh = undef;         # holds driver handle once initialized</PRE>
  267. <P>This is where the driver handle will be stored, once created. Note,
  268. that you may assume, there's only one handle for your driver.</P>
  269. <DT><STRONG><A NAME="item_The_driver_constructor">The driver constructor</A></STRONG><BR>
  270. <DD>
  271. <PRE>
  272.   sub driver {
  273.     return $drh if $drh;        # already created - return same one
  274.     my($class, $attr) = @_;</PRE>
  275. <PRE>
  276.     $class .= "::dr";</PRE>
  277. <PRE>
  278.     # not a 'my' since we use it above to prevent multiple drivers
  279.     $drh = DBI::_new_drh($class, {
  280.       'Name'    => 'File',
  281.       'Version' => $VERSION,
  282.       'Err'     => \$DBD::File::err,
  283.       'Errstr'  => \$DBD::File::errstr,
  284.       'State'   => \$DBD::File::state,
  285.       'Attribution' => 'DBD::File by Jochen Wiedmann',
  286.     });</PRE>
  287. <PRE>
  288.     return $drh;
  289.   }</PRE>
  290. <P>The <EM>driver</EM> method is the driver handle constructor. It's a
  291. reasonable example of how DBI implements its handles. There are three
  292. kinds: <STRONG>driver handles</STRONG> (typically stored in <CODE>$drh</CODE>, from now on
  293. called <CODE>drh</CODE>), <STRONG>database handles</STRONG> (from now on called <CODE>dbh</CODE> or
  294. <CODE>$dbh</CODE>) and <STRONG>statement handles</STRONG>, (from now on called <CODE>sth</CODE> or
  295. <CODE>$sth</CODE>).</P>
  296. <P>The prototype of DBI::_new_drh is</P>
  297. <PRE>
  298.     $drh = DBI::_new_drh($class, $attr1, $attr2);</PRE>
  299. <P>with the following arguments:</P>
  300. <DL>
  301. <DT><STRONG><A NAME="item_%24class"><EM>$class</EM></A></STRONG><BR>
  302. <DD>
  303. is typically your drivers class, e.g., ``DBD::File::dr'', passed as first
  304. argument to the <EM>driver</EM> method.
  305. <P></P>
  306. <DT><STRONG><A NAME="item_%24attr1"><EM>$attr1</EM></A></STRONG><BR>
  307. <DD>
  308. is a hash ref to attributes like <EM>Name</EM>, <EM>Version</EM>, <EM>Err</EM>, <EM>Errstr</EM>
  309. <EM>State</EM> and <EM>Attributrion</EM>. These are processed and used by DBI, you
  310. better not make any assumptions on them nor should you add private
  311. attributes here.
  312. <P></P>
  313. <DT><STRONG><A NAME="item_%24attr2"><EM>$attr2</EM></A></STRONG><BR>
  314. <DD>
  315. This is another (optional) hash ref with your private attributes. DBI
  316. will leave them alone.
  317. <P></P></DL>
  318. <P>The <EM>DBI::new_drh</EM> method and the <EM>driver</EM> method
  319. both return <A HREF="../../../lib/Pod/perlfunc.html#item_undef"><CODE>undef</CODE></A> for failure (in which case you must look at
  320. $DBI::err and $DBI::errstr, because you have no driver handle).</P>
  321. <DT><STRONG><A NAME="item_The_database_handle_constructor">The database handle constructor</A></STRONG><BR>
  322. <DD>
  323. The next lines of code look as follows:
  324. <PRE>
  325.   package DBD::Driver::dr; # ====== DRIVER ======</PRE>
  326. <PRE>
  327.   $DBD::Driver::dr::imp_data_size = 0;</PRE>
  328. <P>Note that no @ISA is needed here, or for the other DBD::Driver::*
  329. classes, because the DBI takes care of that for you when the driver is
  330. loaded.</P>
  331. <P>The database handle constructor is a driver method, thus we have
  332. to change the namespace.</P>
  333. <PRE>
  334.   sub connect {
  335.     my($drh, $dbname, $user, $auth, $attr)= @_;</PRE>
  336. <PRE>
  337.     # Some database specific verifications, default settings
  338.     # and the like following here. This should only include
  339.     # syntax checks or similar stuff where it's legal to
  340.     # 'die' in case of errors.</PRE>
  341. <PRE>
  342.     # create a 'blank' dbh (call superclass constructor)
  343.     my $dbh = DBI::_new_dbh($drh, {
  344.       'Name' => $dbname,
  345.       'USER' => $user,
  346.       'CURRENT_USER' => $user,
  347.     });</PRE>
  348. <PRE>
  349.     # Process attributes from the DSN; we assume ODBC syntax
  350.     # here, that is, the DSN looks like var1=val1;...;varN=valN</PRE>
  351. <PRE>
  352.     my $var;
  353.     foreach $var (split(/;/, $dbname)) {
  354.       if ($var =~ /(.*?)=(,*)/) {
  355.         # Not !!! $dbh->{$var} = $val;
  356.         $dbh->STORE($var, $val);
  357.       }
  358.     }
  359.     $dbh;
  360.   }</PRE>
  361. <P>This is mostly the same as in the <EM>driver handle constructor</EM> above.
  362. The arguments are described in the DBI man page. See <EM>DBI(3)</EM>.
  363. The constructor is called, returning a database handle. The constructors
  364. prototype is</P>
  365. <PRE>
  366.     $dbh = DBI::_new_dbh($drh, $attr1, $attr2);</PRE>
  367. <P>with the same arguments as in the <EM>driver handle constructor</EM>, the
  368. exception being <A HREF="#item_%24class"><CODE>$class</CODE></A> replaced by <CODE>$drh</CODE>.</P>
  369. <P>Note the use of the <EM>STORE</EM> method for setting the dbh attributes.
  370. That's because within the driver code, the handle object you have is
  371. the 'inner' handle of a tied hash, not the outer handle that the
  372. users of your driver have.</P>
  373. <P>Because you have the inner handle, tie magic doesn't get invoked
  374. when you get or set values in the hash. This is often very handy for
  375. speed when you want to get or set simple non-special driver-specific
  376. attributes.</P>
  377. <P>However, some attribute values, such as those handled by the DBI
  378. like PrintError, don't actually exist in the hash and must be
  379. read via $h-><CODE>FETCH($attrib)</CODE> and set via $h->STORE($attrib, $value).
  380. If in any doubt, use these methods.</P>
  381. <P></P>
  382. <DT><STRONG><A NAME="item_Error_handling">Error handling</A></STRONG><BR>
  383. <DD>
  384. It is quite likely that something fails in the connect method. With
  385. DBD::File for example, you might catch an error when setting the
  386. current directory to something not existant by using the f_dir
  387. attribute.
  388. <P>To report an error, you use the <CODE>DBI::set_err</CODE> function/method:</P>
  389. <PRE>
  390.     $h->DBI::set_err($errcode, $errmsg);</PRE>
  391. <P>This will ensure that the error is recorded correctly and that
  392. RaiseError and PrintError etc are handled correctly.  Typically you'll
  393. always use the method instance, aka your method's first argument.</P>
  394. <P>As set_err always returns undef your error handling code can
  395. usually be simplified to something like this:</P>
  396. <PRE>
  397.   return $h->DBI::set_err($errcode, $errmsg) if ...;</PRE>
  398. <P></P>
  399. <DT><STRONG><A NAME="item_Other_driver_handle_methods">Other driver handle methods</A></STRONG><BR>
  400. <DD>
  401. may follow here. In particular you should consider a <EM>data_sources</EM>
  402. method, and a (possibly empty) <EM>disconnect_all</EM> method. See <EM>DBI(3)</EM>.
  403. <P></P>
  404. <DT><STRONG><A NAME="item_The_statement_handle_constructor">The statement handle constructor</A></STRONG><BR>
  405. <DD>
  406. There's nothing much new in the statement handle constructor.
  407. <PRE>
  408.   package DBD::Driver::db; # ====== DATABASE ======</PRE>
  409. <PRE>
  410.   $DBD::Driver::db::imp_data_size = 0;</PRE>
  411. <PRE>
  412.   sub prepare {
  413.         my($dbh, $statement, @attribs)= @_;</PRE>
  414. <PRE>
  415.         # create a 'blank' sth
  416.         my $sth = DBI::_new_sth($dbh, {
  417.             'Statement' => $statement,
  418.             });</PRE>
  419. <PRE>
  420.         # Setup module specific data
  421.         $sth->STORE('driver_params', []);
  422.         $sth->STORE('NUM_OF_PARAMS', ($statement =~ tr/?//));</PRE>
  423. <PRE>
  424.         $sth;
  425.   }</PRE>
  426. <P>This is still the same: Check the arguments and call the super class
  427. constructor <EM>DBI::_new_sth</EM>. Note the prefix <EM>driver_</EM> in the
  428. attribute names: It is required that your private attributes
  429. are lowercased and use such a prefix. See the DBI manual.</P>
  430. <P>Note that we parse the statement here in order to setup the attribute
  431. <EM>NUM_OF_PARAMS</EM>. We could as well do this in the <EM>execute</EM> method
  432. below, the DBI specs explicitly allow to defer this. However, one
  433. could not call <EM>bind_param</EM> in that case.</P>
  434. <P></P>
  435. <DT><STRONG><A NAME="item_Transaction_handling">Transaction handling</A></STRONG><BR>
  436. <DD>
  437. Pure Perl drivers will rarely support transactions. Thus you're <EM>commit</EM>
  438. and <EM>rollback</EM> methods will typically be quite simple:
  439. <PRE>
  440.   sub commit {
  441.     my($dbh) = @_;
  442.     if ($dbh->FETCH('Warn')) {
  443.       warn("Commit ineffective while AutoCommit is on");
  444.     }
  445.     1;
  446.   }</PRE>
  447. <PRE>
  448.   sub rollback {
  449.     my($dbh) = @_;
  450.     if ($dbh->FETCH('Warn')) {
  451.       warn("Rollback ineffective while AutoCommit is on");
  452.     }
  453.     0;
  454.   }</PRE>
  455. <P></P>
  456. <DT><STRONG><A NAME="item_The_STORE_and_FETCH_methods">The STORE and FETCH methods</A></STRONG><BR>
  457. <DD>
  458. These methods (that we have already used, see above) are called for
  459. you, whenever the user does a
  460. <PRE>
  461.     $dbh->{$attr} = $val;</PRE>
  462. <P>or, respectively,</P>
  463. <PRE>
  464.     $val = $dbh->{$attr};</PRE>
  465. <P>See <EM>perltie(1)</EM> for details on tied hash refs to understand why these
  466. methods are required.</P>
  467. <P>The DBI will handle most attributes for you, in particular attributes
  468. like <EM>RaiseError</EM> or <EM>PrintError</EM>. All you have to do handle your
  469. driver's private attributes and any attributes, like AutoCommit, that
  470. the DBI can't handle for you. A good example might look like this:</P>
  471. <PRE>
  472.   sub STORE {
  473.     my($dbh, $attr, $val) = @_;
  474.     if ($attr eq 'AutoCommit') {
  475.       # AutoCommit is currently the only standard attribute we have
  476.       # to consider.
  477.       if (!$val) { die "Can't disable AutoCommit"; }
  478.       return 1;
  479.     }
  480.     if ($attr =~ /^driver_/) {
  481.       # Handle only our private attributes here
  482.       # Note that we could trigger arbitrary actions.
  483.       # Ideally we should catch unknown attributes.
  484.       $dbh->{$attr} = $val; # Yes, we are allowed to do this,
  485.       return 1;             # but only for our private attributes
  486.     }
  487.     # Else pass up to DBI to handle for us
  488.     $dbh->SUPER::STORE($attr, $val);
  489.   }</PRE>
  490. <PRE>
  491.   sub FETCH {
  492.     my($dbh, $attr) = @_;
  493.     if ($attr eq 'AutoCommit') { return 1; }
  494.     if ($attr =~ /^driver_/) {
  495.       # Handle only our private attributes here
  496.       # Note that we could trigger arbitrary actions.
  497.       return $dbh->{$attr}; # Yes, we are allowed to do this,
  498.                             # but only for our private attributes
  499.     }
  500.     # Else pass up to DBI to handle
  501.     $dbh->SUPER::FETCH($attr);
  502.   }</PRE>
  503. <P>The DBI will actually store and fetch driver-specific attributes (with all
  504. lowercase names) without warning or error, so there's actually no need to
  505. implement driver-specific any code in your FETCH and STORE methods unless
  506. you need extra logic/checks, beyond getting or setting the value.</P>
  507. <P></P>
  508. <DT><STRONG><A NAME="item_Other_database_handle_methods">Other database handle methods</A></STRONG><BR>
  509. <DD>
  510. may follow here. In particular you should consider a (possibly empty)
  511. <EM>disconnect</EM> method, a <EM>quote</EM> method (if DBI's default isn't good
  512. for you).
  513. <P></P>
  514. <DT><STRONG><A NAME="item_The_execute_method">The execute method</A></STRONG><BR>
  515. <DD>
  516. This is perhaps the most difficult method because we have to consider
  517. parameter bindings here. We present a simplified implementation by
  518. using the <EM>driver_params</EM> attribute from above:
  519. <PRE>
  520.   package DBD::Driver::st;</PRE>
  521. <PRE>
  522.   $DBD::Driver::st::imp_data_size = 0;</PRE>
  523. <PRE>
  524.   sub bind_param {
  525.     my($sth, $pNum, $val, $attr) = @_;
  526.     my $type = (ref $attr) ? $attr->{TYPE} : $attr;
  527.     if ($type) {
  528.         my $dbh = $sth->{Database};
  529.         $val = $dbh->quote($sth, $type);
  530.     }
  531.     my $params = $sth->FETCH('driver_params');
  532.     $params->[$pNum-1] = $val;
  533.     1;
  534.   }</PRE>
  535. <PRE>
  536.   sub execute {
  537.     my($sth, @bind_values) = @_;
  538.     my $params = (@bind_values) ?
  539.         \@bind_values : $sth->FETCH('driver_params');
  540.     my $numParam = $sth->FETCH('NUM_OF_PARAMS');
  541.     if (@$params != $numParam) { ... }
  542.     my $statement = $sth->{'Statement'};
  543.     for (my $i = 0;  $i < $numParam;  $i++) {
  544.         $statement =~ s/?/$params->[$i]/e;
  545.     }
  546.     # Do anything ... we assume that an array ref of rows is
  547.     # created and store it:
  548.     $sth->{'driver_data'} = $data;
  549.     $sth->{'driver_rows'} = @$data; # number of rows
  550.     $sth->STORE('NUM_OF_FIELDS') = $numFields;
  551.     @$data || '0E0';
  552.   }</PRE>
  553. <P>Things you should note here: We setup the NUM_OF_FIELDS attribute
  554. here, because this is essential for <EM>bind_columns</EM> to work. And
  555. we use attribute <EM>$sth-</EM>{'Statement'}> which we have created
  556. within <EM>prepare</EM>. The attribute <EM>$sth-</EM>{'Database'}>, which is
  557. nothing else than the <EM>dbh</EM>, was automatically created by DBI.</P>
  558. <P>Finally note that we return the string '0E0' instead of the number
  559. 0, so that</P>
  560. <PRE>
  561.   if (!$sth->execute()) { die $sth->errstr }</PRE>
  562. <P>works.</P>
  563. <P></P>
  564. <DT><STRONG><A NAME="item_Fetching_data">Fetching data</A></STRONG><BR>
  565. <DD>
  566. We need not implement the methods <EM>fetchrow_array</EM>, <EM>fetchall_arrayref</EM>,
  567. ... because these are already part of DBI. All we need is the method
  568. <EM>fetchrow_arrayref</EM>:
  569. <PRE>
  570.   sub fetchrow_arrayref {
  571.     my($sth) = @_;
  572.     my $data = $sth->FETCH('driver_data');
  573.     my $row = shift @$data;
  574.     if (!$row) { return undef; }
  575.     if ($sth->FETCH('ChopBlanks')) {
  576.         map { $_ =~ s/\s+$//; } @$row;
  577.     }
  578.     return $sth->_set_fbav($row);
  579.   }
  580.   *fetch = \&fetchrow_arrayref; # required alias for fetchrow_arrayref</PRE>
  581. <PRE>
  582.   sub rows { my($sth) = @_; $sth->FETCH('driver_rows'); }</PRE>
  583. <P>Note the use of the method <EM>_set_fbav</EM>: This is required so that
  584. <EM>bind_col</EM> and <EM>bind_columns</EM> work.</P>
  585. <P>Fixing the broken implementation for correct handling of quoted
  586. question marks is left as an exercise to the reader. :-)</P>
  587. <P></P>
  588. <DT><STRONG><A NAME="item_Statement_attributes">Statement attributes</A></STRONG><BR>
  589. <DD>
  590. The main difference between dbh and sth attributes is, that you
  591. should implement a lot of attributes here that are required by
  592. the DBI: For example <EM>NAME</EM>, <EM>NULLABLE</EM>, <EM>TYPE</EM>, ...
  593. <P>Besides that the STORE and FETCH methods are mainly the same
  594. as above for dbh's.</P>
  595. <P></P>
  596. <DT><STRONG><A NAME="item_Other_statement_methods">Other statement methods</A></STRONG><BR>
  597. <DD>
  598. A trivial <CODE>finish</CODE> method to discard the stored data and do
  599. $sth->SUPER::finish;
  600. <P>A <CODE>table_info</CODE> method to return details of available tables.</P>
  601. <P>A <CODE>type_info_all</CODE> method to return details of supported types.</P>
  602. <P>And perhaps some other methods that are not part of the DBI specs, in
  603. particular make metadata available. Considering Tim's last articles do
  604. yourself a favour and follow the ODBC driver.</P>
  605. <P></P></DL>
  606. <P>
  607. <H2><A NAME="tests">Tests</A></H2>
  608. <P>The test process should conform as closely as possibly to the Perl
  609. standard test harness.</P>
  610. <P>In particular, most of the tests should be run in the t sub-directory,
  611. and should simply produce an 'ok' when run under 'make test'.
  612. For details on how this is done, see the Camel book and the section in
  613. Chapter 7, ``The Standard Perl Library'' on <A HREF="../../../lib/Test/Harness.html">the Test::Harness manpage</A>.</P>
  614. <P>The tests may need to adapt to the type of database which is being
  615. used for testing, and to the privileges of the user testing the
  616. driver.</P>
  617. <P>The DBD::Informix test code has to adapt in a number of places to the
  618. type of database to which it is connected as different Informix
  619. databases have different capabilities.</P>
  620. <PRE>
  621.         [...More info TBS...]</PRE>
  622. <P>
  623. <HR>
  624. <H1><A NAME="creating a new driver using c/xs">CREATING A NEW DRIVER USING C/XS</A></H1>
  625. <P>Creating a new C/XS driver from scratch will always be a daunting task.
  626. You can and should greatly simplify your task by taking a good
  627. reference driver implementation and modifying that to match the
  628. database product for which you are writing a driver.</P>
  629. <P>The de facto reference driver has been the one for DBD::Oracle, written
  630. by Tim Bunce who is also the author of the DBI package. The DBD::Oracle
  631. module is a good example of a driver implemented around a C-level API.</P>
  632. <P>Nowadays it it seems better to base on DBD::ODBC, another driver
  633. maintained by Tim and Jeff Urlwin, because it offers a lot of metadata
  634. and seems to become the guideline for the future development. (Also as
  635. DBD::Oracle digs deeper into the Oracle 8 OCI interface it'll get even
  636. more hairly than it is now.)</P>
  637. <P>The DBD::Informix driver is a good reference for a driver implemented
  638. using 'embedded SQL'. DBD::Ingres may also be worth a look.</P>
  639. <PRE>
  640.         [...More info TBS...]</PRE>
  641. <P>
  642. <H2><A NAME="requirements on a driver">REQUIREMENTS ON A DRIVER</A></H2>
  643. <P>T.B.S.</P>
  644. <P>
  645. <H2><A NAME="code to be written">CODE TO BE WRITTEN</A></H2>
  646. <P>A minimal driver will typically contain 7 files plus some tests.
  647. Assuming that your driver is called DBD::Driver, these files are:</P>
  648. <DL>
  649. <DT><STRONG><A NAME="item_Driver%2Epm">Driver.pm</A></STRONG><BR>
  650. <DD>
  651. <DT><STRONG><A NAME="item_Driver%2Exs">Driver.xs</A></STRONG><BR>
  652. <DD>
  653. <DT><STRONG><A NAME="item_Driver%2Eh">Driver.h</A></STRONG><BR>
  654. <DD>
  655. <DT><STRONG><A NAME="item_dbdimp%2Eh">dbdimp.h</A></STRONG><BR>
  656. <DD>
  657. <DT><STRONG><A NAME="item_dbdimp%2Ec">dbdimp.c</A></STRONG><BR>
  658. <DD>
  659. <DT><STRONG><A NAME="item_Makefile%2EPL">Makefile.PL</A></STRONG><BR>
  660. <DD>
  661. <DT><STRONG><A NAME="item_README">README</A></STRONG><BR>
  662. <DD>
  663. <DT><STRONG><A NAME="item_MANIFEST">MANIFEST</A></STRONG><BR>
  664. <DD>
  665. </DL>
  666. <P>
  667. <H2><A NAME="driver.pm">Driver.pm</A></H2>
  668. <P>The Driver.pm file is the same as for Pure Perl modules, see above.
  669. However, there are some subtile differences:</P>
  670. <UL>
  671. <LI>
  672. The variables $DBD::File::dr|db|st::imp_data_size are not defined
  673. here, but in the XS code, because they declare the size of certain
  674. C structures.
  675. <P></P>
  676. <LI>
  677. Some methods are typically moved to the XS code, in particular
  678. <EM>prepare</EM>, <EM>execute</EM>, <EM>disconnect</EM>, <EM>disconnect_all</EM> and the STORE
  679. and FETCH methods.
  680. <P></P>
  681. <LI>
  682. Other methods are still part of <A HREF="#item_Driver%2Epm"><CODE>Driver.pm</CODE></A>, but have callbacks in
  683. the XS code.
  684. <P></P></UL>
  685. <P>Now let's take a closer look at an excerpt of Oracle.pm (around version
  686. 0.54, prior to Oracle 8 support) as an example.  We ignore things that
  687. are already discussed for Pure Perl drivers or really Oracle specific.</P>
  688. <DL>
  689. <DT><STRONG>The database handle constructor</STRONG><BR>
  690. <DD>
  691. <PRE>
  692.   sub connect {
  693.         my($drh, $dbname, $user, $auth)= @_;</PRE>
  694. <PRE>
  695.         # Some database specific verifications, default settings
  696.         # and the like following here. This should only include
  697.         # syntax checks or similar stuff where it's legal to
  698.         # 'die' in case of errors.</PRE>
  699. <PRE>
  700.         # create a 'blank' dbh (call superclass constructor)
  701.         my $dbh = DBI::_new_dbh($drh, {
  702.             'Name' => $dbname,
  703.             'USER' => $user, 'CURRENT_USER' => $user,
  704.             });</PRE>
  705. <PRE>
  706.         # Call Oracle OCI orlon func in Oracle.xs file
  707.         # and populate internal handle data.
  708.         DBD::Oracle::db::_login($dbh, $dbname, $user, $auth)
  709.             or return undef;</PRE>
  710. <PRE>
  711.         $dbh;
  712.     }</PRE>
  713. <P>This is mostly the same as in the Pure Perl case, the exception being
  714. the use of the private <EM>_login</EM> callback: This will really connect to
  715. the database. It is implemented in Driver.xst (you should not implement
  716. it) and calls <EM>dbd_db_login</EM> from <EM>dbdimp.c</EM>. See below for details.</P>
  717. <P>Since the DBI::_new_xxh methods can't fail in normal situations, we
  718. don't both checking $dbh before calling _login.</P>
  719. <DT><STRONG>The statement handle constructor</STRONG><BR>
  720. <DD>
  721. There's nothing much new in the statement handle constructor. Like
  722. the <EM>connect</EM> method it now has a C callback:
  723. <PRE>
  724.   package DBD::Oracle::db; # ====== DATABASE ======
  725.   use strict;</PRE>
  726. <PRE>
  727.   sub prepare {
  728.         my($dbh, $statement, @attribs)= @_;</PRE>
  729. <PRE>
  730.         # create a 'blank' sth
  731.         my $sth = DBI::_new_sth($dbh, {
  732.             'Statement' => $statement,
  733.             });</PRE>
  734. <PRE>
  735.         # Call Oracle OCI oparse func in Oracle.xs file.
  736.         # (This will actually also call oopen for you.)
  737.         # and populate internal handle data.</PRE>
  738. <PRE>
  739.         DBD::Oracle::st::_prepare($sth, $statement, @attribs)
  740.             or return undef;</PRE>
  741. <PRE>
  742.         $sth;
  743.   }</PRE>
  744. <P></P></DL>
  745. <P>
  746. <H2><A NAME="driver.xs">Driver.xs</A></H2>
  747. <P>Driver.xs should look something like this:</P>
  748. <PRE>
  749.   #include "Driver.h"</PRE>
  750. <PRE>
  751.   DBISTATE_DECLARE;</PRE>
  752. <PRE>
  753.   INCLUDE: Driver.xsi</PRE>
  754. <PRE>
  755.   MODULE = DBD::Driver    PACKAGE = DBD::Driver::db</PRE>
  756. <PRE>
  757.   /* Non-standard dbh XS methods following here, if any.       */
  758.   /* Currently this includes things like _list_tables from     */
  759.   /* DBD::mSQL and DBD::mysql.                                 */</PRE>
  760. <PRE>
  761.   MODULE = DBD::Driver    PACKAGE = DBD::Driver::st</PRE>
  762. <PRE>
  763.   /* Non-standard sth XS methods following here, if any.       */
  764.   /* In particular this includes things like _list_fields from */
  765.   /* DBD::mSQL and DBD::mysql for accessing metadata.          */</PRE>
  766. <P>Note especially the include of <EM>Driver.xsi</EM> here: DBI inserts stub
  767. functions for almost all private methods here which will typically
  768. do much work for you. Wherever you really have to implement something,
  769. it will call a private function in <EM>dbdimp.c</EM>: This is what you have
  770. to implement.</P>
  771. <P>
  772. <H2><A NAME="driver.h">Driver.h</A></H2>
  773. <P>Driver.h should look like this:</P>
  774. <PRE>
  775.   #define NEED_DBIXS_VERSION 93</PRE>
  776. <PRE>
  777.   #include <DBIXS.h>      /* installed by the DBI module  */</PRE>
  778. <PRE>
  779.   #include "dbdimp.h"</PRE>
  780. <PRE>
  781.   #include <dbd_xsh.h>     /* installed by the DBI module  */</PRE>
  782. <P>
  783. <H2><A NAME="implementation header dbdimp.h">Implementation header dbdimp.h</A></H2>
  784. <P>This header file has two jobs:</P>
  785. <P>First it defines data structures for your private part of the handles.</P>
  786. <P>Second it defines macros that rename the generic names like
  787. <EM>dbd_db_login</EM> to database specific names like <EM>ora_db_login</EM>. This
  788. avoids name clashes and enables use of different drivers when you work
  789. with a statically linked perl.</P>
  790. <P>It also will have the important task of disabling XS methods that you
  791. don't want to implement.</P>
  792. <P>Finally, the macros will also be used to select alternate
  793. implementations of some functions. For example, the currently defined
  794. <A HREF="#item_dbd_db_login"><CODE>dbd_db_login</CODE></A> function is not passed the attribute hash. In future,
  795. if a dbd_db_login6 macro is defined (for a function with 6 arguments),
  796. it will be used instead with the attribute hash passed at the sixth
  797. argument.</P>
  798. <P>People liked to just pick Oracle's dbdimp.c and use the same names,
  799. structures and types. I strongly recommend against that: At first
  800. glance this saves time, but your implementation will be less readable.
  801. It was just a hell when I had to separate DBI specific parts, Oracle
  802. specific parts, mSQL specific parts and mysql specific parts in
  803. DBD::mysql's <EM>dbdimp.h</EM> and <EM>dbdimp.c</EM>. (DBD::mysql was a port of
  804. DBD::mSQL which was based on DBD::Oracle.) This part of the driver
  805. is <EM>your exclusive part</EM>. Rewrite it from scratch, so it will be
  806. clean and short, in other words: A better piece of code. (Of course
  807. have an eye at other people's work.)</P>
  808. <PRE>
  809.    struct imp_drh_st {
  810.         dbih_drc_t com;         /* MUST be first element in structure   */</PRE>
  811. <PRE>
  812.        /* Insert your driver handle attributes here */
  813.    };</PRE>
  814. <PRE>
  815.    struct imp_dbh_st {
  816.        dbih_dbc_t com;          /* MUST be first element in structure   */</PRE>
  817. <PRE>
  818.        /* Insert your database handle attributes here */
  819.    };</PRE>
  820. <PRE>
  821.    struct imp_sth_st {
  822.        dbih_stc_t com;          /* MUST be first element in structure   */</PRE>
  823. <PRE>
  824.        /* Insert your statement handle attributes here */
  825.    };</PRE>
  826. <PRE>
  827.    /*  Rename functions for avoiding name clashes; prototypes are  */
  828.    /*  in dbd_xst.h                                                */
  829.    #define dbd_init         ora_init
  830.    #define dbd_db_login     ora_db_login
  831.    #define dbd_db_do        ora_db_do
  832.    ... many more here ...</PRE>
  833. <P>This structures implement your private part of the handles. You <EM>have</EM>
  834. to use the name <EM>imp_dbh_dr|db|st</EM> and the first field <EM>must</EM> be of
  835. type <EM>dbih_drc|dbc|stc_t</EM>. You should never access this fields directly,
  836. except of using the <EM>DBIc_xxx</EM> macros below.</P>
  837. <P>
  838. <H2><A NAME="implementation source dbdimp.c">Implementation source dbdimp.c</A></H2>
  839. <P>This is the main implementation file. I will drop a short note on any
  840. function here that's used in the <EM>Driver.xsi</EM> template and thus <STRONG>has</STRONG>
  841. to be implemented. Of course you can add private or better static
  842. functions here.</P>
  843. <P>Note that most people are still using Kernighan & Ritchie syntax here.
  844. I personally don't like this and especially in this documentation it
  845. cannot be of harm, so let's use ANSI. Finally Tim Bunce has announced
  846. interest in moving the DBI sources to ANSI as well.</P>
  847. <DL>
  848. <DT><STRONG><A NAME="item_Initialization">Initialization</A></STRONG><BR>
  849. <DD>
  850. <PRE>
  851.     #include "Driver.h"</PRE>
  852. <PRE>
  853.     DBISTATE_DECLARE;</PRE>
  854. <PRE>
  855.     void dbd_init(dbistate_t* dbistate) {
  856.         DBIS = dbistate;  /*  Initialize the DBI macros  */
  857.     }</PRE>
  858. <P>dbd_init will be called when your driver is first loaded. These
  859. statements are needed for use of the DBI macros. They will include your
  860. private header file <EM>dbdimp.h</EM> in turn.</P>
  861. <DT><STRONG><A NAME="item_do_error">do_error</A></STRONG><BR>
  862. <DD>
  863. You need a function to handle recording of errors. You can call it
  864. whatever you like, but we'll call it <A HREF="#item_do_error"><CODE>do_error</CODE></A> here.
  865. <PRE>
  866.     void do_error(SV* h, int rc, char* what) {</PRE>
  867. <P>Note that <EM>h</EM> is a generic handle, may it be a driver handle, a
  868. database or a statement handle.</P>
  869. <PRE>
  870.         D_imp_xxh(h);</PRE>
  871. <P>This macro will declare and initialize a variable <EM>imp_xxh</EM> with
  872. a pointer to your private handle pointer. You may cast this to
  873. to <EM>imp_drh_t</EM>, <EM>imp_dbh_t</EM> or <EM>imp_sth_t</EM>.</P>
  874. <PRE>
  875.         SV *errstr = DBIc_ERRSTR(imp_xxh);
  876.         sv_setiv(DBIc_ERR(imp_xxh), (IV)rc);    /* set err early        */
  877.         sv_setpv(errstr, what);
  878.         DBIh_EVENT2(h, ERROR_event, DBIc_ERR(imp_xxh), errstr);</PRE>
  879. <P>Note the use of the macros DBIc_ERRSTR and DBIc_ERR for accessing the
  880. handles error string and error code.</P>
  881. <P>The macro DBIh_EVENT2 will ensure that the attributes <EM>RaiseError</EM>
  882. and <EM>PrintError</EM> work: That's all what you have to deal with them. :-)</P>
  883. <PRE>
  884.         if (dbis->debug >= 2)
  885.               fprintf(DBILOGFP, "%s error %d recorded: %s\n",
  886.                     what, rc, SvPV(errstr,na));</PRE>
  887. <P>That's the first time we see how debug/trace logging works within a DBI
  888. driver.  Make use of this as often as you can!</P>
  889. <P></P>
  890. <DT><STRONG><A NAME="item_dbd_db_login">dbd_db_login</A></STRONG><BR>
  891. <DD>
  892. <PRE>
  893.     int dbd_db_login(SV* dbh, imp_dbh_t* imp_dbh, char* dbname,
  894.                      char* user, char* auth) {</PRE>
  895. <P>This function will really connect to the database. The argument <EM>dbh</EM>
  896. is the database handle. <EM>imp_dbh</EM> is the pointer to the handles private
  897. data, as is <EM>imp_xxx</EM> in <EM>do_error</EM> above. The arguments <EM>dsn</EM>,
  898. <EM>user</EM> and <EM>auth</EM> correspond to the arguments of the driver handles
  899. <EM>connect</EM> method.</P>
  900. <P>You will quite often use database specific attributes here, that are
  901. specified in the DSN. I recommend you parse the DSN within the
  902. <EM>connect</EM> method and pass them as handle attributes to <EM>dbd_db_login</EM>.
  903. Here's how you fetch them, as an example we use <EM>hostname</EM> and <EM>port</EM>
  904. attributes:</P>
  905. <PRE>
  906.   /* This code assumes that the *second* attribute parameter to
  907.    * DBI::_new_dbh was used to store an hash with login attributes
  908.    */
  909.   SV* imp_data = DBIc_IMP_DATA(dbh);
  910.   HV* hv;
  911.   SV** svp;
  912.   char* hostname;
  913.   char* port;</PRE>
  914. <PRE>
  915.   if (!SvTRUE(imp_data)  ||  !SvROK(imp_data)  ||
  916.         SvTYPE(hv = (HV*) SvRV(imp_data)) != SVt_PVHV) {
  917.         croak("Implementation dependent data invalid: Not a hash ref.\n");
  918.   }
  919.   if ((svp = hv_fetch(hv, "hostname", strlen("hostname"), FALSE)) &&
  920.         SvTRUE(*svp)) {
  921.         hostname = SvPV(*svp, na);
  922.   } else {
  923.         hostname = "localhost";
  924.   }
  925.   if ((svp = hv_fetch(hv, "port", strlen("port"), FALSE))  &&
  926.         SvTRUE(*svp)) {
  927.         port = SvPV(*svp, na);  /*  May be a service name  */
  928.   } else {
  929.         port = DEFAULT_PORT;
  930.   }</PRE>
  931. <P>Now you should really connect to the database. If you are successful
  932. (or even if you fail, but you have allocated some resources), you should
  933. use the following macros:</P>
  934. <PRE>
  935.     DBIc_IMPSET_on(imp_dbh);</PRE>
  936. <P>This indicates that the driver (implementor) has allocated resources in
  937. the imp_dbh structure and that the implementors private dbd_db_destroy
  938. function should be called when the handle is destroyed.</P>
  939. <PRE>
  940.     DBIc_ACTIVE_on(imp_dbh);</PRE>
  941. <P>This indicates that the handle has an active connection to the server
  942. and that the dbd_db_disconnect function should be called before the
  943. handle is destroyed.</P>
  944. <P>The dbd_db_login function should return TRUE for success, FALSE otherwise.</P>
  945. <DT><STRONG><A NAME="item_dbd_db_commit">dbd_db_commit</A></STRONG><BR>
  946. <DD>
  947. <DT><STRONG><A NAME="item_dbd_db_rollback">dbd_db_rollback</A></STRONG><BR>
  948. <DD>
  949. <PRE>
  950.     int dbd_db_commit(   SV* dbh, imp_dbh_t* imp_dbh );
  951.     int dbd_db_rollback( SV* dbh, imp_dbh_t* imp_dbh );</PRE>
  952. <P>These are used for commit and rollback. They should return TRUE for
  953. success, FALSE for error.</P>
  954. <P>The arguments <EM>dbh</EM> and <EM>imp_dbh</EM> are like above, I will omit
  955. describing them in what follows, as they appear always.</P>
  956. <DT><STRONG><A NAME="item_dbd_db_disconnect">dbd_db_disconnect</A></STRONG><BR>
  957. <DD>
  958. This is your private part of the <EM>disconnect</EM> method. Any dbh with
  959. the <EM>ACTIVE</EM> flag on must be disconnected. (Note that you have to set
  960. it in <EM>dbd_db_connect</EM> above.)
  961. <PRE>
  962.     int dbd_db_disconnect(SV* dbh, imp_dbh_t* imp_dbh);</PRE>
  963. <P>The database handle will return TRUE for success, FALSE otherwise.
  964. In any case it should do a</P>
  965. <PRE>
  966.     DBIc_ACTIVE_off(imp_dbh);</PRE>
  967. <P>before returning so DBI knows that <EM>dbd_db_disconnect</EM> was executed.</P>
  968. <P></P>
  969. <DT><STRONG><A NAME="item_dbd_db_discon_all">dbd_db_discon_all</A></STRONG><BR>
  970. <DD>
  971. <PRE>
  972.     int dbd_discon_all (SV *drh, imp_drh_t *imp_drh) {</PRE>
  973. <P>This function may be called at shutdown time. It should make
  974. best-efforts to disconnect all database handles - if possible. Some
  975. databases don't support that, in which case you can do nothing
  976. but return 'success'.</P>
  977. <P>You guess what the return codes are? (Hint: See the last functions
  978. above ... :-)</P>
  979. <DT><STRONG><A NAME="item_dbd_db_destroy">dbd_db_destroy</A></STRONG><BR>
  980. <DD>
  981. This is your private part of the database handle destructor. Any dbh with
  982. the <EM>IMPSET</EM> flag on must be destroyed, so that you can safely free
  983. resources. (Note that you have to set it in <EM>dbd_db_connect</EM> above.)
  984. <PRE>
  985.     void dbd_db_destroy(SV* dbh, imp_dbh_t* imp_dbh) {
  986.         DBIc_IMPSET_off(imp_dbh);
  987.     }</PRE>
  988. <P>The DBI Driver.xst code will have called dbd_db_disconnect for you,
  989. if the handle is still 'active', before calling dbd_db_destroy.</P>
  990. <P>Before returning the function must switch IMPSET to off, so DBI knows
  991. that the destructor was called.</P>
  992. <P></P>
  993. <DT><STRONG><A NAME="item_dbd_db_STORE_attrib">dbd_db_STORE_attrib</A></STRONG><BR>
  994. <DD>
  995. This function handles
  996. <PRE>
  997.      $dbh->{$key} = $value;</PRE>
  998. <P>its prototype is</P>
  999. <PRE>
  1000.     int dbd_db_STORE_attrib(SV* dbh, imp_dbh_t* imp_dbh, SV* keysv,
  1001.                             SV* valuesv);</PRE>
  1002. <P>You do not handle all attributes, in contrary you should not handle
  1003. DBI attributes here: Leave this to DBI. (There's one exception,
  1004. <EM>AutoCommit</EM>, which you should care about.)</P>
  1005. <P>The return value is TRUE, if you have handled the attribute or FALSE
  1006. otherwise. If you are handling an attribute and something fails, you
  1007. should call <EM>do_error</EM>, so DBI can raise exceptions, if desired.
  1008. If <EM>do_error</EM> returns, however, you have a problem: The user will
  1009. never know about the error, because he typically will not check
  1010. <A HREF="#item_errstr"><CODE>$dbh->errstr</CODE></A>.</P>
  1011. <P>I cannot recommend a general way of going on, if <EM>do_error</EM> returns,
  1012. but there are examples where even the DBI specification expects that
  1013. you croak(). (See the <EM>AutoCommit</EM> method in <EM>DBI(3)</EM>.)</P>
  1014. <P>If you have to store attributes, you should either use your private
  1015. data structure imp_xxx, the handle hash (via (HV*)SvRV(dbh)), or use
  1016. the private imp_data.</P>
  1017. <P>The first is best for internal C values like integers or pointers and
  1018. where speed is important within the driver. The handle hash is best for
  1019. values the user may want to get/set via driver-specific attributes.
  1020. The private imp_data is an additional SV attached to the handle. You
  1021. could think of it as an unnamed handle attribute. It's not normally used.</P>
  1022. <P></P>
  1023. <DT><STRONG><A NAME="item_dbd_db_FETCH_attrib">dbd_db_FETCH_attrib</A></STRONG><BR>
  1024. <DD>
  1025. This is the counterpart of dbd_db_STORE_attrib, needed for
  1026. <PRE>
  1027.     $value = $dbh->{$key};</PRE>
  1028. <P>Its prototype is:</P>
  1029. <PRE>
  1030.     SV* dbd_db_FETCH_attrib(SV* dbh, imp_dbh_t* imp_dbh, SV* keysv) {</PRE>
  1031. <P>Unlike all previous methods this returns an SV with the value. Note
  1032. that you should normally execute sv_2mortal, if you return a nonconstant
  1033. value. (Constant values are <CODE>&sv_undef</CODE>, <CODE>&sv_no</CODE> and <CODE>&sv_yes</CODE>.)</P>
  1034. <P>Note, that DBI implements a caching algorithm for attribute values.
  1035. If you think, that an attribute may be fetched, you store it in the
  1036. dbh itself:</P>
  1037. <PRE>
  1038.     if (cacheit) /* cache value for later DBI 'quick' fetch? */
  1039.         hv_store((HV*)SvRV(dbh), key, kl, cachesv, 0);</PRE>
  1040. <P></P>
  1041. <DT><STRONG><A NAME="item_dbd_st_prepare">dbd_st_prepare</A></STRONG><BR>
  1042. <DD>
  1043. This is the private part of the <EM>prepare</EM> method. Note that you
  1044. <STRONG>must not</STRONG> really execute the statement here. You may, for example,
  1045. preparse and validate the statement or do similar things.
  1046. <PRE>
  1047.     int dbd_st_prepare(SV* sth, imp_sth_t* imp_sth, char* statement,
  1048.                        SV* attribs);</PRE>
  1049. <P>A typical, simple possibility is just to store the statement in the
  1050. imp_data hash ref and use it in dbd_st_execute. If you can, you should
  1051. setup attributes like NUM_OF_FIELDS, NAME, ... here, but DBI
  1052. doesn't require that. However, if you do, document it.</P>
  1053. <P>In any case you should set the IMPSET flag, as you did in
  1054. <EM>dbd_db_connect</EM> above:</P>
  1055. <PRE>
  1056.    DBIc_IMPSET_on(imp_sth);</PRE>
  1057. <P></P>
  1058. <DT><STRONG><A NAME="item_dbd_st_execute">dbd_st_execute</A></STRONG><BR>
  1059. <DD>
  1060. This is where a statement will really be executed.
  1061. <PRE>
  1062.    int dbd_st_execute(SV* sth, imp_sth_t* imp_sth);</PRE>
  1063. <P>Note, that you must be aware, that a statement may be executed repeatedly.
  1064. Also, you should not expect, that <EM>finish</EM> will be called between
  1065. two executions.</P>
  1066. <P>If your driver supports binding of parameters (he should!), but the
  1067. database doesn't, you must probably do it here. This can be done as
  1068. follows:</P>
  1069. <PRE>
  1070.       char* statement = dbd_st_get_statement(sth, imp_sth);
  1071.           /*  Its your drivers task to implement this function.  It      */
  1072.           /*  must restore the statement passed to preparse.            */
  1073.           /*  See use of imp_data above for an example of how to do     */
  1074.           /* this.                                                     */
  1075.       int numParam = DBIc_NUM_PARAMS(imp_sth);
  1076.       int i;</PRE>
  1077. <PRE>
  1078.       for (i = 0;  i < numParam;  i++) {
  1079.           char* value = dbd_db_get_param(sth, imp_sth, i);
  1080.               /*  Its your drivers task to implement dbd_db_get_param,  */
  1081.               /*  it must be setup as a counterpart of dbd_bind_ph.     */
  1082.           /*  Look for '?' and replace it with 'value'.  Difficult       */
  1083.           /*  task, note that you may have question marks inside        */
  1084.           /*  quotes and the like ...  :-(                               */
  1085.           /*  See DBD::mysql for an example. (Don't look too deep into  */
  1086.           /*  the example, you will notice where I was lazy ...)        */
  1087.       }</PRE>
  1088. <P>The next thing is you really execute the statement. Note that you must
  1089. prepare the attributes NUM_OF_FIELDS, NAME, ... when the statement is
  1090. successfully executed if you have not already done so: They may be used even before a potential
  1091. <EM>fetchrow</EM>. In particular you have to tell DBI the number of fields,
  1092. that the statement has, because it will be used by DBI internally.
  1093. Thus the function will typically ends with:</P>
  1094. <PRE>
  1095.     if (isSelectStatement) {
  1096.         DBIc_NUM_FIELDS(imp_sth) = numFields;
  1097.     DBIc_ACTIVE_on(imp_sth);
  1098.     }</PRE>
  1099. <P>It is important that the ACTIVE flag only be set for select statements.
  1100. See <EM>dbd_st_preparse</EM> and <EM>dbd_db_connect</EM> above for more explanations.</P>
  1101. <P></P>
  1102. <DT><STRONG><A NAME="item_dbd_st_fetch">dbd_st_fetch</A></STRONG><BR>
  1103. <DD>
  1104. This function fetches a row of data. The row is stored in in an array,
  1105. of SV's that DBI prepares for you. This has two advantages: It is fast
  1106. (you even reuse the SV's, so they don't have to be created after the
  1107. first fetchrow) and it guarantees, that DBI handles <EM>bind_cols</EM> for
  1108. you.
  1109. <P>What you do is the following:</P>
  1110. <PRE>
  1111.     AV* av;
  1112.     int numFields = DBIc_NUM_FIELDS(imp_sth); /* Correct, if NUM_FIELDS
  1113.         is constant for this statement. There are drivers where this is
  1114.         not the case! */
  1115.     int chopBlanks = DBIc_is(imp_sth, DBIcf_ChopBlanks);
  1116.     int i;</PRE>
  1117. <PRE>
  1118.     if (!fetch_new_row_of_data(...)) {
  1119.          ... /* check for error or end-of-data */
  1120.          DBIc_ACTIVE_off(imp_sth); /* turn off Active flag automatically */
  1121.          return Nullav;
  1122.     }
  1123.     /* get the fbav (field buffer array value) for this row     */
  1124.     /* it is very important to only call this after you know    */
  1125.     /* that you have a row of data to return.                   */
  1126.     av = DBIS->get_fbav(imp_sth);
  1127.     for (i = 0;  i < numFields;  i++) {
  1128.         SV* sv = fetch_a_field(..., i);
  1129.         if (chopBlanks && SvOK(sv) && type_is_blank_padded(field_type[i])) {
  1130.             /*  Remove white space from end (only) of sv  */
  1131.         }
  1132.         sv_setsv(AvARRAY(av)[i], sv); /* Note: (re)use! */
  1133.     }
  1134.     return av;</PRE>
  1135. <P>There's no need to use a fetch_a_field function returning an SV*.
  1136. It's more common to use your database API functions to fetch the
  1137. data as character strings and use code like this:</P>
  1138. <PRE>
  1139.         sv_setpvn(AvARRAY(av)[i], char_ptr, char_count);</PRE>
  1140. <P>NULL values must be returned as undef. You can use code like this:</P>
  1141. <PRE>
  1142.         SvOK_off(AvARRAY(av)[i]);</PRE>
  1143. <P>The function returns the AV prepared by DBI for success or <CODE>Nullav</CODE>
  1144. otherwise.</P>
  1145. <P></P>
  1146. <DT><STRONG><A NAME="item_dbd_st_finish">dbd_st_finish</A></STRONG><BR>
  1147. <DD>
  1148. This function can be called if the user wishes to indicate that no
  1149. more rows will be fetched even if the server has more rows to offer.
  1150. See the DBI docs for more background details.
  1151. <P>All it <EM>needs</EM> to do is turn off the Active flag for the sth.
  1152. It will only be called by Driver.xst code, if the driver has set
  1153. ACTIVE to on for the sth.</P>
  1154. <P>Minimal example (the DBI default method just does this):</P>
  1155. <PRE>
  1156.     int dbd_st_finish(SV* sth, imp_sth_t* imp_sth) {
  1157.         DBIc_ACTIVE_off(imp_sth);
  1158.         return 1;
  1159.     }</PRE>
  1160. <P>The function returns TRUE for success, FALSE otherwise.</P>
  1161. <P></P>
  1162. <DT><STRONG><A NAME="item_dbd_st_destroy">dbd_st_destroy</A></STRONG><BR>
  1163. <DD>
  1164. This function is the private part of the statement handle destructor.
  1165. <PRE>
  1166.     void dbd_st_destroy(SV* sth, imp_sth_t* imp_sth);
  1167.         ... /* any clean-up that's needed */
  1168.         DBIc_IMPSET_off(imp_sth); /* let DBI know we've done it   */
  1169.    }</PRE>
  1170. <P>The DBI Driver.xst code will call dbd_st_finish for you, if the sth has
  1171. the ACTIVE flag set, before calling dbd_st_destroy.</P>
  1172. <P></P>
  1173. <DT><STRONG><A NAME="item_dbd_st_STORE_attrib">dbd_st_STORE_attrib</A></STRONG><BR>
  1174. <DD>
  1175. <DT><STRONG><A NAME="item_dbd_st_FETCH_attrib">dbd_st_FETCH_attrib</A></STRONG><BR>
  1176. <DD>
  1177. These functions correspond to dbd_db_STORE|FETCH attrib above, except
  1178. that they are for statement handles. See above.
  1179. <PRE>
  1180.     int dbd_st_STORE_attrib(SV* sth, imp_sth_t* imp_sth, SV* keysv,
  1181.                             SV* valuesv);
  1182.     SV* dbd_st_FETCH_attrib(SV* sth, imp_sth_t* imp_sth, SV* keysv);</PRE>
  1183. <P></P>
  1184. <DT><STRONG><A NAME="item_dbd_bind_ph">dbd_bind_ph</A></STRONG><BR>
  1185. <DD>
  1186. This function is internally used by the <EM>bind_param</EM> method, the
  1187. <EM>bind_param_inout</EM> method and by the DBI Driver.xst code if <CODE>execute</CODE>
  1188. is called with any bind parameters.
  1189. <PRE>
  1190.     int dbd_bind_ph (SV *sth, imp_sth_t *imp_sth, SV *param,
  1191.                      SV *value, IV sql_type, SV *attribs,
  1192.                      int is_inout, IV maxlen);</PRE>
  1193. <P>The <EM>param</EM> argument holds an IV with the parameter number (1, 2, ...).
  1194. The <EM>value</EM> argument is the parameter value and <EM>sql_type</EM> is its type.</P>
  1195. <P>If your driver does not support bind_param_inout then you should
  1196. ignore <EM>maxlen</EM> and croak if <EM>is_inout</EM> is TRUE.</P>
  1197. <P>If your driver <EM>does</EM> support bind_param_inout then you should
  1198. note that <EM>value</EM> is the SV <EM>after</EM> dereferencing the reference
  1199. passed to bind_param_inout.</P>
  1200. <P>In drivers of simple databases the function will, for example, store
  1201. the value in a parameter array and use it later in <EM>dbd_st_execute</EM>.
  1202. See the <EM>DBD::mysql</EM> driver for an example.</P>
  1203. <P></P></DL>
  1204. <P>
  1205. <H2><A NAME="makefile.pl">Makefile.PL</A></H2>
  1206. <P>This is exactly as in the Pure Perl case. To be honest, the above
  1207. Makefile.PL contains some things that are superfluous for Pure Perl
  1208. drivers. :-)</P>
  1209. <P>
  1210. <HR>
  1211. <H1><A NAME="methods which do not need to be written">METHODS WHICH DO NOT NEED TO BE WRITTEN</A></H1>
  1212. <P>The DBI code implements the majority of the methods which are
  1213. accessed using the notation DBI->function(), the only exceptions being
  1214. DBI-><A HREF="../../../lib/Pod/perlfunc.html#item_connect"><CODE>connect()</CODE></A> and DBI-><CODE>data_sources()</CODE> which require support from the
  1215. driver.</P>
  1216. <P>The DBI code implements the following documented driver, database and
  1217. statement functions which do not need to be written by the DBD driver
  1218. writer.</P>
  1219. <DL>
  1220. <DT><STRONG><A NAME="item_do">$dbh-><CODE>do()</CODE></A></STRONG><BR>
  1221. <DD>
  1222. The default implementation of this function prepares, executes and
  1223. destroys the statement.  This can be replaced if there is a better
  1224. way to implement this, such as EXECUTE IMMEDIATE which can
  1225. sometimes be used if there are no parameters.
  1226. <P></P>
  1227. <DT><STRONG><A NAME="item_errstr">$h-><CODE>errstr()</CODE></A></STRONG><BR>
  1228. <DD>
  1229. <DT><STRONG><A NAME="item_err">$h-><CODE>err()</CODE></A></STRONG><BR>
  1230. <DD>
  1231. <DT><STRONG><A NAME="item_state">$h-><CODE>state()</CODE></A></STRONG><BR>
  1232. <DD>
  1233. <DT><STRONG><A NAME="item_trace">$h-><CODE>trace()</CODE></A></STRONG><BR>
  1234. <DD>
  1235. The DBD driver does not need to worry about these routines at all.
  1236. <P></P>
  1237. <DT><STRONG><A NAME="item_%24h%2D%3E%7BChopBlanks%7D">$h->{ChopBlanks}</A></STRONG><BR>
  1238. <DD>
  1239. This attribute needs to be honured during fetch operations, but does
  1240. not need to be handled by the attribute handling code.
  1241. <P></P>
  1242. <DT><STRONG><A NAME="item_%24h%2D%3E%7BRaiseError%7D">$h->{RaiseError}</A></STRONG><BR>
  1243. <DD>
  1244. The DBD driver does not need to worry about this attribute at all.
  1245. <P></P>
  1246. <DT><STRONG><A NAME="item_%24h%2D%3E%7BPrintError%7D">$h->{PrintError}</A></STRONG><BR>
  1247. <DD>
  1248. The DBD driver does not need to worry about this attribute at all.
  1249. <P></P>
  1250. <DT><STRONG><A NAME="item_bind_col">$sth-><CODE>bind_col()</CODE></A></STRONG><BR>
  1251. <DD>
  1252. Assuming the driver uses the DBIS-><CODE>get_fbav()</CODE> function (C drivers,
  1253. see below), or the $sth-><CODE>_set_fbav($data)</CODE> method (Perl drivers)
  1254. the driver does not need to do anything about this routine.
  1255. <P></P>
  1256. <DT><STRONG><A NAME="item_bind_columns">$sth-><CODE>bind_columns()</CODE></A></STRONG><BR>
  1257. <DD>
  1258. Regardless of whether the driver uses DBIS->get_fbav(), the driver
  1259. does not need to do anything about this routine as it simply
  1260. iteratively calls $sth->bind_col().
  1261. <P></P></DL>
  1262. <P>The DBI code implements a default implementation of the following
  1263. functions which do not need to be written by the DBD driver writer
  1264. unless the default implementation is incorrect for the Driver.</P>
  1265. <DL>
  1266. <DT><STRONG><A NAME="item_quote">$dbh-><CODE>quote()</CODE></A></STRONG><BR>
  1267. <DD>
  1268. This should only be written if the database does not accept the ANSI
  1269. SQL standard for quoting strings, with the string enclosed in single
  1270. quotes and any embedded single quotes replaced by two consecutive
  1271. single quotes.
  1272. <P>For the two argument form of quote, you need to implement the
  1273. <CODE>type_info</CODE> method to provide the information that quote needs.</P>
  1274. <P></P>
  1275. <DT><STRONG><A NAME="item_ping">$dbh-><CODE>ping()</CODE></A></STRONG><BR>
  1276. <DD>
  1277. This should be implemented as a simple efficient way to determine
  1278. whether the connection to the database is still alive. Typically
  1279. code like this:
  1280. <PRE>
  1281.   sub ping {
  1282.     my $dbh = shift;
  1283.     $sth = $dbh->prepare_cached(q{
  1284.       select * from A_TABLE_NAME where 1=0
  1285.     }) or return 0;
  1286.     $sth->execute or return 0;
  1287.     $sth->finish;
  1288.     return 1;
  1289.   }</PRE>
  1290. <P>where A_TABLE_NAME is the name of a table that always exists (such as a
  1291. database system catalogue).</P>
  1292. <P></P></DL>
  1293. <P>
  1294. <HR>
  1295. <H1><A NAME="writing an emulation layer for an old perl interface">WRITING AN EMULATION LAYER FOR AN OLD PERL INTERFACE</A></H1>
  1296. <P>Study Oraperl.pm (supplied with DBD::Oracle) and Ingperl.pm (supplied
  1297. with DBD::Ingres) and the corresponding dbdimp.c files for ideas.</P>
  1298. <P>Note that the emulation code sets $dbh->{CompatMode} = 1; for each
  1299. connection so that the internals of the driver can implement behaviour
  1300. compatible with the old interface when dealing with those handles.</P>
  1301. <P>
  1302. <H2><A NAME="setting emulation perl variables">Setting emulation perl variables</A></H2>
  1303. <P>For example, ingperl has a $sql_rowcount variable. Rather than try
  1304. to manually update this in Ingperl.pm it can be done faster in C code.
  1305. In dbd_init():</P>
  1306. <PRE>
  1307.   sql_rowcount = perl_get_sv("Ingperl::sql_rowcount", GV_ADDMULTI);</PRE>
  1308. <P>In the relevant places do:</P>
  1309. <PRE>
  1310.   if (DBIc_COMPAT(imp_sth))     /* only do this for compatibility mode handles */
  1311.       sv_setiv(sql_rowcount, the_row_count);</PRE>
  1312. <P>
  1313. <HR>
  1314. <H1><A NAME="other miscellaneous information">OTHER MISCELLANEOUS INFORMATION</A></H1>
  1315. <P>
  1316. <H2><A NAME="the imp_xyz_t types">The imp_xyz_t types</A></H2>
  1317. <P>Any handle has a corresponding C structure filled with private data.
  1318. Some of this data is reserved for use by DBI (except for using the
  1319. DBIc macros below), some is for you. See the description of the
  1320. <EM>dbdimp.h</EM> file above for examples. The most functions in dbdimp.c
  1321. are passed both the handle <CODE>xyz</CODE> and a pointer to <CODE>imp_xyz</CODE>. In
  1322. rare cases, however, you may use the following macros:</P>
  1323. <DL>
  1324. <DT><STRONG><A NAME="item_D_imp_dbh"><CODE>D_imp_dbh(dbh)</CODE></A></STRONG><BR>
  1325. <DD>
  1326. Given a function argument <EM>dbh</EM>, declare a variable <EM>imp_dbh</EM> and
  1327. initialize it with a pointer to the handles private data. Note: This
  1328. must be a part of the function header, because it declares a variable.
  1329. <P></P>
  1330. <DT><STRONG><A NAME="item_D_imp_sth"><CODE>D_imp_sth(sth)</CODE></A></STRONG><BR>
  1331. <DD>
  1332. Likewise for statement handles.
  1333. <P></P>
  1334. <DT><STRONG><A NAME="item_D_imp_xxx"><CODE>D_imp_xxx(h)</CODE></A></STRONG><BR>
  1335. <DD>
  1336. Given any handle, declare a variable <EM>imp_xxx</EM> and initialize it
  1337. with a pointer to the handles private data. It is safe, for example,
  1338. to cast <EM>imp_xxx</EM> to <CODE>imp_dbh_t*</CODE>, if <CODE>DBIc_TYPE(imp_xxx)</CODE> == DBIt_DB.
  1339. (You can also call sv_derived_from(h, ``DBI::db''), but that's much
  1340. slower.)
  1341. <P></P>
  1342. <DT><STRONG><A NAME="item_D_imp_sth_from_dbh">D_imp_sth_from_dbh</A></STRONG><BR>
  1343. <DD>
  1344. Given a imp_sth, declare a variable <EM>imp_dbh</EM> and initialize it with a
  1345. pointer to the parent database handles implementors structure.
  1346. <P></P></DL>
  1347. <P>
  1348. <H2><A NAME="using dbic_impset_on">Using DBIc_IMPSET_on</A></H2>
  1349. <P>The driver code which initializes a handle should use <CODE>DBIc_IMPSET_on()</CODE>
  1350. as soon as its state is such that the cleanup code must be called.
  1351. When this happens is determined by your driver code.</P>
  1352. <P>Failure to call this can lead to corruption of data structures.
  1353. For example, DBD::Informix maintains a linked list of database handles
  1354. in the driver, and within each handle, a linked list of statements.
  1355. Once a statement is added to the linked list, it is crucial that it is
  1356. cleaned up (removed from the list).
  1357. When <CODE>DBIc_IMPSET_on()</CODE> was being called too late, it was able to cause
  1358. all sorts of problems.</P>
  1359. <P>
  1360. <H2><A NAME="using dbic_is(), dbic_has(), dbic_on() and dbic_off()">Using DBIc_is(), DBIc_has(), <CODE>DBIc_on()</CODE> and <CODE>DBIc_off()</CODE></A></H2>
  1361. <P>Once upon a long time ago, the only way of handling the internal DBI
  1362. boolean flags/attributes was through macros such as:</P>
  1363. <PRE>
  1364.     DBIc_WARN       DBIc_WARN_on        DBIc_WARN_off
  1365.     DBIc_COMPAT     DBIc_COMPAT_on      DBIc_COMPAT_off</PRE>
  1366. <P>Each of these took an imp_xxh pointer as an argument.</P>
  1367. <P>Since then, new attributes have been added such as ChopBlanks,
  1368. RaiseError and PrintError, and these do not have the full set of
  1369. macros.
  1370. The approved method for handling these is now the four macros:</P>
  1371. <PRE>
  1372.         DBIc_is(imp, flag)
  1373.         DBIc_has(imp, flag)    an alias for DBIc_is
  1374.         DBIc_on(imp, flag)
  1375.         DBIc_off(imp, flag)</PRE>
  1376. <P>Consequently, the DBIc_XXXXX family of macros is now mostly deprecated
  1377. and new drivers should avoid using them, even though the older drivers
  1378. will probably continue to do so for quite a while yet. However...</P>
  1379. <P>There is an <EM>important exception</EM> to that. The ACTIVE and IMPSET
  1380. flags should be set via the DBIc_ACTIVE_on and DBIc_IMPSET_on macros,
  1381. and unset via the DBIc_ACTIVE_off and DBIc_IMPSET_off macros.</P>
  1382. <P>
  1383. <H2><A NAME="using dbis>get_fbav()">Using DBIS-><CODE>get_fbav()</CODE></A></H2>
  1384. <P>The $sth-><A HREF="#item_bind_col"><CODE>bind_col()</CODE></A> and $sth-><A HREF="#item_bind_columns"><CODE>bind_columns()</CODE></A> documented in the DBI
  1385. specification do not have to be implemented by the driver writer
  1386. becuase DBI takes care of the details for you.
  1387. However, the key to ensuring that bound columns work is to call the
  1388. function DBIS-><CODE>get_fbav()</CODE> in the code which fetches a row of data.
  1389. This returns an AV, and each element of the AV contains the SV which
  1390. should be set to contain the returned data.</P>
  1391. <P>The above is for C drivers only. The Perl equivalent is the
  1392. $sth-><CODE>_set_fbav($data)</CODE> method, as described in the part on Pure
  1393. Perl drivers.</P>
  1394. <P>
  1395. <HR>
  1396. <H1><A NAME="subclassing dbi drivers">SUBCLASSING DBI DRIVERS</A></H1>
  1397. <P>This is definitely an open subject. It can be done, as demonstrated by
  1398. the <EM>DBD::File</EM> driver, but it is not as simple as one might think.</P>
  1399. <P>(Note that this topic is different from subclassing the DBI. For an
  1400. example of that, see the t/subclass.t file supplied with the DBI.)</P>
  1401. <P>The main problem is that the dbh's and sth's that your <EM>connect</EM> and
  1402. <EM>prepare</EM> methods return are not instances of your <EM>DBD::Driver::db</EM>
  1403. or <EM>DBD::Driver::st</EM> packages, they are not even derived from it.
  1404. Instead they are instances of the <EM>DBI::db</EM> or <EM>DBI::st</EM> classes or
  1405. a derived subclass. Thus, if you write a method <EM>mymethod</EM> and do a</P>
  1406. <PRE>
  1407.     $dbh->mymethod()</PRE>
  1408. <P>then the autoloader will search for that method in the package <EM>DBI::db</EM>.
  1409. Of course you can instead to a</P>
  1410. <PRE>
  1411.     $dbh->func('mymethod')</PRE>
  1412. <P>and that will indeed work, even if <EM>mymethod</EM> is inherited, but not
  1413. without additional work. Setting <CODE>@ISA</CODE> is not sufficient.</P>
  1414. <P>
  1415. <H2><A NAME="overwriting methods">Overwriting methods</A></H2>
  1416. <P>The first problem is, that the <EM>connect</EM> method has no idea of
  1417. subclasses. For example, you cannot implement base class and subclass
  1418. in the same file: The <EM>install_driver</EM> method wants to do a</P>
  1419. <PRE>
  1420.     require DBD::Driver;</PRE>
  1421. <P>In particular, your subclass <STRONG>has</STRONG> to be a separate driver, from
  1422. the view of DBI, and you cannot share driver handles.</P>
  1423. <P>Of course that's not much of a problem. You should even be able
  1424. to inherit the base classes <EM>connect</EM> method. But you cannot
  1425. simply overwrite the method, unless you do something like this,
  1426. quoted from <EM>DBD::CSV</EM>:</P>
  1427. <PRE>
  1428.   sub connect ($$;$$$) {
  1429.     my($drh, $dbname, $user, $auth, $attr) = @_;</PRE>
  1430. <PRE>
  1431.     my $this = $drh->DBD::File::dr::connect($dbname, $user, $auth, $attr);
  1432.     if (!exists($this->{csv_tables})) {
  1433.       $this->{csv_tables} = {};
  1434.     }</PRE>
  1435. <PRE>
  1436.     $this;
  1437.   }</PRE>
  1438. <P>Note that we cannot do a</P>
  1439. <PRE>
  1440.     $srh->SUPER::connect($dbname, $user, $auth, $attr);</PRE>
  1441. <P>as we would usually do in a an OO environment, because $drh is an instance
  1442. of <EM>DBI::dr</EM>. And note, that the <EM>connect</EM> method of <EM>DBD::File</EM> is
  1443. able to handle subclass attributes. See the description of Pure Perl
  1444. drivers above.</P>
  1445. <P>It is essential that you always call superclass method in the above
  1446. manner. However, that should do.</P>
  1447. <P>
  1448. <H2><A NAME="attribute handling">Attribute handling</A></H2>
  1449. <P>Fortunately the DBI specs allow a simple, but still performant way of
  1450. handling attributes. The idea is based on the convention that any
  1451. driver uses a prefix <EM>driver_</EM> for its private methods. Thus it's
  1452. always clear whether to pass attributes to the super class or not.
  1453. For example, consider this STORE method from the <EM>DBD::CSV</EM> class:</P>
  1454. <PRE>
  1455.     sub STORE {
  1456.         my($dbh, $attr, $val) = @_;
  1457.         if ($attr !~ /^driver_/) {
  1458.             return $dbh->DBD::File::db::STORE($attr, $val);
  1459.         }
  1460.         if ($attr eq 'driver_foo') {
  1461.         ...
  1462.     }</PRE>
  1463. <P>
  1464. <HR>
  1465. <H1><A NAME="acknowledgements">ACKNOWLEDGEMENTS</A></H1>
  1466. <P>Tim Bunce - for writing DBI and managing the DBI specification and the
  1467. DBD::Oracle driver.</P>
  1468. <P>
  1469. <HR>
  1470. <H1><A NAME="authors">AUTHORS</A></H1>
  1471. <P>Jonathan Leffler <<A HREF="mailto:johnl@informix.com">johnl@informix.com</A>>,
  1472. Jochen Wiedmann <<A HREF="mailto:joe@ispsoft.de">joe@ispsoft.de</A>>,
  1473. and Tim Bunce.</P>
  1474. <TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>
  1475. <TR><TD CLASS=block VALIGN=MIDDLE WIDTH=100% BGCOLOR="#cccccc">
  1476. <STRONG><P CLASS=block> DBI::DBD - DBD Driver Writer's Guide</P></STRONG>
  1477. </TD></TR>
  1478. </TABLE>
  1479.  
  1480. </BODY>
  1481.  
  1482. </HTML>
  1483.