Yii:s frågeverktyg erbjuder en objektorienterad variant för framställning av SQL-frågor. Verktyget möjliggör för utvecklare att använda klassmetoder och propertyn för specificering av de enskilda delarna av en SQL-fråga. Därefter sammanställer verktyget de olika delarna till en giltig SQL-fråga som kan exekveras genom amrop till DAO-metoderna som beskrivs i Data Access Objects. Nedan visas exempel på typisk användning av frågeverktyget för att bygga en SQL SELECT-fråga:
$user = Yii::app()->db->createCommand()
->select('id, username, profile')
->from('tbl_user u')
->join('tbl_profile p', 'u.id=p.user_id')
->where('id=:id', array(':id'=>$id))
->queryRow();
Frågeverktyget kommer bäst till sin rätt när en SQL-fråga behöver komponeras programmatiskt eller baserat på någon villkorlig logik i applikationen. Bland huvudsakliga fördelarna med att använda frågeverktyget ingår:
Det tillåter att komplexa SQL-frågor byggs programmatiskt.
Tabell- och kolumnnamn omsluts automatiskt med med diakritiskt tecken (`) så att konflikt undviks med reserverade ord och specialtecken i SQL.
Även parametervärden omsluts och parameterbindning används när så är möjligt, vilket hjälper till att reducera risken för "SQL injection"-attacker.
Ett visst mått av databasabstraktion erhålls, vilket underlättar migrering till andra databasplattformar.
Det är inte nödvändigt att använda frågeverktyget. Faktum är att enkla frågor lättare och snabbare kan skrivas direkt med SQL-satser.
Märk: Frågeverktyget kan inte användas för att modifiera en existerande fråga, specificerad som en SQL-sats. Följande kod kommer inte att fungera:
$command = Yii::app()->db->createCommand('SELECT * FROM tbl_user'); // Nedanstående rad kommer INTE att lägga till ett WHERE-led till ovanstående SQL $command->where('id=:id', array(':id'=>$id));
Med andra ord, blanda inte renodlad SQL med användning av frågeverktyget.
Yii:s frågeverktyg är relaterat till CDbCommand, den huvudsakliga DB-frågeklassen beskriven i Data Access Objects.
För att börja använda frågeverktyget skapar vi en ny instans av CDbCommand
$command = Yii::app()->db->createCommand();
Det vill säga, vi använder Yii::app()->db
för att erhålla DB-anslutningen och anropar sedan CDbConnection::createCommand()
för att skapa den önskade command-instansen.
Märk att i stället för att lämna med en komplett SQL-sats vid anropet av createCommand()
, så som är brukligt
i Data Access Objects, lämnar vi den tom.
Anledningen till detta är att vi vill bygga enskilda delar av SQL-satsen genom att använda frågeverktygets
metoder, vilka beskrivs nedan.
Datahämtningsfrågor refererar till SQL SELECT-satser. Frågeverktyget erbjuder en uppsättning metoder för att bygga individuella delar av en SELECT-sats. Eftersom alla dessa metoder lämnar CDbCommand-instansen i retur, kan de anropas i en kedja (method chaining), som exemplet i början av detta avsnitt visar.
I fortsättningen nedan förklaras hur man använder dessa frågeverktygets metoder. För enkelhets skull antar vi att den underliggande databasen är MySQL. Märk att om annan DBMS används, kan annorlunda "quoting" av tabell-/kolumnnamn/värden än i exemplen användas.
function select($columns='*')
Metoden select() specificerar SELECT
-delen av en fråga. Parametern $columns
specificerar
vilka kolumner som skall selekteras, antingen som en sträng av kommaseparerade kolumnnamn, eller en vektor
innehållande kolumnnamn. Kolumnnamn kan innehålla tabellprefix ochd/eller kolumnalias. Metoden kommer att
automatiskt omge kolumnnamn med diakritiskt tecken utom då en kolumnspecifikation innehåller parenteser
(vilket innebär att kolumnen angetts som ett DB-uttryck).
Nedan följer några exempel:
// SELECT *
select()
// SELECT `id`, `username`
select('id, username')
// SELECT `tbl_user`.`id`, `username` AS `name`
select('tbl_user.id, username as name')
// SELECT `id`, `username`
select(array('id', 'username'))
// SELECT `id`, count(*) as num
select(array('id', 'count(*) as num'))
function selectDistinct($columns)
Metoden selectDistinct() är snarlik select() förutom att
den aktiverar DISTINCT
-flaggan. Till exempel, selectDistinct('id, username')
kommer att generera följande SQL:
SELECT DISTINCT `id`, `username`
function from($tables)
Metoden from() specificerar FROM
-delen av en fråga. Parametern $tables
specificerar
vilka tabeller selektering skall ske från. Denna kan antingen vara en sträng av kommaseparerade tabellnamn,
eller en vektor innehållande tabellnamn. Tabellnamn kan innehålla schemaprefix (t.ex. public.tbl_user
)
och/eller tabellalias (t.ex. tbl_user u
). Metoden kommer att automatiskt omge tabellnamn med
diakritiskt tecken utom då en tabellspecifikationen innehåller parenteser (vilket innebär att tabellen angetts
som en subfråga eller ett DB-uttryck).
Nedan följer några exempel:
// FROM `tbl_user`
from('tbl_user')
// FROM `tbl_user` `u`, `public`.`tbl_profile` `p`
from('tbl_user u, public.tbl_profile p')
// FROM `tbl_user`, `tbl_profile`
from(array('tbl_user', 'tbl_profile'))
// FROM `tbl_user`, (select * from tbl_profile) p
from(array('tbl_user', '(select * from tbl_profile) p'))
function where($conditions, $params=array())
Metoden where() specificerar WHERE
-delen av en fråga.
Parametern $conditions
specificerar frågevillkor medan $params
specificerar de parameterar som kommer att knytas till den kompletta frågan.
Parametern $conditions
kan ges antingen som en sträng (t.ex. id=1
) eller
som en vektor med följande format:
array(operator, operand1, operand2, ...)
där operator
kan vara något av följande:
and
: operanderna sammanbinds med hjälp av AND
.
Till exempel, array('and', 'id=1', 'id=2')
genererar id=1 AND id=2
.
Om en operand i sin tur ges i form av en vektor, kommer den att konverteras till sträng på samma sätt.
Till exempel, array('and', 'type=1', array('or', 'id=1', 'id=2'))
genererar type=1 AND (id=1 OR id=2)
.
Metoden lägger INTE till "quoting" med diakritiskt tecken, inte heller införs undantag "escaping" av specialteckenkoder.
or
: lika som and
-operatorn förutom att operanderna sammanbinds med OR.
in
: operand 1 skall vara en kolumn eller ett DB-uttryck, operand 2 en vektor som representerar ett intervall
av värden som kolumnen eller DB-uttrycket skall finnas inom.
Till exempel, array('in', 'id', array(1,2,3))
genererar id IN (1,2,3)
.
Metoden omger kolumnnamn med diakritiskt tecken samt inför vid behov undantag (escaping) för specialteckenkoder i range-operanden.
not in
: lika som in
-operatorn förutom att IN
ersätts av NOT IN
i det genererade villkoret.
like
: operand 1 skall vara en kolumn eller ett DB-uttryck, operand 2 en vektor som representerar ett intervall
av värden som kolumnen eller DB-uttrycket skall likna.
Till exempel, array('like', 'name', '%tester%')
genererar name LIKE '%tester%'
.
När intervallet anges som en vektor, kommer flera LIKE
-predikat sammanbundna av AND
att genereras.
Till exempel, array('like', 'name', array('%test%', '%sample%'))
genererar name LIKE '%test%' AND name LIKE '%sample%'
.
Metoden omger kolumnnamn med diakritiskt tecken samt inför vid behov undantag för specialteckenkoder i range-operanden.
not like
: lika som like
-operatorn förutom att LIKE
ersätts av NOT LIKE
i det genererade villkoret.
or like
: lika som like
-operatorn förutom att OR
används vid sammanbindning av flera LIKE
-predikat.
or not like
: lika som not like
-operatorn förutom att OR
används vid sammanbindning av flera NOT LIKE
-predikat.
Nedan följer några exempel på användning av where
:
// WHERE id=1 or id=2
where('id=1 or id=2')
// WHERE id=:id1 or id=:id2
where('id=:id1 or id=:id2', array(':id1'=>1, ':id2'=>2))
// WHERE id=1 OR id=2
where(array('or', 'id=1', 'id=2'))
// WHERE id=1 AND (type=2 OR type=3)
where(array('and', 'id=1', array('or', 'type=2', 'type=3')))
// WHERE `id` IN (1, 2)
where(array('in', 'id', array(1, 2))
// WHERE `id` NOT IN (1, 2)
where(array('not in', 'id', array(1,2)))
// WHERE `name` LIKE '%Qiang%'
where(array('like', 'name', '%Qiang%'))
// WHERE `name` LIKE '%Qiang' AND `name` LIKE '%Xue'
where(array('like', 'name', array('%Qiang', '%Xue')))
// WHERE `name` LIKE '%Qiang' OR `name` LIKE '%Xue'
where(array('or like', 'name', array('%Qiang', '%Xue')))
// WHERE `name` NOT LIKE '%Qiang%'
where(array('not like', 'name', '%Qiang%'))
// WHERE `name` NOT LIKE '%Qiang%' OR `name` NOT LIKE '%Xue%'
where(array('or not like', 'name', array('%Qiang%', '%Xue%')))
Vänligen notera att när operator innehåller like
, behöver vi uttryckligen specificera jokertecken
(så som %
and _
) i mönstren. Om mönstren hämtas från användarinmatning, bör vi även använda
följande kod för att införa undantag för specialteckenkoder och därmed förhindra att de behandlas som jokertecken:
$keyword=$_GET['q'];
// escape % and _ characters
$keyword=strtr($keyword, array('%'=>'\%', '_'=>'\_'));
$command->where(array('like', 'title', '%'.$keyword.'%'));
function order($columns)
Metoden order() specificerar ORDER BY
-delen av en fråga.
Parametern $columns
specificerar kolumnerna att sortera efter, antingen i form av en sträng som representerar
kommaseparerade kolumnnamn samt sorteringsdirektiv (ASC
or DESC
), alternativt en vektor av
kolumnnamn och sorteringsdirektiv. Kolumnnamn kan innehålla tabellprefix. Metoden omger automatiskt kolumnnamn
med diakritiskt tecken förutom när kolumn innehåller parenteser (vilket innebär att kolumn ges i form av ett DB-uttryck).
Nedan följer några exempel:
// ORDER BY `name`, `id` DESC
order('name, id desc')
// ORDER BY `tbl_profile`.`name`, `id` DESC
order(array('tbl_profile.name', 'id desc'))
function limit($limit, $offset=null)
function offset($offset)
Metoderna limit() och offset() specificerar
LIMIT
- och OFFSET
-delarna av en fråga. Lägg märke till att vissa DBMS saknar stöd för LIMIT
- och OFFSET
-syntax.
I sådant fall skriver frågeverktyget om SQL-satsen för simulering av funktionaliteten hos limit och offset.
Nedan följer några exempel:
// LIMIT 10
limit(10)
// LIMIT 10 OFFSET 20
limit(10, 20)
// OFFSET 20
offset(20)
function join($table, $conditions, $params=array())
function leftJoin($table, $conditions, $params=array())
function rightJoin($table, $conditions, $params=array())
function crossJoin($table)
function naturalJoin($table)
Metoden join() och dess varianter specificerar sammanfogning med andra tabeller
med hjälp av INNER JOIN
, LEFT OUTER JOIN
, RIGHT OUTER JOIN
, CROSS JOIN
, eller NATURAL JOIN
.
Parametern $table
specificerar tabellen med vilken sammanfogning skall ske. Tabellnamnet kan innehålla
schemaprefix och/eller alias. Metoden kommer att automatiskt omge tabellnamnet med
diakritiskt tecken utom då en det innehåller parenteser, vilket innebär en subfråga eller ett DB-uttryck.
Parametern $conditions
specificerar villkor för sammanfogningen. Dess syntax är samma som för where().
Och $params
specificerar de parametrar som skall knytas till den kompletta frågan.
Till skillnad från frågeverktygets övriga metoder, medför varje nytt anrop till en join-metod att dess resultat kommer att läggas till efter de tidigare.
Nedan följer några exempel:
// JOIN `tbl_profile` ON user_id=id
join('tbl_profile', 'user_id=id')
// LEFT JOIN `pub`.`tbl_profile` `p` ON p.user_id=id AND type=1
leftJoin('pub.tbl_profile p', 'p.user_id=id AND type=:type', array(':type'=>1))
function group($columns)
Metoden group() specificerar GROUP BY
-delen av en fråga.
Parametern $columns
specificerar kolumnerna att gruppindela efter, i strängformat representerande
kommaseparerade kolumnnamn, alternativt som motsvarande vektor. Kolumnnamn kan innehålla tabellprefix.
Metoden kommer att automatiskt omge kolumnnamn med diakritiskt tecken utom då en kolumnspecifikationen innehåller parenteser
(vilket innebär att kolumnen angetts som en subfråga eller ett DB-uttryck).
Nedan följer några exempel:
// GROUP BY `name`, `id`
group('name, id')
// GROUP BY `tbl_profile`.`name`, `id`
group(array('tbl_profile.name', 'id')
function having($conditions, $params=array())
Metoden having() specificerar HAVING
-delen av en fråga. Dess användning
har likhet med where().
Nedan följer några exempel:
// HAVING id=1 or id=2
having('id=1 or id=2')
// HAVING id=1 OR id=2
having(array('or', 'id=1', 'id=2'))
function union($sql)
Metoden union() specificerar UNION
-delen av en fråga. Den lägger till $sql
till existerande SQL genom användning av operatorn UNION
. Anrop av union()
upprepade gånger kommer att
lägga till flera SQL-led efter existerande SQL.
Nedan följer några exempel:
// UNION (select * from tbl_profile)
union('select * from tbl_profile')
När en fråga byggts genom anrop till frågeverktygets metoder enligt ovan, kan vi anropa DAO-metoderna som beskrivs i Data Access Objects, så att frågan exekveras. Till exempel, kan vi anropa CDbCommand::queryRow() för att erhålla en enda rad som resultat, alternativt CDbCommand::queryAll() för att erhålla samtliga rader tillsammans.
Exempel:
$users = Yii::app()->db->createCommand()
->select('*')
->from('tbl_user')
->queryAll();
Förutom att exekvera en fråga som byggts med frågeverktyget, kan vi även hämta den motsvarande SQL-satsen. Detta kan ske genom anrop av CDbCommand::getText().
$sql = Yii::app()->db->createCommand()
->select('*')
->from('tbl_user')
->text;
Om det finns parametrar som skall knytas till frågan, kan dessa hämtas via propertyn CDbCommand::params.
Ibland är användning av metodkedja (method chaining) för att bygga en fråga inte det optimala valet.
Yii:s frågeverktyg tillåter att man bygger en fråga genom att helt enkelt tilldela värden till ett objekts propertyn.
Specifikt finns för varje metod i frågeverktyget en motsvarande property med samma namn. Tilldelning av ett värde
till propertyn är ekvivalent med att anropa motsvarande metod. Till exempel så är följande två uttryck ekvivalenta,
förutsatt att $command
representerar ett CDbCommand-objekt:
$command->select(array('id', 'username'));
$command->select = array('id', 'username');
Dessutom kan metoden CDbConnection::createCommand() acceptera en vektor som parameter. Namn-värdeparen i vektorn kommer att användas till att initialisera CDbCommand-instansens propertyn. Detta innebär att vi kan använda följande kod för att bygga en fråga:
$row = Yii::app()->db->createCommand(array(
'select' => array('id', 'username'),
'from' => 'tbl_user',
'where' => 'id=:id',
'params' => array(':id'=>1),
))->queryRow();
En CDbCommand-instans kan återanvändas flera gånger för att bygga ytterligare frågor. Innan en ny fråga byggs behöver dock metoden CDbCommand::reset() anropas för att städa efter föregående fråga.
Till exempel:
$command = Yii::app()->db->createCommand();
$users = $command->select('*')->from('tbl_users')->queryAll();
$command->reset(); // clean up the previous query
$posts = $command->select('*')->from('tbl_posts')->queryAll();
Datamanipuleringsfrågor refererar till SQL-satser för insättning, uppdatering och borttagning av data i en databastabell.
Som motsvarighet till dessa frågor tillhandahåller frågeverktyget metoderna insert
, update
och delete
.
Till skillnad från SELECT-frågemetoderna som beskrivits ovan, bygger var och en av frågemetoderna för datamanipulering
en komplett SQL-sats och exekverar den omedelbart.
Nedan beskrivs dessa frågemetoder för datamanipulering.
function insert($table, $columns)
Metoden insert() bygger och exekverar en SQL INSERT
-sats.
Parametern $table
specificerar vilken tabell att infoga i, medan $columns
är en vektor
innehållande namn-värdepar som specificerar vilka kolumnvärden som skall infogas.
Metoden kommer att korrekt omge tabellnamn med diakritiskt tecken samt använda parameterbindning
för värden som skall infogas.
Nedan följer ett exempel:
// bygg och exekvera följande SQL:
// INSERT INTO `tbl_user` (`name`, `email`) VALUES (:name, :email)
$command->insert('tbl_user', array(
'name'=>'Tester',
'email'=>'tester@example.com',
));
function update($table, $columns, $conditions='', $params=array())
Metoden update() bygger och exekverar en SQL UPDATE
-sats.
Parametern $table
specificerar vilken tabell som skall uppdateras; $columns
är en vektor
innehållande namn-värdepar som specificerar vilka kolumnvärden som skall uppdateras;
$conditions
och $params
specificerar, precis som i where(), WHERE
-ledet i UPDATE
-satsen.
Metoden kommer att korrekt omge tabellnamn med diakritiskt tecken samt använda parameterbindning
för värden som skall uppdateras.
Nedan följer ett exempel:
// bygg och exekvera följande SQL:
// UPDATE `tbl_user` SET `name`=:name WHERE id=:id
$command->update('tbl_user', array(
'name'=>'Tester',
), 'id=:id', array(':id'=>1));
function delete($table, $conditions='', $params=array())
Metoden delete() bygger och exekverar en SQL DELETE
-sats.
Parametern $table
specificerar tabell att ta bort från; $conditions
och $params
specificerar, precis som i where(), WHERE
-ledet i
DELETE
-satsen. Metoden kommer att korrekt omge tabellnamn med diakritiskt tecken.
Nedan följer ett exempel:
// bygg och exekvera följande SQL:
// DELETE FROM `tbl_user` WHERE id=:id
$command->delete('tbl_user', 'id=:id', array(':id'=>1));
Förutom vanliga frågor som hämtar eller manipulerar data, erbjuder frågeverktyget även en uppsättning metoder som bygger och exekverar SQL-frågor som kan manipulera schema i en databas. Mer specifikt erbjuds stöd för följande frågor:
Info: Även om de faktiska SQL-satserna för schemamanipulering varierar en hel del mellan olika databashanterare (DBMS), försöker frågeverktyget att erbjuda ett enhetligt gränssnitt för att bygga dessa frågor. Detta förenklar uppgiften att flytta en databas från en DBMS till en annan.
Frågeverktyget introducerar en uppsättning abstrakta datatyper som kan användas till att definiera tabellkolumner. Till skillnad från de fysiska datatyperna som är specifika för enskilda DBMS och skiljer sig åt mellan olika DBMS, är de abstrakta datatyperna DBMS-oberoende. När abstrakta datatyper används till att definiera tabellkolumner, kommer frågeverktyget att konvertera till motsvarande fysiska datatyper.
Följande abstrakta datatyper stöds av frågeverktyget.
pk
: en generell primärnyckeltyp, konverteras till int(11) NOT NULL AUTO_INCREMENT PRIMARY KEY
för MySQL;string
: strängtyp, konverteras till varchar(255)
för MySQL;text
: texttyp (long string), konverteras till text
för MySQL;integer
: heltalstyp, konverteras till int(11)
för MySQL;float
: flyttalstyp, konverteras till float
för MySQL;decimal
: decimaltal, konverteras till decimal
för MySQL;datetime
: datumtid, konverteras till datetime
för MySQL;timestamp
: tidstämpel, konverteras till timestamp
för MySQL;time
: klockslag, konverteras till time
för MySQL;date
: datum, konverteras till date
för MySQL;binary
: binärdata, konverteras till blob
för MySQL;boolean
: boolsk data, konverteras till tinyint(1)
för MySQL;money
: monetär/valuta-data, konverteras till decimal(19,4)
för MySQL. Denna typ har varit tillgänglig sedan version 1.1.8.function createTable($table, $columns, $options=null)
Metoden createTable() bygger och exekverar en SQL-sats som skapar en tabell.
Parametern $table
specificerar namnet på tabellen som skall skapas. Parametern $columns
specificerar
kolumnerna i den nya tabellen. De måste anges i form av namn-definitionspar (t.ex. 'username'=>'string'
).
Parametern $options
specificerar möjliga extra SQL-fragment som skall följa på genererad SQL.
Metoden kommer att korrekt omge tabellnamn och kolumnnamn med diakritiskt tecken.
Vid specificering av kolumndefinition kan man använda en abstrakt datatyp som beskrivits ovan.
Frågeverktyget kommer att konvertera den abstrakta datatypen till motsvarande fysiska datatyp,
givet vilken DBMS som för tillfället används. Till exempel för MySQL, kommer string
att
konverteras till varchar(255)
.
En kolumndefinition kan även innehålla icke-abstrakta datatyper eller specifikationer. De kommer att
infogas i genererad SQL utan ändring. Till exempel point
, som inte är en abstrakt datatyp kommer,
om den används i en kolumndefinition, att uppträda oförändrad i resulterande SQL; string NOT NULL
kommer att konverteras till varchar(255) NOT NULL
(dvs endast den abstrakta typen string
konverteras).
Nedan följer ett exempel på hur man skapar en tabell:
// CREATE TABLE `tbl_user` (
// `id` int(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
// `username` varchar(255) NOT NULL,
// `location` point
// ) ENGINE=InnoDB
createTable('tbl_user', array(
'id' => 'pk',
'username' => 'string NOT NULL',
'location' => 'point',
), 'ENGINE=InnoDB')
function renameTable($table, $newName)
Metoden renameTable() bygger och exekverar en SQL-sats som ändrar
namnet på en tabell. Parametern $table
specificerar namnet på tabellen som skall namnändras.
Parametern $newName
specificerar det nya tabellnamnet. Frågeverktyget kommer att korrekt
omge tabellnamnen med diakritiskt tecken.
Nedan följer ett exempel som visar hur man ändrar namn på en tabell:
// RENAME TABLE `tbl_users` TO `tbl_user`
renameTable('tbl_users', 'tbl_user')
function dropTable($table)
Metoden dropTable() bygger och exekverar en SQL-sats som tar bort en tabell.
Parametern $table
specificerar namnet på tabellen som skall tas bort. Frågeverktyget kommer att
korrekt omge tabellnamnet med diakritiskt tecken.
Nedan följer ett exempel på hur man tar bort en tabell:
// DROP TABLE `tbl_user`
dropTable('tbl_user')
function truncateTable($table)
Metoden truncateTable() bygger och exekverar en SQL-sats som tar bort
allt innehåll ur en tabell. Parametern $table
specificerar namnet på tabellen som skall tömmas.
Frågeverktyget kommer att korrekt omge tabellnamnet med diakritiskt tecken.
Nedan följer ett exempel på hur man tömmer en tabell på innehåll:
// TRUNCATE TABLE `tbl_user`
truncateTable('tbl_user')
function addColumn($table, $column, $type)
Metoden addColumn() bygger och exekverar en SQL-sats som lägger till en ny
tabellkolumn. Parametern $table
specificerar namnet på tabellen som en ny kolumn skall tillfogas.
Parametern $column
specificerar namnet på den nya kolumnen. Och $type
specificerar definitionen
för den nya kolumnen. En kolumndefinition kan innehålla abstrakt datatyp, som beskrivits i avsnittet
om "createTable". Frågeverktyget kommer att korrekt omge tabellnamn och kolumnnamn med diakritiskt tecken.
Nedan följer ett exempel på hur man lägger till en kolumn:
// ALTER TABLE `tbl_user` ADD `email` varchar(255) NOT NULL
addColumn('tbl_user', 'email', 'string NOT NULL')
function dropColumn($table, $column)
Metoden dropColumn() bygger och exekverar en SQL-sats som tar bort en
tabellkolumn. Parametern $table
specificerar namnet på tabellen ur vilken en kolumn skall tas bort.
Parametern $column
specificerar namnet på kolumnen som skall tas bort. Frågeverktyget kommer
att korrekt omge tabellnamn och kolumnnamn med diakritiskt tecken.
Nedan följer ett exempel på hur man tar bort en kolumn:
// ALTER TABLE `tbl_user` DROP COLUMN `location`
dropColumn('tbl_user', 'location')
function renameColumn($table, $name, $newName)
Metoden renameColumn() bygger och exekverar en SQL-sats som ändrar namn
på en tabellkolumn. Parametern $table
specificerar namnet på tabellen vars kolumn skall byta namn.
Parametern $name
specificerar det befintliga kolumnnamnet. $newName
specificerar önskat kolumnnamn.
Frågeverktyget kommer att korrekt omge tabellnamn och kolumnnamn med diakritiskt tecken.
Nedan följer ett exempel på hur man ändrar en kolumns namn:
// ALTER TABLE `tbl_users` CHANGE `name` `username` varchar(255) NOT NULL
renameColumn('tbl_user', 'name', 'username')
function alterColumn($table, $column, $type)
Metoden alterColumn() bygger och exekverar en SQL-sats som ändrar definition
för en tabellkolumn. Parametern $table
specificerar namnet på tabellen vars kolumndefinition skall ändras.
Parametern $column
specificerar namnet på kolumnen som skall ändras. Och $type
specificerar den nya
kolumndefinitionen. En kolumndefinition kan innehålla abstrakt datatyp, så som beskrivits tidigare för
"createTable". Frågeverktyget kommer att korrekt omge tabellnamn och kolumnnamn med diakritiskt tecken.
Nedan följer ett exempel på hur man ändrar specifikation för en kolumn:
// ALTER TABLE `tbl_user` CHANGE `username` `username` varchar(255) NOT NULL
alterColumn('tbl_user', 'username', 'string NOT NULL')
function addForeignKey($name, $table, $columns,
$refTable, $refColumns, $delete=null, $update=null)
Metoden addForeignKey() bygger och exekverar en SQL-sats som lägger till
ett integritetsvillkor (constraint) till en tabell. Parametern $name
specificerar namnet på villkoret.
Parametrarna $table
och $columns
specificerar tabell- och kolumnnamn för referensattributet (FK).
Vid flera kolumner skall dessa separeras med kommatecken. Parametrarna $refTable
och $refColumns
specificerar tabell- och kolumnnamn som referensattributet refererar till. Parametrarna $delete
och
$update
specificerar alternativenON DELETE
och ON UPDATE
i SQL-satsen. De flesta databashanterare
stöder följande alternativ: RESTRICT
, CASCADE
, NO ACTION
, SET DEFAULT
, SET NULL
.
Frågeverktyget kommer att korrekt omge tabellnamn, indexnamn och kolumnnamn med diakritiskt tecken.
Nedan följer ett exempel på hur man skapar en restriktion för referensattribut:
// ALTER TABLE `tbl_profile` ADD CONSTRAINT `fk_profile_user_id`
// FOREIGN KEY (`user_id`) REFERENCES `tbl_user` (`id`)
// ON DELETE CASCADE ON UPDATE CASCADE
addForeignKey('fk_profile_user_id', 'tbl_profile', 'user_id',
'tbl_user', 'id', 'CASCADE', 'CASCADE')
function dropForeignKey($name, $table)
Metoden dropForeignKey() bygger och exekverar en SQL-sats som tar bort ett
integritetsvillkor. Parametern $name
specificerar namnet på det villkor som skall tas bort.
Parametern $table
specificerar namnet på tabellen som innehåller villkoret. Frågeverktyget kommer
att korrekt omge tabellnamnet och villkorsnamnet med diakritiskt tecken.
Nedan följer ett exempel på hur man tar bort en restriktion för referensattribut:
// ALTER TABLE `tbl_profile` DROP FOREIGN KEY `fk_profile_user_id`
dropForeignKey('fk_profile_user_id', 'tbl_profile')
function createIndex($name, $table, $column, $unique=false)
Metoden createIndex() bygger och exekverar en SQL-sats som skapar ett index.
Parametern $name
specificerar namn på det index som skall skapas. Parametern $table
specificerar
namnet på tabellen som indexet skall tillhöra. Parametern $column
specificerar namnet på kolumnen
som skall indexeras. Och parametern $unique
specificerar huruvida ett unikt index skall skapas.
Om indexet består av flera kolumner, måste dessa separeras med kommatecken.
Frågeverktyget kommer att korrekt omge tabellnamn, indexnamn och kolumnnamn med diakritiskt tecken.
Nedan följer ett exempel på hur man skapar ett index:
// CREATE INDEX `idx_username` ON `tbl_user` (`username`)
createIndex('idx_username', 'tbl_user')
function dropIndex($name, $table)
Metoden dropIndex() bygger och exekverar en SQL-sats som tar bort ett index.
Parametern $name
specificerar namn för indexet som skall tas bort. Parametern $table
specificerar
namnet på tabellen som indexet tillhör. Frågeverktyget kommer att korrekt omge tabellnamn och indexnamn
med diakritiskt tecken.
Nedan följer ett exempel på hur man tar bort ett index:
// DROP INDEX `idx_username` ON `tbl_user`
dropIndex('idx_username', 'tbl_user')
Found a typo or you think this page needs improvement?
Edit it on github !
Signup or Login in order to comment.