SchemaNormalization.cs

Go to the documentation of this file.

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

namespace Avro
{
    public static class SchemaNormalization
    {
        public static long Empty64 = -4513414715797952619;

        public static string ToParsingForm(Schema s)
        {
            IDictionary<string, string> env = new Dictionary<string, string>();
            return Build(env, s, new StringBuilder()).ToString();
        }

        public static byte[] Fingerprint(string fpName, byte[] data)
        {
            switch (fpName)
            {
                case "CRC-64-AVRO":
                    long fp = Fingerprint64(data);
                    byte[] result = new byte[8];
                    for (int i = 0; i < 8; i++)
                    {
                        result[i] = (byte) fp;
                        fp >>= 8;
                    }
                    return result;
                case "MD5":
                    var md5 = System.Security.Cryptography.MD5.Create();
                    return md5.ComputeHash(data);
                case "SHA-256":
                    var sha256 = System.Security.Cryptography.SHA256.Create();
                    return sha256.ComputeHash(data);
                default:
                    throw new ArgumentException(string.Format("Unsupported fingerprint computation algorithm ({0})", fpName));
            }
        }

        public static byte[] ParsingFingerprint(string fpName, Schema s)
        {
            return Fingerprint(fpName, Encoding.UTF8.GetBytes(ToParsingForm(s)));
        }

        public static long ParsingFingerprint64(Schema s)
        {
            return Fingerprint64(Encoding.UTF8.GetBytes(ToParsingForm(s)));
        }

        private static long Fingerprint64(byte[] data)
        {
            long result = Empty64;
            foreach (var b in data)
            {
                result = ((long)(((ulong)result) >> 8)) ^ Fp64.FpTable[(int) (result ^ b) & 0xff];
            }
            return result;
        }

        private static StringBuilder Build(IDictionary<string, string> env, Schema s, StringBuilder o)
        {
            bool firstTime = true;
            Schema.Type st = s.Tag;
            switch (st)
            {
                case Schema.Type.Union:
                    UnionSchema us = s as UnionSchema;
                    o.Append('[');
                    foreach(Schema b in us.Schemas)
                    {
                        if (!firstTime)
                        {
                            o.Append(",");
                        }
                        else
                        {
                            firstTime = false;
                        }
                        Build(env, b, o);
                    }
                    return o.Append(']');

                case Schema.Type.Array:
                case Schema.Type.Map:
                    o.Append("{\"type\":\"").Append(Schema.GetTypeString(s.Tag)).Append("\"");
                    if (st == Schema.Type.Array)
                    {
                        ArraySchema arraySchema  = s as ArraySchema;
                        Build(env, arraySchema.ItemSchema, o.Append(",\"items\":"));
                    }
                    else
                    {
                        MapSchema mapSchema = s as MapSchema;
                        Build(env, mapSchema.ValueSchema, o.Append(",\"values\":"));
                    }
                    return o.Append("}");

                case Schema.Type.Enumeration:
                case Schema.Type.Fixed:
                case Schema.Type.Record:
                    NamedSchema namedSchema = s as NamedSchema;
                    var name = namedSchema.Fullname;
                    if (env.ContainsKey(name))
                    {
                        return o.Append(env[name]);
                    }
                    var qname = "\"" + name + "\"";
                    env.Add(name, qname);
                    o.Append("{\"name\":").Append(qname);
                    o.Append(",\"type\":\"").Append(Schema.GetTypeString(s.Tag)).Append("\"");
                    if (st == Schema.Type.Enumeration)
                    {
                        EnumSchema enumSchema = s as EnumSchema;
                        o.Append(",\"symbols\":[");
                        foreach (var enumSymbol in enumSchema.Symbols)
                        {
                            if (!firstTime)
                            {
                                o.Append(",");
                            }
                            else
                            {
                                firstTime = false;
                            }
                            o.Append("\"").Append(enumSymbol).Append("\"");
                        }
                        o.Append("]");
                    }
                    else if (st == Schema.Type.Fixed)
                    {
                        FixedSchema fixedSchema = s as FixedSchema;
                        o.Append(",\"size\":").Append(fixedSchema.Size.ToString());
                    }
                    else  // st == Schema.Type.Record
                    {
                        RecordSchema recordSchema = s as RecordSchema;
                        o.Append(",\"fields\":[");
                        foreach (var field in recordSchema.Fields)
                        {
                            if (!firstTime)
                            {
                                o.Append(",");
                            }
                            else
                            {
                                firstTime = false;
                            }
                            o.Append("{\"name\":\"").Append(field.Name).Append("\"");
                            Build(env, field.Schema, o.Append(",\"type\":")).Append("}");
                        }
                        o.Append("]");
                    }
                    return o.Append("}");

                default:    //boolean, bytes, double, float, int, long, null, string
                    return o.Append("\"").Append(s.Name).Append("\"");
            }
        }

        private static class Fp64
        {
            private static readonly long[] fpTable = new long[256];

            public static long[] FpTable
            {
                get { return fpTable; }
            }

            static Fp64()
            {
                for (int i = 0; i < 256; i++)
                {
                    long fp = i;
                    for (int j = 0; j < 8; j++)
                    {
                        long mask = -(fp & 1L);
                        fp = ((long) (((ulong) fp) >> 1)) ^ (Empty64 & mask);
                    }
                    FpTable[i] = fp;
                }
            }
        }
    }
}