github.com/cockroachdb/cockroach@v20.2.0-alpha.1+incompatible/pkg/roachpb/io-formats.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: roachpb/io-formats.proto

package roachpb

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"

import io "io"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type IOFileFormat_FileFormat int32

const (
	IOFileFormat_Unknown      IOFileFormat_FileFormat = 0
	IOFileFormat_CSV          IOFileFormat_FileFormat = 1
	IOFileFormat_MysqlOutfile IOFileFormat_FileFormat = 2
	IOFileFormat_Mysqldump    IOFileFormat_FileFormat = 3
	IOFileFormat_PgCopy       IOFileFormat_FileFormat = 4
	IOFileFormat_PgDump       IOFileFormat_FileFormat = 5
	IOFileFormat_Avro         IOFileFormat_FileFormat = 6
)

var IOFileFormat_FileFormat_name = map[int32]string{
	0: "Unknown",
	1: "CSV",
	2: "MysqlOutfile",
	3: "Mysqldump",
	4: "PgCopy",
	5: "PgDump",
	6: "Avro",
}
var IOFileFormat_FileFormat_value = map[string]int32{
	"Unknown":      0,
	"CSV":          1,
	"MysqlOutfile": 2,
	"Mysqldump":    3,
	"PgCopy":       4,
	"PgDump":       5,
	"Avro":         6,
}

func (x IOFileFormat_FileFormat) Enum() *IOFileFormat_FileFormat {
	p := new(IOFileFormat_FileFormat)
	*p = x
	return p
}
func (x IOFileFormat_FileFormat) String() string {
	return proto.EnumName(IOFileFormat_FileFormat_name, int32(x))
}
func (x *IOFileFormat_FileFormat) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(IOFileFormat_FileFormat_value, data, "IOFileFormat_FileFormat")
	if err != nil {
		return err
	}
	*x = IOFileFormat_FileFormat(value)
	return nil
}
func (IOFileFormat_FileFormat) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_io_formats_e2ffeab7714b237d, []int{0, 0}
}

type IOFileFormat_Compression int32

const (
	IOFileFormat_Auto IOFileFormat_Compression = 0
	IOFileFormat_None IOFileFormat_Compression = 1
	IOFileFormat_Gzip IOFileFormat_Compression = 2
	IOFileFormat_Bzip IOFileFormat_Compression = 3
)

var IOFileFormat_Compression_name = map[int32]string{
	0: "Auto",
	1: "None",
	2: "Gzip",
	3: "Bzip",
}
var IOFileFormat_Compression_value = map[string]int32{
	"Auto": 0,
	"None": 1,
	"Gzip": 2,
	"Bzip": 3,
}

func (x IOFileFormat_Compression) Enum() *IOFileFormat_Compression {
	p := new(IOFileFormat_Compression)
	*p = x
	return p
}
func (x IOFileFormat_Compression) String() string {
	return proto.EnumName(IOFileFormat_Compression_name, int32(x))
}
func (x *IOFileFormat_Compression) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(IOFileFormat_Compression_value, data, "IOFileFormat_Compression")
	if err != nil {
		return err
	}
	*x = IOFileFormat_Compression(value)
	return nil
}
func (IOFileFormat_Compression) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_io_formats_e2ffeab7714b237d, []int{0, 1}
}

type MySQLOutfileOptions_Enclose int32

const (
	MySQLOutfileOptions_Never    MySQLOutfileOptions_Enclose = 0
	MySQLOutfileOptions_Always   MySQLOutfileOptions_Enclose = 1
	MySQLOutfileOptions_Optional MySQLOutfileOptions_Enclose = 2
)

var MySQLOutfileOptions_Enclose_name = map[int32]string{
	0: "Never",
	1: "Always",
	2: "Optional",
}
var MySQLOutfileOptions_Enclose_value = map[string]int32{
	"Never":    0,
	"Always":   1,
	"Optional": 2,
}

func (x MySQLOutfileOptions_Enclose) Enum() *MySQLOutfileOptions_Enclose {
	p := new(MySQLOutfileOptions_Enclose)
	*p = x
	return p
}
func (x MySQLOutfileOptions_Enclose) String() string {
	return proto.EnumName(MySQLOutfileOptions_Enclose_name, int32(x))
}
func (x *MySQLOutfileOptions_Enclose) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(MySQLOutfileOptions_Enclose_value, data, "MySQLOutfileOptions_Enclose")
	if err != nil {
		return err
	}
	*x = MySQLOutfileOptions_Enclose(value)
	return nil
}
func (MySQLOutfileOptions_Enclose) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_io_formats_e2ffeab7714b237d, []int{2, 0}
}

type AvroOptions_Format int32

const (
	// Avro object container file input
	AvroOptions_OCF AvroOptions_Format = 0
	// Input file contains avro binary encoded records; one record per line
	AvroOptions_BIN_RECORDS AvroOptions_Format = 1
	// Input file contains avro JSON encoded records; one record per line
	AvroOptions_JSON_RECORDS AvroOptions_Format = 2
)

var AvroOptions_Format_name = map[int32]string{
	0: "OCF",
	1: "BIN_RECORDS",
	2: "JSON_RECORDS",
}
var AvroOptions_Format_value = map[string]int32{
	"OCF":          0,
	"BIN_RECORDS":  1,
	"JSON_RECORDS": 2,
}

func (x AvroOptions_Format) Enum() *AvroOptions_Format {
	p := new(AvroOptions_Format)
	*p = x
	return p
}
func (x AvroOptions_Format) String() string {
	return proto.EnumName(AvroOptions_Format_name, int32(x))
}
func (x *AvroOptions_Format) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(AvroOptions_Format_value, data, "AvroOptions_Format")
	if err != nil {
		return err
	}
	*x = AvroOptions_Format(value)
	return nil
}
func (AvroOptions_Format) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_io_formats_e2ffeab7714b237d, []int{5, 0}
}

type IOFileFormat struct {
	Format      IOFileFormat_FileFormat  `protobuf:"varint,1,opt,name=format,enum=cockroach.roachpb.IOFileFormat_FileFormat" json:"format"`
	Csv         CSVOptions               `protobuf:"bytes,2,opt,name=csv" json:"csv"`
	MysqlOut    MySQLOutfileOptions      `protobuf:"bytes,3,opt,name=mysql_out,json=mysqlOut" json:"mysql_out"`
	PgCopy      PgCopyOptions            `protobuf:"bytes,4,opt,name=pg_copy,json=pgCopy" json:"pg_copy"`
	PgDump      PgDumpOptions            `protobuf:"bytes,6,opt,name=pg_dump,json=pgDump" json:"pg_dump"`
	Avro        AvroOptions              `protobuf:"bytes,8,opt,name=avro" json:"avro"`
	Compression IOFileFormat_Compression `protobuf:"varint,5,opt,name=compression,enum=cockroach.roachpb.IOFileFormat_Compression" json:"compression"`
	// If true, don't abort on failures but instead save the offending row and keep on.
	SaveRejected bool `protobuf:"varint,7,opt,name=save_rejected,json=saveRejected" json:"save_rejected"`
}

func (m *IOFileFormat) Reset()         { *m = IOFileFormat{} }
func (m *IOFileFormat) String() string { return proto.CompactTextString(m) }
func (*IOFileFormat) ProtoMessage()    {}
func (*IOFileFormat) Descriptor() ([]byte, []int) {
	return fileDescriptor_io_formats_e2ffeab7714b237d, []int{0}
}
func (m *IOFileFormat) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IOFileFormat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *IOFileFormat) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IOFileFormat.Merge(dst, src)
}
func (m *IOFileFormat) XXX_Size() int {
	return m.Size()
}
func (m *IOFileFormat) XXX_DiscardUnknown() {
	xxx_messageInfo_IOFileFormat.DiscardUnknown(m)
}

var xxx_messageInfo_IOFileFormat proto.InternalMessageInfo

// CSVOptions describe the format of csv data (delimiter, comment, etc).
type CSVOptions struct {
	// comma is an delimiter used by the CSV file; defaults to a comma.
	Comma int32 `protobuf:"varint,1,opt,name=comma" json:"comma"`
	// comment is an comment rune; zero value means comments not enabled.
	Comment int32 `protobuf:"varint,2,opt,name=comment" json:"comment"`
	// null_encoding, if not nil, is the string which identifies a NULL. Can be the empty string.
	NullEncoding *string `protobuf:"bytes,3,opt,name=null_encoding,json=nullEncoding" json:"null_encoding,omitempty"`
	// skip the first N lines of the input (e.g. to ignore column headers) when reading.
	Skip uint32 `protobuf:"varint,4,opt,name=skip" json:"skip"`
	// If strict_quotes is true, a quote may NOT appear in an unquoted field and a
	// non-doubled quote may NOT appear in a quoted field.
	StrictQuotes bool `protobuf:"varint,5,opt,name=strict_quotes,json=strictQuotes" json:"strict_quotes"`
}

func (m *CSVOptions) Reset()         { *m = CSVOptions{} }
func (m *CSVOptions) String() string { return proto.CompactTextString(m) }
func (*CSVOptions) ProtoMessage()    {}
func (*CSVOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_io_formats_e2ffeab7714b237d, []int{1}
}
func (m *CSVOptions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CSVOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *CSVOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CSVOptions.Merge(dst, src)
}
func (m *CSVOptions) XXX_Size() int {
	return m.Size()
}
func (m *CSVOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_CSVOptions.DiscardUnknown(m)
}

var xxx_messageInfo_CSVOptions proto.InternalMessageInfo

// MySQLOutfileOptions describe the format of mysql's outfile.
type MySQLOutfileOptions struct {
	// row_separator is the delimiter between rows (mysql's --rows-terminated-by)
	RowSeparator int32 `protobuf:"varint,1,opt,name=row_separator,json=rowSeparator" json:"row_separator"`
	// field_separator is the delimiter between fields (mysql's --fields-terminated-by)
	FieldSeparator int32 `protobuf:"varint,2,opt,name=field_separator,json=fieldSeparator" json:"field_separator"`
	// enclose is the enclosing (quoting) behavior (i.e. if specified and if optional).
	Enclose MySQLOutfileOptions_Enclose `protobuf:"varint,3,opt,name=enclose,enum=cockroach.roachpb.MySQLOutfileOptions_Enclose" json:"enclose"`
	// encloser is the character used to enclose (qupte) fields (--fields-enclosed-by)
	Encloser int32 `protobuf:"varint,4,opt,name=encloser" json:"encloser"`
	// has_escape indicates that an escape character is set (mysql's default is not).
	HasEscape bool `protobuf:"varint,5,opt,name=has_escape,json=hasEscape" json:"has_escape"`
	// escape is the character used to prefix the other delimiters (--fields-escaped-by)
	Escape int32 `protobuf:"varint,6,opt,name=escape" json:"escape"`
	// skip the first N lines of the input (e.g. to ignore column headers) when reading.
	Skip uint32 `protobuf:"varint,7,opt,name=skip" json:"skip"`
	// null_encoding, if not nil, is the string which identifies a NULL. Can be the empty string.
	NullEncoding *string `protobuf:"bytes,8,opt,name=null_encoding,json=nullEncoding" json:"null_encoding,omitempty"`
}

func (m *MySQLOutfileOptions) Reset()         { *m = MySQLOutfileOptions{} }
func (m *MySQLOutfileOptions) String() string { return proto.CompactTextString(m) }
func (*MySQLOutfileOptions) ProtoMessage()    {}
func (*MySQLOutfileOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_io_formats_e2ffeab7714b237d, []int{2}
}
func (m *MySQLOutfileOptions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MySQLOutfileOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *MySQLOutfileOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MySQLOutfileOptions.Merge(dst, src)
}
func (m *MySQLOutfileOptions) XXX_Size() int {
	return m.Size()
}
func (m *MySQLOutfileOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_MySQLOutfileOptions.DiscardUnknown(m)
}

var xxx_messageInfo_MySQLOutfileOptions proto.InternalMessageInfo

// PgCopyOptions describe the format of postgresql's COPY TO STDOUT.
type PgCopyOptions struct {
	// delimiter is the delimitor between columns (DELIMITER)
	Delimiter int32 `protobuf:"varint,1,opt,name=delimiter" json:"delimiter"`
	// null is the NULL value (NULL)
	Null string `protobuf:"bytes,2,opt,name=null" json:"null"`
	// maxRowSize is the maximum row size
	MaxRowSize int32 `protobuf:"varint,3,opt,name=maxRowSize" json:"maxRowSize"`
}

func (m *PgCopyOptions) Reset()         { *m = PgCopyOptions{} }
func (m *PgCopyOptions) String() string { return proto.CompactTextString(m) }
func (*PgCopyOptions) ProtoMessage()    {}
func (*PgCopyOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_io_formats_e2ffeab7714b237d, []int{3}
}
func (m *PgCopyOptions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PgCopyOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *PgCopyOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PgCopyOptions.Merge(dst, src)
}
func (m *PgCopyOptions) XXX_Size() int {
	return m.Size()
}
func (m *PgCopyOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_PgCopyOptions.DiscardUnknown(m)
}

var xxx_messageInfo_PgCopyOptions proto.InternalMessageInfo

// PgDumpOptions describe the format of postgresql's pg_dump.
type PgDumpOptions struct {
	// maxRowSize is the maximum row size
	MaxRowSize int32 `protobuf:"varint,1,opt,name=maxRowSize" json:"maxRowSize"`
}

func (m *PgDumpOptions) Reset()         { *m = PgDumpOptions{} }
func (m *PgDumpOptions) String() string { return proto.CompactTextString(m) }
func (*PgDumpOptions) ProtoMessage()    {}
func (*PgDumpOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_io_formats_e2ffeab7714b237d, []int{4}
}
func (m *PgDumpOptions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PgDumpOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *PgDumpOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PgDumpOptions.Merge(dst, src)
}
func (m *PgDumpOptions) XXX_Size() int {
	return m.Size()
}
func (m *PgDumpOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_PgDumpOptions.DiscardUnknown(m)
}

var xxx_messageInfo_PgDumpOptions proto.InternalMessageInfo

type AvroOptions struct {
	Format AvroOptions_Format `protobuf:"varint,1,opt,name=format,enum=cockroach.roachpb.AvroOptions_Format" json:"format"`
	// Strict mode import will reject avro records that do not have
	// a one-to-one mapping to our target schema.
	// The default is to ignore unknown avro fields, and to set any missing
	// columns to null value if they were not set in the avro record.
	StrictMode bool `protobuf:"varint,2,opt,name=strict_mode,json=strictMode" json:"strict_mode"`
	// Applicable for records only.
	SchemaJSON      string `protobuf:"bytes,3,opt,name=schemaJSON" json:"schemaJSON"`
	MaxRecordSize   int32  `protobuf:"varint,4,opt,name=max_record_size,json=maxRecordSize" json:"max_record_size"`
	RecordSeparator int32  `protobuf:"varint,5,opt,name=record_separator,json=recordSeparator" json:"record_separator"`
}

func (m *AvroOptions) Reset()         { *m = AvroOptions{} }
func (m *AvroOptions) String() string { return proto.CompactTextString(m) }
func (*AvroOptions) ProtoMessage()    {}
func (*AvroOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_io_formats_e2ffeab7714b237d, []int{5}
}
func (m *AvroOptions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AvroOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *AvroOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AvroOptions.Merge(dst, src)
}
func (m *AvroOptions) XXX_Size() int {
	return m.Size()
}
func (m *AvroOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_AvroOptions.DiscardUnknown(m)
}

var xxx_messageInfo_AvroOptions proto.InternalMessageInfo

func init() {
	proto.RegisterType((*IOFileFormat)(nil), "cockroach.roachpb.IOFileFormat")
	proto.RegisterType((*CSVOptions)(nil), "cockroach.roachpb.CSVOptions")
	proto.RegisterType((*MySQLOutfileOptions)(nil), "cockroach.roachpb.MySQLOutfileOptions")
	proto.RegisterType((*PgCopyOptions)(nil), "cockroach.roachpb.PgCopyOptions")
	proto.RegisterType((*PgDumpOptions)(nil), "cockroach.roachpb.PgDumpOptions")
	proto.RegisterType((*AvroOptions)(nil), "cockroach.roachpb.AvroOptions")
	proto.RegisterEnum("cockroach.roachpb.IOFileFormat_FileFormat", IOFileFormat_FileFormat_name, IOFileFormat_FileFormat_value)
	proto.RegisterEnum("cockroach.roachpb.IOFileFormat_Compression", IOFileFormat_Compression_name, IOFileFormat_Compression_value)
	proto.RegisterEnum("cockroach.roachpb.MySQLOutfileOptions_Enclose", MySQLOutfileOptions_Enclose_name, MySQLOutfileOptions_Enclose_value)
	proto.RegisterEnum("cockroach.roachpb.AvroOptions_Format", AvroOptions_Format_name, AvroOptions_Format_value)
}
func (m *IOFileFormat) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IOFileFormat) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.Format))
	dAtA[i] = 0x12
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.Csv.Size()))
	n1, err := m.Csv.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n1
	dAtA[i] = 0x1a
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.MysqlOut.Size()))
	n2, err := m.MysqlOut.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n2
	dAtA[i] = 0x22
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.PgCopy.Size()))
	n3, err := m.PgCopy.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n3
	dAtA[i] = 0x28
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.Compression))
	dAtA[i] = 0x32
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.PgDump.Size()))
	n4, err := m.PgDump.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n4
	dAtA[i] = 0x38
	i++
	if m.SaveRejected {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	dAtA[i] = 0x42
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.Avro.Size()))
	n5, err := m.Avro.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n5
	return i, nil
}

func (m *CSVOptions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CSVOptions) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.Comma))
	dAtA[i] = 0x10
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.Comment))
	if m.NullEncoding != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintIoFormats(dAtA, i, uint64(len(*m.NullEncoding)))
		i += copy(dAtA[i:], *m.NullEncoding)
	}
	dAtA[i] = 0x20
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.Skip))
	dAtA[i] = 0x28
	i++
	if m.StrictQuotes {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	return i, nil
}

func (m *MySQLOutfileOptions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MySQLOutfileOptions) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.RowSeparator))
	dAtA[i] = 0x10
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.FieldSeparator))
	dAtA[i] = 0x18
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.Enclose))
	dAtA[i] = 0x20
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.Encloser))
	dAtA[i] = 0x28
	i++
	if m.HasEscape {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	dAtA[i] = 0x30
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.Escape))
	dAtA[i] = 0x38
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.Skip))
	if m.NullEncoding != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintIoFormats(dAtA, i, uint64(len(*m.NullEncoding)))
		i += copy(dAtA[i:], *m.NullEncoding)
	}
	return i, nil
}

func (m *PgCopyOptions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PgCopyOptions) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.Delimiter))
	dAtA[i] = 0x12
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(len(m.Null)))
	i += copy(dAtA[i:], m.Null)
	dAtA[i] = 0x18
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.MaxRowSize))
	return i, nil
}

func (m *PgDumpOptions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PgDumpOptions) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.MaxRowSize))
	return i, nil
}

func (m *AvroOptions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AvroOptions) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.Format))
	dAtA[i] = 0x10
	i++
	if m.StrictMode {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	dAtA[i] = 0x1a
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(len(m.SchemaJSON)))
	i += copy(dAtA[i:], m.SchemaJSON)
	dAtA[i] = 0x20
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.MaxRecordSize))
	dAtA[i] = 0x28
	i++
	i = encodeVarintIoFormats(dAtA, i, uint64(m.RecordSeparator))
	return i, nil
}

func encodeVarintIoFormats(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *IOFileFormat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovIoFormats(uint64(m.Format))
	l = m.Csv.Size()
	n += 1 + l + sovIoFormats(uint64(l))
	l = m.MysqlOut.Size()
	n += 1 + l + sovIoFormats(uint64(l))
	l = m.PgCopy.Size()
	n += 1 + l + sovIoFormats(uint64(l))
	n += 1 + sovIoFormats(uint64(m.Compression))
	l = m.PgDump.Size()
	n += 1 + l + sovIoFormats(uint64(l))
	n += 2
	l = m.Avro.Size()
	n += 1 + l + sovIoFormats(uint64(l))
	return n
}

func (m *CSVOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovIoFormats(uint64(m.Comma))
	n += 1 + sovIoFormats(uint64(m.Comment))
	if m.NullEncoding != nil {
		l = len(*m.NullEncoding)
		n += 1 + l + sovIoFormats(uint64(l))
	}
	n += 1 + sovIoFormats(uint64(m.Skip))
	n += 2
	return n
}

func (m *MySQLOutfileOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovIoFormats(uint64(m.RowSeparator))
	n += 1 + sovIoFormats(uint64(m.FieldSeparator))
	n += 1 + sovIoFormats(uint64(m.Enclose))
	n += 1 + sovIoFormats(uint64(m.Encloser))
	n += 2
	n += 1 + sovIoFormats(uint64(m.Escape))
	n += 1 + sovIoFormats(uint64(m.Skip))
	if m.NullEncoding != nil {
		l = len(*m.NullEncoding)
		n += 1 + l + sovIoFormats(uint64(l))
	}
	return n
}

func (m *PgCopyOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovIoFormats(uint64(m.Delimiter))
	l = len(m.Null)
	n += 1 + l + sovIoFormats(uint64(l))
	n += 1 + sovIoFormats(uint64(m.MaxRowSize))
	return n
}

func (m *PgDumpOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovIoFormats(uint64(m.MaxRowSize))
	return n
}

func (m *AvroOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovIoFormats(uint64(m.Format))
	n += 2
	l = len(m.SchemaJSON)
	n += 1 + l + sovIoFormats(uint64(l))
	n += 1 + sovIoFormats(uint64(m.MaxRecordSize))
	n += 1 + sovIoFormats(uint64(m.RecordSeparator))
	return n
}

func sovIoFormats(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozIoFormats(x uint64) (n int) {
	return sovIoFormats(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *IOFileFormat) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowIoFormats
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IOFileFormat: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IOFileFormat: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Format", wireType)
			}
			m.Format = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Format |= (IOFileFormat_FileFormat(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Csv", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthIoFormats
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Csv.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MysqlOut", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthIoFormats
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MysqlOut.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PgCopy", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthIoFormats
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PgCopy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Compression", wireType)
			}
			m.Compression = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Compression |= (IOFileFormat_Compression(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PgDump", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthIoFormats
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PgDump.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SaveRejected", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SaveRejected = bool(v != 0)
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Avro", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthIoFormats
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Avro.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipIoFormats(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthIoFormats
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CSVOptions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowIoFormats
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CSVOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CSVOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Comma", wireType)
			}
			m.Comma = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Comma |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Comment", wireType)
			}
			m.Comment = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Comment |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullEncoding", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthIoFormats
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.NullEncoding = &s
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Skip", wireType)
			}
			m.Skip = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Skip |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StrictQuotes", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.StrictQuotes = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipIoFormats(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthIoFormats
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MySQLOutfileOptions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowIoFormats
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MySQLOutfileOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MySQLOutfileOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RowSeparator", wireType)
			}
			m.RowSeparator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RowSeparator |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FieldSeparator", wireType)
			}
			m.FieldSeparator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FieldSeparator |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Enclose", wireType)
			}
			m.Enclose = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Enclose |= (MySQLOutfileOptions_Enclose(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Encloser", wireType)
			}
			m.Encloser = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Encloser |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HasEscape", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HasEscape = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Escape", wireType)
			}
			m.Escape = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Escape |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Skip", wireType)
			}
			m.Skip = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Skip |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NullEncoding", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthIoFormats
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.NullEncoding = &s
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipIoFormats(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthIoFormats
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PgCopyOptions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowIoFormats
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PgCopyOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PgCopyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delimiter", wireType)
			}
			m.Delimiter = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Delimiter |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Null", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthIoFormats
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Null = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxRowSize", wireType)
			}
			m.MaxRowSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxRowSize |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipIoFormats(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthIoFormats
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PgDumpOptions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowIoFormats
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PgDumpOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PgDumpOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxRowSize", wireType)
			}
			m.MaxRowSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxRowSize |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipIoFormats(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthIoFormats
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AvroOptions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowIoFormats
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AvroOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AvroOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Format", wireType)
			}
			m.Format = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Format |= (AvroOptions_Format(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StrictMode", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.StrictMode = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SchemaJSON", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthIoFormats
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SchemaJSON = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxRecordSize", wireType)
			}
			m.MaxRecordSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxRecordSize |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordSeparator", wireType)
			}
			m.RecordSeparator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RecordSeparator |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipIoFormats(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthIoFormats
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipIoFormats(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowIoFormats
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowIoFormats
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthIoFormats
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowIoFormats
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipIoFormats(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthIoFormats = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowIoFormats   = fmt.Errorf("proto: integer overflow")
)

func init() {
	proto.RegisterFile("roachpb/io-formats.proto", fileDescriptor_io_formats_e2ffeab7714b237d)
}

var fileDescriptor_io_formats_e2ffeab7714b237d = []byte{
	// 876 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xcf, 0x72, 0xdb, 0x44,
	0x18, 0x97, 0xfc, 0x4f, 0xf6, 0x67, 0x3b, 0x59, 0x16, 0x0e, 0x9a, 0x0e, 0x08, 0x8f, 0xa0, 0x4c,
	0x0a, 0x54, 0x99, 0xc9, 0x90, 0x19, 0x6e, 0x4c, 0xe3, 0x26, 0x90, 0x0e, 0xb1, 0xa9, 0x3d, 0xf4,
	0xc0, 0x45, 0x23, 0xe4, 0x8d, 0x23, 0x22, 0x69, 0xd5, 0x5d, 0xc9, 0xae, 0xfb, 0x14, 0xbc, 0x01,
	0x2f, 0xd1, 0x03, 0x8f, 0x90, 0x63, 0x8f, 0x3d, 0x31, 0xe0, 0xbc, 0x08, 0xb3, 0xab, 0x95, 0x2d,
	0xb5, 0x6e, 0xe0, 0xf6, 0xcd, 0xef, 0xf7, 0xfd, 0xff, 0x7e, 0xbb, 0x60, 0x32, 0xea, 0xf9, 0x57,
	0xc9, 0xaf, 0x87, 0x01, 0x7d, 0x78, 0x49, 0x59, 0xe4, 0xa5, 0xdc, 0x49, 0x18, 0x4d, 0x29, 0xfe,
	0xc0, 0xa7, 0xfe, 0xb5, 0x64, 0x1d, 0xe5, 0x73, 0xef, 0xa3, 0x39, 0x9d, 0x53, 0xc9, 0x1e, 0x0a,
	0x2b, 0x77, 0xb4, 0x5f, 0x35, 0xa1, 0x77, 0x3e, 0x3e, 0x0b, 0x42, 0x72, 0x26, 0x13, 0xe0, 0x1f,
	0xa0, 0x95, 0xa7, 0x32, 0xf5, 0x81, 0x7e, 0xb0, 0x77, 0xf4, 0xa5, 0xf3, 0x4e, 0x2a, 0xa7, 0x1c,
	0xe0, 0x6c, 0xcd, 0x93, 0xc6, 0xcd, 0x5f, 0x9f, 0x6a, 0x13, 0x15, 0x8f, 0x8f, 0xa1, 0xee, 0xf3,
	0x85, 0x59, 0x1b, 0xe8, 0x07, 0xdd, 0xa3, 0x4f, 0x76, 0xa4, 0x19, 0x4e, 0x9f, 0x8d, 0x93, 0x34,
	0xa0, 0x31, 0x57, 0x91, 0xc2, 0x1f, 0x9f, 0x43, 0x27, 0x5a, 0xf1, 0xe7, 0xa1, 0x4b, 0xb3, 0xd4,
	0xac, 0xcb, 0xe0, 0x2f, 0x76, 0x04, 0x5f, 0xac, 0xa6, 0x4f, 0x7f, 0x1c, 0x67, 0xe9, 0x65, 0x10,
	0x92, 0x6a, 0x96, 0xb6, 0x0c, 0x1f, 0x67, 0x29, 0xfe, 0x0e, 0x8c, 0x64, 0xee, 0xfa, 0x34, 0x59,
	0x99, 0x0d, 0x99, 0x68, 0xb0, 0x23, 0xd1, 0x4f, 0xf3, 0x21, 0x4d, 0x56, 0xd5, 0x14, 0xad, 0x44,
	0x82, 0x78, 0x0a, 0x5d, 0x9f, 0x46, 0x09, 0x23, 0x9c, 0x07, 0x34, 0x36, 0x9b, 0x72, 0x23, 0x5f,
	0xfd, 0xd7, 0x46, 0x86, 0xdb, 0x10, 0x95, 0xaf, 0x9c, 0x45, 0x75, 0x35, 0xcb, 0xa2, 0xc4, 0x6c,
	0xdd, 0xd1, 0xd5, 0xe3, 0x2c, 0x4a, 0xde, 0xe9, 0x4a, 0x80, 0xf8, 0x01, 0xf4, 0xb9, 0xb7, 0x20,
	0x2e, 0x23, 0xbf, 0x11, 0x3f, 0x25, 0x33, 0xd3, 0x18, 0xe8, 0x07, 0x6d, 0xe5, 0xd4, 0x13, 0xd4,
	0x44, 0x31, 0xf8, 0x5b, 0x68, 0x78, 0x0b, 0x46, 0xcd, 0xb6, 0x2c, 0x64, 0xed, 0x28, 0xf4, 0x68,
	0xc1, 0x68, 0xb5, 0x8c, 0x8c, 0xb0, 0x09, 0x40, 0x49, 0x15, 0x5d, 0x30, 0x7e, 0x8e, 0xaf, 0x63,
	0xba, 0x8c, 0x91, 0x86, 0x0d, 0xa8, 0x0f, 0xa7, 0xcf, 0x90, 0x8e, 0x11, 0xf4, 0x2e, 0xd4, 0xae,
	0xc5, 0x19, 0x50, 0x0d, 0xf7, 0xa1, 0x23, 0x11, 0x31, 0x1d, 0xaa, 0x63, 0x80, 0x56, 0xbe, 0x5e,
	0xd4, 0xc8, 0x6d, 0xd1, 0x3f, 0x6a, 0xe2, 0x36, 0x34, 0x44, 0x5d, 0xd4, 0xb2, 0x8f, 0xa1, 0x5b,
	0x5a, 0x97, 0x24, 0xb2, 0x94, 0x22, 0x4d, 0x58, 0x23, 0x1a, 0x13, 0xa4, 0x0b, 0xeb, 0xfb, 0x97,
	0x41, 0x82, 0x6a, 0xc2, 0x3a, 0x11, 0x56, 0xdd, 0xfe, 0x53, 0x07, 0xd8, 0xca, 0x07, 0xdf, 0x83,
	0xa6, 0x4f, 0xa3, 0xc8, 0x93, 0x9a, 0x6d, 0xaa, 0x39, 0x72, 0x08, 0x5b, 0x60, 0x08, 0x83, 0xc4,
	0xa9, 0x94, 0x62, 0xc1, 0x16, 0xa0, 0xd8, 0x66, 0x9c, 0x85, 0xa1, 0x4b, 0x62, 0x9f, 0xce, 0x82,
	0x78, 0x2e, 0x35, 0xd7, 0x91, 0x5e, 0xfa, 0xa4, 0x27, 0xa8, 0x53, 0xc5, 0x60, 0x13, 0x1a, 0xfc,
	0x3a, 0x48, 0xa4, 0x98, 0xfa, 0xc5, 0xb6, 0x04, 0x22, 0x4f, 0x92, 0xb2, 0xc0, 0x4f, 0xdd, 0xe7,
	0x19, 0x4d, 0x09, 0x97, 0x52, 0xd9, 0x9e, 0x44, 0x52, 0x4f, 0x25, 0x63, 0xff, 0x51, 0x87, 0x0f,
	0x77, 0x88, 0x57, 0xa4, 0x60, 0x74, 0xe9, 0x72, 0x92, 0x78, 0xcc, 0x4b, 0x29, 0xab, 0xcc, 0xd2,
	0x63, 0x74, 0x39, 0x2d, 0x18, 0xfc, 0x10, 0xf6, 0x2f, 0x03, 0x12, 0xce, 0x4a, 0xce, 0xe5, 0xd1,
	0xf6, 0x24, 0xb9, 0x75, 0x1f, 0x81, 0x41, 0x62, 0x3f, 0xa4, 0x9c, 0xc8, 0xd9, 0xf6, 0x8e, 0x9c,
	0xff, 0xf7, 0x9e, 0x9c, 0xd3, 0x3c, 0xaa, 0xd8, 0x98, 0x4a, 0x82, 0x07, 0xd0, 0x56, 0x26, 0x93,
	0xab, 0x28, 0xea, 0x6e, 0x50, 0xfc, 0x19, 0xc0, 0x95, 0xc7, 0x5d, 0xc2, 0x7d, 0x2f, 0x21, 0x95,
	0x5d, 0x74, 0xae, 0x3c, 0x7e, 0x2a, 0x61, 0xfc, 0x31, 0xb4, 0x94, 0x43, 0xab, 0x94, 0x44, 0x61,
	0x9b, 0x5d, 0x1b, 0xbb, 0x76, 0x5d, 0x3d, 0x58, 0xfb, 0x7d, 0x07, 0xb3, 0x1d, 0x30, 0xd4, 0x0c,
	0xb8, 0x03, 0xcd, 0x11, 0x59, 0x10, 0x86, 0x34, 0xa1, 0xc4, 0x47, 0xe1, 0xd2, 0x5b, 0x71, 0xa4,
	0xe3, 0x1e, 0xb4, 0xf3, 0x69, 0xbd, 0x10, 0xd5, 0x9e, 0x34, 0xda, 0x1d, 0x04, 0x36, 0x87, 0x7e,
	0xe5, 0x53, 0xc0, 0x36, 0x74, 0x66, 0x24, 0x0c, 0xa2, 0x20, 0x25, 0xd5, 0xb3, 0x6c, 0x61, 0xd1,
	0xaf, 0x28, 0x2d, 0x0f, 0xd1, 0x29, 0xfa, 0x15, 0x08, 0xfe, 0x1c, 0x20, 0xf2, 0x5e, 0x4c, 0xe8,
	0x72, 0x1a, 0xbc, 0xcc, 0x2f, 0x50, 0x84, 0x97, 0x70, 0xfb, 0x58, 0x14, 0x2d, 0xbd, 0xf9, 0xb7,
	0xc2, 0xf4, 0xf7, 0x84, 0xbd, 0xaa, 0x41, 0xb7, 0xf4, 0x84, 0xf1, 0xf0, 0xad, 0xef, 0xfb, 0xfe,
	0xdd, 0x4f, 0xde, 0xd9, 0xf9, 0x73, 0xdf, 0x87, 0xae, 0x52, 0x73, 0x44, 0x67, 0x44, 0x8e, 0x54,
	0xdc, 0x0f, 0x72, 0xe2, 0x82, 0xce, 0x88, 0xe8, 0x90, 0xfb, 0x57, 0x24, 0xf2, 0x9e, 0x4c, 0xc7,
	0xa3, 0xd2, 0xb3, 0x11, 0x5e, 0x1b, 0x1c, 0x7f, 0x0d, 0xfb, 0x91, 0xf7, 0xc2, 0x65, 0xc4, 0xa7,
	0x6c, 0xe6, 0x72, 0x31, 0x4c, 0x59, 0x34, 0x7d, 0x31, 0x8c, 0xe4, 0xc4, 0x3c, 0xf8, 0x10, 0x50,
	0xe1, 0xb9, 0xd1, 0x76, 0xb3, 0xe4, 0xbe, 0x9f, 0xb3, 0x1b, 0x71, 0xdb, 0xdf, 0x40, 0x4b, 0xfd,
	0x51, 0x06, 0xd4, 0xc7, 0xc3, 0x33, 0xa4, 0xe1, 0x7d, 0xe8, 0x9e, 0x9c, 0x8f, 0xdc, 0xc9, 0xe9,
	0x70, 0x3c, 0x79, 0x3c, 0xcd, 0xff, 0x29, 0xd1, 0xca, 0x06, 0xa9, 0x9d, 0x3c, 0xb8, 0xf9, 0xc7,
	0xd2, 0x6e, 0xd6, 0x96, 0xfe, 0x7a, 0x6d, 0xe9, 0x6f, 0xd6, 0x96, 0xfe, 0xf7, 0xda, 0xd2, 0x7f,
	0xbf, 0xb5, 0xb4, 0xd7, 0xb7, 0x96, 0xf6, 0xe6, 0xd6, 0xd2, 0x7e, 0x31, 0xd4, 0xb6, 0xfe, 0x0d,
	0x00, 0x00, 0xff, 0xff, 0xe0, 0x82, 0x8d, 0xf0, 0x65, 0x07, 0x00, 0x00,
}