Graph workspace using system-managed indices

Abstract

Systems and methods described herein relate to automatic creation and management of indices for graph workareas. A missing index of a graph workspace is identified and automatically created as appropriate. The automatically created index is re-used for other graph working areas working on the same data set. Automatic creation and management of an index of a graph workspace allows creation of a graph workspace with a single user command rather than multiple user commands involving creation of an index prior to creation of the graph workspace.

Description

Technical Field

[0001] This article generally covers database technologies. More specifically, but not exclusively, it covers the automatic creation and management of graph workspaces and associated indexes. Background Technology

[0002] Graph workspaces in database systems offer sophisticated capabilities for processing data, allowing users to perform analyses of complex networks. For example, graph workspaces are used to map complex routing networks, such as supply chains, 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 identify interaction patterns within them. However, as computer technology continues to advance, the data utilized in graph workspaces becomes increasingly complex. Therefore, there is a ongoing need for technological improvements in database technologies to address these challenges. Attached Figure Description

[0003] For illustrative purposes and not for limitation, some examples are shown in the accompanying drawings. In drawings that are not necessarily drawn to scale, the same numbers may describe similar components in different views or examples. It should be understood that additional and alternative examples are possible without departing from the principles of the subject matter described herein.

[0004] Figure 1 The diagram illustrates a network environment including a graph workspace system based on some examples.

[0005] Figure 2 It is a block diagram of the components of a workspace system based on some examples.

[0006] Figure 3 This is a block diagram illustrating an example of creating a graph workspace based on some examples.

[0007] Figure 4 This is a block diagram showing an example of a replacement workspace based on some examples.

[0008] Figures 5A to 5B This is a block diagram showing an example of an export and import workspace based on some examples.

[0009] Figures 6A to 6B This is a flowchart illustrating example methods based on some examples.

[0010] Figure 7 This is a block diagram illustrating a software architecture for a computing device, based on some examples.

[0011] Figure 8 It is a block diagram of a machine in the form of a computer system based on some examples, in which instructions can be executed to cause the machine to perform any one or more of the methods discussed herein. Detailed Implementation

[0012] Typically, a graph workspace is a catalog object (e.g., a database object) representing an interconnected dataset (e.g., a collection of data, a table of data) within a database. Graph workspaces use vertices and edges to provide a structured representation of the dataset. By providing this structured representation, graph workspaces support various graph analysis capabilities, such as performing traversals and analyzing relationships. To leverage these graph analysis capabilities, graph workspaces are created based on hash indexes (e.g., vertex indexes) and adjacency indexes (e.g., edge indexes), and these indexes support the graph analysis capabilities of the graph workspace. Because graph workspaces are created based on hash and adjacency indexes, attempts to create a graph workspace before creating the hash and adjacency indexes will fail. Similarly, because hash and adjacency indexes support the graph analysis capabilities of graph workspaces, if a hash or adjacency index is discarded or deleted, the graph workspace based on that hash or adjacency index becomes invalid (e.g., inoperable). Therefore, database technologies that use graph workspaces face technical challenges arising from their dependence on hash and adjacency indexes.

[0013] The topics described in this article address these and other technical challenges in the field of database technology. As an overview, the topics described in this article provide 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 instead of multiple user commands involving the creation of hash and adjacency indexes before the graph workspace itself. Therefore, by providing automated index creation and management, database technology is improved by preventing failures in graph workspace creation and increasing ease of use.

[0014] In some examples, the graph workspace system, in response to a user command to create a graph workspace for a dataset, identifies existing indexes on the dataset (e.g., user-created indexes), and automatically creates the indexes accordingly. For instance, the graph workspace system receives a user command to create a graph workspace for a dataset. In response, the system identifies whether a hash index and an adjacency index have already been created for the dataset. In this example, a hash index has been created for the dataset, but an adjacency index has not. Based on the absence of an adjacency index for the dataset, the graph workspace system automatically creates the adjacency index. The graph workspace is then created using the hash index and the automatically created adjacency index. As this example illustrates, the automatic creation of indexes advantageously prevents errors during graph workspace creation while avoiding the creation of irrelevant indexes.

[0015] In some examples, automatically created indexes (e.g., system indexes) for graph workspaces are reused in the creation of subsequent graph workspaces. For instance, in response to a first user command to create a first graph workspace, a first graph workspace for a dataset is created. In this example, hash indexes and adjacency indexes have not yet been created. In response to a user command to create the first graph workspace, hash indexes and adjacency indexes are automatically created. In response to a second user command to create a second graph workspace, a second graph workspace for the dataset is created. Since the first and second graph workspaces are created for the same dataset, the automatically created hash indexes and automatically created adjacency indexes can be referenced to create the second graph workspace. As this example illustrates, through the automatic creation and management of indexes, indexes are automatically created and reused in graph workspaces, thereby improving the use of computational resources.

[0016] In some examples, automatically created indexes (e.g., system indexes) of a graph workspace are discarded in response to the creation of an index for that workspace, and based on the number of graph workspaces referencing the automatically created indexes. For example, hash indexes and adjacency indexes are automatically created in response to a user command to create a graph workspace for a dataset. When a graph workspace is discarded, the graph workspaces referencing the automatically created hash indexes and adjacency indexes are identified. If the number of graph workspaces referencing the automatically created hash indexes and adjacency indexes is less than a threshold number (e.g., one), the automatically created hash indexes and adjacency indexes are automatically discarded. For example, if the number of graph workspaces referencing the automatically created hash indexes and adjacency indexes is zero, then there are no graph workspaces referencing the automatically created hash indexes and adjacency indexes. As this example illustrates, through the automatic creation and management of indexes, indexes are automatically created and automatically discarded, thereby freeing up computational resources that would otherwise not be used.

[0017] In some examples, the graph workspace system facilitates the replacement of 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 an adjacency index have already been created for the first data set. In this example, no hash index and adjacency index have been created. Therefore, the graph workspace system automatically creates the hash index and adjacency index. The automatically created hash index and automatically created adjacency index are referenced to create the graph workspace. Subsequently, in response to a second user command to create a graph workspace for the second data set, the graph workspace is replaced. To facilitate the replacement of the graph workspace, the graph workspace system identifies whether a hash index and an adjacency index have already been created for the second data set, and automatically creates the hash index and adjacency index as appropriate. Furthermore, the graph workspace system identifies whether the hash index and automatically created adjacency index automatically created for the first data set are referenced by any other graph workspace, and discards the hash index and automatically created adjacency index automatically created for the first data set as appropriate. The graph workspace is replaced with the hash index and adjacency index of the second data set. As this example illustrates, by managing automatically created indexes, the graph workspace system optimizes the use of computational resources by automatically creating and discarding indexes as they are used.

[0018] In some examples, the graph workspace system manages the indexes used by the graph workspace for export and import operations. For instance, a first user exports a graph workspace referencing 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 discarded due to a lack of user privileges. When a second user imports the graph workspace and hash index, the unexported adjacency index is automatically created. As this example illustrates, managing automatically created indexes in export and import operations maintains explicit user privileges on objects, thus avoiding situations that could lead to the loss of computational resources. This paper provides further details regarding the automatic creation and management of indexes in graph workspaces.

[0019] Figure 1 This is an illustrated representation of a networked computing environment 100 in which some examples of this disclosure may be implemented or deployed. One or more servers in server system 104 provide server-side functionality to a networked device via network 102, the networked device having an example form of a user device 106 accessed by user 108. A network client 110 (e.g., a browser) or a programming client 112 (e.g., an "application") may be hosted and executed on user device 106.

[0020] Application Programming Interface (API) server 124 and web (network) server 126 provide corresponding programming interfaces and web interfaces to the components of server system 104. Application-specific server 122 hosts supply chain platform 128 and graph workspace system 130, each of which includes a component, module, or application. Note that in some examples, supply chain platform 128 and graph workspace system 130 may be hosted via separate application servers.

[0021] User equipment 106 can communicate with application server 122 via a web interface supported by web server 126 or via a programming interface provided by API server 124. It should be understood that, although... Figure 1 Only a single user device 106 is shown herein, but in some examples, multiple user devices may be communicatively coupled to server system 104. Furthermore, while some functions may be described herein as being performed at user device 106 (e.g., network client 110 or programming client 112) or server system 104, the location of certain functions within user device 106 or server system 104 may be a design choice. Additionally, while some functions may be described herein as being performed at a specific system (such as graph workspace system 130), the location of functions may also be a design choice. For example, some functions described with reference to graph workspace system 130 may be performed by supply chain platform 128 or by both graph workspace system 130 and supply chain platform 128.

[0022] Application server 122 is communicatively coupled to database server 132, facilitating access to one or more information repositories, such as database 134. In some examples, database 134 includes storage devices for storing information to be accessed, processed, modified, or deleted by supply chain platform 128 or graph workspace system 130.

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

[0024] Supply chain platform 128 can facilitate the tracking, coordination, and execution of supply chain activities, such as procurement and distribution. In some examples, supply chain platform 128 allows organizations to streamline and digitize their procurement lifecycle using a cloud-based architecture, integrating with database 134 for rapid processing of large datasets and real-time insights. Various data objects are created and used to manage and operate supply chain platform 128. For example, various data objects corresponding to real-world business entities or objects can be mapped to tables in database 134, and such tables (and therefore their data objects) can be interconnected based on hierarchy, dependency, or reference.

[0025] In some examples, supply chain platform 128 integrates with other systems to enhance its functionality, such as interfacing with graph workspace system 130. For instance, supply chain platform 128 may leverage graph workspace system 130 to provide graph analytics capabilities.

[0026] In some examples, graph workspace system 130 is configured to create graph workspaces for datasets within database 134. Graph workspace system 130 automatically creates indexes to facilitate the creation of graph workspaces. Graph workspace system 130 manages the automatically created indexes and graph workspaces in operations such as create, delete, export, and import.

[0027] For example, graph workspace system 130 processes requests to create graph workspaces for datasets within database 134. In some examples, supply chain platform 128 and graph workspace system 130 work together to process user commands to create graph workspaces, create indexes, export graph workspaces, import graph workspaces, discard graph workspaces, and discard indexes.

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

[0029] In some examples, application server 122 is part of a cloud-based platform provided by a software provider that allows user 108 to utilize tools from supply chain platform 128, graph workspace system 130, and (where applicable) other systems or subsystems (e.g., human resources system, ERP system, or accounting system as described above).

[0030] One or more of the application server 122, database server 132, API server 124, web server 126, and supply chain platform 128 can each be implemented wholly or partially in the computer system, as shown in the following reference. Figure 8As described above. In some examples, external applications (which may be third-party applications or other applications provided by the same software vendor), such as external server 118 running on external application 120, may communicate with application server 122 via a programming interface provided by API server 124. For example, a third-party application may support one or more features or functions on a website or platform hosted by a third party, or may perform certain methods and provide input or output information to application server 122 for further processing.

[0031] Network 102 can be any network that enables communication between or within machines, databases, and devices. Therefore, network 102 can 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 components constituting a private network, a public network (e.g., the Internet), or any suitable combination thereof.

[0032] Figure 2 This is shown based on some examples. Figure 1 A block diagram of the components of the workspace system 130. Figure 2 In the diagram, the workspace system 130 is shown as including 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.

[0033] Module 202 is responsible for creating the graph workspace and the indexes referenced by it. Typically, a graph workspace is a catalog object representing a dataset (e.g., a collection of data, a table) used to perform graph analysis. The graph workspace references hash indices (e.g., vertex index, vertex table) that identify the vertices in the dataset. It also references adjacency indices (e.g., edge index, edge table) that identify connections (e.g., edges) between adjacent vertices in the dataset. The adjacency indexes reference hash indices of the vertices in the dataset. They use references to source vertices and target vertices in the dataset to identify edges between adjacent vertices, where each edge is defined as the edge between the source and target vertices. Since the graph workspace references hash indices and adjacency indices, these are prerequisites for creating the graph workspace.

[0034] In some examples, 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, the user command may include the name of the graph workspace, a data set identifier for the data set for which the graph workspace is to be created, a hash index identifier containing hash indices of the vertex data of the graph workspace, an adjacency index identifier containing adjacency indices of the edge data of the graph workspace, a source vertex identifier containing references to source vertices within the vertex data, a target vertex identifier containing references to target vertices within the vertex data, and a type identifier identifying the information types of the edges and vertices of the graph workspace. For example, the user command to create a graph workspace is:

[0035] Create a graph workspace S2.WS

[0036] Set S1.col1

[0037] vertex

[0038] Key "uid1"

[0039] side

[0040] Key "uid2"

[0041] Source "src"

[0042] Target "tgt"

[0043] Type "typ";

[0044] Where “S2.WS” is the name of the graph workspace, “S1.col1” is the data set identifier, “uid1” is the hash index identifier, “uid2” is the adjacency index identifier, “src” is the source vertex identifier, “tgt” is the destination vertex identifier, and “typ” is the type identifier. Here, the example user command is a single statement that creates the graph workspace.

[0045] In response to a user command to create a graph workspace, creation module 202 identifies hash indices and adjacency indices based on hash index identifiers, adjacency index identifiers, source vertex identifiers, target vertex identifiers, and type identifiers. If an existing hash index corresponding to the hash index identifier and type identifier has already been created (e.g., a user-created hash index or an automatically created hash index), the graph workspace references the existing hash index. If an existing adjacency index corresponding to the adjacency index identifier, source vertex identifier, target vertex identifier, and type identifier has already been created (e.g., a user-created adjacency index or an automatically created adjacency index), the graph workspace references the existing adjacency index. If no hash index corresponding to the hash index identifier and type identifier has been created, a hash index is automatically created for the graph workspace to reference. If no adjacency index corresponding to the adjacency index identifier, source vertex identifier, target vertex identifier, and type identifier has been created, an adjacency index is automatically created for the graph workspace to reference.

[0046] The creation module 202 uses a naming scheme that identifies hash indexes or adjacency indexes as automatically created indexes to create hash indexes or adjacency indexes. For example, automatically created hash indexes have the prefix "_SYS_HASH_INDEX_". Automatically created adjacency indexes have the prefix "_SYS_ADJACENCY_INDEX_". The naming scheme allows the graph workspace system 130 to identify automatically created indexes as system indexes without appending additional metadata to them. In some examples, user-defined indexes that follow the naming scheme are prevented from being created. Therefore, the naming scheme clearly identifies which indexes are created in response to user commands and which are created automatically.

[0047] In some examples, users are prevented from directly referencing automatically created indexes. For instance, users creating a graph workspace are prevented from referencing automatically created indexes in user commands to create the workspace. Similarly, users are prevented from using a discard command to discard automatically created indexes. This allows the graph workspace system 130 to maintain control over automatically created indexes.

[0048] In some examples, graph workspaces, indexes, and collections can belong to different schemas. Typically, a schema is a namespace used to organize related database objects. For example, a graph workspace created in response to a user command belongs to a user-defined schema. The collection on which the graph workspace is created belongs to a different user-defined schema. An automatically created index created in response to a user command belongs to the schema of the collection on which the graph workspace is created.

[0049] The owner of the data set on which the automatically created index was created is assigned the ownership of the automatically created index. This links the automatically created index to the data set, such that if the owner of the data set discards the data set, any automatically created indexes created on the data set are also discarded. If the owner of the data set discards the data set, all database objects belonging to that user, including the automatically created indexes, are discarded.

[0050] In some examples, the number of hash indexes and adjacency indexes created for a dataset is limited to a threshold number (e.g., one). For example, for a dataset, only one hash index and only one adjacency index are allowed. The graph workspace created for the dataset will use an existing hash index created for the dataset, or an automatically created hash index for the dataset if no existing hash index exists. The graph workspace will use an existing adjacency index created for the dataset, or an automatically created adjacency index for the dataset if no existing adjacency index exists. In this example, there is a threshold allowing one hash index and one adjacency index for the dataset. Therefore, all users creating graph workspaces for the dataset use the same hash index and the same adjacency index.

[0051] Management module 204 is responsible for maintaining the indexes of the graph workspaces. In some examples, indexes automatically created for a dataset 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 dataset, a hash index and an adjacency index for the dataset are automatically created. Based on the determination that no existing hash index and no existing adjacency index for the dataset exist, a hash index and an adjacency index are automatically created. In this example, in response to a second user command from a second user who does not have privileges to access the first graph workspace and is unaware of the first graph workspace, a second graph workspace for the dataset is created. The automatically created hash index and automatically created adjacency index are recognized as existing hash indexes and existing adjacency indexes for the dataset. The automatically created hash index and automatically created adjacency index are referenced to create the second graph workspace. As shown in this example, management module 204 prevents redundant index creation, thereby improving the use of computing resources.

[0052] In some examples, automatically created indexes are deleted or discarded when all graph workspaces referencing them are discarded. For example, the first and second graph workspaces use the same automatically created hash index and the same automatically created adjacency index for the dataset. In response to a user command to discard the first graph workspace, the first graph workspace is discarded. When the first graph workspace is discarded, the automatically created hash index and automatically created adjacency index are checked to determine if any graph workspace references either the automatically created hash index or the automatically created adjacency index. In this example, it is determined that the second graph workspace is referencing both the automatically created hash index and the automatically created adjacency index. Based on this determination, when the first graph workspace is discarded, the automatically created hash index and the automatically created adjacency index are retained. Continuing with this example, in response to a user command to discard the second graph workspace, the second graph workspace is discarded. When the second graph workspace is discarded, the automatically created hash index and the automatically created adjacency index are checked to determine if any graph workspace references either the automatically created hash index or the automatically created adjacency index. Here, it is determined that after discarding the second graph workspace, no graph workspace references either the automatically created hash index or the automatically created adjacency index. Based on this determination, when discarding the second graph workspace, the automatically created hash index and the automatically created adjacency index are also discarded.

[0053] In some examples, management module 204 determines whether automatically created indexes for a data set are referenced by the set's graph workspaces by iterating through the data objects defined for the data set. For example, when discarding a graph workspace for a data set, management module 204 iterates through the data set's metadata to identify other graph workspaces defined for the data set. For each such graph workspace, it determines whether the graph workspace uses an automatically created hash index or an automatically created adjacency index created for the graph workspace. For each graph workspace using an automatically created index, a counter for the automatically created index is incremented. A counter of one or more after iterating through each graph workspace indicates that the automatically created index is in use. A counter of zero after iterating through each graph workspace indicates that the automatically created index is no longer in use. After iterating through the graph workspaces of the data set for which automatically created indexes were created, the automatically created indexes can be discarded when the counter associated with the automatically created index is zero. By iterating through the graph workspaces when discarding them, it is not necessary to maintain a persistent counter for each automatically created index. In some examples, maintaining a persistent counter for each automatically created index reduces computational resource usage at the cost of maintaining additional metadata. Metadata migration operations may be involved when the system is updated to support additional metadata.

[0054] In some examples, the management module 204 locks the data collection on which automatically created indexes are built. The data collection is locked to prevent modification, as modification could lead to a potential deadlock, causing data definition language statements to fail. Once the indexes are created, the data collection is unlocked and can be modified.

[0055] Replacement module 206 is responsible for replacing graph workspaces to work on different datasets. In response to a user command to create a graph workspace using the name of an existing graph workspace, the graph workspace is replaced. The created graph workspace replaces the existing graph workspace. For example, the user provides a user command to create a graph workspace with the name of an existing graph workspace for a first dataset. The user command includes a dataset identifier specifying a second dataset. In response to the user command, a graph workspace for the second dataset is created. If the second dataset does not have an existing hash index, a hash index for the second dataset is automatically created. If the second dataset does not have an existing adjacency index, an adjacency index for the second dataset is automatically created. The automatically created hash index and the automatically created adjacency index are referenced to create the graph workspace for the second dataset. In response to a user command, the graph workspace for the first dataset is discarded. If the graph workspace for the first dataset references the automatically created hash index and no other graph workspace references the automatically created hash index, the automatically created hash index is discarded. If a graph workspace in the second data set references an automatically created adjacency index, and no other graph workspace references an automatically created adjacency index, then the automatically created adjacency index is discarded.

[0056] The Export / Import module 208 is responsible for exporting and importing graph workspaces. In some examples, automatically created indexes are not exported with the exported graph workspace. User-created indexes and other basic objects (e.g., data sets) are exported with the exported graph workspace. Preventing automatically created indexes from being exported avoids situations where users import indexes that cannot be discarded. For example, a user provides a user command to create a graph workspace on a data set that has no existing hash index and no existing adjacency index. In response to the user command, hash indexes and adjacency indexes are automatically created. The automatically created hash indexes and automatically created adjacency indexes are referenced to create the graph workspace. In this example, a user provides a user command to export the graph workspace. In response to the user command, the graph workspace and the data set for which the graph workspace is created are exported. The automatically created hash indexes and automatically created adjacency indexes are not included in the export (e.g., excluded from the export).

[0057] Because automatically created indexes are not exported with the exported graph workspace (e.g., excluded from the exported graph workspace), indexes are automatically created for imported graph workspaces with missing indexes. Automatically created indexes are managed by the system that imports the graph workspace being imported and can be discarded when they are no longer needed (e.g., the imported graph workspace is discarded). For example, a graph workspace referencing automatically created hash and adjacency indexes is exported to the system. In this example, the graph workspace and the dataset for which the graph workspace was created are exported to the system. The automatically created hash and adjacency indexes are not exported to the system. The system imports the graph workspace and the dataset. Here, the dataset has no hash index and no adjacency index, so the system automatically creates hash and adjacency indexes for the dataset. The imported graph workspace references the automatically created hash and adjacency indexes.

[0058] Metadata module 210 is responsible for identifying and providing access to metadata associated with the graph workspace. For example, the metadata of the graph workspace includes:

[0059] • Entity type: Specifies the type of entity in the graph workspace (e.g., vertex, edge);

[0060] • Entity schema name: Specifies the name of the schema in which the entity table resides;

[0061] • Entity table name: Specifies the name of the entity table containing vertex or edge data;

[0062] • Entity column name: Specifies the name of the column in the entity table;

[0063] • Entity Roles: Specifies the roles (e.g., key, source, target, type) listed in the graph workspace.

[0064] • Referenced pattern name: Specifies the pattern name of the vertex table referenced by the edge table for the source vertex and the target vertex;

[0065] • Referenced table name: Specifies the name of the vertex table referenced by the edge table for the source vertex and the target vertex.

[0066] In some examples, the metadata associated with a graph workspace referencing a user-created index is the same as the metadata associated with a graph workspace referencing an automatically created index. That is, graph workspaces referencing automatically created indexes do not use additional metadata to track dependencies on automatically created indexes. By following the naming scheme of automatically created indexes and traversing the metadata when discarding graph workspaces, automatically created indexes are maintained and discarded when no longer in use.

[0067] Privileged module 212 is responsible for processing user commands used to create graph workspaces based on user privileges. In some examples, if the user providing the command does not have the user privilege to create an index on a collection, the user command to create a graph workspace for the collection is rejected. This prevents a user without the user privilege to create an index on a collection from causing the automatically created index to be created for the collection. In some examples, if the user providing the command does not have the user privilege to discard an index on a collection, the user command to discard the graph workspace of the collection is rejected. This prevents a user without the user privilege to discard an index on a collection from causing the automatically created index to be discarded. In some examples, if the user providing the command does not have the user privilege to discard an index, the user command to replace the graph workspace of the collection is rejected. This prevents a situation where the graph workspace is discarded due to replacement, but the automatically created index referenced by the graph workspace is not discarded.

[0068] In some examples, Figure 2 At least some of the components shown are configured to communicate with each other to implement the aspects described herein. One or more components described herein may be implemented using hardware (e.g., one or more processors of one or more machines) or a combination of hardware and software. For example, a component 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 functionality described herein for a single component may be subdivided among multiple components. Additionally, according to various examples, the components described herein may be implemented using a single machine, database, or device, or distributed across multiple machines, databases, or devices.

[0069] In some examples, Figure 1 or Figure 2 Some of the components or subsystems shown are implemented (individually or in combination) as microservices. A microservice subsystem (e.g., a microservice application) may have components that enable it to operate independently and communicate with other services. Example components of a microservice subsystem include:

[0070] • Functional logic: Functional logic implements the functions of the microservice subsystem and represents the specific capabilities or functions provided by the microservice.

[0071] • API Interface: Microservices can use lightweight protocols such as Representational State Transfer (REST) ​​or messaging to communicate with other components through well-defined APIs or interfaces.

[0072] • Data storage: A microservice subsystem can be responsible for its own data storage, which can be in the form of a database, cache, or other storage mechanism (e.g., using Database134). This allows the microservice subsystem to operate independently of other microservices.

[0073] • Service discovery: The microservice subsystem can find and communicate with other microservice subsystems of server system 104. The service discovery mechanism enables the microservice subsystem to locate and communicate with other microservice subsystems in a scalable and efficient manner.

[0074] • Monitoring and logging: Monitoring and logging of microservice subsystems may be necessary to ensure availability and performance. Monitoring and logging mechanisms enable the tracking of the health and performance of microservice subsystems.

[0075] Figure 3 This is a block diagram illustrating Example 300 for creating a graph workspace, based on some examples. One or more of the various functions described in Example 300 can be provided by, for example... Figure 1 or Figure 2 This can be achieved using a graph workspace system 130 or a similar graph workspace system.

[0076] Example 300 illustrates the creation of graph workspace A 314 and graph workspace B 316 on data set 308 in graph workspace system 306. User A 302 provides a user command to create graph workspace A 314 on data set 308. In response to the user command, graph workspace system 306 determines whether an index on data set 308 has already been created for graph workspace A 314. In this example, hash index 310 is an existing hash index created on data set 308. Adjacency index 312 has not yet been created on data set 308. Therefore, graph workspace system 306 determines that adjacency index 312 has not yet been created and automatically creates adjacency index 312 on data set 308. Graph workspace system 306 references hash index 310 and adjacency index 312 to create graph workspace A 314.

[0077] User B 304 provides a user command to create a graph workspace B 316 on data set 308. In response to the user command, the graph workspace system 306 determines whether an index on data set 308 has already been created for graph workspace B 316. In this example, hash index 310 is an existing hash index created on data set 308. Adjacency index 312 is an existing adjacency index automatically created on data set 308 in response to the user command to create graph workspace A 314. Therefore, the graph workspace system 306 determines that hash index 310 and adjacency index 312 have been created, and uses hash index 310 and adjacency index 312 to create graph workspace B 316.

[0078] Figure 4 This is a block diagram of Example 400, illustrating a workspace with alternative diagrams based on some examples. One or more of the various functions described in Example 400 can be provided by, for example... Figure 1 or Figure 2 This can be achieved using a graph workspace system 130 or a similar graph workspace system.

[0079] Example 400 illustrates replacing the graph workspace A 412 created for data set B 414 with the graph workspace A 412 created for data set A 406. User A 402 provides a user command to create graph workspace A 412 on data set B 414. In this example, graph workspace A 412 was previously created for data set A 406. Hash index A 408 and adjacency index A 410 are automatically created for graph workspace A 412. In response to the user command, graph workspace system 404 determines whether an index on data set B 414 has already been created for graph workspace A 412. In this example, no index has been created on data set B 414. Therefore, graph workspace system 404 determines that no index has been created on data set B 414 and automatically creates hash index B 416 and adjacency index B 418 on data set B. Graph workspace system 404 discards graph workspace A 412 on data set A 406 and creates graph workspace A 412 on data set B 414 as a replacement, referencing hash index B 416 and adjacency index B 418. Based on the discarding of graph workspace A 412 on data set A 406, graph workspace system 404 determines whether the automatically created hash index A 408 and adjacency index A 410 are referenced by any graph workspace. In this example, only graph workspace A 412 references hash index A 408 and adjacency index A 410. Therefore, graph workspace system 404 determines that no graph workspace references hash index A 408 and adjacency index A 410. Based on this determination, graph workspace system 404 discards hash index A 408 and adjacency index A 410.

[0080] Figures 5A to 5B This is a block diagram illustrating an example of an export and import workspace based on some examples. One or more of the various functions described in these examples can be provided by, for example... Figure 1 or Figure 2 This can be achieved using a graph workspace system 130 or a similar graph workspace system.

[0081] exist Figure 5AExample 500 illustrates the export of a graph workspace 510 created for dataset 504. When graph workspace 510 is created for dataset 504, hash index 506 is already created on dataset 504, and adjacency index 508 is automatically created on adjacency index 508. Graph workspace 510 is created by referencing hash index 506 and adjacency index 508. In response to the user command to export graph workspace 510, graph workspace system 502 generates a binary file 512 that includes graph workspace 510, dataset 504, and hash index 506. The automatically created adjacency index 508 is not included in binary file 512.

[0082] exist Figure 5B Example 550 illustrates the import of binary file 512. In response to a user command to import graph workspace 510, graph workspace system 552 imports binary file 512. Binary file 512 includes graph workspace 510, data set 504, and hash index 506. Graph workspace system 552 identifies the index on data set 504 imported into binary file 512. Since hash index 506 is included in binary file 512 and adjacency index is not included in binary file 512, graph workspace system 552 automatically creates adjacency index 554. Graph workspace 510 references hash index 506 and adjacency index 554.

[0083] Figures 6A to 6B This is a flowchart illustrating example methods based on some examples. One or more functions described in the example methods can be derived from, for example... Figure 1 or Figure 2 This can be implemented using a graph workspace system 130 or a similar graph workspace system. Although the flowchart depicts a specific sequence of operations, the sequence can be changed without departing from the scope of the subject matter disclosed herein. For example, some of the depicted operations can be performed in parallel or in a different order without substantially affecting the functionality described in the example methods.

[0084] exist Figure 6AIn example method 600, operations associated with creating a graph workspace are performed by a graph workspace system. In operation 602, the graph workspace system creates a data set. For example, a data set is created in response to a user command to create a dataset in a database. In operation 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. At operation 606, the graph workspace system determines existing indexes on the data set. For example, the graph workspace system determines whether a hash index exists on the data set and whether an adjacency index exists on the data set. If the graph workspace determines that existing indexes exist on the data set, then at operation 608, the graph workspace system uses the existing indexes. For example, the graph workspace system uses an existing hash index and an existing adjacency index to create the graph workspace. If the graph workspace determines that no existing indexes exist on the data set, then at operation 610, the graph workspace system automatically creates indexes. For example, the graph workspace system automatically creates a hash index and automatically creates an adjacency index on the data set. At operation 612, the 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 created adjacency index, or an automatically created hash index and an automatically created adjacency index. In operation 614, the graph workspace system manages the graph workspace. Managing the graph workspace involves various operations. At operation 616, the graph workspace system facilitates the use of the graph workspace to query and analyze graph data. For example, the graph workspace system facilitates performing graph traversal on the graph workspace. At operation 618, the graph workspace system updates the graph workspace. For example, the graph workspace system may modify an existing hash index or modify an existing adjacency index and refresh the graph workspace. At operation 620, the graph workspace system discards the graph workspace. For example, if no other graph workspace references the automatically created hash index and the automatically created adjacency index, the graph workspace system discards the graph workspace and discards the automatically created hash index and the automatically created adjacency index. At operation 624, the graph workspace system exports and imports graph workspaces. For example, the graph workspace system outputs the graph workspace as a binary file that includes existing indexes but does not include automatically created indexes.

[0085] exist Figure 6B In example method 650, operations are performed by the graph workspace system. In operation 652, the graph workspace system receives a user command to create a graph workspace for a dataset. In operation 654, the graph workspace system determines missing indices on the dataset for the graph workspace. At operation 656, the graph workspace system automatically creates automatically created indices on the dataset for the graph workspace based on the missing indices. In operation 658, the graph workspace system uses the automatically created indices to create the graph workspace.

[0086] In view of the above-described embodiments of the subject matter, this application discloses the following list of examples, wherein a feature of a single example or a combination thereof, and optionally in combination with one or more features of one or more other examples, are other examples that also fall within the scope of this application.

[0087] Example 1 is a system comprising: at least one memory for storing instructions; and

[0088] One or more processors configured by the instructions are configured to perform operations including: receiving a first user command to create a first graph workspace for a first dataset; determining a first missing index on the first dataset of the first graph workspace; automatically creating a first automatically created index on the first dataset of the first graph workspace based on the first missing index; and creating a first graph workspace that references the first automatically created index.

[0089] In Example 2, the subject of Example 1 includes receiving a second user command to discard a first graph workspace; identifying the number of second graph workspaces referencing a first automatically created index; and discarding the first automatically created index based on the number of second graph workspaces referencing the first automatically created index being less than a threshold number.

[0090] In Example 3, the subject of Example 2 includes identifying the number of workspaces in the second graph by: traversing the data objects defined for the first dataset; and incrementing a counter for each data object in the data objects that references the first automatically created index.

[0091] In Example 4, the subject of any of Examples 1-3 includes receiving a second user command for creating a second graph workspace for a first dataset; identifying an automatically created first index on the first dataset; and creating a second graph workspace that references the first automatically created index.

[0092] In Example 5, the subject of any of Examples 1-4 includes determining a first existing index on a first dataset in the first graph workspace, the first existing index not identified in the first user command; and causing the first graph workspace to reference the first existing index and the first automatically created index.

[0093] In Example 6, the subject of any one of Examples 1-5 includes, wherein the first automatically created index identifies vertices in the first dataset, and the operation further includes: automatically creating a second automatically created index, the second automatically created index identifying connections between vertices in the first dataset, the second automatically created index referencing the first automatically created index; and causing the first graph workspace to reference the first automatically created index and the second automatically created index.

[0094] In Example 7, the subject of any one of Examples 1-6 includes receiving a second user command to replace a first graph workspace with a second graph workspace of a second dataset; determining a second missing index on the second dataset of the second graph workspace; automatically creating a second automatically created index on the second dataset of the second graph workspace based on the second missing index; creating a second graph workspace that references the second automatically created index; and discarding the first graph workspace and the first automatically created index.

[0095] 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 file that includes the first graph workspace and a first dataset, the binary file not including a first automatically created index.

[0096] In Example 9, the subject of any one of Examples 1-8 includes receiving a second user command for importing a second graph workspace; receiving a binary file including the second graph workspace and a second dataset; determining a second missing index in the binary file; and automatically creating a second automatically created index on the second dataset, the second graph workspace referencing the second automatically created index.

[0097] In Example 10, the subject matter as described in any one of Examples 1 to 9 includes: locking the first dataset based on a first automatically created index; and unlocking the first dataset based on the creation of the first automatically created index.

[0098] In Example 11, the subject of any of Examples 1-10 includes determining that the user providing the first user command has the privilege to create an index on the first dataset, wherein the creation of the first graph workspace is based on the user having the privilege to create an index on the first dataset.

[0099] In Example 12, the subject matter as described in any one of Examples 1 to 11 includes: determining that the user providing the first user command does not have the privilege to discard an index on the first dataset; and rejecting the second user command to replace the first graph workspace with a second graph workspace for the second dataset.

[0100] In Example 13, the subject of any of Examples 1-12 includes that the first automatically created index follows a naming scheme that identifies the first automatically created index as a system index.

[0101] Example 14 is a method comprising: receiving a first user command to create a first graph workspace for a first dataset; determining a first missing index on the first dataset of the first graph workspace; automatically creating a first automatically created index on the first dataset of the first graph workspace based on the first missing index; and creating a first graph workspace that references the first automatically created index.

[0102] In Example 15, the subject of Example 14 includes receiving a second user command to discard a first graph workspace; identifying the number of second graph workspaces referencing a first automatically created index; and discarding the first automatically created index based on the number of second graph workspaces referencing the first automatically created index being less than a threshold number.

[0103] In Example 16, the subject of Example 15 includes identifying the number of workspaces in the second graph by: traversing data objects defined for the first dataset; and incrementing a counter for each data object in the data objects that references the first automatically created index.

[0104] In Example 17, the subject of any one of Examples 14-16 includes receiving a second user command to create a second graph workspace for a first dataset; identifying a first automatically created index on the first dataset; and creating a second graph workspace that references the first automatically created index.

[0105] Example 18 is one or more non-transitory computer-readable media storing computer-executable instructions that, when executed by a computing system, cause the computing system to perform operations including: receiving a first user command to create a first graph workspace for a first dataset; determining a first missing index on the first dataset in the first graph workspace; automatically creating a first automatically created index on the first dataset in the first graph workspace based on the first missing index; and creating a first graph workspace that references the first automatically created index.

[0106] In Example 19, the subject of Example 18 includes receiving a second user command to discard a first graph workspace; identifying the number of second graph workspaces referencing a first automatically created index; and discarding the first automatically created index based on the number of second graph workspaces referencing the first automatically created index being less than a threshold number.

[0107] In Example 20, the subject of Example 19 includes identifying the number of workspaces in the second graph by: traversing the data objects defined for the first dataset; and incrementing a counter for each data object in the data objects that references the first automatically created index.

[0108] Example 21 is at least one machine-readable medium including instructions that, when executed by processing circuitry, cause the processing circuitry to perform operations to implement any one of Examples 1-20.

[0109] Example 22 is an apparatus that includes means for implementing any one of Examples 1-20.

[0110] Example 23 is a system for implementing any one of Examples 1-20.

[0111] Example 24 is a method for implementing any one of Examples 1-20.

[0112] Figure 7 This is a block diagram 700 illustrating a software architecture 702 for a computing device according to some examples. The software architecture 702 can be used in conjunction with various hardware architectures, such as those described herein. Figure 7 This is merely a non-limiting illustration of a software architecture, and many other architectures can be implemented to facilitate the functionality described herein. A representative hardware layer 704 is shown and can represent, for example, any computing device referenced above. In some examples, hardware layer 704 can be configured according to… Figure 8 It is implemented through the architecture of computer systems.

[0113] Representative hardware layer 704 includes one or more processing units 706 having associated executable instructions 708. The executable instructions 708 represent executable instructions of software architecture 702, including implementations of the methods, modules, subsystems, and components described herein, and may also include memory and / or storage module 710, which also has executable instructions 708. Hardware layer 704 may also include other hardware as indicated by other hardware 712 and other hardware 722 representing any other hardware of hardware layer 704, such as other hardware shown as part of software architecture 702.

[0114] exist Figure 7 In the architecture, software architecture 702 can be conceptualized as a stack of layers, where each layer provides specific functionality. For example, software architecture 702 may include layers such as operating system 714, libraries 716, framework / middleware layer 718, applications 720, and presentation layer 744. Operationally, applications 720 or other components within a layer can invoke API calls 724 via the software stack, and responses to API call 724 access are shown as messages 726, return values, etc. The layers shown are representative in nature, and not all software architectures have all layers. For example, some mobile or dedicated operating systems may not provide a framework / middleware layer 718, while others may provide such a layer. Other software architectures may include additional or different layers.

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

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

[0117] Library 716 provides common infrastructure that can be used by application 720 or other components or layers. Library 716 typically provides functionality that allows other software modules to perform tasks in a way that is easier than directly interfaced with the underlying operating system 714 functions (e.g., kernel 728, service 730, or driver 732). Library 716 may include system libraries 734 (e.g., the C standard library), which provide functions such as memory allocation, string manipulation, and mathematical functions. Additionally, library 716 may include API libraries 736, such as media libraries (e.g., libraries for supporting the rendering and manipulation of various media formats such as MPEG4, H.264, MP3, AAC, AMR, JPG, and PNG), graphics libraries (e.g., OpenGL frameworks for rendering 2D and 3D graphic content on a display), database repositories (e.g., SQLite providing various relational database functions), web libraries (e.g., WebKit providing web browsing functionality), and so on. Library 716 may also include a wide variety of other libraries 738 to provide many other APIs to application 720 and other software components / modules.

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

[0119] Application 720 includes either built-in application 740 or third-party application 742. Examples of representative built-in 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 any built-in application as well as a wide variety of other applications. In a specific example, a third-party application 742 (e.g., an entity using the Android System other than a platform-specific vendor) is considered a third-party application. TM Or iOS TM Applications developed using a Software Development Kit (SDK) can be used in applications such as iOS. TM Android TM Mobile software running on the mobile operating system of a Windows® phone or other mobile computing device operating system. In this example, a third-party application 742 may invoke API call 724 provided by the mobile operating system, such as operating system 714, to facilitate the functionality described herein.

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

[0121] Some software architectures utilize virtual machines. Figure 7 In the example, this is illustrated by virtual machine 748. The virtual machine creates a software environment where applications / modules can execute as if they were running on a hardware computing device. The virtual machine is hosted by a host operating system (operating system 714) and typically, but 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). Software architectures execute within virtual machine 748, such as operating system 750, libraries 752, frameworks / middleware 754, applications 756, or presentation layers 758. These software architecture layers executing within virtual machine 748 may be the same as or different from their previously described counterparts.

[0122] Some examples are described herein as including logic or multiple components, modules, or mechanisms. Modules or components may constitute software modules / components (e.g., (1) code embodied on a non-transitory machine-readable medium or (2) in transmitted signals) or hardware-implemented modules / components. Hardware-implemented modules / components are tangible units capable of performing certain operations and may be configured or arranged in a certain way. In the examples, one or more computer systems (e.g., standalone, client, or server computer systems) or one or more hardware processors may be hardware-implemented modules / components configured by software (e.g., an application or application portion) to operate to perform certain operations as described herein.

[0123] In various examples, hardware-implemented modules / components can be implemented mechanically or electronically. For example, hardware-implemented modules / components may include dedicated circuitry or logic permanently configured to perform certain operations (e.g., as a dedicated processor, such as a field-programmable gate array (FPGA) or application-specific integrated circuit (ASIC)). Hardware-implemented modules / components may also include programmable logic or circuitry temporarily configured by software to perform certain operations (e.g., contained within a general-purpose processor or another programmable processor).

[0124] Therefore, the terms "hardware-implemented module" or "hardware-implemented component" should be understood to encompass tangible entities, i.e., entities physically constructed, permanently configured (e.g., hardwired), or temporarily or provisionally configured (e.g., programmed) to operate or perform certain operations described herein. Consider examples where hardware-implemented modules / components are provisionally configured (e.g., programmed), and each of the hardware-implemented modules / components does not need to be configured or instantiated at any given time. For example, in the case where a hardware-implemented module / component includes a general-purpose processor configured using software, the general-purpose processor can be configured at different times as correspondingly different hardware-implemented modules / components. The software can accordingly configure the processor, for example, to constitute a particular hardware-implemented module / component at one time and different hardware-implemented modules / components at different times.

[0125] Hardware-implemented modules / components can provide information to and receive information from other hardware-implemented modules / components. Therefore, the described hardware-implemented modules / components can be considered communicatively coupled. In the presence of multiple such hardware-implemented modules / components, communication can be achieved through signal transmission (e.g., by connecting appropriate circuitry and buses to the hardware-implemented modules / components). In an example where multiple hardware-implemented modules / components are configured or instantiated at different times, communication between such hardware-implemented modules / components can be achieved, for example, by storing and retrieving information in a memory structure accessible to the multiple hardware-implemented modules / components. For example, one hardware-implemented module / component can perform an operation and store the output of that operation in a memory device communicatively coupled to it. Another hardware-implemented module / component can then later access the memory device to retrieve and process the stored output.

[0126] The various operations of the example methods described herein can 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 temporarily or permanently configured, such processors can constitute modules / components of processor implementations that operate to perform one or more operations or functions. In some examples, modules / components mentioned herein may include processor-implemented modules / components.

[0127] Similarly, the methods described herein can be implemented at least partially by a processor. For example, at least some operations of the methods can be performed by one or more processors or modules / components implemented by processors. The execution of certain operations can be distributed among one or more processors, residing not only within a single machine but also deployed across multiple machines.

[0128] One or more processors may also 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 a machine that includes processors), and these operations may be accessible via a network (e.g., the Internet) and via one or more appropriate interfaces (e.g., APIs).

[0129] Examples can be implemented in digital electronic circuits, or in computer hardware, firmware, or software, or in a combination thereof. Examples can be implemented using computer program products, such as computer programs tangibly embodied in an information carrier, for example, in a machine-readable medium, for execution by or control of a data processing apparatus (e.g., a programmable processor, a computer, or a plurality of computers).

[0130] Computer programs can be written in any programming language, including compiled or interpreted languages, and can be deployed in any form, including as standalone programs or as modules, subroutines, or other units suitable for use in a computing environment. Computer programs can be deployed to execute on a single computer, at a single site, or distributed across multiple sites and interconnected via a communication network.

[0131] Figure 8 This is a block diagram of a machine in the example form of a computer system 800, within which instructions 824 can be executed to cause the machine to perform any or more of the methods discussed herein. In alternative examples, the machine operates as a standalone device or can be connected (e.g., networked) to other machines. In a networked deployment, the machine can 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 can be a personal computer (PC), tablet PC, set-top box (STB), personal digital assistant (PDA), cellular phone, web device, network router, switch, or bridge, or any machine capable of executing instructions (sequentially or otherwise) specifying actions to be taken by that machine. Furthermore, although only a single machine is shown, the term "machine" should also be considered as any collection of machines that individually or jointly execute a set (or more) of instructions to perform any or more of the methods discussed herein.

[0132] Example computer system 800 includes a processor 802 (e.g., a central processing unit (CPU), GPU, or both), main or primary memory 804, and static memory 806, which communicate with each other via bus 808. Computer system 800 may also include a video display unit 810 (e.g., a liquid crystal display (LCD) or a cathode ray tube (CRT)). Computer system 800 also includes an alphanumeric input device 812 (e.g., a keyboard or touch-sensitive display), 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.

[0133] As used herein, the term "processor" can refer to any one or more circuits or virtual circuits (e.g., physical circuitry emulated by logic executed on an actual processor) that manipulate data values ​​according to control signals (e.g., commands, opcodes, machine code, control words, macro instructions, etc.) and generate corresponding output signals applied to operate a machine. Processors can include, for example, at least one of a central processing unit (CPU), a reduced instruction set computing (RISC) processor, a complex 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 neuromorphic processor, a quantum processor, or any combination thereof. A processor can be a multi-core processor having two or more independent processors (sometimes referred to as "cores") capable of executing instructions simultaneously. A multi-core processor can contain multiple computational cores on a single integrated circuit die, each of which can independently execute program instructions in parallel. Parallel processing on multi-core processors can be achieved through architectures such as superscalar, VLIW, vector processing, or SIMD, which allow each core to execute a separate stream of instructions simultaneously. Processors can be emulated in software and run on a physical processor as virtual processors or virtual circuits. Virtual processors can behave like independent processors but are implemented in software rather than hardware.

[0134] Storage unit 816 includes machine-readable medium 822 on which one or more sets of data structures and instructions 824 (e.g., software) embody or be utilized by any one or more methods or functions described herein. Instructions 824 may also reside wholly or at least partially within main memory 804 or processor 802 during execution by computer system 800, wherein main memory 804 and processor 802 each constitute machine-readable medium 822.

[0135] Although machine-readable medium 822 is shown as a single medium according to some examples, the term "machine-readable medium" can include a single medium or multiple media (e.g., a centralized or distributed database, or associated caches and servers) storing one or more instructions 824 or data structures. The term "machine-readable medium" should also be considered to include any tangible medium capable of storing, encoding, or carrying instructions 824 for execution by a machine and causing the machine to perform any one or more of the methods of this disclosure, or capable of storing, encoding, or carrying data structures utilized by or associated with such instructions 824. Therefore, the term "machine-readable medium" should be considered to include, but is not limited to, solid-state memory and optical and magnetic media. Specific examples of machine-readable medium 822 include non-volatile memory, including, for example, semiconductor memory devices such as erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), and flash memory devices; disks, such as internal hard disks and removable disks; magneto-optical disks; and compact disc read-only memory (CD-ROM) and digital universal disc read-only memory (DVD-ROM). Machine-readable medium is not a transmission medium.

[0136] Instructions 824 can also be sent or received on the communication network 826 using a transmission medium. Instructions 824 can be sent using the network interface device 820 and any of a number of well-known transmission protocols, such as Hypertext Transfer Protocol (HTTP). Examples of communication networks include local area networks (LANs), wide area networks (WANs), the Internet, mobile phone networks, common-use telephone (POTS) networks, and wireless data networks (such as Wi-Fi and Wi-Max networks). The term "transmission medium" should be considered to include any intangible medium capable of storing, encoding, or carrying instructions 824 for machine execution, and includes digital or analog communication signals or other intangible media to facilitate communication of such software.

[0137] Although specific examples are described herein, it will be apparent that various modifications and changes can be made to these examples without departing from the broader spirit and scope of this disclosure. Therefore, the specification and drawings are to be considered illustrative rather than restrictive. The drawings, which form a part thereof, illustrate specific examples by way of illustration, not limitation, of how the subject matter can be practiced. The examples shown are described in sufficient detail to enable those skilled in the art to practice the teachings disclosed herein. Other examples can be utilized and derived from them, such that structural and logical substitutions and changes can be made without departing from the scope of this disclosure. Therefore, this specific embodiment should not be considered limiting, and the scope of the various examples is defined only by the appended claims and the full scope of their equivalents.

[0138] Such examples of the subject matter may be referred to individually or collectively herein by the term "example" for convenience only, and if more than one example or concept is actually disclosed, it is not intended to voluntarily limit the scope of this application to any single example or concept. Therefore, although specific examples have been shown and described herein, it should be understood that any arrangement calculated to achieve the same purpose may be substituted for the specific examples shown. This disclosure is intended to cover any and all adaptations or variations of the various examples. Combinations of the foregoing examples, as well as other examples not specifically described herein, will be apparent to those skilled in the art upon reading the above description.

[0139] Some parts of the subject matter discussed herein can be presented as algorithms or symbolic representations of operations on data stored as bit or binary digital signals in machine memory (e.g., computer memory). Such algorithms or symbolic representations are examples of techniques used by those of ordinary skill in the art of data processing to convey the essence of their work to others of skill in the art. As used herein, an "algorithm" is a self-consistent sequence of operations or similar processing that leads to a desired result. In this context, algorithms and operations involve the physical manipulation of physical quantities. Typically, but not necessarily, such quantities can take the form of electrical, magnetic, or optical signals that can be stored, accessed, transmitted, combined, compared, or otherwise manipulated by a machine. Sometimes, primarily for general reasons, it is convenient to use terms such as "data," "content," "bit," "value," "element," "symbol," "character," "term," "number," "label," etc., to refer to such signals. However, these terms are merely convenient labels and are associated with appropriate physical quantities.

[0140] Unless otherwise specified, the use of terms such as “processing,” “computing,” “operation,” “determining,” “presenting,” and “displaying” herein 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 machine components that receive, store, transmit, or display information. Furthermore, unless otherwise specified, as is common in patent literature, the terms “a” and “an” are used herein to include one or more instances.

[0141] Unless the context explicitly requires otherwise, throughout the specification and claims, the terms “comprise,” “comprising,” etc., shall be interpreted in an inclusive sense, rather than an exclusive or exhaustive sense, such as “including but not limited to.” As used herein, the terms “connection,” “coupling,” or any variation thereof mean any direct or indirect connection or coupling between two or more elements; the coupling or connection between elements may be physical, logical, or a combination thereof. Additionally, when used in this application, the terms “this article,” “above,” “below,” and similar terms refer to the application as a whole, and not to any particular part of the application. Where the context permits, the use of singular or plural terms may also include the plural or singular, respectively. Unless otherwise stated, the term “or” in relation to a list of two or more items covers all of the following interpretations: any one of the items in the list, all the items in the list, and any combination of the items in the list.

[0142] While some examples (such as those depicted in the accompanying drawings) include a specific sequence of operations, the sequence may be varied without departing from the scope of this disclosure. For example, some of the depicted operations may be performed in parallel or in a different order that does not substantially affect the functionality described in the examples. In other examples, different components of an example device or system implementing the example methods may perform functions substantially simultaneously or in a specific order. For ease of reference, the term "operation" is used to refer to an element in the accompanying drawings of this disclosure, and it should be understood that each "operation" may identify one or more operations, processes, actions, or steps, and may be performed by one or more components.

Claims

1. A system comprising: At least one memory for storing instructions; and One or more processors, the one or more processors being configured by the instructions to perform operations including the following: Receive the first user command to create the first graph workspace for the first dataset; Determine the first missing index on the first dataset in the first graph's working area; Based on the first missing index, an automatically created index is automatically created on the first dataset in the first graph workspace. and Create the first graph workspace that references the first automatically created index.

2. The system of claim 1, wherein the operation further includes: Receive the second user command to discard the first workspace; The number of second-graph workspaces that reference the first automatically created index; and The first automatically created index is discarded if the number of second graph workspaces referencing the first automatically created index is less than a threshold number.

3. The system of claim 2, wherein identifying the number of second drawing work areas includes: Iterate through the data objects defined for the first dataset; and For each data object that references the first automatically created index, increment the counter.

4. The system of claim 1, wherein the operation further comprises: Receive the second user command to create a second graph workspace for the first dataset; Identify the first automatically created index on the first dataset; and Create a second graph workspace that references the first automatically created index.

5. The system of claim 1, wherein the operation further comprises: Determine the first existing index on the first dataset in the first graph work area. The first existing index was not identified in the first user command. and Make the first workspace reference the first existing index and the first automatically created index.

6. The system of claim 1, wherein the first automatically created index identifies vertices in the first dataset, and the operation further includes: A second automatically created index is automatically created. The second automatically created index identifies the connection between vertices in the first dataset. The second automatically created index references the first automatically created index. and This causes the first workspace to reference the first automatically created index and the second automatically created index.

7. The system of claim 1, wherein the operation further comprises: Receive a second user command to replace the first graph workspace with a second graph workspace used for the second dataset; Determine the second missing index on the second dataset in the second graph's working area; Based on the second missing index, a second automatically created index is automatically created on the second dataset in the second graph workspace; Create a second graph workspace that references the second automatically created index; and Discard the first workspace and the first automatically created index.

8. The system of claim 1, wherein the operation further comprises: Receive the second user command to export the first drawing workspace; and Generate a binary file that includes a first graph workspace and a first dataset, excluding the first automatically created index.

9. The system of claim 1, wherein the operation further comprises: Receive the second user command to import the second workspace; Receive binary files including the second graph workspace and the second dataset; Determine the second missing index in the binary file; and A second automatically created index is automatically created on the second dataset, and the second graph workspace references the second automatically created index.

10. The system of claim 1, wherein the operation further comprises: Lock the first dataset based on the first automatically created index; and The first automatically created index is used to unlock the first dataset.

11. The system of claim 1, wherein the operation further comprises: It is determined that the user who provides the first user command has the privilege to create an index on the first dataset, wherein the creation of the first graph workspace is based on the user having the privilege to create an index on the first dataset.

12. The system of claim 1, wherein the operation further comprises: It is determined that the user who provides the first user command does not have the privilege to discard the indexes on the first dataset; and The second user command to replace the first graph workspace with the second graph workspace used for the second dataset was rejected.

13. The system of claim 1, wherein, The first automatically created index follows the naming scheme that identifies the first automatically created index as a system index.

14. A method comprising: Receive the first user command to create the first graph workspace for the first dataset; Determine the first missing index on the first dataset in the first graph's working area; Based on the first missing index, an automatically created index is automatically created on the first dataset in the first graph workspace. and Create the first graph workspace that references the first automatically created index.

15. The method of claim 14, further comprising: Receive the second user command to discard the first workspace; The number of second-graph workspaces that reference the first automatically created index; and The first automatically created index is discarded if the number of second graph workspaces referencing the first automatically created index is less than a threshold number.

16. The method of claim 15, wherein identifying the number of second drawing work areas comprises: Iterate through the data objects defined for the first dataset; and For each data object that references the first automatically created index, increment the counter.

17. The method of claim 14, further comprising: Receive the second user command to create a second graph workspace for the first dataset; Identify the first automatically created index on the first dataset; and Create a second graph workspace that references the first automatically created index.

18. One or more non-transitory computer-readable media storing computer-executable instructions, which, when executed by a computing system, cause the computing system to perform operations, including: Receive the first user command to create the first graph workspace for the first dataset; Determine the first missing index on the first dataset in the first graph's working area; Based on the first missing index, an automatically created index is automatically created on the first dataset in the first graph workspace. and Create the first graph workspace that references the first automatically created index.

19. The operation further comprises: one or more non-transitory computer-readable media as claimed in claim 18. Receive the second user command to discard the first workspace; Identify the number of second-graph workspaces that reference the first automatically created index; and The first automatically created index is discarded if the number of second graph workspaces referencing the first automatically created index is less than a threshold number.

20. The one or more non-transitory computer-readable media of claim 19, wherein identifying the number of second figure working areas comprises: Iterate through the data objects defined for the first dataset; and For each data object that references the first automatically created index, increment the counter.

Images