python 脚本 通过解析 DDL 更新PDM

最新推荐文章于 2024-08-12 10:00:00 发布
最新推荐文章于 2024-08-12 10:00:00 发布
阅读量2.2k 收藏 3
点赞数
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/happyzwh/article/details/78614123
版权

     需求：

            上线工作涉及到表结构更新时，由开发人员提交变更的sql语句由DBA操作，为了保障表结构变更与PDM同步并且自动化，写了python脚本，解析DDL语句更新PDM文件。

    PDM是XML文件为脚本更新提供可能。

         代码如下：

         PDM解析操作脚本：

         

#!/usr/bin/python
# -*- coding: utf-8 -*- #

from xml.dom.minidom import parse
import xml.dom.minidom


class PDMHandler(object):
    TBL_ATTR_LIST = ["Code"]
    COL_ATTR_LIST = ["Code"]

    tableNodes = {}
    columnNodes = {}
    modelTablesNode = None
    ph = None

    filename = 'package.pdm'

    def __init__(self):
        self.init();
        return

    def init(self):
        self.ph = PDMHandler.parse(self.filename)
        for pkg in PDMHandler.getPkgNodes(self.ph):
            for tbl in PDMHandler.getTblNodesInPkg(pkg):
                tbl_attrs = PDMHandler.getTblAttrs(tbl)
                self.tableNodes[tbl_attrs['Code']] = tbl
                for col in PDMHandler.getColNodesInTbl(tbl):
                    col_attrs = PDMHandler.getColAttrs(col)
                    self.columnNodes[tbl_attrs['Code'] + '_' + col_attrs['Code']] = col

    @staticmethod
    def parse(pdmfilename):
        """
        @brief       PDM文件导入函数
        @param[in]   pdmfilename       pdm文件名
        @return      pdm文件的DOM结构
        """
        return xml.dom.minidom.parse(pdmfilename)

    @staticmethod
    def __get_nodes_by_path(parent, xml_path):
        """
        @brief 按路径取节点核心函数,通过传入一个节点和一个路径
               (类文件系统路径)的字符串,获得相应的子结点(或集合).
               例1: __get_nodes_by_path(node,"a/b/c|3/d")
                 即获得node下a下b下第3个c节点下的所有d节点的一个
                 list.
               例2: __get_nodes_by_path(node,"a/b/c|3/d|2")
                 即获得node下a下b下第3个c节点下的第2个d节点.
                 注意:此处返回的不是list,而是节点
        @param[in]   parent DOM中的父节点
        @return      节点list或节点句柄
        """
        curr_node = parent
        for tag in xml_path.split("/")[0:-1]:
            tag_desc = tag.split("|")
            tag_name, tag_index = tag_desc[0], (int(tag_desc[1]) if len(tag_desc) == 2 else 0)
            child_nodes = []
            for child_node in curr_node.childNodes:
                if child_node.nodeName == tag_name:
                    child_nodes.append(child_node)
            if len(child_nodes) < tag_index + 1:
                return []
            curr_node = child_nodes[tag_index]
        # -- 最后一级路径特殊处理 -- #
        tag = xml_path.split("/")[-1]
        tag_desc = tag.split("|")
        tag_name, tag_index = tag_desc[0], (int(tag_desc[1]) if len(tag_desc) == 2 else None)
        child_nodes = []
        for child_node in curr_node.childNodes:
            if child_node.nodeName == tag_name:
                child_nodes.append(child_node)
        if tag_index == None:
            return child_nodes
        elif len(child_nodes) < tag_index + 1:
            return []
        else:
            curr_node = child_nodes[tag_index]
            return curr_node

    @staticmethod
    def __get_attrs_by_list(parent, attr_list):
        """
        @brief       取PDM属性(注意:此属性非xml属性）
                     背景:PDM文件中主要节点(o:Table,o:Column...)的具体属性
                          一般以子节点形式表示，而不以通常的XML属性表示.此
                          函数传入一个attr_list,输出一个字典表示的:
                          { "attr":"value" ...}
        @param[in]   parent    需要被取属性的节点句柄
        @param[in]   attr_list 一个字符串的list["attr1","attr2"...],代表要取的属性名集合
        @return      返回一个dict:{"attr1":"value" ...}
        """
        ret_dict = {}
        for attr in attr_list:
            ret_dict[attr] = ""
            for child in parent.childNodes:
                if child.nodeName == "a:" + attr:
                    ret_dict[attr] = child.childNodes[0].data
                    break
        return ret_dict

    @staticmethod
    def __get_pkgnodes_recursively(o_pkg):
        # -- 需要传入一个o:Model/o:Package节点 --#
        if o_pkg.nodeName != "o:Model" and o_pkg.nodeName != "o:Package":
            return []
        ret_list = []
        subpkgs = PDMHandler.__get_nodes_by_path(o_pkg, "c:Packages/o:Package")
        if subpkgs != None:
            for subpkg in subpkgs:
                ret_list.append(subpkg)
                ret_list = ret_list + PDMHandler.__get_pkgnodes_recursively(subpkg)
        else:
            return []
        return ret_list

    @staticmethod
    def getPkgNodes(hpdm):
        """
        @brief       获取pdm文件中所有的o:package的句柄list
        @param[in]   hpdm    待处理的pdm文件DOM句柄(可通过PDMHandler.parse取得)
        @return      返回pacakge的节点list:[pkg1,pkg2...],元素为DOM节点类型
        """
        ret_list = []
        try:
            o_mdl = PDMHandler.__get_nodes_by_path(hpdm, "Model/o:RootObject/c:Children/o:Model")[0]
            ret_list.append(o_mdl)
        except IndexError:
            print("ERROR:不是一个合法的pdm文件!")
            return []
        ret_list = ret_list + PDMHandler.__get_pkgnodes_recursively(o_mdl)
        return ret_list

    @staticmethod
    def getModelTablesNodes(hpdm):
        """
        @brief       获取pdm文件中所有的o:package的句柄list
        @param[in]   hpdm    待处理的pdm文件DOM句柄(可通过PDMHandler.parse取得)
        @return      返回pacakge的节点list:[pkg1,pkg2...],元素为DOM节点类型
        """
        ret_list = []
        try:
            o_mdl = PDMHandler.__get_nodes_by_path(hpdm, "Model/o:RootObject/c:Children/o:Model/c:Tables")
            if len(o_mdl) == 0:
                o_mdl = PDMHandler.__get_nodes_by_path(hpdm, "Model/o:RootObject/c:Children/o:Model")[0]
                cTables = hpdm.createElement('c:Tables')
                o_mdl.appendChild(cTables)
                ret_list.append(cTables)
            else:
                ret_list.append(o_mdl[0])
        except IndexError:
            return []
        return ret_list

    @staticmethod
    def getTblNodesInPkg(pkgnode):
        """
        @brief       获取指定o:Package下的所有o:Table的list
        @param[in]   pkgnode 待处理的o:Package节点(可通过PDMHandler.getPkgNodes取得)
        @return      返回o:Table的节点list:[tbl1,tbl2...],元素为DOM节点类型
        """
        return PDMHandler.__get_nodes_by_path(pkgnode, "c:Tables/o:Table")

    @staticmethod
    def getColNodesInTbl(tblnode):
        """
        @brief       获取指定o:Table下的所有o:Column的list
        @param[in]   tblnode 待处理的o:Table节点(可通过PDMHandler.getTblInPkg取得)
        @return      返回o:Column的节点list:[col1,col2...],元素为DOM节点类型
        """
        return PDMHandler.__get_nodes_by_path(tblnode, "c:Columns/o:Column")

    @staticmethod
    def getIdxNodesInTbl(tblnode):
        """
        @brief       获取指定o:Table下的所有o:Index的list
        @param[in]   tblnode 待处理的o:Table节点(可通过PDMHandler.getTblInPkg取得)
        @return      返回o:Index的节点list:[idx1,idx2...],元素为DOM节点类型
        """
        return PDMHandler.__get_nodes_by_path(tblnode, "c:Indexes/o:Index")

    @staticmethod
    def getIdxColNodesInIdx(idxnode):
        """
        @brief       获取指定o:Index下的所有o:IndexColumn的list
        @param[in]   idxnode 待处理的o:Index节点(可通过PDMHandler.getIdxNodesInTbl取得)
        @return      返回o:IndexColumn的节点list:[idxcol1,idxcol2...],元素为DOM节点类型
        """
        return PDMHandler.__get_nodes_by_path(idxnode, "c:IndexColumns/o:IndexColumn")

    @staticmethod
    def getTblAttrs(tblnode):
        """
        @brief       获取指定o:Table的属性(可取的属性参见PDMHandler.TBL_ATTR_LIST)
        @param[in]   tblnode 待处理的o:Table节点(可通过PDMHandler.getTblNodesInPkg取得)
        @return      返回一个字典dict:{"attr1":"value",...}
        """
        return PDMHandler.__get_attrs_by_list(tblnode, PDMHandler.TBL_ATTR_LIST)

    @staticmethod
    def getColAttrs(colnode):
        """
        @brief       获取指定o:Column的属性(可取的属性参见PDMHandler.COL_ATTR_LIST)
        @param[in]   colnode 待处理的o:Column节点(可通过PDMHandler.getColNodesInTbl取得)
        @return      返回一个字典dict:{"attr1":"value",...}
        """
        return PDMHandler.__get_attrs_by_list(colnode, PDMHandler.COL_ATTR_LIST)

    @staticmethod
    def getNodePath(node):
        """
        @brief       获取指定node的路径(模拟文件系统路径表示法)
        @param[in]   node 待处理的节点,类型为DOM的节点类型
        @return      返回一个字符串表示node的路径,形如"/foo/bar/node"
        """
        curr = node
        path_nodes = []
        while (1):
            if curr != None and curr.nodeName != "#document":
                path_nodes.append(curr.tagName)
            else:
                break
            curr = curr.parentNode
        path_nodes.reverse()
        path = "".join([slash + node for slash in '/' for node in path_nodes])
        return path

    @staticmethod
    def getNode(parent, nodeName):
        """
        @brief 判断结点parent的名称是否与参数名称nodeName相同，相同返回parent,否则返则None
        :param parent: 节点
        :param nodeName: 参数名称
        :return:
        """
        for node in parent.childNodes:
            if node.nodeName == 'a:Name' and node.childNodes[0].data == nodeName:
                return parent
        return None

    @staticmethod
    def getTableColumnsNode(tableNode):
        """
        @brief 根据表结点tableNode查询列结点
        :param tableNode: 表节点
        :return: 表节点下节点c:Columns
        """
        for node in tableNode.childNodes:
            if node.nodeName == 'c:Columns':
                return node
        return None

    @staticmethod
    def addColumn(pdm, tableCode, columnObjectList=None):
        """
        @brief 增加列
        :param pdm: dom文档
        :return:
        """

        if tableCode == None:
            print('待增加列对应表编码不能为空')
            return False

        if columnObjectList == None or len(columnObjectList) == 0:
            print('待增加列不能为空且格式为[{"code":,"name":,...}]')
            return False

        for columnObject in columnObjectList:

            tableNode = pdm.tableNodes[tableCode]

            TableColumnsNode = PDMHandler.getTableColumnsNode(tableNode)

            nColumn = pdm.ph.createElement('o:Column')
            TableColumnsNode.appendChild(nColumn)

            nCode = pdm.ph.createElement('a:Code')
            cCode = pdm.ph.createTextNode(columnObject['code'])
            nCode.appendChild(cCode)
            nColumn.appendChild(nCode)

            pdm.columnNodes[tableCode + '_' + columnObject['code']] = nColumn

            nName = pdm.ph.createElement('a:Name')
            cName = pdm.ph.createTextNode(columnObject['code'] if columnObject.get('name') == None else columnObject['name'])
            nName.appendChild(cName)
            nColumn.appendChild(nName)

            if columnObject.get('comment') != None:
                nComment = pdm.ph.createElement('a:Comment')
                cComment = pdm.ph.createTextNode(columnObject['comment'])
                nComment.appendChild(cComment)
                nColumn.appendChild(nComment)

            nDataType = pdm.ph.createElement('a:DataType')
            cDataType = pdm.ph.createTextNode(columnObject['dataType'])
            nDataType.appendChild(cDataType)
            nColumn.appendChild(nDataType)

            nLength = pdm.ph.createElement('a:Length')
            cLength = pdm.ph.createTextNode(columnObject['length'])
            nLength.appendChild(cLength)
            nColumn.appendChild(nLength)

    @staticmethod
    def updateColumn(pdm, tableCode, columnObjectList=None):
        """
        @breif 更新列
        :param pdm:  dom文档
        :param tableCode: 表编码
        :param columnCode:
        :return:
        """

        if tableCode == None:
            print('待修改列对应表编码不能为空')
            return False

        if columnObjectList == None or len(columnObjectList) == 0:
            print('待增加列不能为空且格式为[{"code":,"name":},...]')
            return False

        for columnObject in columnObjectList:

            columnNode = pdm.columnNodes[tableCode + '_' + columnObject['code']]

            for key in columnObject.keys():
                if key != 'code':
                    tf = False
                    for node in columnNode.childNodes:
                        if node.nodeName == 'a:' + key.capitalize():
                            node.removeChild(node.childNodes[0])

                            cName = pdm.ph.createTextNode(columnObject[key])
                            node.appendChild(cName)
                            tf = True
                            break
                    if tf == False:
                        csNode = pdm.ph.createElement('a:' + key.capitalize())
                        columnNode.appendChild(csNode)
                        cName = pdm.ph.createTextNode(columnObject[key])
                        csNode.appendChild(cName)

    @staticmethod
    def addTable(pdm, tableObject=None):
        """
        @breif  增加表
        :param pdm: dom文档
        :return:
        """

        if tableObject == None or tableObject.get('code') == None:
            print('待增加表不能为空且格式为{"code":,...}')
            return False

        if pdm.modelTablesNode == None:
            pdm.modelTablesNode = PDMHandler.getModelTablesNodes(pdm.ph)[0]

        nTable = pdm.ph.createElement('o:Table')
        pdm.modelTablesNode.appendChild(nTable)

        pdm.tableNodes[tableObject['code']] = nTable

        nCode = pdm.ph.createElement('a:Code')
        cCode = pdm.ph.createTextNode(tableObject['code'])
        nCode.appendChild(cCode)
        nTable.appendChild(nCode)

        # tableObject['name'] = tableObject['code'] if tableObject.get('name') != None else tableObject['name']

        # if tableObject.get('name') != None:
        nName = pdm.ph.createElement('a:Name')
        cName = pdm.ph.createTextNode(tableObject['code'] if tableObject.get('name') == None else tableObject['name'])
        nName.appendChild(cName)
        nTable.appendChild(nName)

        if tableObject.get('comment') != None:
            nComment = pdm.ph.createElement('a:Comment')
            cComment = pdm.ph.createTextNode(tableObject['comment'])
            nComment.appendChild(cComment)
            nTable.appendChild(nComment)

        nColumns = pdm.ph.createElement('c:Columns')
        nTable.appendChild(nColumns)

    @staticmethod
    def updateTable(pdm, tableCode,tableObject=None):
        """
        @breif  增加表
        :param pdm: dom文档
        :return:
        """
        if tableObject == None:
            print('待修改表不能为空且格式为{"name":,....}')
            return False

        tableNode = pdm.tableNodes[tableCode]

        for key in tableObject.keys():
            if key != 'code':
                tf = False
                for node in tableNode.childNodes:
                    if node.nodeName == 'a:' + key.capitalize():
                        node.removeChild(node.childNodes[0])

                        cName = pdm.ph.createTextNode(tableObject[key])
                        node.appendChild(cName)
                        tf = True
                        break
                if tf == False:
                    tsNode = pdm.ph.createElement('a:' + key.capitalize())
                    tableNode.appendChild(tsNode)
                    cName = pdm.ph.createTextNode(tableObject[key])
                    tsNode.appendChild(cName)

    @staticmethod
    def delTable(pdm, tableCodeList=None):
        """
        @breif  删除表
        :param pdm: dom文档
        :return:
        """

        if tableCodeList == None or len(tableCodeList) == 0:
            print('待删除表code列表不能为空')
            return False

        for tableCode in tableCodeList:

            tableNode = pdm.tableNodes[tableCode]
            tableNode.parentNode.removeChild(tableNode)

            pdm.tableNodes.pop(tableCode)

            keysTmp = []

            for key in pdm.columnNodes.keys():
                keysTmp.append(key)

            for key in keysTmp:
                if key.startswith(tableCode + '_'):
                    pdm.columnNodes.pop(key)


    @staticmethod
    def delColumn(pdm,tableCode, columnCodeList=None):
        """
        @breif  删除列
        :param pdm: dom文档
        :return:
        """

        if columnCodeList == None or len(columnCodeList) == 0:
            print("待删除表code列表不能为空且格式如下['columnCode'...]")
            return False

        for columnCode in columnCodeList:
            colunmNode = pdm.columnNodes[tableCode + '_' + columnCode]
            colunmNode.parentNode.removeChild(colunmNode)

            pdm.columnNodes.pop(tableCode + '_' + columnCode)

 

    DDL解析操作脚本：
 

    
#!/usr/bin/python
# -*- coding: utf-8 -*- #
import re


class DDLHandler(object):

    """
    @preif  DDL解析
    """
    ANNOTION = ['-','#']
    LIST_DDL = ['CREATE TABLE','DROP TABLE','ALTER TABLE','COMMENT ON TABLE','COMMENT ON COLUMN']

    list_ddl = []
    list_ddl_line_join = []
    fileName = 'ddl.sql'

    list_table_add = []
    list_column_add = {}
    list_table_del = []
    list_table_update = {}
    list_column_update = {}
    list_column_del = {}

    def __init__(self):
        self.init()
        self.joinLine()
        self.parseDdl()
        return

    def init(self):
        with open(self.fileName,'r',encoding='utf-8') as fl:
            for line in fl:
                if not re.match('^\s*('+'|'.join(self.ANNOTION)+')',line):

                    line = re.sub('\s+',' ', line)

                    self.list_ddl.append(line.upper().strip())

    def joinLine(self):
        list_join = []
        for line in self.list_ddl:
            if re.match('^\s*('+'|'.join(self.LIST_DDL)+')', line):
                if re.match('^\s*' + self.LIST_DDL[0], line):
                    if re.match('.*\);\s*$', line):
                        self.list_ddl_line_join.append(line)
                    else:
                        list_join.append(line)
                else:
                    self.list_ddl_line_join.append(line)
            elif re.match('^\s*\);\s*$', line):
                list_join.append(line)
                self.list_ddl_line_join.append(' '.join(list_join))
                list_join = []
            else:
                list_join.append(line)

    def parseDdl(self):
        for sql in self.list_ddl_line_join:
            if re.match('^\s*'+self.LIST_DDL[0], sql):
                self.parseTableCreate(sql)
            elif re.match('^\s*'+self.LIST_DDL[1], sql):
                self.parseTableDel(sql)
            elif re.match('^\s*'+self.LIST_DDL[2], sql):
                self.parseColumnUpdate(sql)
            elif re.match('^\s*'+self.LIST_DDL[3], sql):
                self.parseTableComment(sql)
            elif re.match('^\s*'+self.LIST_DDL[4], sql):
                self.parseColumnComment(sql)

    def parseTableCreate(self,sql):
        regex = re.compile('^\s*CREATE\s+TABLE\s+(?P<tableCode>\w+)\s*\( (?P<columnCodes>.+)\);')
        match = regex.match(sql)
        tableCode = match.groupdict()['tableCode']
        columnCodes = match.groupdict()['columnCodes']
        columnCodes = columnCodes.split(',')

        tableObject = {'code':tableCode}
        self.list_table_add.append(tableObject)

        list = []
        for column in columnCodes:
            regex = re.compile('^\s*(?P<columnCode>\w+)\s+(?P<dataType>\w+)(\((?P<length>\d+)\))?.*$')
            match = regex.match(column)

            length = match.groupdict()['length'] if match.groupdict().get('length') != None else ''
            dataType = match.groupdict()['dataType']+ ('('+match.groupdict()['length']+')' if match.groupdict().get('length') != None else '')

            data = {'code':match.groupdict()['columnCode'],'dataType':dataType,'length':length}
            list.append(data)

        self.list_column_add[tableCode] = list

    def parseTableDel(self, sql):
        regex = re.compile('^\s*DROP\s+TABLE\s+(?P<tableCode>\w+)\s*;')
        match = regex.match(sql)
        self.list_table_del.append(match.groupdict()['tableCode'])

    def parseColumnUpdate(self, sql):
        if re.match('^\s*ALTER\s+TABLE\s+\w+\s+ADD', sql):
            regex = re.compile('^\s*ALTER\s+TABLE\s+(?P<tableCode>\w+)\s+ADD\s*\((?P<columnCode>\w+)\s+(?P<dataType>\w+)(\((?P<length>\d+)\))?\);$')
            match = regex.match(sql)

            length = match.groupdict()['length'] if match.groupdict().get('length') != None else ''
            dataType = match.groupdict()['dataType'] + ('(' + match.groupdict()['length'] + ')' if match.groupdict().get('length') != None else '')

            data = {'code':match.groupdict()['columnCode'],'dataType':dataType,'length':length}

            if self.list_column_add.get(match.groupdict()['tableCode']) == None:
                self.list_column_add[match.groupdict()['tableCode']] = [data]
            else:
                self.list_column_add[match.groupdict()['tableCode']].append(data)

        elif re.match('^\s*ALTER\s+TABLE\s+\w+\s+DROP', sql):
            regex = re.compile('^\s*ALTER\s+TABLE\s+(?P<tableCode>\w+)\s+DROP\s+COLUMN\s+(?P<columnCode>\w+);$')
            match = regex.match(sql)

            if self.list_column_del.get(match.groupdict()['tableCode']) == None:
                self.list_column_del[match.groupdict()['tableCode']] = [match.groupdict()['columnCode']]
            else:
                self.list_column_del[match.groupdict()['tableCode']].append(match.groupdict()['columnCode'])

        elif re.match('^\s*ALTER\s+TABLE\s+\w+\s+MODIFY', sql):
            regex = re.compile('^\s*ALTER\s+TABLE\s+(?P<tableCode>\w+)\s+MODIFY\s*\((?P<columnCode>\w+)\s+(?P<dataType>\w+)(\((?P<length>\d+)\))?\);$')
            match = regex.match(sql)

            length = match.groupdict()['length'] if match.groupdict().get('length') != None else ''
            dataType = match.groupdict()['dataType'] + ('(' + match.groupdict()['length'] + ')' if match.groupdict().get('length') != None else '')

            data = {'code': match.groupdict()['columnCode'], 'dataType': dataType, 'length': length}

            if self.list_column_update.get(match.groupdict()['tableCode']) == None:
                self.list_column_update[match.groupdict()['tableCode']] = [data]
            else:
                self.list_column_update[match.groupdict()['tableCode']].append(data)

    def parseTableComment(self,sql):
        regex = re.compile("^\s*COMMENT\s+ON\s+TABLE\s+(?P<tableCode>\w+)\s+IS\s+'(?P<comment>.*)';$")
        match = regex.match(sql)

        if self.list_table_update.get(match.groupdict()['tableCode']) == None:
            self.list_table_update[match.groupdict()['tableCode']] = {'comment':match.groupdict()['comment']}
        else:
            self.list_table_update[match.groupdict()['tableCode']]['comment'] = match.groupdict()['comment']


    def parseColumnComment(self,sql):
        regex = re.compile("^\s*COMMENT\s+ON\s+COLUMN\s+(?P<tableCode>\w+)\.(?P<columnCode>\w+)\s+IS\s+'(?P<comment>.*)';$")
        match = regex.match(sql)

        data = {'code': match.groupdict()['columnCode'], 'comment': match.groupdict()['comment']}

        if self.list_column_update.get(match.groupdict()['tableCode']) == None:
            self.list_column_update[match.groupdict()['tableCode']] = [data]
        else:
            self.list_column_update[match.groupdict()['tableCode']].append(data)

if __name__ ==  '__main__':
        # ddl = DDLHandler()
        # text = 'CREATE TABLE STUDENTS( SNO CHAR(10), SNAME VARCHAR2(20), AGE NUMBER(3), SCHOOLDATE DATE, GRADE NUMBER(1) DEFAULT 1, CLAZZ NUMBER(2), EMAIL VARCHAR2(100) );'
        # ddl.parseTableCreate(text)
        # print(ddl.list_column_add)

        # text = "COMMENT ON COLUMN BANNER.NAME IS 'COMMENT';"
        # regex = re.compile("^\s*COMMENT\s+ON\s+COLUMN\s+(?P<tableCode>\w+)\.(?P<columnCode>\w+)\s+IS\s+'(?P<comment>.*)';$")
        # match = regex.match(text)
        # print(match.groupdict())
        text = 'CREATE     TABLE    NOTE'

        print(re.sub('\s+',' ',text))
        # if re.match('^\s*' + 'CREATE TABLE', text.replace('\s+',' ')):
        #     print(True)
        # else:
        #     print(False)


    DDL文件：
    
--创建表结构
CREATE      TABLE STUDENT(
    SNO CHAR(10),
    SNAME VARCHAR2(20),
    AGE NUMBER(3),
    SCHOOLDATE DATE,
    GRADE NUMBER(1) DEFAULT 1,
    CLAZZ NUMBER(2),
    EMAIL VARCHAR2(100)
);
CREATE TABLE STUDENTS( SNO CHAR(10), SNAME VARCHAR2(20), AGE NUMBER(3), SCHOOLDATE DATE, GRADE NUMBER(1) DEFAULT 1, CLAZZ NUMBER(2), EMAIL VARCHAR2(100) );
--删除表结构
DROP TABLE STUDENT;
DROP TABLE STUDENTS;
--修改表的名称
RENAME BANK TO SXTBANK;
--向表中添加注释
COMMENT ON TABLE STUDENT is 'banner';
-------------------修改表的结构
--添加列
ALTER TABLE STUDENT ADD(ADDRESS VARCHAR2(100));
ALTER TABLE STUDENT ADD(CLASS VARCHAR2(100));
--删除列
ALTER TABLE STUDENT DROP COLUMN ADDRESS;
ALTER TABLE STUDENT DROP COLUMN AGE;
ALTER TABLE STUDENTS DROP COLUMN SCHOOLDATE;
--修改列
ALTER TABLE STUDENT MODIFY(EMAIL VARCHAR2(200));
ALTER TABLE STUDENT MODIFY(CLASS VARCHAR2(200));
--向列添加注释
COMMENT ON COLUMN STUDENT.sname is 'the name of employees';
 
   测试脚本：


    
from PDMHandler import PDMHandler
from DDLHandler import DDLHandler

if __name__ == '__main__':

    ddl = DDLHandler()
    pmd = PDMHandler()

    #创建表
    if len(ddl.list_table_add) != 0:
        for sql_table_add in ddl.list_table_add:
            PDMHandler.addTable(pmd, sql_table_add)

    #修改表
    if len(ddl.list_table_update) != 0:
        for key in ddl.list_table_update.keys():
            PDMHandler.updateTable(pmd, key, ddl.list_table_update[key])

    #增加列
    if len(ddl.list_column_add) != 0:
        for key in ddl.list_column_add.keys():
            PDMHandler.addColumn(pmd, key, ddl.list_column_add[key])

    #修改列
    if len(ddl.list_column_update) != 0:
        for key in ddl.list_column_update.keys():
            PDMHandler.updateColumn(pmd, key, ddl.list_column_update[key])

    #删除列
    if len(ddl.list_column_del) != 0:
        for key in ddl.list_column_del.keys():
            PDMHandler.delColumn(pmd, key, ddl.list_column_del[key])

    #删除表
    if len(ddl.list_table_del) != 0:
        PDMHandler.delTable(pmd, ddl.list_table_del)

    #写入文件
    with open('package_tmp.pdm', 'w',encoding = 'utf-8') as xmlfile:
        pmd.ph.writexml(xmlfile, addindent=' ' * 2, newl='\n', encoding='utf-8')
    
   测试通过，待改进
 


                

        

        

    

  


    

      

        

            

              
                
                  happyzwh
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
Python—pdm解析

				
			

			

				

					蓝魔的博客
				

				

					08-09
					
					1113
					
				

			

		

		

			
				
Python 解析pdm文件

			
		

	



                

              
                



	

		

			

				
					
python 文件 解析ddl_Python ddlparse包_程序模块 - PyPI - Python中文网

				
			

			

				

					weixin_35971787的博客
				

				

					01-28
					
					629
					
				

			

		

		

			
				
fromddlparse.ddlparseimportDdlParsesample_ddl="""CREATE TABLE My_Schema.Sample_Table (Id integer PRIMARY KEY COMMENT 'User ID',Name varchar(100) NOT NULL COMMENT 'User name',Total bigint NOT NULL,Avg ...

			
		

	



                


  
              

                


	

		

			

				
					
python解析DDL操作PDM

				
			

			

				

					11-23
				

			

		

		

			
				
python       解析        DDL         操作      PDM

			
		

	





	

		

			

				
					
超详细Python教程——SQL详解之DDL

				
			

			

				

					月流霜的专栏
				

				

					08-12
					
					983
					
				

			

		

		

			
				
四个关键的实体分别是学院、老师、学生和课程，其中，学生跟学院是从属关系，这个关系从数量上来讲是多对一关系，因为一个学院可以有多名学生，而一个学生通常只属于一个学院；对于自增字段 AUTO_INCREMENT，如果使用 MySQL 5.x 版本要注意自增字段的回溯问题，当然这个问题在 MySQL 8.x 中已经得到了很好的解决，当然，MySQL 8.x 还有很多其他的好处，不管是功能还是性能上都有很多的优化和调整，因此强烈推荐大家使用 MySQL 8.x 版本。在创建表的时候，可以自行选择底层的存储引擎。

			
		

	



		

			
		



	

		

			

				
					
PDMHandler:一个由python编写的工具类，用于处理sybase PowerDesigner数据文件(.pdm)。 目前，它能够处理电源设计器文件中的物理图

				
			

			

				

					06-04
				

			

		

		

			
				
PDM处理程序
用于处理 sybase PowerDesigner 数据文件 (.pdm) 的工具类。 目前，它能够处理 .pdm 中的 PhysicalDiagram。
源代码介绍。
PDMHandler.py
 PDMHandler 的类实现。 使用以下命令查看帮助文档（抱歉我输入的是中文）： 
$ echo " import PDMHandler; help(PDMHandler); " | python
测试 PDM 文件
PowerDesigner 模型文件 (.pdm) 准备在 [repodir]/src/testpdm 中使用这些作为输入参数来测试 example1.py
 注意：(.pdm) 文件来自 PowerDesigner15 目录 [Sybase\PowerDesigner 15\Examples]
示例1.py
 它是 PDMHandler 类的一个用例，阅读它作

			
		

	





	

		

			

				
					
python检测MySQL的DDL语句正确性

				
			

			

				

					qq_29848559的博客
				

				

					09-20
					
					2133
					
				

			

		

		

			
				
1.Inception库

  Inception是一个开源系统，每个人或者每个公司都可以自由使用, 可以用于审核SQL语句的合法性。

  Inception使用说明:https://inception-document.readthedocs.io/zh_CN/latest/


/*--user={username};--password={password};--host={host};--check=1;--port={port};*/
inception_magic_start;
...

			
		

	





	

		

			

				
					
python脚本 通过cmd操作数据库

				
			

			

				

					06-04
				

			

		

		

			
				
Python脚本通过CMD操作数据库是一种常见的自动化任务处理方式，尤其在数据库管理、数据迁移或定期备份等场景下非常实用。本篇文章将详细讲解如何利用Python和命令行接口（CMD）来实现MySQL数据库的操作。  首先，...

			
		

	





	

		

			

				
					
python小工具-sqlserver ddl转换为mysql规范ddl

				
			

			

				

					02-14
				

			

		

		

			
				
图形化实现sqlserver转换为mysql ddl（需字段注释） 应用于数据库、新老系统迁移，提升开发效率。

			
		

	





	

		

			

				
					
Python库 | simple-ddl-parser-0.2.1a0.tar.gz

				
			

			

				

					04-15
				

			

		

		

			
				
资源分类：Python库 所属语言：Python 资源全名：simple-ddl-parser-0.2.1a0.tar.gz 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059

			
		

	





	

		

			

				
					
mysql数据库表字段替换问题之python解决办法(后来直接用了sql解决，其中py程序有个小问题暂时还没解决)

				
			

			

				

					Tony 's Blog 只为精进而生
				

				

					04-08
					
					3331
					
				

			

		

		

			
				
本篇会提供两种解决方案，当然py部分，可能比较麻烦。不过，我想这个部分今后也会使用到，所以还是贴出来留个纪念，以鼓励后人。对于长期性能监控来说，使用shell进行自动话性能监控，只是我对游戏自动化构想的第一步。而既然现在，可以产生如此多的数据，如何更为高效的管理和分析这些数据应该下个阶段需要着重讨论的问题。本篇后，本人也会花更多经历在这个方面进行研究，欢迎高手指证，嘿嘿！以下提供Py部分解决方

			
		

	





	

		

			

				
					
使用Python解析MySQL数据库中的DDL语句

				
			

			

				

					weixin_42510222的博客
				

				

					08-10
					
					52
					
				

			

		

		

			
				
目录简介DDL（Data Definition Language）的概述解析DDL语句的背景和用途使用Python解析DDL语句的过程
数据库连接提取DDL语句结构化解析DDL语句
解析表的创建语句（CREATE TABLE）解析修改表结构语句（ALTER TABLE）解析删除表语句（DROP TABLE）展示解析结果实例...

			
		

	





	

		

			

				
					
Python库 | ddlparse-1.1.0-py3-none-any.whl

				
			

			

				

					04-21
				

			

		

		

			
				
资源分类：Python库
所属语言：Python
使用前提：需要解压
资源全名：ddlparse-1.1.0-py3-none-any.whl
资源来源：官方
安装方法：https://lanzao.blog.csdn.net/article/details/101784059

			
		

	





	

		

			

				
					
PDM解析后台代码

				
			

			

				

					01-23
				

			

		

		

			
				
解析 pdm文件 转换成 sql 数据库脚本 和 cs 实体类 文件

			
		

	





	

		

			

				
					
ddlparse：DDL parase并转换为BigQuery JSON模式和DDL语句

				
			

			

				

					01-28
				

			

		

		

			
				
DDL解析
 DDL parase并转换为BigQuery JSON模式和DDL语句模块，可在Python中使用。
特征
DDL解析并获取表架构信息。
 当前，仅支持CREATE TABLE语句。
 转换为和。
 支持的数据库是MySQL / MariaDB，PostgreSQL，Oracle，Redshift。
需求
Python> = 3.5
安装
安装
点安装： 
$ pip install ddlparse
 命令安装： 
$ python setup.py install
更新资料
点更新： 
$ pip install ddlparse --upgrade
用法
例
import json
from ddlparse import DdlParse
sample_ddl = """
CREATE TABLE My_Schema.Sample_Table (
  Id integer PRIMARY KEY COMMENT 'User ID',
  Name varchar(100) NOT NULL COMMENT 'User name',
  Total bigint N

			
		

	





	

		

			

				
					
python 文件 解析ddl_python读取excel生成HiveDDL

				
			

			

				

					weixin_33917474的博客
				

				

					01-17
					
					648
					
				

			

		

		

			
				
需求说明：数仓建模过程中，一般会在excel中先将数仓各层的表和字段都梳理好，然后再建表和开发。该程序可以方便的利用excel中的字段名、字段类型、字段描述等信息生成HiveDDL语句数据示例：在这里插入图片描述在这里插入图片描述输出示例：在这里插入图片描述代码：import osimport sysimport xlrd# 要读取的excel的名称excel_name = sys.argv[1]...

			
		

	





	

		

			

				
					
python 文件 解析ddl_在python中使用cx_Oracle使用PL / SQL和DML / DDL解析SQL文件

				
			

			

				

					weixin_36156538的博客
				

				

					01-17
					
					202
					
				

			

		

		

			
				
I have an SQL file which I want to parse and execute in oracle using cx_Oracle python library. The SQL file contains both classic DML/DDL and PL/SQL, eg. it can look like this:create.sql:-- This is so...

			
		

	





	

		

			

				
					
Python变量解析

				
			

			

				

					Gordennizaicunzai的博客
				

				

					04-04
					
					844
					
				

			

		

		

			
				
1、Python变量名可以包含字母、数字和下划线（_），变量不能以数字开头。
2、Python数据类型不需要指定type。
3、Python变量的“变”是指向，id。Python 2.7.3 (default, Apr 10 2012, 23:31:26) [MSC v.1500 32 bit (Intel)] on win32
Type "copyright", "credits" or "

			
		

	





	

		

			

				
					
用python做DDL的静态分析

				
			

			

				

					tlxamulet的博客
				

				

					07-06
					
					299
					
				

			

		

		

			
				
顺带说一个小窍门，就是DDLParser有一个silent=True选项，默认是关闭的，跳过语法错。但如果发现有的DDL解析不出来，可以临时打开该选项，看看究竟是哪一处语法不支持，非常快捷。最近在用python做DDL SQL的分析，用的是simple_ddl_parser1.5.1。遇到了一些问题，记录一下。这种情况需要我们对DDL做一些预处理，才能获得表结构的信息。会被输出为我们需要的t_testtbl。

			
		

	





	

		

			

				
					
通过pdm转换数据库结构，导出不同数据库的ddl

				
			

			

				

					ff836526942的博客
				

				

					08-29
					
					1067
					
				

			

		

		

			
				
以oracle的ddl为例导出db2ddl 
1.导入任意库的ddl语句



2.转换数据库类型



3.导出ddl语句

			
		

	





	

		

			

				
					
Python 获取ORACLE数据库 DDL执行结果

					
最新发布

				
			

			

				

					09-11
				

			

		

		

			
				
在Python中，获取Oracle数据库的DDL（数据定义语言）执行结果通常涉及使用ODBC (Oracle Data Access Components)、cx_Oracle库或者是通过Python的psycopg2库（针对PostgreSQL，但也可用于连接Oracle，因为Oracle支持...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值