{"id":55000521,"date":"2026-08-01T00:00:00","date_gmt":"2026-10-18T13:21:50","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=521"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"SQL_Server_datetime_und_datetime2_in_Access","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/SQL_Server_datetime_und_datetime2_in_Access\/","title":{"rendered":"SQL Server: datetime und datetime2 in Access"},"content":{"rendered":"

Wir verknüpfen eine Tabelle des SQL Servers mit Access, öffnen den Direktbereich und lesen mit DLookup<\/b> ein Datum aus der ersten Zeile. Bei einem Feld liefert der Aufruf den Wert, bei einem anderen scheitert derselbe Aufruf mit der Meldung Typen unverträglich<\/b>. Beide Felder enthalten ein Datum mit Uhrzeit. Der Unterschied liegt im Datentyp: Der SQL Server kennt mehrere Datentypen für Datum und Uhrzeit, und Access bindet sie je nach Einstellung unterschiedlich ein. Welche Konstellationen ohne Probleme laufen, welche Fehler auftreten und wie wir die Anbindung einrichten, zeigt dieser Beitrag.<\/b><\/p>\n

Beispieldatenbank<\/h2>\n

Die Beispiele dieses Beitrags laufen gegen die SQL Server-Datenbank DateTimeTest<\/b>. Das Skript DateTimeTest.sql<\/b> legt sie auf einer lokalen Instanz an, in unserem Fall .SQLEXPRESS<\/b>.<\/p>\n

Es löscht eine vorhandene Datenbank gleichen Namens und erzeugt sie neu.<\/p>\n

Die Datenbank enthält zwei Tabellen und eine Sicht. Die Tabelle tblZeitstempel<\/b> hat neben ZeitstempelID<\/b> und Bezeichnung<\/b> je eine Spalte für jeden Datentyp, den wir untersuchen wollen:<\/p>\n

    \n
  • ZDate:<\/b> Datentyp date<\/b><\/li>\n
  • ZSmallDateTime:<\/b> Datentyp smalldatetime<\/b><\/li>\n
  • ZDateTime:<\/b> Datentyp datetime<\/b><\/li>\n
  • ZDateTime2_0:<\/b> Datentyp datetime2(0)<\/b><\/li>\n
  • ZDateTime2_3:<\/b> Datentyp datetime2(3)<\/b><\/li>\n
  • ZDateTime2_7:<\/b> Datentyp datetime2(7)<\/b><\/li>\n<\/ul>\n

    Sie enthält drei Zeilen. Die erste enthält den 2. Oktober 2026 um 8:30:15 Uhr. Bei ZDate<\/b> fehlt die Uhrzeit, ZSmallDateTime<\/b> steht auf 8:30:00, weil der Typ nur Minuten speichert. ZDateTime<\/b> und ZDateTime2_3<\/b> tragen die Sekundenbruchteile .123<\/b>, ZDateTime2_7<\/b> die Sekundenbruchteile .1234567<\/b>.<\/p>\n

    Die zweite Zeile hat den 15. September 2026 um 11:30:05 Uhr, die dritte den 1. Januar 2026 ohne Uhrzeit. Das Ergebnis in SQL Server Management Studio steht im Ergebnisraster (siehe Bild 1).<\/p>\n

    \"Die<\/p>\n

    Bild 1: Die Tabelle tblZeitstempel im Ergebnisraster von SSMS<\/span><\/b><\/p>\n

    Die Tabelle tblSchreibtest<\/b> hat die vier Spalten ZDateTime<\/b>, ZDateTime2_0<\/b>, ZDateTime2_3<\/b> und ZDateTime2_7<\/b>. Wir verwenden sie für die Schreibversuche. Die Sicht vwZeitstempel<\/b> liefert dieselben Daten wie tblZeitstempel<\/b>, wandelt aber die drei datetime2<\/b>-Spalten mit CAST<\/b> in datetime<\/b> um.<\/p>\n

    Das Frontend SQLServer_DateTimeUndDateTime2InAccess.accdb<\/b> enthält die Tabellen als Verknüpfungen.<\/p>\n

    Die Verknüpfungen mit dem Zusatz Normal<\/b> im Namen verwenden die Einstellung, die wir weiter unten als Konstellation 3 beschreiben, die übrigen die Standardeinstellung. Die VBA-Prozeduren stehen im Modul mdlDateTimeBeispiele<\/b>, ein Testmodul prüft die Aussagen dieses Beitrags.<\/p>\n

    Datums- und Zeittypen im SQL Server<\/h2>\n

    Für Datum und Uhrzeit bietet der SQL Server vier Datentypen an, die wir hier betrachten:<\/p>\n

      \n
    • date:<\/b> nur das Datum, vom 1. Januar 0001 bis zum 31. Dezember 9999<\/li>\n
    • smalldatetime:<\/b> Datum und Uhrzeit auf die Minute genau, vom 1. Januar 1900 bis zum 6. Juni 2079<\/li>\n
    • datetime:<\/b> Datum und Uhrzeit, vom 1. Januar 1753 bis zum 31. Dezember 9999, in Schritten von etwa 3 Millisekunden<\/li>\n
    • datetime2(n):<\/b> Datum und Uhrzeit, vom 1. Januar 0001 bis zum 31. Dezember 9999, mit n<\/b> Nachkommastellen für die Sekunden, wobei n<\/b> zwischen 0 und 7 liegt<\/li>\n<\/ul>\n

      Den Typ datetime<\/b> gibt es seit den frühen Versionen des SQL Servers, datetime2<\/b> ist neuer. Er hat einen größeren Bereich, eine höhere Genauigkeit und entspricht dem SQL-Standard. Die Dokumentation von Microsoft zu datetime<\/b> empfiehlt für neue Arbeiten die Typen date<\/b>, time<\/b>, datetime2<\/b> und datetimeoffset<\/b>.<\/p>\n

      Für Access sieht das anders aus. Hier kommt es darauf an, wie Access die Typen einbindet, wenn wir eine Tabelle verknüpfen.<\/p>\n

      Wie Access die Typen einbindet<\/h2>\n

      Access kennt für Datum und Uhrzeit zwei Felddatentypen. Datum\/Uhrzeit<\/b> speichert den Wert intern als Zahl vom Typ Double<\/b>.<\/p>\n

      Der Teil vor dem Komma ist die Zahl der Tage seit dem 30. Dezember 1899, der Teil hinter dem Komma der Anteil des Tages. Daneben gibt es seit Access 2021 und Access in Microsoft 365 den Typ Datum\/Uhrzeit, erweitert<\/b>, der Sekundenbruchteile mit bis zu sieben Stellen speichert. Er ist nicht mit älteren Access-Versionen kompatibel.<\/p>\n

      Der erweiterte Typ wurde vor allem für die Anbindung des SQL Servers eingeführt. Er bildet den Typ datetime2<\/b> nach. Ob Access ihn beim Verknüpfen verwendet, steuert eine Option der aktuellen Datenbank. Wir finden sie in den Access-Optionen unter Aktuelle Datenbank<\/b> im Bereich Datentypunterstützungs-Optionen<\/b>, sie heißt Unterstützung des erweiterten Datentyps “Date Time Extended” (DateTime2) für mit ODBC verknüpfte\/importierte Tabellen<\/b> (siehe Bild 2).<\/p>\n

      \"Die<\/p>\n

      Bild 2: Die Option für datetime2 in den Access-Optionen<\/span><\/b><\/p>\n

      Die Option wirkt beim Verknüpfen oder Importieren. Eine bestehende Verknüpfung ändert sich nicht, wenn wir die Option später umschalten, bis wir sie neu verknüpfen. In unseren Tests verhielt sich eine neue Datenbank, in der wir die Option nie geändert hatten, wie bei eingeschalteter Option.<\/p>\n

      Was daraus folgt, sehen wir an den Verknüpfungen mit DAO<\/b>. Die Funktion FeldTypen<\/b> liefert zu jedem Feld einer Tabelle den DAO-Datentyp (siehe Listing 1). Der Wert 8 steht für Datum\/Uhrzeit<\/b>, der Wert 26 für Datum\/Uhrzeit, erweitert<\/b>.<\/p>\n

      Public Function <\/span>FeldTypen(strTabelle As String<\/span>) As String<\/span>\r\n    Dim <\/span>db As <\/span>DAO.Database\r\n    Dim <\/span>fld As <\/span>DAO.Field\r\n    Set<\/span> db = CurrentDb\r\n    For Each fld In db.TableDefs(strTabelle).Fields\r\n        FeldTypen = FeldTypen & fld.Name & \"=\" & fld.Type & \" \"\r\n    Next<\/span> fld\r\n    FeldTypen = Trim<\/span>(FeldTypen)\r\nEnd Function<\/span><\/pre>\n
      Listing 1: FeldTypen liefert die Felder einer Tabelle mit dem DAO-Datentyp<\/span><\/b><\/p>\n
      Für die Standardverknüpfung dbo_tblZeitstempel<\/b> erhalten wir im Direktbereich diese Zeile, hier zur besseren Lesbarkeit umgebrochen:<\/p>\n
      FeldTypen(\"dbo_tblZeitstempel\")\r\nZeitstempelID=4 Bezeichnung=10 ZDate=8\r\nZSmallDateTime=8 ZDateTime=8\r\nZDateTime2_0=26 ZDateTime2_3=26\r\nZDateTime2_7=26<\/pre>\n
      Die Typen date<\/b>, smalldatetime<\/b> und datetime<\/b> kommen als Datum\/Uhrzeit<\/b> an, alle drei datetime2<\/b>-Felder als Datum\/Uhrzeit, erweitert<\/b>.<\/p>\n
      Die Tabelle im Entwurf zeigt denselben Unterschied (siehe Bild 3).<\/p>\n
      \"Die<\/p>\n
      Bild 3: Die Felder der verknüpften Tabelle im Entwurf mit den Datentypen<\/span><\/b><\/p>\n
      Damit ergeben sich drei Konstellationen, die wir nacheinander durchgehen: datetime<\/b>, smalldatetime<\/b> und date<\/b> in Access, datetime2<\/b> bei eingeschalteter Option und datetime2<\/b> bei ausgeschalteter Option.<\/p>\n
      Konstellation 1: datetime, smalldatetime und date<\/h2>\n
      Die Typen date<\/b>, smalldatetime<\/b> und datetime<\/b> verhalten sich in Access wie ein normales Datum\/Uhrzeit-Feld. Das gilt in unseren Tests unabhängig von der Option. Ein Aufruf von DLookup<\/b> auf das Feld ZDateTime<\/b> liefert den Wert wie bei einer Access-Tabelle:<\/p>\n
      DLookup(\"ZDateTime\",\"dbo_tblZeitstempel\")\r\n02.10.2026 08:30:15<\/pre>\n
      Der Wert in der Tabelle lautet 8:30:15.123 Uhr. Access zeigt die Sekundenbruchteile nicht an. Format<\/b>, CDate<\/b>, Nz<\/b> und DateAdd<\/b> arbeiten mit dem Feld wie bei einer Access-Tabelle.<\/p>\n
      Bei ZDate<\/b> und ZSmallDateTime<\/b> gelten in unseren Tests dieselben Ergebnisse. Der Aufruf ohne Kriterium liest den ersten Datensatz in der Reihenfolge der Tabelle.<\/p>\n
      Wer in einer Datenbank, auf die vor allem Access zugreift, keine Sekundenbruchteile braucht, kommt mit diesen Typen ohne Einstellungen aus.<\/p>\n
      Die Einschränkungen des Typs datetime<\/b> sind die Schritte von etwa 3 Millisekunden und der Bereich ab dem Jahr 1753.<\/p>\n
      Konstellation 2: datetime2 bei eingeschalteter Option<\/h2>\n
      Bei eingeschalteter Option, in unseren Tests die Standardeinstellung, kommt datetime2<\/b> als Datum\/Uhrzeit, erweitert<\/b> an. Hier treten die Fehler auf. Wir gehen sie der Reihe nach durch, beginnend mit der Funktion aus der Einleitung.<\/p>\n
      Der Aufruf von DLookup<\/b> auf ein datetime2<\/b>-Feld liefert einen Fehler:<\/p>\n
      DLookup(\"ZDateTime2_3\",\"dbo_tblZeitstempel\")<\/pre>\n
      Es erscheint die Meldung Laufzeitfehler 13: Typen unverträglich<\/b> (siehe Bild 4). Der Aufruf liefert einen Wert, den Access nicht ausgeben kann. Auch die Zuweisung an eine Date<\/b>-Variable oder an eine String<\/b>-Variable scheitert mit dem Fehler 13. Dasselbe gilt in unseren Tests für DMax<\/b>, DMin<\/b> und DFirst<\/b>.<\/p>\n
      \"Der<\/p>\n
      Bild 4: Der Aufruf von DLookup auf ein datetime2-Feld meldet Typen unverträglich<\/span><\/b><\/p>\n
      Eine Verwendung der Domänenfunktionen ist trotzdem möglich. Die Funktion DCount<\/b> zählt Datensätze auch dann, wenn das Kriterium ein datetime2<\/b>-Feld enthält. Der folgende Aufruf zählt die Zeilen vom 2. Oktober 2026 und liefert 1:<\/p>\n
      DCount(\"*\",\"dbo_tblZeitstempel\", _\r\n  \"ZDateTime2_3>=#10\/2\/2026# AND \" & _\r\n  \"ZDateTime2_3<#10\/3\/2026#\")<\/pre>\n
      Eine Datumsbedingung auf einem datetime2<\/b>-Feld funktioniert also, nur der Wert des Feldes lässt sich nicht lesen.<\/p>\n
      Recordset und CDate bei datetime2<\/h2>\n
      Mit einem Recordset lässt sich der Feldwert lesen. Er kommt allerdings als Text an. Die folgende Abfrage liest das Feld ZDateTime2_7<\/b> der ersten Zeile:<\/p>\n
      Set<\/span> rst = CurrentDb.OpenRecordset( _\r\n  \"SELECT ZDateTime2_7 \" & _\r\n  \"FROM dbo_tblZeitstempel \" & _\r\n  \"WHERE ZeitstempelID=1\", _\r\n  dbOpenSnapshot, dbSeeChanges)\r\nTypeName(rst.Fields(0).Value)\r\nString\r\nrst.Fields(0).Value\r\n10\/02\/2026 08:30:15.1234567<\/pre>\n
      Der Text hat in unseren Tests mit deutschen Regionaleinstellungen das amerikanische Format Monat, Tag, Jahr, dazu sieben Nachkommastellen für die Sekunden.<\/p>\n
      Gemeint ist hier der 2. Oktober 2026. Die Funktion CDate<\/b> kann diesen Text mit den Nachkommastellen nicht in ein Datum umwandeln und löst den Fehler 13 aus.<\/p>\n
      Wer die Nachkommastellen mit Left<\/b> abschneidet, bekommt einen Wert, aber einen falschen. CDate(Left(Text, 19))<\/b> liest bei deutschen Regionaleinstellungen den Text 10\/02\/2026 08:30:15<\/b> als 10. Februar 2026 statt als 2. Oktober 2026 (siehe Bild 5). Access gibt dazu keine Meldung aus.<\/p>\n
      \"CDate<\/p>\n
      Bild 5: CDate liest den Text des Feldes mit vertauschtem Tag und Monat<\/span><\/b><\/p>\n
      Beim zweiten Datum der Tabelle, dem 15. September, liefert derselbe Aufruf das richtige Datum, weil es keinen 15. Monat gibt und CDate<\/b> den Text dann als Monat und Tag liest.<\/p>\n
      Die Vertauschung tritt deshalb bei Tagen bis zum zwölften eines Monats auf, außer wenn Tag und Monat übereinstimmen. Access meldet dazu nichts.<\/p>\n
      Abfragen auf datetime2-Felder<\/h2>\n
      In Abfragen verhält sich das Feld je nach Funktion unterschiedlich. Mehrere Funktionen funktionieren: Year<\/b>, Month<\/b>, Hour<\/b> und DateAdd<\/b>.<\/p>\n
      Die folgende Abfrage liefert 2026, 10 und 8:<\/p>\n
      SELECT Year(ZDateTime2_3), Month(ZDateTime2_3),\r\n  Hour(ZDateTime2_3)\r\nFROM dbo_tblZeitstempel\r\nWHERE ZeitstempelID=1;<\/pre>\n
      Andere scheitern mit dem Fehler 3071 (Dieser Ausdruck wurde falsch eingegeben, oder er ist zu komplex, um ausgewertet zu werden<\/b>), nämlich CDate<\/b>, DateValue<\/b>, Format<\/b>, CStr<\/b>, Left<\/b> und Nz<\/b>.<\/p>\n
      Die Rechnung mit + 1<\/b> meldet den Fehler 3464 (Datentypenkonflikt in Kriterienausdruck<\/b>). In einer Gruppierung bedeutet das: Format<\/b> im GROUP BY<\/b> funktioniert nicht, Year<\/b> und Month<\/b> dagegen schon. Die folgende Abfrage liefert drei Zeilen, eine für jeden Monat der Beispieldaten:<\/p>\n
      SELECT Year(ZDateTime2_3)*100+Month(ZDateTime2_3) AS M\r\nFROM dbo_tblZeitstempel\r\nGROUP BY Year(ZDateTime2_3)*100+Month(ZDateTime2_3);<\/pre>\n
      Auch ORDER BY<\/b> auf das Feld und der Vergleich mit Datumsliteralen in WHERE<\/b> funktionieren. Max<\/b> und Min<\/b> liefern das Ergebnis als Text im bekannten Format.<\/p>\n
      Bei Max<\/b> sind die Sekundenbruchteile auf null gesetzt: Statt 8:30:15.123<\/b> steht 8:30:15.0000000<\/b> im Ergebnis, hier für die Spalte ZDateTime2_3<\/b>.<\/p>\n
      Schreiben in datetime2-Felder<\/h2>\n
      Auch beim Schreiben gibt es Unterschiede. Die Funktion ZeitstempelAnlegen<\/b> legt in einer Tabelle einen Datensatz an und trägt in alle vier Felder denselben Date<\/b>-Wert ein (siehe Listing 2).<\/p>\n
      Public Function <\/span>ZeitstempelAnlegen(strTabelle As String<\/span>, datWert As Date<\/span>) As Long<\/span>\r\n    Dim <\/span>rst As <\/span>DAO.Recordset\r\n    Set<\/span> rst = CurrentDb.OpenRecordset(strTabelle, dbOpenDynaset, dbSeeChanges)\r\n    rst.AddNew<\/span>\r\n    rst!ZDateTime = datWert\r\n    rst!ZDateTime2_0 = datWert\r\n    rst!ZDateTime2_3 = datWert\r\n    rst!ZDateTime2_7 = datWert\r\n    rst.Update\r\n    rst.Bookmark = rst.LastModified\r\n    ZeitstempelAnlegen = rst!SchreibtestID\r\n    rst.Close\r\nEnd Function<\/span><\/pre>\n
      Listing 2: ZeitstempelAnlegen trägt einen Datumswert in alle Felder ein<\/span><\/b><\/p>\n
      Wir rufen sie für die Standardverknüpfung dbo_tblSchreibtest<\/b> mit dem 2. Oktober 2026, 8:30:15 Uhr und 123 Millisekunden auf. Im Server stehen danach diese Werte:<\/p>\n
        \n
      • ZDateTime:<\/b> 2026-10-02 08:30:15.123<\/b><\/li>\n
      • ZDateTime2_0:<\/b> 2026-10-02 08:30:15<\/b><\/li>\n
      • ZDateTime2_3:<\/b> 2026-10-02 08:30:15.000<\/b><\/li>\n
      • ZDateTime2_7:<\/b> 2026-10-02 08:30:15.0000000<\/b><\/li>\n<\/ul>\n
        Die Millisekunden gehen bei den datetime2<\/b>-Feldern verloren, bei datetime<\/b> bleiben sie erhalten. Wer Sekundenbruchteile in ein datetime2<\/b>-Feld schreiben will, kann in einer Abfrage die nicht dokumentierte Funktion NowExtended<\/b> verwenden.<\/p>\n
        Mit INSERT INTO … VALUES (NowExtended())<\/b> erhielt das Feld ZDateTime2_7<\/b> in unserem Test einen Wert mit sieben Nachkommastellen. Ein INSERT<\/b> mit einem Datumsliteral wie #10\/2\/2026 08:30:15#<\/b> schreibt in allen vier Feldern den Wert mit ganzen Sekunden, wie er im Literal steht. Das Literal enthält keine Sekundenbruchteile.<\/p>\n
        Auswege bei eingeschalteter Option<\/h2>\n
        Wenn die Tabellen bereits datetime2<\/b> enthalten und wir die Option nicht umstellen wollen, gibt es mehrere Möglichkeiten. Die erste liest den Text aus einem Recordset und wandelt ihn selbst in ein Datum um.<\/p>\n
        Die Funktion ErweitertZuDatum<\/b> erwartet den Text im Format des erweiterten Typs und liefert ein Date<\/b>. Sie gibt ein Datum unverändert zurück und akzeptiert auch Null<\/b> (siehe Listing 3).<\/p>\n
        Public Function <\/span>ErweitertZuDatum(varWert As Variant<\/span>) As Variant<\/span>\r\n    Dim <\/span>strWert As String<\/span>\r\n    Dim <\/span>datTag As Date<\/span>\r\n    Dim <\/span>datZeit As Date<\/span>\r\n    If <\/span>IsNull(varWert) Then<\/span>\r\n        ErweitertZuDatum = Null\r\n    Else<\/span>If VarType(varWert) = vbDate Then\r\n        ErweitertZuDatum = varWert\r\n    Else<\/span>\r\n        strWert = CStr(varWert)\r\n        datTag = DateSerial(CInt(Mid<\/span>(strWert, 7, 4)), _\r\n            CInt(Left<\/span>(strWert, 2)), CInt(Mid<\/span>(strWert, 4, 2)))\r\n        datZeit = TimeSerial(CInt(Mid<\/span>(strWert, 12, 2)), _\r\n            CInt(Mid<\/span>(strWert, 15, 2)), CInt(Mid<\/span>(strWert, 18, 2)))\r\n        ErweitertZuDatum = datTag + datZeit\r\n    End If<\/span>\r\nEnd Function<\/span><\/pre>\n
        Listing 3: ErweitertZuDatum wandelt den Text eines erweiterten Datums um<\/span><\/b><\/p>\n
        Die Funktion schneidet die einzelnen Teile aus dem Text und setzt sie mit DateSerial<\/b> und TimeSerial<\/b> zusammen. Die Sekundenbruchteile entfallen, der Wert ist auf die Sekunde genau und unabhängig von den Regionaleinstellungen. Der Aufruf mit dem Text aus dem Abschnitt Recordset und CDate bei datetime2<\/b> liefert den 2. Oktober 2026, 8:30:15 Uhr.<\/p>\n
        Die zweite Möglichkeit ist eine Abfrage, die nur Funktionen verwendet, die mit dem Feld funktionieren. Die Abfrage setzt aus Year<\/b>, Month<\/b> und Day<\/b> ein Datum und aus Hour<\/b>, Minute<\/b> und Second<\/b> eine Uhrzeit zusammen:<\/p>\n
        SELECT DateSerial(Year(ZDateTime2_3),\r\n  Month(ZDateTime2_3), Day(ZDateTime2_3)) +\r\n  TimeSerial(Hour(ZDateTime2_3),\r\n  Minute(ZDateTime2_3), Second(ZDateTime2_3))\r\nFROM dbo_tblZeitstempel;<\/pre>\n
        Das Ergebnis ist ein normales Datum\/Uhrzeit, mit dem Format<\/b> und die übrigen Funktionen arbeiten. Die Abfrage lässt sich einmal als gespeicherte Abfrage anlegen.<\/p>\n
        Die dritte Möglichkeit liegt im SQL Server. Die Sicht vwZeitstempel<\/b> wandelt die datetime2<\/b>-Spalten mit CAST<\/b> in datetime<\/b> um. Verknüpft Access die Sicht, kommen alle Spalten als Datum\/Uhrzeit<\/b> an, auch bei eingeschalteter Option.<\/p>\n
        DLookup<\/b> und Format<\/b> funktionieren dann wie in Konstellation 1. Die Umwandlung hat Nachteile: Der Typ datetime<\/b> hat Schritte von etwa 3 Millisekunden und beginnt erst im Jahr 1753, und die Sicht meldet einen Fehler, sobald ein Wert davor liegt.<\/p>\n
        Die vierte Möglichkeit sind Pass-Through-Abfragen. Sie reichen den Text unverändert an den Server weiter und liefern das Ergebnis, wie im ersten Teil der Reihe, T-SQL, Teil 1: Von Jet-SQL zu T-SQL<\/b>, beschrieben. In unserem Test kam ein datetime2<\/b>-Feld über eine Pass-Through-Abfrage als normales Datum an.<\/p>\n
        Alternativ richten wir die Anbindung so ein, dass der erweiterte Typ nicht entsteht, wie die nächste Konstellation zeigt.<\/p>\n
        Konstellation 3: datetime2 bei ausgeschalteter Option<\/h2>\n
        Schalten wir die Option aus und verknüpfen die Tabelle neu, kommen die datetime2<\/b>-Felder als Datum\/Uhrzeit<\/b> an. Die Funktion FeldTypen<\/b> liefert für die Verknüpfung dbo_tblZeitstempelNormal<\/b> bei allen sechs Datumsfeldern den Typ 8.<\/p>\n
        Die beschriebenen Fehler traten in unseren Tests nicht auf. DLookup<\/b> liefert ein Datum, und CDate<\/b>, Nz<\/b> und Format<\/b>, auch im GROUP BY<\/b>, funktionieren.<\/p>\n
        Zwei Einschränkungen bleiben. Die erste betrifft das Lesen: Ein Feld vom Typ datetime2(7)<\/b> liefert Access nur auf die Millisekunde genau.<\/p>\n
        Hat das Feld in der Tabelle den Wert .1234567, steht in Access .123.<\/p>\n
        Die zweite betrifft das Schreiben. Ein Date<\/b>-Wert mit Sekundenbruchteilen in einem Feld vom Typ datetime2(0)<\/b> lässt sich nicht speichern. Access meldet den Fehler 3146 mit dem Text ODBC-Aufruf fehlgeschlagen<\/b>. In der Auflistung DBEngine.Errors<\/b> steht die genauere Meldung des ODBC-Treibers:<\/p>\n
        Datetime field overflow. Fractional second\r\nprecision exceeds the scale specified in\r\nthe parameter binding.<\/pre>\n
        Das Feld datetime2(0)<\/b> speichert keine Sekundenbruchteile, und Access übergibt sie trotzdem. Die Meldung stammt vom ODBC-Treiber, nicht vom Server. Ein Date<\/b>-Wert mit ganzen Sekunden, wie ihn Now<\/b> liefert, wird ohne Fehler gespeichert. In datetime2(3)<\/b> und datetime2(7)<\/b> funktioniert die Eingabe mit Millisekunden ohne Fehler.<\/p>\n
        Die Funktion NowExtended<\/b> liefert bei ausgeschalteter Option keinen Sekundenbruchteil mehr, die Felder erhalten in unserem Test den Wert mit .0000000<\/b>.<\/p>\n
        Für Spalten, in die Access Zeitstempel mit Millisekunden schreibt, eignet sich daher datetime2(3)<\/b> besser als datetime2(0)<\/b>.<\/p>\n
        Option umstellen und neu verknüpfen<\/h2>\n
        In der Oberfläche schalten wir die Option in den Access-Optionen unter Aktuelle Datenbank<\/b> um. Danach müssen wir die betroffenen Tabellen neu verknüpfen, entweder im Tabellenverknüpfungs-Manager<\/b> oder durch Löschen und erneutes Anlegen der Verknüpfung.<\/p>\n
        Wie wir Tabellen per VBA verknüpfen, haben wir im Beitrag SQL Server: Tabellen per VBA verknüpfen (www.vbentwickler.de\/485)<\/b> gezeigt.<\/p>\n
        Auch die Option lässt sich per VBA umstellen. Sie ist eine Eigenschaft der Datenbank mit dem Namen Use DateTime2 for linking and importing data<\/b>. Die Prozedur DateTime2OptionSetzen<\/b> setzt sie und legt sie an, wenn sie in der Datenbank noch nicht vorhanden ist (siehe Listing 4).<\/p>\n
        Public Sub <\/span>DateTime2OptionSetzen(blnErweitert As Boolean<\/span>)\r\n    Dim <\/span>db As <\/span>DAO.Database\r\n    Dim <\/span>prp As <\/span>DAO.Property\r\n    Set<\/span> db = CurrentDb\r\n    On Error Resume Next<\/span>\r\n    db.Properties(cstrOption) = blnErweitert\r\n    If <\/span>Err.Number <> 0 Then<\/span>\r\n        Err.Clear\r\n        On Error GoTo<\/span> 0\r\n        Set<\/span> prp = db.CreateProperty(cstrOption, dbBoolean, blnErweitert)\r\n        db.Properties.Append prp\r\n    End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
        Listing 4: DateTime2OptionSetzen schaltet die Unterstützung von datetime2 ein oder aus<\/span><\/b><\/p>\n
        Die Konstante cstrOption<\/b> mit dem Namen der Eigenschaft und die Konstante cstrVerbindung<\/b> mit der Verbindungszeichenfolge stehen am Anfang des Moduls.<\/p>\n
        Beim Anlegen der Eigenschaft verwenden wir den Datentyp dbBoolean<\/b>. In einer Datenbank, in der die Option über die Oberfläche umgeschaltet worden war, fanden wir sie mit dem Typ Long<\/b>.<\/p>\n
        Die Zuweisung an die vorhandene Eigenschaft funktioniert dann ohne Änderung.<\/p>\n
        Nach dem Ändern der Eigenschaft holen wir mit CurrentDb<\/b> ein neues Datenbankobjekt. Mit einem vorher geholten Objekt trat in unseren Tests der Fehler 3420 auf.<\/p>\n
        Die Prozedur TabelleVerknuepfen<\/b> verknüpft eine Tabelle oder Sicht und setzt dazu zuerst die Option. Sie entfernt eine vorhandene Verknüpfung gleichen Namens und legt sie neu an (siehe Listing 5). Die Option behält danach den zuletzt gesetzten Wert und gilt für alle weiteren Verknüpfungen.<\/p>\n
        Public Sub <\/span>TabelleVerknuepfen(strName As String<\/span>, strQuelle As String<\/span>, blnErweitert As Boolean<\/span>)\r\n    Dim <\/span>db As <\/span>DAO.Database\r\n    Dim <\/span>tdf As <\/span>DAO.TableDef\r\n    DateTime2OptionSetzen blnErweitert\r\n    Set<\/span> db = CurrentDb\r\n    On Error Resume Next<\/span>\r\n    db.TableDefs.Delete strName\r\n    On Error GoTo<\/span> 0\r\n    Set<\/span> tdf = db.CreateTableDef(strName)\r\n    tdf.Connect = cstrVerbindung\r\n    tdf.SourceTableName = strQuelle\r\n    db.TableDefs.Append tdf\r\nEnd Sub<\/span><\/pre>\n
        Listing 5: TabelleVerknuepfen verknüpft eine Tabelle mit oder ohne erweiterten Datentyp<\/span><\/b><\/p>\n
        Der Aufruf TabelleVerknuepfen “dbo_tblZeitstempelNormal”, “dbo.tblZeitstempel”, False<\/b> erzeugt die Verknüpfung mit den Typen aus Konstellation 3.<\/p>\n
        In unseren Tests stellte auch RefreshLink<\/b> nach dem Umschalten der Option die Verknüpfung auf den passenden Typ um, und zwar in beide Richtungen.<\/p>\n
        Welche Konstellation wann<\/h2>\n
        Die Konstellationen lassen sich so zusammenfassen:<\/p>\n
          \n
        • date, smalldatetime und datetime:<\/b> laufen in unseren Tests unabhängig von der Option ohne Fehler und ohne besondere Maßnahmen<\/li>\n
        • datetime2 mit eingeschalteter Option:<\/b> DLookup<\/b> und andere Domänenfunktionen scheitern mit dem Fehler 13, CDate<\/b>, Format<\/b> und Nz<\/b> in Abfragen mit dem Fehler 3071, die Rechnung mit + 1<\/b> mit dem Fehler 3464, Sekundenbruchteile gehen beim Schreiben verloren<\/li>\n
        • datetime2 mit ausgeschalteter Option:<\/b> die getesteten Funktionen laufen, das Lesen kürzt auf Millisekunden, ein Date<\/b>-Wert mit Sekundenbruchteilen in datetime2(0)<\/b> scheitert<\/li>\n<\/ul>\n
          Für die Praxis ergeben sich diese Empfehlungen:<\/p>\n
            \n
          • Reine Datumswerte speichern wir als date<\/b>.<\/li>\n
          • Zeitstempel für ein Frontend, das nur mit Access arbeitet, speichern wir als datetime<\/b>.<\/li>\n
          • Zeitstempel, die auch andere Anwendungen nutzen oder die feiner als eine Millisekunde sein müssen, speichern wir als datetime2<\/b>. In Access schalten wir dann die Option aus und verknüpfen neu. Access liest die Werte dann nur auf die Millisekunde genau, die feinere Auflösung nutzen nur andere Anwendungen. Wenn Access Werte mit Millisekunden schreibt, verwenden wir datetime2(3)<\/b>.<\/li>\n
          • Wer bereits datetime2<\/b>-Spalten mit eingeschalteter Option hat, nutzt für Abfragen ErweitertZuDatum<\/b>, die Funktionen Year<\/b> und Month<\/b>, eine Sicht mit CAST<\/b> oder Pass-Through-Abfragen.<\/li>\n<\/ul>\n
            Bei der Migration einer Access-Datenbank mit dem SQL Server Migration Assistant lässt sich in den Optionen einstellen, dass Datumsfelder als datetime<\/b> statt als datetime2<\/b> angelegt werden.<\/p>\n
            Zusammenfassung und Ausblick<\/h2>\n
            Wie sich ein Datumsfeld des SQL Servers in Access verhält, hängt vom Datentyp und von einer Option ab.<\/p>\n
            date<\/b>, smalldatetime<\/b> und datetime<\/b> verhalten sich in Access unauffällig. datetime2<\/b> kommt bei eingeschalteter Option als Datum\/Uhrzeit, erweitert<\/b> an, und dann scheitern DLookup<\/b> und viele Funktionen, oder sie liefern ein falsches Datum, wie CDate<\/b> mit vertauschtem Tag und Monat.<\/p>\n
            Bei ausgeschalteter Option und nach dem erneuten Verknüpfen verhält sich auch datetime2<\/b> bis auf zwei Einschränkungen, die Millisekunden beim Lesen und datetime2(0)<\/b> beim Schreiben, wie ein normales Datumsfeld. Die Option lässt sich in der Oberfläche und per VBA umstellen.<\/p>\n
            Wie sich der Datentyp Datum\/Uhrzeit, erweitert<\/b> in einer reinen Access-Datenbank verhält, beschreibt der Beitrag Probleme mit dem Datentyp Datum\/Uhrzeit erweitert<\/b>.<\/p>\n
            Wie wir mit T-SQL aus Access auf den SQL Server zugreifen und welche Unterschiede zwischen Access-SQL und T-SQL bestehen, zeigt der erste Teil der Reihe, T-SQL, Teil 1: Von Jet-SQL zu T-SQL<\/b>.<\/p>\n","protected":false},"excerpt":{"rendered":"
            Wir verknüpfen eine Tabelle des SQL Servers mit Access, öffnen den Direktbereich und lesen mit DLookup ein Datum aus der ersten Zeile. Bei einem Feld liefert der Aufruf den Wert, bei einem anderen scheitert derselbe Aufruf mit der Meldung Typen unverträglich. Beide Felder enthalten ein Datum mit Uhrzeit. Der Unterschied liegt im Datentyp: Der SQL Server kennt mehrere Datentypen für Datum und Uhrzeit, und Access bindet sie je nach Einstellung unterschiedlich ein. Welche Konstellationen ohne Probleme laufen, welche Fehler auftreten und wie wir die Anbindung einrichten, zeigt dieser Beitrag.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662026,66042026,44000006],"tags":[],"yst_prominent_words":[],"class_list":["post-55000521","post","type-post","status-publish","format-standard","hentry","category-662026","category-66042026","category-SQL_Server_und_Co"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t