Using expo sqlite prepopulated db in production mode

i was able to copy and use a prepopulated database using

copyDatabase=async()=> {
  let databaseName = 'uuzaposfour.db'
	try {
	  await FileSystem.makeDirectoryAsync(`${FileSystem.documentDirectory}SQLite`, {
	    intermediates: true
	  });
	  const localDatabase = await FileSystem.getInfoAsync(`${FileSystem.documentDirectory}SQLite/${databaseName}`);
	  if ( !localDatabase.exists ) {
	    FileSystem.downloadAsync(
	      Asset.fromModule(require('../../assets/db/olddbs.db')).uri,
	      `${FileSystem.documentDirectory}SQLite/${databaseName}`
	    ).then(({ uri }) => {
        Toast.show('Copying Database')
	     // alert('✅ Database copy to : ' + uri);
	    })
	    .catch(error => {
        Toast.show('Copy error')
        //alert('❗️ Database copy error : ' + error);
	    })
	  } else {
     // Toast.show('Database already updated')
     Toast.show('✅ Database already Configured');
	  }
	} catch (error) {
    Toast.show('❗️ Error : ' + error)
	  //alert('❗️ Error : ' + error);
	}
}

the above copies the database well, problem is when am running the the app using expo cli the app runs smoothly but when build an apk some tables are working while others are not, am using redux for state management and below is code from two action scripts:
THIS ONE DOES NOT WORK

import {EXPENSE_NAME_CHANGED,EXPENSE_AMOUNT_CHANGED,EXPENSE_SAVED,FETCHING_EXPENSES,EXPENSE_DELETED,EXPENSE_UPDATED,
  EXPENSE_NOTE_CHANGED,FETCHING_EXPENSE_SUM} from './types'
import { ActionSheet } from 'native-base';
import * as SQLite from 'expo-sqlite'
const db = SQLite.openDatabase('uuzaposfour.db')

import Toast from 'react-native-simple-toast';
export const expensenameChanged=(text)=>{
  return{type:EXPENSE_NAME_CHANGED,payload:text}
}
export const expenseamountChanged=(text)=>{
    return{type:EXPENSE_AMOUNT_CHANGED,payload:text}
  }
export const expensenoteChanged=(text)=>{
    return{type:EXPENSE_NOTE_CHANGED,payload:text}
  }

export const saveExpense = (name,amount,note,to) =>{
 

  return async(dispatch)=>{
           await  db.transaction(tx => {
      tx.executeSql('INSERT INTO expenses (title,amount,note,date) VALUES (?,?,?,?)', [name,amount,note,to],
        (txObj, resultSet) =>{
          dispatch({type:EXPENSE_SAVED})
          Toast.show('Expense saved')},
        (txObj, error) => console.log('Error', error))
   })
//    await  db.transaction(tx => {
//     tx.executeSql('UPDATE drawer SET amount = amount - ? WHERE date = ?', [amount,to],
//       (txObj, resultSet) =>{
//         dispatch({type:EXPENSE_SAVED})
//         console.log('SAVED')
//         console.log(resultSet)},
//       (txObj, error) => console.log('Error', error))
//  })
  }
}

 export const getExpenses = () => {
   return (dispatch)=>{
        db.transaction(tx => {
         // sending 4 arguments in executeSql
         tx.executeSql('SELECT * FROM expenses', null, // passing sql query and parameters:null
           // success callback which sends two things Transaction object and ResultSet Object
           (txObj, { rows: { _array } }) => {
            dispatch({type:FETCHING_EXPENSES,payload:_array})
             } ,
           // failure callback which sends two things Transaction object and Error
           (txObj, error) => console.log('Error ', error)
           ) // end executeSQL
       }) // end transaction


   }
 }

export const deleteExpense = (id) =>{
  return async(dispatch)=>{
           await  db.transaction(tx => {
      tx.executeSql('DELETE FROM expenses WHERE id = ?', [id],
        (txObj, resultSet) =>{
          dispatch({type:EXPENSE_DELETED})
          console.log('deleted')},
        (txObj, error) => console.log('Error', error))
   })
  }
}

export const updateExpense = (id) =>{
  return async(dispatch)=>{
           await  db.transaction(tx => {
      tx.executeSql('UPDATE expenses WHERE id = ?', [id],
        (txObj, resultSet) =>{
          dispatch({type:EXPENSE_UPDATED})
          console.log('deleted')},
        (txObj, error) => console.log('Error', error))
   })
  }
}


export const getExpense = ({from,to}) => {
  return (dispatch)=>{
       db.transaction(tx => {
        // sending 4 arguments in executeSql
        tx.executeSql('SELECT * FROM expenses WHERE date BETWEEN ? AND ?', [from, to], // passing sql query and parameters:null
          // success callback which sends two things Transaction object and ResultSet Object
          (txObj, { rows: { _array } }) => {
            dispatch({type:FETCHING_EXPENSES,payload:_array})
            console.log('EXPENSES ARE')
            console.log(JSON.stringify(_array))} ,
          // failure callback which sends two things Transaction object and Error
          (txObj, error) => console.log('Error ', error)
          ) // end executeSQL
      }) // end transaction

      db.transaction(tx => {
        // sending 4 arguments in executeSql
        tx.executeSql('SELECT SUM(note) FROM expenses WHERE date BETWEEN ? AND ? ', [from, to], // passing sql query and parameters:null
          // success callback which sends two things Transaction object and ResultSet Object
          (txObj, { rows: { _array } }) => {
            let expensesum = _array[0][Object.keys(_array[0])[0]]
            dispatch({type:FETCHING_EXPENSE_SUM,payload:expensesum})
            // console.log('SEXPENSE SUM')
            // console.log(expensesum)
          } ,
          // failure callback which sends two things Transaction object and Error
          (txObj, error) => console.log('Error ', error)
          ) // end executeSQL
      }) 

  }
}

THIS ONE WORKS IN APK am able to save to perform CRUD on a product

import axios from 'axios';
import * as ImagePicker from 'expo-image-picker';
import {CAMERA_IMAGE_SUCCESS,PRODUCT_NAME_CHANGED,PRODUCT_DESCRIPTION_CHANGED,
  PRODUCT_QUANTITY_CHANGED,PRODUCT_CATEGORY_CHANGED,PRODUCT_COST_CHANGED,PRODUCT_PRICE_CHANGED,PRODUCT_WARN_CHANGED,
  PRODUCT_SAVED,FETCHING_PRODUCTS,QUANTITY_MODAL,QUANTITY_MODAL_CLOSE,ITEM_EDITED,PRODUCT_DELETED,SEARCH_TERM,
  SEARCH_PRODUCTS,ADD_TO_PO,REMOVE_FROM_PO,UPDATE_PO_QUANTITY,UPDATE_PO_COST,PO_SAVED,STOCK_SAVED,FETCHING_POS,
  FETCHING_PO_ITEM,UNIT_CHANGED,SEARCH_FLATLIST,MONEY_CHANGED,DRAWER_SAVED,GET_DRAWER_BALANCE} from './types'
import * as Permissions from 'expo-permissions';
import Constants from 'expo-constants';
import Toast from 'react-native-simple-toast';
import * as SQLite from 'expo-sqlite'


const db = SQLite.openDatabase('uuzaposfour.db')


export const takePictureAsync =  () => {
  return async (dispatch) => {
    let permissionResult = await ImagePicker.requestCameraPermissionsAsync();
    if (permissionResult.granted === false) {
      alert('Permission to access camera roll is required!');
      return;
    }
    const result = await ImagePicker.launchCameraAsync()
    let image = result.uri
    console.log(result)
    dispatch({
      type: CAMERA_IMAGE_SUCCESS,
      payload: image })

  }
  
};

export const openImagePickerAsync =  () => {
  return async (dispatch) => {
    let permissionResult = await ImagePicker.requestCameraRollPermissionsAsync();

    if (permissionResult.granted === false) {
      alert('Permission to access camera roll is required!');
      return;
    }
    let result = await ImagePicker.launchImageLibraryAsync({
      mediaTypes: ImagePicker.MediaTypeOptions.All,
      base64: true,
     
      allowsEditing: true,
      aspect: [4, 3],
      quality: 1
    });
    console.log(result)
    let image = result.uri;
    let image64 = result.base64
    dispatch({
      type: CAMERA_IMAGE_SUCCESS,
      payload: image })
  }
 
  
}


export const getPermissionAsync = async () => {
  return async () =>{
  if (Constants.platform.ios) {
    const { status } = await Permissions.askAsync(Permissions.CAMERA_ROLL);
    if (status !== 'granted') {
      alert('Sorry, we need camera roll permissions to make this work!');
    }

  }
}
}



export const nameChanged=(text)=>{
  return {type: PRODUCT_NAME_CHANGED, 
    payload: text}
}

export const descChanged=(text)=>{
  return {type: PRODUCT_DESCRIPTION_CHANGED, 
    payload: text}
}


export const warnChanged=(text)=>{
  return {type: PRODUCT_WARN_CHANGED, 
    payload: text}
}
export const quantityChanged=(text)=>{ 
  return {type: PRODUCT_QUANTITY_CHANGED, 
    payload: text}
}


export const categoryChanged=(itemIndex)=>{
  return {type: PRODUCT_CATEGORY_CHANGED, 
    payload: itemIndex}
}

export const costChanged=(text)=>{
  return {type: PRODUCT_COST_CHANGED, 
    payload: text}
}

export const priceChanged=(text)=>{
  return {type: PRODUCT_PRICE_CHANGED, 
    payload: text}
}

export const saveProduct = ({name, price,cost,quantity,warn,description,image,expiredate}) =>{
  return async(dispatch)=>{
           await  db.transaction(tx => {
      tx.executeSql('INSERT INTO products (name,price,cost,quantity,warn,image,stock,expiredate) values (?,?,?,?,?,?,?,?)', [name, price,cost,'1',warn,image,quantity,expiredate],
        (txObj, resultSet) =>{
          dispatch({type:PRODUCT_SAVED})
          console.log(resultSet)},
        (txObj, error) => console.log('Error', error))
   })
  }
}

export const getProducts = () => {
  return (dispatch)=>{
       db.transaction(tx => {
        // sending 4 arguments in executeSql
        tx.executeSql('SELECT * FROM products', null, // passing sql query and parameters:null
          // success callback which sends two things Transaction object and ResultSet Object
          (txObj, { rows: { _array } }) => {
            dispatch({type:FETCHING_PRODUCTS,payload:_array})
            console.log('_array PRODUCTS')
            console.log(JSON.stringify(_array))} ,
          // failure callback which sends two things Transaction object and Error
          (txObj, error) => console.log('Error ', error)
          ) // end executeSQL
      }) // end transaction
  }
}

export const qtyModalV = () =>{
  return{type:QUANTITY_MODAL}
}

export const qtyModalC = () =>{
  return{type:QUANTITY_MODAL_CLOSE}
}

// export const updateProductprice = (id) =>{
//   return async(dispatch)=>{
//            await  db.transaction(tx => {
//       tx.executeSql('UPDATE categories WHERE id = ?', [id],
//         (txObj, resultSet) =>{
//           dispatch({type:CATEGORY_UPDATED})
//           console.log('deleted')},
//         (txObj, error) => console.log('Error', error))
//    })
//   }
// }

export const updateProductqty = ({id,qty}) =>{
  
  return async(dispatch)=>{
           await  db.transaction(tx => {
      tx.executeSql('UPDATE products SET stock = stock + ? WHERE id = ?', [qty,id],
        (txObj, resultSet) =>{
          dispatch({type:ITEM_EDITED})
          Toast.show('login successful');},
        (txObj, error) => console.log('Error', error))
   })
  }
}

// export const updateProductwarn = (id,warn) =>{
//   return async(dispatch)=>{
//            await  db.transaction(tx => {
//       tx.executeSql('UPDATE categories WHERE id = ?', [id],
//         (txObj, resultSet) =>{
//           dispatch({type:CATEGORY_UPDATED})
//           console.log('deleted')},
//         (txObj, error) => console.log('Error', error))
//    })
//   }
// }

export const updateProductname = ({id,name}) =>{
  
  return async(dispatch)=>{
           await  db.transaction(tx => {
      tx.executeSql('UPDATE products SET name = ? WHERE id = ?', [name,id],
        (txObj, resultSet) =>{
          dispatch({type:ITEM_EDITED})
          Toast.show('Product name changed')},
        (txObj, error) => console.log('Error', error))
   })
  }
}


export const updateProductprice = ({id,price}) =>{
  
  return async(dispatch)=>{
           await  db.transaction(tx => {
      tx.executeSql('UPDATE products SET price = ? WHERE id = ?', [price,id],
        (txObj, resultSet) =>{
          dispatch({type:ITEM_EDITED})
          Toast.show('Product price changed')},
        (txObj, error) => console.log('Error', error))
   })
  }
}

export const updateProductwarn = ({id,warn}) =>{
  
  return async(dispatch)=>{
           await  db.transaction(tx => {
      tx.executeSql('UPDATE products SET warn = ? WHERE id = ?', [warn,id],
        (txObj, resultSet) =>{
          dispatch({type:ITEM_EDITED})
          Toast.show('Product warn quantity changed')},
        (txObj, error) => console.log('Error', error))
   })
  }
}

export const updateProductCost = ({id,cost}) =>{
  return async(dispatch)=>{
           await  db.transaction(tx => {
      tx.executeSql('UPDATE products SET cost = ? WHERE id = ?', [cost,id],
        (txObj, resultSet) =>{
          dispatch({type:ITEM_EDITED})
          Toast.show('Product cost changed')},
        (txObj, error) => console.log('Error', error))
   })
  }
}

export const deleteItem=(id)=>{
  
    return async(dispatch)=>{
             await  db.transaction(tx => {
        tx.executeSql('DELETE FROM products WHERE id = ?', [id],
          (txObj, resultSet) =>{
            dispatch({type:PRODUCT_DELETED})
            Toast.show('Product deleted')},
          (txObj, error) => console.log('Error', error))
     })
    }
  
}

export const Searchterm = (text) =>{
 
  return{type:SEARCH_TERM, payload:text}
}

export const Searchproducts=(search) =>{
  return{type:SEARCH_PRODUCTS, payload:search}
}


export const addToPO =  (Group) => {
  return (dispatch) =>{
      dispatch({
          type:ADD_TO_PO, 
          payload: Group}); 
          Toast.show('Item Added to Purchase Order');  
    }          
}

export const removeFromPO=  (item) => {
  return (dispatch) =>{
      dispatch({
          type:REMOVE_FROM_PO, 
          payload: item.id}); 
          Toast.show('Item has been removed from Purchase Order');  
          
    }
}

export const UpdatePOQuantity = (value, item) => {
  
  return (dispatch) =>{
      dispatch({
          type:UPDATE_PO_QUANTITY, 
          payload:  {value,item}});      
    }
}

export const UpdatePOCost = (value, item) => {
  
  return (dispatch) =>{
      dispatch({
          type:UPDATE_PO_COST, 
          payload:  {value,item}});      
    }
}

export const savePurchaseOrder=(po,datetime,txid)=>{
  return async(dispatch)=>{
    po.forEach(item => {
        db.transaction(tx => {           
            tx.executeSql('INSERT INTO purchaseorder (title, quantity,cost,transactionid,date,productid) values (?,?,?,?,?,?)', [item.name,item.quantity,item.cost,txid,datetime,item.id],
              (txObj, resultSet) =>{
                dispatch({type:PO_SAVED})
                Toast.show('Purchase order added')},
              (txObj, error) => console.log('Error', error))
         })
         db.transaction(tx => {           
          tx.executeSql('UPDATE products SET stock = stock + ? WHERE id = ? ', [item.quantity, item.id],
            (txObj, resultSet) =>{
              dispatch({type:STOCK_SAVED})
              console.log('STOCK UPDATED')},
            (txObj, error) => console.log('Error', error))
       })


    });

}
}

export const searchPurchaseOrders = ({fromdate,todate})=>{
  
  return (dispatch)=>{
    db.transaction(tx => {
     // sending 4 arguments in executeSql
     tx.executeSql('SELECT * FROM purchaseorder WHERE date BETWEEN ? AND ? ', [fromdate,todate], // passing sql query and parameters:null
       // success callback which sends two things Transaction object and ResultSet Object
       (txObj, { rows: { _array } }) => {
         console.log('PURCHASE ORDERS ARE')
         console.log(_array)
         dispatch({type:FETCHING_POS,payload:_array})
        
         console.log(JSON.stringify(_array))} ,
       // failure callback which sends two things Transaction object and Error
       (txObj, error) => console.log('Error ', error)
       ) // end executeSQL
   }) // end transaction

  //  db.transaction(tx => {
  //    // sending 4 arguments in executeSql
  //    tx.executeSql('SELECT SUM(cost) FROM expenses WHERE date BETWEEN ? AND ? ', [from, to], // passing sql query and parameters:null
  //      // success callback which sends two things Transaction object and ResultSet Object
  //      (txObj, { rows: { _array } }) => {
  //        let expensesum = _array[0][Object.keys(_array[0])[0]]
  //        dispatch({type:FETCHING_EXPENSE_SUM,payload:expensesum})
  //        // console.log('SEXPENSE SUM')
  //        // console.log(expensesum)
  //      } ,
  //      // failure callback which sends two things Transaction object and Error
  //      (txObj, error) => console.log('Error ', error)
  //      ) // end executeSQL
  //  }) 

}
}


export const POitem = (Group) =>{
  return(dispatch)=>{
    let id = Group.transactionid
    db.transaction(tx => {
      // sending 4 arguments in executeSql
      tx.executeSql('SELECT id,title,cost,quantity,TransactionID,date FROM purchaseorder WHERE Transactionid = ?', [id], // passing sql query and parameters:null
        // success callback which sends two things Transaction object and ResultSet Object
        (txObj, { rows: { _array } }) => {
          dispatch({type:FETCHING_PO_ITEM,payload:_array})
          } ,
        // failure callback which sends two things Transaction object and Error
        (txObj, error) => console.log('Error ', error)
        ) // end executeSQL
    })
  }

}

export const productUnit = (itemValue) =>{
  return{type:UNIT_CHANGED,payload:itemValue }
}

export const setSearchTerm = (newData) =>{
  return{type:SEARCH_FLATLIST,payload:newData}
}


export const moneyChanged = (text) =>{
    return{type:MONEY_CHANGED,payload:text}
}

export const saveDrawer = ({money,dateTime}) =>{
  return (dispatch)=>{
    db.transaction(tx => {           
      tx.executeSql('INSERT INTO drawer (amount,date) values (?,?)', [money,dateTime],
        (txObj, resultSet) =>{
          dispatch({type:DRAWER_SAVED})
         },
        (txObj, error) => console.log('Error', error))
   })
  }
}


export const editDrawer = ({money,dateTime}) =>{
  return (dispatch)=>{
    db.transaction(tx => {           
      tx.executeSql('UPDATE drawer SET amount = amount + ? WHERE date(date) = ?', [money,dateTime],
        (txObj, resultSet) =>{
          dispatch({type:DRAWER_SAVED})
         },
        (txObj, error) => console.log('Error', error))
   })
  }
}

export const getDrawerBalance = ({dateTime}) =>{
  return (dispatch)=>{
    db.transaction(tx => {           
      tx.executeSql('SELECT * FROM drawer WHERE date = ?', [dateTime],
        (txObj, resultSet) =>{
          if(resultSet.rows.length <= 0){
            dispatch({type:GET_DRAWER_BALANCE,payload:0})  
          }else{
          dispatch({type:GET_DRAWER_BALANCE,payload:resultSet.rows._array[1].amount})
          
        }
        },
        (txObj, error) => console.log('Error', error))
   })
  }
}

export const addtoDrawer = ({money,dateTime}) =>{
  return (dispatch)=>{
    db.transaction(tx => {           
      tx.executeSql('UPDATE drawer SET amount = amount + ? WHERE date = ?', [money,dateTime],
        (txObj, resultSet) =>{
          dispatch({type:DRAWER_SAVED})
         },
        (txObj, error) => console.log('Error', error))
   })
  }
}

export const allDrawer = () =>{
  return (dispatch)=>{
    db.transaction(tx => {           
      tx.executeSql('SELECT * FROM drawer', [],
        (txObj, resultSet) =>{
          dispatch({type:DRAWER_SAVED})
          console.log(resultSet.rows._array)},
        (txObj, error) => console.log('Error', error))
   })
  }
}