Programmierung von Datum & Zeit

Datum und Zeit in Programmiersprachen

Zielgruppe sind StudentInnen und ambitionierte Informatik-Amateure

Grundkenntnisse der Informatik und der IT-Entwicklung werden vorausgesetzt.



Datum & Zeit Grundlagen


In jedem Kapitel werden sinngemäß die gleichen Maßstäbe angelegt, die hier kurz angeführt werden.


Die meist verwendeten Systeme zur internen Verwaltung sind

Unix-Timestamp (→ Details): Nullpunkt ist 1970‑01‑01 00:00:00 Weltzeit UTC. Schrittweite 1 Sekunde, Typ daher meist Ganze Zahl (32‑Bit‑Integer, es werden jedoch nur positive Zahlen verwendet). Angabe in → Weltzeit UTC, ohne Zeitzonen und Sommerzeit, daher global eindeutig und portabel.
Aktueller Wert:  0

Unix-Timestamp in Millisekunden: Nullpunkt ist ebenfalls 1970‑01‑01 00:00:00 Weltzeit UTC, jedoch meist als 64‑Bit‑Integer.
Aktueller Wert:  0

Y1900-System (→ Details): Nullpunkt ist 1899-12-30 00:00:00 in der lokalen Zeitzone. Schrittweite 1 Tag.  Daher ist das Datum im ganzzahligen Teil enthalten, die Zeit im Nachkomma-Teil, und der Typ ist 64-Bit Gleitkomma-Zahl. Die Daten sind an die Zeitzone der Erzeugung gebunden.
Aktueller Wert:  0



Zur Messung kurzer Zeiten (ns...µs...ms) werden unabhängig davon meist andere Funktionen geboten. Diese werden hier nicht vorgestellt.



Dazu verwendet jedes System seinen eingebauten Kalender. Für manche Anwendungen (z.B. Büro-(Office)-Programme) ist es wichtig, Grenzen und Besonderheiten des Kalenders zu berücksichtigen.



In diesem Web wird nach Möglichkeit nur das Format des internationalen → Standards ISO‑8601 vorgestellt und verwendet.


Einige Elemente und Regeln weisen jedoch nationale und regionale Besonderheiten auf, z.B. die Namen von Monaten und Wochentagen, die Zählung von Wochentagen und → Kalenderwochen, die → Sommerzeit-Regeln, eigenartige Text-Formate usw.

Datum & Zeit @ Tabellen-Kalkulation


Alle Datum- und Zeit-Daten werden intern im → Y1900-Format verwaltet.
MS-Excel kann derzeit (?) nur den Datum-Bereich 1900‑03‑01 bis 9999‑12‑31 korrekt verwenden.
LibreOffice und OpenOffice können den Bereich der Jahre 1‑32767 verwenden.


Die berechneten Werte werden im jeweils eingestellten Standard-Format angezeigt.
Der Wert ### zeigt an, dass eine Zelle zu schmal zur Anzeige ist: Bewegen sie den Mauszeiger nach oben zum Kopf der Spalte und ziehen sie an einer Grenze zwischen 2 Spalten. Alternativ kann man benachbarte Zellen zu einer größeren Zelle zusammenfassen.
Wenn die Zelle markiert ist, kann man das angezeigte Format ändern (Empfehlung: Standard → ISO-Format).



Die aktuellen Daten, sowohl als Datum+Zeit als auch als Zahlenwerte:
 ABC
1=JETZT() =A1=B1
2 =B1+1/24=B2
3 =B1+1=B3
In den beiden folgenden Zeilen wird demonstriert, wie mit einem Y1900-Wert gerechnet wird:
In Zelle B2 wird eine Stunde (1/24 Tag) addiert, in Zelle B3 ein Tag.
Die berechneten Werte werden in Spalte B als Zahlen und in den Nachbar-Zellen als Datum und Zeit angezeigt.

Das Beispiel sollte mit Taste F9 diese aktuellen Daten anzeigen:
 ABC
1=JETZT()=A1=B1
2 =B1+1/24=B2
3 =B1+1=B3



Jede dieser Funktionen liefert ein Teil-Element von Datum und Zeit als Ganze Zahl:
=JAHR(A1)
=MONAT(A1)
=TAG(A1)
=STUNDE(A1)
=MINUTE(A1)
=SEKUNDE(A1)
Die Funktion SEKUNDE() gibt meist auch dann Ganze Zahlen 0..59 zurück, wenn das Y1900-Argument noch kleinere Werte (z.B. Millisekunden) enthält. (Beispiel am Ende ↓ dieses Kapitels).



Die Funktion ZEIT() liefert aus diesen (genau !) 3 Elementen eine Y1900-Zeit als Gleitkomma-Zahl im Bereich 0...1:
=ZEIT(STUNDE; MINUTE; SEKUNDE)

Die Argumente sollten Ganze Zahlen sein:
  Achtung: Gleitkomma-Werte werden von manchen Programmen abgeschnitten, von anderen sinngemäß berechnet !
Bei STUNDE werden Werte >23 meist ohne Warnung abgeschnitten und ignoriert.
Gleitkomma-Werte von STUNDE oder MINUTE werden je nach Programm und Version abgeschnitten oder sinngemäß interpretiert.

Die Addition der beiden Werte von DATUM() und ZEIT() liefert einen kompletten Zeitstempel vom Typ → Y1900.



Die meisten Standard-Funktionen versuchen, ihr Ergebnis im passenden Format anzuzeigen.
Das gelingt nicht immer. Außerdem ist es möglich, dass ein Ergebnis je nach Programm und Version anders angezeigt wird.

Formatieren sie Datum & Zeit-Werte immer selbst und überlassen sie das nicht dem jeweiligen Programm.

Die Umwandlung einer Zeichenkette (Text, String) in Datum oder Zeit ist heikel. Man kann dazu am eigenen PC die Funktionen DATWERT(), ZEITWERT() verwenden, sollte diese Funktionen jedoch keinesfalls weitergeben: Sie sind nicht zuverlässig sowie von Programm und Version abhängig.
Wenn eine derartige Umwandlung notwendig ist, dann muss man die Ergebnisse vor der weiteren Verwendung unbedingt kontrollieren.


Achten sie auf das rot formatierte Argument, um mit den Funktionen Ergebnisse nach dem in der EU geltenden ISO-Standard zu berechnen:
=KALENDERWOCHE(Y1900;21)
Ein Test muss diese Werte ergeben:
WOCHENTAG(DATUM(2015;1;1);2) = 4
KALENDERWOCHE(DATUM(2015;1;1);21) = 1

Details zu den Themen → Wochentag und Kalenderwoche



In Spalte C wird das gleiche Experiment mit selbst programmierten Formeln ausgeführt.
Das ist aufwändiger, rechnet jedoch mit voller Genauigkeit:
Der Fehler in den Zellen C7:C8 ist Null oder sehr klein. Die Formeln ergeben sich aus der Umrechnung von Tagen, Stunden, Minuten und Sekunden.
Beachten sie, dass die Sekunden in Zelle C5 nicht gerundet sind sondern mit ihren Nachkomma-Stellen angezeigt werden.

In Spalte D wird das gleiche Experiment mit den 'BenutzerInnen-definierten' Funktionen des Basic-Moduls DaTim.bas ausgeführt. Das Modul wird im nächsten↓ Absatz vorgestellt.
Die Programmierung ist genauso einfach wie mit Standard-Funktionen, die Rechnung erfolgt jedoch mit voller Genauigkeit.

Ein Kalkulations-Programm kann prinzipiell auch mit sehr kleinen Zeit-Differenzen rechnen.
Die realistische → Grenze der Genauigkeit (Auflösung) liegt bei ca. 1µs. Man kann daher (mit geeigneten Formeln) noch bequem mit Millisekunden (ms) rechnen.


 ABCD
1 StandardFormelnBasic
2Jetzt=REST(JETZT();1) =REST(JETZT();1)=REST(JETZT();1)
3Stunden=STUNDE(B2)=C2*24=STUNDE(D2)
4Minuten=MINUTE(B2) =REST(C3;1)*60=MINUTE(D2)
5Sekunden=SEKUNDE(B2) =REST(C4;1)*60=DaTim_Seconds(D2)
6Zeit=ZEIT(B3;B4;B5) =(GANZZAHL(C3)+GANZZAHL(C4)/60+C5/3600)/24 =DaTim_HMS_toTime(D3;D4;D5)
7Differenz=B6-B2=C6-C2=D6-D2
8 in Sekunden=B7*86400=C7*86400=D7*86400


Das Basic-Modul bietet die Funktion DaTim_HMS_toTime() als Alternative zur Standard-Funktion ZEIT()
Die Funktion akzeptiert die Argumente Stunden, Minuten, Sekunden und optional zusätzlich Millisekunden.
Alle Argumente sind optional. Wenn ein Argument nicht angegeben ist, dann wird sein aktueller Wert eingesetzt. Gleitkomma-Argumente werden nicht abgeschnitten sondern sinngemäß interpretiert.
Beispiel: Das Argument Stunden=3.5 ergibt 3 Stunden und 30 Minuten.

Die Funktion DaTim_Seconds() dient als Alternative zur Standard-Funktion SEKUNDE()
Sie akzeptiert ein Y1900-Argument und gibt die Anzahl der Sekunden als echte Gleitkomma-Zahl zurück, d.h. inklusive allfälliger Millisekunden.

Die Funktion DaTim_MilliSeconds() dient zur Ergänzung der Standard-Funktionen. Sie akzeptiert ein Y1900-Argument und gibt die Anzahl der Millisekunden zurück. Die Genauigkeit ist allerdings auf ±1 ms begrenzt.

Datum & Zeit @ Basic


Programmierung von Basic-Funktionen: LibreOffice-Calc, MS-Excel, OpenOffice-Calc, Portable Funktionen


Der für Y1900-Werte vorgesehene Daten-Typ Date ist in der Praxis leider nicht zuverlässig portabel. Hier wird der äquivalente Typ Double verwendet. Einziger Nachteil: Man muss das gewünschte Format in der Ergebnis-Zelle selbst einstellen.

Details und praktische Beispiele bietet die Seite → Datum und Zeit @ Basic. Die dort vorgestellten Beispiele kann man als Basic-Modul herunterladen und mit jedem gängigen Tabellen-Kalkulations Programm verwenden.



Function datest(arg)
Dim x As Double
x = arg
x = Date
MsgBox "Date=" & x
x = Time
MsgBox "Time=" & x
x = Now
MsgBox "Now=" & x
x = Timer
MsgBox "Timer=" & x
End Function



Man kann die Funktion in jeder Zelle eines Kalkulations-Programms anwenden, z.B.
=y1900_to_ymdhms(A1)
wenn sich in der als Argument angegebenen Zelle ein Y1900-Zeitstempel befindet, z.B:
A1 = JETZT()
Die Funktion erzeugt einen Text, zeigt ihn in einem Meldungsfenster an und gibt ihn an das Kalkulations-Programm zurück.
Die Funktion wird (nur dann) neu ausgeführt, wenn sich das Argument (hier der Wert in Zelle A1) geändert hat. Die Funktionen =JETZT() und =ZUFALLSZAHL() werden auch mit Taste F9 neu berechnet.



Function ymdhms_to_y1900(Optional yy As Variant, _
Optional mo As Variant, Optional dd As Variant, _
Optional hh As Variant, Optional mi As Variant, _
Optional ss As Variant) As Double
Dim y1900 As Double
If (IsMissing(yy)) Then yy = Year(Date)
If (IsMissing(mo)) Then mo = 1
If (IsMissing(dd)) Then dd = 1
If (IsMissing(hh)) Then hh = 0
If (IsMissing(mi)) Then mi = 0
If (IsMissing(ss)) Then ss = 0
y1900 = DateSerial(yy, mo, dd)
y1900 = y1900 + (hh + (mi + ss / 60) / 60) / 24
ymdhms_to_y1900 = y1900
End Function
Darüber hinaus rechnet diese Variante mit maximaler Genauigkeit: Allfällig angegebene Sekunden-Bruchteile werden weder abgeschnitten noch gerundet sondern korrekt verarbeitet.


Standard String-Funktionen sind zuverlässig:
Function y1900_to_iso(mydate) As String
Dim iso As String
iso = Year(mydate)
iso = iso & "-" & Right("0" & Month(mydate), 2)
iso = iso & "-" & Right("0" & Day(mydate), 2)
iso = iso & " " & Right("0" & Hour(mydate), 2)
iso = iso & ":" & Right("0" & Minute(mydate), 2)
iso = iso & ":" & Right("0" & Second(mydate), 2)
y1900_to_iso = iso
End Function
Funktionen, die vom Betriebssystem und dessen Konfiguration abhängen, sind nichtverlässlich.

Datum & Zeit @ Javascript



Ein Zeitpunkt wird allerdings nicht als Zahl verwaltet sondern als Objekt vom Typ Date
Es stehen Methoden zum Lesen und Schreiben aller gewünschten Daten-Elemente zur Verfügung.



Man kann die Standard-Elemente (Jahr, Monat-1, Tag, Stunde, Minute, Sekunde) als Argumente angeben, z.B. Heute 00:00:00
var dt = new Date(yy,mo,dd);
Dabei ist zu beachten:
Man muss mindestens die ersten 3 Argumente angeben. Weitere Elemente sind optional und werden =0 gesetzt, wenn sie nicht angegeben werden.
Die Monate werden beginnend mit Jänner⇒0 gezählt.



Zur Rückgabe eines neu erzeugten Objekts mit bestimmten Eigenschaften verwendet man klassische Funktionen, z.B. eine mögliche selbst programmierte Funktion
var DateObject = TodayMidnight();
Geben sie Objekte nicht als Argumente an Funktionen weiter, z.B.
var Anything = BadFunction(Object);



Weitere Lese-Methoden:
var DayofWeekNr = dt.getDay();
liefert die US-Nummer des Wochentags, beginnend mit Sonntag=>0 (!) bis Samstag=>6

Die Methode getTime() gibt den UNIX-Timestamp des Objekts in ms zurück:
var uts_ms = dt.getTime();

Berechnung der Differenz zwischen Lokalzeit und Weltzeit für einen beliebigen Zeitpunkt:
var dif_stunden = dt.getHours() - dt.getUTCHours();


Beispiele: → Tag der Woche nach ISO-Standard, → Kalenderwoche nach ISO-Standard, Kalenderwoche nach US-Standard, Schaltjahr, Halbjahr, Quartal, usw.



Es gibt weitere 6 Methoden
setUTCFullYear() ... setUTCSeconds()
um die Elemente in Weltzeit UTC zu ändern.

Man kann auch einen UNIX-Timestamp in ms angeben, z.B. von heute Mitternacht:
dt.setTime(?);

Es gibt keine Methode zum Schreiben der Wochentag-Nummer - diese wird immer aus dem Datum berechnet und ist daher nur lesbar (readonly).


Beispiele: Mitternacht, Monats-Anfang, Monats-Ende, Jahres-Anfang, Oster-Datum, Datum der Sommerzeit-Umstellung, usw.



Eine neue Methode wird dem Prototyp des Date-Objekts zugeordnet und ist danach auf alle Date-Objekte anwendbar:
Date.prototype.tomyISO = function(){
var iso = this.getFullYear().toString();
iso += '-' + s2(this.getMonth()+1);
iso += '-' + s2(this.getDate());
iso += ' ' + s2(this.getHours());
iso += ':' + s2(this.getMinutes());
iso += ':' + s2(this.getSeconds());
return iso;
function s2(n) {return (n<10 ? '0' : '')+n.toString();}
};



Date.prototype.getWochentag=function(){
var wta = new Array('Sonntag','Montag','Dienstag',
'Mittwoch','Donnerstag','Freitag','Samstag');
var dow = this.getDay();
return wta[dow];
};

Nach dem gleichen Muster kann man auch eine Methode zur Rückgabe der deutschen Monats-Namen programmieren (→ Umlaute).



Schlechtes Beispiel:
var now = new Date();
var mid = now;
mid.setHours(0); mid.setMinutes(0); mid.setSeconds(0);
dif = (now - mid) / 1000;
Ergebnis:
dif = 0

Gutes Beispiel:
var now = new Date();
var mid = new Date(now.getTime());
mid.setHours(0); mid.setMinutes(0); mid.setSeconds(0);
dif = (now - mid) / 1000;
Ergebnis:
dif = ?

Aufgabe für Fortgeschrittene: Programmieren sie eine Methode zur Erzeugung eines Clones, die sich so verwenden lässt:
var clone = now.Clone();
Verbessern sie die Methode so, dass man einen Clone optional auch mit einem vorgegebenen zeitlichen Abstand (in Sekunden) erzeugen kann, z.B.
var clone1h = now.Clone(3600);



Live-Messung sehr kurzer Zeiten:
try{
var t0 = performance.now();
testprogramm();
var t1 = performance.now();
var dus = (t1-t0)*1000;
alert('Arbeitszeit=' + dus + 'us');
}
catch(e) {alert('Fehler-Meldung');}

Function testprogramm() {
var z = Math.random();
z = Math.log(z+1);}
}
Live-Ausgabe:
???


In diesem Web werden für Datum und Zeit die Methoden und Funktionen dieser ↗ Javascript-Bibliothek verwendet

Datum & Zeit @ PHP


Die Funktion time() liefert den aktuellen Zeitstempel:
$jetzt = time();
ergibt
$jetzt = ?



Weitere Elemente erfordern kleine Änderungen:

Das Array-Element 'wday' liefert die Nummer des Wochentags nach US-Regeln, d.h. von So⇒0 bis Sa⇒6
Die Nummern 1...6 entsprechen dem EU-Standard, zum Sonntag muss man jedoch +7 addieren.
Details zu Wochentags-Nr und Kalenderwoche

Das Array-Element 'yday' liefert (nur) bei Addition von +1 die Nummer vom Tag‑des‑Jahres nach → Standard ISO‑8601.



Jedes nicht angegebene Argument wird durch die aktuellen Daten ersetzt.

Beispiele:
$jetzt = mktime();
$heute = mktime(0,0,0);
$monat_anfang = mktime(0,0,0,0,1,0);
$jahr_anfang = mktime(0,0,0,1,1);



Beispiel:  So kann man Datum und Zeit als Text im Standard-Format ausgeben:
$jetzt = time();
$s = date('Y-m-d H:i:s',$jetzt);
print $s."<br/>\n";
$s = strftime('%Y-%m-%d %H:%M:%S',$jetzt);
print $s."<br/>\n";
Beide print-Anweisungen erzeugen den gleichen Ausgabe-Text:
?



In der Konfigurations-Datei php.ini sind beim Modul Date auch die geografischen Koordinaten des (Server)-Standorts einstellbar. Bei korrekter Angabe wird u.a. der Sonnenstand (Aufgang, Untergang) richtig berechnet. Die geografischen Koordinaten kann man u.a. aus Wikipedia oder GoogleEarth entnehmen, z.B. für Wien:
date.default_latitude = 48.2086
date.default_longitude = 16.3729

Datum & Zeit @ Perl


Die Funktion time() liefert den aktuellen Zeitstempel:
my $jetzt = time();
ergibt
$jetzt = ?



Auf Windows sollte man daher in Perl-Programmen nur die Weltzeit UTC verwenden und die Differenz zur Lokalen Zeitzone bei Bedarf selbst berechnen.
In naturwissenschaftlichen oder technischen Anwendungen wird meist die Weltzeit UTC verwendet, daher ist die Lokalzeit ohnehin oft uninteressant.



  Den Monat erhält man durch Addition von +1 zum Element mit dem Index [4], das Jahr durch Addition von +1900 zum Element mit dem Index [5].
Der Tag der Woche wird nach US-Regeln angegeben (So⇒0 bis Sa⇒6).
Das Element [8] gibt an, ob Sommerzeit (Daylight Savings Time) gilt oder nicht. Der Wert (-1 bedeutet 'unbekannt', 0⇒'Normalzeit' und 1⇒'Sommerzeit') scheint jedoch unverlässlich zu sein.

Die Funktion gmtime() gibt die Daten in Weltzeit UTC zurück, die Funktion localtime() in der lokalen Zeitzone (CET, MEZ).

Die Funktion gmtime() arbeitet in allen Systemen zuverlässig. Die Funktion localtime() gibt in den meisten Windows-Versionen die Differenz zur Weltzeit nicht richtig wieder. Es wird daher empfohlen, diese Differenz auf Windows → selbst zu berechnen.



Hilfs-Funktion:
Die globale Variable $tzoh bezeichnet die Differenz der lokalen Zeitzone zur Weltzeit UTC in Stunden. Der Wert für Mitteleuropa ist =1 (unabhängig von der Sommerzeit !).
Die Variable $tzok gibt an, ob man der Zeitzone vertrauen kann (Linux) oder nicht (Windows).
use POSIX;
my $tzoh = 1;   # CET, MEZ
my $tzok = 1;   # Linux=>1, Windows=>0
if($^O=~m/mswin/i) {$tzok=0;}

sub ymdhms_to_uts {
my($yy,$mo,$dd,$hh,$mi,$ss)=@_;
my $uts=mktime($ss,$mi,$hh,$dd,$mo-1,$yy-1900,0,0,0);
if(!$tzok) {$uts+=$tzoh*3600;}
return $uts;
}
Anwendung (Standard-Elemente in Weltzeit UTC !):
my $uts = ymdhms_to_uts(2000,1,2,12,12,12);
Ergebnis:
$uts = 1234567890


Beispiel:  So kann man Datum und Zeit als Text im Standard-Format ausgeben:
use POSIX;
my $jetzt = time();
my @dta = gmtime($jetzt);
my $iso = strftime('%Y-%m-%d %H:%M:%S',@dta);
print $iso."<br/>\n";
Die print-Anweisung erzeugt diesen Ausgabe-Text in Weltzeit UTC:
?



Funktionen zum Thema Datum & Zeit findet man u.a. in den Modulen Astro, Date, DateTime, Time, die selbst aus zahlreichen Sub-Modulen bestehen.
Details zur → Berechnung der Kalenderwoche mit Modul DateTime

Datum & Zeit @ SQL



In diesem Kapitel werden einige Experimente vorgestellt, die man auch mit minimalen Zugangs-Rechten ausführen kann.
Eine Voraussetzung für die Experimente dieses Kapitels ist der Zugang zu einem Datenbank-Server im eigenen Intranet oder im Internet.

Es gibt auch PC-Datenbank-Programme (z.B. LibreOffice-Base, MS-Access, OpenOffice-Base) zur Verwendung am eigenen Arbeits-PC. Die gezeigten Beispiele sind prinzipiell auch damit ausführbar. Das ist allerdings mühsam, weil diese Programme zur Bedienung mit einem eigenen User-Interface optimiert sind und SQL mehr oder weniger versteckt ist.

Cloud-Lösungen sind eine moderne aber problematische Variante: DB-Server und Interface-Programme befinden sich ebenso am entfernten Server des Anbieters wie die eigenen Daten. Solche Lösungen werden normalerweise nur über Miet-Verträge angeboten und es gelten die Rechte am Standort des Anbieters.



Die Weltzeit UTC lässt sich bei Bedarf in jede andere Zeitzone umrechnen. Da sich die Regeln (z.B. der → Sommerzeit) gelegentlich ändern, muss man sogar je nach Datum unterschiedliche Regeln zur Umrechnung verwenden.

Wenn man Daten in der lokalen Zeitzone speichert, dann werden sogar einfache Zeit-Differenzen falsch berechnet, wenn dabei eine Umstellung von/auf Sommerzeit überschritten wird.



Eingabe und Ausgabe der Typen DATE, DATETIME und TIME erfolgen ohne weitere Maßnahmen als Text (String) im Standard → ISO‑8601 Format, z.B. (in Weltzeit UTC):
update test set dat='2000-01-02' where pk=12;
update test set tim='12:34:56' where pk=23;
update test set datim='2000-01-01 12:34:56' where pk=34;



Zur Eingabe und Ausgabe wird ein Timestamp als positive ganze Zahl verwendet. Das ist für manche Anwendungen (Rechnungen, Zeit-Differenzen) praktischer als ein String.

Darüber hinaus bieten die beiden genannten Datenbank-Programme die Funktion unix_timestamp() zur Umwandlung von DATETIME nach TIMESTAMP und from_unixtime() zur Umwandlung von TIMESTAMP nach DATETIME


Gekürztes Beispiel (MariaDB oder MySQL) einer Tabellen-Definition:
create table creadat (uts timestamp not null default CURRENT_TIMESTAMP);
Das Feld uts vom Typ timestamp wird angelegt, der aktuelle UNIX-Timestamp wird bei der Erzeugung in jeden neuen Datensatz eingetragen.

Gekürztes Beispiel einer Tabellen-Definition:
create table modifdat (uts timestamp not null DEFAULT CURRENT_TIMESTAMP on update CURRENT_TIMESTAMP)
In das Feld uts wird bei jeder Änderung der Daten der aktuelle Zeitstempel eingetragen.
Die Anweisung CURRENT_TIMESTAMP kann man nur in 1 Feld jeder Tabelle eintragen.

Anregung für Fortgeschrittene:
Wie könnte man sowohl das Erzeugungs- als auch das Änderungs-Datum speichern ?
Wie könnte man die unbefugte Änderung der Zeitstempel verhindern ?



mysql> select curdate() as date, curtime() as time;
+------------+----------+
| date       | time     |
+------------+----------+
| 2000-01-02 | 12:34:56 |
+------------+----------+
mysql> select now() as datetime;
+---------------------+
| datetime            |
+---------------------+
| 2000-01-02 12:34:56 |
+--------------------------+
mysql> select unix_timestamp(now()) as UTS, CURRENT_TIMESTAMP as ISO;
+----------------------------------+
| UTS        | ISO                 |
+----------------------------------+
| 1234567890 | 2000-01-02 12:34:56 |
+----------------------------------+



Darüber hinaus werden einige Funktionen geboten, die spezielle Elemente zurückgeben, z.B.
weekday()+1, dayofyear, quarter(), time_to_sec()

Tipp: Alle Funktionen, die einen Kalender brauchen (so wie die hier genannten) werden besser im User-Interface (PHP-Programm) ausgeführt.



Die Anwendung ist allerdings heikel, weil sich bei Differenz-Rechnungen aus der Struktur unseres Gregorianischen Kalenders erstaunlich viele Sonderfälle ergeben, und weil die Datenbank-Programme ohne besondere Maßnahmen meist US-Regeln anwenden.
Konsultieren sie die Dokumentation und experimentieren sie selbst, bevor sie diese Funktionen verwenden.
Beispiel: → Berechnung der und Suche nach der Kalenderwoche



Es ist daher nicht empfehlenswert, die (durchaus vorhandenen) SQL-Funktionen zur Text-Formatierung anzuwenden: Das überlässt man besser den User-Interface Programmen (z.B. in Java oder PHP).

Datum & Zeit @ Konsole


Hier werden nur einige einfache Beispiele angeführt.
Wer sich mit Systemverwaltung beschäftigt, muss sich ohnehin intensiver in das umfangreiche Thema einarbeiten.



Einige Beispiele der Anwendung (ohne Ausgabe):
# date --iso-8601
# date "+%F"
# date "+%Y-%m-%d"
# date "+%T"
# date "+%H:%M:%S"
# date "+%F %T"
UNIX-Timestamp:
# date "+%s"


Unmittelbar danach kann man die neue Anweisung an der Konsole verwenden, um Datum ä Zeit im Standard-Format anzuzeigen:
# isodate


Mit den eigenen User-Rechten kann man den Text an das Ende der Datei .bashrc im eigenen home-Verzeichnis schreiben.
Erzeugen sie eine einfache Text-Datei mit diesem Namen, falls die Datei noch nicht existiert.

Die Anweisung isodate ist dann nach der nächsten eigenen Anmeldung verfügbar, nicht jedoch für andere User.



C:\> date /T
2000-01-02
C:\> time /T
12:34
C:\> echo %time:~0,8%
12:34:56


Meist ist das 'Kurze' Datum auf dieses Format eingestellt:
TT.MM.JJJJ
Empfehlung: Ändern sie es auf das → Standard Format
JJJJ-MM-TT
und das Trennzeichen von Punkt auf - Minus-Zeichen.


Wenn sie das 'Kurze Datum' auf das Standard-Format JJJJ‑MM‑TT eingestellt haben, dann kopieren sie diesen Text in die Text-Datei
@echo off
echo %date% %time:~0,8%
@echo on
Wenn sie das Format TT.MM.JJJJ bevorzugen, dann lautet die 2. Zeile:
echo %date:~6%-%date:~3,2%-%date:~0,2%

Unmittelbar danach ist die neue Anweisung für alle User verfügbar:
C:\> isodate


Die moderne Variante Powershell ist zwar sehr leistungsfähig, wird jedoch fast nur von Windows-Insidern verwendet. Neuerdings wird auch eine abgespeckte Variante der mächtigen Linux-Konsole integriert, aber:  Warum sollte man einen teuren Karren mit einem Motor ausrüsten, wenn man kostenlos ein Auto mit Motor haben kann ?


Die Auswertung, Suche, Zusammenfassung, ... der Log-Dateien ist eine typische Verwaltungs-Arbeit an jedem Server.

Wenn man dazu (teilweise) eigene Programme (z.B. Java, Perl, PHP, ...) verwendet, dann benutzt man dazu fast immer die Technologie der Regulären Ausdrücke (RegExp).
Diese ist umfangreich, hat fast den Charakter einer eigenen Programmiersprache und wird von allen modernen Programmiersprachen unterstützt.