avro 1.11.1 → 1.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 660434b4d31525eed0d771a26e10c3753856fa45797e55845a82b4a8d4b2361c
-  data.tar.gz: a44c0c7af2a5a030c648d5cc3705ae2ea092fccb3d58ccf9186f4f4619d79092
+  metadata.gz: 124c809b0bcf3463852b754fb01cf2b75e4d90547a934d8932a27f52a3264b69
+  data.tar.gz: e293185ed5b05dd1aaf6837dc9a64748cd0d26fbba8ab5fc0a4b608cca7ab244
 SHA512:
-  metadata.gz: a7eb879efaea928bf6a8d39079f0b6d92381c3905fcae130c37e1e426f33f940b13b028df43ebcf5ce0bb40dc996efd4c88d7bea5b7b6088715c2677a48146d5
-  data.tar.gz: 9657974edde8c940074930808706554c9db9390f061f573830194cdd9167fed1c46c1811b188cf598cc2a48673874e2af41d43c73ce74ff7c620594e641f4831
+  metadata.gz: 677e4fc7525cea9ac5309b891bb88b60c2421ee58add86d90efa3fa0731199b6cbb2f0bb2b7db42c9237f54a36fb5dda49de649fb5d40810d73f1c7084d9e290
+  data.tar.gz: e0bcfcd4f139ad961ae0af5ecac5eba24d6cfaab866487bd8c06918158d7e0f8307b33fc550cd35c2a75cc93fa75851c038a85a2f27f8eed123bf16219d07105

data/lib/avro/VERSION.txt

@@ -1 +1 @@
-1.11.1
+1.11.3

data/lib/avro/io.rb

@@ -390,31 +390,31 @@ module Avro
 
       def read_default_value(field_schema, default_value)
         # Basically a JSON Decoder?
-        case field_schema.type_sym
+        datum = case field_schema.type_sym
         when :null
-          return nil
+          nil
         when :int, :long
-          return Integer(default_value)
+          Integer(default_value)
         when :float, :double
-          return Float(default_value)
+          Float(default_value)
         when :boolean, :enum, :fixed, :string, :bytes
-          return default_value
+          default_value
         when :array
           read_array = []
           default_value.each do |json_val|
             item_val = read_default_value(field_schema.items, json_val)
             read_array << item_val
           end
-          return read_array
+          read_array
         when :map
           read_map = {}
           default_value.each do |key, json_val|
             map_val = read_default_value(field_schema.values, json_val)
             read_map[key] = map_val
           end
-          return read_map
+          read_map
         when :union
-          return read_default_value(field_schema.schemas[0], default_value)
+          read_default_value(field_schema.schemas[0], default_value)
         when :record, :error
           read_record = {}
           field_schema.fields.each do |field|
@@ -423,11 +423,13 @@ module Avro
             field_val = read_default_value(field.type, json_val)
             read_record[field.name] = field_val
           end
-          return read_record
+          read_record
         else
           fail_msg = "Unknown type: #{field_schema.type}"
           raise AvroError, fail_msg
         end
+
+        field_schema.type_adapter.decode(datum)
       end
 
       def skip_data(writers_schema, decoder)

data/lib/avro/schema.rb

@@ -111,7 +111,7 @@ module Avro
       elsif PRIMITIVE_TYPES.include? json_obj
         return PrimitiveSchema.new(json_obj)
       else
-        raise UnknownSchemaError.new(json_obj)
+        raise UnknownSchemaError.new(json_obj, default_namespace)
       end
     end
 
@@ -126,6 +126,7 @@ module Avro
     def initialize(type, logical_type=nil)
       @type_sym = type.is_a?(Symbol) ? type : type.to_sym
       @logical_type = logical_type
+      @type_adapter = nil
     end
 
     attr_reader :type_sym
@@ -571,6 +572,7 @@ module Avro
         @order = order
         @doc = doc
         @aliases = aliases
+        @type_adapter = nil
         validate_aliases! if aliases
         validate_default! if default? && !Avro.disable_field_default_validation
       end
@@ -599,8 +601,16 @@ module Avro
                            else
                              type
                            end
-
-        Avro::SchemaValidator.validate!(type_for_default, default)
+        case type_for_default.logical_type
+        when DECIMAL_LOGICAL_TYPE
+          # https://avro.apache.org/docs/1.11.1/specification/#schema-record
+          # Default values for bytes and fixed fields are JSON strings, where Unicode code points 0-255 are mapped to unsigned 8-bit byte values 0-255
+          options = SchemaValidator::DEFAULT_VALIDATION_OPTIONS.dup
+          options[:encoded] = true
+          Avro::SchemaValidator.validate!(type_for_default, default, options)
+        else
+          Avro::SchemaValidator.validate!(type_for_default, default)
+        end
       rescue Avro::SchemaValidator::ValidationError => e
         raise Avro::SchemaParseError, "Error validating default for #{name}: #{e.message}"
       end
@@ -611,9 +621,11 @@ module Avro
 
   class UnknownSchemaError < SchemaParseError
     attr_reader :type_name
+    attr_reader :default_namespace
 
-    def initialize(type)
+    def initialize(type, default_namespace)
       @type_name = type
+      @default_namespace = default_namespace
       super("#{type.inspect} is not a schema we know about.")
     end
   end

data/test/test_logical_types.rb

@@ -124,6 +124,113 @@ class TestLogicalTypes < Test::Unit::TestCase
     end
   end
 
+  def test_logical_type_default_value
+    sales_schema = Avro::Schema.parse('{
+        "type": "record",
+        "name": "Order",
+        "fields" : [
+            {
+                "name": "sales",
+                "type": [
+                    {
+                        "type": "bytes",
+                        "logicalType": "decimal",
+                        "precision": 4,
+                        "scale": 2
+                    },
+                    "null"
+                ],
+                "default": "\u0000"
+            }  
+        ]
+    }')
+
+    sales_tax_schema = Avro::Schema.parse('{
+        "type": "record",
+        "name": "Order",
+        "fields" : [
+            {
+                "name": "sales",
+                "type": [
+                    {
+                        "type": "bytes",
+                        "logicalType": "decimal",
+                        "precision": 4,
+                        "scale": 2
+                    },
+                    "null"
+                ],
+                "default": "\u0000"
+            },
+            {
+                "name": "tax",
+                "type": [
+                    {
+                        "type": "bytes",
+                        "logicalType": "decimal",
+                        "precision": 4,
+                        "scale": 2
+                    },
+                    "null"
+                ],
+                "default": "\u0000"
+            },
+            {
+                "name": "invoice_date",
+                "type": [
+                    {
+                        "type": "int",
+                        "logicalType": "date"
+                    },
+                    "null"
+                ],
+                "default": 0
+            },
+            {
+                "name": "invoice_time",
+                "type": [
+                    {
+                        "type": "int",
+                        "logicalType": "time-millis"
+                    },
+                    "null"
+                ],
+                "default": 0
+            },
+            {
+                "name": "created_at",
+                "type": [
+                    {
+                        "type": "long",
+                        "logicalType": "timestamp-millis"
+                    },
+                    "null"
+                ],
+                "default": 0
+            }
+        ]
+    }')
+
+    sales_record = {"sales" => BigDecimal("12.34")}
+    sales_tax_record = {
+      "sales" => BigDecimal("12.34"),
+      "tax" => BigDecimal("0.000"),
+      "invoice_date" => Time.at(0).to_date,
+      # time-millis is not supported
+      "invoice_time" => 0,
+      "created_at" => Time.at(0).utc,
+    }
+    encoded = encode(sales_record, sales_schema)
+    assert_equal sales_record, decode(encoded, sales_schema)
+    # decode with different schema applies default
+    assert_equal sales_tax_record, decode(encoded, sales_tax_schema, writer_schema: sales_schema)
+
+    # decode with same schema does not apply default, since it is nullable during encode
+    encoded = encode(sales_record, sales_tax_schema)
+    tax_nil_record = {"sales" => BigDecimal("12.34"), "tax" => nil, "invoice_date" => nil, "invoice_time" => nil, "created_at" => nil}
+    assert_equal tax_nil_record, decode(encoded, sales_tax_schema)
+  end
+
   def test_bytes_decimal_range_errors
     schema = Avro::Schema.parse <<-SCHEMA
       { "type": "bytes", "logicalType": "decimal", "precision": 4, "scale": 2 }
@@ -230,8 +337,8 @@ class TestLogicalTypes < Test::Unit::TestCase
       end
 
       assert_equal 5, report.total_allocated
-      # Ruby 2.7 does not retain anything. Ruby 2.6 retains 1
-      assert_operator 1, :>=, report.total_retained
+      # Ruby 2.7 does not retain anything. Ruby 2.6 retains 1 or 2
+      assert_operator 2, :>=, report.total_retained
     end
   end
 
@@ -245,11 +352,12 @@ class TestLogicalTypes < Test::Unit::TestCase
     buffer.string
   end
 
-  def decode(encoded, schema)
+  def decode(encoded, schema, writer_schema: nil)
+    writer_schema ||= schema
     buffer = StringIO.new(encoded)
     decoder = Avro::IO::BinaryDecoder.new(buffer)
 
-    datum_reader = Avro::IO::DatumReader.new(schema, schema)
+    datum_reader = Avro::IO::DatumReader.new(writer_schema, schema)
     datum_reader.read(decoder)
   end
 

data/test/test_schema.rb

@@ -176,6 +176,8 @@ class TestSchema < Test::Unit::TestCase
     end
 
     assert_equal '"MissingType" is not a schema we know about.', error.message
+    assert_equal "MissingType", error.type_name
+    assert_equal "my.name.space", error.default_namespace
   end
 
   def test_invalid_name
@@ -612,6 +614,37 @@ class TestSchema < Test::Unit::TestCase
     assert_equal schema_hash, schema.to_avro
   end
 
+  def test_bytes_decimal_in_record
+    assert_nothing_raised do
+      hash_to_schema(
+        type: 'record',
+        name: 'account',
+        fields: [
+          { name: 'balance', type: 'bytes', logicalType: 'decimal', precision: 9, scale: 2 }
+        ]
+      )
+    end
+  end
+
+  def test_bytes_decimal_with_default_in_record
+    assert_nothing_raised do
+      hash_to_schema(
+        type: 'record',
+        name: 'account',
+        fields: [
+          {
+            name: 'balance',
+            type: [
+              { type: 'bytes', logicalType: 'decimal', precision: 9, scale: 2 },
+              'null'
+            ],
+            default: '\u00ff'
+          }
+        ]
+      )
+    end
+  end
+  
   def test_bytes_decimal_to_include_precision_scale
     schema = Avro::Schema.parse <<-SCHEMA
       {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avro
 version: !ruby/object:Gem::Version
-  version: 1.11.1
+  version: 1.11.3
 platform: ruby
 authors:
 - Apache Software Foundation
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-26 00:00:00.000000000 Z
+date: 2023-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -72,9 +72,9 @@ metadata:
   homepage_uri: https://avro.apache.org/
   bug_tracker_uri: https://issues.apache.org/jira/browse/AVRO
   source_code_uri: https://github.com/apache/avro
-  documentation_uri: https://avro.apache.org/docs/1.11.1/
+  documentation_uri: https://avro.apache.org/docs/1.11.3/
   rubygems_mfa_required: 'true'
-post_install_message:
+post_install_message: 
 rdoc_options:
 - "--line-numbers"
 - "--title"
@@ -93,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key:
+signing_key: 
 specification_version: 4
 summary: Apache Avro for Ruby
 test_files: