我正在处理一个项目，其中包含大量的数据库写入操作，我会说（70%插入和30%读取）。这个比例也包括更新操作，我认为一次更新操作相当于一次读取和一次写入操作。这些读取操作可以是不准确的（例如，我在读取时不需要100%准确的信息）。
所涉及的任务每小时将执行超过100万个数据库事务。
我在网上阅读了许多关于MyISAM和InnoDB之间区别的文章，对于我将用于此任务的特定数据库/表格而言，MyISAM似乎是显而易见的选择。从我所看到的内容来看，如果需要事务，则InnoDB非常适合，因为它支持行级锁定。
有没有人有这种负载（或更高）的经验？ MyISAM是否是最好的选择？
我已经在表格中简要讨论了这个问题，以便您可以得出是否选择InnoDB或MyISAM的结论。
以下是应使用哪种db存储引擎的小概述：
MyISAM InnoDB ---------------------------------------------------------------- 需要全文搜索 是 5.6.4 ---------------------------------------------------------------- 需要事务 是 ---------------------------------------------------------------- 频繁进行select查询 是 ---------------------------------------------------------------- 频繁进行insert、update和delete操作 是 ---------------------------------------------------------------- 行锁定（单个表上的多处理） 是 ---------------------------------------------------------------- 关系型基础设计 是
总结
InnoDB - full-text: 5.6.4 是什么意思？它是否存在？ - user4795756我不是一个数据库专家，也没有从经验中说话。然而：
MyISAM表使用表级锁定。根据您的流量估计，您每秒有近200个写入操作。使用MyISAM时，在任何时候只能进行其中之一。您必须确保硬件跟得上这些交易以避免被淹没，即单个查询不能超过5ms。
这提示我您需要一个支持行级锁定的存储引擎，即InnoDB。
另一方面，编写几个简单的脚本来模拟每个存储引擎的负载，然后比较结果应该是相当容易的。
人们经常谈论性能、读写操作、外键等等，但在我看来，存储引擎还必须具备一项非常重要的功能：原子更新。
试试这个：
killall -9 mysqld 来模拟崩溃，也可以正常工作。当然，性能是令人向往的，但不丢失数据应该比性能更加重要。
Bill Karwin。 - user3833682我曾经在一个使用MySQL的高容量系统上工作过，尝试过MyISAM和InnoDB两种引擎。
我发现MyISAM的表级锁定会对我们的工作负载造成严重的性能问题，这听起来与你们的情况相似。不幸的是，我也发现InnoDB的性能也不如我所希望的那样好。
最终，我通过将数据分片来解决争用问题，使得插入操作进入“热”表格，而查询操作从未查询过热表格。
这也允许删除操作（数据是时间敏感的，我们只保留X天）发生在“陈旧”的表格上，这些表格也不会被查询操作触及。InnoDB在批量删除方面的性能似乎很差，因此，如果你计划清除数据，你可能需要设计一种结构，使得旧数据位于一个可以简单删除的“陈旧”表格中，而不是在该表格上运行删除操作。
当然，我不知道你的应用程序是什么，但希望这些信息可以为你提供关于MyISAM和InnoDB的一些问题的见解。
虽然有点晚了，但是这里有一篇我几个月前写的非常全面的文章，详细介绍MYISAM和InnoDB之间的主要区别。拿杯茶（或许还有饼干），享受阅读。
MyISAM不支持事务，而InnoDB支持。
如果在使用MyISAM表时操作被中断，操作将立即中止，并且受影响的行（甚至是每行内的数据）仍然受影响，即使操作没有完成。
如果在使用InnoDB表时操作被中断，由于它使用了具有原子性的事务，任何未完成的事务都不会生效，因为没有提交。
当对MyISAM表运行查询时，将锁定正在查询的整个表。这意味着当前查询完成后才能执行后续查询。如果您正在读取大型表格和/或频繁进行读写操作，则可能会导致大量查询积压。
当对InnoDB表运行查询时，只锁定涉及的行，其余表格仍可用于CRUD操作。这意味着可以在同一表上同时运行查询，前提是它们不使用相同的行。
这个InnoDB中的特性被称为并发性。虽然并发性很棒，但是对于一些表格来说，存在一个主要缺点，即在内核线程之间切换会产生开销，因此您应该设置内核线程的限制，以防止服务器停止运行。如果需要进行更多的读写操作，你将受益于InnoDB。因为InnoDB提供的是行级锁而不是表级锁，你的 SELECT 语句可以并发执行，不仅仅是彼此之间，还可以与许多 INSERT 语句一起执行。但是，除非你打算使用SQL事务，否则将InnoDB提交刷新设置为2 (innodb_flush_log_at_trx_commit)。这样可以节约大量的原始性能，否则在从MyISAM转移到InnoDB时会损失很多性能。
另外，请考虑添加复制功能。这可以给你一些读取扩展性，并且由于你说明了读取不必实时，所以可以允许复制稍微滞后一些时间。只要确保它可以在除了最繁忙的流量之外的任何情况下追上来，否则它总是会落后并永远赶不上。然而，如果采用这种方式，我强烈建议你将从从库中读取和复制滞后管理隔离到数据库处理程序中。如果应用程序代码不知道这一点，那么这样做会更简单。
最后，请注意不同的表负载。你不会在所有表上拥有相同的读写比例。一些较小的表几乎全部都是读取，可以继续使用MyISAM。同样，如果你有一些表几乎全部都是写入，那么你可能会从 INSERT DELAYED 中受益，但这仅适用于MyISAM（对于InnoDB表，DELAYED子句将被忽略）。
但是要进行基准测试以确保效果。
innodb_flush_log_at_trx_commit吗？ - ceejayoz除了这些已经提到的机械差异，我还提供了一项实证速度比较研究。
就纯速度而言，并不总是MyISAM比InnoDB更快，但根据我的经验，在纯读取工作环境下，它往往比InnoDB快2.0-2.5倍。显然，这并不适用于所有环境——正如其他人所写的，MyISAM缺乏事务和外键等功能。
我在下面进行了一些基准测试，使用Python进行循环操作，使用timeit库进行时间比较。出于兴趣，我还包括了内存引擎，它在整体性能方面表现最佳，尽管它只适用于较小的表格（当超过MySQL内存限制时，你会不断遇到“表'tbl'已满”的情况）。我观察的四种选择类型为：
首先，我使用以下SQL创建了三个表：
CREATE TABLE
data_interrogation.test_table_myisam
(
index_col BIGINT NOT NULL AUTO_INCREMENT,
value1 DOUBLE,
value2 DOUBLE,
value3 DOUBLE,
value4 DOUBLE,
PRIMARY KEY (index_col)
)
ENGINE=MyISAM DEFAULT CHARSET=utf8
在第二个和第三个表中，将'MyISAM'替换为'InnoDB'和'memory'。
查询：SELECT * FROM tbl WHERE index_col = xx
结果：平局
它们的速度基本相同，并且预期是随要选择的列数线性增长的。InnoDB似乎比MyISAM快一些，但这差异微不足道。
代码：
import timeit
import MySQLdb
import MySQLdb.cursors
import random
from random import randint
db = MySQLdb.connect(host="...", user="...", passwd="...", db="...", cursorclass=MySQLdb.cursors.DictCursor)
cur = db.cursor()
lengthOfTable = 100000
# Fill up the tables with random data
for x in xrange(lengthOfTable):
rand1 = random.random()
rand2 = random.random()
rand3 = random.random()
rand4 = random.random()
insertString = "INSERT INTO test_table_innodb (value1,value2,value3,value4) VALUES (" + str(rand1) + "," + str(rand2) + "," + str(rand3) + "," + str(rand4) + ")"
insertString2 = "INSERT INTO test_table_myisam (value1,value2,value3,value4) VALUES (" + str(rand1) + "," + str(rand2) + "," + str(rand3) + "," + str(rand4) + ")"
insertString3 = "INSERT INTO test_table_memory (value1,value2,value3,value4) VALUES (" + str(rand1) + "," + str(rand2) + "," + str(rand3) + "," + str(rand4) + ")"
cur.execute(insertString)
cur.execute(insertString2)
cur.execute(insertString3)
db.commit()
# Define a function to pull a certain number of records from these tables
def selectRandomRecords(testTable,numberOfRecords):
for x in xrange(numberOfRecords):
rand1 = randint(0,lengthOfTable)
selectString = "SELECT * FROM " + testTable + " WHERE index_col = " + str(rand1)
cur.execute(selectString)
setupString = "from __main__ import selectRandomRecords"
# Test time taken using timeit
myisam_times = []
innodb_times = []
memory_times = []
for theLength in [3,10,30,100,300,1000,3000,10000]:
innodb_times.append( timeit.timeit('selectRandomRecords("test_table_innodb",' + str(theLength) + ')', number=100, setup=setupString) )
myisam_times.append( timeit.timeit('selectRandomRecords("test_table_myisam",' + str(theLength) + ')', number=100, setup=setupString) )
memory_times.append( timeit.timeit('selectRandomRecords("test_table_memory",' + str(theLength) + ')', number=100, setup=setupString) )
查询：SELECT count(*) FROM tbl
结果：MyISAM 胜出
这个示例展示了 MyISAM 和 InnoDB 之间的巨大差异 - MyISAM（和内存）跟踪表中记录的数量，因此此事务很快且 O(1)。在我调查的范围内，InnoDB 进行计数所需的时间随着表大小呈超线性增长。我怀疑实际观察到的 MyISAM 查询加速的许多效果都是由于类似的影响。
代码：
myisam_times = []
innodb_times = []
memory_times = []
# Define a function to count the records
def countRecords(testTable):
selectString = "SELECT count(*) FROM " + testTable
cur.execute(selectString)
setupString = "from __main__ import countRecords"
# Truncate the tables and re-fill with a set amount of data
for theLength in [3,10,30,100,300,1000,3000,10000,30000,100000]:
truncateString = "TRUNCATE test_table_innodb"
truncateString2 = "TRUNCATE test_table_myisam"
truncateString3 = "TRUNCATE test_table_memory"
cur.execute(truncateString)
cur.execute(truncateString2)
cur.execute(truncateString3)
for x in xrange(theLength):
rand1 = random.random()
rand2 = random.random()
rand3 = random.random()
rand4 = random.random()
insertString = "INSERT INTO test_table_innodb (value1,value2,value3,value4) VALUES (" + str(rand1) + "," + str(rand2) + "," + str(rand3) + "," + str(rand4) + ")"
insertString2 = "INSERT INTO test_table_myisam (value1,value2,value3,value4) VALUES (" + str(rand1) + "," + str(rand2) + "," + str(rand3) + "," + str(rand4) + ")"
insertString3 = "INSERT INTO test_table_memory (value1,value2,value3,value4) VALUES (" + str(rand1) + "," + str(rand2) + "," + str(rand3) + "," + str(rand4) + ")"
cur.execute(insertString)
cur.execute(insertString2)
cur.execute(insertString3)
db.commit()
# Count and time the query
innodb_times.append( timeit.timeit('countRecords("test_table_innodb")', number=100, setup=setupString) )
myisam_times.append( timeit.timeit('countRecords("test_table_myisam")', number=100, setup=setupString) )
memory_times.append( timeit.timeit('countRecords("test_table_memory")', number=100, setup=setupString) )
查询语句：SELECT * FROM tbl WHERE value1<0.5 AND value2<0.5 AND value3<0.5 AND value4<0.5
查询结果：MyISAM 胜出
在这个例子中，MyISAM 和内存表性能差不多，并且在处理更大的数据表时比 InnoDB 快50%左右。这是 MyISAM 的优势最大的查询类型之一。
代码：
myisam_times = []
innodb_times = []
memory_times = []
# Define a function to perform conditional selects
def conditionalSelect(testTable):
selectString = "SELECT * FROM " + testTable + " WHERE value1 < 0.5 AND value2 < 0.5 AND value3 < 0.5 AND value4 < 0.5"
cur.execute(selectString)
setupString = "from __main__ import conditionalSelect"
# Truncate the tables and re-fill with a set amount of data
for theLength in [3,10,30,100,300,1000,3000,10000,30000,100000]:
truncateString = "TRUNCATE test_table_innodb"
truncateString2 = "TRUNCATE test_table_myisam"
truncateString3 = "TRUNCATE test_table_memory"
cur.execute(truncateString)
cur.execute(truncateString2)
cur.execute(truncateString3)
for x in xrange(theLength):
rand1 = random.random()
rand2 = random.random()
rand3 = random.random()
rand4 = random.random()
insertString = "INSERT INTO test_table_innodb (value1,value2,value3,value4) VALUES (" + str(rand1) + "," + str(rand2) + "," + str(rand3) + "," + str(rand4) + ")"
insertString2 = "INSERT INTO test_table_myisam (value1,value2,value3,value4) VALUES (" + str(rand1) + "," + str(rand2) + "," + str(rand3) + "," + str(rand4) + ")"
insertString3 = "INSERT INTO test_table_memory (value1,value2,value3,value4) VALUES (" + str(rand1) + "," + str(rand2) + "," + str(rand3) + "," + str(rand4) + ")"
cur.execute(insertString)
cur.execute(insertString2)
cur.execute(insertString3)
db.commit()
# Count and time the query
innodb_times.append( timeit.timeit('conditionalSelect("test_table_innodb")', number=100, setup=setupString) )
myisam_times.append( timeit.timeit('conditionalSelect("test_table_myisam")', number=100, setup=setupString) )
memory_times.append( timeit.timeit('conditionalSelect("test_table_memory")', number=100, setup=setupString) )
结果：InnoDB胜出
针对这个查询，我创建了一个额外的子查询表。每个表只有两列BIGINT，一列是主键索引，另一列没有任何索引。由于表格较大，我没有测试内存引擎。SQL表格创建命令如下：
CREATE TABLE
subselect_myisam
(
index_col bigint NOT NULL,
non_index_col bigint,
PRIMARY KEY (index_col)
)
ENGINE=MyISAM DEFAULT CHARSET=utf8;
在第二个表中，'MyISAM' 再次被替换为 'InnoDB'。
在这个查询中，我将选择表的大小保持在1000000，并改变子选择列的大小。
这里InnoDB轻松胜出。当我们达到一个合理大小的表时，两个引擎都随子选择大小线性扩展。索引加速了MyISAM命令，但有趣的是对InnoDB速度影响很小。subSelect.png
代码：
myisam_times = []
innodb_times = []
myisam_times_2 = []
innodb_times_2 = []
def subSelectRecordsIndexed(testTable,testSubSelect):
selectString = "SELECT * FROM " + testTable + " WHERE index_col in ( SELECT index_col FROM " + testSubSelect + " )"
cur.execute(selectString)
setupString = "from __main__ import subSelectRecordsIndexed"
def subSelectRecordsNotIndexed(testTable,testSubSelect):
selectString = "SELECT * FROM " + testTable + " WHERE index_col in ( SELECT non_index_col FROM " + testSubSelect + " )"
cur.execute(selectString)
setupString2 = "from __main__ import subSelectRecordsNotIndexed"
# Truncate the old tables, and re-fill with 1000000 records
truncateString = "TRUNCATE test_table_innodb"
truncateString2 = "TRUNCATE test_table_myisam"
cur.execute(truncateString)
cur.execute(truncateString2)
lengthOfTable = 1000000
# Fill up the tables with random data
for x in xrange(lengthOfTable):
rand1 = random.random()
rand2 = random.random()
rand3 = random.random()
rand4 = random.random()
insertString = "INSERT INTO test_table_innodb (value1,value2,value3,value4) VALUES (" + str(rand1) + "," + str(rand2) + "," + str(rand3) + "," + str(rand4) + ")"
insertString2 = "INSERT INTO test_table_myisam (value1,value2,value3,value4) VALUES (" + str(rand1) + "," + str(rand2) + "," + str(rand3) + "," + str(rand4) + ")"
cur.execute(insertString)
cur.execute(insertString2)
for theLength in [3,10,30,100,300,1000,3000,10000,30000,100000]:
truncateString = "TRUNCATE subselect_innodb"
truncateString2 = "TRUNCATE subselect_myisam"
cur.execute(truncateString)
cur.execute(truncateString2)
# For each length, empty the table and re-fill it with random data
rand_sample = sorted(random.sample(xrange(lengthOfTable), theLength))
rand_sample_2 = random.sample(xrange(lengthOfTable), theLength)
for (the_value_1,the_value_2) in zip(rand_sample,rand_sample_2):
insertString = "INSERT INTO subselect_innodb (index_col,non_index_col) VALUES (" + str(the_value_1) + "," + str(the_value_2) + ")"
insertString2 = "INSERT INTO subselect_myisam (index_col,non_index_col) VALUES (" + str(the_value_1) + "," + str(the_value_2) + ")"
cur.execute(insertString)
cur.execute(insertString2)
db.commit()
# Finally, time the queries
innodb_times.append( timeit.timeit('subSelectRecordsIndexed("test_table_innodb","subselect_innodb")', number=100, setup=setupString) )
myisam_times.append( timeit.timeit('subSelectRecordsIndexed("test_table_myisam","subselect_myisam")', number=100, setup=setupString) )
innodb_times_2.append( timeit.timeit('subSelectRecordsNotIndexed("test_table_innodb","subselect_innodb")', number=100, setup=setupString2) )
myisam_times_2.append( timeit.timeit('subSelectRecordsNotIndexed("test_table_myisam","subselect_myisam")', number=100, setup=setupString2) )
我认为所有这些的重点是，如果你真的关心速度，你需要基准测试你正在执行的查询，而不是对哪个引擎更合适做任何假设。
my.cnf文件没有针对InnoDB进行优化，那么MyISAM在大多数情况下可能会胜过InnoDB。您并没有提及您的my.cnf文件的具体内容，这实际上是影响InnoDB性能最重要的因素。 - itoctopus虽然有些离题，但为了文档目的和完整性，我想补充以下内容。
通常使用InnoDB将会导致应用程序更简单，可能也更少出现Bug。因为你可以将所有引用完整性(Foreign Key-constraints)放入数据模型中，所以需要的应用程序代码远不如使用MyISAM那么多。
每次插入、删除或替换记录时，都需要检查和维护关系。例如，如果你删除一个父项，所有子项也应该被删除。例如，在一个简单的博客系统中，如果你删除一个Blogposting记录，你还必须删除评论记录和点赞等。在InnoDB中，这是由数据库引擎自动完成的(如果在模型中指定了约束条件)，不需要应用程序代码。在MyISAM中，这必须被编写到应用程序中，而在Web服务器中非常困难。Web服务器天生就是非常并发/并行的，因为这些操作应该是原子的，而MyISAM不支持真正的事务，所以在Web服务器上使用MyISAM是有风险的 / 容易出错。
此外，在大多数一般情况下，InnoDB将表现得更好，其中一个原因是能够使用记录级别锁定，而不是表级别锁定。不仅在写操作比读操作频繁的情况下，还在处理大数据集上的复杂连接时。我们注意到，仅通过使用InnoDB表而不是MyISAM表，就可以将非常大的连接(花费几分钟)的性能提高三倍。
我认为，在使用MySQL时，通常应该选择InnoDB(使用一个完整的3NF数据模型和引用完整性)。MyISAM只应该在特定情况下使用。它很可能会表现得更差，导致应用程序变得更大且更容易出现Bug。
话虽如此，数据建模是一种很少在Web设计师/程序员中发现的艺术。不是针对你们，但这解释了为什么MyISAM被如此广泛地使用。
InnoDB提供：
ACID transactions
row-level locking
foreign key constraints
automatic crash recovery
table compression (read/write)
spatial data types (no spatial indexes)
在InnoDB中，除了TEXT和BLOB之外的行数据最多可以占用8,000个字节。InnoDB不支持全文本索引。在InnoDB中，当未使用WHERE、GROUP BY或JOIN时，COUNT(*)的执行速度比MyISAM慢，因为行计数没有在内部存储。InnoDB将数据和索引存储在一个文件中。InnoDB使用缓冲池来缓存数据和索引。
MyISAM提供：
fast COUNT(*)s (when WHERE, GROUP BY, or JOIN is not used)
full text indexing
smaller disk footprint
very high table compression (read only)
spatial data types and indexes (R-tree)
MyISAM具有表级锁定，但没有行级锁定。没有事务。没有自动崩溃恢复功能，但它提供了修复表功能。没有外键约束。与InnoDB表相比，MyISAM表在磁盘上通常更紧凑。如果需要，可以通过myisampack压缩MyISAM表以进一步减小尺寸，但表会变成只读。MyISAM在一个文件中存储索引，在另一个文件中存储数据。MyISAM使用关键字缓存索引，并将数据缓存管理留给操作系统。
总的来说，我推荐大多数情况下使用InnoDB，仅在特殊用途时使用MyISAM。新的MySQL版本中InnoDB现在是默认引擎。
这个问题和大多数答案都已经过时了.
是的，MyISAM比InnoDB更快是一个老掉牙的说法，注意问题的日期：2008年。现在已经过去了将近十年，InnoDB已经取得了重大的性能进展。
那张引人注目的图表只是针对一种情况，即COUNT(*)没有WHERE子句的情况下，MyISAM才获胜。但你真的会把时间花在这样的操作上吗？
如果您运行并发测试，InnoDB很可能会获胜，甚至击败MEMORY。
如果您在对SELECTs进行基准测试时执行任何写操作，则由于表级锁定，MyISAM和MEMORY可能会输。
实际上，Oracle非常确定InnoDB更好，以至于他们已经从8.0中除去了MyISAM。
问题是在5.1早期编写的。从那时起，这些主要版本被标记为“一般可用”：
最重要的是：不要使用MyISAM