Getting Started with Core data

Getting started with Core dataTags: Core dataiosiosios data Access database data persistence Brief introduction

Core data is a framework that appears after IOS5, which provides object-relational mapping (ORM) functionality that enables you to convert OC objects into data, store them in SQLite database files, and restore data saved in a database to OC objects. During this data operation, we do not need to write any SQL statements, which is somewhat similar to the famous Hibernate persistence framework, but the feature is definitely not hibernate powerful. Simply use the description to describe its function:

On the left is the relational model, that is, the database, the database has a person table, the person table contains ID, name, age three fields, and there are 2 records;

On the right is the object model, you can see that there are 2 OC objects;

With the core data framework, we can easily convert 2 of records in a database into 2 OC objects, or you can easily save 2 OC objects into a database, become 2 table records, and not write an SQL statement.

The model files are in core data, the objects that need to be mapped are called entities (entity), and the model files of core data are used to describe all the entity and entity attributes in the app. Here is an example of a person (people) and a card (identity card) 2 entities, first look at the relationship between entity attributes and entities:

The person entity has: name, age, card (ID) three attributes
The card entity has: no (number), person (people) two attributes

Next look at the process of creating the model file:
1. Select a template


2. Adding entities


3. Add 2 basic attributes for person


4. Add the 1 Basic properties of a card



5. Establish the relationship between card and person

The figure in the right indicates that there is a person attribute in the card that has the type of man, the purpose of which is to set up a one-to-two relationship between a card and someone (which is recommended), and after adding the inverse attribute You will find that the inverse attribute in the card is also automatically mended.

About Nsmanagedobject

1. Objects fetched from the database via core data are Nsmanagedobject objects by default


The 2.NSManagedObject mode of operation is somewhat similar to the Nsdictionary object, which accesses all entity properties via key-value pairs.

1> Setvalue:forkey: Store attribute value (property name is key)

2> Valueforkey: Get Property Value (property name is key)


Core objects in the CoreData

Note: Black denotes the class name, and red indicates a property within the class
Summary of development steps:
1. Initialize the Nsmanagedobjectmodel object, load the model file, and read all the entity information in the app
2. Initialize Nspersistentstorecoordinator object, add Persistence library (take SQLite database here)
3. Initialize the Nsmanagedobjectcontext object, get the context object operation entity, and perform crud operations

Code implementation first add Coredata.framework and import the main header file <CoreData/CoreData.h>


1. Setting up the context
[Java]View Plaincopy

2. To load a model file from an application package
4. Nsmanagedobjectmodel *model = [Nsmanagedobjectmodel Mergedmodelfrombundles:nil];
6. Incoming model object, initializing Nspersistentstorecoordinator
8. Nspersistentstorecoordinator *PSC = [[[Nspersistentstorecoordinator alloc] Initwithmanagedobjectmodel:model] Autorelease];
10. To build the path to the SQLite database file
12. NSString *docs = [Nssearchpathfordirectoriesindomains (nsdocumentdirectory, Nsuserdomainmask, YES) lastObject];
14. Nsurl *url = [Nsurl fileurlwithpath:[docs stringbyappendingpathcomponent:@"Person.data"]];
16. Add a persistent repository, where SQLite is used as the repository
18. Nserror *error = nil;
20. Nspersistentstore *store = [PSC addpersistentstorewithtype:nssqlitestoretype configuration:nil URL:url Options:nil error:&error];
22. if (store = = nil) { //Direct Throw exception
24. [NSException raise:@"Add Database Error" format:@"%@", [Error localizeddescription]];
26. }
28. Initialize context, set Persistentstorecoordinator property
30. Nsmanagedobjectcontext *context = [[Nsmanagedobjectcontext alloc] init];
32. Context.persistentstorecoordinator = PSC;
34. After use, remember to [context release];

2. Adding data to the database
[Java]View Plaincopy

2. Incoming context, creating a person entity object
4. Nsmanagedobject *person = [nsentitydescription insertnewobjectforentityforname:@"Person" inmanagedobjectcontext  : Context];
6. Set simple properties for person
8. [Person setvalue:@"MJ" forkey:@"name"];
10. [Person Setvalue:[nsnumber numberwithint:] forkey:@' age ';
12. Incoming context, creating a card entity object
14. Nsmanagedobject *card = [nsentitydescription insertnewobjectforentityforname:@"card" Inmanagedobjectcontext:  Context];
16. [Card setvalue:@"4414241933432" forkey:@"no"];
18. Set the association between person and card
20. [Person Setvalue:card forkey:@"card"];
22. Use context objects to synchronize data to a persistent repository
24. Nserror *error = nil;
26. BOOL success = [Context save:&error];
28. if (!success) {
30. [NSException raise:@"Access database error" format:@"%@", [Error localizeddescription]];
32. }
34. If you want to do an update: When you change the properties of an entity object and call [context Save:&error], you can synchronize the changed data to the database

3. Querying data from the database
[Java]View Plaincopy

2. Initializing a query Request
4. Nsfetchrequest *request = [[[[Nsfetchrequest alloc] init] autorelease];
6. Set the entity to query
8. request.entity = [nsentitydescription entityforname:@"person" inmanagedobjectcontext:context];
10. Set sort (by age descending)
12. Nssortdescriptor *sort = [Nssortdescriptor sortdescriptorwithkey:@"age" ascending:no];
14. Request.sortdescriptors = [Nsarray arraywithobject:sort];
16. Set conditional filtering (search for records containing the string "Itcast-1" in name, note: When setting conditional filtering,% in a database SQL statement is replaced with *, so%itcast-1% should be written as *itcast-1*)
18. Nspredicate *predicate = [nspredicate predicatewithformat:@"name like%@", @"*itcast-1*"];
20. Request.predicate = predicate;
22. Execute request
24. Nserror *error = nil;
26. Nsarray *OBJS = [Context executefetchrequest:request error:&error];
28. if (Error) {
30. [NSException raise:@"Query Error" format:@"%@", [Error localizeddescription]];
32. }
34. Traversing data
36. For (Nsmanagedobject *obj in Objs) {
38. NSLog (@"name=%@", [obj valueforkey:@"name"]
40. }

Note: Core data does not immediately obtain the corresponding associated object based on the association relationship in the entity, such as when the person entity is fetched through Core data, and the associated card entity is not immediately queried, and the database is queried again when the application really needs to use the card. Loads the information for the card entity. This is the deferred loading mechanism for core data.

4. Deleting data from a database
[Java]View Plaincopy

1. Incoming entity objects that need to be deleted
2. [Context Deleteobject:managedobject];
3. Synchronizing the results to the database
4. Nserror *error = nil;
5. [Context save:&error];
6. if (Error) {
7. [NSException raise:@"Delete error" format:@"%@", [Error localizeddescription]];
8. }

Open the CoreData SQL statement output Switch 1. Open product, click Editscheme ...
2. Click arguments to add 2 items to argumentspassed on launch
1>-com.apple.coredata.sqldebug
2> 1



Create a subclass of Nsmanagedobject by default, entities taken with core data are of type Nsmanagedobject and can access data using key-value pairs. However, in general, entities may need to add some business methods to accomplish some other tasks on the basis of accessing the data, then they must create nsmanagedobject subclasses


Select Model File


Select the entity you want to create a subclass of


After creation, there are 2 more sub-classes


File content display:
Person.h
[Java]View Plaincopy

1. #import <foundation/foundation.h>   
2. #IMPORT&NBSP;<COREDATA/COREDATA.H>&NBSP;&NBSP;
3. &NBSP;&NBSP;
4. @class  card;  
Li class= "alt" >&NBSP;&NBSP;
5. @interface  person : nsmanagedobject   
6.   
7. @property   ( Nonatomic, retain)  nsstring * name;  
8. @property   (nonatomic, retain)  nsnumber * age;  
9. @property   (nonatomic, retain)  card *card;  
10. &NBSP;&NBSP;
11. @end   

Person.m
[Java]View Plaincopy

1. #Import "Person.h"
3. @implementation person
5. @dynamic name;
6. @dynamic age;
7. @dynamic Card;
9. @end

Card.h
[Java]View Plaincopy

1. #Import <Foundation/Foundation.h>
2. #Import <CoreData/CoreData.h>
4. @class person;
6. @interface Card:nsmanagedobject
8. @property (nonatomic, retain) nsstring * NO;
9. @property (nonatomic, retain) person *person;
11. @end

Card.m
[Java]View Plaincopy

1. #Import "Card.h"
2. #Import "Person.h"
4. @implementation Card
6. @dynamic No;
7. @dynamic person;
9. @end

So when you add data to the database, you should write:
[Java]View Plaincopy

1. Person *person = [nsentitydescription insertnewobjectforentityforname:@' person ' inmanagedobjectcontext:context]  ;
2. Person.name = @"MJ";
3. Person.age = [NSNumber numberwithint:27];
5. Card *card = [nsentitydescription insertnewobjectforentityforname:@ "card" inmanagedobjectcontext:context];
6. card.no = @ "4414245465656";
7. Person.card = Card;
8. Finally call [context save&error]; to save data

Here, the entire core data framework is the end of the introduction, in fact, core data is far more than these features, it also supports automatic revocation mechanism, one-to-many associations, etc., here does not introduce

Getting started with Core data