MySql my.cnf 설정 요소...

MySQL 기본 설정

시스템에 따라 데이터 파일과 같은 일부 변수 값이 달라질 수 있으니, 자신의 시스템에 맞게 수정해서 사용하자.

 

 

하드웨어 

일반적으로 대용량  InnoDB에서는 CPU보다 메모리가 관건이다

 

최근에는 대부분 16-32G정도의 메모리가 가격대비 성능이 좋은 편이다 

RAID 1+0

빠른 입출력을 원한다면 SSD혹은 SAS사용

 

운영체제

운영하는것이 redhat,centos 를 추천

또한  무조건 64bit를 사용해야 한다.

 

 

 

[code lang="bash"]
vi /etc/my.cnf
[/code]
[code lang="Apache"]
[client]
port = 3306
socket = /tmp/mysql.sock

[mysqld]
# generic configuration options
port = 3306
socket = /tmp/mysql.sock

back_log = 100
max_connections = 500
max_connect_errors = 10
table_open_cache = 2048
max_allowed_packet = 16M
join_buffer_size = 8M
read_buffer_size = 2M
read_rnd_buffer_size = 16M
sort_buffer_size = 8M
bulk_insert_buffer_size = 16M
thread_cache_size = 128
thread_concurrency = 16
query_cache_type = 0
default_storage_engine = innodb
thread_stack = 192K
lower_case_table_names = 1
max_heap_table_size = 128M
tmp_table_size = 128M
local_infile = 0
max_prepared_stmt_count = 256K
event_scheduler = ON
log_bin_trust_function_creators = 1
secure_auth = 1
skip_external_locking
skip_symbolic_links
#skip_name_resolve

## config server and data path
basedir = /usr/local/mysql
datadir = /data/mysql/mysql-data
tmpdir = /data/mysql/mysql-tmp
log_bin = /data/mysql/mysql-binlog/mysql-bin
relay_log = /data/mysql/mysql-binlog/mysql-relay
innodb_data_home_dir = /data/mysql/mysql-data
innodb_log_group_home_dir = /data/mysql/mysql-iblog

## config character set
##utf8
character_set_client_handshake = FALSE
character_set_server = utf8
collation_server = utf8_general_ci
init_connect = "SET collation_connection = utf8_general_ci"
init_connect = "SET NAMES utf8"

## bin log
binlog_format = row
binlog_cache_size = 4M

## Replication related settings
server_id = 1
expire_logs_days = 7
slave_net_timeout = 60
log_slave_updates
#read_only

## MyISAM Specific options
key_buffer_size = 32M
myisam_sort_buffer_size = 8M
myisam_max_sort_file_size = 16M
myisam_repair_threads = 1
myisam_recover = FORCE,BACKUP

# *** INNODB Specific options ***
innodb_additional_mem_pool_size = 16M

#innodb_buffer_pool_size  전체 메모리의 70~80%가 적당하다. 16G -> 12G , 32G -> 26G 정도를 설정한다.
innodb_buffer_pool_size = 2G

innodb_data_file_path = ibdata1:1G:autoextend
innodb_file_per_table = 1
innodb_thread_concurrency = 16
innodb_flush_log_at_trx_commit = 2
innodb_log_buffer_size = 8M

#innodb_log_file_size 16G이상에서는 256 미만은 128M
innodb_log_file_size = 256M
innodb_log_files_in_group = 3
innodb_max_dirty_pages_pct = 90
innodb_flush_method = O_DIRECT
innodb_lock_wait_timeout = 120
innodb_support_xa = 0
innodb_file_io_threads = 8

 

 

[mysqldump]
quick
max_allowed_packet = 16M

[mysql]
no_auto_rehash

[myisamchk]
key_buffer_size = 512M
sort_buffer_size = 512M
read_buffer = 8M
write_buffer = 8M

[mysqlhotcopy]
interactive_timeout

[mysqld_safe]
open_files_limit = 8192
[/code]

 

 

# ================================================================================
# key_buffer : 
# 인덱스를 위한 버퍼크기, 키 버퍼의 크기는 공유된쓰레드의 크기이며 중복된 키를 자주 
# 사용할 경우 속도를 높일 수 있고, 기준은 show status 명령을 했을 때 
# Key_blocks_used를 체크해서 key_buffer 사이즈를 줄이던가 늘리던가 해야 한다. 
# 일반적인 key_buffer 의 크기는 Key_blocks_used*1024 로 잡으면 된다.
# Key_reads 가 크다면, key_buffer_size 변수가 너무 작은 것이다. 
# 대용량 테이블일 경우 쿼리가 느리다면, 인덱스 버퍼 크기가 작아서 느릴 수 있으므로
# key_buffer 크기를 늘려 주어야 한다. 
# show status 명령에서 다음과 같이 계산되는 것이 key_buffer 설정이 적당한 것이다.
# Key_reads/Key_read_request < 0.01   [ 0.00112318293327 ]
# key_write/key_write_request = 1     [ 0.0763101585936 ]
# | Key_blocks_used          | 360325     |  > 368972800
# | Key_read_requests        | 386263882  |
# | Key_reads                | 433845     |
# | Key_write_requests       | 5685285    |

key_buffer = 384M

# ================================================================================
# max_allowed_packet :
# 클라이언트 통신에 대해 사용되는 버퍼가 커질수 있는 최대 크기, 이변수의 가장 큰 값은
# MySQL 4 이전은 16MB 가 될 수 있고 MySQL 4와 그 이후는 1GB까지 될 수 있다.
# 클라이언트가 커다란 BLOB나 TEXT값들을 전송하는 경우라면, 이 서버 변수를 늘릴 
# 필요가 있고 클라이언트 측에서도 이것을 늘려야 할 것이다. 
# shell>mysql --set-variable=max_allowed_packet=64M

max_allowed_packet = 1M

# ================================================================================
# table_cache : 
# MySQL 서버가 한번에 열수 있는 테이블의 개수 설정, 
# 기본값은 64개이다, Opened_tables 값이 크다면 table_cache 값이 너무 작은 것이다.
# max_connections 값과도 관계가 있는데, 만약 100이라면 table_cache는 100*n 으로 
# 설정해 주는것이 좋다.
# n은 조인해서 열수 있는 최대 테이블 개수이다. 
# ex ) 사용중인 테이블이 20개이고, max_connections=100이라면, table_cache 는 그의
# 5~6배인 table_cache=512 정도로 설정하는 것이 좋다.

table_cache = 512

# ================================================================================
# sort_buffer_size , read_buffer_size :
# 정렬을 위해 사용하는 버퍼 크기, ORDER BY 나 GROUP BY 절을 빠르게 하기 위해서는 
# 이 값을 증가시킨다.
# 4.0.3 이전에서는 
# sort_buffer_size => sort_buffer 
# read_buffer_size => record_buffer 
# 라는 변수로 쓰였다.
# max_used_connections에 따라서 증가시키는 것이 좋다. 한번에 많은 쓰레드가 동시에
# 붙을 경우는 증가시키는 것이 좋다. max_used_connections가 높을 경우
# sort_buffer=6M 정도로 설정하는 것이 좋고, record_buffer=2M 정도가 적당하다.
# sort_buffer와 record_buffer 를 합쳐서 8M를 넘지 않는 것이 좋다.
# (sort_buffer+record_buffer)*max_connections를 할 경우 ram을 다 차지할 수 있기
# 때문이다.
# 많은 연속적인 테이블 스캔이 이루어진다면 read_buffer_size 값을 증가시켜야 한다.

sort_buffer_size = 2M
read_buffer_size = 2M

 
# ================================================================================
# myisam_sort_buffer_size :
# MyISAM 테이블 타입에서 인덱스를 만들거나(create table ..), 인덱스로 
# 변경(alter table ...) 하거나, 복구( repair ...) 할 때 사용하는 버퍼크기
myisam_sort_buffer_size = 64M

thread_cache = 8

 

# 쿼리 캐시 버퍼 사이즈

query_cache_size = 32M

 

# Try number of CPU's*2 for thread_concurrency

# thread_concurrency : 솔라리스에서만 사용된다.

thread_concurrency = 8

 

# max_connections :
# show status 명령을 했을때 , max_used_connections을 보고 늘리던가, 줄이던가 해야 한다.
# 최대값보다 10% 정도 더 크게 잡는 것이 좋다.
max_connections=1000

 

# max_connect_error :

# 서버가 차단되기 전에 최대 연결 오류수

max_connect_error=10000

 

# max_delayed_threads : INSERT DELAYED 쿼리를 사용할 수 있는 최대 쓰레드 수

max_delayed_threads=1000

 

# tmp_table_size = 디스크에 쓰여진 후 임시 테이블의 최대 크기

tmp_table_size=64M

 

# key_buffer_size :

# 인덱스를 위한 버퍼 사이즈,  느리다면 크기를 늘리는 것이 좋으나

# OS의 Ram 크기를 고려하여 늘려야 한다. 인덱스 데이터 캐싱을 위한

# 메모리 제한이 key_buffer 이다.

# 인덱스 기반의 검색과 정렬은 이 변수의 값을 늘리면 인덱스들을 만들거나 수정하는

# 동작만큼 더 빨라진다. 키 퍼버가 클수록 MySQL이 메모리 안에서 키를 찾을 확률이

# 늘어나는데 그만큼 인덱스 처리에 필요한 디스크 접근 횟수를 줄여주게 된다.

# 3.23 버전 이전에는 key_buffer 로 불렸다. 3.23부터 두 이름 모두 인식한다.

key_buffer_size=369M

key_buffer =369M

 

--------------------------------------------------------------------------------

# Don't listen on a TCP/IP port at all. This can be a security enhancement,

# if all processes that need to connect to mysqld run on the same host.

# All interaction with mysqld must be made via Unix sockets or named pipes.

# Note that using this option without enabling named pipes on Windows

# (via the "enable-named-pipe" option) will render mysqld useless!

#

#skip-networking

 

# Replication Master Server (default)

# binary logging is required for replication

 

# log-bin :

# 리플리케이션을 설정할때 활성화 시키는 곳?

# mysql 이 log-bin을 이용한다는 것을 알려준다.

log-bin

 

# required unique id between 1 and 2^32 - 1

# defaults to 1 if master-host is not set

# but will not function as a master if omitted

 

# server-id :

# 리플리케이션 설정을 위해. id를 부여해 준다.

# slave 의 경우 .. 2 ~ .... 중복불가!

server-id      = 1

 

# binlog-do-db :

# 특정데이터베이스만 리플리케이션 기능을 사용할 수 있게 하는 옵션이다.

# 서버부담이 클수도 있으므로 인증 부분이 걸린 곳에 사용하면 좋을 것이다.

binlog-do-db   = V2PRJ

 

# Replication Slave (comment out master section to use this)

#

# To configure this host as a replication slave, you can choose between

# two methods :

#

# 1) Use the CHANGE MASTER TO command (fully described in our manual) -

#    the syntax is:

#

#    CHANGE MASTER TO MASTER_HOST=<host>, MASTER_PORT=<port>,

#    MASTER_USER=<user>, MASTER_PASSWORD=<password> ;

#

#    where you replace <host>, <user>, <password> by quoted strings and

#    <port> by the master's port number (3306 by default).

#

#    Example:

#

#    CHANGE MASTER TO MASTER_HOST='125.564.12.1', MASTER_PORT=3306,

#    MASTER_USER='joe', MASTER_PASSWORD='secret';

#

# OR   

#

# 2) Set the variables below. However, in case you choose this method, then

#    start replication for the first time (even unsuccessfully, for example

#    if you mistyped the password in master-password and the slave fails to

#    connect), the slave will create a master.info file, and any later

#    change in this file to the variables' values below will be ignored and

#    overridden by the content of the master.info file, unless you shutdown

#    the slave server, delete master.info and restart the slaver server.

#    For that reason, you may want to leave the lines below untouched

#    (commented) and instead use CHANGE MASTER TO (see above)

#

# required unique id between 2 and 2^32 - 1

# (and different from the master)

# defaults to 2 if master-host is set

# but will not function as a slave if omitted

#server-id       = 2

#

# The replication master for this slave - required

#master-host     =   <hostname>

#

# The username the slave will use for authentication when connecting

# to the master - required

#master-user     =   <username>

#

# The password the slave will authenticate with when connecting to

# the master - required

#master-password =   <password>

#

# The port the master is listening on.

# optional - defaults to 3306

#master-port     =  <port>

#

# binary logging - not required for slaves, but recommended

#log-bin

 

# Point the following paths to different dedicated disks

#tmpdir        = /tmp/       

#log-update    = /path-to-dedicated-directory/hostname

 

# Uncomment the following if you are using BDB tables

#bdb_cache_size = 384M

#bdb_max_lock = 100000

 

# Uncomment the following if you are using InnoDB tables

#innodb_data_home_dir = /data/

#innodb_data_file_path = ibdata1:2000M;ibdata2:10M:autoextend

#innodb_log_group_home_dir = /data/

#innodb_log_arch_dir = /data/

# You can set .._buffer_pool_size up to 50 - 80 %

# of RAM but beware of setting memory usage too high

#innodb_buffer_pool_size = 384M

#innodb_additional_mem_pool_size = 20M

# Set .._log_file_size to 25 % of buffer pool size

#innodb_log_file_size = 100M

#innodb_log_buffer_size = 8M

#innodb_flush_log_at_trx_commit = 1

#innodb_lock_wait_timeout = 50

 

[mysqldump]

quick

max_allowed_packet = 16M

 

[mysql]

no-auto-rehash

# Remove the next comment character if you are not familiar with SQL

#safe-updates

 

[isamchk]

key_buffer = 256M

sort_buffer_size = 256M

read_buffer = 2M

write_buffer = 2M

 

[myisamchk]

key_buffer = 256M

sort_buffer_size = 256M

read_buffer = 2M

write_buffer = 2M

 

[mysqlhotcopy]

interactive-timeout

 

 

[mysqladmin]

▷mysqladmin -u root -p proc stat(=processlist) --> 서버에 현재 활동중인 threads상태보기
Enter password: 
+------+------+-----------+----+---------+------+-------+------------------+
| Id   | User | Host      | db | Command | Time | State | Info             |
+------+------+-----------+----+---------+------+-------+------------------+
| 3704 | root | localhost |    | Query   | 0    |       | show processlist |
+------+------+-----------+----+---------+------+-------+------------------+
Uptime: 281302  Threads: 1  Questions: 27330  Slow queries: 0  Opens: 1771  Flush tables: 1  Open tables: 64 Queries per second avg: 0.097

▷mysqladmin status

Uptime    : the MySQL server 시작된 후 현재까지 시간 (초) 
Threads    : 현재 디비서버에 연결된 유저수 
Questions    : 서버시작후 지금까지 요청된 쿼리수  
Slow queries    : --log-slow-queries[=file_name] option로 시작된 서버가 variables에 지정된 
                 long_query_time seconds시간보다 큰 쿼리시간을 가진 요청수
Opens     : 서버가 시작된 후 현재까지 열렸던 테이블 수
Flush tables    : flush ..., refresh, and reload commands된 수
Open tables    : 현재 열려 있는 테이블 수
Queries per second avg  : 평균 초당 쿼리수

Memory in use    :the mysqld code에 의해 직접 할당된 메모리 (only available when MySQL is compiled with --with-debug=full).  
Max memory used   : the mysqld code에 의해 직접 할당된 최대메모리 (only available when MySQL is compiled with --with-debug=full). 

▷mysqladmin -u root -p ping   -->디비서버가 살아있는지 확인    
Enter password: 
mysqld is alive

▷mysqladmin -u root -p extended-status(※mysql>show stauts)
+--------------------------+-----------+
| Variable_name            | Value     |
+--------------------------+-----------+
| Aborted_clients          | 0         |
| Aborted_connects         | 7         |
| Bytes_received           | 1273369   |
| Bytes_sent               | 334385278 |
| Connections              | 3656      |
| Created_tmp_disk_tables  | 0         |
| Created_tmp_tables       | 0         |
| Created_tmp_files        | 0         |
| Delayed_insert_threads   | 0         |
| Delayed_writes           | 0         |
| Delayed_errors           | 0         |
| Flush_commands           | 1         |
| Handler_delete           | 4         |
| Handler_read_first       | 1766      |
| Handler_read_key         | 3525      |
| Handler_read_next        | 2052      |
| Handler_read_prev        | 1859      |
| Handler_read_rnd         | 757854    |
| Handler_read_rnd_next    | 1975607   |
| Handler_update           | 3190      |
| Handler_write            | 36        |
| Key_blocks_used          | 245       |
| Key_read_requests        | 7473      |
| Key_reads                | 245       |
| Key_write_requests       | 386       |
| Key_writes               | 209       |
| Max_used_connections     | 1         |
| Not_flushed_key_blocks   | 0         |
| Not_flushed_delayed_rows | 0         |
| Open_tables              | 64        |
| Open_files               | 128       |
| Open_streams             | 0         |
| Opened_tables            | 1768      |
| Questions                | 27128     |
| Select_full_join         | 0         |
| Select_full_range_join   | 0         |
| Select_range             | 22        |
| Select_range_check       | 0         |
| Select_scan              | 7694      |
| Slave_running            | OFF       |
| Slave_open_temp_tables   | 0         |
| Slow_launch_threads      | 0         |
| Slow_queries             | 0         |
| Sort_merge_passes        | 0         |
| Sort_range               | 38        |
| Sort_rows                | 757848    |
| Sort_scan                | 5121      |
| Threads_cached           | 0         |
| Threads_created          | 3655      |
| Threads_connected        | 1         |
| Threads_running          | 1         |
| Uptime                   | 279770    |
+--------------------------+-----------+

▷mysqladmin -u root -p variables(※mysql>show valiables)
+-------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Variable_name           | Value                                                                                                                                                            |
+-------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| ansi_mode               | OFF                                                                                                                                                              |
| back_log                | 50                                                                                                                                                               |
| basedir                 | /usr/local/mysql/                                                                                                                                                |
| binlog_cache_size       | 32768                                                                                                                                                            |
| character_set           | euc_kr                                                                                                                                                           |
| character_sets          | euc_kr dec8 dos german1 hp8 koi8_ru latin1 latin2 swe7 usa7 cp1251 danish hebrew win1251 estonia hungarian koi8_ukr win1251ukr greek win1250 croat cp1257 latin5 |
| concurrent_insert       | ON                                                                                                                                                               |
| connect_timeout         | 5                                                                                                                                                                |
| datadir                 | /usr/local/mysql/data/                                                                                                                                           |
| delay_key_write         | ON                                                                                                                                                               |
| delayed_insert_limit    | 100                                                                                                                                                              |
| delayed_insert_timeout  | 300                                                                                                                                                              |
| delayed_queue_size      | 1000                                                                                                                                                             |
| flush                   | OFF                                                                                                                                                              |
| flush_time              | 0                                                                                                                                                                |
| have_bdb                | NO                                                                                                                                                               |
| have_gemini             | NO                                                                                                                                                               |
| have_innobase           | NO                                                                                                                                                               |
| have_isam               | YES                                                                                                                                                              |
| have_raid               | NO                                                                                                                                                               |
| have_ssl                | NO                                                                                                                                                               |
| init_file               |                                                                                                                                                                  |
| interactive_timeout     | 28800                                                                                                                                                            |
| join_buffer_size        | 131072                                                                                                                                                           |
| key_buffer_size         | 8388600                                                                                                                                                          |
| language                | /usr/local/mysql/share/mysql/korean/                                                                                                                             |
| large_files_support     | ON                                                                                                                                                               |
| locked_in_memory        | OFF                                                                                                                                                              |
| log                     | OFF                                                                                                                                                              |
| log_update              | OFF                                                                                                                                                              |
| log_bin                 | OFF                                                                                                                                                              |
| log_slave_updates       | OFF                                                                                                                                                              |
| long_query_time         | 10                                                                                                                                                               |
| low_priority_updates    | OFF                                                                                                                                                              |
| lower_case_table_names  | 0                                                                                                                                                                |
| max_allowed_packet      | 1048576                                                                                                                                                          |
| max_binlog_cache_size   | 4294967295                                                                                                                                                       |
| max_connections         | 100                                                                                                                                                              |
| max_connect_errors      | 10                                                                                                                                                               |
| max_delayed_threads     | 20                                                                                                                                                               |
| max_heap_table_size     | 16777216                                                                                                                                                         |
| max_join_size           | 4294967295                                                                                                                                                       |
| max_sort_length         | 1024                                                                                                                                                             |
| max_tmp_tables          | 32                                                                                                                                                               |
| max_write_lock_count    | 4294967295                                                                                                                                                       |
| myisam_recover_options  | OFF                                                                                                                                                              |
| myisam_sort_buffer_size | 8388608                                                                                                                                                          |
| net_buffer_length       | 16384                                                                                                                                                            |
| net_read_timeout        | 30                                                                                                                                                               |
| net_retry_count         | 10                                                                                                                                                               |
| net_write_timeout       | 60                                                                                                                                                               |
| open_files_limit        | 0                                                                                                                                                                |
| pid_file                | /usr/local/mysql/data/3egg.com.pid                                                                                                                               |
| port                    | 3306                                                                                                                                                             |
| protocol_version        | 10                                                                                                                                                               |
| record_buffer           | 131072                                                                                                                                                           |
| query_buffer_size       | 0                                                                                                                                                                |
| safe_show_database      | OFF                                                                                                                                                              |
| server_id               | 0                                                                                                                                                                |
| skip_locking            | ON                                                                                                                                                               |
| skip_networking         | OFF                                                                                                                                                              |
| skip_show_database      | OFF                                                                                                                                                              |
| slow_launch_time        | 2                                                                                                                                                                |
| socket                  | /tmp/mysql.sock                                                                                                                                                  |
| sort_buffer             | 2097144                                                                                                                                                          |
| table_cache             | 64                                                                                                                                                               |
| table_type              | MYISAM                                                                                                                                                           |
| thread_cache_size       | 0                                                                                                                                                                |
| thread_stack            | 65536                                                                                                                                                            |
| timezone                | KST                                                                                                                                                              |
| tmp_table_size          | 1048576                                                                                                                                                          |
| tmpdir                  | /tmp/                                                                                                                                                            |
| version                 | 3.23.32                                                                                                                                                          |
| wait_timeout            | 28800                                                                                                                                                            |
+-------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------+

[그외]
mysqladmin create [databasename] : Create a new database. 
mysqladmin drop [databasename] : Delete a database and all its tables. 
mysqladmin flush-hosts : Flush all cached hosts. 
mysqladmin flush-logs : Flush all logs. 
mysqladmin flush-tables : Flush all tables. 
mysqladmin flush-privileges : Reload grant tables (same as reload). 
mysqladmin kill [id(,id,...)]: Kill mysql threads. 
mysqladmin password : Set a new password. Change old password to new-password. 
mysqladmin reload : Reload grant tables. 
mysqladmin refresh : Flush all tables and close and open logfiles. 
mysqladmin shutdown : Take server down. 
mysqladmin slave-start : Start slave replication thread. 
mysqladmin slave-stop : Stop slave replication thread. 
mysqladmin version : Get version info from server.

▷ mysqladmin -u root -p variables(※mysql>show valiables)
------------------------------------------------------------------------------------------------------------------------------
ansi_mode
on으로 되어있으면 --ansi로 시작된 것이다(Running MySQL in ANSI Mode를 참조하고,설명은 다음에)

back_log 
mysql이 가지는 현저한 커넥션요청수
메인 mysql 스레드가 짧은시간에 매우 많은 커넥션이 일어났을때 생기며, 이때 그러한 커넥션을 체크하고 
새로운 스레드를 생성시키기위해 생기지만 이러한 현상은 극히 적게 발생하는 것이다.
back_log는 mysql이 순간적으로 새로운 요청에 답변하는 것을 멈추기전 짧은 시간동안 얼마나 많은 요청들이 
쌓일 수있는지 알려준다. 만약, 짧은 시간동안 많은 수의 커넥션이 생길것을 예상한다면 back_log를 증가시켜주어야 한다
back_log를 다른말로 표현하면 들어오는 TCP/IP커넥션에 대해서 귀기울이는 큐의 수이다.
사용자OS마다 이러한 큐의 사이즈에 한계가 있다. 따라서, 자신들이 가지고 있는 OS의 메뉴얼을 참고하여 
최대치가 얼마인지 확인하여야 한다. 또한, 자신의 OS시스템이 가지는 한계치보다 높게 back_log를 가지면 효가가 없다.

basedir 
mysql이 설치된 기본 디렉토리

-------------------------------------------------------------------------------------------------------------- 
bdb_cache_size 
bdb테이블에 대한 rows와 인데스 케쉬에 할당된 버퍼
bdb테이블을 사용하지않는다면 시작할 때 --skip-dbd로 시작해야 이러한 케쉬에 대해 메모리를 낭비하지 않는다

bdb_log_buffer_size 
dbd테이블의 인덱스와 rows를 케쉬하는데 할당된 버퍼
bdb테이블을 사용하지않는다면 시작할 때 --skip-dbd로 시작해야 이러한 케쉬에 대해 메모리를 낭비하지 않는다

bdb_home 
--dbd-home옵션으로 설치했을대 나타나는 버클리디비 홈디렉토리

bdb_max_lock 
긴 트랙잭션이나 mysql이 쿼리계산시에 많은 rows를 검사해야만 할때, lock테이블이 12개의 에러혹은 lock이 가능하지 않는
dbd타입의 에러가 발생되면 bdb_max_lock를 증가시켜야한다. 디폴트는 1000이며 bdb테이블을 활성화시킬수있다

bdb_logdir 
--bdb-logdir 옵션을 주었을때 나타난다

bdb_shared_data 
--bdb-shared-data을 사용하면 on된다

bdb_tmpdir 
--bdb-tmpdir옵션을 주었을 때

※ 위는 버클리디비를 사용하였을 때 나타나는 values이다
--------------------------------------------------------------------------------------------------------------

binlog_cache_size. 
트랜젝션동안 binary log에 대해 sql문을 잡고있는 케쉬사이즈
큰 다중문 트랜젝션을 빈번히 사용한다면, 이 사이즈를 높게잡아 퍼포먼스를 증가시킬수있다
자세한 것은 BEGIN/COMMIT/ROLLBACK Syntax를 참조하라

character_set
디폴트 문자셋(현재 세팅한)

character_sets
지원하는 모든 문자셋

concurrent_inserts 
디폴트로 on되어있으면 mysql은 select하는 동안에 동시에 myisam테이블에 insert를 사용할 수있도록한다
시작시 off로 하려면 --safe or --skip-new로 해주어야 한다

connect_timeout 
mysqld server가 Bad handshake에 반응하기전 연결된 패킷에 대해 기다리는 시간(초)

datadir
mysql 데이타가 들어있는 홈디렉토리

delay_key_write
(디폴트로 )on되어있으면 mysql은 delay_key_write option을 테이블생성에 honor(??)한다
이 옵션과 함께 테이블에 대한 key buffer는 모든 인덱스 update시에 flush하지 않고 테이블이 잠겨질때만 flush한다
이것은 key가 많을때 쓰기 속도를 높일 수있으나, 이를 사용하려면 myisamchk --fast --force함께 모든 테이블에 자동 체크를
추가하여야 한다. mysqld를 --delay-key-write-for-all-tables option으로 시작하면, 모든 테이블들이 마치 the delay_key_write option
으로 생성된 것으로 취급된다.
mysqld를 --skip-new or --safe-mode로 시작함으로써 이런 flag를 없앨수 있다.

delayed_insert_limit
delayed_insert_limit rows를 삽입한 후에 INSERT DELAYED handler는 어떠한 select문들이 해결되지 않았는지 체크한다
만약 해결되지않은 select문들이 있다면 실행한다.

delayed_insert_timeout
INSERT DELAYED thread는 얼마나 오래동안 종료되기전 insert문들을 기다려야 하는지를 나타낸다.

delayed_queue_size 
INSERT DELAYED를 처리하는데 할당된 rows의 queue사이즈
queue가 풀되면 INSERT DELAYED를 행하는 클라이언트는 queue에 다시 여유가 생길때까지 기다릴 것이다.

flush 
--flush option으로 시작된 mysql은 on으로 표시된다

flush_time 
non-zero value로 세팅되면 매번 flush_time시 모든 테이블이 닫히는 것을 기다린다.(디스크에 resources and sync things를 비우기 위해)
작은 리소스를 가지는 Win95, Win98에서 이러한 옵션을 사용하기를 추천한다.

ft_min_word_len 
FULLTEXT index에 포함된 최소문자길이
이 값을 바꾼후에는 FULLTEXT index를 재생성해야만 한다

ft_max_word_len 
FULLTEXT index에 포함된 최대문자길이
이 값을 바꾼후에는 FULLTEXT index를 재생성해야만 한다

ft_max_word_len_sort 
REPAIR, CREATE INDEX, or ALTER TABLE에서 빠른 인데스 재생성에 사용되는 FULLTEXT index의 최대문자길이
문자길이가 길면 길수록 늦게 insert된다.
thumb규칙은 다음과 같다.
ft_max_word_len_sort를 증가시킬때 mysql은 temporary files을 더크게 생성하고(따라서, disk I/O로 인해 프로세스가 줄어든다)
one sort block에 더적은 keys를 둘것이다(이것은 효율성을 저하시킨다)
ft_max_word_len_sort가 너무 작을 때, 대신 mysql은 인덱스에 많은 단어들을 천천히 insert하지만, 짧은 단어들은 매우 빠르게 입력한다.
이것은 단지 EPAIR, CREATE INDEX, or ALTER TABLE동안 인덱스를 재성시 적용된다

ft_boolean_syntax
List of operators는 MATCH ... AGAINST(... IN BOOLEAN MODE)의해 지원된다. MySQL Full-text Search참조

have_innodb 
InnoDB tables을 지원할 시에 YES가 되고, --skip-innodb사용하면 disalbed된다

have_bdb 
Berkeley DB tables을 지원할 시에 YES가 되고, --skip-bdb사용하면 disalbed된다

have_raid 
mysqld가 RAID option을 지원하면 YES

have_openssl 
mysql이 the client/server protocol상에서 SSL (encryption:암호화)를 지원하면 YES로 나타난다

init_file 
서버를 시작할때 --init-file option를 지정할 때 나타는 파일 이름
서버가 시작시에 이파일을 실행하기를 원하는 sql문 파일이다

interactive_timeout 
서버가 close전에 상호작용할 커넥션에 activity를 기다리는 시간(초)
상호작용하는 클라이언트는 mysql_real_connect()에 CLIENT_INTERACTIVE option를 사용하는 클라이언트로 정의된다
wait_timeout를 참조하라

join_buffer_size 
인덱스를 사용하지않는 full 조인에 사용되는 버퍼사이즈
이 버퍼는 두개의 테이블사이에 각각의 full조인에 대한 유일한 시간이 할당된다
인덱스를 추가하는 것이 불가능할때 더 빠른 full조인을 하기위해 증가시켜라
보통 빠른 조인을 수행하는 최상의 방법은 인덱스를 추가하는 것이다

key_buffer_size 
인덱스 블럭은 모든 쓰레드에의해 완화되어지고 공유되어진다.
key_buffer_size는 인덱스블럭에 사용되어지는 버퍼사이즈이다.
인덱스를 더 잘 다루기위해 허용된 만큼 많이 이것을 증가시켜라.
256M에 64M를 할당하는 것이 주로 mysql에서 일반화 되어있다.
하지만,당신의 시스템의 50% 이상 커진다면, 시스템이 페이징하면서 굉장히 느려진다.
mysql이 데이타를 읽는데 케쉬하지 않기 때문에 show status와 show varibles를 사용하여 
Key_read_requests, Key_reads, Key_write_requests, Key_writes를 검사하고 key buffer의 퍼포먼스를 체크하는 것을 명심하라.
Key_reads/Key_read_request율은 보통 0.01보다 작아야한다.
updates/deletes를 대부분 사용한다면 Key_write/Key_write_requests가 1에 가까워지는게 일반적이고,
동시에 update를 많이하거나 delay_key_write를 사용한다면 Key_write/Key_write_requests는 작아진다.
※기본은 16M이다.
Key_buffer_used*1024(byte)에 2~3배면 충분하다(투덜이님)

SHOW Syntax를 참조하라
동시에 많은 rows를 쓰게하려면 LOCK TABLES를 사용하라
LOCK TABLES/UNLOCK TABLES Syntax를 참조하라

language
에러메세지에 사용되는 언어

large_file_support
big file support로 mysql이 컴파일되을때

locked_in_memory
mysqld는 --memlock로 메모리에 lock된다면 on

log
시작시 --log로 모든 쿼리를 logging하면 on

log_update 
시작시 --update-log하면 on

log_bin 
시작시 binary log를 하면

log_slave_updates 
If the updates from the slave should be logged.

long_query_time 
하나의 쿼리가 long_query_time(초)보다 길면, Slow_queries counter가 증가될 것이다
시작시 --log-slow-queries를 사용하면, 쿼리는 slow query logfile에 쌓인다
The Slow Query Log를 참조하라

lower_case_table_names 
테이블이름에 1로 세팅되면, 디스크에 lowercase(인쇄)되어 쌓이며, 테이블이름은 case-insensitive될 것이다
Case Sensitivity in Names를 참조하라

max_allowed_packet 
패킷의 최대사이즈
이 message버퍼는 net_buffer_length bytes에 최기화된다.
하지만, 필요시  max_allowed_packet bytes까지 증가한다.

가능한 잘못된 큰 패킷을 잡기위해 디폴트는 작다
biggest BLOB를 사용하기를 원하면 이것을 증가시켜야 하며, 당신이 사용하기 원하는 만큼 커진다.
The protocol limits for max_allowed_packet은 MySQL 3.23에서는 16M이고, MySQL 4.0에서는 4G이다

max_binlog_cache_size 
multi-statement transaction가 max_binlog_cache_size의 메모리양보다 큰 메모리를 요청하면
에러가 발생

max_binlog_size 
3.23.33이후에서 가능하며, 주어진 값보다 초과되어 binary (replication) log에 쓰는 것은 log가 rotate된다
1024bytes보다 작거나 1Gbytes보다 크게 할 수없으며, 디폴트는 1Gbytes이다

max_connections 
동시유저 수
이 값이 mysqld에서 요구하는 file descriptors의 수를 증가하면 이 값을 증가시켜라
file descriptor limits와 Too many connections Error를 참조하라

※기본 값은 100이다. 투덜이님에 의하면 max_userd_connections의 두배정도가 적정하다고 한다

max_connect_errors 
호스트로 부터 interrupted connections수가 많아지면, 이 호스트는 많아진 수부터 block될 것이다.
FLUSH HOSTS를 사용하여 unblock할 수있다.

max_delayed_threads 
INSERT DELAYED statements를 다루기 위해 쓰레드수들보다 더 많이 시작시키지 마라.
모든 INSERT DELAYED threads가 사용되어진 이후 새로운 테이블에 데이타를 입력시키면,
그 row는 마치 DELAYED attribute이 지정되지 않은것처럼 입력될 것이다.

max_heap_table_size 
Don't allow creation of heap tables bigger than this. 
여기에서 정의 되어진 것보다 더큰 테이블을 heap에 만들지 못한다

max_join_size 
max_join_size 레코드들보다 더 큰것들을 읽으려 조인을 사용하는 것은 에러를 발생시킨다.
where절이 없고, 오래걸리는 조인과 많은(수백만)rows를 반환하려는 유저가 있으면 이것을 세팅하라

max_sort_length 
BLOB or TEXT values를 정렬할때 사용되는 수(bytes)
(only the first max_sort_length bytes of each value are used; the rest are ignored).

max_user_connections 
하나의 유저당 활성화된 커넥션수(0 = no limit).

max_tmp_tables 
(This option doesn't yet do anything.) 
클라이언트가 동시에 열수있는 임시테이블의 최대수

max_write_lock_count 
After this many write locks, allow some read locks to run in between.

myisam_bulk_insert_tree_size 
MySQL은 bulk inserts를 하기위해 특별한 트리구조의 케쉬를 사용한다
(예: INSERT ... SELECT, INSERT ... VALUES (...), (...), ..., and LOAD DATA INFILE)
이것은 쓰레드당 bytes에 케쉬 트리 사이즈를 제한한다.
0으로 세팅하면 이 최적화는 disable된다
디폴트는 8MB이다

myisam_recover_options 
--myisam-recover option를 사용하였을때

myisam_sort_buffer_size 
REPAIR를 사용하는 인덱스를 정력하거나 CREATE INDEX or ALTER TABLE과 함께 인덱스를 만들때 할당되는 버퍼사이즈

myisam_max_extra_sort_file_size 
fast index creation를 위해 temporary file를 생성하는 것이 key cache보다 더 커진다면 key cache method가 우선한다
이것은 인덱스를 생성하기위해 slower key cache method를 사용하는 large tables에서 long character keys에 주로 사용된다
이 parameter는 Mbytes이다

myisam_max_sort_file_size 
temporary file은 최대사이즈는 인덱스(mysql이 REPAIR, ALTER TABLE or LOAD DATA INFILE동안)를 
재생성하는 동안 사용되도록 허락한다.
파일사이즈는 이것보다 더 클것이며, 인덱스는 slower key cache를 통해 생성될 것이다.
이 parameter는 Mbytes이다

net_buffer_length 
communication buffer는 쿼리사이에 이 사이즈를 다시 세팅하여야 한다
net_buffer_length가 보통 바뀌지는 않지만, 당신이 매우 작은 메모리를 가지고 있다면 
이것을 기대된 쿼리사이즈를 세팅할 수있다.
(클라이언트에 의해 보내진 sql문의 기대된 길이이다. sql문이 이 길이를 초과한다면, 
버퍼는 max_allowed_packet까지 자동적으로 커진다)

net_read_timeout 
읽기가 안되기전 커넥션으로 부터 더 많은 데이타를 기다리는 시간(초)
커넥션으로부터 데이타를 기대하지 않을때는 이 타임아웃은 rite_timeout으로 정의된다
lave_read_timeout참조하라

net_retry_count 
communication port에 읽기가 방해된다면, 이것은 포기하기전에 많은 수를 재시도한다.
이것은 internal interrupts가 모든 쓰레드에 보내짐으로써 FreeBSD에서 꽤 높게 나타난다

net_write_timeout 
block이 쓰기를 회피하기전에 커넥션에 쓰여지기를 기다리는 시간(초)

open_files_limit 
이 값이 '0'이면 mysqld는 max_connections*5 
또는 max_connections + table_cache*2 (whichever is larger) number of files이 필요하다
mysqld가 'Too many open files'에러를 나타내면 이 값을 증가시켜야 한다.
open_files_limit  '0'이 아니면 mysqld는 file descriptors가 setrlimit()를 사용하도록 바꾸기위해 이것을 사용한다
open_files_limit  '0'이면, mysqld는 max_connections*5

pid_file 
--pid-file pid 파일위치

port 
mysql포트넘버 (디폴트 3306)

protocol_version 
The protocol version used by the MySQL server.

record_buffer 
일련의 연속적인 스캔을 하는 각각의 쓰레드는 쓰레드가 스캔하는 버퍼사이즈를 할당한다
많은 연속적인 스캔을 할경우 이값을 증가시키기를 원할 수있다.

record_rnd_buffer 
정렬된 순서대로 rows를 읽을때 rows는 디스크찾기를 하지않고 이 버퍼를 통해 읽는다
세팅해놓지않으면 record buffer에서 세팅된값이다

query_buffer_size 
쿼리버퍼의 초기 할당
대부분의 쿼리가 (like when inserting blobs) 길다면 이값을 증가시켜야만 한다

safe_show_databases 
유저가 어떤 데이타베이스권한도 테이블의 권한도 가지지 않는 데이타베이스를 보여주지 마라
이것은 만약 당신이 다른 유저들이 가지고 있는 데이타베이스를 볼 수있는 사람들에 대해 걱정한다면 보안을 향상시킬수있다
skip_show_databases를 참조하라

server_id 
--server-id option의 값

skip_locking 
만약 mysqld가 외부 lock을 사용한다면 off이다

skip_networking 
local(socket)커넥션만을 허락한다면 on이다

skip_show_databases 
PROCESS_PRIV권한을 가지지 않는 사람들이 SHOW DATABASES를 못하게 한다
만약 사람들이 다른 유저들이 가지고있는 데이타베이스를 보는 것을 걱정한다면 이것은 보안을 향상시킨다
safe_show_databases참조

slave_read_timeout 
읽기가 실패하기전 master/slave연결로 부터 더 많은 데이터를 기다릴 수있는 시간(초)

slow_launch_time 
쓰레드 생성이 이 값보다 더 길다면(초당), Slow_launch_threads counter는 증가될 것이다

socket 
서버에 의해 사용되는 Unix socket /[절대경로]/이름

sort_buffer 
정렬을 필요로 하는 각 쓰레드는 버퍼사이즈를 할당한다.
더 빠른 ORDER BY or GROUP BY operations를 위해서 이 값을 증가시켜라.
section A.4.4 Where MySQL Stores Temporary Files를 참조하라

※sort_buffer와 record_buffer
sort_buffer와 record_buffer의 합이 8M가 넘지 않도록 주의한다
(sort_buffer+record_buffer)*max_connections가 자신의 램보다 크지 않도록해야 한다.

table_cache 
모든 쓰레드들에 대한 오픈할 수있는 테이블 수
이 값을 증가시키면 mysqld가 필요로 하는 파일 descriptors의 수를 증가시킨다.
Opened_tables variable를 체크함으로서 테이블케쉬를 증가시키것이 필요한지 체크할 수있다.
SHOW Syntax를 참조하라
이 값이 크고 FLUSH TABLES가 많지않다면(모든 테이블들을 닫고 재오픈하도록 강요하는 것) 그때, 이값을 증가시켜야 한다
테이블케쉬에 더 많은 정보를 얻으려면 How MySQL Opens and Closes Tables를 참조하라

※이것은 투덜이님에 의하면 mysql서버가 한번에 열수있는 테이블 수라고 한다
기본값은 64인데, max_connections의 1.5배정도 크기로 하는것이 좋다고 한다.

table_type 
디폴트 테이블 타입(myisam)

thread_cache_size 
케쉬를 재사용하기위해 얼마나 많은 쓰래드를 유지해야하는가
클라이언트가 연결이 끊겼을 때, 그 클라이언트의 쓰래드는 이전보다 더 많은 thread_cache_size 쓰레드가 존재하지 않는다면
케쉬에 놓여진다.
모든 새로운 쓰레드들은 먼저 케쉬에서 나오며, 단지 케쉬가 비어있을대 새로운 쓰레드를 생성한다.
이 값은 새로운 연결이 많을 경우 성능향상을 위해 증가시키게 된다.
보통 이것은 좋은 쓰레드수행을 가진다면 현저한 성능향상을 주지는 않는다.
connection과 threds_created사이에 차이를 알기위해서는 현재의 쓰레드 케쉬가 당신에게 얼마나 효과적인지 알 수있다.

thread_concurrency 
솔라리스에서, mysqld는 이 값과 thr_setconcurrency()를 호출할 것이다.
thr_setconcurrency()는 application에게 쓰레드시스템에게 동시에 실행되도록 원하는 쓰레드수에 대한 힌트를 준다

 

thread_stack 
각 쓰레드에 대한 스택사이즈
the crash-me test에 의해 발견된 한계치
디폴트는 normal operation에 대해 충분히 크다.
MySQL Benchmark Suite를 참조하라

timezone 
디비서버 타임 존

tmp_table_size 
메모리안에 temporary table이 이 사이즈를 초과하면 mysql은 자동적으로 temporary table을 디스크에 MyISAM table으로 
변환할 것이다. 당신이 많은 advanced GROUP BY queries과 많은 메모리를 가지고 있다면 이 값을 증가시켜라

tmpdir 
temporary files 과 temporary tables를 사용할 수있는 디렉토리

version 
mysql서버 버젼

wait_timeout 
서버를 닫히기전에 연결을 활성화하는데 서버가 기다리는 시간(초) 
interactive_timeout를 참조하라
----------------------------------------------------------------------------------------------------------------------------------------

▷ mysqladmin -u root -p extended-status(※mysql>show stauts)
----------------------------------------------------------------------------------------------------------------------------------------
Aborted_clients  
클라이언트가 연결을 적절히 닫지않아서 죽었기때문에 끊어진 연결수
Communication Errors / Aborted Connection를 참조

Aborted_connects  
연결실패된 mysql서버에 연결시도 수 
Communication Errors / Aborted Connection참조 

Bytes_received  
모든 클라이언트로 부터 받은 바이트 수

Bytes_sent  
모든 클라이언트에게 보낸 바이트수

Connections  
mysql서버에 연결시도한 수

Created_tmp_disk_tables  
sql문을 실행하는 동안 생성된 디스크에 존재하는 임시테이블 수

Created_tmp_tables  
sql문을 실행하는 동안 생성된 메모리에 존재하는 임시테이블 수

Created_tmp_files  
얼마나 많은 임시파일을 mysqld가 생성했는가

Delayed_insert_threads  
사용중인 insert handler threads가 지연되고 있는 수

Delayed_writes  
INSERT DELAYED로 쓰여진 rows수

Delayed_errors  
어떤 에러(duplicate key로인한 때문에 INSERT DELAYED로 쓰여진 rows수

Flush_commands  
초과 flush명령수

Handler_delete  
테이블로 부터 지워진 rows수

Handler_read_first  
인덱스로 부터 읽혀진 처음 entry수
이것이 높으면 서버는 많은 full index scans를 하고 있다는 것을 의미한다
예를 들어 SELECT col1 FROM foo는 col1은 인덱스되었다는 것을 추정한다.

Handler_read_key  
키가 존재하는 row를 읽는 요청수
이것이 높으면 당신의 쿼리와 테이블이 적절히 인덱스화되었다는 좋은 지적이된다.

Handler_read_next  
키순서대로 다음 row를 읽는 요청수
이것은 만약 range constraint와 함께 인덱스컬럼을 쿼리할 경우 높아질 것이다.
이것은 또한 인덱스 스캔하면 높아질 것이다

Handler_read_rnd  
고정된 위치에 존재하는 row를 읽는 요청수
이것은 결과를 정렬하기를 요하는 많은 쿼리를 한다면 높아질 것이다

Handler_read_rnd_next  
데이타파일에서 다음 row를 읽기를 요청수
이것은 많은 테이블 스캔을 하면 높아질 것이다
일반적으로 이것은 당신의 테이블들이 적절하게 인덱스되지 않았거나 당신의 쿼리들이 
당신이 가지고 있는 인덱스들의 이점을 활용하지 못하고 있다는 것을 의미한다

Handler_update  
Number of requests to update a row in a table.  
한테이블에 한 row를 업데이트를 요청하는 수

Handler_write  
Number of requests to insert a row in a table.  
한테이블에 한 row를 insert요청하는 수

Key_blocks_used  
The number of used blocks in the key cache.  
key케쉬에서 블럭을 사용하는 수

Key_read_requests  
케쉬에서 키블럭을 읽기를 요청하는 수

Key_reads  
디스크로부터 키블럭을 물리적으로 읽는 수

Key_write_requests  
The number of requests to write a key block to the cache.  
케쉬에서 키블럭을 쓰기위해 요청하는 수

Key_writes  
The number of physical writes of a key block to disk.  
디스크에 키블럭을 물리적으로 쓰는 수

Max_used_connections  
동시사용 연결 최대수 

Not_flushed_key_blocks  
키케쉬에서 키블럭이 바뀌지만 디스크에는 아직 flush되지 않는다

Not_flushed_delayed_rows  
Number of rows waiting to be written in INSERT DELAY queues.  
INSERT DELAY queue에서 쓰여지기를 기다리는 row수

Open_tables  
현재 오픈된 테이블수

Open_files  
현재 오픈된 파일수

Open_streams  
주로 logging에 사용되는 현재 오픈된 stream수

Opened_tables  
지금까지 오픈된 테이블 수

Select_full_join  
키없이 조인된 수(0이 되어야만 한다)

Select_full_range_join  
reference table에서 range search를 사용한 조인수

Select_range  
첫번째 테이블에 range를 사용했던 조인수
보통 이것이 크더라도 위험하진 않다

Select_scan  
첫번째 테이블을 스캔했던 조인수

Select_range_check  
각 row후에 key usage를 체크한 키없이 조인한 수(0이어야만 한다)

Questions  
서버에서 보낸 쿼리수

Slave_open_temp_tables  
현재 slave thread에 의해 오픈된 임시 테이블 수

Slow_launch_threads  
연결된 slow_launch_time보다 더 많은 수를 갖는 쓰레드수

Slow_queries  
long_query_time보다 더 많은 시간이 걸리는 쿼리 수
Slow Query Log참고

Sort_merge_passes  
정렬해야만 하는 merge수
이 값이 크면 sort_buffer를 증가하는것에 대해 고려해야한다

Sort_range  
Number of sorts that where done with ranges. 

Sort_rows  
정렬된 row수

Sort_scan  
테이블 스캔에 의해 행해진 정렬수

Table_locks_immediate  
즉시 획득된 테이블 lock 시간 (3.23.33부터 추가된 항목)

Table_locks_waited  
즉시 획득되지 않고 기다림이 필요한 테이블 lock 시간
이것이 높아지면 성능에 문제가 있으므로, 먼저 쿼리를 최적화 시키고, 테이블을 분산시키거나 복제를 사용해야한다
(3.23.33부터 추가된 항목)

Threads_cached  
스레드 캐쉬에서 쓰레드 수

Threads_connected  
현재 오픈된 연결수

Threads_created  
연결을 다루기위해 생성된 쓰레드 수

Threads_running  
sleeping하지 않는 쓰레드 수

Uptime  
서버가 스타트된 후로 지금까지의 시간

[참고]
1. Opened_tables가 크면  table_cache variable의 값이 너무 작은것일지도 모른다
2. key_reads가 크면 key_cach의 값이 너무 작은것일지도 모른다
3. cache hit rate은 key_reads/key_read_requests이다
4. Handler_read_rnd가 크면 MySQL의 모든 테이블을 스캔하는 많은 쿼리가 있다거나 
key를 적절히 사용하지 않는 조인들이 있을지 모른다
5. Threads_created가 크면 thread_cache_size값을 증가시키기를 바랄수도 있다
6. Created_tmp_disk_tables이 크면 디스크대신 임시테이블메모리를 얻기위해 
tmp_table_size값을 증가시키기를 원할 수있다
----------------------------------------------------------------------------------------------------------------------------------------

[튜닝참조 1]
※ 기본적으로 support-files밑에 `my-huge.cnf', `my-large.cnf', `my-medium.cnf', `my-small.출
를 기본으로 my.cnf 로 바꾸어 사용하면서 조정한다.

1. memory (>=256M)이고
많은 테이블이 있으며, 적당한 클라이언트수에서 최고 성능을 유지하기 위해
shell> safe_mysqld -O key_buffer=64M -O table_cache=256 
           -O sort_buffer=4M -O record_buffer=1M &
이러한 옵션으로 서버를 실행하는데, my-cnf에서 이를 수정하여 사용하면 될 것이다.

2. 128M메모리에 테이블이 적지만, 정렬이 많을 때
shell> safe_mysqld -O key_buffer=16M -O sort_buffer=1M

3. 메모리는 적지만 많은 연결이 있을 때
shell> safe_mysqld -O key_buffer=512k -O sort_buffer=100k 
           -O record_buffer=100k &
또는

shell> safe_mysqld -O key_buffer=512k -O sort_buffer=16k 
-O table_cache=32 -O record_buffer=8k -O net_buffer=1K &

[튜닝 참조2]
※group by와 order by작업이 가지고 있는 메모리보다 훨씬 클 경우, 정렬 후 row 읽는 것을 빠르게
하기위해 record_rnd_buffer값을 증가시켜라

※많은 연결로 인한 swapping problems는 메모리를 올려야 되는 것은 당연하다

※만약 튜닝을 위해 parameter를 바꾸고 그 효과에 대해 알아볼려면 
shell> mysqld -O key_buffer=32m --help
를 사용하면된다. 주의할점은 --help를 나중에 붙여야 한다는 것이다.

※mysqladmin -u root -p -i5 -r extended-status | grep -v "0" 
Enter password: 
+--------------------------+-------+
| Variable_name            | Value |
+--------------------------+-------+
| Bytes_received           | 38    |
| Bytes_sent               | 55    |
| Connections              | 2     |
| Flush_commands           | 1     |
| Handler_read_first       | 1     |
| Handler_read_rnd_next    | 13    |
| Open_files               | 1     |
| Opened_tables            | 6     |
| Questions                | 1     |
| Table_locks_immediate    | 5     |
| Threads_created          | 1     |
| Threads_connected        | 1     |
| Threads_running          | 1     |
| Uptime                   | 5     |
+--------------------------+-------+

▶Bytes_received:
모든 클라이언트로 부터 받은 바이트 수
▶Bytes_sent:
모든 클라이언트에게 보낸 바이트수
▶Connections:
mysql서버에 연결시도한 수
▶Flush_commands:
초과 flush명령수
▶Handler_read_first:
인덱스로 부터 읽혀진 처음 entry수
이것이 높으면 서버는 많은 full index scans를 하고 있다는 것을 의미한다
예를 들어 SELECT col1 FROM foo는 col1은 인덱스되었다는 것을 추정한다.
▶Handler_read_rnd_next:
데이타파일에서 다음 row를 읽기를 요청수
이것은 많은 테이블 스캔을 하면 높아질 것이다
일반적으로 이것은 당신의 테이블들이 적절하게 인덱스되지 않았거나 당신의 쿼리들이 
당신이 가지고 있는 인덱스들의 이점을 활용하지 못하고 있다는 것을 의미한다
▶Open_files:
현재 오픈된 파일수
▶Opened_tables:
현재 오픈된 테이블수
▶Questions:
서버시작후 지금까지 요청된 쿼리수  
▶Table_locks_immediate:
즉시 획득된 테이블 lock 시간 (3.23.33부터 추가된 항목)
▶Threads_created:
연결을 다루기위해 생성된 쓰레드 수
▶Threads_connected:
현재 오픈된 연결수
▶Threads_running:
sleeping하지 않는 쓰레드 수
▶Uptime :
서버가 스타트된 후로 지금까지의 시간