Newsgroup: it.comp.appl.access
Titolo: calcolo nella query

Ho una query in cui, inserendo le date di inizio e fine servizio, vengono
calcolati, per ogni anno, i periodi (in giorni) di servizio degli
insegnanti.
Poi con un altro calcolo vengono sommati i periodi di ogni anno e ottengo il
numero totale dei giorni di servizio per ogni anno.
Il problema che si presenta è questo:
Se un insegnante insegna in due scuole, i periodi di servizio si
sovrappongono, e quindi i giorni che coincidono non devono essere sommati,
ma devono essere considerati una volta sola.
C'è un modo per individuare questi giorni che coincidono, o cmq per
risolvere questo problema, avendo io solo le date di inizio e fine?
Spero di essermi spiegata. Grazie in anticipo.
Francesca

 ha scritto nel messaggio
news:am7vs7$qi5$1...@newsreader.mailgate.org...

Non so come è strutturata la tua query, ma problemi di questo tipo
solitamente si risolvono con un raggruppamento nella colonna
dei giorni.
--
Debora

 dei giorni.
debora 
non credo che questo sia un problema che si possa risolvere
con un raggruppamento
quello che vuole dovrebbe essere questo
* = periodo osservato
-/+ = periodi registrati (+ utili - inutili)
              *****************
1   -------
2      -------++++++
3        ----------++++++++++++-------
4                          --------------
5                  ---------
6                                    --------------
con una query non so. Ma, estratti i periodi utili (2,3,4,5),
il resto con poche righe di codice si fa.
--
a.cara

 ha scritto nel messaggio
news:am7vs7$qi5$1...@newsreader.mailgate.org...

Io direi di risolvere condue query: la prima di selezione con la quale
effettuare la valorizzazione della durata di servizio per ogni singolo
record; la seconda, basata sulla prima, di raggruppamento che restituisce i
totali delle durate di servizio per anno e per insegnante.
Se i dati sono contenuti in una tabella chiamata Servizio che abbia una
struttura simile a questa:
ID                    Contatore e chiave primaria
IDInsegnante    Numerico
Anno                Testo
Inizio                Data/ora
Fine                  Data/ora
Per la valorizzazione al livello di record crea una prima query chiamata
Query1 che abbia il seguente codice SQL:
SELECT Anno, IDInsegnante, DLookUp("ID","Servizio","ID<>" & [ID] & " And
IDInsegnante=" & [IDInsegnante] & " And Inizio=#" &
Format([Inizio],"mm/dd/yyyy") & "# And Fine=#" & Format([Fine],"mm/dd/yyyy")
& "#") AS Uno, DLookUp("ID","Servizio","ID<>" & [ID] & " And IDInsegnante="
& [IDInsegnante] & " And Inizio<=#" & Format([Inizio],"mm/dd/yyyy") & "# And
Fine>=#" & Format([Fine],"mm/dd/yyyy") & "#") AS Due,
DLookUp("ID","Servizio","ID<>" & [ID] & " And IDInsegnante=" &
[IDInsegnante] & " And Inizio<#" & Format([Inizio],"mm/dd/yyyy") & "# And
Fine<#" & Format([Fine],"mm/dd/yyyy") & "# And Fine >#" &
Format([Inizio],"mm/dd/yyyy") & "#") AS Tre, IIf(Not
IsNull([Uno]),IIf(Val([Uno])<[ID],0,[Fine]-[Inizio]+1),IIf(Not
IsNull([Due]),0,IIf(IsNull([Tre]),[Fine]-[Inizio]+1,[Fine]-DLookUp("Fine","S
ervizio","ID=" & [Tre])))) AS Durata
FROM Servizio;
Quindi crea una query di raggruppamento, che ti restituirà i totali per anno
ed insegnante, che abbia il seguente codice SQL:
SELECT Anno, IDInsegnante, Sum(Durata) AS SommaDiDurata
FROM Query1
GROUP BY Anno, IDInsegnante;
Dovrebbe funzionare. ;-)
--
Roberto
---------------------------------------------
il Sito Comune di it.comp.appl.access:
http://www.sitocomune.com
---------------------------------------------

Roberto da casa wrote:
[cut]

Ciao Roberto
ero curioso rispetto alla query da te proposta.
Ho provato a "leggerla" poi ho preferito provarla
Questi sono i risultati (tranne la definizione
della tabella tutto fatto con copiaincolla)
dati tabella
id	idinsegnante	anno	inizio	fine
1	1	2002	15/01/2002	20/01/2002
2	1	2002	21/01/2002	23/01/2002
4	2	2002	01/02/2002	20/02/2002
5	2	2002	10/02/2002	21/02/2002
6	2	2002	01/03/2002	10/03/2002
7	3	2002	02/03/2002	10/03/2002
8	3	2002	02/03/2002	10/03/2002
9	3	2002	02/03/2002	11/03/2002
risultato query
Anno	IDInsegnante	Uno	Due	Tre	Durata
2002		1				6
2002		1				3
2002		2				20
2002		2			4	#Errore
2002		2				10
2002		3	8	8		9
2002		3	7	7		0
2002		3				10
curiosita' a che ti servono uno, due, tre
--
a.cara

 > Quindi crea una query di raggruppamento, che ti restituirą i totali per

Scusate se mi intrometto, ma dato che serve anche a me, dico la mia:
Franc. sta chiedendo di non sommare giorni uguali, quindi la query deve
avere
un raggruppamento dei giorni in modo che si possano sommare univocamente
 in poche parole una specie SELECT DISTINCT dei giorni, x ogni insegnante.
A voi il metodo per ottenerlo. ;-P
--
Debora

 ha scritto nel messaggio
news:3D884C3A...@blunet.it...
[CUT]

In effetti c'era un errore su Query1 nel calcolo del campo calcolato Tre: o
modificato Query1 in questa maniera:
SELECT Servizio.Anno, Servizio.IDInsegnante, DLookUp("ID","Servizio","ID<>"
& [ID] & " And IDInsegnante=" & [IDInsegnante] & " And Inizio=#" &
Format([Inizio],"mm/dd/yyyy") & "# And Fine=#" & Format([Fine],"mm/dd/yyyy")
& "#") AS Uno, DLookUp("ID","Servizio","ID<>" & [ID] & " And IDInsegnante="
& [IDInsegnante] & " And Inizio<=#" & Format([Inizio],"mm/dd/yyyy") & "# And
Fine>=#" & Format([Fine],"mm/dd/yyyy") & "#") AS Due,
DLookUp("ID","Servizio","ID<>" & [ID] & " And IDInsegnante=" &
[IDInsegnante] & " And Inizio<=#" & Format([Inizio],"mm/dd/yyyy") & "# And
Fine<#" & Format([Fine],"mm/dd/yyyy") & "# And Fine >#" &
Format([Inizio],"mm/dd/yyyy") & "#") AS Tre, IIf(Not
IsNull([Uno]),IIf(Val([Uno])<[ID],0,[Fine]-[Inizio]+1),IIf(Not
IsNull([Due]),0,IIf(IsNull([Tre]),[Fine]-[Inizio]+1,[Fine]-DLookUp("Fine","S
ervizio","ID=" & [Tre])))) AS Durata
FROM Servizio;
Ho provato ad inserire nella tabella Servizio i tuoi stessi dati ed aprendo
Query1 vedo i seguenti risultati;
Anno IDInsegnante Uno Due Tre Durata
2002     1                                       6
2002     1                                       3
2002     2                                      20
2002     2                                4     1
2002     2                                      10
2002     3                  8     8             9
2002     3                  7     7             0
2002     3                                7      1
che ora misembrano tutti corretti
Ti faccio presente, comunque, che #Errore nella durata del quarto record non
me lo ha dato neppure prima della modifica di Query1: non saprei cosa dirti.
Nel campo calcolato Uno calcolo l'ID dell'eventale record che si sovrappone
completamente al record corrente; se Uno non è Null, forso a zero la durata
se l'ID del record corrente è maggiore del valore del campo Uno, in caso
contrario determino la durata facendo la differenza tra le due date più uno
del record corrente.
Nel campo calcolato Uno calcolo l'ID dell'eventale record che contiene
completamente il record corrente (naturalmente un record che ha
significativo il campo Uno avrà significativo ed uguale anche il campo Due:
non è vero l'inverso); se il campo Uno è Null ed il campo Due è
significatico forso a zero la durata.
Nel campo calcolato Tre colcolo l'ID dell'eventuale record che si sovrappone
parzialmente al record corrente e che ha un inizio minore o uguale
all'inizio del record corrente; se il campo Tre è significativo e i campi
Uno e Due sono Null, determino la durata sottraendo la fine del record
corrente alla fine del record il cui ID è contenuto nel campo Tre.
Se tutti e tre i campi calcolati sono Null, determino la durata facendo la
differenza tre le due date più uno del record corrente.
Ho provato a non far visualizzare i tre campi calcolati inserendo il loro
algoritmo direttamente nella formula del campo Durata, ma la stringa che ne
risultava era troppo lunga, ed Access mi ha mandato a quel paese.


Grazie a tutti... Rientro ora.
Adesso studio per benino i vostri consigli.
Un caro saluto.
Francesca

Per la Quey1 usa il codice che ho postato in risposta ad Alessandro oggi
alle ore 13:14 ; il primo conteneva un errore.


 me lo ha dato neppure prima della modifica di Query1: non saprei cosa dirti.
che versione di access usi? Io sto usando il 2000 SR1 ed ora con
la nuova query di #Errore ne prende 2 (sui campi in
sovrapposizione parziale 4to e 8vo record)
Mi fa anche un'altra stranezza, esegue la query e poi
ricevo un messaggio di errore di Jet che pressapoco recita
"......Jet non e' in grado di trovare la tabella o la query 
di input 'Servizio'......" ed il bello e' che il messaggio
appare ogni volta che mi muovo, sul risultato della query,
con il mouse sul campo durata che contiene #Errore
Ho cancellato record, modificato, inserito a nuovo 
ora ho una situazione pulita (ed e' OK)
Non sono ancora riuscito a capire la regola che 
genera #Errore e cmq e' legata sicuramente ai periodi 
in sovrapposizione
[cut]
--
a.cara

Il database mi sembra molto complesso (almeno per le mie possibilità) e
spesso mi perdo io stessa...
Debora mi ha messo la pulce nell'orecchio dicendomi della query di
raggruppamento. Mi è venuto in mente che forse si può risolvere utilizzando,
in "formula", il "Min" per l'inizio servizio, e il "Max" per la fine del
servizio. Così in un unico periodo dovrebbero essere compresi tutti i giorni
sovrapposti. Ma forse così si presenta un altro problema...
Cmq sto studiando per benino la situazione con tutte le soluzioni proposte.
Grazie. Francesca


Poi magari vi dico come avrò risolto, se ci riesco...
Grazie. Francesca

... and so on 
Vado a rileggermi la domanda da cui partivamo perchč mi sa che non
l'ho capita, ..... niente non riesco a defilarmi, sparatemi.
Ciao. Fabrizio

[cut]
Provo ..... confermo, con periodi in sovrapposizione da errore: e
bravo Ale.
Non mi sono defilato e non mi sono sparato, perciò sopportatemi.
Ciao. Fabrizio

 a.cara


 Debora


 Ciao. Fabrizio


oggi alle 15:23 e facci sapere.
Provo, ma ti dirò solo cosa mi capita non mi chiedere di dirti quello
che non so ..... sig .. io volevo .. sigh .. provare solo .. sigh ..
quella funzione DLookUp :°-(  .
Ciao. Fabrizio

anche questa è una soddisfazione.
A me capita spesso con mia moglie , ma non me la cavo a così buon
mercato.  :-)  .
ASPETTATE UN MOMENTO : mentre stavo cercando di mettermelo giù meglio
per potermi leggere il codice con una formattazione che mi piace di
più ( e quindi aggiustando anche gli spazi ) tutto va a meraviglia:
vuoi vedere che ci eravamo fidati troppo del copia incolla.
DOMANDA: ho messo due record così ( per provare un po' tutti i casi)
....   inizio           fine
....   01/01/02   03/01/02
.....  03/01/02   04/01/02
risultato
.....     durata
......    3
......    2
, ma non dovrebbe ridarmi 1 per il secondo record essendo il giorno
03/01/02 già fatto nel primo record ?
Adesso provo i codici che ci davano errore riaggiustando gli spazi e
vi faccio sapere.
Ciao. Fabrizio

Ciao. Fabrizio
Provato, funziona il secondo codice postato da Roberto.... e anche il
primo: ho scoperto il problema, quando si fa copia incolla succede
questo:
IsNull([Due]),0,IIf(IsNull([Tre]),[Fine]-[Inizio]+1,[Fine]-DLookUp("Fine","S****
*****ervizio","ID=" & [Tre])))) AS Durata
La parola servizio rimane troncata, aggiustandola cosě:
IsNull([Due]),0,IIf(IsNull([Tre]),[Fine]-[Inizio]+1,[Fine]-DLookUp("Fine","Servizio","ID="
& [Tre])))) AS Durata
, torna tutto a posto.
Abbiamo fatto di una cagatina una montagna di merda, scusa Roberto.
Ciao. Fabrizio

 Ciao. Fabrizio
Hai visto che non dovevi defilarti; se lo facevi probabilmente non avremmo
scoperto l'arcano e saremmo rimasti della convinzione di un bug su Access
2000 e 2002.


2000 e 2002.
Però non hai detto che non mi devo sparare e tutto questo perchè sei
geloso di me , ingrato :-))))) ( risata grassa)
Grazie Roberto, sei un pozzo di scienza.
Ciao. Fabrizio

 Bene, Bravo, 7+ . :-))
mi va bene tutto, compreso il 7+
Domanda: Per quale motivo l'errore spuntava in quel modo?
Provo a rispondermi da solo: Solo perche' in quei casi attivava
la dlookup ed essendo "Servizio" un parametro viene valutato dal parser
SQL solo al momento della chiamata di funzione?
--
a.cara

> "Francesca" [...]:

        PARAMETERS
            [DataInizio?] DateTime
          , [DataFine?] DateTime
        ;
        SELECT
            x_Francesca.Insegnante
          , x_Francesca.Servizio
          , x_Francesca.DataInizio
          , x_Francesca.DataFine
          , IIf
            (
              (
                SELECT
                    Count(*) AS ConteggioDiRecord
                FROM
                    x_Francesca AS TEMP1
                WHERE
                    TEMP1.Insegnante=x_Francesca.Insegnante
                    AND
                    TEMP1.Servizio = x_Francesca.Servizio
                    AND
                    x_Francesca.DataInizio < TEMP1.DataInizio
                    And
                    TEMP1.DataFine < x_Francesca.DataFine
              )
              =
              0
            , [x_Francesca].[DataFine]-[x_Francesca].[DataInizio]
            , 0
            ) AS Giorni
        FROM
            x_Francesca
        WHERE
            x_Francesca.DataInizio>=[DataInizio?]
            AND
            x_Francesca.DataFine<=[DataFine?]
        ORDER BY
            x_Francesca.Insegnante
          , x_Francesca.Servizio
          , x_Francesca.DataInizio
          , x_Francesca.DataFine
        ;
SE&O
--
Ciao :-)
Maurizio
--------
?SPQR(C)
 X
--------

cut
Ciao. Fabrizio

cut

Eh no adesso la mia etica  mi impone di provare anche questa :-) ,
maledizione Maurì torna a lavurà :-))))  :
non mi sono ancora studiato il codice di Roberto che ci si mette anche
lui , chi glielo dice alla mia mamma :-))))  ?
Servizio che tipo di campo è e cosa indica ?
Non rispondere da tracotante, please. :-)
Ciao. Fabrizio

Servizio che tipo di campo č e cosa indica ?
Ho proprio bisogno di sapere come hai impostato Servizio , perchč cosě
com'č i risultati fanno schifo.
Ciao. Fabrizio

 Non rispondere da tracotante, please. :-)
    Tra cotante parole di Francesca che hai tagliato dal mio post cerca
"servizio" e troverai buona parte della risposta.


 com'è i risultati fanno schifo.
    Tabella: x_Francesca
        Campi
            Insegnante: Testo
            DataInizio: Data/ora
            DataFine:   Data/ora
            Servizio:   Testo
Dati di test:
Insegnante  DataInizio  DataFine    Servizio
Paperino    01/05/2002  01/08/2002  A
Paperino    01/01/2002  01/03/2002  A
Pippo       01/01/2001  01/05/2001  A
Pippo       01/01/2002  01/09/2002  B
Pippo       01/01/2002  01/05/2002  A
Pippo       01/02/2002  01/03/2002  B
Pippo       01/03/2001  01/08/2001  C
Pluto       01/01/2002  01/08/2002  A
Pluto       01/01/2001  01/05/2001  B
Pluto       01/04/2002  01/05/2002  B
OUTPUT (DataInizio?=1/1/2002, DataFine?=31/12/2002)
Insegnante  Servizio  DataInizio  DataFine    Giorni
Paperino    A         01/01/2002  01/03/2002      59
Paperino    A         01/05/2002  01/08/2002      92
Pippo       A         01/01/2002  01/05/2002     120
Pippo       B         01/01/2002  01/09/2002       0
Pippo       B         01/02/2002  01/03/2002      28
Pluto       A         01/01/2002  01/08/2002     212
Pluto       B         01/04/2002  01/05/2002      30


"servizio" e troverai buona parte della risposta.
Me lo sono riletto e ancora non capisco, così ti dico dove sono
arrivato io : Francesca vuole sapere quali sono i giorni totali (
potremo dire meglio i giorni consecutivi , dato che se ha lavorato
nello steso lasso di tempo in un'altra scuola tali giorni non vengono
conteggiati ) di "servizio" degli insegnanti.
Per Farancesca se non ho capito male "servizio" è il periodo in giorni
in cui un insegnante lavora, ma per te che cosa è ? i giorni, un ' ID,
una cavallina storna ? perchè dai sempre per scontato che ti si deve
capire tutto, se no sono scemo io ? .... cavolo sei quasi riuscito a
farmi arrabiare ... complimenti.
Ciao. Fabrizio

 Ciao. Fabrizio
--


 a.cara




OK non andare a guardare il mio post delle 18
A vederlo cosě c'č qlc che non mi quaglia, mi prendo un 'oretta per
guardarmi i tuoi risultati e provarlo ( facciamo anche qlc di piů va
che ho da legere ancora un paio di post)
Ciao. Fabrizio

facile.
L'ho gia letto e lo stavo usando per studiarmi il codice quando poi è
intervenuto Maurì e ho testato il suo codice: chiaramente non poteva
andarmi bene al primo colpo.
Ad occhio e croce avrò un po' di robetta da riguardarmi per capirlo
bene, cmq BRAVO.
Ciao. Fabrizio


    Per me "Servizio" non vuol dire niente. Nemmeno "Insegnante". Ci
potresti scrivere "Campo1" e "Campo2" che a me andrebbe bene egualmente. Io
ragiono in termini di A + B = C. Se poi A, B e C sono ore, pere o navette
spaziali... chemmefrega?
    Giusto per farti un favore pero' provo a risponderti, senno' poi mi stai
male. "Servizio" immagino che sia il "servizio prestato" da un "insegnante"
presso una certa scuola. Tipo che l'insegnante Tizio ha insegnato dal ... al
... presso la scuola XY e dal ... al ... presso la scuola YZ.
    Ecco... adesso mi accorgo che la mia query e' da correggere. Non
importa, speriamo che ci sia un volontario, per questo. ;-)


InizioServizio e FineServizio: data/ora
Io sono ancora in alto mare, mi sto incasinando a più nn posso, ma nn
dispero. Prima o poi capirò come fare! Con calma...
Cmq grazie a tutti per tutto. Farò tesoro dei vs consigli, anche se mi pare
di aver scatenato un bella discussione...
Ciao. Franci


.
Ciao. Fabrizio

 facile.
ciao roberto 
c'e' rimasto, credo, un'unico problema 
legato all'utilizzo del periodo di osservazione
che dovrebbero essere 2 parametri esterni
e dove il problema potrebbe sorgere se le date
di "Servizio" sono a cavallo del limite inferiore
o superiore del periodo di osservazione. 
Sono comunque interessato poiche' il discorso
e' naturalmente applicabile ad attivita' concorrenti
di qualsiasi tipologia.
L'ho gia' avuto e, ovviamente,per me, l'ho risolto
via codice
--
a.cara

 Ciao. Franci


importa, speriamo che ci sia un volontario, per questo. ;-)
Speriamo proprio che qlcn si faccia avanti, oh da quando ti sei
impigrito .... 
Cmq le mie coronarie non ringraziano piů.
Ciao. Fabrizio

 a.cara
--


 Che ne pensi di questa soluzione???
Le tue soluzioni le trovo sempre "ottime".
A me e' piu' facile scrivere codice. Vedo che riesci a risolvere
problemi anche complessi con delle query "tuttofare"
L'unica cosa e' che alcune volte e' difficile trasportarle su 
altri DBMS. 
Ad esempio questa. In ORACLE la iif non esiste e' parzialmente
sostituibile con la DECODE. ed ovviamente non esiste la 
DLOOKUP anche se e' sostituibile con una select innestata.
(S.E. & O.)
Se abbiamo capito bene credo che questa sia la soluzione
ottimale per francesca.
Purtuttavia continuero' a scrivere codice, alcune volte
lo trovo piu' "user friendly" ;<))))))))))))))
Sullo stesso DB di test o anche provato la proprieta'
DefaultValue (una di quelle cose da me mai usate),
va che e' una spada, semplice e chiaro,
mentre qui a dato luogo ad una telenovela. 
C'e' solo quel problema relativo alle date ma anche in
questo caso c'e' una stranezza che devo verificare....
ciao
--
a.cara

 importa, speriamo che ci sia un volontario, per questo. ;-)
    Bene. Il volontario non s'e' visto. :-(
    "Ritiro" la query precedente perche' e' proprio una gran fregnaccia. Il
concetto e' buono (l'uso di una sottoquery) ma la mia realizzazione e' stata
decisamente pessima.
    Probabilmente lavorandoci un po' su se ne puo' tirare fuori qualcosa di
buono ma ora come ora non ho ne' tempo ne' voglia.
    Mi ha intrigato di piu' l'idea di un'altra soluzione, sempre mediante
una query. E dico una query non perche' sia meglio o peggio del codice ma
cosi', perche' in questo periodo sto studiando questo tipo di soluzioni.
    In fondo il risultato che si vuole ottenere e' il numero dei giorni di
servizio di ciascun insegnate, giusto? Come potrei fare "a mano libera"?
Prenderei un bel calendario nuovo da una parte, dall'altra le schede dei
singoli servizi di un insegnante:
        Insegnante A
        Dal ... Al ...
        Scuola A
        ----------
        Insegnante A
        Dal ... Al ...
        Scuola B
        ----------
        .
        .
        ----------
e con santa pazienza, scheda per scheda, farei una crocetta sul calendario
per ogni giorno di servizio della scheda. Quando passo alla scheda
successiva se nel calendario c'e' gia' la crocetta ovviamente salto il
giorno. Arrivato alla fine, mese per mese, conto i giorni e segno il totale
a fine mese.
    Poi, nuovo calendario, nuovo pacchetto di schede dei servizio
dell'insegnante successivo.
    Ok?
    Quindi ci manca un calendario...
    Per costruirlo non ci vuole molto. Una tabella di nome "tblCalendario"
con un solo campo "Data", di tipo Data/ora, indicizzato come Primario e
Univoco.
    Poi siccome scriverlo a mano e' scomodo :-) con qualche riga di codice
aggiungo tutte le date dell'intervallo che mi interessa, magari abbondando
cosi' e' gia' pronto per gli anni a venire. (Vedi codice piu' sotto)
    A questo punto dovremmo avere tutto, credo. Quindi:
        Query: x_Francesca Giorni di servizio
        PARAMETERS
            [DataIniziale?] DateTime
          , [DataFinale?] DateTime
        ;
        SELECT DISTINCT
            x_Francesca.Insegnante
          , tblCalendario.Data
          , -
            (
               [tblCalendario].[Data]
               Between
               [x_Francesca].[DataInizio] And [x_Francesca].[DataFine]
            )
            AS HaPrestatoServizio
        FROM
            tblCalendario
          , x_Francesca
        WHERE
          (
            tblCalendario.Data
            Between
            [DataIniziale?] And [DataFinale?]
          )
          AND
          (
            -
            (
              [tblCalendario].[Data]
              Between
              [x_Francesca].[DataInizio] And [x_Francesca].[DataFine]
            )
            =
            1
          )
        ORDER BY
            x_Francesca.Insegnante
          , tblCalendario.Data
        ;
        Query: x_Francesca Somma Giorni di servizio per mese
        SELECT
            [x_Francesca Giorni di servizio].Insegnante
          , DateSerial
            (
              Year([x_Francesca Giorni di servizio].[Data])
            , Month([x_Francesca Giorni di servizio].[Data])
            , 1
            )
            AS DataMese
          , Format([DataMese],"mmm yyyy")
            AS Mese
          , Sum
            (
              [x_Francesca Giorni di servizio].HaPrestatoServizio
            )
            AS GiorniDiServizio
        FROM
            [x_Francesca Giorni di servizio]
        GROUP BY
            [x_Francesca Giorni di servizio].Insegnante
          , DateSerial
            (
              Year([x_Francesca Giorni di servizio].[Data])
            , Month([x_Francesca Giorni di servizio].[Data])
            , 1
            )
        ORDER BY
            [x_Francesca Giorni di servizio].Insegnante
          , DateSerial
            (
              Year([x_Francesca Giorni di servizio].[Data])
            , Month([x_Francesca Giorni di servizio].[Data])
            , 1
            )
        ;
Dati di test:
Insegnante  DataInizio  DataFine    Servizio
Paperino    01/05/2002  01/08/2002  A
Paperino    01/01/2002  01/03/2002  A
Pippo       01/01/2001  01/05/2001  A
Pippo       01/01/2002  01/09/2002  B
Pippo       01/01/2002  01/05/2002  A
Pippo       01/02/2002  01/03/2002  B
Pippo       01/03/2001  01/08/2001  C
Pluto       01/01/2002  01/08/2002  A
Pluto       01/01/2001  01/05/2001  B
Pluto       01/04/2002  01/05/2002  B
OUTPUT (DataInizio?=1/1/2002, DataFine?=31/12/2002)
Insegnante  DataMese    Mese      GiorniDiServizio
Paperino    01/01/2002  gen 2002                31
Paperino    01/02/2002  feb 2002                28
Paperino    01/03/2002  mar 2002                 1
Paperino    01/05/2002  mag 2002                31
Paperino    01/06/2002  giu 2002                30
Paperino    01/07/2002  lug 2002                31
Paperino    01/08/2002  ago 2002                 1
Pippo       01/01/2002  gen 2002                31
Pippo       01/02/2002  feb 2002                28
Pippo       01/03/2002  mar 2002                31
Pippo       01/04/2002  apr 2002                30
Pippo       01/05/2002  mag 2002                31
Pippo       01/06/2002  giu 2002                30
Pippo       01/07/2002  lug 2002                31
Pippo       01/08/2002  ago 2002                31
Pippo       01/09/2002  set 2002                 1
Pluto       01/01/2002  gen 2002                31
Pluto       01/02/2002  feb 2002                28
Pluto       01/03/2002  mar 2002                31
Pluto       01/04/2002  apr 2002                30
Pluto       01/05/2002  mag 2002                31
Pluto       01/06/2002  giu 2002                30
Pluto       01/07/2002  lug 2002                31
Pluto       01/08/2002  ago 2002                 1
************************************************************
Public Function GeneraCalendario()
  On Error GoTo erh
  Dim tStart As Date
  Dim tStop  As Date
  Dim tDate  As Date
  Dim rst    As ADODB.Recordset
  tStart = #1/1/1998#
  tStop = #12/31/2005#
  Set rst = New ADODB.Recordset
  With rst
    .Open _
        "tblCalendario" _
      , CurrentProject.Connection _
      , adOpenDynamic _
      , adLockPessimistic
    For tDate = tStart To tStop
      On Error Resume Next
      .AddNew "Data", tDate
      If Err.Number = 0 Then
        .Update
      Else
        .CancelUpdate
      End If
      Err.Clear
    Next
    On Error GoTo erh
  End With
ext:
  On Error Resume Next
  rst.Close
  Set rst = Nothing
  Exit Function
erh:
  With Err
    MsgBox .Description, vbCritical, "ERR#" & .Number
  End With
  Resume ext
End Function
************************************************************
SE&O


....
Alla fine di tutto ti dico che proverò  la tua soluzione, anche se mi
sembra parecchio laboriosa, sicuramente imparerò qlc.
Ciao. Fabrizio

 > "Maurizio Borrelli" [...]:
[cut]
kaiser fai? stai a riscrive windows o l'acqua delle sorgenti del Po ti ha
dato alla testa?
--
a.cara

 o l'acqua delle sorgenti del Po ti ha dato alla testa?
    Prego?...


 a.cara
Ciao


>cut

Provato ... molto carino e molto istruttivo ( a parte i soliti
problemi col copia incolla ( ma almeno ti costringe a guardati il
codice molto meglio )), hai messo tante cose e infatti mi sono salvato
( e incorniciato )  il DB di esempio derivante dal tuo suggerimento, a
dire il vero non l'ho ancora testato bene , se vuoi un giorno ti dirň
le mie impressioni a freddo ( chemmefrega dirai tu, ma io te lo dirň
lo stesso cosě impari )
Ciao. Fabrizio

Non ho presente il problema.
Spero che adesso lo spieghi ... ops vi sto seguendo ancora , ma sto'
DefaultValue mi interessa, visto che mi è capitato di incontrarlo
recentemente: spiegaci Ale ( per me sto' NG sta diventando un manuale
)
Ciao. Fabrizio

 lo stesso cosě impari )
    Anzi. Mi interessa molto la tua opinione. (E non solo la tua...).
    Considera anche che e' stato proprio un tuo post a farmi cambiare la mia
idea originaria: quello dove parlavi di giorni festivi & C.
    Stavo per risponderti con tracotanza "che cacchio c'entra?!" poi mi son
detto: e' vero, non c'entra, ma l'impostazione che sto per dare alla query
e' limitativa. Infatti se per esempio, una volta ottenuto il risultato, a
Francesca salta il ghiribizzo di dire: ok, questi sono i giorni di servizio,
ma il capo *per sua curiosita'* (i capi hanno sempre di queste curiosita')
vuole sapere di questi giorni di servizio quanti sono stati di effettiva
presenza in sede, cioe' al netto di feste, giorni di riposo, assenze varie,
scioperi..., ecco che con questo impianto tale risultato lo si puo' ottenere
in modo abbastanza semplice.


in modo abbastanza semplice.
Pensa che stavo proprio studiando la possibilità dei giorni festivi :
adesso ho una bella tabella da cui eliminare 
-le domeniche  che inserirei da codice o attraverso query ( di
eliminazione )  
-i festivi che inserirei a manella in una tabella ( ogni azienda c'ha
i suoi festivi ) --> query di selezione ( solo i giorni che non
compaiono nella tabella festivi ) e il gioco dovrebbe essere fatto.
Sparo perchè sto ancora provando, intanto provo.
Ciao. Fabrizio

 Sparo perchè sto ancora provando, intanto provo.
    Ok. Io ho gia' abbozzato il discorso ma ho dovuto sospendere. Poi
vediamo.


vediamo.
Ci risentiamo allora ( tra lavoro, studio e compitini tuoi )
Ciao. Fabrizio

Ciao. Fabrizio
-([tblCalendario].[Data] Between [x_Francesca].[DataInizio] And
[x_Francesca].[DataFine]) AS HaPrestatoServizio
Stavo guardando solo adesso il codice da te postato ( volevo usarlo
per le festività ) e questa riga non la capivo a fondo poi ci sono
arrivato: confronta le date tra la tabella calendario e quella
insegnanti , quando le date coincidono da vero (-1, anzi 1 col meno
davanti ) e quando non coincidono da falso (0) , per cui il campo
'HaPrestatoServizio'  è un campo booleano: sottile, mi piace, non
avevo mai usato una cosa così.
So che così ammetto la mia ignoranza , ma non me ne frega nulla (
tanto non era un segreto ), anzi se hai da aggiungere ti prego fallo.
Ciao. Fabrizio

 So che così ammetto la mia ignoranza ,
    Piantala. Tanto non te lo dico che sei bravo.


    Piantala. Tanto non te lo dico che sei bravo.
Mai un complimento sigh .. da quando siamo sposati non mi guardi più ,
non mi cerchi più ... aveva ragione mia madre avrei dovuto sposare
Berlusconi al posto tuo  :-))))  , strunziello che non sei altro :-)))
(sempre ridendo ).
Ciao. Fabrizio


Ciao. Francesca

cut
Ammetto che è una domanda idiota, quando l'ho fatta non mi ricordavo
che poi si doveva sommare i giorni .
Cmq per sfizio ho provato con count al posto di sum nella seconda
query e tutto torna a posto , poi ho provato a sommare il campo
booleano : ho un numero negativo, ma basta un meno al posto giusto  (
nella seconda query ) e tutto torna in regola
Dall'help in linea:
"Le variabili di tipo Boolean sono memorizzate come numeri a 16 bit (2
byte) e possono essere solo True o False. Le variabili di tipo Boolean
sono visualizzate come Vero o Falso quando si utilizza Print, oppure
#TRUE# o #FALSE# quando si utilizza Write #. Utilizzare le parole
chiave True e False per assegnare alle variabili di tipo Boolean uno
dei due stati.
Quando si convertono in Boolean dati numerici, 0 diventa False e tutti
gli altri valori diventano True. Quando i valori di tipo Boolean
vengono convertiti in altri tipi di dati, False diventa 0 e True
diventa -1."
Domanda : ma se noi abbiamo già 0 e -1 non abbiamo già degli interi ?
Il campo "HaPrestatoServizio" non da già come risultato un numero
intero ( 0 e -1 ) pur essendo esso stesso un campo Booleano?
Datemi una mano e mi prenderò il braccio.
Ciao. Fabrizio

 recentemente: spiegaci Ale ( per me sto' NG sta diventando un manuale
Ti faccio il riassunto di una telenovela, visto che non hai voluto
leggerla
1) D. Maniero aveva il problema di ripetere i dati dal 
   record precedente
2) Ne e' nato un casino
3) Fra le varie indicazioni (credo di Ganci) c'era l'uso
   del defaultvalue
4) Io non avendolo mai usato non ne sapevo nulla e l'ho 
   anche "snobbato"
5) D. Maniero ha intrapreso la strada suggerita da me
   che prevedeva un po' di codice sparso in giro
6) Quando la cosa ha interessato anche te, hai usato la
   soluzione defaultvalue con quel problema di dover
   racchiudere la data fra apici altrimenti la visualizzazione
   che si ottiene non e' corretta
7) Dopo questa situazione mi sono andato a vedere la DefaultValue
   e l'ho provata e funziona ed ho visto che la visualizzazione
   della data e' funzione anche del tipo di formato
   (a me dava una cosa tipo 0.00.47 evidentemente la parte 
    di orario)
8) pero' avendo osservato una cosa ho modificato le routine di 
   uso della defaultvalue per ottenere una "feature" aggiuntiva
   per la gioia del Borrelli ecco il codice
   Private Sub Form_AfterUpdate()
   	Me.idinsegnante.DefaultValue = Me.idinsegnante
    	Me.anno.DefaultValue = Me.anno
    	Me.inizio.DefaultValue = "'" & Me.inizio & "'"
    	Me.fine.DefaultValue = "'" & Me.fine & "'"
   End Sub
   Private Sub Form_current()
	If Not Me.NewRecord Then
	    Call Form_AfterUpdate
	End If
   End Sub 
 
   Qual'e' la feature aggiuntiva. E' che, in questo caso, se
mi posiziono su qualsiasi record viene fatto il prelievo dei
valori del record su cui mi sono posizionato. Nel caso in cui
si elimina la form current, ovviamente, avviene lo stesso solo
se modifico il record su cui mi sono posizionato.
La cosa mi puo' fare comodo.
sentiti saluti
--
a.cara

sentiti saluti
Anche a te.
Ciao. Fabrizio

cut
Vado avanti ad aggiornarvi su come sto andando avanti con l'esempio di
Borrelli:
-ho creato una tabella (Festivi):
ID (contatore, PK); DataInizio (Data/ora); DataFine (Data/Ora).
-Ho popolato la tabella con un paio di record ( tanto per avere qlc ).
-Ho costruito una query di selezione sulla falsariga della prima query
di Maurì:
Query:'PerFestivi'
SELECT DISTINCT 
   Festivi.ID, 
   tblCalendario.Data, 
   -(tblCalendario.Data BETWEEN Festivi.DataInizio AND
Festivi.DataFine) AS GiorniFestivi
FROM 
   Festivi, 
   tblCalendario
WHERE 
   -(tblCalendario.Data BETWEEN Festivi.DataInizio AND
Festivi.DataFine)=1;
-Ho giocato su questa query un po' ( principalmente l'ho incrociata
con la tabella tblCalendario:
Query: 'CalendarioSenzaFestivi'
PARAMETERS 
   [Data iniziale?] DateTime, 
   [Data finale?] DateTime;
SELECT 
   tblCalendario.Data
FROM 
         PerFestivi 
     RIGHT JOIN 
         tblCalendario 
     ON 
         PerFestivi.Data = tblCalendario.Data
WHERE 
   (tblCalendario.Data Between [Data iniziale?] AND [Data finale?])
AND PerFestivi.Data IS NULL;
)
.......................................................................................................................................................................
Adesso vado ad operare con le domeniche : pensavo a una qlc che prende
le date formattate con solo il giorno ( tipo: 
Format ([tblCalendario.Data] , 'ddd')
) e poi escludo 'Dom' ...mhm .... forse conviene anche che prima metta
Cstr davanti a Format ... numble ... devo provare.
Ah ... siccome ho un codice che mi genera il calendario pensavo anche
di escludere le domeniche da li ... poi già che siamo sempre da quel
codice volevo decidere quale tabella costruire ( una per ogni anno
dopo esplicita richiesta, quindi una tabella per anno ) ... c'è un
sacco di carne sul fuoco speriamo di riuscire a finire e che il capo
mi lasci stare.
p.s. decisamente per il momento ho lasciato perdere la soluzione di
Roberto, ma è solo perchè ancora non ho capito bene il suo codice.
Ciao. Fabrizio

cut
Continuo per il momento solo con le query:
- Eliminare le Domeniche dal calendario:
Query:'CalendarioSenzaDom'
SELECT 
   tblCalendario.Data, 
   CStr(Format([tblCalendario.Data],'ddd')) AS NomeLungo
FROM 
   tblCalendario
WHERE
    CStr(Format([tblCalendario.Data],'ddd')) Not In ('Dom')
ORDER BY 
   tblCalendario.Data;
( ho selezionato anche 'CStr(Format([tblCalendario.Data],'ddd')) AS
NomeLungo' per controllare la query, ma in definitiva non serve, come
non serve Cstr davanti a Format, l'ho tenuto per sfizio ( mi ricorda
la prima domanda che ho rivolto al NG ))
- Eliminare i giorni festivi dalla query dove elimino le domeniche:
Query:'CalendarioScolastico'
SELECT 
    CalendarioSenzaDom.Data 
FROM 
           CalendarioSenzaDom  
       LEFT JOIN 
           PerFestivi 
       ON 
           CalendarioSenzaDom.Data = PerFestivi.Data
WHERE  
    (CalendarioSenzaDom.Data BETWEEN [DataIniziale] AND [DataFinale])
AND PerFestivi.Data Is Null;
Non ho messo i parametri questa volta con sommo dispiacere di Maurì.
Semplificando molto. 
Così ho il calendario ( dal '98 al '05, ricordate il codice che
generava i record in tblCalendario)su cui fare i calcoli dei giorni
lavorativi degli insegnanti: c'è ancora da lavorarci parecchio ( mi è
gia venuto in mente un paio di cose da farci su, sempre con le query,
ma ho pietà di voi e ve lo dirò solamente se approdo a qlc ), tra
l'altro questo post dovrebbe rispondere, in parte, a un vecchio post (
di quasi due mesi fa ) in cui si domandava come gestire gli
abbonamenti in una palestra: non è un DB però è un inizio.
Adesso mi piacerebbe fare qlc attraverso codice ( tipo eliminare le
domeniche, scegliere gli anni .... ), ma qui entriamo in terreno
minato per me, per cui con vostro sommo piacere prima che rimetta
piede in questo 3d passerà parecchia acqua sotto i ponti.
A meno che non intervenga Maurì: a lui non so resistere.
Ciao. Fabrizio

 la prima domanda che ho rivolto al NG ))
[...]
    Meglio non toglierseli questi sfizi. Scriverei piuttosto:
        Format([tblCalendario].[Data],'ddd')="dom"
ma questo metodo e' "localizzato". Cioe' funziona solo per la lingua
italiana. Meglio usare la funzione WeekDay:
        WeekDay([tblCalendario].[Data])=1


        
Sempre restando nell'ambito della lingua italiana ( non c'avevo
pensato, si vede che non sono uno sviluppatore di software ), ho usato
Format nella SELECT e WeekDay in WHERE , cosě: mi sembrava carino.
Cmq ho capito il problema, č un aspetto che cercherň, nel mio piccolo,
di non trascurare.
Grazie ancora ti farň sapere come va con VBA ( fra qlc eone si
intende).
Ciao. Fabrizio

cut
perchč preferisci '=' a 'IN'
, c'č qlc motivo particolare ?
Cosě ha piů senso la domanda, scusa
Ciao. Fabrizio

 , c'è qlc motivo particolare ?
    La forma con "In" puoi usarla solo nello script di una query. Capita
invece che una formula, anche non complessa, prima di scriverla in sql la
testi con Visual Basic e una volta che ritieni sia funzionante la incolli in
sql...


sql...
 
Grazie.
Ciao. Fabrizio


Ale, ma stai dicendo che tutta la pappardella che ho fatto io
può essere modificata o meglio sostitita con:
    Private Sub Form_current()
   If Not Me.NewRecord Then
       Call Form_AfterUpdate
  End If
    End Sub
Ho capito bene? Sai mi eviterebbe di ripetere
tante volte il codice per ogni controllo!
--
Debora

 tante volte il codice per ogni controllo!
yes e' chiaro se sa!
(pero' attenzione il blocco di codice che viene chiamato (call)
deve essere "buono" per tutti i controlli in cui lo chiami,
questo talvolta richiede una certa "generalizzazione", che,
normalmente, si ottiene con l'uso di parametri, cfr. la 
routine controlChk sull'altro 3d)
Guardati il concetto di Funzione (o sub)  e Richiamo di funzione
(prima o poi passeremo alle classi)
--
a.cara

 ha scritto nel messaggio
news:3D8ACA6C...@blunet.it...

Forse è meglio  che lo testi  (IO) con
una applicazione prova.
--
Debora

 Sě, la vs soluzione (tua e di Alessandro) sembra andare.
Sěěěě! Molto bene! Grazie!
La soluzione di Maurizio nn l'ho capita tanto... Ma per limiti miei (tempo,
ignoranza,...) Cmq mi sembra interessante il concetto, e mi riprometto di
studiarmela meglio.
Cmq, (Maurizio nn volermene) per un insegnante con incarico annuale sono
considerati 360 gg lavorativi, dal 01/09 al 31/08. Quindi con festivi,
riposi ecc.
Cmq č interessantissimo il problema che ti sei posto...   :-))) e puň sempre
tornare utile...
Uff! Vorrei dedicare + tempo ad Access... Purtroppo per ora rimane solo un
bel passatempo.
Thanks. Francesca

 bel passatempo.
    Meglio delle parole crociate, no?
    Mi permetto pero' una piccola considerazione generale, cioe' non
riguardante te in particolare.
    Quando si fanno le parole crociate si puo' operare almeno in due modi:
         a) si leggono le definizioni e si compilano le caselle con le
parole che si ritengono corrette e, con gli incroci, si cerca di individuare
le parole che non si conoscono;
         b) non si leggono le definizioni e si riempiono le caselle con
lettere a caso.
    Sia il metodo a) che il metodo b) ci fanno "passare" il tempo, ma solo
il metodo a) puo' essere definito "fare le parole crociate".


 > Sě, la vs soluzione (tua e di Alessandro) sembra andare.
non darmi meriti che non ho.
Fabrizio ed  io abbiamo fatto il "beta" test
--
a.cara

 Maurizio
Ciao. Franci


wrote:


Parlava di te e Roberto .... bestiun.  :-)
Ciao. Fabrizio

 Parlava di te e Roberto .... bestiun.  :-)
Ma no? Sicuro? Non di filologia romanza? 
--
a.cara

Ma no? Sicuro? Non di filologia romanza? 
Siccome ogni tanto mia moglie legge quello che posto ho preferito
tirarmene fuori , spiego: non capendo lei concetti tipo "beta Tester"
e siccome fa fatica a credere che IO non sia su una chat porno .....
:-)))))  ....  insomma ho anche due figli e non vorrei rischiare un
divorzio per questioni simili( " Che cosa ha i testato alla fanciulla?
la sua beta ? PORCO")    :-))))
Ciao. Fabrizio

 forse un po' tardi...  :-)
    :-))
    Considera che, in un normale rapporto di lavoro, in un caso come questo,
non servirebbe "scusarsi" in quanto sarebbe sufficiente pagare, alle usuali
condizioni, una fattura in piu', probabilmente salata.
