A computing system may obtain code for a query to a database from a first user. In response, the application may automatically perform an operation to determine a number of records of the database that would be accessed by executing the query on the database. The computing system may output, for display to the first user, the number of records of the database that would be accessed by executing the query on the database. The computing system may output, for display to the first user, a prompt for an acknowledgement of the number of records of the database that would be accessed. In response to receiving an indication of the acknowledgement by the first user of the number of records of the database that would be accessed, the computing system may output, for display to a second user, the code for the query for review by the second user.
Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A method comprising: obtaining, by processing circuitry of a computing device and from a first user, code for a query to a database, wherein the code for the query expresses an operation to be performed on the database in response to execution of the query; in response to receiving the code for the query, automatically performing, by the processing circuitry, an operation to determine a number of records of the database that would be accessed by executing the query on the database; outputting, by the processing circuitry and for display to the first user, the number of records of the database that would be accessed by executing the query on the database; outputting, by the processing circuitry and for display to the first user, a prompt for an acknowledgement by the first user of the number of records of the database that would be accessed; receiving, by the processing circuitry and from the first user, an indication of the acknowledgement by the first user of the number of records of the database that would be accessed; in response to receiving the code for the query and the indication of the acknowledgement by the first user of the number of records of the database that would be accessed, outputting, by the processing circuitry and for display to a second user, the code for the query for review by the second user; after outputting the code for the query for review by the second user, obtaining, by the processing circuitry and from the second user, an indication that the second user approves the code for the query; and based on the indication that the second user approves the code for the query, executing, by the processing circuitry, the query on the database.
This invention relates to database query management systems that improve efficiency and reduce errors in database operations. The problem addressed is the risk of executing inefficient or unintended queries that may access excessive records, leading to performance degradation or unintended data exposure. The solution involves a multi-step approval process for database queries that includes pre-execution analysis and user acknowledgment. The system obtains a database query from a first user, which specifies an operation to be performed on the database. Before execution, the system automatically determines the number of records that would be accessed if the query were run. This count is displayed to the first user, who must acknowledge it before the query proceeds. The query is then sent to a second user for review and approval. Only after the second user approves the query is it executed on the database. This ensures that queries are reviewed for efficiency and correctness before execution, reducing the risk of performance issues or unintended data access. The system enforces a structured workflow where both the query originator and a reviewer must confirm the query's impact before execution.
2. The method of claim 1 , wherein the method further comprises: prior to outputting, for display to the second user, the code for the query for review by the second user: automatically validating, by the processing circuitry, a syntax of the code for the query; and outputting, by the processing circuitry and for display to the first user, an indication of whether the syntax of the code for the query is valid.
A system and method for validating query code syntax in a collaborative environment involves generating a query code snippet based on user input, such as natural language or structured parameters, and automatically checking the syntax of the generated code before sharing it with another user. The system processes the input to produce executable code, such as SQL or another query language, and performs a validation step to ensure the syntax is correct. If errors are detected, the system notifies the first user, allowing corrections before the code is shared with a second user for review. This ensures that only syntactically valid code is presented to collaborators, reducing errors and improving efficiency in collaborative query development. The validation process may include parsing the code, checking for syntax errors, and providing feedback to the user before finalizing the output. This approach streamlines the review process by eliminating invalid code early in the workflow.
3. The method of claim 1 , wherein the method further comprises after receiving the indication that the second user approves the code for the query, receiving, by the processing circuitry, a request to execute the query on the database; and wherein executing the query on the database comprises: based on the indication that the second user approves the code for the query and in response to receiving the request to execute the query, executing, by the processing circuitry, the query on the database.
A system and method for managing database query execution involves a multi-user approval process to ensure code safety before execution. The technology addresses the problem of unauthorized or unsafe database queries that could compromise data integrity or security. The method includes receiving a query from a first user, where the query is associated with executable code. The system then sends the query to a second user for approval, ensuring that the code is reviewed before execution. After the second user approves the code, the system receives a request to execute the query on the database. The query is then executed only if the approval from the second user is confirmed, providing an additional layer of security. This approach prevents unauthorized or malicious queries from being executed, reducing the risk of data corruption or unauthorized access. The method ensures that only approved and verified queries are run on the database, enhancing security and reliability in database management systems.
4. The method of claim 3 , wherein the operation to determine the number of records of the database that would be accessed by executing the query on the database comprises a first operation to determine a first number of records of the database that would be accessed by executing the query on the database, and wherein the method further comprises: in response to receiving the request to execute the query and prior to executing the query on the database, automatically performing, by the processing circuitry, a second operation to determine a second number of records of the database that would be accessed by executing the query on the database; and outputting, by the processing circuitry, the second number of records of the database that would be accessed by executing the query on the database.
Database query optimization involves predicting the performance impact of executing a query before actual execution to avoid resource-intensive operations. A method addresses the challenge of estimating the number of records a query will access without running the query, which is critical for large-scale databases where full execution is costly. The method first determines an initial estimate of the number of records a query would access. Before executing the query, the system automatically performs a second estimation to refine the prediction. This second operation provides a more accurate count of the records that would be accessed if the query were executed. The refined estimate is then outputted, allowing users or systems to assess the query's potential impact on database performance. This approach helps prevent unnecessary resource consumption by identifying inefficient queries before execution, improving database efficiency and responsiveness. The method leverages processing circuitry to perform these operations, ensuring rapid and automated estimation without manual intervention. This technique is particularly useful in environments where query performance prediction is essential for maintaining system stability and optimizing resource allocation.
5. The method of claim 4 , wherein the method further comprises: prior to executing the query on the database: determining that the second number of records of the database that would be accessed by executing the query on the database is different from the first number of records of the database that would be accessed by executing the query on the database; outputting, by the processing circuitry, an indication that the second number of records is different from the first number of records and a prompt for an explanation of why the second number of records is different from the first number of records; receiving, by the processing circuitry, data indicating the explanation of why the second number of records is different from the first number of records; and storing, by the processing circuitry, the data indicating the explanation of why the second number of records is different from the first number of records, and wherein in response to receiving the request to execute the query and based on the indication that the second user approves the code for the query, executing, by the processing circuitry, the query on the database comprises: in response to receiving the request to execute the query and the data from the first user indicating the explanation of why the second number of records is different from the first number of records, and based on the indication that the second user approves the code for the query, executing, by the processing circuitry, the query on the database.
This invention relates to database query execution systems that track and validate changes in query behavior. The problem addressed is ensuring transparency and accountability when a database query's record access pattern changes unexpectedly, which can indicate errors, performance issues, or unintended data exposure. The system monitors database queries to detect discrepancies between the expected and actual number of records accessed. When a query is modified, the system compares the record access count of the new query version against the original. If a difference is detected, the system prompts the query author for an explanation before execution. The explanation is stored alongside the query for audit purposes. A second user, such as a reviewer or approver, must explicitly approve the modified query code before execution is allowed. This approval process ensures that changes in query behavior are documented and authorized, reducing risks from unintended modifications. The system enforces this validation workflow by intercepting query execution requests, performing the record count comparison, and requiring both the explanation and approval before proceeding. This approach enhances data governance by maintaining a clear audit trail of query changes and ensuring that modifications are intentional and justified.
6. The method of claim 1 , wherein the code for the query that expresses the operation to be performed on the database comprises a first code for the query that expresses a first operation to be performed on the database, wherein the first operation is configured to alter at least one record stored by the database from a first state to a second state, wherein the method further comprises: prior to outputting, for display to the second user, the code for the query for review by the second user: outputting, by the processing circuitry and to the first user, a prompt for a second query for rolling back changes to the database caused by execution of the first code, wherein the second query expresses a second operation to be performed on the database, and wherein the second operation is configured to revert the at least one record from the second state back to the first state; and receiving, by the processing circuitry and from the first user, the second code for rolling back changes to the database caused by execution of the first code.
This invention relates to database management systems, specifically methods for handling database queries and ensuring data integrity by providing rollback capabilities. The problem addressed is the risk of unintended or erroneous changes to database records, which can lead to data corruption or loss. The solution involves a system that generates and manages database queries, including both the primary operation and a corresponding rollback operation to revert any changes made. The method involves processing a database query that alters at least one record from a first state to a second state. Before displaying the query to a second user for review, the system prompts the first user to provide a rollback query. This rollback query is designed to revert the record(s) from the second state back to the first state, effectively undoing the changes made by the initial query. The system then receives the rollback query from the first user, ensuring that a mechanism exists to reverse the database modifications if needed. This approach enhances data safety by requiring explicit consideration of potential rollback actions before changes are finalized.
7. The method of claim 1 , wherein the code for the query that expresses the operation to be performed on the database comprises a first code for the query that expresses a first operation to be performed on the database, wherein the first operation is configured to alter at least one record stored by the database from a first state to a second state, wherein the method further comprises: prior to outputting, for display to the second user, the code for the query for review by the second user: processing, by the processing circuitry, the first code to generate a second code, wherein the second code is for rolling back changes to the database caused by execution of the first code, wherein the second code expresses a second operation to be performed on the database, and wherein the second operation is configured to cause the database to revert the at least one record from the second state back to the first state.
This invention relates to database management systems, specifically to methods for generating and managing database queries that include rollback capabilities. The problem addressed is the need to ensure data integrity when executing database operations that modify records, by providing a mechanism to revert changes if necessary. The method involves processing a database query that alters at least one record in a database from a first state to a second state. Before displaying the query for review by a user, the system automatically generates a corresponding rollback query. This rollback query is designed to revert the modified record(s) back to their original state, effectively undoing the changes made by the initial query. The rollback query is generated by analyzing the original query's operations and constructing an inverse operation that reverses the modifications. This ensures that if the initial query is executed and later needs to be undone, the system can automatically apply the rollback query to restore the database to its prior state, maintaining data consistency and integrity. The method is particularly useful in environments where database operations must be reversible, such as in transactional systems or during development and testing phases.
8. The method of claim 1 , wherein the database comprises a first database, and wherein the method further comprises: after obtaining the code for the query to the first database and prior to outputting the code for the query for review by the second user, storing, by the processing circuitry and in a second database, a record for the query comprising the code for the query; after obtaining the indication that the second user approves the code for the query and prior to receiving the request to execute the query on the first database, storing, by the processing circuitry, data in the second database that indicates that the second user approves the code for the query; and after receiving the request to execute the query on the first database, storing, by the processing circuitry, data in the second database that indicates the request to execute the query.
This invention relates to database query management systems, specifically improving the tracking and approval process for database queries. The system addresses the challenge of ensuring that database queries are reviewed and approved before execution, while maintaining a detailed audit trail of all query-related activities. The system involves a first database where queries are executed and a second database used for tracking and approval purposes. When a user submits a query, the system generates code for the query and stores it in the second database before presenting it to a second user for review. The second user can approve or reject the query. If approved, the system records this approval in the second database. When the query is later executed on the first database, the system updates the second database to reflect the execution request. This ensures that all query-related actions—submission, review, approval, and execution—are logged in a centralized tracking database, providing transparency and accountability in database operations. The system enhances security and compliance by enforcing a structured approval workflow and maintaining a complete history of query activities.
9. The method of claim 1 , further comprising: storing, by the processing circuitry, an indication that the first user is a user of the database; storing, by the processing circuitry, an indication that the second user is a supervisor of the first user; storing, by the processing circuitry, data indicating that the first user is allowed to submit one or more codes for one or more queries to the database; and storing, by the processing circuitry, data indicating that the second user is allowed to submit approval of the one or more codes for the one or more queries to the database.
This invention relates to a database system that manages user permissions and approval workflows for code submissions. The system addresses the need for controlled access and oversight in database operations, particularly where certain users require approval from supervisors before submitting code for queries. The method involves storing user roles and permissions within the database. Specifically, the system records that a first user is a standard user of the database and that a second user is a supervisor of the first user. The system also stores permissions indicating that the first user is authorized to submit code for database queries, while the second user is authorized to approve those submissions. This ensures that only approved code is executed, enhancing security and compliance. The method integrates role-based access control with a hierarchical approval process, preventing unauthorized or unapproved database modifications. The system automates permission checks and approval tracking, streamlining workflows while maintaining oversight. This approach is particularly useful in environments where database integrity and regulatory compliance are critical, such as financial institutions or healthcare systems. The stored permissions and roles enable dynamic management of user capabilities, allowing administrators to adjust access levels as needed.
10. The method of claim 1 , the first user is disallowed from submitting approval of one or more queries to the database that the same first user submitted.
A system and method for managing database query approvals to prevent conflicts of interest. The technology addresses the problem of biased or unreliable data analysis when the same user submits both the query and its approval, which can lead to skewed results or unchecked errors. The invention ensures integrity by enforcing a separation between query submission and approval processes. When a user submits a query to a database, the system prevents that same user from approving the query, requiring a different user to review and approve it. This separation mitigates risks of self-approval, ensuring that queries are validated by independent parties. The method involves tracking query submissions and approvals, cross-referencing user identities to enforce the restriction. The system may apply this rule universally or selectively based on predefined criteria, such as query type or user role. The approach enhances data reliability by reducing conflicts of interest and promoting objective validation. The invention is applicable in environments where data integrity is critical, such as financial audits, scientific research, or regulatory compliance.
11. The method of claim 1 , wherein receiving the request to execute the query on the database comprises receiving, from the first user, the request to execute the query on the database.
A system and method for executing database queries involves processing requests from users to query a database. The method includes receiving a query request from a first user, where the request specifies a query to be executed on the database. The system then processes the query by accessing the database, retrieving the requested data, and returning the results to the user. The method ensures that the query is executed efficiently and securely, with appropriate access controls to verify that the requesting user has permission to access the requested data. The system may also log the query execution for auditing purposes. The method supports various types of queries, including read and write operations, and can be applied to different types of databases, such as relational, NoSQL, or distributed databases. The system may further optimize query performance by caching frequently accessed data or using indexing techniques to speed up data retrieval. The method ensures data integrity and consistency by enforcing transactional rules and concurrency controls. The system may also provide query validation to prevent malicious or improperly formatted queries from being executed. The method is designed to handle high volumes of concurrent queries while maintaining system stability and performance.
12. A computing system comprising processing circuitry and a storage system, the processing circuitry configured to: obtain, from a first user, code for a query to a database stored in the storage system, wherein the code for the query expresses an operation to be performed on the database; in response to receiving the code for the query, automatically perform an operation to determine a number of records of the database that would be accessed by executing the query on the database; output, for display to the first user, the number of records of the database that would be accessed by executing the query on the database; output, for display to the first user, a prompt for an acknowledgement by the first user of the number of records of the database that would be accessed; receive, from the first user, an indication of the acknowledgement by the first user of the number of records of the database that would be accessed; in response to receiving the code for the query and the indication of the acknowledgement by the first user of the number of records of the database that would be accessed, output, for display to a second user, the code for the query for review by the second user; after outputting the code for the query for review by the second user, obtain, from the second user, an indication that the second user approves the code for the query; and based on the indication that the second user approves the code for the query, execute the query on the database.
The computing system operates in the domain of database query management, addressing inefficiencies and risks associated with executing large-scale database queries without prior validation. The system includes processing circuitry and a storage system to manage database operations. When a first user submits a query, the system automatically estimates the number of records the query would access before execution. This estimate is displayed to the first user, who must acknowledge the potential impact before the query proceeds. The system then presents the query to a second user for approval, ensuring an additional layer of oversight. Only after both users confirm the query is executed, preventing unintended large-scale data retrieval or processing. This approach enhances control and transparency in database operations, reducing the risk of performance degradation or resource misuse due to unchecked queries. The system is particularly useful in environments where query impact must be carefully managed, such as large-scale databases or regulated industries.
13. The computing system of claim 12 , wherein the processing circuitry is configured to: prior to outputting, for display to the second user, the code for the query for review by the second user: automatically validate a syntax of the code for the query; and output, for display to the first user, an indication of whether the syntax of the code for the query is valid.
This invention relates to computing systems that facilitate collaborative query development between multiple users. The system addresses the challenge of ensuring query code correctness before sharing it with a second user for review, reducing errors and improving efficiency in collaborative environments. The system includes processing circuitry that automatically validates the syntax of query code generated by a first user before it is displayed to a second user. The validation process checks the code for errors, such as incorrect syntax or formatting, and provides feedback to the first user. If the code is valid, the system proceeds to display it to the second user for review. If errors are detected, the system alerts the first user, allowing them to correct the code before sharing it. This feature ensures that only syntactically correct query code is shared, minimizing review time and preventing downstream processing errors. The system may also include additional functionalities, such as generating the query code based on user inputs, storing query templates, and managing user permissions for collaborative query development. The validation step acts as a quality control measure, improving the reliability of shared query code in collaborative workflows.
14. The computing system of claim 13 , wherein the processing circuits are further configured to receive, after receiving the indication that the second user approves the code for the query, a request to execute the query on the database; and wherein the processing circuits are configured to execute, based on the indication that the second user approves the code for the query and in response to receiving the request to execute the query, the query on the database.
A computing system is designed to facilitate secure and approved execution of database queries. The system addresses the problem of unauthorized or unapproved database queries, which can lead to data breaches, unintended modifications, or system vulnerabilities. The system includes processing circuits that receive an indication from a first user that a second user has been granted approval rights for a specific database query. The processing circuits then receive a request from the second user to execute the query on the database. Upon receiving this request, the system verifies that the second user has the necessary approval from the first user. If approved, the system executes the query on the database. This ensures that only authorized and approved queries are executed, enhancing security and compliance. The system may also include additional features such as logging query execution, tracking approvals, or enforcing access controls to further secure database operations. The overall solution provides a controlled and auditable process for executing database queries, reducing the risk of unauthorized access or unintended actions.
15. The computing system of claim 14 , wherein the operation to determine the number of records of the database that would be accessed by executing the query on the database comprises a first operation to determine a first number of records of the database that would be accessed by executing the query on the database, and wherein the processing circuitry is further configured to: in response to receiving the request to execute the query and prior to executing the query on the database, automatically perform a second operation to determine a second number of records of the database that would be accessed by executing the query on the database; and output the second number of records of the database that would be accessed by executing the query on the database.
Database systems often struggle with efficiently estimating the impact of a query before execution, leading to performance issues or resource waste. This invention addresses the problem by providing a computing system that predicts the number of database records a query will access, both before and during execution, to optimize performance. The system includes processing circuitry configured to determine how many records a query would access if executed on a database. This involves a first operation to estimate the number of records the query would access, followed by a second operation that automatically recalculates this estimate in response to a request to execute the query. The second operation provides an updated estimate of the number of records the query will access, which is then output before the query is actually executed. This allows the system to dynamically assess query impact, helping to prevent excessive resource usage or inefficient execution plans. The system may also include additional components, such as a query optimizer or a database interface, to further refine query performance based on these estimates. By providing real-time feedback on query scope, the invention improves database efficiency and user experience.
16. The computing system of claim 15 , wherein the processing circuitry is further configured to: prior to executing the query on the database: determine that the second number of records of the database that would be accessed by executing the query on the database is different from the first number of records of the database that would be accessed by executing the query on the database; output an indication that the second number of records is different from the first number of records and a prompt for an explanation of why the second number of records is different from the first number of records; receive data indicating the explanation of why the second number of records is different from the first number of records; store, in the storage system, the data indicating the explanation of why the second number of records is different from the first number of records; and in response to receiving the request to execute the query and the data from the first user indicating the explanation of why the second number of records is different from the first number of records, and based on the indication that the second user approves the code for the query, execute the query on the database.
This invention relates to database query execution systems that detect and handle discrepancies in query results. The problem addressed is ensuring data integrity and transparency when executing database queries, particularly when changes in the database or query logic cause unexpected differences in the number of records accessed. The system compares the expected number of records (first number) that a query would access against the actual number of records (second number) it would access after modifications. If a discrepancy is detected, the system prompts the user for an explanation before proceeding. The explanation is stored for audit purposes. The system also requires approval from a second user before executing the query, ensuring accountability. This approach enhances data governance by tracking and justifying changes that affect query results, reducing errors and improving compliance. The invention is particularly useful in environments where data accuracy and traceability are critical, such as financial systems or regulatory reporting.
17. The computing system of claim 12 , wherein the code for the query that expresses the operation to be performed on the database comprises first code for the query that expresses a first operation to be performed on the database, wherein the first operation is configured to alter at least one record stored by the database from a first state to a second state, wherein the processing circuitry is further configured to: prior to outputting, for display to the second user, the code for the query for review by the second user: output, to the first user, a prompt for second query for rolling back changes to the database caused by execution of the first code, wherein the second query expresses a second operation to be performed on the database, and wherein the second operation is configured to revert the at least one record from the second state back to the first state; and receive, from the first user, the second code for rolling back changes to the database caused by execution of the first code.
This invention relates to computing systems that facilitate database operations with built-in rollback capabilities. The system is designed to enhance database management by ensuring that changes made to records can be easily reverted if needed. The system includes processing circuitry that executes code for a query to perform an operation on a database, such as altering a record from a first state to a second state. Before displaying this query to a second user for review, the system prompts the first user to provide a rollback query. This rollback query expresses an operation that reverts the altered record back to its original state. The system then receives the rollback code from the first user, ensuring that any changes made by the initial query can be undone. This approach improves database integrity by providing a mechanism to undo modifications, reducing the risk of unintended data loss or corruption. The system is particularly useful in collaborative environments where multiple users interact with the database, ensuring that changes can be reviewed and reverted if necessary. The rollback functionality is integrated into the query process, making it seamless and user-friendly.
18. The computing system of claim 12 , wherein the code for the query that expresses the operation to be performed on the database comprises first code for the query that expresses a first operation to be performed on the database, wherein the first operation is configured to alter at least one record stored by the database from a first state to a second state, wherein the processing circuitry is further configured to: prior to outputting, for display to the second user, the code for the query for review by the second user: process the first code to generate a second code for rolling back changes to the database caused by execution of the first code, wherein the second code expresses a second operation to be performed on the database, and wherein the second operation is configured to cause the database to revert the at least one record from the second state back to the first state.
This invention relates to computing systems that manage database operations, particularly focusing on query execution and rollback mechanisms. The system processes database queries that alter records, such as updating or modifying data, and generates corresponding rollback queries to revert those changes. When a user submits a query to modify database records, the system automatically creates a complementary rollback query that can undo the modifications. This rollback query is generated before the original query is executed, ensuring that any changes can be reversed if needed. The system then displays both the original query and the rollback query to a second user for review, allowing verification before execution. This approach enhances data integrity by providing a safeguard against unintended modifications, ensuring that changes can be reverted if errors or issues arise during execution. The invention is particularly useful in environments where data accuracy and recoverability are critical, such as financial systems, transaction processing, or any application requiring strict data consistency.
19. The computing system of claim 12 , wherein the database comprises a first database, and wherein the processing circuitry is further configured to: after obtaining the code for the query to the first database and prior to outputting the code for the query for review by the second user, store, in a second database, a record for the query comprising the code for the query; after obtaining the indication that the second user approves the code for the query and prior to receiving the request to execute the query on the first database, store data in the second database that indicates that the second user approves the code for the query; and after receiving the request to execute the query on the first database, store data in the second database that indicates the request to execute the query.
The invention relates to a computing system for managing database queries, particularly focusing on query approval and execution tracking. The system addresses the problem of ensuring proper review and authorization of database queries before execution, which is critical for security and data integrity in environments where multiple users interact with sensitive data. The system includes processing circuitry configured to obtain code for a query targeting a first database. Before allowing a second user to review the query code, the system stores a record of the query in a second database, including the query code. After the second user approves the query code, the system updates the second database to reflect this approval. When a request is received to execute the query on the first database, the system records this execution request in the second database. This approach ensures a clear audit trail of query creation, approval, and execution, enhancing accountability and traceability in database operations. The second database serves as a log for tracking the lifecycle of each query, from initial submission to final execution, providing transparency and control over database access.
20. The computing system of claim 12 , wherein the processing circuitry is further configured to: store, in the storage system, an indication that the first user is a user of the database; store, in the storage system, an indication that the second user is a supervisor of the first user; store, in the storage system, data indicating that the first user is allowed to submit one or more codes for one or more queries to the database; and store, in the storage system, data indicating that the second user is allowed to submit approval of the one or more codes for the one or more queries to the database.
This invention relates to a computing system for managing user permissions and approval workflows in a database environment. The system addresses the challenge of securely controlling access and approval processes for database queries, ensuring that only authorized users can submit queries and that their submissions are properly reviewed by designated supervisors. The computing system includes processing circuitry and a storage system. The processing circuitry is configured to store user roles and permissions in the storage system. Specifically, it records that a first user is a standard user of the database and that a second user is a supervisor of the first user. The system also stores data indicating that the first user is permitted to submit one or more codes for queries to the database, while the second user is authorized to approve those codes. This setup enforces a hierarchical approval process, where queries from standard users must be reviewed and approved by their supervisors before execution. The storage system maintains these permissions and relationships to ensure proper access control and workflow management. The system may also include additional features, such as query validation, logging, and audit trails, to enhance security and compliance.
21. The computing system of claim 12 , the first user is disallowed from submitting approval of one or more queries to the database that the same first user submitted.
A computing system is designed to manage database queries by preventing a user from approving their own submissions. The system includes a database, a query submission interface, and an approval mechanism. Users submit queries through the interface, which are then reviewed and approved by other users before execution. The system enforces a rule that disallows a user from approving any query they previously submitted, ensuring unbiased review. The system tracks query submissions and approvals to enforce this restriction, preventing conflicts of interest. This approach improves data integrity by ensuring that only independent users validate queries, reducing the risk of errors or manipulation. The system may also include additional features such as query validation, logging, and user authentication to enhance security and reliability. The approval process may involve multiple users or automated checks to further validate queries before execution. The system is particularly useful in environments where query accuracy and impartiality are critical, such as financial, medical, or regulatory applications.
22. A non-transitory, computer-readable medium comprising instructions that, when executed, are configured to cause processing circuitry of a computing device to: obtain, from a first user, code for a query to a database, wherein the code for the query expresses an operation to be performed on the database; in response to receiving the code for the query, automatically perform an operation to determine a number of records of the database that would be accessed by executing the query on the database; output, for display to the first user, the number of records of the database that would be accessed by executing the query on the database; output, for display to the first user, a prompt for an acknowledgement by the first user of the number of records of the database that would be accessed; receive, from the first user, an indication of the acknowledgement by the first user of the number of records of the database that would be accessed; in response to receiving the code for the query and the indication of the acknowledgement by the first user of the number of records of the database that would be accessed, output, for display to a second user, the code for the query for review by the second user; after outputting the code for the query for review by the second user, obtain, from the second user, an indication that the second user approves the code for the query; and based on the indication that the second user approves the code for the query, execute the query on the database.
This invention relates to database query management systems that enhance transparency and control in database operations. The system addresses the problem of unintended or excessive data access during query execution, which can lead to performance issues, security risks, or unauthorized data exposure. The solution involves a multi-step process to ensure that database queries are reviewed and approved before execution. The system obtains a query code from a first user, which specifies an operation to be performed on a database. Before executing the query, the system automatically estimates the number of records that would be accessed if the query were run. This estimate is displayed to the first user, who must acknowledge the potential data impact. The query is then presented to a second user for review and approval. Only after the second user approves the query is it executed on the database. This approach ensures that queries are scrutinized for efficiency and security before execution, reducing the risk of unintended data access. The system operates on a computing device with processing circuitry and is implemented via executable instructions stored on a non-transitory, computer-readable medium.
Cooperative Patent Classification codes for this invention. Click any code to explore related patents in that topic.
November 19, 2019
March 8, 2022
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.