MySql មិនត្រឹមតែជាប្រព័ន្ធដ៏ទាក់ទាញសម្រាប់រៀបចំការផ្ទុកទិន្នន័យប៉ុណ្ណោះទេ ប៉ុន្តែក៏ជាឧបករណ៍ដ៏ល្អសម្រាប់ដំណើរការព័ត៌មានផងដែរ។
ថ្ងៃនេះយើងនឹងពិនិត្យមើលការធ្វើការជាមួយ មុខងារ mysql៖ កាលបរិច្ឆេទ DateTime ។ ខ្ញុំក៏នឹងនិយាយអំពីវិធីសាស្រ្ត mysql ដែលប្រើដើម្បីបំប្លែងខ្សែអក្សរទៅជាកាលបរិច្ឆេទ។ ជាទូទៅវិធីសាស្រ្តផ្សេងគ្នាក្នុងការដោះស្រាយបញ្ហាទាក់ទងនឹងកាលបរិច្ឆេទនៅក្នុង mysql DBMS.
បញ្ហា។
ចូរស្រមៃថាអ្នកកំពុងសរសេរប្រព័ន្ធសម្រាប់ការផ្ញើការជូនដំណឹង SMS ទៅកាន់មូលដ្ឋានអតិថិជនរបស់អ្នក។
តារាង 1. tbl_clients* - តារាងដែលមានទិន្នន័យអតិថិជន (ឈ្មោះពេញ និងថ្ងៃខែឆ្នាំកំណើត) ទិន្នន័យអំពីបរិមាណ ប្រភេទនៃទំនិញ និងស្ថានភាពដំណើរការកម្មវិធី។
តារាងទី 2. tbl_sms – តារាងស្ថានភាព SMS និងការភ្ជាប់លេខសម្គាល់អតិថិជនជាមួយនឹងកាលបរិច្ឆេទដែលស្ថានភាពត្រូវបានទទួល។
កាន់តែខិតជិតប្រយុទ្ធ។ យើងបំពាក់ខ្លួនយើងជាមួយនឹងមុខងារដែលភ្ជាប់មកជាមួយ។
តារាង tbl_sms មានកំណត់ត្រាជាច្រើនសម្រាប់ Id_clients មួយជាមួយ ស្ថានភាពផ្សេងគ្នានិងពេលវេលានៃការទទួល។ ឧទាហរណ៍៖
ឧបមាថាចៅហ្វាយទាមទារបញ្ជី ស្ថានភាពចុងក្រោយបំផុត។សម្រាប់អតិថិជនទាំងអស់។ អ្នកអាចដោះស្រាយបញ្ហាបានយ៉ាងឆាប់រហ័សដោយប្រើមុខងារដែលភ្ជាប់មកជាមួយ។ សំណួរ sqlសម្រាប់ករណីនេះវាមើលទៅដូចនេះ:
SELECT * FROM tbl_sms ts JOIN (SELECT Id_clients, max(Date_status) as max_dat FROM tbl_sms GROUP BY Id_clients) ts_max ON ts. id_clients = ts_max. id_clients និង ts. Date_status= ts_max.max_dat ;
លទ្ធផលនៃសំណួរគឺជាជម្រើសនៃកំណត់ត្រាដែលមានកាលបរិច្ឆេទអតិបរមាសម្រាប់ Id_clients នីមួយៗ៖
សំណើនេះស្មុគស្មាញ ខ្ញុំមិនយល់វាជាលើកដំបូងទេ ប៉ុន្តែខ្ញុំនឹងព្យាយាមពន្យល់។ នៅក្នុងសំណួរមួយ យើងចូលរួមតារាងពីរ។ tbl_sms ដំបូងមានទិន្នន័យទាំងអស់ដោយមិនគិតពីលក្ខខណ្ឌដូច្នេះដើម្បីនិយាយជា "ទម្រង់ឆៅ" ។ តារាងទីពីរគឺជាលទ្ធផលនៃសំណួរ
SELECT Id_clients, max(Date_status) ជា max_dat ពី tbl_sms GROUP ដោយ Id_clients ;
ទៅ tbl_sms ដូចគ្នាដោយប្រើ មុខងារ MAX() និងការដាក់ជាក្រុមដោយវាល Id_clients ។
នៅក្នុងតារាងទីពីរ យើងកំណត់ក្រុមដោយ id_clients ដោយប្រើ "GROUP BY Id_clients" construct ។ នោះគឺឥឡូវនេះយើងមានកំណត់ត្រាមួយ (ទោះបីជាមានកំណត់ត្រាជាច្រើននៅក្នុងតារាងសម្រាប់តម្លៃ id_clients មួយ) - នេះគឺជាតម្លៃមួយនៃវាល id_clients ។ នៅក្នុង SELECT យើងប្រើមុខងារ MAX() ដែលជាលទ្ធផលគឺជ្រើសរើសតម្លៃអតិបរមាដែលបានកត់ត្រាក្នុងតារាង។ សម្រាប់ឯកសារយោងមាននៅក្នុង mysql DBMS មុខងារបញ្ច្រាស MIN() ជាលទ្ធផលនៅក្នុងសំណួរដែលប្រើមុខងារ MAX() យើងទទួលបាន តម្លៃអតិបរមាវាល Date_status សម្រាប់តម្លៃវាល id_clients នីមួយៗ។
ហើយចុងក្រោយ ការជ្រើសរើសកំណត់ត្រាដែលត្រូវនឹងលក្ខខណ្ឌដូចខាងក្រោម៖ “ON ts. id_clients = ts_max. id_clients និង ts. Date_status= ts_max.max_dat” យើងទទួលបានលទ្ធផលដែលចង់បាន។
ចៅហ្វាយពេញចិត្ត។ ប៉ុន្តែបន្ទាប់មកគណនេយ្យករម្នាក់មក ហើយកំណត់កិច្ចការថ្មីមួយថា “យើងត្រូវជ្រើសរើសគ្រប់ស្ថានភាពទាំងអស់ដែលយើងបានទទួលសម្រាប់តែថ្ងៃ 10/05/2014”។
យើងសរសេរសំណើដូចខាងក្រោមៈ
SELECT * FROM tbl_sms WHERE Date_status>'2014-10-05 00:00:00' និង Date_status<’2014-10-05 23:59:59’ ;
ដោយសារប្រភេទទិន្នន័យនៃវាល Date_status គឺ DATETIME ដូច្នេះយើងកំណត់លក្ខខណ្ឌដូចខាងក្រោម៖ តម្លៃចាប់ពី 00:00 ដល់ 23:59 10/05/2014 – រយៈពេលនេះរួមបញ្ចូលយ៉ាងពិតប្រាកដមួយថ្ងៃ ឬ 24 ម៉ោង។ អ្នកគួរតែយកចិត្តទុកដាក់លើទម្រង់នៃការកត់ត្រាកាលបរិច្ឆេទ។ នៅក្នុងប្រភេទទិន្នន័យកាលបរិច្ឆេទក្នុង mysql យើងតំណាងឱ្យកាលបរិច្ឆេទក្នុងទម្រង់ដូចខាងក្រោម Year(4)-Month(2)-Day(2)។ ប្រសិនបើវាល "ស្ថានភាព" មានទម្រង់ DATE នោះសំណើនឹងមើលទៅដូចនេះ៖
SELECT * FROM tbl_sms WHERE Date_status="2014-10-05";
យើងបានស្វែងយល់ពីភារកិច្ចរបស់គណនេយ្យករ។ របាយការណ៍ត្រូវបានដាក់ជូន។ ឥឡូវនេះសូមមើលការធ្វើការជាមួយកាលបរិច្ឆេទនៅក្នុង mysql ពីមុំផ្សេងគ្នា - ប្រសិនបើកាលបរិច្ឆេទត្រូវបានតំណាងជាខ្សែអក្សរ។ រឿងនេះក៏កើតឡើងដែរ...
កាលបរិច្ឆេទក្នុងប្រភេទ VARCHAR ឬ CHAR... អ្វីដែលត្រូវធ្វើ? ដោយប្រើមុខងារបំប្លែងខ្សែអក្សរ។
ខ្លួនខ្ញុំផ្ទាល់បានជួបប្រទះបញ្ហាស្រដៀងគ្នានេះច្រើនជាងម្តង។ ការពិតគឺថា ប្រសិនបើអ្នកមានកាលបរិច្ឆេទក្នុងទម្រង់ជាខ្សែ នោះសំណួរទាំងអស់ដែលបានពិពណ៌នាខាងលើនឹងក្លាយទៅជាគ្មានប្រយោជន៍។ ឧទាហរណ៍ អ្នកត្រូវជ្រើសរើសអតិថិជនទាំងអស់ដែលតម្លៃវាល Date_Zap ស្ថិតនៅក្នុងរយៈពេលកាលបរិច្ឆេទជាក់លាក់មួយ។ កុំរាយកាលបរិច្ឆេទទាំងអស់ ... ពិតណាស់មិនមែនទេ។ វាតែងតែមានផ្លូវចេញ ហើយមុខងារដែលភ្ជាប់មកជាមួយនឹងជួយយើងម្តងទៀត។ សម្រាប់កិច្ចការបែបនេះនៅក្នុង mysql មានមុខងារ STR_TO_DATE()។
ដូចដែលឈ្មោះបានបង្ហាញ មុខងារបំប្លែងខ្សែអក្សរទៅជាកាលបរិច្ឆេទ។ អាគុយម៉ង់ចំពោះអនុគមន៍ STR_TO_DATE គឺជាកាលបរិច្ឆេទនៅក្នុងប្រភេទទិន្នន័យ CHAR ឬ VARCHAR និងទម្រង់កាលបរិច្ឆេទដែលអ្នកឆ្លងកាត់។
ឧទាហរណ៍ អ្នកនឹងសួរតារាង tbl_clients៖
SELECT Date_Zap, STR_TO_DATE(Date_Zap,'%d.%m.%Y') ពី tbl_clients WHERE id_clietns='345';
លទ្ធផលនៃការប្រើប្រាស់មុខងារ STR_TO_DATE()៖
ដូចដែលអ្នកអាចឃើញពីទម្រង់កាលបរិច្ឆេទធម្មតាយើងទទួលបានកាលបរិច្ឆេទទម្រង់ mysql ។ មតិមួយចំនួនអំពីសំណើ៖
- ប្រសិនបើអ្នកមិនប្រាកដទាំងស្រុងអំពីលទ្ធផលនៃមុខងារទេ តែងតែធ្វើដូចនៅទីនេះ ដើម្បីមើលតម្លៃវាលមុន និងក្រោយការបំប្លែង។ នេះនឹងជួយសង្រ្គោះអ្នកពីសរសៃប្រសាទ។
- ប្រសិនបើអ្នកនឹងប្រើលទ្ធផល ជាឧទាហរណ៍ ក្នុងកម្មវិធី ហើយយោងជាពិសេសទៅឈ្មោះវាល នោះខ្ញុំណែនាំអ្នកឱ្យជំនួសឈ្មោះវែង “STR_TO_DATE(Date_Zap,'%d.%m.%Y')”, ឧទាហរណ៍ជាមួយឈ្មោះ Data_Mysql សម្រាប់ការនេះយើងកែប្រែសំណួរ
លទ្ធផលនៃការប្រើប្រាស់មុខងារបំប្លែងខ្សែអក្សរទៅជាទម្រង់កាលបរិច្ឆេទ mysql (STR_TO_DATE())៖
បង្ហាញកាលបរិច្ឆេទជាពាក្យ។
ជាញឹកញយ មានតម្រូវការដើម្បីធានាថា នៅពេលបង្កើតរបាយការណ៍ពីមូលដ្ឋានទិន្នន័យ (mysql) កាលបរិច្ឆេទនៅលើឯកសារគួរតែជាទម្រង់ “ថ្ងៃខែជាពាក្យឆ្នាំ”។ ឧទាហរណ៍៖ មាន “10/21/2014” ប៉ុន្តែអ្នកត្រូវការ “ថ្ងៃទី 21 ខែតុលា ឆ្នាំ 2014”។ នៅពេលដែលខ្ញុំជួបប្រទះបញ្ហាបែបនេះ ខ្ញុំបានសរសេរដំណើរការទាំងមូលនៅក្នុង Delphi ដើម្បីបង្កើតកាលបរិច្ឆេទ។ វាបានប្រែក្លាយថា mysql DBMS មានមុខងារដែលភ្ជាប់មកជាមួយរួចហើយសម្រាប់បំប្លែងកាលបរិច្ឆេទពីតំណាងលេខទៅជាកាលបរិច្ឆេទក្នុងពាក្យ។ ហើយដូចដែលខ្ញុំបាននិយាយនៅដើមដំបូង mysql មិនត្រឹមតែជាឧបករណ៍គ្រប់គ្រងការផ្ទុកទិន្នន័យប៉ុណ្ណោះទេ ប៉ុន្តែវាក៏ជាឧបករណ៍ដំណើរការព័ត៌មានផងដែរ។
ដូច្នេះ វាងាយស្រួលក្នុងការទទួលបានកាលបរិច្ឆេទក្នុងទម្រង់ដែលបានពិពណ៌នាខាងលើក្នុងសំណើសាមញ្ញមួយ៖
SELECT DATE_FORMAT('2014-10-21','%d %M %Y') ជា Data_Mysql; // ចំណាំអក្ខរាវិរុទ្ធ %M
អ្វីៗនឹងល្អ កាលបរិច្ឆេទត្រូវបានបង្ហាញជាពាក្យ ប៉ុន្តែឈ្មោះខែជាភាសាអង់គ្លេស។ វាអាចកើតឡើងប្រសិនបើម៉ាស៊ីនមេមានអថេរសកល lc_time_names=en_EN ។ តម្លៃសម្រាប់កាលបរិច្ឆេទរុស្ស៊ីនឹងស្មើនឹង៖ lc_time_names=ru_RU ។
មានជម្រើសជាច្រើនសម្រាប់ដោះស្រាយបញ្ហានេះ។
ជម្រើសដំបូងគឺកំណត់តម្លៃលំនាំដើមនៅក្នុងការកំណត់រចនាសម្ព័ន្ធម៉ាស៊ីនមេ mysql ។ ដើម្បីធ្វើដូចនេះបើក my.ini នៅក្នុងថតដែលម៉ាស៊ីនមេ mysql ត្រូវបានដំឡើង ហើយនៅក្នុងផ្នែក "" បញ្ចូលបន្ទាត់ "lc_time_names = 'ru_RU" ។
ជម្រើសទីពីរនឹងសាកសមនឹងអ្នក ប្រសិនបើមិនមានការចូលដោយផ្ទាល់ទៅកាន់ការកំណត់រចនាសម្ព័ន្ធ mysql ។ តម្លៃនៃអថេរអាចត្រូវបានផ្លាស់ប្តូរនៅពេលប្រតិបត្តិសំណួរ sql ។ គ្រាន់តែធ្វើដូចខាងក្រោមមុនពេលស្នើសុំ: "SET lc_time_names = 'ru_RU';" ។ ជាមួយនឹងពាក្យបញ្ជានេះ អ្នកកំណត់តម្លៃនៃអថេរ lc_time_names ក្នុងវគ្គនេះជាមួយម៉ាស៊ីនមេ mysql ។ នោះគឺប្រសិនបើអ្នកបាត់បង់ការតភ្ជាប់ជាមួយម៉ាស៊ីនមេ mysql នៅពេលអ្នកភ្ជាប់ឡើងវិញ វានឹងត្រូវបានកំណត់ទៅជាតម្លៃលំនាំដើម “en_EN” ។
ដូច្នេះខ្ញុំណែនាំអ្នកឱ្យប្រើពាក្យបញ្ជាភ្លាមៗមុនពេលប្រតិបត្តិសំណួរ sql ។ ក្នុងករណីនេះ សំណួរចុងក្រោយនឹងមើលទៅដូចនេះ៖
SET lc_time_names = "ru_RU"; SELECT DATE_FORMAT('2014-10-21','%d %M %Y') ជា 'Data_Mysql';
លទ្ធផលនៃសំណួរ sql ដោយប្រើមុខងារ DATE_FORMAT()៖
ដូចដែលអ្នកអាចឃើញអ្វីគ្រប់យ៉ាងបានក្លាយទៅជាត្រឹមត្រូវឈ្មោះនៃខែបានក្លាយជាភាសារុស្ស៊ី។
ដូច្នេះ ការប្រើប្រាស់មុខងារ mysql វាមានភាពងាយស្រួល និងរហ័សក្នុងដំណើរការព័ត៌មាន។ ខ្ញុំណែនាំអ្នកកុំឱ្យធ្វើការងារដែលអ្នកអាចផ្ទេរសិទ្ធិទៅឧបករណ៍ mysql ។ វិធីនេះអ្នកត្រូវសរសេរកូដតិច ហើយក្នុង 90% នៃករណីប្រព័ន្ធបែបនេះនឹងដំណើរការកាន់តែមានស្ថេរភាព។ សាកល្បងពីបទពិសោធន៍ផ្ទាល់ខ្លួនរបស់ខ្ញុំ។ ខ្ញុំសង្ឃឹមថាអត្ថបទនេះនឹងមានប្រយោជន៍សម្រាប់អ្នកអ្នកអានជាទីគោរព! សូមគោរព Shinobi របស់អ្នក។
ដើម្បីចាប់ផ្តើម ខ្ញុំចង់ប៉ះលើប្រធានបទនៃទម្រង់ណាដែលល្អបំផុតដើម្បីរក្សាទុកកាលបរិច្ឆេទនៅក្នុងមូលដ្ឋានទិន្នន័យ៖ TIMESTAMPឬ DATETIME. សំណួរនេះបាននិងកំពុងត្រូវបានលើកឡើងជាច្រើនដងនៅលើវេទិកា ប្លក់ ជាដើម។ ប៉ុន្តែដើម្បីកុំឱ្យបញ្ជូនអ្នកទៅម៉ាស៊ីនស្វែងរកភ្លាមៗ ខ្ញុំនឹងព្យាយាមបង្ហាញភាពខុសគ្នាក្នុងពាក្យសាមញ្ញ និងជាមួយឧទាហរណ៍មួយ។ ប្រភេទ DATETIME- រក្សាទុកតម្លៃកាលបរិច្ឆេទក្នុងទម្រង់ "YYYY-MM-DD HH:MM:SS" និងមិនអាស្រ័យលើតំបន់ពេលវេលា។ TIMESTAMP- រក្សាទុកត្រាពេលវេលា, i.e. ចំនួនវិនាទីដែលបានកន្លងផុតទៅចាប់តាំងពីថ្ងៃទី 1 ខែមករាឆ្នាំ 1970 ។ MySQL បំប្លែងតម្លៃទាំងនេះដោយគិតគូរពីតំបន់ពេលវេលាបច្ចុប្បន្ន ទាំងនៅពេលសរសេរទៅកាន់មូលដ្ឋានទិន្នន័យ និងពេលចេញលទ្ធផលពីវា។ តើនេះមានន័យយ៉ាងណា...
ជាឧទាហរណ៍ អ្នកទើបតែបានបន្ថែមអត្ថបទមួយទៅមូលដ្ឋានទិន្នន័យ ហើយនៅលើប្រតិទិនរបស់អ្នកវាគឺជាខែមករា 2014 ដំបូង ហើយនៅលើនាឡិការបស់អ្នកគឺម៉ោង 01:00។ ប្រសិនបើវាលកាលបរិច្ឆេទជាប្រភេទ DATETIME នោះអ្នកគ្រប់គ្នាដែលចូលមើលគេហទំព័រនឹងឃើញកាលបរិច្ឆេទ និងពេលវេលានេះយ៉ាងពិតប្រាកដ ដោយមិនគិតពីទីកន្លែងរស់នៅរបស់ពួកគេ។ អ្វីៗហាក់ដូចជាល្អ ប៉ុន្តែអ្នកប្រើប្រាស់ ( តោះហៅគាត់ថា Bill G), រស់នៅកន្លែងណាមួយក្នុងទីក្រុងញូវយ៉ក, ខែមករាដំបូងមិនទាន់មកដល់ - សម្រាប់គាត់វាគឺថ្ងៃទី 31 ខែធ្នូឆ្នាំ 2013 ហើយនាឡិការបស់គាត់បង្ហាញម៉ោង 19:00 ។ គាត់ឆ្ងល់បន្តិចព្រោះ... គាត់មិនទាន់បានចាប់ផ្តើមប្រារព្ធពិធីចូលឆ្នាំថ្មីនៅឡើយទេ ប៉ុន្តែគាត់កំពុងស្រមៃមើល "អត្ថបទពីអនាគត" រួចហើយ ;) វានឹងមិនកើតឡើងជាមួយប្រភេទ TIMESTAMP ទេ ពីព្រោះ នៅពេលចេញលទ្ធផល តំបន់ពេលវេលារបស់វានឹងត្រូវបានយកមកពិចារណា។
“អ្វីគ្រប់យ៉ាងគឺច្បាស់ហើយ!” អ្នកនិយាយហើយប្តូរវាលកាលបរិច្ឆេទទាំងអស់យ៉ាងលឿនទៅជាប្រភេទ TIMESTAMP ហើយ Bill G នឹងដកដង្ហើមធំ ប៉ុន្តែមិនយូរទេ។ នៅពេលចុះឈ្មោះនៅលើគេហទំព័ររបស់អ្នក Bill បានចង្អុលបង្ហាញកាលបរិច្ឆេទនិងពេលវេលានៃកំណើតរបស់គាត់។ ធ្វើដំណើរជុំវិញពិភពលោក គាត់តែងតែមើលគេហទំព័ររបស់អ្នក ហើយស្វែងយល់ដោយភាពភ័យរន្ធត់ថា ពេលវេលា និង ពេលខ្លះថ្ងៃខែឆ្នាំកំណើតរបស់គាត់ តែងតែខុសគ្នា ដោយសារតែ... ត្រូវបានបង្ហាញដោយគិតគូរពីតំបន់ពេលវេលាដែលគាត់ស្ថិតនៅបច្ចុប្បន្ន។ បាទ ក្នុងករណីនេះ ប្រភេទ TIMESTAMP បានលេងសើចយ៉ាងសាហាវ។
យើងសន្និដ្ឋានថាសម្រាប់កិច្ចការជាក់លាក់ អ្នកត្រូវជ្រើសរើសប្រភេទវាលដែលសមស្រប ឬគ្រប់គ្រងការថត/លទ្ធផល អាស្រ័យលើលទ្ធផលដែលចង់បាន។
ចូរបន្តទៅបញ្ហាពេញនិយម និងជម្រើសសម្រាប់ដោះស្រាយពួកគេ។ ជ្រើសរើសកំណត់ត្រាក្នុងចន្លោះកាលបរិច្ឆេទដែលបានបញ្ជាក់ i.e. សម្រាប់រយៈពេលជាក់លាក់មួយ។
ជ្រើសរើស * ពី `table_name` កន្លែង `date_field` រវាង "2014-07-05" និង "2014-07-15" បញ្ជាទិញដោយ `date_field`;
កំណត់ត្រាទាំងអស់នឹងត្រូវបានជ្រើសរើសដែលកាលបរិច្ឆេទនៅក្នុងវាល "date_field" នឹងស្ថិតនៅក្នុងចន្លោះពីថ្ងៃទី 5 ខែកក្កដា ឆ្នាំ 2014 ដល់ថ្ងៃទី 15 ខែកក្កដា ឆ្នាំ 2014 រួមទាំងកាលបរិច្ឆេទដែលបានបញ្ជាក់ផងដែរ។ យើងមិនត្រូវភ្លេចថាតាមកាលបរិច្ឆេទលំនាំដើមក្នុង MySQL ត្រូវបានរក្សាទុកក្នុងទម្រង់ "YYYY-MM-DD HH:MM:SS" ហើយតាមនោះ ទម្រង់របាំងមុខគឺ "%Y-%m-%d %H:%i: %s" (ស្តង់ដារ អាយអេសអូ) តើធ្វើដូចម្តេចដើម្បីដោះស្រាយបញ្ហាប្រសិនបើកាលបរិច្ឆេទមិនមកក្នុងទម្រង់នេះ? ចូរយើងបោះបង់ជម្រើស PHP ហើយមើលពីរបៀបដែលវាអាចត្រូវបានធ្វើនៅក្នុងសំណើដោយខ្លួនឯង។ ហើយសម្រាប់គោលបំណងបែបនេះយើងនឹងត្រូវការមុខងារ STR_TO_DATE(). វាក្យសម្ពន្ធ៖ STR_TO_DATE(str, ទម្រង់), កន្លែងណា " str"- ខ្សែអក្សរកាលបរិច្ឆេទ និង " ទម្រង់" គឺជាទម្រង់ដែលត្រូវនឹងវា។ តោះសាកល្បង៖
SELECT STR_TO_DATE("12/31/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" */
លទ្ធផលនៃការប្រតិបត្តិគឺជាកាលបរិច្ឆេទក្នុងទម្រង់ដែលត្រូវបានប្រើតាមលំនាំដើមក្នុង MySQL ។ នោះគឺយើងត្រូវបញ្ជាក់មិនមែនជាទម្រង់ដែលយើងចង់ទទួលបានកាលបរិច្ឆេទលទ្ធផលនោះទេ ប៉ុន្តែជាទម្រង់ដែលយើងផ្តល់កាលបរិច្ឆេទសម្រាប់ដំណើរការ។ ដោយប្រើវិធីសាស្ត្រនេះ ធាតុខាងលើរបស់យើងអាចមើលទៅដូចនេះ៖
ជ្រើសរើស * ពី `table_name` WHERE `date_field` BETWEEN STR_TO_DATE("07/05/2014", "%d.%m.%Y") និង STR_TO_DATE("ថ្ងៃទី 15 ខែកក្កដា ឆ្នាំ 2014", "%M %d,%Y" ") បញ្ជាទិញដោយ `date_field`;
ដោយសារយើងបានប៉ះលើបញ្ហានៃការធ្វើទ្រង់ទ្រាយកាលបរិច្ឆេទ សូមមើលរបៀបទទួលបានកាលបរិច្ឆេទនៅពេលដែលយកគំរូតាមទម្រង់ដែលយើងត្រូវការ ព្រោះ មនុស្សជាច្រើនមានទម្លាប់មើលឃើញ "12/31/2014" ឬ "31 ធ្នូ 2014" ជាង "2014-12-31" ។ សម្រាប់គោលបំណងបែបនេះសូមប្រើមុខងារ DATE_FORMAT(). វាក្យសម្ពន្ធ៖ DATE_FORMAT(កាលបរិច្ឆេទ ទម្រង់), កន្លែងណា " កាលបរិច្ឆេទ"- ខ្សែអក្សរកាលបរិច្ឆេទ និង " ទម្រង់" - ទម្រង់ដែលត្រូវបំប្លែងទៅជា " កាលបរិច្ឆេទ"។ មិនដូចមុខងារ STR_TO_DATE() ទេ យើងខ្លួនយើងផ្ទាល់បង្ហាញពីទម្រង់លទ្ធផលដែលចង់បាន ប៉ុន្តែកាលបរិច្ឆេទត្រូវតែបញ្ជាក់ជាទម្រង់ ISO ពោលគឺ "YYYY-MM-DD HH:MM:SS" យើងពិនិត្យមើល៖
SELECT DATE_FORMAT("2014-12-31", "%d.%m.%Y"); // 12/31/2014 SELECT DATE_FORMAT("2014-12-31", "%d %M %Y"); // ថ្ងៃទី ៣១ ខែ ធ្នូ ឆ្នាំ ២០១៤
ប្រសិនបើយើងកំពុងប្រាស្រ័យទាក់ទងជាមួយអ្នកក្នុងពេលជាក់ស្តែង នោះនៅចំណុចនេះ សំណួរនឹងកើតឡើងភ្លាមៗ៖ ប៉ុន្តែរបៀបបង្ហាញខែជាភាសាផ្សេងទៀត៖ អ៊ុយក្រែន រុស្ស៊ី ឬចិន?"វាសាមញ្ញណាស់ - កំណត់មូលដ្ឋានដែលត្រូវការ។ ហើយនេះអាចត្រូវបានធ្វើទាំងនៅក្នុងឯកសារកំណត់រចនាសម្ព័ន្ធ MySQL (my.cnf) ឬសាមញ្ញជាមួយសំណើពី PHP បន្ទាប់ពីភ្ជាប់ទៅមូលដ្ឋានទិន្នន័យ និងមុនពេលសំណួរចម្បង៖
SET lc_time_names = ru_RU; ជ្រើសរើស DATE_FORMAT("2014-12-31", "%d %M %Y"); // លទ្ធផល៖ ថ្ងៃទី ៣១ ខែធ្នូ ឆ្នាំ ២០១៤ // ប្រសិនបើចង់បាន អ្នកក៏អាចបន្ថែម “g” ផងដែរ។ ឬ "ឆ្នាំ" SELECT DATE_FORMAT("2014-12-31", "%d %M %Y year"); // លទ្ធផល៖ ថ្ងៃទី ៣១ ខែ ធ្នូ ឆ្នាំ ២០១៤
សម្រស់! ;) និងឧទាហរណ៍មួយចំនួនទៀតនៃសំណើដែលត្រូវការជាញឹកញាប់ផងដែរ ប៉ុន្តែបណ្តាលឱ្យមានការភ័ន្តច្រឡំក្នុងចំណោមអ្នកចាប់ផ្តើមដំបូង។
// ជ្រើសរើសកំណត់ត្រាសម្រាប់ថ្ងៃបច្ចុប្បន្ន SELECT * FROM `table_name` WHERE `date_field` >= CURDATE(); // កំណត់ត្រាទាំងអស់សម្រាប់ម្សិលមិញ SELECT * FROM `table_name` WHERE `date_field` >= DATE_SUB(CURDATE(), INTERVAL 1 DAY) និង `date_field` NOW() - INTERVAL 30 DAY; // ជ្រើសរើសអ្វីគ្រប់យ៉ាងសម្រាប់ខែជាក់លាក់នៃឆ្នាំបច្ចុប្បន្ន (ឧទាហរណ៍ ខែឧសភា) ជ្រើសរើស * ពី `table_name` WHERE YEAR(`date_field`) = YEAR(NOW()) AND MONTH(`date_field`) = 5 ; // ឬសម្រាប់ខែឧសភា ប៉ុន្តែក្នុងឆ្នាំ 2009 SELECT * FROM `table_name` WHERE YEAR(`date_field`) = 2009 AND MONTH(`date_field`) = 5;
ខ្ញុំមិនឃើញចំណុចក្នុងការពិពណ៌នាលម្អិតអំពីមុខងារ MySQL ដែលប្រើក្នុងឧទាហរណ៍ទេ ព្រោះ... ពួកគេមានវិចារណញាណ ហើយសម្រាប់អ្នកដែលមានចំណេះដឹងភាសាអង់គ្លេសតិចតួច វានឹងមិនមានការលំបាកក្នុងការយល់ដឹងថា ឧទាហរណ៍ មុខងារ ខែ()ត្រឡប់ខែនៃកាលបរិច្ឆេទ, ឆ្នាំ()- ឆ្នាំរបស់នាងនិង ថ្ងៃ() (ឬមានន័យដូច DAYOFMONTH()) - ថ្ងៃ។ ពាក្យគន្លឹះ ចន្លោះពេល- បម្រើសម្រាប់ប្រតិបត្តិការនព្វន្ធតាមកាលបរិច្ឆេទ និងការផ្លាស់ប្តូររបស់វា។
SELECT "2014-07-07 23:59:59" + INTERVAL 1 SECOND; // លទ្ធផល៖ 2014-07-08 00:00:00 SELECT "2014-07-07 23:59:59" + INTERVAL 1 DAY; // លទ្ធផល: 2014-07-08 23:59:59 // រឿងដដែល។ ប៉ុន្តែការប្រើមុខងារ DATE_ADD() SELECT DATE_ADD("2014-07-07 23:59:59", INTERVAL 1 DAY); // 2014-07-08 23:59:59 // ប្រសិនបើអ្នកត្រូវការដកជាជាងបន្ថែម SELECT DATE_SUB("2014-07-07 23:59:59", INTERVAL 1 DAY); // 2014-07-06 23:59:59 // ឬគ្រាន់តែដូចនោះ SELECT "2014-07-07 23:59:59" - INTERVAL 1 DAY; // 2014-07-06 23:59:59
ទាំងនេះមិនមែនជាមុខងារទាំងអស់សម្រាប់ធ្វើការជាមួយកាលបរិច្ឆេទទេ ហើយខ្ញុំសូមណែនាំអ្នកឱ្យឆ្លងកាត់ពួកវាសម្រាប់គោលបំណងផ្តល់ព័ត៌មាននៅលើគេហទំព័រផ្លូវការ ដើម្បីដឹងអំពីអត្ថិភាពរបស់វា ប្រសិនបើស្ថានភាពមិនស្តង់ដារកើតឡើង។ ប៉ុន្តែខ្ញុំចង់សង្ឃឹមថាសូម្បីតែទិដ្ឋភាពទូទៅតូចមួយនៃមុខងារ MySQL សម្រាប់ធ្វើការជាមួយកាលបរិច្ឆេទនៅក្នុងអត្ថបទនេះនឹងជួយអ្នកក្នុងការរុករកស្ថានភាព និងធ្វើការសម្រេចចិត្តត្រឹមត្រូវ។ ប្រសិនបើការលំបាកនៅតែកើតឡើងបន្ទាប់មកសួរសំណួរក្នុងប្រធានបទនេះ ឬផ្នែក "សំណួររបស់អ្នក"។ យើងនឹងដោះស្រាយជាមួយគ្នា ;)
ដូច្នេះ ប្រភេទទិន្នន័យប្រតិទិនទាំងអស់ត្រូវបានពិពណ៌នាលម្អិតនៅក្នុងផ្នែក “10.3. ប្រភេទកាលបរិច្ឆេទ និងពេលវេលា » ការបង្រៀន MySQL ។ ព័ត៌មានសំខាន់ៗទាក់ទងនឹងការគាំទ្រ DBMS សម្រាប់តំបន់ពេលវេលាត្រូវបានពិពណ៌នានៅក្នុងផ្នែក “9.7. ការគាំទ្រតំបន់ពេលវេលាម៉ាស៊ីនមេ MySQL" ។ អ្វីគ្រប់យ៉ាងដូចខាងក្រោមគឺផ្អែកលើការសិក្សាសៀវភៅដៃ។ ក្នុងពេលជាមួយគ្នានេះ មានតែការមិនពេញចិត្តក្នុងការជ្រើសរើសប្រភេទមួយ ឬប្រភេទផ្សេងទៀតប៉ុណ្ណោះដែលត្រូវបានចង្អុលបង្ហាញនៅទីនេះ ដូច្នេះសម្ភារៈនេះមិនជំនួសសៀវភៅដៃតាមមធ្យោបាយណាមួយឡើយ ប៉ុន្តែបំពេញបន្ថែមវា។
ជាដំបូង ការពិពណ៌នាសង្ខេបនៃប្រភេទនីមួយៗ៖
- TIMESTAMP - ប្រភេទទិន្នន័យសម្រាប់រក្សាទុកកាលបរិច្ឆេទ និងពេលវេលា។ ទិន្នន័យត្រូវបានរក្សាទុកជាចំនួនវិនាទីដែលបានកន្លងផុតទៅចាប់តាំងពីការចាប់ផ្តើមនៃ "យុគសម័យយូនីក"។ ជួរតម្លៃ៖ 1970-01-01 00:00:00 - 2038-12-31 00:00:00 ។ កាន់កាប់ 4 បៃ។
- YEAR - ប្រភេទទិន្នន័យសម្រាប់រក្សាទុកឆ្នាំ។ ជួរតម្លៃ៖ 1901 - 2155. កាន់កាប់ 1 បៃ។
- DATE គឺជាប្រភេទទិន្នន័យសម្រាប់រក្សាទុកកាលបរិច្ឆេទ។ ជួរតម្លៃ៖ 1000-01-01 - 9999-12-31 ។ កាន់កាប់ 3 បៃ។
- TIME គឺជាប្រភេទទិន្នន័យសម្រាប់រក្សាទុកពេលវេលា។ ជួរតម្លៃ៖ −828:59:59 - 828:59:59 ។ កាន់កាប់ 3 បៃ។
- DATETIME គឺជាប្រភេទទិន្នន័យសម្រាប់រក្សាទុកកាលបរិច្ឆេទ និងពេលវេលា។ ជួរតម្លៃ៖ 1000-01-01 00:00:00 - 9999-12-31 00:00:00 ។ កាន់កាប់ 8 បៃ។
បន្ទាប់ពីការវិភាគការពិពណ៌នានៃប្រភេទដែលបានបង្ហាញខាងលើអ្នកអាចទាញការសន្និដ្ឋានស្ទើរតែទាំងអស់អំពីគុណសម្បត្តិនិងគុណវិបត្តិនៃប្រភេទមួយចំនួន។ អ្វីគ្រប់យ៉ាងគឺសាមញ្ញនិងជាក់ស្តែង។
ប៉ុន្តែមុននឹងនិយាយអំពីការប្រើប្រាស់ប្រភេទទាំងនេះ ខ្ញុំចង់កត់សម្គាល់ថានៅក្នុងការអនុវត្តប្រភេទមួយផ្សេងទៀតត្រូវបានគេប្រើជាញឹកញាប់ដើម្បីរក្សាទុកកាលបរិច្ឆេទ និងពេលវេលា៖ តម្លៃចំនួនគត់ (សម្រាប់រក្សាទុកកាលបរិច្ឆេទ - INT (4 បៃ) កាលបរិច្ឆេទ និងពេលវេលា - BIGINT (8 បៃ។ )) ភាពខុសគ្នាតែមួយគត់រវាងការប្រើប្រាស់ប្រភេទចំនួនគត់ និង DATE និង DATETIME គឺថាទិន្នន័យមិនត្រូវបានធ្វើទ្រង់ទ្រាយកំឡុងពេលលទ្ធផល ហើយនៅក្នុងការគណនាជាមួយកាលបរិច្ឆេទ និងពេលវេលា ចំនួនគត់ត្រូវតែបំប្លែងទៅជាប្រភេទប្រតិទិនសមស្រប។ លើសពីនេះទៀតមិនមានការត្រួតពិនិត្យសម្រាប់សុពលភាពនៃតម្លៃដែលបានបង្ហាញមុនពេលរក្សាទុកទេ។ សមត្ថភាពតម្រៀបត្រូវបានរក្សាទុក។ ដូច្នេះវាសមហេតុផលក្នុងការប្រើ INT និង BIGINT នៅក្នុងករណីដូចគ្នាទៅនឹង DATE និង DATETIME ដើម្បីបង្កើនភាពងាយស្រួល និងឯករាជ្យភាពពី DBMS ។ ខ្ញុំមិនឃើញមានអត្ថប្រយោជន៍ផ្សេងទៀតទេ បើមានខ្ញុំស្នើឱ្យអ្នកបង្ហាញវានៅក្នុងមតិយោបល់។
ការប្រើប្រាស់ប្រភេទទិន្នន័យប្រតិទិននៅក្នុង MySQL
ចូរចាប់ផ្តើមជាមួយសាមញ្ញបំផុត - ប្រភេទ ឆ្នាំ. អត្ថប្រយោជន៍តែមួយគត់របស់វាគឺទំហំតូចរបស់វា - ត្រឹមតែ 1 បៃ។ ប៉ុន្តែដោយសារតែវាមានការកំណត់យ៉ាងតឹងរ៉ឹងលើជួរតម្លៃត្រឹមត្រូវ (ប្រភេទអាចទុកបានតែ២៥៥តម្លៃផ្សេងគ្នា)។ ខ្ញុំមានការលំបាកក្នុងការស្រមៃមើលស្ថានភាពជាក់ស្តែងដែលមនុស្សម្នាក់អាចចង់រក្សាទុកឆ្នាំយ៉ាងតឹងរ៉ឹងក្នុងចន្លោះពីឆ្នាំ 1901 ដល់ឆ្នាំ 2155។ លើសពីនេះ ប្រភេទ SMALLINT (2 បៃ) ផ្តល់នូវជួរដែលគ្រប់គ្រាន់ក្នុងស្ថានភាពភាគច្រើនដើម្បីរក្សាទុកក្នុងមួយឆ្នាំ។ ហើយការរក្សាទុក 1 បៃក្នុងមួយជួរក្នុងតារាងមូលដ្ឋានទិន្នន័យមិនសមហេតុផលទេនៅក្នុងពេលវេលារបស់យើង។ប្រភេទ DATEនិង DATETIMEអាចត្រូវបានរួមបញ្ចូលគ្នាជាក្រុមមួយ។ ពួកគេរក្សាទុកកាលបរិច្ឆេទ ឬកាលបរិច្ឆេទ និងពេលវេលាជាមួយនឹងជួរដ៏ធំទូលាយនៃតម្លៃត្រឹមត្រូវ ដោយឯករាជ្យពីតំបន់ពេលវេលាដែលបានកំណត់នៅលើម៉ាស៊ីនមេ។ ការប្រើប្រាស់របស់ពួកគេពិតជាធ្វើឱ្យយល់បានជាក់ស្តែង។ ប៉ុន្តែប្រសិនបើអ្នកចង់រក្សាទុកកាលបរិច្ឆេទសម្រាប់ព្រឹត្តិការណ៍ប្រវត្តិសាស្ត្រដែលត្រលប់ទៅហួសសម័យធម្មតា អ្នកនឹងត្រូវជ្រើសរើសប្រភេទទិន្នន័យផ្សេងទៀត។ ប្រភេទទាំងនេះគឺល្អសម្រាប់ការរក្សាទុកកាលបរិច្ឆេទសម្រាប់ព្រឹត្តិការណ៍មួយចំនួនដែលមានសក្តានុពលនៅក្រៅជួរនៃប្រភេទ TIMESTAMP (ថ្ងៃកំណើត កាលបរិច្ឆេទចេញផ្សាយផលិតផល ការបោះឆ្នោតប្រធានាធិបតី ការបាញ់បង្ហោះរ៉ុក្កែតអវកាស។ល។)។ នៅពេលប្រើប្រភេទទាំងនេះ អ្នកត្រូវគិតគូរពីចំណុចសំខាន់មួយ ប៉ុន្តែបន្ថែមលើវាខាងក្រោម។
ប្រភេទ ម៉ោងអាចត្រូវបានប្រើដើម្បីរក្សាទុករយៈពេលដែលភាពត្រឹមត្រូវតិចជាង 1 វិនាទីមិនត្រូវការ ហើយរយៈពេលតិចជាង 829 ម៉ោង។ មិនមានអ្វីបន្ថែមនៅទីនេះទេ។
ប្រភេទគួរឱ្យចាប់អារម្មណ៍បំផុតនៅតែមាន - TIMESTAMP. វាគួរតែត្រូវបានពិចារណាដោយប្រៀបធៀបជាមួយ DATE និង DATETIME៖ TIMESTAMP ក៏ត្រូវបានរចនាឡើងដើម្បីរក្សាទុកកាលបរិច្ឆេទ និង/ឬពេលវេលានៃការកើតឡើងនៃព្រឹត្តិការណ៍មួយចំនួន។ ភាពខុសគ្នាដ៏សំខាន់មួយរវាងពួកវាគឺស្ថិតនៅក្នុងជួរនៃតម្លៃ៖ ជាក់ស្តែង TIMESTAMP មិនស័ក្តិសមសម្រាប់ការរក្សាទុកព្រឹត្តិការណ៍ប្រវត្តិសាស្ត្រ (សូម្បីតែដូចជាថ្ងៃកំណើត) ប៉ុន្តែគឺល្អបំផុតសម្រាប់ការរក្សាទុកបច្ចុប្បន្ន (ការកត់ត្រា កាលបរិច្ឆេទនៃការបង្ហោះអត្ថបទ ការបន្ថែមផលិតផល ការដាក់ការបញ្ជាទិញ) និងព្រឹត្តិការណ៍ដែលនឹងមកដល់នាពេលខាងមុខនៅក្នុងព្រឹត្តិការណ៍នាពេលអនាគតដែលអាចមើលឃើញ (ការចេញផ្សាយកំណែថ្មី ប្រតិទិន និងកម្មវិធីកំណត់ពេលជាដើម)។
ភាពងាយស្រួលចម្បងនៃការប្រើប្រាស់ប្រភេទ TIMESTAMP គឺថាសម្រាប់ជួរឈរនៃប្រភេទនេះនៅក្នុងតារាង អ្នកអាចកំណត់តម្លៃលំនាំដើមក្នុងទម្រង់នៃការជំនួសនៃពេលវេលាបច្ចុប្បន្ន ក៏ដូចជាការកំណត់ពេលវេលាបច្ចុប្បន្ននៅពេលធ្វើបច្ចុប្បន្នភាពកំណត់ត្រាមួយ។ ប្រសិនបើអ្នកត្រូវការលក្ខណៈពិសេសទាំងនេះ នោះមានឱកាស 99% ដែល TIMESTAMP គឺជាអ្វីដែលអ្នកត្រូវការ។ (សូមមើលសៀវភៅណែនាំអំពីរបៀបធ្វើវា។ )
កុំខ្លាចថាកម្មវិធីរបស់អ្នកនឹងឈប់ដំណើរការ នៅពេលដែលយើងខិតជិតដល់ឆ្នាំ 2038។ ទីមួយ មុនពេលនេះ កម្មវិធីរបស់អ្នកទំនងជានឹងត្រូវបានបញ្ឈប់ការប្រើប្រាស់ (ជាពិសេសកំណែដែលត្រូវបានសរសេរឥឡូវនេះ)។ ទីពីរ នៅពេលដែលកាលបរិច្ឆេទនេះខិតជិតមកដល់ អ្នកអភិវឌ្ឍន៍ MySQL ពិតជានឹងមករកអ្វីមួយដើម្បីរក្សាកម្មវិធីរបស់អ្នកឱ្យដំណើរការ។ អ្វីគ្រប់យ៉ាងនឹងត្រូវបានដោះស្រាយក៏ដូចជាបញ្ហា Y2K ។
ដូច្នេះ យើងប្រើប្រភេទ TIMESTAMP ដើម្បីរក្សាទុកកាលបរិច្ឆេទ និងពេលវេលានៃព្រឹត្តិការណ៍នៃពេលវេលារបស់យើង និង DATETIME និង DATE ដើម្បីរក្សាទុកកាលបរិច្ឆេទ និងពេលវេលានៃព្រឹត្តិការណ៍ប្រវត្តិសាស្ត្រ ឬព្រឹត្តិការណ៍នៃអនាគតដ៏ជ្រាលជ្រៅ។
ជួរតម្លៃគឺជាភាពខុសគ្នាដ៏សំខាន់រវាងប្រភេទ TIMESTAMP, DATETIME, និង DATE ប៉ុន្តែពួកវាមិនមែនជាភាពខុសគ្នាសំខាន់នោះទេ។ មេដែល TIMESTAMP រក្សាទុកតម្លៃនៅក្នុង UTC ។ នៅពេលរក្សាទុកតម្លៃ វាត្រូវបានបកប្រែពីតំបន់ពេលវេលាបច្ចុប្បន្នទៅជា UTC ហើយនៅពេលអានវា វាត្រូវបានបកប្រែពីតំបន់ពេលវេលាបច្ចុប្បន្នពី UTC ។ DATETIME និង DATE តែងតែរក្សាទុក និងបង្ហាញពេលវេលាដូចគ្នា ដោយមិនគិតពីតំបន់ពេលវេលា។
តំបន់ពេលវេលាត្រូវបានកំណត់ជាសកលនៅក្នុង MySQL DBMS ឬ សម្រាប់ការតភ្ជាប់បច្ចុប្បន្នក្រោយមកទៀតអាចត្រូវបានប្រើដើម្បីធានានូវការងាររបស់អ្នកប្រើប្រាស់ផ្សេងៗគ្នានៅក្នុងតំបន់ពេលវេលាផ្សេងៗគ្នានៅកម្រិត DBMS ។ តម្លៃពេលវេលាទាំងអស់នឹងត្រូវបានរក្សាទុកជារូបវ័ន្តនៅក្នុង UTC ហើយបានទទួលពីអតិថិជន និងផ្តល់ទៅឱ្យអតិថិជន - នៅក្នុងតម្លៃនៃតំបន់ពេលវេលារបស់គាត់។ ប៉ុន្តែនៅពេលប្រើប្រភេទទិន្នន័យ TIMESTAMP ប៉ុណ្ណោះ។ DATE និង DATETIME តែងតែទទួល រក្សាទុក និងត្រឡប់តម្លៃដូចគ្នា។
មុខងារ NOW() និងសទិសន័យរបស់វាត្រឡប់តម្លៃពេលវេលានៅក្នុងតំបន់ពេលវេលាបច្ចុប្បន្នរបស់អ្នកប្រើ។
ដោយគិតពីកាលៈទេសៈទាំងអស់នេះ អ្នកត្រូវតែមានការប្រុងប្រយ័ត្នបំផុតនៅពេលផ្លាស់ប្តូរតំបន់ពេលវេលានៅក្នុងការតភ្ជាប់ទៅម៉ាស៊ីនមេ និងប្រើប្រាស់ប្រភេទ DATE និង DATETIME។ ប្រសិនបើអ្នកត្រូវការរក្សាទុកកាលបរិច្ឆេទ (ឧទាហរណ៍ថ្ងៃខែឆ្នាំកំណើត) នោះនឹងមិនមានបញ្ហាអ្វីទេ។ ថ្ងៃខែឆ្នាំកំណើតគឺដូចគ្នានៅក្នុងតំបន់ណាមួយ។ ទាំងនោះ។ ប្រសិនបើអ្នកកើតនៅថ្ងៃទី 1 ខែមករា វេលាម៉ោង 0:00 UTC/GMT+0 នោះនេះគឺជា ទេ។មានន័យថា នៅអាមេរិក ពួកគេនឹងប្រារព្ធខួបកំណើតរបស់អ្នកនៅថ្ងៃទី 31 ខែធ្នូ។ ប៉ុន្តែប្រសិនបើអ្នកសម្រេចចិត្តរក្សាទុក ពេលវេលាព្រឹត្តិការណ៍នៅក្នុងជួរ DATETIME បន្ទាប់មកវានឹងមិនអាចដំណើរការជាមួយតំបន់ពេលវេលារបស់អ្នកប្រើប្រាស់នៅកម្រិត DBMS បានទេ។ ខ្ញុំសូមពន្យល់ជាមួយឧទាហរណ៍៖
អ្នកប្រើប្រាស់ X ធ្វើការនៅក្នុងតំបន់ UTC/GMT+2, Y - នៅក្នុងតំបន់ UTC/GMT+3។ សម្រាប់ការតភ្ជាប់របស់អ្នកប្រើទៅកាន់ MySQL តំបន់ពេលវេលាដែលត្រូវគ្នា (នីមួយៗមានរបស់វា) ត្រូវបានកំណត់។ អ្នកប្រើប្រាស់បង្ហោះសារនៅលើវេទិកា យើងចាប់អារម្មណ៍លើកាលបរិច្ឆេទដែលសារត្រូវបានសរសេរ។
ជម្រើសទី 1៖ DATETIME។ អ្នកប្រើប្រាស់ X សរសេរសារនៅម៉ោង 14:00 UTC/GMT+2។ តម្លៃនៅក្នុងវាល "កាលបរិច្ឆេទ" នៃសារត្រូវបានជំនួសជាលទ្ធផលនៃការប្រតិបត្តិមុខងារ NOW() - 14:00 ។ អ្នកប្រើប្រាស់ Y អានពេលវេលាដែលសារត្រូវបានសរសេរ ហើយឃើញដូចគ្នានៅម៉ោង 14:00 ។ ប៉ុន្តែការកំណត់របស់គាត់ត្រូវបានកំណត់ទៅ UTC/GMT+3 ហើយគាត់គិតថាសារនេះត្រូវបានសរសេរមិនមែនទើបតែពេលនេះទេ ប៉ុន្តែមួយម៉ោងមុន។
ជម្រើសទី 2៖ TIMESTAMP អ្នកប្រើប្រាស់ X សរសេរសារនៅម៉ោង 14:00 UTC/GMT+2។ វាល "កាលបរិច្ឆេទ" មានលទ្ធផលនៃការប្រតិបត្តិមុខងារ NOW() - ក្នុងករណីនេះ - 12:00 UTC/GMT+0 ។ UserY អានពេលវេលាដែលសារត្រូវបានសរសេរ និងទទួល (UTC/GMT+3)(12:00 UTC/GMT+0) = 15:00 UTC/GMT+3។ អ្វីគ្រប់យ៉ាងប្រែទៅជាពិតជារបៀបដែលយើងចង់បាន។ ហើយសំខាន់បំផុត វាងាយស្រួលប្រើខ្លាំងណាស់៖ ដើម្បីគាំទ្រតំបន់ពេលវេលាផ្ទាល់ខ្លួន អ្នកមិនចាំបាច់សរសេរកូដបំប្លែងពេលវេលាណាមួយឡើយ។
លទ្ធភាពនៃការជំនួសម៉ោងបច្ចុប្បន្ន និងធ្វើការជាមួយតំបន់ពេលវេលាក្នុងប្រភេទ TIMESTAMP គឺមានឥទ្ធិពលខ្លាំងណាស់ ដែលប្រសិនបើអ្នកត្រូវការរក្សាទុកកាលបរិច្ឆេទដោយគ្មានពេលវេលានៅក្នុងកំណត់ហេតុជាក់លាក់ អ្នកនៅតែគួរប្រើ TIMESTAMP ជំនួសឱ្យ DATE ដោយមិនរក្សាទុក 1 បៃនៃភាពខុសគ្នា រវាងពួកគេ។ ក្នុងករណីនេះគ្រាន់តែមិនអើពើ "00:00:00" ។
ប្រសិនបើអ្នកមិនអាចប្រើ TIMESTAMP ដោយសារតែជួរតម្លៃរបស់វាតូច (ជាធម្មតា 1-2 ករណីធៀបនឹង 10-15 នៅក្នុងមូលដ្ឋានទិន្នន័យគេហទំព័រ) អ្នកនឹងត្រូវប្រើ DATETIME ហើយកែតម្រូវតម្លៃរបស់វាដោយប្រុងប្រយ័ត្ននៅកន្លែងដែលត្រឹមត្រូវ ( ឧ. ពេលសរសេរក្នុងវាលនេះ បំប្លែងកាលបរិច្ឆេទទៅជា UTC ហើយពេលអាន - ទៅម៉ោងក្នុងតំបន់អានរបស់អ្នកប្រើ)។ ប្រសិនបើអ្នកទុកតែកាលបរិច្ឆេទ នោះទំនងជាវាមិនមានបញ្ហាអ្វីទេដែលអ្នកមាន៖ មនុស្សគ្រប់គ្នាប្រារព្ធពិធីចូលឆ្នាំថ្មីនៅថ្ងៃទី 1 ខែមករា ម៉ោងក្នុងស្រុក ដូច្នេះអ្នកមិនចាំបាច់បកប្រែអ្វីនៅទីនេះទេ។
ខាងក្រោមនេះជាឧទាហរណ៍ដែលប្រើមុខងារកាលបរិច្ឆេទ។ សំណួរខាងក្រោមជ្រើសរើសកំណត់ត្រាទាំងអស់ដែលមានតម្លៃ date_col ក្នុងរយៈពេល 30 ថ្ងៃចុងក្រោយ៖
Mysql> ជ្រើសរើសអ្វីមួយពី tbl_name WHERE TO_DAYS(NOW()) - TO_DAYS(date_col)<= 30;
ត្រឡប់សន្ទស្សន៍នៃថ្ងៃនៃសប្តាហ៍សម្រាប់កាលបរិច្ឆេទ (0 = ថ្ងៃច័ន្ទ, 1 = ថ្ងៃអង្គារ, ... 6 = ថ្ងៃអាទិត្យ):
Mysql> SELECT WEEKDAY("1998-02-03 22:23:00");
-> 1 mysql> SELECT WEEKDAY("1997-11-05");
-> ២
DAYOFMONTH(កាលបរិច្ឆេទ)
ត្រឡប់លេខធម្មតានៃថ្ងៃនៃខែសម្រាប់អាគុយម៉ង់កាលបរិច្ឆេទក្នុងចន្លោះពី 1 ដល់ 31៖
Mysql> SELECT DAYOFMONTH("1998-02-03");
-> ៣
ត្រឡប់លេខធម្មតានៃថ្ងៃនៃឆ្នាំសម្រាប់អាគុយម៉ង់កាលបរិច្ឆេទក្នុងចន្លោះពី 1 ដល់ 366៖
ត្រឡប់ឈ្មោះថ្ងៃនៃសប្តាហ៍សម្រាប់អាគុយម៉ង់កាលបរិច្ឆេទ៖
Mysql> SELECT DAYNAME("1998-02-05");
-> "ថ្ងៃព្រហស្បតិ៍"
ត្រឡប់ឈ្មោះខែសម្រាប់អាគុយម៉ង់កាលបរិច្ឆេទ៖
Mysql> SELECT MONTHNAME("1998-02-05");
-> "កុម្ភៈ"
ត្រឡប់លេខត្រីមាសនៃឆ្នាំសម្រាប់អាគុយម៉ង់កាលបរិច្ឆេទចាប់ពី 1 ដល់ 4៖
Mysql> SELECT QUARTER("98-04-01");
-> ២
សប្តាហ៍(កាលបរិច្ឆេទ) សប្តាហ៍(កាលបរិច្ឆេទដំបូង)
ដែលបានផ្ដល់ឱ្យនូវអំណះអំណាងមួយ ត្រឡប់លេខលំដាប់ប្រចាំសប្តាហ៍នៃសប្តាហ៍ក្នុងឆ្នាំសម្រាប់កាលបរិច្ឆេទចាប់ពី 0 ដល់ 53 (បាទ ប្រហែលជាការចាប់ផ្តើមនៃសប្តាហ៍ទី 53) សម្រាប់តំបន់ដែលថ្ងៃអាទិត្យត្រូវបានចាត់ទុកថាជាថ្ងៃដំបូងនៃសប្តាហ៍។ ទម្រង់ WEEK() ដែលមានអាគុយម៉ង់ពីរអនុញ្ញាតឱ្យអ្នកបញ្ជាក់ថាតើសប្តាហ៍ចាប់ផ្តើមនៅថ្ងៃអាទិត្យឬថ្ងៃច័ន្ទ។ លទ្ធផលនឹងស្ថិតក្នុងចន្លោះ 0-53 ឬ 1-52។
នេះជារបៀបដែលអាគុយម៉ង់ទីពីរដំណើរការ៖
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);
-> ៥៣
ចំណាំ៖ នៅក្នុងកំណែ 4.0 មុខងារ WEEK(#,0) ត្រូវបានផ្លាស់ប្តូរដើម្បីផ្គូផ្គងប្រតិទិនសហរដ្ឋអាមេរិក។
ចំណាំថាប្រសិនបើសប្តាហ៍គឺជាសប្តាហ៍ចុងក្រោយនៃឆ្នាំមុននោះ MySQL នឹងត្រឡប់ 0 លុះត្រាតែអ្នកបញ្ជាក់ 2 ឬ 3 ជាអាគុយម៉ង់ស្រេចចិត្ត៖
Mysql> SELECT YEAR("2000-01-01"), WEEK("2000-01-01",0);
-> 2000, 0 mysql> SELECT WEEK("2000-01-01",2);
-> ៥២
ត្រឡប់ម៉ោងសម្រាប់អាគុយម៉ង់ពេលវេលា ចាប់ពី 0 ដល់ 23៖
Mysql> SELECT HOUR("10:05:03");
-> ១០
ត្រឡប់ចំនួននាទីសម្រាប់អាគុយម៉ង់ពេលវេលាដែលមានចាប់ពី 0 ដល់ 59៖
Mysql> SELECT MINUTE("98-02-03 10:05:03");
-> ៥
ត្រឡប់ចំនួនវិនាទីសម្រាប់អាគុយម៉ង់ពេលវេលាដែលមានចាប់ពី 0 ដល់ 59៖
Mysql> SELECT SECOND("10:05:03");
-> ៣
បន្ថែម N ខែទៅរយៈពេល P (ក្នុងទម្រង់ YYMM ឬ YYYYMM) ។ ត្រឡប់តម្លៃក្នុងទម្រង់ YYYYMM ។ ចំណាំថាអាគុយម៉ង់រយៈពេល P មិនមែនជាតម្លៃកាលបរិច្ឆេទទេ៖
Mysql> SELECT PERIOD_ADD(9801,2);
-> ឆ្នាំ ១៩៩៨០៣
PERIOD_DIFF(P1,P2)
ត្រឡប់ចំនួនខែរវាងអំឡុងពេល P1 និង P2 ។ P1 និង P2 ត្រូវតែជាទម្រង់ YYMM ឬ YYYYMM ។ ចំណាំថាអាគុយម៉ង់រយៈពេល P1 និង P2 មិនមែនជាតម្លៃកាលបរិច្ឆេទ៖
| Mysql> SELECT PERIOD_DIFF(9802,199703);-> ១១ | DATE_ADD(date,INTERVAL expr type), DATE_SUB(date,INTERVAL expr type), ADDDATE(date,INTERVAL expr type), SUBDATE(date,INTERVAL expr type) មុខងារទាំងនេះធ្វើប្រតិបត្តិការនព្វន្ធតាមកាលបរិច្ឆេទ។ ទាំងពីរគឺថ្មីនៅក្នុង MySQL 3.22 ។ អនុគមន៍ ADDDATE() និង SUBDATE() គឺជាសទិសន័យសម្រាប់ DATE_ADD() និង DATE_SUB() ។ នៅក្នុង MySQL 3.23 អ្នកអាចប្រើ + និង - operators ជំនួសឱ្យមុខងារ DATE_ADD() និង DATE_SUB() ប្រសិនបើកន្សោមខាងស្តាំគឺជាជួរឈរនៃប្រភេទ DATE ឬ DATETIME (សូមមើលឧទាហរណ៍ខាងក្រោម)។ អាគុយម៉ង់កាលបរិច្ឆេទគឺជាតម្លៃ DATETIME ឬ DATE ដែលបញ្ជាក់កាលបរិច្ឆេទចាប់ផ្តើម។ |
| កន្សោម expr បញ្ជាក់ចំនួនចន្លោះពេលដែលត្រូវបន្ថែម ឬដកពីកាលបរិច្ឆេទចាប់ផ្តើម។ កន្សោម expr គឺជាខ្សែអក្សរដែលអាចចាប់ផ្តើមជាមួយ - សម្រាប់តម្លៃចន្លោះពេលអវិជ្ជមាន។ ប្រភេទពាក្យគន្លឹះបង្ហាញពីរបៀបដែលកន្សោមដែលបានផ្តល់ឱ្យគួរតែត្រូវបានបកស្រាយ។ មុខងារជំនួយ EXTRACT(type FROM date) ត្រឡប់ចន្លោះពេលនៃប្រភេទដែលបានបញ្ជាក់ (ប្រភេទ) ពីតម្លៃកាលបរិច្ឆេទ។ តារាងខាងក្រោមបង្ហាញពីទំនាក់ទំនងរវាងប្រភេទ និងអាគុយម៉ង់ expr៖ | អត្ថន័យ |
| ប្រភេទ | ទម្រង់រំពឹងទុក |
| ផុតកំណត់ | ទីពីរ |
| វិនាទី | នាទី |
| នាទី | ម៉ោង |
| ម៉ោង | ថ្ងៃ |
| ថ្ងៃ | ខែ |
| ខែ | ឆ្នាំ |
| ឆ្នាំ | MINUTE_SECOND |
| "នាទី៖ វិនាទី" | HOUR_MINUTE |
| "ម៉ោង៖ នាទី" | DAY_HOUR |
| "DAYS HOURS" | YEAR_MONTH |
| "ឆ្នាំ-ខែ" | HOUR_SECOND |
នៅក្នុង MySQL ទម្រង់កន្សោម expr អនុញ្ញាតឱ្យកំណត់ព្រំដែនណាមួយ។
សញ្ញាកំណត់ដែលបង្ហាញក្នុងតារាងនេះត្រូវបានផ្តល់ជាឧទាហរណ៍។ ប្រសិនបើកាលបរិច្ឆេទគឺជាតម្លៃ DATE ហើយការគណនាដែលបានគ្រោងទុកពាក់ព័ន្ធនឹងតែផ្នែក YEAR ខែ និងថ្ងៃ (នោះគឺមិនមានផ្នែក TIME) នោះលទ្ធផលត្រូវបានតំណាងដោយតម្លៃ DATE ។ ក្នុងករណីផ្សេងទៀត លទ្ធផលគឺតម្លៃ DATETIME៖
Mysql> SELECT "1997-12-31 23:59:59" + INTERVAL 1 SECOND;
-> 1998-01-01 00:00:00 mysql> SELECT INTERVAL 1 DAY + "1997-12-31";
ប្រសិនបើអ្នកប្រើតម្លៃកាលបរិច្ឆេទមិនត្រឹមត្រូវ លទ្ធផលនឹងជា NULL ។
ប្រសិនបើនៅពេលបូកសរុប MONTH , YEAR_MONTH ឬ YEAR លេខថ្ងៃនៅក្នុងកាលបរិច្ឆេទលទ្ធផលលើសពីចំនួនថ្ងៃអតិបរមាក្នុងខែថ្មី នោះលេខថ្ងៃនៃកាលបរិច្ឆេទលទ្ធផលត្រូវបានកំណត់ទៅថ្ងៃចុងក្រោយនៃខែថ្មី៖
Mysql> SELECT DATE_ADD("1998-01-30", INTERVAL 1 MONTH);
-> ១៩៩៨-០២-២៨
ពីឧទាហរណ៍មុន អ្នកអាចមើលឃើញថាពាក្យ INTERVAL និងប្រភេទពាក្យគន្លឹះមិនប្រកាន់អក្សរតូចធំទេ។
EXTRACT(ប្រភេទចាប់ពីកាលបរិច្ឆេទ)
អនុគមន៍ EXTRACT() ប្រើប្រភេទចន្លោះពេលដូចគ្នាទៅនឹងមុខងារ DATE_ADD() ឬ DATE_SUB() ប៉ុន្តែ EXTRACT() ស្រង់ចេញផ្នែកនៃតម្លៃកាលបរិច្ឆេទជាជាងអនុវត្តនព្វន្ធ។
Mysql> SELECT EXTRACT (ឆ្នាំពី "1999-07-02");
-> 1999 mysql> SELECT EXTRACT(YEAR_MONTH FROM "1999-07-02 01:02:03");
-> 199907 mysql> SELECT EXTRACT(DAY_MINUTE FROM "1999-07-02 01:02:03");
-> ឆ្នាំ ២០១០២
អនុគមន៍ត្រឡប់លេខថ្ងៃសម្រាប់កាលបរិច្ឆេទដែលបានបញ្ជាក់ក្នុងអាគុយម៉ង់កាលបរិច្ឆេទ (ចំនួនថ្ងៃដែលបានកន្លងផុតពីឆ្នាំ 0)៖
Mysql> ជ្រើសរើស TO_DAYS (950501);
-> 728779 mysql> ជ្រើសរើស TO_DAYS("1997-10-07");
| -> ៧២៩៦៦៩ | មុខងារ TO_DAYS() មិនត្រូវបានបម្រុងទុកសម្រាប់ប្រើជាមួយតម្លៃមុនពេលការណែនាំនៃប្រតិទិនហ្គ្រេហ្គោរៀន (1582) ទេព្រោះវាមិនគិតពីថ្ងៃដែលបាត់បង់នៅពេលដែលប្រតិទិនត្រូវបានផ្លាស់ប្តូរ។ |
| ត្រឡប់តម្លៃ DATE សម្រាប់លេខថ្ងៃដែលបានផ្តល់ឱ្យ N: | Mysql> ជ្រើសរើស FROM_DAYS(729669); |
| -> "1997-10-07" | មុខងារ FROM_DAYS() មិនត្រូវបានបម្រុងទុកសម្រាប់ប្រើជាមួយតម្លៃមុនពេលការណែនាំនៃប្រតិទិនហ្គ្រេហ្គោរៀន (1582) ទេព្រោះវាមិនរាប់បញ្ចូលថ្ងៃដែលបាត់បង់នៅពេលដែលប្រតិទិនត្រូវបានផ្លាស់ប្តូរ។ |
| DATE_FORMAT(កាលបរិច្ឆេទ ទម្រង់) | ធ្វើទ្រង់ទ្រាយតម្លៃកាលបរិច្ឆេទដោយយោងតាមខ្សែអក្សរទ្រង់ទ្រាយ។ គុណវុឌ្ឍិខាងក្រោមអាចត្រូវបានប្រើនៅក្នុងបន្ទាត់ទម្រង់៖ |
| កំណត់ | ការពិពណ៌នា |
| %M | ឈ្មោះខែ (មករា...ធ្នូ) |
| %W | ឈ្មោះថ្ងៃនៃសប្តាហ៍ (ថ្ងៃអាទិត្យ ... ថ្ងៃសៅរ៍) |
| %D | ថ្ងៃនៃខែដែលមានបច្ច័យភាសាអង់គ្លេស (0st, 1st, 2nd, 3rd, etc.) |
| %Y | ឆ្នាំ, កាលបរិច្ឆេទ, ៤ ខ្ទង់ |
| %y | ឆ្នាំ, កាលបរិច្ឆេទ, 2 ខ្ទង់ |
| %X | ឆ្នាំសម្រាប់សប្តាហ៍ដែលថ្ងៃអាទិត្យត្រូវបានចាត់ទុកថាជាថ្ងៃដំបូងនៃសប្តាហ៍ លេខ 4 ខ្ទង់ ប្រើជាមួយ "%V" |
| %x | ឆ្នាំសម្រាប់មួយសប្តាហ៍ដែលថ្ងៃអាទិត្យត្រូវបានចាត់ទុកជាថ្ងៃដំបូងនៃសប្តាហ៍ លេខ 4 ខ្ទង់ ប្រើជាមួយ "%v" |
| %a | ឈ្មោះអក្សរកាត់នៃថ្ងៃនៃសប្តាហ៍ (ព្រះអាទិត្យ ... សៅរ៍) |
| %d | ថ្ងៃខែ លេខ (00..31) |
| %e | ថ្ងៃនៃខែ, លេខ (0..31) |
| % ម | ខែ ថ្ងៃ (00..12) |
| %c | ខែ កាលបរិច្ឆេទ (0..12) |
| %b | ឈ្មោះអក្សរកាត់នៃខែ (មករា ... ធ្នូ) |
| %j | ឈ្មោះអក្សរកាត់នៃខែ (មករា ... ធ្នូ) |
| ថ្ងៃនៃឆ្នាំ (001..366) | %H |
| ម៉ោង (00..23) | %k |
| ម៉ោង (0..23) | ពេលវេលា ទម្រង់ 12 ម៉ោង (hh:mm:ss M) |
| %T | ពេលវេលា ទម្រង់ 24 ម៉ោង (hh:mm:ss) |
| %S | វិនាទី (00..59) |
| %s | វិនាទី (00..59) |
| %p | ព្រឹក ឬ ល្ងាច |
| %w | ថ្ងៃនៃសប្តាហ៍ (0=ថ្ងៃអាទិត្យ..6=ថ្ងៃសៅរ៍) |
| % U | សប្តាហ៍ (00..53) ដែលថ្ងៃអាទិត្យត្រូវបានចាត់ទុកថាជាថ្ងៃដំបូងនៃសប្តាហ៍ |
| %u | សប្តាហ៍ (00..53) ដែលថ្ងៃច័ន្ទត្រូវបានចាត់ទុកថាជាថ្ងៃដំបូងនៃសប្តាហ៍ |
| %V | សប្តាហ៍ (01..53) ដែលថ្ងៃអាទិត្យត្រូវបានចាត់ទុកថាជាថ្ងៃដំបូងនៃសប្តាហ៍។ ប្រើជាមួយ "%X" |
| %v | សប្តាហ៍ (01..53) ដែលថ្ងៃច័ន្ទត្រូវបានចាត់ទុកថាជាថ្ងៃដំបូងនៃសប្តាហ៍។ ប្រើជាមួយ " %x " |
| %% | ព្យញ្ជនៈ "%" ។ |
តួអក្សរផ្សេងទៀតទាំងអស់ត្រូវបានចម្លងយ៉ាងសាមញ្ញទៅក្នុងកន្សោមលទ្ធផលដោយគ្មានការបកស្រាយ៖
Mysql> SELECT DATE_FORMAT("1997-10-04 22:23:00", "%W %M %Y");
-> "ថ្ងៃសៅរ៍ ខែតុលា ឆ្នាំ 1997" mysql> SELECT DATE_FORMAT("1997-10-04 22:23:00", "%H:%i:%s");
-> "22:23:00" mysql> SELECT DATE_FORMAT("1997-10-04 22:23:00", "%D %y %a %d %m %b %j");
-> "ទី 4 ទី 97 សៅរ៍ 04 10 តុលា 277" mysql> SELECT DATE_FORMAT("1997-10-04 22:23:00", "%H %k %I %r %T %S %w");
-> "22 22 10 10:23:00 PM 22:23:00 00 6" mysql> SELECT DATE_FORMAT("1999-01-01", "%X %V");
-> "ឆ្នាំ ១៩៩៨ ៥២"
នៅក្នុង MySQL 3.23 តួអក្សរ "%" ត្រូវតែនាំមុខតួអក្សរបញ្ជាក់ទ្រង់ទ្រាយ។ នៅក្នុងកំណែមុនរបស់ MySQL តួអក្សរ "%" គឺស្រេចចិត្ត។
ហេតុផលដែលចន្លោះពេលខែ និងថ្ងៃចាប់ផ្តើមនៅសូន្យគឺថា MySQL អនុញ្ញាតឱ្យកាលបរិច្ឆេទដោយផ្នែកដូចជា "2004-00-00" ចាប់តាំងពី MySQL 3.23 ។
TIME_FORMAT(ពេលវេលា ទម្រង់)
មុខងារនេះត្រូវបានប្រើស្រដៀងនឹងមុខងារ DATE_FORMAT() ដែលបានពិពណ៌នាខាងលើ ប៉ុន្តែខ្សែអក្សរទម្រង់អាចមានតែការកំណត់ទម្រង់ដែលទាក់ទងនឹងម៉ោង នាទី និងវិនាទីប៉ុណ្ណោះ។ នៅពេលបញ្ជាក់គុណវុឌ្ឍិផ្សេងទៀត តម្លៃ NULL ឬ 0 នឹងត្រលប់មកវិញ។
CURDATE() , CURRENT_DATE
ត្រឡប់កាលបរិច្ឆេទថ្ងៃនេះជាតម្លៃក្នុងទម្រង់ YYYY-MM-DD ឬ YYYYMMDD អាស្រ័យលើថាតើអនុគមន៍ត្រូវបានប្រើក្នុងខ្សែអក្សរ ឬបរិបទលេខ៖
Mysql> SELECT CURDATE();
-> "1997-12-15" mysql> SELECT CURDATE() + 0;
ចំណាំថា NOW() ត្រូវបានវាយតម្លៃតែម្តងប៉ុណ្ណោះសម្រាប់សំណើនីមួយៗ ពោលគឺនៅដើមដំបូងនៃការអនុវត្តរបស់វា។ នេះធានាថាឯកសារយោងជាច្រើនទៅកាន់ NOW() នៅក្នុងសំណួរដូចគ្នានឹងបង្កើតតម្លៃដូចគ្នា។
UNIX_TIMESTAMP() , UNIX_TIMESTAMP(កាលបរិច្ឆេទ)
នៅពេលហៅដោយគ្មានអំណះអំណាង មុខងារនេះត្រឡប់ត្រាពេលវេលា UNIX_TIMESTAMP (វិនាទីចាប់តាំងពី 1970-01-01 00:00:00 GMT) ជាចំនួនគត់ដែលមិនបានចុះហត្ថលេខា។ ប្រសិនបើអនុគមន៍ UNIX_TIMESTAMP() ត្រូវបានហៅជាមួយអាគុយម៉ង់កាលបរិច្ឆេទ វាត្រឡប់តម្លៃនៃអាគុយម៉ង់ជាចំនួនវិនាទីចាប់តាំងពី 1970-01-01 00:00:00 GMT ។ អាគុយម៉ង់កាលបរិច្ឆេទអាចជាខ្សែអក្សរ DATE ខ្សែ DATETIME តម្លៃ TIMESTAMP ឬលេខក្នុងទម្រង់ម៉ោងក្នុងស្រុក YYMMDD ឬ YYYYMMDD៖
Mysql> ជ្រើសរើស UNIX_TIMESTAMP();
-> 882226357 mysql> SELECT UNIX_TIMESTAMP("1997-10-04 22:23:00"); នៅពេលប្រើមុខងារ UNIX_TIMESTAMP នៅលើជួរឈរ TIMESTAMP មុខងារនេះនឹងត្រឡប់តម្លៃនៃត្រាពេលវេលាខាងក្នុងដោយផ្ទាល់ ដោយមិនមានការបំប្លែងដោយអត្ថន័យនៃខ្សែអក្សរទៅជាត្រាពេលវេលា (``string-to-unix-timestamp'')។ ប្រសិនបើកាលបរិច្ឆេទដែលបានផ្តល់ឱ្យគឺនៅក្រៅជួរត្រឹមត្រូវ នោះមុខងារ UNIX_TIMESTAMP() នឹងត្រឡប់ 0 ប៉ុន្តែចំណាំថាមានតែការត្រួតពិនិត្យជាមូលដ្ឋានប៉ុណ្ណោះដែលត្រូវបានអនុវត្ត (ឆ្នាំ 1970-2037 ខែ 01-12 ថ្ងៃទី 01-31)។ ប្រសិនបើអ្នកត្រូវអនុវត្តការដកជួរឈរ UNIX_TIMESTAMP() លទ្ធផលអាចត្រូវបានបម្លែងទៅជាចំនួនគត់ដែលបានចុះហត្ថលេខា។.
សូមមើល
៦.៣.៥. វាយបញ្ចូលមុខងារខាស
ផ្នែកទី 6.3.5 "ប្រភេទមុខងារ Casting"
FROM_UNIXTIME(unix_timestamp)
ត្រឡប់តំណាងនៃអាគុយម៉ង់ unix_timestamp ជាតម្លៃក្នុងទម្រង់ YYYY-MM-DD HH:MM:SS ឬ YYYYMMDDHHMMSS អាស្រ័យលើថាតើមុខងារនេះត្រូវបានប្រើក្នុងខ្សែអក្សរ ឬបរិបទលេខ៖
Mysql> ជ្រើសរើស FROM_UNIXTIME(875996580);
-> "1997-10-04 22:23:00" mysql> SELECT FROM_UNIXTIME(875996580) + 0;
-> 19971004222300
Mysql> SELECT SEC_TO_TIME(2378);
-> "00:39:38" mysql> SELECT SEC_TO_TIME(2378) + 0;
-> ៣៩៣៨
TIME_TO_SEC(ម៉ោង)
