Temporary graphics database
By using a temporary graph database in a relational database and storing it in a BLOB storage device, the problem of waste of storage space and high maintenance costs during graph data analysis in a relational database is solved, and more efficient graph analysis is achieved and cost reduction is reduced.
Patent Information
- Application Number
- CN202411148784.2
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Priority Date
- 2023-08-28
- Filing Date
- 2024-08-21
- Publication Date
- 2025-02-28
AI Technical Summary
When performing graphical data analysis in relational databases, prior art requires copying data and storing it in a persistent storage device, resulting in waste of storage space and increased maintenance costs.
It is proposed to use a temporary graph database, which is stored in a binary large object (BLOB) storage device, rather than a relational database management system (RDBMS). The temporary graph database only exists when the graph analysis algorithm is running and deleted after the analysis is completed.
By reducing data copies stored in RDBMS, storage space requirements and maintenance costs are reduced, while improving the efficiency of graphical analysis.
Smart Images
Figure HDA0005003004860000011 
Figure HDA0005003004860000021 
Figure HDA0005003004860000031
Abstract
Description
Technical Field
[0001] The present application relates generally to database management, and more particularly to computing graphical analysis results from data stored in a database. Background Art
[0002] A relational database is a type of database in which data elements that are related to each other are stored in a way that reflects the relationship between the data elements. A database that organizes data elements into rows and columns is an example of a relational database. More complex relationships between data elements and their collections can also be expressed using a relational database.
[0003] A relational database can be represented as having a graph structure. In such a graph structure, data elements or sets of data elements are represented as nodes of the graph, and the relationships between these elements or sets are represented as edges of the graph. When a relational database is represented using a graph structure, analysis can be performed on the relational database using techniques from graph theory. Thus, users can extract insights related to the graph structure of the relationships between data elements. Summary of the invention
[0004] According to one aspect of the present disclosure, a server computing device is provided, including one or more server memory devices storing a relational database. The server computing device also 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 also configured to generate a temporary graph database. The temporary graph database encodes the selected data into a graph structure. The one or more server processing devices are also configured to store the temporary graph database in a binary large object (BLOB) storage device at the one or more server memory devices. The one or more server processing devices are also configured to receive an instruction to apply a graph analysis algorithm at the temporary graph database via the database API, and in response to receiving the instruction to apply the graph analysis algorithm, read the temporary graph database from the BLOB storage device. The one or more server processing devices are also 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 also configured to output the graph analysis result. The one or more server processing devices are also configured to delete the temporary graph database from the BLOB storage device. BRIEF DESCRIPTION OF THE DRAWINGS
[0005] Figure 1 A computing system including a server computing device and a client computing device is schematically illustrated when generating a temporary graph database and applying a graph analysis algorithm according to an example embodiment.
[0006] Figure 2 Schematically shows the Figure 1 In an example, a server computing device when one or more server processing devices included in the server computing device receive a temporary graph database request.
[0007] Figure 3 Schematically shows the Figure 1 Examples of additional details of the server computing device when generating and storing temporary database log data.
[0008] Figure 4 Schematically shows the Figure 1 An example of a computing system when a graphical database user interface is executed at one or more client processing devices included in a client computing device.
[0009] Figure 5 Schematically shows the Figure 1 An example of a computing system when requesting and displaying a temporary graph database storage size at a client computing device.
[0010] Figure 6 Shown according to Figure 1 An example graphical database user interface configured to be displayed at a display device of a client computing device.
[0011] Fig. 7A Shown according to Figure 1 An example of a flow chart of a method for use with a server computing device to generate a temporary graph database and execute a graph analysis algorithm.
[0012] Figure 7B-7D In some examples, the Fig. 7A Additional steps of the method.
[0013] Figure 8 Schematically shows the Figure 1 An example of a computing environment in which a computing system is instantiated. DETAILED DESCRIPTION
[0014] In existing relational database management systems (RDBMS), performing graph analytics on a stored database includes replicating the data stored in the relational database. While the graph analytics are being performed, this replicated data is stored in a persistent storage device. However, storing the replicated data in a persistent storage device often requires a large amount of storage space while the graph analytics are being performed. Furthermore, in examples where the graph analytics are being performed repeatedly, storing the replicated data in a persistent storage device often incurs additional costs associated with maintaining and updating copies of the database. When a relational database is replicated, the frequency of data quality errors also increases, as does the cost associated with correcting these errors.
[0015] To address the above challenges when performing graph data analysis on a relational database, a temporary graph database is provided. The temporary graph database is stored for a limited duration and is stored in a binary large object (BLOB) storage device rather than in 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 executing a graph analysis algorithm and delete the temporary graph database once the graph analysis algorithm has completed running.
[0016] Figure 1 A computing system 1 according to an example embodiment is schematically shown, which includes a server computing device 10 and a client computing device 20. Figure 1 As depicted in the example of , 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 includes, 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 include, for example, one or more volatile memory devices and one or more non-volatile memory devices.
[0017] In some examples, one or more server processing devices 12 and one or more server memory devices 14 are included in one or more components that combine processor and memory functionality, such as a system on a chip (SoC). Additionally or alternatively, in some examples, one or more server processing devices 12 and one or more server memory devices 14 are distributed across multiple physical computing systems, such as multiple networked computing devices located in a data center.
[0018] like Figure 1As depicted in the example of , 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. In addition, the client computing device 20 includes one or more user input devices 26 and one or more display devices 28. The client computing device 20 may include an example user input device 26, such as a keyboard, a mouse, a touch screen, a microphone, an inertial measurement unit (IMU), and / or a camera. In some examples, in addition to one or more display devices 28, the client computing device also includes one or more other output devices, such as a speaker or a tactile feedback device. The client computing device 20 is configured to communicate with the server computing device 10.
[0019] like Figure 1 As depicted in the example of , one or more server memory devices 14 store a relational database 32 at the RDBMS 30. The relational database 32 includes one or more tables 34, each table 34 including corresponding data 36 provided as one or more data elements. The server computing device 10 is configured to store the relational database 32 in a persistent memory.
[0020] The one or more server processing devices 12 are configured to execute a database application programming interface (API) 50. Via the database API 50, the RDBMS 30 is configured to interact with other computing processes executing at the one or more server processing devices 12. In addition, the client computing devices 20 are configured to interact with the RDBMS 30 using the database API 50.
[0021] Via the database API 50, one or more server processing devices 12 are configured to receive a temporary graph database request 52. As discussed in further detail below, the temporary graph database request 52 is a request to generate a temporary graph database 42. The temporary graph database request 52 includes a data selection 54, which is a selection of data 36 stored in the relational database 32 for inclusion in the temporary graph database 42. In some examples, the data selection 54 indicates all of the data 36 included in the relational database 32, while in other examples, the data selection 54 indicates only a subset of the data 36, such as data included in a subset of the plurality of tables 34.
[0022] In some examples, such as Figure 1As shown, the temporary graph database request 52 also includes a temporary graph database lifetime 56. The temporary graph database lifetime 56 specifies the duration that the server computing device 10 is configured to store the temporary graph database 42 in one or more server memory devices 14. In some examples, such as Figure 1 As shown, the temporary graph database request 52 also includes an access control setting 59 that specifies one or more users who are authorized to access the temporary graph database 42. In some examples, different role-based permissions are indicated in the access control setting 59, such as instructions to grant one or more users a reader role and grant one or more other users a maintainer role.
[0023] exist Figure 1 In the example of , the temporary graph database request 52 is received from the client computing device 20. In other examples, the database API 50 receives the temporary graph database request 52 originating from a computing process executed at the server computing device 10.
[0024] The one or more server processing devices 12 are also configured to generate a temporary graph database 42. The temporary graph database 42 encodes the selected data 36 into a graph structure 44 including a plurality of nodes 46 and edges 48. In some examples, the graph structure 44 is a directed graph structure in which the edges 48 have respective directions. In other examples, the graph structure 44 is a weighted graph structure in which the edges 48 have respective weights. In other examples, the graph structure 44 is a directed weighted graph structure. The weights and / or directions of the edges 48 can be calculated based on the selected data 36 used to generate the temporary graph database 42. In other examples, the graph structure 44 is an undirected unweighted graph structure.
[0025] Figure 2 The schematic diagram shows additional details of the server computing device 10 when receiving the temporary graph database request 52. In the temporary graph database request 52, according to Figure 2 In the example of , data selection 54 specifies one or more first tables 34A and one or more second tables 34B included in relational database 32. One or more first tables 34A store first data 36A, and one or more second tables 34B store second data 36B. In some examples, the set of one or more first tables 34A overlaps with the set of one or more second tables 34B.
[0026] exist Figure 2In an example of , 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 also configured to use the one or more second tables 34B or one or more queries 58 on the one or more second tables 34B as edges 48 of the graph structure 44. The one or more queries 58 on the one or more second tables 34B are queries to the relational database 32 and are also included in the temporary graph database request 52. Therefore, in such examples, the temporary graph database request 52 uses the one or more queries 58 to specify the structure of the temporary graph database 42 in a manner that allows for specifying relationships that are not explicitly encoded in the tables 34 included in the relational database 32. In some examples, 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 can be calculated based on the second data 36B stored in the one or more second tables 34B.
[0027] The one or more server processing devices 12 are also configured to store a temporary graph database 42 in the BLOB storage 40 at the one or more memory devices 14 . Figure 2 The one or more server memory devices 14 are schematically illustrated when the relational database 32 is stored at the RDBMS 30 and the temporary graph database 42 is stored at 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 instead of the RDBMS 30, the one or more server processing devices 12 store the temporary graph database in a manner in which the temporary graph database storage size 43 of the temporary graph database 22 is smaller than the relational database storage size 33 of the relational database 32.
[0028] return Figure 1 In the example of FIG. 4 , after storing the temporary graph database 42 in the BLOB storage device 40, the one or more server processing devices 12 are also configured to receive instructions 60 via the database API 50 to apply a graph analysis algorithm 62 at the temporary graph database 42. For example, the graph analysis algorithm 62 can be a nearest neighbor algorithm, a centrality algorithm, a minimum cut algorithm, a clustering algorithm, or some other algorithm that utilizes the graph structure 44 as an input.
[0029] In response to receiving the instruction 60 to apply the graph analysis algorithm 62, the one or more server processing devices 12 are also configured to read the temporary graph database 42 from the BLOB storage device 40. The temporary graph database 42 is read from the non-volatile memory into the working memory. The one or more server processing devices 12 are also configured to apply the graph analysis algorithm 62 to the temporary graph database 42 to generate a graph analysis result 64 as an output of the graph analysis algorithm 62.
[0030] The one or more server processing devices 12 are further configured to output the graph analysis results 64. In some examples, the graph analysis results 64 are output to the client computing device 20. Thus, the graph analysis results 64 are available for output to a user. Additionally or alternatively, in some examples, the one or more server processing devices 12 are further configured to store the graph analysis results 64 in the relational database 32, such as Figure 2 Thus, in such examples, the graph analysis results 64 may be used for querying and as input to additional analysis processes. In some examples, temporary graph database generation is performed iteratively in a manner that combines graph analysis results 64 computed from previous iterations of the temporary graph database 42.
[0031] The one or more server processing devices 12 are also configured to delete the temporary graph database 42 from the BLOB storage 40. In some examples, 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 examples where the temporary graph database request includes the 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 examples, the temporary graph database 22 is deleted in response to some other event, such as receiving an instruction to evict the temporary graph database 42 received before the end of the temporary graph database lifetime 56.
[0032] Figure 2 Also shown is temporary database log data 80 stored at one or more server memory devices 14. The temporary database log data 80 is organized into a plurality 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 registered event. In some examples, other types of record metadata 88 may also be included in the temporary database log data 80.
[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 at the one or more server memory devices 14 . Figure 3 Schematically illustrates additional details of the server computing device 10 when generating and storing temporary database log data 80. Figure 3 As shown, the temporary database log data 80 includes a temporary database creation record 82 that generates the temporary graph database 42. The temporary database creation record 82 indicates the inputs and parameters used to generate the temporary graph database 42, as specified in the temporary graph database request 52.
[0034] In addition, the temporary database log data 80 also includes an analysis record 84 for executing the graph analysis algorithm 62. The analysis record 84 specifies the graph analysis algorithm 62 indicated in the instructions 60, and the inputs and parameters used to apply the graph analysis algorithm 60 to the temporary graph database 42. The temporary database log data 80 also includes a temporary database deletion record 86 for deleting the temporary graph database 42 from the BLOB storage device 40.
[0035] Figure 4 Schematically, additional details of the computing system 1 are shown when a graphical database user interface 70 is executed at one or more client processing devices 22 included in the client computing device 20. The graphical database user interface 70 is displayed on the display device 28 and is configured to receive user interactions via one or more user input devices 26. The graphical database user interface 70 is configured to exchange data with the graphical database API 50 executed at the server computing device 10.
[0036] exist Figure 4 In the example of FIG. 4 , a user enters a temporary graphical database request 52 at a graphical database user interface 70 , including data selection, temporary graphical database lifetime 56 , and query 58 . In some examples, other inputs and / or parameters used in generating the temporary graphical database 42 are also entered at the graphical database user interface 70 .
[0037] The one or more client processing devices 22 are also configured to receive an analysis algorithm selection 72 from a user via the graphical database user interface 70 to select the graphical analysis algorithm 62, and the one or more server processing devices 12 are configured to execute the graphical analysis algorithm 62. Thus, the instructions 60 to apply the graphical analysis algorithm 62 are generated based at least in part on the analysis algorithm selection 72 entered at the graphical database user interface 70. Figure 4 In the example of , the graph analysis results 64 are also displayed at the graph database user interface 70. Thus, the output of the requested graph analysis algorithm 62 is presented to the user.
[0038] exist Figure 4 In the example of FIG. 4 , the one or more client processing devices 22 are further configured to receive temporary graph modification input 74 input by a user at the graph database user interface 70. Based at least in part on the temporary graph modification input 74, the one or more client processing devices 22 are further configured to generate instructions 76 for updating, auditing, evicting, or extending the temporary graph database 42. These instructions 76 are then transmitted to the server computing device 10.
[0039] The one or more server processing devices 12 are further configured to receive instructions 76 via the database API 50 to update, audit, evict or extend the temporary graph database 42. The one or more server processing devices 12 are further configured to update, audit, evict or extend the temporary graph database 42 as directed by the instructions 76.
[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 examples, such modifications are to the topology of the graph structure 44. Such modifications include, for example, adding or removing one or more nodes 46 and / or adding or removing one or more edges 48. In some examples, the one or more server processing devices 12 additionally or alternatively modify the data 36 stored at the nodes 46 and / or edges 48.
[0041] In some examples, when executing instructions 76, one or more server processing devices 12 are also 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 examples, auditing the temporary graph database 42 includes obtaining corresponding user identifiers 88D included in record metadata 88 of multiple records stored in the temporary database log data 80. In some examples, other portions of the temporary database log data 80 are also retrieved during the database audit, such as multiple timestamps 88A associated with the records. The one or more server processing devices 12 are also configured to output selected temporary database log data 80 for display at the graph database user interface 70. Thus, performing a database audit of the temporary graph database 42 allows a user to determine whether previous use of the temporary graph database 42 satisfies a data usage policy, such as a data privacy policy or a database access permission policy.
[0042] In examples where 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 delete the temporary graph database 42 from the one or more server memory devices 14 before the temporary graph database lifetime 56 has elapsed. In examples where 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 examples, the user controls the cache duration of the temporary graph database 42 via the temporary graph modification input 74.
[0043] In some examples, actions other than updating, auditing, evicting, or expanding temporary graph database 42 may be indicated in instructions 76. For example, instructions 76 may indicate a modification of access control settings 59.
[0044] Figure 5 The computing system 1 in the example is schematically illustrated, wherein a user previews a temporary graph database storage size 43 of a 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 transmit the temporary graph database storage size 43 to the client computing device 20 for display at the graph database user interface 70. In some examples, the relational database storage size 33 is also transmitted to the client computing device 20.
[0045] exist Figure 5 In the example of , the one or more server processing devices 12 are further configured to calculate the persistent graph database storage size 73 in response to receiving the storage size request 78. The persistent graph database storage size 73 is the size that the persistent graph database would have if it were generated using the same data selection 54 as the temporary graph database 42, but stored in the RDBMS 30 instead of the BLOB storage 40. The one or more server processing devices 12 are further configured to transmit the persistent graph database storage size 73 to the client computing device 20 for display at the graph database user interface 70.
[0046] In some examples, the storage size request 78 is received before the temporary graph database request 52. Thus, in such examples, the user may refer to 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 command the server computing device 10 to generate a persistent copy of the temporary graph database 42 or the relational database 32.
[0047] Figure 6 An example graphical database user interface 70 configured for display at the display device 28 of the client computing device 20 is shown. Figure 6 The graphical database user interface 70 shown in the example of FIG. 5 includes interface elements configured to receive user input specifying one or more tables 34 indicated in the data selection 54. Figure 6 In the example of FIG. 5 , the user has selected the first table 34A and the second table 34B, and the one or more server processing devices 12 are configured to generate the temporary graphical database 42 using these two tables, as indicated by the two different types of highlighting shown in the data selection 54 .
[0048] Figure 6 The graphical database user interface 70 depicted in FIG. 5 also includes an interface element configured to receive a user selection of the temporary graphical database lifecycle 56. Figure 6 In the example of FIG. 4 , the user instructs the server computing device 10 to store the temporary graph database 42 in the BLOB storage 40 for one month and 15 days. The graph database user interface 70 also includes an interface element configured to receive specifications of one or more queries 58 used in building the temporary graph database 42 .
[0049] Figure 6 The illustrated graphical database user interface 70 also displays the relational database storage size 33 and the temporary graphical database storage size 43. In this example, the graphical database user interface 70 also displays the persistent graphical database storage size 73. The graphical database user interface 70 also illustrates the storage size reduction achieved by generating a temporary graphical database 42 instead of a persistent graphical database.
[0050] Figure 6 The illustrated graphical database user interface 70 also includes an interface element configured to receive a user selection of an access control setting 59. Figure 6 In the example of FIG. 4 , a user may add or remove users as readers or maintainers of the temporary graphical database 42 by interacting with the graphical database user interface 70 .
[0051] Fig. 7A A flow chart of a method 100 for use with a server computing device according to one example is shown. At a server computing device used to perform the method 100, a relational database is stored at 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 the method 100 are performed at one or more server processing devices included in the server computing device.
[0052] At step 102, method 100 includes receiving a temporary graph database request via a database API. The temporary graph database request indicates a selection of data stored in a relational database for inclusion in the temporary graph database. In some examples, the temporary graph database request indicates a plurality of tables included in the relational database, and the temporary graph database is configured to be generated using these tables. The plurality of tables include, for example, one or more first tables included in the relational database configured to be used as nodes of a graph structure, and one or more second tables included in the relational database configured to be used as edges of the graph structure.
[0053] In some examples, the temporary graph database request also includes one or more queries to the relational database. In examples where the temporary graph database request specifies one or more first tables and one or more second tables, the one or more queries may be queries on the one or more second tables.
[0054] In some examples, the temporary graph database request also includes a temporary graph database lifetime. The temporary graph database lifetime indicates a duration for which the one or more server memory devices are configured to retain the temporary graph database. In some examples, access control settings that specify access rights for one or more users of the temporary graph database may also be included in the temporary graph database request.
[0055] At step 104, method 100 also 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, method 100 also includes storing the temporary graph database in a BLOB storage device at one or more server memory devices. Storing the temporary graph database in the BLOB storage device rather than in the RDBMS allows for a reduced storage size of the temporary graph database. Additionally, in some examples, by storing the temporary graph database in the BLOB storage device, maintenance costs associated with database audits, RDBMS maintenance, and data quality errors are reduced. Thus, in such examples, both ongoing costs and upfront costs are reduced.
[0056] At step 108, method 100 also includes receiving, via the database API, an instruction to apply a graph analysis algorithm at the temporary graph database. Example types of graph analysis algorithms include nearest neighbor algorithms, centrality algorithms, minimum cut algorithms, and clustering algorithms. Other types of graph analysis algorithms are performed in other examples. At step 110, in response to receiving the instruction to apply the graph analysis algorithm, method 100 also includes reading the temporary graph database from the BLOB storage device. When step 110 is performed, the temporary graph database is read into the working memory.
[0057] At step 112, method 100 also includes applying the graph analysis algorithm to the temporary graph database to generate a graph analysis result. In addition, at step 114, method 100 also includes outputting the graph analysis result. In some examples, step 114 includes storing the graph analysis result in a relational database at step 116. Additionally or alternatively, step 114 may include outputting the graph analysis result to a client computing device for display at a graph database user interface.
[0058] At step 118, method 100 further includes deleting the temporary graph database from the BLOB storage. In examples where the temporary graph database request includes a temporary graph 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 examples, the temporary graph database is deleted from the BLOB storage in response to outputting the graph analysis result. Thus, the temporary graph database is 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 are avoided.
[0059] Figure 7B Additional steps of method 100 that may be performed in some examples are shown. Figure 7B As shown, in some examples, method 100 also includes step 120. In step 120, method 100 also includes receiving instructions to update, audit, evict, or expand the temporary graph database. These instructions are received via a database API. In some examples, these instructions are received from a client computing device. In step 122, method 100 also includes updating, auditing, evicting, or expanding the temporary graph database as indicated by the instructions. Therefore, in response to the instructions, the temporary graph database is modified, temporary database log data is retrieved, or the temporary graph database lifecycle is modified. In some examples, the instructions to update, audit, evict, or expand the temporary graph database are user-specified, while in other examples, such instructions are programmatically output by some other computing process executed at the client computing device or the server computing device.
[0060] Figure 7C Steps performed in some examples before generating a temporary graph database are shown. At step 124, method 100 also includes receiving a storage size request from the client computing device. In some examples, the storage size request is received before the temporary graph database request is received at step 102, while in other examples, the storage size request is included in the temporary graph database request.
[0061] At step 126, method 100 also includes calculating a temporary graph database storage size. At step 128, method 100 also includes transmitting the temporary graph database storage size to the client computing device. In some examples, a relational database storage size of the relational database is also transmitted to the client computing device. Additionally or alternatively, in some examples, in response to receiving the temporary graph database request, a size of the persistent graph database to be stored in the RDBMS is calculated and transmitted to the client computing device.
[0062] Fig.7D Additional steps of method 100 performed in some examples are shown. At step 130, method 100 also includes generating temporary database log data, which includes a temporary database creation record for generating a temporary graph database, an analysis record for executing the graph analysis algorithm, and a temporary database deletion record for deleting the temporary graph database from the BLOB storage device. Each of these records includes record metadata, such as a timestamp, an event type, an event identifier, and / or a user identifier. In some examples, records are also generated in response to event types other than creating a temporary database, executing a graph analysis algorithm, and deleting a temporary graph database.
[0063] At step 132, method 100 further includes storing the temporary database log data at one or more server memory devices. The stored temporary database log data is retrievable during a database audit, during which the temporary database log data is transmitted to a client computing device.
[0064] Using the apparatus and methods discussed above, graph analytics are performed at a relational database that does not have an explicit graph structure when stored in an RDBMS. These graph analytics are performed on a temporary graph database that is generated to be used as an input to the graph analytics algorithms. The temporary graph database is stored in a BLOB storage device, rather than in the RDBMS. After the graph analytics algorithms are executed, the temporary graph database is deleted from the BLOB storage device. The above apparatus and methods reduce the amount of storage space used and the costs associated with database maintenance.
[0065] In some embodiments, the methods and processes described herein are linked to a computing system of one or more computing devices. In such examples, such methods and processes are implemented as computer applications or services, application programming interfaces (APIs), libraries, and / or other computer program products.
[0066] Figure 8 A non-limiting embodiment of a computing system 200 that can perform one or more of the above methods and processes is schematically shown. The computing system 200 is shown in simplified form. The computing system 200 can embody the above description and in Figure 1Components of computing system 200 are included, for example, in the form of one or more personal computers, server computers, tablet computers, home entertainment computers, network computing devices, video gaming devices, mobile computing devices, mobile communication devices (e.g., smart phones), and / or other computing devices, as well as wearable computing devices (such as smart watches and head-mounted augmented reality devices).
[0067] The computing system 200 includes a logic processor 202, a volatile memory 204, and a non-volatile storage device 206. The computing system 200 may optionally include a display subsystem 208, an input subsystem 210, a communication subsystem 212, and / or Figure 8 Other components not shown.
[0068] Logical processor 202 includes one or more physical devices configured to execute instructions. For example, logical processor 202 is configured to execute instructions that are 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 achieve a desired result.
[0069] The logical processor 202 includes one or more physical processors configured to execute software instructions. Additionally or alternatively, in some examples, the logical processor 202 includes one or more hardware logic circuits or firmware devices configured to execute hardware-implemented logic or firmware instructions. The processor of the logical processor 202 is a single core or multi-core, and the instructions executed thereon can be configured for sequential, parallel and / or distributed processing. The individual components of the logical processor 202 are optionally distributed in two or more separate devices, which in some examples are remotely located and / or configured for coordinated processing. In some examples, various aspects of the logical processor 202 are virtualized and executed by a remotely accessible networked computing device configured in a cloud computing configuration. In such a case, these virtualized aspects run on different physical logical processors of various different machines.
[0070] The non-volatile storage device 206 includes one or more physical devices configured to store instructions executable by a logical processor to implement the methods and processes described herein. When implementing such methods and processes, the state of the non-volatile storage device 206 is transformed—for example, to store different data.
[0071] The non-volatile storage device 206 includes a removable and / or built-in physical device. The non-volatile storage device 206 may include optical memory, semiconductor memory, and / or magnetic memory or other mass storage device technology. The non-volatile storage device 206 may include a non-volatile, dynamic, static, read / write, read-only, sequential access, location addressable, file addressable, and / or content addressable device. It should be understood that the non-volatile storage device 206 is configured to save instructions even when the power to the non-volatile storage device 206 is cut off.
[0072] Volatile memory 204 includes physical devices that contain random access memory. Volatile memory 204 is typically used by logical processor 202 to temporarily store information during the processing of software instructions. It should be understood that when power to volatile memory 204 is cut off, volatile memory 204 typically does not continue to store instructions.
[0073] In some examples, aspects of logic processor 202, volatile memory 204, and non-volatile storage 206 are integrated together into one or more hardware logic components. Examples of such hardware logic components include, for example, field programmable gate arrays (FPGAs), program-specific and application-specific integrated circuits (PASIC / ASICs), program-specific and application-specific standard products (PSSP / ASSPs), systems on chips (SOCs), and complex programmable logic devices (CPLDs).
[0074] The terms "module", "program", and "engine" are used to describe aspects of the computing system 200 that are typically implemented in software by a processor to use portions of volatile memory to perform a specific function that involves a transformation process that specifically configures the processor to perform the function. Therefore, a module, program, or engine can be instantiated using portions of volatile memory 204, via the logical processor 202 executing instructions stored by the non-volatile storage device 206. It should be understood that different modules, programs, and / or engines can be instantiated from the same application, service, code block, object, library, routine, API, function, etc. Similarly, different applications, services, code blocks, objects, routines, APIs, functions, etc. can instantiate the same module, program, and / or engine. The terms "module", "program", and "engine" can cover individual or grouped executable files, data files, libraries, drivers, scripts, database records, etc.
[0075] In some examples, the display subsystem 208 is used to present a visual representation of the data stored by the non-volatile storage device 206. For example, the visual representation takes the form of a graphical user interface (GUI). In such examples, when the methods and processes described herein change the data stored by the non-volatile storage device and thus transform the state of the non-volatile storage device, the state of the display subsystem 208 is also transformed to visually represent the change of the underlying data. The display subsystem 208 includes one or more display devices using virtually any type of display technology. In some examples, such a display device is combined with the logical processor 202, the volatile memory 204, and / or the non-volatile storage device 206 in a shared housing. In other examples, such a display device is a peripheral display device.
[0076] When included, input subsystem 210 includes or interfaces with one or more user input devices, such as a keyboard, mouse, touch screen, camera, or microphone.
[0077] When included, the communication subsystem 212 is configured to communicatively couple the various computing devices described herein to each other and to other devices. For example, the communication subsystem 212 includes one or more wired and / or wireless communication devices compatible with one or more different communication protocols. As non-limiting examples, the communication subsystem is configured to communicate via a wired or wireless local or wide area network, a broadband cellular network, or the like. In some embodiments, the communication subsystem allows the computing system 200 to send messages to and / or receive messages from other devices via a network (such as the Internet).
[0078] Furthermore, the present disclosure includes configurations according to the following clauses.
[0079] Item 1. A server computing device comprising: one or more server memory devices storing a relational database; and one or more server processing devices configured to: receive a temporary graph database request via a database application programming interface, i.e., a database API, wherein the temporary graph database request indicates a selection of data stored in the relational database for inclusion in a temporary graph database; generate the temporary graph database, wherein the temporary graph database encodes the selected data into a graph structure; store the temporary graph database in a binary large object storage device, i.e., a BLOB storage device, at the one or more server memory devices; receive an instruction via the database API to apply a graph analysis algorithm at the temporary graph database; in response to receiving the instruction to apply the graph analysis algorithm, read the temporary graph database from the BLOB storage device; 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 device.
[0080] Clause 2. A server computing device according to clause 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.
[0081] Clause 3. A server computing device according to clause 1 or 2, wherein: the temporary graph database request also includes a temporary graph database lifetime; and the one or more server processing devices are also configured to delete the temporary graph database from the BLOB storage device in response to determining that the temporary graph database lifetime has expired.
[0082] Clause 4. The server computing device of any of Clauses 1-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 result.
[0083] Clause 5. A server computing device according to any one of Clauses 1-4, wherein the temporary graph database comprises: one or more first tables included in the relational database as nodes of the graph structure; and the following items as edges of the graph structure: one or more second tables included in the relational database; and / or one or more queries on the one or more second tables.
[0084] Clause 6. The server computing device of any of clauses 1-5, wherein the one or more server processing devices are further configured to store the graph analysis results in the relational database.
[0085] Clause 7. A server computing device according to any one of clauses 1-6, wherein the one or more server processing devices are further configured to: receive instructions to update, audit, evict or expand the temporary graph database via the database API; and update, audit, evict or expand the temporary graph database as indicated by the instructions.
[0086] Clause 8. The server computing device of any of Clauses 1-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.
[0087] Clause 9. A server computing device according to Clause 8, wherein the one or more server processing devices are further configured to, before generating the temporary graph database: receive a storage size request from a client computing device; calculate the temporary graph database storage size; and transmit the temporary graph database storage size to the client computing device.
[0088] Clause 10. A server computing device according to any one of clauses 1-9, wherein the one or more server processing devices are also configured to: generate temporary database log data, which includes: generating a temporary database creation record for the temporary graphic database; executing an analysis record of the graphic analysis algorithm; and deleting a temporary database deletion record of the temporary graphic database from the BLOB storage device; and storing the temporary database log data in the one or more server memory devices.
[0089] Item 11. A method for use with a server computing device, the method comprising: receiving a temporary graph database request via a database application programming interface, i.e., a database API, wherein the temporary graph database request indicates a selection of data stored in a relational database for inclusion in a temporary graph database; generating the temporary graph database, wherein the temporary graph database encodes the selected data as a graph structure; storing the temporary graph database in a binary large object storage device, i.e., a BLOB storage device, at one or more server memory devices; receiving instructions via the database API for applying a graph analysis algorithm at the temporary graph database; in response to receiving the instructions for applying the graph analysis algorithm, reading the temporary graph database from the BLOB storage device; 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 device.
[0090] Clause 12. The method of clause 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 elapsed, deleting the temporary graph database from the BLOB storage device.
[0091] Clause 13. The method of clause 11 or 12, wherein in response to outputting the graph analysis result, the temporary graph database is deleted from the BLOB storage device.
[0092] Clause 14. A method according to any one of clauses 11-13, wherein the temporary graph database comprises: one or more first tables included in the relational database as nodes of the graph structure; and the following items as edges of the graph structure: one or more second tables included in the relational database; and / or one or more queries on the one or more second tables.
[0093] Clause 15. The method according to any one of clauses 11-14, further comprising storing the graph analysis results in the relational database.
[0094] Clause 16. The method according to any one of clauses 11-15 further includes: receiving instructions via the database API to update, audit, evict or expand the temporary graph database; and updating, auditing, evicting or expanding the temporary graph database as indicated by the instructions.
[0095] Clause 17. The method of any of Clauses 11-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.
[0096] Clause 18. The method of clause 17, further comprising, before generating the temporary graph database: receiving a storage size request from a client computing device; calculating the temporary graph database storage size; and transmitting the temporary graph database storage size to the client computing device.
[0097] Clause 19. The method according to any one of clauses 11-18 further includes: generating temporary database log data, which includes: generating a temporary database creation record for the temporary graph database; executing an analysis record of the graph analysis algorithm; and deleting a temporary database deletion record of the temporary graph database from the BLOB storage device; and storing the temporary database log data in one or more server memory devices.
[0098] Item 20. A computing system comprising: one or more memory devices storing a relational database in a relational database management system (RDBMS); and one or more processing devices configured to: receive a temporary graph database request, wherein the temporary graph database request indicates a selection of data stored in the relational database for inclusion in a temporary graph database; generate the temporary graph database, wherein the temporary graph database encodes the selected data as a graph structure; store the temporary graph database in a binary large object storage device (BLOB storage device) at the one or more memory devices without storing the temporary graph database in the RDBMS; receive an instruction to apply a graph analysis algorithm at the temporary graph database; in response to receiving the instruction to apply the graph analysis algorithm, read the temporary graph database from the BLOB storage device; 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 device.
[0099] As used herein, "and / or" is defined as an inclusive OR, as specified by the following truth table:
[0100] A B AVB real real real real Fake real Fake real real Fake Fake Fake
[0101] It should be understood that the configurations and / or methods described herein are exemplary in nature, and these specific embodiments or examples should not be considered restrictive, as many variations are possible. The specific routines or methods described herein represent one or more of any number of processing strategies. Thus, the various actions illustrated and / or described may be performed in the order illustrated and / or described, in other orders, in parallel, or omitted. Likewise, the order of the above-mentioned processing may be changed.
[0102] The subject matter of the present disclosure includes all novel and nonobvious combinations and subcombinations of the various processes, systems and configurations, and other features, functions, acts, and / or properties disclosed herein, as well as any and all equivalents thereof.
[0103] Parts List:
[0104] Computing System 1
[0105] Server computing device 10
[0106] Server processing device 12
[0107] Server storage device 14
[0108] Client computing device 20
[0109] Client processing device 22
[0110] Client storage device 24
[0111] User input device 26
[0112] Display device 28
[0113] Relational Database Management System 30
[0114] Relational Database32
[0115] Relational database storage size 33
[0116] Table 34
[0117] Table 1 34A
[0118] Table 2 34B
[0119] Data 36
[0120] First Data 36A
[0121] Second data 36B
[0122] Binary large object storage device 40
[0123] Temporary Graphics Database 42
[0124] Temporary graph database storage size 43
[0125] Graphic structure 44
[0126] Node 46
[0127] Edge 48
[0128] Database Application Programming Interface 50
[0129] Temporary graph database request 52
[0130] Data Selection 54
[0131] Temporary graph database lifetime 56
[0132] Query 58
[0133] Access Control Settings 59
[0134] Directive 60
[0135] Graph Analysis Algorithms62
[0136] Graphical analysis results 64
[0137] Delete instruction 66
[0138] Graphical Database User Interface 70
[0139] Analysis Algorithm Selection 72
[0140] Persistent graph database storage size 73
[0141] Temporary Graphic Modification Input 74
[0142] Directive 76
[0143] Storage size request 78
[0144] Temporary graph database log data 80
[0145] Temporary database creation record 82
[0146] Analysis Log 84
[0147] Temporary database delete record 86
[0148] Recording metadata88
[0149] Timestamp 88A
[0150] Event Type 88B
[0151] Event Identifier 88C
[0152] User ID 88D
[0153] Method 100
[0154] Step 102
[0155] Step 104
[0156] Step 106
[0157] Step 108
[0158] Step 110
[0159] Step 112
[0160] Step 114
[0161] Step 116
[0162] Step 118
[0163] Step 120
[0164] Step 122
[0165] Step 124
[0166] Step 126
[0167] Step 128
[0168] Step 130
[0169] Step 132
[0170] Computing system 200
[0171] Logical processor 202
[0172] Volatile memory 204
[0173] Non-volatile storage device 206
[0174] Display subsystem 208
[0175] Input subsystem 210
[0176] Communication subsystem 212
Claims
1. A server computing device (10), comprising: one or more server memory devices (14) storing a relational database (32); as well as One or more server processing devices (12) configured to: receiving a temporary graph database request (52) via a database application programming interface (database API) (50), wherein the temporary graph database request indicates a selection (54) of data (36) stored in the relational database for inclusion in the temporary graph database (42); generating the temporary graph database, wherein the temporary graph database encodes the selected data as a graph structure (44); storing the temporary graph database in a binary large object storage device (BLOB storage device) (40) at the one or more server memory devices; receiving, via the database API, instructions (60) to apply a graph analysis algorithm (62) at the temporary graph database; In response to receiving the instruction to apply the graph analysis algorithm, reading the temporary graph database from the BLOB storage device; applying the graph analysis algorithm to the temporary graph database to generate a graph analysis result (64); Outputting the graphic analysis result; and The temporary graph database is deleted from the BLOB storage device.
2. The server computing device of claim 1, wherein: The relational database is stored in a relational database management system (RDBMS) (30); and The temporary graph database is not stored in the RDBMS.
3. The server computing device of claim 1 , wherein: The temporary graph database request also includes a temporary graph database lifetime (56); and The one or more server processing devices are further configured to, in response to determining that a lifetime of the temporary graph database has elapsed, delete the temporary graph database from the BLOB storage. 4 . 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 result.
5. The server computing device of claim 1 , wherein the temporary graph database comprises: One or more first tables (34A) included in the relational database as nodes (46) of the graph structure; and As the edge (48) of the graph structure: One or more second tables (34B) included in the relational database; and / or One or more queries (58) are performed on 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 server computing device of claim 1 , wherein the one or more server processing devices are further configured to: receiving, via the database API, instructions to update, audit, evict, or expand the temporary graph database (76); and The temporary graph database is updated, audited, evicted, or expanded as directed 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 of the relational database.
9. The server computing device of claim 8, wherein the one or more server processing devices are further configured to, before generating the temporary graph database: receiving a storage size request (78) from a client computing device (20); Calculating the temporary graph database storage size; and The temporary graph database storage size is communicated to the client computing device.
10. The server computing device of claim 1, wherein the one or more server processing devices are further configured to: Generate temporary database log data (80), which includes: Generating a temporary database creation record (82) of the temporary graphic database; executing the analysis record of the graph analysis algorithm (84); as well as deleting the temporary database deletion record of the temporary graphic database from the BLOB storage device (86); and The temporary database log data is stored at the one or more server memory devices.
11. A method (100) for use with a server computing device, the method comprising: receiving a temporary graph database request via a database application programming interface (database API), wherein the temporary graph database request indicates a selection of data stored in a relational database for inclusion in the temporary graph database (102); generating the temporary graph database, wherein the temporary graph database encodes the selected data into a graph structure (104); storing the temporary graph database in a binary large object storage device (BLOB storage device) at the one or more server memory devices (106); Instructions (108) for applying a graph analysis algorithm at the temporary graph database via the database API; In response to receiving the instruction to apply the graph analysis algorithm, reading the temporary graph database (110) from the BLOB storage device; Applying the graph analysis algorithm to the temporary graph database to generate a graph analysis result (112); Outputting the graphic analysis result (114); as well as The temporary graph database is deleted from the BLOB storage device (118).
12. The method according to claim 11, wherein: The temporary graph database request also includes a temporary graph database lifetime; and In response to determining that the temporary graph database lifetime has elapsed, the temporary graph database is deleted from the BLOB storage.
13. The method of claim 11, wherein in response to outputting the graph analysis result, the temporary graph database is deleted from the BLOB storage device.
14. The method according to claim 11, wherein the temporary graph database comprises: One or more first tables included in the relational database as nodes of the graph structure; as well as The following items are the edges of the graph structure: One or more second tables included in the relational database; or One or more queries on the one or more second tables.
15. The method according to claim 11, further comprising storing the graph analysis results in the relational database.
16. The method according to claim 11, further comprising: Receiving, via the database API, instructions to update, audit, evict, or expand the temporary graph database (120); as well as The temporary graph database (122) is updated, audited, evicted, or expanded as directed 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. The method according to claim 17, further comprising, before 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 The temporary graph database storage size is communicated to the client computing device (128).
19. The method according to claim 11, further comprising: Generates temporary database log data, which includes: generating a temporary database creation record of the temporary graphic database; executing the analysis record of the graph analysis algorithm; and Deleting a temporary database deletion record of the temporary graphic database from the BLOB storage device (130); and The temporary database log data is stored at one or more server memory devices (132).
20. A computing system (1), comprising: one or more memory devices (14) storing a relational database (32) in a relational database management system, or RDBMS (30); as well as One or more processing devices (12) configured to: receiving a temporary graph database request (52), wherein the temporary graph database request indicates a selection (54) of data (36) stored in the relational database for inclusion in a temporary graph database (42); generating the temporary graph database, wherein the temporary graph database encodes the selected data as a graph structure (44); storing the temporary graph database in a binary large object store (BLOB store) (40) at the one or more memory devices without storing the temporary graph database in the RDBMS; receiving instructions (60) to apply a graph analysis algorithm (62) at the temporary graph database; In response to receiving the instruction to apply the graph analysis algorithm, reading the temporary graph database from the BLOB storage device; applying the graph analysis algorithm to the temporary graph database to generate a graph analysis result (64); Outputting the graphic analysis result; and The temporary graph database is deleted from the BLOB storage device.