sql&python—正则表达式_python执行sql的regexp语句

1、需求场景

在 Sql、Java、Python语言中都支持正则表达式，其中正则的规则也基本接近，此处统一记录。

1.1、编码类型

ASCII编码和UNICODE编码
对照表：https://blog.csdn.net/m0_49447718/article/details/108191136

2、正则匹配

2.1、Sql

参考资料：
1、https://www.cnblogs.com/yj411511/p/13397807.html
2、https://blog.csdn.net/fd2025/article/details/125326832

• regexp_like

匹配以多种字符串开头实现：
实现-A（正确）

---匹配以 "mx"或"zb"开头的字符串
select case
         when regexp_like(v_string, '^mx|^zb') then
          'Y'
         else
          'N'
       end
  from dual;
1
2
3
4
5
6
7
8

实现-B（正确）

---匹配以 "mx"或"zb"开头的字符串
select case
         when regexp_like(v_string, '^(mx|zb)') then
          'Y'
         else
          'N'
       end
  from dual;
1
2
3
4
5
6
7
8

实现-C（错误）

---匹配以 "mx"或"zb"开头的字符串
select case
         when regexp_like(v_string, '^[mx|zb]') then
          'Y'
         else
          'N'
       end
  from dual;
1
2
3
4
5
6
7
8

• regexp_replace
  场景：替换数据列值域中的换行、回车、空格、制表符等符号；

=====推荐写法

---通用语法
regexp_replace(orig_str,'['||chr(9)||chr(10)||chr(13)||chr(32)||']')

---Oracle语法
regexp_replace(orig_str,'[' || unistr('\0009\000a\000d\0020') || ']','')

---Oracle语法
regexp_replace(orig_str,'' || unistr('\0009|\000a|\000d|\0020') || '','')

---GaussDB语法
regexp_replace(orig_str,'[\u0009\u000a\u000d\u0020]','','g')
1
2
3
4
5
6
7
8
9
10
11

========不推荐此种写法

regexp_replace(orig_str,''||chr(9)||'|'||chr(10)||'|'||chr(13)||'|'||chr(32)||'')

---高斯语法
regexp_replace(orig_str,'\u0009|\u000a|\u000d|\u0020','','g')
1
2
3
4

==说明：==通过拼接的表达式的形式和使用 [ ]的形式效果一样，但是对于有 “|” 的字符串，则不能使用拼接的形式；

正则匹配多个模板字符串：如从一个通信地址里抠出所在的行政区划名称，行政区划有一个代码表对应；

with v_wd_xzqh as
 (select listagg('(' || xzqhmc || ')', '|') within group(order by 1) str_qhmc
    from (select '滨江区' as xzqhmc
            from dual
          union all
          select '萧山区' as xzqhmc
            from dual
          union all
          select '西湖区' as xzqhmc
            from dual) dm_qhmc)
select qh.str_qhmc,
       case
         when regexp_like('杭州市萧山区阡陌路299号XXX公寓', qh.str_qhmc) then
          'True'
         else
          'False'
       end as str_like,
       regexp_substr('杭州市萧山区阡陌路299号XXX公寓', qh.str_qhmc) as str_substr
  from dual t, v_wd_xzqh qh
 where 1 = 1;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

说明：此处正则的模糊匹配和截取表达式可以使用表的字段拼接值；

• regexp_substr
  场景5：从一个字符串中提取符合格式的所有数值；
  实现方式：使用正则截取，递归实现；

select regexp_substr('986.4WERJIP2345UPSEF op894.9', '\d+.?\d+', 1, level),
       level

  from dual
connect by level <=
           regexp_count('986.4WERJIP2345UPSEF op894.9', '\d+.?\d+');
1
2
3
4
5
6

结果如下图：

• Oracle正则分割
  场景：多行数据正则分割

select xh, regexp_substr(col_add, '[^,]+', 1, level) split_col
  from test_split_1206
connect by level <= regexp_count(col_add, '[^,]+')
       and rowid = prior rowid
       and prior dbms_random.value is not null;
1
2
3
4
5

说明：
1）这里的 connect 后面的2行条件不能缺少；这里 rowid 非必须，可以是 union all几段里的某个唯一列，如 xh；

select qysbh, regexp_substr(cgbl_str, '[^(>|(|))]+', 1, level) split_col
  from (select 'HHH' as qysbh,
               '>(0.745084)>(0.990991)>(0.246572)' as cgbl_str
          from dual)
connect by level <= regexp_count(cgbl_str, '[^(>|(|))]+')
      -- and rowid = prior rowid
      -- and prior dbms_random.value is not null;
1
2
3
4
5
6
7

结果：

说明：这里的分隔符可以是多种，具体见 sql；

• 检测一个字符串是否为数字

regexp_like(t.nsrdzdah,'^\d\d{m,n}\d$')
1

• pg正则分割

select *
  from (select regexp_split_to_table('我们积极探索新时代金融发展规律，不断加深对中国特色社会主义金融本质的认识，不断推进金融实践创新理论创新制度创新，逐步走出一条中国特色金融发展之路，坚持党中央对金融工作的集中统一领导，坚持以人民为中心的价值取向，坚持把金融服务实体经济作为根本宗旨，坚持把防控风中国险作为金融工作的永恒主题，坚持在市场化法治化轨道上推进金融创新发展，坚持深化金融供给侧结构性改革，坚持统筹金融开放和安全，坚持稳中国求进工作总基调。',
                                     '[，|,|:|：|;|；|.|。]') as per_line  ) h
 where h.per_line like '%中国%';
1
2
3
4

说明：此处查找包含 "中国"关键词的语句，支持多种分隔符号；

2.2、Python

re 模块是Python的正则模块；

2.2.1、正则表达

2.2.2、正则分割

• re.split(r'[\s\,\;]+', 'a,b;; c d')
  说明：[ ] 中的字符是或的关系，[\s\,\;]+表示空格或 , 或 ;；

2.2.3、分组

2.2.4、编译

在Python中使用正则表达式时，re模块内部会首先
1）编译正则表达式，如果正则表达式的字符串本身不合法，会报错；
2）用编译后的正则表达式去匹配字符串。

如果一个正则表达式要重复使用多次次，出于效率的考虑，可以预编译该正则表达式，后面则无需编译这个步骤，直接匹配；

re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$')
re_telephone.match('010-12345').groups()
1
2

========================================== over ============================================