---
title: JoinAlgorithm.Type – ระบุอัลกอริทึมที่ใช้ในการ Join
url: https://www.thepexcel.com/functions/power-query/enumerations/joinalgorithm-type/
type: function-explainer
program: Power Query
syntax: "{{ JoinAlgorithm.Dynamic | JoinAlgorithm.PairwiseHash | JoinAlgorithm.SortMerge | JoinAlgorithm.LeftHash | JoinAlgorithm.RightHash | JoinAlgorithm.LeftIndex | JoinAlgorithm.RightIndex }}"
date: 2025-12-04
updated: 2025-12-26
scores:
  popularity: 3
  difficulty: 3
  usefulness: 3
---

# JoinAlgorithm.Type – ระบุอัลกอริทึมที่ใช้ในการ Join

> ระบุอัลกอริทึมที่ใช้ในการ Join ข้อมูลจากสองตาราง ช่วยให้คุณควบคุมประสิทธิภาพการทำงานได้ดีขึ้น

## คำอธิบาย

ระบุอัลกอริทึมที่ใช้ในการ Join ข้อมูลจากสองตาราง ช่วยให้คุณควบคุมประสิทธิภาพการทำงานได้ดีขึ้น

## Syntax

```excel
{{ JoinAlgorithm.Dynamic | JoinAlgorithm.PairwiseHash | JoinAlgorithm.SortMerge | JoinAlgorithm.LeftHash | JoinAlgorithm.RightHash | JoinAlgorithm.LeftIndex | JoinAlgorithm.RightIndex }}
```

## Arguments

| Name | Required | Type | Default | Description |
| --- | --- | --- | --- | --- |
| JoinAlgorithm.Dynamic | No | number (0) |  | ปล่อยให้ Power Query เลือกอัลกอริทึมที่เหมาะสมเอง โดยดูจากลักษณะของข้อมูลและตาราง (ค่าเริ่มต้น) |
| JoinAlgorithm.PairwiseHash | No | number (1) |  | เก็บข้อมูลของทั้งสองตารางไว้ในหน่วยความจำก่อน แล้วค่อย Join ทีหลัง ใช้ได้ดีถ้าข้อมูลน้อยเท่านั้น |
| JoinAlgorithm.SortMerge | No | number (2) |  | Join โดยถือว่าทั้งสองตารางถูกเรียงลำดับแล้ว เร็วและประหยัดหน่วยความจำ แต่ต้องแน่ใจว่าข้อมูลเรียงตาม Join Key จริงๆ |
| JoinAlgorithm.LeftHash | No | number (3) |  | เก็บข้อมูลตารางซ้ายไว้เป็น Lookup Table แล้ว Stream ข้อมูลตารางขวา เหมาะเวลาตารางซ้ายเล็กกว่า |
| JoinAlgorithm.RightHash | No | number (4) |  | เก็บข้อมูลตารางขวาไว้เป็น Lookup Table แล้ว Stream ข้อมูลตารางซ้าย เหมาะเวลาตารางขวาเล็กกว่า |
| JoinAlgorithm.LeftIndex | No | number (5) |  | ใช้ Key จากตารางซ้ายเพื่อ Query ตารางขวา เหมาะตารางขวาใหญ่ที่รองรับ Query Folding |
| JoinAlgorithm.RightIndex | No | number (6) |  | ใช้ Key จากตารางขวาเพื่อ Query ตารางซ้าย เหมาะตารางซ้ายใหญ่ที่รองรับ Query Folding |

## ตัวอย่าง

### 1. ใช้ Dynamic Algorithm (ค่าเริ่มต้น)

```excel
let
    LeftTable = Table.FromRecords({[ID = 1, Name = "Alice"], [ID = 2, Name = "Bob"]}),
    RightTable = Table.FromRecords({[ID = 1, Salary = 50000], [ID = 2, Salary = 60000]}),
    Joined = Table.Join(LeftTable, {"ID"}, RightTable, {"ID"}, JoinKind.Inner, JoinAlgorithm.Dynamic)
in
    Joined
```

**ผลลัพธ์:** `ตารางที่รวม ID, Name, และ Salary โดยให้ Power Query เลือกวิธี Join เอง`

ใช้ JoinAlgorithm.Dynamic เป็นตัวเลือกเริ่มต้นที่ปลอดภัยที่สุด Power Query จะตรวจสอบข้อมูลและเลือกอัลกอริทึมที่ดีที่สุดโดยอัตโนมัติ

### 2. ใช้ LeftHash เมื่อตารางซ้ายเล็ก

```excel
let
    SmallTable = Table.FromRecords({[ProductID = 1, ProductName = "Laptop"], [ProductID = 2, ProductName = "Phone"]}),
    LargeTable = Table.FromRecords({[ProductID = 1, Quantity = 100], [ProductID = 2, Quantity = 200], [ProductID = 1, Quantity = 50]}),
    Joined = Table.Join(SmallTable, {"ProductID"}, LargeTable, {"ProductID"}, JoinKind.Inner, JoinAlgorithm.LeftHash)
in
    Joined
```

**ผลลัพธ์:** `ตารางที่ Join ProductID Name และ Quantity โดยเก็บ SmallTable ไว้ในหน่วยความจำ`

เมื่อตารางซ้ายมีจำนวนแถวน้อย (SmallTable) ให้ใช้ LeftHash มันจะเก็บ SmallTable ไว้ในหน่วยความจำแล้ว Stream ข้อมูลจาก LargeTable ทีละแถว ประหยัดหน่วยความจำและเร็วกว่า

### 3. ใช้ SortMerge เมื่อข้อมูลเรียงลำดับแล้ว

```excel
let
    SortedLeft = Table.Sort(Table.FromRecords({[ID = 2, Value = "B"], [ID = 1, Value = "A"]}), {{"ID", Order.Ascending}}),
    SortedRight = Table.Sort(Table.FromRecords({[ID = 1, Amount = 100], [ID = 2, Amount = 200]}), {{"ID", Order.Ascending}}),
    Joined = Table.Join(SortedLeft, {"ID"}, SortedRight, {"ID"}, JoinKind.Inner, JoinAlgorithm.SortMerge)
in
    Joined
```

**ผลลัพธ์:** `ตารางที่ Join ID Value และ Amount โดยใช้ SortMerge ซึ่งเร็วและประหยัด`

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

### 4. ใช้ RightHash เมื่อตารางขวาเล็ก

```excel
let
    LargeTable = Table.FromRecords({[ID = 1, Name = "A"], [ID = 2, Name = "B"]}),
    SmallTable = Table.FromRecords({[ID = 1, Category = "X"], [ID = 2, Category = "Y"]}),
    Joined = Table.Join(LargeTable, {"ID"}, SmallTable, {"ID"}, JoinKind.Inner, JoinAlgorithm.RightHash)
in
    Joined
```

**ผลลัพธ์:** `ตารางที่ Join ID Name และ Category โดยเก็บ SmallTable ไว้ในหน่วยความจำ`

เมื่อตารางขวามีจำนวนแถวน้อย (SmallTable) ให้ใช้ RightHash มันจะเก็บตารางขวาไว้ในหน่วยความจำแล้ว Stream ข้อมูลจากตารางซ้าย ประสิทธิภาพดีเมื่อตารางขวาเล็กกว่า

## หมายเหตุเพิ่มเติม

- ผมแนะนำให้ทดสอบหลายๆ อัลกอริทึมแล้วดูว่าตัวไหนให้ Performance ดีสุด เพราะมันขึ้นอยู่กับลักษณะข้อมูล

- ส่วนตัวผมสำหรับตารางเล็ก (ไม่กี่พันแถว) ให้ใช้ LeftHash หรือ RightHash ลองแล้วเร็วดีครับ

- เมื่อ Join กับ Database ที่รองรับ Query Folding ให้ลองใช้ LeftIndex หรือ RightIndex ได้ Folding ผลจะดีมาก

- SortMerge นั่นเร็วที่สุดแต่ต้องแน่ใจว่าข้อมูลเรียงแล้ว ผมชอบใช้เวลาข้อมูลมากๆ หลักแสน หรือ ล้านแถว

## คำถามที่พบบ่อย

**Q: JoinAlgorithm.Type คืออะไร และทำไมผมต้องใส่ใจ?**

JoinAlgorithm.Type นั่นแหละคือตัวควบคุมว่า Power Query จะใช้อัลกอริทึมไหนในการ Join ข้อมูลครับ ผมเห็นมาหลายครั้งที่คนเขียน M code ลืมใส่ใจเรื่องนี้ แล้วได้ผลลัพธ์ที่ช้ามากๆ เลือกอัลกอริทึมที่เหมาะสมกับข้อมูลของคุณแล้วเร็วเลย

**Q: ความแตกต่างระหว่าง LeftHash กับ RightHash คืออะไร?**

LeftHash เก็บตารางซ้ายไว้ในหน่วยความจำ Stream ตารางขวา ใช้เวลาตารางซ้ายเล็กกว่า RightHash เก็บตารางขวาไว้ในหน่วยความจำ Stream ตารางซ้าย ใช้เวลาตารางขวาเล็กกว่า ผมมักตรวจสอบว่าตารางไหนเล็กกว่าแล้วเลือกให้เหมาะสม

**Q: SortMerge ต้องใช้เมื่อไหร่?**

ผมแนะนำให้ใช้ SortMerge เมื่อข้อมูลเรียงลำดับแล้วตามพื้นฐาน Join Key แล้วครับ มันเร็วมากและประหยัดหน่วยความจำ แต่ต้องแน่ใจจริงๆ ว่าข้อมูลเรียงแล้ว ถ้าไม่เรียงผลลัพธ์จะผิดแน่ๆ

**Q: LeftIndex กับ RightIndex ต่างกันยังไง?**

LeftIndex ใช้ Key จากตารางซ้ายเพื่อ Query ตารางขวา เหมาะตารางขวาใหญ่ที่รองรับ Query Folding (เช่น SQL database) RightIndex ใช้ Key จากตารางขวาเพื่อ Query ตารางซ้าย เหมาะตารางซ้ายใหญ่ ผมใช้มากเวลาทำงานกับ Database ที่รองรับ Folding

**Q: ผมควรเลือก Dynamic หรือที่อื่น?**

ส่วนตัวผมแนะนำให้เริ่มด้วย Dynamic (ค่าเริ่มต้น) ปล่อยให้ Power Query เลือกเอง แต่ถ้า Performance ไม่ดีหรือคุณรู้ลักษณะข้อมูลได้ดีก็ให้ระบุอัลกอริทึมเฉพาะครับ

## แหล่งข้อมูลเพิ่มเติม

- [Microsoft Learn: JoinAlgorithm.Type](https://learn.microsoft.com/en-us/powerquery-m/joinalgorithm-type) _(official)_
- [Power Query How - Join Algorithms](https://powerquery.how/) _(article)_

---

_Source: [https://www.thepexcel.com/functions/power-query/enumerations/joinalgorithm-type/](https://www.thepexcel.com/functions/power-query/enumerations/joinalgorithm-type/)_