如何用python解析OracleJDBCEZConnect

我尝试过搜索如何用python解析不同格式的oracle jdbc字符串，但没有找到任何方法

问题:

输入字符串可以基于不同的模式：

• jdbc:oracle:thin:@//hostname.example.ru:1521/database.example.ru
• jdbc:oracle:thin:@hostname:1521:DATABASE

我无法预测下一次我会得到什么样的模式。所以我需要使用一些包，它总是能够解析这样的字符串，而不是实现更多的自行车

更新#0 仍然找不到任何可以解析部件上的连接字符串而不实际连接到oracle的包

现在，我编写了用于解析jdbc oracle ezconnect字符串的正则表达式，您可以使用它来解析ezconnect：

[代码>^代码>^jdbc:甲骨文：甲骨文：瘦：：（（（（？'用户名'[a-zA-扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎扎9 9 9 9 9 9 9 9[1{1{1，1，1，1，1，{1，{1，1，1，1，1，1，1，1，，，，，，，{1，，，，，，，{1，1，1，1，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，}）{0,1}（\/（？'instance_name'[a-zA-Z0-9]{1,}））{0,1}）{0,1}$

这是一个扩展查询：

^
    jdbc:oracle:thin:
    (
        (?'username'[a-zA-Z0-9]{1,})
        ([\/]
            (?'password'[a-zA-Z0-9]{1,})
        ){0,1}
    ){0,1}
    @
    (
        (\/\/){0,1}
        (?'hostname'[a-zA-Z0-9\.\-]{1,})
        (\:(?'port'\d+)){0,1}
    )
    (\/
        (?'service_name'[a-zA-Z\.\-0-9]{1,}
            (\:
                (?'server_type'[a-zA-Z]{1,})
            ){0,1}
        ){0,1}
        (\/
            (?'instance_name'[a-zA-Z0-9]{1,})
        ){0,1}
    ){0,1}
$

您可以在以下行中测试它：

jdbc:oracle:thin:@//hostname.example.ru:1521/database.example.ru
jdbc:oracle:thin:@sales-server
jdbc:oracle:thin:@sales-server:3456
jdbc:oracle:thin:@sales-server/sales
jdbc:oracle:thin:@sales-server:80/sales
jdbc:oracle:thin:@sales-server/sales:dedicated/inst1
jdbc:oracle:thin:@sales-server//inst1
jdbc:oracle:thin:@sales-server:1521/sales.us.acme.com
jdbc:oracle:thin:@//sales-server/sales.us.acme.com
jdbc:oracle:thin:@//sales-server.us.acme.com/sales.us.oracle.com
jdbc:oracle:thin:wat@//sales-server.us.acme.com/sales.us.oracle.com
jdbc:oracle:thin:wat/wat@//sales-server.us.acme.com/sales.us.oracle.com
jdbc:oracle:thin:wat/wat@//sales-server.us.acme.com/sales.us.oracle.com:dedicated/instance
jdbc:oracle:thin:wat/wat@//sales-server.us.acme.com//instance
jdbc:oracle:thin:@non-ezconnect-string-test:1521:DATABASE

更新#1 此代码适用于python：

import re

jdbc_ezconnect = re.compile("^jdbc:oracle:thin:((?P<username>[a-zA-Z0-9]{1,})([\/](?P<password>[a-zA-Z0-9]{1,})){0,1}){0,1}@(?P<ezdb_name>((\/\/){0,1}(?P<hostname>[a-zA-Z0-9\.\-]{1,})(\:(?P<port>\d+)){0,1})(\/(?P<service_name>[a-zA-Z\.\-0-9]{1,}(\:(?P<server_type>[a-zA-Z]{1,})){0,1}){0,1}(\/(?P<instance_name>[a-zA-Z0-9]{1,})){0,1}){0,1})$", re.MULTILINE)

text = [
    "jdbc:oracle:thin:@//hostname.example.ru:1521/database.example.ru",
    "jdbc:oracle:thin:@sales-server",
    "jdbc:oracle:thin:@sales-server:3456",
    "jdbc:oracle:thin:@sales-server/sales",
    "jdbc:oracle:thin:@sales-server:80/sales",
    "jdbc:oracle:thin:@sales-server/sales:dedicated/inst1",
    "jdbc:oracle:thin:@sales-server//inst1",
    "jdbc:oracle:thin:@sales-server:1521/sales.us.acme.com",
    "jdbc:oracle:thin:@//sales-server/sales.us.acme.com",
    "jdbc:oracle:thin:@//sales-server.us.acme.com/sales.us.oracle.com",
    "jdbc:oracle:thin:wat@//sales-server.us.acme.com/sales.us.oracle.com",
    "jdbc:oracle:thin:wat/wat@//sales-server.us.acme.com/sales.us.oracle.com",
    "jdbc:oracle:thin:wat/wat@//sales-server.us.acme.com/sales.us.oracle.com:dedicated/instance",
    "jdbc:oracle:thin:wat/wat@//sales-server.us.acme.com//instance",
    "jdbc:oracle:thin:@hostname:1521:DATABASE"
]

matches = jdbc_ezconnect.search(text[0])

username = matches.group('username')
password = matches.group('password')
ezdb_name = matches.group('ezdb_name')
hostname = matches.group('hostname')
port = matches.group('port')
service_name = matches.group('service_name')
server_type = matches.group('server_type')
instance_name = matches.group('instance_name')


print username, password, ezdb_name, hostname, port, service_name, server_type, instance_name

重新导入
（P[P[a-zA-Z0-Z0-9-9-10-10-10-10-9..[1，}）1，（[10//）（[[[P[a-a-a-zA-Z0-Z0-10-10-10-10-Z0-Z0-Z0-Z0-10-9-9-9-9-9[1，1，}）5（1，（1，）））5，5（0，1，1）5，1（0，0，1）0，1）0，1（0，1）0，1（1）0，1）0，1）0，1）0，1（0，1）0，1）0，1（0，1）0，1）0，1（0，1）0，1）0，1）0，1（0，1）0，1（0，1）0，1）0，（0，1）0，1）0，1）0，1）0{0,1}（\/（？P[a-zA-Z0-9]{1，}））{0,1}{0,1}）$”，关于多行）
文本=[
“jdbc:oracle:thin:@//hostname.example.ru:1521/database.example.ru”，
“jdbc:oracle:thin:@sales server”，
“jdbc:oracle:thin:@sales server:3456”，
“jdbc:oracle:thin:@sales server/sales”，
“jdbc:oracle:thin:@sales server:80/sales”，
“jdbc:oracle:thin:@sales server/sales:专用/inst1”，
“jdbc:oracle:thin:@sales server//inst1”，
“jdbc:oracle:thin:@sales server:1521/sales.us.acme.com”，
“jdbc:oracle:thin:@//sales server/sales.us.acme.com”，
“jdbc:oracle:thin:@//sales server.us.acme.com/sales.us.oracle.com”，
“jdbc:oracle:thin:wat@//sales server.us.acme.com/sales.us.oracle.com”，
“jdbc:oracle:thin:wat/wat@//sales server.us.acme.com/sales.us.oracle.com”，
“jdbc:oracle:thin:wat/wat@//sales server.us.acme.com/sales.us.oracle.com:dedicated/instance”，
“jdbc:oracle:thin:wat/wat@//sales server.us.acme.com//instance”，
“jdbc:oracle:thin:@hostname:1521:DATABASE”
]
matches=jdbc_ezconnect.search（文本[0]）
username=matches.group（'username'）
password=matches.group（'password'）
ezdb_name=matches.group（'ezdb_name'））
hostname=matches.group（'hostname'）
端口=匹配。组（'端口'）
服务\u名称=匹配的.group（'服务\u名称'）
服务器类型=匹配的.group（'服务器类型'）
instance\u name=matches.group（'instance\u name'）
打印用户名、密码、ezdb名称、主机名、端口、服务名称、服务器类型、实例名称

产出：

---

None//hostname.example.ru:1521/database.example.ru hostname.example.ru 1521 database.example.ru None

我已经阅读了有关EZCONNECT语法的oracle文档，并编写了regex来解析它。 第二个字符串是标准jdbc模式的一个简短版本，因此我在一个类中统一了这些regexp字符串来解析每个变量

下面是jdbc连接字符串解析器：

# -*- coding: utf-8 -*-

import re


class JDBCParserError(Exception):
    pass


class JDBCParser:
    """
    Класс для распарсивания jdbc-строк.
    """

    # ezonnect patterns
    jdbc_ezconnect = re.compile("^jdbc:oracle:thin:"
                                "((?P<username>[a-zA-Z0-9]{1,})"
                                "([\/](?P<password>[a-zA-Z0-9]{1,})){0,1}){0,1}"
                                "@"
                                "(?P<ezdb_name>((\/\/){0,1}"
                                "(?P<hostname>[a-zA-Z0-9\.\-]{1,})"
                                "(\:(?P<port>\d+)){0,1})"
                                "(\/(?P<service_name>[a-zA-Z\.\-0-9]{1,}"
                                "(\:(?P<server_type>[a-zA-Z]{1,})){0,1}){0,1}"
                                "(\/(?P<instance_name>[a-zA-Z0-9]{1,})){0,1}){0,1})$")

    # jdbc standard pattern - host:port:sid
    jdbc_classic = re.compile("^jdbc:oracle:thin:"
                              "((?P<username>[a-zA-Z0-9]{1,})"
                              "([\/](?P<password>[a-zA-Z0-9]{1,})){0,1}){0,1}"
                              "@"
                              "(?P<connection_string>("
                              "(?P<hostname>[a-zA-Z0-9\.\-]+)"
                              "(\:(?P<port>\d+)))"
                              "(\:(?P<service_name>[a-zA-Z0-9]+)))$")

    username = None
    password = None
    ezdb_name = None
    hostname = None
    port = None
    service_name = None
    instance_name = None

    connection_string = None

    def __init__(self, jdbc_string):
        ezconnect_match = self.jdbc_ezconnect.search(jdbc_string)
        classic_match = self.jdbc_classic.search(jdbc_string)

        if ezconnect_match or classic_match:
            if ezconnect_match:
                self.username = ezconnect_match.group('username')
                self.password = ezconnect_match.group('password')
                self.ezdb_name = ezconnect_match.group('ezdb_name')
                self.hostname = ezconnect_match.group('hostname')
                self.port = ezconnect_match.group('port')
                self.service_name = ezconnect_match.group('service_name')
                self.instance_name = ezconnect_match.group('instance_name')
            if classic_match:
                self.username = classic_match.group('username')
                self.password = classic_match.group('password')
                self.connection_string = classic_match.group('connection_string')
                self.hostname = classic_match.group('hostname')
                self.port = classic_match.group('port')
                self.service_name = classic_match.group('service_name')
        else:
            raise JDBCParserError("JDBC string not recognized")

#-*-编码：utf-8-*-
进口稀土
类JDBCParserError（异常）：
通过
类JDBCParser:
"""
联合开发银行-联合开发银行。
"""
#E连接模式
jdbc_ezconnect=re.compile（^jdbc:oracle:thin:
（（？[a-zA-Z0-9]{1，}）
“（[\/]（？P[a-zA-Z0-9]{1，}））{0,1}{0,1}”
"@"
“（？P（\/\/）{0,1}”
（？P[a-zA-Z0-9\.\-]{1，}）
“（\：（？P\d+）{0,1}）”
（\/（？P[a-zA-Z\.-0-9]{1，}
“（\：（？P[a-zA-Z]{1，}））{0,1}{0,1}”
“（\/（？P[a-zA-Z0-9]{1，}））{0,1}{0,1}）$”）
#jdbc标准模式-主机：端口：sid
jdbc_classic=re.compile（^jdbc:oracle:thin:
（（？[a-zA-Z0-9]{1，}）
“（[\/]（？P[a-zA-Z0-9]{1，}））{0,1}{0,1}”
"@"
“（？P（”
“（？P[a-zA-Z0-9\.\-]+）”
“（\：（？P\d+）”
“（\：（？P[a-zA-Z0-9]+）$”）
用户名=无
密码=无
ezdb_name=None
主机名=无
端口=无
服务名称=无
实例名称=无
连接字符串=无
定义初始化（self，jdbc_字符串）：
ezconnect_match=self.jdbc_ezconnect.search（jdbc_字符串）
classic_match=self.jdbc_classic.search（jdbc_字符串）
如果ezconnect_匹配或经典_匹配：
如果ezconnect_匹配：
self.username=ezconnect_match.group（'username'））
self.password=ezconnect_match.group（'password'））
self.ezdb_name=ezconnect_match.group（'ezdb_name'））
self.hostname=ezconnect_match.group（'hostname'））
self.port=ezconnect_match.group（'port'））
self.service_name=ezconnect_match.group（'service_name'））
self.instance_name=ezconnect_match.group（'instance_name'））
如果匹配：
self.username=classic_match.group（'username'））
self.password=classic_match.group（'password'））
self.connection\u string=classic\u match.group（'connection\u string'））
self.hostname=classic_match.group（'hostname'））
self.port=classic_match.group（'port'））
self.service\u name=classic\u match.group（'service\u name'））
其他：
引发JDBCParserError（“未识别JDBC字符串”）

我已经阅读了oracle文档中关于EZCONNECT语法的内容，并编写了正则表达式来解析它。 塞科