Mattepuffo.com

Più o meno tutti conosciamo Apache e Tomcat e il ruolo che hanno.

Apache è uno dei web server più usati ed in genere viene usato come web server per applicazioni scritte in PHP.

Tomcat è invece è un contenitore Servlet e viene usato per le applicazioni web scritte in Java (JSP e Servlet appunto).

In genere Apache gira sulla porta 80 e Tomcat sulla 8080.

Può rendersi necessario però fare in modo che anche i servizi di Tomcat siano raggiungibili senza indicare la porta, in quanto è una cosa scomoda.

E' possibile infatti integrare le due applicazioni per evitare ciò.

Prima di tutto installate e configurate Apache.

Poi installate e configurate Tomcat.

Una volta accertati che tutto funziona dobbiame riprendere in mano la configurazione di Apache.

Per integrare i due abbiamo principalmente due opzioni:

• usare un ReverseProxy -> più lento ma più semplice da mettere su
• usare il connettore jk -> più veloce ma richiede un pò più di configurazione

Cominciamo dal ReverseProxy.

Supponiamo di voler accedere alla pagina http://localhost:8080/book/index.jsp.

Creare Foreign Key con MySQL è abbastanza semplice.

Create le tabelle di tipo InnoDB e in fase di creazione della tabella aggiungete le FK:

CREATE TABLE libro (
  id INT auto_increment, 
  titolo VARCHAR (200), 
  editore INT NOT NULL, 
  PRIMARY KEY id (id), 
  INDEX editore_key (editore),
  FOREIGN KEY (editore) REFERENCES editore(id)
    ON DELETE NO ACTION
    ON UPDATE NO ACTION)
TYPE=InnoDB;

Come vedete abbiamo impostato una FK che si riferisce ad una tabella editore.

Il problema però è come gestire poi le relazioni quando andiamo a modificare/eliminare dei valori nella tabella collegata.

Nella maggior parte dei casi per fare delle ricerche non precise, si usa LIKE.

LIKE però soffre di lentezza quando esegue query pesanti.

Un modo per ovviare è usare ricerche Full-Text che sono parecchie più performanti.

Non è tutto oro quel luccica però perchè per usare Full-Text bisogna tenere in considerazione alcune cose:

• è possibile farla solo su campi di tipo testo
• bisogna creare un indice full-text
• le tabelle non possono esserer di tpo InnoDB

Comunque, prima di tutto creiamo un indice:

ALTER TABLE tabellaADD FULLTEXT(campo1, campo2, campo3, ...);

L'indice può anche essere aggiunto in fase di creazione tabella ovviamente.

In MySQL è molto facile concatenare più campi.

In genere l'SQL prevede l'uso di || che equivale a OR, ma questo funziona solo è attivato l’SQL MODE PIPES_AS_CONCAT.

Nel caso non fosse attivato otterremo un risultato strano:

mysql> SELECT author_name||"-"||editor_name AS CONC FROM bookv LIMIT 5;
+------+
| CONC |
+------+
|    0 |
|    0 |
|    0 |
|    0 |
|    0 |
+------+

Per ovviare si possono usare le funzioni CONCAT()  e CONCAT_WS().

Ovviamente posiamo concatenare campi di diverso tipo, come un VARCHAR e un DECIMAL.

La sintassi base è:

SELECT CONCAT(campo1, campo2, campo3, ....);

Ovviamente possiamo mettere anche stringhe di separazione.

L'istruzione TRUNCATE TABLE di MySQL serve per svuotare le tabelle ed azzerare eventuali inidici.

Il problema è che nel caso in cui due tabelle siano collegate tramite foreign key questa istruzione da errore.

Ad esempio io ho una tabella pacchetti e una tabella articoli che ha un FK verso pacchetti.

Se provo a svuotare pacchetti:

mysql> TRUNCATE pacchetti;

ERROR 1701 (42000): Cannot truncate a table referenced in a foreign key constraint (`compagnia`.`articoli`, CONSTRAINT `pacchetto_codice_FK` FOREIGN KEY (`pacchetto_codice`) REFERENCES `compagnia`.`pacchetti` (`pacchetto_codice`))

Si potrebbe usare DELETE, ma non azzera gli indici.

Come fare?

Asp.NET è la teconologia per la creazione di applicazioni e servizi web di Microsoft.

Potremmo o vorremo però far girare un'applicazione Asp.NET su Apahce e Linux.

Tutto ciò non è impossibile (anche se ovviamente non propio consigliato).

Vediamo come.

Ho fatto qualche test su Debian e vi posto le operazioni.

Prima di tutto dobbiamo installare un pò di roba:

#aptitude install mono-xsp2 mono-apache-server2 libapache2-mod-mono mono-gmcs mono-utils

Come vedete abbiamo installato un pò di Mono, un progetto molto interessante che si occupa di importare bel pò di .NET Framework in Linux/MAC.

A questo punto dobbiamo modificare il file mod_mono.conf.

L'altro giorno mi è capitato questo problema: dovevo importare tutti i valori da una tabella di un db Informix in una tabella MySQL.

Abbiamo esportato tutti i valori dal db Informix e questo è ciò che viene fuori:

NULL;CODICE-61;DESCRIZIONE-1; ;

NULL;CODICE-63;DESCRIZIONE-2; ;

NULL;CODICE-64;DESCRIZIONE-3; ;

Tutte queste righe vanno importate in MySQL.

Come vedete non ci sono istruzioni INSERT preconfezionate come fanno i db moderni.

Supponiamo di avere un tabella per la registrazione degli utenti che, come accade di solito, richiede un indirizzo email.

Per nostre statistiche vogliamo contare quanti indirizzi email, raggrupati per dominio, ci sono.

Oggi vi parlo di due importanti operatori di MySQL: IN e BETWEEN.

Per spiegarli al meglio partiamo da questo esempio:

SELECT * FROM author WHERE author_name='clive cussler' OR author_name='stephen king' OR author_name='alessandro cecchi paone';
+-----------+-------------------------+
| author_id | author_name             |
+-----------+-------------------------+
|        46 | alessandro cecchi paone |
|         2 | clive cussler           |
|         3 | stephen king            |
+-----------+-------------------------+

La query restituisce tutti i record che hanno nel campo nome uno dei seguenti valori: clive cussler, stephen king o alessandro cecchi paone.

Bhe non è proprio elegante come query, soprattutto se i valori da ricercare aumentano.

MySQL dispone di una serie di funzioni aggregate per i più disparati compiti.

Vediamo quelle più usate e comuni.

MAX

Restituisce il valore più alto di una colonna.

Nei capi numerici restituisce il valore più alto; nei campi testuali invece restituisce quello che ha l'iniziale più avanti nell'alfabeto.

SELECT MAX(campo) FROM tabella;

MIN

Fa l'opposto di MAX.

SELECT MIN(campo) FROM tabella;