Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

32-bit architecture, CPU Architecture
404 errors, Application-Level Caching, Pregenerating Content
451 Group, Scaling by Clustering
64-bit architecture, CPU Architecture
:= assign operator, Using User-Defined Variables
@ user variable, Counting UPDATEs and INSERTs
@@ system variable, Syntax, Scope, and Dynamism

A

ab tool, Apache, Full-Stack Tools
Aborted_clients variable, Thread and Connection Statistics
Aborted_connects variable, Thread and Connection Statistics
access time, Choosing Hard Disks
access types, Rows examined and access types, The type Column
ACID transactions, Transactions, Clustrix
active caches, Caching
active data, keeping separate, Keeping active data separate
active-active access, Shared Storage or Replicated Disk
Adaptec controllers, Using RAID with SSDs
adaptive hash indexes, Hash indexes, INSERT BUFFER AND ADAPTIVE HASH INDEX
Adaptive Query Localization, MySQL Cluster (NDB Cluster), MySQL Cluster
Address Resolution Protocol (ARP), Moving IP addresses, Virtual IP Addresses or IP Takeover
Adminer, Interface Tools
admission control features, InnoDB Concurrency Configuration
advanced performance control, Advanced Performance Control
after-action reviews, Improving Mean Time to Recovery
aggregating sharded data, Aggregating Sharded Data
Ajax, Common Problems
Aker, Brian, User-Defined Functions, Forks and Variants of MySQL
Akiban, Scaling by Clustering, Akiban
algebraic equivalence rules, The query optimizer
algorithms, load-balancing, Load-balancing algorithms
ALL_O_DIRECT variable, How InnoDB opens and flushes log and data files
ALTER TABLE command, AUTOCOMMIT, ALTER TABLE, Speeding Up ALTER TABLE–Building MyISAM Indexes Quickly, Partitioned Tables, Master-Master in Active-Passive Mode, Allocating data, shards, and nodes
Amazon EBS (Elastic Block Store), MySQL in the Cloud, The Four Fundamental Resources
Amazon EC2 (Elastic Compute Cloud), MySQL in the Cloud, The Four Fundamental Resources–MySQL Performance in Cloud Hosting
Amazon RDS (Relational Database Service), MySQL in the Cloud, Amazon RDS
Amazon Web Services (AWS), MySQL in the Cloud
Amdahl scaling, A Formal Definition
Amdahl’s Law, Interpreting the Profile, A Formal Definition
ANALYZE TABLE command, Updating Index Statistics
ANSI SQL isolation levels, Isolation Levels
Apache ab, Full-Stack Tools
application-level optimization
alternatives to MySQL, Alternatives to MySQL
caching, Caching–Using HandlerSocket and memcached Access
common problems, Application-Level Optimization–Common Problems
extending MySQL, Extending MySQL
finding the optimal concurrency, Finding the Optimal Concurrency
web server issues, Web Server Issues
approximations, Using an approximation
Archive storage engine, The Archive engine, Table and index statistics
Aria storage engine, Community storage engines, MariaDB
ARP (Address Resolution Protocol), Moving IP addresses, Virtual IP Addresses or IP Takeover
Aslett, Matt, Scaling by Clustering
Aspersa (see Percona Toolkit)
asynchronous I/O, FILE I/O
asynchronous replication, Replication Overview
async_unbuffered, How InnoDB opens and flushes log and data files
atomicity, Transactions
attributes, Efficient and Scalable Full-Text Searching, Support for Attributes
audit plugins, Plugins
auditing, Why Backups?
authentication plugins, Plugins
auto-increment keys, Percona XtraDB Cluster
AUTOCOMMIT mode, AUTOCOMMIT
autogenerated schemas, Choosing Identifiers
AUTO_INCREMENT, Modifying Only the .frm File, Merge Tables, Writing to Both Masters in Master-Master Replication, Generating globally unique IDs
availability zone, Avoiding Single Points of Failure
AVG() function, Materialized Views
AWS (Amazon Web Services), MySQL in the Cloud

B

B-Tree indexes, B-Tree indexes, MyISAM’s data layout, Reducing Index and Data Fragmentation, The query optimizer, How to Use Partitioning
Background Patrol Read, RAID Failure, Recovery, and Monitoring
Backup & Recovery (Preston), Backup and Recovery
backup load, Online or Offline Backups?
backup time, Online or Offline Backups?
backup tools
Enterprise Backup, MySQL, MySQL Enterprise Backup
mydumper, mydumper
mylvmbackup, mylvmbackup
mysqldump, mysqldump
Percona XtraBackup, Percona XtraBackup
Zmanda Recovery Manager, Zmanda Recovery Manager
backups, Should You Use a SAN?, Backup and Recovery
binary logs, Managing and Backing Up Binary Logs–Purging Old Binary Logs Safely
data, Backing Up Data–Recovering from a Backup
designing a MySQL solution, Designing a MySQL Backup Solution–Replication
online or offline, Online or Offline Backups?
reasons for, Why Backups?
and replication, Problems Solved by Replication
scripting, Scripting Backups–Scripting Backups
snapshots not, Planning for LVM backups
and storage engines, Selecting the Right Engine
tools for, Backup and Recovery Tools–mysqldump
balanced trees, The execution plan
Barth, Wolfgang, Open Source Monitoring Tools
batteries in SSDs, Solid-State Drives (SSDs)
BBU (battery backup unit), The RAID cache
BEFORE INSERT trigger, Triggers
Beginning Database Design (Churcher), Optimizing Schema and Data Types
Bell, Charles, Summary
Benchmark Suite, Single-Component Tools, MySQL Benchmark Suite
BENCHMARK() function, Single-Component Tools
benchmarks, Benchmarking MySQL–Why Benchmark?
analyzing results, Running the Benchmark and Analyzing Results
capturing system performance and status, Capturing System Performance and Status
common mistakes, Benchmarking Tactics, What Not to Do
design and planning, Designing and Planning a Benchmark
examples, Benchmarking Examples–Percona’s TPCC-MySQL Tool
file copy, File Copy Benchmarks
flash memory, Benchmarking Flash Storage
getting accurate results, Getting Accurate Results
good uses for, Iterative Optimization by Benchmarking
how long to run, How Long Should the Benchmark Last?
iterative optimization by, Iterative Optimization by Benchmarking
MySQL versions read-only, A MySQL Timeline
plotting, The Importance of Plotting
SAN, SAN Benchmarks
strategies, Benchmarking Strategies–What to Measure
tactics, Benchmarking Tactics–The Importance of Plotting
tools, Full-Stack Tools–Single-Component Tools
what to measure, What to Measure
BerkeleyDB, A MySQL Timeline
BIGINT type, Whole Numbers
binary logs
backing up, Managing and Backing Up Binary Logs–Purging Old Binary Logs Safely
format, The Binary Log Format
master record changes (events), How Replication Works, Errors Caused by Data Corruption or Loss
purging old logs safely, Purging Old Binary Logs Safely
status, Binary Logging Status
binlog dump command, How Replication Works, Master, Distribution Master, and Replicas
binlog_do_db variable, Replication Filters
binlog_ignore_db variable, Replication Filters
Birthday Paradox, Handling hash collisions
BIT type, Bit-Packed Data Types
bit-packed data types, Bit-Packed Data Types
bitwise operations, Bit-Packed Data Types
Blackhole storage engine, The Blackhole engine, Master, Distribution Master, and Replicas, Emulating multisource replication
blktrace, Other Helpful Tools
BLOB type, The Memory engine, BLOB and TEXT types, Optimizing for BLOB and TEXT Workloads
blog, MySQL Performance, Column-oriented storage engines
BoardReader.com, Full-Text Searching on BoardReader.com, Optimizing GROUP BY on BoardReader.com
Boolean full-text searches, Boolean Full-Text Searches
Boost library, Drizzle
Bouman, Roland, Limitations of Views, Triggers, SQL Utilities
buffer pool
InnoDB, BUFFER POOL AND MEMORY
size of, Creating a MySQL Configuration File
buffer threads, FILE I/O
built-in MySQL engines, Other Built-in MySQL Engines–The NDB Cluster engine
bulletin boards, Bulletin boards and threaded discussion forums
burstable capacity, How Long Should the Benchmark Last?
bzip2, A One-Step Method

C

cache hits, Single-Component Tools, How MySQL Checks for a Cache Hit, What Not to Do, Caching, Reads, and Writes
CACHE INDEX command, The MyISAM Key Caches
cache tables, Cache and Summary Tables
cache units, What’s Your Working Set?
cachegrind, Instrumenting PHP Applications
caches
allocating memory for, Allocating Memory for Caches
control policies, Cache Control Policies
hierarchy, Balancing Memory and Disk Resources, Cache Object Hierarchies
invalidations, When the Query Cache Is Helpful
misses, When the Query Cache Is Helpful, The MyISAM Key Caches, Finding an Effective Memory-to-Disk Ratio
RAID, RAID Configuration and Caching
read-ahead data, The RAID cache
tuning by ratio, What Not to Do
writes, The RAID cache
Cacti, Network Configuration, Open Source Monitoring Tools
Calpont InfiniDB, Column-oriented storage engines
capacitors in SSDs, Solid-State Drives (SSDs)
capacity planning, Should You Use a SAN?, Replication and Capacity Planning
cardinality, Prefix Indexes and Index Selectivity, The query optimizer
case studies
building a queue table, Building a Queue Table in MySQL
computing the distance between points, Computing the Distance Between Points
diagnostics, A Case Study in Diagnostics–A Case Study in Diagnostics
indexing, An Indexing Case Study–Optimizing Sorts
using user-defined functions, Using User-Defined Functions
CD-ROM applications, CD-ROM applications
Change Data Capture (CDC) utilities, Materialized Views
CHANGE MASTER TO command, Starting the Replica, Initializing a Replica from Another Server, Changing Masters, Planned promotions, Undefined Server IDs
CHAR type, VARCHAR and CHAR types
character sets, Character Sets and Collations, Choosing a Character Set and Collation–How Character Sets and Collations Affect Queries, Summary
character_set_database, Special-case behaviors
CHARSET() function, How MySQL compares values
CHAR_LENGTH() function, How Character Sets and Collations Affect Queries
CHECK OPTION variable, Updatable Views
CHECK TABLES command, MyISAM I/O Configuration
CHECKSUM TABLE command, Determining Whether Replicas Are Consistent with the Master
chunk size, RAID Configuration and Caching
Churcher, Clare, Optimizing Schema and Data Types
Circonus, Commercial Monitoring Systems
circular replication, Ring Replication
Cisco server, Benchmarks for MySQL in the Cloud
client, returning results to, Returning Results to the Client
client-side emulated prepared statements, Limitations of Prepared Statements
client/server communication settings, Settings for client/server communication
cloud, MySQL in the, MySQL in the Cloud–Other DBaaS Solutions
benchmarks, Benchmarks for MySQL in the Cloud
benefits and drawbacks, Benefits, Drawbacks, and Myths of the Cloud–Benefits, Drawbacks, and Myths of the Cloud
DBaaS, MySQL Database as a Service (DBaaS)
economics, The Economics of MySQL in the Cloud
four fundamental resources, The Four Fundamental Resources
performance, MySQL Performance in Cloud Hosting–MySQL Performance in Cloud Hosting
scaling and HA, Benefits, Drawbacks, and Myths of the Cloud
Cluster Control, SeveralNines, MySQL Cluster
Cluster, MySQL, MySQL Cluster
clustered indexes, InnoDB overview, Clustered Indexes–Inserting rows in primary key order with InnoDB, What’s Your Working Set?, How to recover corrupted InnoDB data
clustering, scaling by, Scaling by Clustering
Clustrix, Scaling by Clustering, Summary
COALESCE() function, Making evaluation order deterministic
code
backing up, What to Back Up
stored, Storing Code Inside MySQL–Storing Code Inside MySQL, Preserving Comments in Stored Code
Codership Oy, Percona XtraDB Cluster
COERCIBILITY() function, How MySQL compares values
cold or warm copy, Initializing a Replica from Another Server
Cole, Jeremy, Using SHOW PROFILE
collate clauses, How MySQL compares values
COLLATION() function, How MySQL compares values
collations, String Types, Character Sets and Collations, Choosing a Character Set and Collation–How Character Sets and Collations Affect Queries
collisions, hash, Handling hash collisions
column-oriented storage engines, Column-oriented storage engines
command counters, Command Counters
command-line monitoring with innotop, Command-Line Monitoring with Innotop–Command-Line Monitoring with Innotop
command-line utilities, Command-Line Utilities
comments
stripping before compare, How MySQL Checks for a Cache Hit
version-specific, Preserving Comments in Stored Code
commercial monitoring systems, Commercial Monitoring Systems
common_schema, Redundant and Duplicate Indexes, SQL Utilities
community storage engines, Community storage engines
complete result sets, The MySQL Query Cache
COMPRESS() function, Optimizing for BLOB and TEXT Workloads
compressed files, Transferring Large Files
compressed MyISAM tables, Compressed MyISAM tables
computations
distance between points, Computing the Distance Between Points–Computing the Distance Between Points
integer, Whole Numbers
temporal, Date and Time Types
Com_admin_commands variable, Command Counters
CONCAT() function, Applying WHERE Clauses Efficiently, Optimizing Selects on Sahibinden.com
concurrency
control, Concurrency Control–Row locks
inserts, MyISAM features
measuring, What to Measure
multiversion concurrency control (MVCC), Multiversion Concurrency Control
need for high, MySQL Performance in Cloud Hosting
configuration
by cache hit ratio, What Not to Do
completing basic, Completing the Basic Configuration–Completing the Basic Configuration
creating configuration files, Creating a MySQL Configuration File–Inspecting MySQL Server Status Variables
InnoDB flushing algorithm, Optimizing MySQL for Solid-State Storage
memory usage, Configuring Memory Usage–The InnoDB Data Dictionary
MySQL concurrency, Configuring MySQL Concurrency–MyISAM Concurrency Configuration
workload-based, Workload-Based Configuration–Optimizing for Filesorts
connection management, Connection Management and Security
connection pooling, Load balancers, Common Problems
connection refused error, Network Configuration
connection statistics, Thread and Connection Statistics
CONNECTION_ID() function, Building a Queue Table in MySQL, Events, How MySQL Checks for a Cache Hit, Missing Temporary Tables, The Binary Log Format
consistency, Transactions
consolidation
scaling by, Scaling by Consolidation
storage, Other Types of Solid-State Storage, Should You Use a SAN?
constant expressions, The query optimizer
Continuent Tungsten Replicator, Emulating multisource replication, Other Replication Technologies
CONVERT() function, How MySQL compares values
Cook, Richard, Improving Mean Time to Recovery
correlated subqueries, Correlated Subqueries–When a correlated subquery is good
corrupt system structures, How to recover corrupted InnoDB data
corruption, finding and repairing, Finding and Repairing Table Corruption, Errors Caused by Data Corruption or Loss–Errors Caused by Data Corruption or Loss
COUNT() function optimizations, Rows examined and access types, The query optimizer, Optimizing COUNT() Queries–Simple optimizations, Prepared Statement Optimization
counter tables, Counter Tables
counters, SHOW STATUS, Command Counters
covering indexes, Covering Indexes–Covering Indexes, The query optimizer
CPU-bound machines, A CPU-Bound Machine
CPUs, The sysbench CPU benchmark, Introduction to Performance Optimization, Which Is Better: Fast CPUs or Many CPUs?–Scaling to Many CPUs and Cores, The Four Fundamental Resources, Benchmarks for MySQL in the Cloud
crash recovery, Selecting the Right Engine
crash testing, The RAID cache
CRC32() function, Building your own hash indexes, Fixed allocation
CREATE and SELECT conversions, CREATE and SELECT
CREATE INDEX command, The MyISAM key block size
CREATE TABLE command, Packed (Prefix-Compressed) Indexes, Partitioned Tables, The MyISAM key block size, Master, Distribution Master, and Replicas, Emulating multisource replication
CREATE TEMPORARY TABLE command, Temporary Files and Tables
cron jobs, Events, Handling Failover in the Application, What to Back Up
crontab, Lock Contention Caused by InnoDB Locking Selects
cross-data center replication, Master, Distribution Master, and Replicas
cross-shard queries, Choosing a partitioning key, Querying across shards
CSV format, Delimited file backups
CSV logging table, Amazon RDS
CSV storage engine, The CSV engine
CURRENT_DATE() function, How MySQL Checks for a Cache Hit
CURRENT_USER() function, How MySQL Checks for a Cache Hit, Statement-Based Replication
cursors, Cursors
custom benchmark suite, Iterative Optimization by Benchmarking
custom replication solutions, Custom Replication Solutions–Creating a log server

D

daemon plugins, Plugins
dangling pointer records, Scaling Back
data
archiving, Data archiving, Do writes in parallel outside of replication
backing up nonobvious, What to Back Up
changes on the replica, Data Changes on the Replica
consistency, Data consistency
deduplication, Incremental and differential backups
dictionary, The InnoDB Data Dictionary
distribution, Problems Solved by Replication
fragmentation, Reducing Index and Data Fragmentation
loss, avoiding, Scaling Back
optimizing access to, Slow Query Basics: Optimize Data Access–Rows examined and access types
scanning, How to Use Partitioning
sharding, Data sharding–Tools for sharding, Summary, Aggregating Sharded Data
types, Choosing Optimal Data Types
volume of and search engine choice, Large data volumes
Data Definition Language (DDL), AUTOCOMMIT
Data Recovery Toolkit, Finding and Repairing Table Corruption
data types
BIGINT, Whole Numbers
BIT, Bit-Packed Data Types
BLOB, The Memory engine, BLOB and TEXT types, Optimizing for BLOB and TEXT Workloads
CHAR, VARCHAR and CHAR types
DATETIME, Choosing Optimal Data Types, Date and Time Types
DECIMAL, Real Numbers
DOUBLE, Real Numbers
ENUM, Using ENUM instead of a string type, Choosing Identifiers, Schema Design Gotchas in MySQL, Foreign Key Constraints
FLOAT, Real Numbers
GEOMETRY, Spatial (R-Tree) indexes
INT, Whole Numbers
LONGBLOB, BLOB and TEXT types
LONGTEXT, BLOB and TEXT types
MEDIUMBLOB, BLOB and TEXT types
MEDIUMINT, Whole Numbers
MEDIUMTEXT, BLOB and TEXT types
RANGE COLUMNS, Types of Partitioning
SET, Bit-Packed Data Types, Choosing Identifiers
SMALLBLOB, BLOB and TEXT types
SMALLINT, Whole Numbers
SMALLTEXT, BLOB and TEXT types
TEXT, The Memory engine, BLOB and TEXT types, Optimizing for BLOB and TEXT Workloads
TIMESTAMP, Choosing Optimal Data Types, Date and Time Types, Incremental and differential backups
TINYBLOB, BLOB and TEXT types
TINYINT, Whole Numbers
TINYTEXT, BLOB and TEXT types
VARCHAR, VARCHAR and CHAR types, Using ENUM instead of a string type, Special Types of Data, How Fast Is Replication?
data=journal option, Choosing a Filesystem
data=ordered option, Choosing a Filesystem
data=writeback option, Choosing a Filesystem
Database as a Service (DBaaS), MySQL in the Cloud, MySQL Database as a Service (DBaaS)
database servers, Balancing Memory and Disk Resources
Database Test Suite, Single-Component Tools
Date, C. J., Other uses for variables
DATETIME type, Choosing Optimal Data Types, Date and Time Types
DBaaS (Database as a Service), MySQL in the Cloud, MySQL Database as a Service (DBaaS)
dbShards, Tools for sharding, Scaling by Clustering
dbt2 tool, Single-Component Tools, dbt2 TPC-C on the Database Test Suite
DDL (Data Definition Language), AUTOCOMMIT
deadlocks, Deadlocks
Debian, Other MySQL Variants
debug symbols, What kinds of data should you collect?
debugging locks, Debugging Locks–Using the INFORMATION_SCHEMA Tables
DECIMAL type, Real Numbers
deduplication, data, Incremental and differential backups
“degraded” mode, Plan to Underutilize
DELAYED hint, Query Optimizer Hints
delayed key writes, MyISAM features
delayed replication, Delayed replication for fast recovery
DELETE command, How Partitioning Works, Updatable Views
delimited file backups, Delimited file backups, Loading delimited files
DeNA, Using HandlerSocket and memcached Access
denormalization, Normalization and Denormalization–A Mixture of Normalized and Denormalized
dependencies on nonreplicated data, Dependencies on Nonreplicated Data
derived tables, SELECT and UPDATE on the Same Table, Views, Derived tables and unions
DETERMINISTIC variable, Stored Procedures and Functions
diagnostics, Diagnosing Intermittent Problems
capturing diagnostic data, Capturing Diagnostic Data–Interpreting the data
case study, A Case Study in Diagnostics–A Case Study in Diagnostics
single-query versus server-wide problems, Single-Query Versus Server-Wide Problems–Making sense of the findings
differential backups, Incremental and differential backups
directio() function, How InnoDB opens and flushes log and data files
directory servers, Dynamic allocation
dirty reads, Isolation Levels
DISABLE KEYS command, Building MyISAM Indexes Quickly, Full-Text Configuration and Optimization
disaster recovery, Why Backups?
disk queue scheduler, Choosing a Disk Queue Scheduler
disk space, No Disk Space
disruptive innovations, A MySQL Timeline
DISTINCT queries, Pros and Cons of a Normalized Schema, The query optimizer, Optimizing GROUP BY and DISTINCT
distributed (XA) transactions, Distributed (XA) Transactions
distributed indexes, Scaling
distributed memory caches, Application-Level Caching
distributed replicated block device (DRBD), Locating the desired log positions, What Is High Availability?, Shared Storage or Replicated Disk, Replication-Based Redundancy
distribution master and replicas, Master, Distribution Master, and Replicas
DNS (Domain Name System), Load Balancing, Changing DNS names, Avoiding Single Points of Failure, Virtual IP Addresses or IP Takeover
document pointers, Full-Text Searching
Domain Name System (DNS), Load Balancing, Changing DNS names, Avoiding Single Points of Failure, Virtual IP Addresses or IP Takeover
DorsalSource, Other MySQL Variants
DOUBLE type, Real Numbers
doublewrite buffer, The doublewrite buffer, Optimizing MySQL for Solid-State Storage
downtime, causes of, What Causes Downtime?
DRBD (distributed replicated block device), Locating the desired log positions, What Is High Availability?, Shared Storage or Replicated Disk, Replication-Based Redundancy
drinking from the fire hose, The MySQL Client/Server Protocol
Drizzle, Character Sets and Collations, Drizzle
DROP DATABASE command, Defining Recovery Requirements
DROP TABLE command, Dump and import, Configuring the tablespace, Avoiding Single Points of Failure, Point-in-Time Recovery
DTrace, Choosing an Operating System
dump and import conversions, Dump and import
duplicate indexes, Redundant and Duplicate Indexes–Redundant and Duplicate Indexes
durability, Transactions
DVD-ROM applications, CD-ROM applications
dynamic allocation, Fixed allocation–Mixing dynamic and fixed allocation
dynamic optimizations, The query optimizer
dynamic SQL, The SQL Interface to Prepared Statements, Side Effects of Setting Variables–Side Effects of Setting Variables

E

early termination, The query optimizer
EBS (Elastic Block Store), Amazon, MySQL in the Cloud, The Four Fundamental Resources
EC2 (Elastic Compute Cloud), MySQL in the Cloud, The Four Fundamental Resources–MySQL Performance in Cloud Hosting
edge side (ESI), Web Server Issues
Elastic Block Store (EBS), Amazon, MySQL in the Cloud, The Four Fundamental Resources
Elastic Compute Cloud (EC2), Amazon, MySQL in the Cloud, The Four Fundamental Resources–MySQL Performance in Cloud Hosting
embedded escape sequences, Special-case behaviors
eMLC (enterprise MLC), Flash Technologies
ENABLE KEYS command, Full-Text Configuration and Optimization
encryption overhead, avoiding, Avoiding Encryption Overhead
end_log_pos, The Binary Log Format
Enterprise Backup, MySQL, Initializing a Replica from Another Server, Designing a MySQL Backup Solution, Online or Offline Backups?, Incremental and differential backups, MySQL Enterprise Backup
enterprise MLC (eMLC), Flash Technologies
Enterprise Monitor, MySQL, Instrumenting PHP Applications, Commercial Monitoring Systems
ENUM type, Using ENUM instead of a string type, Choosing Identifiers, Schema Design Gotchas in MySQL, Foreign Key Constraints
equality propagation, The query optimizer, Equality Propagation
errors
404 error, Application-Level Caching, Pregenerating Content
from data corruption or loss, Errors Caused by Data Corruption or Loss–Errors Caused by Data Corruption or Loss
ERROR 1005, Choosing Identifiers
ERROR 1168, Merge Tables
ERROR 1267, How MySQL compares values
escape sequences, Special-case behaviors
evaluation order, Making evaluation order deterministic
Even Faster Websites (Souders), Web Server Issues
events, Storing Code Inside MySQL, Events
exclusive locks, Read/Write Locks
exec_time, The Binary Log Format
EXISTS operator, Correlated Subqueries, When a correlated subquery is good
expire_logs_days variable, Safety and Sanity Settings, Replication Files, Designing a MySQL Backup Solution, Purging Old Binary Logs Safely
EXPLAIN command, Using SHOW STATUS, Multicolumn Indexes, Using Index Scans for Sorts, The execution plan, Optimizing Queries, Views, Using EXPLAIN–The Extra Column
explicit allocation, Explicit allocation
explicit invalidation, Cache Control Policies
explicit locking, Implicit and explicit locking
external XA transactions, External XA Transactions
extra column, The Extra Column

F

Facebook, Instrumenting PHP Applications, Using Flashcache, The Economics of MySQL in the Cloud
fadvise() function, Online or Offline Backups?
failback, Failover and Failback
failover, Problems Solved by Replication, Failover and Failback, Handling Failover in the Application
failures, mean time between, Improving Mean Time Between Failures
Falcon storage engine, OLTP storage engines
fallback, Failover and Failback
fast warmup feature, The InnoDB Buffer Pool
FathomDB, Other DBaaS Solutions
FCP (Fibre Channel Protocol), Storage Area Networks and Network-Attached Storage
fdatasync() function, How InnoDB opens and flushes log and data files
Federated storage engine, The Federated engine
Fedora, Other MySQL Variants
fencing, Virtual IP Addresses or IP Takeover
fetching mistakes, Are You Asking the Database for Data You Don’t Need?
Fibre Channel Protocol (FCP), Storage Area Networks and Network-Attached Storage
FIELD() function, Using ENUM instead of a string type, Bit-Packed Data Types
FILE () function, Amazon RDS
FILE I/O, FILE I/O
files
consistency of, File consistency
copying, Copying Files
descriptors, File Descriptors
transferring large, Transferring Large Files–File Copy Benchmarks
filesort, Sort optimizations, Optimizing for Filesorts
filesystems, Choosing a Filesystem–Choosing a Filesystem, Shared Storage or Replicated Disk, Filesystem Snapshots–Recovering from a Backup
filtered column, The filtered Column
filtering, Supporting Many Kinds of Filtering, Replication Filters, Load Balancing with a Master and Multiple Replicas, Applying WHERE Clauses Efficiently, Filtering
fincore tool, The MyISAM key block size
FIND_IN_SET() function, Bit-Packed Data Types
fire hose, drinking from the, The MySQL Client/Server Protocol
FIRST() function, Other uses for variables
first-write penalty, The Four Fundamental Resources
Five Whys, Improving Mean Time to Recovery
fixed allocation, Fixed allocation–Mixing dynamic and fixed allocation
flapping, Virtual IP Addresses or IP Takeover
flash storage, Solid-State Storage–Optimizing MySQL for Solid-State Storage
Flashcache, Using Flashcache–Using Flashcache
Flexviews tools, Materialized Views, Limitations of Views
FLOAT type, Real Numbers
FLOOR() function, Computing the Distance Between Points
FLUSH LOGS command, Locating the desired log positions, What to Back Up
FLUSH QUERY CACHE command, Reducing fragmentation
FLUSH TABLES WITH READ LOCK command, The Table Cache, MyISAM I/O Configuration, Planned promotions, Switching Roles in a Master-Master Configuration, Online or Offline Backups?, Lock-free InnoDB backups with LVM snapshots
flushing algorithm, InnoDB, Optimizing MySQL for Solid-State Storage
flushing binary logs, Scripting Backups
flushing log buffer, How InnoDB flushes the log buffer, LOG
flushing tables, Scripting Backups
FOR UPDATE hint, Query Optimizer Hints
FORCE INDEX hint, Query Optimizer Hints
foreign keys, Choosing Identifiers, Foreign Key Constraints, Summary
Forge, MySQL, Command-Line Utilities, The INFORMATION_SCHEMA
FOUND_ROWS() function, Query Optimizer Hints
fractal trees, OLTP storage engines, Other types of index
fragmentation, Reducing Index and Data Fragmentation, How the Cache Uses Memory, When the Query Cache Is Helpful, Reducing fragmentation
free space fragmentation, Reducing Index and Data Fragmentation
FreeBSD, Choosing an Operating System, Filesystem Snapshots
“freezes”, Profiling Server Performance
frequency scaling, Scaling to Many CPUs and Cores
.frm file, MySQL’s Storage Engines, Speeding Up ALTER TABLE, The Table Cache, Tables in Percona Server
FROM_UNIXTIME() function, Date and Time Types
fsync() function, Internal XA Transactions, How InnoDB opens and flushes log and data files, The doublewrite buffer, Causes of InnoDB corruption, SHOW ENGINE INNODB STATUS
full-stack benchmarking, Benchmarking Strategies, Full-Stack Tools
full-text searching, Full-text indexes, Full-Text Searching–Full-Text Configuration and Optimization, Using replicas for full-text searches
on BoardReader.com, Full-Text Searching on BoardReader.com
Boolean full-text searches, Boolean Full-Text Searches
collection, Full-Text Searching
on Mininova.org, Full-Text Searching on Mininova.org
parser plugins, Plugins
Sphinx storage engine, Efficient and Scalable Full-Text Searching
functional partitioning, Functional partitioning, Load Balancing with a Master and Multiple Replicas
furious flushing, The Importance of Plotting, LOG, ROW OPERATIONS
Fusion-io, PCIe Storage Devices

G

Galbraith, Patrick, User-Defined Functions
Galera, Scaling by Clustering, Percona XtraDB Cluster, Percona XtraDB Cluster
Ganglia, Open Source Monitoring Tools
garbage collection, An Overview of Flash Memory
GDB stack traces, What kinds of data should you collect?
gdb tool, What kinds of data should you collect?–Interpreting the data
general log, Capturing MySQL’s queries to a log
GenieDB, Scaling by Clustering, GenieDB
Gentoo, Other MySQL Variants
GEOMETRY type, Spatial (R-Tree) indexes
geospatial searches, Selecting the Right Engine, Spatial (R-Tree) indexes, Computing the Distance Between Points
GET_LOCK() function, Building a Queue Table in MySQL, Events
get_name_from_id() function, Application-Level Caching
Gladwell, Malcom, Improving Mean Time to Recovery
glibc libraries, How Much Memory Can MySQL Use?
global locks, Lock Waits at the Server Level, The Global Read Lock
global scope, Syntax, Scope, and Dynamism
global version/session splits, Splitting reads and writes in replication
globally unique IDs (GUIDs), Generating globally unique IDs
gnuplot, The Importance of Plotting, Making sense of the findings
Goal (Goldratt), A Formal Definition, Summary
Goal-Driven Performance Optimization white paper, Introduction to Performance Optimization
GoldenGate, Oracle, Other Replication Technologies
Goldratt, Eliyahu M., A Formal Definition, Summary
Golubchik, Sergei, Plugins
Graphite, Open Source Monitoring Tools
great-circle formula, Computing the Distance Between Points
GREATEST() function, Making evaluation order deterministic
grep, SQL dumps
Grimmer, Lenz, mylvmbackup
Groonga storage engine, Community storage engines
Groundwork Open Source, Open Source Monitoring Tools
GROUP BY queries, Pros and Cons of a Normalized Schema, Cache and Summary Tables, Prefix Indexes and Index Selectivity, Optimizing GROUP BY and DISTINCT, Full-Text Tradeoffs and Workarounds, Optimizing GROUP BY Queries
group commit, Internal XA Transactions
Grouply.com, Optimizing Sharded JOIN Queries on Grouply.com
GROUP_CONCAT() function, Correlated Subqueries
Guerrilla Capacity Planning (Gunther), A Formal Definition, Summary
GUID values, Generating globally unique IDs
Gunther, Neil J., A Formal Definition, Summary
gunzip tool, A Naïve Example
gzip compression, Web Server Issues, A Naïve Example, File Copy Benchmarks

H

Hadoop, Alternatives to MySQL
handler API, The Query Execution Engine
handler operations, The Query Execution Engine, Partitioned Tables, Handler Operations
HandlerSocket, Using HandlerSocket and memcached Access
HAProxy, Load Balancing
hard disks, choosing, Choosing Hard Disks
hardware and software RAID, Balancing Hardware RAID and Software RAID
hardware threads, Which Is Better: Fast CPUs or Many CPUs?
hash codes, Hash indexes
hash indexes, The Memory engine, Hash indexes
hash joins, Hash Joins
Haversine formula, Computing the Distance Between Points
header, Header
headroom, Avoiding Single Points of Failure
HEAP tables, The Memory engine
heartbeat record, Measuring Replication Lag
HEX() function, Choosing Identifiers
Hibernate Core interfaces, Tools for sharding
Hibernate Shards, Tools for sharding
high availability
achieving, Achieving High Availability–Improving Mean Time to Recovery
avoiding single points of failure, Avoiding Single Points of Failure–Replication-Based Redundancy
defined, What Is High Availability?
failover and failback, Failover and Failback–Middleman Solutions
High Availability Linux project, Failover and Failback
high bits, Writing to Both Masters in Master-Master Replication
High Performance Web Sites (Souders), Web Server Issues
high throughput, Which Is Better: Fast CPUs or Many CPUs?
HIGH_PRIORITY hint, Query Optimizer Hints
hit rate, When the Query Cache Is Helpful
HiveDB, Tools for sharding
hot data, segregating, How to Use Partitioning
“hot” online backups, InnoDB overview
How Complex Systems Fail (Cook), Improving Mean Time to Recovery
HTTP proxy, Middleman Solutions
http_load tool, Full-Stack Tools, http_load
Hutchings, Andrew, Plugins
Hyperic HQ, Open Source Monitoring Tools
hyperthreading, Which Is Better: Fast CPUs or Many CPUs?

I

I/O
benchmark, The sysbench file I/O benchmark
InnoDB, InnoDB I/O Configuration–How InnoDB opens and flushes log and data files
MyISAM, MyISAM I/O Configuration–MyISAM I/O Configuration
performance, The Four Fundamental Resources
slave thread, How Replication Works
I/O-bound machines, An I/O-Bound Machine
IaaS (Infrastructure as a Service), MySQL in the Cloud
.ibd files, The InnoDB Data Dictionary, Configuring the tablespace, Restoring Raw Files
Icinga, Open Source Monitoring Tools
id column, The id Column
identifiers, choosing, Choosing Identifiers–Special Types of Data
idle machine’s vmstat output, An Idle Machine
IF() function, Making evaluation order deterministic
IfP (instrumentation-for-php), Instrumenting PHP Applications
IGNORE INDEX hint, Multicolumn Indexes, Query Optimizer Hints
implicit locking, Implicit and explicit locking
IN() function, Supporting Many Kinds of Filtering–Avoiding Multiple Range Conditions, The query optimizer, Computing the Distance Between Points
incr() function, Generating globally unique IDs
incremental backups, Incremental and differential backups
.index files, Replication Files
index-covered queries, Covering Indexes–Covering Indexes
indexer, Sphinx, Architectural Overview
indexes
benefits of, Benefits of Indexes
case study, An Indexing Case Study–Optimizing Sorts
clustered, Clustered Indexes–Inserting rows in primary key order with InnoDB
covering, Covering Indexes–Covering Indexes
and locking, Indexes and Locking
maintaining, Index and Table Maintenance–Reducing Index and Data Fragmentation
merge optimizations, Index Merge Optimizations
and mismatched PARTITION BY, What Can Go Wrong
MyISAM storage engine, Building MyISAM Indexes Quickly
order of columns, Choosing a Good Column Order–Choosing a Good Column Order
packed (prefix-compressed), Packed (Prefix-Compressed) Indexes
reducing fragmentation, Reducing Index and Data Fragmentation
redundant and duplicate, Redundant and Duplicate Indexes–Redundant and Duplicate Indexes
and scans, Using Index Scans for Sorts–Using Index Scans for Sorts, How to Use Partitioning
statistics, Updating Index Statistics, Table and index statistics
strategies for high performance, Indexing Strategies for High Performance–Choosing a Good Column Order
types of, Types of Indexes–Other types of index
unused, Unused Indexes
INET_ATON() function, Special Types of Data
INET_NTOA() function, Special Types of Data
InfiniDB, Calpont, Column-oriented storage engines
info() function, Updating Index Statistics
Infobright, Column-oriented storage engines, Large data volumes, Whole Numbers, How to Use Partitioning
INFORMATION_SCHEMA tables, MySQL’s Storage Engines, Using the USER_STATISTICS Tables, Plugins, Nondeterministic Statements, Using the INFORMATION_SCHEMA Tables–Using the INFORMATION_SCHEMA Tables
infrastructure, The Cache as an Infrastructure Component
Infrastructure as a Service (IaaS), MySQL in the Cloud
Ingo, Henrik, Advanced Features in MySQL Replication, Other MySQL Variants
inner joins, The query optimizer
Innobase Oy, A MySQL Timeline
InnoDB, Multiversion Concurrency Control, The InnoDB Engine
advanced settings, Advanced InnoDB Settings–Advanced InnoDB Settings
buffer pool, Allocating Memory for Caches, Tables in Percona Server
concurrency configuration, InnoDB Concurrency Configuration
crash recovery, InnoDB Crash Recovery–How to recover corrupted InnoDB data
data dictionary, The InnoDB Data Dictionary, Tables in Percona Server
data layout, InnoDB’s data layout–Inserting rows in primary key order with InnoDB
Data Recovery Toolkit, Finding and Repairing Table Corruption
and deadlocks, Deadlocks
and filesystem snapshots, LVM snapshots for online backups–Planning for LVM backups
flushing algorithm, Optimizing MySQL for Solid-State Storage
Hot Backup, Initializing a Replica from Another Server, MySQL Enterprise Backup
I/O configuration, InnoDB I/O Configuration–How InnoDB opens and flushes log and data files, Optimizing MySQL for Solid-State Storage
lock waits in, Lock Waits in InnoDB–Using the INFORMATION_SCHEMA Tables
log files, Optimizing MySQL for Solid-State Storage
and query cache, InnoDB and the Query Cache
release history, InnoDB’s history
row locks, Indexes and Locking
tables, InnoDB Tables, Using the INFORMATION_SCHEMA Tables
tablespace, The InnoDB tablespace
transaction log, The InnoDB transaction log, Errors Caused by Data Corruption or Loss
InnoDB locking selects, Lock Contention Caused by InnoDB Locking Selects
innodb variable, Advanced InnoDB Settings
InnoDB-specific variables, InnoDB-Specific
innodb_adaptive_checkpoint variable, Optimizing MySQL for Solid-State Storage
innodb_analyze_is_persistent variable, Updating Index Statistics, The InnoDB Data Dictionary
innodb_autoinc_lock_mode variable, Inserting rows in primary key order with InnoDB, Advanced InnoDB Settings
innodb_buffer_pool_instances variable, Advanced InnoDB Settings
innodb_buffer_pool_size variable, How Much Memory Can MySQL Use?
innodb_commit_concurrency variable, InnoDB Concurrency Configuration
innodb_concurrency_tickets variable, InnoDB Concurrency Configuration
innodb_data_file_path variable, Configuring the tablespace
innodb_data_home_dir variable, Configuring the tablespace
innodb_doublewrite variable, The doublewrite buffer
innodb_file_io_threads variable, FILE I/O
innodb_file_per_table variable, Creating a MySQL Configuration File, How InnoDB opens and flushes log and data files, Configuring the tablespace, Optimizing MySQL for Solid-State Storage, Balancing Hardware RAID and Software RAID, Restoring Raw Files, Backup and Recovery Tools
innodb_flush_log_at_trx_commit variable, How InnoDB flushes the log buffer, How InnoDB opens and flushes log and data files, Other I/O configuration options, RAID Failure, Recovery, and Monitoring, Planned promotions, Excessive Replication Lag
innodb_flush_method variable, Creating a MySQL Configuration File, How InnoDB opens and flushes log and data files, Balancing Hardware RAID and Software RAID, Swapping
innodb_flush_neighbor_pages variable, Optimizing MySQL for Solid-State Storage
innodb_force_recovery variable, Finding and Repairing Table Corruption, How to recover corrupted InnoDB data
innodb_io_capacity variable, Advanced InnoDB Settings, Optimizing MySQL for Solid-State Storage
innodb_lazy_drop_table variable, Configuring the tablespace
innodb_locks_unsafe_for_binlog variable, Lock Contention Caused by InnoDB Locking Selects, Excessive Replication Lag
innodb_log_buffer_size variable, Log file size and the log buffer
innodb_log_files_in_group variable, The InnoDB transaction log
innodb_log_file_size variable, The InnoDB transaction log
innodb_max_dirty_pages_pct variable, The InnoDB Buffer Pool
innodb_max_purge_lag variable, Old row versions and the tablespace
innodb_old_blocks_time variable, Advanced InnoDB Settings
innodb_open_files variable, The InnoDB Data Dictionary
innodb_overwrite_relay_log_info variable, Safety and Sanity Settings
innodb_read_io_threads variable, Advanced InnoDB Settings, FILE I/O
innodb_recovery_stats variable, Log file size and the log buffer
innodb_stats_auto_update variable, Updating Index Statistics
innodb_stats_on_metadata variable, Updating Index Statistics, The InnoDB Data Dictionary
innodb_stats_sample_pages variable, Updating Index Statistics
innodb_strict_mode variable, Advanced InnoDB Settings
innodb_support_xa variable, Internal XA Transactions, Summary
innodb_sync_spin_loops variable, SEMAPHORES
innodb_thread_concurrency variable, Interpreting the data, InnoDB Concurrency Configuration
innodb_thread_sleep_delay variable, InnoDB Concurrency Configuration
innodb_use_sys_stats_table variable, Updating Index Statistics, The InnoDB Data Dictionary
innodb_version variable, Using the INFORMATION_SCHEMA Tables
innodb_write_io_threads variable, Advanced InnoDB Settings, FILE I/O
innotop tool, Nonunique Server IDs, Command-Line Monitoring with Innotop, SHOW ENGINE INNODB STATUS
INSERT ... SELECT statements, CREATE and SELECT, Query Optimizer Hints, Determining Whether Replicas Are Consistent with the Master, Lock Contention Caused by InnoDB Locking Selects
insert buffer, Optimizing MySQL for Solid-State Storage, INSERT BUFFER AND ADAPTIVE HASH INDEX
INSERT command, How Partitioning Works, Updatable Views
INSERT ON DUPLICATE KEY UPDATE command, Counting UPDATEs and INSERTs, Drizzle
insert-to-select rate, When the Query Cache Is Helpful
inspecting server status variables, Inspecting MySQL Server Status Variables
INSTEAD OF trigger, Updatable Views
instrumentation, Optimization Through Profiling
instrumentation-for-php (IfP), Instrumenting PHP Applications
INT type, Whole Numbers
integer computations, Whole Numbers
integer types, Whole Numbers, Choosing Identifiers
Intel X-25E drives, Solid-State Drives (SSDs)
Intel Xeon X5670 Nehalem CPU, Benchmarks for MySQL in the Cloud
interface tools, Interface Tools
intermittent problems, diagnosing, Diagnosing Intermittent Problems
capturing diagnostic data, Capturing Diagnostic Data–Interpreting the data
case study, A Case Study in Diagnostics–A Case Study in Diagnostics
single-query versus server-wide problems, Single-Query Versus Server-Wide Problems–Making sense of the findings
internal concurrency issues, Scaling to Many CPUs and Cores
internal XA transactions, Internal XA Transactions
intra-row fragmentation, Reducing Index and Data Fragmentation
introducers, How MySQL compares values
invalidation on read, Cache Control Policies
ionice, Online or Offline Backups?
iostat, Operating System Status–Other Helpful Tools, Benefits, Drawbacks, and Myths of the Cloud, Planning for LVM backups
IP addresses, Moving IP addresses, Middleman Solutions
IP takeover, Virtual IP Addresses or IP Takeover
ISNULL() function, Making evaluation order deterministic
isolating columns, Isolating the Column
isolation, Transactions, Isolation Levels
iterative optimization by benchmarking, Iterative Optimization by Benchmarking

J

JMeter, Full-Stack Tools
joins, Schema Design Gotchas in MySQL, Hash Joins
decomposition, Join Decomposition
execution strategy, MySQL’s join execution strategy
JOIN queries, Optimizing JOIN Queries
optimizers for, The join optimizer–The join optimizer
journaling filesystems, Choosing a Filesystem
Joyent, MySQL in the Cloud

K

Karlsson, Anders, Prime the cache for the replication thread
Karwin, Bill, Case Studies
Keep-Alive, Web Server Issues
key block size, The MyISAM key block size
key buffers, The MyISAM Key Caches
key column, The key Column
key_buffer_size variable, Side Effects of Setting Variables, The MyISAM Key Caches
key_len column, The key_len Column
Köhntopp, Kristian, Counting UPDATEs and INSERTs
Kyte, Tom, Profiling Your Application

L

L-values, Optimizing ranking queries
lag, When Will Replicas Begin to Lag?, Measuring Replication Lag, Excessive Replication Lag–Prime the cache for the replication thread
Lahdenmaki, Tapio, Benefits of Indexes, Response time
LAST() function, Other uses for variables
LAST_INSERT_ID() function, Query Optimizer Hints
latency, What to Measure, Choosing Hard Disks, Shared Storage or Replicated Disk
LATEST DETECTED DEADLOCK, LATEST DETECTED DEADLOCK
LATEST FOREIGN KEY ERROR, LATEST FOREIGN KEY ERROR
Launchpad, Percona’s TPCC-MySQL Tool
lazy UNIONs, Writing a lazy UNION
LDAP authentication, Plugins
Leach, Mike, Benefits of Indexes, Response time
LEAST() function, Making evaluation order deterministic
LEFT JOIN queries, The query optimizer
LEFT OUTER JOIN queries, When a correlated subquery is good
left-deep trees, The execution plan
Leith, Mark, The Performance Schema
LENGTH() function, Making evaluation order deterministic, How Character Sets and Collations Affect Queries
lighttpd, Web Server Issues
lightweight profiling, Profiling Your Application
LIMIT query, The query optimizer, Sort optimizations, Optimizing LIMIT and OFFSET
limited replication bandwidth, Limited Replication Bandwidth
linear scalability, A Formal Definition
“lint checking”, Static Query Analysis
Linux Virtual Server (LVS), Problems Solved by Replication, Load Balancing, Moving IP addresses
Linux-HA stack, Failover and Failback
linuxthreads, Threading
Little’s Law, How to Read iostat Output
load balancers, Load balancers
load balancing, Problems Solved by Replication, Load Balancing–Load Balancing with a Master and Multiple Replicas
LOAD DATA FROM MASTER command, Initializing a Replica from Another Server
LOAD DATA INFILE command, Instrumenting PHP Applications, Special-case behaviors, Lock Contention Caused by InnoDB Locking Selects, Don’t duplicate the expensive part of writes, No Disk Space, Amazon RDS, Loading delimited files
LOAD INDEX command, What Can Go Wrong, The MyISAM Key Caches
LOAD TABLE FROM MASTER command, Initializing a Replica from Another Server
LOAD_FILE() function, Limitations of Views
local caches, Application-Level Caching
local shared-memory caches, Application-Level Caching
locality of reference, Balancing Memory and Disk Resources
lock contention, Lock Contention Caused by InnoDB Locking Selects
LOCK IN SHARE MODE command, Query Optimizer Hints
LOCK TABLES command, AUTOCOMMIT, Data consistency
lock time, Online or Offline Backups?
lock waits, Lock Waits at the Server Level, Lock Waits in InnoDB–Using the INFORMATION_SCHEMA Tables
lock-all-tables variable, Initializing a Replica from Another Server
lock-free InnoDB backups, Lock-free InnoDB backups with LVM snapshots
locks
debugging, Debugging Locks–Using the INFORMATION_SCHEMA Tables
granularities, Lock Granularity
implicit and explicit, Implicit and explicit locking
read/write, Read/Write Locks
row, Row locks
table, Table locks
log buffer, Log file size and the log buffer–How InnoDB flushes the log buffer
log file coordinates, Initializing a Replica from Another Server
log file size, Creating a MySQL Configuration File, Log file size and the log buffer–How InnoDB flushes the log buffer, Optimizing MySQL for Solid-State Storage
log positions, locating, Locating the desired log positions
log servers, Creating a log server, Recovering with a log server
log threads, FILE I/O
log, InnoDB transaction, LOG
logging, Transaction Logging, Logging
logical backups, Logical or Raw Backups?, Making a Logical Backup–Delimited file backups, Restoring Logical Backups–Loading delimited files
logical concurrency issues, Scaling to Many CPUs and Cores
logical reads, Caching, Reads, and Writes
logical replication, Statement-Based Replication
logical unit numbers (LUNs), Storage Area Networks and Network-Attached Storage
log_bin variable, Recommended Replication Configuration
log_slave_updates variable, Configuring the Master and Replica, Sending Replication Events to Other Replicas, Replication Topologies, No Disk Space, Managing and Backing Up Binary Logs
LONGBLOB type, BLOB and TEXT types
LONGTEXT type, BLOB and TEXT types
lookup tables, The Memory engine
loose index scans, Loose Index Scans
lost time, Interpreting the Profile
low latency, Which Is Better: Fast CPUs or Many CPUs?
LOW_PRIORITY hint, Query Optimizer Hints
Lua language, Single-Component Tools
Lucene, Full-Text Configuration and Optimization
LucidDB, Column-oriented storage engines
LUNs (logical unit numbers), Storage Area Networks and Network-Attached Storage
LVM snapshots, Choosing a Filesystem, File consistency, Filesystem Snapshots–Recovering from a Backup
lvremove command, Creating, mounting, and removing an LVM snapshot
LVS (Linux Virtual Server), Problems Solved by Replication, Load Balancing, Moving IP addresses
lzo, Online or Offline Backups?

M

Maatkit (see Percona Toolkit)
maintenance operations, What Can Go Wrong
malloc() function, How the Cache Uses Memory
manual joins, Common Problems
mapping tables, The Memory engine
MariaDB, MyISAM performance, When Will Replicas Begin to Lag?, MariaDB
master and replicas, Master and Multiple Replicas, Master, Distribution Master, and Replicas, Load Balancing with a Master and Multiple Replicas
master shutdown, unexpected, Errors Caused by Data Corruption or Loss
master-data variable, Initializing a Replica from Another Server
master-master in active-active mode, Master-Master in Active-Active Mode
master-master in active-passive mode, Master-Master in Active-Passive Mode
master-master replication, Master-Master with Replicas, Writing to Both Masters in Master-Master Replication
master.info file, Recommended Replication Configuration, Replication Files, Changing Masters, Errors Caused by Data Corruption or Loss
Master_Log_File, Unplanned promotions
MASTER_POS_WAIT() function, Switching Roles in a Master-Master Configuration, Load Balancing with a Master and Multiple Replicas
MATCH() function, The query optimizer, Full-Text Searching, Natural-Language Full-Text Searches, Full-Text Tradeoffs and Workarounds
materialized views, Materialized Views, Limitations of Views
Matsunobu, Yoshinori, Replication-Based Redundancy
MAX() function, The query optimizer, MIN() and MAX(), Prepared Statement Optimization
Maxia, Giuseppe, Storing Code Inside MySQL, Starting the Replica, How Fast Is Replication?, Advanced Features in MySQL Replication, Other Replication Technologies, SQL Utilities
maximum system capacity, What Is Scalability?, Finding the Optimal Concurrency
max_allowed_packet variable, Safety and Sanity Settings
max_connections setting variable, Completing the Basic Configuration
max_connect_errors variable, Safety and Sanity Settings
max_heap_table_size setting variable, Completing the Basic Configuration
mbox mailbox messages, Concurrency Control
MBRCONTAINS() function, Spatial (R-Tree) indexes
McCullagh, Paul, OLTP storage engines
MD5() function, Single-Component Tools, Choosing Identifiers, Building your own hash indexes, Writing to Both Masters in Master-Master Replication
md5sum, File Copy Benchmarks
mean time between failures (MTBF), Achieving High Availability
mean time to recover (MTTR), Achieving High Availability–Improving Mean Time to Recovery, Shared Storage or Replicated Disk, Failover and Failback, Summary
measurement uncertainty, Introduction to Performance Optimization
MEDIUMBLOB type, BLOB and TEXT types
MEDIUMINT type, Whole Numbers
MEDIUMTEXT type, BLOB and TEXT types
memcached, Data sharding, Generating globally unique IDs, Application-Level Caching, Cache Object Hierarchies
Memcached Access, Using HandlerSocket and memcached Access
memory
allocating for caches, Allocating Memory for Caches
configuring, Configuring Memory Usage–The InnoDB Data Dictionary
consumption formula for, What Not to Do
InnoDB buffer pool, Allocating Memory for Caches
InnoDB data dictionary, The InnoDB Data Dictionary
limits on, How Much Memory Can MySQL Use?
memory-to-disk ratio, Finding an Effective Memory-to-Disk Ratio
MyISAM key cache, The MyISAM Key Caches–The MyISAM key block size
per-connection needs, Per-Connection Memory Needs
pool, BUFFER POOL AND MEMORY
reserving for operating system, Reserving Memory for the Operating System
size, The Four Fundamental Resources
Sphinx RAM, Finding the Top Results in Order
table cache, The Table Cache
thread cache, The Thread Cache
Memory storage engine, The Memory engine
Merge storage engine, The Merge storage engine
merge tables, Merge Tables–Merge Tables
merged read and write requests, How to Read iostat Output
mget() call, Cache Object Hierarchies
MHA toolkit, Replication-Based Redundancy
middleman solutions, Introducing a Middleman–Load-balancing algorithms, Middleman Solutions
migration, benchmarking after, Getting Accurate Results
Millsap, Cary, Introduction to Performance Optimization, Interpreting the Profile, What Not to Do
MIN() function, The query optimizer, MIN() and MAX(), Prepared Statement Optimization
Mininova.org, Full-Text Searching on Mininova.org
mk-parallel-dump tool, SQL dumps
mk-parallel-restore tool, SQL dumps
mk-query-digest tool, Optimization Through Profiling
mk-slave-prefetch tool, Prime the cache for the replication thread
MLC (multi-level cell), Flash Technologies, PCIe Storage Devices
MMM replication manager, Improving Mean Time to Recovery, Replication-Based Redundancy
mod_log_config variable, Instrumenting PHP Applications
MonetDB, Column-oriented storage engines
Monitis, Commercial Monitoring Systems
monitoring tools, Monitoring Tools–Command-Line Monitoring with Innotop
MONyog, Commercial Monitoring Systems
mpstat tool, Operating System Status
MRTG (Multi Router Traffic Grapher), Network Configuration, Open Source Monitoring Tools
MTBF (mean time between failures), Achieving High Availability
mtop tool, Command-Line Monitoring with Innotop
MTTR (mean time to recovery), Achieving High Availability–Improving Mean Time to Recovery, Shared Storage or Replicated Disk, Failover and Failback, Summary
Mulcahy, Lachlan, Percona XtraBackup
Multi Router Traffic Grapher (MRTG), Network Configuration, Open Source Monitoring Tools
multi-level cell (MLC), Flash Technologies, PCIe Storage Devices
multi-query mechanism, Generating Parallel Result Sets
multicolumn indexes, Multicolumn Indexes
multiple disk volumes, Using Multiple Disk Volumes
multiple partitioning keys, Multiple partitioning keys
multisource replication, Master-Master in Active-Active Mode, Emulating multisource replication
multivalued attributes, Architectural Overview, Support for Attributes
Munin, Open Source Monitoring Tools
MVCC (multiversion concurrency control), Multiversion Concurrency Control, MySQL Cluster (NDB Cluster)
my.cnf file, Configuring the Master and Replica, Planned promotions, Undefined Server IDs
.MYD file, MyISAM I/O Configuration, File consistency, Restoring Raw Files
mydumper, SQL dumps, mydumper
.MYI file, File consistency, Restoring Raw Files
MyISAM storage engine, The MyISAM Engine
and backups, Incremental and differential backups
concurrency configuration, MyISAM features, MyISAM Concurrency Configuration
and COUNT() queries, Myths about MyISAM
data layout, MyISAM’s data layout
delayed key writes, MyISAM features
indexes, Storage, Building MyISAM Indexes Quickly
key block size, The MyISAM key block size
key buffer/cache, The MyISAM Key Caches–The MyISAM key block size, MyISAM Key Buffer
performance, MyISAM performance
tables, Compressed MyISAM tables, Using Nontransactional Tables
myisamchk, Raw backups
myisampack, Merge Tables
mylvmbackup, Backup and Recovery Tools, mylvmbackup
MySQL
concurrency, Configuring MySQL Concurrency–MyISAM Concurrency Configuration
configuration mechanisms, How MySQL’s Configuration Works–Side Effects of Setting Variables
development model, MySQL’s Development Model
GPL-licensing, MySQL’s Development Model
logical architecture, MySQL’s Logical Architecture
proprietary plugins, MySQL’s Development Model
Sandbox script, Starting the Replica, Creating a log server
version history, A MySQL Timeline–A MySQL Timeline, Covering Indexes, Indexes and Locking
MySQL 5.1 Plugin Development (Golubchik & Hutchings), Plugins
MySQL Benchmark Suite, Single-Component Tools, MySQL Benchmark Suite
MySQL Cluster, Percona XtraDB Cluster
MySQL Enterprise Backup, Initializing a Replica from Another Server, Designing a MySQL Backup Solution, Online or Offline Backups?, Incremental and differential backups, MySQL Enterprise Backup
MySQL Enterprise Monitor, Instrumenting PHP Applications, Commercial Monitoring Systems
MySQL Forge, Command-Line Utilities, The INFORMATION_SCHEMA
MySQL High Availability (Bell et al.), Summary
MySQL Stored Procedure Programming (Harrison & Feuerstein), Storing Code Inside MySQL
MySQL Workbench Utilities, Interface Tools
mysql-bin.index file, Replication Files
mysql-relay-bin.index file, Replication Files
mysqladmin, Command-Line Utilities, SHOW STATUS
mysqlbinlog tool, Statement-Based Replication, Creating a log server, Locating the desired log positions, Recovering with a log server
mysqlcheck tool, Raw backups, Command-Line Utilities
mysqld tool, What kinds of data should you collect?, Creating a MySQL Configuration File
mysqldump tool, Initializing a Replica from Another Server, Resyncing a Replica from the Master, Defining Recovery Requirements, Logical backups, SQL dumps, mysqldump
mysqlhotcopy tool, Backup and Recovery Tools
mysqlimport tool, Logical backups, Loading delimited files
mysqlslap tool, Single-Component Tools
mysql_query() function, The MySQL Client/Server Protocol, Prepared Statements
mysql_unbuffered_query() function, The MySQL Client/Server Protocol
mytop tool, Command-Line Monitoring with Innotop

N

Nagios, Open Source Monitoring Tools
Nagios System and Network Monitoring (Barth), Creating, mounting, and removing an LVM snapshot, Open Source Monitoring Tools
name locks, Lock Waits at the Server Level, Name Locks
NAS (network-attached storage), Storage Area Networks and Network-Attached Storage–Should You Use a SAN?
NAT (network address translation), Middleman Solutions
Native POSIX Threads Library (NPTL), Threading
natural identifiers, Normalization and Denormalization
natural-language full-text searches, Natural-Language Full-Text Searches
NDB API, Alternatives to MySQL
NDB Cluster storage engine, The NDB Cluster engine, Choosing a partitioning key, Scaling by Clustering, MySQL Cluster (NDB Cluster), MySQL Cluster
nesting cursors, Cursors
netcat, Avoiding Encryption Overhead
network address translation (NAT), Middleman Solutions
network configuration, Network Configuration–Network Configuration
network overhead, Are You Asking the Database for Data You Don’t Need?
network performance, The Four Fundamental Resources
network provider, reliance on single, Avoiding Single Points of Failure
network-attached storage (NAS), Storage Area Networks and Network-Attached Storage–Should You Use a SAN?
New Relic, Profiling Your Application, Commercial Monitoring Systems
next-key locking, InnoDB overview
NFS, SAN over, Using a SAN over NFS or SMB
Nginx, Web Server Issues, Caching Below the Application
nice, Online or Offline Backups?
nines rule of availability, What Is High Availability?
Noach, Shlomi, Redundant and Duplicate Indexes, Command-Line Utilities, SHOW STATUS, The INFORMATION_SCHEMA
nodes, Scaling Out, Allocating data, shards, and nodes
non-SELECT queries, Rewriting Non-SELECT Queries
nondeterministic statements, Nondeterministic Statements
nonrepeatable reads, Isolation Levels
nonreplicated data, Dependencies on Nonreplicated Data
nonsharded data, Querying across shards
nontransactional tables, Using Nontransactional Tables
nonunique server IDs, Nonunique Server IDs
nonvolatile random access memory (NVRAM), Solid-State Storage
normalization, Normalization and Denormalization–A Mixture of Normalized and Denormalized
NOT EXISTS() queries, The query optimizer, When a correlated subquery is good
NOT NULL, Choosing Optimal Data Types, Drizzle
NOW() function, How MySQL Checks for a Cache Hit
NOW_USEC() function, User-Defined Functions, How Fast Is Replication?
NPTL (Native POSIX Threads Library), Threading
NULL, Choosing Optimal Data Types, Schema Design Gotchas in MySQL, What Can Go Wrong
null hypothesis, Running the Benchmark and Analyzing Results
NULLIF() function, Making evaluation order deterministic
NuoDB, OLTP storage engines
NVRAM (nonvolatile random access memory), Solid-State Storage

O

object versioning, Cache Control Policies
object-relational mapping (ORM) tool, Choosing Identifiers, Indexing Basics, Common Problems
OCZ, PCIe Storage Devices
OFFSET variable, Optimizing LIMIT and OFFSET
OLTP (online transaction processing), OLTP storage engines, What to Measure, The sysbench OLTP benchmark, Separating functions, Do writes in parallel outside of replication, MySQL Performance in Cloud Hosting
on-controller cache (see RAID)
on-disk caches, Application-Level Caching
on-disk temporary tables, BLOB and TEXT types
online transaction processing (OLTP), OLTP storage engines, What to Measure, The sysbench OLTP benchmark, Separating functions, Do writes in parallel outside of replication, MySQL Performance in Cloud Hosting
open() function, How InnoDB opens and flushes log and data files
openark kit, Command-Line Utilities
opened tables, The Table Cache
opening and locking partitions, What Can Go Wrong
OpenNMS, Open Source Monitoring Tools
operating system
choosing an, Choosing an Operating System
how to select CPUs for MySQL, How to Select CPUs for MySQL
optimization, Operating System and Hardware Optimization
status of, Operating System Status–An Idle Machine
what limits performance, What Limits MySQL’s Performance?
oprofile tool, What kinds of data should you collect?–Interpreting the data, Using strace
Opsview, Open Source Monitoring Tools
optimistic concurrency control, Multiversion Concurrency Control
optimization, Optimization and Execution
(see also application-level optimization)
(see also query optimization)
BLOB workload, Optimizing for BLOB and TEXT Workloads
DISTINCT queries, Optimizing GROUP BY and DISTINCT
filesort, Optimizing for Filesorts
full-text indexes, Full-Text Configuration and Optimization
GROUP BY queries, Optimizing GROUP BY and DISTINCT, Optimizing GROUP BY Queries, Optimizing GROUP BY on BoardReader.com
JOIN queries, Optimizing JOIN Queries
LIMIT and OFFSET, Optimizing LIMIT and OFFSET
OPTIMIZE TABLE command, Comparison of InnoDB and MyISAM data layout, Full-Text Tradeoffs and Workarounds, Dependencies on Nonreplicated Data
optimizer traces, Improvements in MySQL 5.6
optimizer_prune_level, Query Optimizer Hints
optimizer_search_depth, Query Optimizer Hints
optimizer_switch, Query Optimizer Hints
prepared statements, Prepared Statement Optimization
queries, Optimizing Queries
query cache, General Query Cache Optimizations
query optimizer, The query optimizer–The query optimizer
RAID performance, RAID Performance Optimization–RAID Performance Optimization
ranking queries, Optimizing ranking queries
selects on Sahibinden.com, Optimizing Selects on Sahibinden.com
server setting optimization, Optimizing Server Settings
sharded JOIN queries on Grouply.com, Optimizing Sharded JOIN Queries on Grouply.com
for solid-state storage, Optimizing MySQL for Solid-State Storage–Optimizing MySQL for Solid-State Storage
sorts, Optimizing Sorts
SQL_CALC_FOUND_ROWS variable, Optimizing SQL_CALC_FOUND_ROWS
subqueries, Optimizing Subqueries
TEXT workload, Optimizing for BLOB and TEXT Workloads
through profiling, Optimization Through Profiling–Interpreting the Profile, Using the Profile for Optimization
UNION variable, Optimizing UNION
Optimizer
hints
DELAYED, Query Optimizer Hints
FOR UPDATE, Query Optimizer Hints
FORCE INDEX, Query Optimizer Hints
HIGH_PRIORITY, Query Optimizer Hints
IGNORE INDEX, Query Optimizer Hints
LOCK IN SHARE MODE, Query Optimizer Hints
LOW_PRIORITY, Query Optimizer Hints
SQL_BIG_RESULT, Query Optimizer Hints
SQL_BUFFER_RESULT, Query Optimizer Hints
SQL_CACHE, Query Optimizer Hints
SQL_CALC_FOUND_ROWS, Query Optimizer Hints
SQL_NO_CACHE, Query Optimizer Hints
SQL_SMALL_RESULT, Query Optimizer Hints
STRAIGHT_JOIN, Query Optimizer Hints
USE INDEX, Query Optimizer Hints
limitations of
correlated subqueries, Correlated Subqueries–When a correlated subquery is good
equality propogation, Equality Propagation
hash joins, Hash Joins
index merge optimizations, Index Merge Optimizations
loose index scans, Loose Index Scans
MIN() and MAX(), MIN() and MAX()
parallel execution, Parallel Execution
SELECT and UPDATE on the Same Table, SELECT and UPDATE on the Same Table
UNION limitations, UNION Limitations
query, The Query Optimization Process–Sort optimizations
complex queries versus many queries, Complex Queries Versus Many Queries
COUNT() aggregate function, Optimizing COUNT() Queries
join decomposition, Join Decomposition
limitations of MySQL, Limitations of the MySQL Query Optimizer–SELECT and UPDATE on the Same Table
optimizing data access, Slow Query Basics: Optimize Data Access–Rows examined and access types
reasons for slow queries, Why Are Queries Slow?
restructuring queries, Ways to Restructure Queries–Join Decomposition
Optimizing Oracle Performance (Millsap), Introduction to Performance Optimization, What Not to Do
options, How MySQL’s Configuration Works
OQGraph storage engine, Community storage engines
Oracle Database, Using Flashcache
Oracle development milestones, MySQL’s Development Model
Oracle Enterprise Linux, Choosing an Operating System
Oracle GoldenGate, Other Replication Technologies
ORDER BY queries, Prefix Indexes and Index Selectivity, Using Index Scans for Sorts, Sort optimizations, Making evaluation order deterministic
order processing, Order processing
ORM (object-relational mapping), Indexing Basics, Common Problems
OurDelta, Other MySQL Variants
out-of-sync replicas, Resyncing a Replica from the Master
OUTER JOIN queries, MySQL’s join execution strategy
outer joins, The query optimizer
outliers, Interpreting the Profile
oversized packets, Oversized Packets from the Master
O_DIRECT variable, How InnoDB opens and flushes log and data files
O_DSYNC variable, How InnoDB opens and flushes log and data files

P

Pacemaker, Moving IP addresses, Failover and Failback
packed indexes, Packed (Prefix-Compressed) Indexes
packed tables, Compressed MyISAM tables
PACK_KEYS variable, Packed (Prefix-Compressed) Indexes
page splits, Clustered Indexes
paging, Swapping
PAM authentication, Plugins
parallel execution, Parallel Execution
parallel result sets, Generating Parallel Result Sets
parse tree, Optimization and Execution
parser, The parser and the preprocessor
PARTITION BY variable, Partitioned Tables, What Can Go Wrong
partitioning, RAID Performance Optimization
across multiple nodes, Scaling Out
how to use, How to Use Partitioning
keys, Choosing a partitioning key
with replication filters, Load Balancing with a Master and Multiple Replicas
sharding, Data sharding–Tools for sharding, Summary, Aggregating Sharded Data
tables, Partitioned Tables–Merge Tables, Summary
types of, Types of Partitioning
passive caches, Caching
Patricia tries, Other types of index
PBXT, OLTP storage engines
PCIe cards, Solid-State Storage, PCIe Storage Devices
Pen, Load Balancing
per-connection memory needs, Per-Connection Memory Needs
per-connection needs, Per-Connection Memory Needs
percent() function, Command-Line Monitoring with Innotop
percentile response times, What to Measure
Percona InnoDB Recovery Toolkit, How to recover corrupted InnoDB data
Percona Server, MySQL Performance in Cloud Hosting, Percona Server, Tables in Percona Server
BLOB and TEXT types, BLOB and TEXT types
buffer pool, Tables in Percona Server
bypassing operating system caches, Creating a MySQL Configuration File
corrupted tables, How to recover corrupted InnoDB data
doublewrite buffer, Optimizing MySQL for Solid-State Storage
enhanced slow query log, Using the slow query log
expand_fast_index_creation, Reducing Index and Data Fragmentation
extended slow query log, When the Query Cache Is Helpful, Summary
fast warmup features, The InnoDB Buffer Pool, Adding and removing servers in the pool, MySQL Performance in Cloud Hosting
FNV64() function, Handling hash collisions
HandlerSocket plugin, Plugins
idle transaction timeout parameter, Using the INFORMATION_SCHEMA Tables
INFORMATION_SCHEMA.INDEX_STATISTICS table, Unused Indexes
innobd_use_sys_stats_table option, Updating Index Statistics
InnoDB online text creation, Building MyISAM Indexes Quickly
innodb_overwrite_relay_log_info option, Safety and Sanity Settings
innodb_read_io_threads option, FILE I/O
innodb_recovery_stats option, Log file size and the log buffer
innodb_use_sys_stats_table option, The InnoDB Data Dictionary
innodb_write_io_threads option, FILE I/O
larger log files, Optimizing MySQL for Solid-State Storage
lazy page invalidation, Configuring the tablespace
limit data dictionary size, The InnoDB Data Dictionary, Tables in Percona Server
mutex issues, Advanced InnoDB Settings
mysqldump, Logical backups
object-level usage statistics, Using the USER_STATISTICS Tables
query-level instrumentation, Optimization Through Profiling
read-ahead, Optimizing MySQL for Solid-State Storage
replication, When Will Replicas Begin to Lag?, Errors Caused by Data Corruption or Loss, Excessive Replication Lag, Advanced Features in MySQL Replication
slow query log, Optimization Through Profiling, Capturing MySQL’s queries to a log, Analyzing the query log, Using the slow query log, Using query logging
stripping query comments, How MySQL Checks for a Cache Hit
temporary tables, Temporary Files and Tables, Tables in Percona Server
user statistics tables, Tables in Percona Server
Percona Toolkit, Command-Line Utilities
Aspersa, Command-Line Utilities
Maatkit, Backup and Recovery Tools, Command-Line Utilities
mk-parallel-dump tool, SQL dumps
mk-parallel-restore tool, SQL dumps
mk-query-digest tool, Optimization Through Profiling
mk-slave-prefetch tool, Prime the cache for the replication thread
pt-archiver, Chopping Up a Query, Data archiving, Lock Contention Caused by InnoDB Locking Selects, Rebalancing shards, Scaling Back
pt-collect, What kinds of data should you collect?, Other Helpful Tools
pt-deadlock-logger, LATEST DETECTED DEADLOCK
pt-diskstats, Capturing System Performance and Status, Other Helpful Tools
pt-duplicate-key-checker, Redundant and Duplicate Indexes
pt-fifo-split, Loading delimited files
pt-find, Missing Temporary Tables
pt-heartbeat, Master, Distribution Master, and Replicas, Measuring Replication Lag, Locating the desired log positions, Splitting reads and writes in replication
pt-index-usage, Unused Indexes
pt-kill, Using the INFORMATION_SCHEMA Tables
pt-log-player, Iterative Optimization by Benchmarking
pt-mext, Inspecting MySQL Server Status Variables, SHOW STATUS
pt-mysql-summary, Interpreting the data, A Case Study in Diagnostics, Inspecting MySQL Server Status Variables, Summary
pt-online-schema-change, CREATE and SELECT
pt-pmp, What kinds of data should you collect?, Interpreting the data, Which Is Better: Fast CPUs or Many CPUs?
pt-query-advisor, Static Query Analysis
pt-query-digest, Workload-Based Configuration, Excessive Replication Lag, Adding and removing servers in the pool
extracting from comments, Instrumenting PHP Applications
profiling, Optimization Through Profiling–Interpreting the Profile
query log, Analyzing the query log–Analyzing the query log
slow query logging, Using the slow query log, Using query logging, Iterative Optimization by Benchmarking
pt-sift, Interpreting the data, Other Helpful Tools
pt-slave-delay, Advanced Features in MySQL Replication, Replication
pt-slave-restart, Errors Caused by Data Corruption or Loss
pt-stalk, The diagnostic trigger, What kinds of data should you collect?, Other Helpful Tools
pt-summary, Interpreting the data, A Case Study in Diagnostics, Summary
pt-table-checksum, Determining Whether Replicas Are Consistent with the Master, Errors Caused by Data Corruption or Loss, Summary, Replication
pt-table-sync, Resyncing a Replica from the Master
pt-tcp-model, Finding the Optimal Concurrency
pt-upgrade, Redundant and Duplicate Indexes, Query Optimizer Hints, Improving Mean Time Between Failures, Improvements in MySQL 5.6
pt-visual-explain, Tree-Formatted Output
Percona tools, Single-Component Tools, Percona’s TPCC-MySQL Tool–Percona’s TPCC-MySQL Tool, Finding and Repairing Table Corruption
Percona XtraBackup, Initializing a Replica from Another Server, Designing a MySQL Backup Solution, Online or Offline Backups?, Incremental and differential backups, Restoring Raw Files, Percona XtraBackup
Percona XtraDB Cluster, Other Replication Technologies, Scaling by Clustering, Percona XtraDB Cluster–Percona XtraDB Cluster, Percona Server
performance optimization, Introduction to Performance Optimization–Introduction to Performance Optimization, A Case Study in Diagnostics
plotting metrics, The Importance of Plotting
profiling, Optimization Through Profiling–Interpreting the Profile
SAN, MySQL Performance on a SAN
views and, Performance Implications of Views
Performance Schema, Using the Performance Schema
Perl scripts, Improving Mean Time to Recovery
Perldoc, Scripting Backups
perror utility, The Table Cache
persistent connections, Load balancers, Common Problems
persistent memory, MySQL Performance in Cloud Hosting
pessimistic concurrency control, Multiversion Concurrency Control
phantom reads, Isolation Levels
PHP profiling tools, Instrumenting PHP Applications
phpMyAdmin tool, Interface Tools
phrase proximity ranking, Phrase Proximity Ranking
phrase searches, Boolean Full-Text Searches
physical reads, Caching, Reads, and Writes
physical size of disk, Choosing Hard Disks
pigz tool, Online or Offline Backups?
“pileups”, Profiling Server Performance
Pingdom, Commercial Monitoring Systems
pinging, Common Problems, Command Counters
Planet MySQL blog aggregator, Command-Line Utilities
planned promotions, Planned promotions
plugin-specific variables, Plugin-Specific
plugins, Plugins
point-in-time recovery, Designing a MySQL Backup Solution, Point-in-Time Recovery
poor man’s profiler, Interpreting the data
port forwarding, Middleman Solutions
possible_keys column, The possible_keys Column
post-mortems, Improving Mean Time to Recovery
PostgreSQL, Computing the Distance Between Points
potential cache size, When the Query Cache Is Helpful
power grid, Avoiding Single Points of Failure
preferring a join, Optimizing Subqueries
prefix indexes, Prefix Indexes and Index Selectivity–Prefix Indexes and Index Selectivity
prefix-compressed indexes, Packed (Prefix-Compressed) Indexes
preforking, Web Server Issues
pregenerating content, Pregenerating Content
prepared statements, Prepared Statements–Limitations of Prepared Statements, Summary
preprocessor, The parser and the preprocessor
Preston, W. Curtis, Backup and Recovery
primary key, InnoDB overview, Inserting rows in primary key order with InnoDB–Inserting rows in primary key order with InnoDB
PRIMARY KEY constraint, Redundant and Duplicate Indexes
priming the cache, Prime the cache for the replication thread
PROCEDURE ANALYSE command, Plugins
procedure plugins, Plugins
processor speed, Scaling to Many CPUs and Cores
profiling
and application speed, Profiling Your Application
applications, Profiling Your Application–Instrumenting PHP Applications
diagnosing intermittent problems, Diagnosing Intermittent Problems–A Case Study in Diagnostics
interpretation, Interpreting the Profile
MySQL queries, Profiling MySQL Queries–Analyzing the query log
optimization through, Optimization Through Profiling–Interpreting the Profile, Using the Profile for Optimization
single queries, Profiling a Single Query–Using the Performance Schema
tools, Optimization Through Profiling, Other Profiling Tools–Using strace
promotions of replicas, Unplanned promotions, Promoting a Replica or Switching Roles
propagation of changes, Virtual IP Addresses or IP Takeover
proprietary plugins, MySQL’s Development Model
proxies, Load Balancing, Middleman Solutions, Web Server Issues
pruning, What Can Go Wrong
pt-archiver tool, Chopping Up a Query, Data archiving, Lock Contention Caused by InnoDB Locking Selects, Rebalancing shards, Scaling Back
pt-collect tool, What kinds of data should you collect?, Other Helpful Tools
pt-deadlock-logger tool, LATEST DETECTED DEADLOCK
pt-diskstats tool, Capturing System Performance and Status, Other Helpful Tools
pt-duplicate-key-checker tool, Redundant and Duplicate Indexes
pt-fifo-split tool, Loading delimited files
pt-find tool, Missing Temporary Tables
pt-heartbeat tool, Master, Distribution Master, and Replicas, Measuring Replication Lag, Locating the desired log positions, Splitting reads and writes in replication
pt-index-usage tool, Unused Indexes
pt-kill tool, Using the INFORMATION_SCHEMA Tables
pt-log-player tool, Iterative Optimization by Benchmarking
pt-mext tool, Inspecting MySQL Server Status Variables, SHOW STATUS
pt-mysql-summary tool, Interpreting the data, A Case Study in Diagnostics, Inspecting MySQL Server Status Variables, Summary
pt-online-schema-change tool, CREATE and SELECT
pt-pmp tool, What kinds of data should you collect?, Interpreting the data, Which Is Better: Fast CPUs or Many CPUs?
pt-query-advisor tool, Static Query Analysis
pt-query-digest (see Percona Toolkit)
pt-sift tool, Interpreting the data, Other Helpful Tools
pt-slave-delay tool, Advanced Features in MySQL Replication, Replication
pt-slave-restart tool, Errors Caused by Data Corruption or Loss
pt-stalk tool, The diagnostic trigger, What kinds of data should you collect?, Other Helpful Tools
pt-summary tool, Interpreting the data, A Case Study in Diagnostics, Summary
pt-table-checksum tool, Determining Whether Replicas Are Consistent with the Master, Errors Caused by Data Corruption or Loss, Summary, Replication
pt-table-sync tool, Resyncing a Replica from the Master
pt-tcp-model tool, Finding the Optimal Concurrency
pt-upgrade tool, Redundant and Duplicate Indexes, Query Optimizer Hints, Improving Mean Time Between Failures, Improvements in MySQL 5.6
pt-visual-explain tool, Tree-Formatted Output
PURGE MASTER LOGS command, Other I/O configuration options, Replication Files, Monitoring Replication
purging old binary logs, Purging Old Binary Logs Safely
pushdown joins, MySQL Cluster (NDB Cluster), MySQL Cluster

Q

Q mode, Command-Line Monitoring with Innotop
Q4M storage engine, Community storage engines
Qcache_lowmem_prunes variable, Reducing fragmentation
query cache, The Query Cache, The MySQL Query Cache, Summary, Query Cache
alternatives to, Alternatives to the Query Cache
configuring and maintaining, How to Configure and Maintain the Query Cache–Reducing fragmentation
InnoDB and the, InnoDB and the Query Cache
memory use, How the Cache Uses Memory
optimizations, General Query Cache Optimizations
when to use, When the Query Cache Is Helpful–When the Query Cache Is Helpful
query execution
MySQL client/server protocol, The MySQL Client/Server Protocol–Query states
optimization process, The Query Optimization Process
query cache, The Query Optimization Process, The MySQL Query Cache–Alternatives to the Query Cache
query execution engine, The Query Execution Engine
query logging, Using query logging
query optimization, The Query Optimization Process–Sort optimizations
complex queries versus many queries, Complex Queries Versus Many Queries
COUNT() aggregate function, Optimizing COUNT() Queries
join decomposition, Join Decomposition
limitations of MySQL, Limitations of the MySQL Query Optimizer–SELECT and UPDATE on the Same Table
optimizing data access, Slow Query Basics: Optimize Data Access–Rows examined and access types
reasons for slow queries, Why Are Queries Slow?
restructuring queries, Ways to Restructure Queries–Join Decomposition
query states, Query states
query-based splits, Splitting reads and writes in replication
querying across shards, Querying across shards
query_cache_limit variable, How to Configure and Maintain the Query Cache
query_cache_min_res_unit value variable, How to Configure and Maintain the Query Cache
query_cache_size variable, How to Configure and Maintain the Query Cache, Side Effects of Setting Variables
query_cache_type variable, How to Configure and Maintain the Query Cache
query_cache_wlock_invalidate variable, How to Configure and Maintain the Query Cache
queue scheduler, Choosing a Disk Queue Scheduler
queue tables, Building a Queue Table in MySQL
queue time, Response time
quicksort, Sort optimizations

R

R-Tree indexes, Spatial (R-Tree) indexes
Rackspace Cloud, MySQL in the Cloud
RAID
balancing hardware and software, Balancing Hardware RAID and Software RAID
configuration and caching, RAID Configuration and Caching–The RAID cache
failure, recovery, and monitoring, RAID Failure, Recovery, and Monitoring
moving files from flash to, Optimizing MySQL for Solid-State Storage
not for backup, Defining Recovery Requirements
performance optimization, RAID Performance Optimization–RAID Performance Optimization
splits, Other uses and alternatives
with SSDs, Using RAID with SSDs
RAND() function, Prefix Indexes and Index Selectivity, The select_type Column
random read-ahead, Optimizing MySQL for Solid-State Storage
random versus sequential I/O, Random Versus Sequential I/O
RANGE COLUMNS type, Types of Partitioning
range conditions, Avoiding Multiple Range Conditions
raw file
backup, Logical or Raw Backups?
restoration, Restoring Raw Files
RDBMS technology, Solid-State Storage
RDS (Relational Database Service), MySQL in the Cloud, Amazon RDS
read buffer size, Creating a MySQL Configuration File
READ COMMITTED isolation level, Isolation Levels, Multiversion Concurrency Control
read locks, Read/Write Locks, Indexes and Locking
read threads, FILE I/O
READ UNCOMMITTED isolation level, Isolation Levels, Multiversion Concurrency Control
read-ahead, Optimizing MySQL for Solid-State Storage
read-around writes, The MyISAM key block size
read-mostly tables, Read-only or read-mostly tables
read-only variable, Read-only or read-mostly tables, Safety and Sanity Settings, Recommended Replication Configuration, Read-only replicas
read-write splitting, Splitting reads and writes in replication
read_buffer_size variable, Side Effects of Setting Variables
Read_Master_Log_Pos, Unplanned promotions
read_rnd_buffer_size variable, Side Effects of Setting Variables
real number data types, Real Numbers
rebalancing shards, Rebalancing shards
records_in_range() function, Updating Index Statistics
recovery
from a backup, Recovering from a Backup–How to recover corrupted InnoDB data
defined, Backup and Recovery
defining requirements, Defining Recovery Requirements
more advanced techniques, More Advanced Recovery Techniques
recovery point objective (RPO), Defining Recovery Requirements, Designing a MySQL Backup Solution
recovery time objective (RTO), Defining Recovery Requirements, Designing a MySQL Backup Solution
Red Hat, Choosing an Operating System, Other MySQL Variants
Redis, Alternatives to MySQL
redundancy, replication-based, Replication-Based Redundancy
Redundant Array of Inexpensive Disks (see RAID)
redundant indexes, Redundant and Duplicate Indexes–Redundant and Duplicate Indexes
ref column, The ref Column
Relational Database Index Design and the Optimizers (Lahdenmaki & Leach), Benefits of Indexes, Response time
Relational Database Service (RDS), Amazon, MySQL in the Cloud, Amazon RDS
relay log, How Replication Works, Errors Caused by Data Corruption or Loss
relay-log.info file, Replication Files
relay_log variable, Configuring the Master and Replica, Recommended Replication Configuration
relay_log_purge variable, Recommended Replication Configuration
relay_log_space_limit variable, Recommended Replication Configuration, No Disk Space
RELEASE_LOCK() function, Building a Queue Table in MySQL
reordering joins, The query optimizer
REORGANIZE PARTITION command, What Can Go Wrong
REPAIR TABLE command, Building MyISAM Indexes Quickly, MyISAM I/O Configuration
repairing MyISAM tables, MyISAM features
REPEATABLE READ isolation level, Isolation Levels, Multiversion Concurrency Control, Data consistency
replica hardware, Choosing Hardware for a Replica
replica shutdown, unexpected, Errors Caused by Data Corruption or Loss
replicate_ignore_db variable, Data archiving
replication, Replication, Replication
administration and maintenance, Replication Administration and Maintenance
advanced features in MySQL, Advanced Features in MySQL Replication
backing up configuration, What to Back Up
and capacity planning, Replication and Capacity Planning–When Will Replicas Begin to Lag?
changing masters, Changing Masters–Locating the desired log positions
checking consistency of, Determining Whether Replicas Are Consistent with the Master
checking for up-to-dateness, Load Balancing with a Master and Multiple Replicas
configuring master and replica, Configuring the Master and Replica
creating accounts for, Creating Replication Accounts
custom solutions, Custom Replication Solutions–Creating a log server
filtering, Replication Filters, Load Balancing with a Master and Multiple Replicas
how it works, How Replication Works
initializing replica from another server, Initializing a Replica from Another Server
limitations, Replication Limitations
master and multiple replicas, Master and Multiple Replicas
master, distribution master, and replicas, Master, Distribution Master, and Replicas
master-master in active-active mode, Master-Master in Active-Active Mode
master-master in active-passive mode, Master-Master in Active-Passive Mode
master-master with replicas, Master-Master with Replicas
measuring lag, Measuring Replication Lag
monitoring, Monitoring Replication
other technologies, Other Replication Technologies
problems and solutions, Replication Problems and Solutions–Replication Limitations
problems solved by, Problems Solved by Replication
promotions of replicas, Unplanned promotions, Promoting a Replica or Switching Roles
recommended configuration, Recommended Replication Configuration
replica consistency with master, Determining Whether Replicas Are Consistent with the Master
replication files, Replication Files
resyncing replica from master, Resyncing a Replica from the Master
ring, Ring Replication
row-based, Replication Overview, Row-Based Replication–Statement-Based or Row-Based: Which Is Better?
sending events to other replicas, Sending Replication Events to Other Replicas
setting up, Setting Up Replication
speed of, How Fast Is Replication?–How Fast Is Replication?
splitting reads and writes in, Splitting reads and writes in replication
starting the replica, Starting the Replica–Starting the Replica
statement-based, Replication Overview, Statement-Based Replication–Statement-Based or Row-Based: Which Is Better?
status, Replication Status
switching master-master configuration roles, Switching Roles in a Master-Master Configuration
topologies, Replication Topologies, Planned promotions
tree or pyramid, Tree or Pyramid
REPLICATION CLIENT privilege, Creating Replication Accounts
REPLICATION SLAVE privilege, Creating Replication Accounts
replication-based redundancy, Replication-Based Redundancy
RESET QUERY CACHE command, Reducing fragmentation
RESET SLAVE command, Planned promotions
resource consumption, Introduction to Performance Optimization
response time, What to Measure, Introduction to Performance Optimization, Response time
restoring
defined, Backup and Recovery
logical backups, Restoring Logical Backups–Loading delimited files
RethinkDB, OLTP storage engines
ring replication, Ring Replication
ROLLBACK command, Mixing Transactional and Nontransactional Tables
round-robin database (RRD) files, Open Source Monitoring Tools
row fragmentation, Reducing Index and Data Fragmentation
row locks, Row locks, Implicit and explicit locking
ROW OPERATIONS, ROW OPERATIONS
row-based logging, The Binary Log Format
row-based replication, Replication Overview, Row-Based Replication–Statement-Based or Row-Based: Which Is Better?
rows column, The rows Column
rows examined, number of, Rows examined and rows returned
rows returned, number of, Rows examined and rows returned
ROW_COUNT command, Triggers
RPO (recovery point objective), Defining Recovery Requirements, Designing a MySQL Backup Solution
RRDTool, Open Source Monitoring Tools
rsync, Finding and Repairing Table Corruption, Initializing a Replica from Another Server, Other Options, File Copy Benchmarks
RTO (recovery time objective), Defining Recovery Requirements, Designing a MySQL Backup Solution
running totals and averages, Other uses for variables

S

safety and sanity settings, Safety and Sanity Settings–Safety and Sanity Settings
Sahibinden.com, Optimizing Selects on Sahibinden.com
SandForce, Other Types of Solid-State Storage
SANs (storage area networks), Storage Area Networks and Network-Attached Storage–Should You Use a SAN?
sar, Operating System Status
sargs, Choosing a Good Column Order
SATA SSDs, Using RAID with SSDs
scalability, What Is Scalability?
by clustering, Scaling by Clustering
by consolidation, Scaling by Consolidation
frequency, Scaling to Many CPUs and Cores
and load balancing, Load Balancing
mathematical definition, A Formal Definition
multiple CPUs/cores, Scaling to Many CPUs and Cores
planning for, Planning for Scalability
preparing for, Buying Time Before Scaling
“scale-out” architecture, Replication
scaling back, Scaling Back
scaling out, Scaling Out–Tools for sharding
scaling pattern, Scaling to Many CPUs and Cores
scaling up, Scaling Up
scaling writes, Why Replication Doesn’t Help Scale Writes
Sphinx, Scaling
universal law of, A Formal Definition–A Formal Definition
scalability measurements, What to Measure
ScaleArc, Tools for sharding, Scaling by Clustering
ScaleBase, Tools for sharding, Scaling by Clustering, ScaleBase, MySQL Scaling and HA in the Cloud
ScaleDB, Other Types of Solid-State Storage, Shared Storage or Replicated Disk
scanning data, How to Use Partitioning
scheduled tasks, Lock Contention Caused by InnoDB Locking Selects
schemas, MySQL’s Storage Engines
changes, CREATE and SELECT
design, Schema Design Gotchas in MySQL
normalized and denormalized, Pros and Cons of a Denormalized Schema
Schooner Active Cluster, Scaling by Clustering
scope, Syntax, Scope, and Dynamism
scp, A Naïve Example
search engine, selecting the right, Selecting the Right Engine–Large data volumes
search space, The join optimizer
searchd, Sphinx, A Typical Sphinx Search, Scaling, Architectural Overview–Full-Text Searching on BoardReader.com
secondary indexes, InnoDB overview, How to recover corrupted InnoDB data
security, connection management, Connection Management and Security
sed, SQL dumps
segmented key cache, MyISAM performance
segregating hot data, How to Use Partitioning
SELECT command, SELECT and UPDATE on the Same Table, How Partitioning Works, Rewriting Non-SELECT Queries
SELECT FOR UPDATE command, Building a Queue Table in MySQL, Triggers
SELECT INTO OUTFILE command, Special-case behaviors, Lock Contention Caused by InnoDB Locking Selects, Don’t duplicate the expensive part of writes, Amazon RDS, Delimited file backups, Loading delimited files, How to recover corrupted InnoDB data
SELECT types, SELECT Types
selective replication, Selective replication
selectivity, index, Prefix Indexes and Index Selectivity
select_type column, The select_type Column
SEMAPHORES, SEMAPHORES
sequential versus random I/O, Random Versus Sequential I/O
sequential writes, Shared Storage or Replicated Disk
SERIALIZABLE isolation level, Isolation Levels, Multiversion Concurrency Control
serialized writes, Do writes in parallel outside of replication
server, MySQL Server Status
adding/removing, Adding and removing servers in the pool
configuration, backing up, What to Back Up
consolidation, Should You Use a SAN?
INFORMATION_SCHEMA database, Tables in Percona Server
MySQL configuration, How MySQL’s Configuration Works
PERFORMANCE_SCHEMA database, The Performance Schema
profiling and speed of, Profiling Your Application, Profiling a Server’s Workload
server-wide problems, Single-Query Versus Server-Wide Problems–Making sense of the findings
setting optimization, Optimizing Server Settings
SHOW ENGINE INNODB MUTEX command, SHOW ENGINE INNODB MUTEX–Replication Status
SHOW ENGINE INNODB STATUS command, SHOW ENGINE INNODB STATUS–ROW OPERATIONS
SHOW PROCESSLIST command, SHOW PROCESSLIST
SHOW STATUS command, SHOW STATUS–Plugin-Specific
status variables, Inspecting MySQL Server Status Variables
workload profiling, Profiling a Server’s Workload
server-side prepared statements, Limitations of Prepared Statements
service time, Response time
session scope, Syntax, Scope, and Dynamism
session-based splits, Splitting reads and writes in replication
SET CHARACTER SET command, Settings for client/server communication
SET GLOBAL command, Switching Roles in a Master-Master Configuration
SET GLOBAL SQL_SLAVE_SKIP_COUNTER command, Delayed replication for fast recovery
SET NAMES command, Settings for client/server communication
SET NAMES utf8 command, Settings for client/server communication, Common Problems
SET SQL_LOG_BIN command, Not Replicating All Updates
SET TIMESTAMP command, The Binary Log Format
SET TRANSACTION ISOLATION LEVEL command, AUTOCOMMIT
SET type, Bit-Packed Data Types, Choosing Identifiers
SetLimits() function, A Typical Sphinx Search, Advanced Performance Control
SetMaxQueryTime() function, Advanced Performance Control
SeveralNines, MySQL Cluster (NDB Cluster), MySQL Cluster
SHA1() function, Single-Component Tools, Choosing Identifiers, Building your own hash indexes
Shard-Query system, Tools for sharding
sharding, Data sharding–Tools for sharding, Summary, Aggregating Sharded Data
shared locks, Read/Write Locks
shared storage, Shared Storage or Replicated Disk–Shared Storage or Replicated Disk
SHOW BINLOG EVENTS command, Monitoring Replication, Replication Status
SHOW commands, Other uses for variables
SHOW CREATE TABLE command, Choosing Optimal Data Types, Multicolumn Indexes
SHOW CREATE VIEW command, Limitations of Views
SHOW ENGINE INNODB MUTEX command, SEMAPHORES, SHOW ENGINE INNODB MUTEX–Replication Status
SHOW ENGINE INNODB STATUS command, The diagnostic trigger, Log file size and the log buffer, Old row versions and the tablespace, Advanced InnoDB Settings, File consistency, SHOW ENGINE INNODB STATUS–ROW OPERATIONS, Lock Waits in InnoDB
SHOW FULL PROCESSLIST command, Capturing MySQL’s queries to a log, TRANSACTIONS
SHOW GLOBAL STATUS command, Using SHOW STATUS, Using SHOW GLOBAL STATUS, Inspecting MySQL Server Status Variables, SHOW STATUS
SHOW INDEX command, Updating Index Statistics
SHOW INDEX FROM command, Updating Index Statistics
SHOW INNODB STATUS command (see SHOW ENGINE INNODB STATUS command)
SHOW MASTER STATUS command, Configuring the Master and Replica, Initializing a Replica from Another Server, Monitoring Replication, Planned promotions, Splitting reads and writes in replication, What to Back Up, LVM snapshots for online backups
SHOW PROCESSLIST command, Using SHOW PROCESSLIST–Making sense of the findings, Building a Queue Table in MySQL, Events, Common Problems, SHOW PROCESSLIST
SHOW PROFILE command, Using SHOW PROFILE–Using SHOW STATUS
SHOW RELAYLOG EVENTS command, Replication Status
SHOW SLAVE STATUS command, Starting the Replica, Initializing a Replica from Another Server, Measuring Replication Lag, Unplanned promotions, Splitting reads and writes in replication, What to Back Up, Replication Status
SHOW STATUS command, Using SHOW STATUS, The MyISAM Key Caches
SHOW TABLE STATUS command, MySQL’s Storage Engines, Updating Index Statistics, Configuring the tablespace, Commercial Monitoring Systems
SHOW VARIABLES command, The MyISAM Key Caches, System Variables
SHOW WARNINGS command, The execution plan, Views
signed types, Whole Numbers
single-component benchmarking, Benchmarking Strategies, Single-Component Tools
single-level cell (SLC), Flash Technologies, PCIe Storage Devices
single-shard queries, Choosing a partitioning key
single-transaction variable, Initializing a Replica from Another Server, Data consistency
skip_innodb variable, Master, Distribution Master, and Replicas
skip_name_resolve variable, Safety and Sanity Settings, Network Configuration, Improving Mean Time Between Failures
skip_slave_start variable, Safety and Sanity Settings, Recommended Replication Configuration
slavereadahead tool, Prime the cache for the replication thread
slave_compressed_protocol variable, Master, Distribution Master, and Replicas, Limited Replication Bandwidth
slave_master_info variable, Safety and Sanity Settings
slave_net_timeout variable, Safety and Sanity Settings
Slave_open_temp_tables variable, Missing Temporary Tables
SLC (single-level cell), Flash Technologies, PCIe Storage Devices
Sleep state, Common Problems
SLEEP() function, Building a Queue Table in MySQL, Drizzle, Table Locks
sleeping before entering queue, InnoDB Concurrency Configuration
slots, SEMAPHORES
slow queries, Introduction to Performance Optimization, Optimization Through Profiling, Profiling a Server’s Workload, Using the slow query log, A Case Study in Diagnostics, When the Query Cache Is Helpful
SMALLBLOB type, BLOB and TEXT types
SMALLINT type, Whole Numbers
SMALLTEXT type, BLOB and TEXT types
Smokeping tool, Network Configuration
snapshots, Initializing a Replica from Another Server, Designing a MySQL Backup Solution, Filesystem Snapshots–Recovering from a Backup
Solaris SPARC hardware, Choosing an Operating System
Solaris ZFS filesystem, Choosing an Operating System
solid-state drives (SSD), Indexing for High Performance, How to Use Partitioning, How InnoDB flushes the log buffer, Solid-State Drives (SSDs)
solid-state storage, Solid-State Storage–Optimizing MySQL for Solid-State Storage
sort buffer size, Creating a MySQL Configuration File
sort optimizations, Sort optimizations, Sorts
sorting, Optimizing Sorts
sort_buffer_size variable, Side Effects of Setting Variables
Souders, Steve, Web Server Issues
SourceForge, Single-Component Tools
SPARC hardware, Choosing an Operating System
spatial indexes, Spatial (R-Tree) indexes
Sphinx, Full-Text Configuration and Optimization, Extending MySQL, Using Sphinx with MySQL, Summary
advanced performance control, Advanced Performance Control
applying WHERE clauses, Applying WHERE Clauses Efficiently
architectural overview, Architectural Overview–Typical Partition Use
efficient and scalable full-text searching, Efficient and Scalable Full-Text Searching
filtering, Filtering
finding top results in order, Finding the Top Results in Order
geospatial search functions, Computing the Distance Between Points
installation overview, Installation Overview
optimizing GROUP BY queries, Optimizing GROUP BY Queries, Optimizing GROUP BY on BoardReader.com
optimizing selects on Sahibinden.com, Optimizing Selects on Sahibinden.com
optimizing sharded JOIN queries on Grouply.com, Optimizing Sharded JOIN Queries on Grouply.com
phrase proximity ranking, Phrase Proximity Ranking
searching, A Typical Sphinx Search–A Typical Sphinx Search
special features, Special Features–Advanced Performance Control
SphinxSE, Architectural Overview, Special Features, The SphinxSE Pluggable Storage Engine, Optimizing Selects on Sahibinden.com
support for attributes, Support for Attributes
typical partition use, Typical Partition Use
Spider storage engine, Community storage engines
spin-wait, SEMAPHORES
spindle rotation speed, Choosing Hard Disks
splintering, Data sharding–Tools for sharding
split-brain syndrome, Shared Storage or Replicated Disk, Percona XtraDB Cluster
splitting reads and write in replication, Splitting reads and writes in replication
Splunk, Commercial Monitoring Systems
spoon-feeding, Web Server Issues
SQL and Relational Theory (Date), Other uses for variables
SQL Antipatterns (Karwin), Case Studies
SQL dumps, SQL dumps
SQL interface prepared statements, Limitations of Prepared Statements
SQL slave thread, How Replication Works
SQL statements, SQL dumps
SQL utilities, SQL Utilities
sql-bench, Single-Component Tools
SQLyog tool, Interface Tools
SQL_BIG_RESULT hint, Query Optimizer Hints, Optimizing GROUP BY and DISTINCT
SQL_BUFFER_RESULT hint, Query Optimizer Hints
SQL_CACHE hint, Query Optimizer Hints
SQL_CACHE variable, When the Query Cache Is Helpful, General Query Cache Optimizations
SQL_CALC_FOUND_ROWS hint, Query Optimizer Hints
SQL_CALC_FOUND_ROWS variable, Optimizing SQL_CALC_FOUND_ROWS
sql_mode, Safety and Sanity Settings
SQL_MODE configuration variable, Optimizing GROUP BY and DISTINCT
SQL_NO_CACHE hint, Query Optimizer Hints
SQL_NO_CACHE variable, General Query Cache Optimizations
SQL_SMALL_RESULT hint, Query Optimizer Hints, Optimizing GROUP BY and DISTINCT
Squid, Web Server Issues
SSD (solid-state drives), Indexing for High Performance, How to Use Partitioning, How InnoDB flushes the log buffer, Solid-State Drives (SSDs)
SSH, A One-Step Method
staggering numbers, Writing to Both Masters in Master-Master Replication
stale-data splits, Splitting reads and writes in replication
“stalls”, Profiling Server Performance
Starkey, Jim, OLTP storage engines
START SLAVE command, Delayed replication for fast recovery
START SLAVE UNTIL command, Delayed replication for fast recovery
start-position variable, Errors Caused by Data Corruption or Loss
statement handles, Prepared Statements
statement-based replication, Replication Overview, Statement-Based Replication–Statement-Based or Row-Based: Which Is Better?
static optimizations, The query optimizer
static query analysis, Static Query Analysis
STEC, PCIe Storage Devices
STONITH, Virtual IP Addresses or IP Takeover
STOP SLAVE command, Determining Whether Replicas Are Consistent with the Master, Planned promotions, Using Nontransactional Tables
stopwords, Full-Text Searching, Full-Text Configuration and Optimization
storage area networks (SANs), Storage Area Networks and Network-Attached Storage–Should You Use a SAN?
storage capacity, Choosing Hard Disks
storage consolidation, Should You Use a SAN?
storage engine API, MySQL’s Logical Architecture
storage engines, MySQL’s Storage Engines, Community storage engines–Large data volumes
Archive, The Archive engine
Blackhole, The Blackhole engine
column-oriented, Column-oriented storage engines
community, Community storage engines
and consistency, File consistency
CSV, The CSV engine
Falcon, OLTP storage engines
Federated, The Federated engine
InnoDB, The InnoDB Engine
Memory, The Memory engine
Merge, The Merge storage engine
mixing, Mixing storage engines in transactions, Different Storage Engines on the Master and Replica
MyISAM, Storage
NDB Cluster, The NDB Cluster engine
OLTP, OLTP storage engines
ScaleDB, Shared Storage or Replicated Disk
XtraDB, Percona Server
stored code, Storing Code Inside MySQL–Storing Code Inside MySQL, Preserving Comments in Stored Code
Stored Procedure Library, SQL Utilities
stored procedures and functions, Stored Procedures and Functions
stored routines, Storing Code Inside MySQL, Summary
strace tool, What kinds of data should you collect?, Using strace
STRAIGHT_JOIN hint, The join optimizer, Query Optimizer Hints
string data types, String Types–Using ENUM instead of a string type, Choosing Identifiers
string locks, Lock Waits at the Server Level
stripe chunk size, The RAID stripe chunk size
subqueries, The query optimizer, Optimizing Subqueries
SUBSTRING() function, BLOB and TEXT types, How Character Sets and Collations Affect Queries, Optimizing for BLOB and TEXT Workloads
sudo rules, What to Back Up
SUM() function, Materialized Views
summary tables, Cache and Summary Tables
Super Smack, Single-Component Tools
surrogate keys, Inserting rows in primary key order with InnoDB
Swanhart, Justin, Materialized Views, Limitations of Views, Tools for sharding
swapping, Swapping, A Swapping Machine
switchover, Failover and Failback
synchronization, two-way, Triggers
synchronous MySQL replication, Synchronous MySQL Replication–Percona XtraDB Cluster
sync_relay_log variable, Safety and Sanity Settings
sync_relay_log_info variable, Safety and Sanity Settings
sysbench, What to Measure, Single-Component Tools, sysbench–Other sysbench features, Balancing Hardware RAID and Software RAID, Should You Use a SAN?, Benchmarks for MySQL in the Cloud
SYSDATE() function, Safety and Sanity Settings
sysdate_is_now variable, Safety and Sanity Settings
system of record approach, Other Replication Technologies
system performance, benchmarking, Capturing System Performance and Status
system under test (SUT), Capturing System Performance and Status
system variables, System Variables

T

table definition cache, The InnoDB Data Dictionary
tables
building a queue, Building a Queue Table in MySQL
cache memory, The Table Cache
column, The table Column–An example of complex SELECT types
conversions, Table Conversions
derived, SELECT and UPDATE on the Same Table, Views, Derived tables and unions
finding and repairing corruption, Finding and Repairing Table Corruption
INFORMATION_SCHEMA in Percona Server, Tables in Percona Server
locks, Table locks, Table Locking, Lock Waits at the Server Level–Finding out who holds a lock
maintenance, Index and Table Maintenance–Reducing Index and Data Fragmentation
merge, Merge Tables–Merge Tables
partitioned, Partitioned Tables–Merge Tables, Summary
reducing to an MD5 hash value, Other uses for variables
SELECT and UPDATE on, SELECT and UPDATE on the Same Table
SHOW TABLE STATUS output, MySQL’s Storage Engines
splitting, Keeping active data separate
statistics, Table and index statistics
tablespaces, InnoDB overview, The InnoDB tablespace
views, Views–Performance Implications of Views
table_cache_size variable, Side Effects of Setting Variables, Completing the Basic Configuration
tagged cache, Cache Control Policies
TCP, Load Balancing, Promoting a Replica or Switching Roles
tcpdump tool, Capturing MySQL’s queries to a log, Using query logging, What kinds of data should you collect?
tcp_max_syn_backlog variable, Network Configuration
temporal computations, Date and Time Types
temporary files and tables, The Memory engine, Missing Temporary Tables, Temporary Files and Tables, Tables in Percona Server
TEMPTABLE algorithm, Views
Texas Memory Systems, PCIe Storage Devices
TEXT type, The Memory engine, BLOB and TEXT types, BLOB and TEXT types
TEXT workload, optimizing for, Optimizing for BLOB and TEXT Workloads
Theory of Constraints, A Formal Definition
third-party storage engines, Third-Party Storage Engines
thread and connection statistics, Thread and Connection Statistics
thread cache memory, The Thread Cache
threaded discussion forums, Bulletin boards and threaded discussion forums
threading, Query states, Threading
Threads_connected variable, The Thread Cache, MySQL Performance in Cloud Hosting
Threads_created variable, The Thread Cache
Threads_running variable, MySQL Performance in Cloud Hosting
thread_cache_size variable, Side Effects of Setting Variables, The Thread Cache, Completing the Basic Configuration
throttling variables, Online or Offline Backups?
throughput, What to Measure, Introduction to Performance Optimization, Choosing Hard Disks, Shared Storage or Replicated Disk
tickets, InnoDB Concurrency Configuration
time to live (TTL), Cache Control Policies
time-based data partitioning, Keeping active data separate
TIMESTAMP type, Choosing Optimal Data Types, Date and Time Types, Incremental and differential backups
TIMESTAMPDIFF() function, How Fast Is Replication?
TINYBLOB type, BLOB and TEXT types
TINYINT type, Whole Numbers
TINYTEXT type, BLOB and TEXT types
Tkachenko, Vadim, Using RAID with SSDs
tmp_table_size setting, Completing the Basic Configuration
TokuDB, OLTP storage engines, Other types of index
TO_DAYS() function, Types of Partitioning
TPC Benchmarks
dbt2, dbt2 TPC-C on the Database Test Suite
TPC-C, Single-Component Tools
TPC-H, Designing and Planning a Benchmark
TPCC-MySQL tool, Single-Component Tools, Percona’s TPCC-MySQL Tool–Percona’s TPCC-MySQL Tool
transactional tables, Mixing Transactional and Nontransactional Tables
transactions, Selecting the Right Engine
ACID test, Transactions
deadlocks, Deadlocks
InnoDB, Old row versions and the tablespace, TRANSACTIONS
isolation levels, Isolation Levels
logging, Transaction Logging
in MySQL, Transactions in MySQL
and storage engines, Selecting the Right Engine
transfer speed, Choosing Hard Disks
transferring large files, Transferring Large Files–File Copy Benchmarks
transparency, Load Balancing, Percona XtraDB Cluster, Caching
tree or pyramid replication, Tree or Pyramid
tree-formatted output, Tree-Formatted Output
trial-and-error troubleshooting, Diagnosing Intermittent Problems
triggers, The diagnostic trigger, Foreign Key Constraints, Triggers
TRIM command, Benchmarking Flash Storage
Trudeau, Yves, Using User-Defined Functions
tsql2mysql tool, Storing Code Inside MySQL
TTL (time to live), Cache Control Policies
tunefs, Choosing a Filesystem
Tungsten Replicator, Continuent, Emulating multisource replication, Other Replication Technologies
“tuning”, What Not to Do
turbo boost technology, Scaling to Many CPUs and Cores
type column, The type Column

U

Ubuntu, Other MySQL Variants
UDF Library, SQL Utilities
UDFs, Using User-Defined Functions, User-Defined Functions
unarchiving, Scaling Back
uncommitted data, Isolation Levels
uncompressed files, Transferring Large Files
undefined server IDs, Undefined Server IDs
underutilization, Plan to Underutilize
UNHEX() function, Choosing Identifiers
UNION ALL query, Optimizing UNION
UNION limitations, UNION Limitations
UNION query, MySQL’s join execution strategy, Optimizing UNION, Writing a lazy UNION, The select_type Column–An example of complex SELECT types
UNION syntax, Merge Tables
UNIQUE constraint, Redundant and Duplicate Indexes
unit of sharding, Choosing a partitioning key
Universal Scalability Law (USL), A Formal Definition–A Formal Definition
Unix, How MySQL’s Configuration Works, Choosing an Operating System, Lock Contention Caused by InnoDB Locking Selects, Failover and Failback, What to Back Up
UNIX_TIMESTAMP() function, Date and Time Types
UNLOCK TABLES command, Implicit and explicit locking, Modifying Only the .frm File, LVM snapshots for online backups
UNSIGNED attribute, Whole Numbers
“unsinkable” systems, Avoiding Single Points of Failure
unused indexes, Unused Indexes
unwrapping, Other uses for variables
updatable views, Updatable Views
UPDATE command, SELECT and UPDATE on the Same Table, How Partitioning Works, Updatable Views
UPDATE RETURNING command, Avoiding retrieving the row just modified
upgrades
replication before, Problems Solved by Replication
validating MySQL, Query Optimizer Hints
USE INDEX hint, Query Optimizer Hints
user logs, User Locks
user optimization issues, What to Measure, Choosing a Good Column Order
user statistics tables, Tables in Percona Server
user-defined functions (UDFs), Using User-Defined Functions, User-Defined Functions
user-defined variables, Using User-Defined Variables–Other uses for variables
USER_STATISTICS tables, Using the USER_STATISTICS Tables
“Using filesort” value, The Extra Column
“Using index” value, The Extra Column
USING query, The query optimizer
“Using temporary” value, The Extra Column
“Using where” value, The Extra Column
USL (Universal Scalability Law), A Formal Definition–A Formal Definition
UTF-8, Character Sets and Collations, How Character Sets and Collations Affect Queries
utilities, SQL, SQL Utilities
UUID() function, Choosing Identifiers, Writing to Both Masters in Master-Master Replication, Generating globally unique IDs
UUID_SHORT() function, Generating globally unique IDs

V

Valgrind, Instrumenting PHP Applications
validating MySQL upgrades, Query Optimizer Hints
VARCHAR type, VARCHAR and CHAR types, Using ENUM instead of a string type, Special Types of Data, How Fast Is Replication?
variables, How MySQL’s Configuration Works
assignments in statements, Other uses for variables
setting dynamically, Side Effects of Setting Variables–Side Effects of Setting Variables
user-defined, Using User-Defined Variables–Other uses for variables
version-based splits, Splitting reads and writes in replication
versions
and full-text searching, Full-Text Changes in MySQL 5.1
history of MySQL, A MySQL Timeline–A MySQL Timeline
improvements in MySQL 5.6, Improvements in MySQL 5.6
old row, Old row versions and the tablespace
replication before upgrading, Problems Solved by Replication
version-specific comments, Preserving Comments in Stored Code
vgdisplay command, Prerequisites and configuration
views, Views–Performance Implications of Views, Summary
Violin Memory, Other Types of Solid-State Storage
Virident, Flash Technologies, Using Flashcache
virtual IP addresses, Moving IP addresses, Virtual IP Addresses or IP Takeover
virtualization, Scaling by Consolidation
vmstat tool, Swapping, Operating System Status, A CPU-Bound Machine, Benefits, Drawbacks, and Myths of the Cloud, Planning for LVM backups
volatile memory, MySQL Performance in Cloud Hosting
VoltDB, Scaling by Clustering
volume groups, Prerequisites and configuration
VPForMySQL storage engine, Community storage engines

W

Wackamole, Load Balancing
waiters flag, SEMAPHORES
warmup, The InnoDB Buffer Pool, Shared Storage or Replicated Disk
wear leveling, An Overview of Flash Memory
What the Dog Saw (Gladwell), Improving Mean Time to Recovery
WHERE clauses, Other uses for variables, Applying WHERE Clauses Efficiently
whole number data types, Whole Numbers
Widenius, Monty, Forks and Variants of MySQL, MariaDB
Windows, Lock Contention Caused by InnoDB Locking Selects
WITH ROLLUP variable, Optimizing GROUP BY WITH ROLLUP
Workbench Utilities, MySQL, Interface Tools, Command-Line Utilities
working concurrency, What to Measure
working sets of data, What’s Your Working Set?, MySQL Performance in Cloud Hosting
workload-based configuration, Workload-Based Configuration–Optimizing for Filesorts
worst-case selectivity, Prefix Indexes and Index Selectivity
write amplification, An Overview of Flash Memory
write cache and power failure, Solid-State Drives (SSDs)
write locks, Read/Write Locks, Indexes and Locking
write synchronization, Load Balancing with a Master and Multiple Replicas
write threads, FILE I/O
write-ahead logging, Transaction Logging, Caching, Reads, and Writes
write-invalidate policy, Cache Control Policies
write-set replication, Percona XtraDB Cluster
write-update, Cache Control Policies
writes, scaling, Why Replication Doesn’t Help Scale Writes
WriteThrough vs. WriteBack, RAID Failure, Recovery, and Monitoring

X

X-25E drives, Solid-State Drives (SSDs)
X.509 certificates, Connection Management and Security
x86 architecture, CPU Architecture, Choosing an Operating System
XA transactions, Distributed (XA) Transactions, Summary
xdebug, Instrumenting PHP Applications
Xeround, Scaling by Clustering, Other DBaaS Solutions
xhprof tool, Instrumenting PHP Applications
XtraBackup, Percona, Initializing a Replica from Another Server, Designing a MySQL Backup Solution, Online or Offline Backups?, Incremental and differential backups, Restoring Raw Files, Percona XtraBackup
XtraDB Cluster, Percona, Other Replication Technologies, Scaling by Clustering, Percona XtraDB Cluster–Percona XtraDB Cluster, Percona Server

Y

YEAR() function, Types of Partitioning, What Can Go Wrong

Z

Zabbix, Open Source Monitoring Tools
Zenoss, Open Source Monitoring Tools
ZFS filer, Incremental and differential backups, Filesystem Snapshots
ZFS filesystem, Using Flashcache, Choosing an Operating System
zlib, The Archive engine, Limited Replication Bandwidth
Zmanda Recovery Manager (ZRM), Zmanda Recovery Manager
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset