* a POJO.
   *
   * @param input The future to transform
   * @param function A Function to transform the results of the provided future to the results of
   *     the returned future.
   * @param executor Executor to run the function in.
   * @return A future that holds result of the transformation.
   * @since 9.0 (in 2.0 as {@code compose})
   */

                }
                response = builder.execute().actionGet(fessConfig.getIndexIndexTimeout());
            }
            final Result result = response.getResult();
            return result == Result.CREATED || result == Result.UPDATED;
        } catch (final OpenSearchException e) {
            throw new SearchEngineClientException("Failed to store: " + obj, e);
        }
    }

			"SELECT * FROM `users` WHERE NOT ((`users`.`id` = ? AND `age` > ?) OR `score` < ?)",
			[]interface{}{"1", 18, 100},
		},
	}

	for idx, result := range results {
		t.Run(fmt.Sprintf("case #%v", idx), func(t *testing.T) {
			checkBuildClauses(t, result.Clauses, result.Result, result.Vars)
		})
	}

        String result = ace.toString();

        assertTrue(result.startsWith("Allow "));
        // Hexdump.toHexString produces uppercase hex
        assertTrue(result.toLowerCase().contains("0x001200a9"));
        // ACE.toString() outputs "Direct    " with 4 spaces
        assertTrue(result.contains("Direct"));
        assertTrue(result.contains("This folder only"));
    }

    @Test

		t.Errorf("Should not raise any error, but got %v", err)
	}

	if result.Age.Int64 != 18 {
		t.Errorf("should update age to 18")
	}

	var result2 ScannerValuerStruct
	if err := DB.First(&result2, result.ID).Error; err != nil {
		t.Errorf("got error %v when query with %v", err, result.ID)
	}

///

Whenever a new request arrives, **FastAPI** will take care of:

* Calling your dependency ("dependable") function with the correct parameters.
* Get the result from your function.
* Assign that result to the parameter in your *path operation function*.

```mermaid
graph TB

common_parameters(["common_parameters"])
read_items["/items/"]
read_users["/users/"]

        if (!attrList.isEmpty()) {
            consumer.accept(attrList.get(0));
        }
    }

    /**
     * Gets a list of attribute values from search results.
     *
     * @param result the list of search results
     * @param name the attribute name
     * @return a list of attribute values
     */

   * contains {@link Double#NEGATIVE_INFINITY} and not {@link Double#NaN} then the result is {@link
   * Double#NEGATIVE_INFINITY}. If it contains {@link Double#POSITIVE_INFINITY} and finite values
   * only then the result is the lowest finite value. If it contains {@link
   * Double#POSITIVE_INFINITY} only then the result is {@link Double#POSITIVE_INFINITY}.
   *

If you are using third party libraries that tell you to call them with `await`, like:

```Python
results = await some_library()
```

Then, declare your *path operation functions* with `async def` like:

```Python hl_lines="2"
@app.get('/')
async def read_results():
    results = await some_library()
    return results
```

/// note

You can only use `await` inside of functions created with `async def`.

///

/**
 * API action for admin elevate word management.
 * Provides RESTful API endpoints for managing elevate word settings in the Fess search engine.
 * Elevate words boost specific search terms to appear higher in search results.
 */
public class ApiAdminElevatewordAction extends FessApiAdminAction {

    private static final Logger logger = LogManager.getLogger(ApiAdminElevatewordAction.class);