diff --git a/buf.gen.yaml b/buf.gen.yaml index 4b7ebb7130..63146b4ee3 100644 --- a/buf.gen.yaml +++ b/buf.gen.yaml @@ -2,9 +2,9 @@ version: v1 managed: enabled: true plugins: - - remote: buf.build/protocolbuffers/plugins/go:v1.28.1-1 + - plugin: buf.build/protocolbuffers/go:v1.30.0 out: internal opt: paths=source_relative - - remote: buf.build/planetscale/plugins/vtproto:v0.3.0 + - plugin: buf.build/community/planetscale-vtprotobuf:v0.4.0 out: internal - opt: paths=source_relative \ No newline at end of file + opt: paths=source_relative diff --git a/internal/plugin/codegen.pb.go b/internal/plugin/codegen.pb.go index 17a43c6c4c..d906eb0f3f 100644 --- a/internal/plugin/codegen.pb.go +++ b/internal/plugin/codegen.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.28.1 +// protoc-gen-go v1.30.0 // protoc (unknown) // source: plugin/codegen.proto diff --git a/internal/plugin/codegen_vtproto.pb.go b/internal/plugin/codegen_vtproto.pb.go index 95841ff5bd..81559f4f9b 100644 --- a/internal/plugin/codegen_vtproto.pb.go +++ b/internal/plugin/codegen_vtproto.pb.go @@ -1,11 +1,12 @@ // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. -// protoc-gen-go-vtproto version: v0.3.0 +// protoc-gen-go-vtproto version: v0.4.0 // source: plugin/codegen.proto package plugin import ( fmt "fmt" + proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" bits "math/bits" @@ -18,11 +19,526 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +func (m *File) CloneVT() *File { + if m == nil { + return (*File)(nil) + } + r := &File{ + Name: m.Name, + } + if rhs := m.Contents; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Contents = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *File) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Override) CloneVT() *Override { + if m == nil { + return (*Override)(nil) + } + r := &Override{ + CodeType: m.CodeType, + DbType: m.DbType, + Nullable: m.Nullable, + Column: m.Column, + Table: m.Table.CloneVT(), + ColumnName: m.ColumnName, + GoType: m.GoType.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Override) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ParsedGoType) CloneVT() *ParsedGoType { + if m == nil { + return (*ParsedGoType)(nil) + } + r := &ParsedGoType{ + ImportPath: m.ImportPath, + Package: m.Package, + TypeName: m.TypeName, + BasicType: m.BasicType, + } + if rhs := m.StructTags; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.StructTags = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ParsedGoType) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Settings) CloneVT() *Settings { + if m == nil { + return (*Settings)(nil) + } + r := &Settings{ + Version: m.Version, + Engine: m.Engine, + Codegen: m.Codegen.CloneVT(), + Go: m.Go.CloneVT(), + Json: m.Json.CloneVT(), + } + if rhs := m.Schema; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Schema = tmpContainer + } + if rhs := m.Queries; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Queries = tmpContainer + } + if rhs := m.Rename; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.Rename = tmpContainer + } + if rhs := m.Overrides; rhs != nil { + tmpContainer := make([]*Override, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Overrides = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Settings) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Codegen) CloneVT() *Codegen { + if m == nil { + return (*Codegen)(nil) + } + r := &Codegen{ + Out: m.Out, + Plugin: m.Plugin, + } + if rhs := m.Options; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Options = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Codegen) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GoCode) CloneVT() *GoCode { + if m == nil { + return (*GoCode)(nil) + } + r := &GoCode{ + EmitInterface: m.EmitInterface, + EmitJsonTags: m.EmitJsonTags, + EmitDbTags: m.EmitDbTags, + EmitPreparedQueries: m.EmitPreparedQueries, + EmitExactTableNames: m.EmitExactTableNames, + EmitEmptySlices: m.EmitEmptySlices, + EmitExportedQueries: m.EmitExportedQueries, + EmitResultStructPointers: m.EmitResultStructPointers, + EmitParamsStructPointers: m.EmitParamsStructPointers, + EmitMethodsWithDbArgument: m.EmitMethodsWithDbArgument, + JsonTagsCaseStyle: m.JsonTagsCaseStyle, + Package: m.Package, + Out: m.Out, + SqlPackage: m.SqlPackage, + SqlDriver: m.SqlDriver, + OutputDbFileName: m.OutputDbFileName, + OutputModelsFileName: m.OutputModelsFileName, + OutputQuerierFileName: m.OutputQuerierFileName, + OutputFilesSuffix: m.OutputFilesSuffix, + EmitEnumValidMethod: m.EmitEnumValidMethod, + EmitAllEnumValues: m.EmitAllEnumValues, + EmitPointersForNullTypes: m.EmitPointersForNullTypes, + OutputBatchFileName: m.OutputBatchFileName, + } + if rhs := m.InflectionExcludeTableNames; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.InflectionExcludeTableNames = tmpContainer + } + if rhs := m.QueryParameterLimit; rhs != nil { + tmpVal := *rhs + r.QueryParameterLimit = &tmpVal + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GoCode) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *JSONCode) CloneVT() *JSONCode { + if m == nil { + return (*JSONCode)(nil) + } + r := &JSONCode{ + Out: m.Out, + Indent: m.Indent, + Filename: m.Filename, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *JSONCode) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Catalog) CloneVT() *Catalog { + if m == nil { + return (*Catalog)(nil) + } + r := &Catalog{ + Comment: m.Comment, + DefaultSchema: m.DefaultSchema, + Name: m.Name, + } + if rhs := m.Schemas; rhs != nil { + tmpContainer := make([]*Schema, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Schemas = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Catalog) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Schema) CloneVT() *Schema { + if m == nil { + return (*Schema)(nil) + } + r := &Schema{ + Comment: m.Comment, + Name: m.Name, + } + if rhs := m.Tables; rhs != nil { + tmpContainer := make([]*Table, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Tables = tmpContainer + } + if rhs := m.Enums; rhs != nil { + tmpContainer := make([]*Enum, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Enums = tmpContainer + } + if rhs := m.CompositeTypes; rhs != nil { + tmpContainer := make([]*CompositeType, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.CompositeTypes = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Schema) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CompositeType) CloneVT() *CompositeType { + if m == nil { + return (*CompositeType)(nil) + } + r := &CompositeType{ + Name: m.Name, + Comment: m.Comment, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CompositeType) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Enum) CloneVT() *Enum { + if m == nil { + return (*Enum)(nil) + } + r := &Enum{ + Name: m.Name, + Comment: m.Comment, + } + if rhs := m.Vals; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Vals = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Enum) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Table) CloneVT() *Table { + if m == nil { + return (*Table)(nil) + } + r := &Table{ + Rel: m.Rel.CloneVT(), + Comment: m.Comment, + } + if rhs := m.Columns; rhs != nil { + tmpContainer := make([]*Column, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Columns = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Table) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Identifier) CloneVT() *Identifier { + if m == nil { + return (*Identifier)(nil) + } + r := &Identifier{ + Catalog: m.Catalog, + Schema: m.Schema, + Name: m.Name, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Identifier) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Column) CloneVT() *Column { + if m == nil { + return (*Column)(nil) + } + r := &Column{ + Name: m.Name, + NotNull: m.NotNull, + IsArray: m.IsArray, + Comment: m.Comment, + Length: m.Length, + IsNamedParam: m.IsNamedParam, + IsFuncCall: m.IsFuncCall, + Scope: m.Scope, + Table: m.Table.CloneVT(), + TableAlias: m.TableAlias, + Type: m.Type.CloneVT(), + IsSqlcSlice: m.IsSqlcSlice, + EmbedTable: m.EmbedTable.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Column) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Query) CloneVT() *Query { + if m == nil { + return (*Query)(nil) + } + r := &Query{ + Text: m.Text, + Name: m.Name, + Cmd: m.Cmd, + Filename: m.Filename, + InsertIntoTable: m.InsertIntoTable.CloneVT(), + } + if rhs := m.Columns; rhs != nil { + tmpContainer := make([]*Column, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Columns = tmpContainer + } + if rhs := m.Params; rhs != nil { + tmpContainer := make([]*Parameter, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Params = tmpContainer + } + if rhs := m.Comments; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Comments = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Query) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Parameter) CloneVT() *Parameter { + if m == nil { + return (*Parameter)(nil) + } + r := &Parameter{ + Number: m.Number, + Column: m.Column.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Parameter) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CodeGenRequest) CloneVT() *CodeGenRequest { + if m == nil { + return (*CodeGenRequest)(nil) + } + r := &CodeGenRequest{ + Settings: m.Settings.CloneVT(), + Catalog: m.Catalog.CloneVT(), + SqlcVersion: m.SqlcVersion, + } + if rhs := m.Queries; rhs != nil { + tmpContainer := make([]*Query, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Queries = tmpContainer + } + if rhs := m.PluginOptions; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.PluginOptions = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CodeGenRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CodeGenResponse) CloneVT() *CodeGenResponse { + if m == nil { + return (*CodeGenResponse)(nil) + } + r := &CodeGenResponse{} + if rhs := m.Files; rhs != nil { + tmpContainer := make([]*File, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Files = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CodeGenResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (this *File) EqualVT(that *File) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" + if this == that { + return true + } else if this == nil || that == nil { + return false } if this.Name != that.Name { return false @@ -33,11 +549,18 @@ func (this *File) EqualVT(that *File) bool { return string(this.unknownFields) == string(that.unknownFields) } +func (this *File) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*File) + if !ok { + return false + } + return this.EqualVT(that) +} func (this *Override) EqualVT(that *Override) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" + if this == that { + return true + } else if this == nil || that == nil { + return false } if this.CodeType != that.CodeType { return false @@ -63,11 +586,18 @@ func (this *Override) EqualVT(that *Override) bool { return string(this.unknownFields) == string(that.unknownFields) } +func (this *Override) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Override) + if !ok { + return false + } + return this.EqualVT(that) +} func (this *ParsedGoType) EqualVT(that *ParsedGoType) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" + if this == that { + return true + } else if this == nil || that == nil { + return false } if this.ImportPath != that.ImportPath { return false @@ -84,19 +614,30 @@ func (this *ParsedGoType) EqualVT(that *ParsedGoType) bool { if len(this.StructTags) != len(that.StructTags) { return false } - for i := range this.StructTags { - if this.StructTags[i] != that.StructTags[i] { + for i, vx := range this.StructTags { + vy, ok := that.StructTags[i] + if !ok { + return false + } + if vx != vy { return false } } return string(this.unknownFields) == string(that.unknownFields) } +func (this *ParsedGoType) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ParsedGoType) + if !ok { + return false + } + return this.EqualVT(that) +} func (this *Settings) EqualVT(that *Settings) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" + if this == that { + return true + } else if this == nil || that == nil { + return false } if this.Version != that.Version { return false @@ -107,33 +648,48 @@ func (this *Settings) EqualVT(that *Settings) bool { if len(this.Schema) != len(that.Schema) { return false } - for i := range this.Schema { - if this.Schema[i] != that.Schema[i] { + for i, vx := range this.Schema { + vy := that.Schema[i] + if vx != vy { return false } } if len(this.Queries) != len(that.Queries) { return false } - for i := range this.Queries { - if this.Queries[i] != that.Queries[i] { + for i, vx := range this.Queries { + vy := that.Queries[i] + if vx != vy { return false } } if len(this.Rename) != len(that.Rename) { return false } - for i := range this.Rename { - if this.Rename[i] != that.Rename[i] { + for i, vx := range this.Rename { + vy, ok := that.Rename[i] + if !ok { + return false + } + if vx != vy { return false } } if len(this.Overrides) != len(that.Overrides) { return false } - for i := range this.Overrides { - if !this.Overrides[i].EqualVT(that.Overrides[i]) { - return false + for i, vx := range this.Overrides { + vy := that.Overrides[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &Override{} + } + if q == nil { + q = &Override{} + } + if !p.EqualVT(q) { + return false + } } } if !this.Go.EqualVT(that.Go) { @@ -148,11 +704,18 @@ func (this *Settings) EqualVT(that *Settings) bool { return string(this.unknownFields) == string(that.unknownFields) } +func (this *Settings) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Settings) + if !ok { + return false + } + return this.EqualVT(that) +} func (this *Codegen) EqualVT(that *Codegen) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" + if this == that { + return true + } else if this == nil || that == nil { + return false } if this.Out != that.Out { return false @@ -166,11 +729,18 @@ func (this *Codegen) EqualVT(that *Codegen) bool { return string(this.unknownFields) == string(that.unknownFields) } +func (this *Codegen) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Codegen) + if !ok { + return false + } + return this.EqualVT(that) +} func (this *GoCode) EqualVT(that *GoCode) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" + if this == that { + return true + } else if this == nil || that == nil { + return false } if this.EmitInterface != that.EmitInterface { return false @@ -235,8 +805,9 @@ func (this *GoCode) EqualVT(that *GoCode) bool { if len(this.InflectionExcludeTableNames) != len(that.InflectionExcludeTableNames) { return false } - for i := range this.InflectionExcludeTableNames { - if this.InflectionExcludeTableNames[i] != that.InflectionExcludeTableNames[i] { + for i, vx := range this.InflectionExcludeTableNames { + vy := that.InflectionExcludeTableNames[i] + if vx != vy { return false } } @@ -255,11 +826,18 @@ func (this *GoCode) EqualVT(that *GoCode) bool { return string(this.unknownFields) == string(that.unknownFields) } +func (this *GoCode) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*GoCode) + if !ok { + return false + } + return this.EqualVT(that) +} func (this *JSONCode) EqualVT(that *JSONCode) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" + if this == that { + return true + } else if this == nil || that == nil { + return false } if this.Out != that.Out { return false @@ -273,11 +851,18 @@ func (this *JSONCode) EqualVT(that *JSONCode) bool { return string(this.unknownFields) == string(that.unknownFields) } +func (this *JSONCode) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*JSONCode) + if !ok { + return false + } + return this.EqualVT(that) +} func (this *Catalog) EqualVT(that *Catalog) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" + if this == that { + return true + } else if this == nil || that == nil { + return false } if this.Comment != that.Comment { return false @@ -291,19 +876,35 @@ func (this *Catalog) EqualVT(that *Catalog) bool { if len(this.Schemas) != len(that.Schemas) { return false } - for i := range this.Schemas { - if !this.Schemas[i].EqualVT(that.Schemas[i]) { - return false + for i, vx := range this.Schemas { + vy := that.Schemas[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &Schema{} + } + if q == nil { + q = &Schema{} + } + if !p.EqualVT(q) { + return false + } } } return string(this.unknownFields) == string(that.unknownFields) } +func (this *Catalog) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Catalog) + if !ok { + return false + } + return this.EqualVT(that) +} func (this *Schema) EqualVT(that *Schema) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" + if this == that { + return true + } else if this == nil || that == nil { + return false } if this.Comment != that.Comment { return false @@ -314,35 +915,69 @@ func (this *Schema) EqualVT(that *Schema) bool { if len(this.Tables) != len(that.Tables) { return false } - for i := range this.Tables { - if !this.Tables[i].EqualVT(that.Tables[i]) { - return false + for i, vx := range this.Tables { + vy := that.Tables[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &Table{} + } + if q == nil { + q = &Table{} + } + if !p.EqualVT(q) { + return false + } } } if len(this.Enums) != len(that.Enums) { return false } - for i := range this.Enums { - if !this.Enums[i].EqualVT(that.Enums[i]) { - return false + for i, vx := range this.Enums { + vy := that.Enums[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &Enum{} + } + if q == nil { + q = &Enum{} + } + if !p.EqualVT(q) { + return false + } } } if len(this.CompositeTypes) != len(that.CompositeTypes) { return false } - for i := range this.CompositeTypes { - if !this.CompositeTypes[i].EqualVT(that.CompositeTypes[i]) { - return false + for i, vx := range this.CompositeTypes { + vy := that.CompositeTypes[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &CompositeType{} + } + if q == nil { + q = &CompositeType{} + } + if !p.EqualVT(q) { + return false + } } } return string(this.unknownFields) == string(that.unknownFields) } +func (this *Schema) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Schema) + if !ok { + return false + } + return this.EqualVT(that) +} func (this *CompositeType) EqualVT(that *CompositeType) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" + if this == that { + return true + } else if this == nil || that == nil { + return false } if this.Name != that.Name { return false @@ -353,11 +988,18 @@ func (this *CompositeType) EqualVT(that *CompositeType) bool { return string(this.unknownFields) == string(that.unknownFields) } +func (this *CompositeType) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*CompositeType) + if !ok { + return false + } + return this.EqualVT(that) +} func (this *Enum) EqualVT(that *Enum) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" + if this == that { + return true + } else if this == nil || that == nil { + return false } if this.Name != that.Name { return false @@ -365,8 +1007,9 @@ func (this *Enum) EqualVT(that *Enum) bool { if len(this.Vals) != len(that.Vals) { return false } - for i := range this.Vals { - if this.Vals[i] != that.Vals[i] { + for i, vx := range this.Vals { + vy := that.Vals[i] + if vx != vy { return false } } @@ -376,11 +1019,18 @@ func (this *Enum) EqualVT(that *Enum) bool { return string(this.unknownFields) == string(that.unknownFields) } +func (this *Enum) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Enum) + if !ok { + return false + } + return this.EqualVT(that) +} func (this *Table) EqualVT(that *Table) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" + if this == that { + return true + } else if this == nil || that == nil { + return false } if !this.Rel.EqualVT(that.Rel) { return false @@ -388,9 +1038,18 @@ func (this *Table) EqualVT(that *Table) bool { if len(this.Columns) != len(that.Columns) { return false } - for i := range this.Columns { - if !this.Columns[i].EqualVT(that.Columns[i]) { - return false + for i, vx := range this.Columns { + vy := that.Columns[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &Column{} + } + if q == nil { + q = &Column{} + } + if !p.EqualVT(q) { + return false + } } } if this.Comment != that.Comment { @@ -399,11 +1058,18 @@ func (this *Table) EqualVT(that *Table) bool { return string(this.unknownFields) == string(that.unknownFields) } +func (this *Table) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Table) + if !ok { + return false + } + return this.EqualVT(that) +} func (this *Identifier) EqualVT(that *Identifier) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" + if this == that { + return true + } else if this == nil || that == nil { + return false } if this.Catalog != that.Catalog { return false @@ -417,11 +1083,18 @@ func (this *Identifier) EqualVT(that *Identifier) bool { return string(this.unknownFields) == string(that.unknownFields) } +func (this *Identifier) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Identifier) + if !ok { + return false + } + return this.EqualVT(that) +} func (this *Column) EqualVT(that *Column) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" + if this == that { + return true + } else if this == nil || that == nil { + return false } if this.Name != that.Name { return false @@ -465,11 +1138,18 @@ func (this *Column) EqualVT(that *Column) bool { return string(this.unknownFields) == string(that.unknownFields) } +func (this *Column) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Column) + if !ok { + return false + } + return this.EqualVT(that) +} func (this *Query) EqualVT(that *Query) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" + if this == that { + return true + } else if this == nil || that == nil { + return false } if this.Text != that.Text { return false @@ -483,116 +1163,1704 @@ func (this *Query) EqualVT(that *Query) bool { if len(this.Columns) != len(that.Columns) { return false } - for i := range this.Columns { - if !this.Columns[i].EqualVT(that.Columns[i]) { - return false + for i, vx := range this.Columns { + vy := that.Columns[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &Column{} + } + if q == nil { + q = &Column{} + } + if !p.EqualVT(q) { + return false + } } } if len(this.Params) != len(that.Params) { return false } - for i := range this.Params { - if !this.Params[i].EqualVT(that.Params[i]) { - return false - } + for i, vx := range this.Params { + vy := that.Params[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &Parameter{} + } + if q == nil { + q = &Parameter{} + } + if !p.EqualVT(q) { + return false + } + } } if len(this.Comments) != len(that.Comments) { return false } - for i := range this.Comments { - if this.Comments[i] != that.Comments[i] { - return false + for i, vx := range this.Comments { + vy := that.Comments[i] + if vx != vy { + return false + } + } + if this.Filename != that.Filename { + return false + } + if !this.InsertIntoTable.EqualVT(that.InsertIntoTable) { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Query) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Query) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *Parameter) EqualVT(that *Parameter) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if this.Number != that.Number { + return false + } + if !this.Column.EqualVT(that.Column) { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *Parameter) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*Parameter) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *CodeGenRequest) EqualVT(that *CodeGenRequest) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if !this.Settings.EqualVT(that.Settings) { + return false + } + if !this.Catalog.EqualVT(that.Catalog) { + return false + } + if len(this.Queries) != len(that.Queries) { + return false + } + for i, vx := range this.Queries { + vy := that.Queries[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &Query{} + } + if q == nil { + q = &Query{} + } + if !p.EqualVT(q) { + return false + } + } + } + if this.SqlcVersion != that.SqlcVersion { + return false + } + if string(this.PluginOptions) != string(that.PluginOptions) { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *CodeGenRequest) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*CodeGenRequest) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *CodeGenResponse) EqualVT(that *CodeGenResponse) bool { + if this == that { + return true + } else if this == nil || that == nil { + return false + } + if len(this.Files) != len(that.Files) { + return false + } + for i, vx := range this.Files { + vy := that.Files[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &File{} + } + if q == nil { + q = &File{} + } + if !p.EqualVT(q) { + return false + } + } + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *CodeGenResponse) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*CodeGenResponse) + if !ok { + return false + } + return this.EqualVT(that) +} +func (m *File) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *File) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *File) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Contents) > 0 { + i -= len(m.Contents) + copy(dAtA[i:], m.Contents) + i = encodeVarint(dAtA, i, uint64(len(m.Contents))) + i-- + dAtA[i] = 0x12 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Override) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Override) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Override) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.GoType != nil { + size, err := m.GoType.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if len(m.ColumnName) > 0 { + i -= len(m.ColumnName) + copy(dAtA[i:], m.ColumnName) + i = encodeVarint(dAtA, i, uint64(len(m.ColumnName))) + i-- + dAtA[i] = 0x42 + } + if m.Table != nil { + size, err := m.Table.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x3a + } + if len(m.Column) > 0 { + i -= len(m.Column) + copy(dAtA[i:], m.Column) + i = encodeVarint(dAtA, i, uint64(len(m.Column))) + i-- + dAtA[i] = 0x32 + } + if m.Nullable { + i-- + if m.Nullable { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x28 + } + if len(m.DbType) > 0 { + i -= len(m.DbType) + copy(dAtA[i:], m.DbType) + i = encodeVarint(dAtA, i, uint64(len(m.DbType))) + i-- + dAtA[i] = 0x1a + } + if len(m.CodeType) > 0 { + i -= len(m.CodeType) + copy(dAtA[i:], m.CodeType) + i = encodeVarint(dAtA, i, uint64(len(m.CodeType))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ParsedGoType) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ParsedGoType) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ParsedGoType) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.StructTags) > 0 { + for k := range m.StructTags { + v := m.StructTags[k] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarint(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = encodeVarint(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = encodeVarint(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x2a + } + } + if m.BasicType { + i-- + if m.BasicType { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if len(m.TypeName) > 0 { + i -= len(m.TypeName) + copy(dAtA[i:], m.TypeName) + i = encodeVarint(dAtA, i, uint64(len(m.TypeName))) + i-- + dAtA[i] = 0x1a + } + if len(m.Package) > 0 { + i -= len(m.Package) + copy(dAtA[i:], m.Package) + i = encodeVarint(dAtA, i, uint64(len(m.Package))) + i-- + dAtA[i] = 0x12 + } + if len(m.ImportPath) > 0 { + i -= len(m.ImportPath) + copy(dAtA[i:], m.ImportPath) + i = encodeVarint(dAtA, i, uint64(len(m.ImportPath))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Settings) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Settings) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Settings) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Codegen != nil { + size, err := m.Codegen.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x62 + } + if m.Json != nil { + size, err := m.Json.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x5a + } + if m.Go != nil { + size, err := m.Go.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if len(m.Overrides) > 0 { + for iNdEx := len(m.Overrides) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Overrides[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + } + if len(m.Rename) > 0 { + for k := range m.Rename { + v := m.Rename[k] + baseI := i + i -= len(v) + copy(dAtA[i:], v) + i = encodeVarint(dAtA, i, uint64(len(v))) + i-- + dAtA[i] = 0x12 + i -= len(k) + copy(dAtA[i:], k) + i = encodeVarint(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = encodeVarint(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.Queries) > 0 { + for iNdEx := len(m.Queries) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Queries[iNdEx]) + copy(dAtA[i:], m.Queries[iNdEx]) + i = encodeVarint(dAtA, i, uint64(len(m.Queries[iNdEx]))) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Schema) > 0 { + for iNdEx := len(m.Schema) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Schema[iNdEx]) + copy(dAtA[i:], m.Schema[iNdEx]) + i = encodeVarint(dAtA, i, uint64(len(m.Schema[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + if len(m.Engine) > 0 { + i -= len(m.Engine) + copy(dAtA[i:], m.Engine) + i = encodeVarint(dAtA, i, uint64(len(m.Engine))) + i-- + dAtA[i] = 0x12 + } + if len(m.Version) > 0 { + i -= len(m.Version) + copy(dAtA[i:], m.Version) + i = encodeVarint(dAtA, i, uint64(len(m.Version))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Codegen) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Codegen) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Codegen) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Options) > 0 { + i -= len(m.Options) + copy(dAtA[i:], m.Options) + i = encodeVarint(dAtA, i, uint64(len(m.Options))) + i-- + dAtA[i] = 0x1a + } + if len(m.Plugin) > 0 { + i -= len(m.Plugin) + copy(dAtA[i:], m.Plugin) + i = encodeVarint(dAtA, i, uint64(len(m.Plugin))) + i-- + dAtA[i] = 0x12 + } + if len(m.Out) > 0 { + i -= len(m.Out) + copy(dAtA[i:], m.Out) + i = encodeVarint(dAtA, i, uint64(len(m.Out))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GoCode) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GoCode) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *GoCode) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.SqlDriver) > 0 { + i -= len(m.SqlDriver) + copy(dAtA[i:], m.SqlDriver) + i = encodeVarint(dAtA, i, uint64(len(m.SqlDriver))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xca + } + if len(m.OutputBatchFileName) > 0 { + i -= len(m.OutputBatchFileName) + copy(dAtA[i:], m.OutputBatchFileName) + i = encodeVarint(dAtA, i, uint64(len(m.OutputBatchFileName))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xc2 + } + if m.QueryParameterLimit != nil { + i = encodeVarint(dAtA, i, uint64(*m.QueryParameterLimit)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb8 + } + if m.EmitPointersForNullTypes { + i-- + if m.EmitPointersForNullTypes { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb0 + } + if len(m.InflectionExcludeTableNames) > 0 { + for iNdEx := len(m.InflectionExcludeTableNames) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.InflectionExcludeTableNames[iNdEx]) + copy(dAtA[i:], m.InflectionExcludeTableNames[iNdEx]) + i = encodeVarint(dAtA, i, uint64(len(m.InflectionExcludeTableNames[iNdEx]))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xaa + } + } + if m.EmitAllEnumValues { + i-- + if m.EmitAllEnumValues { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa0 + } + if m.EmitEnumValidMethod { + i-- + if m.EmitEnumValidMethod { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x98 + } + if len(m.OutputFilesSuffix) > 0 { + i -= len(m.OutputFilesSuffix) + copy(dAtA[i:], m.OutputFilesSuffix) + i = encodeVarint(dAtA, i, uint64(len(m.OutputFilesSuffix))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x92 + } + if len(m.OutputQuerierFileName) > 0 { + i -= len(m.OutputQuerierFileName) + copy(dAtA[i:], m.OutputQuerierFileName) + i = encodeVarint(dAtA, i, uint64(len(m.OutputQuerierFileName))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } + if len(m.OutputModelsFileName) > 0 { + i -= len(m.OutputModelsFileName) + copy(dAtA[i:], m.OutputModelsFileName) + i = encodeVarint(dAtA, i, uint64(len(m.OutputModelsFileName))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + if len(m.OutputDbFileName) > 0 { + i -= len(m.OutputDbFileName) + copy(dAtA[i:], m.OutputDbFileName) + i = encodeVarint(dAtA, i, uint64(len(m.OutputDbFileName))) + i-- + dAtA[i] = 0x7a + } + if len(m.SqlPackage) > 0 { + i -= len(m.SqlPackage) + copy(dAtA[i:], m.SqlPackage) + i = encodeVarint(dAtA, i, uint64(len(m.SqlPackage))) + i-- + dAtA[i] = 0x72 + } + if len(m.Out) > 0 { + i -= len(m.Out) + copy(dAtA[i:], m.Out) + i = encodeVarint(dAtA, i, uint64(len(m.Out))) + i-- + dAtA[i] = 0x6a + } + if len(m.Package) > 0 { + i -= len(m.Package) + copy(dAtA[i:], m.Package) + i = encodeVarint(dAtA, i, uint64(len(m.Package))) + i-- + dAtA[i] = 0x62 + } + if len(m.JsonTagsCaseStyle) > 0 { + i -= len(m.JsonTagsCaseStyle) + copy(dAtA[i:], m.JsonTagsCaseStyle) + i = encodeVarint(dAtA, i, uint64(len(m.JsonTagsCaseStyle))) + i-- + dAtA[i] = 0x5a + } + if m.EmitMethodsWithDbArgument { + i-- + if m.EmitMethodsWithDbArgument { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x50 + } + if m.EmitParamsStructPointers { + i-- + if m.EmitParamsStructPointers { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x48 + } + if m.EmitResultStructPointers { + i-- + if m.EmitResultStructPointers { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x40 + } + if m.EmitExportedQueries { + i-- + if m.EmitExportedQueries { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x38 + } + if m.EmitEmptySlices { + i-- + if m.EmitEmptySlices { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x30 + } + if m.EmitExactTableNames { + i-- + if m.EmitExactTableNames { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x28 + } + if m.EmitPreparedQueries { + i-- + if m.EmitPreparedQueries { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if m.EmitDbTags { + i-- + if m.EmitDbTags { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if m.EmitJsonTags { + i-- + if m.EmitJsonTags { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if m.EmitInterface { + i-- + if m.EmitInterface { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *JSONCode) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *JSONCode) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *JSONCode) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Filename) > 0 { + i -= len(m.Filename) + copy(dAtA[i:], m.Filename) + i = encodeVarint(dAtA, i, uint64(len(m.Filename))) + i-- + dAtA[i] = 0x1a + } + if len(m.Indent) > 0 { + i -= len(m.Indent) + copy(dAtA[i:], m.Indent) + i = encodeVarint(dAtA, i, uint64(len(m.Indent))) + i-- + dAtA[i] = 0x12 + } + if len(m.Out) > 0 { + i -= len(m.Out) + copy(dAtA[i:], m.Out) + i = encodeVarint(dAtA, i, uint64(len(m.Out))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Catalog) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Catalog) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Catalog) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Schemas) > 0 { + for iNdEx := len(m.Schemas) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Schemas[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x1a + } + if len(m.DefaultSchema) > 0 { + i -= len(m.DefaultSchema) + copy(dAtA[i:], m.DefaultSchema) + i = encodeVarint(dAtA, i, uint64(len(m.DefaultSchema))) + i-- + dAtA[i] = 0x12 + } + if len(m.Comment) > 0 { + i -= len(m.Comment) + copy(dAtA[i:], m.Comment) + i = encodeVarint(dAtA, i, uint64(len(m.Comment))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Schema) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Schema) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Schema) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.CompositeTypes) > 0 { + for iNdEx := len(m.CompositeTypes) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.CompositeTypes[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.Enums) > 0 { + for iNdEx := len(m.Enums) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Enums[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Tables) > 0 { + for iNdEx := len(m.Tables) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Tables[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x12 + } + if len(m.Comment) > 0 { + i -= len(m.Comment) + copy(dAtA[i:], m.Comment) + i = encodeVarint(dAtA, i, uint64(len(m.Comment))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CompositeType) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CompositeType) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CompositeType) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Comment) > 0 { + i -= len(m.Comment) + copy(dAtA[i:], m.Comment) + i = encodeVarint(dAtA, i, uint64(len(m.Comment))) + i-- + dAtA[i] = 0x12 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Enum) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Enum) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Enum) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Comment) > 0 { + i -= len(m.Comment) + copy(dAtA[i:], m.Comment) + i = encodeVarint(dAtA, i, uint64(len(m.Comment))) + i-- + dAtA[i] = 0x1a + } + if len(m.Vals) > 0 { + for iNdEx := len(m.Vals) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Vals[iNdEx]) + copy(dAtA[i:], m.Vals[iNdEx]) + i = encodeVarint(dAtA, i, uint64(len(m.Vals[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Table) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Table) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Table) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Comment) > 0 { + i -= len(m.Comment) + copy(dAtA[i:], m.Comment) + i = encodeVarint(dAtA, i, uint64(len(m.Comment))) + i-- + dAtA[i] = 0x1a + } + if len(m.Columns) > 0 { + for iNdEx := len(m.Columns) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Columns[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + } + if m.Rel != nil { + size, err := m.Rel.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Identifier) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Identifier) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Identifier) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x1a + } + if len(m.Schema) > 0 { + i -= len(m.Schema) + copy(dAtA[i:], m.Schema) + i = encodeVarint(dAtA, i, uint64(len(m.Schema))) + i-- + dAtA[i] = 0x12 + } + if len(m.Catalog) > 0 { + i -= len(m.Catalog) + copy(dAtA[i:], m.Catalog) + i = encodeVarint(dAtA, i, uint64(len(m.Catalog))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Column) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Column) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Column) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.EmbedTable != nil { + size, err := m.EmbedTable.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x72 + } + if m.IsSqlcSlice { + i-- + if m.IsSqlcSlice { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x68 + } + if m.Type != nil { + size, err := m.Type.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x62 + } + if len(m.TableAlias) > 0 { + i -= len(m.TableAlias) + copy(dAtA[i:], m.TableAlias) + i = encodeVarint(dAtA, i, uint64(len(m.TableAlias))) + i-- + dAtA[i] = 0x5a + } + if m.Table != nil { + size, err := m.Table.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x52 + } + if len(m.Scope) > 0 { + i -= len(m.Scope) + copy(dAtA[i:], m.Scope) + i = encodeVarint(dAtA, i, uint64(len(m.Scope))) + i-- + dAtA[i] = 0x4a + } + if m.IsFuncCall { + i-- + if m.IsFuncCall { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x40 + } + if m.IsNamedParam { + i-- + if m.IsNamedParam { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x38 + } + if m.Length != 0 { + i = encodeVarint(dAtA, i, uint64(m.Length)) + i-- + dAtA[i] = 0x30 + } + if len(m.Comment) > 0 { + i -= len(m.Comment) + copy(dAtA[i:], m.Comment) + i = encodeVarint(dAtA, i, uint64(len(m.Comment))) + i-- + dAtA[i] = 0x2a + } + if m.IsArray { + i-- + if m.IsArray { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if m.NotNull { + i-- + if m.NotNull { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Query) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Query) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Query) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.InsertIntoTable != nil { + size, err := m.InsertIntoTable.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x42 + } + if len(m.Filename) > 0 { + i -= len(m.Filename) + copy(dAtA[i:], m.Filename) + i = encodeVarint(dAtA, i, uint64(len(m.Filename))) + i-- + dAtA[i] = 0x3a + } + if len(m.Comments) > 0 { + for iNdEx := len(m.Comments) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Comments[iNdEx]) + copy(dAtA[i:], m.Comments[iNdEx]) + i = encodeVarint(dAtA, i, uint64(len(m.Comments[iNdEx]))) + i-- + dAtA[i] = 0x32 + } + } + if len(m.Params) > 0 { + for iNdEx := len(m.Params) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Params[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + } + if len(m.Columns) > 0 { + for iNdEx := len(m.Columns) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Columns[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + } + if len(m.Cmd) > 0 { + i -= len(m.Cmd) + copy(dAtA[i:], m.Cmd) + i = encodeVarint(dAtA, i, uint64(len(m.Cmd))) + i-- + dAtA[i] = 0x1a + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarint(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x12 + } + if len(m.Text) > 0 { + i -= len(m.Text) + copy(dAtA[i:], m.Text) + i = encodeVarint(dAtA, i, uint64(len(m.Text))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Parameter) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Parameter) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *Parameter) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.Column != nil { + size, err := m.Column.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Number != 0 { + i = encodeVarint(dAtA, i, uint64(m.Number)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *CodeGenRequest) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CodeGenRequest) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *CodeGenRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.PluginOptions) > 0 { + i -= len(m.PluginOptions) + copy(dAtA[i:], m.PluginOptions) + i = encodeVarint(dAtA, i, uint64(len(m.PluginOptions))) + i-- + dAtA[i] = 0x2a + } + if len(m.SqlcVersion) > 0 { + i -= len(m.SqlcVersion) + copy(dAtA[i:], m.SqlcVersion) + i = encodeVarint(dAtA, i, uint64(len(m.SqlcVersion))) + i-- + dAtA[i] = 0x22 + } + if len(m.Queries) > 0 { + for iNdEx := len(m.Queries) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Queries[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + } + if m.Catalog != nil { + size, err := m.Catalog.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Settings != nil { + size, err := m.Settings.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa } - if this.Filename != that.Filename { - return false - } - if !this.InsertIntoTable.EqualVT(that.InsertIntoTable) { - return false - } - return string(this.unknownFields) == string(that.unknownFields) + return len(dAtA) - i, nil } -func (this *Parameter) EqualVT(that *Parameter) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" - } - if this.Number != that.Number { - return false +func (m *CodeGenResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil } - if !this.Column.EqualVT(that.Column) { - return false + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err } - return string(this.unknownFields) == string(that.unknownFields) + return dAtA[:n], nil } -func (this *CodeGenRequest) EqualVT(that *CodeGenRequest) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" - } - if !this.Settings.EqualVT(that.Settings) { - return false - } - if !this.Catalog.EqualVT(that.Catalog) { - return false - } - if len(this.Queries) != len(that.Queries) { - return false - } - for i := range this.Queries { - if !this.Queries[i].EqualVT(that.Queries[i]) { - return false - } - } - if this.SqlcVersion != that.SqlcVersion { - return false - } - if string(this.PluginOptions) != string(that.PluginOptions) { - return false - } - return string(this.unknownFields) == string(that.unknownFields) +func (m *CodeGenResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (this *CodeGenResponse) EqualVT(that *CodeGenResponse) bool { - if this == nil { - return that == nil || fmt.Sprintf("%v", that) == "" - } else if that == nil { - return fmt.Sprintf("%v", this) == "" +func (m *CodeGenResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil } - if len(this.Files) != len(that.Files) { - return false + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) } - for i := range this.Files { - if !this.Files[i].EqualVT(that.Files[i]) { - return false + if len(m.Files) > 0 { + for iNdEx := len(m.Files) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Files[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa } } - return string(this.unknownFields) == string(that.unknownFields) + return len(dAtA) - i, nil } -func (m *File) MarshalVT() (dAtA []byte, err error) { +func encodeVarint(dAtA []byte, offset int, v uint64) int { + offset -= sov(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *File) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *File) MarshalToVT(dAtA []byte) (int, error) { +func (m *File) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *File) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *File) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -621,25 +2889,25 @@ func (m *File) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Override) MarshalVT() (dAtA []byte, err error) { +func (m *Override) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *Override) MarshalToVT(dAtA []byte) (int, error) { +func (m *Override) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *Override) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *Override) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -652,7 +2920,7 @@ func (m *Override) MarshalToSizedBufferVT(dAtA []byte) (int, error) { copy(dAtA[i:], m.unknownFields) } if m.GoType != nil { - size, err := m.GoType.MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.GoType.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -669,7 +2937,7 @@ func (m *Override) MarshalToSizedBufferVT(dAtA []byte) (int, error) { dAtA[i] = 0x42 } if m.Table != nil { - size, err := m.Table.MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Table.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -712,25 +2980,25 @@ func (m *Override) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *ParsedGoType) MarshalVT() (dAtA []byte, err error) { +func (m *ParsedGoType) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *ParsedGoType) MarshalToVT(dAtA []byte) (int, error) { +func (m *ParsedGoType) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *ParsedGoType) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *ParsedGoType) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -795,25 +3063,25 @@ func (m *ParsedGoType) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Settings) MarshalVT() (dAtA []byte, err error) { +func (m *Settings) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *Settings) MarshalToVT(dAtA []byte) (int, error) { +func (m *Settings) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *Settings) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *Settings) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -826,7 +3094,7 @@ func (m *Settings) MarshalToSizedBufferVT(dAtA []byte) (int, error) { copy(dAtA[i:], m.unknownFields) } if m.Codegen != nil { - size, err := m.Codegen.MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Codegen.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -836,7 +3104,7 @@ func (m *Settings) MarshalToSizedBufferVT(dAtA []byte) (int, error) { dAtA[i] = 0x62 } if m.Json != nil { - size, err := m.Json.MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Json.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -846,7 +3114,7 @@ func (m *Settings) MarshalToSizedBufferVT(dAtA []byte) (int, error) { dAtA[i] = 0x5a } if m.Go != nil { - size, err := m.Go.MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Go.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -857,7 +3125,7 @@ func (m *Settings) MarshalToSizedBufferVT(dAtA []byte) (int, error) { } if len(m.Overrides) > 0 { for iNdEx := len(m.Overrides) - 1; iNdEx >= 0; iNdEx-- { - size, err := m.Overrides[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Overrides[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -921,25 +3189,25 @@ func (m *Settings) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Codegen) MarshalVT() (dAtA []byte, err error) { +func (m *Codegen) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *Codegen) MarshalToVT(dAtA []byte) (int, error) { +func (m *Codegen) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *Codegen) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *Codegen) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -975,25 +3243,25 @@ func (m *Codegen) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *GoCode) MarshalVT() (dAtA []byte, err error) { +func (m *GoCode) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *GoCode) MarshalToVT(dAtA []byte) (int, error) { +func (m *GoCode) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *GoCode) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *GoCode) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1242,25 +3510,25 @@ func (m *GoCode) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *JSONCode) MarshalVT() (dAtA []byte, err error) { +func (m *JSONCode) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *JSONCode) MarshalToVT(dAtA []byte) (int, error) { +func (m *JSONCode) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *JSONCode) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *JSONCode) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1296,25 +3564,25 @@ func (m *JSONCode) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Catalog) MarshalVT() (dAtA []byte, err error) { +func (m *Catalog) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *Catalog) MarshalToVT(dAtA []byte) (int, error) { +func (m *Catalog) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *Catalog) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *Catalog) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1328,7 +3596,7 @@ func (m *Catalog) MarshalToSizedBufferVT(dAtA []byte) (int, error) { } if len(m.Schemas) > 0 { for iNdEx := len(m.Schemas) - 1; iNdEx >= 0; iNdEx-- { - size, err := m.Schemas[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Schemas[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -1362,25 +3630,25 @@ func (m *Catalog) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Schema) MarshalVT() (dAtA []byte, err error) { +func (m *Schema) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *Schema) MarshalToVT(dAtA []byte) (int, error) { +func (m *Schema) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *Schema) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *Schema) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1394,7 +3662,7 @@ func (m *Schema) MarshalToSizedBufferVT(dAtA []byte) (int, error) { } if len(m.CompositeTypes) > 0 { for iNdEx := len(m.CompositeTypes) - 1; iNdEx >= 0; iNdEx-- { - size, err := m.CompositeTypes[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.CompositeTypes[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -1406,7 +3674,7 @@ func (m *Schema) MarshalToSizedBufferVT(dAtA []byte) (int, error) { } if len(m.Enums) > 0 { for iNdEx := len(m.Enums) - 1; iNdEx >= 0; iNdEx-- { - size, err := m.Enums[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Enums[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -1418,7 +3686,7 @@ func (m *Schema) MarshalToSizedBufferVT(dAtA []byte) (int, error) { } if len(m.Tables) > 0 { for iNdEx := len(m.Tables) - 1; iNdEx >= 0; iNdEx-- { - size, err := m.Tables[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Tables[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -1445,25 +3713,25 @@ func (m *Schema) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *CompositeType) MarshalVT() (dAtA []byte, err error) { +func (m *CompositeType) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *CompositeType) MarshalToVT(dAtA []byte) (int, error) { +func (m *CompositeType) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *CompositeType) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *CompositeType) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1492,25 +3760,25 @@ func (m *CompositeType) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Enum) MarshalVT() (dAtA []byte, err error) { +func (m *Enum) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *Enum) MarshalToVT(dAtA []byte) (int, error) { +func (m *Enum) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *Enum) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *Enum) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1548,25 +3816,25 @@ func (m *Enum) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Table) MarshalVT() (dAtA []byte, err error) { +func (m *Table) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *Table) MarshalToVT(dAtA []byte) (int, error) { +func (m *Table) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *Table) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *Table) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1587,7 +3855,7 @@ func (m *Table) MarshalToSizedBufferVT(dAtA []byte) (int, error) { } if len(m.Columns) > 0 { for iNdEx := len(m.Columns) - 1; iNdEx >= 0; iNdEx-- { - size, err := m.Columns[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Columns[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -1598,7 +3866,7 @@ func (m *Table) MarshalToSizedBufferVT(dAtA []byte) (int, error) { } } if m.Rel != nil { - size, err := m.Rel.MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Rel.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -1610,25 +3878,25 @@ func (m *Table) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Identifier) MarshalVT() (dAtA []byte, err error) { +func (m *Identifier) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *Identifier) MarshalToVT(dAtA []byte) (int, error) { +func (m *Identifier) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *Identifier) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *Identifier) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1664,25 +3932,25 @@ func (m *Identifier) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Column) MarshalVT() (dAtA []byte, err error) { +func (m *Column) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *Column) MarshalToVT(dAtA []byte) (int, error) { +func (m *Column) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *Column) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *Column) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1695,7 +3963,7 @@ func (m *Column) MarshalToSizedBufferVT(dAtA []byte) (int, error) { copy(dAtA[i:], m.unknownFields) } if m.EmbedTable != nil { - size, err := m.EmbedTable.MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.EmbedTable.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -1715,7 +3983,7 @@ func (m *Column) MarshalToSizedBufferVT(dAtA []byte) (int, error) { dAtA[i] = 0x68 } if m.Type != nil { - size, err := m.Type.MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Type.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -1732,7 +4000,7 @@ func (m *Column) MarshalToSizedBufferVT(dAtA []byte) (int, error) { dAtA[i] = 0x5a } if m.Table != nil { - size, err := m.Table.MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Table.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -1810,25 +4078,25 @@ func (m *Column) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Query) MarshalVT() (dAtA []byte, err error) { +func (m *Query) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *Query) MarshalToVT(dAtA []byte) (int, error) { +func (m *Query) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *Query) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *Query) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1841,7 +4109,7 @@ func (m *Query) MarshalToSizedBufferVT(dAtA []byte) (int, error) { copy(dAtA[i:], m.unknownFields) } if m.InsertIntoTable != nil { - size, err := m.InsertIntoTable.MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.InsertIntoTable.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -1868,7 +4136,7 @@ func (m *Query) MarshalToSizedBufferVT(dAtA []byte) (int, error) { } if len(m.Params) > 0 { for iNdEx := len(m.Params) - 1; iNdEx >= 0; iNdEx-- { - size, err := m.Params[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Params[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -1880,7 +4148,7 @@ func (m *Query) MarshalToSizedBufferVT(dAtA []byte) (int, error) { } if len(m.Columns) > 0 { for iNdEx := len(m.Columns) - 1; iNdEx >= 0; iNdEx-- { - size, err := m.Columns[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Columns[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -1914,25 +4182,25 @@ func (m *Query) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Parameter) MarshalVT() (dAtA []byte, err error) { +func (m *Parameter) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *Parameter) MarshalToVT(dAtA []byte) (int, error) { +func (m *Parameter) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *Parameter) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *Parameter) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1945,7 +4213,7 @@ func (m *Parameter) MarshalToSizedBufferVT(dAtA []byte) (int, error) { copy(dAtA[i:], m.unknownFields) } if m.Column != nil { - size, err := m.Column.MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Column.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -1962,25 +4230,25 @@ func (m *Parameter) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *CodeGenRequest) MarshalVT() (dAtA []byte, err error) { +func (m *CodeGenRequest) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *CodeGenRequest) MarshalToVT(dAtA []byte) (int, error) { +func (m *CodeGenRequest) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *CodeGenRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *CodeGenRequest) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -2008,7 +4276,7 @@ func (m *CodeGenRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { } if len(m.Queries) > 0 { for iNdEx := len(m.Queries) - 1; iNdEx >= 0; iNdEx-- { - size, err := m.Queries[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Queries[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -2019,7 +4287,7 @@ func (m *CodeGenRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { } } if m.Catalog != nil { - size, err := m.Catalog.MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Catalog.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -2029,7 +4297,7 @@ func (m *CodeGenRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { dAtA[i] = 0x12 } if m.Settings != nil { - size, err := m.Settings.MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Settings.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -2041,25 +4309,25 @@ func (m *CodeGenRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *CodeGenResponse) MarshalVT() (dAtA []byte, err error) { +func (m *CodeGenResponse) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } -func (m *CodeGenResponse) MarshalToVT(dAtA []byte) (int, error) { +func (m *CodeGenResponse) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) + return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } -func (m *CodeGenResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *CodeGenResponse) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -2073,7 +4341,7 @@ func (m *CodeGenResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { } if len(m.Files) > 0 { for iNdEx := len(m.Files) - 1; iNdEx >= 0; iNdEx-- { - size, err := m.Files[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + size, err := m.Files[iNdEx].MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } @@ -2086,17 +4354,6 @@ func (m *CodeGenResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func encodeVarint(dAtA []byte, offset int, v uint64) int { - offset -= sov(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} func (m *File) SizeVT() (n int) { if m == nil { return 0 @@ -2111,9 +4368,7 @@ func (m *File) SizeVT() (n int) { if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -2150,9 +4405,7 @@ func (m *Override) SizeVT() (n int) { l = m.GoType.SizeVT() n += 1 + l + sov(uint64(l)) } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -2185,9 +4438,7 @@ func (m *ParsedGoType) SizeVT() (n int) { n += mapEntrySize + 1 + sov(uint64(mapEntrySize)) } } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -2243,9 +4494,7 @@ func (m *Settings) SizeVT() (n int) { l = m.Codegen.SizeVT() n += 1 + l + sov(uint64(l)) } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -2267,9 +4516,7 @@ func (m *Codegen) SizeVT() (n int) { if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -2367,9 +4614,7 @@ func (m *GoCode) SizeVT() (n int) { if l > 0 { n += 2 + l + sov(uint64(l)) } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -2391,9 +4636,7 @@ func (m *JSONCode) SizeVT() (n int) { if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -2421,9 +4664,7 @@ func (m *Catalog) SizeVT() (n int) { n += 1 + l + sov(uint64(l)) } } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -2459,9 +4700,7 @@ func (m *Schema) SizeVT() (n int) { n += 1 + l + sov(uint64(l)) } } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -2479,9 +4718,7 @@ func (m *CompositeType) SizeVT() (n int) { if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -2505,9 +4742,7 @@ func (m *Enum) SizeVT() (n int) { if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -2531,9 +4766,7 @@ func (m *Table) SizeVT() (n int) { if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -2555,9 +4788,7 @@ func (m *Identifier) SizeVT() (n int) { if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -2613,9 +4844,7 @@ func (m *Column) SizeVT() (n int) { l = m.EmbedTable.SizeVT() n += 1 + l + sov(uint64(l)) } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -2663,9 +4892,7 @@ func (m *Query) SizeVT() (n int) { l = m.InsertIntoTable.SizeVT() n += 1 + l + sov(uint64(l)) } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -2682,9 +4909,7 @@ func (m *Parameter) SizeVT() (n int) { l = m.Column.SizeVT() n += 1 + l + sov(uint64(l)) } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -2716,9 +4941,7 @@ func (m *CodeGenRequest) SizeVT() (n int) { if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -2734,9 +4957,7 @@ func (m *CodeGenResponse) SizeVT() (n int) { n += 1 + l + sov(uint64(l)) } } - if m.unknownFields != nil { - n += len(m.unknownFields) - } + n += len(m.unknownFields) return n } @@ -6950,6 +9171,7 @@ func (m *CodeGenResponse) UnmarshalVT(dAtA []byte) error { } return nil } + func skip(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0