这个问题很好,不过我感觉是问产品的,不是问测试的。
如果测试能有这种视野当然更好,属于锦上添花的事情,但也就更好仅此而已。
现在整体行业,想要拿到高工资,懂技术是必备的。
也许大家都很不爽,测试为啥需要懂那么多技术,甚至还要刷算法,我点点点需要啥玩意算法。
但事实就如此,个人力量是无法改变行业趋势,懂技术就是比纯点点点的工资更高。
这一切的前提都是工作就是为了搞钱,如果纯为了乐趣,点点点也很快乐,那就另说。
这三个用途都完全不一样啊,先搞清楚需求。
另外,没必要买最新款的,买二手,官翻的性价比高很多,特别适合预算不足的情况
整体上来说,员工薪水是市场决定的。
当然,也会存在很多和市场不匹配的个例。
这是因为市场价格和当前员工薪是不同步,或者企业故意为之
转行做啥哦
确实,怎么发现好多人结婚好难呀
婚纱照是跟老婆挑了一家私人定制来拍,大概 7k 左右
没有订婚,没有定亲
彩礼是我妈直接跟丈母娘沟通的,我至今都不知道具体数字,只知道大概是 3w 多
3 金是老婆家拿彩礼买的
婚礼的酒席是我爸安排的,在广东三线城市的老家 40 桌不到,12w 左右
婚礼流程,舞台这些是我们请人设计,主持司仪是老婆的好朋友
这一套下来,整体花费跟部分省份的彩礼起步价差不多
结婚整体还是蛮顺利的,唯一的遗憾就是因为口罩,导致老婆很多朋友闺蜜不能来
可以说甲方就是牛批:我可以不用,但你得有
也可以换个角度:
哈哈哈,符合阿里高管的作风。
其实都一样,新高管入职都会搞类似的动作。。
通勤方面说一下个人的感受:
如果单身的话,可以考虑在公司附近的小区合租,不要住城中村。缩短通勤幸福感提升超级明显!!!
我在福田市中心合租 2k 多点就行,电梯老小区。很多城中村也差不多这个价格,甚至更贵。
住得近,通勤骑小电驴 10min 不到,比起 1h 的地铁要好太多了!
本来下班血槽就差不多空了,但是还要快 1h 通勤,要命啊。
早上又要一大早起来挤地铁,太难受了。
多出来的时间,大概率也不会用来学习,但身体感受会很爽,整个人都开心多了。
正 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 倍
使用 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()