CN111597164A - Database structure testing method, database structure testing device and terminal equipment - Google Patents

Abstract

The application is applicable to the field of computers, and provides a database structure testing method, a database structure testing device and terminal equipment, wherein the method comprises the following steps: the method comprises the steps of obtaining a regular expression to be detected in front-end codes, and converting the regular expression which accords with the language rules of the front-end codes into first database data which accords with the structured query language rules; extracting all second database fields matched with the first database fields and second data attributes corresponding to each second database field from a preset database; and comparing the first database data with each group of second database data to obtain a test result, wherein each group of second database data comprises a second database field and a second data attribute corresponding to the second database field. By the method, the efficiency of the database structure test and the accuracy of the test result can be effectively improved.

Description

Database structure testing method, database structure testing device and terminal equipment

technical field

The application belongs to the field of computers, and in particular relates to a database structure testing method, a database structure testing device and terminal equipment.

Background technique

In the software development process, the attributes of the data are usually defined in the database. For example: define a data property in a dialog box as a value. Because front-end developers don't pay enough attention to data attributes, it often happens that the data attributes acquired by the front-end are different from those defined by the database. This requires database structure testing.

Existing database structure testing methods are usually exhaustive testing by testers. For example, when testing data attributes in a dialog box, it is necessary to input data of different attributes one by one to confirm whether the data attributes in the dialog box are correct. Such testing methods are less efficient, and due to the inertial thinking of the testers, the accuracy of the test results is also lower.

SUMMARY OF THE INVENTION

The embodiments of the present application provide a database structure testing method, a database structure testing device and a terminal device, which can solve the problems of low testing efficiency and low test result accuracy of the existing database structure testing method.

In a first aspect, an embodiment of the present application provides a method for testing a database structure, the method comprising:

Obtain the regular expression to be detected in the front-end code, and convert the regular expression that conforms to the front-end code language rules into first database data that conforms to the structured query language rules, wherein the first database data includes the first database field and the first data attribute corresponding to the first database field;

Extract all second database fields that match the first database fields, and second data attributes corresponding to each second database field from a preset database;

Comparing the first database data with each group of second database data respectively to obtain a test result, wherein each group of second database data includes a second database field and second data corresponding to the second database field Attributes.

In a possible implementation manner of the first aspect, converting the regularized expression conforming to the front-end code language rules into the first database data conforming to the structured query language rules includes:

Obtain the preset mapping relationship between the front-end code language rules and the back-end code language rules, and convert the regular expression into back-end data that complies with the back-end code language rules according to the preset mapping relationship. The back-end data includes at least one back-end code field and a third data attribute corresponding to each back-end code field;

For each back-end code field, convert the back-end code field into a first database field that conforms to structured query language rules, and set the first data attribute corresponding to the first database field as the back-end code The third data attribute corresponding to the field.

In a possible implementation manner of the first aspect, converting the regular expression into back-end data conforming to the back-end code language rule according to the preset mapping relationship includes:

Identifying the back-end code function corresponding to the regular expression according to the preset mapping relationship;

According to the definition rule of the back-end code function, the back-end code field and the third data attribute corresponding to the back-end code field are extracted from the back-end code function to obtain the back-end data.

In a possible implementation manner of the first aspect, the first database data is compared with each group of second database data respectively to obtain a test result, including:

For each first database field, search for the second database field that is the same as the first database field in each group of second database data;

If the second database field that is the same as the first database field is not found in each group of second database data, a first abnormal result is generated, and the first abnormal result is used to indicate that the second database data does not contain the same second database field. there is a second database field identical to the first database field;

If a second database field that is the same as the first database field is found in each set of second database data, a test result is generated according to the first set and the second set, where the first set is the first set A set of first data attributes corresponding to a database field, and the second set is a set of second data attributes corresponding to a second database field that is the same as the first database field.

In a possible implementation manner of the first aspect, the generating the test result according to the first set and the second set includes:

if the first set is the same as the second set, generating a normal result;

If there is no intersection between the first set and the second set, a second abnormal result is generated, and the second abnormal result is used to prompt the user to re-test;

If the first set does contain the second set, a third abnormal result is generated, and the third abnormal result is used to prompt the user to delete the first data attribute in the first set that does not belong to the second set ;

If the second set does contain the first set, a fourth abnormal result is generated, where the fourth abnormal result is used to prompt the user to attribute the second data in the second set that does not belong to the first set added to the first set.

In a possible implementation manner of the first aspect, the method further includes:

Obtaining multiple sets of training samples, wherein each set of training samples includes a regular expression and a back-end code function corresponding to the regular expression;

The preset neural network is trained by using the multiple sets of training samples to obtain a trained neural network, and the trained neural network is used as the preset mapping relationship.

In a possible implementation manner of the first aspect, the training of the preset neural network by using the multiple sets of training samples includes:

For each group of training samples, the regular expressions in the training samples are divided into at least one grammatical unit according to the grammatical structure, and the grammatical unit is used as the input of the neural network.

In a second aspect, an embodiment of the present application provides a database structure testing device, including:

an acquisition unit, configured to acquire the regular expression to be detected in the front-end code, and convert the regular expression that conforms to the front-end code language rules into first database data that conforms to the structured query language rules, wherein the first database The data includes a first database field and a first data attribute corresponding to the first database field;

an extraction unit, configured to extract from a preset database all second database fields matching the first database fields, and second data attributes corresponding to each second database field;

A test unit, configured to compare the first database data with each group of second database data respectively to obtain a test result, wherein each group of second database data includes a second database field and the second database field The corresponding second data attribute.

In a third aspect, an embodiment of the present application provides a terminal device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes all When the computer program is used, the database structure testing method according to any one of the above-mentioned first aspects is realized.

In a fourth aspect, an embodiment of the present application provides a computer-readable storage medium, where a computer program is stored in the computer-readable storage medium, wherein, when the computer program is executed by a processor, the above-mentioned first aspect is implemented The database structure testing method of any one.

In a fifth aspect, an embodiment of the present application provides a computer program product that, when the computer program product runs on a terminal device, enables the terminal device to execute the database structure testing method described in any one of the first aspects above.

It can be understood that, for the beneficial effects of the second aspect to the fifth aspect, reference may be made to the relevant description in the first aspect, which is not repeated here.

The beneficial effects that the embodiments of the present application have compared with the prior art are:

In this embodiment of the present application, the regular expression to be detected in the front-end code is obtained, and the regular expression conforming to the front-end code language rules is converted into the first database data conforming to the structured query language rules, wherein the first database The data includes a first database field and a first data attribute corresponding to the first database field; the structured query language is a language that can be recognized by the database, and the essence of the conversion is to convert the front-end code into a database language; Extract all the second database fields that match the first database fields, and the second data attributes corresponding to each second database field; compare the first database data with each group of second database data respectively to obtain The test result, wherein each set of second database data includes a second database field and a second data attribute corresponding to the second database field. Using the above method, the data attributes corresponding to the matching fields in the front-end code and the database are compared, and through objective data comparison, the wrong results caused by manual testing due to experience are avoided, and the accuracy of the test results is improved. Through the above method, the database structure can be automatically tested, the tediousness of the exhaustive method test is avoided, the test efficiency is improved, and the accuracy of the test result is improved at the same time.

Description of drawings

In order to illustrate the technical solutions in the embodiments of the present application more clearly, the following briefly introduces the accompanying drawings that need to be used in the description of the embodiments or the prior art. Obviously, the drawings in the following description are only for the present application. In some embodiments, for those of ordinary skill in the art, other drawings can also be obtained according to these drawings without any creative effort.

1 is a schematic diagram of a database system provided by an embodiment of the present application;

2 is a schematic flowchart of a database structure testing method provided by an embodiment of the present application;

3 is a schematic flowchart of a method for establishing a preset dictionary provided by an embodiment of the present application;

4 is a schematic structural diagram of a database structure testing device provided by an embodiment of the present application;

FIG. 5 is a schematic structural diagram of a terminal device provided by an embodiment of the present application.

Detailed ways

In the following description, for the purpose of illustration rather than limitation, specific details such as a specific system structure and technology are set forth in order to provide a thorough understanding of the embodiments of the present application. However, it will be apparent to those skilled in the art that the present application may be practiced in other embodiments without these specific details. In other instances, detailed descriptions of well-known systems, devices, circuits, and methods are omitted so as not to obscure the description of the present application with unnecessary detail.

It is to be understood that, when used in this specification and the appended claims, the term "comprising" indicates the presence of the described feature, integer, step, operation, element and/or component, but does not exclude one or more other The presence or addition of features, integers, steps, operations, elements, components and/or sets thereof.

As used in the specification of this application and the appended claims, the term "if" may be contextually interpreted as "when" or "once" or "in response to determining" or "in response to detecting ".

In addition, in the description of the specification of the present application and the appended claims, the terms "first", "second", "third", etc. are only used to distinguish the description, and should not be construed as indicating or implying relative importance.

References in this specification to "one embodiment" or "some embodiments" and the like mean that a particular feature, structure or characteristic described in connection with the embodiment is included in one or more embodiments of the present application. Thus, appearances of the phrases "in one embodiment," "in some embodiments," "in other embodiments," "in other embodiments," etc. in various places in this specification are not necessarily All refer to the same embodiment, but mean "one or more but not all embodiments" unless specifically emphasized otherwise.

First, an application scenario of the database structure testing method provided by the embodiment of the present application is introduced. Referring to FIG. 1 , it is a schematic diagram of a database system according to an embodiment of the present application. As shown in the figure, the database system may include: a database server 101 and a database 102 . The database server tests the database structure by using the database structure testing method provided in the embodiment of the present application. Specifically, the database server obtains the regular expression to be detected in the front-end code, converts the regular expression into the first database data that can be recognized by the database; and extracts the second database data corresponding to the first database data from the database, and then The first database data and the second database data are compared to obtain a test result.

In practical applications, the database server can also be deployed separately as a front-end server and a back-end server. The front-end server communicates with the back-end server through the interface, and the back-end server communicates with the database. In this case, in the database structure testing method provided by the embodiment of the present application, the regular expression to be detected in the front-end code is obtained through the front-end server, and the regular expression is converted into a post-processing code that can be recognized by the back-end server according to the preset mapping relationship. The back-end data is sent to the back-end server; then the back-end data is converted into the first database data that can be recognized by the database through the back-end server, and the second database data corresponding to the first database data is extracted from the database. , and compare the first database data with the second database data to obtain the test result.

Referring to FIG. 2 , it is a schematic flowchart of a database structure testing method according to an embodiment of the present application. As shown in Figure 2, the method may include:

S201: Acquire a regular expression to be detected in the front-end code, and convert the regular expression conforming to the front-end code language rules into first database data conforming to the structured query language rules.

The first database data includes a first database field and a first data attribute corresponding to the first database field.

Exemplarily, it is assumed that the first database data is (phone, number), where "phone" is the first database field, and "number" is the first data attribute. That is, the first data attribute is used to define the data structure of the first database field.

A regular expression is a search pattern formed by a sequence of characters, which can be used to describe and match a series of strings that conform to a certain syntactic rule. In other words, a regular expression can describe a pattern of character combinations in a string. For example, a and b means a string containing two characters a and b, and "database" is a search result that matches the regular expression.

When searching for data in text, you can use search patterns to describe what you are looking for. Regular expressions are often used in front-end pages.

In step S201, the regular expression is essentially a front-end code, and usually the voice used by the front-end code is Javascript. The first database data is SQL data, that is, data conforming to the rules of structured query language. Since the front-end code language and database language are different, it is not possible to directly compare the two. It is necessary to convert the two into the same language before comparing.

In practical applications, the regular expression can be converted into JSON-formatted data first, and then the JSON-formatted data can be converted into SQL data (ie, structured query language). This conversion method needs to write conversion code. For different regular expressions, you need to rewrite or modify the conversion code. In other words, each regular expression needs to correspond to a set of conversion codes, which makes the conversion process more complicated. , the conversion efficiency is low.

In one embodiment, in step S201, converting the regularized expression conforming to the front-end code language rules into first database data conforming to the structured query language rules includes:

S11: Acquire a preset mapping relationship between the front-end code language rules and the back-end code language rules, and convert the regular expression into back-end data conforming to the back-end code language rules according to the preset mapping relationship , the back-end data includes at least one back-end code field and a third data attribute corresponding to each back-end code field.

The preset mapping relationship can be established in advance, so that when data needs to be converted, back-end data corresponding to a regular expression can be quickly found according to the preset mapping relationship, which improves the conversion efficiency.

Converting regular expressions into back-end data is actually the process of converting front-end code into back-end code. Because the front-end code is usually in JavaScript, and the back-end code is usually in C++.

S12, for each back-end code field, convert the back-end code field into a first database field that complies with the structured query language rules, and set the first data attribute corresponding to the first database field to the back-end code field The third data attribute corresponding to the terminal code field.

Because the database is based on Structured Query Language (SQL for short), translating the back-end code field into the first database field is actually a process of converting the back-end code into a database language.

In practical applications, there is another possibility that the expression of the back-end code field is different from that of the first database field. For example, the back-end code field is "mobil", and the corresponding first database field is "phone". The meanings they express are all mobile phones, but the expressions are different, and conversions are also required in this case.

In one embodiment, step S11, converting the regular expression into back-end data conforming to the back-end code language rule according to the preset mapping relationship includes:

S111: Identify a back-end code function corresponding to the regular expression according to the preset mapping relationship.

S112, according to the definition rule of the back-end code function, extract the back-end code field and the third data attribute corresponding to the back-end code field from the back-end code function to obtain the back-end data.

Exemplarily, it is assumed that the back-end code function is set(a, b), and the definition rule of this function is to set the attribute of a to b. According to the definition rules of this function, the extracted back-end code field is a, and the third data attribute is b. It should be noted that this is only to explain the process of extracting back-end data from back-end code functions, and does not make any specific restrictions.

Since the definition rules of the back-end code functions are invariable and well known, the variables (that is, the back-end code fields) and attributes (that is, the third data) in the back-end code functions can be obtained by obtaining the back-end code functions. Attributes).

S202: Extract all second database fields matching the first database fields and second data attributes corresponding to each second database field from a preset database.

The database preset in the embodiment of the present application refers to a database corresponding to the database server that executes the database structure testing method in the embodiment of the present application.

Each first database field may match multiple second database fields. The matching here may mean that the first database field is completely the same as the second database field, or it may mean that the first database field and the second database field are partially identical. Exemplarily, assuming that the first database field is "name", there are multiple second database fields such as "name_number", "name_length", and "name" that match "name" in the database, wherein "name_number" and "name_length" ” is a second database field that is partially identical to the first database field.

S203, comparing the first database data with each group of second database data respectively to obtain a test result.

Wherein, each set of second database data includes a second database field and a second data attribute corresponding to the second database field.

In one embodiment, in step S203, the first database data is compared with each group of second database data respectively to obtain a test result, including:

S21. For each first database field, search for a second database field that is the same as the first database field in each group of second database data.

The same here means that the first database field is exactly the same as the second database field. Since there may be multiple second database fields that match the first database field, when comparing, the attributes of two identical fields are actually compared. Therefore, it is first necessary to find a second database field that is identical to the first database field. As in the above example, the second field corresponding to "name" includes "name_number", "name_length", "name", etc., and only the second field "name" is the same.

S22, if the second database field that is the same as the first database field is not found in each group of second database data, generate a first abnormal result, where the first abnormal result is used to represent the second database data There is no second database field that is the same as the first database field.

S23, if a second database field that is the same as the first database field is found in each group of second database data, generate a test result according to the first set and the second set, wherein the first set is the A set of first data attributes corresponding to a first database field, and the second set is a set of second data attributes corresponding to a second database field that is the same as the first database field.

In one embodiment, step S23, generating test results according to the first set and the second set, including:

S231, if the first set is the same as the second set, generate a normal result.

The fact that the first set is the same as the second set means that each second data attribute in the second set can be found in the first set, and each first data attribute in the first set can also be found in the second set. At this point, it means that the attributes defined by the front end are consistent with the attributes defined by the database.

S232, if the first set and the second set have no intersection, generate a second abnormal result, where the second abnormal result is used to prompt the user to re-test.

This situation means that the properties defined by the front end and the properties defined by the database are completely different. At this time, it may be caused by an error in the execution of the previous steps S201-S202, or there may be a problem with the database structure itself. In this case, the user may be prompted to perform steps S201-S202 again.

S233, if the first set really includes the second set, generate a third abnormal result, where the third abnormal result is used to prompt the user to delete the first set in the first set that does not belong to the second set data attributes.

In this case, the attributes defined by the front end are beyond the scope defined by the database.

S234, if the second set really includes the first set, generate a fourth abnormal result, where the fourth abnormal result is used to prompt the user to assign the second set that does not belong to the first set in the second set A data attribute is added to the first set.

In this case, the attributes defined by the front-end are incomplete.

In this embodiment of the present application, the regular expression to be detected in the front-end code is obtained, and the regular expression conforming to the front-end code language rules is converted into the first database data conforming to the structured query language rules, wherein the first database The data includes a first database field and a first data attribute corresponding to the first database field; the structured query language is a language that can be recognized by the database, and the essence of the conversion is to convert the front-end code into a database language; Extract all the second database fields that match the first database fields, and the second data attributes corresponding to each second database field; compare the first database data with each group of second database data respectively to obtain The test result, wherein each set of second database data includes a second database field and a second data attribute corresponding to the second database field. Using the above method, the data attributes corresponding to the matching fields in the front-end code and the database are compared, and through objective data comparison, the wrong results caused by manual testing due to experience are avoided, and the accuracy of the test results is improved. Through the above method, the database structure can be automatically tested, the tediousness of the exhaustive method test is avoided, the test efficiency is improved, and the accuracy of the test result is improved at the same time.

Referring to FIG. 3 , it is a schematic flowchart of a method for establishing a preset dictionary according to an embodiment of the present application.

As an embodiment of the present application, the preset mapping relationship may be a trained neural network. Because in the process of code development, the front-end code language has certain rules, and the back-end code language also has certain rules, so the mapping relationship between the front-end code language rules and the back-end code language rules can be established in advance. The regular expression is actually the front-end code, and the back-end code function belongs to the back-end code. Using the pre-established mapping relationship, the back-end code function corresponding to the regular expression can be found quickly and accurately.

As shown in Figure 3, the method for establishing the preset dictionary may include:

S301: Acquire multiple sets of training samples, wherein each set of training samples includes a regular expression and a back-end code function corresponding to the regular expression.

S302, using the multiple sets of training samples to train a preset neural network to obtain a trained neural network, and using the trained neural network as the preset mapping relationship.

Optionally, for each group of training samples, the regular expression in the training samples may be divided into at least one grammatical unit according to the grammatical structure, and the grammatical unit may be used as the input of the neural network for training.

Exemplarily, it is assumed that a regularized expression A and B can be split into 3 grammatical units, namely "A", "and" and "B", and these 3 grammatical units are used as the input of the neural network.

Use the training samples to train the neural network. If the output result of the neural network corresponding to a training sample is the back-end code function corresponding to the training sample, it means that the recognition is correct, otherwise the recognition is wrong. When the recognition accuracy reaches the preset value, the training ends.

In this embodiment, after the regularized expression is divided into grammatical elements, the neural network is trained, which is actually to find the combination relationship between the grammatical elements, and further, to determine the back-end code function corresponding to the combination relationship. In other words, which lemmas are grouped together to identify what backend code functions result.

Exemplarily, the neural network recognition results of the regularized expression "mobile phone and number" and the regularized expression "mobile phone and number" may be similar because the search patterns of the two regularized expressions are the same. Assume that the back-end code functions corresponding to these two regular expressions are set(a, b) (where a is the content before "and", that is, "mobile phone", and b is the content after "and", that is, " number" or "numerical value"), then their neural network recognition results are consistent. That is to say, no matter how the content changes, the structure of the function body is the same. If a new regular expression "mobile phone and character" appears, its search mode is the same as the previous two, that is to say, their back-end function main structure is the same, then the corresponding neural network recognition result will also be is set(a,b). It should be noted that the above examples are only used to explain the correspondence between regular expressions and back-end code functions, and are not used to specifically limit the forms, meanings, etc. of regular expressions and back-end code functions.

In the embodiment of the present application, the neural network is trained by using multiple training samples, that is, the mapping relationship between the regular expression and the back-end code function is found; then the trained neural network is used as the preset mapping relationship. After the regular expression, the corresponding back-end code function can be obtained automatically, quickly and accurately by using the established preset dictionary. Through the above method, the efficiency of the database structure testing method is effectively improved.

It should be understood that the size of the sequence numbers of the steps in the above embodiments does not mean the sequence of execution, and the execution sequence of each process should be determined by its function and internal logic, and should not constitute any limitation to the implementation process of the embodiments of the present application.

Corresponding to the switching method of the working mode described in the above embodiment, FIG. 4 shows a structural block diagram of the database structure testing apparatus provided by the embodiment of the present application. For the convenience of description, only the part related to the embodiment of the present application is shown. .

4, the device 4 includes:

The obtaining unit 41 is used to obtain the regular expression to be detected in the front-end code, and convert the regular expression conforming to the front-end code language rules into first database data conforming to the structured query language rules, wherein the first The database data includes a first database field and a first data attribute corresponding to the first database field.

The extracting unit 42 extracts all the second database fields matching the first database fields and the second data attributes corresponding to each second database field from the preset database.

The test unit 43 is configured to compare the first database data with each group of second database data respectively to obtain a test result, wherein each group of second database data includes a second database field and a The second data attribute corresponding to the field.

Optionally, the obtaining unit 41 includes:

a first conversion module, configured to obtain a preset mapping relationship between the front-end code language rules and the back-end code language rules, and convert the regular expression into a language that conforms to the back-end code according to the preset mapping relationship The back-end data of the rule, the back-end data includes at least one back-end code field and a third data attribute corresponding to each back-end code field.

The second conversion module is configured to, for each back-end code field, convert the back-end code field into a first database field conforming to the rules of structured query language, and convert the first data attribute corresponding to the first database field Set to the third data attribute corresponding to the back-end code field.

Optionally, the first conversion module includes:

The identification sub-module is configured to identify the back-end code function corresponding to the regular expression according to the preset mapping relationship.

The extraction sub-module is configured to extract the back-end code field and the third data attribute corresponding to the back-end code field from the back-end code function according to the definition rule of the back-end code function, and obtain the backend data.

Optionally, the testing unit 43 includes:

The search module is configured to extract the back-end code field and the third data attribute corresponding to the back-end code field from the back-end code function according to the definition rule of the back-end code function, and obtain the back-end code field. end data.

The first result module is configured to generate a first abnormal result if the second database field that is the same as the first database field is not found in each group of second database data, and the first abnormal result is used to indicate all The second database field that is the same as the first database field does not exist in the second database data.

The second result module is configured to generate a test result according to the first set and the second set if a second database field that is the same as the first database field is found in each set of second database data, wherein the first A set is a set of first data attributes corresponding to the first database field, and the second set is a set of second data attributes corresponding to a second database field that is the same as the first database field.

Optionally, the second result module is further configured to generate a normal result if the first set is the same as the second set; and generate a second exception if the first set and the second set have no intersection As a result, the second abnormal result is used to prompt the user to perform the test again; if the first set really includes the second set, a third abnormal result is generated, and the third abnormal result is used to prompt the user to delete the The first data attribute in the first set that does not belong to the second set; if the second set really contains the first set, a fourth abnormal result is generated, and the fourth abnormal result is used to prompt the user to A second data attribute in the second set that does not belong to the first set is added to the first set.

Optionally, the device 4 further includes:

The sample acquisition unit is used for acquiring multiple sets of training samples, wherein each set of training samples includes a regular expression and a back-end code function corresponding to the regular expression.

A training unit, configured to train a preset neural network by using the multiple sets of training samples to obtain a trained neural network, and use the trained neural network as the preset mapping relationship.

Optionally, the training unit is further configured to, for each group of training samples, divide the regular expression in the training samples into at least one grammatical unit according to the grammatical structure, and use the grammatical unit as the input of the neural network.

It should be noted that the information exchange, execution process and other contents between the above-mentioned devices/units are based on the same concept as the method embodiments of the present application. For specific functions and technical effects, please refer to the method embodiments section. It is not repeated here.

In addition, the database structure testing device shown in FIG. 4 can be a software unit, a hardware unit, or a unit combining software and hardware built into the existing terminal equipment, or can be integrated into the terminal equipment as an independent pendant, and also Can exist as an independent terminal device.

Those skilled in the art can clearly understand that, for the convenience and simplicity of description, only the division of the above-mentioned functional units and modules is used as an example. Module completion, that is, dividing the internal structure of the device into different functional units or modules to complete all or part of the functions described above. Each functional unit and module in the embodiment may be integrated in one processing unit, or each unit may exist physically alone, or two or more units may be integrated in one unit, and the above-mentioned integrated units may adopt hardware. It can also be realized in the form of software functional units. In addition, the specific names of the functional units and modules are only for the convenience of distinguishing from each other, and are not used to limit the protection scope of the present application. For the specific working processes of the units and modules in the above-mentioned system, reference may be made to the corresponding processes in the foregoing method embodiments, which will not be repeated here.

FIG. 5 is a schematic structural diagram of a terminal device according to an embodiment of the present application. As shown in FIG. 5 , the terminal device 5 in this embodiment includes: at least one processor 50 (only one is shown in FIG. 5 ), a processor, a memory 51 , and a processor stored in the memory 51 and can be processed in the at least one processor A computer program 52 running on the processor 50, the processor 50 implements the steps in any of the above method embodiments when the computer program 52 is executed.

The terminal device may include, but is not limited to, a processor and a memory. Those skilled in the art can understand that FIG. 5 is only an example of the terminal device 5, and does not constitute a limitation on the terminal device 5. It may include more or less components than the one shown, or combine some components, or different components , for example, may also include input and output devices, network access devices, and the like.

The so-called processor 50 may be a central processing unit (Central Processing Unit, CPU), and the processor 50 may also be other general-purpose processors, digital signal processors (Digital Signal Processors, DSP), application specific integrated circuits (Application Specific Integrated Circuits) , ASIC), off-the-shelf programmable gate array (Field-Programmable Gate Array, FPGA) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like.

The memory 51 may be an internal storage unit of the terminal device 5 in some embodiments, such as a hard disk or a memory of the terminal device 5 . The memory 51 may also be an external storage device of the terminal device 5 in other embodiments, such as a plug-in hard disk, a smart memory card (Smart Media Card, SMC), a secure digital (Secure Digital, SD) card, flash memory card (Flash Card), etc. Further, the memory 51 may also include both an internal storage unit of the terminal device 5 and an external storage device. The memory 51 is used to store an operating system, an application program, a boot loader (Boot Loader), data, and other programs, such as program codes of the computer program, and the like. The memory 51 can also be used to temporarily store data that has been output or will be output.

Embodiments of the present application further provide a computer-readable storage medium, where a computer program is stored in the computer-readable storage medium, and when the computer program is executed by a processor, the steps in the foregoing method embodiments can be implemented.

The embodiments of the present application provide a computer program product, when the computer program product runs on a mobile terminal, the steps in the foregoing method embodiments can be implemented when the mobile terminal executes the computer program product.

The integrated unit, if implemented in the form of a software functional unit and sold or used as an independent product, may be stored in a computer-readable storage medium. Based on this understanding, the present application realizes all or part of the processes in the methods of the above embodiments, which can be completed by instructing the relevant hardware through a computer program, and the computer program can be stored in a computer-readable storage medium. When executed by a processor, the steps of each of the above method embodiments can be implemented. Wherein, the computer program includes computer program code, and the computer program code may be in the form of source code, object code, executable file or some intermediate form, and the like. The computer-readable medium may include at least: any entity or device capable of carrying the computer program code to the photographing device/terminal device, recording medium, computer memory, read-only memory (ROM, Read-Only Memory), random access memory (RAM, RandomAccess Memory), electrical carrier signal, telecommunication signal, and software distribution medium. For example, U disk, mobile hard disk, disk or CD, etc. In some jurisdictions, under legislation and patent practice, computer readable media may not be electrical carrier signals and telecommunications signals.

In the foregoing embodiments, the description of each embodiment has its own emphasis. For parts that are not described or described in detail in a certain embodiment, reference may be made to the relevant descriptions of other embodiments.

Those of ordinary skill in the art can realize that the units and algorithm steps of each example described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. Skilled artisans may implement the described functionality using different methods for each particular application, but such implementations should not be considered beyond the scope of this application.

In the embodiments provided in this application, it should be understood that the disclosed apparatus/network device and method may be implemented in other manners. For example, the apparatus/network device embodiments described above are only illustrative. For example, the division of the modules or units is only a logical function division. In actual implementation, there may be other division methods, such as multiple units. Or components may be combined or may be integrated into another system, or some features may be omitted, or not implemented. On the other hand, the shown or discussed mutual coupling or direct coupling or communication connection may be through some interfaces, indirect coupling or communication connection of devices or units, and may be in electrical, mechanical or other forms.

The units described as separate components may or may not be physically separated, and components displayed as units may or may not be physical units, that is, may be located in one place, or may be distributed to multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution in this embodiment.

The above-mentioned embodiments are only used to illustrate the technical solutions of the present application, but not to limit them; although the present application has been described in detail with reference to the above-mentioned embodiments, those of ordinary skill in the art should understand that: it can still be used for the above-mentioned implementations. The technical solutions described in the examples are modified, or some technical features thereof are equivalently replaced; and these modifications or replacements do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions in the embodiments of the application, and should be included in the within the scope of protection of this application.

Claims (10)

1. A method for testing a database structure, the method comprising:

the method comprises the steps of obtaining a regular expression to be detected in front-end codes, and converting the regular expression which accords with a front-end code language rule into first database data which accords with a structured query language rule, wherein the first database data comprises first database fields and first data attributes corresponding to the first database fields;

extracting all second database fields matched with the first database fields and second data attributes corresponding to each second database field from a preset database;

and comparing the first database data with each group of second database data to obtain a test result, wherein each group of second database data comprises a second database field and a second data attribute corresponding to the second database field.

2. The database structure testing method of claim 1, wherein said converting the regularization expression that conforms to front end code language rules to first database data that conforms to structured query language rules comprises:

acquiring a preset mapping relation between the front-end code language rule and the back-end code language rule, and converting the regular expression into back-end data which accords with the back-end code language rule according to the preset mapping relation, wherein the back-end data comprises at least one back-end code field and third data attributes corresponding to each back-end code field;

for each back-end code field, converting the back-end code field into a first database field conforming to the structured query language rule, and setting a first data attribute corresponding to the first database field as a third data attribute corresponding to the back-end code field.

3. The database structure testing method of claim 2, wherein said transforming said regular expression into backend data according to said preset mapping relationship, said backend data conforming to said backend code language rules, comprises:

identifying a back-end code function corresponding to the regular expression according to the preset mapping relation;

and extracting the back-end code field and a third data attribute corresponding to the back-end code field from the back-end code function according to the definition rule of the back-end code function to obtain the back-end data.

4. The method for testing a database structure according to claim 2, wherein the comparing the first database data with each group of second database data to obtain the test result comprises:

for each first database field, searching a second database field identical to the first database field in each group of second database data;

if a second database field identical to the first database field is not found in each group of second database data, generating a first abnormal result, wherein the first abnormal result is used for indicating that no second database field identical to the first database field exists in the second database data;

if a second database field identical to the first database field is found in each group of second database data, generating a test result according to a first set and a second set, wherein the first set is a set of first data attributes corresponding to the first database field, and the second set is a set of second data attributes corresponding to the second database field identical to the first database field.

5. The database structure testing method of claim 4, wherein generating test results from the first set and the second set comprises:

if the first set is the same as the second set, generating a normal result;

if the first set and the second set are not intersected, generating a second abnormal result, wherein the second abnormal result is used for prompting the user to test again;

if the first set really comprises the second set, generating a third exception result, wherein the third exception result is used for prompting a user to delete a first data attribute which does not belong to the second set in the first set;

and if the second set really comprises the first set, generating a fourth abnormal result, wherein the fourth abnormal result is used for prompting a user to add a second data attribute which does not belong to the first set in the second set into the first set.

6. The database structure testing method of claim 2, wherein the method further comprises:

acquiring a plurality of groups of training samples, wherein each group of training samples comprises a regular expression and a back-end code function corresponding to the regular expression;

and training a preset neural network by using the plurality of groups of training samples to obtain the trained neural network, and taking the trained neural network as the preset mapping relation.

7. The database structure testing method of claim 6, wherein the training of the predetermined neural network using the plurality of sets of training samples comprises:

for each group of training samples, dividing the regular expression in the training samples into at least one speech element according to a grammatical structure, and taking the speech element as the input of the neural network.

8. A database structure testing apparatus, comprising:

the system comprises an acquisition unit, a processing unit and a processing unit, wherein the acquisition unit is used for acquiring a regular expression to be detected in front-end codes and converting the regular expression conforming to a language rule of the front-end codes into first database data conforming to a structured query language rule, and the first database data comprises first database fields and first data attributes corresponding to the first database fields;

the extraction unit is used for extracting all second database fields matched with the first database fields and second data attributes corresponding to each second database field from a preset database;

and the test unit is used for comparing the first database data with each group of second database data to obtain a test result, wherein each group of second database data comprises a second database field and a second data attribute corresponding to the second database field.

9. A terminal device comprising a memory, a processor and a computer program stored in the memory and executable on the processor, characterized in that the processor implements the method according to any of claims 1 to 7 when executing the computer program.

10. A computer-readable storage medium, in which a computer program is stored which, when being executed by a processor, carries out the method according to any one of claims 1 to 7.

Images