From c789a5b1e358be41e5102c03eab6ecdd7fddb57d Mon Sep 17 00:00:00 2001 From: Kyle Conroy Date: Thu, 18 Mar 2021 22:18:12 -0700 Subject: [PATCH 01/11] A ton of errors --- go.mod | 3 +- go.sum | 21 +- internal/engine/postgresql/convert.go | 1514 +++++++++++++------------ internal/engine/postgresql/parse.go | 5 +- internal/engine/postgresql/utils.go | 2 +- 5 files changed, 789 insertions(+), 756 deletions(-) diff --git a/go.mod b/go.mod index a02216693b..fcb1f744c6 100644 --- a/go.mod +++ b/go.mod @@ -9,8 +9,9 @@ require ( github.com/google/go-cmp v0.5.5 github.com/jackc/pgx/v4 v4.10.1 github.com/jinzhu/inflection v1.0.0 - github.com/lfittl/pg_query_go v1.0.2 + github.com/kr/pretty v0.2.1 // indirect github.com/lib/pq v1.10.0 + github.com/pganalyze/pg_query_go/v2 v2.0.0 github.com/pingcap/parser v0.0.0-20201024025010-3b2fb4b41d73 github.com/spf13/cobra v1.1.3 github.com/spf13/pflag v1.0.5 diff --git a/go.sum b/go.sum index 7608f1c49d..6c096f3059 100644 --- a/go.sum +++ b/go.sum @@ -71,10 +71,20 @@ github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFU github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= @@ -181,8 +191,6 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/pty v1.1.8/go.mod h1:O1sed60cT9XZ5uDucP5qwvh+TE3NnUj51EiZO/lmSfw= github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= -github.com/lfittl/pg_query_go v1.0.2 h1:adHtAAb0LpoXI3cYqdJTbo5W682+V9vg3/8ONAhnhqE= -github.com/lfittl/pg_query_go v1.0.2/go.mod h1:Ch/Oiv5pRI5jf9M7Hvf0XwCvFwa4PWRcNoFcLtVU8pc= github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= github.com/lib/pq v1.1.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= @@ -216,6 +224,8 @@ github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRW github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U= github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= +github.com/pganalyze/pg_query_go/v2 v2.0.0 h1:wenHyJGXIX1/E6Q8ZeT546ZgzUjQDzHnDfmuYbAKXMU= +github.com/pganalyze/pg_query_go/v2 v2.0.0/go.mod h1:XAxmVqz1tEGqizcQ3YSdN90vCOHBWjJi8URL1er5+cA= github.com/pingcap/check v0.0.0-20190102082844-67f458068fc8 h1:USx2/E1bX46VG32FIw034Au6seQ2fY9NEILmNh/UlQg= github.com/pingcap/check v0.0.0-20190102082844-67f458068fc8/go.mod h1:B1+S9LNcuMyLH/4HMTViQOJevkGiik3wW2AN9zb2fNQ= github.com/pingcap/errors v0.11.0/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8= @@ -436,6 +446,13 @@ google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvx google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= +google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= +google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= +google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= diff --git a/internal/engine/postgresql/convert.go b/internal/engine/postgresql/convert.go index 3f83d66706..c5007e1977 100644 --- a/internal/engine/postgresql/convert.go +++ b/internal/engine/postgresql/convert.go @@ -3,12 +3,20 @@ package postgresql import ( - nodes "github.com/lfittl/pg_query_go/nodes" + pg "github.com/pganalyze/pg_query_go/v2" "github.com/kyleconroy/sqlc/internal/sql/ast" ) -func convertList(l nodes.List) *ast.List { +func makeByte(s string) byte { + var b byte + if s == "" { + return b + } + return []byte(s)[0] +} + +func convertList(l pg.List) *ast.List { out := &ast.List{} for _, item := range l.Items { out.Items = append(out.Items, convertNode(item)) @@ -16,7 +24,15 @@ func convertList(l nodes.List) *ast.List { return out } -func convertValuesList(l [][]nodes.Node) *ast.List { +func convertSlice(nodes []*pg.Node) *ast.List { + out := &ast.List{} + for _, n := range nodes { + out.Items = append(out.Items, convertNode(n)) + } + return out +} + +func convertValuesList(l [][]*pg.Node) *ast.List { out := &ast.List{} for _, outer := range l { o := &ast.List{} @@ -28,44 +44,44 @@ func convertValuesList(l [][]nodes.Node) *ast.List { return out } -func convert(node nodes.Node) (ast.Node, error) { +func convert(node *pg.Node) (ast.Node, error) { return convertNode(node), nil } -func convertA_ArrayExpr(n *nodes.A_ArrayExpr) *ast.A_ArrayExpr { +func convertA_ArrayExpr(n *pg.A_ArrayExpr) *ast.A_ArrayExpr { if n == nil { return nil } return &ast.A_ArrayExpr{ - Elements: convertList(n.Elements), - Location: n.Location, + Elements: convertSlice(n.Elements), + Location: int(n.Location), } } -func convertA_Const(n *nodes.A_Const) *ast.A_Const { +func convertA_Const(n *pg.A_Const) *ast.A_Const { if n == nil { return nil } return &ast.A_Const{ Val: convertNode(n.Val), - Location: n.Location, + Location: int(n.Location), } } -func convertA_Expr(n *nodes.A_Expr) *ast.A_Expr { +func convertA_Expr(n *pg.A_Expr) *ast.A_Expr { if n == nil { return nil } return &ast.A_Expr{ Kind: ast.A_Expr_Kind(n.Kind), - Name: convertList(n.Name), + Name: convertSlice(n.Name), Lexpr: convertNode(n.Lexpr), Rexpr: convertNode(n.Rexpr), - Location: n.Location, + Location: int(n.Location), } } -func convertA_Indices(n *nodes.A_Indices) *ast.A_Indices { +func convertA_Indices(n *pg.A_Indices) *ast.A_Indices { if n == nil { return nil } @@ -76,34 +92,34 @@ func convertA_Indices(n *nodes.A_Indices) *ast.A_Indices { } } -func convertA_Indirection(n *nodes.A_Indirection) *ast.A_Indirection { +func convertA_Indirection(n *pg.A_Indirection) *ast.A_Indirection { if n == nil { return nil } return &ast.A_Indirection{ Arg: convertNode(n.Arg), - Indirection: convertList(n.Indirection), + Indirection: convertSlice(n.Indirection), } } -func convertA_Star(n *nodes.A_Star) *ast.A_Star { +func convertA_Star(n *pg.A_Star) *ast.A_Star { if n == nil { return nil } return &ast.A_Star{} } -func convertAccessPriv(n *nodes.AccessPriv) *ast.AccessPriv { +func convertAccessPriv(n *pg.AccessPriv) *ast.AccessPriv { if n == nil { return nil } return &ast.AccessPriv{ - PrivName: n.PrivName, - Cols: convertList(n.Cols), + PrivName: &n.PrivName, + Cols: convertSlice(n.Cols), } } -func convertAggref(n *nodes.Aggref) *ast.Aggref { +func convertAggref(n *pg.Aggref) *ast.Aggref { if n == nil { return nil } @@ -114,164 +130,164 @@ func convertAggref(n *nodes.Aggref) *ast.Aggref { Aggcollid: ast.Oid(n.Aggcollid), Inputcollid: ast.Oid(n.Inputcollid), Aggtranstype: ast.Oid(n.Aggtranstype), - Aggargtypes: convertList(n.Aggargtypes), - Aggdirectargs: convertList(n.Aggdirectargs), - Args: convertList(n.Args), - Aggorder: convertList(n.Aggorder), - Aggdistinct: convertList(n.Aggdistinct), + Aggargtypes: convertSlice(n.Aggargtypes), + Aggdirectargs: convertSlice(n.Aggdirectargs), + Args: convertSlice(n.Args), + Aggorder: convertSlice(n.Aggorder), + Aggdistinct: convertSlice(n.Aggdistinct), Aggfilter: convertNode(n.Aggfilter), Aggstar: n.Aggstar, Aggvariadic: n.Aggvariadic, - Aggkind: n.Aggkind, + Aggkind: makeByte(n.Aggkind), Agglevelsup: ast.Index(n.Agglevelsup), Aggsplit: ast.AggSplit(n.Aggsplit), - Location: n.Location, + Location: int(n.Location), } } -func convertAlias(n *nodes.Alias) *ast.Alias { +func convertAlias(n *pg.Alias) *ast.Alias { if n == nil { return nil } return &ast.Alias{ - Aliasname: n.Aliasname, - Colnames: convertList(n.Colnames), + Aliasname: &n.Aliasname, + Colnames: convertSlice(n.Colnames), } } -func convertAlterCollationStmt(n *nodes.AlterCollationStmt) *ast.AlterCollationStmt { +func convertAlterCollationStmt(n *pg.AlterCollationStmt) *ast.AlterCollationStmt { if n == nil { return nil } return &ast.AlterCollationStmt{ - Collname: convertList(n.Collname), + Collname: convertSlice(n.Collname), } } -func convertAlterDatabaseSetStmt(n *nodes.AlterDatabaseSetStmt) *ast.AlterDatabaseSetStmt { +func convertAlterDatabaseSetStmt(n *pg.AlterDatabaseSetStmt) *ast.AlterDatabaseSetStmt { if n == nil { return nil } return &ast.AlterDatabaseSetStmt{ - Dbname: n.Dbname, + Dbname: &n.Dbname, Setstmt: convertVariableSetStmt(n.Setstmt), } } -func convertAlterDatabaseStmt(n *nodes.AlterDatabaseStmt) *ast.AlterDatabaseStmt { +func convertAlterDatabaseStmt(n *pg.AlterDatabaseStmt) *ast.AlterDatabaseStmt { if n == nil { return nil } return &ast.AlterDatabaseStmt{ - Dbname: n.Dbname, - Options: convertList(n.Options), + Dbname: &n.Dbname, + Options: convertSlice(n.Options), } } -func convertAlterDefaultPrivilegesStmt(n *nodes.AlterDefaultPrivilegesStmt) *ast.AlterDefaultPrivilegesStmt { +func convertAlterDefaultPrivilegesStmt(n *pg.AlterDefaultPrivilegesStmt) *ast.AlterDefaultPrivilegesStmt { if n == nil { return nil } return &ast.AlterDefaultPrivilegesStmt{ - Options: convertList(n.Options), + Options: convertSlice(n.Options), Action: convertGrantStmt(n.Action), } } -func convertAlterDomainStmt(n *nodes.AlterDomainStmt) *ast.AlterDomainStmt { +func convertAlterDomainStmt(n *pg.AlterDomainStmt) *ast.AlterDomainStmt { if n == nil { return nil } return &ast.AlterDomainStmt{ - Subtype: n.Subtype, - TypeName: convertList(n.TypeName), - Name: n.Name, + Subtype: makeByte(n.Subtype), + TypeName: convertSlice(n.TypeName), + Name: &n.Name, Def: convertNode(n.Def), Behavior: ast.DropBehavior(n.Behavior), MissingOk: n.MissingOk, } } -func convertAlterEnumStmt(n *nodes.AlterEnumStmt) *ast.AlterEnumStmt { +func convertAlterEnumStmt(n *pg.AlterEnumStmt) *ast.AlterEnumStmt { if n == nil { return nil } return &ast.AlterEnumStmt{ - TypeName: convertList(n.TypeName), - OldVal: n.OldVal, - NewVal: n.NewVal, - NewValNeighbor: n.NewValNeighbor, + TypeName: convertSlice(n.TypeName), + OldVal: &n.OldVal, + NewVal: &n.NewVal, + NewValNeighbor: &n.NewValNeighbor, NewValIsAfter: n.NewValIsAfter, SkipIfNewValExists: n.SkipIfNewValExists, } } -func convertAlterEventTrigStmt(n *nodes.AlterEventTrigStmt) *ast.AlterEventTrigStmt { +func convertAlterEventTrigStmt(n *pg.AlterEventTrigStmt) *ast.AlterEventTrigStmt { if n == nil { return nil } return &ast.AlterEventTrigStmt{ - Trigname: n.Trigname, - Tgenabled: n.Tgenabled, + Trigname: &n.Trigname, + Tgenabled: makeByte(n.Tgenabled), } } -func convertAlterExtensionContentsStmt(n *nodes.AlterExtensionContentsStmt) *ast.AlterExtensionContentsStmt { +func convertAlterExtensionContentsStmt(n *pg.AlterExtensionContentsStmt) *ast.AlterExtensionContentsStmt { if n == nil { return nil } return &ast.AlterExtensionContentsStmt{ - Extname: n.Extname, - Action: n.Action, + Extname: &n.Extname, + Action: int(n.Action), Objtype: ast.ObjectType(n.Objtype), Object: convertNode(n.Object), } } -func convertAlterExtensionStmt(n *nodes.AlterExtensionStmt) *ast.AlterExtensionStmt { +func convertAlterExtensionStmt(n *pg.AlterExtensionStmt) *ast.AlterExtensionStmt { if n == nil { return nil } return &ast.AlterExtensionStmt{ - Extname: n.Extname, - Options: convertList(n.Options), + Extname: &n.Extname, + Options: convertSlice(n.Options), } } -func convertAlterFdwStmt(n *nodes.AlterFdwStmt) *ast.AlterFdwStmt { +func convertAlterFdwStmt(n *pg.AlterFdwStmt) *ast.AlterFdwStmt { if n == nil { return nil } return &ast.AlterFdwStmt{ - Fdwname: n.Fdwname, - FuncOptions: convertList(n.FuncOptions), - Options: convertList(n.Options), + Fdwname: &n.Fdwname, + FuncOptions: convertSlice(n.FuncOptions), + Options: convertSlice(n.Options), } } -func convertAlterForeignServerStmt(n *nodes.AlterForeignServerStmt) *ast.AlterForeignServerStmt { +func convertAlterForeignServerStmt(n *pg.AlterForeignServerStmt) *ast.AlterForeignServerStmt { if n == nil { return nil } return &ast.AlterForeignServerStmt{ - Servername: n.Servername, - Version: n.Version, - Options: convertList(n.Options), + Servername: &n.Servername, + Version: &n.Version, + Options: convertSlice(n.Options), HasVersion: n.HasVersion, } } -func convertAlterFunctionStmt(n *nodes.AlterFunctionStmt) *ast.AlterFunctionStmt { +func convertAlterFunctionStmt(n *pg.AlterFunctionStmt) *ast.AlterFunctionStmt { if n == nil { return nil } return &ast.AlterFunctionStmt{ Func: convertObjectWithArgs(n.Func), - Actions: convertList(n.Actions), + Actions: convertSlice(n.Actions), } } -func convertAlterObjectDependsStmt(n *nodes.AlterObjectDependsStmt) *ast.AlterObjectDependsStmt { +func convertAlterObjectDependsStmt(n *pg.AlterObjectDependsStmt) *ast.AlterObjectDependsStmt { if n == nil { return nil } @@ -283,7 +299,7 @@ func convertAlterObjectDependsStmt(n *nodes.AlterObjectDependsStmt) *ast.AlterOb } } -func convertAlterObjectSchemaStmt(n *nodes.AlterObjectSchemaStmt) *ast.AlterObjectSchemaStmt { +func convertAlterObjectSchemaStmt(n *pg.AlterObjectSchemaStmt) *ast.AlterObjectSchemaStmt { if n == nil { return nil } @@ -291,34 +307,34 @@ func convertAlterObjectSchemaStmt(n *nodes.AlterObjectSchemaStmt) *ast.AlterObje ObjectType: ast.ObjectType(n.ObjectType), Relation: convertRangeVar(n.Relation), Object: convertNode(n.Object), - Newschema: n.Newschema, + Newschema: &n.Newschema, MissingOk: n.MissingOk, } } -func convertAlterOpFamilyStmt(n *nodes.AlterOpFamilyStmt) *ast.AlterOpFamilyStmt { +func convertAlterOpFamilyStmt(n *pg.AlterOpFamilyStmt) *ast.AlterOpFamilyStmt { if n == nil { return nil } return &ast.AlterOpFamilyStmt{ - Opfamilyname: convertList(n.Opfamilyname), - Amname: n.Amname, + Opfamilyname: convertSlice(n.Opfamilyname), + Amname: &n.Amname, IsDrop: n.IsDrop, - Items: convertList(n.Items), + Items: convertSlice(n.Items), } } -func convertAlterOperatorStmt(n *nodes.AlterOperatorStmt) *ast.AlterOperatorStmt { +func convertAlterOperatorStmt(n *pg.AlterOperatorStmt) *ast.AlterOperatorStmt { if n == nil { return nil } return &ast.AlterOperatorStmt{ Opername: convertObjectWithArgs(n.Opername), - Options: convertList(n.Options), + Options: convertSlice(n.Options), } } -func convertAlterOwnerStmt(n *nodes.AlterOwnerStmt) *ast.AlterOwnerStmt { +func convertAlterOwnerStmt(n *pg.AlterOwnerStmt) *ast.AlterOwnerStmt { if n == nil { return nil } @@ -330,80 +346,80 @@ func convertAlterOwnerStmt(n *nodes.AlterOwnerStmt) *ast.AlterOwnerStmt { } } -func convertAlterPolicyStmt(n *nodes.AlterPolicyStmt) *ast.AlterPolicyStmt { +func convertAlterPolicyStmt(n *pg.AlterPolicyStmt) *ast.AlterPolicyStmt { if n == nil { return nil } return &ast.AlterPolicyStmt{ - PolicyName: n.PolicyName, + PolicyName: &n.PolicyName, Table: convertRangeVar(n.Table), - Roles: convertList(n.Roles), + Roles: convertSlice(n.Roles), Qual: convertNode(n.Qual), WithCheck: convertNode(n.WithCheck), } } -func convertAlterPublicationStmt(n *nodes.AlterPublicationStmt) *ast.AlterPublicationStmt { +func convertAlterPublicationStmt(n *pg.AlterPublicationStmt) *ast.AlterPublicationStmt { if n == nil { return nil } return &ast.AlterPublicationStmt{ - Pubname: n.Pubname, - Options: convertList(n.Options), - Tables: convertList(n.Tables), + Pubname: &n.Pubname, + Options: convertSlice(n.Options), + Tables: convertSlice(n.Tables), ForAllTables: n.ForAllTables, TableAction: ast.DefElemAction(n.TableAction), } } -func convertAlterRoleSetStmt(n *nodes.AlterRoleSetStmt) *ast.AlterRoleSetStmt { +func convertAlterRoleSetStmt(n *pg.AlterRoleSetStmt) *ast.AlterRoleSetStmt { if n == nil { return nil } return &ast.AlterRoleSetStmt{ Role: convertRoleSpec(n.Role), - Database: n.Database, + Database: &n.Database, Setstmt: convertVariableSetStmt(n.Setstmt), } } -func convertAlterRoleStmt(n *nodes.AlterRoleStmt) *ast.AlterRoleStmt { +func convertAlterRoleStmt(n *pg.AlterRoleStmt) *ast.AlterRoleStmt { if n == nil { return nil } return &ast.AlterRoleStmt{ Role: convertRoleSpec(n.Role), - Options: convertList(n.Options), - Action: n.Action, + Options: convertSlice(n.Options), + Action: int(n.Action), } } -func convertAlterSeqStmt(n *nodes.AlterSeqStmt) *ast.AlterSeqStmt { +func convertAlterSeqStmt(n *pg.AlterSeqStmt) *ast.AlterSeqStmt { if n == nil { return nil } return &ast.AlterSeqStmt{ Sequence: convertRangeVar(n.Sequence), - Options: convertList(n.Options), + Options: convertSlice(n.Options), ForIdentity: n.ForIdentity, MissingOk: n.MissingOk, } } -func convertAlterSubscriptionStmt(n *nodes.AlterSubscriptionStmt) *ast.AlterSubscriptionStmt { +func convertAlterSubscriptionStmt(n *pg.AlterSubscriptionStmt) *ast.AlterSubscriptionStmt { if n == nil { return nil } return &ast.AlterSubscriptionStmt{ Kind: ast.AlterSubscriptionType(n.Kind), - Subname: n.Subname, - Conninfo: n.Conninfo, - Publication: convertList(n.Publication), - Options: convertList(n.Options), + Subname: &n.Subname, + Conninfo: &n.Conninfo, + Publication: convertSlice(n.Publication), + Options: convertSlice(n.Options), } } -func convertAlterSystemStmt(n *nodes.AlterSystemStmt) *ast.AlterSystemStmt { +func convertAlterSystemStmt(n *pg.AlterSystemStmt) *ast.AlterSystemStmt { if n == nil { return nil } @@ -412,32 +428,32 @@ func convertAlterSystemStmt(n *nodes.AlterSystemStmt) *ast.AlterSystemStmt { } } -func convertAlterTSConfigurationStmt(n *nodes.AlterTSConfigurationStmt) *ast.AlterTSConfigurationStmt { +func convertAlterTSConfigurationStmt(n *pg.AlterTSConfigurationStmt) *ast.AlterTSConfigurationStmt { if n == nil { return nil } return &ast.AlterTSConfigurationStmt{ Kind: ast.AlterTSConfigType(n.Kind), - Cfgname: convertList(n.Cfgname), - Tokentype: convertList(n.Tokentype), - Dicts: convertList(n.Dicts), + Cfgname: convertSlice(n.Cfgname), + Tokentype: convertSlice(n.Tokentype), + Dicts: convertSlice(n.Dicts), Override: n.Override, Replace: n.Replace, MissingOk: n.MissingOk, } } -func convertAlterTSDictionaryStmt(n *nodes.AlterTSDictionaryStmt) *ast.AlterTSDictionaryStmt { +func convertAlterTSDictionaryStmt(n *pg.AlterTSDictionaryStmt) *ast.AlterTSDictionaryStmt { if n == nil { return nil } return &ast.AlterTSDictionaryStmt{ - Dictname: convertList(n.Dictname), - Options: convertList(n.Options), + Dictname: convertSlice(n.Dictname), + Options: convertSlice(n.Options), } } -func convertAlterTableCmd(n *nodes.AlterTableCmd) *ast.AlterTableCmd { +func convertAlterTableCmd(n *pg.AlterTableCmd) *ast.AlterTableCmd { if n == nil { return nil } @@ -445,7 +461,7 @@ func convertAlterTableCmd(n *nodes.AlterTableCmd) *ast.AlterTableCmd { columnDef := def.(*ast.ColumnDef) return &ast.AlterTableCmd{ Subtype: ast.AlterTableType(n.Subtype), - Name: n.Name, + Name: &n.Name, Newowner: convertRoleSpec(n.Newowner), Def: columnDef, Behavior: ast.DropBehavior(n.Behavior), @@ -453,64 +469,64 @@ func convertAlterTableCmd(n *nodes.AlterTableCmd) *ast.AlterTableCmd { } } -func convertAlterTableMoveAllStmt(n *nodes.AlterTableMoveAllStmt) *ast.AlterTableMoveAllStmt { +func convertAlterTableMoveAllStmt(n *pg.AlterTableMoveAllStmt) *ast.AlterTableMoveAllStmt { if n == nil { return nil } return &ast.AlterTableMoveAllStmt{ - OrigTablespacename: n.OrigTablespacename, + OrigTablespacename: &n.OrigTablespacename, Objtype: ast.ObjectType(n.Objtype), - Roles: convertList(n.Roles), - NewTablespacename: n.NewTablespacename, + Roles: convertSlice(n.Roles), + NewTablespacename: &n.NewTablespacename, Nowait: n.Nowait, } } -func convertAlterTableSpaceOptionsStmt(n *nodes.AlterTableSpaceOptionsStmt) *ast.AlterTableSpaceOptionsStmt { +func convertAlterTableSpaceOptionsStmt(n *pg.AlterTableSpaceOptionsStmt) *ast.AlterTableSpaceOptionsStmt { if n == nil { return nil } return &ast.AlterTableSpaceOptionsStmt{ - Tablespacename: n.Tablespacename, - Options: convertList(n.Options), + Tablespacename: &n.Tablespacename, + Options: convertSlice(n.Options), IsReset: n.IsReset, } } -func convertAlterTableStmt(n *nodes.AlterTableStmt) *ast.AlterTableStmt { +func convertAlterTableStmt(n *pg.AlterTableStmt) *ast.AlterTableStmt { if n == nil { return nil } return &ast.AlterTableStmt{ Relation: convertRangeVar(n.Relation), - Cmds: convertList(n.Cmds), + Cmds: convertSlice(n.Cmds), Relkind: ast.ObjectType(n.Relkind), MissingOk: n.MissingOk, } } -func convertAlterUserMappingStmt(n *nodes.AlterUserMappingStmt) *ast.AlterUserMappingStmt { +func convertAlterUserMappingStmt(n *pg.AlterUserMappingStmt) *ast.AlterUserMappingStmt { if n == nil { return nil } return &ast.AlterUserMappingStmt{ User: convertRoleSpec(n.User), - Servername: n.Servername, - Options: convertList(n.Options), + Servername: &n.Servername, + Options: convertSlice(n.Options), } } -func convertAlternativeSubPlan(n *nodes.AlternativeSubPlan) *ast.AlternativeSubPlan { +func convertAlternativeSubPlan(n *pg.AlternativeSubPlan) *ast.AlternativeSubPlan { if n == nil { return nil } return &ast.AlternativeSubPlan{ Xpr: convertNode(n.Xpr), - Subplans: convertList(n.Subplans), + Subplans: convertSlice(n.Subplans), } } -func convertArrayCoerceExpr(n *nodes.ArrayCoerceExpr) *ast.ArrayCoerceExpr { +func convertArrayCoerceExpr(n *pg.ArrayCoerceExpr) *ast.ArrayCoerceExpr { if n == nil { return nil } @@ -527,7 +543,7 @@ func convertArrayCoerceExpr(n *nodes.ArrayCoerceExpr) *ast.ArrayCoerceExpr { } } -func convertArrayExpr(n *nodes.ArrayExpr) *ast.ArrayExpr { +func convertArrayExpr(n *pg.ArrayExpr) *ast.ArrayExpr { if n == nil { return nil } @@ -536,13 +552,13 @@ func convertArrayExpr(n *nodes.ArrayExpr) *ast.ArrayExpr { ArrayTypeid: ast.Oid(n.ArrayTypeid), ArrayCollid: ast.Oid(n.ArrayCollid), ElementTypeid: ast.Oid(n.ElementTypeid), - Elements: convertList(n.Elements), + Elements: convertSlice(n.Elements), Multidims: n.Multidims, Location: n.Location, } } -func convertArrayRef(n *nodes.ArrayRef) *ast.ArrayRef { +func convertArrayRef(n *pg.ArrayRef) *ast.ArrayRef { if n == nil { return nil } @@ -552,14 +568,14 @@ func convertArrayRef(n *nodes.ArrayRef) *ast.ArrayRef { Refelemtype: ast.Oid(n.Refelemtype), Reftypmod: n.Reftypmod, Refcollid: ast.Oid(n.Refcollid), - Refupperindexpr: convertList(n.Refupperindexpr), - Reflowerindexpr: convertList(n.Reflowerindexpr), + Refupperindexpr: convertSlice(n.Refupperindexpr), + Reflowerindexpr: convertSlice(n.Reflowerindexpr), Refexpr: convertNode(n.Refexpr), Refassgnexpr: convertNode(n.Refassgnexpr), } } -func convertBitString(n *nodes.BitString) *ast.BitString { +func convertBitString(n *pg.BitString) *ast.BitString { if n == nil { return nil } @@ -568,7 +584,7 @@ func convertBitString(n *nodes.BitString) *ast.BitString { } } -func convertBlockIdData(n *nodes.BlockIdData) *ast.BlockIdData { +func convertBlockIdData(n *pg.BlockIdData) *ast.BlockIdData { if n == nil { return nil } @@ -578,19 +594,19 @@ func convertBlockIdData(n *nodes.BlockIdData) *ast.BlockIdData { } } -func convertBoolExpr(n *nodes.BoolExpr) *ast.BoolExpr { +func convertBoolExpr(n *pg.BoolExpr) *ast.BoolExpr { if n == nil { return nil } return &ast.BoolExpr{ Xpr: convertNode(n.Xpr), Boolop: ast.BoolExprType(n.Boolop), - Args: convertList(n.Args), + Args: convertSlice(n.Args), Location: n.Location, } } -func convertBooleanTest(n *nodes.BooleanTest) *ast.BooleanTest { +func convertBooleanTest(n *pg.BooleanTest) *ast.BooleanTest { if n == nil { return nil } @@ -602,7 +618,7 @@ func convertBooleanTest(n *nodes.BooleanTest) *ast.BooleanTest { } } -func convertCaseExpr(n *nodes.CaseExpr) *ast.CaseExpr { +func convertCaseExpr(n *pg.CaseExpr) *ast.CaseExpr { if n == nil { return nil } @@ -611,13 +627,13 @@ func convertCaseExpr(n *nodes.CaseExpr) *ast.CaseExpr { Casetype: ast.Oid(n.Casetype), Casecollid: ast.Oid(n.Casecollid), Arg: convertNode(n.Arg), - Args: convertList(n.Args), + Args: convertSlice(n.Args), Defresult: convertNode(n.Defresult), Location: n.Location, } } -func convertCaseTestExpr(n *nodes.CaseTestExpr) *ast.CaseTestExpr { +func convertCaseTestExpr(n *pg.CaseTestExpr) *ast.CaseTestExpr { if n == nil { return nil } @@ -629,7 +645,7 @@ func convertCaseTestExpr(n *nodes.CaseTestExpr) *ast.CaseTestExpr { } } -func convertCaseWhen(n *nodes.CaseWhen) *ast.CaseWhen { +func convertCaseWhen(n *pg.CaseWhen) *ast.CaseWhen { if n == nil { return nil } @@ -641,14 +657,14 @@ func convertCaseWhen(n *nodes.CaseWhen) *ast.CaseWhen { } } -func convertCheckPointStmt(n *nodes.CheckPointStmt) *ast.CheckPointStmt { +func convertCheckPointStmt(n *pg.CheckPointStmt) *ast.CheckPointStmt { if n == nil { return nil } return &ast.CheckPointStmt{} } -func convertClosePortalStmt(n *nodes.ClosePortalStmt) *ast.ClosePortalStmt { +func convertClosePortalStmt(n *pg.ClosePortalStmt) *ast.ClosePortalStmt { if n == nil { return nil } @@ -657,7 +673,7 @@ func convertClosePortalStmt(n *nodes.ClosePortalStmt) *ast.ClosePortalStmt { } } -func convertClusterStmt(n *nodes.ClusterStmt) *ast.ClusterStmt { +func convertClusterStmt(n *pg.ClusterStmt) *ast.ClusterStmt { if n == nil { return nil } @@ -668,7 +684,7 @@ func convertClusterStmt(n *nodes.ClusterStmt) *ast.ClusterStmt { } } -func convertCoalesceExpr(n *nodes.CoalesceExpr) *ast.CoalesceExpr { +func convertCoalesceExpr(n *pg.CoalesceExpr) *ast.CoalesceExpr { if n == nil { return nil } @@ -676,12 +692,12 @@ func convertCoalesceExpr(n *nodes.CoalesceExpr) *ast.CoalesceExpr { Xpr: convertNode(n.Xpr), Coalescetype: ast.Oid(n.Coalescetype), Coalescecollid: ast.Oid(n.Coalescecollid), - Args: convertList(n.Args), + Args: convertSlice(n.Args), Location: n.Location, } } -func convertCoerceToDomain(n *nodes.CoerceToDomain) *ast.CoerceToDomain { +func convertCoerceToDomain(n *pg.CoerceToDomain) *ast.CoerceToDomain { if n == nil { return nil } @@ -696,7 +712,7 @@ func convertCoerceToDomain(n *nodes.CoerceToDomain) *ast.CoerceToDomain { } } -func convertCoerceToDomainValue(n *nodes.CoerceToDomainValue) *ast.CoerceToDomainValue { +func convertCoerceToDomainValue(n *pg.CoerceToDomainValue) *ast.CoerceToDomainValue { if n == nil { return nil } @@ -709,7 +725,7 @@ func convertCoerceToDomainValue(n *nodes.CoerceToDomainValue) *ast.CoerceToDomai } } -func convertCoerceViaIO(n *nodes.CoerceViaIO) *ast.CoerceViaIO { +func convertCoerceViaIO(n *pg.CoerceViaIO) *ast.CoerceViaIO { if n == nil { return nil } @@ -723,18 +739,18 @@ func convertCoerceViaIO(n *nodes.CoerceViaIO) *ast.CoerceViaIO { } } -func convertCollateClause(n *nodes.CollateClause) *ast.CollateClause { +func convertCollateClause(n *pg.CollateClause) *ast.CollateClause { if n == nil { return nil } return &ast.CollateClause{ Arg: convertNode(n.Arg), - Collname: convertList(n.Collname), + Collname: convertSlice(n.Collname), Location: n.Location, } } -func convertCollateExpr(n *nodes.CollateExpr) *ast.CollateExpr { +func convertCollateExpr(n *pg.CollateExpr) *ast.CollateExpr { if n == nil { return nil } @@ -746,7 +762,7 @@ func convertCollateExpr(n *nodes.CollateExpr) *ast.CollateExpr { } } -func convertColumnDef(n *nodes.ColumnDef) *ast.ColumnDef { +func convertColumnDef(n *pg.ColumnDef) *ast.ColumnDef { if n == nil { return nil } @@ -768,23 +784,23 @@ func convertColumnDef(n *nodes.ColumnDef) *ast.ColumnDef { Identity: n.Identity, CollClause: convertCollateClause(n.CollClause), CollOid: ast.Oid(n.CollOid), - Constraints: convertList(n.Constraints), - Fdwoptions: convertList(n.Fdwoptions), + Constraints: convertSlice(n.Constraints), + Fdwoptions: convertSlice(n.Fdwoptions), Location: n.Location, } } -func convertColumnRef(n *nodes.ColumnRef) *ast.ColumnRef { +func convertColumnRef(n *pg.ColumnRef) *ast.ColumnRef { if n == nil { return nil } return &ast.ColumnRef{ - Fields: convertList(n.Fields), + Fields: convertSlice(n.Fields), Location: n.Location, } } -func convertCommentStmt(n *nodes.CommentStmt) *ast.CommentStmt { +func convertCommentStmt(n *pg.CommentStmt) *ast.CommentStmt { if n == nil { return nil } @@ -795,25 +811,25 @@ func convertCommentStmt(n *nodes.CommentStmt) *ast.CommentStmt { } } -func convertCommonTableExpr(n *nodes.CommonTableExpr) *ast.CommonTableExpr { +func convertCommonTableExpr(n *pg.CommonTableExpr) *ast.CommonTableExpr { if n == nil { return nil } return &ast.CommonTableExpr{ Ctename: n.Ctename, - Aliascolnames: convertList(n.Aliascolnames), + Aliascolnames: convertSlice(n.Aliascolnames), Ctequery: convertNode(n.Ctequery), Location: n.Location, Cterecursive: n.Cterecursive, Cterefcount: n.Cterefcount, - Ctecolnames: convertList(n.Ctecolnames), - Ctecoltypes: convertList(n.Ctecoltypes), - Ctecoltypmods: convertList(n.Ctecoltypmods), - Ctecolcollations: convertList(n.Ctecolcollations), + Ctecolnames: convertSlice(n.Ctecolnames), + Ctecoltypes: convertSlice(n.Ctecoltypes), + Ctecoltypmods: convertSlice(n.Ctecoltypmods), + Ctecolcollations: convertSlice(n.Ctecolcollations), } } -func convertCompositeTypeStmt(n *nodes.CompositeTypeStmt) *ast.CompositeTypeStmt { +func convertCompositeTypeStmt(n *pg.CompositeTypeStmt) *ast.CompositeTypeStmt { if n == nil { return nil } @@ -826,7 +842,7 @@ func convertCompositeTypeStmt(n *nodes.CompositeTypeStmt) *ast.CompositeTypeStmt } } -func convertConst(n *nodes.Const) *ast.Const { +func convertConst(n *pg.Const) *ast.Const { if n == nil { return nil } @@ -843,7 +859,7 @@ func convertConst(n *nodes.Const) *ast.Const { } } -func convertConstraint(n *nodes.Constraint) *ast.Constraint { +func convertConstraint(n *pg.Constraint) *ast.Constraint { if n == nil { return nil } @@ -857,37 +873,37 @@ func convertConstraint(n *nodes.Constraint) *ast.Constraint { RawExpr: convertNode(n.RawExpr), CookedExpr: n.CookedExpr, GeneratedWhen: n.GeneratedWhen, - Keys: convertList(n.Keys), - Exclusions: convertList(n.Exclusions), - Options: convertList(n.Options), + Keys: convertSlice(n.Keys), + Exclusions: convertSlice(n.Exclusions), + Options: convertSlice(n.Options), Indexname: n.Indexname, Indexspace: n.Indexspace, AccessMethod: n.AccessMethod, WhereClause: convertNode(n.WhereClause), Pktable: convertRangeVar(n.Pktable), - FkAttrs: convertList(n.FkAttrs), - PkAttrs: convertList(n.PkAttrs), + FkAttrs: convertSlice(n.FkAttrs), + PkAttrs: convertSlice(n.PkAttrs), FkMatchtype: n.FkMatchtype, FkUpdAction: n.FkUpdAction, FkDelAction: n.FkDelAction, - OldConpfeqop: convertList(n.OldConpfeqop), + OldConpfeqop: convertSlice(n.OldConpfeqop), OldPktableOid: ast.Oid(n.OldPktableOid), SkipValidation: n.SkipValidation, InitiallyValid: n.InitiallyValid, } } -func convertConstraintsSetStmt(n *nodes.ConstraintsSetStmt) *ast.ConstraintsSetStmt { +func convertConstraintsSetStmt(n *pg.ConstraintsSetStmt) *ast.ConstraintsSetStmt { if n == nil { return nil } return &ast.ConstraintsSetStmt{ - Constraints: convertList(n.Constraints), + Constraints: convertSlice(n.Constraints), Deferred: n.Deferred, } } -func convertConvertRowtypeExpr(n *nodes.ConvertRowtypeExpr) *ast.ConvertRowtypeExpr { +func convertConvertRowtypeExpr(n *pg.ConvertRowtypeExpr) *ast.ConvertRowtypeExpr { if n == nil { return nil } @@ -900,33 +916,33 @@ func convertConvertRowtypeExpr(n *nodes.ConvertRowtypeExpr) *ast.ConvertRowtypeE } } -func convertCopyStmt(n *nodes.CopyStmt) *ast.CopyStmt { +func convertCopyStmt(n *pg.CopyStmt) *ast.CopyStmt { if n == nil { return nil } return &ast.CopyStmt{ Relation: convertRangeVar(n.Relation), Query: convertNode(n.Query), - Attlist: convertList(n.Attlist), + Attlist: convertSlice(n.Attlist), IsFrom: n.IsFrom, IsProgram: n.IsProgram, Filename: n.Filename, - Options: convertList(n.Options), + Options: convertSlice(n.Options), } } -func convertCreateAmStmt(n *nodes.CreateAmStmt) *ast.CreateAmStmt { +func convertCreateAmStmt(n *pg.CreateAmStmt) *ast.CreateAmStmt { if n == nil { return nil } return &ast.CreateAmStmt{ Amname: n.Amname, - HandlerName: convertList(n.HandlerName), + HandlerName: convertSlice(n.HandlerName), Amtype: n.Amtype, } } -func convertCreateCastStmt(n *nodes.CreateCastStmt) *ast.CreateCastStmt { +func convertCreateCastStmt(n *pg.CreateCastStmt) *ast.CreateCastStmt { if n == nil { return nil } @@ -939,32 +955,32 @@ func convertCreateCastStmt(n *nodes.CreateCastStmt) *ast.CreateCastStmt { } } -func convertCreateConversionStmt(n *nodes.CreateConversionStmt) *ast.CreateConversionStmt { +func convertCreateConversionStmt(n *pg.CreateConversionStmt) *ast.CreateConversionStmt { if n == nil { return nil } return &ast.CreateConversionStmt{ - ConversionName: convertList(n.ConversionName), + ConversionName: convertSlice(n.ConversionName), ForEncodingName: n.ForEncodingName, ToEncodingName: n.ToEncodingName, - FuncName: convertList(n.FuncName), + FuncName: convertSlice(n.FuncName), Def: n.Def, } } -func convertCreateDomainStmt(n *nodes.CreateDomainStmt) *ast.CreateDomainStmt { +func convertCreateDomainStmt(n *pg.CreateDomainStmt) *ast.CreateDomainStmt { if n == nil { return nil } return &ast.CreateDomainStmt{ - Domainname: convertList(n.Domainname), + Domainname: convertSlice(n.Domainname), TypeName: convertTypeName(n.TypeName), CollClause: convertCollateClause(n.CollClause), - Constraints: convertList(n.Constraints), + Constraints: convertSlice(n.Constraints), } } -func convertCreateEnumStmt(n *nodes.CreateEnumStmt) *ast.CreateEnumStmt { +func convertCreateEnumStmt(n *pg.CreateEnumStmt) *ast.CreateEnumStmt { if n == nil { return nil } @@ -974,45 +990,45 @@ func convertCreateEnumStmt(n *nodes.CreateEnumStmt) *ast.CreateEnumStmt { } return &ast.CreateEnumStmt{ TypeName: tn, - Vals: convertList(n.Vals), + Vals: convertSlice(n.Vals), } } -func convertCreateEventTrigStmt(n *nodes.CreateEventTrigStmt) *ast.CreateEventTrigStmt { +func convertCreateEventTrigStmt(n *pg.CreateEventTrigStmt) *ast.CreateEventTrigStmt { if n == nil { return nil } return &ast.CreateEventTrigStmt{ Trigname: n.Trigname, Eventname: n.Eventname, - Whenclause: convertList(n.Whenclause), - Funcname: convertList(n.Funcname), + Whenclause: convertSlice(n.Whenclause), + Funcname: convertSlice(n.Funcname), } } -func convertCreateExtensionStmt(n *nodes.CreateExtensionStmt) *ast.CreateExtensionStmt { +func convertCreateExtensionStmt(n *pg.CreateExtensionStmt) *ast.CreateExtensionStmt { if n == nil { return nil } return &ast.CreateExtensionStmt{ Extname: n.Extname, IfNotExists: n.IfNotExists, - Options: convertList(n.Options), + Options: convertSlice(n.Options), } } -func convertCreateFdwStmt(n *nodes.CreateFdwStmt) *ast.CreateFdwStmt { +func convertCreateFdwStmt(n *pg.CreateFdwStmt) *ast.CreateFdwStmt { if n == nil { return nil } return &ast.CreateFdwStmt{ Fdwname: n.Fdwname, - FuncOptions: convertList(n.FuncOptions), - Options: convertList(n.Options), + FuncOptions: convertSlice(n.FuncOptions), + Options: convertSlice(n.Options), } } -func convertCreateForeignServerStmt(n *nodes.CreateForeignServerStmt) *ast.CreateForeignServerStmt { +func convertCreateForeignServerStmt(n *pg.CreateForeignServerStmt) *ast.CreateForeignServerStmt { if n == nil { return nil } @@ -1022,22 +1038,22 @@ func convertCreateForeignServerStmt(n *nodes.CreateForeignServerStmt) *ast.Creat Version: n.Version, Fdwname: n.Fdwname, IfNotExists: n.IfNotExists, - Options: convertList(n.Options), + Options: convertSlice(n.Options), } } -func convertCreateForeignTableStmt(n *nodes.CreateForeignTableStmt) *ast.CreateForeignTableStmt { +func convertCreateForeignTableStmt(n *pg.CreateForeignTableStmt) *ast.CreateForeignTableStmt { if n == nil { return nil } return &ast.CreateForeignTableStmt{ Base: convertCreateStmt(&n.Base), Servername: n.Servername, - Options: convertList(n.Options), + Options: convertSlice(n.Options), } } -func convertCreateFunctionStmt(n *nodes.CreateFunctionStmt) *ast.CreateFunctionStmt { +func convertCreateFunctionStmt(n *pg.CreateFunctionStmt) *ast.CreateFunctionStmt { if n == nil { return nil } @@ -1048,14 +1064,14 @@ func convertCreateFunctionStmt(n *nodes.CreateFunctionStmt) *ast.CreateFunctionS return &ast.CreateFunctionStmt{ Replace: n.Replace, Func: fn, - Params: convertList(n.Parameters), + Params: convertSlice(n.Parameters), ReturnType: convertTypeName(n.ReturnType), - Options: convertList(n.Options), - WithClause: convertList(n.WithClause), + Options: convertSlice(n.Options), + WithClause: convertSlice(n.WithClause), } } -func convertCreateOpClassItem(n *nodes.CreateOpClassItem) *ast.CreateOpClassItem { +func convertCreateOpClassItem(n *pg.CreateOpClassItem) *ast.CreateOpClassItem { if n == nil { return nil } @@ -1063,51 +1079,51 @@ func convertCreateOpClassItem(n *nodes.CreateOpClassItem) *ast.CreateOpClassItem Itemtype: n.Itemtype, Name: convertObjectWithArgs(n.Name), Number: n.Number, - OrderFamily: convertList(n.OrderFamily), - ClassArgs: convertList(n.ClassArgs), + OrderFamily: convertSlice(n.OrderFamily), + ClassArgs: convertSlice(n.ClassArgs), Storedtype: convertTypeName(n.Storedtype), } } -func convertCreateOpClassStmt(n *nodes.CreateOpClassStmt) *ast.CreateOpClassStmt { +func convertCreateOpClassStmt(n *pg.CreateOpClassStmt) *ast.CreateOpClassStmt { if n == nil { return nil } return &ast.CreateOpClassStmt{ - Opclassname: convertList(n.Opclassname), - Opfamilyname: convertList(n.Opfamilyname), + Opclassname: convertSlice(n.Opclassname), + Opfamilyname: convertSlice(n.Opfamilyname), Amname: n.Amname, Datatype: convertTypeName(n.Datatype), - Items: convertList(n.Items), + Items: convertSlice(n.Items), IsDefault: n.IsDefault, } } -func convertCreateOpFamilyStmt(n *nodes.CreateOpFamilyStmt) *ast.CreateOpFamilyStmt { +func convertCreateOpFamilyStmt(n *pg.CreateOpFamilyStmt) *ast.CreateOpFamilyStmt { if n == nil { return nil } return &ast.CreateOpFamilyStmt{ - Opfamilyname: convertList(n.Opfamilyname), + Opfamilyname: convertSlice(n.Opfamilyname), Amname: n.Amname, } } -func convertCreatePLangStmt(n *nodes.CreatePLangStmt) *ast.CreatePLangStmt { +func convertCreatePLangStmt(n *pg.CreatePLangStmt) *ast.CreatePLangStmt { if n == nil { return nil } return &ast.CreatePLangStmt{ Replace: n.Replace, Plname: n.Plname, - Plhandler: convertList(n.Plhandler), - Plinline: convertList(n.Plinline), - Plvalidator: convertList(n.Plvalidator), + Plhandler: convertSlice(n.Plhandler), + Plinline: convertSlice(n.Plinline), + Plvalidator: convertSlice(n.Plvalidator), Pltrusted: n.Pltrusted, } } -func convertCreatePolicyStmt(n *nodes.CreatePolicyStmt) *ast.CreatePolicyStmt { +func convertCreatePolicyStmt(n *pg.CreatePolicyStmt) *ast.CreatePolicyStmt { if n == nil { return nil } @@ -1116,115 +1132,115 @@ func convertCreatePolicyStmt(n *nodes.CreatePolicyStmt) *ast.CreatePolicyStmt { Table: convertRangeVar(n.Table), CmdName: n.CmdName, Permissive: n.Permissive, - Roles: convertList(n.Roles), + Roles: convertSlice(n.Roles), Qual: convertNode(n.Qual), WithCheck: convertNode(n.WithCheck), } } -func convertCreatePublicationStmt(n *nodes.CreatePublicationStmt) *ast.CreatePublicationStmt { +func convertCreatePublicationStmt(n *pg.CreatePublicationStmt) *ast.CreatePublicationStmt { if n == nil { return nil } return &ast.CreatePublicationStmt{ Pubname: n.Pubname, - Options: convertList(n.Options), - Tables: convertList(n.Tables), + Options: convertSlice(n.Options), + Tables: convertSlice(n.Tables), ForAllTables: n.ForAllTables, } } -func convertCreateRangeStmt(n *nodes.CreateRangeStmt) *ast.CreateRangeStmt { +func convertCreateRangeStmt(n *pg.CreateRangeStmt) *ast.CreateRangeStmt { if n == nil { return nil } return &ast.CreateRangeStmt{ - TypeName: convertList(n.TypeName), - Params: convertList(n.Params), + TypeName: convertSlice(n.TypeName), + Params: convertSlice(n.Params), } } -func convertCreateRoleStmt(n *nodes.CreateRoleStmt) *ast.CreateRoleStmt { +func convertCreateRoleStmt(n *pg.CreateRoleStmt) *ast.CreateRoleStmt { if n == nil { return nil } return &ast.CreateRoleStmt{ StmtType: ast.RoleStmtType(n.StmtType), Role: n.Role, - Options: convertList(n.Options), + Options: convertSlice(n.Options), } } -func convertCreateSchemaStmt(n *nodes.CreateSchemaStmt) *ast.CreateSchemaStmt { +func convertCreateSchemaStmt(n *pg.CreateSchemaStmt) *ast.CreateSchemaStmt { if n == nil { return nil } return &ast.CreateSchemaStmt{ Name: n.Schemaname, Authrole: convertRoleSpec(n.Authrole), - SchemaElts: convertList(n.SchemaElts), + SchemaElts: convertSlice(n.SchemaElts), IfNotExists: n.IfNotExists, } } -func convertCreateSeqStmt(n *nodes.CreateSeqStmt) *ast.CreateSeqStmt { +func convertCreateSeqStmt(n *pg.CreateSeqStmt) *ast.CreateSeqStmt { if n == nil { return nil } return &ast.CreateSeqStmt{ Sequence: convertRangeVar(n.Sequence), - Options: convertList(n.Options), + Options: convertSlice(n.Options), OwnerId: ast.Oid(n.OwnerId), ForIdentity: n.ForIdentity, IfNotExists: n.IfNotExists, } } -func convertCreateStatsStmt(n *nodes.CreateStatsStmt) *ast.CreateStatsStmt { +func convertCreateStatsStmt(n *pg.CreateStatsStmt) *ast.CreateStatsStmt { if n == nil { return nil } return &ast.CreateStatsStmt{ - Defnames: convertList(n.Defnames), - StatTypes: convertList(n.StatTypes), - Exprs: convertList(n.Exprs), - Relations: convertList(n.Relations), + Defnames: convertSlice(n.Defnames), + StatTypes: convertSlice(n.StatTypes), + Exprs: convertSlice(n.Exprs), + Relations: convertSlice(n.Relations), IfNotExists: n.IfNotExists, } } -func convertCreateStmt(n *nodes.CreateStmt) *ast.CreateStmt { +func convertCreateStmt(n *pg.CreateStmt) *ast.CreateStmt { if n == nil { return nil } return &ast.CreateStmt{ Relation: convertRangeVar(n.Relation), - TableElts: convertList(n.TableElts), - InhRelations: convertList(n.InhRelations), + TableElts: convertSlice(n.TableElts), + InhRelations: convertSlice(n.InhRelations), Partbound: convertPartitionBoundSpec(n.Partbound), Partspec: convertPartitionSpec(n.Partspec), OfTypename: convertTypeName(n.OfTypename), - Constraints: convertList(n.Constraints), - Options: convertList(n.Options), + Constraints: convertSlice(n.Constraints), + Options: convertSlice(n.Options), Oncommit: ast.OnCommitAction(n.Oncommit), Tablespacename: n.Tablespacename, IfNotExists: n.IfNotExists, } } -func convertCreateSubscriptionStmt(n *nodes.CreateSubscriptionStmt) *ast.CreateSubscriptionStmt { +func convertCreateSubscriptionStmt(n *pg.CreateSubscriptionStmt) *ast.CreateSubscriptionStmt { if n == nil { return nil } return &ast.CreateSubscriptionStmt{ Subname: n.Subname, Conninfo: n.Conninfo, - Publication: convertList(n.Publication), - Options: convertList(n.Options), + Publication: convertSlice(n.Publication), + Options: convertSlice(n.Options), } } -func convertCreateTableAsStmt(n *nodes.CreateTableAsStmt) *ast.CreateTableAsStmt { +func convertCreateTableAsStmt(n *pg.CreateTableAsStmt) *ast.CreateTableAsStmt { if n == nil { return nil } @@ -1237,7 +1253,7 @@ func convertCreateTableAsStmt(n *nodes.CreateTableAsStmt) *ast.CreateTableAsStmt } } -func convertCreateTableSpaceStmt(n *nodes.CreateTableSpaceStmt) *ast.CreateTableSpaceStmt { +func convertCreateTableSpaceStmt(n *pg.CreateTableSpaceStmt) *ast.CreateTableSpaceStmt { if n == nil { return nil } @@ -1245,11 +1261,11 @@ func convertCreateTableSpaceStmt(n *nodes.CreateTableSpaceStmt) *ast.CreateTable Tablespacename: n.Tablespacename, Owner: convertRoleSpec(n.Owner), Location: n.Location, - Options: convertList(n.Options), + Options: convertSlice(n.Options), } } -func convertCreateTransformStmt(n *nodes.CreateTransformStmt) *ast.CreateTransformStmt { +func convertCreateTransformStmt(n *pg.CreateTransformStmt) *ast.CreateTransformStmt { if n == nil { return nil } @@ -1262,29 +1278,29 @@ func convertCreateTransformStmt(n *nodes.CreateTransformStmt) *ast.CreateTransfo } } -func convertCreateTrigStmt(n *nodes.CreateTrigStmt) *ast.CreateTrigStmt { +func convertCreateTrigStmt(n *pg.CreateTrigStmt) *ast.CreateTrigStmt { if n == nil { return nil } return &ast.CreateTrigStmt{ Trigname: n.Trigname, Relation: convertRangeVar(n.Relation), - Funcname: convertList(n.Funcname), - Args: convertList(n.Args), + Funcname: convertSlice(n.Funcname), + Args: convertSlice(n.Args), Row: n.Row, Timing: n.Timing, Events: n.Events, - Columns: convertList(n.Columns), + Columns: convertSlice(n.Columns), WhenClause: convertNode(n.WhenClause), Isconstraint: n.Isconstraint, - TransitionRels: convertList(n.TransitionRels), + TransitionRels: convertSlice(n.TransitionRels), Deferrable: n.Deferrable, Initdeferred: n.Initdeferred, Constrrel: convertRangeVar(n.Constrrel), } } -func convertCreateUserMappingStmt(n *nodes.CreateUserMappingStmt) *ast.CreateUserMappingStmt { +func convertCreateUserMappingStmt(n *pg.CreateUserMappingStmt) *ast.CreateUserMappingStmt { if n == nil { return nil } @@ -1292,21 +1308,21 @@ func convertCreateUserMappingStmt(n *nodes.CreateUserMappingStmt) *ast.CreateUse User: convertRoleSpec(n.User), Servername: n.Servername, IfNotExists: n.IfNotExists, - Options: convertList(n.Options), + Options: convertSlice(n.Options), } } -func convertCreatedbStmt(n *nodes.CreatedbStmt) *ast.CreatedbStmt { +func convertCreatedbStmt(n *pg.CreatedbStmt) *ast.CreatedbStmt { if n == nil { return nil } return &ast.CreatedbStmt{ Dbname: n.Dbname, - Options: convertList(n.Options), + Options: convertSlice(n.Options), } } -func convertCurrentOfExpr(n *nodes.CurrentOfExpr) *ast.CurrentOfExpr { +func convertCurrentOfExpr(n *pg.CurrentOfExpr) *ast.CurrentOfExpr { if n == nil { return nil } @@ -1318,7 +1334,7 @@ func convertCurrentOfExpr(n *nodes.CurrentOfExpr) *ast.CurrentOfExpr { } } -func convertDeallocateStmt(n *nodes.DeallocateStmt) *ast.DeallocateStmt { +func convertDeallocateStmt(n *pg.DeallocateStmt) *ast.DeallocateStmt { if n == nil { return nil } @@ -1327,7 +1343,7 @@ func convertDeallocateStmt(n *nodes.DeallocateStmt) *ast.DeallocateStmt { } } -func convertDeclareCursorStmt(n *nodes.DeclareCursorStmt) *ast.DeclareCursorStmt { +func convertDeclareCursorStmt(n *pg.DeclareCursorStmt) *ast.DeclareCursorStmt { if n == nil { return nil } @@ -1338,7 +1354,7 @@ func convertDeclareCursorStmt(n *nodes.DeclareCursorStmt) *ast.DeclareCursorStmt } } -func convertDefElem(n *nodes.DefElem) *ast.DefElem { +func convertDefElem(n *pg.DefElem) *ast.DefElem { if n == nil { return nil } @@ -1351,34 +1367,34 @@ func convertDefElem(n *nodes.DefElem) *ast.DefElem { } } -func convertDefineStmt(n *nodes.DefineStmt) *ast.DefineStmt { +func convertDefineStmt(n *pg.DefineStmt) *ast.DefineStmt { if n == nil { return nil } return &ast.DefineStmt{ Kind: ast.ObjectType(n.Kind), Oldstyle: n.Oldstyle, - Defnames: convertList(n.Defnames), - Args: convertList(n.Args), - Definition: convertList(n.Definition), + Defnames: convertSlice(n.Defnames), + Args: convertSlice(n.Args), + Definition: convertSlice(n.Definition), IfNotExists: n.IfNotExists, } } -func convertDeleteStmt(n *nodes.DeleteStmt) *ast.DeleteStmt { +func convertDeleteStmt(n *pg.DeleteStmt) *ast.DeleteStmt { if n == nil { return nil } return &ast.DeleteStmt{ Relation: convertRangeVar(n.Relation), - UsingClause: convertList(n.UsingClause), + UsingClause: convertSlice(n.UsingClause), WhereClause: convertNode(n.WhereClause), - ReturningList: convertList(n.ReturningList), + ReturningList: convertSlice(n.ReturningList), WithClause: convertWithClause(n.WithClause), } } -func convertDiscardStmt(n *nodes.DiscardStmt) *ast.DiscardStmt { +func convertDiscardStmt(n *pg.DiscardStmt) *ast.DiscardStmt { if n == nil { return nil } @@ -1387,41 +1403,41 @@ func convertDiscardStmt(n *nodes.DiscardStmt) *ast.DiscardStmt { } } -func convertDoStmt(n *nodes.DoStmt) *ast.DoStmt { +func convertDoStmt(n *pg.DoStmt) *ast.DoStmt { if n == nil { return nil } return &ast.DoStmt{ - Args: convertList(n.Args), + Args: convertSlice(n.Args), } } -func convertDropOwnedStmt(n *nodes.DropOwnedStmt) *ast.DropOwnedStmt { +func convertDropOwnedStmt(n *pg.DropOwnedStmt) *ast.DropOwnedStmt { if n == nil { return nil } return &ast.DropOwnedStmt{ - Roles: convertList(n.Roles), + Roles: convertSlice(n.Roles), Behavior: ast.DropBehavior(n.Behavior), } } -func convertDropRoleStmt(n *nodes.DropRoleStmt) *ast.DropRoleStmt { +func convertDropRoleStmt(n *pg.DropRoleStmt) *ast.DropRoleStmt { if n == nil { return nil } return &ast.DropRoleStmt{ - Roles: convertList(n.Roles), + Roles: convertSlice(n.Roles), MissingOk: n.MissingOk, } } -func convertDropStmt(n *nodes.DropStmt) *ast.DropStmt { +func convertDropStmt(n *pg.DropStmt) *ast.DropStmt { if n == nil { return nil } return &ast.DropStmt{ - Objects: convertList(n.Objects), + Objects: convertSlice(n.Objects), RemoveType: ast.ObjectType(n.RemoveType), Behavior: ast.DropBehavior(n.Behavior), MissingOk: n.MissingOk, @@ -1429,7 +1445,7 @@ func convertDropStmt(n *nodes.DropStmt) *ast.DropStmt { } } -func convertDropSubscriptionStmt(n *nodes.DropSubscriptionStmt) *ast.DropSubscriptionStmt { +func convertDropSubscriptionStmt(n *pg.DropSubscriptionStmt) *ast.DropSubscriptionStmt { if n == nil { return nil } @@ -1440,7 +1456,7 @@ func convertDropSubscriptionStmt(n *nodes.DropSubscriptionStmt) *ast.DropSubscri } } -func convertDropTableSpaceStmt(n *nodes.DropTableSpaceStmt) *ast.DropTableSpaceStmt { +func convertDropTableSpaceStmt(n *pg.DropTableSpaceStmt) *ast.DropTableSpaceStmt { if n == nil { return nil } @@ -1450,7 +1466,7 @@ func convertDropTableSpaceStmt(n *nodes.DropTableSpaceStmt) *ast.DropTableSpaceS } } -func convertDropUserMappingStmt(n *nodes.DropUserMappingStmt) *ast.DropUserMappingStmt { +func convertDropUserMappingStmt(n *pg.DropUserMappingStmt) *ast.DropUserMappingStmt { if n == nil { return nil } @@ -1461,7 +1477,7 @@ func convertDropUserMappingStmt(n *nodes.DropUserMappingStmt) *ast.DropUserMappi } } -func convertDropdbStmt(n *nodes.DropdbStmt) *ast.DropdbStmt { +func convertDropdbStmt(n *pg.DropdbStmt) *ast.DropdbStmt { if n == nil { return nil } @@ -1471,34 +1487,34 @@ func convertDropdbStmt(n *nodes.DropdbStmt) *ast.DropdbStmt { } } -func convertExecuteStmt(n *nodes.ExecuteStmt) *ast.ExecuteStmt { +func convertExecuteStmt(n *pg.ExecuteStmt) *ast.ExecuteStmt { if n == nil { return nil } return &ast.ExecuteStmt{ Name: n.Name, - Params: convertList(n.Params), + Params: convertSlice(n.Params), } } -func convertExplainStmt(n *nodes.ExplainStmt) *ast.ExplainStmt { +func convertExplainStmt(n *pg.ExplainStmt) *ast.ExplainStmt { if n == nil { return nil } return &ast.ExplainStmt{ Query: convertNode(n.Query), - Options: convertList(n.Options), + Options: convertSlice(n.Options), } } -func convertExpr(n *nodes.Expr) *ast.Expr { +func convertExpr(n *pg.Expr) *ast.Expr { if n == nil { return nil } return &ast.Expr{} } -func convertFetchStmt(n *nodes.FetchStmt) *ast.FetchStmt { +func convertFetchStmt(n *pg.FetchStmt) *ast.FetchStmt { if n == nil { return nil } @@ -1510,7 +1526,7 @@ func convertFetchStmt(n *nodes.FetchStmt) *ast.FetchStmt { } } -func convertFieldSelect(n *nodes.FieldSelect) *ast.FieldSelect { +func convertFieldSelect(n *pg.FieldSelect) *ast.FieldSelect { if n == nil { return nil } @@ -1524,20 +1540,20 @@ func convertFieldSelect(n *nodes.FieldSelect) *ast.FieldSelect { } } -func convertFieldStore(n *nodes.FieldStore) *ast.FieldStore { +func convertFieldStore(n *pg.FieldStore) *ast.FieldStore { if n == nil { return nil } return &ast.FieldStore{ Xpr: convertNode(n.Xpr), Arg: convertNode(n.Arg), - Newvals: convertList(n.Newvals), - Fieldnums: convertList(n.Fieldnums), + Newvals: convertSlice(n.Newvals), + Fieldnums: convertSlice(n.Fieldnums), Resulttype: ast.Oid(n.Resulttype), } } -func convertFloat(n *nodes.Float) *ast.Float { +func convertFloat(n *pg.Float) *ast.Float { if n == nil { return nil } @@ -1546,17 +1562,17 @@ func convertFloat(n *nodes.Float) *ast.Float { } } -func convertFromExpr(n *nodes.FromExpr) *ast.FromExpr { +func convertFromExpr(n *pg.FromExpr) *ast.FromExpr { if n == nil { return nil } return &ast.FromExpr{ - Fromlist: convertList(n.Fromlist), + Fromlist: convertSlice(n.Fromlist), Quals: convertNode(n.Quals), } } -func convertFuncCall(n *nodes.FuncCall) *ast.FuncCall { +func convertFuncCall(n *pg.FuncCall) *ast.FuncCall { if n == nil { return nil } @@ -1567,9 +1583,9 @@ func convertFuncCall(n *nodes.FuncCall) *ast.FuncCall { } return &ast.FuncCall{ Func: fn, - Funcname: convertList(n.Funcname), - Args: convertList(n.Args), - AggOrder: convertList(n.AggOrder), + Funcname: convertSlice(n.Funcname), + Args: convertSlice(n.Args), + AggOrder: convertSlice(n.AggOrder), AggFilter: convertNode(n.AggFilter), AggWithinGroup: n.AggWithinGroup, AggStar: n.AggStar, @@ -1580,7 +1596,7 @@ func convertFuncCall(n *nodes.FuncCall) *ast.FuncCall { } } -func convertFuncExpr(n *nodes.FuncExpr) *ast.FuncExpr { +func convertFuncExpr(n *pg.FuncExpr) *ast.FuncExpr { if n == nil { return nil } @@ -1593,12 +1609,12 @@ func convertFuncExpr(n *nodes.FuncExpr) *ast.FuncExpr { Funcformat: ast.CoercionForm(n.Funcformat), Funccollid: ast.Oid(n.Funccollid), Inputcollid: ast.Oid(n.Inputcollid), - Args: convertList(n.Args), + Args: convertSlice(n.Args), Location: n.Location, } } -func convertFunctionParameter(n *nodes.FunctionParameter) *ast.FunctionParameter { +func convertFunctionParameter(n *pg.FunctionParameter) *ast.FunctionParameter { if n == nil { return nil } @@ -1610,13 +1626,13 @@ func convertFunctionParameter(n *nodes.FunctionParameter) *ast.FunctionParameter } } -func convertGrantRoleStmt(n *nodes.GrantRoleStmt) *ast.GrantRoleStmt { +func convertGrantRoleStmt(n *pg.GrantRoleStmt) *ast.GrantRoleStmt { if n == nil { return nil } return &ast.GrantRoleStmt{ - GrantedRoles: convertList(n.GrantedRoles), - GranteeRoles: convertList(n.GranteeRoles), + GrantedRoles: convertSlice(n.GrantedRoles), + GranteeRoles: convertSlice(n.GranteeRoles), IsGrant: n.IsGrant, AdminOpt: n.AdminOpt, Grantor: convertRoleSpec(n.Grantor), @@ -1624,7 +1640,7 @@ func convertGrantRoleStmt(n *nodes.GrantRoleStmt) *ast.GrantRoleStmt { } } -func convertGrantStmt(n *nodes.GrantStmt) *ast.GrantStmt { +func convertGrantStmt(n *pg.GrantStmt) *ast.GrantStmt { if n == nil { return nil } @@ -1632,40 +1648,40 @@ func convertGrantStmt(n *nodes.GrantStmt) *ast.GrantStmt { IsGrant: n.IsGrant, Targtype: ast.GrantTargetType(n.Targtype), Objtype: ast.GrantObjectType(n.Objtype), - Objects: convertList(n.Objects), - Privileges: convertList(n.Privileges), - Grantees: convertList(n.Grantees), + Objects: convertSlice(n.Objects), + Privileges: convertSlice(n.Privileges), + Grantees: convertSlice(n.Grantees), GrantOption: n.GrantOption, Behavior: ast.DropBehavior(n.Behavior), } } -func convertGroupingFunc(n *nodes.GroupingFunc) *ast.GroupingFunc { +func convertGroupingFunc(n *pg.GroupingFunc) *ast.GroupingFunc { if n == nil { return nil } return &ast.GroupingFunc{ Xpr: convertNode(n.Xpr), - Args: convertList(n.Args), - Refs: convertList(n.Refs), - Cols: convertList(n.Cols), + Args: convertSlice(n.Args), + Refs: convertSlice(n.Refs), + Cols: convertSlice(n.Cols), Agglevelsup: ast.Index(n.Agglevelsup), Location: n.Location, } } -func convertGroupingSet(n *nodes.GroupingSet) *ast.GroupingSet { +func convertGroupingSet(n *pg.GroupingSet) *ast.GroupingSet { if n == nil { return nil } return &ast.GroupingSet{ Kind: ast.GroupingSetKind(n.Kind), - Content: convertList(n.Content), + Content: convertSlice(n.Content), Location: n.Location, } } -func convertImportForeignSchemaStmt(n *nodes.ImportForeignSchemaStmt) *ast.ImportForeignSchemaStmt { +func convertImportForeignSchemaStmt(n *pg.ImportForeignSchemaStmt) *ast.ImportForeignSchemaStmt { if n == nil { return nil } @@ -1674,12 +1690,12 @@ func convertImportForeignSchemaStmt(n *nodes.ImportForeignSchemaStmt) *ast.Impor RemoteSchema: n.RemoteSchema, LocalSchema: n.LocalSchema, ListType: ast.ImportForeignSchemaType(n.ListType), - TableList: convertList(n.TableList), - Options: convertList(n.Options), + TableList: convertSlice(n.TableList), + Options: convertSlice(n.Options), } } -func convertIndexElem(n *nodes.IndexElem) *ast.IndexElem { +func convertIndexElem(n *pg.IndexElem) *ast.IndexElem { if n == nil { return nil } @@ -1687,14 +1703,14 @@ func convertIndexElem(n *nodes.IndexElem) *ast.IndexElem { Name: n.Name, Expr: convertNode(n.Expr), Indexcolname: n.Indexcolname, - Collation: convertList(n.Collation), - Opclass: convertList(n.Opclass), + Collation: convertSlice(n.Collation), + Opclass: convertSlice(n.Opclass), Ordering: ast.SortByDir(n.Ordering), NullsOrdering: ast.SortByNulls(n.NullsOrdering), } } -func convertIndexStmt(n *nodes.IndexStmt) *ast.IndexStmt { +func convertIndexStmt(n *pg.IndexStmt) *ast.IndexStmt { if n == nil { return nil } @@ -1703,10 +1719,10 @@ func convertIndexStmt(n *nodes.IndexStmt) *ast.IndexStmt { Relation: convertRangeVar(n.Relation), AccessMethod: n.AccessMethod, TableSpace: n.TableSpace, - IndexParams: convertList(n.IndexParams), - Options: convertList(n.Options), + IndexParams: convertSlice(n.IndexParams), + Options: convertSlice(n.Options), WhereClause: convertNode(n.WhereClause), - ExcludeOpNames: convertList(n.ExcludeOpNames), + ExcludeOpNames: convertSlice(n.ExcludeOpNames), Idxcomment: n.Idxcomment, IndexOid: ast.Oid(n.IndexOid), OldNode: ast.Oid(n.OldNode), @@ -1721,19 +1737,19 @@ func convertIndexStmt(n *nodes.IndexStmt) *ast.IndexStmt { } } -func convertInferClause(n *nodes.InferClause) *ast.InferClause { +func convertInferClause(n *pg.InferClause) *ast.InferClause { if n == nil { return nil } return &ast.InferClause{ - IndexElems: convertList(n.IndexElems), + IndexElems: convertSlice(n.IndexElems), WhereClause: convertNode(n.WhereClause), Conname: n.Conname, Location: n.Location, } } -func convertInferenceElem(n *nodes.InferenceElem) *ast.InferenceElem { +func convertInferenceElem(n *pg.InferenceElem) *ast.InferenceElem { if n == nil { return nil } @@ -1745,7 +1761,7 @@ func convertInferenceElem(n *nodes.InferenceElem) *ast.InferenceElem { } } -func convertInlineCodeBlock(n *nodes.InlineCodeBlock) *ast.InlineCodeBlock { +func convertInlineCodeBlock(n *pg.InlineCodeBlock) *ast.InlineCodeBlock { if n == nil { return nil } @@ -1756,22 +1772,22 @@ func convertInlineCodeBlock(n *nodes.InlineCodeBlock) *ast.InlineCodeBlock { } } -func convertInsertStmt(n *nodes.InsertStmt) *ast.InsertStmt { +func convertInsertStmt(n *pg.InsertStmt) *ast.InsertStmt { if n == nil { return nil } return &ast.InsertStmt{ Relation: convertRangeVar(n.Relation), - Cols: convertList(n.Cols), + Cols: convertSlice(n.Cols), SelectStmt: convertNode(n.SelectStmt), OnConflictClause: convertOnConflictClause(n.OnConflictClause), - ReturningList: convertList(n.ReturningList), + ReturningList: convertSlice(n.ReturningList), WithClause: convertWithClause(n.WithClause), Override: ast.OverridingKind(n.Override), } } -func convertInteger(n *nodes.Integer) *ast.Integer { +func convertInteger(n *pg.Integer) *ast.Integer { if n == nil { return nil } @@ -1780,14 +1796,14 @@ func convertInteger(n *nodes.Integer) *ast.Integer { } } -func convertIntoClause(n *nodes.IntoClause) *ast.IntoClause { +func convertIntoClause(n *pg.IntoClause) *ast.IntoClause { if n == nil { return nil } return &ast.IntoClause{ Rel: convertRangeVar(n.Rel), - ColNames: convertList(n.ColNames), - Options: convertList(n.Options), + ColNames: convertSlice(n.ColNames), + Options: convertSlice(n.Options), OnCommit: ast.OnCommitAction(n.OnCommit), TableSpaceName: n.TableSpaceName, ViewQuery: convertNode(n.ViewQuery), @@ -1795,7 +1811,7 @@ func convertIntoClause(n *nodes.IntoClause) *ast.IntoClause { } } -func convertJoinExpr(n *nodes.JoinExpr) *ast.JoinExpr { +func convertJoinExpr(n *pg.JoinExpr) *ast.JoinExpr { if n == nil { return nil } @@ -1804,14 +1820,14 @@ func convertJoinExpr(n *nodes.JoinExpr) *ast.JoinExpr { IsNatural: n.IsNatural, Larg: convertNode(n.Larg), Rarg: convertNode(n.Rarg), - UsingClause: convertList(n.UsingClause), + UsingClause: convertSlice(n.UsingClause), Quals: convertNode(n.Quals), Alias: convertAlias(n.Alias), Rtindex: n.Rtindex, } } -func convertListenStmt(n *nodes.ListenStmt) *ast.ListenStmt { +func convertSliceenStmt(n *pg.ListenStmt) *ast.ListenStmt { if n == nil { return nil } @@ -1820,7 +1836,7 @@ func convertListenStmt(n *nodes.ListenStmt) *ast.ListenStmt { } } -func convertLoadStmt(n *nodes.LoadStmt) *ast.LoadStmt { +func convertLoadStmt(n *pg.LoadStmt) *ast.LoadStmt { if n == nil { return nil } @@ -1829,29 +1845,29 @@ func convertLoadStmt(n *nodes.LoadStmt) *ast.LoadStmt { } } -func convertLockStmt(n *nodes.LockStmt) *ast.LockStmt { +func convertLockStmt(n *pg.LockStmt) *ast.LockStmt { if n == nil { return nil } return &ast.LockStmt{ - Relations: convertList(n.Relations), + Relations: convertSlice(n.Relations), Mode: n.Mode, Nowait: n.Nowait, } } -func convertLockingClause(n *nodes.LockingClause) *ast.LockingClause { +func convertLockingClause(n *pg.LockingClause) *ast.LockingClause { if n == nil { return nil } return &ast.LockingClause{ - LockedRels: convertList(n.LockedRels), + LockedRels: convertSlice(n.LockedRels), Strength: ast.LockClauseStrength(n.Strength), WaitPolicy: ast.LockWaitPolicy(n.WaitPolicy), } } -func convertMinMaxExpr(n *nodes.MinMaxExpr) *ast.MinMaxExpr { +func convertMinMaxExpr(n *pg.MinMaxExpr) *ast.MinMaxExpr { if n == nil { return nil } @@ -1861,12 +1877,12 @@ func convertMinMaxExpr(n *nodes.MinMaxExpr) *ast.MinMaxExpr { Minmaxcollid: ast.Oid(n.Minmaxcollid), Inputcollid: ast.Oid(n.Inputcollid), Op: ast.MinMaxOp(n.Op), - Args: convertList(n.Args), + Args: convertSlice(n.Args), Location: n.Location, } } -func convertMultiAssignRef(n *nodes.MultiAssignRef) *ast.MultiAssignRef { +func convertMultiAssignRef(n *pg.MultiAssignRef) *ast.MultiAssignRef { if n == nil { return nil } @@ -1877,7 +1893,7 @@ func convertMultiAssignRef(n *nodes.MultiAssignRef) *ast.MultiAssignRef { } } -func convertNamedArgExpr(n *nodes.NamedArgExpr) *ast.NamedArgExpr { +func convertNamedArgExpr(n *pg.NamedArgExpr) *ast.NamedArgExpr { if n == nil { return nil } @@ -1890,7 +1906,7 @@ func convertNamedArgExpr(n *nodes.NamedArgExpr) *ast.NamedArgExpr { } } -func convertNextValueExpr(n *nodes.NextValueExpr) *ast.NextValueExpr { +func convertNextValueExpr(n *pg.NextValueExpr) *ast.NextValueExpr { if n == nil { return nil } @@ -1901,7 +1917,7 @@ func convertNextValueExpr(n *nodes.NextValueExpr) *ast.NextValueExpr { } } -func convertNotifyStmt(n *nodes.NotifyStmt) *ast.NotifyStmt { +func convertNotifyStmt(n *pg.NotifyStmt) *ast.NotifyStmt { if n == nil { return nil } @@ -1911,14 +1927,14 @@ func convertNotifyStmt(n *nodes.NotifyStmt) *ast.NotifyStmt { } } -func convertNull(n *nodes.Null) *ast.Null { +func convertNull(n *pg.Null) *ast.Null { if n == nil { return nil } return &ast.Null{} } -func convertNullTest(n *nodes.NullTest) *ast.NullTest { +func convertNullTest(n *pg.NullTest) *ast.NullTest { if n == nil { return nil } @@ -1931,47 +1947,47 @@ func convertNullTest(n *nodes.NullTest) *ast.NullTest { } } -func convertObjectWithArgs(n *nodes.ObjectWithArgs) *ast.ObjectWithArgs { +func convertObjectWithArgs(n *pg.ObjectWithArgs) *ast.ObjectWithArgs { if n == nil { return nil } return &ast.ObjectWithArgs{ - Objname: convertList(n.Objname), - Objargs: convertList(n.Objargs), + Objname: convertSlice(n.Objname), + Objargs: convertSlice(n.Objargs), ArgsUnspecified: n.ArgsUnspecified, } } -func convertOnConflictClause(n *nodes.OnConflictClause) *ast.OnConflictClause { +func convertOnConflictClause(n *pg.OnConflictClause) *ast.OnConflictClause { if n == nil { return nil } return &ast.OnConflictClause{ Action: ast.OnConflictAction(n.Action), Infer: convertInferClause(n.Infer), - TargetList: convertList(n.TargetList), + TargetList: convertSlice(n.TargetList), WhereClause: convertNode(n.WhereClause), Location: n.Location, } } -func convertOnConflictExpr(n *nodes.OnConflictExpr) *ast.OnConflictExpr { +func convertOnConflictExpr(n *pg.OnConflictExpr) *ast.OnConflictExpr { if n == nil { return nil } return &ast.OnConflictExpr{ Action: ast.OnConflictAction(n.Action), - ArbiterElems: convertList(n.ArbiterElems), + ArbiterElems: convertSlice(n.ArbiterElems), ArbiterWhere: convertNode(n.ArbiterWhere), Constraint: ast.Oid(n.Constraint), - OnConflictSet: convertList(n.OnConflictSet), + OnConflictSet: convertSlice(n.OnConflictSet), OnConflictWhere: convertNode(n.OnConflictWhere), ExclRelIndex: n.ExclRelIndex, - ExclRelTlist: convertList(n.ExclRelTlist), + ExclRelTlist: convertSlice(n.ExclRelTlist), } } -func convertOpExpr(n *nodes.OpExpr) *ast.OpExpr { +func convertOpExpr(n *pg.OpExpr) *ast.OpExpr { if n == nil { return nil } @@ -1983,12 +1999,12 @@ func convertOpExpr(n *nodes.OpExpr) *ast.OpExpr { Opretset: n.Opretset, Opcollid: ast.Oid(n.Opcollid), Inputcollid: ast.Oid(n.Inputcollid), - Args: convertList(n.Args), + Args: convertSlice(n.Args), Location: n.Location, } } -func convertParam(n *nodes.Param) *ast.Param { +func convertParam(n *pg.Param) *ast.Param { if n == nil { return nil } @@ -2003,7 +2019,7 @@ func convertParam(n *nodes.Param) *ast.Param { } } -func convertParamExecData(n *nodes.ParamExecData) *ast.ParamExecData { +func convertParamExecData(n *pg.ParamExecData) *ast.ParamExecData { if n == nil { return nil } @@ -2014,7 +2030,7 @@ func convertParamExecData(n *nodes.ParamExecData) *ast.ParamExecData { } } -func convertParamExternData(n *nodes.ParamExternData) *ast.ParamExternData { +func convertParamExternData(n *pg.ParamExternData) *ast.ParamExternData { if n == nil { return nil } @@ -2026,7 +2042,7 @@ func convertParamExternData(n *nodes.ParamExternData) *ast.ParamExternData { } } -func convertParamListInfoData(n *nodes.ParamListInfoData) *ast.ParamListInfoData { +func convertParamListInfoData(n *pg.ParamListInfoData) *ast.ParamListInfoData { if n == nil { return nil } @@ -2038,7 +2054,7 @@ func convertParamListInfoData(n *nodes.ParamListInfoData) *ast.ParamListInfoData } } -func convertParamRef(n *nodes.ParamRef) *ast.ParamRef { +func convertParamRef(n *pg.ParamRef) *ast.ParamRef { if n == nil { return nil } @@ -2048,20 +2064,20 @@ func convertParamRef(n *nodes.ParamRef) *ast.ParamRef { } } -func convertPartitionBoundSpec(n *nodes.PartitionBoundSpec) *ast.PartitionBoundSpec { +func convertPartitionBoundSpec(n *pg.PartitionBoundSpec) *ast.PartitionBoundSpec { if n == nil { return nil } return &ast.PartitionBoundSpec{ Strategy: n.Strategy, - Listdatums: convertList(n.Listdatums), - Lowerdatums: convertList(n.Lowerdatums), - Upperdatums: convertList(n.Upperdatums), + Listdatums: convertSlice(n.Listdatums), + Lowerdatums: convertSlice(n.Lowerdatums), + Upperdatums: convertSlice(n.Upperdatums), Location: n.Location, } } -func convertPartitionCmd(n *nodes.PartitionCmd) *ast.PartitionCmd { +func convertPartitionCmd(n *pg.PartitionCmd) *ast.PartitionCmd { if n == nil { return nil } @@ -2071,20 +2087,20 @@ func convertPartitionCmd(n *nodes.PartitionCmd) *ast.PartitionCmd { } } -func convertPartitionElem(n *nodes.PartitionElem) *ast.PartitionElem { +func convertPartitionElem(n *pg.PartitionElem) *ast.PartitionElem { if n == nil { return nil } return &ast.PartitionElem{ Name: n.Name, Expr: convertNode(n.Expr), - Collation: convertList(n.Collation), - Opclass: convertList(n.Opclass), + Collation: convertSlice(n.Collation), + Opclass: convertSlice(n.Opclass), Location: n.Location, } } -func convertPartitionRangeDatum(n *nodes.PartitionRangeDatum) *ast.PartitionRangeDatum { +func convertPartitionRangeDatum(n *pg.PartitionRangeDatum) *ast.PartitionRangeDatum { if n == nil { return nil } @@ -2095,29 +2111,29 @@ func convertPartitionRangeDatum(n *nodes.PartitionRangeDatum) *ast.PartitionRang } } -func convertPartitionSpec(n *nodes.PartitionSpec) *ast.PartitionSpec { +func convertPartitionSpec(n *pg.PartitionSpec) *ast.PartitionSpec { if n == nil { return nil } return &ast.PartitionSpec{ Strategy: n.Strategy, - PartParams: convertList(n.PartParams), + PartParams: convertSlice(n.PartParams), Location: n.Location, } } -func convertPrepareStmt(n *nodes.PrepareStmt) *ast.PrepareStmt { +func convertPrepareStmt(n *pg.PrepareStmt) *ast.PrepareStmt { if n == nil { return nil } return &ast.PrepareStmt{ Name: n.Name, - Argtypes: convertList(n.Argtypes), + Argtypes: convertSlice(n.Argtypes), Query: convertNode(n.Query), } } -func convertQuery(n *nodes.Query) *ast.Query { +func convertQuery(n *pg.Query) *ast.Query { if n == nil { return nil } @@ -2137,31 +2153,31 @@ func convertQuery(n *nodes.Query) *ast.Query { HasModifyingCte: n.HasModifyingCte, HasForUpdate: n.HasForUpdate, HasRowSecurity: n.HasRowSecurity, - CteList: convertList(n.CteList), - Rtable: convertList(n.Rtable), + CteList: convertSlice(n.CteList), + Rtable: convertSlice(n.Rtable), Jointree: convertFromExpr(n.Jointree), - TargetList: convertList(n.TargetList), + TargetList: convertSlice(n.TargetList), Override: ast.OverridingKind(n.Override), OnConflict: convertOnConflictExpr(n.OnConflict), - ReturningList: convertList(n.ReturningList), - GroupClause: convertList(n.GroupClause), - GroupingSets: convertList(n.GroupingSets), + ReturningList: convertSlice(n.ReturningList), + GroupClause: convertSlice(n.GroupClause), + GroupingSets: convertSlice(n.GroupingSets), HavingQual: convertNode(n.HavingQual), - WindowClause: convertList(n.WindowClause), - DistinctClause: convertList(n.DistinctClause), - SortClause: convertList(n.SortClause), + WindowClause: convertSlice(n.WindowClause), + DistinctClause: convertSlice(n.DistinctClause), + SortClause: convertSlice(n.SortClause), LimitOffset: convertNode(n.LimitOffset), LimitCount: convertNode(n.LimitCount), - RowMarks: convertList(n.RowMarks), + RowMarks: convertSlice(n.RowMarks), SetOperations: convertNode(n.SetOperations), - ConstraintDeps: convertList(n.ConstraintDeps), - WithCheckOptions: convertList(n.WithCheckOptions), + ConstraintDeps: convertSlice(n.ConstraintDeps), + WithCheckOptions: convertSlice(n.WithCheckOptions), StmtLocation: n.StmtLocation, StmtLen: n.StmtLen, } } -func convertRangeFunction(n *nodes.RangeFunction) *ast.RangeFunction { +func convertRangeFunction(n *pg.RangeFunction) *ast.RangeFunction { if n == nil { return nil } @@ -2169,13 +2185,13 @@ func convertRangeFunction(n *nodes.RangeFunction) *ast.RangeFunction { Lateral: n.Lateral, Ordinality: n.Ordinality, IsRowsfrom: n.IsRowsfrom, - Functions: convertList(n.Functions), + Functions: convertSlice(n.Functions), Alias: convertAlias(n.Alias), - Coldeflist: convertList(n.Coldeflist), + Coldeflist: convertSlice(n.Coldeflist), } } -func convertRangeSubselect(n *nodes.RangeSubselect) *ast.RangeSubselect { +func convertRangeSubselect(n *pg.RangeSubselect) *ast.RangeSubselect { if n == nil { return nil } @@ -2186,7 +2202,7 @@ func convertRangeSubselect(n *nodes.RangeSubselect) *ast.RangeSubselect { } } -func convertRangeTableFunc(n *nodes.RangeTableFunc) *ast.RangeTableFunc { +func convertRangeTableFunc(n *pg.RangeTableFunc) *ast.RangeTableFunc { if n == nil { return nil } @@ -2194,14 +2210,14 @@ func convertRangeTableFunc(n *nodes.RangeTableFunc) *ast.RangeTableFunc { Lateral: n.Lateral, Docexpr: convertNode(n.Docexpr), Rowexpr: convertNode(n.Rowexpr), - Namespaces: convertList(n.Namespaces), - Columns: convertList(n.Columns), + Namespaces: convertSlice(n.Namespaces), + Columns: convertSlice(n.Columns), Alias: convertAlias(n.Alias), Location: n.Location, } } -func convertRangeTableFuncCol(n *nodes.RangeTableFuncCol) *ast.RangeTableFuncCol { +func convertRangeTableFuncCol(n *pg.RangeTableFuncCol) *ast.RangeTableFuncCol { if n == nil { return nil } @@ -2216,20 +2232,20 @@ func convertRangeTableFuncCol(n *nodes.RangeTableFuncCol) *ast.RangeTableFuncCol } } -func convertRangeTableSample(n *nodes.RangeTableSample) *ast.RangeTableSample { +func convertRangeTableSample(n *pg.RangeTableSample) *ast.RangeTableSample { if n == nil { return nil } return &ast.RangeTableSample{ Relation: convertNode(n.Relation), - Method: convertList(n.Method), - Args: convertList(n.Args), + Method: convertSlice(n.Method), + Args: convertSlice(n.Args), Repeatable: convertNode(n.Repeatable), Location: n.Location, } } -func convertRangeTblEntry(n *nodes.RangeTblEntry) *ast.RangeTblEntry { +func convertRangeTblEntry(n *pg.RangeTblEntry) *ast.RangeTblEntry { if n == nil { return nil } @@ -2241,17 +2257,17 @@ func convertRangeTblEntry(n *nodes.RangeTblEntry) *ast.RangeTblEntry { Subquery: convertQuery(n.Subquery), SecurityBarrier: n.SecurityBarrier, Jointype: ast.JoinType(n.Jointype), - Joinaliasvars: convertList(n.Joinaliasvars), - Functions: convertList(n.Functions), + Joinaliasvars: convertSlice(n.Joinaliasvars), + Functions: convertSlice(n.Functions), Funcordinality: n.Funcordinality, Tablefunc: convertTableFunc(n.Tablefunc), - ValuesLists: convertList(n.ValuesLists), + ValuesLists: convertSlice(n.ValuesLists), Ctename: n.Ctename, Ctelevelsup: ast.Index(n.Ctelevelsup), SelfReference: n.SelfReference, - Coltypes: convertList(n.Coltypes), - Coltypmods: convertList(n.Coltypmods), - Colcollations: convertList(n.Colcollations), + Coltypes: convertSlice(n.Coltypes), + Coltypmods: convertSlice(n.Coltypmods), + Colcollations: convertSlice(n.Colcollations), Enrname: n.Enrname, Enrtuples: n.Enrtuples, Alias: convertAlias(n.Alias), @@ -2264,26 +2280,26 @@ func convertRangeTblEntry(n *nodes.RangeTblEntry) *ast.RangeTblEntry { SelectedCols: n.SelectedCols, InsertedCols: n.InsertedCols, UpdatedCols: n.UpdatedCols, - SecurityQuals: convertList(n.SecurityQuals), + SecurityQuals: convertSlice(n.SecurityQuals), } } -func convertRangeTblFunction(n *nodes.RangeTblFunction) *ast.RangeTblFunction { +func convertRangeTblFunction(n *pg.RangeTblFunction) *ast.RangeTblFunction { if n == nil { return nil } return &ast.RangeTblFunction{ Funcexpr: convertNode(n.Funcexpr), Funccolcount: n.Funccolcount, - Funccolnames: convertList(n.Funccolnames), - Funccoltypes: convertList(n.Funccoltypes), - Funccoltypmods: convertList(n.Funccoltypmods), - Funccolcollations: convertList(n.Funccolcollations), + Funccolnames: convertSlice(n.Funccolnames), + Funccoltypes: convertSlice(n.Funccoltypes), + Funccoltypmods: convertSlice(n.Funccoltypmods), + Funccolcollations: convertSlice(n.Funccolcollations), Funcparams: n.Funcparams, } } -func convertRangeTblRef(n *nodes.RangeTblRef) *ast.RangeTblRef { +func convertRangeTblRef(n *pg.RangeTblRef) *ast.RangeTblRef { if n == nil { return nil } @@ -2292,7 +2308,7 @@ func convertRangeTblRef(n *nodes.RangeTblRef) *ast.RangeTblRef { } } -func convertRangeVar(n *nodes.RangeVar) *ast.RangeVar { +func convertRangeVar(n *pg.RangeVar) *ast.RangeVar { if n == nil { return nil } @@ -2307,7 +2323,7 @@ func convertRangeVar(n *nodes.RangeVar) *ast.RangeVar { } } -func convertRawStmt(n *nodes.RawStmt) *ast.RawStmt { +func convertRawStmt(n *pg.RawStmt) *ast.RawStmt { if n == nil { return nil } @@ -2318,17 +2334,17 @@ func convertRawStmt(n *nodes.RawStmt) *ast.RawStmt { } } -func convertReassignOwnedStmt(n *nodes.ReassignOwnedStmt) *ast.ReassignOwnedStmt { +func convertReassignOwnedStmt(n *pg.ReassignOwnedStmt) *ast.ReassignOwnedStmt { if n == nil { return nil } return &ast.ReassignOwnedStmt{ - Roles: convertList(n.Roles), + Roles: convertSlice(n.Roles), Newrole: convertRoleSpec(n.Newrole), } } -func convertRefreshMatViewStmt(n *nodes.RefreshMatViewStmt) *ast.RefreshMatViewStmt { +func convertRefreshMatViewStmt(n *pg.RefreshMatViewStmt) *ast.RefreshMatViewStmt { if n == nil { return nil } @@ -2339,7 +2355,7 @@ func convertRefreshMatViewStmt(n *nodes.RefreshMatViewStmt) *ast.RefreshMatViewS } } -func convertReindexStmt(n *nodes.ReindexStmt) *ast.ReindexStmt { +func convertReindexStmt(n *pg.ReindexStmt) *ast.ReindexStmt { if n == nil { return nil } @@ -2351,7 +2367,7 @@ func convertReindexStmt(n *nodes.ReindexStmt) *ast.ReindexStmt { } } -func convertRelabelType(n *nodes.RelabelType) *ast.RelabelType { +func convertRelabelType(n *pg.RelabelType) *ast.RelabelType { if n == nil { return nil } @@ -2366,7 +2382,7 @@ func convertRelabelType(n *nodes.RelabelType) *ast.RelabelType { } } -func convertRenameStmt(n *nodes.RenameStmt) *ast.RenameStmt { +func convertRenameStmt(n *pg.RenameStmt) *ast.RenameStmt { if n == nil { return nil } @@ -2382,7 +2398,7 @@ func convertRenameStmt(n *nodes.RenameStmt) *ast.RenameStmt { } } -func convertReplicaIdentityStmt(n *nodes.ReplicaIdentityStmt) *ast.ReplicaIdentityStmt { +func convertReplicaIdentityStmt(n *pg.ReplicaIdentityStmt) *ast.ReplicaIdentityStmt { if n == nil { return nil } @@ -2392,19 +2408,19 @@ func convertReplicaIdentityStmt(n *nodes.ReplicaIdentityStmt) *ast.ReplicaIdenti } } -func convertResTarget(n *nodes.ResTarget) *ast.ResTarget { +func convertResTarget(n *pg.ResTarget) *ast.ResTarget { if n == nil { return nil } return &ast.ResTarget{ Name: n.Name, - Indirection: convertList(n.Indirection), + Indirection: convertSlice(n.Indirection), Val: convertNode(n.Val), Location: n.Location, } } -func convertRoleSpec(n *nodes.RoleSpec) *ast.RoleSpec { +func convertRoleSpec(n *pg.RoleSpec) *ast.RoleSpec { if n == nil { return nil } @@ -2415,36 +2431,36 @@ func convertRoleSpec(n *nodes.RoleSpec) *ast.RoleSpec { } } -func convertRowCompareExpr(n *nodes.RowCompareExpr) *ast.RowCompareExpr { +func convertRowCompareExpr(n *pg.RowCompareExpr) *ast.RowCompareExpr { if n == nil { return nil } return &ast.RowCompareExpr{ Xpr: convertNode(n.Xpr), Rctype: ast.RowCompareType(n.Rctype), - Opnos: convertList(n.Opnos), - Opfamilies: convertList(n.Opfamilies), - Inputcollids: convertList(n.Inputcollids), - Largs: convertList(n.Largs), - Rargs: convertList(n.Rargs), + Opnos: convertSlice(n.Opnos), + Opfamilies: convertSlice(n.Opfamilies), + Inputcollids: convertSlice(n.Inputcollids), + Largs: convertSlice(n.Largs), + Rargs: convertSlice(n.Rargs), } } -func convertRowExpr(n *nodes.RowExpr) *ast.RowExpr { +func convertRowExpr(n *pg.RowExpr) *ast.RowExpr { if n == nil { return nil } return &ast.RowExpr{ Xpr: convertNode(n.Xpr), - Args: convertList(n.Args), + Args: convertSlice(n.Args), RowTypeid: ast.Oid(n.RowTypeid), RowFormat: ast.CoercionForm(n.RowFormat), - Colnames: convertList(n.Colnames), + Colnames: convertSlice(n.Colnames), Location: n.Location, } } -func convertRowMarkClause(n *nodes.RowMarkClause) *ast.RowMarkClause { +func convertRowMarkClause(n *pg.RowMarkClause) *ast.RowMarkClause { if n == nil { return nil } @@ -2456,7 +2472,7 @@ func convertRowMarkClause(n *nodes.RowMarkClause) *ast.RowMarkClause { } } -func convertRuleStmt(n *nodes.RuleStmt) *ast.RuleStmt { +func convertRuleStmt(n *pg.RuleStmt) *ast.RuleStmt { if n == nil { return nil } @@ -2466,12 +2482,12 @@ func convertRuleStmt(n *nodes.RuleStmt) *ast.RuleStmt { WhereClause: convertNode(n.WhereClause), Event: ast.CmdType(n.Event), Instead: n.Instead, - Actions: convertList(n.Actions), + Actions: convertSlice(n.Actions), Replace: n.Replace, } } -func convertSQLValueFunction(n *nodes.SQLValueFunction) *ast.SQLValueFunction { +func convertSQLValueFunction(n *pg.SQLValueFunction) *ast.SQLValueFunction { if n == nil { return nil } @@ -2484,7 +2500,7 @@ func convertSQLValueFunction(n *nodes.SQLValueFunction) *ast.SQLValueFunction { } } -func convertScalarArrayOpExpr(n *nodes.ScalarArrayOpExpr) *ast.ScalarArrayOpExpr { +func convertScalarArrayOpExpr(n *pg.ScalarArrayOpExpr) *ast.ScalarArrayOpExpr { if n == nil { return nil } @@ -2494,12 +2510,12 @@ func convertScalarArrayOpExpr(n *nodes.ScalarArrayOpExpr) *ast.ScalarArrayOpExpr Opfuncid: ast.Oid(n.Opfuncid), UseOr: n.UseOr, Inputcollid: ast.Oid(n.Inputcollid), - Args: convertList(n.Args), + Args: convertSlice(n.Args), Location: n.Location, } } -func convertSecLabelStmt(n *nodes.SecLabelStmt) *ast.SecLabelStmt { +func convertSecLabelStmt(n *pg.SecLabelStmt) *ast.SecLabelStmt { if n == nil { return nil } @@ -2511,24 +2527,24 @@ func convertSecLabelStmt(n *nodes.SecLabelStmt) *ast.SecLabelStmt { } } -func convertSelectStmt(n *nodes.SelectStmt) *ast.SelectStmt { +func convertSelectStmt(n *pg.SelectStmt) *ast.SelectStmt { if n == nil { return nil } return &ast.SelectStmt{ - DistinctClause: convertList(n.DistinctClause), + DistinctClause: convertSlice(n.DistinctClause), IntoClause: convertIntoClause(n.IntoClause), - TargetList: convertList(n.TargetList), - FromClause: convertList(n.FromClause), + TargetList: convertSlice(n.TargetList), + FromClause: convertSlice(n.FromClause), WhereClause: convertNode(n.WhereClause), - GroupClause: convertList(n.GroupClause), + GroupClause: convertSlice(n.GroupClause), HavingClause: convertNode(n.HavingClause), - WindowClause: convertList(n.WindowClause), + WindowClause: convertSlice(n.WindowClause), ValuesLists: convertValuesList(n.ValuesLists), - SortClause: convertList(n.SortClause), + SortClause: convertSlice(n.SortClause), LimitOffset: convertNode(n.LimitOffset), LimitCount: convertNode(n.LimitCount), - LockingClause: convertList(n.LockingClause), + LockingClause: convertSlice(n.LockingClause), WithClause: convertWithClause(n.WithClause), Op: ast.SetOperation(n.Op), All: n.All, @@ -2537,7 +2553,7 @@ func convertSelectStmt(n *nodes.SelectStmt) *ast.SelectStmt { } } -func convertSetOperationStmt(n *nodes.SetOperationStmt) *ast.SetOperationStmt { +func convertSetOperationStmt(n *pg.SetOperationStmt) *ast.SetOperationStmt { if n == nil { return nil } @@ -2546,14 +2562,14 @@ func convertSetOperationStmt(n *nodes.SetOperationStmt) *ast.SetOperationStmt { All: n.All, Larg: convertNode(n.Larg), Rarg: convertNode(n.Rarg), - ColTypes: convertList(n.ColTypes), - ColTypmods: convertList(n.ColTypmods), - ColCollations: convertList(n.ColCollations), - GroupClauses: convertList(n.GroupClauses), + ColTypes: convertSlice(n.ColTypes), + ColTypmods: convertSlice(n.ColTypmods), + ColCollations: convertSlice(n.ColCollations), + GroupClauses: convertSlice(n.GroupClauses), } } -func convertSetToDefault(n *nodes.SetToDefault) *ast.SetToDefault { +func convertSetToDefault(n *pg.SetToDefault) *ast.SetToDefault { if n == nil { return nil } @@ -2566,7 +2582,7 @@ func convertSetToDefault(n *nodes.SetToDefault) *ast.SetToDefault { } } -func convertSortBy(n *nodes.SortBy) *ast.SortBy { +func convertSortBy(n *pg.SortBy) *ast.SortBy { if n == nil { return nil } @@ -2574,12 +2590,12 @@ func convertSortBy(n *nodes.SortBy) *ast.SortBy { Node: convertNode(n.Node), SortbyDir: ast.SortByDir(n.SortbyDir), SortbyNulls: ast.SortByNulls(n.SortbyNulls), - UseOp: convertList(n.UseOp), + UseOp: convertSlice(n.UseOp), Location: n.Location, } } -func convertSortGroupClause(n *nodes.SortGroupClause) *ast.SortGroupClause { +func convertSortGroupClause(n *pg.SortGroupClause) *ast.SortGroupClause { if n == nil { return nil } @@ -2592,7 +2608,7 @@ func convertSortGroupClause(n *nodes.SortGroupClause) *ast.SortGroupClause { } } -func convertString(n *nodes.String) *ast.String { +func convertString(n *pg.String) *ast.String { if n == nil { return nil } @@ -2601,7 +2617,7 @@ func convertString(n *nodes.String) *ast.String { } } -func convertSubLink(n *nodes.SubLink) *ast.SubLink { +func convertSubLink(n *pg.SubLink) *ast.SubLink { if n == nil { return nil } @@ -2610,13 +2626,13 @@ func convertSubLink(n *nodes.SubLink) *ast.SubLink { SubLinkType: ast.SubLinkType(n.SubLinkType), SubLinkId: n.SubLinkId, Testexpr: convertNode(n.Testexpr), - OperName: convertList(n.OperName), + OperName: convertSlice(n.OperName), Subselect: convertNode(n.Subselect), Location: n.Location, } } -func convertSubPlan(n *nodes.SubPlan) *ast.SubPlan { +func convertSubPlan(n *pg.SubPlan) *ast.SubPlan { if n == nil { return nil } @@ -2624,7 +2640,7 @@ func convertSubPlan(n *nodes.SubPlan) *ast.SubPlan { Xpr: convertNode(n.Xpr), SubLinkType: ast.SubLinkType(n.SubLinkType), Testexpr: convertNode(n.Testexpr), - ParamIds: convertList(n.ParamIds), + ParamIds: convertSlice(n.ParamIds), PlanId: n.PlanId, PlanName: n.PlanName, FirstColType: ast.Oid(n.FirstColType), @@ -2633,36 +2649,36 @@ func convertSubPlan(n *nodes.SubPlan) *ast.SubPlan { UseHashTable: n.UseHashTable, UnknownEqFalse: n.UnknownEqFalse, ParallelSafe: n.ParallelSafe, - SetParam: convertList(n.SetParam), - ParParam: convertList(n.ParParam), - Args: convertList(n.Args), + SetParam: convertSlice(n.SetParam), + ParParam: convertSlice(n.ParParam), + Args: convertSlice(n.Args), StartupCost: ast.Cost(n.StartupCost), PerCallCost: ast.Cost(n.PerCallCost), } } -func convertTableFunc(n *nodes.TableFunc) *ast.TableFunc { +func convertTableFunc(n *pg.TableFunc) *ast.TableFunc { if n == nil { return nil } return &ast.TableFunc{ - NsUris: convertList(n.NsUris), - NsNames: convertList(n.NsNames), + NsUris: convertSlice(n.NsUris), + NsNames: convertSlice(n.NsNames), Docexpr: convertNode(n.Docexpr), Rowexpr: convertNode(n.Rowexpr), - Colnames: convertList(n.Colnames), - Coltypes: convertList(n.Coltypes), - Coltypmods: convertList(n.Coltypmods), - Colcollations: convertList(n.Colcollations), - Colexprs: convertList(n.Colexprs), - Coldefexprs: convertList(n.Coldefexprs), + Colnames: convertSlice(n.Colnames), + Coltypes: convertSlice(n.Coltypes), + Coltypmods: convertSlice(n.Coltypmods), + Colcollations: convertSlice(n.Colcollations), + Colexprs: convertSlice(n.Colexprs), + Coldefexprs: convertSlice(n.Coldefexprs), Notnulls: n.Notnulls, Ordinalitycol: n.Ordinalitycol, Location: n.Location, } } -func convertTableLikeClause(n *nodes.TableLikeClause) *ast.TableLikeClause { +func convertTableLikeClause(n *pg.TableLikeClause) *ast.TableLikeClause { if n == nil { return nil } @@ -2672,18 +2688,18 @@ func convertTableLikeClause(n *nodes.TableLikeClause) *ast.TableLikeClause { } } -func convertTableSampleClause(n *nodes.TableSampleClause) *ast.TableSampleClause { +func convertTableSampleClause(n *pg.TableSampleClause) *ast.TableSampleClause { if n == nil { return nil } return &ast.TableSampleClause{ Tsmhandler: ast.Oid(n.Tsmhandler), - Args: convertList(n.Args), + Args: convertSlice(n.Args), Repeatable: convertNode(n.Repeatable), } } -func convertTargetEntry(n *nodes.TargetEntry) *ast.TargetEntry { +func convertTargetEntry(n *pg.TargetEntry) *ast.TargetEntry { if n == nil { return nil } @@ -2699,18 +2715,18 @@ func convertTargetEntry(n *nodes.TargetEntry) *ast.TargetEntry { } } -func convertTransactionStmt(n *nodes.TransactionStmt) *ast.TransactionStmt { +func convertTransactionStmt(n *pg.TransactionStmt) *ast.TransactionStmt { if n == nil { return nil } return &ast.TransactionStmt{ Kind: ast.TransactionStmtKind(n.Kind), - Options: convertList(n.Options), + Options: convertSlice(n.Options), Gid: n.Gid, } } -func convertTriggerTransition(n *nodes.TriggerTransition) *ast.TriggerTransition { +func convertTriggerTransition(n *pg.TriggerTransition) *ast.TriggerTransition { if n == nil { return nil } @@ -2721,18 +2737,18 @@ func convertTriggerTransition(n *nodes.TriggerTransition) *ast.TriggerTransition } } -func convertTruncateStmt(n *nodes.TruncateStmt) *ast.TruncateStmt { +func convertTruncateStmt(n *pg.TruncateStmt) *ast.TruncateStmt { if n == nil { return nil } return &ast.TruncateStmt{ - Relations: convertList(n.Relations), + Relations: convertSlice(n.Relations), RestartSeqs: n.RestartSeqs, Behavior: ast.DropBehavior(n.Behavior), } } -func convertTypeCast(n *nodes.TypeCast) *ast.TypeCast { +func convertTypeCast(n *pg.TypeCast) *ast.TypeCast { if n == nil { return nil } @@ -2743,23 +2759,23 @@ func convertTypeCast(n *nodes.TypeCast) *ast.TypeCast { } } -func convertTypeName(n *nodes.TypeName) *ast.TypeName { +func convertTypeName(n *pg.TypeName) *ast.TypeName { if n == nil { return nil } return &ast.TypeName{ - Names: convertList(n.Names), + Names: convertSlice(n.Names), TypeOid: ast.Oid(n.TypeOid), Setof: n.Setof, PctType: n.PctType, - Typmods: convertList(n.Typmods), + Typmods: convertSlice(n.Typmods), Typemod: n.Typemod, - ArrayBounds: convertList(n.ArrayBounds), + ArrayBounds: convertSlice(n.ArrayBounds), Location: n.Location, } } -func convertUnlistenStmt(n *nodes.UnlistenStmt) *ast.UnlistenStmt { +func convertUnlistenStmt(n *pg.UnlistenStmt) *ast.UnlistenStmt { if n == nil { return nil } @@ -2768,32 +2784,32 @@ func convertUnlistenStmt(n *nodes.UnlistenStmt) *ast.UnlistenStmt { } } -func convertUpdateStmt(n *nodes.UpdateStmt) *ast.UpdateStmt { +func convertUpdateStmt(n *pg.UpdateStmt) *ast.UpdateStmt { if n == nil { return nil } return &ast.UpdateStmt{ Relation: convertRangeVar(n.Relation), - TargetList: convertList(n.TargetList), + TargetList: convertSlice(n.TargetList), WhereClause: convertNode(n.WhereClause), - FromClause: convertList(n.FromClause), - ReturningList: convertList(n.ReturningList), + FromClause: convertSlice(n.FromClause), + ReturningList: convertSlice(n.ReturningList), WithClause: convertWithClause(n.WithClause), } } -func convertVacuumStmt(n *nodes.VacuumStmt) *ast.VacuumStmt { +func convertVacuumStmt(n *pg.VacuumStmt) *ast.VacuumStmt { if n == nil { return nil } return &ast.VacuumStmt{ Options: n.Options, Relation: convertRangeVar(n.Relation), - VaCols: convertList(n.VaCols), + VaCols: convertSlice(n.VaCols), } } -func convertVar(n *nodes.Var) *ast.Var { +func convertVar(n *pg.Var) *ast.Var { if n == nil { return nil } @@ -2811,19 +2827,19 @@ func convertVar(n *nodes.Var) *ast.Var { } } -func convertVariableSetStmt(n *nodes.VariableSetStmt) *ast.VariableSetStmt { +func convertVariableSetStmt(n *pg.VariableSetStmt) *ast.VariableSetStmt { if n == nil { return nil } return &ast.VariableSetStmt{ Kind: ast.VariableSetKind(n.Kind), Name: n.Name, - Args: convertList(n.Args), + Args: convertSlice(n.Args), IsLocal: n.IsLocal, } } -func convertVariableShowStmt(n *nodes.VariableShowStmt) *ast.VariableShowStmt { +func convertVariableShowStmt(n *pg.VariableShowStmt) *ast.VariableShowStmt { if n == nil { return nil } @@ -2832,29 +2848,29 @@ func convertVariableShowStmt(n *nodes.VariableShowStmt) *ast.VariableShowStmt { } } -func convertViewStmt(n *nodes.ViewStmt) *ast.ViewStmt { +func convertViewStmt(n *pg.ViewStmt) *ast.ViewStmt { if n == nil { return nil } return &ast.ViewStmt{ View: convertRangeVar(n.View), - Aliases: convertList(n.Aliases), + Aliases: convertSlice(n.Aliases), Query: convertNode(n.Query), Replace: n.Replace, - Options: convertList(n.Options), + Options: convertSlice(n.Options), WithCheckOption: ast.ViewCheckOption(n.WithCheckOption), } } -func convertWindowClause(n *nodes.WindowClause) *ast.WindowClause { +func convertWindowClause(n *pg.WindowClause) *ast.WindowClause { if n == nil { return nil } return &ast.WindowClause{ Name: n.Name, Refname: n.Refname, - PartitionClause: convertList(n.PartitionClause), - OrderClause: convertList(n.OrderClause), + PartitionClause: convertSlice(n.PartitionClause), + OrderClause: convertSlice(n.OrderClause), FrameOptions: n.FrameOptions, StartOffset: convertNode(n.StartOffset), EndOffset: convertNode(n.EndOffset), @@ -2863,15 +2879,15 @@ func convertWindowClause(n *nodes.WindowClause) *ast.WindowClause { } } -func convertWindowDef(n *nodes.WindowDef) *ast.WindowDef { +func convertWindowDef(n *pg.WindowDef) *ast.WindowDef { if n == nil { return nil } return &ast.WindowDef{ Name: n.Name, Refname: n.Refname, - PartitionClause: convertList(n.PartitionClause), - OrderClause: convertList(n.OrderClause), + PartitionClause: convertSlice(n.PartitionClause), + OrderClause: convertSlice(n.OrderClause), FrameOptions: n.FrameOptions, StartOffset: convertNode(n.StartOffset), EndOffset: convertNode(n.EndOffset), @@ -2879,7 +2895,7 @@ func convertWindowDef(n *nodes.WindowDef) *ast.WindowDef { } } -func convertWindowFunc(n *nodes.WindowFunc) *ast.WindowFunc { +func convertWindowFunc(n *pg.WindowFunc) *ast.WindowFunc { if n == nil { return nil } @@ -2889,7 +2905,7 @@ func convertWindowFunc(n *nodes.WindowFunc) *ast.WindowFunc { Wintype: ast.Oid(n.Wintype), Wincollid: ast.Oid(n.Wincollid), Inputcollid: ast.Oid(n.Inputcollid), - Args: convertList(n.Args), + Args: convertSlice(n.Args), Aggfilter: convertNode(n.Aggfilter), Winref: ast.Index(n.Winref), Winstar: n.Winstar, @@ -2898,7 +2914,7 @@ func convertWindowFunc(n *nodes.WindowFunc) *ast.WindowFunc { } } -func convertWithCheckOption(n *nodes.WithCheckOption) *ast.WithCheckOption { +func convertWithCheckOption(n *pg.WithCheckOption) *ast.WithCheckOption { if n == nil { return nil } @@ -2911,18 +2927,18 @@ func convertWithCheckOption(n *nodes.WithCheckOption) *ast.WithCheckOption { } } -func convertWithClause(n *nodes.WithClause) *ast.WithClause { +func convertWithClause(n *pg.WithClause) *ast.WithClause { if n == nil { return nil } return &ast.WithClause{ - Ctes: convertList(n.Ctes), + Ctes: convertSlice(n.Ctes), Recursive: n.Recursive, Location: n.Location, } } -func convertXmlExpr(n *nodes.XmlExpr) *ast.XmlExpr { +func convertXmlExpr(n *pg.XmlExpr) *ast.XmlExpr { if n == nil { return nil } @@ -2930,9 +2946,9 @@ func convertXmlExpr(n *nodes.XmlExpr) *ast.XmlExpr { Xpr: convertNode(n.Xpr), Op: ast.XmlExprOp(n.Op), Name: n.Name, - NamedArgs: convertList(n.NamedArgs), - ArgNames: convertList(n.ArgNames), - Args: convertList(n.Args), + NamedArgs: convertSlice(n.NamedArgs), + ArgNames: convertSlice(n.ArgNames), + Args: convertSlice(n.Args), Xmloption: ast.XmlOptionType(n.Xmloption), Type: ast.Oid(n.Type), Typmod: n.Typmod, @@ -2940,7 +2956,7 @@ func convertXmlExpr(n *nodes.XmlExpr) *ast.XmlExpr { } } -func convertXmlSerialize(n *nodes.XmlSerialize) *ast.XmlSerialize { +func convertXmlSerialize(n *pg.XmlSerialize) *ast.XmlSerialize { if n == nil { return nil } @@ -2952,679 +2968,679 @@ func convertXmlSerialize(n *nodes.XmlSerialize) *ast.XmlSerialize { } } -func convertNode(node nodes.Node) ast.Node { - switch n := node.(type) { +func convertNode(node *pg.Node) ast.Node { + switch n := node.Node.(type) { - case nodes.A_ArrayExpr: - return convertA_ArrayExpr(&n) + case *pg.Node_AArrayExpr: + return convertA_ArrayExpr(n.AArrayExpr) - case nodes.A_Const: + case pg.A_Const: return convertA_Const(&n) - case nodes.A_Expr: + case pg.A_Expr: return convertA_Expr(&n) - case nodes.A_Indices: + case pg.A_Indices: return convertA_Indices(&n) - case nodes.A_Indirection: + case pg.A_Indirection: return convertA_Indirection(&n) - case nodes.A_Star: + case pg.A_Star: return convertA_Star(&n) - case nodes.AccessPriv: + case pg.AccessPriv: return convertAccessPriv(&n) - case nodes.Aggref: + case pg.Aggref: return convertAggref(&n) - case nodes.Alias: + case pg.Alias: return convertAlias(&n) - case nodes.AlterCollationStmt: + case pg.AlterCollationStmt: return convertAlterCollationStmt(&n) - case nodes.AlterDatabaseSetStmt: + case pg.AlterDatabaseSetStmt: return convertAlterDatabaseSetStmt(&n) - case nodes.AlterDatabaseStmt: + case pg.AlterDatabaseStmt: return convertAlterDatabaseStmt(&n) - case nodes.AlterDefaultPrivilegesStmt: + case pg.AlterDefaultPrivilegesStmt: return convertAlterDefaultPrivilegesStmt(&n) - case nodes.AlterDomainStmt: + case pg.AlterDomainStmt: return convertAlterDomainStmt(&n) - case nodes.AlterEnumStmt: + case pg.AlterEnumStmt: return convertAlterEnumStmt(&n) - case nodes.AlterEventTrigStmt: + case pg.AlterEventTrigStmt: return convertAlterEventTrigStmt(&n) - case nodes.AlterExtensionContentsStmt: + case pg.AlterExtensionContentsStmt: return convertAlterExtensionContentsStmt(&n) - case nodes.AlterExtensionStmt: + case pg.AlterExtensionStmt: return convertAlterExtensionStmt(&n) - case nodes.AlterFdwStmt: + case pg.AlterFdwStmt: return convertAlterFdwStmt(&n) - case nodes.AlterForeignServerStmt: + case pg.AlterForeignServerStmt: return convertAlterForeignServerStmt(&n) - case nodes.AlterFunctionStmt: + case pg.AlterFunctionStmt: return convertAlterFunctionStmt(&n) - case nodes.AlterObjectDependsStmt: + case pg.AlterObjectDependsStmt: return convertAlterObjectDependsStmt(&n) - case nodes.AlterObjectSchemaStmt: + case pg.AlterObjectSchemaStmt: return convertAlterObjectSchemaStmt(&n) - case nodes.AlterOpFamilyStmt: + case pg.AlterOpFamilyStmt: return convertAlterOpFamilyStmt(&n) - case nodes.AlterOperatorStmt: + case pg.AlterOperatorStmt: return convertAlterOperatorStmt(&n) - case nodes.AlterOwnerStmt: + case pg.AlterOwnerStmt: return convertAlterOwnerStmt(&n) - case nodes.AlterPolicyStmt: + case pg.AlterPolicyStmt: return convertAlterPolicyStmt(&n) - case nodes.AlterPublicationStmt: + case pg.AlterPublicationStmt: return convertAlterPublicationStmt(&n) - case nodes.AlterRoleSetStmt: + case pg.AlterRoleSetStmt: return convertAlterRoleSetStmt(&n) - case nodes.AlterRoleStmt: + case pg.AlterRoleStmt: return convertAlterRoleStmt(&n) - case nodes.AlterSeqStmt: + case pg.AlterSeqStmt: return convertAlterSeqStmt(&n) - case nodes.AlterSubscriptionStmt: + case pg.AlterSubscriptionStmt: return convertAlterSubscriptionStmt(&n) - case nodes.AlterSystemStmt: + case pg.AlterSystemStmt: return convertAlterSystemStmt(&n) - case nodes.AlterTSConfigurationStmt: + case pg.AlterTSConfigurationStmt: return convertAlterTSConfigurationStmt(&n) - case nodes.AlterTSDictionaryStmt: + case pg.AlterTSDictionaryStmt: return convertAlterTSDictionaryStmt(&n) - case nodes.AlterTableCmd: + case pg.AlterTableCmd: return convertAlterTableCmd(&n) - case nodes.AlterTableMoveAllStmt: + case pg.AlterTableMoveAllStmt: return convertAlterTableMoveAllStmt(&n) - case nodes.AlterTableSpaceOptionsStmt: + case pg.AlterTableSpaceOptionsStmt: return convertAlterTableSpaceOptionsStmt(&n) - case nodes.AlterTableStmt: + case pg.AlterTableStmt: return convertAlterTableStmt(&n) - case nodes.AlterUserMappingStmt: + case pg.AlterUserMappingStmt: return convertAlterUserMappingStmt(&n) - case nodes.AlternativeSubPlan: + case pg.AlternativeSubPlan: return convertAlternativeSubPlan(&n) - case nodes.ArrayCoerceExpr: + case pg.ArrayCoerceExpr: return convertArrayCoerceExpr(&n) - case nodes.ArrayExpr: + case pg.ArrayExpr: return convertArrayExpr(&n) - case nodes.ArrayRef: + case pg.ArrayRef: return convertArrayRef(&n) - case nodes.BitString: + case pg.BitString: return convertBitString(&n) - case nodes.BlockIdData: + case pg.BlockIdData: return convertBlockIdData(&n) - case nodes.BoolExpr: + case pg.BoolExpr: return convertBoolExpr(&n) - case nodes.BooleanTest: + case pg.BooleanTest: return convertBooleanTest(&n) - case nodes.CaseExpr: + case pg.CaseExpr: return convertCaseExpr(&n) - case nodes.CaseTestExpr: + case pg.CaseTestExpr: return convertCaseTestExpr(&n) - case nodes.CaseWhen: + case pg.CaseWhen: return convertCaseWhen(&n) - case nodes.CheckPointStmt: + case pg.CheckPointStmt: return convertCheckPointStmt(&n) - case nodes.ClosePortalStmt: + case pg.ClosePortalStmt: return convertClosePortalStmt(&n) - case nodes.ClusterStmt: + case pg.ClusterStmt: return convertClusterStmt(&n) - case nodes.CoalesceExpr: + case pg.CoalesceExpr: return convertCoalesceExpr(&n) - case nodes.CoerceToDomain: + case pg.CoerceToDomain: return convertCoerceToDomain(&n) - case nodes.CoerceToDomainValue: + case pg.CoerceToDomainValue: return convertCoerceToDomainValue(&n) - case nodes.CoerceViaIO: + case pg.CoerceViaIO: return convertCoerceViaIO(&n) - case nodes.CollateClause: + case pg.CollateClause: return convertCollateClause(&n) - case nodes.CollateExpr: + case pg.CollateExpr: return convertCollateExpr(&n) - case nodes.ColumnDef: + case pg.ColumnDef: return convertColumnDef(&n) - case nodes.ColumnRef: + case pg.ColumnRef: return convertColumnRef(&n) - case nodes.CommentStmt: + case pg.CommentStmt: return convertCommentStmt(&n) - case nodes.CommonTableExpr: + case pg.CommonTableExpr: return convertCommonTableExpr(&n) - case nodes.CompositeTypeStmt: + case pg.CompositeTypeStmt: return convertCompositeTypeStmt(&n) - case nodes.Const: + case pg.Const: return convertConst(&n) - case nodes.Constraint: + case pg.Constraint: return convertConstraint(&n) - case nodes.ConstraintsSetStmt: + case pg.ConstraintsSetStmt: return convertConstraintsSetStmt(&n) - case nodes.ConvertRowtypeExpr: + case pg.ConvertRowtypeExpr: return convertConvertRowtypeExpr(&n) - case nodes.CopyStmt: + case pg.CopyStmt: return convertCopyStmt(&n) - case nodes.CreateAmStmt: + case pg.CreateAmStmt: return convertCreateAmStmt(&n) - case nodes.CreateCastStmt: + case pg.CreateCastStmt: return convertCreateCastStmt(&n) - case nodes.CreateConversionStmt: + case pg.CreateConversionStmt: return convertCreateConversionStmt(&n) - case nodes.CreateDomainStmt: + case pg.CreateDomainStmt: return convertCreateDomainStmt(&n) - case nodes.CreateEnumStmt: + case pg.CreateEnumStmt: return convertCreateEnumStmt(&n) - case nodes.CreateEventTrigStmt: + case pg.CreateEventTrigStmt: return convertCreateEventTrigStmt(&n) - case nodes.CreateExtensionStmt: + case pg.CreateExtensionStmt: return convertCreateExtensionStmt(&n) - case nodes.CreateFdwStmt: + case pg.CreateFdwStmt: return convertCreateFdwStmt(&n) - case nodes.CreateForeignServerStmt: + case pg.CreateForeignServerStmt: return convertCreateForeignServerStmt(&n) - case nodes.CreateForeignTableStmt: + case pg.CreateForeignTableStmt: return convertCreateForeignTableStmt(&n) - case nodes.CreateFunctionStmt: + case pg.CreateFunctionStmt: return convertCreateFunctionStmt(&n) - case nodes.CreateOpClassItem: + case pg.CreateOpClassItem: return convertCreateOpClassItem(&n) - case nodes.CreateOpClassStmt: + case pg.CreateOpClassStmt: return convertCreateOpClassStmt(&n) - case nodes.CreateOpFamilyStmt: + case pg.CreateOpFamilyStmt: return convertCreateOpFamilyStmt(&n) - case nodes.CreatePLangStmt: + case pg.CreatePLangStmt: return convertCreatePLangStmt(&n) - case nodes.CreatePolicyStmt: + case pg.CreatePolicyStmt: return convertCreatePolicyStmt(&n) - case nodes.CreatePublicationStmt: + case pg.CreatePublicationStmt: return convertCreatePublicationStmt(&n) - case nodes.CreateRangeStmt: + case pg.CreateRangeStmt: return convertCreateRangeStmt(&n) - case nodes.CreateRoleStmt: + case pg.CreateRoleStmt: return convertCreateRoleStmt(&n) - case nodes.CreateSchemaStmt: + case pg.CreateSchemaStmt: return convertCreateSchemaStmt(&n) - case nodes.CreateSeqStmt: + case pg.CreateSeqStmt: return convertCreateSeqStmt(&n) - case nodes.CreateStatsStmt: + case pg.CreateStatsStmt: return convertCreateStatsStmt(&n) - case nodes.CreateStmt: + case pg.CreateStmt: return convertCreateStmt(&n) - case nodes.CreateSubscriptionStmt: + case pg.CreateSubscriptionStmt: return convertCreateSubscriptionStmt(&n) - case nodes.CreateTableAsStmt: + case pg.CreateTableAsStmt: return convertCreateTableAsStmt(&n) - case nodes.CreateTableSpaceStmt: + case pg.CreateTableSpaceStmt: return convertCreateTableSpaceStmt(&n) - case nodes.CreateTransformStmt: + case pg.CreateTransformStmt: return convertCreateTransformStmt(&n) - case nodes.CreateTrigStmt: + case pg.CreateTrigStmt: return convertCreateTrigStmt(&n) - case nodes.CreateUserMappingStmt: + case pg.CreateUserMappingStmt: return convertCreateUserMappingStmt(&n) - case nodes.CreatedbStmt: + case pg.CreatedbStmt: return convertCreatedbStmt(&n) - case nodes.CurrentOfExpr: + case pg.CurrentOfExpr: return convertCurrentOfExpr(&n) - case nodes.DeallocateStmt: + case pg.DeallocateStmt: return convertDeallocateStmt(&n) - case nodes.DeclareCursorStmt: + case pg.DeclareCursorStmt: return convertDeclareCursorStmt(&n) - case nodes.DefElem: + case pg.DefElem: return convertDefElem(&n) - case nodes.DefineStmt: + case pg.DefineStmt: return convertDefineStmt(&n) - case nodes.DeleteStmt: + case pg.DeleteStmt: return convertDeleteStmt(&n) - case nodes.DiscardStmt: + case pg.DiscardStmt: return convertDiscardStmt(&n) - case nodes.DoStmt: + case pg.DoStmt: return convertDoStmt(&n) - case nodes.DropOwnedStmt: + case pg.DropOwnedStmt: return convertDropOwnedStmt(&n) - case nodes.DropRoleStmt: + case pg.DropRoleStmt: return convertDropRoleStmt(&n) - case nodes.DropStmt: + case pg.DropStmt: return convertDropStmt(&n) - case nodes.DropSubscriptionStmt: + case pg.DropSubscriptionStmt: return convertDropSubscriptionStmt(&n) - case nodes.DropTableSpaceStmt: + case pg.DropTableSpaceStmt: return convertDropTableSpaceStmt(&n) - case nodes.DropUserMappingStmt: + case pg.DropUserMappingStmt: return convertDropUserMappingStmt(&n) - case nodes.DropdbStmt: + case pg.DropdbStmt: return convertDropdbStmt(&n) - case nodes.ExecuteStmt: + case pg.ExecuteStmt: return convertExecuteStmt(&n) - case nodes.ExplainStmt: + case pg.ExplainStmt: return convertExplainStmt(&n) - case nodes.Expr: + case pg.Expr: return convertExpr(&n) - case nodes.FetchStmt: + case pg.FetchStmt: return convertFetchStmt(&n) - case nodes.FieldSelect: + case pg.FieldSelect: return convertFieldSelect(&n) - case nodes.FieldStore: + case pg.FieldStore: return convertFieldStore(&n) - case nodes.Float: + case pg.Float: return convertFloat(&n) - case nodes.FromExpr: + case pg.FromExpr: return convertFromExpr(&n) - case nodes.FuncCall: + case pg.FuncCall: return convertFuncCall(&n) - case nodes.FuncExpr: + case pg.FuncExpr: return convertFuncExpr(&n) - case nodes.FunctionParameter: + case pg.FunctionParameter: return convertFunctionParameter(&n) - case nodes.GrantRoleStmt: + case pg.GrantRoleStmt: return convertGrantRoleStmt(&n) - case nodes.GrantStmt: + case pg.GrantStmt: return convertGrantStmt(&n) - case nodes.GroupingFunc: + case pg.GroupingFunc: return convertGroupingFunc(&n) - case nodes.GroupingSet: + case pg.GroupingSet: return convertGroupingSet(&n) - case nodes.ImportForeignSchemaStmt: + case pg.ImportForeignSchemaStmt: return convertImportForeignSchemaStmt(&n) - case nodes.IndexElem: + case pg.IndexElem: return convertIndexElem(&n) - case nodes.IndexStmt: + case pg.IndexStmt: return convertIndexStmt(&n) - case nodes.InferClause: + case pg.InferClause: return convertInferClause(&n) - case nodes.InferenceElem: + case pg.InferenceElem: return convertInferenceElem(&n) - case nodes.InlineCodeBlock: + case pg.InlineCodeBlock: return convertInlineCodeBlock(&n) - case nodes.InsertStmt: + case pg.InsertStmt: return convertInsertStmt(&n) - case nodes.Integer: + case pg.Integer: return convertInteger(&n) - case nodes.IntoClause: + case pg.IntoClause: return convertIntoClause(&n) - case nodes.JoinExpr: + case pg.JoinExpr: return convertJoinExpr(&n) - case nodes.List: - return convertList(n) + case pg.List: + return convertSlice(n) - case nodes.ListenStmt: - return convertListenStmt(&n) + case pg.ListenStmt: + return convertSliceenStmt(&n) - case nodes.LoadStmt: + case pg.LoadStmt: return convertLoadStmt(&n) - case nodes.LockStmt: + case pg.LockStmt: return convertLockStmt(&n) - case nodes.LockingClause: + case pg.LockingClause: return convertLockingClause(&n) - case nodes.MinMaxExpr: + case pg.MinMaxExpr: return convertMinMaxExpr(&n) - case nodes.MultiAssignRef: + case pg.MultiAssignRef: return convertMultiAssignRef(&n) - case nodes.NamedArgExpr: + case pg.NamedArgExpr: return convertNamedArgExpr(&n) - case nodes.NextValueExpr: + case pg.NextValueExpr: return convertNextValueExpr(&n) - case nodes.NotifyStmt: + case pg.NotifyStmt: return convertNotifyStmt(&n) - case nodes.Null: + case pg.Null: return convertNull(&n) - case nodes.NullTest: + case pg.NullTest: return convertNullTest(&n) - case nodes.ObjectWithArgs: + case pg.ObjectWithArgs: return convertObjectWithArgs(&n) - case nodes.OnConflictClause: + case pg.OnConflictClause: return convertOnConflictClause(&n) - case nodes.OnConflictExpr: + case pg.OnConflictExpr: return convertOnConflictExpr(&n) - case nodes.OpExpr: + case pg.OpExpr: return convertOpExpr(&n) - case nodes.Param: + case pg.Param: return convertParam(&n) - case nodes.ParamExecData: + case pg.ParamExecData: return convertParamExecData(&n) - case nodes.ParamExternData: + case pg.ParamExternData: return convertParamExternData(&n) - case nodes.ParamListInfoData: + case pg.ParamListInfoData: return convertParamListInfoData(&n) - case nodes.ParamRef: + case pg.ParamRef: return convertParamRef(&n) - case nodes.PartitionBoundSpec: + case pg.PartitionBoundSpec: return convertPartitionBoundSpec(&n) - case nodes.PartitionCmd: + case pg.PartitionCmd: return convertPartitionCmd(&n) - case nodes.PartitionElem: + case pg.PartitionElem: return convertPartitionElem(&n) - case nodes.PartitionRangeDatum: + case pg.PartitionRangeDatum: return convertPartitionRangeDatum(&n) - case nodes.PartitionSpec: + case pg.PartitionSpec: return convertPartitionSpec(&n) - case nodes.PrepareStmt: + case pg.PrepareStmt: return convertPrepareStmt(&n) - case nodes.Query: + case pg.Query: return convertQuery(&n) - case nodes.RangeFunction: + case pg.RangeFunction: return convertRangeFunction(&n) - case nodes.RangeSubselect: + case pg.RangeSubselect: return convertRangeSubselect(&n) - case nodes.RangeTableFunc: + case pg.RangeTableFunc: return convertRangeTableFunc(&n) - case nodes.RangeTableFuncCol: + case pg.RangeTableFuncCol: return convertRangeTableFuncCol(&n) - case nodes.RangeTableSample: + case pg.RangeTableSample: return convertRangeTableSample(&n) - case nodes.RangeTblEntry: + case pg.RangeTblEntry: return convertRangeTblEntry(&n) - case nodes.RangeTblFunction: + case pg.RangeTblFunction: return convertRangeTblFunction(&n) - case nodes.RangeTblRef: + case pg.RangeTblRef: return convertRangeTblRef(&n) - case nodes.RangeVar: + case pg.RangeVar: return convertRangeVar(&n) - case nodes.RawStmt: + case pg.RawStmt: return convertRawStmt(&n) - case nodes.ReassignOwnedStmt: + case pg.ReassignOwnedStmt: return convertReassignOwnedStmt(&n) - case nodes.RefreshMatViewStmt: + case pg.RefreshMatViewStmt: return convertRefreshMatViewStmt(&n) - case nodes.ReindexStmt: + case pg.ReindexStmt: return convertReindexStmt(&n) - case nodes.RelabelType: + case pg.RelabelType: return convertRelabelType(&n) - case nodes.RenameStmt: + case pg.RenameStmt: return convertRenameStmt(&n) - case nodes.ReplicaIdentityStmt: + case pg.ReplicaIdentityStmt: return convertReplicaIdentityStmt(&n) - case nodes.ResTarget: + case pg.ResTarget: return convertResTarget(&n) - case nodes.RoleSpec: + case pg.RoleSpec: return convertRoleSpec(&n) - case nodes.RowCompareExpr: + case pg.RowCompareExpr: return convertRowCompareExpr(&n) - case nodes.RowExpr: + case pg.RowExpr: return convertRowExpr(&n) - case nodes.RowMarkClause: + case pg.RowMarkClause: return convertRowMarkClause(&n) - case nodes.RuleStmt: + case pg.RuleStmt: return convertRuleStmt(&n) - case nodes.SQLValueFunction: + case pg.SQLValueFunction: return convertSQLValueFunction(&n) - case nodes.ScalarArrayOpExpr: + case pg.ScalarArrayOpExpr: return convertScalarArrayOpExpr(&n) - case nodes.SecLabelStmt: + case pg.SecLabelStmt: return convertSecLabelStmt(&n) - case nodes.SelectStmt: + case pg.SelectStmt: return convertSelectStmt(&n) - case nodes.SetOperationStmt: + case pg.SetOperationStmt: return convertSetOperationStmt(&n) - case nodes.SetToDefault: + case pg.SetToDefault: return convertSetToDefault(&n) - case nodes.SortBy: + case pg.SortBy: return convertSortBy(&n) - case nodes.SortGroupClause: + case pg.SortGroupClause: return convertSortGroupClause(&n) - case nodes.String: + case pg.String: return convertString(&n) - case nodes.SubLink: + case pg.SubLink: return convertSubLink(&n) - case nodes.SubPlan: + case pg.SubPlan: return convertSubPlan(&n) - case nodes.TableFunc: + case pg.TableFunc: return convertTableFunc(&n) - case nodes.TableLikeClause: + case pg.TableLikeClause: return convertTableLikeClause(&n) - case nodes.TableSampleClause: + case pg.TableSampleClause: return convertTableSampleClause(&n) - case nodes.TargetEntry: + case pg.TargetEntry: return convertTargetEntry(&n) - case nodes.TransactionStmt: + case pg.TransactionStmt: return convertTransactionStmt(&n) - case nodes.TriggerTransition: + case pg.TriggerTransition: return convertTriggerTransition(&n) - case nodes.TruncateStmt: + case pg.TruncateStmt: return convertTruncateStmt(&n) - case nodes.TypeCast: + case pg.TypeCast: return convertTypeCast(&n) - case nodes.TypeName: + case pg.TypeName: return convertTypeName(&n) - case nodes.UnlistenStmt: + case pg.UnlistenStmt: return convertUnlistenStmt(&n) - case nodes.UpdateStmt: + case pg.UpdateStmt: return convertUpdateStmt(&n) - case nodes.VacuumStmt: + case pg.VacuumStmt: return convertVacuumStmt(&n) - case nodes.Var: + case pg.Var: return convertVar(&n) - case nodes.VariableSetStmt: + case pg.VariableSetStmt: return convertVariableSetStmt(&n) - case nodes.VariableShowStmt: + case pg.VariableShowStmt: return convertVariableShowStmt(&n) - case nodes.ViewStmt: + case pg.ViewStmt: return convertViewStmt(&n) - case nodes.WindowClause: + case pg.WindowClause: return convertWindowClause(&n) - case nodes.WindowDef: + case pg.WindowDef: return convertWindowDef(&n) - case nodes.WindowFunc: + case pg.WindowFunc: return convertWindowFunc(&n) - case nodes.WithCheckOption: + case pg.WithCheckOption: return convertWithCheckOption(&n) - case nodes.WithClause: + case pg.WithClause: return convertWithClause(&n) - case nodes.XmlExpr: + case pg.XmlExpr: return convertXmlExpr(&n) - case nodes.XmlSerialize: + case pg.XmlSerialize: return convertXmlSerialize(&n) default: diff --git a/internal/engine/postgresql/parse.go b/internal/engine/postgresql/parse.go index 2ac680afae..33f2d920cd 100644 --- a/internal/engine/postgresql/parse.go +++ b/internal/engine/postgresql/parse.go @@ -9,8 +9,7 @@ import ( "io/ioutil" "strings" - pg "github.com/lfittl/pg_query_go" - nodes "github.com/lfittl/pg_query_go/nodes" + nodes "github.com/pganalyze/pg_query_go/v2" "github.com/kyleconroy/sqlc/internal/metadata" "github.com/kyleconroy/sqlc/internal/sql/ast" @@ -190,7 +189,7 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) { if err != nil { return nil, err } - tree, err := pg.Parse(string(contents)) + tree, err := nodes.Parse(string(contents)) if err != nil { return nil, err } diff --git a/internal/engine/postgresql/utils.go b/internal/engine/postgresql/utils.go index 67d1fbcc44..98ca057d8e 100644 --- a/internal/engine/postgresql/utils.go +++ b/internal/engine/postgresql/utils.go @@ -3,7 +3,7 @@ package postgresql import ( - nodes "github.com/lfittl/pg_query_go/nodes" + nodes "github.com/pganalyze/pg_query_go/v2" ) func isArray(n *nodes.TypeName) bool { From 633f021996d795cca3811c25df7b0a9c029d3488 Mon Sep 17 00:00:00 2001 From: Kyle Conroy Date: Thu, 18 Mar 2021 23:13:29 -0700 Subject: [PATCH 02/11] On to impossible type switches --- internal/engine/postgresql/convert.go | 543 ++++++++++---------------- internal/engine/postgresql/parse.go | 57 +++ internal/engine/postgresql/utils.go | 16 + 3 files changed, 289 insertions(+), 327 deletions(-) diff --git a/internal/engine/postgresql/convert.go b/internal/engine/postgresql/convert.go index c5007e1977..809d5ad987 100644 --- a/internal/engine/postgresql/convert.go +++ b/internal/engine/postgresql/convert.go @@ -8,14 +8,6 @@ import ( "github.com/kyleconroy/sqlc/internal/sql/ast" ) -func makeByte(s string) byte { - var b byte - if s == "" { - return b - } - return []byte(s)[0] -} - func convertList(l pg.List) *ast.List { out := &ast.List{} for _, item := range l.Items { @@ -533,13 +525,11 @@ func convertArrayCoerceExpr(n *pg.ArrayCoerceExpr) *ast.ArrayCoerceExpr { return &ast.ArrayCoerceExpr{ Xpr: convertNode(n.Xpr), Arg: convertNode(n.Arg), - Elemfuncid: ast.Oid(n.Elemfuncid), Resulttype: ast.Oid(n.Resulttype), Resulttypmod: n.Resulttypmod, Resultcollid: ast.Oid(n.Resultcollid), - IsExplicit: n.IsExplicit, Coerceformat: ast.CoercionForm(n.Coerceformat), - Location: n.Location, + Location: int(n.Location), } } @@ -554,24 +544,7 @@ func convertArrayExpr(n *pg.ArrayExpr) *ast.ArrayExpr { ElementTypeid: ast.Oid(n.ElementTypeid), Elements: convertSlice(n.Elements), Multidims: n.Multidims, - Location: n.Location, - } -} - -func convertArrayRef(n *pg.ArrayRef) *ast.ArrayRef { - if n == nil { - return nil - } - return &ast.ArrayRef{ - Xpr: convertNode(n.Xpr), - Refarraytype: ast.Oid(n.Refarraytype), - Refelemtype: ast.Oid(n.Refelemtype), - Reftypmod: n.Reftypmod, - Refcollid: ast.Oid(n.Refcollid), - Refupperindexpr: convertSlice(n.Refupperindexpr), - Reflowerindexpr: convertSlice(n.Reflowerindexpr), - Refexpr: convertNode(n.Refexpr), - Refassgnexpr: convertNode(n.Refassgnexpr), + Location: int(n.Location), } } @@ -584,16 +557,6 @@ func convertBitString(n *pg.BitString) *ast.BitString { } } -func convertBlockIdData(n *pg.BlockIdData) *ast.BlockIdData { - if n == nil { - return nil - } - return &ast.BlockIdData{ - BiHi: n.BiHi, - BiLo: n.BiLo, - } -} - func convertBoolExpr(n *pg.BoolExpr) *ast.BoolExpr { if n == nil { return nil @@ -602,7 +565,7 @@ func convertBoolExpr(n *pg.BoolExpr) *ast.BoolExpr { Xpr: convertNode(n.Xpr), Boolop: ast.BoolExprType(n.Boolop), Args: convertSlice(n.Args), - Location: n.Location, + Location: int(n.Location), } } @@ -614,7 +577,7 @@ func convertBooleanTest(n *pg.BooleanTest) *ast.BooleanTest { Xpr: convertNode(n.Xpr), Arg: convertNode(n.Arg), Booltesttype: ast.BoolTestType(n.Booltesttype), - Location: n.Location, + Location: int(n.Location), } } @@ -629,7 +592,7 @@ func convertCaseExpr(n *pg.CaseExpr) *ast.CaseExpr { Arg: convertNode(n.Arg), Args: convertSlice(n.Args), Defresult: convertNode(n.Defresult), - Location: n.Location, + Location: int(n.Location), } } @@ -653,7 +616,7 @@ func convertCaseWhen(n *pg.CaseWhen) *ast.CaseWhen { Xpr: convertNode(n.Xpr), Expr: convertNode(n.Expr), Result: convertNode(n.Result), - Location: n.Location, + Location: int(n.Location), } } @@ -669,7 +632,7 @@ func convertClosePortalStmt(n *pg.ClosePortalStmt) *ast.ClosePortalStmt { return nil } return &ast.ClosePortalStmt{ - Portalname: n.Portalname, + Portalname: &n.Portalname, } } @@ -679,8 +642,7 @@ func convertClusterStmt(n *pg.ClusterStmt) *ast.ClusterStmt { } return &ast.ClusterStmt{ Relation: convertRangeVar(n.Relation), - Indexname: n.Indexname, - Verbose: n.Verbose, + Indexname: &n.Indexname, } } @@ -693,7 +655,7 @@ func convertCoalesceExpr(n *pg.CoalesceExpr) *ast.CoalesceExpr { Coalescetype: ast.Oid(n.Coalescetype), Coalescecollid: ast.Oid(n.Coalescecollid), Args: convertSlice(n.Args), - Location: n.Location, + Location: int(n.Location), } } @@ -708,7 +670,7 @@ func convertCoerceToDomain(n *pg.CoerceToDomain) *ast.CoerceToDomain { Resulttypmod: n.Resulttypmod, Resultcollid: ast.Oid(n.Resultcollid), Coercionformat: ast.CoercionForm(n.Coercionformat), - Location: n.Location, + Location: int(n.Location), } } @@ -721,7 +683,7 @@ func convertCoerceToDomainValue(n *pg.CoerceToDomainValue) *ast.CoerceToDomainVa TypeId: ast.Oid(n.TypeId), TypeMod: n.TypeMod, Collation: ast.Oid(n.Collation), - Location: n.Location, + Location: int(n.Location), } } @@ -735,7 +697,7 @@ func convertCoerceViaIO(n *pg.CoerceViaIO) *ast.CoerceViaIO { Resulttype: ast.Oid(n.Resulttype), Resultcollid: ast.Oid(n.Resultcollid), Coerceformat: ast.CoercionForm(n.Coerceformat), - Location: n.Location, + Location: int(n.Location), } } @@ -746,7 +708,7 @@ func convertCollateClause(n *pg.CollateClause) *ast.CollateClause { return &ast.CollateClause{ Arg: convertNode(n.Arg), Collname: convertSlice(n.Collname), - Location: n.Location, + Location: int(n.Location), } } @@ -758,7 +720,7 @@ func convertCollateExpr(n *pg.CollateExpr) *ast.CollateExpr { Xpr: convertNode(n.Xpr), Arg: convertNode(n.Arg), CollOid: ast.Oid(n.CollOid), - Location: n.Location, + Location: int(n.Location), } } @@ -766,27 +728,22 @@ func convertColumnDef(n *pg.ColumnDef) *ast.ColumnDef { if n == nil { return nil } - colname := "" - if n.Colname != nil { - colname = *n.Colname - } return &ast.ColumnDef{ - Colname: colname, + Colname: n.Colname, TypeName: convertTypeName(n.TypeName), - Inhcount: n.Inhcount, + Inhcount: int(n.Inhcount), IsLocal: n.IsLocal, IsNotNull: n.IsNotNull, IsFromType: n.IsFromType, - IsFromParent: n.IsFromParent, - Storage: n.Storage, + Storage: makeByte(n.Storage), RawDefault: convertNode(n.RawDefault), CookedDefault: convertNode(n.CookedDefault), - Identity: n.Identity, + Identity: makeByte(n.Identity), CollClause: convertCollateClause(n.CollClause), CollOid: ast.Oid(n.CollOid), Constraints: convertSlice(n.Constraints), Fdwoptions: convertSlice(n.Fdwoptions), - Location: n.Location, + Location: int(n.Location), } } @@ -796,7 +753,7 @@ func convertColumnRef(n *pg.ColumnRef) *ast.ColumnRef { } return &ast.ColumnRef{ Fields: convertSlice(n.Fields), - Location: n.Location, + Location: int(n.Location), } } @@ -807,7 +764,7 @@ func convertCommentStmt(n *pg.CommentStmt) *ast.CommentStmt { return &ast.CommentStmt{ Objtype: ast.ObjectType(n.Objtype), Object: convertNode(n.Object), - Comment: n.Comment, + Comment: &n.Comment, } } @@ -816,12 +773,12 @@ func convertCommonTableExpr(n *pg.CommonTableExpr) *ast.CommonTableExpr { return nil } return &ast.CommonTableExpr{ - Ctename: n.Ctename, + Ctename: &n.Ctename, Aliascolnames: convertSlice(n.Aliascolnames), Ctequery: convertNode(n.Ctequery), - Location: n.Location, + Location: int(n.Location), Cterecursive: n.Cterecursive, - Cterefcount: n.Cterefcount, + Cterefcount: int(n.Cterefcount), Ctecolnames: convertSlice(n.Ctecolnames), Ctecoltypes: convertSlice(n.Ctecoltypes), Ctecoltypmods: convertSlice(n.Ctecoltypmods), @@ -833,29 +790,9 @@ func convertCompositeTypeStmt(n *pg.CompositeTypeStmt) *ast.CompositeTypeStmt { if n == nil { return nil } - tn, err := parseTypeName(n.Typevar) - if err != nil { - panic(err) - } + rel := parseRelationFromRangeVar(n.Typevar) return &ast.CompositeTypeStmt{ - TypeName: tn, - } -} - -func convertConst(n *pg.Const) *ast.Const { - if n == nil { - return nil - } - return &ast.Const{ - Xpr: convertNode(n.Xpr), - Consttype: ast.Oid(n.Consttype), - Consttypmod: n.Consttypmod, - Constcollid: ast.Oid(n.Constcollid), - Constlen: n.Constlen, - Constvalue: ast.Datum(n.Constvalue), - Constisnull: n.Constisnull, - Constbyval: n.Constbyval, - Location: n.Location, + TypeName: rel.TypeName(), } } @@ -865,27 +802,27 @@ func convertConstraint(n *pg.Constraint) *ast.Constraint { } return &ast.Constraint{ Contype: ast.ConstrType(n.Contype), - Conname: n.Conname, + Conname: &n.Conname, Deferrable: n.Deferrable, Initdeferred: n.Initdeferred, - Location: n.Location, + Location: int(n.Location), IsNoInherit: n.IsNoInherit, RawExpr: convertNode(n.RawExpr), - CookedExpr: n.CookedExpr, - GeneratedWhen: n.GeneratedWhen, + CookedExpr: &n.CookedExpr, + GeneratedWhen: makeByte(n.GeneratedWhen), Keys: convertSlice(n.Keys), Exclusions: convertSlice(n.Exclusions), Options: convertSlice(n.Options), - Indexname: n.Indexname, - Indexspace: n.Indexspace, - AccessMethod: n.AccessMethod, + Indexname: &n.Indexname, + Indexspace: &n.Indexspace, + AccessMethod: &n.AccessMethod, WhereClause: convertNode(n.WhereClause), Pktable: convertRangeVar(n.Pktable), FkAttrs: convertSlice(n.FkAttrs), PkAttrs: convertSlice(n.PkAttrs), - FkMatchtype: n.FkMatchtype, - FkUpdAction: n.FkUpdAction, - FkDelAction: n.FkDelAction, + FkMatchtype: makeByte(n.FkMatchtype), + FkUpdAction: makeByte(n.FkUpdAction), + FkDelAction: makeByte(n.FkDelAction), OldConpfeqop: convertSlice(n.OldConpfeqop), OldPktableOid: ast.Oid(n.OldPktableOid), SkipValidation: n.SkipValidation, @@ -912,7 +849,7 @@ func convertConvertRowtypeExpr(n *pg.ConvertRowtypeExpr) *ast.ConvertRowtypeExpr Arg: convertNode(n.Arg), Resulttype: ast.Oid(n.Resulttype), Convertformat: ast.CoercionForm(n.Convertformat), - Location: n.Location, + Location: int(n.Location), } } @@ -926,7 +863,7 @@ func convertCopyStmt(n *pg.CopyStmt) *ast.CopyStmt { Attlist: convertSlice(n.Attlist), IsFrom: n.IsFrom, IsProgram: n.IsProgram, - Filename: n.Filename, + Filename: &n.Filename, Options: convertSlice(n.Options), } } @@ -936,9 +873,9 @@ func convertCreateAmStmt(n *pg.CreateAmStmt) *ast.CreateAmStmt { return nil } return &ast.CreateAmStmt{ - Amname: n.Amname, + Amname: &n.Amname, HandlerName: convertSlice(n.HandlerName), - Amtype: n.Amtype, + Amtype: makeByte(n.Amtype), } } @@ -961,8 +898,8 @@ func convertCreateConversionStmt(n *pg.CreateConversionStmt) *ast.CreateConversi } return &ast.CreateConversionStmt{ ConversionName: convertSlice(n.ConversionName), - ForEncodingName: n.ForEncodingName, - ToEncodingName: n.ToEncodingName, + ForEncodingName: &n.ForEncodingName, + ToEncodingName: &n.ToEncodingName, FuncName: convertSlice(n.FuncName), Def: n.Def, } @@ -984,12 +921,12 @@ func convertCreateEnumStmt(n *pg.CreateEnumStmt) *ast.CreateEnumStmt { if n == nil { return nil } - tn, err := parseTypeName(n.TypeName) + rel, err := parseRelationFromNodes(n.TypeName) if err != nil { panic(err) } return &ast.CreateEnumStmt{ - TypeName: tn, + TypeName: rel.TypeName(), Vals: convertSlice(n.Vals), } } @@ -999,8 +936,8 @@ func convertCreateEventTrigStmt(n *pg.CreateEventTrigStmt) *ast.CreateEventTrigS return nil } return &ast.CreateEventTrigStmt{ - Trigname: n.Trigname, - Eventname: n.Eventname, + Trigname: &n.Trigname, + Eventname: &n.Eventname, Whenclause: convertSlice(n.Whenclause), Funcname: convertSlice(n.Funcname), } @@ -1011,7 +948,7 @@ func convertCreateExtensionStmt(n *pg.CreateExtensionStmt) *ast.CreateExtensionS return nil } return &ast.CreateExtensionStmt{ - Extname: n.Extname, + Extname: &n.Extname, IfNotExists: n.IfNotExists, Options: convertSlice(n.Options), } @@ -1022,7 +959,7 @@ func convertCreateFdwStmt(n *pg.CreateFdwStmt) *ast.CreateFdwStmt { return nil } return &ast.CreateFdwStmt{ - Fdwname: n.Fdwname, + Fdwname: &n.Fdwname, FuncOptions: convertSlice(n.FuncOptions), Options: convertSlice(n.Options), } @@ -1033,10 +970,10 @@ func convertCreateForeignServerStmt(n *pg.CreateForeignServerStmt) *ast.CreateFo return nil } return &ast.CreateForeignServerStmt{ - Servername: n.Servername, - Servertype: n.Servertype, - Version: n.Version, - Fdwname: n.Fdwname, + Servername: &n.Servername, + Servertype: &n.Servertype, + Version: &n.Version, + Fdwname: &n.Fdwname, IfNotExists: n.IfNotExists, Options: convertSlice(n.Options), } @@ -1047,8 +984,7 @@ func convertCreateForeignTableStmt(n *pg.CreateForeignTableStmt) *ast.CreateFore return nil } return &ast.CreateForeignTableStmt{ - Base: convertCreateStmt(&n.Base), - Servername: n.Servername, + Servername: &n.Servername, Options: convertSlice(n.Options), } } @@ -1057,17 +993,16 @@ func convertCreateFunctionStmt(n *pg.CreateFunctionStmt) *ast.CreateFunctionStmt if n == nil { return nil } - fn, err := parseFuncName(n.Funcname) + rel, err := parseRelationFromNodes(n.Funcname) if err != nil { panic(err) } return &ast.CreateFunctionStmt{ Replace: n.Replace, - Func: fn, + Func: rel.FuncName(), Params: convertSlice(n.Parameters), ReturnType: convertTypeName(n.ReturnType), Options: convertSlice(n.Options), - WithClause: convertSlice(n.WithClause), } } @@ -1076,9 +1011,9 @@ func convertCreateOpClassItem(n *pg.CreateOpClassItem) *ast.CreateOpClassItem { return nil } return &ast.CreateOpClassItem{ - Itemtype: n.Itemtype, + Itemtype: int(n.Itemtype), Name: convertObjectWithArgs(n.Name), - Number: n.Number, + Number: int(n.Number), OrderFamily: convertSlice(n.OrderFamily), ClassArgs: convertSlice(n.ClassArgs), Storedtype: convertTypeName(n.Storedtype), @@ -1092,7 +1027,7 @@ func convertCreateOpClassStmt(n *pg.CreateOpClassStmt) *ast.CreateOpClassStmt { return &ast.CreateOpClassStmt{ Opclassname: convertSlice(n.Opclassname), Opfamilyname: convertSlice(n.Opfamilyname), - Amname: n.Amname, + Amname: &n.Amname, Datatype: convertTypeName(n.Datatype), Items: convertSlice(n.Items), IsDefault: n.IsDefault, @@ -1105,7 +1040,7 @@ func convertCreateOpFamilyStmt(n *pg.CreateOpFamilyStmt) *ast.CreateOpFamilyStmt } return &ast.CreateOpFamilyStmt{ Opfamilyname: convertSlice(n.Opfamilyname), - Amname: n.Amname, + Amname: &n.Amname, } } @@ -1115,7 +1050,7 @@ func convertCreatePLangStmt(n *pg.CreatePLangStmt) *ast.CreatePLangStmt { } return &ast.CreatePLangStmt{ Replace: n.Replace, - Plname: n.Plname, + Plname: &n.Plname, Plhandler: convertSlice(n.Plhandler), Plinline: convertSlice(n.Plinline), Plvalidator: convertSlice(n.Plvalidator), @@ -1128,9 +1063,9 @@ func convertCreatePolicyStmt(n *pg.CreatePolicyStmt) *ast.CreatePolicyStmt { return nil } return &ast.CreatePolicyStmt{ - PolicyName: n.PolicyName, + PolicyName: &n.PolicyName, Table: convertRangeVar(n.Table), - CmdName: n.CmdName, + CmdName: &n.CmdName, Permissive: n.Permissive, Roles: convertSlice(n.Roles), Qual: convertNode(n.Qual), @@ -1143,7 +1078,7 @@ func convertCreatePublicationStmt(n *pg.CreatePublicationStmt) *ast.CreatePublic return nil } return &ast.CreatePublicationStmt{ - Pubname: n.Pubname, + Pubname: &n.Pubname, Options: convertSlice(n.Options), Tables: convertSlice(n.Tables), ForAllTables: n.ForAllTables, @@ -1166,7 +1101,7 @@ func convertCreateRoleStmt(n *pg.CreateRoleStmt) *ast.CreateRoleStmt { } return &ast.CreateRoleStmt{ StmtType: ast.RoleStmtType(n.StmtType), - Role: n.Role, + Role: &n.Role, Options: convertSlice(n.Options), } } @@ -1176,7 +1111,7 @@ func convertCreateSchemaStmt(n *pg.CreateSchemaStmt) *ast.CreateSchemaStmt { return nil } return &ast.CreateSchemaStmt{ - Name: n.Schemaname, + Name: &n.Schemaname, Authrole: convertRoleSpec(n.Authrole), SchemaElts: convertSlice(n.SchemaElts), IfNotExists: n.IfNotExists, @@ -1223,7 +1158,7 @@ func convertCreateStmt(n *pg.CreateStmt) *ast.CreateStmt { Constraints: convertSlice(n.Constraints), Options: convertSlice(n.Options), Oncommit: ast.OnCommitAction(n.Oncommit), - Tablespacename: n.Tablespacename, + Tablespacename: &n.Tablespacename, IfNotExists: n.IfNotExists, } } @@ -1233,8 +1168,8 @@ func convertCreateSubscriptionStmt(n *pg.CreateSubscriptionStmt) *ast.CreateSubs return nil } return &ast.CreateSubscriptionStmt{ - Subname: n.Subname, - Conninfo: n.Conninfo, + Subname: &n.Subname, + Conninfo: &n.Conninfo, Publication: convertSlice(n.Publication), Options: convertSlice(n.Options), } @@ -1258,9 +1193,9 @@ func convertCreateTableSpaceStmt(n *pg.CreateTableSpaceStmt) *ast.CreateTableSpa return nil } return &ast.CreateTableSpaceStmt{ - Tablespacename: n.Tablespacename, + Tablespacename: &n.Tablespacename, Owner: convertRoleSpec(n.Owner), - Location: n.Location, + Location: &n.Location, Options: convertSlice(n.Options), } } @@ -1272,7 +1207,7 @@ func convertCreateTransformStmt(n *pg.CreateTransformStmt) *ast.CreateTransformS return &ast.CreateTransformStmt{ Replace: n.Replace, TypeName: convertTypeName(n.TypeName), - Lang: n.Lang, + Lang: &n.Lang, Fromsql: convertObjectWithArgs(n.Fromsql), Tosql: convertObjectWithArgs(n.Tosql), } @@ -1283,13 +1218,13 @@ func convertCreateTrigStmt(n *pg.CreateTrigStmt) *ast.CreateTrigStmt { return nil } return &ast.CreateTrigStmt{ - Trigname: n.Trigname, + Trigname: &n.Trigname, Relation: convertRangeVar(n.Relation), Funcname: convertSlice(n.Funcname), Args: convertSlice(n.Args), Row: n.Row, - Timing: n.Timing, - Events: n.Events, + Timing: int16(n.Timing), + Events: int16(n.Events), Columns: convertSlice(n.Columns), WhenClause: convertNode(n.WhenClause), Isconstraint: n.Isconstraint, @@ -1306,7 +1241,7 @@ func convertCreateUserMappingStmt(n *pg.CreateUserMappingStmt) *ast.CreateUserMa } return &ast.CreateUserMappingStmt{ User: convertRoleSpec(n.User), - Servername: n.Servername, + Servername: &n.Servername, IfNotExists: n.IfNotExists, Options: convertSlice(n.Options), } @@ -1317,7 +1252,7 @@ func convertCreatedbStmt(n *pg.CreatedbStmt) *ast.CreatedbStmt { return nil } return &ast.CreatedbStmt{ - Dbname: n.Dbname, + Dbname: &n.Dbname, Options: convertSlice(n.Options), } } @@ -1329,8 +1264,8 @@ func convertCurrentOfExpr(n *pg.CurrentOfExpr) *ast.CurrentOfExpr { return &ast.CurrentOfExpr{ Xpr: convertNode(n.Xpr), Cvarno: ast.Index(n.Cvarno), - CursorName: n.CursorName, - CursorParam: n.CursorParam, + CursorName: &n.CursorName, + CursorParam: int(n.CursorParam), } } @@ -1339,7 +1274,7 @@ func convertDeallocateStmt(n *pg.DeallocateStmt) *ast.DeallocateStmt { return nil } return &ast.DeallocateStmt{ - Name: n.Name, + Name: &n.Name, } } @@ -1348,8 +1283,8 @@ func convertDeclareCursorStmt(n *pg.DeclareCursorStmt) *ast.DeclareCursorStmt { return nil } return &ast.DeclareCursorStmt{ - Portalname: n.Portalname, - Options: n.Options, + Portalname: &n.Portalname, + Options: int(n.Options), Query: convertNode(n.Query), } } @@ -1359,11 +1294,11 @@ func convertDefElem(n *pg.DefElem) *ast.DefElem { return nil } return &ast.DefElem{ - Defnamespace: n.Defnamespace, - Defname: n.Defname, + Defnamespace: &n.Defnamespace, + Defname: &n.Defname, Arg: convertNode(n.Arg), Defaction: ast.DefElemAction(n.Defaction), - Location: n.Location, + Location: int(n.Location), } } @@ -1450,7 +1385,7 @@ func convertDropSubscriptionStmt(n *pg.DropSubscriptionStmt) *ast.DropSubscripti return nil } return &ast.DropSubscriptionStmt{ - Subname: n.Subname, + Subname: &n.Subname, MissingOk: n.MissingOk, Behavior: ast.DropBehavior(n.Behavior), } @@ -1461,7 +1396,7 @@ func convertDropTableSpaceStmt(n *pg.DropTableSpaceStmt) *ast.DropTableSpaceStmt return nil } return &ast.DropTableSpaceStmt{ - Tablespacename: n.Tablespacename, + Tablespacename: &n.Tablespacename, MissingOk: n.MissingOk, } } @@ -1472,7 +1407,7 @@ func convertDropUserMappingStmt(n *pg.DropUserMappingStmt) *ast.DropUserMappingS } return &ast.DropUserMappingStmt{ User: convertRoleSpec(n.User), - Servername: n.Servername, + Servername: &n.Servername, MissingOk: n.MissingOk, } } @@ -1482,7 +1417,7 @@ func convertDropdbStmt(n *pg.DropdbStmt) *ast.DropdbStmt { return nil } return &ast.DropdbStmt{ - Dbname: n.Dbname, + Dbname: &n.Dbname, MissingOk: n.MissingOk, } } @@ -1492,7 +1427,7 @@ func convertExecuteStmt(n *pg.ExecuteStmt) *ast.ExecuteStmt { return nil } return &ast.ExecuteStmt{ - Name: n.Name, + Name: &n.Name, Params: convertSlice(n.Params), } } @@ -1521,7 +1456,7 @@ func convertFetchStmt(n *pg.FetchStmt) *ast.FetchStmt { return &ast.FetchStmt{ Direction: ast.FetchDirection(n.Direction), HowMany: n.HowMany, - Portalname: n.Portalname, + Portalname: &n.Portalname, Ismove: n.Ismove, } } @@ -1576,13 +1511,13 @@ func convertFuncCall(n *pg.FuncCall) *ast.FuncCall { if n == nil { return nil } - fn, err := parseFuncName(n.Funcname) + rel, err := parseRelationFromNodes(n.Funcname) if err != nil { // TODO: How should we handle errors? panic(err) } return &ast.FuncCall{ - Func: fn, + Func: rel.FuncName(), Funcname: convertSlice(n.Funcname), Args: convertSlice(n.Args), AggOrder: convertSlice(n.AggOrder), @@ -1592,7 +1527,7 @@ func convertFuncCall(n *pg.FuncCall) *ast.FuncCall { AggDistinct: n.AggDistinct, FuncVariadic: n.FuncVariadic, Over: convertWindowDef(n.Over), - Location: n.Location, + Location: int(n.Location), } } @@ -1610,7 +1545,7 @@ func convertFuncExpr(n *pg.FuncExpr) *ast.FuncExpr { Funccollid: ast.Oid(n.Funccollid), Inputcollid: ast.Oid(n.Inputcollid), Args: convertSlice(n.Args), - Location: n.Location, + Location: int(n.Location), } } @@ -1619,7 +1554,7 @@ func convertFunctionParameter(n *pg.FunctionParameter) *ast.FunctionParameter { return nil } return &ast.FunctionParameter{ - Name: n.Name, + Name: &n.Name, ArgType: convertTypeName(n.ArgType), Mode: ast.FunctionParameterMode(n.Mode), Defexpr: convertNode(n.Defexpr), @@ -1666,7 +1601,7 @@ func convertGroupingFunc(n *pg.GroupingFunc) *ast.GroupingFunc { Refs: convertSlice(n.Refs), Cols: convertSlice(n.Cols), Agglevelsup: ast.Index(n.Agglevelsup), - Location: n.Location, + Location: int(n.Location), } } @@ -1677,7 +1612,7 @@ func convertGroupingSet(n *pg.GroupingSet) *ast.GroupingSet { return &ast.GroupingSet{ Kind: ast.GroupingSetKind(n.Kind), Content: convertSlice(n.Content), - Location: n.Location, + Location: int(n.Location), } } @@ -1686,9 +1621,9 @@ func convertImportForeignSchemaStmt(n *pg.ImportForeignSchemaStmt) *ast.ImportFo return nil } return &ast.ImportForeignSchemaStmt{ - ServerName: n.ServerName, - RemoteSchema: n.RemoteSchema, - LocalSchema: n.LocalSchema, + ServerName: &n.ServerName, + RemoteSchema: &n.RemoteSchema, + LocalSchema: &n.LocalSchema, ListType: ast.ImportForeignSchemaType(n.ListType), TableList: convertSlice(n.TableList), Options: convertSlice(n.Options), @@ -1700,9 +1635,9 @@ func convertIndexElem(n *pg.IndexElem) *ast.IndexElem { return nil } return &ast.IndexElem{ - Name: n.Name, + Name: &n.Name, Expr: convertNode(n.Expr), - Indexcolname: n.Indexcolname, + Indexcolname: &n.Indexcolname, Collation: convertSlice(n.Collation), Opclass: convertSlice(n.Opclass), Ordering: ast.SortByDir(n.Ordering), @@ -1715,15 +1650,15 @@ func convertIndexStmt(n *pg.IndexStmt) *ast.IndexStmt { return nil } return &ast.IndexStmt{ - Idxname: n.Idxname, + Idxname: &n.Idxname, Relation: convertRangeVar(n.Relation), - AccessMethod: n.AccessMethod, - TableSpace: n.TableSpace, + AccessMethod: &n.AccessMethod, + TableSpace: &n.TableSpace, IndexParams: convertSlice(n.IndexParams), Options: convertSlice(n.Options), WhereClause: convertNode(n.WhereClause), ExcludeOpNames: convertSlice(n.ExcludeOpNames), - Idxcomment: n.Idxcomment, + Idxcomment: &n.Idxcomment, IndexOid: ast.Oid(n.IndexOid), OldNode: ast.Oid(n.OldNode), Unique: n.Unique, @@ -1744,8 +1679,8 @@ func convertInferClause(n *pg.InferClause) *ast.InferClause { return &ast.InferClause{ IndexElems: convertSlice(n.IndexElems), WhereClause: convertNode(n.WhereClause), - Conname: n.Conname, - Location: n.Location, + Conname: &n.Conname, + Location: int(n.Location), } } @@ -1766,7 +1701,7 @@ func convertInlineCodeBlock(n *pg.InlineCodeBlock) *ast.InlineCodeBlock { return nil } return &ast.InlineCodeBlock{ - SourceText: n.SourceText, + SourceText: &n.SourceText, LangOid: ast.Oid(n.LangOid), LangIsTrusted: n.LangIsTrusted, } @@ -1792,7 +1727,7 @@ func convertInteger(n *pg.Integer) *ast.Integer { return nil } return &ast.Integer{ - Ival: n.Ival, + Ival: int64(n.Ival), } } @@ -1805,7 +1740,7 @@ func convertIntoClause(n *pg.IntoClause) *ast.IntoClause { ColNames: convertSlice(n.ColNames), Options: convertSlice(n.Options), OnCommit: ast.OnCommitAction(n.OnCommit), - TableSpaceName: n.TableSpaceName, + TableSpaceName: &n.TableSpaceName, ViewQuery: convertNode(n.ViewQuery), SkipData: n.SkipData, } @@ -1823,7 +1758,7 @@ func convertJoinExpr(n *pg.JoinExpr) *ast.JoinExpr { UsingClause: convertSlice(n.UsingClause), Quals: convertNode(n.Quals), Alias: convertAlias(n.Alias), - Rtindex: n.Rtindex, + Rtindex: int(n.Rtindex), } } @@ -1832,7 +1767,7 @@ func convertSliceenStmt(n *pg.ListenStmt) *ast.ListenStmt { return nil } return &ast.ListenStmt{ - Conditionname: n.Conditionname, + Conditionname: &n.Conditionname, } } @@ -1841,7 +1776,7 @@ func convertLoadStmt(n *pg.LoadStmt) *ast.LoadStmt { return nil } return &ast.LoadStmt{ - Filename: n.Filename, + Filename: &n.Filename, } } @@ -1851,7 +1786,7 @@ func convertLockStmt(n *pg.LockStmt) *ast.LockStmt { } return &ast.LockStmt{ Relations: convertSlice(n.Relations), - Mode: n.Mode, + Mode: int(n.Mode), Nowait: n.Nowait, } } @@ -1878,7 +1813,7 @@ func convertMinMaxExpr(n *pg.MinMaxExpr) *ast.MinMaxExpr { Inputcollid: ast.Oid(n.Inputcollid), Op: ast.MinMaxOp(n.Op), Args: convertSlice(n.Args), - Location: n.Location, + Location: int(n.Location), } } @@ -1888,8 +1823,8 @@ func convertMultiAssignRef(n *pg.MultiAssignRef) *ast.MultiAssignRef { } return &ast.MultiAssignRef{ Source: convertNode(n.Source), - Colno: n.Colno, - Ncolumns: n.Ncolumns, + Colno: int(n.Colno), + Ncolumns: int(n.Ncolumns), } } @@ -1900,9 +1835,9 @@ func convertNamedArgExpr(n *pg.NamedArgExpr) *ast.NamedArgExpr { return &ast.NamedArgExpr{ Xpr: convertNode(n.Xpr), Arg: convertNode(n.Arg), - Name: n.Name, - Argnumber: n.Argnumber, - Location: n.Location, + Name: &n.Name, + Argnumber: int(n.Argnumber), + Location: int(n.Location), } } @@ -1922,8 +1857,8 @@ func convertNotifyStmt(n *pg.NotifyStmt) *ast.NotifyStmt { return nil } return &ast.NotifyStmt{ - Conditionname: n.Conditionname, - Payload: n.Payload, + Conditionname: &n.Conditionname, + Payload: &n.Payload, } } @@ -1943,7 +1878,7 @@ func convertNullTest(n *pg.NullTest) *ast.NullTest { Arg: convertNode(n.Arg), Nulltesttype: ast.NullTestType(n.Nulltesttype), Argisrow: n.Argisrow, - Location: n.Location, + Location: int(n.Location), } } @@ -1967,7 +1902,7 @@ func convertOnConflictClause(n *pg.OnConflictClause) *ast.OnConflictClause { Infer: convertInferClause(n.Infer), TargetList: convertSlice(n.TargetList), WhereClause: convertNode(n.WhereClause), - Location: n.Location, + Location: int(n.Location), } } @@ -1982,7 +1917,7 @@ func convertOnConflictExpr(n *pg.OnConflictExpr) *ast.OnConflictExpr { Constraint: ast.Oid(n.Constraint), OnConflictSet: convertSlice(n.OnConflictSet), OnConflictWhere: convertNode(n.OnConflictWhere), - ExclRelIndex: n.ExclRelIndex, + ExclRelIndex: int(n.ExclRelIndex), ExclRelTlist: convertSlice(n.ExclRelTlist), } } @@ -2000,7 +1935,7 @@ func convertOpExpr(n *pg.OpExpr) *ast.OpExpr { Opcollid: ast.Oid(n.Opcollid), Inputcollid: ast.Oid(n.Inputcollid), Args: convertSlice(n.Args), - Location: n.Location, + Location: int(n.Location), } } @@ -2011,46 +1946,11 @@ func convertParam(n *pg.Param) *ast.Param { return &ast.Param{ Xpr: convertNode(n.Xpr), Paramkind: ast.ParamKind(n.Paramkind), - Paramid: n.Paramid, + Paramid: int(n.Paramid), Paramtype: ast.Oid(n.Paramtype), Paramtypmod: n.Paramtypmod, Paramcollid: ast.Oid(n.Paramcollid), - Location: n.Location, - } -} - -func convertParamExecData(n *pg.ParamExecData) *ast.ParamExecData { - if n == nil { - return nil - } - return &ast.ParamExecData{ - ExecPlan: &ast.TODO{}, - Value: ast.Datum(n.Value), - Isnull: n.Isnull, - } -} - -func convertParamExternData(n *pg.ParamExternData) *ast.ParamExternData { - if n == nil { - return nil - } - return &ast.ParamExternData{ - Value: ast.Datum(n.Value), - Isnull: n.Isnull, - Pflags: n.Pflags, - Ptype: ast.Oid(n.Ptype), - } -} - -func convertParamListInfoData(n *pg.ParamListInfoData) *ast.ParamListInfoData { - if n == nil { - return nil - } - return &ast.ParamListInfoData{ - ParamFetchArg: &ast.TODO{}, - ParserSetupArg: &ast.TODO{}, - NumParams: n.NumParams, - ParamMask: n.ParamMask, + Location: int(n.Location), } } @@ -2059,8 +1959,8 @@ func convertParamRef(n *pg.ParamRef) *ast.ParamRef { return nil } return &ast.ParamRef{ - Number: n.Number, - Location: n.Location, + Number: int(n.Number), + Location: int(n.Location), } } @@ -2069,11 +1969,11 @@ func convertPartitionBoundSpec(n *pg.PartitionBoundSpec) *ast.PartitionBoundSpec return nil } return &ast.PartitionBoundSpec{ - Strategy: n.Strategy, + Strategy: makeByte(n.Strategy), Listdatums: convertSlice(n.Listdatums), Lowerdatums: convertSlice(n.Lowerdatums), Upperdatums: convertSlice(n.Upperdatums), - Location: n.Location, + Location: int(n.Location), } } @@ -2092,11 +1992,11 @@ func convertPartitionElem(n *pg.PartitionElem) *ast.PartitionElem { return nil } return &ast.PartitionElem{ - Name: n.Name, + Name: &n.Name, Expr: convertNode(n.Expr), Collation: convertSlice(n.Collation), Opclass: convertSlice(n.Opclass), - Location: n.Location, + Location: int(n.Location), } } @@ -2107,7 +2007,7 @@ func convertPartitionRangeDatum(n *pg.PartitionRangeDatum) *ast.PartitionRangeDa return &ast.PartitionRangeDatum{ Kind: ast.PartitionRangeDatumKind(n.Kind), Value: convertNode(n.Value), - Location: n.Location, + Location: int(n.Location), } } @@ -2116,9 +2016,9 @@ func convertPartitionSpec(n *pg.PartitionSpec) *ast.PartitionSpec { return nil } return &ast.PartitionSpec{ - Strategy: n.Strategy, + Strategy: &n.Strategy, PartParams: convertSlice(n.PartParams), - Location: n.Location, + Location: int(n.Location), } } @@ -2127,7 +2027,7 @@ func convertPrepareStmt(n *pg.PrepareStmt) *ast.PrepareStmt { return nil } return &ast.PrepareStmt{ - Name: n.Name, + Name: &n.Name, Argtypes: convertSlice(n.Argtypes), Query: convertNode(n.Query), } @@ -2140,10 +2040,9 @@ func convertQuery(n *pg.Query) *ast.Query { return &ast.Query{ CommandType: ast.CmdType(n.CommandType), QuerySource: ast.QuerySource(n.QuerySource), - QueryId: n.QueryId, CanSetTag: n.CanSetTag, UtilityStmt: convertNode(n.UtilityStmt), - ResultRelation: n.ResultRelation, + ResultRelation: int(n.ResultRelation), HasAggs: n.HasAggs, HasWindowFuncs: n.HasWindowFuncs, HasTargetSrfs: n.HasTargetSrfs, @@ -2172,8 +2071,8 @@ func convertQuery(n *pg.Query) *ast.Query { SetOperations: convertNode(n.SetOperations), ConstraintDeps: convertSlice(n.ConstraintDeps), WithCheckOptions: convertSlice(n.WithCheckOptions), - StmtLocation: n.StmtLocation, - StmtLen: n.StmtLen, + StmtLocation: int(n.StmtLocation), + StmtLen: int(n.StmtLen), } } @@ -2213,7 +2112,7 @@ func convertRangeTableFunc(n *pg.RangeTableFunc) *ast.RangeTableFunc { Namespaces: convertSlice(n.Namespaces), Columns: convertSlice(n.Columns), Alias: convertAlias(n.Alias), - Location: n.Location, + Location: int(n.Location), } } @@ -2222,13 +2121,13 @@ func convertRangeTableFuncCol(n *pg.RangeTableFuncCol) *ast.RangeTableFuncCol { return nil } return &ast.RangeTableFuncCol{ - Colname: n.Colname, + Colname: &n.Colname, TypeName: convertTypeName(n.TypeName), ForOrdinality: n.ForOrdinality, IsNotNull: n.IsNotNull, Colexpr: convertNode(n.Colexpr), Coldefexpr: convertNode(n.Coldefexpr), - Location: n.Location, + Location: int(n.Location), } } @@ -2241,7 +2140,7 @@ func convertRangeTableSample(n *pg.RangeTableSample) *ast.RangeTableSample { Method: convertSlice(n.Method), Args: convertSlice(n.Args), Repeatable: convertNode(n.Repeatable), - Location: n.Location, + Location: int(n.Location), } } @@ -2252,7 +2151,7 @@ func convertRangeTblEntry(n *pg.RangeTblEntry) *ast.RangeTblEntry { return &ast.RangeTblEntry{ Rtekind: ast.RTEKind(n.Rtekind), Relid: ast.Oid(n.Relid), - Relkind: n.Relkind, + Relkind: makeByte(n.Relkind), Tablesample: convertTableSampleClause(n.Tablesample), Subquery: convertQuery(n.Subquery), SecurityBarrier: n.SecurityBarrier, @@ -2262,13 +2161,13 @@ func convertRangeTblEntry(n *pg.RangeTblEntry) *ast.RangeTblEntry { Funcordinality: n.Funcordinality, Tablefunc: convertTableFunc(n.Tablefunc), ValuesLists: convertSlice(n.ValuesLists), - Ctename: n.Ctename, + Ctename: &n.Ctename, Ctelevelsup: ast.Index(n.Ctelevelsup), SelfReference: n.SelfReference, Coltypes: convertSlice(n.Coltypes), Coltypmods: convertSlice(n.Coltypmods), Colcollations: convertSlice(n.Colcollations), - Enrname: n.Enrname, + Enrname: &n.Enrname, Enrtuples: n.Enrtuples, Alias: convertAlias(n.Alias), Eref: convertAlias(n.Eref), @@ -2277,9 +2176,9 @@ func convertRangeTblEntry(n *pg.RangeTblEntry) *ast.RangeTblEntry { InFromCl: n.InFromCl, RequiredPerms: ast.AclMode(n.RequiredPerms), CheckAsUser: ast.Oid(n.CheckAsUser), - SelectedCols: n.SelectedCols, - InsertedCols: n.InsertedCols, - UpdatedCols: n.UpdatedCols, + SelectedCols: makeUint32Slice(n.SelectedCols), + InsertedCols: makeUint32Slice(n.InsertedCols), + UpdatedCols: makeUint32Slice(n.UpdatedCols), SecurityQuals: convertSlice(n.SecurityQuals), } } @@ -2290,12 +2189,12 @@ func convertRangeTblFunction(n *pg.RangeTblFunction) *ast.RangeTblFunction { } return &ast.RangeTblFunction{ Funcexpr: convertNode(n.Funcexpr), - Funccolcount: n.Funccolcount, + Funccolcount: int(n.Funccolcount), Funccolnames: convertSlice(n.Funccolnames), Funccoltypes: convertSlice(n.Funccoltypes), Funccoltypmods: convertSlice(n.Funccoltypmods), Funccolcollations: convertSlice(n.Funccolcollations), - Funcparams: n.Funcparams, + Funcparams: makeUint32Slice(n.Funcparams), } } @@ -2304,7 +2203,7 @@ func convertRangeTblRef(n *pg.RangeTblRef) *ast.RangeTblRef { return nil } return &ast.RangeTblRef{ - Rtindex: n.Rtindex, + Rtindex: int(n.Rtindex), } } @@ -2313,13 +2212,13 @@ func convertRangeVar(n *pg.RangeVar) *ast.RangeVar { return nil } return &ast.RangeVar{ - Catalogname: n.Catalogname, - Schemaname: n.Schemaname, - Relname: n.Relname, + Catalogname: &n.Catalogname, + Schemaname: &n.Schemaname, + Relname: &n.Relname, Inh: n.Inh, - Relpersistence: n.Relpersistence, + Relpersistence: makeByte(n.Relpersistence), Alias: convertAlias(n.Alias), - Location: n.Location, + Location: int(n.Location), } } @@ -2329,8 +2228,8 @@ func convertRawStmt(n *pg.RawStmt) *ast.RawStmt { } return &ast.RawStmt{ Stmt: convertNode(n.Stmt), - StmtLocation: n.StmtLocation, - StmtLen: n.StmtLen, + StmtLocation: int(n.StmtLocation), + StmtLen: int(n.StmtLen), } } @@ -2362,8 +2261,8 @@ func convertReindexStmt(n *pg.ReindexStmt) *ast.ReindexStmt { return &ast.ReindexStmt{ Kind: ast.ReindexObjectType(n.Kind), Relation: convertRangeVar(n.Relation), - Name: n.Name, - Options: n.Options, + Name: &n.Name, + Options: int(n.Options), } } @@ -2378,7 +2277,7 @@ func convertRelabelType(n *pg.RelabelType) *ast.RelabelType { Resulttypmod: n.Resulttypmod, Resultcollid: ast.Oid(n.Resultcollid), Relabelformat: ast.CoercionForm(n.Relabelformat), - Location: n.Location, + Location: int(n.Location), } } @@ -2391,8 +2290,8 @@ func convertRenameStmt(n *pg.RenameStmt) *ast.RenameStmt { RelationType: ast.ObjectType(n.RelationType), Relation: convertRangeVar(n.Relation), Object: convertNode(n.Object), - Subname: n.Subname, - Newname: n.Newname, + Subname: &n.Subname, + Newname: &n.Newname, Behavior: ast.DropBehavior(n.Behavior), MissingOk: n.MissingOk, } @@ -2403,8 +2302,8 @@ func convertReplicaIdentityStmt(n *pg.ReplicaIdentityStmt) *ast.ReplicaIdentityS return nil } return &ast.ReplicaIdentityStmt{ - IdentityType: n.IdentityType, - Name: n.Name, + IdentityType: makeByte(n.IdentityType), + Name: &n.Name, } } @@ -2413,10 +2312,10 @@ func convertResTarget(n *pg.ResTarget) *ast.ResTarget { return nil } return &ast.ResTarget{ - Name: n.Name, + Name: &n.Name, Indirection: convertSlice(n.Indirection), Val: convertNode(n.Val), - Location: n.Location, + Location: int(n.Location), } } @@ -2426,8 +2325,8 @@ func convertRoleSpec(n *pg.RoleSpec) *ast.RoleSpec { } return &ast.RoleSpec{ Roletype: ast.RoleSpecType(n.Roletype), - Rolename: n.Rolename, - Location: n.Location, + Rolename: &n.Rolename, + Location: int(n.Location), } } @@ -2456,7 +2355,7 @@ func convertRowExpr(n *pg.RowExpr) *ast.RowExpr { RowTypeid: ast.Oid(n.RowTypeid), RowFormat: ast.CoercionForm(n.RowFormat), Colnames: convertSlice(n.Colnames), - Location: n.Location, + Location: int(n.Location), } } @@ -2478,7 +2377,7 @@ func convertRuleStmt(n *pg.RuleStmt) *ast.RuleStmt { } return &ast.RuleStmt{ Relation: convertRangeVar(n.Relation), - Rulename: n.Rulename, + Rulename: &n.Rulename, WhereClause: convertNode(n.WhereClause), Event: ast.CmdType(n.Event), Instead: n.Instead, @@ -2496,7 +2395,7 @@ func convertSQLValueFunction(n *pg.SQLValueFunction) *ast.SQLValueFunction { Op: ast.SQLValueFunctionOp(n.Op), Type: ast.Oid(n.Type), Typmod: n.Typmod, - Location: n.Location, + Location: int(n.Location), } } @@ -2511,7 +2410,7 @@ func convertScalarArrayOpExpr(n *pg.ScalarArrayOpExpr) *ast.ScalarArrayOpExpr { UseOr: n.UseOr, Inputcollid: ast.Oid(n.Inputcollid), Args: convertSlice(n.Args), - Location: n.Location, + Location: int(n.Location), } } @@ -2522,8 +2421,8 @@ func convertSecLabelStmt(n *pg.SecLabelStmt) *ast.SecLabelStmt { return &ast.SecLabelStmt{ Objtype: ast.ObjectType(n.Objtype), Object: convertNode(n.Object), - Provider: n.Provider, - Label: n.Label, + Provider: &n.Provider, + Label: &n.Label, } } @@ -2540,7 +2439,7 @@ func convertSelectStmt(n *pg.SelectStmt) *ast.SelectStmt { GroupClause: convertSlice(n.GroupClause), HavingClause: convertNode(n.HavingClause), WindowClause: convertSlice(n.WindowClause), - ValuesLists: convertValuesList(n.ValuesLists), + ValuesLists: convertSlice(n.ValuesLists), SortClause: convertSlice(n.SortClause), LimitOffset: convertNode(n.LimitOffset), LimitCount: convertNode(n.LimitCount), @@ -2578,7 +2477,7 @@ func convertSetToDefault(n *pg.SetToDefault) *ast.SetToDefault { TypeId: ast.Oid(n.TypeId), TypeMod: n.TypeMod, Collation: ast.Oid(n.Collation), - Location: n.Location, + Location: int(n.Location), } } @@ -2591,7 +2490,7 @@ func convertSortBy(n *pg.SortBy) *ast.SortBy { SortbyDir: ast.SortByDir(n.SortbyDir), SortbyNulls: ast.SortByNulls(n.SortbyNulls), UseOp: convertSlice(n.UseOp), - Location: n.Location, + Location: int(n.Location), } } @@ -2624,11 +2523,11 @@ func convertSubLink(n *pg.SubLink) *ast.SubLink { return &ast.SubLink{ Xpr: convertNode(n.Xpr), SubLinkType: ast.SubLinkType(n.SubLinkType), - SubLinkId: n.SubLinkId, + SubLinkId: int(n.SubLinkId), Testexpr: convertNode(n.Testexpr), OperName: convertSlice(n.OperName), Subselect: convertNode(n.Subselect), - Location: n.Location, + Location: int(n.Location), } } @@ -2641,8 +2540,8 @@ func convertSubPlan(n *pg.SubPlan) *ast.SubPlan { SubLinkType: ast.SubLinkType(n.SubLinkType), Testexpr: convertNode(n.Testexpr), ParamIds: convertSlice(n.ParamIds), - PlanId: n.PlanId, - PlanName: n.PlanName, + PlanId: int(n.PlanId), + PlanName: &n.PlanName, FirstColType: ast.Oid(n.FirstColType), FirstColTypmod: n.FirstColTypmod, FirstColCollation: ast.Oid(n.FirstColCollation), @@ -2672,9 +2571,9 @@ func convertTableFunc(n *pg.TableFunc) *ast.TableFunc { Colcollations: convertSlice(n.Colcollations), Colexprs: convertSlice(n.Colexprs), Coldefexprs: convertSlice(n.Coldefexprs), - Notnulls: n.Notnulls, - Ordinalitycol: n.Ordinalitycol, - Location: n.Location, + Notnulls: makeUint32Slice(n.Notnulls), + Ordinalitycol: int(n.Ordinalitycol), + Location: int(n.Location), } } @@ -2707,7 +2606,7 @@ func convertTargetEntry(n *pg.TargetEntry) *ast.TargetEntry { Xpr: convertNode(n.Xpr), Expr: convertNode(n.Expr), Resno: ast.AttrNumber(n.Resno), - Resname: n.Resname, + Resname: &n.Resname, Ressortgroupref: ast.Index(n.Ressortgroupref), Resorigtbl: ast.Oid(n.Resorigtbl), Resorigcol: ast.AttrNumber(n.Resorigcol), @@ -2722,7 +2621,7 @@ func convertTransactionStmt(n *pg.TransactionStmt) *ast.TransactionStmt { return &ast.TransactionStmt{ Kind: ast.TransactionStmtKind(n.Kind), Options: convertSlice(n.Options), - Gid: n.Gid, + Gid: &n.Gid, } } @@ -2731,7 +2630,7 @@ func convertTriggerTransition(n *pg.TriggerTransition) *ast.TriggerTransition { return nil } return &ast.TriggerTransition{ - Name: n.Name, + Name: &n.Name, IsNew: n.IsNew, IsTable: n.IsTable, } @@ -2755,7 +2654,7 @@ func convertTypeCast(n *pg.TypeCast) *ast.TypeCast { return &ast.TypeCast{ Arg: convertNode(n.Arg), TypeName: convertTypeName(n.TypeName), - Location: n.Location, + Location: int(n.Location), } } @@ -2771,7 +2670,7 @@ func convertTypeName(n *pg.TypeName) *ast.TypeName { Typmods: convertSlice(n.Typmods), Typemod: n.Typemod, ArrayBounds: convertSlice(n.ArrayBounds), - Location: n.Location, + Location: int(n.Location), } } @@ -2780,7 +2679,7 @@ func convertUnlistenStmt(n *pg.UnlistenStmt) *ast.UnlistenStmt { return nil } return &ast.UnlistenStmt{ - Conditionname: n.Conditionname, + Conditionname: &n.Conditionname, } } @@ -2803,9 +2702,10 @@ func convertVacuumStmt(n *pg.VacuumStmt) *ast.VacuumStmt { return nil } return &ast.VacuumStmt{ - Options: n.Options, - Relation: convertRangeVar(n.Relation), - VaCols: convertSlice(n.VaCols), + // FIXME: The VacuumStmt node has changed quite a bit + // Options: n.Options + // Relation: convertRangeVar(n.Relation), + // VaCols: convertSlice(n.VaCols), } } @@ -2821,9 +2721,7 @@ func convertVar(n *pg.Var) *ast.Var { Vartypmod: n.Vartypmod, Varcollid: ast.Oid(n.Varcollid), Varlevelsup: ast.Index(n.Varlevelsup), - Varnoold: ast.Index(n.Varnoold), - Varoattno: ast.AttrNumber(n.Varoattno), - Location: n.Location, + Location: int(n.Location), } } @@ -2833,7 +2731,7 @@ func convertVariableSetStmt(n *pg.VariableSetStmt) *ast.VariableSetStmt { } return &ast.VariableSetStmt{ Kind: ast.VariableSetKind(n.Kind), - Name: n.Name, + Name: &n.Name, Args: convertSlice(n.Args), IsLocal: n.IsLocal, } @@ -2844,7 +2742,7 @@ func convertVariableShowStmt(n *pg.VariableShowStmt) *ast.VariableShowStmt { return nil } return &ast.VariableShowStmt{ - Name: n.Name, + Name: &n.Name, } } @@ -2867,11 +2765,11 @@ func convertWindowClause(n *pg.WindowClause) *ast.WindowClause { return nil } return &ast.WindowClause{ - Name: n.Name, - Refname: n.Refname, + Name: &n.Name, + Refname: &n.Refname, PartitionClause: convertSlice(n.PartitionClause), OrderClause: convertSlice(n.OrderClause), - FrameOptions: n.FrameOptions, + FrameOptions: int(n.FrameOptions), StartOffset: convertNode(n.StartOffset), EndOffset: convertNode(n.EndOffset), Winref: ast.Index(n.Winref), @@ -2884,14 +2782,14 @@ func convertWindowDef(n *pg.WindowDef) *ast.WindowDef { return nil } return &ast.WindowDef{ - Name: n.Name, - Refname: n.Refname, + Name: &n.Name, + Refname: &n.Refname, PartitionClause: convertSlice(n.PartitionClause), OrderClause: convertSlice(n.OrderClause), - FrameOptions: n.FrameOptions, + FrameOptions: int(n.FrameOptions), StartOffset: convertNode(n.StartOffset), EndOffset: convertNode(n.EndOffset), - Location: n.Location, + Location: int(n.Location), } } @@ -2910,7 +2808,7 @@ func convertWindowFunc(n *pg.WindowFunc) *ast.WindowFunc { Winref: ast.Index(n.Winref), Winstar: n.Winstar, Winagg: n.Winagg, - Location: n.Location, + Location: int(n.Location), } } @@ -2920,8 +2818,8 @@ func convertWithCheckOption(n *pg.WithCheckOption) *ast.WithCheckOption { } return &ast.WithCheckOption{ Kind: ast.WCOKind(n.Kind), - Relname: n.Relname, - Polname: n.Polname, + Relname: &n.Relname, + Polname: &n.Polname, Qual: convertNode(n.Qual), Cascaded: n.Cascaded, } @@ -2934,7 +2832,7 @@ func convertWithClause(n *pg.WithClause) *ast.WithClause { return &ast.WithClause{ Ctes: convertSlice(n.Ctes), Recursive: n.Recursive, - Location: n.Location, + Location: int(n.Location), } } @@ -2945,14 +2843,14 @@ func convertXmlExpr(n *pg.XmlExpr) *ast.XmlExpr { return &ast.XmlExpr{ Xpr: convertNode(n.Xpr), Op: ast.XmlExprOp(n.Op), - Name: n.Name, + Name: &n.Name, NamedArgs: convertSlice(n.NamedArgs), ArgNames: convertSlice(n.ArgNames), Args: convertSlice(n.Args), Xmloption: ast.XmlOptionType(n.Xmloption), Type: ast.Oid(n.Type), Typmod: n.Typmod, - Location: n.Location, + Location: int(n.Location), } } @@ -2964,7 +2862,7 @@ func convertXmlSerialize(n *pg.XmlSerialize) *ast.XmlSerialize { Xmloption: ast.XmlOptionType(n.Xmloption), Expr: convertNode(n.Expr), TypeName: convertTypeName(n.TypeName), - Location: n.Location, + Location: int(n.Location), } } @@ -3100,15 +2998,9 @@ func convertNode(node *pg.Node) ast.Node { case pg.ArrayExpr: return convertArrayExpr(&n) - case pg.ArrayRef: - return convertArrayRef(&n) - case pg.BitString: return convertBitString(&n) - case pg.BlockIdData: - return convertBlockIdData(&n) - case pg.BoolExpr: return convertBoolExpr(&n) @@ -3166,9 +3058,6 @@ func convertNode(node *pg.Node) ast.Node { case pg.CompositeTypeStmt: return convertCompositeTypeStmt(&n) - case pg.Const: - return convertConst(&n) - case pg.Constraint: return convertConstraint(&n) diff --git a/internal/engine/postgresql/parse.go b/internal/engine/postgresql/parse.go index 33f2d920cd..686e6c31b9 100644 --- a/internal/engine/postgresql/parse.go +++ b/internal/engine/postgresql/parse.go @@ -25,12 +25,38 @@ func stringSlice(list nodes.List) []string { return items } +func stringSliceFromNodes(items []*nodes.Node) []string { + items := []string{} + for _, item := range items { + if n, ok := item.Node.(nodes.Node_String); ok { + items = append(items, n.String.Str) + } + } + return items +} + type relation struct { Catalog string Schema string Name string } +func (r relation) TypeName() *ast.TypeName { + return &ast.TypeName{ + Catalog: r.Catalog, + Schema: r.Schema, + Name: r.Name, + } +} + +func (r relation) FuncName() *ast.FuncName { + return &ast.FuncName{ + Catalog: rel.Catalog, + Schema: rel.Schema, + Name: rel.Name, + } +} + func parseFuncName(node nodes.Node) (*ast.FuncName, error) { rel, err := parseRelation(node) if err != nil { @@ -84,6 +110,37 @@ func parseTableName(node nodes.Node) (*ast.TableName, error) { }, nil } +func parseRelationFromNodes(list []*nodes.Node) (*relation, error) { + parts := stringSliceFromNodes(n) + switch len(parts) { + case 1: + return &relation{ + Name: parts[0], + }, nil + case 2: + return &relation{ + Schema: parts[0], + Name: parts[1], + }, nil + case 3: + return &relation{ + Catalog: parts[0], + Schema: parts[1], + Name: parts[2], + }, nil + default: + return nil, fmt.Errorf("invalid name: %s", join(n, ".")) + } +} + +func parseRelationFromRangeVar(rv *nodes.RangeVar) *relation { + return *relation{ + Catalog: n.Catalogname, + Schema: *n.Schemaname, + Name: *n.Relname, + } +} + func parseRelation(node nodes.Node) (*relation, error) { switch n := node.(type) { diff --git a/internal/engine/postgresql/utils.go b/internal/engine/postgresql/utils.go index 98ca057d8e..d9d43cc1ed 100644 --- a/internal/engine/postgresql/utils.go +++ b/internal/engine/postgresql/utils.go @@ -40,3 +40,19 @@ func IsNamedParamSign(node nodes.Node) bool { expr, ok := node.(nodes.A_Expr) return ok && join(expr.Name, ".") == "@" } + +func makeByte(s string) byte { + var b byte + if s == "" { + return b + } + return []byte(s)[0] +} + +func makeUint32Slice(in []uint64) []uint32 { + out := make([]uint32, len(v)) + for i, v := range in { + out[i] = uint32(v) + } + return out +} From 689b94461c97b6cb46920fee7cf3066bc4439880 Mon Sep 17 00:00:00 2001 From: Kyle Conroy Date: Thu, 18 Mar 2021 23:19:05 -0700 Subject: [PATCH 03/11] Slowly fix type switches --- internal/engine/postgresql/convert.go | 466 +++++++++++++------------- internal/engine/postgresql/parse.go | 6 +- 2 files changed, 236 insertions(+), 236 deletions(-) diff --git a/internal/engine/postgresql/convert.go b/internal/engine/postgresql/convert.go index 809d5ad987..5963a1ccc5 100644 --- a/internal/engine/postgresql/convert.go +++ b/internal/engine/postgresql/convert.go @@ -2872,664 +2872,664 @@ func convertNode(node *pg.Node) ast.Node { case *pg.Node_AArrayExpr: return convertA_ArrayExpr(n.AArrayExpr) - case pg.A_Const: - return convertA_Const(&n) + case *pg.Node_AConst: + return convertA_Const(n.AConst) - case pg.A_Expr: - return convertA_Expr(&n) + case *pg.Node_AExpr: + return convertA_Expr(n.AExpr) - case pg.A_Indices: - return convertA_Indices(&n) + case *pg.Node_AIndices: + return convertA_Indices(n.AIndices) - case pg.A_Indirection: - return convertA_Indirection(&n) + case *pg.Node_AIndirection: + return convertA_Indirection(n.AIndirection) - case pg.A_Star: - return convertA_Star(&n) + case *pg.Node_AStar: + return convertA_Star(n.AStar) - case pg.AccessPriv: - return convertAccessPriv(&n) + case *pg.Node_AccessPriv: + return convertAccessPriv(n.AccessPriv) - case pg.Aggref: - return convertAggref(&n) + case *pg.Node_Aggref: + return convertAggref(n.Aggref) - case pg.Alias: - return convertAlias(&n) + case *pg.Node_Alias: + return convertAlias(n.Alias) - case pg.AlterCollationStmt: - return convertAlterCollationStmt(&n) + case *pg.Node_AlterCollationStmt: + return convertAlterCollationStmt(n.AlterCollationStmt) - case pg.AlterDatabaseSetStmt: - return convertAlterDatabaseSetStmt(&n) + case *pg.Node_AlterDatabaseSetStmt: + return convertAlterDatabaseSetStmt(n.AlterDatabaseSetStmt) - case pg.AlterDatabaseStmt: - return convertAlterDatabaseStmt(&n) + case *pg.Node_AlterDatabaseStmt: + return convertAlterDatabaseStmt(n.AlterDatabaseStmt) - case pg.AlterDefaultPrivilegesStmt: - return convertAlterDefaultPrivilegesStmt(&n) + case *pg.Node_AlterDefaultPrivilegesStmt: + return convertAlterDefaultPrivilegesStmt(n.AlterDefaultPrivilegesStmt) - case pg.AlterDomainStmt: - return convertAlterDomainStmt(&n) + case *pg.Node_AlterDomainStmt: + return convertAlterDomainStmt(n.AlterDomainStmt) - case pg.AlterEnumStmt: + case *pg.Node_AlterEnumStmt: return convertAlterEnumStmt(&n) - case pg.AlterEventTrigStmt: + case *pg.Node_AlterEventTrigStmt: return convertAlterEventTrigStmt(&n) - case pg.AlterExtensionContentsStmt: + case *pg.Node_AlterExtensionContentsStmt: return convertAlterExtensionContentsStmt(&n) - case pg.AlterExtensionStmt: + case *pg.Node_AlterExtensionStmt: return convertAlterExtensionStmt(&n) - case pg.AlterFdwStmt: + case *pg.Node_AlterFdwStmt: return convertAlterFdwStmt(&n) - case pg.AlterForeignServerStmt: + case *pg.Node_AlterForeignServerStmt: return convertAlterForeignServerStmt(&n) - case pg.AlterFunctionStmt: + case *pg.Node_AlterFunctionStmt: return convertAlterFunctionStmt(&n) - case pg.AlterObjectDependsStmt: + case *pg.Node_AlterObjectDependsStmt: return convertAlterObjectDependsStmt(&n) - case pg.AlterObjectSchemaStmt: + case *pg.Node_AlterObjectSchemaStmt: return convertAlterObjectSchemaStmt(&n) - case pg.AlterOpFamilyStmt: + case *pg.Node_AlterOpFamilyStmt: return convertAlterOpFamilyStmt(&n) - case pg.AlterOperatorStmt: + case *pg.Node_AlterOperatorStmt: return convertAlterOperatorStmt(&n) - case pg.AlterOwnerStmt: + case *pg.Node_AlterOwnerStmt: return convertAlterOwnerStmt(&n) - case pg.AlterPolicyStmt: + case *pg.Node_AlterPolicyStmt: return convertAlterPolicyStmt(&n) - case pg.AlterPublicationStmt: + case *pg.Node_AlterPublicationStmt: return convertAlterPublicationStmt(&n) - case pg.AlterRoleSetStmt: + case *pg.Node_AlterRoleSetStmt: return convertAlterRoleSetStmt(&n) - case pg.AlterRoleStmt: + case *pg.Node_AlterRoleStmt: return convertAlterRoleStmt(&n) - case pg.AlterSeqStmt: + case *pg.Node_AlterSeqStmt: return convertAlterSeqStmt(&n) - case pg.AlterSubscriptionStmt: + case *pg.Node_AlterSubscriptionStmt: return convertAlterSubscriptionStmt(&n) - case pg.AlterSystemStmt: + case *pg.Node_AlterSystemStmt: return convertAlterSystemStmt(&n) - case pg.AlterTSConfigurationStmt: + case *pg.Node_AlterTSConfigurationStmt: return convertAlterTSConfigurationStmt(&n) - case pg.AlterTSDictionaryStmt: + case *pg.Node_AlterTSDictionaryStmt: return convertAlterTSDictionaryStmt(&n) - case pg.AlterTableCmd: + case *pg.Node_AlterTableCmd: return convertAlterTableCmd(&n) - case pg.AlterTableMoveAllStmt: + case *pg.Node_AlterTableMoveAllStmt: return convertAlterTableMoveAllStmt(&n) - case pg.AlterTableSpaceOptionsStmt: + case *pg.Node_AlterTableSpaceOptionsStmt: return convertAlterTableSpaceOptionsStmt(&n) - case pg.AlterTableStmt: + case *pg.Node_AlterTableStmt: return convertAlterTableStmt(&n) - case pg.AlterUserMappingStmt: + case *pg.Node_AlterUserMappingStmt: return convertAlterUserMappingStmt(&n) - case pg.AlternativeSubPlan: + case *pg.Node_AlternativeSubPlan: return convertAlternativeSubPlan(&n) - case pg.ArrayCoerceExpr: + case *pg.Node_ArrayCoerceExpr: return convertArrayCoerceExpr(&n) - case pg.ArrayExpr: + case *pg.Node_ArrayExpr: return convertArrayExpr(&n) - case pg.BitString: + case *pg.Node_BitString: return convertBitString(&n) - case pg.BoolExpr: + case *pg.Node_BoolExpr: return convertBoolExpr(&n) - case pg.BooleanTest: + case *pg.Node_BooleanTest: return convertBooleanTest(&n) - case pg.CaseExpr: + case *pg.Node_CaseExpr: return convertCaseExpr(&n) - case pg.CaseTestExpr: + case *pg.Node_CaseTestExpr: return convertCaseTestExpr(&n) - case pg.CaseWhen: + case *pg.Node_CaseWhen: return convertCaseWhen(&n) - case pg.CheckPointStmt: + case *pg.Node_CheckPointStmt: return convertCheckPointStmt(&n) - case pg.ClosePortalStmt: + case *pg.Node_ClosePortalStmt: return convertClosePortalStmt(&n) - case pg.ClusterStmt: + case *pg.Node_ClusterStmt: return convertClusterStmt(&n) - case pg.CoalesceExpr: + case *pg.Node_CoalesceExpr: return convertCoalesceExpr(&n) - case pg.CoerceToDomain: + case *pg.Node_CoerceToDomain: return convertCoerceToDomain(&n) - case pg.CoerceToDomainValue: + case *pg.Node_CoerceToDomainValue: return convertCoerceToDomainValue(&n) - case pg.CoerceViaIO: + case *pg.Node_CoerceViaIO: return convertCoerceViaIO(&n) - case pg.CollateClause: + case *pg.Node_CollateClause: return convertCollateClause(&n) - case pg.CollateExpr: + case *pg.Node_CollateExpr: return convertCollateExpr(&n) - case pg.ColumnDef: + case *pg.Node_ColumnDef: return convertColumnDef(&n) - case pg.ColumnRef: + case *pg.Node_ColumnRef: return convertColumnRef(&n) - case pg.CommentStmt: + case *pg.Node_CommentStmt: return convertCommentStmt(&n) - case pg.CommonTableExpr: + case *pg.Node_CommonTableExpr: return convertCommonTableExpr(&n) - case pg.CompositeTypeStmt: + case *pg.Node_CompositeTypeStmt: return convertCompositeTypeStmt(&n) - case pg.Constraint: + case *pg.Node_Constraint: return convertConstraint(&n) - case pg.ConstraintsSetStmt: + case *pg.Node_ConstraintsSetStmt: return convertConstraintsSetStmt(&n) - case pg.ConvertRowtypeExpr: + case *pg.Node_ConvertRowtypeExpr: return convertConvertRowtypeExpr(&n) - case pg.CopyStmt: + case *pg.Node_CopyStmt: return convertCopyStmt(&n) - case pg.CreateAmStmt: + case *pg.Node_CreateAmStmt: return convertCreateAmStmt(&n) - case pg.CreateCastStmt: + case *pg.Node_CreateCastStmt: return convertCreateCastStmt(&n) - case pg.CreateConversionStmt: + case *pg.Node_CreateConversionStmt: return convertCreateConversionStmt(&n) - case pg.CreateDomainStmt: + case *pg.Node_CreateDomainStmt: return convertCreateDomainStmt(&n) - case pg.CreateEnumStmt: + case *pg.Node_CreateEnumStmt: return convertCreateEnumStmt(&n) - case pg.CreateEventTrigStmt: + case *pg.Node_CreateEventTrigStmt: return convertCreateEventTrigStmt(&n) - case pg.CreateExtensionStmt: + case *pg.Node_CreateExtensionStmt: return convertCreateExtensionStmt(&n) - case pg.CreateFdwStmt: + case *pg.Node_CreateFdwStmt: return convertCreateFdwStmt(&n) - case pg.CreateForeignServerStmt: + case *pg.Node_CreateForeignServerStmt: return convertCreateForeignServerStmt(&n) - case pg.CreateForeignTableStmt: + case *pg.Node_CreateForeignTableStmt: return convertCreateForeignTableStmt(&n) - case pg.CreateFunctionStmt: + case *pg.Node_CreateFunctionStmt: return convertCreateFunctionStmt(&n) - case pg.CreateOpClassItem: + case *pg.Node_CreateOpClassItem: return convertCreateOpClassItem(&n) - case pg.CreateOpClassStmt: + case *pg.Node_CreateOpClassStmt: return convertCreateOpClassStmt(&n) - case pg.CreateOpFamilyStmt: + case *pg.Node_CreateOpFamilyStmt: return convertCreateOpFamilyStmt(&n) - case pg.CreatePLangStmt: + case *pg.Node_CreatePLangStmt: return convertCreatePLangStmt(&n) - case pg.CreatePolicyStmt: + case *pg.Node_CreatePolicyStmt: return convertCreatePolicyStmt(&n) - case pg.CreatePublicationStmt: + case *pg.Node_CreatePublicationStmt: return convertCreatePublicationStmt(&n) - case pg.CreateRangeStmt: + case *pg.Node_CreateRangeStmt: return convertCreateRangeStmt(&n) - case pg.CreateRoleStmt: + case *pg.Node_CreateRoleStmt: return convertCreateRoleStmt(&n) - case pg.CreateSchemaStmt: + case *pg.Node_CreateSchemaStmt: return convertCreateSchemaStmt(&n) - case pg.CreateSeqStmt: + case *pg.Node_CreateSeqStmt: return convertCreateSeqStmt(&n) - case pg.CreateStatsStmt: + case *pg.Node_CreateStatsStmt: return convertCreateStatsStmt(&n) - case pg.CreateStmt: + case *pg.Node_CreateStmt: return convertCreateStmt(&n) - case pg.CreateSubscriptionStmt: + case *pg.Node_CreateSubscriptionStmt: return convertCreateSubscriptionStmt(&n) - case pg.CreateTableAsStmt: + case *pg.Node_CreateTableAsStmt: return convertCreateTableAsStmt(&n) - case pg.CreateTableSpaceStmt: + case *pg.Node_CreateTableSpaceStmt: return convertCreateTableSpaceStmt(&n) - case pg.CreateTransformStmt: + case *pg.Node_CreateTransformStmt: return convertCreateTransformStmt(&n) - case pg.CreateTrigStmt: + case *pg.Node_CreateTrigStmt: return convertCreateTrigStmt(&n) - case pg.CreateUserMappingStmt: + case *pg.Node_CreateUserMappingStmt: return convertCreateUserMappingStmt(&n) - case pg.CreatedbStmt: + case *pg.Node_CreatedbStmt: return convertCreatedbStmt(&n) - case pg.CurrentOfExpr: + case *pg.Node_CurrentOfExpr: return convertCurrentOfExpr(&n) - case pg.DeallocateStmt: + case *pg.Node_DeallocateStmt: return convertDeallocateStmt(&n) - case pg.DeclareCursorStmt: + case *pg.Node_DeclareCursorStmt: return convertDeclareCursorStmt(&n) - case pg.DefElem: + case *pg.Node_DefElem: return convertDefElem(&n) - case pg.DefineStmt: + case *pg.Node_DefineStmt: return convertDefineStmt(&n) - case pg.DeleteStmt: + case *pg.Node_DeleteStmt: return convertDeleteStmt(&n) - case pg.DiscardStmt: + case *pg.Node_DiscardStmt: return convertDiscardStmt(&n) - case pg.DoStmt: + case *pg.Node_DoStmt: return convertDoStmt(&n) - case pg.DropOwnedStmt: + case *pg.Node_DropOwnedStmt: return convertDropOwnedStmt(&n) - case pg.DropRoleStmt: + case *pg.Node_DropRoleStmt: return convertDropRoleStmt(&n) - case pg.DropStmt: + case *pg.Node_DropStmt: return convertDropStmt(&n) - case pg.DropSubscriptionStmt: + case *pg.Node_DropSubscriptionStmt: return convertDropSubscriptionStmt(&n) - case pg.DropTableSpaceStmt: + case *pg.Node_DropTableSpaceStmt: return convertDropTableSpaceStmt(&n) - case pg.DropUserMappingStmt: + case *pg.Node_DropUserMappingStmt: return convertDropUserMappingStmt(&n) - case pg.DropdbStmt: + case *pg.Node_DropdbStmt: return convertDropdbStmt(&n) - case pg.ExecuteStmt: + case *pg.Node_ExecuteStmt: return convertExecuteStmt(&n) - case pg.ExplainStmt: + case *pg.Node_ExplainStmt: return convertExplainStmt(&n) - case pg.Expr: + case *pg.Node_Expr: return convertExpr(&n) - case pg.FetchStmt: + case *pg.Node_FetchStmt: return convertFetchStmt(&n) - case pg.FieldSelect: + case *pg.Node_FieldSelect: return convertFieldSelect(&n) - case pg.FieldStore: + case *pg.Node_FieldStore: return convertFieldStore(&n) - case pg.Float: + case *pg.Node_Float: return convertFloat(&n) - case pg.FromExpr: + case *pg.Node_FromExpr: return convertFromExpr(&n) - case pg.FuncCall: + case *pg.Node_FuncCall: return convertFuncCall(&n) - case pg.FuncExpr: + case *pg.Node_FuncExpr: return convertFuncExpr(&n) - case pg.FunctionParameter: + case *pg.Node_FunctionParameter: return convertFunctionParameter(&n) - case pg.GrantRoleStmt: + case *pg.Node_GrantRoleStmt: return convertGrantRoleStmt(&n) - case pg.GrantStmt: + case *pg.Node_GrantStmt: return convertGrantStmt(&n) - case pg.GroupingFunc: + case *pg.Node_GroupingFunc: return convertGroupingFunc(&n) - case pg.GroupingSet: + case *pg.Node_GroupingSet: return convertGroupingSet(&n) - case pg.ImportForeignSchemaStmt: + case *pg.Node_ImportForeignSchemaStmt: return convertImportForeignSchemaStmt(&n) - case pg.IndexElem: + case *pg.Node_IndexElem: return convertIndexElem(&n) - case pg.IndexStmt: + case *pg.Node_IndexStmt: return convertIndexStmt(&n) - case pg.InferClause: + case *pg.Node_InferClause: return convertInferClause(&n) - case pg.InferenceElem: + case *pg.Node_InferenceElem: return convertInferenceElem(&n) - case pg.InlineCodeBlock: + case *pg.Node_InlineCodeBlock: return convertInlineCodeBlock(&n) - case pg.InsertStmt: + case *pg.Node_InsertStmt: return convertInsertStmt(&n) - case pg.Integer: + case *pg.Node_Integer: return convertInteger(&n) - case pg.IntoClause: + case *pg.Node_IntoClause: return convertIntoClause(&n) - case pg.JoinExpr: + case *pg.Node_JoinExpr: return convertJoinExpr(&n) - case pg.List: + case *pg.Node_List: return convertSlice(n) - case pg.ListenStmt: + case *pg.Node_ListenStmt: return convertSliceenStmt(&n) - case pg.LoadStmt: + case *pg.Node_LoadStmt: return convertLoadStmt(&n) - case pg.LockStmt: + case *pg.Node_LockStmt: return convertLockStmt(&n) - case pg.LockingClause: + case *pg.Node_LockingClause: return convertLockingClause(&n) - case pg.MinMaxExpr: + case *pg.Node_MinMaxExpr: return convertMinMaxExpr(&n) - case pg.MultiAssignRef: + case *pg.Node_MultiAssignRef: return convertMultiAssignRef(&n) - case pg.NamedArgExpr: + case *pg.Node_NamedArgExpr: return convertNamedArgExpr(&n) - case pg.NextValueExpr: + case *pg.Node_NextValueExpr: return convertNextValueExpr(&n) - case pg.NotifyStmt: + case *pg.Node_NotifyStmt: return convertNotifyStmt(&n) - case pg.Null: + case *pg.Node_Null: return convertNull(&n) - case pg.NullTest: + case *pg.Node_NullTest: return convertNullTest(&n) - case pg.ObjectWithArgs: + case *pg.Node_ObjectWithArgs: return convertObjectWithArgs(&n) - case pg.OnConflictClause: + case *pg.Node_OnConflictClause: return convertOnConflictClause(&n) - case pg.OnConflictExpr: + case *pg.Node_OnConflictExpr: return convertOnConflictExpr(&n) - case pg.OpExpr: + case *pg.Node_OpExpr: return convertOpExpr(&n) - case pg.Param: + case *pg.Node_Param: return convertParam(&n) - case pg.ParamExecData: + case *pg.Node_ParamExecData: return convertParamExecData(&n) - case pg.ParamExternData: + case *pg.Node_ParamExternData: return convertParamExternData(&n) - case pg.ParamListInfoData: + case *pg.Node_ParamListInfoData: return convertParamListInfoData(&n) - case pg.ParamRef: + case *pg.Node_ParamRef: return convertParamRef(&n) - case pg.PartitionBoundSpec: + case *pg.Node_PartitionBoundSpec: return convertPartitionBoundSpec(&n) - case pg.PartitionCmd: + case *pg.Node_PartitionCmd: return convertPartitionCmd(&n) - case pg.PartitionElem: + case *pg.Node_PartitionElem: return convertPartitionElem(&n) - case pg.PartitionRangeDatum: + case *pg.Node_PartitionRangeDatum: return convertPartitionRangeDatum(&n) - case pg.PartitionSpec: + case *pg.Node_PartitionSpec: return convertPartitionSpec(&n) - case pg.PrepareStmt: + case *pg.Node_PrepareStmt: return convertPrepareStmt(&n) - case pg.Query: + case *pg.Node_Query: return convertQuery(&n) - case pg.RangeFunction: + case *pg.Node_RangeFunction: return convertRangeFunction(&n) - case pg.RangeSubselect: + case *pg.Node_RangeSubselect: return convertRangeSubselect(&n) - case pg.RangeTableFunc: + case *pg.Node_RangeTableFunc: return convertRangeTableFunc(&n) - case pg.RangeTableFuncCol: + case *pg.Node_RangeTableFuncCol: return convertRangeTableFuncCol(&n) - case pg.RangeTableSample: + case *pg.Node_RangeTableSample: return convertRangeTableSample(&n) - case pg.RangeTblEntry: + case *pg.Node_RangeTblEntry: return convertRangeTblEntry(&n) - case pg.RangeTblFunction: + case *pg.Node_RangeTblFunction: return convertRangeTblFunction(&n) - case pg.RangeTblRef: + case *pg.Node_RangeTblRef: return convertRangeTblRef(&n) - case pg.RangeVar: + case *pg.Node_RangeVar: return convertRangeVar(&n) - case pg.RawStmt: + case *pg.Node_RawStmt: return convertRawStmt(&n) - case pg.ReassignOwnedStmt: + case *pg.Node_ReassignOwnedStmt: return convertReassignOwnedStmt(&n) - case pg.RefreshMatViewStmt: + case *pg.Node_RefreshMatViewStmt: return convertRefreshMatViewStmt(&n) - case pg.ReindexStmt: + case *pg.Node_ReindexStmt: return convertReindexStmt(&n) - case pg.RelabelType: + case *pg.Node_RelabelType: return convertRelabelType(&n) - case pg.RenameStmt: + case *pg.Node_RenameStmt: return convertRenameStmt(&n) - case pg.ReplicaIdentityStmt: + case *pg.Node_ReplicaIdentityStmt: return convertReplicaIdentityStmt(&n) - case pg.ResTarget: + case *pg.Node_ResTarget: return convertResTarget(&n) - case pg.RoleSpec: + case *pg.Node_RoleSpec: return convertRoleSpec(&n) - case pg.RowCompareExpr: + case *pg.Node_RowCompareExpr: return convertRowCompareExpr(&n) - case pg.RowExpr: + case *pg.Node_RowExpr: return convertRowExpr(&n) - case pg.RowMarkClause: + case *pg.Node_RowMarkClause: return convertRowMarkClause(&n) - case pg.RuleStmt: + case *pg.Node_RuleStmt: return convertRuleStmt(&n) - case pg.SQLValueFunction: + case *pg.Node_SQLValueFunction: return convertSQLValueFunction(&n) - case pg.ScalarArrayOpExpr: + case *pg.Node_ScalarArrayOpExpr: return convertScalarArrayOpExpr(&n) - case pg.SecLabelStmt: + case *pg.Node_SecLabelStmt: return convertSecLabelStmt(&n) - case pg.SelectStmt: + case *pg.Node_SelectStmt: return convertSelectStmt(&n) - case pg.SetOperationStmt: + case *pg.Node_SetOperationStmt: return convertSetOperationStmt(&n) - case pg.SetToDefault: + case *pg.Node_SetToDefault: return convertSetToDefault(&n) - case pg.SortBy: + case *pg.Node_SortBy: return convertSortBy(&n) - case pg.SortGroupClause: + case *pg.Node_SortGroupClause: return convertSortGroupClause(&n) - case pg.String: + case *pg.Node_String: return convertString(&n) - case pg.SubLink: + case *pg.Node_SubLink: return convertSubLink(&n) - case pg.SubPlan: + case *pg.Node_SubPlan: return convertSubPlan(&n) - case pg.TableFunc: + case *pg.Node_TableFunc: return convertTableFunc(&n) - case pg.TableLikeClause: + case *pg.Node_TableLikeClause: return convertTableLikeClause(&n) - case pg.TableSampleClause: + case *pg.Node_TableSampleClause: return convertTableSampleClause(&n) - case pg.TargetEntry: + case *pg.Node_TargetEntry: return convertTargetEntry(&n) - case pg.TransactionStmt: + case *pg.Node_TransactionStmt: return convertTransactionStmt(&n) - case pg.TriggerTransition: + case *pg.Node_TriggerTransition: return convertTriggerTransition(&n) - case pg.TruncateStmt: + case *pg.Node_TruncateStmt: return convertTruncateStmt(&n) - case pg.TypeCast: + case *pg.Node_TypeCast: return convertTypeCast(&n) - case pg.TypeName: + case *pg.Node_TypeName: return convertTypeName(&n) - case pg.UnlistenStmt: + case *pg.Node_UnlistenStmt: return convertUnlistenStmt(&n) - case pg.UpdateStmt: + case *pg.Node_UpdateStmt: return convertUpdateStmt(&n) - case pg.VacuumStmt: + case *pg.Node_VacuumStmt: return convertVacuumStmt(&n) - case pg.Var: + case *pg.Node_Var: return convertVar(&n) - case pg.VariableSetStmt: + case *pg.Node_VariableSetStmt: return convertVariableSetStmt(&n) - case pg.VariableShowStmt: + case *pg.Node_VariableShowStmt: return convertVariableShowStmt(&n) - case pg.ViewStmt: + case *pg.Node_ViewStmt: return convertViewStmt(&n) - case pg.WindowClause: + case *pg.Node_WindowClause: return convertWindowClause(&n) - case pg.WindowDef: + case *pg.Node_WindowDef: return convertWindowDef(&n) - case pg.WindowFunc: + case *pg.Node_WindowFunc: return convertWindowFunc(&n) - case pg.WithCheckOption: + case *pg.Node_WithCheckOption: return convertWithCheckOption(&n) - case pg.WithClause: + case *pg.Node_WithClause: return convertWithClause(&n) - case pg.XmlExpr: + case *pg.Node_XmlExpr: return convertXmlExpr(&n) - case pg.XmlSerialize: + case *pg.Node_XmlSerialize: return convertXmlSerialize(&n) default: diff --git a/internal/engine/postgresql/parse.go b/internal/engine/postgresql/parse.go index 686e6c31b9..a73ed5af78 100644 --- a/internal/engine/postgresql/parse.go +++ b/internal/engine/postgresql/parse.go @@ -25,9 +25,9 @@ func stringSlice(list nodes.List) []string { return items } -func stringSliceFromNodes(items []*nodes.Node) []string { - items := []string{} - for _, item := range items { +func stringSliceFromNodes(s []*nodes.Node) []string { + var items []string + for _, item := range s { if n, ok := item.Node.(nodes.Node_String); ok { items = append(items, n.String.Str) } From 50a716671e745be3dfc54ef2c1c59fb6139f443a Mon Sep 17 00:00:00 2001 From: Kyle Conroy Date: Thu, 18 Mar 2021 23:26:11 -0700 Subject: [PATCH 04/11] More type switch fixes --- internal/engine/postgresql/convert.go | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/internal/engine/postgresql/convert.go b/internal/engine/postgresql/convert.go index 5963a1ccc5..174b17ba3d 100644 --- a/internal/engine/postgresql/convert.go +++ b/internal/engine/postgresql/convert.go @@ -2912,40 +2912,40 @@ func convertNode(node *pg.Node) ast.Node { return convertAlterDomainStmt(n.AlterDomainStmt) case *pg.Node_AlterEnumStmt: - return convertAlterEnumStmt(&n) + return convertAlterEnumStmt(n.AlterEnumStmt) case *pg.Node_AlterEventTrigStmt: - return convertAlterEventTrigStmt(&n) + return convertAlterEventTrigStmt(n.AlterEventTrigStmt) case *pg.Node_AlterExtensionContentsStmt: - return convertAlterExtensionContentsStmt(&n) + return convertAlterExtensionContentsStmt(n.AlterExtensionContentsStmt) case *pg.Node_AlterExtensionStmt: - return convertAlterExtensionStmt(&n) + return convertAlterExtensionStmt(n.AlterExtensionStmt) case *pg.Node_AlterFdwStmt: - return convertAlterFdwStmt(&n) + return convertAlterFdwStmt(n.AlterFdwStmt) case *pg.Node_AlterForeignServerStmt: - return convertAlterForeignServerStmt(&n) + return convertAlterForeignServerStmt(n.AlterForeignServerStmt) case *pg.Node_AlterFunctionStmt: - return convertAlterFunctionStmt(&n) + return convertAlterFunctionStmt(n.AlterFunctionStmt) case *pg.Node_AlterObjectDependsStmt: - return convertAlterObjectDependsStmt(&n) + return convertAlterObjectDependsStmt(n.AlterObjectDependsStmt) case *pg.Node_AlterObjectSchemaStmt: - return convertAlterObjectSchemaStmt(&n) + return convertAlterObjectSchemaStmt(n.AlterObjectSchemaStmt) case *pg.Node_AlterOpFamilyStmt: - return convertAlterOpFamilyStmt(&n) + return convertAlterOpFamilyStmt(n.AlterOpFamilyStmt) case *pg.Node_AlterOperatorStmt: - return convertAlterOperatorStmt(&n) + return convertAlterOperatorStmt(n.AlterOperatorStmt) case *pg.Node_AlterOwnerStmt: - return convertAlterOwnerStmt(&n) + return convertAlterOwnerStmt(n.AlterOwnerStmt) case *pg.Node_AlterPolicyStmt: return convertAlterPolicyStmt(&n) From 9090764d67f29fd8dfa0daf72fc9044a7db2f2fe Mon Sep 17 00:00:00 2001 From: Kyle Conroy Date: Thu, 18 Mar 2021 23:33:24 -0700 Subject: [PATCH 05/11] making progress --- internal/engine/postgresql/convert.go | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/internal/engine/postgresql/convert.go b/internal/engine/postgresql/convert.go index 174b17ba3d..c60ca31abc 100644 --- a/internal/engine/postgresql/convert.go +++ b/internal/engine/postgresql/convert.go @@ -2948,37 +2948,37 @@ func convertNode(node *pg.Node) ast.Node { return convertAlterOwnerStmt(n.AlterOwnerStmt) case *pg.Node_AlterPolicyStmt: - return convertAlterPolicyStmt(&n) + return convertAlterPolicyStmt(n.AlterPolicyStmt) case *pg.Node_AlterPublicationStmt: - return convertAlterPublicationStmt(&n) + return convertAlterPublicationStmt(n.AlterPublicationStmt) case *pg.Node_AlterRoleSetStmt: - return convertAlterRoleSetStmt(&n) + return convertAlterRoleSetStmt(n.AlterRoleSetStmt) case *pg.Node_AlterRoleStmt: - return convertAlterRoleStmt(&n) + return convertAlterRoleStmt(n.AlterRoleStmt) case *pg.Node_AlterSeqStmt: - return convertAlterSeqStmt(&n) + return convertAlterSeqStmt(n.AlterSeqStmt) case *pg.Node_AlterSubscriptionStmt: - return convertAlterSubscriptionStmt(&n) + return convertAlterSubscriptionStmt(n.AlterSubscriptionStmt) case *pg.Node_AlterSystemStmt: - return convertAlterSystemStmt(&n) + return convertAlterSystemStmt(n.AlterSystemStmt) - case *pg.Node_AlterTSConfigurationStmt: - return convertAlterTSConfigurationStmt(&n) + case *pg.Node_AlterTsconfigurationStmt: + return convertAlterTSConfigurationStmt(n.AlterTsconfigurationStmt) - case *pg.Node_AlterTSDictionaryStmt: - return convertAlterTSDictionaryStmt(&n) + case *pg.Node_AlterTsdictionaryStmt: + return convertAlterTSDictionaryStmt(n.AlterTsdictionaryStmt) case *pg.Node_AlterTableCmd: - return convertAlterTableCmd(&n) + return convertAlterTableCmd(n.AlterTableCmd) case *pg.Node_AlterTableMoveAllStmt: - return convertAlterTableMoveAllStmt(&n) + return convertAlterTableMoveAllStmt(n.AlterTableMoveAllStmt) case *pg.Node_AlterTableSpaceOptionsStmt: return convertAlterTableSpaceOptionsStmt(&n) From f58addd77c94e24bfec2c089921e98baef31c7f4 Mon Sep 17 00:00:00 2001 From: Kyle Conroy Date: Fri, 19 Mar 2021 09:10:14 -0700 Subject: [PATCH 06/11] On to DDL stmts --- internal/engine/postgresql/convert.go | 383 +++++++++++++------------- internal/engine/postgresql/parse.go | 282 +++++++------------ 2 files changed, 286 insertions(+), 379 deletions(-) diff --git a/internal/engine/postgresql/convert.go b/internal/engine/postgresql/convert.go index c60ca31abc..6f83b67a02 100644 --- a/internal/engine/postgresql/convert.go +++ b/internal/engine/postgresql/convert.go @@ -8,7 +8,7 @@ import ( "github.com/kyleconroy/sqlc/internal/sql/ast" ) -func convertList(l pg.List) *ast.List { +func convertList(l *pg.List) *ast.List { out := &ast.List{} for _, item := range l.Items { out.Items = append(out.Items, convertNode(item)) @@ -1762,7 +1762,7 @@ func convertJoinExpr(n *pg.JoinExpr) *ast.JoinExpr { } } -func convertSliceenStmt(n *pg.ListenStmt) *ast.ListenStmt { +func convertListenStmt(n *pg.ListenStmt) *ast.ListenStmt { if n == nil { return nil } @@ -2981,556 +2981,547 @@ func convertNode(node *pg.Node) ast.Node { return convertAlterTableMoveAllStmt(n.AlterTableMoveAllStmt) case *pg.Node_AlterTableSpaceOptionsStmt: - return convertAlterTableSpaceOptionsStmt(&n) + return convertAlterTableSpaceOptionsStmt(n.AlterTableSpaceOptionsStmt) case *pg.Node_AlterTableStmt: - return convertAlterTableStmt(&n) + return convertAlterTableStmt(n.AlterTableStmt) case *pg.Node_AlterUserMappingStmt: - return convertAlterUserMappingStmt(&n) + return convertAlterUserMappingStmt(n.AlterUserMappingStmt) case *pg.Node_AlternativeSubPlan: - return convertAlternativeSubPlan(&n) + return convertAlternativeSubPlan(n.AlternativeSubPlan) case *pg.Node_ArrayCoerceExpr: - return convertArrayCoerceExpr(&n) + return convertArrayCoerceExpr(n.ArrayCoerceExpr) case *pg.Node_ArrayExpr: - return convertArrayExpr(&n) + return convertArrayExpr(n.ArrayExpr) case *pg.Node_BitString: - return convertBitString(&n) + return convertBitString(n.BitString) case *pg.Node_BoolExpr: - return convertBoolExpr(&n) + return convertBoolExpr(n.BoolExpr) case *pg.Node_BooleanTest: - return convertBooleanTest(&n) + return convertBooleanTest(n.BooleanTest) case *pg.Node_CaseExpr: - return convertCaseExpr(&n) + return convertCaseExpr(n.CaseExpr) case *pg.Node_CaseTestExpr: - return convertCaseTestExpr(&n) + return convertCaseTestExpr(n.CaseTestExpr) case *pg.Node_CaseWhen: - return convertCaseWhen(&n) + return convertCaseWhen(n.CaseWhen) case *pg.Node_CheckPointStmt: - return convertCheckPointStmt(&n) + return convertCheckPointStmt(n.CheckPointStmt) case *pg.Node_ClosePortalStmt: - return convertClosePortalStmt(&n) + return convertClosePortalStmt(n.ClosePortalStmt) case *pg.Node_ClusterStmt: - return convertClusterStmt(&n) + return convertClusterStmt(n.ClusterStmt) case *pg.Node_CoalesceExpr: - return convertCoalesceExpr(&n) + return convertCoalesceExpr(n.CoalesceExpr) case *pg.Node_CoerceToDomain: - return convertCoerceToDomain(&n) + return convertCoerceToDomain(n.CoerceToDomain) case *pg.Node_CoerceToDomainValue: - return convertCoerceToDomainValue(&n) + return convertCoerceToDomainValue(n.CoerceToDomainValue) - case *pg.Node_CoerceViaIO: - return convertCoerceViaIO(&n) + case *pg.Node_CoerceViaIo: + return convertCoerceViaIO(n.CoerceViaIo) case *pg.Node_CollateClause: - return convertCollateClause(&n) + return convertCollateClause(n.CollateClause) case *pg.Node_CollateExpr: - return convertCollateExpr(&n) + return convertCollateExpr(n.CollateExpr) case *pg.Node_ColumnDef: - return convertColumnDef(&n) + return convertColumnDef(n.ColumnDef) case *pg.Node_ColumnRef: - return convertColumnRef(&n) + return convertColumnRef(n.ColumnRef) case *pg.Node_CommentStmt: - return convertCommentStmt(&n) + return convertCommentStmt(n.CommentStmt) case *pg.Node_CommonTableExpr: - return convertCommonTableExpr(&n) + return convertCommonTableExpr(n.CommonTableExpr) case *pg.Node_CompositeTypeStmt: - return convertCompositeTypeStmt(&n) + return convertCompositeTypeStmt(n.CompositeTypeStmt) case *pg.Node_Constraint: - return convertConstraint(&n) + return convertConstraint(n.Constraint) case *pg.Node_ConstraintsSetStmt: - return convertConstraintsSetStmt(&n) + return convertConstraintsSetStmt(n.ConstraintsSetStmt) case *pg.Node_ConvertRowtypeExpr: - return convertConvertRowtypeExpr(&n) + return convertConvertRowtypeExpr(n.ConvertRowtypeExpr) case *pg.Node_CopyStmt: - return convertCopyStmt(&n) + return convertCopyStmt(n.CopyStmt) case *pg.Node_CreateAmStmt: - return convertCreateAmStmt(&n) + return convertCreateAmStmt(n.CreateAmStmt) case *pg.Node_CreateCastStmt: - return convertCreateCastStmt(&n) + return convertCreateCastStmt(n.CreateCastStmt) case *pg.Node_CreateConversionStmt: - return convertCreateConversionStmt(&n) + return convertCreateConversionStmt(n.CreateConversionStmt) case *pg.Node_CreateDomainStmt: - return convertCreateDomainStmt(&n) + return convertCreateDomainStmt(n.CreateDomainStmt) case *pg.Node_CreateEnumStmt: - return convertCreateEnumStmt(&n) + return convertCreateEnumStmt(n.CreateEnumStmt) case *pg.Node_CreateEventTrigStmt: - return convertCreateEventTrigStmt(&n) + return convertCreateEventTrigStmt(n.CreateEventTrigStmt) case *pg.Node_CreateExtensionStmt: - return convertCreateExtensionStmt(&n) + return convertCreateExtensionStmt(n.CreateExtensionStmt) case *pg.Node_CreateFdwStmt: - return convertCreateFdwStmt(&n) + return convertCreateFdwStmt(n.CreateFdwStmt) case *pg.Node_CreateForeignServerStmt: - return convertCreateForeignServerStmt(&n) + return convertCreateForeignServerStmt(n.CreateForeignServerStmt) case *pg.Node_CreateForeignTableStmt: - return convertCreateForeignTableStmt(&n) + return convertCreateForeignTableStmt(n.CreateForeignTableStmt) case *pg.Node_CreateFunctionStmt: - return convertCreateFunctionStmt(&n) + return convertCreateFunctionStmt(n.CreateFunctionStmt) case *pg.Node_CreateOpClassItem: - return convertCreateOpClassItem(&n) + return convertCreateOpClassItem(n.CreateOpClassItem) case *pg.Node_CreateOpClassStmt: - return convertCreateOpClassStmt(&n) + return convertCreateOpClassStmt(n.CreateOpClassStmt) case *pg.Node_CreateOpFamilyStmt: - return convertCreateOpFamilyStmt(&n) + return convertCreateOpFamilyStmt(n.CreateOpFamilyStmt) - case *pg.Node_CreatePLangStmt: - return convertCreatePLangStmt(&n) + case *pg.Node_CreatePlangStmt: + return convertCreatePLangStmt(n.CreatePlangStmt) case *pg.Node_CreatePolicyStmt: - return convertCreatePolicyStmt(&n) + return convertCreatePolicyStmt(n.CreatePolicyStmt) case *pg.Node_CreatePublicationStmt: - return convertCreatePublicationStmt(&n) + return convertCreatePublicationStmt(n.CreatePublicationStmt) case *pg.Node_CreateRangeStmt: - return convertCreateRangeStmt(&n) + return convertCreateRangeStmt(n.CreateRangeStmt) case *pg.Node_CreateRoleStmt: - return convertCreateRoleStmt(&n) + return convertCreateRoleStmt(n.CreateRoleStmt) case *pg.Node_CreateSchemaStmt: - return convertCreateSchemaStmt(&n) + return convertCreateSchemaStmt(n.CreateSchemaStmt) case *pg.Node_CreateSeqStmt: - return convertCreateSeqStmt(&n) + return convertCreateSeqStmt(n.CreateSeqStmt) case *pg.Node_CreateStatsStmt: - return convertCreateStatsStmt(&n) + return convertCreateStatsStmt(n.CreateStatsStmt) case *pg.Node_CreateStmt: - return convertCreateStmt(&n) + return convertCreateStmt(n.CreateStmt) case *pg.Node_CreateSubscriptionStmt: - return convertCreateSubscriptionStmt(&n) + return convertCreateSubscriptionStmt(n.CreateSubscriptionStmt) case *pg.Node_CreateTableAsStmt: - return convertCreateTableAsStmt(&n) + return convertCreateTableAsStmt(n.CreateTableAsStmt) case *pg.Node_CreateTableSpaceStmt: - return convertCreateTableSpaceStmt(&n) + return convertCreateTableSpaceStmt(n.CreateTableSpaceStmt) case *pg.Node_CreateTransformStmt: - return convertCreateTransformStmt(&n) + return convertCreateTransformStmt(n.CreateTransformStmt) case *pg.Node_CreateTrigStmt: - return convertCreateTrigStmt(&n) + return convertCreateTrigStmt(n.CreateTrigStmt) case *pg.Node_CreateUserMappingStmt: - return convertCreateUserMappingStmt(&n) + return convertCreateUserMappingStmt(n.CreateUserMappingStmt) case *pg.Node_CreatedbStmt: - return convertCreatedbStmt(&n) + return convertCreatedbStmt(n.CreatedbStmt) case *pg.Node_CurrentOfExpr: - return convertCurrentOfExpr(&n) + return convertCurrentOfExpr(n.CurrentOfExpr) case *pg.Node_DeallocateStmt: - return convertDeallocateStmt(&n) + return convertDeallocateStmt(n.DeallocateStmt) case *pg.Node_DeclareCursorStmt: - return convertDeclareCursorStmt(&n) + return convertDeclareCursorStmt(n.DeclareCursorStmt) case *pg.Node_DefElem: - return convertDefElem(&n) + return convertDefElem(n.DefElem) case *pg.Node_DefineStmt: - return convertDefineStmt(&n) + return convertDefineStmt(n.DefineStmt) case *pg.Node_DeleteStmt: - return convertDeleteStmt(&n) + return convertDeleteStmt(n.DeleteStmt) case *pg.Node_DiscardStmt: - return convertDiscardStmt(&n) + return convertDiscardStmt(n.DiscardStmt) case *pg.Node_DoStmt: - return convertDoStmt(&n) + return convertDoStmt(n.DoStmt) case *pg.Node_DropOwnedStmt: - return convertDropOwnedStmt(&n) + return convertDropOwnedStmt(n.DropOwnedStmt) case *pg.Node_DropRoleStmt: - return convertDropRoleStmt(&n) + return convertDropRoleStmt(n.DropRoleStmt) case *pg.Node_DropStmt: - return convertDropStmt(&n) + return convertDropStmt(n.DropStmt) case *pg.Node_DropSubscriptionStmt: - return convertDropSubscriptionStmt(&n) + return convertDropSubscriptionStmt(n.DropSubscriptionStmt) case *pg.Node_DropTableSpaceStmt: - return convertDropTableSpaceStmt(&n) + return convertDropTableSpaceStmt(n.DropTableSpaceStmt) case *pg.Node_DropUserMappingStmt: - return convertDropUserMappingStmt(&n) + return convertDropUserMappingStmt(n.DropUserMappingStmt) case *pg.Node_DropdbStmt: - return convertDropdbStmt(&n) + return convertDropdbStmt(n.DropdbStmt) case *pg.Node_ExecuteStmt: - return convertExecuteStmt(&n) + return convertExecuteStmt(n.ExecuteStmt) case *pg.Node_ExplainStmt: - return convertExplainStmt(&n) + return convertExplainStmt(n.ExplainStmt) case *pg.Node_Expr: - return convertExpr(&n) + return convertExpr(n.Expr) case *pg.Node_FetchStmt: - return convertFetchStmt(&n) + return convertFetchStmt(n.FetchStmt) case *pg.Node_FieldSelect: - return convertFieldSelect(&n) + return convertFieldSelect(n.FieldSelect) case *pg.Node_FieldStore: - return convertFieldStore(&n) + return convertFieldStore(n.FieldStore) case *pg.Node_Float: - return convertFloat(&n) + return convertFloat(n.Float) case *pg.Node_FromExpr: - return convertFromExpr(&n) + return convertFromExpr(n.FromExpr) case *pg.Node_FuncCall: - return convertFuncCall(&n) + return convertFuncCall(n.FuncCall) case *pg.Node_FuncExpr: - return convertFuncExpr(&n) + return convertFuncExpr(n.FuncExpr) case *pg.Node_FunctionParameter: - return convertFunctionParameter(&n) + return convertFunctionParameter(n.FunctionParameter) case *pg.Node_GrantRoleStmt: - return convertGrantRoleStmt(&n) + return convertGrantRoleStmt(n.GrantRoleStmt) case *pg.Node_GrantStmt: - return convertGrantStmt(&n) + return convertGrantStmt(n.GrantStmt) case *pg.Node_GroupingFunc: - return convertGroupingFunc(&n) + return convertGroupingFunc(n.GroupingFunc) case *pg.Node_GroupingSet: - return convertGroupingSet(&n) + return convertGroupingSet(n.GroupingSet) case *pg.Node_ImportForeignSchemaStmt: - return convertImportForeignSchemaStmt(&n) + return convertImportForeignSchemaStmt(n.ImportForeignSchemaStmt) case *pg.Node_IndexElem: - return convertIndexElem(&n) + return convertIndexElem(n.IndexElem) case *pg.Node_IndexStmt: - return convertIndexStmt(&n) + return convertIndexStmt(n.IndexStmt) case *pg.Node_InferClause: - return convertInferClause(&n) + return convertInferClause(n.InferClause) case *pg.Node_InferenceElem: - return convertInferenceElem(&n) + return convertInferenceElem(n.InferenceElem) case *pg.Node_InlineCodeBlock: - return convertInlineCodeBlock(&n) + return convertInlineCodeBlock(n.InlineCodeBlock) case *pg.Node_InsertStmt: - return convertInsertStmt(&n) + return convertInsertStmt(n.InsertStmt) case *pg.Node_Integer: - return convertInteger(&n) + return convertInteger(n.Integer) case *pg.Node_IntoClause: - return convertIntoClause(&n) + return convertIntoClause(n.IntoClause) case *pg.Node_JoinExpr: - return convertJoinExpr(&n) + return convertJoinExpr(n.JoinExpr) case *pg.Node_List: - return convertSlice(n) + return convertList(n.List) case *pg.Node_ListenStmt: - return convertSliceenStmt(&n) + return convertListenStmt(n.ListenStmt) case *pg.Node_LoadStmt: - return convertLoadStmt(&n) + return convertLoadStmt(n.LoadStmt) case *pg.Node_LockStmt: - return convertLockStmt(&n) + return convertLockStmt(n.LockStmt) case *pg.Node_LockingClause: - return convertLockingClause(&n) + return convertLockingClause(n.LockingClause) case *pg.Node_MinMaxExpr: - return convertMinMaxExpr(&n) + return convertMinMaxExpr(n.MinMaxExpr) case *pg.Node_MultiAssignRef: - return convertMultiAssignRef(&n) + return convertMultiAssignRef(n.MultiAssignRef) case *pg.Node_NamedArgExpr: - return convertNamedArgExpr(&n) + return convertNamedArgExpr(n.NamedArgExpr) case *pg.Node_NextValueExpr: - return convertNextValueExpr(&n) + return convertNextValueExpr(n.NextValueExpr) case *pg.Node_NotifyStmt: - return convertNotifyStmt(&n) + return convertNotifyStmt(n.NotifyStmt) case *pg.Node_Null: - return convertNull(&n) + return convertNull(n.Null) case *pg.Node_NullTest: - return convertNullTest(&n) + return convertNullTest(n.NullTest) case *pg.Node_ObjectWithArgs: - return convertObjectWithArgs(&n) + return convertObjectWithArgs(n.ObjectWithArgs) case *pg.Node_OnConflictClause: - return convertOnConflictClause(&n) + return convertOnConflictClause(n.OnConflictClause) case *pg.Node_OnConflictExpr: - return convertOnConflictExpr(&n) + return convertOnConflictExpr(n.OnConflictExpr) case *pg.Node_OpExpr: - return convertOpExpr(&n) + return convertOpExpr(n.OpExpr) case *pg.Node_Param: - return convertParam(&n) - - case *pg.Node_ParamExecData: - return convertParamExecData(&n) - - case *pg.Node_ParamExternData: - return convertParamExternData(&n) - - case *pg.Node_ParamListInfoData: - return convertParamListInfoData(&n) + return convertParam(n.Param) case *pg.Node_ParamRef: - return convertParamRef(&n) + return convertParamRef(n.ParamRef) case *pg.Node_PartitionBoundSpec: - return convertPartitionBoundSpec(&n) + return convertPartitionBoundSpec(n.PartitionBoundSpec) case *pg.Node_PartitionCmd: - return convertPartitionCmd(&n) + return convertPartitionCmd(n.PartitionCmd) case *pg.Node_PartitionElem: - return convertPartitionElem(&n) + return convertPartitionElem(n.PartitionElem) case *pg.Node_PartitionRangeDatum: - return convertPartitionRangeDatum(&n) + return convertPartitionRangeDatum(n.PartitionRangeDatum) case *pg.Node_PartitionSpec: - return convertPartitionSpec(&n) + return convertPartitionSpec(n.PartitionSpec) case *pg.Node_PrepareStmt: - return convertPrepareStmt(&n) + return convertPrepareStmt(n.PrepareStmt) case *pg.Node_Query: - return convertQuery(&n) + return convertQuery(n.Query) case *pg.Node_RangeFunction: - return convertRangeFunction(&n) + return convertRangeFunction(n.RangeFunction) case *pg.Node_RangeSubselect: - return convertRangeSubselect(&n) + return convertRangeSubselect(n.RangeSubselect) case *pg.Node_RangeTableFunc: - return convertRangeTableFunc(&n) + return convertRangeTableFunc(n.RangeTableFunc) case *pg.Node_RangeTableFuncCol: - return convertRangeTableFuncCol(&n) + return convertRangeTableFuncCol(n.RangeTableFuncCol) case *pg.Node_RangeTableSample: - return convertRangeTableSample(&n) + return convertRangeTableSample(n.RangeTableSample) case *pg.Node_RangeTblEntry: - return convertRangeTblEntry(&n) + return convertRangeTblEntry(n.RangeTblEntry) case *pg.Node_RangeTblFunction: - return convertRangeTblFunction(&n) + return convertRangeTblFunction(n.RangeTblFunction) case *pg.Node_RangeTblRef: - return convertRangeTblRef(&n) + return convertRangeTblRef(n.RangeTblRef) case *pg.Node_RangeVar: - return convertRangeVar(&n) + return convertRangeVar(n.RangeVar) case *pg.Node_RawStmt: - return convertRawStmt(&n) + return convertRawStmt(n.RawStmt) case *pg.Node_ReassignOwnedStmt: - return convertReassignOwnedStmt(&n) + return convertReassignOwnedStmt(n.ReassignOwnedStmt) case *pg.Node_RefreshMatViewStmt: - return convertRefreshMatViewStmt(&n) + return convertRefreshMatViewStmt(n.RefreshMatViewStmt) case *pg.Node_ReindexStmt: - return convertReindexStmt(&n) + return convertReindexStmt(n.ReindexStmt) case *pg.Node_RelabelType: - return convertRelabelType(&n) + return convertRelabelType(n.RelabelType) case *pg.Node_RenameStmt: - return convertRenameStmt(&n) + return convertRenameStmt(n.RenameStmt) case *pg.Node_ReplicaIdentityStmt: - return convertReplicaIdentityStmt(&n) + return convertReplicaIdentityStmt(n.ReplicaIdentityStmt) case *pg.Node_ResTarget: - return convertResTarget(&n) + return convertResTarget(n.ResTarget) case *pg.Node_RoleSpec: - return convertRoleSpec(&n) + return convertRoleSpec(n.RoleSpec) case *pg.Node_RowCompareExpr: - return convertRowCompareExpr(&n) + return convertRowCompareExpr(n.RowCompareExpr) case *pg.Node_RowExpr: - return convertRowExpr(&n) + return convertRowExpr(n.RowExpr) case *pg.Node_RowMarkClause: - return convertRowMarkClause(&n) + return convertRowMarkClause(n.RowMarkClause) case *pg.Node_RuleStmt: - return convertRuleStmt(&n) + return convertRuleStmt(n.RuleStmt) - case *pg.Node_SQLValueFunction: - return convertSQLValueFunction(&n) + case *pg.Node_SqlvalueFunction: + return convertSQLValueFunction(n.SqlvalueFunction) case *pg.Node_ScalarArrayOpExpr: - return convertScalarArrayOpExpr(&n) + return convertScalarArrayOpExpr(n.ScalarArrayOpExpr) case *pg.Node_SecLabelStmt: - return convertSecLabelStmt(&n) + return convertSecLabelStmt(n.SecLabelStmt) case *pg.Node_SelectStmt: - return convertSelectStmt(&n) + return convertSelectStmt(n.SelectStmt) case *pg.Node_SetOperationStmt: - return convertSetOperationStmt(&n) + return convertSetOperationStmt(n.SetOperationStmt) case *pg.Node_SetToDefault: - return convertSetToDefault(&n) + return convertSetToDefault(n.SetToDefault) case *pg.Node_SortBy: - return convertSortBy(&n) + return convertSortBy(n.SortBy) case *pg.Node_SortGroupClause: - return convertSortGroupClause(&n) + return convertSortGroupClause(n.SortGroupClause) - case *pg.Node_String: - return convertString(&n) + case *pg.Node_String_: + return convertString(n.String_) case *pg.Node_SubLink: - return convertSubLink(&n) + return convertSubLink(n.SubLink) case *pg.Node_SubPlan: - return convertSubPlan(&n) + return convertSubPlan(n.SubPlan) case *pg.Node_TableFunc: - return convertTableFunc(&n) + return convertTableFunc(n.TableFunc) case *pg.Node_TableLikeClause: - return convertTableLikeClause(&n) + return convertTableLikeClause(n.TableLikeClause) case *pg.Node_TableSampleClause: - return convertTableSampleClause(&n) + return convertTableSampleClause(n.TableSampleClause) case *pg.Node_TargetEntry: - return convertTargetEntry(&n) + return convertTargetEntry(n.TargetEntry) case *pg.Node_TransactionStmt: - return convertTransactionStmt(&n) + return convertTransactionStmt(n.TransactionStmt) case *pg.Node_TriggerTransition: - return convertTriggerTransition(&n) + return convertTriggerTransition(n.TriggerTransition) case *pg.Node_TruncateStmt: - return convertTruncateStmt(&n) + return convertTruncateStmt(n.TruncateStmt) case *pg.Node_TypeCast: - return convertTypeCast(&n) + return convertTypeCast(n.TypeCast) case *pg.Node_TypeName: - return convertTypeName(&n) + return convertTypeName(n.TypeName) case *pg.Node_UnlistenStmt: - return convertUnlistenStmt(&n) + return convertUnlistenStmt(n.UnlistenStmt) case *pg.Node_UpdateStmt: - return convertUpdateStmt(&n) + return convertUpdateStmt(n.UpdateStmt) case *pg.Node_VacuumStmt: - return convertVacuumStmt(&n) + return convertVacuumStmt(n.VacuumStmt) case *pg.Node_Var: - return convertVar(&n) + return convertVar(n.Var) case *pg.Node_VariableSetStmt: - return convertVariableSetStmt(&n) + return convertVariableSetStmt(n.VariableSetStmt) case *pg.Node_VariableShowStmt: - return convertVariableShowStmt(&n) + return convertVariableShowStmt(n.VariableShowStmt) case *pg.Node_ViewStmt: - return convertViewStmt(&n) + return convertViewStmt(n.ViewStmt) case *pg.Node_WindowClause: - return convertWindowClause(&n) + return convertWindowClause(n.WindowClause) case *pg.Node_WindowDef: - return convertWindowDef(&n) + return convertWindowDef(n.WindowDef) case *pg.Node_WindowFunc: - return convertWindowFunc(&n) + return convertWindowFunc(n.WindowFunc) case *pg.Node_WithCheckOption: - return convertWithCheckOption(&n) + return convertWithCheckOption(n.WithCheckOption) case *pg.Node_WithClause: - return convertWithClause(&n) + return convertWithClause(n.WithClause) case *pg.Node_XmlExpr: - return convertXmlExpr(&n) + return convertXmlExpr(n.XmlExpr) case *pg.Node_XmlSerialize: - return convertXmlSerialize(&n) + return convertXmlSerialize(n.XmlSerialize) default: return &ast.TODO{} diff --git a/internal/engine/postgresql/parse.go b/internal/engine/postgresql/parse.go index a73ed5af78..9a15cbc76b 100644 --- a/internal/engine/postgresql/parse.go +++ b/internal/engine/postgresql/parse.go @@ -15,11 +15,11 @@ import ( "github.com/kyleconroy/sqlc/internal/sql/ast" ) -func stringSlice(list nodes.List) []string { +func stringSlice(list *nodes.List) []string { items := []string{} for _, item := range list.Items { - if n, ok := item.(nodes.String); ok { - items = append(items, n.Str) + if n, ok := item.Node.(*nodes.Node_String_); ok { + items = append(items, n.String_.Str) } } return items @@ -28,8 +28,8 @@ func stringSlice(list nodes.List) []string { func stringSliceFromNodes(s []*nodes.Node) []string { var items []string for _, item := range s { - if n, ok := item.Node.(nodes.Node_String); ok { - items = append(items, n.String.Str) + if n, ok := item.Node.(*nodes.Node_String_); ok { + items = append(items, n.String_.Str) } } return items @@ -41,6 +41,14 @@ type relation struct { Name string } +func (r relation) TableName() *ast.TableName { + return &ast.TableName{ + Catalog: r.Catalog, + Schema: r.Schema, + Name: r.Name, + } +} + func (r relation) TypeName() *ast.TypeName { return &ast.TypeName{ Catalog: r.Catalog, @@ -51,22 +59,10 @@ func (r relation) TypeName() *ast.TypeName { func (r relation) FuncName() *ast.FuncName { return &ast.FuncName{ - Catalog: rel.Catalog, - Schema: rel.Schema, - Name: rel.Name, - } -} - -func parseFuncName(node nodes.Node) (*ast.FuncName, error) { - rel, err := parseRelation(node) - if err != nil { - return nil, fmt.Errorf("parse func name: %w", err) + Catalog: r.Catalog, + Schema: r.Schema, + Name: r.Name, } - return &ast.FuncName{ - Catalog: rel.Catalog, - Schema: rel.Schema, - Name: rel.Name, - }, nil } func parseFuncParamMode(m nodes.FunctionParameterMode) (ast.FuncParamMode, error) { @@ -86,32 +82,8 @@ func parseFuncParamMode(m nodes.FunctionParameterMode) (ast.FuncParamMode, error } } -func parseTypeName(node nodes.Node) (*ast.TypeName, error) { - rel, err := parseRelation(node) - if err != nil { - return nil, fmt.Errorf("parse type name: %w", err) - } - return &ast.TypeName{ - Catalog: rel.Catalog, - Schema: rel.Schema, - Name: rel.Name, - }, nil -} - -func parseTableName(node nodes.Node) (*ast.TableName, error) { - rel, err := parseRelation(node) - if err != nil { - return nil, fmt.Errorf("parse table name: %w", err) - } - return &ast.TableName{ - Catalog: rel.Catalog, - Schema: rel.Schema, - Name: rel.Name, - }, nil -} - func parseRelationFromNodes(list []*nodes.Node) (*relation, error) { - parts := stringSliceFromNodes(n) + parts := stringSliceFromNodes(list) switch len(parts) { case 1: return &relation{ @@ -129,84 +101,22 @@ func parseRelationFromNodes(list []*nodes.Node) (*relation, error) { Name: parts[2], }, nil default: - return nil, fmt.Errorf("invalid name: %s", join(n, ".")) + return nil, fmt.Errorf("invalid name: %s", joinNodes(list, ".")) } } func parseRelationFromRangeVar(rv *nodes.RangeVar) *relation { - return *relation{ - Catalog: n.Catalogname, - Schema: *n.Schemaname, - Name: *n.Relname, - } -} - -func parseRelation(node nodes.Node) (*relation, error) { - switch n := node.(type) { - - case nodes.List: - parts := stringSlice(n) - switch len(parts) { - case 1: - return &relation{ - Name: parts[0], - }, nil - case 2: - return &relation{ - Schema: parts[0], - Name: parts[1], - }, nil - case 3: - return &relation{ - Catalog: parts[0], - Schema: parts[1], - Name: parts[2], - }, nil - default: - return nil, fmt.Errorf("invalid name: %s", join(n, ".")) - } - - case nodes.RangeVar: - name := relation{} - if n.Catalogname != nil { - name.Catalog = *n.Catalogname - } - if n.Schemaname != nil { - name.Schema = *n.Schemaname - } - if n.Relname != nil { - name.Name = *n.Relname - } - return &name, nil - - case *nodes.RangeVar: - name := relation{} - if n.Catalogname != nil { - name.Catalog = *n.Catalogname - } - if n.Schemaname != nil { - name.Schema = *n.Schemaname - } - if n.Relname != nil { - name.Name = *n.Relname - } - return &name, nil - - case nodes.TypeName: - return parseRelation(n.Names) - - case *nodes.TypeName: - return parseRelation(n.Names) - - default: - return nil, fmt.Errorf("unexpected node type: %T", n) + return &relation{ + Catalog: rv.Catalogname, + Schema: rv.Schemaname, + Name: rv.Relname, } } -func parseColName(node nodes.Node) (*ast.ColumnRef, *ast.TableName, error) { - switch n := node.(type) { - case nodes.List: - parts := stringSlice(n) +func parseColName(node *nodes.Node) (*ast.ColumnRef, *ast.TableName, error) { + switch n := node.Node.(type) { + case *nodes.Node_List: + parts := stringSlice(n.List) var tbl *ast.TableName var ref *ast.ColumnRef switch len(parts) { @@ -228,10 +138,14 @@ func parseColName(node nodes.Node) (*ast.ColumnRef, *ast.TableName, error) { } } -func join(list nodes.List, sep string) string { +func join(list *nodes.List, sep string) string { return strings.Join(stringSlice(list), sep) } +func joinNodes(list []*nodes.Node, sep string) string { + return strings.Join(stringSliceFromNodes(list), sep) +} + func NewParser() *Parser { return &Parser{} } @@ -252,11 +166,7 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) { } var stmts []ast.Statement - for _, stmt := range tree.Statements { - raw, ok := stmt.(nodes.RawStmt) - if !ok { - return nil, fmt.Errorf("expected RawStmt; got %T", stmt) - } + for _, raw := range tree.Stmts { n, err := translate(raw.Stmt) if err == errSkip { continue @@ -270,8 +180,8 @@ func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) { stmts = append(stmts, ast.Statement{ Raw: &ast.RawStmt{ Stmt: n, - StmtLocation: raw.StmtLocation, - StmtLen: raw.StmtLen, + StmtLocation: int(raw.StmtLocation), + StmtLen: int(raw.StmtLen), }, }) } @@ -286,101 +196,99 @@ func (p *Parser) CommentSyntax() metadata.CommentSyntax { } } -func translate(node nodes.Node) (ast.Node, error) { - switch n := node.(type) { +func translate(node *nodes.Node) (ast.Node, error) { + switch inner := node.Node.(type) { - case nodes.AlterEnumStmt: - name, err := parseTypeName(n.TypeName) + case *nodes.Node_AlterEnumStmt: + n := inner.AlterEnumStmt + rel, err := parseRelationFromNodes(n.TypeName) if err != nil { return nil, err } - if n.OldVal != nil { + if n.OldVal != "" { return &ast.AlterTypeRenameValueStmt{ - Type: name, - OldValue: n.OldVal, - NewValue: n.NewVal, + Type: rel.TypeName(), + OldValue: &n.OldVal, + NewValue: &n.NewVal, }, nil } else { return &ast.AlterTypeAddValueStmt{ - Type: name, - NewValue: n.NewVal, + Type: rel.TypeName(), + NewValue: &n.NewVal, SkipIfNewValExists: n.SkipIfNewValExists, }, nil } - case nodes.AlterObjectSchemaStmt: + case *nodes.Node_AlterObjectSchemaStmt: + n := inner.AlterObjectSchemaStmt switch n.ObjectType { - case nodes.OBJECT_TABLE: - tbl, err := parseTableName(*n.Relation) - if err != nil { - return nil, err - } + case nodes.ObjectType_OBJECT_TABLE: + rel := parseRelationFromRangeVar(n.Relation) return &ast.AlterTableSetSchemaStmt{ - Table: tbl, - NewSchema: n.Newschema, + Table: rel.TableName(), + NewSchema: &n.Newschema, }, nil } return nil, errSkip - case nodes.AlterTableStmt: - name, err := parseTableName(*n.Relation) - if err != nil { - return nil, err - } + case *nodes.Node_AlterTableStmt: + n := inner.AlterTableStmt + rel := parseRelationFromRangeVar(n.Relation) at := &ast.AlterTableStmt{ - Table: name, + Table: rel.TableName(), Cmds: &ast.List{}, } - for _, cmd := range n.Cmds.Items { - switch cmd := cmd.(type) { - case nodes.AlterTableCmd: - item := &ast.AlterTableCmd{Name: cmd.Name, MissingOk: cmd.MissingOk} - - switch cmd.Subtype { - case nodes.AT_AddColumn: - d := cmd.Def.(nodes.ColumnDef) - tn, err := parseTypeName(d.TypeName) + for _, cmd := range n.Cmds { + switch cmdOneOf := cmd.Node.(type) { + case *nodes.Node_AlterTableCmd: + altercmd := cmdOneOf.AlterTableCmd + item := &ast.AlterTableCmd{Name: &altercmd.Name, MissingOk: altercmd.MissingOk} + + switch altercmd.Subtype { + case nodes.AlterTableType_AT_AddColumn: + d := altercmd.Def.(nodes.ColumnDef) + rel, err := parseRelationFromNodes(d.TypeName) if err != nil { return nil, err } item.Subtype = ast.AT_AddColumn item.Def = &ast.ColumnDef{ Colname: *d.Colname, - TypeName: tn, + TypeName: rel.TypeName(), IsNotNull: isNotNull(d), IsArray: isArray(d.TypeName), } - case nodes.AT_AlterColumnType: - d := cmd.Def.(nodes.ColumnDef) + case nodes.AlterTableType_AT_AlterColumnType: + d := altercmd.Def.(nodes.ColumnDef) col := "" if cmd.Name != nil { - col = *cmd.Name + col = *altercmd.Name } else if d.Colname != nil { col = *d.Colname } else { return nil, fmt.Errorf("unknown name for alter column type") } - tn, err := parseTypeName(d.TypeName) + rel, err := parseRelationFromNodes(d.TypeName) if err != nil { return nil, err } item.Subtype = ast.AT_AlterColumnType item.Def = &ast.ColumnDef{ Colname: col, - TypeName: tn, + TypeName: rel.TypeName(), IsNotNull: isNotNull(d), IsArray: isArray(d.TypeName), } - case nodes.AT_DropColumn: + case nodes.AlterTableType_AT_DropColumn: item.Subtype = ast.AT_DropColumn - case nodes.AT_DropNotNull: + case nodes.AlterTableType_AT_DropNotNull: item.Subtype = ast.AT_DropNotNull - case nodes.AT_SetNotNull: + case nodes.AlterTableType_AT_SetNotNull: item.Subtype = ast.AT_SetNotNull default: @@ -392,10 +300,11 @@ func translate(node nodes.Node) (ast.Node, error) { } return at, nil - case nodes.CommentStmt: + case *nodes.Node_CommentStmt: + n := inner.CommentStmt switch n.Objtype { - case nodes.OBJECT_COLUMN: + case nodes.ObjectType_OBJECT_COLUMN: col, tbl, err := parseColName(n.Object) if err != nil { return nil, fmt.Errorf("COMMENT ON COLUMN: %w", err) @@ -406,7 +315,7 @@ func translate(node nodes.Node) (ast.Node, error) { Comment: n.Comment, }, nil - case nodes.OBJECT_SCHEMA: + case nodes.ObjectType_OBJECT_SCHEMA: o, ok := n.Object.(nodes.String) if !ok { return nil, fmt.Errorf("COMMENT ON SCHEMA: unexpected node type: %T", n.Object) @@ -416,7 +325,7 @@ func translate(node nodes.Node) (ast.Node, error) { Comment: n.Comment, }, nil - case nodes.OBJECT_TABLE: + case nodes.ObjectType_OBJECT_TABLE: name, err := parseTableName(n.Object) if err != nil { return nil, fmt.Errorf("COMMENT ON TABLE: %w", err) @@ -426,7 +335,7 @@ func translate(node nodes.Node) (ast.Node, error) { Comment: n.Comment, }, nil - case nodes.OBJECT_TYPE: + case nodes.ObjectType_OBJECT_TYPE: name, err := parseTypeName(n.Object) if err != nil { return nil, err @@ -439,7 +348,8 @@ func translate(node nodes.Node) (ast.Node, error) { } return nil, errSkip - case nodes.CompositeTypeStmt: + case *nodes.Node_CompositeTypeStmt: + n := inner.CompositeTypeStmt name, err := parseTypeName(n.Typevar) if err != nil { return nil, err @@ -448,7 +358,8 @@ func translate(node nodes.Node) (ast.Node, error) { TypeName: name, }, nil - case nodes.CreateStmt: + case *nodes.Node_CreateStmt: + n := inner.CreateStmt name, err := parseTableName(*n.Relation) if err != nil { return nil, err @@ -485,7 +396,8 @@ func translate(node nodes.Node) (ast.Node, error) { } return create, nil - case nodes.CreateEnumStmt: + case *nodes.Node_CreateEnumStmt: + n := inner.CreateEnumStmt name, err := parseTypeName(n.TypeName) if err != nil { return nil, err @@ -504,7 +416,8 @@ func translate(node nodes.Node) (ast.Node, error) { } return stmt, nil - case nodes.CreateFunctionStmt: + case *nodes.Node_CreateFunctionStmt: + n := inner.CreateFunctionStmt fn, err := parseFuncName(n.Funcname) if err != nil { return nil, err @@ -541,13 +454,15 @@ func translate(node nodes.Node) (ast.Node, error) { } return stmt, nil - case nodes.CreateSchemaStmt: + case *nodes.Node_CreateSchemaStmt: + n := inner.CreateSchemaStmt return &ast.CreateSchemaStmt{ Name: n.Schemaname, IfNotExists: n.IfNotExists, }, nil - case nodes.DropStmt: + case *nodes.Node_DropStmt: + n := inner.DropStmt switch n.RemoveType { case nodes.OBJECT_FUNCTION: @@ -583,7 +498,7 @@ func translate(node nodes.Node) (ast.Node, error) { } return drop, nil - case nodes.OBJECT_SCHEMA: + case nodes.ObjectType_OBJECT_SCHEMA: drop := &ast.DropSchemaStmt{ MissingOk: n.MissingOk, } @@ -596,7 +511,7 @@ func translate(node nodes.Node) (ast.Node, error) { } return drop, nil - case nodes.OBJECT_TABLE: + case nodes.ObjectType_OBJECT_TABLE: drop := &ast.DropTableStmt{ IfExists: n.MissingOk, } @@ -609,7 +524,7 @@ func translate(node nodes.Node) (ast.Node, error) { } return drop, nil - case nodes.OBJECT_TYPE: + case nodes.ObjectType_OBJECT_TYPE: drop := &ast.DropTypeStmt{ IfExists: n.MissingOk, } @@ -625,10 +540,11 @@ func translate(node nodes.Node) (ast.Node, error) { } return nil, errSkip - case nodes.RenameStmt: + case *nodes.Node_RenameStmt: + n := inner.RenameStmt switch n.RenameType { - case nodes.OBJECT_COLUMN: + case nodes.ObjectType_OBJECT_COLUMN: tbl, err := parseTableName(*n.Relation) if err != nil { return nil, fmt.Errorf("nodes.RenameType: COLUMN: %w", err) @@ -639,7 +555,7 @@ func translate(node nodes.Node) (ast.Node, error) { NewName: n.Newname, }, nil - case nodes.OBJECT_TABLE: + case nodes.ObjectType_OBJECT_TABLE: tbl, err := parseTableName(*n.Relation) if err != nil { return nil, fmt.Errorf("nodes.RenameType: TABLE: %w", err) From 0176f8a0fd5c5ba36646befe7f6eed01f83651ad Mon Sep 17 00:00:00 2001 From: Kyle Conroy Date: Fri, 19 Mar 2021 09:36:33 -0700 Subject: [PATCH 07/11] Making more progress --- internal/engine/postgresql/parse.go | 166 +++++++++++++++------------- internal/engine/postgresql/utils.go | 2 +- 2 files changed, 91 insertions(+), 77 deletions(-) diff --git a/internal/engine/postgresql/parse.go b/internal/engine/postgresql/parse.go index 9a15cbc76b..26a5bf6b2d 100644 --- a/internal/engine/postgresql/parse.go +++ b/internal/engine/postgresql/parse.go @@ -113,6 +113,17 @@ func parseRelationFromRangeVar(rv *nodes.RangeVar) *relation { } } +func parseRelation(in *nodes.Node) (*relation, error) { + switch n := in.Node.(type) { + case *nodes.Node_RangeVar: + return parseRelationFromRangeVar(n.RangeVar), nil + case *nodes.Node_List: + return parseRelationFromNodes(n.List.Items) + default: + return nil, fmt.Errorf("unexpected node type: %T", n) + } +} + func parseColName(node *nodes.Node) (*ast.ColumnRef, *ast.TableName, error) { switch n := node.Node.(type) { case *nodes.Node_List: @@ -247,30 +258,37 @@ func translate(node *nodes.Node) (ast.Node, error) { switch altercmd.Subtype { case nodes.AlterTableType_AT_AddColumn: - d := altercmd.Def.(nodes.ColumnDef) - rel, err := parseRelationFromNodes(d.TypeName) + d, ok := altercmd.Def.Node.(*nodes.Node_ColumnDef) + if !ok { + return nil, fmt.Errorf("expected alter table defintion to be a ColumnDef") + } + + rel, err := parseRelationFromNodes(d.ColumnDef.TypeName.Names) if err != nil { return nil, err } item.Subtype = ast.AT_AddColumn item.Def = &ast.ColumnDef{ - Colname: *d.Colname, + Colname: d.ColumnDef.Colname, TypeName: rel.TypeName(), - IsNotNull: isNotNull(d), - IsArray: isArray(d.TypeName), + IsNotNull: isNotNull(d.ColumnDef), + IsArray: isArray(d.ColumnDef.TypeName), } case nodes.AlterTableType_AT_AlterColumnType: - d := altercmd.Def.(nodes.ColumnDef) + d, ok := altercmd.Def.Node.(*nodes.Node_ColumnDef) + if !ok { + return nil, fmt.Errorf("expected alter table defintion to be a ColumnDef") + } col := "" - if cmd.Name != nil { - col = *altercmd.Name - } else if d.Colname != nil { - col = *d.Colname + if altercmd.Name != "" { + col = altercmd.Name + } else if d.ColumnDef.Colname != "" { + col = d.ColumnDef.Colname } else { return nil, fmt.Errorf("unknown name for alter column type") } - rel, err := parseRelationFromNodes(d.TypeName) + rel, err := parseRelationFromNodes(d.ColumnDef.TypeName.Names) if err != nil { return nil, err } @@ -278,8 +296,8 @@ func translate(node *nodes.Node) (ast.Node, error) { item.Def = &ast.ColumnDef{ Colname: col, TypeName: rel.TypeName(), - IsNotNull: isNotNull(d), - IsArray: isArray(d.TypeName), + IsNotNull: isNotNull(d.ColumnDef), + IsArray: isArray(d.ColumnDef.TypeName), } case nodes.AlterTableType_AT_DropColumn: @@ -312,37 +330,37 @@ func translate(node *nodes.Node) (ast.Node, error) { return &ast.CommentOnColumnStmt{ Col: col, Table: tbl, - Comment: n.Comment, + Comment: &n.Comment, }, nil case nodes.ObjectType_OBJECT_SCHEMA: - o, ok := n.Object.(nodes.String) + o, ok := n.Object.Node.(*nodes.Node_String_) if !ok { return nil, fmt.Errorf("COMMENT ON SCHEMA: unexpected node type: %T", n.Object) } return &ast.CommentOnSchemaStmt{ - Schema: &ast.String{Str: o.Str}, - Comment: n.Comment, + Schema: &ast.String{Str: o.String_.Str}, + Comment: &n.Comment, }, nil case nodes.ObjectType_OBJECT_TABLE: - name, err := parseTableName(n.Object) + rel, err := parseRelation(n.Object) if err != nil { return nil, fmt.Errorf("COMMENT ON TABLE: %w", err) } return &ast.CommentOnTableStmt{ - Table: name, - Comment: n.Comment, + Table: rel.TableName(), + Comment: &n.Comment, }, nil case nodes.ObjectType_OBJECT_TYPE: - name, err := parseTypeName(n.Object) + rel, err := parseRelation(n.Object) if err != nil { return nil, err } return &ast.CommentOnTypeStmt{ - Type: name, - Comment: n.Comment, + Type: rel.TypeName(), + Comment: &n.Comment, }, nil } @@ -350,47 +368,42 @@ func translate(node *nodes.Node) (ast.Node, error) { case *nodes.Node_CompositeTypeStmt: n := inner.CompositeTypeStmt - name, err := parseTypeName(n.Typevar) - if err != nil { - return nil, err - } + rel := parseRelationFromRangeVar(n.Typevar) return &ast.CompositeTypeStmt{ - TypeName: name, + TypeName: rel.TypeName(), }, nil case *nodes.Node_CreateStmt: n := inner.CreateStmt - name, err := parseTableName(*n.Relation) - if err != nil { - return nil, err - } + rel := parseRelationFromRangeVar(n.Relation) create := &ast.CreateTableStmt{ - Name: name, + Name: rel.TableName(), IfNotExists: n.IfNotExists, } primaryKey := make(map[string]bool) - for _, elt := range n.TableElts.Items { - switch n := elt.(type) { - case nodes.Constraint: - if n.Contype == nodes.CONSTR_PRIMARY { - for _, item := range n.Keys.Items { - primaryKey[item.(nodes.String).Str] = true + for _, elt := range n.TableElts { + switch item := elt.Node.(type) { + case *nodes.Node_Constraint: + if item.Constraint.Contype == nodes.ConstrType_CONSTR_PRIMARY { + for _, key := range item.Constraint.Keys { + // FIXME: Possible nil pointer dereference + primaryKey[key.Node.(*nodes.Node_String_).String_.Str] = true } } } } - for _, elt := range n.TableElts.Items { - switch n := elt.(type) { - case nodes.ColumnDef: - tn, err := parseTypeName(n.TypeName) + for _, elt := range n.TableElts { + switch item := elt.Node.(type) { + case *nodes.Node_ColumnDef: + rel, err := parseRelationFromNodes(item.ColumnDef.TypeName.Names) if err != nil { return nil, err } create.Cols = append(create.Cols, &ast.ColumnDef{ - Colname: *n.Colname, - TypeName: tn, - IsNotNull: isNotNull(n) || primaryKey[*n.Colname], - IsArray: isArray(n.TypeName), + Colname: item.ColumnDef.Colname, + TypeName: rel.TypeName(), + IsNotNull: isNotNull(item.ColumnDef) || primaryKey[item.ColumnDef.Colname], + IsArray: isArray(item.ColumnDef.TypeName), }) } } @@ -398,19 +411,19 @@ func translate(node *nodes.Node) (ast.Node, error) { case *nodes.Node_CreateEnumStmt: n := inner.CreateEnumStmt - name, err := parseTypeName(n.TypeName) + rel, err := parseRelationFromNodes(n.TypeName) if err != nil { return nil, err } stmt := &ast.CreateEnumStmt{ - TypeName: name, + TypeName: rel.TypeName(), Vals: &ast.List{}, } - for _, val := range n.Vals.Items { - switch v := val.(type) { - case nodes.String: + for _, val := range n.Vals { + switch v := val.Node.(type) { + case *nodes.Node_String_: stmt.Vals.Items = append(stmt.Vals.Items, &ast.String{ - Str: v.Str, + Str: v.String_.Str, }) } } @@ -418,23 +431,23 @@ func translate(node *nodes.Node) (ast.Node, error) { case *nodes.Node_CreateFunctionStmt: n := inner.CreateFunctionStmt - fn, err := parseFuncName(n.Funcname) + fn, err := parseRelationFromNodes(n.Funcname) if err != nil { return nil, err } - rt, err := parseTypeName(n.ReturnType) + rt, err := parseRelationFromNodes(n.ReturnType.Names) if err != nil { return nil, err } stmt := &ast.CreateFunctionStmt{ - Func: fn, - ReturnType: rt, + Func: fn.FuncName(), + ReturnType: rt.TypeName(), Replace: n.Replace, Params: &ast.List{}, } - for _, item := range n.Parameters.Items { - arg := item.(nodes.FunctionParameter) - tn, err := parseTypeName(arg.ArgType) + for _, item := range n.Parameters { + arg := item.Node.(*nodes.Node_FunctionParameter).FunctionParameter + rel, err := parseRelationFromNodes(arg.ArgType.Names) if err != nil { return nil, err } @@ -443,8 +456,8 @@ func translate(node *nodes.Node) (ast.Node, error) { return nil, err } fp := &ast.FuncParam{ - Name: arg.Name, - Type: tn, + Name: &arg.Name, + Type: rel.TypeName(), Mode: mode, } if arg.Defexpr != nil { @@ -457,7 +470,7 @@ func translate(node *nodes.Node) (ast.Node, error) { case *nodes.Node_CreateSchemaStmt: n := inner.CreateSchemaStmt return &ast.CreateSchemaStmt{ - Name: n.Schemaname, + Name: &n.Schemaname, IfNotExists: n.IfNotExists, }, nil @@ -465,33 +478,34 @@ func translate(node *nodes.Node) (ast.Node, error) { n := inner.DropStmt switch n.RemoveType { - case nodes.OBJECT_FUNCTION: + case nodes.ObjectType_OBJECT_FUNCTION: drop := &ast.DropFunctionStmt{ MissingOk: n.MissingOk, } - for _, obj := range n.Objects.Items { - owa, ok := obj.(nodes.ObjectWithArgs) + for _, obj := range n.Objects { + nowa, ok := obj.Node.(*nodes.Node_ObjectWithArgs) if !ok { return nil, fmt.Errorf("nodes.DropStmt: FUNCTION: unknown type in objects list: %T", obj) } - fn, err := parseFuncName(owa.Objname) + owa := nowa.ObjectWithArgs + fn, err := parseRelationFromNodes(owa.Objname) if err != nil { return nil, fmt.Errorf("nodes.DropStmt: FUNCTION: %w", err) } - args := make([]*ast.TypeName, len(owa.Objargs.Items)) - for i, objarg := range owa.Objargs.Items { - tn, ok := objarg.(nodes.TypeName) + args := make([]*ast.TypeName, len(owa.Objargs)) + for i, objarg := range owa.Objargs { + tn, ok := objarg.Node.(*nodes.Node_TypeName) if !ok { return nil, fmt.Errorf("nodes.DropStmt: FUNCTION: unknown type in objargs list: %T", objarg) } - at, err := parseTypeName(tn) + at, err := parseRelationFromNodes(tn.TypeName.Names) if err != nil { return nil, fmt.Errorf("nodes.DropStmt: FUNCTION: %w", err) } - args[i] = at + args[i] = at.TypeName() } drop.Funcs = append(drop.Funcs, &ast.FuncSpec{ - Name: fn, + Name: fn.FuncName(), Args: args, HasArgs: !owa.ArgsUnspecified, }) @@ -502,12 +516,12 @@ func translate(node *nodes.Node) (ast.Node, error) { drop := &ast.DropSchemaStmt{ MissingOk: n.MissingOk, } - for _, obj := range n.Objects.Items { - val, ok := obj.(nodes.String) + for _, obj := range n.Objects { + val, ok := obj.Node.(*nodes.Node_String_) if !ok { return nil, fmt.Errorf("nodes.DropStmt: SCHEMA: unknown type in objects list: %T", obj) } - drop.Schemas = append(drop.Schemas, &ast.String{Str: val.Str}) + drop.Schemas = append(drop.Schemas, &ast.String{Str: val.String_.Str}) } return drop, nil diff --git a/internal/engine/postgresql/utils.go b/internal/engine/postgresql/utils.go index d9d43cc1ed..978f71a60c 100644 --- a/internal/engine/postgresql/utils.go +++ b/internal/engine/postgresql/utils.go @@ -13,7 +13,7 @@ func isArray(n *nodes.TypeName) bool { return len(n.ArrayBounds.Items) > 0 } -func isNotNull(n nodes.ColumnDef) bool { +func isNotNull(n *nodes.ColumnDef) bool { if n.IsNotNull { return true } From 4de104ec1f4e67c57f45690a1bedd2b77116183b Mon Sep 17 00:00:00 2001 From: Kyle Conroy Date: Fri, 19 Mar 2021 09:57:41 -0700 Subject: [PATCH 08/11] compiling, tests now fail --- internal/engine/postgresql/convert.go | 4 +++ internal/engine/postgresql/parse.go | 40 ++++++++++++--------------- internal/engine/postgresql/utils.go | 26 ++++++++--------- 3 files changed, 35 insertions(+), 35 deletions(-) diff --git a/internal/engine/postgresql/convert.go b/internal/engine/postgresql/convert.go index 6f83b67a02..4dbd53204a 100644 --- a/internal/engine/postgresql/convert.go +++ b/internal/engine/postgresql/convert.go @@ -2867,6 +2867,10 @@ func convertXmlSerialize(n *pg.XmlSerialize) *ast.XmlSerialize { } func convertNode(node *pg.Node) ast.Node { + if node == nil || node.Node == nil { + return &ast.TODO{} + } + switch n := node.Node.(type) { case *pg.Node_AArrayExpr: diff --git a/internal/engine/postgresql/parse.go b/internal/engine/postgresql/parse.go index 26a5bf6b2d..2e3863d491 100644 --- a/internal/engine/postgresql/parse.go +++ b/internal/engine/postgresql/parse.go @@ -115,10 +115,12 @@ func parseRelationFromRangeVar(rv *nodes.RangeVar) *relation { func parseRelation(in *nodes.Node) (*relation, error) { switch n := in.Node.(type) { - case *nodes.Node_RangeVar: - return parseRelationFromRangeVar(n.RangeVar), nil case *nodes.Node_List: return parseRelationFromNodes(n.List.Items) + case *nodes.Node_RangeVar: + return parseRelationFromRangeVar(n.RangeVar), nil + case *nodes.Node_TypeName: + return parseRelationFromNodes(n.TypeName.Names) default: return nil, fmt.Errorf("unexpected node type: %T", n) } @@ -529,12 +531,12 @@ func translate(node *nodes.Node) (ast.Node, error) { drop := &ast.DropTableStmt{ IfExists: n.MissingOk, } - for _, obj := range n.Objects.Items { - name, err := parseTableName(obj) + for _, obj := range n.Objects { + name, err := parseRelation(obj) if err != nil { return nil, fmt.Errorf("nodes.DropStmt: TABLE: %w", err) } - drop.Tables = append(drop.Tables, name) + drop.Tables = append(drop.Tables, name.TableName()) } return drop, nil @@ -542,12 +544,12 @@ func translate(node *nodes.Node) (ast.Node, error) { drop := &ast.DropTypeStmt{ IfExists: n.MissingOk, } - for _, obj := range n.Objects.Items { - name, err := parseTypeName(obj) + for _, obj := range n.Objects { + name, err := parseRelation(obj) if err != nil { return nil, fmt.Errorf("nodes.DropStmt: TYPE: %w", err) } - drop.Types = append(drop.Types, name) + drop.Types = append(drop.Types, name.TypeName()) } return drop, nil @@ -559,30 +561,24 @@ func translate(node *nodes.Node) (ast.Node, error) { switch n.RenameType { case nodes.ObjectType_OBJECT_COLUMN: - tbl, err := parseTableName(*n.Relation) - if err != nil { - return nil, fmt.Errorf("nodes.RenameType: COLUMN: %w", err) - } + rel := parseRelationFromRangeVar(n.Relation) return &ast.RenameColumnStmt{ - Table: tbl, - Col: &ast.ColumnRef{Name: *n.Subname}, - NewName: n.Newname, + Table: rel.TableName(), + Col: &ast.ColumnRef{Name: n.Subname}, + NewName: &n.Newname, }, nil case nodes.ObjectType_OBJECT_TABLE: - tbl, err := parseTableName(*n.Relation) - if err != nil { - return nil, fmt.Errorf("nodes.RenameType: TABLE: %w", err) - } + rel := parseRelationFromRangeVar(n.Relation) return &ast.RenameTableStmt{ - Table: tbl, - NewName: n.Newname, + Table: rel.TableName(), + NewName: &n.Newname, }, nil } return nil, errSkip default: - return convert(n) + return convert(node) } } diff --git a/internal/engine/postgresql/utils.go b/internal/engine/postgresql/utils.go index 978f71a60c..2e4f22fcfd 100644 --- a/internal/engine/postgresql/utils.go +++ b/internal/engine/postgresql/utils.go @@ -10,20 +10,20 @@ func isArray(n *nodes.TypeName) bool { if n == nil { return false } - return len(n.ArrayBounds.Items) > 0 + return len(n.ArrayBounds) > 0 } func isNotNull(n *nodes.ColumnDef) bool { if n.IsNotNull { return true } - for _, c := range n.Constraints.Items { - switch n := c.(type) { - case nodes.Constraint: - if n.Contype == nodes.CONSTR_NOTNULL { + for _, c := range n.Constraints { + switch inner := c.Node.(type) { + case *nodes.Node_Constraint: + if inner.Constraint.Contype == nodes.ConstrType_CONSTR_NOTNULL { return true } - if n.Contype == nodes.CONSTR_PRIMARY { + if inner.Constraint.Contype == nodes.ConstrType_CONSTR_PRIMARY { return true } } @@ -31,14 +31,14 @@ func isNotNull(n *nodes.ColumnDef) bool { return false } -func IsNamedParamFunc(node nodes.Node) bool { - fun, ok := node.(nodes.FuncCall) - return ok && join(fun.Funcname, ".") == "sqlc.arg" +func IsNamedParamFunc(node *nodes.Node) bool { + fun, ok := node.Node.(*nodes.Node_FuncCall) + return ok && joinNodes(fun.FuncCall.Funcname, ".") == "sqlc.arg" } -func IsNamedParamSign(node nodes.Node) bool { - expr, ok := node.(nodes.A_Expr) - return ok && join(expr.Name, ".") == "@" +func IsNamedParamSign(node *nodes.Node) bool { + expr, ok := node.Node.(*nodes.Node_AExpr) + return ok && joinNodes(expr.AExpr.Name, ".") == "@" } func makeByte(s string) byte { @@ -50,7 +50,7 @@ func makeByte(s string) byte { } func makeUint32Slice(in []uint64) []uint32 { - out := make([]uint32, len(v)) + out := make([]uint32, len(in)) for i, v := range in { out[i] = uint32(v) } From 02205fd7a7170e4df0a00146178f440e47f17d49 Mon Sep 17 00:00:00 2001 From: Kyle Conroy Date: Fri, 19 Mar 2021 10:04:33 -0700 Subject: [PATCH 09/11] last fix --- internal/engine/postgresql/parse.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/internal/engine/postgresql/parse.go b/internal/engine/postgresql/parse.go index 2e3863d491..13d0e6272e 100644 --- a/internal/engine/postgresql/parse.go +++ b/internal/engine/postgresql/parse.go @@ -67,15 +67,15 @@ func (r relation) FuncName() *ast.FuncName { func parseFuncParamMode(m nodes.FunctionParameterMode) (ast.FuncParamMode, error) { switch m { - case 'i': + case nodes.FunctionParameterMode_FUNC_PARAM_IN: return ast.FuncParamIn, nil - case 'o': + case nodes.FunctionParameterMode_FUNC_PARAM_OUT: return ast.FuncParamOut, nil - case 'b': + case nodes.FunctionParameterMode_FUNC_PARAM_INOUT: return ast.FuncParamInOut, nil - case 'v': + case nodes.FunctionParameterMode_FUNC_PARAM_VARIADIC: return ast.FuncParamVariadic, nil - case 't': + case nodes.FunctionParameterMode_FUNC_PARAM_TABLE: return ast.FuncParamTable, nil default: return -1, fmt.Errorf("parse func param: invalid mode %v", m) From ab8b449e1fd4e4f53edf5f212d4f2cb4313d9fcd Mon Sep 17 00:00:00 2001 From: Kyle Conroy Date: Fri, 19 Mar 2021 10:45:43 -0700 Subject: [PATCH 10/11] Turn empty strings into nil pointers --- internal/engine/postgresql/convert.go | 252 +++++++++++++------------- internal/engine/postgresql/parse.go | 22 +-- internal/engine/postgresql/utils.go | 7 + 3 files changed, 144 insertions(+), 137 deletions(-) diff --git a/internal/engine/postgresql/convert.go b/internal/engine/postgresql/convert.go index 4dbd53204a..42d33ef29b 100644 --- a/internal/engine/postgresql/convert.go +++ b/internal/engine/postgresql/convert.go @@ -106,7 +106,7 @@ func convertAccessPriv(n *pg.AccessPriv) *ast.AccessPriv { return nil } return &ast.AccessPriv{ - PrivName: &n.PrivName, + PrivName: makeString(n.PrivName), Cols: convertSlice(n.Cols), } } @@ -142,7 +142,7 @@ func convertAlias(n *pg.Alias) *ast.Alias { return nil } return &ast.Alias{ - Aliasname: &n.Aliasname, + Aliasname: makeString(n.Aliasname), Colnames: convertSlice(n.Colnames), } } @@ -161,7 +161,7 @@ func convertAlterDatabaseSetStmt(n *pg.AlterDatabaseSetStmt) *ast.AlterDatabaseS return nil } return &ast.AlterDatabaseSetStmt{ - Dbname: &n.Dbname, + Dbname: makeString(n.Dbname), Setstmt: convertVariableSetStmt(n.Setstmt), } } @@ -171,7 +171,7 @@ func convertAlterDatabaseStmt(n *pg.AlterDatabaseStmt) *ast.AlterDatabaseStmt { return nil } return &ast.AlterDatabaseStmt{ - Dbname: &n.Dbname, + Dbname: makeString(n.Dbname), Options: convertSlice(n.Options), } } @@ -193,7 +193,7 @@ func convertAlterDomainStmt(n *pg.AlterDomainStmt) *ast.AlterDomainStmt { return &ast.AlterDomainStmt{ Subtype: makeByte(n.Subtype), TypeName: convertSlice(n.TypeName), - Name: &n.Name, + Name: makeString(n.Name), Def: convertNode(n.Def), Behavior: ast.DropBehavior(n.Behavior), MissingOk: n.MissingOk, @@ -206,9 +206,9 @@ func convertAlterEnumStmt(n *pg.AlterEnumStmt) *ast.AlterEnumStmt { } return &ast.AlterEnumStmt{ TypeName: convertSlice(n.TypeName), - OldVal: &n.OldVal, - NewVal: &n.NewVal, - NewValNeighbor: &n.NewValNeighbor, + OldVal: makeString(n.OldVal), + NewVal: makeString(n.NewVal), + NewValNeighbor: makeString(n.NewValNeighbor), NewValIsAfter: n.NewValIsAfter, SkipIfNewValExists: n.SkipIfNewValExists, } @@ -219,7 +219,7 @@ func convertAlterEventTrigStmt(n *pg.AlterEventTrigStmt) *ast.AlterEventTrigStmt return nil } return &ast.AlterEventTrigStmt{ - Trigname: &n.Trigname, + Trigname: makeString(n.Trigname), Tgenabled: makeByte(n.Tgenabled), } } @@ -229,7 +229,7 @@ func convertAlterExtensionContentsStmt(n *pg.AlterExtensionContentsStmt) *ast.Al return nil } return &ast.AlterExtensionContentsStmt{ - Extname: &n.Extname, + Extname: makeString(n.Extname), Action: int(n.Action), Objtype: ast.ObjectType(n.Objtype), Object: convertNode(n.Object), @@ -241,7 +241,7 @@ func convertAlterExtensionStmt(n *pg.AlterExtensionStmt) *ast.AlterExtensionStmt return nil } return &ast.AlterExtensionStmt{ - Extname: &n.Extname, + Extname: makeString(n.Extname), Options: convertSlice(n.Options), } } @@ -251,7 +251,7 @@ func convertAlterFdwStmt(n *pg.AlterFdwStmt) *ast.AlterFdwStmt { return nil } return &ast.AlterFdwStmt{ - Fdwname: &n.Fdwname, + Fdwname: makeString(n.Fdwname), FuncOptions: convertSlice(n.FuncOptions), Options: convertSlice(n.Options), } @@ -262,8 +262,8 @@ func convertAlterForeignServerStmt(n *pg.AlterForeignServerStmt) *ast.AlterForei return nil } return &ast.AlterForeignServerStmt{ - Servername: &n.Servername, - Version: &n.Version, + Servername: makeString(n.Servername), + Version: makeString(n.Version), Options: convertSlice(n.Options), HasVersion: n.HasVersion, } @@ -299,7 +299,7 @@ func convertAlterObjectSchemaStmt(n *pg.AlterObjectSchemaStmt) *ast.AlterObjectS ObjectType: ast.ObjectType(n.ObjectType), Relation: convertRangeVar(n.Relation), Object: convertNode(n.Object), - Newschema: &n.Newschema, + Newschema: makeString(n.Newschema), MissingOk: n.MissingOk, } } @@ -310,7 +310,7 @@ func convertAlterOpFamilyStmt(n *pg.AlterOpFamilyStmt) *ast.AlterOpFamilyStmt { } return &ast.AlterOpFamilyStmt{ Opfamilyname: convertSlice(n.Opfamilyname), - Amname: &n.Amname, + Amname: makeString(n.Amname), IsDrop: n.IsDrop, Items: convertSlice(n.Items), } @@ -343,7 +343,7 @@ func convertAlterPolicyStmt(n *pg.AlterPolicyStmt) *ast.AlterPolicyStmt { return nil } return &ast.AlterPolicyStmt{ - PolicyName: &n.PolicyName, + PolicyName: makeString(n.PolicyName), Table: convertRangeVar(n.Table), Roles: convertSlice(n.Roles), Qual: convertNode(n.Qual), @@ -356,7 +356,7 @@ func convertAlterPublicationStmt(n *pg.AlterPublicationStmt) *ast.AlterPublicati return nil } return &ast.AlterPublicationStmt{ - Pubname: &n.Pubname, + Pubname: makeString(n.Pubname), Options: convertSlice(n.Options), Tables: convertSlice(n.Tables), ForAllTables: n.ForAllTables, @@ -370,7 +370,7 @@ func convertAlterRoleSetStmt(n *pg.AlterRoleSetStmt) *ast.AlterRoleSetStmt { } return &ast.AlterRoleSetStmt{ Role: convertRoleSpec(n.Role), - Database: &n.Database, + Database: makeString(n.Database), Setstmt: convertVariableSetStmt(n.Setstmt), } } @@ -404,8 +404,8 @@ func convertAlterSubscriptionStmt(n *pg.AlterSubscriptionStmt) *ast.AlterSubscri } return &ast.AlterSubscriptionStmt{ Kind: ast.AlterSubscriptionType(n.Kind), - Subname: &n.Subname, - Conninfo: &n.Conninfo, + Subname: makeString(n.Subname), + Conninfo: makeString(n.Conninfo), Publication: convertSlice(n.Publication), Options: convertSlice(n.Options), } @@ -453,7 +453,7 @@ func convertAlterTableCmd(n *pg.AlterTableCmd) *ast.AlterTableCmd { columnDef := def.(*ast.ColumnDef) return &ast.AlterTableCmd{ Subtype: ast.AlterTableType(n.Subtype), - Name: &n.Name, + Name: makeString(n.Name), Newowner: convertRoleSpec(n.Newowner), Def: columnDef, Behavior: ast.DropBehavior(n.Behavior), @@ -466,10 +466,10 @@ func convertAlterTableMoveAllStmt(n *pg.AlterTableMoveAllStmt) *ast.AlterTableMo return nil } return &ast.AlterTableMoveAllStmt{ - OrigTablespacename: &n.OrigTablespacename, + OrigTablespacename: makeString(n.OrigTablespacename), Objtype: ast.ObjectType(n.Objtype), Roles: convertSlice(n.Roles), - NewTablespacename: &n.NewTablespacename, + NewTablespacename: makeString(n.NewTablespacename), Nowait: n.Nowait, } } @@ -479,7 +479,7 @@ func convertAlterTableSpaceOptionsStmt(n *pg.AlterTableSpaceOptionsStmt) *ast.Al return nil } return &ast.AlterTableSpaceOptionsStmt{ - Tablespacename: &n.Tablespacename, + Tablespacename: makeString(n.Tablespacename), Options: convertSlice(n.Options), IsReset: n.IsReset, } @@ -503,7 +503,7 @@ func convertAlterUserMappingStmt(n *pg.AlterUserMappingStmt) *ast.AlterUserMappi } return &ast.AlterUserMappingStmt{ User: convertRoleSpec(n.User), - Servername: &n.Servername, + Servername: makeString(n.Servername), Options: convertSlice(n.Options), } } @@ -632,7 +632,7 @@ func convertClosePortalStmt(n *pg.ClosePortalStmt) *ast.ClosePortalStmt { return nil } return &ast.ClosePortalStmt{ - Portalname: &n.Portalname, + Portalname: makeString(n.Portalname), } } @@ -642,7 +642,7 @@ func convertClusterStmt(n *pg.ClusterStmt) *ast.ClusterStmt { } return &ast.ClusterStmt{ Relation: convertRangeVar(n.Relation), - Indexname: &n.Indexname, + Indexname: makeString(n.Indexname), } } @@ -764,7 +764,7 @@ func convertCommentStmt(n *pg.CommentStmt) *ast.CommentStmt { return &ast.CommentStmt{ Objtype: ast.ObjectType(n.Objtype), Object: convertNode(n.Object), - Comment: &n.Comment, + Comment: makeString(n.Comment), } } @@ -773,7 +773,7 @@ func convertCommonTableExpr(n *pg.CommonTableExpr) *ast.CommonTableExpr { return nil } return &ast.CommonTableExpr{ - Ctename: &n.Ctename, + Ctename: makeString(n.Ctename), Aliascolnames: convertSlice(n.Aliascolnames), Ctequery: convertNode(n.Ctequery), Location: int(n.Location), @@ -802,20 +802,20 @@ func convertConstraint(n *pg.Constraint) *ast.Constraint { } return &ast.Constraint{ Contype: ast.ConstrType(n.Contype), - Conname: &n.Conname, + Conname: makeString(n.Conname), Deferrable: n.Deferrable, Initdeferred: n.Initdeferred, Location: int(n.Location), IsNoInherit: n.IsNoInherit, RawExpr: convertNode(n.RawExpr), - CookedExpr: &n.CookedExpr, + CookedExpr: makeString(n.CookedExpr), GeneratedWhen: makeByte(n.GeneratedWhen), Keys: convertSlice(n.Keys), Exclusions: convertSlice(n.Exclusions), Options: convertSlice(n.Options), - Indexname: &n.Indexname, - Indexspace: &n.Indexspace, - AccessMethod: &n.AccessMethod, + Indexname: makeString(n.Indexname), + Indexspace: makeString(n.Indexspace), + AccessMethod: makeString(n.AccessMethod), WhereClause: convertNode(n.WhereClause), Pktable: convertRangeVar(n.Pktable), FkAttrs: convertSlice(n.FkAttrs), @@ -863,7 +863,7 @@ func convertCopyStmt(n *pg.CopyStmt) *ast.CopyStmt { Attlist: convertSlice(n.Attlist), IsFrom: n.IsFrom, IsProgram: n.IsProgram, - Filename: &n.Filename, + Filename: makeString(n.Filename), Options: convertSlice(n.Options), } } @@ -873,7 +873,7 @@ func convertCreateAmStmt(n *pg.CreateAmStmt) *ast.CreateAmStmt { return nil } return &ast.CreateAmStmt{ - Amname: &n.Amname, + Amname: makeString(n.Amname), HandlerName: convertSlice(n.HandlerName), Amtype: makeByte(n.Amtype), } @@ -898,8 +898,8 @@ func convertCreateConversionStmt(n *pg.CreateConversionStmt) *ast.CreateConversi } return &ast.CreateConversionStmt{ ConversionName: convertSlice(n.ConversionName), - ForEncodingName: &n.ForEncodingName, - ToEncodingName: &n.ToEncodingName, + ForEncodingName: makeString(n.ForEncodingName), + ToEncodingName: makeString(n.ToEncodingName), FuncName: convertSlice(n.FuncName), Def: n.Def, } @@ -936,8 +936,8 @@ func convertCreateEventTrigStmt(n *pg.CreateEventTrigStmt) *ast.CreateEventTrigS return nil } return &ast.CreateEventTrigStmt{ - Trigname: &n.Trigname, - Eventname: &n.Eventname, + Trigname: makeString(n.Trigname), + Eventname: makeString(n.Eventname), Whenclause: convertSlice(n.Whenclause), Funcname: convertSlice(n.Funcname), } @@ -948,7 +948,7 @@ func convertCreateExtensionStmt(n *pg.CreateExtensionStmt) *ast.CreateExtensionS return nil } return &ast.CreateExtensionStmt{ - Extname: &n.Extname, + Extname: makeString(n.Extname), IfNotExists: n.IfNotExists, Options: convertSlice(n.Options), } @@ -959,7 +959,7 @@ func convertCreateFdwStmt(n *pg.CreateFdwStmt) *ast.CreateFdwStmt { return nil } return &ast.CreateFdwStmt{ - Fdwname: &n.Fdwname, + Fdwname: makeString(n.Fdwname), FuncOptions: convertSlice(n.FuncOptions), Options: convertSlice(n.Options), } @@ -970,10 +970,10 @@ func convertCreateForeignServerStmt(n *pg.CreateForeignServerStmt) *ast.CreateFo return nil } return &ast.CreateForeignServerStmt{ - Servername: &n.Servername, - Servertype: &n.Servertype, - Version: &n.Version, - Fdwname: &n.Fdwname, + Servername: makeString(n.Servername), + Servertype: makeString(n.Servertype), + Version: makeString(n.Version), + Fdwname: makeString(n.Fdwname), IfNotExists: n.IfNotExists, Options: convertSlice(n.Options), } @@ -984,7 +984,7 @@ func convertCreateForeignTableStmt(n *pg.CreateForeignTableStmt) *ast.CreateFore return nil } return &ast.CreateForeignTableStmt{ - Servername: &n.Servername, + Servername: makeString(n.Servername), Options: convertSlice(n.Options), } } @@ -1027,7 +1027,7 @@ func convertCreateOpClassStmt(n *pg.CreateOpClassStmt) *ast.CreateOpClassStmt { return &ast.CreateOpClassStmt{ Opclassname: convertSlice(n.Opclassname), Opfamilyname: convertSlice(n.Opfamilyname), - Amname: &n.Amname, + Amname: makeString(n.Amname), Datatype: convertTypeName(n.Datatype), Items: convertSlice(n.Items), IsDefault: n.IsDefault, @@ -1040,7 +1040,7 @@ func convertCreateOpFamilyStmt(n *pg.CreateOpFamilyStmt) *ast.CreateOpFamilyStmt } return &ast.CreateOpFamilyStmt{ Opfamilyname: convertSlice(n.Opfamilyname), - Amname: &n.Amname, + Amname: makeString(n.Amname), } } @@ -1050,7 +1050,7 @@ func convertCreatePLangStmt(n *pg.CreatePLangStmt) *ast.CreatePLangStmt { } return &ast.CreatePLangStmt{ Replace: n.Replace, - Plname: &n.Plname, + Plname: makeString(n.Plname), Plhandler: convertSlice(n.Plhandler), Plinline: convertSlice(n.Plinline), Plvalidator: convertSlice(n.Plvalidator), @@ -1063,9 +1063,9 @@ func convertCreatePolicyStmt(n *pg.CreatePolicyStmt) *ast.CreatePolicyStmt { return nil } return &ast.CreatePolicyStmt{ - PolicyName: &n.PolicyName, + PolicyName: makeString(n.PolicyName), Table: convertRangeVar(n.Table), - CmdName: &n.CmdName, + CmdName: makeString(n.CmdName), Permissive: n.Permissive, Roles: convertSlice(n.Roles), Qual: convertNode(n.Qual), @@ -1078,7 +1078,7 @@ func convertCreatePublicationStmt(n *pg.CreatePublicationStmt) *ast.CreatePublic return nil } return &ast.CreatePublicationStmt{ - Pubname: &n.Pubname, + Pubname: makeString(n.Pubname), Options: convertSlice(n.Options), Tables: convertSlice(n.Tables), ForAllTables: n.ForAllTables, @@ -1101,7 +1101,7 @@ func convertCreateRoleStmt(n *pg.CreateRoleStmt) *ast.CreateRoleStmt { } return &ast.CreateRoleStmt{ StmtType: ast.RoleStmtType(n.StmtType), - Role: &n.Role, + Role: makeString(n.Role), Options: convertSlice(n.Options), } } @@ -1111,7 +1111,7 @@ func convertCreateSchemaStmt(n *pg.CreateSchemaStmt) *ast.CreateSchemaStmt { return nil } return &ast.CreateSchemaStmt{ - Name: &n.Schemaname, + Name: makeString(n.Schemaname), Authrole: convertRoleSpec(n.Authrole), SchemaElts: convertSlice(n.SchemaElts), IfNotExists: n.IfNotExists, @@ -1158,7 +1158,7 @@ func convertCreateStmt(n *pg.CreateStmt) *ast.CreateStmt { Constraints: convertSlice(n.Constraints), Options: convertSlice(n.Options), Oncommit: ast.OnCommitAction(n.Oncommit), - Tablespacename: &n.Tablespacename, + Tablespacename: makeString(n.Tablespacename), IfNotExists: n.IfNotExists, } } @@ -1168,8 +1168,8 @@ func convertCreateSubscriptionStmt(n *pg.CreateSubscriptionStmt) *ast.CreateSubs return nil } return &ast.CreateSubscriptionStmt{ - Subname: &n.Subname, - Conninfo: &n.Conninfo, + Subname: makeString(n.Subname), + Conninfo: makeString(n.Conninfo), Publication: convertSlice(n.Publication), Options: convertSlice(n.Options), } @@ -1193,9 +1193,9 @@ func convertCreateTableSpaceStmt(n *pg.CreateTableSpaceStmt) *ast.CreateTableSpa return nil } return &ast.CreateTableSpaceStmt{ - Tablespacename: &n.Tablespacename, + Tablespacename: makeString(n.Tablespacename), Owner: convertRoleSpec(n.Owner), - Location: &n.Location, + Location: makeString(n.Location), Options: convertSlice(n.Options), } } @@ -1207,7 +1207,7 @@ func convertCreateTransformStmt(n *pg.CreateTransformStmt) *ast.CreateTransformS return &ast.CreateTransformStmt{ Replace: n.Replace, TypeName: convertTypeName(n.TypeName), - Lang: &n.Lang, + Lang: makeString(n.Lang), Fromsql: convertObjectWithArgs(n.Fromsql), Tosql: convertObjectWithArgs(n.Tosql), } @@ -1218,7 +1218,7 @@ func convertCreateTrigStmt(n *pg.CreateTrigStmt) *ast.CreateTrigStmt { return nil } return &ast.CreateTrigStmt{ - Trigname: &n.Trigname, + Trigname: makeString(n.Trigname), Relation: convertRangeVar(n.Relation), Funcname: convertSlice(n.Funcname), Args: convertSlice(n.Args), @@ -1241,7 +1241,7 @@ func convertCreateUserMappingStmt(n *pg.CreateUserMappingStmt) *ast.CreateUserMa } return &ast.CreateUserMappingStmt{ User: convertRoleSpec(n.User), - Servername: &n.Servername, + Servername: makeString(n.Servername), IfNotExists: n.IfNotExists, Options: convertSlice(n.Options), } @@ -1252,7 +1252,7 @@ func convertCreatedbStmt(n *pg.CreatedbStmt) *ast.CreatedbStmt { return nil } return &ast.CreatedbStmt{ - Dbname: &n.Dbname, + Dbname: makeString(n.Dbname), Options: convertSlice(n.Options), } } @@ -1264,7 +1264,7 @@ func convertCurrentOfExpr(n *pg.CurrentOfExpr) *ast.CurrentOfExpr { return &ast.CurrentOfExpr{ Xpr: convertNode(n.Xpr), Cvarno: ast.Index(n.Cvarno), - CursorName: &n.CursorName, + CursorName: makeString(n.CursorName), CursorParam: int(n.CursorParam), } } @@ -1274,7 +1274,7 @@ func convertDeallocateStmt(n *pg.DeallocateStmt) *ast.DeallocateStmt { return nil } return &ast.DeallocateStmt{ - Name: &n.Name, + Name: makeString(n.Name), } } @@ -1283,7 +1283,7 @@ func convertDeclareCursorStmt(n *pg.DeclareCursorStmt) *ast.DeclareCursorStmt { return nil } return &ast.DeclareCursorStmt{ - Portalname: &n.Portalname, + Portalname: makeString(n.Portalname), Options: int(n.Options), Query: convertNode(n.Query), } @@ -1294,8 +1294,8 @@ func convertDefElem(n *pg.DefElem) *ast.DefElem { return nil } return &ast.DefElem{ - Defnamespace: &n.Defnamespace, - Defname: &n.Defname, + Defnamespace: makeString(n.Defnamespace), + Defname: makeString(n.Defname), Arg: convertNode(n.Arg), Defaction: ast.DefElemAction(n.Defaction), Location: int(n.Location), @@ -1385,7 +1385,7 @@ func convertDropSubscriptionStmt(n *pg.DropSubscriptionStmt) *ast.DropSubscripti return nil } return &ast.DropSubscriptionStmt{ - Subname: &n.Subname, + Subname: makeString(n.Subname), MissingOk: n.MissingOk, Behavior: ast.DropBehavior(n.Behavior), } @@ -1396,7 +1396,7 @@ func convertDropTableSpaceStmt(n *pg.DropTableSpaceStmt) *ast.DropTableSpaceStmt return nil } return &ast.DropTableSpaceStmt{ - Tablespacename: &n.Tablespacename, + Tablespacename: makeString(n.Tablespacename), MissingOk: n.MissingOk, } } @@ -1407,7 +1407,7 @@ func convertDropUserMappingStmt(n *pg.DropUserMappingStmt) *ast.DropUserMappingS } return &ast.DropUserMappingStmt{ User: convertRoleSpec(n.User), - Servername: &n.Servername, + Servername: makeString(n.Servername), MissingOk: n.MissingOk, } } @@ -1417,7 +1417,7 @@ func convertDropdbStmt(n *pg.DropdbStmt) *ast.DropdbStmt { return nil } return &ast.DropdbStmt{ - Dbname: &n.Dbname, + Dbname: makeString(n.Dbname), MissingOk: n.MissingOk, } } @@ -1427,7 +1427,7 @@ func convertExecuteStmt(n *pg.ExecuteStmt) *ast.ExecuteStmt { return nil } return &ast.ExecuteStmt{ - Name: &n.Name, + Name: makeString(n.Name), Params: convertSlice(n.Params), } } @@ -1456,7 +1456,7 @@ func convertFetchStmt(n *pg.FetchStmt) *ast.FetchStmt { return &ast.FetchStmt{ Direction: ast.FetchDirection(n.Direction), HowMany: n.HowMany, - Portalname: &n.Portalname, + Portalname: makeString(n.Portalname), Ismove: n.Ismove, } } @@ -1554,7 +1554,7 @@ func convertFunctionParameter(n *pg.FunctionParameter) *ast.FunctionParameter { return nil } return &ast.FunctionParameter{ - Name: &n.Name, + Name: makeString(n.Name), ArgType: convertTypeName(n.ArgType), Mode: ast.FunctionParameterMode(n.Mode), Defexpr: convertNode(n.Defexpr), @@ -1621,9 +1621,9 @@ func convertImportForeignSchemaStmt(n *pg.ImportForeignSchemaStmt) *ast.ImportFo return nil } return &ast.ImportForeignSchemaStmt{ - ServerName: &n.ServerName, - RemoteSchema: &n.RemoteSchema, - LocalSchema: &n.LocalSchema, + ServerName: makeString(n.ServerName), + RemoteSchema: makeString(n.RemoteSchema), + LocalSchema: makeString(n.LocalSchema), ListType: ast.ImportForeignSchemaType(n.ListType), TableList: convertSlice(n.TableList), Options: convertSlice(n.Options), @@ -1635,9 +1635,9 @@ func convertIndexElem(n *pg.IndexElem) *ast.IndexElem { return nil } return &ast.IndexElem{ - Name: &n.Name, + Name: makeString(n.Name), Expr: convertNode(n.Expr), - Indexcolname: &n.Indexcolname, + Indexcolname: makeString(n.Indexcolname), Collation: convertSlice(n.Collation), Opclass: convertSlice(n.Opclass), Ordering: ast.SortByDir(n.Ordering), @@ -1650,15 +1650,15 @@ func convertIndexStmt(n *pg.IndexStmt) *ast.IndexStmt { return nil } return &ast.IndexStmt{ - Idxname: &n.Idxname, + Idxname: makeString(n.Idxname), Relation: convertRangeVar(n.Relation), - AccessMethod: &n.AccessMethod, - TableSpace: &n.TableSpace, + AccessMethod: makeString(n.AccessMethod), + TableSpace: makeString(n.TableSpace), IndexParams: convertSlice(n.IndexParams), Options: convertSlice(n.Options), WhereClause: convertNode(n.WhereClause), ExcludeOpNames: convertSlice(n.ExcludeOpNames), - Idxcomment: &n.Idxcomment, + Idxcomment: makeString(n.Idxcomment), IndexOid: ast.Oid(n.IndexOid), OldNode: ast.Oid(n.OldNode), Unique: n.Unique, @@ -1679,7 +1679,7 @@ func convertInferClause(n *pg.InferClause) *ast.InferClause { return &ast.InferClause{ IndexElems: convertSlice(n.IndexElems), WhereClause: convertNode(n.WhereClause), - Conname: &n.Conname, + Conname: makeString(n.Conname), Location: int(n.Location), } } @@ -1701,7 +1701,7 @@ func convertInlineCodeBlock(n *pg.InlineCodeBlock) *ast.InlineCodeBlock { return nil } return &ast.InlineCodeBlock{ - SourceText: &n.SourceText, + SourceText: makeString(n.SourceText), LangOid: ast.Oid(n.LangOid), LangIsTrusted: n.LangIsTrusted, } @@ -1740,7 +1740,7 @@ func convertIntoClause(n *pg.IntoClause) *ast.IntoClause { ColNames: convertSlice(n.ColNames), Options: convertSlice(n.Options), OnCommit: ast.OnCommitAction(n.OnCommit), - TableSpaceName: &n.TableSpaceName, + TableSpaceName: makeString(n.TableSpaceName), ViewQuery: convertNode(n.ViewQuery), SkipData: n.SkipData, } @@ -1767,7 +1767,7 @@ func convertListenStmt(n *pg.ListenStmt) *ast.ListenStmt { return nil } return &ast.ListenStmt{ - Conditionname: &n.Conditionname, + Conditionname: makeString(n.Conditionname), } } @@ -1776,7 +1776,7 @@ func convertLoadStmt(n *pg.LoadStmt) *ast.LoadStmt { return nil } return &ast.LoadStmt{ - Filename: &n.Filename, + Filename: makeString(n.Filename), } } @@ -1835,7 +1835,7 @@ func convertNamedArgExpr(n *pg.NamedArgExpr) *ast.NamedArgExpr { return &ast.NamedArgExpr{ Xpr: convertNode(n.Xpr), Arg: convertNode(n.Arg), - Name: &n.Name, + Name: makeString(n.Name), Argnumber: int(n.Argnumber), Location: int(n.Location), } @@ -1857,8 +1857,8 @@ func convertNotifyStmt(n *pg.NotifyStmt) *ast.NotifyStmt { return nil } return &ast.NotifyStmt{ - Conditionname: &n.Conditionname, - Payload: &n.Payload, + Conditionname: makeString(n.Conditionname), + Payload: makeString(n.Payload), } } @@ -1992,7 +1992,7 @@ func convertPartitionElem(n *pg.PartitionElem) *ast.PartitionElem { return nil } return &ast.PartitionElem{ - Name: &n.Name, + Name: makeString(n.Name), Expr: convertNode(n.Expr), Collation: convertSlice(n.Collation), Opclass: convertSlice(n.Opclass), @@ -2016,7 +2016,7 @@ func convertPartitionSpec(n *pg.PartitionSpec) *ast.PartitionSpec { return nil } return &ast.PartitionSpec{ - Strategy: &n.Strategy, + Strategy: makeString(n.Strategy), PartParams: convertSlice(n.PartParams), Location: int(n.Location), } @@ -2027,7 +2027,7 @@ func convertPrepareStmt(n *pg.PrepareStmt) *ast.PrepareStmt { return nil } return &ast.PrepareStmt{ - Name: &n.Name, + Name: makeString(n.Name), Argtypes: convertSlice(n.Argtypes), Query: convertNode(n.Query), } @@ -2121,7 +2121,7 @@ func convertRangeTableFuncCol(n *pg.RangeTableFuncCol) *ast.RangeTableFuncCol { return nil } return &ast.RangeTableFuncCol{ - Colname: &n.Colname, + Colname: makeString(n.Colname), TypeName: convertTypeName(n.TypeName), ForOrdinality: n.ForOrdinality, IsNotNull: n.IsNotNull, @@ -2161,13 +2161,13 @@ func convertRangeTblEntry(n *pg.RangeTblEntry) *ast.RangeTblEntry { Funcordinality: n.Funcordinality, Tablefunc: convertTableFunc(n.Tablefunc), ValuesLists: convertSlice(n.ValuesLists), - Ctename: &n.Ctename, + Ctename: makeString(n.Ctename), Ctelevelsup: ast.Index(n.Ctelevelsup), SelfReference: n.SelfReference, Coltypes: convertSlice(n.Coltypes), Coltypmods: convertSlice(n.Coltypmods), Colcollations: convertSlice(n.Colcollations), - Enrname: &n.Enrname, + Enrname: makeString(n.Enrname), Enrtuples: n.Enrtuples, Alias: convertAlias(n.Alias), Eref: convertAlias(n.Eref), @@ -2212,9 +2212,9 @@ func convertRangeVar(n *pg.RangeVar) *ast.RangeVar { return nil } return &ast.RangeVar{ - Catalogname: &n.Catalogname, - Schemaname: &n.Schemaname, - Relname: &n.Relname, + Catalogname: makeString(n.Catalogname), + Schemaname: makeString(n.Schemaname), + Relname: makeString(n.Relname), Inh: n.Inh, Relpersistence: makeByte(n.Relpersistence), Alias: convertAlias(n.Alias), @@ -2261,7 +2261,7 @@ func convertReindexStmt(n *pg.ReindexStmt) *ast.ReindexStmt { return &ast.ReindexStmt{ Kind: ast.ReindexObjectType(n.Kind), Relation: convertRangeVar(n.Relation), - Name: &n.Name, + Name: makeString(n.Name), Options: int(n.Options), } } @@ -2290,8 +2290,8 @@ func convertRenameStmt(n *pg.RenameStmt) *ast.RenameStmt { RelationType: ast.ObjectType(n.RelationType), Relation: convertRangeVar(n.Relation), Object: convertNode(n.Object), - Subname: &n.Subname, - Newname: &n.Newname, + Subname: makeString(n.Subname), + Newname: makeString(n.Newname), Behavior: ast.DropBehavior(n.Behavior), MissingOk: n.MissingOk, } @@ -2303,7 +2303,7 @@ func convertReplicaIdentityStmt(n *pg.ReplicaIdentityStmt) *ast.ReplicaIdentityS } return &ast.ReplicaIdentityStmt{ IdentityType: makeByte(n.IdentityType), - Name: &n.Name, + Name: makeString(n.Name), } } @@ -2312,7 +2312,7 @@ func convertResTarget(n *pg.ResTarget) *ast.ResTarget { return nil } return &ast.ResTarget{ - Name: &n.Name, + Name: makeString(n.Name), Indirection: convertSlice(n.Indirection), Val: convertNode(n.Val), Location: int(n.Location), @@ -2325,7 +2325,7 @@ func convertRoleSpec(n *pg.RoleSpec) *ast.RoleSpec { } return &ast.RoleSpec{ Roletype: ast.RoleSpecType(n.Roletype), - Rolename: &n.Rolename, + Rolename: makeString(n.Rolename), Location: int(n.Location), } } @@ -2377,7 +2377,7 @@ func convertRuleStmt(n *pg.RuleStmt) *ast.RuleStmt { } return &ast.RuleStmt{ Relation: convertRangeVar(n.Relation), - Rulename: &n.Rulename, + Rulename: makeString(n.Rulename), WhereClause: convertNode(n.WhereClause), Event: ast.CmdType(n.Event), Instead: n.Instead, @@ -2421,8 +2421,8 @@ func convertSecLabelStmt(n *pg.SecLabelStmt) *ast.SecLabelStmt { return &ast.SecLabelStmt{ Objtype: ast.ObjectType(n.Objtype), Object: convertNode(n.Object), - Provider: &n.Provider, - Label: &n.Label, + Provider: makeString(n.Provider), + Label: makeString(n.Label), } } @@ -2541,7 +2541,7 @@ func convertSubPlan(n *pg.SubPlan) *ast.SubPlan { Testexpr: convertNode(n.Testexpr), ParamIds: convertSlice(n.ParamIds), PlanId: int(n.PlanId), - PlanName: &n.PlanName, + PlanName: makeString(n.PlanName), FirstColType: ast.Oid(n.FirstColType), FirstColTypmod: n.FirstColTypmod, FirstColCollation: ast.Oid(n.FirstColCollation), @@ -2606,7 +2606,7 @@ func convertTargetEntry(n *pg.TargetEntry) *ast.TargetEntry { Xpr: convertNode(n.Xpr), Expr: convertNode(n.Expr), Resno: ast.AttrNumber(n.Resno), - Resname: &n.Resname, + Resname: makeString(n.Resname), Ressortgroupref: ast.Index(n.Ressortgroupref), Resorigtbl: ast.Oid(n.Resorigtbl), Resorigcol: ast.AttrNumber(n.Resorigcol), @@ -2621,7 +2621,7 @@ func convertTransactionStmt(n *pg.TransactionStmt) *ast.TransactionStmt { return &ast.TransactionStmt{ Kind: ast.TransactionStmtKind(n.Kind), Options: convertSlice(n.Options), - Gid: &n.Gid, + Gid: makeString(n.Gid), } } @@ -2630,7 +2630,7 @@ func convertTriggerTransition(n *pg.TriggerTransition) *ast.TriggerTransition { return nil } return &ast.TriggerTransition{ - Name: &n.Name, + Name: makeString(n.Name), IsNew: n.IsNew, IsTable: n.IsTable, } @@ -2679,7 +2679,7 @@ func convertUnlistenStmt(n *pg.UnlistenStmt) *ast.UnlistenStmt { return nil } return &ast.UnlistenStmt{ - Conditionname: &n.Conditionname, + Conditionname: makeString(n.Conditionname), } } @@ -2731,7 +2731,7 @@ func convertVariableSetStmt(n *pg.VariableSetStmt) *ast.VariableSetStmt { } return &ast.VariableSetStmt{ Kind: ast.VariableSetKind(n.Kind), - Name: &n.Name, + Name: makeString(n.Name), Args: convertSlice(n.Args), IsLocal: n.IsLocal, } @@ -2742,7 +2742,7 @@ func convertVariableShowStmt(n *pg.VariableShowStmt) *ast.VariableShowStmt { return nil } return &ast.VariableShowStmt{ - Name: &n.Name, + Name: makeString(n.Name), } } @@ -2765,8 +2765,8 @@ func convertWindowClause(n *pg.WindowClause) *ast.WindowClause { return nil } return &ast.WindowClause{ - Name: &n.Name, - Refname: &n.Refname, + Name: makeString(n.Name), + Refname: makeString(n.Refname), PartitionClause: convertSlice(n.PartitionClause), OrderClause: convertSlice(n.OrderClause), FrameOptions: int(n.FrameOptions), @@ -2782,8 +2782,8 @@ func convertWindowDef(n *pg.WindowDef) *ast.WindowDef { return nil } return &ast.WindowDef{ - Name: &n.Name, - Refname: &n.Refname, + Name: makeString(n.Name), + Refname: makeString(n.Refname), PartitionClause: convertSlice(n.PartitionClause), OrderClause: convertSlice(n.OrderClause), FrameOptions: int(n.FrameOptions), @@ -2818,8 +2818,8 @@ func convertWithCheckOption(n *pg.WithCheckOption) *ast.WithCheckOption { } return &ast.WithCheckOption{ Kind: ast.WCOKind(n.Kind), - Relname: &n.Relname, - Polname: &n.Polname, + Relname: makeString(n.Relname), + Polname: makeString(n.Polname), Qual: convertNode(n.Qual), Cascaded: n.Cascaded, } @@ -2843,7 +2843,7 @@ func convertXmlExpr(n *pg.XmlExpr) *ast.XmlExpr { return &ast.XmlExpr{ Xpr: convertNode(n.Xpr), Op: ast.XmlExprOp(n.Op), - Name: &n.Name, + Name: makeString(n.Name), NamedArgs: convertSlice(n.NamedArgs), ArgNames: convertSlice(n.ArgNames), Args: convertSlice(n.Args), diff --git a/internal/engine/postgresql/parse.go b/internal/engine/postgresql/parse.go index 13d0e6272e..54306584aa 100644 --- a/internal/engine/postgresql/parse.go +++ b/internal/engine/postgresql/parse.go @@ -221,13 +221,13 @@ func translate(node *nodes.Node) (ast.Node, error) { if n.OldVal != "" { return &ast.AlterTypeRenameValueStmt{ Type: rel.TypeName(), - OldValue: &n.OldVal, - NewValue: &n.NewVal, + OldValue: makeString(n.OldVal), + NewValue: makeString(n.NewVal), }, nil } else { return &ast.AlterTypeAddValueStmt{ Type: rel.TypeName(), - NewValue: &n.NewVal, + NewValue: makeString(n.NewVal), SkipIfNewValExists: n.SkipIfNewValExists, }, nil } @@ -240,7 +240,7 @@ func translate(node *nodes.Node) (ast.Node, error) { rel := parseRelationFromRangeVar(n.Relation) return &ast.AlterTableSetSchemaStmt{ Table: rel.TableName(), - NewSchema: &n.Newschema, + NewSchema: makeString(n.Newschema), }, nil } return nil, errSkip @@ -332,7 +332,7 @@ func translate(node *nodes.Node) (ast.Node, error) { return &ast.CommentOnColumnStmt{ Col: col, Table: tbl, - Comment: &n.Comment, + Comment: makeString(n.Comment), }, nil case nodes.ObjectType_OBJECT_SCHEMA: @@ -342,7 +342,7 @@ func translate(node *nodes.Node) (ast.Node, error) { } return &ast.CommentOnSchemaStmt{ Schema: &ast.String{Str: o.String_.Str}, - Comment: &n.Comment, + Comment: makeString(n.Comment), }, nil case nodes.ObjectType_OBJECT_TABLE: @@ -352,7 +352,7 @@ func translate(node *nodes.Node) (ast.Node, error) { } return &ast.CommentOnTableStmt{ Table: rel.TableName(), - Comment: &n.Comment, + Comment: makeString(n.Comment), }, nil case nodes.ObjectType_OBJECT_TYPE: @@ -362,7 +362,7 @@ func translate(node *nodes.Node) (ast.Node, error) { } return &ast.CommentOnTypeStmt{ Type: rel.TypeName(), - Comment: &n.Comment, + Comment: makeString(n.Comment), }, nil } @@ -472,7 +472,7 @@ func translate(node *nodes.Node) (ast.Node, error) { case *nodes.Node_CreateSchemaStmt: n := inner.CreateSchemaStmt return &ast.CreateSchemaStmt{ - Name: &n.Schemaname, + Name: makeString(n.Schemaname), IfNotExists: n.IfNotExists, }, nil @@ -565,14 +565,14 @@ func translate(node *nodes.Node) (ast.Node, error) { return &ast.RenameColumnStmt{ Table: rel.TableName(), Col: &ast.ColumnRef{Name: n.Subname}, - NewName: &n.Newname, + NewName: makeString(n.Newname), }, nil case nodes.ObjectType_OBJECT_TABLE: rel := parseRelationFromRangeVar(n.Relation) return &ast.RenameTableStmt{ Table: rel.TableName(), - NewName: &n.Newname, + NewName: makeString(n.Newname), }, nil } diff --git a/internal/engine/postgresql/utils.go b/internal/engine/postgresql/utils.go index 2e4f22fcfd..7521ca5750 100644 --- a/internal/engine/postgresql/utils.go +++ b/internal/engine/postgresql/utils.go @@ -56,3 +56,10 @@ func makeUint32Slice(in []uint64) []uint32 { } return out } + +func makeString(s string) *string { + if s == "" { + return nil + } + return &s +} From 24a7a44c69bbaded88c51e2a8d867c3e191e370d Mon Sep 17 00:00:00 2001 From: Kyle Conroy Date: Fri, 19 Mar 2021 22:49:30 -0700 Subject: [PATCH 11/11] Tests passing --- internal/engine/postgresql/convert.go | 81 +++++++++++++++++++++++++-- internal/engine/postgresql/parse.go | 19 +------ 2 files changed, 78 insertions(+), 22 deletions(-) diff --git a/internal/engine/postgresql/convert.go b/internal/engine/postgresql/convert.go index 42d33ef29b..b36444a35c 100644 --- a/internal/engine/postgresql/convert.go +++ b/internal/engine/postgresql/convert.go @@ -3,11 +3,68 @@ package postgresql import ( + "fmt" + pg "github.com/pganalyze/pg_query_go/v2" "github.com/kyleconroy/sqlc/internal/sql/ast" ) +func convertFuncParamMode(m pg.FunctionParameterMode) (ast.FuncParamMode, error) { + switch m { + case pg.FunctionParameterMode_FUNC_PARAM_IN: + return ast.FuncParamIn, nil + case pg.FunctionParameterMode_FUNC_PARAM_OUT: + return ast.FuncParamOut, nil + case pg.FunctionParameterMode_FUNC_PARAM_INOUT: + return ast.FuncParamInOut, nil + case pg.FunctionParameterMode_FUNC_PARAM_VARIADIC: + return ast.FuncParamVariadic, nil + case pg.FunctionParameterMode_FUNC_PARAM_TABLE: + return ast.FuncParamTable, nil + default: + return -1, fmt.Errorf("parse func param: invalid mode %v", m) + } +} + +func convertSubLinkType(t pg.SubLinkType) (ast.SubLinkType, error) { + switch t { + case pg.SubLinkType_EXISTS_SUBLINK: + return ast.EXISTS_SUBLINK, nil + case pg.SubLinkType_ALL_SUBLINK: + return ast.ALL_SUBLINK, nil + case pg.SubLinkType_ANY_SUBLINK: + return ast.ANY_SUBLINK, nil + case pg.SubLinkType_ROWCOMPARE_SUBLINK: + return ast.ROWCOMPARE_SUBLINK, nil + case pg.SubLinkType_EXPR_SUBLINK: + return ast.EXISTS_SUBLINK, nil + case pg.SubLinkType_MULTIEXPR_SUBLINK: + return ast.MULTIEXPR_SUBLINK, nil + case pg.SubLinkType_ARRAY_SUBLINK: + return ast.ARRAY_SUBLINK, nil + case pg.SubLinkType_CTE_SUBLINK: + return ast.CTE_SUBLINK, nil + default: + return 0, fmt.Errorf("parse sublink type: unknown type %s", t) + } +} + +func convertSetOperation(t pg.SetOperation) (ast.SetOperation, error) { + switch t { + case pg.SetOperation_SETOP_NONE: + return ast.None, nil + case pg.SetOperation_SETOP_UNION: + return ast.Union, nil + case pg.SetOperation_SETOP_INTERSECT: + return ast.Intersect, nil + case pg.SetOperation_SETOP_EXCEPT: + return ast.Except, nil + default: + return 0, fmt.Errorf("parse set operation: unknown type %s", t) + } +} + func convertList(l *pg.List) *ast.List { out := &ast.List{} for _, item := range l.Items { @@ -2430,6 +2487,10 @@ func convertSelectStmt(n *pg.SelectStmt) *ast.SelectStmt { if n == nil { return nil } + op, err := convertSetOperation(n.Op) + if err != nil { + panic(err) + } return &ast.SelectStmt{ DistinctClause: convertSlice(n.DistinctClause), IntoClause: convertIntoClause(n.IntoClause), @@ -2445,7 +2506,7 @@ func convertSelectStmt(n *pg.SelectStmt) *ast.SelectStmt { LimitCount: convertNode(n.LimitCount), LockingClause: convertSlice(n.LockingClause), WithClause: convertWithClause(n.WithClause), - Op: ast.SetOperation(n.Op), + Op: op, All: n.All, Larg: convertSelectStmt(n.Larg), Rarg: convertSelectStmt(n.Rarg), @@ -2456,8 +2517,12 @@ func convertSetOperationStmt(n *pg.SetOperationStmt) *ast.SetOperationStmt { if n == nil { return nil } + op, err := convertSetOperation(n.Op) + if err != nil { + panic(err) + } return &ast.SetOperationStmt{ - Op: ast.SetOperation(n.Op), + Op: op, All: n.All, Larg: convertNode(n.Larg), Rarg: convertNode(n.Rarg), @@ -2520,9 +2585,13 @@ func convertSubLink(n *pg.SubLink) *ast.SubLink { if n == nil { return nil } + slt, err := convertSubLinkType(n.SubLinkType) + if err != nil { + panic(err) + } return &ast.SubLink{ Xpr: convertNode(n.Xpr), - SubLinkType: ast.SubLinkType(n.SubLinkType), + SubLinkType: slt, SubLinkId: int(n.SubLinkId), Testexpr: convertNode(n.Testexpr), OperName: convertSlice(n.OperName), @@ -2535,9 +2604,13 @@ func convertSubPlan(n *pg.SubPlan) *ast.SubPlan { if n == nil { return nil } + slt, err := convertSubLinkType(n.SubLinkType) + if err != nil { + panic(err) + } return &ast.SubPlan{ Xpr: convertNode(n.Xpr), - SubLinkType: ast.SubLinkType(n.SubLinkType), + SubLinkType: slt, Testexpr: convertNode(n.Testexpr), ParamIds: convertSlice(n.ParamIds), PlanId: int(n.PlanId), diff --git a/internal/engine/postgresql/parse.go b/internal/engine/postgresql/parse.go index 54306584aa..0d1325c600 100644 --- a/internal/engine/postgresql/parse.go +++ b/internal/engine/postgresql/parse.go @@ -65,23 +65,6 @@ func (r relation) FuncName() *ast.FuncName { } } -func parseFuncParamMode(m nodes.FunctionParameterMode) (ast.FuncParamMode, error) { - switch m { - case nodes.FunctionParameterMode_FUNC_PARAM_IN: - return ast.FuncParamIn, nil - case nodes.FunctionParameterMode_FUNC_PARAM_OUT: - return ast.FuncParamOut, nil - case nodes.FunctionParameterMode_FUNC_PARAM_INOUT: - return ast.FuncParamInOut, nil - case nodes.FunctionParameterMode_FUNC_PARAM_VARIADIC: - return ast.FuncParamVariadic, nil - case nodes.FunctionParameterMode_FUNC_PARAM_TABLE: - return ast.FuncParamTable, nil - default: - return -1, fmt.Errorf("parse func param: invalid mode %v", m) - } -} - func parseRelationFromNodes(list []*nodes.Node) (*relation, error) { parts := stringSliceFromNodes(list) switch len(parts) { @@ -453,7 +436,7 @@ func translate(node *nodes.Node) (ast.Node, error) { if err != nil { return nil, err } - mode, err := parseFuncParamMode(arg.Mode) + mode, err := convertFuncParamMode(arg.Mode) if err != nil { return nil, err }