MariaDB - Guida rapida

Un'applicazione di database esiste separata dall'applicazione principale e memorizza le raccolte di dati. Ogni database utilizza una o più API per la creazione, l'accesso, la gestione, la ricerca e la replica dei dati in esso contenuti.

I database utilizzano anche origini dati non relazionali come oggetti o file. Tuttavia, i database si dimostrano l'opzione migliore per set di dati di grandi dimensioni, che soffrirebbero di un lento recupero e scrittura con altre origini dati.

I sistemi di gestione dei database relazionali, o RDBMS, memorizzano i dati in varie tabelle.Le relazioni tra queste tabelle vengono stabilite utilizzando chiavi primarie e chiavi esterne.

RDBMS offre le seguenti funzionalità:

• Consentono di implementare un'origine dati con tabelle, colonne e indici.

• Garantiscono l'integrità dei riferimenti tra le righe di più tabelle.

• Aggiornano automaticamente gli indici.

• Interpretano le query e le operazioni SQL nella manipolazione o nel reperimento di dati dalle tabelle.

Terminologia RDBMS

Prima di iniziare la nostra discussione su MariaDB, esaminiamo alcuni termini relativi ai database.

• Database - Un database è un'origine dati composta da tabelle che contengono dati correlati.

• Table - Una tabella, ovvero un foglio di calcolo, è una matrice contenente dati.

• Column- Una colonna, che significa elemento di dati, è una struttura che contiene dati di un tipo; ad esempio, le date di spedizione.

• Row- Una riga è una struttura che raggruppa i dati correlati; ad esempio, dati per un cliente. È anche noto come tupla, voce o record.

• Redundancy - Questo termine si riferisce alla memorizzazione dei dati due volte per accelerare il sistema.

• Primary Key- Si riferisce a un valore univoco e identificativo. Questo valore non può apparire due volte all'interno di una tabella ed è associata solo una riga.

• Foreign Key - Una chiave esterna funge da collegamento tra due tabelle.

• Compound Key- Una chiave composta, o chiave composta, è una chiave che fa riferimento a più colonne. Si riferisce a più colonne a causa di una colonna priva di una qualità unica.

• Index - Un indice è praticamente identico all'indice di un libro.

• Referential Integrity - Questo termine si riferisce alla garanzia che tutti i valori delle chiavi esterne puntino a righe esistenti.

Database MariaDB

MariaDB è un popolare fork di MySQL creato dagli sviluppatori originali di MySQL. Nasce dalle preoccupazioni legate all'acquisizione di MySQL da parte di Oracle. Offre supporto sia per piccole attività di elaborazione dati che per esigenze aziendali. Vuole essere un sostituto immediato di MySQL che richiede solo una semplice disinstallazione di MySQL e un'installazione di MariaDB. MariaDB offre le stesse funzionalità di MySQL e molto altro ancora.

Caratteristiche principali di MariaDB

Le caratteristiche importanti di MariaDB sono:

• Tutto MariaDB è sotto GPL, LGPL o BSD.

• MariaDB include un'ampia selezione di motori di archiviazione, inclusi motori di archiviazione ad alte prestazioni, per lavorare con altre origini dati RDBMS.

• MariaDB utilizza un linguaggio di query standard e popolare.

• MariaDB funziona su una serie di sistemi operativi e supporta un'ampia varietà di linguaggi di programmazione.

• MariaDB offre supporto per PHP, uno dei linguaggi di sviluppo web più popolari.

• MariaDB offre la tecnologia dei cluster Galera.

• MariaDB offre anche molte operazioni e comandi non disponibili in MySQL ed elimina / sostituisce le funzionalità che incidono negativamente sulle prestazioni.

Iniziare

Prima di iniziare questo tutorial, assicurati di avere una conoscenza di base di PHP e HTML, in particolare il materiale discusso nei nostri tutorial PHP e HTML.

Questa guida si concentra sull'uso di MariaDB in un ambiente PHP, quindi i nostri esempi saranno molto utili per gli sviluppatori PHP.

Consigliamo vivamente di rivedere il nostro Tutorial PHP se non hai familiarità o hai bisogno di rivedere.

Tutti i download per MariaDB si trovano nella sezione Download del sito web ufficiale della fondazione MariaDB. Fare clic sul collegamento alla versione desiderata e verrà visualizzato un elenco di download per più sistemi operativi, architetture e tipi di file di installazione.

Installazione su LINUX / UNIX

Se hai una conoscenza approfondita dei sistemi Linux / Unix, scarica semplicemente il sorgente per creare la tua installazione. Il nostro metodo di installazione consigliato è utilizzare i pacchetti di distribuzione. MariaDB offre pacchetti per le seguenti distribuzioni Linux / Unix:

• RedHat/CentOS/Fedora
• Debian/Ubuntu

Le seguenti distribuzioni includono un pacchetto MariaDB nei loro repository:

• openSUSE
• Arch Linux
• Mageia
• Mint
• Slackware

Segui questi passaggi per installare in un ambiente Ubuntu:

Step 1 - Accedi come utente root.

Step 2 - Accedi alla directory contenente il pacchetto MariaDB.

Step 3 - Importa la chiave di firma di GnuPG con il codice seguente -

sudo apt-key adv --recv-keys --keyserver keyserver.ubuntu.com 0xcbcb082a1bb943db

Step 4 - Aggiungi MariaDB al file sources.listfile. Apri il file e aggiungi il codice seguente:

sudo add-apt-repository 'deb http://ftp.osuosl.org/pub/mariadb/repo/5.5/ubuntuprecise main'

Step 5 - Aggiorna il sistema con quanto segue -

sudo apt-get update

Step 6 - Installa MariaDB con quanto segue -

sudo apt-get install mariadb-server

Installazione su Windows

Dopo aver individuato e scaricato un file di installazione automatica (MSI), fare semplicemente doppio clic sul file per avviare l'installazione. La procedura guidata di installazione ti guiderà attraverso ogni fase dell'installazione e tutte le impostazioni necessarie.

Testare l'installazione avviandola dal prompt dei comandi. Accedere al percorso dell'installazione, in genere nella directory, e digitare quanto segue al prompt:

mysqld.exe --console

Se l'installazione ha esito positivo, verranno visualizzati messaggi relativi all'avvio. Se non viene visualizzato, potresti avere problemi di autorizzazione. Assicurati che il tuo account utente possa accedere all'applicazione. I client grafici sono disponibili per l'amministrazione di MariaDB nell'ambiente Windows. Se trovi la riga di comando scomoda o ingombrante, assicurati di sperimentarli.

Verifica dell'installazione

Eseguire alcune semplici operazioni per confermare il funzionamento e l'installazione di MariaDB.

Use the Admin Utility to Get Server Status

Visualizza la versione del server con il binario mysqladmin.

[root@host]# mysqladmin --version

Dovrebbe visualizzare la versione, la distribuzione, il sistema operativo e l'architettura. Se non vedi l'output di quel tipo, esamina la tua installazione per problemi.

Execute Simple Commands with a Client

Apri il prompt dei comandi per MariaDB. Questo dovrebbe connetterti a MariaDB e consentire l'esecuzione dei comandi. Immettere un semplice comando come segue:

mysql> SHOW DATABASES;

Post installazione

Dopo aver installato correttamente MariaDB, impostare una password di root. Una nuova installazione avrà una password vuota. Immettere quanto segue per impostare la nuova password:

mysqladmin -u root password "[enter your password here]";

Immettere quanto segue per connettersi al server con le nuove credenziali:

mysql -u root -p
Enter password:*******

Aggiornamento su Windows

Se hai già MySQL installato sul tuo sistema Windows e desideri eseguire l'aggiornamento a MariaDB; non disinstallare MySQL e installare MariaDB. Ciò causerà un conflitto con il database esistente. Devi invece installare MariaDB e quindi utilizzare la procedura guidata di aggiornamento nel file di installazione di Windows.

Le opzioni del tuo file MySQL my.cnf dovrebbero funzionare con MariaDB. Tuttavia, MariaDB ha molte funzionalità, che non si trovano in MySQL.

Considera i seguenti conflitti nel tuo file my.cnf:

• MariaDB utilizza il motore di archiviazione Aria per impostazione predefinita per i file temporanei. Se si dispone di molti file temporanei, modificare la dimensione del buffer delle chiavi se non si utilizzano tabelle MyISAM.

• Se le tue applicazioni si connettono / disconnettono frequentemente, modifica la dimensione della cache del thread.

• Se utilizzi più di 100 connessioni, utilizza il pool di thread.

Compatibilità

MySQL e MariaDB sono essenzialmente identici. Tuttavia, ci sono differenze sufficienti per creare problemi nell'aggiornamento. Rivedi altre di queste differenze chiave nella Knowledge Base di MariaDB.

Prima di tentare di eseguire MariaDB, determinarne lo stato corrente, in esecuzione o in arresto. Ci sono tre opzioni per avviare e arrestare MariaDB:

• Esegui mysqld (il binario MariaDB).
• Esegui lo script di avvio mysqld_safe.
• Esegui lo script di avvio mysql.server.

Se hai installato MariaDB in una posizione non standard, potresti dover modificare le informazioni sulla posizione nei file di script. Arrestare MariaDB semplicemente aggiungendo un parametro "stop" con lo script.

Se desideri avviarlo automaticamente sotto Linux, aggiungi gli script di avvio al tuo file initsistema. Ogni distribuzione ha una procedura diversa. Fare riferimento alla documentazione del sistema.

Creazione di un account utente

Crea un nuovo account utente con il seguente codice:

CREATE USER 'newusername'@'localhost' IDENTIFIED BY 'userpassword';

Questo codice aggiunge una riga alla tabella utente senza privilegi. Hai anche la possibilità di utilizzare un valore hash per la password. Concedi all'utente i privilegi con il codice seguente:

GRANT SELECT, INSERT, UPDATE, DELETE ON database1 TO 'newusername'@'localhost';

Altri privilegi includono quasi ogni comando o operazione possibile in MariaDB. Dopo aver creato un utente, eseguire un comando "FLUSH PRIVILEGES" per aggiornare le tabelle di concessione. Ciò consente di utilizzare l'account utente.

Il file di configurazione

Dopo una build su Unix / Linux, il file di configurazione "/etc/mysql/my.cnf" dovrebbe essere modificato in modo che appaia come segue:

# Example mysql config file.
# You can copy this to one of:
# /etc/my.cnf to set global options,
# /mysql-data-dir/my.cnf to get server specific options or
# ~/my.cnf for user specific options.

#

# One can use all long options that the program supports.
# Run the program with --help to get a list of available options

# This will be passed to all mysql clients
[client]
#password = my_password
#port = 3306
#socket = /tmp/mysql.sock

# Here is entries for some specific programs
# The following values assume you have at least 32M ram

# The MySQL server
[mysqld]
#port = 3306
#socket = /tmp/mysql.sock
temp-pool

# The following three entries caused mysqld 10.0.1-MariaDB (and possibly other
   versions) to abort...
# skip-locking
# set-variable = key_buffer = 16M
# set-variable = thread_cache = 4

loose-innodb_data_file_path = ibdata1:1000M
loose-mutex-deadlock-detector
gdb

######### Fix the two following paths

# Where you want to have your database
data = /path/to/data/dir

# Where you have your mysql/MariaDB source + sql/share/english
language = /path/to/src/dir/sql/share/english

[mysqldump]
quick
MariaDB
8
set-variable = max_allowed_packet=16M
[mysql]
no-auto-rehash

[myisamchk]
set-variable = key_buffer = 128M

Modifica le righe "data =" e "language =" in modo che corrispondano al tuo ambiente.

Dopo la modifica del file, accedere alla directory di origine ed eseguire quanto segue:

./scripts/mysql_install_db --srcdir = $PWD --datadir = /path/to/data/dir -- user = $LOGNAME

Ometti il ​​"$PWD” variable if you added datadir to the configuration file. Ensure “$LOGNAME "viene utilizzato quando si esegue la versione 10.0.1 di MariaDB.

Comandi di amministrazione

Rivedi il seguente elenco di comandi importanti che utilizzerai regolarmente quando lavori con MariaDB -

• USE [database name] - Imposta il database predefinito corrente.

• SHOW DATABASES - Elenca i database attualmente sul server.

• SHOW TABLES - Elenca tutte le tabelle non temporanee.

• SHOW COLUMNS FROM [table name] - Fornisce le informazioni sulle colonne relative alla tabella specificata.

• SHOW INDEX FROM TABLENAME [table name] - Fornisce informazioni sull'indice della tabella relative alla tabella specificata.

• SHOW TABLE STATUS LIKE [table name]\G – - Fornisce tabelle con informazioni sulle tabelle non temporanee e il modello visualizzato dopo la clausola LIKE viene utilizzato per recuperare i nomi delle tabelle.

MariaDB collabora bene con un'ampia varietà di linguaggi di programmazione e framework come PHP, C #, JavaScript, Ruby on Rails, Django e altri. PHP rimane il più popolare di tutti i linguaggi disponibili grazie alla sua semplicità e impronta storica. Questa guida si concentrerà su PHP in collaborazione con MariaDB.

PHP fornisce una selezione di funzioni per lavorare con il database MySQL. Queste funzioni eseguono attività come accedervi o eseguire operazioni e sono completamente compatibili con MariaDB. Chiama semplicemente queste funzioni come chiameresti qualsiasi altra funzione PHP.

Le funzioni PHP che utilizzerai per MariaDB sono conformi al seguente formato:

mysql_function(value,value,...);

La seconda parte della funzione specifica la sua azione. Due delle funzioni utilizzate in questa guida sono le seguenti:

mysqli_connect($connect); mysqli_query($connect,"SQL statement");

L'esempio seguente mostra la sintassi generale di una chiamata PHP a una funzione MariaDB -

<html>
   <head>
      <title>PHP and MariaDB</title>
   </head>

   <body>
      <?php
         $retval = mysql_function(value, [value,...]); if( !$retval ) {
            die ( "Error: Error message here" );
         }
         // MariaDB or PHP Statements
      ?>
   </body>
</html>

Nella prossima sezione, esamineremo le attività essenziali di MariaDB, utilizzando le funzioni PHP.

Un modo per stabilire una connessione con MariaDB consiste nell'usare il binario mysql al prompt dei comandi.

Binario MYSQL

Rivedi un esempio fornito di seguito.

[root@host]# mysql -u root -p

Enter password:******

Il codice sopra riportato si connette a MariaDB e fornisce un prompt dei comandi per eseguire i comandi SQL. Dopo aver inserito il codice, dovrebbe apparire un messaggio di benvenuto che indica una connessione riuscita, con il numero di versione visualizzato.

Welcome to the MariaDB monitor. Commands end with ; or \g. 
Your MariaDB connection id is 122323232 
Server version: 5.5.40-MariaDB-log
  
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.  
mysql>

L'esempio utilizza l'accesso root, ma qualsiasi utente con privilegi può ovviamente accedere al prompt di MariaDB ed eseguire operazioni.

Disconnettiti da MariaDB tramite exit comando come segue -

mysql> exit

Script di connessione PHP

Un altro modo per connettersi e disconnettersi da MariaDB consiste nell'impiegare uno script PHP. PHP fornisce l'estensionemysql_connect()funzione per l'apertura di una connessione al database. Utilizza cinque parametri opzionali e restituisce un identificatore di collegamento MariaDB dopo una connessione riuscita o un falso in caso di connessione non riuscita. Fornisce anche l'estensionemysql_close() funzione per la chiusura delle connessioni al database, che utilizza un singolo parametro.

Sintassi

Rivedere la seguente sintassi dello script di connessione PHP:

connection mysql_connect(server,user,passwd,new_link,client_flag);

Di seguito la descrizione dei parametri:

Suor n	Parametro e descrizione
1	server Questo parametro facoltativo specifica il nome host che esegue il server database. Il suo valore predefinito è "localhost: .3036".
2	user Questo parametro facoltativo specifica il nome utente che accede al database. Il suo valore predefinito è il proprietario del server.
3	passwd Questo parametro facoltativo specifica la password dell'utente. Il suo valore predefinito è vuoto.
4	new_link Questo parametro facoltativo lo specifica in una seconda chiamata a mysql_connect() con argomenti identici, invece di una nuova connessione, verrà restituito l'identificatore della connessione corrente.
5	client flags Questo parametro facoltativo utilizza una combinazione dei seguenti valori costanti: MYSQL_CLIENT_SSL - Utilizza la crittografia ssl. MYSQL_CLIENT_COMPRESS - Utilizza il protocollo di compressione. MYSQL_CLIENT_IGNORE_SPACE - Consente lo spazio dopo i nomi delle funzioni. MYSQL_CLIENT_INTERACTIVE - Consente timeout interattivi secondi di inattività prima di chiudere la connessione.

Rivedere la sintassi dello script di disconnessione PHP fornita di seguito -

bool mysql_close ( resource $link_identifier );

Se ometti la risorsa, la risorsa aperta più di recente verrà chiusa. Restituisce un valore true in caso di chiusura riuscita o false.

Prova il seguente codice di esempio per connetterti a un server MariaDB:

<html>
   <head>
      <title>Connect to MariaDB Server</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'guest1'; $dbpass = 'guest1a';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
      
         if(! $conn ) { die('Could not connect: ' . mysql_error()); } echo 'Connected successfully'; mysql_close($conn);
      ?>
   </body>
</html>

In caso di connessione riuscita, vedrai il seguente output:

mysql> Connected successfully

La creazione o l'eliminazione di database in MariaDB richiede privilegi generalmente concessi solo agli utenti root o agli amministratori. Sotto questi account, hai due opzioni per creare un database: il binario mysqladmin e uno script PHP.

binario mysqladmin

Il seguente esempio dimostra l'uso del binario mysqladmin nella creazione di un database con il nome Products -

[root@host]# mysqladmin -u root -p create PRODUCTS
Enter password:******

PHP Crea script database

PHP utilizza l'estensione mysql_queryfunzione nella creazione di un database MariaDB. La funzione utilizza due parametri, uno opzionale, e restituisce un valore "true" in caso di successo o "false" quando non lo è.

Sintassi

Controlla quanto segue create database script sintassi -

bool mysql_query( sql, connection );

Di seguito la descrizione dei parametri:

S.No	Parametro e descrizione
1	sql Questo parametro obbligatorio è costituito dalla query SQL necessaria per eseguire l'operazione.
2	connection Quando non specificato, questo parametro facoltativo utilizza la connessione più recente utilizzata.

Prova il seguente codice di esempio per creare un database:

<html>
   <head>
      <title>Create a MariaDB Database</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036'; $dbuser = 'root';
         $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }

         echo 'Connected successfully<br />';
         $sql = 'CREATE DATABASE PRODUCTS'; $retval = mysql_query( $sql, $conn );
      
         if(! $retval ) { die('Could not create database: ' . mysql_error()); } echo "Database PRODUCTS created successfully\n"; mysql_close($conn);
      ?>
   </body>
</html>

In caso di eliminazione riuscita, vedrai il seguente output:

mysql> Database PRODUCTS created successfully 
mysql> SHOW DATABASES; 
+-----------------------+ 
| Database              | 
+-----------------------+ 
| PRODUCTS              | 
+-----------------------+

La creazione o l'eliminazione di database in MariaDB richiede privilegi, in genere, concessi solo agli utenti root o agli amministratori. In questi account, hai due opzioni per eliminare un database: il binario mysqladmin e uno script PHP.

Tieni presente che i database eliminati sono irrecuperabili, quindi fai attenzione nell'eseguire questa operazione. Inoltre, gli script PHP utilizzati per la cancellazione lo fannonot ti chiederà una conferma prima della cancellazione.

binario mysqladmin

L'esempio seguente mostra come utilizzare il binario mysqladmin per eliminare un database esistente:

[root@host]# mysqladmin -u root -p drop PRODUCTS
Enter password:******
mysql> DROP PRODUCTS
ERROR 1008 (HY000): Can't drop database 'PRODUCTS'; database doesn't exist

Script per database di rilascio PHP

PHP utilizza l'estensione mysql_queryfunzione nell'eliminazione dei database MariaDB. La funzione utilizza due parametri, uno opzionale, e restituisce un valore "true" in caso di successo o "false" quando non lo è.

Sintassi

Rivedere la seguente sintassi dello script del database di rilascio:

bool mysql_query( sql, connection );

Di seguito la descrizione dei parametri:

Suor n	Parametro e descrizione
1	sql Questo parametro obbligatorio è costituito dalla query SQL necessaria per eseguire l'operazione.
2	connection Quando non specificato, questo parametro facoltativo utilizza la connessione più recente utilizzata.

Prova il seguente codice di esempio per eliminare un database:

<html>
   <head>
      <title>Delete a MariaDB Database</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036'; $dbuser = 'root';
         $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }
         echo 'Connected successfully<br />';
         
         $sql = 'DROP DATABASE PRODUCTS'; $retval = mysql_query( $sql, $conn );
         
         if(! $retval ){ die('Could not delete database: ' . mysql_error()); } echo "Database PRODUCTS deleted successfully\n"; mysql_close($conn);
      ?>
   </body>
</html>

In caso di eliminazione riuscita, vedrai il seguente output:

mysql> Database PRODUCTS deleted successfully

Dopo esserti connesso a MariaDB, devi selezionare un database con cui lavorare perché potrebbero esistere molti database. Esistono due modi per eseguire questa attività: dal prompt dei comandi o tramite uno script PHP.

Il prompt dei comandi

Nella scelta di un database al prompt dei comandi, utilizzare semplicemente il comando SQL ‘use’ -

[root@host]# mysql -u root -p

Enter password:******

mysql> use PRODUCTS;

Database changed

mysql> SELECT database();  
+-------------------------+ 
| Database                | 
+-------------------------+ 
| PRODUCTS                | 
+-------------------------+

Una volta selezionato un database, tutti i comandi successivi opereranno sul database scelto.

Note- Tutti i nomi (ad esempio, database, tabella, campi) fanno distinzione tra maiuscole e minuscole. Assicurati che i comandi siano conformi al caso corretto.

PHP Seleziona script database

PHP fornisce l'estensione mysql_select_dbfunzione per la selezione del database. La funzione utilizza due parametri, uno opzionale, e restituisce un valore "true" in caso di selezione riuscita o false in caso di errore.

Sintassi

Rivedere la seguente sintassi dello script di selezione del database.

bool mysql_select_db( db_name, connection );

Di seguito la descrizione dei parametri:

S.No	Parametro e descrizione
1	db_name Questo parametro obbligatorio specifica il nome del database da utilizzare.
2	connection Quando non specificato, questo parametro facoltativo utilizza la connessione più recente utilizzata.

Prova il seguente codice di esempio per selezionare un database:

<html>
   <head>
      <title>Select a MariaDB Database</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036'; $dbuser = 'guest1';
         $dbpass = 'guest1a'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }
         echo 'Connected successfully';
         
         mysql_select_db( 'PRODUCTS' );
         mysql_close($conn);
      ?>
   </body>
</html>

In caso di selezione riuscita, vedrai il seguente output:

mysql> Connected successfully

Una buona definizione dei campi è essenziale per l'ottimizzazione del database. L'approccio ideale richiede l'utilizzo esclusivo di un campo del tipo e della dimensione necessari. Ad esempio, se utilizzerai solo un campo largo cinque caratteri, non definire un campo largo 20 caratteri. I tipi di campo (o colonna) sono noti anche come tipi di dati in base ai tipi di dati memorizzati all'interno del campo.

I tipi di dati MariaDB possono essere classificati come valori numerici, data e ora e stringa.

Tipi di dati numerici

I tipi di dati numerici supportati da MariaDB sono i seguenti:

• TINYINT - Questo tipo di dati rappresenta piccoli numeri interi che rientrano nell'intervallo con segno compreso tra -128 e 127 e l'intervallo senza segno compreso tra 0 e 255.

• BOOLEAN - Questo tipo di dati associa un valore 0 a "false" e un valore 1 a "true".

• SMALLINT - Questo tipo di dati rappresenta numeri interi nell'intervallo con segno compreso tra -32768 e 32768 e nell'intervallo senza segno compreso tra 0 e 65535.

• MEDIUMINT - Questo tipo di dati rappresenta numeri interi nell'intervallo con segno compreso tra -8388608 e 8388607 e nell'intervallo senza segno compreso tra 0 e 16777215.

• INT(also INTEGER)- Questo tipo di dati rappresenta un numero intero di dimensioni normali. Quando è contrassegnato come non firmato, l'intervallo va da 0 a 4294967295. Quando è firmato (impostazione predefinita), l'intervallo va da -2147483648 a 2147483647. Quando una colonna è impostata su ZEROFILL (uno stato senza segno), tutti i suoi valori sono preceduti da zeri da inserire Cifre M nel valore INT.

• BIGINT - Questo tipo di dati rappresenta numeri interi compresi nell'intervallo con segno compreso tra 9223372036854775808 e 9223372036854775807 e nell'intervallo senza segno compreso tra 0 e 18446744073709551615.

• DECIMAL(anche DEC, NUMERIC, FIXED) - Questo tipo di dati rappresenta numeri a virgola fissa precisi, con M che specifica le sue cifre e D che specifica le cifre dopo il decimale. Il valore M non aggiunge "-" o il punto decimale. Se D è impostato su 0, non viene visualizzata alcuna parte decimale o frazionaria e il valore verrà arrotondato al DECIMALE più vicino su INSERT. Il numero massimo consentito di cifre è 65 e il massimo per i decimali è 30. Il valore predefinito per M in caso di omissione è 10 e 0 per D in caso di omissione.

• FLOAT - Questo tipo di dati rappresenta un piccolo numero in virgola mobile del valore 0 o un numero compreso nei seguenti intervalli -

  • Da -3,402823466E + 38 a -1,175494351E-38

  • 1.175494351E-38 a 3.402823466E + 38

• DOUBLE (anche REAL e DOUBLE PRECISION) - Questo tipo di dati rappresenta i numeri in virgola mobile di dimensione normale del valore 0 o entro i seguenti intervalli -

  • -1.7976931348623157E + 308 a -2.2250738585072014E-308

  • 2.2250738585072014E-308 a 1.7976931348623157E + 308

• BIT- Questo tipo di dati rappresenta i campi di bit con M che specifica il numero di bit per valore. In caso di omissione di M, il valore predefinito è 1. I valori di bit possono essere applicati con "b '[valore]'" in cui il valore rappresenta il valore di bit in 0 e 1. Lo zero padding avviene automaticamente da sinistra per l'intera lunghezza; ad esempio, "10" diventa "0010".

Tipi di dati di data e ora

I tipi di dati di data e ora supportati da MariaDB sono i seguenti:

• DATE - Questo tipo di dati rappresenta un intervallo di date compreso tra "1000-01-01" e "9999-12-31" e utilizza il formato di data "AAAA-MM-GG".

• TIME - Questo tipo di dati rappresenta un intervallo di tempo compreso tra "-838: 59: 59.999999" e "838: 59: 59.999999".

• DATETIME- Questo tipo di dati rappresenta l'intervallo da "1000-01-01 00: 00: 00.000000" a "9999-12-31 23: 59: 59.999999". Utilizza il formato "AAAA-MM-GG HH: MM: SS".

• TIMESTAMP- Questo tipo di dati rappresenta un timestamp del formato "AAAA-MM-GG HH: MM: GG". Viene utilizzato principalmente per dettagliare l'ora delle modifiche al database, ad esempio l'inserimento o l'aggiornamento.

• YEAR- Questo tipo di dati rappresenta un anno in formato a 4 cifre. Il formato a quattro cifre consente valori compresi tra 1901 e 2155 e 0000.

String DataTypes

I valori del tipo di stringa supportati da MariaDB sono i seguenti:

• String literals - Questo tipo di dati rappresenta sequenze di caratteri racchiuse tra virgolette.

• CHAR- Questo tipo di dati rappresenta una stringa di lunghezza fissa riempita a destra contenente spazi di lunghezza specificata. M rappresenta la lunghezza della colonna di caratteri in un intervallo da 0 a 255, il suo valore predefinito è 1.

• VARCHAR - Questo tipo di dati rappresenta una stringa di lunghezza variabile, con un intervallo M (lunghezza massima della colonna) da 0 a 65535.

• BINARY - Questo tipo di dati rappresenta stringhe di byte binarie, con M come lunghezza della colonna in byte.

• VARBINARY - Questo tipo di dati rappresenta stringhe di byte binarie di lunghezza variabile, con M come lunghezza della colonna.

• TINYBLOB- Questo tipo di dati rappresenta una colonna BLOB con una lunghezza massima di 255 (28 - 1) byte. Nella memoria, ognuno utilizza un prefisso di lunghezza di un byte che indica la quantità di byte nel valore.

• BLOB- Questo tipo di dati rappresenta una colonna BLOB con una lunghezza massima di 65.535 (216 - 1) byte. Nella memoria, ognuno utilizza un prefisso di lunghezza di due byte che indica la quantità di byte nel valore.

• MEDIUMBLOB- Questo tipo di dati rappresenta una colonna BLOB con una lunghezza massima di 16.777.215 (2 ²⁴ - 1) byte. Nella memoria, ciascuno utilizza un prefisso di lunghezza di tre byte che indica la quantità di byte nel valore.

• LONGBLOB- Questo tipo di dati rappresenta una colonna BLOB con una lunghezza massima di 4.294.967.295 (2 ³² - 1) byte. Nella memoria, ciascuno utilizza un prefisso di lunghezza di quattro byte che indica la quantità di byte nel valore.

• TINYTEXT- Questo tipo di dati rappresenta una colonna di testo con una lunghezza massima di 255 (2 ⁸ - 1) caratteri. Nella memoria, ognuno utilizza un prefisso di lunghezza di un byte che indica la quantità di byte nel valore.

• TEXT- Questo tipo di dati rappresenta una colonna di testo con una lunghezza massima di 65.535 (2 ¹⁶ - 1) caratteri. Nella memoria, ognuno utilizza un prefisso di lunghezza di due byte che indica la quantità di byte nel valore.

• MEDIUMTEXT- Questo tipo di dati rappresenta una colonna di testo con una lunghezza massima di 16.777.215 (2 ²⁴ - 1) caratteri. Nella memoria, ciascuno utilizza un prefisso di lunghezza di tre byte che indica la quantità di byte nel valore.

• LONGTEXT- Questo tipo di dati rappresenta una colonna di testo con una lunghezza massima di 4.294.967.295 o 4 GB (2 ³² - 1) caratteri. Nella memoria, ciascuno utilizza un prefisso di lunghezza di quattro byte che indica la quantità di byte nel valore.

• ENUM - Questo tipo di dati rappresenta un oggetto stringa con un solo valore da un elenco.

• SET- Questo tipo di dati rappresenta un oggetto stringa con zero o più valori da un elenco, con un massimo di 64 membri. I valori SET sono presenti internamente come valori interi.

In questo capitolo impareremo come creare tabelle. Prima di creare una tabella, determinarne il nome, i nomi dei campi e le definizioni dei campi.

Di seguito è riportata la sintassi generale per la creazione di tabelle:

CREATE TABLE table_name (column_name column_type);

Rivedere il comando applicato per creare una tabella nel database PRODOTTI -

databaseproducts_ tbl(
   product_id INT NOT NULL AUTO_INCREMENT,
   product_name VARCHAR(100) NOT NULL,
   product_manufacturer VARCHAR(40) NOT NULL,
   submission_date DATE,
   PRIMARY KEY ( product_id )
);

L'esempio precedente utilizza "NOT NULL" come attributo di campo per evitare errori causati da un valore null. L'attributo "AUTO_INCREMENT" indica a MariaDB di aggiungere il successivo valore disponibile al campo ID. La parola chiave chiave primaria definisce una colonna comeprimary key. Più colonne separate da virgole possono definire una chiave primaria.

I due metodi principali per la creazione di tabelle utilizzano il prompt dei comandi e uno script PHP.

Il prompt dei comandi

Utilizzare il comando CREATE TABLE per eseguire l'attività come mostrato di seguito:

root@host# mysql -u root -p
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> CREATE TABLE products_tbl(
   -> product_id INT NOT NULL AUTO_INCREMENT,
   -> product_name VARCHAR(100) NOT NULL,
   -> product_manufacturer VARCHAR(40) NOT NULL,
   -> submission_date DATE,
   -> PRIMARY KEY ( product_id )
   -> );
mysql> SHOW TABLES;
+------------------------+
| PRODUCTS               |
+------------------------+
| products_tbl           |
+------------------------+

Assicurati che tutti i comandi terminino con un punto e virgola.

PHP Crea script tabella

PHP fornisce mysql_query()per la creazione di tabelle. Il suo secondo argomento contiene il comando SQL necessario:

<html>
   <head>
      <title>Create a MariaDB Table</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'root'; $dbpass = 'rootpassword';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
      
         if(! $conn ){ die('Could not connect: ' . mysql_error()); } echo 'Connected successfully<br />'; $sql = "CREATE TABLE products_tbl( ".
            "product_id INT NOT NULL AUTO_INCREMENT, ".
            "product_name VARCHAR(100) NOT NULL, ".
            "product_manufacturer VARCHAR(40) NOT NULL, ".
            "submission_date DATE, ".
            "PRIMARY KEY ( product_id )); ";
      
         mysql_select_db( 'PRODUCTS' );
         $retval = mysql_query( $sql, $conn ); if(! $retval ) {
            die('Could not create table: ' . mysql_error());
         }
         echo "Table created successfully\n";
         
         mysql_close($conn);
      ?>
   </body>
</html>

Dopo aver creato con successo la tabella, vedrai il seguente output:

mysql> Table created successfully

In questo capitolo impareremo a eliminare le tabelle.

La cancellazione delle tabelle è molto semplice, ma ricorda che tutte le tabelle eliminate sono irrecuperabili. La sintassi generale per l'eliminazione della tabella è la seguente:

DROP TABLE table_name ;

Esistono due opzioni per eseguire un drop di tabella: utilizzare il prompt dei comandi o uno script PHP.

Il prompt dei comandi

Al prompt dei comandi, usa semplicemente il file DROP TABLE Comando SQL -

root@host# mysql -u root -p
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> DROP TABLE products_tbl

mysql> SELECT * from products_tbl
ERROR 1146 (42S02): Table 'products_tbl' doesn't exist

Script PHP Drop Table

PHP fornisce mysql_query()per far cadere i tavoli. Passa semplicemente il suo secondo argomento al comando SQL appropriato -

<html>
   <head>
      <title>Create a MariaDB Table</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'root'; $dbpass = 'rootpassword';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
         
         if(! $conn ) { die('Could not connect: ' . mysql_error()); } echo 'Connected successfully<br />'; $sql = "DROP TABLE products_tbl";
         mysql_select_db( 'PRODUCTS' );
         $retval = mysql_query( $sql, $conn ); if(! $retval ) {
            die('Could not delete table: ' . mysql_error());
         }
         echo "Table deleted successfully\n";
         
         mysql_close($conn);
      ?>
   </body>
</html>

In caso di eliminazione corretta della tabella, vedrai il seguente output:

mysql> Table deleted successfully

In questo capitolo impareremo come inserire dati in una tabella.

L'inserimento di dati in una tabella richiede il comando INSERT. La sintassi generale del comando è INSERT seguita dal nome della tabella, dai campi e dai valori.

Rivedi la sua sintassi generale fornita di seguito:

INSERT INTO tablename (field,field2,...) VALUES (value, value2,...);

L'istruzione richiede l'uso di virgolette singole o doppie per i valori di stringa. Altre opzioni per l'istruzione includono le istruzioni "INSERT ... SET", le istruzioni "INSERT ... SELECT" e molte altre opzioni.

Note - La funzione VALUES () che appare all'interno dell'istruzione, si applica solo alle istruzioni INSERT e restituisce NULL se utilizzata altrove.

Esistono due opzioni per eseguire l'operazione: utilizzare la riga di comando o utilizzare uno script PHP.

Il prompt dei comandi

Quando richiesto, ci sono molti modi per eseguire un'operazione di selezione. Di seguito viene fornita una dichiarazione standard:

belowmysql>
INSERT INTO products_tbl (ID_number, Nomenclature) VALUES (12345,“Orbitron 4000”);
mysql> SHOW COLUMNS FROM products_tbl;
+-------------+-------------+------+-----+---------+-------+
| Field       | Type        | Null | Key | Default | Extra |
+-------------+-------------+------+-----+---------+-------+
| ID_number   | int(5)      |      |     |         |       |
| Nomenclature| char(13)    |      |     |         |       |
+-------------+-------------+------+-----+---------+-------+

Puoi inserire più righe -

INSERT INTO products VALUES (1, “first row”), (2, “second row”);

Puoi anche utilizzare la clausola SET -

INSERT INTO products SELECT * FROM inventory WHERE status = 'available';

Script di inserimento PHP

Utilizzare la stessa istruzione "INSERT INTO ..." all'interno di una funzione PHP per eseguire l'operazione. Userai il filemysql_query() funzione ancora una volta.

Rivedi l'esempio fornito di seguito:

<?php
   if(isset($_POST['add'])) {
      $dbhost = 'localhost:3036'; $dbuser = 'root';
      $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
         die('Could not connect: ' . mysql_error());
      }

      if(! get_magic_quotes_gpc() ) {
         $product_name = addslashes ($_POST['product_name']);
         $product_manufacturer = addslashes ($_POST['product_name']);
      } else {
         $product_name = $_POST['product_name'];
         $product_manufacturer = $_POST['product_manufacturer'];
      }
      $ship_date = $_POST['ship_date'];
      $sql = "INSERT INTO products_tbl ". "(product_name,product_manufacturer, ship_date) ". "VALUES"."('$product_name','$product_manufacturer','$ship_date')";

      mysql_select_db('PRODUCTS');
      $retval = mysql_query( $sql, $conn ); if(! $retval ) {
         die('Could not enter data: ' . mysql_error());
      }

      echo "Entered data successfully\n";
      mysql_close($conn);
   }
?>

In caso di inserimento dei dati riuscito, vedrai il seguente output:

mysql> Entered data successfully

Collaborerai anche alle dichiarazioni di convalida con istruzioni di inserimento come il controllo per garantire l'immissione corretta dei dati. MariaDB include una serie di opzioni per questo scopo, alcune delle quali sono automatiche.

In questo capitolo impareremo come selezionare i dati da una tabella.

Le istruzioni SELECT recuperano le righe selezionate. Possono includere istruzioni UNION, una clausola di ordinamento, una clausola LIMIT, una clausola WHERE, una clausola GROUP BY ... HAVING e sottoquery.

Rivedi la seguente sintassi generale:

SELECT field, field2,... FROM table_name, table_name2,... WHERE...

Un'istruzione SELECT fornisce più opzioni per specificare la tabella utilizzata:

• database_name.table_name

• table_name.column_name

• database_name.table_name.column_name

Tutte le istruzioni select devono contenere uno o più select expressions. Le espressioni di selezione sono costituite da una delle seguenti opzioni:

• Un nome di colonna.

• Un'espressione che impiega operatori e funzioni.

• La specifica "nome_tabella. *" Per selezionare tutte le colonne all'interno della tabella data.

• Il carattere "*" per selezionare tutte le colonne da tutte le tabelle specificate nella clausola FROM.

Il prompt dei comandi o uno script PHP possono essere utilizzati per eseguire un'istruzione select.

Il prompt dei comandi

Al prompt dei comandi, esegui le istruzioni come segue:

root@host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> SELECT * from products_tbl
+-------------+---------------+
| ID_number   | Nomenclature  |
+-------------+---------------+
| 12345       | Orbitron 4000 |
+-------------+---------------+

Script di selezione PHP

Utilizzare le stesse istruzioni SELECT all'interno di una funzione PHP per eseguire l'operazione. Userai il filemysql_query()funzione ancora una volta. Rivedi un esempio fornito di seguito:

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT product_id, product_name,product_manufacturer, ship_date FROM products_tbl';
   mysql_select_db('PRODUCTS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }

   while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) {
      echo "Product ID :{$row['product_id']} <br> ". "Name: {$row['product_name']} <br> ".
         "Manufacturer: {$row['product_manufacturer']} <br> ". "Ship Date : {$row['ship_date']} <br>".
         "--------------------------------<br>";
   }

   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

In caso di recupero dei dati riuscito, vedrai il seguente output:

Product ID: 12345
Nomenclature: Orbitron 4000
Manufacturer: XYZ Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 12346
Nomenclature: Orbitron 3000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
mysql> Fetched data successfully

Le migliori pratiche suggeriscono di rilasciare la memoria del cursore dopo ogni istruzione SELECT. PHP fornisce l'estensionemysql_free_result()funzione per questo scopo. Rivedi il suo utilizzo come mostrato di seguito -

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT product_id, product_name, product_manufacturer, ship_date FROM products_tbl';
   mysql_select_db('PRODUCTS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }

   while($row = mysql_fetch_array($retval, MYSQL_NUM)) {
      echo "Product ID :{$row[0]} <br> ". "Name: {$row[1]} <br> ".
         "Manufacturer: {$row[2]} <br> ". "Ship Date : {$row[3]} <br> ".
         "--------------------------------<br>";
   }

   mysql_free_result($retval); echo "Fetched data successfully\n"; mysql_close($conn);
?>

WHEREle clausole filtrano varie istruzioni come SELECT, UPDATE, DELETE e INSERT. Presentano i criteri utilizzati per specificare l'azione. In genere vengono visualizzati dopo il nome di una tabella in un'istruzione e la loro condizione segue. La clausola WHERE funziona essenzialmente come un'istruzione if.

Rivedere la sintassi generale della clausola WHERE riportata di seguito -

[COMMAND] field,field2,... FROM table_name,table_name2,... WHERE [CONDITION]

Notare le seguenti qualità della clausola WHERE:

• È opzionale.

• Consente di specificare qualsiasi condizione.

• Consente la specifica di più condizioni utilizzando un operatore AND o OR.

• La distinzione tra maiuscole e minuscole si applica solo alle istruzioni che utilizzano confronti LIKE.

La clausola WHERE consente l'uso dei seguenti operatori:

Operatore
=! =
> <
> = <=

Le clausole WHERE possono essere utilizzate al prompt dei comandi o all'interno di uno script PHP.

Il prompt dei comandi

Al prompt dei comandi, usa semplicemente un comando standard:

root@host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> SELECT * from products_tbl WHERE product_manufacturer = 'XYZ Corp';
+-------------+----------------+----------------------+
| ID_number   | Nomenclature   | product_manufacturer |
+-------------+----------------+----------------------+
| 12345       | Orbitron 4000  | XYZ Corp             |
+-------------+----------------+----------------------+
| 12346       | Orbitron 3000  | XYZ Corp             |
+-------------+----------------+----------------------+
| 12347       | Orbitron 1000  | XYZ Corp             |
+-------------+----------------+----------------------+

Rivedi un esempio utilizzando il AND condizione -

SELECT *
FROM products_tbl
WHERE product_name = 'Bun Janshu 3000';
AND product_id <= 344;

Questo esempio combina condizioni AND e OR

SELECT *
FROM products_tbl
WHERE (product_name = 'Bun Janshu 3000' AND product_id < 344)
OR (product_name = 'Bun Janshu 3000');

Script PHP che utilizzano la clausola Where

Utilizza il mysql_query() funzione nelle operazioni che utilizzano una clausola WHERE -

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'SELECT product_id, product_name, product_manufacturer, ship_date FROM products_tbl WHERE product_manufacturer = "XYZ Corp"'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );
   
   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Product ID :{$row['product_id']} <br> ".
         "Name: {$row['product_name']} <br> ". "Manufacturer: {$row['product_manufacturer']} <br> ".
         "Ship Date: {$row['ship_date']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

In caso di recupero dei dati riuscito, vedrai il seguente output:

Product ID: 12345
Nomenclature: Orbitron 4000
Manufacturer: XYZ Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 12346
Nomenclature: Orbitron 3000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
Product ID: 12347
Nomenclature: Orbitron 1000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
mysql> Fetched data successfully

Il UPDATEIl comando modifica i campi esistenti cambiando i valori. Utilizza la clausola SET per specificare le colonne per la modifica e per specificare i nuovi valori assegnati. Questi valori possono essere un'espressione o il valore predefinito del campo. L'impostazione di un valore predefinito richiede l'utilizzo della parola chiave DEFAULT. Il comando può anche utilizzare una clausola WHERE per specificare le condizioni per un aggiornamento e / o una clausola ORDER BY da aggiornare in un certo ordine.

Rivedi la seguente sintassi generale:

UPDATE table_name SET field=new_value, field2=new_value2,...
[WHERE ...]

Esegui un comando UPDATE dal prompt dei comandi o utilizzando uno script PHP.

Il prompt dei comandi

Al prompt dei comandi, usa semplicemente un commandroot standard -

root@host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> UPDATE products_tbl
   SET nomenclature = 'Fiber Blaster 300Z' WHERE ID_number = 112;
mysql> SELECT * from products_tbl WHERE ID_number='112';
+-------------+---------------------+----------------------+
| ID_number   | Nomenclature        | product_manufacturer |
+-------------+---------------------+----------------------+
| 112         | Fiber Blaster 300Z  | XYZ Corp             |
+-------------+---------------------+----------------------+

Script di query di aggiornamento PHP

Utilizza il mysql_query() funzione nelle istruzioni di comando UPDATE -

<?php
   $dbhost = ‘localhost:3036’; $dbuser = ‘root’;
   $dbpass = ‘rootpassword’; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die(‘Could not connect: ‘ . mysql_error());
   }

   $sql = ‘UPDATE products_tbl SET product_name = ”Fiber Blaster 300z” WHERE product_id = 112’; mysql_select_db(‘PRODUCTS’); $retval = mysql_query( $sql, $conn );

   if(! $retval ) { die(‘Could not update data: ‘ . mysql_error()); } echo “Updated data successfully\n”; mysql_close($conn);
?>

In caso di aggiornamento dei dati riuscito, vedrai il seguente output:

mysql> Updated data successfully

Il comando DELETE elimina le righe della tabella dalla tabella specificata e restituisce la quantità eliminata. Accedi alla quantità eliminata con la funzione ROW_COUNT (). Una clausola WHERE specifica le righe e, in sua assenza, tutte le righe vengono eliminate. Una clausola LIMIT controlla il numero di righe eliminate.

In un'istruzione DELETE per più righe, elimina solo quelle righe che soddisfano una condizione; e le clausole LIMIT e WHERE non sono consentite. Le istruzioni DELETE consentono l'eliminazione di righe da tabelle in database diversi, ma non consentono l'eliminazione da una tabella e quindi la selezione dalla stessa tabella all'interno di una sottoquery.

Rivedi la seguente sintassi DELETE:

DELETE FROM table_name [WHERE …]

Esegui un comando DELETE dal prompt dei comandi o utilizzando uno script PHP.

Il prompt dei comandi

Al prompt dei comandi, usa semplicemente un comando standard:

root@host# mysql –u root –p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> DELETE FROM products_tbl WHERE product_id=133;
mysql> SELECT * from products_tbl WHERE ID_number='133';
ERROR 1032 (HY000): Can't find record in 'products_tbl'

PHP Elimina script di query

Utilizzare il mysql_query() funzione nelle istruzioni di comando DELETE -

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'DELETE FROM products_tbl WHERE product_id = 261'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );

   if(! $retval ) { die('Could not delete data: ' . mysql_error()); } echo "Deleted data successfully\n"; mysql_close($conn);
?>

In caso di eliminazione dei dati riuscita, vedrai il seguente output:

mysql> Deleted data successfully
mysql> SELECT * from products_tbl WHERE ID_number='261';
ERROR 1032 (HY000): Can't find record in 'products_tbl'

La clausola WHERE fornisce un modo per recuperare i dati quando un'operazione utilizza una corrispondenza esatta. In situazioni che richiedono più risultati con caratteristiche condivise, ilLIKE la clausola si adatta a un ampio pattern matching.

Una clausola LIKE verifica una corrispondenza del modello, restituendo vero o falso. I modelli utilizzati per il confronto accettano i seguenti caratteri jolly: "%", che corrisponde a numeri di caratteri (0 o più); e "_", che corrisponde a un singolo carattere. Il carattere jolly "_" corrisponde solo ai caratteri all'interno del suo set, il che significa che ignorerà i caratteri latini quando si utilizza un altro set. Le corrispondenze non fanno distinzione tra maiuscole e minuscole per impostazione predefinita e richiedono impostazioni aggiuntive per la distinzione tra maiuscole e minuscole.

Una clausola NOT LIKE consente di testare la condizione opposta, in modo molto simile a not operatore.

Se l'espressione o il modello dell'istruzione restituisce NULL, il risultato è NULL.

Rivedere la sintassi della clausola LIKE generale fornita di seguito:

SELECT field, field2,... FROM table_name, table_name2,...
WHERE field LIKE condition

Utilizza una clausola LIKE al prompt dei comandi o all'interno di uno script PHP.

Il prompt dei comandi

Al prompt dei comandi, usa semplicemente un comando standard:

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT * from products_tbl
   WHERE product_manufacturer LIKE 'XYZ%';
+-------------+----------------+----------------------+
| ID_number   | Nomenclature   | product_manufacturer |
+-------------+----------------+----------------------+
| 12345       | Orbitron 4000  | XYZ Corp             |
+-------------+----------------+----------------------+
| 12346       | Orbitron 3000  | XYZ Corp             |
+-------------+----------------+----------------------+
| 12347       | Orbitron 1000  | XYZ Corp             |
+-------------+----------------+----------------------+

Script PHP che utilizza la clausola Like

Utilizzare il mysql_query() funzione nelle istruzioni che impiegano la clausola LIKE

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'SELECT product_id, product_name, product_manufacturer, ship_date FROM products_tbl WHERE product_manufacturer LIKE "xyz%"'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );
   
   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Product ID:{$row['product_id']} <br> ".
         "Name: {$row['product_name']} <br> ". "Manufacturer: {$row['product_manufacturer']} <br> ".
         "Ship Date: {$row['ship_date']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

In caso di recupero dei dati riuscito, vedrai il seguente output:

Product ID: 12345
Nomenclature: Orbitron 4000
Manufacturer: XYZ Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 12346
Nomenclature: Orbitron 3000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
Product ID: 12347
Nomenclature: Orbitron 1000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
mysql> Fetched data successfully

Il ORDER BYla clausola, come menzionato nelle discussioni precedenti, ordina i risultati di una dichiarazione. Specifica l'ordine dei dati su cui si opera e include l'opzione di ordinare in ordine crescente (ASC) o decrescente (DESC). In caso di omissione della specifica dell'ordine, l'ordine predefinito è crescente.

Le clausole ORDER BY vengono visualizzate in un'ampia varietà di istruzioni come DELETE e UPDATE. Appaiono sempre alla fine di un'istruzione, non in una sottoquery o prima di una funzione set, perché operano sulla tabella risultante finale. Non è inoltre possibile utilizzare un numero intero per identificare una colonna.

Rivedere la sintassi generale della clausola ORDER BY fornita di seguito -

SELECT field, field2,... [or column] FROM table_name, table_name2,...
ORDER BY field, field2,... ASC[or DESC]

Utilizza una clausola ORDER BY al prompt dei comandi o all'interno di uno script PHP.

Il prompt dei comandi

Al prompt dei comandi, usa semplicemente un comando standard:

root@ host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed

mysql> SELECT * from products_tbl ORDER BY product_manufacturer ASC
+-------------+----------------+----------------------+
| ID_number   | Nomenclature   | product_manufacturer |
+-------------+----------------+----------------------+
| 56789       | SuperBlast 400 | LMN Corp             |
+-------------+----------------+----------------------+
| 67891       | Zoomzoom 5000  | QFT Corp             |
+-------------+----------------+----------------------+
| 12347       | Orbitron 1000  | XYZ Corp             |
+-------------+----------------+----------------------+

Script PHP utilizzando Order By Clause

Utilizza il file mysql_query() funzione, ancora una volta, nelle istruzioni che impiegano la clausola ORDER BY -

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'SELECT product_id, product_name, product_manufacturer, ship_date FROM products_tbl ORDER BY product_manufacturer DESC'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );

   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Product ID :{$row['product_id']} <br> ".
         "Name: {$row['product_name']} <br> ". "Manufacturer: {$row['product_manufacturer']} <br> ".
         "Ship Date : {$row['ship_date']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

In caso di recupero dei dati riuscito, vedrai il seguente output:

Product ID: 12347
Nomenclature: Orbitron 1000
Manufacturer: XYZ Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 67891
Nomenclature: Zoomzoom 5000
Manufacturer: QFT Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 56789
Nomenclature: SuperBlast 400
Manufacturer: LMN Corp
Ship Date: 01/04/17
----------------------------------------------
mysql> Fetched data successfully

Nelle discussioni ed esempi precedenti, abbiamo esaminato il recupero da una singola tabella o il recupero di più valori da più origini. La maggior parte delle operazioni sui dati del mondo reale sono molto più complesse e richiedono aggregazione, confronto e recupero da più tabelle.

JOINsconsentire l'unione di due o più tabelle in un unico oggetto. Vengono utilizzati tramite le istruzioni SELECT, UPDATE e DELETE.

Rivedi la sintassi generale di un'istruzione che utilizza un JOIN come mostrato di seguito:

SELECT column
FROM table_name1
INNER JOIN table_name2
ON table_name1.column = table_name2.column;

Notare che la vecchia sintassi per JOINS utilizzava join impliciti e nessuna parola chiave. È possibile utilizzare una clausola WHERE per ottenere un join, ma le parole chiave funzionano meglio per la leggibilità, la manutenzione e le migliori pratiche.

I JOIN sono disponibili in molte forme come un join sinistro, un join destro o un join interno. Vari tipi di join offrono diversi tipi di aggregazione in base a valori o caratteristiche condivisi.

Utilizza un JOIN al prompt dei comandi o con uno script PHP.

Il prompt dei comandi

Al prompt dei comandi, usa semplicemente un'istruzione standard:

root@host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed

mysql> SELECT products.ID_number, products.Nomenclature, inventory.inventory_ct
   FROM products
   INNER JOIN inventory
   ON products.ID_numbeer = inventory.ID_number;
+-------------+----------------+-----------------+
| ID_number   | Nomenclature   | Inventory Count |
+-------------+----------------+-----------------+
| 12345       | Orbitron 4000  | 150             |
+-------------+----------------+-----------------+
| 12346       | Orbitron 3000  | 200             |
+-------------+----------------+-----------------+
| 12347       | Orbitron 1000  | 0               |
+-------------+----------------+-----------------+

Script PHP utilizzando JOIN

Utilizzare il mysql_query() funzione per eseguire un'operazione di unione -

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'SELECT a.product_id, a.product_manufacturer, b.product_count FROM products_tbl a, pcount_tbl b WHERE a.product_manufacturer = b.product_manufacturer'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );

   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Manufacturer:{$row['product_manufacturer']} <br> ".
         "Count: {$row['product_count']} <br> ". "Product ID: {$row['product_id']} <br> ".
         "--------------------------------<br>";
   }

   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

In caso di recupero dei dati riuscito, vedrai il seguente output:

ID Number: 12345
Nomenclature: Orbitron 4000
Inventory Count: 150
--------------------------------------
ID Number: 12346
Nomenclature: Orbitron 3000
Inventory Count: 200
--------------------------------------
ID Number: 12347
Nomenclature: Orbitron 1000
Inventory Count: 0
--------------------------------------
mysql> Fetched data successfully

Quando lavori con valori NULL, ricorda che sono valori sconosciuti. Non sono stringhe vuote o zero, che sono valori validi. Nella creazione della tabella, le specifiche delle colonne consentono di impostarle per accettare valori nulli o rifiutarli. Utilizza semplicemente una clausola NULL o NOT NULL. Questo ha applicazioni in caso di informazioni sui record mancanti come un numero ID.

Le variabili definite dall'utente hanno un valore NULL fino all'assegnazione esplicita. I parametri di routine memorizzate e le variabili locali consentono di impostare un valore NULL. Quando una variabile locale non ha un valore predefinito, ha un valore NULL.

NULL non distingue tra maiuscole e minuscole e ha i seguenti alias:

• UNKNOWN (un valore booleano)
• \N

Operatori NULL

Gli operatori di confronto standard non possono essere utilizzati con NULL (ad esempio, =,>,> =, <=, <o! =) Perché tutti i confronti con un valore NULL restituiscono NULL, non vero o falso. I confronti con NULL o che eventualmente lo contengono devono utilizzare l'operatore "<=>" (NULL-SAFE).

Altri operatori disponibili sono:

• IS NULL - Verifica un valore NULL.

• NON È NULLO - Conferma l'assenza di un valore NULL.

• ISNULL - Restituisce un valore di 1 alla scoperta di un valore NULL e 0 in sua assenza.

• COALESCE - Restituisce il primo valore non NULL di una lista, oppure restituisce un valore NULL in assenza di uno.

Ordinamento dei valori NULL

Nelle operazioni di ordinamento, i valori NULL hanno il valore più basso, quindi l'ordine DESC restituisce valori NULL in fondo. MariaDB consente di impostare un valore più alto per i valori NULL.

Ci sono due modi per farlo come mostrato di seguito:

SELECT column1 FROM product_tbl ORDER BY ISNULL(column1), column1;

L'altro modo -

SELECT column1 FROM product_tbl ORDER BY IF(column1 IS NULL, 0, 1), column1 DESC;

Funzioni NULL

Le funzioni generalmente restituiscono NULL quando qualsiasi parametro è NULL. Tuttavia, esistono funzioni progettate specificamente per la gestione dei valori NULL. Sono -

• IFNULL()- Se la prima espressione non è NULL, la restituisce. Quando restituisce NULL, restituisce la seconda espressione.

• NULLIF() - Restituisce NULL quando le espressioni confrontate sono uguali, altrimenti restituisce la prima espressione.

Funzioni come SUM e AVG ignorano i valori NULL.

Inserimento di valori NULL

All'inserimento di un valore NULL in una colonna dichiarata NOT NULL, si verifica un errore. Nella modalità SQL predefinita, una colonna NOT NULL inserirà invece un valore predefinito basato sul tipo di dati.

Quando un campo è una colonna TIMESTAMP, AUTO_INCREMENT o virtuale, MariaDB gestisce i valori NULL in modo diverso. L'inserimento in una colonna AUTO_INCREMENT fa sì che il numero successivo nella sequenza venga inserito al suo posto. In un campo TIMESTAMP, MariaDB assegna invece il timestamp corrente. Nelle colonne virtuali, un argomento discusso più avanti in questo tutorial, viene assegnato il valore predefinito.

Gli indici UNIQUE possono contenere molti valori NULL, tuttavia, le chiavi primarie non possono essere NULL.

Valori NULL e comando Alter

Quando si utilizza il comando ALTER per modificare una colonna, in assenza di specifiche NULL, MariaDB assegna automaticamente i valori.

Oltre alla corrispondenza del modello disponibile dalle clausole LIKE, MariaDB offre la corrispondenza basata su espressioni regolari tramite l'operatore REGEXP. L'operatore esegue la corrispondenza del modello per un'espressione stringa in base a un determinato modello.

MariaDB 10.0.5 ha introdotto PCRE Regular Expressions, che aumenta notevolmente l'ambito della corrispondenza in aree come modelli ricorsivi, asserzioni previsionali e altro ancora.

Rivedere l'uso della sintassi dell'operatore REGEXP standard fornita di seguito:

SELECT column FROM table_name WHERE column REGEXP '[PATTERN]';

REGEXP restituisce 1 per una corrispondenza di pattern o 0 in assenza di uno.

Un'opzione per l'opposto esiste sotto forma di NOT REGEXP. MariaDB offre anche sinonimi per REGEXP e NOT REGEXP, RLIKE e NOT RLIKE, che sono stati creati per motivi di compatibilità.

Il modello confrontato può essere una stringa letterale o qualcos'altro come una colonna di tabella. Nelle stringhe utilizza la sintassi di escape C, quindi raddoppia i caratteri "\". REGEXP non fa distinzione tra maiuscole e minuscole, ad eccezione delle stringhe binarie.

Di seguito viene fornita una tabella dei possibili modelli che possono essere utilizzati:

Suor n	Modello e descrizione
1	^ Corrisponde all'inizio della stringa.
2	$ Corrisponde alla fine della stringa.
3	. Corrisponde a un singolo carattere.
4	[...] Corrisponde a qualsiasi carattere tra parentesi.
5	[^...] Corrisponde a qualsiasi carattere non elencato tra parentesi.
6	p1|p2|p3 Corrisponde a uno qualsiasi dei modelli.
7	* Corrisponde a 0 o più istanze dell'elemento precedente.
8	+ Corrisponde a 1 o più istanze dell'elemento precedente.
9	{n} Corrisponde a n istanze dell'elemento precedente.
10	{m,n} Corrisponde a m an istanze dell'elemento precedente.

Rivedi gli esempi di corrispondenza dei modelli forniti di seguito:

Prodotti che iniziano con "pr" -

SELECT name FROM product_tbl WHERE name REGEXP '^pr';

Prodotti che terminano con "na" -

SELECT name FROM product_tbl WHERE name REGEXP 'na$';

Prodotti che iniziano con una vocale -

SELECT name FROM product_tbl WHERE name REGEXP '^[aeiou]';

Le transazioni sono operazioni di gruppo sequenziali. Funzionano come una singola unità e non terminano finché tutte le operazioni all'interno del gruppo non vengono eseguite correttamente. Un singolo errore nel gruppo causa il fallimento dell'intera transazione e non ha alcun impatto sul database.

Le transazioni sono conformi ad ACID (atomicità, coerenza, isolamento e durabilità) -

• Atomicity - Assicura il successo di tutte le operazioni interrompendo gli errori e ripristinando le modifiche.

• Consistency - Assicura che il database applichi le modifiche su una transazione riuscita.

• Isolation - Consente transazioni indipendenti operazioni di transazioni.

• Durability - Assicura la persistenza di una transazione di successo in caso di guasto del sistema.

All'inizio di un'istruzione di transazione c'è l'istruzione START TRANSACTION seguita dalle istruzioni COMMIT e ROLLBACK -

• START TRANSACTION avvia la transazione.

• COMMIT salva le modifiche ai dati.

• ROLLBACK termina la transazione, distruggendo qualsiasi modifica.

In caso di transazione di successo, COMMIT agisce. In caso di errore, ROLLBACK agisce.

Note- Alcune istruzioni causano un commit implicito e causano anche un errore quando vengono utilizzate all'interno delle transazioni. Esempi di tali dichiarazioni includono, ma non sono limitati a CREATE, ALTER e DROP.

Le transazioni MariaDB includono anche opzioni come SAVEPOINT e LOCK TABLES. SAVEPOINT imposta un punto di ripristino da utilizzare con ROLLBACK. LOCK TABLES consente di controllare l'accesso alle tabelle durante le sessioni per impedire modifiche durante determinati periodi di tempo.

La variabile AUTOCOMMIT fornisce il controllo sulle transazioni. Un'impostazione di 1 forza tutte le operazioni da considerare come transazioni riuscite e un'impostazione di 0 fa sì che la persistenza delle modifiche si verifichi solo su un'istruzione COMMIT esplicita.

Struttura di una transazione

La struttura generale di una dichiarazione di transazione consiste nell'iniziare con START TRANSACTION. Il passo successivo è l'inserimento di uno o più comandi / operazioni, l'inserimento di istruzioni che verificano la presenza di errori, l'inserimento di istruzioni ROLLBACK per gestire eventuali errori rilevati e infine l'inserimento di un'istruzione COMMIT per applicare le modifiche alle operazioni riuscite.

Rivedi l'esempio fornito di seguito:

START TRANSACTION;
SELECT name FROM products WHERE manufacturer = 'XYZ Corp';
UPDATE spring_products SET item = name;
COMMIT;

Il comando ALTER fornisce un modo per modificare la struttura di una tabella esistente, ovvero modifiche come la rimozione o l'aggiunta di colonne, la modifica degli indici, la modifica dei tipi di dati o la modifica dei nomi. ALTER attende inoltre di applicare le modifiche quando è attivo un blocco dei metadati.

Utilizzo di ALTER per modificare le colonne

ALTER abbinato a DROP rimuove una colonna esistente. Tuttavia, non riesce se la colonna è l'unica colonna rimanente.

Rivedi l'esempio fornito di seguito:

mysql> ALTER TABLE products_tbl DROP version_num;

Usa un'istruzione ALTER ... ADD per aggiungere colonne -

mysql> ALTER TABLE products_tbl ADD discontinued CHAR(1);

Utilizza le parole chiave PRIMA e DOPO per specificare il posizionamento della colonna -

ALTER TABLE products_tbl ADD discontinued CHAR(1) FIRST;
ALTER TABLE products_tbl ADD discontinued CHAR(1) AFTER quantity;

Nota che le parole chiave FIRST e AFTER si applicano solo alle istruzioni ALTER ... ADD. Inoltre, devi rilasciare una tabella e quindi aggiungerla per riposizionarla.

Modificare una definizione o un nome di colonna utilizzando la clausola MODIFY o CHANGE in un'istruzione ALTER. Le clausole hanno effetti simili, ma utilizzano una sintassi sostanzialmente diversa.

Rivedi un esempio di MODIFICA fornito di seguito:

mysql> ALTER TABLE products_tbl CHANGE discontinued status CHAR(4);

In un'istruzione che utilizza CHANGE, specificare la colonna originale e quindi la nuova colonna che la sostituirà. Rivedi un esempio di MODIFICA di seguito:

mysql> ALTER TABLE products_tbl MODIFY discontinued CHAR(4);

Il comando ALTER consente anche di modificare i valori predefiniti. Rivedi un esempio:

mysql> ALTER TABLE products_tbl ALTER discontinued SET DEFAULT N;

Puoi anche usarlo per rimuovere i vincoli predefiniti associandolo a una clausola DROP -

mysql> ALTER TABLE products_tbl ALTER discontinued DROP DEFAULT;

Utilizzo di ALTER per modificare le tabelle

Cambia il tipo di tabella con la clausola TYPE -

mysql> ALTER TABLE products_tbl TYPE = INNODB;

Rinomina una tabella con la parola chiave RENAME -

mysql> ALTER TABLE products_tbl RENAME TO products2016_tbl;

Gli indici sono strumenti per accelerare il recupero dei record. Un indice genera una voce per ogni valore all'interno di una colonna indicizzata.

Esistono quattro tipi di indici:

• Primary (un record rappresenta tutti i record)

• Unique (un record rappresenta più record)

• Plain

• Full-Text (consente molte opzioni nelle ricerche di testo).

I termini "chiave" e "indice" sono identici in questo utilizzo.

Gli indici si associano a una o più colonne e supportano ricerche rapide e un'organizzazione efficiente dei record. Quando crei un indice, considera quali colonne vengono utilizzate di frequente nelle tue query. Quindi crea uno o più indici su di essi. Inoltre, visualizza gli indici essenzialmente come tabelle di chiavi primarie.

Sebbene gli indici accelerino le ricerche o le istruzioni SELECT, fanno trascinare gli inserimenti e gli aggiornamenti a causa dell'esecuzione delle operazioni sia sulle tabelle che sugli indici.

Crea un indice

È possibile creare un indice tramite un'istruzione CREATE TABLE ... INDEX o un'istruzione CREATE INDEX. L'opzione migliore per supportare leggibilità, manutenzione e best practice è CREATE INDEX.

Rivedere la sintassi generale dell'indice fornita di seguito:

CREATE [UNIQUE or FULLTEXT or...] INDEX index_name ON table_name column;

Rivedi un esempio del suo utilizzo -

CREATE UNIQUE INDEX top_sellers ON products_tbl product;

Rilascia un indice

Puoi rilasciare un indice con DROP INDEX o ALTER TABLE ... DROP. L'opzione migliore per supportare leggibilità, manutenzione e best practice è DROP INDEX.

Rivedi la sintassi generale dell'indice di rilascio fornita di seguito:

DROP INDEX index_name ON table_name;

Rivedi un esempio del suo utilizzo -

DROP INDEX top_sellers ON product_tbl;

Rinomina un indice

Rinomina un indice con l'istruzione ALTER TABLE. Rivedi la sua sintassi generale fornita di seguito:

ALTER TABLE table_name DROP INDEX index_name, ADD INDEX new_index_name;

Rivedi un esempio del suo utilizzo -

ALTER TABLE products_tbl DROP INDEX top_sellers, ADD INDEX top_2016sellers;

Gestione degli indici

Dovrai esaminare e tenere traccia di tutti gli indici. Utilizzare SHOW INDEX per elencare tutti gli indici esistenti associati a una determinata tabella. È possibile impostare il formato del contenuto visualizzato utilizzando un'opzione come "\ G", che specifica un formato verticale.

Rivedi il seguente esempio:

mysql > SHOW INDEX FROM products_tbl\G

Statistiche tabella

Gli indici vengono utilizzati molto per ottimizzare le query dato l'accesso più rapido ai record e alle statistiche fornite. Tuttavia, molti utenti trovano complicata la manutenzione dell'indice. MariaDB 10.0 ha reso disponibili tabelle statistiche indipendenti dal motore di archiviazione, che calcolano le statistiche dei dati per ogni tabella in ogni motore di archiviazione e persino le statistiche per le colonne che non sono indicizzate.

Alcune operazioni possono trarre vantaggio dalle tabelle temporanee a causa della velocità o dei dati disponibili. La vita di una tabella temporanea termina alla fine di una sessione, sia che tu le utilizzi dal prompt dei comandi, con uno script PHP o tramite un programma client. Inoltre, non appare nel sistema in modo tipico. Il comando MOSTRA TABELLE non rivelerà un elenco contenente tabelle temporanee.

Crea una tabella temporanea

La parola chiave TEMPORARY all'interno di un'istruzione CREATE TABLE genera una tabella temporanea. Rivedi un esempio fornito di seguito:

mysql>CREATE TEMPORARY TABLE order (
   item_name VARCHAR(50) NOT NULL
   , price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   , quantity INT UNSIGNED NOT NULL DEFAULT 0
);

Nella creazione di una tabella temporanea, è possibile clonare le tabelle esistenti, ovvero tutte le loro caratteristiche generali, con la clausola LIKE. L'istruzione CREATE TABLE utilizzata per spawnare la tabella temporanea non eseguirà il commit delle transazioni come risultato della parola chiave TEMPORARY.

Sebbene le tabelle temporanee si distinguano da quelle non temporanee e cadano alla fine di una sessione, potrebbero avere alcuni conflitti:

• A volte entrano in conflitto con tabelle temporanee fantasma da sessioni scadute.

• A volte entrano in conflitto con i nomi shadow di tabelle non temporanee.

Note - Le tabelle temporanee possono avere lo stesso nome di una tabella non temporanea esistente perché MariaDB la vede come un riferimento di differenza.

Amministrazione

MariaDB richiede la concessione di privilegi agli utenti per la creazione di tabelle temporanee. Utilizzare un'istruzione GRANT per concedere questo privilegio agli utenti non amministratori.

GRANT CREATE TEMPORARY TABLES ON orders TO 'machine122'@'localhost';

Rilascia una tabella temporanea

Sebbene le tabelle temporanee vengano essenzialmente rimosse alla fine delle sessioni, hai la possibilità di eliminarle. L'eliminazione di una tabella temporanea richiede l'uso della parola chiave TEMPORARY e le migliori pratiche suggeriscono di eliminare le tabelle temporanee prima di qualsiasi tabella non temporanea.

mysql> DROP TABLE order;

Alcune situazioni richiedono la produzione di una copia esatta di una tabella esistente. L'istruzione CREATE ... SELECT non può produrre questo output perché trascura cose come indici e valori predefiniti.

La procedura per la duplicazione di una tabella è la seguente:

• Utilizzare SHOW CREATE TABLE per produrre un'istruzione CREATE TABLE che descriva l'intera struttura della tabella di origine.

• Modificare l'istruzione per dare alla tabella un nuovo nome ed eseguirla.

• Utilizzare un'istruzione INSERT INTO ... SELECT se è necessario copiare anche i dati della tabella.

mysql> INSERT INTO inventory_copy_tbl (
   product_id,product_name,product_manufacturer,ship_date)
   
   SELECT product_id,product_name,product_manufacturer,ship_date,
   FROM inventory_tbl;

Un altro metodo per creare un duplicato utilizza un'istruzione CREATE TABLE AS. L'istruzione copia tutte le colonne, le definizioni di colonna e popola la copia con i dati della tabella di origine.

Rivedi la sua sintassi fornita di seguito -

CREATE TABLE clone_tbl AS
   SELECT columns
   FROM original_tbl
   WHERE conditions];

Rivedi un esempio del suo utilizzo di seguito:

CREATE TABLE products_copy_tbl AS
   SELECT *
   FROM products_tbl;

Nella versione 10.0.3, MariaDB ha introdotto un motore di archiviazione noto come sequenza. Il suo ad hoc genera una sequenza intera per le operazioni e quindi termina. La sequenza contiene numeri interi positivi in ​​ordine decrescente o crescente e utilizza un valore iniziale, finale e di incremento.

Non consente l'utilizzo in più query, solo nella query originale a causa della sua natura virtuale (non scritta su disco). Tuttavia, le tabelle di sequenza possono essere convertite in tabelle standard tramite un comando ALTER. Se una tabella convertita viene eliminata, la tabella di sequenza esiste ancora. Le sequenze inoltre non possono produrre numeri negativi o ruotare al minimo / massimo.

Installazione del Sequence Engine

L'utilizzo delle sequenze richiede l'installazione del motore delle sequenze, che MariaDB distribuisce come plugin invece che come binario. Installalo con il seguente comando:

INSTALL SONAME "ha_sequence";

Dopo l'installazione, verificalo -

SHOW ENGINES\G

Ricordare che dopo l'installazione del motore, non è possibile creare una tabella standard con un nome che utilizza la sintassi della sequenza, ma è possibile creare una tabella temporanea con un nome della sintassi della sequenza.

Creazione della sequenza

Esistono due metodi per creare una sequenza:

• Creare una tabella e utilizzare l'attributo AUTO_INCREMENT per definire una colonna come incremento automatico.

• Utilizzare un database esistente e utilizzare una query SELECT di sequenza per produrre una sequenza. La query utilizza la sintassi seq_ [FROM] _to_ [TO] o seq_ [FROM] _to_ [TO] _step_STEP.

Le migliori pratiche preferiscono l'uso del secondo metodo. Rivedi un esempio di creazione di una sequenza fornito di seguito:

SELECT * FROM seq_77_to_99;

Le sequenze hanno molti usi:

• Individua i valori mancanti all'interno di una colonna per proteggerti da problemi correlati nelle operazioni -

SELECT myseq.seq FROM seq_22_to_28 myseq LEFT JOIN table1 t ON myseq.seq
   = x.y WHERE x.y IS NULL;

• Costruisci una combinazione di valori -

SELECT x1.seq, x2.seq FROM seq_5_to_9 x1 JOIN seq_5_to_9 x2 ORDER BY 5, 6;

• Trova multipli di un numero -

SELECT seq FROM seq_3_to_100_step_4;

• Costruisci una sequenza di date da utilizzare in applicazioni come i sistemi di prenotazione.
• Costruisci una sequenza temporale.

MariaDB, come discusso nelle lezioni precedenti, consente di duplicare record e tabelle in alcune situazioni. Alcuni di questi duplicati non sono in realtà duplicati a causa di dati o tipi di oggetti distinti o come risultato della durata o della memorizzazione univoca dell'oggetto operazione. Inoltre, questi duplicati in genere non presentano problemi.

In alcune situazioni, i duplicati causano problemi e spesso appaiono a causa di azioni implicite o della politica indulgente di un comando MariaDB. Esistono modi per controllare questo problema, trovare duplicati, eliminare duplicati e impedire la creazione di duplicati.

Strategie e strumenti

Esistono quattro modi principali per gestire i duplicati:

• Pescali con JOIN e cancellali con una tabella temporanea.

• Utilizzare INSERT ... ON DUPLICATE KEY UPDATE per aggiornare alla scoperta di un duplicato.

• Utilizzare DISTINCT per eliminare i risultati di un'istruzione SELECT e rimuovere i duplicati.

• Utilizzare INSERISCI IGNORA per interrompere l'inserimento dei duplicati.

Utilizzo di Join with a Temporary Table

Esegui semplicemente un semi join come un inner join, quindi rimuovi i duplicati trovati con una tabella temporanea.

Utilizzando INSERT

Quando INSERT ... ON DUPLICATE KEY UPDATE rileva una chiave univoca o primaria duplicata, esegue un aggiornamento. Alla scoperta di più chiavi univoche, aggiorna solo la prima. Quindi, non utilizzarlo su tabelle con più indici univoci.

Esamina il seguente esempio, che rivela cosa accade in una tabella contenente valori indicizzati all'inserimento in un campo popolato:

INSERT INTO add_dupl VALUES (1,'Apple');
ERROR 1062 (23000): Duplicate entry '1' for key 'PRIMARY'

Note - Se non trova alcuna chiave, un'istruzione INSERT ... ON DUPLICATE KEY UPDATE viene eseguita come una normale istruzione insert.

Utilizzando DISTINCT

Le clausole DISTINCT rimuovono i duplicati dai risultati. La sintassi generale per una clausola DISTINCT è la seguente:

SELECT DISTINCT fields
FROM table
[WHERE conditions];

Note - I risultati di un'istruzione con una clausola DISTINCT -

• Quando si utilizza un'espressione, restituisce valori univoci per essa.

• Quando si utilizzano più espressioni, restituisce combinazioni uniche.

• Non ignora i valori NULL; pertanto, i risultati contengono anche NULL come valori univoci.

Rivedi la seguente dichiarazione utilizzando una clausola DISTINCT per una singola espressione:

SELECT DISTINCT product_id
FROM products
WHERE product_name = 'DustBlaster 5000';

Rivedi il seguente esempio utilizzando più espressioni:

SELECT DISTINCT product_name, product_id
FROM products
WHERE product_id < 30

Utilizzo di INSERT IGNORE

Un'istruzione INSERT IGNORE ordina a MariaDB di annullare l'inserimento alla scoperta di un record duplicato. Rivedi un esempio del suo utilizzo fornito di seguito:

mysql> INSERT IGNORE INTO customer_tbl (LN, FN)
   VALUES( 'Lex', 'Luther');

Inoltre, nota la logica dietro i duplicati. Alcune tabelle richiedono duplicati in base alla natura dei dati della tabella. Soddisfa tale esigenza nella tua strategia per la gestione dei record duplicati.

Il semplice atto di accettare l'input dell'utente apre la porta agli exploit. Il problema deriva principalmente dalla gestione logica dei dati, ma fortunatamente è abbastanza facile evitare questi grandi difetti.

Le opportunità per l'iniezione SQL si verificano in genere quando gli utenti immettono dati come un nome e la logica del codice non riesce ad analizzare questo input. Il codice, invece, consente a un utente malintenzionato di inserire un'istruzione MariaDB, che verrà eseguita sul database.

Considera sempre i dati inseriti dagli utenti, sospetti e necessitano di una forte convalida prima di qualsiasi elaborazione. Eseguire questa convalida tramite la corrispondenza del modello. Ad esempio, se l'input previsto è un nome utente, limitare i caratteri immessi a caratteri alfanumerici e trattini bassi e a una certa lunghezza. Rivedi un esempio fornito di seguito:

if(check_match("/^\w{8,20}$/", $_GET['user_name'], $matches)) {
   $result = mysql_query("SELECT * FROM system_users WHERE user_name = $matches[0]");
} else {
   echo "Invalid username";
}

Inoltre, utilizza l'operatore REGEXP e le clausole LIKE per creare vincoli di input.

Considerare tutti i tipi di controllo esplicito necessario dell'input come:

• Controlla i caratteri di escape utilizzati.

• Controllare i tipi di dati appropriati specifici per l'input. Limita l'input al tipo di dati e alla dimensione necessari.

• Controlla la sintassi dei dati inseriti. Non consentire nulla al di fuori dello schema necessario.

• Controlla i termini consentiti. Parole chiave SQL nella blacklist.

Potresti non conoscere i pericoli degli attacchi injection o considerarli insignificanti, ma sono in cima alla lista dei problemi di sicurezza. Inoltre, considera l'effetto di queste due voci:

1=1
-or-
*

Il codice che consente di inserire uno di questi insieme al comando corretto può comportare la rivelazione di tutti i dati utente sul database o l'eliminazione di tutti i dati sul database e nessuna delle due operazioni di iniezione è particolarmente intelligente. In alcuni casi, gli aggressori non passano nemmeno il tempo a esaminare i buchi; eseguono attacchi alla cieca con un semplice input.

Inoltre, considera gli strumenti di pattern matching e di espressioni regolari forniti da qualsiasi linguaggio di programmazione / scripting abbinato a MariaDB, che forniscono più controllo e talvolta un controllo migliore.

I dati servono come fondamento del business e delle operazioni e, con varie possibili minacce (ad esempio, attaccanti, errori di sistema, aggiornamenti errati ed errori di manutenzione), i backup rimangono fondamentali. Questi backup assumono molte forme ed esistono molte opzioni per crearli con una serie ancora più ampia di opzioni all'interno di tali processi. Le cose importanti da ricordare sono il tipo di database, le informazioni critiche e la struttura coinvolta. Questa informazione determina la tua migliore opzione.

OPZIONI

Le opzioni principali per i backup includono backup logici e backup fisici. I backup logici contengono istruzioni SQL per il ripristino dei dati. I backup fisici contengono copie dei dati.

• Logical backupsoffrono la flessibilità di ripristinare i dati su un'altra macchina con una configurazione diversa rispetto ai backup fisici, che sono spesso limitati alla stessa macchina e tipo di database. I backup logici vengono eseguiti a livello di database e tabella e fisici a livello di directory e file.

• Physical backupssono di dimensioni inferiori a quelle logiche e richiedono anche meno tempo per l'esecuzione e il ripristino. I backup fisici includono anche i file di registro e di configurazione, ma i backup logici no.

Strumenti di backup

Lo strumento principale utilizzato per i backup di MariaDB è mysqldump. Offre backup logici e flessibilità. Si rivela anche un'ottima opzione per piccoli database.Mysqldumpscarica i dati in SQL, CSV, XML e molti altri formati. Il suo output non conserva stored procedure, viste ed eventi senza istruzioni esplicite.

Ci sono tre opzioni per mysqldump backup -

• Raw data - Scarica una tabella come file di dati non elaborati tramite l'opzione --tab, che specifica anche la destinazione del file -

$ mysqldump -u root -p --no-create-info \
   --tab=/tmp PRODUCTS products_tbl

• Data/Definitions export- Questa opzione consente di esportare una o più tabelle in un file e supporta il backup di tutti i database esistenti sulla macchina host. Esamina un esempio di esportazione di contenuti o definizioni in un file

$ mysqldump -u root -p PRODUCTS products_tbl > export_file.txt

• Transfer - È inoltre possibile inviare in output database e tabelle a un altro host

$ mysqldump -u root -p database_name \
   | mysql -h other-host.com database_name

Utilizzo dell'istruzione SELECT ... INTO OUTFILE

Un'altra opzione per esportare i dati utilizza l'istruzione SELECT ... INTO OUTFILE. Questa semplice opzione restituisce la tabella in un semplice file di testo formattato -

mysql> SELECT * FROM products_tbl
   -> INTO OUTFILE '/tmp/products.txt';

I suoi attributi consentono di formattare il file in base alle specifiche preferite.

Nota le seguenti qualità di questa dichiarazione:

• Il nome del file deve specificare la posizione desiderata per l'output.

• Sono necessari i privilegi di file MariaDB per eseguire l'istruzione.

• Il nome del file di output deve essere univoco.

• Hai bisogno delle credenziali di accesso sull'host.

• In un ambiente UNIX, il file di output è leggibile in tutto il mondo, ma la proprietà del server influisce sulla possibilità di eliminarlo. Assicurati di disporre dei privilegi.

Utilizzo di CONNECT nei backup

Il gestore CONNECT consente l'esportazione dei dati. Ciò si rivela utile principalmente nelle situazioni in cui l'operazione SELECT ... INTO OUTFILE non supporta il formato del file.

Rivedi il seguente esempio:

create table products
engine = CONNECT table_type = XML file_name = 'products.htm' header = yes
option_list = 'name = TABLE,coltype = HTML,attribute = border = 1;cellpadding = 5'

select plugin_name handler, plugin_version version, plugin_author
author, plugin_description description, plugin_maturity maturity
from information_schema.plugins where plugin_type = 'STORAGE ENGINE';

Altri strumenti

Altre opzioni per i backup sono le seguenti:

• XtraBackup- Questa opzione si rivolge ai database XtraDB / InnoDB e funziona con qualsiasi motore di archiviazione. Ulteriori informazioni su questo strumento dal sito ufficiale di Percona.

• Snapshots- Alcuni filesystem consentono gli snapshot. Il processo consiste nello svuotare le tabelle con il blocco di lettura, montare l'istantanea, sbloccare le tabelle, copiare l'istantanea e quindi smontare l'istantanea.

• LVM- Questo popolare metodo utilizza uno script Perl. Ottiene un blocco di lettura su ogni tabella e scarica le cache su disco. Quindi ottiene un'istantanea e sblocca le tabelle. Consulta il funzionariomylvmbackup sito web per ulteriori informazioni.

• TokuBackup- Questa soluzione fornita da Percona fornisce backup a caldo tenendo conto dei problemi e dei limiti delle opzioni di backup di InnoDB. Produce una copia audio transazionale dei file mentre le applicazioni continuano a manipolarli.Consultare il sito Web di Percona per ulteriori informazioni.

Considerazioni su INNODB

InnoDB utilizza un pool di buffer per migliorare le prestazioni. In un backup, configurare InnoDB per evitare di copiare un'intera tabella nel pool di buffer poiché i backup logici in genere eseguono scansioni complete della tabella.

In questo capitolo impareremo i vari metodi di caricamento dei backup. Il ripristino di un database da un backup è un processo semplice ea volte terribilmente lungo.

Sono disponibili tre opzioni per il caricamento dei dati: l'istruzione LOAD DATA, mysqlimport e un semplice ripristino di mysqldump.

Utilizzo di LOAD DATA

L'istruzione LOAD DATA funziona come un caricatore di massa. Rivedi un esempio del suo utilizzo che carica un file di testo -

mysql> LOAD DATA LOCAL INFILE 'products_copy.txt' INTO TABLE empty_tbl;

Notare le seguenti qualità di un'istruzione LOAD DATA:

• Utilizza la parola chiave LOCAL per impedire a MariaDB di eseguire una ricerca approfondita dell'host e utilizza un percorso molto specifico.

• L'istruzione assume un formato costituito da righe terminate da avanzamenti riga (newline) e valori di dati separati da tabulazioni.

• Utilizzare la clausola FIELDS per specificare in modo esplicito la formattazione dei campi su una riga. Utilizzare la clausola LINES per specificare la fine della riga. Rivedi un esempio di seguito.

mysql> LOAD DATA LOCAL INFILE 'products_copy.txt' INTO TABLE empty_tbl
   FIELDS TERMINATED BY '|'
   LINES TERMINATED BY '\n';

• L'istruzione presuppone che le colonne all'interno del file di dati utilizzino lo stesso ordine della tabella. Se è necessario impostare un ordine diverso, è possibile caricare il file come segue:

mysql> LOAD DATA LOCAL INFILE 'products_copy.txt' INTO TABLE empty_tbl (c, b, a);

Utilizzando MYSQLIMPORT

Lo strumento mysqlimport funge da wrapper LOAD DATA consentendo le stesse operazioni dalla riga di comando.

Caricare i dati come segue:

$ mysqlimport -u root -p --local database_name source_file.txt

Specificare la formattazione come segue:

$ mysqlimport -u root -p --local --fields-terminated-by="|" \
   --lines-terminated-by="\n" database_name source_file.txt

Utilizzare il --columns opzione per specificare l'ordine delle colonne -

$ mysqlimport -u root -p --local --columns=c,b,a \
   database_name source_file.txt

Utilizzando MYSQLDUMP

Ripristino con mysqldump richiede questa semplice istruzione per caricare nuovamente il file di dump nell'host -

shell> mysql database_name < source_file.sql

PERSONAGGI E CITAZIONI SPECIALI

In un'istruzione LOAD DATA, virgolette e caratteri speciali potrebbero non essere interpretati correttamente. L'istruzione assume valori non quotati e tratta i backslash come caratteri di escape. Utilizza la clausola FIELDS per specificare la formattazione. Punta alle virgolette con "ENCLOSED BY", che causa la rimozione delle virgolette dai valori dei dati. Cambia escape con "ESCAPED BY".

Questo capitolo contiene un elenco delle funzioni utilizzate più di frequente, offrendo definizioni, spiegazioni ed esempi.

Funzioni aggregate di MariaDB

Le funzioni aggregate utilizzate più di frequente sono fornite di seguito:

Suor n	Nome e descrizione
1	COUNT Conta il numero di record. Example - SELEZIONA COUNT (*) DA customer_table;
2	MIN Rivela il valore minimo di un insieme di record. Example - SELEZIONA organizzazione, MIN (account) DA contratti GROUP BY organizzazione;
3	MAX Rivela il valore massimo di un insieme di record. Example - SELEZIONA organizzazione, MAX (account_size) DA contratti GROUP BY organizzazione;
4	AVG Calcola il valore medio di un insieme di record. Example - SELEZIONA AVG (account_size) DA contratti;
5	SUM Calcola la somma di un insieme di record. Example - SELEZIONA SUM (account_size) FROM contratti;

MariaDB Calcolo dell'età

Il TIMESTAMPDIFF funzione fornisce un modo per calcolare l'età -

SELECT CURDATE() AS today;
SELECT ID, DOB, TIMESTAMPDIFF(YEAR,DOB,'2015-07-01') AS age FROM officer_info;

Concatenazione di stringhe MariaDB

Il CONCATfunzione restituisce la stringa risultante dopo un'operazione di concatenazione. Puoi utilizzare uno o più argomenti. Rivedi la sua sintassi fornita di seguito -

SELECT CONCAT(item, item,...);

Rivedi il seguente esempio:

SELECT CONCAT('Ram', 'bu', 'tan');
Output:Rambutan

Funzioni data / ora di MariaDB

Di seguito sono riportate importanti funzioni di data:

Suor n	Nome e descrizione
1	CURDATE() Restituisce la data nel formato aaaa-mm-gg o aaaammgg. Example - SELEZIONA CURDATE ();
2	DATE() Restituisce la data in più formati. Example −CREATE TABLE product_release_tbl (x DATE);
3	CURTIME() Restituisce l'ora nel formato HH: MM: SS o HHMMSS.uuuuuu. Example - SELEZIONA CURTIME ();
4	DATE_SUB() Aggiunge o sottrae un numero di giorni dalla data specificata. Example - SELEZIONA DATE_SUB ('08/02/2016', INTERVALLO 60 GIORNI);
5	DATEDIFF() Determina i giorni tra due date. Example - SELEZIONA DATEDIFF ('01/01/2016 23:59:59', '03/01/2016');
6	DATE ADD() Aggiunge o sottrae qualsiasi unità di tempo alla / dalla data e ora. Example - SELEZIONA DATA_ADD ('04-01-2016 23:59:59', INTERVALLO 22 SECONDI);
7	EXTRACT() Estrae un'unità dalla data. Example - SELEZIONA ESTRATTO (ANNO DA "2016-01-08");
8	NOW() Restituisce la data e l'ora correnti nel formato aaaa-mm-gg hh: mm: ss o aaaammgghhmmss.uuuuuu. Example - SELEZIONA ORA ();
9	DATE FORMAT() Formatta la data in base alla stringa di formato specificata. Example - SELEZIONA DATE_FORMAT ('2016-01-09 20:20:00', '% W% M% Y');

Di seguito sono riportate alcune importanti funzioni temporali:

Suor n	Nome e descrizione
1	HOUR() Restituisce l'ora del tempo o le ore trascorse. Example - SELEZIONA ORA ('19: 17: 09 ');
2	LOCALTIME() Funziona esattamente come NOW ().
3	MICROSECOND() Restituisce i microsecondi del tempo. Example - SELEZIONA MICROSECONDO ('16: 30: 00.543876 ');
4	MINUTE() Restituisce i minuti del tempo. Example - SELEZIONA MINUTO ('22/05/2016 17:22:01');
5	SECOND() Restituisce i secondi della data. Example - SELEZIONA SECONDO ('2016-03-12 16: 30: 04.000001');
6	TIME_FORMAT() Formatta l'ora in base alla stringa di formato specificata. Example - SELEZIONA TIME_FORMAT ('22: 02: 20 ','% H% k% h% I% l ');
7	TIMESTAMP() Fornisce un timestamp per un'attività nel formato aaaa-mm-gg hh: mm: gg. Example - CREATE TABLE orders_ (ID INT, tmst TIMESTAMP);

Funzioni numeriche MariaDB

Di seguito sono riportate alcune importanti funzioni numeriche in MariaDB:

Suor n	Nome e descrizione
1	TRUNCATE() Restituisce un numero troncato nella specifica della posizione decimale. Example - SELEZIONA TRONCA (101.222, 1);
2	COS() Restituisce il coseno di x radianti. Example - SELEZIONA COS (PI ());
3	CEILING() Restituisce il numero intero più piccolo non inferiore a x. Example - SELEZIONA SOFFITTO (2.11);
4	DEGREES() Converte i radianti in gradi. Example - SELEZIONA GRADI (PI ());
5	DIV() Esegue la divisione intera. Example - SELEZIONA 100 DIV 4;
6	EXP() Restituisce e alla potenza di x. Example - SELEZIONA EXP (2);
7	FLOOR() Restituisce il numero intero più grande non sopra x. Example - SELEZIONA PIANO (2.01);
8	LN() Restituisce il logaritmo naturale di x. Example - SELEZIONA LN (3);
9	LOG() Restituisce il logaritmo naturale o il logaritmo a una data base. Example - SELEZIONA LOG (3);
10	SQRT() Restituisce la radice quadrata. Example - SELEZIONA SQRT (16);

Funzioni stringa MariaDB

Di seguito vengono fornite importanti funzioni per le stringhe:

Suor n	Nome e descrizione
1	INSTR() Restituisce la posizione della prima istanza di una sottostringa. Example - SELEZIONA INSTR ('rambutan', 'tan');
2	RIGHT() Restituisce i caratteri di stringa più a destra. Example - SELEZIONA DESTRA ('rambutan', 3);
3	LENGTH() Restituisce la lunghezza in byte di una stringa. Example - SELEZIONA LUNGHEZZA ('rambutan');
4	LOCATE() Restituisce la posizione della prima istanza di una sottostringa. Example - SELEZIONA LOCALIZZA ('tan', 'rambutan');
5	INSERT() Restituisce una stringa, con una sottostringa specificata in una certa posizione, che è stata modificata. Example - SELEZIONA INSERT ('ramputan', 4, 1, 'b');
6	LEFT() Restituisce i caratteri più a sinistra. Example - SELEZIONA SINISTRA ('rambutan', 3);
7	UPPER() Cambia i caratteri in maiuscolo. Example - SELEZIONA MAIUSCOLO (cognome);
8	LOWER() Cambia i caratteri in minuscolo. Example - SELEZIONA INFERIORE (cognome);
9	STRCMP() Confronta le stringhe e restituisce 0 quando sono uguali. Example - SELEZIONA STRCMP ('uovo', 'formaggio');
10	REPLACE() Restituisce una stringa dopo aver sostituito i caratteri. Example - SELEZIONA SOSTITUISCI ('sully', 'l', 'n');
11	REVERSE() Inverte i caratteri in una stringa. Example - SELEZIONA RETROMARCIA ("macchina da corsa");
12	REPEAT() Restituisce una stringa che ripete i caratteri dati x volte. Example - SELEZIONA RIPETIZIONE ('ha', 10);
13	SUBSTRING() Restituisce una sottostringa da una stringa, a partire dalla posizione x. Example - SELEZIONA SUBSTRING ('rambutan', 3);
14	TRIM() Rimuove i caratteri finali / iniziali da una stringa. Example - SELEZIONA TRIM (LEADING '_' FROM '_rambutan');