Ricerche IT

La versione pacchettizzata di MySQL Server 5 per Linux Debian Etch 4.0 ha una caratteristica, non accetta connessioni sulla porta 3306 (la porta a cui risponde MySQL) se non da localhost, cioè sé stesso. Questo può essere un problema se vogliamo o dobbiamo tenere due macchine separate per un’applicazione (o sito) ed il relativo database.

La soluzione al problema è molto semplice, si tratta di commentare la seguente voce

bind-address = 127.0.0.1

presente nel file di configurazione di MySQL, /etc/mysql/my.cnf, dopodiché, dobbiamo abilitare uno o più utenti per poter connettersi in remoto su un particolare database utilizzando l’istruzione SQL GRANT:

GRANT ALL privileges ON testDB.* TO 'testUSR'@'192.168.0.3' IDENTIFIED BY 'testPWD'

così facendo, si abilita l’utente testUSR a connettersi al database testDB dall’host 192.168.0.3. A questo punto, è sufficiente far ripartire il demone di MySQL per abilitare la modifica effettuata al file my.cnf:

/etc/init.d/mysql restart

e questo è tutto.

Se dobbiamo installare Wordpress su un server con un’installazione pulita di MySQL (dando per scontato di aver correttamente installato e configurato Apache, PHP e MySQL), per prima cosa dovremo creare il database in cui verranno messe tutte le tabelle relative a Wordpress, e l’utente MySQL che avrà pieno accesso al database, ipotizzando di denominare il database "wordpressDB", a cui potrà accedere con i pieni privilegi l’utente "wordpressUSR" con password "wordpressPWD".

La prima cosa da fare, trattandosi di un’installazione pulita di MySQL, è quella di assegnare una password al superutente (root) di MySQL, tramite il comando:

> mysqladmin -u root -p PasswordROOT

dove per PasswordROOT si intende la password assegnata all’utente root.

A questo punto è possibile connettersi a MySQL come superutente per preparare il database su cui si appoggerà Wordpress col comando:

> mysql -u root -p

che richiederà di inserire la password del superutente. Una volta entrati in MySQL, creare il database per Wordpress:

mysql> create database wordpressDB;

quindi, creare l’utente MySQL "wordpressUSR" ed assegnarli tutti i privilegi sul database "WordpressDB":

mysql> grant all privileges on wordpressDB.* to ‘wordpressUSR’@'localhost’ identified by ‘wordpressPWD’;

Ora non rimane altro che rinominare il file wp-config-sample.php in wp-config.php e configurare queste quattro righe nel modo seguente:

define(’DB_NAME’, ‘wordpressDB’);    // The name of the database
define(’DB_USER’, ‘wordpressUSR’);     // Your MySQL username
define(’DB_PASSWORD’, ‘wordpressPWD’); // …and password
define(’DB_HOST’, ‘localhost’);

Siamo al passo finale, basta connettersi tramite browser al sito http://indirizzoblog/wp-admin/install.php e procedere con l’installazione (veramente semplicissima) di Wordpress.

SQL Server 2005 Express è il database gratuito di Microsoft appartenente alla serie SQL Server 2005, e si pone quindi come successore di MSDE, il database rilasciato gratuitamente da Microsoft fino alla serie SQL Server 2000. Questa versione di SQL è liberamente scaricabile dal sito Microsoft e richiede il framework .NET 2.0, altrimenti non si installa.

Il grosso limite di SQL Express è che non ha un’interfaccia visuale di gestione, per cui andrà gestito da linea di comando (a meno di non avere un’altra installazione di SQL Server attiva sulla rete o di altri tool che al momento non conosco), ma soprattutto, in modo predefinito, SQL Express non accetta connessioni da altri host.

Per permettere a SQL Express di accettare connessioni da altri host, è necessario per prima cosa aprire il tool di configurazione di SQL Express che prende il nome di SQL Configuration Manager, quindi da lì andare in "SQL Server 2005 Network Configuration", poi su "Protocols for SQLEXPRESS", quindi abilitare il protocollo TCP/IP. Fatto questo, andare nel registro di configurazione e impostare il valore HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Microsoft SQL Server\90\SQL Browser\Ssrplistener a 1, dopodiché bisogna abilitare l’avvio automatico del servizio "SQL Server Browser", poi bisogna avviarlo ed infine riavviare il servizio "SQL Server (SQLEXPRESS). Ora, oltre a rendere possibile l’accesso ad altri host, è possibile anche amministrare la nostra installazione di SQL col tool da riga di comando SQLCMD, tramite il comando:

sqlcmd -E -S nomeserverSQL\nomeistanzaSQL,1434

dove per nomeserverSQL si intende il nome host del PC su cui è installato SQL Express, per nomeistanzaSQL si intende il nome che si è dato all’istanza in fase d’installazione (il nome dell’istanza predefinita è MSSQL$EXPRESS) e per 1434 si intende la porta TCP su cui risponde SQL Express.

A questo punto, è abbastanza probabile che si vogliano riutilizzare database utilizzati in precedenza con SQL Server 2000 o con MSDE; se abbiamo i file del database (.mdf e .ldf), è possibile metterli nella cartella predefinita in cui sono contenuti i database di sistema di SQL Express e quindi, tramite T-SQL, creare un nuovo database facendo un attach dei file già esistenti:

> CREATE DATABASE nuovoDB ON
> (FILENAME = ‘c:\program files\Microsoft SQL Server\MSSQL.1\MSSQL\Data\nomefileDB.mdf’) FOR ATTACH;

in questo modo SQL Express crea il nuovo database agganciando i vecchi dati in nostro possesso, facendo una conversione nel nuovo formato se stiamo facendo l’attach di un database SQL Server 2000

E’ inoltre possibile che esistano applicazioni distribuite sulla rete locale che devono accedere al database SQL Express presente su un server, per cui in questo caso possono servire i driver nativi per accedere al database via ODBC o via OLE DB. Questi driver sono installati con un pacchetto messo a disposizione di Microsoft e chiamato "Microsoft SQL Server Native Client", scaricabile ovviamente dal sito Microsoft.

Per amministrare la nostra installazione di SQL Express 2005, è possibile anche scaricare ed installare SQL Server Management Studio Express, che altro non è che l’erede di Enterprise Manager, ovvero la console MMC di gestione visuale di SQL Server, in questo modo non siamo legati per forza all’amministrazione di SQL Express da riga di comando.

Può capitare di dover importare dei dati in un database di un’applicazione partendo da un file Excel. In questi casi, può essere una buona soluzione convertire il file di Excel in un file di testo (ad esempio un file CSV) ed importare i dati presenti nel file di testo in una o più tabelle del nostro DB. In questo caso prendiamo in esame un’applicazione ASP che si poggia su un database MySQL, con il file di dati trasformato da Excel in CSV, coi campi delimitati dal ";". In MySQL esiste un comando, load data infile, che permette appunto di importare file di testo in una tabella a scelta, peccato che questa procedura non si adatti a tutte le situazioni, ad esempio, non funziona quando non si ha un accesso diretto al server Web, oppure se il file contiene dati che non vanno su un’unica tabella ma che, essendo un file di testo una tabella di un database "piatto", non ha un minimo di normalizzazione, da ricreare in fase di importazione.

Una situazione tipica può essere quella di un file di testo contenente una lista di dipendenti e delle relative aziende di appartenenza, infatti esistendo più dipendenti per ogni azienda, le informazioni relative ad ogni singola azienda vengono ripetute diverse volte, e quindi questi dati non possono essere importati in una singola tabella, ma dovranno essere posti in due tabelle, aziende e dipendenti, in relazione uno a molti; in questo caso, non può essere usata l’istruzione load data infile, poiché, a quanto ne so io, questo comando non supporta l’inserimento in due tabelle distinte. Intanto vediamo da quali campi è composto il file CSV e come questi campi verranno distribuiti nelle due tabelle "Dipendenti" e "Aziende":

File CSV

Cognome;Nome;Via;CAP;Localita;CodiceFiscale;NomeAzienda;
ViaAzienda;CAPAzienda;LocalitaAzienda;PartitaIVA

Tabella Dipendenti

idDipendente int not null auto_increment primary key
cognome varchar(30) not null
nome varchar(30) not null
via varchar(60)
CAP varchar(5)
localita varchar(60)
codiceFiscale varchar(16)
idAzienda int not null

Tabella Aziende

idAzienda int not null auto_increment primary key
nomeAzienda varchar(60) not null
viaAzienda varchar(60)
CAPAzienda varchar(5)
localitaAzienda varchar(60)
partitaIVA varchar(11)

A questo punto vediamo come impostare il codice vbscript della pagina ASP. Per prima cosa bisognerà aprire il file di testo che quindi dovrà essere posto in una cartella visibile del nostro server Web, utilizzando l’oggetto FileSystemObject per aprire il file e per scorrerlo; i primi dati a dover essere letti sono quelli relativi alle aziende, visto che poi dovrò associare i dipendenti all’azienda di appartenenza. Di seguito la prima parte del codice:

<%
Dim percorso, fileFSO, apriFile, rigaFile, arrRiga ‘dichiarazione delle variabili
Dim vNomeAzienda, vViaAzienda, vCAPAzienda, vLocalitaAzienda, vPartitaIVA
Dim conn, importTempAziende, importAziende, truncateTempAziende, queryAzienda, rsAzienda, importIscritti
Dim vidAzienda, vCognome, vNome, vVia, vCAP, vLocalita, vCodiceFiscale, vPartitaIVAAzienda
set conn = server.CreateObject("ADODB.Connection") ‘creazione dell’oggetto di connessione al database
conn.ConnectionString = "DRIVER={MySQL ODBC 3.51 Driver}; SERVER=localhost; DATABASE=prova; UID=prova; PWD=prova; OPTION=3" ‘opzioni di connessione al DB
conn.Open ‘apertura della connessione al DB
percorso = Server.MapPath("filecsv.csv") ’si specifica il percorso relativo del file da aprire. Server.MapPath serve per convertire un percorso virtuale in un percorso fisico
set fileFSO = server.CreateObject("Scripting.FileSystemObject") ‘crea una nuova istanza dell’oggetto FileSystemObject
if fileFSO.FileExists(percorso) then ‘utilizzo - all’interno di una struttura condizionale if… then… else - il metodo FileExists per verificare se il file esiste
set apriFile = fileFSO.openTextFile(percorso, 1) ‘utilizzo il metodo openTextFile per aprire il file csv in sola lettura (il numero 1 significa l’apertura del file in sola lettura)
do until apriFile.AtEndOfStream ‘uso un ciclo per leggere riga per riga il file fino ad arrivare alla fine tramite la proprietà AtEndOfStream
rigaFile = apriFile.ReadLine ‘uso il metodo ReadLine per leggere una riga del file di testo e trasformarla in stringa
arrRiga = split(rigaFile, ";") ‘tramite la funzione split trasformo la stringa ottenuta tramite il metodo ReadLine in un array
vNomeAzienda = arrRiga(6) ‘assegno alla variabile vNomeAzienda il valore relativo al nome dell’azienda pescato nell’array creato precedentemente
vNomeAzienda = replace(vNomeAzienda, "’", "”") ’sostituzione dell’apice con un doppio apice per permettere l’inserimento nella tabella senza problemi
vViaAzienda = arrRiga(7)
vViaAzienda = replace(vViaAzienda, "’", "”")
vCAPAzienda = arrRiga(8)
vLocalitaAzienda = arrRiga(9)
vLocalitaAzienda = replace(vLocalitaAzienda, "’", "”")
vPartitaIVA = arrRiga(10)
%>

Ora abbiamo tutti gli elementi che ci servono per inserire i dati relativi alle aziende in una tabella di transito, infatti non è possibile inserire direttamente i dati nella tabella Aziende, poiché i dati sarebbero duplicati e quindi il database di fatto inutile, quindi di seguito verrà fatto in modo di inserire questi dati nella tabella "transitoAziende", e da qui si prenderanno i dati filtrati in modo da non avere record duplicati per inserirli nella tabella "Aziende".

<%
ImportTempAziende = "INSERT INTO tempAziende (nomeAzienda, viaAzienda, capAzienda, localitaAzienda, partitaIVA) " & _
VALUES (’" & vNomeAzienda & "’, ‘" & vViaAzienda & "’, ‘" & vCAPAzienda & "’, ‘" & vLocalitaAzienda & "’, ‘" & vPartitaIVA & "’)" ‘istruzione di inserimento dei dati prelevati dall’array nella tabella tempAziende
conn.Execute ImportTempAziende ‘esecuzione dell’istruzione SQL precedente
loop ‘termine del ciclo
end if ‘termine struttura condizionale
importAziende = "INSERT INTO aziende (nomeAzienda, viaAzienda, capAzienda, localitaAzienda, partitaIVA) " & _
SELECT nomeAzienda, viaAzienda, capAzienda, localitaAzienda, partitaIVA FROM tempAziende GROUP BY partitaIVA ‘istruzione per filtrare i dati dalla tabella tempAziende ed inserirli nella tabella aziende
truncateTempAziende = "TRUNCATE TABLE tempAziende" ‘istruzione per cancellare i dati di transito presenti all’interno della tabella tempAziende
conn.Execute importAziende ‘esecuzione dell’istruzione SQL definita nella variabile importAziende
conn.Execute truncateTempAziende ‘esecuzione dell’istruzione SQL definita nella variabile truncateTempAziende
set fileFSO = nothing ‘libero la memoria occupata dall’istanza fileFSO
%>

Con le istruzioni precedenti la procedura inserisce, riga per riga, i dati relativi alle aziende presenti nel file CSV nella tabella tempAziende, quindi fa in modo di filtrare i dati dalla tabella tempAziende ed eliminare i record duplicati tramite l’istruzione GROUP BY (utilizzando DISTINCT, se i dati non sono "perfetti", si rischia di non eliminare completamente i duplicati), quindi questi dati filtrati sono inseriti nella tabella aziende tramite un’unica istruzione SQL, "INSERT INTO SELECT"; infine, vengono cancellati i dati dalla tabella tempAziende essendo questi dati di natura temporanea. A questo punto bisogna inserire i dipendenti nella tabella "dipendenti". In primo luogo, dovrò riaprire il file "filecsv.csv" tramite il solito ciclo, ricreare l’array per ogni riga del file csv, ed "estrarre" dall’array i dati relativi ai dipendenti, e la partita IVA dell’azienda corrispondente per poter associare il dipendente all’azienda; come si può vedere, la prima parte del codice è identica alla parte precedente:

<%
set fileFSO = server.CreateObject("Scripting.FileSystemObject") ‘crea una nuova istanza dell’oggetto FileSystemObject
if fileFSO.FileExists(percorso) then ‘utilizzo - all’interno di una struttura condizionale if… then… else - il metodo FileExists per verificare se il file esiste
set apriFile = fileFSO.openTextFile(percorso, 1) ‘utilizzo il metodo openTextFile per aprire il file csv in sola lettura (il numero 1 significa l’apertura del file in sola lettura)
do until apriFile.AtEndOfStream ‘uso un ciclo per leggere riga per riga il file fino ad arrivare alla fine tramite la proprietà AtEndOfStream
rigaFile = apriFile.ReadLine ‘uso il metodo ReadLine per leggere una riga del file di testo e trasformarla in stringa
arrRiga = split(rigaFile, ";") ‘tramite la funzione split trasformo la stringa ottenuta tramite il metodo ReadLine in un array
vCognome = arrRiga(0) ‘assegno alla variabile vCognome il valore relativo al nome dell’azienda pescato nell’array creato precedentemente
vCognome = replace(vCognome, "’", "”") ’sostituzione dell’apice con un doppio apice per permettere l’inserimento nella tabella senza problemi
vNome = arrRiga(1)
vNome = replace(vNome, "’", "”")
vVia = arrRiga(2)
vVia = replace(vVia, "’", "”")
vCAP = arrRiga(3)
vLocalita = arrRiga(4)
vLocalita = replace(vLocalita, "’", "”")
vCodiceFiscale = arrRiga(5)
vPartitaIVAAzienda = arrRiga(10)
%>

Ottenuti i dati che ci servono, per ogni dipendente bisogna ricavare l’azienda di appartenenza, nel dettaglio significa fare una query sulla tabella Aziende cercando l’idAzienda corrispondente alla Partita IVA ricavata in precedenza. Se si fosse impostata la partita IVA come chiave primaria non sarebbe stato necessario dover fare questa query, ma in alcuni casi i dati che vengono forniti non sono poi così ben bonificati… Una volta ottenuto l’ID dell’azienda, è possibile inserire il dipendente nella tabella Dipendenti completo di Foreign Key, indispensabile per poter mettere in relazione la tabella Aziende con la tabella Dipendenti.

<%
queryAzienda = "SELECT idAzienda FROM aziende WHERE PI = ‘" & vPartitaIVAAzienda & "’" ‘definizione della query per ottenere l’idAzienda in base alla Partita IVA
set rsAzienda = server.CreateObject("ADODB.Recordset") ‘istanziazione recordset
rsAzienda.Open queryAzienda, conn, 3, 3 ‘apertura recordset
vidAzienda = rsAzienda("idAzienda") ‘assegnazione dell’ID dell’azienda alla relativa variabile
importIscritti = "INSERT INTO iscritti (cognome, nome, via, CAP, localita, codiceFiscale, idAzienda)  VALUES " & _
(’" & vCognome & "’, ‘" & vNome & "’, ‘" & vVia & "’, ‘" & vCAP & "’, ‘" & vLocalita & "’, ‘" & vCodiceFiscale & "’, " & vidAzienda & ")" ‘definizione dell’istruzione di inserimento dipendente
conn.Execute importIscritti ‘esecuzione dell’inserimento dipendente
loop ‘termine del ciclo
end if ‘termine struttura condizionale
set fileFSO = nothing ‘libero la memoria occupata dall’istanza fileFSO
rsAzienda.close ‘chiusura del recordset
set rsAzienda = nothing ‘libero memoria
conn.close ‘chiusura connessione al database
set conn = nothing ‘libero memoria
%>

Ora sono inseriti anche i dipendenti con indicata anche la loro azienda d’appartenenza. Siccome non sono esattamente un esperto di questi argomenti, ho affrontato la questione a modo mio, quindi molto probabilmente esistono modi più brillanti di risolvere il problema, nel mio caso questa soluzione ha l’indubbio pregio di funzionare. Chi volesse segnalare metodi migliori per affrontare la situazione può farlo tramite la pagina dei contatti.

Quando si devono esportare dei dati in una tabella di un database SQL, ovviamente la tabella di destinazione dovrà avere una chiave primaria, ed inoltre la tabella di destinazione potrà contenere dei vincoli Unique, in breve, situazioni in cui per uno o più campi non è possibile avere record duplicati.

Se la tabella di origine contiene record duplicati, ed abbiamo già impostato chiavi primarie, vincoli o indici sulla tabella di destinazione, l’esportazione non andrà a buon fine, proprio per i vincoli già impostati sulla tabella di destinazione che non permettono l’inserimento di dati se questi vincoli non vengono rispettati.

In questi casi è bene fare un’analisi preventiva sulla tabella di origine, cercando i record duplicati per capire dove intervenire per eliminarli. La ricerca di record duplicati viene effettuata tramite una semplice query come questa:

SELECT campo, count(*) AS numRecordDuplicati FROM tabellaEsempio GROUP BY campo HAVING count(*) > 1

Il risultato è una tabella in cui viene mostrato nella colonna "campo" il valore duplicato, mentre nella colonna "numRecordDuplicati" viene mostrato il numero di volte in cui il valore indicato nella colonna "campo" si ripete. Ora non rimane che analizzare i record duplicati facendo una query sulla tabella "tabellaEsempio" basata sui valori indicati ed analizzare i dati risultanti per verificare perché avviene la duplicazione.

Link di riferimento: html.it

Quando in MSSQL Server si trasferisce un database da un server da un altro, può succedere che un utente definito nel database non sia stato definito come login di accesso a SQL Server. Ad esempio, posso avere un utente del database chiamato DuffyDuck che non è definito come login di accesso. Se io creo un nuovo account SQL e lo chiamo DuckDodgers, questo non corrisponderà all’utente del database DuckDodgers, e ciò sarà fonte di problemi nell’accesso al database da parte delle applicazioni.

Per ovviare al problema bisogna mappare l’utente del database e l’account SQL, e ciò è possibile grazie all’utilizzo della stored procedure sp_change_users_login. Ipotizzando di avere un database chiamato "Universo", per collegare l’utente del database DuckDodgers al login SQL DuckDodgers, digitare la seguente istruzione T-SQL da Query Analyzer:

use universo
exec sp_change_users_login ‘update_one’, ‘DuckDodgers’, ‘DuckDodgers’
go

In questo modo ho risolto il problema.

Quando si utilizza un database, è sempre essenziale fare un salvataggio del DB. Con software di backup professionali si possono fare salvataggi automatizzati senza bisogno di impostazioni particolari, poiché il software utilizza in genere un agente in grado di interagire con il database e di fare il salvataggio.

Se però si utilizza ntbackup per il salvataggio dei dati, non siamo in possesso di questa funzione. Ntbackup può fare solamente il backup del filesystem (oltre al backup dello Store di Exchange e del System State), quindi, se ad esempio si volesse fare il backup dei database di SQL Server, è possibile salvare i file .mdf e .ldf previo arresto dei servizi di SQL Server: una soluzione non ottimale.

Un altro modo, più efficiente, è quello di schedulare il backup di un database direttamente da SQL Server stesso, in questo modo non è necessario fermare i servizi di SQL. Andare in SQL Server Enterprise Manager, recarsi sul proprio server e quindi accedere all’oggetto Gestione e cliccare col tasto destro sulla voce Backup -> Backup Database. Da questa finestra, scegliere il database di cui si vuole effettuare il backup (eventualmente cambiare il nome proposto di default e aggiungere una descrizione) e indicare il tipo di backup che si vuole effettuare. Se il database non è molto grande, si hanno meno scocciature scegliendo il tipo di backup “Database - completo”. Ora bisogna scegliere se effettuare il backup su nastro o su disco: se, come capita nella maggior parte delle piccole aziende, il server ha altri compiti oltre a fungere da DB Server, è meglio fare il backup del database su disco per poi fare un unico processo di backup su nastro che includerà anche il database salvato precedentemente. Fatto questo, scegliere se aggiungere o se sovrascrivere il supporto: nel caso del salvataggio su disco, in genere è meglio sovrascrivere, visto che comunque il backup vero e proprio avviene su nastro. Ora bisogna pianificare a seconda delle proprie esigenze la frequenza con cui avviene il salvataggio, anche se un salvataggio alla settimana nelle giornate lavorative (L, M, M, G, V) in genere è sufficiente nella maggior parte dei casi.

Nella scheda Opzioni, si può scegliere se fare una verifica al termine del backup e si può anche prevedere una scadenza del processo. Ora fatte queste scelte si può cliccare su Ok per confermare la schedulazione del salvataggio. La lista dei backup può essere visualizzata espandendo l’oggetto “Agente SQL Server” e andando nell’oggetto “Processi”, dove è anche possibile verificare se i salvataggi avvengono regolarmente.

Tenere conto del fatto che è il servizio SQL Server Agent che si occupa di effettuare il backup, quindi se questo servizio viene avviato da un utente specifico, assicurarsi che quell’utente abbia l’autorizzazione in lettura - scrittura sulla cartella prescelta per ospitare i salvataggi.