DETAILED ACTION
Receipt of Applicant’s Amendment, filed September 3, 2025 is acknowledged.
Claims 1, 4, 10, 13, and 19 were amended.
Claims 2, 3, 5-8, 11, 12, 14-17 and 20 were cancelled.
Claims 1, 4, 9, 10, 13, 18 and 19 are pending in this office 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 .
Claim Interpretation
Please note that the instant claims use the terms “reusable software module” and “user identified function (UDF)”. Within the independent claims (claims 1, 10 and 19) it is recited that “wherein the plurality of reusable software modules includes a user defined function (UDF)”. As such, within the context of the instant claims it should be noted that these claim labels have been identified as referring to the same claim element. This interpretation is in line with applicant’s remarks (Remarks filed September 3, 2025, Page 14 Section discussing the 112 rejections).
Claims 1, 10 and 19 recite “receiving, by the at least one processor, a job request that corresponds to a feature desired by a user, the feature corresponding to a data analytics task for which software development is to be conducted in order to generate a software program configured to fulfill the job request.” This claim limitation appears to recite an intended use (MPEP 2114) for the job request. What job request is to be used for (e.g. use for which software development is to be conducted) does not recite a structural or functional limitation of the claimed device. What the software is to be ‘conducted in order to generate’ does not impose a structural or functional limitation on the claimed device. The instant claim limitation recites an intention of use of the job request and the feature which does not recite any operations to actually be performed. The instant claim limitation does not require the execution of any operation which performs software development, or the generation of any software program, nor the fulfilment of the job request. The only functionality being recited by the instant claim limitation is the receipt of the job request that corresponds to the feature desired by the user, the feature corresponding to a data analytics task.
Claims 1, 10 and 19 recite “extracting, by the at least one processor, a set of configuration instructions from the job request, wherein the set of configuration instructions correspond to a set of operations to be performed within the software program … “the software program to be constructed for performing the set of operations included in the DAG … retrieving, by the at least one processor and from the library, the plurality of reusable software modules determined to be included in the software program to be constructed; … receiving a set of input data to be provided to the constructed software program” This claim limitation has been identified as an intended use (MPEP 2114) of the software program. The instant claim limitations recite an intended future operation to be performed but does not actually require the execution/performance of the recited operation.
It is suggested that the claims be amended to recite the functionality actually performed by the claimed device instead of reciting the intention to perform functionality.
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, 4, 9, 10, 13, 18 and 19 are rejected under 35 U.S.C. 103 as being unpatentable over George [2012/0191690] in view of O’Krafka [11327966] and Singh [WO2016/012903].
With regard to claim 1, George teaches A method for providing a data analytics platform (George, ¶7 “a method for performing a data analytics task is provided.”) that facilitates efficient feature delivery based on reusability (George, ¶9 “This ability of the function to provide multiple, different instantiations of a general application program model, referred to herein as function polymorphism, allows for a reduction in the overall number of function implementations necessary to implement the desired functionalities in a single user defined function.”) of software modules as the UDF which represent the application program models (George, ¶11 “system 10 in which user defined functions (UDFs) use parameter expressions to represent general application program models”), the method being implemented by at least one processor (George, ¶10 “The system 10 includes a processor 12 and a memory 14 connected to a communications interface 16.”), the method comprising:
Receiving as receiving database queries (George, ¶15 “It will be appreciated that the communication interface 56 can comprise any appropriate hardware and machine readable instructions for receiving database queries”), by the at least one processor (George, ¶10), a job request as the database query (George, ¶15 “It will be appreciated that the communication interface 56 can comprise any appropriate hardware and machine readable instructions for receiving database queries from an associated query source (not shown) and returning the results of the queries to the query source”) that corresponds to a feature desired by a user as the desired search result corresponding to the search request input from the query source, e.g. a user (Id), the feature corresponding to a data analytics task (George, ¶7 “a method for performing a data analytics task is provided.”) for which software development is to be conducted in order to generate a software program as establishing a plan for executing the query (George, ¶23 “A query optimizer 80 establishes a plan for executing the received query, including any user defined functions in the query.”) configured to fulfill the job request as executing the UDF in the query (Id; ¶58);
Extracting, by the at least one processor (George, ¶10), a set of configuration instructions (George, ¶11 “The query compiler 22 identifies a call to the user defined function 28 with a list of input, output and parameter expressions associated with the function call.”) from the job request as the query (George, ¶11), wherein the set of configuration instructions correspond to a set of operations as the parameter expressions, for example the operator ‘=’, insert, delete, or update operations (George, ¶16 “The query complier 62 includes a query parser 72 that identifies a call to a user defined function and any input, output, and parameters expressions that may be available in the call to the user defined function.”; ¶26 “Each parameter expression consists of a key and a value pair connected by an equal sign, '=', where key is the name of the parameter field metadata and the value is a constant or an expression that evaluates to a constant value at the time of invoking the user defined function”; ¶59 “For example, row sending UDFs can be configured with parameters for sending rows to live applications from databases as database triggering UDF execution at row insert or delete or update operation.”) to be performed within the software program as the plan for executing the query (George, ¶23 “A query optimizer 80 establishes a plan for executing the received query, including any user defined functions in the query.”);
Transforming as parsing (George, ¶16 “The query complier 62 includes a query parser 72 that identifies a call to a user defined function and any input, output, and parameters expressions that may be available in the call to the user defined function.”), by the at least one processor (George, ¶10), the job request as parsing the query (George, ¶16 “The query complier 62 includes a query parser 72 that identifies a call to a user defined function and any input, output, and parameters expressions that may be available in the call to the user defined function.”) into [[ as the parameter expressions, for example the operator ‘=’, insert, delete, or update operations (George, ¶16; ¶26; ¶59), wherein the transforming includes a transformation of the job request with a plurality of environment variables as input and output expressions (George, ¶16 “The query complier 62 includes a query parser 72 that identifies a call to a user defined function and any input, output, and parameters expressions that may be available in the call to the user defined function”), wherein the set of operations as parameter expressions (Id) corresponds to the set of configuration instructions (George, ¶11 “The query compiler 22 identifies a call to the user defined function 28 with a list of input, output and parameter expressions associated with the function call.”), [[
[[ as the parsed query information (George, ¶16), as an input, into a core engine (George, ¶11 “The database engine 24 starts the execution process to the user defined function by composing input and output table and parameter objects from the arguments in the user defined function call in the query and proceeds to execute the function using input rows set in the input table object. When result rows are produced from the user defined function in the output table object, they are retrieved by the database engine 24.”) wherein each operation included in the set of operations as the processing instructions, for example the operator ‘=’, insert, delete, or update operations (George, ¶12 “The metadata can further include a defined class type, parameter fields for customizing the function to a particular application and other processing instructions for the user defined function 28.”; George, ¶16; ¶26; ¶59) [[
determining, [[(George, ¶9 “This ability of the function to provide multiple, different instantiations of a general application program model, referred to herein as function polymorphism, allows for a reduction in the overall number of function implementations necessary to implement the desired functionalities in a single user defined function.”) software modules as the UDF which represent the application program models (George, ¶11 “system 10 in which user defined functions (UDFs) use parameter expressions to represent general application program models”; Please see the 112b rejection above for claim interpretation explanation; interpreted in light of Paragraph [0010] and [0072] of the original specification) to be included in a software program as establishing a plan for executing the query (George, ¶23 “A query optimizer 80 establishes a plan for executing the received query, including any user defined functions in the query.”) to be constructed for performing the set of operations as executing the UDF in the query (Id; ¶58) included in the [[ as the UDFs (Id) is stored in a library as the Dynamic Link Library, e.g. DLL (George, ¶17 “the user defined functions are built in a UDF library 74, for example, as shared objects or dynamic link libraries, and registered with the database engine.”; Please see the 112b rejection above regarding claim interpretation), wherein the library includes operation handler modules as the API (George, ¶12 “In one instance, the exposed metadata can further include an application programming interface (API) comprising rules for validating and resolving arguments within the call to the user defined function”; ¶24 “During runtime, data are loaded into the input table object according to the requirements of the user defined function class type. With the input and output table objects as arguments, the data processing API of the user defined function is called to process data.”) that define operation type attributes (George, ¶12 “The meta data can further include a defined class type, parameter fields for customizing the function to a particular application and other processing instructions for the user defined function 28.”; ¶17 “The UDF metadata object can include the UDF name, UDF description, class type, and an indicator to denote if the UDF requires all the input records together while processing.”) that correspond to various types of operations as the parameter expressions, which include the operator ‘=’ (George, ¶16, ¶26, ¶59) included in the software program as the plan for executing the query (George, ¶23), wherein the plurality of reusable software modules as the UDF which represent the application program models (George, ¶11 “system 10 in which user defined functions (UDFs) use parameter expressions to represent general application program models”) includes a user defined function (UDF) as the UDF (George, ¶12 “In the illustrated implementation, the metadata fields of input, output and parameters of the user defined function can include a field name, a description of the field and an associated data type for each field.”), wherein the UDF includes a name attribute as a field name (Id) that corresponds to an identification of the UDF as the name of the UDF (Id), a class attribute as class type (George, ¶12 “The meta data can further include a defined class type, parameter fields for customizing the function to a particular application and other processing instructions for the user defined function 28”) that corresponds to a function type of the UDF as customizing the function of the application for the UDF 28 (Id), and an initialization attribute that corresponds to initializing an instance as default values for the UDF (George, ¶13 “Depending on the user defined function, parameter metadata fields can be set as optional or mandatory, and optional parameter metadata fields can, but do not need to, provide default parameter values”) of the UDF as the UDF (George ¶11), and wherein the determining of the plurality of reusable software modules as the UDF which represents the application program model (George, ¶11) to be included in the software program as the plan for executing the query (George, ¶23 to be constructed includes matching (George, ¶34 “However, the query application is at liberty to use either the generated field name or the ordinal number of the output field using the $# syntax fur selecting and mapping the output fields to match the output requirements of the query application”; ¶44 “When UDF input variable metadata fields are defined as a double data type or a similar concrete data type, the UDF processing infrastructure converts the input field arguments to match the UDF data type at the time of processing.”; ¶16 “To this end, the query parser 72 processes a call to a user defined function in a database query using a standardized user defined function syntax to distinctly map the input, output, and parameter expressions to appropriate objects.”; ¶21) at least one operation from the set of operations as the input (¶21) e.g. the parameter expressions, which include the operator ‘=’ (George, ¶16, ¶26, ¶59) is mapped to the output (¶21) included [[ as the parsed query information (George, ¶16) with at least one reusable software module as the output to which the input is mapped (¶21) stored in the library as the Dynamic Link Library, e.g. DLL (George, ¶17 “the user defined functions are built in a UDF library 74, for example, as shared objects or dynamic link libraries, and registered with the database engine.”);
retrieving (George, ¶11 “the user defined function 28 is stored as one of a shared object or a dynamic link library and loaded into an analytical data processing system such as a database. The query compiler 22 identifies a call to the user defined function 28 with a list of input, output and parameter expressions associated with the function call. The query compiler 22 retrieves the input, output and parameter metadata from the user defined function 28 and validates and resolves the lists of input, output and parameter expressions in the call to the user defined function in the query.”), by the at least one processor as the processor running the query compiler (Id) and from the library as the dynamic link library (Id), the plurality of reusable software modules as the UDF (Id) determined to be included in the software program as establishing a plan for executing the query (George, ¶23 “A query optimizer 80 establishes a plan for executing the received query, including any user defined functions in the query.”) to be constructed as developed (George, ¶23 “Each of the data objects extracted by the query parser 72 and the query plan developed at the query optimizer 80 are provided to the database engine 64 to execute the query, including the user defined function.”);
[[ as the search results (George, ¶15 “It will be appreciated that the communication interface 56 can comprise any appropriate hardware and machine readable instructions for receiving database queries from an associated query source (not shown) and returning the results of the queries to the query source”) associated with the set of configuration instructions (George, ¶11 “The query compiler 22 identifies a call to the user defined function 28 with a list of input, output and parameter expressions associated with the function call.”);
constructing as developed (George, ¶23 “Each of the data objects extracted by the query parser 72 and the query plan developed at the query optimizer 80 are provided to the database engine 64 to execute the query, including the user defined function.”), by the at least one processor (George, ¶10), the software program as establishing a plan for executing the query (George, ¶23 “A query optimizer 80 establishes a plan for executing the received query, including any user defined functions in the query.”) that is configured to execute the set of operations as executing the UDF in the query (Id; ¶58) included in the [[ as the UDFs from the query identified during the parsing (George, ¶23 “Each of the data objects extracted by the query parser 72 and the query plan developed at the query optimizer 80 are provided to the database engine 64 to execute the query, including the user defined function”), wherein the software program as establishing a plan for executing the query (George, ¶23 “A query optimizer 80 establishes a plan for executing the received query, including any user defined functions in the query.”) is constructed as developed (George, ¶23 “Each of the data objects extracted by the query parser 72 and the query plan developed at the query optimizer 80 are provided to the database engine 64 to execute the query, including the user defined function.”) to include the plurality of reusable software modules as the UDF (Id) retrieved from the library as the Dynamic Link Library, e.g. DLL (George, ¶17), and wherein the constructing as the developing of the QEP (George, ¶23) includes assembling as arranging the processes in an optimal manner (George, ¶23 “For class types having known outputs, the query optimizer 80 can proceed normally. Functions having indeterminate outputs are handled as part of an alternative optimization process, in which the potential impact of a function having a large number of output rows is mitigated. Each of the data objects extracted by the query parser 72 and the query plan developed at the query optimizer 80 are provided to the database engine 64 to execute the query, including the user defined function.”) the plurality of reusable software modules as the UDF (Id) together as using the UDF to execute the query (George, ¶23 “”) to form the software program as the executable QEP (George, ¶24 “The database engine 64 uses the extracted query plan objects including the user defined function objects to execute the query plan to provide a query result, and returns the query result to the query source via the communications interface 56.”);
receiving a set of input data (George, ¶19 “Function input fields are extracted from query fields, and composed as an input table object”) to be provided to the constructed software program as the developed executable QEP (George, ¶23, ¶24);
generating, by executing the constructed software program with the set of input data (George, ¶24 “During runtime, data are loaded into the input table object according to the requirements of the user defined function class type.”), a set of output data (George, ¶29 “When output fields are represented by'*' as in OUTPUT(*), all the output fields from the user defined function are returned.”); and
generating a set of software construction data as the resolution and validation utility (George¶43 “When UDF output fields are mapped with the ordinal number of output fields, the resolution and validation utility function determines the repetition count and resolves the ordinal numbers into appropriate output field names.”), based on the transforming of the job request as the use of the UDF output fields and ordinal numbers (Id), the constructing of the software program, and the executing of the software program as at the query compiler (George, ¶44 “A general purpose function supplied with the system can be used to validate input and output fields and resolve their data types and lengths at the query compiler 62 when an explicit validation and resolution function is not supplied by the user defined function as a function pointer in the metadata.”),
wherein the set of software construction data provides an indication whether the feature desired by the user as the results the user was searching for (George, ¶15 “It will be appreciated that the communication interface 56 can comprise any appropriate hardware and machine readable instructions for receiving database queries from an associated query source (not shown) and returning the results of the queries to the query source”) has been captured by the software program as resolving the data types (George, ¶44), and whether the set of configuration instructions (George, ¶11 “The query compiler 22 identifies a call to the user defined function 28 with a list of input, output and parameter expressions associated with the function call.”) correctly correspond to the reusable software modules as the UDF output (George, ¶43 “When UDF output fields are mapped with the ordinal number of output fields, the resolution and validation utility function determines the repetition count and resolves the ordinal numbers into appropriate output field names.”) used for constructing the software program as establishing a plan for executing the query (George, ¶23 “A query optimizer 80 establishes a plan for executing the received query, including any user defined functions in the query.”), and
wherein the set of software construction data as the resolution and validation utility (George¶43 “When UDF output fields are mapped with the ordinal number of output fields, the resolution and validation utility function determines the repetition count and resolves the ordinal numbers into appropriate output field names.”) [[
[[
George does not explicitly teach transforming … the job request into a directed acyclic graph (DAG) …wherein the DAG includes a plurality of vertices connected by a plurality of directional edges, and wherein each of the plurality of directional edges is directed from one vertex to another vertex without forming a closed loop; …Loading the DAG, as input, into a core engine wherein each operation in the set of operations corresponds to a vertex in the DAG, …determining, by applying an artificial intelligence (AI) algorithm that used a machine learning technique,… for performing the set of operations included in the DAG… the set of operations included in the DAG; …building a pipeline DAG that corresponds to the feature associated with the set of configuration instructions; … execute the set of operations included in the DAG… the AI algorithm… .
O’Krafka teaches transforming as transform (O’Krafka, Column 5 lines 6-13 “During job execution, an application may submit a query to the Apache Spark architecture through SQL, a Dataframe Application Programming Interface (API), a Dataset API, or streaming Spark libraries. The Apache Spark architecture transforms the submitted query into a logical plan. Thereafter, the Apache Spark architecture transforms the logical plan into a physical plan, which is represented as a Directed Acyclic Graph (DAG).”) … the job request as the job request, e.g. the query (Id) into a directed acyclic graph (DAG) as the directed Acyclic Graph (DAG) (Id) …wherein the DAG includes a plurality of vertices as query nodes (O’Krafka Column 5, line 66-Column 6 line 1 “Physical plans are represented as a DAG, which is composed of nodes. To avoid confusion, the nodes of a query graph shall be referred to herein as a query node”) connected by a plurality of directional edges as children and parent relationships (O’Krafka, Column 6, lines 12-16 “Each runtime instance responsible for performing the work associated with a query node possesses its own thread, which may dequeue row groups from its child(ren), processes them, and passes new row groups onto its parent.”), and wherein each of the plurality of directional edges as parent-child relationship between nodes (Id) is directed from one vertex as one query node, e.g. the parent node (Id) to another vertex as the specified child node (Id) without forming a closed loop as acyclic (O’Krafka, Column 5, lines 66-Column 6, line 1”);
Loading the DAG (O’Krafka, column 9, lines 25-28 “thereby turning the DAG of the query execution graph layout into a directed cycle graph, as can be seen in FIG. 8,”), as input, into a core engine (O’Krafka, column 9, lines 17-19 “As shown, to perform a checkpoint restore operation, upon startup of the SNE software all query nodes load their initial state from a previously checkpointed state.”) wherein each operation of the set of operations corresponds to a vertex in the DAG (O’Krafka, Column 15, lines 19-21 “wherein each vertex of the query graph is associated with a set of data responsive to at least a portion of the query”; Column 6, lines 10-16),
determining, by applying an artificial intelligence (AI) algorithm as AI (O’Krafka, Column 12, lines 62-66 “SNE may be implemented as a "Execution Fabric" in additional data analysis applications (including Presto, Aurora, Flink, BigQuery) and in artificial intelligence (AI) and machine learning frameworks ( e.g. PySpark, Dask, Ray, TensorFlow)”) that used a machine learning technique as Machine learning frameworks (Id), a plurality of reusable software modules as referencing SNE operators (O’Krafka, Column 5, lines 17-25 “the SNE transparent integration code serializes the spark plan (DAG) and calls SNE to process the DAG, e.g., via a Scala native command call. SNE parses the physical query plan (DAG), compiles the DAG to the C programming language referencing SNE operators, compiles the C code to native code, and then SNE executes the MPP engine with parallel precise cloud store prefetching, spilling, and checkpointing to complete the query.”) to be included in a software program as the native code compiled from the C code (Id) to be constructed as created and compiled code (Id) for performing the set of operations (O’Krafka, Column 6, lines 5-16 “For ease of explanation, a query node discussed in terms of performing some action or work may be implemented by a compute node performing the action or work associated with that query node. Each query node in an SNE query graph is associated with work which may be performed by a separate runtime instance of SNE. Each runtime instance responsible for performing the work associated with a query node possesses its own thread, which may dequeue row groups from its child(ren), processes them, and passes new row groups onto its parent.”) included in the DAG as the DAG (O’Krafka, Column 5, lines 5-25) … the set of operations included in the DAG (Id)
building a pipeline DAG that corresponds to the feature associated with the set of configuration instructions (O’Krafka, Column 6, lines 10-20 “Each query node in an SNE query graph is associated with work which may be performed by a separate runtime instance of SNE. Each runtime instance responsible for performing the work associated with a query node possesses its own thread, which may dequeue row groups from its child(ren), processes them, and passes new row groups onto its parent. Query node processing is thus pipelined, and the memory consumed is determined by the total number of row groups in flight. Operators exchange, merge, and join with concurrent counterparts in other vCPUs and cloud servers using MPI to complete queries as shown in FIG. 2.” Emphasis added);
… execute the set of operations included in the DAG (O’Krafka, Column 15, lines 31-33 “processing data sets associated with each vertex of the query graph using separate threads of execution for each vertex of the query graph”)
… Al algorithm as AI (O’Krafka, Column 12, lines 62-66 “SNE may be implemented as a "Execution Fabric" in additional data analysis applications (including Presto, Aurora, Flink, BigQuery) and in artificial intelligence (AI) and machine learning frameworks ( e.g. PySpark, Dask, Ray, TensorFlow)”).
It would have been obvious to one of ordinary skill in the art to which said subject matter pertains at the time in which the invention was filed to have implemented the execution plan presented by George using the physical plan techniques taught by O’Krafka (O’Krafka, Column 5, lines 6-13) as it yields the predictable results of providing a means of generating the execution plan within the Apache Spark Architecture. The proposed combination would enable the system to function on an underlying Spark Native Execution (O’Krafka, Column 4, line 66 to Column 5 line 5), which is a known architecture for executing queries within the field of art, while enabling polymorphism (George, ¶9) thereby reducing the analytical application processing time (George, ¶9). Please note that the underlying environment taught by O’Krafka is implemented using a ML framework (O’Krafka, Column 3, lines 10; Column 12, lines 56-67). One of ordinary skill in the art would recognize the QEP generated by George as a recitation of a ‘logical plan’ within O’Krafka, and would recognize how to use the device taught by O’Krafka to implement the execution of the QEP generated by George which incorporates the UDF.
George does not explicitly teach wherein the set of software construction data is appended to historical ground truth data to form an enhanced set of training data … retraining the Al algorithm using the enhanced set of training data
Singh teaches wherein the set of software construction data as processing time and execution details of the query (Singh, Page 11, lines 25-29 “In the event that any query failed to execute within the predicted processing time then execution details of the query along with the predicted processing time and class of service are appended to a training table (not shown in the figures) in the self-learning module (114) as new training data.”) is appended as appended (Id) to historical ground truth data as the training table (Id) to form an enhanced set of training data as new training data (Id);
retraining as the self-learning module (Id) used to retrain (Singh, Page 11, lines 30-35 “Referring to FIGURE 4 which discloses the steps followed by the COU (106) in initiating self-learning rules to re-train and correct conflicting data by selecting various models of machine learning for the purpose of improving accuracy of selecting the best route when queries are generated.”) the Al algorithm as the ML (Singh, Page 9, lines 21-22 “the query editor (104) and facilitates in selection of a best route for a query by selecting at least one machine learning module”) using the enhanced set of training data as the new training data (Singh, Page 11, lines 25-29 “In the event that any query failed to execute within the predicted processing time then execution details of the query along with the predicted processing time and class of service are appended to a training table (not shown in the figures) in the self-learning module (114) as new training data.”).
It would have been obvious to one of ordinary skill in the art to which said subject matter pertains at the time in which the invention was filed to have implemented the AI module taught by the proposed combination using the self-learning techniques taught by Singh as it yields the predictable results of improving accuracy of selection (Singh, Page 11, lines 31-32 “the purpose of improving accuracy of selecting the best route when queries are generated”). Within the proposed combination as a whole, the AI and ML models within the SNE framework used by O’Krafka may be trained using the techniques taught by Singh to perform the selection and retrieval of the UDFs.
With regard to claims 4 and 13, the proposed combination further teaches wherein the library (George, ¶17 “the user defined functions are built in a UDF library 74, for example, as shared objects or dynamic link libraries, and registered with the database engine.”) stores the plurality of reusable software modules as UDF (Id) that respectively correspond to algorithm functions as API functions (George, ¶12 “The meta data can further include a defined class type, parameter fields for customizing the function to a particular application and other processing instructions for the user defined function 28. In one instance, the exposed metadata can further include an application programming interface (API) comprising rules for validating and resolving arguments within the call to the user defined function. It will be appreciated, however, that for the majority of user defined functions, a generalized API function pointer in the metadata will validate and resolve arguments unless the user defined function requires a specific function for special handling for resolving input, output and parameter arguments”), and wherein the at least one reusable (George, ¶17 “As described previously, each user defined function exposes a self-describing UDF metadata 76 that can be retrieved by the query complier 62 for query resolution and validation.”) software module as the UDF (Id) included in the constructed software program as the execution of the QEP (George, ¶15) e.g. the native code compiled from the C code (O’Krafka, Column 5, lines 17-25) is configured to execute the at least one operation from among the set of operations (George, ¶58 “Parameters can also be used to supply runtime program scripts to a UDF or a file name containing program script, allowing the UDF to compile the program script and generate execution code to process the input rows.”; O’Krafka, Column 6, lines 5-16 “For ease of explanation, a query node discussed in terms of performing some action or work may be implemented by a compute node performing the action or work associated with that query node. Each query node in an SNE query graph is associated with work which may be performed by a separate runtime instance of SNE. Each runtime instance responsible for performing the work associated with a query node possesses its own thread, which may dequeue row groups from its child(ren), processes them, and passes new row groups onto its parent.”) included in the DAG as the DAG (O’Krafka, Column 5, lines 5-25).
With regard to claims 9 and 18 the proposed combination further teaches wherein each operation included in the set of operations is compatible with a Spark (O’Krafka, Column 2, lines 24-26 “invoking Spark Native Execution (SNE) during operation of the Apache Spark architecture”; Column 5, lines 6-7 “During job execution, an application may submit a query to the Apache Spark architecture through SQL,”) Structured Query Language (SQL) module for structured data processing (George, ¶3 “A standardized query language, such as Structured Query Language (SQL), can be used for creating and operating relational databases”; ¶27).
With regard to claim 10 George teaches A computing apparatus for providing a data analytics platform that facilitates efficient feature delivery based on reusability (George, ¶9 “This ability of the function to provide multiple, different instantiations of a general application program model, referred to herein as function polymorphism, allows for a reduction in the overall number of function implementations necessary to implement the desired functionalities in a single user defined function.”) of software modules as the UDF which represent the application program models (George, ¶11 “system 10 in which user defined functions (UDFs) use parameter expressions to represent general application program models”), the computing apparatus comprising:
a processor as a processor (George, ¶10 “The system 10 includes a processor 12 and a memory 14 connected to a communications interface 16.”);
a memory as the memory (Id); and
a communication interface as the communications interface (Id) coupled to each of the processor and the memory, wherein the processor is configured to:
Receive as receiving database queries (George, ¶15 “It will be appreciated that the communication interface 56 can comprise any appropriate hardware and machine readable instructions for receiving database queries”), via the communication interface (George, ¶10), a job request as the database query (George, ¶15 “It will be appreciated that the communication interface 56 can comprise any appropriate hardware and machine readable instructions for receiving database queries from an associated query source (not shown) and returning the results of the queries to the query source”) that corresponds to a feature desired by a user as the desired search result corresponding to the search request input from the query source, e.g. a user (Id) the feature corresponding to a data analytics task (George, ¶7 “a method for performing a data analytics task is provided.”) for which software development is to be conducted in order to generate a software program as establishing a plan for executing the query (George, ¶23 “A query optimizer 80 establishes a plan for executing the received query, including any user defined functions in the query.”) configured to fulfill the job request as executing the UDF in the query (Id; ¶58);
Extract a set of configuration instructions (George, ¶11 “The query compiler 22 identifies a call to the user defined function 28 with a list of input, output and parameter expressions associated with the function call.”) from the job request as the query (George, ¶11), wherein the set of configuration instructions correspond to a set of operations as the parameter expressions, for example the operator ‘=’, insert, delete, or update operations (George, ¶16 “The query complier 62 includes a query parser 72 that identifies a call to a user defined function and any input, output, and parameters expressions that may be available in the call to the user defined function.”; ¶26 “Each parameter expression consists of a key and a value pair connected by an equal sign, '=', where key is the name of the parameter field metadata and the value is a constant or an expression that evaluates to a constant value at the time of invoking the user defined function”; ¶59 “For example, row sending UDFs can be configured with parameters for sending rows to live applications from databases as database triggering UDF execution at row insert or delete or update operation.”) to be performed within the software program as the plan for executing the query (George, ¶23 “A query optimizer 80 establishes a plan for executing the received query, including any user defined functions in the query.”);
Transform as parsing (George, ¶16 “The query complier 62 includes a query parser 72 that identifies a call to a user defined function and any input, output, and parameters expressions that may be available in the call to the user defined function.”) the job request as parsing the query (George, ¶16 “The query complier 62 includes a query parser 72 that identifies a call to a user defined function and any input, output, and parameters expressions that may be available in the call to the user defined function.”) into [[ as the parameter expressions, for example the operator ‘=’, insert, delete, or update operations (George, ¶16; ¶26; ¶59), wherein the transforming includes a transformation of the job request with a plurality of environment variables as input and output expressions (George, ¶16 “The query complier 62 includes a query parser 72 that identifies a call to a user defined function and any input, output, and parameters expressions that may be available in the call to the user defined function”), wherein the set of operations as parameter expressions (Id) corresponds to the set of configuration instructions (George, ¶11 “The query compiler 22 identifies a call to the user defined function 28 with a list of input, output and parameter expressions associated with the function call.”), [[
[[ as the parsed query information (George, ¶16), as an input, into a core engine (George, ¶11 “The database engine 24 starts the execution process to the user defined function by composing input and output table and parameter objects from the arguments in the user defined function call in the query and proceeds to execute the function using input rows set in the input table object. When result rows are produced from the user defined function in the output table object, they are retrieved by the database engine 24.”) wherein each operation included in the set of operations as the processing instructions, for example the operator ‘=’, insert, delete, or update operations (George, ¶12 “The metadata can further include a defined class type, parameter fields for customizing the function to a particular application and other processing instructions for the user defined function 28.”; George, ¶16; ¶26; ¶59) [[
determining, [[(George, ¶9 “This ability of the function to provide multiple, different instantiations of a general application program model, referred to herein as function polymorphism, allows for a reduction in the overall number of function implementations necessary to implement the desired functionalities in a single user defined function.”) software modules as the UDF which represent the application program models (George, ¶11 “system 10 in which user defined functions (UDFs) use parameter expressions to represent general application program models”; Please see the 112b rejection above for claim interpretation explanation; interpreted in light of Paragraph [0010] and [0072] of the original specification) to be included in the software program as establishing a plan for executing the query (George, ¶23 “A query optimizer 80 establishes a plan for executing the received query, including any user defined functions in the query.”) to be constructed for performing the set of operations as executing the UDF in the query (Id; ¶58) included in the [[ as the UDFs (Id) is stored in a library as the Dynamic Link Library, e.g. DLL (George, ¶17 “the user defined functions are built in a UDF library 74, for example, as shared objects or dynamic link libraries, and registered with the database engine.”; Please see the 112b rejection above regarding claim interpretation) , wherein the library includes operation handler modules as the API (George, ¶12 “In one instance, the exposed metadata can further include an application programming interface (API) comprising rules for validating and resolving arguments within the call to the user defined function”; ¶24 “During runtime, data are loaded into the input table object according to the requirements of the user defined function class type. With the input and output table objects as arguments, the data processing API of the user defined function is called to process data.”) that define operation type attributes (George, ¶12 “The meta data can further include a defined class type, parameter fields for customizing the function to a particular application and other processing instructions for the user defined function 28.”; ¶17 “The UDF metadata object can include the UDF name, UDF description, class type, and an indicator to denote if the UDF requires all the input records together while processing.”) that correspond to various types of operations as the parameter expressions, which include the operator ‘=’ (George, ¶16, ¶26, ¶59) included in the software program as the plan for executing the query (George, ¶23), wherein the plurality of reusable software modules as the UDF which represent the application program models (George, ¶11 “system 10 in which user defined functions (UDFs) use parameter expressions to represent general application program models”) includes a user defined function (UDF) as the UDF (George, ¶12 “In the illustrated implementation, the metadata fields of input, output and parameters of the user defined function can include a field name, a description of the field and an associated data type for each field.”), wherein the UDF includes a name attribute as a field name (Id) that corresponds to an identification of the UDF as the name of the UDF (Id), a class attribute as class type (George, ¶12 “The meta data can further include a defined class type, parameter fields for customizing the function to a particular application and other processing instructions for the user defined function 28”) that corresponds to a function type of the UDF as customizing the function of the application for the UDF 28 (Id), and an initialization attribute that corresponds to initializing an instance as default values for the UDF (George, ¶13 “Depending on the user defined function, parameter metadata fields can be set as optional or mandatory, and optional parameter metadata fields can, but do not need to, provide default parameter values”) of the UDF as the UDF (George ¶11), and wherein the determining of the plurality of reusable software modules as the UDF which represents the application program model (George, ¶11) to be included in the software program as the plan for executing the query (George, ¶23 to be constructed includes matching (George, ¶34 “However, the query application is at liberty to use either the generated field name or the ordinal number of the output field using the $# syntax fur selecting and mapping the output fields to match the output requirements of the query application”; ¶44 “When UDF input variable metadata fields are defined as a double data type or a similar concrete data type, the UDF processing infrastructure converts the input field arguments to match the UDF data type at the time of processing.”; ¶16 “To this end, the query parser 72 processes a call to a user defined function in a database query using a standardized user defined function syntax to distinctly map the input, output, and parameter expressions to appropriate objects.”; ¶21) at least one operation from the set of operations as the input (¶21) e.g. the parameter expressions, which include the operator ‘=’ (George, ¶16, ¶26, ¶59) is mapped to the output (¶21) included [[ as the parsed query information (George, ¶16) with at least one reusable software module as the output to which the input is mapped (¶21) stored in the library as the Dynamic Link Library, e.g. DLL (George, ¶17 “the user defined functions are built in a UDF library 74, for example, as shared objects or dynamic link libraries, and registered with the database engine.”);
retrieve (George, ¶11 “the user defined function 28 is stored as one of a shared object or a dynamic link library and loaded into an analytical data processing system such as a database. The query compiler 22 identifies a call to the user defined function 28 with a list of input, output and parameter expressions associated with the function call. The query compiler 22 retrieves the input, output and parameter metadata from the user defined function 28 and validates and resolves the lists of input, output and parameter expressions in the call to the user defined function in the query.”), from the library as the dynamic link library (Id), the plurality of reusable software modules as the UDF (Id) determined to be included in the software program as establishing a plan for executing the query (George, ¶23 “A query optimizer 80 establishes a plan for executing the received query, including any user defined functions in the query.”) to be constructed as developed (George, ¶23 “Each of the data objects extracted by the query parser 72 and the query plan developed at the query optimizer 80 are provided to the database engine 64 to execute the query, including the user defined function.”);
[[ as the search results (George, ¶15 “It will be appreciated that the communication interface 56 can comprise any appropriate hardware and machine readable instructions for receiving database queries from an associated query source (not shown) and returning the results of the queries to the query source”) associated with the set of configuration instructions (George, ¶11 “The query compiler 22 identifies a call to the user defined function 28 with a list of input, output and parameter expressions associated with the function call.”);
construct as developed (George, ¶23 “Each of the data objects extracted by the query parser 72 and the query plan developed at the query optimizer 80 are provided to the database engine 64 to execute the query, including the user defined function.”), by the at least one processor (George, ¶10), the software program as establishing a plan for executing the query (George, ¶23 “A query optimizer 80 establishes a plan for executing the received query,