Newsgroup: it.comp.appl.access
Titolo: [QRY] Ottenere vista tipo agenda

Ho una tabella del tipo:
*tblAppt*
ID  DataAppt    OraAppt  Durata  Note
1   08/05/2001   9.00     0.30   pippo
2   08/05/2001  10.00     1.00   paperino
3   08/05/2001  11.00     0.45   minnie
devo riuscire ad ottenere una vista, per un determinato giorno, del
tipo:
 8.00
 9.00  pippo
 9.30
10.00  paperino
11.00  minnie
11.45
12.00
13.00
14.00
...
Al momento uso una tabella che contiene i possibili slot con intervallo
di 5 min.
8.05
8.10
8.15
8.20
...
e dopo una serie estenuante di query, che si incrociano tra di loro,
ottengo quello che voglio.
naturalmente Durata puo' essere sostituito con OraFine, che al momento
viene calcolato
Spererei di trovare una soluzione piu' semplice. Avete qualche idea?
-- 
Federico
----------------------------------
Rimuovi paperino. per e-mail
----------------------------------
Tutte le richieste che arrivano
in privato, vengono cestinate.
----------------------------------
Sito Comune di it.comp.appl.access
http://www.sitocomune.com
mailto:
webm...@sitocomune.com
----------------------------------

 ottengo quello che voglio.
La tabella con gli intervalli mi sembra l'unica soluzione.
Piuttosto, le query bisogna vedere se possono essere snellite..ma
bisognerebbe sapere come le hai fatte!:-)
Saluti.
Luciano
(DOC)

 wrote in message
3AF7BA29...@paperino.sitocomune.com...

Ciao Federico,
farlo solo con SQL puro e con una sola query la vedo dura.
Ti riporto un esempio estratto da una delle tante applicazioni da me
scritte, in cui ho risolto un problema analogo al tuo.
Io ho due tabelle di comodo e 4 query, lineari.
Nel mio esempio l'epsilon (lo step) è il giorno.
Tuno(uno) (un solo campo, che va da 0 a 30) (mesi commerciali di 30 giorni)
Tempo (Giorno), un solo campo con le date dal primo all'ultimo dell'anno.
Tabella1(Da, Ad, Testo), due date ed un testo .
La circostanza è analoga alla tua.
Tabella1
01/01/2001, 10/01/2001, Pippo
15/01/2001, 25/01/2001, Pluto
Io voglio
Giorno    Testo
01/01/00 pippo
02/01/00    "
03/01/00    "
04/01/00    "
05/01/00    "
06/01/00    "
07/01/00    "
08/01/00    "
09/01/00    "
10/01/00    "
11/01/00
12/01/00
13/01/00
14/01/00
15/01/00 pluto
16/01/00    "
17/01/00    "
18/01/00    "
19/01/00    "
20/01/00    "
21/01/00    "
22/01/00    "
23/01/00    "
24/01/00    "
25/01/00    "
25/01/00
26/01/00
27/01/00
28/01/00
29/01/00
30/01/00
Query1: (verticalizzo l'intervallo)
SELECT DateAdd("d",[uno],[da]) AS Giorno, IIf([Giorno]=[Da],[testo],"""") AS
TestoCalcolato
FROM Tabella1, Tuno
WHERE (((DateAdd("d",[uno],[da]))<=[Ad]))
(nota l'assenza della join condition)
Query2: (definisco l'insieme delle date mancanti)
SELECT Tempo.Giorno, "" AS Espr1
FROM Tempo
WHERE (((Tempo.Giorno) Not In (select Giorno From Query1)));
Query3: (unisco i due precedente insiemi)
SELECT * FROM Query1
UNION ALL
SELECT * FROM Query2;
Query4: (ordino per data)
SELECT Query3.Giorno, Query3.TestoCalcolato
FROM Query3
ORDER BY Query3.Giorno;
Tieni presente che volendo potrebbe essere fatto con due sole query
(esplodendo le Query1 e 2 nella Query3:
Query123:
SELECT DateAdd("d",[uno],[da]) AS Giorno, IIf([Giorno]=[Da],[testo],"""") AS
TestoCalcolato
FROM Tabella1, Tuno
WHERE (((DateAdd("d",[uno],[da]))<=[Ad]));
UNION ALL
SELECT Tempo.Giorno, "" AS Espr1
FROM Tempo
WHERE Tempo.Giorno Not In
   SELECT DateAdd("d",[uno],[da])
   FROM Tabella1, Tuno
   WHERE (((DateAdd("d",[uno],[da]))<=[Ad]))
  );
Query4Bis:
SELECT *
FROM Query123
ORDER BY Query123.Giorno;
HTH
Michele Amato
p.s.
Credo che nel tuo caso la tabella Tempo non serva...
--
{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}
Sulla mia pagina personale
http://utenti.worldonline.it/micheleamato
è possibile trovare del materiale relativo ad Access
scritto da me, sia freeware che shareware
{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}

 [cut]
quello che mi hai inviato, naturalmente funziona, ma non arriva a quello
che mi serve ;-)
nel senso che io non devo visualizzare una intera giornata, ti faccio un
esempio:
situazione iniziale:
 8.00
 9.00
10.00
11.00
12.00
13.00
...
aggiungo tre record:
 pippo     9.00-> 9.30
 paperino 10.00->11.00
 minnie   11.00->11.45
la vista cambia in questo modo:
 8.00
 9.00  pippo
 9.30
10.00  paperino
11.00  minnie
11.45
12.00
13.00
grazie lo stesso
PS
guardati queste due query ;-))
utilizzo solo due delle tue tabelle:
- Tempo (Giorno), un solo campo con le date dal primo all'ultimo
dell'anno.
- Tabella1(Da, Ad, Testo), due date ed un testo .
Query1:
SELECT Tempo.Giorno, Tabella1.Da, Tabella1.Testo
FROM Tabella1, Tempo
WHERE (((Tempo.Giorno)>=[Da] And (Tempo.Giorno)<[Ad]));
Query2:
SELECT Tempo.Giorno,
IIf([Tempo].[Giorno]=[Da],[Testo],IIf([Query1].[Giorno] Is Not
Null,"...")) AS TestoCalcolato
FROM Tempo LEFT JOIN Query1 ON Tempo.Giorno = Query1.Giorno
ORDER BY Tempo.Giorno;
aprendo la seconda dovresti ottenere lo stesso risultato della tua
query4, ma credo sia molto piu' veloce ;-)
fammi sapere


 fammi sapere
Non ci penso neanche, no a parte gli scherzi, non ho il tempo per farlo.
Senti ma
situazione iniziale:
 8.00
 9.00
10.00
11.00
12.00
13.00
...
cos'è, una tabella?
Se ti va, fammelo sapere.
Un saluto
Michele Amato

 ha scritto nel
messaggio news:3AF7BA29...@paperino.sitocomune.com...

Una soluzione lineare con le query non sono riuscito a trovarla; penso però
di esserci riuscito registrandro gli appuntamenti di una giornata in una
tabella temporanea (tblTemp) che poi uso come origine riga di una casella di
riepilogo non associata (Elenco2) inserita nella maschera non associata
(Maschera1) che contiene anche la casella di testo non associata (Data1) in
cui digito la data di cui voglio vedere gli appuntamenti e la disponibilità
di orari.
In tblAppt ho preferito usare OraFine anziché Durata (visto che per te
andava bene).
Presupposti.
--------------
tblAppt
--------
ID                Contatore e chiave primaria
DataAppt     Data/ora
OraAppt      Data/ora
OraFine       Data/ora
Note            Testo o Memo
tblTemp
--------
Ora1            Data/ora e chiave primaria
Note1          Testo o Memo
Per prima cosa mi sono creato una query (Query1) con la quale seleziono gli
appuntamenti della giornata scelta in Maschera1; Query 1 ha il seguente
codice SQL:
SELECT tblAppt.DataAppt, tblAppt.OraAppt, tblAppt.OraFine, tblAppt.Note
FROM tblAppt
WHERE (((tblAppt.DataAppt)=[Forms]![Maschera1]![Data1]))
ORDER BY tblAppt.DataAppt, tblAppt.OraAppt;
Per il modo in cui ho creato Maschera1 vale quanto detto sopra.
A fronte dell'evento "Su corrente" di Maschera1 ho generato il seguente
codice VBA:
Private Sub Form_Current()
DoCmd.SetWarnings False
DoCmd.RunSQL "DELETE * FROM tblTemp;"
DoCmd.SetWarnings True
Me!Elenco2.Requery
End Sub
A fronte dell'evento "Dopo aggiornamento" del controllo Data1 (contenuto in
Maschera1) ho generato il seguente codice VBA:
Private Sub Data1_AfterUpdate()
DoCmd.SetWarnings False
DoCmd.RunSQL "DELETE * FROM tblTemp;"
DoCmd.SetWarnings True
Me!Elenco2.Requery
Dim dbMio As Database
Dim rstMio As Recordset
Dim qdfMio As QueryDef
Dim rstTemp As Recordset
Dim Pippo As Date
Dim Pippo1 As Date
Dim Pippo2 As Date
Dim Pippo3 As Date
Dim DepOraFine As Date
Pippo1 = Int(#8:00:00 AM# * 24) / 24
Pippo3 = Int(#8:00:00 AM# * 24) / 24
Set dbMio = CurrentDb
Set rstTemp = dbMio.OpenRecordset("tblTemp")
Set qdfMio = dbMio.QueryDefs("Query1")
qdfMio.Parameters("[Forms]![Maschera1]![Data1]") = Me![Data1]
Set rstMio = qdfMio.OpenRecordset()
rstMio.MoveFirst
DepOraFine = rstMio!OraFine
Do Until rstMio.EOF
    If Int(rstMio!OraAppt * 24) < Int(Pippo1 * 24) Then
        Pippo1 = Int(rstMio!OraAppt * 24) / 24
    End If
    For Pippo = Pippo1 To rstMio!OraAppt Step #1:00:00 AM#
    If Pippo <> #7:00:00 AM# Then
        If IsNull(DLookup("[Ora1]", "tblTemp", "Int(Ora1*60)=" & Int(Pippo *
60))) Then
            rstTemp.AddNew
            rstTemp!Ora1 = Pippo
            rstTemp.Update
        End If
    End If
    Next Pippo
    rstTemp.AddNew
    rstTemp!Ora1 = rstMio!OraAppt
    rstTemp!Note1 = rstMio!Note
    rstTemp.Update
    If Int(rstMio!OraFine * 60) <> Int((Pippo + #1:00:00 AM#) * 60) Then
    rstTemp.AddNew
    rstTemp!Ora1 = rstMio!OraFine
    rstTemp.Update
    End If
DepOraFine = rstMio!OraFine
rstMio.MoveNext
Loop
For Pippo2 = Pippo3 To #8:00:00 PM# Step #1:00:00 AM#
    If IsNull(DLookup("[Ora1]", "tblTemp", "Int(Ora1*60)=" & Int(Pippo2 *
60))) Then
        If Pippo2 >= DepOraFine Then
            rstTemp.AddNew
            rstTemp!Ora1 = Pippo2
            rstTemp.Update
        End If
    End If
Next Pippo2
Me!Elenco2.Requery
rstTemp.Close
Set rstTemp = Nothing
rstMio.Close
Set rstMio = Nothing
End Sub
Come vedi é possibile, in maniera estemporanea, gestire anche appuntamenti
prima delle 8:00 (che levataccia! :-)) ).
Ho previsto di poter prendere appuntamenti sino alle ore 20:00. Troppo
tardi? :-))
Con la casistica che mi sono costruito (compresa la tua) a me funziona.
Spero che non ci siano buchi.
Ciao
Roberto


Aho non te ne scappa uno :-))
Michele Amato


Di buchi ne ho trovati un paio io dovuti agli inopportuni arrotondamenti che
si hanno con i decimali dei campi/variabili Data/ora.
Spero di averli risolti modificando il codice VBA generato a fronte
dell'evento "Dopo aggiornamento" del controllo Data1 in questa maniera:
Private Sub Data1_AfterUpdate()
DoCmd.SetWarnings False
DoCmd.RunSQL "DELETE * FROM tblTemp;"
DoCmd.SetWarnings True
Me!Elenco2.Requery
Dim dbMio As Database
Dim rstMio As Recordset
Dim qdfMio As QueryDef
Dim rstTemp As Recordset
Dim Pippo As Integer
Dim Pippo1 As Integer
Dim Pippo2 As Integer
Dim DepOraAppt As Integer
Dim DepOraFine As Integer
Dim DepOraFine2 As Integer
Pippo1 = 480
Set dbMio = CurrentDb
Set rstTemp = dbMio.OpenRecordset("tblTemp")
Set qdfMio = dbMio.QueryDefs("Query1")
qdfMio.Parameters("[Forms]![Maschera1]![Data1]") = Me![Data1]
Set rstMio = qdfMio.OpenRecordset()
If Not rstMio.EOF Then
rstMio.MoveFirst
DepOraFine = rstMio!OraFine * 1440
DepOraAppt = rstMio!OraAppt * 1440
End If
Do Until rstMio.EOF
    If DepOraAppt < 480 Then
        Pippo1 = Int(DepOraAppt / 60) * 60
    End If
    For Pippo = Pippo1 To DepOraAppt - 1 Step 60
        If IsNull(DLookup("[Ora1]", "tblTemp", "Int(Ora1*1440)=" & Pippo))
Then
            rstTemp.AddNew
            rstTemp!Ora1 = Pippo / 1440
            rstTemp.Update
        End If
    Next Pippo
    rstTemp.AddNew
    rstTemp!Ora1 = rstMio!OraAppt
    rstTemp!Note1 = rstMio!Note
    rstTemp.Update
    If DepOraFine <> DepOraAppt + 60 Then
    rstTemp.AddNew
    rstTemp!Ora1 = rstMio!OraFine
    rstTemp.Update
    End If
DepOraFine2 = DepOraFine
rstMio.MoveNext
If Not rstMio.EOF Then
DepOraFine = rstMio!OraFine * 1440
DepOraAppt = rstMio!OraAppt * 1440
End If
Loop
For Pippo2 = 480 To 1200 Step 60
    If IsNull(DLookup("[Ora1]", "tblTemp", "Int(Ora1*1440)=" & Pippo2)) Then
        If Pippo2 >= DepOraFine2 Then
            rstTemp.AddNew
            rstTemp!Ora1 = Pippo2 / 1440
            rstTemp.Update
        End If
    End If
Next Pippo2
Me!Elenco2.Requery
rstTemp.Close
Set rstTemp = Nothing
rstMio.Close
Set rstMio = Nothing
End Sub
Fammi sapere cosa te ne sembra.
--
Roberto
---------------------------------------------
il Sito Comune di it.comp.appl.access:
http://www.sitocomune.com
---------------------------------------------

 Aho non te ne scappa uno :-))
E' evidente che si tratta di uno script!:-)
Se vuoi sapere chi e' il tizio e perche' lo fa:
http://www.news.nic.it/news-it/componenti.html
Saluti.
Luciano
(DOC)

 Aho non te ne scappa uno :-))
E' evidente che si tratta di uno script!:-)


 wrote in message

no, e' la vista se non ci sono appuntamenti
a mano a mano che vengono inseriti la vista si trasforma come ti ho
mostrato


 dell'evento "Dopo aggiornamento" del controllo Data1 in questa maniera:
la mia soluzione e' fatta tutta con le query e' funziona, ma speravo di
rendere il tutto piu' lineare, infatti sono quattro query che si
incrociano varie volte, e non mi piace molto.
purtroppo quando si ha una soluzione che funziona difficilmente si
riesce a ripartire da zero senza tener conto delle soluzioni gia'
trovate, e per questo che ho chiesto aiuto e non ho inviato la mia di
soluzione :-)
cmq, non dispero ;-))
provero' la tua soluzione code-based questa sera, anche se non mi piace
molto utilizzare tabelle d'appoggio, ma questo non e' un problema, in
quanto se la soluzione mi piace, mando tutto in una matrice dinamica e
poi riempio una lista.
grazie, non chiedevo tanto ;-))
-- 
Federico
----------------------------------
Rimuovi paperino. per e-mail
----------------------------------
Tutte le richieste che arrivano
in privato, vengono cestinate.
----------------------------------
Sito Comune di it.comp.appl.access
http://www.sitocomune.com
mailto:
webm...@sitocomune.com
----------------------------------

 Federico
Ero riuscito a trovare una soluzione con sole due query: una unione ed una
di raggruppamento.
La casistica che tu avevi dato la risolveva egregiamente: mi sembrava di
aver fatto Bingo.
Poi l'ho tetstata più attentamente e sono venuti fuori due problemi cui non
sono riuscito a dare soluzione:
1) Non gestisce appuntamenti estemporanei prima delle 8:00 (e questo forse è
rimediabile)
2) Non gestisce gli appuntamenti a cavallo di due ore (e questo è grave!)
E' a questo punto che, incavolato come pochi e sostenendo che l'importante è
vincere e non partecipare, ho cambiato strada ed ho partorito la soluzione
che ho postato precedentemente.
Ti posto comunque anche la soluzione dell'incavolatura; magari tu riesci a
metterci una pezza.
Mi sono creato, come avevi presupposto tu, una tabella (Tabella3) che
contiene gli slot con intervallo di 5 minuti; il campo di Tabella3 si chiama
Ora2.
Per tblAppt vale la struttura con OraFine anziché Durata.
Mi sono crato una query unione (Query7) che ha il seguente codice SQL:
SELECT tblAppt.OraAppt, tblAppt.Note
FROM tblAppt
WHERE (((tblAppt.DataAppt)=[Sccegli la data:]))
UNION SELECT tblAppt.OraFine, "."
FROM tblAppt
WHERE (((tblAppt.DataAppt)=[Sccegli la data:]))
UNION Select Tabella3.ora2, Null
From Tabella3
ORDER BY tblAppt.OraAppt, tblAppt.Note;
Infine, basata su Query7, mi sono creata le seguente query di
raggruppamento:
SELECT Query7.OraAppt, Last(Query7.Note) AS UltimoDiNote
FROM Query7
WHERE ((Not ((IIf([OraAppt]*24=Int([OraAppt]*24),[OraAppt],Null))) Is Null))
OR ((Not (Query7.Note) Is Null))
GROUP BY Query7.OraAppt;
Ciao
Roberto

 Creane una su un servizio dotato di filtri antispam.
ti ha beccato di nuovo....vero?
ciao Riccardo


Forse ho fatto Bingo!!
Prova a vedere se con queste 2 query funziona. Mi sembra che ora gestisce
anche gli appuntamenti estemporanei prima delle 8:00 e gli appuntamenti a
cavallo delle ore.
Presupposti.
--------------
tblAppt
--------
ID                Contatore e chiave primaria
DataAppt     Data/ora
OraAppt      Data/ora
OraFine       Data/ora
Note            Testo o Memo
Tabella3
---------
Ora2            Data/ora e chiave primaria
Tabella3 contiene gli slot con intervallo di 1 ora:
08:00
09:00
10:00
11:00
...
20:00
La prima query  è una query unione che si chiama Query7 e che ha il seguente
codice SQL:
SELECT tblAppt.DataAppt, tblAppt.OraAppt, tblAppt.Note
FROM tblAppt
WHERE (((tblAppt.DataAppt)=[Digita la data:]))
UNION SELECT tblAppt.DataAppt, tblAppt.OraFine, Null
FROM tblAppt
WHERE (((tblAppt.OraFine)>#8:0:0#) AND ((tblAppt.DataAppt)=[Digita la
data:]))
UNION Select [Digita la data:] As DataAppt, Tabella4.ora2, Null
From Tabella4
ORDER BY tblAppt.OraAppt, tblAppt.Note;
La seconda è una query di raggruppamento, visualizza il risultato finale ed
ha il seguente codice SQL:
SELECT Query7.OraAppt, Max(Query7.Note) AS MaxDiNote
FROM Query7
WHERE (((DLookUp("[OraAppt]","tblAppt","int(OraAppt*1440)<" &
Int([OraAppt]*1440) & " And int(OraFine*1440) >" & Int([OraAppt]*1440) & "
And DataAppt=#" & Format([DataAppt],"mm/dd/yyyy") & "#")) Is Null))
GROUP BY Query7.OraAppt;
Naturalmente cambiando l'intervallo di Tabella3, puoi gestire anche uno
schedul di appuntamenti ogni mezzora.
Fammi sapere.
--
Roberto
---------------------------------------------
il Sito Comune di it.comp.appl.access:
http://www.sitocomune.com
---------------------------------------------