Ephemeral graph database
By using a temporary graph database and storing it with BLOB during the graph analysis process, the problems of large storage space occupation and high maintenance costs caused by graph analysis in the prior art are solved, and more efficient storage and maintenance are achieved.
Patent Information
- Application Number
- JP2024135525
- Authority / Receiving Office
- JP · JP
- Patent Type
- Applications
- Current Assignee / Owner
- Priority Date
- 2023-08-28
- Filing Date
- 2024-08-15
- Publication Date
- 2025-03-18
AI Technical Summary
In the prior art, when performing graph analysis, data needs to be copied to a permanent storage device, resulting in large storage space occupancy, high maintenance costs, and increased data quality errors.
The temporary graph database is used, and the temporary graph database is stored in binary large objects (BLOB) rather than relational database management system (RDBMS), and is deleted immediately after use, avoiding unnecessary storage and maintenance.
Through the use of temporary graph databases, the storage space occupation and maintenance costs are reduced, and the occurrence of data quality errors is reduced.
Smart Images
Figure 2025037815000001_ABST
Abstract
Description
[Technical field]
[0001] This application relates generally to database management, and more particularly to computing graphical analysis results from data stored in a database. [Background technology]
[0002]
[0002] A relational database is a type of database in which related data elements are stored in a manner that reflects the relationships between the data elements. A database in which data elements are organized into rows and columns is an example of a relational database. More complex relationships between data elements and sets of data elements can also be represented using a relational database.
[0003]
[0003] A relational database can be represented as having a graph structure, where a data element or a set of data elements is represented as a node of the graph, and the relationships between the elements or sets are represented as edges of the graph. When a relational database is represented using a graph structure, techniques from graph theory can be used to perform analysis of the relational database. Thus, a user can extract insights related to the graph structure of the relationships between the data elements. Summary of the Invention
[0004]
[0004] According to one aspect of the disclosure, a server computing device is provided that includes one or more server memory devices having a relational database stored thereon. The server computing device further includes one or more server processing devices configured to receive a temporary graph database request via a database application programming interface (API). The temporary graph database request indicates a selection of data stored in the relational database for inclusion in the temporary graph database. The one or more server processing devices are further configured to generate the temporary graph database. The temporary graph database encodes the selected data into a graph structure. The one or more server processing devices are further configured to store the temporary graph database in a binary large object (BLOB) storage of the one or more server memory devices. The one or more server processing devices are further configured to receive, via the database API, an instruction to apply a graph analysis algorithm to the temporary graph database, and to retrieve the temporary graph database from the BLOB storage in response to receiving the instruction to apply the graph analysis algorithm. The one or more server processing devices are further configured to apply the graph analysis algorithm to the temporary graph database to generate a graph analysis result. The one or more server processing devices are further configured to output the graph analysis result. The one or more server processing devices are further configured to delete the temporary graph database from the BLOB storage. [Brief description of the drawings]
[0005] [Figure 1]
[0005] A schematic illustration of a computing system including a server computing device and a client computing device when a temporary graph database is generated and a graph analysis algorithm is applied in accordance with an exemplary embodiment. [Diagram 2]
[0006] 2 illustrates a schematic diagram of a server computing device when one or more server processing devices included in the server computing device receive a temporary graph database request, according to one embodiment of FIG. 1; [Diagram 3]
[0007] 2 is a schematic diagram illustrating a server computing device in further detail when temporary database log data is generated and stored according to one embodiment of FIG. 1; [Figure 4]
[0008] FIG. 2 illustrates a schematic diagram of a computing system when a graph database user interface is executed on one or more client processing devices included in a client computing device, according to one embodiment. [Diagram 5]
[0009] 2 is a schematic diagram of a computing system when a temporary graph database storage size is requested and displayed on a client computing device according to one embodiment of FIG. 1; [Figure 6]
[0010] 2 illustrates an exemplary graph database user interface configured to be displayed on a display device of a client computing device, according to one embodiment of FIG. 1. [Figure 7A]
[0011] 2 shows a flowchart of a method for use with a server computing device to generate a temporary graph database and execute graph analysis algorithms according to one embodiment of FIG. 1; [Figure 7B]
[0012] 7B illustrates further steps of the method of FIG. 7A that are performed in some embodiments. [Figure 7C] 7B illustrates further steps of the method of FIG. 7A that are performed in some embodiments. [Figure 7D] 7B illustrates further steps of the method of FIG. 7A that are performed in some embodiments. [Figure 8]
[0013] FIG. 1 illustrates a schematic of a computing environment in which a computing system is instantiated, according to one embodiment. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0006]
[0014] In existing relational database management systems (RDBMS), performing graph analysis on a stored database involves replicating data stored in the relational database. This replicated data is stored in persistent storage while the graph analysis is being performed. However, storing the replicated data in persistent storage when graph analysis is frequently performed requires large amounts of storage space. Furthermore, in some embodiments where graph analysis is repeatedly performed, frequently storing the replicated data in persistent storage results in additional costs associated with maintaining and updating copies of the database. When relational databases are replicated, data quality errors also increase, as do the costs associated with correcting the errors.
[0007]
[0015] To address the above challenges in performing graph data analytics on relational databases, a temporary graph database is provided. The temporary graph database is stored for a limited period of time and is stored in binary large object (BLOB) storage rather than an RDBMS. Thus, the temporary graph database is generated with reduced overhead. This reduced overhead allows a user to generate a temporary graph database specifically for performing a graph analytics algorithm, and the temporary graph database is deleted once the graph analytics algorithm has finished executing.
[0008]
[0016] FIGURE 1 illustrates a schematic diagram of a computing system 1 including a server computing device 10 and a client computing device 20, according to one exemplary embodiment. As illustrated in the example of FIGURE 1, the server computing device 10 includes one or more server processing devices 12 and one or more server memory devices 14. The server processing device 12 may include, for example, one or more central processing units (CPUs), one or more graphics processing units (GPUs), and / or one or more other hardware accelerators. The one or more server memory devices 14 may include, for example, one or more volatile memory devices and one or more non-volatile storage devices.
[0009]
[0017] In some embodiments, one or more of the server processing devices 12 and one or more of the server memory devices 14 are included in one or more components that combine processor and memory capabilities, such as a system on a chip (SoC). Additionally or alternatively, in some embodiments, one or more of the server processing devices 12 and one or more of the server memory devices 14 are distributed across multiple physical computing systems, such as multiple networked computing devices located in a data center.
[0010]
[0018] As shown in the embodiment of FIG. 1, the client computing device 20 includes one or more client processing devices 22 and one or more client memory devices 24. The client processing device 22 includes one or more CPUs, GPUs, and / or other hardware accelerators. The client memory device 24 includes, for example, one or more volatile memory devices and one or more non-volatile storage devices. Additionally, the client computing device 20 includes one or more user input devices 26 and one or more display devices 28. Exemplary user input devices 26, such as a keyboard, a mouse, a touch screen, a microphone, an inertial measurement unit (IMU), and / or a camera, may be included in the client computing device 20. In addition to the one or more display devices 28, one or more other output devices, such as a speaker or a haptic feedback device, may also be included in the client computing device in some embodiments. The client computing device 20 is configured to communicate with the server computing device 10.
[0011]
[0019] 1, the one or more server memory devices 14 store a relational database 32 in an RDBMS 30. The relational database 32 includes one or more tables 34. Each table includes respective data 36 provided as one or more data elements. The server computing device 10 is configured to store the relational database 32 in persistent storage.
[0012]
[0020] The one or more server processing devices 12 are configured to execute a database application programming interface (API) 50. Through the database API 50, the RDBMS 30 is configured to interact with other computing processes executing on the one or more server processing devices 12. In addition, the client computing devices 20 are configured to use the database API 50 to interact with the RDBMS 30.
[0013]
[0021] Via the database API 50, the one or more server processing devices 12 are configured to receive a temporary graph database request 52. The temporary graph database request 52 is a request to generate a temporary graph database 42, as described in further detail below. The temporary graph database request 52 includes a data selection 54 that is a selection of data 36 stored in the relational database 32 for inclusion in the temporary graph database 42. In some embodiments, the data selection 54 represents all of the data 36 contained in the relational database 32, while in other embodiments, the data selection 54 represents only a subset of the data 36, such as that contained in a subset of the plurality of tables 34.
[0014]
[0022] 1, the temporary graph database request 52 further includes a temporary graph database lifetime 56 that specifies a period of time during which the server computing device 10 is configured to store the temporary graph database 42 in the one or more server memory devices 14. In some embodiments, as shown in FIG. 1, the temporary graph database request 52 further includes an access control setting 59 that specifies one or more users that are permitted to access the temporary graph database 42. In some embodiments, various role-based permissions are indicated in the access control setting 59, such as instructions to grant one or more users a role of reader and one or more other users a role of maintainer.
[0015]
[0023] 1 , the temporary graph database request 52 is received from a client computing device 20. In other embodiments, the database API 50 receives the temporary graph database request 52 originating from a computing process executing on the server computing device 10.
[0016]
[0024] The one or more server processing devices 12 are further configured to generate a temporary graph database 42. The temporary graph database 42 encodes the selected data 36 into a graph structure 44. The graph structure 44 includes a plurality of nodes 46 and edges 48. In some embodiments, the graph structure 44 is a directed graph structure, where the edges 48 have respective directions. In other embodiments, the graph structure 44 is a weighted graph structure, where the edges 48 have respective weights. In other embodiments, the graph structure 44 is a directed weighted graph structure. The weights and / or directions of the edges 48 may be calculated from the selected data 36. With the selected data 36, the temporary graph database 42 is generated. In other embodiments, the graph structure 44 is an undirected, unweighted graph structure.
[0017]
[0025] Figure 2 illustrates in further detail a schematic diagram of the server computing device 10 when a temporary graph database request 52 is received. According to the embodiment of Figure 2, in the temporary graph database request 52, a data selection 54 specifies one or more first tables 34A and one or more second tables 34B to be included in the relational database 32. The one or more first tables 34A store first data 36A and the one or more second tables 34B store second data 36B. The set of one or more first tables 34A overlaps, in some embodiments, with the set of one or more second tables 34B.
[0018]
[0026] In the embodiment of FIG. 2, the one or more server processing devices 12 are configured to use the one or more first tables 34A as nodes 46 of the graph structure 44. The one or more server processing devices 12 are further configured to use the one or more second tables 34B or one or more queries 58 to the one or more second tables 34B as edges 48 of the graph structure 44. The one or more queries 58 to the one or more second tables 34B are queries to the relational database 32 and are further included in the temporary graph database request 52. Thus, the temporary graph database request 52 uses the one or more queries 58 in such embodiments to specify the structure of the temporary graph database 42 in a manner that can specify relationships that are not explicitly encoded in the tables 34 included in the relational database 32. In some embodiments, the direction and / or weight of the edge 48 is calculated as specified by the one or more queries 58. Additionally or alternatively, the direction and / or weight may be calculated from second data 36B stored in the one or more second tables 34B.
[0019]
[0027] The one or more server processing devices 12 are further configured to store the temporary graph database 42 in a binary large object (BLOB) storage 40 of the one or more memory devices 14. FIG. 2 illustrates the one or more server memory devices 14 when the relational database 32 is stored in the RDBMS 30 and the temporary graph database 42 is stored in the BLOB storage 40. However, the temporary graph database 42 is not stored in the RDBMS 30. By storing the temporary graph database 42 in the BLOB storage 40 rather than the RDBMS 30, the one or more server processing devices 12 store the temporary graph database 42 in a manner such that a temporary graph database storage size 43 of the temporary graph database 42 is smaller than a relational database storage size 33 of the relational database 32.
[0020]
[0028] Returning to the embodiment of Figure 1, after storing the temporary graph database 42 in the BLOB storage 40, the one or more server processing devices 12 are further configured to receive, via the database API 50, instructions 60 to apply a graph analysis algorithm 62 to the temporary graph database 42. For example, the graph analysis algorithm 62 can be a nearest neighbor algorithm, a centrality algorithm, a min-cut algorithm, a clustering algorithm, or some other algorithm that utilizes the graph structure 44 as input.
[0021]
[0029] In response to receiving the instructions 60 to apply the graph analysis algorithm 62, the one or more server processing devices 12 are further configured to retrieve the temporary graph database 42 from the BLOB storage 40. The temporary graph database 42 is retrieved from the non-volatile memory into the working memory. The one or more server processing devices 12 are further configured to apply the graph analysis algorithm 62 to the temporary graph database 42 to generate graph analysis results 64 as output of the graph analysis algorithm 62.
[0022]
[0030] The one or more server processing devices 12 are further configured to output the graph analysis results 64. In some embodiments, the graph analysis results 64 are output to the client computing device 20. Thus, the graph analysis results 64 may be available for output to a user. Additionally or alternatively, in some embodiments, the one or more server processing devices 12 are further configured to store the graph analysis results 64 in the relational database 32, as shown in the embodiment of FIG. 2. Thus, in such embodiments, the graph analysis results 64 may be available for querying and used as input to further analysis processes. In some embodiments, the temporary graph database generation is performed iteratively in a manner that incorporates the graph analysis results 64 calculated from previous iterations of the temporary graph database 42.
[0023]
[0031] The one or more server processing devices 12 are further configured to delete the temporary graph database 42 from the BLOB storage 40. In some embodiments, the one or more server processing devices 12 are configured to delete the temporary graph database 42 from the BLOB storage 40 in response to outputting the graph analysis results 64. Alternatively, in embodiments in which the temporary graph database request includes a temporary graph database lifetime 56, the one or more server processing devices 12 are further configured to delete the temporary graph database 42 from the BLOB storage 40 in response to determining that the temporary graph database lifetime 56 has elapsed. In other embodiments, the temporary graph database 42 is deleted in response to some other event, such as receiving an instruction to purge the temporary graph database 42 received prior to the expiration of the temporary graph database lifetime 56.
[0024]
[0032] 2 further illustrates database log data 80 stored in one or more server memory devices 14. The temporary database log data 80 is organized as a number of records associated with respective events. Each record included in the temporary database log data 80 includes record metadata 88, such as a timestamp 88A, an event type 88B, an event identifier 88C, and / or a user identifier 88D associated with the logged event. Other types of record metadata 88 may also be included in the database log data 80 in some embodiments.
[0025]
[0033] The one or more server processing devices 12 are configured to generate temporary database log data 80 and store the temporary database log data 80 in the one or more server memory devices 14. Figure 3 illustrates in further detail the server computing device 10 as the temporary database log data 80 is generated and stored. As shown in Figure 3, the temporary database log data 80 includes a temporary database creation record 82 of the creation of the temporary graph database 42. The temporary database creation record 82 indicates the inputs and parameters with which the temporary graph database 42 was created, as specified in the temporary graph database request 52.
[0026]
[0034] Additionally, the temporary database log data 80 further includes an analysis record 84 of the execution of the graph analysis algorithm 62. The analysis record 84 specifies the graph analysis algorithm 62 indicated in the instructions 60, as well as the inputs and parameters by which the graph analysis algorithm 62 is applied to the temporary graph database 42. The temporary database log data 80 further includes a temporary database deletion record 86 of the deletion of the temporary graph database 42 from the BLOB storage 40.
[0027]
[0035] 4 illustrates in schematic form the computing system 1 in further detail when a graph database user interface 70 is executed on one or more client processing devices 22 included in the client computing device 20. The graph database user interface 70 is configured to be displayed on the display device 28 and to receive user interaction via one or more user input devices 26. The graph database user interface 70 is configured to interact with a graph database API 50 executing on the server computing device 10.
[0028]
[0036] 4, a user inputs a temporary graph database request 52, including a data selection, a temporary graph database lifetime 56, and a query 58, at a graph database user interface 70. Other inputs and / or parameters used in generating the temporary graph database 42 are also input at the graph database user interface 70 in some embodiments.
[0029]
[0037] The one or more client processing devices 22 are further configured to receive, via a graph database user interface 70, an analysis algorithm selection 72 from a user for selecting a graph analysis algorithm 62 that the one or more server processing devices 12 are configured to execute. Thus, instructions 60 for applying the graph analysis algorithm 62 are generated based at least in part on the analysis algorithm selection 72 entered at the graph database user interface 70. Graph analysis results 64 are also displayed at the graph database user interface 70 in the embodiment of FIG. 4. Thus, the output of the requested graph analysis algorithm 62 is presented to the user.
[0030]
[0038] 4 embodiment, the one or more client processing devices 22 are further configured to receive temporary graph modification inputs 74 entered via the graph database user interface 70. Based at least in part on the temporary graph modification inputs 74, the one or more client processing devices 22 are further configured to generate instructions 76 for updating, auditing, pruning, or extending the temporary graph database 42. These instructions 76 are then transmitted to the server computing device 10.
[0031]
[0039] The one or more server processing devices 12 are further configured to receive, via the database API 50, instructions 76 to update, audit, prune, or extend the temporary graph database 42. The one or more server processing devices 12 are further configured to update, audit, prune, or extend the temporary graph database 42 as indicated by the instructions 76.
[0032]
[0040] When the one or more server processing devices 12 update the temporary graph database 42, the one or more server processing devices 12 modify one or more of the nodes 46 and / or edges 48 of the temporary graph database 42. In some embodiments, the modification is to the topology of the graph structure 44. Such modifications may include, for example, adding or removing one or more nodes 46 and / or adding or removing one or more edges 48. In some embodiments, the one or more server processing devices 12 also or alternatively modify the data 36 stored in the nodes 46 and / or edges 48.
[0033]
[0041] In some embodiments, when the instructions 76 are executed, the one or more server processing devices 12 are further configured to audit the temporary graph database 42. Auditing the temporary graph database 42 includes retrieving at least a portion of the temporary database log data 80 associated with the temporary graph database 42. In some embodiments, auditing the temporary graph database 42 includes obtaining respective user identifiers 88D included in record metadata 88 of a plurality of records stored in the temporary database log data 80. Other portions of the temporary database log data 80, such as a plurality of timestamps 88A associated with the records, are also retrieved during the database audit in some embodiments. The one or more server processing devices 12 are further configured to output selected temporary database log data 80 for display in the graph database user interface 70. Thus, by performing a database audit of the temporary graph database 42, a user can determine whether previous usage of the temporary graph database 42 satisfies database usage policies, such as a data privacy policy or a database access permission policy.
[0034]
[0042] In embodiments in which the one or more server processing devices 12 are configured to evict the temporary graph database 42, the one or more server processing devices 12 are configured to remove the temporary graph database 42 from the one or more server memory devices 14 before the temporary graph database lifetime 56 expires. In embodiments in which the one or more server processing devices 12 are configured to extend the temporary graph database 42, the one or more server processing devices 12 are configured to increase the temporary graph database lifetime 56. Thus, in such embodiments, a user controls the caching period of the temporary graph database 42 via the temporary graph database modification input 74.
[0035]
[0043] In some embodiments, activities other than updating, auditing, pruning, or extending temporary graph database 42 may be indicated in instructions 76. For example, instructions 76 may indicate modifications to access control settings 59.
[0036]
[0044] 5 illustrates a schematic of the computing system 1 in one embodiment where a user previews a temporary graph database storage size 43 of the temporary graph database 42. Prior to generating the temporary graph database 42, the one or more server processing devices 12 are further configured to receive a storage size request 78 from the client computing device 20. The one or more server processing devices 12 are further configured to calculate the temporary graph database storage size 43 and communicate the temporary graph database storage size 43 to the client computing device 20 for display in a graph database user interface 70. The relational database storage size 33 is also sent to the client computing device 20 in some embodiments.
[0037]
[0045] 5 embodiment, the one or more server processing devices 12 are further configured to, in response to receiving the storage size request 78, calculate a persistent graph database storage size 73 that would be the size if the persistent graph database were generated with the same data selection 54 as the temporary graph database 42, but stored in the RDBMS 30 instead of in the BLOB storage 40. The one or more server processing devices 12 are further configured to send the persistent graph database storage size 73 to the client computing device 20 for display in the graph database user interface 70.
[0038]
[0046] In some embodiments, the storage size request 78 is received before the temporary graph database request 52. Thus, in such embodiments, the user may reference the temporary graph database storage size 43, the relational database storage size 33, and the persistent graph database storage size 73 when determining whether to instruct the server computing device 10 to generate a persistent copy of the temporary graph database 42 or the relational database 32.
[0039]
[0047] FIGURE 6 illustrates an exemplary graph database user interface 70 configured to be displayed on the display device 28 of the client computing device 20. The graph database user interface 70 illustrated in the example of FIGURE 6 includes an interface element configured to receive user input identifying one or more tables 34 shown in the data selection 54. In the example of FIGURE 6, a user has selected a first table 34A and a second table 34B. The one or more server processing devices 12 are configured to generate a temporary graph database 42 with the first table 34A and the second table 34B, as indicated by the highlighting of the two different types shown in the data selection 54.
[0040]
[0048] The graph database user interface 70 shown in Figure 6 further includes an interface element configured to receive a user selection of the temporary graph database lifetime 56. In the example of Figure 6, a user instructs the server computing device 10 to store the temporary graph database 42 in BLOB storage 40 for one month and 15 days. The graph database user interface 70 is configured to receive a specification of one or more queries 58 to be used in constructing the temporary graph database 42.
[0041]
[0049] 6 also displays the relational database storage size 33 and the temporary graph database storage size 43. In this example, the graph database user interface 70 further displays the persistent graph database storage size 73. The graph database user interface 70 further illustrates the reduction in storage size achieved by generating the temporary graph database 42 instead of a persistent graph database.
[0042]
[0050] The graph database user interface 70 shown in Figure 6 further includes an interface element configured to receive a user selection of access control settings 59. In the embodiment of Figure 6, a user may add or remove users as readers or maintainers of the temporary graph database 42 by interacting with the graph database user interface 70.
[0043]
[0051] 7 illustrates a flow chart of a method 100 for use with a server computing device, according to one embodiment. In the server computing device on which method 100 is executed, a relational database is stored in an RDBMS in one or more server memory devices of the server computing device. The relational database includes data organized into one or more tables. The steps of method 100 are performed on one or more server processing devices included in the server computing device.
[0044]
[0052] At step 102, the method 100 includes receiving a transient graph database request via a database API. The transient graph database request indicates a selection of data stored in a relational database for inclusion in the transient graph database. In some embodiments, the transient graph database request indicates a plurality of tables in the relational database for which a transient graph database is configured to be generated. The plurality of tables may include, for example, one or more first tables in the relational database configured to be used as nodes of a graph structure and one or more second tables in the relational database configured to be used as edges of the graph structure.
[0045]
[0053] The transient graph database request, in some embodiments, further includes one or more queries against the relational database. In embodiments in which the transient graph database request specifies one or more first tables and one or more second tables, the one or more queries may be queries against the one or more second tables.
[0046]
[0054] In some embodiments, the temporary graph database request further includes a temporary graph database lifetime indicating a period of time during which the one or more server memory devices are configured to retain the temporary graph database. Access control settings specifying access permissions of one or more users of the temporary graph database may also be included in the temporary graph database request in some embodiments.
[0047]
[0055] At step 104, the method 100 further includes generating a temporary graph database. The temporary graph database encodes the selected data into a graph structure indicated in the temporary graph database request. At step 106, the method 100 further includes storing the temporary graph database in a BLOB storage of one or more server memory devices. By storing the temporary graph database in a BLOB storage instead of an RDBMS, the storage size of the temporary graph database may be reduced. Additionally, by storing the temporary graph database in a BLOB storage, maintenance costs associated with database audits, RDBMS maintenance, and data quality errors are reduced in some embodiments. In such embodiments, not only initial costs but also running costs are reduced.
[0048]
[0056] At step 108, method 100 further includes receiving, via the database API, an instruction to apply a graph analysis algorithm to the temporary graph database. Exemplary types of graph analysis algorithms include nearest neighbor algorithms, centrality algorithms, min-cut algorithms, and clustering algorithms. Other types of graph analysis algorithms are implemented in other embodiments. At step 110, in response to receiving the instruction to apply the graph analysis algorithm, method 100 further includes retrieving the temporary graph database from the BLOB storage. When step 110 is performed, the temporary graph database is loaded into the working memory.
[0049]
[0057] At step 112, method 100 further includes applying a graph analysis algorithm to the temporary graph database to generate graph analysis results. Additionally, at step 114, method 100 further includes outputting the graph analysis results. In some embodiments, step 114 includes storing the graph analysis results in a relational database at step 116. Additionally or alternatively, step 114 may include outputting the graph analysis results to a client computing device for display in a graph database user interface.
[0050]
[0058] At step 118, the method 100 further includes deleting the temporary graph database from the BLOB storage. In some embodiments in which the temporary graph database request includes a temporary graph database lifetime, the temporary graph database is configured to be deleted from the BLOB storage in response to determining that the temporary graph database lifetime has elapsed. In other embodiments, the temporary graph database is deleted from the BLOB storage in response to outputting the graph analysis results. The temporary graph database is thus maintained for a specified period of time. By deleting the temporary graph database from the BLOB storage, costs associated with maintaining the temporary graph database may be avoided.
[0051]
[0059] FIG. 7B illustrates further steps of method 100 that are performed in some embodiments. As shown in FIG. 7B, method 100 further includes step 120 in some embodiments. In step 120, method 100 further includes receiving instructions to update, audit, prune, or extend the temporary graph database. These instructions are received via a database API. These instructions are received from a client computing device in some embodiments. In step 122, method 100 further includes updating, auditing, pruning, or extending the temporary graph database as indicated by the instructions. Thus, in response to the instructions, the temporary graph database is modified, the temporary database log data is retrieved, or the temporary graph database lifetime is modified. The instructions to update, audit, prune, or extend the temporary graph database are specified by a user in some embodiments, while in other embodiments, such instructions are programmatically output by some other computing process executing on the client computing device or the server computing device.
[0052]
[0060] 7C illustrates steps that, in some embodiments, are performed prior to generating the temporary graph database. At step 124, method 100 further includes receiving a storage size request from a client computing device. In some embodiments, the storage size request is received prior to receiving the temporary graph database request at step 102, while in other embodiments, the storage size request is included in the temporary graph database request.
[0053]
[0061] At step 126, the method 100 further includes calculating a temporary graph database storage size. At step 128, the method 100 further includes communicating the temporary graph database storage size to the client computing device. The relational database storage size of the relational database is also communicated to the client computing device in some embodiments. Additionally or alternatively, in some embodiments, in response to receiving the temporary graph database request, a size of a persistent graph database, which may be stored in an RDBMS, is calculated and communicated to the client computing device.
[0054]
[0062] 7D illustrates further steps of method 100 that are performed in some embodiments. At step 130, method 100 further includes generating temporary database log data including a temporary database creation record for generating the temporary graph database, an analysis record for running the graph analysis algorithm, and a temporary graph database deletion record for deleting the temporary graph database from the BLOB storage. Each of these records includes record metadata, such as a timestamp, an event type, an event identifier, and / or a user identifier. In some embodiments, records are also generated in response to types of events other than generating the temporary graph database, running the graph analysis algorithm, and deleting the temporary graph database.
[0055]
[0063] At step 132, the method 100 further includes storing the temporary database log data in one or more server memory devices. The stored temporary database log data is searchable during a database audit, during which the temporary database log data is transmitted to a client computing device.
[0056]
[0064] Using the above described devices and methods, graph analyses are performed on relational databases that do not have an explicit graph structure when stored in an RDBMS. These graph analyses are performed on temporary graph databases that are generated to be used as input to graph analysis algorithms. The temporary graph databases are stored in BLOB storage rather than in the RDBMS. After running the graph analysis algorithms, the temporary graph databases are deleted from the BLOB storage. The above described devices and methods reduce the amount of storage space used and the costs associated with database maintenance.
[0057]
[0065] In some embodiments, the methods and processes described herein are coupled to a computing system of one or more computing devices, and in some such embodiments, such methods and processes are implemented as computer application programs or services, application programming interfaces (APIs), libraries, and / or other computer program products.
[0058]
[0066] 8 illustrates generally one non-limiting embodiment of a computing system 200 that may implement one or more of the methods and processes described above. The computing system 200 is illustrated in simplified form. The computing system 200 may embody the computing system 1 described above and shown in FIG. 1. The components of the computing system 200 may be included within, for example, one or more personal computers, server computers, tablet computers, home entertainment computers, network computing devices, video game devices, mobile computing devices, mobile communication devices (e.g., smartphones), and / or other computing devices, as well as wearable computing devices, such as smart watches and head-mounted augmented reality devices.
[0059]
[0067] Computing system 200 includes a logical processor 202, a volatile memory 204, and a non-volatile storage device 206. Computing system 200 optionally includes a display subsystem 208, an input subsystem 210, a communication subsystem 212, and / or other components not shown in FIG.
[0060]
[0068] Logical processor 202 includes one or more physical devices configured to execute instructions. For example, logical processor 202 may be configured to execute instructions, which may be part of one or more applications, programs, routines, libraries, objects, components, data structures, or other logical constructs. Such instructions are implemented to perform a task, implement a data type, transform the state of one or more components, achieve a technical effect, or otherwise arrive at a desired result.
[0061]
[0069] Logical processor 202 includes one or more physical processors configured to execute software instructions. Additionally or alternatively, in some embodiments, logical processor 202 includes one or more hardware logic circuits or firmware devices configured to execute hardware-implemented logic or firmware instructions. The processors of logical processor 202 may be single-core or multi-core, and instructions executed by the processors may be configured for sequential, parallel, and / or distributed processing. Individual components of logical processor 202 may optionally be distributed across two or more separate devices, which in some embodiments are remotely located and / or configured for coordinated processing. In some embodiments, aspects of logical processor 202 are virtualized and executed by remotely accessible networked computing devices configured as a cloud computing configuration. In such cases, these virtualized aspects are executed on various physical logical processors of various different machines.
[0062]
[0070] Non-volatile storage device 206 includes one or more physical devices configured to hold instructions executable by a logical processor to implement the methods and processes described herein. When such methods and processes are implemented, the state of non-volatile storage device 206 may be transformed, for example, to hold various data.
[0063]
[0071] The non-volatile storage device 206 includes removable and / or built-in physical devices. The non-volatile storage device 206 may include optical, semiconductor, and / or magnetic memory, or other mass storage device technologies. The non-volatile storage device 206 may include non-volatile, dynamic, static, read / write, serial access, location addressable, file addressable, and / or content addressable devices. The non-volatile storage device 206 is configured to retain instructions even when power to the non-volatile storage device 206 is interrupted.
[0064]
[0072] Volatile memory 204 includes physical devices that include random access memory. Volatile memory 204 is typically utilized by logical processor 202 to temporarily store information during the processing of software instructions. It will be appreciated that volatile memory 204 is typically not configured to continue to store instructions when power to volatile memory 204 is interrupted.
[0065]
[0073] The logical processor 202, volatile memory 204, and non-volatile storage device 206 may, in some embodiments, be integrated together into one or more hardware logic components, examples of which include, for example, a field programmable gate array (FPGA), a program specific integrated circuit / application specific integrated circuit (PASIC / ASIC), a program specific standard product / application specific standard product (PSSP / ASSP), a system on a chip (SOC), and a complex programmable logic device (CPLD).
[0066]
[0074] The terms "module," "program," and "engine" are typically used to describe an aspect of the computing system 200 implemented in software by a processor to perform a particular function using portions of volatile memory, including transformation operations that specifically configure the processor to perform the function. Thus, a module, program, or engine may be instantiated via the logical processor 202 using portions of volatile memory 204 to execute instructions held by the non-volatile storage device 206. It will be understood that different modules, programs, and / or engines may be instantiated from the same application, service, code block, object, library, routine, API, function, etc. Similarly, the same module, program, and / or engine may be instantiated from different applications, services, code blocks, objects, routines, APIs, functions, etc. The terms "module," "program," and "engine" may encompass individual or groups of executable files, data files, libraries, drivers, scripts, database records, etc.
[0067]
[0075] In some embodiments, the display subsystem 208 can be used to present a visual representation of the data maintained by the non-volatile storage device 206. This visual representation may take the form of, for example, a graphical user interface (GUI). In such embodiments, as methods and processes described herein change the data maintained by the non-volatile storage device, thus transforming the state of the non-volatile storage device, and the state of the display subsystem 208 is likewise transformed to visually represent the changes in the underlying data. The display subsystem 208 includes one or more display devices utilizing virtually any type of technology. In some embodiments, such display devices are combined with the logic processor 202, the volatile memory 204, and / or the non-volatile storage device 206 in a shared enclosure. In other embodiments, such display devices are perimeter display devices.
[0068]
[0076] When included, input subsystem 210 includes or interacts with one or more user input devices, such as a keyboard, mouse, touch screen, camera, or microphone.
[0069]
[0077] When included, the communications subsystem 212 is configured to communicatively couple the various computing devices described herein with each other and with other devices. The communications subsystem 212 includes, for example, one or more wired and / or wireless communication devices compatible with one or more various communications protocols. By way of non-limiting examples, the communications subsystem is configured for communication over wired or wireless local or wide area networks, broadband cellular networks, and the like. In some embodiments, the communications subsystem enables the computing system 200 to send and / or receive messages to and from other devices over a network, such as the Internet.
[0070]
[0078] Furthermore, the present disclosure includes multiple configurations according to the following clauses.
[0071]
[0079] Article 1. 1. A server computing device comprising: one or more server memory devices having a relational database stored thereon; and one or more server processing devices, the one or more server processing devices configured to: receive, via a database application programming interface (API), a temporary graph database request indicating a selection of data stored in the relational database for inclusion in a temporary graph database; generate the temporary graph database, the temporary graph database encoding the selected data into a graph structure; store the temporary graph database in a binary large object (BLOB) storage of the one or more server memory devices; receive, via the database API, instructions to apply a graph analysis algorithm to the temporary graph database; in response to receiving the instructions to apply the graph analysis algorithm, read the temporary graph database from the BLOB storage; apply the graph analysis algorithm to the temporary graph database to generate a graph analysis result; output the graph analysis result; and delete the temporary graph database from the BLOB storage.
[0072]
[0080] Article 2. 2. The server computing device of claim 1, wherein the relational database is stored in a relational database management system (RDBMS) and the temporary graph database is not stored in the RDBMS.
[0073]
[0081] Article 3. 3. The server computing device of claim 1 or 2, wherein the temporary graph database request further includes a temporary graph database lifetime, and wherein the one or more server processing devices are further configured to delete the temporary graph database from the BLOB storage in response to determining that the temporary graph database lifetime has expired.
[0074]
[0082] Article 4. 4. The server computing device of any one of clauses 1 to 3, wherein the one or more server processing devices are configured to delete the temporary graph database from the BLOB storage in response to outputting the graph analysis results.
[0075]
[0083] Article 5. A server computing device as described in any one of clauses 1 to 4, wherein the temporary graph database includes one or more first tables contained in the relational database as nodes of the graph structure, and one or more second tables contained in the relational database as edges of the graph structure, and / or one or more queries against the one or more second tables.
[0076]
[0084] Article 6. 6. The server computing device of any one of clauses 1 to 5, wherein the one or more server processing devices are further configured to store the graph analysis results in the relational database.
[0077]
[0085] Article 7. 7. The server computing device of any one of clauses 1 to 6, wherein the one or more server processing devices are further configured to receive, via the database API, instructions to update, audit, prune, or extend the temporary graph database, and to update, audit, prune, or extend the temporary graph database as indicated by the instructions.
[0078]
[0086] Article 8. 8. The server computing device of any one of clauses 1 to 7, wherein a temporary graph database storage size of the temporary graph database is smaller than a relational database storage size of the relational database.
[0079]
[0087] Article 9. 9. The server computing device of claim 8, wherein the one or more server processing devices are further configured to: receive a storage size request from a client computing device, calculate the temporary graph database storage size, and communicate the temporary graph database storage size to the client computing device before generating the temporary graph database.
[0080]
[0088] Article 10. 10. The server computing device of any one of clauses 1 to 9, wherein the one or more server processing devices are further configured to: generate temporary database log data, the temporary database log data including a temporary database creation record of generating the temporary graph database, an analysis record of executing the graph analysis algorithm, and a temporary graph database deletion record of deleting the temporary graph database from the BLOB storage; and store the temporary database log data in the one or more server memory devices.
[0081]
[0089] Article 11. 11. A method for use with a server computing device, the method comprising: receiving, via a database application programming interface (API), a temporary graph database request, the temporary graph database request indicating a selection of data stored in a relational database for inclusion in a temporary graph database; generating the temporary graph database, the temporary graph database encoding the selected data into a graph structure; storing the temporary graph database in a binary large object (BLOB) storage of one or more server memory devices; receiving, via the database API, instructions to apply a graph analysis algorithm to the temporary graph database; in response to receiving the instructions to apply the graph analysis algorithm, reading the temporary graph database from the BLOB storage; applying the graph analysis algorithm to the temporary graph database to generate a graph analysis result; outputting the graph analysis result; and deleting the temporary graph database from the BLOB storage.
[0082]
[0090] Article 12. 12. The method of claim 11, wherein the temporary graph database request further includes a temporary graph database lifetime, and in response to determining that the temporary graph database lifetime has expired, the temporary graph database is deleted from the BLOB storage.
[0083]
[0091] Article 13. 13. The method of claim 11 or 12, wherein in response to outputting the graph analysis results, the temporary graph database is deleted from the BLOB storage.
[0084]
[0092] Article 14. 14. The method of any one of clauses 11 to 13, wherein the temporary graph database includes one or more first tables contained in the relational database as nodes of the graph structure, and one or more second tables contained in the relational database as edges of the graph structure, and / or one or more queries against the one or more second tables.
[0085]
[0093] Article 15. 15. The method of any one of clauses 11 to 14, further comprising storing the graph analysis results in the relational database.
[0086]
[0094] Article 16. 16. The method of any one of clauses 11 to 15, further comprising receiving, via the database API, an instruction to update, audit, prune, or extend the temporary graph database; and updating, auditing, pruning, or extending the temporary graph database as indicated by the instruction.
[0087]
[0095] Article 17. 17. The method of any one of clauses 11 to 16, wherein a temporary graph database storage size of the temporary graph database is smaller than a relational database storage size of the relational database.
[0088]
[0096] Article 18. 18. The method of claim 17, further comprising, prior to generating the temporary graph database, receiving a storage size request from a client computing device, calculating the temporary graph database storage size, and communicating the temporary graph database storage size to the client computing device.
[0089]
[0097] Article 19. 19. The method of any one of clauses 11 to 18, further comprising: generating temporary database log data, the temporary database log data including a temporary database creation record of generating the temporary graph database, an analysis record of running the graph analysis algorithm, and a temporary graph database deletion record of deleting the temporary graph database from the BLOB storage; and storing the temporary database log data in the one or more server memory devices.
[0090]
[0098] Article 20. 1. A computing system comprising: one or more memory devices that store a relational database in a relational database management system (RDBMS) and one or more processing devices, the one or more processing devices configured to: receive a temporary graph database request, the temporary graph database request indicating a selection of data stored in the relational database for inclusion in a temporary graph database; generate the temporary graph database, the temporary graph database encoding the selected data into a graph structure; store the temporary graph database in a binary large object (BLOB) storage of the one or more memory devices without storing the temporary graph database in the RDBMS; receive instructions to apply a graph analysis algorithm to the temporary graph database; in response to receiving the instructions to apply the graph analysis algorithm, read the temporary graph database from the BLOB storage; apply the graph analysis algorithm to the temporary graph database to generate a graph analysis result; output the graph analysis result; and delete the temporary graph database from the BLOB storage.
[0091]
[0099] As used herein, "and / or" is defined as inclusive or ∨ according to the following truth table: TIFF2025037815000002.tif34170
[0092]
[0100] It will be understood that the configurations and / or approaches described herein are exemplary in nature, and that these specific embodiments or examples should not be considered in a limiting sense, as numerous variations are possible. The specific routines or methods described herein represent one or more of any number of processing strategies. Thus, various operations illustrated and / or described may be performed in the order illustrated and / or described, in other orders, simultaneously, or omitted. Similarly, the order of the processes described above may be changed.
[0093]
[0101] The subject matter of the present disclosure includes all novel and non-obvious combinations and subcombinations of the various process, system, and configurations disclosed herein, as well as other features, functions, operations, and / or properties, and any and all equivalents thereof. [Explanation of symbols]
[0094] 1. Computing Systems 10 Server Computing Devices 12 Server Processing Device 14 Server Memory Devices 20 Client Computing Devices 22 Client Processing Device 24 Client Memory Device 26 User Input Devices 28 Display Devices 30 Relational Database Management Systems 32 Relational Databases 33 Relational Database Storage Size 34 table 34A First Table 34B Second Table 36 Data 36A First Data 36B Second Data 40 Binary Large Object Storage 42 Temporary Graph Databases 43 Temporary Graph Database Storage Size 44 Graph Structure 46 nodes 48 Edge 50 Database Application Programming Interface 52 Transient Graph Database Requests 54 Data Selection 56 Transient Graph Database Lifespan 58 Queries 59 Access Control Settings 60 instructions 62 Graph Analysis Algorithms 64 Graph Analysis Results 66 Deletion Order 70 Graph Database User Interfaces 72 Analysis Algorithm Selection 73 Persistent Graph Database Storage Size 74 Temporary graph correction input 76 Command 78 Storage Size Request 80 Temporary Graph Database Log Data 82 Temporary Database Creation Record 84 Analysis Record 86 Temporary Database Deletion Record 88 Recording Metadata 88A Timestamp 88B Event Type 88C Event Identifier 88D User Identifier 100 ways 102 Steps 104 Steps 106 Steps 108 Steps 110 Steps 112 Steps 114 Steps 116 Steps 118 Steps 120 steps 122 Steps 124 Steps 126 Steps 128 steps 130 Steps 132 Steps 200 Computing Systems 202 logical processors 204 Volatile Memory 206 Non-volatile Storage Devices 208 Display Subsystem 210 Input Subsystem 212 Communication Subsystem
Claims
1. one or more server memory devices (14) having a relational database (32) stored thereon; A server computing device (10) comprising one or more server processing devices (12), the one or more server processing devices: receiving a temporary graph database request (52) via a database application programming interface (API) (50), the temporary graph database request indicating a selection (54) of data (36) stored in the relational database for inclusion in a temporary graph database (42); generating the temporary graph database, the temporary graph database encoding the selected data into a graph structure (44); storing said temporary graph database in a binary large object (BLOB) storage (40) of said one or more server memory devices; receiving, via the database API, instructions (60) for applying a graph analysis algorithm (62) to the temporary graph database; retrieving the temporary graph database from the BLOB storage in response to receiving the instruction to apply the graph analysis algorithm; applying said graph analysis algorithm to said temporary graph database to generate graph analysis results (64); outputting the graph analysis results; and and deleting the temporary graph database from the BLOB storage.
2. The relational database is stored in a relational database management system (RDBMS) (30); The server computing device of claim 1 , wherein the temporary graph database is not stored in the RDBMS.
3. the temporary graph database request further includes a temporary graph database lifetime (56); 2. The server computing device of claim 1, wherein the one or more server processing devices are further configured to delete the temporary graph database from the BLOB storage in response to determining that the temporary graph database lifetime has expired.
4. 2. The server computing device of claim 1, wherein the one or more server processing devices are configured to delete the temporary graph database from the BLOB storage in response to outputting the graph analysis results.
5. The temporary graph database comprises: one or more first tables (34A) contained in the relational database as nodes (46) of the graph structure; and As edges (48) of the graph structure, one or more second tables (34B) contained in said relational database; and / or The server computing device of claim 1 further comprising one or more queries (58) against the one or more second tables.
6. The server computing device of claim 1 , wherein the one or more server processing devices are further configured to store the graph analysis results in the relational database.
7. the one or more server processing devices, receiving instructions (76) via the database API to update, audit, prune, or extend the temporary graph database; The server computing device of claim 1 , further configured to update, audit, prune, or extend the temporary graph database as indicated by the instructions.
8. The server computing device of claim 1 , wherein a temporary graph database storage size (43) of the temporary graph database is smaller than a relational database storage size (33) of the relational database.
9. The one or more server processing devices, prior to generating the temporary graph database, receiving a storage size request (78) from a client computing device (20); Calculating the temporary graph database storage size; The server computing device of claim 8 , further configured to communicate the temporary graph database storage size to the client computing device.
10. the one or more server processing devices, a temporary database creation record (82) of the creation of said temporary graph database; an analysis record (84) of the execution of the graph analysis algorithm; and a temporary graph database deletion record (86) of deleting the temporary graph database from the BLOB storage; generating temporary database log data (80); and The server computing device of claim 1 , further configured to: store the temporary database log data in the one or more server memory devices.
11. A method (100) for use with a server computing device, comprising: receiving (102) a transient graph database request via a database application programming interface (API), the transient graph database request indicating a selection of data stored in a relational database for inclusion in the transient graph database; generating the temporary graph database (104), the temporary graph database encoding the selected data into a graph structure; storing (106) the temporary graph database in a binary large object (BLOB) storage of one or more server memory devices; receiving (108) instructions via the database API to apply a graph analysis algorithm to the temporary graph database; retrieving (110) the temporary graph database from the BLOB storage in response to receiving the instruction to apply the graph analysis algorithm; applying (112) the graph analysis algorithm to the temporary graph database to generate graph analysis results; Outputting the graphical analysis results (114); and deleting (118) the temporary graph database from the BLOB storage.
12. the temporary graph database request further comprises a temporary graph database lifetime; The method of claim 11 , wherein in response to determining that the temporary graph database lifetime has expired, the temporary graph database is deleted from the BLOB storage.
13. The method of claim 11 , wherein in response to outputting the graph analysis results, the temporary graph database is deleted from the BLOB storage.
14. The temporary graph database comprises: one or more first tables included in the relational database as nodes of the graph structure; and As edges of the graph structure, one or more second tables contained in the relational database; and / or The method of claim 11 , further comprising one or more queries against the one or more second tables.
15. The method of claim 11 , further comprising storing the graph analysis results in the relational database.
16. receiving (120) instructions via the database API to update, audit, prune, or extend the temporary graph database; and 12. The method of claim 11, further comprising updating, auditing, pruning, or extending the temporary graph database (122) as indicated by the instructions.
17. The method of claim 11 , wherein a temporary graph database storage size of the temporary graph database is smaller than a relational database storage size of the relational database.
18. Prior to generating the temporary graph database, receiving a storage size request from a client computing device (124); Calculating the temporary graph database storage size (126); and 20. The method of claim 17, further comprising communicating (128) the temporary graph database storage size to the client computing device.
19. a temporary database creation record of generating the temporary graph database; an analysis record of the execution of the graph analysis algorithm; and A temporary graph database deletion record indicating that the temporary graph database was deleted from the BLOB storage. generating (130) temporary database log data, The method of claim 11 , further comprising storing (132) the temporary database log data in the one or more server memory devices.
20. one or more memory devices (14) for storing a relational database (32) in a relational database management system (RDBMS) (30); A computing system (1) comprising one or more processing devices (12), the one or more processing devices: receiving a temporary graph database request (52), the temporary graph database request indicating a selection (54) of data (36) stored in the relational database for inclusion in a temporary graph database (42); generating the temporary graph database, the temporary graph database encoding the selected data into a graph structure (44); storing the temporary graph database in a binary large object (BLOB) storage (40) of the one or more memory devices without storing the temporary graph database in the RDBMS; receiving instructions (60) for applying a graph analysis algorithm (62) to said temporary graph database; retrieving the temporary graph database from the BLOB storage in response to receiving the instruction to apply the graph analysis algorithm; applying said graph analysis algorithm to said temporary graph database to generate graph analysis results (64); outputting the graph analysis results; and deleting the temporary graph database from the BLOB storage.