没有在 mysql 中修剪的 LPAD

Question

I am trying to find a way to add 0 at the beginning of an ID without trimming it :

I am currently using LPAD(id,4,"0") witch works fine until 9999

• Request : SELECT LPAD(12345,4,"0");
• Excepted result : 12345
• Result : 1234

I am Looking for a Request who does LPAD(id, MAX(LENGTH(id),4), "0")

I found SELECT IF(LENGTH(12345)>4, 12345, LPAD(12345, 4, "0")); but i would prefer if the 4 was in a single place (to make it easier use it elsewhere).

• Is there a build-in function that does what i'm looking For ?
• Or is there an alternative to the function MAX() that would work in that situation ?
• Or should I stick with the IF(LENGTH) solution and it's drawbacks ?

Edit :

ZEROFILL doesn't fit my needs because I also need the id without 0 s. I mainly use the ID without the LPAD() , but when I do, I use it with a prefix : CONCAT("PFX", LPAD(id,4,"0"))

Thanks for your Help

PS: please tell me if i do anything wrong, it's my first time asking here.

Answer 1

You can cat the length of a int field and also set zerofill like this:

CREATE TABLE `num` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `Numbers` int(5) unsigned zerofill DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Insert values:

INSERT INTO `num` (`id`, `Numbers`)
VALUES
    (1, 1),
    (2, 22),
    (3, 123456);

See the result:

MariaDB []> select * from num;
+----+---------+
| id | Numbers |
+----+---------+
|  1 |   00001 |
|  2 |   00022 |
|  3 |  123456 |
+----+---------+
3 rows in set (0.000 sec)

MariaDB []>

without zerofill you can calc it like:

SELECT 
  id,
  SUBSTRING( CONCAT('000000',Numbers),- GREATEST(LENGTH(Numbers),5))
FROM num;

Result:

MariaDB []>     SELECT
    ->       id,
    ->       SUBSTRING( CONCAT('000000',Numbers),- GREATEST(LENGTH(Numbers),5))
    ->     FROM num;
+----+--------------------------------------------------------------------+
| id | SUBSTRING( CONCAT('000000',Numbers),- GREATEST(LENGTH(Numbers),5)) |
+----+--------------------------------------------------------------------+
|  1 | 00001                                                              |
|  2 | 00022                                                              |
|  3 | 123456                                                             |
+----+--------------------------------------------------------------------+
3 rows in set (0.001 sec)

MariaDB []>

Answer 2

Well I had similar problem with LPAD, it was truncating number to its pad length. According to https://dev.mysql.com/doc/refman/8.0/en/string-functions.html#function_lpad it is expected result.

As far as I can see, nobody mentioned answer that solved my same problem:

LPAD(id, GREATEST(LENGTH(id), 4), "0")

It works as expected. Pads any id 's shorter than 4 characters with 0, and returns unchanged id 's that are longer than 4 characters.

I'm leaving my answer here for other people, that will find this question in the future.

Answer 3

Ask yourself, why a number would need leading zeroes at all. No number in practical and theoretical math needs leading zeroes.

Maybe you want to visuals something, and not work with the result as a real number. In that case, you can either declare the field in the table ZEROFILL and select it converted to char: SELECT CONVERT(id, CHAR); .

Other than that, the only way is a mix of CONCAT() and LENGTH() , that way you avoid stripping the ID to the value in LPAD() .

Answer 4

LPAD

You can achieve this with an REGEXP_REPLACE to do a LPAD equivalent but without truncating the result. If you want a minimum length of 4 and padding with 0, you can do:

REGEXP_REPLACE(CONCAT('0000', id), '^0{0,4}(.{4,})$', '\\1')

You can adapt this by replacing '0000' with REPEAT('0', 4) to do it programmatically. The main advantage in this approach, is to not repeating the padded thing. In my use cases, I can have very long and complex things that I don't want to duplicate to only pad them, so this code fragment do its job.

RPAD

For those who have the problem for RPAD , you need a very close pattern:

REGEXP_REPLACE(CONCAT(id, '0000'), '^(.{4,}?)0{0,4}$', '\\1')

The two blocks in the pattern are essentially inverted but you can see .{4,}? instead of .{4,} . It's for set the greediness to lazy for the {4,} quantifier. It's needed here.