<\/p>\n
Das Speichern von Datum- und Zeitwerten mit Access birgt wenige Geheimnisse. Sie fügen einer Ta-belle ein Feld vom Datentyp „Datum\/Zeit“ hinzu und schon können Sie Werte in dieses Feld eingeben. Die tägliche Praxis im Umgang mit Datums- und Zeitwerten stellt jedoch höhere Anforderungen. Mit den Tipps aus dem folgenden Beitrag können Sie die meisten der sich stellenden Fragen beantworten.<\/b><\/p>\nEin Wert mit vielen Gesichtern<\/h2>\n
Innerhalb Deutschlands geben die meisten Menschen einen Datumswert intuitiv als 5.3.2023, als 05.03.2023 oder schreibfaul als 5.3.23 oder mit Mischformen ein. Access versteht all diese Schreibweisen und interpretiert sie als den gleichen Tag, den 5.3.2023.<\/p>\n
Selbst Angaben im Klartext wie beispielsweise 5. März 2023 sind bei der Dateneingabe erlaubt. Sie müssen lediglich darauf achten, dass Ihre Eingabe den in der Systemsteuerung von Windows getätigten Ländereinstellungen entspricht.<\/p>\n
Dass Access Ihre Eingabe richtig versteht, können Sie leicht feststellen, indem Sie ein Formular mit einem Textfeld namens txtDatumZeit <\/b>anlegen.<\/p>\n
Fügen Sie dem Formular ein weiteres Textfeld namens txtDatum <\/b>mit dem folgenden Steuerelementinhalt hinzu:<\/p>\n Mit einem weiteren Textfeld namens txtZeit<\/b> können Sie die Zeitangabe aus dem Eingabewert ermitteln. Geben Sie für dieses den folgenden Steuerelementinhalt ein:<\/p>\n Access erkennt selbständig, dass es sich bei dem eingegebenen Text um einen Datum- und Zeitwert handelt und wandelt ihn in automatisch in diesen Datentyp um. Die Format<\/b>-Funktion formatiert den Wert aus dem Steuerelement txtDatumZeit <\/b>im ersten Fall als Datums- und im zweiten Fall als Zeitwert. Mit tt.mm.jjjj <\/b>erhalten Sie die Anzeige mit zweistelligem Tages-, zweistelligem Monats- und vierstelligem Jahreswert. Das Zeitformat zeigt Stunden, Minuten und Sekunden ebenfalls zweistellig an.<\/p>\n Nun können Sie nacheinander verschiedene Datumswerte in das Textfeld eingeben und beobachten, welchen Datumswert und welchen Zeitwert Access ermittelt.<\/p>\n Ein Beispiel hierfür sehen Sie in Bild 1.<\/p>\n Bild 1: Mit diesem Formular können Sie prüfen, ob Access Ihre Datums- und Zeiteingabe versteht.<\/span><\/b><\/p>\n Sie können allerlei verschiedene Eingaben für den gleichen Tag tätigen. Wenn Sie wissen wollen, wie Access die Werte intern speichert, dann fügen Sie dem Formular drei weitere Steuerelemente mit folgenden Formeln als Steuerelementinhalt hinzu:<\/p>\n Besonders interessant ist die ZDate<\/b>-Funktion (englisch: CDate<\/b>). Diese Funktion wandelt irgendeinen Wert, in diesem Fall die eingegebene Zeichenkette, in den Datentyp DatumZeit <\/b>um. Der anschließende Aufruf von ZDouble <\/b>(englisch: CDbl<\/b>) führt dazu, dass Access den berechneten Wert als Zahl mit Nachkommastellen anzeigt. Ein Beispiel hierfür sehen Sie in Bild 2.<\/p>\n Bild 2: Beispiel für die Umrechnung eines Datums- und Zeitwertes in einen Double-Wert.<\/span><\/b><\/p>\n Access wandelt beispielsweise 14.03.2023 10:35:32 <\/b>in den Double<\/b>-Wert 499,4413425926 <\/b>um. Der Grund hierfür besteht darin, dass Access Datums- und Zeitwerte als Double<\/b>-Werte kodiert.<\/p>\n Der ganzzahlige Anteil speichert die Anzahl der Tage in Bezug auf den 30.12.1899<\/b>. Negative Werte geben die Anzahl der Tage vor diesem Datum an und positive Werte die Anzahl der Tage nach diesem Datum.<\/p>\n Der Nachkommanteil entspricht jeweils der seit 0 Uhr vergangen Zeit. Der Zeitpunkt 30.12.1899 0:00:00<\/b> entspricht dem Double-Wert 0,0<\/b>.<\/p>\n Aufgrund der internen Umrechnung in Double<\/b>-Werte können Sie mit Datums- und Zeitwerten rechnen. Bei der Addition von zwei Werten erhalten Sie absolut sinnvolle Ergebnisse. Das in Bild 3 gezeigte Beispielformular enthält zwei Textfelder zur Dateneingabe.<\/p>\n Bild 3: Beispiel für die Addition von zwei Datum-\/Zeit-Werten<\/span><\/b><\/p>\n Der eingegebene Text wird jeweils wie oben beschrieben mit ZDate() <\/b>und ZDouble() <\/b>in einen Double<\/b>-Wert umgerechnet. Das Textfeld txtSumme <\/b>berechnet dann die Summe aus den beiden Werten. Das unterste Textfeld zeigt den berechneten Wert als Standarddatum formatiert an.<\/p>\n Im Beispiel wurden zu dem Datum\/Zeit<\/b>-Wert 14.03.2023 23:00:00<\/b> zwei Stunden hinzuaddiert. Als Ergebnis erhalten Sie den Datum\/Zeit<\/b>-Wert 15.03.2023 01:00:00<\/b>.<\/p>\n Hinweis: Beim Rechnen mit Datum\/Zeit<\/b>-Werten dürfen Sie nur positive Zahlen oder nur ganze Zahlen verwenden. Bei Datumswerten vor dem 30.12.1899 <\/b>wird dem negativen ganzzahligen Anteil der positive Nachkommaanteil hinzugerechnet.<\/p>\n Wenn Sie beispielsweise dem Datum\/Zeit<\/b>-Wert 15.12.1899 23:00:00 <\/b>(entspricht -15,9583333333333<\/b>) zwei Stunden (entspricht 0,0833333333333333<\/b>) hinzuaddieren, dann erhalten Sie das fehlerhafte Ergebnis 15.12.1899 21:00:00<\/b>.<\/p>\n Access verfügt über eine ganze Reihe eingebauter Funktionen für die Berechnung von Datum- und Zeit-Werten. Mit der Jetzt<\/b>-Funktion erhalten Sie die aktuelle Systemzeit inklusive Datum. Die Datum<\/b>-Funktion liefert nur das Datum, die Jetzt<\/b>-Funktion nur die Zeit.<\/p>\n Mit der DatAdd<\/b>-Funktion (englisch: DateAdd<\/b>) können Sie eine Sekunde (s<\/b>), eine Minute (n<\/b>), eine Stunde (h<\/b>), einen Tag (d<\/b>), einen Wochentag (w<\/b>), einen Tag des Jahres (y<\/b>), eine Woche (ww<\/b>), einen Monat (m<\/b>), ein Quartal (q<\/b>) oder ein Jahr (yyyy<\/b>) zu einem Datumswert hinzuaddieren. Die in Klammern angegebenen Werte können Sie als Parameter für die DatAdd<\/b>-Funktion verwenden. Bild 4 zeigt exemplarisch das Addieren einer Woche und eines Monats zu einem Datumswert.<\/p>\n Bild 4: Addition einer Woche und eines Monats zu einem Datumswert<\/span><\/b><\/p>\n Die in der Abbildung gezeigten Werte können Sie mit den folgenden beiden Ausdrücken berechnen:<\/p>\n Für viele Berechnungen benötigen Sie die Differenz zwischen zwei Datumswerten nicht einfach nur als Double<\/b>-Zahl, sondern als konkret benanntes Intervall.<\/p>\n Mit der DateDiff<\/b>-Funktion ermitteln Sie die Differenz zwischen zwei Zeitpunkten in Sekunden (s<\/b>), Minuten (n<\/b>), Stunden (h<\/b>), Wochen (ww<\/b>), Wochentagen (w<\/b>), Tagen (d<\/b>), Tagen des Jahres (y<\/b>), Monaten (m<\/b>), Quartalen (q<\/b>) und Jahren (y<\/b>) . So berechnet beispielsweise der Ausdruck<\/p>\n die Differenz zwischen zwei Datumswerten in Tagen. Der erste Parameter bezeichnet das Intervall. Das d <\/b>für englisch Day <\/b>veranlasst Access, die Differenz in Tagen zu berechnen. Der zweite und dritte Parameter bezeichnen zwei Steuerelemente mit Datumswerten.<\/p>\n Parameter Nummer vier und fünf sind optional, sollten aber im deutschsprachigen Raum angegeben werden.<\/p>\n Diese beiden Parameter bestimmen, wie Access die Kalenderwochen zählt. Mit der ersten 2 <\/b>legen Sie fest, dass der erste Tag einer Woche der Montag (2 <\/b>= vbMonday<\/b>) ist. Mit der zweiten 2 <\/b>legen Sie fest, dass die erste Kalenderwoche eines Jahres die erste Woche im neuen Jahr mit mindestens 4 Tagen ist.<\/p>\n Etwas seltsam ist die Unterscheidung zwischen der Differenz in Wochentagen (w<\/b>) und Wochen (ww<\/b>). Falls Sie dieses Thema interessiert, sollten Sie sich den genauen Text in der Hilfe durchlesen.<\/p>\n Eine verständliche Interpretation des Hilfetextes könnte wie folgt lauten: Bei Verwendung des Parameters w <\/b>berechnet Access die Anzahl voller Kalenderwochen mit 7 Tagen, die zwischen den beiden Datumswerten liegen.<\/p>\n Bei Verwendung des Parameters ww <\/b>zählt Access die Anzahl der Sonntage zwischen den beiden Datumswerten. Dabei wird das zweite Datum nicht mitgezählt, sofern es auf einen Sonntag fällt. Dieser Wert ist entweder gleich oder größer als der mit w <\/b>ermittelte.<\/p>\n Wenn Sie wie in Bild 5 beispielsweise die Wochen von Sonntag, den 5.3.2023 bis Montag, den 13.3.2023 mit DateDiff <\/b>berechnen, dann erhalten Sie bei Verwendung des Parameters w <\/b>ein Ergebnis von einer Woche und bei Verwendung des Parameters ww <\/b>ein Ergebnis von zwei Wochen. Tatsächlich liegen zwischen den beiden Zeitpunkten acht Tage.<\/p>\n Bild 5: Berechnungen mit DateDiff<\/span><\/b><\/p>\n Wenn Sie hingegen die Differenz von Sonntag, den 5.3.2023 und Sonntag, den 12.3.2023 berechnen, dann ermitteln beide Parameter den gleichen Wert 1 <\/b>als Ergebnis. Der Grund besteht darin, dass auch bei Verwendung von ww <\/b>der zweite Sonntag nicht mitgezählt wird.<\/p>\n Mit der DatTeil<\/b>-Funktion (englisch: DatePart<\/b>) können Sie die Jahreszahl (yyyy<\/b>), das Quartal (q<\/b>), den Monat (m<\/b>), den Tag des Jahres (y<\/b>), den Tag (d<\/b>), den Wochentag (w<\/b>), die Woche (ww<\/b>), die Stunde (h<\/b>), die Minute (n<\/b>) oder die Sekunde (s<\/b>) aus einem Zeitpunkt berechnen. Mit dem fol-genden Ausdruck berechnen Sie beispielsweise den Tag des Jahres des im Steuerelement txtZeitpunkt <\/b>gespeicherten Zeitpunkts:<\/p>\n Am 8.3.2023 ist dies der Wert 73<\/b>, am 31.12 des Schaltjahres 2024 ist es der Wert 366<\/b>. Bild 6 enthält eine Übersicht der verschiedenen Datumsteile.<\/p>\n Bild 6: Ergebnisse der DatTeil-Funktion<\/span><\/b><\/p>\n Die DatSeriell<\/b>-Funktion (englisch: DateSerial<\/b>) ermittelt einen Datumswert aus den in dieser Reihenfolge angegebenen Werten Jahr<\/b>, Monat <\/b>und Tag<\/b>. <\/p>\n Ein Beispiel lautet:<\/p>\n Die korrespondierende Funktion ZeitSeriell <\/b>(englisch: TimeSerial<\/b>) berechnet einen Zeitwert aus Stunde, Minute und Sekunde:<\/p>\n Mit der ZDate<\/b>-Funktion (englisch: CDate<\/b>) wandeln Sie einen Ausdruck in einen Datumswert um. Ein Beispiel für die Umwandlung einer Zeichenkette lautet wie folgt:<\/p>\n Dazu korrespondierend wandelt die ZeitSeriellStr<\/b>-Funktion (englisch: TimeValue<\/b>) einen Ausdruck in einen Zeitwert um:<\/p>\n Mit der IstDatum<\/b>-Funktion (englisch: IsDate<\/b>) können Sie feststellen, ob sich ein Ausdruck in einen Datumswert umwandeln lässt.<\/p>\n Mit den bisher beschriebenen Funktionen können Sie die meisten Aufgabenstellungen im Zusammenhang mit Datum- und Zeitwerten lösen. Die folgenden Abschnitte beschreiben die Berechnung einiger häufig benötigter Kennziffern. Sie finden alle Beispiele im Formular frmFunktionen <\/b>in der Beispieldatenbank zu diesem Beitrag (siehe Bild 7).<\/p>\n Bild 7: Diese Abbildung enthält eine Übersicht der häufig verwendeten Datums- und Zeitfunktionen.<\/span><\/b><\/p>\n Bei der Berechnung des ersten Tages eines Monats können Sie sich zu Nutze machen, dass Access den Tag eines Datums als ganze Zahl speichert.<\/p>\n Von dieser Zahl brauchen Sie nur die Anzahl der in diesem Monat vergangenen Tage abzuziehen und das Ergebnis wieder in einen Datumswert umzurechnen. Mit der folgenden Formel berechnen Sie den ersten Tag des Monats auf der Basis des Datumswertes, der in dem Steuerelement txtZeitpunkt <\/b>gespeichert ist:<\/p>\n Falls in txtZeitpunkt <\/b>auch eine Uhrzeit angegeben ist, wird diese übernommen. Um die Uhrzeit abzuschneiden, können Sie folgenden Ausdruck verwenden:<\/p>\n Zur Berechnung des ersten Tages des Folgemonats verwenden Sie die gleiche Formel wie zur Berechnung des ersten Tages innerhalb des Monats. Diesen Wert erhöhen Sie mittels DateAdd<\/b>-Funktion um einen Monat:<\/p>\n Den 1.1. <\/b>des aktuellen Jahres berechnen Sie mit der DatSeriell<\/b>-Funktion. Setzen Sie das Datum aus der Jahreszahl des in txtZeitpunkt <\/b>gespeicherten Datums, dem Monat 1 <\/b>und dem Tag 1 <\/b>zusammen:<\/p>\n Zur Berechnung des ersten Tages im laufenden Quartal ermitteln Sie zuerst das Quartal aus dem in txtZeitpunkt <\/b>enthaltenen Datumswert. Es handelt sich hierbei um einen Wert zwischen 1 <\/b>und 4<\/b>. Von diesem Wert subtrahieren Sie den Wert 1<\/b>, so dass Sie einen Wert zwischen 0 <\/b>und 3 <\/b>erhalten.<\/p>\n Mit der DatAdd<\/b>-Funktion addieren Sie die Anzahl der ermittelten Quartale zum 1.1. <\/b>des laufenden Jahres. Da beispielsweise der 1.1.2023 <\/b>gleichzeitig auch der 1.1. <\/b>des 1. Quartals ist, erhalten Sie mit der Addition von 0<\/b>–3 <\/b>Quartalen die jeweiligen Quartalsanfänge:<\/p>\n Um den letzten Tag eines Quartals zu ermitteln, berechnen Sie zuerst den 1.1. des Folgequartals. Anschließend ziehen Sie von diesem Datum einen Tag ab:<\/p>\n Der folgende Ausdruck ermittelt die Kalenderwoche des im Steuerelement txtZeitpunkt <\/b>gespeicherten Datums:<\/p>\n Auf der Seite www.donkarl.com <\/b>befindet sich eine kleine VBA-Funktion, die den Montag einer Kalenderwoche berechnet und die wir ein wenig abgewandelt haben (siehe Listing 1). Sie finden diese Funktion auch in der Beispieldatenbank zu diesem Beitrag.<\/p>\n Listing 1: Berechnen des Montags einer Kalenderwoche<\/span><\/b><\/p>\n Der Ausdruck DateSerial(intJahr, 1, 1) <\/b>berechnet das Datum des 1.1. <\/b>des Kalenderjahres. Diesem Datum wird die Anzahl (Kalenderwoche -1) x 7 Tage hinzugerechnet. Für Kalenderwoche 5 werden dem Datum also 28 Tage hinzugerechnet. Für das Jahr 2023 ergibt sich so Sonntag, der 29. Januar 2023.<\/p>\n Danach wird der Montag vor diesem Datum berechnet. Dazu wird der Wochentag subtrahiert und der Wert 1 <\/b>addiert.<\/p>\n Als Ergebnis erhalten Sie Montag, den 30.1.2023<\/b>. Dies entspricht bereits dem gesuchten Ergebnis.<\/p>\n In der Funktion folgen aber dennoch zwei If<\/b>-Abfragen, die gelegentlich auftretende Sonderfälle abdecken.<\/p>\n Die Addition von Zeitwerten zu einem Datum ist mit Access absolut unproblematisch.<\/p>\n Mit dem folgenden Ausdruck addieren Sie 36 Stunden und 30 Minuten zu einem Zeitpunkt hinzu:<\/p>\n Wenn das Steuerelement txtZeitpunkt <\/b>den Wert 08.03.2023 04:00:00 <\/b>enthält, dann erhalten Sie als Ergebnis den Wert 09.03.2023 16:30:00<\/b>.<\/p>\n Etwas schwieriger ist die Anzeige der 36 Stunden. <\/p>\n Wenn Sie den ZeitSeriell<\/b>-Wert direkt einem Steuerelement zuweisen, dann addiert Access die Zeit zum 30.12.1899, 0:00:00 Uhr<\/b> und speichert den berechneten Zeitpunkt in dem Steuerelement. Zur Anzeige kommt dann der 31.12.1899, 12:00:00 Uhr<\/b>.<\/p>\n Wie Sie dieses und ähnliche Probleme umgehen, zeigen wir im Beitrag Mit Zeiten rechnen <\/b>(www.access-im-unternehmen.de\/1421<\/b>).<\/p>\n Um das Enddatum eines Projekts zu berechnen, muss zum Startdatum eine bestimmte Anzahl von Arbeitstagen addiert werden. Wenn das Projekt beispielsweise am Dienstag, den 14.3.2023 startet und fünf Tage dauert, dann können Sie es bis Dienstag, den 21.3.2023 fertig stellen. Eine solche Berechnung können Sie mit der folgenden Anweisung durchführen:<\/p>\n Ein Beispiel für diese Berechnung finden Sie im Formular frmArbeitstage <\/b>in der Beispieldatenbank zu diesem Beitrag (siehe Bild 8).<\/p>\n Bild 8: Endtermin berechnen<\/span><\/b><\/p>\n Access kennt nur einen Datentyp für Datums- und Zeitwerte. Dies hat viele Vorteile, kann aber auch zur Verwirrung führen. Die folgenden Abschnitte enthalten einige Hinweise für den Umgang mit Datums- und Zeitwerten in Abfragen.<\/p>\n Als Beispiel dient die Tabelle tblPreise<\/b>. Es handelt sich hierbei um eine Preisliste, die mit der Artikeltabelle verknüpft ist. Für jeden Artikel können mehrere Preise mit einem Von- und einem Bis-Datum gespeichert werden. Es handelt sich hierbei um die Gültigkeitsdauer des Preises. Eine Überprüfung auf überlappende Zeiträume klammern wir in diesem Beispiel aus. Wir gehen davon aus, dass die Preisliste stimmt und beschäftigen uns mit der Abfrage.<\/p>\n Für einen ersten Test sollten Sie eine Abfrage mit den Tabellen tblArtikel <\/b>und tblPreise <\/b>erstellen. Access zeigt die Beziehung zwischen den beiden Tabellen in der Abfrage automatisch an. Fügen Sie dem Entwurfsbereich der Abfrage die Felder Artikel<\/b>, Preis<\/b>, GueltigVon <\/b>und GueltigBis <\/b>hinzu. Geben Sie für GueltigVon <\/b>das folgende Kriterium ein:<\/p>\n Für das Feld GueltigBis <\/b>geben Sie folgendes Kriterium ein:<\/p>\n Diese Kriterien (siehe Bild 9) sollen bewirken, dass die Abfrage alle Preise ermittelt, die am 8.3.2023 <\/b>gültig sind.<\/p>\n Bild 9: Abfrage zur Berechnung der Preise am 8.3.2023<\/span><\/b><\/p>\n Wenn Sie die Abfrage ausführen, erhalten Sie das in Bild 10 gezeigte Ergebnis in der Datenblattansicht der Tabelle tblPreise<\/b>. Wie Sie sehen, liefert die Abfrage leider einen Datensatz zu wenig. Der Grund hierfür besteht darin, dass Access die eingegebenen Kriterien wie folgt interpretiert:<\/p>\n Bild 10: Ergebnis der Berechnung der Preise am 8.3.2023<\/span><\/b><\/p>\n Der Preis mit der ID 3 <\/b>ist aber erst ab dem 8.3.2023, 12:00:01 gültig und fällt aus dem Vergleich heraus. Die Zeitangabe erweist sich hier als echter Stolperstein. Um die Abfrage zu korrigieren, ändern Sie das Feld GueltigVon <\/b>den Ausdruck Von: Fix([GueltigVon])<\/b>. Den Ausdruck für das Feld GueltigBis <\/b>ändern Sie in Bis: Fix([GueltigBis])<\/b> (siehe Bild 11).<\/p>\n Bild 11: Korrigierte Abfrage zur Berechnung der Preise am 8.3.2023<\/span><\/b><\/p>\n Wenn Sie die Abfrage nun erneut starten, zeigt Access wie in Bild 12 alle am 8.3.2023 gültigen Preise an – auch von dem Artikel, dessen Preis mittags um 12:00 Uhr geändert wurde.<\/p>\n Bild 12: Ergebnis der korrigierten Berechnung der Preise am 8.3.2023<\/span><\/b><\/p>\n Bei der korrigierten Fassung der Abfrage ermittelt die Fix<\/b>-Funktion jeweils den ganzzahligen Anteil der Felder GültigVon <\/b>und GültigBis<\/b>. Dies entspricht dem reinen Datumswert ohne Zeitangabe. Der Vergleich erfolgt dann automatisch für alle Datumswerte mit der nivellierten Uhrzeit 00:00:00.<\/p>\n Das Handling von Datums- und Zeitwerten bei der Programmierung in VBA entspricht weitgehend dem Handling in Abfragen, Formularen und Berichten. Ein wesentlicher Unterschied besteht darin, dass Sie in VBA nur die englischen Funktionsnamen verwenden dürfen. Dies gilt aber nicht nur für Datums- und Zeitfunktionen, sondern prinzipiell für alle Funktionen.<\/p>\n In VBA kommt es häufiger vor, dass SQL-Anweisungen im Programmcode als Zeichenkette zusammengesetzt werden. Hierbei müssen Sie beachten, dass Datumswerte in SQL-Anweisungen prinzipiell in der Form #MM\/DD\/YYYY# <\/b>anzugeben sind. Dies betrifft sowohl die Reihenfolge von Monat, Tag und Jahr als auch die Verwendung des Schrägstrichs als Trennzeichen. Der Ausdruck muss außerdem in Rauten (#) geklammert werden.<\/p>\n Es ist empfehlenswert, dass Sie für die Bildung von Abfragen, WHERE<\/b>-Klauseln und Filterausdrücken die in Listing 2 zu findende Funktion SQLDatum <\/b>verwenden. Zum Aufruf der Funktion genügt die Angabe eines Datumswertes. Wenn Sie beispielsweise die Anweisung<\/p>\n Listing 2: Formatieren des Datums für SQL-Abfragen<\/span><\/b><\/p>\n in das Direktfenster von Access eingeben, dann erhalten Sie am 8. März 2023 als Ergebnis den Ausdruck #3\/8\/2023#<\/b>. Bei Bedarf können Sie der Funktion als zweiten Parameter den Wert True <\/b>übergeben. In diesem Fall ergänzt sie die Uhrzeit. Wenn Sie beispielsweise die Anweisung<\/p>\n in das Direktfenster eingeben, dann ermittelt die Funktion den Wert #3\/8\/2023 18:57:8#<\/b>.<\/p>\n Wenn wir nun konkret das Datum in eine SQL-Abfrage einbauen wollen, die wir per VBA nutzen, können wir genau diese Funktion nutzen, um das Datum in die benötigte Form zu bringen.<\/p>\n Allerdings müssen wir sie dazu noch in eine entsprechende Anweisung einbetten. Wenn wir zum Beispiel das Datum als Parameter an eine VBA-Prozedur übergeben wollen, welche die Abfrage aus qryGueltigePreiseKorrigiert <\/b>verwendet, holen wir uns zuerst einmal den SQL-Code der Abfrage. Dazu öffnen wir diese in der Entwurfsansicht und klicken dann im Ribbon auf den Eintrag Abfrageentwurf|Ergebnisse|Ansicht|SQL-Ansicht<\/b> (siehe Bild 13).<\/p>\n Bild 13: SQL-Ansicht einer Abfrage<\/span><\/b><\/p>\n Diese Abfrage liefert uns fix die Daten, die zum 8.3.2023 gültig sind und sieht wie folgt aus:<\/p>\n=Format([txtDatumZeit];\"tt.mm.jjjj\")<\/pre>\n
=Format([txtDatumZeit];\"hh:nn:ss\")<\/pre>\n
![\"Mit](\"..\/fileadmin\/_temp_\/2023_03\/pic_1432_001.png\")
<\/p>\n=ZDouble(ZDate([txtDatumZeit]))\r\n=DatWert([txtDatumZeit])\r\n=ZeitSeriellStr([txtDatumZeit])<\/pre>\n
![\"Beispiel](\"..\/fileadmin\/_temp_\/2023_03\/pic_1432_002.png\")
<\/p>\nRechnen mit Datum und Zeit<\/h2>\n
![\"Beispiel](\"..\/fileadmin\/_temp_\/2023_03\/pic_1432_003.png\")
<\/p>\nFunktionen für Datum und Zeit<\/h2>\n
Addieren von Zeitintervallen<\/h2>\n
![\"Addition](\"..\/fileadmin\/_temp_\/2023_03\/pic_1432_004.png\")
<\/p>\n=DatAdd(\"ww\";1;[txtDouble1])\r\n=DatAdd(\"m\";1;[txtDouble1])<\/pre>\n
Differenz in Tagen, Wochen und Monaten<\/h2>\n
=DatDiff(\"d\";[txtDouble1];[txtDouble2];2;2)<\/pre>\n
![\"Berechnungen](\"..\/fileadmin\/_temp_\/2023_03\/pic_1432_005.png\")
<\/p>\nDatumsteile ermitteln<\/h2>\n
=DatTeil(\"y\";[txtZeitpunkt];2;2)<\/pre>\n
![\"Ergebnisse](\"..\/fileadmin\/_temp_\/2023_03\/pic_1432_006.png\")
<\/p>\nTypen umwandeln<\/h2>\n
=DatSeriell(2023;3;14)<\/pre>\n
=ZeitSeriell(14;39;15)<\/pre>\n
=ZDate(\"13 März 2023\")<\/pre>\n
=ZeitSeriellStr(\"14:43:20\")<\/pre>\n
Praxis mit Datum und Zeit<\/h2>\n
![\"Diese](\"..\/fileadmin\/_temp_\/2023_03\/pic_1432_007.png\")
<\/p>\nErster des Monats<\/h2>\n
=[txtZeitpunkt]-Tag([txtZeitpunkt])+1<\/pre>\n
=Fix([txtZeitpunkt])-Tag([txtZeitpunkt])+1<\/pre>\n
Erster Tag des Folgemonats<\/h2>\n
=DatAdd(\"m\";1;[txtZeitpunkt]-Tag([txtZeitpunkt])+1)<\/pre>\n
1.1. des Jahres<\/h2>\n
=DatSeriell(Jahr([txtZeitpunkt]);1;1)<\/pre>\n
Erster Tag des Quartals<\/h2>\n
=DatAdd(\"q\";DatTeil(\"q\";[txtZeitpunkt];2;2)-1;[txtErsterErster])<\/pre>\n
Letzter Tag des Quartals<\/h2>\n
=DatAdd(\"q\";DatTeil(\"q\";[txtZeitpunkt];2;2);[txtErsterErster])-1<\/pre>\n
Kalenderwoche ermitteln<\/h2>\n
=DatTeil(\"ww\";[txtZeitpunkt])<\/pre>\n
Montag einer Kalenderwoche berechnen<\/h2>\n
Public Function <\/span>MontagDerKalenderwoche(intKalenderwoche As Integer<\/span>, Optional<\/span> intJahr As Integer<\/span>) As Date<\/span>\r\n Dim <\/span>datMontag As Date<\/span>\r\n If <\/span>intJahr = 0 Then<\/span>\r\n intJahr = Year(Date)\r\n End If<\/span>\r\n datMontag = DateSerial(intJahr, 1, 1) + (intKalenderwoche - 1) * 7\r\n datMontag = datMontag + 1 - Weekday(datMontag, 2)\r\n If <\/span>Format(datMontag, \"ww\", 2, 2) <> intKalenderwoche Then<\/span>\r\n datMontag = datMontag + 7\r\n End If<\/span>\r\n If <\/span>(intKalenderwoche = 1 Or intKalenderwoche = 53) And Day(datMontag) > 4 And Day(datMontag) < 8 Then<\/span>\r\n datMontag = datMontag - 7\r\n End If<\/span>\r\n MontagDerKalenderwoche = datMontag\r\nEnd Function<\/span><\/pre>\nZeiten addieren<\/h2>\n
=[txtZeitpunkt]+ZeitSeriell(36;30;0)<\/pre>\n
Arbeitstage addieren<\/h2>\n
=[txtStarttermin]+[txtArbeitstage]\r\n+Int(([txtArbeitstage]\r\n+Wochentag([txtStarttermin])-2)\/5)*2<\/pre>\n
![\"Endtermin](\"..\/fileadmin\/_temp_\/2023_03\/pic_1432_008.png\")
<\/p>\nAbfragen mit Datum und Zeit<\/h2>\n
Aktuellen Preis ermitteln<\/h2>\n
<=#08.03.2023#<\/pre>\n
>=#08.03.2023#<\/pre>\n
![\"Abfrage](\"..\/fileadmin\/_temp_\/2023_03\/pic_1432_009.png\")
<\/p>\n![\"Ergebnis](\"..\/fileadmin\/_temp_\/2023_03\/pic_1432_010.png\")
<\/p>\nGueltigVon <= #08.03.2023 00:00:00# AND GueltigBis >=#08.03.2023 00:00:00#<\/pre>\n
![\"Korrigierte](\"..\/fileadmin\/_temp_\/2023_03\/pic_1432_011.png\")
<\/p>\n![\"Ergebnis](\"..\/fileadmin\/_temp_\/2023_03\/pic_1432_012.png\")
<\/p>\nDatum und Zeit in Abfragen unter VBA<\/h2>\n
SQL-Anweisung mit Datumsvergleich<\/h2>\n
Function <\/span>SQLDatum(varDatum As Variant<\/span>, Optional<\/span> bolMitZeit As Boolean<\/span>) As String<\/span>\r\n Dim <\/span>strErgebnis As String<\/span>\r\n strErgebnis = \"#\" & Month(varDatum) & \"\/\" & Day(varDatum) & \"\/\" & Year(varDatum)\r\n If <\/span>bolMitZeit = True<\/span> Then<\/span>\r\n strErgebnis = strErgebnis & \" \" & Hour(varDatum) & \":\" & Minute(varDatum) & \":\" & Second(varDatum)\r\n End If<\/span>\r\n strErgebnis = strErgebnis & \"#\"\r\n SQLDatum = strErgebnis\r\nEnd Function<\/span><\/pre>\n SQLDatum(Date)<\/pre>\n
SQLDatum(Now, True<\/span>) <\/pre>\nDatum in VBA-SQL-Abfragen<\/h2>\n
![\"SQL-Ansicht](\"..\/fileadmin\/_temp_\/2023_03\/pic_1432_013.png\")
<\/p>\nSELECT tblArtikel.Artikel, tblPreise.Preis, Fix([GueltigVon]) AS Von, Fix([GueltigBis]) AS Bis FROM tblArtikel INNER JOIN tblPreise ON tblArtikel.ArtikelID = tblPreise.ArtikelIDWHERE (((Fix([GueltigVon]))<=#3\/8\/2023#) AND ((Fix([GueltigBis]))>=#3\/8\/2023#));<\/pre>\n