Method transformSelectStmt

transpiler/transform/operators.go:81–190

(stmt *pg_query.SelectStmt)

}

func (t *OperatorTransform) transformSelectStmt(stmt *pg_query.SelectStmt) bool {
	if stmt == nil {
		return false
	}

	changed := false

	// Transform target list
	for _, target := range stmt.TargetList {
		if resTarget := target.GetResTarget(); resTarget != nil && resTarget.Val != nil {
			if newVal := t.transformExpression(resTarget.Val); newVal != nil {
				resTarget.Val = newVal
				changed = true
			}
		}
	}

	// Transform WHERE clause
	if stmt.WhereClause != nil {
		if newWhere := t.transformExpression(stmt.WhereClause); newWhere != nil {
			stmt.WhereClause = newWhere
			changed = true
		}
	}

	// Transform HAVING clause
	if stmt.HavingClause != nil {
		if newHaving := t.transformExpression(stmt.HavingClause); newHaving != nil {
			stmt.HavingClause = newHaving
			changed = true
		}
	}

	// Transform VALUES lists (e.g. INSERT INTO t VALUES ('abc' ~ 'b'))
	for _, valuesList := range stmt.ValuesLists {
		if list := valuesList.GetList(); list != nil {
			for i, item := range list.Items {
				if newItem := t.transformExpression(item); newItem != nil {
					list.Items[i] = newItem
					changed = true
				}
			}
		}
	}

	// Transform DISTINCT ON expressions. Plain DISTINCT is represented as a
	// single empty node, which transformExpression leaves untouched.
	for i, distinct := range stmt.DistinctClause {
		if newDistinct := t.transformExpression(distinct); newDistinct != nil {
			stmt.DistinctClause[i] = newDistinct
			changed = true
		}
	}

	// Transform GROUP BY expressions (e.g. GROUP BY data->>'type')
	for i, group := range stmt.GroupClause {
		if newGroup := t.transformExpression(group); newGroup != nil {
			stmt.GroupClause[i] = newGroup