snapshot of https://github.com/sqlc-dev/sqlc.git (main, 2026-09-16; blobs > 131072B omitted)

internal/engine/googlesql/catalog.go

@@ -0,0 +1,16 @@
+package googlesql
+
+import (
+	"github.com/sqlc-dev/sqlc/internal/sql/catalog"
+)
+
+func NewCatalog() *catalog.Catalog {
+	def := "main" // GoogleSQL has no implicit schema; use "main" as the default
+	return &catalog.Catalog{
+		DefaultSchema: def,
+		Schemas: []*catalog.Schema{
+			defaultSchema(def),
+		},
+		Extensions: map[string]struct{}{},
+	}
+}

internal/engine/googlesql/convert.go

@@ -0,0 +1,977 @@
+package googlesql
+
+import (
+	"strconv"
+	"strings"
+
+	zjast "github.com/sqlc-dev/zetajones/ast"
+
+	"github.com/sqlc-dev/sqlc/internal/sql/ast"
+)
+
+type cc struct {
+	paramCount int
+	// namedParams tracks the number assigned to each "@name" so repeated uses
+	// share a single parameter.
+	namedParams map[string]int
+}
+
+func (c *cc) convert(node zjast.Node) ast.Node {
+	switch n := node.(type) {
+	case *zjast.QueryStatement:
+		return c.convertQuery(n.Query)
+	case *zjast.InsertStatement:
+		return c.convertInsertStatement(n)
+	case *zjast.UpdateStatement:
+		return c.convertUpdateStatement(n)
+	case *zjast.DeleteStatement:
+		return c.convertDeleteStatement(n)
+	case *zjast.CreateTableStatement:
+		return c.convertCreateTableStatement(n)
+	case *zjast.DropStatement:
+		return c.convertDropStatement(n)
+	case *zjast.TruncateStatement:
+		return c.convertTruncateStatement(n)
+	case *zjast.HintedStatement:
+		if n.Statement == nil {
+			return todo(n)
+		}
+		return c.convert(n.Statement)
+	default:
+		return todo(n)
+	}
+}
+
+func (c *cc) convertQuery(n *zjast.Query) ast.Node {
+	if n == nil {
+		return todo(n)
+	}
+	// Pipe operators (|>) have no sqlc AST equivalent.
+	if len(n.PipeOperators) > 0 {
+		return todo(n)
+	}
+	node := c.convertQueryExpr(n.QueryExpr)
+	stmt, ok := node.(*ast.SelectStmt)
+	if !ok {
+		return node
+	}
+	if n.WithClause != nil {
+		stmt.WithClause = c.convertWithClause(n.WithClause)
+	}
+	if n.OrderBy != nil {
+		stmt.SortClause = c.convertOrderBy(n.OrderBy)
+	}
+	if n.Limit != nil {
+		if n.Limit.Limit != nil {
+			if _, all := n.Limit.Limit.Expr.(*zjast.LimitAll); !all {
+				stmt.LimitCount = c.convertExpr(n.Limit.Limit.Expr)
+			}
+		}
+		if n.Limit.Offset != nil {
+			stmt.LimitOffset = c.convertExpr(n.Limit.Offset)
+		}
+	}
+	return stmt
+}
+
+func (c *cc) convertQueryExpr(node zjast.Node) ast.Node {
+	switch n := node.(type) {
+	case *zjast.Select:
+		return c.convertSelect(n)
+	case *zjast.SetOperation:
+		return c.convertSetOperation(n)
+	case *zjast.Query:
+		// Parenthesized query.
+		return c.convertQuery(n)
+	case *zjast.AliasedQueryExpression:
+		return c.convertQuery(n.Query)
+	default:
+		return todo(n)
+	}
+}
+
+func (c *cc) convertSetOperation(n *zjast.SetOperation) ast.Node {
+	if len(n.Inputs) == 0 {
+		return todo(n)
+	}
+	var entries []*zjast.SetOperationMetadata
+	if n.Metadata != nil {
+		entries = n.Metadata.Entries
+	}
+	result, ok := c.convertQueryExpr(n.Inputs[0]).(*ast.SelectStmt)
+	if !ok {
+		return todo(n)
+	}
+	for i, input := range n.Inputs[1:] {
+		rarg, ok := c.convertQueryExpr(input).(*ast.SelectStmt)
+		if !ok {
+			return todo(n)
+		}
+		op := ast.Union
+		all := false
+		if i < len(entries) && entries[i] != nil {
+			meta := entries[i]
+			if meta.OpType != nil {
+				switch strings.ToUpper(meta.OpType.Op) {
+				case "UNION":
+					op = ast.Union
+				case "INTERSECT":
+					op = ast.Intersect
+				case "EXCEPT":
+					op = ast.Except
+				}
+			}
+			if meta.AllOrDistinct != nil {
+				all = strings.ToUpper(meta.AllOrDistinct.Value) == "ALL"
+			}
+		}
+		result = &ast.SelectStmt{
+			Op:   op,
+			All:  all,
+			Larg: result,
+			Rarg: rarg,
+		}
+	}
+	return result
+}
+
+func (c *cc) convertSelect(n *zjast.Select) *ast.SelectStmt {
+	stmt := &ast.SelectStmt{}
+
+	if n.SelectList != nil {
+		stmt.TargetList = &ast.List{}
+		for _, col := range n.SelectList.Columns {
+			if col == nil {
+				continue
+			}
+			stmt.TargetList.Items = append(stmt.TargetList.Items, c.convertSelectColumn(col))
+		}
+	}
+
+	if n.From != nil {
+		stmt.FromClause = &ast.List{
+			Items: []ast.Node{c.convertTableExpr(n.From.TableExpression)},
+		}
+	}
+
+	if n.Where != nil {
+		stmt.WhereClause = c.convertExpr(n.Where.Expr)
+	}
+
+	if n.GroupBy != nil {
+		stmt.GroupClause = &ast.List{}
+		for _, item := range n.GroupBy.Items {
+			if item == nil {
+				continue
+			}
+			if item.Expr != nil {
+				stmt.GroupClause.Items = append(stmt.GroupClause.Items, c.convertExpr(item.Expr))
+			} else {
+				// ROLLUP, CUBE, GROUPING SETS, or the empty grouping item.
+				stmt.GroupClause.Items = append(stmt.GroupClause.Items, todo(item))
+			}
+		}
+	}
+
+	if n.Having != nil {
+		stmt.HavingClause = c.convertExpr(n.Having.Expr)
+	}
+
+	if n.Distinct {
+		stmt.DistinctClause = &ast.List{}
+	}
+
+	return stmt
+}
+
+func (c *cc) convertSelectColumn(n *zjast.SelectColumn) *ast.ResTarget {
+	res := &ast.ResTarget{
+		Location: n.Pos(),
+	}
+	if n.Alias != nil && n.Alias.Identifier != nil {
+		name := identifier(n.Alias.Identifier.Name)
+		res.Name = &name
+	}
+	res.Val = c.convertExpr(n.Expr)
+	return res
+}
+
+func (c *cc) convertTableExpr(node zjast.Node) ast.Node {
+	switch n := node.(type) {
+	case *zjast.TablePathExpression:
+		return c.convertTablePathExpression(n)
+	case *zjast.TableSubquery:
+		if len(n.PostfixOperators) > 0 {
+			return todo(n)
+		}
+		return &ast.RangeSubselect{
+			Lateral:  n.IsLateral,
+			Subquery: c.convertQuery(n.Query),
+			Alias:    convertAlias(n.Alias),
+		}
+	case *zjast.Join:
+		return c.convertJoin(n)
+	case *zjast.ParenthesizedJoin:
+		if len(n.PostfixOperators) > 0 {
+			return todo(n)
+		}
+		return c.convertTableExpr(n.Join)
+	case *zjast.TVF:
+		return c.convertTVF(n)
+	default:
+		return todo(n)
+	}
+}
+
+func (c *cc) convertTablePathExpression(n *zjast.TablePathExpression) ast.Node {
+	if len(n.PostfixOperators) > 0 {
+		return todo(n)
+	}
+	if n.UnnestExpr != nil {
+		return &ast.RangeFunction{
+			Functions: &ast.List{
+				Items: []ast.Node{c.convertUnnestExpression(n.UnnestExpr)},
+			},
+			Alias: convertAlias(n.Alias),
+		}
+	}
+	rv := parseRangeVar(n.Path)
+	rv.Alias = convertAlias(n.Alias)
+	return rv
+}
+
+func (c *cc) convertUnnestExpression(n *zjast.UnnestExpression) *ast.FuncCall {
+	fc := &ast.FuncCall{
+		Func:     &ast.FuncName{Name: "unnest"},
+		Funcname: &ast.List{Items: []ast.Node{&ast.String{Str: "unnest"}}},
+		Args:     &ast.List{},
+		Location: n.Pos(),
+	}
+	for _, e := range n.Expressions {
+		if e == nil {
+			continue
+		}
+		fc.Args.Items = append(fc.Args.Items, c.convertExpr(e.Expr))
+	}
+	return fc
+}
+
+func (c *cc) convertTVF(n *zjast.TVF) ast.Node {
+	if len(n.PostfixOperators) > 0 {
+		return todo(n)
+	}
+	parts := pathParts(n.Name)
+	if len(parts) == 0 {
+		return todo(n)
+	}
+	fc := c.newFuncCall(parts, n.Pos())
+	for _, arg := range n.Args {
+		if arg == nil || arg.Expr == nil {
+			continue
+		}
+		fc.Args.Items = append(fc.Args.Items, c.convertExpr(arg.Expr))
+	}
+	return &ast.RangeFunction{
+		Functions: &ast.List{Items: []ast.Node{fc}},
+		Alias:     convertAlias(n.Alias),
+	}
+}
+
+func (c *cc) convertJoin(n *zjast.Join) ast.Node {
+	join := &ast.JoinExpr{
+		Larg:      c.convertTableExpr(n.Lhs),
+		Rarg:      c.convertTableExpr(n.Rhs),
+		IsNatural: n.Natural,
+	}
+
+	switch strings.ToUpper(n.JoinType) {
+	case "", "INNER", "CROSS", "COMMA":
+		join.Jointype = ast.JoinTypeInner
+	case "LEFT":
+		join.Jointype = ast.JoinTypeLeft
+	case "RIGHT":
+		join.Jointype = ast.JoinTypeRight
+	case "FULL":
+		join.Jointype = ast.JoinTypeFull
+	default:
+		join.Jointype = ast.JoinTypeInner
+	}
+
+	switch clause := n.OnOrUsingClause.(type) {
+	case *zjast.OnClause:
+		join.Quals = c.convertExpr(clause.Expr)
+	case *zjast.UsingClause:
+		join.UsingClause = &ast.List{}
+		for _, key := range clause.Keys {
+			if key == nil {
+				continue
+			}
+			join.UsingClause.Items = append(join.UsingClause.Items, NewIdentifier(key.Name))
+		}
+	}
+
+	return join
+}
+
+func (c *cc) convertWithClause(n *zjast.WithClause) *ast.WithClause {
+	wc := &ast.WithClause{
+		Recursive: n.Recursive,
+		Ctes:      &ast.List{},
+		Location:  n.Pos(),
+	}
+	for _, entry := range n.Entries {
+		if entry == nil || entry.AliasedQuery == nil {
+			// "name() AS GROUP ROWS" entries are not supported.
+			continue
+		}
+		aq := entry.AliasedQuery
+		cte := &ast.CommonTableExpr{
+			Location: aq.Pos(),
+			Ctequery: c.convertQuery(aq.Query),
+		}
+		if aq.Identifier != nil {
+			name := identifier(aq.Identifier.Name)
+			cte.Ctename = &name
+		}
+		wc.Ctes.Items = append(wc.Ctes.Items, cte)
+	}
+	return wc
+}
+
+func (c *cc) convertOrderBy(n *zjast.OrderBy) *ast.List {
+	list := &ast.List{}
+	for _, item := range n.Items {
+		if item == nil {
+			continue
+		}
+		sortBy := &ast.SortBy{
+			Node:     c.convertExpr(item.Expr),
+			Location: item.Pos(),
+		}
+		switch {
+		case item.Descending:
+			sortBy.SortbyDir = ast.SortByDirDesc
+		case item.HasAsc:
+			sortBy.SortbyDir = ast.SortByDirAsc
+		default:
+			sortBy.SortbyDir = ast.SortByDirDefault
+		}
+		if item.NullOrder != nil {
+			if item.NullOrder.NullsFirst {
+				sortBy.SortbyNulls = ast.SortByNullsFirst
+			} else {
+				sortBy.SortbyNulls = ast.SortByNullsLast
+			}
+		}
+		list.Items = append(list.Items, sortBy)
+	}
+	return list
+}
+
+func (c *cc) convertExpr(node zjast.Node) ast.Node {
+	if node == nil {
+		return nil
+	}
+	switch n := node.(type) {
+	case *zjast.Identifier:
+		return &ast.ColumnRef{
+			Fields:   &ast.List{Items: []ast.Node{NewIdentifier(n.Name)}},
+			Location: n.Pos(),
+		}
+	case *zjast.PathExpression:
+		return c.convertPathExpression(n)
+	case *zjast.DotIdentifier:
+		if fields, ok := columnRefFields(n); ok {
+			return &ast.ColumnRef{
+				Fields:   &ast.List{Items: fields},
+				Location: n.Pos(),
+			}
+		}
+		return todo(n)
+	case *zjast.IntLiteral:
+		return c.convertIntLiteral(n)
+	case *zjast.FloatLiteral:
+		return &ast.A_Const{
+			Val:      &ast.Float{Str: n.Image},
+			Location: n.Pos(),
+		}
+	case *zjast.StringLiteral:
+		return &ast.A_Const{
+			Val:      &ast.String{Str: stringLiteralValue(n)},
+			Location: n.Pos(),
+		}
+	case *zjast.BooleanLiteral:
+		return &ast.A_Const{
+			Val:      &ast.Boolean{Boolval: n.Value},
+			Location: n.Pos(),
+		}
+	case *zjast.NullLiteral:
+		return &ast.A_Const{
+			Val:      &ast.Null{},
+			Location: n.Pos(),
+		}
+	case *zjast.ParameterExpr:
+		return c.convertParameterExpr(n)
+	case *zjast.UnaryExpression:
+		return c.convertUnaryExpression(n)
+	case *zjast.BinaryExpression:
+		return c.convertBinaryExpression(n)
+	case *zjast.BitwiseShiftExpression:
+		op := ">>"
+		if n.IsLeftShift {
+			op = "<<"
+		}
+		return &ast.A_Expr{
+			Kind:     ast.A_Expr_Kind_OP,
+			Name:     &ast.List{Items: []ast.Node{&ast.String{Str: op}}},
+			Lexpr:    c.convertExpr(n.Lhs),
+			Rexpr:    c.convertExpr(n.Rhs),
+			Location: n.Pos(),
+		}
+	case *zjast.AndExpr:
+		return c.convertBoolExpr(ast.BoolExprTypeAnd, n.Conjuncts, n.Pos())
+	case *zjast.OrExpr:
+		return c.convertBoolExpr(ast.BoolExprTypeOr, n.Disjuncts, n.Pos())
+	case *zjast.BetweenExpression:
+		return &ast.BetweenExpr{
+			Expr:     c.convertExpr(n.Lhs),
+			Left:     c.convertExpr(n.Low),
+			Right:    c.convertExpr(n.High),
+			Not:      n.IsNot,
+			Location: n.Pos(),
+		}
+	case *zjast.InExpression:
+		return c.convertInExpression(n)
+	case *zjast.CaseValueExpression:
+		if len(n.Arguments) == 0 {
+			return todo(n)
+		}
+		return c.buildCaseExpr(c.convertExpr(n.Arguments[0]), n.Arguments[1:], n.Pos())
+	case *zjast.CaseNoValueExpression:
+		return c.buildCaseExpr(nil, n.Arguments, n.Pos())
+	case *zjast.CastExpression:
+		return &ast.TypeCast{
+			Arg:      c.convertExpr(n.Expr),
+			TypeName: spelledTypeName(typeName(n.Type)),
+			Location: n.Pos(),
+		}
+	case *zjast.ExpressionSubquery:
+		return c.convertExpressionSubquery(n)
+	case *zjast.FunctionCall:
+		return c.convertFunctionCall(n)
+	case *zjast.AnalyticFunctionCall:
+		return c.convertAnalyticFunctionCall(n)
+	case *zjast.Star:
+		return &ast.ColumnRef{
+			Fields:   &ast.List{Items: []ast.Node{&ast.A_Star{}}},
+			Location: n.Pos(),
+		}
+	case *zjast.DotStar:
+		return c.convertDotStar(n)
+	case *zjast.ArrayElement:
+		return &ast.A_Indirection{
+			Arg: c.convertExpr(n.Array),
+			Indirection: &ast.List{
+				Items: []ast.Node{
+					&ast.A_Indices{Uidx: c.convertExpr(n.Position)},
+				},
+			},
+		}
+	case *zjast.NamedArgument:
+		return c.convertExpr(n.Value)
+	case *zjast.ExpressionWithAlias:
+		return c.convertExpr(n.Expression)
+	default:
+		return todo(n)
+	}
+}
+
+func (c *cc) convertPathExpression(n *zjast.PathExpression) ast.Node {
+	fields, ok := columnRefFields(n)
+	if !ok {
+		return todo(n)
+	}
+	return &ast.ColumnRef{
+		Fields:   &ast.List{Items: fields},
+		Location: n.Pos(),
+	}
+}
+
+func (c *cc) convertIntLiteral(n *zjast.IntLiteral) ast.Node {
+	// Base 0 also accepts hexadecimal literals (0x1a).
+	ival, err := strconv.ParseInt(n.Image, 0, 64)
+	if err != nil {
+		return &ast.A_Const{
+			Val:      &ast.Float{Str: n.Image},
+			Location: n.Pos(),
+		}
+	}
+	return &ast.A_Const{
+		Val:      &ast.Integer{Ival: ival},
+		Location: n.Pos(),
+	}
+}
+
+// convertParameterExpr converts "@name" and "?" query parameters.
+//
+// Both become ParamRef nodes. "@name" is native GoogleSQL syntax rather than
+// sqlc syntax, so nothing rewrites it before the parser runs and the numbering
+// here is what the rest of the pipeline sees: repeated uses of a name share a
+// number, and positional parameters are numbered by their 1-based position in
+// the statement.
+func (c *cc) convertParameterExpr(n *zjast.ParameterExpr) ast.Node {
+	if n.Name != nil {
+		number, ok := c.namedParams[n.Name.Name]
+		if !ok {
+			c.paramCount++
+			number = c.paramCount
+			if c.namedParams == nil {
+				c.namedParams = map[string]int{}
+			}
+			c.namedParams[n.Name.Name] = number
+		}
+		return &ast.ParamRef{
+			Number:   number,
+			Location: n.Pos(),
+		}
+	}
+	c.paramCount++
+	number := n.Position
+	if number == 0 {
+		number = c.paramCount
+	}
+	return &ast.ParamRef{
+		Number:   number,
+		Location: n.Pos(),
+	}
+}
+
+func (c *cc) convertUnaryExpression(n *zjast.UnaryExpression) ast.Node {
+	if strings.ToUpper(n.Op) == "NOT" {
+		return &ast.BoolExpr{
+			Boolop: ast.BoolExprTypeNot,
+			Args: &ast.List{
+				Items: []ast.Node{c.convertExpr(n.Operand)},
+			},
+			Location: n.Pos(),
+		}
+	}
+	return &ast.A_Expr{
+		Kind:     ast.A_Expr_Kind_OP,
+		Name:     &ast.List{Items: []ast.Node{&ast.String{Str: n.Op}}},
+		Rexpr:    c.convertExpr(n.Operand),
+		Location: n.Pos(),
+	}
+}
+
+func (c *cc) convertBinaryExpression(n *zjast.BinaryExpression) ast.Node {
+	// "x IS NULL" and "x IS NOT NULL" become NullTest nodes.
+	if strings.ToUpper(n.Op) == "IS" {
+		if _, isNull := n.Right.(*zjast.NullLiteral); isNull {
+			nullTest := &ast.NullTest{
+				Arg:      c.convertExpr(n.Left),
+				Location: n.Pos(),
+			}
+			if n.IsNot {
+				nullTest.Nulltesttype = ast.NullTestTypeIsNotNull
+			} else {
+				nullTest.Nulltesttype = ast.NullTestTypeIsNull
+			}
+			return nullTest
+		}
+	}
+
+	var expr ast.Node = &ast.A_Expr{
+		Kind:     ast.A_Expr_Kind_OP,
+		Name:     &ast.List{Items: []ast.Node{&ast.String{Str: n.Op}}},
+		Lexpr:    c.convertExpr(n.Left),
+		Rexpr:    c.convertExpr(n.Right),
+		Location: n.Pos(),
+	}
+	if n.IsNot {
+		// "a NOT LIKE b", "a IS NOT b", etc: wrap the comparison in a NOT.
+		expr = &ast.BoolExpr{
+			Boolop:   ast.BoolExprTypeNot,
+			Args:     &ast.List{Items: []ast.Node{expr}},
+			Location: n.Pos(),
+		}
+	}
+	return expr
+}
+
+func (c *cc) convertBoolExpr(op ast.BoolExprType, operands []zjast.Node, loc int) *ast.BoolExpr {
+	expr := &ast.BoolExpr{
+		Boolop:   op,
+		Args:     &ast.List{},
+		Location: loc,
+	}
+	for _, operand := range operands {
+		expr.Args.Items = append(expr.Args.Items, c.convertExpr(operand))
+	}
+	return expr
+}
+
+func (c *cc) convertInExpression(n *zjast.InExpression) ast.Node {
+	in := &ast.In{
+		Expr:     c.convertExpr(n.Lhs),
+		Not:      n.IsNot,
+		Location: n.Pos(),
+	}
+	if n.List != nil {
+		for _, expr := range n.List.Exprs {
+			in.List = append(in.List, c.convertExpr(expr))
+		}
+	}
+	if n.UnnestExpr != nil {
+		in.List = append(in.List, c.convertUnnestExpression(n.UnnestExpr))
+	}
+	if n.Query != nil {
+		in.Sel = c.convertQuery(n.Query)
+	}
+	return in
+}
+
+// buildCaseExpr builds a CaseExpr from the alternating WHEN/THEN expression
+// pairs (and optional trailing ELSE expression) of a zetajones CASE node.
+func (c *cc) buildCaseExpr(arg ast.Node, rest []zjast.Node, loc int) *ast.CaseExpr {
+	caseExpr := &ast.CaseExpr{
+		Arg:      arg,
+		Args:     &ast.List{},
+		Location: loc,
+	}
+	i := 0
+	for ; i+1 < len(rest); i += 2 {
+		caseExpr.Args.Items = append(caseExpr.Args.Items, &ast.CaseWhen{
+			Expr:   c.convertExpr(rest[i]),
+			Result: c.convertExpr(rest[i+1]),
+		})
+	}
+	if i < len(rest) {
+		caseExpr.Defresult = c.convertExpr(rest[i])
+	}
+	return caseExpr
+}
+
+func (c *cc) convertExpressionSubquery(n *zjast.ExpressionSubquery) *ast.SubLink {
+	subLink := &ast.SubLink{
+		Subselect: c.convertQuery(n.Query),
+		Location:  n.Pos(),
+	}
+	switch strings.ToUpper(n.Modifier) {
+	case "EXISTS":
+		subLink.SubLinkType = ast.EXISTS_SUBLINK
+	case "ARRAY":
+		subLink.SubLinkType = ast.ARRAY_SUBLINK
+	default:
+		subLink.SubLinkType = ast.EXPR_SUBLINK
+	}
+	return subLink
+}
+
+// newFuncCall builds a FuncCall from a dotted function path. GoogleSQL
+// function names are case-insensitive, so they are lowercased.
+func (c *cc) newFuncCall(parts []string, loc int) *ast.FuncCall {
+	name := strings.ToLower(parts[len(parts)-1])
+	var schema string
+	if len(parts) > 1 {
+		schema = strings.ToLower(strings.Join(parts[:len(parts)-1], "."))
+	}
+	items := []ast.Node{}
+	if schema != "" {
+		items = append(items, &ast.String{Str: schema})
+	}
+	items = append(items, &ast.String{Str: name})
+	return &ast.FuncCall{
+		Func:     &ast.FuncName{Schema: schema, Name: name},
+		Funcname: &ast.List{Items: items},
+		Args:     &ast.List{},
+		Location: loc,
+	}
+}
+
+func (c *cc) convertFunctionCall(n *zjast.FunctionCall) ast.Node {
+	// Chained calls ("expr.method(...)") have no sqlc AST equivalent.
+	if n.IsChained {
+		return todo(n)
+	}
+	parts := pathParts(n.Function)
+	if len(parts) == 0 {
+		return todo(n)
+	}
+	fc := c.newFuncCall(parts, n.Pos())
+	fc.AggDistinct = n.Distinct
+	for _, arg := range n.Args {
+		if _, ok := arg.(*zjast.Star); ok {
+			fc.AggStar = true
+			continue
+		}
+		fc.Args.Items = append(fc.Args.Items, c.convertExpr(arg))
+	}
+	if n.OrderBy != nil {
+		fc.AggOrder = c.convertOrderBy(n.OrderBy)
+	}
+	return fc
+}
+
+func (c *cc) convertAnalyticFunctionCall(n *zjast.AnalyticFunctionCall) ast.Node {
+	base := c.convertExpr(n.Expr)
+	fc, ok := base.(*ast.FuncCall)
+	if !ok {
+		return base
+	}
+	over := &ast.WindowDef{Location: n.Pos()}
+	if spec := n.WindowSpec; spec != nil {
+		if spec.Name != nil {
+			name := identifier(spec.Name.Name)
+			over.Name = &name
+		}
+		if spec.PartitionBy != nil {
+			over.PartitionClause = &ast.List{}
+			for _, expr := range spec.PartitionBy.Expressions {
+				over.PartitionClause.Items = append(over.PartitionClause.Items, c.convertExpr(expr))
+			}
+		}
+		if spec.OrderBy != nil {
+			over.OrderClause = c.convertOrderBy(spec.OrderBy)
+		}
+	}
+	fc.Over = over
+	return fc
+}
+
+func (c *cc) convertDotStar(n *zjast.DotStar) ast.Node {
+	fields, ok := columnRefFields(n.Expr)
+	if !ok {
+		return todo(n)
+	}
+	fields = append(fields, &ast.A_Star{})
+	return &ast.ColumnRef{
+		Fields:   &ast.List{Items: fields},
+		Location: n.Pos(),
+	}
+}
+
+// targetPath extracts the table path of an INSERT/UPDATE/DELETE target.
+func targetPath(node zjast.Node) (*zjast.PathExpression, bool) {
+	path, ok := node.(*zjast.PathExpression)
+	return path, ok && path != nil
+}
+
+func (c *cc) convertInsertStatement(n *zjast.InsertStatement) ast.Node {
+	path, ok := targetPath(n.Target)
+	if !ok {
+		return todo(n)
+	}
+	stmt := &ast.InsertStmt{
+		Relation: parseRangeVar(path),
+	}
+
+	if n.Columns != nil {
+		stmt.Cols = &ast.List{}
+		for _, col := range n.Columns.Identifiers {
+			if col == nil {
+				continue
+			}
+			name := identifier(col.Name)
+			stmt.Cols.Items = append(stmt.Cols.Items, &ast.ResTarget{
+				Name:     &name,
+				Location: col.Pos(),
+			})
+		}
+	}
+
+	switch {
+	case n.Rows != nil:
+		selectStmt := &ast.SelectStmt{
+			ValuesLists: &ast.List{},
+		}
+		for _, row := range n.Rows.Rows {
+			if row == nil {
+				continue
+			}
+			rowList := &ast.List{}
+			for _, val := range row.Values {
+				rowList.Items = append(rowList.Items, c.convertExpr(val))
+			}
+			selectStmt.ValuesLists.Items = append(selectStmt.ValuesLists.Items, rowList)
+		}
+		stmt.SelectStmt = selectStmt
+	case n.Query != nil:
+		stmt.SelectStmt = c.convertQuery(n.Query)
+	}
+
+	if n.Returning != nil {
+		stmt.ReturningList = c.convertReturningClause(n.Returning)
+	}
+
+	return stmt
+}
+
+// convertReturningClause converts a "THEN RETURN" clause to a returning list.
+func (c *cc) convertReturningClause(n *zjast.ReturningClause) *ast.List {
+	list := &ast.List{}
+	if n.SelectList != nil {
+		for _, col := range n.SelectList.Columns {
+			if col == nil {
+				continue
+			}
+			list.Items = append(list.Items, c.convertSelectColumn(col))
+		}
+	}
+	return list
+}
+
+func (c *cc) convertUpdateStatement(n *zjast.UpdateStatement) ast.Node {
+	path, ok := targetPath(n.Target)
+	if !ok {
+		return todo(n)
+	}
+	rv := parseRangeVar(path)
+	rv.Alias = convertAlias(n.Alias)
+	stmt := &ast.UpdateStmt{
+		Relations:  &ast.List{Items: []ast.Node{rv}},
+		TargetList: &ast.List{},
+	}
+
+	if n.UpdateItemList != nil {
+		for _, item := range n.UpdateItemList.Items {
+			if item == nil || item.SetValue == nil {
+				// Nested INSERT/UPDATE/DELETE update items are unsupported.
+				continue
+			}
+			stmt.TargetList.Items = append(stmt.TargetList.Items, c.convertUpdateSetValue(item.SetValue))
+		}
+	}
+
+	if n.From != nil {
+		stmt.FromClause = &ast.List{
+			Items: []ast.Node{c.convertTableExpr(n.From.TableExpression)},
+		}
+	}
+
+	if n.Where != nil {
+		stmt.WhereClause = c.convertExpr(whereExpr(n.Where))
+	}
+
+	if n.Returning != nil {
+		stmt.ReturningList = c.convertReturningClause(n.Returning)
+	}
+
+	return stmt
+}
+
+func (c *cc) convertUpdateSetValue(n *zjast.UpdateSetValue) *ast.ResTarget {
+	res := &ast.ResTarget{
+		Val:      c.convertExpr(n.Value),
+		Location: n.Pos(),
+	}
+	if path, ok := n.Path.(*zjast.PathExpression); ok {
+		if parts := pathParts(path); len(parts) > 0 {
+			name := identifier(parts[len(parts)-1])
+			res.Name = &name
+		}
+	}
+	return res
+}
+
+func (c *cc) convertDeleteStatement(n *zjast.DeleteStatement) ast.Node {
+	path, ok := targetPath(n.Target)
+	if !ok {
+		return todo(n)
+	}
+	rv := parseRangeVar(path)
+	rv.Alias = convertAlias(n.Alias)
+	stmt := &ast.DeleteStmt{
+		Relations: &ast.List{Items: []ast.Node{rv}},
+	}
+
+	if n.Where != nil {
+		stmt.WhereClause = c.convertExpr(whereExpr(n.Where))
+	}
+
+	if n.Returning != nil {
+		stmt.ReturningList = c.convertReturningClause(n.Returning)
+	}
+
+	return stmt
+}
+
+func (c *cc) convertCreateTableStatement(n *zjast.CreateTableStatement) ast.Node {
+	stmt := &ast.CreateTableStmt{
+		Name:        parseTableName(n.Name),
+		IfNotExists: n.IsIfNotExists,
+	}
+	if n.TableElementList != nil {
+		for _, elem := range n.TableElementList.Elements {
+			col, ok := elem.(*zjast.ColumnDefinition)
+			if !ok {
+				// Table-level PRIMARY KEY, FOREIGN KEY, and CHECK
+				// constraints are skipped.
+				continue
+			}
+			stmt.Cols = append(stmt.Cols, c.convertColumnDefinition(col))
+		}
+	}
+	return stmt
+}
+
+func (c *cc) convertColumnDefinition(n *zjast.ColumnDefinition) *ast.ColumnDef {
+	col := &ast.ColumnDef{
+		Location: n.Pos(),
+		TypeName: spelledTypeName(columnSchemaTypeName(n.Schema)),
+	}
+	if n.Name != nil {
+		col.Colname = identifier(n.Name.Name)
+	}
+
+	if attrs := columnAttributes(n.Schema); attrs != nil {
+		for _, attr := range attrs.Attributes {
+			switch attr.(type) {
+			case *zjast.NotNullColumnAttribute:
+				col.IsNotNull = true
+			case *zjast.PrimaryKeyColumnAttribute:
+				col.PrimaryKey = true
+			}
+		}
+	}
+
+	if simple, ok := n.Schema.(*zjast.SimpleColumnSchema); ok {
+		if simple.DefaultExpression != nil {
+			col.RawDefault = c.convertExpr(simple.DefaultExpression)
+		}
+	}
+
+	return col
+}
+
+func (c *cc) convertDropStatement(n *zjast.DropStatement) ast.Node {
+	// Only DROP TABLE maps onto the sqlc AST; other object kinds (views,
+	// functions, schemas, ...) fall through to TODO.
+	if strings.EqualFold(n.ObjectKind, "TABLE") && n.Path != nil {
+		return &ast.DropTableStmt{
+			IfExists: n.IsIfExists,
+			Tables:   []*ast.TableName{parseTableName(n.Path)},
+		}
+	}
+	return todo(n)
+}
+
+func (c *cc) convertTruncateStatement(n *zjast.TruncateStatement) ast.Node {
+	if n.Target == nil {
+		return todo(n)
+	}
+	return &ast.TruncateStmt{
+		Relations: &ast.List{Items: []ast.Node{parseRangeVar(n.Target)}},
+	}
+}
+
+// spelledTypeName is a type name the core reads from its spelling, whose
+// name is the family the spelling applies: string for string(10), array
+// for array(int64).
+func spelledTypeName(spelling string) *ast.TypeName {
+	name := spelling
+	if i := strings.IndexByte(name, '('); i >= 0 {
+		name = name[:i]
+	}
+	return &ast.TypeName{Name: name, Canonical: spelling}
+}

internal/engine/googlesql/dialect/dialect.json

@@ -0,0 +1,15 @@
+{
+  "dialect": "googlesql",
+  "const": {
+    "integer": "int64",
+    "float": "float64",
+    "string": "string",
+    "bool": "bool"
+  },
+  "bool": "bool",
+  "comparison": ["=", "<>", "!=", "<", "<=", ">", ">="],
+  "comparison_categories": "BNSDTU",
+  "arithmetic": ["+", "-", "*", "/"],
+  "arithmetic_categories": "N",
+  "idents": ["max"]
+}

internal/engine/googlesql/dialect/functions.jsonl

@@ -0,0 +1 @@
+{"name": "count", "kind": "a", "returns": "int64"}

internal/engine/googlesql/dialect/operators.jsonl

@@ -0,0 +1 @@
+{"name": "||", "left": "string", "right": "string", "result": "string"}

internal/engine/googlesql/dialect/relations.jsonl

@@ -0,0 +1,98 @@
+{"schema":"INFORMATION_SCHEMA","name":"CHANGE_STREAMS","kind":"v","columns":[{"name":"CHANGE_STREAM_CATALOG","type":"string(max)","not_null":true},{"name":"CHANGE_STREAM_SCHEMA","type":"string(max)","not_null":true},{"name":"CHANGE_STREAM_NAME","type":"string(max)","not_null":true},{"name":"ALL","type":"bool","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"CHANGE_STREAM_COLUMNS","kind":"v","columns":[{"name":"CHANGE_STREAM_CATALOG","type":"string(max)","not_null":true},{"name":"CHANGE_STREAM_SCHEMA","type":"string(max)","not_null":true},{"name":"CHANGE_STREAM_NAME","type":"string(max)","not_null":true},{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"COLUMN_NAME","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"CHANGE_STREAM_OPTIONS","kind":"v","columns":[{"name":"CHANGE_STREAM_CATALOG","type":"string(max)","not_null":true},{"name":"CHANGE_STREAM_SCHEMA","type":"string(max)","not_null":true},{"name":"CHANGE_STREAM_NAME","type":"string(max)","not_null":true},{"name":"OPTION_NAME","type":"string(max)","not_null":true},{"name":"OPTION_TYPE","type":"string(max)","not_null":true},{"name":"OPTION_VALUE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"CHANGE_STREAM_PRIVILEGES","kind":"v","columns":[{"name":"CHANGE_STREAM_CATALOG","type":"string(max)","not_null":true},{"name":"CHANGE_STREAM_SCHEMA","type":"string(max)","not_null":true},{"name":"CHANGE_STREAM_NAME","type":"string(max)","not_null":true},{"name":"PRIVILEGE_TYPE","type":"string(max)","not_null":true},{"name":"GRANTEE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"CHANGE_STREAM_TABLES","kind":"v","columns":[{"name":"CHANGE_STREAM_CATALOG","type":"string(max)","not_null":true},{"name":"CHANGE_STREAM_SCHEMA","type":"string(max)","not_null":true},{"name":"CHANGE_STREAM_NAME","type":"string(max)","not_null":true},{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"ALL_COLUMNS","type":"bool","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"CHECK_CONSTRAINTS","kind":"v","columns":[{"name":"CONSTRAINT_CATALOG","type":"string(max)","not_null":true},{"name":"CONSTRAINT_SCHEMA","type":"string(max)","not_null":true},{"name":"CONSTRAINT_NAME","type":"string(max)","not_null":true},{"name":"CHECK_CLAUSE","type":"string(max)","not_null":true},{"name":"SPANNER_STATE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"COLUMNS","kind":"v","columns":[{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"COLUMN_NAME","type":"string(max)","not_null":true},{"name":"ORDINAL_POSITION","type":"int64","not_null":true},{"name":"COLUMN_DEFAULT","type":"string(max)"},{"name":"DATA_TYPE","type":"string(max)"},{"name":"IS_NULLABLE","type":"string(max)"},{"name":"SPANNER_TYPE","type":"string(max)"},{"name":"IS_GENERATED","type":"string(max)","not_null":true},{"name":"GENERATION_EXPRESSION","type":"string(max)"},{"name":"IS_STORED","type":"string(max)"},{"name":"IS_HIDDEN","type":"bool","not_null":true},{"name":"SPANNER_STATE","type":"string(max)"},{"name":"IS_IDENTITY","type":"string(max)"},{"name":"IDENTITY_GENERATION","type":"string(max)"},{"name":"IDENTITY_KIND","type":"string(max)"},{"name":"IDENTITY_START_WITH_COUNTER","type":"string(max)"},{"name":"IDENTITY_SKIP_RANGE_MIN","type":"string(max)"},{"name":"IDENTITY_SKIP_RANGE_MAX","type":"string(max)"},{"name":"ON_UPDATE_EXPRESSION","type":"string(max)"}]}
+{"schema":"INFORMATION_SCHEMA","name":"COLUMN_COLUMN_USAGE","kind":"v","columns":[{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"COLUMN_NAME","type":"string(max)","not_null":true},{"name":"DEPENDENT_COLUMN","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"COLUMN_OPTIONS","kind":"v","columns":[{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"COLUMN_NAME","type":"string(max)","not_null":true},{"name":"OPTION_NAME","type":"string(max)","not_null":true},{"name":"OPTION_TYPE","type":"string(max)","not_null":true},{"name":"OPTION_VALUE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"COLUMN_PRIVILEGES","kind":"v","columns":[{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"COLUMN_NAME","type":"string(max)","not_null":true},{"name":"PRIVILEGE_TYPE","type":"string(max)","not_null":true},{"name":"GRANTEE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"CONSTRAINT_COLUMN_USAGE","kind":"v","columns":[{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"COLUMN_NAME","type":"string(max)","not_null":true},{"name":"CONSTRAINT_CATALOG","type":"string(max)","not_null":true},{"name":"CONSTRAINT_SCHEMA","type":"string(max)","not_null":true},{"name":"CONSTRAINT_NAME","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"CONSTRAINT_TABLE_USAGE","kind":"v","columns":[{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"CONSTRAINT_CATALOG","type":"string(max)","not_null":true},{"name":"CONSTRAINT_SCHEMA","type":"string(max)","not_null":true},{"name":"CONSTRAINT_NAME","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"DATABASE_OPTIONS","kind":"v","columns":[{"name":"CATALOG_NAME","type":"string(max)","not_null":true},{"name":"SCHEMA_NAME","type":"string(max)","not_null":true},{"name":"OPTION_NAME","type":"string(max)","not_null":true},{"name":"OPTION_TYPE","type":"string(max)","not_null":true},{"name":"OPTION_VALUE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"INDEXES","kind":"v","columns":[{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"INDEX_NAME","type":"string(max)","not_null":true},{"name":"INDEX_TYPE","type":"string(max)","not_null":true},{"name":"PARENT_TABLE_NAME","type":"string(max)","not_null":true},{"name":"IS_UNIQUE","type":"bool","not_null":true},{"name":"IS_NULL_FILTERED","type":"bool","not_null":true},{"name":"INDEX_STATE","type":"string(100)","not_null":true},{"name":"FILTER","type":"string(max)"},{"name":"SPANNER_IS_MANAGED","type":"bool","not_null":true},{"name":"SEARCH_PARTITION_BY","type":"string(max)","array":true},{"name":"SEARCH_ORDER_BY","type":"string(max)","array":true},{"name":"SEARCH_UNNEST","type":"string(max)","array":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"INDEX_COLUMNS","kind":"v","columns":[{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"INDEX_NAME","type":"string(max)","not_null":true},{"name":"INDEX_TYPE","type":"string(max)","not_null":true},{"name":"COLUMN_NAME","type":"string(max)","not_null":true},{"name":"ORDINAL_POSITION","type":"int64"},{"name":"COLUMN_ORDERING","type":"string(max)"},{"name":"IS_NULLABLE","type":"string(max)"},{"name":"SPANNER_TYPE","type":"string(max)"},{"name":"EXPRESSION","type":"string(max)"}]}
+{"schema":"INFORMATION_SCHEMA","name":"INDEX_OPTIONS","kind":"v","columns":[{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"INDEX_NAME","type":"string(max)","not_null":true},{"name":"INDEX_TYPE","type":"string(max)","not_null":true},{"name":"OPTION_NAME","type":"string(max)","not_null":true},{"name":"OPTION_TYPE","type":"string(max)","not_null":true},{"name":"OPTION_VALUE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"KEY_COLUMN_USAGE","kind":"v","columns":[{"name":"CONSTRAINT_CATALOG","type":"string(max)","not_null":true},{"name":"CONSTRAINT_SCHEMA","type":"string(max)","not_null":true},{"name":"CONSTRAINT_NAME","type":"string(max)","not_null":true},{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"COLUMN_NAME","type":"string(max)","not_null":true},{"name":"ORDINAL_POSITION","type":"int64","not_null":true},{"name":"POSITION_IN_UNIQUE_CONSTRAINT","type":"int64"}]}
+{"schema":"INFORMATION_SCHEMA","name":"LOCALITY_GROUP_OPTIONS","kind":"v","columns":[{"name":"LOCALITY_GROUP_NAME","type":"string(max)","not_null":true},{"name":"OPTION_NAME","type":"string(max)","not_null":true},{"name":"OPTION_VALUE","type":"string(max)"}]}
+{"schema":"INFORMATION_SCHEMA","name":"MODELS","kind":"v","columns":[{"name":"MODEL_CATALOG","type":"string(max)","not_null":true},{"name":"MODEL_SCHEMA","type":"string(max)","not_null":true},{"name":"MODEL_NAME","type":"string(max)","not_null":true},{"name":"IS_REMOTE","type":"bool","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"MODEL_COLUMNS","kind":"v","columns":[{"name":"MODEL_CATALOG","type":"string(max)","not_null":true},{"name":"MODEL_SCHEMA","type":"string(max)","not_null":true},{"name":"MODEL_NAME","type":"string(max)","not_null":true},{"name":"COLUMN_KIND","type":"string(max)","not_null":true},{"name":"COLUMN_NAME","type":"string(max)","not_null":true},{"name":"ORDINAL_POSITION","type":"int64","not_null":true},{"name":"DATA_TYPE","type":"string(max)","not_null":true},{"name":"IS_EXPLICIT","type":"bool","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"MODEL_COLUMN_OPTIONS","kind":"v","columns":[{"name":"MODEL_CATALOG","type":"string(max)","not_null":true},{"name":"MODEL_SCHEMA","type":"string(max)","not_null":true},{"name":"MODEL_NAME","type":"string(max)","not_null":true},{"name":"COLUMN_KIND","type":"string(max)","not_null":true},{"name":"COLUMN_NAME","type":"string(max)","not_null":true},{"name":"OPTION_NAME","type":"string(max)","not_null":true},{"name":"OPTION_TYPE","type":"string(max)","not_null":true},{"name":"OPTION_VALUE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"MODEL_OPTIONS","kind":"v","columns":[{"name":"MODEL_CATALOG","type":"string(max)","not_null":true},{"name":"MODEL_SCHEMA","type":"string(max)","not_null":true},{"name":"MODEL_NAME","type":"string(max)","not_null":true},{"name":"OPTION_NAME","type":"string(max)","not_null":true},{"name":"OPTION_TYPE","type":"string(max)","not_null":true},{"name":"OPTION_VALUE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"MODEL_PRIVILEGES","kind":"v","columns":[{"name":"MODEL_CATALOG","type":"string(max)","not_null":true},{"name":"MODEL_SCHEMA","type":"string(max)","not_null":true},{"name":"MODEL_NAME","type":"string(max)","not_null":true},{"name":"PRIVILEGE_TYPE","type":"string(max)","not_null":true},{"name":"GRANTEE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"PARAMETERS","kind":"v","columns":[{"name":"SPECIFIC_CATALOG","type":"string(max)","not_null":true},{"name":"SPECIFIC_SCHEMA","type":"string(max)","not_null":true},{"name":"SPECIFIC_NAME","type":"string(max)","not_null":true},{"name":"ORDINAL_POSITION","type":"int64","not_null":true},{"name":"PARAMETER_NAME","type":"string(max)","not_null":true},{"name":"DATA_TYPE","type":"string(max)","not_null":true},{"name":"PARAMETER_DEFAULT","type":"string(max)"},{"name":"SPANNER_TYPE","type":"string(max)"}]}
+{"schema":"INFORMATION_SCHEMA","name":"PLACEMENTS","kind":"v","columns":[{"name":"PLACEMENT_NAME","type":"string(max)","not_null":true},{"name":"IS_DEFAULT","type":"bool","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"PLACEMENT_OPTIONS","kind":"v","columns":[{"name":"PLACEMENT_NAME","type":"string(max)","not_null":true},{"name":"OPTION_NAME","type":"string(max)","not_null":true},{"name":"OPTION_TYPE","type":"string(max)","not_null":true},{"name":"OPTION_VALUE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"PROPERTY_GRAPHS","kind":"v","columns":[{"name":"PROPERTY_GRAPH_CATALOG","type":"string(max)","not_null":true},{"name":"PROPERTY_GRAPH_SCHEMA","type":"string(max)","not_null":true},{"name":"PROPERTY_GRAPH_NAME","type":"string(max)","not_null":true},{"name":"PROPERTY_GRAPH_METADATA_JSON","type":"json"}]}
+{"schema":"INFORMATION_SCHEMA","name":"REFERENTIAL_CONSTRAINTS","kind":"v","columns":[{"name":"CONSTRAINT_CATALOG","type":"string(max)","not_null":true},{"name":"CONSTRAINT_SCHEMA","type":"string(max)","not_null":true},{"name":"CONSTRAINT_NAME","type":"string(max)","not_null":true},{"name":"UNIQUE_CONSTRAINT_CATALOG","type":"string(max)"},{"name":"UNIQUE_CONSTRAINT_SCHEMA","type":"string(max)"},{"name":"UNIQUE_CONSTRAINT_NAME","type":"string(max)"},{"name":"MATCH_OPTION","type":"string(max)","not_null":true},{"name":"UPDATE_RULE","type":"string(max)","not_null":true},{"name":"DELETE_RULE","type":"string(max)","not_null":true},{"name":"SPANNER_STATE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"ROLES","kind":"v","columns":[{"name":"ROLE_NAME","type":"string(max)","not_null":true},{"name":"IS_SYSTEM","type":"bool","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"ROLE_CHANGE_STREAM_GRANTS","kind":"v","columns":[{"name":"CHANGE_STREAM_CATALOG","type":"string(max)","not_null":true},{"name":"CHANGE_STREAM_SCHEMA","type":"string(max)","not_null":true},{"name":"CHANGE_STREAM_NAME","type":"string(max)","not_null":true},{"name":"PRIVILEGE_TYPE","type":"string(max)","not_null":true},{"name":"GRANTEE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"ROLE_COLUMN_GRANTS","kind":"v","columns":[{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"COLUMN_NAME","type":"string(max)","not_null":true},{"name":"PRIVILEGE_TYPE","type":"string(max)","not_null":true},{"name":"GRANTEE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"ROLE_GRANTEES","kind":"v","columns":[{"name":"ROLE_NAME","type":"string(max)","not_null":true},{"name":"GRANTEE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"ROLE_MODEL_GRANTS","kind":"v","columns":[{"name":"MODEL_CATALOG","type":"string(max)","not_null":true},{"name":"MODEL_SCHEMA","type":"string(max)","not_null":true},{"name":"MODEL_NAME","type":"string(max)","not_null":true},{"name":"PRIVILEGE_TYPE","type":"string(max)","not_null":true},{"name":"GRANTEE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"ROLE_ROUTINE_GRANTS","kind":"v","columns":[{"name":"SPECIFIC_CATALOG","type":"string(max)","not_null":true},{"name":"SPECIFIC_SCHEMA","type":"string(max)","not_null":true},{"name":"SPECIFIC_NAME","type":"string(max)","not_null":true},{"name":"PRIVILEGE_TYPE","type":"string(max)","not_null":true},{"name":"GRANTEE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"ROLE_TABLE_GRANTS","kind":"v","columns":[{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"PRIVILEGE_TYPE","type":"string(max)","not_null":true},{"name":"GRANTEE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"ROUTINES","kind":"v","columns":[{"name":"SPECIFIC_CATALOG","type":"string(max)","not_null":true},{"name":"SPECIFIC_SCHEMA","type":"string(max)","not_null":true},{"name":"SPECIFIC_NAME","type":"string(max)","not_null":true},{"name":"ROUTINE_CATALOG","type":"string(max)","not_null":true},{"name":"ROUTINE_SCHEMA","type":"string(max)","not_null":true},{"name":"ROUTINE_NAME","type":"string(max)","not_null":true},{"name":"ROUTINE_TYPE","type":"string(max)","not_null":true},{"name":"DATA_TYPE","type":"string(max)","not_null":true},{"name":"ROUTINE_BODY","type":"string(max)","not_null":true},{"name":"ROUTINE_DEFINITION","type":"string(max)","not_null":true},{"name":"SECURITY_TYPE","type":"string(max)","not_null":true},{"name":"SPANNER_TYPE","type":"string(max)"}]}
+{"schema":"INFORMATION_SCHEMA","name":"ROUTINE_OPTIONS","kind":"v","columns":[{"name":"SPECIFIC_CATALOG","type":"string(max)","not_null":true},{"name":"SPECIFIC_SCHEMA","type":"string(max)","not_null":true},{"name":"SPECIFIC_NAME","type":"string(max)","not_null":true},{"name":"OPTION_NAME","type":"string(max)","not_null":true},{"name":"OPTION_TYPE","type":"string(max)","not_null":true},{"name":"OPTION_VALUE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"ROUTINE_PRIVILEGES","kind":"v","columns":[{"name":"SPECIFIC_CATALOG","type":"string(max)","not_null":true},{"name":"SPECIFIC_SCHEMA","type":"string(max)","not_null":true},{"name":"SPECIFIC_NAME","type":"string(max)","not_null":true},{"name":"PRIVILEGE_TYPE","type":"string(max)","not_null":true},{"name":"GRANTEE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"SCHEMATA","kind":"v","columns":[{"name":"CATALOG_NAME","type":"string(max)","not_null":true},{"name":"SCHEMA_NAME","type":"string(max)","not_null":true},{"name":"EFFECTIVE_TIMESTAMP","type":"int64"},{"name":"PROTO_BUNDLE","type":"proto('proto2.FileDescriptorSet')"},{"name":"SCHEMA_OWNER","type":"string(max)"}]}
+{"schema":"INFORMATION_SCHEMA","name":"SEQUENCES","kind":"v","columns":[{"name":"CATALOG","type":"string(max)","not_null":true},{"name":"SCHEMA","type":"string(max)","not_null":true},{"name":"NAME","type":"string(max)","not_null":true},{"name":"DATA_TYPE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"SEQUENCE_OPTIONS","kind":"v","columns":[{"name":"CATALOG","type":"string(max)","not_null":true},{"name":"SCHEMA","type":"string(max)","not_null":true},{"name":"NAME","type":"string(max)","not_null":true},{"name":"OPTION_NAME","type":"string(max)","not_null":true},{"name":"OPTION_TYPE","type":"string(max)","not_null":true},{"name":"OPTION_VALUE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"SPANNER_STATISTICS","kind":"v","columns":[{"name":"CATALOG_NAME","type":"string(max)","not_null":true},{"name":"SCHEMA_NAME","type":"string(max)","not_null":true},{"name":"PACKAGE_NAME","type":"string(max)","not_null":true},{"name":"ALLOW_GC","type":"bool","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"TABLES","kind":"v","columns":[{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"PARENT_TABLE_NAME","type":"string(max)"},{"name":"ON_DELETE_ACTION","type":"string(max)"},{"name":"TABLE_TYPE","type":"string(32)","not_null":true},{"name":"SPANNER_STATE","type":"string(max)"},{"name":"INTERLEAVE_TYPE","type":"string(max)"},{"name":"ROW_DELETION_POLICY_EXPRESSION","type":"string(max)"}]}
+{"schema":"INFORMATION_SCHEMA","name":"TABLE_CONSTRAINTS","kind":"v","columns":[{"name":"CONSTRAINT_CATALOG","type":"string(max)","not_null":true},{"name":"CONSTRAINT_SCHEMA","type":"string(max)","not_null":true},{"name":"CONSTRAINT_NAME","type":"string(max)","not_null":true},{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"CONSTRAINT_TYPE","type":"string(max)","not_null":true},{"name":"IS_DEFERRABLE","type":"string(max)","not_null":true},{"name":"INITIALLY_DEFERRED","type":"string(max)","not_null":true},{"name":"ENFORCED","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"TABLE_OPTIONS","kind":"v","columns":[{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"OPTION_NAME","type":"string(max)","not_null":true},{"name":"OPTION_TYPE","type":"string(max)","not_null":true},{"name":"OPTION_VALUE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"TABLE_PRIVILEGES","kind":"v","columns":[{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"PRIVILEGE_TYPE","type":"string(max)","not_null":true},{"name":"GRANTEE","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"TABLE_SYNONYMS","kind":"v","columns":[{"name":"SYNONYM_CATALOG","type":"string(max)","not_null":true},{"name":"SYNONYM_SCHEMA","type":"string(max)","not_null":true},{"name":"SYNONYM_NAME","type":"string(max)","not_null":true},{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true}]}
+{"schema":"INFORMATION_SCHEMA","name":"VIEWS","kind":"v","columns":[{"name":"TABLE_CATALOG","type":"string(max)","not_null":true},{"name":"TABLE_SCHEMA","type":"string(max)","not_null":true},{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"VIEW_DEFINITION","type":"string(max)"},{"name":"SECURITY_TYPE","type":"string(max)","not_null":true}]}
+{"schema":"SPANNER_SYS","name":"ACTIVE_PARTITIONED_DMLS","kind":"v","columns":[{"name":"TEXT","type":"string(max)"},{"name":"TEXT_FINGERPRINT","type":"string(max)"},{"name":"SESSION_ID","type":"string(max)"},{"name":"NUM_PARTITIONS_TOTAL","type":"int64"},{"name":"NUM_PARTITIONS_COMPLETE","type":"int64"},{"name":"NUM_TRIVIAL_PARTITIONS_COMPLETE","type":"int64"},{"name":"PROGRESS","type":"string(max)"},{"name":"ROWS_PROCESSED","type":"int64"},{"name":"START_TIMESTAMP","type":"timestamp"},{"name":"LAST_UPDATE_TIMESTAMP","type":"timestamp"}]}
+{"schema":"SPANNER_SYS","name":"ACTIVE_QUERIES_SUMMARY","kind":"v","columns":[{"name":"ACTIVE_COUNT","type":"int64"},{"name":"OLDEST_START_TIME","type":"timestamp"},{"name":"COUNT_OLDER_THAN_1S","type":"int64"},{"name":"COUNT_OLDER_THAN_10S","type":"int64"},{"name":"COUNT_OLDER_THAN_100S","type":"int64"}]}
+{"schema":"SPANNER_SYS","name":"COLUMN_OPERATIONS_STATS_10MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"TABLE_NAME","type":"string(max)"},{"name":"COLUMN_NAME","type":"string(max)"},{"name":"QUERY_COUNT","type":"int64"},{"name":"READ_COUNT","type":"int64"},{"name":"WRITE_COUNT","type":"int64"},{"name":"IS_QUERY_CACHE_MEMORY_CAPPED","type":"bool"}]}
+{"schema":"SPANNER_SYS","name":"COLUMN_OPERATIONS_STATS_HOUR","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"TABLE_NAME","type":"string(max)"},{"name":"COLUMN_NAME","type":"string(max)"},{"name":"QUERY_COUNT","type":"int64"},{"name":"READ_COUNT","type":"int64"},{"name":"WRITE_COUNT","type":"int64"},{"name":"IS_QUERY_CACHE_MEMORY_CAPPED","type":"bool"}]}
+{"schema":"SPANNER_SYS","name":"COLUMN_OPERATIONS_STATS_MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"TABLE_NAME","type":"string(max)"},{"name":"COLUMN_NAME","type":"string(max)"},{"name":"QUERY_COUNT","type":"int64"},{"name":"READ_COUNT","type":"int64"},{"name":"WRITE_COUNT","type":"int64"},{"name":"IS_QUERY_CACHE_MEMORY_CAPPED","type":"bool"}]}
+{"schema":"SPANNER_SYS","name":"GRAPH_OPERATION_EXECUTION_STATUS","kind":"v","columns":[{"name":"QUERY_ID","type":"string(max)"},{"name":"QUERY_TEXT","type":"string(max)"},{"name":"START_TIMESTAMP","type":"timestamp"},{"name":"LAST_UPDATE_TIMESTAMP","type":"timestamp"},{"name":"PROGRESS","type":"float64"},{"name":"STATUS","type":"string(max)"},{"name":"ERROR_MESSAGE","type":"string(max)"}]}
+{"schema":"SPANNER_SYS","name":"LOCK_STATS_TOP_10MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"ROW_RANGE_START_KEY","type":"bytes(max)"},{"name":"LOCK_WAIT_SECONDS","type":"float64"},{"name":"SAMPLE_LOCK_REQUESTS","type":"struct(COLUMN: string(max), LOCK_MODE: string(max), TRANSACTION_TAG: string(max))","array":true},{"name":"SAMPLE_LOCK_REQUESTS_JSON_STRING","type":"string(max)"}]}
+{"schema":"SPANNER_SYS","name":"LOCK_STATS_TOP_HOUR","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"ROW_RANGE_START_KEY","type":"bytes(max)"},{"name":"LOCK_WAIT_SECONDS","type":"float64"},{"name":"SAMPLE_LOCK_REQUESTS","type":"struct(COLUMN: string(max), LOCK_MODE: string(max), TRANSACTION_TAG: string(max))","array":true},{"name":"SAMPLE_LOCK_REQUESTS_JSON_STRING","type":"string(max)"}]}
+{"schema":"SPANNER_SYS","name":"LOCK_STATS_TOP_MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"ROW_RANGE_START_KEY","type":"bytes(max)"},{"name":"LOCK_WAIT_SECONDS","type":"float64"},{"name":"SAMPLE_LOCK_REQUESTS","type":"struct(COLUMN: string(max), LOCK_MODE: string(max), TRANSACTION_TAG: string(max))","array":true},{"name":"SAMPLE_LOCK_REQUESTS_JSON_STRING","type":"string(max)"}]}
+{"schema":"SPANNER_SYS","name":"LOCK_STATS_TOTAL_10MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"TOTAL_LOCK_WAIT_SECONDS","type":"float64"}]}
+{"schema":"SPANNER_SYS","name":"LOCK_STATS_TOTAL_HOUR","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"TOTAL_LOCK_WAIT_SECONDS","type":"float64"}]}
+{"schema":"SPANNER_SYS","name":"LOCK_STATS_TOTAL_MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"TOTAL_LOCK_WAIT_SECONDS","type":"float64"}]}
+{"schema":"SPANNER_SYS","name":"OLDEST_ACTIVE_QUERIES","kind":"v","columns":[{"name":"START_TIME","type":"timestamp"},{"name":"TEXT_FINGERPRINT","type":"int64"},{"name":"TEXT","type":"string(max)"},{"name":"TEXT_TRUNCATED","type":"bool"},{"name":"SESSION_ID","type":"string(max)"},{"name":"QUERY_ID","type":"string(max)"},{"name":"CLIENT_IP_ADDRESS","type":"string(max)"},{"name":"API_CLIENT_HEADER","type":"string(max)"},{"name":"USER_AGENT_HEADER","type":"string(max)"},{"name":"SERVER_REGION","type":"string(max)"},{"name":"PRIORITY","type":"string(max)"},{"name":"TRANSACTION_TYPE","type":"string(max)"}]}
+{"schema":"SPANNER_SYS","name":"QUERY_PROFILES_TOP_10MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"TEXT_FINGERPRINT","type":"int64"},{"name":"LATENCY_SECONDS","type":"float64"},{"name":"QUERY_PROFILE","type":"string(max)"}]}
+{"schema":"SPANNER_SYS","name":"QUERY_PROFILES_TOP_HOUR","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"TEXT_FINGERPRINT","type":"int64"},{"name":"LATENCY_SECONDS","type":"float64"},{"name":"QUERY_PROFILE","type":"string(max)"}]}
+{"schema":"SPANNER_SYS","name":"QUERY_PROFILES_TOP_MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"TEXT_FINGERPRINT","type":"int64"},{"name":"LATENCY_SECONDS","type":"float64"},{"name":"QUERY_PROFILE","type":"string(max)"}]}
+{"schema":"SPANNER_SYS","name":"QUERY_RECOMMENDATIONS","kind":"v","columns":[{"name":"GENERATION_TIME","type":"timestamp"},{"name":"TEXT_FINGERPRINT","type":"int64"},{"name":"QUERY_RECOMMENDATIONS","type":"string(max)"}]}
+{"schema":"SPANNER_SYS","name":"QUERY_STATS_TOP_10MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"TEXT","type":"string(max)"},{"name":"TEXT_TRUNCATED","type":"bool"},{"name":"TEXT_FINGERPRINT","type":"int64"},{"name":"EXECUTION_COUNT","type":"int64"},{"name":"AVG_LATENCY_SECONDS","type":"float64"},{"name":"AVG_ROWS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"AVG_ROWS_SCANNED","type":"float64"},{"name":"AVG_CPU_SECONDS","type":"float64"},{"name":"CANCELLED_OR_DISCONNECTED_EXECUTION_COUNT","type":"int64"},{"name":"TIMED_OUT_EXECUTION_COUNT","type":"int64"},{"name":"ALL_FAILED_EXECUTION_COUNT","type":"int64"},{"name":"ALL_FAILED_AVG_LATENCY_SECONDS","type":"float64"},{"name":"REQUEST_TAG","type":"string(max)"},{"name":"AVG_BYTES_WRITTEN","type":"float64"},{"name":"AVG_ROWS_WRITTEN","type":"float64"},{"name":"STATEMENT_COUNT","type":"int64"},{"name":"LATENCY_DISTRIBUTION","type":"struct(COUNT: int64, MEAN: float64, SUM_OF_SQUARED_DEVIATION: float64, NUM_FINITE_BUCKETS: int64, GROWTH_FACTOR: float64, SCALE: float64, BUCKET_COUNTS: int64[])","array":true},{"name":"RUN_IN_RW_TRANSACTION_EXECUTION_COUNT","type":"int64"},{"name":"QUERY_TYPE","type":"string(max)"},{"name":"AVG_MEMORY_PEAK_USAGE_BYTES","type":"float64"},{"name":"AVG_MEMORY_USAGE_PERCENTAGE","type":"float64"},{"name":"AVG_QUERY_PLAN_CREATION_TIME_SECS","type":"float64"},{"name":"AVG_FILESYSTEM_DELAY_SECS","type":"float64"},{"name":"AVG_REMOTE_SERVER_CALLS","type":"float64"},{"name":"AVG_ROWS_SPOOLED","type":"float64"},{"name":"AVG_DISK_IO_COST","type":"float64"},{"name":"LATENCY_DISTRIBUTION_JSON_STRING","type":"string(max)"},{"name":"AVG_COLUMNAR_READ_SHARE","type":"float64"},{"name":"QUERY_OPTIMIZER_VERSIONS","type":"int64","array":true},{"name":"STATISTICS_PACKAGE_NAMES","type":"string(max)","array":true}]}
+{"schema":"SPANNER_SYS","name":"QUERY_STATS_TOP_HOUR","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"TEXT","type":"string(max)"},{"name":"TEXT_TRUNCATED","type":"bool"},{"name":"TEXT_FINGERPRINT","type":"int64"},{"name":"EXECUTION_COUNT","type":"int64"},{"name":"AVG_LATENCY_SECONDS","type":"float64"},{"name":"AVG_ROWS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"AVG_ROWS_SCANNED","type":"float64"},{"name":"AVG_CPU_SECONDS","type":"float64"},{"name":"CANCELLED_OR_DISCONNECTED_EXECUTION_COUNT","type":"int64"},{"name":"TIMED_OUT_EXECUTION_COUNT","type":"int64"},{"name":"ALL_FAILED_EXECUTION_COUNT","type":"int64"},{"name":"ALL_FAILED_AVG_LATENCY_SECONDS","type":"float64"},{"name":"REQUEST_TAG","type":"string(max)"},{"name":"AVG_BYTES_WRITTEN","type":"float64"},{"name":"AVG_ROWS_WRITTEN","type":"float64"},{"name":"STATEMENT_COUNT","type":"int64"},{"name":"LATENCY_DISTRIBUTION","type":"struct(COUNT: int64, MEAN: float64, SUM_OF_SQUARED_DEVIATION: float64, NUM_FINITE_BUCKETS: int64, GROWTH_FACTOR: float64, SCALE: float64, BUCKET_COUNTS: int64[])","array":true},{"name":"RUN_IN_RW_TRANSACTION_EXECUTION_COUNT","type":"int64"},{"name":"QUERY_TYPE","type":"string(max)"},{"name":"AVG_MEMORY_PEAK_USAGE_BYTES","type":"float64"},{"name":"AVG_MEMORY_USAGE_PERCENTAGE","type":"float64"},{"name":"AVG_QUERY_PLAN_CREATION_TIME_SECS","type":"float64"},{"name":"AVG_FILESYSTEM_DELAY_SECS","type":"float64"},{"name":"AVG_REMOTE_SERVER_CALLS","type":"float64"},{"name":"AVG_ROWS_SPOOLED","type":"float64"},{"name":"AVG_DISK_IO_COST","type":"float64"},{"name":"LATENCY_DISTRIBUTION_JSON_STRING","type":"string(max)"},{"name":"AVG_COLUMNAR_READ_SHARE","type":"float64"},{"name":"QUERY_OPTIMIZER_VERSIONS","type":"int64","array":true},{"name":"STATISTICS_PACKAGE_NAMES","type":"string(max)","array":true}]}
+{"schema":"SPANNER_SYS","name":"QUERY_STATS_TOP_MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"TEXT","type":"string(max)"},{"name":"TEXT_TRUNCATED","type":"bool"},{"name":"TEXT_FINGERPRINT","type":"int64"},{"name":"EXECUTION_COUNT","type":"int64"},{"name":"AVG_LATENCY_SECONDS","type":"float64"},{"name":"AVG_ROWS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"AVG_ROWS_SCANNED","type":"float64"},{"name":"AVG_CPU_SECONDS","type":"float64"},{"name":"CANCELLED_OR_DISCONNECTED_EXECUTION_COUNT","type":"int64"},{"name":"TIMED_OUT_EXECUTION_COUNT","type":"int64"},{"name":"ALL_FAILED_EXECUTION_COUNT","type":"int64"},{"name":"ALL_FAILED_AVG_LATENCY_SECONDS","type":"float64"},{"name":"REQUEST_TAG","type":"string(max)"},{"name":"AVG_BYTES_WRITTEN","type":"float64"},{"name":"AVG_ROWS_WRITTEN","type":"float64"},{"name":"STATEMENT_COUNT","type":"int64"},{"name":"LATENCY_DISTRIBUTION","type":"struct(COUNT: int64, MEAN: float64, SUM_OF_SQUARED_DEVIATION: float64, NUM_FINITE_BUCKETS: int64, GROWTH_FACTOR: float64, SCALE: float64, BUCKET_COUNTS: int64[])","array":true},{"name":"RUN_IN_RW_TRANSACTION_EXECUTION_COUNT","type":"int64"},{"name":"QUERY_TYPE","type":"string(max)"},{"name":"AVG_MEMORY_PEAK_USAGE_BYTES","type":"float64"},{"name":"AVG_MEMORY_USAGE_PERCENTAGE","type":"float64"},{"name":"AVG_QUERY_PLAN_CREATION_TIME_SECS","type":"float64"},{"name":"AVG_FILESYSTEM_DELAY_SECS","type":"float64"},{"name":"AVG_REMOTE_SERVER_CALLS","type":"float64"},{"name":"AVG_ROWS_SPOOLED","type":"float64"},{"name":"AVG_DISK_IO_COST","type":"float64"},{"name":"LATENCY_DISTRIBUTION_JSON_STRING","type":"string(max)"},{"name":"AVG_COLUMNAR_READ_SHARE","type":"float64"},{"name":"QUERY_OPTIMIZER_VERSIONS","type":"int64","array":true},{"name":"STATISTICS_PACKAGE_NAMES","type":"string(max)","array":true}]}
+{"schema":"SPANNER_SYS","name":"QUERY_STATS_TOTAL_10MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"EXECUTION_COUNT","type":"int64"},{"name":"AVG_LATENCY_SECONDS","type":"float64"},{"name":"AVG_ROWS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"AVG_ROWS_SCANNED","type":"float64"},{"name":"AVG_CPU_SECONDS","type":"float64"},{"name":"CANCELLED_OR_DISCONNECTED_EXECUTION_COUNT","type":"int64"},{"name":"TIMED_OUT_EXECUTION_COUNT","type":"int64"},{"name":"ALL_FAILED_EXECUTION_COUNT","type":"int64"},{"name":"ALL_FAILED_AVG_LATENCY_SECONDS","type":"float64"},{"name":"AVG_BYTES_WRITTEN","type":"float64"},{"name":"AVG_ROWS_WRITTEN","type":"float64"},{"name":"LATENCY_DISTRIBUTION","type":"struct(COUNT: int64, MEAN: float64, SUM_OF_SQUARED_DEVIATION: float64, NUM_FINITE_BUCKETS: int64, GROWTH_FACTOR: float64, SCALE: float64, BUCKET_COUNTS: int64[])","array":true},{"name":"RUN_IN_RW_TRANSACTION_EXECUTION_COUNT","type":"int64"},{"name":"AVG_MEMORY_PEAK_USAGE_BYTES","type":"float64"},{"name":"AVG_MEMORY_USAGE_PERCENTAGE","type":"float64"},{"name":"AVG_QUERY_PLAN_CREATION_TIME_SECS","type":"float64"},{"name":"AVG_FILESYSTEM_DELAY_SECS","type":"float64"},{"name":"AVG_REMOTE_SERVER_CALLS","type":"float64"},{"name":"AVG_ROWS_SPOOLED","type":"float64"},{"name":"AVG_DISK_IO_COST","type":"float64"},{"name":"LATENCY_DISTRIBUTION_JSON_STRING","type":"string(max)"},{"name":"AVG_COLUMNAR_READ_SHARE","type":"float64"}]}
+{"schema":"SPANNER_SYS","name":"QUERY_STATS_TOTAL_HOUR","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"EXECUTION_COUNT","type":"int64"},{"name":"AVG_LATENCY_SECONDS","type":"float64"},{"name":"AVG_ROWS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"AVG_ROWS_SCANNED","type":"float64"},{"name":"AVG_CPU_SECONDS","type":"float64"},{"name":"CANCELLED_OR_DISCONNECTED_EXECUTION_COUNT","type":"int64"},{"name":"TIMED_OUT_EXECUTION_COUNT","type":"int64"},{"name":"ALL_FAILED_EXECUTION_COUNT","type":"int64"},{"name":"ALL_FAILED_AVG_LATENCY_SECONDS","type":"float64"},{"name":"AVG_BYTES_WRITTEN","type":"float64"},{"name":"AVG_ROWS_WRITTEN","type":"float64"},{"name":"LATENCY_DISTRIBUTION","type":"struct(COUNT: int64, MEAN: float64, SUM_OF_SQUARED_DEVIATION: float64, NUM_FINITE_BUCKETS: int64, GROWTH_FACTOR: float64, SCALE: float64, BUCKET_COUNTS: int64[])","array":true},{"name":"RUN_IN_RW_TRANSACTION_EXECUTION_COUNT","type":"int64"},{"name":"AVG_MEMORY_PEAK_USAGE_BYTES","type":"float64"},{"name":"AVG_MEMORY_USAGE_PERCENTAGE","type":"float64"},{"name":"AVG_QUERY_PLAN_CREATION_TIME_SECS","type":"float64"},{"name":"AVG_FILESYSTEM_DELAY_SECS","type":"float64"},{"name":"AVG_REMOTE_SERVER_CALLS","type":"float64"},{"name":"AVG_ROWS_SPOOLED","type":"float64"},{"name":"AVG_DISK_IO_COST","type":"float64"},{"name":"LATENCY_DISTRIBUTION_JSON_STRING","type":"string(max)"},{"name":"AVG_COLUMNAR_READ_SHARE","type":"float64"}]}
+{"schema":"SPANNER_SYS","name":"QUERY_STATS_TOTAL_MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"EXECUTION_COUNT","type":"int64"},{"name":"AVG_LATENCY_SECONDS","type":"float64"},{"name":"AVG_ROWS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"AVG_ROWS_SCANNED","type":"float64"},{"name":"AVG_CPU_SECONDS","type":"float64"},{"name":"CANCELLED_OR_DISCONNECTED_EXECUTION_COUNT","type":"int64"},{"name":"TIMED_OUT_EXECUTION_COUNT","type":"int64"},{"name":"ALL_FAILED_EXECUTION_COUNT","type":"int64"},{"name":"ALL_FAILED_AVG_LATENCY_SECONDS","type":"float64"},{"name":"AVG_BYTES_WRITTEN","type":"float64"},{"name":"AVG_ROWS_WRITTEN","type":"float64"},{"name":"LATENCY_DISTRIBUTION","type":"struct(COUNT: int64, MEAN: float64, SUM_OF_SQUARED_DEVIATION: float64, NUM_FINITE_BUCKETS: int64, GROWTH_FACTOR: float64, SCALE: float64, BUCKET_COUNTS: int64[])","array":true},{"name":"RUN_IN_RW_TRANSACTION_EXECUTION_COUNT","type":"int64"},{"name":"AVG_MEMORY_PEAK_USAGE_BYTES","type":"float64"},{"name":"AVG_MEMORY_USAGE_PERCENTAGE","type":"float64"},{"name":"AVG_QUERY_PLAN_CREATION_TIME_SECS","type":"float64"},{"name":"AVG_FILESYSTEM_DELAY_SECS","type":"float64"},{"name":"AVG_REMOTE_SERVER_CALLS","type":"float64"},{"name":"AVG_ROWS_SPOOLED","type":"float64"},{"name":"AVG_DISK_IO_COST","type":"float64"},{"name":"LATENCY_DISTRIBUTION_JSON_STRING","type":"string(max)"},{"name":"AVG_COLUMNAR_READ_SHARE","type":"float64"}]}
+{"schema":"SPANNER_SYS","name":"READ_STATS_TOP_10MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"READ_COLUMNS","type":"string(max)","array":true},{"name":"FPRINT","type":"int64"},{"name":"EXECUTION_COUNT","type":"int64"},{"name":"AVG_ROWS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"AVG_CPU_SECONDS","type":"float64"},{"name":"AVG_LOCKING_DELAY_SECONDS","type":"float64"},{"name":"AVG_CLIENT_WAIT_SECONDS","type":"float64"},{"name":"AVG_LEADER_REFRESH_DELAY_SECONDS","type":"float64"},{"name":"REQUEST_TAG","type":"string(max)"},{"name":"RUN_IN_RW_TRANSACTION_EXECUTION_COUNT","type":"int64"},{"name":"READ_TYPE","type":"string(max)"},{"name":"AVG_DISK_IO_COST","type":"float64"}]}
+{"schema":"SPANNER_SYS","name":"READ_STATS_TOP_HOUR","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"READ_COLUMNS","type":"string(max)","array":true},{"name":"FPRINT","type":"int64"},{"name":"EXECUTION_COUNT","type":"int64"},{"name":"AVG_ROWS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"AVG_CPU_SECONDS","type":"float64"},{"name":"AVG_LOCKING_DELAY_SECONDS","type":"float64"},{"name":"AVG_CLIENT_WAIT_SECONDS","type":"float64"},{"name":"AVG_LEADER_REFRESH_DELAY_SECONDS","type":"float64"},{"name":"REQUEST_TAG","type":"string(max)"},{"name":"RUN_IN_RW_TRANSACTION_EXECUTION_COUNT","type":"int64"},{"name":"READ_TYPE","type":"string(max)"},{"name":"AVG_DISK_IO_COST","type":"float64"}]}
+{"schema":"SPANNER_SYS","name":"READ_STATS_TOP_MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"READ_COLUMNS","type":"string(max)","array":true},{"name":"FPRINT","type":"int64"},{"name":"EXECUTION_COUNT","type":"int64"},{"name":"AVG_ROWS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"AVG_CPU_SECONDS","type":"float64"},{"name":"AVG_LOCKING_DELAY_SECONDS","type":"float64"},{"name":"AVG_CLIENT_WAIT_SECONDS","type":"float64"},{"name":"AVG_LEADER_REFRESH_DELAY_SECONDS","type":"float64"},{"name":"REQUEST_TAG","type":"string(max)"},{"name":"RUN_IN_RW_TRANSACTION_EXECUTION_COUNT","type":"int64"},{"name":"READ_TYPE","type":"string(max)"},{"name":"AVG_DISK_IO_COST","type":"float64"}]}
+{"schema":"SPANNER_SYS","name":"READ_STATS_TOTAL_10MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"EXECUTION_COUNT","type":"int64"},{"name":"AVG_ROWS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"AVG_CPU_SECONDS","type":"float64"},{"name":"AVG_LOCKING_DELAY_SECONDS","type":"float64"},{"name":"AVG_CLIENT_WAIT_SECONDS","type":"float64"},{"name":"AVG_LEADER_REFRESH_DELAY_SECONDS","type":"float64"},{"name":"RUN_IN_RW_TRANSACTION_EXECUTION_COUNT","type":"int64"},{"name":"AVG_DISK_IO_COST","type":"float64"}]}
+{"schema":"SPANNER_SYS","name":"READ_STATS_TOTAL_HOUR","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"EXECUTION_COUNT","type":"int64"},{"name":"AVG_ROWS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"AVG_CPU_SECONDS","type":"float64"},{"name":"AVG_LOCKING_DELAY_SECONDS","type":"float64"},{"name":"AVG_CLIENT_WAIT_SECONDS","type":"float64"},{"name":"AVG_LEADER_REFRESH_DELAY_SECONDS","type":"float64"},{"name":"RUN_IN_RW_TRANSACTION_EXECUTION_COUNT","type":"int64"},{"name":"AVG_DISK_IO_COST","type":"float64"}]}
+{"schema":"SPANNER_SYS","name":"READ_STATS_TOTAL_MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"EXECUTION_COUNT","type":"int64"},{"name":"AVG_ROWS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"AVG_CPU_SECONDS","type":"float64"},{"name":"AVG_LOCKING_DELAY_SECONDS","type":"float64"},{"name":"AVG_CLIENT_WAIT_SECONDS","type":"float64"},{"name":"AVG_LEADER_REFRESH_DELAY_SECONDS","type":"float64"},{"name":"RUN_IN_RW_TRANSACTION_EXECUTION_COUNT","type":"int64"},{"name":"AVG_DISK_IO_COST","type":"float64"}]}
+{"schema":"SPANNER_SYS","name":"ROW_DELETION_POLICIES","kind":"v","columns":[{"name":"TABLE_NAME","type":"string(max)","not_null":true},{"name":"PROCESSED_WATERMARK","type":"timestamp"},{"name":"UNDELETABLE_ROWS","type":"int64","not_null":true},{"name":"MIN_UNDELETABLE_TIMESTAMP","type":"timestamp"}]}
+{"schema":"SPANNER_SYS","name":"SCHEMA_RECOMMENDATIONS","kind":"v","columns":[{"name":"GENERATION_TIME","type":"timestamp"},{"name":"FINGERPRINT","type":"string(max)"},{"name":"SCHEMA_RECOMMENDATIONS","type":"string(max)"}]}
+{"schema":"SPANNER_SYS","name":"SPLIT_HOTNESS_STATS_TOP_MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"SPLIT_START","type":"string(max)"},{"name":"SPLIT_LIMIT","type":"string(max)"},{"name":"AFFECTED_TABLES","type":"string(max)","array":true},{"name":"HOTNESS","type":"int64"}]}
+{"schema":"SPANNER_SYS","name":"SPLIT_STATS_TOP_10MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"SPLIT_START","type":"string(max)"},{"name":"SPLIT_LIMIT","type":"string(max)"},{"name":"AFFECTED_TABLES","type":"string(max)","array":true},{"name":"CPU_USAGE_SCORE","type":"int64"},{"name":"UNSPLITTABLE_REASONS","type":"string(max)","array":true}]}
+{"schema":"SPANNER_SYS","name":"SPLIT_STATS_TOP_HOUR","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"SPLIT_START","type":"string(max)"},{"name":"SPLIT_LIMIT","type":"string(max)"},{"name":"AFFECTED_TABLES","type":"string(max)","array":true},{"name":"CPU_USAGE_SCORE","type":"int64"},{"name":"UNSPLITTABLE_REASONS","type":"string(max)","array":true}]}
+{"schema":"SPANNER_SYS","name":"SPLIT_STATS_TOP_MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"SPLIT_START","type":"string(max)"},{"name":"SPLIT_LIMIT","type":"string(max)"},{"name":"AFFECTED_TABLES","type":"string(max)","array":true},{"name":"CPU_USAGE_SCORE","type":"int64"},{"name":"UNSPLITTABLE_REASONS","type":"string(max)","array":true}]}
+{"schema":"SPANNER_SYS","name":"SUPPORTED_OPTIMIZER_VERSIONS","kind":"v","columns":[{"name":"VERSION","type":"int64","not_null":true},{"name":"RELEASE_DATE","type":"date","not_null":true},{"name":"IS_DEFAULT","type":"bool","not_null":true}]}
+{"schema":"SPANNER_SYS","name":"TABLE_OPERATIONS_STATS_10MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"TABLE_NAME","type":"string(max)"},{"name":"READ_QUERY_COUNT","type":"int64"},{"name":"WRITE_COUNT","type":"int64"},{"name":"DELETE_COUNT","type":"int64"}]}
+{"schema":"SPANNER_SYS","name":"TABLE_OPERATIONS_STATS_HOUR","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"TABLE_NAME","type":"string(max)"},{"name":"READ_QUERY_COUNT","type":"int64"},{"name":"WRITE_COUNT","type":"int64"},{"name":"DELETE_COUNT","type":"int64"}]}
+{"schema":"SPANNER_SYS","name":"TABLE_OPERATIONS_STATS_MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"TABLE_NAME","type":"string(max)"},{"name":"READ_QUERY_COUNT","type":"int64"},{"name":"WRITE_COUNT","type":"int64"},{"name":"DELETE_COUNT","type":"int64"}]}
+{"schema":"SPANNER_SYS","name":"TABLE_SIZES_STATS_1HOUR","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"TABLE_NAME","type":"string(max)"},{"name":"USED_BYTES","type":"float64"},{"name":"USED_SSD_BYTES","type":"float64"},{"name":"USED_HDD_BYTES","type":"float64"},{"name":"COLUMNAR_USED_BYTES","type":"float64"},{"name":"COLUMNAR_USED_SSD_BYTES","type":"float64"},{"name":"COLUMNAR_USED_HDD_BYTES","type":"float64"},{"name":"COLUMNAR_COVERAGE_RATIO","type":"float64"},{"name":"COLUMNAR_SSD_COVERAGE_RATIO","type":"float64"},{"name":"COLUMNAR_HDD_COVERAGE_RATIO","type":"float64"}]}
+{"schema":"SPANNER_SYS","name":"TABLE_SIZES_STATS_PER_LOCALITY_GROUP_1HOUR","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"TABLE_NAME","type":"string(max)"},{"name":"LOCALITY_GROUP","type":"string(max)"},{"name":"USED_SSD_BYTES","type":"float64"},{"name":"USED_HDD_BYTES","type":"float64"}]}
+{"schema":"SPANNER_SYS","name":"TASKS","kind":"v","columns":[{"name":"TASK_NAME","type":"string(max)","not_null":true},{"name":"PROCESSED_WATERMARK","type":"timestamp"},{"name":"LAST_RUN_STATUS","type":"string(max)"},{"name":"UNDELETABLE_ROWS","type":"int64","not_null":true}]}
+{"schema":"SPANNER_SYS","name":"TXN_STATS_TOP_10MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"FPRINT","type":"int64"},{"name":"READ_COLUMNS","type":"string(max)","array":true},{"name":"WRITE_CONSTRUCTIVE_COLUMNS","type":"string(max)","array":true},{"name":"WRITE_DELETE_TABLES","type":"string(max)","array":true},{"name":"COMMIT_ATTEMPT_COUNT","type":"int64"},{"name":"COMMIT_FAILED_PRECONDITION_COUNT","type":"int64"},{"name":"COMMIT_ABORT_COUNT","type":"int64"},{"name":"AVG_PARTICIPANTS","type":"float64"},{"name":"AVG_TOTAL_LATENCY_SECONDS","type":"float64"},{"name":"AVG_COMMIT_LATENCY_SECONDS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"COMMIT_RETRY_COUNT","type":"int64"},{"name":"TRANSACTION_TAG","type":"string(max)"},{"name":"OPERATIONS_BY_TABLE","type":"struct(TABLE_NAME: string(max), INSERT_OR_UPDATE_COUNT: int64, INSERT_OR_UPDATE_BYTES: int64)","array":true},{"name":"TOTAL_LATENCY_DISTRIBUTION","type":"struct(COUNT: int64, MEAN: float64, SUM_OF_SQUARED_DEVIATION: float64, NUM_FINITE_BUCKETS: int64, GROWTH_FACTOR: float64, SCALE: float64, BUCKET_COUNTS: int64[])","array":true},{"name":"ATTEMPT_COUNT","type":"int64"},{"name":"SERIALIZABLE_PESSIMISTIC_TXN_COUNT","type":"int64"},{"name":"REPEATABLE_READ_OPTIMISTIC_TXN_COUNT","type":"int64"},{"name":"OPERATIONS_BY_TABLE_JSON_STRING","type":"string(max)"},{"name":"TOTAL_LATENCY_DISTRIBUTION_JSON_STRING","type":"string(max)"},{"name":"SERIALIZABLE_OPTIMISTIC_TXN_COUNT","type":"int64"},{"name":"REPEATABLE_READ_PESSIMISTIC_TXN_COUNT","type":"int64"}]}
+{"schema":"SPANNER_SYS","name":"TXN_STATS_TOP_HOUR","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"FPRINT","type":"int64"},{"name":"READ_COLUMNS","type":"string(max)","array":true},{"name":"WRITE_CONSTRUCTIVE_COLUMNS","type":"string(max)","array":true},{"name":"WRITE_DELETE_TABLES","type":"string(max)","array":true},{"name":"COMMIT_ATTEMPT_COUNT","type":"int64"},{"name":"COMMIT_FAILED_PRECONDITION_COUNT","type":"int64"},{"name":"COMMIT_ABORT_COUNT","type":"int64"},{"name":"AVG_PARTICIPANTS","type":"float64"},{"name":"AVG_TOTAL_LATENCY_SECONDS","type":"float64"},{"name":"AVG_COMMIT_LATENCY_SECONDS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"COMMIT_RETRY_COUNT","type":"int64"},{"name":"TRANSACTION_TAG","type":"string(max)"},{"name":"OPERATIONS_BY_TABLE","type":"struct(TABLE_NAME: string(max), INSERT_OR_UPDATE_COUNT: int64, INSERT_OR_UPDATE_BYTES: int64)","array":true},{"name":"TOTAL_LATENCY_DISTRIBUTION","type":"struct(COUNT: int64, MEAN: float64, SUM_OF_SQUARED_DEVIATION: float64, NUM_FINITE_BUCKETS: int64, GROWTH_FACTOR: float64, SCALE: float64, BUCKET_COUNTS: int64[])","array":true},{"name":"ATTEMPT_COUNT","type":"int64"},{"name":"SERIALIZABLE_PESSIMISTIC_TXN_COUNT","type":"int64"},{"name":"REPEATABLE_READ_OPTIMISTIC_TXN_COUNT","type":"int64"},{"name":"OPERATIONS_BY_TABLE_JSON_STRING","type":"string(max)"},{"name":"TOTAL_LATENCY_DISTRIBUTION_JSON_STRING","type":"string(max)"},{"name":"SERIALIZABLE_OPTIMISTIC_TXN_COUNT","type":"int64"},{"name":"REPEATABLE_READ_PESSIMISTIC_TXN_COUNT","type":"int64"}]}
+{"schema":"SPANNER_SYS","name":"TXN_STATS_TOP_MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"FPRINT","type":"int64"},{"name":"READ_COLUMNS","type":"string(max)","array":true},{"name":"WRITE_CONSTRUCTIVE_COLUMNS","type":"string(max)","array":true},{"name":"WRITE_DELETE_TABLES","type":"string(max)","array":true},{"name":"COMMIT_ATTEMPT_COUNT","type":"int64"},{"name":"COMMIT_FAILED_PRECONDITION_COUNT","type":"int64"},{"name":"COMMIT_ABORT_COUNT","type":"int64"},{"name":"AVG_PARTICIPANTS","type":"float64"},{"name":"AVG_TOTAL_LATENCY_SECONDS","type":"float64"},{"name":"AVG_COMMIT_LATENCY_SECONDS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"COMMIT_RETRY_COUNT","type":"int64"},{"name":"TRANSACTION_TAG","type":"string(max)"},{"name":"OPERATIONS_BY_TABLE","type":"struct(TABLE_NAME: string(max), INSERT_OR_UPDATE_COUNT: int64, INSERT_OR_UPDATE_BYTES: int64)","array":true},{"name":"TOTAL_LATENCY_DISTRIBUTION","type":"struct(COUNT: int64, MEAN: float64, SUM_OF_SQUARED_DEVIATION: float64, NUM_FINITE_BUCKETS: int64, GROWTH_FACTOR: float64, SCALE: float64, BUCKET_COUNTS: int64[])","array":true},{"name":"ATTEMPT_COUNT","type":"int64"},{"name":"SERIALIZABLE_PESSIMISTIC_TXN_COUNT","type":"int64"},{"name":"REPEATABLE_READ_OPTIMISTIC_TXN_COUNT","type":"int64"},{"name":"OPERATIONS_BY_TABLE_JSON_STRING","type":"string(max)"},{"name":"TOTAL_LATENCY_DISTRIBUTION_JSON_STRING","type":"string(max)"},{"name":"SERIALIZABLE_OPTIMISTIC_TXN_COUNT","type":"int64"},{"name":"REPEATABLE_READ_PESSIMISTIC_TXN_COUNT","type":"int64"}]}
+{"schema":"SPANNER_SYS","name":"TXN_STATS_TOTAL_10MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"COMMIT_ATTEMPT_COUNT","type":"int64"},{"name":"COMMIT_FAILED_PRECONDITION_COUNT","type":"int64"},{"name":"COMMIT_ABORT_COUNT","type":"int64"},{"name":"AVG_PARTICIPANTS","type":"float64"},{"name":"AVG_TOTAL_LATENCY_SECONDS","type":"float64"},{"name":"AVG_COMMIT_LATENCY_SECONDS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"COMMIT_RETRY_COUNT","type":"int64"},{"name":"OPERATIONS_BY_TABLE","type":"struct(TABLE_NAME: string(max), INSERT_OR_UPDATE_COUNT: int64, INSERT_OR_UPDATE_BYTES: int64)","array":true},{"name":"TOTAL_LATENCY_DISTRIBUTION","type":"struct(COUNT: int64, MEAN: float64, SUM_OF_SQUARED_DEVIATION: float64, NUM_FINITE_BUCKETS: int64, GROWTH_FACTOR: float64, SCALE: float64, BUCKET_COUNTS: int64[])","array":true},{"name":"ATTEMPT_COUNT","type":"int64"},{"name":"SERIALIZABLE_PESSIMISTIC_TXN_COUNT","type":"int64"},{"name":"REPEATABLE_READ_OPTIMISTIC_TXN_COUNT","type":"int64"},{"name":"OPERATIONS_BY_TABLE_JSON_STRING","type":"string(max)"},{"name":"TOTAL_LATENCY_DISTRIBUTION_JSON_STRING","type":"string(max)"},{"name":"SERIALIZABLE_OPTIMISTIC_TXN_COUNT","type":"int64"},{"name":"REPEATABLE_READ_PESSIMISTIC_TXN_COUNT","type":"int64"}]}
+{"schema":"SPANNER_SYS","name":"TXN_STATS_TOTAL_HOUR","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"COMMIT_ATTEMPT_COUNT","type":"int64"},{"name":"COMMIT_FAILED_PRECONDITION_COUNT","type":"int64"},{"name":"COMMIT_ABORT_COUNT","type":"int64"},{"name":"AVG_PARTICIPANTS","type":"float64"},{"name":"AVG_TOTAL_LATENCY_SECONDS","type":"float64"},{"name":"AVG_COMMIT_LATENCY_SECONDS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"COMMIT_RETRY_COUNT","type":"int64"},{"name":"OPERATIONS_BY_TABLE","type":"struct(TABLE_NAME: string(max), INSERT_OR_UPDATE_COUNT: int64, INSERT_OR_UPDATE_BYTES: int64)","array":true},{"name":"TOTAL_LATENCY_DISTRIBUTION","type":"struct(COUNT: int64, MEAN: float64, SUM_OF_SQUARED_DEVIATION: float64, NUM_FINITE_BUCKETS: int64, GROWTH_FACTOR: float64, SCALE: float64, BUCKET_COUNTS: int64[])","array":true},{"name":"ATTEMPT_COUNT","type":"int64"},{"name":"SERIALIZABLE_PESSIMISTIC_TXN_COUNT","type":"int64"},{"name":"REPEATABLE_READ_OPTIMISTIC_TXN_COUNT","type":"int64"},{"name":"OPERATIONS_BY_TABLE_JSON_STRING","type":"string(max)"},{"name":"TOTAL_LATENCY_DISTRIBUTION_JSON_STRING","type":"string(max)"},{"name":"SERIALIZABLE_OPTIMISTIC_TXN_COUNT","type":"int64"},{"name":"REPEATABLE_READ_PESSIMISTIC_TXN_COUNT","type":"int64"}]}
+{"schema":"SPANNER_SYS","name":"TXN_STATS_TOTAL_MINUTE","kind":"v","columns":[{"name":"INTERVAL_END","type":"timestamp"},{"name":"COMMIT_ATTEMPT_COUNT","type":"int64"},{"name":"COMMIT_FAILED_PRECONDITION_COUNT","type":"int64"},{"name":"COMMIT_ABORT_COUNT","type":"int64"},{"name":"AVG_PARTICIPANTS","type":"float64"},{"name":"AVG_TOTAL_LATENCY_SECONDS","type":"float64"},{"name":"AVG_COMMIT_LATENCY_SECONDS","type":"float64"},{"name":"AVG_BYTES","type":"float64"},{"name":"COMMIT_RETRY_COUNT","type":"int64"},{"name":"OPERATIONS_BY_TABLE","type":"struct(TABLE_NAME: string(max), INSERT_OR_UPDATE_COUNT: int64, INSERT_OR_UPDATE_BYTES: int64)","array":true},{"name":"TOTAL_LATENCY_DISTRIBUTION","type":"struct(COUNT: int64, MEAN: float64, SUM_OF_SQUARED_DEVIATION: float64, NUM_FINITE_BUCKETS: int64, GROWTH_FACTOR: float64, SCALE: float64, BUCKET_COUNTS: int64[])","array":true},{"name":"ATTEMPT_COUNT","type":"int64"},{"name":"SERIALIZABLE_PESSIMISTIC_TXN_COUNT","type":"int64"},{"name":"REPEATABLE_READ_OPTIMISTIC_TXN_COUNT","type":"int64"},{"name":"OPERATIONS_BY_TABLE_JSON_STRING","type":"string(max)"},{"name":"TOTAL_LATENCY_DISTRIBUTION_JSON_STRING","type":"string(max)"},{"name":"SERIALIZABLE_OPTIMISTIC_TXN_COUNT","type":"int64"},{"name":"REPEATABLE_READ_PESSIMISTIC_TXN_COUNT","type":"int64"}]}
+{"schema":"SPANNER_SYS","name":"USER_SPLIT_POINTS","kind":"v","columns":[{"name":"TABLE_NAME","type":"string(max)"},{"name":"INDEX_NAME","type":"string(max)"},{"name":"INITIATOR","type":"string(max)"},{"name":"SPLIT_KEY","type":"string(max)"},{"name":"EXPIRE_TIME","type":"timestamp"}]}
+{"schema":"SPANNER_SYS","name":"VECTOR_INDEX_METRICS_HISTORY","kind":"v","columns":[{"name":"VECTOR_INDEX_NAME","type":"string(max)"},{"name":"START_TIME","type":"timestamp"},{"name":"COMPLETION_TIME","type":"timestamp"},{"name":"ROWS_SCANNED","type":"int64"},{"name":"CLUSTERS_SAMPLED","type":"int64"},{"name":"ZERO_SIZE_CLUSTERS_SAMPLED","type":"int64"},{"name":"MIN_CLUSTER_SIZE","type":"int64"},{"name":"MAX_CLUSTER_SIZE","type":"int64"},{"name":"CLUSTER_SIZE_PERCENTILES","type":"struct(percentile: int64, value_at_percentile: int64)","array":true},{"name":"CLUSTER_AVERAGE_DISTANCE_TO_CENTROID_PERCENTILES","type":"struct(percentile: int64, value_at_percentile: float64)","array":true},{"name":"NUM_LEAVES","type":"int64"},{"name":"NUM_BRANCHES","type":"int64"}]}

internal/engine/googlesql/dialect/types.jsonl

@@ -0,0 +1,23 @@
+{"name": "bool", "category": "B"}
+{"name": "int64", "category": "N"}
+{"name": "float32", "category": "N"}
+{"name": "float64", "category": "N"}
+{"name": "numeric", "category": "N"}
+{"name": "bignumeric", "category": "N"}
+{"name": "string", "category": "S"}
+{"name": "bytes", "category": "S"}
+{"name": "uuid", "category": "S"}
+{"name": "date", "category": "D"}
+{"name": "datetime", "category": "D"}
+{"name": "time", "category": "D"}
+{"name": "timestamp", "category": "D"}
+{"name": "interval", "category": "T"}
+{"name": "json", "category": "U"}
+{"name": "geography", "category": "U"}
+{"name": "struct", "category": "U"}
+{"name": "enum", "category": "U"}
+{"name": "proto", "category": "U"}
+{"name": "tokenlist", "category": "U"}
+{"name": "array", "category": "A"}
+{"name": "range", "category": "U"}
+{"name": "map", "category": "U"}

internal/engine/googlesql/parse.go

@@ -0,0 +1,70 @@
+package googlesql
+
+import (
+	"bytes"
+	"context"
+	"io"
+
+	"github.com/sqlc-dev/zetajones/parser"
+
+	"github.com/sqlc-dev/sqlc/internal/source"
+	"github.com/sqlc-dev/sqlc/internal/sql/ast"
+)
+
+func NewParser() *Parser {
+	return &Parser{}
+}
+
+type Parser struct{}
+
+func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) {
+	blob, err := io.ReadAll(r)
+	if err != nil {
+		return nil, err
+	}
+
+	ctx := context.Background()
+	stmtNodes, err := parser.Parse(ctx, bytes.NewReader(blob))
+	if err != nil {
+		return nil, err
+	}
+
+	// zetajones node locations are byte offsets into the input. Following the
+	// convention used by the other engines, a statement's location starts at the
+	// end of the previous statement (or the start of the input) so that any
+	// leading comment — in particular the "-- name:" annotation sqlc relies on —
+	// is captured as part of the statement.
+	var stmts []ast.Statement
+	loc := 0
+	for _, stmt := range stmtNodes {
+		converter := &cc{}
+		out := converter.convert(stmt)
+		if _, ok := out.(*ast.TODO); ok {
+			// Skip over the unsupported statement (and its trailing semicolon)
+			// so the next statement's leading comment is measured from here.
+			loc = stmt.End() + 1
+			continue
+		}
+
+		end := stmt.End()
+		stmts = append(stmts, ast.Statement{
+			Raw: &ast.RawStmt{
+				Stmt:         out,
+				StmtLocation: loc,
+				StmtLen:      end - loc,
+			},
+		})
+		loc = end + 1
+	}
+
+	return stmts, nil
+}
+
+// https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#comments
+func (p *Parser) CommentSyntax() source.CommentSyntax {
+	return source.CommentSyntax{
+		Dash:      true, // -- comment
+		SlashStar: true, // /* comment */
+		Hash:      true, // # comment
+	}
+}

internal/engine/googlesql/reserved.go

@@ -0,0 +1,11 @@
+package googlesql
+
+import (
+	"github.com/sqlc-dev/zetajones/token"
+)
+
+// IsReservedKeyword reports whether s is a reserved keyword in GoogleSQL; see
+// https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#reserved_keywords
+func (p *Parser) IsReservedKeyword(s string) bool {
+	return token.IsReservedKeyword(s)
+}

internal/engine/googlesql/seed.go

@@ -0,0 +1,16 @@
+package googlesql
+
+import (
+	"embed"
+
+	"github.com/sqlc-dev/sqlc/internal/core"
+	"github.com/sqlc-dev/sqlc/internal/core/seed"
+)
+
+//go:embed dialect
+var dialectFS embed.FS
+
+// Dialect returns the catalog option that seeds GoogleSQL's type system.
+func Dialect() core.Option {
+	return seed.Dialect(dialectFS, "dialect")
+}

internal/engine/googlesql/stdlib.go

@@ -0,0 +1,9 @@
+package googlesql
+
+import (
+	"github.com/sqlc-dev/sqlc/internal/sql/catalog"
+)
+
+func defaultSchema(name string) *catalog.Schema {
+	return &catalog.Schema{Name: name}
+}

internal/engine/googlesql/utils.go

@@ -0,0 +1,298 @@
+package googlesql
+
+import (
+	"log"
+	"strings"
+
+	zjast "github.com/sqlc-dev/zetajones/ast"
+
+	"github.com/sqlc-dev/sqlc/internal/debug"
+	"github.com/sqlc-dev/sqlc/internal/sql/ast"
+)
+
+func todo(n zjast.Node) *ast.TODO {
+	if debug.Active {
+		log.Printf("googlesql.convert: Unknown node type %T\n", n)
+	}
+	return &ast.TODO{}
+}
+
+// identifier passes table and column identifiers through unchanged. GoogleSQL
+// keywords are case-insensitive, but table names (on BigQuery) are
+// case-sensitive, so unlike the MySQL and ClickHouse engines we do not
+// lowercase identifiers here. Function and type names, which are
+// case-insensitive, are lowercased at their call sites instead.
+func identifier(id string) string {
+	return id
+}
+
+func NewIdentifier(t string) *ast.String {
+	return &ast.String{Str: identifier(t)}
+}
+
+// pathParts returns the identifier names of a dotted path expression.
+func pathParts(n *zjast.PathExpression) []string {
+	if n == nil {
+		return nil
+	}
+	parts := make([]string, 0, len(n.Names))
+	for _, id := range n.Names {
+		if id == nil {
+			continue
+		}
+		parts = append(parts, id.Name)
+	}
+	return parts
+}
+
+func parseTableName(n *zjast.PathExpression) *ast.TableName {
+	name := &ast.TableName{}
+	parts := pathParts(n)
+	switch len(parts) {
+	case 0:
+	case 1:
+		name.Name = identifier(parts[0])
+	case 2:
+		name.Schema = identifier(parts[0])
+		name.Name = identifier(parts[1])
+	default:
+		name.Catalog = identifier(parts[0])
+		name.Schema = identifier(parts[len(parts)-2])
+		name.Name = identifier(parts[len(parts)-1])
+	}
+	return name
+}
+
+func parseRangeVar(n *zjast.PathExpression) *ast.RangeVar {
+	tn := parseTableName(n)
+	rv := &ast.RangeVar{}
+	if n != nil {
+		rv.Location = n.Pos()
+	}
+	if tn.Catalog != "" {
+		catalog := tn.Catalog
+		rv.Catalogname = &catalog
+	}
+	if tn.Schema != "" {
+		schema := tn.Schema
+		rv.Schemaname = &schema
+	}
+	if tn.Name != "" {
+		relname := tn.Name
+		rv.Relname = &relname
+	}
+	return rv
+}
+
+func convertAlias(a *zjast.Alias) *ast.Alias {
+	if a == nil || a.Identifier == nil {
+		return nil
+	}
+	name := identifier(a.Identifier.Name)
+	return &ast.Alias{Aliasname: &name}
+}
+
+// whereExpr unwraps a WHERE clause node to its expression. The DELETE and
+// UPDATE statement nodes hold either a *WhereClause or a bare expression.
+func whereExpr(node zjast.Node) zjast.Node {
+	if wc, ok := node.(*zjast.WhereClause); ok {
+		return wc.Expr
+	}
+	return node
+}
+
+// stringLiteralValue concatenates and unquotes the components of a string
+// literal.
+func stringLiteralValue(n *zjast.StringLiteral) string {
+	var sb strings.Builder
+	for _, comp := range n.Components {
+		if comp == nil {
+			continue
+		}
+		sb.WriteString(unquote(comp.Image))
+	}
+	return sb.String()
+}
+
+// unquote strips the optional r/b prefix and the surrounding quotes from a
+// string literal component and decodes escape sequences for non-raw strings.
+// It is best-effort: malformed input is returned unchanged.
+func unquote(image string) string {
+	raw := false
+	i := 0
+prefix:
+	for i < len(image) {
+		switch image[i] {
+		case 'r', 'R':
+			raw = true
+			i++
+		case 'b', 'B':
+			i++
+		default:
+			break prefix
+		}
+	}
+	s := image[i:]
+	for _, q := range []string{`'''`, `"""`, `'`, `"`} {
+		if len(s) >= 2*len(q) && strings.HasPrefix(s, q) && strings.HasSuffix(s, q) {
+			s = s[len(q) : len(s)-len(q)]
+			if raw || !strings.ContainsRune(s, '\\') {
+				return s
+			}
+			return decodeEscapes(s)
+		}
+	}
+	return image
+}
+
+func decodeEscapes(s string) string {
+	var sb strings.Builder
+	for i := 0; i < len(s); i++ {
+		ch := s[i]
+		if ch != '\\' || i+1 >= len(s) {
+			sb.WriteByte(ch)
+			continue
+		}
+		i++
+		switch s[i] {
+		case 'n':
+			sb.WriteByte('\n')
+		case 't':
+			sb.WriteByte('\t')
+		case 'r':
+			sb.WriteByte('\r')
+		case 'a':
+			sb.WriteByte('\a')
+		case 'b':
+			sb.WriteByte('\b')
+		case 'f':
+			sb.WriteByte('\f')
+		case 'v':
+			sb.WriteByte('\v')
+		case '\\', '\'', '"', '?', '`':
+			sb.WriteByte(s[i])
+		default:
+			// Unknown escape (\x, \u, ...): keep it verbatim.
+			sb.WriteByte('\\')
+			sb.WriteByte(s[i])
+		}
+	}
+	return sb.String()
+}
+
+// typeName renders a zetajones type node (used by CAST) as a lowercased type
+// name. Nested types degrade to a readable representation.
+// typeName spells a type the way the analysis core reads one: a family
+// applied to its arguments, with an array's element, a struct's labelled
+// fields, a range's subtype and a map's key and value nested, and a
+// parameter list's integers and MAX written as they were.
+func typeName(node zjast.Node) string {
+	switch t := node.(type) {
+	case *zjast.SimpleType:
+		return strings.ToLower(strings.Join(pathParts(t.Name), ".")) + typeParameters(t.TypeParameters)
+	case *zjast.ArrayType:
+		return "array(" + typeName(t.ElementType) + ")"
+	case *zjast.StructType:
+		fields := make([]string, 0, len(t.Fields))
+		for _, f := range t.Fields {
+			field := typeName(f.Type)
+			if f.Name != nil {
+				field = identifier(f.Name.Name) + ": " + field
+			}
+			fields = append(fields, field)
+		}
+		return "struct(" + strings.Join(fields, ", ") + ")"
+	case *zjast.RangeType:
+		return "range(" + typeName(t.ElementType) + ")"
+	case *zjast.MapType:
+		return "map(" + typeName(t.KeyType) + ", " + typeName(t.ValueType) + ")"
+	default:
+		return ""
+	}
+}
+
+// typeParameters spells a parameter list, STRING(10) or BYTES(MAX), as the
+// arguments of a call.
+func typeParameters(params *zjast.TypeParameterList) string {
+	if params == nil || len(params.Parameters) == 0 {
+		return ""
+	}
+	parts := make([]string, 0, len(params.Parameters))
+	for _, p := range params.Parameters {
+		switch v := p.(type) {
+		case *zjast.IntLiteral:
+			parts = append(parts, v.Image)
+		case *zjast.MaxLiteral:
+			parts = append(parts, "max")
+		default:
+			continue
+		}
+	}
+	if len(parts) == 0 {
+		return ""
+	}
+	return "(" + strings.Join(parts, ", ") + ")"
+}
+
+// columnSchemaTypeName renders a CREATE TABLE column schema as a lowercased
+// type name. Nested types degrade to a readable representation.
+// columnSchemaTypeName spells a column's type the way typeName spells a
+// type.
+func columnSchemaTypeName(node zjast.Node) string {
+	switch t := node.(type) {
+	case *zjast.SimpleColumnSchema:
+		return strings.ToLower(strings.Join(pathParts(t.Type), ".")) + typeParameters(t.TypeParameters)
+	case *zjast.ArrayColumnSchema:
+		return "array(" + columnSchemaTypeName(t.ElementSchema) + ")"
+	case *zjast.StructColumnSchema:
+		fields := make([]string, 0, len(t.Fields))
+		for _, f := range t.Fields {
+			field := columnSchemaTypeName(f.Schema)
+			if f.Name != nil {
+				field = identifier(f.Name.Name) + ": " + field
+			}
+			fields = append(fields, field)
+		}
+		return "struct(" + strings.Join(fields, ", ") + ")"
+	default:
+		return ""
+	}
+}
+
+// columnAttributes returns the attribute list (NOT NULL, PRIMARY KEY, ...) of
+// a column schema, if any.
+func columnAttributes(node zjast.Node) *zjast.ColumnAttributeList {
+	switch t := node.(type) {
+	case *zjast.SimpleColumnSchema:
+		return t.Attributes
+	case *zjast.ArrayColumnSchema:
+		return t.Attributes
+	case *zjast.StructColumnSchema:
+		return t.Attributes
+	default:
+		return nil
+	}
+}
+
+// columnRefFields flattens an identifier, path expression, or dotted
+// identifier chain into ColumnRef fields.
+func columnRefFields(node zjast.Node) ([]ast.Node, bool) {
+	switch n := node.(type) {
+	case *zjast.Identifier:
+		return []ast.Node{NewIdentifier(n.Name)}, true
+	case *zjast.PathExpression:
+		var fields []ast.Node
+		for _, part := range pathParts(n) {
+			fields = append(fields, NewIdentifier(part))
+		}
+		return fields, len(fields) > 0
+	case *zjast.DotIdentifier:
+		base, ok := columnRefFields(n.Expr)
+		if !ok || n.Name == nil {
+			return nil, false
+		}
+		return append(base, NewIdentifier(n.Name.Name)), true
+	default:
+		return nil, false
+	}
+}