Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

2.3 KB
Raw Blame
package trino

import (
	"github.com/bytebase/omni/trino/ast"
	"github.com/bytebase/omni/trino/parser"
	"github.com/pkg/errors"

	storepb "github.com/bytebase/bytebase/backend/generated-go/store"
	"github.com/bytebase/bytebase/backend/plugin/parser/base"
)

func init() {
	base.RegisterExplainStatementFunc(storepb.Engine_TRINO, explainStatement)
}

// explainStatement implements base.ExplainStatement. Trino spells its structured
// plan (FORMAT JSON); any other format the caller names gets the engine's own
// text plan (the driver capability table refuses the rest).
func explainStatement(statement string, format base.ExplainFormat) (string, error) {
	node, err := singleStatement(statement)
	if err != nil {
		return "", err
	}
	planned := statement
	if explain, ok := node.(*parser.ExplainStmt); ok {
		if explain.Analyze {
			return "", base.ErrExplainAnalyzeExecutes
		}
		if inner, ok := explainedText(explain, statement); ok {
			planned = inner
		} else {
			// Nothing to rebuild around: run what the user wrote rather than
			// plan a plan.
			return statement, nil
		}
	}
	if format == base.ExplainFormatJSON {
		return "EXPLAIN (FORMAT JSON) " + planned, nil
	}
	return "EXPLAIN " + planned, nil
}

// singleStatement returns the one statement in text. An explain request plans one
// statement at a time: both the drivers and the API gate split a multi-statement
// request first.
func singleStatement(text string) (ast.Node, error) {
	parsed, err := parseTrinoSQL(text)
	if err != nil {
		return nil, err
	}
	if len(parsed) == 0 || parsed[0].Node() == nil {
		return nil, errors.New("EXPLAIN needs a statement to plan")
	}
	if len(parsed) > 1 {
		return nil, errors.New("EXPLAIN plans a single statement")
	}
	return parsed[0].Node(), nil
}

// explainedText returns the text within text of the statement explain plans, and
// whether it could be located.
func explainedText(explain *parser.ExplainStmt, text string) (string, bool) {
	inner, ok := nodeSpan(explain.Statement)
	if !ok {
		return "", false
	}
	// The plan ends where the EXPLAIN does, which is past clauses that the
	// planned statement's own location can leave out.
	if inner.Start < 0 || inner.Start >= explain.Loc.End || explain.Loc.End > len(text) {
		return "", false
	}
	return text[inner.Start:explain.Loc.End], true
}