HYTOS

                # Get a cursor object

                cursor = conn.cursor()

                join Symbol b on a.Symbol_UID=b.UID \

                cursor.execute(sql)

                return cursor.fetchall()

            # Catch the exception

                # Get a cursor object

                cursor = conn.cursor()

                cursor.execute(sql)

                return cursor.fetchall()

            # Catch the exception

                # Get a cursor object

                cursor = conn.cursor()

                cursor.execute(sql)

                return cursor.fetchall()

            # Catch the exception

                sql = "delete from Components where Drawings_UID='{}'".format(drawing_uid)

                cursor.execute(sql)

                for item in items:

                    sql = item.toSql()

                    if type(sql) is list:

        @author     humkyung

        @date       2018.11.03

        """

        res = []

            # Creates or opens a file called mydb with a SQLite3 DB

            dbPath = os.path.join(self.getCurrentProject().getDbFilePath(), AppDocData.DATABASE)

            conn = sqlite3.connect(dbPath)

        # Catch the exception

        except Exception as ex:

            # Roll back any change if something goes wrong

            message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        return res

            db_items = [item for item in items if issubclass(type(item), QEngineeringAbstractItem) and type(item) is not QGraphicsBoundingBoxItem and type(item) is not QEngineeringErrorItem]

            db_items.extend([line for line in appDocData.tracerLineNos if type(line) is QEngineeringTrimLineNoTextItem])

            self.resultStr = SaveWorkCommand.save_to_xml()

                        child.setCheckState(0, Qt.Checked)

                        break

                        self.loadRecognitionResultFromXml(path)

                self.changeViewCheckedState(True)

        except Exception as ex:

            message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)

        #cv2.destroyAllWindows()

        return (True, mergedOtherLine)

        from xml.etree.ElementTree import Element, SubElement, dump, ElementTree, parse

        from EngineeringRunItem import QEngineeringRunItem

        from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem

        try:

            symbols = []

            lines = []

            maxValue = len(components)

            self.progress.setMaximum(maxValue)

            """ parsing all symbols """

            for symbol in [component for component in components if component['SymbolType_UID'] != '-1']:

                if item is not None:

                    item.transfer.onRemoved.connect(self.itemRemoved)

                    symbols.append(item)

            QApplication.processEvents()

            # parse texts

                item = QEngineeringTextItem.from_database(text)

                if item is not None:

                    item.uid = text['UID']

            QApplication.processEvents()

            # note

                item = QEngineeringTextItem.from_database(note)

                if item is not None:

                    item.uid = note['UID']

            QApplication.processEvents()

                item = QEngineeringLineItem.from_database(line)

                if item:

                    item.transfer.onRemoved.connect(self.itemRemoved)

            QApplication.processEvents()

                item = QEngineeringUnknownItem.from_database(unknown)

                item.transfer.onRemoved.connect(self.itemRemoved)

                if item is not None:

            #    self.addSvgItemToScene(item)

            #    self.itemTreeWidget.addTreeItem(self.itemTreeWidget.root, item)

                line_no = QEngineeringLineNoTextItem.from_database(component)

                if line_no is None: continue

                self.progress.setValue(self.progress.value() + 1)

            QApplication.processEvents()

                line_no = QEngineeringTrimLineNoTextItem()

                line_no.uid = uuid.UUID(component['UID'], version=4)

                for run_item in line_run.items:

                    if issubclass(type(run_item), SymbolSvgItem): self.itemTreeWidget.addTreeItem(line_no_tree_item, run_item)

                self.progress.setValue(self.progress.value() + 1)

                item = QEngineeringVendorItem.from_database(component)

                item.transfer.onRemoved.connect(self.itemRemoved)

                self.graphicsView.scene.addItem(item)

        import uuid

        try:

            self._connected_at = QEngineeringAbstractItem.CONNECTED_AT_PT if record['Connected_At'] == '0' else QEngineeringAbstractItem.CONNECTED_AT_BODY

            connectPointStr = [record['X'], record['Y']]

            sceneConnectPointStr = [record['X'], record['Y']]

            self.connectPoint = (float(connectPointStr[0]), float(connectPointStr[1]))

            self.sceneConnectPoint = (float(sceneConnectPointStr[0]), float(sceneConnectPointStr[1]))

        sql = 'insert or replace into EQUIPMENT_DATA_LIST({}) values({})'.format(','.join(cols), ','.join(values))

        res.append((sql, (tuple(param),)))

                'SpecialItemTypes_UID', 'OriginIndex']

        values = ['?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?']

        param = [(str(self.uid), str(appDocData.activeDrawing.UID), str(self.dbUid), self.loc[0], self.loc[1], self.size[0], self.size[1], str(self.angle), 

        sql = 'insert or replace into INSTRUMENT_DATA_LIST({}) values({})'.format(','.join(cols), ','.join(values))

        res.append((sql, tuple(param)))

                'SpecialItemTypes_UID']

        values = ['?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?']

        param = [(str(self.uid), str(appDocData.activeDrawing.UID), str(self.dbUid), self.loc[0], self.loc[1], self.size[0], self.size[1], str(self.angle), 

            values = ['?', '?', '?', '?']

            params = []

            for assoc in self.associations():

        # save connectors to database

        if self.connectors:

            print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))

    @staticmethod 

        """ get line from database """

        import uuid

        from AppDocData import AppDocData

        item = None

        try:

            app_doc_data = AppDocData.instance()

            connectors = app_doc_data.get_component_connectors(uid)

            startPoint = [float(connectors[0]['X']), float(connectors[0]['Y'])]

            endPoint = [float(connectors[1]['X']), float(connectors[1]['Y'])]

            item = QEngineeringLineItem(vertices=[startPoint, endPoint], uid=uid)

            item.setVisible(False)

            ## assign area

                for area in app_doc_data.getAreaList():

                    if area.contains(startPoint) and area.contains(endPoint):

                        item.area = area.name

                        break

            else:

            ## up to here

            if connectors:

                iterIndex = 0

                str(self.uid), index, connector.connectPoint[0], connector.connectPoint[1],\

                str(connector.connectedItem.uid) if connector.connectedItem else None,\

                str(connector._connected_at)))

        sql = 'insert or replace into Points({}) values({})'.format(','.join(cols), ','.join(values))

        res.append((sql, tuple(params)))

        # up to here

        return res

        item = None

        try:

            x = float(component['X'])

            y = float(component['Y'])

            height = float(component['Height']) if component['Height'] is not None else 0

            angle = float(component['Rotation']) if component['Rotation'] is not None else 0

            text = component['Value']

            item = TextItemFactory.instance().createTextItem(textInfo)

            if item is not None:

                for key in item._properties.keys():

                    item._properties[key] = key.parse_value(component[key.Attribute])

        sql = 'insert or replace into VALVE_DATA_LIST({}) values({})'.format(','.join(cols), ','.join(values))

        res.append((sql, tuple(param)))

                'SpecialItemTypes_UID']

        values = ['?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?']

        param = [(str(self.uid), str(appDocData.activeDrawing.UID), str(self.dbUid), self.loc[0], self.loc[1], self.size[0], self.size[1], str(self.angle), 

        return visited

    '''

        @brief      parse xml code

        @author     humkyung

                    item.loc = [x, y]

                    item.size = [width, height]

                    item.angle = angle

            # set uid and owner of item

            if item is not None:

            app_doc_data = AppDocData.instance()

            connectors = app_doc_data.get_component_connectors(component['UID'])

            points = [[float(connector['X']), float(connector['Y'])] for connector in connectors]

                if lineIndicator[0] == 'True':

                    item = QEngineeringUnknownItem(points, 'True', lineIndicator[1], [round(float(lineIndicator[2])), round(float(lineIndicator[3])), round(float(lineIndicator[4])), round(float(lineIndicator[5]))])

                elif lineIndicator[0] == 'Match':

        res = []

        appDocData = AppDocData.instance()

        rect = self.sceneBoundingRect()

        sql = 'insert or replace into Components({}) values({})'.format(','.join(cols), ','.join(values))

        res.append((sql, tuple(param)))

        sql = 'insert or replace into Points({}) values({})'.format(','.join(cols), ','.join(values))

        res.append((sql, tuple(params)))

        return res

    '''

        sql = 'insert or replace into VALVE_DATA_LIST({}) values({})'.format(','.join(cols), ','.join(values))

        res.append((sql, tuple(param)))

                'SpecialItemTypes_UID', 'OriginIndex']

        values = ['?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?']

        param = [(str(self.uid), str(appDocData.activeDrawing.UID), str(self.dbUid), self.loc[0], self.loc[1], self.size[0], self.size[1], str(self.angle), 

            values = ['?', '?', '?', '?']

            params = []

            for assoc in self.associations():

        # save connectors to database

        if self.connectors:

        return node 

        """ create a item related to given component from database """

        import uuid

        from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

            app_doc_data = AppDocData.instance()

            uid = component['UID']

            angle = float(component['Rotation'])

            origin = [float(x) for x in component['OriginalPoint'].split(',')]

            connPts = []

                for conn_pt in component['ConnectionPoint'].split('/'):

                    tokens = conn_pt.split(',')

                    connPts.append(('AUTO', float(tokens[0]), float(tokens[1]), '0') if len(tokens) == 2 else \

            owner = component['Owner'] if component['Owner'] is not None and component['Owner'] != 'None' else None

            hasInstrumentLabelNode = component['HasInstrumentLabel']

            flipLabelNode = component['Flip']

            project = app_doc_data.getCurrentProject()

            svgFilePath = os.path.join(project.getSvgFilePath(), _type, name + '.svg')

                    return None

                for key in item._properties.keys():

                ## assign area

                areaNode = component['Area']

                            item.area = area.name

                            break

                else:

                ## up to here

                connectors = app_doc_data.get_component_connectors(uid)

                currentPointModeIndex = component['OriginIndex']

                if currentPointModeIndex is not None:

        except Exception as ex:

            from App import App 

            message = 'error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)

        else:

            return uuid.UUID(text, version=4) if text and SymbolProp.is_valid_uuid(text) else text if text else ''

    def toXml(self):

        """ generate xml code for symbol property """

        from xml.etree.ElementTree import Element, SubElement, dump, ElementTree

        self.IsProp = None

    @staticmethod

    def fromXml(node):

        """ generate SymbolAttr instance from xml node """

        import uuid