/ लगाएं एक स्ट्रिंग के भीतर से एक स्ट्रिंग पार्स

Original post: http://anothermysqldba.blogspot.com/2014/12/findparse-string-from-within-string.html

तो मैंने हाल ही में एक और स्ट्रिंग के बाहर एक स्ट्रिंग पार्स करने के बारे में कुछ अलग सवाल और पदों देखा। कुछ समाधान आदि नए कार्य और बनाने शामिल है, जबकि यह भी है कि कुछ मामलों में एक ही प्रश्न के भीतर किया जा सकता है। 

उदाहरण के लिए, हमें हम एक यूआरएल से डोमेन बाहर खींचने के लिए देख रहे हैं कि हम कहते हैं। मैं करने के लिए क्यों और कैसे यह काम करता है के रूप में विस्तार में जाने की कोशिश करेंगे। 
हम निम्न तालिका है। 


CREATE TABLE `parse_example` ( 
`id` int(11) NOT NULL AUTO_INCREMENT, 
`urldemo` varchar(150) NOT NULL, 
PRIMARY KEY (`id`) 
) ENGINE=InnoDB; 
+----+----------------------------+ 
| id | urldemo | 
+----+----------------------------+ 
| 1 | http://www.mysql.com/ | 
| 2 | http://www.percona.com/ | 
| 3 | https://tools.percona.com/ | 
| 4 | https://mariadb.com/ | 
| 5 | http://planet.mysql.com/ | 
| 6 | http://dev.mysql.com/doc/ | 
+----+----------------------------+ 

कॉम के बाद // और कुछ भी: // या https: इस उदाहरण के लिए लक्ष्य HTTP उपेक्षा करने के लिए है। इसलिए हम स्थानों को खोजने के लिए खोजें उपयोग करें। 

कॉम संदर्भ हम उस के साथ शुरू कर सकते हैं इतना है कि स्थिर है के बाद से आसान है। 


SELECT LOCATE('.com', urldemo), urldemo FROM parse_example; 
+-------------------------+----------------------------+ 
| LOCATE('.com', urldemo) | urldemo | 
+-------------------------+----------------------------+ 
| 17 | http://www.mysql.com/ | 
| 19 | http://www.percona.com/ | 
| 22 | https://tools.percona.com/ | 
| 16 | https://mariadb.com/ | 
| 20 | http://planet.mysql.com/ | 
| 17 | http://dev.mysql.com/doc/ | 
+-------------------------+----------------------------+ 

ठीक है तो हम / निकालना चाहते हैं, कि क्या स्थान है? 


SELECT LOCATE('.com', urldemo) as start, LOCATE('.com', urldemo) +4 as end, SUBSTRING(urldemo FROM LOCATE('.com', urldemo) + 4 ) AS resulting , urldemo FROM parse_example; 
+-------+-----+-----------+----------------------------+ 
| start | end | resulting | urldemo | 
+-------+-----+-----------+----------------------------+ 
| 17 | 21 | / | http://www.mysql.com/ | 
| 19 | 23 | / | http://www.percona.com/ | 
| 22 | 26 | / | https://tools.percona.com/ | 
| 16 | 20 | / | https://mariadb.com/ | 
| 20 | 24 | / | http://planet.mysql.com/ | 
| 17 | 21 | /doc/ | http://dev.mysql.com/doc/ | 
+-------+-----+-----------+----------------------------+

यह मैं ही पालन करने के लिए परिणामों को आसान बनाने के लिए क्षेत्र उपनाम रखा है, हमें हमारे अंत की स्थिति देता है। 

उन्हें बाद //, तो हम सिर्फ स्ट्रिंग में / दूसरे के स्थान की जरूरत: अब HTTP और HTTPS के बाद बाहर छँटाई बहुत आसान के रूप में अच्छी तरह से वे दोनों के रूप में वास्तव में है। 


SELECT LOCATE('/', urldemo) as first, LOCATE('/', urldemo) +1 as second, urldemo 
FROM parse_example; 
+-------+--------+----------------------------+ 
| first | second | urldemo | 
+-------+--------+----------------------------+ 
| 6 | 7 | http://www.mysql.com/ | 
| 6 | 7 | http://www.percona.com/ | 
| 7 | 8 | https://tools.percona.com/ | 
| 7 | 8 | https://mariadb.com/ | 
| 6 | 7 | http://planet.mysql.com/ | 
| 6 | 7 | http://dev.mysql.com/doc/ | 
+-------+--------+----------------------------+ 

इन प्रश्नों सिर्फ अंतिम क्वेरी के विभिन्न पहलुओं कर रही हो जाएगा क्या दिखा रहे हैं। इसलिए हमें यह सब एक साथ डाल दिया। 


SELECT 
TRIM(TRAILING SUBSTRING(urldemo FROM LOCATE('.com', urldemo) + 4 ) 
FROM SUBSTRING(urldemo FROM LOCATE('/', urldemo) + 2 ) ) AS parsed_domain , 
urldemo as original_url 
FROM parse_example; 
+-------------------+----------------------------+ 
| parsed_domain | original_url | 
+-------------------+----------------------------+ 
| www.mysql.com | http://www.mysql.com/ | 
| www.percona.com | http://www.percona.com/ | 
| tools.percona.com | https://tools.percona.com/ | 
| mariadb.com | https://mariadb.com/ | 
| planet.mysql.com | http://planet.mysql.com/ | 
| dev.mysql.com | http://dev.mysql.com/doc/ | 
+-------------------+----------------------------+ 

अब उम्मीद है कि आप की जरूरत है जो कुछ भी बाहर पार्स करने में सक्षम हो मदद करता है। यह उदाहरण एक यूआरएल तक सीमित है। लेकिन कार्य के कुछ उदाहरण के बाद से पहले से ही यहाँ आप की जरूरत है जो कुछ पार्स करने के लिए उपयोग कर सकते हैं कि एक समारोह के मेरे उदाहरण है। 


CREATE FUNCTION PARSE_STRING(delimiterA VARCHAR(50), delimiterB VARCHAR(50), passed_string VARCHAR(255) ) 
RETURNS VARCHAR(255) DETERMINISTIC 
RETURN 
TRIM(TRAILING SUBSTRING(passed_string FROM LOCATE(delimiterB, passed_string) ) 
FROM SUBSTRING(passed_string FROM LOCATE(delimiterA, passed_string) + CHAR_LENGTH(delimiterA) ) ) ; 

SELECT PARSE_STRING('//','.com', urldemo) FROM parse_example; 
+------------------------------------+ 
| PARSE_STRING('//','.com', urldemo) | 
+------------------------------------+ 
| www.mysql | 
| www.percona | 
| tools.percona | 
| mariadb | 
| planet.mysql | 
| dev.mysql | 
+------------------------------------+ 

एक पूरा नाम क्षेत्र से एक अंतिम नाम खींचो: 


SELECT PARSE_STRING('John ','', 'John Smith') ; 
+----------------------------------------+ 
| PARSE_STRING('John ','', 'John Smith') | 
+----------------------------------------+ 
| Smith | 
+----------------------------------------+ 

पहला नाम खींचो 


SELECT PARSE_STRING('',' Smith', 'John Smith') ; 
+-----------------------------------------+ 
| PARSE_STRING('',' Smith', 'John Smith') | 
+-----------------------------------------+ 
| John | 
+-----------------------------------------+ 

नाम उदाहरणों के साथ दी जाती है कि आप सीमांकक मूल्यों को पता करने की आवश्यकता होगी। लेकिन यह आप पर निर्माण कर सकते हैं सिर्फ एक उदाहरण है।

एक MySQL विभाजन और SUBPARTITION उदाहरण

Original post: http://anothermysqldba.blogspot.com/2014/12/a-mysql-partition-and-subpartition.html

तो यह एक विभाजन और MySQL में एक SUBPARTITION कैसे स्थापित करने के लिए सिर्फ एक सरल उदाहरण है। यहाँ अवधारणा आप एक datetime क्षेत्र में कई मूल्यों के साथ एक तालिका में डेटा है। आप (यदि आप करते हैं सबसे अधिक संभावना) कई साल भर में फैला हुआ है कि डेटा हो सकता है। इसलिए इस डेटा विभाजन करने के लिए एक ही रास्ता वर्ष से इसे तरह है, लेकिन फिर भी लगता है कि वार्षिक विभाजन के भीतर माह से यह सॉर्ट करने के लिए है। 

नीचे आप विचार के लिए उपयोग कर सकते हैं कि एक उदाहरण है। 

परीक्षण मेज पर विचार करें। के साथ अपनी मेज पाठ्यक्रम के कई क्षेत्रों है। 


CREATE TABLE `t1` ( 
`id` int(11) NOT NULL AUTO_INCREMENT, 
`date_time` datetime DEFAULT NOW(), 
PRIMARY KEY (`id`) 
) ENGINE=InnoDB; 

पहले मैं DATE_TIME क्षेत्र के लिए यादृच्छिक मूल्यों के साथ परीक्षण तालिका आबाद होगा। 


delimiter // 
CREATE PROCEDURE populate_t1( IN rowsofdata INT ) 
BEGIN 

SET @A = 1; 
SET @B = 25 - @A; 

WHILE rowsofdata > 0 DO 
SELECT FLOOR( @A + (RAND() * @B )) INTO @randvalue; 
INSERT INTO t1 
SELECT NULL, NOW() - INTERVAL @randvalue MONTH; 
SET rowsofdata = rowsofdata - 1; 
END WHILE; 
END// 
delimiter ; 
call populate_t1(1000); 

मैं के साथ समाप्त हुआ मूल्यों का किस तरह देखने के लिए जाँच करें: 


> SELECT COUNT(*) FROM t1 WHERE date_time BETWEEN '2012-01-01 00:00:00' AND '2013-01-01 00:00:00'\G 
*************************** 1. row *************************** 
COUNT(*): 43 
1 row in set (0.00 sec) 

> SELECT COUNT(*) FROM t1 WHERE date_time BETWEEN '2013-01-01 00:00:00' AND '2014-01-01 00:00:00'\G 
*************************** 1. row *************************** 
COUNT(*): 529 
1 row in set (0.00 sec) 

> SELECT COUNT(*) FROM t1 WHERE date_time BETWEEN '2014-01-01 00:00:00' AND NOW() \G
*************************** 1. row *************************** 
COUNT(*): 428 
1 row in set (0.00 sec) 

मैं विभाजन के माध्यम से मूल्यों मायने रखता है मेरी विभाजन जोड़ने और फिर परीक्षण कर सकते हैं तो अब मैं टेबल बदल सकते हैं। 


ALTER TABLE t1 DROP PRIMARY KEY, ADD PRIMARY KEY (`id`,`date_time`), LOCK=SHARED; 
ALTER TABLE t1 
PARTITION BY RANGE( YEAR(date_time) ) 
SUBPARTITION BY HASH(MONTH(date_time) ) ( 

PARTITION p2012 VALUES LESS THAN (2013) ( 
SUBPARTITION dec_2012, 
SUBPARTITION jan_2012, 
SUBPARTITION feb_2012, 
SUBPARTITION mar_2012, 
SUBPARTITION apr_2012, 
SUBPARTITION may_2012, 
SUBPARTITION jun_2012, 
SUBPARTITION jul_2012, 
SUBPARTITION aug_2012, 
SUBPARTITION sep_2012, 
SUBPARTITION oct_2012, 
SUBPARTITION nov_2012 
), 

PARTITION p2013 VALUES LESS THAN (2014) ( 
SUBPARTITION dec_2013, 
SUBPARTITION jan_2013, 
SUBPARTITION feb_2013, 
SUBPARTITION mar_2013, 
SUBPARTITION apr_2013, 
SUBPARTITION may_2013, 
SUBPARTITION jun_2013, 
SUBPARTITION jul_2013, 
SUBPARTITION aug_2013, 
SUBPARTITION sep_2013, 
SUBPARTITION oct_2013, 
SUBPARTITION nov_2013 

), 
PARTITION p2014 VALUES LESS THAN (2015) ( 
SUBPARTITION dec_2014, 
SUBPARTITION jan_2014, 
SUBPARTITION feb_2014, 
SUBPARTITION mar_2014, 
SUBPARTITION apr_2014, 
SUBPARTITION may_2014, 
SUBPARTITION jun_2014, 
SUBPARTITION jul_2014, 
SUBPARTITION aug_2014, 
SUBPARTITION sep_2014, 
SUBPARTITION oct_2014, 
SUBPARTITION nov_2014 
), 

PARTITION pmax VALUES LESS THAN MAXVALUE ( 
SUBPARTITION dec_max, 
SUBPARTITION jan_max, 
SUBPARTITION feb_max, 
SUBPARTITION mar_max, 
SUBPARTITION apr_max, 
SUBPARTITION may_max, 
SUBPARTITION jun_max, 
SUBPARTITION jul_max, 
SUBPARTITION aug_max, 
SUBPARTITION sep_max, 
SUBPARTITION oct_max, 
SUBPARTITION nov_max 
) 
); 

तालिका बनाने के अपने शो अब बहुत अलग है। 


> show create table t1; 
CREATE TABLE `t1` ( 
`id` int(11) NOT NULL AUTO_INCREMENT, 
`date_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP, 
PRIMARY KEY (`id`,`date_time`) 
) ENGINE=InnoDB AUTO_INCREMENT=1001 DEFAULT CHARSET=latin1 
/*!50100 PARTITION BY RANGE ( YEAR(date_time)) 
SUBPARTITION BY HASH (MONTH(date_time)) 
(PARTITION p2012 VALUES LESS THAN (2013) 
(SUBPARTITION dec_2012 ENGINE = InnoDB, 
SUBPARTITION jan_2012 ENGINE = InnoDB, 
SUBPARTITION feb_2012 ENGINE = InnoDB, 
SUBPARTITION mar_2012 ENGINE = InnoDB, 
SUBPARTITION apr_2012 ENGINE = InnoDB, 
SUBPARTITION may_2012 ENGINE = InnoDB, 
SUBPARTITION jun_2012 ENGINE = InnoDB, 
SUBPARTITION jul_2012 ENGINE = InnoDB, 
SUBPARTITION aug_2012 ENGINE = InnoDB, 
SUBPARTITION sep_2012 ENGINE = InnoDB, 
SUBPARTITION oct_2012 ENGINE = InnoDB, 
SUBPARTITION nov_2012 ENGINE = InnoDB), 
PARTITION p2013 VALUES LESS THAN (2014) 
(SUBPARTITION dec_2013 ENGINE = InnoDB, 
SUBPARTITION jan_2013 ENGINE = InnoDB, 
SUBPARTITION feb_2013 ENGINE = InnoDB, 
SUBPARTITION mar_2013 ENGINE = InnoDB, 
SUBPARTITION apr_2013 ENGINE = InnoDB, 
SUBPARTITION may_2013 ENGINE = InnoDB, 
SUBPARTITION jun_2013 ENGINE = InnoDB, 
SUBPARTITION jul_2013 ENGINE = InnoDB, 
SUBPARTITION aug_2013 ENGINE = InnoDB, 
SUBPARTITION sep_2013 ENGINE = InnoDB, 
SUBPARTITION oct_2013 ENGINE = InnoDB, 
SUBPARTITION nov_2013 ENGINE = InnoDB), 
PARTITION p2014 VALUES LESS THAN (2015) 
(SUBPARTITION dec_2014 ENGINE = InnoDB, 
SUBPARTITION jan_2014 ENGINE = InnoDB, 
SUBPARTITION feb_2014 ENGINE = InnoDB, 
SUBPARTITION mar_2014 ENGINE = InnoDB, 
SUBPARTITION apr_2014 ENGINE = InnoDB, 
SUBPARTITION may_2014 ENGINE = InnoDB, 
SUBPARTITION jun_2014 ENGINE = InnoDB, 
SUBPARTITION jul_2014 ENGINE = InnoDB, 
SUBPARTITION aug_2014 ENGINE = InnoDB, 
SUBPARTITION sep_2014 ENGINE = InnoDB, 
SUBPARTITION oct_2014 ENGINE = InnoDB, 
SUBPARTITION nov_2014 ENGINE = InnoDB), 
PARTITION pmax VALUES LESS THAN MAXVALUE 
(SUBPARTITION dec_max ENGINE = InnoDB, 
SUBPARTITION jan_max ENGINE = InnoDB, 
SUBPARTITION feb_max ENGINE = InnoDB, 
SUBPARTITION mar_max ENGINE = InnoDB, 
SUBPARTITION apr_max ENGINE = InnoDB, 
SUBPARTITION may_max ENGINE = InnoDB, 
SUBPARTITION jun_max ENGINE = InnoDB, 
SUBPARTITION jul_max ENGINE = InnoDB, 
SUBPARTITION aug_max ENGINE = InnoDB, 
SUBPARTITION sep_max ENGINE = InnoDB, 
SUBPARTITION oct_max ENGINE = InnoDB, 
SUBPARTITION nov_max ENGINE = InnoDB)) 

उम्मीद के रूप में तो हम अभी भी हमारे मूल्य भरोसा कर सकते हैं? 


> SELECT count(*) FROM t1 PARTITION (p2012) \G 
*************************** 1. row *************************** 
count(*): 43 
> SELECT count(*) FROM t1 PARTITION (p2013) \G 
*************************** 1. row *************************** 
count(*): 529 
> SELECT count(*) FROM t1 PARTITION (p2014) \G 
*************************** 1. row *************************** 
count(*): 428 

अब तक तो अच्छा, सभी मानों हम पहले था गणना करने के लिए मिलान। इसलिए हम भी गिनती या subpartition प्रति चुन सकते हैं। 


> SELECT * FROM t1 PARTITION (dec_2012) limit 5; 
+-----+---------------------+ 
| id | date_time | 
+-----+---------------------+ 
| 59 | 2012-12-19 00:59:57 | 
| 68 | 2012-12-19 00:59:58 | 
| 93 | 2012-12-19 00:59:59 | 
| 105 | 2012-12-19 00:59:59 | 
| 111 | 2012-12-19 00:59:59 | 
+-----+---------------------+ 

> SELECT * FROM t1 PARTITION (jan_2013) limit 5; 
+-----+---------------------+ 
| id | date_time | 
+-----+---------------------+ 
| 6 | 2013-01-19 00:59:55 | 
| 29 | 2013-01-19 00:59:56 | 
| 55 | 2013-01-19 00:59:57 | 
| 79 | 2013-01-19 00:59:58 | 
| 100 | 2013-01-19 00:59:59 | 
+-----+---------------------+ 

> SELECT * FROM t1 PARTITION (jan_2014) limit 5; 
+-----+---------------------+ 
| id | date_time | 
+-----+---------------------+ 
| 16 | 2014-01-19 00:59:55 | 
| 190 | 2014-01-19 01:00:04 | 
| 191 | 2014-01-19 01:00:04 | 
| 229 | 2014-01-19 01:00:05 | 
| 234 | 2014-01-19 01:00:06 | 
+-----+---------------------+ 

> SELECT * FROM t1 PARTITION (jun_2014) limit 5; 
+-----+---------------------+ 
| id | date_time | 
+-----+---------------------+ 
| 13 | 2014-06-19 00:59:55 | 
| 189 | 2014-06-19 01:00:04 | 
| 221 | 2014-06-19 01:00:05 | 
| 222 | 2014-06-19 01:00:05 | 
| 238 | 2014-06-19 01:00:06 | 
+-----+---------------------+ 

> SELECT * FROM t1 PARTITION (dec_2013) limit 5; 
+-----+---------------------+ 
| id | date_time | 
+-----+---------------------+ 
| 50 | 2013-12-19 00:59:57 | 
| 74 | 2013-12-19 00:59:58 | 
| 98 | 2013-12-19 00:59:59 | 
| 107 | 2013-12-19 00:59:59 | 
| 167 | 2013-12-19 01:00:02 | 
+-----+---------------------+ 

इस महान और आसान है लेकिन वर्ष 2015 या 2016 के आसपास आता है तो क्या होगा? उस डेटा के सभी pmax विभाजन में होगा। तो कैसे हम p2014 और pmax के बीच में एक नया विभाजन जोड़ सकता हूँ? 

आप pmax में कोई डाटा नहीं था, तो आप इसे छोड़ देता है और अंत पर एक नया विभाजन जोड़ सकता है। लेकिन यह विभाजन के पुनर्निर्माण के लिए बस के रूप में आसान है। इस pmax विभाजन लेने के लिए और हमारे नए विभाजन में बदल जाएगा। 


ALTER TABLE t1 REORGANIZE PARTITION pmax INTO ( 
PARTITION p2015 VALUES LESS THAN (2016) ( 
SUBPARTITION dec_2015, 
SUBPARTITION jan_2015, 
SUBPARTITION feb_2015, 
SUBPARTITION mar_2015, 
SUBPARTITION apr_2015, 
SUBPARTITION may_2015, 
SUBPARTITION jun_2015, 
SUBPARTITION jul_2015, 
SUBPARTITION aug_2015, 
SUBPARTITION sep_2015, 
SUBPARTITION oct_2015, 
SUBPARTITION nov_2015 
), 
PARTITION pmax VALUES LESS THAN MAXVALUE ( 
SUBPARTITION dec_max, 
SUBPARTITION jan_max, 
SUBPARTITION feb_max, 
SUBPARTITION mar_max, 
SUBPARTITION apr_max, 
SUBPARTITION may_max, 
SUBPARTITION jun_max, 
SUBPARTITION jul_max, 
SUBPARTITION aug_max, 
SUBPARTITION sep_max, 
SUBPARTITION oct_max, 
SUBPARTITION nov_max 
) 
); 

यह भाग्य का सबसे अच्छा मदद करता है उम्मीद।

Mysqlbinlog बिंदु में समय-वसूली उदाहरण के साथ खो दिया है MySQL डेटा की वसूली

Original post: http://anothermysqldba.blogspot.com/2014/11/recover-lost-mysql-data-with.html

बैकअप ... बैकअप ... बैकअप ... लेकिन निश्चित रूप से .. आप भी अक्सर अन्यथा वे बेकार हो सकता है उन लोगों के बैकअप की निगरानी और परीक्षण की जरूरत है। अपने MySQL होने binlogs निश्चित रूप से और साथ ही एक आपातकालीन स्थिति के बार में आप मदद कर सकते हैं सक्षम होना चाहिए। MySQL के binlogs अक्सर MySQL के प्रतिकृति के संबंध में संदर्भित कर रहे हैं, एक अच्छे कारण के लिए, वे डेटा (बदल कि प्रश्नों या घटनाओं के सभी स्टोर पंक्ति आधारितएक छोटे से अलग है, लेकिन यह एक उदाहरण है)। वे उपलब्ध कराने वसूली विकल्पों पर विचार जब binlogs सर्वर के प्रदर्शन पर बहुत कम प्रभाव पड़ता है। 


[anothermysqldba]> show variables like 'log_bin%'; 
+---------------------------------+--------------------------------------------+ 
| Variable_name | Value | 
+---------------------------------+--------------------------------------------+ 
| log_bin | ON | 
| log_bin_basename | /var/lib/mysql/binlogs/mysql-binlogs | 
| log_bin_index | /var/lib/mysql/binlogs/mysql-binlogs.index | 

show variables like 'binlog_format%'; 
+---------------+-------+ 
| Variable_name | Value | 
+---------------+-------+ 
| binlog_format | MIXED | 
+---------------+-------+ 

तो यह एक binlog से डाटा को ठीक हैं और वापस डेटाबेस के लिए इसे लागू करने के लिए mysqlbinlog का उपयोग करते हुए सिर्फ एक सरल उदाहरण है। 

पहले हम ढीला करने के लिए कुछ की जरूरत है। कुछ हमारे डेटाबेस को कुछ नहीं करना था, तो हम डाटा को ठीक करने में सक्षम होने की जरूरत है या हो सकता है कि यह सिर्फ किसी गलती से उबरने के लिए एक तरीका है। 


CREATE TABLE `table_w_rdata` ( 
`id` int(11) NOT NULL AUTO_INCREMENT, 
`somedata` varchar(50) CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL, 
`moredata` varchar(50) CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL, 
PRIMARY KEY (`id`) 
) ENGINE=InnoDB; 

हम यहाँ नाटक और हम डेवलपर्स / बहुत अच्छी तरह से संवाद स्थापित करने और / या उनके कोड की प्रतियां बचत नहीं कर रहे हैं कि DBAs है कि ग्रहण कर सकते हैं। 


delimiter // 
CREATE PROCEDURE populate_dummydata( IN rowsofdata INT ) 
BEGIN 

SET @A = 3; 
SET @B = 15 - @A; 
SET @C = 16; 
SET @D = 25 - @C; 

WHILE rowsofdata > 0 DO 
INSERT INTO table_w_rdata 
SELECT NULL, SUBSTR(md5(''),FLOOR( @A + (RAND() * @B ))) as somedata, SUBSTR(md5(''),FLOOR( @C + (RAND() * @D ))) AS moredata ; 
SET rowsofdata = rowsofdata - 1; 
END WHILE; 
END// 
delimiter ; 
call populate_dummydata(50); 

> SELECT NOW() \G 
*************************** 1. row *************************** 
NOW(): 2014-11-27 17:32:25 
1 row in set (0.00 sec) 

> SELECT * from table_w_rdata WHERE id > 45; 
+----+----------------------------+------------------+ 
| id | somedata | moredata | 
+----+----------------------------+------------------+ 
| 46 | b204e9800998ecf8427e | 0998ecf8427e | 
| 47 | d98f00b204e9800998ecf8427e | 8ecf8427e | 
| 48 | b204e9800998ecf8427e | 800998ecf8427e | 
| 49 | 98f00b204e9800998ecf8427e | e9800998ecf8427e | 
| 50 | 98f00b204e9800998ecf8427e | 998ecf8427e | 
+----+----------------------------+------------------+ 

एक प्रक्रिया बनाई गई है, जबकि इसे बाद में किसी और को गलत तरीके से किसी के द्वारा लिखा जाता है। 


DROP PROCEDURE IF EXISTS populate_dummydata ; 
delimiter // 
CREATE PROCEDURE populate_dummydata( IN rowsofdata INT ) 
BEGIN 

SET @A = 3; 
SET @B = 15 - @A; 
SET @C = 16; 
SET @D = 25 - @C; 

WHILE rowsofdata > 0 DO 
INSERT INTO table_w_rdata 
SELECT NULL, SUBSTR(md5(''),FLOOR( @C + (RAND() * @A ))) as somedata, SUBSTR(md5(''),FLOOR( @B + (RAND() * @D ))) AS moredata ; 
SET rowsofdata = rowsofdata - 1; 
END WHILE; 
END// 
delimiter ; 

call populate_dummydata(50); 
> SELECT NOW(); SELECT * from table_w_rdata WHERE id > 95; 
+---------------------+ 
| NOW() | 
+---------------------+ 
| 2014-11-27 17:36:28 | 
+---------------------+ 
1 row in set (0.00 sec) 

+-----+-------------------+---------------------+ 
| id | somedata | moredata | 
+-----+-------------------+---------------------+ 
| 96 | 4e9800998ecf8427e | 00998ecf8427e | 
| 97 | 9800998ecf8427e | 800998ecf8427e | 
| 98 | e9800998ecf8427e | 204e9800998ecf8427e | 
| 99 | e9800998ecf8427e | 4e9800998ecf8427e | 
| 100 | 9800998ecf8427e | 04e9800998ecf8427e | 
+-----+-------------------+---------------------+ 

टीम चाहता था जैसे प्रक्रिया की प्रतिस्थापित संस्करण यादृच्छिक मूल्यों नहीं पैदा कर रहा है। प्रक्रिया के मूल निर्माता सिर्फ निराशा से बाहर निकलें। तो क्या करें?यह के रूप में अच्छी तरह से बनाया गया था के बाद से थोड़ा सा समय अतीत है। हम गलत प्रक्रिया बिन लॉग्स के आसपास अभी भी कर रहे हैं बनाया है और हमारे लिए भाग्यशाली था जब डेटाबेस का नाम, दिनचर्या नाम और सामान्य समय सीमा पता है, इसलिए हम इसे पाने के लिए जा सकते हैं। 

हम सिर्फ एक चाहते आसपास के बाद से एक सामान्य देख ले जाना है बिंदु में समय-वसूली इस procedure.We की प्रक्रिया और पहले और बाद binlog में स्थिति को खोजने के लिए होता है। 


NOW(): 2014-11-27 19:46:17 
# mysqlbinlog --start-datetime=20141127173200 --stop-datetime=20141127173628 --database=anothermysqldba mysql-binlogs.000001 | more 

at 253053 
at 253564 

# mysql anothermysqldba --login-path =local -e "DROP PROCEDURE populate_dummydata"; 
# mysqlbinlog --start-position=253053 --stop-position=253564 --database=anothermysqldba mysql-binlogs.000001 | mysql --login-path =local anothermysqldba 


> SHOW CREATE PROCEDURE populate_dummydata\G 
*************************** 1. row *************************** 
Procedure: populate_dummydata 
sql_mode: NO_AUTO_VALUE_ON_ZERO,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION 
Create Procedure: CREATE DEFINER=`root`@`localhost` PROCEDURE `populate_dummydata`( IN rowsofdata INT ) 
BEGIN 

SET @A = 3; 
SET @B = 15 - @A; 
SET @C = 16; 
SET @D = 25 - @C; 

WHILE rowsofdata > 0 DO 
INSERT INTO table_w_rdata 
SELECT NULL, SUBSTR(md5(''),FLOOR( @A + (RAND() * @B ))) as somedata, SUBSTR(md5(''),FLOOR( @C + (RAND() * @D ))) AS moredata ; 
SET rowsofdata = rowsofdata - 1; 
END WHILE; 
END 
character_set_client: utf8 
collation_connection: utf8_general_ci 
Database Collation: latin1_swedish_ci 
1 row in set (0.00 sec) 

NOW(): 2014-11-27 19:51:03 
> call populate_dummydata(50); 
> SELECT * from table_w_rdata WHERE id > 145; 
+-----+-----------------------------+------------------+ 
| id | somedata | moredata | 
+-----+-----------------------------+------------------+ 
| 146 | 98f00b204e9800998ecf8427e | 800998ecf8427e | 
| 147 | cd98f00b204e9800998ecf8427e | 800998ecf8427e | 
| 148 | 204e9800998ecf8427e | 98ecf8427e | 
| 149 | d98f00b204e9800998ecf8427e | e9800998ecf8427e | 
| 150 | 204e9800998ecf8427e | 9800998ecf8427e | 
+-----+-----------------------------+------------------+ 

हम के माध्यम से बाइनरी प्रवेश से हमारे प्रक्रिया बरामद बिंदु में समय-वसूली । 
यह एक सरल उदाहरण है, लेकिन इसे आप आगे बढ़ने का उपयोग कर सकते हैं उपकरणों का एक उदाहरण है। 

Binlogs इतना मूल्यवान हैं यही कारण है। 

सहायक यूआरएल: 

• http://dev.mysql.com/doc/refman/5.6/en/binary-log.html
• http://dev.mysql.com/doc/refman/5.6/en/point-in-time-recovery.html