Function encodeJsonObject

binlogreplication/binlog_json_serialization.go:148–229

encodeJsonObject encodes the specified |jsonObject| into MySQL's internal JSON encoding and returns the type ID indicating whether this is a small or large object, the encoded object data, and any error encountered. The |largeEncoding| param controls whether this function will use the small object e

(jsonObject map[string]any, largeEncoding bool)

// - Value Entries (variable): 1 per value; 1 byte for type ID, 2 bytes for offset or inlined literal value for jsonTypeSmallObject, otherwise 4
// - Keys (variable): 1 per key; encoded string bytes
// - Values (variable): 1 per value; encoded value bytes
func encodeJsonObject(jsonObject map[string]any, largeEncoding bool) (typeId byte, encodedObject []byte, err error) {
	var keyEntriesBuffer []byte
	var keysBuffer []byte
	nextKeysOffset := calculateInitialObjectKeysOffset(len(jsonObject), largeEncoding)

	// Sort the keys so that we can process the keys and values in a consistent order. MySQL seems to sort
	// json keys internally first by length, then alphabetically, but correct replication doesn't seem to
	// rely on matching that behavior.
	sortedKeys := make([]string, 0, len(jsonObject))
	for key := range jsonObject {
		sortedKeys = append(sortedKeys, key)
	}
	sort.Strings(sortedKeys)

	// Process keys first, since value entry data depends on offsets that we don't know until we
	// process all the keys.
	for _, key := range sortedKeys {
		// NOTE: Don't use encodeJsonValue for the key – its length gets encoded slightly differently
		//       for JSON objects.
		encodedValue := []byte(key)

		if !largeEncoding && nextKeysOffset > maxOffsetSize-uint32(len(encodedValue)) {
			return 0, nil, fmt.Errorf("offset too large for small object encoding")
		}

		keyEntriesBuffer = appendForEncoding(keyEntriesBuffer, nextKeysOffset, largeEncoding)
		keyEntriesBuffer = append(keyEntriesBuffer, byte(len(encodedValue)), byte(len(encodedValue)<<8))
		keysBuffer = append(keysBuffer, encodedValue...)
		nextKeysOffset += uint32(len(encodedValue))
	}

	// Process values – since the object values are written after the keys, and we need to store the
	// offsets to those locations in the value entries that appear before the keys and the values, we
	// have to make a second pass through the object to process the values once we know the final
	// length of the keys section.
	var valueEntriesBuffer []byte
	var valuesBuffer []byte
	nextValuesOffset := nextKeysOffset
	for _, key := range sortedKeys {
		value := jsonObject[key]
		typeId, encodedValue, err := encodeJsonValue(value)
		if err != nil {
			return 0, nil, err
		}

		// Literals may be inlined in the value-entries section
		if typeId == jsonTypeLiteral {
			valueEntriesBuffer = append(valueEntriesBuffer, typeId)
			if len(encodedValue) != 1 {
				return 0, nil, fmt.Errorf("unexpected buffer length")
			}
			valueEntriesBuffer = appendForEncoding(valueEntriesBuffer, uint32(encodedValue[0]), largeEncoding)
		} else {
			if !largeEncoding && nextValuesOffset > maxOffsetSize-uint32(len(encodedValue)) {
				return 0, nil, fmt.Errorf("offset too large for small object encoding")
			}