A system includes reception of an instruction to commit a design-time artifact of a database server application to a repository of a database server, storage of the design-time artifact in the repository of the database server in association with an inactive flag, reception of a request from a user to access the design-time artifact associated with the inactive flag, and, in response to the request, generation of a private runtime representation of the design-time artifact associated with the inactive flag, and deployment of the private runtime representation of the design-time artifact for exclusive use by the 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 system comprising: a memory storing processor-executable process steps; and a processor to execute the processor-executable process steps to cause the system to: receive an instruction to commit a design-time artifact of a database server application and metadata associated with the design-time artifact to a repository of a database server; associate the design-time artifact with a flag that indicates an active state of the design-time artifact or an inactive state of the design-time artifact, wherein the design-time artifact is a database procedure or an analytical view and wherein in a case that the design-time artifact is associated with a flag that indicates an inactive state, the metadata stored in the repository indicates that the design-time artifact is a test version of a second design-time artifact that is associated with a flag that indicates an active state; store the design-time artifact in the repository of the database server in association with the flag; set the flag to indicate the inactive state; receive a request from a user to access the design-time artifact associated with the flag set to the inactive state; and in response to the request, and based on the flag indicating the inactive state, generate a private runtime representation of the design-time artifact and deploy the private runtime representation of the design-time artifact for exclusive use by the user.
A system manages database server application design-time artifacts (like database procedures or analytical views) by storing them in a repository along with metadata. When a design-time artifact is committed, it's associated with a flag indicating whether it's active or inactive (a test version). If inactive, the metadata marks it as a test version of an active artifact. When a user requests access to an inactive artifact, the system generates a private, runtime version specifically for that user. This allows developers to test changes without affecting the production database.
2. A system according to claim 1 , wherein the processor is further to execute the processor-executable process steps to cause the system to: store a second design-time artifact in the repository of the database server in association with a second flag set to the inactive state; and in response to the request, and based on the second flag indicating the inactive state, generate a second private runtime representation of the second design-time artifact, and deploy the second private runtime representation of the design-time artifact for exclusive use by the user.
The system described previously also allows storing multiple design-time artifacts in the repository, each with its own active/inactive flag. If a user requests access to multiple artifacts flagged as inactive, the system generates separate, private runtime representations for each of those artifacts, enabling isolated testing of multiple components or versions simultaneously. Each private version is deployed exclusively for the requesting user.
3. A system according to claim 1 , wherein the instruction is received from the user.
In the system described previously, the instruction to commit a design-time artifact (along with its metadata) comes directly from the user (likely a developer). This means the user initiates the process of saving the artifact to the repository, triggering the active/inactive flagging and potential private runtime environment creation.
4. A computer-implemented method comprising: receiving an instruction to commit a design-time artifact of a database server application and metadata associated with the design-time artifact to a repository of a database server; associating the design-time artifact with a flag that indicates an active state of the design-time artifact or an inactive state of the design-time artifact, wherein the design-time artifact is a database procedure or an analytical view and wherein in a case that the design-time artifact is associated with a flag that indicates an inactive state, the metadata stored in the repository indicates that the design-time artifact is a test version of a second design-time artifact that is associated with a flag that indicates an active state; storing the design-time artifact in the repository of the database server in association with the flag; setting the flag to indicate the inactive state; receiving a request from a user to access the design-time artifact associated with the flag set to the inactive state; and in response to the request, and based on the flag indicating the inactive state, generating a private runtime representation of the design-time artifact, and deploying the private runtime representation of the design-time artifact for exclusive use by the user.
A computer-implemented method manages database server application design-time artifacts (like database procedures or analytical views) by storing them in a repository along with metadata. When a design-time artifact is committed, it's associated with a flag indicating whether it's active or inactive (a test version). If inactive, the metadata marks it as a test version of an active artifact. When a user requests access to an inactive artifact, the method generates a private, runtime version specifically for that user. This allows developers to test changes without affecting the production database.
5. A computer-implemented method according to claim 4 , further comprising: storing a second design-time artifact in the repository of the database server in association with a second flag set to the inactive state; and in response to the request, and based on the second flag indicating the inactive state, generating a second private runtime representation of the second design-time artifact, and deploying the second private runtime representation of the design-time artifact for exclusive use by the user.
The computer-implemented method described previously also allows storing multiple design-time artifacts in the repository, each with its own active/inactive flag. If a user requests access to multiple artifacts flagged as inactive, the method generates separate, private runtime representations for each of those artifacts, enabling isolated testing of multiple components or versions simultaneously. Each private version is deployed exclusively for the requesting user.
6. A computer-implemented method according to claim 4 , wherein the instruction is received from the user.
In the computer-implemented method described previously, the instruction to commit a design-time artifact (along with its metadata) comes directly from the user (likely a developer). This means the user initiates the process of saving the artifact to the repository, triggering the active/inactive flagging and potential private runtime environment creation.
7. A non-transitory computer-readable medium storing program code, the program code executable by a computer system to cause to the computer system to: receive an instruction to commit a design-time artifact of a database server application and metadata associated with the design-time artifact to a repository of a database server; associating the design-time artifact with a flag that indicates an active state of the design-time artifact or an inactive state of the design-time artifact, wherein the design-time artifact is a database procedure or an analytical view and wherein in a case that the design-time artifact is associated with a flag that indicates an inactive state, the metadata stored in the repository indicates that the design-time artifact is a test version of a second design-time artifact that is associated with a flag that indicates an active state; store the design-time artifact in the repository of the database server in association with the flag; set the flag to indicate the inactive state; receive a request from a user to access the design-time artifact associated with the flag set to the inactive state; and in response to the request, and based on the flag indicating the inactive state, generate a private runtime representation of the design-time artifact and deploy the private runtime representation of the design-time artifact for exclusive use by the user.
A computer-readable medium stores instructions to manage database server application design-time artifacts (like database procedures or analytical views) by storing them in a repository along with metadata. When a design-time artifact is committed, it's associated with a flag indicating whether it's active or inactive (a test version). If inactive, the metadata marks it as a test version of an active artifact. When a user requests access to an inactive artifact, the instructions generate a private, runtime version specifically for that user. This allows developers to test changes without affecting the production database.
8. A medium according to claim 7 , wherein the program code is further executable by a computer system to cause to the computer system to: store a second design-time artifact in the repository of the database server in association with a second flag set to the inactive state; and in response to the request, and based on the second flag indicating the inactive state, generate a second private runtime representation of the second design-time artifact, and deploy the second private runtime representation of the design-time artifact for exclusive use by the user.
The computer-readable medium described previously also stores instructions to allow storing multiple design-time artifacts in the repository, each with its own active/inactive flag. If a user requests access to multiple artifacts flagged as inactive, the instructions generate separate, private runtime representations for each of those artifacts, enabling isolated testing of multiple components or versions simultaneously. Each private version is deployed exclusively for the requesting user.
9. A medium according to claim 7 , wherein the instruction is received from the user.
In the computer-readable medium described previously, the instruction to commit a design-time artifact (along with its metadata) comes directly from the user (likely a developer). This means the user initiates the process of saving the artifact to the repository, triggering the active/inactive flagging and potential private runtime environment creation.
10. The system of claim 1 , wherein in a case that the design-time artifact is associated with a flag that indicates an active state, the design-time artifact is compiled as a runtime object and is executed at runtime.
In the system for managing design-time artifacts, when a design-time artifact is committed with the active flag set, it is compiled into a runtime object. This compiled object is then executed during normal database server operation. The active design-time artifact is the production version.
11. The system of claim 1 , wherein the user is a developer that committed the design-time artifact to the repository.
In the system for managing design-time artifacts, the user requesting access to the inactive design-time artifact is a developer who initially committed the artifact to the repository. This developer uses the system to test their own changes in isolation.
12. The system of claim 1 , wherein the received request comprises a request to access all design-time artifacts associated with a flag set to the inactive state.
In the system for managing design-time artifacts, the user's request can be to access all design-time artifacts marked with the inactive flag. This allows a developer to retrieve and test multiple test artifacts simultaneously, or to test an application which contains multiple inactive or test artifacts.
13. The system of claim 1 , wherein the private runtime representation of the design-time artifact is associated with an application that comprises the design-time artifact associated with the flag set to the inactive state and wherein the private runtime representation of the design-time artifact associated with the flag set to the inactive state comprises execution of the application including the design-time artifact associated with the flag set to the inactive state.
In the system for managing design-time artifacts, the private runtime representation of the inactive design-time artifact is part of an application containing that artifact. When the user executes the private runtime representation, they are effectively running the entire application, including the test artifact in its isolated environment.
Cooperative Patent Classification codes for this invention. Click any code to explore related patents in that topic.
June 23, 2014
May 9, 2017
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.