FuelPHP - Modelli e database

Il modello gioca un ruolo importante nel framework web FuelPHP. Rappresenta le entità aziendali dell'applicazione. Sono forniti dai clienti o recuperati dal database back-end, manipolati secondo le regole aziendali e persistenti nel database. Impariamo a conoscere i modelli e come interagiscono con il sistema di back-end in questo capitolo.

Creazione di un modello

In FuelPHP, il modello è semplicemente una semplice classe PHP che estende la classe Model incorporata. Per impostazione predefinita, i modelli possono avere il prefisso Model_ simile ai controller e devono essere inseriti infuel/app/classes/model/cartella. Creiamo un modello di base dei dipendenti e lo estendiamo man mano che procediamo.

carburante / app / classi / modello / dipendente.php

<?php 
   namespace Model; 

   class Model_Employee extends \Model { 
      public static function fetchAll() { 
         // Code to fetch employee from database 
      } 
   }

Accedi a un modello

Una volta definito un modello, può essere utilizzato liberamente in qualsiasi controller semplicemente includendolo nel controller come segue.

use \Model\Employee; 

class Controller_Employee extends Controller { 
   public function action_index() { 
      $employees = Employee::fetchAll(); 
   } 
}

Panoramica del database

FuelPHP fornisce il proprio livello di astrazione del database per recuperare i dati dal database. Fornisce strumenti ORM sia di base che avanzati. Il toolkit di base è costituito da classi basate su DB, DBUtil e Query_Builer. Il toolkit avanzato è Orm. Il toolkit Orm è derivato dal toolkit di base e fornito in bundle come pacchetto separato.

Configurazione del database

FuelPHP separa le impostazioni del database dal file di configurazione principale e il file è fuel/app/config/db.php. Supporta un'impostazione separata per ogni ambiente. Attualmente, FuelPHP supporta i driver MySQL, MySQLi e PDO. L'impostazione del campione è la seguente:

<?php  
   return array ( 
      'development' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'    => 'localhost', 
            'port'        => '3306', 
            'database'    => 'tutorialspoint_fueldb', 
            'username'    => 'root', 
            'password'    => 'password', 
            'persistent'  => false, 
            'compress'    => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ), 
   )

Toolkit basato su DB

Il DB classè l'opzione più semplice per accedere al database dall'applicazione. Fornisce opzioni per creare la query del database, eseguirla sul database di destinazione e infine recuperare il risultato. La classe DB interagisce con le seguenti classi e fornisce un'API di database completa.

Database_Connection - Singleton e classe principale per interagire con il database
Database_Query - Base, classe concreta per eseguire la query SQL e recuperare il risultato
Database_Query_Builder - Base, classe astratta per costruire query SQL
Database_Query_Builder_Join - Classe per costruire join SQL
Database_Query_Builder_Where - Classe astratta per creare condizioni di query SQL
Database_Query_Builder_Select - Classe concreta per costruire query di selezione SQL
Database_Query_Builder_Insert - Classe astratta per creare query di inserimento SQL
Database_Query_Builder_Update - Classe astratta per creare query di aggiornamento SQL
Database_Query_Builder_Delete - Classe astratta per creare query di eliminazione SQL

Il diagramma seguente illustra la relazione tra le classi ei metodi forniti dalle classi.

API DB

Impariamo i metodi più importanti disponibili nella classe DB in questa sezione.

esempio

Purpose- Crea e restituisce la nuova istanza Database_Connection .
Parameter -
- $db - Nome della connessione al database definito nel file di configurazione, facoltativo.
Returns- Restituisce l' oggetto Database_Connection

Per esempio,

$db = DB::instance(); 
$db = DB::instance('test');

query

Purpose - Prepara l'istruzione SQL fornita e restituisce l'oggetto Database_Query, che può essere utilizzato per inserire, aggiornare, eliminare o recuperare i dati dal database.
Parameter -
- $query - Istruzione SQL, può contenere segnaposto;
- $type - Tipo SQL, opzionale (DB :: SELECT, DB :: INSERT, DB :: UPDATE e DB :: DELETE)
Returns- Restituisce l' oggetto Database_Query

Per esempio,

$query = DB::query('SELECT * FROM 'employees'');

last_query

Purpose - Per ottenere l'ultima query eseguita
Parameter - Nessuno
Returns - Restituisce l'ultima query eseguita

Per esempio,

$employees = DB::Select('Select * from 'employee''); 
$sql = DB::last_query();

Selezionare

Purpose - Genera la parte selezionata della query
Parameter -
- $columns - Elenco dei nomi delle colonne del database
Returns - Restituisce l'oggetto Database_Query_Builder_Select

Per esempio,

$query = DB::select();              // Select *
$query = DB::select('id', 'name'); // Select id, name

select_array (DB)

È simile a select tranne che possiamo inviare colonne come array.

$query = DB::select_array(array('id', 'name')); // Select id, name

inserire

Purpose - Genera la parte di inserimento della query
Parameter -
- $table_name - nome della tabella del database;
- $columns - matrice di colonne della tabella
Returns - Restituisce l'oggetto Database_Query_Builder_Insert

Per esempio,

$query = DB::insert('employee');  // Insert into employee 
$query = DB::insert('employee', array('id', 'name')); // Insert into employee (id, name)

aggiornare

Purpose - Genera la parte di aggiornamento della query
Parameter -
- $table_name - nome della tabella del database
Returns - Restituisce l'oggetto Database_Query_Builder_Update

Per esempio,

$query = DB::update('employee'); // update `employee`

Elimina

Purpose - Genera la parte di cancellazione della query
Parameter -
- $table_name - nome della tabella del database
Returns - Restituisce l'oggetto Database_Query_Builder_Delete

Per esempio

$query = DB::delete('employee');  // delete from 'employee'

API Query

Database_Queryfornisce un'opzione per impostare la connessione al database, eseguire la query e recuperare il risultato come array o oggetto associativo. Vediamo i metodi forniti dalla classe Database_Query.

set_connection

Purpose - Per impostare il database (dettagli di connessione al database) su cui eseguire la query
Parameter - $ db - nome della connessione al database
Returns- Restituisce l' oggetto Database_Query

Per esempio,

$query = DB::query('DELETE * FROM employee', DB::DELETE); 
$query->set_connection('2nd-db');

param

Purpose - Per impostare il valore del parametro definito nell'oggetto Query
Parameter -
- $param - nome del parametro;
- $value - valore del parametro
Returns- Restituisce l' oggetto Database_Query

Per esempio,

// set some variables
$table = 'employee';
$id = 1;
$name = 'Jon';

// don't use
$query = DB::query('SELECT * FROM '.$table.'. WHERE id = '.$id.' AND name = "'.$name.'"');

// but use
$query = DB::query('SELECT * FROM :tablename WHERE id = :id AND name = :name');
$query->param('tablename', 'employee');
$query->param('id', $id);
$query->param('name', $name);

Metodi simili

parameters è un oggetto simile tranne che fornisce l'opzione per dare più valori contemporaneamente.

$query->parameters (array( 
   'tablename' => $table, 
   'id' => $id, 
   'name' => $name 
});

legare

Purpose - Per impostare una variabile sul parametro definito nell'oggetto Query
Parameter -
- $param - nome del parametro
- $var - la variabile a cui associare il parametro
Returns- Restituisce l' oggetto Database_Query

Per esempio,

// bind a query parameter 
$table = 'employee'; 
$query = DB::query('DELETE * FROM :tablename', DB::DELETE); 
$query->bind('tablename', $table);  

// update the variable 
$table = 'employee_salary'; 

// DELETE * FROM `employee_salary`; 
$sql = $query->compile();

compilare

Purpose - Per compilare l'oggetto query definito nella query SQL
Parameter -
- $db - stringa di connessione, opzionale
Returns -

Per esempio,

// assign a value to a query parameter 
$table = 'employee'; 
$query = DB::query('DELETE * FROM :tablename', DB::DELETE); 
$query->param('tablename', $table);

// compile the query, returns: DELETE * FROM employee 
$sql = $query->compile();

eseguire

Purpose - Per eseguire la query definita nell'oggetto Query e restituire il risultato
Parameter -
- $db - nome della connessione al database
Returns - Restituisce il risultato

Per esempio,

// assign a value to a query parameter 
$table = 'employee'; 
$query = DB::query('DELETE * FROM :tablename', DB::DELETE); 
$query->param('tablename', $table);  

// execute the query 
$query->execute();

as_assoc

Purpose - Per impostare il tipo restituito come array associativo invece che come oggetti
Parameter - Nessuno
Returns - Restituisce l'oggetto corrente

Per esempio,

$query = DB::query('SELECT * FROM employee', DB::SELECT); 
$result = $query->as_assoc()->execute(); 
foreach ($result as $row) { 
   echo $row['id']; 
}

as_object

Purpose - Per impostare il tipo restituito come oggetto anziché come array associativo
Parameter - Nessuno
Returns - Restituisce l'oggetto corrente

Per esempio,

$query = DB::query('SELECT * FROM employee', DB::SELECT); 
$result = $query->as_object()->execute(); 
foreach ($result as $row) { 
   echo $row->id; 
}  

// have ORM model objects return instead 
$result = $query->as_object('Model_Employee')->execute();

API Query Builder

Le classi basate su Query Builder (Query_Builder) forniscono opzioni per creare dinamicamente query SQL. Ha quattro classi, ciascuna per selezionare (Query_Builder_Select) , inserire (Query_Builder_Insert) , aggiornare (Query_Builder_Update) ed eliminare (Query_Builder_Delete) query. Queste classi derivano dalla classe Query_Builder_Where (opzione per generare condizioni), a sua volta derivata da Query_Builder , base di tutte le classi.

Diamo un'occhiata ai metodi forniti dalla classe Query_Builder.

Selezionare

Purpose - Per generare le colonne delle query selezionate.
Parameter -
- $columns - elenco delle colonne, facoltativo
Returns - Restituisce l'istanza corrente

Per esempio,

$query = DB::select('name')  // select `name` 
$query = DB::select(array('first_name', 'name')) // select `first_name` as `name`

a partire dal

Purpose - Per generare i dettagli della tabella delle query selezionate
Parameter -
- $tables - elenco delle tabelle
Returns - Restituisce l'istanza corrente

Per esempio,

$query = DB::select('name')->from('employee') // select `name` from `employee`

dove

Purpose - Per generare le condizioni di selezione, inserimento e aggiornamento delle query
Parameters -
- $column - nome della colonna o array ($ colonna, $ alias);
- $op - operatori logici, =,! =, IN, BETWEEN e LIKE, opzionali;
- $value - valore della colonna
Returns - Restituisce l'istanza corrente

Per esempio,

$query = DB::select('name')->from('employee')  
$query = $query->where('name', '=', 'Jon'); 
// select `name` from `employee` where `name` = `Jon`;

Metodi simili

I metodi simili sono where_open (), and_where_open (), or_where_open (), where_close (), and_where_close () o_where_close (). Sono simili ai metodi where () tranne per il fatto che aggiungono parole chiave e parentesi extra attorno alle condizioni. Di seguito è riportato un codice di esempio.

$query = DB::select('*')->from('employee');  
$query->where('email', 'like', '%@gmail.com'); 
$query->or_where_open(); 
$query->where('name', 'Jon'); 
$query->and_where('surname', 'Peter');
$query->or_where_close();  
// SELECT * FROM `employee` WHERE `email` LIKE "%gmail.com" OR 
   (`name` = "Jon" AND `surname` = "Peter")

aderire

Purpose - Per generare i join di tabella delle query selezionate
Parameters -
- $table - nome o array della tabella ($ table, $ alias);
- $type - tipo di join (LEFT, RIGHT, INNER, ecc.)
Returns - Restituisce l'istanza corrente

Esempio

$query = DB::select('name')->from('employee')->join('employee_salary') 
// select `name` from `employee` JOIN `employee_salary`

sopra

Purpose - Per generare la condizione dei join nelle query selezionate
Parameters -
- $c1 - nome della tabella o nome della tabella con alias in array;
- $op - operatore logico;
- $c2 - nome della tabella o nome della tabella con alias in array
Returns - Restituisce l'istanza corrente

Per esempio,

$query = DB::select('name')->from('employee')->join('employee_salary') 
$query = $query->on('employee.employee_id', '=', 'employee_salary.employee_id') 
// select `name` from `employee` JOIN `employee_salary` on 
// `employee.employee_id` = `employee_salary.employee_id`

Metodi simili

I metodi correlati sono and_on () e or_on (). Sono simili a on () tranne per il fatto che aggiungono parole chiave e parentesi extra attorno ai join.

raggruppa per

Purpose - Per generare gruppo per query
Parameter - $columns - Nome della colonna in base al quale raggruppare il risultato
Returns - Restituisce l'istanza corrente

Per esempio,

$query = DB::select('name')->from('employee')  
$query = $query->group_by('name'); 
// select `name` from `employee` group by `name`

avendo

Purpose - Per generare il gruppo in base alle condizioni delle query SQL
Parameter - $column - nome della colonna o array ($ colonna, $ alias); $op - operatori logici, =,! =, IN, BETWEEN e LIKE, opzionali; $value - valore della colonna
Returns - Restituisce l'istanza corrente

Esempio

$query = DB::select('name')->from('employee')
$query = $query->group_by('name');
$query = $query->having('name', '!=', 'Jon');
// select `name` from `employee` group by `name` having `name` != `Jon`

Metodi simili

I metodi simili sono having_open (), and_having_open (), or_having_open (), having_close (), and_having_close () o_having_close (). Sono simili ai metodi having () tranne per il fatto che aggiungono parole chiave e parentesi extra attorno alle condizioni.

Ripristina

Purpose - Per ripristinare la query
Parameter - Nessuno
Returns - Restituisce l'istanza corrente

Per esempio,

$query = DB::select('name')->from('employee')  
$query->reset() 
$query = DB::select('name')->from('employee_salary') 
// select `name` from `employee_salary`

Classe DBUtil

La classe DBUtil fornisce un'opzione per gestire ed eseguire operazioni di database di routine. Alcuni dei metodi importanti sono i seguenti:

set_connection - Imposta la connessione predefinita

DBUtil::set_connection('new_database');

create_database - Crea un database.

DBUtil::create_database('my_database');

drop_database - Elimina un database.

DBUtil::drop_database('my_database');

table_exists - Controlla se esiste una determinata tabella.

if(DBUtil::table_exists('my_table')) { 
   // Table exists 
} else { 
   // Table does NOT exist, create it! 
}

drop_table - Elimina una tabella.

DBUtil::drop_table('my_table');

create_table - Crea una tabella.

\DBUtil::create_table ( 
   'users', 
   array ( 
      'id' => array('type' => 'int', 'auto_increment' => true), 
      'name' => array('type' => 'text'), 
   ), 
);

Orm Toolkit

FuelPHP fornisce un livello di database avanzato utilizzando il concetto ORM basato sul popolare Active record pattern. Il toolkit è incluso nell'applicazione ma non è configurato per impostazione predefinita. È raggruppato come pacchetto e il nome del pacchetto è orm. Possiamo aggiungere la seguente configurazione nel file di configurazione principale,fuel/app/config/config.php per caricare il toolkit orm.

'always_load' => array ( 
   'packages' => array (
      'orm', 
   ), 
),

Creazione di modelli

Orm fornisce la classe del modello base Orm \ Model. Dobbiamo estendere i nostri modelli con il modello orm per utilizzare le funzionalità ORM. Di seguito è riportato un codice di esempio.

class Model_Employee extends Orm\Model {}

Configurazione

Orm fornisce una serie di impostazioni per configurare il modello in modo che utilizzi le funzionalità ORM. Sono i seguenti:

connection- Impostare una proprietà _connection statica nel modello per specificare il nome della connessione.

class Model_Employee extends Orm\Model { 
   protected static $_connection = "production"; 
}

table name- Impostare una proprietà _table_name statica nel modello per specificare il nome della tabella della tabella di backend.

class Model_Employee extends Orm\Model { 
   protected static $_table_name = 'employee'; 
}

primary key- Imposta una proprietà _primary_key statica nel modello per specificare la chiave primaria della tabella di backend.

class Model_Employee extends Orm\Model { 
   protected static $_primary_key = array('id'); 
}

Columns- Impostare una proprietà _properties statica nel modello per specificare le colonne della tabella di backend. Supporta data_type, label, validation, form elememts, ecc.

class Model_Employee extends Orm\Model { 
   protected static $_properties = array ( 
      'id',  
      'name' => array ( 
         'data_type' => 'varchar', 
         'label' => 'Employee Name', 
         'validation' => array ( 
            'required',  
            'min_length' => array(3),  
            'max_length' > array(80) 
         ), 
         
         'form' => array ( 
            'type' => 'text' 
         ), 
      ),  

      'age' => array ( 
         'data_type' => 'int', 
         'label' => 'Employee Age', 
         'validation' => array ( 
            'required',  
         ),  
         
         'form' => array ( 
            'type' => 'text' 
         ), 
      ),  
   ); 
}

Conditions- Impostare una proprietà _conditions statica per impostare le condizioni e l'ordine per opzioni.

class Model_Employee extends Orm\Model { 
   protected static $_conditions = array ( 
      'order_by' => array('id' => 'desc'), 
      'where' => array ( 
         array('is_active', > true), 
      ), 
   ); 
}

Observers- Orm fornisce un sistema di eventi basato sull'osservatore per aggiungere comportamenti a eventi specifici. Per aggiungere un comportamento, impostare prima una proprietà _observers nel modello. Quindi, definire il comportamento come una classe e impostarlo nella proprietà _observers insieme agli eventi. Se non viene specificato alcun evento, il comportamento verrà richiamato per tutti gli eventi. Possiamo anche specificare più comportamenti.

class Model_Employee { 
   protected static $_observers = array ( 
      'example',  // will call Observer_Example class for all events 
      'Orm\\Observer_CreatedOn' => array ( 
         'events' => array('before_insert'),  
         // will only call Orm\Observer_CreatedOn at before_insert event 
      ) 
   ); 
}

Creare

Una volta configurato il modello, possiamo iniziare a utilizzare i metodi immediatamente. Orm fornisce un risparmio metodo per salvare l'oggetto nel database. Possiamo impostare i dati utilizzando le proprietà configurate come segue:

// option 1 
$new = new Model_Employee(); 
$new->name = 'Jon'; 
$new->save();  

// option 2, use forge instead of new 
$new = Model_Employee::forge();
$new->name = 'Jon'; 
$new->save();  

// option 3, use array for properties 
$props = array('name' => 'Jon'); 
$new = Model_Employee::forge($props); 
$new>save();

Leggere

Orm fornisce un metodo, find per recuperare i dati dal database e collegarli all'oggetto. Il metodo find funziona a seconda del parametro di input. Diamo un'occhiata alle diverse opzioni:

by primary key - La specifica della chiave primaria restituisce il record facendo corrispondere la chiave primaria della tabella configurata.

$employee = Model_Employee::find(1);

first / last record- Se si specifica "primo" o "ultimo", verrà recuperato rispettivamente il primo o l'ultimo record. Possiamo anche passare l'ordine per opzione.

$entry = Model_Employee::find('first'); 
$entry = Model_Article::find('last', array('order_by' => 'id'));

All- Specificando "all" verranno recuperati tutti i record dalla tabella configurata. Possiamo specificare l'ordine per opzione e condizioni.

$entry = Model_Employee::find('all');  
$entry = Model_Article::find ('all', array ( 
   'where' => array ( 
      array ('name', 'Jon'), 
   ), 
   'order_by' => array ('id' => 'desc'), 
));

Possiamo usare Query API del toolkit di database di base insieme al modello per l'opzione di ricerca avanzata come segue.

$query = Model_Employee::query()->where('category_id', 1)->order_by('date', 'desc');
$number_of_employees = $query->count(); 
$latest_employee = $query->max('id'); 
$young_employee = $query->min('age'); 
$newest_employee = $query->get_one(); 
$employees = $query->limit(15)->get();

Aggiornare

L'aggiornamento del modello è lo stesso della creazione, tranne che invece di creare un nuovo modello è sufficiente recuperare il modello da aggiornare utilizzando il metodo find, aggiornare la proprietà e quindi chiamare il metodo di salvataggio come segue.

$entry = Model_Employee:find(4);
$entry->name = 'Peter'; 
$entry->save();

Elimina

Orm fornisce un metodo di eliminazione per eliminare il modello. Basta recuperare l'oggetto e chiamare il metodo di eliminazione.

$entry = Model_Employee:find(4); 
$entry->delete();

Esempio di lavoro

Creiamo un esempio funzionante in questo capitolo per comprendere il modello e il database.

Crea un database

Crea un nuovo database nel server MySQL, utilizzando il seguente comando.

create database tutorialspoint_fueldb

Quindi, crea una tabella all'interno del database utilizzando il seguente comando.

create table employee(id int primary key, name varchar(20), age int not null);

Configura il database

Cerchiamo di configurare il database utilizzando il file di configurazione del database, * fuel / app / config / db.php. Aggiungi le seguenti modifiche per connettere il server MySQL.

<?php  
   return array ( 
      'development' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'       => 'localhost', 
            'port'           => '3306', 
            'database'       => 'tutorialspoint_fueldb', 
            'username'       => 'root', 
            'password'       => 'pass', 
            'persistent'     => false, 
            'compress'       => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ),  
      
      'production' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'       => 'localhost', 
            'port'           => '3306', 
            'database'       => 'tutorialspoint_fueldb', 
            'username'       => 'root', 
            'password'       => 'pass', 
            'persistent'     => false, 
            'compress'       => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ), 
   );

Includi pacchetto ORM

Aggiorna il file di configurazione principale, fuel/app/config/config.php per includere il pacchetto ORM aggiungendo la seguente configurazione.

'always_load' => array ( 
   'packages' => array ( 
      'orm' 
   ), 
),

Ora ORM è abilitato nella tua applicazione

Crea modello dipendente

Crea un nuovo modello, Dipendente nella cartella del modello “fuel/app/classes/model”. È definito come segue.

Employee.php

<?php  
   class Model_Employee extends Orm\Model { 
      protected static $_connection = 'production'; 
      protected static $_table_name = 'employee'; 
      protected static $_primary_key = array('id'); 
      protected static $_properties = array ( 
         'id',  
         'name' => array ( 
            'data_type' => 'varchar', 
            'label' => 'Employee Name', 
            'form' => array (
               'type' => 'text' 
            ), 
         ),  
         
         'age' => array ( 
            'data_type' => 'int', 
            'label' => 'Employee Age', 
            'form' => array ( 
               'type' => 'text' 
            ), 
         ),  
      ); 
   }

Crea azione

Crea nuova azione, action_model in Controller dei dipendenti situato in fuel/app/classes/controller/employee.php come segue.

class Controller_Employee extends Controller { 
   public function action_model() { 
      
      // db based sql command to delete all employees 
      $query = db::query('delete from `employee`'); 
      $query->execute('production');  
      
      // orm based query to add new employees 
      $model = new model_employee(); 
      $model->name = "john"; 
      $model->age = 25; 
      $model->save();  
      $model = new model_employee(); 
      $model->name = "peter"; 
      $model->age = 20; 
      $model->save(); 
      
      // orm based query to fetch all employee data 
      $data = array(); 
      $data['emps'] = model_employee::find('all');  
      return response::forge(view::forge('employee/model', $data)); 
   } 
}

Crea vista

Ora, crea un file di visualizzazione model.php situato in “fuel/app/views/employee”. Aggiungi le seguenti modifiche al file.

<ul> 
   <?php 
      foreach($emps as $emp) {  
   ?> 
   <li><?php echo $emp['name']; ?></li> 
   
   <?php 
   } 
   ?> 
</ul>

Ora, richiedi l'URL, http://localhost:8080/employee/model e produrrà il seguente risultato.

Risultato

↰ Previous page Next page ↱

FuelPHP - Modelli e database

Creazione di un modello

carburante / app / classi / modello / dipendente.php

Accedi a un modello

Panoramica del database

Configurazione del database

Toolkit basato su DB

API DB

esempio

query

last_query

Selezionare

select_array (DB)

inserire

aggiornare

Elimina

API Query

set_connection

param

Metodi simili

legare

compilare

eseguire

as_assoc

as_object

API Query Builder

Selezionare

a partire dal

dove

Metodi simili

aderire

sopra

Metodi simili

raggruppa per

avendo

Metodi simili

Ripristina

Classe DBUtil

Orm Toolkit

Creazione di modelli

Configurazione

Creare

Leggere

Aggiornare

Elimina

Esempio di lavoro

Crea un database

Configura il database

Includi pacchetto ORM

Crea modello dipendente

Crea azione

Crea vista

Risultato

Tutorial di FuelPHP