/*

Copyright 2017 Google Inc.

Licensed under the Apache License, Version 2.0 (the "License");

you may not use this file except in compliance with the License.

You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software

distributed under the License is distributed on an "AS IS" BASIS,

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

See the License for the specific language governing permissions and

limitations under the License.

*/

package sqlparser

import (

"bytes"

"encoding/hex"

"encoding/json"

"errors"

"strings"

"github.com/xelabs/go-mysqlstack/sqlparser/depends/sqltypes"

)

// Instructions for creating new types: If a type

// needs to satisfy an interface, declare that function

// along with that interface. This will help users

// identify the list of types to which they can assert

// those interfaces.

// If the member of a type has a string with a predefined

// list of values, declare those values as const following

// the type.

// For interfaces that define dummy functions to consolidate

// a set of types, define the function as iTypeName.

// This will help avoid name collisions.

// Parse parses the sql and returns a Statement, which

// is the AST representation of the query. If a DDL statement

// is partially parsed but still contains a syntax error, the

// error is ignored and the DDL is returned anyway.

func Parse(sql string) (Statement, error) {

tokenizer := NewStringTokenizer(sql)

if yyParse(tokenizer) != 0 {

return nil, errors.New(tokenizer.LastError)

}

return tokenizer.ParseTree, nil

}

// SQLNode defines the interface for all nodes

// generated by the parser.

type SQLNode interface {

Format(buf *TrackedBuffer)

// WalkSubtree calls visit on all underlying nodes

// of the subtree, but not the current one. Walking

// must be interrupted if visit returns an error.

WalkSubtree(visit Visit) error

}

// Visit defines the signature of a function that

// can be used to visit all nodes of a parse tree.

type Visit func(node SQLNode) (kontinue bool, err error)

// Walk calls visit on every node.

// If visit returns true, the underlying nodes

// are also visited. If it returns an error, walking

// is interrupted, and the error is returned.

func Walk(visit Visit, nodes ...SQLNode) error {

for _, node := range nodes {

if node == nil {

continue

}

kontinue, err := visit(node)

if err != nil {

return err

}

if kontinue {

err = node.WalkSubtree(visit)

if err != nil {

return err

}

}

}

return nil

}

// String returns a string representation of an SQLNode.

func String(node SQLNode) string {

buf := NewTrackedBuffer(nil)

buf.Myprintf("%v", node)

return buf.String()

}

// Append appends the SQLNode to the buffer.

func Append(buf *bytes.Buffer, node SQLNode) {

tbuf := &TrackedBuffer{

Buffer: buf,

}

node.Format(tbuf)

}

// Statement represents a statement.

type Statement interface {

iStatement()

SQLNode

}

func (*Union) iStatement() {}

func (*Select) iStatement() {}

func (*Insert) iStatement() {}

func (*Update) iStatement() {}

func (*Delete) iStatement() {}

func (*Set) iStatement() {}

func (*DDL) iStatement() {}

func (*Show) iStatement() {}

func (*Use) iStatement() {}

func (*OtherRead) iStatement() {}

func (*OtherAdmin) iStatement() {}

// ParenSelect can actually not be a top level statement,

// but we have to allow it because it's a requirement

// of SelectStatement.

func (*ParenSelect) iStatement() {}

// SelectStatement any SELECT statement.

type SelectStatement interface {

iSelectStatement()

iStatement()

iInsertRows()

AddOrder(*Order)

SetLimit(*Limit)

SQLNode

}

func (*Select) iSelectStatement() {}

func (*Union) iSelectStatement() {}

func (*ParenSelect) iSelectStatement() {}

// Select represents a SELECT statement.

type Select struct {

Cache string

Comments Comments

Distinct string

Hints string

SelectExprs SelectExprs

From TableExprs

Where *Where

GroupBy GroupBy

Having *Where

OrderBy OrderBy

Limit *Limit

Lock string

ForBackup string

}

// Select.Distinct

const (

DistinctStr = "distinct "

StraightJoinHint = "straight_join "

)

// Select.Lock

const (

ForUpdateStr = " for update"

ShareModeStr = " lock in share mode"

)

// Select.Cache

const (

SQLCacheStr = "sql_cache "

SQLNoCacheStr = "sql_no_cache "

)

// AddOrder adds an order by element

func (node *Select) AddOrder(order *Order) {

node.OrderBy = append(node.OrderBy, order)

}

// SetLimit sets the limit clause

func (node *Select) SetLimit(limit *Limit) {

node.Limit = limit

}

// Format formats the node.

func (node *Select) Format(buf *TrackedBuffer) {

buf.Myprintf("select %v%s%s%s%v from %v%v%v%v%v%v%s",

node.Comments, node.Cache, node.Distinct, node.Hints, node.SelectExprs,

node.From, node.Where,

node.GroupBy, node.Having, node.OrderBy,

node.Limit, node.Lock)

}

// WalkSubtree walks the nodes of the subtree.

func (node *Select) WalkSubtree(visit Visit) error {

if node == nil {

return nil

}

return Walk(

visit,

node.Comments,

node.SelectExprs,

node.From,

node.Where,

node.GroupBy,

node.Having,

node.OrderBy,

node.Limit,

)

}

// AddWhere adds the boolean expression to the

// WHERE clause as an AND condition. If the expression

// is an OR clause, it parenthesizes it. Currently,

// the OR operator is the only one that's lower precedence

// than AND.

func (node *Select) AddWhere(expr Expr) {

if _, ok := expr.(*OrExpr); ok {

expr = &ParenExpr{Expr: expr}

}

if node.Where == nil {

node.Where = &Where{

Type: WhereStr,

Expr: expr,

}

return

}

node.Where.Expr = &AndExpr{

Left: node.Where.Expr,

Right: expr,

}

}

// AddHaving adds the boolean expression to the

// HAVING clause as an AND condition. If the expression

// is an OR clause, it parenthesizes it. Currently,

// the OR operator is the only one that's lower precedence

// than AND.

func (node *Select) AddHaving(expr Expr) {

if _, ok := expr.(*OrExpr); ok {

expr = &ParenExpr{Expr: expr}

}

if node.Having == nil {

node.Having = &Where{

Type: HavingStr,

Expr: expr,

}

return

}

node.Having.Expr = &AndExpr{

Left: node.Having.Expr,

Right: expr,

}

}

// ParenSelect is a parenthesized SELECT statement.

type ParenSelect struct {

Select SelectStatement

}

// AddOrder adds an order by element

func (node *ParenSelect) AddOrder(order *Order) {

panic("unreachable")

}

// SetLimit sets the limit clause

func (node *ParenSelect) SetLimit(limit *Limit) {

panic("unreachable")

}

// Format formats the node.

func (node *ParenSelect) Format(buf *TrackedBuffer) {

buf.Myprintf("(%v)", node.Select)

}

// WalkSubtree walks the nodes of the subtree.

func (node *ParenSelect) WalkSubtree(visit Visit) error {

if node == nil {

return nil

}

return Walk(

visit,

node.Select,

)

}

// Union represents a UNION statement.

type Union struct {

Type string

Left, Right SelectStatement

OrderBy OrderBy

Limit *Limit

Lock string

}

// Union.Type

const (

UnionStr = "union"

UnionAllStr = "union all"

UnionDistinctStr = "union distinct"

)

// AddOrder adds an order by element

func (node *Union) AddOrder(order *Order) {

node.OrderBy = append(node.OrderBy, order)

}

// SetLimit sets the limit clause

func (node *Union) SetLimit(limit *Limit) {

node.Limit = limit

}

// Format formats the node.

func (node *Union) Format(buf *TrackedBuffer) {

buf.Myprintf("%v %s %v%v%v%s", node.Left, node.Type, node.Right,

node.OrderBy, node.Limit, node.Lock)

}

// WalkSubtree walks the nodes of the subtree.

func (node *Union) WalkSubtree(visit Visit) error {

if node == nil {

return nil

}

return Walk(

visit,

node.Left,

node.Right,

)

}

// Insert represents an INSERT or REPLACE statement.

// Per the MySQL docs, http://dev.mysql.com/doc/refman/5.7/en/replace.html

// Replace is the counterpart to `INSERT IGNORE`, and works exactly like a

// normal INSERT except if the row exists. In that case it first deletes

// the row and re-inserts with new values. For that reason we keep it as an Insert struct.

// Replaces are currently disallowed in sharded schemas because

// of the implications the deletion part may have on vindexes.

type Insert struct {

Action string

Comments Comments

Ignore string

Table TableName

Columns Columns

Rows InsertRows

OnDup OnDup

}

const (

// InsertStr represents insert action.

InsertStr = "insert"

// ReplaceStr represents replace action.

ReplaceStr = "replace"

)

// Format formats the node.

func (node *Insert) Format(buf *TrackedBuffer) {

buf.Myprintf("%s %v%sinto %v%v %v%v",

node.Action,

node.Comments, node.Ignore,

node.Table, node.Columns, node.Rows, node.OnDup)

}

// WalkSubtree walks the nodes of the subtree.

func (node *Insert) WalkSubtree(visit Visit) error {

if node == nil {

return nil

}

return Walk(

visit,

node.Comments,

node.Table,

node.Columns,

node.Rows,

node.OnDup,

)

}

// InsertRows represents the rows for an INSERT statement.

type InsertRows interface {

iInsertRows()

SQLNode

}

func (*Select) iInsertRows() {}

func (*Union) iInsertRows() {}

func (Values) iInsertRows() {}

func (*ParenSelect) iInsertRows() {}

// Update represents an UPDATE statement.

type Update struct {

Comments Comments

Table TableName

Exprs UpdateExprs

Where *Where

OrderBy OrderBy

Limit *Limit

}

// Format formats the node.

func (node *Update) Format(buf *TrackedBuffer) {

buf.Myprintf("update %v%v set %v%v%v%v",

node.Comments, node.Table,

node.Exprs, node.Where, node.OrderBy, node.Limit)

}

// WalkSubtree walks the nodes of the subtree.

func (node *Update) WalkSubtree(visit Visit) error {

if node == nil {

return nil

}

return Walk(

visit,

node.Comments,

node.Table,

node.Exprs,

node.Where,

node.OrderBy,

node.Limit,

)

}

// Delete represents a DELETE statement.

type Delete struct {

Comments Comments

Table TableName

Where *Where

OrderBy OrderBy

Limit *Limit

}

// Format formats the node.

func (node *Delete) Format(buf *TrackedBuffer) {

buf.Myprintf("delete %vfrom %v%v%v%v", node.Comments, node.Table, node.Where, node.OrderBy, node.Limit)

}

// WalkSubtree walks the nodes of the subtree.

func (node *Delete) WalkSubtree(visit Visit) error {

if node == nil {

return nil

}

return Walk(

visit,

node.Comments,

node.Table,

node.Where,

node.OrderBy,

node.Limit,

)

}

// Set represents a SET statement.

type Set struct {

Comments Comments

Exprs UpdateExprs

}

// Format formats the node.

func (node *Set) Format(buf *TrackedBuffer) {

buf.Myprintf("set")

}

// WalkSubtree walks the nodes of the subtree.

func (node *Set) WalkSubtree(visit Visit) error {

if node == nil {

return nil

}

return Walk(

visit,

node.Comments,

node.Exprs,

)

}

// DDL represents a CREATE, ALTER, DROP or RENAME statement.

// Table is set for AlterStr, DropStr, RenameStr.

// NewName is set for AlterStr, CreateStr, RenameStr.

type DDL struct {

Action string

Engine string

Charset string

IndexName string

PartitionName string

IfExists bool

IfNotExists bool

Table TableName

NewName TableName

Database TableIdent

TableSpec *TableSpec

// table column operation

DropColumnName string

ModifyColumnDef *ColumnDefinition

}

// DDL strings.

const (

CreateDBStr = "create database"

CreateTableStr = "create table"

CreatePartitionTableStr = "create partition table"

CreateIndexStr = "create index"

DropDBStr = "drop database"

DropTableStr = "drop table"

DropIndexStr = "drop index"

AlterStr = "alter"

AlterEngineStr = "alter table"

AlterCharsetStr = "alter table charset"

AlterAddColumnStr = "alter table add column"

AlterDropColumnStr = "alter table drop column"

AlterModifyColumnStr = "alter table modify column"

RenameStr = "rename"

TruncateTableStr = "truncate table"

)

// Format formats the node.

func (node *DDL) Format(buf *TrackedBuffer) {

switch node.Action {

case CreateDBStr:

ifnotexists := ""

if node.IfNotExists {

ifnotexists = " if not exists"

}

buf.Myprintf("%s%s %s", node.Action, ifnotexists, node.Database.String())

case DropDBStr:

exists := ""

if node.IfExists {

exists = " if exists"

}

buf.Myprintf("%s%s %s", node.Action, exists, node.Database.String())

case CreateTableStr:

ifnotexists := ""

if node.IfNotExists {

ifnotexists = " if not exists"

}

if node.TableSpec == nil {

buf.Myprintf("%s%s %v", node.Action, ifnotexists, node.NewName)

} else {

buf.Myprintf("%s%s %v %v", node.Action, ifnotexists, node.NewName, node.TableSpec)

}

case CreateIndexStr:

buf.Myprintf("%s %s on %v", node.Action, node.IndexName, node.NewName)

case DropTableStr:

exists := ""

if node.IfExists {

exists = " if exists"

}

buf.Myprintf("%s%s %v", node.Action, exists, node.Table)

case DropIndexStr:

buf.Myprintf("%s %s on %v", node.Action, node.IndexName, node.Table)

case RenameStr:

buf.Myprintf("%s %v %v", node.Action, node.Table, node.NewName)

case AlterStr:

buf.Myprintf("%s table %v", node.Action, node.NewName)

case AlterEngineStr:

buf.Myprintf("%s %v engine = %s", node.Action, node.NewName, node.Engine)

case AlterCharsetStr:

buf.Myprintf("alter table %v convert to character set %s", node.NewName, node.Charset)

case AlterAddColumnStr:

buf.Myprintf("alter table %v add column %v", node.NewName, node.TableSpec)

case AlterDropColumnStr:

buf.Myprintf("alter table %v drop column `%s`", node.NewName, node.DropColumnName)

case AlterModifyColumnStr:

buf.Myprintf("alter table %v modify column %v", node.NewName, node.ModifyColumnDef)

case TruncateTableStr:

buf.Myprintf("%s %v", node.Action, node.NewName)

}

}

// WalkSubtree walks the nodes of the subtree.

func (node *DDL) WalkSubtree(visit Visit) error {

if node == nil {

return nil

}

return Walk(

visit,

node.Table,

node.NewName,

)

}

// TableOptions represents the table options.

type TableOptions struct {

Engine string

Charset string

}

// Format formats the node.

func (opts TableOptions) Format(buf *TrackedBuffer) {

if opts.Engine != "" {

buf.Myprintf(" engine=%s", opts.Engine)

}

if opts.Charset != "" {

buf.Myprintf(" default charset=%s", opts.Charset)

}

}

// WalkSubtree walks the nodes of the subtree.

func (opts TableOptions) WalkSubtree(visit Visit) error {

return nil

}

// TableSpec describes the structure of a table from a CREATE TABLE statement

type TableSpec struct {

Columns []*ColumnDefinition

Indexes []*IndexDefinition

Options TableOptions

}

// Format formats the node.

func (ts *TableSpec) Format(buf *TrackedBuffer) {

buf.Myprintf("(\n")

for i, col := range ts.Columns {

if i == 0 {

buf.Myprintf("\t%v", col)

} else {

buf.Myprintf(",\n\t%v", col)

}

}

for _, idx := range ts.Indexes {

buf.Myprintf(",\n\t%v", idx)

}

buf.Myprintf("\n)%v", ts.Options)

}

// AddColumn appends the given column to the list in the spec

func (ts *TableSpec) AddColumn(cd *ColumnDefinition) {

ts.Columns = append(ts.Columns, cd)

}

// AddIndex appends the given index to the list in the spec

func (ts *TableSpec) AddIndex(id *IndexDefinition) {

ts.Indexes = append(ts.Indexes, id)

}

// WalkSubtree walks the nodes of the subtree.

func (ts *TableSpec) WalkSubtree(visit Visit) error {

if ts == nil {

return nil

}

for _, n := range ts.Columns {

if err := Walk(visit, n); err != nil {

return err

}

}

for _, n := range ts.Indexes {

if err := Walk(visit, n); err != nil {

return err

}

}

return nil

}

// ColumnDefinition describes a column in a CREATE TABLE statement

type ColumnDefinition struct {

Name ColIdent

Type ColumnType

}

// Format formats the node.

func (col *ColumnDefinition) Format(buf *TrackedBuffer) {

buf.Myprintf("`%s` %v", col.Name.String(), &col.Type)

}

// WalkSubtree walks the nodes of the subtree.

func (col *ColumnDefinition) WalkSubtree(visit Visit) error {

if col == nil {

return nil

}

return Walk(

visit,

col.Name,

&col.Type,

)

}

// ColumnType represents a sql type in a CREATE TABLE statement

// All optional fields are nil if not specified

type ColumnType struct {

// The base type string

Type string

// Generic field options.

NotNull BoolVal

Autoincrement BoolVal

Default *SQLVal

Comment *SQLVal

// Numeric field options

Length *SQLVal

Unsigned BoolVal

Zerofill BoolVal

Scale *SQLVal

// Text field options

Charset string

Collate string

// Enum values

EnumValues []string

// Key specification

KeyOpt ColumnKeyOption

}

// Format returns a canonical string representation of the type and all relevant options

func (ct *ColumnType) Format(buf *TrackedBuffer) {

buf.Myprintf("%s", ct.Type)

if ct.Length != nil && ct.Scale != nil {

buf.Myprintf("(%v,%v)", ct.Length, ct.Scale)

} else if ct.Length != nil {

buf.Myprintf("(%v)", ct.Length)

}

if ct.EnumValues != nil {

buf.Myprintf("(%s)", strings.Join(ct.EnumValues, ", "))

}

opts := make([]string, 0, 16)

if ct.Unsigned {

opts = append(opts, keywordStrings[UNSIGNED])

}

if ct.Zerofill {

opts = append(opts, keywordStrings[ZEROFILL])

}

if ct.Charset != "" {

opts = append(opts, keywordStrings[CHARACTER], keywordStrings[SET], ct.Charset)

}

if ct.Collate != "" {

opts = append(opts, keywordStrings[COLLATE], ct.Collate)

}

if ct.NotNull {

opts = append(opts, keywordStrings[NOT], keywordStrings[NULL])

}

if ct.Default != nil {

opts = append(opts, keywordStrings[DEFAULT], String(ct.Default))

}

if ct.Autoincrement {

opts = append(opts, keywordStrings[AUTO_INCREMENT])

}

if ct.Comment != nil {

opts = append(opts, keywordStrings[COMMENT_KEYWORD], String(ct.Comment))

}

if ct.KeyOpt == ColKeyPrimary {

opts = append(opts, keywordStrings[PRIMARY], keywordStrings[KEY])

}

if ct.KeyOpt == ColKeyUnique {

opts = append(opts, keywordStrings[UNIQUE])

}

if ct.KeyOpt == ColKeyUniqueKey {

opts = append(opts, keywordStrings[UNIQUE], keywordStrings[KEY])

}

if ct.KeyOpt == ColKey {

opts = append(opts, keywordStrings[KEY])

}

if len(opts) != 0 {

buf.Myprintf(" %s", strings.Join(opts, " "))

}

}

// WalkSubtree walks the nodes of the subtree.

func (ct *ColumnType) WalkSubtree(visit Visit) error {

return nil

}

// IndexDefinition describes an index in a CREATE TABLE statement

type IndexDefinition struct {

Info *IndexInfo

Columns []*IndexColumn

}

// Format formats the node.

func (idx *IndexDefinition) Format(buf *TrackedBuffer) {

buf.Myprintf("%v (", idx.Info)

for i, col := range idx.Columns {

if i != 0 {

buf.Myprintf(", `%s`", col.Column.String())

} else {

buf.Myprintf("`%s`", col.Column.String())

}

if col.Length != nil {

buf.Myprintf("(%v)", col.Length)

}

}

buf.Myprintf(")")

}

// WalkSubtree walks the nodes of the subtree.

func (idx *IndexDefinition) WalkSubtree(visit Visit) error {

if idx == nil {

return nil

}

for _, n := range idx.Columns {

if err := Walk(visit, n.Column); err != nil {

return err

}

}

return nil

}

// IndexInfo describes the name and type of an index in a CREATE TABLE statement

type IndexInfo struct {

Type string

Name ColIdent

Primary bool

Unique bool

}

// Format formats the node.

func (ii *IndexInfo) Format(buf *TrackedBuffer) {

if ii.Primary {

buf.Myprintf("%s", ii.Type)

} else {

buf.Myprintf("%s `%v`", ii.Type, ii.Name)

}

}

// WalkSubtree walks the nodes of the subtree.

func (ii *IndexInfo) WalkSubtree(visit Visit) error {

return Walk(visit, ii.Name)

}

// IndexColumn describes a column in an index definition with optional length

type IndexColumn struct {

Column ColIdent

Length *SQLVal

}

// LengthScaleOption is used for types that have an optional length

// and scale

type LengthScaleOption struct {

Length *SQLVal

Scale *SQLVal

}

// ColumnKeyOption indicates whether or not the given column is defined as an

// index element and contains the type of the option

type ColumnKeyOption int

const (

// ColKeyNone enum.

ColKeyNone ColumnKeyOption = iota

// ColKeyPrimary enum.

ColKeyPrimary

// ColKeyUnique enum.

ColKeyUnique

// ColKeyUniqueKey enum.

ColKeyUniqueKey

// ColKey enum.

ColKey

)

// Show represents a show statement.

type Show struct {

Type string

Table TableName

Database TableName

From string

Limit *Limit

}

// The frollowing constants represent SHOW statements.

const (

ShowDatabasesStr = "databases"

ShowCreateDatabaseStr = "create database"

ShowTablesStr = "tables"

ShowTablesFromStr = "tables from"

ShowCreateTableStr = "create table"

ShowEnginesStr = "engines"

ShowStatusStr = "status"

ShowVersionsStr = "versions"

ShowProcesslistStr = "processlist"

ShowQueryzStr = "queryz"

ShowTxnzStr = "txnz"

ShowWarningsStr = "warnings"

ShowVariablesStr = "variables"

ShowBinlogEventsStr = "binlog events"

ShowUnsupportedStr = "unsupported"

)

// Format formats the node.

func (node *Show) Format(buf *TrackedBuffer) {

switch node.Type {

case ShowCreateDatabaseStr:

buf.Myprintf("show %s %v", node.Type, node.Database)

case ShowCreateTableStr:

buf.Myprintf("show %s %v", node.Type, node.Table)

case ShowTablesFromStr:

buf.Myprintf("show %s %v", node.Type, node.Database)

case ShowBinlogEventsStr:

buf.Myprintf("show %s", node.Type)

if node.From != "" {

buf.Myprintf(" from gtid '%s'", node.From)

}

buf.Myprintf("%v", node.Limit)

default:

buf.Myprintf("show %s", node.Type)

}

}

// WalkSubtree walks the nodes of the subtree.

func (node *Show) WalkSubtree(visit Visit) error {

return nil

}

// Use represents a use statement.

type Use struct {

DBName TableIdent

}

// Format formats the node.

func (node *Use) Format(buf *TrackedBuffer) {

buf.Myprintf("use %v", node.DBName)

}

// WalkSubtree walks the nodes of the subtree.

func (node *Use) WalkSubtree(visit Visit) error {

return Walk(visit, node.DBName)

}

// OtherRead represents a DESCRIBE, or EXPLAIN statement.

// It should be used only as an indicator. It does not contain

// the full AST for the statement.

type OtherRead struct{}

// Format formats the node.

func (node *OtherRead) Format(buf *TrackedBuffer) {

buf.WriteString("otherread")

}

// WalkSubtree walks the nodes of the subtree.

func (node *OtherRead) WalkSubtree(visit Visit) error {

return nil

}

// OtherAdmin represents a misc statement that relies on ADMIN privileges,

// such as REPAIR, OPTIMIZE, or TRUNCATE statement.

// It should be used only as an indicator. It does not contain

// the full AST for the statement.

type OtherAdmin struct{}

// Format formats the node.

func (node *OtherAdmin) Format(buf *TrackedBuffer) {

buf.WriteString("otheradmin")

}

// WalkSubtree walks the nodes of the subtree.

func (node *OtherAdmin) WalkSubtree(visit Visit) error {

return nil

}

// Comments represents a list of comments.

type Comments [][]byte

// Format formats the node.

func (node Comments) Format(buf *TrackedBuffer) {

for _, c := range node {

buf.Myprintf("%s ", c)

}

}

// WalkSubtree walks the nodes of the subtree.

func (node Comments) WalkSubtree(visit Visit) error {

return nil

}

// SelectExprs represents SELECT expressions.

type SelectExprs []SelectExpr

// Format formats the node.

func (node SelectExprs) Format(buf *TrackedBuffer) {

var prefix string

for _, n := range node {

buf.Myprintf("%s%v", prefix, n)

prefix = ", "

}

}

// WalkSubtree walks the nodes of the subtree.

func (node SelectExprs) WalkSubtree(visit Visit) error {

for _, n := range node {

if err := Walk(visit, n); err != nil {

return err

}

}

return nil

}