// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module parser

import v.ast
import v.token

struct SqlPrefix {
	pos              token.Pos
	db_expr          ast.Expr
	tmp_inside_match bool
	is_dynamic       bool
}

struct SqlQueryDataItemsBlock {
	items        []ast.SqlQueryDataItem
	end_comments []ast.Comment
}

fn sql_aggregate_kind_from_name(name string) ast.SqlAggregateKind {
	return match name {
		'count' { .count }
		'sum' { .sum }
		'avg' { .avg }
		'min' { .min }
		'max' { .max }
		else { .none }
	}
}

fn (mut p Parser) parse_sql_select_field_name() ast.SqlSelectField {
	pos := p.tok.pos()
	mut parts := []string{}
	parts << p.check_name()
	for p.tok.kind == .dot {
		p.next()
		parts << p.check_name()
	}
	return ast.SqlSelectField{
		name: parts.join('.')
		pos:  pos.extend(p.prev_tok.pos())
	}
}

fn (mut p Parser) parse_sql_select_fields() []ast.SqlSelectField {
	mut fields := []ast.SqlSelectField{}
	for {
		if p.tok.kind != .name {
			p.error('expected an ORM select field before `from`')
			return fields
		}
		fields << p.parse_sql_select_field_name()
		if p.tok.kind != .comma {
			break
		}
		p.next()
	}
	return fields
}

// select from User
// insert user into User returning id
fn (mut p Parser) sql_expr() ast.Expr {
	prefix := p.sql_prefix()
	return p.sql_expr_after_prefix(prefix)
}

fn (mut p Parser) sql_stmt_or_expr() ast.Stmt {
	prefix := p.sql_prefix()
	if p.sql_stmt_can_be_value()
		&& (p.tok.kind == .key_select || (p.tok.kind == .name && p.tok.lit == 'insert')) {
		expr := p.sql_expr_after_prefix(prefix)
		return ast.ExprStmt{
			expr: expr
			pos:  expr.pos()
		}
	}
	return p.sql_stmt_after_prefix(prefix)
}

fn (p &Parser) sql_stmt_can_be_value() bool {
	return p.inside_if_expr || p.inside_match_body || p.inside_or_expr
}

fn (mut p Parser) sql_prefix() SqlPrefix {
	tmp_inside_match := p.inside_match
	p.inside_orm = true
	p.inside_match = true
	pos := p.tok.pos()
	p.check_name()
	db_expr := p.check_expr(0) or {
		p.unexpected(prepend_msg: 'invalid expression:', expecting: 'database')
	}
	p.check(.lcbr)
	mut is_dynamic := false
	if p.tok.kind == .name && p.tok.lit == 'dynamic' {
		is_dynamic = true
		p.next()
	}
	return SqlPrefix{
		pos:              pos
		db_expr:          db_expr
		tmp_inside_match: tmp_inside_match
		is_dynamic:       is_dynamic
	}
}

fn (mut p Parser) sql_expr_after_prefix(prefix SqlPrefix) ast.Expr {
	is_dynamic := prefix.is_dynamic
	is_select := p.tok.kind == .key_select
	is_insert := p.tok.lit == 'insert'
	if !is_select && !is_insert {
		p.error('expected "select" or "insert" in an ORM expression')
	}
	if is_dynamic && !is_select {
		p.error('expected "select" after `dynamic` in an ORM expression')
	}
	p.next()
	// kind := if is_select { ast.SqlExprKind.select_ } else { ast.SqlExprKind.insert }
	mut inserted_var := ''
	mut aggregate_kind := ast.SqlAggregateKind.none
	mut aggregate_field := ''
	mut has_distinct := false
	mut requested_fields := []ast.SqlSelectField{}
	if is_insert {
		inserted_var = p.check_name()
		p.scope.mark_var_as_used(inserted_var)
		into := p.check_name()
		if into != 'into' {
			p.error('expecting `into`')
		}
	} else if is_select {
		if p.tok.kind == .name && p.tok.lit == 'distinct' {
			has_distinct = true
			p.next()
		}
		if p.tok.kind == .name {
			aggregate_kind = sql_aggregate_kind_from_name(p.tok.lit)
		}
		if aggregate_kind == .count {
			p.next()
			n := p.check_name() // from
			if n != 'from' {
				p.error('expecting "from" in a "select count" ORM statement')
			}
		} else if aggregate_kind != .none {
			p.next()
			if p.tok.kind != .lpar {
				p.error('expecting `(` after aggregate function in ORM select')
			}
			p.next()
			if p.tok.kind != .name {
				p.error('ORM aggregate functions only support a single field name argument')
			}
			aggregate_field = p.check_name()
			if p.tok.kind != .rpar {
				p.error('ORM aggregate functions only support a single field name argument')
			}
			p.next()
			n := p.check_name() // from
			if n != 'from' {
				p.error('expecting `from` after ORM aggregate function')
			}
		} else if p.tok.kind == .name && p.tok.lit == 'from' {
			p.next()
		} else {
			requested_fields = p.parse_sql_select_fields()
			n := p.check_name() // from
			if n != 'from' {
				p.error('expecting `from` after ORM select fields')
			}
		}
	}
	mut typ := ast.void_type

	table_pos := p.tok.pos()
	table_type := p.parse_type() // `User`

	// Parse JOIN clauses (e.g., `join Department on User.dept_id == Department.id`)
	mut joins := []ast.JoinClause{}
	for p.tok.kind == .name && p.tok.lit in ['join', 'left', 'right', 'full', 'inner'] {
		join_clause := p.parse_sql_join_clause()
		if join_clause.table_expr.typ != ast.void_type {
			joins << join_clause
		}
	}

	mut where_expr := ast.empty_expr
	has_where := p.tok.kind == .name && p.tok.lit == 'where'

	if has_where {
		p.next()
		where_expr = p.expr(0)
		if !is_dynamic {
			where_check_result := p.check_sql_where_expr_has_no_undefined_variables(&where_expr, [])
			if where_check_result is ast.NodeError {
				return where_check_result
			}
		}
	}

	mut has_limit := false
	mut limit_expr := ast.empty_expr
	mut has_offset := false
	mut offset_expr := ast.empty_expr
	mut has_order := false
	mut order_expr := ast.empty_expr
	mut has_desc := false
	if p.tok.kind == .name && p.tok.lit == 'order' {
		p.check_name() // `order`
		order_pos := p.tok.pos()
		if p.tok.kind == .name && p.tok.lit == 'by' {
			p.check_name() // `by`
		} else {
			return p.error_with_pos('use `order by` in ORM queries', order_pos)
		}
		has_order = true
		order_expr = p.expr(0)
		if p.tok.kind == .name && p.tok.lit in ['asc', 'desc'] {
			has_desc = p.tok.lit == 'desc'
			p.check_name() // `asc` or `desc`
		}
	}

	if p.tok.kind == .name && p.tok.lit == 'limit' {
		p.check_name() // `limit`
		has_limit = true
		limit_expr = p.expr(0)
	}

	if p.tok.kind == .name && p.tok.lit == 'offset' {
		p.check_name() // `offset`
		has_offset = true
		offset_expr = p.expr(0)
	}

	if aggregate_kind == .count {
		typ = ast.int_type
	} else if aggregate_kind != .none {
		typ = ast.void_type
	} else if table_type.has_flag(.generic) {
		typ = ast.new_type(p.table.find_or_register_array(table_type)).set_flag(.generic)
	} else {
		typ = ast.new_type(p.table.find_or_register_array(table_type))
	}

	p.check(.rcbr)
	p.inside_match = false
	p.inside_orm = false
	or_expr := p.parse_sql_or_block()
	p.inside_match = prefix.tmp_inside_match

	return ast.SqlExpr{
		aggregate_kind:   aggregate_kind
		aggregate_field:  aggregate_field
		is_insert:        is_insert
		typ:              typ.set_flag(.result)
		scope:            p.scope
		or_expr:          or_expr
		db_expr:          prefix.db_expr
		where_expr:       where_expr
		has_where:        has_where
		has_limit:        has_limit
		limit_expr:       limit_expr
		has_offset:       has_offset
		offset_expr:      offset_expr
		has_order:        has_order
		order_expr:       order_expr
		has_desc:         has_desc
		has_distinct:     has_distinct
		is_array:         aggregate_kind == .none
		is_generated:     false
		is_dynamic:       is_dynamic
		inserted_var:     inserted_var
		requested_fields: requested_fields
		pos:              prefix.pos.extend(p.prev_tok.pos())
		table_expr:       ast.TypeNode{
			typ: table_type
			pos: table_pos
		}
		joins:            joins
	}
}

// parse_sql_join_clause parses a JOIN clause like:
// `join Department on User.dept_id == Department.id`
// `left join Department on User.dept_id == Department.id`
// `inner join Department on User.dept_id == Department.id`
fn (mut p Parser) parse_sql_join_clause() ast.JoinClause {
	mut kind := ast.JoinKind.inner
	join_pos := p.tok.pos()

	// Check for join type prefix (left, right, full, inner)
	if p.tok.lit == 'left' {
		kind = .left
		p.next()
	} else if p.tok.lit == 'right' {
		kind = .right
		p.next()
	} else if p.tok.lit == 'full' {
		kind = .full_outer
		p.next()
		// Handle optional 'outer' keyword
		if p.tok.kind == .name && p.tok.lit == 'outer' {
			p.next()
		}
	} else if p.tok.lit == 'inner' {
		// 'inner' is optional, just skip it
		p.next()
	}

	// Now expect 'join'
	if p.tok.kind != .name || p.tok.lit != 'join' {
		p.error('expected `join` keyword after join type')
		return ast.JoinClause{}
	}
	p.next() // consume 'join'

	// Parse the joined table type
	table_pos := p.tok.pos()
	table_type := p.parse_type()

	// Expect 'on' keyword
	if p.tok.kind != .name || p.tok.lit != 'on' {
		p.error('expected `on` keyword after table name in JOIN clause')
		return ast.JoinClause{}
	}
	p.next() // consume 'on'

	// Parse the ON condition expression
	on_expr := p.expr(0)

	return ast.JoinClause{
		kind:       kind
		pos:        join_pos
		table_expr: ast.TypeNode{
			typ: table_type
			pos: table_pos
		}
		on_expr:    on_expr
	}
}

// insert user into User
// update User set nr_oders=nr_orders+1 where id == user_id
// delete
fn (mut p Parser) sql_stmt() ast.SqlStmt {
	prefix := p.sql_prefix()
	return p.sql_stmt_after_prefix(prefix)
}

fn (mut p Parser) sql_stmt_after_prefix(prefix SqlPrefix) ast.SqlStmt {
	mut pos := prefix.pos

	mut lines := []ast.SqlStmtLine{}

	for p.tok.kind != .rcbr {
		if p.tok.kind == .eof {
			p.unexpected_with_pos(pos, got: 'eof, while parsing an SQL statement')
			return ast.SqlStmt{}
		}
		lines << p.parse_sql_stmt_line(prefix.is_dynamic)
	}

	p.next()

	p.inside_orm = false
	p.inside_match = false
	mut or_expr := p.parse_sql_or_block()
	p.inside_match = prefix.tmp_inside_match

	pos.last_line = p.prev_tok.line_nr
	return ast.SqlStmt{
		pos:     pos.extend(p.prev_tok.pos())
		db_expr: prefix.db_expr
		lines:   lines
		or_expr: or_expr
	}
}

fn (mut p Parser) parse_sql_or_block() ast.OrExpr {
	mut stmts := []ast.Stmt{}
	mut kind := ast.OrKind.absent
	mut pos := p.tok.pos()
	mut or_scope := ast.empty_scope

	if p.tok.kind == .key_orelse {
		kind = .block
		stmts, pos, or_scope = p.or_block(.with_err_var)
	} else if p.tok.kind == .not {
		kind = .propagate_result
		or_scope = p.scope
		p.next()
	}

	return ast.OrExpr{
		stmts: stmts
		kind:  kind
		pos:   pos
		scope: or_scope
	}
}

fn (mut p Parser) parse_sql_stmt_line(is_dynamic bool) ast.SqlStmtLine {
	pre_comments := p.eat_comments()
	mut n := p.check_name() // insert
	pos := p.tok.pos()
	mut kind := ast.SqlStmtKind.insert
	if n == 'delete' {
		kind = .delete
	} else if n == 'upsert' {
		kind = .upsert
	} else if n == 'update' {
		kind = .update
	} else if n == 'create' {
		kind = .create
		table := p.check_name()
		if table != 'table' {
			p.error('expected `table` got `${table}`')
			return ast.SqlStmtLine{}
		}
		typ := p.parse_type()
		typ_pos := p.tok.pos()
		end_comments := p.eat_comments()
		return ast.SqlStmtLine{
			kind:         kind
			pos:          pos.extend(p.prev_tok.pos())
			table_expr:   ast.TypeNode{
				typ: typ
				pos: typ_pos
			}
			scope:        p.scope
			is_generated: false
			is_dynamic:   is_dynamic
			pre_comments: pre_comments
			end_comments: end_comments
		}
	} else if n == 'drop' {
		kind = .drop
		table := p.check_name()
		if table != 'table' {
			p.error('expected `table` got `${table}`')
			return ast.SqlStmtLine{}
		}
		typ := p.parse_type()
		typ_pos := p.tok.pos()
		end_comments := p.eat_comments()
		return ast.SqlStmtLine{
			kind:         kind
			pos:          pos.extend(p.prev_tok.pos())
			table_expr:   ast.TypeNode{
				typ: typ
				pos: typ_pos
			}
			is_generated: false
			is_dynamic:   is_dynamic
			scope:        p.scope
			pre_comments: pre_comments
			end_comments: end_comments
		}
	}
	if is_dynamic && kind != .update {
		p.error('`dynamic` is only supported for ORM `select` and `update` queries')
		return ast.SqlStmtLine{}
	}
	mut inserted_var := ''
	mut table_type := ast.no_type
	if kind != .delete {
		if kind == .update {
			table_type = p.parse_type()
		} else if kind in [.insert, .upsert] {
			expr := p.expr(0)
			if expr is ast.Ident {
				inserted_var = expr.name
			} else {
				p.error('can only insert variables')
				return ast.SqlStmtLine{}
			}
		}
	}
	n = p.check_name() // into
	mut updated_columns := []string{}
	mut update_exprs := []ast.Expr{cap: 5}
	mut update_data_expr := ast.empty_expr
	if kind in [.insert, .upsert] && n != 'into' {
		p.error('expecting `into`')
		return ast.SqlStmtLine{}
	} else if kind == .update {
		if n != 'set' {
			p.error('expecting `set`')
			return ast.SqlStmtLine{}
		}
		if is_dynamic {
			update_data_expr = p.expr(0)
		} else {
			for {
				column := p.check_name()
				updated_columns << column
				p.check(.assign)
				update_exprs << p.expr(0)
				if p.tok.kind == .comma {
					p.check(.comma)
				} else {
					break
				}
			}
		}
	} else if kind == .delete && n != 'from' {
		p.error('expecting `from`')
		return ast.SqlStmtLine{}
	}

	mut table_pos := p.tok.pos()
	mut where_expr := ast.empty_expr
	if kind in [.insert, .upsert] {
		table_pos = p.tok.pos()
		table_type = p.parse_type()
	} else if kind == .update {
		p.check_sql_keyword('where') or { return ast.SqlStmtLine{} }
		where_expr = p.expr(0)

		where_expr_result := p.check_sql_where_expr_has_no_undefined_variables(&where_expr, [])
		if where_expr_result is ast.NodeError {
			return ast.SqlStmtLine{}
		}
	} else if kind == .delete {
		table_pos = p.tok.pos()
		table_type = p.parse_type()
		p.check_sql_keyword('where') or { return ast.SqlStmtLine{} }
		where_expr = p.expr(0)

		where_expr_result := p.check_sql_where_expr_has_no_undefined_variables(&where_expr, [])
		if where_expr_result is ast.NodeError {
			return ast.SqlStmtLine{}
		}
	}
	end_comments := p.eat_comments()
	return ast.SqlStmtLine{
		table_expr:       ast.TypeNode{
			typ: table_type
			pos: table_pos
		}
		object_var:       inserted_var
		pos:              pos
		updated_columns:  updated_columns
		update_exprs:     update_exprs
		update_data_expr: update_data_expr
		kind:             kind
		where_expr:       where_expr
		is_generated:     false
		is_dynamic:       is_dynamic
		scope:            p.scope
		pre_comments:     pre_comments
		end_comments:     end_comments
	}
}

fn (p &Parser) is_sql_query_data_expr() bool {
	if p.tok.kind != .lcbr {
		return false
	}
	mut idx := 1
	for p.peek_token(idx).kind == .comment {
		idx++
	}
	first := p.peek_token(idx)
	if first.kind == .key_if {
		return true
	}
	if first.kind != .name {
		return false
	}
	idx++
	for p.peek_token(idx).kind == .dot && p.peek_token(idx + 1).kind == .name {
		idx += 2
	}
	return is_sql_query_data_operator(p.peek_token(idx).kind)
}

fn is_sql_query_data_operator(kind token.Kind) bool {
	return kind in [.eq, .ne, .gt, .lt, .ge, .le, .key_like, .key_ilike, .key_in, .not_in, .key_is,
		.not_is]
}

fn (mut p Parser) sql_query_data_expr() ast.Expr {
	start_pos := p.tok.pos()
	block := p.parse_sql_query_data_items_block()
	return ast.SqlQueryDataExpr{
		pos:          start_pos.extend(p.prev_tok.pos())
		items:        block.items
		end_comments: block.end_comments
	}
}

fn (mut p Parser) parse_sql_query_data_items_block() SqlQueryDataItemsBlock {
	p.check(.lcbr)
	mut items := []ast.SqlQueryDataItem{}
	mut pending_comments := p.eat_comments()
	for {
		if p.tok.kind == .rcbr {
			break
		}
		if p.tok.kind == .eof {
			p.unexpected(got: 'eof, while parsing a dynamic ORM expression')
			break
		}
		mut item := p.parse_sql_query_data_item()
		item = sql_query_data_item_with_pre_comments(item, pending_comments)
		pending_comments = []
		item = sql_query_data_item_with_end_comments(item, p.eat_comments(same_line: true))
		if p.tok.kind == .comma {
			p.next()
			item = sql_query_data_item_with_end_comments(item, p.eat_comments(same_line: true))
			items << item
			pending_comments = p.eat_comments()
			continue
		}
		items << item
		pending_comments = p.eat_comments()
		if p.tok.kind != .rcbr {
			p.error('expected `,` or `}` in a dynamic ORM expression')
			break
		}
	}
	p.check(.rcbr)
	return SqlQueryDataItemsBlock{
		items:        items
		end_comments: pending_comments
	}
}

fn (mut p Parser) parse_sql_query_data_item() ast.SqlQueryDataItem {
	if p.tok.kind == .key_if {
		return p.parse_sql_query_data_if_item()
	}
	expr := p.expr(0)
	return ast.SqlQueryDataLeaf{
		pos:  expr.pos()
		expr: expr
	}
}

fn sql_query_data_item_with_pre_comments(item ast.SqlQueryDataItem, comments []ast.Comment) ast.SqlQueryDataItem {
	if comments.len == 0 {
		return item
	}
	return match item {
		ast.SqlQueryDataLeaf {
			mut leaf := item
			leaf.pre_comments << comments
			leaf
		}
		ast.SqlQueryDataIf {
			mut if_item := item
			if_item.pre_comments << comments
			if_item
		}
	}
}

fn sql_query_data_item_with_end_comments(item ast.SqlQueryDataItem, comments []ast.Comment) ast.SqlQueryDataItem {
	if comments.len == 0 {
		return item
	}
	return match item {
		ast.SqlQueryDataLeaf {
			mut leaf := item
			leaf.end_comments << comments
			leaf
		}
		ast.SqlQueryDataIf {
			mut if_item := item
			if_item.end_comments << comments
			if_item
		}
	}
}

fn (mut p Parser) parse_sql_query_data_if_guard_expr() ast.IfGuardExpr {
	p.open_scope()
	mut vars := []ast.IfGuardVar{}
	mut var_names := []string{}
	for {
		mut var := ast.IfGuardVar{}
		mut is_mut := false
		if p.tok.kind == .key_mut {
			is_mut = true
			p.next()
		}
		var.is_mut = p.scope_var_is_mut(is_mut)
		var.pos = p.tok.pos()
		var.name = p.check_name()
		var_names << var.name

		if p.scope.known_var(var.name) {
			p.error_with_pos('redefinition of `${var.name}`', var.pos)
		}
		vars << var
		if p.tok.kind != .comma {
			break
		}
		p.next()
	}
	p.check(.decl_assign)
	old_assign_rhs := p.inside_assign_rhs
	p.inside_assign_rhs = true
	expr := p.expr(0)
	p.inside_assign_rhs = old_assign_rhs
	if expr !in [ast.CallExpr, ast.IndexExpr, ast.PrefixExpr, ast.SelectorExpr, ast.Ident] {
		p.error_with_pos('if guard condition expression is illegal, it should return an Option',
			expr.pos())
	}
	p.check_undefined_variables(var_names, expr) or { p.error_with_pos(err.msg(), expr.pos()) }
	cond := ast.IfGuardExpr{
		vars: vars
		expr: expr
	}
	for var in vars {
		p.scope.register(ast.Var{
			name:   var.name
			is_mut: var.is_mut
			expr:   cond
			pos:    var.pos
		})
	}
	return cond
}

fn (mut p Parser) parse_sql_query_data_if_item() ast.SqlQueryDataItem {
	start_pos := p.tok.pos()
	mut branches := []ast.SqlQueryDataBranch{}
	mut has_else := false
	mut prev_guard := false
	for {
		branch_pos := p.tok.pos()
		p.check(.key_if)
		mut cond := ast.empty_expr
		mut has_guard_scope := false
		if p.peek_token_after_var_list().kind == .decl_assign {
			cond = p.parse_sql_query_data_if_guard_expr()
			has_guard_scope = true
			prev_guard = true
		} else {
			cond = p.expr(0)
			prev_guard = false
		}
		p.open_scope()
		block := p.parse_sql_query_data_items_block()
		p.close_scope()
		if has_guard_scope {
			p.close_scope()
		}
		branches << ast.SqlQueryDataBranch{
			pos:          branch_pos.extend(p.prev_tok.pos())
			cond:         cond
			items:        block.items
			end_comments: block.end_comments
		}
		comments_before_else := p.eat_comments()
		if p.tok.kind != .key_else {
			return ast.SqlQueryDataIf{
				pos:          start_pos.extend(p.prev_tok.pos())
				branches:     branches
				has_else:     has_else
				end_comments: comments_before_else
			}
		}
		if comments_before_else.len > 0 {
			last_idx := branches.len - 1
			branches[last_idx].end_comments << comments_before_else
		}
		has_else = true
		else_pos := p.tok.pos()
		p.next()
		if p.tok.kind == .key_if {
			continue
		}
		p.open_scope()
		if prev_guard {
			p.scope.register(ast.Var{
				name:         'err'
				typ:          ast.error_type
				pos:          p.tok.pos()
				is_used:      false
				is_stack_obj: true
				is_special:   true
			})
		}
		else_block := p.parse_sql_query_data_items_block()
		p.close_scope()
		branches << ast.SqlQueryDataBranch{
			pos:          else_pos.extend(p.prev_tok.pos())
			cond:         ast.empty_expr
			items:        else_block.items
			end_comments: else_block.end_comments
		}
		break
	}
	return ast.SqlQueryDataIf{
		pos:      start_pos.extend(p.prev_tok.pos())
		branches: branches
		has_else: has_else
	}
}

fn (mut p Parser) check_sql_keyword(name string) ?bool {
	if p.check_name() != name {
		p.error('ORM: expecting `${name}`')
		return none
	}
	return true
}

// check_sql_where_expr_has_no_undefined_variables recursively tries to find undefined variables in the right part of infix expressions.
fn (mut p Parser) check_sql_where_expr_has_no_undefined_variables(expr &ast.Expr, unacceptable_variable_names []string) ast.Expr {
	if expr is ast.Ident {
		if !p.scope.known_var(expr.name) {
			p.check_undefined_variables(unacceptable_variable_names, expr) or {
				return p.error_with_pos(err.msg(), expr.pos)
			}
		}
	} else if expr is ast.InfixExpr {
		if expr.left is ast.Ident {
			if expr.right is ast.Ident {
				return p.check_sql_where_expr_has_no_undefined_variables(expr.right, [
					expr.left.name,
				])
			}
		}

		left_check_result := p.check_sql_where_expr_has_no_undefined_variables(expr.left, [])

		if left_check_result is ast.NodeError {
			return left_check_result
		}

		variable_names := if expr.left is ast.Ident { [expr.left.name] } else { []string{} }
		right_check_result := p.check_sql_where_expr_has_no_undefined_variables(expr.right,
			variable_names)

		if right_check_result is ast.NodeError {
			return right_check_result
		}
	} else if expr is ast.ParExpr {
		return p.check_sql_where_expr_has_no_undefined_variables(expr.expr, [])
	}

	return ast.empty_expr
}