SchemaNegotiatorImpl (Drill : 1.20.3 API)

java.lang.Object
- org.apache.drill.exec.physical.impl.scan.v3.lifecycle.SchemaNegotiatorImpl

All Implemented Interfaces:

SchemaNegotiator

Direct Known Subclasses:

FileSchemaNegotiatorImpl
```
public class SchemaNegotiatorImpl
extends Object
implements SchemaNegotiator
```
Implementation of the schema negotiation between scan operator and batch reader. Anticipates that the select list (and/or the list of predefined fields (implicit, partition) might be set by the scanner. For now, all readers have their own implementation of the select set.
Handles both early- and late-schema readers. Early-schema readers provide a table schema, late-schema readers do not.
If the reader (or, later, the scanner) has a SELECT list, then that select list is pushed down into the result set loader created for the reader.
Also handles parsing out various column types, filling in null columns and (via the vector cache), minimizing changes across readers. In the worst case, a reader might have a column "c" in one file, might skip "c" in the second file, and "c" may appear again in a third file. This negotiator, along with the scan projection and vector cache, "smoothes out" schema changes by preserving the vector for "c" across all three files. In the first and third files "c" is a vector written by the reader, in the second, it is a null column filled in by the scan projector (assuming, of course, that "c" is nullable or an array.)
Pushes limits into the result set loader. The caller must either check the return value from {#code startBatch()}, or call atLimit() after harvest() to detect when the scan has reached the limit. Treat the limit condition the same as EOF.

Field Summary

Fields
Modifier and Type	Field and Description
`protected CustomErrorContext`	`baseErrorContext`
`protected int`	`batchSize`
`protected boolean`	`isSchemaComplete`
`protected CustomErrorContext`	`readerErrorContext`
`protected ReaderLifecycle`	`readerLifecycle`
`protected TupleMetadata`	`readerSchema`

Constructor Summary

Constructors
Constructor and Description

SchemaNegotiatorImpl(ReaderLifecycle readerLifecycle)

Constructors
Constructor and Description
`SchemaNegotiatorImpl(ReaderLifecycle readerLifecycle)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`batchSize(int maxRecordsPerBatch)` Set the preferred batch size (which may be overridden by the result set loader in order to limit vector or batch size.)
`ResultSetLoader`	`build()` Callback from the schema negotiator to build the schema from information from both the table and scan operator.
`OperatorContext`	`context()`
`CustomErrorContext`	`errorContext()` Returns the error context to use for this reader: either the parent or the reader-specific context set in `SchemaNegotiator.setErrorContext(CustomErrorContext)`.
`StaticBatchBuilder`	`implicitColumnsLoader()`
`TupleMetadata`	`inputSchema()` Returns the reader input schema: the schema which describes the set of columns this reader should produce.
`boolean`	`isProjectionEmpty()` Report whether the projection list is empty, as occurs in two cases: `SELECT COUNT(*) ...` -- empty project. `SELECT a, b FROM table(c d)` -- disjoint project.
`boolean`	`isSchemaComplete()`
`ManagedReader`	`newReader(ReaderFactory<?> readerFactory)`
`protected void`	`onEndBatch()`
`CustomErrorContext`	`parentErrorContext()` The context to use as a parent when creating a custom context.
`ProjectedColumn`	`projectionFor(String colName)`
`TupleMetadata`	`providedSchema()` Returns the provided schema, if defined.
`void`	`schemaIsComplete(boolean isComplete)`
`void`	`setErrorContext(CustomErrorContext errorContext)` Specify an advanced error context which allows the reader to fill in custom context values.
`void`	`tableSchema(TupleMetadata schema)`
`void`	`tableSchema(TupleMetadata schema, boolean isComplete)` Specify the table schema if this is an early-schema reader.
`String`	`userName()` Name of the user running the query.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - readerLifecycle
```
protected final ReaderLifecycle readerLifecycle
```
  - readerSchema
```
protected TupleMetadata readerSchema
```
  - isSchemaComplete
```
protected boolean isSchemaComplete
```
  - batchSize
```
protected int batchSize
```
  - baseErrorContext
```
protected CustomErrorContext baseErrorContext
```
  - readerErrorContext
```
protected CustomErrorContext readerErrorContext
```
- Constructor Detail
  - SchemaNegotiatorImpl
```
public SchemaNegotiatorImpl(ReaderLifecycle readerLifecycle)
```
- Method Detail
  - isProjectionEmpty
```
public boolean isProjectionEmpty()
```
    Description copied from interface: SchemaNegotiator
    Report whether the projection list is empty, as occurs in two cases:
    - SELECT COUNT(*) ... -- empty project.
  - SELECT a, b FROM table(c d) -- disjoint project.

Specified by:: isProjectionEmpty in interface SchemaNegotiator
Returns:: true if no columns are projected, and the client can make use of ResultSetLoader.skipRows(int) to indicate the row count, false if at least one column is projected and so data must be written using the loader

projectionFor
```
public ProjectedColumn projectionFor(String colName)
```
Specified by:

projectionFor in interface SchemaNegotiator

providedSchema
```
public TupleMetadata providedSchema()
```
Description copied from interface: SchemaNegotiator

Returns the provided schema, if defined. The provided schema is a description of the source schema viewed as a Drill schema.
If a schema is provided, the reader should use that schema, converting or ignoring columns as needed. A scan without a provided schema has a "dynamic" schema to be defined by the scan operator itself along with the column projection list.
The provided schema describes the columns that the reader is capable of providing. Any given query may choose to project a subset of these columns.

Specified by:

providedSchema in interface SchemaNegotiator

Returns:

the provided schema if the execution plan defines the output schema, null if the schema should be computed dynamically from the source schema and column projections

inputSchema
```
public TupleMetadata inputSchema()
```
Description copied from interface: SchemaNegotiator

Returns the reader input schema: the schema which describes the set of columns this reader should produce. The schema can be fully dynamic (a wildcard), fully concrete (a list of columns and their types) or partially dynamic (a list of columns, but some types are not known.) If the reader has a choice of ways to map input columns to types, the reader must choose the type specified in the schema. Presumably, the specified types are those that the reader is capable of providing; there is no expectation that the reader will convert to arbitrary types.
If the type is LATE (dynamic), then the reader can choose the type. Subsequent readers in the same scan will then see the same column as concrete, with the type selected by the present reader.
The reader is free to add additional columns. The internal mechanism will just ignore those columns and return a dummy reader for them.
The reader is also free to ignore columns. In this case, the internal mechanism will fill in NULL or default values.

Specified by:

inputSchema in interface SchemaNegotiator

context
```
public OperatorContext context()
```
Specified by:

context in interface SchemaNegotiator

parentErrorContext
```
public CustomErrorContext parentErrorContext()
```
Description copied from interface: SchemaNegotiator

The context to use as a parent when creating a custom context.
(Obtain the error context for this reader from the ResultSetLoader.

Specified by:

parentErrorContext in interface SchemaNegotiator

errorContext
```
public CustomErrorContext errorContext()
```
Description copied from interface: SchemaNegotiator

Returns the error context to use for this reader: either the parent or the reader-specific context set in SchemaNegotiator.setErrorContext(CustomErrorContext).

Specified by:

errorContext in interface SchemaNegotiator

setErrorContext
```
public void setErrorContext(CustomErrorContext errorContext)
```
Description copied from interface: SchemaNegotiator

Specify an advanced error context which allows the reader to fill in custom context values.

Specified by:

setErrorContext in interface SchemaNegotiator

tableSchema
```
public void tableSchema(TupleMetadata schema,
                        boolean isComplete)
```
Description copied from interface: SchemaNegotiator

Specify the table schema if this is an early-schema reader. Need not be called for a late-schema readers. The schema provided here, if any, is a base schema: the reader is free to discover additional columns during the read.

Specified by:

tableSchema in interface SchemaNegotiator

Parameters:

schema - the table schema if known at open time

isComplete - true if the schema is complete: if it can be used to define an empty schema-only batch for the first reader. Set to false if the schema is partial: if the reader must read rows to determine the full schema

tableSchema
```
public void tableSchema(TupleMetadata schema)
```
Specified by:

tableSchema in interface SchemaNegotiator

schemaIsComplete
```
public void schemaIsComplete(boolean isComplete)
```
Specified by:

schemaIsComplete in interface SchemaNegotiator

isSchemaComplete
```
public boolean isSchemaComplete()
```

batchSize
```
public void batchSize(int maxRecordsPerBatch)
```
Description copied from interface: SchemaNegotiator

Set the preferred batch size (which may be overridden by the result set loader in order to limit vector or batch size.)

Specified by:

batchSize in interface SchemaNegotiator

Parameters:

maxRecordsPerBatch - preferred number of record per batch

userName
```
public String userName()
```
Description copied from interface: SchemaNegotiator

Name of the user running the query.

Specified by:

userName in interface SchemaNegotiator

build
```
public ResultSetLoader build()
```
Callback from the schema negotiator to build the schema from information from both the table and scan operator. Returns the result set loader to be used by the reader to write to the table's value vectors.

Specified by:

build in interface SchemaNegotiator

Returns:

the result set loader to be used by the reader

implicitColumnsLoader

public StaticBatchBuilder implicitColumnsLoader()

newReader

public ManagedReader newReader(ReaderFactory<?> readerFactory)
                        throws ManagedReader.EarlyEofException

Throws:: ManagedReader.EarlyEofException

onEndBatch
```
protected void onEndBatch()
```

Class SchemaNegotiatorImpl

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

readerLifecycle

readerSchema

isSchemaComplete

batchSize

baseErrorContext

readerErrorContext

Constructor Detail

SchemaNegotiatorImpl

Method Detail

isProjectionEmpty

projectionFor

providedSchema

inputSchema

context

parentErrorContext

errorContext

setErrorContext

tableSchema

tableSchema

schemaIsComplete

isSchemaComplete

batchSize

userName

build

implicitColumnsLoader

newReader

onEndBatch