Newsgroup: it.comp.www.php
Titolo: Aiuto per ciclo while e foreach con checkboxes!

Ciao a tutti, è da diverse ore che sto perdendo la testa con un ciclo,
vi chiedo gentilmente di darmi una mano...
Allora, ho un campo nel db che contiene le particolarità che può
avere un'automobile (abs, airbag, navigatore, etc.).
Ho creato una tabella "particolarita" che contiene due colonne, "id" e
"nome" (es "1" "abs", "2" "airbag", etc)
Nel modulo di inserzione delle auto ho creato diverse checkboxes aventi
come name "particolarita[]" in modo che da crearmi un array contenente
i numeri delle particolarità selezionate, dopodichè inserisco il dato
nel database facendo un implode e separando i numeri da "-".
Nel database quindi compare una stringa simile a questa: "1-4-5-8-12",
quando vado poi a visualizzare l'auto faccio un'explode di quel campo
sul carattere "-" e vado a richiamare i nomi delle particolarità
sfruttando gli id.
Spero di esser stato chiaro fin qui
Ora sto scrivendo un modulo per modificare un'inserzione e vorrei
quindi che le checkboxes delle particolarità fossero "checkate" o meno
a seconda dei valori precedentemente inseriti nel database.
Per i campi <Option><Select> non ho mai avuto problemi, dentro un ciclo
while infatti inglobavo un ciclo if che dava alla variabile "$selected"
un valore "SELECTED" se l'id coincideva con quello corrispondente
all'auto, in questo modo il ciclo while mi stampava qualcosa come:
<option value=tot SELECTED>marca auto</option>
oppure
<option value=tot>altra marca auto</option> per tutte le altre.
Come posso riuscire a fare una cosa simile per le checkboxes?
Vi passo il codice che ho creato, il problema è che nel ciclo foreach
mi ristampa la stessa stringa tante volte quanti elementi sono presenti
nell'array creato (quello creato con explode, ricordate?).
Ecco il pastrocchio:
codice:
-------------------------------
// Qui prendo il dato del database (es: 1-5-6-7-12-15)
$particolarita_exp = explode('-',$dati['particolarita']);
//Con l'explode ottengo l'array $particolarita_exp contenente i 6
valori
//La tabella "particolarita" ha 2 colonne, id e nome (es: 1 - ABS, 2 -
Airbag, etc.)
$query_particolarita = "SELECT * FROM particolarita ORDER BY id";
$result_particolarita = mysql_query("$query_particolarita") or
die("$diesql".mysql_error());
while ($dati_particolarita = mysql_fetch_array($result_particolarita)){
$particolarita2 = $dati_particolarita['id'];
$nome_particolarita2 = $dati_particolarita['nome'];
//Con questo ciclo vorrei riempire la variabile $checked
foreach($particolarita_exp as $particolarita_exp2){
	if ($particolarita2 == $particolarita_exp2) { $checked = "
checked=\"checked\" ";}
	else $checked = "";
$option_particolarita .= "\n<input type=\"checkbox\"
value=\"$particolarita2\"  $checked name=\"particolarita[]\"
/>$nome_particolarita2<br>\n";
}
--------------------------------
Spero che qualcuno abbia la pazienza di aiutarmi, non dovrebbe essere
difficile ma io proprio non ci sto riuscendo aiutatemi a capire ;)

 
   questa struttura del database e' concettualmente priva di senso
ti consiglio di postare su it.comp.software.database per riscrivere
al meglio questa struttura
   ti faccio notare che:
- e' superfluo avere un campo id numerico che non abbia una corrispondenza
significativa con il dato che vai a modellare
- il solo fatto che con una query non si riesca ad individuare le particolarita'
di un'auto (cosa che riesce tranquillamente dopo aver normalizzato il database)
debba far riflettere molto
   ti invito nuovamente a postare su it.comp.software.database in modo che tu possa
evitare di trovarti a dover scrivere "accrocchi" che sono risolvibili partendo da
un buon database

 sfruttando gli id.
Premesso che era meglio avere una tabella normalizzata (ovvero 
utilizzare una terza tabella che contiene l'id dell'auto e n-righe, 
tante quante sono le particolarità
$auto['str_particolarita'] contiene la stringa 1-2-4 relativa alla 
particolarità della macchina selezionata
$array_particolarita = explode("-", $auto['str_particolarita']);
$sql =" Select id, nome from particolarita";
$r = mysql_query...
while($row = mysql_fetch_array($r)) {
	echo '<input type="checkbox" name="particolarita[]"' 
.(in_array($row['id'], $array_particolarita) ? ' checked' : '') . '>' . 
$row['nome'] . '</option>';
}
	Francesco

 un buon database
Ciao, mi interessa molto quello che mi suggerisci ma potresti spiegarmi
meglio cosa intendi? Io pensavo che questa fosse la soluzione più
funzionale, per ogni automobile c'è un solo campo nel db
"particolarità", inoltre nella tabella "particolarita" in questo modo
posso aggiungerne altre senza fare casini...

 posso aggiungerne altre senza fare casini...
Per esempio in questo caso devi creare una terza tabella, per la 
correlazione tra le particolarità dell'auto e la tabella particolarità. 
Ovvero:
Tabella AUTO
1 Auto A
2 Auto B
3 Auto C
Tabella PARTICOLARITA
1 ABS
2 AIRBAG
3 ESP
Tab. Auto_Particolarita
CONTATORE | ID_AUTO | ID_PARTICOLARITA
1  1 3
2  1 1
3  3 2
Significa che l'auto A ha la particolarita 3 (esp) e 1 (abs) mentre 
l'auto 3 ha solo l'airbag
Se vuoi sapere quale auto ha la particolarità 2 (airbag) ti basta fare:
Select auto.*, particolarita.descrizione from AUTO inner join 
Auto_Particolarita on (AUTO.id = Auto_Particolarita.id_auto) where 
Auto_Particolarita.ID_PARTICOLARITA = 2
Questo è solo uno spunto, puoi devi analizzare il tipo di join che ti 
serve (1:1 , 1:N), quindi left, inner etc.
Sul manuale mysql qualcosa c'e' (6.4.1.1 JOIN Syntax) cmq basta cercare 
su google documenti sulla normalizzazione del db
	Francesco

 3  3 2
  il campo autoincrement e' inutile e ti permette
di inserire dati non "validi" (ad esempio 50 volte la coppia 1 3),
  invito nuovamente l'OP a postare su it.comp.software.database

 di inserire dati non "validi" (ad esempio 50 volte la coppia 1 3),
Per questo puoi fare una chiave univoca ID_AUTO | ID_PARTICOLARITA
il contatore lo usi per rimuovere un record (invece di rimuovere con un 
criterio ID_AUTO = y and ID_PARTICOLARITA = x
	Francesco

 criterio ID_AUTO = y and ID_PARTICOLARITA = x
   mi sembra un passaggio inutile e potenzialmente dannoso:
quando il campo auto_increment "finisce" quali record cancelli?
p.s.
  prima di difendere a spada tratta le tue opinioni cerca di capire
dove sbagli: sottoscrivi it.comp.software.database e leggiti un paio
di post

 di post
Non difendo a spada tratta, ci mancherebbe. Anzi, ti prego cortesemente, 
di motivare meglio alcune scelte, magari sono io che mi sbaglio
Cordialità,
	Francesco

quando il campo auto_increment "finisce" quali record cancelli?
Suvvia: il campo auto_increment regge due miliardi di record per default,
e su MySQL almeno, esiste il tipo BIGINT (otto miliardi di miliardi).
Ma gia' con due miliardi di record, vendendo un'auto al secondo, ci vuole
un paio di secoli prima che "finisca" il campo auto_increment.
Leonardo
-- 
Dawn is near, the time is short (Human aircraft! Hard to port!)
We eight reindeers of the night work as one in silent flight.
Let not one damn house pass by (Who taught that guy how to fly?)
Each year sees more girls and boys: how many of them can we bring toys?

 di motivare meglio alcune scelte, magari sono io che mi sbaglio
   rinnovo l'invito a postare su it.comp.software.database
troverai gente *molto* preparata (sicuramente più di me) sull'argomento

 (e prima di dire "ti sbagli" cerca di capire il perchè)
Ho seguito la discussione anche su ics.db, e rimango dell'idea che il
campo id numerico serva.
Innanzitutto per questioni di prestazioni. Fare una join su un campo
numerico costa molto meno che farla su un campo di testo.
Poi per motivi pratici. Se voglio aggiungere una tabella "vendite" in cui
scrivo cosa ho venduto cosa faccio? Un riferimento a due colonne di
un'altra tabella?
Motivo pratico/tecnico: OK, Automatic Braking System (o quello che e`) lo
posso identificare con una chiave primaria ABS, ma se mi capita un
Anti-Border Steering (nome del casso per fare un esempio), lo chiamo
ABS2? A-BS? E quanto lunga deve essere la chiave primaria? 3 caratteri?
AIRBAG non ci sta. 10 caratteri? E se capita qualcosa che non ha la sigla?
E poi deve essere un valore binario o testuale? Se scrivo abs mi prende
anche ABS e AbS?
Ha senso quando fai una tabella delle provincie italiane, e metti come
chiave primaria la sigla della provincia (2 caratteri fissi, matching solo
maiuscolo, solo 2 caratteri che non appesantiscono le ricerche), ma per la
maggior parte delle cose non puoi farlo.
Bye.

 un paio di secoli prima che "finisca" il campo auto_increment.
   il discorso si era portato sulle "best practice" e fin ora non
mi e' capitata una situazione in cui si sia reso _necessario_ l'utilizzo
di un campo auto_increment
   il fatto che un campo auto_increment debba essere definito come
PK ne sconsiglia difatto l'utilizzo, se poi uno non ha voglia di modellare
correttamente il db, crea un campo id auto_increment in tutte le tabelle
e via ... pratica che sconsiglio e rifuggo

 ERROR 1062: Duplicate entry '
2147483647
' for key 1
Scusami, sono duro e sicuramente meno preparato di te, ma perchè vuoi 
fare un insert su un campo auto_inc specificando il valore dell'autoinc?
Siamo OT, ma visto che è la 3/4 volta in 2 settimane che si evidenziano 
questi probeli, forse a qualcuno può tornar comodo.
	Francesco

E quanto lunga deve essere la chiave primaria? 3 caratteri?
   la lunghezza la scegli confrontando il modello con il caso reale


Le regole d'oro del buon data modeler:
- prima le specifiche concettuali, poi quelle logiche
- considerare i dati per come descrivono la realtà, e non pensando
al modo in cui li useremo
- problemi del layer fisico (performaces, spazio occupato) per ultimi
Ricordarsi sempre che si sta implementanto un un modello logico, e
non un semplice sistema di stoccaggio dati.
Uno schema relazionalmente corretto è un subset della realtà (o
porzione della realtà di interesse), che se corretto, può essere
esteso e ridotto senza modificare il significato logico dello schema.

   sto simulando quello che potrebbe succedere
Succedere in che caso? Perchè devi inserire un valore nel campo 
contatore? Ipotizzi un ripristino di db
	Francesco

 contatore? Ipotizzi un ripristino di db
forse così è più chiaro:
CREATE TABLE `prova` (
   `rowid` int(11) NOT NULL auto_increment,
   `valore` varchar(255) default NULL,
   PRIMARY KEY  (`rowid`)
) TYPE=MyISAM
SELECT * FROM prova;
+------------+--------+
| rowid      | valore |
+------------+--------+
| 
2147483647
 | NULL   |
+------------+--------+
1 row in set (0.00 sec)
INSERT INTO prova(valore) VALUES('pippo');


 SELECT * FROM particolarita where nomeparticolita='ABS'
Ok, mi arrendo, depongo la tastiera :-)
Sarà sbagliato, non sarà correttamente normalizzato, sarò ignorante ma 
preferisco un'unica select (con 2 join) rispetto a 2 select distinte
	Francesco



non mi sono spiegato:
AUTO
(PK modello)
+------------+-----------------------------------+
|modello     | tutti i campi aggiuntivi che vuoi |
+------------+-----------------------------------+
| DUNA 2.0TD |                ....               |
+------------+-----------------------------------+
PARTICOLARITA
(PK nome)
+------------+-----------------------------------+
| nome       | tutti i campi aggiuntivi che vuoi |
+------------+-----------------------------------+
| ABS        |                ....               |
+------------+-----------------------------------+
| GPS        |                ....               |
+------------+-----------------------------------+
| MMS        |                ....               |
+------------+-----------------------------------+
AUTO_PARTICOLARITA
PK(modello,nome)
+------------+------------+
|modello     | nome       |
+------------+------------+
| DUNA 2.0TD | ABS        |
+------------+------------+
| DUNA 2.0TD | GPS        |
+------------+------------+
(la duna, come e' noto, non ha gli mms)
Elenco nomi particolarità dell'auto:
senza id:
SELECT ap.nome FROM auto_particolarita AS ap WHERE ap.modello='DUNA 2.0TD';
con id:
SELECT p.nome FROM auto_particolarita AS ap
LEFT JOIN particolarita AS p ON 
p.id
 == 
ap.id
WHERE ap.modello='DUNA 2.0TD';
Elenco tutti i campi particolarità:
SELECT p.* FROM auto_particolarita AS ap
LEFT JOIN particolarita AS p ON p.nome = ap.nome
WHERE ap.modello='DUNA 2.0TD';
spero di essere stato più chiaro adesso

e via...
Calma, calma: non stavo predicando un'aggiunta di auto_increment a caso,
"Un impegno preciso: piu' auto_increment per tutti!" :-); esprimevo solo
la mia opinione che in QUESTO caso i vantaggi superassero gli svantaggi.
Svantaggi che per altro, IN QUESTO CASO, ancora non vedo: OK, si impegna
un po' di spazio su disco (per la PK "eretica"); l'indice univoco, sulle
componenti della PK "giusta", ci serve sempre (lo usiamo meno); e poi si
viola la best practice con conseguente dannazione all'Inferno (SQHell).
Non mi pare che, in questo caso!, ci sia altro. Nel caso generale, penso
che fossimo, e tuttora siamo, tutti d'accordo nel dire che non sia il...
caso, no?


 
Nella pratica (almeno per me, quindi opinione strettamente personale e 
non documentabile) risulta più semplice fare query con campo ID (quindi 
numerico) rispetto campi text (per problemi di quote, apici etc)
$sql ="SELECT ap.nome FROM auto_particolarita AS ap WHERE 
ap.id
=" . 
$id_auto . ";"; [1]
rispetto a
$sql ="SELECT ap.nome FROM auto_particolarita AS ap WHERE ap.modello='" 
.  mysql_real_escape_string($nome_auto) . "';";
[1] In precenza s'e' controllato la bontà di $id_auto, per eventuali SQL 
Injection
	Francesco

 caso, no?
   ineccepibile :)

portarsi appresso "difetti di fabbricazione"?
Be', perche' mi pareva un difetto abbastanza piccolo in confronto a quello
che mi pareva un beneficio apprezzabile.
Comunque c'e' stato il COLPO DI SCENA.
Visto che sto aspettando che mi portino un panino (ora di pranzo, qui allo
zoo), ho scritto uno scriptino di test, convinto che mi avrebbe dato ampia
ragione.
Be'. Almeno dai primi test, mi da' torto.
E' circa uguale fare una ricerca per == testuale sulla PK, rispetto a fare
la ricerca su un ID numerico... e questo nel caso a me piu' favorevole.
Lo script e' in PHP e genera un SQL, cosi' potete verificarlo. Spero, come
e' logico, di avere sbagliato qualcosa nello script :-)
<?php
        define('ALLESTIMENTI',  100);
        define('PARTICOLARITA', 50);
        print <<<TEST1
DROP TABLE IF EXISTS auto_pk_modello;
DROP TABLE IF EXISTS auto_pk_id;
DROP TABLE IF EXISTS auto_particolarita_pk1;
DROP TABLE IF EXISTS auto_particolarita_pk2;
DROP TABLE IF EXISTS part_pk_nome;
DROP TABLE IF EXISTS part_pk_id;
CREATE TABLE auto_pk_modello (
        modello varchar(32)     primary key,
        costo   integer
);
CREATE TABLE part_pk_nome (
        nome    varchar(32)     primary key,
        descr   varchar(200),
        extra   integer
);
CREATE TABLE auto_particolarita_pk1 (
        nome    varchar(32),
        modello varchar(32)
);
CREATE TABLE auto_pk_id (
        id      integer unsigned not null primary key auto_increment,
        modello varchar(32),
        costo   integer
);
CREATE TABLE part_pk_id (
        id      integer unsigned not null primary key auto_increment,
        nome    varchar(32),
        descr   varchar(200),
        extra   integer
);
CREATE TABLE auto_particolarita_pk2 (
        idauto  integer,
        idpart  integer
);
CREATE UNIQUE INDEX index_nm ON auto_particolarita_pk1 (nome, modello);
CREATE UNIQUE INDEX index_id ON auto_particolarita_pk2 (idauto, idpart);
CREATE UNIQUE INDEX extra_1 ON auto_pk_id(modello);
CREATE UNIQUE INDEX extra_2 ON part_pk_id(nome);
TEST1;
        // Creo le particolarita'
        $part   = array();
        for ($i = 0; $i < PARTICOLARITA; $i++)
        {
                $nome = uniqid("PART-");
                print "INSERT INTO part_pk_nome (nome) VALUES
('$nome');\n";
                print "INSERT INTO part_pk_id   (nome) VALUES
('$nome');\n";
                $part[] = $nome;
        }
        // Inserisco i dati
        for ($i = 0; $i < ALLESTIMENTI; $i++)
        {
                $auto   = uniqid("AUTO-");
                $parts  = array_rand($part, rand(2, 10));
                // Inserisco nel db 1 l'auto
                print "INSERT INTO auto_pk_modello (modello) VALUES
('$auto');\n";
                print "INSERT INTO auto_pk_id      (modello) VALUES
('$auto');\n";
                // Inserisco nel db le particolarita'
                foreach ($parts as $partid)
                {
                        $partn = $part[$partid];
                        print "INSERT INTO auto_particolarita_pk1
VALUES('$auto', '$partn');\n";
                        print "INSERT INTO auto_particolarita_pk2
VALUES($i, $partid);\n";
                }
        }
?>
===
Nel mio test ho fatto un OPTIMIZE TABLE a tappeto, poi ho provato (non ho
usato gli stessi valori di ALLESTIMENTO che ci sono sopra; qui trovi 400,
anziche' 100... ero alla ricerca disperata di un caso dove risultasse che
avessi ragione io 8-D )
DESCRIBE SELECT descr FROM auto_pk_id JOIN auto_particolarita_pk2 JOIN
part_pk_id ON (
auto_pk_id.id
 = auto_particolarita_pk2.idauto AND
auto_particolarita_pk2.idpart = 
part_pk_id.id
);
+------------------------+--------+---------------+----------+---------+-------------------------------+------+--------------------------+
| table                  | type   | possible_keys | key      | key_len | ref                           | rows | Extra                    |
+------------------------+--------+---------------+----------+---------+-------------------------------+------+--------------------------+
| auto_pk_id             | index  | PRIMARY       | PRIMARY  |       4 | NULL                          |  400 | Using index              |
| auto_particolarita_pk2 | ref    | index_id      | index_id |       5 | 
auto_pk_id.id
                 |   34 | Using where; Using index |
| part_pk_id             | eq_ref | PRIMARY       | PRIMARY  |       4 | auto_particolarita_pk2.idpart |    1 | Using where              |
+------------------------+--------+---------------+----------+---------+-------------------------------+------+--------------------------+
DESCRIBE SELECT descr FROM auto_pk_modello JOIN auto_particolarita_pk1
JOIN part_pk_nome ON (auto_pk_modello.modello =
auto_particolarita_pk1.modello AND auto_particolarita_pk1.nome =
part_pk_nome.nome);
+------------------------+--------+---------------+----------+---------+--------------------------------+------+--------------------------+
| table                  | type   | possible_keys | key      | key_len | ref                            | rows | Extra                    |
+------------------------+--------+---------------+----------+---------+--------------------------------+------+--------------------------+
| part_pk_nome           | ALL    | PRIMARY       | NULL     |    NULL | NULL                           |   50 |                          |
| auto_particolarita_pk1 | ref    | index_nm      | index_nm |      33 | part_pk_nome.nome              |   34 | Using where; Using index |
| auto_pk_modello        | eq_ref | PRIMARY       | PRIMARY  |      32 | auto_particolarita_pk1.modello |    1 | Using index              |
+------------------------+--------+---------------+----------+---------+--------------------------------+------+--------------------------+
Qui l'unica cosa e' che non mi torna come usa gli indici - nessuna delle
due versioni. Ma forse sono io.
Nel caso in cui volessi avere i dati di una certa automobile, farei:
DESCRIBE SELECT auto_pk_id.modello,part_pk_id.nome,descr FROM auto_pk_id
JOIN auto_particolarita_pk2 JOIN part_pk_id ON (
auto_pk_id.id
 =
auto_particolarita_pk2.idauto AND auto_particolarita_pk2.idpart =
part_pk_id.id
) WHERE auto_pk_id.modello = 'AUTO-450a8c31e0547';
+------------------------+--------+-----------------+----------+---------+-------------------------------+------+--------------------------+
| table                  | type   | possible_keys   | key      | key_len | ref                           | rows | Extra                    |
+------------------------+--------+-----------------+----------+---------+-------------------------------+------+--------------------------+
| auto_pk_id             | const  | PRIMARY,extra_1 | extra_1  |      33 | const                         |    1 |                          |
| auto_particolarita_pk2 | ref    | index_id        | index_id |       5 | const                         |   34 | Using where; Using index |
| part_pk_id             | eq_ref | PRIMARY         | PRIMARY  |       4 | auto_particolarita_pk2.idpart |    1 | Using where              |
+------------------------+--------+-----------------+----------+---------+-------------------------------+------+--------------------------+
DESCRIBE SELECT auto_pk_modello.modello,part_pk_nome.nome,descr FROM
auto_pk_modello JOIN auto_particolarita_pk1 JOIN part_pk_nome ON
(auto_pk_modello.modello = auto_particolarita_pk1.modello AND
auto_particolarita_pk1.nome = part_pk_nome.nome) WHERE
auto_pk_modello.modello ='AUTO-450a8c31e0547';
+------------------------+-------+---------------+----------+---------+-------------------------+------+--------------------------+
| table                  | type  | possible_keys | key      | key_len | ref                     | rows | Extra                    |
+------------------------+-------+---------------+----------+---------+-------------------------+------+--------------------------+
| auto_pk_modello        | const | PRIMARY       | PRIMARY  |      32 | const                   |    1 |                          |
| part_pk_nome           | ALL   | PRIMARY       | NULL     |    NULL | NULL                    |   50 |                          |
| auto_particolarita_pk1 | ref   | index_nm      | index_nm |      66 | part_pk_nome.nome,const |   34 | Using where; Using index |
+------------------------+-------+---------------+----------+---------+-------------------------+------+--------------------------+
La ricerca impiega 440 ticks nel caso "tuo"... ed esattamente uguale
nel caso "mio" 8-(
Spero di non aver visto qualche cosa di ovvio 8-D
Leonardo (il lato buono e' che nel frattempo e' arrivato il panino)


 auto_pk_modello.modello ='AUTO-450a8c31e0547';
Stessa cosa, stesso modello:
SELECT auto_pk_modello.modello,part_pk_nome.nome,descr FROM
auto_pk_modello JOIN auto_particolarita_pk1 JOIN part_pk_nome ON
(auto_pk_modello.modello = auto_particolarita_pk1.modello AND
auto_particolarita_pk1.nome = part_pk_nome.nome) WHERE
auto_pk_modello.modello ='AUTO-450ac01b61ca6';
Empty set (0.00 sec)
Ho sommariamente controllato le query, ma mi sembrano corrette.
O gli indici in varchar NON funzionano con MySQL 5.0.24a oppure non so
cosa pensare, se non che forse ho ragione io che ci sono problemi piu`
gravi, come il tipo del campo, il coding delle celle, ecc.
Lo script dovrebbe creare le stesse identiche relazioni tra le due tabelle.
Bye.

Lo script dovrebbe creare le stesse identiche relazioni tra le due tabelle.
Gia'... comunque anche dopo aver corretto l'errore, i tempi mi rimangono
sostanzialmente identici (0.00221 contro 0.00228).
Con un numero demenziale di allestimenti e particolarita', le cose, piu'
o meno, non cambiano.
Lo spazio occupato e' minore con il caso "integer" (ovviamente; e vorrei
vedere), ma per 32+32 byte non c'e' di che sforzarsi:
 3361732 Sep 16 00:42 auto_particolarita_pk1.MYD
 3792896 Sep 16 00:42 auto_particolarita_pk1.MYI
  687627 Sep 16 00:42 auto_particolarita_pk2.MYD
 1288192 Sep 16 00:42 auto_particolarita_pk2.MYI
Di questo passo... perche' la cosa abbia rilevanza dovrei avere qualcosa
come qualche centinaio di migliaia di modelli.
Il resto dei file di dati sono dell'ordine dei 30-40 Kb o meno.
Leonardo


Ragazzi, nel frattempo ho risolto il problema delle checkboxes ma mi
sono soffermato a leggere la vostra diatriba... che dire, mi sono messo
le mani nei capelli :D L'argomento di cui parlate mi interessa, ma la
discussione è troppo tecnica per le mie capacità, sono un niubbino :(
Dato che ci sono volevo chiedervi se l'approccio che ho adottato per il
mio database sia corretto oppure no...
In pratica ho una tabella "automobili" così strutturata:
|ID|marca|modello|stato|etc|
1   3          Focus   2      etc
Poi ho una tabella per diversi campi della tabella automobili, ad
esempio ho la tabella "marche":
|id|nome|
1   Fiat
2   Mercedes
3   Ford
In questo modo in tutti i moduli per l'inserimento o la modifica di un
auto, e in tutti i form di ricerca se vado ad aggiungere una nuova
marca nella tabella marche non sputtano niente, anzi, mi comparirà la
nuova marca dappertutto...
Da quel che ho capito mi sembrava che stavate discutendo se fosse
corretto o meno utilizzare un campo "id" per questo tipo di tabelle...
ma probabilmente ho capito male...

 due versioni. Ma forse sono io.
o forse è mysql
comunque, per completezza, si ottengono gli stessi risultati rimuovendo l'indice index_nm
e creando la primary key su (nome, modello) (che era il mio consiglio)
ALTER TABLE `auto_particolarita_pk1` DROP INDEX `index_nm`
ALTER TABLE `auto_particolarita_pk1` ADD PRIMARY KEY ( `nome` , `modello` )
lo stesso vale per le altre query
   quindi a parità di risultato perchè non usare uno schema corretto
dal punto di vista relazionale ed essere "pronti per il futuro"?

 mio database sia corretto oppure no...
[snip]
   non ricordo più se ti ho consigliato di postare su
it.comp.software.database :)
   a parte gli scherzi prima di buttarti a scrivere codice
posta la tua struttura su it.comp.software.database e seguine
i consigli, ne avrai solo vantaggi

 auto_pk_modello.modello ='AUTO-450a8c31e0547';
Se mi posso permettere, forse c'e' un piccolo neo: esegui una where sul 
campo auto_pk_modello.modello: nel primo caso al campo è assegnata una 
chiave primaria, nel secondo caso, no. Quindi oltre al tempo impiegato 
per la join, devi valutare anche il tempo impiegato per la where.
Ho fatto un'altra prova, ma forse ho commesso un errore di valutazione.
Se cambi la select, con un count(*) (come evidenziato anche in questa 
lista senza la where in mysql è più veloce di un select(field))[1], il 
risultato cambia.
Personalmente ho portato a 4999 le auto e a 99 le particolarità (nel for 
mi sono dimenticato un = e non avevo voglia di rifare il tutto), 
ottendendo una tabella n:m di 494901 record
Nel mio portatile, rhel + mysql 4.1.20 impiega ad eseguire il count 3.57 
e 5.80 secondi rispettivamente per id-id, txt-txt (nella vita quotidiana 
non capita mai di fare query non filtrate da mezzo milione di record)
Opinioni in merito?
	Francesco
[1]
http://dev.mysql.com/doc/refman/5.0/en/group-by-functions.html
COUNT(*) is optimized to return very quickly if the SELECT retrieves
from one table, no other columns are retrieved, and there is no WHERE
clause.

 non capita mai di fare query non filtrate da mezzo milione di record)
non capita _quasi_ mai di fare query non filtrate ...
	Francesco