feat: Add size in bytes to CQ types

[yevgenypats]

This makes sure every CQType implements size so we can report to the users also how many bytes/MB were synced in addition to number of resources/rows.

This will also be useful in our analytics.

[github-actions]

⏱️ Benchmark results

• DefaultConcurrencyDFS-2 resources/s: 10,775
• DefaultConcurrencyRoundRobin-2 resources/s: 12,489
• Glob-2 ns/op: 204.9
• TablesWithChildrenDFS-2 resources/s: 28,534
• TablesWithChildrenRoundRobin-2 resources/s: 25,521
• TablesWithRateLimitingDFS-2 resources/s: 28.3
• TablesWithRateLimitingRoundRobin-2 resources/s: 819.5
• BufferedScanner-2 ns/op: 12.56
• LogReader-2 ns/op: 37.91

[erezrokah]

Could we use https://github.com/DmitriyVTitov/size for this?
It seems calculating the size in bytes of values has a lot of gotchas, so maybe better to use a library that already has a few tests for it?

If not using a library, maybe use reflect.Size() https://go.dev/play/p/Sogem09ks3o

[yevgenypats]

Could we use https://github.com/DmitriyVTitov/size for this? It seems calculating the size in bytes of values has a lot of gotchas, so maybe better to use a library that already has a few tests for it?

If not using a library, maybe use reflect.Size() https://go.dev/play/p/Sogem09ks3o

We don't want to use https://github.com/DmitriyVTitov/size/blob/master/size.go as this uses reflection. There is no much gotchas for size calculation but also we mostly use it for a ballpark number it doesn't has to be the exact number of bytes. To have the exact number of bytes we need to marshal it and do len. If we will ever need it to be byte accurate then we can change to marshal and len approach but it will introduce overhead

[erezrokah]

Can we call Int8.Size() here?

[hermanschaaf]

I think this one is probably okay, the name even has 8 in it, and we're unlikely to redefine the size of 64-bit ints :) Otherwise we have to write:

if len(dst.Elements) == 0 {
     return 0
}
return dst.Elements[0] * len(dst.Elements)

And then there's still the assumption that all the elements have the same size.

We could also do:

	totalSize := 0
	for _, element := range dst.Elements {
		totalSize += element.Size()
	}
	return totalSize

but that would be unnecessarily inefficient, being O(N) instead of O(1)

[erezrokah]

To have the exact number of bytes we need to marshal it and do len. If we will ever need it to be byte accurate then we can change to marshal and len approach but it will introduce overhead

Marshal also uses reflection https://cs.opensource.google/go/go/+/refs/tags/go1.19.4:src/encoding/json/encode.go;l=330;drc=0b2ad1d815ea8967c49b32d848b2992d0c588d88.

I think the question is what we want, size in memory, or serialized size.