mysql 正则表达式 如何截取字符串中指定格式的字符

Posted 2023-05-13

我从数据库中取了一个字段 例如 字段名是 a 他的内容如下：
1.1.1.2中文1中文中文3
2.1.3.14单独的3中文3中文1
类似这种格式 ： 数字.数字.数字.数字 中文 我想把最前面的 1.1.1.2 或者2.1.3.14 这种格式的字符串取出来 后面的内容都不要。其中的最前面的数字 有可能是1位最多2位。正则表达式怎么写啊？？

mysql> select @col;
+---------------------------+
| @col |
+---------------------------+
| 2.1.3.14单独的3中文3中文1 |
+---------------------------+
1 row in set

mysql> select concat(substring_index(@col, ".", 3), ".", replace(@col, concat(substring_index(@col, ".", 3), "."), "")+0) as result;
+----------+
| result |
+----------+
| 2.1.3.14 |
+----------+
1 row in set

你把第二句中的 @col 替换成你的列名就可以了，然后加上 from 表　成为一个完成的 sql 语句试试吧。 参考技术A

MySQL 一直以来都支持正则匹配，不过对于正则替换则一直到MySQL 8.0 才支持。对于这类场景，以前要么在MySQL端处理，要么把数据拿出来在应用端处理。

比如我想把表y1的列str1的出现第3个action的子 串替换成dble，怎么实现？

1. 自己写SQL层的存储函数。代码如下写死了3个，没有优化，仅仅作为演示，MySQL 里非常不建议写这样的函数。

mysql

DELIMITER $$

USE `ytt`$$

DROP FUNCTION IF EXISTS `func_instr_simple_ytt`$$

CREATE DEFINER=`root`@`localhost` FUNCTION `func_instr_simple_ytt`(

f_str VARCHAR(1000), -- Parameter 1

f_substr VARCHAR(100),  -- Parameter 2

f_replace_str varchar(100),

f_times int -- times counter.only support  3.

) RETURNS varchar(1000)

BEGIN

declare v_result varchar(1000) default 'ytt'; -- result.

declare v_substr_len int default 0; -- search string length.

set f_times = 3; -- only support  3.

set v_substr_len = length(f_substr);

select instr(f_str,f_substr) into @p1; -- First real position .

select instr(substr(f_str,@p1+v_substr_len),f_substr) into @p2; Secondary virtual position.

select instr(substr(f_str,@p2+ @p1 +2*v_substr_len - 1),f_substr) into @p3; -- Third virtual position.

if @p1 > 0  && @p2 > 0 && @p3 > 0 then -- Fine.

select

concat(substr(f_str,1,@p1 + @p2 + @p3 + (f_times - 1) * v_substr_len  - f_times)

,f_replace_str,

substr(f_str,@p1 + @p2 + @p3 + f_times * v_substr_len-2)) into v_result;

else

set v_result = f_str; -- Never changed.

end if;

-- Purge all session variables.

set @p1 = null;

set @p2 = null;

set @p3 = null;

return v_result;

end;

$$

DELIMITER ;

-- 调用函数来更新：

mysql> update y1 set str1 = func_instr_simple_ytt(str1,'action','dble',3);

Query OK, 20 rows affected (0.12 sec)

Rows matched: 20  Changed: 20  Warnings: 0

2. 导出来用sed之类的工具替换掉在导入，步骤如下：（推荐使用）

1）导出表y1的记录。

mysqlmysql> select * from y1 into outfile '/var/lib/mysql-files/y1.csv';Query OK, 20 rows affected (0.00 sec)




2）用sed替换导出来的数据。

shellroot@ytt-Aspire-V5-471G:/var/lib/mysql-files#  sed -i 's/action/dble/3' y1.csv




3）再次导入处理好的数据，完成。

mysql

mysql> truncate y1;

Query OK, 0 rows affected (0.99 sec)

mysql> load data infile '/var/lib/mysql-files/y1.csv' into table y1;

Query OK, 20 rows affected (0.14 sec)

Records: 20  Deleted: 0  Skipped: 0  Warnings: 0

以上两种还是推荐导出来处理好了再重新导入，性能来的高些，而且还不用自己费劲写函数代码。

那MySQL 8.0 对于以上的场景实现就非常简单了，一个函数就搞定了。

mysqlmysql> update y1 set str1 = regexp_replace(str1,'action','dble',1,3) ;Query OK, 20 rows affected (0.13 sec)Rows matched: 20  Changed: 20  Warnings: 0




还有一个regexp_instr 也非常有用，特别是这种特指出现第几次的场景。比如定义 SESSION 变量@a。

mysqlmysql> set @a = 'aa bb cc ee fi lucy  1 1 1 b s 2 3 4 5 2 3 5 561 19 10 10 20 30 10 40';Query OK, 0 rows affected (0.04 sec)




拿到至少两次的数字出现的第二次子串的位置。

mysqlmysql> select regexp_instr(@a,'[:digit:]2,',1,2);+--------------------------------------+| regexp_instr(@a,'[:digit:]2,',1,2) |+--------------------------------------+|                                   50 |+--------------------------------------+1 row in set (0.00 sec)




那我们在看看对多字节字符支持如何。

mysql

mysql> set @a = '中国 美国 俄罗斯 日本 中国 北京 上海 深圳 广州 北京 上海 武汉 东莞 北京 青岛 北京';

Query OK, 0 rows affected (0.00 sec)

mysql> select regexp_instr(@a,'北京',1,1);

+-------------------------------+

| regexp_instr(@a,'北京',1,1)   |

+-------------------------------+

|                            17 |

+-------------------------------+

1 row in set (0.00 sec)

mysql> select regexp_instr(@a,'北京',1,2);

+-------------------------------+

| regexp_instr(@a,'北京',1,2)   |

+-------------------------------+

|                            29 |

+-------------------------------+

1 row in set (0.00 sec)

mysql> select regexp_instr(@a,'北京',1,3);

+-------------------------------+

| regexp_instr(@a,'北京',1,3)   |

+-------------------------------+

|                            41 |

+-------------------------------+

1 row in set (0.00 sec)

那总结下，这里我提到了 MySQL 8.0 的两个最有用的正则匹配函数 regexp_replace 和 regexp_instr。针对以前类似的场景算是有一个完美的解决方案。

参考技术B 代码如下:
CREATE PROCEDURE sp_str
(
IN p_str VARCHAR(50), /*原始字符串*/
IN p_begin_str VARCHAR(50), /*要匹配的起始字符串*/
IN p_end_str VARCHAR(50)) /*要匹配的结束字符串*/
OUT p_result VARCHAR(50)) /*返回结果*/
NOT DETERMINISTIC
SQL SECURITY DEFINER
COMMENT ''
BEGIN
DECLARE m_len INT DEFAULT 0;
DECLARE m_index INT DEFAULT 0;
/*计算第一个匹配字符串的索引位置*/
select locate(p_begin_str,p_str)+char_length(p_begin_str) into m_index;
/*计算第一个匹配字符串的长度*/
select locate(p_end_str,p_str,m_index) into m_len;
select SUBSTRING(p_str,m_index,m_len-m_index) INTO p_result ;
END;

执行：
CALL sp_str('[]abcd[12345]aa[]ss','abcd[',']',@result);
返回值 @result 为12345
call sp_str('[]abcd[sdww]aa[]ss','abcd[',']',@result);
返回值 @result 为sdww
如果不用存储过程，可以直接写sql语句实现：

代码如下:
select SUBSTRING(
']abcd[12345]111[]',
locate('abcd[',']abcd[12345]111[]')+CHAR_LENGTH('abcd['),
locate(']',']abcd[12345]111[]',CHAR_LENGTH('abcd['))-
(select locate('abcd[',']abcd[12345]111[]')+CHAR_LENGTH('abcd['))
)

返回值为 12345
关于mysql的函数介绍：
CHAR_LENGTH(str) 　
返回字符串str的长度。
LOCATE(substr,str) 　
POSITION(substr IN str)
返回子串substr在字符串str第一个出现的位置，如果substr不是在str里面，返回0.
mysql> select LOCATE('bar', 'foobarbar');
-> 4
mysql> select LOCATE('xbar', 'foobar');
-> 0
该函数是多字节可靠的。 LOCATE(substr,str,pos)
返回子串substr在字符串str第一个出现的位置，从位置pos开始。如果substr不是在str里面，返回0。
mysql> select LOCATE('bar', 'foobarbar',5);
-> 7
这函数是多字节可靠的。
SUBSTRING(str,pos,len) 　
SUBSTRING(str FROM pos FOR len) 　
MID(str,pos,len)
从字符串str返回一个len个字符的子串，从位置pos开始。使用FROM的变种形式是ANSI SQL92语法。
mysql> select SUBSTRING('Quadratically',5,6);
-> 'ratica'
该函数是多字节可靠的。
SUBSTRING(str,pos)

为啥我必须在 Java 正则表达式中指定整个字符串？ [复制]

【中文标题】为啥我必须在 Java 正则表达式中指定整个字符串？ [复制]

【英文标题】：Why I must specify whole string in Java regular expression? [duplicate]为什么我必须在 Java 正则表达式中指定整个字符串？ [复制]

【发布时间】：2016-11-06 02:25:10

【问题描述】：

假设，我有一个字符串：

String str = "some strange string with searched symbol";

我想在其中搜索一些符号，假设它是"string"。所以我们有以下内容：

str.matches("string"); //false
str.matches(".*string.*"); //true

那么，如标题所述，为什么我必须在 Java 正则表达式中指定整个字符串？

Java 文档说：

公共布尔匹配（字符串正则表达式）

判断这个字符串是否匹配给定的正则表达式。

没有说

判断这个整个字符串是否匹配给定的正则表达式。

例如，在php 中会是：

$str = "some strange string with searched symbol";
var_dump(preg_match('/string/', $str)); // int(1)
var_dump(preg_match('/.*string.*/', $str)); //int(1)

所以，两个正则表达式都是true。 我认为这是正确的，因为如果我想测试整个字符串，我会做str.matches("^string$");

PS：是的，我知道是搜索一个子字符串，更简单更快捷的是使用str.indexOf("string")或str.contains("string")。我的问题只涉及 Java 正则表达式。

---

更新：如@ChrisJester-Young（和@GyroGearless）所述，如果您想搜索作为主题字符串一部分的regex，则其中一种解决方案是使用@987654331像这样的@方法：

    String str = "some strange string with searched symbol";
    Matcher m = Pattern.compile("string").matcher(str);
    System.out.println(m.find()); //true

【问题讨论】：

你可以在if中使用find func。

Matcher 类的 Javadoc 非常清楚：“matches 方法尝试将整个输入序列与模式进行匹配。”​​

Java 在正则表达式部门的非直觉方法命名方面几乎没有问题。例如replace(str, str) 与replaceAll(str, str)。这两者之间的 only 区别在于replace 不使用正则表达式语法，而replaceAll 使用正则表达式语法并不明显（这两种方法都将替换所有出现或选定的文本）。不幸的是，我们现在所能做的就是接受这一点，犯下我们的错误并最终习惯它。

因为正则表达式“string”与您的测试字符串不匹配。该函数的行为与文档中所说的完全相同。我建议阅读更多关于正则表达式的内容，这应该有助于解决未来的误解。

【参考方案1】：

按照您建议的文档，

公共布尔匹配（字符串正则表达式）

判断这个字符串是否匹配给定的正则表达式。

这意味着该字符串是否与给定的正则表达式匹配。即matches 验证您的字符串是否是给定正则表达式的 instance。

not 是否包含作为给定正则表达式的 instance 的子字符串。正如 Chris 建议的那样，您可以改用 find，或者对于您的问题，您可以使用 contains。

【参考方案2】：

是的，您已经知道（现在）matches() 将仅对完整的字符串返回 true。

但是，在您的更新中，您已声明：

正如@ChrisJester-Young（和@GyroGearless）所述，only 解决方案，如果您想搜索作为主题字符串一部分的正则表达式，则使用 find() 方法...

我想说的是，使用find() 不是唯一的解决方案。至少还有一个，我知道：

String str = "some strange string with searched symbol";
boolean found = str.split("string").length>1;
System.out.println(found);

这将打印true。这适用于所有正则表达式。虽然这不是这样做的方法，而是一种 hack。

可能还有更多解决方案。

【讨论】：

我很确定有很多 hacks 可以达到相同的结果 =)。我正在讲述实现这一目标的正确方法。但现在我明白了，那只是我的看法。已删除仅 =)

@spirit 你只删除了唯一的唯一问题？仅有的？好的。仅有的！ :P

【参考方案3】：

matches 始终匹配整个输入字符串。如果要允许子字符串匹配，请使用find。

【讨论】：

你的意思是：Pattern.compile("string").matcher(str).find() ?

@spirit 正确。可悲的是，String 类上没有花哨的便利功能。 :-(

同意 =) 如果有 str.find("regex") 方法会更好。

嗯，有indexOf(String) ... .

@KevinEsche 是的，但find 在功能方面更接近matches。