iceberg 0.11.2 → 0.12.1

data/ext/iceberg/src/utils.rs

@@ -1,15 +1,24 @@
+use std::sync::Arc;
+
 use iceberg::spec::{
-    EncryptedKey, Literal, NestedField, PartitionSpec, PartitionStatisticsFile, PrimitiveLiteral,
-    PrimitiveType, Schema, Snapshot, SortOrder, StatisticsFile, Type,
+    EncryptedKey, Literal, MetadataLog, NestedField, NullOrder, PartitionSpec,
+    PartitionStatisticsFile, PrimitiveLiteral, PrimitiveType, Schema, Snapshot, SnapshotLog,
+    SortDirection, SortOrder, StatisticsFile, Transform, Type,
 };
 use iceberg::{NamespaceIdent, TableIdent};
 use magnus::{
-    Error as RbErr, IntoValue, RArray, RClass, RHash, RModule, Ruby, TryConvert, Value, kwargs,
-    prelude::*,
+    Error as RbErr, IntoValue, RClass, RModule, RString, Ruby, TryConvert, Value, prelude::*,
+    value::Lazy,
 };
 
 use crate::RbResult;
-use crate::error::to_rb_err;
+use crate::encryption::RbEncryptedKey;
+use crate::error::{to_rb_err, todo_error};
+use crate::partitioning::RbPartitionSpec;
+use crate::schema::{RbNestedField, RbSchema};
+use crate::snapshot::{RbMetadataLogEntry, RbSnapshot, RbSnapshotLogEntry};
+use crate::sorting::RbSortOrder;
+use crate::statistics::{RbPartitionStatisticsFile, RbStatisticsFile};
 
 pub struct Wrap<T>(pub T);
 
@@ -42,88 +51,80 @@ impl TryConvert for Wrap<TableIdent> {
     }
 }
 
-impl TryConvert for Wrap<Schema> {
+impl TryConvert for Wrap<Transform> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        let ruby = Ruby::get_with(ob);
-        let mut fields = Vec::new();
-        let rb_fields: RArray = ob.funcall("fields", ())?;
-        for rb_field in rb_fields {
-            let rb_field = RHash::try_convert(rb_field)?;
-            let rb_type: Value = rb_field.aref(ruby.to_symbol("type"))?;
-            let field_type = if let Ok(s) = String::try_convert(rb_type) {
-                match s.as_str() {
-                    "boolean" => Type::Primitive(PrimitiveType::Boolean),
-                    "int" => Type::Primitive(PrimitiveType::Int),
-                    "long" => Type::Primitive(PrimitiveType::Long),
-                    "float" => Type::Primitive(PrimitiveType::Float),
-                    "double" => Type::Primitive(PrimitiveType::Double),
-                    // TODO PrimitiveType::Decimal
-                    "date" => Type::Primitive(PrimitiveType::Date),
-                    "time" => Type::Primitive(PrimitiveType::Time),
-                    "timestamp" => Type::Primitive(PrimitiveType::Timestamp),
-                    "timestamptz" => Type::Primitive(PrimitiveType::Timestamptz),
-                    "timestamp_ns" => Type::Primitive(PrimitiveType::TimestampNs),
-                    "timestamptz_ns" => Type::Primitive(PrimitiveType::TimestamptzNs),
-                    "string" => Type::Primitive(PrimitiveType::String),
-                    "uuid" => Type::Primitive(PrimitiveType::Uuid),
-                    // TODO PrimitiveType::Fixed
-                    "binary" => Type::Primitive(PrimitiveType::Binary),
-                    _ => {
-                        return Err(RbErr::new(
-                            ruby.exception_arg_error(),
-                            format!("Type not supported: {}", s),
-                        ));
-                    }
+        let v = if let Ok(s) = RString::try_convert(ob) {
+            match unsafe { s.as_str() }? {
+                "identity" => Transform::Identity,
+                "year" => Transform::Year,
+                "month" => Transform::Month,
+                "day" => Transform::Day,
+                "hour" => Transform::Hour,
+                _ => {
+                    return Err(RbErr::new(
+                        Ruby::get_with(ob).exception_arg_error(),
+                        "Unsupported transform",
+                    ));
                 }
-            } else {
-                let class_name = unsafe { rb_type.classname() }.to_string();
-                match class_name.as_str() {
-                    "Polars::Boolean" => Type::Primitive(PrimitiveType::Boolean),
-                    "Polars::Int32" => Type::Primitive(PrimitiveType::Int),
-                    "Polars::Int64" => Type::Primitive(PrimitiveType::Long),
-                    "Polars::Float32" => Type::Primitive(PrimitiveType::Float),
-                    "Polars::Float64" => Type::Primitive(PrimitiveType::Double),
-                    "Polars::Date" => Type::Primitive(PrimitiveType::Date),
-                    "Polars::Time" => Type::Primitive(PrimitiveType::Time),
-                    "Polars::String" => Type::Primitive(PrimitiveType::String),
-                    "Polars::Binary" => Type::Primitive(PrimitiveType::Binary),
-                    _ => {
-                        return Err(RbErr::new(
-                            ruby.exception_arg_error(),
-                            format!("Type not supported: {}", class_name),
-                        ));
-                    }
+            }
+        } else {
+            match &*unsafe { ob.classname() } {
+                "Iceberg::IdentityTransform" => Transform::Identity,
+                "Iceberg::BucketTransform" => Transform::Bucket(ob.funcall("num_buckets", ())?),
+                "Iceberg::TruncateTransform" => Transform::Truncate(ob.funcall("width", ())?),
+                "Iceberg::YearTransform" => Transform::Year,
+                "Iceberg::MonthTransform" => Transform::Month,
+                "Iceberg::DayTransform" => Transform::Day,
+                "Iceberg::HourTransform" => Transform::Hour,
+                "Iceberg::VoidTransform" => Transform::Void,
+                "Iceberg::UnknownTransform" => Transform::Unknown,
+                _ => {
+                    return Err(RbErr::new(
+                        Ruby::get_with(ob).exception_arg_error(),
+                        format!("Transform not supported: {}", ob),
+                    ));
                 }
-            };
-
-            let initial_default = rb_field.aref(ruby.to_symbol("initial_default"))?;
-            let write_default = rb_field.aref(ruby.to_symbol("write_default"))?;
+            }
+        };
+        Ok(Wrap(v))
+    }
+}
 
-            let initial_default = default_value(initial_default, &field_type)?;
-            let write_default = default_value(write_default, &field_type)?;
+impl TryConvert for Wrap<SortDirection> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let s = RString::try_convert(ob)?;
+        let v = match unsafe { s.as_str() }? {
+            "asc" => SortDirection::Ascending,
+            "desc" => SortDirection::Descending,
+            _ => {
+                return Err(RbErr::new(
+                    Ruby::get_with(ob).exception_arg_error(),
+                    "Unsupported sort direction",
+                ));
+            }
+        };
+        Ok(Wrap(v))
+    }
+}
 
-            fields.push(
-                NestedField {
-                    id: rb_field.aref(ruby.to_symbol("id"))?,
-                    name: rb_field.aref(ruby.to_symbol("name"))?,
-                    required: rb_field.aref(ruby.to_symbol("required"))?,
-                    field_type: field_type.into(),
-                    doc: rb_field.aref(ruby.to_symbol("doc"))?,
-                    initial_default,
-                    write_default,
-                }
-                .into(),
-            );
-        }
-        let schema = Schema::builder()
-            .with_fields(fields)
-            .build()
-            .map_err(to_rb_err)?;
-        Ok(Wrap(schema))
+impl TryConvert for Wrap<NullOrder> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let s = RString::try_convert(ob)?;
+        let v = match unsafe { s.as_str() }? {
+            "first" => NullOrder::First,
+            "last" => NullOrder::Last,
+            _ => {
+                return Err(RbErr::new(
+                    Ruby::get_with(ob).exception_arg_error(),
+                    "Unsupported null order",
+                ));
+            }
+        };
+        Ok(Wrap(v))
     }
 }
 
-fn default_value(ob: Value, field_type: &Type) -> RbResult<Option<Literal>> {
+pub fn default_value(ob: Value, field_type: &Type) -> RbResult<Option<Literal>> {
     if ob.is_nil() {
         return Ok(None);
     }
@@ -136,114 +137,116 @@ fn default_value(ob: Value, field_type: &Type) -> RbResult<Option<Literal>> {
                 PrimitiveType::Long => PrimitiveLiteral::Long(i64::try_convert(ob)?),
                 PrimitiveType::Float => PrimitiveLiteral::Float(f32::try_convert(ob)?.into()),
                 PrimitiveType::Double => PrimitiveLiteral::Double(f64::try_convert(ob)?.into()),
+                PrimitiveType::Decimal {
+                    precision: _,
+                    scale: _,
+                } => return Err(todo_error(field_type)),
+                PrimitiveType::Date => return Err(todo_error(field_type)),
+                PrimitiveType::Time => return Err(todo_error(field_type)),
+                PrimitiveType::Timestamp => return Err(todo_error(field_type)),
+                PrimitiveType::Timestamptz => return Err(todo_error(field_type)),
+                PrimitiveType::TimestampNs => return Err(todo_error(field_type)),
+                PrimitiveType::TimestamptzNs => return Err(todo_error(field_type)),
                 PrimitiveType::String => PrimitiveLiteral::String(String::try_convert(ob)?),
-                _ => todo!(),
+                PrimitiveType::Uuid => return Err(todo_error(field_type)),
+                PrimitiveType::Fixed(_) => return Err(todo_error(field_type)),
+                PrimitiveType::Binary => {
+                    let s = RString::try_convert(ob)?;
+                    PrimitiveLiteral::Binary(unsafe { s.as_slice() }.to_vec())
+                }
             };
             Literal::Primitive(pl)
         }
-        _ => todo!(),
+        Type::Struct(_) => return Err(todo_error(field_type)),
+        Type::List(_) => return Err(todo_error(field_type)),
+        Type::Map(_) => return Err(todo_error(field_type)),
+        Type::Variant(_) => return Err(todo_error(field_type)),
     };
     Ok(Some(lit))
 }
 
-pub fn rb_schema(ruby: &Ruby, schema: &Schema) -> RbResult<Value> {
-    let fields = ruby.ary_new();
-    for f in schema.as_struct().fields() {
-        let field = ruby.hash_new();
-        field.aset(ruby.to_symbol("id"), f.id)?;
-        field.aset(ruby.to_symbol("name"), ruby.str_new(&f.name))?;
-
-        let field_type = match &*f.field_type {
-            Type::Primitive(ty) => match ty {
-                PrimitiveType::Boolean => "boolean",
-                PrimitiveType::Int => "int",
-                PrimitiveType::Long => "long",
-                PrimitiveType::Float => "float",
-                PrimitiveType::Double => "double",
-                PrimitiveType::Decimal {
-                    precision: _,
-                    scale: _,
-                } => todo!(),
-                PrimitiveType::Date => "date",
-                PrimitiveType::Time => "time",
-                PrimitiveType::Timestamp => "timestamp",
-                PrimitiveType::Timestamptz => "timestamptz",
-                PrimitiveType::TimestampNs => "timestamp_ns",
-                PrimitiveType::TimestamptzNs => "timestamptz_ns",
-                PrimitiveType::String => "string",
-                PrimitiveType::Uuid => "uuid",
-                PrimitiveType::Binary => "binary",
-                PrimitiveType::Fixed(_) => todo!(),
-            },
-            _ => todo!(),
-        };
-        field.aset(ruby.to_symbol("type"), field_type)?;
-
-        field.aset(ruby.to_symbol("required"), f.required)?;
-
-        let initial_default = f.initial_default.as_ref().map(|v| rb_literal(ruby, v));
-        field.aset(ruby.to_symbol("initial_default"), initial_default)?;
-
-        let write_default = f.write_default.as_ref().map(|v| rb_literal(ruby, v));
-        field.aset(ruby.to_symbol("write_default"), write_default)?;
+impl From<&Arc<Schema>> for RbSchema {
+    fn from(schema: &Arc<Schema>) -> Self {
+        Self {
+            schema: (**schema).clone(),
+        }
+    }
+}
 
-        field.aset(
-            ruby.to_symbol("doc"),
-            f.doc.as_ref().map(|v| ruby.str_new(v)),
-        )?;
+impl From<&Arc<NestedField>> for RbNestedField {
+    fn from(field: &Arc<NestedField>) -> Self {
+        Self {
+            field: field.clone(),
+        }
+    }
+}
 
-        fields.push(field)?;
+impl From<&Arc<Snapshot>> for RbSnapshot {
+    fn from(snapshot: &Arc<Snapshot>) -> Self {
+        Self {
+            snapshot: (**snapshot).clone(),
+        }
     }
-    let schema_id = schema.schema_id();
+}
 
-    ruby.class_object()
-        .const_get::<_, RModule>("Iceberg")
-        .unwrap()
-        .const_get::<_, RClass>("Schema")
-        .unwrap()
-        .funcall("new", (fields, kwargs!("schema_id" => schema_id)))
+impl From<&SnapshotLog> for RbSnapshotLogEntry {
+    fn from(snapshot_log: &SnapshotLog) -> Self {
+        Self {
+            log: snapshot_log.clone(),
+        }
+    }
 }
 
-pub fn rb_snapshot(ruby: &Ruby, snapshot: &Snapshot) -> RbResult<Value> {
-    let rb_snapshot = ruby.hash_new();
-    rb_snapshot.aset(ruby.to_symbol("snapshot_id"), snapshot.snapshot_id())?;
-    rb_snapshot.aset(
-        ruby.to_symbol("parent_snapshot_id"),
-        snapshot.parent_snapshot_id(),
-    )?;
-    rb_snapshot.aset(
-        ruby.to_symbol("sequence_number"),
-        snapshot.sequence_number(),
-    )?;
-    rb_snapshot.aset(ruby.to_symbol("manifest_list"), snapshot.manifest_list())?;
-    rb_snapshot.aset(ruby.to_symbol("schema_id"), snapshot.schema_id())?;
-    Ok(rb_snapshot.as_value())
+impl From<&MetadataLog> for RbMetadataLogEntry {
+    fn from(metadata_log: &MetadataLog) -> Self {
+        Self {
+            log: metadata_log.clone(),
+        }
+    }
 }
 
-pub fn rb_partition_spec(_partition_spec: &PartitionSpec) -> RbResult<Value> {
-    todo!();
+impl From<&Arc<PartitionSpec>> for RbPartitionSpec {
+    fn from(partition_spec: &Arc<PartitionSpec>) -> Self {
+        Self {
+            spec: (**partition_spec).clone().into(),
+        }
+    }
 }
 
-pub fn rb_sort_order(_sort_order: &SortOrder) -> RbResult<Value> {
-    todo!();
+impl From<&Arc<SortOrder>> for RbSortOrder {
+    fn from(sort_order: &Arc<SortOrder>) -> Self {
+        Self {
+            order: (**sort_order).clone(),
+        }
+    }
 }
 
-pub fn rb_statistics_file(_statistics_file: &StatisticsFile) -> RbResult<Value> {
-    todo!();
+impl From<&StatisticsFile> for RbStatisticsFile {
+    fn from(statistics_file: &StatisticsFile) -> Self {
+        Self {
+            file: statistics_file.clone(),
+        }
+    }
 }
 
-pub fn rb_partition_statistics_file(
-    _partition_statistics_file: &PartitionStatisticsFile,
-) -> RbResult<Value> {
-    todo!();
+impl From<&PartitionStatisticsFile> for RbPartitionStatisticsFile {
+    fn from(partition_statistics_file: &PartitionStatisticsFile) -> Self {
+        Self {
+            file: partition_statistics_file.clone(),
+        }
+    }
 }
 
-pub fn rb_encrypted_key(_encrypted_key: &EncryptedKey) -> RbResult<Value> {
-    todo!();
+impl From<&EncryptedKey> for RbEncryptedKey {
+    fn from(encrypted_key: &EncryptedKey) -> Self {
+        Self {
+            key: encrypted_key.clone(),
+        }
+    }
 }
 
-pub fn rb_literal(ruby: &Ruby, literal: &Literal) -> Value {
-    match literal {
+pub fn rb_literal(ruby: &Ruby, literal: &Literal) -> RbResult<Value> {
+    let v = match literal {
         Literal::Primitive(pl) => match pl {
             PrimitiveLiteral::Boolean(v) => v.into_value_with(ruby),
             PrimitiveLiteral::Int(v) => v.into_value_with(ruby),
@@ -252,8 +255,64 @@ pub fn rb_literal(ruby: &Ruby, literal: &Literal) -> Value {
             PrimitiveLiteral::Double(v) => v.into_value_with(ruby),
             PrimitiveLiteral::String(v) => ruby.str_new(v).as_value(),
             PrimitiveLiteral::Binary(v) => ruby.str_from_slice(v).as_value(),
-            _ => todo!(),
+            PrimitiveLiteral::Int128(v) => v.into_value_with(ruby),
+            PrimitiveLiteral::UInt128(v) => v.into_value_with(ruby),
+            PrimitiveLiteral::AboveMax => return Err(todo_error(literal)),
+            PrimitiveLiteral::BelowMin => return Err(todo_error(literal)),
         },
-        _ => todo!(),
-    }
+        Literal::Struct(_) => return Err(todo_error(literal)),
+        Literal::List(_) => return Err(todo_error(literal)),
+        Literal::Map(_) => return Err(todo_error(literal)),
+    };
+    Ok(v)
+}
+
+pub fn rb_transform(transform: &Transform) -> RbResult<Value> {
+    let ruby = Ruby::get().unwrap();
+    let iceberg = ruby.class_object().const_get::<_, RModule>("Iceberg")?;
+    let v = match transform {
+        Transform::Identity => iceberg
+            .const_get::<_, RClass>("IdentityTransform")?
+            .new_instance(())?,
+        Transform::Bucket(num_buckets) => iceberg
+            .const_get::<_, RClass>("BucketTransform")?
+            .new_instance((*num_buckets,))?,
+        Transform::Truncate(width) => iceberg
+            .const_get::<_, RClass>("TruncateTransform")?
+            .new_instance((*width,))?,
+        Transform::Year => iceberg
+            .const_get::<_, RClass>("YearTransform")?
+            .new_instance(())?,
+        Transform::Month => iceberg
+            .const_get::<_, RClass>("MonthTransform")?
+            .new_instance(())?,
+        Transform::Day => iceberg
+            .const_get::<_, RClass>("DayTransform")?
+            .new_instance(())?,
+        Transform::Hour => iceberg
+            .const_get::<_, RClass>("HourTransform")?
+            .new_instance(())?,
+        Transform::Void => iceberg
+            .const_get::<_, RClass>("VoidTransform")?
+            .new_instance(())?,
+        Transform::Unknown => iceberg
+            .const_get::<_, RClass>("UnknownTransform")?
+            .new_instance(())?,
+    };
+    Ok(v)
+}
+
+pub static EPOCH: Lazy<Value> = Lazy::new(|ruby| {
+    ruby.class_object()
+        .const_get::<_, RClass>("Date")
+        .unwrap()
+        .new_instance((1970, 1, 1))
+        .unwrap()
+});
+
+pub fn date_to_i32(value: Value) -> RbResult<i32> {
+    let epoch = Ruby::get_with(value).get_inner(&EPOCH);
+    value
+        .funcall::<_, _, Value>("-", (epoch,))?
+        .funcall("to_i", ())
 }

data/lib/iceberg/catalog.rb

@@ -1,14 +1,18 @@
 module Iceberg
   class Catalog
+    def _initialize(catalog, default_namespace:)
+      @catalog = catalog
+      @default_namespace = default_namespace
+    end
+
     def list_namespaces(parent = nil)
       @catalog.list_namespaces(parent)
     end
 
     def create_namespace(namespace, properties: {}, if_not_exists: nil)
       @catalog.create_namespace(namespace, properties)
-    rescue Error => e
-      # ideally all catalogs would use NamespaceAlreadyExistsError
-      if !if_not_exists || (e.message != "Cannot create namespace" && !e.message.include?("already exists"))
+    rescue NamespaceAlreadyExistsError => e
+      if !if_not_exists
         raise e
       end
       nil
@@ -28,19 +32,18 @@ module Iceberg
 
     def drop_namespace(namespace, if_exists: nil)
       @catalog.drop_namespace(namespace)
-    rescue Error => e
-      # ideally all catalogs would use NamespaceNotFoundError
-      if !if_exists || (e.message != "Tried to drop a namespace that does not exist" && !e.message.include?("No such namespace") && !e.message.include?("The specified namespace does not exist") && !e.message.include?("not found"))
+    rescue NoSuchNamespaceError => e
+      if !if_exists
         raise e
       end
       nil
     end
 
-    def list_tables(namespace)
-      @catalog.list_tables(namespace)
+    def list_tables(namespace = nil)
+      @catalog.list_tables(namespace || @default_namespace)
     end
 
-    def create_table(table_name, schema: nil, location: nil)
+    def create_table(table_name, schema: nil, location: nil, partition_spec: nil, sort_order: nil, properties: {})
       if !schema.nil? && block_given?
         raise ArgumentError, "Must pass schema or block"
       end
@@ -48,63 +51,84 @@ module Iceberg
       if block_given?
         table_definition = TableDefinition.new
         yield table_definition
-        schema = Schema.new(table_definition.fields)
-      elsif schema.is_a?(Hash) || (defined?(Polars::Schema) && schema.is_a?(Polars::Schema))
-        fields =
-          schema.to_h.map.with_index do |(k, v), i|
-            {
-              id: i + 1,
-              name: k.is_a?(Symbol) ? k.to_s : k,
-              type: v,
-              required: false
-            }
-          end
-        schema = Schema.new(fields)
+        schema = Schema.new(*table_definition.fields)
+      elsif schema.is_a?(Schema)
+        # do nothing
+      elsif schema.respond_to?(:arrow_c_schema)
+        schema = Schema.new(schema)
+      elsif schema.is_a?(Hash)
+        table_definition = TableDefinition.new
+        schema.each do |k, v|
+          table_definition.column(k, v)
+        end
+        schema = Schema.new(*table_definition.fields)
       elsif schema.nil?
-        schema = Schema.new([])
+        schema = Schema.new
       end
 
-      Table.new(@catalog.create_table(table_name, schema, location), @catalog)
+      format_version = (properties["format-version"] || 2).to_i
+      if properties["format-version"] && (is_a?(MemoryCatalog) || is_a?(SqlCatalog))
+        properties = properties.except("format-version")
+      end
+
+      Table.new(@catalog.create_table(with_namespace(table_name), schema, location, partition_spec, sort_order, properties, format_version), @catalog)
     end
 
     def load_table(table_name)
-      Table.new(@catalog.load_table(table_name), @catalog)
+      Table.new(@catalog.load_table(with_namespace(table_name)), @catalog)
     end
 
     def drop_table(table_name, if_exists: nil)
-      @catalog.drop_table(table_name)
-    rescue Error => e
-      # ideally all catalogs would use TableNotFoundError
-      if !if_exists || (e.message != "Tried to drop a table that does not exist" && !e.message.include?("No such table") && !e.message.include?("The specified table does not exist") && !e.message.include?("not found"))
+      @catalog.drop_table(with_namespace(table_name))
+    rescue NoSuchTableError => e
+      if !if_exists
         raise e
       end
       nil
     end
 
+    def purge_table(table_name)
+      @catalog.purge_table(with_namespace(table_name))
+    end
+
     def table_exists?(table_name)
-      @catalog.table_exists?(table_name)
-    rescue NamespaceNotFoundError
+      @catalog.table_exists?(with_namespace(table_name))
+    rescue NoSuchNamespaceError
       false
     end
 
     def rename_table(table_name, new_name)
-      @catalog.rename_table(table_name, new_name)
+      @catalog.rename_table(with_namespace(table_name), with_namespace(new_name))
     end
 
     def register_table(table_name, metadata_location)
-      @catalog.register_table(table_name, metadata_location)
+      @catalog.register_table(with_namespace(table_name), metadata_location)
     end
 
-    def sql(sql)
+    def sql(sql, params = [])
       # requires datafusion feature
-      raise Todo unless @catalog.respond_to?(:sql)
+      raise Todo unless @catalog.respond_to?(:session_context)
 
-      @catalog.sql(sql)
+      session_context.sql(sql, params)
     end
 
     # hide internal state
     def inspect
       to_s
     end
+
+    private
+
+    def with_namespace(table_name)
+      if @default_namespace && table_name.is_a?(String) && !table_name.include?(".")
+        [@default_namespace, table_name]
+      else
+        table_name
+      end
+    end
+
+    def session_context
+      @session_context ||= @catalog.session_context(@default_namespace)
+    end
   end
 end

data/lib/iceberg/glue_catalog.rb

@@ -1,8 +1,11 @@
 module Iceberg
   class GlueCatalog < Catalog
     # warehouse is URI of S3 storage bucket
-    def initialize(warehouse:)
-      @catalog = RbCatalog.new_glue(warehouse)
+    def initialize(warehouse:, default_namespace: nil)
+      _initialize(
+        RbCatalog.new_glue(warehouse),
+        default_namespace:
+      )
     end
   end
 end

data/lib/iceberg/memory_catalog.rb

@@ -1,8 +1,11 @@
 module Iceberg
   class MemoryCatalog < Catalog
     # warehouse is default storage location
-    def initialize(warehouse: nil)
-      @catalog = RbCatalog.new_memory(warehouse)
+    def initialize(warehouse: nil, default_namespace: nil)
+      _initialize(
+        RbCatalog.new_memory(warehouse),
+        default_namespace:
+      )
     end
   end
 end

data/lib/iceberg/rest_catalog.rb

@@ -1,8 +1,11 @@
 module Iceberg
   class RestCatalog < Catalog
     # warehouse is passed to REST server
-    def initialize(uri:, warehouse: nil, properties: {})
-      @catalog = RbCatalog.new_rest(uri, warehouse, properties)
+    def initialize(uri:, warehouse: nil, properties: {}, default_namespace: nil)
+      _initialize(
+        RbCatalog.new_rest(uri, warehouse, properties),
+        default_namespace:
+      )
     end
   end
 end