1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
//! Create table transaction types and entry point (internal API).
//!
//! This module defines the [`CreateTableTransaction`] type alias and the [`create_table`]
//! entry point function. The builder logic lives in
//! [`builder::create_table`](super::builder::create_table).
//!
//! # Example
//!
//! ```rust,no_run
//! use delta_kernel::transaction::create_table::create_table;
//! use delta_kernel::schema::{StructType, StructField, DataType};
//! use delta_kernel::committer::FileSystemCommitter;
//! use std::sync::Arc;
//! # use delta_kernel::Engine;
//! # fn example(engine: &dyn Engine) -> delta_kernel::KernelResult<()> {
//!
//! let schema = Arc::new(StructType::try_new(vec![
//! StructField::nullable("id", DataType::INTEGER),
//! ])?);
//!
//! let result = create_table("/path/to/table", schema, "MyApp/1.0", /* data_change */ true)
//! .with_table_properties([("myapp.version", "1.0")])
//! .build(engine, Box::new(FileSystemCommitter::new()))?
//! .commit(engine)?;
//! # Ok(())
//! # }
//! ```
// Allow `pub` items in this module even though the module itself may be `pub(crate)`.
// The module visibility controls external access; items are `pub` for use within the crate
// and for tests. Also allow dead_code since these are used by integration tests.
// Re-export the builder so callers can still access it from this module path.
pub use CreateTableTransactionBuilder;
use crateSchemaRef;
use crate;
/// A type alias for create-table transactions.
///
/// This provides a restricted API surface that only exposes operations valid during table
/// creation. Operations like removing files, removing domain metadata, and updating deletion
/// vectors are not available at compile time.
///
/// Create-table transactions always record `"CREATE TABLE"` as their operation.
/// Create-table builders do not support blind append.
///
/// # Operations NOT available on create-table transactions
///
/// - **`with_domain_metadata_removed()`** — Cannot remove domain metadata from a table that doesn't
/// exist yet.
/// - **`remove_files()`** — Cannot remove files from a table that has no files.
/// - **`update_deletion_vectors()`** — Deletion vectors require an existing table.
///
/// # Example
///
/// ```rust,no_run
/// use delta_kernel::transaction::create_table::create_table;
/// use delta_kernel::schema::{StructType, StructField, DataType};
/// use delta_kernel::committer::FileSystemCommitter;
/// use std::sync::Arc;
/// # use delta_kernel::Engine;
/// # fn example(engine: &dyn Engine) -> delta_kernel::KernelResult<()> {
///
/// let schema = Arc::new(StructType::try_new(vec![
/// StructField::nullable("id", DataType::INTEGER),
/// ])?);
///
/// let result = create_table("/path/to/table", schema, "MyApp/1.0", /* data_change */ true)
/// .build(engine, Box::new(FileSystemCommitter::new()))?
/// .commit(engine)?;
/// # Ok(())
/// # }
/// ```
pub type CreateTableTransaction = ;
/// Creates a builder for creating a new Delta table.
///
/// This function returns a [`CreateTableTransactionBuilder`] that can be configured with table
/// properties and other options before building a [`CreateTableTransaction`].
///
/// # Arguments
///
/// * `path` - The file system path where the Delta table will be created
/// * `schema` - The schema for the new table
/// * `engine_info` - Information about the engine creating the table (e.g., "MyApp/1.0")
/// * `data_change` - Whether added files change logical data. Use `true` when inserting initial
/// rows, such as `CREATE TABLE AS SELECT`, and `false` for schema-only creation with no staged
/// files. The value cannot be changed later and is preserved even when no files are staged, so an
/// empty creation may also use `true`.
///
/// Engine info is required at construction:
///
/// ```compile_fail,E0061
/// # use delta_kernel::schema::SchemaRef;
/// # use delta_kernel::transaction::create_table::create_table;
/// fn configure(schema: SchemaRef) {
/// let _ = create_table("/path/to/table", schema);
/// }
/// ```
///
/// Data-change intent is also required:
///
/// ```compile_fail,E0061
/// # use delta_kernel::schema::SchemaRef;
/// # use delta_kernel::transaction::create_table::create_table;
/// fn configure(schema: SchemaRef) {
/// let _ = create_table("/path/to/table", schema, "my-app/1.0");
/// }
/// ```
///
/// ```compile_fail,E0599
/// # use delta_kernel::transaction::create_table::CreateTableTransactionBuilder;
/// fn configure(builder: CreateTableTransactionBuilder) {
/// let _ = builder.with_data_change(true);
/// }
/// ```
///
/// # Example
///
/// ```no_run
/// use std::sync::Arc;
/// use delta_kernel::transaction::create_table::create_table;
/// use delta_kernel::schema::{DataType, StructField, StructType};
/// use delta_kernel::committer::FileSystemCommitter;
/// use test_utils::delta_kernel_default_engine::DefaultEngineBuilder;
/// use test_utils::delta_kernel_default_engine::storage::store_from_url;
///
/// # fn main() -> delta_kernel::KernelResult<()> {
/// let schema = Arc::new(StructType::try_new([
/// StructField::nullable("id", DataType::INTEGER),
/// StructField::nullable("name", DataType::STRING),
/// ])?);
///
/// let url = url::Url::parse("file:///tmp/my_table")?;
/// let engine = DefaultEngineBuilder::new(store_from_url(&url)?).build();
///
/// let transaction = create_table("/tmp/my_table", schema, "MyApp/1.0", /* data_change */ true)
/// .build(&engine, Box::new(FileSystemCommitter::new()))?;
///
/// // Commit the transaction to create the table
/// transaction.commit(&engine)?;
/// # Ok(())
/// # }
/// ```