bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
    }

    public void bool(BoolCall<BoostDocumentRuleCQ> boolLambda) {
        bool(boolLambda, null);
    }

    public void bool(BoolCall<BoostDocumentRuleCQ> boolLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {

	dependGlobalObjectAPI           bool
	dependGlobalAuthNPlugin         bool
	dependGlobalSiteReplicationSys  bool
	dependGlobalNotificationSys     bool
	dependGlobalKMS                 bool
	bucketOnly                      bool
	dependGlobalLambdaTargetList    bool
	dependGlobalIAMSys              bool
	dependGlobalLockServer          bool
	dependGlobalIsDistErasure       bool
	dependGlobalBackgroundHealState bool

    }

    public void bool(BoolCall<KeyMatchCQ> boolLambda) {
        bool(boolLambda, null);
    }

    public void bool(BoolCall<KeyMatchCQ> boolLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
        KeyMatchCQ mustQuery = new KeyMatchCQ();
        KeyMatchCQ shouldQuery = new KeyMatchCQ();
        KeyMatchCQ mustNotQuery = new KeyMatchCQ();
        KeyMatchCQ filterQuery = new KeyMatchCQ();

	var csvRecord []string
	for _, kv := range r.KVS {
		var columnValue string
		switch val := kv.Value.(type) {
		case float64:
			columnValue = jsonFloat(val)
		case string:
			columnValue = val
		case bool, int64:
			columnValue = fmt.Sprintf("%v", val)
		case nil:
			columnValue = ""
		case RawJSON:
			columnValue = string([]byte(val))
		case []interface{}:
			b, err := json.Marshal(val)
			if err != nil {

		if err != nil {
			// Can't fit into int, convert to float.
			v, err := iter.Float()
			return sql.FromFloat(v), err
		}
		return sql.FromInt(v), nil
	case simdjson.TypeBool:
		v, err := iter.Bool()
		if err != nil {
			return nil, err
		}
		return sql.FromBool(v), nil
	case simdjson.TypeNull:
		return sql.FromNull(), nil
	case simdjson.TypeObject, simdjson.TypeArray:
		b, err := iter.MarshalJSON()

	// Create new HTTP listener.
	var listener *httpListener
	listener, listenErrs := newHTTPListener(
		listenCtx,
		srv.Addrs,
		srv.TCPOptions,
	)

	var interfaceFound bool
	for i := range listenErrs {
		if listenErrs[i] != nil {
			listenErrCallback(srv.Addrs[i], listenErrs[i])
		} else {
			interfaceFound = true
		}
	}
	if !interfaceFound {

//
//	e.g. Send the log to a http server
type Target interface {
	String() string
	Endpoint() string
	Stats() types.TargetStats
	Init(ctx context.Context) error
	IsOnline(ctx context.Context) bool
	Cancel()
	Send(ctx context.Context, entry interface{}) error
	Type() types.TargetType
}

type targetsList struct {
	list []Target
	mu   sync.RWMutex
}

func newTargetsList() *targetsList {

from typing import Union

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    price: float
    is_offer: Union[bool, None] = None


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):

from fastapi import FastAPI
from pydantic import BaseModel
from typing import Optional

app = FastAPI()


class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = Optional[None]


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Optional[str] = None):

# 추가 데이터 자료형

지금까지 일반적인 데이터 자료형을 사용했습니다. 예를 들면 다음과 같습니다:

* `int`
* `float`
* `str`
* `bool`

하지만 더 복잡한 데이터 자료형 또한 사용할 수 있습니다.

그리고 지금까지와 같은 기능들을 여전히 사용할 수 있습니다.

* 훌륭한 편집기 지원.
* 들어오는 요청의 데이터 변환.
* 응답 데이터의 데이터 변환.
* 데이터 검증.
* 자동 어노테이션과 문서화.

## 다른 데이터 자료형

아래의 추가적인 데이터 자료형을 사용할 수 있습니다:

* `UUID`:
    * 표준 "범용 고유 식별자"로, 많은 데이터베이스와 시스템에서 ID로 사용됩니다.
    * 요청과 응답에서 `str`로 표현됩니다.
* `datetime.datetime`: