Graph workspace using system-managed indexes

Abstract

The systems and methods described herein relate to the automated creation and management of indexes for graph workspaces. [Solution] Missing indexes for graph workspaces are identified and automatically created as needed. Automatically created indexes are reused for other graph workspaces that work on the same set of data. Automatic creation and management of indexes for graph workspaces ensures that graph workspaces are created with a single user command, rather than multiple user commands involving index creation prior to the creation of the graph workspace.

Description

Technical Field

[0001] The subject matter described herein generally relates to database technology. More specifically, but not exclusively, the subject matter described herein relates to the automatic creation and management of graph workspaces and related indexes.

Background Art

[0002] Graph workspaces in database systems provide advanced capabilities for processing data, enabling users to perform analyses of complex networks. For example, graph workspaces are used to map complex routing networks, such as supply chains, and to identify bottlenecks, optimize routes, and improve the overall efficiency of these complex routing networks. Graph workspaces are also used to model and analyze social networks and to identify patterns of interaction within these social networks. However, with the continuing improvement of computer technology, the data for which graph workspaces are used is becoming increasingly complex.

Summary of the Invention

Problems to be Solved by the Invention

[0003] Thus, there is a continuing need for technical improvements in database technology to address these technical challenges.

Means for Solving the Problems

[0004] Some examples, for purposes of illustration and not limitation, are shown in the figures of the accompanying drawings. The drawings are not necessarily drawn to scale, and like numbers may describe similar components from different perspectives or examples. It should be understood that additional and alternative examples are possible without departing from the principles of the subject matter described herein.

Brief Description of the Drawings

[0005] [Figure 1] This diagram shows a network environment including a graph workspace system, with several examples. [Figure 2] Here are some examples of block diagrams showing the components of a graph workspace system. [Figure 3] This block shows examples of creating a graph workspace, with several examples. [Figure 4] This block shows examples of replacing the graph workspace, with several examples. [Figure 5A] This block diagram shows examples of exporting and importing graph workspaces, with several examples. [Figure 5B] This block diagram shows examples of exporting and importing graph workspaces, with several examples. [Figure 6A] This flowchart illustrates the method with several examples. [Figure 6B] This flowchart illustrates the method with several examples. [Figure 7] This block diagram shows software architectures for computing devices, with several examples. [Figure 8] This specification includes several examples of block diagrams of machines in the form of computer systems, in which instructions can be executed to cause the machine to implement one or more of the methodologies discussed herein. [Modes for carrying out the invention]

[0006] Generally speaking, a graph workspace is a catalog object (e.g., a database object) that represents an interconnected set of data (e.g., a data set, a data table) within a database. A graph workspace provides a structured representation of the data set using vertices and edges to represent the data. By providing this structured representation, a graph workspace supports various graph analysis capabilities, such as cross-trajectory analysis and relationship analysis. To leverage these graph analysis capabilities, a graph workspace is created based on hash indexes (e.g., vertex indexes) and adjacency indexes (e.g., edge indexes), which support the graph analysis capabilities of the graph workspace. Because a graph workspace is created based on hash indexes and adjacency indexes, any attempt to create a graph workspace before these indexes are created will fail. Similarly, because hash indexes and adjacency indexes support the graph analysis capabilities of a graph workspace, if a hash index or adjacency index is dropped or deleted, a graph workspace based on a hash index or adjacency index becomes invalid (e.g., ceases to function). Therefore, database technologies that use graph workspaces face technical challenges arising from the graph workspace's reliance on hash indexes and adjacency indexes.

[0007] The subject matter described herein addresses these and other technical challenges that arise in the field of database technology. In summary, the subject matter described herein enables the automated creation and management of indexes for graph workspaces. Automated creation and management of indexes for graph workspaces allows graph workspaces to be created with a single user command, rather than multiple user commands involving the creation of hash indexes and adjacent indexes prior to the creation of the graph workspace. Thus, by enabling automated creation and management of indexes, database technology is improved by preventing failures in graph workspace creation and increasing ease of use.

[0008] In some examples, the graph workspace system, in response to a user command to create a graph workspace for a data set, identifies existing indexes for the data set (e.g., user-created indexes) and automatically creates indexes accordingly. For example, the graph workspace system receives a user command to create a graph workspace for a data set. In response, the graph workspace system identifies whether a hash index and an adjacency index have been created for the data set. In this example, a hash index has already been created for the data set, but an adjacency index has not. Based on the fact that an adjacency index has not been created for the data set, the graph workspace system automatically creates an adjacency index. The graph workspace is created using the hash index and the automatically created adjacency index. As this example shows, automatic index creation is advantageous because it prevents failures in graph workspace creation while avoiding the creation of irrelevant indexes.

[0009] In some examples, automatically generated indexes for graph workspaces (e.g., system indexes) are reused for the creation of subsequent graph workspaces. For example, a first graph workspace for a data set is created in response to a first user command to create the first graph workspace. In this example, hash indexes and adjacency indexes are not created. Hash indexes and adjacency indexes are automatically created in response to the user command to create the first graph workspace. A second graph workspace for the data set is created in response to a second user command to create the second graph workspace. Since the first and second graph workspaces are created for the same set, the second graph workspace can be created by referencing the automatically generated hash indexes and adjacency indexes. As this example demonstrates, through the automatic creation and management of indexes, indexes are automatically created and reused for graph workspaces, improving the use of computing resources.

[0010] In some cases, automatically created indexes for graph workspaces (e.g., system indexes) are automatically dropped in response to the dropping of the graph workspace for which the index was created, and based on the number of graph workspaces referencing the automatically created index. For example, hash indexes and neighbor indexes are automatically created in response to a user command to create a graph workspace for a data set. When a graph workspace is dropped, an identification is made of the graph workspaces that reference the automatically created hash index and neighbor index. If the number of graph workspaces referencing the automatically created hash index and neighbor index is less than a threshold number (e.g., 1), the automatically created hash index and neighbor index are automatically dropped. For example, if the number of graph workspaces referencing the automatically created hash index and neighbor index is zero, no graph workspaces reference the automatically created hash index and neighbor index. As this example shows, through the automatic creation and management of indexes, indexes are automatically created, automatically dropped, and free up computing resources that would otherwise not be used.

[0011] In some examples, the graph workspace system facilitates replacing a graph workspace created for a first data set with the same graph workspace created for a second data set. For example, in response to a first user command to create a graph workspace, a graph workspace is created for the first data set. To facilitate the creation of the graph workspace, the graph workspace system identifies whether a hash index and adjacent index have been created for the first data set. In this example, neither a hash index nor an adjacent index has been created. Therefore, the graph workspace system automatically creates the hash index and adjacent index. The graph workspace is created by referencing the automatically created hash index and adjacent index. Subsequently, the graph workspace is replaced in response to a second user command to create a graph workspace for the second data set. To facilitate the replacement of the graph workspace, the graph workspace system identifies whether a hash index and adjacent index have been created for the second data set and automatically creates the hash index and adjacent index if necessary. Furthermore, the graph workspace system identifies whether the automatically generated hash index and adjacency index for the first data set are referenced by any other graph workspace, and, if necessary, drops the automatically generated hash index and adjacency index for the first data set. The graph workspace then references and replaces the hash index and adjacency index for the second data set. As this example demonstrates, by managing automatically generated indexes, the graph workspace system optimizes the use of computing resources by automatically creating and dropping indexes when they are used.

[0012] In some examples, the graph workspace system manages the indexes used by the graph workspace for export and import operations of the graph workspace. For example, a first user exports a graph workspace that references a hash index created in response to a user command and an automatically created adjacency index. In this example, the hash index and graph workspace are exported without the automatically created adjacency index. This avoids granting user privileges to automatically created objects or providing objects that cannot be dropped due to a lack of user privileges. When a second user imports the graph workspace and hash index, the adjacency index that was not exported is automatically created. As this example demonstrates, automatically created indexes are managed to maintain apparent user privileges over objects during export and import operations, avoiding situations where computational resources could be lost. Further details relating to the automatic creation and management of indexes for graph workspaces are provided herein.

[0013] Figure 1 is a schematic representation of a networked computing environment 100 in which several examples of the present disclosure may be implemented or deployed. One or more servers in a server system 104 provide server-side functionality via a network 102 to a networked device, in an exemplary form, a user device 106 accessed by a user 108. A web client 110 (e.g., a browser) or a programmatic client 112 (e.g., an "app") may be hosted and run on the user device 106.

[0014] The Application Programming Interface (API) server 124 and the web server 126 provide their respective programmatic and web interfaces to the components of the server system 104. A specific application server 122 hosts the supply chain platform 128 and the graph workspace system 130, each containing components, modules, or applications. Note that the supply chain platform 128 and the graph workspace system 130 may be hosted by separate application servers in some examples.

[0015] The user device 106 can communicate with the application server 122, for example, via a web interface supported by the web server 126, or via a programmatic interface provided by the API server 124. Although only a single user device 106 is shown in Figure 1, it will be understood that in some examples, multiple user devices may be coupled to the server system 104 in a communicative manner. Furthermore, some functions may be described herein as being implemented in either the user device 106 (e.g., the web client 110 or the programmatic client 112) or the server system 104, but the placement of a particular functionality in either the user device 106 or the server system 104 may be a design choice. Furthermore, some functions may be described herein as being implemented in a specific system, such as the graph workspace system 130, but the placement of functionality may be a design choice. For example, some functions described with reference to the graph workspace system 130 may be implemented by the supply chain platform 128, or by both the graph workspace system 130 and the supply chain platform 128.

[0016] The application server 122 is communicatively coupled to the database server 132 to facilitate access to one or more information storage repositories, such as the database 134. In some examples, the database 134 includes a storage device that stores information to be accessed, processed, modified, or erased by the supply chain platform 128 or the graph workspace system 130.

[0017] The application server 122 accesses application data (e.g., application data stored by the database server 132) and provides one or more applications or software tools to the user device 106 via the web interface 114 or the app interface 116. The supply chain platform 128 is an example of a platform having one or more applications or software tools provided by the application server 122.

[0018] The supply chain platform 128 can facilitate the tracking, coordination, and execution of supply chain activities (e.g., from procurement to distribution). In some examples, the supply chain platform 128 enables an organization to rationalize and digitize its procurement lifecycle using a cloud-based architecture and integrate with the database 134 for high-speed processing of large datasets and real-time insights. Various data objects are created and used to manage and operate the supply chain platform 128. For example, various data objects corresponding to real-world enterprises or objects can be mapped to tables in the database 134, and such tables (and thus those data objects) can be interconnected based on hierarchy, dependency, or reference.

[0019] In some examples, the supply chain platform 128 integrates with other systems to enhance functionality, for example, interfacing with the graph workspace system 130. For example, the supply chain platform 128 may use the graph workspace system 130 to provide graph analysis capabilities.

[0020] In some examples, the graph workspace system 130 is a system configured to create a graph workspace for a set of data within the database 134. The graph workspace system 130 automatically creates an index to facilitate creation of the graph workspace. The graph workspace system 130 manages the automatically created index and the graph workspace, for example, with create operations, drop operations, export operations, and import operations.

[0021] For example, the graph workspace system 130 handles requests to create a graph workspace for an aggregate of data within the database 134. In some examples, the supply chain platform 128 and the graph workspace system 130 jointly process user commands to create a graph workspace, create an index, export a graph workspace, import a graph workspace, drop a graph workspace, and drop an index.

[0022] Note that the supply chain platform 128 is merely an example of a platform or system that can benefit from the features of the graph workspace system 130. The graph workspace system 130 can operate to create and manage graph workspaces and indexes for other platforms or systems, such as, for example, a personnel system, an enterprise resource planning (ERP) system, or an accounting system.

[0023] In some examples, the application server 122 is part of a cloud-based platform provided by a software provider, which enables the user 108 to use tools from the supply chain platform 128, the graph workspace system 130, and, where applicable, other systems or subsystems (for example, human resources systems, ERP systems, or accounting systems, as mentioned).

[0024] One or more of the application server 122, database server 132, API server 124, web server 126, and supply chain platform 128 may be implemented in whole or in part in the computer system, as described below with respect to Figure 8. In some examples, an external application (which may be a third-party application or another application provided by the same software provider), such as an external server 118 running on an external application 120, can communicate with the application server 122 through a programmatic interface provided by the API server 124. For example, a third-party application may support one or more features or functions on a website or platform hosted by the third party, or it may implement some methodology to provide input or output information to the application server 122 for further processing.

[0025] Network 102 may be any network that enables communication between machines, databases, and devices. Therefore, Network 102 may be a wired network, a wireless network (e.g., a mobile or cellular network), or any suitable combination thereof. Network 102 may include one or more parts that constitute a private network, a public network (e.g., the Internet), or any suitable combination thereof.

[0026] Figure 2 is a block diagram showing the components of the graph workspace system 130 in Figure 1, with some examples. In Figure 2, the graph workspace system 130 is shown to include a creation module 202, a management module 204, a replacement module 206, an export / import module 208, a metadata module 210, and a privilege module 212.

[0027] The creation module 202 is responsible for creating graph workspaces and the indexes referenced by those graph workspaces. Generally, a graph workspace is a catalog object that represents a set of data (e.g., a data set, a data table) for performing graph analysis. A graph workspace references a hash index (e.g., a vertex index, a vertex table) that identifies vertices in the set of data for the graph workspace. A graph workspace references an adjacency index (e.g., an edge index, an edge table) that identifies connections (e.g., edges) between adjacent vertices in the set of data. The adjacency index references a hash index for vertices in the set of data. The adjacency index identifies edges between adjacent vertices in the set of data using references to source points and target vertices in the set of data, with each edge defined as an edge between a source point and a target vertex. When a graph workspace references a hash index and an adjacency index, the hash index and the adjacency index are prerequisites for creating the graph workspace.

[0028] In some examples, the creation module 202 receives a user command to create a graph workspace and creates the graph workspace in response to the user command. For example, a user command may include the name of the graph workspace, a data set identifier for the data set for which the graph workspace should be created, a hash index identifier for the hash index containing vertex data for the graph workspace, an adjacency index identifier for the adjacency index containing edge data for the graph workspace, a source identifier containing a reference to the source in the vertex data, a target vertex identifier containing a reference to the target vertex in the vertex data, and a type identifier that identifies the type of information about the edges and vertices of the graph workspace. For example, a user command to create a graph workspace may be: CREATE GRAPH WORKSPACE S2.WS COLLECTION S1.COLL VERTEX KEY “uid1” EDGE KEY “uid2” SOURCE “src” TARGET “tgt” TYPE “typ”; That is the case.

[0029] Here, "S2.WS" is the name of the graph workspace, "S1.COLL" is the data set identifier, "uid1" is the hash index identifier, "uid2" is the adjacent index identifier, "src" is the source identifier, "tgt" is the target vertex identifier, and "typ" is the type identifier. Here, this exemplary user command is a single statement for creating a graph workspace.

[0030] In response to a user command to create a graph workspace, creation module 202 identifies hash indexes and adjacent indexes based on the hash index identifier, adjacent index identifier, source identifier, target vertex identifier, and type identifier. If existing hash indexes (e.g., user-created hash indexes, automatically generated hash indexes) have been created that correspond to the hash index identifier and type identifier, the graph workspace refers to the existing hash indexes. If existing adjacent indexes (e.g., user-created adjacent indexes, automatically generated adjacent indexes) have been created that correspond to the adjacent index identifier, source identifier, target vertex identifier, and type identifier, the graph workspace refers to the existing adjacent indexes. If no hash indexes have been created that correspond to the hash index identifier and type identifier, hash indexes are automatically created for the graph workspace to refer to. If no adjacent indexes have been created that correspond to the adjacent index identifier, source identifier, target vertex identifier, and type identifier, adjacent indexes are automatically created for the graph workspace to refer to.

[0031] The creation module 202 creates hash indexes or adjacency indexes using a naming scheme that identifies them as automatically created indexes. For example, an automatically created hash index has the prefix "_SYS_HASH_INDEX_", and an automatically created adjacency index has the prefix "_SYS_ADJACENCY_INDEX_". The naming scheme allows the graph workspace system 130 to identify automatically created indexes as system indexes without adding additional metadata to them. In some cases, users are prevented from creating indexes that follow the naming scheme. Therefore, the naming scheme clearly identifies which indexes are created in response to user commands and which indexes are automatically created.

[0032] In some cases, users are prevented from directly referencing automatically generated indexes. For example, a user creating a graph workspace is prevented from referencing an automatically generated index within the user command used to create the graph workspace. For example, a user is prevented from using a drop command to drop an automatically generated index. This allows the graph workspace system 130 to maintain control over the automatically generated indexes.

[0033] In some cases, graph workspaces, indexes, and data sets may belong to different schemas. Generally, a schema is a namespace for organizing related database objects. For example, a graph workspace created in response to a user command belongs to a user-defined schema. The data sets on which the graph workspace is created belong to a different user-defined schema. An automatically generated index created in response to a user command belongs to the schema of the data sets on which the graph workspace is created.

[0034] The owner of a data set on which an automatically generated index is created is appointed as the owner of the automatically generated index. This links the automatically generated index to the data set, so that, for example, if the owner of the data set drops the data set, any automatically generated indexes created on that data set will also be dropped. If the owner of the data set is dropped, all database objects belonging to that user, including automatically generated indexes, will be dropped.

[0035] In some examples, the number of hash indices and neighbor indices created for a data set is limited to a threshold number (e.g., 1). For example, only one hash index and one neighbor index are allowed for a single data set. A graph workspace created for a data set will use an existing hash index created for the data set, or an automatically generated hash index for the data set if no existing hash index exists. The graph workspace will use an existing neighbor index created for the data set, or an automatically generated neighbor index for the data set if no existing neighbor index exists. In this example, there is a threshold of one hash index and one neighbor index allowed for a data set. Therefore, all users creating a graph workspace for a set will use the same hash index and the same neighbor index.

[0036] The management module 204 is responsible for maintaining indexes for graph workspaces. In some examples, automatically generated indexes for a data set are used by multiple graph workspaces. For example, in response to a first user command from a first user to create a first graph workspace for a data set, a hash index and an adjacency index for the data set are automatically generated. The hash index and adjacency index are automatically generated based on the determination that there is no existing hash index and no existing adjacency index for the data set. In this example, a second graph workspace for the data set is created in response to a second user command from a second user who does not have the privileges to access the first graph workspace and is unaware of the first graph workspace. The automatically generated hash index and adjacency index are identified as existing hash index and existing adjacency index for the data set. The second graph workspace is created by referencing the automatically generated hash index and adjacency index. As shown in this example, the management module 204 prevents redundant index creation and improves the use of computing resources.

[0037] In some examples, when all graph workspaces that reference an auto-created index are dropped, the auto-created index is erased or dropped. For example, suppose a first graph workspace and a second graph workspace use the same auto-created hash index and the same auto-created adjacency index for a data set. The first graph workspace is dropped in response to a user command to drop it. When the first graph workspace is dropped, the auto-created hash index and auto-created adjacency index are examined to determine whether any graph workspace references the auto-created hash index or the auto-created adjacency index. In this example, it is determined that the second graph workspace references the auto-created hash index and the auto-created adjacency index. Based on this determination, the auto-created hash index and the auto-created adjacency index are saved when the first graph workspace is dropped. Continuing this example, the second graph workspace is dropped in response to a user command to drop it. When the second graph workspace is dropped, the auto-created hash index and the auto-created adjacency index are examined to determine whether any graph workspace references the auto-created hash index or the auto-created adjacency index. At this point, after the second graph workspace is dropped, a determination is made that no graph workspaces will reference the automatically generated hash index or the automatically generated adjacency index. Based on this determination, the automatically generated hash index and the automatically generated adjacency index are dropped when the second graph workspace is dropped.

[0038] In some cases, the management module 204 determines whether an automatically generated index for a data set is referenced by a graph workspace for that data set by iterating through the data objects defined for that data set. For example, if a graph workspace for a data set is dropped, the management module 204 iterates through the metadata for the data set to identify other graph workspaces defined for that data set. For each such graph workspace, a decision is made as to whether the graph workspace uses an automatically generated hash index or an automatically generated adjacency index created for the graph workspace. For each graph workspace that uses an automatically generated index, a counter for the automatically generated index is incremented. A counter of 1 or more after iterating through each graph workspace indicates that the automatically generated index is being used. A counter of zero after iterating through each graph workspace indicates that the automatically generated index is no longer being used. An automatically generated index can be dropped if the counter associated with the automatically generated index becomes zero after iterating through the graph workspaces for which the automatically generated index was created. It is not necessary to maintain persistent counters for each automatically generated index by iterating through the graph workspaces when a graph workspace is dropped. In some cases, persistent counters are maintained for each automatically created index to reduce computing resource usage at the expense of maintaining additional metadata. This may involve metadata migration when the system is updated to support additional metadata.

[0039] In some cases, the management module 204 locks the data sets on which the auto-created index is built. The data sets are locked to prevent modifications to them, which could lead to a potential deadlock resulting in the failure of data definition language statements. Once the index is created, the data sets are unlocked and can be modified.

[0040] The replacement module 206 is responsible for replacing graph workspaces to work with different data sets. Graph workspaces are replaced in response to user commands to create a graph workspace using the name of an existing graph workspace. The created graph workspace replaces the existing graph workspace. For example, a user gives a user command to create a graph workspace with the name of an existing graph workspace for a first data set. The user command includes a data set identifier specifying a second data set. In response to the user command, a graph workspace for the second data set is created. If the second data set does not have an existing hash index, a hash index for the second data set is automatically created. If the second data set does not have an existing adjacency index, an adjacency index for the second data set is automatically created. The graph workspace for the second data set is created by referencing the automatically created hash index and the automatically created adjacency index. The graph workspace for the first data set is dropped in response to the user command. If the graph workspace for the first data set references the automatically created hash index and no other graph workspaces reference the automatically created hash index, the automatically created hash index is dropped. If a graph workspace for a second data set references an automatically generated adjacency index, and no other graph workspace references an automatically generated adjacency index, the automatically generated adjacency index is dropped.

[0041] The Export / Import module 208 is responsible for exporting and importing graph workspaces. In some examples, automatically generated indexes are not exported along with the exported graph workspace. User-created indexes and other base objects (e.g., data sets) are exported along with the exported graph workspace. Preventing automatically generated indexes from being exported avoids situations where a user imports indexes they cannot drop. For example, a user gives a user command to create a graph workspace on a data set that has no existing hash index or adjacency index. The hash index and adjacency index are automatically created in response to the user command. The graph workspace is created by referencing the automatically generated hash index and adjacency index. In this example, the user gives a user command to export the graph workspace. The graph workspace and the data set on which the graph workspace was created are exported in response to the user command. The automatically generated hash index and adjacency index are not included in the export (e.g., they are excluded).

[0042] When automatically generated indexes are not exported with an exported graph workspace (for example, they are excluded), indexes are automatically created for imported graph workspaces with missing indexes. Automatically generated indexes are managed by the system that imported the graph workspace, and it is possible to drop them when they are no longer needed (for example, when the imported graph workspace is dropped). For example, a graph workspace that references automatically generated hash indexes and automatically generated adjacency indexes is exported to the system. In this example, the graph workspace and the data set for which the graph workspace is created are exported to the system. The automatically generated hash indexes and automatically generated adjacency indexes are not exported to the system. The system imports the graph workspace and data set. Since there are no hash indexes or adjacency indexes for the data set, the system automatically creates them. The imported graph workspace references the automatically generated hash indexes and automatically generated adjacency indexes.

[0043] The metadata module 210 is responsible for identifying metadata associated with the graph workspace and providing access to that metadata. For example, metadata for a graph workspace includes the following: • Entity Type: Specifies the type of entity in the graph workspace (e.g., vertex, edge). • Entity schema name: Specifies the name of the schema where the entity tables are located. • Entity table name: Specify the name of the entity table containing vertex data or edge data. • Entity column name: Specifies the name of the column in the entity table. • Entity Role: Specifies the role of a column in the graph workspace (e.g., key, source, target, type). • Reference schema name: Specifies the schema name of the reference vertex table, using the edge tables for the source and target vertices. • Reference Table Name: Specifies the name of the reference vertex table, using the edge tables for the source and target vertices.

[0044] In some cases, the metadata associated with a graph workspace that references a user-created index is the same as the metadata associated with a graph workspace that references an automatically generated index. That is, a graph workspace that references an automatically generated index does not use additional metadata to track the dependencies of the automatically generated index. Automatically generated indexes are maintained and dropped when they are no longer used by iterating through the metadata when a graph workspace is dropped, according to the naming convention for automatically generated indexes.

[0045] Privileged module 212 is responsible for processing user commands for creating graph workspaces, which are granted by user privileges. In some examples, a user command to create a graph workspace for a collection is denied if the user who issued the command does not have the user privilege to create an index on the collection. This prevents a user who does not have the user privilege to create an index on a collection from creating an automatically generated index on the collection. In some examples, a user command to drop a graph workspace for a collection is denied if the user who issued the command does not have the user privilege to drop an index on the collection. This prevents a user who does not have the user privilege to drop an index on a collection from dropping an automatically generated index on the collection. In some examples, a user command to replace a graph workspace for a collection is denied if the user who issued the command does not have the user privilege to drop an index. This prevents a situation where a graph workspace is dropped due to replacement, but the automatically generated index referenced by the graph workspace is not dropped.

[0046] In some examples, at least some of the components shown in Figure 2 are configured to communicate with each other in order to implement the embodiments described herein. One or more of the components described herein may be implemented using hardware (for example, one or more processors of one or more machines) or a combination of hardware and software. For example, one of the components described herein may be implemented by a processor configured to perform the operations described herein for that component. Furthermore, two or more of these components may be combined into a single component, or the functions described herein for a single component may be subdivided among multiple components. In addition, according to various examples, the components described herein may be implemented using a single machine, database, or device, or they may be distributed across multiple machines, databases, or devices.

[0047] In some examples, several components or subsystems shown in Figure 1 or Figure 2 are implemented as microservices (individually or collectively). A microservice subsystem (e.g., a microservice application) may have components that operate independently and enable communication with other services. Exemplary components of a microservice subsystem include: • Functional logic: Functional logic implements the functionality of a microservice subsystem and represents the specific capabilities or functions that the microservice provides. • API Interface: Microservices can communicate with each other through a clear API or interface, using lightweight protocols such as Representational State Transition (REST) ​​or messaging. • Data storage: Microservice subsystems may handle their own data storage, which may take the form of a database, cache, or other storage mechanism (for example, using database 134). This allows microservice subsystems to operate independently of other microservices. • Service discovery: Microservice subsystems can find and communicate with other microservice subsystems of the server system 104. The service discovery mechanism enables microservice subsystems to locate and communicate with other microservice subsystems in a scalable and efficient manner. • Monitoring and Logging: Microservice subsystems may need to be monitored and logged to ensure their availability and performance. Monitoring and logging mechanisms enable tracking of the health and performance of microservice subsystems.

[0048] Figure 3 is a block diagram illustrating Example 300 of creating a graph workspace with several examples. One or more of the various functions described in Example 300 may be implemented, for example, by the graph workspace system 130 in Figure 1 or Figure 2 or a similar graph workspace system.

[0049] Example 300 illustrates the creation of graph workspaces A314 and B316 in data set 308 within the graph workspace system 306. User A302 provides a user command to create graph workspace A314 in data set 308. In response to the user command, the graph workspace system 306 determines whether an index for graph workspace A314 has been created in data set 308. In this example, hash index 310 is an existing hash index created in data set 308. The adjacency index 312 has not been created in data set 308. Therefore, the graph workspace system 306 determines that the adjacency index 312 has not been created and automatically creates the adjacency index 312 in data set 308. The graph workspace system 306 creates graph workspace A314 by referencing hash index 310 and adjacency index 312.

[0050] User B304 provides a user command to create graph workspace B316 in data set 308. In response to the user command, the graph workspace system 306 determines whether an index for graph workspace B316 has been created in data set 308. In this example, hash index 310 is an existing hash index created in data set 308. Adjacent index 312 is an existing adjacent index that was automatically created in data set 308 in response to a user command to create graph workspace A314. Therefore, the graph workspace system 306 determines that hash index 310 and adjacent index 312 have been created and creates graph workspace B316 by referencing hash index 310 and adjacent index 312.

[0051] Figure 4 is a block diagram illustrating Example 400, which replaces a graph workspace, with several examples. One or more of the various functions described in Example 400 may be implemented, for example, by the graph workspace system 130 in Figure 1 or Figure 2 or a similar graph workspace system.

[0052] Example 400 illustrates the replacement of a graph workspace A412 created for data set A406 with a graph workspace A412 created for data set B414. User A402 provides a user command to create graph workspace A412 in data set B414. In this example, graph workspace A412 has already been created for data set A406. Hash index A408 and neighbor index A410 have been automatically created for graph workspace A412. In response to the user command, the graph workspace system 404 determines whether an index for graph workspace A412 has been created in data set B414. In this example, no index has been created in data set B414. Therefore, the graph workspace system 404 determines that no index has been created in data set B414 and automatically creates hash index B416 and neighbor index B418 in data set B. The graph workspace system 404 drops graph workspace A412 in data set A406 and creates a replacement graph workspace A412 in data set B414, referencing hash index B416 and neighbor index B418. Based on the fact that graph workspace A412 was dropped in data set A406, the graph workspace system 404 determines whether the automatically created hash index A408 and neighbor index A410 are referenced by any graph workspace. In this example, only graph workspace A412 referenced hash index A408 and neighbor index A410. Therefore, the graph workspace system 404 determines that no graph workspace references hash index A408 and neighbor index A410. Based on this determination, the graph workspace system 404 drops hash index A408 and neighbor index A410.

[0053] Figures 5A and 5B are block diagrams illustrating examples of exporting and importing graph workspaces. One or more of the various functions described in these examples may be implemented by, for example, the graph workspace system 130 in Figure 1 or Figure 2 or a similar graph workspace system.

[0054] In Figure 5A, Example 500 shows the export of a graph workspace 510 created for a data set 504. When the graph workspace 510 was created for the data set 504, the hash index 506 had already been created in the data set 504, and the neighbor index 508 was automatically created in the data set 504. The graph workspace 510 was created by referencing the hash index 506 and the neighbor index 508. In response to a user command to export the graph workspace 510, the graph workspace system 502 generates a binary 512 containing the graph workspace 510, the data set 504, and the hash index 506. The automatically created neighbor index 508 is not included in the binary 512.

[0055] In Figure 5B, Example 550 shows the import of binary 512. In response to a user command to import graph workspace 510, the graph workspace system 552 imports binary 512. Binary 512 contains graph workspace 510, data set 504, and hash index 506. The graph workspace system 552 identifies the index in data set 504 that is imported into binary 512. Since the hash index 506 is included in binary 512, and the neighbor index is not included in binary 512, the graph workspace system 552 automatically creates the neighbor index 554. Graph workspace 510 refers to the hash index 506 and the neighbor index 554.

[0056] Figures 6A and 6B are flowcharts illustrating exemplary methods in several examples. One or more of the functions described in the exemplary methods may be implemented, for example, by the graph workspace system 130 in Figure 1 or Figure 2 or a similar graph workspace system. While flowcharts illustrate specific operation sequences, sequences may be modified without departing from the scope of the subject matter disclosed herein. For example, some of the operations shown may be performed in parallel or in different sequences without substantially affecting the functionality as described in the exemplary methods.

[0057] In Figure 6A, exemplary method 600 includes actions performed by the graph workspace system related to the creation of a graph workspace. In action 602, the graph workspace system creates a data set. For example, the data set is created in response to a user command to create a data set of data in a database. In action 604, the graph workspace system creates a graph workspace. For example, the graph workspace system receives a user command to create a graph workspace for the data set. In action 606, the graph workspace system determines whether existing indexes exist in the data set. For example, the graph workspace system determines whether a hash index and an adjacency index exist in the data set. If the graph workspace determines that existing indexes exist in the data set, in action 608, the graph workspace system uses the existing indexes. For example, the graph workspace system uses the existing hash index and the existing adjacency index to create the graph workspace. If the graph workspace determines that there are no existing indexes for the data set, in action 610, the graph workspace system automatically creates indexes. For example, the graph workspace system automatically creates a hash index and an adjacency index for the data set. In operation 612, a graph workspace is created. For example, a graph workspace is created by referencing an existing hash index and an existing adjacency index, an existing hash index and an automatically generated adjacency index, or an automatically generated hash index and an automatically generated adjacency index. In operation 614, the graph workspace system manages the graph workspace. Managing the graph workspace involves various operations. In operation 616, the graph workspace system uses the graph workspace to facilitate querying and analyzing graph data.For example, the graph workspace system facilitates cross-graph operations on the graph workspace. In operation 618, the graph workspace system updates the graph workspace. For example, the graph workspace system can refresh the graph workspace by modifying an existing hash index or an existing adjacency index. In operation 620, the graph workspace system drops the graph workspace. For example, the graph workspace system drops the graph workspace system and, if no other graph workspaces reference the auto-generated hash index and auto-generated adjacency index, it drops the auto-generated hash index and auto-generated adjacency index. In operation 624, the graph workspace system exports and imports the graph workspace. For example, the graph workspace system exports the graph workspace to a binary that includes existing indexes but does not include the auto-generated indexes.

[0058] In Figure 6B, exemplary method 650 includes actions performed by the graph workspace system. In action 652, the graph workspace system receives a user command to create a graph workspace for a set of data. In action 654, the graph workspace system determines missing indexes in the set of data for the graph workspace. In action 656, the graph workspace system automatically creates an auto-created index in the set of data for the graph workspace based on the missing indexes. In action 658, the graph workspace system creates the graph workspace by referring to the auto-created index.

[0059] In light of the implementation forms of the subject matter described above, this application discloses the following list of embodiments, where one feature of a separated embodiment or multiple features of an embodiment, when combined and, at any option, combined with one or more features of one or more further embodiments, also constitutes a further embodiment that falls within the scope of the disclosure of this application.

[0060] Example 1 is a system comprising at least one memory for storing instructions and one or more processors configured by instructions to perform an operation, the operation comprising: receiving a first user command for creating a first graph workspace for a first set of data; determining a first missing index in the first set of data for the first graph workspace; automatically creating a first auto-created index in the first set of data for the first graph workspace based on the first missing index; and creating a first graph workspace by referencing the first auto-created index.

[0061] In Example 2, the subject of Example 1 includes receiving a second user command to drop a first graph workspace, referring to a first auto-generated index to identify the number of second graph workspaces, and dropping the first auto-generated index based on the fact that the number of second graph workspaces referring to the first auto-generated index is less than a threshold number.

[0062] In Example 3, identifying the number of second graph workspaces in the subject of Example 2 involves iterating through the data objects defined for the first set of data and incrementing a counter for each data object of the data objects, referencing the first automatically generated index.

[0063] In Example 4, the subject of any of Examples 1-3 includes receiving a second user command to create a second graph workspace for a first set of data, identifying a first auto-generated index in the first set of data, and creating the second graph workspace by referencing the first auto-generated index.

[0064] In Example 5, the subject of any of Examples 1-4 is to determine a first existing index in a first set of data for a first graph workspace, the first existing index being not identified in a first user command, and to cause the first graph workspace to reference the first existing index and the first auto-created index.

[0065] In Example 6, in any subject from Examples 1 to 5, the operation is to automatically create a second automatic index, the second automatic index identifies the connections between vertices in the first set of data, and the second automatic index references the first automatic index, and further includes causing a first graph workspace to reference the first and second automatic indexes.

[0066] In Example 7, the subject of any of Examples 1-6 includes receiving a second user command to replace the first graph workspace with a second graph workspace for a second set of data, determining a second missing index in the second set of data for the second graph workspace, automatically creating a second auto-generated index in the second set of data for the second graph workspace based on the second missing index, creating a second graph workspace by referencing the second auto-generated index, and dropping the first graph workspace and the first auto-generated index.

[0067] In Example 8, the subject of any of Examples 1-7 includes receiving a second user command to export a first graph workspace and generating a binary containing the first graph workspace and a first set of data, the binary being generated excluding a first automatically generated index.

[0068] In Example 9, the subject of any of Examples 1-8 includes receiving a second user command to import a second graph workspace, receiving a binary containing the second graph workspace and a second set of data, determining a second missing index in the binary, and automatically creating a second auto-created index in the second set of data, wherein the second graph workspace references the second auto-created index.

[0069] In Example 10, the subject of any of Examples 1-9 includes locking a first set of data based on a first automatically generated index and unlocking the first set of data based on the fact that the first automatically generated index has been created.

[0070] In Example 11, the subject of any of Examples 1-10 involves determining that the user who gave the first user command has the privilege to create an index on the first set of data, and creating the first graph workspace is based on the user having the privilege to create an index on the first set of data.

[0071] In Example 12, the subject matter of any of Examples 1-11 includes determining that the user who issued the first user command does not have the privilege to drop an index in the first set of data, and rejecting a second user command to replace the first graph workspace with a second graph workspace for the second set of data.

[0072] In Example 13, in any subject from Examples 1 to 12, the first automatically generated index follows a naming scheme that identifies the first automatically generated index as a system index.

[0073] Example 14 is a method that includes the steps of: receiving a first user command to create a first graph workspace for a first set of data; determining a first missing index in the first set of data for the first graph workspace; automatically creating a first auto-created index in the first set of data for the first graph workspace based on the first missing index; and creating a first graph workspace by referencing the first auto-created index.

[0074] In Example 15, the subject of Example 14 includes the steps of receiving a second user command to drop a first graph workspace, referring to a first auto-generated index to identify the number of second graph workspaces, and dropping the first auto-generated index based on the fact that the number of second graph workspaces referring to the first auto-generated index is less than a threshold number.

[0075] In Example 16, in the subject of Example 15, the step of identifying the number of second graph workspaces includes iterating through the data objects defined for the first set of data and incrementing a counter for each data object of the data objects, which refers to the first auto-created index.

[0076] In Example 17, the subject of any of Examples 14–16 includes the steps of receiving a second user command to create a second graph workspace for a first set of data, identifying a first auto-created index in the first set of data, and creating the second graph workspace by referencing the first auto-created index.

[0077] Example 18 is one or more non-temporary computer-readable media for storing computer-executable instructions, the instructions, when executed by a computing system, cause the computing system to perform an action, the action including receiving a first user command for creating a first graph workspace for a first set of data; determining a first missing index in the first set of data for the first graph workspace; automatically creating a first auto-created index in the first set of data for the first graph workspace based on the first missing index; and creating a first graph workspace by referencing the first auto-created index.

[0078] In Example 19, the subject of Example 18 includes receiving a second user command to drop a first graph workspace, referring to a first auto-generated index to identify the number of second graph workspaces, and dropping the first auto-generated index based on the fact that the number of second graph workspaces referring to the first auto-generated index is less than a threshold number.

[0079] In Example 20, in the subject of Example 19, identifying the number of second graph workspaces involves iterating through the data objects defined for the first set of data and incrementing a counter for each data object of the data objects, which references the first auto-generated index.

[0080] Example 21 is at least one machine-readable medium that, when executed by a processing circuit configuration, contains instructions that cause the processing circuit configuration to perform an operation to implement any of Examples 1 to 20.

[0081] Example 22 is an apparatus that includes means for implementing any of Examples 1 to 20.

[0082] Example 23 is a system for implementing any of Examples 1 through 20.

[0083] Example 24 is a method for implementing any of Examples 1 through 20.

[0084] Figure 7 is a block diagram 700 showing a software architecture 702 for a computing device in several examples. The software architecture 702 can be used with various hardware architectures, for example, as described herein. Figure 7 is merely a non-limiting illustration of the software architecture, and many other architectures may be implemented to facilitate the functionality described herein. A typical hardware layer 704 is shown, which can represent, for example, any of the computing devices referenced above. In some examples, the hardware layer 704 may be implemented according to the architecture of the computer system in Figure 8.

[0085] A typical hardware layer 704 comprises one or more processing units 706 having associated executable instructions 708. The executable instructions 708 represent executable instructions of the software architecture 702, including implementations of methods, modules, subsystems, and components described herein, and the hardware layer 704 may also include memory and / or storage modules 710, which also have executable instructions 708. The hardware layer 704 may also include other hardware represented by other hardware 712 and other hardware 722, which represent any other hardware of the hardware layer 704, such as other hardware shown as part of the software architecture 702.

[0086] In the architecture of Figure 7, the software architecture 702 can be conceptualized as a stack of layers, each providing specific functionality. For example, the software architecture 702 may include layers such as the operating system 714, libraries 716, a framework / middleware layer 718, an application 720, and a presentation layer 744. Operationally, the application 720 or other components within the layer may invoke an API call 724 through the software stack and, in response to the API call 724, access a response, return value, etc., indicated as a message 726. The layers shown are representative in nature, and not all software architectures have all layers. For example, some mobile or special-purpose operating systems may not provide a framework / middleware layer 718, while others may. Other software architectures may include additional or different layers.

[0087] The operating system 714 may manage hardware resources and provide common services. The operating system 714 may include, for example, a kernel 728, services 730, and drivers 732. The kernel 728 may act as an abstraction layer between hardware and other software layers. For example, the kernel 728 may be responsible for memory management, processor management (e.g., scheduling), component management, network connectivity, security settings, etc. Services 730 may provide other common services to other software layers. In some examples, services 730 may include interrupt services. Interrupt services may detect the reception of interrupts and, in response, cause the software architecture 702 to interrupt its current processing and execute an interrupt service routine (ISR) when the interrupt is accessed.

[0088] Driver 732 may be responsible for controlling or interfacing with the underlying hardware. For example, depending on the hardware configuration, driver 732 may include a display driver, camera driver, Bluetooth® driver, flash memory driver, serial communication driver (e.g., Universal Serial Bus (USB) driver), Wi-Fi® driver, Near Field Communication (NFC) driver, audio driver, power management driver, etc.

[0089] Library 716 may provide a common infrastructure that can be used by applications 720 or other components or layers. Library 716 typically provides functionality that makes it easier for other software modules to perform tasks than directly interface with the functionality of the underlying operating system 714 (e.g., kernel 728, services 730, or drivers 732). Library 716 may include system libraries 734 (e.g., the C standard library) that may provide functions such as memory allocation functions, string manipulation functions, and mathematical functions. Furthermore, Library 716 may include API libraries 736 such as media libraries (e.g., libraries to support the presentation and manipulation of various media formats such as MPEG4, H.264, MP3, AAC, AMR, JPG, PNG, etc.), graphics libraries (e.g., the OpenGL framework that can be used to render 2D and 3D in graphic content on a display), database libraries (e.g., SQLite that can provide various relational database functions), and web libraries (e.g., WebKit that can provide web browsing functionality). Library 716 may also include a wide variety of other libraries 738 for providing many other APIs to application 720 and other software components / modules.

[0090] The framework / middleware layer 718 may provide a higher level of common infrastructure that can be used by applications 720 or other software components / modules. For example, the framework / middleware layer 718 may provide various graphical user interface (GUI) functions, high-level resource management, high-level location services, etc. The framework / middleware layer 718 may provide a wide range of other APIs that can be used by applications 720 or other software components / modules, although some components / modules may be specific to a particular operating system or platform.

[0091] Application 720 includes either an embedded application 740 or a third-party application 742. Typical examples of embedded applications 740 may include, but are not limited to, a contacts application, a browser application, a book reader application, a location application, a media application, a messaging application, or a game application. Third-party applications 742 may include either embedded applications or a wide variety of other applications. In specific examples, a third-party application 742 (for example, an application developed by an entity other than the vendor of a particular platform using the Android® or iOS® Software Development Kit (SDK)) may be mobile software running on a mobile operating system such as iOS®, Android®, Windows® Phone, or another mobile computing device operating system. In this example, the third-party application 742 may call API calls 724 provided by the mobile operating system, such as operating system 714, to facilitate the functionality described herein.

[0092] Application 720 may use built-in operating system functions (e.g., kernel 728, services 730, or drivers 732), libraries (e.g., system libraries 734, API libraries 736, and other libraries 738), and framework / middleware layers 718 to create a user interface for interacting with the system's users. Alternatively or additionally, in some systems, user interaction may occur through presentation layers such as presentation layer 744. In these systems, the application / module "logic" can be separated from the application / module aspects that interact with the user.

[0093] Some software architectures use a virtual machine. In the example in Figure 7, this is represented by a virtual machine 748. The virtual machine creates a software environment in which applications / modules can run as if they were running on a hardware computing device. The virtual machine is hosted by a host operating system (operating system 714) and usually, though not always, has a virtual machine monitor 746, which manages the operation of the virtual machine and its interface with the host operating system (e.g., operating system 714). The software architecture runs within the virtual machine 748, including the operating system 750, libraries 752, frameworks / middleware 754, applications 756, or presentation layers 758. These layers of the software architecture running within the virtual machine 748 may be the same as, or different from, the corresponding layers described above.

[0094] Several examples are described herein, including logic or several components, modules, or mechanisms. A module or component may constitute either a software module / component (e.g., code embodied (1) on a non-temporary machine-readable medium, or (2) in a transmitted signal) or a hardware implementation module / component. A hardware implementation module / component is a tangible unit capable of performing several operations, and may be configured or arranged in a particular manner. In the examples, one or more computer systems (e.g., standalone, client, or server computer systems) or one or more hardware processors may be configured by software (e.g., an application or application portion) as hardware implementation modules / components that operate to perform some of the operations described herein.

[0095] In various examples, hardware implementation modules / components can be implemented mechanically or electronically. For example, a hardware implementation module / component may have a dedicated circuit configuration or logic that is permanently configured to perform certain operations (e.g., as a special-purpose processor such as a field-programmable gate array (FPGA) or application-specific integrated circuit (ASIC)). A hardware implementation module / component may also have a programmable logic or circuit configuration that is temporarily configured by software to perform certain operations (e.g., so as to be contained within a general-purpose processor or another programmable processor).

[0096] Therefore, the terms “hardware implementation module” or “hardware implementation component” should be understood to encompass tangible entities that are physically constructed to operate in a particular way or to perform some of the operations described herein, that are permanently configured (e.g., wired), or that are temporarily or briefly configured (e.g., programmed). Considering an example where a hardware implementation module / component is temporarily configured (e.g., programmed), each hardware implementation module / component does not need to be configured or instantiated at any given moment. For example, if a hardware implementation module / component comprises a general-purpose processor configured using software, the general-purpose processor may be configured as different hardware implementation modules / components at different times. The software, therefore, may configure the processor to configure a particular hardware implementation module / component at one moment and different hardware implementation modules / components at a different moment.

[0097] Hardware implementation modules / components can provide and receive information from other hardware implementation modules / components. Therefore, the hardware implementation modules / components described can be considered to be communicatively coupled. When various such hardware implementation modules / components exist simultaneously, communication may be carried out through signal transmission (e.g., via appropriate circuits and buses connecting the hardware implementation modules / components). In examples where multiple hardware implementation modules / components are configured or instantiated at different times, communication between such hardware implementation modules / components may be carried out, for example, through the storage and retrieval of information in memory structures that multiple hardware implementation modules / components have access to. For example, one hardware implementation module / component may perform an operation and store the output of that operation in a memory device to which it is communicatively coupled. Further hardware implementation modules / components may then, at a later time, access the memory device to retrieve and process the stored output.

[0098] Various operations of the exemplary methods described herein may be performed, at least in part, by one or more processors configured either temporarily (e.g., by software) or permanently to perform the relevant operations. Whether temporary or permanently configured, such processors may constitute processor implementation modules / components that operate to perform one or more operations or functions. The modules / components referred to herein may, in some examples, comprise processor implementation modules / components.

[0099] Similarly, the methods described herein may be processor implementations, at least in part. For example, at least some of the operations of the methods may be performed by one or more processors or processor implementation modules / components. Some implementations of the operations may be distributed across one or more processors, deployed across several machines rather than being confined to a single machine.

[0100] One or more processors may operate to support the performance of related operations in a “cloud computing” environment or as “software as a service (SaaS).” For example, at least some of the operations may be performed by a group of computers (as an example of machines including processors), and these operations may be accessible over a network (e.g., the Internet) and over one or more suitable interfaces (e.g., APIs).

[0101] The embodiments can be implemented in digital electronic circuit configurations, or in computer hardware, firmware, or software, or in combination thereof. The embodiments can also be implemented using computer program products, such as data processing devices, such as programmable processors, computers, or information carriers for execution by or control of the operation of multiple computers, for example, computer programs implemented in tangible form on machine-readable media.

[0102] Computer programs may be written in any form of programming language, including compiled or interpreted languages, and may be deployed in any form, such as as standalone programs or modules, including subroutines or other units suitable for use in a computing environment. Computer programs may be deployed to run on one computer or multiple computers in one location, or they may be distributed across multiple locations and interconnected by communication networks.

[0103] Figure 8 is a block diagram of a machine in an exemplary form representing a computer system 800 in which instruction 824 can be executed to cause the machine to implement one or more of the methodologies discussed herein. In alternative examples, the machine may operate as a standalone device or be connected to other machines (e.g., networked). In a networked deployment, the machine may operate as a server or client machine in a server-client network environment, or as a peer machine in a peer-to-peer (or distributed) network environment. The machine may be a personal computer (PC), tablet PC, set-top box (STB), personal digital assistant (PDA), cellular telephone, web appliance, network router, switch, or bridge, or any machine capable of executing instructions (sequential or otherwise) that specify the actions to be taken by that machine. Furthermore, although only a single machine is shown, the term “machine” also includes any collection of machines that individually or collectively execute one or more sets of instructions to implement one or more of the methodologies discussed herein.

[0104] An exemplary computer system 800 includes a processor 802 (e.g., a central processing unit (CPU), a GPU, or both), primary or main memory 804, and static memory 806, which communicate with each other via a bus 808. The computer system 800 may further include a video display unit 810 (e.g., a liquid crystal display (LCD) or a cathode ray tube (CRT)). The computer system 800 also includes an alphanumeric input device 812 (e.g., a keyboard or a touch-sensitive display screen), a UI navigation (or cursor control) device 814 (e.g., a mouse), a storage unit 816, a signal generation device 818 (e.g., a speaker), and a network interface device 820.

[0105] As used herein, the term “processor” can refer to any one or more circuits or virtual circuits (e.g., physical circuits emulated by logic running on an actual processor) that manipulate data values ​​in accordance with control signals (e.g., commands, opcodes, machine codes, control words, macro instructions, etc.) and produce corresponding output signals applied to operate a machine. A processor can include, for example, a central processing unit (CPU), a reduced instruction set computing (RISC) processor, a composite instruction set computing (CISC) processor, a graphics processing unit (GPU), a digital signal processor (DSP), a tensor processing unit (TPU), a neural processing unit (NPU), a vision processing unit (VPU), a machine learning accelerator, an artificial intelligence accelerator, an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), a radio frequency integrated circuit (RFIC), a neuromorphological processor, a quantum processor, or at least one of any combination thereof. A processor may also be a multicore processor having two or more independent processors (sometimes called “cores”) capable of executing instructions simultaneously. A multicore processor may contain multiple computing cores on a single integrated circuit die, each capable of independently executing program instructions in parallel. Parallel processing on a multicore processor can be implemented by architectures such as superscalar, VLIW, vector processing, or SIMD, allowing each core to run separate instruction streams simultaneously. A processor can be emulated as a virtual processor or virtual circuit by software running on a physical processor. A virtual processor can behave like an independent processor but is implemented in software rather than hardware.

[0106] The storage unit 816 includes a machine-readable medium 822 in which one or more sets of data structures and instructions 824 (e.g., software) that embody or are used by any one or more of the methodologies or functions described herein are stored. The instructions 824 may be entirely or at least partially in the main memory 804 or the processor 802 while being executed by the computer system 800, and the main memory 804 and the processor 802 also constitute the machine-readable medium 822, respectively.

[0107] While the machine-readable medium 822 is shown to be a single medium according to some examples, the term “machine-readable medium” may include a single medium or multiple mediums (e.g., a centralized or distributed database, or associated caches and servers) that store one or more instructions 824 or data structures. The term “machine-readable medium” shall also include any tangible medium capable of storing, encoding, or carrying instructions 824 for machine execution, enabling a machine to execute one or more of the methodologies of this disclosure, or storing, encoding, or carrying data structures used by or associated with such instructions 824. The term “machine-readable medium” therefore includes, but is not limited to, solid-state memory, as well as optical and magnetic media. Specific examples of machine-readable media 822 include, for example, non-volatile memory including semiconductor memory devices such as erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), and flash memory devices; magnetic disks such as internal hard disks and removable disks; magneto-optical disks; and compact disc read-only memory (CD-ROM) and digital multipurpose disc read-only memory (DVD-ROM) disks. Machine-readable media are not transmission media.

[0108] Instructions 824 may further be transmitted or received over a communication network 826 using a transmission medium. Instructions 824 may be transmitted using a network interface device 820 and one of several well-known transport protocols (e.g., Hypertext Transport Protocol (HTTP)). Examples of communication networks include local area networks (LANs), wide area networks (WANs), the Internet, mobile telephone networks, simple old telephone (POTS) networks, and wireless data networks (e.g., Wi-Fi and Wi-Max networks). The term “transmission medium” includes any intangible medium capable of storing, encoding, or carrying instructions 824 for machine execution, and includes digital or analog communication signals or other intangible mediums to facilitate communication of such software.

[0109] Specific examples are described herein, but it will be apparent that various modifications and changes may be made to these examples without departing from the broader intent and scope of this disclosure. Therefore, this specification and the drawings should be considered illustrative rather than restrictive. The accompanying drawings, forming part of this specification, illustrate, not restrictively, specific examples of how the subject matter may be put into practice. The examples shown are described in sufficient detail to enable those skilled in the art to put the teachings disclosed herein into practice. Other examples may be used and derived therefrom, so that structural and logical substitutions and modifications may be made without departing from the scope of this disclosure. This detailed description should therefore not be interpreted restrictively, and the scope of the various examples is defined only by the accompanying claims, together with the entire scope of equivalents to which such claims are entitled.

[0110] Such examples of the subject matter may be referred to herein, individually or collectively, by the term “Examples,” for convenience only, and without any intention to spontaneously limit the scope of this application to any single example or concept, even if multiple examples are actually disclosed. Therefore, please understand that any arrangements calculated to achieve the same purpose, although specific examples are shown and described herein, may be used in place of the specific examples shown. This disclosure is intended to cover all adaptations or variations of various examples. A careful examination of the above description will reveal to those skilled in the art combinations of the above examples with other examples not specifically described herein.

[0111] Some parts of the subject matter discussed herein may be presented by algorithms or symbolic representations of operations on data stored as bits or binary digital signals in machine memory (e.g., computer memory). Such algorithms or symbolic representations are examples of techniques used by those skilled in the art of data processing to communicate the essence of their work to others skilled in the art. As used herein, “algorithm” is a self-consistent set of operations or similar processes that produce a desired result. In this context, an algorithm or operation involves the physical handling of a physical quantity. Generally, though not always necessary, such quantities may take the form of electrical, magnetic, or optical signals that can be stored, accessed, transferred, combined, compared, or otherwise handled by a machine. For reasons of common usage, it is sometimes convenient to refer to such signals using words such as “data,” “content,” “bit,” “value,” “element,” “symbol,” “character,” “term,” “digit,” and “numerical value.” These words, however, are merely convenient labels and should be associated with appropriate physical quantities.

[0112] Unless otherwise specified, discussions herein using words such as “process,” “calculate,” “calculate,” “determine,” “present,” and “display” may refer to the actions or processes of a machine (e.g., a computer) that manipulates or transforms data represented as physical (e.g., electronic, magnetic, or optical) quantities within one or more memories (e.g., volatile memory, non-volatile memory, or any suitable combination thereof), registers, or other mechanical components that receive, store, transmit, or display information. Furthermore, unless otherwise specified, the terms “a” and “an” are used herein to include one or more instances, as is common in patent documents.

[0113] Unless the context clearly indicates otherwise, words such as “comprise,” “comprising,” etc., throughout the description and claims should be interpreted in a comprehensive sense, for example, “including, but not limited to,” rather than in an exclusive or exhaustive sense. As used herein, the terms “connected,” “joined,” or any variation thereof, mean any connection or joining, direct or indirect, between two or more elements, and the joining or connection between elements may be physical, logical, or a combination thereof. Furthermore, when used in this application, the words “in this specification,” “above,” “below,” and words of similar intent refer to this application as a whole, not to any particular part thereof. Where the context allows, words used in the singular or plural may also include the plural or singular, respectively. Unless otherwise indicated, the word “or,” referring to a list of two or more items, covers all interpretations of that word: any one of the items in the list, all of the items in the list, and any combination of the items in the list.

[0114] Some examples, for instance, shown in the drawings, include specific sequences of operations, but these sequences may be modified without departing from the scope of this disclosure. For example, some of the operations shown may be performed in parallel or in different sequences that do not substantially affect the function, as described in the examples. In other examples, different components of an exemplary device or system implementing an exemplary method may perform the function at substantially the same time or in a specific sequence. The term “operation” is used to refer to elements in the drawings of this disclosure for ease of reference, and it will be understood that each “operation” may identify one or more operations, processes, actions, or steps, which may be performed by one or more components. [Explanation of Symbols]

[0115] 102 Network 104 Server System 106 User Devices 112 Programmatic Clients 110 Web Clients 114 Web Interface 116 App Interface 118 External Servers 120 External applications 122 Application Server 124 Application Programming Interface (API) Servers 126 Web Servers 128 Supply Chain Platforms 130 Graph Workspace System 132 Database Servers 134 Databases 202 Create Module 204 Management Module 206 Replacement Module 208 Export / Import Module 210 Metadata Modules 212 Privileged Modules 306 Graph Workspace System 314 Graph Workspace A 316 Graph Workspace B 404 Graph Workspace System 412 Graph Workspace A 502 Graph Workspace System 510 Graph Workspace 552 Graph Workspace System 702 Software Architecture 704 Hardware Layer 706 Processing Units 712 Other Hardware 714 Operating Systems 716 Library 718 Framework / Middleware Layer 720 applications 722 Other Hardware 728 kernel 730 Services 732 Driver 734 System Library 736 API libraries 738 Other Libraries 740 Built-in Applications 742 Third-party applications 744 Presentation Layer 746 Virtual Machine Monitor 748 Virtual Machine 758 Presentation Layer 800 Computer Systems 802 Processor 804 Primary or Main Memory 806 Static Memory 808 Bus 810 Video Display Unit 812 Alphanumeric input devices 814 UI Navigation Devices 816 Memory Unit 818 Signal Generating Devices 820 Network Interface Devices 822 Machine-readable media 826 Communication Network

Claims

1. At least one memory for storing instructions, One or more processors configured by the instructions to perform an operation and The operation is provided, Receiving a first user command to create a first graph workspace for a first set of data, Determining a first missing index in the first set of data for the first graph workspace, Based on the aforementioned first missing index, a first automatically generated index is automatically created in the first set of data for the first graph workspace, The first graph workspace is created by referring to the first automatically generated index. A system that includes this.

2. The aforementioned operation is, Receiving a second user command to drop the first graph workspace, By referring to the first automatically generated index described above, the number of second graph workspaces is identified, Based on the fact that the number of second graph workspaces referencing the first automatically generated index is less than a threshold number, the first automatically generated index is dropped. The system according to claim 1, further comprising:

3. Identifying the aforementioned number in the second graph workspace is: Iterating through the data object defined for the first data of the aforementioned data, Incrementing a counter for each data object of the data object, which references the first automatically generated index mentioned above. The system according to claim 2, including the above.

4. The aforementioned operation is, Receiving a second user command to create a second graph workspace for the first set of the aforementioned data, Identifying the first automatically generated index in the first set of data, The second graph workspace is created by referring to the first automatically generated index mentioned above. The system according to claim 1, further comprising:

5. The aforementioned operation is, Determining a first existing index in the first set of data for the first graph workspace, wherein the first existing index is not identified in the first user command, The first graph workspace is made to reference the first existing index and the first automatically created index. The system according to claim 1, further comprising:

6. The first automatically generated index identifies the vertices in the first set of data, and the operation is as follows: The method involves automatically creating a second automatically generated index, wherein the second automatically generated index identifies the connections between the vertices in the first data, and the second automatically generated index references the first automatically generated index. The first graph workspace is made to reference the first automatically generated index and the second automatically generated index. The system according to claim 1, further comprising:

7. The aforementioned operation is, Receiving a second user command to replace the first graph workspace with a second graph workspace for a second set of data, Determining a second missing index in the second set of data for the second graph workspace, Based on the aforementioned second missing index, a second automatically generated index is automatically created in the second set of data for the second graph workspace, The second graph workspace is created by referring to the second automatically generated index, Dropping the first graph workspace and the first automatically generated index The system according to claim 1, further comprising:

8. The aforementioned operation is, Receiving a second user command to export the first graph workspace, To generate a binary including the first graph workspace and the first set of data, wherein the binary is generated excluding the first automatically generated index. The system according to claim 1, further comprising:

9. The aforementioned operation is, Receiving a second user command to import a second graph workspace, Receiving a binary containing the second graph workspace and a second set of data, To determine the second missing index in the aforementioned binary, The process involves automatically creating a second automatically generated index in a second set of the aforementioned data, wherein the second graph workspace references the second automatically generated index. The system according to claim 1, further comprising:

10. The aforementioned operation is, Locking the first set of data based on the first automatically generated index, Based on the creation of the first automatically generated index, the first set of data is unlocked. The system according to claim 1, further comprising:

11. The aforementioned operation is, The system according to claim 1, further comprising determining that the user who gave the first user command has the privilege to create an index in the first set of data, and that creating the first graph workspace is based on the determination that the user has the privilege to create an index in the first set of data.

12. The aforementioned operation is, It is determined that the user who issued the first user command does not have the privilege to drop the index in the first set of data, Rejecting a second user command to replace the aforementioned first graph workspace with a second graph workspace for a second set of data. The system according to claim 1, further comprising:

13. The system according to claim 1, wherein the first automatically generated index follows a naming scheme that identifies the first automatically generated index as a system index.

14. The steps include receiving a first user command to create a first graph workspace for a first set of data, The steps include determining a first missing index in the first set of data for the first graph workspace, The steps include: automatically creating a first auto-created index in a first set of data for the first graph workspace based on the first missing index; The steps include creating the first graph workspace by referring to the first automatically generated index and Methods that include...

15. The steps include receiving a second user command to drop the first graph workspace, The steps include: identifying the number of second graph workspaces by referring to the first automatically generated index described above; The steps include dropping the first automatically generated index based on the number of second graph workspaces referencing the first automatically generated index being less than a threshold number, and The method according to claim 14, further comprising:

16. The step of identifying the number in the second graph workspace is: The steps include iterating through a data object defined for the first set of data, The steps include: incrementing a counter for each data object of the data object, which references the first automatically generated index; The method according to claim 15, including the method described in claim 15.

17. The steps include receiving a second user command to create a second graph workspace for the first set of data, The steps include identifying the first automatically generated index in the first set of data, The steps include creating the second graph workspace by referring to the first automatically generated index and The method according to claim 14, further comprising:

18. One or more non-temporary computer-readable media for storing computer executable instructions, wherein, when executed by a computing system, the instructions cause the computing system to perform an action, and the action is Receiving a first user command to create a first graph workspace for a first set of data, Determining a first missing index in the first set of data for the first graph workspace, Based on the aforementioned first missing index, a first automatically generated index is automatically created in the first set of data for the first graph workspace, The first graph workspace is created by referring to the first automatically generated index. One or more non-temporary computer-readable media, including [the specified text].

19. The aforementioned operation is, Receiving a second user command to drop the first graph workspace, By referring to the first automatically generated index described above, the number of second graph workspaces is identified, Based on the fact that the number of second graph workspaces referencing the first automatically generated index is less than a threshold number, the first automatically generated index is dropped. One or more non-temporary computer-readable media according to claim 18, further comprising:

20. Identifying the aforementioned number in the second graph workspace is: Iterating through the data objects defined for the first set of the aforementioned data, Incrementing a counter for each data object of the data object, which references the first automatically generated index mentioned above. One or more non-temporary computer-readable media according to claim 19, including the following:

Images