hql學習

Hibernate配備了一種非常強大的查詢語言，這種語言看上去很像SQL。但是不要被文法結構上的相似所迷惑，HQL是非常有意識的被設計為完全面向對象的查詢，它可以了解如繼承、多态和關聯之類的概念。

第 15 章 HQL: Hibernate查詢語言

15.1. 大小寫敏感性問題

除了Java類與屬性的名稱外，查詢語句對大小寫并不敏感。是以 SeLeCT 與 sELEct 以及 SELECT 是相同的，但是 org.hibernate.eg.FOO 并不等價于 org.hibernate.eg.Foo 并且 foo.barSet 也不等價于 foo.BARSET。

本手冊中的HQL關鍵字将使用小寫字母. 很多使用者發現使用完全大寫的關鍵字會使查詢語句的可讀性更強, 但我們發現，當把查詢語句嵌入到Java語句中的時候使用大寫關鍵字比較難看。

15.2. from子句

Hibernate中最簡單的查詢語句的形式如下：

from eg.Cat

該子句簡單的傳回eg.Cat類的所有執行個體。通常我們不需要使用類的全限定名, 因為 auto-import（自動引入）是預設的情況。是以我們幾乎隻使用如下的簡單寫法：

from Cat

大多數情況下, 你需要指定一個别名, 原因是你可能需要在查詢語句的其它部分引用到Cat

from Cat as cat

這個語句把别名cat指定給類Cat 的執行個體, 這樣我們就可以在随後的查詢中使用此别名了。關鍵字as 是可選的，我們也可以這樣寫:

from Cat cat

子句中可以同時出現多個類, 其查詢結果是産生一個笛卡兒積或産生跨表的連接配接。

from Formula, Parameter

from Formula as form, Parameter as param

查詢語句中别名的開頭部分小寫被認為是實踐中的好習慣，這樣做與Java變量的命名标準保持了一緻 (比如，domesticCat)。

15.3. 關聯(Association)與連接配接(Join)

我們也可以為相關聯的實體甚至是對一個集合中的全部元素指定一個别名, 這時要使用關鍵字join。

from Cat as cat 
    inner join cat.mate as mate
    left outer join cat.kittens as kitten

from Cat as cat left join cat.mate.kittens as kittens

from Formula form full join form.parameter param

受支援的連接配接類型是從ANSI SQL中借鑒來的。

inner join（内連接配接）
left outer join（左外連接配接）
right outer join（右外連接配接）
full join (全連接配接，并不常用)

語句inner join, left outer join 以及 right outer join 可以簡寫。

from Cat as cat 
    join cat.mate as mate
    left join cat.kittens as kitten

還有，一個"fetch"連接配接允許僅僅使用一個選擇語句就将相關聯的對象或一組值的集合随着他們的父對象的初始化而被初始化，這種方法在使用到集合的情況下尤其有用，對于關聯和集合來說，它有效的代替了映射檔案中的外聯接與延遲聲明（lazy declarations）. 檢視第 20.1 節 “ 抓取政策(Fetching strategies) ” 以獲得等多的資訊。

from Cat as cat 
    inner join fetch cat.mate
    left join fetch cat.kittens

一個fetch連接配接通常不需要被指定别名, 因為相關聯的對象不應當被用在 where 子句 (或其它任何子句)中。同時，相關聯的對象并不在查詢的結果中直接傳回，但可以通過他們的父對象來通路到他們。

注意fetch構造變量在使用了scroll() 或 iterate()函數的查詢中是不能使用的。最後注意，使用full join fetch 與 right join fetch是沒有意義的。

如果你使用屬性級别的延遲擷取（lazy fetching）（這是通過重新編寫位元組碼實作的），可以使用 fetch all properties 來強制Hibernate立即取得那些原本需要延遲加載的屬性（在第一個查詢中）。

from Document fetch all properties order by name

from Document doc fetch all properties where lower(doc.name) like '%cats%'

15.4. select子句

select 子句選擇将哪些對象與屬性返回到查詢結果集中. 考慮如下情況:

select mate 
from Cat as cat 
    inner join cat.mate as mate

該語句将選擇mates of other Cats。（其他貓的配偶）實際上, 你可以更簡潔的用以下的查詢語句表達相同的含義:

select cat.mate from Cat cat

查詢語句可以傳回值為任何類型的屬性，包括傳回類型為某種元件(Component)的屬性:

select cat.name from DomesticCat cat
where cat.name like 'fri%'

select cust.name.firstName from Customer as cust

查詢語句可以傳回多個對象和（或）屬性，存放在 Object[]隊列中,

select mother, offspr, mate.name 
from DomesticCat as mother
    inner join mother.mate as mate
    left outer join mother.kittens as offspr

或存放在一個List對象中,

select new list(mother, offspr, mate.name)
from DomesticCat as mother
    inner join mother.mate as mate
    left outer join mother.kittens as offspr

也可能直接傳回一個實際的類型安全的Java對象,

select new Family(mother, mate, offspr)
from DomesticCat as mother
    join mother.mate as mate
    left join mother.kittens as offspr

假設類Family有一個合适的構造函數.

你可以使用關鍵字as給“被選擇了的表達式”指派别名:

select max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n
from Cat cat

這種做法在與子句select new map一起使用時最有用:

select new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n )
from Cat cat

該查詢傳回了一個Map的對象，内容是别名與被選擇的值組成的名-值映射。

15.5. 聚集函數

HQL查詢甚至可以傳回作用于屬性之上的聚集函數的計算結果:

select avg(cat.weight), sum(cat.weight), max(cat.weight), count(cat)
from Cat cat

受支援的聚集函數如下：

avg(...), sum(...), min(...), max(...)
count(*)
count(...), count(distinct ...), count(all...)

你可以在選擇子句中使用數學操作符、連接配接以及經過驗證的SQL函數：

select cat.weight + sum(kitten.weight) 
from Cat cat 
    join cat.kittens kitten
group by cat.id, cat.weight

select firstName||' '||initial||' '||upper(lastName) from Person

關鍵字distinct與all 也可以使用，它們具有與SQL相同的語義.

select distinct cat.name from Cat cat

select count(distinct cat.name), count(cat) from Cat cat

15.6. 多态查詢

一個如下的查詢語句:

from Cat as cat

不僅傳回Cat類的執行個體, 也同時傳回子類 DomesticCat的執行個體. Hibernate 可以在from子句中指定任何 Java 類或接口. 查詢會傳回繼承了該類的所有持久化子類的執行個體或傳回聲明了該接口的所有持久化類的執行個體。下面的查詢語句傳回所有的被持久化的對象：

from java.lang.Object o

接口Named 可能被各種各樣的持久化類聲明：

from Named n, Named m where n.name = m.name

注意，最後的兩個查詢将需要超過一個的SQL SELECT.這表明order by子句沒有對整個結果集進行正确的排序. (這也說明你不能對這樣的查詢使用Query.scroll()方法.)

15.7. where子句

where子句允許你将傳回的執行個體清單的範圍縮小. 如果沒有指定别名，你可以使用屬性名來直接引用屬性:

from Cat where name='Fritz'

如果指派了别名，需要使用完整的屬性名:

from Cat as cat where cat.name='Fritz'

傳回名為（屬性name等于）'Fritz'的Cat類的執行個體。

select foo 
from Foo foo, Bar bar
where foo.startDate = bar.date

将傳回所有滿足下面條件的Foo類的執行個體：存在如下的bar的一個執行個體，其date屬性等于 Foo的startDate屬性。複合路徑表達式使得where子句非常的強大，考慮如下情況：

from Cat cat where cat.mate.name is not null

該查詢将被翻譯成為一個含有表連接配接（内連接配接）的SQL查詢。如果你打算寫像這樣的查詢語句

from Foo foo  
where foo.bar.baz.customer.address.city is not null

在SQL中，你為達此目的将需要進行一個四表連接配接的查詢。

=運算符不僅可以被用來比較屬性的值，也可以用來比較執行個體：

from Cat cat, Cat rival where cat.mate = rival.mate

select cat, mate 
from Cat cat, Cat mate
where cat.mate = mate

特殊屬性（小寫）id可以用來表示一個對象的唯一的辨別符。（你也可以使用該對象的屬性名。）

from Cat as cat where cat.id = 123

from Cat as cat where cat.mate.id = 69

第二個查詢是有效的。此時不需要進行表連接配接！

同樣也可以使用複合辨別符。比如Person類有一個複合辨別符，它由country屬性與medicareNumber屬性組成。

from bank.Person person
where person.id.country = 'AU' 
    and person.id.medicareNumber = 123456

from bank.Account account
where account.owner.id.country = 'AU' 
    and account.owner.id.medicareNumber = 123456

第二個查詢也不需要進行表連接配接。

同樣的，特殊屬性class在進行多态持久化的情況下被用來存取一個執行個體的鑒别值（discriminator value）。一個嵌入到where子句中的Java類的名字将被轉換為該類的鑒别值。

from Cat cat where cat.class = DomesticCat

你也可以聲明一個屬性的類型是元件或者複合使用者類型（以及由元件構成的元件等等）。永遠不要嘗試使用以元件類型來結尾的路徑表達式（path-expression）（與此相反，你應當使用元件的一個屬性來結尾）。舉例來說，如果store.owner含有一個包含了元件的實體address

store.owner.address.city    // 正确
store.owner.address         // 錯誤!

一個“任意”類型有兩個特殊的屬性id和class, 來允許我們按照下面的方式表達一個連接配接（AuditLog.item 是一個屬性，該屬性被映射為<any>）。

from AuditLog log, Payment payment 
where log.item.class = 'Payment' and log.item.id = payment.id

注意，在上面的查詢與句中，log.item.class 和 payment.class 将涉及到完全不同的資料庫中的列。

15.8. 表達式

在where子句中允許使用的表達式包括大多數你可以在SQL使用的表達式種類:

數學運算符+, -, *, /
二進制比較運算符=, >=, <=, <>, !=, like
邏輯運算符and, or, not
in, not in, between, is null, is not null, is empty, is not empty, member of and not member of
"簡單的" case, case ... when ... then ... else ... end,和 "搜尋" case, case when ... then ... else ... end
字元串連接配接符...||... or concat(...,...)
current_date(), current_time(), current_timestamp()
second(...), minute(...), hour(...), day(...), month(...), year(...),
EJB-QL 3.0定義的任何函數或操作：substring(), trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length()
coalesce() 和 nullif()
cast(... as ...), 其第二個參數是某Hibernate類型的名字，以及extract(... from ...)，隻要ANSI cast() 和 extract() 被底層資料庫支援
任何資料庫支援的SQL标量函數，比如sign(), trunc(), rtrim(), sin()
JDBC參數傳入 ?
命名參數:name, :start_date, :x1
SQL 直接常量 'foo', 69, '1970-01-01 10:00:01.0'
Java public static final 類型的常量 eg.Color.TABBY

關鍵字in與between可按如下方法使用:

from DomesticCat cat where cat.name between 'A' and 'B'

from DomesticCat cat where cat.name in ( 'Foo', 'Bar', 'Baz' )

而且否定的格式也可以如下書寫：

from DomesticCat cat where cat.name not between 'A' and 'B'

from DomesticCat cat where cat.name not in ( 'Foo', 'Bar', 'Baz' )

同樣, 子句is null與is not null可以被用來測試空值(null).

在Hibernate配置檔案中聲明HQL“查詢替代（query substitutions）”之後，布爾表達式（Booleans）可以在其他表達式中輕松的使用:

<property name="hibernate.query.substitutions">true 1, false 0</property>

系統将該HQL轉換為SQL語句時，該設定表明将用字元 1 和 0 來取代關鍵字true 和 false:

from Cat cat where cat.alive = true

你可以用特殊屬性size, 或是特殊函數size()測試一個集合的大小。

from Cat cat where cat.kittens.size > 0

from Cat cat where size(cat.kittens) > 0

對于索引了（有序）的集合，你可以使用minindex 與 maxindex函數來引用到最小與最大的索引序數。同理，你可以使用minelement 與maxelement函數來引用到一個基本資料類型的集合中最小與最大的元素。

from Calendar cal where maxelement(cal.holidays) > current date

from Order order where maxindex(order.items) > 100

from Order order where minelement(order.items) > 10000

在傳遞一個集合的索引集或者是元素集(elements與indices 函數) 或者傳遞一個子查詢的結果的時候，可以使用SQL函數any, some, all, exists, in

select mother from Cat as mother, Cat as kit
where kit in elements(foo.kittens)

select p from NameList list, Person p
where p.name = some elements(list.names)

from Cat cat where exists elements(cat.kittens)

from Player p where 3 > all elements(p.scores)

from Show show where 'fizard' in indices(show.acts)

注意，在Hibernate3種，這些結構變量- size, elements, indices, minindex, maxindex, minelement, maxelement - 隻能在where子句中使用。

一個被索引過的（有序的）集合的元素(arrays, lists, maps)可以在其他索引中被引用（隻能在where子句中）：

from Order order where order.items[0].id = 1234

select person from Person person, Calendar calendar
where calendar.holidays['national day'] = person.birthDay
    and person.nationality.calendar = calendar

select item from Item item, Order order
where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11

select item from Item item, Order order
where order.items[ maxindex(order.items) ] = item and order.id = 11

在[]中的表達式甚至可以是一個算數表達式。

select item from Item item, Order order
where order.items[ size(order.items) - 1 ] = item

對于一個一對多的關聯（one-to-many association）或是值的集合中的元素， HQL也提供内建的index()函數，

select item, index(item) from Order order 
    join order.items item
where index(item) < 5

如果底層資料庫支援标量的SQL函數，它們也可以被使用

from DomesticCat cat where upper(cat.name) like 'FRI%'

如果你還不能對所有的這些深信不疑，想想下面的查詢。如果使用SQL，語句長度會增長多少，可讀性會下降多少：

select cust
from Product prod,
    Store store
    inner join store.customers cust
where prod.name = 'widget'
    and store.location.name in ( 'Melbourne', 'Sydney' )
    and prod = all elements(cust.currentOrder.lineItems)

提示: 會像如下的語句

SELECT cust.name, cust.address, cust.phone, cust.id, cust.current_order
FROM customers cust,
    stores store,
    locations loc,
    store_customers sc,
    product prod
WHERE prod.name = 'widget'
    AND store.loc_id = loc.id
    AND loc.name IN ( 'Melbourne', 'Sydney' )
    AND sc.store_id = store.id
    AND sc.cust_id = cust.id
    AND prod.id = ALL(
        SELECT item.prod_id
        FROM line_items item, orders o
        WHERE item.order_id = o.id
            AND cust.current_order = o.id
    )

15.9. order by子句

查詢傳回的清單(list)可以按照一個傳回的類或元件（components)中的任何屬性（property）進行排序：

from DomesticCat cat
order by cat.name asc, cat.weight desc, cat.birthdate

可選的asc或desc關鍵字指明了按照升序或降序進行排序.

15.10. group by子句

一個傳回聚集值(aggregate values)的查詢可以按照一個傳回的類或元件（components)中的任何屬性（property）進行分組：

select cat.color, sum(cat.weight), count(cat) 
from Cat cat
group by cat.color

select foo.id, avg(name), max(name) 
from Foo foo join foo.names name
group by foo.id

having子句在這裡也允許使用.

select cat.color, sum(cat.weight), count(cat) 
from Cat cat
group by cat.color 
having cat.color in (eg.Color.TABBY, eg.Color.BLACK)

如果底層的資料庫支援的話(例如不能在MySQL中使用)，SQL的一般函數與聚集函數也可以出現在having與order by 子句中。

select cat
from Cat cat
    join cat.kittens kitten
group by cat
having avg(kitten.weight) > 100
order by count(kitten) asc, sum(kitten.weight) desc

注意group by子句與 order by子句中都不能包含算術表達式（arithmetic expressions）.

15.11. 子查詢

對于支援子查詢的資料庫，Hibernate支援在查詢中使用子查詢。一個子查詢必須被圓括号包圍起來（經常是SQL聚集函數的圓括号）。甚至互相關聯的子查詢（引用到外部查詢中的别名的子查詢）也是允許的。

from Cat as fatcat 
where fatcat.weight > ( 
    select avg(cat.weight) from DomesticCat cat 
)

from DomesticCat as cat 
where cat.name = some ( 
    select name.nickName from Name as name 
)

from Cat as cat 
where not exists ( 
    from Cat as mate where mate.mate = cat 
)

from DomesticCat as cat 
where cat.name not in ( 
    select name.nickName from Name as name 
)

在select清單中包含一個表達式以上的子查詢，你可以使用一個元組構造符（tuple constructors）：

from Cat as cat 
where not ( cat.name, cat.color ) in ( 
    select cat.name, cat.color from DomesticCat cat 
)

注意在某些資料庫中（不包括Oracle與HSQL），你也可以在其他語境中使用元組構造符，比如查詢使用者類型的元件與組合：

from Person where name = ('Gavin', 'A', 'King')

該查詢等價于更複雜的：

from Person where name.first = 'Gavin' and name.initial = 'A' and name.last = 'King')

有兩個很好的理由使你不應當作這樣的事情：首先，它不完全适用于各個資料庫平台；其次，查詢現在依賴于映射檔案中屬性的順序。

15.12. HQL示例

Hibernate查詢可以非常的強大與複雜。實際上，Hibernate的一個主要賣點就是查詢語句的威力。這裡有一些例子，它們與我在最近的一個項目中使用的查詢非常相似。注意你能用到的大多數查詢比這些要簡單的多！

下面的查詢對于某個特定的客戶的所有未支付的賬單，在給定給最小總價值的情況下，傳回訂單的id，條目的數量和總價值，傳回值按照總價值的結果進行排序。為了決定價格，查詢使用了目前目錄。作為轉換結果的SQL查詢，使用了ORDER, ORDER_LINE, PRODUCT, CATALOG 和PRICE 庫表。

select order.id, sum(price.amount), count(item)
from Order as order
    join order.lineItems as item
    join item.product as product,
    Catalog as catalog
    join catalog.prices as price
where order.paid = false
    and order.customer = :customer
    and price.product = product
    and catalog.effectiveDate < sysdate
    and catalog.effectiveDate >= all (
        select cat.effectiveDate 
        from Catalog as cat
        where cat.effectiveDate < sysdate
    )
group by order
having sum(price.amount) > :minAmount
order by sum(price.amount) desc

這簡直是一個怪物！實際上，在現實生活中，我并不熱衷于子查詢，是以我的查詢語句看起來更像這個：

select order.id, sum(price.amount), count(item)
from Order as order
    join order.lineItems as item
    join item.product as product,
    Catalog as catalog
    join catalog.prices as price
where order.paid = false
    and order.customer = :customer
    and price.product = product
    and catalog = :currentCatalog
group by order
having sum(price.amount) > :minAmount
order by sum(price.amount) desc

下面一個查詢計算每一種狀态下的支付的數目，除去所有處于AWAITING_APPROVAL狀态的支付，因為在該狀态下目前的使用者作出了狀态的最新改變。該查詢被轉換成含有兩個内連接配接以及一個相關聯的子選擇的SQL查詢，該查詢使用了表 PAYMENT, PAYMENT_STATUS 以及PAYMENT_STATUS_CHANGE。

select count(payment), status.name 
from Payment as payment 
    join payment.currentStatus as status
    join payment.statusChanges as statusChange
where payment.status.name <> PaymentStatus.AWAITING_APPROVAL
    or (
        statusChange.timeStamp = ( 
            select max(change.timeStamp) 
            from PaymentStatusChange change 
            where change.payment = payment
        )
        and statusChange.user <> :currentUser
    )
group by status.name, status.sortOrder
order by status.sortOrder

如果我把statusChanges執行個體集映射為一個清單（list）而不是一個集合（set）, 書寫查詢語句将更加簡單.

select count(payment), status.name 
from Payment as payment
    join payment.currentStatus as status
where payment.status.name <> PaymentStatus.AWAITING_APPROVAL
    or payment.statusChanges[ maxIndex(payment.statusChanges) ].user <> :currentUser
group by status.name, status.sortOrder
order by status.sortOrder

下面一個查詢使用了MS SQL Server的 isNull()函數用以傳回目前使用者所屬組織的組織帳号及組織未支付的賬。它被轉換成一個對表ACCOUNT,PAYMENT, PAYMENT_STATUS, ACCOUNT_TYPE, ORGANIZATION 以及 ORG_USER進行的三個内連接配接，一個外連接配接和一個子選擇的SQL查詢。

select account, payment
from Account as account
    left outer join account.payments as payment
where :currentUser in elements(account.holder.users)
    and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)
order by account.type.sortOrder, account.accountNumber, payment.dueDate

對于一些資料庫，我們需要棄用（相關的）子選擇。

select account, payment
from Account as account
    join account.holder.users as user
    left outer join account.payments as payment
where :currentUser = user
    and PaymentStatus.UNPAID = isNull(payment.currentStatus.name, PaymentStatus.UNPAID)
order by account.type.sortOrder, account.accountNumber, payment.dueDate

15.13. 批量的UPDATE & DELETE語句

HQL現在支援UPDATE與DELETE語句. 查閱第 14.3 節 “大批量更新/删除（Bulk update/delete）” 以獲得更多資訊。

15.14. 小技巧 & 小竅門

你可以統計查詢結果的數目而不必實際的傳回他們：

( (Integer) session.iterate("select count(*) from ....").next() ).intValue()

若想根據一個集合的大小來進行排序，可以使用如下的語句：

select usr.id, usr.name
from User as usr 
    left join usr.messages as msg
group by usr.id, usr.name
order by count(msg)

如果你的資料庫支援子選擇，你可以在你的查詢的where子句中為選擇的大小（selection size）指定一個條件:

from User usr where size(usr.messages) >= 1

如果你的資料庫不支援子選擇語句，使用下面的查詢：

select usr.id, usr.name
from User usr.name
    join usr.messages msg
group by usr.id, usr.name
having count(msg) >= 1

因為内連接配接（inner join）的原因，這個解決方案不能傳回含有零個資訊的User 類的執行個體, 是以這種情況下使用下面的格式将是有幫助的:

select usr.id, usr.name
from User as usr
    left join usr.messages as msg
group by usr.id, usr.name
having count(msg) = 0

JavaBean的屬性可以被綁定到一個命名查詢（named query）的參數上：

Query q = s.createQuery("from foo Foo as foo where foo.name=:name and foo.size=:size");
q.setProperties(fooBean); // fooBean包含方法getName()與getSize()
List foos = q.list();

通過将接口Query與一個過濾器（filter）一起使用，集合（Collections）是可以分頁的：

Query q = s.createFilter( collection, "" ); // 一個簡單的過濾器
q.setMaxResults(PAGE_SIZE);
q.setFirstResult(PAGE_SIZE * pageNumber);
List page = q.list();

通過使用查詢過濾器（query filter）可以将集合（Collection）的原素分組或排序:

Collection orderedCollection = s.filter( collection, "order by this.amount" );
Collection counts = s.filter( collection, "select this.type, count(this) group by this.type" );

不用通過初始化，你就可以知道一個集合（Collection）的大小：

( (Integer) session.iterate("select count(*) from ....").next() ).intValue();

hql學習

第 15 章 HQL: Hibernate查詢語言

15.1. 大小寫敏感性問題

15.2. from子句

15.3. 關聯(Association)與連接配接(Join)

15.4. select子句

15.5. 聚集函數

15.6. 多态查詢

15.7. where子句

15.8. 表達式

15.9. order by子句

15.10. group by子句

15.11. 子查詢

15.12. HQL示例

15.13. 批量的UPDATE & DELETE語句

15.14. 小技巧 & 小竅門

繼續閱讀

關于Gradle配置的小結

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method