从源码到实战盘点MySQL中不写Binlog的N种场景

// sql/binlog.cc
int binlog_log_row(TABLE *table, const uchar *before_record,
                   const uchar *after_record, Log_func *log_func) {
    THD *const thd = table->in_use;
    
    // 核心判断：当前操作是否需要写入binlog
    if (check_table_binlog_row_based(thd, table)) {
        // 写入表映射信息
        if (!write_locked_table_maps(thd)) {
            // 根据操作类型调用不同的日志函数
            error = (*log_func)(thd, table, has_trans, 
                                before_record, after_record);
        }
    }
    return error ? HA_ERR_RBR_LOGGING_FAILED : 0;
}

static bool check_table_binlog_row_based(THD *thd, TABLE *table) {
    // 缓存判断结果，避免重复计算
    if (table->s->cached_row_logging_check == -1) {
        int const check(
            table->s->tmp_table == NO_TMP_TABLE &&    // 不是临时表
            !table->no_replicate &&                    // 允许复制
            binlog_filter->db_ok(table->s->db.str)     // 库在复制白名单
        );
        table->s->cached_row_logging_check = check;
    }
    
    // 需要满足4个条件才返回true
    return (thd->is_current_stmt_binlog_format_row() &&   // 行格式
            table->s->cached_row_logging_check &&          // 表允许复制
            (thd->variables.option_bits & OPTION_BIN_LOG) && // 线程启用binlog
            mysql_bin_log.is_open());                        // binlog已打开
}

-- 创建临时表
CREATE TEMPORARY TABLE temp_user (
    id INT PRIMARY KEY,
    name VARCHAR(50)
);

-- 插入数据（不会写入binlog）
INSERT INTO temp_user VALUES (1, '张三');

-- 更新数据（不会写入binlog）
UPDATE temp_user SET name = '李四' WHERE id = 1;

// table->s->tmp_table == NO_TMP_TABLE 为false时，cached_row_logging_check为0
int const check(
    table->s->tmp_table == NO_TMP_TABLE &&  // 临时表时，此条件为false
    !table->no_replicate &&
    binlog_filter->db_ok(table->s->db.str)
);

-- 开启慢日志记录到表
SET GLOBAL log_output = 'TABLE';
SET GLOBAL slow_query_log = ON;

-- 执行慢查询
SELECT SLEEP(2);

-- 查看慢日志表（写入成功）
SELECT * FROM mysql.slow_log;

-- 但这些记录不会同步到从库！

// sql/table.cc - open_table_from_share函数
if ((share->table_category == TABLE_CATEGORY_LOG) ||
    (share->table_category == TABLE_CATEGORY_RPL_INFO) ||
    (share->table_category == TABLE_CATEGORY_GTID)) {
    outparam->no_replicate = true;  // 这些表设置no_replicate标志
}

// sql/table.h
enum enum_table_category {
  TABLE_CATEGORY_USER,      // 用户表
  TABLE_CATEGORY_LOG,       // 日志表
  TABLE_CATEGORY_RPL_INFO,  // 复制信息表
  TABLE_CATEGORY_GTID,      // GTID表
  TABLE_CATEGORY_INFORMATION_SCHEMA,  // 信息模式
  TABLE_CATEGORY_PERFORMANCE_SCHEMA   // 性能模式
};

-- 尝试修改performance_schema表（会报错）
UPDATE performance_schema.accounts SET CURRENT_CONNECTIONS = 10;
-- ERROR: 1044 (42000): Access denied for user

-- 但可以truncate（不会写入binlog）
TRUNCATE performance_schema.accounts;
-- Query OK, 0 rows affected

// 在Perfschema存储引擎的table_flags函数中
handler::Table_flags ha_perfschema::table_flags() const {
    return HA_REC_NOT_IN_SEQ | HA_NO_TRANSACTIONS | HA_NO_BINLOG;
    // HA_NO_BINLOG表示不支持binlog
}

else if (outparam->file) {
    const handler::Table_flags flags = outparam->file->ha_table_flags();
    outparam->no_replicate =
        !(flags & (HA_BINLOG_STMT_CAPABLE | HA_BINLOG_ROW_CAPABLE)) ||
        (flags & HA_HAS_OWN_BINLOGGING);
}

-- 关闭当前会话的binlog
SET SESSION sql_log_bin = 0;

-- 以下操作不会写入binlog
INSERT INTO user VALUES (100, '测试用户');
UPDATE user SET name = '新名字' WHERE id = 100;

-- 重新开启
SET SESSION sql_log_bin = 1;

static bool fix_sql_log_bin_after_update(sys_var *, THD *thd,
                                         enum_var_type type) {
    if (thd->variables.sql_log_bin)
        thd->variables.option_bits |= OPTION_BIN_LOG;   // 开启
    else
        thd->variables.option_bits &= ~OPTION_BIN_LOG;  // 关闭
    
    return false;
}

-- 场景1：批量导入大量数据，避免binlog暴涨
SET SESSION sql_log_bin = 0;
LOAD DATA INFILE '/data/big_data.csv' INTO TABLE history_data;
SET SESSION sql_log_bin = 1;

-- 场景2：从库配置不记录重放日志
-- 在从库上设置 log_replica_updates = OFF
-- 这样从库SQL线程重放的操作不写入自己的binlog

# my.cnf
[mysqld]
# MySQL 8.0之前
log_slave_updates = OFF

# MySQL 8.0+
log_replica_updates = OFF

void set_slave_thread_options(THD *thd) {
    ulonglong options = thd->variables.option_bits | OPTION_BIG_SELECTS;
    
    if (opt_log_replica_updates)
        options |= OPTION_BIN_LOG;      // 开启：从库操作记录binlog
    else
        options &= ~OPTION_BIN_LOG;     // 关闭：从库操作不记录binlog
}

class Disable_binlog_guard {
public:
    explicit Disable_binlog_guard(THD *thd)
        : m_thd(thd),
          m_binlog_disabled(thd->variables.option_bits & OPTION_BIN_LOG) {
        // 构造函数中关闭binlog
        thd->variables.option_bits &= ~OPTION_BIN_LOG;
    }
    
    ~Disable_binlog_guard() {
        // 析构函数中恢复
        if (m_binlog_disabled)
            m_thd->variables.option_bits |= OPTION_BIN_LOG;
    }
    
private:
    THD *const m_thd;
    const bool m_binlog_disabled;
};

static bool handle_bootstrap_impl(handle_bootstrap_args *args) {
    if (opt_initialize) {
        const Disable_binlog_guard disable_binlog(thd);
        // 初始化系统表，这些操作不写入binlog
        rc = process_iterator(thd, &comp_iter, true);
    }
}

bool upgrade_system_schemas(THD *thd) {
    Disable_binlog_guard disable_binlog(thd);
    // 升级系统表，不写入binlog
    err = fix_mysql_tables(thd) || fix_sys_schema(thd);
}

-- 1. OPTIMIZE TABLE
OPTIMIZE NO_WRITE_TO_BINLOG TABLE t1;
OPTIMIZE LOCAL TABLE t1;  -- LOCAL是NO_WRITE_TO_BINLOG的同义词

-- 2. ANALYZE TABLE
ANALYZE NO_WRITE_TO_BINLOG TABLE t1;

-- 3. REPAIR TABLE
REPAIR NO_WRITE_TO_BINLOG TABLE t1;

-- 4. FLUSH命令
FLUSH NO_WRITE_TO_BINLOG PRIVILEGES;
FLUSH LOCAL TABLES;  -- LOCAL版本

// sql/sql_yacc.yy - 语法解析部分
opt_no_write_to_binlog:
    /* Empty */ { $$ = false; }
  | NO_WRITE_TO_BINLOG_SYM { $$ = true; }
  | LOCAL_SYM { $$ = true; }
  ;

// 在语法规则中设置
repair_table_stmt:
    REPAIR opt_no_write_to_binlog TABLE ...
    {
        Lex->sql_command = SQLCOM_REPAIR;
        Lex->no_write_to_binlog = $2;  // 设置no_write_to_binlog标志
    }

-- 以下FLUSH命令即使不加NO_WRITE_TO_BINLOG，也不会写入binlog
FLUSH LOGS;
FLUSH BINARY LOGS;
FLUSH TABLES WITH READ LOCK;
FLUSH TABLES tbl_name ... FOR EXPORT;

-- performance_schema表支持TRUNCATE
TRUNCATE performance_schema.events_statements_summary_by_digest;

-- 但不会写入binlog
-- 从库不会执行这个TRUNCATE操作

// storage/perfschema/ha_perfschema.cc
int ha_perfschema::truncate() {
    // 直接清空内存数据结构
    reset_table_handles(m_table);
    return 0;
    // 不调用binlog_log_row，不写入binlog
}

-- 1. 不要期望慢日志表被复制
-- ❌ 错误想法：在从库查询慢日志
SELECT * FROM mysql.slow_log;  -- 从库可能是空的

-- ✅ 正确做法：在主库查询或通过监控系统收集

-- 2. 批量操作记得关闭binlog
-- 大批量数据导入
SET SESSION sql_log_bin = 0;
-- 执行批量操作
SET SESSION sql_log_bin = 1;

-- 3. 维护操作使用LOCAL关键字
OPTIMIZE LOCAL TABLE large_table;  -- 不写binlog，减少网络传输

# 从库配置：如果不是链式复制，建议关闭
[mysqld]
log_replica_updates = OFF
relay_log = relay-bin
read_only = ON