Om te beginnen wil ik het hebben over het onderwerp in welk formaat het beter is om datums in de database op te slaan: TIJDSTEMPEL of DATUM TIJD... Deze kwestie is aan de orde gesteld en wordt vele malen aan de orde gesteld op forums, blogs, enz. Maar om u niet meteen naar de zoekmachines te sturen, zal ik het in eenvoudige bewoordingen proberen en met een voorbeeld het verschil laten zien. Een type DATUM TIJD- slaat de datumwaarde op in het formaat "JJJJ-MM-DD UU: MM: SS" en is niet afhankelijk van de tijdzone. TIJDSTEMPEL- slaat de tijdstempel op, d.w.z. het aantal seconden sinds 1 januari 1970. MySQL converteert deze waarden, rekening houdend met de huidige tijdzone, zowel bij het schrijven naar de database als bij het uitvoeren ervan. Wat betekent dit ...
U heeft bijvoorbeeld zojuist een artikel aan de database toegevoegd, in uw agenda heeft u 1 januari 2014 en op de klok - 01:00 uur. Als het datumveld van het type DATETIME is, ziet iedereen die de site bezoekt deze specifieke datum en tijd, ongeacht hun woonplaats. Alles lijkt in orde te zijn, maar de gebruiker ( laten we hem "Bill G" noemen), die ergens in New York woont, is nog niet aangekomen op 1 januari - zijn 31 december 2013 en de klok geeft 19:00 uur aan. Hij is een beetje verbijsterd, want feest vieren Nieuwjaar hij is nog niet begonnen, maar hij lijkt nu al "een artikel uit de toekomst" te zijn;) Dit zal niet gebeuren met het TIMESTAMP-type, aangezien de output houdt rekening met de tijdzone.
"Alles is duidelijk!", zeg je en verander snel alle velden voor datums in het TIMESTAMP-type, en Bill G zal opgelucht ademhalen, maar niet voor lang. Bij het registreren op uw site heeft Bill de datum en tijd van zijn geboorte aangegeven. Terwijl hij de wereld rondreist, kijkt hij altijd naar uw site en ontdekt hij met afschuw dat de tijd, en soms de datum van zijn geboorte, altijd anders is, omdat worden weergegeven rekening houdend met de tijdzone waarin het zich bevindt dit moment... Ja, in dit geval speelde het type TIMESTAMP een wrede grap.
We trekken een conclusie - voor bepaalde taken moet u het juiste type veld selecteren of de opname / uitvoer regelen, afhankelijk van het gewenste resultaat.
Overgaan naar populaire problemen en opties voor hun oplossing. Selecteer records in het bereik van opgegeven datums, d.w.z. per bepaalde periode tijd.
SELECTEER * UIT `table_name` WHERE` date_field` TUSSEN "2014-07-05" EN "2014-07-15" ORDER OP `date_field`;
Hiermee worden alle records geselecteerd waarvan de datums in het veld "date_field" in het bereik liggen van 5 juli 2014 tot 15 juli 2014, inclusief de opgegeven datums. We mogen niet vergeten dat datums in MySQL standaard worden opgeslagen in het formaat "JJJJ-MM-DD HH: MM: SS" en dienovereenkomstig is het formaatmasker "% Y-% m-% d% H:% i: % s" (standaard ISO). En hoe het probleem op te lossen als de datum niet in dit formaat komt? Laten we de PHP-opties achterwege laten en kijken hoe dit in het verzoek zelf kan worden gedaan. En voor dergelijke doeleinden hebben we de functie nodig STR_TO_DATE ()... Syntaxis: STR_TO_DATE (str, formaat), waar " str"is een datumstring en" formaat"- het bijbehorende formaat. Laten we testen:
SELECT STR_TO_DATE ("31-12-2013", "% d.% M.% Y"); / * "2013-12-31" * / SELECT STR_TO_DATE ("31/12/13 13:50", "% d /% m /% y% H:% i"); / * "2013-12-31 13:50:00" * /
Het resultaat van de uitvoering is een datum in het formaat dat standaard wordt gebruikt in MySQL. Dat wil zeggen, we moeten niet het formaat specificeren waarin we de uitvoerdatum willen ontvangen, maar het formaat waarin we de datum voor verwerking verstrekken. Met behulp van deze methode zou ons bericht hierboven er zelfs als volgt uit kunnen zien:
SELECT * FROM `table_name` WHERE` date_field` TUSSEN STR_TO_DATE ("07/05/2014", "% d.% M.% Y") EN STR_TO_DATE ("15 juli 2014", "% M% d,% Y ") BESTELLEN OP `datum_veld`;
Aangezien we het probleem van het formatteren van datums hebben aangeroerd, laten we eens kijken hoe we de datum kunnen krijgen bij het nemen van monsters in het formaat dat we nodig hebben, aangezien velen zijn veel meer gewend aan het zien van "31-12-2014" of "31 december 2014" dan "2014-12-31". Gebruik voor dergelijke doeleinden de functie DATUMNOTATIE ()... Syntaxis: DATE_FORMAT (datum, formaat), waar " datum"is een datumstring en" formaat"- het formaat waarnaar moet worden geconverteerd" datum". In tegenstelling tot de functie STR_TO_DATE () specificeren we zelf het gewenste uitvoerformaat, maar de datum moet worden opgegeven in ISO-formaat, dwz" JJJJ-MM-DD HH: MM: SS ".
SELECT DATE_FORMAT ("2014-12-31", "% d.% M.% Y"); // 31.12.2014 SELECT DATE_FORMAT ("2014-12-31", "% d% M% Y"); // 31 december 2014
Als we in realtime met u zouden communiceren, zou op deze plek hoogstwaarschijnlijk onmiddellijk de vraag volgen: " En hoe de maand in een andere taal weer te geven: toch Oekraïens, Russisch of Chinees?"Het is heel eenvoudig - om de vereiste landinstelling in te stellen. En u kunt dit doen in config-bestand MySQL (my.cnf), of gewoon een vraag van PHP, na verbinding met de database en voor de hoofdvragen:
SET lc_time_names = ru_RU; SELECT DATE_FORMAT ("2014-12-31", "% d% M% Y"); // resultaat: 31 december 2014 // als je wilt, kun je "g." toevoegen. of "jaar" SELECT DATE_FORMAT ("2014-12-31", "% d% M% Y jaar"); // resultaat: 31 december 2014
Schoonheid! ;) En nog een paar voorbeelden van queries die ook vaak nodig zijn, maar voor verdoving zorgen bij beginners.
// Selecteer records voor de huidige dag SELECT * FROM `table_name` WHERE` date_field`> = CURDATE (); // Alle records voor gisteren SELECT * FROM `table_name` WHERE` date_field`> = DATE_SUB (CURDATE (), INTERVAL 1 DAG) EN `date_field` NU () - INTERVAL 30 DAGEN; // Selecteer alles voor een specifieke maand van het huidige jaar (bijvoorbeeld de maand mei) SELECTEER * FROM `table_name` WHERE YEAR (` date_field`) = JAAR (NU ()) AND MAAND (`date_field`) = 5 ; // of voor de maand mei, maar in 2009 SELECTEER * FROM `table_name` WHERE YEAR (`date_field`) = 2009 AND MAAND (`date_field`) = 5;
Ik heb geen zin in een gedetailleerde beschrijving van de MySQL-functies die in de voorbeelden worden gebruikt. ze zijn intuïtief en voor iemand die zelfs maar een beetje bekend is met Engels, zal het niet moeilijk zijn om te begrijpen dat bijvoorbeeld een functie MAAND () geeft de maand van de datum terug, JAAR ()- haar jaar, en DAG () (of een synoniem voor DAYOFMONTH ()) - dag. trefwoord INTERVAL- dient voor rekenkundige bewerkingen op datums, hun verandering.
SELECTEER "2014-07-07 23:59:59" + INTERVAL 1 SECOND; // resultaat: 2014-07-08 00:00:00 SELECTEER "2014-07-07 23:59:59" + INTERVAL 1 DAG; // resultaat: 2014-07-08 23:59:59 // hetzelfde. maar met behulp van de functie DATE_ADD () SELECT DATE_ADD ("2014-07-07 23:59:59", INTERVAL 1 DAG); // 2014-07-08 23:59:59 // Als u niet wilt optellen, maar aftrekken, SELECT DATE_SUB ("2014-07-07 23:59:59", INTERVAL 1 DAG); // 2014-07-06 23:59:59 // of zo SELECTEER gewoon "2014-07-07 23:59:59" - INTERVAL 1 DAG; // 2014-07-06 23:59:59
Dit zijn niet alle functies om met datums te werken, en ik zou je aanraden om ze ter informatie op de officiële website door te nemen om te weten of ze bestaan als zich een ongebruikelijke situatie voordoet. Maar ik wil hopen dat zelfs dit klein overzicht De MySQL-datumfuncties in dit artikel helpen u door de situatie te navigeren en de juiste beslissing te nemen. Als je nog steeds problemen hebt, stel dan vragen in dit onderwerp of in het gedeelte "Je vraag". Laten we het samen uitzoeken ;)
MySql is niet alleen een aantrekkelijk systeem voor het organiseren van gegevensopslag, maar ook een UITSTEKENDE INFORMATIEVERWERKING TOOL.
Vandaag zullen we het werk analyseren met mysql-functies: Datum, DatumTijd. Ik zal ook praten over de mysql-methoden die worden gebruikt om een string naar een datum te converteren. In het algemeen, verschillende benaderingen voor het oplossen van problemen met verbonden datums in de mysql DBMS.
Het probleem.
Stel dat u een systeem schrijft voor het verzenden van sms-meldingen naar uw klantenbestand.
Tabel 1. tbl_clients * - een tabel met klantgegevens (volledige naam en geboortedatum), gegevens over de hoeveelheid, soort goederen en de status van aanvraagverwerking.
Tabel 2. tbl_sms - tabel met sms-statussen en client-id-koppelingen met de datum waarop de status is ontvangen.
Dichter bij de gevechten. We wapenen ons met ingebouwde functies.
Er zijn verschillende vermeldingen in de tbl_sms-tabel voor één Id_clients, met verschillende statussen en het tijdstip van ontvangst. Bijvoorbeeld:
Stel dat de baas een lijst wil met de laatste statussen van alle klanten. U kunt het probleem snel oplossen met behulp van ingebouwde functies. De sql-query voor zo'n geval ziet er als volgt uit:
SELECTEER * VANUIT tbl_sms ts JOIN (SELECT Id_clients, max (Date_status) as max_dat VAN tbl_sms GROEP DOOR Id_clients) ts_max ON ts. id_clients = ts_max. id_clients en ts. Date_status = ts_max.max_dat;
Het resultaat van de query is een selectie van records met de maximale datum voor elke Id_clients:
Het verzoek is complex, ik begreep het zelf de eerste keer niet, maar ik zal het proberen uit te leggen. In de query voegen we twee tabellen samen. De eerste tbl_sms - bevat alle gegevens zonder rekening te houden met voorwaarden, om zo te zeggen in "ruwe vorm". De tweede tabel is het resultaat van de query
SELECT Id_clients, max (Date_status) als max_dat FROM tbl_sms GROEP DOOR Id_clients;
naar dezelfde tbl_sms met behulp van MAX functies() en groeperen op het veld Id_clients.
In de tweede tabel groeperen we de records op id_clients met behulp van de GROUP BY Id_clients-clausule. Dat wil zeggen, nu hebben we één record (hoewel er meerdere records zijn voor één id_clients-waarde in de tabel) - dit is één waarde van het id_clients-veld. In SELECT gebruiken we de MAX ()-functie, waarvan het resultaat een selectie is van de maximale waarde die in het tabelveld is vastgelegd. Ter referentie is er in de mysql DBMS omgekeerde functie MIJN (). Als resultaat krijgen we in een query met de functie MAX () maximale waarde Date_status velden voor elke waarde in het id_clients veld.
Tot slot, door records te selecteren die aan de volgende voorwaarden voldoen: “ON ts. id_clients = ts_max. id_clients en ts. Date_status = ts_max.max_dat ”, krijgen we het gewenste resultaat.
De baas is blij. Maar dan, een accountant komt en zet nieuwe taak: "Het is noodzakelijk om alle statussen te selecteren die we alleen voor 10/05/2014 hebben ontvangen."
We schrijven het volgende verzoek:
SELECT * FROM tbl_sms WHERE Date_status> ’2014-10-05 00:00:00’ en Date_status<’2014-10-05 23:59:59’ ;
Aangezien het gegevenstype van het veld Datum_status DATETIME is, stellen we daarom de volgende voorwaarden in: waarde Van 00:00 tot 23:59 op 10/05/2014 — dit interval omvat een dag of 24 uur. Let op de vorm van het vastleggen van de datum. In het gegevenstype Datum in mysql vertegenwoordigen we de datum in het volgende formaat Jaar (4) -Maand (2) -Dag (2). Als het "status"-veld de DATE-indeling had, zou de query de volgende vorm hebben:
SELECTEER * VANUIT tbl_sms WHERE Date_status = "2014-10-05";
We hebben de taak van een accountant geregeld. De rapporten zijn ingediend. Laten we nu eens kijken naar het werken met datums in mysql vanuit een andere hoek - als de datum wordt weergegeven als een string. Soms gebeurt het…
Datum in het type VARCHAR of CHAR ... Wat moet ik doen? Met behulp van de tekenreeksconversiefunctie.
Zelf ben ik meer dan eens een soortgelijk probleem tegengekomen. Het feit is dat als je een datum in de vorm van een string hebt, alle hierboven beschreven zoekopdrachten nutteloos worden. U moet bijvoorbeeld alle klanten selecteren waarvan de veldwaarde Date_Zap in een bepaalde datumperiode ligt. Noem niet alle data... Natuurlijk niet. Er is altijd een uitweg en ingebouwde functies helpen ons weer uit de brand. Voor zo'n taak in mysql is er de STR_TO_DATE () functie.
Zoals de naam al doet vermoeden, converteert de functie een string naar een datum. De argumenten van de functie STR_TO_DATE zijn de datum in het gegevenstype CHAR of VARCHAR en de datumnotatie YOU ARE PASSING.
U voert bijvoorbeeld een query uit op de tabel tbl_clients:
SELECT Date_Zap, STR_TO_DATE (Date_Zap, '% d.% M.% Y') VANAF tbl_clients WHERE id_clietns = '345';
Het resultaat van het gebruik van de STR_TO_DATE () functie:
Zoals je kunt zien, krijgen we van het gebruikelijke datumformaat de datum in het mysql-formaat. Een paar opmerkingen over de aanvraag:
- Als je niet helemaal zeker bent van het resultaat van de functie, doe het dan altijd zo om de veldwaarden voor en na transformatie te zien. Het zal je zenuwen besparen.
- Als je het resultaat bijvoorbeeld in een programma gaat gebruiken en specifiek naar de veldnaam verwijst, dan raad ik je aan om de lange naam “STR_TO_DATE (Date_Zap,'% d.% M.% Y '”) te vervangen, bijvoorbeeld, aan de naam Data_Mysql hiervoor wijzigen we de query
Het resultaat van het gebruik van de functie convert string to date format mysql (STR_TO_DATE ()):
Datumweergave in woorden.
Het is vaak nodig dat bij het maken van rapporten uit een database (mysql) de datum op de documenten in het formaat "Dag Maand in woorden Jaar" staat. Bijvoorbeeld: er is "21.10.2014", maar je hebt "21 oktober 2014" nodig. Toen ik tegen zo'n probleem aanliep, schreef ik de hele verwerking in Delphi om de datum te genereren. Het bleek dat het mysql DBMS al een ingebouwde functie heeft om een datum om te zetten van een numerieke representatie naar een datum in woorden. En, zoals ik in het begin al zei, mysql is niet alleen een tool voor opslagbeheer, maar ook een tool voor gegevensverwerking.
Dus het verkrijgen van de datum in het hierboven beschreven formaat is eenvoudig in een eenvoudige zoekopdracht:
SELECT DATE_FORMAT (‘2014-10-21’, ’% d% M% Y’) als Data_Mysql; // Let op de spelling van% M
Alles zou goed zijn, de datum wordt in woorden weergegeven, maar de naam van de maand is in het Engels. Dit kan gebeuren als de globale variabele lc_time_names = en_EN op de server. De waarde voor de Russische datum is: lc_time_names = ru_RU.
Er zijn verschillende opties om dit probleem op te lossen.
De eerste optie, u kunt de waarde als een standaardvariabele in de mysql-serverconfiguratie schrijven. Om dit te doen, opent u my.ini in de map waar de mysql-server is geïnstalleerd en voegt u in de sectie "" de regel "lc_time_names =' ru_RU "" in.
De tweede optie is geschikt voor u als er geen directe toegang tot de mysql-configuratie is. De waarde van de variabele kan worden gewijzigd bij het uitvoeren van de sql-query. Doe gewoon het volgende vóór het verzoek: "SET lc_time_names =‘ ru_RU ’;". Met dit commando stel je de waarde van de lc_time_names variabele in deze sessie in met de mysql server. Dat wil zeggen, als u de verbinding met de mysql-server verliest wanneer u opnieuw verbinding maakt, wordt deze standaard ingesteld op "en_EN".
Daarom raad ik u aan om de opdracht toe te passen net voordat u de sql-query uitvoert. In dit geval zal de uiteindelijke vraag de vorm aannemen:
SET lc_time_names = "ru_RU"; SELECTEER DATE_FORMAT (‘2014-10-21’, ’% d% M% Y’) als ‘Data_Mysql’;
Resultaat van een sql-query met de functie DATE_FORMAT ():
Zoals je kunt zien, is alles correct geworden, de naam van de maand is Russisch geworden.
Met behulp van mysql-functies is het dus gemakkelijk en snel om informatie te verwerken. Ik raad je aan om niet het werk te doen dat je misschien op de mysql-tools zou gooien. U schrijft dus minder code en in 90% van de gevallen zal zo'n systeem stabieler werken. Getest op onze eigen ervaring. Ik hoop dat dit artikel nuttig voor u zal zijn, beste lezers! Met vriendelijke groet, uw Shinobi.
Voor een beschrijving van het waardenbereik voor elk type en de mogelijke datum- en tijdnotaties, zie paragraaf paragraaf 6.2.2 Datum- en tijdgegevenstypen.
Hieronder ziet u een voorbeeld waarin datumfuncties worden gebruikt. De bovenstaande query selecteert alle records met date_col in de afgelopen 30 dagen:
Mysql> SELECTEER iets UIT tbl_name WHERE TO_DAYS (NOW ()) - TO_DAYS (date_col) DAYOFWEEK (date) Geeft de index van de dag van de week voor datum (1 = zondag, 2 = maandag, ... 7 = zaterdag). Deze indexwaarden voldoen aan de ODBC-standaard: mysql> SELECT DAYOFWEEK ("1998-02-03"); -> 3 WEEKDAY (datum) Geeft als resultaat de index van de dag van de week voor datum (0 = maandag, 1 = dinsdag, ... 6 = zondag): mysql> SELECT WEEKDAY ("1997-10-04 22:23: 00"); -> 5 mysql> SELECTEER WEEKDAG ("1997-11-05"); -> 2 DAYOFMONTH (datum) Retourneert de rangschikking van de dag van de maand voor datum, in het bereik van 1 tot 31: mysql> SELECT DAYOFMONTH ("1998-02-03"); -> 3 DAYOFYEAR (datum) Retourneert de rangschikking van de dag van het jaar voor datum, in het bereik van 1 tot 366: mysql> SELECT DAYOFYEAR ("1998-02-03"); -> 34 MAAND (datum) Retourneert de rangschikking van de maand in het jaar voor datum, in het bereik van 1 tot 12: mysql> SELECT MAAND ("1998-02-03"); -> 2 DAYNAME (datum) Geeft als resultaat de naam van de dag van de week voor het datumargument: mysql> SELECT DAYNAME ("1998-02-05"); -> "Donderdag" MONTHNAME (datum) Geeft als resultaat de naam van de maand voor het datumargument: mysql> SELECT MONTHNAME ("1998-02-05"); -> "Februari" QUARTER (datum) Retourneert het kwartaalnummer van het jaar voor de datum, in het bereik van 1 tot 4: mysql> SELECT QUARTER ("98-04-01"); -> 2 WEEK (datum) WEEK (datum, eerste) Geeft met één argument de rangschikking van de week van het jaar terug voor de datum in het bereik 0 tot 53 (ja, mogelijk het begin van week 53) voor regio's waar de zondag wordt beschouwd de eerste dag van de week... Met het formulier WEEK () met twee argumenten kunt u aangeven of de week op zondag of maandag begint. De week begint met zondag als het tweede argument 0 is, en maandag als 1: mysql> SELECT WEEK ("1998-02-20"); -> 7 mysql> SELECT WEEK ("1998-02-20", 0); -> 7 mysql> SELECT WEEK ("1998-02-20", 1); -> 8 mysql> SELECT WEEK ("1998-12-31", 1); -> 53 Opmerking: In versie 4.0 is de functie WEEK (#, 0) gewijzigd om overeen te komen met de Amerikaanse kalender. JAAR (datum) Retourneert het jaar voor de datum, in het bereik van 1000 tot 9999: mysql> SELECTEER JAAR ("98-02-03"); -> 1998 JAARWEEK (datum) JAARWEEK (datum, eerste) Geeft het jaar en de week voor het datumargument. Het tweede argument van deze functie werkt als het tweede argument van de WEEK () functie. Merk op dat het jaar kan verschillen van dat gespecificeerd in het datumargument voor de eerste en laatste week van het jaar: mysql> SELECT YEARWEEK ("1987-01-01"); -> 198653 HOUR (time) Retourneert het uur voor het tijdargument, in het bereik van 0 tot 23: mysql> SELECT HOUR ("10:05:03"); -> 10 MINUTE (tijd) Geeft het aantal minuten terug voor het tijdargument, in het bereik van 0 tot 59: mysql> SELECT MINUTE ("98-02-03 10:05:03"); -> 5 SECOND (tijd) Geeft het aantal seconden terug voor het tijdargument, in het bereik van 0 tot 59: mysql> SELECT SECOND ("10:05:03"); -> 3 PERIOD_ADD (P, N) Voegt N maanden toe aan periode P (in YYMM- of YYYYMM-formaat). Retourneert de waarde in de indeling JJJJMM. Merk op dat het P-periodeargument geen datumwaarde is: mysql> SELECT PERIOD_ADD (9801,2); -> 199803 PERIOD_DIFF (P1, P2) Geeft als resultaat het aantal maanden tussen perioden P1 en P2. P1 en P2 moeten de indeling JJMM of JJJJMM hebben. Merk op dat de periodeargumenten P1 en P2 geen datumwaarden zijn: mysql> SELECT PERIOD_DIFF (9802,199703); -> 11 DATE_ADD (datum, INTERVAL expr type) DATE_SUB (datum, INTERVAL expr type) ADDDATE (datum, INTERVAL expr type) SUBDATE (datum, INTERVAL expr type) Deze functies voeren rekenkundige bewerkingen uit op datums. Beide zijn nieuw in MySQL 3.22. De functies ADDDATE () en SUBDATE () zijn synoniemen voor DATE_ADD () en DATE_SUB (). Vanaf MySQL 3.23 kunnen de + en - operators worden gebruikt in plaats van de DATE_ADD () en DATE_SUB () functies als de expressie aan de rechterkant een DATE of DATETIME kolom is (zie voorbeeld hieronder). Datum is een DATETIME of DATE die de startdatum aangeeft. De expr-expressie specificeert de hoeveelheid interval die moet worden opgeteld bij of afgetrokken van de startdatum. Uitdr is een tekenreeks die kan beginnen met - voor negatieve bereikwaarden. Het sleutelwoord type geeft aan hoe een bepaalde uitdrukking moet worden geïnterpreteerd. De hulpfunctie EXTRACT (type FROM date) retourneert een interval van het opgegeven type uit een datumwaarde. De volgende tabel toont de relatie tussen de argumenten type en expr:
| Betekenis Type | Verwacht formaat expr |
| SECONDE | SECONDEN |
| MINUUT | MINUTEN |
| UUR | UUR |
| DAG | DAGEN |
| MAAND | MAANDEN |
| JAAR | JAREN |
| MINUTE_SECOND | "MINUTEN: SECONDEN" |
| HOUR_MINUTE | "UREN: MINUTEN" |
| DAY_HOUR | "DAGEN UUR" |
| JAAR MAAND | "JAAR-MAANDEN" |
| HOUR_SECOND | "UREN: MINUTEN: SECONDEN" |
| DAY_MINUTE | "DAGEN UUR: MINUTEN" |
| DAY_SECOND | "DAGEN UUR: MINUTEN: SECONDEN" |
| Bepalend | Beschrijving |
| % M | Naam maand (januari ... december) |
| % W | Naam van de dag van de week (zondag ... zaterdag) |
| % D | Dag van de maand met Engels achtervoegsel (1e, 2e, 3e, etc.) |
| % Ja | Jaar, nummer, 4 cijfers |
| % ja | Jaar, nummer, 2 cijfers |
| % X | Jaar voor week waarin zondag de eerste dag van de week is, getal, 4 cijfers, gebruikt met "% V" |
| % x | Jaar voor week waarin zondag de eerste dag van de week is, getal, 4 cijfers, gebruikt met "% v" |
| % een | Afgekorte naam van de dag van de week (zon ... za) |
| % D | Dag van de maand, dag (00..31) |
| % e | Dag van de maand, dag (0..31) |
| % m | Maand, nummer (01..12) |
| % C | Maand, nummer (1..12) |
| % B | Afgekorte naam van de maand (jan ... dec) |
| % J | Dag van het jaar (001..366) |
| % H | Uur (00..23) |
| % k | Uur (0..23) |
| % H | Uur (01..12) |
| % I | Uur (01..12) |
| % l | Uur (1..12) |
| % I | Minuten, aantal (00..59) |
| % R | Tijd, 12-uurs formaat (uu: mm: ss M) |
| % T | Tijd, 24-uurs formaat (uu: mm: ss) |
| % S | Seconden (00..59) |
| % s | Seconden (00..59) |
| % P | AM of PM |
| % met | Dag van de week (0 = zondag..6 = zaterdag) |
| % U | Week (00..53), waarbij de zondag als de eerste dag van de week wordt beschouwd |
| % u | Week (00..53), waarbij maandag wordt beschouwd als de eerste dag van de week |
| % V | Week (01..53), waarbij de zondag als de eerste dag van de week wordt beschouwd. Gebruikt met '% X' |
| % v | Week (01..53), waarbij maandag wordt beschouwd als de eerste dag van de week. Gebruikt met '% x' |
| %% | De letterlijke '%'. |
Gebruikerscommentaar
| Geplaatst door op donderdag 20 juni 2002, @ 7: 08am | [Verwijderen] [Bewerken] |
Bij het selecteren van een tijdstempelgegevenstype uit een tabel
en wil je aanpassen aan een tijdzone (dit voorbeeld is
van Pacific Time tot EST):
SELECT date_format (DATE_ADD (,
INTERVAL 3 UUR), "% M% e,% Y bij% H:% i EST") VAN
;
| Geplaatst door Dan Allen op dinsdag 25 juni 2002, @ 12: 50am | [Verwijderen] [Bewerken] |
| Geplaatst door op woensdag 18 december 2002, @ 5: 28pm | [Verwijderen] [Bewerken] |
Ik moet me afvragen waarom er geen functie is die
doet eigenlijk wat dit doet:
SELECTEER VERDIEPING ((UNIX_TIMESTAMP (NU ()) -
UNIX_TIMESTAMP (geboortedatum)) / 60/60/24 / 364.25)
als leeftijd
Het zou veel code er veel laten uitzien
schoner.
Dit is zelfs van bijzonder belang voor gebruik
Aan
het opslaan of verzamelen van gegevens over mensen in de VS,
aangezien de Amerikaanse wet het verzamelen van persoonlijke gegevens verbiedt
informatie over iedereen onder de 13 jaar,
en deze truc berekent hun leeftijd in jaren.
Het zou een stuk leuker zijn met een AGE (datum .)
[, datum2]
) functie.
Het dichtstbijzijnde ding daar is period_diff,
die
accepteert geen standaard datumtekenreeks en retourneert
maanden, die zijn
bruikbaar
Dit werkt eigenlijk niet in het geval van pre-
tijdperk geboortedata, erger nog. unix_timestamp
geeft 0 terug voor alle datums vóór het tijdperk.
Ik beweer dat dat een bug is en echt nodig heeft
naar
vast zijn.
Moet period_diff / 12 gebruiken, denk ik.
| Geplaatst door Matthew Mullenweg op woensdag 18 december 2002, om 17:27 uur | [Verwijderen] [Bewerken] |
Je brengt een aantal belangrijke zaken aan, maar
omgaan met leeftijden is echt "t Dat
moeilijk. Voor
je zou bijvoorbeeld zoiets als dit kunnen doen:
Mysql> SELECT DATE_FORMAT (
FROM_DAYS (TO_DAYS (NOW ()) - TO_DAYS (dob)), "% Y") + 0
ALS leeftijd VAN mensen;
Waar "dob" duidelijk hun geboortedatum is.
Het werkt ook met datums voor en na het tijdperk.
Excuseer de funky opmaak als de
commentaarsysteem lijkt erop aan te dringen een regel in te voegen
breekt in het codeblok. I
kwam dit probleem tegen tijdens het werken aan sommige
genealogische dingen op href = "http://www.mullenweg.com"> Mullenweg.com
, een familiesite. Ik hoop dat dit helpt!
| Geplaatst door Dan Allen op woensdag 18 december 2002, @ 5: 31pm | [Verwijderen] [Bewerken] |
Lijkt een echte pijn om de dagen in de . te krijgen
maand, maar hier is een manier:
selecteer
DATE_FORMAT (CONCAT (JAAR ("2002-05-05"), "-",
MAAND ("2002-05-05" + INTERVAL 1 MAAND), "-01") -
INTERVAL 1 DAG, "% e") als aantalDagen
Ik denk dat het leuk zou zijn als we gewoon een
DATE_FORMAT entiteit hiervoor
| Geplaatst door Isaac Shepard op woensdag 18 december 2002, om 17:31 uur | [Verwijderen] [Bewerken] |
Als je zoeken naar generieke SQL-query's die
kunt u de dagen, maanden en jaren krijgen
tussen twee gegeven datums, zou je kunnen overwegen:
deze gebruiken. U hoeft alleen datum1 en . te vervangen
date2 met je datumvelden en mijntabel met je
tafel naam.
Aantal dagen tussen datum1 en datum2: SELECT TO_DAYS (datum2) - |
Aantal maanden tussen datum1 en datum2: SELECTEER PERIODE_DIFF |
Aantal jaren tussen datum1 en datum2: SELECTEER (JAAR (datum2) - JAAR |
Nu enkele opmerkingen hierover.
1. Deze resultaten geven een geheel aantal jaren terug,
maanden en dagen. Ze zijn "gevloerd". Dus 1.4
dagen zou worden weergegeven als 1 dag, en 13,9 jaar zou
weergegeven als 13 jaar.
2. Merk op dat ik in sommige booleaanse uitdrukkingen gebruik
gevallen. Omdat booleaanse expressies evalueren tot 0
of 1, ik kan ze gebruiken om 1 van het totaal af te trekken
op basis van een voorwaarde.
Om bijvoorbeeld het aantal jaren te berekenen
tussen tot datums, eerst gewoon de jaren aftrekken.
Het probleem is dat dit niet altijd correct is.
Denk aan het aantal jaren tussen 1 juli 1950
en 1 mei 1952. Technisch gezien is er maar één vol
jaar tussen hen. Op 1 juli 1952 en later,
er zullen twee jaar zijn. Daarom moet u
één jaar aftrekken voor het geval de datum "nog niet" is
een vol jaar bereikt. Dit doe je door de if . aan te vinken
de tweede maand-dag is voor de eerste maand-
dag. Als dat zo is, resulteert dit in een waarde van 1, dat is
afgetrokken van het totaal.
3. Om de maand-dag te krijgen, gebruik ik MID. Dit is beter
dan met RECHTS, omdat het voor beide datums werkt
en datums.
4. Zoals vermeld in een vorige post, PERIOD_DIFF
heeft het formaat jaarmaand nodig, maar er is echt geen beste
manier om dit te doen. Om dit te krijgen, gebruik ik DATE_FORMAT
(datum1, "% Y% m").
5. In tegenstelling tot veel andere oplossingen, zouden deze vragen:
werken met data vóór 01/01/1970.
6. Feedback wordt zeer op prijs gesteld. Sinds ik "m
als ik dit in mijn eigen toepassingen gebruik, zou ik het fijn vinden als
je laat het me weten als je een fout in de logica ontdekt.
| Geplaatst door Jason Rust op woensdag 18 december 2002, om 17:31 uur | [Verwijderen] [Bewerken] |
Nog een paar keer tussen functies. Dit is
een andere manier om de maanden tussen twee te berekenen
datums die soms van pas kunnen komen, zoals het is
lineair:
Maanden Tussen 2002-02-15 en
2002-01-15
(((JAAR ("2002-02-15") - 1) * 12 +
MAAND ("2002-02-15")) - ((JAAR ("2002-01-15") - 1) *
12 + MAAND ("2002-01-15"))) - (MID ("2002-01-15", 9,
2) < MID("2002-02-15", 9, 2))
Het volgende is een week tussen functie:
Weken tussen 2002-08-28 en
2002-08-21
VERDIEPING ((TO_DAYS ("2002-08-28") -
TO_DAYS ("2002-08-21")) / 7)
| Geplaatst door op donderdag 12 september 2002, @ 6: 22am | [Verwijderen] [Bewerken] |
U kunt "DATE_ADD" niet doen (" 15:30:00 ", INTERVAL 55
MINUTE), het zal NULL retourneren, de oplossing die ik heb gevonden
is:
DATE_FORMAT (DATE_ADD (CONCAT ("2000-01-
01 ",` time_field`), INTERVAL "minuten" MINUTE), "%
Zijn ")
| Geplaatst door Marcelo Celleri op dinsdag 17 september 2002, om 14:58 | [Verwijderen] [Bewerken] |
Ik heb twee datetime-velden, (date_out, date_in),
het zijn records van inlog- en uitlogtijden en ik
moet de weg vinden om te komen het verschil tussen
die twee, en ik heb deze geprobeerd: f_out -
f_in maar het gaf me een geheel getal resultaat dat is
waardeloos voor mij, ik heb het verschil nodig in
seconden Kun je me alsjeblieft helpen, want ik wil niet
heb een idee hoe je dit antwoord in seconden kunt omzetten
| Geplaatst door Ricky Orea op dinsdag 12 november 2002, @ 3: 51pm | [Verwijderen] [Bewerken] |
Mijn gebruiker voert een datum in het formaat in
van "MM / DD / YYYYY", hoe kan ik dit converteren naar de
formatteer "JJJJ / MM / DD" voordat ik het op een mysql . opsla
tafel?
| Geplaatst door Ram Narayan op maandag 18 november 2002, @ 20:46 uur | [Verwijderen] [Bewerken] |
Hallo allemaal,
Toevoegen aan de vraag van mijn vriend Ricky Orea, als mijn gebruiker
voert de datum in in dd mmm jjjj-formaat (26 nov
2002), hoe moet ik invoegen in de mysql db.
| Geplaatst door louis bennett op donderdag 21 november 2002, @ 11: 35am | [Verwijderen] [Bewerken] |
% d Dag van de maand, numeriek (00..31)
% e Dag van de maand, numeriek (0..31)
Niet om pedant te zijn, maar er is nooit een dag "0"
binnen een maand ...
| Geplaatst door Twidi op woensdag 18 december 2002, om 17:27 uur | [Verwijderen] [Bewerken] |
Hoe het aantal dagen in een maand te verkrijgen:
Neem gewoon de eerste dag van de maand, voeg er een toe
maand (om de eerste dag van de volgende maand te krijgen) en
één dag aftrekken (om de laatste dag van de
vorige maand, dat is het aantal dagen), als
volgen:
Selecteer
dayofmonth (date_sub (date_add (concat (date_format (MYDATE,
"% Y-% m"), "-01"), interval 1 maand), interval 1
day)) als aantal_dagen van MYTABLE;
(vervang gewoon MYDATE en MYTABLE)
Misschien is er een andere manier ...
| Geplaatst door op zondag 1 december 2002, @ 10: 46am | [op woensdag 8 januari 2003, @ 5: 25u | [Verwijderen] [Bewerken] |
Ik probeer een MySQL-script te schrijven dat een tabel zal vullen met records voor elke waarde tussen 2 gegeven parameters. Zonder de lusstructuur beschikbaar in
Opgeslagen procedures, dit blijkt problematisch. Heeft iemand een oplossing?
Ruw voorbeeld: -
Tabel "test" heeft een datumveld "test_date".
Deze functies zijn ook ontworpen om te werken met kalendergegevenstypen. Laten we ze in meer detail bekijken.
- DATE_FORMAT (datum, formaat) formatteert de datum volgens het geselecteerde formaat. Deze functie wordt heel vaak gebruikt. In MySQL heeft de datum bijvoorbeeld het formaat JJJJ-MM-DD (jaar-maand-dag), en zijn we meer bekend met het formaat DD-MM-JJJJ (dag-maand-jaar). Daarom, om de datum weer te geven die we gewend zijn, moet deze opnieuw worden geformatteerd. Laten we eerst het verzoek doen en dan uitzoeken hoe we het formaat kunnen instellen:
SELECT DATE_FORMAT (CURDATE (), "% d.% M.% Y");
Nu komt de datum ons bekend voor. Om het datumformaat in te stellen, worden speciale kwalificaties gebruikt. Voor het gemak vermelden we ze in de tabel.
Bepaald Beschrijving % een De afgekorte naam van de dag van de week (ma - maandag, di - dinsdag, wo - woensdag, do - donderdag, vr - vrijdag, za - zaterdag, zo - zondag). Voorbeeld:
SELECT DATE_FORMAT (CURDATE (), "% a");
Resultaat:
% B Afgekorte maandnamen (jan - januari, feb - februari, maart - maart, april - april, mei - mei, juni - juni, juli - juli, aug - augustus, sep - september, okt - oktober, nov - november, dec - December). Voorbeeld:
SELECT DATE_FORMAT (CURDATE (), "% b");
Resultaat:
% C Maand in numerieke vorm (1 - 12). Voorbeeld:
SELECT DATE_FORMAT (CURDATE (), "% s");
Resultaat:
% D De dag van de maand in numerieke vorm met een nul (01 - 31). Voorbeeld:
SELECT DATE_FORMAT (CURDATE (), "% d");
Resultaat:
% D Dag van de maand in het Engels (1e, 2e ...). Voorbeeld:
SELECT DATE_FORMAT (CURDATE (), "% D");
Resultaat:
% e Dag van de maand in numerieke vorm zonder nul (1 - 31). Voorbeeld:
SELECT DATE_FORMAT (CURDATE (), "% e");
Resultaat:
% H Uren met voorloopnullen van 00 tot 23. Voorbeeld:
SELECT DATE_FORMAT ("2011-04-15 23:03:20", "% H");
Resultaat:
% H Uren met voorloopnullen van 00 tot 12. Voorbeeld:
SELECT DATE_FORMAT ("2011-04-15 23:03:20", "% u");
Resultaat:
% I Minuten van 00 tot 59. Voorbeeld:
SELECT DATE_FORMAT ("2011-04-15 23:03:20", "% i");
Resultaat:
% J Dag van het jaar van 001 tot 366. Voorbeeld:
SELECT DATE_FORMAT ("2011-04-15 23:03:20", "% j");
Resultaat:
% k Uren met voorloopnullen van 0 tot 23. Voorbeeld:
SELECT DATE_FORMAT ("2011-12-31 01:03:20", "% k");
Resultaat:
% l Uren zonder voorloop nul van 1 tot 12. Voorbeeld:
SELECT DATE_FORMAT ("2011-04-15 00:03:20", "% l");
Resultaat:
% M Voorbeeld:
Resultaat:
% M Maandnaam zonder afkorting. Voorbeeld:
SELECT DATE_FORMAT ("2011-04-15 00:03:20", "% M");
Resultaat:
% m Maand in numerieke vorm met een voorloopnul (01 - 12). Voorbeeld:
SELECT DATE_FORMAT ("2011-04-15 00:03:20", "% m");
Resultaat:
% P AM of PM voor 12 uur formaat. Voorbeeld:
SELECT DATE_FORMAT ("2011-04-15 00:03:20", "% p");
Resultaat:
% R Tijd in 12-uurs formaat. Voorbeeld:
SELECT DATE_FORMAT ("2011-04-15 00:03:20", "% r");
Resultaat:
% s Seconden van 00 tot 59. Voorbeeld:
SELECT DATE_FORMAT ("2011-04-15 00:03:20", "% s");
Resultaat:
% T Tijd in 24-uurs formaat. Voorbeeld:
SELECT DATE_FORMAT ("2011-04-15 21:03:20", "% T");
Resultaat:
% u Week (00 - 52), waarbij maandag als de eerste dag van de week wordt beschouwd. Voorbeeld:
SELECT DATE_FORMAT ("2011-04-17 21:03:20", "% u");
Resultaat:
% U Week (00 - 52) met zondag als eerste dag van de week. Voorbeeld:
SELECT DATE_FORMAT ("2011-04-17 21:03:20", "% U");
Resultaat:
% W De naam van de dag van de week zonder afkorting. Voorbeeld:
SELECT DATE_FORMAT ("2011-04-17 21:03:20", "% W");
Resultaat:
% met Dag van de week nummer (0 - zondag, 6 - zaterdag). Voorbeeld:
SELECT DATE_FORMAT ("2011-04-17 21:03:20", "% w");
Resultaat:
% Ja Jaar, 4 categorieën. Voorbeeld:
SELECT DATE_FORMAT ("2011-04-17 21:03:20", "% Y");
Resultaat:
% ja Jaar, 2 categorieën. Voorbeeld:
SELECT DATE_FORMAT ("2011-04-17 21:03:20", "% y");
Resultaat:
- STR_TO_DATE (datum, formaat) de functie is het tegenovergestelde van de vorige, het neemt de datum datum in formaat en retourneert de datum in MySQL-indeling.
SELECT STR_TO_DATE ("17-04-2011 23:50", "% d.% M.% Y% H:% i");
- De functie TIME_FORMAT (tijd, formaat) is vergelijkbaar met de functie DATE_FORMAT (), maar wordt alleen voor tijd gebruikt:
SELECT TIME_FORMAT ("22:38:15", "% H-% i-% s");
- De functie GET_FORMAT (datum, formaat) retourneert een opmaakreeks die overeenkomt met een van de vijf tijdnotaties:
EUR - Europese norm
VS - Amerikaanse standaard
JIS - Japanse industriële norm
ISO - ISO-norm ( internationale organisatie normen)
INTERN - internationale normDeze functie is goed te gebruiken in combinatie met de vorige - DATE_FORMAT (). Laten we een voorbeeld bekijken:
SELECT GET_FORMAT (DATE, "EUR"), DATE_FORMAT ("2011-04-17", GET_FORMAT (DATE, "EUR"));
Zoals u kunt zien, retourneert de functie GET_FORMAT () zelf het presentatieformaat en samen met de functie DATE_FORMAT () retourneert het de datum in het gewenste formaat. Doe uw eigen query's met alle vijf de normen en zie het verschil.
Waarden in deze formaten:
Als string in het formaat "JJJJ-MM-DD" of "JJ-MM-DD". Een ontspannen syntaxis is toegestaan: elk leesteken kan worden gebruikt als scheidingsteken tussen delen van een datum. Bijvoorbeeld "2012-12-31", "2012/12/31", "2012 ^ 12 ^ 31" en " [e-mail beveiligd]@ 31 "zijn gelijkwaardig.
Als een niet-gescheiden tekenreeks in het formaat "JJJJMMDD" of "JJMMDD", op voorwaarde dat de tekenreeks een datum is. "20070523" en "070523" worden bijvoorbeeld geïnterpreteerd als "2007-05-23", maar "071332" is illegaal (het heeft betekenisloze maandelijkse en dagelijkse delen) en wordt "0000-00-00".
Als een getal in het formaat JJJJMMDD of JJMMDD, op voorwaarde dat het getal logisch is als datum. 19830905 en 830905 worden bijvoorbeeld geïnterpreteerd als "1983-09-05".
Daarom is de tekenreeks "25-08-2012" geen geldige letterlijke MySQL-datum. U heeft vier opties (in een soort ongedefinieerde volgorde van voorkeur, zonder verdere informatie over uw vereisten):
- $ dt = \ DateTime :: createFromFormat ("m / d / Y", $ _POST ["datum"]);
en dan ofwel:
krijg een geschikte opgemaakte string:
$ datum = $ dt-> formaat ("J-m-d");
UNIX-tijdstempel ophalen:
$ tijdstempel = $ dt-> getTimestamp ();
die vervolgens rechtstreeks wordt doorgegeven aan MySQL FROM_UNIXTIME ():
INSERT INTO user_date VALUES ("", "$ naam", FROM_UNIXTIME ($ tijdstempel))
Configureer de Datepicker om datums in een ondersteund formaat weer te geven met behulp van altField samen met altFormat:
$ ("selector"). datepicker ((altField: "#actualDate" altFormat: "jjjj-mm-dd"));
Of, als u tevreden bent dat gebruikers de datum in de indeling JJJJ-MM-DD zien, stelt u in plaats daarvan gewoon de parameter dateFormat in:
$ ("selector") datepicker ((dateFormat: "jjjj-mm-dd"));
Voer de tekenreeks handmatig in een geldige letterlijke tekst in:
$ parts = explode ("/", $ _POST ["datum"]); $ date = "$ onderdelen- $ onderdelen- $ onderdelen";
Waarschuwing
-
Het type DATE wordt gebruikt voor waarden met een datumgedeelte maar geen tijdgedeelte. MySQL haalt DATE-waarden op en geeft ze weer in de indeling "JJJJ-MM-DD". Het ondersteunde bereik is "1000-01-01" tot "9999-12-31".
DatumTijd-type gebruikt voor waarden die zowel datum als tijd bevatten. MySQL haalt DateTime-waarden op en geeft ze weer in de indeling "JJJJ-MM-DD HH: MM: SS". Het ondersteunde bereik is "1000-01-01 00:00:00" tot "9999-12-31 23:59:59".
Uw code is kwetsbaar voor SQL-injectie. U moet echt voorbereide instructies gebruiken waarin u uw variabelen doorgeeft als parameters die niet worden geëvalueerd voor SQL. Als je niet weet waar ik het over heb, of hoe je het kunt oplossen, lees dan het Bobby Tables-verhaal.
de functie
JAARMAAND () ontbreekt overduidelijk !!! Zeg dat je hebt
twee datums en je wilt een period_diff doen ... jij
kan () JAAR () en MAAND () niet zomaar samenvoegen omdat
maand is niet "0" opgevuld ... lijkt gewoon met
JAARWEEK () zou het logisch zijn om ook te hebben
JAARMAAND () ... gedachten? ik weet jij kan doe het met
DATE_FORMAT, maar waarom dan al die andere
functies?