mirror of
https://github.com/macintoshplus/doc-fr.git
synced 2026-03-24 08:52:09 +01:00
372 lines
9.0 KiB
XML
372 lines
9.0 KiB
XML
<?xml version="1.0" encoding="utf-8"?>
|
|
<!-- $Revision$ -->
|
|
<!-- EN-Revision: 5e41012cfdf8f2eff5fa56de446c7656afac536c Maintainer: yannick Status: ready -->
|
|
<!-- Reviewed: no -->
|
|
<chapter xml:id="oci8.examples" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
|
|
&reftitle.examples;
|
|
<para>
|
|
Ces exemples utilisent, pour se connecter à la base de données,
|
|
l'utilisateur <literal>HR</literal> qui est le schéma
|
|
<literal>"Human Resources"</literal> fourni par la
|
|
base de données Oracle. Ce compte doit avoir été déverrouillé et
|
|
le mot de passe réinitialisé avant de pouvoir l'utiliser.
|
|
</para>
|
|
|
|
<para>
|
|
Ces exemples se connectent à la base de données
|
|
<literal>XE</literal> de votre machine. Modifiez la chaîne de connexion
|
|
afin de correspondre à votre base de données avant d'exécuter les
|
|
exemples de cette documentation.
|
|
</para>
|
|
|
|
<example>
|
|
<title>Requête simple</title>
|
|
<para>
|
|
Cet exemple montre l'exécution d'une requête et l'affiche des résultats.
|
|
Les requêtes OCI8 utilisent les étapes préparation/exécution/récupération
|
|
des données.
|
|
</para>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
|
|
$conn = oci_connect('hr', 'welcome', 'localhost/XE');
|
|
if (!$conn) {
|
|
$e = oci_error();
|
|
trigger_error(htmlentities($e['message'], ENT_QUOTES), E_USER_ERROR);
|
|
}
|
|
|
|
// Préparation de la requête
|
|
$stid = oci_parse($conn, 'SELECT * FROM departments');
|
|
if (!$stid) {
|
|
$e = oci_error($conn);
|
|
trigger_error(htmlentities($e['message'], ENT_QUOTES), E_USER_ERROR);
|
|
}
|
|
|
|
// Exécution de la logique de la requête
|
|
$r = oci_execute($stid);
|
|
if (!$r) {
|
|
$e = oci_error($stid);
|
|
trigger_error(htmlentities($e['message'], ENT_QUOTES), E_USER_ERROR);
|
|
}
|
|
|
|
// Récupération des résultats de la requête
|
|
print "<table border='1'>\n";
|
|
while ($row = oci_fetch_array($stid, OCI_ASSOC+OCI_RETURN_NULLS)) {
|
|
print "<tr>\n";
|
|
foreach ($row as $item) {
|
|
print " <td>" . ($item !== null ? htmlentities($item, ENT_QUOTES) : "") . "</td>\n";
|
|
}
|
|
print "</tr>\n";
|
|
}
|
|
print "</table>\n";
|
|
|
|
oci_free_statement($stid);
|
|
oci_close($conn);
|
|
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
|
|
<example>
|
|
<title>Insertion de données en utilisant des variables liées</title>
|
|
<para>
|
|
Les variables liées augmentent les performances en permettant la réutilisation
|
|
du cache et du contexte d'exécution. Les variables liées augmentent également
|
|
la sécurité en prévenant bons nombres d'injection SQL.
|
|
</para>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
|
|
// Avant l'exécution, créez la table suivante :
|
|
// CREATE TABLE MYTABLE (mid NUMBER, myd VARCHAR2(20));
|
|
|
|
$conn = oci_connect('hr', 'welcome', 'localhost/XE');
|
|
if (!$conn) {
|
|
$e = oci_error();
|
|
trigger_error(htmlentities($e['message'], ENT_QUOTES), E_USER_ERROR);
|
|
}
|
|
|
|
$stid = oci_parse($conn, 'INSERT INTO MYTABLE (mid, myd) VALUES(:myid, :mydata)');
|
|
|
|
$id = 60;
|
|
$data = 'Some data';
|
|
|
|
oci_bind_by_name($stid, ':myid', $id);
|
|
oci_bind_by_name($stid, ':mydata', $data);
|
|
|
|
$r = oci_execute($stid); // exécution et validation
|
|
|
|
if ($r) {
|
|
print "Une ligne insérée";
|
|
}
|
|
|
|
oci_free_statement($stid);
|
|
oci_close($conn);
|
|
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
<example>
|
|
<title>Liage d'une clause WHERE d'une requête</title>
|
|
<para>
|
|
Ceci montre le liage simple.
|
|
</para>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
|
|
$conn = oci_connect("hr", "hrpwd", "localhost/XE");
|
|
if (!$conn) {
|
|
$m = oci_error();
|
|
trigger_error(htmlentities($m['message']), E_USER_ERROR);
|
|
}
|
|
|
|
$sql = 'SELECT last_name FROM employees WHERE department_id = :didbv ORDER BY last_name';
|
|
$stid = oci_parse($conn, $sql);
|
|
$didbv = 60;
|
|
oci_bind_by_name($stid, ':didbv', $didbv);
|
|
oci_execute($stid);
|
|
while (($row = oci_fetch_array($stid, OCI_ASSOC)) != false) {
|
|
echo $row['LAST_NAME'] ."<br>\n";
|
|
}
|
|
|
|
// Affiche :
|
|
// Austin
|
|
// Ernst
|
|
// Hunold
|
|
// Lorentz
|
|
// Pataballa
|
|
|
|
oci_free_statement($stid);
|
|
oci_close($conn);
|
|
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
|
|
<example>
|
|
<title>Insertion de données dans une colonne CLOB</title>
|
|
<para>
|
|
Pour de lourdes données, utilisez un objet binaire long (BLOB)
|
|
ou un objet de caractères long (CLOB). Cet exemple utilise les CLOB.
|
|
</para>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
|
|
// Avant l'exécution, créez la table suivante :
|
|
// CREATE TABLE MYTABLE (mykey NUMBER, myclob CLOB);
|
|
|
|
$conn = oci_connect('hr', 'welcome', 'localhost/XE');
|
|
if (!$conn) {
|
|
$e = oci_error();
|
|
trigger_error(htmlentities($e['message'], ENT_QUOTES), E_USER_ERROR);
|
|
}
|
|
|
|
$mykey = 12343; // clé arbitraire pour l'exemple
|
|
|
|
$sql = "INSERT INTO mytable (mykey, myclob)
|
|
VALUES (:mykey, EMPTY_CLOB())
|
|
RETURNING myclob INTO :myclob";
|
|
|
|
$stid = oci_parse($conn, $sql);
|
|
$clob = oci_new_descriptor($conn, OCI_D_LOB);
|
|
oci_bind_by_name($stid, ":mykey", $mykey, 5);
|
|
oci_bind_by_name($stid, ":myclob", $clob, -1, OCI_B_CLOB);
|
|
oci_execute($stid, OCI_NO_AUTO_COMMIT);
|
|
$clob->save("Une chaîne vraiment très longue");
|
|
|
|
oci_commit($conn);
|
|
|
|
// Récupération de données CLOB
|
|
|
|
$query = 'SELECT myclob FROM mytable WHERE mykey = :mykey';
|
|
|
|
$stid = oci_parse ($conn, $query);
|
|
oci_bind_by_name($stid, ":mykey", $mykey, 5);
|
|
oci_execute($stid);
|
|
|
|
print '<table border="1">';
|
|
while ($row = oci_fetch_array($stid, OCI_ASSOC+OCI_RETURN_LOBS)) {
|
|
print '<tr><td>'.$row['MYCLOB'].'</td></tr>';
|
|
// Dans une boucle, le fait de libérer la variable avantde récupérer la
|
|
// seconde ligne permet de réduire l'utilisation mémoire de PHP
|
|
unset($row);
|
|
}
|
|
print '</table>';
|
|
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
|
|
<example>
|
|
<title>Utilisation d'une procédure stockée PL/SQL</title>
|
|
<para>
|
|
Vous devez lier une variable pour la valeur retournée et, optionnellement,
|
|
pour tous les arguments de la fonction PL/SQL.
|
|
</para>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
|
|
/*
|
|
Avant d'exécuter le programme PHP, créez une fonction stockée
|
|
en langage SQL*Plus ou SQL Developer :
|
|
|
|
CREATE OR REPLACE FUNCTION myfunc(p IN NUMBER) RETURN NUMBER AS
|
|
BEGIN
|
|
RETURN p * 3;
|
|
END;
|
|
|
|
*/
|
|
|
|
$conn = oci_connect('hr', 'welcome', 'localhost/XE');
|
|
if (!$conn) {
|
|
$e = oci_error();
|
|
trigger_error(htmlentities($e['message'], ENT_QUOTES), E_USER_ERROR);
|
|
}
|
|
|
|
$p = 8;
|
|
|
|
$stid = oci_parse($conn, 'begin :r := myfunc(:p); end;');
|
|
oci_bind_by_name($stid, ':p', $p);
|
|
oci_bind_by_name($stid, ':r', $r, 40);
|
|
|
|
oci_execute($stid);
|
|
|
|
print "$r\n"; // Affiche 24
|
|
|
|
oci_free_statement($stid);
|
|
oci_close($conn);
|
|
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
|
|
<example>
|
|
<title>Utilisation d'une procédure stockée PL/SQL</title>
|
|
<para>
|
|
Avec les procédures stockées, vous devez lier les variables pour tous
|
|
les arguments.
|
|
</para>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
|
|
/*
|
|
Avant d'exécuter le programme PHP, créez une procédure stockée en
|
|
langage SQL*Plus ou SQL Developer :
|
|
|
|
CREATE OR REPLACE PROCEDURE myproc(p1 IN NUMBER, p2 OUT NUMBER) AS
|
|
BEGIN
|
|
p2 := p1 * 2;
|
|
END;
|
|
|
|
*/
|
|
|
|
$conn = oci_connect('hr', 'welcome', 'localhost/XE');
|
|
if (!$conn) {
|
|
$e = oci_error();
|
|
trigger_error(htmlentities($e['message'], ENT_QUOTES), E_USER_ERROR);
|
|
}
|
|
|
|
$p1 = 8;
|
|
|
|
$stid = oci_parse($conn, 'begin myproc(:p1, :p2); end;');
|
|
oci_bind_by_name($stid, ':p1', $p1);
|
|
oci_bind_by_name($stid, ':p2', $p2, 40);
|
|
|
|
oci_execute($stid);
|
|
|
|
print "$p2\n"; // affiche 16
|
|
|
|
oci_free_statement($stid);
|
|
oci_close($conn);
|
|
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
|
|
<example>
|
|
<title>Appel d'une fonction PL/SQL qui retourne un <literal>REF CURSOR</literal></title>
|
|
<para>
|
|
Chaque valeur retournée par la requête est un <literal>REF
|
|
CURSOR</literal> à utiliser pour récupérer les données.
|
|
</para>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
/*
|
|
Créez une fonction stockée PL/SQL comme ceci :
|
|
|
|
CREATE OR REPLACE FUNCTION myfunc(p1 IN NUMBER) RETURN SYS_REFCURSOR AS
|
|
rc SYS_REFCURSOR;
|
|
BEGIN
|
|
OPEN rc FOR SELECT city FROM locations WHERE ROWNUM < p1;
|
|
RETURN rc;
|
|
END;
|
|
*/
|
|
|
|
$conn = oci_connect('hr', 'welcome', 'localhost/XE');
|
|
|
|
$stid = oci_parse($conn, 'SELECT myfunc(5) AS mfrc FROM dual');
|
|
oci_execute($stid);
|
|
|
|
echo "<table border='1'>\n";
|
|
while (($row = oci_fetch_array($stid, OCI_ASSOC))) {
|
|
echo "<tr>\n";
|
|
$rc = $row['MFRC'];
|
|
oci_execute($rc); // La valeur de la colonne retournée depuis la requête est une référence de curseur
|
|
while (($rc_row = oci_fetch_array($rc, OCI_ASSOC))) {
|
|
echo " <td>" . $rc_row['CITY'] . "</td>\n";
|
|
}
|
|
oci_free_statement($rc);
|
|
echo "</tr>\n";
|
|
}
|
|
echo "</table>\n";
|
|
|
|
// Affiche :
|
|
// Beijing
|
|
// Bern
|
|
// Bombay
|
|
// Geneva
|
|
|
|
oci_free_statement($stid);
|
|
oci_close($conn);
|
|
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</chapter>
|
|
|
|
<!-- Keep this comment at the end of the file
|
|
Local variables:
|
|
mode: sgml
|
|
sgml-omittag:t
|
|
sgml-shorttag:t
|
|
sgml-minimize-attributes:nil
|
|
sgml-always-quote-attributes:t
|
|
sgml-indent-step:1
|
|
sgml-indent-data:t
|
|
indent-tabs-mode:nil
|
|
sgml-parent-document:nil
|
|
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
|
|
sgml-exposed-tags:nil
|
|
sgml-local-catalogs:nil
|
|
sgml-local-ecat-files:nil
|
|
End:
|
|
vim600: syn=xml fen fdm=syntax fdl=2 si
|
|
vim: et tw=78 syn=sgml
|
|
vi: ts=1 sw=1
|
|
-->
|
|
|