दिलचस्प पोस्ट
कैसे एक स्ट्रिंग एक वैध HTTP यूआरएल है कि कैसे जांच करने के लिए? बाश: क्या स्ट्रिंग एक पूर्णांक के रूप में मान्य है? वास्तव में किसी भी कंप्यूटर को विशिष्ट रूप से पहचानने का कोई तरीका क्या है? JQuery का उपयोग किए बिना जावास्क्रिप्ट ईवेंट रजिस्टर कैसे चेक बॉक्स राज्य सहित MVC में नियंत्रक के लिए IEnumerable सूची पारित करने के लिए? रेलिंग 4 link_to आरंभिक ट्यूटोरियल में काम नहीं कर रहा है एएसपी.नेट के साथ .json फ़ाइल डाउनलोड करने की अनुमति कैसे दें सूचियों की सूची के सभी संयोजन PHP में रेफरर निर्धारित करना विंडोज 7, update.packages समस्या: "अस्थायी स्थापना को स्थानांतरित करने में असमर्थ"? AVAudioplayer का उपयोग कर पृष्ठभूमि में संगीत चलाएं विशिष्ट आयडी सेट करने के लिए प्रोग्राममैटिक अवलोकन JQuery का उपयोग करते हुए आईफ्रेम के अंदर HTML प्राप्त करें 'प्रिंट' स्टेटमेंट जोड़कर डीबगिंग करने का उचित नाम क्या है मैं मौजूदा निष्पादित फाइल का पथ पायथन में कैसे प्राप्त करूं?

MySQL 'ऑर्डर बाय' – अल्फ़ान्यूमेरिक को सही ढंग से सॉर्ट करना

मैं निम्नलिखित डेटा वस्तुओं को क्रम में प्रस्तुत करने के लिए सॉर्ट करना चाहता हूं (नंबर 1-12):

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 1 1
 12 

हालांकि, मेरी क्वेरी – order by xxxxx asc का उपयोग पहले सभी अंकों से ऊपर:

 1
 10
 1 1
 12
 2
 3
 4
 5
 6
 7
 8
 9 

किसी भी चाल इसे बेहतर ढंग से बनाने के लिए?

इसके अलावा, पूर्ण प्रकटीकरण के हित में, यह अक्षर और संख्याओं का मिश्रण हो सकता है (यद्यपि अभी नहीं है), IE:

 ए 1
 534G
 G46A
 100B
 100A
 100JE

आदि….

धन्यवाद!

अपडेट: लोग क्वेरी के लिए पूछ रहे हैं

 select * from table order by name asc 

वेब के समाधान से एकत्रित समाधान "MySQL 'ऑर्डर बाय' – अल्फ़ान्यूमेरिक को सही ढंग से सॉर्ट करना"

ऐसा करने के लिए लोग विभिन्न युक्तियों का उपयोग करते हैं मैं Googled और कुछ परिणाम प्रत्येक अलग चाल का पालन पता उन पर एक नज़र डालें:

  • MySQL में अल्फ़ा न्यूमेरिक सॉर्टिंग
  • माईएसक्यूएल में प्राकृतिक वर्गीकरण
  • अल्फ़ान्यूमेरिक मानों के साथ मिश्रित संख्यात्मक मानों को क्रमबद्ध करना
  • mySQL प्राकृतिक सॉर्ट
  • प्राकृतिक क्रमबद्ध MySQL में

संपादित करें:

मैंने भविष्य के आगंतुकों के लिए बस प्रत्येक लिंक का कोड जोड़ा है

MySQL में अल्फ़ा न्यूमेरिक सॉर्टिंग

इनपुट को देखते हुए

  1 ए 1 ए 10 ए 9 बी 21 सी 1 सी 1 डी 

अपेक्षित उत्पादन

  1 ए 1 सी 1 डी 1 ए 9 बी 10 ए 21 सी 

सवाल

 Bin Way =================================== SELECT tbl_column, BIN(tbl_column) AS binray_not_needed_column FROM db_table ORDER BY binray_not_needed_column ASC , tbl_column ASC ----------------------- Cast Way =================================== SELECT tbl_column, CAST(tbl_column as SIGNED) AS casted_column FROM db_table ORDER BY casted_column ASC , tbl_column ASC 

माईएसक्यूएल में प्राकृतिक वर्गीकरण

इनपुट को देखते हुए

  तालिका: सॉर्टिंग_स्टेस्ट
  -------------------------- -------------
 |  अल्फ़ान्यूमेरिक VARCHAR (75) |  पूर्णांक INT |
  -------------------------- -------------
 |  test1 |  1 |
 |  test12 |  2 |
 |  test13 |  3 |
 |  test2 |  4 |
 |  test3 |  5 |
  -------------------------- -------------

अपेक्षित उत्पादन

  -------------------------- ------------- | alphanumeric VARCHAR(75) | integer INT | -------------------------- ------------- | test1 | 1 | | test2 | 4 | | test3 | 5 | | test12 | 2 | | test13 | 3 | -------------------------- ------------- 

सवाल

 SELECT alphanumeric, integer FROM sorting_test ORDER BY LENGTH(alphanumeric), alphanumeric 

अल्फ़ान्यूमेरिक मानों के साथ मिश्रित संख्यात्मक मानों को क्रमबद्ध करना

इनपुट को देखते हुए

 2a, 12, 5b, 5a, 10, 11, 1, 4b 

अपेक्षित उत्पादन

 1, 2a, 4b, 5a, 5b, 10, 11, 12 

सवाल

 SELECT version FROM version_sorting ORDER BY CAST(version AS UNSIGNED), version; 

उम्मीद है की यह मदद करेगा

मुझे पता है कि यह पोस्ट बंद है, लेकिन मुझे लगता है कि मेरा रास्ता कुछ लोगों को मदद कर सकता है। तो यह है:

मेरा डेटासेट बहुत समान है, लेकिन थोड़ा और जटिल है इसकी संख्या, अल्फ़ान्यूमेरिक डेटा है:

 1 2 Chair 3 0 4 5 - Table 10 13 19 Windows 99 102 Dog 

मैं '-' प्रतीक पहले करना चाहता हूं, फिर संख्याएं, फिर टेक्स्ट

तो मैं इस तरह जाता हूं:

 SELECT name, (name = '-') boolDash, (name = '0') boolZero, (name+0 > 0) boolNum FROM table ORDER BY boolDash DESC, boolZero DESC, boolNum DESC, (name+0), name 

परिणाम कुछ होना चाहिए:

 - 0 1 2 3 4 5 10 13 99 102 Chair Dog Table Windows 

संपूर्ण विचार SELECT में कुछ सरल जांच कर रहा है और परिणाम के साथ सॉर्टिंग कर रहा है।

बस ऐसा करें:

 SELECT * FROM table ORDER BY column `name`+0 ASC 

+0 जोड़कर इसका अर्थ होगा कि:

0, 10, 11, 2, 3, 4

हो जाता है:

0, 2, 3, 4, 10, 11

मुझे यह नफरत है, लेकिन यह काम करेगा

 order by lpad(name, 10, 0) <-- assuming maximum string length is 10 <-- you can adjust to a bigger length if you want to 

मेरे साथ अच्छे परिणाम थे

 SELECT alphanumeric, integer FROM sorting_test ORDER BY CAST(alphanumeric AS UNSIGNED), alphanumeric ASC 

इस प्रकार के प्रश्न को पहले से पूछा गया है।

आप जिस प्रकार की सॉर्टिंग कर रहे हैं उसे "प्राकृतिक सॉर्टिंग" कहा जाता है जिस डेटा पर आप सॉर्ट करना चाहते हैं वह अल्फ़ान्यूमेरिक है सॉर्टिंग के लिए एक नया कॉलम बनाना बेहतर होगा।

अधिक सहायता के लिए प्राकृतिक-सॉर्ट-इन-मायसाइक्ल की जांच करें

इस तरह अल्फ़ान्यूमेरिक फ़ील्ड को सॉर्ट करना चाहिए: 1 / नंबर केवल, order by 1,2,3,4,5,6,7,8,9,10,11 आदि … 2 / फिर फ़ील्ड के साथ पाठ जैसे: 1foo, 2bar, aaa11aa, aaa22aa, b5452 आदि …

 SELECT MyField FROM MyTable order by IF( MyField REGEXP '^-?[0-9]+$' = 0, 9999999999 , CAST(MyField AS DECIMAL) ), MyField 

क्वेरी एक संख्या है, अगर यह 99 99 99 99 99 99 में नहीं है, तो यह जांचें कि पहले इस कॉलम पर ऑर्डर करें, फिर पाठ के साथ डेटा पर ऑर्डर करें

सौभाग्य!

एएससीसीसीआई, लेनन, एएससी द्वारा टेबल-एनाम के आदेश से एएससीसीआई का चयन एस.आईडी, एस.एन.एन., एलएएनजीटीएच (एस.एन.एन.) लैन, एएससीआईआई (एस.एन.

कुछ फ़ंक्शन लिखने और SELECT क्वेरी को धीमा करने की कोशिश करने के बजाय, मैंने ऐसा करने का एक और तरीका सोचा …

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

String nsFieldVal = new NaturalSortString(getFieldValue(), 4).toString()

 The above means: - Create a NaturalSortString for the String returned from getFieldValue() - Allow up to 4 bytes to store each character or number (4 bytes = ffff = 65535) | field(32) | nsfield(161) | a1 300610001 

String sortString = new NaturalSortString(getString(), 4).toString()

 import StringUtils; /** * Creates a string that allows natural sorting in a SQL database * eg, 0 1 1a 2 3 3a 10 100 a a1 a1a1 b */ public class NaturalSortString { private String inStr; private int byteSize; private StringBuilder out = new StringBuilder(); /** * A byte stores the hex value (0 to f) of a letter or number. * Since a letter is two bytes, the minimum byteSize is 2. * * 2 bytes = 00 - ff (max number is 255) * 3 bytes = 000 - fff (max number is 4095) * 4 bytes = 0000 - ffff (max number is 65535) * * For example: * dog123 = 64,6F,67,7B and thus byteSize >= 2. * dog280 = 64,6F,67,118 and thus byteSize >= 3. * * For example: * The String, "There are 1000000 spots on a dalmatian" would require a byteSize that can * store the number '1000000' which in hex is 'f4240' and thus the byteSize must be at least 5 * * The dbColumn size to store the NaturalSortString is calculated as: * > originalStringColumnSize x byteSize + 1 * The extra '1' is a marker for String type - Letter, Number, Symbol * Thus, if the originalStringColumn is varchar(32) and the byteSize is 5: * > NaturalSortStringColumnSize = 32 x 5 + 1 = varchar(161) * * The byteSize must be the same for all NaturalSortStrings created in the same table. * If you need to change the byteSize (for instance, to accommodate larger numbers), you will * need to recalculate the NaturalSortString for each existing row using the new byteSize. * * @param str String to create a natural sort string from * @param byteSize Per character storage byte size (minimum 2) * @throws Exception See the error description thrown */ public NaturalSortString(String str, int byteSize) throws Exception { if (str == null || str.isEmpty()) return; this.inStr = str; this.byteSize = Math.max(2, byteSize); // minimum of 2 bytes to hold a character setStringType(); iterateString(); } private void setStringType() { char firstchar = inStr.toLowerCase().subSequence(0, 1).charAt(0); if (Character.isLetter(firstchar)) // letters third out.append(3); else if (Character.isDigit(firstchar)) // numbers second out.append(2); else // non-alphanumeric first out.append(1); } private void iterateString() throws Exception { StringBuilder n = new StringBuilder(); for (char c : inStr.toLowerCase().toCharArray()) { // lowercase for CASE INSENSITIVE sorting if (Character.isDigit(c)) { // group numbers n.append(c); continue; } if (n.length() > 0) { addInteger(n.toString()); n = new StringBuilder(); } addCharacter(c); } if (n.length() > 0) { addInteger(n.toString()); } } private void addInteger(String s) throws Exception { int i = Integer.parseInt(s); if (i >= (Math.pow(16, byteSize))) throw new Exception("naturalsort_bytesize_exceeded"); out.append(StringUtils.padLeft(Integer.toHexString(i), byteSize)); } private void addCharacter(char c) { //TODO: Add rest of accented characters if (c >= 224 && c <= 229) // set accented a to a c = 'a'; else if (c >= 232 && c <= 235) // set accented e to e c = 'e'; else if (c >= 236 && c <= 239) // set accented i to i c = 'i'; else if (c >= 242 && c <= 246) // set accented o to o c = 'o'; else if (c >= 249 && c <= 252) // set accented u to u c = 'u'; else if (c >= 253 && c <= 255) // set accented y to y c = 'y'; out.append(StringUtils.padLeft(Integer.toHexString(c), byteSize)); } @Override public String toString() { return out.toString(); } } 

पूर्णता के लिए, नीचे StringUtils.padLeft विधि है:

 public static String padLeft(String s, int n) { if (n - s.length() == 0) return s; return String.format("%0" + (n - s.length()) + "d%s", 0, s); } 

नतीजा निम्नलिखित की तरह बाहर आना चाहिए

 -1 -a 0 1 1.0 1.01 1.1.1 1a 1b 9 10 10a 10ab 11 12 12abcd 100 a a1a1 a1a2 a-1 a-2 áviacion b c1 c2 c12 c100 d d1.1.1 e 

मुझे लगता है कि आपको स्तंभ का डेटाटाइप टेक्स्ट या कुछ और है जो ठीक तरह से सॉर्ट नहीं किया गया है इसे इंट, बिंटिंट, संख्यात्मक प्रकार की तरह फ्लोट में परिवर्तित करें ताकि यह ठीक से कार्य करे …

 SELECT * FROM table ORDER BY column name ASC