def query(self, name):
     """Blindly query the schema by name."""
     log.debug('searching schema for (%s)', name)
     schema = self.schema
     wsdl = self.wsdl()
     if wsdl is None:
         qref = qualify(name, schema.root, schema.tns)
     else:
         qref = qualify(name, wsdl.root, wsdl.tns)
     query = BlindQuery(qref)
     result = query.execute(schema)
     return (result, [])

 def known(self, node):
     """Resolve type referenced by @xsi:type."""
     ref = node.get('type', Namespace.xsins)
     if ref is None:
         return None
     qref = qualify(ref, node, node.namespace())
     query = BlindQuery(qref)
     return query.execute(self.schema)

 def qualify(self, name):
     """
     Qualify the name as either:
       - plain name
       - ns prefixed name (eg: ns0:Person)
       - fully ns qualified name (eg: {http://myns-uri}Person)
     @param name: The name of an object in the schema.
     @type name: str
     @return: A qualified name.
     @rtype: qname
     """
     m = self.altp.match(name)
     if m is None:
         return qualify(name, self.wsdl.root, self.wsdl.tns)
     else:
         return (m.group(4), m.group(2))

 def find(self, name, resolved=True):
     """
     Get the definition object for the schema object by name.
     @param name: The name of a schema object.
     @type name: basestring
     @param resolved: A flag indicating that the fully resolved type
         should be returned.
     @type resolved: boolean
     @return: The found schema I{type}
     @rtype: L{xsd.sxbase.SchemaObject}
     """
     log.debug('searching schema for (%s)', name)
     qref = qualify(name, self.schema.root, self.schema.tns)
     query = BlindQuery(qref)
     result = query.execute(self.schema)
     if result is None:
         log.error('(%s) not-found', name)
         return None
     log.debug('found (%s) as (%s)', name, Repr(result))
     if resolved:
         result = result.resolve()
     return result

    def known(self, node):
        """ resolve type referenced by @xsi:type """
        ref = node.get("type", Namespace.xsins)
        if ref is None:
            return None
        qref = qualify(ref, node, node.namespace())

        # Originally, this always created a BlindQuery for the qref name so
        # that the schema was always searched. We assume that the schema does
        # not change while unserializing and cache the query results here.

        try:
            lookup_cache = self.schema.NodeResolver__known_cache
        except AttributeError:
            lookup_cache = self.schema.NodeResolver__known_cache = {}

        try:
            return lookup_cache[qref]
        except KeyError:
            query = BlindQuery(qref)
            r = query.execute(self.schema)
            if r is not None:
                lookup_cache[qref] = r
            return r