diff --git a/APP/app/src/androidTest/java/javinator9889/securepass/DatabaseTest.java b/APP/app/src/androidTest/java/javinator9889/securepass/DatabaseTest.java
new file mode 100644
index 0000000..3d19f41
--- /dev/null
+++ b/APP/app/src/androidTest/java/javinator9889/securepass/DatabaseTest.java
@@ -0,0 +1,88 @@
+package javinator9889.securepass;
+
+import android.content.Context;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.runner.AndroidJUnit4;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.Arrays;
+import java.util.Map;
+
+import javinator9889.securepass.io.database.DatabaseManager;
+import javinator9889.securepass.io.database.DatabaseOperations;
+
+/**
+ * Created by Javinator9889 on 20/05/2018.
+ */
+@RunWith(AndroidJUnit4.class)
+public class DatabaseTest {
+    private Context context = InstrumentationRegistry.getTargetContext();
+
+    private DatabaseOperations op;
+
+    @Before
+    public void initParams() {
+        DatabaseManager manager = DatabaseManager.newInstance(context, "1234");
+        this.op = DatabaseOperations.newInstance(manager);
+    }
+
+    @Test
+    public void insertIntoDB() {
+        long defaultCategoryId = op.registerDefaultCategory();
+        long newAccountId = op.registerNewAccount("cuenta", "password",
+                "icono", "descripción", defaultCategoryId);
+        long newCategoryId = op.registerNewCategory("cat2");
+        long newQRCodeId = op.registerQRCode(newAccountId, "qr1", "desc",
+                "1234");
+        long newSecurityCodeId = op.registerNewSecurityCodeSource("sec1");
+        long newFieldForSecCodeId = op.registerNewFieldForSecurityCodeSource("12345",
+                false,
+                newSecurityCodeId);
+        op.updateInformationForCategory("cat3", newCategoryId);
+        op.updateInformationForEntry("cuent", "pass", "icon",
+                "desc", newCategoryId, newAccountId);
+        op.updateInformationForQRCode(newAccountId, "qr1,2", "descq", "data",
+                newQRCodeId);
+        op.updateInformationForSecurityCode("secCode", newSecurityCodeId);
+        op.updateInformationForField("12321", true, newFieldForSecCodeId,
+                newSecurityCodeId);
+        printer();
+        op.registerNewAccount("cuenta", "password", "icono",
+                "descripción", defaultCategoryId);
+        op.registerNewCategory("cat2");
+        op.registerQRCode(newAccountId, "qr1", "desc",
+                "1234");
+        op.registerNewSecurityCodeSource("sec1");
+        op.registerNewFieldForSecurityCodeSource("12345",false,
+                newSecurityCodeId);
+        printer();
+        op.deleteCategory(newCategoryId);
+        op.deleteAccount(newAccountId);
+        op.deleteQRCode(newQRCodeId);
+        op.deleteSecurityCode(newSecurityCodeId);
+        op.deleteField(newFieldForSecCodeId);
+        printer();
+    }
+
+    private void printer() {
+        for (Map<String, Object> objectMap : op.getAllCategories())
+            System.out.println(objectMap);
+        for (Map<String, Object> objectMap : op.getAllEntries())
+            System.out.println(objectMap);
+        for (Map<String, Object> objectMap : op.getAllQRCodes())
+            System.out.println(objectMap);
+        for (Map<String, Object> objectMap : op.getAllSecurityCodes())
+            System.out.println(objectMap);
+        for (Map<String, Object> objectMap : op.getAllFields())
+            System.out.println(objectMap);
+    }
+
+    @After
+    public void closeConnection() {
+        op.finishConnection();
+    }
+}
diff --git a/APP/app/src/main/java/javinator9889/securepass/data/container/ClassContainer.java b/APP/app/src/main/java/javinator9889/securepass/data/container/ClassContainer.java
index ced9bec..1ddd6c4 100644
--- a/APP/app/src/main/java/javinator9889/securepass/data/container/ClassContainer.java
+++ b/APP/app/src/main/java/javinator9889/securepass/data/container/ClassContainer.java
@@ -81,17 +81,18 @@ public void storeDataInDB() {
                     entry.getAccountPassword(),
                     entry.getIcon(),
                     entry.getDescription(),
-                    entry.getCategory());
+                    entry.getCategory().getId());
         for (QRCode qrCode : qrCodes)
             operations.registerQRCode(
-                    qrCode.getEntry(),
+                    qrCode.getEntry().getId(),
                     qrCode.getName(),
                     qrCode.getDescription(),
                     qrCode.getQrData());
         for (SecurityCode code : securityCodes)
-            operations.registerNewSecurityCodeSource(code);
+            operations.registerNewSecurityCodeSource(code.getAccountName());
         for (Field field : fields)
-            operations.registerNewFieldForSecurityCodeSource(field);
+            operations.registerNewFieldForSecurityCodeSource(field.getCode(), field.isCodeUsed(),
+                    field.getSecurityCodeID());
         operations.finishConnection();
     }
 
diff --git a/APP/app/src/main/java/javinator9889/securepass/io/IOManager.java b/APP/app/src/main/java/javinator9889/securepass/io/IOManager.java
index 71e558c..2c64701 100644
--- a/APP/app/src/main/java/javinator9889/securepass/io/IOManager.java
+++ b/APP/app/src/main/java/javinator9889/securepass/io/IOManager.java
@@ -16,6 +16,8 @@
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.List;
 
 import javinator9889.securepass.R;
 import javinator9889.securepass.util.cipher.PasswordCipher;
@@ -28,14 +30,11 @@
 
 public class IOManager {
     private Context activityContext;
-    private InputStream sqlScriptInputFile;
     private File filesCache;
 
     private IOManager(@NonNull Context activityContext) {
         this.activityContext = activityContext;
         this.filesCache = activityContext.getCacheDir();
-        int sqlScript = R.raw.database_script;
-        this.sqlScriptInputFile = activityContext.getResources().openRawResource(sqlScript);
     }
 
     @NonNull
@@ -43,14 +42,22 @@ public static IOManager newInstance(Context activityContext) {
         return new IOManager(activityContext);
     }
 
-    public String loadSQLScript() throws IOException {
-        BufferedReader sqlStringsInFile = new BufferedReader(
-                new InputStreamReader(sqlScriptInputFile));
-        StringBuilder completeFileRead = new StringBuilder();
-        String currentLine;
-        while ((currentLine = sqlStringsInFile.readLine()) != null)
-            completeFileRead.append(currentLine).append("\n");
-        return completeFileRead.toString();
+    public List<String> loadSQLScript() throws IOException {
+        List<String> result = new ArrayList<>(5);
+        int[] sqlScripts = new int[]{R.raw.create_category, R.raw.create_entry, R.raw.create_qrcode,
+                R.raw.create_security_code, R.raw.create_field};
+        for (int sqlScript : sqlScripts) {
+            InputStream sqlScriptInputFile = this.activityContext.getResources()
+                    .openRawResource(sqlScript);
+            StringBuilder builder = new StringBuilder();
+            BufferedReader sqlStringsInFile = new BufferedReader(
+                    new InputStreamReader(sqlScriptInputFile));
+            String currentLine;
+            while ((currentLine = sqlStringsInFile.readLine()) != null)
+                builder.append(currentLine).append("\n");
+            result.add(builder.toString());
+        }
+        return result;
     }
 
     public void storePassword(@NonNull String userPassword) {
diff --git a/APP/app/src/main/java/javinator9889/securepass/io/database/DatabaseManager.java b/APP/app/src/main/java/javinator9889/securepass/io/database/DatabaseManager.java
index d95a795..b776d65 100644
--- a/APP/app/src/main/java/javinator9889/securepass/io/database/DatabaseManager.java
+++ b/APP/app/src/main/java/javinator9889/securepass/io/database/DatabaseManager.java
@@ -8,6 +8,7 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.util.List;
 
 import javinator9889.securepass.io.IOManager;
 import javinator9889.securepass.util.resources.ISharedPreferencesManager;
@@ -56,13 +57,15 @@ public void run() {
                         databaseFile,
                         databasePassword,
                         null);
-                String databaseScript;
+                List<String> databaseScripts;
                 ISharedPreferencesManager preferencesManager = SharedPreferencesManager
                         .newInstance();
                 try {
                     if (!preferencesManager.isDatabaseInitialized()) {
-                        databaseScript = IOManager.newInstance(databaseContext).loadSQLScript();
-                        database.execSQL(databaseScript);
+                        databaseScripts = IOManager.newInstance(databaseContext).loadSQLScript();
+                        for (String script : databaseScripts) {
+                            database.execSQL(script);
+                        }
                         DatabaseManager.this.createDefaultCategory();
                     }
                 } catch (IOException e) {
diff --git a/APP/app/src/main/java/javinator9889/securepass/io/database/DatabaseOperations.java b/APP/app/src/main/java/javinator9889/securepass/io/database/DatabaseOperations.java
index 30631d0..ef601d9 100644
--- a/APP/app/src/main/java/javinator9889/securepass/io/database/DatabaseOperations.java
+++ b/APP/app/src/main/java/javinator9889/securepass/io/database/DatabaseOperations.java
@@ -9,12 +9,10 @@
 import net.sqlcipher.database.SQLiteDatabase;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
-import javinator9889.securepass.data.entry.Category;
-import javinator9889.securepass.data.entry.Entry;
-import javinator9889.securepass.data.secret.Field;
-import javinator9889.securepass.data.secret.SecurityCode;
 import javinator9889.securepass.util.values.Constants.SQL;
 import javinator9889.securepass.util.values.DatabaseTables;
 
@@ -40,15 +38,19 @@ public static DatabaseOperations newInstance(DatabaseManager databaseManagerInst
     }
 
     public long registerDefaultCategory() {
-        ContentValues params = setParams(DatabaseTables.CATEGORY, "Global");
-        return database.insert(SQL.CATEGORY.NAME, null, params);
+//        ContentValues params = setParams(DatabaseTables.CATEGORY, "Global");
+        ContentValues params = new ContentValues();
+        params.put(SQL.CATEGORY.C_ID, 1);
+        params.put(SQL.CATEGORY.C_NAME, "Global");
+        return database.insertWithOnConflict(SQL.CATEGORY.NAME, null, params,
+                SQLiteDatabase.CONFLICT_IGNORE);
     }
 
     public long registerNewAccount(@NonNull String accountName, @NonNull String accountPassword,
                                    @NonNull String icon, @Nullable String description,
-                                   @NonNull Category entryCategory) {
+                                   long entryParentCategoryId) {
         ContentValues params = setParams(DatabaseTables.ENTRY, accountName, accountPassword, icon,
-                description, entryCategory.getId());
+                description, entryParentCategoryId);
         return database.insert(SQL.ENTRY.NAME, null, params);
     }
 
@@ -57,31 +59,33 @@ public long registerNewCategory(@NonNull String name) {
         return database.insert(SQL.CATEGORY.NAME, null, params);
     }
 
-    public long registerQRCode(@NonNull Entry sourceEntry, @NonNull String name,
+    public long registerQRCode(long sourceEntryId, @NonNull String name,
                                @Nullable String description, @NonNull String qrData) {
         ContentValues params = setParams(DatabaseTables.QR_CODE, name, description, qrData,
-                sourceEntry.getId());
+                sourceEntryId);
         return database.insert(SQL.QR_CODE.NAME, null, params);
     }
 
-    public long registerNewSecurityCodeSource(@NonNull SecurityCode securityCodeSource) {
+    public long registerNewSecurityCodeSource(@NonNull String securityCodeName) {
         ContentValues params = setParams(DatabaseTables.SECURITY_CODE,
-                securityCodeSource.getAccountName());
+                securityCodeName);
         return database.insert(SQL.SECURITY_CODE.NAME, null, params);
     }
 
-    public long registerNewFieldForSecurityCodeSource(@NonNull Field newField) {
+    public long registerNewFieldForSecurityCodeSource(@NonNull String fieldCode,
+                                                      boolean isCodeUsed,
+                                                      long parentSecurityCodeId) {
         ContentValues params = setParams(DatabaseTables.FIELD,
-                newField.getCode(), newField.isCodeUsed(), newField.getSecurityCodeID());
+                fieldCode, isCodeUsed, parentSecurityCodeId);
         return database.insert(SQL.FIELD.NAME, null, params);
     }
 
-    public void deleteAccount(int accountID) {
+    public void deleteAccount(long accountID) {
         String[] selectionArgs = setSelectionArgs(accountID);
         database.delete(SQL.ENTRY.NAME, SQL.DB_DELETE_ENTRY_WHERE_CLAUSE, selectionArgs);
     }
 
-    public void deleteCategory(int categoryID) {
+    public void deleteCategory(long categoryID) {
         String[] selectionArgs = setSelectionArgs(categoryID);
         ContentValues entryUpdatedValues = new ContentValues();
         entryUpdatedValues.put(SQL.ENTRY.E_PARENT_CATEGORY, 0);
@@ -92,19 +96,20 @@ public void deleteCategory(int categoryID) {
         database.delete(SQL.CATEGORY.NAME, SQL.DB_DELETE_CATEGORY_WHERE_CLAUSE, selectionArgs);
     }
 
-    public void deleteQRCode(int qrID) {
+    public void deleteQRCode(long qrID) {
         String[] selectionArgs = setSelectionArgs(qrID);
         database.delete(SQL.QR_CODE.NAME, SQL.DB_DELETE_QR_CODE_WHERE_CLAUSE, selectionArgs);
     }
 
-    public void deleteSecurityCode(int securityCodeID) {
+    public void deleteSecurityCode(long securityCodeID) {
         String[] selectionArgs = setSelectionArgs(securityCodeID);
         database.delete(SQL.FIELD.NAME,
                 SQL.DB_DELETE_FIELD_FROM_SECURITY_CODE_WHERE_CLAUSE, selectionArgs);
-        database.delete(SQL.SECURITY_CODE.NAME, SQL.DB_DELETE_CATEGORY_WHERE_CLAUSE, selectionArgs);
+        database.delete(SQL.SECURITY_CODE.NAME, SQL.DB_DELETE_SECURITY_CODE_WHERE_CLAUSE,
+                selectionArgs);
     }
 
-    public void deleteField(int fieldCodeID) {
+    public void deleteField(long fieldCodeID) {
         String[] selectionArgs = setSelectionArgs(fieldCodeID);
         database.delete(SQL.FIELD.NAME, SQL.DB_DELETE_FIELD_WHERE_CLAUSE, selectionArgs);
     }
@@ -113,69 +118,149 @@ public void updateInformationForEntry(@NonNull String accountName,
                                           @NonNull String accountPassword,
                                           @NonNull String icon,
                                           @Nullable String description,
-                                          @NonNull Category entryCategory,
-                                          int entryId) {
+                                          long parentEntryCategoryId,
+                                          long entryId) {
         ContentValues params = setParams(DatabaseTables.ENTRY,
                 accountName,
                 accountPassword,
                 icon,
                 description,
-                entryCategory.getId());
+                parentEntryCategoryId);
         String[] selectionArgs = setSelectionArgs(entryId);
         database.update(SQL.ENTRY.NAME, params, SQL.DB_UPDATE_ENTRY_WHERE_CLAUSE, selectionArgs);
     }
 
-    public void updateInformationForCategory(@NonNull String categoryName, int categoryId) {
+    public void updateInformationForCategory(@NonNull String categoryName, long categoryId) {
         ContentValues params = setParams(DatabaseTables.CATEGORY, categoryName);
         String[] selectionArgs = setSelectionArgs(categoryId);
         database.update(SQL.CATEGORY.NAME, params, SQL.DB_UPDATE_CATEGORY_WHERE_CLAUSE,
                 selectionArgs);
     }
 
-    public void updateInformationForQRCode(@NonNull Entry sourceEntry, @NonNull String name,
+    public void updateInformationForQRCode(long sourceEntryId, @NonNull String name,
                                            @Nullable String description, @NonNull String qrData,
-                                           int qrCodeId) {
+                                           long qrCodeId) {
         ContentValues params = setParams(DatabaseTables.QR_CODE, name,
                 description,
                 qrData,
-                sourceEntry.getId());
+                sourceEntryId);
         String[] selectionArgs = setSelectionArgs(qrCodeId);
         database.update(SQL.QR_CODE.NAME, params, SQL.DB_UPDATE_QR_CODE_WHERE_CLAUSE,
                 selectionArgs);
     }
 
-    public void updateInformationForSecurityCode(@NonNull SecurityCode modifiedSecurityCode) {
+    public void updateInformationForSecurityCode(@NonNull String newSecurityCodeName,
+                                                 long securityCodeId) {
         ContentValues params = setParams(DatabaseTables.SECURITY_CODE,
-                modifiedSecurityCode.getAccountName());
-        String[] selectionArgs = setSelectionArgs(modifiedSecurityCode.getId());
+                newSecurityCodeName);
+        String[] selectionArgs = setSelectionArgs(securityCodeId);
         database.update(SQL.SECURITY_CODE.NAME, params, SQL.DB_UPDATE_SECURITY_CODE_WHERE_CLAUSE,
                 selectionArgs);
     }
 
-    public void updateInformationForField(@NonNull Field modifiedField) {
-        ContentValues params = setParams(DatabaseTables.FIELD, modifiedField.getCode(),
-                modifiedField.isCodeUsed());
-        String[] selectionArgs = setSelectionArgs(modifiedField.getId());
+    public void updateInformationForField(@NonNull String newFieldCode,
+                                          boolean isCodeUsed,
+                                          long fieldId, long securityCodeId) {
+        ContentValues params = setParams(DatabaseTables.FIELD, newFieldCode,
+                isCodeUsed, securityCodeId);
+        String[] selectionArgs = setSelectionArgs(fieldId);
         database.update(SQL.FIELD.NAME, params, SQL.DB_UPDATE_FIELD_WHERE_CLAUSE, selectionArgs);
     }
 
-    private String[] loadDataIntoArray(Cursor sourceData) {
-        int numberOfColumns = sourceData.getColumnCount();
-        String[] currentData = new String[numberOfColumns];
-        for (int i = 0; i < numberOfColumns; ++i) {
-            switch (sourceData.getType(i)) {
-                case Cursor.FIELD_TYPE_INTEGER:
-                    currentData[i] = String.valueOf(sourceData.getInt(i));
-                    break;
-                default:
-                    currentData[i] = sourceData.getString(i);
-                    break;
-            }
+    private Map<String, Object> getValuesFromCursor(Cursor sourceData, DatabaseTables type) {
+        Map<String, Object> result = new HashMap<>();
+        switch (type) {
+            case CATEGORY:
+                long categoryId = sourceData.getLong(
+                        sourceData.getColumnIndexOrThrow(SQL.CATEGORY.C_ID));
+                String categoryName = sourceData.getString(
+                        sourceData.getColumnIndexOrThrow(SQL.CATEGORY.C_NAME));
+                result.put(SQL.CATEGORY.C_ID, categoryId);
+                result.put(SQL.CATEGORY.C_NAME, categoryName);
+                return result;
+            case ENTRY:
+                long entryId = sourceData.getLong(
+                        sourceData.getColumnIndexOrThrow(SQL.ENTRY.E_ID));
+                String entryName = sourceData.getString(
+                        sourceData.getColumnIndexOrThrow(SQL.ENTRY.E_ACCOUNT)
+                );
+                String entryPassword = sourceData.getString(
+                        sourceData.getColumnIndexOrThrow(SQL.ENTRY.E_PASSWORD)
+                );
+                String entryDescription = sourceData.getString(
+                        sourceData.getColumnIndexOrThrow(SQL.ENTRY.E_DESCRIPTION)
+                );
+                String entryIcon = sourceData.getString(
+                        sourceData.getColumnIndexOrThrow(SQL.ENTRY.E_ICON)
+                );
+                String entryParentCategory = sourceData.getString(
+                        sourceData
+                                .getColumnIndexOrThrow(SQL.ENTRY.E_PARENT_CATEGORY)
+                );
+                result.put(SQL.ENTRY.E_ID, entryId);
+                result.put(SQL.ENTRY.E_ACCOUNT, entryName);
+                result.put(SQL.ENTRY.E_PASSWORD, entryPassword);
+                result.put(SQL.ENTRY.E_DESCRIPTION, entryDescription);
+                result.put(SQL.ENTRY.E_ICON, entryIcon);
+                result.put(SQL.ENTRY.E_PARENT_CATEGORY, entryParentCategory);
+                return result;
+            case QR_CODE:
+                long qrCodeId = sourceData.getLong(
+                        sourceData.getColumnIndexOrThrow(SQL.QR_CODE.Q_ID)
+                );
+                String qrCodeName = sourceData.getString(
+                        sourceData.getColumnIndexOrThrow(SQL.QR_CODE.Q_NAME)
+                );
+                String qrCodeData = sourceData.getString(
+                        sourceData.getColumnIndexOrThrow(SQL.QR_CODE.Q_DATA)
+                );
+                String qrCodeDescription = sourceData.getString(
+                        sourceData
+                                .getColumnIndexOrThrow(SQL.QR_CODE.Q_DESCRIPTION)
+                );
+                long qrCodeParentEntryId = sourceData.getLong(
+                        sourceData.getColumnIndexOrThrow(SQL.QR_CODE.Q_PARENT_ENTRY)
+                );
+                result.put(SQL.QR_CODE.Q_ID, qrCodeId);
+                result.put(SQL.QR_CODE.Q_NAME, qrCodeName);
+                result.put(SQL.QR_CODE.Q_DATA, qrCodeData);
+                result.put(SQL.QR_CODE.Q_DESCRIPTION, qrCodeDescription);
+                result.put(SQL.QR_CODE.Q_PARENT_ENTRY, qrCodeParentEntryId);
+                return result;
+            case SECURITY_CODE:
+                long securityCodeId = sourceData.getLong(
+                        sourceData.getColumnIndexOrThrow(SQL.SECURITY_CODE.S_ID)
+                );
+                String securityCodeName = sourceData.getString(
+                        sourceData.getColumnIndexOrThrow(SQL.SECURITY_CODE.S_ACCOUNT_NAME)
+                );
+                result.put(SQL.SECURITY_CODE.S_ID, securityCodeId);
+                result.put(SQL.SECURITY_CODE.S_ACCOUNT_NAME, securityCodeName);
+                return result;
+            case FIELD:
+                long fieldId = sourceData.getLong(
+                        sourceData.getColumnIndexOrThrow(SQL.FIELD.F_ID)
+                );
+                String fieldCode = sourceData.getString(
+                        sourceData.getColumnIndexOrThrow(SQL.FIELD.F_CODE)
+                );
+                boolean isFieldUsed = sourceData.getInt(
+                        sourceData.getColumnIndexOrThrow(SQL.FIELD.F_USED)
+                ) == 1;
+                long fieldParentSecurityCode = sourceData.getLong(
+                        sourceData.getColumnIndexOrThrow(SQL.FIELD.F_PARENT_SECURITY_CODE)
+                );
+                result.put(SQL.FIELD.F_ID, fieldId);
+                result.put(SQL.FIELD.F_CODE, fieldCode);
+                result.put(SQL.FIELD.F_USED, isFieldUsed);
+                result.put(SQL.FIELD.F_PARENT_SECURITY_CODE, fieldParentSecurityCode);
+                return result;
+            default:
+                return result;
         }
-        return currentData;
     }
 
-    public List<String[]> getAllCategories() {
+    public List<Map<String, Object>> getAllCategories() {
         String sortOrder = SQL.CATEGORY.C_ID + " DESC";
         Cursor categoriesCursor = database.query(SQL.CATEGORY.NAME,
                 null,
@@ -184,17 +269,23 @@ public List<String[]> getAllCategories() {
                 null,
                 null,
                 sortOrder);
-        List<String[]> categoriesList = new ArrayList<>();
-        if (categoriesCursor.moveToFirst()) {
-            do {
-                categoriesList.add(loadDataIntoArray(categoriesCursor));
-            } while (categoriesCursor.moveToNext());
+        List<Map<String, Object>> itemsObtained = new ArrayList<>();
+        while (categoriesCursor.moveToNext()) {
+            itemsObtained.add(getValuesFromCursor(categoriesCursor, DatabaseTables.CATEGORY));
         }
         categoriesCursor.close();
-        return categoriesList;
+        return itemsObtained;
+//        List<String[]> categoriesList = new ArrayList<>();
+//        if (categoriesCursor.moveToFirst()) {
+//            do {
+//                categoriesList.add(loadDataIntoArray(categoriesCursor));
+//            } while (categoriesCursor.moveToNext());
+//        }
+//        categoriesCursor.close();
+//        return categoriesList;
     }
 
-    public List<String[]> getAllEntries() {
+    public List<Map<String, Object>> getAllEntries() {
         String sortOrder = SQL.ENTRY.E_ID + " DESC";
         Cursor entriesCursor = database.query(SQL.ENTRY.NAME,
                 null,
@@ -203,17 +294,15 @@ public List<String[]> getAllEntries() {
                 null,
                 null,
                 sortOrder);
-        List<String[]> entriesList = new ArrayList<>();
-        if (entriesCursor.moveToFirst()) {
-            do {
-                entriesList.add(loadDataIntoArray(entriesCursor));
-            } while (entriesCursor.moveToNext());
+        List<Map<String, Object>> entriesList = new ArrayList<>();
+        while (entriesCursor.moveToNext()) {
+            entriesList.add(getValuesFromCursor(entriesCursor, DatabaseTables.ENTRY));
         }
         entriesCursor.close();
         return entriesList;
     }
 
-    public List<String[]> getAllQRCodes() {
+    public List<Map<String, Object>> getAllQRCodes() {
         String sortOrder = SQL.QR_CODE.Q_ID + " DESC";
         Cursor qrCodesCursor = database.query(SQL.QR_CODE.NAME,
                 null,
@@ -222,17 +311,15 @@ public List<String[]> getAllQRCodes() {
                 null,
                 null,
                 sortOrder);
-        List<String[]> qrCodesList = new ArrayList<>();
-        if (qrCodesCursor.moveToFirst()) {
-            do {
-                qrCodesList.add(loadDataIntoArray(qrCodesCursor));
-            } while (qrCodesCursor.moveToNext());
+        List<Map<String, Object>> qrCodesList = new ArrayList<>();
+        while (qrCodesCursor.moveToNext()) {
+            qrCodesList.add(getValuesFromCursor(qrCodesCursor, DatabaseTables.QR_CODE));
         }
         qrCodesCursor.close();
         return qrCodesList;
     }
 
-    public List<String[]> getAllSecurityCodes() {
+    public List<Map<String, Object>> getAllSecurityCodes() {
         String sortOrder = SQL.SECURITY_CODE.S_ID + " DESC";
         Cursor securityCodesCursor = database.query(SQL.SECURITY_CODE.NAME,
                 null,
@@ -241,17 +328,16 @@ public List<String[]> getAllSecurityCodes() {
                 null,
                 null,
                 sortOrder);
-        List<String[]> securityCodesList = new ArrayList<>();
-        if (securityCodesCursor.moveToFirst()) {
-            do {
-                securityCodesList.add(loadDataIntoArray(securityCodesCursor));
-            } while (securityCodesCursor.moveToNext());
+        List<Map<String, Object>> securityCodesList = new ArrayList<>();
+        while (securityCodesCursor.moveToNext()) {
+            securityCodesList.add(getValuesFromCursor(securityCodesCursor,
+                    DatabaseTables.SECURITY_CODE));
         }
         securityCodesCursor.close();
         return securityCodesList;
     }
 
-    public List<String[]> getAllFields() {
+    public List<Map<String, Object>> getAllFields() {
         String sortOrder = SQL.FIELD.F_ID + " DESC";
         Cursor fieldsCursor = database.query(SQL.FIELD.NAME,
                 null,
@@ -260,11 +346,9 @@ public List<String[]> getAllFields() {
                 null,
                 null,
                 sortOrder);
-        List<String[]> fieldsList = new ArrayList<>();
-        if (fieldsCursor.moveToFirst()) {
-            do {
-                fieldsList.add(loadDataIntoArray(fieldsCursor));
-            } while (fieldsCursor.moveToNext());
+        List<Map<String, Object>> fieldsList = new ArrayList<>();
+        while (fieldsCursor.moveToNext()) {
+            fieldsList.add(getValuesFromCursor(fieldsCursor, DatabaseTables.FIELD));
         }
         fieldsCursor.close();
         return fieldsList;
@@ -285,13 +369,13 @@ private ContentValues setParams(DatabaseTables table, Object... values) {
                 params.put(SQL.ENTRY.E_PASSWORD, (String) values[1]);
                 params.put(SQL.ENTRY.E_ICON, (String) values[2]);
                 params.put(SQL.ENTRY.E_DESCRIPTION, (String) values[3]);
-                params.put(SQL.ENTRY.E_PARENT_CATEGORY, (int) values[4]);
+                params.put(SQL.ENTRY.E_PARENT_CATEGORY, (long) values[4]);
                 break;
             case QR_CODE:
-                params.put(SQL.QR_CODE.NAME, (String) values[0]);
+                params.put(SQL.QR_CODE.Q_NAME, (String) values[0]);
                 params.put(SQL.QR_CODE.Q_DESCRIPTION, (String) values[1]);
-                params.put(SQL.QR_CODE.Q_DATA, (String) values[3]);
-                params.put(SQL.QR_CODE.Q_PARENT_ENTRY, (int) values[4]);
+                params.put(SQL.QR_CODE.Q_DATA, (String) values[2]);
+                params.put(SQL.QR_CODE.Q_PARENT_ENTRY, (long) values[3]);
                 break;
             case SECURITY_CODE:
                 params.put(SQL.SECURITY_CODE.S_ACCOUNT_NAME, (String) values[0]);
@@ -299,13 +383,13 @@ private ContentValues setParams(DatabaseTables table, Object... values) {
             case FIELD:
                 params.put(SQL.FIELD.F_CODE, (String) values[0]);
                 params.put(SQL.FIELD.F_USED, (boolean) values[1]);
-                params.put(SQL.FIELD.F_PARENT_SECURITY_CODE, (int) values[3]);
+                params.put(SQL.FIELD.F_PARENT_SECURITY_CODE, (long) values[2]);
                 break;
         }
         return params;
     }
 
-    private String[] setSelectionArgs(int id) {
+    private String[] setSelectionArgs(long id) {
         return new String[]{String.valueOf(id)};
     }
 }
diff --git a/APP/app/src/main/java/javinator9889/securepass/util/values/Constants.java b/APP/app/src/main/java/javinator9889/securepass/util/values/Constants.java
index be51a17..70bd830 100644
--- a/APP/app/src/main/java/javinator9889/securepass/util/values/Constants.java
+++ b/APP/app/src/main/java/javinator9889/securepass/util/values/Constants.java
@@ -74,15 +74,11 @@ public static final class FIELD {
         // UPDATE SQL OPERATIONS
         public static String DB_UPDATE_FOR_DELETED_CATEGORY_WHERE_CLAUSE = "Entry.cidCategory = ?";
         public static String DB_UPDATE_ENTRY_WHERE_CLAUSE = "Entry.idEntry = ?";
-        public static String DB_UPDATE_CATEGORY_WHERE_CLAUSE = "UPDATE Category SET Category.name = ? WHERE" +
-                " Category.idCategory = ?";
-        public static String DB_UPDATE_QR_CODE_WHERE_CLAUSE = "UPDATE QRCode SET QRCode.name = ?," +
-                " QRCode.description = ?, QRCode.data = ?, QRCode.fidEntry = ? " +
-                "WHERE QRCode.idQRCode = ?";
-        public static String DB_UPDATE_SECURITY_CODE_WHERE_CLAUSE = "UPDATE SecurityCodes " +
-                "SET SecurityCodes.accountName = ? WHERE SecurityCodes.idSecurityCodes = ?";
-        public static String DB_UPDATE_FIELD_WHERE_CLAUSE = "UPDATE Fields SET Fields.code = ?, " +
-                "Fields.used = ? WHERE Fields.idField = ?";
+        public static String DB_UPDATE_CATEGORY_WHERE_CLAUSE = "Category.idCategory = ?";
+        public static String DB_UPDATE_QR_CODE_WHERE_CLAUSE = "QRCode.idQRCode = ?";
+        public static String DB_UPDATE_SECURITY_CODE_WHERE_CLAUSE =
+                "SecurityCodes.idSecurityCodes = ?";
+        public static String DB_UPDATE_FIELD_WHERE_CLAUSE = "Fields.idField = ?";
 
         // SELECT SQL OPERATIONS
         public static String DB_SELECT_CATEGORIES = "SELECT * FROM Categories";
diff --git a/APP/app/src/main/res/raw/create_category.sql b/APP/app/src/main/res/raw/create_category.sql
new file mode 100644
index 0000000..0e15f7d
--- /dev/null
+++ b/APP/app/src/main/res/raw/create_category.sql
@@ -0,0 +1,4 @@
+CREATE TABLE IF NOT EXISTS Category (
+  idCategory INTEGER NOT NULL DEFAULT 0,
+  name VARCHAR(45) NULL,
+  PRIMARY KEY (idCategory));
\ No newline at end of file
diff --git a/APP/app/src/main/res/raw/create_entry.sql b/APP/app/src/main/res/raw/create_entry.sql
new file mode 100644
index 0000000..6a3e250
--- /dev/null
+++ b/APP/app/src/main/res/raw/create_entry.sql
@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS Entry (
+  idEntry INTEGER NOT NULL DEFAULT 0,
+  account VARCHAR(100) NOT NULL,
+  password VARCHAR(180) NOT NULL,
+  icon VARCHAR(180) NULL,
+  description LONGBLOB NULL,
+  cidCategory INT NOT NULL,
+  PRIMARY KEY (idEntry),
+  CONSTRAINT fk_Entry_Category
+    FOREIGN KEY (cidCategory)
+    REFERENCES Category (idCategory)
+    ON DELETE NO ACTION
+    ON UPDATE CASCADE);
\ No newline at end of file
diff --git a/APP/app/src/main/res/raw/create_field.sql b/APP/app/src/main/res/raw/create_field.sql
new file mode 100644
index 0000000..76a5a1e
--- /dev/null
+++ b/APP/app/src/main/res/raw/create_field.sql
@@ -0,0 +1,11 @@
+CREATE TABLE IF NOT EXISTS Fields (
+    idField INTEGER NOT NULL DEFAULT 0,
+    code VARCHAR(180) NOT NULL,
+    used TINYINT NOT NULL DEFAULT 0,
+    fidSecurityCodes INTEGER NOT NULL,
+    PRIMARY KEY (idField),
+    CONSTRAINT fk_Fields_SecurityCodes
+        FOREIGN KEY (fidSecurityCodes)
+        REFERENCES SecurityCodes (idSecurityCodes)
+        ON DELETE CASCADE
+        ON UPDATE NO ACTION);
\ No newline at end of file
diff --git a/APP/app/src/main/res/raw/create_qrcode.sql b/APP/app/src/main/res/raw/create_qrcode.sql
new file mode 100644
index 0000000..08a2eae
--- /dev/null
+++ b/APP/app/src/main/res/raw/create_qrcode.sql
@@ -0,0 +1,12 @@
+CREATE TABLE IF NOT EXISTS QRCode (
+    idQRCode INTEGER NOT NULL DEFAULT 0,
+    name VARCHAR(45) NOT NULL,
+    description VARCHAR(180) NULL,
+    data LONGTEXT NOT NULL,
+    fidEntry INTEGER NOT NULL,
+    PRIMARY KEY (idQRCode),
+    CONSTRAINT fk_QRCode_Entry
+        FOREIGN KEY (fidEntry)
+        REFERENCES Entry (idEntry)
+        ON DELETE CASCADE
+        ON UPDATE NO ACTION);
\ No newline at end of file
diff --git a/APP/app/src/main/res/raw/create_security_code.sql b/APP/app/src/main/res/raw/create_security_code.sql
new file mode 100644
index 0000000..e205e39
--- /dev/null
+++ b/APP/app/src/main/res/raw/create_security_code.sql
@@ -0,0 +1,4 @@
+CREATE TABLE IF NOT EXISTS SecurityCodes (
+    idSecurityCodes INTEGER NOT NULL DEFAULT 0,
+    accountName VARCHAR(45) NOT NULL,
+    PRIMARY KEY (idSecurityCodes));
\ No newline at end of file
diff --git a/APP/app/src/main/res/raw/database_script.sql b/APP/app/src/main/res/raw/database_script.sql
index 17c5285..93b8515 100644
--- a/APP/app/src/main/res/raw/database_script.sql
+++ b/APP/app/src/main/res/raw/database_script.sql
@@ -1,86 +1,51 @@
--- -----------------------------------------------------
--- Schema securepassdb
--- -----------------------------------------------------
--- SCHEMAS ARE NOT ALLOWED ON SQLite
--- -----------------------------------------------------
-
--- -----------------------------------------------------
--- Table `securepassdb`.`Category`
--- -----------------------------------------------------
 CREATE TABLE IF NOT EXISTS `Category` (
-  `idCategory` INT NOT NULL DEFAULT 0,
-  `name` VARCHAR(45) NULL,
-  PRIMARY KEY (`idCategory`));
--- ENGINE = InnoDB;
-
+    `idCategory` INT NOT NULL DEFAULT 0,
+    `name` VARCHAR(45) NULL,
+    PRIMARY KEY (`idCategory`));
 
--- -----------------------------------------------------
--- Table `securepassdb`.`Entry`
--- -----------------------------------------------------
 CREATE TABLE IF NOT EXISTS `Entry` (
-  `idEntry` INT NOT NULL AUTO_INCREMENT,
-  `account` VARCHAR(180) NOT NULL,
-  `password` VARCHAR(180) NOT NULL,
-  `icon` VARCHAR(180) NULL,
-  `description` LONGBLOB NULL,
-  `cidCategory` INT NOT NULL,
-  PRIMARY KEY (`idEntry`, `cidCategory`),
-  INDEX `fk_Entry_Category1_idx` (`cidCategory` ASC),
-  CONSTRAINT `fk_Entry_Category1`
-    FOREIGN KEY (`cidCategory`)
-    REFERENCES `Category` (`idCategory`)
-    ON DELETE NO ACTION
-    ON UPDATE CASCADE);
--- ENGINE = InnoDB;
+    `idEntry` INT NOT NULL AUTO_INCREMENT,
+    `account` VARCHAR(180) NOT NULL,
+    `password` VARCHAR(180) NOT NULL,
+    `icon` VARCHAR(180) NULL,
+    `description` LONGBLOB NULL,
+    `cidCategory` INT NOT NULL,
+    PRIMARY KEY (`idEntry`, `cidCategory`),
+    INDEX `fk_Entry_Category1_idx` (`cidCategory` ASC),
+    CONSTRAINT `fk_Entry_Category1`
+        FOREIGN KEY (`cidCategory`)
+        REFERENCES `Category` (`idCategory`)
+        ON DELETE NO ACTION
+        ON UPDATE CASCADE);
 
-
--- -----------------------------------------------------
--- Table `securepassdb`.`QRCode`
--- -----------------------------------------------------
 CREATE TABLE IF NOT EXISTS `QRCode` (
-  `idQRCode` INT NOT NULL AUTO_INCREMENT,
-  `name` VARCHAR(45) NOT NULL,
-  `description` VARCHAR(180) NULL,
-  `data` LONGTEXT NOT NULL,
-  `fidEntry` INT NOT NULL,
-  PRIMARY KEY (`idQRCode`, `fidEntry`),
-  INDEX `fk_QRCode_Entry1_idx` (`fidEntry` ASC),
-  CONSTRAINT `fk_QRCode_Entry1`
-    FOREIGN KEY (`fidEntry`)
-    REFERENCES `Entry` (`idEntry`)
-    ON DELETE CASCADE
-    ON UPDATE NO ACTION);
--- ENGINE = InnoDB;
-
+    `idQRCode` INT NOT NULL AUTO_INCREMENT,
+    `name` VARCHAR(45) NOT NULL,
+    `description` VARCHAR(180) NULL,
+    `data` LONGTEXT NOT NULL,
+    `fidEntry` INT NOT NULL,
+    PRIMARY KEY (`idQRCode`, `fidEntry`),
+    INDEX `fk_QRCode_Entry1_idx` (`fidEntry` ASC),
+    CONSTRAINT `fk_QRCode_Entry1`
+        FOREIGN KEY (`fidEntry`)
+        REFERENCES `Entry` (`idEntry`)
+        ON DELETE CASCADE
+        ON UPDATE NO ACTION);
 
--- -----------------------------------------------------
--- Table `securepassdb`.`SecurityCodes`
--- -----------------------------------------------------
 CREATE TABLE IF NOT EXISTS `SecurityCodes` (
-  `idSecurityCodes` INT NOT NULL AUTO_INCREMENT,
-  `accountName` VARCHAR(45) NOT NULL,
-  PRIMARY KEY (`idSecurityCodes`));
--- ENGINE = InnoDB;
+    `idSecurityCodes` INT NOT NULL AUTO_INCREMENT,
+    `accountName` VARCHAR(45) NOT NULL,
+    PRIMARY KEY (`idSecurityCodes`));
 
-
--- -----------------------------------------------------
--- Table `securepassdb`.`Fields`
--- -----------------------------------------------------
 CREATE TABLE IF NOT EXISTS `Fields` (
-  `idField` INT NOT NULL AUTO_INCREMENT,
-  `code` VARCHAR(180) NOT NULL,
-  `used` TINYINT NOT NULL DEFAULT 0,
-  `fidSecurityCodes` INT NOT NULL,
-  PRIMARY KEY (`idField`, `fidSecurityCodes`),
-  INDEX `fk_Fields_SecurityCodes1_idx` (`fidSecurityCodes` ASC),
-  CONSTRAINT `fk_Fields_SecurityCodes1`
-    FOREIGN KEY (`fidSecurityCodes`)
-    REFERENCES `SecurityCodes` (`idSecurityCodes`)
-    ON DELETE CASCADE
-    ON UPDATE NO ACTION);
--- ENGINE = InnoDB;
-
-
-SET SQL_MODE=@OLD_SQL_MODE;
-SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;
-SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS;
+    `idField` INT NOT NULL AUTO_INCREMENT,
+    `code` VARCHAR(180) NOT NULL,
+    `used` TINYINT NOT NULL DEFAULT 0,
+    `fidSecurityCodes` INT NOT NULL,
+    PRIMARY KEY (`idField`, `fidSecurityCodes`),
+    INDEX `fk_Fields_SecurityCodes1_idx` (`fidSecurityCodes` ASC),
+    CONSTRAINT `fk_Fields_SecurityCodes1`
+        FOREIGN KEY (`fidSecurityCodes`)
+        REFERENCES `SecurityCodes` (`idSecurityCodes`)
+        ON DELETE CASCADE
+        ON UPDATE NO ACTION);
\ No newline at end of file