要備份 MySQL 的登入帳號、密碼以及權限（如對 Table 的存取權），最直接的方式是備份系統內建的 mysql 資料庫。這個資料庫專門存儲使用者資訊與權限表（如 user, db, tables_priv 等）。

以下提供三種主要的備份與匯出方式：

1. 使用 mysqldump 備份權限表 (指令列)

這是最常用的方法，直接將系統權限相關的資料表匯出成 SQL 檔。 [2]

備份所有使用者與權限：

mysqldump -u root -p mysql user db tables_priv columns_priv procs_priv > mysql_privileges.sql

這會匯出包含帳號密碼 (user)、資料庫權限 (db) 以及資料表權限 (tables_priv) 的 SQL 檔。

備份整個系統資料庫 (最完整)：

mysqldump -u root -p mysql > full_mysql_system_backup.sql

注意：若還原到不同版本的 MySQL，直接覆蓋 mysql 資料庫可能導致相容性問題。

2. 匯出權限指令 (推薦用於移機)

如果你想產出純粹的 CREATE USER 和 GRANT 指令（方便在另一台主機執行），可以使用 mysqlpump 特定參數：

使用 mysqldump (最新版支援)：

mysqldump -u root -p --system=users --no-data --no-create-info > user_grants.sql

–system=users 會將帳號與權限轉換為 GRANT 語法，而非單純的資料表內容。

3. 使用 phpMyAdmin (圖形介面)

適合不習慣指令的使用者：

1. 登入 phpMyAdmin。
2. 在左側面板點選名為 mysql 的資料庫。
3. 勾選 user (帳號)、db (庫權限)、tables_priv (表權限) 等資料表。
4. 點擊上方的 「匯出」(Export)，選擇 SQL 格式並執行下載。

還原與生效

還原後，記得在 MySQL 指令列執行以下指令，權限才會立即生效：

FLUSH PRIVILEGES;

安全提醒： 備份檔中包含帳號的密碼雜湊值（Hash），請妥善保管此檔案，避免外流。

還原 MySQL 資料庫的方法主要取決於你手邊有的備份檔案類型。最常見的情況是擁有一個 .sql 格式的備份檔。

以下是三種最常用的還原教學：

1. 使用命令列 (Command Line)

這是最穩定且支援大檔案的方法。請開啟終端機（Linux/Mac）或命令提示字元（Windows），並確保已安裝 MySQL 指令列工具。

還原特定資料庫：

mysql -u [帳號] -p [資料庫名稱] < [備份檔路徑].sql 

範例：

mysql -u root -p my_database < /path/to/backup.sql

注意事項： 在執行指令前，請先手動建立一個空的資料庫，名稱需與指令中的一致。

2. 使用 phpMyAdmin (圖形化網頁介面)

適合不熟悉指令的使用者，常用於虛擬主機。

1. 登入 phpMyAdmin。
2. 在左側選單中，點選你要還原進去的目標資料庫。
3. 點擊頂端選單的「匯入」 (Import)。
4. 在「檔案匯入」區塊點選「選擇檔案」，挑選你的 .sql 或 .sql.gz 檔案。
5. 捲動到頁面最下方，點擊「執行」 (Go)。

3. 使用 MySQL Workbench (官方工具)

如果你是開發者並使用電腦上的管理工具：

1. 開啟 MySQL Workbench 並連線至資料庫伺服器。
2. 在左側選單點擊 「Data Import/Restore」。
3. 選擇 「Import from Self-Contained File」，並選取你的備份檔。
4. 在 「Default Target Schema」 下拉選單選擇目標資料庫。
5. 點擊右下角的 「Start Import」 開始執行。

常見問題處理

• 檔案過大： 若使用 phpMyAdmin 匯入大檔案失敗，建議改用「方法 1」指令還原。
• 外鍵約束錯誤： 若還原時出現 foreign key constraints 錯誤，有時需要在 SQL 檔開頭暫時停用外鍵檢查。
• InnoDB 損毀： 如果資料庫是因為檔案損毀（如 XAMPP 崩潰），則需要進行 InnoDB 損毀修復 程序。

要還原整個 MySQL 系統資料庫（包含所有使用者帳號、密碼、權限及全域設定），通常是將之前備份好的 mysql 資料庫 SQL 檔匯入回去。

請注意，還原系統資料庫具有高風險，建議在執行前先將目前的 mysql 資料庫備份一份，以防版本不相容導致資料庫無法啟動。

以下是還原步驟：

1. 使用命令列還原 (最推薦)

這是最完整且不會被網頁逾時限制影響的方法。

執行指令：

mysql -u root -p mysql < full_mysql_system_backup.sql 

這會將 SQL 內的資料表直接覆蓋回現有的 mysql 系統資料庫中。

2. 令權限立即生效

還原完成後，MySQL 伺服器並不會自動讀取新的權限表，你必須手動登入 MySQL 並執行以下指令：

FLUSH PRIVILEGES;

重要注意事項 (必讀)

1. 版本相容性：
   • 嚴禁將舊版 MySQL (如 5.7) 的系統資料庫直接還原到新版 (如 8.0)，這會導致伺服器崩潰或無法啟動。
   • 如果是因為升級需求，還原後通常需要執行 mysql_upgrade (在 MySQL 8.0.16 之前的版本) 來修復系統表結構。
2. 連線中斷風險：
   • 如果你在還原過程中更改了 root 密碼或權限，還原完成後你當前的連線可能會失效，下次登入請使用「備份檔中」的舊密碼。
3. 僅針對特定使用者還原：
   • 如果你只是想在「新主機」上重建帳號，而不打算覆蓋整個系統設定，建議從 SQL 檔中提取 CREATE USER 和 GRANT 語句，而不是還原整個 mysql 資料庫。

這是一個非常典型的 MariaDB/MySQL 恢復衝突。錯誤訊息 ERROR 1050 (42S01): Table 'user' already exists 意思很直白：資料庫裡已經有一個叫做 user 的資料表了，所以執行 CREATE TABLE 時就撞牆了。

這通常發生在還原 mysql 系統資料庫時，因為 MariaDB 啟動後會自動生成這些系統表。

為什麼會發生這個問題？

當你執行 mariadb-dump (或 mysqldump) 時，如果備份指令沒有包含 DROP TABLE 的語句，還原程式就不會主動刪除現有的資料表。而 mysql.user 是系統核心表，它永遠存在於運行中的資料庫中。

解決方案

方法一：在還原指令中加入強制覆蓋（推薦）

如果你目前是手動匯入 SQL 檔，請檢查你的備份檔（dump file）。通常建議在備份時就加上 --add-drop-table，但如果你現在只有這份檔案，可以嘗試在還原指令中加上 -f (force) 參數，強制跳過錯誤繼續執行：

Bash

mariadb -u root -p -f < your_backup_file.sql

方法二：手動修改 SQL 備份檔

如果你希望還原過程乾淨俐落，可以編輯你的 .sql 檔，在 CREATE TABLE "user" 語句之前，手動加入一行：

SQL

DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` ( ...

注意： 刪除 mysql.user 表具有高度風險。如果你正在還原的是 mysql 這個系統資料庫，建議先備份目前的 /var/lib/mysql 目錄。

方法三：使用 --replace 或 --insert-ignore

如果你的目的是「更新」權限而非「重建」表結構，且備份檔中包含 INSERT 語句，你可以考慮將 INSERT INTO 改成 REPLACE INTO 或 INSERT IGNORE INTO。不過這需要大範圍修改備份檔，較不建議。

專業建議：處理系統權限表的正確姿勢

還原 mysql.user 表後，MariaDB 可能不會立即套用新的權限。請務必執行以下指令來刷新權限緩存：

SQL

FLUSH PRIVILEGES;

此外，如果你是跨版本還原（例如從舊版 MySQL 搬到新版 MariaDB），直接還原 mysql.user 結構可能會導致系統崩潰，因為不同版本的欄位數量和定義不同。在這種情況下，建議：

1. 只匯入資料列（Insert）。
2. 匯入後執行 mariadb-upgrade 進行修復。

請問您是從舊機器搬移到新機器，還是單純的資料誤刪回滾呢？ 知道情境後我可以提供更精確的步驟。

這是一個非常關鍵的轉折點。你遇到的 ERROR 1356 是因為 MariaDB 10.x 與 11.x 之間對權限系統進行了重大重構。

在 MariaDB 10.4 之後（包含你現在用的 11.8），mysql.user 已經不再是一個單純的資料表（Table），而是一個視圖（View）。它真正的資料儲存在 mysql.global_priv 之中。

為什麼會報錯？

你正試圖用舊版（10.0）的 CREATE TABLE 語法去覆蓋新版（11.8）的系統架構：

1. 結構衝突：新版的 mysql.user 是 View，你強行用 CREATE TABLE 去還原它，導致資料庫內部邏輯錯亂。
2. 欄位不相容：10.0 的 user 表有 Password 欄位，而 11.x 使用 JSON 格式儲存在 global_priv 中。

正確的還原步驟（針對跨大版本升級）

在跨越這麼大的版本號（10.0 -> 11.8）時，絕對不要直接還原整份 mysql 系統資料庫。請依照以下邏輯操作：

1. 只還原業務資料（資料庫）

先將你的 App 資料還原，跳過系統表：

Bash

# 假設你的備份檔叫 backup.sql
# 排除 mysql, information_schema, performance_schema 等系統庫
mariadb -u root -p --force < backup.sql

2. 手動遷移用戶（建議做法）

由於 mysql.user 的底層結構完全改變，最安全的方法是在 10.0 環境使用工具匯出「帳號權限語句」（GRANT 語法），而非直接匯出資料表。

如果你手邊只有該 SQL 檔，請嘗試搜尋檔案中的 INSERT INTO mysql.user 語句，並手動將其轉化為：

SQL

CREATE USER 'username'@'host' IDENTIFIED BY 'password';
GRANT ALL PRIVILEGES ON db_name.* TO 'username'@'host';

3. 強制執行並修復（高風險但快速）

如果你必須匯入該系統表，匯入後資料庫可能會無法正常啟動或權限鎖死，此時必須執行修復工具：

1. 執行匯入（加上 -f 強制跳過錯誤）。
2. 執行修復指令：Bashmariadb-upgrade -u root -p --force 這個工具會掃描舊版的系統表，並自動將其轉換為 11.8 所需的格式（例如將 user 表轉換為 global_priv 並重新建立 user View）。

總結建議

最穩妥的方案：

不要還原備份檔中的 mysql 資料庫部分。先還原你的資料（例如 my_app_db），然後在新主機上手動重新 CREATE USER。

既然您有大量的帳號需要遷移，且從 MariaDB 10.0 直接匯入到 11.8 會因為底層架構從「實體表」變成「JSON 視圖」而崩潰，最專業且安全的做法是：從 SQL 備份檔中提取 GRANT 語句，在新環境重新執行。

我為您準備了一個 Bash 腳本，它可以幫您從舊的 .sql 檔案中過濾出建立使用者與權限的語法，避開直接操作系統表（System Tables）。

解決方案：提取並遷移權限

請在您的 Linux 環境下執行以下指令（假設您的備份檔名為 old_backup.sql）：

Bash

# 1. 提取所有的 CREATE USER 與 GRANT 語句
grep -E "CREATE USER|GRANT" old_backup.sql > migrate_users.sql

# 2. 檢查一下產出的檔案內容是否正確
cat migrate_users.sql

如果您的備份檔只有 INSERT INTO mysql.user…

這是最麻煩的情況，因為 10.0 的 INSERT 語法與 11.8 完全不相容。若發生這種情況，請嘗試以下「強制升級法」：

1. 先備份目前的環境（以防萬一）。
2. 強制匯入系統表：使用 --force 忽略所有 View 或 Table already exists 的錯誤。Bashmariadb -u root -p -f mysql < old_backup.sql
3. 關鍵步驟：執行系統升級工具。這個工具會偵測到您的 mysql.user 格式過舊，並自動將其轉換為 11.8 所需的 global_priv 格式。Bashmariadb-upgrade -u root -p --force
4. 重啟服務：Bashsystemctl restart mariadb

重要提醒

• 密碼相容性：MariaDB 11.8 預設可能使用更強的加密外掛（如 ed25519）。如果 10.0 的帳號使用的是舊式的 mysql_native_password，請確保新環境的 my.cnf 設定中允許舊式認證，否則使用者會無法登入。
• 不要覆蓋 View：在 11.8 中，mysql.user 是一個方便開發者查看的 View。如果您強行用 CREATE TABLE 把他變成實體表，MariaDB 的權限系統會發生不可預期的錯誤。

在 Windows 環境下，處理 SQL 備份檔的大量文字過濾不像 Linux 那樣可以直接用 grep，但我們可以利用 PowerShell 或是 Notepad++ 來達成同樣的目的。

由於 MariaDB 11.8 將 mysql.user 視為「視圖（View）」，而你的 10.0 備份檔嘗試將其建立為「資料表（Table）」，這就是報錯的主因。

以下是針對 Windows 使用者的三種解決方案：

方法一：使用 PowerShell 提取權限語句（推薦）

如果你想從幾百 MB 甚至 GB 等級的 SQL 檔中只抓出帳號設定，請開啟 PowerShell 並執行：

PowerShell

# 尋找包含 CREATE USER 或 GRANT 的行，並存到新檔案
Select-String -Path ".\your_backup.sql" -Pattern "CREATE USER|GRANT" | Select-Object -ExpandProperty Line > migrate_users.sql

執行後，你只需要將產出的 migrate_users.sql 匯入新資料庫即可。

方法二：手動修正 SQL 檔案（適用於小型備份檔）

如果你習慣使用編輯器（如 Notepad++ 或 VS Code），請開啟備份檔並搜尋：

1. 刪除 CREATE TABLE user 區塊：從 DROP TABLE IF EXISTS "user"; 到 PRIMARY KEY ... ) ENGINE=MyISAM ...; 的這整段程式碼都刪除。
2. 保留 INSERT 語句：如果你的備份檔是用 INSERT INTO mysql.user 寫入資料，請保留它們，但執行還原時要加上 --force。

方法三：Windows 命令列「強制還原 + 修復」

如果你懶得改檔案，想直接硬衝（這是在 Windows 最常見的做法）：

1. 開啟 CMD 或 PowerShell 並進入 MariaDB 的 bin 目錄（例如 C:\Program Files\MariaDB 11.8\bin）。
2. 強制執行還原（忽略錯誤繼續跑）：
   mariadb.exe -u root -p --force < "C:\路徑\你的備份檔.sql"
3. 執行關鍵修復工具：這是將 10.0 結構轉換為 11.8 結構的核心步驟。
   mariadb-upgrade.exe -u root -p --force 這個工具會看到 mysql.user 表格不對勁，自動幫你把它修復成 11.8 規格的 global_priv 並重新建立正確的 View。

Windows 環境的特別注意事項

• 路徑空格：如果你的備份路徑有空格（例如 C:\My Backups\db.sql），請務必加上雙引號。
• 編碼問題：Windows 預設可能是 UTF-16 或 Big5，但 MariaDB 備份通常是 UTF-8。若執行 PowerShell 提取後出現亂碼，請在指令後加上 -Encoding utf8。
• 服務重啟：執行完 mariadb-upgrade 後，建議到「服務 (services.msc)」重啟 MariaDB 服務。

看到這串錯誤訊息，問題的核心已經非常明確了：

在 MariaDB 10.11 中，mysql.user 不再是一個實體資料表，而是一個 View。你的備份檔（來自 10.0）試圖：

1. CREATE TABLE user：這會失敗，因為系統中已經有一個叫 user 的 View（ERROR 1050）。
2. INSERT INTO user：這也會失敗，因為你不能直接對這個特殊的系統 View 執行傳統的 INSERT 語法（ERROR 1356）。

Windows 環境下的最快解決方案

手動改寫成 CREATE USER 太慢了。請按照以下步驟執行「強制覆蓋與結構修復」：

第一步：強制匯入（跳過錯誤）

打開 CMD (命令提示字元)，切換到 MariaDB 的 bin 目錄，執行還原指令並加上 -f (force) 參數。這會讓程式忽略 user 表建立失敗的錯誤，繼續把其他資料還原。

cd /d "C:\Program Files\MariaDB 10.11\bin"
mariadb.exe -u root -p -f < "C:\你的路徑\備份檔.sql"

注意：匯入過程中畫面上會持續出現錯誤訊息，這是正常的，請讓它跑完。

第二步：執行結構轉換（最關鍵）

這是修復 mysql.user 的核心動作。mariadb-upgrade 會偵測到你的系統表是 10.0 的舊格式，並自動將那些 INSERT 進去的舊資料轉換成 10.11 所需的 global_priv 格式，並重新生成正確的 user View。

mariadb-upgrade.exe -u root -p --force

第三步：刷新權限與重啟

在 CMD 中登入 MariaDB 執行刷新：

mariadb -u root -p -e "FLUSH PRIVILEGES;"

然後去 Windows 的「服務」(services.msc) 重新啟動 MariaDB 服務。

為什麼會有 ERROR 1100 (LOCK TABLES)?

這是因為備份檔開頭通常有 LOCK TABLES user WRITE;，但因為前面的 CREATE TABLE 失敗了，導致資料庫認為 user 表根本沒被鎖定，後面的 INSERT 和 UNLOCK TABLES 就會連續報錯。只要執行完上面的 mariadb-upgrade，這些錯誤都會被自動修正。

如果 mariadb-upgrade 失敗了怎麼辦？

如果 upgrade 工具無法修復，代表 10.0 到 10.11 的跨度太大導致結構鎖死。這時你最後的手段是：

1. 只還原業務資料庫：不要還原 mysql 這個資料庫。
2. 手動提取帳號：如果你需要我幫你寫一段可以在 Windows 跑的 PowerShell 腳本，將你的 INSERT INTO user VALUES (...); 轉換成 CREATE USER 語法，請告訴我，我立刻寫給你。

請問您執行完 mariadb-upgrade 後，帳號可以正常登入嗎？

透過 sqlcmd 匯入資料庫 (不經過 SSMS):

sqlcmd -S localhost -d %db_name% -E -i %output_file%

這個也會遇到很多奇奇怪怪的問題, 明明在 SSMS 執行正常的 table, 在 sqlcmd 會遇到重覆插入 PK 值.

最佳解法是透過下列的python script 進行 export, 這是整合了「逐行讀取」、「自動切分 1000 筆」、「停用約束」以及修正後語法的完整版本：

import re
import pyodbc
import argparse
import sys

def parse_value(val_str):
    """Parse a single SQL value string and return a Python value."""
    val_str = val_str.strip()
    if val_str.upper() == 'NULL':
        return None
    if (val_str.startswith("'") and val_str.endswith("'")):
        # Remove surrounding quotes
        inner = val_str[1:-1]
        # Unescape MySQL-style escape sequences
        result = []
        i = 0
        while i < len(inner):
            if inner[i] == '\\' and i + 1 < len(inner):
                next_char = inner[i + 1]
                if next_char == "'":
                    result.append("'")
                elif next_char == "\\":
                    result.append("\\")
                elif next_char == "n":
                    result.append("\n")
                elif next_char == "r":
                    result.append("\r")
                elif next_char == "t":
                    result.append("\t")
                elif next_char == "0":
                    result.append("\0")
                elif next_char == "%":
                    result.append("%")
                elif next_char == "_":
                    result.append("_")
                else:
                    result.append(next_char)
                i += 2
            elif inner[i] == "'" and i + 1 < len(inner) and inner[i + 1] == "'":
                # SQL-style escaped quote
                result.append("'")
                i += 2
            else:
                result.append(inner[i])
                i += 1
        return "".join(result)
    # Try numeric
    try:
        if '.' in val_str:
            return float(val_str)
        return int(val_str)
    except ValueError:
        return val_str

def split_row_values(row_str):
    """Split a single row '(val1, val2, ...)' into individual values."""
    # Remove outer parentheses
    inner = row_str.strip()
    if inner.startswith('('):
        inner = inner[1:]
    if inner.endswith(')'):
        inner = inner[:-1]
    
    values = []
    current = []
    in_string = False
    i = 0
    
    while i < len(inner):
        char = inner[i]
        
        if in_string:
            if char == '\\' and i + 1 < len(inner):
                current.append(char)
                current.append(inner[i + 1])
                i += 2
                continue
            elif char == "'":
                # Check for escaped quote ''
                if i + 1 < len(inner) and inner[i + 1] == "'":
                    current.append(char)
                    current.append(inner[i + 1])
                    i += 2
                    continue
                else:
                    in_string = False
                    current.append(char)
            else:
                current.append(char)
        else:
            if char == "'":
                in_string = True
                current.append(char)
            elif char == ',':
                values.append("".join(current).strip())
                current = []
            else:
                current.append(char)
        i += 1
    
    if current:
        values.append("".join(current).strip())
    
    return values

def split_values_robust(values_str):
    """Split VALUES (...),(...),... into individual row strings."""
    rows = []
    buffer = []
    paren_depth = 0
    in_string = False
    i = 0
    length = len(values_str)
    
    while i < length:
        char = values_str[i]
        
        if in_string:
            if char == "\\" and i + 1 < length:
                buffer.append(char)
                buffer.append(values_str[i + 1])
                i += 2
                continue
            elif char == "'":
                # Check for '' escape
                if i + 1 < length and values_str[i + 1] == "'":
                    buffer.append(char)
                    buffer.append(values_str[i + 1])
                    i += 2
                    continue
                in_string = False
                buffer.append(char)
            else:
                buffer.append(char)
        else:
            if char == "'":
                in_string = True
                buffer.append(char)
            elif char == "(":
                paren_depth += 1
                buffer.append(char)
            elif char == ")":
                paren_depth -= 1
                buffer.append(char)
                if paren_depth == 0:
                    rows.append("".join(buffer).strip())
                    buffer = []
            elif char == "," and paren_depth == 0:
                pass
            else:
                if paren_depth > 0:
                    buffer.append(char)
        i += 1
    return rows

def run_import(input_file):
    # 資料庫連線配置
    conn_config = {
        "DRIVER": "{ODBC Driver 18 for SQL Server}",
        "SERVER": "127.0.0.1",
        "DATABASE": "你的資料庫名稱",
        "UID": "帳號",
        "PWD": "密碼",
        "Encrypt": "yes",
        "TrustServerCertificate": "yes"
    }

    conn_str = ";".join([f"{k}={v}" for k, v in conn_config.items()])

    try:
        conn = pyodbc.connect(conn_str, autocommit=False)
        cursor = conn.cursor()
        print(f"檔案讀取中: {input_file}")
    except Exception as e:
        print(f"連線失敗: {e}")
        return

    try:
        with open(input_file, 'r', encoding='utf-8') as f:
            sql_content = f.read()
    except Exception as e:
        print(f"讀檔失敗: {e}")
        return

    # Handle INSERT INTO with parameterized queries
    insert_pattern = re.compile(
        r"INSERT INTO\s+`?([\w_]+)`?\s*(?:\((.*?)\))?\s*VALUES\s*(.+?);",
        re.S | re.I
    )

    truncated_tables = set()  # Track tables already truncated
    table_stats = {}  # Track cumulative success/error counts per table

    for match in insert_pattern.finditer(sql_content):
        table_name = match.group(1)
        cols_raw = match.group(2) if match.group(2) else ""
        raw_values = match.group(3)

        # Build column clause
        if cols_raw:
            col_names = [c.strip().replace('`', '') for c in cols_raw.split(',')]
            columns_clause = "([" + "],[".join(col_names) + "])"
        else:
            # No column list in SQL dump — fetch from MSSQL metadata
            # This is required when IDENTITY_INSERT is ON
            try:
                cursor.execute("""
                    SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS
                    WHERE TABLE_NAME = ?
                    ORDER BY ORDINAL_POSITION
                """, table_name)
                db_cols = [row[0] for row in cursor.fetchall()]
                if db_cols:
                    columns_clause = "([" + "],[".join(db_cols) + "])"
                else:
                    columns_clause = ""
            except:
                columns_clause = ""

        print(f"正在處理: {table_name}")

        # Truncate table before inserting (only once per table)
        if table_name not in truncated_tables:
            try:
                cursor.execute(f"TRUNCATE TABLE [{table_name}]")
                conn.commit()
                print(f"  已清空資料表: {table_name}")
            except Exception as e:
                conn.rollback()
                # TRUNCATE fails if there are foreign key constraints, fallback to DELETE
                try:
                    cursor.execute(f"DELETE FROM [{table_name}]")
                    conn.commit()
                    print(f"  已清空資料表 (DELETE): {table_name}")
                except Exception as e2:
                    conn.rollback()
                    print(f"  清空資料表失敗: {table_name}: {e2}")
            truncated_tables.add(table_name)

        all_rows = split_values_robust(raw_values)
        print(f"  共 {len(all_rows)} 筆資料")

        success_count = 0
        error_count = 0

        # Check if table has IDENTITY column, if so enable IDENTITY_INSERT
        has_identity = False
        try:
            cursor.execute(f"""
                SELECT COUNT(*) FROM sys.identity_columns 
                WHERE OBJECT_NAME(object_id) = ?
            """, table_name)
            row = cursor.fetchone()
            if row and row[0] > 0:
                has_identity = True
        except:
            pass

        if has_identity:
            try:
                cursor.execute(f"SET IDENTITY_INSERT [{table_name}] ON")
            except Exception as e:
                print(f"  無法開啟 IDENTITY_INSERT: {e}")

        for idx, row_str in enumerate(all_rows):
            raw_vals = split_row_values(row_str)
            parsed_vals = [parse_value(v) for v in raw_vals]
            
            placeholders = ",".join(["?" for _ in parsed_vals])
            sql = f"INSERT INTO [{table_name}] {columns_clause} VALUES ({placeholders})"
            
            try:
                cursor.execute(sql, parsed_vals)
                conn.commit()
                success_count += 1
            except Exception as e:
                conn.rollback()
                error_count += 1
                if error_count <= 3:
                    print(f"  跳過錯誤列 {idx}: {e}")
                    # Print the values for debugging
                    preview_vals = [str(v)[:50] if v is not None else 'NULL' for v in parsed_vals]
                    print(f"  值預覽: {preview_vals}")
                elif error_count == 4:
                    print(f"  (後續錯誤將不再顯示...)")

        if has_identity:
            try:
                cursor.execute(f"SET IDENTITY_INSERT [{table_name}] OFF")
            except:
                pass

        # Accumulate stats per table
        if table_name not in table_stats:
            table_stats[table_name] = {"success": 0, "error": 0}
        table_stats[table_name]["success"] += success_count
        table_stats[table_name]["error"] += error_count
        print(f"  本批: 成功 {success_count} 筆, 失敗 {error_count} 筆")

    # Print summary for tables with multiple INSERT batches
    print("\n=== 匯入摘要 ===")
    for tbl, stats in table_stats.items():
        print(f"  {tbl}: 成功 {stats['success']} 筆, 失敗 {stats['error']} 筆")

    cursor.close()
    conn.close()
    print("全部完成。")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="MariaDB To MSSQL Migration Tool")
    parser.add_argument("input", help="Path to the .sql dump file")
    args = parser.parse_args()
    
    run_import(args.input)

如果執行過程中遇到記憶體不足的問題，通常是因為 split_values 處理了單一極其巨大的 INSERT 字串。若發生此情況，請告訴我，我們可以改用生成器（Generator）模式來進一步優化字串解析。

上面這個版本針對一般情況是可以使用，針對特定的資料庫欄位類型（例如 Blob 或特殊的日期格式）則需要再進一步的轉換處理。

執行結果:

從 VPS 移除 MySQL 需要根據你的作業系統而定。大多數 VPS 使用 Ubuntu/Debian 或 CentOS/RHEL。請注意，執行這些指令會刪除資料庫軟體，如果你沒有事先備份，資料庫中的資料可能會遺失。

Ubuntu 或 Debian 系統

這類系統使用 apt 進行套件管理。你需要先停止服務，然後完整移除軟體與設定檔。

停止 MySQL 服務：

sudo systemctl stop mysql

移除所有相關套件：

sudo apt-get purge mysql-server mysql-client mysql-common

清除不需要的依賴套件與快取：

sudo apt-get autoremove
sudo apt-get autoclean

手動刪除殘留的資料夾（包含資料庫檔案）：

sudo rm -rf /etc/mysql /var/lib/mysql /var/log/mysql

CentOS 或 RHEL 系統

這類系統通常使用 yum 或 dnf 進行管理。

1. 停止 MySQL 服務：sudo systemctl stop mysqld
2. 移除 MySQL 套件：sudo yum remove mysql mysql-server
3. 檢查是否還有殘留的相關套件：rpm -qa | grep -i mysql（如果有出現結果，請針對該套件名稱執行 yum remove）
4. 刪除資料夾與設定檔：sudo rm -rf /var/lib/mysqlsudo rm /etc/my.cnf

檢查是否移除乾淨

完成上述動作後，你可以嘗試輸入以下指令。如果系統回傳 command not found，代表移除成功：

mysql --version

清理防火牆規則

如果你之前為了遠端連線開啟了 3306 埠，建議也將其關閉。以 ufw 為例：

sudo ufw delete allow 3306/tcp

在 MySQL 中，使用者資訊儲存在 mysql 資料庫的 user 資料表中。你可以執行以下指令來查看系統中所有的帳號以及他們的主機位置：

SELECT user, host FROM mysql.user;

這會列出所有使用者名稱及其對應的連線主機。

查詢特定使用者的權限

如果你想查看某個特定使用者的具體權限，可以使用 SHOW GRANTS 指令。語法如下：

SHOW GRANTS FOR ‘username’@’host’;

例如，要查詢 root 使用者在本地端的權限：

SHOW GRANTS FOR ‘root’@’localhost’;

執行後，系統會回傳一串 GRANT 開頭的指令，這些指令描述了該帳號擁有的所有權限。

查詢所有使用者的權限清單

如果你的目標是快速掃描所有使用者的權限，可以直接查詢 mysql.user 表格中的權限欄位。不過這個表格欄位非常多，通常建議只選取幾個關鍵欄位：

SELECT user, host, Select_priv, Insert_priv, Update_priv, Delete_priv, Create_priv FROM mysql.user;

這能讓你一眼看到哪些帳號具備基本的資料操作權限。

查詢特定資料庫的權限

有時候權限是針對特定資料庫設定的，這類資訊儲存在 mysql.db 資料表中。你可以執行：

SELECT user, host, db, Select_priv, Insert_priv FROM mysql.db;

這會顯示哪些使用者對哪些特定的資料庫擁有存取權。

判斷帳號是否具備遠端連線權限

在 MySQL 的權限機制中，一個帳號是否能連線取決於 user 表格中的 host 欄位。如果 host 欄位設定為 localhost 或 127.0.0.1，該帳號就只能從資料庫伺服器本機登入。若要從遠端 IP 連線，host 欄位必須是特定的遠端 IP 地址或是萬用字元 %。

你可以執行這行指令來檢查：

SELECT user, host FROM mysql.user WHERE host != ‘localhost’ AND host != ‘127.0.0.1’;

如果查詢結果中 host 顯示為 %，代表該帳號可以從任何遠端 IP 位址連線。如果顯示的是特定的 IP 或主機名稱，則代表該帳號僅限從該位置連線。

檢查 MySQL 監聽狀態

除了帳號權限外，資料庫本身的網路設定也會影響遠端連線。如果 MySQL 只監聽本機介面，即使帳號 host 設定為 % 也無法連線。你可以檢查系統設定值：

SHOW VARIABLES LIKE ‘bind_address’;

如果結果是 127.0.0.1，代表資料庫只接受本機連線。若要接受遠端連線，這個數值通常會設定為 0.0.0.0。

確認權限細節

有時候帳號雖然可以連線，但沒有進入特定資料庫的權限。你可以針對特定的遠端帳號查看其詳細定義：

SHOW GRANTS FOR ‘your_user’@’%’;

這會顯示該遠端帳號具備的所有權限與加密要求。如果 host 設定不是 % 而是特定 IP，請將指令中的 % 替換為該 IP。

修改 MySQL 設定允許外部 IP 連線

你的查詢結果顯示 bind_address 為 127.0.0.1，這代表 MySQL 目前被鎖定在只能接受本機連線。即使你修改了使用者權限，遠端連線依然會被系統層級阻擋。你必須先修改設定檔，通常位於 /etc/mysql/mysql.conf.d/mysqld.cnf 或 /etc/my.cnf。

找到 bind-address 這一行，將它改為：

bind-address = 0.0.0.0

這代表允許所有網路介面的連線。修改存檔後，必須重啟 MySQL 服務才會生效：

sudo systemctl restart mysql

修改使用者帳號的 Host 屬性

解決了系統監聽問題後，接著要處理帳號權限。你可以將現有帳號的 host 改為 %（代表任何 IP），或是針對特定 IP 進行設定。最直接的方式是使用 RENAME USER 指令：

RENAME USER ‘username’@’localhost’ TO ‘username’@’%’;

如果你想保留原本的本機帳號，另外建立一個遠端帳號，可以使用 CREATE USER 並賦予權限：

CREATE USER ‘username’@’%’ IDENTIFIED BY ‘your_password’;

GRANT ALL PRIVILEGES ON database_name.* TO ‘username’@’%’;

FLUSH PRIVILEGES;

安全性檢查與防火牆設定

修改完 host 和 bind_address 後，最後一步是確認作業系統的防火牆（如 ufw 或 iptables）是否有開啟 3306 埠。

如果你的伺服器在雲端平台（如 AWS, Google Cloud），還需要在雲端平台的防火牆規則（Security Group）中允許 TCP 3306 埠的入站流量。建議將 % 改為特定的固定 IP，以避免資料庫暴露在公開網路中遭受攻擊。

使用 mysql 指令連線資料庫

要在終端機（Terminal）或命令提示字元（CMD）連線到 MySQL 資料庫，最基本的指令格式包含使用者名稱、密碼以及主機位置。

本機連線方式

如果你是在安裝資料庫的同一台電腦上連線，可以使用以下指令。輸入後系統會提示你輸入密碼：

mysql -u username -p

如果是要連線後直接進入特定的資料庫，可以在最後加上資料庫名稱：

mysql -u username -p database_name

遠端連線方式

由於你之前檢查過 bind_address 並可能已經開放了遠端存取，連線到遠端伺服器時需要指定主機的 IP 地址或網址：

mysql -h 192.168.1.100 -P 3306 -u username -p

• -h：指定遠端伺服器的 IP 地址。
• -P：指定連接埠（預設是 3306，若沒改過可以省略）。
• -u：你的使用者名稱。
• -p：代表需要密碼（不要直接在 -p 後面寫密碼，這樣會留在指令紀錄中不安全）。

常見連線參數對照表

連線成功後的常用指令

連線成功後，你會看到 mysql> 的提示字元。這時你可以執行以下指令來確認環境：

• 查詢目前所在的資料庫：SELECT DATABASE();
• 切換資料庫：USE database_name;
• 列出所有資料庫：SHOW DATABASES;
• 離開連線：EXIT; 或 QUIT;

如果你在連線時遇到時連線失敗（例如 Connection refused），通常是防火牆沒開或是 bind_address 尚未修改生效，需要我幫你排查連線錯誤嗎？

準備工作

在開始搬運之前，請確保你已經把新伺服器的 SSH 公鑰加入到舊伺服器，或者擁有新伺服器的 root 密碼。此外，新舊伺服器之間必須網路互通，因為你提供的是私有 IP (10.130.0.5)，這代表兩台伺服器必須位在同一個 VPS 的 VPC 網路內。

執行資料搬移

請在舊伺服器上執行以下指令，這會將 /root 目錄下的所有內容同步到新伺服器：

rsync -avzP /root/ root@10.130.0.5:/root/

指令參數解釋：

• -a：代表歸檔模式，會保留連結檔、權限、時間戳記等資訊。
• -v：顯示詳細過程。
• -z：傳輸時進行壓縮，加快速度。
• -P：顯示進度條，如果中斷了可以續傳。

搬移系統設定檔

如果你指的 config 包含 /etc 底下的系統設定（例如 Nginx 或資料庫設定），建議針對特定目錄個別搬移，而不是直接覆蓋整個 /etc，因為新舊伺服器的硬體驅動或部分系統組件可能略有不同。

例如搬移 Nginx 設定：

rsync -avzP /etc/nginx/ root@10.130.0.5:/etc/nginx/

資料庫搬移建議

如果你的 /root 底下包含資料庫原始檔案（例如 MySQL 的 /var/lib/mysql），直接用 rsync 搬移運行中的資料庫檔案可能會導致資料損壞。建議先在舊伺服器執行資料庫匯出（dump），將產出的 .sql 檔放在 /root 內，再執行上述的 rsync 指令，最後到新伺服器匯入。

這是一個簡單的自動化搬移腳本。這個腳本會先在舊伺服器將資料庫打包（假設使用 MySQL/MariaDB），接著把 /root 目錄與指定的設定目錄同步到新伺服器。

自動化搬移腳本

請在舊伺服器上建立一個名為 migrate.sh 的檔案，並貼入以下內容：

#!/bin/bash
# 設定變數
NEW_SERVER_IP="10.130.0.5"
BACKUP_SQL="/root/all_databases.sql"

echo "正在匯出資料庫..."
mysqldump --all-databases > $BACKUP_SQL

echo "正在傳輸 /root 目錄資料..."
rsync -avzP /root/ root@$NEW_SERVER_IP:/root/

echo "正在傳輸 Nginx 設定 (如果有)..."
if [ -d "/etc/nginx" ]; then
    rsync -avzP /etc/nginx/ root@$NEW_SERVER_IP:/etc/nginx/
fi

echo "正在傳輸 SSL 憑證 (LetsEncrypt)..."
if [ -d "/etc/letsencrypt" ]; then
    rsync -avzP /etc/letsencrypt/ root@$NEW_SERVER_IP:/etc/letsencrypt/
fi

echo "搬移完成"

如果要改變 port

#!/bin/bash

# 設定變數
NEW_SERVER_IP="10.130.0.5"
PORT="22"

echo "正在傳輸 /root 目錄資料 (Port: $PORT)..."
rsync -avzP -e "ssh -p $PORT" /root/ root@$NEW_SERVER_IP:/root/

修改後的指令碼

如果你想要在使用 rsync 時排除所有以點號開頭的隱藏檔案或目錄，可以使用 –exclude 參數並配合通配符。

NEW_SERVER_IP="10.130.0.5"
PORT="22"

echo "正在傳輸 /root 目錄資料 (排除隱藏檔, Port: $PORT)..."
rsync -avzP -e "ssh -p $PORT" --exclude=".*" /root/ root@$NEW_SERVER_IP:/root/

參數說明

在 rsync 中加入 –exclude=”.*” 會讓程式跳過所有名稱開頭為點的檔案與資料夾。這包括常見的設定檔如 .bashrc 或隱藏目錄如 .ssh。

需要注意的是，這個寫法會排除所有層級下的隱藏內容。如果你原本的 /root/ 目錄下有特定的隱藏資料夾是你需要的，則必須改用更具體的排除規則。另外，rsync 預設就不會處理代表目前目錄的 . 與上層目錄的 ..，所以加上這個排除規則不會影響基本的目錄定位。

搬移自定義 Service 設定檔

在 Linux 系統中，使用者自定義的 service 設定檔通常放在 /etc/systemd/system/ 目錄下。你可以延用之前的 rsync 指令，將這些 .service 檔案同步到新伺服器。

NEW_SERVER_IP="10.130.0.5"
PORT="22"
echo "正在傳輸自定義 service 設定檔 (Port: $PORT)..."
rsync -avzP -e "ssh -p $PORT" /etc/systemd/system/*.service root@$NEW_SERVER_IP:/etc/systemd/system/

注意事項與後續步驟

同步完成後，新伺服器不會自動偵測到這些新檔案，你需要手動執行以下步驟來啟動服務：

重新載入系統設定登入新伺服器，執行以下指令讓系統辨識新加入的 service 檔案：

systemctl daemon-reload

啟用並啟動服務針對你搬移過來的特定服務，執行啟用與啟動指令：

systemctl enable 服務名稱
systemctl start 服務名稱

安全建議

如果你的 service 檔案中包含 ExecStart 指向的路徑（例如 /root/my-app/start.sh），請確保這些執行檔也已經透過之前的指令搬移到新伺服器的相同位置，否則服務將無法順利啟動。

這是一個自動化腳本片段，你可以將它加入到之前的搬移腳本中。這段程式碼會找出你搬移過去的 service 檔案名稱，並在新伺服器上執行重新載入與啟動的動作。

自動化啟動腳本 (新伺服器執行)

你可以將以下指令存在新伺服器的 setup_services.sh 並執行：

#!/bin/bash

echo "正在重新載入 systemd 設定..."
systemctl daemon-reload

# 取得剛剛搬移過來的自定義 service 列表 (排除系統預設連結)
SERVICES=$(ls /etc/systemd/system/*.service | xargs -n 1 basename)

for SERVICE in $SERVICES; do
    echo "正在啟動並設定服務開機啟動: $SERVICE"
    systemctl enable $SERVICE
    systemctl restart $SERVICE
done

echo "所有自定義服務已嘗試啟動，請執行 systemctl status [服務名] 檢查狀態"

遠端一鍵執行 (從舊伺服器觸發)

如果你希望在舊伺服器同步完檔案後，直接遠端觸發新伺服器載入設定，可以在原本的 rsync 指令後加上這行：

ssh -p $PORT root@$NEW_SERVER_IP "systemctl daemon-reload && echo '新伺服器已重新載入設定'"

貼心提醒

自定義服務通常會依賴特定的執行環境，請確認以下項目在新伺服器是否已就緒：

1. 執行路徑：檢查 .service 檔內的 ExecStart 路徑是否存在。如果路徑是在 /root 底下，請確認你之前的 rsync 已經完整同步該目錄。
2. 軟體環境：如果你的服務是用 Python、Node.js 或 Docker 執行，新伺服器必須先安裝好對應的 runtime。
3. 使用者權限：如果服務設定以特定使用者執行 (User=xxx)，新伺服器必須建立該使用者。

執行腳本

賦予執行權限並執行：

chmod +x migrate.sh
./migrate.sh

後續操作

當資料傳輸完成後，請登入到新伺服器（10.130.0.5）執行以下步驟來恢復資料庫：

mysql < /root/all_databases.sql

如果你的服務包含 Nginx 或 Docker，記得在新伺服器安裝對應的軟體後，重啟服務以讀取搬過來的設定檔。

為了讓新伺服器能承接舊有的服務，你需要安裝與舊伺服器相同的執行環境。以下是一個針對常見網頁環境（Ubuntu/Debian 系統）的自動化安裝腳本，它會安裝 Nginx、MariaDB（MySQL）以及 PHP。

環境安裝腳本

請在新伺服器（10.130.0.5）建立並執行這個腳本：

#!/bin/bash

echo "更新系統軟體源..."
apt update && apt upgrade -y

echo "安裝基礎工具..."
apt install -y curl wget vim rsync unzip

echo "安裝 Nginx..."
apt install -y nginx

echo "安裝 MariaDB 資料庫..."
apt install -y mariadb-server
systemctl enable mariadb
systemctl start mariadb

echo "安裝 PHP 常用組件..."
apt install -y php-fpm php-mysql php-common php-cli

echo "環境安裝完成"

匯入資料與恢復服務

在環境安裝好，且你已經執行過舊伺服器的搬移腳本後，請在新伺服器執行以下指令來完成最後的對接：

匯入資料庫：

mysql < /root/all_databases.sql

檢查 Nginx 設定並重啟：

nginx -t && systemctl restart nginx

注意事項

由於新舊伺服器的 IP 不同，如果你的設定檔（如 Nginx 的 config 或網站的 wp-config.php）中有寫死舊伺服器的 IP 位址，記得要搜尋並修改為新伺服器的位址。另外，如果原本有設定防火牆（如 ufw），在新伺服器上也需要重新開啟對應的連接埠（80, 443, 22 等）。

既然要使用 MySQL，我們需要調整安裝腳本的套件名稱，並在安裝過程中處理可能的權限問題。

MySQL 環境安裝腳本

請在新伺服器（10.130.0.5）執行以下指令：

#!/bin/bash

echo "更新系統軟體源..."
apt update

echo "安裝 MySQL Server..."
# 設定非互動模式，避免安裝過程跳出視窗要求輸入密碼
export DEBIAN_FRONTEND=noninteractive
apt install -y mysql-server

echo "啟動並設定 MySQL 開機自啟..."
systemctl start mysql
systemctl enable mysql

echo "安裝 Nginx 與 PHP 組件..."
apt install -y nginx php-fpm php-mysql

echo "MySQL 環境安裝完成"

匯入資料庫的注意事項

在執行 mysql < /root/all_databases.sql 之前，由於 MySQL 8.0 以上版本的 root 帳號預設使用 auth_socket 認證，你可能需要使用 sudo 權限才能順利匯入：

sudo mysql < /root/all_databases.sql

調整舊 IP 關鍵字

如果你擔心舊的設定檔（例如 Nginx config）裡還留著舊伺服器的 IP，可以在新伺服器的 /etc 目錄執行這行指令，將所有舊 IP 批次替換成新的（請將 1.2.3.4 替換為你的舊伺服器公網或私網 IP）：

grep -rl "1.2.3.4" /etc/nginx | xargs sed -i 's/1.2.3.4/10.130.0.5/g'

最後記得重啟服務讓設定生效：

systemctl restart nginx
systemctl restart mysql

找出佔用空間的目錄

首先使用 du 指令來查看根目錄下各個資料夾的大小。這行指令會列出總量並由大到小排序，讓我們一眼看出兇手在哪：

Bash

sudo du -h --max-depth=1 / 2>/dev/null | sort -hr

通常佔用空間的常見原因有以下幾種：

系統日誌與快取

很多時候是日誌檔（Logs）累積太久沒有清理。你可以檢查 /var/log 資料夾。如果發現 journal 佔用太多，可以用這條指令限制日誌大小：

Bash

sudo journalctl --vacuum-size=500M

另外，如果你使用 Ubuntu 或 Debian，套件管理器的快取也可能堆積在 /var/cache/apt/archives。執行以下指令可以清除：

Bash

sudo apt-get clean

Docker 容器與鏡像

如果你有安裝 Docker，過期的鏡像（Images）和停止的容器（Containers）非常佔空間。你可以透過這個指令直接清除所有沒在使用的 Docker 資源：

Bash

docker system prune -a

隱藏在刪除程序中的檔案

有一種情況是檔案已經刪除了，但空間沒釋放。這是因為某個程序還在讀取該檔案。你可以用這條指令找出這些「幽靈檔案」：

Bash

sudo lsof / | grep deleted

如果看到很大的檔案被列出，重啟該服務或是直接重新開機就能討回空間。

你想先從哪個目錄查起，或是需要我幫你分析特定目錄的內容嗎？

➜  ~ sudo du -h --max-depth=1 / 2>/dev/null | sort -hr
17G     /
9.5G    /var
6.0G    /usr
713M    /boot
216M    /root
159M    /home
6.9M    /etc
976K    /run
56K     /tmp
16K     /lost+found
4.0K    /Users
4.0K    /srv
4.0K    /opt
4.0K    /mnt
4.0K    /media
0       /sys
0       /proc
0       /dev

從你的查詢結果來看，最大宗的佔用集中在 /var (9.5G) 和 /usr (6.0G)。

追蹤 /var 目錄

/var 通常存放的是會變動的資料。最常見的兇手是日誌檔、套件快取或資料庫。請執行以下指令來縮小範圍：

Bash

sudo du -h --max-depth=1 /var 2>/dev/null | sort -hr

如果 /var/log 很大，通常是系統日誌堆積；如果 /var/lib 很大，則可能是 Docker 容器或是資料庫（如 MySQL）的數據庫檔案。

追蹤 /usr 目錄

/usr 佔用了 6.0G，這主要是系統安裝的軟體和函式庫。雖然 6G 對於現代 Linux 來說還在合理範圍，但如果你的 VPS 只有跑簡單服務，這可能代表裝了太多沒用的套件。你可以檢查看看是哪個子目錄最胖：

Bash

sudo du -h --max-depth=1 /usr 2>/dev/null | sort -hr

關於 /boot 的提醒

雖然 /boot 只佔了 713M，但對於某些 VPS 預設的磁碟分割來說，這可能會造成更新時空間不足。這通常是舊版的 Linux 核心（Kernel）堆積造成的。

你可以先執行 /var 的查詢指令，把結果貼出來，我們直接針對大頭進行清理嗎？

➜  ~ sudo du -h --max-depth=1 /var 2>/dev/null | sort -hr
9.5G    /var
9.3G    /var/lib
140M    /var/log
9.2M    /var/cache
632K    /var/backups
36K     /var/tmp
32K     /var/www
28K     /var/crash
16K     /var/spool
4.0K    /var/opt
4.0K    /var/mail
4.0K    /var/local

兇手已經抓到了，就是 /var/lib 這個目錄，它佔用了高達 9.3G。

在 Linux 中，/var/lib 是用來存放應用程式運行時狀態資料的地方。最常佔用這個位置的通常是 Docker 或資料庫檔案。

繼續深入定位

請執行以下指令，看看 /var/lib 裡面到底是哪個程式佔用了空間：

Bash

sudo du -h --max-depth=1 /var/lib 2>/dev/null | sort -hr

常見的情況預測

1. 如果是 /var/lib/docker：這代表 Docker 的鏡像檔（Images）、容器層或是卷軸（Volumes）堆積太多。你可以先用 docker system df 確認 Docker 的空間使用狀況。
2. 如果是 /var/lib/mysql 或 /var/lib/postgresql：這代表你的資料庫資料量很大，或者是日誌檔（如 binlog）沒清理。
3. 如果是 /var/lib/snapd：代表你使用 Snap 安裝了許多套件，它會保留舊版本的檔案。

你可以跑一下上面的指令，把前幾名列出來看看嗎？

➜  ~ sudo du -h --max-depth=1 /var/lib 2>/dev/null | sort -hr
9.3G    /var/lib
8.9G    /var/lib/mysql
273M    /var/lib/apt
91M     /var/lib/mecab
52M     /var/lib/dpkg
6.2M    /var/lib/ubuntu-advantage
3.4M    /var/lib/command-not-found
704K    /var/lib/usbutils
556K    /var/lib/systemd
316K    /var/lib/fwupd
124K    /var/lib/ucf
40K     /var/lib/polkit-1
36K     /var/lib/PackageKit
28K     /var/lib/pam
24K     /var/lib/nginx
20K     /var/lib/update-notifier
16K     /var/lib/grub
12K     /var/lib/update-manager
8.0K    /var/lib/vim
8.0K    /var/lib/ubuntu-release-upgrader
8.0K    /var/lib/sudo
8.0K    /var/lib/logrotate
8.0K    /var/lib/landscape
8.0K    /var/lib/cloud
8.0K    /var/lib/apport
4.0K    /var/lib/usb_modeswitch
4.0K    /var/lib/upower
4.0K    /var/lib/unattended-upgrades
4.0K    /var/lib/udisks2
4.0K    /var/lib/tpm
4.0K    /var/lib/python
4.0K    /var/lib/private
4.0K    /var/lib/plymouth
4.0K    /var/lib/os-prober
4.0K    /var/lib/mysql-upgrade
4.0K    /var/lib/mysql-keyring
4.0K    /var/lib/mysql-files
4.0K    /var/lib/misc
4.0K    /var/lib/man-db
4.0K    /var/lib/git
4.0K    /var/lib/fail2ban
4.0K    /var/lib/dhcp
4.0K    /var/lib/dbus
4.0K    /var/lib/boltd

結果非常明顯，佔用空間的元兇是 /var/lib/mysql，它獨自佔用了 8.9G。這代表你的 MySQL 資料庫存放了大量的數據，或者是產生了過多的日誌檔案。

檢查 MySQL 內部佔用

通常資料庫變大有兩個原因：一個是你的資料表真的很肥，另一個是開啟了 Binary Log（二進位日誌），這會記錄所有對資料庫的更動，主要用於備援與同步，但非常吃空間。

你可以進到該目錄看看有哪些大檔案：

Bash

sudo ls -lh /var/lib/mysql | sort -k 5 -rh | head -n 10

常見的清理方向

如果看到很多檔名類似 binlog.0000X 的檔案，那可以透過以下方式清理：

1. 登入 MySQL：sudo mysql -u root -p
2. 執行指令清理過舊的日誌（例如保留最近 3 天）：PURGE BINARY LOGS BEFORE NOW() - INTERVAL 3 DAY;
3. 或者是直接限制日誌保留的天數，修改 /etc/mysql/my.cnf 裡面的 binlog_expire_logs_seconds 設定。

檢查特定的資料庫

如果你想知道是哪個資料庫（Database）或資料表（Table）最胖，可以登入 MySQL 後執行這段 SQL：

SQL

SELECT table_schema AS "Database", 
ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) AS "Size (MB)" 
FROM information_schema.TABLES 
GROUP BY table_schema;

這能幫你確認是哪個專案的資料量異常。

需要我幫你看看 ls -lh 的結果，來判斷是數據檔還是日誌檔造成的嗎？

➜  ~ sudo ls -lh /var/lib/mysql | sort -k 5 -rh | head -n 10
-rw-r----- 1 mysql mysql 101M Jan  9 19:40 binlog.000032
-rw-r----- 1 mysql mysql 101M Jan  9 12:41 binlog.000031
-rw-r----- 1 mysql mysql 101M Jan  9 06:00 binlog.000030
-rw-r----- 1 mysql mysql 101M Jan  8 20:21 binlog.000028
-rw-r----- 1 mysql mysql 101M Jan  8 13:01 binlog.000027
-rw-r----- 1 mysql mysql 101M Jan  8 06:27 binlog.000026
-rw-r----- 1 mysql mysql 101M Jan  7 19:42 binlog.000024
-rw-r----- 1 mysql mysql 101M Jan  7 12:41 binlog.000023
-rw-r----- 1 mysql mysql 101M Jan  7 06:00 binlog.000022
-rw-r----- 1 mysql mysql 101M Jan  6 20:21 binlog.000020

從結果來看，你的 MySQL 產生了大量的 binlog（二進位日誌）。雖然單個檔案只有 101M，但數量顯然非常驚人，這就是吃掉你 8.9G 空間的主要原因。

解決方案：清理 binlog

這些檔案記錄了資料庫的所有更動，如果你沒有做資料庫主從同步（Replication）的需求，可以安全地清理它們。

請先登入 MySQL：

Bash

sudo mysql -u root -p

進入後執行以下指令，只保留最近 1 天的日誌（這會立即釋放大量空間）：

SQL

PURGE BINARY LOGS BEFORE NOW() - INTERVAL 1 DAY;

如果你完全不需要這些日誌，也可以直接刪除所有舊日誌，只保留目前正在使用的一個：

SQL

RESET MASTER;

預防措施：限制日誌保留天數

為了避免之後空間又被塞滿，建議修改 MySQL 設定檔。請編輯 /etc/mysql/mysql.conf.d/mysqld.cnf（或是 /etc/mysql/my.cnf）：

使用指令:

vi /etc/mysql/mysql.conf.d/mysqld.cnf

1. 找到
   binlog_expire_logs_seconds
   或
   expire_logs_days（舊版）。
2. 設定較短的過期時間。例如保留 3 天（$3 \times 24 \times 3600 = 259200$ 秒）：
   binlog_expire_logs_seconds = 259200
   (預設值是 2592000)
3. 儲存後重啟 MySQL：
   sudo systemctl restart mysql

執行完 PURGE 或 RESET MASTER 後，你可以再次執行 df -h 看看，空間應該會釋放好幾個 G。需要我幫你確認目前的設定檔位置嗎？

為什麼會有這個需求? 以 user_id 為例, 有可能有2個欄位都是儲存 user_id, 但是是不同帳號的 user_id, 希望在 select 的 join 之後, 可以顯示出這2個不同的 user_id 欄位裡的 usre_name.

SELECT toD.dom_url AS ToURL, 
    fromD.dom_url AS FromUrl, 
    rvw.*

FROM reviews AS rvw

LEFT JOIN domain AS toD 
    ON toD.Dom_ID = rvw.rev_dom_for

LEFT JOIN domain AS fromD 
    ON fromD.Dom_ID = rvw.rev_dom_from

you can use Alias

資料來源:
https://stackoverflow.com/questions/50007406/mysql-left-join-same-table-twice-with-same-field

解法:

If you don’t want to (explicitly) use temporary tables, this will work:

SELECT tmp_table.id
FROM tmp_table
LEFT JOIN users u ON tmp_table.id = u.id
WHERE u.id IS NULL;

Demo

Create the temporary table:

CREATE TABLE a_table (id INT);
CREATE TABLE b_table (id INT);

Insert values:

INSERT INTO a_table (id) values (1),(2),(3),(4),(5);
INSERT INTO b_table (id) values (1),(3),(5);

Check A not in B, should select 2,4:

select a_table.id
from a_table
left join b_table on a_table.id = b_table.id
where b_table.id is null;

相直接刪掉這些不同步的資料, 在 MS SQL 很簡單, 但在 MYSQL 很麻煩，下面的語法會顯示錯誤:

delete from a_table
left join b_table on a_table.id = b_table.id
where b_table.id is null;

修改成這樣，也是錯：

DELETE a_table.*
FROM a_table
WHERE a_table.id IN (SELECT id
             FROM (SELECT a_table.id from a_table
left join b_table on a_table.id = b_table.id
where b_table.id is null));

但是，非常神奇的是，加了一個 x 一切就OK了, 什麼鬼, 太難理解!

DELETE a_table.*
FROM a_table
WHERE a_table.id IN (SELECT id
             FROM (SELECT a_table.id from a_table
left join b_table on a_table.id = b_table.id
where b_table.id is null) x);

最後, 刪掉測試用 table:

drop table a_table;
drop table b_table;

附註: 在測試沒驗證過的 sql command 前, 請先備份 database, 以免重要資料在非預期的狀態下被 delete command 刪掉…。

資料來源

SELECT that returns list of values not occurring in any row
https://stackoverflow.com/questions/10013475/select-that-returns-list-of-values-not-occurring-in-any-row

Query to Check for Values Not Matching List in Where Clause
https://stackoverflow.com/questions/72218215/query-to-check-for-values-not-matching-list-in-where-clause

open up your mysqld.cnf file:

sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

修改

bind-address = 127.0.0.1

為

bind-address = 0.0.0.0

重啟 server

sudo systemctl restart mysql

照下面的格式, 建立使用者:

CREATE USER 'your-account'@'remote_server_ip' IDENTIFIED BY 'account-password';

給權限:

GRANT CREATE, INDEX, ALTER, DROP, INSERT, UPDATE, DELETE, SELECT, REFERENCES on database_name.* TO 'your-account'@'remote_server_ip' WITH GRANT OPTION;

FLUSH PRIVILEGES;

附註：如果這個帳號，沒有權限可以使用create index 的話，請把 INDEX 這個項目刪除。

檢查用的 script:

SELECT user,host FROM mysql.user;

如果有必要的話, 要啟用防火牆規則:

If you only plan to access the database server from one specific machine, you can grant that machine exclusive permission to connect to the database remotely with the following command. Make sure to replace remote_IP_address with the actual IP address of the machine you plan to connect with:

sudo ufw allow from remote_IP_address to any port 3306

如果要允許, 所有的電腦都可以連到 3306 port: (被攻擊的風險較高)

sudo ufw allow 3306

Error Code: 1064. You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '05152018_bwamem.sam' where id=6' at line 1

遇到的 sql command:

update component set code='bwa  mem -t 4 -R ''@RG\ILLUMINA\''  05152018_bwamem.sam' where id=6;

發生的原因, \ (backslash) 在 mysql 是跳脫字元, 愈多跳脫, 就愈多問題!

解法:

Mysql 的 NO_BACKSLASH_ESCAPES
https://stackoverflow.max-everyday.com/2017/08/mysql-no_backslash_escapes/

修改檔案的 /etc/my.cnf.d/mysql-server.cnf

[mysqld]
datadir=/var/lib/mysql
socket=/var/lib/mysql/mysql.sock
log-error=/var/log/mysql/mysqld.log
pid-file=/run/mysqld/mysqld.pid

sql_mode=ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION,NO_BACKSLASH_ESCAPES

說明: 就只有增加 sql_mode= 這行指令. 並重啟 mysql server:

sudo service mysqld restart