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 performed on the first RDD. Therefore, when it is determined whether two or more RDDs are the same).
Regarding claim 20, Cuthbert teaches a non-transitory computer-storage medium comprising instructions that (Cuthbert: Col 8, lines 14-17; The memory 310 comprises one or more computer-readable storage media (CRSM). The CRSM may include one or more of an electronic storage medium, a magnetic storage medium, an optical storage medium, a quantum storage medium, a mechanical computer storage medium, and so forth), when executed by one or more processors of a machine (Cuthbert: Col 9, lines 27-30; the statement processing device 116 may include one or more processors 402 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); 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 configure the machine to perform operations comprising: 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.
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.
Claim 10 is 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 view of U.S Patent Application Publication 2018/0075107 issued to Park et al. (hereinafter as “Park”) in further view of U.S Patent Application Publication 2018/0275977 issued to Kudriavtsev et al. (hereinafter as "Kudriavtsev").
Regarding claim 10, the modification of Cuthbert, Tan, and Park teaches claimed invention substantially as claimed, however the modification of Cuthbert, Tan, and Park does not explicitly teach the first code in the first programming language corresponds to an external system different than the database system including a storage platform, the first code being incompatible with the database system.
However, Kudriavtsev teaches the first code in the first programming language corresponds to an external system different than the database system including a storage platform, the first code being incompatible with the database system(Kudriavtsev: [0022]; determined that the generated source code 116 requires modification, then conversion processing unit 112 may iterate 120 or otherwise modify the new source code. In various embodiments, reasons for modifying the new source code 116 may include determining the initially generated new source code 116 includes syntax errors, is not functionally equivalent to the original source code 102, or some other reason that prevents the new source code 116 from being a usable valid representation of the original source code 102).
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) to further include the teachings of Kudriavtsev (teaches an action command that triggers an output of results, wherein converting the first code to second code is in response to the determining that the first code includes the action command). One of ordinary skill in the art would have been motivated to make such a combination of providing better steps of observing the code statement to determine to proceed to invoke the action in such provides better improvement in generating the new code while maintaining the separation in the old code in improving the efficiency in executing the program (See Kudriavtsev: [0047). In addition, the references (Cuthbert,Tan, Park, and Kudriavtsev) teach features that are directed to analogous art and they are directed to the same field of endeavor as Cuthbert, Tan, Park, and Kudriavtsev are directed to receiving and converting code based on its corresponding requirement.
Claims 6 and 16 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 view of U.S Patent Application Publication 2018/0075107 issued to Park et al. (hereinafter as “Park”) in further view of U.S Patent Application Publication 2018/0321916 issued to Inoue et al. (hereinafter as “Inoue”).
Regarding claim 6, the modification of Cuthbert, Tan, and Park teaches claimed invention substantially as claimed, however the modification of Cuthbert, Tan, and Park does not explicitly teach the first code is incompatible with the database system and converting the first code to second code in the second programming language comprise further operations comprising: generating a user defined function (UDF) based at least in part on the first code, the UDF including a set of code statements that are in the second programming language compatible with the database system.
Inoue teaches the first code is incompatible with the database system and converting the first code to second code in the second programming language comprise further operations comprising: generating a user defined function (UDF) based at least in part on the first code (Inoue: [0034]-[0035]; The acquiring section 11 acquires a source code or bytecode program, as the user program. Next, at S103, the identifying section 12 identifies one or more code portions that access primitive values in the user-defined function included in the user program. For example, the identifying section 12 may identify one or more code portions in the user-defined function included in a method call of an object managing the internal data representation), the UDF including a set of code statements that are in the second programming language compatible with the database system (Inoue: [0041]; Next, at S107, the generating section 14 may generate the calling code of the user-defined function that was converted at S105. The generating section 14 may generate the calling code of a source code label that can be interpreted in a programming language. The generating section 14 may include a call command for obtaining a pointer to the internal data representation of the user program and a call command for calling the converted user-defined function using this pointer, in the generated calling code).
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) to further include the teachings of Inoue (teaches incompatible with the database system and converting the first code to second code in the second programming language comprise generating a user defined function (UDF)). One of ordinary skill in the art would have been motivated to make such a combination of providing better steps of observing the code statement to determine to proceed to invoke the action in such provides better improvement in generating the new code while maintaining the separation in the old code in improving the efficiency in executing the program (See Inoue: [0031]. In addition, the references (Cuthbert,Tan, Park, and Inoue) teach features that are directed to analogous art and they are directed to the same field of endeavor as Cuthbert, Tan , Park, and Inoue are directed to receiving and converting code based on its corresponding requirement.
Regarding claim 16, the modification of Cuthbert, Tan, and Park teaches claimed invention substantially as claimed, however the modification of Cuthbert, Tan, and Park does not explicitly teach the first code is incompatible with the database system and converting the first code to second code in the second programming language comprise further operations comprising: generating a user defined function (UDF) based at least in part on the first code, the UDF including a set of code statements that are in the second programming language compatible with the database system.
Inoue teaches the first code is incompatible with the database system and converting the first code to second code in the second programming language comprise further operations comprising: generating a user defined function (UDF) based at least in part on the first code (Inoue: [0034]-[0035]; The acquiring section 11 acquires a source code or bytecode program, as the user program. Next, at S103, the identifying section 12 identifies one or more code portions that access primitive values in the user-defined function included in the user program. For example, the identifying section 12 may identify one or more code portions in the user-defined function included in a method call of an object managing the internal data representation),
the UDF including a set of code statements that are in the second programming language compatible with the database system (Inoue: [0041]; Next, at S107, the generating section 14 may generate the calling code of the user-defined function that was converted at S105. The generating section 14 may generate the calling code of a source code label that can be interpreted in a programming language. The generating section 14 may include a call command for obtaining a pointer to the internal data representation of the user program and a call command for calling the converted user-defined function using this pointer, in the generated calling code).
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) to further include the teachings of Inoue (teaches incompatible with the database system and converting the first code to second code in the second programming language comprise generating a user defined function (UDF)). One of ordinary skill in the art would have been motivated to make such a combination of providing better steps of observing the code statement to determine to proceed to invoke the action in such provides better improvement in generating the new code while maintaining the separation in the old code in improving the efficiency in executing the program (See Inoue: [0031]. In addition, the references (Cuthbert, Tan, Park, and Inoue) teach features that are directed to analogous art and they are directed to the same field of endeavor as Cuthbert, Tan , Park, and Inoue are directed to receiving and converting code based on its corresponding requirement.
Claims 7 and 17 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 view of U.S Patent Application Publication 2018/0075107 issued to Park et al. (hereinafter as “Park”) in further view of U.S Patent Application Publication 2018/0101583 issued to LI et al. (hereinafter as “LI”).
Regarding claim 7, the modification of Cuthbert, Tan, and Park teaches claimed invention substantially as claimed, however the modification of Warren, Tan, and Park does not explicitly teach the database query calls the generated UDF, the first particular code statement comprises a first code statement in a Scala programming language, the second particular code statement comprises a second code statement in the Scala programming language, the third particular code statement comprises a third code statement in the Scala programming language, and the converted first code includes Java code and a set of SQL statements converted from the Scala programming language.
LI teaches the database query calls the generated UDF, the first particular code statement comprises a first code statement in a Scala programming language, the second particular code statement comprises a second code statement in the Scala programming language (LI: [0041]; Using extensible framework 55, the user may call UDF's in Spark SQL queries. [0045]; Regarding UDF's 250 in embodiments of the present invention, SQL statements 240 in extended job spec 46A of job specification 46 can invoke classes defining UDF's 250. [0049]; A UDF 250 is defined by Scala or Java code, for example, compiled into a jar file and distributed to worker modules 40 (e.g., Spark) on respective nodes 142 of cluster 140. A user simply specifies actions 220 in extended job specification 46A, and extended driver 160EXT translates this to operations 230 at runtime, and further compiles actions 220 to UDF 250 transformation 260 calls), the third particular code statement comprises a third code statement in the Scala programming language, and the converted first code includes Java code and a set of SQL statements converted from the Scala programming language (LI: [0044]-[0045]; End users can define operations 230 and actions 220 in data structure 46A included in job specification 46, i.e., without compiling new classes, where actions 220 describe how operations 230 can be used. Regarding UDF's 250 in embodiments of the present invention, SQL statements 240 in extended job spec 46A of job specification 46 can invoke classes defining UDF's 250. [0048]-[0049]; The UI 210 provides that the extended operation 230 is invoked in accordance with an action 220, i.e., in a predetermined format. According to one or more embodiments, actions 220 are defined in user-generated, extended job spec 46A first by names, followed by aspects including parameters for one or more operations 230, which the action invokes. A UDF 250 is defined by Scala or Java code, for example, compiled into a jar file and distributed to worker modules 40 (e.g., Spark) on respective nodes 142 of cluster 140. A user simply specifies actions 220 in extended job specification 46A, and extended driver 160EXT translates this to operations 230 at runtime, and further compiles actions 220 to UDF 250 transformation 260 calls).
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) to further include the teachings of LI (teaches the database query calls the generated UDF, the first particular code statement comprises a first code statement in a Scala programming language, the second particular code statement comprises a second code statement in the Scala programming language, the third particular code statement comprises a third code statement in the Scala programming language, and the converted first code includes Java code and a set of SQL statements converted from the Scala programming language). One of ordinary skill in the art would have been motivated to make such a combination of providing better steps of observing the code statement to determine to proceed to invoke the action utilizing a user defined function such provides better improvement in generating the new code while maintaining the separation in the old code in improving the efficiency in executing the program (See LI: [0044]). In addition, the references (Cuthbert,Tan, Park, and LI) teach features that are directed to analogous art and they are directed to the same field of endeavor as Cuthbert, Tan , Park, and LI are directed to receiving and converting code based on its corresponding requirement.
Regarding claim 17, the modification of Cuthbert, Tan, and Park teaches claimed invention substantially as claimed, however the modification of Cuthbert, Tan, and Park does not explicitly teach the database query calls the generated UDF, the first particular code statement comprises a first code statement in a Scala programming language, the second particular code statement comprises a second code statement in the Scala programming language, the third particular code statement comprises a third code statement in the Scala programming language, and the converted first code includes Java code and a set of SQL statements converted from the Scala programming language.
LI teaches the database query calls the generated UDF, the first particular code statement comprises a first code statement in a Scala programming language, the second particular code statement comprises a second code statement in the Scala programming language (LI: [0041]; Using extensible framework 55, the user may call UDF's in Spark SQL queries. [0045]; Regarding UDF's 250 in embodiments of the present invention, SQL statements 240 in extended job spec 46A of job specification 46 can invoke classes defining UDF's 250. [0049]; A UDF 250 is defined by Scala or Java code, for example, compiled into a jar file and distributed to worker modules 40 (e.g., Spark) on respective nodes 142 of cluster 140. A user simply specifies actions 220 in extended job specification 46A, and extended driver 160EXT translates this to operations 230 at runtime, and further compiles actions 220 to UDF 250 transformation 260 calls),
the third particular code statement comprises a third code statement in the Scala programming language, and the converted first code includes Java code and a set of SQL statements converted from the Scala programming language (LI: [0044]-[0045]; End users can define operations 230 and actions 220 in data structure 46A included in job specification 46, i.e., without compiling new classes, where actions 220 describe how operations 230 can be used. Regarding UDF's 250 in embodiments of the present invention, SQL statements 240 in extended job spec 46A of job specification 46 can invoke classes defining UDF's 250. [0048]-[0049]; The UI 210 provides that the extended operation 230 is invoked in accordance with an action 220, i.e., in a predetermined format. According to one or more embodiments, actions 220 are defined in user-generated, extended job spec 46A first by names, followed by aspects including parameters for one or more operations 230, which the action invokes. A UDF 250 is defined by Scala or Java code, for example, compiled into a jar file and distributed to worker modules 40 (e.g., Spark) on respective nodes 142 of cluster 140. A user simply specifies actions 220 in extended job specification 46A, and extended driver 160EXT translates this to operations 230 at runtime, and further compiles actions 220 to UDF 250 transformation 260 calls).
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) to further include the teachings of LI (teaches the database query calls the generated UDF, the first particular code statement comprises a first code statement in a Scala programming language, the second particular code statement comprises a second code statement in the Scala programming language, the third particular code statement comprises a third code statement in the Scala programming language, and the converted first code includes Java code and a set of SQL statements converted from the Scala programming language). One of ordinary skill in the art would have been motivated to make such a combination of providing better steps of observing the code statement to determine to proceed to invoke the action utilizing a user defined function such provides better improvement in generating the new code while maintaining the separation in the old code in improving the efficiency in executing the program (See LI: [0044]). In addition, the references (Cuthbert, Tan, Park, and LI) teach features that are directed to analogous art and they are directed to the same field of endeavor as Cuthbert, Tan , Park, and LI are directed to receiving and converting code based on its corresponding requirement.
Conclusion
The prior art made of record and not relied upon is considered pertinent to applicant's disclosure.
U.S Patent Application Publication 2013/0125098 issued to Dhoolia et al. (hereinafter as “Dhoolia”) teaches transforming a plurality of programs associated with programming languages by transforming a first programming language to a second programming language.
U.S Patent Application Publication 2008/0216060 issued to Byron D. Vargas (hereinafter as “Vargas”) teaches translates all or any portion of the source code into a target computer language.
U.S Patent Application Publication 2008/0313161 issued to Ramsey et al. (hereinafter as “Ramsey”) teaches parsing structured queries and translating into intermediate forum so it can be executed parallel.
Applicant's amendment necessitated the new ground(s) of rejection presented in this Office action. Accordingly, THIS ACTION IS MADE FINAL. See MPEP § 706.07(a). Applicant is reminded of the extension of time policy as set forth in 37 CFR 1.136(a).
A shortened statutory period for reply to this final action is set to expire THREE MONTHS from the mailing date of this action. In the event a first reply is filed within TWO MONTHS of the mailing date of this final action and the advisory action is not mailed until after the end of the THREE-MONTH shortened statutory period, then the shortened statutory period will expire on the date the advisory action is mailed, and any nonprovisional extension fee (37 CFR 1.17(a)) pursuant to 37 CFR 1.136(a) will be calculated from the mailing date of the advisory action. In no event, however, will the statutory period for reply expire later than SIX MONTHS from the mailing date of this final action.
Contact Information
Any inquiry concerning this communication or earlier communications from the examiner should be directed to ANDREW N HO whose telephone number is (571)270-0590. The examiner can normally be reached Tuesday and Thursday 10:00-6:00.
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Sherief Badawi can be reached at (571) 272-9782. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
11/4/2025
/ANDREW N HO/Examiner
Art Unit 2169
/SHERIEF BADAWI/Supervisory Patent Examiner, Art Unit 2169
Prosecution Insights