次の方法で共有


カスタム キー値のターゲット設定

パブリッシャーは、広告主にとって価値のあるオファリングを生成するために利用するユーザー (年齢、性別、収入、興味、場所など) やコンテンツ (検索キーワード、コンテキスト タグ、広告の位置など) に関するカスタム データを作成できます。 クエリ文字列やセグメント ターゲットなど、これを実現するために顧客データをターゲットにするさまざまな方法があります。 もう 1 つの方法は、カスタム キー/値のターゲット設定です。

カスタムキー/値ターゲティングを使用すると、独自のキーとそれに対応する値を定義して、データを最大限に活用し、広告主が目的の対象ユーザーに到達できるようにすることができます。 広告サーバーの一部として、独自のカスタム キー値セットの作成に使用できる API サービスを提供しています。

キー値セットの事前定義

カスタム キー/値セットを使用したターゲット設定には、キーと値を作成し、それらのキーと値を使用してターゲット設定式を作成する必要があります。 API では、 targeting-key サービスと targeting-value サービス 使用して、キーとそれに関連する値を作成します。 その後、 プロファイル サービスを使用してターゲットを作成します。

のキーと値の定義

targeting-key サービスを使用してキーを定義すると、これらのキーはプラットフォーム内でターゲットとして使用できるようになります。 targeting-key サービスを使用して事前に定義したキーのみが使用できます。 ただし、値を事前に定義する必要はありません。 targeting-value サービスを使用して値を事前に定義すると、それらの値が に表示されます。 値を事前に定義しない場合は、ターゲット設定を作成するときに、値を直接入力するか、CSV (コンマ区切り値) ファイルからインポートできます。 レガシ UI でキーを定義することは可能ですが、API を使用して、使用可能な新しいキーを定義する必要があることに注意してください。

プロファイル サービスのキーと値の定義

プロファイル サービスでターゲットを作成するために、キーや値を事前に定義する必要はありません。 最初に targeting-key サービスと targeting-value サービスを使用してキーと値を定義せずに、プロファイル サービスのターゲット式にキーと値を含めると、正しくターゲットになります。 ただし、 targeting-key と targeting-value サービスを 使用してキーと 値に 対してクエリを実行する場合、式で定義されたキーと値は、そのクエリの出力には含まれません。 これらのキーは、レポートにも使用できません。

キー値セットの作成

API を使用してカスタム キー値のターゲットを作成する最初の手順は、キーを作成することです。 キーは、値を含むカテゴリであり、そのカテゴリ内の要素です。 たとえば、 "fruit" という名前のキーを定義する場合、 "apple""orange" という名前のそのキーに関連付けられた値を作成できます。 "fruit" キーを作成する方法の例を次に示します。

$ cat create_targeting_key.json
{
    "targeting-key": {
        "name": "fruit",
        "type": "string"
    }
}
 
$ curl -b cookies -X POST -d '@create_targeting_key.json' 'https://api.appnexus.com/targeting-key'
 
"targeting-key": {
    "id": 4,
    "type": "string",
    "name": "fruit",
    "label": null,
    "state": "active",
    "created_on": "2016-08-26 11:30:55",
    "last_modified": "2016-08-26 11:30:55"
},

この例では、キーに "fruit" 名前を指定し、"string" の型を指定しました。 数値を持つキーを作成することもできます。 たとえば、213045の値を持つ "age" という名前のキーを定義できます。

キーを作成したら、そのキーに値を関連付けることができます。 この例では、 "apple" 値と "orange""fruit" キーに関連付けます。

$ cat create_targeting_value.json
{
    "targeting-value": {
        "name": "apple"
    }
}
 
$ curl -b cookies -X POST -d @create_targeting_value.json 'https://api.appnexus.com/targeting-value?targeting_key_id=4'

次の使用例は、 "apple"という名前の値を作成します。 クエリ文字列にtargeting_key_idを指定し、この値を 4 の id を持つ "fruit" キーに関連付けます。 同じコマンドを実行しますが、"apple"の代わりに名前として"orange"を指定します。 "fruit" キー (targeting_key_id = 4) の値は次のようになります。

"targeting-values": [
    {
        "id": 15,
        "targeting_key_id": 4,
        "name": "apple",
        "label": null,
        "created_on": "2016-08-26 11:59:26",
        "last_modified": "2016-08-26 11:59:26"
    },
    {
        "id": 16,
        "targeting_key_id": 4,
        "name": "orange",
        "label": null,
        "created_on": "2016-08-26 11:55:12",
        "last_modified": "2016-08-26 11:55:12"
    }
]

ターゲット値の一括追加を行うこともできます。 この例で行ったように値を一度に 1 つずつ追加するのではなく、次のように複数の値を一度に追加できます。

$ cat create_targeting_value.json
{
    "targeting-values": [
        {
            "name": "apple"
        },
        {
            "name": "orange"
        }
    ]
}
 
$ curl -b cookies -X POST -d @create_targeting_value.json 'https://api.appnexus.com/targeting-value?targeting_key_id=4'

JSON ファイルで targeting-value を 使用する代わりに、 配列として targeting-values (plural) を使用していることに注意してください。

プロファイルの更新

キーと関連する値が定義されたので、 プロファイルに追加します。 プロファイルに関連付けるキーと値の組み合わせは複雑になる可能性があります。 最も簡単な例から始めて、より複雑なソリューションをいくつか紹介します。

式の作成

最初に、ターゲットにするキーと値を決定する必要があります。 前の例を使用して、これを単純にし、リンゴまたはオレンジのすべての果物を対象とするとします。

(fruit == apple)OR (fruit == orange)

かなりシンプルですね。 しかし、より複雑になりたい場合はどうすればよいですか? 果物とそれが食べられている都市に基づいてターゲットを設定する場合はどうなりますか? このようなもの:

(fruit == apple AND city == NY)OR (fruit == orange AND (city == Seattle OR city == LA))

これで、NY のリンゴ、シアトルまたは LA のオレンジをターゲットにしています。

ターゲットにするキーと値の組み合わせを知ったら、それをプロファイルに取り込む方法を教えてください。 ターゲットの式 (およびサブ式) を作成します。

式演算子の使用

ターゲットの式を作成するには、Profile サービスで exp (式) オブジェクトを使用します。 exp オブジェクト内の要素を次に示します。

フィールド 種類 説明
typ string 式で使用される演算子。 次の値を指定できます。
- そして
- 又は
- じゃない
-
- eq (等しい)
- gt (より大きい)
- lt (より小さい)
- gte (以上)
- lte (以下)
- neq (等しくない)
演算子 およびまたは および 、サブ式でのみ使用できません。
in 演算子は配列に使用されます。
演算子 gtltgtelte は数値でのみ使用できます。
sbe exp オブジェクト サブ式 (式の要素) を含むオブジェクト。
key string ターゲット キーの名前
vtp type このフィールドは、式値のデータ型を識別します。 このフィールドに入力する値は、対応する値フィールドのフィールドと型と一致する必要があります。 次の値が有効です。
- num - 数値。 vnm フィールドに値を指定する必要があります
- str - string。 vst フィールドに値を指定する必要があります
- nma - 数値配列。 vna フィールドに値を指定する必要があります
- sta - 文字列配列。 vsa フィールドに値を指定する必要があります
vnm 数値 32 ビット符号付き float (25.3 など) としての値。 数値は最大 13 桁まで使用できます (小数点の右側の最大 6 桁)。
vst string 文字列としての値。
vna 数値の配列 浮動小数点の配列としての値のセット。
vsa 文字列の配列 文字列の配列としての値のセット。

値型は、値フィールド名と一致する必要があります。 たとえば、文字列として定義された値を vnm (数値) フィールドに配置すると、エラーが発生します。 また、 vtp フィールドで指定する型は、値の型と一致する必要があります。 vtp値がstrされている場合は、値を vst フィールドに割り当てる必要があります。

注:

exp オブジェクトでは、vtp フィールドに str を割り当てることで、値が文字列として識別されます。 これは、 targeting-key サービスで文字列値を定義する方法とは異なります。 targeting-key サービスでは、型フィールドに文字列を割り当てます。

式の解析と構築

exp オブジェクトの要素を使用して、ターゲットの式をまとめます。 元の例に戻りましょう。

(fruit == apple)OR (fruit == orange)

exp オブジェクトを使用して、この式をまとめる方法を次に示します。

{
    "key_value_targets": {
        "kv_expression": {
                "header": {
                        "an_version": "1.0",
                        "client_version": "1.0"
                },
            "exp": {
                "typ": "or",
                "sbe": [
                    {
                        "exp": {
                            "typ": "eq",
                            "key": "fruit",
                            "vtp": "str",
                            "vst": "apple"
                        }
                    },
                    {
                        "exp": {
                            "typ": "eq",
                            "key": "fruit",
                            "vtp": "str",
                            "vst": "orange"
                        }
                    }
                ]
            }
        }
    }  
}

key_value_targets オブジェクトから始まり、次に kv_expression フィールドから始めます。 そのフィールド内には、式全体が含まれます。 リンゴまたはオレンジをターゲットにしているため、式 typ フィールドの値を "or"に設定しました。

注:

すべての演算子の大文字と小文字を小文字にする必要があります。

有効: "typ": "or"

無効です: "typ": "OR"

キーと値では、大文字と小文字は区別されません。

次にヘッダーを追加 しますheader オブジェクトには、式に関するバージョン管理情報が含まれています。 次の例で説明するように、これらの式は計画と実装に一定の作業を要する可能性があるため、API の更新のために後で壊れることを心配する必要はありません。 問題を回避するには、バージョン管理情報を含むヘッダーを key_value_targets フィールドに追加する必要があります。 header オブジェクトには、次の 2 つのフィールドがあります。

フィールド 種類 説明
an_version string 1.0 式を評価するバックエンド エンジンのバージョン。 現在のバージョンは 1.0 です。
client_version string 1.0 式のクライアント向け実装のバージョン (このドキュメントで説明する形式)。 現在のバージョンは 1.0 です。

これらのフィールドは、 PUT 呼び出しと POST 呼び出しの両方で必要です。 式を正しく評価するには、ここに示すように値を入力する必要があります。 ヘッダー情報を、例に示すように値を含めて正確に入力します。

最後に、"or"が適用されるサブ式 (sbe) を定義します。 最初のサブ式は fruit == apple です。 "eq" (と等しい) のtyp"fruit"キーvtp (値型) が文字列"str"vst (文字列値) が"apple"。 次に、サブ式のフルーツ == オレンジで同じことを行います。 つまり、次のとおりです。

サブ式を示す図。

次に、より複雑な例を試してみましょう。

(fruit == apple AND city == NY)OR (fruit == orange AND (city == Seattle OR city == LA))

これは、式の文字列化を開始しようとすると、少し困難に思える場合があります。 お勧めする方法の 1 つは、次のような式の構造を作成することから始める方法です。

式の構造体の例を示す図。

式を描画したら、ターゲット プロファイルで作成を開始できます。 私たちは右下から始めて、私たちの道を進むつもりです。

ターゲット プロファイルで式を構築する方法を示す図。

都市 == シアトルと市区町村 == LA の式を次に示します。

               "exp": {
                        "typ": "eq",
                        "key": "city",
                        "vtp": "str",
                        "vst": "Seattle"
                },
                "exp": {
                        "typ": "eq",
                        "key": "city",
                        "vtp": "str",
                        "vst": "LA"
                }

次に、OR ステートメントに 1 レベル上に移動します。ここで、市区町村 == Seattle OR city == LA を作成します。

OR ステートメントを示す図。

これを行うには、両方の式を 1 つのサブ式 (sbe) 内に配置します。 そのサブ式は、サブ式内の 2 つの式のリレーションシップを "or" リレーションシップ ("typ": "or") として定義する別の式内にあります。 つまり、都市 == シアトルと都市 == LA の間には "or" 関係があります。

       "exp": {
                "typ": "or",
                "sbe": [
                        {
                                "exp": {
                                        "typ": "eq",
                                        "key": "city",
                                        "vtp": "str",
                                        "vst": "Seattle"
                                }
            },
            {
                                "exp": {
                                        "typ": "eq",
                                        "key": "city",
                                        "vtp": "str",
                                        "vst": "LA"
                                }
                        }
                ]
        }

上記の式は配列として作成することもできます。 ここでは、式と部分式を作成するプロセスを説明するために例を作成しましたが、配列を使用すると、多くの場合、単に数式を使用したり、 式のレベルを減らしたりできます。 ここで の式が配列 として表示される例については、以下の「配列の使用」を参照してください。

これは OR ステートメントであるため、配列を使用して構築することもできます。 この同じ式は配列を使用して作成できます。 ここまでは、複数の expの作成について説明しました。 上記の式は配列として構築することもできます。 配列を使用することが推奨される方法は、構造体をフラット化するためです。これは、レベルが不足し始める場合に重要な場合があります。 (詳細については、以下 の式のレベル を参照してください)。 配列と同じ式を作成するには、次のコマンドを使用します。

これで、ダイアグラムの右下隅 (市区町村 == Seattle OR city == LA) が完了しました。

配列としての OR 式を示す図。

次に、式のフルーツ == オレンジを定義してみましょう。

OR 式を定義する図。

"exp": {
                "typ": "eq",
                "key": "fruit",
                "vtp": "str",
                "vst": "orange"
        }

とてもシンプルでした。 次に、 "and" 式と組み合わせてフルーツ = オレンジ AND (city == Seattle OR city == LA) を作成します。

AND 式を使用して式をまとめる方法を示す図。

 "exp": {
                "typ": "and",
                "sbe": [
                        {
                                "exp": {
                                        "typ": "eq",
                                        "key": "fruit",
                                        "vtp": "str",
                                        "vst": "orange"
                                }
            },
            {
                                "exp": {
                                        "typ": "or",
                                        "sbe": [
                                                {
                                                        "exp": {
                                                                "typ": "eq",
                                                                "key": "city",
                                                                "vtp": "str",
                                                                "vst": "Seattle"
                                                        }
                        },
                        {
                                                        "exp": {
                                                                "typ": "eq",
                                                                "key": "city",
                                                                "vtp": "str",
                                                                "vst": "LA"
                                                        }
                                                }
                                        ]
                                }
                        }
                ]
        }

これで図の右側全体が完成します。

式の完成した右側を示す図。

次に、左側に移動してみましょう:fruit == apple AND city == NY:

式の左側を示す図。

 "exp": {
        "typ": "and",
        "sbe": [
                {
                        "exp": {
                                "typ": "eq",
                                "key": "fruit",
                                "vtp": "str",
                                "vst": "apple"
                        }
        },
        {
                        "exp": {
                                "typ": "eq",
                                "key": "city",
                                "vtp": "str",
                                "vst": "NY"
                        }
                }
        ]
}

これで練習が終わったら、その表現は非常に早く行きましたね? サブ式 fruit == apple と city == NY を組み合わせたtyp"and"を持つexpを作成しました。

図の両側を確認しました。作成しました (fruit == apple AND city == NY)、フルーツ == オレンジ AND (city == Seattle OR city == LA) を作成しました。 次に、最上位の "or"を追加します。

式の両側を示す図。

式全体を最上位レベルで結び付け、すべてを key_value_targets フィールドに配置します。

       "key_value_targets": {
                "kv_expression": {
                        "header": {
                                "an_version": "1.0",
                                "client_version": "1.0"
                        },
                        "exp": {
                                "typ": "or",
                                "sbe": [
                                        {

ご覧のとおり、式を key_value_targets オブジェクトと kv_expression オブジェクトの内部に配置し、 header オブジェクト (前述) を追加しました。 すべての右中かっこを追加することを忘れないでください。

最後に、完全なターゲット設定式は次のようになります。

{
        "key_value_targets": {
                "kv_expression": {
                        "header": {
                                "an_version": "1.0",
                                "client_version": "1.0"
                        },
                        "exp": {
                                "typ": "or",
                                "sbe": [
                                        {
                                                "exp": {
                                                        "typ": "and",
                                                        "sbe": [
                                                                {
                                                                        "exp": {
                                                                                "typ": "eq",
                                                                                "key": "fruit",
                                                                                "vtp": "str",
                                                                                "vst": "apple"
                                                                        }
                                                                },
                                                                {
                                                                        "exp": {
                                                                                "typ": "eq",
                                                                                "key": "city",
                                                                                "vtp": "str",
                                                                                "vst": "NY"
                                                                        }
                                                                }
                                                        ]
                                                }
                                        },
                                        {
                                                "exp": {
                                                        "typ": "and",
                                                        "sbe": [
                                                                {
                                                                        "exp": {
                                                                                "typ": "eq",
                                                                                "key": "fruit",
                                                                                "vtp": "str",
                                                                                "vst": "orange"
                                                                        }
                                                                },
                                                                {
                                                                        "exp": {
                                                                                "typ": "or",
                                                                                "sbe": [
                                                                                        {
                                                                                                "exp": {
                                                                                                        "typ": "eq",
                                                                                                        "key": "city",
                                                                                                        "vtp": "str",
                                                                                                        "vst": "Seattle"
                                                                                                }
                                                                                        },
                                                                                        {
                                                                                                "exp": {
                                                                                                        "typ": "eq",
                                                                                                        "key": "city",
                                                                                                        "vtp": "str",
                                                                                                        "vst": "LA"
                                                                                                }
                                                                                        }
                                                                                ]
                                                                        }
                                                                }
                                                        ]
                                                }
                                        }
                                ]
                        }
                }
        }
}

配列の使用

前の例は、文字列値を使用して作成されました。 キー/値ターゲットに数値を使用することもできます。配列を使用することもできます。 配列を使用すると、式を簡略化し、式が長すぎる場合に構造体をフラット化できます。 (下記 の「式のレベル 」を参照してください)。最初の例では、次のような式がありました。

{
    "key_value_targets": {
        "kv_expression": {
                "header": {
                        "an_version": "1.0",
                        "client_version": "1.0"
                },
            "exp": {
                "typ": "or",
                "sbe": [
                    {
                        "exp": {
                            "typ": "eq",
                            "key": "fruit",
                            "vtp": "str",
                            "vst": "apple"
                        }
                    },
                    {
                        "exp": {
                            "typ": "eq",
                            "key": "fruit",
                            "vtp": "str",
                            "vst": "orange"
                        }
                    }
                ]
            }
        }
    }  
}

これは OR 式であるため、単一の配列式に簡単に簡略化できます。

{
    "key_value_targets": {
        "kv_expression": {
                "header": {
                        "an_version": "1.0",
                        "client_version": "1.0"
                },
            "exp": {
                "typ": "in",
                "key": "fruit",
                "vtp": "sta",
                "vsa": ["apple","orange"]
            }
        }
    }  
}

いくつかの主な違いに注意してください。

  • "or"型の外側のexpを削除しました。 "Or" は 配列で暗黙的に指定されます。
  • 外側の式がないと、2 つのキー/値文字列セット (fruit = apple、fruit = orange) を含む部分式 (sbe) は不要になります。
  • 式の typ"eq" から "in"に変更されました。 私たちは「配列アップル、オレンジにある果物の任意の値」と言っています。
  • vtpは、str (文字列) ではなくsta (文字列配列) になりました。
  • 値は、vst (文字列値) ではなく、vsa (文字列配列値) として指定されます。

ここでは、個別の文字列値ではなく配列を使用するように簡略化された完全な式を示します。 "and"式が残っていることに注意してください。配列を使用するように"or"式のみが変更されました。

{
        "key_value_targets": {
                "kv_expression": {
                        "header": {
                                "an_version": "1.0",
                                "client_version": "1.0"
                        },
                        "exp": {
                                "typ": "or",
                                "sbe": [
                                        {
                                                "exp": {
                                                        "typ": "and",
                                                        "sbe": [
                                                                {
                                                                        "exp": {
                                                                                "typ": "eq",
                                                                                "key": "fruit",
                                                                                "vtp": "str",
                                                                                "vst": "apple"
                                                                        }
                                                                },
                                                                {
                                                                        "exp": {
                                                                                "typ": "eq",
                                                                                "key": "city",
                                                                                "vtp": "str",
                                                                                "vst": "NY"
                                                                        }
                                                                }
                                                        ]
                                                }
                                        },
                                        {
                                                "exp": {
                                                        "typ": "and",
                                                        "sbe": [
                                                                {
                                                                        "exp": {
                                                                                "typ": "eq",
                                                                                "key": "fruit",
                                                                                "vtp": "str",
                                                                                "vst": "orange"
                                                                        }
                                                                },
                                                                {
                                                                        "exp": {
                                                                                "typ": "in",
                                                                                "key": "city",
                                                                                "vtp": "sta",
                                                                                "vsa": ["Seattle","LA"]
                                                                        }
                                                                }
                                                        ]
                                                }
                                        }
                                ]
                        }
                }
        }
}

式の制限

式の詳細については、制限があります。

式のレベル

式の論理深さ (論理式のレベルの数) は最大 5 にすることができます。 論理レベルは、 および の型を持つ任意の式です。または、それ以外の式です。 または、exp オブジェクトに関しては、部分式 (sbe) を持つ任意の式 (exp) です。 先ほど説明した例では、次の図に示すように、論理深度は 3 です。

式のレベルを示す図。

多くの場合、1 つの式は複数の異なる方法で記述できます (および の異なる組み合わせ、または等しくないなど)。多くの場合、同じ結果が生成される場合があります。 式が 5 つの論理レベルを超えている場合は、式を簡略化するか、構造を "フラット化" する方法で書き直す方法を探す必要があります。

最大文字数

式には、最大 500,000 文字 (空白を含まない) を含めることができます。 式が 500,000 文字を超える場合、予期したとおりに実行されません。 式を短縮する必要がある場合は、再構成を試すことができます。

個々のキー/値の制限事項と要件の詳細については、「 Targeting Key Service and Targeting Value Service」の「要件」セクションを参照してください。

Key ごとの最大値

各キーの値は最大 999 個です。 同じキーに対して複数のキー/値式を作成し、OR を使用してそれらを結び付けることで、値の数を増やすことが可能です。 たとえば、key1 に 999 個の値がある場合は、最大 999 個の値を含む別の key1 を式に追加できます。 同じキーに対して複数の値セットを結合する方法を示す簡単な例を次に示します。

"kv_expression": {
    "exp": {
        "sbe": [
            {
                "exp": {
                    "key": "key1",
                    "typ": "in",
                    "vsa": [
                        "1",
                        "2",
                        "3"
                    ],
                    "vtp": "sta"
                }
            },
            {
                "exp": {
                    "key": "key1",
                    "typ": "in",
                    "vsa": [
                        "4",
                        "5",
                        "6"
                    ],
                    "vtp": "sta"
                }
            },
            {
                "exp": {
                    "key": "key1",
                    "typ": "in",
                    "vsa": [
                        "7",
                        "8",
                        "9"
                    ],
                    "vtp": "sta"
                }
            }
        ],
        "typ": "or"
    },

ワイルドカードの使用

* ワイルドカード記号を使用して、1 つの式で複数の値をターゲットにすることができます。 たとえば、リンゴをターゲットにするのではなく、特定の種類のリンゴをターゲットにするオプションが必要だとします。 あなたはおばあちゃんのスミスアップル、赤いおいしいリンゴ、蜂蜜りんごを含む値を持つ果物の鍵を持つことができます。 特定の種類のリンゴを対象にするには、式 fruit == honeycrisp apple を使用します。 すべてのリンゴを対象にすることにした場合は、ワイルドカードである fruit == *apple を使用します。 exp オブジェクトでは、次のようになります。

"exp": {
        "typ": "eq",
        "key": "fruit",
        "vtp": "str",
        "vst": "*apple"
}

値には最大 2 つのワイルドカードを使用できます。 だから、何らかの理由であなたの値がおいしいリンゴの赤とおいしいリンゴゴールデンとして入力されていた場合は、式 フルーツ==おいしいリンゴ*、および式 フルーツ== *apple*を持つ任意の種類のすべてのリンゴを持つすべてのおいしいリンゴを見つけることができます。

トラブルシューティング

数式を作成する際に問題が発生するのはかなり簡単だと、既に理解していることでしょう。 数式の問題を解決するのに役立ついくつかの手順があります。

無効な JSON 式

プロファイル サービスは、JSON 式で発生する可能性がある問題の原因を特定するのに役立つエラー処理を提供します。 ただし、すべての問題の完全なレポートを一度に受け取ることはありません。 サービスは、このドキュメントで説明したのと同じ方法で数式を走査します。 最も内側の数式 (数式ツリーの下部) から開始し、その数式を確認します。 数式のその部分にエラーがある場合、それらのエラーが報告されます。 これらのエラーを修正してサービスをもう一度実行すると、ツリーの次のレベルに進み、エラーが再度チェックされます。

で式を編集できない

で表示または編集できない式を API で作成できます。 API を使用して式を作成した後で式を変更できるようにするには、次のガイドラインに従う必要があります。

2 つ以上のレベルの深い式を作成しないでください

API を使用して最大 5 レベルの深さの式を作成できますが、処理できるのは最大 2 つのレベルのみです。 式を簡略化し、それらを変更できるようにするには、最大 2 つのレベルに保つ必要があります。 深さのレベルの説明については、「 式の制限」 を参照してください。

代替 AND レベルと OR レベル

上の例では、AND レベルと OR レベルを交互に使用しました。

"exp": {
        "typ": "or",
        "sbe": [
                {
                        "exp": {
                                "typ": "and",
                                "sbe": [

後続のレベルで演算子を繰り返す式を作成できます。 たとえば、この式では、AND から始まり、その直後に別の AND が続くことがわかります。

"exp": {
        "typ": "and",
        "sbe": [
                {
                        "exp": {
                                "typ": "and",
                                "sbe": [
                                        {
                                                "exp": {
                                                        "typ": "eq",
                                                        "key": "fruit",
                                                        "vtp": "str",
                                                        "vst": "apple"
                                                }
                                        },
                                        {
                                                "exp": {
                                                        "typ": "eq",
                                                        "key": "city",
                                                        "vtp": "str",
                                                        "vst": "NY"
                                                }
                                        }
                                ]
                        }
                },
                {
                        "exp": {
                                "typ": "and",
                                "sbe": [
                                        {
                                                "exp": {
                                                        "typ": "eq",
                                                        "key": "fruit",
                                                        "vtp": "str",
                                                        "vst": "orange"
                                                }
                                        },
                                        {
                                                "exp": {
                                                        "typ": "eq",
                                                        "key": "city",
                                                        "vtp": "str",
                                                        "vst": "LA"
                                                }
                                        }
                                ]
                        }
                }
        }
}

ただし、これらの式は編集できません。 式を簡略化してみてください。後続の AND 式を入れ子にする場合は、それらを入れ子にする必要がない場合があります。 書き出された前の式は次のようになります。

(fruit == apple AND city == NY)AND (フルーツ = オレンジ AND city == LA)

次のように記述することで、簡略化し、 で編集可能にすることができます。

 "exp": {
        "typ": "and",
        "sbe": [
                {
                        "exp": {
                                "typ": "eq",
                                "key": "fruit",
                                "vtp": "str",
                                "vst": "apple"
                        }
        },
        {
                        "exp": {
                                "typ": "eq",
                                "key": "city",
                                "vtp": "str",
                                "vst": "NY"
                        }
                }
                {
                        "exp": {
                                "typ": "eq",
                                "key": "fruit",
                                "vtp": "str",
                                "vst": "orange"
                        }
        },
        {
                        "exp": {
                                "typ": "eq",
                                "key": "city",
                                "vtp": "str",
                                "vst": "LA"
                        }
                }
        ]
}

ターゲット設定が正しくありません

前の手順に従い、 プロファイル サービスはエラーなしで実行されますが、ターゲット設定では予想どおりの結果が得られません。 問題を特定するために実行できるいくつかの手順を次に示します。

  • 数式を再確認する: ORing の場所を ANDing していますか? あなたが考えたことの反対の結果を返している可能性がある二重陰性(ではない(x neq y)を持っていますか?
  • 数式ツリーを描画する: 数式ツリーを実際に描画しなかった場合は、試してみることをお勧めします。 この形式は、数式の各ステップを歩く場合に非常に役立ちます。
  • 数式ツリーと数式を比較する: 一度に 1 つのノードを歩き、すべての eq と neq、およびおよびすべてが属していることを確認します。