package package-name

imports

globals

functions

queries

rules

rule "name"
    attributes
when
    LHS
then
    RHS
end

rule one
when
    exists Foo()
    exits Bar()
then
end

[ERR 101] Line 4:4 no viable alternative at input 'exits' in rule one

package org.drools;
rule
when
    Object()
then
    System.out.println("A RHS");
end

[ERR 101] Line 3:2 no viable alternative at input 'WHEN'

rule simple_rule
when
    Student( name == "Andy )
then
end

[ERR 101] Line 0:-1 no viable alternative at input
'<eof>' in rule simple_rule in pattern Student

rule simple_rule
when
    foo3 : Bar(

[ERR 102] Line 0:-1 mismatched input '<eof>' expecting
')' in rule simple_rule in pattern Bar

package org.drools;

rule "Avoid NPE on wrong syntax"
when
    not(Cheese((type=="stilton",price==10)||(type=="brie",price==15))
        from $cheeseList)
then
    System.out.println("OK");
end

[ERR 102] Line 5:36 mismatched input ',' expecting ')' in rule
"Avoid NPE on wrong syntax" in pattern Cheese

[ERR 101] Line 5:57 no viable alternative at input 'type' in
rule "Avoid NPE on wrong syntax"

[ERR 102] Line 5:106 mismatched input ')' expecting 'then' in
          rule "Avoid NPE on wrong syntax"

package nesting;
dialect "mvel"

import org.drools.Person
import org.drools.Address

fdsfdsfds

rule "test something"
when
    p: Person( name=="Michael" )
then
    p.name = "other";
    System.out.println(p.name);
end

[ERR 103] Line 7:0 rule 'rule_key' failed predicate:
{(validateIdentifierKey(DroolsSoftKeywords.RULE))}? in rule

rule simple_rule
when
    eval(abc();)
then
end

[ERR 104] Line 3:4 trailing semi-colon not allowed in rule
simple_rule

template test_error
    aa s  11;
end

[ERR 105] Line 2:2 required (...)+ loop did not match anything
at input 'aa' in template test_error

@matadata_key( metadata_value )

@author( Bob )

import java.util.Date

declare Person
    @author( Bob )
    @dateOfCreation( 01-Feb-2009 )

    name : String @key @maxLength( 30 )
    dateOfBirth : Date 
    address : Address
end

図4.11 ルール属性

rule "my rule"
salience 42
agenda-group "number 1"
when ...

図4.12 左側

rule "no CEs"
when
then
        <action>*
end

rule "no CEs"
when
    eval( true )
then
    <action>*
end

4.8.3.1. パターン

パターン は conditional element の最も重要な型です。以下のエンティティー関係図はパターンの制約を構成するさまざまな部分の概要と、これらの部分がどのように連携するかを表しています。各部分の詳細は、図やコード例と共に本項の後半で取り上げます。

図4.13 パターンエンティティー関係図

エンティティー関係図の上部を見ると、パターンはゼロ以上の制約で構成され、パターンバインディングは任意であることが分かります。次の図は構文の形式を表しています。

図4.14 パターン

最も簡単な形式 (制約のない状態) では、パターンは該当する型のファクトに対して照合されます。以下の場合、型は Cheese であるため、パターンは working memory の各 Cheese オブジェクトに対して照合されます。

注記

「型」はファクトオブジェクトの実際のクラスである必要はありません。パターンは スーパークラス やインターフェースも参照する場合があるため、多数のクラスからのファクトと一致する可能性があります。

Cheese( )

$c などのパターンバインディング変数を使用して一致するオブジェクトを参照します。$ プレフィックスの使用は任意ですが、このプレフィックスを使用すると変数をフィールドを区別しやすくなるため、複雑なルールに対処するする場合に便利です。

$c : Cheese( )

構文の主な要素は括弧です。括弧内に制約を置きます。主な型は フィールド制約、インライン評価、および 制約グループ になります。

,、&&、|| のいずれかを使用して制約を区切ります。ただし、これらの記号は若干ことなる機能を持つことに注意してください。

図4.15 制約

図4.16 制約

図4.17 constraintGroup

コンマ (,) は制約グループを区切るために使用されます。これは暗黙的で接続的な意味論を持ちます。

# Cheese type is stilton and price < 10 and age is mature.
Cheese( type == "stilton", price < 10, age == "mature" )

この例では、3 つの制約グループがあり、各制約グループは単一の制約を持っています。

1. type == "stilton" の通り、型は stilton です。
2. price < 10 の通り、価格 (price) は 10 未満です。
3. age == "mature" の通り、熟成度 (age) は mature です。

&& と || を用いると、グループは複数の制約を持つことができます。例は次の通りです。

// Cheese type is "stilton" and price < 10, and age is mature
Cheese( type == "stilton" && price < 10, age == "mature" )
// Cheese type is "stilton" or price < 10, and age is mature
Cheese( type == "stilton" || price < 10, age == "mature" )

この場合、 2 つの制約グループが存在します。最初の制約グループは 2 つの制約を持ち、2 つ目の制約グループは制約を 1 つ持ちます。

結合記号は次の順で最初から最後まで評価されます。

1. &&
2. ||
3. ,

評価の優先度を変更するには、論理や数式のように括弧を使用します。例は次の通りです。

# Cheese type is stilton and ( price is less than 20 or age is mature ).
Cheese( type == "stilton" && ( price < 20 || age == "mature" ) ) 

この場合、括弧を使用すると || は && の前に評価されるようになります。

&& と , は同じ意味論を持ちますが、異なる優先度で解決されることに注意してください。そのため、複合制約式に , を組み込むことはできません。

// invalid as ',' cannot be embedded in an expression:
Cheese( ( type == "stilton", price < 10 ) || age == "mature" )
// valid as '&&' can be embedded in an expression:
Cheese( ( type == "stilton" && price < 10 ) || age == "mature")

4.8.3.1.1. フィールド制約

フィールド制約 を使用して名前付きフィールドを制限します。任意でフィールド名に変数バンディングを使用することができます。

図4.18 fieldConstraint

制限には次の 3 つの形式があります。

• 単一値制限
• 複合値制限
• 複数制限

図4.19 制限

4.8.3.1.2. ファクトとしての Java Bean

フィールドはオブジェクトの アクセス可能メソッド です。モデルオブジェクトが Java Bean パターン に従う場合、 getXXX メソッドか isXXX メソッドを使用してフィールドが公開されます。この場合、これらのメソッドは引数を取りませんが、何らかの値を返します。

Bean 命名規則を使用してパターン内のフィールドにアクセスします (たとえば、getType は type としてアクセスされ、JBoss Rules は標準的な Java Development Kit の Introspector クラスを使用してこのマッピング処理を実行します)。

Cheese クラスの例では、Cheese(type == "brie") パターンは getType() メソッドを Cheese インスタンスへ適用します。フィールド名が見つからない場合、コンパイラーは最終的に引数のないメソッドとして名前を使用します。そのため、Cheese(toString == "cheddar") 制約により toString() が呼び出されます。この場合、大文字と小文字を正しく区別したメソッドの完全名を使用しますが、括弧は省略します。必ず、アクセスされるメソッドがパラメーターを取らず、これらのメソッドはルールに影響する方法でオブジェクトの状態を変更しない accessors であるようにしてください (パフォーマンス上の理由で、呼び出し間の照合の結果を rule engine がキャッシュすることに注意してください)。

4.8.3.1.3. 値

フィールド制約は次の値を含むさまざまな値を取ります。

• リテラル
• qualifiedIdentifiers (列挙値)
• 変数
• returnValues

図4.20 リテラル

図4.21 qualifiedIdentifier

図4.22 変数

図4.23 returnValue

null であるフィールドに対してチェックを行うには、通常通り == と != を使用します。リテラルの null キーワード (Cheese(type != null) のように使用) は、evaluator が例外をスローしない場合、値が null であると true を返します。

フィールドと値が異なる型である場合、システムは常に 型強制 を実行しようとします。「悪質な」強制を行おうとすると、例外が発生します。たとえば、数値 evaluator に ten を文字列として提供すると、例外が発生しますが、10 を提供すると数値の 10 に強制します (強制は常に値型ではなくフィールド型を優先します)。

4.8.3.1.4. 単一値制限

図4.24 singleValueRestriction

4.8.3.1.5. 演算子

図4.25 演算子

== および != 演算子はすべての型で有効です。型値が順序付けされている時は他のリレーショナル演算子を使用することもできます。データフィールドでは < は 「前」を意味します。 matches と not matches のペアは文字列フィールドへのみ適用し、contains と not contains には Collection 型のフィールドが必要になります (evaluator とフィールドに対して正しい値を強制しようとします)。

matches 演算子

これは有効な Java 正規表現があるフィールドと一致します。正規表現は通常は文字列リテラルですが、有効な正規表現を解決する変数を使用することもできます。

重要

Java とは異なり、文字列リテラルとして書かれる正規表現内にエスケープは必要ありません。

Cheese( type matches "(Buffalo)?\S*Mozarella" )

not matches 演算子

この演算子は文字列が正規表現と一致しない時に true を返します。matches 演算子でも同じルールが適用されます。使用例は次の通りです。

Cheese( type not matches "(Buffulo)?\S*Mozerella" )

contains 演算子

この演算子を使用して、 collection または array フィールドに指定された値が含まれていることを確認します。

CheeseCounter( cheeses contains "stilton" ) // contains with a String literal
CheeseCounter( cheeses contains $var ) // contains with a variable

not contains 演算子

この演算子を使用して、collection または array フィールドに指定された値がないことを確認します。

CheeseCounter( cheeses not contains "cheddar" ) // not contains with a String literal
CheeseCounter( cheeses not contains $var ) // not contains with a variable

注記

後方互換性を維持するため、excludes 演算子もサポートされています。この演算子は not contains と同等です。

memberOf 演算子

この演算子を使用してフィールドが collection または array のメンバーであるかどうかを確認します。コレクションは変数である必要があります。

CheeseCounter( cheese memberOf $matureCheeses )

not memberOf 演算子

この演算子を使用して、フィールドが collection または array のメンバーでないかどうかを確認します。コレクションは変数である必要があります。

CheeseCounter( cheese not memberOf $matureCheeses )

soundslike 演算子

この演算子は matches と似ていますが、言葉が指定値と似た発音であるかどうかを確認します。Soundex アルゴリズムを使用し、英語の発音を基にして言葉の発音を確認します。

// match cheese "fubar" or "foobar"
Cheese( name soundslike 'foobar' )

4.8.3.1.6. リテラル制限

最も単純な形式の制限です。フィールドを指定されたリテラルに対して評価します。リテラルは、数値、日付、文字列、またはブール値になります。

図4.26 literalRestriction

== 演算子を使用するリテラル制限は、ハッシングを使用してインデックスを作成しパフォーマンスを改善できるため、高速な実行を実現します。

数値

標準的な Java 数値プリミティブがすべてサポートされます。

Cheese( quantity == 5 )

日付

デフォルトの日付形式は dd-mmm-yyyy です。これを変更するには、drools.dateformat プロパティーの別の日付形式マスクを提供します (制御を強化する必要がある場合は、inline-eval 制約を使用します)。

Cheese( bestBefore < "27-Oct-2013" )

文字列

有効な Java 文字列を使用します。

Cheese( type == "stilton" )

ブール値

true か false のみを使用できます。0 と 1 は使用できません。単一のブール値フィールド (例 Cheese( smelly )) は許可されません。ブール値リテラルの比較対象となる必要があります。

Cheese( smelly == true )

修飾識別子

Java Development Kit 1.4 および 1.5 形式の enums はサポートされますが、1.5 は JDK 5 の環境でのみ使用可能です。

Cheese( smelly == SomeClass.TRUE )

4.8.3.1.7. バインドされた変数制限

図4.27 variableRestriction

変数をファクトとファクトのフィールドにバインドし、後続の fied constraints で使用することが可能です。バインドされた変数は 宣言 と呼ばれます。制約されるフィールドの型によって有効な演算子が決定されます。可能な場合、強制が試行されます。パフォーマンスを高速化するには、== 演算子を使用して変数制限をバインドします。

Person( likes : favouriteCheese )
Cheese( type == likes )

この例では、一致する各 Person インスタンスの favouriteCheese フィールドへ likes 変数がバインドされます (次のパターンで Cheese の型を制約します)。有効な Java 変数名を使用することができ、フィールドと宣言を区別するために使用される $ プレフィックスを使用できます。

次の例は、最初のパターンと一致するオブジェクトにバインドされる $stilton の宣言を表しています。contains 演算子と共に使用されます (任意の $ の使用方法に注目してください)。

$stilton : Cheese( type == "stilton" )
Cheesery( cheeses contains $stilton )

4.8.3.1.8. 戻り値制限

図4.28 returnValueRestriction

戻り値制限 は、リテラル、有効な Java プリミティブまたはオブジェクト、以前バインドされた変数、関数呼び出し、および演算子によって構成される括弧で囲まれている式です。使用される関数が時間に依存する結果を返すことは禁止されています。

Person( girlAge : age, sex == "F" )
Person( age == ( girlAge + 2) ), sex == 'M' )

4.8.3.1.9. 複合値制限

一致する可能性がある値が複数ある時に 複合値制限 を使用します （現在、in および not in evaluators のみがサポートしています)。

2 つ目のオペランドは、括弧で囲まれている値のコンマ区切りリストである必要があります。値は変数、リテラル、戻り値、または修飾識別子として渡すことができます。両方の evaluators は実際は「シンタクティックシュガー」で、!= および == 演算子を使用して複数制限のリストとして内部で書き直されます。

図4.29 compoundValueRestriction

Person( $cheese : favouriteCheese )
Cheese( type in ( "stilton", "cheddar", $cheese )

4.8.3.1.10. 複数制限

複数制限 制約を使用してフィールドに複数の制限を割り当てます (&& または || 分離記号を使用)。括弧を用いたグループ化は許可され、結果的に再帰的な構文パターンになります。

図4.30 multiRestriction

図4.31 restrictionGroup

// Simple multi restriction using a single &&
Person( age > 30 && < 40 ) 
// Complex multi restriction using groupings of multi restrictions
Person( age ( (> 30 && < 40) ||
              (> 20 && < 25) ) )
// Mixing muti restrictions with constraint connectives
Person( age > 30 && < 40 || location == "london" )

4.8.3.1.11. インライン評価制約

図4.32 インライン評価式

インライン評価 (inline eval) 制約はプリミティブなブール値へ解決する有効なダイアレクト式を使用できます。この式は時間が経過しても一定である必要があります。現在または以前のパターンより以前バインドされた変数を使用できます。フィールドバインディング変数を自動的に作成するため、auto-vivification (自動有効化) も使用されます。

注記

現在の変数でない識別子が発見された場合、識別子が現在のオブジェクト型のフィールドであるかを判断するためにビルダーによってチェックされます。識別子がこれに該当する場合、フィールドバインディングが同じ名前の変数として自動的に作成されます。これは、フィールド変数の auto-vivification (自動有効化) と呼ばれます。

この例では、男性が女性よりも 2 歳年上となる可能な男女のペアをすべて探します。age 変数は auto-vivification によって 2 つ目のパターンで自動作成されます。

Person( girlAge : age, sex = "F" )
Person( eval( age == girlAge + 2 ), sex = 'M' )

4.8.3.1.12. ネストされたアクセサー

JBoss Rules では、フィールド制約で ネストされたアクセサー を使用できます。これには、MVFLEX 式言語のアクセサーグラフ表記法を使用します (ネストされたアクセサーを持つフィールド制約は、実際には MVFLEX 式言語の inline-eval 制約として書き換えられます)。

警告

working memory はネストされた値を認識せず、ネストされた値がいつ変更するかも認識しないため、nested accessors を使用する時は十分注意してください。親参照が working memory に存在する間は常に不変の値として見なしてください。

ネストされた値を変更するには、最初に親オブジェクトを削除し、その後再度アサートします。グラフのルートに親が 1 つのみ存在する場合は、MVEL ダイアレクトの modify とその ブロックセッター を使用し、ネストされたアクセサーの割り当てを書くことができます。この場合、ルートの親オブジェクトを必要に応じて取り消したり挿入したりすることができます (Nested accessors は演算子記号のどちらの側でも使用できます)。

// Find a pet older than its owners first-born child
$p : Person( ) 
Pet( owner == $p, age > $p.children[0].age )

これは内部で MVEL inline eval として書き換えられます。

// Find a pet older than its owners first-born child
$p : Person( ) 
Pet( owner == $p, eval( age > $p.children[0].age ) ) 

警告

nested accessors は direct field accesses よりもパフォーマンスへの影響がかなり大きいため、注意して使用してください。

4.8.3.2. and 条件要素

and conditional element を使用して他の conditional elements を論理積にグループ化します。

左側の root element は暗黙的な and プレフィックスです。これは指定する必要はありません。JBoss Rules は and をプレフィックスとインフィックスの両方としてサポートしますが、暗黙的なグループ化により混乱を避けることができるため、プレフィックスの使用が推奨されます。

図4.33 prefixAnd

(and Cheese( cheeseType : type )
Person( favouriteCheese == cheeseType ) )

when
Cheese( cheeseType : type )
Person( favouriteCheese == cheeseType )

必要な場合は、and インフィックスと括弧による明示的なグループ化がサポートされます。

注記

and の代わりに && 記号を使用できます。この記号は廃止されましたが、レガシーサポートの理由で現在でも使用可能です。

図4.34 infixAnd

//infixAnd
Cheese( cheeseType : type ) and Person( favouriteCheese == cheeseType )
//infixAnd with grouping
( Cheese( cheeseType : type ) and
( Person( favouriteCheese == cheeseType ) or 
Person( favouriteCheese == cheeseType ) )

4.8.3.3. or 条件要素

or conditional element を使用して他の conditional element を論理和にグループ化します。

注記

JBoss Rules では or をプレフィックスまたはインフィックスとして使用できますが、暗黙的なグループ化により混乱を避けることができるため、プレフィックスの使用が推奨されます。

この conditional element の挙動は、フィールド制約や制限に対する結合記号 || とは異なります。engine は実際には or を理解しません。複数の異なる論理変換を使用することにより、or を使用するルールは複数のサブルールとして書き換えられます。この結果、ルールは単一の root node である or と、各 conditional elements に対する 1 つのサブルールを持ちます。各サブルールは通常のルールと同様にアクティベートおよび実行できます。特別な挙動や対話はありませんが、それが新しい開発者が混乱する原因となることがあります。

図4.35 prefixOr

(or Person( sex == "f", age > 60 )
Person( sex == "m", age > 65 )

必要な場合、or インフィックスと括弧による暗示的なグループ化がサポートされます。

注記

or の代わりに || 記号を使用できます。この記号は廃止されましたが、レガシーサポートの理由で現在でも使用可能です。

図4.36 infixOr

//infixOr
Cheese( cheeseType : type ) or Person( favouriteCheese == cheeseType )
//infixOr with grouping
( Cheese( cheeseType : type ) or
( Person( favouriteCheese == cheeseType ) and
Person( favouriteCheese == cheeseType ) )

任意で、or を用いて pattern binding を使用することもできます。これは、結果となる各サブルールがパターンにバインドされることを意味します。次の例のように、eponymous 変数を使用して各パターンを別々にバインドする必要があります。

(or pensioner : Person( sex == "f", age > 60 ) 
pensioner : Person( sex == "m", age > 65 ) )

or を使用すると、可能な結果ごとに 1 つサブルールが作成されます。上記の単純な例では、2 つのルールが生成されます。これらのルールは working memory 内で独立して機能するため、両方とも照合、アクティベートおよび実行することが可能です。ショートカットはありません。

or を 2 つ以上の同様のルールを生成する方法と考えると分かりやすいかもしれません。2 つ以上の項の論理和が true の場合、単一のルールが複数のアクティベーションを持つことがあります。

4.8.3.4. eval 条件要素

図4.37 eval

eval conditional element はプリミティブなブール値を返す意味論コードを実行できるようにする「catch-all」です。このコードはルールの左側にバインドされた変数か、ルールパッケージの関数を参照できます。

警告

eval を使用しすぎないようにしてください。ルールの宣言性が低下し、engine のパフォーマンスが低下することがあります。eval はパターンのどこにでも使用できますが、ルールの左側で最後の条件要素として追加することが推奨されます。

Evals に索引を付けることはできません。そのため、フィールド制約 ほど効率的ではありません。しかし、時間とともに変化する値を返す関数として使用することに適しています (フィールド制約にはこの機能はありません)。

p1 : Parameter() 
p2 : Parameter()
eval( p1.getList().containsKey(p2.getItem()) )
// call function isValid in the LHS
eval( isValid(p1, p2) )

4.8.3.5. not 条件要素

図4.38 not

not conditional element は、1 階論理の 非存在数量詞 (non-existential quantifier) です。この目的は、working memory に存在しないものを確認することです。

not キーワードは、括弧で囲まれた conditional element の前に指定する必要があります (最も単純なユースケースでは、括弧を省略することが可能です)。

not Bus()

// Brackets are optional:
not Bus(color == "red")

// Brackets are optional:
not ( Bus(color == "red", number == 42) ) 

// "not" with nested infix and - two patterns,
// brackets are requires:
not ( Bus(color == "red") and Bus(color == "blue") )

4.8.3.6. exists 条件要素

図4.39 exists

exists conditional element は 1 階論理 の 存在数量詞 (existential quantifier) です。この目的は、working memory に存在するものを確認することです。exists を「少なくとも 1 つ存在する」という意味で考えるプログラマーもいます (「それぞれに対する」のように独自のパターンを持つこととは異なります)。

パターンで exists が使用されると、その条件と一致する working memory のデータの量に関係なく、ルールは一度だけアクティベートされます。存在のみが非常に重要となるため、バインディングは確立されません。

exists キーワードは、適用する conditional elements の前に指定する必要があります。conditional elements は括弧で囲まれている必要があります (以下のような最も単純な単一のパターンでは、括弧を省略することもできます)。

exists Bus()

exists Bus(color == "red")
// brackets are optional:
exists ( Bus(color == "red", number == 42) )
// "exists" with nested infix and,
// brackets are required:
exists ( Bus(color == "red") and
Bus(color == "blue") )

4.8.3.7. conditional elements

図4.40 forall

forall conditional element は JBoss Rules の 1 階論理のサポートを完全にします。最初のパターンに一致するすべてのファクトが、残りの各パターンにも一致する場合、forall は true として評価します。例は次の通りです。

rule "All English buses are red"
when
    forall( $bus : Bus( type == 'english') 
    Bus( this == $bus, color = 'red' ) )
then
    # all english buses are red
end

このルールは、タイプが english の各 Bus オブジェクトを選択します。そして、このパターンに一致する各ファクトに対し、後続のパターンが評価されます。後続のパターンにも一致する場合、forall conditional element は true として評価します。

該当するタイプの各ファクトが制約セットと一致するよう指定するには、以下のような単純な単一パターンを記述します。

rule "All Buses are Red"
when
    forall( Bus( color == 'red' ) )
then
    # all asserted Bus facts are red
end

反対に、複数パターンの場合は次のようになります。

rule "all employees have health and dental care programs"
when
    forall( $emp : Employee()
        HealthCare( employee == $emp )
        DentalCare( employee == $emp )
    )
then
    # all employees have health and dental care
end

forall は not などの他の conditional elements 内にネストできます。

重要

単一パターンの場合のみ括弧の使用が任意になります。そのため、ネストされる場合は括弧を使用する必要があります。

rule "not all employees have health and dental care"
when 
    not ( forall( $emp : Employee()
        HealthCare( employee == $emp )
        DentalCare( employee == $emp ) ) 
    )
then
    # not all employees have health and dental care
end

注記

not( forall( p1 p2 p3...)) は次のコードと同等です。

not(p1 and not(and p2 p3...))

重要

forall は 範囲の区切り文字 であることに注意してください。そのため、以前にバインドされた変数を使用できますが、内部でバインドされた変数は外部で使用することはできません。

4.8.3.8. from 条件要素

図4.41 from

from conditional element を使用して、左側のパターンによって一致されるデータの任意のソースを指定します。これを行うことにより、 engine が working memory で発見されなかったデータを推論できます。データソースはバインドされた変数上のサブフィールドや、メソッド呼び出しの結果であることがあります。

これは、他のアプリケーションコンポーネントやフレームワークとそのまま統合できるようにする強力なコンストラクトです。一般的な例の 1 つは、Hibernate の名前が付けられたクエリを使用してデータベースから要求に応じて読み出されるデータとの統合です。

通常の MVFLEX 式言語の構文に従う式を使用してオブジェクトソースを定義します。これにより、メソッドコールの実行、マップや collections 要素へのアクセス、オブジェクトプロパティーナビゲーション の使用を簡単に行うことができます。

別のパターンサブフィールドへの推論とバインディングを表す簡単な例は次の通りです。

rule "validate zipcode"
when
    Person( $personAddress : address ) 
    Address( zipcode == "23920W") from $personAddress 
then
    # zip code is ok
end

グラフ表記法を使用して同じことを行う方法は次の通りです。

rule "validate zipcode"
when
    $p : Person( ) 
    $a : Address( zipcode == "23920W") from $p.address 
then
    # zip code is ok
end

前述の例は単一パターンの評価でしたが、オブジェクトソース上で from を使用してオブジェクトのコレクションを返すこともできます。この場合、from がコレクションの各オブジェクトを繰り返し、個別に照合しようとします。以下は、注文の各商品を 10 ％ 割引するためのルールが含まれる例になります。

rule "apply 10% discount to all items over $ 100,00 in an order"
when
    $order : Order()
    $item  : OrderItem( value > 100 ) from $order.items
then
    # apply discount to $item
end

各注文の値が 100 を越える各商品に対して、このルールが一度実行されます。

from を lock-on-active ルール属性と共に使用する場合、予期しない結果がもたらされることがあるため特に注意してください。次のように若干変更が加えられている前述の例を考慮してください。

rule "Assign people in Queensland (QLD) to sales region 1"
    ruleflow-group "test"
    lock-on-active true
when
    $p : Person( ) 
    $a : Address( state == "QLD") from $p.address 
then
    modify ($p) {} #Assign person to sales region 1 in a modify block
end

rule "Apply a discount to people in the city of Brisbane"
    ruleflow-group "test"
    lock-on-active true
when
    $p : Person( ) 
    $a : Address( city == "Brisbane") from $p.address 
then
    modify ($p) {} #Apply discount to person in a modify block
end

この例では、QLD 州の Brisbane に在住する人は Sales Region 1 に割り当てられ、割引が適用されます (つまり、両方のルールがアクティベートおよび実行されることを想定しますが、2 つ目のルールのみが実行されます)。

監査ログを有効にすると、2 つ目のルールが実行された時に最初のルールを非アクティベートします。lock-on-active ルール属性により、ファクトのセットが変更された時にルールによって新しいアクティベーションが作成されないようにするため、最初のルールは再アクティベートできません (ファクトのセットは変更されませんが、 from を使用すると目的に関係なく、評価される度に新しいファクトが返されます)。

次の手順に従います。

1. 前述のパターンを使用する必要性について検討します。
   これは異なるルールフローグループ全体で多くのルールが存在するためです。ルールが working memory および該当するルールフローのダウンストリームにある他のルールを変更し、必要性を再評価しなければならない場合、modify を使用することが重要となります。しかし、同じルールフローグループの他のルールがお互いにアクティベーションを再帰的に配置しないようにしてください。
   この場合、ルールがルール自体を再帰的にアクティベートできないようになるため、no-loop 属性では効果がありません。したがって、lock-on-active を使用してください。
2. この問題に対応する方法はいくつかあります。
   • すべてのファクトを working memory にアサートできる場合に from を使用しないようにするか、制約式でネストされたオブジェクト参照を使用します (下記を参照)。
   • modify block で使用するために割り当てられた変数を、左側の条件の最後にある文として配置します。
   • 同じルールフローグループ内のルールがお互いにアクティベーションを配置する方法を明示的に管理できる場合、lock-on-active を使用しないようにします。
   この中で推奨される解決法は、working memory へすべてのファクトを直接アサートできる場合に from の使用を最小限に抑える方法になります。
   上記の例では、Person および Address インスタンスの両方を working memory にアサートすることが可能です。グラフは比較的単純であるため、次のようにルールを変更するとさらに簡単です。

   rule "Assign people in Queensland (QLD) to sales region 1"
       ruleflow-group "test"
       lock-on-active true
   when
       $p : Person(address.state == "QLD" )  
   then
       modify ($p) {} #Assign person to sales region 1 in a modify block
   end
   
   rule "Apply a discount to people in the city of Brisbane"
       ruleflow-group "test"
       lock-on-active true
   when
       $p : Person(address.city == "Brisbane" )  
   then
       modify ($p) {} #Apply discount to person in a modify block
   end
   

3. 両方のルールは想定通り実行されるようになりますが、この方法で常にネストされたファクトへアクセスできるわけではありません。Person が 1 つまたは複数の Addresses を保持し、存在数量詞 を使用して特定条件を満たす住所を最低でも 1 つ person に一致させたい例を考えてみましょう。この場合、コレクションを推論するため from を使用する必要があります。
   これを実現する方法は複数ありますが、すべてで lock-on-active 使用時の問題が発生するわけではありません。たとえば、次のように from を使用すると、両方のルールが想定通りに実行されます。

   rule "Assign people in Queensland (QLD) to sales region 1"
       ruleflow-group "test"
       lock-on-active true
   when
       $p : Person($addresses : addresses)
       exists (Address(state == "QLD") from $addresses)  
   then
       modify ($p) {} #Assign person to sales region 1 in a modify block
   end
   
   rule "Apply a discount to people in the city of Brisbane"
       ruleflow-group "test"
       lock-on-active true
   when
       $p : Person($addresses : addresses)
       exists (Address(city == "Brisbane") from $addresses)  
   then
       modify ($p) {} #Apply discount to person in a modify block
   end
   

   しかし、若干異なる方法では問題が発生します。

   rule "Assign people in Queensland (QLD) to sales region 1"
       ruleflow-group "test"
       lock-on-active true
   when
       $assessment : Assessment()
       $p : Person()
       $addresses : List() from $p.addresses
       exists (Address( state == "QLD") from $addresses) 
   then
       modify ($assessment) {} #Modify assessment in a modify block
   end
   
   rule "Apply a discount to people in the city of Brisbane"
       ruleflow-group "test"
       lock-on-active true
   when
       $assessment : Assessment()
       $p : Person()
       $addresses : List() from $p.addresses 
       exists (Address( city == "Brisbane") from $addresses)
   then
       modify ($assessment) {} #Modify assessment in a modify block
   end
   

   この場合、from を使用すると $addresses が返されます。またこの例では、可能な解決法を示す新しいオブジェクト assessment が導入されます。$addresses 変数が移動され、各ルールの最後の条件となると、両方のルールは想定通り実行されます。
   上記の例は、ルールのアクティベーションを損失せずに from を lock-on-active と組み合わせて使用する方法を表していますが、左側の条件の配置順序に依存するという欠点があります。またこれにより、問題を起こす可能性のある条件を追跡する必要があるため、ルールの作成が極めて複雑になります。
4. 代わりに、ファクトをさらに working memory へアサートする方がよいでしょう。この場合、人の住所が working memory へアサートされると、from を使用する必要がなくなります。

注記

すべてのデータを working memory にアサートするのは現実的ではなく、他の方法を使用する必要がある場合があります。

lock-on-active の必要性を再評価することが 1 つの方法です。working memory が変更された時にお互いを再帰的にアクティベートしないようにする条件が各ルールに含まれるようにして、同じルールフローグループ内のルールがお互いをアクティベートするよう、直接管理する方法もあります。たとえば、前述の例の場合、割引が既に適用されているか確認し、適用されている場合はルールがアクティベートしないようにする条件をルールに追加できます。

4.8.3.9. collect 条件要素

図4.42 collect

collect conditional element を使用して、指定のソースまたは working memory のいずれかより取得されたオブジェクトのコレクションをルールが推定するようにします。

注記

1 階論理 では 基数数量詞 と呼ばれます。

import java.util.ArrayList
rule "Raise priority if system has more than 3 pending alarms"
when
    $system : System()
    $alarms : ArrayList( size >= 3 )
    from collect( Alarm( system == $system, status == 'pending' ) )
then
    # Raise priority, because system $system has
    # 3 or more alarms pending. The pending alarms
    # are $alarms.
end

この場合、ルールは working memory で該当する各システムの保留のアラームを探し、ArrayLists でグループ化します。1 つのシステムに対して 3 つ以上のアラームが見つかった場合にルールが実行されます。

collect の結果パターンは、 java.util.Collection インターフェースを実装し、引数のないデフォルトの公開コンストラクターを提供する「具体的」なクラスになります。これは java.util.Collection を実装し、これらの条件を満たす限り、ArrayList、LinkedList、HashSet、またはカスタムクラスなどの Java 使用できることを意味します。

注記

ソースと結果パターンの両方を他のパターンとして制約できます。

collect conditional element の前にバインドされた変数は、ソースと結果パターン両方のスコープ内にあります。このような変数を使用してこれらのパターンを制約します。しかし、collect はバインディングの scope delimiter であるため、内部のバインディングは外部では使用できません。

collect はネストされた from conditional elements を許可します。そのため、以下は collect の有効な使用例になります。

import java.util.LinkedList;
rule "Send a message to all mothers"
when
    $town : Town( name == 'Paris' )
    $mothers : LinkedList() 
    from collect( 
        Person( gender == 'F', children > 0 ) 
        from $town.getPeople() 
        )
then
    # send a message to all mothers
end

4.8.3.10. accumulate 条件要素

図4.43 accumulate

accumulate conditional element は collect よりも柔軟で強力な条件要素です。ルールはオブジェクトのコレクションにまたがって繰り返しでき、各要素に対してカスタムのアクションを実行できます。終了すると結果オブジェクトを返します。

accumulate conditional element の一般的な構文は次の通りです。

<result pattern> from accumulate(<source pattern>,
    init( <init code> ),
    action( <action code> ),
    reverse( <reverse code> ),
    result( <result expression> ) )

各要素の意味は次のようになります。

• <source pattern>: engine が各ソースオブジェクトとの一致を試みる通常のパターンです。
• <init code>: 選択されたダイアレクトのコードにある意味論ブロックです。ソースオブジェクトで繰り返しする前に各タプルに対して一度実行されます。
• <action code>: 各ソースオブジェクトに対して実行される選択されたオブジェクトにあるコードの意味論ブロックです。
• <reverse code>: 選択されたダイアレクトにあるコードの任意の意味論ブロックです。存在する場合、ソースパターンと一致しなくなった各ソースオブジェクトに対して実行されます。ソースオブジェクトが変更または取り消された時に engine が減分計算を行えるよう、<action code> ブロックで実行された計算を元に戻すことが目的です。このような操作のパフォーマンスを大幅に向上します。
• <result expression>: すべてのソースオブジェクトが繰り返し処理された後に実行される選択されたダイアレクトの意味論の式です。
• <result pattern>: engine が <result expression> から返されたオブジェクトと一致しようとする通常のパターンです。一致する場合、accumulate 条件要素が true として評価し、engine はルールにある次の条件要素を評価します。
  一致しない場合、 accumulate 条件要素は false として評価し、ルールの条件要素を評価することを停止します。

例は次の通りです。

rule "Apply 10% discount to orders over US$ 100,00"
when
    $order : Order()
    $total : Number( doubleValue > 100 ) 
    from accumulate( OrderItem( order == $order, $value : value ),
        init( double total = 0; ),
        action( total += $value; ),
        reverse( total -= $value; ),
        result( total ) )
then
    # apply discount to $order
end

この場合、以下が発生します。

1. engine は working memory の各 order に対する init のコード を実行します。これは、 total 変数をゼロに初期化します。
2. 次に、該当する注文に対する OrderItem オブジェクトすべてで繰り返し処理を行い、各オブジェクトに対してアクションを実行します (この場合、全商品の合計値が計算され、total 変数に置かれます)。
3. result expression に対応する値が返されます (total 変数の値)。
4. エンジンは結果を Number パターンに一致しようとします。double の値が 100 よりも大きい場合にルールが実行されます。

重要

この例では Java が意味論のダイアレクトとして使用されています。そのため、init、action、および reverse コードブロックではセミコロンをステートメントの区切り文字として使用しなければならないことに注意してください。結果は式であり、; は許可されません。他のダイアレクトを使用する場合は、常に特定の構文に従ってください。

重要

reverse code は任意ですが、update および retract の使用時にパフォーマンスが向上するため、Red Hat は reverse code の使用を強く推奨します。

accumulate conditional element を使用してソースオブジェクト上のアクションを実行します。次項の例は、カスタムオブジェクトをインスタンス化し、値を投入します。

4.8.3.10.1. Accumulate 関数

accumulate conditional element は非常に強力な CE ですが、累積関数 と呼ばれる事前定義された関数を使用する場合、特に簡単に使用することができます。累積関数は accumulate とほぼ同様に動作しますが、accumulate conditional element すべてにカスタムコードを明示的に記述する代わりに、一般的な操作に対して事前定義されたコードを使用できることが異なります。

例は次の通りです。これは、accumulate 関数を用いて、次のように注文に割引を適用するルールをプログラミングできることを表しています。

rule "Apply 10% discount to orders over US$ 100,00"
when
$order : Order()
$total : Number( doubleValue > 100 ) 
from accumulate( OrderItem( order == $order, $value : value ),
sum( $value ) )
then
# apply discount to $order
end

この場合、sum は accumulate 関数です。名前の通り、各 OrderItem の $value の合計を計算し、結果を返します。

JBoss Rules には以下の accumulate 関数が内蔵されています。

• average
• min
• max
• count
• sum

このような一般的な関数は、式を入力として受け入れます。たとえば、注文の全商品の平均利益を計算するには、次のように average 関数を使用してルールを記述します。

rule "Average profit"
when
    $order : Order()
    $profit : Number() 
    from accumulate( OrderItem( order == $order, $cost : cost, $price : price )
        average( 1 - $cost / $price ) )
then
    # average profit for $order is $profit
end

accumulate 関数はすべて プラグ可能 です。そのため、必要な場合はカスタマイズされたドメイン固有の関数を比較的簡単に engine へ追加することが可能です。追加後、ルールは制限なしでこれらの関数を使用できます。新しい accumulate 関数を実装するには、以下の手順に従います。

1. org.drools.base.acumulators.AccumulateFunction インターフェースを実装する Java クラスを作成します。
2. 設定ファイルに行を追加するか、システムプロパティーを設定し、engine に新しい関数について知らせます。
   次の例は、average 関数の実装を示しています。

   /*
   * Copyright 2007 JBoss Inc
   * 
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   * 
   *      http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *
   * Created on Jun 21, 2007
   */
   package org.drools.base.accumulators;
   
   
   /**
   * An implementation of an accumulator capable of calculating average values
   * 
   * @author etirelli
   *
   */
   public class AverageAccumulateFunction implements AccumulateFunction {
   
   protected static class AverageData {
   public int    count = 0;
   public double total = 0;
   }
   
   /* (non-Javadoc)
   * @see org.drools.base.accumulators.AccumulateFunction#createContext()
   */
   public Object createContext() {
   return new AverageData();
   }
   
   /* (non-Javadoc)
   * @see org.drools.base.accumulators.AccumulateFunction#init(java.lang.Object)
   */
   public void init(Object context) throws Exception {
   AverageData data = (AverageData) context;
   data.count = 0;
   data.total = 0;
   }
   
   /* (non-Javadoc)
   * @see org.drools.base.accumulators.AccumulateFunction#accumulate(java.lang.Object,
   * java.lang.Object)
   */
   public void accumulate(Object context,
                  Object value) {
   AverageData data = (AverageData) context;
   data.count++;
   data.total += ((Number) value).doubleValue();
   }
   
   /* (non-Javadoc)
   * @see org.drools.base.accumulators.AccumulateFunction#reverse(java.lang.Object,
   * java.lang.Object)
   */
   public void reverse(Object context,
               Object value) throws Exception {
   AverageData data = (AverageData) context;
   data.count--;
   data.total -= ((Number) value).doubleValue();
   }
   
   /* (non-Javadoc)
   * @see org.drools.base.accumulators.AccumulateFunction#getResult(java.lang.Object)
   */
   public Object getResult(Object context) throws Exception {
   AverageData data = (AverageData) context;
   return new Double( data.count == 0 ? 0 : data.total / data.count );
   }
   
   /* (non-Javadoc)
   * @see org.drools.base.accumulators.AccumulateFunction#supportsReverse()
   */
   public boolean supportsReverse() {
   return true;
   }
   
   }
   

   統合の作業はすべて engine によって実行されるため、コードは非常に簡単です。
3. 機能を engine へプラグするには、configuration ファイルへ追加します。

   drools.accumulate.function.average =
       org.drools.base.accumulators.AverageAccumulateFunction
   

   重要

   必ず drools.accumulate.function. プレフィックスを使用してください。
   average は関数がルールファイルでどのように使用されるかを制御します。org.drools.base.accumulators.AverageAccumulateFunction は関数の動作を実装するクラスの完全修飾名です。

[when]Something is {color}=Something(color=="{color}")

[when]This is "{something}" and "{another}"=Something(something=="{something}", another=="{another}")
[when]This is {also} valid=Another(something=="{also}")

[then]do something= if (foo) \{ doSomething(); \}

#This is a comment to be ignored.
[when]There is a Person with name of "{name}"=Person(name=="{name}")
[when]Person is at least {age} years old and lives in "{location}"=Person(age >= {age}, location=="{location}")
[then]Log "{message}"=System.out.println("{message}");
[when]And = and

There is a Person with name of "kitty" 
  ==> Person(name="kitty")
Person is at least 42 years old and lives in "Atlanta" 
  ==> Person(age > 42, location="Atlanta")
Log "boo" 
  ==> System.out.println("boo");
There is a Person with name of "Bob" and Person is at least 30 years old and lives in "Atlanta" 
  ==> Person(name="kitty") and Person(age > 30, location="Atlanta")

Cheese(age < 5, price == 20, type=="stilton", country=="ch")

[when]There is a Cheese with=Cheese()
[when]- age is less than {age}=age<{age}
[when]- type is '{type}'=type=='{type}'
[when]- country equal to '{country}'=country=='{country}'

There is a Cheese with
        - age is less than 42
        - type is 'stilton'

Cheese(age<42, type=='stilton')

[when][]is less than or equal to=<=
[when][]is less than=<
[when][]is greater than or equal to=>=
[when][]is greater than=>
[when][]is equal to===
[when][]equals===
[when][]There is a Cheese with=Cheese()

# Comment: DSL examples

#/ debug: display result and usage

# keyword definition: replaces "regula" by "rule"
[keyword][]regula=rule

# conditional element: "T" or "t", "a" or "an", convert matched word
[when][][Tt]here is an? {entity:\w+}=
        ${entity!lc}: ${entity!ucfirst} ()

# consequence statement: convert matched word, literal braces
[then][]update {entity:\w+}=modify( ${entity!lc} )\{ \}

# definitions for conditions
[when][]There is an? {entity}=${entity!lc}: {entity!ucfirst}()
[when][]- with an? {attr} greater than {amount}={attr} <= {amount!num}
[when][]- with a {what} {attr}={attr} {what!positive?>0/negative?%lt;0/zero?==0/ERROR}

KnowledgeBuilder kBuilder = new KnowledgeBuilder();
Resource dsl = ResourceFactory.newClassPathResource( dslPath, getClass() );
kBuilder.add( dsl, ResourceType.DSL );
Resource dslr = ResourceFactory.newClassPathResource( dslrPath, getClass() );
kBuilder.add( dslr, ResourceType.DSLR );

<?xml version="1.0" encoding="UTF-8"?>

<package name="com.sample"
  xmlns="http://drools.org/drools-4.0"
  xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
  xs:schemaLocation="http://drools.org/drools-4.0 drools-4.0.xsd">

  <import name="java.util.HashMap" />
  <import name="org.drools.*" />

  <global identifier="x" type="com.sample.X" />
  <global identifier="yada" type="com.sample.Yada" />

  <function return-type="void" name="myFunc">
    <parameter identifier="foo" type="Bar" />
    <parameter identifier="bada" type="Bing" />
    <body>System.out.println("hello world");</body>
  </function>

  <rule name="simple_rule">
    <rule-attribute name="salience" value="10" />
    <rule-attribute name="no-loop" value="true" />
    <rule-attribute name="agenda-group" value="agenda-group" />
    <rule-attribute name="activation-group" value="activation-group" />

    <lhs>
      <pattern identifier="foo2" object-type="Bar" >
        <or-constraint-connective>
          <and-constraint-connective>
            <field-constraint field-name="a">
              <or-restriction-connective>
                <and-restriction-connective>
                  <literal-restriction evaluator=">" value="60" />
                  <literal-restriction evaluator="<" value="70" />
                </and-restriction-connective>
                <and-restriction-connective>
                  <literal-restriction evaluator="<" value="50" />
                  <literal-restriction evaluator=">" value="55" />
                </and-restriction-connective>
              </or-restriction-connective>
            </field-constraint>

            <field-constraint field-name="a3">
              <literal-restriction evaluator="==" value="black" />
            </field-constraint>
          </and-constraint-connective>

          <and-constraint-connective>
            <field-constraint field-name="a">
              <literal-restriction evaluator="==" value="40" />
            </field-constraint>

            <field-constraint field-name="a3">
              <literal-restriction evaluator="==" value="pink" />
            </field-constraint>
          </and-constraint-connective>

          <and-constraint-connective>
            <field-constraint field-name="a">
              <literal-restriction evaluator="==" value="12"/>
            </field-constraint>

            <field-constraint field-name="a3">
              <or-restriction-connective>
                <literal-restriction evaluator="==" value="yellow"/>
                <literal-restriction evaluator="==" value="blue" />
              </or-restriction-connective>
            </field-constraint>
          </and-constraint-connective>
        </or-constraint-connective>
      </pattern>

      <not>
        <pattern object-type="Person">
          <field-constraint field-name="likes">
            <variable-restriction evaluator="==" identifier="type"/>
          </field-constraint>
        </pattern>

        <exists>
          <pattern object-type="Person">
            <field-constraint field-name="likes">
              <variable-restriction evaluator="==" identifier="type"/>
            </field-constraint>
          </pattern>        
        </exists>
      </not>

      <or-conditional-element>
        <pattern identifier="foo3" object-type="Bar" >
          <field-constraint field-name="a">
            <or-restriction-connective>
              <literal-restriction evaluator="==" value="3" />
              <literal-restriction evaluator="==" value="4" />
            </or-restriction-connective>
          </field-constraint>
          <field-constraint field-name="a3">
            <literal-restriction evaluator="==" value="hello" />
          </field-constraint>
          <field-constraint field-name="a4">
            <literal-restriction evaluator="==" value="null" />
          </field-constraint>
        </pattern>

        <pattern identifier="foo4" object-type="Bar" >
          <field-binding field-name="a" identifier="a4" />
          <field-constraint field-name="a">
            <literal-restriction evaluator="!=" value="4" />
            <literal-restriction evaluator="!=" value="5" />
          </field-constraint>
        </pattern>
      </or-conditional-element>

      <pattern identifier="foo5" object-type="Bar" >
        <field-constraint field-name="b">
          <or-restriction-connective>
            <return-value-restriction evaluator="==" >
              a4 + 1
            </return-value-restriction>
            <variable-restriction evaluator=">" identifier="a4" />
            <qualified-identifier-restriction evaluator="==">
              org.drools.Bar.BAR_ENUM_VALUE
            </qualified-identifier-restriction>
          </or-restriction-connective>
        </field-constraint>      
      </pattern>

      <pattern identifier="foo6" object-type="Bar" >
        <field-binding field-name="a" identifier="a4" />
        <field-constraint field-name="b">
          <literal-restriction evaluator="==" value="6" />
        </field-constraint>
      </pattern>
    </lhs>
    <rhs>
      if ( a == b ) {
      assert( foo3 );
      } else {
      retract( foo4 );
      }
      System.out.println( a4 );
    </rhs>
  </rule>

</package>

<rule name="simple_rule">
<rule-attribute name="salience" value="10" />
<rule-attribute name="no-loop" value="true" />
<rule-attribute name="agenda-group" value="agenda-group" />
<rule-attribute name="activation-group" value="activation-group" />

<lhs>
    <pattern identifier="cheese" object-type="Cheese">
        <from>
            <accumulate>
                <pattern object-type="Person"></pattern>
                <init>
                    int total = 0;
                </init>
                <action>
                    total += $cheese.getPrice();
                </action>
                <result>
                    new Integer( total ) );
                </result>
            </accumulate>
        </from>
    </pattern>

    <pattern identifier="max" object-type="Number">
        <from>
            <accumulate>
               <pattern identifier="cheese" object-type="Cheese"></pattern>
               <external-function evaluator="max" expression="$price"/>
            </accumulate>
        </from>
    </pattern>
</lhs>
<rhs>
    list1.add( $cheese );
</rhs>
</rule>

XmlDumper - XML のエキスポート。
DrlDumper - DRL のエキスポート
DrlParser - DRL の読み取り。
XmlPackageReader - XML の読み取り。