cortesi         Thu Apr 11 13:14:56 2002 EDT

  Added files:                 
    /phpdoc/it/functions        fbsql.xml 
  Log:
  committing half done translation
  
  #everybody is fearing Hartmut these days
  
  

Index: phpdoc/it/functions/fbsql.xml
+++ phpdoc/it/functions/fbsql.xml
<?xml version="1.0" encoding="iso-8859-1"?>
<!-- EN-Revision: 1.38 Maintainer: calandra Status: working -->
 <reference id="ref.fbsql">
  <title>FrontBase Functions</title>
  <titleabbrev>FrontBase</titleabbrev>
  <partintro>
   <simpara>
    Queste funzioni permettono di accedere ai servers del database FrontBase. 
    Affinché queste funzioni siano disponibili è necessario compilare php con 
    il supporto fbsql usando l' opzione <option
    role="configure">--with-fbsql</option>.Se si usa questa opzione senza specificare 
    il percorso a fbsql, php cercherà le librerie client di fbsql nella cartella di 
default 
    specificata nell'istallazione di FrontBase, a seconda del sistema operativo. Se si 
installa 
    FrontBase in una cartella non standard è necessario specificare sempre 
    il percorso a fbsql: <option
    role="configure">--with-fbsql=/path/to/fbsql</option>.  In questo modo 
    si forzerà php ad usare le librerie client installate da FrontBase, 
    evitando ogni conflitto. 
   </simpara>
   <simpara>
    Maggiori informazioni su FrontBase: <ulink
    url="&url.fbsql;">&url.fbsql;</ulink>.
   </simpara>
   <simpara>
    Documentazione su FrontBase : <ulink
    url="&url.fbsql.docs;">&url.fbsql.docs;</ulink>.
   </simpara>
   <simpara>
    Il supporto Frontbase è stato aggiunto dal PHP 4.0.6.
   </simpara>
  </partintro>

  <refentry id="function.fbsql-affected-rows">
   <refnamediv>
    <refname>fbsql_affected_rows</refname> 
    <refpurpose>
     Ritorna il numero di righe (tuple) interessate nella precedente operazione di 
FrontBase.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>int</type><methodname>fbsql_affected_rows</methodname>
      <methodparam choice="opt"><type>int</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     <function>fbsql_affected_rows</function> restituisce il numero di 
     righe interessate dall'ultima query INSERT, UPDATE or DELETE associata 
     al parametro <parameter>link_identifier</parameter>. Se tale parametro non è 
stato specificato, 
     sarà usata l'ultima connessione aperta da 
     <function>fbsql_connect</function>.
    </para>
    <note>
     <para>
      Se si stanno usando le transazioni, è necessario chiamare la funzione 
      <function>fbsql_affected_rows</function> dopo una query INSERT, UPDATE, or 
DELETE, 
      non dopo la chiusura della transazione (commit).
     </para>
    </note>
    <para>
     Se l'ultima query è un istruzione DELETE senza clausola WHERE, 
     tutte le righe verranno cancellate dalla tabella e la funzione 
     restituirà il valore 0 (zero). 
    </para>
    <note>
     <para>
      Se si utilizza l'istruzione UPDATE, FrontBase non aggiornerà le 
      colonne in cui il valore nuovo è uguale a quello vecchio. Quindi esiste la 
possibilità 
      che <function>fbsql_affected_rows</function> sia diverso dal 
      numero di righe realmente interessate 
      dalla query.
     </para>
    </note>
    <para>
     Se l'ultima query fallisce la funzione restituisce -1.
    </para>
    <para>
     Vedere anche: <function>fbsql_num_rows</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-autocommit">
   <refnamediv>
    <refname>fbsql_autocommit</refname> 
    <refpurpose>Abilita o disabilita autocommit.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>bool</type><methodname>fbsql_autocommit</methodname>
      
<methodparam><type>resource</type><parameter>link_identifier</parameter></methodparam>
      <methodparam choice="opt"><type>bool</type><parameter>
        OnOff
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     <function>fbsql_autocommit</function> restituisce lo stato 
     corrente di autocommit .Se è stato specificato il parametro opzionale 
     OnOff , lo stato di autocommit verrà cambiato. Impostando il parametro 
     OnOff su &true; ogni istruzione verrà eseguita automaticamente, 
     in caso di assenza di errori. Impostandolo 
     su &false; l'utente dovrà eseguire la transazione richiamando 
     le funzioni <function>fbsql_commit</function> o
     <function>fbsql_rollback</function>.
    </para> 
    <para> Vedere anche:
     <function>fbsql_commit</function> and
     <function>fbsql_rollback</function>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-change-user">
   <refnamediv>
    <refname>fbsql_change_user</refname> 
    <refpurpose>
     Cambia l'identità dell'utente connesso con una connessione attiva.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>resource</type><methodname>fbsql_change_user</methodname>
      <methodparam><type>string</type><parameter>user</parameter></methodparam>
      <methodparam><type>string</type><parameter>password</parameter></methodparam>
      <methodparam choice="opt"><type>string</type><parameter>
        database
       </parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     <function>fbsql_change_user</function> Cambia l'identità dell'utente connesso 
     con una connessione attiva, o con la connessione specificata 
     dal parametro opzionale link_identifier. Se è stato specificato un 
     database, dopo che l'identità dell'utente sarà stata cambiata, 
     questo diventerà il database attivo . Se l'autorizzazione del 
     nuovo utente fallisce, rimarrà attiva l'identità dell'utente corrente.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-close">
   <refnamediv>
    <refname>fbsql_close</refname>
    <refpurpose>Chiude la connessione a FrontBase.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>boolean</type><methodname>fbsql_close</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier                   
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     Ritorna: &true; in caso di successo, &false; in caso di fallimento.
    </para>
    <para> 
     <function>fbsql_close</function> chiude la connessione al sever 
     FrontBase associata ad uno specificato link identifier. 
     Se il <parameter>link_identifier</parameter> non fosse specificato, verrebbe 
chiusa 
     l'ultima connessione aperta. 
    </para>
    <para>
     Non è sempre necessario usare <function>fbsql_close</function> nel caso di 
connessioni non permanenti, 
     esse verranno chiuse automaticamente alla fine dell'esecuzione 
     dello script.
    </para>
    <example>
     <title>Uso di <function>fbsql_close</function></title>
     <programlisting role="php">
<![CDATA[
<?php
    $link = fbsql_connect ("localhost", "_SYSTEM", "secret")
        or die ("Could not connect");
    print ("Connected successfully");
    fbsql_close ($link);
?>
]]>
     </programlisting>
    </example>
    <para> 
     Vedere anche: <function>fbsql_connect</function> e
     <function>fbsql_pconnect</function>.
    </para>
   </refsect1>
  </refentry>
  
  <refentry id="function.fbsql-commit">
   <refnamediv>
    <refname>fbsql_commit</refname>
    <refpurpose>Compie una transazione.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>bool</type><methodname>fbsql_commit</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     Ritorna: &true; in caso di successo, &false; in caso di fallimento.
    </para>
    <para> 
     <function>fbsql_commit</function> esegue la transazione 
     corrente scrivendo tutti gli aggiornamenti pendenti, cancella 
     il disco e sblocca tutte le righe della tabella bloccata dalla transazione. 
     Questo comando è necessario solo nel caso in cui autocommit fosse impostato su 
false. 
    </para>
    <para> Vedere anche:
     <function>fbsql_autocommit</function> e
     <function>fbsql_rollback</function>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-connect">
   <refnamediv>
    <refname>fbsql_connect</refname>
    <refpurpose>Apre una connessione al Server FrontBase.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>resource</type><methodname>fbsql_connect</methodname>
      <methodparam choice="opt"><type>string</type><parameter>
        hostname
        
       </parameter></methodparam>
      <methodparam choice="opt"><type>string</type><parameter>
        username
       </parameter></methodparam>
      <methodparam choice="opt"><type>string</type><parameter>
        password
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     Restituisce un valore di link_identifier positivo in 
     caso di successo, o un messaggio di errore in caso di fallimento. 
    </para>
    <para>
     <function>fbsql_connect</function> Apre una connessione 
     al Server FrontBase.Se i parametri opzionali non sono specificati verranno usati 
     i valori seguenti come default: <parameter>hostname</parameter> = '&null;',
     <parameter>username</parameter> = '_SYSTEM' e
     <parameter>password</parameter> = empty password.
    </para>
    <para>
     Se si richiamasse, una seconda volta, la funzione 
<function>fbsql_connect</function>
     con gli stessi argomenti, non si creerebbe una nuova 
     connessione,ma verrebbe restituito il valore di link_identifier 
     della connessione già aperta. 
    </para>
    <para>
     La connessione al server si chiuderà alla fine dello script, a meno che 
     non venga chiusa in anticipo richiamando esplicitamente la funzione 
     <function>fbsql_close</function>.
    </para>  
    <example>
     <title><function>fbsql_connect</function></title>
     <programlisting role="php">
<![CDATA[
<?php

    $link = fbsql_connect ("localhost", "_SYSTEM", "secret")
        or die ("Could not connect");
    print ("Connected successfully");
    fbsql_close ($link);

?>
]]>
     </programlisting>
    </example>
    <para> 
     Vedere anche
     <function>fbsql_pconnect</function> e
     <function>fbsql_close</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-create-db">
   <refnamediv>
    <refname>fbsql_create_db</refname>
    <refpurpose>Crea un database.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>bool</type><methodname>fbsql_create_db</methodname>
      <methodparam><type>string</type><parameter>database 
name</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     <function>fbsql_create_db</function> crea un nuovo database 
     FrontBase sul server, identificato dal parametro 
     link_identifier. 
    </para>
    <example>
     <title><function>fbsql_create_db</function></title>
     <programlisting role="php">
<![CDATA[
<?php
    $link = fbsql_pconnect ("localhost", "_SYSTEM", "secret")
        or die ("Could not connect");
    if (fbsql_create_db ("my_db")) {
        print("Database created successfully\n");
    } else {
        printf("Error creating database: %s\n", fbsql_error ());
    }
?>
]]>
     </programlisting>
    </example>
    <para> 
     Vedere anche <function>fbsql_drop_db</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-create-blob">
   <refnamediv>
    <refname>fbsql_create_blob</refname>
    <refpurpose>Create a BLOB</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>string</type><methodname>fbsql_create_blob</methodname>
      <methodparam><type>string</type><parameter>blob_data</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     Returns: A resource handle to the newly created blob.
    </para>
    <para> 
     <function>fbsql_create_blob</function> creates a blob from
     blob_data.  The returned resource handle can be used with insert
     and update commands to store the blob in the database.
    </para>
    <example>
     <title><function>fbsql_create_blob</function> example</title>
     <programlisting role="php">
<![CDATA[
<?php
    $link = fbsql_pconnect ("localhost", "_SYSTEM", "secret")
        or die ("Could not connect");
    $filename = "blobfile.bin";
    $fp = fopen($filename, "rb");
    $blobdata = fread($fp, filesize($filename));
    fclose($fp);
    
    $blobHandle = fbsql_create_blob($blobdata, $link);
    
    $sql = "INSERT INTO BLOB_TABLE (BLOB_COLUMN) VALUES ($blobHandle);";
    $rs = fbsql_query($sql, $link);
?>
]]>
     </programlisting>
    </example>
    <para>
     See also: <function>fbsql_create_clob</function>,
     <function>fbsql_read_blob</function>,
     <function>fbsql_read_clob</function>, and
     <function>fbsql_set_lob_mode</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-create-clob">
   <refnamediv>
    <refname>fbsql_create_clob</refname>
    <refpurpose>Create a CLOB</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>string</type><methodname>fbsql_create_clob</methodname>
      <methodparam><type>string</type><parameter>clob_data</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     Returns: A resource handle to the newly created CLOB.
    </para>
    <para> 
     <function>fbsql_create_clob</function> creates a clob from
     clob_data.  The returned resource handle can be used with insert
     and update commands to store the clob in the database.
    </para>
    <example>
     <title><function>fbsql_create_clob</function> example</title>
     <programlisting role="php">
<![CDATA[
<?php
    $link = fbsql_pconnect ("localhost", "_SYSTEM", "secret")
        or die ("Could not connect");
    $filename = "clob_file.txt";
    $fp = fopen($filename, "rb");
    $clobdata = fread($fp, filesize($filename));
    fclose($fp);
    
    $clobHandle = fbsql_create_clob($clobdata, $link);
    
    $sql = "INSERT INTO CLOB_TABLE (CLOB_COLUMN) VALUES ($clobHandle);";
    $rs = fbsql_query($sql, $link);
?>
]]>
     </programlisting>
    </example>
    <para>
     See also: <function>fbsql_create_blob</function>,
     <function>fbsql_read_blob</function>,
     <function>fbsql_read_clob</function>, and
     <function>fbsql_set_lob_mode</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-database-password">
   <refnamediv>
    <refname>fbsql_database_password</refname>
    <refpurpose>
     Imposta o ricerca la password di un database FrontBase.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>string</type><methodname>fbsql_database_password</methodname>
      
<methodparam><type>resource</type><parameter>link_identifier</parameter></methodparam>
      <methodparam choice="opt"><type>string</type><parameter>
        database_password
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     Restituisce: La password del database identificato dal parametro link_identifier. 
    </para>
    <para> 
     <function>fbsql_database_password</function> imposta e 
     ricerca la password del database corrente. Se 
     il secondo parametro, opzionale 
     (database_password),è stato specificato la funzione 
     imposta, sul server, il valore del parametro come password del 
     database identificato dal parametro link_identifier. Se il link_identifier 
     non è specificato, verrà utilizzata l'ultima connessione aperta. Se nessuna 
     connessione è aperta, la funzione tenterà di aprirne una come se la funzione 
     <function>fbsql_connect</function> fosse chiamata, e userà quella.
    </para>
    <para> 
     This function does not change the database password in the database
     nor can it be used to retrive the database password for a database.
    </para>
    <example>
     <title>Esempio di <function>fbsql_create_clob</function></title>
     <programlisting role="php">
<![CDATA[
<?php
    $link = fbsql_pconnect ("localhost", "_SYSTEM", "secret")
        or die ("Could not connect");
    fbsql_database_password($link, "secret db password");
    fbsql_select_db($database, $link);
?>
]]>
     </programlisting>
    </example>
    <para> 
     Vedere anche: <function>fbsql_connect</function>,
     <function>fbsql_pconnect</function> e
     <function>fbsql_select_db</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-data-seek">
   <refnamediv>
    <refname>fbsql_data_seek</refname>
    <refpurpose>Sposta il puntatore del risultato interno.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>bool</type><methodname>fbsql_data_seek</methodname>
      
<methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
      <methodparam><type>int</type><parameter>row_number</parameter></methodparam>
     </methodsynopsis>
    <para> 
     Restituisce: &true; in caso di successo, &false; in caso di fallimento.
    </para>
    <para> 
     <function>fbsql_data_seek</function> sposta il 
     puntatore interno al risultato FrontBase associato con 
     uno specificato indice in modo che punti ad un numero di riga 
     specificata . La chiamata successiva alla 
funzione<function>fbsql_fetch_row</function> restituirà la 
     riga richiesta. 
    </para>
    <para>
     <parameter>Row_number</parameter> comincia a contare da 0. 
    </para>
    <example>
     <title><function>fbsql_data_seek</function></title>
     <programlisting role="php">
<![CDATA[
<?php
    $link = fbsql_pconnect ("localhost", "_SYSTEM", "secret")
        or die ("Could not connect");

    fbsql_select_db ("samp_db")
        or die ("Could not select database");

    $query = "SELECT last_name, first_name FROM friends;";
    $result = fbsql_query ($query)
        or die ("Query failed");

    # fetch rows in reverse order

    for ($i = fbsql_num_rows ($result) - 1; $i >=0; $i--) {
        if (!fbsql_data_seek ($result, $i)) {
            printf ("Cannot seek to row %d\n", $i);
            continue;
        }

        if(!($row = fbsql_fetch_object ($result)))
            continue;

        printf("%s %s<BR>\n", $row->last_name, $row->first_name);
    }

    fbsql_free_result ($result);
?>
]]>
     </programlisting>
    </example>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-db-query">
   <refnamediv>
    <refname>fbsql_db_query</refname>
    <refpurpose>Manda una query FrontBase.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>resource</type><methodname>fbsql_db_query</methodname>
      <methodparam><type>string</type><parameter>database</parameter></methodparam>
      <methodparam><type>string</type><parameter>query</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     Restituisce: un indice FrontBase positivo come risultato della 
     query, o &false; in caso di errore. 
    </para>
    <para> 
     <function>fbsql_db_query</function> seleziona un database 
     ed esegue la query su di esso.Se il parametro 
     opzionale link_identifier non è stato specificato, 
     la funzione ne cercherà una già aperta nel FrontBase server, in caso non 
     ne trovasse alcuna aprirà una nuova connessione come se la funzione 
<function>fbsql_connect</function> 
     fosse chiamta senza argomenti. 
    </para>
    <para> 
     Vedere anche: <function>fbsql_connect</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-db-status">
   <refnamediv>
    <refname>fbsql_db_status</refname>
    <refpurpose>Ritorna lo stato di un dato database.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>int</type><methodname>fbsql_db_status</methodname>
      
<methodparam><type>string</type><parameter>database_name</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     Ritorna: Un valore intero con lo stato corrente.
    </para>
    <para> 
     <function>fbsql_db_status</function> richiede lo stato corrente del 
     database specificato da 
     <parameter>database_name</parameter>.  Se il 
     <parameter>link_identifier</parameter> viene omesso verrà usato quello 
     in uso. 
    </para>
    <para> 
     Il valore restituito potrà essere uno delle seguenti costanti: 
     <itemizedlist>
      <listitem>
       <simpara>
        &false; - L' exec handler del host era invalido. Questo errore si 
        presenta quando la connessione avviene direttamente al database, 
        tramite il link_identifier, usando un numero di porta. FBExec può 
        essere disponibile sul server ma nessuna connessione è stata creata.
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        FBSQL_UNKNOWN - Lo stato è sconosciuto.
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        FBSQL_STOPPED - Il database non è attivo. Usare  
        <function>fbsql_start_db</function> per attivare il database.
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        FBSQL_STARTING - Il database è in fase di attivazione.
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        FBSQL_RUNNING - Il database è attivo e può essere usato 
        per eseguire operazioni SQL. 
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        FBSQL_STOPPING - Il database é in fase di disattivazione.
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        FBSQL_NOEXEC - FBExec non è attivo sul server quindi non è 
        possibile conoscere lo stato del database. 
       </simpara>
      </listitem>
     </itemizedlist>
    </para>
    <para> 
     Vedere anche: <function>fbsql_start_db</function> e
     <function>fbsql_stop_db</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-drop-db">
   <refnamediv>
    <refname>fbsql_drop_db</refname>
    <refpurpose>Cancella un database FrontBase.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>bool</type><methodname>fbsql_drop_db</methodname>
      
<methodparam><type>string</type><parameter>database_name</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     Restituisce &true; in caso di successo, &false; in caso di fallimento.
    </para>  
    <para> 
     <function>fbsql_drop_db</function> procede con l'eliminazione 
     di un intero database dal server associato 
     all'identificatore di link. 
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-errno">
   <refnamediv>
    <refname>fbsql_errno</refname> 
    <refpurpose>
     Ritorna il valore numerico del messaggio 
     di errore emesso dalla precedente operazione FrontBase.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>int</type><methodname>fbsql_errno</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     Restituisce il numero di errore dell'ultima funzione fbsql, 
     <literal>0</literal> (zero) se non ci sono stati errori. 
    </para>
    <para>
     Gli errori vengono restituiti dal database fbsql senza visualizzare i warnings. 
     Usare <function>fbsql_errno</function> per ricevere codice dell'errore. 
     Da notare che questa funzione restituisce solamente il codice di 
     errore proveniente dalla più recente esecuzione di una funzione fbsql 
     (escludendo  <function>fbsql_error</function> e
     <function>fbsql_errno</function>),così se si vuole usarla, assicurarsi 
     di controllare il valore prima di richiamare un'altra funzione fbsql. 
     <informalexample>
      <programlisting role="php">
<![CDATA[
<?php
fbsql_connect("marliesle");
echo fbsql_errno().": ".fbsql_error()."<BR>";
fbsql_select_db("nonexistentdb");
echo fbsql_errno().": ".fbsql_error()."<BR>";
$conn = fbsql_query("SELECT * FROM nonexistenttable;");
echo fbsql_errno().": ".fbsql_error()."<BR>";
?>
]]>
      </programlisting>
     </informalexample>
    </para>
    <para> 
     Vedere anche: <function>fbsql_error</function> e 
     <function>fbsql_warnings</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-error">
   <refnamediv>
    <refname>fbsql_error</refname>
    <refpurpose>
     Ritorna il testo del messaggio di errore emesso dalla precedente operazione 
     FrontBase.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>string</type><methodname>fbsql_error</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     Restituisce il testo del messaggio di errore dell'ultima funzione fbsql, o  
     <literal>''</literal> (una stringa vuota) se non ci sono stati errori. 
    </para>
    <para>
     Gli errori vengono restituiti dal database fbsql senza visualizzare i warnings. 
     Usare <function>fbsql_errno</function> per ricevere codice dell'errore. 
     Da notare che questa funzione restituisce solamente il codice di 
     errore proveniente dalla più recente esecuzione di una funzione fbsql 
     (escludendo  <function>fbsql_error</function> e
     <function>fbsql_errno</function>),così se si vuole usarla, assicurarsi 
     di controllare il valore prima di richiamare un'altra funzione fbsql. 
     <informalexample>
      <programlisting role="php">
<![CDATA[
<?php
fbsql_connect("marliesle");
echo fbsql_errno().": ".fbsql_error()."<BR>";
fbsql_select_db("nonexistentdb");
echo fbsql_errno().": ".fbsql_error()."<BR>";
$conn = fbsql_query("SELECT * FROM nonexistenttable;");
echo fbsql_errno().": ".fbsql_error()."<BR>";
?>
]]>
      </programlisting>
     </informalexample>
    </para>
    <para> 
     Vedere anche: <function>fbsql_errno</function> e
     <function>fbsql_warnings</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-fetch-array">
   <refnamediv>
    <refname>fbsql_fetch_array</refname> 
    <refpurpose>
     Restituisce una riga (tupla) di risultato in forma di Array associativo, Array 
enumerato o 
     entrambi.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>array</type><methodname>fbsql_fetch_array</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>
        result_type
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     Restituisce un array che corrisponde alla riga di risultato, o &false;
     se non ci sono righe successive.
    </para>
    <para>
     <function>fbsql_fetch_array</function> è una versione estesa di 
     <function>fbsql_fetch_row</function>.  In aggiunta all'inserimento dei 
     dati negli elementi dell'array con indice numerico, li inserisce anche in 
     indici associativi, usando il nome dei campi come chiavi.
    </para>
    <para>
     Se due o più colonne di risultato hanno lo stesso nome di campo , 
     l'ultima colonna sovrascriverà la precedente con lo stesso nome. Per 
     accedere alle altre colonne con lo stesso nome si deve usare l'indice 
     numerico oppure fare un alias della colonna . 
     <informalexample>
      <programlisting>
<![CDATA[
select t1.f1 as foo t2.f1 as bar from t1, t2
]]>
      </programlisting>
     </informalexample>
    </para>
    <para>
     Una cosa importante da notare è che 
     <function>fbsql_fetch_array</function> NON è singnificativamente 
     più lenta di <function>fbsql_fetch_row</function>, mentre fornisce un 
significativo 
     valore aggiunto.
    </para>
    <para>
     Il secondo parametro opzionale, <parameter>result_type</parameter>
     in <function>fbsql_fetch_array</function> è una costante che può 
     assumere i seguenti valori: FBSQL_ASSOC, FBSQL_NUM, 
     and FBSQL_BOTH. 
    </para>
    <para>
     Per ulteriori dettagli vedere anche
     <function>fbsql_fetch_row</function> e
     <function>fbsql_fetch_assoc</function>.
    </para>
    <example>
     <title><function>fbsql_fetch_array</function></title>
     <programlisting role="php">
<![CDATA[
<?php 
fbsql_connect ($host, $user, $password);
$result = fbsql_db_query ("database","select user_id, fullname from table");
while ($row = fbsql_fetch_array ($result)) {
    echo "user_id: ".$row["user_id"]."<br>\n";
    echo "user_id: ".$row[0]."<br>\n";
    echo "fullname: ".$row["fullname"]."<br>\n";
    echo "fullname: ".$row[1]."<br>\n";
}
fbsql_free_result ($result);
?>
]]>
     </programlisting>
    </example>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-fetch-assoc">
   <refnamediv>
    <refname>fbsql_fetch_assoc</refname> 
    <refpurpose>
     Restituisce una riga (tupla) di risultato in forma di Array associativo.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>array</type><methodname>fbsql_fetch_assoc</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
     </methodsynopsis>
    <para> 
     Restituisce un array associativo corrispondente alla riga di risultato, 
     o &false; se non ci sono righe successive.</para>
    <para>
     <function>fbsql_fetch_assoc</function> è equivalente ad una chiamata a 
     <function>fbsql_fetch_array</function> con FBSQL_ASSOC come parametro opzionale. 
     Restituirà solo un array associativo. 
     <function>fbsql_fetch_array</function> originariamente lavora in questo modo. 
     Se si vuole un indice numerico come pure 
     quello associativo, usare <function>fbsql_fetch_array</function>.
    </para>
    <para>
     Se due o più colonne di risultato hanno lo stesso nome di campo , 
     l'ultima colonna sovrascriverà la precedente con lo stesso nome. Per accedere 
alle 
     altre colonne con lo stesso nome si deve usare 
<function>fbsql_fetch_array</function> che 
     ritorna un indice numerico.
    </para>
    <para>
     Una cosa importante da notare è che
     <function>fbsql_fetch_assoc</function> NON è singnificativamente più lenta di 
     <function>fbsql_fetch_row</function>, mentre fornisce un significativo 
     valore aggiunto. 
    </para>
    <para>
     Per maggiori dettagli, vedi anche 
     <function>fbsql_fetch_row</function> e
     <function>fbsql_fetch_array</function>.
    </para>
    <example>
     <title><function>fbsql_fetch_assoc</function></title>
     <programlisting role="php">
<![CDATA[
<?php 
fbsql_connect ($host, $user, $password);
$result = fbsql_db_query ("database","select * from table");
while ($row = fbsql_fetch_assoc ($result)) {
    echo $row["user_id"];
    echo $row["fullname"];
}
fbsql_free_result ($result);
?>
]]>
     </programlisting>
    </example>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-fetch-field">
   <refnamediv>
    <refname>fbsql_fetch_field</refname>
    <refpurpose>
     Get column information from a result and return as an object
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>object</type><methodname>fbsql_fetch_field</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>
        field_offset
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     Returns an object containing field information.
    </para>  
    <para>
     <function>fbsql_fetch_field</function> can be used in order to
     obtain information about fields in a certain query result.  If
     the field offset isn't specified, the next field that wasn't yet
     retrieved by <function>fbsql_fetch_field</function> is retrieved.
    </para>
    <para>
     The properties of the object are:
     <itemizedlist>
      <listitem>
       <simpara>
        name - column name
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        table - name of the table the column belongs to
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        max_length - maximum length of the column
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        not_null - 1 if the column cannot be &null;
       </simpara>
      </listitem> 
      <listitem>
       <simpara>
        type - the type of the column
       </simpara>
      </listitem>
     </itemizedlist>
    </para>
    <example>
     <title><function>fbsql_fetch_field</function> example</title>
     <programlisting role="php">
<![CDATA[
<?php 
fbsql_connect ($host, $user, $password)
    or die ("Could not connect");
$result = fbsql_db_query ("database", "select * from table")
    or die ("Query failed");
# get column metadata
$i = 0;
while ($i < fbsql_num_fields ($result)) {
    echo "Information for column $i:<BR>\n";
    $meta = fbsql_fetch_field ($result);
    if (!$meta) {
        echo "No information available<BR>\n";
    }
    echo "<PRE>
max_length:   $meta->max_length
name:         $meta->name
not_null:     $meta->not_null
table:        $meta->table
type:         $meta->type
</PRE>";
    $i++;
}
fbsql_free_result ($result);
?>
]]>
     </programlisting>
    </example>
    <para>
     See also <function>fbsql_field_seek</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-fetch-lengths">
   <refnamediv>
    <refname>fbsql_fetch_lengths</refname> 
    <refpurpose>
     Get the length of each output in a result
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>array</type><methodname>fbsql_fetch_lengths</methodname>
      <methodparam 
choice="opt"><type>resource</type><parameter>result</parameter></methodparam>
     </methodsynopsis>
    <para> 
     Returns: An array that corresponds to the lengths of each field
     in the last row fetched by <function>fbsql_fetch_row</function>,
     or &false; on error.
    </para>  
    <para>
     <function>fbsql_fetch_lengths</function> stores the lengths of
     each result column in the last row returned by
     <function>fbsql_fetch_row</function>,
     <function>fbsql_fetch_array</function> and
     <function>fbsql_fetch_object</function> in an array, starting at
     offset 0.
    </para>  
    <para> 
     See also: <function>fbsql_fetch_row</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-fetch-object">
   <refnamediv>
    <refname>fbsql_fetch_object</refname>
    <refpurpose>Fetch a result row as an object</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>object</type><methodname>fbsql_fetch_object</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>
        result_type
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     Returns an object with properties that correspond to the fetched
     row, or &false; if there are no more rows.
    </para>
    <para> 
     <function>fbsql_fetch_object</function> is similar to
     <function>fbsql_fetch_array</function>, with one difference - an
     object is returned, instead of an array.  Indirectly, that means
     that you can only access the data by the field names, and not by
     their offsets (numbers are illegal property names).
    </para>
    <para>
     The optional argument <parameter>result_type</parameter> is a
     constant and can take the following values: FBSQL_ASSOC,
     FBSQL_NUM, and FBSQL_BOTH.
    </para>
    <para>
     Speed-wise, the function is identical to
     <function>fbsql_fetch_array</function>, and almost as quick as
     <function>fbsql_fetch_row</function> (the difference is
     insignificant).
     <example>
      <title><function>fbsql_fetch_object</function> example</title>
      <programlisting role="php">
<![CDATA[
<?php 
fbsql_connect ($host, $user, $password);
$result = fbsql_db_query ("database", "select * from table");
while ($row = fbsql_fetch_object ($result)) {
    echo $row->user_id;
    echo $row->fullname;
}
fbsql_free_result ($result);
?>
]]>
      </programlisting>
     </example>
    </para>
    <para> 
     See also: <function>fbsql_fetch_array</function> and
     <function>fbsql_fetch_row</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-fetch-row">
   <refnamediv>
    <refname>fbsql_fetch_row</refname>
    <refpurpose>Get a result row as an enumerated array</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>array</type><methodname>fbsql_fetch_row</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
     </methodsynopsis>
    <para> 
     Returns: An array that corresponds to the fetched row, or &false;
     if there are no more rows.
    </para>
    <para>
     <function>fbsql_fetch_row</function> fetches one row of data from
     the result associated with the specified result identifier.  The
     row is returned as an array.  Each result column is stored in an
     array offset, starting at offset 0.
    </para>
    <para>
     Subsequent call to <function>fbsql_fetch_row</function> would
     return the next row in the result set, or &false; if there are no
     more rows.
    </para>
    <para>
     See also: <function>fbsql_fetch_array</function>,
     <function>fbsql_fetch_object</function>,
     <function>fbsql_data_seek</function>,
     <function>fbsql_fetch_lengths</function>, and
     <function>fbsql_result</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-field-flags">
   <refnamediv>
    <refname>fbsql_field_flags</refname>
    <refpurpose>
     Get the flags associated with the specified field in a result
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>string</type><methodname>fbsql_field_flags</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
      <methodparam><type>int</type><parameter>field_offset</parameter></methodparam>
     </methodsynopsis>
    <para> 
     <function>fbsql_field_flags</function> returns the field flags of
     the specified field. The flags are reported as a single word
     per flag separated by a single space, so that you can split the
     returned value using <function>explode</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-field-name">
   <refnamediv>
    <refname>fbsql_field_name</refname> 
    <refpurpose>
     Get the name of the specified field in a result
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>string</type><methodname>fbsql_field_name</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
      <methodparam><type>int</type><parameter>field_index</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>fbsql_field_name</function> returns the name of the
     specified field index. <parameter>result</parameter> must be a
     valid result identifier and <parameter>field_index</parameter> is
     the numerical offset of the field.
    </para>
    <note>
     <para>
      <parameter>field_index</parameter> starts at 0.
     </para>
     <para>
      e.g. The index of the third field would actually be 2, the index
      of the fourth field would be 3 and so on.
     </para>
    </note>
    <para>
     <example>
      <title><function>fbsql_field_name</function> example</title>
      <programlisting role="php">
<![CDATA[
// The users table consists of three fields: 
//   user_id
//   username
//   password.

$res = fbsql_db_query("users", "select * from users", $link);

echo fbsql_field_name($res, 0) . "\n";
echo fbsql_field_name($res, 2);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     The above example would produce the following output:
     <informalexample>
      <programlisting>
<![CDATA[
user_id
password
]]>
      </programlisting>
     </informalexample>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-field-len">
   <refnamediv>
    <refname>fbsql_field_len</refname> 
    <refpurpose>
     Returns the length of the specified field
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>int</type><methodname>fbsql_field_len</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
      <methodparam><type>int</type><parameter>field_offset</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>fbsql_field_len</function> returns the length of the
     specified field.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-field-seek">
   <refnamediv>
    <refname>fbsql_field_seek</refname>
    <refpurpose>
     Set result pointer to a specified field offset
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>bool</type><methodname>fbsql_field_seek</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
      <methodparam><type>int</type><parameter>field_offset</parameter></methodparam>
     </methodsynopsis>
    <para>
     Seeks to the specified field offset.  If the next call to
     <function>fbsql_fetch_field</function> doesn't include a field
     offset, the field offset specified in
     <function>fbsql_field_seek</function> will be returned.
    </para>
    <para>
     See also: <function>fbsql_fetch_field</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-field-table">
   <refnamediv>
    <refname>fbsql_field_table</refname>
    <refpurpose>
     Get name of the table the specified field is in
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>string</type><methodname>fbsql_field_table</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
      <methodparam><type>int</type><parameter>field_offset</parameter></methodparam>
     </methodsynopsis>
    <para> 
     Returns the name of the table that the specified field is
     in.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-field-type">
   <refnamediv>
    <refname>fbsql_field_type</refname>
    <refpurpose>
     Get the type of the specified field in a result
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>string</type><methodname>fbsql_field_type</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
      <methodparam><type>int</type><parameter>field_offset</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>fbsql_field_type</function> is similar to the
     <function>fbsql_field_name</function> function. The arguments are
     identical, but the field type is returned instead. The field type
     will be one of "int", "real", "string", "blob", and others as
     detailed in the <ulink url="&url.fbsql.docs;">FrontBase
     documentation</ulink>.
     <example>
      <title><function>fbsql_field_type</function> example</title>
      <programlisting role="php">
<![CDATA[
<?php 

fbsql_connect ("localhost", "_SYSTEM", "");
fbsql_select_db ("wisconsin");
$result = fbsql_query ("SELECT * FROM onek;");
$fields = fbsql_num_fields ($result);
$rows   = fbsql_num_rows ($result);
$i = 0;
$table = fbsql_field_table ($result, $i);
echo "Your '".$table."' table has ".$fields." fields and ".$rows." records <BR>";
echo "The table has the following fields <BR>"; 
while ($i < $fields) {
    $type  = fbsql_field_type  ($result, $i);
    $name  = fbsql_field_name  ($result, $i);
    $len   = fbsql_field_len   ($result, $i);
    $flags = fbsql_field_flags ($result, $i);
    echo $type." ".$name." ".$len." ".$flags."<BR>";
    $i++;
}
fbsql_close();

?>
]]>
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-free-result">
   <refnamediv>
    <refname>fbsql_free_result</refname>
    <refpurpose>Free result memory</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>bool</type><methodname>fbsql_free_result</methodname>
      <methodparam><type>int</type><parameter>result</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>fbsql_free_result</function> will free all memory
     associated with the result identifier <parameter>result</parameter>.
    </para>
    <para>
     <function>fbsql_free_result</function> only needs to be called if
     you are concerned about how much memory is being used for queries
     that return large result sets.  All associated result memory is
     automatically freed at the end of the script's execution.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-insert-id">
   <refnamediv>
    <refname>fbsql_insert_id</refname>
    <refpurpose>
     Get the id generated from the previous INSERT operation
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>int</type><methodname>fbsql_insert_id</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>fbsql_insert_id</function> returns the ID generated for
     an column defined as DEFAULT UNIQUE by the previous INSERT query
     using the given <parameter>link_identifier</parameter>.  If
     <parameter>link_identifier</parameter> isn't specified, the last
     opened link is assumed.
    </para>
    <para>
     <function>fbsql_insert_id</function> returns 0 if the previous
     query does not generate an DEFAULT UNIQUE value. If you need to
     save the value for later, be sure to call fbsql_insert_id()
     immediately after the query that generates the value.
    </para>
    <note>
     <para>
      The value of the FrontBase SQL function
      <literal>LAST_INSERT_ID()</literal> always contains the most
      recently generated DEFAULT UNIQUE value, and is not reset
      between queries.
     </para>
    </note>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-list-dbs">
   <refnamediv>
    <refname>fbsql_list_dbs</refname> 
    <refpurpose>
     List databases available on a FrontBase server
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>resource</type><methodname>fbsql_list_dbs</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>fbsql_list_dbs</function> will return a result pointer
     containing the databases available from the current fbsql
     daemon. Use the <function>fbsql_tablename</function> function to
     traverse this result pointer.
    </para>
    <para>
     <example>
      <title><function>fbsql_list_dbs</function> example</title>
      <programlisting role="php">
<![CDATA[
$link = fbsql_connect('localhost', 'myname', 'secret');
$db_list = fbsql_list_dbs($link);

while ($row = fbsql_fetch_object($db_list)) {
    echo $row->Database . "\n";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     The above example would produce the following output:
     <informalexample>
      <programlisting>
<![CDATA[
database1
database2
database3
..
]]>
      </programlisting>
     </informalexample>
    </para>
    <note>
     <para>
      The above code would just as easily work with
      <function>fbsql_fetch_row</function> or other similar functions.
     </para>
    </note>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-list-fields">
   <refnamediv>
    <refname>fbsql_list_fields</refname>
    <refpurpose>List FrontBase result fields</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>resource</type><methodname>fbsql_list_fields</methodname>
      
<methodparam><type>string</type><parameter>database_name</parameter></methodparam>
      <methodparam><type>string</type><parameter>table_name</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>fbsql_list_fields</function> retrieves information
     about the given tablename. Arguments are the database name and
     the table name. A result pointer is returned which can be used
     with <function>fbsql_field_flags</function>,
     <function>fbsql_field_len</function>,
     <function>fbsql_field_name</function>, and
     <function>fbsql_field_type</function>.
    </para>
    <para>
     A result identifier is a positive integer. The function returns
     -1 if a error occurs. A string describing the error will be
     placed in <literal>$phperrmsg</literal>, and unless the function
     was called as <literal>@fbsql()</literal> then this error string
     will also be printed out.
    </para>
    <para>
     <example>
      <title><function>fbsql_list_fields</function> example</title>
      <programlisting role="php">
<![CDATA[
$link = fbsql_connect('localhost', 'myname', 'secret');

$fields = fbsql_list_fields("database1", "table1", $link);
$columns = fbsql_num_fields($fields);

for ($i = 0; $i < $columns; $i++) {
    echo fbsql_field_name($fields, $i) . "\n";;
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     The above example would produce the following output:
     <informalexample>
      <programlisting>
<![CDATA[
field1
field2
field3
..
]]>
      </programlisting>
     </informalexample>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-list-tables">
   <refnamediv>
    <refname>fbsql_list_tables</refname>
    <refpurpose>List tables in a FrontBase database</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>resource</type><methodname>fbsql_list_tables</methodname>
      <methodparam><type>string</type><parameter>database</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     <function>fbsql_list_tables</function> takes a database name and
     returns a result pointer much like the
     <function>fbsql_db_query</function> function.  The
     <function>fbsql_tablename</function> function should be used to
     extract the actual table names from the result pointer.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-next-result">
   <refnamediv>
    <refname>fbsql_next_result</refname>
    <refpurpose>
     Move the internal result pointer to the next result
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>bool</type><methodname>fbsql_next_result</methodname>
      <methodparam><type>int</type><parameter>result_id</parameter></methodparam>
     </methodsynopsis>
    <para>
     When sending more than one SQL statement to the server or
     executing a stored procedure with multiple results will cause the
     server to return multiple result sets.  This function will test
     for additional results available form the server. If an
     additional result set exists it will free the existing result set
     and prepare to fetch the words from the new result set.  The
     function will return &true; if an additional result set was
     available or &false; otherwise.
    </para>
    <example>
     <title><function>fbsql_next_result</function> example</title>
     <programlisting role="php">
<![CDATA[
<?php
    $link = fbsql_connect ("localhost", "_SYSTEM", "secret");
    fbsql_select_db("MyDB", $link);
    $SQL = "Select * from table1; select * from table2;";
    $rs = fbsql_query($SQL, $link);
    do {
        while ($row = fbsql_fetch_row($rs)) {
        }
    } while (fbsql_next_result($rs));
    fbsql_free_result($rs);
    fbsql_close ($link);
?>
]]>
     </programlisting>
    </example>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-num-fields">
   <refnamediv>
    <refname>fbsql_num_fields</refname>
    <refpurpose>Get number of fields in result</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>int</type><methodname>fbsql_num_fields</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
     </methodsynopsis>
    <para> 
     <function>fbsql_num_fields</function> returns the number of
     fields in a result set.
    </para>
    <para> 
     See also: 
     <function>fbsql_db_query</function>,
     <function>fbsql_query</function>,
     <function>fbsql_fetch_field</function>, and
     <function>fbsql_num_rows</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-num-rows">
   <refnamediv>
    <refname>fbsql_num_rows</refname>
    <refpurpose>Get number of rows in result</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>int</type><methodname>fbsql_num_rows</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>fbsql_num_rows</function> returns the number of rows in
     a result set. This command is only valid for SELECT statements.
     To retrieve the number of rows returned from a INSERT, UPDATE or
     DELETE query, use <function>fbsql_affected_rows</function>.
     <example>
      <title><function>fbsql_num_rows</function> example</title>
      <programlisting role="php">
<![CDATA[
<?php

$link = fbsql_connect("localhost", "username", "password"); 
fbsql_select_db("database", $link);

$result = fbsql_query("SELECT * FROM table1;", $link); 
$num_rows = fbsql_num_rows($result); 

echo "$num_rows Rows\n";

?>
]]>
      </programlisting>
     </example>
    </para>
    <para>
     See also: <function>fbsql_affected_rows</function>,
     <function>fbsql_connect</function>,
     <function>fbsql_select_db</function>, and
     <function>fbsql_query</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-pconnect">
   <refnamediv>
    <refname>fbsql_pconnect</refname> 
    <refpurpose>
     Open a persistent connection to a FrontBase Server
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>resource</type><methodname>fbsql_pconnect</methodname>
      <methodparam 
choice="opt"><type>string</type><parameter>hostname</parameter></methodparam>
      <methodparam 
choice="opt"><type>string</type><parameter>username</parameter></methodparam>
      <methodparam 
choice="opt"><type>string</type><parameter>password</parameter></methodparam>
     </methodsynopsis>
    <para> 
     Returns: A positive FrontBase persistent link identifier on
     success, or &false; on error.
    </para>
    <para>
     <function>fbsql_pconnect</function> establishes a connection
     to a FrontBase server.  The following defaults are assumed for
     missing optional parameters: <parameter>host</parameter> =
     'localhost', <parameter>username</parameter> = "_SYSTEM"
     and <parameter>password</parameter> = empty password.
    </para>
    <para>
     <function>fbsql_pconnect</function> acts very much like
     <function>fbsql_connect</function> with two major differences.
    </para>
    <para>
     To set Frontbase server port number, use
     <function>fbsql_select_db</function>.
    </para>
    <para> 
     First, when connecting, the function would first try to find a
     (persistent) link that's already open with the same host,
     username and password.  If one is found, an identifier for it
     will be returned instead of opening a new connection.
    </para>
    <para> 
     Second, the connection to the SQL server will not be closed when
     the execution of the script ends.  Instead, the link will remain
     open for future use.
    </para>
    <para> 
     This type of links is therefore called 'persistent'.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-query">
   <refnamediv>
    <refname>fbsql_query</refname>
    <refpurpose>Send a FrontBase query</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>resource</type><methodname>fbsql_query</methodname>
      <methodparam><type>string</type><parameter>query</parameter></methodparam>
      <methodparam 
choice="opt"><type>resource</type><parameter>link_identifier</parameter></methodparam>
     </methodsynopsis>
    <para> 
     <function>fbsql_query</function> sends a query to the currently
     active database on the server that's associated with the
     specified link identifier.  If
     <parameter>link_identifier</parameter> isn't specified, the last
     opened link is assumed.  If no link is open, the function tries
     to establish a link as if <function>fbsql_connect</function> was
     called with no arguments, and use it.
    </para>
    <note>
     <para>
      The query string shall always end with a semicolon.
     </para>
    </note>
    <para>
     <function>fbsql_query</function> returns &true; (non-zero) or &false;
     to indicate whether or not the query succeeded.  A return value
     of &true; means that the query was legal and could be executed by
     the server.  It does not indicate anything about the number of
     rows affected or returned. It is perfectly possible for a query
     to succeed but affect no rows or return no rows.
    </para>
    <para>
     The following query is syntactically invalid, so
     <function>fbsql_query</function> fails and returns &false;:
     <example>
      <title><function>fbsql_query</function> example</title>
      <programlisting role="php">
<![CDATA[
<?php
$result = fbsql_query ("SELECT * WHERE 1=1")
    or die ("Invalid query");
?>
]]>
      </programlisting>
     </example>
    </para>
    <para>
     The following query is semantically invalid if
     <literal>my_col</literal> is not a column in the table
     <literal>my_tbl</literal>, so <function>fbsql_query</function>
     fails and returns &false;:
     <example>
      <title><function>fbsql_query</function> example</title>
      <programlisting role="php">
<![CDATA[
<?php
$result = fbsql_query ("SELECT my_col FROM my_tbl")
    or die ("Invalid query");
?>
]]>
      </programlisting>
     </example>
    </para>
    <para>
     <function>fbsql_query</function> will also fail and return
     &false; if you don't have permission to access the table(s)
     referenced by the query.
    </para>
    <para>
     Assuming the query succeeds, you can call
     <function>fbsql_num_rows</function> to find out how many rows
     were returned for a SELECT statement or
     <function>fbsql_affected_rows</function> to find out how many
     rows were affected by a DELETE, INSERT, REPLACE, or UPDATE
     statement.
    </para>
    <para>
     For SELECT statements, <function>fbsql_query</function> returns a
     new result identifier that you can pass to
     <function>fbsql_result</function>.  When you are done with the
     result set, you can free the resources associated with it by
     calling <function>fbsql_free_result</function>.  Although, the
     memory will automatically be freed at the end of the script's
     execution.
    </para>
    <para>
     See also: <function>fbsql_affected_rows</function>,
     <function>fbsql_db_query</function>,
     <function>fbsql_free_result</function>,
     <function>fbsql_result</function>,
     <function>fbsql_select_db</function>, and
     <function>fbsql_connect</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-read-blob">
   <refnamediv>
    <refname>fbsql_read_blob</refname>
    <refpurpose>Read a BLOB from the database</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>string</type><methodname>fbsql_read_blob</methodname>
      <methodparam><type>string</type><parameter>blob_handle</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     Returns: A string containing the BLOB specified by blob_handle.
    </para>
    <para> 
     <function>fbsql_read_blob</function> reads BLOB data from the
     database.  If a select statement contains BLOB and/or BLOB
     columns FrontBase will return the data directly when data is
     fetched. This default behavior can be changed with
     <function>fbsql_set_lob_mode</function> so the fetch functions
     will return handles to BLOB and CLOB data.  If a handle is
     fetched a user must call <function>fbsql_read_blob</function> to
     get the actual BLOB data from the database.
    </para>
    <example>
     <title><function>fbsql_read_blob</function> example</title>
     <programlisting role="php">
<![CDATA[
<?php
    $link = fbsql_pconnect ("localhost", "_SYSTEM", "secret")
        or die ("Could not connect");
    $sql = "SELECT BLOB_COLUMN FROM BLOB_TABLE;";
    $rs = fbsql_query($sql, $link);
    $row_data = fbsql_fetch_row($rs);
    // $row_data[0] will now contain the blob data for teh first row
    fbsql_free_result($rs);
    
    $rs = fbsql_query($sql, $link);
    fbsql_set_lob_mode($rs, FBSQL_LOB_HANDLE);
    $row_data = fbsql_fetch_row($rs);
    // $row_data[0] will now contain a handle to the BLOB data in the first row
    $blob_data = fbsql_read_blob($row_data[0]);
    fbsql_free_result($rs);
    
?>
]]>
     </programlisting>
    </example>
    <para>
     See also: <function>fbsql_create_blob</function>,
     <function>fbsql_read_blob</function>,
     <function>fbsql_read_clob</function>, and
     <function>fbsql_set_lob_mode</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-read-clob">
   <refnamediv>
    <refname>fbsql_read_clob</refname>
    <refpurpose>Read a CLOB from the database</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>string</type><methodname>fbsql_read_clob</methodname>
      <methodparam><type>string</type><parameter>clob_handle</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     Returns: A string containing the CLOB specified by clob_handle.
    </para>
    <para> 
     <function>fbsql_read_clob</function> reads CLOB data from the
     database.  If a select statement contains BLOB and/or CLOB
     columns FrontBase will return the data directly when data is
     fetched. This default behavior can be changed with
     <function>fbsql_set_lob_mode</function> so the fetch functions
     will return handles to BLOB and CLOB data.  If a handle is
     fetched a user must call <function>fbsql_read_clob</function> to
     get the actual CLOB data from the database.
    </para>
    <example>
     <title><function>fbsql_read_clob</function> example</title>
     <programlisting role="php">
<![CDATA[
<?php
    $link = fbsql_pconnect ("localhost", "_SYSTEM", "secret")
        or die ("Could not connect");
    $sql = "SELECT CLOB_COLUMN FROM CLOB_TABLE;";
    $rs = fbsql_query($sql, $link);
    $row_data = fbsql_fetch_row($rs);
    // $row_data[0] will now contain the clob data for teh first row
    fbsql_free_result($rs);
    
    $rs = fbsql_query($sql, $link);
    fbsql_set_lob_mode($rs, FBSQL_LOB_HANDLE);
    $row_data = fbsql_fetch_row($rs);
    // $row_data[0] will now contain a handle to the CLOB data in the first row
    $clob_data = fbsql_read_clob($row_data[0]);
    fbsql_free_result($rs);
    
?>
]]>
     </programlisting>
    </example>
    <para>
     See also: <function>fbsql_create_blob</function>,
     <function>fbsql_read_blob</function>,
     <function>fbsql_read_clob</function>, and
     <function>fbsql_set_lob_mode</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-result">
   <refnamediv>
    <refname>fbsql_result</refname>
    <refpurpose>Get result data</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>mixed</type><methodname>fbsql_result</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
      <methodparam><type>int</type><parameter>row</parameter></methodparam>
      <methodparam choice="opt"><type>mixed</type><parameter>
        field
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>fbsql_result</function> returns the contents of one
     cell from a FrontBase result set.  The field argument can be the
     field's offset, or the field's name, or the field's table dot
     field's name (tabledname.fieldname).  If the column name has been
     aliased ('select foo as bar from...'), use the alias instead of
     the column name.
    </para>
    <para>
     When working on large result sets, you should consider using one
     of the functions that fetch an entire row (specified below).  As
     these functions return the contents of multiple cells in one
     function call, they're MUCH quicker than
     <function>fbsql_result</function>.  Also, note that specifying a
     numeric offset for the field argument is much quicker than
     specifying a fieldname or tablename.fieldname argument.
    </para>
    <para>
     Calls to <function>fbsql_result</function> should not be mixed
     with calls to other functions that deal with the result set.
    </para>
    <para>
     Recommended high-performance alternatives:
     <function>fbsql_fetch_row</function>, 
     <function>fbsql_fetch_array</function>, and
     <function>fbsql_fetch_object</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-rollback">
   <refnamediv>
    <refname>fbsql_rollback</refname>
    <refpurpose>Rollback a transaction to the database</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>bool</type><methodname>fbsql_rollback</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     Returns: &true; on success, &false; on failure.
    </para>
    <para> 
     <function>fbsql_rollback</function> ends the current transaction by
     rolling back all statements issued since last commit.
     This command is only needed if autocommit is set to false.
    </para>
    <para> See also:
     <function>fbsql_autocommit</function> and
     <function>fbsql_commit</function>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-set-lob-mode">
   <refnamediv>
    <refname>fbsql_set_lob_mode</refname>
    <refpurpose>
     Set the LOB retrieve mode for a FrontBase result set
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>bool</type><methodname>fbsql_set_lob_mode</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
      
<methodparam><type>string</type><parameter>database_name</parameter></methodparam>
     </methodsynopsis>
    <para> 
     Returns: &true; on success, &false; on error.
    </para>
    <para> 
     <function>fbsql_set_lob_mode</function> sets the mode for
     retrieving LOB data from the database. When BLOB and CLOB data is
     stored in FrontBase it can be stored direct or indirect.  Direct
     stored LOB data will always be fetched no matter the setting of
     the lob mode. If the LOB data is less than 512 bytes it will
     always be stored directly.
     <itemizedlist>
      <listitem>
       <simpara>
        FBSQL_LOB_DIRECT - LOB data is retrieved directly. When data
        is fetched from the database with
        <function>fbsql_fetch_row</function>, and other fetch
        functions, all CLOB and BLOB columns will be returned as
        ordinary columns.  This is the default value on a new
        FrontBase result.
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        FBSQL_LOB_HANDLE - LOB data is retrieved as handles to the
        data.  When data is fetched from the database with
        <function>fbsql_fetch_row </function>, and other fetch
        functions, LOB data will be returned as a handle to the data
        if the data is stored indirect or the data if it is stored
        direct.  If a handle is returned it will be a 27 byte string
        formatted as "@'000000000000000000000000'".
       </simpara>
      </listitem>
     </itemizedlist>     
    </para>
    <para> See also:
     <function>fbsql_create_blob</function>, 
     <function>fbsql_create_clob</function>, 
     <function>fbsql_read_blob</function>, and
     <function>fbsql_read_clob</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-select-db">
   <refnamediv>
    <refname>fbsql_select_db</refname>
    <refpurpose>Select a FrontBase database</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>bool</type><methodname>fbsql_select_db</methodname>
      
<methodparam><type>string</type><parameter>database_name</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     Returns: &true; on success, &false; on error.
    </para>
    <para> 
     <function>fbsql_select_db</function> sets the current active
     database on the server that's associated with the specified link
     identifier.  If no link identifier is specified, the last opened
     link is assumed.  If no link is open, the function will try to
     establish a link as if <function>fbsql_connect</function> was
     called, and use it.
    </para>
    <para>
     The client contacts FBExec to obtain the port number to use for
     the connection to the database. If the database name is a number
     the system will use that as a port number and it will not ask
     FBExec for the port number.  The FrontBase server can be stared
     as FRontBase -FBExec=No -port=&lt;port number&gt; &lt;database
     name&gt;.
    </para>
    <para>
     Every subsequent call to <function>fbsql_query</function> will be
     made on the active database.
    </para>
    <para>
     if the database is protected with a database password, the user must
     call <function>fbsql_database_password</function> before selecting
     the database. 
    </para>
    <para> See also:
     <function>fbsql_connect</function>, 
     <function>fbsql_pconnect</function>,
     <function>fbsql_database_password</function> and
     <function>fbsql_query</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-start-db">
   <refnamediv>
    <refname>fbsql_start_db</refname>
    <refpurpose>Start a database on local or remote server</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>bool</type><methodname>fbsql_start_db</methodname>
      
<methodparam><type>string</type><parameter>database_name</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     Returns: &true; on success, &false; on failure.
    </para>
    <para> 
     <function>fbsql_start_db</function>
    </para>
    <para> 
     See also: <function>fbsql_db_status</function> and
     <function>fbsql_stop_db</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-stop-db">
   <refnamediv>
    <refname>fbsql_stop_db</refname>
    <refpurpose>Stop a database on local or remote server</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>bool</type><methodname>fbsql_stop_db</methodname>
      
<methodparam><type>string</type><parameter>database_name</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
        link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     Returns: &true; on success, &false; on failure.
    </para>
    <para> 
     <function>fbsql_stop_db</function>
    </para>
    <para> 
     See also: <function>fbsql_db_status</function> and
     <function>fbsql_start_db</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-tablename">
   <refnamediv>
    <refname>fbsql_tablename</refname>
    <refpurpose>Get table name of field</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>string</type><methodname>fbsql_tablename</methodname>
      <methodparam><type>resource</type><parameter>result</parameter></methodparam>
      <methodparam><type>int</type><parameter>i</parameter></methodparam>
     </methodsynopsis>
    <para> 
     <function>fbsql_tablename</function> takes a result pointer
     returned by the <function>fbsql_list_tables</function> function
     as well as an integer index and returns the name of a table. The
     <function>fbsql_num_rows</function> function may be used to
     determine the number of tables in the result pointer.
     <example>
      <title><function>fbsql_tablename</function> example</title>
      <programlisting role="php">
<![CDATA[
<?php 
fbsql_connect ("localhost", "_SYSTEM", "");
$result = fbsql_list_tables ("wisconsin");
$i = 0;
while ($i < fbsql_num_rows ($result)) {
    $tb_names[$i] = fbsql_tablename ($result, $i);
    echo $tb_names[$i] . "<BR>";
    $i++;
}
?>
]]>
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.fbsql-warnings">
   <refnamediv>
    <refname>fbsql_warnings</refname>
    <refpurpose>Enable or disable FrontBase warnings</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>bool</type><methodname>fbsql_warnings</methodname>
      <methodparam choice="opt"><type>bool</type><parameter>
        OnOff
       </parameter></methodparam>
     </methodsynopsis>
    <para> 
     Returns  &true; if warnings is turned on otherwise &false;.
    </para>
    <para> 
     <function>fbsql_warnings</function> enables or disables FrontBase
     warnings.
    </para>
   </refsect1>
  </refentry>

  <refentry id='function.fbsql-database'>
   <refnamediv>
    <refname>fbsql_database</refname>
    <refpurpose>Get or set the database name used with a connection</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>string</type><methodname>fbsql_database</methodname>
      
<methodparam><type>resource</type><parameter>link_identifier</parameter></methodparam>
      <methodparam 
choice="opt"><type>string</type><parameter>database</parameter></methodparam>
     </methodsynopsis>
    <para>
     &warn.undocumented.func;
    </para>
   </refsect1>
  </refentry>

  <refentry id='function.fbsql-get-autostart-info'>
   <refnamediv>
    <refname>fbsql_get_autostart_info</refname>
    <refpurpose>No Descrizione given yet</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>array</type><methodname>fbsql_get_autostart_info</methodname>
      <methodparam 
choice="opt"><type>resource</type><parameter>link_identifier</parameter></methodparam>
     </methodsynopsis>
    <para>
     &warn.undocumented.func;
    </para>
   </refsect1>
  </refentry>



  <refentry id='function.fbsql-hostname'>
   <refnamediv>
    <refname>fbsql_hostname</refname>
    <refpurpose>Get or set the host name used with a connection</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>string</type><methodname>fbsql_hostname</methodname>
      
<methodparam><type>resource</type><parameter>link_identifier</parameter></methodparam>
      <methodparam 
choice="opt"><type>string</type><parameter>host_name</parameter></methodparam>
     </methodsynopsis>
    <para>
     &warn.undocumented.func;
    </para>
   </refsect1>
  </refentry>



  <refentry id='function.fbsql-password'>
   <refnamediv>
    <refname>fbsql_password</refname>
    <refpurpose>Get or set the user password used with a connection</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>string</type><methodname>fbsql_password</methodname>
      
<methodparam><type>resource</type><parameter>link_identifier</parameter></methodparam>
      <methodparam 
choice="opt"><type>string</type><parameter>password</parameter></methodparam>
     </methodsynopsis>
    <para>
     &warn.undocumented.func;
    </para>
   </refsect1>
  </refentry>



  <refentry id='function.fbsql-set-transaction'>
   <refnamediv>
    <refname>fbsql_set_transaction</refname>
    <refpurpose>
     Set the transaction locking and isolation
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>void</type><methodname>fbsql_set_transaction</methodname>
      
<methodparam><type>resource</type><parameter>link_identifier</parameter></methodparam>
      <methodparam><type>int</type><parameter>Locking</parameter></methodparam>
      <methodparam><type>int</type><parameter>Isolation</parameter></methodparam>
     </methodsynopsis>
    <para>
     &warn.undocumented.func;
    </para>
   </refsect1>
  </refentry>



  <refentry id='function.fbsql-username'>
   <refnamediv>
    <refname>fbsql_username</refname>
    <refpurpose>Get or set the host user used with a connection</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descrizione</title>
     <methodsynopsis>
      <type>string</type><methodname>fbsql_username</methodname>
      
<methodparam><type>resource</type><parameter>link_identifier</parameter></methodparam>
      <methodparam 
choice="opt"><type>string</type><parameter>username</parameter></methodparam>
     </methodsynopsis>
    <para>
     &warn.undocumented.func;
    </para>
   </refsect1>
  </refentry>


 </reference>

<!-- 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:"../../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
-->

Reply via email to