diff --git a/backend/Cargo.lock b/backend/Cargo.lock
index 84400d0..9a23381 100644
--- a/backend/Cargo.lock
+++ b/backend/Cargo.lock
@@ -659,7 +659,7 @@ dependencies = [
 
 [[package]]
 name = "database"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "async-trait",
  "chrono",
diff --git a/backend/database/Cargo.toml b/backend/database/Cargo.toml
index ec40e0d..beebb98 100644
--- a/backend/database/Cargo.toml
+++ b/backend/database/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "database"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/backend/database/src/changes.rs b/backend/database/src/changes.rs
index affefd4..f3464ed 100644
--- a/backend/database/src/changes.rs
+++ b/backend/database/src/changes.rs
@@ -1,5 +1,7 @@
 //! Contains general modification structs and enums.
 
+use std::fmt::Display;
+
 use itertools::Itertools;
 use tracing::instrument;
 
@@ -51,13 +53,13 @@ where
     A: ItemMod,
 {
     #[instrument(skip_all)]
-    pub async fn submit_changes_with<P, DB: sqlx::Database>(
+    pub async fn submit_changes_with<P>(
         &self,
         parent: &P,
-        pool: &sqlx::Pool<DB>,
+        pool: &sqlx::Pool<<A as AttachmentItemMod<P>>::Engine>,
     ) -> sqlx::Result<()>
     where
-        A: ItemMod + AttachmentItemMod<P, DB>,
+        A: ItemMod + AttachmentItemMod<P>,
         P: Item,
     {
         for attached in self.attached.iter() {
@@ -124,29 +126,31 @@ pub trait CompareAttachable<I: PartialEq + Clone + Item<IntoMod = A>, A: ItemMod
     }
 }
 
-impl CompareAttachable<CakupanItem, CakupanItem> for KonsepItem {
+impl<I> CompareAttachable<CakupanItem, CakupanItem> for KonsepItem<I> {
     fn items(&self) -> Vec<CakupanItem> {
         Vec::clone(&self.cakupans)
     }
 }
-impl CompareAttachable<KataAsingItem, KataAsingItem> for KonsepItem {
+impl<I> CompareAttachable<KataAsingItem, KataAsingItem> for KonsepItem<I> {
     fn items(&self) -> Vec<KataAsingItem> {
         Vec::clone(&self.kata_asing)
     }
 }
 
-impl CompareAttachable<KonsepItem, KonsepItemMod> for LemmaItem {
-    fn items(&self) -> Vec<KonsepItem> {
+impl<I: Copy + Clone + PartialEq + PartialOrd + Display>
+    CompareAttachable<KonsepItem<I>, KonsepItemMod<I>> for LemmaItem<I>
+{
+    fn items(&self) -> Vec<KonsepItem<I>> {
         Vec::clone(&self.konseps)
     }
-    fn find_attached(&self, other: &Vec<KonsepItem>) -> Vec<KonsepItemMod> {
+    fn find_attached(&self, other: &Vec<KonsepItem<I>>) -> Vec<KonsepItemMod<I>> {
         Vec::clone(other)
             .into_iter()
             .filter(|item| item.id == AutoGen::Unknown)
             .map(|item| KonsepItemMod::from_item(&item))
             .collect_vec()
     }
-    fn find_detached(&self, other: &Vec<KonsepItem>) -> Vec<KonsepItemMod> {
+    fn find_detached(&self, other: &Vec<KonsepItem<I>>) -> Vec<KonsepItemMod<I>> {
         let other_ids = Vec::clone(other)
             .into_iter()
             .filter(|item| item.id != AutoGen::Unknown)
@@ -158,7 +162,7 @@ impl CompareAttachable<KonsepItem, KonsepItemMod> for LemmaItem {
             .map(|item| KonsepItemMod::from_item(&item))
             .collect_vec()
     }
-    fn find_modified(&self, other: &Vec<KonsepItem>) -> Vec<KonsepItemMod> {
+    fn find_modified(&self, other: &Vec<KonsepItem<I>>) -> Vec<KonsepItemMod<I>> {
         let detached_id = self
             .find_detached(other)
             .iter()
diff --git a/backend/database/src/data/items/cakupan.rs b/backend/database/src/data/items/cakupan.rs
index 49b0261..63b6683 100644
--- a/backend/database/src/data/items/cakupan.rs
+++ b/backend/database/src/data/items/cakupan.rs
@@ -1,5 +1,7 @@
 //! Contains the [CakupanItem].
 
+use std::fmt::{Debug, Display};
+
 use crate::io::interface::{AttachmentItemMod, FromView, Item, ItemMod, SubmitItem};
 use crate::prelude::*;
 use tracing::instrument;
@@ -91,12 +93,15 @@ impl From<String> for CakupanItem {
 
 #[cfg(feature = "sqlite")]
 #[async_trait::async_trait]
-impl AttachmentItemMod<KonsepItem, sqlx::Sqlite> for CakupanItem {
+impl<I: Display + Sync + PartialEq + Copy + Clone> AttachmentItemMod<KonsepItem<I>>
+    for CakupanItem
+{
+    type Engine = sqlx::Sqlite;
     #[instrument(skip_all)]
     async fn submit_attachment_to(
         &self,
-        parent: &KonsepItem,
-        pool: &sqlx::Pool<sqlx::Sqlite>,
+        parent: &KonsepItem<I>,
+        pool: &sqlx::Pool<Self::Engine>,
     ) -> sqlx::Result<()> {
         tracing::trace!(
             "Attaching <Cakupan={}> to <{}:{}>",
@@ -123,8 +128,8 @@ impl AttachmentItemMod<KonsepItem, sqlx::Sqlite> for CakupanItem {
     }
     async fn submit_detachment_from(
         &self,
-        parent: &KonsepItem,
-        pool: &sqlx::Pool<sqlx::Sqlite>,
+        parent: &KonsepItem<I>,
+        pool: &sqlx::Pool<Self::Engine>,
     ) -> sqlx::Result<()> {
         tracing::trace!(
             "Detaching <Cakupan={}> from <{}:{}>",
@@ -150,8 +155,90 @@ impl AttachmentItemMod<KonsepItem, sqlx::Sqlite> for CakupanItem {
 
     async fn submit_modification_with(
         &self,
-        parent: &KonsepItem,
-        _pool: &sqlx::Pool<sqlx::Sqlite>,
+        parent: &KonsepItem<I>,
+        _pool: &sqlx::Pool<Self::Engine>,
+    ) -> sqlx::Result<()> {
+        tracing::trace!(
+            "Modifying <Cakupan={}> with <{}:{}>",
+            self.0,
+            parent.id,
+            parent.keterangan
+        );
+        todo!()
+    }
+}
+
+#[cfg(feature = "postgres")]
+#[async_trait::async_trait]
+impl<I: Display + Sync + PartialEq + Copy + Clone> AttachmentItemMod<KonsepItem<I>>
+    for CakupanItem
+{
+    type Engine = sqlx::Postgres;
+    #[instrument(skip_all)]
+    async fn submit_attachment_to(
+        &self,
+        parent: &KonsepItem<I>,
+        pool: &sqlx::Pool<Self::Engine>,
+    ) -> sqlx::Result<()> {
+        tracing::trace!(
+            "Attaching <Cakupan={}> to <{}:{}>",
+            self.0,
+            parent.id,
+            parent.keterangan
+        );
+        sqlx::query! {
+            r#"INSERT INTO cakupan (nama) VALUES ($1) ON CONFLICT (nama) DO NOTHING;"#,
+            self.0
+        }
+        .execute(pool)
+        .await
+        .expect("Error attaching cakupan to konsep");
+
+        sqlx::query! {
+                r#"INSERT INTO cakupan_x_konsep (cakupan_id, konsep_id)
+                    VALUES (
+                        (SELECT id FROM cakupan WHERE cakupan.nama = $1),
+                        (SELECT id FROM konsep WHERE konsep.keterangan = $2)
+                    ) ON CONFLICT (cakupan_id, konsep_id) DO NOTHING;"#,
+            self.0,
+            parent.keterangan
+        }
+        .execute(pool)
+        .await
+        .expect("Error attaching cakupan to konsep");
+        Ok(())
+    }
+    async fn submit_detachment_from(
+        &self,
+        parent: &KonsepItem<I>,
+        pool: &sqlx::Pool<Self::Engine>,
+    ) -> sqlx::Result<()> {
+        tracing::trace!(
+            "Detaching <Cakupan={}> from <{}:{}>",
+            self.0,
+            parent.id,
+            parent.keterangan
+        );
+        sqlx::query! {
+            r#" DELETE FROM cakupan_x_konsep AS cxk
+                WHERE (
+                    cxk.cakupan_id = (SELECT id FROM cakupan WHERE cakupan.nama = $1)
+                        AND
+                    cxk.konsep_id = (SELECT id FROM konsep WHERE konsep.keterangan = $2)
+                );"#,
+            self.0,
+            parent.keterangan
+        }
+        .execute(pool)
+        .await
+        .expect("Error detaching cakupan from konsep");
+        Ok(())
+    }
+
+    async fn submit_modification_with(
+        &self,
+        parent: &KonsepItem<I>,
+        _pool: &sqlx::Pool<Self::Engine>,
     ) -> sqlx::Result<()> {
         tracing::trace!(
             "Modifying <Cakupan={}> with <{}:{}>",
diff --git a/backend/database/src/data/items/kata_asing.rs b/backend/database/src/data/items/kata_asing.rs
index 633bc58..ad40a42 100644
--- a/backend/database/src/data/items/kata_asing.rs
+++ b/backend/database/src/data/items/kata_asing.rs
@@ -1,5 +1,7 @@
 //! Contains struct [KataAsingItem] which map a foreign word with its language of origin.
 
+use std::fmt::Display;
+
 use crate::io::interface::{AttachmentItemMod, FromView, Item, ItemMod, SubmitItem};
 use crate::prelude::*;
 
@@ -97,11 +99,15 @@ impl SubmitItem for KataAsingItem {
 
 #[cfg(feature = "sqlite")]
 #[async_trait::async_trait]
-impl AttachmentItemMod<KonsepItem, sqlx::Sqlite> for KataAsingItem {
+impl<I: Display + Sync + PartialEq + Copy + Clone> AttachmentItemMod<KonsepItem<I>>
+    for KataAsingItem
+{
+    type Engine = sqlx::Sqlite;
+
     async fn submit_attachment_to(
         &self,
-        parent: &KonsepItem,
-        pool: &sqlx::Pool<sqlx::Sqlite>,
+        parent: &KonsepItem<I>,
+        pool: &sqlx::Pool<Self::Engine>,
     ) -> sqlx::Result<()> {
         tracing::trace!(
             "Attaching <KataAsing {}:{}> to <{}:{}>",
@@ -130,8 +136,8 @@ impl AttachmentItemMod<KonsepItem, sqlx::Sqlite> for KataAsingItem {
     }
     async fn submit_detachment_from(
         &self,
-        parent: &KonsepItem,
-        pool: &sqlx::Pool<sqlx::Sqlite>,
+        parent: &KonsepItem<I>,
+        pool: &sqlx::Pool<Self::Engine>,
     ) -> sqlx::Result<()> {
         tracing::trace!(
             "Detaching <KataAsing {}:{}> from <{}:{}>",
@@ -159,8 +165,90 @@ impl AttachmentItemMod<KonsepItem, sqlx::Sqlite> for KataAsingItem {
 
     async fn submit_modification_with(
         &self,
-        parent: &KonsepItem,
-        _pool: &sqlx::Pool<sqlx::Sqlite>,
+        parent: &KonsepItem<I>,
+        _pool: &sqlx::Pool<Self::Engine>,
+    ) -> sqlx::Result<()> {
+        tracing::trace!(
+            "Modifying <KataAsing {}:{}> with <{}:{}>",
+            self.bahasa,
+            self.nama,
+            parent.id,
+            parent.keterangan
+        );
+        todo!()
+    }
+}
+
+#[cfg(feature = "postgres")]
+#[async_trait::async_trait]
+impl<I: Display + Sync + PartialEq + Copy + Clone> AttachmentItemMod<KonsepItem<I>>
+    for KataAsingItem
+{
+    type Engine = sqlx::Postgres;
+
+    async fn submit_attachment_to(
+        &self,
+        parent: &KonsepItem<I>,
+        pool: &sqlx::Pool<Self::Engine>,
+    ) -> sqlx::Result<()> {
+        tracing::trace!(
+            "Attaching <KataAsing {}:{}> to <{}:{}>",
+            self.bahasa,
+            self.nama,
+            parent.id,
+            parent.keterangan
+        );
+        sqlx::query! {
+            r#"INSERT INTO kata_asing (nama, bahasa) VALUES ($1,$2) ON CONFLICT (nama, bahasa) DO NOTHING;"#, self.nama, self.bahasa
+        }.execute(pool).await.expect("Error attaching kata_asing to konsep");
+        sqlx::query! {
+            r#"INSERT INTO kata_asing_x_konsep (kata_asing_id, konsep_id)
+                VALUES (
+                    (SELECT id FROM kata_asing WHERE kata_asing.nama = $1 AND kata_asing.bahasa = $2),
+                    (SELECT id FROM konsep WHERE konsep.keterangan = $3)
+                ) ON CONFLICT (kata_asing_id, konsep_id) DO NOTHING;"#,
+            self.nama,
+            self.bahasa,
+            parent.keterangan
+        }
+        .execute(pool)
+        .await
+        .expect("Error attaching kata_asing to konsep");
+        Ok(())
+    }
+    async fn submit_detachment_from(
+        &self,
+        parent: &KonsepItem<I>,
+        pool: &sqlx::Pool<Self::Engine>,
+    ) -> sqlx::Result<()> {
+        tracing::trace!(
+            "Detaching <KataAsing {}:{}> from <{}:{}>",
+            self.bahasa,
+            self.nama,
+            parent.id,
+            parent.keterangan
+        );
+        sqlx::query! {
+            r#"DELETE FROM kata_asing_x_konsep AS kaxk
+               WHERE (
+                    kaxk.kata_asing_id = (SELECT id FROM kata_asing WHERE kata_asing.nama = $1 AND kata_asing.bahasa = $2)
+                        AND
+                    kaxk.konsep_id = (SELECT id FROM konsep WHERE konsep.keterangan = $3)
+                );"#,
+            self.nama,
+            self.bahasa,
+            parent.keterangan
+        }
+        .execute(pool)
+        .await
+        .expect("Error detaching cakupan from konsep");
+        Ok(())
+    }
+
+    async fn submit_modification_with(
+        &self,
+        parent: &KonsepItem<I>,
+        _pool: &sqlx::Pool<Self::Engine>,
     ) -> sqlx::Result<()> {
         tracing::trace!(
             "Modifying <KataAsing {}:{}> with <{}:{}>",
diff --git a/backend/database/src/data/items/konsep.rs b/backend/database/src/data/items/konsep.rs
index bde4276..8c3520d 100644
--- a/backend/database/src/data/items/konsep.rs
+++ b/backend/database/src/data/items/konsep.rs
@@ -4,6 +4,7 @@ use crate::changes::{AttachmentMod, CompareAttachable, FieldMod};
 use crate::io::interface::{AttachmentItemMod, FromView, FromViewMap, Item, ItemMod};
 use crate::prelude::*;
 use std::collections::HashMap;
+use std::fmt::{Debug, Display};
 use tracing::instrument;
 
 use crate::data::items::cakupan::CakupanItem;
@@ -19,10 +20,10 @@ use crate::data::items::lemma::LemmaItem;
 /// The following are the tags implemented in this struct:
 /// - [cakupans](KonsepItem#structfield.cakupans): the communication contexts of the definition.
 /// - [kata_asing](KonsepItem#structfield.kata_asing): words with equivalent meaning in other languages.
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, ts_rs::TS)]
+#[derive(Clone, serde::Serialize, serde::Deserialize, ts_rs::TS)]
 #[ts(export, export_to = "../../src/bindings/")]
-pub struct KonsepItem {
-    pub id: AutoGen<i64>,
+pub struct KonsepItem<I> {
+    pub id: AutoGen<I>,
     pub keterangan: String,
     pub golongan_kata: String,
     #[ts(type = "Array<string>")]
@@ -30,20 +31,44 @@ pub struct KonsepItem {
     pub kata_asing: Vec<KataAsingItem>,
 }
 
+impl<I: Debug> Debug for KonsepItem<I> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("KonsepItem")
+            .field("id", &self.id)
+            .field("keterangan", &self.keterangan)
+            .field("golongan_kata", &self.golongan_kata)
+            .field("cakupans", &self.cakupans)
+            .field("kata_asing", &self.kata_asing)
+            .finish()
+    }
+}
+
 /// A modified [KonsepItem].
 ///
 /// Its usage is similar to [LemmaItemMod](crate::data::LemmaItemMod).
-#[derive(Debug, Clone, PartialEq)]
-pub struct KonsepItemMod {
-    pub id: AutoGen<i64>,
+#[derive(Clone, PartialEq)]
+pub struct KonsepItemMod<I> {
+    pub id: AutoGen<I>,
     pub keterangan: FieldMod<String>,
     pub golongan_kata: FieldMod<String>,
     pub cakupans: AttachmentMod<CakupanItem>,
     pub kata_asing: AttachmentMod<KataAsingItem>,
 }
 
-impl ItemMod for KonsepItemMod {
-    type FromItem = KonsepItem;
+impl<I: Debug> Debug for KonsepItemMod<I> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("KonsepItemMod")
+            .field("id", &self.id)
+            .field("keterangan", &self.keterangan)
+            .field("golongan_kata", &self.golongan_kata)
+            .field("cakupans", &self.cakupans)
+            .field("kata_asing", &self.kata_asing)
+            .finish()
+    }
+}
+
+impl<I: PartialEq + Copy + Clone> ItemMod for KonsepItemMod<I> {
+    type FromItem = KonsepItem<I>;
 
     fn from_item(value: &Self::FromItem) -> Self {
         Self {
@@ -55,10 +80,10 @@ impl ItemMod for KonsepItemMod {
         }
     }
 }
-impl KonsepItem {
+impl<I> KonsepItem<I> {
     pub fn null() -> Self {
         Self {
-            id: AutoGen::Unknown,
+            id: AutoGen::<I>::Unknown,
             keterangan: "".into(),
             golongan_kata: "".into(),
             cakupans: vec![],
@@ -67,7 +92,7 @@ impl KonsepItem {
     }
 }
 
-impl PartialEq for KonsepItem {
+impl<I> PartialEq for KonsepItem<I> {
     fn eq(&self, other: &Self) -> bool {
         self.keterangan == other.keterangan
             && self.golongan_kata == other.golongan_kata
@@ -89,12 +114,14 @@ impl PartialEq for KonsepItem {
 
 #[cfg(feature = "sqlite")]
 #[async_trait::async_trait]
-impl AttachmentItemMod<LemmaItem, sqlx::Sqlite> for KonsepItemMod {
+impl AttachmentItemMod<LemmaItem<i32>> for KonsepItemMod<i32> {
+    type Engine = sqlx::Sqlite;
+
     #[instrument(skip_all)]
     async fn submit_attachment_to(
         &self,
-        parent: &LemmaItem,
-        pool: &sqlx::Pool<sqlx::Sqlite>,
+        parent: &LemmaItem<i32>,
+        pool: &sqlx::Pool<Self::Engine>,
     ) -> sqlx::Result<()> {
         let konsep = KonsepItem::partial_from_mod(self);
         tracing::trace!(
@@ -124,8 +151,8 @@ impl AttachmentItemMod<LemmaItem, sqlx::Sqlite> for KonsepItemMod {
     }
     async fn submit_detachment_from(
         &self,
-        parent: &LemmaItem,
-        pool: &sqlx::Pool<sqlx::Sqlite>,
+        parent: &LemmaItem<i32>,
+        pool: &sqlx::Pool<Self::Engine>,
     ) -> sqlx::Result<()> {
         tracing::trace!(
             "Detaching <{}:{}> from <{}:{}>",
@@ -146,8 +173,8 @@ impl AttachmentItemMod<LemmaItem, sqlx::Sqlite> for KonsepItemMod {
 
     async fn submit_modification_with(
         &self,
-        parent: &LemmaItem,
-        pool: &sqlx::Pool<sqlx::Sqlite>,
+        parent: &LemmaItem<i32>,
+        pool: &sqlx::Pool<Self::Engine>,
     ) -> sqlx::Result<()> {
         let konsep = KonsepItem::partial_from_mod(self);
         tracing::trace!(
@@ -179,16 +206,119 @@ impl AttachmentItemMod<LemmaItem, sqlx::Sqlite> for KonsepItemMod {
     }
 }
 
-type Key = (i64, Option<String>, Option<String>);
+#[cfg(feature = "postgres")]
+#[async_trait::async_trait]
+impl AttachmentItemMod<LemmaItem<i32>> for KonsepItemMod<i32> {
+    type Engine = sqlx::Postgres;
+
+    #[instrument(skip_all)]
+    async fn submit_attachment_to(
+        &self,
+        parent: &LemmaItem<i32>,
+        pool: &sqlx::Pool<Self::Engine>,
+    ) -> sqlx::Result<()> {
+        let konsep = KonsepItem::partial_from_mod(self);
+        tracing::trace!(
+            "Attaching <{}:{}> to <{}:{}>",
+            konsep.id,
+            konsep.keterangan,
+            parent.id,
+            parent.lemma
+        );
+        sqlx::query! {
+            r#" INSERT INTO konsep (keterangan, lemma_id, golongan_id)
+                VALUES (
+                    $1,
+                    (SELECT id FROM lemma WHERE lemma.nama = $2),
+                    (SELECT id FROM golongan_kata WHERE golongan_kata.nama = $3)
+                ) ON CONFLICT (id) DO NOTHING
+                "#,
+                konsep.keterangan,
+                parent.lemma,
+                konsep.golongan_kata
+        }
+        .execute(pool)
+        .await?;
+        self.cakupans.submit_changes_with(&konsep, pool).await?;
+        self.kata_asing.submit_changes_with(&konsep, pool).await?;
+        Ok(())
+    }
+    async fn submit_detachment_from(
+        &self,
+        parent: &LemmaItem<i32>,
+        pool: &sqlx::Pool<Self::Engine>,
+    ) -> sqlx::Result<()> {
+        tracing::trace!(
+            "Detaching <{}:{}> from <{}:{}>",
+            self.id,
+            self.keterangan.value(),
+            parent.id,
+            parent.lemma
+        );
+        match (self.id, parent.id) {
+            (AutoGen::Known(i), AutoGen::Known(p)) => {
+                sqlx::query! {
+                    r#" DELETE FROM konsep WHERE (id = $1 AND lemma_id = $2)"#,
+                    i,
+                    p
+                }
+                .execute(pool)
+                .await?
+            }
+            (_, _) => todo!(),
+        };
+        Ok(())
+    }
+
+    async fn submit_modification_with(
+        &self,
+        parent: &LemmaItem<i32>,
+        pool: &sqlx::Pool<Self::Engine>,
+    ) -> sqlx::Result<()> {
+        let konsep = KonsepItem::partial_from_mod(self);
+        tracing::trace!(
+            "Modifying <{}:{}> with <{}:{}>",
+            konsep.id,
+            konsep.keterangan,
+            parent.id,
+            parent.lemma
+        );
+        match (konsep.id, parent.id) {
+            (AutoGen::Known(i), AutoGen::Known(p)) => sqlx::query! {
+                r#" UPDATE konsep
+                    SET keterangan = $1, golongan_id = (SELECT id FROM golongan_kata WHERE golongan_kata.nama = $2)
+                    WHERE (
+                        id = $3
+                        AND
+                        lemma_id = $4
+                    )
+                    "#,
+                    konsep.keterangan,
+                    konsep.golongan_kata,
+                    i,
+                    p,
+            }
+            .execute(pool)
+            .await?,
+            (_,_) => todo!()
+        };
+        self.cakupans.submit_changes_with(&konsep, pool).await?;
+        self.kata_asing.submit_changes_with(&konsep, pool).await?;
+        Ok(())
+    }
+}
+
+type Key<I> = (I, Option<String>, Option<String>);
 type Value = Vec<LemmaWithKonsepView>;
-pub(crate) type KonsepHashMap = HashMap<Key, Value>;
+pub(crate) type KonsepHashMap<I> = HashMap<Key<I>, Value>;
 
-impl Item for KonsepItem {
-    type IntoMod = KonsepItemMod;
+impl<I: PartialEq + Copy + Clone> Item for KonsepItem<I> {
+    type IntoMod = KonsepItemMod<I>;
     fn modify_into(&self, other: &Self) -> Result<Self::IntoMod> {
         if self.id != other.id {
             return Err(BackendError {
-                message: format!("ID Assertion error, {} != {}", self.id, other.id),
+                // message: format!("ID Assertion error, {} != {}", self.id, other.id),
+                message: format!("ID Assertion error"),
             });
         }
         Ok(KonsepItemMod {
@@ -214,10 +344,10 @@ impl Item for KonsepItem {
     }
 }
 
-impl FromViewMap for KonsepItem {
-    type KEY = Key;
+impl<I: Copy> FromViewMap for KonsepItem<I> {
+    type KEY = Key<I>;
     type VALUE = Value;
-    fn from_viewmap(value: &KonsepHashMap) -> Vec<Self> {
+    fn from_viewmap(value: &KonsepHashMap<I>) -> Vec<Self> {
         let mut data = Vec::new();
         for (konsep, views) in value.iter().filter(|((_, kon, _), _)| kon.is_some()) {
             data.push(KonsepItem {
diff --git a/backend/database/src/data/items/lemma.rs b/backend/database/src/data/items/lemma.rs
index 028fe0a..b804043 100644
--- a/backend/database/src/data/items/lemma.rs
+++ b/backend/database/src/data/items/lemma.rs
@@ -10,7 +10,7 @@ use crate::{
 };
 
 use crate::io::interface::SubmitMod;
-use std::collections::HashMap;
+use std::{collections::HashMap, fmt::Display};
 use tracing::instrument;
 
 use super::konsep::KonsepHashMap;
@@ -42,10 +42,10 @@ use super::konsep::KonsepHashMap;
 /// ```
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, ts_rs::TS)]
 #[ts(export, export_to = "../../src/bindings/")]
-pub struct LemmaItem {
-    pub id: AutoGen<i64>,
+pub struct LemmaItem<I: Copy + Clone + PartialOrd + Display> {
+    pub id: AutoGen<I>,
     pub lemma: String,
-    pub konseps: Vec<KonsepItem>,
+    pub konseps: Vec<KonsepItem<I>>,
 }
 
 /// A modified [LemmaItem].
@@ -131,14 +131,14 @@ pub struct LemmaItem {
 /// assert_eq!(lemma_modded.konseps.detached, vec![]);
 /// ```
 #[derive(Debug, Clone)]
-pub struct LemmaItemMod {
-    pub id: AutoGen<i64>,
+pub struct LemmaItemMod<I: PartialEq + Copy + Clone> {
+    pub id: AutoGen<I>,
     pub lemma: FieldMod<String>,
-    pub konseps: AttachmentMod<KonsepItemMod>,
+    pub konseps: AttachmentMod<KonsepItemMod<I>>,
 }
 
-impl Item for LemmaItem {
-    type IntoMod = LemmaItemMod;
+impl<I: PartialEq + Copy + Clone + PartialOrd + Display> Item for LemmaItem<I> {
+    type IntoMod = LemmaItemMod<I>;
     fn modify_into(&self, other: &Self) -> Result<Self::IntoMod> {
         if self.id != other.id {
             Err(BackendError {
@@ -153,7 +153,7 @@ impl Item for LemmaItem {
         }
     }
 
-    fn partial_from_mod(other: &LemmaItemMod) -> Self {
+    fn partial_from_mod(other: &LemmaItemMod<I>) -> Self {
         LemmaItem {
             id: other.id,
             lemma: other.lemma.value().to_string(),
@@ -162,8 +162,8 @@ impl Item for LemmaItem {
     }
 }
 
-impl ItemMod for LemmaItemMod {
-    type FromItem = LemmaItem;
+impl<I: PartialEq + Copy + Clone + PartialOrd + Display> ItemMod for LemmaItemMod<I> {
+    type FromItem = LemmaItem<I>;
 
     fn from_item(value: &Self::FromItem) -> Self {
         Self {
@@ -176,7 +176,7 @@ impl ItemMod for LemmaItemMod {
 
 #[cfg(feature = "sqlite")]
 #[async_trait::async_trait]
-impl SubmitMod for LemmaItemMod {
+impl SubmitMod for LemmaItemMod<i32> {
     type Engine = sqlx::Sqlite;
     #[instrument(skip_all)]
     async fn submit_mod(&self, pool: &sqlx::Pool<Self::Engine>) -> sqlx::Result<()> {
@@ -188,7 +188,7 @@ impl SubmitMod for LemmaItemMod {
     }
 }
 
-impl PartialEq for LemmaItem {
+impl<I: PartialEq + Copy + Clone + PartialOrd + Display> PartialEq for LemmaItem<I> {
     fn eq(&self, other: &Self) -> bool {
         let konseps = Vec::from_iter(self.konseps.clone());
         self.lemma == other.lemma
@@ -203,7 +203,7 @@ impl PartialEq for LemmaItem {
 
 #[cfg(feature = "sqlite")]
 #[async_trait::async_trait]
-impl SubmitItem for LemmaItem {
+impl SubmitItem for LemmaItem<i32> {
     type Engine = sqlx::Sqlite;
     async fn submit_full(&self, pool: &sqlx::Pool<Self::Engine>) -> sqlx::Result<()> {
         let _ = self.submit_partial(pool).await?;
@@ -244,7 +244,7 @@ impl SubmitItem for LemmaItem {
 
 #[cfg(feature = "postgres")]
 #[async_trait::async_trait]
-impl SubmitItem for LemmaItem {
+impl SubmitItem for LemmaItem<i32> {
     type Engine = sqlx::Postgres;
 
     async fn submit_full(&self, pool: &sqlx::Pool<Self::Engine>) -> sqlx::Result<()> {
@@ -258,10 +258,16 @@ impl SubmitItem for LemmaItem {
     }
 
     async fn submit_partial(&self, pool: &sqlx::Pool<Self::Engine>) -> sqlx::Result<()> {
-        sqlx::query! {
-            r#"INSERT or IGNORE INTO lemma (id, nama) VALUES (?, ?)"#,
-            self.id,
-            self.lemma
+        match self.id {
+            AutoGen::Known(i) => sqlx::query! {
+                r#"INSERT INTO lemma (id, nama) VALUES ($1, $2) ON CONFLICT (id, nama) DO NOTHING;"#,
+                i,
+                self.lemma
+            },
+            AutoGen::Unknown  => sqlx::query!{
+                r#"INSERT INTO lemma (nama) VALUES ($1);"#,
+                self.lemma
+            }
         }
         .execute(pool)
         .await?;
@@ -273,23 +279,28 @@ impl SubmitItem for LemmaItem {
     }
 
     async fn submit_partial_removal(&self, pool: &sqlx::Pool<Self::Engine>) -> sqlx::Result<()> {
-        sqlx::query! {
-            r#"DELETE FROM lemma WHERE (lemma.id = ? AND lemma.nama = ?)"#,
-            self.id,
-            self.lemma
-        }
-        .execute(pool)
-        .await?;
+        match self.id {
+            AutoGen::Known(i) => {
+                sqlx::query! {
+                    r#"DELETE FROM lemma WHERE (lemma.id = $1 AND lemma.nama = $2)"#,
+                    i,
+                    self.lemma
+                }
+                .execute(pool)
+                .await?
+            }
+            AutoGen::Unknown => todo!(),
+        };
         Ok(())
     }
 }
 
-impl FromViewMap for LemmaItem {
+impl FromViewMap for LemmaItem<i64> {
     type KEY = (i64, String);
-    type VALUE = KonsepHashMap;
+    type VALUE = KonsepHashMap<i64>;
 
-    fn from_viewmap(value: &HashMap<Self::KEY, Self::VALUE>) -> Vec<LemmaItem> {
-        let mut data = Vec::<LemmaItem>::new();
+    fn from_viewmap(value: &HashMap<Self::KEY, Self::VALUE>) -> Vec<LemmaItem<i64>> {
+        let mut data = Vec::<LemmaItem<i64>>::new();
         for (lemma, konsep_map) in value.iter() {
             data.push(LemmaItem {
                 id: AutoGen::Known(lemma.0),
@@ -300,10 +311,33 @@ impl FromViewMap for LemmaItem {
         data
     }
 }
-impl FromView for LemmaItem {
+impl FromViewMap for LemmaItem<i32> {
+    type KEY = (i32, String);
+    type VALUE = KonsepHashMap<i32>;
+
+    fn from_viewmap(value: &HashMap<Self::KEY, Self::VALUE>) -> Vec<LemmaItem<i32>> {
+        let mut data = Vec::<LemmaItem<i32>>::new();
+        for (lemma, konsep_map) in value.iter() {
+            data.push(LemmaItem {
+                id: AutoGen::Known(lemma.0),
+                lemma: lemma.1.clone(),
+                konseps: KonsepItem::from_viewmap(konsep_map),
+            })
+        }
+        data
+    }
+}
+// impl FromView for LemmaItem<i32> {
+//     type VIEW = LemmaWithKonsepView;
+
+//     fn from_views(views: &Vec<Self::VIEW>) -> Vec<LemmaItem<i32>> {
+//         Self::from_viewmap(&(views.clone().into_viewmap()))
+//     }
+// }
+impl FromView for LemmaItem<i64> {
     type VIEW = LemmaWithKonsepView;
 
-    fn from_views(views: &Vec<Self::VIEW>) -> Vec<LemmaItem> {
+    fn from_views(views: &Vec<Self::VIEW>) -> Vec<LemmaItem<i64>> {
         Self::from_viewmap(&(views.clone().into_viewmap()))
     }
 }
diff --git a/backend/database/src/io/interface.rs b/backend/database/src/io/interface.rs
index 0d73d48..82cd55b 100644
--- a/backend/database/src/io/interface.rs
+++ b/backend/database/src/io/interface.rs
@@ -13,7 +13,7 @@ pub trait View {
 }
 
 /// A trait to convert Vec<[View]> into Vec<[Item]>
-pub trait FromView: Item {
+pub trait FromView: Sized {
     /// The view that is to be converted
     type VIEW;
 
@@ -22,7 +22,7 @@ pub trait FromView: Item {
 }
 
 /// A trait that converts [HashMap] into Vec<[Item]>.
-pub trait FromViewMap: Item {
+pub trait FromViewMap: Sized {
     /// Keys of the input [HashMap], typically the ID but can also be a tuple of identifiers.
     type KEY;
     /// The value of the input [HashMap].
@@ -52,7 +52,7 @@ pub trait IntoViewMap<V>: IntoIterator<Item = V> {
 /// A [View] handles the querying from SQL which contains flat tabular data.
 /// While and [Item] represents the intended data which is often nested.
 /// Traits like [FromView] and [FromViewMap] provides the translation layer between [View] and [Item].
-pub trait Item: Sized {
+pub trait Item {
     /// The Modified version of [Self].
     type IntoMod: ItemMod;
 
@@ -69,7 +69,7 @@ pub trait Item: Sized {
 
 /// A trait which allows item data to be submitted into SQL databases.
 #[async_trait::async_trait]
-pub trait SubmitItem: Item {
+pub trait SubmitItem {
     type Engine: sqlx::Database;
     /// Inserts item with corresponding children.
     async fn submit_full(&self, pool: &sqlx::Pool<Self::Engine>) -> sqlx::Result<()>;
@@ -103,14 +103,27 @@ pub trait SubmitMod: ItemMod {
 
 /// A trait which allows attachment items to be submitted into SQL database as [ItemMod].
 #[async_trait::async_trait]
-pub trait AttachmentItemMod<P: Item, DB: sqlx::Database>: ItemMod {
+pub trait AttachmentItemMod<P: Item>: ItemMod {
+    type Engine: sqlx::Database;
+
     /// Submit [Self] to parent item.
-    async fn submit_attachment_to(&self, parent: &P, pool: &sqlx::Pool<DB>) -> sqlx::Result<()>;
+    async fn submit_attachment_to(
+        &self,
+        parent: &P,
+        pool: &sqlx::Pool<Self::Engine>,
+    ) -> sqlx::Result<()>;
 
     /// Detaches [Self] to parent item.
-    async fn submit_detachment_from(&self, parent: &P, pool: &sqlx::Pool<DB>) -> sqlx::Result<()>;
+    async fn submit_detachment_from(
+        &self,
+        parent: &P,
+        pool: &sqlx::Pool<Self::Engine>,
+    ) -> sqlx::Result<()>;
 
     /// Modifies [Self].
-    async fn submit_modification_with(&self, parent: &P, pool: &sqlx::Pool<DB>)
-        -> sqlx::Result<()>;
+    async fn submit_modification_with(
+        &self,
+        parent: &P,
+        pool: &sqlx::Pool<Self::Engine>,
+    ) -> sqlx::Result<()>;
 }
diff --git a/backend/database/src/states.rs b/backend/database/src/states.rs
index 67f3070..0d73434 100644
--- a/backend/database/src/states.rs
+++ b/backend/database/src/states.rs
@@ -2,33 +2,30 @@
 
 use sqlx::migrate::MigrateDatabase;
 use sqlx::migrate::{Migrate, MigrateError};
+use sqlx::FromRow;
 
 use crate::errors::Result;
 use crate::prelude::BackendError;
 
-pub use sqlx::Pool;
-#[cfg(feature = "sqlite")]
-pub use sqlx::Sqlite;
-
 // TODO: Refactor this module
 
 /// Connection to database
 #[derive(Debug, Clone)]
 pub struct Connection<DB: sqlx::Database> {
     #[allow(missing_docs)]
-    pub pool: Pool<DB>,
+    pub pool: sqlx::Pool<DB>,
 }
 
 /// Counts of selected items.
 #[allow(missing_docs)]
 #[derive(Debug, Clone, Default, serde::Serialize, PartialEq, ts_rs::TS)]
 #[ts(export, export_to = "../../src/bindings/")]
-pub struct Counts {
-    lemmas: i32,
-    konseps: i32,
-    golongan_katas: i32,
-    cakupans: i32,
-    kata_asings: i32,
+pub struct Counts<I> {
+    lemmas: I,
+    konseps: I,
+    golongan_katas: I,
+    cakupans: I,
+    kata_asings: I,
 }
 
 /// A helper struct for when a single string value is queried.
@@ -37,6 +34,41 @@ pub struct StringItem {
     pub item: String,
 }
 
+impl Counts<Option<i64>> {
+    fn unwrap_fields(self) -> Counts<i64> {
+        Counts {
+            lemmas: self.lemmas.unwrap_or(0),
+            konseps: self.konseps.unwrap_or(0),
+            golongan_katas: self.golongan_katas.unwrap_or(0),
+            cakupans: self.cakupans.unwrap_or(0),
+            kata_asings: self.kata_asings.unwrap_or(0),
+        }
+    }
+}
+
+#[cfg(feature = "postgres")]
+impl Connection<sqlx::Postgres> {
+    pub async fn from(url: String) -> Self {
+        Self {
+            pool: sqlx::PgPool::connect(&url).await.unwrap(),
+        }
+    }
+    /// Queries the counts of each items as [Counts].
+    ///
+    /// The function calls the following query:
+    /// ```sql
+    #[doc = include_str!("../transactions/postgres/count_items.sql")]
+    /// ```
+    pub async fn statistics(self) -> Result<Counts<i64>> {
+        let inter: Counts<Option<i64>> =
+            sqlx::query_file_as!(Counts, "transactions/postgres/count_items.sql")
+                .fetch_one(&self.pool)
+                .await
+                .map_err(BackendError::from)?;
+        Ok(inter.unwrap_fields())
+    }
+}
+
 #[cfg(feature = "sqlite")]
 impl Connection<sqlx::Sqlite> {
     /// Forcefully reconnect to the specified url.
@@ -63,28 +95,28 @@ impl Connection<sqlx::Sqlite> {
         }
     }
 
-    /// Queries all `golongan_kata.nama` and returns Result<Vec<[StringItem]>>
+    /// Queries the counts of each items as [Counts].
     ///
     /// The function calls the following query:
     /// ```sql
-    /// SELECT nama AS item FROM golongan_kata
+    #[doc = include_str!("../transactions/sqlite/count_items.sql")]
     /// ```
-    pub async fn get_golongan_kata_enumeration(self) -> Result<Vec<StringItem>> {
-        sqlx::query_as!(StringItem, "SELECT nama AS item FROM golongan_kata")
-            .fetch_all(&self.pool)
+    pub async fn statistics(self) -> Result<Counts<i32>> {
+        sqlx::query_file_as!(Counts, "transactions/sqlite/count_items.sql")
+            .fetch_one(&self.pool)
             .await
             .map_err(BackendError::from)
     }
 
-    /// Queries the counts of each items as [Counts].
+    /// Queries all `golongan_kata.nama` and returns Result<Vec<[StringItem]>>
     ///
     /// The function calls the following query:
     /// ```sql
-    #[doc = include_str!("../transactions/count_items.sql")]
+    /// SELECT nama AS item FROM golongan_kata
     /// ```
-    pub async fn statistics(self) -> Result<Counts> {
-        sqlx::query_file_as!(Counts, "transactions/count_items.sql")
-            .fetch_one(&self.pool)
+    pub async fn get_golongan_kata_enumeration(self) -> Result<Vec<StringItem>> {
+        sqlx::query_as!(StringItem, "SELECT nama AS item FROM golongan_kata")
+            .fetch_all(&self.pool)
             .await
             .map_err(BackendError::from)
     }
@@ -96,7 +128,7 @@ impl Connection<sqlx::Sqlite> {
         Ok(Self::migrate(pool).await)
     }
 
-    async fn migrate(pool: Pool<Sqlite>) -> Self {
+    async fn migrate(pool: sqlx::Pool<sqlx::Sqlite>) -> Self {
         match sqlx::migrate!("migrations/sqlite").run(&pool).await {
             Ok(_) => Self { pool },
             // Err(MigrateError::VersionMismatch(v)) => {println!("{}", v);  Self{pool}}
diff --git a/backend/database/src/types.rs b/backend/database/src/types.rs
index c46a492..0a4c10a 100644
--- a/backend/database/src/types.rs
+++ b/backend/database/src/types.rs
@@ -9,22 +9,36 @@ use std::{cmp::Ordering, fmt::Debug};
 /// For values automatically generated by database.
 ///
 /// It works similar to [Option] but conveys a clearer meaning.
-#[derive(Debug, Copy, Clone, serde::Serialize, serde::Deserialize, PartialEq)]
+#[derive(Clone, serde::Serialize, serde::Deserialize)]
 #[serde(untagged)]
-pub enum AutoGen<T>
-where
-    T: core::fmt::Debug + PartialEq,
-{
+pub enum AutoGen<T> {
     /// The value is already provided by the database
     Known(T),
     /// The value is not yet provided by the database
     Unknown,
 }
 
-impl<T> Display for AutoGen<T>
-where
-    T: core::fmt::Debug + PartialEq + Display,
-{
+impl<T: Copy> Copy for AutoGen<T> {}
+
+impl<T: PartialEq> PartialEq for AutoGen<T> {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::Known(l0), Self::Known(r0)) => l0 == r0,
+            _ => core::mem::discriminant(self) == core::mem::discriminant(other),
+        }
+    }
+}
+
+impl<T: Debug> Debug for AutoGen<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Known(arg0) => f.debug_tuple("Known").field(arg0).finish(),
+            Self::Unknown => write!(f, "Unknown"),
+        }
+    }
+}
+
+impl<T: Display> Display for AutoGen<T> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
@@ -41,10 +55,7 @@ where
     }
 }
 
-impl<T> From<AutoGen<T>> for Option<T>
-where
-    T: core::fmt::Debug + PartialEq,
-{
+impl<T> From<AutoGen<T>> for Option<T> {
     fn from(value: AutoGen<T>) -> Option<T> {
         match value {
             AutoGen::Known(v) => Some(v),
@@ -55,7 +66,7 @@ where
 
 impl<T, DB: sqlx::Database> Encode<'_, DB> for AutoGen<T>
 where
-    T: core::fmt::Debug + PartialEq + for<'a> sqlx::Encode<'a, DB>,
+    T: for<'a> sqlx::Encode<'a, DB>,
     Self: Copy,
     Option<T>: for<'a> Encode<'a, DB>,
 {
@@ -66,17 +77,14 @@ where
 
 impl<T, DB: sqlx::Database> Type<DB> for AutoGen<T>
 where
-    T: core::fmt::Debug + PartialEq + Type<DB>,
+    T: Type<DB>,
 {
     fn type_info() -> DB::TypeInfo {
         <Option<T> as Type<DB>>::type_info()
     }
 }
 
-impl<T> PartialOrd for AutoGen<T>
-where
-    T: PartialOrd + Debug,
-{
+impl<T: PartialOrd> PartialOrd for AutoGen<T> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         match (self, other) {
             (AutoGen::Known(a), AutoGen::Known(b)) => a.partial_cmp(b),
@@ -87,10 +95,7 @@ where
     }
 }
 
-impl<T> From<Option<T>> for AutoGen<T>
-where
-    T: ts_rs::TS + core::fmt::Debug + PartialEq,
-{
+impl<T: ts_rs::TS> From<Option<T>> for AutoGen<T> {
     fn from(value: Option<T>) -> Self {
         match value {
             Some(t) => Self::Known(t),
@@ -100,10 +105,7 @@ where
 }
 
 /// `AutoGen<T>` acts like an option in JS/TS
-impl<T> ts_rs::TS for AutoGen<T>
-where
-    T: ts_rs::TS + core::fmt::Debug + PartialEq,
-{
+impl<T: ts_rs::TS> ts_rs::TS for AutoGen<T> {
     fn name() -> String {
         <Option<T> as ts_rs::TS>::name()
     }
diff --git a/backend/database/src/views.rs b/backend/database/src/views.rs
index 3272b33..270b557 100644
--- a/backend/database/src/views.rs
+++ b/backend/database/src/views.rs
@@ -89,7 +89,7 @@ impl LemmaWithKonsepView {
 
 impl IntoViewMap<LemmaWithKonsepView> for Vec<LemmaWithKonsepView> {
     type KEY = (i64, String);
-    type VALUE = KonsepHashMap;
+    type VALUE = KonsepHashMap<i64>;
 
     fn into_viewmap(self) -> HashMap<Self::KEY, Self::VALUE> {
         self.into_iter()
diff --git a/backend/database/transactions/postgres/count_items.sql b/backend/database/transactions/postgres/count_items.sql
new file mode 100644
index 0000000..3127a61
--- /dev/null
+++ b/backend/database/transactions/postgres/count_items.sql
@@ -0,0 +1,7 @@
+SELECT 
+    COUNT(DISTINCT lemma.id) AS lemmas,
+    COUNT(DISTINCT konsep.id) AS konseps,
+    COUNT(DISTINCT golongan_kata.id) as golongan_katas,
+    COUNT(DISTINCT cakupan.id) as cakupans,
+    COUNT(DISTINCT kata_asing.id) as kata_asings
+FROM lemma, konsep, golongan_kata, cakupan, kata_asing
\ No newline at end of file
diff --git a/backend/database/transactions/count_items.sql b/backend/database/transactions/sqlite/count_items.sql
similarity index 100%
rename from backend/database/transactions/count_items.sql
rename to backend/database/transactions/sqlite/count_items.sql