I have to create c# api that fetch large data from database, the data is huge and it has to be stored in object of api and memory data. Please how do I do that
I am expecting to store the data in buffer
Related
Recently I came across ODS(operational Data Store) in my work. I haven't got some points cleared about ODS.
Is ODS a SQL type or NOSQL type?
Can ODS extract data from both SQL and NOSQL db? Is so how they are stored in ODS at same time?
Does ODSes hold real time data or nearly real time data?
Is ODSes main purpose is to act as sink to multiple dbs and do some analytics over the data?
I have an iOS app written in Swift that requests data from a server, the server responds with the requested data in JSON format and the app serializes that data into a Core Data object to cache it.
The point of this being that the client doesn't have to keep re-requesting the data from the server. It's worth noting that this data could be around 300 KB - 1 MB because it has the potential to contain alot of text and an image.
The data can easily be re-requested from the server if needed. So my question is how would I determine when it is an appropriate time to delete the object from Core Data so that the app doesn't keep storing more and more until the whole device HDD is full (or just generally using lots of HDD space)? What is the general strategy in a situation like this?
EDIT - For more context on how the app works. Users can search for data which is displayed in a UICollectionView. The server responds to the search query with an array of IDs of the relevant database objects and then the client will request them individually when the UICollectionView needs to display the data. When the client makes a request it first checks if its in memory, if not then checks core data and finally requests the data from the server if its not in core data. If it is pulled from core data then the client will tell the server the objects id and the version it has and the server will respond by either saying it's up-to-date or with the relevant updated information. I expect that most objects will never be updated but there is always a possibility
My program uses Restkit with Coredata.
I need to persist 3 entities in the local storage so that I don't have to download a huge payload every time I need the data.
I also need the data to be refreshed when I want. The data should be refreshed in a way that only the changed objects will come through.
What is the best practice to do so in a system with CoreData and Restkit?
I see that Restkit used to have a RKSyncManager but not anymore..
I have a local database implemented in my iOS app using Core Data that is populated from a backend driven by Parse.
I want to have a Core Data entity that has as an attribute a PFFile (a parse file object). Core Data doesn't support PFFiles but it does support NSData.
How could I get a NSData representation of my PFFile?
Call getDataInBackgroundWithBlock: on the file.
Note that storing the data on disk and storing the path you saved it at is usually a better idea than storing the data in Core Data.
My IOS App periodically collects data that is time and location stamped (from GPS). That data is sent to a server if the app is online at the time the data is collected. BUT, if a data connection is not available I want the data cached to the iPhone/iPad until a data connection is obtained. When the connection is restored the data is uploaded and the cache is cleared. The data is in the form of an array of strings of SQL. Typically the array might contain a dozen or few dozen strings--nothing too large. The data should be persistent until it is cleared even if the app or device is shut down. Suggestions?
Have you thought about using NSUserDefaults for small amounts of data it is a value, key map solution and very simple. For large amounts of data something like JSON is good. Simply make the JSON when the data is created and then when connection in the app is detected parse the JSON and send it to the server.
I think the best way is to work with CoreData or you store the values in a local file.