func TestQueryResult(t *testing.T) {
want := "\xcb\x00\x00\x00\x04Fields\x009\x00\x00\x00\x030\x001\x00\x00\x00\x05Name\x00\x04\x00\x00\x00\x00name\x12Type\x00\x01\x00\x00\x00\x00\x00\x00\x00\x12Flags\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12RowsAffected\x00\x02\x00\x00\x00\x00\x00\x00\x00\x12InsertId\x00\x03\x00\x00\x00\x00\x00\x00\x00\x04Rows\x00 \x00\x00\x00\x040\x00\x18\x00\x00\x00\x050\x00\x01\x00\x00\x00\x001\x051\x00\x02\x00\x00\x00\x00aa\x00\x00\x03Err\x002\x00\x00\x00\x12Code\x00\xe8\x03\x00\x00\x00\x00\x00\x00\x05Message\x00\x11\x00\x00\x00\x00failed due to err\x00\x00"
custom := QueryResult{
Fields: []Field{{"name", 1, VT_ZEROVALUE_FLAG}},
RowsAffected: 2,
InsertId: 3,
Rows: [][]sqltypes.Value{
{{sqltypes.Numeric("1")}, {sqltypes.String("aa")}},
},
Err: &RPCError{1000, "failed due to err"},
}
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%#v, got\n%#v", want, got)
}
var unmarshalled QueryResult
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if unmarshalled.Err == nil {
t.Errorf("want %#v, got %#v", custom.Err, unmarshalled.Err)
} else {
if *custom.Err != *unmarshalled.Err {
t.Errorf("want %#v, got %#v", custom.Err, unmarshalled.Err)
}
}
if custom.RowsAffected != unmarshalled.RowsAffected {
t.Errorf("want %v, got %#v", custom.RowsAffected, unmarshalled.RowsAffected)
}
if custom.InsertId != unmarshalled.InsertId {
t.Errorf("want %v, got %#v", custom.InsertId, unmarshalled.InsertId)
}
if custom.Fields[0].Name != unmarshalled.Fields[0].Name {
t.Errorf("want %v, got %#v", custom.Fields[0].Name, unmarshalled.Fields[0].Name)
}
if custom.Fields[0].Type != unmarshalled.Fields[0].Type {
t.Errorf("want %v, got %#v", custom.Fields[0].Type, unmarshalled.Fields[0].Type)
}
if !bytes.Equal(custom.Rows[0][0].Raw(), unmarshalled.Rows[0][0].Raw()) {
t.Errorf("want %s, got %s", custom.Rows[0][0].Raw(), unmarshalled.Rows[0][0].Raw())
}
if !bytes.Equal(custom.Rows[0][1].Raw(), unmarshalled.Rows[0][1].Raw()) {
t.Errorf("want %s, got %s", custom.Rows[0][0].Raw(), unmarshalled.Rows[0][0].Raw())
}
extra, err := bson.Marshal(&extraQueryResult{})
if err != nil {
t.Error(err)
}
err = bson.Unmarshal(extra, &unmarshalled)
if err != nil {
t.Error(err)
}
}
func TestQueryList(t *testing.T) {
reflected, err := bson.Marshal(&reflectQueryList{
Queries: []BoundQuery{{
Sql: "query",
BindVariables: map[string]interface{}{"val": int64(1)},
}},
TransactionId: 1,
SessionId: 2,
})
if err != nil {
t.Error(err)
}
want := string(reflected)
custom := QueryList{
Queries: []BoundQuery{{
Sql: "query",
BindVariables: map[string]interface{}{"val": int64(1)},
}},
TransactionId: 1,
SessionId: 2,
}
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%#v, got\n%#v", want, got)
}
var unmarshalled QueryList
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if custom.TransactionId != unmarshalled.TransactionId {
t.Errorf("want %v, got %v", custom.TransactionId, unmarshalled.TransactionId)
}
if custom.SessionId != unmarshalled.SessionId {
t.Errorf("want %v, got %v", custom.SessionId, unmarshalled.SessionId)
}
if custom.Queries[0].Sql != unmarshalled.Queries[0].Sql {
t.Errorf("want %v, got %v", custom.Queries[0].Sql, unmarshalled.Queries[0].Sql)
}
if custom.Queries[0].BindVariables["val"].(int64) != unmarshalled.Queries[0].BindVariables["val"].(int64) {
t.Errorf("want %v, got %v", custom.Queries[0].BindVariables["val"], unmarshalled.Queries[0].BindVariables["val"])
}
unexpected, err := bson.Marshal(&badQueryList{})
if err != nil {
t.Error(err)
}
err = bson.Unmarshal(unexpected, &unmarshalled)
want = "Unrecognized tag Extra"
if err == nil || want != err.Error() {
t.Errorf("want %v, got %v", want, err)
}
}
func TestQueryResultList(t *testing.T) {
reflected, err := bson.Marshal(&reflectQueryResultList{
List: []mproto.QueryResult{{
Fields: []mproto.Field{{"name", 1}},
RowsAffected: 2,
InsertId: 3,
Rows: [][]sqltypes.Value{
{{sqltypes.String("1")}, {sqltypes.String("aa")}},
},
}},
Session: &commonSession,
Error: "error",
})
if err != nil {
t.Error(err)
}
want := string(reflected)
custom := QueryResultList{
List: []mproto.QueryResult{{
Fields: []mproto.Field{{"name", 1}},
RowsAffected: 2,
InsertId: 3,
Rows: [][]sqltypes.Value{
{{sqltypes.String("1")}, {sqltypes.String("aa")}},
},
}},
Session: &commonSession,
Error: "error",
}
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%#v, got\n%#v", want, got)
}
var unmarshalled QueryResultList
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if !reflect.DeepEqual(custom, unmarshalled) {
t.Errorf("want \n%#v, got \n%#v", custom, unmarshalled)
}
unexpected, err := bson.Marshal(&badQueryResultList{})
if err != nil {
t.Error(err)
}
err = bson.Unmarshal(unexpected, &unmarshalled)
want = "Unrecognized tag Extra"
if err == nil || want != err.Error() {
t.Errorf("want %v, got %v", want, err)
}
}
func TestQueryResultList(t *testing.T) {
reflected, err := bson.Marshal(&reflectQueryResultList{
List: []mproto.QueryResult{{
Fields: []mproto.Field{{"name", 1, mproto.VT_ZEROVALUE_FLAG}},
RowsAffected: 2,
InsertId: 3,
Rows: [][]sqltypes.Value{
{{sqltypes.String("1")}, {sqltypes.String("aa")}},
},
}},
Session: &commonSession,
Error: "error",
})
if err != nil {
t.Error(err)
}
want := string(reflected)
custom := QueryResultList{
List: []mproto.QueryResult{{
Fields: []mproto.Field{{"name", 1, mproto.VT_ZEROVALUE_FLAG}},
RowsAffected: 2,
InsertId: 3,
Rows: [][]sqltypes.Value{
{{sqltypes.String("1")}, {sqltypes.String("aa")}},
},
}},
Session: &commonSession,
Error: "error",
}
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%+v, got\n%+v", want, got)
}
var unmarshalled QueryResultList
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if !reflect.DeepEqual(custom, unmarshalled) {
t.Errorf("want \n%+v, got \n%+v", custom, unmarshalled)
}
extra, err := bson.Marshal(&extraQueryResultList{})
if err != nil {
t.Error(err)
}
err = bson.Unmarshal(extra, &unmarshalled)
if err != nil {
t.Error(err)
}
}
func TestQuery(t *testing.T) {
reflected, err := bson.Marshal(&reflectQuery{
Sql: "query",
BindVariables: map[string]interface{}{"val": int64(1)},
SessionId: 2,
TransactionId: 1,
})
if err != nil {
t.Error(err)
}
want := string(reflected)
custom := Query{
Sql: "query",
BindVariables: map[string]interface{}{"val": int64(1)},
SessionId: 2,
TransactionId: 1,
}
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%#v, got\n%#v", want, got)
}
var unmarshalled Query
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if custom.Sql != unmarshalled.Sql {
t.Errorf("want %v, got %v", custom.Sql, unmarshalled.Sql)
}
if custom.TransactionId != unmarshalled.TransactionId {
t.Errorf("want %v, got %v", custom.TransactionId, unmarshalled.TransactionId)
}
if custom.SessionId != unmarshalled.SessionId {
t.Errorf("want %v, got %v", custom.SessionId, unmarshalled.SessionId)
}
if custom.BindVariables["val"].(int64) != unmarshalled.BindVariables["val"].(int64) {
t.Errorf("want %v, got %v", custom.BindVariables["val"], unmarshalled.BindVariables["val"])
}
extra, err := bson.Marshal(&extraQuery{})
if err != nil {
t.Error(err)
}
err = bson.Unmarshal(extra, &unmarshalled)
if err != nil {
t.Error(err)
}
}
func TestBinlogTransaction(t *testing.T) {
reflected, err := bson.Marshal(&reflectBinlogTransaction{
Statements: []reflectStatement{
{
Category: 1,
Sql: []byte("sql"),
},
},
Timestamp: 456,
GroupId: 123,
})
if err != nil {
t.Error(err)
}
want := string(reflected)
custom := BinlogTransaction{
Statements: []Statement{
{
Category: 1,
Sql: []byte("sql"),
},
},
Timestamp: 456,
GroupId: 123,
}
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%#v, got\n%#v", want, got)
}
var unmarshalled BinlogTransaction
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if !reflect.DeepEqual(custom, unmarshalled) {
t.Errorf("%#v != %#v", custom, unmarshalled)
}
extra, err := bson.Marshal(&extraBinlogTransaction{})
if err != nil {
t.Error(err)
}
err = bson.Unmarshal(extra, &unmarshalled)
if err != nil {
t.Error(err)
}
}
func TestQueryResult(t *testing.T) {
want := "\x85\x00\x00\x00\x04Fields\x00*\x00\x00\x00\x030\x00\"\x00\x00\x00\x05Name\x00\x04\x00\x00\x00\x00name\x12Type\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12RowsAffected\x00\x02\x00\x00\x00\x00\x00\x00\x00\x12InsertId\x00\x03\x00\x00\x00\x00\x00\x00\x00\x04Rows\x00 \x00\x00\x00\x040\x00\x18\x00\x00\x00\x050\x00\x01\x00\x00\x00\x001\x051\x00\x02\x00\x00\x00\x00aa\x00\x00\x00"
custom := QueryResult{
Fields: []Field{{"name", 1}},
RowsAffected: 2,
InsertId: 3,
Rows: [][]sqltypes.Value{
{{sqltypes.Numeric("1")}, {sqltypes.String("aa")}},
},
}
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%#v, got\n%#v", want, got)
}
var unmarshalled QueryResult
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if custom.RowsAffected != unmarshalled.RowsAffected {
t.Errorf("want %v, got %#v", custom.RowsAffected, unmarshalled.RowsAffected)
}
if custom.InsertId != unmarshalled.InsertId {
t.Errorf("want %v, got %#v", custom.InsertId, unmarshalled.InsertId)
}
if custom.Fields[0].Name != unmarshalled.Fields[0].Name {
t.Errorf("want %v, got %#v", custom.Fields[0].Name, unmarshalled.Fields[0].Name)
}
if custom.Fields[0].Type != unmarshalled.Fields[0].Type {
t.Errorf("want %v, got %#v", custom.Fields[0].Type, unmarshalled.Fields[0].Type)
}
if !bytes.Equal(custom.Rows[0][0].Raw(), unmarshalled.Rows[0][0].Raw()) {
t.Errorf("want %s, got %s", custom.Rows[0][0].Raw(), unmarshalled.Rows[0][0].Raw())
}
if !bytes.Equal(custom.Rows[0][1].Raw(), unmarshalled.Rows[0][1].Raw()) {
t.Errorf("want %s, got %s", custom.Rows[0][0].Raw(), unmarshalled.Rows[0][0].Raw())
}
unexpected, err := bson.Marshal(&badQueryResult{})
if err != nil {
t.Error(err)
}
err = bson.Unmarshal(unexpected, &unmarshalled)
want = "Unrecognized tag Extra"
if err == nil || want != err.Error() {
t.Errorf("want %v, got %v", want, err)
}
}
func TestResponseBson(t *testing.T) {
reflected, err := bson.Marshal(&reflectResponseBson{
ServiceMethod: "aa",
Seq: 1,
Error: "err",
})
if err != nil {
t.Error(err)
}
want := string(reflected)
custom := ResponseBson{
&rpc.Response{
ServiceMethod: "aa",
Seq: 1,
Error: "err",
},
}
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%#v, got\n%#v", want, got)
}
unmarshalled := ResponseBson{Response: new(rpc.Response)}
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if custom.ServiceMethod != unmarshalled.ServiceMethod {
t.Errorf("want %v, got %#v", custom.ServiceMethod, unmarshalled.ServiceMethod)
}
if custom.Seq != unmarshalled.Seq {
t.Errorf("want %v, got %#v", custom.Seq, unmarshalled.Seq)
}
if custom.Error != unmarshalled.Error {
t.Errorf("want %v, got %#v", custom.Error, unmarshalled.Error)
}
unexpected, err := bson.Marshal(&badResponseBson{})
if err != nil {
t.Error(err)
}
err = bson.Unmarshal(unexpected, &unmarshalled)
want = "Unrecognized tag Extra"
if err == nil || want != err.Error() {
t.Errorf("want %v, got %v", want, err)
}
}
func TestBinlogTransaction(t *testing.T) {
reflected, err := bson.Marshal(&reflectBinlogTransaction{
Statements: []reflectStatement{
{
Category: 1,
Sql: []byte("sql"),
},
},
GroupId: 123,
})
if err != nil {
t.Error(err)
}
want := string(reflected)
custom := BinlogTransaction{
Statements: []Statement{
{
Category: 1,
Sql: []byte("sql"),
},
},
GroupId: 123,
}
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%#v, got\n%#v", want, got)
}
var unmarshalled BinlogTransaction
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if !reflect.DeepEqual(custom, unmarshalled) {
t.Errorf("%#v != %#v", custom, unmarshalled)
}
unexpected, err := bson.Marshal(&badBinlogTransaction{})
if err != nil {
t.Error(err)
}
err = bson.Unmarshal(unexpected, &unmarshalled)
want = "Unrecognized tag Extra"
if err == nil || want != err.Error() {
t.Errorf("want %v, got %v", want, err)
}
}
func TestStreamQueryKeyRange(t *testing.T) {
reflected, err := bson.Marshal(&reflectStreamQueryKeyRange{
Sql: "query",
BindVariables: map[string]interface{}{"val": int64(1)},
Keyspace: "keyspace",
KeyRange: "10-18",
TabletType: "replica",
Session: &commonSession,
})
if err != nil {
t.Error(err)
}
want := string(reflected)
custom := StreamQueryKeyRange{
Sql: "query",
BindVariables: map[string]interface{}{"val": int64(1)},
Keyspace: "keyspace",
KeyRange: "10-18",
TabletType: "replica",
Session: &commonSession,
}
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%#v, got\n%#v", want, got)
}
var unmarshalled StreamQueryKeyRange
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if !reflect.DeepEqual(custom, unmarshalled) {
t.Errorf("want \n%#v, got \n%#v", custom, unmarshalled)
}
unexpected, err := bson.Marshal(&badStreamQueryKeyRange{})
if err != nil {
t.Error(err)
}
err = bson.Unmarshal(unexpected, &unmarshalled)
want = "Unrecognized tag Extra"
if err == nil || want != err.Error() {
t.Errorf("want %v, got %v", want, err)
}
}
func TestKeyRangeQuery(t *testing.T) {
reflected, err := bson.Marshal(&reflectKeyRangeQuery{
Sql: "query",
BindVariables: map[string]interface{}{"val": int64(1)},
Keyspace: "keyspace",
KeyRanges: []kproto.KeyRange{kproto.KeyRange{Start: "10", End: "18"}},
TabletType: "replica",
Session: &commonSession,
})
if err != nil {
t.Error(err)
}
want := string(reflected)
custom := KeyRangeQuery{
Sql: "query",
BindVariables: map[string]interface{}{"val": int64(1)},
Keyspace: "keyspace",
KeyRanges: []kproto.KeyRange{kproto.KeyRange{Start: "10", End: "18"}},
TabletType: "replica",
Session: &commonSession,
}
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%+v, got\n%+v", want, got)
}
var unmarshalled KeyRangeQuery
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if !reflect.DeepEqual(custom, unmarshalled) {
t.Errorf("want \n%+v, got \n%+v", custom, unmarshalled)
}
extra, err := bson.Marshal(&extraKeyRangeQuery{})
if err != nil {
t.Error(err)
}
err = bson.Unmarshal(extra, &unmarshalled)
if err != nil {
t.Error(err)
}
}
func TestQueryShard(t *testing.T) {
reflected, err := bson.Marshal(&reflectQueryShard{
Sql: "query",
BindVariables: map[string]interface{}{"val": int64(1)},
Keyspace: "keyspace",
Shards: []string{"shard1", "shard2"},
TabletType: topo.TabletType("replica"),
Session: &commonSession,
})
if err != nil {
t.Error(err)
}
want := string(reflected)
custom := QueryShard{
Sql: "query",
BindVariables: map[string]interface{}{"val": int64(1)},
Keyspace: "keyspace",
Shards: []string{"shard1", "shard2"},
TabletType: topo.TabletType("replica"),
Session: &commonSession,
}
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%#v, got\n%#v", want, got)
}
var unmarshalled QueryShard
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if !reflect.DeepEqual(custom, unmarshalled) {
t.Errorf("want \n%#v, got \n%#v", custom, unmarshalled)
}
unexpected, err := bson.Marshal(&badQueryShard{})
if err != nil {
t.Error(err)
}
err = bson.Unmarshal(unexpected, &unmarshalled)
want = "Unrecognized tag Extra"
if err == nil || want != err.Error() {
t.Errorf("want %v, got %v", want, err)
}
}
func TestSession(t *testing.T) {
reflected, err := bson.Marshal(&reflectSession{
InTransaction: true,
ShardSessions: []*ShardSession{{
Keyspace: "a",
Shard: "0",
TabletType: topo.TabletType("replica"),
TransactionId: 1,
}, {
Keyspace: "b",
Shard: "1",
TabletType: topo.TabletType("master"),
TransactionId: 2,
}},
})
if err != nil {
t.Error(err)
}
want := string(reflected)
custom := commonSession
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%#v, got\n%#v", want, got)
}
var unmarshalled Session
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if !reflect.DeepEqual(custom, unmarshalled) {
t.Errorf("want \n%#v, got \n%#v", custom, unmarshalled)
}
unexpected, err := bson.Marshal(&badSession{})
if err != nil {
t.Error(err)
}
err = bson.Unmarshal(unexpected, &unmarshalled)
want = "Unrecognized tag Extra"
if err == nil || want != err.Error() {
t.Errorf("want %v, got %v", want, err)
}
}
func TestBsonMarshalUnmarshalGTIDFieldInStruct(t *testing.T) {
gtidParsers["golf"] = func(s string) (GTID, error) {
return fakeGTID{flavor: "golf", value: s}, nil
}
input := fakeGTID{flavor: "golf", value: "par"}
want := fakeGTID{flavor: "golf", value: "par"}
type mystruct struct {
GTIDField
}
buf, err := bson.Marshal(&mystruct{GTIDField{input}})
if err != nil {
t.Errorf("unexpected error: %v", err)
}
var gotStruct mystruct
if err = bson.Unmarshal(buf, &gotStruct); err != nil {
t.Errorf("unexpected error: %v", err)
}
if got := gotStruct.GTIDField.Value; got != want {
t.Errorf("marshal->unmarshal mismatch, got %#v, want %#v", got, want)
}
}
func TestRun(t *testing.T) {
for caseno, tcase := range testcases {
actual, err := bson.Marshal(&tcase.qr)
if err != nil {
t.Errorf("Error on %d: %v", caseno, err)
}
if tcase.encoded != "" && string(actual) != tcase.encoded {
t.Errorf("Expecting vs actual for %d:\n%#v\n%#v", caseno, tcase.encoded, string(actual))
}
var newqr Result
err = bson.Unmarshal(actual, &newqr)
if err != nil {
t.Errorf("Error on %d: %v", caseno, err)
}
if len(newqr.Fields) == 0 {
newqr.Fields = nil
}
if len(newqr.Rows) == 0 {
newqr.Rows = nil
}
if !reflect.DeepEqual(newqr, tcase.qr) {
t.Errorf("Case: %d,\n%#v, want\n%#v", caseno, newqr, tcase.qr)
}
}
}
func (rowCache *InvalidationProcessor) handleTxn(commitEvent *mysqlctl.UpdateResponse) error {
var err error
defer func() {
if x := recover(); x != nil {
if terr, ok := x.(*TabletError); ok {
rowCache.updateErrCounters(NewInvalidationError(INVALID_EVENT, terr.Error(), commitEvent.BinlogPosition.String()))
} else {
err = NewInvalidationError(FATAL_ERROR, "handleTxn failed", commitEvent.BinlogPosition.String())
}
}
}()
if len(rowCache.dmlBuffer) == 0 {
return nil
}
rowCache.encBuf = rowCache.encBuf[:0]
cacheInvalidate := new(proto.CacheInvalidate)
rowCache.encBuf, err = bson.Marshal(&commitEvent.BinlogPosition)
if err != nil {
return NewInvalidationError(FATAL_ERROR, fmt.Sprintf("Error in encoding position, %v", err), commitEvent.BinlogPosition.String())
}
cacheInvalidate.Position = rowCache.encBuf
cacheInvalidate.Dmls = make([]proto.DmlType, 0, len(rowCache.dmlBuffer))
for _, dml := range rowCache.dmlBuffer {
cacheInvalidate.Dmls = append(cacheInvalidate.Dmls, *dml)
}
InvalidateForDml(cacheInvalidate)
return nil
}
func (rowCache *InvalidationProcessor) handleDdlEvent(ddlEvent *mysqlctl.UpdateResponse) error {
var err error
defer func() {
if x := recover(); x != nil {
if terr, ok := x.(*TabletError); ok {
rowCache.updateErrCounters(NewInvalidationError(INVALID_EVENT, terr.Error(), ddlEvent.BinlogPosition.String()))
} else {
err = NewInvalidationError(FATAL_ERROR, "ddlEvent failed", ddlEvent.BinlogPosition.String())
}
}
}()
if ddlEvent.Sql == "" {
rowCache.updateErrCounters(NewInvalidationError(INVALID_EVENT, "Empty ddl sql", ddlEvent.BinlogPosition.String()))
return nil
//return NewInvalidationError(INVALID_EVENT, "Empty ddl sql", ddlEvent.BinlogPosition.String())
}
rowCache.encBuf = rowCache.encBuf[:0]
ddlInvalidate := new(proto.DDLInvalidate)
rowCache.encBuf, err = bson.Marshal(&ddlEvent.BinlogPosition)
if err != nil {
return NewInvalidationError(FATAL_ERROR, fmt.Sprintf("Error in encoding position, %v", err), ddlEvent.BinlogPosition.String())
}
ddlInvalidate.Position = rowCache.encBuf
ddlInvalidate.DDL = ddlEvent.Sql
InvalidateForDDL(ddlInvalidate)
return nil
}
func TestExtraFieldsBson(t *testing.T) {
swra := &SlaveWasRestartedArgs{
Parent: topo.TabletAlias{
Uid: 1,
Cell: "aa",
},
ExpectedMasterAddr: "a1",
ExpectedMasterIpAddr: "i1",
ScrapStragglers: true,
// Disabled for now
// ContinueOnUnexpectedMaster: true,
}
data, err := bson.Marshal(swra)
if err != nil {
t.Fatal(err)
}
output := &slaveWasRestartedTestArgs{}
err = bson.Unmarshal(data, output)
if err != nil {
// This should not error out. See b/12857170
// t.Error(err)
}
}
func TestQueryResult(t *testing.T) {
// We can't do the reflection test because bson
// doesn't do it correctly for embedded fields.
want := "\x90\x01\x00\x00\x03Result\x00\x99\x00\x00\x00\x04Fields\x009\x00\x00\x00\x030\x001\x00\x00\x00\x05Name\x00\x04\x00\x00\x00\x00name\x12Type\x00\x01\x00\x00\x00\x00\x00\x00\x00\x12Flags\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00?RowsAffected\x00\x02\x00\x00\x00\x00\x00\x00\x00?InsertId\x00\x03\x00\x00\x00\x00\x00\x00\x00\x04Rows\x00 \x00\x00\x00\x040\x00\x18\x00\x00\x00\x050\x00\x01\x00\x00\x00\x001\x051\x00\x02\x00\x00\x00\x00aa\x00\x00\nErr\x00\x00\x03Session\x00\xd0\x00\x00\x00\bInTransaction\x00\x01\x04ShardSessions\x00\xac\x00\x00\x00\x030\x00Q\x00\x00\x00\x05Keyspace\x00\x01\x00\x00\x00\x00a\x05Shard\x00\x01\x00\x00\x00\x000\x05TabletType\x00\a\x00\x00\x00\x00replica\x12TransactionId\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x031\x00P\x00\x00\x00\x05Keyspace\x00\x01\x00\x00\x00\x00b\x05Shard\x00\x01\x00\x00\x00\x001\x05TabletType\x00\x06\x00\x00\x00\x00master\x12TransactionId\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05Error\x00\x05\x00\x00\x00\x00error\x00"
custom := QueryResult{
Result: &mproto.QueryResult{
Fields: []mproto.Field{{"name", 1, mproto.VT_ZEROVALUE_FLAG}},
RowsAffected: 2,
InsertId: 3,
Rows: [][]sqltypes.Value{
{{sqltypes.String("1")}, {sqltypes.String("aa")}},
},
},
Session: &commonSession,
Error: "error",
}
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%#v, got\n%#v", want, got)
}
var unmarshalled QueryResult
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if !reflect.DeepEqual(custom, unmarshalled) {
t.Errorf("want \n%+v, got \n%+v", custom, unmarshalled)
}
}
func TestBsonMarshalUnmarshalReplicationPositionInStruct(t *testing.T) {
gtidSetParsers["golf"] = func(s string) (GTIDSet, error) {
return fakeGTID{flavor: "golf", value: s}, nil
}
input := ReplicationPosition{GTIDSet: fakeGTID{flavor: "golf", value: "par"}}
want := ReplicationPosition{GTIDSet: fakeGTID{flavor: "golf", value: "par"}}
type mystruct struct {
ReplicationPosition
}
buf, err := bson.Marshal(&mystruct{ReplicationPosition: input})
if err != nil {
t.Errorf("unexpected error: %v", err)
}
var gotStruct mystruct
if err = bson.Unmarshal(buf, &gotStruct); err != nil {
t.Errorf("unexpected error: %v", err)
}
if got := gotStruct.ReplicationPosition; !got.Equal(want) {
t.Errorf("marshal->unmarshal mismatch, got %#v, want %#v", got, want)
}
}
func BenchmarkUnmarshalByBson(b *testing.B) {
bytes, _ := vitessbson.Marshal(group)
result := ColorGroup{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
vitessbson.Unmarshal(bytes, &result)
}
}
func TestRequestBson(t *testing.T) {
reflected, err := bson.Marshal(&reflectRequestBson{
ServiceMethod: "aa",
Seq: 1,
})
if err != nil {
t.Error(err)
}
want := string(reflected)
custom := RequestBson{
&rpc.Request{
ServiceMethod: "aa",
Seq: 1,
},
}
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%#v, got\n%#v", want, got)
}
unmarshalled := RequestBson{Request: new(rpc.Request)}
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if custom.ServiceMethod != unmarshalled.ServiceMethod {
t.Errorf("want %v, got %#v", custom.ServiceMethod, unmarshalled.ServiceMethod)
}
if custom.Seq != unmarshalled.Seq {
t.Errorf("want %v, got %#v", custom.Seq, unmarshalled.Seq)
}
extra, err := bson.Marshal(&extraRequestBson{})
if err != nil {
t.Error(err)
}
err = bson.Unmarshal(extra, &unmarshalled)
if err != nil {
t.Error(err)
}
}
func TestBoundQuery(t *testing.T) {
reflected, err := bson.Marshal(&reflectBoundQuery{
Sql: "query",
BindVariables: map[string]interface{}{"val": int64(1)},
})
if err != nil {
t.Error(err)
}
want := string(reflected)
custom := BoundQuery{
Sql: "query",
BindVariables: map[string]interface{}{"val": int64(1)},
}
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%#v, got\n%#v", want, got)
}
var unmarshalled BoundQuery
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if custom.Sql != unmarshalled.Sql {
t.Errorf("want %v, got %v", custom.Sql, unmarshalled.Sql)
}
if custom.BindVariables["val"].(int64) != unmarshalled.BindVariables["val"].(int64) {
t.Errorf("want %v, got %v", custom.BindVariables["val"], unmarshalled.BindVariables["val"])
}
unexpected, err := bson.Marshal(&badBoundQuery{})
if err != nil {
t.Error(err)
}
err = bson.Unmarshal(unexpected, &unmarshalled)
want = "Unrecognized tag Extra"
if err == nil || want != err.Error() {
t.Errorf("want %v, got %v", want, err)
}
}
func TestSession(t *testing.T) {
reflected, err := bson.Marshal(&reflectSession{
TransactionId: 1,
SessionId: 2,
})
if err != nil {
t.Error(err)
}
want := string(reflected)
custom := Session{
TransactionId: 1,
SessionId: 2,
}
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%#v, got\n%#v", want, got)
}
var unmarshalled Session
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if custom != unmarshalled {
t.Errorf("want %v, got %#v", custom, unmarshalled)
}
unexpected, err := bson.Marshal(&badSession{})
if err != nil {
t.Error(err)
}
err = bson.Unmarshal(unexpected, &unmarshalled)
want = "Unrecognized tag Extra"
if err == nil || want != err.Error() {
t.Errorf("want %v, got %v", want, err)
}
}
func TestSession(t *testing.T) {
reflected, err := bson.Marshal(&reflectSession{
SessionId: 2,
TransactionId: 1,
})
if err != nil {
t.Error(err)
}
want := string(reflected)
custom := Session{
SessionId: 2,
TransactionId: 1,
}
encoded, err := bson.Marshal(&custom)
if err != nil {
t.Error(err)
}
got := string(encoded)
if want != got {
t.Errorf("want\n%#v, got\n%#v", want, got)
}
var unmarshalled Session
err = bson.Unmarshal(encoded, &unmarshalled)
if err != nil {
t.Error(err)
}
if custom != unmarshalled {
t.Errorf("want %v, got %#v", custom, unmarshalled)
}
extra, err := bson.Marshal(&extraSession{})
if err != nil {
t.Error(err)
}
err = bson.Unmarshal(extra, &unmarshalled)
if err != nil {
t.Error(err)
}
}
func TestBatchQueryShardBadType(t *testing.T) {
unexpected, err := bson.Marshal(&badTypeBatchQueryShard{})
if err != nil {
t.Error(err)
}
var unmarshalled BatchQueryShard
err = bson.Unmarshal(unexpected, &unmarshalled)
want := "unexpected kind 5 for batchQueryShard.Queries"
if err == nil || want != err.Error() {
t.Errorf("want %v, got %v", want, err)
}
}
func TestKeyspaceIdsBatchQueryBadType(t *testing.T) {
unexpected, err := bson.Marshal(&badTypeKeyspaceIdsBatchQuery{})
if err != nil {
t.Error(err)
}
var unmarshalled KeyspaceIdBatchQuery
err = bson.Unmarshal(unexpected, &unmarshalled)
want := "unexpected kind 5 for keyspaceIdBatchQuery.Queries"
if err == nil || want != err.Error() {
t.Errorf("want %v, got %v", want, err)
}
}
func TestUnmarshalEmptyStructIntoUnused(t *testing.T) {
buf, err := bson.Marshal(&struct{}{})
if err != nil {
t.Fatalf("bson.Marshal: %v", err)
}
// Check that a new-style server expecting Unused{} can handle an empty struct.
var unused Unused
if err := bson.Unmarshal(buf, &unused); err != nil {
t.Errorf("bson.Unmarshal: %v", err)
}
}
func TestUnmarshalStructIntoUnused(t *testing.T) {
buf, err := bson.Marshal(&struct{ A, B string }{"A", "B"})
if err != nil {
t.Fatalf("bson.Marshal: %v", err)
}
// Check that a new-style server expecting Unused{} can handle an actual
// struct being sent.
var unused Unused
if err := bson.Unmarshal(buf, &unused); err != nil {
t.Errorf("bson.Unmarshal: %v", err)
}
}
func TestUnmarshalUnusedIntoString(t *testing.T) {
buf, err := bson.Marshal(&Unused{})
if err != nil {
t.Fatalf("bson.Marshal: %v", err)
}
// Check that it's safe for new clients to send Unused{} to an old server
// expecting the naked empty string convention.
var str string
if err := bson.Unmarshal(buf, &str); err != nil {
t.Errorf("bson.Unmarshal: %v", err)
}
}