ElasticSearch Full-text Search สร้างระบบค้นหาอัจฉริยะ

ในยุคดิจิทัลที่ข้อมูลหลั่งไหลไม่หยุดยั้ง การเข้าถึงและค้นหาข้อมูลที่ต้องการได้อย่างรวดเร็วและแม่นยำไม่ใช่แค่ความสะดวกสบายอีกต่อไป แต่เป็นหัวใจสำคัญที่ขับเคลื่อนความสำเร็จของธุรกิจและสร้างประสบการณ์ผู้ใช้ที่ยอดเยี่ยม ไม่ว่าจะเป็นเว็บไซต์อีคอมเมิร์ซ, แพลตฟอร์มข่าวสาร, หรือแม้แต่ระบบจัดการเอกสารภายในองค์กร ระบบค้นหาอัจฉริยะคือสิ่งที่จะยกระดับการโต้ตอบของผู้ใช้กับข้อมูลให้ก้าวไปอีกขั้น และเมื่อพูดถึงการสร้างระบบค้นหาแบบเต็มข้อความ (Full-text Search) ที่ทรงพลังและปรับขนาดได้ ชื่อของ Elasticsearch มักจะถูกกล่าวถึงเป็นอันดับต้น ๆ เสมอครับ บทความนี้จะพาทุกท่านดำดิ่งสู่โลกของ Elasticsearch เพื่อทำความเข้าใจว่าเครื่องมือนี้ทำงานอย่างไร และจะช่วยให้คุณสร้างระบบค้นหาที่ “เข้าใจ” ความต้องการของผู้ใช้ได้อย่างแท้จริงได้อย่างไรบ้างครับ

สารบัญ

• ทำความรู้จักกับ Full-text Search และปัญหาของการค้นหาแบบเดิม
  • Full-text Search คืออะไร?
  • ข้อจำกัดของการค้นหาแบบเดิมในฐานข้อมูลเชิงสัมพันธ์ (RDBMS)
• Elasticsearch คืออะไร? ทำไมต้องเป็น Elasticsearch?
  • ภาพรวมของ Elasticsearch
  • ทำไมต้องเลือก Elasticsearch?
• สถาปัตยกรรมและแนวคิดพื้นฐานของ Elasticsearch
  • แนวคิดหลักที่ควรรู้
  • การทำงานเบื้องหลัง: Inverted Index
• การติดตั้งและเริ่มต้นใช้งาน Elasticsearch เบื้องต้น
• การนำเข้าข้อมูล (Indexing) สู่ Elasticsearch สำหรับ Full-text Search
  • Mapping: การกำหนดโครงสร้างข้อมูล
  • Analyzer: หัวใจของการค้นหาภาษาไทย
  • การนำเข้าเอกสาร (Indexing Documents)
• สร้างระบบค้นหา Full-text Search อัจฉริยะด้วย Elasticsearch Query DSL
  • ประเภทของ Query ที่สำคัญ
  • Relevance Scoring: การจัดอันดับความเกี่ยวข้อง
  • Highlighting: เน้นคำที่ค้นพบ
  • ตัวอย่างโค้ดการค้นหา
• การปรับแต่งและเพิ่มประสิทธิภาพการค้นหา (Advanced Features)
  • การสร้าง Custom Analyzer และ Thai Analyzer
  • Synonyms และ Stopwords
  • Aggregations: การวิเคราะห์ข้อมูลเชิงลึก
  • Suggesters: ระบบแนะนำคำค้นหาและ Autocomplete
• การจัดการข้อมูลและการปรับขนาด (Data Management & Scaling)
  • การอัปเดตและลบเอกสาร
  • การจัดการ Index
  • กลยุทธ์การปรับขนาด (Scaling)
• เปรียบเทียบ Elasticsearch กับ Solr และ RDBMS
• คำถามที่พบบ่อย (FAQ)
• สรุปและ Call-to-Action

ทำความรู้จักกับ Full-text Search และปัญหาของการค้นหาแบบเดิม

Full-text Search คืออะไร?

Full-text Search หรือการค้นหาแบบเต็มข้อความ เป็นวิธีการค้นหาที่ช่วยให้ผู้ใช้สามารถค้นหาคำหรือวลีใด ๆ ก็ตามที่ปรากฏอยู่ในเอกสารหรือชุดข้อมูลขนาดใหญ่ โดยไม่จำเป็นต้องระบุตำแหน่งที่แน่นอนของคำนั้น ๆ ในฐานข้อมูลเหมือนการค้นหาแบบดั้งเดิมครับ เป้าหมายหลักคือการค้นหาข้อมูลที่ “เกี่ยวข้อง” กับคำค้นหาของผู้ใช้มากที่สุด ไม่ใช่แค่การจับคู่คำแบบเป๊ะ ๆ ครับ

ลองจินตนาการถึงระบบค้นหาบทความในเว็บไซต์ข่าวสาร หากคุณพิมพ์คำว่า “น้ำท่วม” ระบบ Full-text Search ไม่เพียงแต่จะหาบทความที่มีคำว่า “น้ำท่วม” เท่านั้น แต่ยังอาจหาบทความที่มีคำว่า “อุทกภัย”, “ภัยพิบัติทางน้ำ” หรือแม้แต่บทความที่กล่าวถึงผลกระทบจากน้ำท่วมโดยตรง แม้จะไม่มีคำว่า “น้ำท่วม” ปรากฏอยู่เลยก็ตามครับ นี่คือความฉลาดที่ระบบ Full-text Search มอบให้ครับ

ข้อจำกัดของการค้นหาแบบเดิมในฐานข้อมูลเชิงสัมพันธ์ (RDBMS)

หลายท่านอาจคุ้นเคยกับการใช้ฐานข้อมูลเชิงสัมพันธ์ (Relational Database Management System – RDBMS) อย่าง MySQL, PostgreSQL, หรือ SQL Server ในการเก็บข้อมูลและค้นหาข้อมูลครับ ซึ่ง RDBMS นั้นยอดเยี่ยมสำหรับการจัดการข้อมูลที่มีโครงสร้างชัดเจนและการดำเนินการกับข้อมูลเชิงสัมพันธ์ต่าง ๆ ครับ แต่เมื่อพูดถึง Full-text Search จะมีข้อจำกัดที่สำคัญหลายประการครับ:

• ประสิทธิภาพ (Performance): การใช้คำสั่ง `LIKE ‘%คำค้นหา%’` ใน SQL เพื่อค้นหาคำในคอลัมน์ที่เป็นข้อความขนาดใหญ่จะใช้เวลานานมากครับ โดยเฉพาะเมื่อข้อมูลมีจำนวนมหาศาล เพราะ RDBMS ต้องสแกนข้อมูลทั้งตารางเพื่อหาคำที่ตรงกัน ซึ่งไม่ได้ใช้ Index ได้อย่างมีประสิทธิภาพเท่าที่ควรสำหรับการค้นหาแบบเต็มข้อความครับ
• ความเกี่ยวข้อง (Relevance): RDBMS ไม่ได้ถูกออกแบบมาเพื่อคำนวณความเกี่ยวข้องของผลลัพธ์ครับ มันทำได้แค่บอกว่ามีคำนั้นอยู่หรือไม่ แต่ไม่สามารถจัดอันดับได้ว่าเอกสารใดมีความเกี่ยวข้องกับคำค้นหามากที่สุด หรือเอกสารใดควรจะถูกแสดงก่อนครับ
• ความยืดหยุ่น (Flexibility): RDBMS ไม่มีความสามารถในตัวสำหรับการจัดการกับภาษาธรรมชาติ เช่น การแยกคำ (tokenization), การตัดคำ (stemming), การจัดการคำพ้องความหมาย (synonyms), หรือการแก้ไขคำผิด (typo tolerance) ซึ่งเป็นสิ่งสำคัญสำหรับระบบ Full-text Search ที่ดีครับ
• การปรับขนาด (Scalability): การปรับขนาด RDBMS เพื่อรองรับปริมาณการค้นหาที่สูงมาก ๆ นั้นทำได้ยากและมีค่าใช้จ่ายสูงครับ

ด้วยเหตุผลเหล่านี้เอง จึงจำเป็นต้องมีเครื่องมือที่ออกแบบมาโดยเฉพาะสำหรับการค้นหาแบบเต็มข้อความ และนั่นคือที่มาของ Elasticsearch ครับ

Elasticsearch คืออะไร? ทำไมต้องเป็น Elasticsearch?

ภาพรวมของ Elasticsearch

Elasticsearch คือ Search Engine แบบ Distributed, RESTful ที่ถูกสร้างขึ้นบนไลบรารี Apache Lucene ครับ มันถูกออกแบบมาเพื่อจัดเก็บ, ค้นหา, และวิเคราะห์ข้อมูลจำนวนมากได้อย่างรวดเร็วและในแบบเรียลไทม์ครับ Elasticsearch เป็นส่วนหนึ่งของ Elastic Stack (หรือที่รู้จักกันในชื่อ ELK Stack ในอดีต) ซึ่งประกอบด้วย Elasticsearch (Search & Analytics Engine), Kibana (Visualization UI), Beats (Data Shippers) และ Logstash (Data Ingestion Pipeline) ครับ

คุณสมบัติหลักของ Elasticsearch คือความสามารถในการทำงานแบบกระจาย (Distributed) ซึ่งหมายความว่ามันสามารถทำงานบนเครื่องเซิร์ฟเวอร์หลายเครื่องพร้อมกันได้ ทำให้มีความสามารถในการปรับขนาด (Scalability) และความทนทานต่อความผิดพลาด (Fault Tolerance) สูงครับ นอกจากนี้ยังสื่อสารผ่าน RESTful API ทำให้ง่ายต่อการนำไปใช้งานร่วมกับแอปพลิเคชันต่าง ๆ ด้วยภาษาโปรแกรมที่หลากหลายครับ

ทำไมต้องเลือก Elasticsearch?

Elasticsearch กลายเป็นตัวเลือกยอดนิยมสำหรับการสร้างระบบค้นหาอัจฉริยะด้วยเหตุผลหลายประการครับ:

• ความเร็วสูง (Blazing Fast): ด้วยการใช้โครงสร้างข้อมูลแบบ Inverted Index ทำให้ Elasticsearch สามารถค้นหาและดึงข้อมูลที่เกี่ยวข้องได้อย่างรวดเร็วมากครับ แม้ข้อมูลจะมีขนาดใหญ่แค่ไหนก็ตาม
• ปรับขนาดได้ดีเยี่ยม (Highly Scalable): ถูกออกแบบมาให้ทำงานแบบ Distributed ตั้งแต่เริ่มต้น ทำให้สามารถเพิ่ม Node (เครื่องเซิร์ฟเวอร์) เข้าไปใน Cluster ได้อย่างง่ายดายเพื่อรองรับปริมาณข้อมูลและการค้นหาที่เพิ่มขึ้นครับ
• ความเกี่ยวข้องในการค้นหา (Relevance Ranking): มีอัลกอริทึมที่ซับซ้อนในการคำนวณคะแนนความเกี่ยวข้องของผลลัพธ์ (Relevance Score) ทำให้สามารถจัดอันดับเอกสารที่ตรงกับความต้องการของผู้ใช้มากที่สุดไว้ลำดับต้น ๆ ได้อย่างแม่นยำครับ
• Query DSL ที่ทรงพลัง (Powerful Query DSL): มีภาษาสำหรับ Query (Query Domain Specific Language) ที่ยืดหยุ่นและทรงพลังมากในรูปแบบ JSON ทำให้สามารถสร้างเงื่อนไขการค้นหาที่ซับซ้อนได้หลากหลาย ไม่ว่าจะเป็นการค้นหาแบบเต็มข้อความ, การค้นหาแบบ Phrase, Fuzzy Search (แก้ไขคำผิด), หรือ Boolean Query ครับ
• วิเคราะห์ข้อมูลเชิงลึก (Rich Analytics Capabilities): นอกจากความสามารถในการค้นหาแล้ว Elasticsearch ยังมี Aggregations ซึ่งเป็นฟังก์ชันที่ช่วยให้สามารถวิเคราะห์ข้อมูลในรูปแบบต่าง ๆ ได้อย่างรวดเร็ว เช่น การนับจำนวน, การหาค่าเฉลี่ย, การจัดกลุ่มข้อมูลตามหมวดหมู่ (Faceting) ซึ่งมีประโยชน์มากสำหรับการสร้าง Dashboard หรือระบบกรองข้อมูลครับ
• ใช้งานง่ายด้วย RESTful API: การสื่อสารกับ Elasticsearch ทำได้ผ่าน HTTP RESTful API ทำให้ง่ายต่อการผสานรวมกับแอปพลิเคชันและภาษาโปรแกรมที่หลากหลายครับ
• Real-time Operation: สามารถจัดทำดัชนี (Indexing) และค้นหาข้อมูลใหม่ ๆ ได้เกือบจะทันที ทำให้ข้อมูลที่ผู้ใช้เห็นนั้นเป็นข้อมูลที่อัปเดตล่าสุดอยู่เสมอครับ

ด้วยคุณสมบัติเหล่านี้ Elasticsearch จึงไม่ได้เป็นเพียงแค่ Search Engine แต่เป็นแพลตฟอร์มที่ครบวงจรสำหรับการจัดการข้อมูล ค้นหา และวิเคราะห์ข้อมูลแบบเรียลไทม์ครับ

สถาปัตยกรรมและแนวคิดพื้นฐานของ Elasticsearch

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

แนวคิดหลักที่ควรรู้

• Cluster: คือกลุ่มของ Node (เซิร์ฟเวอร์) หนึ่งตัวหรือมากกว่าที่ทำงานร่วมกันเพื่อจัดเก็บข้อมูลทั้งหมด และให้ความสามารถในการจัดทำดัชนีและการค้นหาแบบกระจายครับ Cluster จะมีชื่อเฉพาะ (เช่น `elasticsearch` โดยค่าเริ่มต้น) และ Node ทั้งหมดใน Cluster เดียวกันจะใช้ชื่อ Cluster เดียวกันครับ
• Node: คือเครื่องเซิร์ฟเวอร์เดี่ยว ๆ ที่รัน Elasticsearch Instance หนึ่งตัวครับ Node แต่ละตัวจะเก็บข้อมูลบางส่วนของ Cluster และมีส่วนร่วมในการจัดทำดัชนีและการค้นหาครับ Node มีหลายประเภท เช่น Master-eligible node, Data node, Ingest node, ML node เป็นต้น
• Index: เปรียบเสมือนฐานข้อมูล (Database) ใน RDBMS ครับ Index คือคอลเลกชันของ Document ที่เกี่ยวข้องกันครับ แต่ละ Index จะมีชื่อเฉพาะและถูกใช้ในการจัดเก็บข้อมูลประเภทเดียวกัน เช่น `products` index สำหรับสินค้า, `articles` index สำหรับบทความ เป็นต้นครับ
• Document: คือหน่วยข้อมูลพื้นฐานที่สุดใน Elasticsearch ครับ เปรียบเสมือนแถว (Row) ใน RDBMS หรือเอกสารใน MongoDB ครับ Document จะอยู่ในรูปแบบ JSON และเป็นหน่วยข้อมูลที่ถูกจัดทำดัชนีและค้นหาได้ครับ แต่ละ Document จะมี `_id` เฉพาะตัวภายใน Index นั้น ๆ ครับ
• Shard: เนื่องจาก Elasticsearch เป็นแบบ Distributed จึงต้องมีการแบ่งข้อมูลออกเป็นส่วนย่อย ๆ ครับ Shard คือส่วนย่อยของ Index ครับ Index หนึ่งสามารถถูกแบ่งออกเป็นหลาย Shard ได้ เพื่อให้สามารถจัดเก็บข้อมูลที่ใหญ่กว่าความจุของ Node เดี่ยว ๆ และเพื่อกระจายการทำงานข้าม Node ครับ
  • Primary Shard: Shard ต้นฉบับที่เก็บข้อมูลจริงครับ
  • Replica Shard: สำเนาของ Primary Shard ใช้สำหรับเพิ่มความทนทานต่อความผิดพลาด (Fault Tolerance) และเพิ่มประสิทธิภาพในการอ่าน (Read Scalability) ครับ หาก Primary Shard เกิดล่ม Replica Shard สามารถถูกโปรโมทให้เป็น Primary Shard ได้ครับ
• Mapping: คือการกำหนดโครงสร้างและประเภทของข้อมูล (Schema) สำหรับ Document ใน Index ครับ คล้ายกับการกำหนด Schema ใน RDBMS ครับ Mapping จะบอก Elasticsearch ว่าแต่ละ Field ใน Document ควรถูกจัดเก็บและจัดทำดัชนีอย่างไร เช่น Field `title` เป็น `text` เพื่อใช้ Full-text Search, Field `price` เป็น `float` สำหรับการคำนวณ เป็นต้นครับ

การทำงานเบื้องหลัง: Inverted Index

หัวใจสำคัญที่ทำให้ Elasticsearch ค้นหาข้อมูลได้รวดเร็วคือโครงสร้างข้อมูลที่เรียกว่า Inverted Index ครับ ซึ่งแตกต่างจาก Index แบบดั้งเดิมใน RDBMS ที่จะชี้จากแถวข้อมูลไปยังคำ ครับ

ลองนึกภาพสมุดโทรศัพท์แบบเดิม (Forward Index) ที่เรียงตามชื่อและมีเบอร์โทรศัพท์อยู่ข้าง ๆ หากต้องการหาเบอร์โทรศัพท์ของ “สมศักดิ์” ก็แค่พลิกไปที่ตัว “ส” และหาชื่อ “สมศักดิ์” ครับ แต่นั่นคือการค้นหาจากชื่อไปเบอร์โทรศัพท์

Inverted Index กลับกันครับ มันเหมือนกับ Index ท้ายเล่มหนังสือเรียน ที่จะลิสต์ “คำ” ต่าง ๆ ที่ปรากฏในหนังสือ และบอกว่าคำนั้น ๆ อยู่ในหน้าไหนบ้างครับ

ตัวอย่าง: สมมติเรามีเอกสาร 3 ฉบับดังนี้ครับ

• Document 1: “Elasticsearch คือเครื่องมือค้นหาที่ทรงพลัง”
• Document 2: “บทความนี้จะสอนการใช้งาน Elasticsearch”
• Document 3: “สร้างระบบค้นหาอัจฉริยะด้วย Elasticsearch”

เมื่อ Elasticsearch จัดทำดัชนี (Indexing) ข้อมูลเหล่านี้ มันจะทำการแยกคำ (tokenization) และสร้าง Inverted Index ขึ้นมาครับ (ในความเป็นจริงจะมีการประมวลผลคำที่ซับซ้อนกว่านี้ เช่น การแปลงเป็นคำฐาน)

คำ (Term)       | เอกสารที่ปรากฏ (Document IDs)
----------------|-------------------------------
Elasticsearch   | 1, 2, 3
คือ             | 1
เครื่องมือ      | 1
ค้นหา           | 1, 3
ที่             | 1
ทรงพลัง         | 1
บทความนี้       | 2
จะ             | 2
สอน            | 2
การใช้งาน       | 2
สร้าง           | 3
ระบบ            | 3
อัจฉริยะ        | 3
ด้วย            | 3

เมื่อผู้ใช้ค้นหาคำว่า “Elasticsearch” ระบบจะไปดูที่ Inverted Index และพบว่าคำนี้ปรากฏอยู่ใน Document 1, 2, และ 3 ทันที โดยไม่ต้องสแกนเนื้อหาของเอกสารทั้งหมดครับ ทำให้การค้นหาเป็นไปอย่างรวดเร็วมากครับ

นอกจากนี้ Inverted Index ยังเก็บข้อมูลอื่น ๆ ด้วย เช่น ตำแหน่งของคำในเอกสาร, ความถี่ของคำในเอกสารนั้น ๆ (Term Frequency), และความถี่ของคำใน Index ทั้งหมด (Document Frequency) ซึ่งข้อมูลเหล่านี้จะถูกนำไปใช้อัลกอริทึมในการคำนวณ Relevance Score เพื่อจัดอันดับผลลัพธ์ครับ

การติดตั้งและเริ่มต้นใช้งาน Elasticsearch เบื้องต้น

การติดตั้ง Elasticsearch นั้นค่อนข้างตรงไปตรงมาครับ โดยทั่วไปมีสองวิธีหลัก ๆ คือ ติดตั้งบนเครื่องของคุณเอง หรือใช้บริการ Managed Service อย่าง Elastic Cloud ครับ สำหรับบทความนี้เราจะเน้นไปที่การติดตั้งบนเครื่องของเราเองก่อนครับ

สิ่งที่ต้องเตรียม:

1. Java Development Kit (JDK): Elasticsearch ต้องการ Java Runtime Environment (JRE) ในการทำงานครับ โดยทั่วไปแนะนำให้ใช้ OpenJDK เวอร์ชันล่าสุดที่เข้ากันได้กับ Elasticsearch เวอร์ชันที่คุณเลือกครับ (ตรวจสอบได้จากเอกสารของ Elastic)

ขั้นตอนการติดตั้ง (แบบย่อ):

1. ดาวน์โหลด Elasticsearch: เข้าไปที่เว็บไซต์ทางการของ Elastic (elastic.co/downloads/elasticsearch) และดาวน์โหลดไฟล์สำหรับระบบปฏิบัติการของคุณ (เช่น .zip สำหรับ Windows, .tar.gz สำหรับ Linux/macOS)
2. แตกไฟล์: แตกไฟล์ที่ดาวน์โหลดมาไปยังตำแหน่งที่คุณต้องการครับ
3. รัน Elasticsearch:
   • เปิด Terminal/Command Prompt
   • เข้าไปยังไดเรกทอรี `bin` ภายใต้ไดเรกทอรีที่คุณแตกไฟล์ Elasticsearch
   • รันคำสั่ง:

     
     ./elasticsearch  # สำหรับ Linux/macOS
     elasticsearch.bat # สำหรับ Windows
                     

Elasticsearch จะเริ่มทำงานและรันอยู่บนพอร์ต 9200 โดยค่าเริ่มต้นครับ คุณสามารถทดสอบว่า Elasticsearch ทำงานอยู่หรือไม่โดยเปิดเว็บเบราว์เซอร์และเข้าไปที่ `http://localhost:9200` ครับ คุณควรจะเห็นการตอบกลับในรูปแบบ JSON ที่แสดงข้อมูลเกี่ยวกับ Cluster ของคุณครับ

{
  "name" : "your-node-name",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "...",
  "version" : {
    "number" : "8.x.x",
    "build_flavor" : "default",
    "build_type" : "zip",
    "build_hash" : "...",
    "build_date" : "...",
    "build_snapshot" : false,
    "lucene_version" : "...",
    "minimum_wire_compatibility_version" : "...",
    "minimum_index_compatibility_version" : "..."
  },
  "tagline" : "You Know, for Search"
}

เมื่อ Elasticsearch ทำงานแล้ว เราก็พร้อมที่จะนำเข้าข้อมูลและเริ่มสร้างระบบค้นหาของเราแล้วครับ

การนำเข้าข้อมูล (Indexing) สู่ Elasticsearch สำหรับ Full-text Search

ก่อนที่เราจะค้นหาข้อมูลได้ เราต้องนำข้อมูลเข้าไปใน Elasticsearch เสียก่อน กระบวนการนี้เรียกว่า “Indexing” ครับ การ Indexing ใน Elasticsearch ไม่ใช่แค่การบันทึกข้อมูล แต่ยังรวมถึงการประมวลผลข้อมูล (เช่น การแยกคำ) เพื่อให้พร้อมสำหรับการค้นหาแบบ Full-text Search ครับ

Mapping: การกำหนดโครงสร้างข้อมูล

Mapping คือ Schema ของ Index ครับ มันจะกำหนดว่าแต่ละ Field (ช่องข้อมูล) ใน Document จะถูกจัดเก็บและจัดทำดัชนีอย่างไรครับ การกำหนด Mapping ที่เหมาะสมเป็นสิ่งสำคัญมากสำหรับประสิทธิภาพและความถูกต้องของการค้นหา โดยเฉพาะอย่างยิ่งสำหรับ Full-text Search ครับ

ประเภทของ Field ที่สำคัญสำหรับ Full-text Search:

• text: ใช้สำหรับข้อความที่ต้องการค้นหาแบบ Full-text Search ครับ Field ประเภทนี้จะถูกประมวลผลโดย Analyzer (แยกคำ, ตัดคำ, แปลงเป็นคำฐาน ฯลฯ) ก่อนจัดเก็บลงใน Inverted Index ครับ
• keyword: ใช้สำหรับข้อความที่ไม่ต้องการให้ถูกประมวลผลโดย Analyzer ครับ เช่น ชื่อสินค้าที่เป็นรหัส, แท็ก, ชื่อผู้ใช้, รหัสไปรษณีย์ Field ประเภทนี้จะถูกจัดเก็บเป็น “คำ” เดียวทั้งชุดข้อความ เหมาะสำหรับการค้นหาแบบตรงตัว, การจัดกลุ่ม (Aggregation), หรือการกรองครับ

Elasticsearch มีความสามารถในการทำ Dynamic Mapping ซึ่งหมายความว่าหากคุณนำเข้า Document โดยที่ไม่ได้กำหนด Mapping ไว้ล่วงหน้า Elasticsearch จะพยายามเดาประเภทของ Field ให้เองครับ เช่น ถ้าเจอข้อความก็จะเดาว่าเป็น `text` (และสร้าง `keyword` sub-field ให้โดยอัตโนมัติในเวอร์ชันใหม่ ๆ), ถ้าเจอตัวเลขก็จะเดาเป็น `long` หรือ `double` ครับ แม้ว่า Dynamic Mapping จะสะดวก แต่สำหรับการใช้งานจริง โดยเฉพาะ Full-text Search ควรจะกำหนด Explicit Mapping ด้วยตัวเองเพื่อให้ควบคุมการทำงานของ Analyzer ได้อย่างแม่นยำครับ

ตัวอย่างการสร้าง Index พร้อม Mapping สำหรับบทความภาษาไทย:

PUT /thai_articles
{
  "settings": {
    "index": {
      "number_of_shards": 1,
      "number_of_replicas": 1,
      "analysis": {
        "analyzer": {
          "thai_analyzer": {
            "type": "custom",
            "tokenizer": "thai",
            "filter": [
              "lowercase",
              "stop_thai",
              "thai_stemmer"
            ]
          }
        },
        "tokenizer": {
          "thai": {
            "type": "icu_tokenizer"
          }
        },
        "filter": {
          "stop_thai": {
            "type": "stop",
            "stopwords": "_thai_"
          },
          "thai_stemmer": {
            "type": "icu_folding"
            // ในทางปฏิบัติ การ Stemming ภาษาไทยอาจซับซ้อนกว่านี้
            // และอาจต้องใช้ปลั๊กอินเฉพาะ เช่น thai-tokenizer หรือ custom dictionary
          }
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "title": {
        "type": "text",
        "analyzer": "thai_analyzer",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "content": {
        "type": "text",
        "analyzer": "thai_analyzer"
      },
      "category": {
        "type": "keyword"
      },
      "author": {
        "type": "text",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      },
      "publish_date": {
        "type": "date"
      }
    }
  }
}

อธิบาย Mapping ข้างต้น:

• `PUT /thai_articles`: สร้าง Index ชื่อ `thai_articles`
• `settings`: กำหนดค่าเริ่มต้นของ Index เช่น `number_of_shards`, `number_of_replicas`
• `analysis`: ส่วนนี้สำคัญมากสำหรับการค้นหาภาษาไทย เราได้กำหนด `analyzer` ชื่อ `thai_analyzer` ขึ้นมา
  • `tokenizer`: ใช้ `icu_tokenizer` ซึ่งมีความสามารถในการแยกคำภาษาไทยได้ดี
  • `filter`: กำหนด Token Filter ต่าง ๆ เช่น `lowercase` (แปลงเป็นตัวพิมพ์เล็ก), `stop_thai` (ลบ Stopwords ภาษาไทย), และ `thai_stemmer` (สำหรับประมวลผลคำให้เป็นรากศัพท์ ซึ่งสำหรับภาษาไทยอาจต้องใช้เครื่องมือเฉพาะทางเพิ่มเติม เช่นปลั๊กอิน ICU Analysis Plugin หรือปลั๊กอินสำหรับภาษาไทยโดยเฉพาะ)
• `mappings.properties`: กำหนด Field ต่าง ๆ
  • `title`, `content`: กำหนดเป็น `text` และใช้ `thai_analyzer` ที่เราสร้างขึ้น
  • `title.keyword`, `author.keyword`: เป็น `sub-field` ประเภท `keyword` สำหรับกรณีที่เราต้องการค้นหาแบบตรงตัวหรือใช้ในการจัดกลุ่ม/กรองครับ
  • `category`: กำหนดเป็น `keyword` เพราะเราต้องการค้นหาแบบตรงตัว เช่น “ข่าว”, “บันเทิง”
  • `publish_date`: กำหนดเป็น `date` สำหรับการกรองตามช่วงเวลา

การใช้ `icu_tokenizer` เป็นทางเลือกที่ดีสำหรับการเริ่มต้นกับภาษาไทย เนื่องจากมีความสามารถในการแยกคำโดยใช้พจนานุกรมและกฎของภาษาไทยได้ในระดับหนึ่งครับ อย่างไรก็ตาม สำหรับประสิทธิภาพสูงสุดในบางบริบท อาจจำเป็นต้องพิจารณาปลั๊กอินเฉพาะทางสำหรับภาษาไทยเพิ่มเติมครับ อ่านเพิ่มเติมเกี่ยวกับการปรับแต่ง Analyzer ภาษาไทย

Analyzer: หัวใจของการค้นหาภาษาไทย

Analyzer ใน Elasticsearch คือส่วนประกอบสำคัญที่รับผิดชอบในการประมวลผลข้อความก่อนที่จะถูกจัดเก็บลงใน Inverted Index ครับ มันทำงานเป็น Pipeline โดยมีขั้นตอนหลัก ๆ ดังนี้:

1. Character Filters: ทำการประมวลผลข้อความดิบ (Raw Text) ก่อนเป็นอย่างแรก เช่น ลบแท็ก HTML, แทนที่อักขระพิเศษ
2. Tokenizer: ทำหน้าที่แยกข้อความเป็น “คำ” หรือ “Token” ครับ นี่คือส่วนสำคัญที่สุดสำหรับภาษาไทยครับ เพราะภาษาไทยไม่มีการเว้นวรรคระหว่างคำชัดเจนเหมือนภาษาอังกฤษ Tokenizer ที่ดีจะช่วยให้ระบบเข้าใจโครงสร้างของประโยคภาษาไทยได้ถูกต้อง เช่น `icu_tokenizer`
3. Token Filters: ทำการประมวลผล Token ที่ได้จาก Tokenizer อีกครั้ง เช่น
   • `lowercase`: แปลง Token ให้เป็นตัวพิมพ์เล็กทั้งหมด
   • `stop`: ลบ Stopwords (คำที่ไม่สำคัญ เช่น “คือ”, “และ”, “ว่า”)
   • `stemmer`: ลดรูปคำให้เป็นรากศัพท์ (เช่น “วิ่ง”, “วิ่งอยู่”, “วิ่งไป” กลายเป็น “วิ่ง”) ซึ่งเป็นส่วนที่ท้าทายมากสำหรับภาษาไทย
   • `synonym`: แปลงคำให้เป็นคำพ้องความหมาย (เช่น “รถยนต์” กลายเป็น “รถ”)

การเลือกและปรับแต่ง Analyzer ที่เหมาะสม โดยเฉพาะอย่างยิ่งสำหรับภาษาไทย จะส่งผลโดยตรงต่อคุณภาพและความแม่นยำของผลลัพธ์การค้นหาอย่างมากครับ

การนำเข้าเอกสาร (Indexing Documents)

เมื่อเรามี Index พร้อม Mapping แล้ว เราก็สามารถนำเข้า Document ลงไปได้ครับ

นำเข้าเอกสารเดียว:

POST /thai_articles/_doc
{
  "title": "วิธีสร้างระบบค้นหาอัจฉริยะด้วย Elasticsearch",
  "content": "บทความนี้จะแนะนำขั้นตอนการสร้างระบบค้นหาแบบ Full-text Search ด้วย Elasticsearch และการปรับแต่งสำหรับภาษาไทย",
  "category": "เทคโนโลยี",
  "author": "SiamLancard",
  "publish_date": "2023-10-26T10:00:00Z"
}

อัปเดตเอกสาร: หากต้องการอัปเดตเอกสารที่มีอยู่ คุณสามารถใช้ `POST /thai_articles/_update/{id}` หรือ `PUT /thai_articles/_doc/{id}` โดยระบุ `_id` ของเอกสารครับ

POST /thai_articles/_update/AbCdEfGhIjKlMnOpQrSt
{
  "doc": {
    "content": "บทความนี้ได้อัปเดตข้อมูลใหม่ล่าสุดเกี่ยวกับการสร้างระบบค้นหาด้วย Elasticsearch."
  }
}

นำเข้าเอกสารจำนวนมาก (Bulk API): สำหรับการนำเข้าข้อมูลจำนวนมาก การใช้ Bulk API จะมีประสิทธิภาพมากกว่าการส่งทีละ Document ครับ

POST /_bulk
{"index": {"_index": "thai_articles"}}
{"title": "แนวคิดเบื้องต้นของ Inverted Index ใน Elasticsearch", "content": "ทำความเข้าใจว่า Inverted Index ทำงานอย่างไรและสำคัญต่อ Full-text Search อย่างไร", "category": "เทคโนโลยี", "author": "SiamLancard", "publish_date": "2023-10-25T09:30:00Z"}
{"index": {"_index": "thai_articles"}}
{"title": "การใช้ Kibana เพื่อสร้าง Dashboard วิเคราะห์ข้อมูล", "content": "เรียนรู้การใช้ Kibana เพื่อสร้างภาพข้อมูลจาก Elasticsearch", "category": "เครื่องมือ", "author": "ทีมงาน", "publish_date": "2023-10-24T14:15:00Z"}

สังเกตว่าแต่ละรายการใน Bulk API จะมีสองบรรทัด: บรรทัดแรกคือ `action/metadata` และบรรทัดที่สองคือ `document` ครับ

สร้างระบบค้นหา Full-text Search อัจฉริยะด้วย Elasticsearch Query DSL

เมื่อข้อมูลของเราอยู่ใน Elasticsearch แล้ว ขั้นตอนต่อไปคือการสร้าง Query ที่ทรงพลังเพื่อดึงข้อมูลที่เกี่ยวข้องออกมาครับ Elasticsearch มีภาษา Query ที่เรียกว่า Query DSL (Domain Specific Language) ซึ่งเป็น JSON-based syntax ที่มีความยืดหยุ่นสูงมากครับ

ประเภทของ Query ที่สำคัญ

การเลือก Query Type ที่เหมาะสมเป็นสิ่งสำคัญสำหรับการได้ผลลัพธ์ที่ถูกต้องและมีประสิทธิภาพครับ

• Match Query: เป็น Query พื้นฐานและใช้บ่อยที่สุดสำหรับการค้นหาแบบ Full-text Search ครับ ข้อความที่ป้อนจะถูกประมวลผลโดย Analyzer (เช่น แยกคำ) ก่อนนำไปค้นหาครับ
• Term Query: ใช้สำหรับการค้นหาแบบตรงตัว (Exact Match) ครับ ข้อความที่ป้อนจะไม่ถูกประมวลผลโดย Analyzer ครับ เหมาะสำหรับ Field ประเภท `keyword` หรือ Field ที่ไม่ต้องการให้ถูกวิเคราะห์ เช่น ID, รหัสสินค้า, แท็กครับ
• Multi-match Query: คล้ายกับ Match Query แต่สามารถค้นหาในหลาย ๆ Field พร้อมกันได้ครับ มีประโยชน์เมื่อต้องการค้นหาคำเดียวกันใน Field ที่แตกต่างกัน เช่น `title` และ `content` ครับ
• Match Phrase Query: ใช้ค้นหาคำที่เป็นวลี (Phrase) แบบตรงตัว โดยคำที่ค้นหาจะต้องปรากฏติดกันและอยู่ในลำดับที่ถูกต้องครับ
• Boolean Query (`bool` query): เป็น Query ที่ทรงพลังที่สุด ใช้สำหรับรวมเงื่อนไขการค้นหาหลาย ๆ เงื่อนไขเข้าด้วยกัน โดยมี Clause หลักคือ:
  • `must`: เอกสารต้องมีเงื่อนไขนี้ (คล้ายกับ AND)
  • `should`: เอกสารควรมีเงื่อนไขนี้ (คล้ายกับ OR, ใช้เพิ่ม Relevance Score)
  • `must_not`: เอกสารต้องไม่มีเงื่อนไขนี้ (คล้ายกับ NOT)
  • `filter`: เอกสารต้องมีเงื่อนไขนี้ แต่จะไม่ส่งผลต่อ Relevance Score (เหมาะสำหรับการกรองข้อมูลที่ต้องการความเร็วสูงและไม่ต้องสนใจการจัดอันดับ)
• Fuzzy Query: ใช้สำหรับการค้นหาที่ยอมให้มีคำผิด (typos) ได้ในระดับหนึ่งครับ มีประโยชน์มากสำหรับระบบที่ผู้ใช้อาจพิมพ์ผิดบ่อย ๆ ครับ
• Range Query: ใช้สำหรับการค้นหาข้อมูลในช่วงค่าที่กำหนด เช่น ช่วงวันที่, ช่วงราคา, ช่วงตัวเลขครับ

Relevance Scoring: การจัดอันดับความเกี่ยวข้อง

หนึ่งในความสามารถที่โดดเด่นของ Elasticsearch คือการคำนวณคะแนนความเกี่ยวข้อง (Relevance Score) สำหรับแต่ละ Document ที่ตรงกับคำค้นหา โดยค่าเริ่มต้น Elasticsearch ใช้ Algorithm ที่เรียกว่า BM25 (Best Match 25) ซึ่งเป็น Algorithm ที่พัฒนามาจาก TF-IDF (Term Frequency-Inverse Document Frequency) ครับ

ปัจจัยหลักในการคำนวณคะแนนความเกี่ยวข้อง ได้แก่:

• Term Frequency (TF): คำที่ค้นหาปรากฏบ่อยแค่ไหนใน Document นั้น ๆ ยิ่งปรากฏบ่อย ยิ่งมีแนวโน้มที่จะเกี่ยวข้องมากครับ
• Inverse Document Frequency (IDF): คำที่ค้นหาหายากแค่ไหนใน Index ทั้งหมด ถ้าคำนั้นเป็นคำที่หาได้ยากและปรากฏใน Document ยิ่งทำให้ Document นั้นมีคะแนนสูงขึ้นครับ (เพราะคำนั้นมีความเฉพาะเจาะจง)
• Field Length Norm: ความยาวของ Field ที่ค้นหา หากคำที่ค้นหาปรากฏใน Field ที่สั้น (เช่น `title`) จะมีคะแนนสูงกว่าการปรากฏใน Field ที่ยาว (เช่น `content`) เพราะถือว่ามีความสำคัญกว่าครับ

ผู้ใช้สามารถปรับแต่งการคำนวณคะแนนนี้ได้ผ่าน Query DSL โดยการใช้ `boost` เพื่อเพิ่มน้ำหนักให้กับ Field หรือ Query บางประเภทครับ

Highlighting: เน้นคำที่ค้นพบ

Highlighting เป็นคุณสมบัติที่ช่วยให้ผู้ใช้เห็นว่าคำที่ค้นหาปรากฏอยู่ที่ส่วนใดของ Document ครับ โดย Elasticsearch จะส่งข้อความ snippet ที่มีคำที่ค้นหาพร้อมแท็ก HTML (เช่น ``) กลับมา ทำให้ง่ายต่อการนำไปแสดงผลบนหน้าเว็บครับ

GET /thai_articles/_search
{
  "query": {
    "match": {
      "content": "ระบบค้นหาอัจฉริยะ"
    }
  }
}

GET /thai_articles/_search
{
  "query": {
    "multi_match": {
      "query": "Elasticsearch ภาษาไทย",
      "fields": ["title", "content"]
    }
  }
}

GET /thai_articles/_search
{
  "query": {
    "match_phrase": {
      "content": "Full-text Search"
    }
  }
}

GET /thai_articles/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "multi_match": {
            "query": "Elasticsearch ภาษาไทย",
            "fields": ["title^3", "content"],
            "type": "best_fields"
          }
        }
      ],
      "filter": [
        {
          "term": {
            "category.keyword": "เทคโนโลยี"
          }
        },
        {
          "range": {
            "publish_date": {
              "gte": "2023-01-01T00:00:00Z"
            }
          }
        }
      ],
      "should": [
        {
          "match": {
            "author": "SiamLancard"
          }
        }
      ]
    }
  },
  "highlight": {
    "fields": {
      "title": {},
      "content": {}
    }
  }
}

GET /thai_articles/_search
{
  "query": {
    "match": {
      "title": {
        "query": "ระบบค้นหาอจริยะ", // สะกดผิด
        "fuzziness": "AUTO"
      }
    }
  }
}

PUT /my_thai_index
{
  "settings": {
    "index": {
      "analysis": {
        "analyzer": {
          "my_custom_thai_analyzer": {
            "type": "custom",
            "char_filter": ["icu_normalizer"],
            "tokenizer": "icu_tokenizer",
            "filter": [
              "lowercase",
              "icu_folding",
              "icu_normalizer",
              "stop_thai",
              "my_synonym_filter"
            ]
          }
        },
        "char_filter": {
          "icu_normalizer": {
            "type": "icu_normalizer"
          }
        },
        "filter": {
          "stop_thai": {
            "type": "stop",
            "stopwords": "_thai_"
          },
          "my_synonym_filter": {
            "type": "synonym",
            "synonyms_path": "analysis/synonyms.txt" // ไฟล์ synonyms.txt ใน config directory
          }
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "text_content": {
        "type": "text",
        "analyzer": "my_custom_thai_analyzer"
      }
    }
  }
}

GET /thai_articles/_search
{
  "size": 0,
  "aggs": {
    "articles_by_category": {
      "terms": {
        "field": "category.keyword",
        "size": 10
      }
    }
  }
}

{
  "aggregations": {
    "articles_by_category": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [
        {
          "key": "เทคโนโลยี",
          "doc_count": 2
        },
        {
          "key": "เครื่องมือ",
          "doc_count": 1
        }
      ]
    }
  }
}

PUT /products
{
  "mappings": {
    "properties": {
      "name": { "type": "text" },
      "name_suggest": {
        "type": "completion"
      }
    }
  }
}

POST /products/_doc/1
{
  "name": "โทรศัพท์มือถือ Samsung Galaxy",
  "name_suggest": {
    "input": ["Samsung Galaxy", "โทรศัพท์ Samsung", "Galaxy โทรศัพท์"]
  }
}

POST /products/_doc/2
{
  "name": "โน้ตบุ๊ก Acer Swift",
  "name_suggest": {
    "input": ["Acer Swift", "โน้ตบุ๊ก Acer"]
  }
}

GET /products/_search
{
  "suggest": {
    "product-suggester": {
      "prefix": "Sam",
      "completion": {
        "field": "name_suggest",
        "size": 5
      }
    }
  }
}

POST /thai_articles/_update/AbCdEfGhIjKlMnOpQrSt
{
  "doc": {
    "category": "ข่าวเทคโนโลยี"
  }
}

DELETE /thai_articles/_doc/AbCdEfGhIjKlMnOpQrSt