// GetIdentityFieldValuesMapFromValues get identity map from fields
func GetIdentityFieldValuesMapFromValues(ctx context.Context, values []interface{}, fields []*Field) (map[string][]reflect.Value, [][]interface{}) {
	resultsMap := map[string][]reflect.Value{}
	results := [][]interface{}{}

	for _, v := range values {
		rm, rs := GetIdentityFieldValuesMap(ctx, reflect.Indirect(reflect.ValueOf(v)), fields)
		for k, v := range rm {

     * @param boost the boost value
     * @param readings the list of readings
     * @param fields the list of fields
     * @param tags the list of tags
     * @param roles the list of roles
     */
    public ElevateWord(final String elevateWord, final float boost, final List<String> readings, final List<String> fields,
            final List<String> tags, final List<String> roles) {
        this.elevateWord = elevateWord;

    /**
     * Parses a document and extracts suggest items based on the provided fields and converters.
     *
     * @param document The document to parse, represented as a map of field names to values.
     * @param fields The fields to extract from the document.
     * @param tagFieldNames The names of the fields that contain tags.
     * @param roleFieldName The name of the field that contains role information.

				if idx.Option == "" {
					idx.Option = index.Option
				}

				idx.Fields = append(idx.Fields, index.Fields...)
				sort.Slice(idx.Fields, func(i, j int) bool {
					return idx.Fields[i].Priority < idx.Fields[j].Priority
				})
			}
		}
	}
	for _, index := range indexes {
		if index.Class == "UNIQUE" && len(index.Fields) == 1 {
			index.Fields[0].Field.UniqueIndex = index.Name
		}
	}
	return indexes
}

     * @param id the document ID to retrieve
     * @param fields the fields to include in the response (null for all fields)
     * @return the document as a map of field names to values, or null if not found
     */
    public Map<String, Object> getDocument(final SearchEngineClient searchEngineClient, final String id, final String[] fields) {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();

        Field[] fields = FessHtmlPath.class.getDeclaredFields();
        for (Field field : fields) {
            int modifiers = field.getModifiers();
            if (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers)) {
                if (field.getType().equals(HtmlNext.class)) {
                    HtmlNext htmlNext = (HtmlNext) field.get(null);

    public void addField(final String key, final Object value) {
        fields.put(key, value);
    }

    public String getLogMessage() {
        return getUrl();
    }

    @Override
    public Map<String, Object> toSource() {
        final Map<String, Object> sourceMap = super.toSource();
        if (fields != null) {
            sourceMap.putAll(fields);
        }
        return sourceMap;
    }

    @Override

            <type>Phase</type>
            <multiplicity>*</multiplicity>
          </association>
        </field>
      </fields>
    </class>
    <class>
      <name>Phase</name>
      <version>1.0.0+</version>
      <description>A phase mapping definition.</description>
      <fields>
        <field>
          <name>id</name>
          <required>true</required>
          <version>1.0.0+</version>

          </association>
        </field>
      </fields>
    </class>
    <class>
      <name>Profile</name>
      <version>1.0.0</version>
      <description><![CDATA[
        Modifications to the build process which is keyed on some
        sort of environmental parameter.
      ]]></description>
      <fields>
        <field>
          <name>id</name>
          <required>true</required>

			mapValue[column] = nil
		}
	}
}

func (db *DB) scanIntoStruct(rows Rows, reflectValue reflect.Value, values []interface{}, fields []*schema.Field, joinFields [][]*schema.Field) {
	for idx, field := range fields {
		if field != nil {
			values[idx] = field.NewValuePool.Get()
		} else if len(fields) == 1 {
			if reflectValue.CanAddr() {
				values[idx] = reflectValue.Addr().Interface()
			} else {