def _read_sync(self):

        # type of response
        # decode body char with flag continue ( Header already read )
        response_type = self._decode_field(FIELD_CHAR)
        if not isinstance(response_type, str):
            response_type = response_type.decode()
        res = []
        if response_type == 'n':
            self._append(FIELD_CHAR)
            super(CommandMessage, self).fetch_response(True)
            # end Line \x00
            return None
        elif response_type == 'r' or response_type == 'w':
            res = [self._read_record()]
            self._append(FIELD_CHAR)
            # end Line \x00
            _res = super(CommandMessage, self).fetch_response(True)
            if response_type == 'w':
                res = [res[0].oRecordData['result']]
        elif response_type == 'a':
            self._append(FIELD_STRING)
            self._append(FIELD_CHAR)
            res = [super(CommandMessage, self).fetch_response(True)[0]]
        elif response_type == 'l':
            self._append(FIELD_INT)
            list_len = super(CommandMessage, self).fetch_response(True)[0]

            for n in range(0, list_len):
                res.append(self._read_record())

            # async-result-type can be:
            # 0: no records remain to be fetched
            # 1: a record is returned as a result set
            # 2: a record is returned as pre-fetched to be loaded in client's
            #       cache only. It's not part of the result set but the client
            #       knows that it's available for later access
            cached_results = self._read_async_records()
            # cache = cached_results['cached']
        else:
            # this should be never happen, used only to debug the protocol
            msg = b''
            self._orientSocket._socket.setblocking(0)
            m = self._orientSocket.read(1)
            while m != "":
                msg += m
                m = self._orientSocket.read(1)

        return res