• 这个问题很好,不过我感觉是问产品的,不是问测试的。

    如果测试能有这种视野当然更好,属于锦上添花的事情,但也就更好仅此而已。

    现在整体行业,想要拿到高工资,懂技术是必备的。

    也许大家都很不爽,测试为啥需要懂那么多技术,甚至还要刷算法,我点点点需要啥玩意算法。

    但事实就如此,个人力量是无法改变行业趋势,懂技术就是比纯点点点的工资更高。

    这一切的前提都是工作就是为了搞钱,如果纯为了乐趣,点点点也很快乐,那就另说。

  • 这三个用途都完全不一样啊,先搞清楚需求。

    另外,没必要买最新款的,买二手,官翻的性价比高很多,特别适合预算不足的情况

  • 整体上来说,员工薪水是市场决定的。

    当然,也会存在很多和市场不匹配的个例。

    这是因为市场价格和当前员工薪是不同步,或者企业故意为之

  • 准备转行了 at 2025年05月12日

    转行做啥哦

  • 确实,怎么发现好多人结婚好难呀
    婚纱照是跟老婆挑了一家私人定制来拍,大概 7k 左右
    没有订婚,没有定亲

    彩礼是我妈直接跟丈母娘沟通的,我至今都不知道具体数字,只知道大概是 3w 多

    3 金是老婆家拿彩礼买的

    婚礼的酒席是我爸安排的,在广东三线城市的老家 40 桌不到,12w 左右

    婚礼流程,舞台这些是我们请人设计,主持司仪是老婆的好朋友

    这一套下来,整体花费跟部分省份的彩礼起步价差不多😂

    结婚整体还是蛮顺利的,唯一的遗憾就是因为口罩,导致老婆很多朋友闺蜜不能来

  • 可以说甲方就是牛批:我可以不用,但你得有😁

    也可以换个角度:

    • 现在是不用,以后要用到了,有经验肯定会更好
    • 没大厂经历,没有名校毕业,就相当于没有证明过,那就是当没潜力处理了
  • 哈哈哈,符合阿里高管的作风。

    其实都一样,新高管入职都会搞类似的动作。。

  • 逃离一线城市怎么样? at 2025年04月14日

    通勤方面说一下个人的感受:

    如果单身的话,可以考虑在公司附近的小区合租,不要住城中村。缩短通勤幸福感提升超级明显!!!
    我在福田市中心合租 2k 多点就行,电梯老小区。很多城中村也差不多这个价格,甚至更贵。
    住得近,通勤骑小电驴 10min 不到,比起 1h 的地铁要好太多了!
    本来下班血槽就差不多空了,但是还要快 1h 通勤,要命啊。

    早上又要一大早起来挤地铁,太难受了。

    多出来的时间,大概率也不会用来学习,但身体感受会很爽,整个人都开心多了。

  • 近两个月的求职面经总结 at 2025年04月11日

    正 hao,是正浩对吧,之前练手面过,有被恶心到

  • 实战结果

    实践出真知,那就跑起来吧。
    先说结论

    有索引的情况下

    耗时绝对值都是比较小的。
    INNER JOIN 执行时间: 0.0093 秒
    LEFT JOIN 执行时间: 0.0078 秒
    性能差异: LEFT JOIN 比 INNER JOIN 慢 0.84 倍

    无索引情况

    无索引 INNER JOIN 执行时间: 0.2907 秒
    无索引 LEFT JOIN 执行时间: 24.5531 秒
    无索引性能差异: LEFT JOIN 比 INNER JOIN 慢 84.47 倍

    $ python test_inner_join_left_join.py
    数据库创建成功
    表结构创建成功
    正在生成左表数据...
    左表已插入 0 行
    ...
    左表数据生成完成:1000行
    正在生成右表数据...
    右表已插入 10000 行
    ....
    右表已插入 980000 行
    右表已插入 990000 行
    右表已插入 1000000 行
    右表数据生成完成:1,000,000行
    为右表的join_key添加索引...
    索引添加成功
    
    测试 INNER JOIN:
    执行计划分析:
    (1, 'SIMPLE', 'l', 'ALL', 'join_key', None, None, None, '1000', 'Using where')
    (1, 'SIMPLE', 'r', 'ref', 'idx_join_key', 'idx_join_key', '5', 'test_inner_join_left_join.l.join_key', '50', '')
    INNER JOIN 匹配记录数: 100051
    INNER JOIN 执行时间: 0.0093 秒
    
    测试 LEFT JOIN:
    执行计划分析:
    (1, 'SIMPLE', 'l', 'ALL', None, None, None, None, '1000', '')
    (1, 'SIMPLE', 'r', 'ref', 'idx_join_key', 'idx_join_key', '5', 'test_inner_join_left_join.l.join_key', '50', 'Using where')
    LEFT JOIN 匹配记录数: 100051
    LEFT JOIN 执行时间: 0.0078 秒
    
    性能差异: LEFT JOIN 比 INNER JOIN 慢 0.84 倍
    
    测试移除索引后的性能:
    已移除右表索引
    
    测试无索引的 INNER JOIN:
    执行计划分析:
    (1, 'SIMPLE', 'r', 'ALL', None, None, None, None, '997003', 'Using where')
    (1, 'SIMPLE', 'l', 'ref', 'join_key', 'join_key', '5', 'test_inner_join_left_join.r.join_key', '1', '')
    无索引 INNER JOIN 匹配记录数: 100051
    无索引 INNER JOIN 执行时间: 0.2907 秒
    
    测试无索引的 LEFT JOIN:
    执行计划分析:
    (1, 'SIMPLE', 'l', 'ALL', None, None, None, None, '1000', '')
    (1, 'SIMPLE', 'r', 'ALL', None, None, None, None, '997003', 'Using where; Using join buffer (flat, BNL join)')
    无索引 LEFT JOIN 匹配记录数: 100051
    无索引 LEFT JOIN 执行时间: 24.5531 秒
    
    无索引性能差异: LEFT JOIN 比 INNER JOIN 慢 84.47 倍
    

    Prompt


    使用 Cursor + sonnet3.7 模型

    在mysql中,请帮我写程序来验证下面的的结论:
    连接信息是:        
    "HOST": "127.0.0.1",
            "PORT": 3306,
            "USER": "root",
            "PASSWORD": "root",
    db重新创建一个,名为test_inner_join_left_join
    
    优先选 INNER JOIN:若只需匹配数据,效率通常更高。
    谨慎用 LEFT JOIN:仅在需要保留左表所有行时使用,并确保右表连接键有索引。
    实际验证:通过 EXPLAIN 分析执行计划,观察是否触发全表扫描或低效操作。
    

    实际代码

    import pymysql
    import time
    import random
    
    # 数据库连接信息
    DB_CONFIG = {
        "host": "127.0.0.1",
        "port": 3306,
        "user": "root",
        "password": "root",
    }
    
    def create_database():
        """创建新数据库"""
        conn = pymysql.connect(**DB_CONFIG)
        cursor = conn.cursor()
    
        try:
            # 删除已存在的数据库(如果有)
            cursor.execute("DROP DATABASE IF EXISTS test_inner_join_left_join")
            # 创建新数据库
            cursor.execute("CREATE DATABASE test_inner_join_left_join")
            print("数据库创建成功")
        except Exception as e:
            print(f"创建数据库失败: {e}")
        finally:
            cursor.close()
            conn.close()
    
    def setup_tables():
        """创建表结构"""
        # 连接到新创建的数据库
        conn = pymysql.connect(
            **DB_CONFIG,
            database="test_inner_join_left_join"
        )
        cursor = conn.cursor()
    
        try:
            # 创建左表 - 较小的表 (1000行)
            cursor.execute("""
            CREATE TABLE left_table (
                id INT AUTO_INCREMENT PRIMARY KEY,
                join_key INT,
                data VARCHAR(100),
                INDEX (join_key)
            )
            """)
    
            # 创建右表 - 较大的表 (100万行)
            cursor.execute("""
            CREATE TABLE right_table (
                id INT AUTO_INCREMENT PRIMARY KEY,
                join_key INT,
                data VARCHAR(100)
            )
            """)
    
            print("表结构创建成功")
            conn.commit()
        except Exception as e:
            print(f"创建表结构失败: {e}")
            conn.rollback()
        finally:
            cursor.close()
            conn.close()
    
    def generate_data():
        """生成测试数据"""
        conn = pymysql.connect(
            **DB_CONFIG,
            database="test_inner_join_left_join"
        )
        cursor = conn.cursor()
    
        try:
            # 为左表生成1000行数据
            print("正在生成左表数据...")
            for i in range(1000):
                join_key = random.randint(1, 2000)  # 随机生成连接键
                data = f"Left data {i}"
                cursor.execute(
                    "INSERT INTO left_table (join_key, data) VALUES (%s, %s)",
                    (join_key, data)
                )
    
                if i % 200 == 0:
                    conn.commit()
                    print(f"左表已插入 {i} 行")
    
            conn.commit()
            print("左表数据生成完成:1000行")
    
            # 为右表生成100万行数据
            print("正在生成右表数据...")
            batch_size = 10000
            for i in range(1, 1000001):
                join_key = random.randint(1, 10000)  # 随机生成连接键
                data = f"Right data {i}"
                cursor.execute(
                    "INSERT INTO right_table (join_key, data) VALUES (%s, %s)",
                    (join_key, data)
                )
    
                if i % batch_size == 0:
                    conn.commit()
                    print(f"右表已插入 {i} 行")
    
            conn.commit()
            print("右表数据生成完成:1,000,000行")
        except Exception as e:
            print(f"生成数据失败: {e}")
            conn.rollback()
        finally:
            cursor.close()
            conn.close()
    
    def add_index_to_right_table():
        """为右表的连接键添加索引"""
        conn = pymysql.connect(
            **DB_CONFIG,
            database="test_inner_join_left_join"
        )
        cursor = conn.cursor()
    
        try:
            print("为右表的join_key添加索引...")
            cursor.execute("CREATE INDEX idx_join_key ON right_table(join_key)")
            conn.commit()
            print("索引添加成功")
        except Exception as e:
            print(f"添加索引失败: {e}")
            conn.rollback()
        finally:
            cursor.close()
            conn.close()
    
    def test_join_performance():
        """测试两种连接方式的性能差异"""
        conn = pymysql.connect(
            **DB_CONFIG,
            database="test_inner_join_left_join"
        )
        cursor = conn.cursor()
    
        try:
            # 测试INNER JOIN
            print("\n测试 INNER JOIN:")
            print("执行计划分析:")
            cursor.execute("""
            EXPLAIN SELECT l.id, l.data, r.data
            FROM left_table l
            INNER JOIN right_table r ON l.join_key = r.join_key
            """)
    
            explain_result = cursor.fetchall()
            for row in explain_result:
                print(row)
    
            # 测量INNER JOIN执行时间
            start_time = time.time()
            cursor.execute("""
            SELECT COUNT(*)
            FROM left_table l
            INNER JOIN right_table r ON l.join_key = r.join_key
            """)
            inner_count = cursor.fetchone()[0]
            inner_time = time.time() - start_time
            print(f"INNER JOIN 匹配记录数: {inner_count}")
            print(f"INNER JOIN 执行时间: {inner_time:.4f} 秒")
    
            # 测试LEFT JOIN
            print("\n测试 LEFT JOIN:")
            print("执行计划分析:")
            cursor.execute("""
            EXPLAIN SELECT l.id, l.data, r.data
            FROM left_table l
            LEFT JOIN right_table r ON l.join_key = r.join_key
            """)
    
            explain_result = cursor.fetchall()
            for row in explain_result:
                print(row)
    
            # 测量LEFT JOIN执行时间
            start_time = time.time()
            cursor.execute("""
            SELECT COUNT(*)
            FROM left_table l
            LEFT JOIN right_table r ON l.join_key = r.join_key
            """)
            left_count = cursor.fetchone()[0]
            left_time = time.time() - start_time
            print(f"LEFT JOIN 匹配记录数: {left_count}")
            print(f"LEFT JOIN 执行时间: {left_time:.4f} 秒")
    
            # 计算性能差异
            print(f"\n性能差异: LEFT JOIN 比 INNER JOIN 慢 {left_time/inner_time:.2f} 倍")
    
            # 测试没有索引的情况
            print("\n测试移除索引后的性能:")
            cursor.execute("DROP INDEX idx_join_key ON right_table")
            print("已移除右表索引")
    
            # 再次测试INNER JOIN (无索引)
            print("\n测试无索引的 INNER JOIN:")
            print("执行计划分析:")
            cursor.execute("""
            EXPLAIN SELECT l.id, l.data, r.data
            FROM left_table l
            INNER JOIN right_table r ON l.join_key = r.join_key
            """)
    
            explain_result = cursor.fetchall()
            for row in explain_result:
                print(row)
    
            # 测量无索引INNER JOIN执行时间
            start_time = time.time()
            cursor.execute("""
            SELECT COUNT(*)
            FROM left_table l
            INNER JOIN right_table r ON l.join_key = r.join_key
            """)
            inner_count_no_idx = cursor.fetchone()[0]
            inner_time_no_idx = time.time() - start_time
            print(f"无索引 INNER JOIN 匹配记录数: {inner_count_no_idx}")
            print(f"无索引 INNER JOIN 执行时间: {inner_time_no_idx:.4f} 秒")
    
            # 测试无索引的LEFT JOIN
            print("\n测试无索引的 LEFT JOIN:")
            print("执行计划分析:")
            cursor.execute("""
            EXPLAIN SELECT l.id, l.data, r.data
            FROM left_table l
            LEFT JOIN right_table r ON l.join_key = r.join_key
            """)
    
            explain_result = cursor.fetchall()
            for row in explain_result:
                print(row)
    
            # 测量无索引LEFT JOIN执行时间
            start_time = time.time()
            cursor.execute("""
            SELECT COUNT(*)
            FROM left_table l
            LEFT JOIN right_table r ON l.join_key = r.join_key
            """)
            left_count_no_idx = cursor.fetchone()[0]
            left_time_no_idx = time.time() - start_time
            print(f"无索引 LEFT JOIN 匹配记录数: {left_count_no_idx}")
            print(f"无索引 LEFT JOIN 执行时间: {left_time_no_idx:.4f} 秒")
    
            # 计算无索引情况下的性能差异
            print(f"\n无索引性能差异: LEFT JOIN 比 INNER JOIN 慢 {left_time_no_idx/inner_time_no_idx:.2f} 倍")
    
        except Exception as e:
            print(f"测试连接性能失败: {e}")
        finally:
            cursor.close()
            conn.close()
    
    def run_test():
        """运行完整测试流程"""
        create_database()
        setup_tables()
        generate_data()
        add_index_to_right_table()
        test_join_performance()
    
    if __name__ == "__main__":
        run_test()
    

    相关配置


    总结

    • inner join 确实比 left join 性能更好,尤其是在没有右表索引时,都有索引时,100 万数据时,个人认为性能差距可忽略
    • 不管 inner join 和 left join,想要更好性能,都应该注意创建对应的索引