Newsgroup: it.comp.lang.delphi
Titolo: Query.isempty

Dopo aver elaborato una query, dovevo testare se fosse vuota o contenesse
dati. La query era vuota ma l'eof era false, isempty era false, ho fatto un
ulteriore controllo: recordcount = 1.
Poco male mi sono detta, testerò recordcount > 1!
Il guaio è che sia vuota che con un record, il recordcount è sempre 1.
Avete qualche consiglio?
Grazie Monica
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/


Normalmente il recordcount è 0 e eof = true.
Se indichi la versione di delphi , il database che usi , i componenti di
accesso, come è fatta la query  forse .......
Giulio

)

 query è vuota è verificare la condizione Query.Bof and Query.Eof
...mi permetto di aggiungere un metodo che trovo efficace: se nella query ti
fai restituire anche un campo chiave, ti basta testare se il suo valore è
null per scoprire se hai individuato o meno un record:
        TABELLA1 (idtabella, descrizione)
        Query1.SQL.Clear;
        Query1.SQL.Add('select * from TABELLA1');
        Query1.Open;
        if Query1.FieldByName('idtabella').IsNull then
            // tabella vuota
        else
            // almeno un record c'è
Saluti
        Marco Bortolani
        info @ 
marcobortolani.it

 suo valore č null per scoprire se hai individuato o meno un record:
Se non viene restituito alcun record, non ti viene segnalato un errore
nel tentativo di ispezionare i valori dei campi?


 Grazie Monica
Ho letto di un problema simile, ma non ricordo bene a quale database o
tecnologia di accesso ai dati fosse legato...
Comunque la soluzione ideale è quella di eseguire una query preventiva:
SELECT COUNT(*) AS NumRecord FROM tabella
Aggiungendo la stessa clausola WHERE (se presente) che faresti nella tua
query.
A questo punto questa query ti restituisce sicuramente un record con un
unico campo 'NumRecord' che contiene il numero i record estratti. Ovviamente
se valorizzato a zero, sai già preventivamente che la tua query sarà vuota.
Un altra soluzione potrebbe essere quella di muovere il dataset subito dopo
averlo aperto in modo da forzare l'aggiornamento di eventuali proprietà:
Query1.Active := True;
Query1.Last;
Query1.First;
if Query1.Eof and Query1.Bof then
    // Query Vuota
ma a me non piace molto.
Ciao,
Gianluca.


Infatti la necessità di testare che la query fosse vuota è nata da questo
problema:
Ho un report raggruppato per data che viene stampata in intestazione. Il
report viene eseguito, trova almeno un record e quando lo deve trattare
segnala errore. La tabella (.DBF) sulla quale viene fatta la query contiene
10 record, quindi il test del risultato è prevedibile. Dato che il problema
non è stato riscontrato da altri, provo a ricreare la tabella .DBF per
escludere che contenga schifezze non visibili.
Ciao Monica


 ma a me non piace molto.
Non credo ci sia bisogno di effettuare una Last e una First per
verificare le condizioni Eof e Bof.


 nel tentativo di ispezionare i valori dei campi?
No? Direi che Delphi crei i Fields corrispondenti ai campi della tabella
comunque (infatti se la query non fosse corretta, es. interrogando una
tabella che non esiste, verrebbe sollevata una exception al momento
dell'apertura del dataset), poi eventualmente li riempia con i valori che
trova.
Saluti
        Marco Bortolani

> No?
Ops... volevo dire No!

 riempia con i valori che trova.
Sì, questo messaggio è chiaro, ma io presupponevo che, ferma restando la
creazione dei Fields, tentare di leggere il valore di uno dei Field
senza avere di fatto un record corrente (poichè la query è vuota)
generasse un'eccezione.
Dovrei provare... :-)


> Sì, questo messaggio è chiaro, ma io presupponevo che
Non resisto alla tentazione di citare il cattivo di turno alle prese con il
mitico Steven Seagal, in "Trappola sulle montagne rocciose": quando uno dei
suoi scagnozzi gli comunica di avere visto il grande Steven cadere dal
treno, il cattivo gli chiede:
"Hai forse visto il suo cadavere rotolare giù dal monte?"
e lui:
"No, però è scomparso saltando in corsa tra un vagone e l'altro ed io ho
supposto che fosse caduto..."
Al punto che il cattivo fuoriesce nel proverbio sempreverde:
"LA SUPPOSIZIONE E' LA MADRE DI TUTTE LE CAZZATE!"
Non ho resistito.
        Saluti (e omaggi)
        Marco
P.S.
Uso il test sull'IsEmpty del campo chiave da sempre, e non mi hai mai dato
rogne nè la variare della piattaforma db (MsSQLServer, MsAccess, Oracle,
Paradox, Interbase 4..6.02) nè della tecnologia di accesso ai dati (BDE,
ADO, mi pare anche IbComponents).

> Uso il test sull'IsEmpty
... volevo dire IsNull: correggo e mi autopunisco!

Conclusioni:
La query incriminata, si comporta nel modo seguente:
Se analitica il test eof è = true ed il recordcount = 0
Se sintetica il test eof è = false ed il recordcount = 1
Dopo vari test per esclusione trovo che in presenza di group by si comporta
in questo modo.
Nel frattempo io risolvo testando un qualsiasi campo = isnull
dopo l'esecuzione.
Grazie a tutti.
Monica
if RB3.checked = true then
    //-----------------------------------------------------------
    // Analitica
    //-----------------------------------------------------------
    begin
        q1.sql.add('SELECT Data, Articolo, Nome,');
        q1.sql.add(' Qvendu, qannul, Cannul, Qsuppl, ');
       q1.sql.add('Quantita1,'() quantita2, ');
        q1.sql.add(' Ca1, Ca2, Codice, Numcassa, sys_numrec ');
        q1.sql.add('FROM "CONSOLIDATO.DBF" Consolidato ');
        q1.sql.add('WHERE ( data = :WDBTP1)' );
        q1.sql.add('ORDER BY Data, Articolo ' );
    end;
    if (RB1.checked = true) or (RB2.checked = true) then
    //-----------------------------------------------------------
    // Sintetica
    //-----------------------------------------------------------
    begin
        q1.sql.add('SELECT Data, Articolo, articoli.famille as
        famille, ');
        if RB2.checked = true then
            q1.sql.add('Nome, ');
        q1.sql.add('sum(Qvendu) as qvendu, sum(Qannul) as
        qannul, ');
        q1.sql.add('sum(Cannul) as cannul, sum(Qsuppl) as
        qsuppl, ');
        q1.sql.add('sum(Quantita1) as quantita1, sum(Ca1) as
        ca1, ');
        q1.sql.add('sum(Quantita2) as quantita2, sum(Ca2) as
        ca2 ');
        q1.sql.add('FROM "CONSOLIDATO.DBF" Consolidato ');
        q1.sql.add('LEFT OUTER
        JOIN '+#39+nomedb+'ARTICOLI.DBF'+#39+' articoli ');
        q1.sql.add('ON consolidato.ARTICOLO =
        articoli.ARTICOLO ');
        q1.sql.add('WHERE ( data = :WDBTP1)' );
        if RB1.Checked = true then
            q1.sql.add('GROUP BY data, famille, articolo');
         if RB2.Checked = true then
            q1.sql.add('GROUP BY data, nome, famille ,articolo');
    end;
    q1.ParamByName('WDBTP1').asdate := WDBTP1.date;
    try
        q1.open;
    except
        on edatabaseerror do
        showmessage('Impossibile ordinare i dati');
    end;


 dopo l'esecuzione.
Ottimo.
        Marco

Ottimo.
Non e' detto (mi inserisco anche io nel thread ;-) di steve seagal): in un
altro post si menzionava che il test su isnull Monica dovrebbe farlo sulla
chiave, che non puo' mai essere null tranne che nel caso di query vuota. Se
fai il test su una altro campo, devi accertarti che nella struttura della
tabella tale campo non sia "nullable".
Occhio. (all'occhio del ranocchio)
-- 
Morde. 
(
mo...@despammed.com
)
M-List di icld: 
http://it.groups.yahoo.com/group/icld/

 tabella tale campo non sia "nullable".
Azz... HO SUPPOSTO che fosse sottinteso...
Marco

... HO SUPPOSTO che fosse sottinteso...
LOL !
