我想按以下顺序对以下数据项进行排序（数字1-12）：
1个 2 3 4 5 6 7 8 9 10 11 12
但是，我的查询-使用order by xxxxx asc按其他所有字母开头的数字排序：
1个 10 11 12 2 3 4 5 6 7 8 9
有什么技巧可以使其更正确地排序吗？
此外，为了充分公开，这可以是字母和数字的组合（尽管现在不是），例如：
A1 534克 G46A 100B 100A 100JE
等等....
谢谢！
更新：人们要求查询
select * from table order by name asc
Answers:
人们使用不同的技巧来做到这一点。我用Google搜索了一下，发现每个结果都有不同的技巧。看看他们：
编辑：
我刚刚为以后的访问者添加了每个链接的代码。
给定输入
1A 1a 10A 9B 21C 1C 1D
预期产量
1A 1C 1D 1a 9B 10A 21C
询问
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
给定输入
表：sorting_test -------------------------- ------------- | 字母数字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进行一些简单的检查，并对结果进行排序。
(name = '-') boolDash输入select语句来使它起作用。但是我通过name = '-'直接按语句排序使它起作用。
只是这样做：
SELECT * FROM table ORDER BY column `name`+0 ASC
附加+0表示：
0、10、11、2、3、4
变成：
0、2、3、4、10、11
information_schema的只是估计值，它们并未完全汇总。
我恨这个，但是这会工作
order by lpad(name, 10, 0) <-- assuming maximum string length is 10
<-- you can adjust to a bigger length if you want to
USA-0027-1,USA-0027-2,USA-0027-10,USA-0027-12
这适用于数据类型：Data1，Data2，Data3 ......，Data21。表示“数据”字符串在所有行中都是通用的。
对于ORDER BY ASC，它将完美排序；对于ORDER BY DESC，不合适。
SELECT * FROM table_name ORDER BY LENGTH(column_name), column_name ASC;
ALTER TABLE？
这应该对字母数字字段进行排序，例如：1 /仅数字，order by 1,2,3,4,5,6,7,8,9,10,11等等... 2 /然后对文本字段进行排序，例如：1foo, 2bar, aaa11aa, aaa22aa, b5452etc ...
SELECT MyField
FROM MyTable
order by
IF( MyField REGEXP '^-?[0-9]+$' = 0,
9999999999 ,
CAST(MyField AS DECIMAL)
), MyField
该查询检查数据是否为数字，如果未将其置于9999999999，则首先在此列上排序，然后对带有文本的数据进行排序
祝好运！
我没有尝试编写一些函数并减慢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 length(actual_project_name),actual_project_name,
SUBSTRING_INDEX(actual_project_name,'-',1) as aaaaaa,
SUBSTRING_INDEX(actual_project_name, '-', -1) as actual_project_number,
concat(SUBSTRING_INDEX(actual_project_name,'-',1),SUBSTRING_INDEX(actual_project_name, '-', -1)) as a
FROM ctts.test22
order by
SUBSTRING_INDEX(actual_project_name,'-',1) asc,cast(SUBSTRING_INDEX(actual_project_name, '-', -1) as unsigned) asc
MySQL ORDER BY以正确的顺序对字母数字进行排序
例：
SELECT `alphanumericCol` FROM `tableName` ORDER BY
SUBSTR(`alphanumericCol` FROM 1 FOR 1),
LPAD(lower(`alphanumericCol`), 10,0) ASC
输出：
1
2
11
21
100
101
102
104
S-104A
S-105
S-107
S-111
SELECT s.id，s.name，LENGTH（s.name）len，ASCII（s.name）ASCCCI FROM table_name s ORDER BY ASCCCI，len，NAME ASC;
试试这个按订单排序
SELECT * FROM testdata ORDER BY LENGHT(name) DESC, name DESC