package sql

import (

"bytes"

"fmt"

"strings"

)

type Node interface {

node()

fmt.Stringer

}

func (*AlterTableStatement) node() {}

func (*AnalyzeStatement) node() {}

func (*Assignment) node() {}

func (*BeginStatement) node() {}

func (*BinaryExpr) node() {}

func (*BindExpr) node() {}

func (*BlobLit) node() {}

func (*BoolLit) node() {}

func (*Call) node() {}

func (*CaseBlock) node() {}

func (*CaseExpr) node() {}

func (*CastExpr) node() {}

func (*CheckConstraint) node() {}

func (*CollateConstraint) node() {}

func (*CollateExpr) node() {}

func (*ColumnDefinition) node() {}

func (*CommitStatement) node() {}

func (*CreateIndexStatement) node() {}

func (*CreateTableStatement) node() {}

func (*CreateTriggerStatement) node() {}

func (*CreateViewStatement) node() {}

func (*CreateVirtualTableStatement) node() {}

func (*DefaultConstraint) node() {}

func (*DeleteStatement) node() {}

func (*DropIndexStatement) node() {}

func (*DropTableStatement) node() {}

func (*DropTriggerStatement) node() {}

func (*DropViewStatement) node() {}

func (*Exists) node() {}

func (*ExplainStatement) node() {}

func (*ExprList) node() {}

func (*FilterClause) node() {}

func (*ForeignKeyArg) node() {}

func (*ForeignKeyConstraint) node() {}

func (*FrameSpec) node() {}

func (*GeneratedConstraint) node() {}

func (*Ident) node() {}

func (*IndexedColumn) node() {}

func (*InsertStatement) node() {}

func (*JoinClause) node() {}

func (*JoinOperator) node() {}

func (*ModuleArgument) node() {}

func (*NotNullConstraint) node() {}

func (*Null) node() {}

func (*NullLit) node() {}

func (*NumberLit) node() {}

func (*OnConstraint) node() {}

func (*OrderingTerm) node() {}

func (*OverClause) node() {}

func (*ParenExpr) node() {}

func (*ParenSource) node() {}

func (*PragmaStatement) node() {}

func (*PrimaryKeyConstraint) node() {}

func (*QualifiedRef) node() {}

func (*QualifiedTableName) node() {}

func (*QualifiedTableFunctionName) node() {}

func (*Raise) node() {}

func (*Range) node() {}

func (*ReindexStatement) node() {}

func (*ReleaseStatement) node() {}

func (*ResultColumn) node() {}

func (*ReturningClause) node() {}

func (*RollbackStatement) node() {}

func (*SavepointStatement) node() {}

func (*SelectStatement) node() {}

func (*StringLit) node() {}

func (*TimestampLit) node() {}

func (*Type) node() {}

func (*UnaryExpr) node() {}

func (*UniqueConstraint) node() {}

func (*UpdateStatement) node() {}

func (*UpsertClause) node() {}

func (*UsingConstraint) node() {}

func (*Window) node() {}

func (*WindowDefinition) node() {}

func (*WithClause) node() {}

func (*CTE) node() {}

type Statement interface {

Node

stmt()

}

func (*AlterTableStatement) stmt() {}

func (*AnalyzeStatement) stmt() {}

func (*BeginStatement) stmt() {}

func (*CommitStatement) stmt() {}

func (*CreateIndexStatement) stmt() {}

func (*CreateTableStatement) stmt() {}

func (*CreateTriggerStatement) stmt() {}

func (*CreateViewStatement) stmt() {}

func (*CreateVirtualTableStatement) stmt() {}

func (*DeleteStatement) stmt() {}

func (*DropIndexStatement) stmt() {}

func (*DropTableStatement) stmt() {}

func (*DropTriggerStatement) stmt() {}

func (*DropViewStatement) stmt() {}

func (*ExplainStatement) stmt() {}

func (*InsertStatement) stmt() {}

func (*PragmaStatement) stmt() {}

func (*ReindexStatement) stmt() {}

func (*ReleaseStatement) stmt() {}

func (*RollbackStatement) stmt() {}

func (*SavepointStatement) stmt() {}

func (*SelectStatement) stmt() {}

func (*UpdateStatement) stmt() {}

// CloneStatement returns a deep copy stmt.

func CloneStatement(stmt Statement) Statement {

if stmt == nil {

return nil

}

switch stmt := stmt.(type) {

case *AlterTableStatement:

return stmt.Clone()

case *AnalyzeStatement:

return stmt.Clone()

case *BeginStatement:

return stmt.Clone()

case *CommitStatement:

return stmt.Clone()

case *CreateIndexStatement:

return stmt.Clone()

case *CreateTableStatement:

return stmt.Clone()

case *CreateTriggerStatement:

return stmt.Clone()

case *CreateViewStatement:

return stmt.Clone()

case *CreateVirtualTableStatement:

return stmt.Clone()

case *DeleteStatement:

return stmt.Clone()

case *DropIndexStatement:

return stmt.Clone()

case *DropTableStatement:

return stmt.Clone()

case *DropTriggerStatement:

return stmt.Clone()

case *DropViewStatement:

return stmt.Clone()

case *ExplainStatement:

return stmt.Clone()

case *PragmaStatement:

return stmt.Clone()

case *InsertStatement:

return stmt.Clone()

case *ReindexStatement:

return stmt.Clone()

case *ReleaseStatement:

return stmt.Clone()

case *RollbackStatement:

return stmt.Clone()

case *SavepointStatement:

return stmt.Clone()

case *SelectStatement:

return stmt.Clone()

case *UpdateStatement:

return stmt.Clone()

default:

panic(fmt.Sprintf("invalid statement type: %T", stmt))

}

}

func cloneStatements(a []Statement) []Statement {

if a == nil {

return nil

}

other := make([]Statement, len(a))

for i := range a {

other[i] = CloneStatement(a[i])

}

return other

}

// StatementSource returns the root statement for a statement.

func StatementSource(stmt Statement) Source {

switch stmt := stmt.(type) {

case *SelectStatement:

return stmt.Source

case *UpdateStatement:

return stmt.Table

case *DeleteStatement:

return stmt.Table

default:

return nil

}

}

type Expr interface {

Node

expr()

}

func (*BinaryExpr) expr() {}

func (*BindExpr) expr() {}

func (*BlobLit) expr() {}

func (*BoolLit) expr() {}

func (*Call) expr() {}

func (*CaseExpr) expr() {}

func (*CastExpr) expr() {}

func (*CollateExpr) expr() {}

func (*Exists) expr() {}

func (*Null) expr() {}

func (*ExprList) expr() {}

func (*Ident) expr() {}

func (*NullLit) expr() {}

func (*NumberLit) expr() {}

func (*ParenExpr) expr() {}

func (*QualifiedRef) expr() {}

func (*Raise) expr() {}

func (*Range) expr() {}

func (*StringLit) expr() {}

func (*TimestampLit) expr() {}

func (*UnaryExpr) expr() {}

func (SelectExpr) expr() {}

// CloneExpr returns a deep copy expr.

func CloneExpr(expr Expr) Expr {

if expr == nil {

return nil

}

switch expr := expr.(type) {

case *BinaryExpr:

return expr.Clone()

case *BindExpr:

return expr.Clone()

case *BlobLit:

return expr.Clone()

case *BoolLit:

return expr.Clone()

case *Call:

return expr.Clone()

case *CaseExpr:

return expr.Clone()

case *CastExpr:

return expr.Clone()

case *CollateExpr:

return expr.Clone()

case *Exists:

return expr.Clone()

case *Null:

return expr.Clone()

case *ExprList:

return expr.Clone()

case *Ident:

return expr.Clone()

case *NullLit:

return expr.Clone()

case *NumberLit:

return expr.Clone()

case *ParenExpr:

return expr.Clone()

case *QualifiedRef:

return expr.Clone()

case *Raise:

return expr.Clone()

case *Range:

return expr.Clone()

case *StringLit:

return expr.Clone()

case *TimestampLit:

return expr.Clone()

case *UnaryExpr:

return expr.Clone()

case SelectExpr:

return expr.Clone()

default:

panic(fmt.Sprintf("invalid expr type: %T", expr))

}

}

func cloneExprs(a []Expr) []Expr {

if a == nil {

return nil

}

other := make([]Expr, len(a))

for i := range a {

other[i] = CloneExpr(a[i])

}

return other

}

// ExprString returns the string representation of expr.

// Returns a blank string if expr is nil.

func ExprString(expr Expr) string {

if expr == nil {

return ""

}

return expr.String()

}

// SplitExprTree splits apart expr so it is a list of all AND joined expressions.

// For example, the expression "A AND B AND (C OR (D AND E))" would be split into

// a list of "A", "B", "C OR (D AND E)".

func SplitExprTree(expr Expr) []Expr {

if expr == nil {

return nil

}

var a []Expr

splitExprTree(expr, &a)

return a

}

func splitExprTree(expr Expr, a *[]Expr) {

switch expr := expr.(type) {

case *BinaryExpr:

if expr.Op != AND {

*a = append(*a, expr)

return

}

splitExprTree(expr.X, a)

splitExprTree(expr.Y, a)

case *ParenExpr:

splitExprTree(expr.X, a)

default:

*a = append(*a, expr)

}

}

// Scope represents a context for name resolution.

// Names can be resolved at the current source or in parent scopes.

type Scope struct {

Parent *Scope

Source Source

}

// Source represents a table or subquery.

type Source interface {

Node

source()

}

func (*JoinClause) source() {}

func (*ParenSource) source() {}

func (*QualifiedTableName) source() {}

func (*QualifiedTableFunctionName) source() {}

func (*SelectStatement) source() {}

// CloneSource returns a deep copy src.

func CloneSource(src Source) Source {

if src == nil {

return nil

}

switch src := src.(type) {

case *JoinClause:

return src.Clone()

case *ParenSource:

return src.Clone()

case *QualifiedTableName:

return src.Clone()

case *QualifiedTableFunctionName:

return src.Clone()

case *SelectStatement:

return src.Clone()

default:

panic(fmt.Sprintf("invalid source type: %T", src))

}

}

// SourceName returns the name of the source.

// Only returns for QualifiedTableName & ParenSource.

func SourceName(src Source) string {

switch src := src.(type) {

case *JoinClause, *SelectStatement:

return ""

case *ParenSource:

return IdentName(src.Alias)

case *QualifiedTableName:

return src.TableName()

default:

return ""

}

}

// SourceList returns a list of scopes in the current scope.

func SourceList(src Source) []Source {

var a []Source

ForEachSource(src, func(s Source) bool {

a = append(a, s)

return true

})

return a

}

// ForEachSource calls fn for every source within the current scope.

// Stops iteration if fn returns false.

func ForEachSource(src Source, fn func(Source) bool) {

forEachSource(src, fn)

}

func forEachSource(src Source, fn func(Source) bool) bool {

if !fn(src) {

return false

}

switch src := src.(type) {

case *JoinClause:

if !forEachSource(src.X, fn) {

return false

} else if !forEachSource(src.Y, fn) {

return false

}

case *SelectStatement:

if !forEachSource(src.Source, fn) {

return false

}

}

return true

}

// ResolveSource returns a source with the given name.

// This can either be the table name or the alias for a source.

func ResolveSource(root Source, name string) Source {

var ret Source

ForEachSource(root, func(src Source) bool {

switch src := src.(type) {

case *ParenSource:

if IdentName(src.Alias) == name {

ret = src

}

case *QualifiedTableName:

if src.TableName() == name {

ret = src

}

}

return ret == nil // continue until we find the matching source

})

return ret

}

// JoinConstraint represents either an ON or USING join constraint.

type JoinConstraint interface {

Node

joinConstraint()

}

func (*OnConstraint) joinConstraint() {}

func (*UsingConstraint) joinConstraint() {}

// CloneJoinConstraint returns a deep copy cons.

func CloneJoinConstraint(cons JoinConstraint) JoinConstraint {

if cons == nil {

return nil

}

switch cons := cons.(type) {

case *OnConstraint:

return cons.Clone()

case *UsingConstraint:

return cons.Clone()

default:

panic(fmt.Sprintf("invalid join constraint type: %T", cons))

}

}

type ExplainStatement struct {

Explain Pos // position of EXPLAIN

Query Pos // position of QUERY (optional)

QueryPlan Pos // position of PLAN after QUERY (optional)

Stmt Statement // target statement

}

// Clone returns a deep copy of s.

func (s *ExplainStatement) Clone() *ExplainStatement {

if s == nil {

return nil

}

other := *s

other.Stmt = CloneStatement(s.Stmt)

return &other

}

// String returns the string representation of the statement.

func (s *ExplainStatement) String() string {

var buf bytes.Buffer

buf.WriteString("EXPLAIN")

if s.QueryPlan.IsValid() {

buf.WriteString(" QUERY PLAN")

}

fmt.Fprintf(&buf, " %s", s.Stmt.String())

return buf.String()

}

type BeginStatement struct {

Begin Pos // position of BEGIN

Deferred Pos // position of DEFERRED keyword

Immediate Pos // position of IMMEDIATE keyword

Exclusive Pos // position of EXCLUSIVE keyword

Transaction Pos // position of TRANSACTION keyword (optional)

}

// Clone returns a deep copy of s.

func (s *BeginStatement) Clone() *BeginStatement {

if s == nil {

return nil

}

other := *s

return &other

}

// String returns the string representation of the statement.

func (s *BeginStatement) String() string {

var buf bytes.Buffer

buf.WriteString("BEGIN")

if s.Deferred.IsValid() {

buf.WriteString(" DEFERRED")

} else if s.Immediate.IsValid() {

buf.WriteString(" IMMEDIATE")

} else if s.Exclusive.IsValid() {

buf.WriteString(" EXCLUSIVE")

}

if s.Transaction.IsValid() {

buf.WriteString(" TRANSACTION")

}

return buf.String()

}

type CommitStatement struct {

Commit Pos // position of COMMIT keyword

End Pos // position of END keyword

Transaction Pos // position of TRANSACTION keyword (optional)

}

// Clone returns a deep copy of s.

func (s *CommitStatement) Clone() *CommitStatement {

if s == nil {

return nil

}

other := *s

return &other

}

// String returns the string representation of the statement.

func (s *CommitStatement) String() string {

var buf bytes.Buffer

if s.End.IsValid() {

buf.WriteString("END")

} else {

buf.WriteString("COMMIT")

}

if s.Transaction.IsValid() {

buf.WriteString(" TRANSACTION")

}

return buf.String()

}

type RollbackStatement struct {

Rollback Pos // position of ROLLBACK keyword

Transaction Pos // position of TRANSACTION keyword (optional)

To Pos // position of TO keyword (optional)

Savepoint Pos // position of SAVEPOINT keyword (optional)

SavepointName *Ident // name of savepoint

}

// Clone returns a deep copy of s.

func (s *RollbackStatement) Clone() *RollbackStatement {

if s == nil {

return s

}

other := *s

other.SavepointName = s.SavepointName.Clone()

return &other

}

// String returns the string representation of the statement.

func (s *RollbackStatement) String() string {

var buf bytes.Buffer

buf.WriteString("ROLLBACK")

if s.Transaction.IsValid() {

buf.WriteString(" TRANSACTION")

}

if s.SavepointName != nil {

buf.WriteString(" TO")

if s.Savepoint.IsValid() {

buf.WriteString(" SAVEPOINT")

}

fmt.Fprintf(&buf, " %s", s.SavepointName.String())

}

return buf.String()

}

type SavepointStatement struct {

Savepoint Pos // position of SAVEPOINT keyword

Name *Ident // name of savepoint

}

// Clone returns a deep copy of s.

func (s *SavepointStatement) Clone() *SavepointStatement {

if s == nil {

return s

}

other := *s

other.Name = s.Name.Clone()

return &other

}

// String returns the string representation of the statement.

func (s *SavepointStatement) String() string {

return fmt.Sprintf("SAVEPOINT %s", s.Name.String())

}

type ReleaseStatement struct {

Release Pos // position of RELEASE keyword

Savepoint Pos // position of SAVEPOINT keyword (optional)

Name *Ident // name of savepoint

}

// Clone returns a deep copy of s.

func (s *ReleaseStatement) Clone() *ReleaseStatement {

if s == nil {

return s

}

other := *s

other.Name = s.Name.Clone()

return &other

}

// String returns the string representation of the statement.

func (s *ReleaseStatement) String() string {

var buf bytes.Buffer

buf.WriteString("RELEASE")

if s.Savepoint.IsValid() {

buf.WriteString(" SAVEPOINT")

}

fmt.Fprintf(&buf, " %s", s.Name.String())

return buf.String()

}

type CreateTableStatement struct {

Create Pos // position of CREATE keyword

Temp Pos // position of TEMP or TEMPORARY keyword (optional)

Table Pos // position of TABLE keyword

If Pos // position of IF keyword (optional)

IfNot Pos // position of NOT keyword (optional)

IfNotExists Pos // position of EXISTS keyword (optional)

Schema *Ident // optional schema name

Name *Ident // table name

Lparen Pos // position of left paren of column list

Columns []*ColumnDefinition // column definitions

Constraints []Constraint // table constraints

Rparen Pos // position of right paren of column list

Without Pos // position of WITHOUT keyword (optional)

Rowid Pos // position of ROWID keyword (optional)

Strict Pos // position of STRICT keyword (optional)

As Pos // position of AS keyword (optional)

Select *SelectStatement // select stmt to build from

}

// Clone returns a deep copy of s.

func (s *CreateTableStatement) Clone() *CreateTableStatement {

if s == nil {

return s

}

other := *s

other.Schema = s.Schema.Clone()

other.Name = s.Name.Clone()

other.Columns = cloneColumnDefinitions(s.Columns)

other.Constraints = cloneConstraints(s.Constraints)

other.Select = s.Select.Clone()

return &other

}

// String returns the string representation of the statement.

func (s *CreateTableStatement) String() string {

var buf bytes.Buffer

buf.WriteString("CREATE")

if s.Temp.IsValid() {

buf.WriteString(" TEMP")

}

buf.WriteString(" TABLE")

if s.IfNotExists.IsValid() {

buf.WriteString(" IF NOT EXISTS")

}

buf.WriteString(" ")

if s.Schema != nil {

buf.WriteString(s.Schema.String())

buf.WriteString(".")

}

buf.WriteString(s.Name.String())

if s.Select != nil {

buf.WriteString(" AS ")

buf.WriteString(s.Select.String())

} else {

buf.WriteString(" (")

for i := range s.Columns {

if i != 0 {

buf.WriteString(", ")

}

buf.WriteString(s.Columns[i].String())

}

for i := range s.Constraints {

buf.WriteString(", ")

buf.WriteString(s.Constraints[i].String())

}

buf.WriteString(")")

// Table options.

if s.Without.IsValid() {

buf.WriteString(" WITHOUT ROWID")

if s.Strict.IsValid() {

buf.WriteString(", STRICT")

}

} else if s.Strict.IsValid() {

buf.WriteString(" STRICT")

}

}

return buf.String()

}

type ColumnDefinition struct {

Name *Ident // column name

Type *Type // data type

Constraints []Constraint // column constraints

}

// Clone returns a deep copy of d.

func (d *ColumnDefinition) Clone() *ColumnDefinition {

if d == nil {

return d

}

other := *d

other.Name = d.Name.Clone()

other.Type = d.Type.Clone()

other.Constraints = cloneConstraints(d.Constraints)

return &other

}

func cloneColumnDefinitions(a []*ColumnDefinition) []*ColumnDefinition {

if a == nil {

return nil

}

other := make([]*ColumnDefinition, len(a))

for i := range a {

other[i] = a[i].Clone()

}

return other

}

// String returns the string representation of the statement.

func (c *ColumnDefinition) String() string {

var buf bytes.Buffer

buf.WriteString(c.Name.String())

if c.Type != nil {

buf.WriteString(" ")

buf.WriteString(c.Type.String())

}

for i := range c.Constraints {

buf.WriteString(" ")

buf.WriteString(c.Constraints[i].String())

}

return buf.String()

}

type Constraint interface {

Node

constraint()

}

func (*PrimaryKeyConstraint) constraint() {}

func (*NotNullConstraint) constraint() {}

func (*UniqueConstraint) constraint() {}

func (*CheckConstraint) constraint() {}

func (*DefaultConstraint) constraint() {}

func (*GeneratedConstraint) constraint() {}

func (*CollateConstraint) constraint() {}

func (*ForeignKeyConstraint) constraint() {}

// CloneConstraint returns a deep copy cons.

func CloneConstraint(cons Constraint) Constraint {

if cons == nil {

return nil

}

switch cons := cons.(type) {

case *PrimaryKeyConstraint:

return cons.Clone()

case *NotNullConstraint:

return cons.Clone()

case *UniqueConstraint:

return cons.Clone()

case *CheckConstraint:

return cons.Clone()

case *DefaultConstraint:

return cons.Clone()

case *GeneratedConstraint:

return cons.Clone()

case *CollateConstraint:

return cons.Clone()

case *ForeignKeyConstraint:

return cons.Clone()

default:

panic(fmt.Sprintf("invalid constraint type: %T", cons))

}

}

func cloneConstraints(a []Constraint) []Constraint {

if a == nil {

return nil

}

other := make([]Constraint, len(a))

for i := range a {

other[i] = CloneConstraint(a[i])

}

return other

}

type PrimaryKeyConstraint struct {

Constraint Pos // position of CONSTRAINT keyword

Name *Ident // constraint name

Primary Pos // position of PRIMARY keyword

Key Pos // position of KEY keyword

Lparen Pos // position of left paren (table only)

Columns []*Ident // indexed columns (table only)

Rparen Pos // position of right paren (table only)

Asc Pos // position of ASC keyword (column only)

Desc Pos // position of DESC keyword (column only)

Conflict *ConflictClause // optional ON CONFLICT clause

Autoincrement Pos // position of AUTOINCREMENT keyword (column only)

}

// Clone returns a deep copy of c.

func (c *PrimaryKeyConstraint) Clone() *PrimaryKeyConstraint {

if c == nil {

return c

}

other := *c

other.Name = c.Name.Clone()

other.Columns = cloneIdents(c.Columns)

other.Conflict = c.Conflict.Clone()

return &other

}

// String returns the string representation of the constraint.

func (c *PrimaryKeyConstraint) String() string {

var buf bytes.Buffer

if c.Name != nil {

buf.WriteString("CONSTRAINT ")

buf.WriteString(c.Name.String())

buf.WriteString(" ")

}

buf.WriteString("PRIMARY KEY")

if len(c.Columns) > 0 {

buf.WriteString(" (")

for i := range c.Columns {

if i != 0 {

buf.WriteString(", ")

}

buf.WriteString(c.Columns[i].String())

}

buf.WriteString(")")

}

if c.Asc.IsValid() {

buf.WriteString(" ASC")

} else if c.Desc.IsValid() {

buf.WriteString(" DESC")

}

if c.Conflict != nil {

buf.WriteString(" ")

buf.WriteString(c.Conflict.String())

}

if c.Autoincrement.IsValid() {

buf.WriteString(" AUTOINCREMENT")

}

return buf.String()

}

type NotNullConstraint struct {

Constraint Pos // position of CONSTRAINT keyword

Name *Ident // constraint name

Not Pos // position of NOT keyword

Null Pos // position of NULL keyword

Conflict *ConflictClause // optional ON CONFLICT clause

}

// Clone returns a deep copy of c.

func (c *NotNullConstraint) Clone() *NotNullConstraint {

if c == nil {

return c

}

other := *c

other.Name = c.Name.Clone()

other.Conflict = c.Conflict.Clone()

return &other

}

// String returns the string representation of the constraint.

func (c *NotNullConstraint) String() string {

var buf bytes.Buffer

if c.Name != nil {

buf.WriteString("CONSTRAINT ")

buf.WriteString(c.Name.String())

buf.WriteString(" ")

}

buf.WriteString("NOT NULL")

if c.Conflict != nil {

buf.WriteString(" ")

buf.WriteString(c.Conflict.String())

}

return buf.String()

}

type UniqueConstraint struct {

Constraint Pos // position of CONSTRAINT keyword

Name *Ident // constraint name

Unique Pos // position of UNIQUE keyword

Lparen Pos // position of left paren (table only)

Columns []*IndexedColumn // indexed columns (table only)

Rparen Pos // position of right paren (table only)

Conflict *ConflictClause // optional ON CONFLICT clause

}

// Clone returns a deep copy of c.

func (c *UniqueConstraint) Clone() *UniqueConstraint {

if c == nil {

return c

}

other := *c

other.Name = c.Name.Clone()

other.Columns = make([]*IndexedColumn, len(c.Columns))

for i := range c.Columns {

other.Columns[i] = c.Columns[i].Clone()

}

other.Conflict = c.Conflict.Clone()

return &other

}

// String returns the string representation of the constraint.

func (c *UniqueConstraint) String() string {

var buf bytes.Buffer

if c.Name != nil {

buf.WriteString("CONSTRAINT ")

buf.WriteString(c.Name.String())

buf.WriteString(" ")

}

buf.WriteString("UNIQUE")

if len(c.Columns) > 0 {

buf.WriteString(" (")

for i := range c.Columns {

if i != 0 {

buf.WriteString(", ")

}

buf.WriteString(c.Columns[i].String())

}

buf.WriteString(")")

}

if c.Conflict != nil {

buf.WriteString(" ")

buf.WriteString(c.Conflict.String())

}

return buf.String()

}

// ConflictClause represents an ON CONFLICT clause attached to a PRIMARY KEY,

// NOT NULL or UNIQUE constraint. Exactly one of the resolution positions is

// set.

type ConflictClause struct {

On Pos // position of ON keyword

Conflict Pos // position of CONFLICT keyword