From 09b3704bb1888dc460d32d31fb30125dcc822575 Mon Sep 17 00:00:00 2001 From: simons Date: Wed, 12 Aug 2020 11:52:11 +0800 Subject: [PATCH 1/2] Add directory goimpl/lib to parse data form DTS or Canal-Kafka --- .gitignore | 1 + goimpl/go.mod | 13 + goimpl/lib/dtsavro/array_field.go | 56 ++++ goimpl/lib/dtsavro/array_long.go | 54 ++++ ..._binary_object_text_object_empty_object.go | 79 +++++ goimpl/lib/dtsavro/binary_geometry.go | 118 +++++++ goimpl/lib/dtsavro/binary_object.go | 118 +++++++ goimpl/lib/dtsavro/character.go | 118 +++++++ goimpl/lib/dtsavro/date_time.go | 214 +++++++++++++ goimpl/lib/dtsavro/decimal.go | 126 ++++++++ goimpl/lib/dtsavro/empty_object.go | 120 ++++++++ goimpl/lib/dtsavro/field.go | 118 +++++++ goimpl/lib/dtsavro/float.go | 126 ++++++++ goimpl/lib/dtsavro/integer.go | 118 +++++++ goimpl/lib/dtsavro/map_string.go | 66 ++++ goimpl/lib/dtsavro/operation.go | 195 ++++++++++++ goimpl/lib/dtsavro/record.go | 279 +++++++++++++++++ goimpl/lib/dtsavro/source.go | 118 +++++++ goimpl/lib/dtsavro/source_type.go | 175 +++++++++++ goimpl/lib/dtsavro/text_geometry.go | 118 +++++++ goimpl/lib/dtsavro/text_object.go | 118 +++++++ goimpl/lib/dtsavro/timestamp.go | 118 +++++++ .../lib/dtsavro/timestamp_with_time_zone.go | 120 ++++++++ ..._object_text_object_empty_object_record.go | 291 ++++++++++++++++++ goimpl/lib/dtsavro/union_null_array_long.go | 97 ++++++ goimpl/lib/dtsavro/union_null_int.go | 96 ++++++ ..._binary_object_text_object_empty_object.go | 271 ++++++++++++++++ goimpl/lib/dtsavro/union_null_string.go | 96 ++++++ .../dtsavro/union_null_string_array_field.go | 110 +++++++ ..._binary_object_text_object_empty_object.go | 131 ++++++++ goimpl/lib/img/1.png | Bin 0 -> 69604 bytes goimpl/lib/kfkdts/config.go | 24 ++ goimpl/lib/kfkdts/consumer.go | 96 ++++++ goimpl/lib/kfkdts/consumer_test.go | 74 +++++ goimpl/lib/kfkdts/data_type_number.go | 118 +++++++ goimpl/lib/kfkdts/dts.go | 122 ++++++++ goimpl/lib/kfkdts/dts_decode.go | 113 +++++++ goimpl/lib/kfkdts/kfk.go | 111 +++++++ goimpl/lib/kfkdts/kfk_decode.go | 1 + goimpl/lib/readme.md | 18 ++ 40 files changed, 4455 insertions(+) create mode 100644 .gitignore create mode 100644 goimpl/go.mod create mode 100644 goimpl/lib/dtsavro/array_field.go create mode 100644 goimpl/lib/dtsavro/array_long.go create mode 100644 goimpl/lib/dtsavro/array_union_null_integer_character_decimal_float_timestamp_date_time_timestamp_with_time_zone_binary_geometry_text_geometry_binary_object_text_object_empty_object.go create mode 100644 goimpl/lib/dtsavro/binary_geometry.go create mode 100644 goimpl/lib/dtsavro/binary_object.go create mode 100644 goimpl/lib/dtsavro/character.go create mode 100644 goimpl/lib/dtsavro/date_time.go create mode 100644 goimpl/lib/dtsavro/decimal.go create mode 100644 goimpl/lib/dtsavro/empty_object.go create mode 100644 goimpl/lib/dtsavro/field.go create mode 100644 goimpl/lib/dtsavro/float.go create mode 100644 goimpl/lib/dtsavro/integer.go create mode 100644 goimpl/lib/dtsavro/map_string.go create mode 100644 goimpl/lib/dtsavro/operation.go create mode 100644 goimpl/lib/dtsavro/record.go create mode 100644 goimpl/lib/dtsavro/source.go create mode 100644 goimpl/lib/dtsavro/source_type.go create mode 100644 goimpl/lib/dtsavro/text_geometry.go create mode 100644 goimpl/lib/dtsavro/text_object.go create mode 100644 goimpl/lib/dtsavro/timestamp.go create mode 100644 goimpl/lib/dtsavro/timestamp_with_time_zone.go create mode 100644 goimpl/lib/dtsavro/union_field_integer_character_float_decimal_timestamp_date_time_timestamp_with_time_zone_binary_geometry_text_geometry_binary_object_text_object_empty_object_record.go create mode 100644 goimpl/lib/dtsavro/union_null_array_long.go create mode 100644 goimpl/lib/dtsavro/union_null_int.go create mode 100644 goimpl/lib/dtsavro/union_null_integer_character_decimal_float_timestamp_date_time_timestamp_with_time_zone_binary_geometry_text_geometry_binary_object_text_object_empty_object.go create mode 100644 goimpl/lib/dtsavro/union_null_string.go create mode 100644 goimpl/lib/dtsavro/union_null_string_array_field.go create mode 100644 goimpl/lib/dtsavro/union_null_string_array_union_null_integer_character_decimal_float_timestamp_date_time_timestamp_with_time_zone_binary_geometry_text_geometry_binary_object_text_object_empty_object.go create mode 100644 goimpl/lib/img/1.png create mode 100644 goimpl/lib/kfkdts/config.go create mode 100644 goimpl/lib/kfkdts/consumer.go create mode 100644 goimpl/lib/kfkdts/consumer_test.go create mode 100644 goimpl/lib/kfkdts/data_type_number.go create mode 100644 goimpl/lib/kfkdts/dts.go create mode 100644 goimpl/lib/kfkdts/dts_decode.go create mode 100644 goimpl/lib/kfkdts/kfk.go create mode 100644 goimpl/lib/kfkdts/kfk_decode.go create mode 100644 goimpl/lib/readme.md diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..08cb523 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +go.sum diff --git a/goimpl/go.mod b/goimpl/go.mod new file mode 100644 index 0000000..78b7842 --- /dev/null +++ b/goimpl/go.mod @@ -0,0 +1,13 @@ +module github.com/LioRoger/subscribe_example/goimpl + +go 1.14 + +require ( + github.com/Shopify/sarama v1.27.0 + github.com/actgardner/gogen-avro/v7 v7.1.1 + github.com/bsm/sarama-cluster v2.1.15+incompatible + github.com/linkedin/goavro v2.1.0+incompatible + github.com/mitchellh/mapstructure v1.3.3 + github.com/stretchr/testify v1.6.1 + gopkg.in/linkedin/goavro.v1 v1.0.5 // indirect +) diff --git a/goimpl/lib/dtsavro/array_field.go b/goimpl/lib/dtsavro/array_field.go new file mode 100644 index 0000000..ac3dc94 --- /dev/null +++ b/goimpl/lib/dtsavro/array_field.go @@ -0,0 +1,56 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "io" + + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" +) + +func writeArrayField(r []*Field, w io.Writer) error { + err := vm.WriteLong(int64(len(r)), w) + if err != nil || len(r) == 0 { + return err + } + for _, e := range r { + err = writeField(e, w) + if err != nil { + return err + } + } + return vm.WriteLong(0, w) +} + +type ArrayFieldWrapper struct { + Target *[]*Field +} + +func (_ *ArrayFieldWrapper) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *ArrayFieldWrapper) SetInt(v int32) { panic("Unsupported operation") } +func (_ *ArrayFieldWrapper) SetLong(v int64) { panic("Unsupported operation") } +func (_ *ArrayFieldWrapper) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *ArrayFieldWrapper) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *ArrayFieldWrapper) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *ArrayFieldWrapper) SetString(v string) { panic("Unsupported operation") } +func (_ *ArrayFieldWrapper) SetUnionElem(v int64) { panic("Unsupported operation") } +func (_ *ArrayFieldWrapper) Get(i int) types.Field { panic("Unsupported operation") } +func (_ *ArrayFieldWrapper) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *ArrayFieldWrapper) Finalize() {} +func (_ *ArrayFieldWrapper) SetDefault(i int) { panic("Unsupported operation") } +func (r *ArrayFieldWrapper) NullField(i int) { + panic("Unsupported operation") +} + +func (r *ArrayFieldWrapper) AppendArray() types.Field { + var v *Field + v = NewField() + + *r.Target = append(*r.Target, v) + + return (*r.Target)[len(*r.Target)-1] +} diff --git a/goimpl/lib/dtsavro/array_long.go b/goimpl/lib/dtsavro/array_long.go new file mode 100644 index 0000000..ab4374a --- /dev/null +++ b/goimpl/lib/dtsavro/array_long.go @@ -0,0 +1,54 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "io" + + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" +) + +func writeArrayLong(r []int64, w io.Writer) error { + err := vm.WriteLong(int64(len(r)), w) + if err != nil || len(r) == 0 { + return err + } + for _, e := range r { + err = vm.WriteLong(e, w) + if err != nil { + return err + } + } + return vm.WriteLong(0, w) +} + +type ArrayLongWrapper struct { + Target *[]int64 +} + +func (_ *ArrayLongWrapper) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *ArrayLongWrapper) SetInt(v int32) { panic("Unsupported operation") } +func (_ *ArrayLongWrapper) SetLong(v int64) { panic("Unsupported operation") } +func (_ *ArrayLongWrapper) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *ArrayLongWrapper) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *ArrayLongWrapper) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *ArrayLongWrapper) SetString(v string) { panic("Unsupported operation") } +func (_ *ArrayLongWrapper) SetUnionElem(v int64) { panic("Unsupported operation") } +func (_ *ArrayLongWrapper) Get(i int) types.Field { panic("Unsupported operation") } +func (_ *ArrayLongWrapper) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *ArrayLongWrapper) Finalize() {} +func (_ *ArrayLongWrapper) SetDefault(i int) { panic("Unsupported operation") } +func (r *ArrayLongWrapper) NullField(i int) { + panic("Unsupported operation") +} + +func (r *ArrayLongWrapper) AppendArray() types.Field { + var v int64 + + *r.Target = append(*r.Target, v) + return &types.Long{Target: &(*r.Target)[len(*r.Target)-1]} +} diff --git a/goimpl/lib/dtsavro/array_union_null_integer_character_decimal_float_timestamp_date_time_timestamp_with_time_zone_binary_geometry_text_geometry_binary_object_text_object_empty_object.go b/goimpl/lib/dtsavro/array_union_null_integer_character_decimal_float_timestamp_date_time_timestamp_with_time_zone_binary_geometry_text_geometry_binary_object_text_object_empty_object.go new file mode 100644 index 0000000..486145c --- /dev/null +++ b/goimpl/lib/dtsavro/array_union_null_integer_character_decimal_float_timestamp_date_time_timestamp_with_time_zone_binary_geometry_text_geometry_binary_object_text_object_empty_object.go @@ -0,0 +1,79 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "io" + + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" +) + +func writeArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject(r []*UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject, w io.Writer) error { + err := vm.WriteLong(int64(len(r)), w) + if err != nil || len(r) == 0 { + return err + } + for _, e := range r { + err = writeUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject(e, w) + if err != nil { + return err + } + } + return vm.WriteLong(0, w) +} + +type ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectWrapper struct { + Target *[]*UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject +} + +func (_ *ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectWrapper) SetBoolean(v bool) { + panic("Unsupported operation") +} +func (_ *ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectWrapper) SetInt(v int32) { + panic("Unsupported operation") +} +func (_ *ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectWrapper) SetLong(v int64) { + panic("Unsupported operation") +} +func (_ *ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectWrapper) SetFloat(v float32) { + panic("Unsupported operation") +} +func (_ *ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectWrapper) SetDouble(v float64) { + panic("Unsupported operation") +} +func (_ *ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectWrapper) SetBytes(v []byte) { + panic("Unsupported operation") +} +func (_ *ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectWrapper) SetString(v string) { + panic("Unsupported operation") +} +func (_ *ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectWrapper) SetUnionElem(v int64) { + panic("Unsupported operation") +} +func (_ *ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectWrapper) Get(i int) types.Field { + panic("Unsupported operation") +} +func (_ *ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectWrapper) AppendMap(key string) types.Field { + panic("Unsupported operation") +} +func (_ *ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectWrapper) Finalize() { +} +func (_ *ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectWrapper) SetDefault(i int) { + panic("Unsupported operation") +} +func (r *ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectWrapper) NullField(i int) { + (*r.Target)[len(*r.Target)-1] = nil +} + +func (r *ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectWrapper) AppendArray() types.Field { + var v *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject + v = NewUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject() + + *r.Target = append(*r.Target, v) + + return (*r.Target)[len(*r.Target)-1] +} diff --git a/goimpl/lib/dtsavro/binary_geometry.go b/goimpl/lib/dtsavro/binary_geometry.go new file mode 100644 index 0000000..fe2aeeb --- /dev/null +++ b/goimpl/lib/dtsavro/binary_geometry.go @@ -0,0 +1,118 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "github.com/actgardner/gogen-avro/v7/compiler" + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" + "io" +) + +type BinaryGeometry struct { + Type string `json:"type"` + + Value []byte `json:"value"` +} + +const BinaryGeometryAvroCRC64Fingerprint = "\x92\xc6=\xfac$\x8e\x80" + +func NewBinaryGeometry() *BinaryGeometry { + return &BinaryGeometry{} +} + +func DeserializeBinaryGeometry(r io.Reader) (*BinaryGeometry, error) { + t := NewBinaryGeometry() + deser, err := compiler.CompileSchemaBytes([]byte(t.Schema()), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func DeserializeBinaryGeometryFromSchema(r io.Reader, schema string) (*BinaryGeometry, error) { + t := NewBinaryGeometry() + + deser, err := compiler.CompileSchemaBytes([]byte(schema), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func writeBinaryGeometry(r *BinaryGeometry, w io.Writer) error { + var err error + err = vm.WriteString(r.Type, w) + if err != nil { + return err + } + err = vm.WriteBytes(r.Value, w) + if err != nil { + return err + } + return err +} + +func (r *BinaryGeometry) Serialize(w io.Writer) error { + return writeBinaryGeometry(r, w) +} + +func (r *BinaryGeometry) Schema() string { + return "{\"fields\":[{\"name\":\"type\",\"type\":\"string\"},{\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"com.alibaba.dts.formats.avro.BinaryGeometry\",\"type\":\"record\"}" +} + +func (r *BinaryGeometry) SchemaName() string { + return "com.alibaba.dts.formats.avro.BinaryGeometry" +} + +func (_ *BinaryGeometry) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *BinaryGeometry) SetInt(v int32) { panic("Unsupported operation") } +func (_ *BinaryGeometry) SetLong(v int64) { panic("Unsupported operation") } +func (_ *BinaryGeometry) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *BinaryGeometry) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *BinaryGeometry) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *BinaryGeometry) SetString(v string) { panic("Unsupported operation") } +func (_ *BinaryGeometry) SetUnionElem(v int64) { panic("Unsupported operation") } + +func (r *BinaryGeometry) Get(i int) types.Field { + switch i { + case 0: + return &types.String{Target: &r.Type} + case 1: + return &types.Bytes{Target: &r.Value} + } + panic("Unknown field index") +} + +func (r *BinaryGeometry) SetDefault(i int) { + switch i { + } + panic("Unknown field index") +} + +func (r *BinaryGeometry) NullField(i int) { + switch i { + } + panic("Not a nullable field index") +} + +func (_ *BinaryGeometry) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *BinaryGeometry) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *BinaryGeometry) Finalize() {} + +func (_ *BinaryGeometry) AvroCRC64Fingerprint() []byte { + return []byte(BinaryGeometryAvroCRC64Fingerprint) +} diff --git a/goimpl/lib/dtsavro/binary_object.go b/goimpl/lib/dtsavro/binary_object.go new file mode 100644 index 0000000..f54d645 --- /dev/null +++ b/goimpl/lib/dtsavro/binary_object.go @@ -0,0 +1,118 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "github.com/actgardner/gogen-avro/v7/compiler" + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" + "io" +) + +type BinaryObject struct { + Type string `json:"type"` + + Value []byte `json:"value"` +} + +const BinaryObjectAvroCRC64Fingerprint = "\xaf\xbe\xee}\x1b\xe04~" + +func NewBinaryObject() *BinaryObject { + return &BinaryObject{} +} + +func DeserializeBinaryObject(r io.Reader) (*BinaryObject, error) { + t := NewBinaryObject() + deser, err := compiler.CompileSchemaBytes([]byte(t.Schema()), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func DeserializeBinaryObjectFromSchema(r io.Reader, schema string) (*BinaryObject, error) { + t := NewBinaryObject() + + deser, err := compiler.CompileSchemaBytes([]byte(schema), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func writeBinaryObject(r *BinaryObject, w io.Writer) error { + var err error + err = vm.WriteString(r.Type, w) + if err != nil { + return err + } + err = vm.WriteBytes(r.Value, w) + if err != nil { + return err + } + return err +} + +func (r *BinaryObject) Serialize(w io.Writer) error { + return writeBinaryObject(r, w) +} + +func (r *BinaryObject) Schema() string { + return "{\"fields\":[{\"name\":\"type\",\"type\":\"string\"},{\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"com.alibaba.dts.formats.avro.BinaryObject\",\"type\":\"record\"}" +} + +func (r *BinaryObject) SchemaName() string { + return "com.alibaba.dts.formats.avro.BinaryObject" +} + +func (_ *BinaryObject) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *BinaryObject) SetInt(v int32) { panic("Unsupported operation") } +func (_ *BinaryObject) SetLong(v int64) { panic("Unsupported operation") } +func (_ *BinaryObject) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *BinaryObject) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *BinaryObject) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *BinaryObject) SetString(v string) { panic("Unsupported operation") } +func (_ *BinaryObject) SetUnionElem(v int64) { panic("Unsupported operation") } + +func (r *BinaryObject) Get(i int) types.Field { + switch i { + case 0: + return &types.String{Target: &r.Type} + case 1: + return &types.Bytes{Target: &r.Value} + } + panic("Unknown field index") +} + +func (r *BinaryObject) SetDefault(i int) { + switch i { + } + panic("Unknown field index") +} + +func (r *BinaryObject) NullField(i int) { + switch i { + } + panic("Not a nullable field index") +} + +func (_ *BinaryObject) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *BinaryObject) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *BinaryObject) Finalize() {} + +func (_ *BinaryObject) AvroCRC64Fingerprint() []byte { + return []byte(BinaryObjectAvroCRC64Fingerprint) +} diff --git a/goimpl/lib/dtsavro/character.go b/goimpl/lib/dtsavro/character.go new file mode 100644 index 0000000..2022cd1 --- /dev/null +++ b/goimpl/lib/dtsavro/character.go @@ -0,0 +1,118 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "github.com/actgardner/gogen-avro/v7/compiler" + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" + "io" +) + +type Character struct { + Charset string `json:"charset"` + + Value []byte `json:"value"` +} + +const CharacterAvroCRC64Fingerprint = "\xc1a\xeb\xfb\x9e\x97\\\xe7" + +func NewCharacter() *Character { + return &Character{} +} + +func DeserializeCharacter(r io.Reader) (*Character, error) { + t := NewCharacter() + deser, err := compiler.CompileSchemaBytes([]byte(t.Schema()), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func DeserializeCharacterFromSchema(r io.Reader, schema string) (*Character, error) { + t := NewCharacter() + + deser, err := compiler.CompileSchemaBytes([]byte(schema), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func writeCharacter(r *Character, w io.Writer) error { + var err error + err = vm.WriteString(r.Charset, w) + if err != nil { + return err + } + err = vm.WriteBytes(r.Value, w) + if err != nil { + return err + } + return err +} + +func (r *Character) Serialize(w io.Writer) error { + return writeCharacter(r, w) +} + +func (r *Character) Schema() string { + return "{\"fields\":[{\"name\":\"charset\",\"type\":\"string\"},{\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"com.alibaba.dts.formats.avro.Character\",\"type\":\"record\"}" +} + +func (r *Character) SchemaName() string { + return "com.alibaba.dts.formats.avro.Character" +} + +func (_ *Character) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *Character) SetInt(v int32) { panic("Unsupported operation") } +func (_ *Character) SetLong(v int64) { panic("Unsupported operation") } +func (_ *Character) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *Character) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *Character) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *Character) SetString(v string) { panic("Unsupported operation") } +func (_ *Character) SetUnionElem(v int64) { panic("Unsupported operation") } + +func (r *Character) Get(i int) types.Field { + switch i { + case 0: + return &types.String{Target: &r.Charset} + case 1: + return &types.Bytes{Target: &r.Value} + } + panic("Unknown field index") +} + +func (r *Character) SetDefault(i int) { + switch i { + } + panic("Unknown field index") +} + +func (r *Character) NullField(i int) { + switch i { + } + panic("Not a nullable field index") +} + +func (_ *Character) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *Character) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *Character) Finalize() {} + +func (_ *Character) AvroCRC64Fingerprint() []byte { + return []byte(CharacterAvroCRC64Fingerprint) +} diff --git a/goimpl/lib/dtsavro/date_time.go b/goimpl/lib/dtsavro/date_time.go new file mode 100644 index 0000000..8c219d1 --- /dev/null +++ b/goimpl/lib/dtsavro/date_time.go @@ -0,0 +1,214 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "github.com/actgardner/gogen-avro/v7/compiler" + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" + "io" +) + +type DateTime struct { + Year *UnionNullInt `json:"year"` + + Month *UnionNullInt `json:"month"` + + Day *UnionNullInt `json:"day"` + + Hour *UnionNullInt `json:"hour"` + + Minute *UnionNullInt `json:"minute"` + + Second *UnionNullInt `json:"second"` + + Millis *UnionNullInt `json:"millis"` +} + +const DateTimeAvroCRC64Fingerprint = "\xef!̾罐\xf1" + +func NewDateTime() *DateTime { + return &DateTime{} +} + +func DeserializeDateTime(r io.Reader) (*DateTime, error) { + t := NewDateTime() + deser, err := compiler.CompileSchemaBytes([]byte(t.Schema()), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func DeserializeDateTimeFromSchema(r io.Reader, schema string) (*DateTime, error) { + t := NewDateTime() + + deser, err := compiler.CompileSchemaBytes([]byte(schema), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func writeDateTime(r *DateTime, w io.Writer) error { + var err error + err = writeUnionNullInt(r.Year, w) + if err != nil { + return err + } + err = writeUnionNullInt(r.Month, w) + if err != nil { + return err + } + err = writeUnionNullInt(r.Day, w) + if err != nil { + return err + } + err = writeUnionNullInt(r.Hour, w) + if err != nil { + return err + } + err = writeUnionNullInt(r.Minute, w) + if err != nil { + return err + } + err = writeUnionNullInt(r.Second, w) + if err != nil { + return err + } + err = writeUnionNullInt(r.Millis, w) + if err != nil { + return err + } + return err +} + +func (r *DateTime) Serialize(w io.Writer) error { + return writeDateTime(r, w) +} + +func (r *DateTime) Schema() string { + return "{\"fields\":[{\"default\":null,\"name\":\"year\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"month\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"day\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"hour\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"minute\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"second\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"millis\",\"type\":[\"null\",\"int\"]}],\"name\":\"com.alibaba.dts.formats.avro.DateTime\",\"type\":\"record\"}" +} + +func (r *DateTime) SchemaName() string { + return "com.alibaba.dts.formats.avro.DateTime" +} + +func (_ *DateTime) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *DateTime) SetInt(v int32) { panic("Unsupported operation") } +func (_ *DateTime) SetLong(v int64) { panic("Unsupported operation") } +func (_ *DateTime) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *DateTime) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *DateTime) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *DateTime) SetString(v string) { panic("Unsupported operation") } +func (_ *DateTime) SetUnionElem(v int64) { panic("Unsupported operation") } + +func (r *DateTime) Get(i int) types.Field { + switch i { + case 0: + r.Year = NewUnionNullInt() + + return r.Year + case 1: + r.Month = NewUnionNullInt() + + return r.Month + case 2: + r.Day = NewUnionNullInt() + + return r.Day + case 3: + r.Hour = NewUnionNullInt() + + return r.Hour + case 4: + r.Minute = NewUnionNullInt() + + return r.Minute + case 5: + r.Second = NewUnionNullInt() + + return r.Second + case 6: + r.Millis = NewUnionNullInt() + + return r.Millis + } + panic("Unknown field index") +} + +func (r *DateTime) SetDefault(i int) { + switch i { + case 0: + r.Year = nil + return + case 1: + r.Month = nil + return + case 2: + r.Day = nil + return + case 3: + r.Hour = nil + return + case 4: + r.Minute = nil + return + case 5: + r.Second = nil + return + case 6: + r.Millis = nil + return + } + panic("Unknown field index") +} + +func (r *DateTime) NullField(i int) { + switch i { + case 0: + r.Year = nil + return + case 1: + r.Month = nil + return + case 2: + r.Day = nil + return + case 3: + r.Hour = nil + return + case 4: + r.Minute = nil + return + case 5: + r.Second = nil + return + case 6: + r.Millis = nil + return + } + panic("Not a nullable field index") +} + +func (_ *DateTime) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *DateTime) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *DateTime) Finalize() {} + +func (_ *DateTime) AvroCRC64Fingerprint() []byte { + return []byte(DateTimeAvroCRC64Fingerprint) +} diff --git a/goimpl/lib/dtsavro/decimal.go b/goimpl/lib/dtsavro/decimal.go new file mode 100644 index 0000000..031169a --- /dev/null +++ b/goimpl/lib/dtsavro/decimal.go @@ -0,0 +1,126 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "github.com/actgardner/gogen-avro/v7/compiler" + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" + "io" +) + +type Decimal struct { + Value string `json:"value"` + + Precision int32 `json:"precision"` + + Scale int32 `json:"scale"` +} + +const DecimalAvroCRC64Fingerprint = "\xf2\x13\xb4\xe6RX\x93\x0f" + +func NewDecimal() *Decimal { + return &Decimal{} +} + +func DeserializeDecimal(r io.Reader) (*Decimal, error) { + t := NewDecimal() + deser, err := compiler.CompileSchemaBytes([]byte(t.Schema()), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func DeserializeDecimalFromSchema(r io.Reader, schema string) (*Decimal, error) { + t := NewDecimal() + + deser, err := compiler.CompileSchemaBytes([]byte(schema), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func writeDecimal(r *Decimal, w io.Writer) error { + var err error + err = vm.WriteString(r.Value, w) + if err != nil { + return err + } + err = vm.WriteInt(r.Precision, w) + if err != nil { + return err + } + err = vm.WriteInt(r.Scale, w) + if err != nil { + return err + } + return err +} + +func (r *Decimal) Serialize(w io.Writer) error { + return writeDecimal(r, w) +} + +func (r *Decimal) Schema() string { + return "{\"fields\":[{\"name\":\"value\",\"type\":\"string\"},{\"name\":\"precision\",\"type\":\"int\"},{\"name\":\"scale\",\"type\":\"int\"}],\"name\":\"com.alibaba.dts.formats.avro.Decimal\",\"type\":\"record\"}" +} + +func (r *Decimal) SchemaName() string { + return "com.alibaba.dts.formats.avro.Decimal" +} + +func (_ *Decimal) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *Decimal) SetInt(v int32) { panic("Unsupported operation") } +func (_ *Decimal) SetLong(v int64) { panic("Unsupported operation") } +func (_ *Decimal) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *Decimal) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *Decimal) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *Decimal) SetString(v string) { panic("Unsupported operation") } +func (_ *Decimal) SetUnionElem(v int64) { panic("Unsupported operation") } + +func (r *Decimal) Get(i int) types.Field { + switch i { + case 0: + return &types.String{Target: &r.Value} + case 1: + return &types.Int{Target: &r.Precision} + case 2: + return &types.Int{Target: &r.Scale} + } + panic("Unknown field index") +} + +func (r *Decimal) SetDefault(i int) { + switch i { + } + panic("Unknown field index") +} + +func (r *Decimal) NullField(i int) { + switch i { + } + panic("Not a nullable field index") +} + +func (_ *Decimal) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *Decimal) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *Decimal) Finalize() {} + +func (_ *Decimal) AvroCRC64Fingerprint() []byte { + return []byte(DecimalAvroCRC64Fingerprint) +} diff --git a/goimpl/lib/dtsavro/empty_object.go b/goimpl/lib/dtsavro/empty_object.go new file mode 100644 index 0000000..1651c8d --- /dev/null +++ b/goimpl/lib/dtsavro/empty_object.go @@ -0,0 +1,120 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" +) + +type EmptyObject int32 + +const ( + EmptyObjectNULL EmptyObject = 0 + EmptyObjectNONE EmptyObject = 1 +) + +func (e EmptyObject) String() string { + switch e { + case EmptyObjectNULL: + return "NULL" + case EmptyObjectNONE: + return "NONE" + } + return "unknown" +} + +func writeEmptyObject(r EmptyObject, w io.Writer) error { + return vm.WriteInt(int32(r), w) +} + +func NewEmptyObjectValue(raw string) (r EmptyObject, err error) { + switch raw { + case "NULL": + return EmptyObjectNULL, nil + case "NONE": + return EmptyObjectNONE, nil + } + + return -1, fmt.Errorf("invalid value for EmptyObject: '%s'", raw) +} + +func (b *EmptyObject) MarshalJSON() ([]byte, error) { + return json.Marshal([]byte(b.String())) +} + +func (b *EmptyObject) UnmarshalJSON(data []byte) error { + var stringVal string + err := json.Unmarshal(data, &stringVal) + if err != nil { + return err + } + val, err := NewEmptyObjectValue(stringVal) + *b = val + return err +} + +type EmptyObjectWrapper struct { + Target *EmptyObject +} + +func (b *EmptyObjectWrapper) SetBoolean(v bool) { + panic("Unable to assign boolean to int field") +} + +func (b *EmptyObjectWrapper) SetInt(v int32) { + *(b.Target) = EmptyObject(v) +} + +func (b *EmptyObjectWrapper) SetLong(v int64) { + panic("Unable to assign long to int field") +} + +func (b *EmptyObjectWrapper) SetFloat(v float32) { + panic("Unable to assign float to int field") +} + +func (b *EmptyObjectWrapper) SetUnionElem(v int64) { + panic("Unable to assign union elem to int field") +} + +func (b *EmptyObjectWrapper) SetDouble(v float64) { + panic("Unable to assign double to int field") +} + +func (b *EmptyObjectWrapper) SetBytes(v []byte) { + panic("Unable to assign bytes to int field") +} + +func (b *EmptyObjectWrapper) SetString(v string) { + panic("Unable to assign string to int field") +} + +func (b *EmptyObjectWrapper) Get(i int) types.Field { + panic("Unable to get field from int field") +} + +func (b *EmptyObjectWrapper) SetDefault(i int) { + panic("Unable to set default on int field") +} + +func (b *EmptyObjectWrapper) AppendMap(key string) types.Field { + panic("Unable to append map key to from int field") +} + +func (b *EmptyObjectWrapper) AppendArray() types.Field { + panic("Unable to append array element to from int field") +} + +func (b *EmptyObjectWrapper) NullField(int) { + panic("Unable to null field in int field") +} + +func (b *EmptyObjectWrapper) Finalize() {} diff --git a/goimpl/lib/dtsavro/field.go b/goimpl/lib/dtsavro/field.go new file mode 100644 index 0000000..f1acbea --- /dev/null +++ b/goimpl/lib/dtsavro/field.go @@ -0,0 +1,118 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "github.com/actgardner/gogen-avro/v7/compiler" + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" + "io" +) + +type Field struct { + Name string `json:"name"` + + DataTypeNumber int32 `json:"dataTypeNumber"` +} + +const FieldAvroCRC64Fingerprint = "\xa4\x82\xda_\x04c\xb1\x00" + +func NewField() *Field { + return &Field{} +} + +func DeserializeField(r io.Reader) (*Field, error) { + t := NewField() + deser, err := compiler.CompileSchemaBytes([]byte(t.Schema()), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func DeserializeFieldFromSchema(r io.Reader, schema string) (*Field, error) { + t := NewField() + + deser, err := compiler.CompileSchemaBytes([]byte(schema), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func writeField(r *Field, w io.Writer) error { + var err error + err = vm.WriteString(r.Name, w) + if err != nil { + return err + } + err = vm.WriteInt(r.DataTypeNumber, w) + if err != nil { + return err + } + return err +} + +func (r *Field) Serialize(w io.Writer) error { + return writeField(r, w) +} + +func (r *Field) Schema() string { + return "{\"fields\":[{\"name\":\"name\",\"type\":\"string\"},{\"name\":\"dataTypeNumber\",\"type\":\"int\"}],\"name\":\"com.alibaba.dts.formats.avro.Field\",\"type\":\"record\"}" +} + +func (r *Field) SchemaName() string { + return "com.alibaba.dts.formats.avro.Field" +} + +func (_ *Field) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *Field) SetInt(v int32) { panic("Unsupported operation") } +func (_ *Field) SetLong(v int64) { panic("Unsupported operation") } +func (_ *Field) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *Field) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *Field) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *Field) SetString(v string) { panic("Unsupported operation") } +func (_ *Field) SetUnionElem(v int64) { panic("Unsupported operation") } + +func (r *Field) Get(i int) types.Field { + switch i { + case 0: + return &types.String{Target: &r.Name} + case 1: + return &types.Int{Target: &r.DataTypeNumber} + } + panic("Unknown field index") +} + +func (r *Field) SetDefault(i int) { + switch i { + } + panic("Unknown field index") +} + +func (r *Field) NullField(i int) { + switch i { + } + panic("Not a nullable field index") +} + +func (_ *Field) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *Field) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *Field) Finalize() {} + +func (_ *Field) AvroCRC64Fingerprint() []byte { + return []byte(FieldAvroCRC64Fingerprint) +} diff --git a/goimpl/lib/dtsavro/float.go b/goimpl/lib/dtsavro/float.go new file mode 100644 index 0000000..384b235 --- /dev/null +++ b/goimpl/lib/dtsavro/float.go @@ -0,0 +1,126 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "github.com/actgardner/gogen-avro/v7/compiler" + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" + "io" +) + +type Float struct { + Value float64 `json:"value"` + + Precision int32 `json:"precision"` + + Scale int32 `json:"scale"` +} + +const FloatAvroCRC64Fingerprint = "\xf1N6\xa3\x8b#\xad\xe5" + +func NewFloat() *Float { + return &Float{} +} + +func DeserializeFloat(r io.Reader) (*Float, error) { + t := NewFloat() + deser, err := compiler.CompileSchemaBytes([]byte(t.Schema()), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func DeserializeFloatFromSchema(r io.Reader, schema string) (*Float, error) { + t := NewFloat() + + deser, err := compiler.CompileSchemaBytes([]byte(schema), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func writeFloat(r *Float, w io.Writer) error { + var err error + err = vm.WriteDouble(r.Value, w) + if err != nil { + return err + } + err = vm.WriteInt(r.Precision, w) + if err != nil { + return err + } + err = vm.WriteInt(r.Scale, w) + if err != nil { + return err + } + return err +} + +func (r *Float) Serialize(w io.Writer) error { + return writeFloat(r, w) +} + +func (r *Float) Schema() string { + return "{\"fields\":[{\"name\":\"value\",\"type\":\"double\"},{\"name\":\"precision\",\"type\":\"int\"},{\"name\":\"scale\",\"type\":\"int\"}],\"name\":\"com.alibaba.dts.formats.avro.Float\",\"type\":\"record\"}" +} + +func (r *Float) SchemaName() string { + return "com.alibaba.dts.formats.avro.Float" +} + +func (_ *Float) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *Float) SetInt(v int32) { panic("Unsupported operation") } +func (_ *Float) SetLong(v int64) { panic("Unsupported operation") } +func (_ *Float) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *Float) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *Float) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *Float) SetString(v string) { panic("Unsupported operation") } +func (_ *Float) SetUnionElem(v int64) { panic("Unsupported operation") } + +func (r *Float) Get(i int) types.Field { + switch i { + case 0: + return &types.Double{Target: &r.Value} + case 1: + return &types.Int{Target: &r.Precision} + case 2: + return &types.Int{Target: &r.Scale} + } + panic("Unknown field index") +} + +func (r *Float) SetDefault(i int) { + switch i { + } + panic("Unknown field index") +} + +func (r *Float) NullField(i int) { + switch i { + } + panic("Not a nullable field index") +} + +func (_ *Float) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *Float) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *Float) Finalize() {} + +func (_ *Float) AvroCRC64Fingerprint() []byte { + return []byte(FloatAvroCRC64Fingerprint) +} diff --git a/goimpl/lib/dtsavro/integer.go b/goimpl/lib/dtsavro/integer.go new file mode 100644 index 0000000..a239062 --- /dev/null +++ b/goimpl/lib/dtsavro/integer.go @@ -0,0 +1,118 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "github.com/actgardner/gogen-avro/v7/compiler" + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" + "io" +) + +type Integer struct { + Precision int32 `json:"precision"` + + Value string `json:"value"` +} + +const IntegerAvroCRC64Fingerprint = "\xbcV\u07bc\x88\xb9hx" + +func NewInteger() *Integer { + return &Integer{} +} + +func DeserializeInteger(r io.Reader) (*Integer, error) { + t := NewInteger() + deser, err := compiler.CompileSchemaBytes([]byte(t.Schema()), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func DeserializeIntegerFromSchema(r io.Reader, schema string) (*Integer, error) { + t := NewInteger() + + deser, err := compiler.CompileSchemaBytes([]byte(schema), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func writeInteger(r *Integer, w io.Writer) error { + var err error + err = vm.WriteInt(r.Precision, w) + if err != nil { + return err + } + err = vm.WriteString(r.Value, w) + if err != nil { + return err + } + return err +} + +func (r *Integer) Serialize(w io.Writer) error { + return writeInteger(r, w) +} + +func (r *Integer) Schema() string { + return "{\"fields\":[{\"name\":\"precision\",\"type\":\"int\"},{\"name\":\"value\",\"type\":\"string\"}],\"name\":\"com.alibaba.dts.formats.avro.Integer\",\"type\":\"record\"}" +} + +func (r *Integer) SchemaName() string { + return "com.alibaba.dts.formats.avro.Integer" +} + +func (_ *Integer) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *Integer) SetInt(v int32) { panic("Unsupported operation") } +func (_ *Integer) SetLong(v int64) { panic("Unsupported operation") } +func (_ *Integer) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *Integer) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *Integer) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *Integer) SetString(v string) { panic("Unsupported operation") } +func (_ *Integer) SetUnionElem(v int64) { panic("Unsupported operation") } + +func (r *Integer) Get(i int) types.Field { + switch i { + case 0: + return &types.Int{Target: &r.Precision} + case 1: + return &types.String{Target: &r.Value} + } + panic("Unknown field index") +} + +func (r *Integer) SetDefault(i int) { + switch i { + } + panic("Unknown field index") +} + +func (r *Integer) NullField(i int) { + switch i { + } + panic("Not a nullable field index") +} + +func (_ *Integer) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *Integer) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *Integer) Finalize() {} + +func (_ *Integer) AvroCRC64Fingerprint() []byte { + return []byte(IntegerAvroCRC64Fingerprint) +} diff --git a/goimpl/lib/dtsavro/map_string.go b/goimpl/lib/dtsavro/map_string.go new file mode 100644 index 0000000..133cec6 --- /dev/null +++ b/goimpl/lib/dtsavro/map_string.go @@ -0,0 +1,66 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" + "io" +) + +func writeMapString(r map[string]string, w io.Writer) error { + err := vm.WriteLong(int64(len(r)), w) + if err != nil || len(r) == 0 { + return err + } + for k, e := range r { + err = vm.WriteString(k, w) + if err != nil { + return err + } + err = vm.WriteString(e, w) + if err != nil { + return err + } + } + return vm.WriteLong(0, w) +} + +type MapStringWrapper struct { + Target *map[string]string + keys []string + values []string +} + +func (_ *MapStringWrapper) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *MapStringWrapper) SetInt(v int32) { panic("Unsupported operation") } +func (_ *MapStringWrapper) SetLong(v int64) { panic("Unsupported operation") } +func (_ *MapStringWrapper) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *MapStringWrapper) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *MapStringWrapper) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *MapStringWrapper) SetString(v string) { panic("Unsupported operation") } +func (_ *MapStringWrapper) SetUnionElem(v int64) { panic("Unsupported operation") } +func (_ *MapStringWrapper) Get(i int) types.Field { panic("Unsupported operation") } +func (_ *MapStringWrapper) SetDefault(i int) { panic("Unsupported operation") } + +func (r *MapStringWrapper) NullField(_ int) { + panic("Unsupported operation") +} + +func (r *MapStringWrapper) Finalize() { + for i := range r.keys { + (*r.Target)[r.keys[i]] = r.values[i] + } +} + +func (r *MapStringWrapper) AppendMap(key string) types.Field { + r.keys = append(r.keys, key) + var v string + r.values = append(r.values, v) + return &types.String{Target: &r.values[len(r.values)-1]} +} + +func (_ *MapStringWrapper) AppendArray() types.Field { panic("Unsupported operation") } diff --git a/goimpl/lib/dtsavro/operation.go b/goimpl/lib/dtsavro/operation.go new file mode 100644 index 0000000..cfb747b --- /dev/null +++ b/goimpl/lib/dtsavro/operation.go @@ -0,0 +1,195 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" +) + +type Operation int32 + +const ( + OperationINSERT Operation = 0 + OperationUPDATE Operation = 1 + OperationDELETE Operation = 2 + OperationDDL Operation = 3 + OperationBEGIN Operation = 4 + OperationCOMMIT Operation = 5 + OperationROLLBACK Operation = 6 + OperationABORT Operation = 7 + OperationHEARTBEAT Operation = 8 + OperationCHECKPOINT Operation = 9 + OperationCOMMAND Operation = 10 + OperationFILL Operation = 11 + OperationFINISH Operation = 12 + OperationCONTROL Operation = 13 + OperationRDB Operation = 14 + OperationNOOP Operation = 15 + OperationINIT Operation = 16 +) + +func (e Operation) String() string { + switch e { + case OperationINSERT: + return "INSERT" + case OperationUPDATE: + return "UPDATE" + case OperationDELETE: + return "DELETE" + case OperationDDL: + return "DDL" + case OperationBEGIN: + return "BEGIN" + case OperationCOMMIT: + return "COMMIT" + case OperationROLLBACK: + return "ROLLBACK" + case OperationABORT: + return "ABORT" + case OperationHEARTBEAT: + return "HEARTBEAT" + case OperationCHECKPOINT: + return "CHECKPOINT" + case OperationCOMMAND: + return "COMMAND" + case OperationFILL: + return "FILL" + case OperationFINISH: + return "FINISH" + case OperationCONTROL: + return "CONTROL" + case OperationRDB: + return "RDB" + case OperationNOOP: + return "NOOP" + case OperationINIT: + return "INIT" + } + return "unknown" +} + +func writeOperation(r Operation, w io.Writer) error { + return vm.WriteInt(int32(r), w) +} + +func NewOperationValue(raw string) (r Operation, err error) { + switch raw { + case "INSERT": + return OperationINSERT, nil + case "UPDATE": + return OperationUPDATE, nil + case "DELETE": + return OperationDELETE, nil + case "DDL": + return OperationDDL, nil + case "BEGIN": + return OperationBEGIN, nil + case "COMMIT": + return OperationCOMMIT, nil + case "ROLLBACK": + return OperationROLLBACK, nil + case "ABORT": + return OperationABORT, nil + case "HEARTBEAT": + return OperationHEARTBEAT, nil + case "CHECKPOINT": + return OperationCHECKPOINT, nil + case "COMMAND": + return OperationCOMMAND, nil + case "FILL": + return OperationFILL, nil + case "FINISH": + return OperationFINISH, nil + case "CONTROL": + return OperationCONTROL, nil + case "RDB": + return OperationRDB, nil + case "NOOP": + return OperationNOOP, nil + case "INIT": + return OperationINIT, nil + } + + return -1, fmt.Errorf("invalid value for Operation: '%s'", raw) +} + +func (b *Operation) MarshalJSON() ([]byte, error) { + return json.Marshal([]byte(b.String())) +} + +func (b *Operation) UnmarshalJSON(data []byte) error { + var stringVal string + err := json.Unmarshal(data, &stringVal) + if err != nil { + return err + } + val, err := NewOperationValue(stringVal) + *b = val + return err +} + +type OperationWrapper struct { + Target *Operation +} + +func (b *OperationWrapper) SetBoolean(v bool) { + panic("Unable to assign boolean to int field") +} + +func (b *OperationWrapper) SetInt(v int32) { + *(b.Target) = Operation(v) +} + +func (b *OperationWrapper) SetLong(v int64) { + panic("Unable to assign long to int field") +} + +func (b *OperationWrapper) SetFloat(v float32) { + panic("Unable to assign float to int field") +} + +func (b *OperationWrapper) SetUnionElem(v int64) { + panic("Unable to assign union elem to int field") +} + +func (b *OperationWrapper) SetDouble(v float64) { + panic("Unable to assign double to int field") +} + +func (b *OperationWrapper) SetBytes(v []byte) { + panic("Unable to assign bytes to int field") +} + +func (b *OperationWrapper) SetString(v string) { + panic("Unable to assign string to int field") +} + +func (b *OperationWrapper) Get(i int) types.Field { + panic("Unable to get field from int field") +} + +func (b *OperationWrapper) SetDefault(i int) { + panic("Unable to set default on int field") +} + +func (b *OperationWrapper) AppendMap(key string) types.Field { + panic("Unable to append map key to from int field") +} + +func (b *OperationWrapper) AppendArray() types.Field { + panic("Unable to append array element to from int field") +} + +func (b *OperationWrapper) NullField(int) { + panic("Unable to null field in int field") +} + +func (b *OperationWrapper) Finalize() {} diff --git a/goimpl/lib/dtsavro/record.go b/goimpl/lib/dtsavro/record.go new file mode 100644 index 0000000..c06fa9b --- /dev/null +++ b/goimpl/lib/dtsavro/record.go @@ -0,0 +1,279 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "github.com/actgardner/gogen-avro/v7/compiler" + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" + "io" +) + +type Record struct { + // version infomation + Version int32 `json:"version"` + // unique id of this record in the whole stream + Id int64 `json:"id"` + // record log timestamp + SourceTimestamp int64 `json:"sourceTimestamp"` + // record source location information + SourcePosition string `json:"sourcePosition"` + // safe record source location information, use to recovery. + SafeSourcePosition string `json:"safeSourcePosition"` + // record transation id + SourceTxid string `json:"sourceTxid"` + // source dataource + Source *Source `json:"source"` + + Operation Operation `json:"operation"` + + ObjectName *UnionNullString `json:"objectName"` + // time when this record is processed along the stream dataflow + ProcessTimestamps *UnionNullArrayLong `json:"processTimestamps"` + // tags to identify properties of this record + Tags map[string]string `json:"tags"` + + Fields *UnionNullStringArrayField `json:"fields"` + + BeforeImages *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject `json:"beforeImages"` + + AfterImages *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject `json:"afterImages"` + // the timestamp in unit of millisecond that record is born in source + BornTimestamp int64 `json:"bornTimestamp"` +} + +const RecordAvroCRC64Fingerprint = "x\xc4\xc4yg\x16\xeb\xae" + +func NewRecord() *Record { + return &Record{} +} + +func DeserializeRecord(r io.Reader) (*Record, error) { + t := NewRecord() + deser, err := compiler.CompileSchemaBytes([]byte(t.Schema()), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func DeserializeRecordFromSchema(r io.Reader, schema string) (*Record, error) { + t := NewRecord() + + deser, err := compiler.CompileSchemaBytes([]byte(schema), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func writeRecord(r *Record, w io.Writer) error { + var err error + err = vm.WriteInt(r.Version, w) + if err != nil { + return err + } + err = vm.WriteLong(r.Id, w) + if err != nil { + return err + } + err = vm.WriteLong(r.SourceTimestamp, w) + if err != nil { + return err + } + err = vm.WriteString(r.SourcePosition, w) + if err != nil { + return err + } + err = vm.WriteString(r.SafeSourcePosition, w) + if err != nil { + return err + } + err = vm.WriteString(r.SourceTxid, w) + if err != nil { + return err + } + err = writeSource(r.Source, w) + if err != nil { + return err + } + err = writeOperation(r.Operation, w) + if err != nil { + return err + } + err = writeUnionNullString(r.ObjectName, w) + if err != nil { + return err + } + err = writeUnionNullArrayLong(r.ProcessTimestamps, w) + if err != nil { + return err + } + err = writeMapString(r.Tags, w) + if err != nil { + return err + } + err = writeUnionNullStringArrayField(r.Fields, w) + if err != nil { + return err + } + err = writeUnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject(r.BeforeImages, w) + if err != nil { + return err + } + err = writeUnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject(r.AfterImages, w) + if err != nil { + return err + } + err = vm.WriteLong(r.BornTimestamp, w) + if err != nil { + return err + } + return err +} + +func (r *Record) Serialize(w io.Writer) error { + return writeRecord(r, w) +} + +func (r *Record) Schema() string { + return "{\"fields\":[{\"doc\":\"version infomation\",\"name\":\"version\",\"type\":\"int\"},{\"doc\":\"unique id of this record in the whole stream\",\"name\":\"id\",\"type\":\"long\"},{\"doc\":\"record log timestamp\",\"name\":\"sourceTimestamp\",\"type\":\"long\"},{\"doc\":\"record source location information\",\"name\":\"sourcePosition\",\"type\":\"string\"},{\"default\":\"\",\"doc\":\"safe record source location information, use to recovery.\",\"name\":\"safeSourcePosition\",\"type\":\"string\"},{\"default\":\"\",\"doc\":\"record transation id\",\"name\":\"sourceTxid\",\"type\":\"string\"},{\"doc\":\"source dataource\",\"name\":\"source\",\"type\":{\"fields\":[{\"name\":\"sourceType\",\"type\":{\"name\":\"SourceType\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"symbols\":[\"MySQL\",\"Oracle\",\"SQLServer\",\"PostgreSQL\",\"MongoDB\",\"Redis\",\"DB2\",\"PPAS\",\"DRDS\",\"HBASE\",\"HDFS\",\"FILE\",\"OTHER\"],\"type\":\"enum\"}},{\"doc\":\"source datasource version information\",\"name\":\"version\",\"type\":\"string\"}],\"name\":\"Source\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"type\":\"record\"}},{\"name\":\"operation\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"type\":{\"name\":\"Operation\",\"symbols\":[\"INSERT\",\"UPDATE\",\"DELETE\",\"DDL\",\"BEGIN\",\"COMMIT\",\"ROLLBACK\",\"ABORT\",\"HEARTBEAT\",\"CHECKPOINT\",\"COMMAND\",\"FILL\",\"FINISH\",\"CONTROL\",\"RDB\",\"NOOP\",\"INIT\"],\"type\":\"enum\"}},{\"default\":null,\"name\":\"objectName\",\"type\":[\"null\",\"string\"]},{\"default\":null,\"doc\":\"time when this record is processed along the stream dataflow\",\"name\":\"processTimestamps\",\"type\":[\"null\",{\"items\":\"long\",\"type\":\"array\"}]},{\"default\":{},\"doc\":\"tags to identify properties of this record\",\"name\":\"tags\",\"type\":{\"type\":\"map\",\"values\":\"string\"}},{\"default\":null,\"name\":\"fields\",\"type\":[\"null\",\"string\",{\"items\":{\"fields\":[{\"name\":\"name\",\"type\":\"string\"},{\"name\":\"dataTypeNumber\",\"type\":\"int\"}],\"name\":\"Field\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"type\":\"record\"},\"type\":\"array\"}]},{\"default\":null,\"name\":\"beforeImages\",\"type\":[\"null\",\"string\",{\"items\":[\"null\",{\"fields\":[{\"name\":\"precision\",\"type\":\"int\"},{\"name\":\"value\",\"type\":\"string\"}],\"name\":\"Integer\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"type\":\"record\"},{\"fields\":[{\"name\":\"charset\",\"type\":\"string\"},{\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"Character\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"type\":\"record\"},{\"fields\":[{\"name\":\"value\",\"type\":\"string\"},{\"name\":\"precision\",\"type\":\"int\"},{\"name\":\"scale\",\"type\":\"int\"}],\"name\":\"Decimal\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"type\":\"record\"},{\"fields\":[{\"name\":\"value\",\"type\":\"double\"},{\"name\":\"precision\",\"type\":\"int\"},{\"name\":\"scale\",\"type\":\"int\"}],\"name\":\"Float\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"type\":\"record\"},{\"fields\":[{\"name\":\"timestamp\",\"type\":\"long\"},{\"name\":\"millis\",\"type\":\"int\"}],\"name\":\"Timestamp\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"type\":\"record\"},{\"fields\":[{\"default\":null,\"name\":\"year\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"month\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"day\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"hour\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"minute\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"second\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"millis\",\"type\":[\"null\",\"int\"]}],\"name\":\"DateTime\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"type\":\"record\"},{\"fields\":[{\"name\":\"value\",\"type\":\"com.alibaba.dts.formats.avro.DateTime\"},{\"name\":\"timezone\",\"type\":\"string\"}],\"name\":\"TimestampWithTimeZone\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"type\":\"record\"},{\"fields\":[{\"name\":\"type\",\"type\":\"string\"},{\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"BinaryGeometry\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"type\":\"record\"},{\"fields\":[{\"name\":\"type\",\"type\":\"string\"},{\"name\":\"value\",\"type\":\"string\"}],\"name\":\"TextGeometry\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"type\":\"record\"},{\"fields\":[{\"name\":\"type\",\"type\":\"string\"},{\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"BinaryObject\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"type\":\"record\"},{\"fields\":[{\"name\":\"type\",\"type\":\"string\"},{\"name\":\"value\",\"type\":\"string\"}],\"name\":\"TextObject\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"type\":\"record\"},{\"name\":\"EmptyObject\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"symbols\":[\"NULL\",\"NONE\"],\"type\":\"enum\"}],\"type\":\"array\"}]},{\"default\":null,\"name\":\"afterImages\",\"type\":[\"null\",\"string\",{\"items\":[\"null\",\"com.alibaba.dts.formats.avro.Integer\",\"com.alibaba.dts.formats.avro.Character\",\"com.alibaba.dts.formats.avro.Decimal\",\"com.alibaba.dts.formats.avro.Float\",\"com.alibaba.dts.formats.avro.Timestamp\",\"com.alibaba.dts.formats.avro.DateTime\",\"com.alibaba.dts.formats.avro.TimestampWithTimeZone\",\"com.alibaba.dts.formats.avro.BinaryGeometry\",\"com.alibaba.dts.formats.avro.TextGeometry\",\"com.alibaba.dts.formats.avro.BinaryObject\",\"com.alibaba.dts.formats.avro.TextObject\",\"com.alibaba.dts.formats.avro.EmptyObject\"],\"type\":\"array\"}]},{\"default\":0,\"doc\":\"the timestamp in unit of millisecond that record is born in source\",\"name\":\"bornTimestamp\",\"type\":\"long\"}],\"name\":\"com.alibaba.dts.formats.avro.Record\",\"type\":\"record\"}" +} + +func (r *Record) SchemaName() string { + return "com.alibaba.dts.formats.avro.Record" +} + +func (_ *Record) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *Record) SetInt(v int32) { panic("Unsupported operation") } +func (_ *Record) SetLong(v int64) { panic("Unsupported operation") } +func (_ *Record) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *Record) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *Record) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *Record) SetString(v string) { panic("Unsupported operation") } +func (_ *Record) SetUnionElem(v int64) { panic("Unsupported operation") } + +func (r *Record) Get(i int) types.Field { + switch i { + case 0: + return &types.Int{Target: &r.Version} + case 1: + return &types.Long{Target: &r.Id} + case 2: + return &types.Long{Target: &r.SourceTimestamp} + case 3: + return &types.String{Target: &r.SourcePosition} + case 4: + return &types.String{Target: &r.SafeSourcePosition} + case 5: + return &types.String{Target: &r.SourceTxid} + case 6: + r.Source = NewSource() + + return r.Source + case 7: + return &OperationWrapper{Target: &r.Operation} + case 8: + r.ObjectName = NewUnionNullString() + + return r.ObjectName + case 9: + r.ProcessTimestamps = NewUnionNullArrayLong() + + return r.ProcessTimestamps + case 10: + r.Tags = make(map[string]string) + + return &MapStringWrapper{Target: &r.Tags} + case 11: + r.Fields = NewUnionNullStringArrayField() + + return r.Fields + case 12: + r.BeforeImages = NewUnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject() + + return r.BeforeImages + case 13: + r.AfterImages = NewUnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject() + + return r.AfterImages + case 14: + return &types.Long{Target: &r.BornTimestamp} + } + panic("Unknown field index") +} + +func (r *Record) SetDefault(i int) { + switch i { + case 4: + r.SafeSourcePosition = "" + return + case 5: + r.SourceTxid = "" + return + case 8: + r.ObjectName = nil + return + case 9: + r.ProcessTimestamps = nil + return + case 10: + + return + case 11: + r.Fields = nil + return + case 12: + r.BeforeImages = nil + return + case 13: + r.AfterImages = nil + return + case 14: + r.BornTimestamp = 0 + return + } + panic("Unknown field index") +} + +func (r *Record) NullField(i int) { + switch i { + case 8: + r.ObjectName = nil + return + case 9: + r.ProcessTimestamps = nil + return + case 11: + r.Fields = nil + return + case 12: + r.BeforeImages = nil + return + case 13: + r.AfterImages = nil + return + } + panic("Not a nullable field index") +} + +func (_ *Record) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *Record) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *Record) Finalize() {} + +func (_ *Record) AvroCRC64Fingerprint() []byte { + return []byte(RecordAvroCRC64Fingerprint) +} diff --git a/goimpl/lib/dtsavro/source.go b/goimpl/lib/dtsavro/source.go new file mode 100644 index 0000000..ede11be --- /dev/null +++ b/goimpl/lib/dtsavro/source.go @@ -0,0 +1,118 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "github.com/actgardner/gogen-avro/v7/compiler" + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" + "io" +) + +type Source struct { + SourceType SourceType `json:"sourceType"` + // source datasource version information + Version string `json:"version"` +} + +const SourceAvroCRC64Fingerprint = "Z\xe3G\xb0O\u007f\xb4z" + +func NewSource() *Source { + return &Source{} +} + +func DeserializeSource(r io.Reader) (*Source, error) { + t := NewSource() + deser, err := compiler.CompileSchemaBytes([]byte(t.Schema()), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func DeserializeSourceFromSchema(r io.Reader, schema string) (*Source, error) { + t := NewSource() + + deser, err := compiler.CompileSchemaBytes([]byte(schema), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func writeSource(r *Source, w io.Writer) error { + var err error + err = writeSourceType(r.SourceType, w) + if err != nil { + return err + } + err = vm.WriteString(r.Version, w) + if err != nil { + return err + } + return err +} + +func (r *Source) Serialize(w io.Writer) error { + return writeSource(r, w) +} + +func (r *Source) Schema() string { + return "{\"fields\":[{\"name\":\"sourceType\",\"type\":{\"name\":\"SourceType\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"symbols\":[\"MySQL\",\"Oracle\",\"SQLServer\",\"PostgreSQL\",\"MongoDB\",\"Redis\",\"DB2\",\"PPAS\",\"DRDS\",\"HBASE\",\"HDFS\",\"FILE\",\"OTHER\"],\"type\":\"enum\"}},{\"doc\":\"source datasource version information\",\"name\":\"version\",\"type\":\"string\"}],\"name\":\"com.alibaba.dts.formats.avro.Source\",\"type\":\"record\"}" +} + +func (r *Source) SchemaName() string { + return "com.alibaba.dts.formats.avro.Source" +} + +func (_ *Source) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *Source) SetInt(v int32) { panic("Unsupported operation") } +func (_ *Source) SetLong(v int64) { panic("Unsupported operation") } +func (_ *Source) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *Source) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *Source) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *Source) SetString(v string) { panic("Unsupported operation") } +func (_ *Source) SetUnionElem(v int64) { panic("Unsupported operation") } + +func (r *Source) Get(i int) types.Field { + switch i { + case 0: + return &SourceTypeWrapper{Target: &r.SourceType} + case 1: + return &types.String{Target: &r.Version} + } + panic("Unknown field index") +} + +func (r *Source) SetDefault(i int) { + switch i { + } + panic("Unknown field index") +} + +func (r *Source) NullField(i int) { + switch i { + } + panic("Not a nullable field index") +} + +func (_ *Source) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *Source) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *Source) Finalize() {} + +func (_ *Source) AvroCRC64Fingerprint() []byte { + return []byte(SourceAvroCRC64Fingerprint) +} diff --git a/goimpl/lib/dtsavro/source_type.go b/goimpl/lib/dtsavro/source_type.go new file mode 100644 index 0000000..827e645 --- /dev/null +++ b/goimpl/lib/dtsavro/source_type.go @@ -0,0 +1,175 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" +) + +type SourceType int32 + +const ( + SourceTypeMySQL SourceType = 0 + SourceTypeOracle SourceType = 1 + SourceTypeSQLServer SourceType = 2 + SourceTypePostgreSQL SourceType = 3 + SourceTypeMongoDB SourceType = 4 + SourceTypeRedis SourceType = 5 + SourceTypeDB2 SourceType = 6 + SourceTypePPAS SourceType = 7 + SourceTypeDRDS SourceType = 8 + SourceTypeHBASE SourceType = 9 + SourceTypeHDFS SourceType = 10 + SourceTypeFILE SourceType = 11 + SourceTypeOTHER SourceType = 12 +) + +func (e SourceType) String() string { + switch e { + case SourceTypeMySQL: + return "MySQL" + case SourceTypeOracle: + return "Oracle" + case SourceTypeSQLServer: + return "SQLServer" + case SourceTypePostgreSQL: + return "PostgreSQL" + case SourceTypeMongoDB: + return "MongoDB" + case SourceTypeRedis: + return "Redis" + case SourceTypeDB2: + return "DB2" + case SourceTypePPAS: + return "PPAS" + case SourceTypeDRDS: + return "DRDS" + case SourceTypeHBASE: + return "HBASE" + case SourceTypeHDFS: + return "HDFS" + case SourceTypeFILE: + return "FILE" + case SourceTypeOTHER: + return "OTHER" + } + return "unknown" +} + +func writeSourceType(r SourceType, w io.Writer) error { + return vm.WriteInt(int32(r), w) +} + +func NewSourceTypeValue(raw string) (r SourceType, err error) { + switch raw { + case "MySQL": + return SourceTypeMySQL, nil + case "Oracle": + return SourceTypeOracle, nil + case "SQLServer": + return SourceTypeSQLServer, nil + case "PostgreSQL": + return SourceTypePostgreSQL, nil + case "MongoDB": + return SourceTypeMongoDB, nil + case "Redis": + return SourceTypeRedis, nil + case "DB2": + return SourceTypeDB2, nil + case "PPAS": + return SourceTypePPAS, nil + case "DRDS": + return SourceTypeDRDS, nil + case "HBASE": + return SourceTypeHBASE, nil + case "HDFS": + return SourceTypeHDFS, nil + case "FILE": + return SourceTypeFILE, nil + case "OTHER": + return SourceTypeOTHER, nil + } + + return -1, fmt.Errorf("invalid value for SourceType: '%s'", raw) +} + +func (b *SourceType) MarshalJSON() ([]byte, error) { + return json.Marshal([]byte(b.String())) +} + +func (b *SourceType) UnmarshalJSON(data []byte) error { + var stringVal string + err := json.Unmarshal(data, &stringVal) + if err != nil { + return err + } + val, err := NewSourceTypeValue(stringVal) + *b = val + return err +} + +type SourceTypeWrapper struct { + Target *SourceType +} + +func (b *SourceTypeWrapper) SetBoolean(v bool) { + panic("Unable to assign boolean to int field") +} + +func (b *SourceTypeWrapper) SetInt(v int32) { + *(b.Target) = SourceType(v) +} + +func (b *SourceTypeWrapper) SetLong(v int64) { + panic("Unable to assign long to int field") +} + +func (b *SourceTypeWrapper) SetFloat(v float32) { + panic("Unable to assign float to int field") +} + +func (b *SourceTypeWrapper) SetUnionElem(v int64) { + panic("Unable to assign union elem to int field") +} + +func (b *SourceTypeWrapper) SetDouble(v float64) { + panic("Unable to assign double to int field") +} + +func (b *SourceTypeWrapper) SetBytes(v []byte) { + panic("Unable to assign bytes to int field") +} + +func (b *SourceTypeWrapper) SetString(v string) { + panic("Unable to assign string to int field") +} + +func (b *SourceTypeWrapper) Get(i int) types.Field { + panic("Unable to get field from int field") +} + +func (b *SourceTypeWrapper) SetDefault(i int) { + panic("Unable to set default on int field") +} + +func (b *SourceTypeWrapper) AppendMap(key string) types.Field { + panic("Unable to append map key to from int field") +} + +func (b *SourceTypeWrapper) AppendArray() types.Field { + panic("Unable to append array element to from int field") +} + +func (b *SourceTypeWrapper) NullField(int) { + panic("Unable to null field in int field") +} + +func (b *SourceTypeWrapper) Finalize() {} diff --git a/goimpl/lib/dtsavro/text_geometry.go b/goimpl/lib/dtsavro/text_geometry.go new file mode 100644 index 0000000..48ff71d --- /dev/null +++ b/goimpl/lib/dtsavro/text_geometry.go @@ -0,0 +1,118 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "github.com/actgardner/gogen-avro/v7/compiler" + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" + "io" +) + +type TextGeometry struct { + Type string `json:"type"` + + Value string `json:"value"` +} + +const TextGeometryAvroCRC64Fingerprint = "\xa0e\x94\x95=\xfb\xb2r" + +func NewTextGeometry() *TextGeometry { + return &TextGeometry{} +} + +func DeserializeTextGeometry(r io.Reader) (*TextGeometry, error) { + t := NewTextGeometry() + deser, err := compiler.CompileSchemaBytes([]byte(t.Schema()), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func DeserializeTextGeometryFromSchema(r io.Reader, schema string) (*TextGeometry, error) { + t := NewTextGeometry() + + deser, err := compiler.CompileSchemaBytes([]byte(schema), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func writeTextGeometry(r *TextGeometry, w io.Writer) error { + var err error + err = vm.WriteString(r.Type, w) + if err != nil { + return err + } + err = vm.WriteString(r.Value, w) + if err != nil { + return err + } + return err +} + +func (r *TextGeometry) Serialize(w io.Writer) error { + return writeTextGeometry(r, w) +} + +func (r *TextGeometry) Schema() string { + return "{\"fields\":[{\"name\":\"type\",\"type\":\"string\"},{\"name\":\"value\",\"type\":\"string\"}],\"name\":\"com.alibaba.dts.formats.avro.TextGeometry\",\"type\":\"record\"}" +} + +func (r *TextGeometry) SchemaName() string { + return "com.alibaba.dts.formats.avro.TextGeometry" +} + +func (_ *TextGeometry) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *TextGeometry) SetInt(v int32) { panic("Unsupported operation") } +func (_ *TextGeometry) SetLong(v int64) { panic("Unsupported operation") } +func (_ *TextGeometry) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *TextGeometry) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *TextGeometry) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *TextGeometry) SetString(v string) { panic("Unsupported operation") } +func (_ *TextGeometry) SetUnionElem(v int64) { panic("Unsupported operation") } + +func (r *TextGeometry) Get(i int) types.Field { + switch i { + case 0: + return &types.String{Target: &r.Type} + case 1: + return &types.String{Target: &r.Value} + } + panic("Unknown field index") +} + +func (r *TextGeometry) SetDefault(i int) { + switch i { + } + panic("Unknown field index") +} + +func (r *TextGeometry) NullField(i int) { + switch i { + } + panic("Not a nullable field index") +} + +func (_ *TextGeometry) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *TextGeometry) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *TextGeometry) Finalize() {} + +func (_ *TextGeometry) AvroCRC64Fingerprint() []byte { + return []byte(TextGeometryAvroCRC64Fingerprint) +} diff --git a/goimpl/lib/dtsavro/text_object.go b/goimpl/lib/dtsavro/text_object.go new file mode 100644 index 0000000..0d2ca6c --- /dev/null +++ b/goimpl/lib/dtsavro/text_object.go @@ -0,0 +1,118 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "github.com/actgardner/gogen-avro/v7/compiler" + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" + "io" +) + +type TextObject struct { + Type string `json:"type"` + + Value string `json:"value"` +} + +const TextObjectAvroCRC64Fingerprint = "\x84\xe7\f|\xb0m\xb5\xbe" + +func NewTextObject() *TextObject { + return &TextObject{} +} + +func DeserializeTextObject(r io.Reader) (*TextObject, error) { + t := NewTextObject() + deser, err := compiler.CompileSchemaBytes([]byte(t.Schema()), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func DeserializeTextObjectFromSchema(r io.Reader, schema string) (*TextObject, error) { + t := NewTextObject() + + deser, err := compiler.CompileSchemaBytes([]byte(schema), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func writeTextObject(r *TextObject, w io.Writer) error { + var err error + err = vm.WriteString(r.Type, w) + if err != nil { + return err + } + err = vm.WriteString(r.Value, w) + if err != nil { + return err + } + return err +} + +func (r *TextObject) Serialize(w io.Writer) error { + return writeTextObject(r, w) +} + +func (r *TextObject) Schema() string { + return "{\"fields\":[{\"name\":\"type\",\"type\":\"string\"},{\"name\":\"value\",\"type\":\"string\"}],\"name\":\"com.alibaba.dts.formats.avro.TextObject\",\"type\":\"record\"}" +} + +func (r *TextObject) SchemaName() string { + return "com.alibaba.dts.formats.avro.TextObject" +} + +func (_ *TextObject) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *TextObject) SetInt(v int32) { panic("Unsupported operation") } +func (_ *TextObject) SetLong(v int64) { panic("Unsupported operation") } +func (_ *TextObject) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *TextObject) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *TextObject) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *TextObject) SetString(v string) { panic("Unsupported operation") } +func (_ *TextObject) SetUnionElem(v int64) { panic("Unsupported operation") } + +func (r *TextObject) Get(i int) types.Field { + switch i { + case 0: + return &types.String{Target: &r.Type} + case 1: + return &types.String{Target: &r.Value} + } + panic("Unknown field index") +} + +func (r *TextObject) SetDefault(i int) { + switch i { + } + panic("Unknown field index") +} + +func (r *TextObject) NullField(i int) { + switch i { + } + panic("Not a nullable field index") +} + +func (_ *TextObject) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *TextObject) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *TextObject) Finalize() {} + +func (_ *TextObject) AvroCRC64Fingerprint() []byte { + return []byte(TextObjectAvroCRC64Fingerprint) +} diff --git a/goimpl/lib/dtsavro/timestamp.go b/goimpl/lib/dtsavro/timestamp.go new file mode 100644 index 0000000..a95cabd --- /dev/null +++ b/goimpl/lib/dtsavro/timestamp.go @@ -0,0 +1,118 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "github.com/actgardner/gogen-avro/v7/compiler" + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" + "io" +) + +type Timestamp struct { + Timestamp int64 `json:"timestamp"` + + Millis int32 `json:"millis"` +} + +const TimestampAvroCRC64Fingerprint = "\x8e\xdd@\fBJ[~" + +func NewTimestamp() *Timestamp { + return &Timestamp{} +} + +func DeserializeTimestamp(r io.Reader) (*Timestamp, error) { + t := NewTimestamp() + deser, err := compiler.CompileSchemaBytes([]byte(t.Schema()), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func DeserializeTimestampFromSchema(r io.Reader, schema string) (*Timestamp, error) { + t := NewTimestamp() + + deser, err := compiler.CompileSchemaBytes([]byte(schema), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func writeTimestamp(r *Timestamp, w io.Writer) error { + var err error + err = vm.WriteLong(r.Timestamp, w) + if err != nil { + return err + } + err = vm.WriteInt(r.Millis, w) + if err != nil { + return err + } + return err +} + +func (r *Timestamp) Serialize(w io.Writer) error { + return writeTimestamp(r, w) +} + +func (r *Timestamp) Schema() string { + return "{\"fields\":[{\"name\":\"timestamp\",\"type\":\"long\"},{\"name\":\"millis\",\"type\":\"int\"}],\"name\":\"com.alibaba.dts.formats.avro.Timestamp\",\"type\":\"record\"}" +} + +func (r *Timestamp) SchemaName() string { + return "com.alibaba.dts.formats.avro.Timestamp" +} + +func (_ *Timestamp) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *Timestamp) SetInt(v int32) { panic("Unsupported operation") } +func (_ *Timestamp) SetLong(v int64) { panic("Unsupported operation") } +func (_ *Timestamp) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *Timestamp) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *Timestamp) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *Timestamp) SetString(v string) { panic("Unsupported operation") } +func (_ *Timestamp) SetUnionElem(v int64) { panic("Unsupported operation") } + +func (r *Timestamp) Get(i int) types.Field { + switch i { + case 0: + return &types.Long{Target: &r.Timestamp} + case 1: + return &types.Int{Target: &r.Millis} + } + panic("Unknown field index") +} + +func (r *Timestamp) SetDefault(i int) { + switch i { + } + panic("Unknown field index") +} + +func (r *Timestamp) NullField(i int) { + switch i { + } + panic("Not a nullable field index") +} + +func (_ *Timestamp) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *Timestamp) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *Timestamp) Finalize() {} + +func (_ *Timestamp) AvroCRC64Fingerprint() []byte { + return []byte(TimestampAvroCRC64Fingerprint) +} diff --git a/goimpl/lib/dtsavro/timestamp_with_time_zone.go b/goimpl/lib/dtsavro/timestamp_with_time_zone.go new file mode 100644 index 0000000..f9d3f24 --- /dev/null +++ b/goimpl/lib/dtsavro/timestamp_with_time_zone.go @@ -0,0 +1,120 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "github.com/actgardner/gogen-avro/v7/compiler" + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" + "io" +) + +type TimestampWithTimeZone struct { + Value *DateTime `json:"value"` + + Timezone string `json:"timezone"` +} + +const TimestampWithTimeZoneAvroCRC64Fingerprint = "2T\x1b\x8c=\x01_\xb9" + +func NewTimestampWithTimeZone() *TimestampWithTimeZone { + return &TimestampWithTimeZone{} +} + +func DeserializeTimestampWithTimeZone(r io.Reader) (*TimestampWithTimeZone, error) { + t := NewTimestampWithTimeZone() + deser, err := compiler.CompileSchemaBytes([]byte(t.Schema()), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func DeserializeTimestampWithTimeZoneFromSchema(r io.Reader, schema string) (*TimestampWithTimeZone, error) { + t := NewTimestampWithTimeZone() + + deser, err := compiler.CompileSchemaBytes([]byte(schema), []byte(t.Schema())) + if err != nil { + return nil, err + } + + err = vm.Eval(r, deser, t) + if err != nil { + return nil, err + } + return t, err +} + +func writeTimestampWithTimeZone(r *TimestampWithTimeZone, w io.Writer) error { + var err error + err = writeDateTime(r.Value, w) + if err != nil { + return err + } + err = vm.WriteString(r.Timezone, w) + if err != nil { + return err + } + return err +} + +func (r *TimestampWithTimeZone) Serialize(w io.Writer) error { + return writeTimestampWithTimeZone(r, w) +} + +func (r *TimestampWithTimeZone) Schema() string { + return "{\"fields\":[{\"name\":\"value\",\"type\":{\"fields\":[{\"default\":null,\"name\":\"year\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"month\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"day\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"hour\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"minute\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"second\",\"type\":[\"null\",\"int\"]},{\"default\":null,\"name\":\"millis\",\"type\":[\"null\",\"int\"]}],\"name\":\"DateTime\",\"namespace\":\"com.alibaba.dts.formats.avro\",\"type\":\"record\"}},{\"name\":\"timezone\",\"type\":\"string\"}],\"name\":\"com.alibaba.dts.formats.avro.TimestampWithTimeZone\",\"type\":\"record\"}" +} + +func (r *TimestampWithTimeZone) SchemaName() string { + return "com.alibaba.dts.formats.avro.TimestampWithTimeZone" +} + +func (_ *TimestampWithTimeZone) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *TimestampWithTimeZone) SetInt(v int32) { panic("Unsupported operation") } +func (_ *TimestampWithTimeZone) SetLong(v int64) { panic("Unsupported operation") } +func (_ *TimestampWithTimeZone) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *TimestampWithTimeZone) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *TimestampWithTimeZone) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *TimestampWithTimeZone) SetString(v string) { panic("Unsupported operation") } +func (_ *TimestampWithTimeZone) SetUnionElem(v int64) { panic("Unsupported operation") } + +func (r *TimestampWithTimeZone) Get(i int) types.Field { + switch i { + case 0: + r.Value = NewDateTime() + + return r.Value + case 1: + return &types.String{Target: &r.Timezone} + } + panic("Unknown field index") +} + +func (r *TimestampWithTimeZone) SetDefault(i int) { + switch i { + } + panic("Unknown field index") +} + +func (r *TimestampWithTimeZone) NullField(i int) { + switch i { + } + panic("Not a nullable field index") +} + +func (_ *TimestampWithTimeZone) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *TimestampWithTimeZone) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *TimestampWithTimeZone) Finalize() {} + +func (_ *TimestampWithTimeZone) AvroCRC64Fingerprint() []byte { + return []byte(TimestampWithTimeZoneAvroCRC64Fingerprint) +} diff --git a/goimpl/lib/dtsavro/union_field_integer_character_float_decimal_timestamp_date_time_timestamp_with_time_zone_binary_geometry_text_geometry_binary_object_text_object_empty_object_record.go b/goimpl/lib/dtsavro/union_field_integer_character_float_decimal_timestamp_date_time_timestamp_with_time_zone_binary_geometry_text_geometry_binary_object_text_object_empty_object_record.go new file mode 100644 index 0000000..5e4c832 --- /dev/null +++ b/goimpl/lib/dtsavro/union_field_integer_character_float_decimal_timestamp_date_time_timestamp_with_time_zone_binary_geometry_text_geometry_binary_object_text_object_empty_object_record.go @@ -0,0 +1,291 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" +) + +type UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnum int + +const ( + UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumField UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnum = 0 + + UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumInteger UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnum = 1 + + UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumCharacter UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnum = 2 + + UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumFloat UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnum = 3 + + UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumDecimal UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnum = 4 + + UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumTimestamp UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnum = 5 + + UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumDateTime UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnum = 6 + + UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumTimestampWithTimeZone UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnum = 7 + + UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumBinaryGeometry UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnum = 8 + + UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumTextGeometry UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnum = 9 + + UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumBinaryObject UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnum = 10 + + UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumTextObject UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnum = 11 + + UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumEmptyObject UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnum = 12 + + UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumRecord UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnum = 13 +) + +type UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord struct { + Field *Field + Integer *Integer + Character *Character + Float *Float + Decimal *Decimal + Timestamp *Timestamp + DateTime *DateTime + TimestampWithTimeZone *TimestampWithTimeZone + BinaryGeometry *BinaryGeometry + TextGeometry *TextGeometry + BinaryObject *BinaryObject + TextObject *TextObject + EmptyObject EmptyObject + Record *Record + UnionType UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnum +} + +func writeUnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord(r *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord, w io.Writer) error { + + err := vm.WriteLong(int64(r.UnionType), w) + if err != nil { + return err + } + switch r.UnionType { + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumField: + return writeField(r.Field, w) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumInteger: + return writeInteger(r.Integer, w) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumCharacter: + return writeCharacter(r.Character, w) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumFloat: + return writeFloat(r.Float, w) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumDecimal: + return writeDecimal(r.Decimal, w) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumTimestamp: + return writeTimestamp(r.Timestamp, w) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumDateTime: + return writeDateTime(r.DateTime, w) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumTimestampWithTimeZone: + return writeTimestampWithTimeZone(r.TimestampWithTimeZone, w) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumBinaryGeometry: + return writeBinaryGeometry(r.BinaryGeometry, w) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumTextGeometry: + return writeTextGeometry(r.TextGeometry, w) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumBinaryObject: + return writeBinaryObject(r.BinaryObject, w) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumTextObject: + return writeTextObject(r.TextObject, w) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumEmptyObject: + return writeEmptyObject(r.EmptyObject, w) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumRecord: + return writeRecord(r.Record, w) + } + return fmt.Errorf("invalid value for *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord") +} + +func NewUnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord() *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord { + return &UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord{} +} + +func (_ *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord) SetBoolean(v bool) { + panic("Unsupported operation") +} +func (_ *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord) SetInt(v int32) { + panic("Unsupported operation") +} +func (_ *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord) SetFloat(v float32) { + panic("Unsupported operation") +} +func (_ *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord) SetDouble(v float64) { + panic("Unsupported operation") +} +func (_ *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord) SetBytes(v []byte) { + panic("Unsupported operation") +} +func (_ *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord) SetString(v string) { + panic("Unsupported operation") +} +func (r *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord) SetLong(v int64) { + r.UnionType = (UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnum)(v) +} +func (r *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord) Get(i int) types.Field { + switch i { + case 0: + r.Field = NewField() + return r.Field + case 1: + r.Integer = NewInteger() + return r.Integer + case 2: + r.Character = NewCharacter() + return r.Character + case 3: + r.Float = NewFloat() + return r.Float + case 4: + r.Decimal = NewDecimal() + return r.Decimal + case 5: + r.Timestamp = NewTimestamp() + return r.Timestamp + case 6: + r.DateTime = NewDateTime() + return r.DateTime + case 7: + r.TimestampWithTimeZone = NewTimestampWithTimeZone() + return r.TimestampWithTimeZone + case 8: + r.BinaryGeometry = NewBinaryGeometry() + return r.BinaryGeometry + case 9: + r.TextGeometry = NewTextGeometry() + return r.TextGeometry + case 10: + r.BinaryObject = NewBinaryObject() + return r.BinaryObject + case 11: + r.TextObject = NewTextObject() + return r.TextObject + case 12: + return &EmptyObjectWrapper{Target: (&r.EmptyObject)} + case 13: + r.Record = NewRecord() + return r.Record + } + panic("Unknown field index") +} +func (_ *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord) NullField(i int) { + panic("Unsupported operation") +} +func (_ *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord) SetDefault(i int) { + panic("Unsupported operation") +} +func (_ *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord) AppendMap(key string) types.Field { + panic("Unsupported operation") +} +func (_ *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord) AppendArray() types.Field { + panic("Unsupported operation") +} +func (_ *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord) Finalize() { +} + +func (r *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord) MarshalJSON() ([]byte, error) { + if r == nil { + return []byte("null"), nil + } + switch r.UnionType { + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumField: + return json.Marshal(map[string]interface{}{"Field": r.Field}) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumInteger: + return json.Marshal(map[string]interface{}{"Integer": r.Integer}) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumCharacter: + return json.Marshal(map[string]interface{}{"Character": r.Character}) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumFloat: + return json.Marshal(map[string]interface{}{"Float": r.Float}) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumDecimal: + return json.Marshal(map[string]interface{}{"Decimal": r.Decimal}) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumTimestamp: + return json.Marshal(map[string]interface{}{"Timestamp": r.Timestamp}) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumDateTime: + return json.Marshal(map[string]interface{}{"DateTime": r.DateTime}) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumTimestampWithTimeZone: + return json.Marshal(map[string]interface{}{"TimestampWithTimeZone": r.TimestampWithTimeZone}) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumBinaryGeometry: + return json.Marshal(map[string]interface{}{"BinaryGeometry": r.BinaryGeometry}) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumTextGeometry: + return json.Marshal(map[string]interface{}{"TextGeometry": r.TextGeometry}) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumBinaryObject: + return json.Marshal(map[string]interface{}{"BinaryObject": r.BinaryObject}) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumTextObject: + return json.Marshal(map[string]interface{}{"TextObject": r.TextObject}) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumEmptyObject: + return json.Marshal(map[string]interface{}{"EmptyObject": r.EmptyObject}) + case UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecordTypeEnumRecord: + return json.Marshal(map[string]interface{}{"Record": r.Record}) + } + return nil, fmt.Errorf("invalid value for *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord") +} + +func (r *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord) UnmarshalJSON(data []byte) error { + var fields map[string]json.RawMessage + if err := json.Unmarshal(data, &fields); err != nil { + return err + } + if value, ok := fields["Field"]; ok { + r.UnionType = 0 + return json.Unmarshal([]byte(value), &r.Field) + } + if value, ok := fields["Integer"]; ok { + r.UnionType = 1 + return json.Unmarshal([]byte(value), &r.Integer) + } + if value, ok := fields["Character"]; ok { + r.UnionType = 2 + return json.Unmarshal([]byte(value), &r.Character) + } + if value, ok := fields["Float"]; ok { + r.UnionType = 3 + return json.Unmarshal([]byte(value), &r.Float) + } + if value, ok := fields["Decimal"]; ok { + r.UnionType = 4 + return json.Unmarshal([]byte(value), &r.Decimal) + } + if value, ok := fields["Timestamp"]; ok { + r.UnionType = 5 + return json.Unmarshal([]byte(value), &r.Timestamp) + } + if value, ok := fields["DateTime"]; ok { + r.UnionType = 6 + return json.Unmarshal([]byte(value), &r.DateTime) + } + if value, ok := fields["TimestampWithTimeZone"]; ok { + r.UnionType = 7 + return json.Unmarshal([]byte(value), &r.TimestampWithTimeZone) + } + if value, ok := fields["BinaryGeometry"]; ok { + r.UnionType = 8 + return json.Unmarshal([]byte(value), &r.BinaryGeometry) + } + if value, ok := fields["TextGeometry"]; ok { + r.UnionType = 9 + return json.Unmarshal([]byte(value), &r.TextGeometry) + } + if value, ok := fields["BinaryObject"]; ok { + r.UnionType = 10 + return json.Unmarshal([]byte(value), &r.BinaryObject) + } + if value, ok := fields["TextObject"]; ok { + r.UnionType = 11 + return json.Unmarshal([]byte(value), &r.TextObject) + } + if value, ok := fields["EmptyObject"]; ok { + r.UnionType = 12 + return json.Unmarshal([]byte(value), &r.EmptyObject) + } + if value, ok := fields["Record"]; ok { + r.UnionType = 13 + return json.Unmarshal([]byte(value), &r.Record) + } + return fmt.Errorf("invalid value for *UnionFieldIntegerCharacterFloatDecimalTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectRecord") +} diff --git a/goimpl/lib/dtsavro/union_null_array_long.go b/goimpl/lib/dtsavro/union_null_array_long.go new file mode 100644 index 0000000..c38c713 --- /dev/null +++ b/goimpl/lib/dtsavro/union_null_array_long.go @@ -0,0 +1,97 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" +) + +type UnionNullArrayLongTypeEnum int + +const ( + UnionNullArrayLongTypeEnumArrayLong UnionNullArrayLongTypeEnum = 1 +) + +type UnionNullArrayLong struct { + Null *types.NullVal + ArrayLong []int64 + UnionType UnionNullArrayLongTypeEnum +} + +func writeUnionNullArrayLong(r *UnionNullArrayLong, w io.Writer) error { + + if r == nil { + err := vm.WriteLong(0, w) + return err + } + + err := vm.WriteLong(int64(r.UnionType), w) + if err != nil { + return err + } + switch r.UnionType { + case UnionNullArrayLongTypeEnumArrayLong: + return writeArrayLong(r.ArrayLong, w) + } + return fmt.Errorf("invalid value for *UnionNullArrayLong") +} + +func NewUnionNullArrayLong() *UnionNullArrayLong { + return &UnionNullArrayLong{} +} + +func (_ *UnionNullArrayLong) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *UnionNullArrayLong) SetInt(v int32) { panic("Unsupported operation") } +func (_ *UnionNullArrayLong) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *UnionNullArrayLong) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *UnionNullArrayLong) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *UnionNullArrayLong) SetString(v string) { panic("Unsupported operation") } +func (r *UnionNullArrayLong) SetLong(v int64) { + r.UnionType = (UnionNullArrayLongTypeEnum)(v) +} +func (r *UnionNullArrayLong) Get(i int) types.Field { + switch i { + case 0: + return r.Null + case 1: + r.ArrayLong = make([]int64, 0) + return &ArrayLongWrapper{Target: (&r.ArrayLong)} + } + panic("Unknown field index") +} +func (_ *UnionNullArrayLong) NullField(i int) { panic("Unsupported operation") } +func (_ *UnionNullArrayLong) SetDefault(i int) { panic("Unsupported operation") } +func (_ *UnionNullArrayLong) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *UnionNullArrayLong) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *UnionNullArrayLong) Finalize() {} + +func (r *UnionNullArrayLong) MarshalJSON() ([]byte, error) { + if r == nil { + return []byte("null"), nil + } + switch r.UnionType { + case UnionNullArrayLongTypeEnumArrayLong: + return json.Marshal(map[string]interface{}{"array": r.ArrayLong}) + } + return nil, fmt.Errorf("invalid value for *UnionNullArrayLong") +} + +func (r *UnionNullArrayLong) UnmarshalJSON(data []byte) error { + var fields map[string]json.RawMessage + if err := json.Unmarshal(data, &fields); err != nil { + return err + } + if value, ok := fields["array"]; ok { + r.UnionType = 1 + return json.Unmarshal([]byte(value), &r.ArrayLong) + } + return fmt.Errorf("invalid value for *UnionNullArrayLong") +} diff --git a/goimpl/lib/dtsavro/union_null_int.go b/goimpl/lib/dtsavro/union_null_int.go new file mode 100644 index 0000000..e356085 --- /dev/null +++ b/goimpl/lib/dtsavro/union_null_int.go @@ -0,0 +1,96 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" +) + +type UnionNullIntTypeEnum int + +const ( + UnionNullIntTypeEnumInt UnionNullIntTypeEnum = 1 +) + +type UnionNullInt struct { + Null *types.NullVal + Int int32 + UnionType UnionNullIntTypeEnum +} + +func writeUnionNullInt(r *UnionNullInt, w io.Writer) error { + + if r == nil { + err := vm.WriteLong(0, w) + return err + } + + err := vm.WriteLong(int64(r.UnionType), w) + if err != nil { + return err + } + switch r.UnionType { + case UnionNullIntTypeEnumInt: + return vm.WriteInt(r.Int, w) + } + return fmt.Errorf("invalid value for *UnionNullInt") +} + +func NewUnionNullInt() *UnionNullInt { + return &UnionNullInt{} +} + +func (_ *UnionNullInt) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *UnionNullInt) SetInt(v int32) { panic("Unsupported operation") } +func (_ *UnionNullInt) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *UnionNullInt) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *UnionNullInt) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *UnionNullInt) SetString(v string) { panic("Unsupported operation") } +func (r *UnionNullInt) SetLong(v int64) { + r.UnionType = (UnionNullIntTypeEnum)(v) +} +func (r *UnionNullInt) Get(i int) types.Field { + switch i { + case 0: + return r.Null + case 1: + return &types.Int{Target: (&r.Int)} + } + panic("Unknown field index") +} +func (_ *UnionNullInt) NullField(i int) { panic("Unsupported operation") } +func (_ *UnionNullInt) SetDefault(i int) { panic("Unsupported operation") } +func (_ *UnionNullInt) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *UnionNullInt) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *UnionNullInt) Finalize() {} + +func (r *UnionNullInt) MarshalJSON() ([]byte, error) { + if r == nil { + return []byte("null"), nil + } + switch r.UnionType { + case UnionNullIntTypeEnumInt: + return json.Marshal(map[string]interface{}{"int": r.Int}) + } + return nil, fmt.Errorf("invalid value for *UnionNullInt") +} + +func (r *UnionNullInt) UnmarshalJSON(data []byte) error { + var fields map[string]json.RawMessage + if err := json.Unmarshal(data, &fields); err != nil { + return err + } + if value, ok := fields["int"]; ok { + r.UnionType = 1 + return json.Unmarshal([]byte(value), &r.Int) + } + return fmt.Errorf("invalid value for *UnionNullInt") +} diff --git a/goimpl/lib/dtsavro/union_null_integer_character_decimal_float_timestamp_date_time_timestamp_with_time_zone_binary_geometry_text_geometry_binary_object_text_object_empty_object.go b/goimpl/lib/dtsavro/union_null_integer_character_decimal_float_timestamp_date_time_timestamp_with_time_zone_binary_geometry_text_geometry_binary_object_text_object_empty_object.go new file mode 100644 index 0000000..c5d06ce --- /dev/null +++ b/goimpl/lib/dtsavro/union_null_integer_character_decimal_float_timestamp_date_time_timestamp_with_time_zone_binary_geometry_text_geometry_binary_object_text_object_empty_object.go @@ -0,0 +1,271 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" +) + +type UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum int + +const ( + UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumInteger UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum = 1 + + UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumCharacter UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum = 2 + + UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumDecimal UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum = 3 + + UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumFloat UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum = 4 + + UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumTimestamp UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum = 5 + + UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumDateTime UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum = 6 + + UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumTimestampWithTimeZone UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum = 7 + + UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumBinaryGeometry UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum = 8 + + UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumTextGeometry UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum = 9 + + UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumBinaryObject UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum = 10 + + UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumTextObject UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum = 11 + + UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumEmptyObject UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum = 12 +) + +type UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject struct { + Null *types.NullVal + Integer *Integer + Character *Character + Decimal *Decimal + Float *Float + Timestamp *Timestamp + DateTime *DateTime + TimestampWithTimeZone *TimestampWithTimeZone + BinaryGeometry *BinaryGeometry + TextGeometry *TextGeometry + BinaryObject *BinaryObject + TextObject *TextObject + EmptyObject EmptyObject + UnionType UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum +} + +func writeUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject(r *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject, w io.Writer) error { + + if r == nil { + err := vm.WriteLong(0, w) + return err + } + + err := vm.WriteLong(int64(r.UnionType), w) + if err != nil { + return err + } + switch r.UnionType { + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumInteger: + return writeInteger(r.Integer, w) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumCharacter: + return writeCharacter(r.Character, w) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumDecimal: + return writeDecimal(r.Decimal, w) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumFloat: + return writeFloat(r.Float, w) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumTimestamp: + return writeTimestamp(r.Timestamp, w) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumDateTime: + return writeDateTime(r.DateTime, w) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumTimestampWithTimeZone: + return writeTimestampWithTimeZone(r.TimestampWithTimeZone, w) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumBinaryGeometry: + return writeBinaryGeometry(r.BinaryGeometry, w) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumTextGeometry: + return writeTextGeometry(r.TextGeometry, w) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumBinaryObject: + return writeBinaryObject(r.BinaryObject, w) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumTextObject: + return writeTextObject(r.TextObject, w) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumEmptyObject: + return writeEmptyObject(r.EmptyObject, w) + } + return fmt.Errorf("invalid value for *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject") +} + +func NewUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject() *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject { + return &UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject{} +} + +func (_ *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) SetBoolean(v bool) { + panic("Unsupported operation") +} +func (_ *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) SetInt(v int32) { + panic("Unsupported operation") +} +func (_ *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) SetFloat(v float32) { + panic("Unsupported operation") +} +func (_ *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) SetDouble(v float64) { + panic("Unsupported operation") +} +func (_ *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) SetBytes(v []byte) { + panic("Unsupported operation") +} +func (_ *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) SetString(v string) { + panic("Unsupported operation") +} +func (r *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) SetLong(v int64) { + r.UnionType = (UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum)(v) +} +func (r *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) Get(i int) types.Field { + switch i { + case 0: + return r.Null + case 1: + r.Integer = NewInteger() + return r.Integer + case 2: + r.Character = NewCharacter() + return r.Character + case 3: + r.Decimal = NewDecimal() + return r.Decimal + case 4: + r.Float = NewFloat() + return r.Float + case 5: + r.Timestamp = NewTimestamp() + return r.Timestamp + case 6: + r.DateTime = NewDateTime() + return r.DateTime + case 7: + r.TimestampWithTimeZone = NewTimestampWithTimeZone() + return r.TimestampWithTimeZone + case 8: + r.BinaryGeometry = NewBinaryGeometry() + return r.BinaryGeometry + case 9: + r.TextGeometry = NewTextGeometry() + return r.TextGeometry + case 10: + r.BinaryObject = NewBinaryObject() + return r.BinaryObject + case 11: + r.TextObject = NewTextObject() + return r.TextObject + case 12: + return &EmptyObjectWrapper{Target: (&r.EmptyObject)} + } + panic("Unknown field index") +} +func (_ *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) NullField(i int) { + panic("Unsupported operation") +} +func (_ *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) SetDefault(i int) { + panic("Unsupported operation") +} +func (_ *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) AppendMap(key string) types.Field { + panic("Unsupported operation") +} +func (_ *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) AppendArray() types.Field { + panic("Unsupported operation") +} +func (_ *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) Finalize() { +} + +func (r *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) MarshalJSON() ([]byte, error) { + if r == nil { + return []byte("null"), nil + } + switch r.UnionType { + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumInteger: + return json.Marshal(map[string]interface{}{"Integer": r.Integer}) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumCharacter: + return json.Marshal(map[string]interface{}{"Character": r.Character}) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumDecimal: + return json.Marshal(map[string]interface{}{"Decimal": r.Decimal}) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumFloat: + return json.Marshal(map[string]interface{}{"Float": r.Float}) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumTimestamp: + return json.Marshal(map[string]interface{}{"Timestamp": r.Timestamp}) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumDateTime: + return json.Marshal(map[string]interface{}{"DateTime": r.DateTime}) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumTimestampWithTimeZone: + return json.Marshal(map[string]interface{}{"TimestampWithTimeZone": r.TimestampWithTimeZone}) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumBinaryGeometry: + return json.Marshal(map[string]interface{}{"BinaryGeometry": r.BinaryGeometry}) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumTextGeometry: + return json.Marshal(map[string]interface{}{"TextGeometry": r.TextGeometry}) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumBinaryObject: + return json.Marshal(map[string]interface{}{"BinaryObject": r.BinaryObject}) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumTextObject: + return json.Marshal(map[string]interface{}{"TextObject": r.TextObject}) + case UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumEmptyObject: + return json.Marshal(map[string]interface{}{"EmptyObject": r.EmptyObject}) + } + return nil, fmt.Errorf("invalid value for *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject") +} + +func (r *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) UnmarshalJSON(data []byte) error { + var fields map[string]json.RawMessage + if err := json.Unmarshal(data, &fields); err != nil { + return err + } + if value, ok := fields["Integer"]; ok { + r.UnionType = 1 + return json.Unmarshal([]byte(value), &r.Integer) + } + if value, ok := fields["Character"]; ok { + r.UnionType = 2 + return json.Unmarshal([]byte(value), &r.Character) + } + if value, ok := fields["Decimal"]; ok { + r.UnionType = 3 + return json.Unmarshal([]byte(value), &r.Decimal) + } + if value, ok := fields["Float"]; ok { + r.UnionType = 4 + return json.Unmarshal([]byte(value), &r.Float) + } + if value, ok := fields["Timestamp"]; ok { + r.UnionType = 5 + return json.Unmarshal([]byte(value), &r.Timestamp) + } + if value, ok := fields["DateTime"]; ok { + r.UnionType = 6 + return json.Unmarshal([]byte(value), &r.DateTime) + } + if value, ok := fields["TimestampWithTimeZone"]; ok { + r.UnionType = 7 + return json.Unmarshal([]byte(value), &r.TimestampWithTimeZone) + } + if value, ok := fields["BinaryGeometry"]; ok { + r.UnionType = 8 + return json.Unmarshal([]byte(value), &r.BinaryGeometry) + } + if value, ok := fields["TextGeometry"]; ok { + r.UnionType = 9 + return json.Unmarshal([]byte(value), &r.TextGeometry) + } + if value, ok := fields["BinaryObject"]; ok { + r.UnionType = 10 + return json.Unmarshal([]byte(value), &r.BinaryObject) + } + if value, ok := fields["TextObject"]; ok { + r.UnionType = 11 + return json.Unmarshal([]byte(value), &r.TextObject) + } + if value, ok := fields["EmptyObject"]; ok { + r.UnionType = 12 + return json.Unmarshal([]byte(value), &r.EmptyObject) + } + return fmt.Errorf("invalid value for *UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject") +} diff --git a/goimpl/lib/dtsavro/union_null_string.go b/goimpl/lib/dtsavro/union_null_string.go new file mode 100644 index 0000000..b0aab66 --- /dev/null +++ b/goimpl/lib/dtsavro/union_null_string.go @@ -0,0 +1,96 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" +) + +type UnionNullStringTypeEnum int + +const ( + UnionNullStringTypeEnumString UnionNullStringTypeEnum = 1 +) + +type UnionNullString struct { + Null *types.NullVal + String string + UnionType UnionNullStringTypeEnum +} + +func writeUnionNullString(r *UnionNullString, w io.Writer) error { + + if r == nil { + err := vm.WriteLong(0, w) + return err + } + + err := vm.WriteLong(int64(r.UnionType), w) + if err != nil { + return err + } + switch r.UnionType { + case UnionNullStringTypeEnumString: + return vm.WriteString(r.String, w) + } + return fmt.Errorf("invalid value for *UnionNullString") +} + +func NewUnionNullString() *UnionNullString { + return &UnionNullString{} +} + +func (_ *UnionNullString) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *UnionNullString) SetInt(v int32) { panic("Unsupported operation") } +func (_ *UnionNullString) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *UnionNullString) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *UnionNullString) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *UnionNullString) SetString(v string) { panic("Unsupported operation") } +func (r *UnionNullString) SetLong(v int64) { + r.UnionType = (UnionNullStringTypeEnum)(v) +} +func (r *UnionNullString) Get(i int) types.Field { + switch i { + case 0: + return r.Null + case 1: + return &types.String{Target: (&r.String)} + } + panic("Unknown field index") +} +func (_ *UnionNullString) NullField(i int) { panic("Unsupported operation") } +func (_ *UnionNullString) SetDefault(i int) { panic("Unsupported operation") } +func (_ *UnionNullString) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *UnionNullString) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *UnionNullString) Finalize() {} + +func (r *UnionNullString) MarshalJSON() ([]byte, error) { + if r == nil { + return []byte("null"), nil + } + switch r.UnionType { + case UnionNullStringTypeEnumString: + return json.Marshal(map[string]interface{}{"string": r.String}) + } + return nil, fmt.Errorf("invalid value for *UnionNullString") +} + +func (r *UnionNullString) UnmarshalJSON(data []byte) error { + var fields map[string]json.RawMessage + if err := json.Unmarshal(data, &fields); err != nil { + return err + } + if value, ok := fields["string"]; ok { + r.UnionType = 1 + return json.Unmarshal([]byte(value), &r.String) + } + return fmt.Errorf("invalid value for *UnionNullString") +} diff --git a/goimpl/lib/dtsavro/union_null_string_array_field.go b/goimpl/lib/dtsavro/union_null_string_array_field.go new file mode 100644 index 0000000..9efd485 --- /dev/null +++ b/goimpl/lib/dtsavro/union_null_string_array_field.go @@ -0,0 +1,110 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" +) + +type UnionNullStringArrayFieldTypeEnum int + +const ( + UnionNullStringArrayFieldTypeEnumString UnionNullStringArrayFieldTypeEnum = 1 + + UnionNullStringArrayFieldTypeEnumArrayField UnionNullStringArrayFieldTypeEnum = 2 +) + +type UnionNullStringArrayField struct { + Null *types.NullVal + String string + ArrayField []*Field + UnionType UnionNullStringArrayFieldTypeEnum +} + +func writeUnionNullStringArrayField(r *UnionNullStringArrayField, w io.Writer) error { + + if r == nil { + err := vm.WriteLong(0, w) + return err + } + + err := vm.WriteLong(int64(r.UnionType), w) + if err != nil { + return err + } + switch r.UnionType { + case UnionNullStringArrayFieldTypeEnumString: + return vm.WriteString(r.String, w) + case UnionNullStringArrayFieldTypeEnumArrayField: + return writeArrayField(r.ArrayField, w) + } + return fmt.Errorf("invalid value for *UnionNullStringArrayField") +} + +func NewUnionNullStringArrayField() *UnionNullStringArrayField { + return &UnionNullStringArrayField{} +} + +func (_ *UnionNullStringArrayField) SetBoolean(v bool) { panic("Unsupported operation") } +func (_ *UnionNullStringArrayField) SetInt(v int32) { panic("Unsupported operation") } +func (_ *UnionNullStringArrayField) SetFloat(v float32) { panic("Unsupported operation") } +func (_ *UnionNullStringArrayField) SetDouble(v float64) { panic("Unsupported operation") } +func (_ *UnionNullStringArrayField) SetBytes(v []byte) { panic("Unsupported operation") } +func (_ *UnionNullStringArrayField) SetString(v string) { panic("Unsupported operation") } +func (r *UnionNullStringArrayField) SetLong(v int64) { + r.UnionType = (UnionNullStringArrayFieldTypeEnum)(v) +} +func (r *UnionNullStringArrayField) Get(i int) types.Field { + switch i { + case 0: + return r.Null + case 1: + return &types.String{Target: (&r.String)} + case 2: + r.ArrayField = make([]*Field, 0) + return &ArrayFieldWrapper{Target: (&r.ArrayField)} + } + panic("Unknown field index") +} +func (_ *UnionNullStringArrayField) NullField(i int) { panic("Unsupported operation") } +func (_ *UnionNullStringArrayField) SetDefault(i int) { panic("Unsupported operation") } +func (_ *UnionNullStringArrayField) AppendMap(key string) types.Field { panic("Unsupported operation") } +func (_ *UnionNullStringArrayField) AppendArray() types.Field { panic("Unsupported operation") } +func (_ *UnionNullStringArrayField) Finalize() {} + +func (r *UnionNullStringArrayField) MarshalJSON() ([]byte, error) { + if r == nil { + return []byte("null"), nil + } + switch r.UnionType { + case UnionNullStringArrayFieldTypeEnumString: + return json.Marshal(map[string]interface{}{"string": r.String}) + case UnionNullStringArrayFieldTypeEnumArrayField: + return json.Marshal(map[string]interface{}{"array": r.ArrayField}) + } + return nil, fmt.Errorf("invalid value for *UnionNullStringArrayField") +} + +func (r *UnionNullStringArrayField) UnmarshalJSON(data []byte) error { + var fields map[string]json.RawMessage + if err := json.Unmarshal(data, &fields); err != nil { + return err + } + if value, ok := fields["string"]; ok { + r.UnionType = 1 + return json.Unmarshal([]byte(value), &r.String) + } + if value, ok := fields["array"]; ok { + r.UnionType = 2 + return json.Unmarshal([]byte(value), &r.ArrayField) + } + return fmt.Errorf("invalid value for *UnionNullStringArrayField") +} diff --git a/goimpl/lib/dtsavro/union_null_string_array_union_null_integer_character_decimal_float_timestamp_date_time_timestamp_with_time_zone_binary_geometry_text_geometry_binary_object_text_object_empty_object.go b/goimpl/lib/dtsavro/union_null_string_array_union_null_integer_character_decimal_float_timestamp_date_time_timestamp_with_time_zone_binary_geometry_text_geometry_binary_object_text_object_empty_object.go new file mode 100644 index 0000000..41d1a0e --- /dev/null +++ b/goimpl/lib/dtsavro/union_null_string_array_union_null_integer_character_decimal_float_timestamp_date_time_timestamp_with_time_zone_binary_geometry_text_geometry_binary_object_text_object_empty_object.go @@ -0,0 +1,131 @@ +// Code generated by github.com/actgardner/gogen-avro/v7. DO NOT EDIT. +/* + * SOURCE: + * record.avsc + */ +package dtsavro + +import ( + "encoding/json" + "fmt" + "io" + + "github.com/actgardner/gogen-avro/v7/vm" + "github.com/actgardner/gogen-avro/v7/vm/types" +) + +type UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum int + +const ( + UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumString UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum = 1 + + UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum = 2 +) + +type UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject struct { + Null *types.NullVal + String string + ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject []*UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject + UnionType UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum +} + +func writeUnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject(r *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject, w io.Writer) error { + + if r == nil { + err := vm.WriteLong(0, w) + return err + } + + err := vm.WriteLong(int64(r.UnionType), w) + if err != nil { + return err + } + switch r.UnionType { + case UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumString: + return vm.WriteString(r.String, w) + case UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject: + return writeArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject(r.ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject, w) + } + return fmt.Errorf("invalid value for *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject") +} + +func NewUnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject() *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject { + return &UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject{} +} + +func (_ *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) SetBoolean(v bool) { + panic("Unsupported operation") +} +func (_ *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) SetInt(v int32) { + panic("Unsupported operation") +} +func (_ *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) SetFloat(v float32) { + panic("Unsupported operation") +} +func (_ *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) SetDouble(v float64) { + panic("Unsupported operation") +} +func (_ *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) SetBytes(v []byte) { + panic("Unsupported operation") +} +func (_ *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) SetString(v string) { + panic("Unsupported operation") +} +func (r *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) SetLong(v int64) { + r.UnionType = (UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnum)(v) +} +func (r *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) Get(i int) types.Field { + switch i { + case 0: + return r.Null + case 1: + return &types.String{Target: (&r.String)} + case 2: + r.ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject = make([]*UnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject, 0) + return &ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectWrapper{Target: (&r.ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject)} + } + panic("Unknown field index") +} +func (_ *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) NullField(i int) { + panic("Unsupported operation") +} +func (_ *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) SetDefault(i int) { + panic("Unsupported operation") +} +func (_ *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) AppendMap(key string) types.Field { + panic("Unsupported operation") +} +func (_ *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) AppendArray() types.Field { + panic("Unsupported operation") +} +func (_ *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) Finalize() { +} + +func (r *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) MarshalJSON() ([]byte, error) { + if r == nil { + return []byte("null"), nil + } + switch r.UnionType { + case UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumString: + return json.Marshal(map[string]interface{}{"string": r.String}) + case UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObjectTypeEnumArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject: + return json.Marshal(map[string]interface{}{"array": r.ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject}) + } + return nil, fmt.Errorf("invalid value for *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject") +} + +func (r *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) UnmarshalJSON(data []byte) error { + var fields map[string]json.RawMessage + if err := json.Unmarshal(data, &fields); err != nil { + return err + } + if value, ok := fields["string"]; ok { + r.UnionType = 1 + return json.Unmarshal([]byte(value), &r.String) + } + if value, ok := fields["array"]; ok { + r.UnionType = 2 + return json.Unmarshal([]byte(value), &r.ArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject) + } + return fmt.Errorf("invalid value for *UnionNullStringArrayUnionNullIntegerCharacterDecimalFloatTimestampDateTimeTimestampWithTimeZoneBinaryGeometryTextGeometryBinaryObjectTextObjectEmptyObject") +} diff --git a/goimpl/lib/img/1.png b/goimpl/lib/img/1.png new file mode 100644 index 0000000000000000000000000000000000000000..3895d864b0ea00848439971fa703a082044dd1df GIT binary patch literal 69604 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 X`Sv&5 Date: Wed, 12 Aug 2020 13:06:21 +0800 Subject: [PATCH 2/2] =?UTF-8?q?=E6=8B=BC=E5=86=99=E9=94=99=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- goimpl/lib/kfkdts/dts_decode.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/goimpl/lib/kfkdts/dts_decode.go b/goimpl/lib/kfkdts/dts_decode.go index 952fb2f..82b9c26 100644 --- a/goimpl/lib/kfkdts/dts_decode.go +++ b/goimpl/lib/kfkdts/dts_decode.go @@ -50,7 +50,7 @@ func DtsDecode(value []byte, message *Message) error { for i, v := range record.Fields.Array { if record.BeforeImages != nil { value := GetSqlValue(v.DataTypeNumber, record.BeforeImages.Array[i]) - afterColomns[v.Name] = value + beforeColomns[v.Name] = value } if record.AfterImages != nil { value := GetSqlValue(v.DataTypeNumber, record.AfterImages.Array[i])