AvroSchemaBuilder.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Text;

namespace kinetica.SchemaBuilder;

    internal readonly struct FieldDef
    {
        public string Name { get; }
        public AvroType Type { get; }
        public bool IsNullable { get; }
        public string? Doc { get; }

        public FieldDef(string name, AvroType type, bool isNullable, string? doc = null)
        {
            Name = name;
            Type = type;
            IsNullable = isNullable;
            Doc = doc;
        }
    }

    public sealed class AvroSchemaBuilder
    {
        private readonly string _name;
        private string? _namespace;
        private string? _doc;
        private readonly List<FieldDef> _fields;

        public AvroSchemaBuilder(string name)
        {
            _name = name ?? throw new ArgumentNullException(nameof(name));
            _fields = new List<FieldDef>();
        }

        public AvroSchemaBuilder Namespace(string ns)
        {
            _namespace = ns;
            return this;
        }

        public AvroSchemaBuilder Doc(string doc)
        {
            _doc = doc;
            return this;
        }

        #region Generic Field Methods

        public AvroSchemaBuilder Field(string name, AvroType type)
        {
            _fields.Add(new FieldDef(name, type, false));
            return this;
        }

        public AvroSchemaBuilder FieldWithDoc(string name, AvroType type, string doc)
        {
            _fields.Add(new FieldDef(name, type, false, doc));
            return this;
        }

        public AvroSchemaBuilder NullableField(string name, AvroType type)
        {
            _fields.Add(new FieldDef(name, type, true));
            return this;
        }

        #endregion

        #region Convenience Type Methods

        public AvroSchemaBuilder IntField(string name)
        {
            _fields.Add(new FieldDef(name, AvroType.Int, false));
            return this;
        }

        public AvroSchemaBuilder LongField(string name)
        {
            _fields.Add(new FieldDef(name, AvroType.Long, false));
            return this;
        }

        public AvroSchemaBuilder FloatField(string name)
        {
            _fields.Add(new FieldDef(name, AvroType.Float, false));
            return this;
        }

        public AvroSchemaBuilder DoubleField(string name)
        {
            _fields.Add(new FieldDef(name, AvroType.Double, false));
            return this;
        }

        public AvroSchemaBuilder StringField(string name)
        {
            _fields.Add(new FieldDef(name, AvroType.String, false));
            return this;
        }

        public AvroSchemaBuilder BoolField(string name)
        {
            _fields.Add(new FieldDef(name, AvroType.Boolean, false));
            return this;
        }

        public AvroSchemaBuilder BytesField(string name)
        {
            _fields.Add(new FieldDef(name, AvroType.Bytes, false));
            return this;
        }

        public AvroSchemaBuilder TimestampField(string name)
        {
            _fields.Add(new FieldDef(name, AvroType.Long, false));
            return this;
        }

        #endregion

        #region Nullable Convenience Methods

        public AvroSchemaBuilder NullableIntField(string name)
        {
            _fields.Add(new FieldDef(name, AvroType.Int, true));
            return this;
        }

        public AvroSchemaBuilder NullableLongField(string name)
        {
            _fields.Add(new FieldDef(name, AvroType.Long, true));
            return this;
        }

        public AvroSchemaBuilder NullableFloatField(string name)
        {
            _fields.Add(new FieldDef(name, AvroType.Float, true));
            return this;
        }

        public AvroSchemaBuilder NullableDoubleField(string name)
        {
            _fields.Add(new FieldDef(name, AvroType.Double, true));
            return this;
        }

        public AvroSchemaBuilder NullableStringField(string name)
        {
            _fields.Add(new FieldDef(name, AvroType.String, true));
            return this;
        }

        public AvroSchemaBuilder NullableBoolField(string name)
        {
            _fields.Add(new FieldDef(name, AvroType.Boolean, true));
            return this;
        }

        public AvroSchemaBuilder NullableBytesField(string name)
        {
            _fields.Add(new FieldDef(name, AvroType.Bytes, true));
            return this;
        }

        public AvroSchemaBuilder NullableTimestampField(string name)
        {
            _fields.Add(new FieldDef(name, AvroType.Long, true));
            return this;
        }

        #endregion

        #region Build Methods

        public string Build()
        {
            var sb = new StringBuilder();
            sb.Append('{');
            sb.Append("\"type\":\"record\"");
            sb.Append(",\"name\":\"");
            sb.Append(EscapeJsonString(_name));
            sb.Append('"');

            if (!string.IsNullOrEmpty(_namespace))
            {
                sb.Append(",\"namespace\":\"");
                sb.Append(EscapeJsonString(_namespace!));
                sb.Append('"');
            }

            if (!string.IsNullOrEmpty(_doc))
            {
                sb.Append(",\"doc\":\"");
                sb.Append(EscapeJsonString(_doc!));
                sb.Append('"');
            }

            sb.Append(",\"fields\":[");

            for (int i = 0; i < _fields.Count; i++)
            {
                if (i > 0) sb.Append(',');

                var field = _fields[i];
                sb.Append("{\"name\":\"");
                sb.Append(EscapeJsonString(field.Name));
                sb.Append("\",\"type\":");

                var typeName = field.Type.GetTypeName();
                if (field.IsNullable)
                {
                    sb.Append("[\"null\",\"");
                    sb.Append(typeName);
                    sb.Append("\"]");
                }
                else
                {
                    sb.Append('"');
                    sb.Append(typeName);
                    sb.Append('"');
                }

                if (!string.IsNullOrEmpty(field.Doc))
                {
                    sb.Append(",\"doc\":\"");
                    sb.Append(EscapeJsonString(field.Doc!));
                    sb.Append('"');
                }

                sb.Append('}');
            }

            sb.Append("]}");
            return sb.ToString();
        }

        private static string EscapeJsonString(string s)
        {
            if (s.IndexOfAny(new[] { '"', '\\', '\n', '\r', '\t' }) < 0)
                return s;

            var sb = new StringBuilder(s.Length + 10);
            foreach (var c in s)
            {
                switch (c)
                {
                    case '"': sb.Append("\\\""); break;
                    case '\\': sb.Append("\\\\"); break;
                    case '\n': sb.Append("\\n"); break;
                    case '\r': sb.Append("\\r"); break;
                    case '\t': sb.Append("\\t"); break;
                    default: sb.Append(c); break;
                }
            }
            return sb.ToString();
        }

        #endregion
    }