WO2024040607A1 - Data access method and apparatus, electronic device, and computer-readable storage medium - Google Patents

Abstract

Disclosed are a data access method and apparatus, an electronic device, and a computer-readable storage medium. The method comprises: generating a list comprising keys in a dictionary, wherein the dictionary stores data in key-value pairs, and the list supports regular matching; receiving a regular expression comprising a matching rule, wherein the matching rule is described by a character string; matching the list by using the matching rule of the regular expression; and using a hit result matching the list as a retrieval item, and querying the dictionary to access the value corresponding to the retrieval item. Thus, the complexity of directly retrieving a dictionary is reduced, case sensitivity is achieved, and fault tolerance is improved.

Description

Data access methods, devices, electronic equipment and computer-readable storage media Technical field

The present invention relates to the field of data processing technology, in particular to data access methods, devices, electronic equipment and computer-readable storage media.

Background technique

Dictionary is used to store key-value pairs (key=>value) and is a data structure in programming languages such as Python. Specifically, a dictionary can be viewed as a mutable container model and can store any type of object. Each key-value pair in the dictionary is separated by a colon (:), each key-value pair is separated by a comma (,), and the entire dictionary is enclosed in curly braces ({}). The key (key) must be unique, but the value (value) does not have to be; the value can be of any data type, but the key must be an immutable data type, such as: string, integer, tuple, etc. Dictionary query is efficient and uses keys internally to calculate a memory address (hash).

For example, D1={‘a’:1,‘b’:2}, where D1 is a dictionary. Dictionary D1 contains two keys: 'a' and 'b', which store the values 1 and 2 respectively. If it is desired to obtain the value stored at the address corresponding to 'a', then the value of D1['a'] is 1.

When the dictionary becomes complex in size and depth, there are often long keys in the dictionary and it becomes difficult to enter the correct key and therefore it becomes difficult to access the data based on the key. In particular, when the long key contains both uppercase and lowercase letters, accessing the data is more troublesome.

Contents of the invention

The embodiments of the present invention provide data access methods, devices, electronic equipment and computer-readable storage media.

A data access method, the method includes:

Generate a list containing keys in a dictionary, where the dictionary stores data in the form of key-value pairs, and the list supports regular matching;

Receive a regular expression containing a matching rule, where the matching rule is described by a string;

Match the list using the matching rule in the regular expression;

Hits matching the list are used as search terms, and the dictionary is queried to access values corresponding to the search terms.

It can be seen that the embodiment of the present invention generates a list containing keys in the dictionary that supports regular matching, and then matches in the list based on the received regular expression. Therefore, the hit result can be directly used to access the value corresponding to the search item in the dictionary. There is no need for users to directly provide lengthy keys, which improves user convenience and reduces the difficulty of data access.

In an exemplary embodiment, generating a list including keys in the dictionary includes:

Parse the dictionary to determine the lowest-level key in the dictionary, wherein no other dictionaries are nested in the values stored in the dictionary corresponding to the lowest-level key;

Generate a list containing the lowest-level keys in the dictionary.

Therefore, data can be accessed quickly by generating a list containing the lowest-level keys in the dictionary.

In an exemplary embodiment, when the lowest-level key has a dependency relationship between layers, a forward slash is used in the list as a connector characterizing the dependency relationship.

It can be seen that forward slashes, which have no special meaning in programming languages, are used to describe the relationship of the lowest-level keys with subordinate relationships in the list, making it easier for users to write regular expressions accurately.

In an exemplary embodiment, the dictionary includes N levels of keys, where N is a positive integer that is at least 2;

The generating a list containing keys in the dictionary includes: parsing the dictionary to generate N lists, wherein each list contains keys of the same corresponding level in the dictionary;

The receiving regular expressions containing matching rules includes: receiving N regular expressions containing respective matching rules, wherein the N regular expressions correspond to the N lists one-to-one;

Using the matching rules in the regular expressions to match the list includes: using respective matching rules in each of the N regular expressions to match the corresponding list;

The step of using the hit result matching the list as a retrieval item and querying the dictionary to access the value corresponding to the retrieval item includes: using the hit result of each regular expression and the corresponding list as a retrieval item to layer-by-layer The matching method determines the value corresponding to the retrieval item from the corresponding layer.

Therefore, the embodiment of the present invention also uses multiple regular expressions corresponding to the number of layers to determine the value in a layer-by-layer matching manner, which reduces the complexity of the list and reduces the difficulty of generating the list.

In an exemplary implementation, matching the list using the matching rule in a regular expression includes:

Exactly match the list using the matching rules; or

The list is fuzzy matched using the matching rule, wherein the fuzzy match includes at least one of the following:

Case-insensitive; typo matching.

It can be seen that the embodiment of the present invention can be case-insensitive and support typo matching through fuzzy matching, thereby reducing user difficulty.

A data access device, the device includes:

A list generation module configured to generate a list containing keys in a dictionary, wherein the dictionary stores data in the form of key-value pairs, and the list supports regular matching;

A receiving module configured to receive a regular expression containing a matching rule, where the matching rule is described by a string;

a matching module configured to match the list using the matching rule in the regular expression;

A query module configured to use hit results matching the list as retrieval items and query the dictionary to access values corresponding to the retrieval items.

It can be seen that the embodiment of the present invention generates a list containing keys in the dictionary that supports regular matching, and then matches in the list based on the received regular expression. Therefore, the hit result can be directly used to access the value corresponding to the search item in the dictionary. There is no need for users to directly provide lengthy keys, which improves user convenience and reduces the difficulty of data access.

In an exemplary embodiment, the list generation module is configured to parse the dictionary to determine a bottom-level key in the dictionary, wherein among the values stored in the dictionary corresponding to the bottom-level key No other dictionaries are nested; produces a list containing the lowest-level keys in the dictionary.

Therefore, data can be accessed quickly by generating a list containing the lowest-level keys in the dictionary.

In an exemplary embodiment, the list generation module is configured to use a forward slash in the list as a connector characterizing the dependency relationship when the lowest-level key has a dependency relationship between layers.

It can be seen that forward slashes, which have no special meaning in programming languages, are used to describe the relationship of the lowest-level keys with subordinate relationships in the list, making it easier for users to write regular expressions accurately.

In an exemplary embodiment, the dictionary includes N levels of keys, where N is a positive integer that is at least 2;

The list generation module is configured to parse the dictionary to generate N lists, wherein each list contains keys of the same corresponding layer in the dictionary;

The receiving module is configured to receive N regular expressions containing respective matching rules, wherein the N regular expressions correspond to the N lists one-to-one;

The matching module is configured to use respective matching rules in each of the N regular expressions to match the corresponding list;

The query module is configured to use the hit result of each regular expression and the corresponding list as a retrieval item, and determine the value corresponding to the retrieval item from the corresponding layer in a layer-by-layer matching manner.

Therefore, the embodiment of the present invention also uses multiple regular expressions corresponding to the number of layers to determine the value in a layer-by-layer matching manner, thereby reducing the complexity of the list and reducing the difficulty of generating the list.

In an exemplary embodiment, the matching module is configured to accurately match the list using the matching rules; or fuzzy matching the list using the matching rules, wherein the fuzzy matching includes at least one of the following:

Case-insensitive; typo matching.

It can be seen that the embodiment of the present invention can be case-insensitive and support typo matching through fuzzy matching, thereby reducing user difficulty.

An electronic device including:

processor;

memory for storing executable instructions for the processor;

The processor is configured to read the executable instructions from the memory and execute the executable instructions to perform any of the above data access methods.

A computer-readable storage medium has computer instructions stored thereon, and when the computer instructions are executed by a processor, the data access method as described in any one of the above items is implemented.

A computer program product includes a computer program that implements the data access method as described in any one of the above items when executed by a processor.

Description of drawings

Preferred embodiments of the present invention will be described in detail below to make the above and other features and advantages of the present invention more apparent to those skilled in the art with reference to the accompanying drawings, in which:

Figure 1 is a flow chart of a data access method according to an embodiment of the present invention.

Figure 2 is an exemplary schematic diagram of a dictionary according to an embodiment of the present invention.

Figure 3 is a first exemplary flow chart of a data access method according to an embodiment of the present invention.

Figure 4 is a second exemplary flow chart of a data access method according to an embodiment of the present invention.

Figure 5 is an exemplary structural diagram of a data access device according to an embodiment of the present invention.

FIG. 6 is an exemplary structural diagram of an electronic device according to an embodiment of the present invention.

Among them, the reference signs are as follows:

label	meaning
100	Data access methods
101～104	step
10	first dictionary
11	second dictionary
12	third dictionary
201～205	step
301～304	step
500	data access device
501	List generation module
502	receiving module
503	matching module
504	Query module
600	Electronic equipment

601	processor
602	memory

Detailed ways

In order to make the purpose, technical solutions and advantages of the present invention clearer, the following examples are given to further describe the present invention in detail.

For the sake of simplicity and intuitiveness in description, the solution of the present invention is explained below by describing several representative embodiments. A large number of details in the embodiments are only used to help understand the solution of the present invention. However, it is obvious that the technical solution of the present invention may not be limited to these details when implemented. In order to avoid unnecessarily obscuring the solutions of the present invention, some embodiments are not described in detail, but only give a framework. Hereinafter, "including" means "including but not limited to", and "based on..." means "at least based on..., but not limited to only based on...". Due to Chinese language habits, when the number of a component is not specified below, it means that the component can be one or more, or it can be understood as at least one.

In the existing technology, the exact matching of keys is directly used to obtain the corresponding value in the dictionary. However, when the dictionary structure is complex (such as large size and depth), there are usually long keys in the dictionary, and it is difficult to write accurate long keys to retrieve values from the dictionary. In particular, long keys may contain uppercase and lowercase letters, making writing long keys more error-prone. For example, assume that we have the following dictionary D2:

When expecting to access the value ['XGB'], the user is required to accurately write the following expression:

D2['predict_t_config']['LIST_000000']['train_cfg_obj_PT']['LIST_000000']['selected_methods'];

This is quite difficult and error-prone. This would be very inefficient when programming with such a dictionary. In addition, spelling words correctly can be difficult. For example: a dictionary contains a key named "cost", which may be misspelled as "cos", "Cost" or "coSt" when programming since keys are case sensitive. X['cost'] can retrieve the corresponding value correctly, but X['cos'], X['cost'] and X['COMST'] will not retrieve the value correctly.

In the embodiment of the present invention, the technical problem of obtaining values from complex dictionaries is solved based on regular expressions. Considering that it is difficult to obtain values from the dictionary directly through regular expressions, the embodiment of the present invention first generates a list that supports regular matching, where the list contains keys in the dictionary, so that the keys can be determined by matching the list through regular expressions.

Figure 1 is a flow chart of a data access method according to an embodiment of the present invention. As shown in Figure 1, the method includes:

Step 101: Generate a list containing keys in a dictionary, where the dictionary stores data in the form of key-value pairs, and the list supports regular matching.

Here, the dictionary is also called a hash map (hashmap) or a mapping table (map). It stores data in a key-value manner, and the value can be looked up through the key. When searching a dictionary, the hash value of the key is usually calculated first, and then the array subscript is quickly located through modular operation. If the subscript has only one element, then the value is returned directly; if there are multiple elements, they are stored Compare the same subscript and return the same value. For example, you can use the dict function in Python coding to create a dictionary.

Here, the dictionary is parsed to generate a list that supports regular matching and contains the keys in the dictionary. For example, lists that support regular matching can be generated through the following programming languages: Scala, PHP, C#, Java, C++, Objective-c, Perl, Swift, VBScript, Javascript, Ruby, Python, etc.

In one embodiment, step 101 includes: parsing the dictionary to determine the lowest-level key in the dictionary, where the value stored in the dictionary corresponding to the lowest-level key is not nested in other dictionaries; generating a file containing the lowest-level key in the dictionary list of.

Therefore, data can be accessed quickly by generating a list containing the lowest-level keys in the dictionary.

For example, FIG. 2 is an exemplary schematic diagram of a dictionary according to an embodiment of the present invention.

As can be seen from Figure 2, dictionary X (the first dictionary) 10 contains keys located at the first level of dictionary other dictionaries, so 'a' and 'b' belong to the bottom keys of dictionary X. The value of ‘c’ contains the second dictionary 11, so ‘c’ does not belong to the bottom key of dictionary X. The second dictionary 11 contains the keys located in the second level of dictionary Belongs to the lowest level key of dictionary X. The value of 'd' contains the third dictionary 12, so 'd' does not belong to the bottom key of dictionary X. The third dictionary 12 contains keys located at the third level of dictionary X: 'd1' and 'd2'. The 'd1' and 'd2' values do not contain other dictionaries, so 'd1' and 'd2' belong to the bottom keys of dictionary X.

The applicant found that in current programming languages such as Scala, PHP, C#, Java, C++, Objective-c, Perl, Swift, VBScript, Javascript, Ruby and Python, forward slashes usually have no special meaning. In one embodiment, when the lowest-level key has a dependency relationship between layers, a forward slash ("/") is used in the list as a connector characterizing the dependency relationship. Therefore, the embodiment of the present invention uses forward slashes, which usually do not have special meaning in programming languages, to describe the relationships of the lowest-level keys with subordinate relationships in the list, which facilitates key-based hash operations and helps users accurately compose regular expressions. .

Example: Assume that the structure of dictionary D is as follows:

It can be seen that the value of 'c' contains the dictionary structure ('c1':5, 'c2':10), and the dictionary structure ('c1':5, 'c2':10) is called dictionary C. It can be seen that 'c' does not belong to the bottom key of dictionary D (the value of the bottom key is no longer nested in other dictionaries). The lowest-level keys of dictionary D include 'a', 'b', 'd', 'c1' and 'c2', where 'c1' and 'c2' are both subordinate to 'c'. Therefore, the generated list includes ['a','b','d','c/c1','c/c2']. 'c/c1' is the key of 'c1' in dictionary D, and 'c/c2' is the key of 'c2' in dictionary D. Among them: "/" can play the role of a connector and is used to determine the lowest-level key with a subordinate relationship. For example, for 'c/c1', the meaning is: 'c1' belongs to the dictionary structure contained by the 'c' value. The key of 'c/c1' is: the combination of the key of 'c' in dictionary D and the key of 'c1' in dictionary C. Therefore, you can directly use the key of 'c/c1' to directly determine ' in dictionary D. The value of c1'.

Step 102: Receive a regular expression containing a matching rule, where the matching rule is described by a string.

Regular expression, also known as regular expression (Regular Expression), often abbreviated as regex, regexp or RE in code, is a text pattern that includes ordinary characters (for example, letters between a to z) and special characters (called "Metacharacters"), a concept in computer science. Regular expressions use a single string to describe and match a series of strings that match a certain syntax rule. They are usually used to retrieve and replace text that matches a certain pattern (rule). A regular expression is a logical formula for string operations. It uses some predefined specific characters and combinations of these specific characters to form a "regular string". This "regular string" is used to express a pair of characters. A filtering logic for strings. Since the main application object of regular expressions is text, it is used in various text editor situations.

Metacharacters in regular expressions often have special meanings. For example, for the metacharacter "?": When the metacharacter immediately follows any other limiter (*, +,?, {n}, {n,}, {n,m}), the matching mode is non-greedy of. Non-greedy mode matches as little of the searched string as possible, while the default greedy mode matches as much of the searched string as possible. For example, for the string "oooo", "o+" will match as many "o"s as possible, resulting in ["oooo"], while "o+?" will match as few "o"s as possible, resulting in ['o ','o','o','o']. For another example, for the metacharacter ".": match any single character except "\n" and "\r".

Here, a regular expression containing matching rules input by the user is received, where the matching rules are described by strings (usually containing ordinary characters and metacharacters).

Step 103: Use the matching rules in the regular expression to match the list.

In one embodiment, using a regular expression to match the list in step 103 includes: using a matching rule to match the list exactly. In an exact match, the key will be matched exactly and a value will be returned. If multiple keys match, an error and message will be raised, thus recommending the use of more precise regular expressions until a single key is matched. If this key does not match at all, nothing is returned. Example 1: Exact match: "abc", then only "abc" can match, "ab"/"Abc"/"abcd" cannot match. Example 2: Exact match: "a\&c" (special characters need to be escaped), then only "a&c" can be matched, not "ab"/"abc"/"a&cd".

In one embodiment, using a regular expression to match the list in step 103 includes: using a matching rule to fuzzy match the list, where fuzzy matching includes at least one of the following: case-insensitive; typo matching. Here, a regular expression will match multiple keys and return multiple values, and the return value is a list of values matched by the key. Example 1: [...] can match characters in the range: "[abc]1", then "a1"/"b1"/"c1" will match, but "ab1"/"x1" will not match. Example 2: [...] can match a range of characters: "[a-f]1", then "a1"/"b1"/"f1" will match, but "q1"/"ab1" will not match. Example 3: [...] can match characters in the range: "[a-f0-9]{6}", then "1a2b3c"/"ffffff"/"ff0102" matches, "abc12"/"A0000F" does not Can match.

Example 1: User input regular expression: D4['cfg.*siid'];

The output is: ('query result:','cfg.*siid',′′,1)

[[('predict_t_config',

'LIST_000000',

'train_cfg_obj_PT',

'LIST_000000',

'siid'),'35788']]

The regular expression matches a key for 'cfg'*siid' and returns a list with one result. The result consists of two parts: the first part is: ('predict_t_config', LIST_000000', ..., 'siid'), which is the matching key tuple. The second part is the value of this matching key. If you use the traditional method, you need to write a long line of code to get the value "35788". For example, D2['predict_t_config']['LIST_000000']['train_cfg_obj_PT']['LIST_000000']['siid'].

Suppose you want to get the values whose keys include 'obligate00' or obligate0'1', etc., until 'obligate05'. Using traditional methods of exact key acquisition would be cumbersome because more code would have to be written.

Example 2: Enter the regular expression: D4['obligate[0-5]']

The result below returns 5 matching values for this regular expression 'obligate[0-5]', which means matching keys containing 'obligate 0' up to 'obligate5'.

The output is:

These regular expression-based methods provide a very efficient and robust way to get, set, and remove keys that may be misspelled. The matched key can be an exact match, which returns only one value, or a fuzzy match, which returns multiple values. It can be seen that the embodiment of the present invention can be case-insensitive and support typo matching through fuzzy matching, thereby reducing user difficulty.

Step 104: Use the hit result of the matching list as the retrieval item, and query the dictionary to access the value corresponding to the retrieval item.

Here, after accessing the value corresponding to the search term, the value corresponding to the search term can be read, deleted, or changed.

In one embodiment, the dictionary includes N levels of keys, where N is a positive integer of at least 2; generating a list containing the keys in the dictionary in step 101 includes: parsing the dictionary to generate N lists, where each list contains Keys of the same corresponding layer in the dictionary; Step 102 includes: receiving N regular expressions containing respective matching rules, where N regular expressions correspond to N lists one-to-one; Step 103 includes: using N regular expressions The respective matching rules in each regular expression are matched with the corresponding list; step 104 includes: using the hit result of each regular expression and the corresponding list as a search term, and determining the matching rule from the corresponding layer in a layer-by-layer matching manner. The value corresponding to the retrieved item.

Therefore, the embodiment of the present invention also uses multiple regular expressions corresponding to the number of layers to determine the value in a layer-by-layer matching manner, thereby reducing the complexity of the list and reducing the difficulty of generating the list.

The embodiments of the present invention can be applied to various scenarios. For example, it can be applied to power data storage in industrial parks.

The data access method of the embodiment of the present invention can be implemented in an energy management system, where the energy management system includes regional energy management systems such as industrial parks and field-level energy management systems such as groups, factories, buildings, and microgrids. The following describes the implementation of the present invention, taking power data management in an industrial park as an example. Figure 3 is a first exemplary flow chart of a data access method according to an embodiment of the present invention.

Step 201: Parse the dictionary that stores the power data in the industrial park to determine the bottom-level key in the dictionary, where no other dictionaries are nested in the values stored in the dictionary that correspond to the bottom-level key. For example, the key in electricity data is usually the geographical location information, and the value can be the electricity consumption at the geographical location information. Since geolocation information is often verbose, it is quite difficult to directly provide accurate keys to query power usage.

For example, taking the dictionary shown in Figure 2 as an example, determine that the bottom-level keys include: 'a', 'b', 'c/c1', 'c/c2', 'c/d/d1' and 'c/d /d2'.

Step 202: Generate a list containing the lowest-level keys in the dictionary.

For example, following the above example, the list [‘a’, ‘b’, ‘c/c1’, ‘c/c2’, ‘c/d/d1’, ‘c/d/d2’] is generated. Based on the key of each element in the list, the address of that element in the dictionary 10 can be determined.

For example, for element 'a': use the key of 'a' in dictionary 10 to determine the address of 'a' in dictionary 10; for element 'c/c1': use the address of 'c' in dictionary 10 (determined by the key of 'c' in dictionary 10) and the address of 'c1' in dictionary 11 (determined by the key of 'c1' in dictionary 11), the address of 'c1' in dictionary 10 can be determined. For element 'c/d/d1': use the address of 'c' in dictionary 10 (determined by the key of 'c' in dictionary 10), the address of 'd' in dictionary 11 (determined by the key of 'd' in dictionary 10 Determined by the key in dictionary 11) and the address of 'd1' in dictionary 12 (determined by the key of 'd1' in dictionary 12), the address of 'd1' in dictionary 10 can be determined.

Step 203: Receive a regular expression containing a matching rule.

Step 204: Use the matching rules in the regular expression to match the list.

Step 205: Use the hit result of the matching list as the retrieval item, and query the dictionary to access the value corresponding to the retrieval item.

Among them, for the elements containing "/" in the list, when the key at the rightmost "/" is matched, it is considered to be matched with the regular expression, regardless of the matching of the left key of the rightmost "/" state. For example, for 'c/d/d2', when 'd2' hits the regular expression, the match is considered successful, regardless of whether 'c' or 'd' hits the regular expression.

For example, when receiving Get the corresponding value. For another example, when receiving X['c.*'], the key of 'c' is retrieved based on the list, the address of 'c' in the first dictionary 10 is determined based on the key, and then 'c' is The address in the dictionary 10 obtains the corresponding value. Even if 'c' in the first dictionary is mistakenly written as 'c4' or other incorrect expressions, the address of 'c' in the first dictionary 10 can still be retrieved correctly. For another example, receive The corresponding value of 'd1' in 10.

Figure 4 is a second exemplary flow chart of a data access method according to an embodiment of the present invention.

Step 301: Parse the dictionary storing the power data in the industrial park (the dictionary includes keys of N layers) to generate N lists, where each list includes keys of the same corresponding layer in the dictionary. For example, the key in electricity data is usually the geographical location information, and the value can be the electricity consumption at the geographical location information. Since geolocation information is often verbose, providing accurate keys directly is challenging.

For example, taking the dictionary shown in Figure 2 as an example, there are three levels, so N equals 3. The keys on the first level include: 'a', 'b', 'c', the keys on the second level include: 'c1', 'c2', 'd', and the keys on the third level include: 'd1' and 'd2'. Therefore, the first list [‘a’, ‘b’, ‘c’], the second list [‘c1’, ‘c2’, ‘d’], and the third list [‘d1’, ‘d2’] are generated.

Step 302: Receive up to N regular expressions, where N regular expressions correspond to N lists one-to-one, and each regular expression contains its own matching rule.

Determine the number of regular expressions that need to be received based on the level of the value that needs to be obtained. For example, receive a regular expression: X[‘a’] to get the value of ‘a’ in the first level. Alternatively, receive 2 regular expressions: X[‘c’] and X[‘c1’] to get the value of ‘c1’ in the second layer. Alternatively, receive 3 regular expressions: X[‘c’], X[‘d’] and X[‘d2’] to get the value of ‘d2’ in the third layer.

Step 303: Match each of the N regular expressions with the corresponding list.

Step 304: Using the hit result of the matching list as the search item, querying the dictionary to access the value corresponding to the search item includes: using the hit result of each regular expression and the corresponding list as the search item, and matching from the corresponding layer in a layer-by-layer manner. Determine the value corresponding to the search term.

For example, when receiving a regular expression: to the value 1.

For example, when receiving two regular expressions corresponding to the two layers from the outside to the inside: X['c'] and X['c1'], you can convert the 'c'] matches the first list to obtain the key with 'c' in the first level, and uses this key to detect dictionary 10 to obtain the corresponding value, that is, dictionary 11. Then, match X['c1'] corresponding to the second layer with the second list to obtain the key of 'c1' in the second layer, and use the key of 'c1' to detect dictionary 11 to obtain the value, that is, 5 .

For example, when receiving three regular expressions corresponding to the three layers from the outside to the inside: X['c'], X['d'] and X['d2'], you can The (outermost) X['c'] matches the first list to obtain the key of 'c' in the first level, and uses this key to detect the first dictionary 10 to obtain the value, that is, the second dictionary 11. Then, match the X['d'] corresponding to the second layer with the second list to obtain the key with 'd' in the second layer, that is, the third dictionary 12, and match the X['d2 corresponding to the third layer '] matches the third list to obtain the key of 'd2' in the third layer, and uses the key of 'd2' to detect the third dictionary 12 to obtain the value, that is, 8.

The embodiment of the present invention also provides a data access device. Figure 5 is an exemplary structural diagram of a data access device according to an embodiment of the present invention. As shown in Figure 5, the data access device 500 includes:

The list generation module 501 is configured to generate a list containing keys in the dictionary, where the dictionary stores data in the form of key-value pairs, and the list supports regular matching;

The receiving module 502 is configured to receive a regular expression containing a matching rule, where the matching rule is described by a string;

The matching module 503 is configured to match the list using the matching rules in the regular expression;

The query module 504 is configured to use the hit result of the matching list as a retrieval item, and query the dictionary to access the value corresponding to the retrieval item.

In an exemplary embodiment, the list generation module 501 is configured to parse the dictionary to determine the bottom-level key in the dictionary, where the values stored in the dictionary corresponding to the bottom-level key are not nested in other dictionaries; generate a dictionary containing The list of lowest-level keys in .

In an exemplary embodiment, the list generation module 501 is configured to use a forward slash as a connector characterizing the dependency relationship in the list when the lowest-level key has a dependency relationship between layers.

In an exemplary embodiment, the dictionary includes N levels of keys, where N is a positive integer of at least 2; the list generation module 501 is configured to parse the dictionary to generate N lists, where each list contains the same key in the dictionary. The key of the corresponding layer; the receiving module 502 is configured to receive N regular expressions containing respective matching rules, where the N regular expressions correspond to N lists one-to-one; the matching module 503 is configured to utilize N regular expressions The respective matching rules in each regular expression in the formula are matched with the corresponding list; the query module 504 is configured to use the hit result of each regular expression and the corresponding list as a retrieval item, in a layer-by-layer matching manner. The value corresponding to the retrieval item is determined in the corresponding layer.

In an exemplary embodiment, the matching module 503 is configured to accurately match the list using matching rules; or fuzzy matching the list using matching rules, where fuzzy matching includes at least one of the following: case-insensitive; typo matching.

The embodiment of the present invention also provides an electronic device with a processor-memory architecture. FIG. 6 is an exemplary structural diagram of an electronic device according to an embodiment of the present invention.

As shown in Figure 6, the electronic device 600 includes a processor 601, a memory 602, and a computer program stored in the memory 602 and executable on the processor 601. When the computer program is executed by the processor 601, any of the above data accesses are implemented. method. Among them, the memory 602 can be implemented as various storage media such as electrically erasable programmable read-only memory (EEPROM), flash memory (Flash memory), programmable programmable read-only memory (PROM), etc. The processor 601 may be implemented to include one or more central processing units or one or more field programmable gate arrays, where the field programmable gate array integrates one or more central processing unit cores. Specifically, the central processing unit or central processing unit core may be implemented as a CPU, an MCU, a DSP, or the like.

It should be noted that not all steps and modules in the above-mentioned processes and structure diagrams are necessary, and some steps or modules can be ignored according to actual needs. The execution order of each step is not fixed and can be adjusted as needed. The division of each module is only for the convenience of describing the functional division. In actual implementation, one module can be implemented by multiple modules, and the functions of multiple modules can also be implemented by the same module. These modules can be located on the same device. , or it can be on a different device.

The hardware modules in various embodiments may be implemented mechanically or electronically. For example, a hardware module may include specially designed permanent circuits or logic devices (such as a dedicated processor such as an FPGA or ASIC) to perform specific operations. Hardware modules may also include programmable logic devices or circuits (such as general-purpose processors or other programmable processors) temporarily configured by software to perform specific operations. As for the specific use of mechanical means, or the use of dedicated permanent circuits, or the use of temporarily configured circuits (such as configured by software) to implement the hardware modules, it can be decided based on cost and time considerations.

The above descriptions are only preferred embodiments of the present invention and are not intended to limit the scope of the present invention. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present invention shall be included in the protection scope of the present invention.

Claims (13)

1. A data access method (100), characterized in that the method (100) includes:

   Generate a list containing keys in a dictionary, where the dictionary stores data in the form of key-value pairs, and the list supports regular matching (101);

   Receive a regular expression containing a matching rule, where the matching rule is described by a string (102);

   Match the list using the matching rule in the regular expression (103);

   Using hits matching the list as search terms, the dictionary is queried to access values corresponding to the search terms (104).
2. The method (100) according to claim 1, characterized in that:

   Generating a list (101) containing keys in a dictionary includes:

   Parse the dictionary to determine the lowest-level key in the dictionary, wherein no other dictionaries are nested in the values stored in the dictionary corresponding to the lowest-level key;

   Generate a list containing the lowest-level keys in the dictionary.
3. The method (100) according to claim 2, characterized in that when the bottom-layer key has a dependency relationship between layers, a forward slash is used in the list as a connector characterizing the dependency relationship.
4. The method (100) according to claim 1, characterized in that the dictionary includes keys of N levels, where N is a positive integer of at least 2;

   Said generating a list containing keys in the dictionary (101) includes: parsing the dictionary to generate N lists, wherein each list contains keys of the same corresponding level in the dictionary;

   The receiving regular expressions containing matching rules (102) includes: receiving N regular expressions containing respective matching rules, wherein the N regular expressions correspond to the N lists one-to-one;

   The using the matching rules in the regular expressions to match the list (103) includes: using the respective matching rules in each of the N regular expressions to match the corresponding list;

   The step of using the hit result matching the list as a retrieval item and querying the dictionary to access the value corresponding to the retrieval item (104) includes: using the hit result of each regular expression and the corresponding list as a retrieval item, The value corresponding to the retrieval term is determined from the corresponding layer in a layer-by-layer matching manner.
5. The method (100) according to any one of claims 1-4, characterized in that, using the matching rule in a regular expression to match the list (103) includes:

   Exactly match the list using the matching rules; or

   The list is fuzzy matched using the matching rule, wherein the fuzzy match includes at least one of the following:

   Case-insensitive; typo matching.
6. A data access device (500), characterized in that the device (500) includes:

   The list generation module (501) is configured to generate a list containing keys in a dictionary, where the dictionary stores data in the form of key-value pairs, and the list supports regular matching;

   The receiving module (502) is configured to receive a regular expression containing a matching rule, where the matching rule is described by a character string;

   A matching module (503) configured to match the list using the matching rule in the regular expression;

   The query module (504) is configured to use hit results matching the list as retrieval items, and query the dictionary to access values corresponding to the retrieval items.
7. The device (500) according to claim 6, characterized in that

   The list generation module (501) is configured to parse the dictionary to determine the bottom-level key in the dictionary, wherein the value stored in the dictionary corresponding to the bottom-level key does not nest other values. Dictionary; generates a list containing the lowest-level keys in the dictionary.
8. The device (500) according to claim 7, characterized in that

   The list generation module (501) is configured to use a forward slash as a connector characterizing the dependency relationship in the list when the lowest-level key has a dependency relationship between layers.
9. The device (500) according to claim 6, characterized in that the dictionary includes N levels of keys, where N is a positive integer of at least 2;

   The list generation module (501) is configured to parse the dictionary to generate N lists, where each list contains keys of the same corresponding layer in the dictionary;

   The receiving module (502) is configured to receive N regular expressions containing respective matching rules, wherein the N regular expressions correspond to the N lists one-to-one;

   The matching module (503) is configured to use respective matching rules in each of the N regular expressions to match the corresponding list;

   The query module (504) is configured to use the hit result of each regular expression and the corresponding list as a retrieval item, and determine the value corresponding to the retrieval item from the corresponding layer in a layer-by-layer matching manner.
10. The device (500) according to any one of claims 6-9, characterized in that,

    The matching module (503) is configured to accurately match the list using the matching rules; or to fuzzy match the list using the matching rules, wherein the fuzzy matching includes at least one of the following:

    Case-insensitive; typo matching.
11. An electronic device (600), characterized by including:

    processor(601);

    Memory (602), used to store executable instructions of the processor;

    The processor (601) is configured to read the executable instructions from the memory (602) and execute the executable instructions to implement the data access method according to any one of claims 1-5 (100).
12. A computer-readable storage medium having computer instructions stored thereon, characterized in that when the computer instructions are executed by a processor, the data access method (100) described in any one of claims 1-5 is implemented.
13. A computer program product, characterized by comprising a computer program that implements the data access method (100) according to any one of claims 1-5 when executed by a processor.

Images