avro 1.9.1 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 96c7660634a5f7e85c04d6895dc94ae20a2ea9c8
-  data.tar.gz: 4e68260b9070cc565aa152988d9809a3f7671772
+  metadata.gz: eab84afb7b30d99dee71a7e360dba2a36957500b
+  data.tar.gz: 8211aea9ad1e00a4f94bb3edc2aeaf9ab06edffa
 SHA512:
-  metadata.gz: '064323997a22d0341e21d93bda5855a27d3859e8f247a85032854198e00330a278912f12cf6037fb374e1e322b009bd902fdff112ededb78b994f6978d6db020'
-  data.tar.gz: ecdec673bb86ca8d8571198eebf0bada327f71134ddc176dbc327bdea27be31b62838f37a5952edaf33398f21591677268f4b15bee28176cac88b839b8df44b6
+  metadata.gz: c51889575e3cd689f7288bdd7a0d8250a8147a8eaf568805f726991f9f115c28f8ca9fa396262c687021859cbd9a26c5f196b7f73a174a2da9dd7f22764fe8d8
+  data.tar.gz: 0d936920e8b8ea8edd70583164bd519ac46108de4ab9f7d359d6edb7e8d1941eb3bad06ed8462cdc6bac2d3152c16faba49833d115cc6240e26d3cf51f746c08

data/Rakefile

@@ -23,8 +23,8 @@ Echoe.new('avro', VERSION) do |p|
   p.summary = "Apache Avro for Ruby"
   p.description = "Avro is a data serialization and RPC format"
   p.url = "https://avro.apache.org/"
-  p.runtime_dependencies = %w[multi_json]
-  p.licenses = ["Apache License 2.0 (Apache-2.0)"]
+  p.runtime_dependencies = ["multi_json ~>1"]
+  p.licenses = ["Apache-2.0"]
 end
 
 t = Rake::TestTask.new(:interop)
@@ -38,17 +38,13 @@ task :generate_interop do
 
   schema = Avro::Schema.parse(File.read(SCHEMAS + '/interop.avsc'))
   r = RandomData.new(schema, ENV['SEED'])
-  f = File.open(BUILD + '/interop/data/ruby.avro', 'w')
-  writer = Avro::DataFile::Writer.new(f, Avro::IO::DatumWriter.new(schema), schema)
-  begin
-    writer << r.next
-    writer << r.next
-  ensure
-    writer.close
-  end
-
-  Avro::DataFile.open(BUILD + '/interop/data/ruby_deflate.avro', 'w', schema.to_s, :deflate) do |writer|
-    20.times { writer << r.next }
+  Avro::DataFile.codecs.each do |name, codec|
+    next unless codec
+    filename = name == 'null' ? 'ruby.avro' : "ruby_#{name}.avro"
+    path = File.join(BUILD, 'interop/data', filename)
+    Avro::DataFile.open(path, 'w', schema.to_s, name) do |writer|
+      writer << r.next
+    end
   end
 end
 

data/avro.gemspec

@@ -1,35 +1,35 @@
 # -*- encoding: utf-8 -*-
-# stub: avro 1.9.1 ruby lib
+# stub: avro 1.10.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "avro".freeze
-  s.version = "1.9.1"
+  s.version = "1.10.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Apache Software Foundation".freeze]
-  s.date = "2019-08-28"
+  s.date = "2020-06-22"
   s.description = "Avro is a data serialization and RPC format".freeze
   s.email = "dev@avro.apache.org".freeze
   s.extra_rdoc_files = ["CHANGELOG".freeze, "LICENSE".freeze, "lib/avro.rb".freeze, "lib/avro/data_file.rb".freeze, "lib/avro/io.rb".freeze, "lib/avro/ipc.rb".freeze, "lib/avro/logical_types.rb".freeze, "lib/avro/protocol.rb".freeze, "lib/avro/schema.rb".freeze, "lib/avro/schema_compatibility.rb".freeze, "lib/avro/schema_normalization.rb".freeze, "lib/avro/schema_validator.rb".freeze]
   s.files = ["CHANGELOG".freeze, "LICENSE".freeze, "Manifest".freeze, "NOTICE".freeze, "Rakefile".freeze, "avro.gemspec".freeze, "interop/test_interop.rb".freeze, "lib/avro.rb".freeze, "lib/avro/data_file.rb".freeze, "lib/avro/io.rb".freeze, "lib/avro/ipc.rb".freeze, "lib/avro/logical_types.rb".freeze, "lib/avro/protocol.rb".freeze, "lib/avro/schema.rb".freeze, "lib/avro/schema_compatibility.rb".freeze, "lib/avro/schema_normalization.rb".freeze, "lib/avro/schema_validator.rb".freeze, "test/case_finder.rb".freeze, "test/random_data.rb".freeze, "test/sample_ipc_client.rb".freeze, "test/sample_ipc_http_client.rb".freeze, "test/sample_ipc_http_server.rb".freeze, "test/sample_ipc_server.rb".freeze, "test/test_datafile.rb".freeze, "test/test_fingerprints.rb".freeze, "test/test_help.rb".freeze, "test/test_io.rb".freeze, "test/test_logical_types.rb".freeze, "test/test_protocol.rb".freeze, "test/test_schema.rb".freeze, "test/test_schema_compatibility.rb".freeze, "test/test_schema_normalization.rb".freeze, "test/test_schema_validator.rb".freeze, "test/test_socket_transport.rb".freeze, "test/tool.rb".freeze]
   s.homepage = "https://avro.apache.org/".freeze
-  s.licenses = ["Apache License 2.0 (Apache-2.0)".freeze]
+  s.licenses = ["Apache-2.0".freeze]
   s.rdoc_options = ["--line-numbers".freeze, "--title".freeze, "Avro".freeze]
   s.rubyforge_project = "avro".freeze
   s.rubygems_version = "2.5.2.1".freeze
   s.summary = "Apache Avro for Ruby".freeze
-  s.test_files = ["test/test_schema_validator.rb".freeze, "test/test_help.rb".freeze, "test/test_schema_normalization.rb".freeze, "test/test_datafile.rb".freeze, "test/test_schema.rb".freeze, "test/test_io.rb".freeze, "test/test_socket_transport.rb".freeze, "test/test_schema_compatibility.rb".freeze, "test/test_logical_types.rb".freeze, "test/test_fingerprints.rb".freeze, "test/test_protocol.rb".freeze]
+  s.test_files = ["test/test_help.rb".freeze, "test/test_io.rb".freeze, "test/test_socket_transport.rb".freeze, "test/test_fingerprints.rb".freeze, "test/test_schema.rb".freeze, "test/test_schema_compatibility.rb".freeze, "test/test_schema_validator.rb".freeze, "test/test_schema_normalization.rb".freeze, "test/test_protocol.rb".freeze, "test/test_datafile.rb".freeze, "test/test_logical_types.rb".freeze]
 
   if s.respond_to? :specification_version then
     s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<multi_json>.freeze, [">= 0"])
+      s.add_runtime_dependency(%q<multi_json>.freeze, ["~> 1"])
     else
-      s.add_dependency(%q<multi_json>.freeze, [">= 0"])
+      s.add_dependency(%q<multi_json>.freeze, ["~> 1"])
     end
   else
-    s.add_dependency(%q<multi_json>.freeze, [">= 0"])
+    s.add_dependency(%q<multi_json>.freeze, ["~> 1"])
   end
 end

data/interop/test_interop.rb

@@ -19,12 +19,22 @@ require 'rubygems'
 require 'test/unit'
 require 'avro'
 
+CODECS_TO_VALIDATE = ['deflate', 'snappy', 'zstandard']  # The 'null' codec is implicitly included
+
 class TestInterop < Test::Unit::TestCase
   HERE = File.expand_path(File.dirname(__FILE__))
   SHARE = HERE + '/../../../share'
   SCHEMAS = SHARE + '/test/schemas'
-  Dir[HERE + '/../../../build/interop/data/*'].each do |fn|
-    define_method("test_read_#{File.basename(fn, 'avro')}") do
+
+  files = Dir[HERE + '/../../../build/interop/data/*.avro'].select do |fn|
+    sep, codec = File.basename(fn, '.avro').rpartition('_')[1, 2]
+    sep.empty? || CODECS_TO_VALIDATE.include?(codec)
+  end
+  puts "The following files will be tested:"
+  puts files
+
+  files.each do |fn|
+    define_method("test_read_#{File.basename(fn, '.avro')}") do
       projection = Avro::Schema.parse(File.read(SCHEMAS+'/interop.avsc'))
 
       File.open(fn) do |f|

data/lib/avro.rb

@@ -28,18 +28,30 @@ module Avro
 
   class AvroTypeError < Avro::AvroError
     def initialize(schm=nil, datum=nil, msg=nil)
-      msg ||= "Not a #{schm.to_s}: #{datum}"
+      msg ||= "Not a #{schm}: #{datum}"
       super(msg)
     end
   end
 
   class << self
+    attr_writer :disable_enum_symbol_validation
     attr_writer :disable_field_default_validation
+    attr_writer :disable_schema_name_validation
+
+    def disable_enum_symbol_validation
+      @disable_enum_symbol_validation ||=
+        ENV.fetch('AVRO_DISABLE_ENUM_SYMBOL_VALIDATION', '') != ''
+    end
 
     def disable_field_default_validation
       @disable_field_default_validation ||=
         ENV.fetch('AVRO_DISABLE_FIELD_DEFAULT_VALIDATION', '') != ''
     end
+
+    def disable_schema_name_validation
+      @disable_schema_name_validation ||=
+        ENV.fetch('AVRO_DISABLE_SCHEMA_NAME_VALIDATION', '') != ''
+    end
   end
 end
 

data/lib/avro/data_file.rb

@@ -372,9 +372,32 @@ module Avro
       end
     end
 
+    class ZstandardCodec
+      def codec_name; 'zstandard'; end
+
+      def decompress(data)
+        load_zstandard!
+        Zstd.decompress(data)
+      end
+
+      def compress(data)
+        load_zstandard!
+        Zstd.compress(data)
+      end
+
+      private
+
+      def load_zstandard!
+        require 'zstd-ruby' unless defined?(Zstd)
+      rescue LoadError
+        raise LoadError, "Zstandard compression is not available, please install the `zstd-ruby` gem."
+      end
+    end
+
     DataFile.register_codec NullCodec
     DataFile.register_codec DeflateCodec
     DataFile.register_codec SnappyCodec
+    DataFile.register_codec ZstandardCodec
 
     # TODO this constant won't be updated if you register another codec.
     # Deprecated in favor of Avro::DataFile::codecs

data/lib/avro/io.rb

@@ -172,7 +172,7 @@ module Avro
       end
 
       # null is written as zero bytes
-      def write_null(datum)
+      def write_null(_datum)
         nil
       end
 
@@ -292,7 +292,7 @@ module Avro
         readers_schema.type_adapter.decode(datum)
       end
 
-      def read_fixed(writers_schema, readers_schema, decoder)
+      def read_fixed(writers_schema, _readers_schema, decoder)
         decoder.read(writers_schema.size)
       end
 
@@ -300,12 +300,12 @@ module Avro
         index_of_symbol = decoder.read_int
         read_symbol = writers_schema.symbols[index_of_symbol]
 
-        # TODO(jmhodges): figure out what unset means for resolution
-        # schema resolution
-        unless readers_schema.symbols.include?(read_symbol)
-          # 'unset' here
+        if !readers_schema.symbols.include?(read_symbol) && readers_schema.default
+          read_symbol = readers_schema.default
         end
 
+        # This implementation deviates from the spec by always returning
+        # a symbol.
         read_symbol
       end
 
@@ -359,26 +359,28 @@ module Avro
         readers_fields_hash = readers_schema.fields_hash
         read_record = {}
         writers_schema.fields.each do |field|
-          if readers_field = readers_fields_hash[field.name]
+          readers_field = readers_fields_hash[field.name]
+          if readers_field
             field_val = read_data(field.type, readers_field.type, decoder)
             read_record[field.name] = field_val
+          elsif readers_schema.fields_by_alias.key?(field.name)
+            readers_field = readers_schema.fields_by_alias[field.name]
+            field_val = read_data(field.type, readers_field.type, decoder)
+            read_record[readers_field.name] = field_val
           else
             skip_data(field.type, decoder)
           end
         end
 
         # fill in the default values
-        if readers_fields_hash.size > read_record.size
-          writers_fields_hash = writers_schema.fields_hash
-          readers_fields_hash.each do |field_name, field|
-            unless writers_fields_hash.has_key? field_name
-              if field.default?
-                field_val = read_default_value(field.type, field.default)
-                read_record[field.name] = field_val
-              else
-                raise AvroError, "Missing data for #{field.type} with no default"
-              end
-            end
+        readers_fields_hash.each do |field_name, field|
+          next if read_record.key?(field_name)
+
+          if field.default?
+            field_val = read_default_value(field.type, field.default)
+            read_record[field.name] = field_val
+          else
+            raise AvroError, "Missing data for #{field.type} with no default"
           end
         end
 
@@ -468,7 +470,7 @@ module Avro
         decoder.skip(writers_schema.size)
       end
 
-      def skip_enum(writers_schema, decoder)
+      def skip_enum(_writers_schema, decoder)
         decoder.skip_int
       end
 
@@ -545,7 +547,7 @@ module Avro
         end
       end
 
-      def write_fixed(writers_schema, datum, encoder)
+      def write_fixed(_writers_schema, datum, encoder)
         encoder.write(datum)
       end
 
@@ -591,7 +593,7 @@ module Avro
       def write_record(writers_schema, datum, encoder)
         raise AvroTypeError.new(writers_schema, datum) unless datum.is_a?(Hash)
         writers_schema.fields.each do |field|
-          write_data(field.type, datum[field.name], encoder)
+          write_data(field.type, datum.key?(field.name) ? datum[field.name] : datum[field.name.to_sym], encoder)
         end
       end
     end # DatumWriter

data/lib/avro/ipc.rb

@@ -278,7 +278,7 @@ module Avro::IPC
           response = call(local_message, request)
         rescue AvroRemoteError => e
           error = e
-        rescue Exception => e
+        rescue Exception => e # rubocop:disable Lint/RescueException
           error = AvroRemoteError.new(e.to_s)
         end
 
@@ -350,7 +350,7 @@ module Avro::IPC
       remote_protocol
     end
 
-    def call(local_message, request)
+    def call(_local_message, _request)
       # Actual work done by server: cf. handler in thrift.
       raise NotImplementedError
     end

data/lib/avro/schema.rb

@@ -29,6 +29,8 @@ module Avro
     NAMED_TYPES_SYM     = Set.new(NAMED_TYPES.map(&:to_sym))
     VALID_TYPES_SYM     = Set.new(VALID_TYPES.map(&:to_sym))
 
+    NAME_REGEX = /^([A-Za-z_][A-Za-z0-9_]*)(\.([A-Za-z_][A-Za-z0-9_]*))*$/
+
     INT_MIN_VALUE = -(1 << 31)
     INT_MAX_VALUE = (1 << 31) - 1
     LONG_MIN_VALUE = -(1 << 63)
@@ -53,23 +55,34 @@ module Avro
 
         type_sym = type.to_sym
         if PRIMITIVE_TYPES_SYM.include?(type_sym)
-          return PrimitiveSchema.new(type_sym, logical_type)
-
+          case type_sym
+          when :bytes
+            precision = json_obj['precision']
+            scale = json_obj['scale']
+            return BytesSchema.new(type_sym, logical_type, precision, scale)
+          else
+            return PrimitiveSchema.new(type_sym, logical_type)
+          end
         elsif NAMED_TYPES_SYM.include? type_sym
           name = json_obj['name']
+          if !Avro.disable_schema_name_validation && name !~ NAME_REGEX
+            raise SchemaParseError, "Name #{name} is invalid for type #{type}!"
+          end
           namespace = json_obj.include?('namespace') ? json_obj['namespace'] : default_namespace
+          aliases = json_obj['aliases']
           case type_sym
           when :fixed
             size = json_obj['size']
-            return FixedSchema.new(name, namespace, size, names, logical_type)
+            return FixedSchema.new(name, namespace, size, names, logical_type, aliases)
           when :enum
             symbols = json_obj['symbols']
             doc     = json_obj['doc']
-            return EnumSchema.new(name, namespace, symbols, names, doc)
+            default = json_obj['default']
+            return EnumSchema.new(name, namespace, symbols, names, doc, default, aliases)
           when :record, :error
             fields = json_obj['fields']
             doc    = json_obj['doc']
-            return RecordSchema.new(name, namespace, fields, names, type_sym, doc)
+            return RecordSchema.new(name, namespace, fields, names, type_sym, doc, aliases)
           else
             raise SchemaParseError.new("Unknown named type: #{type}")
           end
@@ -131,6 +144,49 @@ module Avro
       Digest::SHA256.hexdigest(parsing_form).to_i(16)
     end
 
+    CRC_EMPTY = 0xc15d213aa4d7a795
+
+    # The java library caches this value after initialized, so this pattern
+    # mimics that.
+    @@fp_table = nil
+    def initFPTable
+      @@fp_table = Array.new(256)
+      256.times do |i|
+        fp = i
+        8.times do
+          fp = (fp >> 1) ^ ( CRC_EMPTY & -( fp & 1 ) )
+        end
+        @@fp_table[i] = fp
+      end
+    end
+
+    def crc_64_avro_fingerprint
+      parsing_form = Avro::SchemaNormalization.to_parsing_form(self)
+      data_bytes = parsing_form.unpack("C*")
+
+      initFPTable unless @@fp_table
+
+      fp = CRC_EMPTY
+      data_bytes.each do |b|
+        fp = (fp >> 8) ^ @@fp_table[ (fp ^ b) & 0xff ]
+      end
+      fp
+    end
+
+    SINGLE_OBJECT_MAGIC_NUMBER = [0xC3, 0x01]
+    def single_object_encoding_header
+      [SINGLE_OBJECT_MAGIC_NUMBER, single_object_schema_fingerprint].flatten
+    end
+    def single_object_schema_fingerprint
+      working = crc_64_avro_fingerprint
+      bytes = Array.new(8)
+      8.times do |i|
+        bytes[7 - i] = (working & 0xff)
+        working = working >> 8
+      end
+      bytes
+    end
+
     def read?(writers_schema)
       SchemaCompatibility.can_read?(writers_schema, self)
     end
@@ -143,11 +199,11 @@ module Avro
       SchemaCompatibility.mutual_read?(other_schema, self)
     end
 
-    def ==(other, seen=nil)
+    def ==(other, _seen=nil)
       other.is_a?(Schema) && type_sym == other.type_sym
     end
 
-    def hash(seen=nil)
+    def hash(_seen=nil)
       type_sym.hash
     end
 
@@ -165,7 +221,7 @@ module Avro
       end
     end
 
-    def to_avro(names=nil)
+    def to_avro(_names=nil)
       props = {'type' => type}
       props['logicalType'] = logical_type if logical_type
       props
@@ -175,14 +231,26 @@ module Avro
       MultiJson.dump to_avro
     end
 
+    def validate_aliases!
+      unless aliases.nil? ||
+        (aliases.is_a?(Array) && aliases.all? { |a| a.is_a?(String) })
+
+        raise Avro::SchemaParseError,
+              "Invalid aliases value #{aliases.inspect} for #{type} #{name}. Must be an array of strings."
+      end
+    end
+    private :validate_aliases!
+
     class NamedSchema < Schema
-      attr_reader :name, :namespace
+      attr_reader :name, :namespace, :aliases
 
-      def initialize(type, name, namespace=nil, names=nil, doc=nil, logical_type=nil)
+      def initialize(type, name, namespace=nil, names=nil, doc=nil, logical_type=nil, aliases=nil)
         super(type, logical_type)
         @name, @namespace = Name.extract_namespace(name, namespace)
-        @doc  = doc
-        names = Name.add_name(names, self)
+        @doc = doc
+        @aliases = aliases
+        validate_aliases! if aliases
+        Name.add_name(names, self)
       end
 
       def to_avro(names=Set.new)
@@ -192,33 +260,53 @@ module Avro
         end
         props = {'name' => @name}
         props.merge!('namespace' => @namespace) if @namespace
-        props.merge!('doc' => @doc) if @doc
+        props['namespace'] = @namespace if @namespace
+        props['doc'] = @doc if @doc
+        props['aliases'] = aliases if aliases && aliases.any?
         super.merge props
       end
 
       def fullname
         @fullname ||= Name.make_fullname(@name, @namespace)
       end
+
+      def fullname_aliases
+        @fullname_aliases ||= if aliases
+                                aliases.map { |a| Name.make_fullname(a, namespace) }
+                              else
+                                []
+                              end
+      end
+
+      def match_fullname?(name)
+        name == fullname || fullname_aliases.include?(name)
+      end
     end
 
     class RecordSchema < NamedSchema
       attr_reader :fields, :doc
 
       def self.make_field_objects(field_data, names, namespace=nil)
-        field_objects, field_names = [], Set.new
-        field_data.each_with_index do |field, i|
+        field_objects, field_names, alias_names = [], Set.new, Set.new
+        field_data.each do |field|
           if field.respond_to?(:[]) # TODO(jmhodges) wtffffff
             type = field['type']
             name = field['name']
             default = field.key?('default') ? field['default'] : :no_default
             order = field['order']
             doc = field['doc']
-            new_field = Field.new(type, name, default, order, names, namespace, doc)
+            aliases = field['aliases']
+            new_field = Field.new(type, name, default, order, names, namespace, doc, aliases)
             # make sure field name has not been used yet
             if field_names.include?(new_field.name)
               raise SchemaParseError, "Field name #{new_field.name.inspect} is already in use"
             end
             field_names << new_field.name
+            # make sure alias has not be been used yet
+            if new_field.aliases && alias_names.intersect?(new_field.aliases.to_set)
+              raise SchemaParseError, "Alias #{(alias_names & new_field.aliases).to_a} already in use"
+            end
+            alias_names.merge(new_field.aliases) if new_field.aliases
           else
             raise SchemaParseError, "Not a valid field: #{field}"
           end
@@ -227,14 +315,14 @@ module Avro
         field_objects
       end
 
-      def initialize(name, namespace, fields, names=nil, schema_type=:record, doc=nil)
+      def initialize(name, namespace, fields, names=nil, schema_type=:record, doc=nil, aliases=nil)
         if schema_type == :request || schema_type == 'request'
           @type_sym = schema_type.to_sym
           @namespace = namespace
           @name = nil
           @doc = nil
         else
-          super(schema_type, name, namespace, names, doc)
+          super(schema_type, name, namespace, names, doc, nil, aliases)
         end
         @fields = if fields
                     RecordSchema.make_field_objects(fields, names, self.namespace)
@@ -247,6 +335,16 @@ module Avro
         @fields_hash ||= fields.inject({}){|hsh, field| hsh[field.name] = field; hsh }
       end
 
+      def fields_by_alias
+        @fields_by_alias ||= fields.each_with_object({}) do |field, hash|
+          if field.aliases
+            field.aliases.each do |a|
+              hash[a] = field
+            end
+          end
+        end
+      end
+
       def to_avro(names=Set.new)
         hsh = super
         return hsh unless hsh.is_a?(Hash)
@@ -313,20 +411,41 @@ module Avro
     end
 
     class EnumSchema < NamedSchema
-      attr_reader :symbols, :doc
+      SYMBOL_REGEX = /^[A-Za-z_][A-Za-z0-9_]*$/
+
+      attr_reader :symbols, :doc, :default
 
-      def initialize(name, space, symbols, names=nil, doc=nil)
+      def initialize(name, space, symbols, names=nil, doc=nil, default=nil, aliases=nil)
         if symbols.uniq.length < symbols.length
           fail_msg = "Duplicate symbol: #{symbols}"
           raise Avro::SchemaParseError, fail_msg
         end
-        super(:enum, name, space, names, doc)
+
+        if !Avro.disable_enum_symbol_validation
+          invalid_symbols = symbols.select { |symbol| symbol !~ SYMBOL_REGEX }
+
+          if invalid_symbols.any?
+            raise SchemaParseError,
+              "Invalid symbols for #{name}: #{invalid_symbols.join(', ')} don't match #{SYMBOL_REGEX.inspect}"
+          end
+        end
+
+        if default && !symbols.include?(default)
+          raise Avro::SchemaParseError, "Default '#{default}' is not a valid symbol for enum #{name}"
+        end
+
+        super(:enum, name, space, names, doc, nil, aliases)
+        @default = default
         @symbols = symbols
       end
 
-      def to_avro(names=Set.new)
+      def to_avro(_names=Set.new)
         avro = super
-        avro.is_a?(Hash) ? avro.merge('symbols' => symbols) : avro
+        if avro.is_a?(Hash)
+          avro['symbols'] = symbols
+          avro['default'] = default if default
+        end
+        avro
       end
     end
 
@@ -348,14 +467,32 @@ module Avro
       end
     end
 
+    class BytesSchema < PrimitiveSchema
+      attr_reader :precision, :scale
+      def initialize(type, logical_type=nil, precision=nil, scale=nil)
+        super(type.to_sym, logical_type)
+        @precision = precision
+        @scale = scale
+      end
+
+      def to_avro(names=nil)
+        avro = super
+        return avro if avro.is_a?(String)
+
+        avro['precision'] = precision if precision
+        avro['scale'] = scale if scale
+        avro
+      end
+    end
+
     class FixedSchema < NamedSchema
       attr_reader :size
-      def initialize(name, space, size, names=nil, logical_type=nil)
+      def initialize(name, space, size, names=nil, logical_type=nil, aliases=nil)
         # Ensure valid cto args
         unless size.is_a?(Integer)
           raise AvroError, 'Fixed Schema requires a valid integer for size property.'
         end
-        super(:fixed, name, space, names, nil, logical_type)
+        super(:fixed, name, space, names, nil, logical_type, aliases)
         @size = size
       end
 
@@ -366,14 +503,16 @@ module Avro
     end
 
     class Field < Schema
-      attr_reader :type, :name, :default, :order, :doc
+      attr_reader :type, :name, :default, :order, :doc, :aliases
 
-      def initialize(type, name, default=:no_default, order=nil, names=nil, namespace=nil, doc=nil)
+      def initialize(type, name, default=:no_default, order=nil, names=nil, namespace=nil, doc=nil, aliases=nil)
         @type = subparse(type, names, namespace)
         @name = name
         @default = default
         @order = order
         @doc = doc
+        @aliases = aliases
+        validate_aliases! if aliases
         validate_default! if default? && !Avro.disable_field_default_validation
       end
 
@@ -389,6 +528,10 @@ module Avro
         end
       end
 
+      def alias_names
+        @alias_names ||= Array(aliases)
+      end
+
       private
 
       def validate_default!