Ex Parte Alcorn et al

Patent Trial and Appeal Board

Mar 5, 2013

10829625 (P.T.A.B. Mar. 5, 2013)

UNITED STATES PATENT AND TRADEMARKOFFICE
UNITED STATES DEPARTMENT OF COMMERCE
United States Patent and Trademark Office
Address: COMMISSIONER FOR PATENTS
P.O. Box 1450
Alexandria, Virginia 22313-1450
www.uspto.gov
APPLICATION NO. FILING DATE FIRST NAMED INVENTOR ATTORNEY DOCKET NO. CONFIRMATION NO.
10/829,625 04/22/2004 John William Alcorn ROC920030352US1 7294
7590 03/05/2013
Robert R. Williams
IBM Corporation
Dept. 917
3605 Highway 52 North
Rochester, MN 55901-7829
EXAMINER
CHEN, QING
ART UNIT PAPER NUMBER
2191
MAIL DATE DELIVERY MODE
03/05/2013 PAPER
Please find below and/or attached an Office communication concerning this application or proceeding.
The time period for reply, if any, is set in the attached communication.
PTOL-90A (Rev. 04/07)

UNITED STATES PATENT AND TRADEMARK OFFICE
____________

BEFORE THE PATENT TRIAL AND APPEAL BOARD
____________

Ex parte JOHN WILLIAM ALCORN, ERIC NELS HERNESS,
ARTHUR THOMAS JOLIN, TERESA CHUNG KAN, and
KEVIN WILLIAM SUTTER
___________

Appeal 2010-000270
Application 10/829,625
Technology Center 2100
____________

Before KRISTEN L. DROESCH, JUSTIN BUSCH, and
GEORGIANNA W. BRADEN, Administrative Patent Judges.

BRADEN, Administrative Patent Judge

DECISION ON APPEAL

Appeal 2010-000270
Application 10/829,625

2
This is an appeal1 under 35 U.S.C. § 134(a) from the Final Rejection
of claims 1-3. We have jurisdiction under 35 U.S.C. § 6(b).
We affirm.

STATEMENT OF THE CASE
Appellants’ Invention
Appellants’ invention relates to entity beans, which are reusable
components in Java, that represent a business object in a persistent storage
mechanism. (Spec. page 2, ll. 27-29.) A container-managed persistence
(CMP) entity bean is one where the Enterprise JavaBeans (EJB) container
handles all database access required by the entity bean. (Spec. page 4, ll. 1-
2.) The bean’s code contains no database access calls. (Spec. page 4, ll. 2-
3.) Appellants’ invention relates to methods for container-managed
persistence entity beans to access backend data stores without knowledge of
the backend-specific protocol by using code generated in a helper class that
performs the accessing. (Spec. page 6, ll. 13-20.)

Exemplary Claim
Claim 1 is independent and is representative of the invention.
Independent claim 1 is reproduced below with disputed limitations in italics:
1. A method comprising:

receiving a specification of a method in a container-managed
persistence entity bean and a procedure in a backend data store,
wherein a container generates access calls to the backend data
store, and wherein the container-managed persistence entity
bean does not include the calls to the backend data store,

1 The Real Party in Interest is International Business Machines, Corp.
Appeal 2010-000270
Application 10/829,625

3
wherein the container marks transaction boundaries, wherein
the container includes the container-managed persistence entity
bean, and wherein the receiving further comprises receiving the
specification of the method and the procedure from a deployer;

in response to the receiving, generating code in a helper class
associated with the container-managed persistence entity bean,
wherein the helper class determines a connector based on a
connection factory type, wherein the deployer supplies the
connection factory type;

accessing the procedure in the backend data store via a
backend-specific protocol and the connector, wherein the
accessing the procedure in the backend data store further
comprises invoking the procedure in the backend data store,
wherein the code in the helper class performs the accessing and
the invoking, and wherein the code in the helper class calls an
evaluator class and passes results of the procedure, wherein the
evaluator class evaluates the results;

receiving a specification of input and output records for the
procedure in the backend data store; and

mapping the input and output records between the method in
the container-managed persistence entity bean and the
procedure in the backend data store, wherein the output records
comprise the results, and wherein a state of the container-
managed persistence entity bean persists beyond a lifetime of
an application that uses the container-managed persistence
entity bean.

Examiner’s Rejections
1. Claim 1 is rejected under 35 U.S.C. 103(a) as being unpatentable over
US 6,889,227 B1; May 3, 2005 (“Hamilton”) in view of US 6,748,373
B2; Jun. 8, 2004 (“Messinger”) and US 5,899,990; May 4, 1999
(“Maritzen”). (Ans. 3.)
Appeal 2010-000270
Application 10/829,625

4

2. Claims 2 and 3 are rejected under 35 U.S.C. 103(a) as being
unpatentable over Hamilton in view of Messinger and Maritzen as
applied to Claim 1, and further in view of US 6,269,373 B1; Jul. 31,
2001 (“Apte”). (Ans. 8.)

ISSUE 1
§ 103(a) Rejection of Claim 1
Appellants contend that the claim limitation “a container generates
access calls to the backend data store, and wherein the container-managed
persistence entity bean does not include the calls to the backend data store”
is not taught or suggested in the combination of Hamilton, Messinger, and
Maritzen. (App. Br. 16.)

Issue 1: Has the Examiner erred in finding that the combination of
Hamilton, Messinger, and Maritzen teaches or suggests the claim limitation
“a container generates access calls to the backend data store, and wherein the
container-managed persistence entity bean does not include the calls to the
backend data store” as recited in independent claim 1?

ANALYSIS
We have reviewed the Examiner’s rejections in light of Appellants’
arguments that the Examiner has erred. We are unpersuaded by Appellants’
arguments (App. Br. 15-17) that the combination of Hamilton, Messinger,
and Maritzen fails to teach or suggest the claim limitation “a container
generates access calls to the backend data store, and wherein the container-
Appeal 2010-000270
Application 10/829,625

5
managed persistence entity bean does not include the calls to the backend
data store.”
Appellants acknowledge that the Examiner relies on Messinger for the
disclosure of “container-managed persistence” (App. Br. 15; Messinger, col.
2, ll. 33-34), but contend that Hamilton teaches away from the disputed
limitation and that modifying Hamilton with the container-managed
persistence of Messinger would destroy the function of Hamilton and render
Hamilton inoperable for its intended purpose. (App. Br. 16.) Per the
Appellant, the mapped or converted commands in Hamilton are “executed
on the application server to access the database,” as described by Hamilton
at column 4, lines 13-14. (App. Br. 16.) Therefore, the Hamilton converted
commands include whatever calls to the database that they need in order to
access the database, which contradicts and teaches away from “the
container-managed persistence entity bean does not include the calls to the
backend data store,” as recited in claim 1. (App. Br. 16.) Appellants argue
that if Hamilton was hypothetically modified so that its bean (its general
programming language call) no longer includes the call to the backend store,
executing the Hamilton programming language call (bean) would no longer
result in a call to the Hamilton database. (App. Br. 17.) Consequently,
Appellants argue, the hypothetically modified Hamilton would no longer
convert a database call received from its client (first tier) into a call to its
database server (third tier) or enable “a computer application designed to
operate in a two tier computer environment” to “operate in a three tier
environment” (Hamilton, col. 2, ll. 29-36), destroying the stated purpose of
Hamilton. (App. Br. 17.)
Appeal 2010-000270
Application 10/829,625

6
Appellants further contend that Maritzen does not teach or suggest “a
container generates access calls to the backend data store, and wherein the
container-managed persistence entity bean does not include the calls to the
backend data store,” as recited in claim 1 because the Maritzen Abstract
merely describes that a “[s]erver . . . upon client command establishes a
connection to a database,” so Maritzen does not teach or suggest container-
managed persistence. (App. Br. 17.) Thereafter, Appellants conclude that
“no suggestion exists to combine Hamilton, Messinger, and
Maritzen.” (App. Br. 17.)
However, as Appellants noted (App. Br. 15), the Examiner finds that
Messinger discloses “container-managed persistence” (Ans. 12, citing
Messinger col. 2, ll. 33-34), and does not rely on Hamilton for the teaching
of this disputed claim element. Further, Hamilton does not criticize or
discredit the claimed feature of “the container managed persistence entity
bean does not include the calls to the backend data store” as recited in claim
1 and disclosed in Messinger. (Ans. 12-13.) Per the Examiner,
Hamilton discloses using EJB components for accessing a
database by mapping EJB components to the database fields
and properties (see Column 4: 33- 46). As the Appellants are
likely aware and disclosed by Messinger, an EJB container
typically hosts EJB components, such as entity beans or session
beans (see Column 1: 45-47). Thus, by incorporating the
teaching of Messinger into the teaching of Hamilton, one of
ordinary skill in the art would readily recognize that Hamilton's
EJB components are hosted by EJB containers. (Ans. 14.)

Appellants’ Specification teaches that if an entity bean has container-
managed persistence, the EJB container handles all database access required
Appeal 2010-000270
Application 10/829,625

7
by the entity bean. Appellants’ Specification further teaches that the entity
bean’s code contains no database access calls. (Spec. pages 3-4.) Thus, the
Examiner finds that if Hamilton was hypothetically modified to host the EJB
components in EJB containers such that “the container-managed persistence
entity bean does not include the calls to the backend data store,” Hamilton’s
invention would still function as originally intended because those of
ordinary skill in the art would readily comprehend that it is the EJB
container that executes the mapped or converted commands on the
application server to access the database, and not the entity bean. (Ans. 14-
15.) We agree.
Therefore, the Examiner finds that the combination of Hamilton,
Messinger, and Maritzen teaches or suggests the claim limitation “a
container generates access calls to the backend data store, and wherein the
container-managed persistence entity bean does not include the calls to the
backend data store” and renders claim 1 unpatentable. We agree with the
Examiner’s findings and conclusions. Accordingly, we sustain the rejection
of claim 1 under 35 U.S.C. § 103(a).

ISSUE 2
§ 103(a) Rejection of Claims 2 and 3
Appellants contend that the claim limitation “a container generates
access calls to the backend data store, and wherein the container-managed
persistence entity bean does not include the calls to the backend data store”
is not taught or suggested in the combination of Hamilton, Messinger,
Maritzen, and Apte. (App. Br. 17-18.)

Appeal 2010-000270
Application 10/829,625

8
Issue 2: Has the Examiner erred in finding that the combination of
Hamilton, Messinger, Maritzen, and Apte teaches or suggests the claim
limitation “a container generates access calls to the backend data store, and
wherein the container-managed persistence entity bean does not include the
calls to the backend data store” as recited in independent claim 1, on which
claims 2 and 3 depend?

ANALYSIS
We have reviewed the Examiner’s rejections in light of Appellants’
arguments that the Examiner has erred. We are unpersuaded by Appellants’
arguments (App. Br. 17-18) that the combination of Hamilton, Messinger,
Maritzen, and Apte fails to teach or suggest the claim limitation “a container
generates access calls to the backend data store, and wherein the container-
managed persistence entity bean does not include the calls to the backend
data store.”
Appellants contend that in Apte, a Java bean, which implements the
server object 402, contains the business logic that utilizes the SQL database
interface, which provides access to relational databases. Thus, Apte
contradicts and teaches away from claim 1, which requires that the “entity
bean does not include the calls to the backend data store.” (App. Br. 18.)
However, the Examiner relies on Apte for its teachings of “wherein an
instance of the container-managed persistence entity bean corresponds to a
row in a table of the relational database” in Claim 2 and “wherein the
backend data store comprises a nonrelational database” in Claim 3. (Ans.
16.) Apte discloses a technique of mapping references to a CORBA server
containing an Enterprise JavaBean to back-end data store using primitive
Appeal 2010-000270
Application 10/829,625

9
data types. (Ans. 17, citing Apte col. 16, l. 66-col. 17, l. 3.) The Examiner
finds that the Appellants have not demonstrated that Apte criticizes or
discredits the claimed feature of “the container-managed persistence entity
bean does not include the calls to the backend data store” as recited in Claim
1. (Id.) We agree.
As discussed above, the Examiner finds that the combination of
Hamilton, Messinger, and Maritzen teaches or suggests the claim limitation
“a container generates access calls to the backend data store, and wherein the
container-managed persistence entity bean does not include the calls to the
backend data store” and renders claim 1 unpatentable. Therefore, the
Examiner finds that the combination of Hamilton, Messinger, Maritzen, and
Apte renders claims 2 and 3 obvious. We agree.
Accordingly, we sustain the Examiner’s rejection of claims 2 and 3
under 35 U.S.C. § 103(a).

DECISION
The Examiner’s decision to reject claims 1-3 is affirmed.
No time period for taking any subsequent action in connection with
this appeal may be extended under 37 C.F.R. § 1.136(a)(1)(iv).

AFFIRMED

ke