ruby-hdf5 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7932dfc6c7cc1ffcfb6dc30c8963785e1e1e2ba206add86e634878d999e166d
-  data.tar.gz: cd6e121152d557821c64deb08a08286528911db013a48a0d7d7a1bff8c6da7a0
+  metadata.gz: 85ca4ff79d4a34553188284efb980628cd4f4931aa29d12bd37b09e0a89d3ca8
+  data.tar.gz: 1126e3458c88e00b00a6919ed832c35196673a5d785da524a218a9ff0772bd03
 SHA512:
-  metadata.gz: f7270f19f0bd3732147faad5f94f0c429f02c93e81ad66985adefddff43ac41fbacb2834073d6b195c14f4ff905df4a60735ea143fee79fab1116a96f76c7e54
-  data.tar.gz: 060cb8b49f0373ca6ac788274c1bb5bc187fe92bab799b240f731034b59abebd789c956e23da6ccdbef4dd577e37be38e20121879ce98caea20c326829cb2e2e
+  metadata.gz: 15f984a33a2c9036364e4bd4cef11acd041a1684f531cd30f05c235e764df5ff5a69cea2e7e727f0c34fd1438272673ed3764661bf1f0e19b0322f0879b4fea0
+  data.tar.gz: 9ef886f63b1c207e6c58e9b5a00462207d74239e522cb2aaeb9344237e93e14e6ad29326d3e79d7e9a1ea05b5a3d0215b0f5f5a250c412e9459a9810835f2aeb

data/lib/hdf5/attribute.rb

@@ -14,6 +14,8 @@ module HDF5
 
       space_id = HDF5::FFI.H5Aget_space(@attr_id)
       raise HDF5::Error, 'Failed to get attribute dataspace' if space_id < 0
+      return HDF5::Empty.new(DType.for_hdf5(type_id)) if HDF5::FFI.H5Sget_simple_extent_type(space_id) == :H5S_NULL
+
       return read_string(type_id, space_id) if HDF5::FFI.H5Tget_class(type_id) == :H5T_STRING
 
       dtype_object = DType.for_hdf5(type_id)
@@ -66,7 +68,7 @@ module HDF5
       status = HDF5::FFI.H5Aread(@attr_id, type_id, buffer)
       raise HDF5::Error, 'Failed to read string attribute' if status < 0
 
-      HDF5::StringCodec.read_values(buffer, count, attribute_shape)
+      HDF5::StringCodec.read_values(buffer, count, attribute_shape, encoding: HDF5::StringCodec.encoding_for(type_id))
     ensure
       if buffer
         active_error = $ERROR_INFO
@@ -134,7 +136,7 @@ module HDF5
       write(attr_name, value)
     end
 
-    def modify(attr_name, value)
+    def modify(attr_name, value, casting: :safe)
       @context&.ensure_open!(@dataset_id)
       raise HDF5::Error, "Attribute not found: #{attr_name}" unless key?(attr_name)
 
@@ -144,28 +146,34 @@ module HDF5
       type_id = HDF5::FFI.H5Aget_type(attr_id)
       space_id = HDF5::FFI.H5Aget_space(attr_id)
       raise HDF5::Error, "Failed to inspect attribute: #{attr_name}" if type_id < 0 || space_id < 0
+      if HDF5::FFI.H5Sget_simple_extent_type(space_id) == :H5S_NULL
+        unless value.is_a?(HDF5::Empty) && value.dtype.to_sym == DType.for_hdf5(type_id).to_sym
+          raise HDF5::ShapeError, 'Cannot assign a value to a Null attribute'
+        end
+        return value
+      end
 
       if HDF5::FFI.H5Tget_class(type_id) == :H5T_STRING
         unless HDF5::StringCodec.variable?(type_id)
           raise UnsupportedTypeError, 'Fixed-length string attributes are not yet supported'
         end
 
-        string_values, string_shape = HDF5::StringCodec.normalize_data(value)
+        encoding = HDF5::StringCodec.encoding_for(type_id)
+        string_values, string_shape = HDF5::StringCodec.normalize_data(value, encoding:)
         unless string_shape == attribute_shape(space_id)
           raise HDF5::ShapeError,
                 'Attribute shape must not change when modifying'
         end
 
-        buffer, _string_pointers = HDF5::StringCodec.buffer_for_values(string_values)
+        buffer, _string_pointers = HDF5::StringCodec.buffer_for_values(string_values, encoding:)
         status = HDF5::FFI.H5Awrite(attr_id, type_id, buffer)
       else
         dtype_object = DType.for_hdf5(type_id)
-        values = HDF5::DataHelpers.normalize_data(value, label: 'Attribute data')
+        values = HDF5::DataHelpers.normalize_data(value, label: 'Attribute data', dtype: dtype_object, casting:, convert: false)
         expected_shape = attribute_shape(space_id)
         raise HDF5::Error, 'Attribute shape must not change when modifying' unless values.shape == expected_shape
 
-        converted = dtype_object.numo_class.cast(values)
-        status = HDF5::FFI.H5Awrite(attr_id, dtype_object.memory_type_id, HDF5::DataHelpers.buffer_for(converted))
+        status = HDF5::FFI.H5Awrite(attr_id, DType.for_numo(values).memory_type_id, HDF5::DataHelpers.buffer_for(values))
       end
       raise HDF5::Error, "Failed to modify attribute: #{attr_name}" if status < 0
 
@@ -178,10 +186,14 @@ module HDF5
 
     def write(attr_name, value)
       @context&.ensure_open!(@dataset_id)
+      empty_data = value.is_a?(HDF5::Empty)
+      if empty_data && value.dtype.kind == :string
+        raise UnsupportedFeatureError, 'Creating Null string attributes is not yet supported'
+      end
       string_data = HDF5::StringCodec.string_data?(value)
       string_values, string_shape = HDF5::StringCodec.normalize_data(value) if string_data
-      values = HDF5::DataHelpers.normalize_data(value, label: 'Attribute data') unless string_data
-      dtype_object = DType.for_numo(values) unless string_data
+      values = HDF5::DataHelpers.normalize_data(value, label: 'Attribute data') unless string_data || empty_data
+      dtype_object = empty_data ? value.dtype : DType.for_numo(values) unless string_data
       type_id = string_data ? HDF5::StringCodec.datatype_id : dtype_object.storage_type_id
 
       exists = HDF5::FFI.H5Aexists(@dataset_id, attr_name)
@@ -192,7 +204,7 @@ module HDF5
         raise HDF5::Error, "Failed to replace attribute: #{attr_name}" if status < 0
       end
 
-      dataspace_id = create_dataspace(string_data ? string_shape : values.shape)
+      dataspace_id = create_dataspace(empty_data ? nil : (string_data ? string_shape : values.shape))
       raise HDF5::Error, 'Failed to create attribute dataspace' if dataspace_id < 0
 
       attr_id = HDF5::FFI.H5Acreate2(
@@ -204,6 +216,7 @@ module HDF5
         HDF5::DEFAULT_PROPERTY_LIST
       )
       raise HDF5::Error, "Failed to create attribute: #{attr_name}" if attr_id < 0
+      return value if empty_data
 
       buffer, _string_pointers = if string_data
                                    HDF5::StringCodec.buffer_for_values(string_values)
@@ -236,6 +249,8 @@ module HDF5
     end
 
     def create_dataspace(shape)
+      return HDF5::FFI.H5Screate(:H5S_NULL) if shape.nil?
+
       return HDF5::FFI.H5Screate(:H5S_SCALAR) if shape.empty?
 
       dimensions = ::FFI::MemoryPointer.new(:ulong_long, shape.length)

data/lib/hdf5/data_helpers.rb

@@ -2,27 +2,163 @@ module HDF5
   module DataHelpers
     module_function
 
-    def normalize_data(data, label: 'Data')
-      return data if data.is_a?(Numo::NArray) && DType.for_numo(data)
-
-      values = data.is_a?(Array) ? data.flatten : [data]
-      raise HDF5::Error, "#{label} must not be empty" if values.empty?
-
-      dtype = if values.all? { |value| value.is_a?(Integer) }
-                DType.for_symbol(:int64)
-              elsif values.all? { |value| [true, false].include?(value) }
-                DType.for_symbol(:bool)
-              elsif values.all? { |value| value.is_a?(Numeric) } && values.any? { |value| value.is_a?(Complex) }
-                DType.for_symbol(:complex128)
-              elsif values.all? { |value| value.is_a?(Numeric) }
-                DType.for_symbol(:float64)
-              else
-                raise HDF5::Error, "Only numeric #{label.downcase} is supported"
-              end
+    def normalize_data(data, label: 'Data', dtype: nil, casting: :safe, convert: true)
+      raise ArgumentError, "Unsupported casting mode: #{casting.inspect}" unless %i[safe unsafe].include?(casting)
+
+      if data.is_a?(Numo::NArray)
+        source = DType.for_numo(data)
+        return data unless dtype
+        unless source.castable_to?(dtype, casting:)
+          raise ConversionError, "Cannot safely cast #{source.to_sym} to #{dtype.to_sym}"
+        end
+        return data if source.to_sym == dtype.to_sym
+        # HDF5 converts numeric widths and matching complex compounds directly,
+        # but cannot convert a real numeric datatype to a complex compound.
+        native_conversion = dtype.kind != :complex || source.kind == :complex
+        return data if !convert && casting == :safe && native_conversion
+
+        return dtype.numo_class.cast(data)
+      end
+
+      # Homogeneous flat Arrays need no recursive shape traversal or per-value
+      # conversion checks: integer extrema cover the range; Ruby Float is float64.
+      if dtype.nil? && data.is_a?(Array) && !data.empty?
+        homogeneous = normalize_homogeneous_array(data, data, casting:)
+        return homogeneous if homogeneous
+      end
+
+      shape = array_shape(data)
+      values = data.is_a?(Array) ? (shape.length <= 1 ? data : data.flatten) : [data]
+      raise HDF5::Error, "#{label} must not be empty without an explicit dtype" if values.empty? && !dtype
+      if dtype.nil? && shape.length > 1
+        homogeneous = normalize_homogeneous_array(data, values, casting:)
+        return homogeneous if homogeneous
+      end
+
+      dtype ||= inferred_dtype(values, label:)
+      validate_values(values, dtype, casting:)
       normalized = dtype.kind == :bool ? normalize_booleans(data) : data
+      return dtype.numo_class.new(*shape) if values.empty?
+      return Numo::Bit.new.store(normalized) if dtype.kind == :bool && !data.is_a?(Array)
+
       dtype.numo_class.cast(normalized)
     end
 
+    def normalize_homogeneous_array(data, values, casting:)
+      if values.all? { |value| value.is_a?(Integer) }
+        minimum, maximum = values.minmax
+        dtype = DType.for_symbol(minimum >= 0 && maximum >= (1 << 63) ? :uint64 : :int64)
+        validate_values([minimum, maximum], dtype, casting:)
+        dtype.numo_class.cast(data)
+      elsif values.all? { |value| value.is_a?(Float) }
+        Numo::DFloat.cast(data)
+      end
+    end
+
+    def inferred_dtype(values, label:)
+      kind = nil
+      minimum = maximum = 0
+      values.each do |value|
+        if value.is_a?(Integer)
+          current = :int64
+          minimum = value if value < minimum
+          maximum = value if value > maximum
+        elsif value.is_a?(Complex)
+          current = :complex128
+        elsif value.is_a?(Numeric)
+          current = :float64
+        elsif value.equal?(true) || value.equal?(false)
+          current = :bool
+        else
+          raise HDF5::Error, "Only numeric #{label.downcase} is supported"
+        end
+        if kind && (kind == :bool) != (current == :bool)
+          raise HDF5::Error, "Only numeric #{label.downcase} is supported"
+        end
+        kind = current if kind.nil? || current == :complex128 || current == :float64 && kind == :int64
+      end
+      kind = :uint64 if kind == :int64 && minimum >= 0 && maximum >= (1 << 63)
+      DType.for_symbol(kind)
+    end
+
+    def array_shape(value)
+      return [] unless value.is_a?(Array)
+      return [0] if value.empty?
+
+      unless value.first.is_a?(Array)
+        raise ShapeError, 'Data must be rectangular' if value.any? { |item| item.is_a?(Array) }
+
+        return [value.length]
+      end
+
+      child_shape = array_shape(value.first)
+      index = 1
+      while index < value.length
+        item = value[index]
+        unless item.is_a?(Array) && array_shape(item) == child_shape
+          raise ShapeError, 'Data must be rectangular'
+        end
+        index += 1
+      end
+
+      [value.length, *child_shape]
+    end
+
+    def scalar?(value)
+      value.is_a?(Numeric) || value.equal?(true) || value.equal?(false) ||
+        value.is_a?(Numo::NArray) && value.shape.empty?
+    end
+
+    def validate_values(values, dtype, casting:)
+      if dtype.kind == :bool
+        unless values.all? { |value| value.equal?(true) || value.equal?(false) }
+          raise ConversionError, 'Bool data must contain true or false'
+        end
+        return
+      end
+      if casting == :unsafe
+        raise ConversionError, 'Data must contain numeric values' unless values.all? { |value| value.is_a?(Numeric) }
+        return
+      end
+
+      case dtype.kind
+      when :integer
+        bits = dtype.itemsize * 8
+        minimum = dtype.unsigned? ? 0 : -(1 << (bits - 1))
+        maximum = dtype.unsigned? ? (1 << bits) - 1 : (1 << (bits - 1)) - 1
+        values.each do |value|
+          unless value.is_a?(Integer) && value.between?(minimum, maximum)
+            raise ConversionError, "Value #{value.inspect} cannot safely be represented as #{dtype.to_sym}"
+          end
+        end
+      when :float, :complex
+        size = dtype.kind == :complex ? dtype.itemsize / 2 : dtype.itemsize
+        values.each do |value|
+          raise ConversionError, 'Data must contain numeric values' unless value.is_a?(Numeric)
+          if dtype.kind == :complex
+            validate_component(value.real, size, dtype)
+            validate_component(value.imag, size, dtype)
+          else
+            validate_component(value, size, dtype)
+          end
+        end
+      end
+    end
+
+    def validate_component(component, size, dtype)
+      return if size == 8 && component.is_a?(Float)
+
+      raise ConversionError, "Cannot safely cast complex data to #{dtype.to_sym}" if component.is_a?(Complex)
+
+      converted = component.to_f
+      converted = [converted].pack('f').unpack1('f') if size == 4
+      return if component.is_a?(Float) && !component.finite? && !converted.finite?
+      return if component.is_a?(Float) && component == converted
+      return if converted.finite? && converted.to_r == component.to_r
+
+      raise ConversionError, "Value #{component.inspect} cannot safely be represented as #{dtype.to_sym}"
+    end
+
     def buffer_for(narray)
       dtype = DType.for_numo(narray)
       binary = if dtype.kind == :bool

data/lib/hdf5/dataset.rb

@@ -2,13 +2,22 @@ module HDF5
   class Dataset
     class << self
       def create(parent_id, name, data = nil, shape: nil, dtype: nil, maxshape: nil, chunks: nil, compression: nil,
-                 compression_opts: nil, shuffle: false, fletcher32: false, fillvalue: nil, context: nil)
+                 compression_opts: nil, shuffle: false, fletcher32: false, fillvalue: nil, context: nil, casting: :safe)
+        raise HDF5::Error, 'shape: and dtype: are required when data: is omitted' if data.nil? && (!shape || !dtype)
+
         empty_data = data.is_a?(HDF5::Empty)
+        if empty_data
+          raise ShapeError, 'Null datasets cannot have a shape' unless shape.nil?
+          if data.dtype.kind == :string
+            raise UnsupportedFeatureError, 'Creating Null string datasets is not yet supported'
+          end
+        end
         string_data = HDF5::StringCodec.string_data?(data)
         _string_values, string_shape = HDF5::StringCodec.normalize_data(data) if string_data
         unless data.nil? || string_data || empty_data
           narray = HDF5::DataHelpers.normalize_data(data,
-                                                    label: 'Dataset data')
+                                                    label: 'Dataset data', dtype: dtype && DType.for_symbol(dtype), casting:,
+                                                    convert: false)
         end
         unless string_data
           dtype_object = if empty_data
@@ -19,7 +28,6 @@ module HDF5
         end
         type_id = string_data ? HDF5::StringCodec.datatype_id : dtype_object.storage_type_id
         shape = string_data ? string_shape : narray.shape if shape.nil? && !data.nil? && !empty_data
-        raise HDF5::Error, 'shape: and dtype: are required when data: is omitted' if data.nil? && (!shape || !dtype)
         raise HDF5::Error, 'Dataset shape must match data shape' if narray && shape != narray.shape
         raise HDF5::ShapeError, 'Dataset shape must match string data shape' if string_data && shape != string_shape
 
@@ -31,7 +39,7 @@ module HDF5
         raise HDF5::Error, "Failed to create dataspace for dataset: #{name}" if dataspace_id < 0
 
         dcpl_id = create_property_list(shape, dtype_object, chunks:, compression:, compression_opts:, shuffle:, fletcher32:,
-                                                            fillvalue:)
+                                                            fillvalue:, casting:)
 
         dataset = from_id(
           HDF5::FFI.H5Dcreate2(parent_id, name, type_id, dataspace_id, HDF5::DEFAULT_PROPERTY_LIST,
@@ -39,6 +47,7 @@ module HDF5
         )
         dataset.write(data) if string_data
         dataset.write(narray) if narray
+        initialized = true
         return dataset unless block_given?
 
         begin
@@ -47,7 +56,7 @@ module HDF5
           dataset.close
         end
       rescue StandardError
-        if dataset
+        if dataset && !initialized
           dataset.close unless dataset.closed?
           HDF5::FFI.H5Ldelete(parent_id, name, HDF5::DEFAULT_PROPERTY_LIST)
         end
@@ -104,7 +113,7 @@ module HDF5
       end
 
       def create_property_list(shape, dtype_object, chunks:, compression:, compression_opts:, shuffle:, fletcher32:,
-                               fillvalue:)
+                               fillvalue:, casting:)
         chunked = chunks || compression || compression_opts || shuffle || fletcher32
         return unless chunked || !fillvalue.nil?
         raise HDF5::Error, 'Chunked storage is not supported for scalar datasets' if chunked && shape.empty?
@@ -152,7 +161,7 @@ module HDF5
         end
         check_property_status(HDF5::FFI.H5Pset_fletcher32(dcpl_id), 'enable Fletcher32') if fletcher32
         unless fillvalue.nil?
-          value = dtype_object.numo_class.cast(fillvalue)
+          value = HDF5::DataHelpers.normalize_data(fillvalue, dtype: dtype_object, casting:, label: 'Fill value')
           raise HDF5::Error, 'fillvalue must be scalar' unless value.shape.empty?
 
           check_property_status(HDF5::FFI.H5Pset_fill_value(dcpl_id, dtype_object.memory_type_id, HDF5::DataHelpers.buffer_for(value)),
@@ -223,43 +232,24 @@ module HDF5
       ensure_open!
       return write_string(data, selection:) if HDF5::StringCodec.string_data?(data)
 
-      normalized_selection = Selection.normalize(selection, shape)
-      values = if data.is_a?(Numeric)
-                 target_dtype = dtype
-                 if normalized_selection.scalar?
-                   target_dtype.numo_class.cast(data)
-                 else
-                   target_dtype.numo_class.ones(*normalized_selection.result_shape) * data
-                 end
-               else
-                 HDF5::DataHelpers.normalize_data(data, label: 'Dataset data')
-               end
-      raise HDF5::Error, 'Dataset shape must match data shape' unless values.shape == normalized_selection.result_shape
+      current_shape = shape
+      raise HDF5::Error, 'Cannot write to a Null dataset' if current_shape.nil?
 
-      dtype_object = DType.for_numo(values)
+      normalized_selection = Selection.normalize(selection, current_shape)
       target_dtype = dtype
-      raise ConversionError, "Cannot safely cast #{dtype_object.to_sym} to #{target_dtype.to_sym}" unless
-        dtype_object.castable_to?(target_dtype, casting:)
-      return data if normalized_selection.size.zero?
+      raise ConversionError, 'String datasets require string data' if target_dtype.kind == :string
 
-      buffer = HDF5::DataHelpers.buffer_for(values)
-      file_space_id = HDF5::FFI.H5Dget_space(@dataset_id)
-      raise HDF5::Error, 'Failed to get dataset dataspace' if file_space_id < 0
-
-      select_hyperslab(file_space_id, normalized_selection)
-      memory_space_id = create_memory_dataspace(normalized_selection.result_shape)
-      raise HDF5::Error, 'Failed to create memory dataspace' if memory_space_id < 0
-      raise HDF5::Error, 'File and memory selections have different sizes' unless
-        HDF5::FFI.H5Sget_select_npoints(file_space_id) == HDF5::FFI.H5Sget_select_npoints(memory_space_id)
+      values = HDF5::DataHelpers.normalize_data(data, label: 'Dataset data', dtype: target_dtype, casting:, convert: false)
+      if HDF5::DataHelpers.scalar?(data) && !normalized_selection.scalar?
+        write_scalar(values, target_dtype, normalized_selection) unless normalized_selection.size.zero?
+        return data
+      end
+      raise HDF5::Error, 'Dataset shape must match data shape' unless values.shape == normalized_selection.result_shape
 
-      status = HDF5::FFI.H5Dwrite(@dataset_id, dtype_object.memory_type_id, memory_space_id, file_space_id,
-                                  HDF5::DEFAULT_PROPERTY_LIST, buffer)
-      raise HDF5::Error, 'Failed to write dataset' if status < 0
+      return data if normalized_selection.size.zero?
 
+      write_numeric_buffer(HDF5::DataHelpers.buffer_for(values), DType.for_numo(values), normalized_selection)
       data
-    ensure
-      HDF5::FFI.H5Sclose(memory_space_id) if memory_space_id && memory_space_id >= 0
-      HDF5::FFI.H5Sclose(file_space_id) if file_space_id && file_space_id >= 0
     end
 
     def close
@@ -344,6 +334,9 @@ module HDF5
     def fillvalue
       ensure_open!
       dtype_object = dtype
+      if dtype_object.kind == :string
+        raise UnsupportedFeatureError, 'fillvalue is not supported for string datasets'
+      end
       property_list_id = HDF5::FFI.H5Dget_create_plist(@dataset_id)
       raise HDF5::Error, 'Failed to get dataset creation properties' if property_list_id < 0
 
@@ -351,7 +344,8 @@ module HDF5
       status = HDF5::FFI.H5Pget_fill_value(property_list_id, dtype_object.memory_type_id, buffer)
       raise HDF5::Error, 'Failed to get dataset fill value' if status < 0
 
-      dtype_object.numo_class.from_binary(buffer.read_bytes(dtype_object.itemsize), []).extract
+      value = HDF5::DataHelpers.from_binary(dtype_object, buffer.read_bytes(dtype_object.itemsize), []).extract
+      dtype_object.kind == :bool ? !value.zero? : value
     ensure
       HDF5::FFI.H5Pclose(property_list_id) if property_list_id && property_list_id >= 0
     end
@@ -381,7 +375,7 @@ module HDF5
 
     def append(data, axis: 0)
       ensure_open!
-      values = HDF5::DataHelpers.normalize_data(data, label: 'Dataset data')
+      values = HDF5::DataHelpers.normalize_data(data, label: 'Dataset data', dtype: dtype, convert: false)
       current_shape = shape
       raise HDF5::Error, 'Cannot append to a Null dataset' if current_shape.nil?
       raise HDF5::Error, 'Cannot append to a scalar dataset' if current_shape.empty?
@@ -421,6 +415,16 @@ module HDF5
       ensure_open!
       type_id = HDF5::FFI.H5Dget_type(@dataset_id)
       raise HDF5::Error, 'Failed to get dataset datatype' if type_id < 0
+      current_shape = shape
+      if current_shape.nil?
+        raise HDF5::Error, 'Null datasets cannot be sliced' unless selection.nil?
+
+        current_dtype = dtype ? DType.for_symbol(dtype) : DType.for_hdf5(type_id)
+        unless DType.for_hdf5(type_id).castable_to?(current_dtype, casting:)
+          raise ConversionError, 'Cannot safely cast Null dataset dtype'
+        end
+        return HDF5::Empty.new(current_dtype)
+      end
       if dtype && HDF5::FFI.H5Tget_class(type_id) == :H5T_STRING
         raise ConversionError,
               'dtype is not supported for string datasets'
@@ -432,11 +436,11 @@ module HDF5
       raise ConversionError, "Cannot safely cast #{source_dtype.to_sym} to #{current_dtype.to_sym}" unless
         source_dtype.castable_to?(current_dtype, casting:)
 
-      current_shape = shape
-      return HDF5::Empty.new(current_dtype) if current_shape.nil?
-
       normalized_selection = Selection.normalize(selection, current_shape)
       return current_dtype.numo_class.zeros(*normalized_selection.result_shape) if normalized_selection.size.zero?
+      if current_dtype.kind == :complex && source_dtype.kind != :complex
+        raise ConversionError, 'Reading non-complex data as complex requires an explicit Numo cast'
+      end
 
       file_space_id = HDF5::FFI.H5Dget_space(@dataset_id)
       raise HDF5::Error, 'Failed to get dataset dataspace' if file_space_id < 0
@@ -485,12 +489,17 @@ module HDF5
       ensure_open!
       raise HDF5::Error, 'read_into destination must be a Numo::NArray' unless destination.is_a?(Numo::NArray)
 
-      values = read(selection:, dtype: DType.for_numo(destination).to_sym, casting:)
-      unless destination.shape == values.shape
+      current_shape = shape
+      raise HDF5::Error, 'Cannot read a Null dataset into an array' if current_shape.nil?
+
+      expected_shape = Selection.normalize(selection, current_shape).result_shape
+      unless destination.shape == expected_shape
         raise HDF5::Error,
               'read_into destination shape must match selection shape'
       end
 
+      values = read(selection:, dtype: DType.for_numo(destination).to_sym, casting:)
+      values = values ? 1 : 0 if expected_shape.empty? && destination.is_a?(Numo::Bit)
       destination.store(values)
     end
 
@@ -500,10 +509,13 @@ module HDF5
       ensure_open!
       raise ArgumentError, 'max_bytes must be a positive integer' unless max_bytes.is_a?(Integer) && max_bytes.positive?
 
-      current_dtype = dtype
+      current_shape, current_dtype = HDF5::FFI::CALL_LOCK.synchronize { [shape, dtype] }
+      raise HDF5::Error, 'Cannot iterate over a Null dataset' if current_shape.nil?
+      if current_dtype.kind == :string
+        raise UnsupportedFeatureError, 'each_block cannot bound the byte size of variable-length strings'
+      end
       raise ArgumentError, 'max_bytes is smaller than one dataset element' if max_bytes < current_dtype.itemsize
 
-      current_shape = shape
       if current_shape.empty?
         yield [], read
         return
@@ -521,10 +533,9 @@ module HDF5
 
       ensure_open!
 
-      chunk_shape = chunks
+      current_shape, chunk_shape = HDF5::FFI::CALL_LOCK.synchronize { [shape, chunks] }
       raise HDF5::Error, 'each_chunk requires a chunked dataset' unless chunk_shape
 
-      current_shape = shape
       return if current_shape.any?(&:zero?)
 
       each_block_selection(current_shape, chunk_shape) do |selection|
@@ -534,25 +545,64 @@ module HDF5
 
     private
 
+    def write_numeric_buffer(buffer, dtype_object, normalized_selection)
+      file_space_id = HDF5::FFI.H5Dget_space(@dataset_id)
+      raise HDF5::Error, 'Failed to get dataset dataspace' if file_space_id < 0
+
+      select_hyperslab(file_space_id, normalized_selection)
+      memory_space_id = create_memory_dataspace(normalized_selection.result_shape)
+      raise HDF5::Error, 'Failed to create memory dataspace' if memory_space_id < 0
+      raise HDF5::Error, 'File and memory selections have different sizes' unless
+        HDF5::FFI.H5Sget_select_npoints(file_space_id) == HDF5::FFI.H5Sget_select_npoints(memory_space_id)
+
+      status = HDF5::FFI.H5Dwrite(@dataset_id, dtype_object.memory_type_id, memory_space_id, file_space_id,
+                                 HDF5::DEFAULT_PROPERTY_LIST, buffer)
+      raise HDF5::Error, 'Failed to write dataset' if status < 0
+    ensure
+      HDF5::FFI.H5Sclose(memory_space_id) if memory_space_id && memory_space_id >= 0
+      HDF5::FFI.H5Sclose(file_space_id) if file_space_id && file_space_id >= 0
+    end
+
+    def write_scalar(value, dtype_object, selection)
+      max_elements = [256 * 1024 / dtype_object.itemsize, selection.size].min
+      constant = dtype_object.numo_class.new(max_elements).fill(value.extract)
+      buffer = HDF5::DataHelpers.buffer_for(constant)
+      block_shape = block_shape_for(selection.result_shape, max_elements)
+      each_block_selection(selection.result_shape, block_shape) do |ranges|
+        write_numeric_buffer(buffer, dtype_object, selection.block(ranges))
+      end
+    end
+
     def write_string(data, selection:)
-      normalized_selection = Selection.normalize(selection, shape)
-      values, values_shape = HDF5::StringCodec.normalize_data(data)
+      current_shape = shape
+      raise HDF5::Error, 'Cannot write to a Null dataset' if current_shape.nil?
+
+      normalized_selection = Selection.normalize(selection, current_shape)
+      type_id = HDF5::FFI.H5Dget_type(@dataset_id)
+      raise HDF5::Error, 'Failed to get dataset datatype' if type_id < 0
+      unless HDF5::FFI.H5Tget_class(type_id) == :H5T_STRING
+        raise ConversionError, 'Cannot write strings to a numeric dataset'
+      end
+      encoding = HDF5::StringCodec.encoding_for(type_id)
+      values, values_shape = HDF5::StringCodec.normalize_data(data, encoding:)
       unless values_shape == normalized_selection.result_shape
         raise HDF5::ShapeError,
               'Dataset shape must match string data shape'
       end
       return data if normalized_selection.size.zero?
 
-      type_id = HDF5::FFI.H5Dget_type(@dataset_id)
-      raise HDF5::Error, 'Failed to get dataset datatype' if type_id < 0
       unless HDF5::StringCodec.variable?(type_id)
         raise UnsupportedTypeError, 'Fixed-length string datasets are not yet supported'
       end
 
       file_space_id = HDF5::FFI.H5Dget_space(@dataset_id)
+      raise HDF5::Error, 'Failed to get string dataset dataspace' if file_space_id < 0
+
       select_hyperslab(file_space_id, normalized_selection)
       memory_space_id = create_memory_dataspace(normalized_selection.result_shape)
-      buffer, _string_pointers = HDF5::StringCodec.buffer_for_values(values)
+      raise HDF5::Error, 'Failed to create string memory dataspace' if memory_space_id < 0
+
+      buffer, _string_pointers = HDF5::StringCodec.buffer_for_values(values, encoding:)
       status = HDF5::FFI.H5Dwrite(@dataset_id, type_id, memory_space_id, file_space_id,
                                   HDF5::DEFAULT_PROPERTY_LIST, buffer)
       raise HDF5::Error, 'Failed to write string dataset' if status < 0
@@ -572,25 +622,36 @@ module HDF5
       return Numo::RObject.new(*normalized_selection.result_shape) if normalized_selection.size.zero?
 
       file_space_id = HDF5::FFI.H5Dget_space(@dataset_id)
+      raise HDF5::Error, 'Failed to get string dataset dataspace' if file_space_id < 0
+
       select_hyperslab(file_space_id, normalized_selection)
       memory_space_id = create_memory_dataspace(normalized_selection.result_shape)
+      raise HDF5::Error, 'Failed to create string memory dataspace' if memory_space_id < 0
+
       buffer = ::FFI::MemoryPointer.new(:pointer, normalized_selection.size)
       status = HDF5::FFI.H5Dread(@dataset_id, type_id, memory_space_id, file_space_id,
                                  HDF5::DEFAULT_PROPERTY_LIST, buffer)
       raise HDF5::Error, 'Failed to read string dataset' if status < 0
 
-      HDF5::StringCodec.read_values(buffer, normalized_selection.size, normalized_selection.result_shape)
+      HDF5::StringCodec.read_values(buffer, normalized_selection.size, normalized_selection.result_shape,
+                                    encoding: HDF5::StringCodec.encoding_for(type_id))
     ensure
-      if buffer && type_id && memory_space_id
-        active_error = $ERROR_INFO
-        reclaim_status = HDF5::FFI.H5Dvlen_reclaim(type_id, memory_space_id, HDF5::DEFAULT_PROPERTY_LIST, buffer)
-        if reclaim_status.negative? && active_error.nil?
-          raise HDF5::Error,
-                'Failed to reclaim variable-length string data'
+      begin
+        if buffer && type_id && memory_space_id
+          active_error = $ERROR_INFO
+          reclaim_status = HDF5::FFI.H5Dvlen_reclaim(type_id, memory_space_id, HDF5::DEFAULT_PROPERTY_LIST, buffer)
+          if reclaim_status.negative? && active_error.nil?
+            raise HDF5::Error,
+                  'Failed to reclaim variable-length string data'
+          end
+        end
+      ensure
+        begin
+          HDF5::FFI.H5Sclose(memory_space_id) if memory_space_id && memory_space_id >= 0
+        ensure
+          HDF5::FFI.H5Sclose(file_space_id) if file_space_id && file_space_id >= 0
         end
       end
-      HDF5::FFI.H5Sclose(memory_space_id) if memory_space_id && memory_space_id >= 0
-      HDF5::FFI.H5Sclose(file_space_id) if file_space_id && file_space_id >= 0
     end
 
     def block_shape_for(dataset_shape, max_elements)
@@ -653,7 +714,7 @@ module HDF5
 
     prepend FileContext.guard(
       :attrs, :write, :dtype, :shape, :chunks, :maxshape, :fillvalue, :resize, :append, :read, :read_array,
-      :[], :[]=, :read_into, :each_block, :each_chunk
+      :[], :[]=, :read_into, :close, :closed?
     )
   end
 end