Rename stage #6

Author: rampage644

bin/bucketd/Cargo.toml

@@ -7,7 +7,7 @@ license-file = { workspace = true }
 [dependencies]
 clap = { version = "4.5.27", features = ["env", "derive"] }
 dotenv = { version = "0.15.0" }
-icebucket_runtime = { path = "../../crates/runtime" }
+embucket_runtime = { path = "../../crates/runtime" }
 object_store = { workspace = true }
 snmalloc-rs = { workspace = true }
 tokio = { workspace = true }

bin/bucketd/src/main.rs

@@ -19,7 +19,7 @@ pub(crate) mod cli;
 
 use clap::Parser;
 use dotenv::dotenv;
-use icebucket_runtime::{
+use embucket_runtime::{
     config::{DbConfig, RuntimeConfig},
     http::config::WebConfig,
     run_binary,
@@ -36,9 +36,8 @@ async fn main() {
 
     tracing_subscriber::registry()
         .with(
-            tracing_subscriber::EnvFilter::try_from_default_env().unwrap_or_else(|_| {
-                "bucketd=debug,icebucket_runtime=debug,tower_http=debug".into()
-            }),
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| "bucketd=debug,embucket_runtime=debug,tower_http=debug".into()),
         )
         .with(tracing_subscriber::fmt::layer())
         .init();

crates/metastore/src/models/table.rs

@@ -99,27 +99,6 @@ impl From<String> for TableFormat {
     }
 }
 
-/*#[derive(Validate, Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
-pub struct IceBucketSimpleSchema {
-    pub fields: Vec<NestedFieldRef>,
-    pub schema_id: Option<i32>,
-}
-
-impl TryFrom<IceBucketSimpleSchema> for Schema {
-    type Error = MetastoreError;
-    fn try_from(schema: IceBucketSimpleSchema) -> MetastoreResult<Self> {
-        let mut builder = Self::builder();
-        builder = builder.with_fields(schema.fields);
-        if let Some(schema_id) = schema.schema_id {
-            builder = builder.with_schema_id(schema_id);
-        }
-        builder.build()
-            .context(metastore_error::IcebergSnafu)
-    }
-}
-
-type SimpleOrIcebergSchema = Either<IceBucketSimpleSchema, Schema>;*/
-
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
 pub struct Table {
     pub ident: TableIdent,
@@ -132,41 +111,6 @@ pub struct Table {
     pub format: TableFormat,
 }
 
-/*impl PartialSchema for IceBucketTable {
-    fn schema() -> openapi::RefOr<openapi::schema::Schema> {
-
-        let table_metadata_schema = openapi::ObjectBuilder::new()
-            .property("format_version", openapi::ObjectBuilder::new()
-                .schema_type(openapi::Type::Integer)
-                .format(Some(openapi::SchemaFormat::KnownFormat(openapi::KnownFormat::Int32)))
-                .build()
-            )
-            .property(
-                "table_uuid",
-                openapi::Object::with_type(openapi::Type::String))
-            .property("name", openapi::schema::String::default())
-            .property("schema_id", openapi::schema::Integer::default())
-            .property("current_schema_id", openapi::schema::Integer::default())
-            .property("default_partition_spec_id", openapi::schema::Integer::default())
-            .property("default_sort_order_id", openapi::schema::Integer::default())
-            .property("last_partition_id", openapi::schema::Integer::default())
-            .property("last_column_id", openapi::schema::Integer::default())
-            .property("refs", openapi::schema::Object::default())
-            .property("properties", utoipa_schema::Map::default())
-            .property("schema", openapi::schema::Object::default())
-            .property("partition_spec", openapi::schema::Object::default())
-            .property("sort_order", openapi::schema::Object::default())
-            .build();
-        openapi::ObjectBuilder::default()
-            .property("ident", IceBucketTableIdent::schema())
-            .property("metadata", table_metadata_schema)
-            .property("metadata_location", openapi::schema::String::default())
-            .property("properties", utoipa_schema::Map::default())
-            .build()
-    }
-}
-impl ToSchema for IceBucketTable {}*/
-
 #[derive(Validate, Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
 pub struct TableCreateRequest {
     #[validate(nested)]
@@ -184,74 +128,6 @@ pub struct TableCreateRequest {
     pub is_temporary: Option<bool>,
 }
 
-/*fn type_schema() -> (String, openapi::RefOr<openapi::schema::Schema>) {
-    let primitive_type = openapi::OneOfBuilder::new()
-        .item(openapi::ObjectBuilder::new()
-            .schema_type(openapi::schema::SchemaType::new(openapi::schema::Type::String))
-            .enum_values(Some(vec!["boolean", "int", "long", "float", "double", "date", "time", "timestamp", "timestamptz", "string", "uuid", "binary"]))
-        )
-        .item(openapi::ObjectBuilder::new()
-            .schema_type(openapi::schema::SchemaType::new(openapi::schema::Type::Object))
-            .property("precision", openapi::ObjectBuilder::new()
-            .schema_type(openapi::schema::SchemaType::new(openapi::schema::Type::Integer))
-            .build())
-            .property("scale", openapi::schema::Type::Integer)
-        )
-        .item(openapi::ObjectBuilder::new()
-            .schema_type(openapi::schema::SchemaType::new(openapi::schema::Type::Integer)))
-        .build();
-    let struct_type = openapi::RefOr::Ref(openapi::Ref::builder().ref_location_from_schema_name("StructType".to_string()).build());
-    let list_type = openapi::ObjectBuilder::new()
-        .property("element_id", openapi::ObjectBuilder::new()
-            .schema_type(openapi::schema::SchemaType::new(openapi::schema::Type::Integer))
-            .build()
-        )
-        .property("element_required", openapi::ObjectBuilder::new()
-            .schema_type(openapi::schema::SchemaType::new(openapi::schema::Type::Boolean))
-            .build()
-        )
-        .property("element", openapi::RefOr::Ref(openapi::Ref::builder().ref_location_from_schema_name("Type".to_string()).build()))
-        .build();
-    let map_type = openapi::ObjectBuilder::new()
-        .property("key_id", openapi::ObjectBuilder::new()
-            .schema_type(openapi::schema::SchemaType::new(openapi::schema::Type::Integer))
-            .build()
-        )
-        .property("key", openapi::RefOr::Ref(openapi::Ref::builder().ref_location_from_schema_name("Type".to_string()).build()))
-        .property("value_id", openapi::ObjectBuilder::new()
-            .schema_type(openapi::schema::SchemaType::new(openapi::schema::Type::Integer))
-            .build()
-        )
-        .property("value", openapi::RefOr::Ref(openapi::Ref::builder().ref_location_from_schema_name("Type".to_string()).build()))
-        .property("value_required", openapi::ObjectBuilder::new()
-            .schema_type(openapi::schema::SchemaType::new(openapi::schema::Type::Boolean))
-            .build()
-        )
-        .build();
-    let one_of = openapi::OneOf::builder()
-        .item(primitive_type.into())
-        .item(struct_type)
-        .item(list_type)
-        .item(map_type);
-    ("Type".to_string(), one_of.into())
-}
-
-impl ToSchema for IceBucketTableCreateRequest {}
-impl PartialSchema for IceBucketTableCreateRequest {
-    fn schema() -> utoipa::openapi::RefOr<utoipa::openapi::schema::Schema> {
-
-        let
-        let mut type_schema = openapi::OneOfBuilder::new()
-            .item(primitive_type)
-
-
-        let mut struct_field_type = openapi::OneOfBuilder::new()
-            .item(primitive_type)
-        let struct_field = openapi::ObjectBuilder::new()
-            .property("id", )
-    }
-}*/
-
 #[derive(ToSchema, Deserialize, Serialize)]
 enum MyPrimitive {
     Int,
@@ -294,33 +170,6 @@ struct MySchema {
     #[serde(flatten)]
     fields: MyStruct,
 }
-/*impl TryFrom<IceBucketTableCreateRequest> for iceberg::TableCreation {
-    type Error = MetastoreError;
-
-    fn try_from(schema: IceBucketTableCreateRequest) -> MetastoreResult<Self> {
-        let mut properties = schema.properties.unwrap_or_default();
-        let utc_now = Utc::now();
-        let utc_now_str = utc_now.to_rfc3339();
-        properties.insert("created_at".to_string(), utc_now_str.clone());
-        properties.insert("updated_at".to_string(), utc_now_str);
-
-        let table_schema = match schema.schema {
-            Either::Left(simple_schema) => {
-                Schema::try_from(simple_schema)?
-            }
-            Either::Right(schema) => schema,
-        };
-
-        Ok(Self {
-            name: schema.ident.table,
-            location: schema.location,
-            schema: table_schema,
-            partition_spec: schema.partition_spec.map(std::convert::Into::into),
-            sort_order: schema.write_order,
-            properties,
-        })
-    }
-}*/
 
 #[derive(Clone, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
 pub struct Config {

crates/runtime/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "icebucket_runtime"
+name = "embucket_runtime"
 version = "0.1.0"
 edition = "2021"
 license-file = { workspace = true }

crates/runtime/src/execution/catalogs/catalog.rs

@@ -23,30 +23,30 @@ use datafusion::catalog::{CatalogProvider, SchemaProvider};
 use embucket_metastore::Metastore;
 use iceberg_rust::catalog::Catalog as IcebergCatalog;
 
-pub struct IceBucketDFCatalog {
+pub struct DFCatalog {
     pub ident: String,
     pub metastore: Arc<dyn Metastore>,
     pub mirror: Arc<CatalogProviderCache>,
     pub iceberg_catalog: Arc<dyn IcebergCatalog>,
 }
 
-impl IceBucketDFCatalog {
+impl DFCatalog {
     #[must_use]
     pub fn catalog(&self) -> Arc<dyn IcebergCatalog> {
         self.iceberg_catalog.clone()
     }
 }
 
 #[allow(clippy::missing_fields_in_debug)]
-impl std::fmt::Debug for IceBucketDFCatalog {
+impl std::fmt::Debug for DFCatalog {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("IceBucketDFCatalog")
+        f.debug_struct("DFCatalog")
             .field("ident", &self.ident)
             .finish()
     }
 }
 
-impl CatalogProvider for IceBucketDFCatalog {
+impl CatalogProvider for DFCatalog {
     fn as_any(&self) -> &dyn Any {
         self
     }

crates/runtime/src/execution/catalogs/iceberg_catalog.rs

@@ -50,13 +50,13 @@ use object_store::ObjectStore;
 use snafu::ResultExt;
 
 #[derive(Debug)]
-pub struct IceBucketIcebergBridge {
+pub struct IcebergBridge {
     pub metastore: Arc<dyn Metastore>,
     pub database: String,
     pub object_store: Arc<dyn ObjectStore>,
 }
 
-impl IceBucketIcebergBridge {
+impl IcebergBridge {
     pub fn new(metastore: Arc<dyn Metastore>, database: String) -> MetastoreResult<Self> {
         let db = block_on(metastore.get_database(&database))?.ok_or(
             MetastoreError::DatabaseNotFound {
@@ -86,7 +86,7 @@ impl IceBucketIcebergBridge {
 }
 
 #[async_trait]
-impl IcebergCatalog for IceBucketIcebergBridge {
+impl IcebergCatalog for IcebergBridge {
     /// Name of the catalog
     fn name(&self) -> &str {
         &self.database

crates/runtime/src/execution/catalogs/metastore.rs

@@ -21,8 +21,8 @@ use std::{
     sync::Arc,
 };
 
-use crate::execution::catalogs::catalog::IceBucketDFCatalog;
-use crate::execution::catalogs::iceberg_catalog::IceBucketIcebergBridge;
+use crate::execution::catalogs::catalog::DFCatalog;
+use crate::execution::catalogs::iceberg_catalog::IcebergBridge;
 use crate::execution::error::{self as ex_error, ExecutionResult};
 use dashmap::DashMap;
 use datafusion::{
@@ -50,14 +50,14 @@ pub type SchemaProviderCache = DashMap<String, TableProviderCache>;
 pub type CatalogProviderCache = DashMap<String, SchemaProviderCache>;
 
 #[derive(Clone)]
-pub struct IceBucketDFMetastore {
+pub struct DFMetastore {
     pub metastore: Arc<dyn Metastore>,
     pub mirror: Arc<CatalogProviderCache>,
     pub table_object_store: Arc<DashMap<String, Arc<dyn ObjectStore>>>,
     pub catalogs: DashMap<String, Arc<dyn CatalogProvider>>,
 }
 
-impl IceBucketDFMetastore {
+impl DFMetastore {
     pub fn new(metastore: Arc<dyn Metastore>) -> Self {
         let table_object_store: DashMap<String, Arc<dyn ObjectStore>> = DashMap::new();
         table_object_store.insert("file://".to_string(), Arc::new(LocalFileSystem::new()));
@@ -146,7 +146,7 @@ impl IceBucketDFMetastore {
                             ) as Arc<dyn TableProvider>
                         }
                         embucket_metastore::TableFormat::Iceberg => {
-                            let bridge = Arc::new(IceBucketIcebergBridge {
+                            let bridge = Arc::new(IcebergBridge {
                                 metastore: self.metastore.clone(),
                                 database: table.ident.clone().database,
                                 object_store: table_object_store.clone(),
@@ -198,9 +198,9 @@ impl IceBucketDFMetastore {
     }
 }
 
-impl std::fmt::Debug for IceBucketDFMetastore {
+impl std::fmt::Debug for DFMetastore {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("IceBucketDFMetastore").finish()
+        f.debug_struct("DFMetastore").finish()
     }
 }
 
@@ -215,7 +215,7 @@ fn get_url_key(url: &Url) -> String {
     )
 }
 
-impl ObjectStoreRegistry for IceBucketDFMetastore {
+impl ObjectStoreRegistry for DFMetastore {
     fn register_store(
         &self,
         url: &Url,
@@ -238,7 +238,7 @@ impl ObjectStoreRegistry for IceBucketDFMetastore {
 }
 
 // Explore using AsyncCatalogProviderList alongside CatalogProviderList
-impl CatalogProviderList for IceBucketDFMetastore {
+impl CatalogProviderList for DFMetastore {
     fn as_any(&self) -> &dyn Any {
         self
     }
@@ -268,10 +268,10 @@ impl CatalogProviderList for IceBucketDFMetastore {
         if !self.mirror.contains_key(name) {
             return None;
         }
-        let iceberg_catalog = IceBucketIcebergBridge::new(self.metastore.clone(), name.to_string())
+        let iceberg_catalog = IcebergBridge::new(self.metastore.clone(), name.to_string())
             .ok()
             .map(Arc::new)?;
-        let catalog: Arc<dyn CatalogProvider> = Arc::new(IceBucketDFCatalog {
+        let catalog: Arc<dyn CatalogProvider> = Arc::new(DFCatalog {
             ident: name.to_string(),
             metastore: self.metastore.clone(),
             mirror: self.mirror.clone(),

crates/runtime/src/execution/datafusion/error.rs

@@ -21,7 +21,7 @@ use snafu::prelude::*;
 
 #[derive(Snafu, Debug)]
 #[snafu(visibility(pub(crate)))]
-pub enum IceBucketSQLError {
+pub enum SQLError {
     #[snafu(display("Arrow error: {source}"))]
     Arrow { source: arrow::error::ArrowError },
 
@@ -64,4 +64,4 @@ pub enum IceBucketSQLError {
     NotImplemented { message: String },
 }
 
-pub type IceBucketSQLResult<T> = std::result::Result<T, IceBucketSQLError>;
+pub type SQLResult<T> = std::result::Result<T, SQLError>;

crates/runtime/src/execution/datafusion/mod.rs

@@ -18,5 +18,6 @@
 //pub mod analyzer;
 //pub mod error;
 pub mod context_provider;
+pub mod error;
 pub mod functions;
 pub mod type_planner;

crates/runtime/src/execution/datafusion/type_planner.rs

@@ -24,9 +24,9 @@ use datafusion::sql::utils::make_decimal_type;
 use datafusion_common::{not_impl_err, DataFusionError};
 
 #[derive(Debug)]
-pub struct IceBucketTypePlanner {}
+pub struct CustomTypePlanner {}
 
-impl TypePlanner for IceBucketTypePlanner {
+impl TypePlanner for CustomTypePlanner {
     fn plan_type(&self, sql_type: &ast::DataType) -> Result<Option<DataType>> {
         match sql_type {
             SQLDataType::Int32 => Ok(Some(DataType::Int32)),