analyzer

var (
	// ErrFieldMissing is returned when the field is not on the schema.
	ErrFieldMissing = errors.NewKind("field %q is not on schema")
	// ErrOrderByColumnIndex is returned when in an order clause there is a
	// column that is unknown.
	ErrOrderByColumnIndex = errors.NewKind("unknown column %d in order by clause")
)

var (
	// ErrValidationResolved is returned when the plan can not be resolved.
	ErrValidationResolved = errors.NewKind("plan is not resolved because of node '%T'")
	// ErrValidationOrderBy is returned when the order by contains aggregation
	// expressions.
	ErrValidationOrderBy = errors.NewKind("OrderBy does not support aggregation expressions")
	// ErrValidationGroupBy is returned when the aggregation expression does not
	// appear in the grouping columns.
	ErrValidationGroupBy = errors.NewKind("expression '%v' doesn't appear in the group by expressions")
	// ErrValidationSchemaSource is returned when there is any column source
	// that does not match the table name.
	ErrValidationSchemaSource = errors.NewKind("one or more schema sources are empty")
	// ErrUnknownIndexColumns is returned when there are columns in the expr
	// to index that are unknown in the table.
	ErrUnknownIndexColumns = errors.NewKind("unknown columns to index for table %q: %s")
	// ErrCaseResultType is returned when one or more of the types of the values in
	// a case expression don't match.
	ErrCaseResultType = errors.NewKind(
		"expecting all case branches to return values of type %s, " +
			"but found value %q of type %s on %s",
	)
	// ErrIntervalInvalidUse is returned when an interval expression is not
	// correctly used.
	ErrIntervalInvalidUse = errors.NewKind(
		"invalid use of an interval, which can only be used with DATE_ADD, " +
			"DATE_SUB and +/- operators to subtract from or add to a date",
	)
	// ErrExplodeInvalidUse is returned when an EXPLODE function is used
	// outside a Project node.
	ErrExplodeInvalidUse = errors.NewKind(
		"using EXPLODE is not supported outside a Project node",
	)

	// ErrSubqueryFieldIndex is returned when an expression subquery references a field outside the range of the rows it
	// works on.
	ErrSubqueryFieldIndex = errors.NewKind(
		"subquery field index out of range for expression %s: only %d columns available",
	)

	// ErrUnionSchemasMatch is returned when both sides of a UNION do not
	// have the same schema.
	ErrUnionSchemasMatch = errors.NewKind(
		"the schema of the left side of union does not match the right side, expected %s to match %s",
	)

	// ErrReadOnlyDatabase is returned when a write is attempted to a ReadOnlyDatabse.
	ErrReadOnlyDatabase = errors.NewKind("Database %s is read-only.")

	// ErrAggregationUnsupported is returned when the analyzer has failed
	// to push down an Aggregation in an expression to a GroupBy node.
	ErrAggregationUnsupported = errors.NewKind(
		"an aggregation remained in the expression '%s' after analysis, outside of a node capable of evaluating it; this query is currently unsupported.",
	)
)

var DefaultRules = []Rule{
	{"resolve_natural_joins", resolveNaturalJoins},
	{"resolve_orderby_literals", resolveOrderByLiterals},
	{"resolve_functions", resolveFunctions},
	{"flatten_table_aliases", flattenTableAliases},
	{"pushdown_sort", pushdownSort},
	{"pushdown_groupby_aliases", pushdownGroupByAliases},
	{"pushdown_subquery_alias_filters", pushdownSubqueryAliasFilters},
	{"qualify_columns", qualifyColumns},
	{"resolve_columns", resolveColumns},
	{"validate_check_constraint", validateCreateCheck},
	{"resolve_bareword_set_variables", resolveBarewordSetVariables},
	{"resolve_database", resolveDatabase},
	{"expand_stars", expandStars},
	{"resolve_having", resolveHaving},
	{"merge_union_schemas", mergeUnionSchemas},
	{"flatten_aggregation_exprs", flattenAggregationExpressions},
	{"reorder_projection", reorderProjection},
	{"resolve_subquery_exprs", resolveSubqueryExpressions},
	{"move_join_conds_to_filter", moveJoinConditionsToFilter},
	{"eval_filter", evalFilter},
	{"optimize_distinct", optimizeDistinct},
}

var DefaultValidationRules = []Rule{
	{validateResolvedRule, validateIsResolved},
	{validateOrderByRule, validateOrderBy},
	{validateGroupByRule, validateGroupBy},
	{validateSchemaSourceRule, validateSchemaSource},
	{validateIndexCreationRule, validateIndexCreation},
	{validateOperandsRule, validateOperands},
	{validateCaseResultTypesRule, validateCaseResultTypes},
	{validateIntervalUsageRule, validateIntervalUsage},
	{validateExplodeUsageRule, validateExplodeUsage},
	{validateSubqueryColumnsRule, validateSubqueryColumns},
	{validateUnionSchemasMatchRule, validateUnionSchemasMatch},
	{validateAggregationsRule, validateAggregations},
}

var ErrInAnalysis = errors.NewKind("error in analysis: %s")

var ErrInvalidNodeType = errors.NewKind("%s: invalid node of type: %T")

var ErrMaxAnalysisIters = errors.NewKind("exceeded max analysis iterations (%d)")

var (
	// ErrUnionSchemasDifferentLength is returned when the two sides of a
	// UNION do not have the same number of columns in their schemas.
	ErrUnionSchemasDifferentLength = errors.NewKind(
		"cannot union two queries whose schemas are different lengths; left has %d column(s) right has %d column(s).",
	)
)

var OnceAfterAll = []Rule{
	{"track_process", trackProcess},
	{"parallelize", parallelize},

	{"clear_warnings", clearWarnings},
}

var OnceAfterDefault = []Rule{
	{"finalize_subqueries", finalizeSubqueries},
	{"finalize_unions", finalizeUnions},
	{"load_triggers", loadTriggers},
	{"process_truncate", processTruncate},
	{"resolve_column_defaults", resolveColumnDefaults},
	{"resolve_generators", resolveGenerators},
	{"remove_unnecessary_converts", removeUnnecessaryConverts},
	{"assign_catalog", assignCatalog},
	{"prune_columns", pruneColumns},
	{"optimize_joins", constructJoinPlan},
	{"pushdown_filters", pushdownFilters},
	{"subquery_indexes", applyIndexesFromOuterScope},
	{"in_subquery_indexes", applyIndexesForSubqueryComparisons},
	{"pushdown_projections", pushdownProjections},
	{"set_join_scope_len", setJoinScopeLen},
	{"erase_projection", eraseProjection},

	{"resolve_subquery_exprs", resolveSubqueryExpressions},
	{"cache_subquery_results", cacheSubqueryResults},
	{"cache_subquery_aliases_in_joins", cacheSubqueryAlisesInJoins},
	{"apply_hash_lookups", applyHashLookups},
	{"resolve_insert_rows", resolveInsertRows},
	{"apply_triggers", applyTriggers},
	{"apply_procedures", applyProcedures},
	{"modify_update_expressions_for_join", modifyUpdateExpressionsForJoin},
	{"apply_row_update_accumulators", applyUpdateAccumulators},
}

var OnceBeforeDefault = []Rule{
	{"validate_offset_and_limit", validateLimitAndOffset},
	{"load_stored_procedures", loadStoredProcedures},
	{"resolve_variables", resolveVariables},
	{"resolve_set_variables", resolveSetVariables},
	{"resolve_views", resolveViews},
	{"lift_common_table_expressions", liftCommonTableExpressions},
	{"resolve_common_table_expressions", resolveCommonTableExpressions},
	{"resolve_tables", resolveTables},
	{"resolve_drop_constraint", resolveDropConstraint},
	{"validate_drop_constraint", validateDropConstraint},
	{"load_check_constraints", loadChecks},
	{"resolve_create_like", resolveCreateLike},
	{"resolve_create_select", resolveCreateSelect},
	{"resolve_subqueries", resolveSubqueries},
	{"resolve_unions", resolveUnions},
	{"resolve_describe_query", resolveDescribeQuery},
	{"check_unique_table_names", checkUniqueTableNames},
	{"resolve_declarations", resolveDeclarations},
	{"validate_create_trigger", validateCreateTrigger},
	{"validate_create_procedure", validateCreateProcedure},
	{"assign_info_schema", assignInfoSchema},
	{"validate_read_only_database", validateReadOnlyDatabase},
	{"validate_read_only_transaction", validateReadOnlyTransaction},
}

var (
	// ParallelQueryCounter describes a metric that accumulates
	// number of parallel queries monotonically.
	ParallelQueryCounter = discard.NewCounter()
)