Skip to content

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

59.9 KB
Raw Blame
package plsql

import (
	"context"
	"reflect"
	"slices"
	"strings"
	"unicode"

	oracleast "github.com/bytebase/omni/oracle/ast"
	"github.com/pkg/errors"

	"github.com/bytebase/bytebase/backend/plugin/parser/base"
	"github.com/bytebase/bytebase/backend/store/model"
)

type querySpanExtractor struct {
	ctx             context.Context
	gCtx            base.GetQuerySpanContext
	defaultDatabase string

	ctes []*base.PseudoTable

	outerTableSources []base.TableSource
	tableSourcesFrom  []base.TableSource
	linkedDatabases   map[string]linkedDatabaseResolution
}

func newQuerySpanExtractor(connectionDatabase string, gCtx base.GetQuerySpanContext) *querySpanExtractor {
	return &querySpanExtractor{
		defaultDatabase: connectionDatabase,
		gCtx:            gCtx,
		linkedDatabases: make(map[string]linkedDatabaseResolution),
	}
}

// linkedDatabaseResolution is what a database link resolved to; a nil meta means it
// resolved to nothing.
type linkedDatabaseResolution struct {
	instanceID   string
	databaseName string
	meta         *model.DatabaseMetadata
}

// getLinkedDatabaseMetadata resolves a database link once per (link, schema) for the
// statement; the access-table pass and the column pass both ask for the same links.
func (q *querySpanExtractor) getLinkedDatabaseMetadata(linkName string, schema string) (string, string, *model.DatabaseMetadata, error) {
	if q.gCtx.GetLinkedDatabaseMetadataFunc == nil {
		return "", "", nil, nil
	}
	key := linkName + "\x00" + schema
	if r, ok := q.linkedDatabases[key]; ok {
		return r.instanceID, r.databaseName, r.meta, nil
	}
	linkedInstanceID, databaseName, meta, err := q.gCtx.GetLinkedDatabaseMetadataFunc(q.ctx, q.gCtx.InstanceID, linkName, schema)
	if err != nil {
		return "", "", nil, errors.Wrapf(err, "failed to get linked database metadata for schema: %s", schema)
	}
	q.linkedDatabases[key] = linkedDatabaseResolution{instanceID: linkedInstanceID, databaseName: databaseName, meta: meta}
	return linkedInstanceID, databaseName, meta, nil
}

func (q *querySpanExtractor) getDatabaseMetadata(schema string) (*model.DatabaseMetadata, error) {
	_, meta, err := q.gCtx.GetDatabaseMetadataFunc(q.ctx, q.gCtx.InstanceID, schema)
	if err != nil {
		return nil, errors.Wrapf(err, "failed to get database metadata for schema: %s", schema)
	}
	return meta, nil
}

func (q *querySpanExtractor) existsTableMetadata(resource base.SchemaResource) bool {
	database := resource.Database
	if database == "" {
		database = q.defaultDatabase
	}
	meta, err := q.getDatabaseMetadata(database)
	if err != nil || meta == nil {
		return false
	}
	schema := meta.GetSchemaMetadata("")
	if schema == nil {
		return false
	}

	return schema.GetTable(resource.Table) != nil ||
		schema.GetView(resource.Table) != nil ||
		schema.GetMaterializedView(resource.Table) != nil ||
		schema.GetExternalTable(resource.Table) != nil
}

// isMixedQuery classifies the tables a statement reads. A linked table is a user table:
// a remote schema name says nothing about the connected instance's system schemas, and an
// info-schema verdict would skip the per-table check for it.
func isMixedQuery(local, linked []base.SchemaResource) (allSystem, mixed bool) {
	hasSystem, hasUser := false, len(linked) > 0
	for _, item := range local {
		if systemSchemaMap[item.Database] {
			hasSystem = true
		} else {
			hasUser = true
		}
	}

	if hasSystem && hasUser {
		return false, true
	}

	return !hasUser && hasSystem, false
}

var systemSchemaMap = map[string]bool{
	"ANONYMOUS":              true,
	"APPQOSSYS":              true,
	"AUDSYS":                 true,
	"CTXSYS":                 true,
	"DBSFWUSER":              true,
	"DBSNMP":                 true,
	"DGPDB_INT":              true,
	"DIP":                    true,
	"DVF":                    true,
	"DVSYS":                  true,
	"GGSYS":                  true,
	"GSMADMIN_INTERNAL":      true,
	"GSMCATUSER":             true,
	"GSMROOTUSER":            true,
	"GSMUSER":                true,
	"LBACSYS":                true,
	"MDDATA":                 true,
	"MDSYS":                  true,
	"OPS$ORACLE":             true,
	"ORACLE_OCM":             true,
	"OUTLN":                  true,
	"REMOTE_SCHEDULER_AGENT": true,
	"SYS":                    true,
	"SYS$UMF":                true,
	"SYSBACKUP":              true,
	"SYSDG":                  true,
	"SYSKM":                  true,
	"SYSRAC":                 true,
	"SYSTEM":                 true,
	"XDB":                    true,
	"XS$NULL":                true,
	"XS$$NULL":               true,
	"FLOWS_FILES":            true,
	"HR":                     true,
	"EXFSYS":                 true,
	"MGMT_VIEW":              true,
	"OLAPSYS":                true,
	"ORDDATA":                true,
	"ORDPLUGINS":             true,
	"ORDSYS":                 true,
	"OWBSYS":                 true,
	"OWBSYS_AUDIT":           true,
	"SCOTT":                  true,
	"SI_INFORMTN_SCHEMA":     true,
	"SPATIAL_CSW_ADMIN_USR":  true,
	"SPATIAL_WFS_ADMIN_USR":  true,
	"SYSMAN":                 true,
	"WMSYS":                  true,
	"OJVMSYS":                true,
}

func (q *querySpanExtractor) plsqlFindTableSchema(dbLink []string, schemaName, tableName string) (base.TableSource, error) {
	if len(dbLink) > 0 {
		linkName := strings.Join(dbLink, ".")
		linkedInstanceID, linkedDatabaseName, linkedMeta, err := q.getLinkedDatabaseMetadata(linkName, schemaName)
		if err != nil {
			return nil, errors.Wrapf(err, "failed to get linked database metadata for: %s", dbLink)
		}
		if linkedMeta == nil {
			return nil, &base.ResourceNotFoundError{
				DatabaseLink: &linkName,
			}
		}
		// Lineage carries the resolved database, as the access set does, so the masker
		// finds the policy of the database the link reaches rather than of "" for `t@link`.
		return q.findTableSchemaInMetadata(linkedInstanceID, linkedMeta, linkedDatabaseName, tableName)
	}

	if schemaName == q.defaultDatabase {
		for i := len(q.ctes) - 1; i >= 0; i-- {
			table := q.ctes[i]
			if table.Name == tableName {
				return table, nil
			}
		}
	}

	dbMetadata, err := q.getDatabaseMetadata(schemaName)
	if err != nil {
		return nil, errors.Wrapf(err, "failed to get database metadata for: %s", schemaName)
	}
	if dbMetadata == nil {
		return nil, &base.ResourceNotFoundError{
			Database: &schemaName,
		}
	}

	return q.findTableSchemaInMetadata(q.gCtx.InstanceID, dbMetadata, schemaName, tableName)
}

func (q *querySpanExtractor) findTableSchemaInMetadata(instanceID string, dbMetadata *model.DatabaseMetadata, databaseName, tableName string) (base.TableSource, error) {
	schema := dbMetadata.GetSchemaMetadata("")
	if schema == nil {
		return nil, &base.ResourceNotFoundError{
			Database: &databaseName,
		}
	}
	table := schema.GetTable(tableName)
	view := schema.GetView(tableName)
	materializedView := schema.GetMaterializedView(tableName)
	foreignTable := schema.GetExternalTable(tableName)
	if table == nil && view == nil && materializedView == nil && foreignTable == nil {
		return nil, &base.ResourceNotFoundError{
			Database: &databaseName,
			Table:    &tableName,
		}
	}

	if table != nil {
		var columns []string
		invisibleColumns := make(map[string]bool)
		for _, column := range table.GetProto().GetColumns() {
			columns = append(columns, column.Name)
			if column.IsInvisible {
				invisibleColumns[column.Name] = true
			}
		}
		return &base.PhysicalTable{
			Server:           "",
			Database:         databaseName,
			Name:             table.GetProto().Name,
			Columns:          columns,
			InvisibleColumns: invisibleColumns,
		}, nil
	}

	if foreignTable != nil {
		var columns []string
		for _, column := range foreignTable.GetProto().GetColumns() {
			columns = append(columns, column.Name)
		}
		return &base.PhysicalTable{
			Server:   "",
			Database: databaseName,
			Name:     foreignTable.GetProto().Name,
			Columns:  columns,
		}, nil
	}

	if view != nil && view.Definition != "" {
		columns, err := q.getColumnsForView(instanceID, databaseName, view.Definition)
		if err != nil {
			return nil, err
		}
		return &base.PseudoTable{
			Name:    view.Name,
			Columns: columns,
		}, nil
	}

	if materializedView != nil && materializedView.Definition != "" {
		columns, err := q.getColumnsForMaterializedView(instanceID, databaseName, materializedView.Definition)
		if err != nil {
			return nil, err
		}
		return &base.PseudoTable{
			Name:    materializedView.Name,
			Columns: columns,
		}, nil
	}
	return nil, nil
}

func (q *querySpanExtractor) getColumnsForView(instanceID, defaultDatabase, definition string) ([]base.QuerySpanResult, error) {
	newContext := base.GetQuerySpanContext{
		InstanceID:                    instanceID,
		GetDatabaseMetadataFunc:       q.gCtx.GetDatabaseMetadataFunc,
		ListDatabaseNamesFunc:         q.gCtx.ListDatabaseNamesFunc,
		GetLinkedDatabaseMetadataFunc: q.gCtx.GetLinkedDatabaseMetadataFunc,
	}
	newQ := newOmniQuerySpanExtractor(defaultDatabase, newContext)
	span, err := newQ.getOmniQuerySpan(q.ctx, definition)
	if err != nil {
		return nil, errors.Wrapf(err, "failed to get query span for view definition: %s", definition)
	}
	if span.NotFoundError != nil {
		return nil, span.NotFoundError
	}
	return span.Results, nil
}

func (q *querySpanExtractor) getColumnsForMaterializedView(instanceID, defaultDatabase, definition string) ([]base.QuerySpanResult, error) {
	newContext := base.GetQuerySpanContext{
		InstanceID:                    instanceID,
		GetDatabaseMetadataFunc:       q.gCtx.GetDatabaseMetadataFunc,
		ListDatabaseNamesFunc:         q.gCtx.ListDatabaseNamesFunc,
		GetLinkedDatabaseMetadataFunc: q.gCtx.GetLinkedDatabaseMetadataFunc,
	}
	newQ := newOmniQuerySpanExtractor(defaultDatabase, newContext)
	span, err := newQ.getOmniQuerySpan(q.ctx, definition)
	if err != nil {
		return nil, errors.Wrapf(err, "failed to get query span for materialized view definition: %s", definition)
	}
	if span.NotFoundError != nil {
		return nil, span.NotFoundError
	}
	return span.Results, nil
}

type omniQuerySpanExtractor struct {
	*querySpanExtractor

	source                   string
	topLevelTableSourcesFrom []base.TableSource
}

func newOmniQuerySpanExtractor(connectionDatabase string, gCtx base.GetQuerySpanContext) *omniQuerySpanExtractor {
	return &omniQuerySpanExtractor{
		querySpanExtractor: newQuerySpanExtractor(connectionDatabase, gCtx),
	}
}

func (q *omniQuerySpanExtractor) getOmniQuerySpan(ctx context.Context, statement string) (*base.QuerySpan, error) {
	q.ctx = ctx
	q.source = statement

	list, err := ParsePLSQL(statement)
	if err != nil {
		return nil, errors.Wrapf(err, "failed to parse statement: %s", statement)
	}
	if list == nil || len(list.Items) == 0 {
		return nil, nil
	}
	if len(list.Items) > 1 {
		return nil, errors.Errorf("query span extraction only supports single statement, got %d statements", len(list.Items))
	}
	raw, ok := list.Items[0].(*oracleast.RawStmt)
	if !ok || raw.Stmt == nil {
		return nil, nil
	}

	accessTables, linkedTables := collectOmniAccessTables(q.defaultDatabase, raw.Stmt)
	allSystem, mixed := isMixedQuery(accessTables, linkedTables)
	if mixed {
		return nil, base.MixUserSystemTablesError
	}

	queryType := omniQueryType(raw.Stmt, allSystem)
	if queryType != base.Select {
		sourceColumns := make(base.SourceColumnSet)
		for _, resource := range accessTables {
			sourceColumns[base.ColumnResource{Database: resource.Database, Table: resource.Table}] = true
		}
		return &base.QuerySpan{
			Type:          queryType,
			SourceColumns: sourceColumns,
			Results:       []base.QuerySpanResult{},
		}, nil
	}

	columnSet := make(base.SourceColumnSet)
	for _, resource := range accessTables {
		if !q.existsTableMetadata(resource) {
			continue
		}
		columnSet[base.ColumnResource{
			Database: resource.Database,
			Table:    resource.Table,
		}] = true
	}
	for _, resource := range linkedTables {
		column, err := q.linkedAccessColumn(resource)
		if err != nil {
			return nil, err
		}
		columnSet[column] = true
	}
	selectStmt, ok := raw.Stmt.(*oracleast.SelectStmt)
	if !ok {
		return nil, errors.Errorf("expected SELECT statement, got %T", raw.Stmt)
	}
	tableSource, err := q.extractOmniSelect(selectStmt)
	if err != nil {
		var resourceNotFound *base.ResourceNotFoundError
		if errors.As(err, &resourceNotFound) {
			if len(columnSet) == 0 {
				columnSet[base.ColumnResource{
					Database: q.defaultDatabase,
				}] = true
			}
			return &base.QuerySpan{
				Type:          base.Select,
				SourceColumns: columnSet,
				Results:       []base.QuerySpanResult{},
				NotFoundError: resourceNotFound,
			}, nil
		}
		return nil, err
	}
	var results []base.QuerySpanResult
	if tableSource != nil {
		results = tableSource.GetQuerySpanResult()
	}
	if resourceNotFound := q.findMissingOmniAccessTable(raw.Stmt, accessTables); resourceNotFound != nil {
		if len(columnSet) == 0 {
			columnSet[base.ColumnResource{
				Database: q.defaultDatabase,
			}] = true
		}
		return &base.QuerySpan{
			Type:          base.Select,
			SourceColumns: columnSet,
			Results:       []base.QuerySpanResult{},
			NotFoundError: resourceNotFound,
		}, nil
	}
	return &base.QuerySpan{
		Type:          base.Select,
		SourceColumns: columnSet,
		Results:       results,
	}, nil
}

func omniQueryType(stmt oracleast.StmtNode, allSystem bool) base.QueryType {
	if stmt == nil {
		return base.QueryTypeUnknown
	}
	switch stmt.(type) {
	case *oracleast.ExplainPlanStmt:
		return base.Explain
	case *oracleast.SelectStmt:
		if allSystem {
			return base.SelectInfoSchema
		}
		return base.Select
	case *oracleast.InsertStmt, *oracleast.UpdateStmt, *oracleast.DeleteStmt, *oracleast.MergeStmt,
		*oracleast.CallStmt, *oracleast.LockTableStmt:
		return base.DML
	case *oracleast.CreateTableStmt, *oracleast.AlterTableStmt, *oracleast.DropStmt,
		*oracleast.CreateIndexStmt, *oracleast.CreateViewStmt,
		*oracleast.CreateSequenceStmt, *oracleast.CreateSynonymStmt,
		*oracleast.CreateDatabaseLinkStmt, *oracleast.CreateTypeStmt,
		*oracleast.CreatePackageStmt, *oracleast.CreateProcedureStmt,
		*oracleast.CreateFunctionStmt, *oracleast.CreateTriggerStmt,
		*oracleast.TruncateStmt, *oracleast.AlterSessionStmt,
		*oracleast.AlterSystemStmt, *oracleast.CreateUserStmt,
		*oracleast.AlterUserStmt, *oracleast.CreateRoleStmt,
		*oracleast.AlterRoleStmt, *oracleast.CreateProfileStmt,
		*oracleast.AlterProfileStmt, *oracleast.AlterResourceCostStmt,
		*oracleast.AdminDDLStmt, *oracleast.CreateSchemaStmt,
		*oracleast.AlterDatabaseLinkStmt, *oracleast.AlterSynonymStmt,
		*oracleast.AlterMaterializedViewStmt,
		*oracleast.CreateAuditPolicyStmt, *oracleast.AlterAuditPolicyStmt,
		*oracleast.DropAuditPolicyStmt, *oracleast.CreateTablespaceStmt,
		*oracleast.AlterTablespaceStmt, *oracleast.CreateTablespaceSetStmt,
		*oracleast.DropTablespaceStmt, *oracleast.CreateClusterStmt,
		*oracleast.CreateDimensionStmt, *oracleast.AlterClusterStmt,
		*oracleast.AlterDimensionStmt, *oracleast.CreateMaterializedZonemapStmt,
		*oracleast.AlterMaterializedZonemapStmt, *oracleast.CreateInmemoryJoinGroupStmt,
		*oracleast.AlterInmemoryJoinGroupStmt, *oracleast.AlterIndexStmt,
		*oracleast.AlterViewStmt, *oracleast.AlterSequenceStmt,
		*oracleast.AlterProcedureStmt, *oracleast.AlterFunctionStmt,
		*oracleast.AlterPackageStmt, *oracleast.AlterTriggerStmt,
		*oracleast.AlterTypeStmt, *oracleast.CreateIndextypeStmt,
		*oracleast.AlterIndextypeStmt, *oracleast.CreateOperatorStmt,
		*oracleast.AlterOperatorStmt, *oracleast.CreateMviewLogStmt,
		*oracleast.AlterMviewLogStmt, *oracleast.CreateAnalyticViewStmt,
		*oracleast.AlterAnalyticViewStmt, *oracleast.CreateJsonDualityViewStmt,
		*oracleast.AlterJsonDualityViewStmt, *oracleast.CreateAttributeDimensionStmt,
		*oracleast.AlterAttributeDimensionStmt, *oracleast.CreateHierarchyStmt,
		*oracleast.AlterHierarchyStmt, *oracleast.CreateDomainStmt,
		*oracleast.AlterDomainStmt, *oracleast.CreatePropertyGraphStmt,
		*oracleast.CreateVectorIndexStmt, *oracleast.CreateLockdownProfileStmt,
		*oracleast.AlterLockdownProfileStmt, *oracleast.CreateOutlineStmt,
		*oracleast.AlterOutlineStmt:
		return base.DDL
	}
	return base.QueryTypeUnknown
}

// linkedAccessColumn authorizes the name as written, not looked up in connected-instance
// metadata, which would drop a remote table or keep a same-named local one as the wrong
// resource. A link that resolves to nothing yields Server set and Instance empty.
func (q *omniQuerySpanExtractor) linkedAccessColumn(resource base.SchemaResource) (base.ColumnResource, error) {
	column := base.ColumnResource{
		Server:   resource.LinkedServer,
		Database: resource.Database,
		Table:    resource.Table,
	}
	linkedInstanceID, linkedDatabaseName, linkedMeta, err := q.getLinkedDatabaseMetadata(resource.LinkedServer, resource.Database)
	if err != nil {
		return base.ColumnResource{}, err
	}
	if linkedMeta == nil || linkedInstanceID == "" || linkedDatabaseName == "" {
		return column, nil
	}
	column.Instance = linkedInstanceID
	column.Database = linkedDatabaseName
	return column, nil
}

func (q *omniQuerySpanExtractor) findMissingOmniAccessTable(stmt oracleast.StmtNode, accessTables []base.SchemaResource) *base.ResourceNotFoundError {
	cteNames := collectOmniCTENames(stmt)
	for _, resource := range accessTables {
		if cteNames[resource.Table] || q.existsTableMetadata(resource) {
			continue
		}
		database := resource.Database
		if database == "" {
			database = q.defaultDatabase
		}
		table := resource.Table
		return &base.ResourceNotFoundError{
			Database: &database,
			Table:    &table,
		}
	}
	return nil
}

func collectOmniCTENames(stmt oracleast.StmtNode) map[string]bool {
	result := make(map[string]bool)
	oracleast.Inspect(stmt, func(node oracleast.Node) bool {
		cte, ok := node.(*oracleast.CTE)
		if ok {
			result[cte.Name] = true
		}
		return true
	})
	return result
}

// isOmniDual reports whether a name is Oracle's DUAL pseudo-table: SYS.DUAL, "PUBLIC".DUAL,
// or an unqualified local DUAL. A schema may own a real table named DUAL, which a qualified
// name resolves to; an unqualified name through a link resolves in the link user's schema
// first, so it is a table there. The unqualified local case assumes the session schema
// owns no DUAL table, as the extractor always has.
func isOmniDual(name *oracleast.ObjectName) bool {
	if name.Name != "DUAL" {
		return false
	}
	return (name.Schema == "" && name.DBLink == "") || name.Schema == "SYS" || name.Schema == "PUBLIC"
}

func omniDualTable() base.TableSource {
	return &base.PseudoTable{
		Name:    "DUAL",
		Columns: []base.QuerySpanResult{},
	}
}

// omniTableLink is the database link a table reference names, as Oracle identifies it. A
// connection qualifier is part of the name: `t@link@q` reaches the link LINK@Q, which omni
// splits between ObjectName.DBLink and TableRef.Dblink. TableRef.Dblink alone names no
// link: omni fills it for a link after a partition clause, which Oracle rejects (ORA-03048).
func omniTableLink(ref *oracleast.TableRef) string {
	if ref.Name == nil {
		return ""
	}
	if ref.Name.DBLink != "" && ref.Dblink != "" {
		return ref.Name.DBLink + "@" + ref.Dblink
	}
	return ref.Name.DBLink
}

// A linked table keeps the schema as written; an unqualified one lives in the link user's
// schema, which the resolver supplies.
func collectOmniAccessTables(defaultDatabase string, stmt oracleast.StmtNode) (local, linked []base.SchemaResource) {
	seen := make(map[base.SchemaResource]bool)
	addResource := func(name *oracleast.ObjectName, link string) {
		if name == nil || isOmniDual(name) {
			return
		}
		database := name.Schema
		if database == "" && link == "" {
			database = defaultDatabase
		}
		resource := base.SchemaResource{
			Database:     database,
			Table:        name.Name,
			LinkedServer: link,
		}
		if seen[resource] {
			return
		}
		seen[resource] = true
		if link != "" {
			linked = append(linked, resource)
			return
		}
		local = append(local, resource)
	}
	addTarget := func(name *oracleast.ObjectName) {
		if name != nil {
			addResource(name, name.DBLink)
		}
	}
	oracleast.Inspect(stmt, func(node oracleast.Node) bool {
		switch node := node.(type) {
		case *oracleast.TableRef:
			addResource(node.Name, omniTableLink(node))
		case *oracleast.ContainersExpr:
			addTarget(node.Name)
		// A DML target is an ObjectName, not a TableRef, so it is named here.
		case *oracleast.InsertStmt:
			addTarget(node.Table)
		case *oracleast.InsertIntoClause:
			addTarget(node.Table)
		case *oracleast.UpdateStmt:
			addTarget(node.Table)
		case *oracleast.DeleteStmt:
			addTarget(node.Table)
		case *oracleast.MergeStmt:
			addTarget(node.Target)
		default:
		}
		return true
	})
	return local, linked
}

func (q *omniQuerySpanExtractor) clone() *omniQuerySpanExtractor {
	copyExtractor := *q.querySpanExtractor
	return &omniQuerySpanExtractor{
		querySpanExtractor:       &copyExtractor,
		source:                   q.source,
		topLevelTableSourcesFrom: cloneTableSourceSlice(q.topLevelTableSourcesFrom),
	}
}

func (q *omniQuerySpanExtractor) extractOmniSelect(stmt *oracleast.SelectStmt) (base.TableSource, error) {
	if stmt == nil {
		return nil, nil
	}

	oldCTEs := q.ctes
	if stmt.WithClause != nil {
		for _, node := range listItems(stmt.WithClause.CTEs) {
			cte, ok := node.(*oracleast.CTE)
			if !ok {
				continue
			}
			table, err := q.extractOmniCTE(cte)
			if err != nil {
				q.ctes = oldCTEs
				return nil, err
			}
			q.ctes = append(q.ctes, table)
		}
	}
	defer func() {
		q.ctes = oldCTEs
	}()

	if stmt.Op != 0 {
		return q.extractOmniSetSelect(stmt)
	}
	// omni wraps a parenthesized query that ORDER BY or a row limit follows,
	// or a WITH clause precedes; the wrapper has no select list of its own.
	if stmt.Larg != nil {
		return q.extractOmniSelect(stmt.Larg)
	}
	if stmt.ModelClause != nil {
		source, err := q.extractOmniModelSelect(stmt)
		if err != nil {
			return nil, err
		}
		return q.projectOmniTransformedSelect(stmt, source)
	}

	oldFrom := q.tableSourcesFrom
	oldTopLevelFrom := q.topLevelTableSourcesFrom
	q.tableSourcesFrom = nil
	q.topLevelTableSourcesFrom = nil
	defer func() {
		q.tableSourcesFrom = oldFrom
		q.topLevelTableSourcesFrom = oldTopLevelFrom
	}()

	for _, node := range listItems(stmt.FromClause) {
		tableExpr, ok := node.(oracleast.TableExpr)
		if !ok {
			continue
		}
		tableSource, err := q.extractOmniTableExpr(tableExpr)
		if err != nil {
			return nil, err
		}
		if tableSource != nil {
			q.tableSourcesFrom = append(q.tableSourcesFrom, tableSource)
			q.topLevelTableSourcesFrom = append(q.topLevelTableSourcesFrom, tableSource)
		}
	}

	results, err := q.extractOmniTargetList(stmt.TargetList)
	if err != nil {
		return nil, err
	}
	return &base.PseudoTable{
		Columns: results,
	}, nil
}

func (q *omniQuerySpanExtractor) projectOmniTransformedSelect(stmt *oracleast.SelectStmt, source base.TableSource) (base.TableSource, error) {
	oldFrom := q.tableSourcesFrom
	oldTopLevelFrom := q.topLevelTableSourcesFrom
	q.tableSourcesFrom = nil
	q.topLevelTableSourcesFrom = nil
	if source != nil {
		q.tableSourcesFrom = append(q.tableSourcesFrom, source)
		q.topLevelTableSourcesFrom = append(q.topLevelTableSourcesFrom, source)
	}
	defer func() {
		q.tableSourcesFrom = oldFrom
		q.topLevelTableSourcesFrom = oldTopLevelFrom
	}()

	results, err := q.extractOmniTargetList(stmt.TargetList)
	if err != nil {
		return nil, err
	}
	return &base.PseudoTable{Columns: results}, nil
}

func (q *omniQuerySpanExtractor) extractOmniSetSelect(stmt *oracleast.SelectStmt) (base.TableSource, error) {
	left, err := q.extractOmniSelect(omniSetLeftSelect(stmt))
	if err != nil {
		return nil, err
	}
	right, err := q.extractOmniSelect(stmt.Rarg)
	if err != nil {
		return nil, err
	}
	return mergeOmniSetTableSources(left, right)
}

func mergeOmniSetTableSources(left, right base.TableSource) (base.TableSource, error) {
	if left == nil {
		return right, nil
	}
	if right == nil {
		return left, nil
	}
	leftResults := left.GetQuerySpanResult()
	rightResults := right.GetQuerySpanResult()
	if len(leftResults) != len(rightResults) {
		return nil, errors.Errorf("left and right query span result length mismatch: %d != %d", len(leftResults), len(rightResults))
	}
	result := make([]base.QuerySpanResult, 0, len(leftResults))
	for i, leftResult := range leftResults {
		sourceColumns, _ := base.MergeSourceColumnSet(leftResult.SourceColumns, rightResults[i].SourceColumns)
		result = append(result, base.QuerySpanResult{
			Name:          leftResult.Name,
			SourceColumns: sourceColumns,
			IsPlainField:  false,
		})
	}
	return &base.PseudoTable{Columns: result}, nil
}

func (q *omniQuerySpanExtractor) extractOmniCTE(cte *oracleast.CTE) (*base.PseudoTable, error) {
	if cte == nil {
		return nil, nil
	}
	name := cte.Name
	columnNames := omniStringList(cte.Columns)

	selectStmt, ok := cte.Query.(*oracleast.SelectStmt)
	if ok && selectStmt.Op != 0 && len(columnNames) > 0 {
		initialSource, err := q.extractOmniSelect(omniSetLeftSelect(selectStmt))
		if err != nil {
			return nil, err
		}
		initial := cloneQuerySpanResults(initialSource.GetQuerySpanResult())
		applyOmniColumnAliases(initial, columnNames)

		placeholder := &base.PseudoTable{Name: name, Columns: initial}
		q.ctes = append(q.ctes, placeholder)
		defer func() {
			q.ctes = q.ctes[:len(q.ctes)-1]
		}()

		columns := initial
		for range 16 {
			placeholder.Columns = columns
			rightSource, err := q.extractOmniSelect(selectStmt.Rarg)
			if err != nil {
				return nil, err
			}
			mergedSource, err := mergeOmniSetTableSources(&base.PseudoTable{Columns: initial}, rightSource)
			if err != nil {
				return nil, err
			}
			next := cloneQuerySpanResults(mergedSource.GetQuerySpanResult())
			applyOmniColumnAliases(next, columnNames)
			if querySpanResultsEqual(columns, next) {
				return &base.PseudoTable{Name: name, Columns: next}, nil
			}
			columns = next
		}
		return &base.PseudoTable{Name: name, Columns: columns}, nil
	}

	child := q.clone()
	tableSource, err := child.extractOmniStmt(cte.Query)
	if err != nil {
		return nil, err
	}
	columns := cloneQuerySpanResults(tableSource.GetQuerySpanResult())
	applyOmniColumnAliases(columns, columnNames)
	return &base.PseudoTable{Name: name, Columns: columns}, nil
}

func (q *omniQuerySpanExtractor) extractOmniStmt(stmt oracleast.StmtNode) (base.TableSource, error) {
	selectStmt, ok := stmt.(*oracleast.SelectStmt)
	if !ok {
		return nil, errors.Errorf("unsupported statement in query span extractor: %T", stmt)
	}
	return q.extractOmniSelect(selectStmt)
}

func (q *omniQuerySpanExtractor) extractOmniTargetList(list *oracleast.List) ([]base.QuerySpanResult, error) {
	if list == nil || list.Len() == 0 {
		return q.expandOmniAsterisk("", "")
	}

	var results []base.QuerySpanResult
	for _, node := range listItems(list) {
		target, ok := node.(*oracleast.ResTarget)
		if !ok || target.Expr == nil {
			continue
		}
		if isOmniStar(target.Expr) {
			expanded, err := q.expandOmniAsterisk("", "")
			if err != nil {
				return nil, err
			}
			results = append(results, expanded...)
			continue
		}
		if ref, ok := target.Expr.(*oracleast.ColumnRef); ok && ref.Column == "*" {
			expanded, err := q.expandOmniAsterisk(ref.Schema, ref.Table)
			if err != nil {
				return nil, err
			}
			results = append(results, expanded...)
			continue
		}

		name, sourceColumns, err := q.extractOmniExpr(target.Expr)
		if err != nil {
			return nil, err
		}
		if target.Name != "" {
			name = target.Name
		}
		results = append(results, base.QuerySpanResult{
			Name:          name,
			SourceColumns: sourceColumns,
			IsPlainField:  false,
		})
	}
	return results, nil
}

func (q *omniQuerySpanExtractor) extractOmniTableExpr(expr oracleast.TableExpr) (base.TableSource, error) {
	switch expr := expr.(type) {
	case *oracleast.TableRef:
		if expr.Name == nil {
			return nil, nil
		}
		if isOmniDual(expr.Name) {
			return aliasOmniTableSource(omniDualTable(), expr.Alias), nil
		}
		dbLink := omniTableLink(expr)
		database := expr.Name.Schema
		if database == "" && dbLink == "" {
			database = q.defaultDatabase
		}
		tableSource, err := q.plsqlFindTableSchema(splitOmniDBLink(dbLink), database, expr.Name.Name)
		if err != nil {
			return nil, err
		}
		return aliasOmniTableSource(tableSource, expr.Alias), nil
	case *oracleast.SubqueryRef:
		child := q.clone()
		tableSource, err := child.extractOmniStmt(expr.Subquery)
		if err != nil {
			return nil, err
		}
		return aliasOmniTableSource(tableSource, expr.Alias), nil
	case *oracleast.SubqueryExpr:
		child := q.clone()
		tableSource, err := child.extractOmniStmt(expr.Subquery)
		if err != nil {
			return nil, err
		}
		return tableSource, nil
	case *oracleast.LateralRef:
		child := q.clone()
		child.outerTableSources = append(cloneTableSourceSlice(child.outerTableSources), q.tableSourcesFrom...)
		tableSource, err := child.extractOmniStmt(expr.Subquery)
		if err != nil {
			return nil, err
		}
		return aliasOmniTableSource(tableSource, expr.Alias), nil
	case *oracleast.JoinClause:
		left, err := q.extractOmniTableExpr(expr.Left)
		if err != nil {
			return nil, err
		}
		if left != nil {
			q.tableSourcesFrom = append(q.tableSourcesFrom, left)
		}
		right, err := q.extractOmniTableExpr(expr.Right)
		if err != nil {
			return nil, err
		}
		if right != nil {
			q.tableSourcesFrom = append(q.tableSourcesFrom, right)
		}
		return mergeOmniJoinTableSource(expr, left, right)
	case *oracleast.XmlTableRef:
		return q.extractOmniXMLTable(expr)
	case *oracleast.JsonTableRef:
		return q.extractOmniJSONTable(expr)
	case *oracleast.ContainersExpr:
		if expr.Name == nil {
			return nil, nil
		}
		if isOmniDual(expr.Name) {
			return aliasOmniTableSource(omniDualTable(), expr.Alias), nil
		}
		database := expr.Name.Schema
		if database == "" {
			database = q.defaultDatabase
		}
		tableSource, err := q.plsqlFindTableSchema(nil, database, expr.Name.Name)
		if err != nil {
			return nil, err
		}
		return aliasOmniTableSource(tableSource, expr.Alias), nil
	case *oracleast.InlineExternalTable:
		return extractOmniInlineExternalTable(expr), nil
	case *oracleast.TableCollectionExpr:
		return q.extractOmniTableCollection(expr)
	case *oracleast.PivotClause:
		return q.extractOmniPivot(expr)
	case *oracleast.UnpivotClause:
		return q.extractOmniUnpivot(expr)
	case *oracleast.MatchRecognizeClause:
		return q.extractOmniMatchRecognize(expr)
	default:
		return nil, errors.Errorf("unsupported oracle table source: %T", expr)
	}
}

func (q *omniQuerySpanExtractor) extractOmniPivot(pivot *oracleast.PivotClause) (base.TableSource, error) {
	if pivot == nil {
		return nil, nil
	}
	// Capture the FROM scope before extracting the source: a join source
	// appends its operands to tableSourcesFrom, and they must not leak past
	// this transform — the clause replaces them with its own output.
	oldFrom := q.tableSourcesFrom
	defer func() {
		q.tableSourcesFrom = oldFrom
	}()
	source, err := q.extractOmniTableExpr(pivot.Source)
	if err != nil {
		return nil, err
	}
	// While deriving the transform's output, the scope is exactly the
	// extracted source: the clause's inputs resolve against it alone, never
	// against enclosing join operands or the source's own leaked operands
	// (a USING-merged column must attribute to both sides, not to the first
	// operand in the slice).
	q.tableSourcesFrom = nil
	if source != nil {
		q.tableSourcesFrom = []base.TableSource{source}
	}

	excluded := make(map[string]bool)
	pivotSources := make(base.SourceColumnSet)
	for _, expr := range omniExprList(pivot.ForColumns) {
		name, sourceColumns, err := q.extractOmniExpr(expr)
		if err != nil {
			return nil, err
		}
		excluded[name] = true
		pivotSources, _ = base.MergeSourceColumnSet(pivotSources, sourceColumns)
	}

	var aggregates []*oracleast.PivotAggregate
	for _, item := range listItems(pivot.Aggregates) {
		aggregate, ok := item.(*oracleast.PivotAggregate)
		if ok {
			aggregates = append(aggregates, aggregate)
		}
	}
	var inItems []*oracleast.PivotInItem
	for _, item := range listItems(pivot.InItems) {
		inItem, ok := item.(*oracleast.PivotInItem)
		if ok {
			inItems = append(inItems, inItem)
		}
	}

	aggregateSources := make([]base.SourceColumnSet, len(aggregates))
	for i, aggregate := range aggregates {
		_, sourceColumns, err := q.extractOmniExpr(aggregate.Expr)
		if err != nil {
			return nil, err
		}
		aggregateSources[i] = sourceColumns
		excludeOmniColumnRefNames(excluded, aggregate.Expr)
		excludeSourceColumnNames(excluded, sourceColumns)
	}

	var results []base.QuerySpanResult
	if source != nil {
		for _, result := range source.GetQuerySpanResult() {
			if !excluded[result.Name] {
				results = append(results, cloneQuerySpanResult(result))
			}
		}
	}
	for _, inItem := range inItems {
		inName := pivotInItemName(q, inItem)
		for i, aggregate := range aggregates {
			sourceColumns, _ := base.MergeSourceColumnSet(pivotSources, aggregateSources[i])
			results = append(results, base.QuerySpanResult{
				Name:          pivotColumnName(inName, aggregate.Alias, len(aggregates)),
				SourceColumns: sourceColumns,
				IsPlainField:  false,
			})
		}
	}
	return aliasOmniTableSource(&base.PseudoTable{Columns: results}, pivot.Alias), nil
}

func (q *omniQuerySpanExtractor) extractOmniUnpivot(unpivot *oracleast.UnpivotClause) (base.TableSource, error) {
	if unpivot == nil {
		return nil, nil
	}
	// Capture the FROM scope before extracting the source: a join source
	// appends its operands to tableSourcesFrom, and they must not leak past
	// this transform — the clause replaces them with its own output.
	oldFrom := q.tableSourcesFrom
	defer func() {
		q.tableSourcesFrom = oldFrom
	}()
	source, err := q.extractOmniTableExpr(unpivot.Source)
	if err != nil {
		return nil, err
	}
	// While deriving the transform's output, the scope is exactly the
	// extracted source: the clause's inputs resolve against it alone, never
	// against enclosing join operands or the source's own leaked operands
	// (a USING-merged column must attribute to both sides, not to the first
	// operand in the slice).
	q.tableSourcesFrom = nil
	if source != nil {
		q.tableSourcesFrom = []base.TableSource{source}
	}

	valueColumns := omniExprList(unpivot.ValueColumns)
	inputSources := make([]base.SourceColumnSet, len(valueColumns))
	excluded := make(map[string]bool)
	for _, item := range listItems(unpivot.InputMappings) {
		mapping, ok := item.(*oracleast.UnpivotInItem)
		if !ok {
			continue
		}
		for i, input := range omniExprList(mapping.InputColumns) {
			name, sourceColumns, err := q.extractOmniExpr(input)
			if err != nil {
				return nil, err
			}
			excluded[name] = true
			if i < len(inputSources) {
				inputSources[i], _ = base.MergeSourceColumnSet(inputSources[i], sourceColumns)
			}
		}
	}

	var results []base.QuerySpanResult
	if source != nil {
		for _, result := range source.GetQuerySpanResult() {
			if !excluded[result.Name] {
				results = append(results, cloneQuerySpanResult(result))
			}
		}
	}
	for i, expr := range valueColumns {
		name, _, err := q.extractOmniExpr(expr)
		if err != nil {
			return nil, err
		}
		results = append(results, base.QuerySpanResult{
			Name:          name,
			SourceColumns: inputSources[i],
			IsPlainField:  false,
		})
	}
	if unpivot.PivotColumn != nil {
		name, _, err := q.extractOmniExpr(unpivot.PivotColumn)
		if err != nil {
			return nil, err
		}
		results = append(results, base.QuerySpanResult{
			Name:          name,
			SourceColumns: base.SourceColumnSet{},
			IsPlainField:  false,
		})
	}
	return aliasOmniTableSource(&base.PseudoTable{Columns: results}, unpivot.Alias), nil
}

func (q *omniQuerySpanExtractor) extractOmniModelSelect(stmt *oracleast.SelectStmt) (base.TableSource, error) {
	oldFrom := q.tableSourcesFrom
	oldTopLevelFrom := q.topLevelTableSourcesFrom
	q.tableSourcesFrom = nil
	q.topLevelTableSourcesFrom = nil
	defer func() {
		q.tableSourcesFrom = oldFrom
		q.topLevelTableSourcesFrom = oldTopLevelFrom
	}()

	for _, node := range listItems(stmt.FromClause) {
		tableExpr, ok := node.(oracleast.TableExpr)
		if !ok {
			continue
		}
		tableSource, err := q.extractOmniTableExpr(tableExpr)
		if err != nil {
			return nil, err
		}
		if tableSource != nil {
			q.tableSourcesFrom = append(q.tableSourcesFrom, tableSource)
			q.topLevelTableSourcesFrom = append(q.topLevelTableSourcesFrom, tableSource)
		}
	}

	var results []base.QuerySpanResult
	if stmt.ModelClause != nil && stmt.ModelClause.MainModel != nil && stmt.ModelClause.MainModel.ColumnClauses != nil {
		columns := stmt.ModelClause.MainModel.ColumnClauses
		for _, list := range []*oracleast.List{columns.PartitionBy, columns.DimensionBy, columns.Measures} {
			if list == nil {
				continue
			}
			extracted, err := q.extractOmniTargetList(list)
			if err != nil {
				return nil, err
			}
			results = append(results, extracted...)
		}
	}
	return &base.PseudoTable{Columns: results}, nil
}

func (*omniQuerySpanExtractor) extractOmniTableCollection(ref *oracleast.TableCollectionExpr) (base.TableSource, error) {
	if ref == nil {
		return nil, nil
	}
	var columns []base.QuerySpanResult
	for _, name := range omniStringList(ref.ColumnAliases) {
		columns = append(columns, base.QuerySpanResult{
			Name:          name,
			SourceColumns: base.SourceColumnSet{},
			IsPlainField:  false,
		})
	}
	if len(columns) == 0 {
		return nil, errors.Errorf("unsupported oracle table collection without column aliases")
	}
	return aliasOmniTableSource(&base.PseudoTable{Columns: columns}, ref.Alias), nil
}

func (q *omniQuerySpanExtractor) extractOmniMatchRecognize(ref *oracleast.MatchRecognizeClause) (base.TableSource, error) {
	if ref == nil {
		return nil, nil
	}
	// Capture the FROM scope before extracting the source: a join source
	// appends its operands to tableSourcesFrom, and they must not leak past
	// this transform — the clause replaces them with its own output.
	oldFrom := q.tableSourcesFrom
	defer func() {
		q.tableSourcesFrom = oldFrom
	}()
	source, err := q.extractOmniTableExpr(ref.Source)
	if err != nil {
		return nil, err
	}
	// While deriving the transform's output, the scope is exactly the
	// extracted source: the clause's inputs resolve against it alone, never
	// against enclosing join operands or the source's own leaked operands
	// (a USING-merged column must attribute to both sides, not to the first
	// operand in the slice).
	q.tableSourcesFrom = nil
	if source != nil {
		q.tableSourcesFrom = []base.TableSource{source}
	}

	partitionResults, err := q.extractOmniResultList(ref.PartitionBy)
	if err != nil {
		return nil, err
	}
	measureResults, err := q.extractOmniMatchRecognizeMeasureList(ref.Measures)
	if err != nil {
		return nil, err
	}
	var results []base.QuerySpanResult
	if strings.HasPrefix(strings.ToUpper(ref.RowsPerMatch), "ALL ROWS PER MATCH") && source != nil {
		results = cloneQuerySpanResults(source.GetQuerySpanResult())
	} else {
		results = append(results, partitionResults...)
	}
	results = append(results, measureResults...)
	return aliasOmniTableSource(&base.PseudoTable{Columns: results}, ref.Alias), nil
}

func (q *omniQuerySpanExtractor) extractOmniResultList(list *oracleast.List) ([]base.QuerySpanResult, error) {
	return q.extractOmniResultListWithSourceColumns(list, nil)
}

func (q *omniQuerySpanExtractor) extractOmniMatchRecognizeMeasureList(list *oracleast.List) ([]base.QuerySpanResult, error) {
	return q.extractOmniResultListWithSourceColumns(list, q.extractOmniMatchRecognizeMeasureSourceColumns)
}

func (q *omniQuerySpanExtractor) extractOmniResultListWithSourceColumns(list *oracleast.List, sourceColumnsExtractor func(oracleast.ExprNode) (base.SourceColumnSet, error)) ([]base.QuerySpanResult, error) {
	var results []base.QuerySpanResult
	for _, node := range listItems(list) {
		var expr oracleast.ExprNode
		name := ""
		switch node := node.(type) {
		case *oracleast.ResTarget:
			expr = node.Expr
			name = node.Name
		case oracleast.ExprNode:
			expr = node
		default:
			continue
		}
		if expr == nil {
			continue
		}

		extractedName, sourceColumns, err := q.extractOmniExpr(expr)
		if err != nil {
			return nil, err
		}
		if sourceColumnsExtractor != nil {
			sourceColumns, err = sourceColumnsExtractor(expr)
			if err != nil {
				return nil, err
			}
		}
		if name == "" {
			name = extractedName
		}
		results = append(results, base.QuerySpanResult{
			Name:          name,
			SourceColumns: sourceColumns,
			IsPlainField:  false,
		})
	}
	return results, nil
}

func (q *omniQuerySpanExtractor) extractOmniMatchRecognizeMeasureSourceColumns(expr oracleast.ExprNode) (base.SourceColumnSet, error) {
	return q.extractOmniExprSourceColumnsWithResolver(expr, func(node *oracleast.ColumnRef) base.SourceColumnSet {
		sourceColumns := q.getOmniFieldColumnSource(node.Schema, node.Table, node.Column)
		if len(sourceColumns) == 0 && node.Schema == "" && node.Table != "" {
			sourceColumns = q.getOmniFieldColumnSource("", "", node.Column)
		}
		return sourceColumns
	})
}

func omniSetLeftSelect(stmt *oracleast.SelectStmt) *oracleast.SelectStmt {
	if stmt == nil {
		return nil
	}
	if stmt.Larg != nil {
		return stmt.Larg
	}
	body := *stmt
	body.Op = 0
	body.SetAll = false
	body.Larg = nil
	body.Rarg = nil
	return &body
}

func mergeOmniJoinTableSource(join *oracleast.JoinClause, left, right base.TableSource) (base.TableSource, error) {
	if left == nil {
		return right, nil
	}
	if right == nil {
		return left, nil
	}
	leftResults := left.GetQuerySpanResult()
	rightResults := right.GetQuerySpanResult()
	result := new(base.PseudoTable)

	leftIndex := make(map[string]int)
	rightIndex := make(map[string]int)
	for i, field := range leftResults {
		leftIndex[field.Name] = i
	}
	for i, field := range rightResults {
		rightIndex[field.Name] = i
	}

	if isOmniNaturalJoin(join.Type) {
		for _, field := range leftResults {
			if rightIdx, ok := rightIndex[field.Name]; ok {
				field.SourceColumns, _ = base.MergeSourceColumnSet(field.SourceColumns, rightResults[rightIdx].SourceColumns)
			}
			result.Columns = append(result.Columns, field)
		}
		for _, field := range rightResults {
			if _, ok := leftIndex[field.Name]; !ok {
				result.Columns = append(result.Columns, field)
			}
		}
		return result, nil
	}

	if len(listItems(join.Using)) != 0 {
		usingMap := make(map[string]bool)
		for _, node := range listItems(join.Using) {
			switch node := node.(type) {
			case *oracleast.String:
				usingMap[node.Str] = true
			case *oracleast.ColumnRef:
				usingMap[node.Column] = true
			default:
			}
		}
		for _, field := range leftResults {
			if usingMap[field.Name] {
				if rightIdx, ok := rightIndex[field.Name]; ok {
					field.SourceColumns, _ = base.MergeSourceColumnSet(field.SourceColumns, rightResults[rightIdx].SourceColumns)
				}
			}
			result.Columns = append(result.Columns, field)
		}
		for _, field := range rightResults {
			if !usingMap[field.Name] {
				result.Columns = append(result.Columns, field)
			}
		}
		return result, nil
	}

	result.Columns = append(result.Columns, leftResults...)
	result.Columns = append(result.Columns, rightResults...)
	return result, nil
}

func isOmniNaturalJoin(joinType oracleast.JoinType) bool {
	switch joinType {
	case oracleast.JOIN_NATURAL_INNER, oracleast.JOIN_NATURAL_LEFT, oracleast.JOIN_NATURAL_RIGHT, oracleast.JOIN_NATURAL_FULL:
		return true
	default:
		return false
	}
}

func (q *omniQuerySpanExtractor) extractOmniExpr(expr oracleast.ExprNode) (string, base.SourceColumnSet, error) {
	if expr == nil {
		return "", base.SourceColumnSet{}, nil
	}

	switch expr := expr.(type) {
	case *oracleast.ColumnRef:
		if expr.Column == "*" {
			return "*", base.SourceColumnSet{}, nil
		}
		return expr.Column, q.getOmniFieldColumnSource(expr.Schema, expr.Table, expr.Column), nil
	case *oracleast.Star:
		return "*", base.SourceColumnSet{}, nil
	case *oracleast.NumberLiteral:
		return q.omniExprName(expr.Loc, expr.Val), base.SourceColumnSet{}, nil
	case *oracleast.StringLiteral:
		return q.omniExprName(expr.Loc, expr.Val), base.SourceColumnSet{}, nil
	case *oracleast.NullLiteral:
		return q.omniExprName(expr.Loc, "NULL"), base.SourceColumnSet{}, nil
	case *oracleast.DateTimeLiteral:
		return q.omniExprName(expr.Loc, expr.TypeName+" "+expr.Val), base.SourceColumnSet{}, nil
	case *oracleast.SubqueryExpr:
		child := q.clone()
		child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)
		tableSource, err := child.extractOmniStmt(expr.Subquery)
		if err != nil {
			return "", nil, err
		}
		return q.omniExprName(expr.Loc, ""), mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()), nil
	case *oracleast.ExistsExpr:
		child := q.clone()
		child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)
		tableSource, err := child.extractOmniStmt(expr.Subquery)
		if err != nil {
			return "", nil, err
		}
		return q.omniExprName(expr.Loc, ""), mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()), nil
	case *oracleast.CursorExpr:
		child := q.clone()
		child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)
		tableSource, err := child.extractOmniStmt(expr.Subquery)
		if err != nil {
			return "", nil, err
		}
		return q.omniExprName(expr.Loc, ""), mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()), nil
	default:
		name := q.omniExprName(getOmniExprFullLoc(expr), oracleast.NodeToString(expr))
		sourceColumns, err := q.extractOmniExprSourceColumns(expr)
		return name, sourceColumns, err
	}
}

func (q *omniQuerySpanExtractor) extractOmniExprSourceColumns(expr oracleast.ExprNode) (base.SourceColumnSet, error) {
	return q.extractOmniExprSourceColumnsWithResolver(expr, func(node *oracleast.ColumnRef) base.SourceColumnSet {
		return q.getOmniFieldColumnSource(node.Schema, node.Table, node.Column)
	})
}

func (q *omniQuerySpanExtractor) extractOmniExprSourceColumnsWithResolver(expr oracleast.ExprNode, resolveColumn func(*oracleast.ColumnRef) base.SourceColumnSet) (base.SourceColumnSet, error) {
	result := make(base.SourceColumnSet)
	var walkErr error
	oracleast.Inspect(expr, func(node oracleast.Node) bool {
		if walkErr != nil || node == nil {
			return false
		}
		switch node := node.(type) {
		case *oracleast.ColumnRef:
			if node.Column != "*" {
				result, _ = base.MergeSourceColumnSet(result, resolveColumn(node))
			}
			return false
		case *oracleast.FuncCallExpr:
			return true
		case *oracleast.SubqueryExpr:
			child := q.clone()
			child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)
			tableSource, err := child.extractOmniStmt(node.Subquery)
			if err != nil {
				walkErr = err
				return false
			}
			result, _ = base.MergeSourceColumnSet(result, mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()))
			return false
		case *oracleast.ExistsExpr:
			child := q.clone()
			child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)
			tableSource, err := child.extractOmniStmt(node.Subquery)
			if err != nil {
				walkErr = err
				return false
			}
			result, _ = base.MergeSourceColumnSet(result, mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()))
			return false
		case *oracleast.CursorExpr:
			child := q.clone()
			child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)
			tableSource, err := child.extractOmniStmt(node.Subquery)
			if err != nil {
				walkErr = err
				return false
			}
			result, _ = base.MergeSourceColumnSet(result, mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()))
			return false
		default:
			return true
		}
	})
	return result, walkErr
}

func (q *omniQuerySpanExtractor) getOmniFieldColumnSource(schemaName, tableName, columnName string) base.SourceColumnSet {
	findInTableSource := func(tableSource base.TableSource) (base.SourceColumnSet, bool) {
		if schemaName != "" && schemaName != tableSource.GetDatabaseName() {
			return nil, false
		}
		if tableName != "" && tableName != tableSource.GetTableName() {
			return nil, false
		}
		for _, field := range tableSource.GetQuerySpanResult() {
			if field.Name == columnName {
				return field.SourceColumns, true
			}
		}
		return nil, false
	}

	for _, tableSource := range q.tableSourcesFrom {
		if sourceColumnSet, ok := findInTableSource(tableSource); ok {
			return sourceColumnSet
		}
	}
	for i := len(q.outerTableSources) - 1; i >= 0; i-- {
		if sourceColumnSet, ok := findInTableSource(q.outerTableSources[i]); ok {
			return sourceColumnSet
		}
	}
	return base.SourceColumnSet{}
}

// expandOmniAsterisk returns the columns * stands for. It leaves out invisible
// columns, as Oracle does; including one would shift every result after it,
// and the masking applied to each.
func (q *omniQuerySpanExtractor) expandOmniAsterisk(schemaName, tableName string) ([]base.QuerySpanResult, error) {
	results, err := q.expandOmniAsteriskWithInvisible(schemaName, tableName)
	if err != nil {
		return nil, err
	}
	return slices.DeleteFunc(results, func(result base.QuerySpanResult) bool { return result.Invisible }), nil
}

func (q *omniQuerySpanExtractor) expandOmniAsteriskWithInvisible(schemaName, tableName string) ([]base.QuerySpanResult, error) {
	findInTableSource := func(tableSource base.TableSource) ([]base.QuerySpanResult, bool) {
		if schemaName != "" && schemaName != tableSource.GetDatabaseName() {
			return nil, false
		}
		if tableName != "" && tableName != tableSource.GetTableName() {
			return nil, false
		}
		return tableSource.GetQuerySpanResult(), true
	}

	if tableName == "" && schemaName == "" {
		if len(q.topLevelTableSourcesFrom) > 0 {
			return cloneQuerySpanResultsFromTableSources(q.topLevelTableSourcesFrom), nil
		}
		if len(q.tableSourcesFrom) > 0 {
			return cloneQuerySpanResultsFromTableSources(q.tableSourcesFrom), nil
		}
		if len(q.outerTableSources) > 0 {
			return cloneQuerySpanResults(q.outerTableSources[len(q.outerTableSources)-1].GetQuerySpanResult()), nil
		}
		return []base.QuerySpanResult{}, nil
	}

	for i := len(q.tableSourcesFrom) - 1; i >= 0; i-- {
		if results, ok := findInTableSource(q.tableSourcesFrom[i]); ok {
			return cloneQuerySpanResults(results), nil
		}
	}
	for i := len(q.outerTableSources) - 1; i >= 0; i-- {
		if results, ok := findInTableSource(q.outerTableSources[i]); ok {
			return cloneQuerySpanResults(results), nil
		}
	}
	return nil, errors.Errorf("failed to resolve asterisk for table %q", tableName)
}

func cloneQuerySpanResultsFromTableSources(tableSources []base.TableSource) []base.QuerySpanResult {
	var result []base.QuerySpanResult
	for _, tableSource := range tableSources {
		if tableSource == nil {
			continue
		}
		result = append(result, cloneQuerySpanResults(tableSource.GetQuerySpanResult())...)
	}
	return result
}

func (q *omniQuerySpanExtractor) extractOmniXMLTable(ref *oracleast.XmlTableRef) (base.TableSource, error) {
	_, sourceColumns, err := q.extractOmniExpr(ref.Passing)
	if err != nil {
		return nil, err
	}
	var columns []base.QuerySpanResult
	for _, node := range listItems(ref.Columns) {
		column, ok := node.(*oracleast.XmlTableColumn)
		if !ok {
			continue
		}
		columnSource := base.SourceColumnSet{}
		if !column.ForOrdinality {
			columnSource = sourceColumns
		}
		columns = append(columns, base.QuerySpanResult{
			Name:          column.Name,
			SourceColumns: columnSource,
			IsPlainField:  false,
		})
	}
	name := ""
	if ref.Alias != nil {
		name = ref.Alias.Name
	}
	return &base.PseudoTable{Name: name, Columns: columns}, nil
}

func (q *omniQuerySpanExtractor) extractOmniJSONTable(ref *oracleast.JsonTableRef) (base.TableSource, error) {
	_, sourceColumns, err := q.extractOmniExpr(ref.Expr)
	if err != nil {
		return nil, err
	}
	columns := extractOmniJSONTableColumns(ref.Columns, sourceColumns)
	name := ""
	if ref.Alias != nil {
		name = ref.Alias.Name
	}
	return &base.PseudoTable{Name: name, Columns: columns}, nil
}

func extractOmniJSONTableColumns(list *oracleast.List, sourceColumns base.SourceColumnSet) []base.QuerySpanResult {
	var columns []base.QuerySpanResult
	for _, node := range listItems(list) {
		column, ok := node.(*oracleast.JsonTableColumn)
		if !ok {
			continue
		}
		if column.Nested != nil {
			columns = append(columns, extractOmniJSONTableColumns(column.Nested.Columns, sourceColumns)...)
			continue
		}
		columnSource := sourceColumns
		if column.ForOrdinality {
			columnSource = base.SourceColumnSet{}
		}
		columns = append(columns, base.QuerySpanResult{
			Name:          column.Name,
			SourceColumns: columnSource,
			IsPlainField:  false,
		})
	}
	return columns
}

func extractOmniInlineExternalTable(ref *oracleast.InlineExternalTable) base.TableSource {
	var columns []base.QuerySpanResult
	for _, node := range listItems(ref.Columns) {
		column, ok := node.(*oracleast.ColumnDef)
		if !ok {
			continue
		}
		columns = append(columns, base.QuerySpanResult{
			Name:          column.Name,
			SourceColumns: base.SourceColumnSet{},
			IsPlainField:  false,
		})
	}
	name := ""
	if ref.Alias != nil {
		name = ref.Alias.Name
	}
	return &base.PseudoTable{Name: name, Columns: columns}
}

func aliasOmniTableSource(tableSource base.TableSource, alias *oracleast.Alias) base.TableSource {
	if tableSource == nil || alias == nil || alias.Name == "" {
		return tableSource
	}
	columns := cloneQuerySpanResults(tableSource.GetQuerySpanResult())
	applyOmniColumnAliases(columns, omniStringList(alias.Cols))
	return &base.PseudoTable{
		Name:    alias.Name,
		Columns: columns,
	}
}

func applyOmniColumnAliases(columns []base.QuerySpanResult, names []string) {
	for i, name := range names {
		if i >= len(columns) {
			return
		}
		columns[i].Name = name
	}
}

func cloneQuerySpanResult(result base.QuerySpanResult) base.QuerySpanResult {
	return base.QuerySpanResult{
		Name:          result.Name,
		SourceColumns: cloneSourceColumnSet(result.SourceColumns),
		IsPlainField:  result.IsPlainField,
		Invisible:     result.Invisible,
	}
}

func cloneQuerySpanResults(results []base.QuerySpanResult) []base.QuerySpanResult {
	cloned := make([]base.QuerySpanResult, 0, len(results))
	for _, result := range results {
		cloned = append(cloned, cloneQuerySpanResult(result))
	}
	return cloned
}

func cloneSourceColumnSet(source base.SourceColumnSet) base.SourceColumnSet {
	cloned := make(base.SourceColumnSet, len(source))
	for column := range source {
		cloned[column] = true
	}
	return cloned
}

func excludeSourceColumnNames(excluded map[string]bool, source base.SourceColumnSet) {
	for column := range source {
		if column.Column == "" {
			continue
		}
		excluded[column.Column] = true
		excluded[strings.ToUpper(column.Column)] = true
	}
}

func excludeOmniColumnRefNames(excluded map[string]bool, expr oracleast.ExprNode) {
	oracleast.Inspect(expr, func(node oracleast.Node) bool {
		columnRef, ok := node.(*oracleast.ColumnRef)
		if ok && columnRef.Schema == "" && columnRef.Table == "" && columnRef.Column != "*" {
			excluded[columnRef.Column] = true
			excluded[strings.ToUpper(columnRef.Column)] = true
		}
		return true
	})
}

func mergeSourceColumnsFromResults(results []base.QuerySpanResult) base.SourceColumnSet {
	merged := make(base.SourceColumnSet)
	for _, result := range results {
		merged, _ = base.MergeSourceColumnSet(merged, result.SourceColumns)
	}
	return merged
}

func querySpanResultsEqual(left, right []base.QuerySpanResult) bool {
	if len(left) != len(right) {
		return false
	}
	for i := range left {
		if left[i].Name != right[i].Name || left[i].IsPlainField != right[i].IsPlainField {
			return false
		}
		if !sourceColumnSetEqual(left[i].SourceColumns, right[i].SourceColumns) {
			return false
		}
	}
	return true
}

func sourceColumnSetEqual(left, right base.SourceColumnSet) bool {
	if len(left) != len(right) {
		return false
	}
	for column := range left {
		if !right[column] {
			return false
		}
	}
	return true
}

func listItems(list *oracleast.List) []oracleast.Node {
	if list == nil {
		return nil
	}
	return list.Items
}

func omniExprList(list *oracleast.List) []oracleast.ExprNode {
	var result []oracleast.ExprNode
	for _, node := range listItems(list) {
		expr, ok := node.(oracleast.ExprNode)
		if ok {
			result = append(result, expr)
		}
	}
	return result
}

func omniStringList(list *oracleast.List) []string {
	var result []string
	for _, node := range listItems(list) {
		switch node := node.(type) {
		case *oracleast.String:
			result = append(result, node.Str)
		case *oracleast.ColumnRef:
			result = append(result, node.Column)
		default:
		}
	}
	return result
}

func pivotInItemName(q *omniQuerySpanExtractor, item *oracleast.PivotInItem) string {
	if item == nil {
		return ""
	}
	if item.Alias != "" {
		return item.Alias
	}
	var parts []string
	for _, expr := range omniExprList(item.Values) {
		name, _, err := q.extractOmniExpr(expr)
		if err != nil {
			continue
		}
		if name != "" {
			parts = append(parts, name)
		}
	}
	return strings.Join(parts, "_")
}

func pivotColumnName(inName, aggregateAlias string, _ int) string {
	if aggregateAlias == "" {
		return inName
	}
	if inName == "" {
		return aggregateAlias
	}
	return inName + "_" + aggregateAlias
}

func isOmniStar(expr oracleast.ExprNode) bool {
	_, ok := expr.(*oracleast.Star)
	return ok
}

func splitOmniDBLink(dbLink string) []string {
	if dbLink == "" {
		return nil
	}
	return strings.Split(dbLink, ".")
}

func cloneTableSourceSlice(sources []base.TableSource) []base.TableSource {
	cloned := make([]base.TableSource, len(sources))
	copy(cloned, sources)
	return cloned
}

func (q *omniQuerySpanExtractor) omniExprName(loc oracleast.Loc, fallback string) string {
	if !loc.IsUnknown() && loc.Start >= 0 && loc.End <= len(q.source) && loc.Start < loc.End {
		return removeWhitespace(q.source[loc.Start:loc.End])
	}
	return removeWhitespace(fallback)
}

func removeWhitespace(s string) string {
	return strings.Map(func(r rune) rune {
		if unicode.IsSpace(r) {
			return -1
		}
		return r
	}, s)
}

func getOmniNodeLoc(node oracleast.Node) oracleast.Loc {
	value := reflect.ValueOf(node)
	if value.Kind() != reflect.Pointer || value.IsNil() {
		return oracleast.NoLoc()
	}
	elem := value.Elem()
	field := elem.FieldByName("Loc")
	if !field.IsValid() || !field.CanInterface() {
		return oracleast.NoLoc()
	}
	loc, ok := field.Interface().(oracleast.Loc)
	if !ok {
		return oracleast.NoLoc()
	}
	return loc
}

func getOmniExprFullLoc(expr oracleast.ExprNode) oracleast.Loc {
	switch expr := expr.(type) {
	case *oracleast.BinaryExpr:
		return mergeOmniLoc(getOmniExprFullLoc(expr.Left), getOmniExprFullLoc(expr.Right), getOmniNodeLoc(expr))
	case *oracleast.UnaryExpr:
		return mergeOmniLoc(getOmniNodeLoc(expr), getOmniExprFullLoc(expr.Operand))
	case *oracleast.BoolExpr:
		return mergeOmniListLoc(expr.Args, getOmniNodeLoc(expr))
	case *oracleast.FuncCallExpr:
		return getOmniNodeLoc(expr)
	case *oracleast.CaseExpr:
		return mergeOmniLoc(getOmniNodeLoc(expr), getOmniListLastLoc(expr.Whens), getOmniExprFullLoc(expr.Default))
	case *oracleast.CaseWhen:
		return mergeOmniLoc(getOmniNodeLoc(expr), getOmniExprFullLoc(expr.Condition), getOmniExprFullLoc(expr.Result))
	case *oracleast.DecodeExpr:
		return mergeOmniLoc(getOmniNodeLoc(expr), getOmniListLastLoc(expr.Pairs), getOmniExprFullLoc(expr.Default))
	case *oracleast.DecodePair:
		return mergeOmniLoc(getOmniExprFullLoc(expr.Search), getOmniExprFullLoc(expr.Result), getOmniNodeLoc(expr))
	case *oracleast.BetweenExpr:
		return mergeOmniLoc(getOmniExprFullLoc(expr.Expr), getOmniExprFullLoc(expr.Low), getOmniExprFullLoc(expr.High), getOmniNodeLoc(expr))
	case *oracleast.InExpr:
		return mergeOmniLoc(getOmniExprFullLoc(expr.Expr), getOmniNodeLoc(expr))
	case *oracleast.LikeExpr:
		return mergeOmniLoc(getOmniExprFullLoc(expr.Expr), getOmniExprFullLoc(expr.Pattern), getOmniExprFullLoc(expr.Escape), getOmniNodeLoc(expr))
	case *oracleast.IsExpr:
		return mergeOmniLoc(getOmniExprFullLoc(expr.Expr), getOmniNodeLoc(expr))
	case *oracleast.CastExpr:
		return mergeOmniLoc(getOmniNodeLoc(expr), getOmniExprFullLoc(expr.Arg))
	case *oracleast.MultisetExpr:
		return mergeOmniLoc(getOmniExprFullLoc(expr.Left), getOmniExprFullLoc(expr.Right), getOmniNodeLoc(expr))
	case *oracleast.CursorExpr:
		return getOmniNodeLoc(expr)
	case *oracleast.TreatExpr:
		return mergeOmniLoc(getOmniNodeLoc(expr), getOmniExprFullLoc(expr.Expr))
	case *oracleast.ParenExpr:
		return mergeOmniLoc(getOmniNodeLoc(expr), getOmniExprFullLoc(expr.Expr))
	default:
		return getOmniNodeLoc(expr)
	}
}

func mergeOmniListLoc(list *oracleast.List, fallback oracleast.Loc) oracleast.Loc {
	loc := fallback
	for _, node := range listItems(list) {
		loc = mergeOmniLoc(loc, getOmniNodeLoc(node))
	}
	return loc
}

func getOmniListLastLoc(list *oracleast.List) oracleast.Loc {
	var loc oracleast.Loc
	for _, node := range listItems(list) {
		loc = mergeOmniLoc(loc, getOmniNodeLoc(node))
	}
	return loc
}

func mergeOmniLoc(locs ...oracleast.Loc) oracleast.Loc {
	result := oracleast.NoLoc()
	for _, loc := range locs {
		if loc.IsUnknown() || loc.Start < 0 || loc.End < loc.Start {
			continue
		}
		if result.IsUnknown() || loc.Start < result.Start {
			result.Start = loc.Start
		}
		if result.IsUnknown() || loc.End > result.End {
			result.End = loc.End
		}
	}
	return result
}