Newsgroup: it.comp.macintosh
Titolo: esperti di sql a me!

sto cercando di capire come fare una query con calpo calcolato, in 
pratica io ho una tabella con i soldi ricevuti per gli affitti di 
stabili, e una seconda tabella con i soldi dovuti e vorrei fare un terzo 
campo calcolato con la differenza tra gli affitti dovuti e gli affitti 
ricevuti per capire di quanti soldi sono in passivo. ho provato  a fare 
con neooffice una query modificandola poi a mano per il campo calcolato, 
il codice sql alla fine è così:
SELECT `ricevuti`.`appartamento`, SUM( `dovuti`.`euro` ) - SUM( 
`ricevuti`.`euro` ) AS `differenza` FROM `ricevuti` `ricevuti`, `dovuti` 
`dovuti` WHERE ( `ricevuti`.`appartamento` = `dovuti`.`appartamento` ) 
AND ( ( `dovuti`.`data` >= {D '2005-01-01' } AND `dovuti`.`data` <= {D 
'2005-12-31' } AND `ricevuti`.`data` >= {D '2005-01-01' } AND 
`ricevuti`.`data` <= {D '2005-12-31' } ) ) GROUP BY 
`ricevuti`.`appartamento`
ma non funziona in pratica mi pare che ogni volta che ci sia una data 
con un ingresso di denaro lui sommi sia l'ingresso sia l'ultima uscita, 
e viceversa  quindi i valori sono altissimi e non rispondenti.
non conosco sql quindi vado a tentoni e non capisco se il metodo che sto 
usando è sbagliato o se sto formulando male il comando sql.
f.
-- 
i miei libri di poesia sono quasi eccezionali, non averli è uno spreco 
di denaro

Il Fri, 15 Apr 2005 09:11:55 +0200,
mionome...@abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijk.com
ha scritto:
Premetto che non conosco il db di neooffice.
Hai provato usanto la JOIN al posto della WHERE, per unire i due file?
Cosi':
SELECT `ricevuti`.`appartamento`, SUM( `dovuti`.`euro` ) - SUM( 
`ricevuti`.`euro` ) AS `differenza` 
FROM `ricevuti` `ricevuti` JOIN `dovuti` `dovuti`
ON `ricevuti`.`appartamento` = `dovuti`.`appartamento`
WHERE ( ( `dovuti`.`data` >= {D '2005-01-01' } AND `dovuti`.`data` <= {D 
'2005-12-31' } AND `ricevuti`.`data` >= {D '2005-01-01' } AND 
`ricevuti`.`data` <= {D '2005-12-31' } ) )
GROUP BY `ricevuti`.`appartamento`
Casomai posta come sono fatte le tabelle.
-- 
Ciao, Valerio
Sono intorno a me ma non parlano con me
Sono come me ma si sentono meglio
(Frankie Hi-Nrg Mc)

In Mysql viene una cosa del genere: TAB1 (tabella soldi ricevuti)
				    TAB2 (tabella soldi dovuti)
é convenete mettere
in entrambe le tabelle un campo (appartamento)
SELECT soldi_ric , soldi_dov , soldi_ric - soldi_dov AS differenza
FROM tab1 JOIN tab2
se invece il campo appartamento non è presente in tutte e due:
SELECT soldi_ric , soldi_dov , soldi_ric - soldi_dov AS differenza
FROM tab1 JOIN tab2 on appartamento1 = appartamento2
prova così, cmq questo è msql standard

 Cosi':
mi dà errore:
parse error, expecting 'BETWEEN' or 'IN' in 'SQL_TOKEN_LIKE'
la struttura della tabella la puoi vedere in
http://www.venerandi.com/trash/db.jpg
grazie!



Ciao, cerco di spiegarti perchè la tua query non funziona...spero di 
riuscirci, non è semplice ;)
Il problema è nel modo di relazionare le tabelle...in pratica la clausola 
FROM associata alla prima condizione WHERE, produce come risultato tutte le 
combinazioni possibili tra le righe delle due tabelle, a parità di 
'appartamento'.
Ti faccio un esempio.
Se hai nella tabella 'ricevuti' 2 record con questi valori:
appartamento=1; euro=100
appartamento=1; euro=200
E nella tabella 'dovuti' 2 record con questo valore:
appartamento=1; euro 400
appartamento=1; euro 600
Il motore SQL prima estrae le righe che soddisfano la clausola FROM e WHERE 
, poi fa il raggruppamento.
Quindi il risultato della tua FROM e della prima WHERE è questo (supponiamo 
che questi 3 record soddisfano le altre WHERE):
ricevuti.appartamento=1; ricevuti.euro=100; dovuti.appartamento=1; 
dovuti.euro=400
ricevuti.appartamento=1; ricevuti.euro=100; dovuti.appartamento=1; 
dovuti.euro=600
ricevuti.appartamento=1; ricevuti.euro=200; dovuti.appartamento=1; 
dovuti.euro=400
ricevuti.appartamento=1; ricevuti.euro=200; dovuti.appartamento=1; 
dovuti.euro=600
e quando poi il motore SQL fa il raggruppamento, ovviamente somma gli 
importi più di una volta, pari al numero di combinazioni possibili tra i 
record.
Per risolvere il problema la soluzione più semplice è fare due query 
separate di raggruppamento sulle due tabelle e poi una query che 'fonde' i 
risultati:
Query `sommaricevuti`:
SELECT `ricevuti`.`appartamento`, SUM(`ricevuti`.`euro` ) AS `ricevuti`
FROM `ricevuti`
WHERE `ricevuti`.`data` >= {D '2005-01-01' } AND
`ricevuti`.`data` <= {D '2005-12-31' }
GROUP BY `ricevuti`.`appartamento`
Query `sommadovuti`:
SELECT `dovuti`.`appartamento`, SUM(`dovuti`.`euro` ) AS `dovuti`
FROM `dovuti`
WHERE `dovuti`.`data` >= {D '2005-01-01' } AND
`dovuti`.`data` <= {D '2005-12-31' }
GROUP BY `dovuti`.`appartamento`
E poi fai una query che usa le due query precedenti e fa la differenza:
SELECT `sommadovuti`.`appartamento`, `sommadovuti`.`dovuti` - 
`sommaricevuti`.`ricevuti`
FROM `sommadovuti`, `sommaricevuti`
WHERE `sommadovuti`.`appartamento` = `sommaricevuti`.`appartamento`
Spero di esserti stato d'aiuto!
Ciao, Davide. 

 mysql, motore esterno
Quindi dovrebbe accettare le join, se non sbaglio.
Assumendo che dovuti e ricevuti abbiano strutture simili, dovrebbe essere
qualcosa del genere:
SELECT dovuti.appartemento, sum(dovuti.euro) - sum(ricevuti.euro)
FROM dovuti JOIN ricevuti
ON dovuti.appartamento = ricevuti.appartamento
WHERE (quello che vuoi)
GROUP BY dovuti.appartemento
Che dovrebbe essere la sintesi di quello che ti avevo detto.
Casomai prova a cambiare JOIN con LEFT JOIN o INNER JOIN, non conosco il
dialetto di mysql, ma dovrebbe essere simile come risultato.


 con un ingresso di denaro lui sommi sia l'ingresso sia l'ultima uscita, 
cosa sarebbe l'ultima uscita? comunque se ci dici come sono le tabelle 
potrebbe essere un po' piu' facile capire come hai impostato la cosa :)

 GROUP BY dovuti.appartemento
Ciao, credo che sebbene sia molto più elegante fare la JOIN invece di 
esprimerla con condizione WHERE, il comportamento è lo stesso del problema 
segnalato...infatti la JOIN esegue il prodotto cartesiano delle righe delle 
tabelle e conteggia più volte gli stessi importi (vedi risposta che ho dato 
sotto).
Davide. 



Mi permetto di dissentire.
La JOIN dovrebbe ritornarti si il prodotto cartesiano della tabelle, ma
solo dei record corrispondenti alla clausola ON, e poi su questi vengono
applicati WHERE, GROUP BY e SELECT, con tutte le funzioni di colonna.
Altrimenti non sarebbe mai corretto il risultato delle SUM, MAX, MIN, ecc,
ecc, applicato a dei dati ottenuti tramite JOIN.
E ti posso garantire, per esperienza personale, che le ho gia' usate con
profitto e fanno quello che mi aspetto, cioe' la somma dei soli dati uniti
con il JOIN e filtrati con la WHERE.


 con il JOIN e filtrati con la WHERE.
Su questo non ho nessun dubbio...ma qui è il JOIN a monte che è 
concettualemnte sbagliato.
Devo dire tuttavia che non consoco mysql, io lavoro da 8 anni su sistemi 
Oracle, SQL Server, PostgreSQL e Access e in tutti questi casi il 
comportamento è quello che ho descritto.
Ho provato ora a fare la prova con Posgres 8.0 e ho avuto la conferma:
-ho creato due tabelle 'dovuto' e 'ricevuto' con i campi 'appartamento' 
(int) e 'euro' (int...solo per provare)
-ho riempito la prima con i due record (1, 400) (1, 600) e la seconda con i 
due record (1, 100) (1, 200)
-ho eseguito la query cha hai postato e il risultato è
(1, 1400)
che ovviamente non è corretto poichè dovrebbe restituire (1, 700)
Ti consiglio di fare la prova su mysql...se poi il comportamento è diverso, 
ritiro tutto...
Ciao, Davide. 

 ritiro tutto...
Senza fare la prova hai ragione a mille, cenere sul mio capo.
Il problema allora e' logico.
Pero' si potrebbe risolvere con delle sub-query, cioe' roba tipo:
SELECT appartamento, (SELECT SUM(euro) FROM dovuti) - (SELECT SUM(euro)
FROM ricevuti) FROM appartemento
ma non so se funziona, oppure con le subquery + UNION:
SELECT appartamento, SUM(dovuti) - SUM(ricevuti)
FROM (
SELECT appartamento, SUM(euro) AS dovuti, 0 as ricevuti
FROM dovuti
WHERE (...)
GROUP BY appartamento
UNION ALL
SELECT appartamento, 0 as dovuti, SUM(euro) AS ricevuti
FROM ricevuti
WHERE (...)
GROUP BY appartamento
)
Pero' non ho la possibilita' di provarlo qui.


 FROM ricevuti) FROM appartemento
Tra l'altro ci mancano i WHERE per l'appartamento cosi':
SELECT appartamento,
   (SELECT SUM(euro) FROM dovuti WHERE appartamento = A.appartamento) -
   (SELECT SUM(euro) FROM ricevuti WHERE appartamento = A.appartamento)
FROM appartemento as A
Pero' resta da provarla.


 Il problema allora e' logico.
esatto...la difficoltà nell'esprimere una query di questo tipo nasce dalla 
struttura del database che usa due tabelle separate. Io avrei creato 
un'unica tabella con i movimenti dare/avere segnati in positivo/negativo...a 
questo punto una semplicissima query di raggruppamento con somma 
sull'importo avrebbe funzionato.
Ciao, Davide. 

 sull'importo avrebbe funzionato.
He he, pure io avrei fatto cosi'.


per te deve essere stato orrendo ha scritto:

il problema credo (se ho capito la situazione) sia causato dalle 
ripetizioni; tu devi avere una riga per ogni appartamento sia in 
RICEVUTI che in DOVUTI e su quei campi fare il calcolo
io con l'SQL di Oracle farei:
select A.appartamento, ( a.TOT - B.TOT ) differenza
from (select `ricevuti`.`appartamento` , SUM( `ricevuti`.`euro` ) TOT
         from RICEVUTI group by `ricevuti`.`appartamento`) A
    , (select `dovuti`.`appartamento` , SUM( `dovuti`.`euro` ) TOT
         from DOVUTI group by `dovuti`.`appartamento`) B
  where A.appartamento = B.appartamento;
(a parte la sintassi sql diversa)
cia'
-- 
Marco @ Work __________________________________________________
PMac 7600/132 - MacOS 8.5 &  iBookG4 1.2/768 - MacOSX 10.3.8

 risultati:
questa risposta mi fa sentire più intelligente perché ci avevo già 
provato qualche giorno fa. All'epoca avevo fallito perché mi diceva che 
non trovava tabelle con quel nome (e ci credo erano query), adesso mi dà 
l'errore:
parse error, expecting 'BETWEEN' or 'IN' in 'SQL_TOKEN_LIKE'
il codice è:
select `totale dovuti 2005`.`appartamento`, `totale dovuti 
2005`.`sum(`euro`)` - `totale ricevuti 2005`.`sum(`euro`)`
from  `totale dovuti 2005`,  `totale ricevuti 2005`
where `totale ricevuti 2005`.`appartamento` = `totale dovuti 
2005`.`appartamento`
sbaglio qualcosa?


 potrebbe essere un po' piu' facile capire come hai impostato la cosa :)
vedi link che indicavo poc'anzi


 dialetto di mysql, ma dovrebbe essere simile come risultato.
rispondo qua tutti i tuoi messaggi che ho letto fino alla fine per 
vedere che join in questo caso non č utilizzabile. grazie comunque, come 
recitano i manifesti di uno di forza italia trombato alle ultime elezioni.
f.
-- 
i miei libri di poesia sono quasi eccezionali, non averli č uno spreco 
di denaro

 )
adesso vado a pranzo e poi ci provo, grazie.
f.


 join in questo caso non è utilizzabile.
Attenzione che la WHERE come la usi tu da' lo stesso problema di record
multipli come diceva correttamente Davide (Freeride78).


 voglio il sangueeeee!
LOL


 He he, pure io avrei fatto cosi'.
ah ma come siete tutti bravi!
io non ci avevo pensato... sì in linea di massima sarebbe possibile, 
dovrei dragdroppare un bel po' di roba e rifare un po' di form...
adesso vedo se trovo una soluzione più semplice.
grazie
f.


 Mi permetto di dissentire.
voglio il sangueeeee!
f.


 adesso vado a pranzo e poi ci provo, grazie.
Buon appetito. Fra poco vado pure io.


 
nulla, sia questa:
SELECT appartamento,
    (SELECT SUM(euro) FROM dovuti WHERE appartamento = A.appartamento) -
    (SELECT SUM(euro) FROM ricevuti WHERE appartamento = A.appartamento)
FROM appartemento as A
  FROM `ricevuti` `ricevuti`, `dovuti` `dovuti` WHERE ( 
`ricevuti`.`appartamento` = `dovuti`.`appartamento` ) AND ( ( 
`dovuti`.`data` >= {D '2005-01-01' } AND `dovuti`.`data` <= {D 
'2005-12-31' } AND `ricevuti`.`data` >= {D '2005-01-01' } AND 
`ricevuti`.`data` <= {D '2005-12-31' } ) )  GROUP BY 
`ricevuti`.`appartamento`
che questa :
SELECT appartamento, SUM(dovuti) - SUM(ricevuti)
FROM (
SELECT appartamento, SUM(euro) AS dovuti, 0 as ricevuti
FROM dovuti
WHERE (data  >= {D '2005-01-01' } AND data  <= {D '2005-12-31' })
GROUP BY appartamento
UNION ALL
SELECT appartamento, 0 as dovuti, SUM(euro) AS ricevuti
FROM ricevuti
WHERE  (data  >= {D '2005-01-01' } AND data  <= {D '2005-12-31' })
GROUP BY appartamento
)
danno errore di sintassi nei pressi della sottoquery, sia in neooffice 
sia in cocoamsql...


 sia in cocoamsql...
Purtroppo le ho scrite a occhio, qui non ho mysql e nemmeno neoofice.
Magari provo questa sera, pero' mi devo scaricare ed installare il tutto.


 Magari provo questa sera, pero' mi devo scaricare ed installare il tutto.
no vabbé non voglio farti impazzire.


 sia in cocoamsql...
che versione usi di mysql? fino a non ricordo che versione mysql manco 
le supportava le sottoquery... (assieme a un mucchio di altra roba)

 no vabbé non voglio farti impazzire.
No, no e' una questione di principio, tipo quesito della susi, e forse ho
risolto....
 
select appartamento, sum(dovuti), sum(ricevuti) from (
select appartamento, sum(euro) as dovuti, 0 as ricevuti from dovuti group
by appartamento
union all
select appartamento, 0 as dovuti, sum(euro) as ricevuti from ricevuti group
by appartamento
) as totale
group by appartamento


 le supportava le sottoquery... (assieme a un mucchio di altra roba)
4.0.21


 risolto....
P.S.: ho provato con una 4.1.11 su xp-prof.


 risolto....
niente non prende la sottoquery... che sia una versone di mysql troppo 
vecchia?


 vecchia?
Ecco, non ho fatto in tempo ad aggiungerlo all'altro posto, io ho provato
con una 4.1.11 su xp-prof.
-- 


 
siano stramaledetti gli installer che non installano tutto con un click.
a lunedě dannato mondo command-line.
f.
-- 


 
allora modificando questa con sum(dovuti) - sum(ricevuti), e aggiornando 
a 4.1.1, funziona! Un grazie a tutti, siete stati fantastici, si fa per 
dire; normali. Generosi.
Nel frattempo l'aggiornamento da 4.0 a 4.1 fa sì che jdbc non mi 
colleghi più il database a neooffice, sembrava finita eh.


 colleghi più il database a neooffice, sembrava finita eh.
Azz, qui non saprei, non uso neooffice, ho installato solo mysql per
provare gli sql e non sparare fesserie ;-p


 provare gli sql e non sparare fesserie ;-p
risolto. con mal di testa ma risolto.


 risolto. con mal di testa ma risolto.
Il mal di testo te lo ha provocato neooffice?
Se si non mi piace piu' ;-p


 Se si non mi piace piu' ;-p
in parte, in pratica il vecchio driver jdbc non funzionava più con il 
nuovo mysql, il nuovo jdbc dava un errore che non capivo, e il driver 
odbc mi dava tutto il database in sola lettura.
lì è venuto il mal di testa.
alla fine ho trovato che il driver nuovo jdbc usa java 1.4.x, mentre 
neooffice/j usa 1.3 e la cosa non era buona.


 potrebbe essere meno performante (dipende quanto sono gli apprtamenti)
in più la differenza tra i due valori si chiama ' sum(dovuti) - 
sum(ricevuti)'. il campo calcolato 'totale' non viene creato.


 
oh beh qui a tonnellate.
f
-- 
nella mia prossima reincarnazione, se non sarò un pesce o altro tipo di 
inverterbato, scriverò la faq per i database

 niente, mi dà errore di sintassi sia a metterlo in cima che in fondo
Boh io ho provato qui e mi funziona in entrambi i modi, le prove le ho
fatte direttamente su un db di prova con MySQL Query Browser.
Ovviamente al posto di :cid nella WHERE ci ho messo direttamente un valore
cioe' 1 o 2 per fare le prove.
Che errore ti da?


 sum(ricevuti)'. il campo calcolato 'totale' non viene creato.
Per questo dovrebbe bastare una modifica alla select iniziale:
da:
select appartamento, sum(dovuti), sum(ricevuti)
a:
select appartamento, sum(dovuti) - sum(ricevuti) as differenza


 Che errore ti da?
con il valore funziona... sembra non accettare l'uso della variabile...
eppure tutte le altre query che ho fatto usano la stessa variabile...


 eppure tutte le altre query che ho fatto usano la stessa variabile...
Se fai una query semplice tipo
   select *
   from dovuti
   where appartamento = :cid
funziona tranquillamente?


 Che errore ti da?
generico errore di sintassi attorno a "= :cid
    group by appartamento
    union all
    select appartamento, 0 "
-- 
si vede che uno dei 25'000 file di testo che costituiscono il sistema 
operativo avra' un errore di battitura.

 funziona tranquillamente?
dunque dunque dunque dunque dopo molte molte prove ho capito questa 
cosa, in pratica la query che ti dicevo prima 'funziona', funziona solo 
se dico a neooffice di interpretarla direttamente come SQL senza 
pre-interpretarla lui. lui non la guarda nemmeno, la manda a mysql che 
capisce e la fa funzionare. se chiedo a neooffice di preinterpetarla mi 
dà errore generico di sintassi.
ora.
la query che invece mi scrivi qui sopra funziona perfettamente se 
neooffice la pre-analizza (viene fuori una finestra di inserimento del 
valore :cid), mentre se la manda direttamente a mysql viene fuori un 
errore che non sa che valore ha :cid (giustamente).
e -ho scoperto- lui si ricorda se una sql deve preinterpretarla oppure 
no, quindi un form con lo stesso comando sql funziona o meno a seconda 
se nella query ho selezionato che deve preinterpretarlo oppure mandarlo 
direttamente come comando sql.
ergo
temo che le query con variabili necessitino per funzionare di poter 
essere preinterpretate da neooffice, perché se le manda direttamente a 
mysql gli ritorna indietro errore. il che rende impossibile mettere 
variabili nella query tanto bella e tanto cara di stamattina.
a meno che io non venga smentito.
adesso mi merito l'insalatina del pranzo.
f.


 adesso mi merito l'insalatina del pranzo.
Buon appetito.


 Buon appetito.
c'era una torta di carciofi ai limiti del commestibile
f;


, quale prendo
OpenOffice.org oppure NeoOffice/J ? Tieni conto che ho gia' X11 installato
sul mac.
3) Per l'integrazione con MySql devo installare qualcos'altro, oltre a
MySql ovviamente ?
Per adesso mi fermo qui, ma ti tartassero' appena scaricato ed installato.
Come si dice uomo avvisato mezzo salvato, te la sei voluta he he ;-p


 Come si dice uomo avvisato mezzo salvato, te la sei voluta he he ;-p
figurati a buon rendere. e poi potresti essere mio alleato.
f.


 figurati a buon rendere. e poi potresti essere mio alleato.
Aaaaah, ma allora tele cerchi proprio ;-p
Scherzi a parte mi interessa molto.


 Aaaaah, ma allora tele cerchi proprio ;-p
Io ti avevo avvertito ;-p


 Io ti avevo avvertito ;-p
he he
f.
-- 
nirgr znv nffnttvngb yr ynzr ebgnagv? uggc://jjj.ynzrebgnagv.pbz

 chiedimeli domani che stasera vado in disco a pogare.
Grazie, buon divertimento


 
hem non il 3.0.6, sono sul pb e ho quello vecchio. usa quello che ti 
indicavo oggi 3.0.1x dove x è un numero che non ricordo


 chiedimeli domani che stasera vado in disco a pogare.
Aaahhh, ma allora sei un veggente ;-p


 
mica male


 fabrizio è ovviamente il nome del database
fatto
Hei funziona! Ed e' pure bello!
Allora sono arrivato a questo punto:
select appartamento, 
   (select sum(euro) from dovuto where appartamento = a.appartamento),
   (select sum(euro) from pagato where appartamento = a.appartamento)
from appartamenti as a
where appartamento = :cid
Se lo eseguo, senza aver attivato "Esegui direttamente comando sql", mi
apre una finestra "Specifica parametro" in cui c'è il parametro cid e
sotto il valore, ci scrivo quello che voglio e lui mi esegue la query
correttamente.
Qui però mi fermo, perchè non so cosa farmene di questo risultato.


 where appartamento = :cid
Cosě perň č meglio
select appartamento, 
   (select sum(euro) from dovuto where appartamento = a.appartamento) as
dovuti,
   (select sum(euro) from pagato where appartamento = a.appartamento) as
pagati
from appartamenti as a
where appartamento = :cid
ci sono i nomi delle colonne


 
bene ho adattato tutto ai miei nomi di tabelle e campi ed ha 
funzionato... però quando provo a mettere di nuovo il campo 'differenza' 
ecco che mi dà errore:
select via,
    (select sum(euro) from dovuti where appartamento = a.via) as
dovuti,
    (select sum(euro) from ricevuti where appartamento = a.via) as
pagati,
    (select sum(euro) from dovuti where appartamento = a.via) - 
(select sum(euro) from ricevuti where appartamento = a.via)
as  differenza,
from generale as a
where via = :cid
dove sto sbagliando?
f


 dove sto sbagliando?
Dovrebbe essere tutto corretto, pero' adesso non riesco a provare con
neooffice + mysql, sono sul pc dell'ufficio, ho provato solo l'sql su mysql
e funziona.
Casomai posso provare durante la pausa.
Che errore ti dà?


 
come sql mi dice che c'è un errore di sintassi in "from generale as a
where via = :cid", come neooffice mi dice genericamente che c'è un 
errore di sintassi.
ribadisco che l'errore viene fuori solo aggiungendo:
(select sum(euro) from dovuti where appartamento = a.via) -   (select 
sum(euro) from ricevuti where appartamento = a.via)
as  differenza,
prima andava
f.


 prima andava
Ok, prometto che durante la pausa pranzo di provo.
Non puo' essere che la vinca LUI.


 where via = :cid
Allora, ho fatto la prova che ti dicevo, ma a me funziona tranquillamente.
L'sql che ho provato è questo:
select appartamento,
(select sum(euro) from dovuto where appartamento = a.appartamento) as
dovuti,
(select sum(euro) from pagato where appartamento = a.appartamento) as
pagati, 
(select sum(euro) from dovuto where appartamento = a.appartamento) -
(select sum(euro) from pagato where appartamento = a.appartamento) as
residuo
from appartamenti as a
where appartamento = :cid
che è uguale al tuo, tranne i nomi di tabelle e colonne.
Boh!


 che è uguale al tuo, tranne i nomi di tabelle e colonne.
se sopravvivo a questa cosa chiamata 'giorno' domani provo ancora
d.


 se sopravvivo a questa cosa chiamata 'giorno' domani provo ancora
Addirittura ;-p


 
non era uguale al mio... io avevo messo una virgola dopo 'differenza' e 
prima di from... grrr a me stesso.
grazie mille ci siamo riusciti adesso funziona perfettamente!
f.


 grazie mille ci siamo riusciti adesso funziona perfettamente!
Bene.
Prima o poi mi spieghi come si fanno le form?
Cioè dopo aver fatto l'sql sul db che faccio?


 
in teroria avevo iniziato a scrivere una breve faq, in pratica mi sono 
reso conto che è un compito quasi immane. mi dò ancora una settimana di 
tempo.
un ottimo ottimo testo è comunque questo:
http://sf.gds.tuwien.ac.at/00-pdf/o/ooodocs/OooDb_1_0.pdf


 
http://sf.gds.tuwien.ac.at/00-pdf/o/ooodocs/OooDb_1_0.pdf
Scaricato, me lo leggo e ci provo.
Grazie.
