def METHOD_NAME(instance, catalog_name,
                               exclude_field_names=None,
                               include_field_names=None):
    """Retrieves all the values of metadata columns in the catalog for
    wildcard searches
    :param instance: the object to retrieve metadata/values from
    :param catalog_name: the catalog to retrieve metadata from
    :param exclude_field_names: field names to exclude from the metadata
    :param include_field_names: field names to include, even if no metadata
    :returns: list of unified searchable text tokes
    """
    entries = set()
    # Fields to include/exclude
    include = include_field_names or []
    exclude = exclude_field_names or []
    # Get the metadata fields from this instance and catalog
    catalog = api.get_tool(catalog_name)
    metadata = get_metadata_for(instance, catalog)
    for key, brain_value in metadata.items():
        if key in exclude:
            continue
        elif key in include:
            # A metadata field already
            include.remove(key)
        instance_value = api.safe_getattr(instance, key, None)
        parsed = api.to_searchable_text_metadata(brain_value or instance_value)
        entries.add(parsed)
    # Include values from additional fields
    for field_name in include:
        field_value = api.safe_getattr(instance, field_name, None)
        field_value = api.to_searchable_text_metadata(field_value)
        entries.add(field_value)
    # Extend metadata entries with pluggable text providers
    for name, adapter in getAdapters((instance, catalog),
                                     IListingSearchableTextProvider):
        value = adapter()
        if isinstance(value, (list, tuple)):
            values = map(api.to_searchable_text_metadata, value)
            entries.update(values)
        else:
            value = api.to_searchable_text_metadata(value)
            entries.add(value)
    # Remove empties
    entries = filter(None, entries)
    # return a list of searchable text tokes
    return list(entries)