Use type-safe PageSize newtype for pager.page_size

core/lib.rs

@@ -480,20 +480,21 @@ impl Database {
         )?;
 
         let size = match page_size {
-            Some(size) => size as u32,
+            Some(size) => PageSize::new(size as u32).unwrap_or_else(|| {
+                panic!("invalid page size: {size}");
+            }),
             None => {
                 pager // if None is passed in, we know that we already initialized so we can safely call `with_header` here
                     .io
                     .block(|| pager.with_header(|header| header.page_size))
                     .unwrap_or_default()
-                    .get()
             }
         };
 
         pager.page_size.set(Some(size));
         let wal_path = format!("{}-wal", self.path);
         let file = self.io.open_file(&wal_path, OpenFlags::Create, false)?;
-        let real_shared_wal = WalFileShared::new_shared(size, &self.io, file)?;
+        let real_shared_wal = WalFileShared::new_shared(size.get(), &self.io, file)?;
         // Modify Database::maybe_shared_wal to point to the new WAL file so that other connections
         // can open the existing WAL.
         *maybe_shared_wal = Some(real_shared_wal.clone());
@@ -1476,18 +1477,18 @@ impl Connection {
     /// is first created, if it does not already exist when the page_size pragma is issued,
     /// or at the next VACUUM command that is run on the same database connection while not in WAL mode.
     pub fn reset_page_size(&self, size: u32) -> Result<()> {
-        if PageSize::new(size).is_none() {
+        let Some(size) = PageSize::new(size) else {
             return Ok(());
-        }
+        };
 
-        self.page_size.set(size);
+        self.page_size.set(size.get());
         if self._db.db_state.get() != DbState::Uninitialized {
             return Ok(());
         }
 
         *self._db.maybe_shared_wal.write() = None;
         self.pager.borrow_mut().clear_page_cache();
-        let pager = self._db.init_pager(Some(size as usize))?;
+        let pager = self._db.init_pager(Some(size.get() as usize))?;
         self.pager.replace(Rc::new(pager));
         self.pager.borrow().set_initial_page_size(size);
 

core/storage/pager.rs

@@ -424,7 +424,7 @@ pub struct Pager {
     /// Cache page_size and reserved_space at Pager init and reuse for subsequent
     /// `usable_space` calls. TODO: Invalidate reserved_space when we add the functionality
     /// to change it.
-    pub(crate) page_size: Cell<Option<u32>>,
+    pub(crate) page_size: Cell<Option<PageSize>>,
     reserved_space: OnceCell<u8>,
     free_page_state: RefCell<FreePageState>,
     /// Maximum number of pages allowed in the database. Default is 1073741823 (SQLite default).
@@ -888,7 +888,6 @@ impl Pager {
             self.io
                 .block(|| self.with_header(|header| header.page_size))
                 .unwrap_or_default()
-                .get()
         });
 
         let reserved_space = *self.reserved_space.get_or_init(|| {
@@ -897,11 +896,11 @@ impl Pager {
                 .unwrap_or_default()
         });
 
-        (page_size as usize) - (reserved_space as usize)
+        (page_size.get() as usize) - (reserved_space as usize)
     }
 
     /// Set the initial page size for the database. Should only be called before the database is initialized
-    pub fn set_initial_page_size(&self, size: u32) {
+    pub fn set_initial_page_size(&self, size: PageSize) {
         assert_eq!(self.db_state.get(), DbState::Uninitialized);
         self.page_size.replace(Some(size));
     }
@@ -1390,8 +1389,8 @@ impl Pager {
                 .io
                 .block(|| self.with_header(|header| header.database_size))?
                 .get();
-            let page_size = self.page_size.get().unwrap_or(PageSize::DEFAULT as u32);
-            let expected = (db_size * page_size) as u64;
+            let page_size = self.page_size.get().unwrap_or_default();
+            let expected = (db_size * page_size.get()) as u64;
             if expected < self.db_file.size()? {
                 self.io.wait_for_completion(self.db_file.truncate(
                     expected as usize,
@@ -1559,7 +1558,7 @@ impl Pager {
                 default_header.database_size = 1.into();
 
                 if let Some(size) = self.page_size.get() {
-                    default_header.page_size = PageSize::new(size).expect("page size");
+                    default_header.page_size = size;
                 }
                 self.buffer_pool
                     .finalize_with_page_size(default_header.page_size.get() as usize)?;

core/storage/sqlite3_ondisk.rs

@@ -947,7 +947,7 @@ pub fn write_pages_vectored(
     // batch item array is already sorted by id, so we just need to find contiguous ranges of page_id's
     // to submit as `writev`/write_pages calls.
 
-    let page_sz = pager.page_size.get().unwrap_or(PageSize::DEFAULT as u32) as usize;
+    let page_sz = pager.page_size.get().expect("page size is not set").get() as usize;
 
     // Count expected number of runs to create the atomic counter we need to track each batch
     let mut run_count = 0;