Capitolul IF.07. Crearea aplicatiilor in PHP IF.07.1

INFORMATICĂ*I* IF.07. Crearea aplicaţiilor în PHP

- 1 -

Capitolul IF.07. Crearea aplicatiilor in PHP

Cuvinte-cheie:

PHP, OCI8

IF.07.1. Generalități

Serverul Oracle XE poate fi accesat şi din aplicaţiile pentru Web. Deşi varianta clasică

presupune utilizarea serverului de baze de date MySQL, accesul la o bază de date Oracle XE este la

fel de simplu.

În cele ce urmează vor fi prezentate cunoştinţele necesare exploatării unei baze de date

Oracle presupunând că limbajul HTML este cunoscut.

Realizarea şi testarea în Windows a unei aplicaţii Web presupune existenţa pe calculator a

unui set de aplicaţii. Acestea pot fi descărcate de la adresa:

http://www.apachefriends.org/en/xampp-windows.html

Din multitudinea de variante oferite se va alege pachetul de aplicaţii XAMPP versiunea Lite.

Dacă s-a descărcat arhiva autoextractibilă (.exe), fişierul descărcat va fi mutat în directorul rădăcină

al unei partiţii şi lansat în execuţie pentru a se realiza dezarhivarea. După dezarhivare, partiţia

aleasă va conţine directorul xampp. Pornirea aplicaţiilor specifice din pachetul xampp se realizează

lansând în execuţie fişierul de comenzi xampp_start:

http://www.apachefriends.org/en/xampp-windows.html


- 2 -

Printre componentele din xampp lansate în execuţie prin executarea scriptului xampp_start

se găseşte şi serverul de Web Apache. Datorită faptului că acesta rulează pe calculatorul pe care

rulează şi aplicaţia de navigare în Internet folosită (Internet Explorer, Firefox, Google Chrome sau

oricare alta), adresele paginilor vor începe cu http://localhost/.

Testarea configuraţiei software disponibilă odată cu lansarea în execuţie a scriptului

xampp_start se realizează tastând în fereastra de navigare adresa http://localhost/index.php:

Dacă în fereastră se afişează pagina din imagine, se va selecta phpinfo(). În pagina afişată se

va căuta o secţiune legată de OCI8. OCI8 este extensia necesară accesului din linbajul PHP

(Hypertext Preprocessor) a unei baze de date Oracle.

http://localhost/


- 3 -

Dacă extensia nu apare se va edita fişierul \xampp\php\php.ini. Pentru a se încărca extensia

menţionată se va înlătura caracterul ';' din faţa liniei:

extension=php_oci8_11g.dll ; Use with Oracle 11gR2 Instant Client

După salvarea fişierului php.ini se reporneşte xampp (xampp_stop urmat de xampp_start).

IF.07.2. Limbajul PHP

PHP este un limbaj de programare destinat scrierii componentelor unei aplicaţii Web.

Limbajul PHP reprezintă o bună soluţie pentru scrierea scripturilor care prelucrează datele din

formulare sau pentru generarea automată a unor pagini Web folosind date păstrate pe server în baze

de date.

Limbajul PHP şi interpretorul de comenzi aferent sunt gratuite. Interpretorul de comenzi

este conţinut în pachetul de aplicaţii XAMPP şi este imediat disponibil, împreună cu celelalte

componente ale pachetului.

Un fişier conţinând cod scris în PHP poate conţine pe lângă secvenţele de cod şi marcaje

HTML cunoscute. Lansarea în execuţie a interpretorului PHP se realizează de către serverul de

Web (Apache, IIS etc.) dacă fişierul cerut de browser are extensia .php. Interpretorul va trimite

browserului atât codul HTML găsit în fişier cât şi rezultatele executării secvenţelor programate în

PHP.

Exemple:

1. Un script PHP minimal poate de exemplu trimite spre browser un şir de caractere.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html>

<head>

<title>Testare PHP</title>

<link rel="stylesheet" type="text/css" href="stil.css" />

</head>

<body>

<h2>Fisier continand cod PHP</h2>

<?php

echo "<p>Acest mesaj este afisat de <em>echo</em></p>";

?>

<p>Secventa programata s-a terminat. Acest cod este simplu HTML.</p>

</body>

</html>

Secvenţa scrisă se salvează într-un director accesibil serverului de Web. Dacă se testează

folosind XAMPP fişierul trebuie să fie plasat în directorul htdocs sau într-un director derivat din

acesta.


- 4 -

Pentru testare se va porni Internet Explorer sau o altă aplicaţie de navigare în Internet şi se

va tasta adresa fişierului în caseta de text destinată adreselor.

În fişier s-a evidenţiat secvenţa scrisă în PHP. Instrucţiunea echo realizează trimiterea spre

browser a şirului de caractere dat ca argument. Şirul de caractere este încadrat între ghilimele.

2. Un script PHP poate prelua şi prelucra datele introduse într-un formular conţinut într-o

pagină Web. În exemplul dat în continuare pagina greutate.html conţine un formular. Atributul

action din marcajul <form> face refinţă la scriptul PHP testphp2.php destinat prelucrării datelor din

formular.

greutate.html: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"


<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">

<head>

<title>Calculul greutatii</title>


</head>

<body>

<h2>Calculul greutatii in PHP</h2>

<p>Completati formularul si apasati butonul <em>Calcul</em></p>


- 5 -

<form action="testphp2.php" method="post">

<table>

<tr><td>Inaltimea [cm]: </td><td> <input type="text" name="inaltime" />

</td></tr>

<tr><td>Varsta [ani]: </td><td> <input type="text" name="varsta" />

</td></tr>

<tr><td colspan="2"><label>Femeie<input type="checkbox" name="sex"

value="f" /> </label></td></tr>

<tr><td colspan="2"><input type="submit" value="Calculeaza" /></td></tr>

</table>

</form>

</body>

</html>

testphp2.php:



<html>

<head>

<title>Calculul greutatii</title>


</head>

<body>

<h2>Calculul greutatii in PHP</h2>

<p>Greutatea Dv. ar trebui sa fie

<?php

$v = $_REQUEST["varsta"];

$h = $_REQUEST["inaltime"];

$s = $_REQUEST["sex"];

$g = 50 + ($h-150)*0.75+($v-20)*0.25;

if($s == "f")

$g = $g * 0.9;

echo "aproximativ $g";

?> kg.</p>

</body>

</html>

Spre deosebire de primul script PHP, în acest exemplu se operează cu câteva variabile: $v,

$h, $s, $g şi $_REQUEST. În PHP numele variabilelor încep cu caracterul '$'.


- 6 -

$_REQUEST este un şir care conţine valorile din câmpurile formularului asociat. Pentru a

extrage o valoare se foloseşte expresia $_REQUEST["camp"], în care camp este valoarea

proprietăţii name a controlului Windows a cărui valoare se preia.

Scriptul PHP se salvează în acelaşi director în care s-a salvat greutate.html.

Pentru testarea aplicaţiei se introduce adresa paginii greutate.html, se completează

formularul şi se apasă butonul Calculeaza.

Apăsarea butonului determină trimiterea spre serverul de Web a cererii de executare a

scriptului testphp2.php împreună cu un şir de caractere conţinând valorile din câmpurile

formularului. Serverul de Web (Apache) va lansa în execuţie interpretorul pentru PHP şi va trimite

acestuia scriptul solicitat. Comenzile echo din script vor realiza afişarea în fereastra browser-ului a

valorii calculate.

Notă: În cazul formularelor pentru care method="post", la apăsarea butonului de tip

submit aplicaţia de navigare trimite spre Internet cererea de executare a scriptului PHP după care

trimite scriptului un şir de caractere având structura:

numecontrol1=valoare1&numecontrol2=valoare2&numecontrol3=valoare3 ...


- 7 -

În cazul formularelor pentru care method="get", la apăsarea butonului de tip submit

aplicaţia de navigare trimite spre Internet o cerere având structura:

nume_script?numecontrol1=valoare1&numecontrol2=valoare2& ...

Scripturile PHP care extrag datele primite folosind şirul $_REQUEST, ca în exemplul dat,

se scriu la fel indiferent de modul de trimitere de către browser a parametrilor asupra cărora trebuie

să opereze. Astfel scriptul testphp2.php poate fi lansat în execuţie fără a folosi formularul din

greutate.html scriind în caseta de adrese a browser-ului :

http://localhost/prosperity/testphp2.php?varsta=34&inaltime=168&sex=f

Acest mod de scriere poate servi la lansarea în execuţie a unui ansamblu de scripturi

folosind în locul formularelor, simple referinţe (marcaje <a>):

Exemplu : <ul>

<li><a href="scriptphp1.php?opt=1">Calcul pentru optiunea 1</li>



- 8 -


</ul>

IF.07.2.1. Elementele de bază ale limbajului PHP

Variabile

În PHP numele unei variabile începe cu caracterul "$". Variabilele nu trebuie declarate în

prealabil. Crearea unei variabile şi stabilirea tipului acesteia se realizează automat, în momentul în

care acesteia i se atribuie o valoare. Unele variabile sunt create automat de interpretorul PHP, ca în

cazul scripturilor care prelucrează datele conţinute în formulare (variabila $_REQUEST).

În PHP variabilele pot fi de tip integer, double, string, boolean (logic) sau array (şir).

Exemple :

$a = "acesta este un sir de caractere"; // $a este un şir de caractere

$b = 3; // $b este un întreg

$c = 4.12; // $c este un nr. real, dublă precizie

$d = "2"; // $d este un şir de caractere

$e = $b + $d; // $e = 5, deci $d a fost tratat ca

// întreg.

$f = TRUE; // $f este o variabilă logică (boolean). Se poate scrie //

// cu majuscule sau normal.

$g = false; // idem.

$luni = array("ian", "feb", "mar", "apr"); // $luni este un şir

// de valori

Şiruri de caractere

Şirurile de caractere sunt delimitate prin caractere " (ghilimele). Dacă în şir există

ghilimele, caractere $ sau caractere \ (backslash), pentru a fi interpretate ca atare acestea vor fi

precedate de \.

Exemplu:

$a = 15;

$comandaSQL = "SELECT * FROM categorii WHERE id_categorie = $a";

Variabilele prezente în şiruri delimitate prin ghilimele vor fi înlocuite prin valoarea lor,

deci dacă $a=15 comanda SQL din secvenţa precedentă va fi:

$comandaSQL = "SELECT * FROM categorii WHERE id_categorie = 15";


- 9 -

Un şir poate fi delimitat şi prin caractere ' (apostrof) dar în acest caz variabilele incluse în

şir nu vor mai fi înlocuite prin valoarea lor.

Caracterul "." (punct) este în PHP operatorul de concatenare.

Exemplu:

<?php

$a=1;

$b=12;

echo '<li><a href=\"caut.php?id_art = '.$a.'&id_materie='.$b.'\"></li>';

. . .

?>

Şiruri de valori

Un şir poate fi declarat folosind funţia array():

$luni = array("ianuarie", "februarie", "martie", "aprilie");

$luni[4] = "mai";

$luni[5] = "iunie";

$luni[] = "iulie";

echo "Luna a doua este $luni[1].";

Deoarece primul element dintr-un şir are indicele 0, efectul comenzii echo va fi

imprimarea şirului "Luna a doua este februarie." Atribuirea $luni[] = "iulie"; este corectă,

elementul care va primi valoare fiind luni[6].

Şiruri asociative

Elementele dintr-un şir asociativ sunt perechi de forma (cheie => valoare).

Un script scris în PHP asociat unui formular primeşte într-un astfel de şir, denumit

$_REQUEST, valorile din câmpurile formularului. Scripturile PHP încep de obicei cu o secvenţă

de cod care preia într-un ansamblu de variabile locale valorile din şirul $_REQUEST.

Exemplu:

$eml = strip_tags($_REQUEST["e_mail"]);

Notă: Elementele aparţinând şirurilor asociative nu sunt înlocuite corect de către

interpretorul PHP dacă apar într-un şir delimitat prin ghilimele.

Exemplu:

$cda = "SELECT * FROM categ WHERE id_categ = $linie['id_cat']"; // Incorect!

Soluţia corectă:


- 10 -

$idc = $linie['id_cat'];

$comandaSQL = "SELECT * FROM categorii WHERE id_categorie = $idc";

Exemplu: Să se realizeze o aplicaţie care permite încărcarea unui fişier într-un director de

pe server.

Fişierul formpoze.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"


<html>

<head>

<title>Upload poze</title>

</head>

<body>

<h1>Incarc poze pe server</h1>

<form enctype="multipart/form-data" action="upld.php" method="post">

<table>

<tr>

<td>Categoria: </td>

<td><select name="categoria">

<option value="niciuna" selected>(Selectati categoria)

<option value="1">Austria

<option value="2">Franta

<option value="3">Elvetia

<option value="4">Ungaria

<option value="5">Grecia

</select>

</td>

</tr>

<tr>

<td>Selectati fisierul : </td>

<td><input type="file" name="fisier" /></td>

</tr>

<tr>

<td colspan="2"><input type="submit" value="Incarcare server"></td>

</tr>

</table>

</form>

</body>

</html>

Fişierul upld.php



<html>

<head>


</head>

<body>

<h1>Afisez informatii despre poza incarcata pe server</h1>

<?php

if ($_FILES["fisier "]["error"] > 0)

{

echo "Error: " . $_FILES["fisier "]["error"] . "<br />";

exit;


- 11 -

}

else

{

$categ = $_REQUEST["categoria"];

$nm = $_FILES["fisier"]["name"];

$nmtmp = $_FILES["fisier"]["tmp_name"];

echo "<p>Numele fisierului: $nm</p>";

echo "<p>Numele temporarului: $nmtmp</p>";

echo "<p>Categoria fisierului: $categ</p>";

$cale = "poze/$nm";

$rezultat = move_uploaded_file($nmtmp, $cale);

if (!$rezultat) {

echo "Eroare la incarcarea fisierului";

exit;

}

}

?>

</body>

</html>

Exemplu de utilizare a aplicaţiei:


- 12 -

Notă: Încărcarea unui fişier pe server se realizează în directorul pentru fişiere temporare

XAMPPLITE/tmp. Scriptul PHP asociat formularului de încărcare trebuie să mute fişierul din acest

director într-un director al aplicaţiei folosind funcţia PHP move_uploaded_file(). .

Accesul la caracteristicile fişierului se realizează prin intermediul matricii $_FILES.

$_FILES["nume_control"]["name"] numele original (pe calc. client)

$_FILES["nume_control"] ["tmp_name"] numele temporar (pe server)

$_FILES["nume_control"] ["type"] tipul fişierului

$_FILES["nume_control"] ["size"] mărimea în octeţi

$_FILES["nume_control"] ["error"] true dacă încărcarea nu a reuşit

Dat fiind faptul că numărul de fişiere care pot fi încărcate pe server poate fi mare, scriptul

ar trebui să se continue cu memorarea datelor fişierului într-o bază de date.

Funcţii PHP pentru testarea variabilelor

Rezultatul apelului unei astfel de funcţii poate fi "FALSE" (fals) sau "TRUE" (adevărat).

Funcţia isset($var) verifică dacă variabilei $var indicată ca argument i s-a atribuit deja

o valoare.

Funcţia empty($var) are valoarea "TRUE" (adevărat) dacă variabila indicată ca

argument este neiniţializată, este un şir de caractere de lungime 0 sau are valoarea

întreagă 0.

Exemplu:

if (empty($nume_client)) {

echo "Va rog sa completati numele dv.!";

exit;

}

Funcţiile is_int($var) , is_double($var), is_string($var),

is_array($var), şi is_bool($var) testează tipul variabilei indicate ca

argument.

Modificarea tipului variabilelor

Modificarea tipului unei variabile se poate face în 3 feluri:

1. Folosind operatori de transtipaj, ca în C: $a = 1;

$b = (string) $a;

Operatorii posibili sunt (integer), (double), (array) şi (string).

2. Folosind funcţia settype():


- 13 -

$a = 1;

settype($a, "string");

3. Folosind funcţiile intval(), doubleval() sau stringval(). Aceste funcţii nu modifică tipul

variabilei introduse ca argument dar returnează o valoare aparţinând tipului cerut:

$a = "12";

$b = intval($a) * 2;

IF.07.2.2. Instrucţiunile limbajului PHP

Instrucţiunea if

Ca şi în alte limbaje, instrucţiunea if are două forme: if (condiţie)

{

acţiuni pentru condiţie = adevărat (TRUE)

}

respectiv

if (condiţie)

{

acţiuni pentru condiţie = adevărat (TRUE)

}

else

{

acţiuni pentru condiţie = fals (FALSE)

}

Condiţia poate fi o expresie logică, scrisă folosind operatorii relaţionali uzuali: < <= >

>= == != (sau <>, diferit), respectiv && (dar şi and, operatorul şi), || (dar şi or, operatorul sau), !

(negaţie). Cele două variante de operatori logici "şi" respectiv "sau" diferă prin ordinea de evaluare

a operanzilor.

Ca şi în alte limbaje, condiţie poate fi o expresie aritmetică, o valoare 0 a acesteia fiind

interpretată ca fals (FALSE) iar o valoare diferită de 0 ca adevărat (TRUE).

Instrucţiunea if ... elseif

Ca şi în C, şi în PHP pot fi scrise construcţii de forma:

if (conditie_1)

{

Acţiuni pentru condiţie_1 = adevărat

} elseif (conditie_2)


- 14 -

{


} elseif (conditie_3)

{


} else {

Acţiuni pentru restul situaţiilor

}

Ultimul else poate lipsi.

Instrucţiunea switch ... case

Pentru cazul în care într-un program ramificarea depinde de valoarea unei variabile,

structura switch ... case este mai potrivită. Ea are sintaxa:

switch ($var)

{

case v1:

acţiuni;

break;

case v2:

acţiuni;

break;

case v3:

acţiuni;

break;

}

Exemplu:

switch ($submit)

{

case "insert":

// instructiuni pt. inserare in baza de date

break;

case "update":

// instructiuni pt. actualizarea bazei de date

case "display":

// instructiuni pt. imprimare

break;

}

Porţiunea din script din exemplu realizează o acţiune comandată prin apăsarea unui buton

de tip submit. În funcţie de butonul apăsat, valoarea transmisă scriptului diferă. În cazul "update"

instrucţiunea "break" lipseşte, deci după actualizare se va executa codul specific imprimării

($submit = "display").

Instrucţiunea while

Instrucţiunea while indică repetarea unei acţiuni atâta vreme cât o condiţie este adevărată.

Sintaxa instrucţiunii este:


- 15 -

while (condiţie)

{

acţiune

}

Exemple:

$comanda = "select nume, prenume from utilizatori";

$rezultat = mysql_query($comanda) or die(mysql_error());

while ($linie = mysql_fetch_array($rezultat))

{

echo $linie["nume"] . " " . $linie["prenume"] . "<br> \n";

}

Această structură de cod este specifică activităţii de preluare a informaţiilor dintr-o bază de

date.

Instrucţiunea do ... while

Instrucţiunea do ... while indică repetarea unei acţiuni atâta vreme cât o condiţie este

adevărată. Spre deosebire de while, condiţia este testată după executarea cel puţin o dată a acţiunii.


do

{

acţiune

}

while (condiţie);

Instrucţiunea for

Instrucţiunea for are sintaxa următoare:

for(exp1; exp2; exp3)

{

acţiune

}

Exemplu:

<html>

<?php

$factorial = 1;

for ($i=1; $i<7; $i++)

{

echo $i . " factorial = " . $factorial . "<br>\n";

$factorial *= $i; // atribuire combinata, ca în C.

}

?>

</html>

Instrucţiunea foreach


- 16 -

Instrucţiunea foreach se foloseşte exclusiv pentru prelucrarea elementelor şirurilor.


foreach ($nume_sir as $variabila)

{

acţiune pentru valoarea curenta

}

Exemplu:

$nume = array("Ion", "Maria", "George");

foreach ($nume as $membru)

{

echo "$membru este invitat la cina.<br>\n";

}

Instrucţiunile break şi continue

Ca şi în C, break întrerupe un ciclu sau un switch. Înstrucţiunea care urmează după break

este cea care urmează după instrucţiunea switch sau după ciclul care conţine break.

Instrucţiunea continue este folosită tot în interiorul ciclurilor şi comandă reluarea imediată

a ciclului întrerupând secvenţa de cod cuprinsă între locul în care continue este inserat şi sfârşitul

ciclului.

Exemplu:

<html>

<?php

$director = opendir ('c:/apache/htdocs/postuniv/');

echo "fisierele din directorul $director sunt:<br>\n";

while ($fisier = readdir ($director))

{

if (is_dir ($fisier)) { continue; }

echo "$fisier <br> \n";

}

closedir ($director);

?>

</html>

Funcţiile opendir() respectiv closedir() deschid respectiv închid un director iar funcţia

readdir() citeşte o intrare din acest director. Tipul intrării (fişier sau director) este testat prin apelul

funcţiei is_dir() şi în caz pozitiv, intrarea este ignorată (se execută instrucţiunea continue).

Instrucţiunea exit

Instrucţiunea exit opreşte imediat scriptul PHP. Acelaşi efect îl are funcţia die().

Exemplu:

die("Ati completat gresit formularul!");


- 17 -

IF.07.2.3. Funcţii

Într-o aplicaţie scrisă în PHP pot fi întâlnite două tipuri de funcţii: funcţii predefinite,

aparţinând limbajului şi funcţii definite de programator pentru a evita scrierea repetată a unor

secvenţe de cod sau pentru a uşura înţelegerea codului.

Definirea unei funcţii

Sintaxa unei funcţii scrise în PHP este următoarea:

function nume([listă_parametri])

{

corpul_funcţiei

[return expresie;]

}

Lista parametrilor transmişi unei funcţii poate lipsi. Dacă funcţia nu returnează nimic

(lipseşte instrucţiunea return) funcţia nu poate figura într-o expresie.

Exemplu:

function calcul ($a=0, $b=0)

{

$c = $a + $b;

return $c;

}

Includerea în lista de parametri a atribuirilor $a=0, $b=0 asigură valori iniţiale variabilelor

$a şi $b, în cazul în care apelul s-a realizat incorect (cu valori neiniţializate de exemplu). Apelul

funcţiei se poate face astfel:

$rez = calcul(12, 223);

Valoarea returnată de o funcţie poate aparţine oricărui tip: string, array, integer, double

etc.

Vizibilitatea variabilelor

Utilizarea funcţiilor pune şi în PHP probleme de vizibilitate a variabilelor. În PHP o

variabilă declarată în afara oricărei funcţii este o variabilă globală iar o variabilă declarată într-o

funcţie este o variabilă locală. Spre deosebire de alte limbaje, pentru a fi vizibile într-o funcţie

variabilele globale trebuie declarate folosind declaraţia global.

Exemplu:

function suma ($b)

{

global $a;

$c = $a + $b;


- 18 -

return $c;

}

$a = 100;

echo suma(12);

Funcţii predefinite

PHP este deosebit de bogat în funcţii. O listă completă poate fi găsită la adresa

http://www.php.net/manual.

Funcţii pentru prelucrarea şirurilor de caractere

În domeniul prelucrării şirurilor de caractere, PHP oferă o mare varietate de funcţii

predefinite, peste 70 la număr, ceea ce face posibilă realizarea în acest limbaj a celor mai multe

dintre prelucrările posibile în alte limbaje. Fiind orientat pe tratarea informaţiilor conţinute în

pagini web, PHP pune la dispoziţie şi o serie de funcţii specifice, deosebit de utile în practică.

explode() – realizează fragmentarea unui şir de caractere folosind separatorii coţinuţi într-un

alt şir. Rezultatul va fi un şir de elemente. Prototipul funcţiei este:

string[] explode(string separatori, string sir_de_prelucrat, limita)

Exemplu de utilizare:

$elemente = explode(',', $cumparaturi); // separatorul este virgula

foreach ($elemente as $articol)

{

. . . // prelucrez elementul curent, $articol

}

Parametrul limita este opţional. El are rolul de a permite limitarea numărului de elemente

din şirul creat.

strip_tags() – realizează înlăturarea dintr-un şir de caractere a tuturor marcajelor HTML sau

PHP, cu excepţia unora specificate în mod explicit. Prototipul funcţiei este:

string strip_tags (string sir [, string marcaje_permise]).

Funcţia permite înlăturarea pericolului includerii de către un utilizator într-o casetă de text

sau o zonă de text, a unor marcaje HTML sau scripturi PHP nedorite.

Exemplu de utilizare:

$sir_bun = strip_tags($sir, "<em><strong>");

addslashes() – modifică un şir de caractere dat adăugând caractere "\" (backslash) în faţa

unor caractere ca: " (ghilimele), ' (apostrof), \ (backslash). Prototipul funcţiei este:


- 19 -

string addslashes (string sir).

Funcţia este gândită să ajute la formarea şirurilor de caractere care sunt inserate în câmpuri

aparţinând unor tabele dintr-o bază de date, ca în exemplul următor:

$str1 = "let's see";

$str1 = addslashes($str1);

$rez = mysql_query("insert into continut (continut) values

('".$str1."')");

Şirurile de caractere provenind din câmpurile unui formular nu necesită o tratare folosind

această funcţie deoarece ele sunt în mod automat modificate şi transmise în acest fel.

stripslashes() – este funcţia opusă funcţiei addslashes(). Ea suprimă caracterele '\' adăugate

ca urmare a apelării funcţiei addslashes(). Prototipul funcţiei este:

string stripslashes (string sir).

str_replace() – realizează căutarea într-un şir de caractere a unui subşir şi înlocuirea sa cu

un alt şir. Prototipul funcţiei este:

string str_replace (string sir_cautat, string sir_substitutie, string

sir_de_prelucrat).

Exemplu:

$sir = "Cei patru evanghelisti erau trei";

$sir1 = str_replace("trei", "doi", $sir);

substr_replace() – permite înlocuirea unei secvenţe de caractere dintr-un şir cu un alt şir, dat

ca argument. Prototipul funcţiei este:

string substr_replace (string sir_de_prelucrat, string sir_substitutie, int start [, int lungime]).

Parametrii start şi lungime definesc poziţia în şirul de prelucrat respectiv lungimea

subşirului care va fi înlocuit. Dacă ultimul parametru lipseşte, vor fi înlocuite toate caracterele

rămase până la sfârşitul şirului.

Exemplu:

$sir = "Vara aceasta mergem in Turcia.";

$sir1 = substr_replace($sir, "Italia.", 23);

strcmp() – este funcţia de comparare a două şiruri. Prototipul funcţiei este:


- 20 -

int strcmp (string sir1, string sir2).

Funcţia returnează o valoare pozitivă dacă primul şir este mai mare, 0 dacă şirurile sunt

identice şi o valoare negativă dacă primul şir este mai mic.

strlen() – returnează lungimea şirului dat ca argument. Prototipul funcţiei este:

int strlen (string sir).

strpos() – furnizează poziţia şirului dat ca al doilea argument în şirul dat ca prim argument.

Prototipul funcţiei este:

int strpos (string sir_dat, string sir_cautat [, int offset]).

Funcţia returnează o valoare pozitivă dacă şirul este găsit şi FALSE dacă şirul căutat nu

există. Dacă parametrul offset este definit, acesta reprezintă poziţia în şirul dat de unde începe

căutarea.

Exemplu:

$sir = "Vara aceasta mergem la munte.";

$p = strpos($sir, " ");

Variabila $p va avea valoarea 4, deoarece pe poziţia 4 se află primul spaţiu.

strrpos() – operează asemănător cu strpos() dar funcţia va returna poziţia ultimei apariţii în

şirul dat a şirului dat ca al doilea argument. Prototipul funcţiei este:

int strrpos (string sir_dat, string sir_cautat).

substr() – returnează o porţiune dintr-un şir indicată prin două valori numerice. Prototipul

funcţiei este:

string substr (string sir_dat, int start [, int lungime]).

Dacă parametrul lungime lipseşte, subşirul returnat va conţine toate caracterele de la start

până la sfârşitul şirului.

Exemplu:

<?

$nume = "carte.pdf";

$lung = strrpos($nume, ".");

$pdf = substr ($nume, 0, $lung);

echo $pdf; // Va afisa "carte"

?>


- 21 -

strrev() – inversează ordinea caracterelor dintr-un şir dat. Prototipul funcţiei este:

string strrev (string sir_dat).

strtolower() – transformă toate majusculele din şirul dat în litere mici. Prototipul funcţiei

este:

string strtolower (string sir_dat).

strtoupper() – transformă toate literele din şirul dat în majuscule. Prototipul funcţiei este:

string strtoupper (string sir_dat).

strtr() – este o funcţie care permite înlocuirea în şirul dat ca prim argument a caracterelor

din şirul dat ca al doilea argument cu caracterele corespunzătoare din şirul dat ca al treilea

argument. Prototipul funcţiei este:

string strtr (string sir_dat, string de_inlocuit, string car_de_substitutie).

Exemplu:

$sir = "sir de caractere de tratat";

$sir1 = strtr($sir, "ca", "qw");

În exemplul dat, toate caracterele "c" vor fi înlocuite cu "q" şi toate caracterele "a" vor fi

înlocuite cu "w".

trim() – este o funcţie care înlătură toate spaţiile de la începutul şi sfârşitul şirului dat ca

argument, inclusiv caracterele return, LF (line feed) sau tab. Prototipul funcţiei este:

string trim (strin sir_dat).

Funcţii pentru accesarea unei baze de date

PHP dispune de funcţii care pot asigura exploatarea unui mare număr de servere de baze de

date. În cele ce urmează vor fi prezentate doar funcţiile care servesc la exploatarea unei baze de

date Oracle XE.

oci_connect() realizează o conexiune cu serverul Oracle XE. Prototipul funcţiei este:

int oci_connect (string schema, string parola, string adr_server).


- 22 -

De regulă apelul funcţiei oci_connect() este urmat de testarea valorii returnate de aceasta,

ca în exemplul următor:

$cnx = oci_connect('hr', 'welcome', 'localhost/XE');

if (!$cnx) {

$e = oci_error();

trigger_error(htmlentities($e['message'], ENT_QUOTES), E_USER_ERROR);

}

Variabila $cnx va servi în continuare la identificarea conexiunii astfel stabilite.

De regulă serverul de baze de date rulează pe acelaşi server pe care rulează serverul de

Web (Apache). Dacă serverul de baze de date Oracle XE rulează însă pe un alt calculator din reţea,

având de exemplu adresa bd.utcluj.ro, conectarea la aceeaşi bază de date ar putea fi realizată

scriind:

$cnx = oci_connect('hr', 'welcome', 'bd.utcluj.ro/XE');

if (!$cnx) {

$e = oci_error();


}

De cele mai multe ori scripturile PHP ale unei aplicaţii Web se conectează la o singură

bază de date. Programatorii îşi scriu atunci un fişier PHP care realizează conexiunea şi care va fi

ulterior inclus în toate scripturile aplicaţiei.

Exemplu:

<?php


if (!$cnx) {

$e = oci_error();


}

?>

Dacă scriptul scris s-a salvat cu numele conectare.php, inserarea sa în scripturile aplicaţiei

se realizează printr-o comandă include: <?php include "conectare.php"; ?>

oci_parse()– este funcţia cea mai frecvent utilizată când este exploatată o bază de date

Oracle. Prototipul funcţiei este :

oci_parse (int conexiune, string fraza_sql).

Această funcţie pregăteşte o comandă SQL (de obicei insert, select, delete sau update)

care va fi trimisă serverului Oracle XE prin apelul funcţiei oci_execute(). Funcţia oci_parse()

returnează o valoare care va fi folosită în continuare ca parametru în apelul funcţiei oci_execute().


- 23 -

oci_execute()– este o funcţie care realizează trimiterea spre serverul Oracle XE a unei

comenzi SQL, pregătită în prealabil prin apelul funcţiei oci_parse(). Prototipul funcţiei

este:

oci_execute (val_parse)

Dacă oci_parse a pregătit o comandă SQL select, rezultatul apelului oci_execute este

identificatorul unei mulţimi de selecţie, rândurile acesteia putând fi ulterior prelucrate folosind

oci_fetch_array().

Exemplu fundamental:

<?php


$stid = oci_parse($cnx, 'SELECT * FROM employees');

oci_execute($stid);

echo "<table border='1'>\n";

while ($linie = oci_fetch_array($stid, OCI_ASSOC+OCI_RETURN_NULLS)) {

echo "<tr>\n";

echo " <td>" . $linie['FIRST_NAME'] . "</td>\n <td>" .

$linie['LAST_NAME'] . "</td>\n";

echo "</tr>\n";

}

echo "</table>\n";

?>

Scriptul generează un tabel HTML conţinând două coloane:

Observaţie: De regulă se optează pentru o scriere uşor diferită a scriptului, cu inserarea la

fiecare apel al unei funcţii legate de accesul la baza de date a unei secvenţe de testare a reuşitei

executării funcţiei folosite.

<?php


if (!$cnx) {

$e = oci_error();


}


- 24 -

$stid = oci_parse($cnx, 'SELECT * FROM employees');

if (!$stid) {

$e = oci_error();


}

oci_execute($stid);

echo "<table border='1'>\n";

while ($linie = oci_fetch_array($stid, OCI_ASSOC+OCI_RETURN_NULLS)) {

echo "<tr>\n";

echo " <td>" . $linie['FIRST_NAME'] . "</td>\n <td>" .

$linie['LAST_NAME'] . "</td>\n";

echo "</tr>\n";

}

echo "</table>\n";

?>

Funcţiile prezentate permit şi realizarea inserării unui articol în baza de date.

Exemplu: Se doreşte realizarea unui formular şi a unui script PHP care realizează inserarea

unui articol în tabelul imagini. Structura acestuia este:

Pentru a nu putea avea mai multe fişiere cu acelaşi nume, fiecare fişier încărcat va fi

redenumit, noul nume fiind obţinut după formula ID_categorie + id_poza. Câmpul id_poza fiind

cheie primară, în acest mod se va obţine un nume unic. Valoarea câmpului id_poza se obţine

folosind secvenţa poze_seq.

formimagini.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"


<html>

<head>



- 25 -

</head>

<body>

<h1>Incarc poze pe server</h1>

<form enctype="multipart/form-data" action="upimagini.php" method="post">

<table>

<tr>

<td>Selectati tara: </td><td><select name="id_tara">

<option value="0" selected>(Selectati tara)

<option value="1">Austria

<option value="2">Elvetia

<option value="3">Franta

<option value="4">Germania

<option value="5">Grecia

<option value="6">Italia

<option value="7">Spania

<option value="8">Turcia

<option value="9">Ungaria

</select>

</td>

</tr>

<tr><td>Selectati fisierul : </td><td><input type="file" name="fisier"

/></td></tr>

<tr><td>Comentariu : </td><td><input type="text" name="comentariu"

maxlength="98" /></td></tr>

<tr><td colspan="2"><input type="submit" value="Incarcare server"></td></tr>

</table>

</form>

</body>

</html>

În controlul de tip select având numele id_tara s-au adăugat ţările din care provin pozele,

valorile introduse prin atributul value fiind valorile câmpului id_categorie.


- 26 -

upimagini.php <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"


<html>

<head>


</head>

<body>

<h1>Afisez informatii despre poza incarcata pe server</h1>

<?php

$cnx = oci_connect('test', 'testpass', 'localhost/XE');

if (!$cnx) {

$e = oci_error();

trigger_error(htmlentities($e['message'],

ENT_QUOTES), E_USER_ERROR);

exit;

}

if ($_FILES["fisier"]["error"] > 0)

{

echo "Eroare: " . $_FILES["fisier"]["error"] . "<br />";

exit;

}

else

{

$tara = $_REQUEST["id_tara"];

$coment = $_REQUEST["comentariu"];

$nm = $_FILES["fisier"]["name"];

$nmtmp = $_FILES["fisier"]["tmp_name"];

// Pregatesc valoarea cheii primare

$stid = oci_parse($cnx, 'SELECT poze_seq.NEXTVAL as ID FROM dual');

if (!$stid) {

$e = oci_error();



exit;

}

oci_execute($stid);

$linie = oci_fetch_array($stid, OCI_ASSOC+OCI_RETURN_NULLS);

// Val. cheii primare va fi $linie['ID'];

$nr = $linie['ID'];

// Redenumesc fisierul.

// Noul nume foloseste codul tarii si cheia primara

$numenou = (string)$tara."_".(string)$nr.".jpg";

$comanda = "insert into imagini values

($nr, '$numenou','$tara','$coment')";

$stid = oci_parse($cnx, $comanda);

if (!$stid) {

$e = oci_error();



exit;

}

oci_execute($stid);

$cale = "poze/".$numenou;

$rezultat = move_uploaded_file($nmtmp, $cale);

if ($rezultat)

echo "<p>Fisierul $nm a fost adaugat.</p>";

else {

echo "<p>Eroare la incarcarea fisierului</p>";

exit;

}


- 27 -

}

?>

</body>

</html>

Rezultatul încărcării pe server:

Notă: Încărcarea pe server poate eşua dacă fişierul este prea mare sau dacă directorul \poze

nu a fost creat în prealabil (derivat din din directorul în care sunt cele două fişiere ale aplicaţiei,

formimagini.html şi upimagini.php sau fişierul care conţine imaginea este de dimensiuni superioare

cele maxime admise, impusă în fişierul php.ini.

În varianta a doua valoarea $_FILES["fisier"]["error"] = 1 şi va trebui operată o

modificare în fişierul \xampp\php\php.ini:

; Maximum allowed size for uploaded files.

; http://php.net/upload-max-filesize

upload_max_filesize = 8M ; era 2M

oci_fetch_array()– permite preluarea unui rând dintr-o mulţime de selecţie realizată ca

urmare a unei interogări. Valorile sunt memorate într-un şir asociativ în care numele cheilor

coincid cu numele câmpurilor. Prototipul funcţiei este :

array mysql_fetch_array (int rezultat).

Exemplu:

Afişarea conţinutului unui tabel al bazei de date

tabtari.php



<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">

<head>

<title>Tabelul tari</title>

</head>

<body>

<h1>Afisez informatiile din tabelul <em>tari</em></h1>

<?php include "conectare.php"; ?>

<?php

$comanda = "select * from tari order by tara";

$rezultat = mysql_query ($comanda) or die(mysql_error());

echo "<table>";


- 28 -

while ($linie = mysql_fetch_array($rezultat))

{

echo "<tr>";

$tar = $linie["tara"];

$img = $linie["imagine_tara"];

echo "<td>$tar</td><td>$img</td>";

echo "</tr>";

}

echo "</table>";

?>

</body>

</html>

Rezultat:

oci_num_rows()– returnează numărul de linii dintr-o mulţime de selecţie creat ca urmare a

executării unei comenzi SQL select. Prototipul funcţiei este:

int mysql_num_rows (int rezultat).

Exemplu:

$query = "select * from utilizatori";

$rez = mysql_query($query) or die (mysql_error());

if (mysql_num_rows($rez) == 0)

{

echo "Tabelul utilizatori nu contine inregistrari";

} else {

// se prelucrează rezultatele

}

mysql_affected_rows()– returnează numărul de linii afectate de o comandă update, insert sau

delete. Prototipul funcţiei este:

int mysql_affected_rows ([int link]).


- 29 -

Exemplu:

$query = "delete from utilizatori where id_utilizator = $v";

$rez = mysql_query($query) or die (mysql_error());

$sterse = mysql_affected_rows();

if ($deleted == 0)

{

echo "Nimic nu s-a sters!";

} else {

echo "Ati sters $sterse linii din tabelul utilizatori.";

}

mysql_error() – afişează un mesaj care indică natura erorii care s-a produs în timpul

exectării unei comenzi SQL. Prototipul funcţiei sunt:

string mysql_error ( [int link] ).

Alte funcţii importante

date() – returnează data şi ora curentă. Prototipul ei este:

string date (string format [int timp])

Dacă este prezent al doilea argument, funcţia va forma din valoarea acestuia un şir de

caractere reprezentând o dată, conform formatului indicat ca prim argument.

Exemplu:

echo date("F d, Y g:i a");

poate imprima ceva de forma "May 12, 2002 19:21 pm".

Caracterele care pot fi folosite în şirul format sunt:

Indicator Semnificaţie

a am sau pm

A AM sau PM

d ziua din lună (01 la 31)

D ziua din săptămână, 3 litere, în engleză (ex. Fri)

F luna, text lung, engleză (ex. January)

g ora, 0, 1 ... 12

G ora, 0 la 24


- 30 -

h ora, 01, 02, ... 12

H ora, 01 ... 24

i minutul, 00 la 59

l (L mic) ziua din săptămână, text lung (ex. Friday)

m luna în cifre (01 la 12)

M luna, text 3 caractere (ex. Jan)

n luna, fără zerouri în faţa lunilor dintr-o cifră

s secunda, 00 la 59

S sufixul pt. numerale ordinale, engl. (ex. th, nd)

w ziua din săptămână, numeric, 0 la 6

Y anul, patru poziţii zecimale

z ziua din an, numeric, 0 la 365

mktime() – crează o dată. Prototipul ei este:

int mktime (int ora, int minutul, int secunda, int luna, int ziua, int anul)

Exemplu:

$anul = 2002;

$luna = 5;

$ziua = 25;

echo date ("l F d, Y", mktime(0,0,0, $luna, $ziua+30, $anul));

va imprima "Monday June 24, 2002". Funcţia permite calcule cu zile şi ore, ca în exemplu.

mail() – permite trimiterea unui e-mail dintr-un script. Prototipul ei este:

bool mail(string to, string subject, string message [, string additional_info]).

Exemplu:

$mesaj = "Comanda dv. a fost inregistrata si va fi tratata cu prioritate";

$adr = "[email protected]";

mail($adr, "Subject Confirmare", $mesaj,

"From: Internationnal Trade\r\nReply-to: [email protected]");

readfile() – realizează deschiderea unui fişier şi trimiterea direct spre browser.

Exemplu:

Trimiterea spre browser a unui fişier .txt:


- 31 -

<?php

echo "Continutul fisierului date.txt \n";

echo "<pre>";

readfile("date.txt");

echo "</pre>";

?>

Notă: Marcajul <pre> impune respectarea formatării textului din fişier, mai precis respectarea caracterelor "LF" (sfârşit de linie) conţinute în acesta. În lipsa acestui marcaj informaţia din fişierul date.txt va apărea pe linii de lungime impusă de browser.

header() – permite trimiterea unui antet. Antetul unei pagini web cuprinde un

ansamblu de informaţii având un format predefinit şi este trimis de serverul de web

browserului înaintea informaţiei propriu-zise. Antetul precizează, printre altele,

tipul de informaţii care vor urma să fie trimise în continuare. Parametrul din antet

care precizează natura informaţiilor care urmează să fie transmise în continuare este

"Content-type". Exemple:

o Content-type : text/html - fişier în format text sau html;

o Content-type : application/xhtml+xml - fişier în format .xhtml;

o Content-type : application/pdf - fişier în format .pdf;

o Content-type : image/jpeg - fişier în format .jpg;

o Content-type : image/png - fişier în format .png;

o Content-type : application/zip - fişier în format .zip

Exemplu:

<?php

header('Content-type: application/pdf');

header('Content-Disposition: inline; filename="articol.pdf"');

readfile('math12934.pdf');

?>

Observaţii: 1. Caracterele trimise de funcţia header() vor fi primele trimise spre browser.

Aceasta este o condiţie uneori dificil de verificat mai ales dacă înainte de apelul funcţiei header()

sunt inserate scripturi prin include() sau require() care ar putea conţine comenzi care trimit

informaţii spre browser. Practic se va verifica dacă există comenzi echo care s-ar putea executa

înaintea apelului funcţiei header().

2. Content-Disposition poate lua valorile inline sau attachement. În primul caz browserul va

încerca să afişeze fişierul în fereastra sa iar dacă tipul fişierului nu permite afişarea, va afişa ferestra

de dialog care permite salvarea acestuia pe disc. În cazul al doilea, se afişează direct fereastra de

dialog pentru salvarea pe disc a fişierului.


- 32 -

Exemple suplimentare:

1. Pagină web care apelează un script PHP în vederea transferului de pe server a un ui fişier

în format .pdf:

Dacă primul fişier este tot un script PHP, numele fişierului de afişat (carte14) poate proveni

dintr-un articol al unui tabel al unei baze de date.

2. Trimiterea unui fişier .gif:

<?php $file = 'monkey.gif'; if (file_exists($file)) { header('Content-Description: File Transfer'); header('Content-Type: application/octet-stream'); header('Content-Disposition: attachment; filename='.$file); header('Content-Transfer-Encoding: binary'); header('Expires: 0'); header('Cache-Control: must-revalidate, post-check=0, pre-check=0'); header('Pragma: public'); header('Content-Length: ' . filesize($file)); ob_clean();

<html> <head> <title>Afisez un fisier .pdf</title> </head> <body> Afiseaza <a href="pdf.php?afisez=carte14">cartea</a> </body> </html>

<?php

$pdf = $_REQUEST["afisez"].".pdf";

header('Content-type: application/pdf');

header('Content-Disposition: attachement; filename='.$pdf');

readfile($pdf);

?>


- 33 -

flush(); readfile($file); exit; } ?>

Notă: În acest ultim exemplu antetul trimis spre browser este complet, cu toate informaţiile

posibile.

SQLite Basics It’s easy to get up and running with SQLite. Its design eliminates the need for any configuration variables, such as a database server name or a database username and password. All you need is the name of a file where the data is stored: $db = sqlite_open('/www/support/users.db');

sqlite_query($db, 'CREATE TABLE users(username VARCHAR(100), password VARCHAR(100))');

This creates a users table stored in the database file located at /www/ support/users.db. When you try to open a database file that doesn’t already exist, SQLite automatically creates it for you; you don’t need to execute a special command to initialize a new database. If you cannot seem to get SQLite to work, make sure you have both read and write permission for the location on the filesystem where you’re trying

to create the database.

SQLite has even fewer data types than PHP—everything’s a string. While you can define a column as INTEGER, SQLite won’t complain if you then INSERT the string PHP into that column. This feature (the SQLite manual declares this a feature, not a bug) is unusual in a database, but PHP programmers frequently use this to their advantage in their scripts, so it’s not a completely crazy idea. A column’s type matters only when SQLite sorts its records (what comes first: 2 or 10?) and when you enforce UNIQUEness (0 and 0.0 are different strings, but the same integer). The table created in this example has two columns: username and password. The columns’ fields are all declared as VARCHARs because they’re supposed to hold text. Although it doesn’t really matter what type you declare your fields, it can be easier to remember what they’re supposed to hold if you give

them explicit types.

Inserting Data Add new rows to the database using INSERT and sqlite_db_query( ): $username = sqlite_escape_string($username); $password = sqlite_escape_string($password);

sqlite_query($db, "INSERT INTO users VALUES ('$username', '$password')");

You must call sqlite_escape_string( ) to avoid the usual set of problems with single quotes and other special characters. Otherwise, a password of abc'123 will cause a parser error. Don’t use addslashes( ) instead of sqlite_

escape_string( ), because the two functions are not equivalent.

Retrieving Data To retrieve data from an SQLite database, call sqlite_query( ) with your SELECT statement and iterate through the results: $r = sqlite_query($db, 'SELECT username FROM users');

while ($row = sqlite_fetch_array($r)) { // do something with $row }

By default, sqlite_fetch_array( ) returns an array with the fields indexed as both a numeric array and an associative array. For example, if this query


- 34 -

returned one row with a username of rasmus, the preceding code would print: Array ( [0] => rasmus

[username] => rasmus )

As you can see, sqlite_fetch_array( ) works like mysqli_fetch_array( ).

When you’re using user-entered data in a WHERE clause, in addition to calling sqlite_escape_string( ), you must filter out SQL wildcard characters. The easiest way to do this is with strtr( ): $username = sqlite_escape_string($_GET['username']); $username = strtr($username, array('_' => '\_', '%' => '\%')); $r = sqlite_query($db,

"SELECT * FROM users WHERE username LIKE '$username'");

Use sqlite_num_rows( ) to find the total number of rows returned by your query without iterating through the results and counting them yourself: $count = sqlite_num_rows($r);

You can call sqlite_num_rows( ) without retrieving the results from SQLite. Remember, this function takes the query result handle, like sqlite_fetch_

array( ). If speed is a concern, use sqlite_array_query( ). This retrieves all the data and puts it into an array in a single request: $r = sqlite_array_query($db, 'SELECT * FROM users'); foreach ($r as $row) { // do something with $row

}

However, if you have more than 50 rows and only need sequential access to the data, use sqlite_unbuffered_query( ): $r = sqlite_unbuffered_query($db, 'SELECT * FROM users'); while ($row = sqlite_fetch_array($r)) {

// do something with $row }

This is the most efficient way to print items in an XML feed or rows in an HTML table because the data flows directly from SQLite to your PHP script without any overhead tracking behind the scenes. However, you can’t use it with sqlite_num_row( ) or any function that needs to know the “current” location within the result set. When you are done with the connection, call sqlite_close( ) to clean up: sqlite_close($db);

Technically, this is not necessary, since PHP will clean up when your script finishes. However, if you open many SQLite connections, calling sqlite_

close( ) when you’re finished reduces memory usage.

SQLite Versus MySQL The SQLite function names are similar to the MySQL functions, but not

identical. Table 4-1 provides a side-by-side comparison of the two.

Table 4-1. Comparison of major MySQL and SQLite function names MySQL SQLite mysqli_connect( ) sqlite_connect( ) mysqli_close( ) sqlite_close( )

mysqli_query( ) sqlite_query( ) mysqli_fetch_row( ) sqlite_fetch_array( ) mysqli_fetch_assoc( ) sqlite_fetch_array( )

mysqli_num_rows( ) sqlite_num_rows( ) mysqli_insert_id( ) sqlite_last_insert_rowid( )

mysqli_real_escape_string( ) sqlite_escape_string( )

Alternate SQLite Result Types SQLite has many different functions for retrieving data. The ones you’ve already seen are not the only ones at your disposal, and you can control whether sqlite_fetch_array( ) returns numeric arrays, associative arrays, or both.


- 35 -

By default, when sqlite_fetch_array( ) returns data, it provides you with an array containing numeric and associative keys. This is a good thing, because it lets you refer to a column either by its position in the SELECT or by its name: $r = sqlite_query($db, 'SELECT username FROM users'); while ($row = sqlite_fetch_array($r)) { print "user: $row[username]\n"; // this line and...

print "user: $row[0]\n"; // this line are equivalent }

This is also a bad thing because it can catch you unawares. For example: $r = sqlite_query($db, 'SELECT * FROM users');

while ($row = sqlite_fetch_array($r)) { foreach ($row as $column) { print "$column\n"; // print each retrieved column

} }

This actually displays every column twice! First it prints the value stored in $row[0], and then it prints the same value referenced by its column name. If you have a generalized table-printing routine where you don’t know the number of fields in advance, you might fall prey to this bug. Additionally, if you retrieve a large dataset from SQLite, such as an entire web page or an image, then each result takes up twice as much memory

because there are two copies stashed in the array.

Therefore, SQLite query functions take an optional parameter that controls the results. Pass SQLITE_ASSOC for only column names, SQLITE_NUM for only column positions, and SQLITE_BOTH for the combination. These arguments are constants, not strings, so you do not place them in quotation marks. For example: // numeric

$row = sqlite_fetch_array($r, SQLITE_NUM); // associative $row = sqlite_fetch_array($r, SQLITE_ASSOC);

// both (the default value) $row = sqlite_fetch_array($r, SQLITE_BOTH);

SQLite returns column names in the same mixed case as you CREATEd them. This is not true of all databases. Some like to use all uppercase letters; others turn everything into lowercase. When porting applications from one of these databases to SQLite, use the sqlite.assoc_case configuration parameter to maintain compatibility without rewriting your code. The default value is 0, for mixed case; changing it to 1 turns the strings in your associative arrays to uppercase, whereas 2 sets them to lowercase. Modifying the column names slows down SQLite slightly, but PHP’s strtolower( ) is significantly

worse in this regard.

User-Defined Functions In addition to all the built-in SQL functions, such as lower( ) and upper( ), you can extend SQLite to include functions of your own written in PHP. These are known as user-defined functions, or UDFs for short. With a UDF, you embed logic into SQLite and avoid doing it yourself in PHP. This way, you take advantage of all the features inherent in a database, such as sorting

and finding distinct entries.

There are two types of UDFs: standard and aggregate. Standard UDFs are one-to-one: when given a single row of data, they return a single result. Functions that change case, calculate cryptographic hashes, and compute the sales tax on an item in a shopping cart are all standard functions. In contrast, aggregate functions are many-to-one: when using an aggregate function, SQLite passes it multiple rows and receives only a single value. Although it is not a UDF, the most popular aggregate function is count( ), which returns the number of rows passed to it. Besides count( ), most aggregate functions are related to statistics: finding the average, standard deviation,


- 36 -

or the maximum or minimum value of a set of data points.

Standard Functions UDFs are good for chopping up strings so you can perform nonstandard collations and groupings. For example, you want to sort through a list of URLs, maybe from a referrer log file, and create a list of unique hostnames sorted alphabetically. So, http://www.example.com/directory/index.html and http://www.example.com/page.html would both map to one entry: http:// www.example.com. To do this in PHP, you need to retrieve all the URLs, process them inside your script, and then sort them. Plus, somewhere in all that, you need to do the deduping. However, if it weren’t for that pesky URL-conversion process, this could all be done in SQL using the DISTINCT and ORDER BY keywords. With a UDF like the one shown in Example 4-3, you foist all that hard work

back onto SQLite where it belongs.

poate de exempluverifica dacă Astfel se va putea vor După lansarea în execuţie a aplicaţiilor din

xampp se va se va

Se verifică dacă modulul de extensie necesar accesului la serverul Oracle XE (OCI8) este accesibil. Pentru

aceasta se accesează pagina

http://localhost/xampp/index.php

pornind de la premisa cunoaşterii limbajului HTMLsoluţiile aspectele paeste o platformă

software destinată dezvoltării rapide a aplicaţiilor care accesează baze de date Oracle. Conceput ca

o aplicaţie web, APEX nu necesită instalarea unor componente software suplimentare, lucrul cu

platforma APEX realizându-se din fereastra unei aplicaţii de navigare în Internet (Internet Explorer,

Mozilla Firefox, Google Chrome etc.).

Platforma Oracle APEX este integrată în Oracle XE. O soluţie alternativă pentru testarea

platformei este conectarea la serviciol oferit de Oracle online accesând adresa

http://apex.oracle.com.

Accesul la platformă în Windows se poate realiza selectând succesiv Start / All Programs

/ Oracle Database 11g Express Edition / Get Started:

În fereastra aplicaţiei de navigare implicită a sistemului va fi încărcată o pagină de unde se

poate accesa platforma APEX (se selectează butonul Application Express).

http://localhost/xampp/index.php


- 37 -

IA.05.2. Tipurile de conturi specifice APEX

Contul de administrare a platformei

Conectarea la APEX în vederea realizării unor activităţi de administrare se realizează

folosind un cont care are drepturi de administrare asupra serverului Oracle (sau Oracle XE). Se

poate crea un cont special în acest scop dar la fel de bine este să se utilizeze system. După selectarea

butonului Application Express se va afişa o fereastră în care se va introduce contul de administrator

al platformei Oracle APEX:

Notă: Administratorul platformei nu poate crea aplicaţii. El poate doar defini spaţii de

lucru (eng. workspaces).

Contul de administrare a unui spaţiu de lucru (workspace)

Administratorul platformei (system de exemplu) poate defini spaţii de lucru (workspaces)

şi, implicit, conturi de administrare a acestora.

Exemplu de creare a unui nou spaţiu de lucru destinat creării de aplicaţii bazate pe schema

personal:


- 38 -

Noul spaţiu de lucru se va numi PERSONAL. În cazul selectării opţiunii Use Existing, ca

în imagine, numele se selectează folosind caseta combinată Database User şi va coincide cu numele

schemei (bazei de date) pe care se vor baza aplicaţiile create ulterior în cadrul noului spaţiu de

lucru.

Numele administratorului spaţiului de lucru din exemplul dat va fi PERS iar ultimele două

câmpuri vor servi la impunerea parolei care va fi utilizată de administratorul noului spaţiu de lucru.

Notă: Setările minimale pentru utilizatorul PERSONAL trebuie să permită platformei

APEX conectarea. Pentru a le impune se va folosi Oracle SQL Developer, astfel:

- se realizează o conexiune ca system şi se selectează Other Users / PERSONAL / Edit

User... :

Opţiunile contului PERSONAL se vor seta folosind opţiunile din fereastra de dialog afişată,

astfel:


- 39 -


- 40 -

Pentru a se realiza conectarea la noul spaţiu de lucru creat, în fereastra afişată după intrarea

în Application Express (ca system) se va selecta butonul Already have an acount?


- 41 -

Administratorul unui spaţiu de lucru (PERS de exemplu) este responsabil pentru

gestionarea acestuia. El poate creea în spaţiul administrat conturi (de dezvoltatori sau simpli

utilizatori) şi aplicaţii.

Contul de dezvoltator (developer)

O aplicaţie poate fi realizată de un singur dezvoltator sau de mai mulţi. În primul caz

dezvoltatorul poate fi chiar administratorul spaţiului de lucru. În al doilea caz însă este bine să se

creeze pentru fiecare dezvoltator câte un cont de dezvoltator.

Pentru a adăuga un cont de dezvoltator sau de simplu utilizator, administratorul spaţiului

de lucru (PERS în exemplul considerat) poate selecta Administration / Create Users and Groups.

În continuare se prezintă succesiunea de etape parcursă pentru crearea dezvoltatorului având numele

de utilizator mdamian:


- 42 -

Dezvoltatorii pot crea şi apoi accesa aplicaţiile din cadrul spaţiului lor de lucru dar nu se

pot conecta la alte spaţii de lucru.

Pentru dezvoltarea unei noi aplicaţii se va realiza conectarea la spaţiul de lucru

PERSONAL ca dezvoltator folosind noul cont.


- 43 -

Contul de utilizator simplu

Utilizatorii simpli sunt creaţi de administratorul unui spaţiu de lucru pentru a lucra cu

aplicaţiile existente în cadrul spaţiului. Crearea unui cont de utilizator al unui spaţiu de lucru se

realizează ca şi crearea unui developer selectând butonul radio corespunzător opţiunii No din

dreptul mesajului User is a developer. Un utilizator simplu nu va avea acces direct la spaţiul de

lucru şi la instrumentele disponibile în cadrul acestuia. Pentru a lucra cu o aplicaţie din cadrul

spaţiului de lucru, un utilizator simplu va tasta în caseta de adrese a ferestrei browser-ului un URL

conţinând adresa primei pagini a aplicaţiei în care va opera:

http://127.0.0.1:8080/apex/f?p=perso1:home În adresa din exemplu perso1 este numele aplicaţiei

iar home este numele dat primei pagini a acesteia.

IA.05.3. Dezvoltarea unei aplicaţii în APEX

Crearea aplicaţiei şi a paginii home

Pentru a crea o nouă aplicaţie folosind Oracle Application Express, din contul de

administrare a spaţiului de lucru sau dintr-un cont de dezvoltator se va selecta Application Builder /

Create.

Procesul de creare va fi realizat în cadrul unei aplicaţii-expert (wizard), în mai mulţi paşi.

http://127.0.0.1:8080/apex/f?p=perso1:home


- 44 -

În primul pas se selectează tipul aplicaţiei care va fi creată. Principial aplicaţia expret poate

crea două tipuri de aplicaţii.

Tipul Database se referă la aplicaţii obişnuite, de tip "desktop". Acestea presupun

definirea unui ansamblu de formulare şi rapoarte care pot fi accesate în urma unui

proces de autentificare.

Tipul Websheet se referă la aplicaţii web. Acestea constau dintr-un număr de pagini

web, unele dintre acestea conţinând regiuni create folosind date din baza de date. De

regulă accesarea informaţiei se realizează fără a fi necesară crearea în prealabil a

unui cont, cu excepţia unor pagini de administrare a bazei de date.

În cele ce urmează, având în vedere obiectivele cursului, va fi abordată doar prima

categorie de aplicaţii, deci în prima fereastră se va selecta varianta "Database" şi se va apăsa

butonul "Next>".

Ca punct de pornire a noii aplicaţii se va selecta "From Scratch" (creare de la zero) şi se va

apăsa "Next>"..


- 45 -

În pasul următor se va da aplicaţiei un nume şi un cod unic. De asemenea se va putea

impune domeniul din baza de date (schema) pe care se bazează aplicaţia. Deoarece la crearea

spaţiului de lucru s-a pornit de la un domeniu ("personal" în exemplul considerat) acesta va apărea

deja selectat.

În pasul următor se vor putea adăuga paginile (formulare şi rapoarte) care formează

aplicaţia. Deoarece acestea pot fi adăugate şi ulterior, pe măsura dezvoltării aplicaţiei, în această

etapă se poate adăuga doar prima pagină. Din multitudinea de variante oferită de interfaţa aplicaţiei

expert se alege "Blank". O astfel de pagină constă din unul sau mai multe blocuri html statice

conţinând informaţii generale despre aplicaţie şi autorii ei.

Paginii adăugate i se dă şi un nume ("Home" în exemplul considerat). Apoi se selectază

butonul "Add Page".


- 46 -

În pasul următor aplicaţia expert afişează o listă a formularelor având deocamdată un

singur element, Home. Se va selecta butonul "Next".

În fereastra afişată în continuare se impune dispunerea taburilor care vor fi folosite la

navigare. Pentru aplicaţii obişnuite se poate opta pentru varianta "One Level of Tabs".

În continuare se va selecta dacă aplicaţia curentă copiază elemente partajate definite în

cadrul unei alte aplicaţii. Varianta implicită este "No".


- 47 -

Următoarea fereastră permite stabilirea modului de autentificare a utilizatorilor aplicaţiei.

Varianta implicită este "Application Express". Aceasta presupune că aplicaţia va fi accesată doar de

utilizatori având conturi definite în cadrul spaţiului de lucru, dezvoltatori sau utilizatori simpli.

Există posibilitatea impunerii unui sistem de autentificare bazat pe utilizarea unui tabel de utilizatori

conţinut în baza de date, dar pentru aplicaţii obişnuite, având un număr redus şi relativ stabil de

utilizatori, varianta implicită este de regulă preferabilă.

Pentru aplicaţia din exemplu s-a acceptat această soluţie.

Tot în fereastra afişată se selectează şi formatul datei calendaristice.

În fereastra următoare se impune aspectul ferestrelor afişate de aplicaţie. Sunt oferite un

număr mare de variante, pentru aplicaţia din exemplu selectându-se varianta 1.


- 48 -

În ultima fereastră se afişează un rezumat al opţiunilor selectate. După selectarea butonului

"Create" aplicaţia este creată şi se poate începe dezvoltarea ei.


- 49 -

Observaţie: Aplicaţia conţine două formulare, cel creat, "Home", având codul 1 şi "Login",

având codul 101. Formularul "Login" a fost inclus deoarece am restricţionat accesul la aplicaţie la

utilizatorii declaraţi în cadrul spaţiului de lucru. Dacă nu s-ar fi restricţionat accesul aplicaţia ar fi

avut doar formularul creat, "Home".

În acest moment aplicaţia poate fi executată (butonul "Run Application").

La prima încercare de executare din APEX se va afişa formularul "Login". Datele care

trebuie introduse sunt cele ale unui cont din cadrul spaţiului de lucru.

Dinafara APEX, pentru a executa aplicaţia se va tasta în fereastra unui browser adresa:

http://127.0.0.1:8080/apex/f?p=101:1 (sau http://localhost:8080/apex/f?p=101:1)

Evident dacă serverul Oracle XE rulează pe un calculator din reţeaua Internet, adresele

trebuie adaptate. În locul adresei 127.0.0.1 se va folosi adresa IP a calculatorului respectiv.


- 50 -

Observaţie: Dacă utilizatorul a cărui nume şi parolă sunt furnizate este administratorul

spaţiului de lucru sau este un dezvoltator, în partea inferioară a ferestrei afişate va fi automat inclusă

o bară cu butoane care permit printre altele revenirea la aplicaţia selectată sau editarea paginii

curente.

În continuare vor fi adăugate şi configurate câteva dintre principalele tipuri de formulare şi

rapoarte necesare creării unei aplicaţii tipice.

IA.05.4. Crearea principalelor tipuri de formulare si rapoarte

a. Crearea unei pagini simple

Prima pagină existentă în aplicaţie este de tipul "Blank". Editarea ei va consta în

modificarea modului de acces (de la acces bazat pe autentificare la acces public) şi adăugarea unor

informaţii despre aplicaţie.

Pentru editarea unei pagini a aplicaţiei se selectează aplicaţia şi apoi pagina (cu un dublu

clic):

Rezultat:

dublu clic

dublu clic


- 51 -

Pentru modificarea unor proprietăţi generale legate de pagina selectată se selectează în

zona "Page Rendering" cu un dublu clic numele acesteia. În cazul paginii curente, "Home" se va

putea astfel accesa secţiunea "Security". Pentru a face pagina accesibilă fără autentificare se va

modifica "Authentication" în "Page Is Public".

După modificarea modului de acces se va selecta "Apply Changes" din partea de sus a

paginii cu proprietăţi afişate.

Observaţie: Suprimarea paginii curente se realizează selectând în acelaşi set de butoane

butonul "Delete".

Editarea regiunii implicite, adăugate la crearea paginii, se realizează selectând cu un dublu

clic regiunea.

dublu clic


- 52 -

În fereastra de editare a diferitelor proprietăţi se va interveni în secţiunile "Identification" şi

"Source"). În secţiunea "Identification" se va schimba numele secţiunii în "Aplicaţie pentru ..." iar

în secţiunea "Source" se vor adăuga informaţii despre aplicaţie. Pentru introducerea acestora se

poate folosi codificarea HTML. Astfel în exemplul dat s-au folosit marcajele <h1>, <p> şi <ol>.

Rezultat:

Observaţie: Se pot adăuga în pagină secţiuni suplimentare prin selectarea în meniul

contextual afişat la selectarea intrării "Regions" (dublu clic pentru afişare) a intrării "Create".


- 53 -

b. Crearea unui formular destinat inserării de date într-un tabel

Pentru adăugarea unui formular suplimentar în aplicaţia începută se va selecta aplicaţia şi

în şirul de butoane afişat se va selecta "Create Page >":

În prima fereastră afişată de aplicaţia-expert astfel iniţiată se selectează opţiunea "Form":


- 54 -

În fereastra următoare se selectează varianta "Form on a Table or View":

În ferestrele care se afişează în contiunuare se va selecta domeniul (schema)

"PERSONAL" şi tabelul în care se va opera ("ANGAJATI").


- 55 -

În fereastra următoare se defineşte identificatorul paginii (2), numele paginii ("Introducere

angajat"), se indică legarea paginii curente în şirul de legături denumit "Breadcrumb" (afişat în

partea superioară a paginii, sub bara cu taburi de navigare).

Dacă se selectează "Breadcrumb" aplicaţia expert afişează o fereastră suplimentară în care

se configurează modul de afişare a paginii curente în lista de legături. În exemplul considerat s-a

indicat afişarea legăturii spre pagina curentă după legătura spre prima pagină ("Home").

În pagina afişată în continuare se configurează lista de taburi destinate afişării diferitelor

pagini (formulare). Pentru formularul curent se va adăuga un tab în lista existentă purtând numele

"Adaugare angajat".

Breadcrumb


- 56 -

În următorii doi paşi se indică cheia primară a tabelului respectiv modul de generare a

valorilor acesteia ("Existing trigger"). Pentru ca opţiunea selectată să fie operaţională s-au adăugat

folosind Oracle SQL Developer două obiecte "sequence" şi două trigger-e care generează valorile

consecutive ale cheilor primare pentru tabelul "Angajaţi" respectiv "Copii" (vezi cap. 4).


- 57 -

În continuare se selectează câmpurile care vor apărea în formularul generat.

Fereastra afişată în continuare impune practic modul de funcţionare a formularului. Astfel

ascunzându-se butoanele "Save" şi "Delete", formularul nu va putea fi folosit decât la adăugarea de

noi angajaţi (butonul "Create", inscripţionat cu "Adăugare angajat"). Operatorul nu va putea deci

opera modificarea unor înregistrări din tabelul "Angajaţi".

Pe lângă butonul "Adăugare angajat" va mai fi afişat un buton de abandon ("Cancel",

inscripţionat cu "Abandon").

În continuare se va afişa o fereastră care permite impunerea ferestrei la care se merge după

apăsarea butoanelor. Indiferent de buton, prin configurarea realizată se va merge la pagina 1

("Home").


- 58 -

Ultima pagină afişată de aplicaţia expert de generare a formularului de inserare de

înregistrări în tabelul "Angajaţi" afişează o recapitulare a opţiunilor stabilite. La apăsarea butonului

"Finish" se va realiza crearea efectivă a formularului.

Rezultat:


- 59 -

Observaţie: Dacă se iniţiază editarea paginii (selectare cu dublu clic în lista de pagini) se

pot accesa şi reconfigura controalele Windows folosite la introducerea datelor.

Fereastra afişată permite modificarea tuturor parametrilor legaţi de controlul selectat, două

dintre acestea fiind prezentate în continuare.

- Numele câmpului ("P2_NUME") şi tipul controlului folosit ("Text Field");

- Eticheta afişată înaintea controlului ("Nume") şi cadrajul acesteia (dreapta).

dublu clic

dublu clic


- 60 -

Observaţie: Dacă sunt necesare modificări la toate controalele afişate se poate selecta în

arborele din zona "Page Rendering" opţiunea "Items / Edit All". Rezultatul este afişarea succintă, în

format tabelar, a principalelor caracteristici ale controalelor formularului.

c. Crearea unei pagini bazate pe o procedură memorată

Există situaţii în care controalele Windows dintr-un formular servesc la culegerea valorilor

unor parametri care apoi sunt transmişi unei proceduri memorate în bază. Un exemplu poate fi


- 61 -

cazul introducereii unor date într-un tabel al bazei doar dacă acestea îndeplinesc anumite condiţii

impuse.

Pentru exemplificarea modului de generare a acestui tip de formular se consideră

procedura AD_ANGAJAT, memorată în baza de date.

Pentru a uşura introducerea corectă a codului procedurii acesta este reluat în continuare:

create or replace

PROCEDURE "AD_ANGAJAT"

(

numeang in varchar2

, prenang in varchar2

) as

begin

insert into angajati (nume, prenume)

values (numeang, prenang);

end ad_angajat;

Procedura realizează adăugarea unui angajat în tabelul "Angajaţi" şi a fost creată folosind

Oracle SQL Developer.

Iniţierea generării noului formular se realizează ca şi în cazul precedent:


- 62 -

În ferestrele afişate în continuare se identifică procedura (schema "PERSONAL", numele

procedurii memorate în bază "AD_ANGAJAT"):

În continuare se defineşte numele paginii ("Angajat") şi se leagă pagina în lista de legături

"Breadcrumb", ca şi în exemplul anterior.


- 63 -

Pentru a fi accesibill, în lista de taburi a aplicaţiei se va adăuga în pasul următor o intrare

dedicată lansării noului formular:

În continuare se avansează cu "Next" până la pagina în care se impune locul în care se

merge după apăsarea butoanelor din noul formular. Ca şi în cazul formularului anterior, în ambele

cazuri se va indica pagina 1.

Aplicaţia expert va afişa în continuare parametrii de intrare în procedura utilizată. Se apasă

"Next".

În final se va afişa o recapitulare a opţiunilor introduse şi se poate genera formularul

(butonul "Finish").


- 64 -

d. Crearea şi utilizarea listelor de valori

În cadrul formularelor care folosesc controale cu listă este necesară pregătirea în prealabil

a listelor care vor fi folosite.

Listele pot fi statice sau dinamice. Diferenţa dintre ele este faptul că listele statice au

valori constante în timp ce listele dinamice sunt populate cu date preluate din baza de date folosind

o comandă SQL "SELECT".

În APEX listele de valori sunt incluse în categoria obiectelor partajate ("Shared

Components"). Pentru a crea o listă de valori, statică sau dinamică, se selectează "Shared

Components" şi apoi, în fereastra afişată se selectează "User Interface" / "Lists of Values".

HAREDPentru crearea unei


- 65 -

În fereastra afişată se selectează "Create".

Ca şi variantă se va selecta apoi "From Scratch":

Pentru realizarea formularului care va fi adăugat aplicaţiei va fi necesară o listă ordonată

cu angajaţii. Din acest motiv lista va fi numită "Angajati" şi va fi de tip "Dynamic".

În fereastra următoare se introduce comanda "SELECT" care va popula lista de valori.


- 66 -

Observaţie: Lista de valori va include două elemente, respectiv numele angajatului şi

identificatorul asociat acestuia ("ID_ANGAJAT"). Pentru obţinerea numelui angajatului s-a optat

pentru concatenarea a trei elemente: "nume || ' ' || prenume".

După selectarea butonului "Create List of Values" lista "Angajati" va fi creată.

Folosind lista creată se poate adăuga aplicaţiei un formular de introducere a copiilor

angajatiilor. Lista "Angajati" va fi folosită pentru a selecta angajatul care este părintele copilului

introdus în bază. Pentru angajatul selectat dorim însă introducerea în bază a identificatorului

acestuia ("ID_ANGAJAT"), aceasta fiind explicaţia prezenţei în comanda "SELECT" cu care s-a

populat lista a două câmpuri, al doilea fiind chiar "ID_ANGAJAT".

Demararea creării formularului va fi cea cunoscută: "Form" / "Form on a Table or View",

selectare domeniu ("PERSONAL"), selectare tabel ("COPII"). Numele formularului şi conectarea

lui în lista de legături sunt prezentate în figura de mai jos.


- 67 -

Ca şi câmpuri incluse în formular au fost selectate toate câmpurile afişate.

Butoanele din formular, implicit şi funcţiile formularului, au fost impuse ca şi în

formularul destinat introducerii unui nou angajat.

Rezultat:


- 68 -

Pentru utilizarea listei de valori "Angajati" în noul formular se iniţiază editarea noii pagini

şi se selectează cu un dublu clic în "Page Rendering" controlul "P3_ID_ANGAJAT".

În fereastra afişată se modifică următoarele:

în panoul "Name" se impune afişarea controlului ca "Popup List of Values";


- 69 -

în panoul "Label" se modifică "Id_Angajat" în "Parinte";

în panoul "List of Values" se selectează lista "ANGAJATI".

Rezultat:

În formular va fi selectat numele angajatului dar în comanda "INSERT" corespunzătoare

va fi inclus, desigur, "ID_Angajat".

Observaţie: Dacă lista de valori necesară populării unui control cu listă nu are informaţii

din bază ci este o listă statică, după selectarea tipului ("Static") şi introducerea numelui listei


- 70 -

aplicaţia expert de creare a acesteia va afişa un tabel cu două coloane. Pe coloana din stânga vor fi

introduse elementele care vor fi afişate în lista asociată controlului iar în coloana din dreapta

valorile transmise de controlul cu listă mai departe. De regulă acestea vor fi coduri, ca în exemplu,

sau vor coincide cu valorile de pe coloana din stânga.

e. Crearea formularelor bazate pe două tabele aflate în relaţie 1 la n

(formulare de tip "Master – Detail")

În cazul tabelelor aflate în relaţie 1 la n se pot crea formulare care să conţină două părţi: o

parte destinată selectării unei linii din tabelul părinte şi o parte destinată afişării în format tabelar a

informaţiilor asociate din tabelul copil.

În continuare se va realiza un astfel de formular. În panoul "Detail" el va afişa tabelar copii

unui angajat selectat în prealabil în panoul "Master".

După iniţierea creării formularului, în prima fereastră se selectează opţiunea "Form" şi apoi

în fereastra următoare "Master Detail Form".

În continuare se va defini tabelul "Master" şi se vor selecta câmpurile din acesta care vor fi

afişate în panoul corespunzător acestuia.


- 71 -

În fereastra următoare se defineşte tabelul asociat şi se selectează câmpurile care vor fi

afişate tabelar în panoul "Detail".

În continuare se indică modul de obţinere a cheilor primare pentru cele două tabele:


- 72 -

În fereastra afişată în continuare se stabileşte dispunerea tabelului din panoul "Detail". În

exemplul dat s-a optat pentru varianta implicită, respectiv dispunerea acestuia pe aceeaşi pagină cu

panoul "Master".


- 73 -

În fereastra următoare se configurează tabul aferent formularului.

În ultima fereastră aplicaţia expert va afişa o recapitulare a opţiunilor introduse. În final se

selectează butonul "Create".


- 74 -

Rezultat:

La selectarea tabului "Copii angajaţilor" se afişează o fereastră care permite selectarea

dintr-o listă a unui angajat.

După selectarea pictogramei din dreptul unui angajat, fereastra aplicaţiei va afişa

formularul propriuzis, având cele două panouri.


- 75 -

În prima pagină afişată se poate impune ordonarea angajaţilor după nume. Pentru aceasta

se editează pagina 4. Se selectează cu butonul drept al mouse-ului intrarea Angajati şi în meniul

contextual se selectează "Edit Report Attributes".

Aplicaţia va afişa într-un tabel câmpurile selectate, putând fi impuse diverse modificări.

Pentru impunerea sortării după nume se va selecta caseta de validare "Sort" şi se va indica faptul că

"NUME" este prima cheie de sortare.


- 76 -

Rezultat:

f. Crearea unui raport

Un raport este bazat de obicei pe o comandă SQL "SELECT". Pentru a genera un astfel de

raport se iniţiază adăugarea unei noi pagini aplicaţiei curente şi în prima fereastră afişată se

selectează "Report".

În fereastra următoare se selectează tipul de raport ("Classic Report").


- 77 -

În continuare se defineşte un tab a cărui selectare va genera raportul.

În fereastra următoare se introduce comanda SQL "SELECT" care va produce liniile

raportului.

În fereastra următoare se configurează raportul (aspect. număr de coloane, număr de linii

pe pagină) şi se impune exportarea sa în format CSV (Comma Separated Values, format acceptat de

Excel).


- 78 -

Ultima fereastră afişată conţine o recapitulare finală a opţiunilor impuse.

Rezultatul este realizarea raportului pe baza comenzii SQL date. În partea inferioară a

paginii apare referinţa "Imprima" a cărei selectare provoacă crearea fişierului "angajati.csv" care

poate fi deschis şi prelucrat în continuare în Excel.


- 79 -

g. Crearea unui raport pornind de la un formular simplu (Blank Page)

În APEX există posibilitatea realizării unor pagini având structuri complexe, adaptate unor

cerinţe neacoperite de variantele expuse de aplicaţia expert. Un exemplu este realizarea unei pagini

conţinând un raport al cărui conţinut depinde de elementul selectat dintr-un control de tip listă aflat

pe aceeaşi pagină.

Pentru crearea unei astfele de pagini în aplicaţia dezvoltată va fi adăugată o pagină goală

("Blank Page").

După adăugarea paginii se va adăuga o primă regiune. Pentru a opera mai uşor modificările

impuse pagina se va afişa selectând butonul "Component View".

Component View


- 80 -

Ca şi tip de regiune se poate alege "HTML Text".

În continuare se configurează regiunea adăugată. I se dă un titlu şi ca şi tip se selectează

"Button Region without Title", ca în imagine.


- 81 -

Pentru a adăuga controale Windows unei regiuni se va selecta "Create" din zon "Items". În

exemplul dat se va crea un control de tip "Select List" care se va adăuga regiunii "Selectare

Angajat". Numele dat controlului va fi "P33_selectare".


- 82 -

Pentru a provoca refacerea conţinutului raportului care va fi adăugat paginii, Pentru "Page

Action when Value Changed" se selectează "Submit Page".

În fereastra următoare se va selecta lista dinamică de valori cu care se populează lista

noului control. În aplicaţie există deja lista "Angajati" care este exact lista necesară.


- 83 -

În ultimul pas se crează elementul din pagină şi se testează pagina.

În continuare se va adăuga paginii o regiune nouă conţinând un raport. În comanda

SELECT utilizată la crearea mulţimii de selecţie a datelor din raport va interveni ca parametru

controlul "P33_SELECTARE" creat deja.


- 84 -

Ca tip de raport se alege fie "Interactive Report", fie "SQL Report".


- 85 -

În comanda scrisă intervine parametrul ":P33+SELECTARE". Valoarea acestuia este

chiar valoarea cheii primare corespunzătoare angajatului selectat, aşa cum s-a impus la crearea

acestei liste de valori.

Rezultat:


- 86 -

În regiunea "Buttons" se selectează "New Item".

Ca regiune în care să se afişeze noul buton se selectează "Selectare angajat".


- 87 -

În continuare se precizează numele butonului şi eticheta cu care va fi inscripţionat.

La apăsarea butonului se va realiza reîncărcarea paginii.


- 88 -

Efectul selectării butonului adăugat este reîncărcarea paginii curente. Pentru ca la

reîncărcare angajatul selectat în listă să fie următorul angajat trebuie adăugată o secvenţă de cod

PL/SQL care impune aceasta. Secvenţa de cod se adaugă astfel:

Pagina curentă fiind selectată, în regiunea "Processes" din panoul "Page Processing" se

selectează butonul "Create".

Ca tip de procers se selectează PL/SQL.

Se dă apoi procesului un numa şi se introduce codul PL/SQL corespunzător.


- 89 -

declare

CURSOR c1 IS SELECT * FROM angajati order by nume;

ang angajati%ROWTYPE; -- var. structurata de tip record

BEGIN

OPEN c1;

LOOP

FETCH c1 INTO ang; -- preia linia curenta in ANG

if c1%NOTFOUND THEN

exit;

else

if ang.id_angajat = :P33_selectare THEN

FETCH c1 INTO ang; -- preiau linia urmatoare

if c1%NOTFOUND THEN

exit;

else

:P33_selectare := ang.id_angajat;

exit;

end if;

end if;

end if;

END LOOP;

CLOSE c1;

end;

Secvenţa de cod este un bloc anonim PL/SQL care crează şi parcurge un cursor având un

conţinut similar listei de valori ANGAJATI. După găsirea angajatului selectat în lista ANGAJATI

se mai citeşte o linie din cursor şi se impune noua valoare ca valoare curentă în controlul cu listă.

După crearea procesului acesta trebuie editat deoarece execuţia sa trebuie condiţionată de

apăsarea butonului creat anterior.


- 90 -

Pentru butonul care realizează parcurgerea listei de angajaţi în sens invers, de la poziţia curentă spre

înapoi, codul PL/SQL poate fi următorul:

declare

CURSOR c1 IS SELECT * FROM angajati order by nume;

ang angajati%ROWTYPE; -- var. structurata de tip record

angurm angajati%ROWTYPE; -- var. structurata de tip record

BEGIN

OPEN c1;

FETCH c1 INTO ang; -- preia linia curenta in ANG

IF ang.id_angajat != :P33_selectare THEN

LOOP

FETCH c1 INTO angurm; -- preia linia curenta in ANGURM

if c1%NOTFOUND THEN

exit;

else

if angurm.id_angajat = :P33_selectare THEN

:P33_selectare := ang.id_angajat;

exit;

else


- 91 -

ang := angurm;

end if;

end if;

END LOOP;

end if;

CLOSE c1;

end;

IA.05.5. Aplicații

1. Verificaţi folosind SQL Developer dacă la Dv. utilizatorul BIBLIO are drepturile de acces

corect impuse şi creaţi în APEX spaţiul de lucru BIBLIO cu parola biblio definit peste

schema BIBLIO.

2. Creaţi o aplicaţie de administrare a schemei BIBLIO având un singur rând de taburi şi

paginile următoare:

a. O pagină denumită "Home" de tip "Blank" conţinând o singură regiune. În

regiunea inclusă tastaţi o descriere a aplicaţiei.

b. O pagină de tip "Form" / "Form on a Table or View" destinată editării datelor

din tabelului "Edituri".

c. O pagină de tip "Form" / "Form on a Table or View" destinată editării datelor

din tabelului "Autori".

d. O pagină de tip "Form" / "Form on a Table or View" destinată editării datelor

din tabelului "Cititori".

e. O pagină de tip "Form" / "Form on a Table or View" destinată editării datelor

din tabelului "Carti". Pentru introducerea codului editurii se va defini o listă de

valori de tip "Dynamic" (conţinând editurile în ordine alfabetică) şi se va

modifica tipul controlului Windows corespunzător din "Number Field" în

"Select List".

f. O pagină de tip "Form" / "Form on a Table or View" destinată editării datelor

din tabelul de legătură "Autcarti". Pentru a putea realiza selectarea valorilor din

două controale Windows cu listă se va defini o listă suplimentară de valori de tip

"Dynamic" care va conţine autorii în ordinea alfabetică, procedându-se apoi ca la

punctul precedent.

g. O pagină care va afişa cărţile de la o anumită editură. Pentru realizarea acesteia

se va porni de la un formular gol ("Blank Page") şi se vor adăuga două regiuni

destinate selectării editurii respectiv afişării cărţilor de la editura selectată.

3. Adăugaţi aplicaţiei Dv. alte pagini pe care le consideraţi necesare.

4. Adăugaţi spaţiului de lucru BIBLIO un utilizator simplu şi verificaţi modul de operare a

aplicaţiei în cazul conectării folosind noul cont.

Documents

Capitolul IF.07. Crearea aplicatiilor in PHP IF.07.1