DETAILED ACTION
Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Claims 1-3, 5-13, and 15-20 are pending in this application.
Response to Amendment
This Office Action is in response to applicant’s communication filed on July 31st, 2025. The applicant’s remark and amendments to the claims were considered with the results that follow.
In response to the last Office Action, claims 1-3, 5-13, and 15-20 have been amended. Claim 4 and 14 have been canceled. As a result, claims 1-3, 5-13, and 15-20 are pending in this application.
Applicant’s argument filed on July 31st, 2025, with respects to claims 1-20 being rejected under 35 U.S.C 101 as being non-statutory subject matter because the claim(s) as a whole are not significantly more than the abstract idea have overcome the rejection. The rejection have been withdrawn due to the rejection filed on July 31st, 2025.
Response to Arguments
Applicant’s arguments, see pg. -12, filed on July 31st,, with respect to the rejection(s) of claims 1, 11, under 35 U have been fully considered and are persuasive. Therefore, the rejection has been withdrawn. However, upon further consideration, a new ground(s) of rejection is made in view of U.S Patent 9,535,948 issued to Cuthbert et al. (hereinafter as "Cuthbert").
Applicant’s argument, see pgs. 11-13 of the remarks, filed on July 31st, 2025, with respect to the rejection of independent claims 1, 11, and 20 as amended under 35 U.S.C 103, where the applicant asserts the prior art does not teach or suggest the previously claim 4 reciting, "serializing the DAG; generating a database table based on the serialized DAG, the database table comprising a column corresponding to an object including the serialized DAG, a first column corresponding to partition identifier, and a second column corresponding to a serialized partition object” which has been incorporated in amended independent claims 1, 11, and 20.
Examiner respectfully disagrees. Park teaches serializing the DAG. Park indicates on [0171], “The DAG generator 1022 may be configured to define and/or create a Directed Acyclic Graph (DAG) of RDD objects based on the RDD objects that it receives from the receiver”. Park then later indicates when it receives an RDD object, it perform serialization (See [0175]; when an executor node 1018 receives an RDD object, it performs the serialization). That RDD is based on DAG generated in which creates the Directed Acyclic Graph of RDD objects.
Applicant later indicates that Park does not teach generating a database table based on the serialized DAG. Park show on Table 1 shown below a list of tuple of events being populated in the table.
PNG
media_image1.png
172
314
media_image1.png
Greyscale
Additionally, applicant argues that Park does not teach or suggest, “the database table comprises a column corresponding to an object including the serialized DAG, a first column corresponding to partition identifier.
Examiner respectfully disagrees. Park teaches a database table comprises a column corresponding to an object including the serialized DAG, a first column corresponding to partition identifier as the claim indicates column from the serialized DAG represents two set of columns that comprises of a partition identifier and a second column corresponding to a serialized partition object.
Park indicates partition identifier based on the order identifier. Park teaches this on [0112]; Each order in the order event stream may comprise attributes such as an order identifier, an order status, and an order amount related to an item. Park then additionally teaches a second column corresponding to a serialized partition object based on the event batch being serialized according to the attribute of the event. Park indicates this on [0199]. Park states on [0199], “the events in the event batch are serialized by identifying the data type of each attribute of the events and determining a particular type of compression technique to be applied to the data values represented by each attribute based on the data type of the attribute” (NOTE: Park describes on [0182], “the one or more attributes of the events may be represented as one or more columns in the set of input tuples (batch of events) and hence, an attribute, in some examples, may refer to a column that stores data values for a tuple(event) in the set of input tuples”. This indicates a second column as the one or more attributes represents one or more columns of the specific attribute represents on the columns associated to the batch of events.
Thus, Park does indeed teach event batch being serialized for the identifying the data type of each attribute in the event. Thus, the second column represents a serialized partition object for order amount associated to the tuple event.
PNG
media_image1.png
172
314
media_image1.png
Greyscale
{Examiner correlates Attribute 1 (column 1) Order Id as the partition number and Attribute 3 (column 3) Order amount as the second column that corresponds to a serialized partition object});
As such, Park teaches the above limitations.
Claim Rejections - 35 USC § 103
The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action:
A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made.
Claims 1-5, 8-9, 11-15, and 18-20 are rejected under 35 U.S.C. 103 as being unpatentable over U.S Patent 9,535,948 issued to Cuthbert et al. (hereinafter as "Cuthbert") in view of E.P Patent Application Publication 3889776 issued to Jun Tan et al. (hereinafter as "Tan") in further view of U.S Patent Application Publication 2018/0075107 issued to Park et al. (hereinafter as “Park”).
Regarding claim 1, Cuthbert teaches a system comprising: at least one hardware processor (Cuthbert: Col 7, lines 35-38; The processor(s) 302 may comprise one or more cores, and may be hardware processor(s) such as one or more central processing units (CPUs)); and a memory storing instructions that cause the at least one hardware processor to perform operations comprising (Cuthbert: Col 7, lines 32-36; the host device 102 may include one or more processors 302 configured to execute one or more stored instructions):
converting the first code to second code in a second programming language different than the first programming language, and at least one database query in a second format different than the first programming language (Cuthbert: Col 5, lines 3-6; The statement processing device(s) 116 may execute a statement processing module 118 to receive, translate, analyze, or otherwise process the first set of statements 108. Col 5, lines 18-24; The second set of statements 126 may include one or more statements that are specified using a second query language that is different from the first query language of the first set of statements 108. In this way, the statement processing module 118 may translate the first set of statements 108 from a first query language to a second query language {See Col 2, lines 10-13; The translated statements may then be executed on a second data storage that supports the different query language, a different transaction model, or a different storage format),
the converting performing a translation of the generated RDD and the generated second RDD to the at least one database query that can execute on the database table (Cuthbert: Col 2, lines 13-15; The result data set generated through execution of the translated statements may be returned to the statement processing device. Col 3, lines 36-38; Each statement may indicate one or more operations to be performed on stored data. Col 5, lines 3-6; The statement processing device(s) 116 may execute a statement processing module 118 to receive, translate, analyze, or otherwise process the first set of statements 108. Col 5, lines 18-24; The second set of statements 126 may include one or more statements that are specified using a second query language that is different from the first query language of the first set of statements 108. In this way, the statement processing module 118 may translate the first set of statements 108 from a first query language to a second query language. Col 6, lines 5-10; the first set of statements 108 may be described using a version of SQL to accessing a relational database, and the second set of statements 126 may be described using a query language for accessing a non-relational datastore such as a key-value store {Examiner correlates the generated RDD and secondary RDD as a set of statements where that set of statement is that translated to another query language to be executed and return from the other storage}); and
sending the converted first code and the at least one database query to a database system for execution (Cuthbert: Col 2, lines 13-15; The result data set generated through execution of the translated statements may be returned to the statement processing device. Col 3, lines 18-21; The application(s) 104 may include one or more statements for accessing a data storage to retrieve data, store data, update or modify stored data, or delete data from the data storage. Col 3, lines 36-37; Each statement may indicate one or more operations to be performed on stored data).
Cuthbert does not explicitly teach generating, by executing first code in a first programming language, a resilient distributed dataset (RDD); generating, by executing the first code in the first programming language, a second RDD based on the generated RDD, the first code further including: a first particular code statement invoking a first set of operations to generate the RDD, a second particular code statement invoking a second set of operations to map data associated with the RDD and generating the second RDD, the second RDD including a reference to the RDD generated by the first particular code statement, and a third particular code statement initiating execution of a particular operation to run the second RDD, provided by the second particular code statement, and the particular operation providing a set of results; generating, by executing the first code in the first programming language, a directed acyclic graph (DAG) including the generated RDD and the generated second RDD.
However, Tan teaches generating, by executing first code in a first programming language, a resilient distributed dataset (RDD) (Tan: [0040]-[0041]; Generate an RDD by using a data source (a text file, a chart file, or the like), or transform an existing RDD (for example, an RDD 1) into another RDD (for example, an RDD 2). For example, as shown in FIG. 2, a DAG 1 is that a map operation is performed on a text file (source data) to generate an RDD 1, and then a filter operation is performed to generate an RDD 2 {Examiner correlates the source data being received as receiving a text file to the executor to create the RDD (first dataset). That is the functional expression (code) is receive to generate the RDD});
generating, by executing the first code in the first programming language, a second RDD based on the generated RDD (Tan: [0040]-[0041]; Generate an RDD by using a data source (a text file, a chart file, or the like), or transform an existing RDD (for example, an RDD 1) into another RDD (for example, an RDD 2). Common transformation includes a map (map) operation, a filter (filter) operation, a flatMap (flatMap) operation, a union operation, a join operation, a reduceByKey operation, and the like. For example, as shown in FIG. 2, a DAG 1 is that a map operation is performed on a text file (source data) to generate an RDD 1, and then a filter operation is performed to generate an RDD 2), the first code further including:
a first particular code statement invoking a first set of operations to generate the RDD (Tan: [0040]; RDD transformation (transformation) operation: Generate an RDD by using a data source (a text file, a chart file, or the like). Common transformation includes a map (map) operation, a filter (filter) operation, a flatMap (flatMap) operation, a union operation, a join operation, a reduceByKey operation, and the like [0052]; Step 5: The SparkContext loads source data (such as a text file and a chart file) from each executor, creates an RDD… the tasks and dependent data of the tasks are serialized and then sent to each executor. [0054]; Step 6: Each executor runs the task allocated to it and releases all resources after the running is completed),
a second particular code statement invoking a second set of operations to map data associated with the RDD and generating the second RDD, the second RDD including a reference to the RDD generated by the first particular code statement (Tan: [0040]; RDD transformation (transformation) operation: Generate an RDD by using a data source (a text file, a chart file, or the like), or transform an existing RDD (for example, an RDD 1) into another RDD (for example, an RDD 2) [0052]; Step 5: The SparkContext loads source data (such as a text file and a chart file) from each executor, creates an RDD… the tasks and dependent data of the tasks are serialized and then sent to each executor. [0054]; Step 6: Each executor runs the task allocated to it and releases all resources after the running is completed), and
a third particular code statement initiating execution of a particular operation to run the second RDD, provided by the second particular code statement, and the particular operation providing a set of results (Tan: [0040]; RDD transformation (transformation) operation: Generate an RDD by using a data source (a text file, a chart file, or the like). Common transformation includes a map (map) operation, a filter (filter) operation, a flatMap (flatMap) operation, a union operation, a join operation, a reduceByKey operation, and the like. [0043]; RDD sharing: During RDD transformation, if two or more DAGs have a same RDD, the same RDD can be reused by the DAGs, thereby implementing sharing. In this way, the RDD 1 may be directly invoked when the RDD 2 and an RDD 3 are generated subsequently. [0052]; Step 5: The SparkContext loads source data (such as a text file and a chart file) from each executor, creates an RDD… the tasks and dependent data of the tasks are serialized and then sent to each executor. [0054]; Step 6: Each executor runs the task allocated to it and releases all resources after the running is completed);
generating, by executing the first code in the first programming language, a directed acyclic graph (DAG) including the generated RDD and the generated second RDD (Tan: [0041]; Directed acyclic graph (Directed Acyclic Graph, DAG): A plurality of transformation operations are provided for an RDD, and each transformation operation generates a new RDD. In other words, a new RDD depends on an original RDD, and the dependency between the RDDs forms a DAG);
It would have been obvious to a person of ordinary skill in the art, before the effective filing date of the invention, to modify Cuthbert (teaches converting the first code to second code in a second programming language different than the first programming language and sending the converted code for execution) with the teachings of Tan (teaches generating, by executing first code in a first programming language, a resilient distributed dataset (RDD); generating, by executing the first code in the first programming language, a second RDD based on the generated RDD…generating, by executing the first code in the first programming language, a directed acyclic graph (DAG) including the generated RDD and the generated second RDD). One of ordinary skill in the art would have been motivated to make such a combination of providing better steps in reusing RDDs in which are shared therefore improves the running speed of the Spark system (See Tan [0060]). In addition, the references (Cuthbert and Tan) teach features that are directed to analogous art and they are directed to the same field of endeavor as Cuthbert and Tan are directed to receiving and converting operations based on its corresponding requirement.
The modification of Cuthbert and Tan teaches claimed invention substantially as claimed, however the modification of Cuthbert and Tan does not explicitly teach serializing the DAG; generating a database table based on the serialized DAG, the database table comprises a column corresponding to an object including the serialized DAG, a first column corresponding to partition identifier, and a second column corresponding to a serialized partition object;
However, Park teaches serializing the DAG (Park: [0171]; The DAG generator 1022 may be configured to define and/or create a Directed Acyclic Graph (DAG) of RDD objects based on the RDD objects that it receives from the receiver. In some examples, the DAG generator 1022 may represent the DAG of RDD objects as a RDD lineage graph of all the RDDs that it has received during a certain interval of time. [0175]; when an executor node 1018 receives an RDD object, it performs the serialization and de-serialization of data in the RDD object {Examiner correlates Tuple (event) as the column corresponding to an object including the serialized DAG as the further limitations indicate serialized DAG comprises of a database table which include the partition identifier and the serialized partition object as shown below on Table 1.
PNG
media_image1.png
172
314
media_image1.png
Greyscale
),
generating a database table based on the serialized DAG(Park: [0171]; The DAG generator 1022 may be configured to define and/or create a Directed Acyclic Graph (DAG) of RDD objects based on the RDD objects that it receives from the receiver. In some examples, the DAG generator 1022 may represent the DAG of RDD objects as a RDD lineage graph of all the RDDs that it has received during a certain interval of time. [0175]; when an executor node 1018 receives an RDD object, it performs the serialization and de-serialization of data in the RDD object if the RDD object needs to be sent to other executor (worker) nodes in the cluster of computing nodes. [0177]; In certain examples, the CQL transformations 1108 invokes a batch serializer process 1112 against the set of input tuples in the RDD object to perform the serialization of data in the RDD object. As noted above, the data in the RDD object represents a batch of input tuples (events) received via the event stream. [0197]; FIG. 15 is an example of the manner in which event stream data can be serialized based on determining the data type of the attributes of the events in the event stream. Each event in the event stream may represent an order for an item and comprise attributes such as an order identifier, an order status, and an order amount related to the item. The schema for such an order event stream can be represented as S(timestamp, <orderId>, <orderStatus>, <orderAmount>). Each event received via such a stream can thus be identified by a time stamp and three attributes
PNG
media_image1.png
172
314
media_image1.png
Greyscale
{Examiner correlates Tuple (event) as the column corresponding to an object including the serialized DAG}),
the database table comprises a column corresponding to an object including the serialized DAG, a first column corresponding to partition identifier and a second column corresponding to a serialized partition object (Park: [0182]; Hence, an attribute, in some examples, may refer to a column that stores data values for a tuple(event) in the set of input tuples. [0199]; the events in the event batch are serialized by identifying the data type of each attribute of the events and determining a particular type of compression technique to be applied to the data values represented by each attribute based on the data type of the attribute {See Park: [0166]; an RDD object, which is an immutable, partitioned collection of elements that can be executed on in parallel in the cluster of computing nodes 1012 in the distributed event processing system 1002. [0176]; In one embodiment, and as described in relation to FIG. 10, each batch of events (tuples) may internally be represented by the receiver as an RDD object}
PNG
media_image1.png
172
314
media_image1.png
Greyscale
{Examiner correlates Attribute 1 (column 1) Order Id as the partition number and Attribute 3 (column 3) Order amount as the second column that corresponds to a serialized partition object});
It would have been obvious to a person of ordinary skill in the art, before the effective filing date of the invention, to modify Cuthbert (teaches converting the first code to second code in a second programming language different than the first programming language and sending the converted code for execution) with the teachings of Tan (teaches generating, by executing first code in a first programming language, a resilient distributed dataset (RDD); generating, by executing the first code in the first programming language, a second RDD based on the generated RDD…generating, by executing the first code in the first programming language, a directed acyclic graph (DAG) including the generated RDD and the generated second RDD) with the further teachings of Park (teaches serializing the DAG; generating a database table based on the serialized DAG). One of ordinary skill in the art would have been motivated to make such a combination of providing better steps of organizing dataset utilizing a table set in such provide clear expectation on how the system performs and determine unrelated events in such to provide better correction (See Park: [0071). In addition, the references (Cuthbert, Tan, and Park) teach features that are directed to analogous art and they are directed to the same field of endeavor as Cuthbert, Tan, and Park are directed to receiving and transforming code based on its corresponding requirement.
Regarding claim 2, the modification of Cuthbert, Tan, and Park teaches claimed invention substantially as claimed, and Tan further teaches the RDD comprises information defining a set of partitions and including a set of data partitioned into the set of partition (Tan: [0040]; Generate an RDD by using a data source (a text file, a chart file, or the like), or transform an existing RDD (for example, an RDD 1) into another RDD (for example, an RDD 2). [0102]; Each RDD may be divided into a plurality of partitions. Each partition is a dataset segment and is a minimum unit for parallel RDD execution. In addition, different partitions of an RDD may be stored on different workers in the cluster, so that parallel computations may be performed on the different workers in the cluster), the RDD being in a first format that is incompatible with the database system (Tan: [0040]; transform an existing RDD (for example, an RDD 1) into another RDD (for example, an RDD 2). The RDD 1 is referred to as a parent RDD of the RDD 2, and the RDD 2 is referred to as a child RDD of the RDD 1 {Examiner correlates that the RDD in it first format is unsuited in its current form in which would require a transformation operation to be perform on the first RDD to transform to another form}).
Regarding claim 3, the modification of Cuthbert, Tan, and Park teaches claimed invention substantially as claimed, and Tan further teaches the operations further comprise: prior to generating the RDD, receiving the first code in the first programming language, the first code including a reference to a first dataset (Tan: [0040]-[0041]; Generate an RDD by using a data source (a text file, a chart file, or the like), or transform an existing RDD (for example, an RDD 1) into another RDD (for example, an RDD 2)...A plurality of transformation operations are provided for an RDD, and each transformation operation generates a new RDD. For example, as shown in FIG. 2, a DAG 1 is that a map operation is performed on a text file (source data) to generate an RDD 1, and then a filter operation is performed to generate an RDD 2 {Examiner correlates the source data being received as receiving a text file to the executor to create the RDD (first dataset). That is the functional expression (code) is receive to generate the RDD}), the first dataset corresponding to the RDD to be generated (Tan: [0040]; Generate an RDD by using a data source (a text file, a chart file, or the like), or transform an existing RDD (for example, an RDD 1) into another RDD (for example, an RDD 2). [0051]-[0052]; Step 4: Each executor applies for a task from the SparkContext. Step 5: The SparkContext loads source data (such as a text file and a chart file) from each executor, creates an RDD. [0056]; Each executor executes a task corresponding to an application program of the executor. It can be learned that data cannot be shared among different application programs).
Regarding claim 5, the modification of Cuthbert, Tan, and Park teaches claimed invention substantially as claimed, and Tan further teaches the RDD comprises a first object and the second RDD comprises a second object (Tan: [0040]; Generate an RDD by using a data source (a text file, a chart file, or the like), or transform an existing RDD (for example, an RDD 1) into another RDD (for example, an RDD 2). [0052]; Step 5: The SparkContext loads source data (such as a text file and a chart file) from each executor, creates an RDD, and constructs a DAG graph. [0108]; When an RDD is created, a dataset (that is, source data) in memory is read first, then a first RDD is created, and a subsequent RDD is formed after a plurality of transformation operations are performed on the first RDD).
Regarding claim 8, the modification of Cuthbert, Tan, and Park teaches claimed invention substantially as claimed, and Cuthbert further teaches the operations further comprise: determining that the first code includes an action command that triggers an output of results or storing the results (Cuthbert: Col 3, lines 18-21; The application(s) 104 may include one or more statements for accessing a data storage to retrieve data, store data, update or modify stored data, or delete data from the data storage. Col 3, lines 36-40; Each statement may indicate one or more operations to be performed on stored data. For example, statements may be configured to perform operations including, but not limited to: operations to retrieve records from a dataset (e.g., select operations); operations to add new records to a dataset (e.g., insert operations)).
Regarding claim 9, the modification of Cuthbert, Tan, and Park teaches claimed invention substantially as claimed, and Tan further teaches the RDD represents a transformation operation, the transformation operation applies a function on the RDD and creates a new RDD, and operations further comprise: generating a tree of RDD operations based on the RDD (Tan: [0041]; provided for an RDD, and each transformation operation generates a new RDD. In other words, a new RDD depends on an original RDD, and the dependency between the RDDs forms a DAG. For example, as shown in FIG. 2, a DAG 1 is that a map operation is performed on a text file (source data) to generate an RDD 1, and then a filter operation is performed to generate an RDD 2); and evaluating the tree of RDD operations based on the action command (Tan: [0041]; the dependency between the RDDs forms a DAG. For example, as shown in FIG. 2, a DAG 1 is that a map operation is performed on a text file (source data) to generate an RDD 1, and then a filter operation is performed to generate an RDD 2. [0108]; When an RDD is created, a dataset (that is, source data) in memory is read first, then a first RDD is created, and a subsequent RDD is formed after a plurality of transformation operations are performed on the first RDD. Therefore, when it is determined whether two or more RDDs are the same).
Regarding claim 11, Cuthbert teaches a method comprising: converting the first code to second code in a second programming language different than the first programming language (Cuthbert: Col 5, lines 3-6; The statement processing device(s) 116 may execute a statement processing module 118 to receive, translate, analyze, or otherwise process the first set of statements 108. Col 5, lines 18-24; The second set of statements 126 may include one or more statements that are specified using a second query language that is different from the first query language of the first set of statements 108. In this way, the statement processing module 118 may translate the first set of statements 108 from a first query language to a second query language {See Col 2, lines 10-13; The translated statements may then be executed on a second data storage that supports the different query language, a different transaction model, or a different storage format}), and
at least one database query in a second format different than the first programming language (Cuthbert: Col 5, lines 18-24; The second set of statements 126 may include one or more statements that are specified using a second query language that is different from the first query language of the first set of statements 108. In this way, the statement processing module 118 may translate the first set of statements 108 from a first query language to a second query language {See Col 2, lines 10-13; The translated statements may then be executed on a second data storage that supports the different query language, a different transaction model, or a different storage format}),
the converting performing a translation of the generated RDD and the generated second RDD to the at least one database query that can execute on the database table (Cuthbert: Col 2, lines 13-15; The result data set generated through execution of the translated statements may be returned to the statement processing device. Col 3, lines 36-38; Each statement may indicate one or more operations to be performed on stored data. Col 5, lines 3-6; The statement processing device(s) 116 may execute a statement processing module 118 to receive, translate, analyze, or otherwise process the first set of statements 108. Col 5, lines 18-24; The second set of statements 126 may include one or more statements that are specified using a second query language that is different from the first query language of the first set of statements 108. In this way, the statement processing module 118 may translate the first set of statements 108 from a first query language to a second query language. Col 6, lines 5-10; the first set of statements 108 may be described using a version of SQL to accessing a relational database, and the second set of statements 126 may be described using a query language for accessing a non-relational datastore such as a key-value store); and
sending the converted first code and the at least one database query to a database system for execution (Cuthbert: Col 2, lines 13-15; The result data set generated through execution of the translated statements may be returned to the statement processing device. Col 3, lines 18-21; The application(s) 104 may include one or more statements for accessing a data storage to retrieve data, store data, update or modify stored data, or delete data from the data storage. Col 3, lines 36-37; Each statement may indicate one or more operations to be performed on stored data).
Cuthbert does not explicitly teach generating, by executing first code in a first programming language, a resilient distributed dataset (RDD); generating, by executing the first code in the first programming language, a second RDD based on the generated RDD, the first code further including: a first particular code statement invoking a first set of operations to generate the RDD, a second particular code statement invoking a second set of operations to map data associated with the RDD and generating the second RDD, the second RDD including a reference to the RDD generated by the first particular code statement, and a third particular code statement initiating execution of a particular operation to run the second RDD, provided by the second particular code statement, and the particular operation providing a set of results; generating, by executing the first code in the first programming language, a directed acyclic graph (DAG) including the generated RDD and the generated second RDD.
However, Tan teaches generating, by executing first code in a first programming language, a resilient distributed dataset (RDD) (Tan: [0040]; Generate an RDD by using a data source (a text file, a chart file, or the like), or transform an existing RDD (for example, an RDD 1) into another RDD (for example, an RDD 2). [0051]-[0052]; Step 4: Each executor applies for a task from the SparkContext. Step 5: The SparkContext loads source data (such as a text file and a chart file) from each executor, creates an RDD);
generating, by executing the first code in the first programming language, a second RDD based on the generated RDD (Tan: [0040]-[0041]; Generate an RDD by using a data source (a text file, a chart file, or the like), or transform an existing RDD (for example, an RDD 1) into another RDD (for example, an RDD 2)...A plurality of transformation operations are provided for an RDD, and each transformation operation generates a new RDD. For example, as shown in FIG. 2, a DAG 1 is that a map operation is performed on a text file (source data) to generate an RDD 1, and then a filter operation is performed to generate an RDD 2 {Examiner correlates the source data being received as receiving a text file to the executor to create the RDD (first dataset). That is the functional expression (code) is receive to generate the RDD}),
the first code further including: a first particular code statement invoking a first set of operations to generate the RDD (Tan: [0040]; Generate an RDD by using a data source (a text file, a chart file, or the like), or transform an existing RDD (for example, an RDD 1) into another RDD (for example, an RDD 2). [0051]-[0052]; Step 4: Each executor applies for a task from the SparkContext. Step 5: The SparkContext loads source data (such as a text file and a chart file) from each executor, creates an RDD. [0052]; Step 5: The SparkContext loads source data (such as a text file and a chart file) from each executor, creates an RDD… the tasks and dependent data of the tasks are serialized and then sent to each executor. [0054]; Step 6: Each executor runs the task allocated to it and releases all resources after the running is completed),
a second particular code statement invoking a second set of operations to map data associated with the RDD and generating the second RDD, the second RDD including a reference to the RDD generated by the first particular code statement (Tan: [0040]; RDD transformation (transformation) operation: Generate an RDD by using a data source (a text file, a chart file, or the like), or transform an existing RDD (for example, an RDD 1) into another RDD (for example, an RDD 2) [0052]; Step 5: The SparkContext loads source data (such as a text file and a chart file) from each executor, creates an RDD… the tasks and dependent data of the tasks are serialized and then sent to each executor. [0054]; Step 6: Each executor runs the task allocated to it and releases all resources after the running is completed), and
a third particular code statement initiating execution of a particular operation to run the second RDD, provided by the second particular code statement, and the particular operation providing a set of results (Tan: [0040]; RDD transformation (transformation) operation: Generate an RDD by using a data source (a text file, a chart file, or the like). Common transformation includes a map (map) operation, a filter (filter) operation, a flatMap (flatMap) operation, a union operation, a join operation, a reduceByKey operation, and the like. [0043]; RDD sharing: During RDD transformation, if two or more DAGs have a same RDD, the same RDD can be reused by the DAGs, thereby implementing sharing. In this way, the RDD 1 may be directly invoked when the RDD 2 and an RDD 3 are generated subsequently. [0052]; Step 5: The SparkContext loads source data (such as a text file and a chart file) from each executor, creates an RDD… the tasks and dependent data of the tasks are serialized and then sent to each executor. [0054]; Step 6: Each executor runs the task allocated to it and releases all resources after the running is completed);
generating, by executing the first code in the first programming language, a directed acyclic graph (DAG) including the generated RDD and the generated second RDD (Tan: [0041]; Directed acyclic graph (Directed Acyclic Graph, DAG): A plurality of transformation operations are provided for an RDD, and each transformation operation generates a new RDD. In other words, a new RDD depends on an original RDD, and the dependency between the RDDs forms a DAG);
It would have been obvious to a person of ordinary skill in the art, before the effective filing date of the invention, to modify Cuthbert (teaches converting the first code to second code in a second programming language different than the first programming language and sending the converted code for execution) with the teachings of Tan (teaches generating, by executing first code in a first programming language, a resilient distributed dataset (RDD); generating, by executing the first code in the first programming language, a second RDD based on the generated RDD…generating, by executing the first code in the first programming language, a directed acyclic graph (DAG). One of ordinary skill in the art would have been motivated to make such a combination of providing better steps in reusing RDDs in which are shared therefore improves the running speed of the Spark system (See Tan [0060]). In addition, the references (Cuthbert and Tan) teach features that are directed to analogous art and they are directed to the same field of endeavor as Cuthbert and Tan are directed to receiving and converting operations based on its corresponding requirement.
The modification of Cuthbert and Tan teaches claimed invention substantially as claimed, however the modification of Cuthbert and Tan does not explicitly teach serializing the DAG; generating a database table based on the serialized DAG, the database table comprises a column corresponding to an object including the serialized DAG, a first column corresponding to partition identifier, and a second column corresponding to a serialized partition object;
However, Park teaches serializing the DAG (Park: [0171]; The DAG generator 1022 may be configured to define and/or create a Directed Acyclic Graph (DAG) of RDD objects based on the RDD objects that it receives from the receiver. In some examples, the DAG generator 1022 may represent the DAG of RDD objects as a RDD lineage graph of all the RDDs that it has received during a certain interval of time. [0175]; when an executor node 1018 receives an RDD object, it performs the serialization and de-serialization of data in the RDD object {Examiner correlates Tuple (event) as the column corresponding to an object including the serialized DAG as the further limitations indicate serialized DAG comprises of a database table which include the partition identifier and the serialized partition object as shown below on Table 1.
PNG
media_image1.png
172
314
media_image1.png
Greyscale
),
generating a database table based on the serialized DAG(Park: [0171]; The DAG generator 1022 may be configured to define and/or create a Directed Acyclic Graph (DAG) of RDD objects based on the RDD objects that it receives from the receiver. In some examples, the DAG generator 1022 may represent the DAG of RDD objects as a RDD lineage graph of all the RDDs that it has received during a certain interval of time. [0175]; when an executor node 1018 receives an RDD object, it performs the serialization and de-serialization of data in the RDD object if the RDD object needs to be sent to other executor (worker) nodes in the cluster of computing nodes. [0177]; In certain examples, the CQL transformations 1108 invokes a batch serializer process 1112 against the set of input tuples in the RDD object to perform the serialization of data in the RDD object. As noted above, the data in the RDD object represents a batch of input tuples (events) received via the event stream. [0197]; FIG. 15 is an example of the manner in which event stream data can be serialized based on determining the data type of the attributes of the events in the event stream. Each event in the event stream may represent an order for an item and comprise attributes such as an order identifier, an order status, and an order amount related to the item. The schema for such an order event stream can be represented as S(timestamp, <orderId>, <orderStatus>, <orderAmount>). Each event received via such a stream can thus be identified by a time stamp and three attributes
PNG
media_image1.png
172
314
media_image1.png
Greyscale
{Examiner correlates Tuple (event) as the column corresponding to an object including the serialized DAG}),
the database table comprises a column corresponding to an object including the serialized DAG, a first column corresponding to partition identifier and a second column corresponding to a serialized partition object (Park: [0182]; Hence, an attribute, in some examples, may refer to a column that stores data values for a tuple(event) in the set of input tuples. [0199]; the events in the event batch are serialized by identifying the data type of each attribute of the events and determining a particular type of compression technique to be applied to the data values represented by each attribute based on the data type of the attribute {See Park: [0166]; an RDD object, which is an immutable, partitioned collection of elements that can be executed on in parallel in the cluster of computing nodes 1012 in the distributed event processing system 1002. [0176]; In one embodiment, and as described in relation to FIG. 10, each batch of events (tuples) may internally be represented by the receiver as an RDD object}
PNG
media_image1.png
172
314
media_image1.png
Greyscale
{Examiner correlates Attribute 1 (column 1) Order Id as the partition number and Attribute 3 (column 3) Order amount as the second column that corresponds to a serialized partition object});
It would have been obvious to a person of ordinary skill in the art, before the effective filing date of the invention, to modify Cuthbert (teaches converting the first code to second code in a second programming language different than the first programming language and sending the converted code for execution) with the teachings of Tan (teaches generating, by executing first code in a first programming language, a resilient distributed dataset (RDD); generating, by executing the first code in the first programming language, a second RDD based on the generated RDD…generating, by executing the first code in the first programming language, a directed acyclic graph (DAG) including the generated RDD and the generated second RDD) with the teachings of Park (teaches serializing the DAG; generating a database table based on the serialized DAG). One of ordinary skill in the art would have been motivated to make such a combination of providing better steps of organizing dataset utilizing a table set in such provide clear expectation on how the system performs and determine unrelated events in such to provide better correction (See Park: [0071). In addition, the references (Cuthbert, Tan, and Park) teach features that are directed to analogous art and they are directed to the same field of endeavor as Cuthbert, Tan, and Park are directed to receiving and transforming code based on its corresponding requirement.
Regarding claim 12, the modification of Cuthbert, Tan, and Park teaches claimed invention substantially as claimed, and Tan further teaches the RDD comprises information defining a set of partitions and including a set of data partitioned into the set of partitions, the RDD being in a first format that is incompatible with the database system (Tan: [0040]; Generate an RDD by using a data source (a text file, a chart file, or the like), or transform an existing RDD (for example, an RDD 1) into another RDD (for example, an RDD 2). [0102]; Each RDD may be divided into a plurality of partitions. Each partition is a dataset segment and is a minimum unit for parallel RDD execution. In addition, different partitions of an RDD may be stored on different workers in the cluster, so that parallel computations may be performed on the different workers in the cluster).
Regarding claim 13, the modification of Cuthbert, Tan, and Park teaches claimed invention substantially as claimed, and Tan further teaches prior to generating the RDD, receiving the first code in the first programming language, the first code including a reference to a first dataset (Tan: [0040]-[0041]; Generate an RDD by using a data source (a text file, a chart file, or the like), or transform an existing RDD (for example, an RDD 1) into another RDD (for example, an RDD 2)...A plurality of transformation operations are provided for an RDD, and each transformation operation generates a new RDD. For example, as shown in FIG. 2, a DAG 1 is that a map operation is performed on a text file (source data) to generate an RDD 1, and then a filter operation is performed to generate an RDD 2 {Examiner correlates the source data being received as receiving a text file to the executor to create the RDD (first dataset). That is the functional expression (code) is receive to generate the RDD}), the first dataset corresponding to the RDD to be generated (Tan: [0040]; Generate an RDD by using a data source (a text file, a chart file, or the like), or transform an existing RDD (for example, an RDD 1) into another RDD (for example, an RDD 2). [0051]-[0052]; Step 4: Each executor applies for a task from the SparkContext. Step 5: The SparkContext loads source data (such as a text file and a chart file) from each executor, creates an RDD. [0056]; Each executor executes a task corresponding to an application program of the executor. It can be learned that data cannot be shared among different application programs).
Regarding claim 15, the modification of Cuthbert, Tan, and Park teaches claimed invention substantially as claimed, and Tan further teaches the RDD comprises a first object and the second RDD comprises a second object (Tan: [0040]; Generate an RDD by using a data source (a text file, a chart file, or the like), or transform an existing RDD (for example, an RDD 1) into another RDD (for example, an RDD 2). [0052]; Step 5: The SparkContext loads source data (such as a text file and a chart file) from each executor, creates an RDD, and constructs a DAG graph. [0108]; When an RDD is created, a dataset (that is, source data) in memory is read first, then a first RDD is created, and a subsequent RDD is formed after a plurality of transformation operations are performed on the first RDD).
Regarding claim 18, the modification of Cuthbert, Tan, and Park teaches claimed invention substantially as claimed, and Cuthbert further teaches determining that the first code includes an action command that triggers an output of results or storing the results (Cuthbert: Col 3, lines 18-21; The application(s) 104 may include one or more statements for accessing a data storage to retrieve data, store data, update or modify stored data, or delete data from the data storage. Col 3, lines 36-40; Each statement may indicate one or more operations to be performed on stored data. For example, statements may be configured to perform operations including, but not limited to: operations to retrieve records from a dataset (e.g., select operations); operations to add new records to a dataset (e.g., insert operations)).
Regarding claim 19, the modification of Cuthbert, Tan, and Park teaches claimed invention substantially as claimed, and Tan further teaches the RDD represents a transformation operation, the transformation operation applies a function on the RDD and creates a new RDD, and operations further comprise: generating a tree of RDD operations based on the RDD (Tan: [0041]; provided for an RDD, and each transformation operation generates a new RDD. In other words, a new RDD depends on an original RDD, and the dependency between the RDDs forms a DAG. For example, as shown in FIG. 2, a DAG 1 is that a map operation is performed on a text file (source data) to generate an RDD 1, and then a filter operation is performed to generate an RDD 2); and
evaluating the tree of RDD operations based on the action command (Tan: [0041]; the dependency between the RDDs forms a DAG. For example, as shown in FIG. 2, a DAG 1 is that a map operation is performed on a text file (source data) to generate an RDD 1, and then a filter operation is performed to generate an RDD 2. [0108]; When an RDD is created, a dataset (that is, source data) in memory is read first, then a first RDD is created, and a subsequent RDD is formed after a plurality of transformation operations are pe