package compiler
- Alphabetic
- By Inheritance
- compiler
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- class AssignUniqueSymbols extends Phase
Ensure that all symbol definitions in a tree are unique.
Ensure that all symbol definitions in a tree are unique. The same symbol can initially occur in multiple sub-trees when some part of a query is reused multiple times. This phase assigns new, uniqe symbols, so that later phases do not have to take scopes into account for identifying the source of a symbol. The rewriting is performed for both, term symbols and type symbols.
The phase state is a collection of flags depending on the presence or absence of certain node types in the AST. This information can be used to selectively skip later compiler phases when it is already known that there is nothing for them to translate.
- abstract class CodeGen extends Phase
A standard skeleton for a code generator phase.
- class CompilerState extends AnyRef
The current state of a compiler run, consisting of the current AST and additional immutable state of individual phases.
The current state of a compiler run, consisting of the current AST and additional immutable state of individual phases. Mutability is confined to the SymbolNamer. The state is tied to a specific compiler instance so that phases can call back into the compiler.
- class CreateAggregates extends Phase
Rewrite aggregation function calls to Aggregate nodes.
- class CreateResultSetMapping extends Phase
Create a ResultSetMapping root node, ensure that the top-level server-side node returns a collection, and hoist client-side type conversions into the ResultSetMapping.
Create a ResultSetMapping root node, ensure that the top-level server-side node returns a collection, and hoist client-side type conversions into the ResultSetMapping. The original result type (which was removed by
removeMappedTypes
) is assigned back to the top level. - class EmulateOuterJoins extends Phase
An optional phase which rewrites outer joins into more commonly supported operations for use on databases that lack outer join support.
An optional phase which rewrites outer joins into more commonly supported operations for use on databases that lack outer join support.
Full outer joins are always emulated. Right joins can be replaced by left joins (or an emulated version thereof). Left joins can be emulated with inner joins and unions.
- class ExpandRecords extends Phase
Expand paths of record types to reference all fields individually and recreate the record structure at the call site.
- class ExpandSums extends Phase
Expand sum types and their catamorphisms to equivalent product type operations.
- class ExpandTables extends Phase
Expand table-valued expressions in the result type to their star projection and compute the missing structural expansions of table types.
Expand table-valued expressions in the result type to their star projection and compute the missing structural expansions of table types. After this phase the AST should always be well-typed.
- class FixRowNumberOrdering extends Phase
Inject the proper orderings into the RowNumber nodes produced earlier by the resolveFixJoins phase.
- class FlattenProjections extends Phase
Flatten all
Pure
node contents into a singleStructNode
.Flatten all
Pure
node contents into a singleStructNode
.After this phase, all
Pure
nodes produce aStructNode
of primitive fields. As a side-effect, nested NominalTypes are eliminated. - class ForceOuterBinds extends Phase
Ensure that all collection operations are wrapped in a Bind so that we have a place for expanding references later.
Ensure that all collection operations are wrapped in a Bind so that we have a place for expanding references later. FilteredQueries are allowed on top of collection operations without a Bind in between, unless that operation is a Join, Pure or Distinct node.
- class HoistClientOps extends Phase
Lift applicable operations at the top level to the client side.
- class InferTypes extends Phase
Infer all missing types.
- class InsertCompiler extends Phase
A custom compiler for INSERT statements.
A custom compiler for INSERT statements. We could reuse the standard phases with a minor modification instead, but this is much faster.
- class MergeToComprehensions extends Phase
This phase merges nested nodes of types Bind, Filter, GroupBy, SortBy, Take, Drop, CollectionCast and Distinct to Comprehension nodes.
This phase merges nested nodes of types Bind, Filter, GroupBy, SortBy, Take, Drop, CollectionCast and Distinct to Comprehension nodes. Nodes can be merged if they occur in the following order:
[Source] -> Filter (where) -> GroupBy -> SortBy / (Distinct | Filter (having)) -> Take / Drop
Aliasing Binds and CollectionCasts are allowed everywhere in the chain. Any out of order operation starts a new chain with a subquery as the source.
- class OptimizeScalar extends Phase
Optimize scalar expressions
- trait Phase extends (CompilerState) => CompilerState with Logging
A phase of the query compiler, identified by a unique name
- class PruneProjections extends Phase
Remove unreferenced fields from StructNodes.
- class QueryCompiler extends Logging
An immutable, stateless query compiler consisting of a series of phases
- class RelabelUnions extends Phase
Assign the AnonSymbols of fields from the left side of a Union to the right side.
Assign the AnonSymbols of fields from the left side of a Union to the right side. This ensures that both sides are protected when we prune unused references pointing to left-side Symbols.
- class RemoveFieldNames extends Phase
Convert unreferenced StructNodes to single columns or ProductNodes (which is needed for aggregation functions and at the top level).
- class RemoveMappedTypes extends Phase
Remove all mapped types from the tree and store the original top-level type as the phase state to be used later for building the ResultSetMapping.
- class RemoveTakeDrop extends Phase
Replace all occurrences of
Take
andDrop
with row number computations based onzipWithIndex
operations. - class ReorderOperations extends Phase
Reorder certain stream operations for more efficient merging in
mergeToComprehensions
. - class ResolveZipJoins extends Phase
Rewrite zip joins into a form suitable for SQL using inner joins and RowNumber columns.
Rewrite zip joins into a form suitable for SQL using inner joins and RowNumber columns.
We rely on having a Bind around every Join and both of its generators, which should have been generated by Phase.forceOuterBinds. The inner Binds need to select
Pure(StructNode(...))
which should be the outcome of Phase.flattenProjections. - class RewriteBooleans extends Phase
For SQL back-ends which do not support real boolean types for fields and general expressions but which do have special boolean expressions and operators, this phase injects conversions between fake and real boolean values.
For SQL back-ends which do not support real boolean types for fields and general expressions but which do have special boolean expressions and operators, this phase injects conversions between fake and real boolean values.
The default for booleans in the AST is to use the fake type (mapped to a numeric type by the profile). There are specific places where a real boolean (that can be used in boolean expressions) is required or produced, so we inject a call to ToRealBoolean or ToFakeBoolean as needed.
- class RewriteDistinct extends Phase
Rewrite "distinct on" to "distinct" or "group by"
- class RewriteJoins extends Phase
Rewrite monadic joins to applicative joins.
Rewrite monadic joins to applicative joins. After this phase all
Bind
nodes are of the formBind(_, _, Pure(_, _))
(i.e.flatMap
has been reduced tomap
). - class SpecializeParameters extends Phase
Specialize the AST for edge cases of query parameters.
Specialize the AST for edge cases of query parameters. This is required for compiling
take(0)
for some databases which do not allowLIMIT 0
. - class UnrollTailBinds extends Phase
- case class UsedFeatures(distinct: Boolean, typeMapping: Boolean, aggregate: Boolean, nonPrimitiveOption: Boolean) extends Product with Serializable
- class VerifySymbols extends Phase
Verify that all monadic joins have been transformed into applicative joins and that the resulting tree does not contain references to unreachable symbols.
- class VerifyTypes extends Phase
Optional phase which verifies that retyping the tree does not change any types.
Optional phase which verifies that retyping the tree does not change any types. Useful for debugging type-related problems with large trees.
Value Members
- object CodeGen
- object CreateAggregates extends Logging
- object InsertCompiler
- object Phase
The
Phase
companion objects contains ready-to-usePhase
objects for the standard phases of the query compiler - object QueryCompiler
- object RewriteBooleans
edit this text on github
Scala Language-Integrated Connection Kit
This is the API documentation for the Slick database library. It should be used as an additional resource to the user manual.
Further documentation for Slick can be found on the documentation pages.
To the slick package list...