Newsgroup: it.comp.appl.access
Titolo: Campi si/no

Problema:
Ho 40 campi si/no che corrispondono ad opzioni non alternative di uno stesso
argomento (es. un elenco di 40 "interessi" dei quali è possibile
selezionarne da un minimo di 1 ad un massimo di 4). Vorrei quindi
trasformare l'informazione contenuta nei 40 campi si/no in 4 campi di testo
contenenti ciascuno una delle 4 scelte possibili. Come posso fare?
Ancora non ho finito...  :P
Il mio scopo finale è quello di eseguire delle statistiche su ciascuna delle
40 opzioni (in particolare vedere quante volte viene selezionata un'opzione
in funzione di un'altra variabile contenuta in un campo indipendente, es. la
fascia d'età del selezionatore) senza dover eseguire 40 query a campi
incrociati..
Tutti i suggerimenti sono ovviamente benvenuti...
Ciao a tutti e grazie,
Simonetta

 incrociati..
--
Ciao :-)
Maurizio
--------
?SPQR(C)
 X
--------

 Qualche idea? :-)
    Non ci hai detto niente a proposito della forma:
        1) 1 1
        2) 1 3
        3) 1 6
        4) 1 8
        5) 2 2
        6) 2 3
        7) 2 4
        8) 2 6
e io non riesco ad avere ideee senza risposte alle mie domande. ;-)


         2) 2 3 4 6
Esatto!
Dove 1) e 2) sono i record che corrispondono ai selezionatori e una colonna
"n" corrisponde al campo di testo rispetto al quale eseguire le statistiche:
    1 2 3 4 5 6 7 8 ...    n
1) X   X     X   X      bianco
2)   X X X   X          rosso
3) X         X              nero
4)       X                    bianco
da trasformare in:
              1     2     3     4     5     6     7     8 ...
bianco    n1    n2    n3    n4    ..    ...    ..    ..
rosso     m1    m2    m3  m4   ..    ..    ..    ..
nero       p1    p2    p3    p4   ..    ..    ..    ..
...
dove n1, m1, p1 etc. sono i conteggi del valore Sě per l'opzione 1 quando il
campo "n" era, rispettivamente, bianco, rosso o nero; n2, m2, p2 per
l'opzione 2 e cosě via.
utilizzando le query a campi incrociati sono costretta a farne 40 (cioč
quanti sono i campi Sě/No da incrociare con il campo "n". trasformare la
tabella come hai descritto tu mi consentirebbe di eseguire solo 4 query a
campi incrociati (poichč i 40 campi Sě/no si trasformerebbero in 4 campi di
testo)
Qualche idea? :-)
Ciao, grazie
Simonetta

"Maurizio Borrelli" [...]:

OK.
Se ho capito bene questo tipo di trasformazione, la prima colonna
corrisponde a quello che prima era il numero di riga (e cioč il
selezionatore) e la seconda colonna al tipo di campo Sě/No selezionato.
Premesso che mancherebbe la colonna "n" con il campo di testo e che lo scopo
finale di tutto deve essere il tipo di informazione che ho descritto
sopra... penso che potrebbe andare bene ugualmente. :-P
Simonetta
P.S. grazie...

 "Simonetta Palleschi"
OK.
Se ho capito bene questo tipo di trasformazione, la prima colonna
corrisponde a quello che prima era il numero di riga (e cioč il
selezionatore) e la seconda colonna al tipo di campo Sě/No selezionato.
Premesso che mancherebbe la colonna "n" con il campo di testo e che lo scopo
finale di tutto deve essere il tipo di informazione che ho descritto
sopra... penso che potrebbe andare bene ugualmente.
**********
    Procedo per approssimazioni. Data la tabella:
        Tabella Schede
            Campi
                IDScheda: Contatore o Numerico
                Q1: Si'/No
                ...
                Q40: Si'/No
                n: Testo
ritengo che la query seguente risponda al quesito principale:
    40 campi -> 4 campi
        SELECT
            [x_Simonetta Schede].IDScheda AS Scheda
          , Mid
            (
              IIf([Q1]=True,"01","")
            & IIf([Q2]=True,"02","")
            <...>
            & IIf([Q39]=True,"39","")
            & IIf([Q40]=True,"40","")
            ,1
            ,2
            )
            AS Campo1
          , Mid
            (
              IIf([Q1]=True,"01","")
            & IIf([Q2]=True,"02","")
            <...>
            & IIf([Q39]=True,"39","")
            & IIf([Q40]=True,"40","")
            ,3
            ,2
            )
            AS Campo2
          , Mid
            (
              IIf([Q1]=True,"01","")
            & IIf([Q2]=True,"02","")
            <...>
            & IIf([Q39]=True,"39","")
            & IIf([Q40]=True,"40","")
            ,5
            ,2
            )
            AS Campo3
          , Mid
            (
              IIf([Q1]=True,"01","")
            & IIf([Q2]=True,"02","")
            <...>
            & IIf([Q39]=True,"39","")
            & IIf([Q40]=True,"40","")
            ,7
            ,2
            )
            AS Campo4
          , [x_Simonetta Schede].n AS n
        FROM
            [x_Simonetta Schede]
        ;
OUTPUT (dei dati del tuo esempio):
Scheda Campo1 Campo2 Campo3 Campo4 n
1      01     03     06     08     bianco
2      02     03     04     06     rosso
3      01     06                   nero
4      04                          bianco
    Siamo sulla strada giusta?


     Siamo sulla strada giusta?
Maurizio, sei impressionante!
Senti, se hai tempo ti faccio scrivere una Gestione Commesse a tempo perso
per me ;-)))
Damiano

Simonetta ha scritto:

10 righe di codice (vabbe' facciamo 20 per l'ipotesi 4)
con matrice a 2 indici (integer)
L'indice di campo da il primo indice matrice
Il valore dell'opzione da il secondo indice
Il tutto se ben costruito (5 righe cdice in piu') non genera
limitazioni sul numero di opzioni e valori
(NB il numero delle istruzioni di codice e' statistico)
Il tutto lo sbatti dove vuoi
1) Tabella temporanea 
2) Form non associato
3) Foglio excel 
4) Documento word 
5) File di testo
6) Ne fai una classe che puoi riutilizzare come e quando vuoi
Se vuoi fare la cosa che dici tu a che ti serve un relazionale?
(la struttura da te pensata e' contro la 1NF)
--
a.cara

 a tempo perso [...]
    :-)


"Maurizio Borrelli" [...]

Direi proprio di sě.... :-))
A questo punto mi aspettano 4 query a campi incrociati o smanettando con il
codice SQL posso risolvere con un'unica query?
Ci provo anch'io.. ma visto che sei stato cosě gentile finora... ;-)
Grazie mille,
Simonetta

Ho appena scoperto il sitocomune... interessante!
Frugando nel database ho trovato come procedere eseguendo (nel mio caso) 4
query a campi incrociati e 1 query di unione (cosa che peraltro supponevo
dall'inizio).
Certo, se tu avessi un'idea  migliore... (...la potresti pubblicare sul
sito!)
Ciao, Simonetta

> "Simonetta Palleschi" [...]:

    Ho appeso la risposta all'altro ramo del 3d.


 sito!)
    Magari. Ma il tempo, come suole, e' tiranno ed io sono ormai un
tirannosauro, non piu' rex. Largo ai giovani.
    Hai valutato quanto ti diceva IQ su microsoft.public.it.office.access?
----------
    Dicevo dunque: "procedo per approssimazioni". E abbiamo cosi' sistemato
la tua prima domanda.
    Resta in sospeso il mio timido tentativo di spingere l'altra soluzione,
quella che in prima battuta hai cassato senza pieta'.
    Magari qualcuno interessato all'altra soluzione c'e' e mi dispiace
lasciare il discorso in sospeso.
    Il problema era trasformare una struttura di tipo:
        ID 1 2 3 4 5 6 7 8 ...  n
        1  X   X     X   X      bianco
        2    X X X   X          rosso
        3  X         X          nero
        4        X              bianco
in:
        ID Q
        1  1
        1  3
        1  6
        1  8
        2  2
        2  3
        2  4
        2  6
        3  1
        3  6
        4  4
        .. ..
mantenendo gli altri valori in una tabella del tipo:
        ID n
        1  bianco
        2  rosso
        3  nero
        4  bianco
in maniera da ottenere con una sola tabella pivot quanto da te richiesto:
                1   2   3   4   5   6   7   8   ..
        bianco  n1  n2  n3  n4  ..  ..  ..  ..
        rosso   m1  m2  m3  m4  ..  ..  ..  ..
        nero    p1  p2  p3  p4  ..  ..  ..  ..
    Dato che ai tuoi quaranta quesiti gli intervistati possono rispondere al
massimo a quattro, dovremo ottenere una tabella che abbia un numero
(massimo) di record pari a 4 per quanti sono i questionari.
        4 x NumQuestionari
    Un prodotto, quindi... Un prodotto... cartesiano! Hai presente?
Normalmente il prodotto cartesiano di due tabelle e' la bestia nera di chi
si accosta a SQL perche' da una manciata di record si riesce ad ottenere un
numero spropositato di record... inutili. E di solito non serve mai a
niente.
    A noi stavolta invece fa comodo. Bastera' che creiamo una nuova tabella
di soli quattro record. Quelli che ci servono appunto per il prodotto
cartesiano.
        Tabella: x_Simonetta Opzioni
            Campi
                id
 id
---
 1
 2
 3
 4
    Ora tieniti forte che il salto e' mortale, carpiato e con avvitamento:
        Query: x_Simonetta Test0
        SELECT
            [x_Simonetta Schede].IDScheda
          , [x_Simonetta Opzioni].id
          , Abs([x_Simonetta Schede].[Q1])
          <...>
          & Abs([x_Simonetta Schede].[Q40])
            AS Espr1
          , InStr([Espr1],"1") AS Val1
          , Mid([Espr1],InStr(1,[Espr1],"1")+1) AS Espr2
          , IIf(InStr([Espr2],"1")=0,0,[Val1]+InStr([Espr2],"1")) AS Val2
          , Mid([Espr2],InStr(1,[Espr2],"1")+1) AS Espr3
          , IIf(InStr([Espr3],"1")=0,0,[Val2]+InStr([Espr3],"1")) AS Val3
          , Mid([Espr3],InStr(1,[Espr3],"1")+1) AS Espr4
          , IIf(InStr([Espr4],"1")=0,0,[Val3]+InStr([Espr4],"1")) AS Val4
          , Choose
            (
              [x_Simonetta Opzioni].[id]
            , [Val1]
            , [Val2]
            , [Val3]
            , [Val4]
            ) AS RispondeSě
        FROM
            [x_Simonetta Opzioni]
          , [x_Simonetta Schede]
        ORDER BY
            [x_Simonetta Schede].IDScheda
          , [x_Simonetta Opzioni].id
        ;
N.B.: lo stesso risultato lo si puo' ottenere con un sistema piu' da
"informatici", ma ritengo che questo sia piu' leggibile per tutti.
    Infine la tabella destinata a ricevere questi dati:
        Tabella: x_Simonetta Quesiti
            Campi:
                IDScheda: Numerico lungo
                RispondeSě: Numerico intero
e la query per popolarla:
        Query: x_Simonetta accoda a Quesiti
        INSERT INTO
            [x_Simonetta Quesiti]
            (
              IDScheda
            , RispondeSě
            )
        SELECT
            [x_Simonetta Test0].IDScheda
          , [x_Simonetta Test0].RispondeSě
        FROM
            [x_Simonetta Test0]
        WHERE
            [x_Simonetta Test0].RispondeSě)>0
        ;
SE&O (Io ho fatto tutti i test con 8 quesiti. Spero che con 40 funzioni
altrettanto bene. Eventualmente facci sapere, grazie.)
