MySQL

Question

में स्ट्रिंग वर्णों को सॉर्ट करना मेरे पास एक mysql तालिका में एक कॉलम (वर्कर (255)) है, इसे "शब्द" कहें। एक चुनिंदा क्वेरी कैसे लिखें जो मुझे स्ट्रिंग में वर्णों द्वारा क्रमबद्ध इस कॉलम में मान देता है?

उदाहरण के लिए, यदि किसी एक रिकॉर्ड में "पृथ्वी" शब्द था तो मुझे सभी पंक्तियों के लिए "aehrt" और इसी तरह वापस करना चाहिए। क्या एक प्रश्न में ऐसा करने का कोई तरीका है?

Answer 1

शायद

अत्यधिक अक्षम है, लेकिन उपयोगकर्ता परिभाषित कार्यों के लिए किसी भी आवश्यकता के बिना:

SELECT GROUP_CONCAT(LETTER SEPARATOR '') AS ReOrderedLetters 
    FROM (SELECT 'A' as LETTER FROM <table> WHERE UPPER(`name`) like '%A%' 
     UNION ALL 
     SELECT 'B' as LETTER FROM <table> WHERE UPPER(`name`) like '%B%' 
     UNION ALL 
     SELECT 'C' as LETTER FROM <table> WHERE UPPER(`name`) like '%C%' 
     UNION ALL 
     SELECT 'D' as LETTER FROM <table> WHERE UPPER(`name`) like '%D%' 
     ... 
     UNION ALL 
     SELECT 'Y' as LETTER FROM <table> WHERE UPPER(`name`) like '%Y%' 
     UNION ALL 
     SELECT 'Z' as LETTER FROM <table> WHERE UPPER(`name`) like '%Z%' 
     ) alpha 

संपादित

मैं सोने से पहले एक बेहतर विकल्प के साथ आने के लिए था, नहीं तो मैं था कभी सोना नहीं है; तो यहां एक बहुत साफ और अधिक कुशल विकल्प है।

मैंने अक्षर (1) के एक कॉलम के साथ अक्षर नामक एक तालिका बनाई जिसे पत्र कहा जाता है;

select U.`name`, 
     GROUP_CONCAT(L.`letter` 
      ORDER BY L.`letter` ASC 
      SEPARATOR '') AS ReOrderedLetters 
    FROM `users` U 
    LEFT JOIN `letters` L ON POSITION(L.`letter` IN UPPER(U.`name`)) > 0 
GROUP BY U.`name` 

Answer 2

ठीक है बच्चे: तो जेड

CREATE TABLE IF NOT EXISTS `letters` (
    `letter` varchar(1) NOT NULL, 
    PRIMARY KEY (`letter`) 
) ENGINE=InnoDB DEFAULT CHARSET=utf8; 

INSERT INTO `letters` (`letter`) VALUES 
('A'),('B'),('C'),('D'),('E'),('F'),('G'),('H'),('I'),('J'),('K'),('L'),('M'), 
('N'),('O'),('P'),('Q'),('R'),('S'),('T'),('U'),('V'),('W'),('X'),('Y'),('Z'); 

तो को पत्र एक साथ उस तालिका आबादी। टी-एसक्यूएल के लिए यहां एक बुलबुले समारोह है। आप स्वयं को mysql में परिवर्तित कर सकते हैं। यह पता चला है कि SQL सर्वर वास्तव में रिकर्सिव फ़ंक्शंस पसंद नहीं करता है, लेकिन यह वास्तव में बहुत तेज़ी से भाग गया।

Create Function bubblesort(@In varchar(255)) 
Returns varchar(255) 
AS 
BEGIN 
    Declare @Answer varchar(255) 
    Declare @swapped bit 
    Declare @Counter int 

    Set @Answer = @In; 
    --only need to sort strings longer than 1 
    if len(@Answer) > 1 
    BEGIN 
     While 1=1 
     BEGIN 
      Set @Counter = 1; 
      Set @swapped = 0; 
      While @Counter <= len(@Answer) - 1 
      BEGIN 
       If substring(@Answer, @Counter, 1) > substring(@Answer, @Counter + 1, 1) 
        BEGIN 
        --swap 
        Set @swapped = 1; 
        Set @Answer = Stuff(@Answer, @Counter, 2, reverse(substring(@Answer, @Counter, 2))); 
        END; 
       Set @Counter = @Counter + 1; 
      END; 
      if @swapped = 0 
      BREAK; 
     END; 
    END; 
    Return @Answer; 
END; 
go 

परिणाम

Select ltrim(myfield) from mytable; 

Answer 3

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

delimiter $$ 
drop procedure if exists sort_letters$$ 
create procedure sort_letters() 
begin 
     declare done int default 0; 
     declare word varchar(256); 
     declare cur1 cursor for select i from a; 
     declare continue handler for not found set done = 1; 
     drop temporary table if exists temp; 
     create temporary table temp (id int, letter char); 
     set @wordcount = 0; 
     open cur1; 
     repeat 
       fetch cur1 into word; 
       if not done then 
         set @counter = 0; 
         set @len = length(word); 
         while (@counter <= @len) do 
           insert into temp values 
           (@wordcount, substring(word,@counter,1)); 
           set @counter = @counter + 1; 
         end while; 
         set @wordcount = @wordcount + 1; 
       end if; 
     until done end repeat; 
     close cur1; 
     select group_concat(letter order by letter separator '') 
     from temp group by id; 
end$$ 


mysql> desc a; 
+-------+--------------+------+-----+---------+-------+ 
| Field | Type   | Null | Key | Default | Extra | 
+-------+--------------+------+-----+---------+-------+ 
| i  | varchar(256) | YES |  | NULL |  | 
+-------+--------------+------+-----+---------+-------+ 
1 row in set (0.04 sec) 

mysql> select * from a; 
+-------+ 
| i  | 
+-------+ 
| earth | 
| sand | 
| fire | 
+-------+ 
3 rows in set (0.00 sec) 

mysql> call sort_letters(); 
+---------------------------------------------------+ 
| group_concat(letter order by letter separator '') | 
+---------------------------------------------------+ 
| aehrt            | 
| adns            | 
| efir            | 
+---------------------------------------------------+ 
3 rows in set (0.00 sec) 

Answer 4

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

SELECT 
CONCAT(
REPEAT('a',SIGN(POSITION('a' IN word_col))), 
REPEAT('b',SIGN(POSITION('b' IN word_col))), 
REPEAT('c',SIGN(POSITION('c' IN word_col))), 
REPEAT('d',SIGN(POSITION('d' IN word_col))), 
REPEAT('e',SIGN(POSITION('e' IN word_col))), 
REPEAT('f',SIGN(POSITION('f' IN word_col))), 
... 
REPEAT('Z',SIGN(POSITION('Z' IN word_col))) 
) 
FROM 
word 

जाहिर है, "प्रकार" कैसे concat संरचित है पर आधारित है।