def __select_wd_item(self):
        """
        The most likely WD item QID should be returned, after querying WDQ for all values in core_id properties
        :return: Either a single WD QID is returned, or an empty string if no suitable item in WD
        """
        qid_list = set()
        conflict_source = {}
        if self.mrh:
            exact_qid = self.mrh.mrt_qids['http://www.w3.org/2004/02/skos/core#exactMatch']
            mrt_pid = self.mrh.mrt_pid
        else:
            # This is a `hack` for if initializing the mapping relation helper fails. We can't determine the
            # mapping relation type PID or the exact match QID. If we set mrt_pid to "Pxxx", then no qualifier will
            # ever match it (and exact_qid will never get checked), and so what happens is exactly what would
            # happen if the statement had no mapping relation qualifiers
            exact_qid = "Q0"
            mrt_pid = "PXXX"

        for statement in self.data:
            wd_property = statement.get_prop_nr()

            # only use this statement if mapping relation type is exact, or mrt is not specified
            mrt_qualifiers = [q for q in statement.get_qualifiers() if q.get_prop_nr() == mrt_pid]
            if (len(mrt_qualifiers) == 1) and (mrt_qualifiers[0].get_value() != int(exact_qid[1:])):
                continue

            # TODO: implement special treatment when searching for date/coordinate values
            data_point = statement.get_value()
            if isinstance(data_point, tuple):
                data_point = data_point[0]

            core_props = self.core_props
            if wd_property in core_props:
                tmp_qids = set()
                # if mrt_pid is "PXXX", this is fine, because the part of the SPARQL query using it is optional
                query = statement.sparql_query.format(mrt_pid=mrt_pid, pid=wd_property, value=data_point)
                results = WDItemEngine.execute_sparql_query(query=query, endpoint=self.sparql_endpoint_url)

                for i in results['results']['bindings']:
                    qid = i['item_id']['value'].split('/')[-1]
                    if ('mrt' not in i) or ('mrt' in i and i['mrt']['value'].split('/')[-1] == exact_qid):
                        tmp_qids.add(qid)

                qid_list.update(tmp_qids)

                # Protocol in what property the conflict arises
                if wd_property in conflict_source:
                    conflict_source[wd_property].append(tmp_qids)
                else:
                    conflict_source[wd_property] = [tmp_qids]

                if len(tmp_qids) > 1:
                    raise ManualInterventionReqException(
                        'More than one WD item has the same property value', wd_property, tmp_qids)

        if len(qid_list) == 0:
            self.create_new_item = True
            return ''

        if not __debug__:
            print(qid_list)

        unique_qids = set(qid_list)
        if len(unique_qids) > 1:
            raise ManualInterventionReqException('More than one WD item has the same property value',
                                                 conflict_source, unique_qids)
        elif len(unique_qids) == 1:
            return list(unique_qids)[0]
The most likely WD item QID should be returned, after querying WDQ for all values in core_id properties
        :return: Either a single WD QID is returned, or an empty string if no suitable item in WD