Stored Routine per gestire facilmente l’SQL_MODE

English version

Lavorare con l’SQL_MODE può essere sconfortante, perché è una lista di parole lunghe separata da virgole. Francamente odio riscrivere i flag, cercare di leggere una lista illeggibile, etc. Certo, alcune funzioni stringa possono aiutare (Justin Swanhart consiglia di usare REPLACE() per rendere leggibili le liste separate da virgola).

Ho fatto un piccolo set di Stored Routine che mi permettono in maniera semplice di mostrare l’SQL_MODE, aggiungere un flag, togliere un flag e controllare se il flag è presente. Queste routine lavorano con l’SQL_MODE globale; se non vi va bene, sostituite “@@global.” con “@@session.” nel file SQL prima di installarlo (facile, no?).

Potete scaricare (o migliorare) queste routine usando il repo SQL_MODER su GitHub.

E ora, qualche esempio.

Mostrare i flag attivi:

MariaDB [(none)]> CALL _.sql_mode_show();
+----------------------------+
| FLAG                       |
+----------------------------+
| ERROR_FOR_DIVISION_BY_ZERO |
| NO_AUTO_CREATE_USER        |
| NO_ENGINE_SUBSTITUTION     |
| NO_ZERO_DATE               |
| NO_ZERO_IN_DATE            |
| ONLY_FULL_GROUP_BY         |
| STRICT_ALL_TABLES          |
| STRICT_TRANS_TABLES        |
+----------------------------+
8 rows in set (0.46 sec)

(questo è l’SQL_MODE che consiglio di usare)

Verificare se un flag è attivo:

MariaDB [(none)]> SELECT _.sql_mode_is_set('HIGH_NOT_PRECEDENCE');
+------------------------------------------+
| _.sql_mode_is_set('HIGH_NOT_PRECEDENCE') |
+------------------------------------------+
|                                        0 |
+------------------------------------------+
1 row in set (0.38 sec)

Aggiungere uno o più flag:

MariaDB [(none)]> CALL _.sql_mode_set('NO_UNSIGNED_SUBTRACTION,HIGH_NOT_PRECEDEN
CE');
Query OK, 0 rows affected (0.07 sec)

MariaDB [(none)]> CALL _.sql_mode_show();
+----------------------------+
| FLAG                       |
+----------------------------+
| ERROR_FOR_DIVISION_BY_ZERO |
| HIGH_NOT_PRECEDENCE        |
| NO_AUTO_CREATE_USER        |
| NO_ENGINE_SUBSTITUTION     |
| NO_UNSIGNED_SUBTRACTION    |
| NO_ZERO_DATE               |
| NO_ZERO_IN_DATE            |
| ONLY_FULL_GROUP_BY         |
| STRICT_ALL_TABLES          |
| STRICT_TRANS_TABLES        |
+----------------------------+
10 rows in set (0.13 sec)

Query OK, 0 rows affected (2.09 sec)

Disattivare un flag:

MariaDB [(none)]> CALL _.sql_mode_unset('HIGH_NOT_PRECEDENCE');
Query OK, 0 rows affected (0.00 sec)

MariaDB [(none)]> SELECT _.sql_mode_is_set('HIGH_NOT_PRECEDENCE');
+------------------------------------------+
| _.sql_mode_is_set('HIGH_NOT_PRECEDENCE') |
+------------------------------------------+
|                                        0 |
+------------------------------------------+
1 row in set (0.00 sec)

Se hai sbagliato a digitare il flag (o non era impostato):

MariaDB [(none)]> CALL _.sql_mode_unset('hello world');
ERROR 1644 (45000): Flag 'hello world' was not set

A presto!

Annunci

MariaDB/MySQL: Procedure facili per leggere la Diagnostics Area

English version

UPDATE 2013-08-30: Ho risolto 2 bug e creato un repo su GitHub chiamato sql_diagnostix. Scusate se non l’ho fatto prima. Se io o chiunque altro troverà altri bug, aggiornerò il repo.

Il problema

Per visualizzare velocemente le informazioni sugli errori e i warning generati dall’ultima istruzione eseguita, è possibile utilizzare SHOW WARNINGS. Però i risultati di questa istruzione non possono essere lette via SQL, perciò non è possibile usarla per gestire gli errori in uno Stored Program.

A questo scopo si può usare GET DIAGNOSTICS, che ha però due problemi:

  • Richiede molto codice
  • Non esiste un modo facile per mostrare tutte le informazioni presenti nella Diagnostics Area.

Il primo problema può scoraggiare molti sviluppatori dall’usare GET DIAGNOSTICS.

Il secondo problema nella maggior parte dei casi non è così importante, perché le info mancanti sono SQLSTATE e le informazioni che possono essere impostate solo con SIGNAL e RESIGNAL, e che non possono essere lette da un programma esterno (SCHEMA_NAME, CURSOR_NAME, etc). Tuttavia leggere SQLSTATE può essere importante, e accedere a tutte le clausole di SIGNAL può aiutare nel debug e nella soluzione dei problemi… ecco perché esistono :-)

Oracle MySQL 5.7 ha due Diagnostics Area e supporta la parola chiave STACKED per accedere alla seconda DA da un error HANDLER. Questo però non aiuta molto: permette solo di eseguire un’altra istruzione che accede a una tabella, prima di leggere le informazioni sugli errori che si sono verificati. Perciò la DA STACKED non sembra in grado di risolvere problemi reali.

La soluzione

Ho creato tre Stored Procedure per risolvere questi problemi:

  • _.materialize_diagnostics_area()
  • _.show_diagnostics_area()
  • _.show_full_diagnostics_area()

Tutte le procedure creano una tabella temporanea MEMORY chiamata DIAGNOSTICS_AREA in un database chiamato _. Se la tabella esiste già, viene eliminata e ricreata. Incidentalmente viene anche cancellata la Diagnostics Area del server, ma le informazioni rimangono disponibili nella tabella finché non si chiama di nuovo una di queste procedure.

_.DIAGNOSTICS_AREA ha una colonna chiamata ID, che indica la posizione di ogni singola condizione nella Diagnostics Area. Le altre colonne sono uguali alle proprietà delle condizioni della Diagnostics Area (MYSQL_ERRNO, etc). L’unica eccezione è la colonna SQLSTATE, che usa il nome utilizzabile in SIGNAL e RESIGNAL, non quello usato nella Diagnostics Area (cioè RETURNED_SQLSTATE).

Siccome sia gli Stored Program, sia i programmi esterni possono accedere a _.DIAGNOSTICS_AREA, questa permette ai programmi esterni di leggere tutte le informazioni che si possono impostare con SIGNAL.

Si può chiamare direttamente materialize_diagnostics_area() per copiare interamente la DA nella tabella, per poi leggere le informazioni con delle query.

show_full_diagnostics_area() mostra tutte le informazioni, dopo aver popolato la tabella. E’ una sorta di SHOW WARNINGS con molte colonne in più.

show_diagnostics_area() mostra solo le colonne ID, SQLSTATE, MYSQL_ERRNO, MESSAGE_TEXT.

Esempio:

MariaDB [test]> INSERT INTO `t` VALUES (1/0), (1/0), (1/0), (-1);
Query OK, 4 rows affected, 4 warnings (0.07 sec)
Records: 4  Duplicates: 0  Warnings: 4
 
MariaDB [test]> CALL _.show_diagnostics_area();
+----+----------+-------------+--------------------------------------------+
| ID | SQLSTATE | MYSQL_ERRNO | MESSAGE_TEXT                               |
+----+----------+-------------+--------------------------------------------+
|  1 | 22012    |        1365 | Division by 0                              |
|  2 | 22012    |        1365 | Division by 0                              |
|  3 | 22012    |        1365 | Division by 0                              |
|  4 | 22003    |        1264 | Out of range value for column 'c' at row 4 |
+----+----------+-------------+--------------------------------------------+
4 rows in set (0.09 sec)

Limitazioni

Se uno Stored Program deve essere veloce, queste procedure possono essere utilizzate solo per il debug.

Come detto sopra, ogni chiamata elimina le informazioni già presenti nella tabella _.DIAGNOSTICS_AREA. E’ una scelta di progettazione.

C’è un’informazione presente nell’output di SHOW WARNING che però manca nella tabella _.DIAGNOSTICS_AREA: la colonna Level. Il motivo è che non sono riuscito a trovare nella documentazione di MySQL come distinguere un Warning da una Nota, se non con SHOW WARNINGS. Se non c’è modo, o se un modo esiste ma non è documentato, non posso aggiungere questa informazione.

La Diagnostics Area STACKED di 5.7 non viene condiderata.

Il codice

Va bene, ho scritto abbastanza. Ora, se siete interessati:

Scaricate il codice SQL

Non spiego qui il codice perché mi sembra molto semplice ed è commentato. Date un’occhiata a materialize_diagnostics_area() e capirete cosa ho fatto.

A presto!

Stoppare rapidamente MariaDB 10

English version

Nota semiseria: stavo per intitolare questo articolo “Arrestare rapidamente MariaDB”. Ma in italiano è veramente brutto…

Normalmente come si arresta un server MariaDB 5.5 o MySQL?

mysqladmin shutdown -uroot -p

Ma con MariaDB 10 (qualità alpha, mentre scrivo questo articolo) c’è un modo più rapido:

C:\Documents and Settings\utente1>mysql -uroot -p
Enter password:
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 3
Server version: 10.0.4-MariaDB mariadb.org binary distribution

Copyright (c) 2000, 2013, Oracle, Monty Program Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MariaDB [(none)]> SELECT 'I\'m alive!';
+------------+
| I'm alive! |
+------------+
| I'm alive! |
+------------+
1 row in set (0.00 sec)

MariaDB [(none)]> SHUTDOWN;
Query OK, 0 rows affected (0.00 sec)

MariaDB [(none)]> SELECT 'I\'m gone away';
ERROR 2006 (HY000): MySQL server has gone away
No connection. Trying to reconnect...
ERROR 2003 (HY000): Can't connect to MySQL server on 'localhost' (10061 "Unknown
 error")
ERROR: Can't connect to the server

unknown [(none)]> \q
Bye

Non ho idea se sia sicuro, o se sarà sicuro, su un server in produzione. Ma in locale è ottimo.

Divertitevi!

JavaScript non ha gli array associativi

English version

Questo post riguarda uno dei più comuni equivoci di JavaScript: gli array associativi.

JavaScript supporta la sintassi degli array associativi, ma non ha realmente questa struttura dati. Sarebbe inutile, perché possiamo usare gli oggetti.

Ecco un semplice oggetto:

var movie = {
    title : '2001: A space Odissey',
    director : 'Stanley Kubrick',
    year : 1968
};

Abbiamo definito una variabile oggetto (movie) con 3 proprietà (title, director, year). Siccome le proprietà sono sempre pubbliche in JavaScript, possiamo leggerle:

alert('Title: ' + movie.title);

Inoltre JavaScript è molto dinamico, perciò possiamo anche modificare le proprietà o crearne di nuove:

movie.genre = 'sf';

Possiamo poi utilizzare la sintassi classica degli array associativi per accedere alle proprietà di un oggetto:

alert('Title: ' + movie['title']);

Può sembrare inutile… e in questo esempio lo è davvero. E’ meglio non usare questa sintassi se non è necessario. Ma possiamo utilizzarla per accedere ad una proprietà che non conosciamo a priori:

var prop = 'title';
alert('Title: ' + movie[prop]);

E’ particolarmente utile nei cicli for … in, che sono l’equivalente JavaScript dei foreach:

for (var i in movie) {
    alert(i + ': ' + movie[i]);
}

Divertitevi!