WWDC2004 Session 418

Transcript

Kind: captions
Language: en
okay good afternoon welcome to session
418 introduction to core data my name is
andreas vantika and i'm the senior
manager for core data and web objects
and core data is a new framework that we
added under the cocoa umbrella and it
continues an initiative we started last
year with cocoa bindings
that's the initiative to bring you and
your applications more functionality for
adding significantly less code like
bindings core data addresses fits gap in
the cocoa functionality core data is
concerned with fine-grained management
of data objects in this space it solves
a number of very difficult problems and
I actually believe that it will have a
much stronger impact on your application
development development and even cocoa
bindings head when I talk about data
objects in this session I really mean
the objects that you refer to as the
model objects in the model view
controller sense but I'm going to use
the term model in a different context
throughout the session so I decided to
stick the data objects also I'd like to
distinguish core data clearly from the
new metadata API the new spotlight API
core data is about the inside of your
data ups of your data files about your
own applications documents and metadata
it really is about the surface about the
outside of those files that you want to
export to the file system and to the
Search API so one thing that sentance
core data is a model driven object graph
management and persistency framework
that's certainly a mouthful but what
does it actually mean it means that if
code data instead of writing a lot of
code you create a description of your
data objects you create a description in
Xcode and that description is called the
model of your application and the model
is what's used by core data to manage
pretty much most aspects of your data
objects for you and it's do that both in
memory and on disk that means that you
are actually freed up to focus entirely
on the application specific problem
domain instead of having to focus on
developing infrastructure for your
application so what can we do with the
model I think the most immediate benefit
to many of you will probably be that you
can provide you with automatic
and ruin redo in your applications so
with core data no more worrying about
that and as undo manager we also provide
you with scalable object lifecycle
management that means that we actually
only keep the pieces of your data in
memory that is currently needed and we
leave the rest on disk so it skates very
very if you automatically synchronize to
user interface you do that - cocoa
bindings but we added a few pieces to
bindings to make the situation even
smoother and core data also helps you be
ready to manage the consistency and
correctness of your data and all you
have to do is specify a bunch of rules
in the model that tells the tale core
data how to validate user input and how
to maintain relationships or references
of your objects to each other the other
thing we can do is we can ultimately
read and write your objects to the disk
and we're going to support three
different file formats and this first
release SQL databases XML files and
binary archive files SQL files are
implemented on top of SQLite which is a
very nice lightweight embedded SQL
database it's an open source project and
SQL databases will usually give you the
best scalability if you have large sets
of data and that's the case because with
SQL databases we can update your files
incremental e we don't have to write the
entire file if just one object changes
everything is incremented and a lot of
the data can stay on the disk
the only fetch them into memory even
needed XML files have the huge advantage
today a human readable and they easily
consumed by other applications if you
need to exchange data but they won't
give you the same performance one other
advantage of XML files is that they are
written atomically so if you are in the
typical code document context but you
want to write the files atomically if
you if you save the next file it's
actually a very good fit and binary
files I kind of in the middle they are
probably good compromise they don't give
you quite the performance of SQL
databases and they don't scale to the
very large data sets but they written
atomically and they are reasonably fast
now what's important for this first
release is that when you use core data
we will take ownership of the file
format of the file schemas so in the one
hand that's great because you don't even
have to worry about trading tables in
the SQL database or creating the schema
for
on the other hand you will lose detailed
control of your five formats to give you
some examples of what you could do with
core data I have to just looked at my
doc and the typical applications are
used on a daily basis and none of these
applications disclaimer actually using
core data right now if you're still
building up core data it's really early
but I think it gives you an idea of what
the scope is of things that you can
solve the core data so starting with
Safari the history in bookmark files
that would be a great thing you could do
with core data persons and groups even
the mailbox fights within mayor the
music library of iTunes calendar files
and I care even sketch documents which
have the different graphics in it and
project files and xcode those are all
great candidates for core data
essentially every application that
manages lots of objects they benefit
greatly from using core data the
applications that you will not see that
much of a benefit applications that work
on large blobs of data so for example
TextEdit if it works from the RTF or or
text files and maybe image processing
software won't benefit that much from
core data so why is it good for you most
importantly because it leads you from
having to reinvent the wheel again and
again it again but implementing and when
we do merging your life the life cycle
of your objects input validation it's
all very mundane work that you have to
implement for every application and with
core data it's done for you you save a
lot of time you will have a much faster
development cycle code data also to give
you robustness and flexibility the
choice of different types of data stores
with the different characteristics of
scalability and human readability etc I
think return are very handy for many of
your applications and also very
important correlated will prepare you
way for the future for features we might
add in cocoa now that we have a model we
can interpret that model in many
different ways without you writing it
any line of code so you could envision
us to for example add a transcript
ability to your applications or maybe
automatic rendezvous connectivity so
there are some features we are looking
at in the future that I think you will
be able to pick up automatically if you
start using core data soon these are
actually fine with screenshots from an
actual application we converted over to
core data recently and that application
was already using cocoa bindings so
there was no glue code for the UI layer
and
can see we were still able to save up a
lot of the code and by the way this
application now has more features than
it had before for something now it has
undo and redo so with that I would like
to ask James Dempsey to come up on stage
and give you first demo of core data
Thank You Andres so we're taking a look
at here is an XML document as might be
managed by core data we're gonna put
that away for now
we're gonna jump right in and build a
full-featured document based application
with 0 lines of code using core data
we're gonna use the core data document
based application projects call that
thing demo 1 and with cocoa bindings you
essentially had your data objects able
to be synchronized with user interface
objects through bindings but you still
have to manage those data objects
yourself with core data it's kind of
like the other half of the equation
where those data objects you can model
them core data will help you manage them
and also deal with the persistence so
let's take a little look at the project
and the code that's in there if we take
a look at the classes we have a document
class which is a subclass of NS
persistent document which in turn is a
subclass of NS document and this
subclass adds all of the hooks needed to
interoperate with core data including
persistence let's take a look at the
implementation file and you'll notice a
couple of common NS document methods
here and a few that are missing
ostensibly those that are for writing to
the data writing and reading data so we
don't need these initialization items
either so in essence this is a negative
lines of code demo and we'll next look
at a new resource in the project the
model so a little later in the session
you're going to see how you can create a
model from scratch but to save time
we're going to import that XML file that
I showed you earlier
and Xcode is going to build an entity
relationship diagram based on the
structure of that XML file and if we
take a look we have persons events tasks
as an event management sort of model so
now we have our model let's build our
user interface we'll head into our
document nib file get rid of this and
what we're going to do is option drag in
this case the person entity let me pick
it up here into interface builder
interface builder is going to ask us
whether we want a user interface for one
object handled by an object excuse me an
object controller or many objects
handled by an array controller we're
going to deal with many objects in this
case and you'll notice that a user
interface has been built based on the
properties of the person in the model
and in addition in the RAID controller
has been added to the project let's just
take a look at the bindings of this text
field here take a look at the value and
you'll notice that it's hooked up to the
arrayed controller selection for the
model key path first name it's just a
straight standard cocoa binding in fact
all of the user interface is dealing
with cocoa bindings in that array
controller in the way it has in Panther
so what's the new stuff well if we take
a look at the array controller you'll
notice a couple of additional features
designed to integrate cocoa bindings
with core data the first is instead of
naming a concrete class we have the
choice to pick an entity in this case a
person so that the array controller
knows what type of thing it's dealing
with if we look at the bindings of the
array controller you'll notice a new
binding called managed object context
and the managed object context andreas
will be talking about it later but in
essence it's the object that's providing
and doing a lot of the heavy lifting for
the functionality that we're going to
see in a moment when I build this
application so one entity is kind of
useful but very few applications deal
with one kind of object and one kind of
object alone and core data is actually
very good at dealing with relationships
queen types of objects so a person is
related to many tasks so let's get a
user interface for a task many tasks in
fact let's clean this up a little again
these are just plain old IB things so we
can get rid of them if we want to let's
get rid of some of these let's get that
task field a little bigger so we can
read it get rid of some stuff okay now
let's take a look at that task array
controller we do need to bind its
content so it knows where it's getting
its tasks from we're going to bind that
content to the person array its
selection and within that selection the
tasks of the selected person let's save
our change and let's build our happy
little application here
well that's building let's just take a
look at the types of documents that we
can save to predefined is the binary
archive format the sequel Lite document
format as well as the XML format so our
build has succeeded
let's run hide a bunch of stuff and
here's our application let's open up
that XML file that we had seen earlier
and you'll notice that indeed as I jump
through the items in this table view
everything's updating I'm seeing all of
the tasks that are related it looks like
Andres has the most to do out of
everybody and we have all the common
cocoa bindings sorts of features such as
sorting such as multiple selection and
some new goodies such as filtering so if
I type in some filtering there it'll
filter for me and the UI is
automatically let me there built in a
menu so I can pick particular things
that I want to filter upon now let's
jump on over to our new document and add
some people so let's add Bob Jones let's
add Barry Bonds and let's save
so I'm going to save again these file
formats appear here let's do the sequel
thing call that test we'll save it and
on our desktop is that sequel Lite
document which represents the sequel
database and let's close the doc now
let's open it up again thus proving we
beyond shadow without that it persisted
and there it is I think I forgot to type
in bonds there we go let's make it
persist a there we go what I do I may
have Miskin disconnected that text field
in interface builder my apologies
okay with that let's add a new person
Betty Brant and let's change Bob to
Robert
and let's remove Barry for legal reasons
now you'll notice looking at the
document that the window does know a
change has occurred it is dirty and if
we go to the edit menu we do have undo
so let's undo through this we should get
Barry back Robert should be get back to
Bob and Betty should disappear and of
course redo and if we feel free
and if we quit of course it knows the
dock is dirty in Alaska so if we want to
save we don't want to save okay let me
close up this project I'd like to show
you one more thing beyond that codeless
demo which is that that's a very cocoa
centric demo this application here the
three bears is a carbon application
that's using core data underneath for
its persistence and in fact this is the
XML file that it's writing to let me
just open that up and TextEdit and so
we'll add the baby bear whose height is
very small we'll save and quit and
restart and indeed it has persisted and
then if we get the saved version from
disk you'll notice that that XML
document has updated so let's take a
look at the project and it's an
objective C++ and it's the code here
that is doing a bit of transition
between those objective-c objects from
core data and core foundation types that
carbon would be able to use and so
depending on which flavor you wish you
can use core data with both so thank you
very much and now back to Andres
[Applause]
thank you James now let's talk about
moderates moderates are high level
description of your data objects they
essentially entity-relationship diagrams
of your objects and the model is what's
needed by core data to implement all
these nice features like Unwin redo and
ultimately read and write your data
objects to disk in fact the model is all
that code data needs as you saw on the
dem was before there was no additional
code really necessary to do all this
work one thing that's important though
for you to keep in mind is that you and
your models you would have to spend
quality time together the models need to
be very detailed for us to do a good job
so the more detail you make your models
the better of a job core data can do one
thing that's interesting in this context
is that we decided to separate the five
formats for the models you edit in Xcode
and the models you load at runtime the
reason for that is instead excrement is
additional information if you don't need
at runtime like the layout information
of the diagram and maybe the colors you
chose for the different boxes and if you
didn't want to burn the runtime with
that so while your project is building
you're actually translating the model as
it is written in Xcode and manage an
Xcode into a new file from R that is
then run imported at at runtime models
and essentially consists of two pieces
entities and properties entities to kryb
describe the types of objects and
properties describes the individual
object components the values inside
those objects for each entity you can
specify a class name that is used to
represent that entity at runtime and
specify the class name here we turn out
to be the most important hook for you to
plug in your own application logic
another thing that's interesting about
entities is that they can be organized
in a hierarchy which is actually
independent of the class hierarchy you
use so for example if you have a person
entity you might might have sub entities
like employee and company customer and
you can then map those entities to
either a class hierarchy that is the
same or two classes that have nothing to
do with each other or you can even map
those three entities to the same object
class at runtime
that's actually fairly common
the advantage for you to use entity
inheritance that you model the types of
data that you can for example define
your queries on the abstract entity you
can still search for our persons and
then going back get their customers and
employees so there's there's a lot of
flexibility for you when you work with
your data objects for properties we
support three different types attributes
relationships and fetch properties
attributes represent the simple types of
data in your object like strings numbers
dates and maybe binary data like images
a relationship through present
references of objects to each other and
then we distinguish between two one and
too many relationships the one
relationship is simply a pointer a
reference to another object no too many
relationship is a collection of
references to other objects in this
first release we are going to support
only unordered relationships too many
relationships and the natural
representation for that is action and is
set going forward we are probably going
to add support for ordered relationships
too and those would be represented by NS
race and for NS race we will then also
archive the order of the object in that
array in the data stores relationship
typically come in pairs if you have a
person that points to company there's
usually over also pointed back from the
company to the person those in those
relations are called inverse
relationships and they make your optic
graph very rich actually it makes it
much easier to navigate through your
object graph so you command that you
typically enter the inverse
relationships in your model too and
fetch properties and many ways similar
to relationships but they aren't they
are much more loosely bound you can
pretty much think about them as smart
groups to make it more concrete for you
in an SQL database a relationship will
actually reside in a join that is
enforced in the database a fetch
property is much more of a loose carry
so all these properties the model
contains the beds of information
starting with validation words those are
the kind of mechanical validation words
like the length of a string or maybe the
very expression a string has to match
min and Max values for numbers and dates
those kind of things they also delete
rules for relationships and those delete
rules take all data what to do if an
object is removed from your
Graff typically there's something like a
ripple effect if you remove an object
let's say you have a person object which
has addresses and contact information if
you delete that person you want to get
rid of the other information too and
delete routes allow you to specify that
kind of behavior and their different
choices you can kind of cascade the
delete so that's the ripple effect you
can deny delete depending on the
situation so there's there's a lot of
flexibility in these 2d tools and also
for attributes we store default values
those are simply the values assigned to
your object when it's inserted when they
are inserted so this table summarize the
kind of mapping we do at runtime and
entity essentially maps to a class and
attribute maps to single a simple
instance variable and the relationship
maps to a managed reference or
collection of these references they
appoint us there are some more things in
the model that I want to go over quickly
starting with predefined queries you can
enter pretty much templates for the
common queries you want to do you want
to perform in your application again
it's something like a smart group would
be a good example here and typically you
will specify variable names within those
queries and then substitute concrete
values at runtime so those are very
handy and make it it's actually a huge
convenience for you to specify those
queries in the model up front there also
sometimes we call configurations in the
model a configuration is pretty much a
named group of entities and those
configurations are used in the more
advanced cases when you talk to my to be
data files at the same time each
configuration then maps to one data file
and you can pretty much predefined the
mapping to the different data files in
the model by separating those
configurations and naming them and the
last thing I want to mention is that we
also decided to give you some
flexibility to to customize the model if
you added so called user info
dictionaries to entities and properties
and you can store your own information
that these are pretty much arbitrary key
value pairs you can end in the modeling
tool in the typical use case for that is
actually localization so with that I'd
like to ask Bill I'm gonna turn up on
stage there he is and he will give you a
more detailed demo of the model
[Applause]
good afternoon so what we have on screen
here is the modeling part of Xcode and
as you've seen probably in an earlier
demo this is also used for doing the
class models so I'm going to strict
stick strictly with the entity model and
the stuff that we use to build the
models for core data what we have here
is the graphical view which gives you a
nice overview of how the various
different entities are related to each
other and the attributes that they have
we can then actually go in here and this
is all live so if I wanted to I can come
in here and I can double click on this
and I could edit this I could you know
edit the attributes I can delete them
things like that so we wanted to really
emphasize the ability to graphically
edit your model and work with it and
because we think that being able to
visualize your data structure is
important to helping understand programs
especially when you start getting into
more complex models now this of course
is not actually a rich enough
environment to be able to do full
editing of the model like the validation
rules and property types relationship
rules etc so if you go into the design
menu there is a model browser and once
we bring up the model browser that adds
a set of user interface it's used for
examining your model in depth and for
actually editing it and controlling
everything from the entities through all
the way down to validation rules so we
can come in and we can create new
entities we can obviously delete them we
can also see in the middle table you
have all the properties listed and
actually there's properties and
relationships so we can select these and
you'll see on the right that there's an
inspector area which shows you a lot of
detail now the diagram at the bottom
will actually update in real time based
on what you're entering in the top area
of course so if we choose the attendees
relationship with the destination of
person which will be where is that okay
we've got event there's is there's
attendees right there if I were to
change the rule so the minimum count or
the maximum count was one you'll see
that this arrow right here updated
that's because of course the arrows
indicate the ordinality of the
relationship relationships are allowed
have ordinality x' so that you can say a
car can only have four tires that kind
of thing and upon save and upon
manipulating the objects at runtime the
system will validate that Andreas will
be getting into that in more detail now
there's some other we've learned a lot
about modeling tools we as some of you
might know we've done some things wrong
in the past and hopefully you'll find
this to be a refreshing change so one of
those is that it was tedious and
annoying to have to go through a model
and edit a particular part of an
attribute over and over and over again
so what you can actually do is you can
come in here and you can multiple select
in here and you'll see that the
inspectors over here update to only show
you the items that are relevant to those
things so now I can come in here and I
can like select first name and last name
and I can change the validation rules
for both of those at the same time but
of course oftentimes when you're
modeling stuff you'll have attributes
across many entities that will need to
be changed at the same time so I come in
here and select them all and then I can
sort by entity or I can sort by property
or kind and then I can again select
multiple across multiple entities and
edit them all at once we also have the
fetch request editor so if I come in
here I can build a new fetch request and
on I can then actually edit the
predicate and we give you a graphical
predicate editor so we can come into
here and let's say we all may say this
is confirmed yes and we also want to
make sure that the date is or less than
you know and we can say maybe we want to
add an or here so we can say the date is
greater than
[Music]
I'm obviously making up some random data
there so that's the predicates editor so
that's built into there it also it does
full logical trees you can also
drag-and-drop
let me go ahead and do a little drag and
drop demo so we'll get one of these and
do another hand and then we'll do say
and/or at this level if I wanted to say
oh well this really should be at the top
level Angus dragged it up there and no
restructure itself appropriately and
then of course as andres mentioned there
is the user info here so it's just key
value pairs so we allow you to annotate
your models with whatever you need
thank you so core data can automate
great many things and it can provide
with a lot of infrastructure but of
course we don't know what the actual
problem is that you want to solve in
your application so there's still some
code you have to write yourself and as I
mentioned before you the most important
hook for you for that is to specify your
own data object classes in the model and
the one requirement we have this core
data is that require you to subclass a
new class that we call an ns-managed
object imagine ns-managed object
actually is a generic data object so you
can use it with an arbitrary entity in
your model and that's what we did with
the demo so far there are no custom data
object classes in there so we just use
the ns-managed object and you know it's
not doing main very smart things it's
just storing getting in and setting
values and it's performing the
validation rules but for your own custom
logic you will subclass that and then at
your own specific code for a problem
domain inside those subclasses that said
ns-managed objects are probably
sufficient for many cases if you don't
need anything special just stick with
ns-managed object it's much more
convenient when you subclass you
typically implement your own logic in
the normal setters and getters that are
defined with key value coding the naming
schemes we defined with Coverity coding
observing the same is true for
validation and we all
to edit a bunch of hooks notifications
for you in your objects that you have
methods that you can override to react
to different kind of state changes and
I'd actually like to work you know
through most of the API of ns-managed
object the init method takes two
arguments first of all the entity that
the object actually represents the
second argument is this ns-managed
object context james are referred a
little bit in the in his demo and the
managed object context is the object
that does all the work for you the
triggers the undo and redo with triggers
the validation every managed object
always needs to be assigned to a managed
object context the first thing you
should do if you create a new object is
inserted into a managed object context
there's a get method for it and there's
also a method to get the entity of the
object and getting the entity can be
very handy at runtime if you want to do
some introspection it's actually very
similar to using the classification
stored in the objective-c runtime you
can use the entity to get more
information of your objects what
properties are there what attributes
what relationships are there to what
other entities can you navigate from a
given object those kind of things
manager object can't manage objects also
have an object ID the object ID is
pretty much a unique reference that is
created when your object is stored in
the file system and it's guaranteed to
stay the same throughout the lifetime of
that object so if you have any need to
get a hold of an object and then stored
away and get back to it later that
object ID is a good reference for you to
use to react to state changes they're a
bunch of methods you can override first
of all there are some get method method
just is inserted is updated it's deleted
they just tell you about the state of
the object and they are very handy in
the context of bindings for example you
can wire up the enabled binding of a
textview to one of these methods if you
only want it to be added to within
certain situations their methods that
inform you if the object was just
fetched inserted
typically you initialize your own caches
in those methods and their methods I
tell you that the option is about to be
deleted or saved and here you can
typically set some values maybe
timestamp right before it's saved
something like that
for QA recording and observing we just
followed the normal standards the
generic methods are value for key and
set value for key you typically don't
override those methods directly but
instead you implement your own accesses
those generic methods call out into
custom versions of these of the Coverity
coding methods like set name and name to
get the name property one thing that's
new in this release is that you also
added support for set mutaters if you
want to modify too many relationships
since they are we represented by sets in
this release they work the same way as
the array mutaters worked in the last
release you pretty much get a hold of a
mutable set for a given key and then you
modify that set and that modifies the
relationship indirectly there two more
things that are interesting in the
context of Coverity coding and observing
with managed objects number one is that
you will typically still want to access
the generic data storage mechanism of
managed objects you don't need to at
your own aivars to store your values you
can continue to use the generic
mechanism and actually you command that
you do there because we can optimize the
access to the values much better if you
continue using that generic storage
mechanism so to access the values we
added the primitive Coverity coding
methods primitive value for key and set
primitive value through key and again
you use them in your own custom accesses
like set name and name to call out into
the generic storage mechanism and then
the access need to be wrapped by real
change and did change methods and also
now they access and did access methods
and the read methods key value observing
actually has this really nice behavior
to do this automatically for you you
don't have to implement it for nsobject
yet we hope to have that ready by the
end of the release membership but at
this time you would have to explicitly
call really change and did change in
your set methods and video access and
did access and your get methods so this
would be an example if for example you
have a social security number of
property and the set method would jump
out in the very first call will change
then access to set primitive value for
key and then called the did change
method the get method would first call
they access then primitive value for key
and then did access and of course you
can insert your own code in between here
if you want to do your own
customizations
for validation it's very similar the
generic method is validate value for key
error again you typically don't
overwrite that directly instead you
implement those custom methods because
unlike validate name error and there are
additional methods for the state changes
so you can validate the state changes so
validate for the lead insert an update
you can deny delete for example those
would be two concrete examples again
it's a social security number to first
check whether the values actually of a
value type and then maybe check the
length and if it's not the right one you
can create an error and also you can
deny an insert you can pretty much
intercept a safe and deny that safe if
the social security number isn't set yet
so let's look at the architecture of
core data and what actually happens to
your managed objects what very heard is
that the managed objects are obviously
signed to manage object context that's
the object that as most of the work for
you and to the UI side the managed
object context are simply hooked up
usually to cocoa bindings to the UI you
don't have to use bindings we saw an
example for the carbon UI for example
but it's the most convenient way
actually to handle managed objects so
you simply hook up the controller a
cocoa bean is controller to the managed
object context it will then go and you
know filter the objects out that I need
to be displayed in the UI it will sort
them prepare them for the UI and then
populate the user interface to the other
side of the persistence side manager
object context is hooked up to
persistentstorecoordinator that
coordinator is the one that provides the
model so it tells the managed object
context of what types of entities are
available and it's also the the object
that synchronizes the access to the
different data files of your application
let's take a step back in summarize
quickly the match object context is the
center of your new word it's really the
thing that manages everything for you it
does and when we do it triggers
validation maintains the inverse
relationships that I mentioned before
all that work happens in the managed
object context it says the Gateway to
the persistentstorecoordinator
and if you want an analogy for it it's
something like a scratch pad it allows
you to load objects into memory from the
fires then modify them and them either
save them back to the fight system or
just throw the changes that way if you
don't need them anymore this is the
store Cornett coordinators the instance
that provides the model it synchronizes
the access to the persistent stores and
the idea really is that if you use my
tab it stores multiple files at the same
time it represents some like a unit of
them so it merges the context the
content of all the files together into
the managed object context it just looks
like it's talking to one single data
source what's important here for this
first release is that the only supports
striping in this versity so you can
merge the content of different data
files together in one context if you
don't support mirroring I want to talk a
little more about memory management I'd
already mentioned that vivid will give
you good scalability by only keeping the
pieces of your object graph in memory
that I actually needed needed means that
the objects are either changed or they
are currently displayed by the UI or
referenced by any other part of your
application and then core data will make
sure that your object graph grows on
demand if you did and go deeper into
your object graph and one concept I want
to mention here is the concept of
forwarding most of the time let's go
back to actually the example that we had
before the XML file that we showed in at
the beginning you have an event
management system and it's common that
you look at you know a table of data
objects but you know if you drill down
it's uncommon that you actually take a
look at all the objects in your data
file so we will make sure that we only
fetch those up into memory that that are
needed but use developer you shouldn't
have to vary about whether an object has
actually been fetched into memory
whether it has been fully initialized or
not and so the concept that you see as a
console of the place holder objects
essentially when you fetch not read into
memory is surrounded by little
placeholders that we call faults and
those faults are not fully initialized
so we haven't done the work to actually
go to the persistent store and get the
data from it so it saves a lot of time
and memory there but the placeholder
object is a valid reference so let's say
you have
that event object that has tasks
assigned to it the task objects can't be
referenced those place orders are vetted
references you don't have to worry about
whether those are fully initialized or
not and we do that pretty much
automatically for you the good thing for
you is that you don't have to worry
about whether the update has been
fetched into memory or not for you is
completely transparent in a typical
document based application you will use
multiple stacks of core data imperative
it stacks that are completely isolated
so each document will typically have its
own managed object context its own
persistentstorecoordinator and we
typically talk to a single document in a
non document based application you
usually have multiple stores that you
want to combine you might have a store
in the users home directory some
additional ones in the network and maybe
you even have removable media that
contain additional data files additional
stores so then again the
persistentstorecoordinator manages the
access to all these files at the same
time and it presents a unit of the the
stores to the to the managed object
context let's take a look at what
happens if you actually fetch Optus if
you load objects into memory typically
request is triggered by the UI layer for
example a nib file is loaded that
contains the controller that control is
hooked up to a managed object context
and then it's trying to populate the UI
if it submits um that we call it a fetch
request to the managed object context so
it's going down the stack the managed
object context we forward that request
to the persistentstorecoordinator which
we take a look at the model and then
decide what kind of data file it needs
to access it will load the objects from
the data files and send the data to the
managed object context which would then
materialize that object graph and then
the controller will filter out which
ones actually need to be displayed in
the UI which sort and prepare them and
then populate the user interface and
then over time when you fetch more
objects if you have maybe load
additional lip files so if you look at
different master detail relationships
the object graph would simply grow over
time
and changes happen those changes usually
start in the UI the user goes into text
field and enters a new value
but the help of the controller to then
access data objects and will start
applying new values to the data objects
and that in turn will cause a key value
observing notification to be sent out so
the match object context will be
notified of the changes in the object
graph and ever then you know start the
the tracking the changes it will start
undoing redo managing the undo manager
all these things essentially managed
object context will observe all the
changes to your object graph over time
so if additional objects change the
simply track all that if objects are
inserted if objects are deleted if you
keep track of all these changes and then
when you save that request usually again
starts in the UI it ends up on the
managed object context and the metric
context within package up all the
changes or the data to your object graph
sent them to the
persistentstorecoordinator which we can
take a look at the model to find out
which data files the changes have to go
to update the data files for you and
then onsuccess to notify the managed
object context which we set the object
graph to a clean state and then
everything starts from the beginning I'd
like to introduce you to one more
concept that is very fundamental to core
data and that's the cancer of predicates
predicates defined theaters they used
for queries and typically you either
predefined them in the model a
u-substitution variables for which you
can then substitute the concrete values
at runtime or you create them
programmatically which is usually based
on the user input for example in a
search field you can evaluate predicates
both in memory if you already have
objects fetched you can filter them out
in memory and sometimes we decide to
translate a predicate into another query
language in the context of sqa
we want to make use of the capabilities
of the SQL database which can do the
various very optimized and very fast so
you would translate those predicates
into SQL and perform the fetch there and
as predicates the classes represent
predicates also used outside of the core
data context the new metadata API in
cocoa uses predicates we also use it to
implement
in DNS or a controller these are some
examples for predicates you can ride
starts with simple comparisons
comparisons like name equal tom the
support case entire critic insensitive
lookups contains is the operator and
then you can have an additional flag the
see for case insensitive and the D for
diacritic insensitive you support
logical operations and or not we allow
you to look into relationships four to
one relationship you simply just follow
a key path like group dot name four to
many relationships we give you digital
operators like all in any so you can
look up persons for which all children
are older than twelve or just some of
them and we even support things like
simple operations like for computing the
sum of all the prices of some items in
the list so as you can see there's a lot
of flexibility here in predicates to
define your types of the types of
queries you want to perform on your data
objects at runtime predicates are
represented as a tree of NS predicate
objects that three classes you will
encounter and its predicate is the
abstract superclass and this compound
predicate is the class of represents
logical gates like and or not and then
this comparison predicate is the
predicate that performs all the
different operators the different
comparisons like less than greater than
contains matches there's a list of
operators we support comparison
predicates use and its expression
objects to provide the extra computation
values and their different types of
expressions again their expressions for
constant values expressions that follow
key paths again there's a list of
different types of expressions we
support but I think it's really
important for you is that the predicate
architectures extensive is you're not
limited to the datatypes v support if
you want to define special operators
that work on NS colors on NS images
you're free to do so with the predicate
architecture and now i think we have
another demo for you a bill is going to
just show you some predicates in action
okay
so I'm first going to show you just
briefly a little application that I use
to pull a bunch of data and mostly I
just wanted to show the model briefly
because this will be the model that will
be used for the other demos this is
actually an application that will go out
to Amazon through their public API will
pull a bunch of information about books
you search for and then we'll populate a
core data database so if I wanted to I
could go out and say you know search for
everything with cocoa in it and it's
going out making a WSDL based web
services soap call to Amazon pulling the
data back throwing in a core data
datastore and then throwing it up in our
default user interface including cover
art so that's just a simple little app a
few lines of code so that's our data
model there what we're going to be
looking at is products and manufacturers
Amazon uses manufacturers because they
make more than or they sell more than
books so think of them as publishers so
let me close that down and go to book
lists so I decided I wanted a little
application that I could use to grab a
bunch of books from Amazon and start
building up my wish list so I wrote a
little app and let me go ahead and open
some data book data as you can see I get
a big list of books and their prices and
and etc and now I can apply some
predicates to it so the first predicate
I'm going to apply is just a very simple
one I want to find all the books or all
of the entities of type product that
have the product name contains the word
cocoa so you can see it's executed in
there it is
now predicate scan also do some more
complex things like I can say show me
all of the books at Amazon or the price
is between 15 and 25 dollars as well
since predicates are all based on key
value coding and it should be emphasized
that they aren't limited to just managed
objects they will work with any object
in the system that's key value code and
compliant I can also follow key value
paths so in this case I'm going to ask
all of my products for all of their
manufacturers and then ask if
for all manufacturer names that begin
with O'Reilly so as you can see there
it's actually following the key path and
looking for O'Reilly and I get my list
of books from O'Reilly now I can also do
things where I'm testing if one object
is in a set of objects that are related
to another set of objects so in this
case if I want to go in and find
everything on Microsoft press and
mcgraw-hill and addison-wesley and Sam's
I can do that now I should actually show
you a little bit of code here so this is
a simple little application to apply the
predicate in the first place that's not
it there it is this is the line of code
I should scroll a little bit these are
the two lines of code necessary to
create a predicate and apply it to an
array the first line will actually take
that string that you saw in the user
interface those were actual real live
predicate expressions it will evaluate
it turn it into a predicate object which
you can then programmatically query or
take apart if you want to and then it
will apply it to an array and return the
array of objects a result from it
there's also a mutable array version of
this you can take a mutable array full
of objects and reduce it by whatever
objects passed the predicate the second
example also shows how to do custom
predicates so in the case of this user
interface I needed to basically check to
see if a particular product has a
manufacturer of this set of
manufacturers I have selected in this UI
and in that case in this line of code
I'm actually creating a comparison
predicate and comparison predicate Sall
ways have a left expression and a right
expression so in this case I'm saying
the left expression is the evaluated
object and all that means is that it's
it's the object in the array of books
that I'm trying to filter it's the thing
I want to filter and the right
expression in this case is a constant
value and it's my selected manufacturers
it's just whatever I have selected in
here
and in this case I said I want to use a
custom selector which is number of array
and this is going to be a method that's
going to be invoked on objects from the
left hand side and it will take an
argument from the at the right hand side
will be the argument passed to it so in
a category an ns-managed object because
in this demo we're using nothing but
managed objects
I wrote the member of array method which
as you can see it's pretty
straightforward
so using this leveraging this you could
like Andre said you could qualify
anything you could predicate you know
any object as long as you have key value
coding and as long as you can express
your expression in a method that takes a
single argument returns a boolean now if
you get into expressions which are more
complex then you can open it up even
further now I have one more demo we at
Apple like to eat her own dog food so
this is actually the core data
predicates are being used by metadata in
the Objective C API - metadata so let me
go ahead and run this application and it
comes up and it gives you a field and
you can type query into it which is
going to be a metadata query and it will
show a list of files of result so for
example I can ask it show me all files
let's start with the word app delegate
in their file name and it takes a second
but there comes and you can see that the
results are filling in as it goes this
is again because it's all leveraging key
value observing and key value binding we
can do some more complex queries like
for example I have a metadata importer
that grabs Objective C metadata from
Objective C source files so in this case
I'm going to find all files on my hard
drive that implements subclasses of NS
view which is pretty handy if you want
to find stuff in the example code now
let's look at the code so the code for
this is actually quite straightforward
and you can ignore the Notification
Center stuff that's a unfortunate hack
necessary to make the demo work right
now it goes
whay doesn't exist those lines not there
so we simply create a query and then
we'd set the predicate on the query and
again you see that line of code
predicate will format argument array and
that's it
start the query you're done so those are
predicates okay what does it mean for
you to start using core data if you want
to use core data you your application
will actively have to opt in you would
have to let core data drive you also
have to make a few changes to your
source code as I mentioned we expected
to use ns-managed objects for your data
objects and those need to follow very
strictly the Coverity coding and key
value observing conventions one thing
that might help you is that you can opt
to only use the in memory logic and not
the persistence logic of the framework
so you can still leverage undo and redo
and validation but continue to use your
own file formats and and save and and
open save and load your objects by hand
and then you know switch to Core Data
later again if you switch to core data
the full stack with the persistence
piece then you will lose detailed
control over the file formats and this
current release so I think adopting core
data is going to be little harder than
cocoa bindings but I also think that the
benefits will be much larger for your
applications of course the seed you have
in your own hands right now is these are
very early bits so not everything is
fully working right now
SQLite your is sort working here on
stage but the access for you and the
seed is not available right now the
other two things worth mentioning is
that controllers and as life as we'd
like them to be right now we like them
to react much better to adding and
removing persistent stores on the fly
and then update the UI automatically if
you don't have all that implemented yet
and also fetch properties aren't
supported at this time and of course the
little things like localization better
error messages leaks optimizations that
are still forthcoming that said
the complete API can be completely
exercised with the xm8 store that
actually works fully in the seed that we
have so we would like you do
this big overt watch sorry
so please try it out and we would like
to get your feedback you can send email
to Coco feedback at Group a tepid calm
or you can submit back reports actually
submitting back report is probably the
best way for you to communicate via
requests and ideas and also the Box you
encounter the documentation there's some
good use there's already a good amount
of documentation available that's listed
here on the slide if you don't have
really do release notes but we have very
good base documentation already and
that's on the seed that you in the seat
that you have
so in summary core data is a model
driven framework it manages your objects
it persists your objects it
automatically updates your UI through
cocoa bindings it's solve some very
difficult problems like undoing video
and gives you great scalability it gives
you choice and persistence stores we
support SQL databases XML files and
binary files we have added some good
support in Xcode for modeling there's a
great modeling tool for you and really
the benefit for you is that you will
read a lot or significantly less code
you would be a lot faster while you
develop your application so that was my
summary the good news for you is there
there's going to be a second summary
the Germans
[Applause]
so last year we had a little song to go
with cocoa bindings called
model-view-controller
and this year with the focus on core
data and building some data models since
the song writing tends to go where the
technology leads me it's a little song
about data modelling so we need to
switch over to the laptop excellent so
hope you like it
Modelling man I'm a modeling man they
say are you in modeling I say oh yes I
am
there's no catwalk involved in the
modeling I do there's no demand for me
to try that kind of model into some
people wanna date a model for a new
application don't wanna write a lot of
code simply use configuration to refine
your data model with each new iteration
as you build a prototype with
persistence automation some people want
to date a model but prefer one in
fashion if you date a data model that's
an interest in passion you're a dreamer
with a schema you can usually cash you
know you ain't got the looks in your
clothes they are clashing modeling man
I'm a modeling man let me lay it all out
so that you will understand you'll have
the terminology and concepts at your
command so you can also be a modeling
woman or man
we're Hill a managed object model also
known as the mom describes the data
objects that your app backs upon you
design your data model as pretty as you
please
by adding items to the model known as
entities and entities are a Pawnee is
one of things supposed to be what type
would sort what class will kind whatever
you might have in mind you pick a name
map to a class now your models growing
fast you work some more and come to
grips with attributes and relationships
now baby now your model into I said Ave
there one more for a model Amanda - and
attribute our relationship is known as a
property no not the kind that they using
monopoly using terms with precision
don't use them sloppily all confusion
will ensue like episodes a Three's
Company
I said I'm modeling man I'm a modeling
man EW and modeling I say oh yes I am
there's no photographers involved in the
modeling I do I got turned down by
everyone I gave my headshot to
[Music]
[Applause]
[Music]
and attributes a sample value string
number all dates or a big old blob of
data that's contained in some states you
can mark it transient if you don't care
about its fate otherwise it will persist
and data stores are you created two
entities can be connected kind of joined
at the hip the formal name for this
arrangement is a relationship one object
references the other so it can't give it
the slip the inverse reference is
maintained for a convenient roundtrip I
said I said a modeling man yeah I'm a
model and man they sell you and model
and I say oh yes I am
but don't come knockin if it's rockin in
the back of the van I'm probably
wrestling with relationships I don't
quite understand
Modelling man I'm a modeling man they
say are you and model and I say oh yes I
am
it's not too glamorous you know that
kind of modeling I do I'd like to see a
supermodel build the apps that we do
[Music]
[Applause]
Wow
so I've the boring task to finish up the
session if you could expect the slides
there are a few more sessions I'd like
to point you to that are related to core
data using a customizing cocoa bindings
this afternoon 5 we'll have a new piece
on the UI part of core data tomorrow
morning at 10:30 there's advanced core
data and on Friday morning at 9:00 we
have an overview of the modeling tool in
depth modeling design in Xcode these are
the usual people to contact