# data[].attributes.body
Pair

Persistent objects are created by applications. Each persistent object has an object identifier (OID) and is an instance of a class. The class may be defined in an object-oriented programming language, or it may be a class defined by Objectivity/DB (for example, ooObj).

# data[].attributes.body
B009 Adbms
object persistency is defined by giving the object a name. This name helps in acessing the object uniquely. It can also be specified by making the object reachable from another persistent object.

PAIR: not mentioned referencing. Also did not explain in detail and i could have talked about the syntax and discuss what persistency is.
Not mentioned the types of persistence storage.

SHARE:
ANSWERS:
Q1. C
Q2. D
Q3. C
Q4. B

# data[].attributes.body
Think
Persistent objects are created by applications. Each persistent object has an object identifier (OID) and is an instance of a class. The class may be defined in an object-oriented programming language, or it may be a class defined by Objectivity/DB (for example, ooObj).

1. A

2. D

3. C

4. B

# data[].attributes.body
E013 ADBMS.                               Think                                             Persistence  is data  storage which can be used when program is run again. It can be specified via file system ,relational database , object                                                             Pair.                                                         Object persistence is specified by either naming or reachability.             In naming we specify a name to the persistence object is and in reachability the object is reachable through some other object.                                                                                  Q1. C                                                         Q2. D.                                                      Q3. C.                                                       Q4. B

# data[].attributes.body
Kajal rathod
Think : how will you specify object persistence : A persistence object is an object which is stored in an Oracle database. It may be fetched into the object cache. Once it is created, it remains in the database until it is explicitly deleted.

Pair : object persistence is not just storing the data but it also stores the behavior and relationships with other objects for later reuse to output valuable information.
Share :
1) A
2) D
3) C
4) C

# data[].attributes.body
Think
Object persistence is specified  by  giving an object a name. This name helps in accessing that object uniquely. It can also be specified by making the object reachable from another persistent  object. Reachable means that a sequence of references from object 1 leads to object 2.
Pair (Yashashwini Gupta B031)
In OODB, objects are made persistent by class declaration.

Persistent objects are required so that even after the system is turned off, the object and it's data must persist. Objects  are made persistent by assigning  them an unique  name and making  them reachable  from other object. In OODB systems, objects are made persistent by class declaration.

Share
1-C
2-D
3-C
4-B

# data[].attributes.body
B027
Think:  storing the data, behaviour, and relationships with other entities for later use to output valuable infirmation.
Pair:
Naming and reachability, transparency and efficiency.
1 C
2 D
3 C
4 B

# data[].attributes.body
Think: Object persistence can be specified by Naming and Reachability. We can either assign the object a unique persistent name through which it can be retrieved or by making it reachable from a persistent object.

Pair:  In OO approach, a class declaration specifies only the type and operations for a class of objects therefore persistent objects must be separetly defined and in traditional databases every object is assumed to be persistent.

SYNTAX  persistence<object>

Q1.  A
Q2.  D
Q3.  C
Q.4  B

# data[].attributes.body
Think
It can be done in 2 ways Naming and Reachability. We can either assign the pbject a unique persistent name through which it can be retrieved or by making it from a persistent object.

Pair
A persistent object is an object which is stored in an Oracle database. It may be fetched into the object cache and modified by an OCCI application. The lifetime of a persistent object can exceed that of the application which is accessing it. Once it is created, it remains in the database until it is explicitly deleted.

Question
1. A
2. D
3. C
4. B

# data[].attributes.body
Think
It is the storage of data from working memory so that it can be restored when the application is run again. It can be defined as a running domain model to survive power failures or power spikes so that no data is lost.
Object persistance is achieved when it is transparent to the application developer as well as storing object state on persistent storage before deactivation.
It can be achieved by naming and by reachability.

Pair
Referencing hasn't been mentioned and explained in detail.
The syntax has also been omitted.
Which is persistance<object>
Have also missed the types of persistance storage.

1-C
2-D

3-C
4-B

# data[].attributes.body
Ans1:

Think:
Persistence is the storage of data from working memory so that it can be restored when the application is run again. In object-oriented systems, there are several ways in which objects can be made persistent. It's an important part of design application.

Pair:
Naming Mechanism:
Assign an object a unique persistent name through which it can be retrieved by this and other programs.

•Reachability Mechanism:
Make the object reachable from some persistent object.

Persistent storage can be
• File system
• Relational Database
• Object-Database.

Share:
1. A
2. D
3. C
4. B

# data[].attributes.body
Naming , Constructor, Reachability                                                                                       PAIR                                               In naming we specify a name to the persistence object and in reachability the object is reachable through some other object                                  Ans 1  C.                                      Ans 2  B.                                        Ans 3 C.                                         Ans 4 B.

# data[].attributes.body
Think-Object persistance can be specified via naming and reachability.
Naming Mechanism: Assign an object a unique persistent name through which it can be retrieved by this and other programs.
Reachability Mechanism: Make the object reachable from some persistent object.
An object B is said to be reachable from an object A if a sequence of references in the object graph lead from object A to object B.
In traditional database models such as relational model or EER model, all objects are assumed to be persistent.

In OO approach, a class declaration specifies only the type and operations for a class of objects. The user must separately define a persistent object of type set (DepartmentSet) or list (DepartmentList) whose value is the collection of references to all persistent DEPARTMENT objects.

Pair- Object Persistence can be described as a running domain model to survive power failures or power spikes so that no data is lost. Some describe Object Persistence as serializing objects out to the disk and retrieving them later. Serializing an object usually means to store the values of public properties of an object. De-serializing would be just the opposite and retrieve the values and reconstruct the original object back to its original state.Persistent storage can be
• File system
• Relational Database
• Object-Database. Flash-RAM

Share
1)A
2)D
3)C
4)B

# data[].attributes.body
Payal

# data[].attributes.body
THINK :Object Persistence is specified by naming, reachbility ,ie by assigning a name through which it can be retrived or also retrived using already persistent object . And in traditional database models such as relational model or EER model, all objects are assumed to be persistent

PAIR: I have not specified the syntax ie
persistence<object>

Answers
Q1 C
Q2 D
Q3 C
Q4 B

SHARE

# data[].attributes.body
E004, ADBMS

Think : .Object Persistence can be described as a running domain model to survive power failures or power spikes so that no data is lost. Some describe Object Persistence as serializing objects out to the disk and retrieving them later. Serializing an object usually means to store the values of public properties of an object. De-serializing would be just the opposite and retrieve the values and reconstruct the original object back to its original state.Persistent storage can be
• File system
• Relational Database
• Object-Database. Flash-RAM            Pair - Object persistence is specified by either namjng or reachability .In naming we specify the name to a persistence object and in reachability the object is reached through another object. This was the point that was missed in the previous answer.                                   Q1 - C Q2- D Q3- C Q4-B

# data[].attributes.body
Think
How will you specify object persistence?
Answer-We can specifying Object Persistence via Naming and Reachability:
•Naming Mechanism: Assign an object a unique persistent name through which it can be retrieved by this and other programs.
•Reachability Mechanism: Make the object reachable from some persistent object.An object B is said to be reachable from an object A if a sequence of references in the object graph lead from object A to object B.
•In traditional database models such as relational model or EER model, all objects are assumed to be persistent

Pair:-Object Persistence can be described as a running domain model to survive power failures or power spikes so that no data is lost. Some describe Object Persistence as serializing objects out to the disk and retrieving them later. Serializing an object usually means to store the values of public properties of an object. De-serializing would be just the opposite and retrieve the values and reconstruct the original object back to its original state.Persistent storage can be
• File system
• Relational Database
• Object-Database. Flash-RAM

1)A
2) D
3)C
4)B

# data[].attributes.body
Think :
Q. How will you specify object persistence?

Ans. In traditional database models such as relational model or EER model, all objects are assumed to be persistent. In OO approach, a class declaration specifies only the type and operations for a class of objects. The user must separately define a persistent object .

Pair :
Q. Missing points in think.

Ans. Store and restore important data, avoid loss of data in case of power failure , transparency of data, efficiency in terms of complexity.

MCQ :
Q.1. C
Q.2. D
Q.3. C
Q.4. B

# data[].attributes.body
Think: Persistence objects can be specified by assigning a unique persistent name and making the object reachable. In Object Oriented, Class declaration is used to make the object persistent.

Pair: Object can be made persistent by defining it from another persistent object. Two methods make an object persistent:
Naming Mechanism: Assign an object a unique persistent name through which it can be retrieved by this and other programs.
Reachability Mechanism: Make the object reachable from some persistent object.

Q1. C
Q2. D
Q3. C
Q4. B

# data[].attributes.body
E026
ADBMS

Think:
You can specify the persistent managed classes associated with a persistence unit by using one or more of the following:

<mapping-file> element: specifies one or more object-relational mapping XML files (orm.xml files).

<jar-file> element: specifies one or more JAR files that will be searched for classes.

<class> element: specifies an explicit list of classes.

The annotated managed persistence classes contained in the root of the persistence unit.

The root of the persistence unit is the JAR file or directory, whose META-INF directory contains the persistence.xml file. To exclude managed persistence classes, add an <exclude-unlisted-classes> element to the persistence unit.

Pair:
Missing points are:
Object persistence can be specified by using the syntax:
persistence <object>

Share
Q1. C
Q2. D
Q3. C
Q4. B

# data[].attributes.body
Think:  Object persistence can be specified by naming , by referencing, or by reachability
Pair: Didn't write the syntax and didn't explain each point
Share:
Answers:
Q1:
Q2: D
Q3: C
Q4: B

# data[].attributes.body
THINK:
Specifying Object Persistence via Naming,Reachability,Reference:
•Naming Mechanism: Assign an object a unique persistent name through which it can be retrieved by this and other programs.
•Reachability Mechanism: Make the object reachable from some persistent object.
•In traditional database models such as relational model or EER model, all objects are assumed to be persistent
PAIR:
Have missed an important example
DISCUSS:
An object B is said to be reachable from an object A if a sequence of references in the object graph lead from object A to object B.
ANSWER:
1.C
2.D
3.C
4.B

# data[].attributes.body
Think: Specifying Object Persistence can be done via Naming and Reachability:
1).Naming Mechanism: Assign an object a unique persistent name through which it can be retrieved by this and other programs.
2).Reachability Mechanism: Make the object reachable from some persistent object.

Pair: Persistence is the storage of data from working
memory so that it can be restored when the
application is run again. Object persistence is a way to make object persistent.

Ans   1).  A
Ans.  2).  D
Ans.  3).  C
Ans.  4).  B

# data[].attributes.body
Naming mechanism:Assign a unique persistant name through which it can be retrieved
Reachability mechanism: make the object reachable from some persistant object.

Pair: OO approach, a class declaration specifies only the type and operations for a class of objects.

Questions-
Ans1.  A
Ans2.  D
Ans3.  C
Ans4.  B

# data[].attributes.body
Think:  Object persistence is specified by either naming or  reachability . In naming we specify a name to the persistence object and in reachability the object is reachable through some other object.

Pair: specified by naming , reachability.In naming we specify a name to the persistence object and in reachability the object is reachable through some other object.                                 Share:                                           Ans 1 : c.                                       Ans 2: b

Ans 3: c                                         Ans 4: b

# data[].attributes.body
Think
object persistence is specified by  2 mechanisms

1. Naming Mechanism where we assign an object a unique persistent name through which it can be retrieved by this and other programs.

2. Reachability Mechanism makes the object reachable from some persistent object.An object is said to be persistent if a sequence of the references in the object graph leads to another object.

Pair (with GVA Sashank)
In relational model or EER model, all objects are assumed to be persistent.
In Object Oriented approach the user has to enter the type and operations for objects.

Share

Answer
1-c
2-d
3-c
4-b

# data[].attributes.body
THINK:
Object persistence can be specified by using the syntax:
persistence <object>

It can be accessed using:
(i) naming
(ii) reference

PAIR:
I did not specify reachability and didn't explain naming, reference.

SHARE:

QUESTIONS:
1. C
2. D
3. C
4. B

# data[].attributes.body
Think :Persistence is the storage of data from working
memory so that it can be restored when the
application is run again. Object persistence is a way to make object persistent.                                               Pair : there are two ways to make an object persistent :                            1 .Naming Mechanism: Assign an object a unique persistent name through which it can be retrieved by this and other programs.
2 .Reachability Mechanism: Make the object reachable from some persistent object.                                   Answers :                                               Q1-  | Q2 - D |
Q3 - C | Q4 - B

# data[].attributes.body
Think : A persistent object is an object which is stored in an Oracle database. It may be fetched into the object cache and modified by an OCCI application.
The lifetime of a persistent object can exceed that of the application which is accessing it. Once it is created, it remains in the database until it is explicitly deleted.
•Naming Mechanism: Assign an object a unique persistent name through which it can be retrieved by this and other programs.

•Reachability Mechanism: Make the object reachable from some persistent object.

Pair:As per my colleague Persistence is the storage of data from working memory so that it can be restored when the application is run again. In object-oriented systems, there are several ways in which objects can be made persistent. It's an important part of design application.

Q1. C
Q2. D
Q3. C
Q4. B

# data[].attributes.body
Think: Specifying Object Persistence can be done via Naming and Reachability:
1).Naming Mechanism: Assign an object a unique persistent name through which it can be retrieved by this and other programs.
2).Reachability Mechanism: Make the object reachable from some persistent object.
->An object B is said to be reachable from an object A if a sequence of references in the object graph lead from object A to object B.
-In traditional database models such as relational model or EER model, all objects are assumed to be persistent

Pair: Persistence is the storage of data from working
memory so that it can be restored when the application is run again. Object persistence is a way to make object persistent.
Ans 1). C
Ans 2). D
Ans 3). C
Ans 4). B

# data[].attributes.body
Thinkt is the term often used with storing objects in the database.We can specify the persistence using OID,standalone objects and embedded objects,also we can use persistent storage and make the access to the objects reachable.
Specifying object can be done by naming and reachability.
Pair
My partner has missed few important points .
He forgot to specify about OID, I.e. OID can be used as a tool to make an object persistent.
2.)Deletion of the object must be explicitly, As once the object is created , It stays in the memory even if the system crashes.
Q.1) A
Q.2) D
Q.3)C
Q.4)B

# data[].attributes.body
Think
We can specify  Object Persistence via Naming and Reachability:
1 Naming Mechanism: Assign an object a unique persistent name.
2 Reachability Mechanism: Make the object reachable from some persistent object.
Pair:
My partner has not writte the following point:
1) He has not written about the embedded object.
2) Object has to be deleted explicitly.
Share:
1 A
2 D
3 C
4 B

# data[].attributes.body
B059
How will you specify object persistence ?

# data[].attributes.body
Think
we can specify the persistence using OID which assigns a unique id to each object., using standalone objects and embedded objects. also we can use persistent storage , and make the access to the objects reachable.
Pair
My partner has missed some important points
1) he didnt specify, that an OID can be used as a tool to make an object persistent.
2) Also we need to delete the Object explicitly, because once the object is created it stays in the memory , even after the application shuts down.
Q 1) A
Q 2) D
Q 3) C
Q 4) B

# data[].attributes.body
B061
ADBMS

Think :An object that continues to exist after the program that created it has been unloaded. An object's class and current state must be saved for use in subsequent sessions. In object technology, persistence means storing the object for later use.

Pair: Object persistence is not just storing the data but it also stores the relationships and the behaviour with other objects for later reuse to output valuable information.

Share:
1) A
2) D
3) C
4) B

# data[].attributes.body
Rajat

# data[].attributes.body
B046
ADBMS
Think:
Object persistence is specified by naming and reachability
An object is assigned unique persistence name retrieved by other programs. The object can also be made reachable from some already persistent object.
An object A is said to be reachable from object B if sequence of references lead from one object to another. In traditional DB models, objects are inherently assumed to be persistent. In object oriented approach, class declaration specifies type and operations for a class of objects. User has to separately define persistence object of a type set or list whose value is a collection of references.
Pair:
An example illustrating pseudocode is not written.
Questions:
1.C
2. D
3. C
4. B

# data[].attributes.body
Think
It can be done by 2 ways naming and reachability
Assign an object a name through which it can be retrieved
Make the object reachable from some persistent object
Syntax is persistence <object>
PAIR
I haven't specified that in traditional databases such as RDBMS or EER model all objects are assumed to be persistent
Answers:
Question 1) C
Question 2) D
Question 3) C
Question 4) B

# data[].attributes.body
Think -
Persistence is the ability of an object to survive the lifetime of the OS process in which it resides.
Storing object state on persistent storage before de-activation n Upon activation, load object state from persistent storage n Persistent storage can be • File system • Relational Database • Object-Database • Flash-RAM
A persistent object continues to exist and retain its data beyond the duration of the process that creates it. In contrast, a transient object exists only within the memory of the process that creates it; when that process terminates, the transient object ceases to exist.
We can specify  Object Persistence via Naming and Reachability:
1 Naming Mechanism: Assign an object a unique persistent name.
2 Reachability Mechanism: Make the object reachable from some persistent object.

Pair -

Some more points what I would like to add more would be that -
Object Persistence is achieved when it is transparent to the application developer as well as storing object state on persistent storage before de-activation.
It is specified via naming and reachability.

Answers -

1- C
2- D
3- C
4- B

# data[].attributes.body
Tejaswini B014 ADBMS

# data[].attributes.body
B019
ADBMS
THINK:
Object Persistence is storing the data, the behavior, and the relationships with other objects for later reuse to output valuable information.
PAIR:
Persistence is the storage of data from working memory so that it can be restored when the application is run again. In object-oriented systems, there are several ways in which objects can be made persistent. It's an important part of design application

SHARE:

Answers
Q.1) A
Q.2) D
Q.3) C
Q.4) B

# data[].attributes.body
E054
ADBMS
ThInK :
Object durability, or persistence, is the term you often hear used in conjunction with the issue of storing objects in databases. Persistence is expected to operate with transactional integrity, and as such it is subject to strict conditions.
It is the ability of an object to survive the lifetime of the os process in which it resides.
Pair:
The object can also be made reachable from some already persistent object. In object oriented approach, class declaration specifies type and operations for a class of objects. User has to separately define persistence object of a type set or list whose value is a collection of references.
Share:
Q1.-C
Q2.-D
Q3.-C
Q4.-B

# data[].attributes.body
1 Marks for your ans for correct choice
1 Mark for your think phase
1 mark for your share, not be counted if you have not written share phase.

# data[].attributes.body
Think: Think individually and write the answer.
Pair: Discuss with your neighbours and write the answer under pair heading, try to include the items that you left in think phase, give feedback to your neighbours.
Share: Share the answer with your class mates and discuss on the best possible solution.

# data[].attributes.body
Start your padlet with your name, roll no. and subject.