CalciteAssert.AssertQuery (Apache Calcite API)

java.lang.Object
- org.apache.calcite.test.CalciteAssert.AssertQuery

封闭类:

CalciteAssert
```
public static class CalciteAssert.AssertQuery
extends Object
```
Fluent interface for building a query to be tested.

方法概要

所有方法实例方法具体方法已过时的方法
限定符和类型	方法和说明
`CalciteAssert.AssertQuery`	`consumesPreparedStatement(CalciteAssert.PreparedStatementConsumer consumer)`
`CalciteAssert.AssertQuery`	`convertContains(String expected)` Checks that when the query (which was set using `CalciteAssert.AssertThat.query(String)`) is converted to a relational algebra expression matching the given string.
`CalciteAssert.AssertQuery`	`convertMatches(Consumer<org.apache.calcite.rel.RelNode> checker)`
`protected Connection`	`createConnection()`
`CalciteAssert.AssertQuery`	`enable(boolean enabled)`
`CalciteAssert.AssertQuery`	`enableMaterializations(boolean materializationsEnabled)`
`CalciteAssert.AssertQuery`	`explainContains(String expected)`
`CalciteAssert.AssertQuery`	`explainHookContains(org.apache.calcite.sql.SqlExplainLevel sqlExplainLevel, String expectedPlan)` This enables to assert the optimized plan without issuing a separate `explain ...`
`CalciteAssert.AssertQuery`	`explainHookContains(String expectedPlan)` This enables to assert the optimized plan without issuing a separate `explain ...`
`CalciteAssert.AssertQuery`	`explainHookMatches(org.hamcrest.Matcher<String> planMatcher)` This enables to assert the optimized plan without issuing a separate `explain ...`
`CalciteAssert.AssertQuery`	`explainHookMatches(org.apache.calcite.sql.SqlExplainLevel sqlExplainLevel, org.hamcrest.Matcher<String> planMatcher)` This enables to assert the optimized plan without issuing a separate `explain ...`
`CalciteAssert.AssertQuery`	`explainHookMatches(String expectedPlan)` This enables to assert the optimized plan without issuing a separate `explain ...`
`CalciteAssert.AssertQuery`	`explainMatches(String extra, Consumer<ResultSet> checker)`
`CalciteAssert.AssertQuery`	`failsAtValidation()` Utility method so that one doesn't have to call `failsAtValidation(java.lang.String)` with `null`.
`CalciteAssert.AssertQuery`	`failsAtValidation(String optionalMessage)` Used to check whether a sql statement fails at the SQL Validation phase.
`CalciteAssert.AssertQuery`	`limit(int limit)` Sets a limit on the number of rows returned. -1 means no limit.
`CalciteAssert.AssertQuery`	`planContains(String expected)`
`CalciteAssert.AssertQuery`	`planHasSql(String expected)`
`CalciteAssert.AssertQuery`	`planUpdateHasSql(String expected, int count)`
`CalciteAssert.AssertQuery`	`queryContains(Consumer<List> predicate1)` Runs the query and applies a checker to the generated third-party queries.
`CalciteAssert.AssertQuery`	`queryContains(com.google.common.base.Function<List,Void> predicate1)` 已过时。 Use `queryContains(Consumer)`.
`CalciteAssert.AssertQuery`	`returns(Consumer<ResultSet> checker)`
`CalciteAssert.AssertQuery`	`returns(String expected)`
`protected CalciteAssert.AssertQuery`	`returns(String sql, Consumer<ResultSet> checker)`
`CalciteAssert.AssertQuery`	`returns2(String expected)` Similar to `returns(java.lang.String)`, but trims a few values before comparing.
`CalciteAssert.AssertQuery`	`returnsCount(int expectedCount)`
`CalciteAssert.AssertQuery`	`returnsOrdered(String... lines)`
`CalciteAssert.AssertQuery`	`returnsStartingWith(String... lines)`
`CalciteAssert.AssertQuery`	`returnsUnordered(String... lines)`
`CalciteAssert.AssertQuery`	`returnsValue(String expected)`
`CalciteAssert.AssertQuery`	`runs()`
`void`	`sameResultWithMaterializationsDisabled()`
`CalciteAssert.AssertQuery`	`substitutionMatches(Consumer<org.apache.calcite.rel.RelNode> checker)`
`CalciteAssert.AssertQuery`	`throws_(String message)`
`CalciteAssert.AssertQuery`	`typeIs(String expected)`
`CalciteAssert.AssertQuery`	`updates(int count)`
`CalciteAssert.AssertQuery`	`withConnection(Consumer<Connection> f)` Performs an action using a connection, and closes the connection afterwards.
`<T> CalciteAssert.AssertQuery`	`withHook(org.apache.calcite.runtime.Hook hook, Consumer<T> handler)` Adds a hook and a handler for that hook.
`<V> CalciteAssert.AssertQuery`	`withProperty(org.apache.calcite.runtime.Hook hook, V value)` Adds a property hook.

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 方法详细资料
  - createConnection
```
protected Connection createConnection()
```
  - withConnection
```
public final CalciteAssert.AssertQuery withConnection(Consumer<Connection> f)
```
    Performs an action using a connection, and closes the connection afterwards.
  - enable
```
public CalciteAssert.AssertQuery enable(boolean enabled)
```
  - returns
```
public CalciteAssert.AssertQuery returns(String expected)
```
  - returns2
```
public CalciteAssert.AssertQuery returns2(String expected)
```
    Similar to returns(java.lang.String), but trims a few values before comparing.
  - returnsValue
```
public CalciteAssert.AssertQuery returnsValue(String expected)
```
  - returnsCount
```
public CalciteAssert.AssertQuery returnsCount(int expectedCount)
```
  - returns
```
public final CalciteAssert.AssertQuery returns(Consumer<ResultSet> checker)
```
  - updates
```
public final CalciteAssert.AssertQuery updates(int count)
```
  - returns
```
protected CalciteAssert.AssertQuery returns(String sql,
                                            Consumer<ResultSet> checker)
```
  - returnsUnordered
```
public CalciteAssert.AssertQuery returnsUnordered(String... lines)
```
  - returnsOrdered
```
public CalciteAssert.AssertQuery returnsOrdered(String... lines)
```
  - returnsStartingWith
```
public CalciteAssert.AssertQuery returnsStartingWith(String... lines)
```
  - throws_
```
public CalciteAssert.AssertQuery throws_(String message)
```
  - failsAtValidation
```
public CalciteAssert.AssertQuery failsAtValidation(String optionalMessage)
```
    Used to check whether a sql statement fails at the SQL Validation phase. More formally, it checks if a SqlValidatorException or CalciteException was thrown.
    
    参数:
    
    optionalMessage - An optional message to check for in the output stacktrace
  - failsAtValidation
```
public CalciteAssert.AssertQuery failsAtValidation()
```
    Utility method so that one doesn't have to call failsAtValidation(java.lang.String) with null.
  - runs
```
public CalciteAssert.AssertQuery runs()
```
  - typeIs
```
public CalciteAssert.AssertQuery typeIs(String expected)
```
  - convertContains
```
public final CalciteAssert.AssertQuery convertContains(String expected)
```
    Checks that when the query (which was set using CalciteAssert.AssertThat.query(String)) is converted to a relational algebra expression matching the given string.
  - consumesPreparedStatement
```
public CalciteAssert.AssertQuery consumesPreparedStatement(CalciteAssert.PreparedStatementConsumer consumer)
```
  - convertMatches
```
public CalciteAssert.AssertQuery convertMatches(Consumer<org.apache.calcite.rel.RelNode> checker)
```
  - substitutionMatches
```
public CalciteAssert.AssertQuery substitutionMatches(Consumer<org.apache.calcite.rel.RelNode> checker)
```
  - explainContains
```
public CalciteAssert.AssertQuery explainContains(String expected)
```
  - explainHookContains
```
@API(since="1.22",
     status=EXPERIMENTAL)
public CalciteAssert.AssertQuery explainHookContains(String expectedPlan)
```
    This enables to assert the optimized plan without issuing a separate explain ... command. This is especially useful when RelNode is provided via Hook.STRING_TO_QUERY or CalciteAssert.AssertThat.withRel(Function).
    Note: this API does NOT trigger the query, so you need to use something like returns(String), or returnsUnordered(String...) to trigger query execution
    Note: prefer using explainHookMatches(String) if you assert the full plan tree as it produces slightly cleaner messages
    
    参数:
    
    expectedPlan - expected execution plan. The plan is normalized to LF line endings
    
    返回:
    
    updated assert query
  - explainHookContains
```
@API(since="1.22",
     status=EXPERIMENTAL)
public CalciteAssert.AssertQuery explainHookContains(org.apache.calcite.sql.SqlExplainLevel sqlExplainLevel,
                                                                                                  String expectedPlan)
```
    This enables to assert the optimized plan without issuing a separate explain ... command. This is especially useful when RelNode is provided via Hook.STRING_TO_QUERY or CalciteAssert.AssertThat.withRel(Function).
    Note: this API does NOT trigger the query, so you need to use something like returns(String), or returnsUnordered(String...) to trigger query execution
    Note: prefer using explainHookMatches(SqlExplainLevel, Matcher) if you assert the full plan tree as it produces slightly cleaner messages
    
    参数:
    
    sqlExplainLevel - the level of explain plan
    
    expectedPlan - expected execution plan. The plan is normalized to LF line endings
    
    返回:
    
    updated assert query
  - explainHookMatches
```
@API(since="1.22",
     status=EXPERIMENTAL)
public CalciteAssert.AssertQuery explainHookMatches(String expectedPlan)
```
    This enables to assert the optimized plan without issuing a separate explain ... command. This is especially useful when RelNode is provided via Hook.STRING_TO_QUERY or CalciteAssert.AssertThat.withRel(Function).
    Note: this API does NOT trigger the query, so you need to use something like returns(String), or returnsUnordered(String...) to trigger query execution.
    
    参数:
    
    expectedPlan - expected execution plan. The plan is normalized to LF line endings
    
    返回:
    
    updated assert query
  - explainHookMatches
```
@API(since="1.22",
     status=EXPERIMENTAL)
public CalciteAssert.AssertQuery explainHookMatches(org.hamcrest.Matcher<String> planMatcher)
```
    This enables to assert the optimized plan without issuing a separate explain ... command. This is especially useful when RelNode is provided via Hook.STRING_TO_QUERY or CalciteAssert.AssertThat.withRel(Function).
    Note: this API does NOT trigger the query, so you need to use something like returns(String), or returnsUnordered(String...) to trigger query execution.
    
    参数:
    
    planMatcher - execution plan matcher. The plan is normalized to LF line endings
    
    返回:
    
    updated assert query
  - explainHookMatches
```
@API(since="1.22",
     status=EXPERIMENTAL)
public CalciteAssert.AssertQuery explainHookMatches(org.apache.calcite.sql.SqlExplainLevel sqlExplainLevel,
                                                                                                 org.hamcrest.Matcher<String> planMatcher)
```
    This enables to assert the optimized plan without issuing a separate explain ... command. This is especially useful when RelNode is provided via Hook.STRING_TO_QUERY or CalciteAssert.AssertThat.withRel(Function).
    Note: this API does NOT trigger the query, so you need to use something like returns(String), or returnsUnordered(String...) to trigger query execution.
    
    参数:
    
    sqlExplainLevel - the level of explain plan
    
    planMatcher - execution plan matcher. The plan is normalized to LF line endings
    
    返回:
    
    updated assert query
  - explainMatches
```
public final CalciteAssert.AssertQuery explainMatches(String extra,
                                                      Consumer<ResultSet> checker)
```
  - planContains
```
public CalciteAssert.AssertQuery planContains(String expected)
```
  - planUpdateHasSql
```
public CalciteAssert.AssertQuery planUpdateHasSql(String expected,
                                                  int count)
```
  - planHasSql
```
public CalciteAssert.AssertQuery planHasSql(String expected)
```
  - queryContains
```
public CalciteAssert.AssertQuery queryContains(Consumer<List> predicate1)
```
    Runs the query and applies a checker to the generated third-party queries. The checker should throw to fail the test if it does not see what it wants. This method can be used to check whether a particular MongoDB or SQL query is generated, for instance.
  - queryContains
```
@Deprecated
public final CalciteAssert.AssertQuery queryContains(com.google.common.base.Function<List,Void> predicate1)
```
    已过时。 Use queryContains(Consumer).
  - limit
```
public CalciteAssert.AssertQuery limit(int limit)
```
    Sets a limit on the number of rows returned. -1 means no limit.
  - sameResultWithMaterializationsDisabled
```
public void sameResultWithMaterializationsDisabled()
```
  - enableMaterializations
```
public CalciteAssert.AssertQuery enableMaterializations(boolean materializationsEnabled)
```
  - withHook
```
public <T> CalciteAssert.AssertQuery withHook(org.apache.calcite.runtime.Hook hook,
                                              Consumer<T> handler)
```
    Adds a hook and a handler for that hook. Calcite will create a thread hook (by calling Hook.addThread(Consumer)) just before running the query, and remove the hook afterwards.
  - withProperty
```
public <V> CalciteAssert.AssertQuery withProperty(org.apache.calcite.runtime.Hook hook,
                                                  V value)
```
    Adds a property hook.

类 CalciteAssert.AssertQuery

方法概要

从类继承的方法 java.lang.Object

方法详细资料

createConnection

withConnection

enable

returns

returns2

returnsValue

returnsCount

returns

updates

returns

returnsUnordered

returnsOrdered

returnsStartingWith

throws_

failsAtValidation

failsAtValidation

runs

typeIs

convertContains

consumesPreparedStatement

convertMatches

substitutionMatches

explainContains

explainHookContains

explainHookContains

explainHookMatches

explainHookMatches

explainHookMatches

explainMatches

planContains

planUpdateHasSql

planHasSql

queryContains

queryContains

limit

sameResultWithMaterializationsDisabled

enableMaterializations

withHook

withProperty