phpmyadmin - MySQL पुनर्प्रकाश 0 पंक्तियों को प्रभावित करता है, लेकिन जहां...9 की तरह लौटता है 90




(8)

मुझे लगता है कि अद्यतन PhpMyAdmin के भीतर से, लेकिन एक क्लाइंट से नहीं हुआ? यदि हां तो यह सिर्फ भिन्न लोकेल सेटिंग्स है

कुछ कारणों से PhpMyAdmin का उपयोग करते समय 90 पंक्तियों को चलाते समय:

SELECT COUNT(*) 
FROM le_wp_posts 
WHERE post_content LIKE '%Â%'

लेकिन निम्नलिखित केवल 3 पंक्तियाँ अद्यतन करें:

UPDATE le_wp_posts 
SET post_content = REPLACE(post_content, 'Â', '') 
WHERE post_content LIKE '%Â%'

मैंने यह भी UPDATE स्टेटमेंट में WHERE क्लॉज को हटाने की कोशिश की है। क्या कोई स्पष्ट कारण है कि मैं इस मुद्दे को देख रहा हूं? या कारणों की जांच के लिए मैं आगे क्या कदम उठा सकता हूं? मेरा एसक्यूएल सबसे अच्छा नहीं है


--you just need to put N before string pattern too (if you want look for unicode char)*/
Update le_wp_posts
Set post_content=REPLACE(post_content,N'Â','')
where post_content like '%Â%'

यह पसंद केस-असंवेदनशील है, लेकिन बायपास करने के लिए, निम्न क्वेरी का उपयोग करने के लिए केस-संवेदना बदलें है:

UPDATE le_wp_posts 
SET post_content = REPLACE(LOWER(post_content), LOWER('Â'), '') 
WHERE post_content LIKE '%Â%'

या यदि आप चाहते हैं कि अंतिम परिणाम निम्न मामला न हो:

UPDATE le_wp_posts 
SET post_content = REPLACE(REPLACE(post_content, LOWER('Â'), ''), 'Â', '') 
WHERE post_content LIKE '%Â%'

यदि आपके पास "आईडी" है तो आप इस तरह से कोशिश कर सकते हैं:

UPDATE le_wp_posts 
SET post_content = REPLACE(post_content, 'Â', '') 
WHERE Id IN ( SELECT * 
             FROM (
            SELECT Id 
            FROM le_wp_posts 
            WHERE post_content LIKE '%Â%'
                 ) as A
            )

मैंने निम्नलिखित परीक्षण किया ...

1) कुछ डेटा के साथ तालिका बनाएं:

create table test(col varchar(10));

insert into test values ('abc'), ('dbe');

2) अपने समान फ़िल्टर (लेकिन अलग-अलग वर्ण) का उपयोग करके पंक्तियों की संख्या चुनें:

select count(*)
from test
where col like '%B%' -- note the uppercase
;

निम्नलिखित परिणाम प्राप्त हुए:

+----------+                                                                                                                                                                
| count(*) |                                                                                                                                                                
+----------+                                                                                                                                                                
|        2 |                                                                                                                                                                
+----------+ 

1 row in set

3) आपके अपडेट की कोशिश की:

update test 
set col = replace(col, 'B', '') -- note the uppercase
where col like '%B%' -- note the uppercase
;

और यह परिणाम मिला:

Query OK, 0 rows affected (0.01 sec)                                                                                                                                        
Rows matched: 2  Changed: 0  Warnings: 0

मेरे मामले में, एक डिफ़ॉल्ट वर्ण सेट और मिलान जहां तालिका निर्माण पर इस्तेमाल किया गया था। डिफ़ॉल्ट वर्ण सेट 'latin1' था और मिलान 'latin1_swedish_ci' कोलेशन के अंत में ci नोट करें .... इसका मतलब है कि केस असंवेदनशील है । इसलिए, LIKE फिल्टर ने एक केस असंवेदनशील खोज की, 2 पंक्तियों को मिला, लेकिन REPLACE समारोह, जैसा कि दस्तावेज़ीकरण पर देखा जा सकता है, मामला संवेदनशील होता है । शायद, जैसा कि मेरे मामले में, अद्यतन में चयन के रूप में पंक्तियों की एक ही संख्या में पाया गया, लेकिन REPLACE पर मामला प्रतिबंध के कारण कम डेटा अपडेट किया गया।

यदि यह आपकी समस्या है, तो क्या आप दो अपडेट नहीं चला सकते हैं, एक अपरकेस केस के लिए और लोअरकेस के लिए? मैं एक अपडेट पर एक समाधान विकसित करने का प्रयास करूंगा ...

REPLACE(str, from_str, to_str) फ़ंक्शन के बारे में दस्तावेज़ :

स्ट्रिंग स्ट्रिंग strings को return_str द्वारा स्ट्रिंग की सभी आवृत्तियों को स्थानांतरित करता है। Replace_str के लिए खोज करते समय एक केस-संवेदी मिलान करता है

LIKE ऑपरेटर के बारे में दस्तावेज़ :

निम्नलिखित दो बयानों का वर्णन है कि स्ट्रिंग तुलना केस के मामले में संवेदनशील नहीं है जब तक कि कोई एक ऑपरेंड मामला संवेदनशील नहीं होता है (केस-संवेदी कोलेशन का उपयोग करता है या बाइनरी स्ट्रिंग है):

पहला उदाहरण:

mysql> SELECT 'abc' LIKE 'ABC';
        -> 1

दूसरा उदाहरण:

mysql> SELECT 'abc' LIKE _latin1 'ABC' COLLATE latin1_general_cs;
        -> 0

कोलेशन के अंत में cs नोट करें। इसका अर्थ केस संवेदनशील होता है


क्या आप निम्न के रूप में JOIN उपयोग करने की कोशिश कर सकते हैं:

UPDATE le_wp_posts l
INNER JOIN (SELECT t.post_content  
            FROM le_wp_posts t 
            WHERE t.post_content LIKE '%Â%') t ON l.post_content = t.post_content
SET l.post_content = REPLACE(l.post_content, 'Â', '')

यदि आप C2A3 एन्कोडेड £ ( C2A3 , utf8 के रूप में माना जाता है) C2A3 और इसे एक लैटिन 1 कॉलम में संग्रहीत करते हैं, जब आप इसे वापस पढ़ते हैं, तो आपको £ ( C2A3 , C2A3 माना जाता है) मिलता है। को हटाने के बारे में 32 वर्णों के लिए काम करेगा, लेकिन कई अन्य वर्णों के लिए विफल हो जाएगा। और यह टेबल की मरम्मत के लिए कठिन बना देगा!

चलो एक उदाहरण को देखने के लिए जो आपने स्टोर करने की कोशिश की थी, तालिका में समाप्त होने वाले HEX के साथ। साथ ही, मेरे संदेह की पुष्टि करने के लिए SHOW CREATE TABLE को SHOW CREATE TABLE कि यह लक्ष्य latin1

यह HEX डिबगिंग तकनीक की चर्चा करता है और यह "बेस्ट प्रैक्टिस" पर चर्चा करता है, जिसमें कनेक्शन के दौरान घोषित करना शामिल है, कि वास्तव में आपके पास यूटी 8 है, लैटिन 1 नहीं है। और इसके बारे में "मोजिबाके" के बारे में बात करती है, जिसमें एक उदाहरण के ñ बदल जाता है, एक गन्दा संभावना बना देता है

आपके लक्षण के साथ वर्ण सेट बेमेल के साथ संगत है।


एक तरीका है कि अगर मैं स्वत: उत्पन्न आईडी है तो मॉड्यूल ऑपरेटर '%' का उपयोग करना बहुत अच्छा लगता है। उदाहरण के लिए, यदि आपको 70,000 से 10,000 यादृच्छिक रिकॉर्ड की आवश्यकता है, तो आप यह कहकर इसे सरल बना सकते हैं कि आपको हर 7 पंक्तियों में से 1 की आवश्यकता है। इस क्वेरी में इसे सरल बनाया जा सकता है:

SELECT * FROM 
    table 
WHERE 
    id % 
    FLOOR(
        (SELECT count(1) FROM table) 
        / 10000
    ) = 0;

यदि कुल उपलब्धियों से लक्ष्य पंक्तियों को विभाजित करने का नतीजा पूर्णांक नहीं है, तो आपके पास जो कुछ भी पूछा गया है उससे आपके पास कुछ अतिरिक्त पंक्तियां होंगी, इसलिए आपको इस तरह के परिणाम सेट को ट्रिम करने में सहायता के लिए एक LIMIT क्लॉज जोड़ना चाहिए:

SELECT * FROM 
    table 
WHERE 
    id % 
    FLOOR(
        (SELECT count(1) FROM table) 
        / 10000
    ) = 0
LIMIT 10000;

इसके लिए एक पूर्ण स्कैन की आवश्यकता होती है, लेकिन यह रैंड द्वारा ऑर्डर से तेज है, और मेरी राय में इस धागे में उल्लिखित अन्य विकल्पों की तुलना में समझने में आसान है। इसके अलावा यदि डीबी को लिखने वाली प्रणाली बैचों में पंक्तियों के सेट बनाती है तो आपको उम्मीद है कि आप इस तरह के एक यादृच्छिक परिणाम नहीं प्राप्त कर सकते हैं।





mysql sql phpmyadmin