การติดตั้ง MySQL ด้วยตนเองบน Windows พื้นฐานการดูแลระบบ MySQL การใช้บรรทัดคำสั่ง การหยุดเซิร์ฟเวอร์ mysql จากบรรทัดคำสั่ง

สำหรับ Win 32 ให้เลือกการกระจาย: Windows (x86, 32-bit) ไฟล์ซิป

สำหรับ Win 64: Windows (x86, 64 บิต) ไฟล์ซิป

หลังจากคลิกที่ปุ่มดาวน์โหลด คุณจะเห็นแบบฟอร์มการลงทะเบียน คุณสามารถข้ามได้โดยคลิกที่ลิงค์ด้านล่าง - ไม่ล่ะ ขอบคุณ เพียงพาฉันไปที่การดาวน์โหลด.

2. สร้างโฟลเดอร์การติดตั้ง ตัวอย่างเช่น . และแกะเนื้อหาของไฟล์เก็บถาวรลงไปเพื่อให้โฟลเดอร์ต่างๆ bin ข้อมูล เอกสาร และอื่นๆอยู่ในรูทของโฟลเดอร์การติดตั้ง

3. มาดูการสร้างไฟล์กำหนดค่า (my.ini) กันดีกว่า เราใช้ไฟล์ทั่วไปไฟล์ใดไฟล์หนึ่งเป็นพื้นฐาน:

my-small.ini - เหมาะสำหรับผู้ที่ใช้ MySQL เป็นครั้งคราวและไม่ต้องการให้เซิร์ฟเวอร์ใช้ทรัพยากรจำนวนมาก
my-medium.ini ยังเป็นการกำหนดค่าที่มีน้ำหนักเบา แต่เหมาะสำหรับผู้ที่ใช้ MySQL เป็นประจำ (เป็นตัวเลือกที่ดีสำหรับเว็บเซิร์ฟเวอร์ในบ้าน)
my-large.ini และ my-huge.ini ใช้สำหรับระบบที่ใช้เป็นเซิร์ฟเวอร์ MySQL เฉพาะ อย่างไรก็ตาม my-large.ini สามารถใช้กับโฮมเซิร์ฟเวอร์ได้ หากคุณต้องการประสิทธิภาพ MySQL เพิ่มเติม (RAM ขนาด 512 MB ปัจจุบันยังไม่ค่อยมากนัก)
my-innodb-heavy-4G - สำหรับเซิร์ฟเวอร์เฉพาะที่มี RAM 4 GB และใช้เฉพาะตาราง InnoDB

ในตัวอย่างนี้ ฉันเลือก my-medium.ini เป็นพื้นฐาน เปลี่ยนชื่อเป็น my.ini และวางไว้ที่รากของโฟลเดอร์การติดตั้ง ( C:\Program Files\MySQL\MySQL เซิร์ฟเวอร์ 5.5).

เปิดเพื่อแก้ไข (ใน Notepad ปกติ) และทันทีหลังจากบรรทัดให้เพิ่มพารามิเตอร์สองตัว:

basedir=C:/Program Files/MySQL/MySQL Server 5.5 datadir=C:/Program Files/MySQL/MySQL Server 5.5/ข้อมูล

โปรดทราบว่าเส้นทางใช้เครื่องหมายทับ (/) และไม่ใช่เครื่องหมายแบ็กสแลช (\)

baseir เป็นเส้นทางไปยังโฟลเดอร์การติดตั้ง

datadir - เส้นทางไปยังโฟลเดอร์ข้อมูล (ที่เก็บฐานข้อมูลทั้งหมด) บางครั้งมันก็สมเหตุสมผลที่จะใส่ข้อมูลไว้ในไดรฟ์แยกต่างหากเพื่อปรับปรุงประสิทธิภาพหรือรับประกันความน่าเชื่อถือ

ในกรณีนี้ นี่เป็นส่วนของไฟล์การกำหนดค่าหลังจากทำการเปลี่ยนแปลง:

# เซิร์ฟเวอร์ MySQL basedir=C:/Program Files/MySQL/MySQL Server 5.5 datadir=C:/Program Files/MySQL/MySQL Server 5.5/data port = 3306 socket = /tmp/mysql.sock ข้ามการล็อคภายนอก key_buffer_size = 16M max_allowed_packet = 1M table_open_cache = 64 sort_buffer_size = 512K net_buffer_length = 8K read_buffer_size = 256K read_rnd_buffer_size = 512K InnoDB_sort_buffer_size = 8M

4. ขั้นตอนต่อไปคือการเพิ่มเส้นทาง C:\Program Files\MySQL\MySQL เซิร์ฟเวอร์ 5.5\binไปยังตัวแปรสภาพแวดล้อม PATH เพื่อให้ง่ายต่อการเริ่ม MySQL จากบรรทัดคำสั่ง ในการดำเนินการนี้ ให้เปิดคุณสมบัติของระบบ -> การตั้งค่าระบบขั้นสูง -> บนแท็บขั้นสูงที่ด้านล่างสุดปุ่ม “ตัวแปรสภาพแวดล้อม…” ในหน้าต่างที่เปิดขึ้น ให้เลื่อนดูตัวแปรระบบจนกระทั่งพบเส้นทาง ไฮไลต์บรรทัดนี้แล้วคลิก "แก้ไข..." ที่ท้ายบรรทัด ให้เพิ่มเส้นทางของคุณ โดยคงพารามิเตอร์ที่มีอยู่ไว้:

โปรดทราบว่าเส้นทางจะถูกคั่นด้วยเครื่องหมายอัฒภาค ตรวจสอบให้แน่ใจว่าคุณใส่เครื่องหมายอัฒภาคที่จุดเริ่มต้นและจุดสิ้นสุดของเส้นทางของคุณ

5. ก่อนทำการทดสอบ ให้เปิดพอร์ตขาเข้า TCP 3306 ในไฟร์วอลล์ Windows:

หากคุณมีไฟร์วอลล์เสริมติดตั้งอยู่ในระบบของคุณ คุณต้องเปิดพอร์ต TCP 3306 บนไฟร์วอลล์นั้นสำหรับการเชื่อมต่อขาเข้าด้วย

6. ตอนนี้เรากำลังทำการทดสอบการทำงาน ในพรอมต์คำสั่งที่ทำงานในฐานะผู้ดูแลระบบ (จำเป็นหากเปิดใช้งาน UAC บน Seven หรือ Vista) เราจะดำเนินการ:

mysqld --console

จะปรากฏหลายบรรทัดบนหน้าจอ หากการเปิดตัวสำเร็จ บรรทัดสุดท้ายจะมีลักษณะดังนี้:

เวอร์ชัน: ซ็อกเก็ต "5.5.9-log": พอร์ต "": 3306 MySQL Community Server (GPL)

เปิดหน้าต่างนี้ทิ้งไว้และเปิดหน้าต่างบรรทัดคำสั่งอื่นซึ่งเราป้อน:

MySQL -u รูท

หากการเชื่อมต่อสำเร็จ คุณจะเห็นพรอมต์บรรทัดคำสั่ง: mysql>

มาดูกันว่าเรามีฐานอะไรบ้าง:

แสดงฐานข้อมูล

อัฒภาคที่ส่วนท้ายของแบบสอบถาม SQL เป็น MANDATORY!

การตอบสนองของทีม:

ในที่สุดเราก็มั่นใจแล้วว่าเซิร์ฟเวอร์ใช้งานได้

7. ไปยังขั้นตอนถัดไป คุณจะต้องตั้งรหัสผ่านผู้ดูแลระบบ MySQL (ผู้ใช้รูท) ตามค่าเริ่มต้น รหัสผ่านไม่ได้ถูกกำหนดไว้ และควรแก้ไขให้ถูกต้อง ในหน้าต่าง MySQL เดียวกัน ให้ป้อนคำสั่งต่อไปนี้:

ใช้รหัสผ่านชุดผู้ใช้ mysql UPDATE = PASSWORD("your_password") WHERE user = "root";

การตรวจสอบผลลัพธ์:

เลือกผู้ใช้ โฮสต์ รหัสผ่านจากผู้ใช้

ดังที่คุณเห็นในภาพหน้าจอ คอลัมน์รหัสผ่านถูกกรอก ซึ่งหมายความว่ามีการตั้งรหัสผ่านแล้ว

ก่อนออกให้รันคำสั่ง:

สิทธิ์ล้าง;

ตอนนี้เมื่อเชื่อมต่อคุณต้องป้อนรหัสผ่าน เมื่อต้องการทำเช่นนี้ ให้ใช้สวิตช์ -p:

MySQL -u รูท -p

หากต้องการปิดการทำงานของ MySQL:

mysqladmin -u root -p ปิดระบบ

8. ขั้นตอนสุดท้ายคือการเริ่ม MySQL เป็นบริการระบบ Windows

ตรวจสอบให้แน่ใจว่าไม่มีกระบวนการ MySQL ที่ใช้งานอยู่ในระบบ

บนพรอมต์คำสั่งให้รันในฐานะผู้ดูแลระบบ ให้รัน:

"C:\Program Files\MySQL\MySQL Server 5.5\bin\mysqld" --ติดตั้ง

ต้องระบุเส้นทางไปยัง mysqld ให้ครบถ้วน (แม้ว่าจะอยู่ใน PATH ก็ตาม)!

หากต้องการเริ่มบริการ ให้เปิด "การจัดการคอมพิวเตอร์" และเริ่มบริการ MySQL ด้วยตนเอง:

หรือง่ายกว่าผ่านบรรทัดคำสั่ง:

เริ่มต้นสุทธิ mysql

หากต้องการลบบริการ ให้หยุดก่อน:

เน็ตหยุด mysql

และดำเนินการ:

"C:\Program Files\MySQL\MySQL Server 5.5\bin\mysqld" --ลบ

เพื่อนมักจะถามคำถามบางอย่างเกี่ยวกับการบริหารงานกับฉัน และฉันก็คิดว่า ทำไมไม่เขียนบทความ-บันทึกดังกล่าวบนเว็บไซต์แทนที่จะอธิบายเรื่องเดียวกัน 100 ครั้งล่ะ นอกจากนี้นี่เป็นโอกาสที่ดีในกรณีนี้ที่จะใช้บันทึกดังกล่าวด้วยตัวเองเพราะคุณเองก็รู้ว่าบางครั้งมันเป็นไปไม่ได้ที่จะเก็บทุกอย่างไว้ในหัวและไม่ทางใดก็ทางหนึ่งบางครั้งคุณต้องหันไปหาหนังสืออ้างอิง ดังนั้นให้ส่วนหนึ่งของเว็บไซต์นี้กลายเป็นหนังสือแบบนั้น วันนี้เราจะพูดถึงวิธีการทำงานกับ MySQL DBMS จากบรรทัดคำสั่งใช่บางคนจะพูดว่า -“ นาคอยเหรอ? ท้ายที่สุดมี phpMyAdmin” ฉันตอบ - เหตุใดจึงต้องสิ้นเปลืองทรัพยากรเซิร์ฟเวอร์อันมีค่าด้วยการติดตั้งขยะทุกประเภทเช่น WebMin, phpMyAdmin เป็นต้น หากทุกสิ่งสามารถทำได้ง่ายด้วยเครื่องมือที่เชื่อถือได้และผ่านการพิสูจน์แล้ว การตั้งค่าจากเทอร์มินัลผ่านอุโมงค์ SSH คือทางเลือกของเรา!

เอาล่ะ มาเริ่มกันเลย เราเชื่อมต่อกับเซิร์ฟเวอร์ผ่าน SSH เช่นผ่าน PuTTY (ไคลเอ็นต์ Telnet / SSH ฟรี) ที่รู้จักกันดี ตอนนี้เรามาดูคำอธิบายของคำสั่งโดยตรงกัน

ล็อกอินเข้าสู่เซิร์ฟเวอร์ MySQL ด้วยโปรแกรม mysql:

mysql -u root -h localhost -p

ตัวเลือก -u ระบุผู้ใช้ที่จะเข้าสู่ระบบ ตัวเลือก -h ระบุโฮสต์ โดยปกติจะเป็น localhost หากคุณกำลังตั้งค่าเซิร์ฟเวอร์ที่ไม่ใช่ระยะไกล สุดท้าย -p บอกให้โปรแกรมไคลเอนต์ mysql ป้อนรหัสผ่านเพื่อเข้าถึงฐานข้อมูล สังเกตพรอมต์ mysql> ที่นี่คุณจะป้อนคำสั่งทั้งหมดของคุณที่นี่ ตอนนี้เมื่ออยู่ในสภาพแวดล้อม mysql ในฐานะผู้ใช้รูท เราสามารถเริ่มการตั้งค่าฐานข้อมูลได้

เราเข้าสู่ระบบแล้วและพรอมต์ mysql อยู่บนหน้าจอ ขั้นแรก มาดูรายการฐานข้อมูลที่มีอยู่กันก่อน เมื่อต้องการทำเช่นนี้ ให้ป้อนคำสั่ง SHOW DATABASES

การตอบสนองทำให้ชัดเจนว่าคำสั่งเสร็จสมบูรณ์โดยไม่มีข้อผิดพลาดใดๆ ในกรณีนี้ มีการเปลี่ยนแปลงหนึ่งบรรทัด นี่หมายถึงฐานข้อมูล mysql หลักซึ่งมีรายการฐานข้อมูลทั้งหมด แต่คุณไม่ต้องกังวลกับรายละเอียดเล็กๆ น้อยๆ มากเกินไป ตัวเลขสุดท้ายระบุเวลาดำเนินการแบบสอบถาม เราสามารถตรวจสอบได้ว่าฐานข้อมูลถูกสร้างขึ้นโดยการรันคำสั่ง SHOW DATABASES อีกครั้ง

ในการเริ่มสร้างตารางในฐานข้อมูลทดสอบใหม่ เราจำเป็นต้องตั้งค่าให้เป็นฐานข้อมูลปัจจุบัน เมื่อต้องการทำเช่นนี้ ให้ใช้คำสั่ง USE พารามิเตอร์ของคำสั่งนี้ระบุชื่อของฐานข้อมูลที่จะทำให้เป็นปัจจุบัน คุณยังสามารถตั้งค่าฐานข้อมูลปัจจุบันบนบรรทัดคำสั่งโดยระบุชื่อฐานข้อมูลหลังพารามิเตอร์ -D ไปข้างหน้าและเปลี่ยนไปใช้ฐานข้อมูลทดสอบ
การสลับฐานข้อมูล:

ใช้การทดสอบ;

สิทธิพิเศษใน MySQL

ให้สิทธิพิเศษตามคำสั่ง ยินยอม.
สิทธิ์กำหนดวิธีที่ผู้ใช้สามารถเข้าถึงฐานข้อมูล ตาราง... แทบทุกอย่าง ปัจจุบัน มีเพียงผู้ใช้ระดับสูงของ MySQL เท่านั้นที่สามารถเข้าถึงฐานข้อมูลทดสอบได้ โดยได้รับอนุญาตตามที่กำหนด เรามาสร้างผู้ใช้รายอื่นเช่นผู้ดูแลระบบ (ผู้ดูแลระบบ) ซึ่งจะเข้าถึงฐานข้อมูลทดสอบและทำงานกับข้อมูลจากฐานข้อมูลนั้น แต่ก่อนที่เราจะเริ่มต้น เรามาดูรูปแบบที่เรียบง่ายเล็กน้อยของคำสั่ง GRANT กันก่อน

บันทึก: คำสั่ง GRANT ถือเป็นวิธีการสร้างผู้ใช้ อย่างไรก็ตาม MySQL เวอร์ชันใหม่กว่ายังมีฟังก์ชัน CREATE_USER แม้ว่าจะยังต้องการ GRANT ก็ตาม
ตอนนี้เราต้องการสิทธิพิเศษที่สามารถมอบหมายได้ จากทั้งหมดที่กล่าวมา คุณสามารถตั้งค่าสิทธิ์ดังต่อไปนี้:

บันทึก: หากคุณใช้ MySQL เพื่อสื่อสารกับเว็บแอปพลิเคชัน สิทธิ์ CREATE, SELECT, INSERT ที่อธิบายไว้ที่นี่ รวมถึงสิทธิ์ DELETE และ UPDATE (อธิบายไว้ในคู่มือ MySQL ส่วน GRANT และ REVOKE Syntax) เป็นเพียงสิทธิ์เดียวที่ มีแนวโน้มว่าจะต้อง หลายคนทำผิดพลาดในการมอบสิทธิพิเศษทั้งหมดโดยที่ไม่จำเป็นจริงๆ ตรวจสอบกับนักพัฒนาแอปเพื่อดูว่าการอนุญาตดังกล่าวจะสร้างปัญหาด้านประสิทธิภาพจริงหรือไม่

สร้างผู้ใช้ที่เป็นผู้ดูแลระบบ:

ดังนั้นผู้ใช้จึงถูกสร้างขึ้น ตอนนี้เรามาทดสอบพวกเขากัน ขั้นแรก ให้ออกจาก mysql โดยพิมพ์ Quit ที่พรอมต์:

ตัวเลือกต่างๆ ได้รับการอธิบายไว้ในส่วนคำสั่ง GRANT และตอนนี้เราจะปฏิเสธการเข้าถึงใด ๆ ของผู้ใช้ สมมติว่าเราพบว่าบัญชีผู้ดูแลระบบทำให้เกิดปัญหาด้านความปลอดภัย เราตัดสินใจที่จะเพิกถอนสิทธิ์ทั้งหมด เราไปในฐานะรูทและทำสิ่งที่จำเป็น
เพิกถอนสิทธิ์สำหรับผู้ใช้ผู้ดูแลระบบ:

เพิกถอนการทดสอบทั้งหมด * จาก "admin" @"localhost" ;

บันทึก: ในกรณีนี้ การเข้าถึงของผู้ใช้ทำได้ง่าย ดังนั้นการเพิกถอนสิทธิ์ในฐานข้อมูลเดียวจึงไม่เป็นปัญหา แต่โดยปกติแล้วคุณจะต้องใช้ *.* แทน test.* เพื่อเพิกถอนสิทธิ์การเข้าถึงฐานข้อมูลอื่น ๆ ของผู้ใช้ด้วย

ตอนนี้เรามาดูวิธีการลบบัญชีอย่างสมบูรณ์ด้วยคำสั่ง DELETE และดูที่ตารางผู้ใช้ MySQL

การลบบัญชีด้วยคำสั่ง ลบ.
ตารางผู้ใช้ MySQL คือรายชื่อผู้ใช้และข้อมูลเกี่ยวกับพวกเขา ตรวจสอบให้แน่ใจว่าคุณเข้าสู่ระบบในฐานะรูท ใช้ฐานข้อมูล MySQL หลัก

การใช้ฐานข้อมูล mysql หลัก:

ตารางผู้ใช้เป็นสิ่งที่คุณต้องการ มี 30 ฟิลด์ที่แตกต่างกันและอ่านยาก เพื่อความสะดวกในการอ่าน เราใช้รูปแบบที่สามของคำสั่ง SELECT ช่องที่ต้องกรอกคือโฮสต์ (โฮสต์) และผู้ใช้ (ผู้ใช้)
ค้นหาผู้ใช้ผู้ดูแลระบบในตารางผู้ใช้:

ตอนนี้เรามีข้อมูลแล้ว เราก็สามารถกำจัดผู้ใช้ที่เป็นผู้ดูแลระบบได้ ทำได้โดยใช้คำสั่ง DELETE นี่คือไวยากรณ์:

คุณอาจสังเกตเห็นว่ารูปแบบ DELETE ค่อนข้างคล้ายกับรูปแบบ SELECT ระบุฟิลด์ผู้ใช้และค่าผู้ดูแลระบบ การดำเนินการนี้จะลบรายการออกจากตารางผู้ใช้โดยที่ผู้ใช้เป็นผู้ดูแลระบบ จะเป็นการลบบัญชีของเรา ลงมือทำกันเถอะ:
การลบผู้ใช้ที่เป็นผู้ดูแลระบบ:

จำเป็นต้องใช้คำสั่ง FLUSH PRIVILEGES เพื่ออัปเดตการอนุญาต

นั่นคือทั้งหมดสำหรับวันนี้ เห็นด้วยทุกอย่างเป็นเรื่องง่าย! ;)

สวัสดีเพื่อนร่วมงาน 🙂

ใช่เพื่อนร่วมงานเพราะบรรทัดคำสั่ง MySQL (หรือ MySQL Shell ตามที่นักพัฒนาชอบเรียก) รวมถึงการทำงานกับ MySQL ในคอนโซลไม่น่าจะมีประโยชน์กับมนุษย์ธรรมดา

เพื่อให้หัวข้อนี้น่าสนใจ อย่างน้อยคุณจะต้องเป็นผู้ดูแลระบบมือใหม่ที่ไม่ได้ใช้ phpMyAdmin และอินเทอร์เฟซอื่น ๆ ตามหลักการ

โดยส่วนตัวแล้วฉันเองก็ชอบใช้ phpMyAdmin เป็นหลักในการทำงานกับ MySQL เพราะ ฉันเป็นคนมีสายตาโดยธรรมชาติ อย่างไรก็ตาม บางครั้งในทางปฏิบัติ มีสถานการณ์ที่จำเป็นต้องมีความรู้เกี่ยวกับบรรทัดคำสั่ง MySQL และความสามารถในการทำงานกับ MySQL ในคอนโซลเซิร์ฟเวอร์

ปัจจุบันฉันมีสามคน:

เป็นครั้งแรกที่ฉันพบกับงานในคอนโซล MySQL เมื่อฉันต้องการนำเข้าดัมพ์ฐานข้อมูลขนาดใหญ่ มันไม่ได้โหลดผ่าน phpMyAdmin ทั้งหมดเพราะว่า ตกลงไปที่ไหนสักแห่งตรงกลางในแง่ของการหมดเวลาแม้ว่าจะเปลี่ยนการตั้งค่าสำหรับเวลาดำเนินการและขนาดของไฟล์ที่ดาวน์โหลดก็ตาม โดยหลักการแล้ว สามารถเลือกค่าที่ต้องการได้ แต่สำหรับฉันแล้วดูเหมือนว่ากระบวนการนี้ยาวเกินไป
ครั้งต่อไปที่ฉันต้องทำงานกับ MySQL ผ่านทางบรรทัดคำสั่งคือปิดการใช้งานการตรวจสอบคีย์ต่างประเทศเมื่อจำเป็นต้องลบข้อมูลจากตารางที่เกี่ยวข้องกับผู้อื่นโดยใช้คีย์ ใน phpMyAdmin ฉันไม่พบวิธีการทำเช่นนี้
ในบริษัทที่จริงจัง มีเพียงคอนโซลเท่านั้นที่ใช้เพื่อทำงานกับ MySQL โดยไม่ต้องใช้ phpMyAdmins ฉันไม่รู้ว่าทำไมโดยเฉพาะ แต่คนที่มีความรู้บอกว่ามันเกี่ยวข้องกับความปลอดภัย เป็นผลให้ทุกคนต้องทำงานกับบรรทัดคำสั่ง MySQL รวมถึงฉันด้วย 🙂

แต่ขอย้ำอีกครั้งว่าการทำงานกับ MySQL ในคอนโซลและบรรทัดคำสั่งค่อนข้างเหมาะสำหรับการใช้งานในชีวิตประจำวัน โปรแกรมวิชวลที่รู้จักทั้งหมดสำหรับการทำงานกับฐานข้อมูลยังคงทำงานบนพื้นฐานของคำสั่งคอนโซล MySQL เพราะฉะนั้นใครชอบ 🙂

ใช้งานคอนโซลบนระบบปฏิบัติการที่แตกต่างกัน

เนื่องจากฉันจะสาธิตบรรทัดคำสั่ง MySQL ในคอนโซลเซิร์ฟเวอร์ จึงเป็นความคิดที่ดีที่จะเริ่มก่อน

การดำเนินการนั้นเรียบง่ายและคุ้นเคยสำหรับหลาย ๆ คนซึ่งความรู้เกี่ยวกับ "ปุ่มลัด" ก็เพียงพอแล้ว

การเปิดตัวคอนโซลบน Windows:

Win+R เพื่อเปิดพรอมต์คำสั่ง Windows พร้อมสิทธิ์ผู้ดูแลระบบ
เราป้อนคำสั่ง คำสั่ง
คลิก เข้าบนแป้นพิมพ์

การเปิดตัวคอนโซลในลีนุกซ์รุ่น (เทอร์มินัล): ใน Ubuntu ที่ฉันใช้งานอยู่ การรวมคีย์ของระบบก็เพียงพอแล้ว Ctrl+Alt+T. ฉันไม่สามารถพูดอะไรเกี่ยวกับระบบปฏิบัติการที่ใช้ Linux อื่น ๆ ได้

เปิดตัวคอนโซลใน MacOS: ตัวฉันเองไม่ได้ทำเช่นนี้เพราะว่า ฉันยังไม่มี Mac และฉันไม่น่าจะทำให้มันไม่จำเป็น แต่เท่าที่ฉันสามารถรู้ได้ ไม่มี "ปุ่มลัด" สำหรับเรียกเทอร์มินัลในระบบปฏิบัติการนี้ ดังนั้นหากคุณเป็นผู้ใช้ผลิตภัณฑ์ "apple" ให้เปิดคอนโซลผ่านอินเทอร์เฟซระบบปฏิบัติการ โชคดีที่มีคู่มือมากมายบนเครือข่าย

เป็นเรื่องน่าอายเล็กน้อยที่จะเผยแพร่ข้อมูลดังกล่าวในกรณีที่ผู้ดูแลระบบมืออาชีพบางคนที่มีประสบการณ์มีหนวดมีเคราบังเอิญเจอบทความนี้ เขาจะคิดว่า: "ผู้เขียนถือว่าผู้อ่านของเขาเป็นโปรแกรมเมอร์ แต่ในขณะเดียวกันเขาก็สอนวิธีเรียกใช้คอนโซล ... มีคนบ้า :-)"

ใช่ มันค่อนข้างสมเหตุสมผล 🙂 แต่ฉันแค่คำนึงถึงสถานการณ์ที่ผู้เริ่มต้นสามารถมาที่นี่ได้พร้อมกับนักพัฒนามืออาชีพ ผมจึงพยายามทำให้ข้อมูลมีความสมบูรณ์และเข้าถึงได้สำหรับผู้ใช้ทุกประเภทดังที่ผมได้กล่าวไปแล้ว

คำสั่งคอนโซล MySQL พื้นฐาน

ก่อนอื่น เราต้องเข้าถึงบรรทัดคำสั่ง MySQL ในคอนโซล ในการดำเนินการนี้ ให้เปิดคอนโซลเซิร์ฟเวอร์ และหากคุณได้ติดตั้ง MySQL ทั่วโลกเป็นบริการ ดังนั้นเพื่อ "ตรวจสอบการเชื่อมต่อ" เราจะเขียนดังต่อไปนี้:

MySQL-V

คำสั่งคอนโซล mysqlช่วยให้เราสามารถเรียกใช้ยูทิลิตี้ชื่อเดียวกันซึ่งเป็นบรรทัดคำสั่ง MySQL

ซึ่งจะช่วยให้เราค้นหาเวอร์ชันของ MySQL ที่ติดตั้งบนคอมพิวเตอร์และตรวจสอบให้แน่ใจว่าได้รับการติดตั้งเป็นบริการเลย หากเป็นเช่นนั้น เพื่อตอบสนองต่อคอนโซล คุณจะเห็นข้อความคล้าย ๆ ต่อไปนี้: .

ใช่ ฉันไม่ใช่ "ผู้เขียนโค้ดอย่างแท้จริง" เพราะฉันนั่งอยู่ใต้ Windows 🙂 แต่นั่นไม่ใช่ประเด็น บนระบบ Unix ขั้นตอนจะเหมือนกัน

หากจู่ๆ MySQL ไม่ได้ติดตั้งทั่วโลกบนคอมพิวเตอร์ของคุณหรือคุณจำเป็นต้องทำงานกับ MySQL หลายเวอร์ชันซึ่งมีเพียงไดเร็กทอรีที่มีไฟล์และไลบรารี MySQL เท่านั้น การเริ่ม MySQL ผ่านคอนโซลจะมีลักษณะเช่นนี้

ในคอนโซล ไปที่ไดเร็กทอรีที่มีไฟล์ปฏิบัติการ MySQL (บน Windows อย่างน้อยก็คือ mysql.exe) โดยใช้คำสั่งต่อไปนี้:

ซีดี C:\OpenServer\modules\database\MySQL-5.7-x64\bin

แน่นอนว่าเส้นทางไปยังชุดการแจกจ่ายอาจแตกต่างกันสำหรับคุณ ตามตัวอย่าง ฉันตัดสินใจใช้งาน MySQL เวอร์ชันใดเวอร์ชันหนึ่งที่มาพร้อมกับ OpenServer

และเราเริ่มต้น MySQL โดยตรวจสอบเวอร์ชันของมันไปพร้อมกัน:

Mysql.exe-V

ด้วยเหตุนี้ ข้อความที่คล้ายกับกรณีแรกจึงควรปรากฏในคอนโซล mysql เวอร์ชัน 14.14 แจกจ่าย 5.7.16 สำหรับ Win64 (x86_64).

ทุกอย่างด้วยการเปิดตัวบรรทัดคำสั่ง MySQL ผ่านคอนโซลเซิร์ฟเวอร์ เราเข้าใจแล้ว ตอนนี้เราจะเชื่อมต่อโดยตรงกับเซิร์ฟเวอร์ MySQL

การเชื่อมต่อกับเซิร์ฟเวอร์ MySQL ในคอนโซล

เซิร์ฟเวอร์ MySQL อาจไม่จำเป็นต้องอยู่บนเครื่องเดียวกับที่คุณพยายามเข้าถึงจากคอนโซล ดังนั้นเพื่อให้สามารถเชื่อมต่อกับเซิร์ฟเวอร์ MySQL ระยะไกลผ่านคอนโซลได้ ยูทิลิตี้ mysql จึงมีพารามิเตอร์มากมายที่คุณสามารถระบุการตั้งค่าที่จำเป็นได้

ในการรันบรรทัดคำสั่ง MySQL ในคอนโซล เราเพียงแค่ต้องเขียนสิ่งต่อไปนี้ในคอนโซลเซิร์ฟเวอร์:

อย่างไรก็ตาม ในกรณีนี้ คุณจะได้รับข้อผิดพลาดดังต่อไปนี้: ข้อผิดพลาด 1045 (28000): การเข้าถึงถูกปฏิเสธสำหรับผู้ใช้ 'ODBC'@'localhost' (โดยใช้รหัสผ่าน: NO). ข้อความแสดงข้อผิดพลาดจะปรากฏบน Windows ของฉันดังนี้ หากคุณใช้ Linux แทนที่จะเป็น ODBC จะเป็นชื่อผู้ใช้ระบบของคุณซึ่งคุณดำเนินการในระบบ

ทั้งหมดนี้เป็นเพราะโดยค่าเริ่มต้น เมื่อเชื่อมต่อกับเซิร์ฟเวอร์ MySQL คอนโซลจะใช้ผู้ใช้ ODBC บน Windows โดยไม่ต้องใช้รหัสผ่าน และผู้ใช้ระบบบน Linux ด้วยรหัสผ่านของตัวเอง โฮสต์เริ่มต้นคือ localhost เช่น ผู้ใช้นี้สามารถเชื่อมต่อจากเครื่องท้องถิ่นเท่านั้น

ดังนั้น คุณมีสองทางเลือก: ใช้ผู้ใช้รายอื่นเพื่อเข้าสู่บรรทัดคำสั่ง MySQL หรือสร้างผู้ใช้ MySQL ด้วยบัญชีที่ต้องการ แต่สำหรับวิธีที่สองเรายังทำไม่ได้ถ้าไม่มีวิธีแรก 🙂 ดังนั้นก่อนอื่นเราเชื่อมต่อกับเซิร์ฟเวอร์ MySQL ภายใต้ผู้ใช้มาตรฐาน รากซึ่งถูกสร้างขึ้นเมื่อมีการติดตั้ง MySQL บนคอมพิวเตอร์และอนุญาตให้เข้าถึงจาก localhost ตามค่าเริ่มต้น:

MySQL -u รูท -p

เมื่อได้รับแจ้งให้ป้อนรหัสผ่าน เพียงกด Enter (แน่นอนว่าหากคุณไม่ได้ป้อนเมื่อติดตั้ง MySQL) หลังจากนั้น คุณจะเชื่อมต่อกับเซิร์ฟเวอร์ MySQL กำหนด ID การเชื่อมต่อ และให้สิทธิ์ในการเข้าถึงบรรทัดคำสั่ง MySQL

หากคุณต้องการเชื่อมต่อกับเซิร์ฟเวอร์ MySQL ที่มีชื่อโฮสต์หรือ IP เฉพาะ หรือต้องการเข้าสู่ระบบในฐานะผู้ใช้อื่น ให้ใช้คำสั่งในรูปแบบต่อไปนี้:

Mysql -u ชื่อผู้ใช้ -p รหัสผ่านผู้ใช้ -h MySQL_server_host_or_IP

แทนที่จะใช้อักขระซีริลลิกที่มีการขีดเส้นใต้ คุณต้องป้อนข้อมูลเป็นภาษาละติน หากต้องการคุณสามารถเขียนคำสั่งนี้ในรูปแบบที่แตกต่างออกไปเล็กน้อย:

Mysql --user=user_name --password=user_password --host=MySQL_server_host_or_IP

หากคุณไม่ต้องการให้รหัสผ่านการเชื่อมต่อ MySQL แสดงในคอนโซลด้วยเหตุผลบางประการ (ซึ่งถูกต้องแล้ว) คุณสามารถใช้คำสั่งต่อไปนี้:

Mysql -u ชื่อผู้ใช้ -h MySQL_server_host_or_IP -p

เนื่องจากไม่ได้ระบุรหัสผ่านอย่างชัดเจน คุณจะได้รับแจ้งให้ป้อนในขั้นตอนถัดไป นอกจากนี้ อักขระที่คุณป้อนจะไม่แสดงแม้จะอยู่ในรูปของเครื่องหมายดอกจัน (ไวด์การ์ด) แต่จะเป็นเพียงแค่สตริงว่าง

นอกเหนือจากการตั้งค่าการเชื่อมต่อที่ระบุแล้ว ยังสามารถใช้พารามิเตอร์ต่อไปนี้ได้ โดยค่าต่างๆ จะถูกระบุในลักษณะเดียวกับที่ระบุไว้ข้างต้น:

--port หรือ -P - เพื่อระบุพอร์ตการเชื่อมต่อกับเซิร์ฟเวอร์ MySQL
--โปรโตคอล — โปรโตคอลที่ใช้ในการเชื่อมต่อ (ตัวเลือกที่เป็นไปได้: TCP สำหรับ Windows และ Linux, SOCKET สำหรับ Linux, PIPE และ MEMORY สำหรับ Windows);
--socket หรือ -S - พารามิเตอร์นี้มีประโยชน์หากคุณต้องการเชื่อมต่อผ่านซ็อกเก็ตดังนั้นค่าของพารามิเตอร์จะเป็นซ็อกเก็ต
-pipe หรือ -W - จำเป็นต้องใช้พารามิเตอร์หากคุณต้องการใช้ชื่อ "pipelines" หรือ "pipes" สำหรับการเชื่อมต่อ
--shared-memory-base-name - พารามิเตอร์นี้มีประโยชน์สำหรับการเชื่อมต่อ MEMORY ผ่านหน่วยความจำที่แชร์บน Windows

เป็นที่ชัดเจนว่ารายการพารามิเตอร์การเชื่อมต่อเซิร์ฟเวอร์ MySQL ทั้งหมดไม่ได้จำกัดอยู่เพียงเท่านี้ ในความเป็นจริงยังมีอีกมากมาย

หากด้วยเหตุผลบางประการตัวเลือกมาตรฐานที่ระบุโฮสต์ผู้ใช้และรหัสผ่านไม่เหมาะกับคุณ ข้อมูลต่อไปนี้จะเป็นประโยชน์สำหรับคุณในการค้นหารายการพารามิเตอร์การเชื่อมต่อทั้งหมด - https://dev.mysql.com/doc /refman/5.7/en/connecting.html

วิธีสร้างฐานข้อมูลในคอนโซล MySQL

เมื่อเราเชื่อมต่อกับเซิร์ฟเวอร์ MySQL และเปิดใช้บรรทัดคำสั่ง MySQL แล้ว ก็ถึงเวลาเริ่มต้นวงจรชีวิตของฐานข้อมูลเว็บไซต์ของเรา ซึ่งเริ่มต้นด้วยการสร้างฐานข้อมูล หากต้องการสร้างฐานข้อมูล MySQL ผ่านทางบรรทัดคำสั่ง ให้ป้อนคำสั่งต่อไปนี้:

สร้างฐานข้อมูลdatabase_name;

การดำเนินการเดียวกันนี้สามารถทำได้โดยใช้ยูทิลิตี้ MySQL พิเศษ mysqladmin. มันทำงานแยกจากบรรทัดคำสั่ง MySQL เช่น หากต้องการใช้งาน คุณจะต้องออกหรือเปิดคอนโซลเซิร์ฟเวอร์ใหม่

จากนั้นเรียกใช้คำสั่งต่อไปนี้:

mysqladmin สร้างฐานข้อมูลชื่อ;

อย่างไรก็ตาม การใช้ยูทิลิตี้ mysqladmin คุณไม่เพียงสามารถสร้างและลบฐานข้อมูลโดยไม่ต้องเข้าสู่คอนโซล MySQL เท่านั้น แต่ยังจัดการการกำหนดค่าเซิร์ฟเวอร์ กระบวนการ MySQL จัดการการจำลองแบบ เซิร์ฟเวอร์ ping และทำสิ่งที่น่าสนใจอื่น ๆ อีกมากมาย

วิธีสร้างผู้ใช้ MySQL บนบรรทัดคำสั่ง

ไม่บ่อยนัก แต่บางครั้งก็จำเป็นต้องสร้างผู้ใช้ MySQL ใหม่ และในโหมดคอนโซล

บนบรรทัดคำสั่ง MySQL ทำได้ดังนี้:

สร้างผู้ใช้ "ชื่อผู้ใช้"@"host_or_machine_ip" ระบุโดย "user_password";

ผู้ใช้ได้ถูกสร้างขึ้นแล้ว พารามิเตอร์ host_or_IP_machineหมายความว่าเมื่อสร้างผู้ใช้คุณจะต้องระบุ IP ที่เขาสามารถเชื่อมต่อกับเซิร์ฟเวอร์หรือชื่อโฮสต์ (ชื่อโดเมนของเครื่องที่ทำงานบนเครือข่ายเหมาะสม)

อย่างไรก็ตาม เมื่อระบุโฮสต์เพื่อเชื่อมต่อกับเซิร์ฟเวอร์ MySQL คุณสามารถใช้สัญลักษณ์เปอร์เซ็นต์ - % ซึ่งหมายความว่าผู้ใช้ที่ถูกสร้างขึ้นสามารถเชื่อมต่อกับเซิร์ฟเวอร์ MySQL จากที่อยู่ IP หรือโฮสต์ใดก็ได้

ควรคำนึงว่าในกรณีนี้ localhost จะไม่รวมอยู่ในรายการที่อยู่ที่ระบุโดยใช้ % เพราะ localhost หมายถึงการเชื่อมต่อซ็อกเก็ต UNIX แทน TCP/IP มาตรฐาน เหล่านั้น. หากผู้ใช้ MySQL ที่สร้างขึ้นเชื่อมต่อกับเซิร์ฟเวอร์ที่ไม่ได้ใช้ซ็อกเก็ต แต่ใช้โปรโตคอลอื่นที่ระบุเมื่อเชื่อมต่อกับเซิร์ฟเวอร์ MySQL ในคอนโซล เขาจะต้องสร้างบัญชีผู้ใช้สองบัญชี:

สร้างผู้ใช้ "ชื่อผู้ใช้"@"%" ระบุโดย "รหัสผ่าน"; สร้างผู้ใช้ "ชื่อผู้ใช้"@"localhost" ระบุโดย "รหัสผ่าน";

เราค้นพบวิธีสร้างผู้ใช้ MySQL ในคอนโซลแล้ว ตอนนี้เรามาตั้งค่าสิทธิ์ผู้ใช้เพื่อดำเนินการใด ๆ กับฐานข้อมูลที่สร้างขึ้นใหม่ของเราด้วยคำสั่งต่อไปนี้:

ให้สิทธิ์ทั้งหมดบนdatabase_name.* เป็น "ชื่อผู้ใช้"@"host_or_machine_ip";

ตัวเลือก ทั้งหมดตามที่คุณเข้าใจ เพียงระบุว่าผู้ใช้ได้รับอนุญาตให้ดำเนินการใดๆ กับฐานข้อมูลเฉพาะ รายการสิทธิ์ทั้งหมดที่สามารถมอบให้กับผู้ใช้ได้โดยใช้คำสั่ง ยินยอมสามารถพบได้ที่นี่ (แม้ว่าคำอธิบายของพารามิเตอร์จะเป็นภาษาอังกฤษ) - https://dev.mysql.com/doc/refman/5.7/en/grant.html#grant-privileges

อย่างไรก็ตาม คุณสามารถใช้พารามิเตอร์สิทธิพิเศษได้หลายรายการโดยระบุเมื่อเรียกใช้คำสั่งโดยคั่นด้วยเครื่องหมายจุลภาค

หากคุณต้องการสร้าง superuser เช่น มีสิทธิ์ระดับโลกในการดำเนินการต่าง ๆ กับฐานข้อมูลทั้งหมดบนเซิร์ฟเวอร์ จากนั้นใช้การเรียกคำสั่งต่อไปนี้:

ให้สิทธิ์ทั้งหมด *.* เป็น "ชื่อผู้ใช้"@"host_or_machine_IP";

อย่างไรก็ตาม การล้างแคชของเซิร์ฟเวอร์ MySQL หลังจากตั้งค่าสิทธิ์จะไม่ฟุ่มเฟือย หากคุณเปลี่ยนแปลงอย่าลืมทำสิ่งนี้ด้วยการเรียกคำสั่งต่อไปนี้:

สิทธิ์ล้าง;

และหากคุณต้องการเปลี่ยนการอนุญาตของผู้ใช้ ให้ใช้คำสั่งต่อไปนี้เพื่อรีเซ็ตการอนุญาตทั้งหมดก่อน:

เพิกถอนสิทธิ์ทั้งหมดบน *.* จาก "ชื่อผู้ใช้"@"host_or_machine_IP";

แล้วติดตั้งด้วย ยินยอมตามที่อธิบายไว้ก่อนหน้านี้

หากคุณต้องการเปลี่ยนรหัสผ่านผู้ใช้ MySQL ในอนาคต เพียงเรียกใช้คำสั่งต่อไปนี้ใน MySQL Shell:

ตั้งรหัสผ่านสำหรับ "ชื่อผู้ใช้"@"host_or_machine_IP" = รหัสผ่าน("new_password"); สิทธิ์ล้าง;

จำเป็นต้องรีเซ็ตแคชสิทธิ์เซิร์ฟเวอร์ MySQL เพื่อจุดประสงค์เดียวกับเมื่อเปลี่ยนสิทธิ์ - หากไม่มีการดำเนินการนี้ การเปลี่ยนรหัสผ่านผู้ใช้ MySQL อาจไม่นับ ดังนั้นอย่าขี้เกียจที่จะใช้มัน 🙂

อย่างไรก็ตาม อินเทอร์เน็ตเต็มไปด้วยตัวอย่างการใช้คำสั่งต่อไปนี้เพื่อรีเซ็ตรหัสผ่าน MySQL ของผู้ใช้:

อัปเดตรหัสผ่าน mysql.user SET = PASSWORD ("รหัสผ่าน") WHERE User = "ชื่อผู้ใช้";

แต่ตัวเลือกนี้ใช้งานไม่ได้สำหรับฉันใน MySQL 5.7 โดยทำให้เกิดข้อผิดพลาด ข้อผิดพลาด 1,054 (42S22): คอลัมน์ที่ไม่รู้จัก 'รหัสผ่าน' ใน 'รายการฟิลด์'. สาเหตุเกิดจากการไม่มีช่องรหัสผ่านในตาราง mysql.user

ซึ่งเราสามารถสรุปได้ว่าตัวเลือกนี้ใช้ได้กับ MySQL เวอร์ชันเก่าเท่านั้นซึ่งมีฟิลด์นี้อยู่ในตารางผู้ใช้ ดังนั้นเพื่อให้แน่ใจว่าใช้ตัวเลือกแรกของฉัน เว้นแต่ว่าคุณถูกบังคับให้ทำงานกับซอฟต์แวร์ต่อต้านไวรัสโดยไม่มีความสามารถในการอัปเดตเวอร์ชัน :)

สิ่งนี้ทำให้การสร้างผู้ใช้ MySQL ใหม่เสร็จสมบูรณ์และตรวจสอบการดำเนินการด้วยสิทธิ์และรหัสผ่าน ไปต่อกันดีกว่า

การเลือกฐานข้อมูลเมื่อทำงานกับ MySQL ผ่านทางบรรทัดคำสั่ง

ตอนนี้หลังจากสร้างผู้ใช้ใน MySQL Shell และกำหนดสิทธิ์ในการทำงานกับฐานข้อมูลแล้ว เราจำเป็นต้องเลือกฐานข้อมูลนี้เพื่อให้เราสามารถดำเนินการกับฐานข้อมูลเองและข้อมูลที่เก็บไว้ในนั้นได้

เมื่อต้องการทำเช่นนี้ ให้ใช้คำสั่งต่อไปนี้ในคอนโซล MySQL:

ใช้ฐานข้อมูล_ชื่อ;

หากทุกอย่างเป็นไปด้วยดี ข้อความจะแสดงบนคอนโซล ฐานข้อมูลมีการเปลี่ยนแปลงซึ่งจะส่งสัญญาณว่าเราลงชื่อเข้าใช้ฐานข้อมูล MySQL ผ่านคอนโซลแล้ว อย่างไรก็ตามเมื่อเชื่อมต่อกับเซิร์ฟเวอร์ MySQL คุณสามารถระบุฐานข้อมูลที่คุณต้องการใช้งานได้ในตอนแรก เมื่อต้องการทำเช่นนี้ ให้ป้อนคำสั่งต่อไปนี้ในคอนโซลเซิร์ฟเวอร์:

Mysql --user=user_name --password=user_password --host=MySQL_server_host_or_IP --database=database_name

หรือเช่นเดียวกันขอเพียงรหัสผ่านผู้ใช้ MySQL:

mysql -u ชื่อผู้ใช้ -h host_or_ip_mysql_server_database_name -p

นั่นคือทั้งหมดที่ ฉันคิดว่าตอนนี้คุณจะไม่มีปัญหาในการเชื่อมต่อกับฐานข้อมูล MySQL ผ่านคอนโซล🙂

การทำงานกับตาราง MySQL ผ่านคอนโซล MySQL

ดังนั้นเราจึงสร้างฐานข้อมูล MySQL ผ่านคอนโซล ตอนนี้เป็นการดีที่จะเรียนรู้วิธีทำงานกับมันในกรณีที่บรรทัดคำสั่ง MySQL จะเป็นวิธีเดียวในการเข้าถึงข้อมูลที่เก็บไว้บนเซิร์ฟเวอร์ (เช่นเดียวกับฉันซึ่งฉันได้พูดถึงในตอนต้นของบทความ ).

ดังที่คุณทราบมันประกอบด้วยตารางซึ่งภายในข้อมูลถูกเก็บไว้แล้วในรูปแบบของบันทึกที่มีหลายฟิลด์ ดังนั้น ตามลำดับชั้นของการจัดวางข้อมูล ก่อนอื่นเราจะเรียนรู้วิธีการดำเนินการ CRUD ทั่วไปกับตาราง

การดำเนินการ CRUD หากมีใครไม่ทราบคือการดำเนินการสำหรับการสร้าง อ่าน อัปเดตและลบข้อมูลจากภาษาอังกฤษ "สร้าง อ่าน อัปเดต ลบ" (คุณอาจต้องใช้ข้อมูลนี้ในการสัมภาษณ์)

ฉันขอเตือนคุณว่าเพื่อที่จะดำเนินการกับตาราง คุณต้องเชื่อมต่อกับฐานข้อมูล MySQL โดยใช้คำสั่งก่อน ใช้.

ดังนั้นสิ่งแรกในวาระการประชุมของเราคือคำสั่งให้สร้างตาราง MySQL ในฐานข้อมูลผ่านทางบรรทัดคำสั่งซึ่งมีลักษณะดังนี้:

สร้างตาราง table_name (field_name_1 field_type_1, field_name_2 field_type_2(field_size_2), INDEX(field_name_1), ...);

ตามที่คุณเข้าใจ สามารถมีฟิลด์ได้มากเท่าที่คุณต้องการ ประเภทของฟิลด์อาจแตกต่างกัน และการมีอยู่ของดัชนีและคีย์ก็เป็นทางเลือก

อย่างไรก็ตาม หากคุณต้องการคัดลอกตารางไปยังฐานข้อมูลอื่นหรือเพียงสร้างสำเนาในฐานข้อมูลปัจจุบัน คำสั่งต่อไปนี้จะช่วยคุณ:

สร้างตาราง new_table_name เช่น old_table_name; ใส่ new_table_name SELECT * จาก old_table_name;

คำสั่งเหล่านี้ช่วยให้คุณสามารถคัดลอกโครงสร้างของตารางและข้อมูลพร้อมกับดัชนีและทริกเกอร์ตารางได้ หากคุณต้องการข้อมูลและโครงสร้าง (ชื่อของฟิลด์และประเภทข้อมูล) คุณสามารถดำเนินการได้ด้วยการเรียกคำสั่งเดียว:

สร้างตาราง new_table_name AS SELECT * จาก old_table_name;

การดำเนินการถัดไปจากบล็อก CRUD กำลังอ่าน ในกรณีของตาราง การอ่านจะแสดงโครงสร้าง มีสี่คำสั่งสำหรับสิ่งนี้:

แสดงคอลัมน์ทั้งหมดจาก table_name; อธิบาย table_name; อธิบาย table_name; แสดงสร้างตาราง table_name;

เอาต์พุตแรกข้อมูลเกี่ยวกับฟิลด์ของตารางฐานข้อมูลในรูปแบบตารางไปยังคอนโซล MySQL โดยระบุชื่อฟิลด์ ประเภทข้อมูล การมีอยู่ของคีย์ ค่าเริ่มต้น ฯลฯ เมื่อใช้คำสำคัญ เต็มคุณสามารถรับข้อมูลเพิ่มเติม รวมถึงสิทธิพิเศษในแต่ละฟิลด์สำหรับผู้ใช้ปัจจุบัน ความคิดเห็นในแต่ละฟิลด์ และค่าการเข้ารหัส

คำสั่งที่สองและสามเป็นเพียงรูปแบบย่อของคำสั่งแรกโดยไม่มีข้อมูลเพิ่มเติม เหตุใดจึงต้องสร้างมันขึ้นมา - ฉันนึกไม่ออกเลย ... เป็นไปได้ไหมที่จะมีเรื่องต้องถามตอนสัมภาษณ์เมื่อสมัครงาน? 🙂

คำสั่งที่สี่ นอกเหนือจากชื่อ ประเภทฟิลด์ และค่าเริ่มต้น ยังช่วยให้คุณรับค่าของคีย์ตาราง เอ็นจิ้นตาราง (InnoDB, MyISAM) การเข้ารหัส ฯลฯ

การดำเนินการอัปเดตในกรณีของตารางคือการเปลี่ยนแปลงโครงสร้างเช่น การดำเนินการต่างๆ กับเขตข้อมูลตาราง MySQL:

แก้ไขตาราง table_name DROP COLUMN field_name; แก้ไขตาราง table_name เพิ่มคอลัมน์ field_name VARCHAR (20); แก้ไขตาราง table_name เปลี่ยน old_field_name new_field_name VARCHAR (50); แก้ไขตาราง table_name MODIFY field_name VARCHAR (3);

คำสั่งแรกช่วยให้คุณสามารถลบฟิลด์เฉพาะของตารางคำสั่งที่สอง - เพื่อเพิ่มคำสั่งที่สามช่วยให้คุณสามารถเปลี่ยนชื่อฟิลด์และเปลี่ยนประเภทของข้อมูลที่เก็บไว้ในนั้นไปพร้อม ๆ กันและคำสั่งที่สี่ - เปลี่ยนเฉพาะประเภทข้อมูล

สิ่งเดียวกันนี้สามารถทำได้กับดัชนีตารางโดยใช้คำสั่งเดียวกันมาก:

แก้ไขตาราง table_name เพิ่มดัชนีที่ไม่ซ้ำกัน index_name (field_name_1, ... ); แก้ไขตาราง table_name เปลี่ยนชื่อ INDEX old_index_name เป็น new_index_name; แก้ไขตาราง table_name DROP INDEX index_name;

คำสั่งข้างต้นอนุญาตให้คุณเพิ่ม เปลี่ยนชื่อ และลบดัชนีออกจากตาราง MySQL ผ่านทางบรรทัดคำสั่ง ในการเพิ่มและลบดัชนี มีตัวเลือกอื่นสำหรับการใช้คำสั่งอิสระและไม่ทำผ่าน แก้ไขตาราง. ดังนั้นหากคุณต้องการคุณสามารถใช้มันได้:

สร้างดัชนีที่ไม่ซ้ำกัน index_name (field_name_1, ...) บน table_name; วางดัชนี index_name บน table_name;

คำสั่งข้างต้นเทียบเท่ากับคำสั่งแรกและสุดท้ายจากบล็อกก่อนหน้า น่าเสียดายที่ไม่มีคำสั่งแยกต่างหากในการเปลี่ยนชื่อดัชนี และหากต้องการเปลี่ยนประเภทดัชนี น่าเสียดายที่ไม่มีความเป็นไปได้ใน MySQL เลย ทางออกเดียวคือการลบดัชนีและสร้างใหม่อีกครั้งตามประเภทที่ต้องการ

ในที่สุดเราก็มาถึงการดำเนินการสุดท้ายจากบล็อก CRUD - เพื่อลบ การลบตาราง MySQL ออกจากฐานข้อมูลนั้นทำได้ง่ายมาก การรันคำสั่งต่อไปนี้ในคอนโซล MySQL ก็เพียงพอแล้ว:

วางตาราง table_name;

บางครั้งในทางปฏิบัติมีสถานการณ์ที่ไม่สามารถลบตารางหรือเปลี่ยนโครงสร้างได้ ตามกฎแล้ว นี่เป็นเพราะการใช้คีย์ต่างประเทศในฐานข้อมูลเพื่อเชื่อมโยงตารางระหว่างกัน โดยส่วนตัวแล้วฉันพบกับสถานการณ์นี้มากกว่าหนึ่งครั้งดังที่ได้กล่าวไว้ในตอนต้นของบทความ

ดังนั้นหากเมื่อลบหรืออัปเดตโครงสร้างของตารางหรือข้อมูล MySQL จะส่งคืนข้อผิดพลาดพร้อมข้อความ ไม่สามารถลบหรืออัปเดตแถวพาเรนต์ได้: ข้อจำกัดของคีย์นอกล้มเหลวจากนั้นข้อมูลต่อไปนี้จะเป็นประโยชน์สำหรับคุณ

เพื่อดำเนินการตามแผนของเรา เราจำเป็นต้องปิดการใช้งานการตรวจสอบการมีอยู่ของคีย์ต่างประเทศชั่วคราว ดำเนินการที่จำเป็น จากนั้นเปิดการตรวจสอบอีกครั้ง เนื่องจาก จำเป็นจริงๆ และช่วยให้คุณสามารถป้องกันตนเองจากการละเมิดความสมบูรณ์ของข้อมูลในกรณีส่วนใหญ่

อันที่จริงจำเป็นต้องใช้คีย์ต่างประเทศของ MySQL เพื่อจุดประสงค์นี้

ดังนั้น หากต้องการลบข้อมูลที่ถูกรบกวนด้วยคีย์ภายนอก คุณต้องทำตามขั้นตอนต่อไปนี้ในคอนโซล MySQL:

ตั้งค่า FOREIGN_KEY_CHECKS=0; #required_mysql_command ตั้งค่า FOREIGN_KEY_CHECKS=1;

อย่างไรก็ตาม หากคุณต้องการลบคีย์ต่างประเทศ ขั้นตอนจะเหมือนกับเมื่อคุณลบดัชนี:

แก้ไขตาราง table_name DROP คีย์ต่างประเทศ Foreign_key_name;

หากต้องการค้นหาชื่อคีย์นอก MySQL ของตาราง ให้ใช้คำสั่งคอนโซล MySQL ที่คุ้นเคยในขณะนี้ แสดงสร้างตาราง.

การทำงานกับข้อมูลตาราง MySQL ผ่านทางบรรทัดคำสั่ง

สำหรับตาราง การดำเนินการ CRUD ในคอนโซล MySQL เราได้พิจารณาแล้ว เพื่อภาพรวมที่สมบูรณ์ เอกสารสรุปนี้ขาดเฉพาะคำสั่งสำหรับการทำงานกับข้อมูลที่จัดเก็บไว้ในตารางฐานข้อมูล ฉันคิดว่าหลายคนรู้จักคำสั่งเหล่านี้และนำไปใช้ในทางปฏิบัติ แต่ฉันก็ยังจะเตือนพวกเขาอีกครั้ง

การดำเนินการ CRUD สำหรับการทำงานกับข้อมูลตาราง MySQL จะมีลักษณะดังนี้:

แทรกลงใน table_name (field1, field2, ...) ค่า (ค่า field_1, ค่า field_2, ...); เลือก field1, field2, ... จาก table_name; อัปเดต table_name SET field1 = ค่า field_1, field2 = ค่า field_2; ลบออกจาก table_name โดยที่ field1 = ค่า field_1;

คำสั่งข้างต้นสอดคล้องกับการดำเนินการสร้าง อ่าน อัปเดต และลบข้อมูลจากตารางฐานข้อมูล MySQL เมื่อใช้ SELECT และ UPDATE ยังเป็นไปได้ที่จะใช้ WHERE clause ที่มีคุณสมบัติเหมาะสม ซึ่งสามารถใช้เพื่อระบุการเลือกข้อมูลในลักษณะที่อธิบายไว้ในกรณีของการใช้ DELETE

นอกจากนี้ เมื่อดึงข้อมูลจากฐานข้อมูลโดยใช้ SELECT คุณสามารถใช้ตัวเลือกต่อไปนี้เพื่อรับค่าของทุกฟิลด์ของตาราง:

SELECT * จาก table_name;

โดยปกติแล้ว ตัวดำเนินการอื่นๆ นอกเหนือจาก WHERE สามารถใช้ในการดำเนินการเหล่านี้ได้ มีหลายตัวเลือกโดยเฉพาะอย่างยิ่งเมื่อเลือกข้อมูลโดยใช้ SELECT: มี UNION สำหรับรวมผลลัพธ์ของการสืบค้นหลายรายการและ JOIN ประเภทต่างๆ รายการทั้งหมดยาวมากและน่าเบื่อสำหรับฉันและคุณจะอ่านข้อความนี้

ดังนั้นเรามาตกลงกัน: หากคุณต้องการเรียนรู้เพิ่มเติมเกี่ยวกับบางสิ่งเพียงเขียนเกี่ยวกับสิ่งนั้นในความคิดเห็นแล้วฉันจะพยายามตอบคุณ หรือสมาชิกที่มีความรู้ในชุมชนของเราก็จะทำเช่นนั้น ตกลง? 😉

ดังนั้น เราจะไม่อยู่บล็อกนี้อีกต่อไป

หากคุณต้องการลบข้อมูลทั้งหมดออกจากตาราง คุณสามารถใช้คำสั่ง MySQL ต่อไปนี้:

ตัด table_name;

ก่อนที่จะเรียกมัน ดังที่กล่าวไปแล้ว คุณอาจต้องปิดการใช้งานการตรวจสอบคีย์ต่างประเทศในกรณีที่มีตาราง MySQL ที่เกี่ยวข้อง ซึ่งอาจขัดขวางไม่ให้ดำเนินการที่จำเป็น

อีกจุดที่น่าสนใจที่ควรพิจารณาที่นี่คือคำสั่งนี้ไม่ได้รีเซ็ตตัวนับ AUTO_INCREMENT ซึ่งทราบกันดีว่าใช้ในการสร้างค่าฟิลด์โดยอัตโนมัติโดยไม่ต้องตั้งค่าด้วยตนเอง

ฟิลด์ประเภทนี้ส่วนใหญ่มักใช้เพื่อสร้างค่าสำหรับรหัสฟิลด์คีย์หลักซึ่งใช้เพื่อสร้างลิงก์ระหว่างข้อมูลจากตารางที่ต่างกัน

นั่นคือถ้าก่อนที่จะลบข้อมูลตารางโดยใช้ ตัดค่าสูงสุดของตัวนับคือ 1200 จากนั้นบันทึกแรกหลังจากขั้นตอนนี้จะมีค่าของตัวระบุ 1201 โดยหลักการแล้ว ไม่เป็นไร หากคุณกำหนดขนาดที่เพียงพอสำหรับช่องนี้ คุณจะไม่ต้องเจอกับค่าล้นในเร็วๆ นี้

อย่างไรก็ตาม ในบางกรณี เมื่อมีการผูกเข้ากับค่าฟิลด์ในโค้ดของแอปพลิเคชันบางประเภท ลักษณะการทำงานนี้อาจไม่สะดวก

เพื่อหลีกเลี่ยงปัญหานี้ ให้ใช้ตัวเลือกนี้แทนคำสั่งด้านบน:

ตัดทอนตาราง someTable RESTART IDENTITY;

ตัวเลือกการเรียกคำสั่งนี้ ตัดจะอนุญาตให้คุณรีเซ็ตค่าตัวนับฟิลด์จาก AUTO_INCREMENT. ดังนั้นค่าฟิลด์ของเรกคอร์ดแรกที่เพิ่มหลังจากการลบนี้จะเป็น 1 แทนที่จะเป็น 1201 ดังตัวอย่างด้านบน

วิธีลบฐานข้อมูล MySQL ผ่านทางบรรทัดคำสั่ง

วงจรชีวิตของการทำงานกับฐานข้อมูลกำลังจะสิ้นสุดลงและจบลงอย่างสมเหตุสมผล - ด้วยการลบออก ในการดำเนินการนี้ในคอนโซล MySQL คุณต้องดำเนินการคำสั่งต่อไปนี้ (ในกรณีนี้ ฐานข้อมูลที่จะลบอาจไม่ถูกเลือกโดยคำสั่ง ใช้):

ลบฐานข้อมูลdatabase_name;

การดำเนินการเดียวกันนี้สามารถทำได้โดยใช้ยูทิลิตี้ MySQL mysqladmin ซึ่งฉันได้กล่าวไว้แล้วในตอนต้นของบทความเมื่อสร้างฐานข้อมูล:

mysqladmin ปล่อยฐานข้อมูล_ชื่อ;

เมื่อเรียกใช้คำสั่ง ข้อความต่อไปนี้จะปรากฏในคอนโซลเซิร์ฟเวอร์:

การปล่อยฐานข้อมูลอาจเป็นสิ่งที่เลวร้ายมาก
ข้อมูลใด ๆ ที่เก็บไว้ในฐานข้อมูลจะถูกทำลาย

คุณต้องการวางฐานข้อมูล 'database_name' จริงๆ หรือไม่

กล่าวโดยสรุป นี่เป็นคำเตือนว่าการลบฐานข้อมูล MySQL เป็นความคิดที่แย่มาก พร้อมทั้งขอคำยืนยันการดำเนินการด้วย หากคุณเห็นด้วยให้เขียน ยและกด เข้าบนแป้นพิมพ์หลังจากนั้นข้อความต่อไปนี้จะปรากฏขึ้นบนหน้าจอ (หากทุกอย่างเป็นไปด้วยดีแน่นอน):

ฐานข้อมูล "database_name" ลดลง

แบบนี้ครับ 🙂

วิธีลบผู้ใช้ MySQL ในคอนโซล

ตอนนี้ชะตากรรมเดียวกันก็จะตกอยู่กับผู้ใช้ MySQL ที่เรากำลังสร้างเพื่อแสดงให้คุณเห็นว่ามันทำงานอย่างไร แต่สำหรับผู้เริ่มต้น เป็นการดีที่จะตรวจสอบว่ามีผู้ใช้ที่ต้องการอยู่จริงหรือไม่ก่อนที่จะลบออก

ตั้งแต่ MySQL 5.7 เป็นต้นไป จะมีหนึ่งคำสั่งสำหรับการดำเนินการทั้งสองนี้:

วางผู้ใช้หากมีชื่อผู้ใช้อยู่

MySQL เวอร์ชันก่อนหน้าต้องใช้คำสั่งสองคำสั่งแยกกัน:

ให้สิทธิ์ใช้งานบน *.* ถึง "ชื่อผู้ใช้"@"host_or_IP_address"; วางผู้ใช้ "ชื่อผู้ใช้"@"host_or_ip_address";

น่าเสียดาย ในกรณีนี้ ข้อความเกี่ยวกับความสำเร็จของการดำเนินการในคอนโซล MySQL นั้นไม่มีข้อมูลตามธรรมเนียม 🙁 ดังนั้น หากต้องการทราบว่ามีการลบผู้ใช้ MySQL เกิดขึ้น คุณสามารถใช้คำสั่งต่อไปนี้ซึ่งแสดงรายการของ ผู้ใช้ทั้งหมดที่มีอยู่ในเซิร์ฟเวอร์ MySQL ปัจจุบัน:

เลือกผู้ใช้จาก mysql.user;

คำสั่งเวอร์ชันนี้จะแสดงเฉพาะชื่อผู้ใช้เท่านั้น หากคุณต้องการดูโฮสต์ที่ผู้ใช้สามารถเชื่อมต่อกับเซิร์ฟเวอร์และรายการสิทธิ์คุณสามารถเรียกคำสั่งในรูปแบบต่อไปนี้:

เลือกผู้ใช้, โฮสต์, Grant_priv จาก mysql.user;

นอกจากนี้ยังมีช่องอื่นๆ อีกมากมายในตาราง mysql.user ที่เก็บสิทธิ์ประเภทอื่นๆ และข้อมูลอื่นๆ สามารถดูรายการทั้งหมดได้ที่นี่ - https://mariadb.com/kb/en/library/mysqluser-table/

อย่าสับสนว่านี่คือเอกสารสำหรับ MariaDB DBMS ในทางเทคนิคแล้วก็เหมือนกับ MySQL เพราะ MariaDB เป็นเพียงหน่อหรือทางแยกจากภาษาอังกฤษ "fork" - สาขาหรือทางแยก

ทำไมต้องทำ - อีกครั้งโดยไม่มีเบาะแส 🙂 เป็นไปได้ไหมที่จะประกาศกับทุกคนอย่างภาคภูมิใจว่า "ฉันมี DBMS ของตัวเอง" .. แต่จริงๆ แล้วฉันไม่ค่อยตระหนักถึงแรงจูงใจและความแตกต่างที่แน่นอนระหว่าง MySQL กับ มาเรียดีบี ดังนั้นหากคุณรู้บางอย่างเกี่ยวกับเรื่องนี้การอ่านความคิดเห็นในความคิดเห็นก็น่าสนใจ

ออกจากคอนโซล MySQL

นั่นคือทั้งหมด วงจรชีวิตของฐานข้อมูลและผู้ใช้ซึ่งเริ่มต้นด้วยการสร้างและสิ้นสุดด้วยการลบได้สิ้นสุดลงแล้ว ดังนั้นบรรทัดคำสั่ง MySQL ที่เราทำงานด้วยในคอนโซลเซิร์ฟเวอร์โดยใช้ยูทิลิตี้ mysqlเราไม่ต้องการอีกต่อไป

มันยังคงอยู่เพียงเพื่อที่จะออกไปจากมัน ...

ดูเหมือนว่าการดำเนินการนั้นไม่สำคัญ แต่หลายอย่างในสถานการณ์ที่คุณต้องออกจากบรรทัดคำสั่ง MySQL เพียงแค่ปิดคอนโซลเซิร์ฟเวอร์แล้วเปิดอีกครั้ง แน่นอนว่าคุณสามารถทำเช่นนี้ได้ แต่จะใช้เวลาทำงานเพิ่มขึ้นไม่กี่วินาทีและทำให้คุณรำคาญทุกครั้งที่ต้องทำ

ลักษณะการทำงานที่ถูกต้องในสถานการณ์นี้คือเพียงแค่เรียกคำสั่ง ออกบนบรรทัดคำสั่ง MySQL หลังจากนั้นบริการจะกล่าวคำอำลาเราอย่างสุภาพ🙂

และอะไรบางอย่าง 🙂 ดังนั้นในครั้งต่อไปที่คุณไม่จำเป็นต้องวางคอนโซลและเปิดคอนโซลเหล่านั้นใหม่ทุกครั้งที่คุณต้องออกจาก MySQL ในคอนโซลและเข้าถึงอีกครั้งเพื่อจัดการเซิร์ฟเวอร์

นั่นคือทั้งหมดที่ฉันอยากจะบอกคุณในวันนี้ ฉันหวังว่าเอกสารสรุปของฉันเกี่ยวกับการทำงานกับบรรทัดคำสั่ง MySQL ผ่านคอนโซลจะมีประโยชน์ไม่เพียงสำหรับฉันเท่านั้น แต่ยังรวมถึงคุณด้วย

เมื่อพูดถึงการประยุกต์ใช้ข้อมูลที่นำเสนอในบทความในทางปฏิบัติ ฉันอยากจะจำไว้ว่าโครงสร้างข้างต้นสามารถใช้ได้ไม่เพียงแต่ในบรรทัดคำสั่ง MySQL และคอนโซลเซิร์ฟเวอร์เท่านั้น แต่ยังรวมถึงคอนโซล phpMyAdmin และซอฟต์แวร์อื่น ๆ ที่ให้บริการดังกล่าวด้วย โอกาส.

ไม่ว่าคุณจะใช้มันหรือไม่ก็ขึ้นอยู่กับคุณ แต่อย่างที่ฉันได้กล่าวไว้ในตอนต้นของบทความ มีสถานการณ์ต่างๆ ที่การใช้คอนโซล MySQL สามารถช่วยคุณประหยัดเวลาและความเครียดได้ และจะใช้บรรทัดคำสั่งทุกวันหรือไม่นั้นก็ขึ้นอยู่กับรสนิยมและความชอบส่วนบุคคล

เขียนความคิดเห็นเกี่ยวกับคำสั่งที่คุณใช้บ่อยที่สุด หรือบางทีคุณอาจรู้เทคนิคอื่น ๆ ไม่ว่าในกรณีใด แบ่งปันความคิดเห็นของคุณกับคนอื่น ๆ และสนทนาต่อไปในความคิดเห็นของผู้ใช้คนอื่น ๆ

ฉันสัญญาว่าในกระบวนการนี้ คุณจะได้เรียนรู้สิ่งใหม่ๆ มากมาย เช่นเดียวกับที่ฉันทำเมื่อเขียนบทความแต่ละบทความ 🙂

นั่นคือทั้งหมด! ขอให้โชคดีแล้วพบกันใหม่🙂

ป.ล.: หากคุณต้องการเว็บไซต์หรือต้องการเปลี่ยนแปลงเว็บไซต์ที่มีอยู่ แต่ไม่มีเวลาและความต้องการ ฉันสามารถให้บริการได้
ประสบการณ์มากกว่า 5 ปีการพัฒนาเว็บไซต์อย่างมืออาชีพ ทำงานกับ PHP, เปิดรถเข็น, เวิร์ดเพรส, ลาราเวล, ยี่, MySQL, PostgreSQL, จาวาสคริปต์, ตอบสนอง, เชิงมุมและเทคโนโลยีการพัฒนาเว็บไซต์อื่นๆ

ด้านล่างนี้คือรายการคำสั่งที่มีประโยชน์และใช้บ่อยที่สุด MySQLพร้อมตัวอย่าง

mysql ที่จุดเริ่มต้นของบรรทัดหมายความว่าคำสั่งจะถูกดำเนินการหลังจากป้อน MySQL.

สัญลักษณ์ # หรือ $ ที่จุดเริ่มต้นของบรรทัดหมายความว่าคำสั่งกำลังถูกดำเนินการจากบรรทัดคำสั่ง

เพื่อตรวจสอบสถานะเซิร์ฟเวอร์ MySQLวิ่ง:

สำหรับ ฟรีBSD:

# บริการสถานะเซิร์ฟเวอร์ mysql

วี CentOS/RHEL:

# บริการสถานะ mysqld

MySQLจากคอนโซลหากเซิร์ฟเวอร์ MySQLอยู่บนโฮสต์เดียวกัน:

เพื่อเชื่อมต่อกับเซิร์ฟเวอร์ MySQLจากคอนโซลหากเซิร์ฟเวอร์ MySQLที่อยู่บนโฮสต์ระยะไกล db1.example.com:

$ mysql -u ชื่อผู้ใช้ -p -h db1.example.com

การทำงานกับฐานข้อมูล ตาราง - การดู การลบ และการแก้ไขบันทึก คอนโซล

สร้างฐานข้อมูลบน MySQLเซิร์ฟเวอร์:

mysql สร้างฐานข้อมูล

แสดงรายการฐานข้อมูลทั้งหมดบนเซิร์ฟเวอร์ MySQL:

ใช้ MySQL ;

แสดงตารางทั้งหมดในฐานข้อมูล:

ตารางแสดง mysql;

ดูรูปแบบตารางในฐานข้อมูล:

mysql อธิบาย;

ลบฐาน:

ฐานข้อมูล mysql หล่น;

ลบตารางออกจากฐานข้อมูล:

ตารางวาง mysql ;

แสดงเนื้อหาทั้งหมดของตาราง:

MySQL เลือก * จาก ;

แสดงคอลัมน์และเนื้อหาของคอลัมน์ในตารางที่เลือก:

Mysql แสดงคอลัมน์จาก ;

แสดงแถวในตารางเฉพาะที่มี " อะไรก็ตาม ":

MySQL SELECT * จากที่ไหน = "อะไรก็ได้";

แสดงบันทึกทั้งหมดในตารางเฉพาะที่มี " Bob " และหมายเลขโทรศัพท์ " 3444444:

Mysql SELECT * จากที่ name = " Bob " และ phone_number = " 3444444 ";

แสดงรายการทั้งหมด ไม่ประกอบด้วยชื่อ " บ๊อบ " และหมายเลขโทรศัพท์ " 3444444 " เรียงตามช่อง phone_number:

Mysql SELECT * จาก WHERE name != " Bob " AND phone_number = " 3444444 " สั่งซื้อโดย phone_number;

แสดงรายการทั้งหมดที่ขึ้นต้นด้วยตัวอักษร " bob " และหมายเลขโทรศัพท์ " 3444444 " ในตารางเฉพาะ:

Mysql SELECT * จากที่ชื่อเช่น " Bob %" และ phone_number = " 3444444 ";

แสดงรายการทั้งหมดที่ขึ้นต้นด้วยตัวอักษร " bob " และหมายเลขโทรศัพท์ " 3444444 " จำกัดเฉพาะรายการที่ 1 ถึง 5:

Mysql SELECT * จากที่ ชื่อเช่น " Bob %" และ phone_number = " 3444444 " จำกัด 1.5;

การใช้นิพจน์ทั่วไป ("REGEXP BINARY") เพื่อค้นหาบันทึก ตัวอย่างเช่น สำหรับการค้นหาที่ไม่คำนึงถึงขนาดตัวพิมพ์ ให้ค้นหารายการทั้งหมดที่ขึ้นต้นด้วยตัวอักษร A:

Mysql SELECT * จากที่รับ RLIKE "^ a";

แสดงรายการที่ไม่ซ้ำทั้งหมด:

MySQL เลือกความแตกต่างจาก; mysql SELECT จากเรียงตาม DESC;

แสดงจำนวนแถวในตาราง:

Mysql เลือก COUNT(*) จาก ;

Mysql SELECT SUM(*) จาก ;

การลบคอลัมน์:

mysql แก้ไขคอลัมน์ดร็อปตาราง;

การเพิ่มคอลัมน์ลงในฐานข้อมูล:

ตารางแก้ไข mysql เพิ่มคอลัมน์ varchar (20);

การเปลี่ยนชื่อคอลัมน์:

mysql แก้ไขตารางเปลี่ยน varchar (50);

สร้างคอลัมน์ที่มีชื่อไม่ซ้ำกันเพื่อหลีกเลี่ยงชื่อที่ซ้ำกัน:

ตารางแก้ไข mysql เพิ่มเฉพาะ ();

การปรับขนาดคอลัมน์:

mysql แก้ไขตารางแก้ไข VARCHAR (3);

การลบคอลัมน์ออกจากตาราง:

mysql แก้ไขดัชนีการวางตาราง;

Mysql โหลดข้อมูล INFILE " /tmp/filename.csv " แทนที่ INTO TABLE FIELDS TERMINATED BY , , " LINES TERMINATED BY "n" (field1,field2,field3);

ผู้ใช้เซิร์ฟเวอร์ MySQL รหัสผ่าน - การเพิ่ม การเปลี่ยนผู้ใช้และรหัสผ่าน คอนโซล

การสร้างผู้ใช้ใหม่ - เชื่อมต่อกับเซิร์ฟเวอร์ MySQLในฐานะรูท, สลับไปที่ฐานข้อมูล, เพิ่มผู้ใช้, อัพเดตสิทธิ์:

# mysql -u root -p mysql ใช้ mysql; mysql INSERT INTO user (โฮสต์, ผู้ใช้, รหัสผ่าน) VALUES("%,” ชื่อผู้ใช้ ", รหัสผ่าน (" รหัสผ่าน ")); สิทธิ์ล้างข้อมูล mysql;

เปลี่ยนรหัสผ่านผู้ใช้จากคอนโซลบนรีโมตโฮสต์ db1.example.org:

# mysqladmin -u ชื่อผู้ใช้ -h db1.example.org -p รหัสผ่าน "รหัสผ่านใหม่"

เปลี่ยนรหัสผ่านผู้ใช้จากคอนโซล MySQL- เชื่อมต่อในฐานะรูท อัปเดตรหัสผ่าน อัปเดตสิทธิ์:

# mysql -u root -p mysql ตั้งรหัสผ่านสำหรับ " ผู้ใช้ "@" ชื่อโฮสต์ " = รหัสผ่าน (" รหัสผ่านที่นี่ "); สิทธิ์ล้างข้อมูล mysql;

การกู้คืน/การเปลี่ยนรหัสผ่านเซิร์ฟเวอร์รูท MySQL- หยุด MySQL, เริ่มต้นโดยไม่มีตารางสิทธิ์, เชื่อมต่อในฐานะรูท, ตั้งรหัสผ่านใหม่, ออกและรีสตาร์ท MySQL.

# /etc/init.d/mysql หยุด # mysqld_safe -skip-grant-tables & # mysql -u root mysql ใช้ mysql; mysql อัพเดตชุดผู้ใช้รหัสผ่าน = PASSWORD (" newrootpassword ") โดยที่ User = "root"; mysql; สิทธิพิเศษฟลัช; mysql ออกจาก # /etc/init.d/mysql หยุด # /etc/init.d/mysql เริ่มต้น

ตั้งรหัสผ่านรูทหากมีรหัสผ่านรูท

# mysqladmin -u รหัสผ่านรูท รหัสผ่านใหม่

อัปเดตรหัสผ่านรูท:

# mysqladmin -u root -p oldpassword รหัสผ่านใหม่

การตั้งค่าสิทธิ์ในการเชื่อมต่อกับเซิร์ฟเวอร์จากโฮสต์ localhost ด้วยรหัสผ่าน "passwd" - การเชื่อมต่อรูทย่อย, สลับไปที่ฐานข้อมูล, การตั้งค่าสิทธิ์, การอัปเดตสิทธิ์:

# mysql -u root -p mysql ใช้ mysql; mysql ให้สิทธิ์การใช้งานบน *.* ให้กับ bob @localhost ที่ระบุโดย " passwd "; สิทธิ์ล้างข้อมูล mysql;

การตั้งค่าสิทธิ์สำหรับผู้ใช้เพื่อใช้ฐานข้อมูล - การเชื่อมต่อเป็นรูท, สลับไปยังฐานข้อมูล, การตั้งค่าสิทธิ์, การอัปเดตสิทธิ์:

# mysql -u root -p mysql ใช้ mysql; mysql INSERT INTO db (โฮสต์,Db,ผู้ใช้,Select_priv,Insert_priv,Update_priv,Delete_priv,Create_priv,Drop_priv) ค่า ("%", "ชื่อฐานข้อมูล", "ชื่อผู้ใช้", "Y", "Y", "Y" ย"ย"น"); สิทธิ์ล้างข้อมูล mysql;

Mysql ให้สิทธิ์ทั้งหมดบนชื่อฐานข้อมูล .* ให้กับชื่อผู้ใช้ @localhost; สิทธิ์ล้างข้อมูล mysql;

อัพเดตข้อมูลในฐานข้อมูล:

ชุดอัปเดต Mysql Select_priv = "Y",Insert_priv = "Y",Update_priv = "Y" โดยที่ = user";

การลบแถวในตาราง:

Mysql ลบจากที่ไหน = "อะไรก็ตาม";

การอัพเดตสิทธิ์ในฐานข้อมูล:

สิทธิ์ล้างข้อมูล mysql;

การสำรองข้อมูล - การสร้างการคืนค่าฐานข้อมูล คอนโซล

สร้างสำเนาสำรอง (ดัมพ์) ของฐานข้อมูลทั้งหมดไปยังไฟล์ alldatabases.sql:

# mysqldump -u root -p รหัสผ่าน -opt ; /tmp/alldatabases.sql

สำรองหนึ่งฐานข้อมูลไปยังไฟล์databasename.sql:

# mysql dump -u ชื่อผู้ใช้ -p รหัสผ่าน - ฐานข้อมูล ชื่อฐานข้อมูล ; /tmp/databasename.sql

สำรองข้อมูลหนึ่งตารางไปยังไฟล์databasename.tablename.sql:

# mysql dump -c -u ชื่อผู้ใช้ -p รหัสผ่าน ชื่อฐานข้อมูล ชื่อตาราง ; /tmp/databasename.tablename.sql

การคืนค่าฐานข้อมูล (หรือตาราง) จากการสำรองข้อมูล:

# mysql -u ชื่อผู้ใช้ -p รหัสผ่าน ชื่อฐานข้อมูล< /tmp/databasename.sql

การสร้างตารางฐานข้อมูล คอนโซล

ตัวอักษรตัวเล็กระบุชื่อของคอลัมน์
ตัวอักษรพิมพ์ใหญ่ - ประเภทและคุณลักษณะของคอลัมน์
ใน (วงเล็บ) - ค่าของประเภทคอลัมน์

สร้างตารางตัวอย่างที่ 1:

mysql CREATE TABLE (ชื่อ VARCHAR(20), ชื่อย่อตรงกลาง VARCHAR(3), นามสกุล VARCHAR(35), ส่วนต่อท้าย VARCHAR(3), officeid VARCHAR(10), ID ผู้ใช้ VARCHAR(15), ชื่อผู้ใช้ VARCHAR(8), อีเมล VARCHAR(35) ) ), โทรศัพท์ VARCHAR(25), กลุ่ม VARCHAR(15), ประทับวันที่ DATE, ประทับเวลา TIME, pgpemail VARCHAR (255));

สร้างตารางตัวอย่างที่ 2:

Mysql สร้างตาราง (personid INT (50) ไม่ใช่ NULL AUTO_INTCREMENT คีย์หลัก, ชื่อ VARCHAR (35), ชื่อกลาง VARCHAR (50), นามสกุล VARCHAR (50) ค่าเริ่มต้น "bato");

ยูทิลิตีบรรทัดคำสั่ง mysql เป็น wrapper SQL แบบธรรมดา (พร้อมความสามารถของไลบรารี readline ของโครงการ GNU) รองรับโหมดโต้ตอบและแบบไม่โต้ตอบ ในโหมดโต้ตอบ ผลลัพธ์ของการสืบค้นจะแสดงในรูปแบบ ASCII เมื่อใช้ในโหมดที่ไม่โต้ตอบ (เช่น เป็นตัวกรอง) ผลลัพธ์จะแสดงในรูปแบบข้อความโดยมีอักขระแท็บเป็นตัวคั่น (รูปแบบเอาต์พุตสามารถเปลี่ยนแปลงได้โดยใช้ตัวเลือกบรรทัดคำสั่ง) สคริปต์สามารถรันได้ดังแสดงด้านล่าง:

เชลล์ > ฐานข้อมูล mysql output.tab

หากคุณประสบปัญหาเนื่องจากหน่วยความจำไม่เพียงพอในไคลเอนต์ ให้ใช้ตัวเลือก --quick! สิ่งนี้จะทำให้ mysql ใช้ฟังก์ชัน mysql_use_result() แทนฟังก์ชัน mysql_store_result() เพื่อรับผลลัพธ์การดึงข้อมูล

การใช้ mysql เป็นเรื่องง่ายมาก เรียกใช้ฐานข้อมูล mysql หรือ mysql --user=user_name --password=ฐานข้อมูล your_password พิมพ์คำสั่ง SQL โดยตรงบนบรรทัดคำสั่ง โดยลงท้ายด้วยอักขระตัวใดตัวหนึ่งต่อไปนี้: `;" , `\g" หรือ `\G" จากนั้นกดปุ่ม ``Enter"'

ยูทิลิตี้บรรทัดคำสั่ง mysql รองรับตัวเลือกต่อไปนี้:

Help แสดงข้อมูลช่วยเหลือเกี่ยวกับการใช้โปรแกรมและออกจากโปรแกรม -A, --no-auto-rehash ปิดใช้งานการแฮชอัตโนมัติอีกครั้ง ควรใช้การแฮชใหม่เพื่อรับแฮชของตารางและฟิลด์ ทำให้ mysql เริ่มต้นเร็วขึ้น --prompt=... ตั้งค่าพรอมต์คำสั่งในรูปแบบที่ระบุ -b, --no-beep ปิดเสียงบี๊บแสดงข้อผิดพลาด -B, --batch เอาต์พุตแบทช์พร้อมตัวคั่นแท็บ แต่ละบรรทัดขึ้นบรรทัดใหม่ ไม่ได้ใช้ไฟล์ประวัติ --Character-sets-dir=... ไดเร็กทอรีที่มีชุดอักขระอยู่ -C, --compress ใช้การบีบอัดข้อมูลโปรโตคอลเซิร์ฟเวอร์/ไคลเอนต์ -#, --debug[=...] บันทึกการแก้ไขข้อบกพร่อง ค่าเริ่มต้นคือ "d:t:o,/tmp/mysql.trace" -D, --database=... ชื่อของฐานข้อมูลที่จะใช้ ส่วนใหญ่ใช้ในไฟล์กำหนดค่า `my.cnf" --default-Character-set=... ตั้งค่าชุดอักขระเริ่มต้น -e, --execute=... --batch) -E, --vertical Print ผลลัพธ์การสืบค้น (สตริง) ในแนวตั้งคุณสามารถสร้างเอาต์พุตเช่นนี้ได้โดยไม่ต้องใช้ตัวเลือกนี้โดยการสิ้นสุดคำสั่งด้วยอักขระ \G -f, --force ดำเนินการประมวลผลต่อไปแม้ว่าจะพบข้อผิดพลาด SQL -g, --no-named-commands ปิดคำสั่งที่มีชื่อ ใช้เฉพาะคำสั่ง \* หรือใช้คำสั่งที่มีชื่อเฉพาะที่จุดเริ่มต้นของบรรทัดที่ลงท้ายด้วย `;" . ตั้งแต่เวอร์ชัน 10.9 ไคลเอนต์เริ่มต้นด้วยตัวเลือกนี้ รวมอยู่ด้วย ค่าเริ่มต้น! ด้วยตัวเลือก -g คำสั่งแบบยาวยังคงใช้งานได้ตั้งแต่บรรทัดแรก -G, --enable-named-commands เปิดใช้งานคำสั่งที่มีชื่อ อนุญาตให้ใช้คำสั่งแบบยาวได้ เช่นเดียวกับคำสั่งแบบย่อ เช่น \* -i, --ignore-space ละเว้นช่องว่างหลังชื่อฟังก์ชัน -h, --host=... เชื่อมต่อกับฐานข้อมูลบนโฮสต์ที่ระบุ -H, --html พิมพ์เอาต์พุตเป็น HTML -L, --skip-line-number ข้ามหมายเลขบรรทัดเพื่อดูข้อผิดพลาด มีประโยชน์สำหรับการเปรียบเทียบไฟล์ผลลัพธ์ที่มีข้อความแสดงข้อผิดพลาด --no-pager ปิดการใช้งานเพจเจอร์และเขียนผลลัพธ์ไปที่ stdout (บน Unix) ดูเพิ่มเติมที่คำสั่ง \h (วิธีใช้ออนไลน์) --no-tee ล็อคไฟล์เอาต์พุต ดูเพิ่มเติมที่คำสั่ง \h (วิธีใช้ออนไลน์) -n, --unbuffered ล้างบัฟเฟอร์หลังจากการร้องขอแต่ละครั้ง -N, --skip-column-names ข้ามชื่อคอลัมน์ในผลลัพธ์ -O, --set-variable var=option ตั้งค่าของตัวแปร รายการตัวแปรที่ใช้จะแสดงผ่าน --help -o, --one-database อัพเดตเฉพาะฐานข้อมูลเริ่มต้นเท่านั้น ช่วยให้คุณสามารถข้ามการอัพเดตฐานข้อมูลอื่นๆ ในบันทึกการอัพเดตได้ --pager[=...] ตั้งค่าชนิดข้อมูลเอาต์พุต โดยดีฟอลต์ นี่คือตัวแปรสภาพแวดล้อม PAGER ค่าที่เป็นไปได้คือน้อยกว่า, มากกว่า, cat [> ชื่อไฟล์] ฯลฯ ดูเพิ่มเติมที่คำสั่ง \h (วิธีใช้ออนไลน์) ตัวเลือกนี้ใช้ไม่ได้ในโหมดแบทช์ เพจเจอร์ทำงานภายใต้ Unix เท่านั้น -p, --password[=...] รหัสผ่านที่ใช้เมื่อเชื่อมต่อกับเซิร์ฟเวอร์ฐานข้อมูล หากไม่ได้ระบุรหัสผ่านในบรรทัดคำสั่ง ระบบจะขอรหัสผ่านจากผู้ใช้ เมื่อใช้รูปแบบสั้น -p อย่าเว้นช่องว่างระหว่างพารามิเตอร์และค่ารหัสผ่าน -P --port=... หมายเลขพอร์ต TCP/IP ที่จะใช้สำหรับการเชื่อมต่อ -q, --quick อย่าแคชผลลัพธ์ ส่งออกทีละบรรทัดเมื่อมาจากเซิร์ฟเวอร์ ซึ่งอาจทำให้เซิร์ฟเวอร์ช้าลงหากเอาต์พุตหยุดชั่วคราว ไม่ได้ใช้ไฟล์ประวัติ -r, --raw แสดงค่าคอลัมน์โดยไม่มีการเปลี่ยนแปลงใดๆ ใช้กับ --batch -s, --silent โหมดเงียบ แสดงเฉพาะข้อความแสดงข้อผิดพลาด -S --socket=... ไฟล์ซ็อกเก็ตที่ใช้สำหรับการเชื่อมต่อ -t --table แสดงผลลัพธ์ในรูปแบบตาราง ตั้งค่าเริ่มต้นสำหรับโหมดที่ไม่ใช่แบตช์ -T, --debug-info พิมพ์ข้อมูลการดีบักบางส่วนเมื่อโปรแกรมออก --tee=... แนบบางสิ่งเข้ากับไฟล์เอาต์พุต ดูเพิ่มเติมที่คำสั่ง \h (วิธีใช้ออนไลน์) ตัวเลือกนี้ใช้ไม่ได้ในโหมดแบทช์ -u, --user=# ชื่อผู้ใช้ MySQL หากผู้ใช้รายนี้ไม่ได้ใช้งานอยู่ในปัจจุบัน -U, --safe-updates[=#], --i-am-a-dummy[=#] อนุญาตเฉพาะการดำเนินการ UPDATE และ DELETE โดยใช้คีย์เท่านั้น ดูด้านล่างสำหรับข้อมูลเพิ่มเติมเกี่ยวกับการตั้งค่านี้ คุณสามารถรีเซ็ตตัวเลือกนี้ได้โดยตั้งค่าอาร์กิวเมนต์ --safe-updates=0 ในไฟล์กำหนดค่า `my.cnf' -v, --verbose โหมดเอาต์พุต verbose เพิ่มเติม (-v -v -v ให้รูปแบบเอาต์พุตตาราง) - V , --version แสดงข้อมูลเวอร์ชันและออกจากโปรแกรม -w, --wait หากการเชื่อมต่อกับเซิร์ฟเวอร์หลุด ให้รอแล้วลองกู้คืนแทนการยกเลิก

คุณยังสามารถตั้งค่าตัวแปรต่อไปนี้ผ่านตัวเลือกบรรทัดคำสั่ง -O หรือ --set-variable:

หากคุณพิมพ์ help บนบรรทัดคำสั่ง โปรแกรม mysql จะแสดงรายการคำสั่งที่รองรับ:

Mysql> help MySQL Commands help (\h) แสดงข้อความที่กำหนด ? (\h) คำพ้องความหมายเพื่อขอความช่วยเหลือ clear (\c) คำสั่งเคลียร์ เชื่อมต่อ (\r) เชื่อมต่อกับเซิร์ฟเวอร์อีกครั้ง อาร์กิวเมนต์เพิ่มเติมคือ db และโฮสต์ แก้ไข (\e) แก้ไขคำสั่งปัจจุบันด้วย $EDITOR อัตตา (\G) ส่งคำสั่ง MySQL ปัจจุบันไปยังเซิร์ฟเวอร์และแสดงผลในแนวตั้ง exit (\q) ออกจากโปรแกรม เหมือนกับเลิกเลย go (\g) ส่งคำสั่ง MySQL ปัจจุบันไปยังเซิร์ฟเวอร์ nopager (\n) บล็อกเพจเจอร์ พิมพ์ไปที่ stdout notee (\t) อย่าเพิ่มรายการลงในไฟล์เอาท์พุต เพจเจอร์ (\P) ตั้งค่า PAGER แสดงผลลัพธ์การค้นหาผ่าน PAGER พิมพ์ (\p) พิมพ์คำสั่งปัจจุบัน prompt (\R) เปลี่ยนรูปแบบ prompt สำหรับคำสั่ง mysql exit (\q) ออกจากโปรแกรม rehash (\#) คืนค่าตารางแฮช แหล่งที่มา (\.) เรียกใช้งานไฟล์สคริปต์ SQL ระบุชื่อไฟล์เป็นอาร์กิวเมนต์ สถานะ (\s) รับข้อมูลสถานะเซิร์ฟเวอร์ tee (\T) ตั้งค่าตัวเลือก outfile ผนวกบางสิ่งเข้ากับไฟล์เอาต์พุตที่กำหนด ใช้ (\u) ใช้ฐานข้อมูลอื่น ระบุชื่อฐานข้อมูลเป็นอาร์กิวเมนต์

คำสั่งเพจเจอร์ทำงานบน Unix เท่านั้น

ผลลัพธ์ของสิ่งนี้คือ:

ไม่อนุญาตให้ดำเนินการคำสั่ง UPDATE หรือ DELETE เว้นแต่จะระบุข้อจำกัดที่สำคัญไว้ในส่วนคำสั่ง WHERE อย่างไรก็ตาม คุณสามารถบังคับให้ดำเนินการคำสั่ง UPDATE / DELETE ได้โดยใช้คำสั่ง LIMIT: UPDATE table_name SET not_key_column=# WHERE not_key_column=# LIMIT 1;
ผลลัพธ์ขนาดใหญ่ทั้งหมดจำกัดไว้ที่ #select_limit# บรรทัด
SELECT ที่อาจต้องใช้ชุดค่าผสมแถวมากกว่า #max_join_size# ในการดำเนินการจะถูกยกเลิก

เคล็ดลับที่เป็นประโยชน์สำหรับการใช้ไคลเอนต์ mysql:

ข้อมูลบางอย่างสามารถอ่านได้ง่ายขึ้นเมื่อแสดงในแนวตั้ง แทนที่จะเป็นหน้าต่างเอาต์พุตแนวนอนที่ใช้กันทั่วไป ตัวอย่างเช่น ข้อความที่ยาวกว่าความกว้างและมีการขึ้นบรรทัดใหม่จำนวนมากมักจะอ่านในแนวตั้งได้ง่ายกว่ามาก

Mysql> SELECT * FROM mails WHERE LENGTH(txt) sbj: UTF-8 txt: >>>>> "Thimble" == Thimble Smith เขียนว่า: Thimble> สวัสดี ฉันคิดว่านี่เป็นความคิดที่ดี มีใครคุ้นเคยกับ UTF-8 Thimble> หรือ Unicode บ้างไหม? มิฉะนั้น ฉันจะใส่สิ่งนี้ลงในรายการสิ่งที่ต้องทำของฉันและดูว่า Thimble> เกิดอะไรขึ้น ใช่ โปรดทำเช่นนั้น ขอแสดงความนับถือ ไฟล์ Monty: inbox-jani-1 hash: 190402944 1 แถวในชุด (0.09 วินาที)

คุณสามารถใช้ตัวเลือกคำสั่ง tee เพื่อเข้าสู่ระบบ สามารถรันด้วยตัวเลือก --tee=... ไปยัง mysql หรือโต้ตอบจากบรรทัดคำสั่งด้วยคำสั่ง tee ข้อมูลทั้งหมดที่แสดงบนหน้าจอจะถูกเพิ่มไปยังไฟล์ที่ระบุด้วย สิ่งนี้มีประโยชน์มากสำหรับวัตถุประสงค์ในการดีบักโปรแกรม ยูทิลิตีทีสามารถบล็อกได้จากบรรทัดคำสั่งด้วยคำสั่ง notee การรันคำสั่ง tee อีกครั้งจะเป็นการเปิดใช้งานการบันทึกอีกครั้ง หากไม่ได้ระบุพารามิเตอร์สำหรับคำสั่ง tee ไฟล์ก่อนหน้าจะถูกนำมาใช้ โปรดทราบว่าคำสั่ง tee จะเขียนผลลัพธ์ลงในไฟล์หลังจากแต่ละคำสั่งดำเนินการ ก่อนที่พร้อมท์คำสั่งจะปรากฏขึ้นสำหรับคำสั่งถัดไป
ตัวเลือก --pager[=...] ทำให้สามารถดูหรือค้นหาผลลัพธ์แบบโต้ตอบกับโปรแกรม Unix less , more หรือคล้ายกันได้ หากคุณไม่ได้ระบุอาร์กิวเมนต์อย่างชัดเจนในพารามิเตอร์นี้ ไคลเอ็นต์ mysql จะค้นหาตัวแปรสภาพแวดล้อม PAGER และตั้งค่าเป็น pager โปรแกรมเพจเจอร์ยังสามารถสตาร์ทจากบรรทัดรับคำสั่งแบบโต้ตอบด้วยคำสั่งเพจเจอร์ และหยุดด้วยคำสั่ง nopager คำสั่งสามารถรับอาร์กิวเมนต์ซึ่งเป็นทางเลือก เพจเจอร์จะถูกตั้งค่าเป็นค่าของอาร์กิวเมนต์นี้ คำสั่งเพจเจอร์สามารถเรียกได้โดยไม่ต้องใช้อาร์กิวเมนต์ แต่ต้องใช้ตัวเลือก --pager หรือการตั้งค่าเริ่มต้นที่เหมาะสมของ stdout คำสั่งเพจเจอร์ใช้งานได้บน Unix เท่านั้น เนื่องจากใช้ฟังก์ชัน popen() ซึ่งไม่มีใน Windows บน Windows คุณสามารถใช้ตัวเลือกทีแทนได้ แม้ว่าในบางสถานการณ์จะสะดวกน้อยกว่าการใช้คำสั่งเพจเจอร์ก็ตาม
เคล็ดลับเล็กๆ น้อยๆ เกี่ยวกับคำสั่งเพจเจอร์: สามารถใช้เพื่อเขียนลงในไฟล์ได้: mysql> pager cat > /tmp/log.txt และผลลัพธ์จะถูกส่งไปยังไฟล์เท่านั้น โปรแกรมที่ถูกเรียกโดยคำสั่งเพจเจอร์สามารถยอมรับอ็อพชันที่ถูกต้องได้: mysql> pager less -n -i -S ให้ความสนใจเป็นพิเศษกับอ็อพชัน -S ในตัวอย่างข้างต้น จะมีประโยชน์มากเมื่อดูผลลัพธ์ ลองใช้เอาต์พุตแนวนอน (สิ้นสุดคำสั่งด้วย "\g" หรือ ";") และเอาต์พุตแนวตั้ง (ที่ท้ายคำสั่งด้วย "\G") ผลลัพธ์เอาต์พุตที่ยุ่งยากมากบางครั้งอาจอ่านจากหน้าจอได้ยาก ในกรณีนี้ คำสั่งที่น้อยกว่าด้วยตัวเลือก -S จะทำให้คุณสามารถดูผลลัพธ์แบบโต้ตอบจากซ้ายไปขวา ในขณะที่บรรทัดที่มีความยาวยาวกว่าความกว้างของหน้าจอ ปรากฏขึ้น ผลลัพธ์จะดำเนินต่อไปในบรรทัดใหม่ ข้อมูลเอาต์พุตในกรณีดังกล่าวสามารถอ่านได้มากขึ้น เมื่อเรียกใช้คำสั่ง less แบบโต้ตอบด้วยตัวเลือก "-S" คุณสามารถสลับโหมดการทำงาน (เปิด/ปิดใช้งาน) จากบรรทัดคำสั่งได้ สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ Less โปรดดูคำอธิบายของคำสั่ง "h"
โดยสรุป เราทราบ (หากคุณยังไม่เข้าใจสิ่งนี้จากตัวอย่างก่อนหน้านี้) ว่ามันเป็นไปได้ที่จะรวมวิธีการประมวลผลผลลัพธ์ที่ซับซ้อนมากเข้าด้วยกัน ดังนั้น ในตัวอย่างต่อไปนี้ ผลลัพธ์จะถูกส่งไปยังไดเร็กทอรีที่แตกต่างกันสองไดเร็กทอรีที่ติดตั้งบนฮาร์ดไดรฟ์สองตัวภายใต้ /dr1 และ /dr2 แต่ยังสามารถดูผลลัพธ์ได้บนหน้าจอด้วยคำสั่ง less: mysql> pager cat | ที /dr1/tmp/res.txt | \ tee /dr2/tmp/res2.txt | น้อยกว่า -n -i -S
ฟังก์ชั่นข้างต้นสามารถรวมกันได้: ด้วยการรัน tee และการตั้งค่าเพจเจอร์เป็น less คุณสามารถดูผลลัพธ์ด้วยคำสั่ง less Unix และยังคงเขียนลงไฟล์ได้ ความแตกต่างระหว่าง tee ยูทิลิตี้ Unix ที่ใช้โดยโปรแกรมเพจเจอร์และคำสั่ง tee ในตัวในไคลเอนต์ mysql ก็คือคำสั่ง tee ในตัวทำงานได้แม้ว่ายูทิลิตี้ tee จะไม่พร้อมใช้งานบน Unix ก็ตาม tee บิวด์อินยังบันทึกทุกสิ่งที่แสดงบนหน้าจอ ในขณะที่ยูทิลิตี้ Unix tee ที่ใช้กับเพจเจอร์ไม่ได้ทำอะไรมากนัก สุดท้ายแต่ไม่ท้ายสุด คำสั่ง tee แบบโต้ตอบจะสะดวกกว่าสำหรับการสลับโหมดเปิด/ปิดการทำงาน หากคุณจำเป็นต้องปิดใช้งานคุณสมบัตินี้ในบางครั้งเมื่อเขียนลงไฟล์

คุณสามารถเปลี่ยนรูปแบบพรอมต์บนบรรทัดคำสั่งไคลเอนต์ mysql

มีตัวเลือกพร้อมท์ต่อไปนี้:

ตัวเลือก	คำอธิบาย
\v	เวอร์ชัน mysql
\d	ชื่อของฐานข้อมูลที่จะใช้
\ชม	ชื่อโฮสต์ที่จะเชื่อมต่อ
\พี	หมายเลขพอร์ตที่ใช้เชื่อมต่อ
\ยู	ชื่อผู้ใช้
\ยู	ที่อยู่แบบเต็มชื่อผู้ใช้@โฮสต์
\\	แบ็กสแลช `\"
\n	อักขระขึ้นบรรทัดใหม่
\t	แท็บหยุด
\	ช่องว่าง
\_	ช่องว่างที่มีขีดล่าง
\อาร์	เขตเวลาทางการทหาร (0-23)
\r	เวลาตามโซนเวลามาตรฐาน (1-12)
\m	นาที
\y	สองหลักของปี
\วาย	สี่หลักของปี
\D	รูปแบบวันที่เต็ม
\s	วินาที
\w	วันในสัปดาห์ในรูปแบบตัวอักษรสามตัว (จันทร์ อังคาร ...)
\พี	เช้า/บ่าย (เช้า/บ่าย)
\o	เดือนในรูปแบบตัวเลข
\โอ	เดือนในรูปแบบตัวอักษรสามตัว (ม.ค., ก.พ., ...)
\ค	ตัวนับที่นับจำนวนคำสั่งที่ป้อน

`\" ตามด้วยตัวอักษรอื่นๆ เพียงเติมตัวอักษรนั้นให้สมบูรณ์

คุณสามารถตั้งค่าตัวเลือกพรอมต์ได้ด้วยวิธีต่อไปนี้:

ในตัวแปรสภาพแวดล้อมคุณสามารถตั้งค่าตัวแปรสภาพแวดล้อม MYSQL_PS1 สำหรับสตริงพร้อมท์ได้ ตัวอย่างเช่น: เชลล์> ส่งออก MYSQL_PS1="(\u@\h) [\d]> " `my.cnf' `.my.cnf"คุณสามารถตั้งค่าตัวเลือกพรอมต์ในไฟล์การกำหนดค่า MySQL ใดก็ได้ภายใต้กลุ่ม mysql ตัวอย่างเช่น: prompt=(\u@\h) [\d]>\_ บนบรรทัดคำสั่งคุณสามารถตั้งค่าตัวเลือก --prompt ได้จากบรรทัดคำสั่ง mysql ตัวอย่างเช่น: เชลล์> mysql --prompt="(\u@\h) [\d]> " (user@host) > เชิงโต้ตอบคุณยังสามารถใช้คำสั่งพร้อมท์ (หรือ \R) เพื่อเปลี่ยนการตั้งค่าพร้อมท์แบบโต้ตอบได้ ตัวอย่างเช่น: mysql> prompt (\u@\h) [\d]>\_ PROMPT ตั้งค่าเป็น "(\u@\h) [\d]>\_" (user@host) > (user@host) > prompt กลับสู่การตั้งค่า PROMPT ดั้งเดิม (ค่าเริ่มต้น) ในยูทิลิตี้ mysql> mysql>

หมวดหมู่

ตัวเลือกของบรรณาธิการ