Newsgroup: it.comp.appl.access
Titolo: VALORE INCREMENTALE!?!?!

Ho bisogno dell'aiuto di un esperto per un problema che, ne sono sicuro, e
di semplice soluzione ma io non riesco a trovarla!!!!!!!
I fatti:
ho creato una query di accodamento che produce una decina di campi. Il primo
di tutti deve essere un campo incrementale, ovvero leggo un valore da una
delle tabelle caricate con la funzione DMax() e lo devo "accodare
incrementandolo!!
D'istinto ho scritto : DMax(..) +1 ma il risultato, ovviamente, è stato
quello di porre in tutti i record aggiunti lo stesso valore mentre io ho
bisogno di un valore che incrementa per ogni record (...... 14, 15, 16
........)
HELPME!!!
Un milione di grazie in anticipo
Maurizi

 ha scritto nel messaggio
news:riWk9.18250$Eu.3...@twister1.libero.it...

Risposta istintiva: il contatore di access non va bene?
Soluzione non molto performante ma facile:
crea una funzione che prende come parametro una variant e restituisce il
Dmax + 1
Quindi nel campo incrementale ci metti la chiamata alla funzione con
parametro un campo qualunque. La funzione viene chiamata per ogni record e
quindi con valori di dmax restituiti diversi, ma esegui una dmax ogni volta
e si rallenta la query.
Infine, potresti prima accodare senza campo incrementale (o meglio
mettendoci 0), quindi da codice ti apri il recordset dei record con valore
0, calcoli il Dmax una volta sola, e quindi ti scorri tutto il recordset
aggiornando il campo con il valore precedente + 1 (usando un var d'appoggio
contatore)
Fai un po' tu...
Antonio

 ........)
        Tabella: x_Kanly
            Campi:
                ID, numerico lungo, chiave primaria;
                Nome, testo (255), duplicati non ammessi.
        Tabella: x_Kanly input
            Campi:
                Nome, testo (255), duplicati non ammessi.
        INSERT INTO
            x_Kanly
            (
              ID
            , Nome
            )
        SELECT
            (
              SELECT
                  Val("" & Max(x_Kanly.ID))
               + (
                   SELECT
                       Count(*)
                   FROM
                       [x_Kanly input] AS TEMP1
                   WHERE
                       TEMP1.Nome<=[x_Kanly input].Nome
                 )
              FROM
                 x_Kanly
            ) AS ID
          , [x_Kanly input].Nome
        FROM
            [x_Kanly input]
        ORDER BY
            [x_Kanly input].Nome
        ;
-oppure-
    Codice: Recordset, Do .. Loop, ...
--
Ciao :-)
Maurizio
--------
?SPQR(C)
 X
--------

 e si rallenta la query.
... la velocità non m'interessa, tanto sono pochi recordi che vanno gestiti
ogni volta. Il problema è che questa è proprio la strada che ho seguito, ma,
facendo un esempio per farmi capire, anche se la queri d'accodamento genera
5 nuovi record la chiamata alla funzione viene fatta solo una volta
all'inizio!! Ne sono certo perchè per verificare ho inserito MsgBox Numero
ed invece che aprirmi 5 volte consecutive il box lo fa solo una volta.
AIUTAMIIIIII!
Ciao e grazie

cut

Funziona , ma non ho capito come. 
Record di prova:
"spaghetti"
"pollo"
"peperoni"
"Topolino"
"Minnie"
"Paperino"
"Paperina"
"Pippo"
"Pippa"
"Pluto"
"Nonna Papera"
Faccio delle considerazioni ad alta voce giusto per aiutarmi a
pensare, salta pure la parte tra le liniette:
----------------------------------------------------------------------------------
-Parti conteggiando tutti i record che si trovano in x_Kanly input,
così sai quanti sono, la condizione Where dovrebbe servire ad
assegnare loro  un valore  in base a cosa?  come ?  , tale istruzione:
SELECT Count(*) 
FROM [x_Kanly input] AS TEMP1
WHERE TEMP1.Nome<=[x_Kanly input].Nome
esattamente cosa fa quella condizione Where ? senza la condizione mi
restituisce il totale dei record di x_Kanly input (ovviamente ), con
la condizione, alla chiamata del tblinput.nome, mi restituisce un
valore numerico uno per ogni record da 1 fino all'ultimo conteggiato (
in base a un ordine alfabetico) ,
... ma no ma no , forse ho capito : serve a conteggiare i record dal
primo fino all'ultimo chiamato ( da un altra istruzione SELECT presumo
): ma pensa quando fa un lavoro del genere li mette in ordine
alfabetico.
- Andiamo su allora :
SELECT
Val("" & Max(x_Kanly.ID) + (1°SELECT)
FROM  x_Kanly             
 
Se la faccio andare da sola sta' istruzione mi chiede di immettere
X_Kanly.Nome : metto Pippo mi da 7 , Minnie 1 , Nonna Papera 2, ...
La prima SELECT mi restituiva il conteggio dal primo record in ordine
alfabetico all'ultimo ( su richiesta di inserimento ) , questa pur
dando lo stesso risultato sembra restituire un valore : con Minnie mi
da  il Max di Kanly.ID ( cioè 0 essendo la tabella vuota ) +  il
conteggio da Minnie a Minnie ( cioè 1 ) e così via .
Provo a svuotare la X_Kanly input senza toccare X_Kanly e poi a far
partire la query.
Come intuivo prendendo in esame solo la 1° SELECT mi conteggia i
[X_Kanly input].Nome dal 1 all'ultimo e la 2° SELECT gli assegna un
valore dall'ultimo X_Kanly.ID sommandolo al risulatato del conteggio ,
ma poi perchè dico che gli assegna un valore , fa ancora parte del
conteggio , il valore gliela assegnerò  l'ultima SELECT quando prende
[X_Kanly input].Nome
Dopodichè c'è l'accodamento , ma quello è l'unica cosa chiara.
--------------------------------------------------------------------------------
A parte che solo nei miei sogni più intimi potrei immaginarmi di
costruire una cosa così: perchè hai fatto Val("" & Max(X_Kanly.ID)),
so che senza Val , partendo da una tabella , vuota mi da errore ,
perchè non riesce a sommare un valore null con qlc altro , .... certo
Val("") restituisce cmq zero con '+' mi da errore con '&' no 
Ciao. Fabrizio

...
Scusate il delirio , di solito non mi partono questi post , ma mi è
scappata la mano .
Visto che è partito mi spiego : di solito per chiarirmi le idee scrivo
un post simile  e lo faccio partire ( debitamente tagliato) solo se
non sono approdato a nulla. 
Fare finta di porre domande mi aiuta a riorganizzare le idee : io dico
sempre che una domanda posta nel miglior modo , contiene in se già la
risposta.
Mi spiace.
Ciao. Fabrizio

 Faccio delle considerazioni ad alta voce
[...]
    Cancello le tue considerazioni solo per non fare un post di lunghezza
eccessiva, pero' le terro' ben presente.
    I dati di prova in effetti dovrebbero essere di questo tipo:
        Tabella: x_Kanly
        ID  Nome
        1   "spaghetti"
        2   "pollo"
        3   "peperoni"
        Tabella: x_Kanly input
        Nome
        "Topolino"
        "Minnie"
        "Paperino"
(accorcio un po'...)
    Il risultato che vogliamo ottenere e':
        Tabella: x_Kanly
        ID  Nome
        1   "spaghetti"
        2   "pollo"
        3   "peperoni"
        4   "Minnie"
        5   "Paperino"
        6   "Topolino"
    Quindi si tratta di "trasformare" la tabella "x_Kanly input" in:
        ID  Nome
        1   "Minnie"
        2   "Paperino"
        3   "Topolino"
per poi sommare ai nuovi ID il valore del maggiore degli ID di x_Kanly.
    Domanda: quanti sono i record in cui Nome <= "Minnie" ? 1
    E quanti in cui Nome <= "Paperino" ? 2
    E cosi' via.
    Come si ottiene questo risultato ?
        SELECT
            [x_Kanly input].Nome AS Nome
          , (
              SELECT
                  Count(*)
              FROM
                  [x_Kanly input] AS TEMP1
              WHERE
                  TEMP1.Nome <=  [x_Kanly input].Nome
            ) AS ID
        FROM
            [x_Kanly input]
        ORDER BY
            [x_Kanly input].Nome
        ;
    Il maggiore degli ID di x_Kanly lo otteniamo con:
        SELECT
            Max(x_Kanly.ID) AS MaxDiID
        FROM
            x_Kanly
        ;
    Tuttavia se x_Kanly fosse vuota otterremmo NULL mentre ci servirebbe
ottenere invece Zero. Quindi:
        SELECT
            Nz(Max(x_Kanly.ID), 0) AS MaxDiID
        FROM
            x_Kanly
        ;
-oppure-
        SELECT
            Val("" & Max(x_Kanly.ID)) AS MaxDiID
        FROM
            x_Kanly
        ;
    Ora sommiamo i nuovi ID al maggiore degli ID di x_Kanly:
        SELECT
            Val("" & Max(x_Kanly.ID))
          +
          (
            ...
          ) AS ID
        FROM
            x_Kanly
        ;
saltando la clausola ORDER BY perche' la inseriremo nella query di
accodamento:
        SELECT
            Val("" & Max(x_Kanly.ID))
          +
          (
            SELECT
                Count(*)
            FROM
                [x_Kanly input] AS TEMP1
            WHERE
                TEMP1.Nome <=  [x_Kanly input].Nome
          ) AS ID
        FROM
            x_Kanly
        ;
    Per inciso  -- messaggio trasversale --  mi piacerebbe che tu notassi
come questo tipo di indentazione ti permetta, con un rapido copia/incolla,
di inserire le sottoquery al posto giusto senza dimenticare parentesi e
senza perdersi... Questo ovviamente non vale per le aquile ma per i tordelli
come me che purtroppo, per far si' che due piu' due facciano quattro il piu'
spesso possibile, sono costretti ad usare i ditini...
    Ora non ci resta che "innestare" questa query in quella di accodamento:
        INSERT INTO
            x_Kanly
            (
              ID
            , Nome
            )
        SELECT
              (
                ...
              ) AS ID
            , [x_Kanly input].Nome AS Nome
        FROM
            [x_Kanly input]
        ORDER BY
            [x_Kanly input].Nome
        ;
--


...
Grazie mille Maurì , anche se mi sembri matto ad esserti letto tutto
quel po' po' di delirio che ho scritto e che non era pensato per le
masse : anzi mi scuso ancora , come ho spiegato nel post seguente a
quello , mi è scappata la mano sul pulsante sbagliato. 
Caspita però che pelo che hai sullo stomaco :-)
Ciao. Fabrizio

             Campi
................
Veramente ottima la tua routine e funziona perfettamente, qundi grazie
mille, ma ..........
Finche la utilizzo in "preview"  (mi mostra i record da aggiungere e la
relativa numerazione incrementale) va tutto bene, ma quando la faccio
funzionare operativamente, ovvero quando deve accodare i record OfficeXP va
costantemente in crash! Ho provato a reinstallare ma nulla è cambiato. Hai
idea del perchè?
Grazie ancora
Maurizio
P.S.
Ti allego la routines da me modificata per adattarla alle mie tabelle così
ti fai un idea!
INSERT INTO Fatture01 ( NFatt, data, Cod, tipologia, iva, totale, emessa,
incasso, REFid )
SELECT (SELECT  Val("" & Max(Fatture01.NFatt)) + ( SELECT Count(*) FROM
[Fatture01temp] AS TEMP1 WHERE TEMP1.Cod<=[Fatture01temp].Cod ) FROM
Fatture01) AS NFatt, Fatture01temp.data, Fatture01temp.Cod,
Fatture01temp.Tipologia, Fatture01temp.iva, Fatture01temp.totale,
Fatture01temp.emessa, Fatture01temp.incasso, Fatture01temp.REFid
FROM Fatture01temp
ORDER BY Fatture01temp.Cod;

 ha scritto nel messaggio news:...


 ti fai un idea!
    Mi pare che sia tutto a posto.


 eccessiva, pero' le terro' ben presente.
In realtà perchè te l'avevo detto io di sfrondare un po'...
Sapevo che in fondo (molto in fondo) eri un bravo ragazzo...
Hehe ehehe eh hehe
Antonio

 Hehe ehehe eh hehe
    In realta' le cose non stanno cosi'. Non perdo tempo a spiegartelo
perche' ormai ho capito che hai delle obiettive difficolta' ad ammettere
l'evidenza dei fatti...
    Ben tornato.


     Ben tornato.
Grazie
Antonio

 ed invece che aprirmi 5 volte consecutive il box lo fa solo una volta.
None!
Se tu crei una tua funzione con un parametro e passi come parametro uno dei
campi, la funzione viene chiamata tante volte quanti sono i nuovi record!!!
Prova quello che ti ho detto!
Antonio

 capito!!!
    A cagione della loro evidenza. Non si puo' sempre girar l'occhio
dall'altra parte e far finta che il problema non ci riguarda.
