ANSI C: giocare con la numerazione binaria per indovinare l’eta’

tavole per indovinare l'etàDiversi anni fa, ero alla ricerca di spunti divertenti e non troppo banali per insegnare agli allievi di un corso di programmazione in ANSI C
come funziona il sistema di numerazione binaria. Ho trovato su un vecchio libretto di curiosità matematiche un gioco per indovinare l’età attraverso l’utilizzo di tavole “magiche”. Va premesso che, ovviamente le tavole non sono magiche e vedremo il perché, e che per limiti di spazio, il gioco funziona solo per età inferiori ai 32 anni (la mia versione arriva a 64). Il gioco consiste nell’individuare la propria età in ciascuna delle colonne della figura a fianco, e segnare in quale di queste è presente. Mettiamo che individuate la vostra età nelle colonne 1,3,4,5 la vostra età è 29 anni.
Vediamo come sono composte le colonne, partendo da sinistra: la prima colonna è una serie di numeri dispari da 1 a 31, la seconda coppie alterne, la terza quadruple alterne, la quarta ottuple alterne e così via. A questo punto si intuisce che la tabella è un sistema per convertire i numeri decimali in cifre binarie, dove la prima colonna corrisponde a 20 nel sistema posizionale binario,
la seconda a 21, la terza a 22 e così via. Per calcolare l’età, quindi, basta sommare le intestazioni delle colonne dove essa viene individuata.
La stringa individuata, indicando con 1 e con 0 rispettivamente la presenza e l’assenza, e nel caso di 29 anni è 10111 che rovesciata da 11101 ovvero il numero 29 in notazione binaria. E’ necessario capovolgere la stringa perché, nella numerazione posizionale, la prima colonna si deve trovare a destra.

Questo è il codice in linguaggio C per l’implementazione del gioco. (Per comodità di costruzione dell’algoritmo, le colonne sono state trasposte in righe)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include 
#include 
 
int main(int argc, char *argv[])
{
  int i,j,a,b,tabella[6][32],anni=0;
  char risposta[6];    
  a=1;  
  tabella[0][0]=1;  
  for (i=0;i<6;i++){      
      printf("\nriga %d:\t",i+1);
      b=1;            
      for (j=0;j<32;j++){ if (j==0){ tabella[i][j]= a;} else {tabella[i][j] = tabella[i][j-1]+1;} if (b>a){
             tabella[i][j] = tabella[i][j] + a;
             b=1;   
          }                           
          printf("%2d ",tabella[i][j]);
          if (!((j+1)%16)) printf("\n\t");
          b++;                   
      }      
      a=a<<1;      
  }    
  printf("\nIn quale di queste righe e' presente la tua eta'?\n");  
  printf("\n(immettere: p.e. 110010 per indicare riga1, riga2, riga5)? ");      
  gets(risposta);      
  for (i=0;i<6;i++){ switch (i){ case 0: if (risposta[i]!='0') anni++; break; case 1: if (risposta[i]!='0') anni+=2; break; case 2: if (risposta[i]!='0') anni+=4; break; case 3: if (risposta[i]!='0') anni+=8; break; case 4: if (risposta[i]!='0') anni+=16; break; case 5: if (risposta[i]!='0') anni+=32; break; default: anni=-1; } } if (anni>0) printf ("\n Tu hai %d anni!\n",anni);
  else printf("\n hai sbagliato ad immettere i dati!\n");
  return 0;
}

output del programma per indovinare l'età

Notate che ho aggiunto la riga 6 (che corrisponde a 25) per avere a disposizione un range di età fra 1 e 63 anni.

Nella figura a fianco, l’output del programma per la mia età…

Più che la reale comprensione del giochino, forse la difficoltà maggiore si incontra nel strutturare l’algoritmo per la costruzione della tabella, io l’ho risolto così: un paio di cicli annidati e una serie di costrutti condizionali. Ho usato anche un operatore bit a bit per l’incremento della variabile a, nei casi di moltiplicazione *2 (shift a sinistra) è estremamente veloce!
Mi aspetto che ci siano altri modi anche più compatti, a voi il divertimento! (fatemi sapere…)

Download (compilato per win32): indovina.exe

Conclusioni:

Vi consiglio di evitare di proporre il giochino a matematici o esperti informatici che scopriranno subito il meccanismo, a parte questo mi sembra un esercizio divertente per rispolverare qualche reminiscenza di C, un linguaggio oggi forse un po’ in disuso ma da sempre un caposaldo della programmazione.

Riferimenti ed approfondimenti:

Movable Type 4 è anche Open Source

Movable Type logoChi ha letto i miei post precedenti si sarà accorto del cambio di piattaforma per il blog di questo sito. Ho deciso di effettuare questo passaggio per diversi motivi, ma la molla che mi ha spinto in maniera determinante è stata il rilascio di una versione Open Source del noto strumento di blogging Movable Type della ditta Six Apart. Vediamo quali sono le caratteristiche distintive di questa piattaforma:

  • Progettazione rivolta ad un mercato professionale
  • Motore interno basato su linguaggio Perl
  • Generazione dinamica di una struttura statica di pagine HTML
  • Presentazione basata su template personalizzabili attraverso un linguaggio di tag evoluto
  • Supporto multiblog e cross-blog (dalla versione 4)
  • Interfaccia per l’amministrazione potente e completa

Senza dubbio il fatto che MT sia pensato per un pubblico di professionisti, è sinonimo di qualità e stabilità. L’utilizzo del Perl è anch’esso sinonimo di professionalità, questo linguaggio di scripting è infatti naturalmente orientato alla ricerca di sequenze di caratteri
all’interno di stringhe, alle sostituzioni di sottostringhe ed altre
operazioni su file di testo strutturati in campi e record oppure non strutturati. La caratteristica di generare una struttura statica di pagine HTML, se da un lato è causa di una certa lentezza al momento della pubblicazione di nuovi post o nuovi template, dall’altro garantisce rapidità nel caricamento del generato e stabilità e persistenza del sito anche durante periodi di manutenzione.
A questo punto vorrei utilizzare come termine di paragone il competitore più agguerrito di MT, cioè WordPress, che da una recente indagine compiuta su Technorati risulta la piattaforma più utilizzata per i blog totalizzando il 34% delle preferenze contro il 16% di MT. Premesso che non sono un esperto di WordPress, dalla documentazione disponibile e da quanto si legge sul web, la personalizzazione avanzata di template e temi, richiede invitabilmente di mettere mano al codice php, e se non si ha una buona conoscenza del linguaggio e, soprattutto una buona conoscenza della struttura gerarchica dei file che compongono la piattaforma software, ci si può trovare in seria difficoltà. Questo problema, in MT, è estremamente semplificato perché il linguaggio di tag proprietario è sufficientemente semplice e allo stesso tempo evoluto (permette di realizzare costrutti condizionali e cicli) per essere alla portata di tutti e realizzare impaginazioni totalmente personalizzate. Un esempio di massiccia personalizzazione è visibile sul sito della Fondazione Giannino Bassetti, e in questo blog sono disponibili diverse informazioni tecniche sulla sua realizzazione.
Infine altri due punti nettamente a favore di MT sono il suo supporto nativo per il multiblog e adesso, anche il supporto per operazioni cross-blog, cosa assai più ardua da realizzare in WordPress, e l’interfaccia di amministrazione molto più potente e completa.
Quello che ha reso fino ad oggi WordPress molto più appetibile di MT era il tipo di licenza. WordPress è nato e cresciuto con una licenza Open Source, mentre MT è sempre stato un prodotto commerciale. Però, già agli inizi dell’anno precedente era possibile utilizzare una versione di MT4 “libera” per usi personali e non commerciali.
La svolta definitiva è avvenuta solo da pochi mesi, ora Movable Type 4 è anche Open Source con una licenza di tipo GPL, per la precisione una GPLv2, dunque chi utilizza MTOS (Movable Type Open Source) è libero di:

  • usarlo per fini commerciali
  • ricevere compensi per l’installazione e il supporto
  • modificarlo e rilasciare le modifiche effettuate
  • modificarlo e rivenderlo

Come è chiaramente specificato dal tipo di licenza e descritto in questo commento sul sito ufficiale. Questo aspetto induce ancora una certa confusione, per il fatto che si tende a confondere MT4 con MTOS4, due prodotti pressoché identici sotto l’aspetto tecnico, ma differenti in termini di licenza e di supporto tecnico.

Download della versione Open Source: MTOS-4.1-en.zip
Guida non ufficiale all’installazione: MT 4 installation guide (in inglese, ma completa e ricca di screenshot)

Conclusioni:
Il rilascio Open Source di Movable Type è da considerarsi senz’altro un fatto positivo, sia per lo sviluppo dello stesso che per la sana competizione con il suo rivale WordPress. Chi vuole un prodotto veramente professionale, ma anche chi è un po’ chic e anticonformista lo amerà di sicuro!

Riferimenti ed approfondimenti:

Javascript e CSS per la stampa di record selezionati in una tabella: l’approccio unobtrusive

Il rinoceronte: simbolo di javascriptHo trovato nel web questo codice javascript per la stampa selettiva di record che possono essere selezionati da una tabella HTML. L’idea è senz’altro interessante e utile, ma non segue la filosofia unobtrusive. Ho cercato di modificarlo seguendo la logica del progressive enhancement.

La regola principale per scrivere codice javascript non intrusivo, banalmente, è pensare che non venga eseguito…! E’ necessario cambiare il punto di vista, pensare che la presentazione della pagina HTML sia sufficiente a sé stessa con il solo ausilio di una progettazione coerente e dell’uso dei CSS. Il codice javascript, servirà soltanto ad integrare le funzionalità offrendo optional ai quali sia possibile rinunciare.
Lo script in questione permette di selezionare attraverso una checkbox una o più righe di una tabella e di stampare, utilizzando l’attributo CSS @media print solo le righe selezionate. Vediamo, dunque, perché non è unobtrusive: se il supporto javascript è disabilitato o comunque non disponibile, la tabella non verrà mai stampata. Questo succede perché gli elementi <tr> della tabella appartengono per default alla classe DONTPrint nella quale la proprietà display è impostata a none. La funzione javascript select_row() provvede a runtime lo scambio della classe di appartenenza dell’elemento <tr> da DONTPrint a DOPrint, che non essendo definita, per default mostra i contenuti.

La logica del progressive enhancement ci fa pensare invece che, non avendo la possibilità di stampare solo i record selezionati, sia almeno disponibile la stampa dell’intera tabella.
Ecco come impostare la pagina secondo questo approccio:

  1. Assegnamo a tutti gli elementi <tr>, per default la classe DOPrint
  2. Al caricamento del documento, mediante una funzione javascript scambiamo la classe dei <tr>, da DOPrint a DONTPrint
  3. Mediante la funzione select_row() ridefiniamo DOPrint solo le righe selezionate

Un po’ di codice:

1
2
3
4
5
6
7
8
9
<!-- Definizione del css per la stampa -->
<style type="text/css">
<!--
@media print {
 .DONTPrint { display:none; }
 .DONTEverPrint { display:none; }
}
-->
</style>

Le due funzioni principali javascript:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<!-- ... -->
<script type="text/javascript">
 
<!--
// Funzione lanciata in avvio
function init(){
 var myTableRows = document.getElementsByTagName("tr");
  for (i = 0; i < myTableRows.length; i++) {
    if(myTableRows[i].className=='DOPrint'){
     myTableRows[i].className = 'DONTPrint';
    }
  }
}
// Funzione per la selezione della riga
function select_row(row, color) {
 if (row.value=='on'){
 row.value="off";
 row.parentNode.parentNode.style.backgroundColor = color;
 row.parentNode.parentNode.className = 'DOPrint'
 }
 else{
 row.value="on";
 row.parentNode.parentNode.style.backgroundColor = '';
 row.parentNode.parentNode.className = 'DONTprint'
 }
}
// -->
</script>

Il codice HTML per l’avvio:

<body onload="init()">

Il codice HTML per la definizione delle righe della tabella:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<!-- ... -->
<tr onmouseover="mouseover(this,'#cc6600','#cc6600');"
  onmouseout="mouseout(this,'#000000','#000000')"
  class='DOPrint'>
 
<td><input type="checkbox" class='DONTEverPrint'
  name="checkbox1" onclick="select_row(this, '#cccccc');">
</td>
<td>Arnold </td>
<td>M</td>
<td>45</td>
 
</tr>
<!-- ... -->

Una demo dell’intero esempio è disponibile qui

Con l’occasione, ho anche modificato sia l’HTML che il codice javascript dell’esempio per renderlo un poco più vicino alle direttive degli standard W3C. Probablimente questo codice è stato scritto qualche anno fa, quando ancora, purtroppo, la sensibilità dei programmatori in tal senso era piuttosto scarsa.

Conclusioni:

L’utilizzo di un approccio unobtrusive è utile non soltanto per matenere struttura e presentazione della pagina nei rispettivi ambiti, ma anche per acquisire una forma mentis in grado di pensare preventivamente le vere necessità dell’utente, le caratteristiche di base dell’applicazione e gli elementi facoltativi. Infine si può affermare che “pensare unobtrusive” vuole dire in qualche modo aver compreso meglio il funzionamento delle tecniche utilizzate.

Riferimenti ed approfondimenti:

P4A framework: utilizzo di multicheckbox e multiselect con tabelle di relazione N:N

screenshot della multicheckboxUn tipico esempio di utilizzo di un multicheckbox o di una multiselect si ha quando è necessario creare una maschera per una tabella di relazione N:N. Nel framework P4A è possibile implementare entrambi i tipi di oggetto.

Il problema è che, come detto in precedenti post, la documentazione non è completa, si rende necessario quindi fare una una ricerca nel forum. In questo thread e in quest’altro, viene spiegato il funzionamento. Sperando di fare cosa gradita, ho cercato di riassumere la procedura in questo esempio pratico.

 

schema del database Dunque, ammettiamo di avere tre tabelle relazionate come nella figura a fianco. L’obiettivo è di poter associare ad ogni fascia uno o più colori. Nella tabella di relazione possono essere presenti N fasce e per ogni fascia N colori. Per prima cosa creaiamo le tre tabelle:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
CREATE TABLE `colori` (
  `idcolori` BIGINT(20) NOT NULL AUTO_INCREMENT,
  `nome` VARCHAR(255) NOT NULL,
  `note` VARCHAR(255) DEFAULT NULL,
  PRIMARY KEY  (`idcolori`),
  UNIQUE KEY `colori_index_nome` (`nome`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1;
-- -----------------------------------------------
CREATE TABLE `fasce` (
  `idfasce` BIGINT(20) NOT NULL AUTO_INCREMENT,
  `descrizione` VARCHAR(255) DEFAULT NULL,
  PRIMARY KEY  (`idfasce`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1;
-- -----------------------------------------------
CREATE TABLE `fasce_colori` (
  `colori_idcolori` BIGINT(20) NOT NULL,
  `fasce_idfasce` BIGINT(20) NOT NULL,
  PRIMARY KEY  (`colori_idcolori`,`fasce_idfasce`),
  KEY `fasce_colori_FKIndex1` (`colori_idcolori`),
  KEY `fasce_colori_FKIndex2` (`fasce_idfasce`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

A questo punto è necessario creare le due classi e le maschere per la gestione delle tabelle fasce e colori nel modo standard, che non illustro ma sono presenti nel pacchetto scaricabile.
Possiamo finalmente creare la maschera per la tabella di relazione: fasce_colori nel seguente modo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
class P4A_Fasce_colori extends P4A_Mask
{
 function P4A_Fasce_colori()
 {
 $this-&gt;P4A_Mask();
 $p4a = &amp; P4A::singleton();
 // DB Source
 $this-&gt;build("p4a_db_source","fasce");
 $this-&gt;fasce-&gt;setTable("fasce");
 $this-&gt;fasce-&gt;setPk("idfasce");
 //Filtro il record con idfasce=0 che indica
 //tutti i colori e non deve essere modificato
 $this-&gt;fasce-&gt;setWhere("idfasce &gt; 0");
 $this-&gt;fasce-&gt;setPageLimit(15);
 $this-&gt;fasce-&gt;addMultivalueField("fld_fasce_colori",
  "fasce_colori","fasce_idfasce", "colori_idcolori");
 $this-&gt;fasce-&gt;load();
 $this-&gt;setSource($this-&gt;fasce);
 $this-&gt;setTitle('Gestione fasce colore');
 $this-&gt;fasce-&gt;firstRow();
 $this-&gt;build("p4a_db_source","colori");
 $this-&gt;colori-&gt;setTable("colori");
 $this-&gt;colori-&gt;setPk("idcolori");
 $this-&gt;colori-&gt;load();
 $this-&gt;fields-&gt;fld_fasce_colori-&gt;setType("multicheckbox");
 // Oppure se si preferisce la multiselect
 //$this-&gt;fields-&gt;fld_fasce_colori-&gt;setType("multiselect");
 $this-&gt;fields-&gt;fld_fasce_colori-&gt;setSource($this-&gt;colori);
 $this-&gt;fields-&gt;fld_fasce_colori-&gt;label-&gt;setVisible(false);
 //Fieldset con l'elenco dei campi
 $this-&gt;build("p4a_fieldset", "fset");
 $this-&gt;fset-&gt;setWidth(590);
 $this-&gt;fset-&gt;setTitle("Selezione colori");
 $this-&gt;fset-&gt;anchor($this-&gt;fields-&gt;fld_fasce_colori);
 // Toolbar
 $this-&gt;build("p4a_simple_toolbar", "toolbar");
 $this-&gt;toolbar-&gt;setMask($this);
 $this-&gt;toolbar-&gt;buttons-&gt;new-&gt;disable();
 // Table
 $table = &amp; $this-&gt;build("p4a_table", "table");
 $table-&gt;setWidth(600);
 $table-&gt;setSource($this-&gt;fasce);
 $table-&gt;setVisibleCols(array("descrizione"));
 $table-&gt;showNavigationBar();
 // Message
 $message = &amp; $this-&gt;build("p4a_message", "message");
 $message-&gt;setWidth("300");
 // Frame
 $frm= &amp; $this-&gt;build("p4a_frame", "frm");
 $frm-&gt;setWidth(600);
 $frm-&gt;anchorCenter($message);
 $frm-&gt;anchorCenter($table);
 $frm-&gt;anchorCenter($this-&gt;fset);
 // Display
 $this-&gt;display("main", $frm);
 $this-&gt;display("menu", $p4a-&gt;menu);
 $this-&gt;display("top", $this-&gt;toolbar);
 }
}

Notate che la sorgente dati principale è quella della tabella dove agisce il selettore dei record,
nel nostro caso: fasce. L’azione chiave di tutta la procedura è la costruzione
di un campo attraverso il metodo addMultivalueField(),
i quattro parametri passati nell’ordine a questo metodo sono:

  • Il nome del nuovo campo
  • Il nome della tabella di relazione
  • Il nome della chiave esterna che lega la tabella dove agisce il selettore record
  • Il nome della chiave esterna che lega la tabella che funge da sorgente dati per il nuovo campo

Richiamando il metodo saveRow() le query di aggiornamento e inserimento verranno automaticamente eseguite dal P4A framework engine senza dover scrivere ulteriori righe di codice!

Download:

Il pacchetto completo è scaricabile qui

Conclusioni:

Il setup del codice necessario all’utilizzo di multicheckbox e multiselect è semplice ma poco documentato, il suo utilizzo è potente e fa risparmiare parecchio tempo.

Riferimenti ed approfondimenti:

P4A framework: modificare il comportamento del bottone print nella simple toolbar

screenshot della simple toolbarIl widget simple toolbar del framework P4A include un bottone predefinito print per la funzione di stampa. Questa funzione, per default, esegue in javascript una semplice window.print() della maschera, ma in molti casi è necessario personalizzare la stampa.
Qui nasce un piccolo problema: mentre per gli altri bottoni, è possibile effettuare semplicemente l’override del metodo, con il print è necessario agire diversamente.

Il motivo risulta chiaro osservando il codice della classe base P4A_Simple_Toolbar in simple.php:

1
2
3
4
5
6
// ...
$print = & $this->addButton('print', 'print');
$print->dropAction('onclick');
$print->setProperty('onclick', 'window.print(); return false;');
$print->setAccessKey("P");
// ...

La chiamata al metodo dropAction() resetta qualsiasi altra azione, ecco il codice del metodo, tratto dalla classe base P4A_Widget in widget.php

1
2
3
4
5
6
7
// ...
function dropAction($action)
{
 $action = strtolower($action);
 unset($this->actions[$action]);
}
// ...

Successivamente il metodo setProperty() assegna la funzione javascript window.print() all’evento onClick() del bottone print.
Come aggirare l’ostacolo? Il sistema più semplice è quello di nascondere il bottone print di default, e crearne uno nuovo, avendo cura di passare come secondo parametro, la stringa “print” al metodo addButton() che identifica il nome dell’icona predefinita (print.png)

1
2
3
4
5
6
7
8
9
10
11
// Toolbar
$tool = & $this->build("p4a_simple_toolbar", "tool");
// Hide original print screen button
$tool->buttons->print->setInvisible();
// Add new button to print pdf
$tool->addButton('stampafattura','print');
// Intercept onClick and override with our own method
$this->intercept($tool->buttons->stampafattura,
                 'onClick','print_doc');
// Join toolbar with this mask
$tool->setMask($this);

Il primo parametro passato ad addButton() assegna il nome al nuovo bottone, quindi possiamo intercettare l’evento associato onClick() abbinadogli un nostro metodo (nell’esempio: print_doc() )

1
2
3
4
5
6
function print_doc()
{
 //...
 // Code to customize print
 //...
}

Conclusioni:

Gli americani direbbero: “a piece of cake” per ottenere la personalizzazione del bottone print della simple toolbar senza mettere mano al codice delle classi base del framework!

Riferimenti ed approfondimenti:

Bigdump: una utility per importare dump voluminosi in MySQL

screenshot di bigdumpHo trovato questa utility di Alexey Ozerov dopo un vano tentativo di fare l’upload di un voluminoso dump di dati su un server MySQL.
I problemi che si verificano in questi casi sono dovuti ad alcune impostazioni del PHP nel file di configurazione php.ini: upload_max_filesize, memory_limit, post_max_size, o alle impostazioni di timeout per gli script PHP: max_execution_time (default = 30s).
Inoltre, sui server di produzione, e su gran parte dei server in hosting gestiti con Plesk, non si hanno i diritti per cambiare le impostazioni dei file di configurazione per ovvie ragioni di sicurezza. Se ciò non bastasse, questi server solitamente sono impostati in modalità safe, quindi non si ha nemmeno la possibilità di modificare a runtime i valori dei parametri preimpostati. Per completare l’opera frequentemente non si ha nemmeno a disposizione una shell per i comandi MySQL.

Per fortuna quelli di phpMyAdmin lo sanno e quando ci si imbatte in un errore dovuto a queste limitazioni, l’applicazione stessa suggerisce l’utilizzo di Bigdump (ma non garantiscono l’utilizzo, perché lo script è di terze parti).
Questo piccolo ma prodigioso script PHP esegue piccole porzioni del dump, ripartendo in sessioni successive fino al termine della query. In questo modo lo script rimane sempre nei limiti di memoria imposti, anche quelli più restrittivi.

screenshot di bigdumpL’utilizzo è semplicissimo: per prima cosa bisogna aprirlo con un editor ed impostare i parametri di connessione al database, poi si può fare l’upload sul server web e modificargli i permessi (chmod 777 su Linux). Una volta lanciato, la prima schermata richiede di selezionare il file .sql che viene caricato sul server spezzato in chunk di 2Mb, per evitare i limiti di upload_max_filesize.
Si può anche usare FTP per trasferire il dump sul server, in questo caso bisogna metterlo nella stessa directory dove risiede Bigdump. A questo punto nella schermata compare il nome del file caricato ed accanto un link con “start import”, basta fare un click ed aspettare pazientemente!

Per darvi un’idea del tempo che serve, posso dirvi che per un dump di 10 tabelle InnoDB con 12000 records per un totale di circa 2Mb ci sono voluti circa 10′. Con tabelle MyISAM è molto più veloce, ad esempio con un file di 8Mb contenente una tabella con 33500 records ha impiegato pochi secondi.

Questo script utilizza AJAX e javascript per mostrare lo stato di avanzamento dell’operazione in modo asincrono e senza ricaricare la pagina nel browser, dunque javascript deve essere abilitato. Da sottolineare anche che il progetto è in fase beta, dunque non è dichiarato stabile, comunque nelle prove che ho fatto non ho avuto nessun problema. Infine una raccomandazione, è molto importante cancellare Bigdump dal server una volta terminata l’importazione perché si può facilmente intuire la pericolosità dello stesso in mani diverse dal gestore del db!

Download:

Bigdump.zip

Conclusioni:

Senza Bigdump avrei dovuto scrivermi uno script simile a Bigdump, ma perché perdere tempo? Secondo me è utilissimo!

Riferimenti ed approfondimenti: