diff --git a/core/lib.rs b/core/lib.rs
index d7f6f7d59..a37955145 100644
--- a/core/lib.rs
+++ b/core/lib.rs
@@ -141,6 +141,7 @@ impl Connection {
                 self.pager.write_database_header(&self.header.borrow());
 
                 // update cache size
+                self.pager.change_page_cache_size(value);
             }
             _ => todo!(),
         }
diff --git a/core/pager.rs b/core/pager.rs
index a30206ec5..5ef837153 100644
--- a/core/pager.rs
+++ b/core/pager.rs
@@ -5,6 +5,7 @@ use crate::PageSource;
 use log::trace;
 use sieve_cache::SieveCache;
 use std::cell::RefCell;
+use std::hash::Hash;
 use std::rc::Rc;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::RwLock;
@@ -72,12 +73,34 @@ impl Page {
     }
 }
 
+pub struct PageCache<K: Eq + Hash + Clone, V> {
+    cache: SieveCache<K, V>,
+}
+
+impl<K: Eq + Hash + Clone, V> PageCache<K, V> {
+    pub fn new(cache: SieveCache<K, V>) -> Self {
+        Self { cache }
+    }
+
+    pub fn insert(&mut self, key: K, value: V) {
+        self.cache.insert(key, value);
+    }
+
+    pub fn get(&mut self, key: &K) -> Option<&V> {
+        self.cache.get(key)
+    }
+
+    pub fn resize(&mut self, capacity: usize) {
+        self.cache = SieveCache::new(capacity).unwrap();
+    }
+}
+
 /// The pager interface implements the persistence layer by providing access
 /// to pages of the database file, including caching, concurrency control, and
 /// transaction management.
 pub struct Pager {
     pub page_source: PageSource,
-    page_cache: RefCell<SieveCache<usize, Rc<Page>>>,
+    page_cache: RefCell<PageCache<usize, Rc<Page>>>,
     buffer_pool: Rc<BufferPool>,
     pub io: Rc<dyn crate::io::IO>,
 }
@@ -95,7 +118,7 @@ impl Pager {
         let db_header = db_header.borrow();
         let page_size = db_header.page_size as usize;
         let buffer_pool = Rc::new(BufferPool::new(page_size));
-        let page_cache = RefCell::new(SieveCache::new(10).unwrap());
+        let page_cache = RefCell::new(PageCache::new(SieveCache::new(10).unwrap()));
         Ok(Self {
             page_source,
             buffer_pool,
@@ -126,4 +149,15 @@ impl Pager {
     pub fn write_database_header(&self, header: &DatabaseHeader) {
         sqlite3_ondisk::begin_write_database_header(header, self).expect("failed to write header");
     }
+
+    pub fn change_page_cache_size(&self, capacity: i64) {
+        // Sadly SieveCache is limited. Not resize available and no iterator.
+        let capacity = if capacity < 0 {
+            let kb = capacity.abs() * 1024;
+            kb / 512 // assume 512 page size for now
+        } else {
+            capacity
+        };
+        self.page_cache.borrow_mut().resize(capacity as usize);
+    }
 }