Struct SchemaFileContext 

pub struct SchemaFileContext<TBaseContext>
where
    TBaseContext: BaseParseContext + Debug,
{ /* private fields */ }

schema file based context

Implementations

impl<TBaseContext> SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug,

pub fn new(sql_source_path: &Path, base: TBaseContext) -> Self

create context for loading schema file

pub fn apply_implicit_change( self, implicit_change: ImplicitChange, ) -> Result<Self, AnalysisError>

apply index from constraint

Trait Implementations

impl<TBaseContext> BaseParseContext for SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug,

fn get_args(&self) -> &SqlFunArgs

get context args

fn get_source_file_path(&self) -> Option<&Path>

get SQL file path

fn report_problem( &mut self, problem: AnalysisProblem, ) -> Result<(), AnalysisError>

reporting a analysis errors

fn extend(&mut self, extension: Box<dyn BaseParseContext>)

Load extension and bind to this context

fn set_statement_span(&mut self, statement_span: StringSpan)

update location for current statement.

fn set_source_file( &mut self, source_access_service: Box<dyn SourceAccessService>, )

setup source access service

fn get_type(&self, key: &FullName) -> Option<&TypeDefinition>

get type by name

fn get_table(&self, name: &TableName) -> Option<&CreateTable>

get CREATE TABLE statement by table name

fn get_view(&self, key: &ViewName) -> Option<&ViewLike>

get CREATE VIEW statement by view name

fn get_sequence(&self, seq_name: &FullName) -> Option<&CreateSequence>

get CREATE SEQUENCE statement by sequence name

fn get_function_by_name( &self, name: &FullName, ) -> Option<FunctionOverloadCollection>

get CREATE FUNCTION statement by function name

fn resolve_function_name_with_search_path( &self, fun_name: &FullName, ) -> FullName

get resolved function name

fn canonicalize_type_ref( &self, type_ref: &TypeReference, ) -> Option<TypeReference>

canonicalize a type reference

impl<TBaseContext> CastInfoRead for SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug,

fn get_explicit_cast( &self, source_type: &TypeReference, target_type: &TypeReference, ) -> Option<CastDefinition>

get explicit cast operation

fn get_implicit_castable( &self, source_type: &TypeReference, ) -> HashSet<TypeReference>

list implicit castable types from source_type

fn get_implicit_cast( &self, source_type: &TypeReference, target_type: &TypeReference, ) -> Option<CastDefinition>

get implicit cast operation

impl<TBaseContext> Debug for SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<TBaseContext> FunctionInfoRead for SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug,

fn get_function_impl( &self, name: &FullName, ) -> Option<FunctionOverloadCollection>

get CREATE FUNCTION statement by function name

impl<TBaseContext> FunctionInfoWrite for SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug,

fn apply_create_function_impl( self, name: &FullName, create_function: &CreateFunction, ) -> Result<Self, AnalysisError>

apply create function statement (implementation)

impl<TBaseContext> IndexInfoRead for SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug,

fn get_index(&self, index_name: &str) -> Option<&CreateIndex>

get CREATE INDEX statement by index name

impl<TBaseContext> OperatorInfoRead for SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug,

fn get_operator_op( &self, name: &OperatorName, has_left: bool, has_right: bool, ) -> Option<&OperatorDefinition>

get operator definition,

impl<TBaseContext> ParseContext for SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug,

fn apply_create_extension( self, create_extension: &CreateExtension, ) -> Result<Self, AnalysisError>

apply create extension to current schema

fn apply_variable_set( self, variable_set: &VariableSet, ) -> Result<Self, AnalysisError>

apply set statement to current schema

fn apply_create_schema( self, create_schema: &CreateSchema, ) -> Result<Self, AnalysisError>

apply create schema to current schema

fn apply_comment(self, comment: &Comment) -> Result<Self, AnalysisError>

apply comment statement to current schema

fn apply_create_index( self, create_index: &CreateIndex, ) -> Result<Self, AnalysisError>

apply create index statement to current schema

fn apply_create_comp_type( self, create_comp_type: &CreateCompositType, ) -> Result<Self, AnalysisError>

apply create type (composite type) to current schema

fn apply_create_domain( self, create_domain: &CreateDomain, ) -> Result<Self, AnalysisError>

apply create domain to current schema

fn apply_default_schema( &self, name: &FullName, ) -> Result<FullName, AnalysisError>

apply default schema when name not specify schema

fn apply_create_enum( self, create_enum_type: &CreateEnum, ) -> Result<Self, AnalysisError>

apply create type as enum statement to current schema

fn apply_create_table( self, create_table: &CreateTable, ) -> Result<Self, AnalysisError>

apply create table statement to current schema

fn apply_create_function( self, create_function: &CreateFunction, ) -> Result<Self, AnalysisError>

apply create function statement to current schema

fn resolve_table_function( &mut self, call: &FuncCall, func_name: FullName, alias_name: &AliasSpec, arg_exprs: IVec<SemScalarExpr>, arg_types: ArgumentBindingCollection, ) -> Result<DataSource, AnalysisError>

resolve table function call as data source

impl<TBaseContext> SearchPathRead for SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug,

fn set_search_path(&mut self, search_path: Vec<SchemaName>)

set serach path

fn get_default_schema(&self) -> Option<SchemaName>

gets default schema.

fn get_search_path(&self) -> &[SchemaName]

get search path

impl<TBaseContext> SequenceInfoRead for SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug,

fn get_sequence_impl(&self, key: &FullName) -> Option<&CreateSequence>

get CREATE SEQUENCE statement by full name

impl<TBaseContext> SequenceInfoWrite for SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug,

fn apply_alter_sequence( self, alter_seq: &AlterSequence, ) -> Result<Self, AnalysisError>

where Self: Sized,

apply alter sequence statement to current schema

fn apply_create_sequence( self, create_sequence: &CreateSequence, ) -> Result<Self, AnalysisError>

apply create sequence statement to current schema

impl<TBaseContext> TableInfoRead for SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug,

fn get_table_impl(&self, key: &FullName) -> Option<&CreateTable>

get CREATE TABLE statement by full_name

impl<TBaseContext> TableInfoWrite for SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug,

fn insert_create_table(&mut self, name: &FullName, create_table: &CreateTable)

insert create table statement

fn apply_alter_table( self, alter_table: &AlterTable, ) -> Result<Self, AnalysisError>

apply alter table statement to current schema

impl<TBaseContext> TypeInfoRead for SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug,

fn get_type_impl(&self, key: &FullName) -> Option<&TypeDefinition>

get type by name

fn get_array_item_type( &self, type_name: &TypeReference, ) -> Option<TypeReference>

get item type for array type

impl<TBaseContext> TypeInfoWrite for SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug,

fn insert_table_ref_type(&mut self, name: &TableName)

insert table reference composite type

fn insert_create_composite_type( &mut self, name: &FullName, create_comp_type: &CreateCompositType, )

register enum type

fn insert_create_domain( &mut self, name: &FullName, create_domain: &CreateDomain, )

insert create domain statement

fn insert_create_enum(&mut self, name: &FullName, create_enum: &CreateEnum)

register enum type

impl<TBaseContext> ViewInfoRead for SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug,

fn get_view_impl(&self, key: &FullName) -> Option<&ViewLike>

get CREATE VIEW statement by view name

impl<TBaseContext> ViewInfoWrite for SchemaFileContext<TBaseContext>

where TBaseContext: BaseParseContext + Debug,

fn apply_alter_view(self, alter_view: &AlterView) -> Result<Self, AnalysisError>

where Self: Sized,

apply alter view statement to current schema

fn apply_create_table_as( self, create_table_as: &CreateTableAs, ) -> Result<Self, AnalysisError>

apply create table as statement to current schema

fn apply_create_view( self, create_view: &CreateView, ) -> Result<Self, AnalysisError>

apply create view to current schema