7.1 DB వైపు కాషింగ్

MySQL పట్టికలతో పని చేస్తున్నప్పుడు అధిక స్కేలబుల్ అల్గారిథమ్‌లను ఉపయోగిస్తుంది, కాబట్టి MySQL చిన్న మొత్తంలో మెమరీతో కూడా రన్ అవుతుంది. సహజంగానే, మెరుగైన పనితీరు కోసం, మీకు మరింత RAM అవసరం.

ప్రస్తుత సెట్టింగ్‌లను వీక్షించడానికి, డేటాబేస్‌కు కనెక్ట్ చేయండి


#mysq -u root -p

mysql> show variables like 'query_cache%';
+------------------------------+-----------+
| Variable_name                | Value     |
+------------------------------+-----------+
| query_cache_limit            | 1048576   |
| query_cache_min_res_unit     | 4096      |
| query_cache_size             | 134217728 |
| query_cache_type             | ON        |
| query_cache_wlock_invalidate | OFF       |
+------------------------------+-----------+
5 rows in set (0.00 sec)

ముందుగా, కాషింగ్ ప్రారంభించబడిందని నిర్ధారించుకోండి. వేరియబుల్:

  • query_cache_typeతప్పనిసరిగా ఆన్‌లో ఉండాలి (1) లేదా డిమాండ్ (2)
  • query_cache_limit- కాష్‌లోకి వచ్చే ఫలితం యొక్క గరిష్ట పరిమాణాన్ని నిర్ణయిస్తుంది
  • query_cache_sizeసున్నా నుండి భిన్నంగా ఉంటుంది. DEMANDని ఉపయోగిస్తున్నప్పుడు, ఆదేశాన్ని కలిగి ఉన్న అభ్యర్థనలు మాత్రమే కాష్ చేయబడతాయిSQL_CACHE;
  • query_cache_min_res_unitకాష్ చేసిన ప్రశ్న ఫలితాలను నిల్వ చేయడానికి కేటాయించిన మెమరీ బ్లాక్ యొక్క కనిష్ట పరిమాణం. MySQL కాష్‌ను ఒక పెద్ద మెమరీలో నిల్వ చేయదు, బదులుగా ఇది query_cache_min_res_unitడిమాండ్‌పై కనిష్ట పరిమాణంతో (=4KB డిఫాల్ట్‌గా) బ్లాక్‌లను కేటాయిస్తుంది. అటువంటి చివరి బ్లాక్ డేటా పరిమాణానికి కత్తిరించబడింది మరియు మిగిలిన మెమరీ ఖాళీ చేయబడుతుంది.

కాషింగ్ యొక్క ప్రభావం ఏమిటంటే, సర్వర్ అభ్యర్థనను స్వీకరించినప్పుడు, అభ్యర్థన యొక్క హాష్ కాష్‌లో ఉందో లేదో చూస్తుంది. హాష్ సరిపోలితే - సర్వర్ వెంటనే ఫలితాన్ని అందిస్తుంది - అభ్యర్థనను అన్వయించడం, ఆప్టిమైజ్ చేయడం మొదలైనవి లేకుండా. ఓవర్‌హెడ్ - కాషింగ్ మెకానిజంతో పాటు - కాష్‌ని బ్రౌజ్ చేయడం, ప్రశ్న ఫలితాన్ని కాష్‌కి రాయడం మొదలైనవి.

మరియు మీరు కాష్‌లో చాలా చిన్న అభ్యర్థనలను కలిగి ఉంటే, ఇది పెద్ద సంఖ్యలో ఉచిత బ్లాక్‌ల కారణంగా మెమరీ ఫ్రాగ్మెంటేషన్‌కు దారితీస్తుంది. మరియు ఇది, మెమరీ లేకపోవడం వల్ల కాష్ చేసిన ఎంట్రీలను తొలగించడానికి కారణమవుతుంది. ఈ సందర్భంలో, విలువను తగ్గించడం అర్ధమే query_cache_min_res_unit. మీ ప్రశ్నలలో చాలా వరకు పెద్ద ఫలితాలు వస్తే, ఈ సెట్టింగ్‌ని పెంచడం వలన పనితీరు మెరుగుపడుతుంది.

Java university

ప్రభావాన్ని అంచనా వేయడానికి ప్రయత్నిద్దాం. కాష్ హిట్ కౌంటర్లు ఎలా మారతాయో (Qcahe_hits), మెమరీ లేకపోవడం వల్ల చెల్లని అభ్యర్థనల సంఖ్య (Qcache_lowmem_prunes), SELECT రకం అభ్యర్థనల మొత్తం సంఖ్య (మరియు అవి మాత్రమే కాష్ చేయబడ్డాయి):


#mysq -u root -p
mysql> show status like 'Qcache%';
+-------------------------+-----------+
| Variable_name           | Value     |
+-------------------------+-----------+
| Qcache_free_blocks      | 715       |
| Qcache_free_memory      | 130369640 |
| Qcache_hits             | 24209     |
| Qcache_inserts          | 16215     |
| Qcache_lowmem_prunes    | 0         |
| Qcache_not_cached       | 444       |
| Qcache_queries_in_cache | 1740      |
| Qcache_total_blocks     | 4225      |
+-------------------------+-----------+
8 rows in set (0.00 sec)

7.2 ప్రస్తుత కాష్ స్థితి

ప్రశ్న కాష్‌ని పర్యవేక్షించడానికి ఉపయోగించబడుతుంది SHOW STATUS:


mysql> SHOW STATUS LIKE 'Qcache_%';
+-------------------------+----------+
| Variable_name           | Value    |
+-------------------------+----------+
| Qcache_free_blocks      | 10       |
| Qcache_free_memory      | 16755496 |
| Qcache_hits             | 49812    |
| Qcache_inserts          | 103999   |
| Qcache_lowmem_prunes    | 0        |
| Qcache_not_cached       | 180      |
| Qcache_queries_in_cache | 6        |
| Qcache_total_blocks     | 28       |
+-------------------------+----------+
8 rows in set (0.00 sec)
  • Qcache_free_blocksకాష్‌లో ఎన్ని ఉచిత బ్లాక్‌లు ఉన్నాయో చూపిస్తుంది (కాష్ చేసిన అభ్యర్థనలు పెరిగేకొద్దీ తగ్గుతుంది);
  • Qcache_total_blocks- ఆక్రమిత బ్లాకుల సంఖ్య;
  • Qcache_free_memory- కాషింగ్ కోసం ఉచిత "అందుబాటులో ఉన్న" మెమరీని చూపుతుంది;
  • Qcache_hits- అభ్యర్థనల సంఖ్య, వాస్తవానికి డేటాబేస్ను యాక్సెస్ చేయకుండానే కాష్ నుండి తీసుకోబడిన ఫలితాలు;
  • Qcache_inserts- కాష్‌కి జోడించబడిన అభ్యర్థనల సంఖ్య;
  • Qcache_lowmem_prunes- మెమరీ లేకపోవడం వల్ల కాష్ నుండి తీసివేయబడిన అభ్యర్థనల సంఖ్య;
  • Qcache_not_cached- సమయ నిర్వహణ విధులు మొదలైన వాటి కారణంగా కాష్‌కి వ్రాయబడని అభ్యర్థనల సంఖ్య;
  • Qcache_queries_in_cache- కాష్‌లో ఉన్న అభ్యర్థనల సంఖ్య.

మీరు మొత్తం SELECT ప్రశ్నల సంఖ్యను వీక్షించవచ్చు:


mysql> show status like 'Com_select';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| Com_select    | 16719 |
+---------------+-------+
1 row in set (0.00 sec)

7.3 కాషింగ్ సామర్థ్యం

Qcache_hits on Qcache_hits + Com_select“అభ్యర్థనను ప్రాసెస్ చేస్తున్నప్పుడు, Qcache_hits కౌంటర్ పెరుగుతుంది (అభ్యర్థన కాష్ నుండి ప్రాసెస్ చేయబడితే) లేదా Com_select (అభ్యర్థన కాష్ చేయబడకపోతే) నుండి వేరియబుల్ విలువను విభజించడం ద్వారా కాష్ యొక్క ప్రభావాన్ని అంచనా వేయమని సిఫార్సు చేయబడింది . ఈ పద్ధతి "Mysql పెర్ఫార్మెన్స్ ఆప్టిమైజేషన్" O'reillyలో సూచించబడింది

ఆన్‌లైన్‌లో మరో మార్గం ఉంది

qcache_hit_ratio = qcache_hits / (qcache_hits + qcache_inserts + qcache_not_cached)

ఈ విలువ > 0.8 అయితే, మీ అభ్యర్థనలలో 80% కాష్ చేయబడి ఉంటాయి, ఇది చాలా మంచి సూచిక.

కాష్ హిట్ తక్కువగా ఉంటే %, మీరు విలువను పెంచాలి query_cache_size.

ప్రస్తుత విలువను ఇలా చూడవచ్చు:

SHOW VARIABLES LIKE 'query_cache_size';

మళ్ళీ, ప్రశ్న తలెత్తుతుంది: తగిన విలువను ఎలా ఎంచుకోవాలిquery_cache_size?

ఇది సహాయం చేస్తుంది Qcache_lowmem_prunes. ఈ వేరియబుల్ కొత్త అభ్యర్థనలను కాష్ చేయవలసిన అవసరం కారణంగా కాష్ నుండి తీసివేయబడిన అభ్యర్థనల సంఖ్యను నిల్వ చేస్తుంది. అటువంటి కాష్ పరిమాణం కోసం ప్రయత్నించడం అవసరం, Qcache_lowmem_prunesఅది కొద్దిగా పెరుగుతుంది. దీన్ని చేయడానికి, గంటకు విలువలలోని వ్యత్యాసాన్ని Qcache_lowmem_prunesమరియు అదే గంటలో mysql అందుకున్న అభ్యర్థనల సంఖ్యను సరిపోల్చాలని సిఫార్సు చేయబడింది.

“ఆచరణలో, query_cache_sizeని లెక్కించడానికి 2 సూత్రాలలో ఒకదాన్ని ఉపయోగించవచ్చు:

query_cache_size = (number of requests for 10 minutes)*(average response volume on request) * 1,2

లేదా

query_cache_size = (number of requests for 10 minutes)*(average response volume on request) * 1,2
query_cache_size = (10 నిమిషాల్లో ట్రాఫిక్ వాల్యూమ్) * 1.2 "

ఇది 10 నిమిషాల పాటు అభ్యర్థనలను కాష్ చేస్తుంది + కాష్ ఫ్రాగ్మెంటేషన్ మరియు అదనపు కాషింగ్ రిజర్వ్ కోసం అదనంగా 20% మెమరీని ఇస్తుంది

మీరు Bytes_sent వేరియబుల్స్ ఉపయోగించి అభ్యర్థనకు ప్రతిస్పందన యొక్క సంఖ్య మరియు సగటు వాల్యూమ్‌ను వరుసగా లెక్కించవచ్చు

కాబట్టి మేము query_cache_sizeవిలువలను పెంచాము, దాని తర్వాత మీరు విలువలకు శ్రద్ధ వహించాలి Qcache_total_blocksమరియు Qcache_free_blocks. Qcache_queries_in_cacheMySQL బ్లాక్‌లలో కాష్‌ని నిల్వ చేస్తుంది. 1 అభ్యర్థన కోసం, 2 బ్లాక్‌లు అవసరం: ఒకటి అభ్యర్థన వచనం కోసం, రెండవది ఫలితం కోసం.

మేము విలువ నుండి పట్టికను పరిశీలిస్తేQcache%

కాష్ బ్లాక్‌ల మొత్తం సంఖ్యQcache_total_blocks – 28

అభ్యర్థన 6 ఇప్పుడు కాష్ చేయబడింది, అంటే 6 * 2 = 12 బ్లాక్‌లు బిజీగా ఉన్నాయి

ఉచిత బ్లాక్‌లు Qcache_free_blocks – 10. మరింత నిష్క్రియంగా ఉంటే Qcache_free_blocks, కాష్ యొక్క "ఫ్రాగ్మెంటేషన్" స్థాయి పెరుగుతుంది.

చాలా ప్రశ్నలు ఫలితంగా డేటా యొక్క చిన్న మొత్తాన్ని కలిగి ఉంటే, అప్పుడు కనీస కాష్ బ్లాక్ పరిమాణాన్ని తగ్గించడం విలువ query_cache_min_res_unit, ఇది డిఫాల్ట్‌గా 4 KB.

చాలా అభ్యర్థనలు చాలా డేటాను తిరిగి ఇస్తే, కాష్ బ్లాక్ పరిమాణాన్ని పెంచడం విలువ.

కనీస విలువను సాధించడం ప్రధాన విషయం Qcache_free_blocks.

కౌంటర్ Qcache_not_cachedపెద్దది అయినట్లయితే, మీరు వేరియబుల్ని పెంచడానికి ప్రయత్నించవచ్చు query_cache_limit- ఇది పరిమితిని పెంచడానికి మరియు "సరిపోని" ప్రశ్నల ఫలితాలను కాష్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.

ప్రశ్న కాష్‌ని ఉపయోగించడానికి క్రింది కాన్ఫిగరేషన్ వేరియబుల్స్ బాధ్యత వహిస్తాయి:

  • query_cache_size- ప్రశ్న కాష్ పరిమాణం. query_cache_size = 0కాష్ వినియోగాన్ని నిలిపివేస్తుంది;
  • query_cache_limit- కాష్‌లో నిల్వ చేయబడిన గరిష్ట నమూనా పరిమాణం;
  • query_cache_wlock_invalidate- డేటా కాష్ నుండి తీసుకోబడుతుందో లేదో నిర్ణయిస్తుంది, అవి చదవడానికి సంబంధించిన టేబుల్ లాక్ చేయబడితే.
    • =

mysql ప్రశ్న కాషింగ్‌ని ప్రారంభించడానికి, my.cnf (విభాగం [mysqld])కి క్రింది పంక్తులను జోడించండి:


query_cache_size = 268435456
query_cache_type =1 
query_cache_limit =1 048576

మరియు సేవను పునఃప్రారంభించండి.

7.4 ఎక్కడ కాష్ ఉపయోగించబడదు

కాష్ చేయబడలేదు:

  • నుండి అభ్యర్థనలుSQL_NO_CACHE
  • సిద్ధం చేసిన ప్రశ్నలు(Prepared statements);
  • బయటి ప్రశ్న యొక్క ఉపప్రశ్నలు;
  • నిల్వ చేయబడిన విధానాలు మరియు విధుల్లోని ప్రశ్నలు;
  • ఫంక్షన్లను ఉపయోగించే ప్రశ్నలు:

    BENCHMARK (), CONNECTION_ID (), CONVERT_TZ (), , , , CURDATE (), , ఒక వాదనతో , , _ _ _ _ _ _ _ _ _ _CURRENT_DATE ()CURRENT_TIME ()CURRENT_TIMESTAMP ()CURTIME ()DATABASE ()ENCRYPT ()FOUND_ROWS ()GET_LOCK () LAST_INSERT_ID ()LOAD_FILE ()MASTER_POS_WAIT ()NOW ()RAND ()RELEASE_LOCK ()SLEEP ()SYSDATE ()UNIX_TIMESTAMP ()USER ()UUID ();

  • mysql సిస్టమ్ డేటాబేస్‌లు లేదా INFORMATION_SCHEMA లో స్టోర్ చేయబడిన ఫంక్షన్‌లు, యూజర్ వేరియబుల్స్ లేదా రెఫరెన్సింగ్ టేబుల్‌లను ఉపయోగించే ప్రశ్నలు ;
  • • కింది ఫారమ్‌లలో అభ్యర్థనలు:
    • SELECT ... IN SHARE MODE
    • SELECT ... FOR UPDATE
    • SELECT ... INTO OUTFILE ...
    • SELECT ... INTO DUMPFILE ...
    • SELECT * FROM ... WHERE autoincrement_col IS NULL
  • తాత్కాలిక పట్టికలు లేదా పట్టికలను ఉపయోగించని ప్రశ్నలు;
  • హెచ్చరికలను రూపొందించే అభ్యర్థనలు (హెచ్చరికలు);

మీరు ఆదేశంతో కాష్‌ను డిఫ్రాగ్మెంట్ చేయవచ్చు:

mysql>flush query cache;

క్లియర్ - కమాండ్:

mysql>flush query cache;

అతి ముఖ్యమిన

డిఫాల్ట్ సెట్టింగ్‌లతో ఉత్పత్తిలో ఎప్పుడూ పని చేయవద్దు. దీని వలన సర్వర్ యొక్క చాలా వనరులు ఉపయోగించబడవు. సరైన MySQL ట్యూనింగ్ అనేక సార్లు డేటాబేస్ పనితీరును మెరుగుపరుస్తుంది. ఇది అప్లికేషన్‌ను వేగవంతం చేయడమే కాకుండా, భారీ లోడ్‌ను కూడా తట్టుకుంటుంది.